Topic: The biggest secret of bitcoin (Read 4291 times)

not i havent reported it to core developers. and thanks bitcoincountry. are you a core developer on bitcoin? BitcoinCountry.

At the momment i developed for the stockmarket (in order to make money so that have enough time to make my projects done decentralized exchange and my coin). At the momment is all websites offline of me. Very sorry for that but the problem is iam only a one dev. and not a developer team as coinffeeine etc. I do my best bitcoincountry but if you want write me a message and i can help you so good i can

Well found. bitcrystal, did you report your finding to the core developers? We need good bitcoin supporters like you.

I think the problem starts when nHeight rolls over and becomes negative. This leads to a negative value of the int halving variable. A negative halving variable triggers undefined behaviour of the the shift operation. Using the bitcoin constant values and a system with 32bit int values, this bug is triggered in about 40000 years.

right but in arith_256.cpp is also this bugg this meaning that all 256 bits version of uint256 have also this bugg. Thats mean if a hacker or anyway can find a exploit to use this problem. Clearly that no software is bugg free and a good tricky hacker/genius find always a bugg to exploit software

i have tested your statement its all right.

But if you use -64 then the bugg is ever worked

and because CAmount is signed thats meaning its possible to make this value to < 0

#include
#include

using namespace std;
typedef signed long long int64_t;
typedef int64_t CAmount;
static const CAmount COIN = 100000000;
static const CAmount CENT = 1000000;

typedef void (*func)();

template
class base_uint
{
protected:
    enum { WIDTH=BITS/32 };
    unsigned int pn[WIDTH];
public:

    base_uint()
    {
        for (int i = 0; i < WIDTH; i++)
            pn = 0xFFFFFFFF;
        printf("cool\n");
    }
    
    func e(func x)
    {
        return x;
    }
    
     base_uint(base_uint& t)
    {
        for (int i = 0; i < WIDTH; i++)
            pn = t.pn;
        printf("cool\n");
    }
    
    const base_uint operator~() const
    {
        base_uint ret;
        for (int i = 0; i < WIDTH; i++)
            ret.pn = ~pn;
        return ret;
    }
    
    base_uint(const base_uint& b)
    {
        for (int i = 0; i < WIDTH; i++)
            pn = b.pn;
    }
    
    base_uint(unsigned long long b)
    {
        pn[0] = (unsigned int)b;
        pn[1] = (unsigned int)(b >> 32);
        for (int i = 2; i < WIDTH; i++)
            pn = 0;
    }
    
    base_uint& operator>>=(unsigned int shift);
};

template
base_uint& base_uint::operator>>=(unsigned int shift)
{
    base_uint a(*this);
    for (int i = 0; i < WIDTH; i++)
        pn = 0;
    printf("shift: %d\n",shift);
    int k = shift / 32;
    printf("k: %d\n",k);
    shift = shift % 32;
    printf("shift: %d\n",shift);
    for (int i = 0; i < WIDTH; i++) {
        if (i - k - 1 >= 0 && shift != 0)
        {
            pn[i - k - 1] |= (a.pn << (32 - shift));
            printf("pn[i-k-1]: %02x\n",pn[i-k-1]);
            printf("pn[%d-%d-%d]: %02x\n",i,k,1,pn[i-k-1]);
            printf("pn[%d]: %02x\n",i-k-1,pn[i-k-1]);
        }  
        if (i - k >= 0) {
            pn[i - k] |= (a.pn >> shift);
            printf("pn[i-k]: %02x\n",pn[i-k]);
            printf("pn[%d-%d]: %02x\n",i,k,pn[i-k]);
            printf("pn[%d]: %02x\n",i-k,pn[i-k]);
        }
    }
    return *this;
}

void tx()
{
     printf("alter\n");
}

int main()
{
   /* unsigned int e = 32;
    base_uint<256> t;
   // unsigned int t = 0xFFFFFFFF;
    t >>= e;
    //t.e(tx)();
    int ef = 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    int halvings = ef / 210000;
    printf("%02x\n",halvings);*/
    CAmount e = 25*COIN;
    e >>= -64;
    printf("%02x\n",e);
        system("pause");
    return 0;
}


here you can test it. thats meaning if you find a good exploit and have time you need only a option to make the number to < 0 and the bugg is worked again.

At this point in time you maybe need to find a computer which is able to run a more than 200 year old software. 

Oh, good to know. I'll mark that year on my calendar so that I don't forget to be bothered when it happens.

Onkel Paul

In the older version of the function there was a bug that results in undefined behaviour when the shift value is larger than 63. The shift expression CAmount is a 64bit integer. There is no problem using a shift value of 32. This change is a hard fork. That means some old clients might split the blockchain in about 200 years from now if they are still in use at that point in time.

that here is a old function of the bitcoin src . Is fixxed in the new version


int64 static GetBlockValue(int nHeight, int64 nFees)
{
    int64 nSubsidy = 50 * COIN;

    // Subsidy is cut in half every 210000 blocks, which will occur approximately every 4 years
    nSubsidy >>= (nHeight / 210000);

    return nSubsidy + nFees;
}


what it happen if nheight /210000 = 31  or 63. Right the result is nSubsidy = 1. But if the number is higher then the result is not 0 . Then through the overflow the result is 0xFFFFFFFF . And even on the newest version you can watch this phenomen. Thats meaning if hacker find overflows the limit protection is breaked. And even in parts of source code you can find overflow exploits. And all old bitcoin clients can still produce reward after the limit is reached. Thats meaning that if anybody say bitcoin is safe limit is worked. The have not research the source code of bitcoin.

Even the newest version of bitcoin is not bug free here a test example
i have tested this .

shift: 31
k: 0
shift: 31
pn[i-k]: 01
pn[0-0]: 01
pn[0]: 01
pn[i-k-1]: ffffffff
pn[1-0-1]: ffffffff
pn[0]: ffffffff
pn[i-k]: 01
pn[1-0]: 01
pn[1]: 01
pn[i-k-1]: ffffffff
pn[2-0-1]: ffffffff
pn[1]: ffffffff
pn[i-k]: 01
pn[2-0]: 01
pn[2]: 01
pn[i-k-1]: ffffffff
pn[3-0-1]: ffffffff
pn[2]: ffffffff
pn[i-k]: 01
pn[3-0]: 01
pn[3]: 01
pn[i-k-1]: ffffffff
pn[4-0-1]: ffffffff
pn[3]: ffffffff
pn[i-k]: 01
pn[4-0]: 01
pn[4]: 01
pn[i-k-1]: ffffffff
pn[5-0-1]: ffffffff
pn[4]: ffffffff
pn[i-k]: 01
pn[5-0]: 01
pn[5]: 01
pn[i-k-1]: ffffffff
pn[6-0-1]: ffffffff
pn[5]: ffffffff
pn[i-k]: 01
pn[6-0]: 01
pn[6]: 01
pn[i-k-1]: ffffffff
pn[7-0-1]: ffffffff
pn[6]: ffffffff
pn[i-k]: 01
pn[7-0]: 01
pn[7]: 01

so ok if the shift is 32 then the result is not 01 . the result is momment

shift: 32
k: 1
shift: 0
pn[i-k]: ffffffff
pn[1-1]: ffffffff
pn[0]: ffffffff
pn[i-k]: ffffffff
pn[2-1]: ffffffff
pn[1]: ffffffff
pn[i-k]: ffffffff
pn[3-1]: ffffffff
pn[2]: ffffffff
pn[i-k]: ffffffff
pn[4-1]: ffffffff
pn[3]: ffffffff
pn[i-k]: ffffffff
pn[5-1]: ffffffff
pn[4]: ffffffff
pn[i-k]: ffffffff
pn[6-1]: ffffffff
pn[5]: ffffffff
pn[i-k]: ffffffff
pn[7-1]: ffffffff
pn[6]: ffffffff

Drücken Sie eine beliebige Taste . . .


0xFFFFFFF

here my test source code i have used the overloading operator function of the bitcoin source

#include
#include

using namespace std;

typedef void (*func)();

template
class base_uint
{
protected:
    enum { WIDTH=BITS/32 };
    unsigned int pn[WIDTH];
public:

    base_uint()
    {
        for (int i = 0; i < WIDTH; i++)
            pn = 0xFFFFFFFF;
        printf("cool\n");
    }
    
    func e(func x)
    {
        return x;
    }
    
     base_uint(base_uint& t)
    {
        for (int i = 0; i < WIDTH; i++)
            pn = t.pn;
        printf("cool\n");
    }
    
    const base_uint operator~() const
    {
        base_uint ret;
        for (int i = 0; i < WIDTH; i++)
            ret.pn = ~pn;
        return ret;
    }
    
    base_uint(const base_uint& b)
    {
        for (int i = 0; i < WIDTH; i++)
            pn = b.pn;
    }
    
    base_uint(unsigned long long b)
    {
        pn[0] = (unsigned int)b;
        pn[1] = (unsigned int)(b >> 32);
        for (int i = 2; i < WIDTH; i++)
            pn = 0;
    }
    
    base_uint& operator>>=(unsigned int shift);
};

template
base_uint& base_uint::operator>>=(unsigned int shift)
{
    base_uint a(*this);
    for (int i = 0; i < WIDTH; i++)
        pn = 0;
    printf("shift: %d\n",shift);
    int k = shift / 32;
    printf("k: %d\n",k);
    shift = shift % 32;
    printf("shift: %d\n",shift);
    for (int i = 0; i < WIDTH; i++) {
        if (i - k - 1 >= 0 && shift != 0)
        {
            pn[i - k - 1] |= (a.pn << (32 - shift));
            printf("pn[i-k-1]: %02x\n",pn[i-k-1]);
            printf("pn[%d-%d-%d]: %02x\n",i,k,1,pn[i-k-1]);
            printf("pn[%d]: %02x\n",i-k-1,pn[i-k-1]);
        }  
        if (i - k >= 0) {
            pn[i - k] |= (a.pn >> shift);
            printf("pn[i-k]: %02x\n",pn[i-k]);
            printf("pn[%d-%d]: %02x\n",i,k,pn[i-k]);
            printf("pn[%d]: %02x\n",i-k,pn[i-k]);
        }
    }
    return *this;
}

void tx()
{
     printf("alter\n");
}

int main()
{
    unsigned int e = 32;
    base_uint<256> t;
   // unsigned int t = 0xFFFFFFFF;
    t >>= e;
    //t.e(tx)();
    int ef = 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    ef += 999999999;
    int halvings = ef / 210000;
    printf("%02x\n",halvings);
        system("pause");
    return 0;
}






pn[6-1]: ffffff
pn[5]: ffffff
pn[i-k-1]: ffffffff
pn[7-1-1]: ffffffff
pn[5]: ffffffff
pn[i-k]: ffffff
pn[7-1]: ffffff
pn[6]: ffffff
ffffdcf1
Drücken Sie eine beliebige Taste . . .


    int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
   // Force block reward to zero when right shift is undefined.
   if (halvings >= 64)

This line fixxed the bugg. But if anybody have older clients as 0.9.2 then the process is repeated and the 21 million limit is breaked. Or if the shift is 32 then is repeated the process. i have tested it.
    CAmount nSubsidy = 50 * COIN;
    // Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
    nSubsidy >>= halvings; If halvings is 32 then the shift is undefined and a overflow is created.
    return nSubsidy;
}

Thats meaning if the shift is 32 what is not higher as 64 then the result is 50 coins. If my calculation is not correct please corrigate me.

Korrekt!

bitcrystal, das Problem ist nicht die Sprache, sondern deine Argumentation.
- Ob ein Developer irgendeiner Altcoin dort das Mining von mehr als 21 Millionen ermöglicht, hat für das Bitcoin-Mining überhaupt keine Bedeutung. Lass also bitte Altcoins einfach aus der Argumentation raus, sie verwirren nur.
- Die zitierte Codestelle, die den maximalen Umfang einer Transaktion prüft (txout.nValue > MAX_MONEY), ist redundant, weil es sowieso nie Inputs in der Höhe geben kann geben kann. Diese Prüfung ist aber kein Argument dafür, dass es insgesamt mehr Bitcoins geben könnte.
- Auch die Tatsache, dass der Mining-Reward in einem Block nicht nur aus den frischen Bitcoins des Blocks besteht, sondern zusätzlich Transaction-Fees enthält, ändert nichts daran, dass die maximale Summe an Bitcoins, die jemals existieren werden, gleich 20999999.9769 ist. Transaction-Fees erhöhen nicht das Gesamtvolumen von Bitcoins, sondern verteilen nur ein bisschen um. Wenn einmal alle 20999999.9769 Bitcoins erzeugt worden sind, werden natürlich durch die Transaction-Fees keine neuen Bitcoins erzeugt, sondern nur bestehende Bitcoins umverteilt von den Benutzern zu den Minern.

Onkel Paul

Source: http://bitcoin.stackexchange.com/questions/161/how-many-bitcoins-will-there-eventually-be

OP please stop before you make an even greater fool of yourself. The 21 million BTC is not hardcoded as a number in the source code, it is the (approximate) total amount mineable given by the mining rewards halving (until it is negligible).

what is worring me, is that he is not trolling, i think he is serious on the matter

it's appear that he have a lot of confusion, due to altcoin and other stuff related to crypto in general

please stop that bullshit.

there will never be more than 21million coins.
it is possible to mine more than 21million coins (because fees are mined also): but again: THERE WONT EVER BE MORE THAN 21 MILLION COINS IN CIRCULATION (probably way less because of lost privkeys)

btw there are many others (including me) who can read code... and we understand the block subsidy function.

IMHO i dont think you are able to develop a trustable decentralized exchange if you arent even able to understand bitcoin in that regard (thats one of the easy parts).

i am german too: thats no excuse (my english sucks too.. )

its true that  i have not a good english grammar. But the reason is iam come from germany not from england. And thats not meaning i dont have the knowledge over coins. And iam aware of this formula. But the trueness is bitcoin is unlimited and thats true. It existed not a part of source code that blocks the option that you can mine more as 21 million coins. its a secret because many guys for example the developer of fourtytwocoin uses this detail to make more profit for his coin.  Because many guys have not the knowledge and the experience through tests. I am developing currently on a final version of my decentralized exchange. And in order to create a real decentralized exchange. I have hard works on bitcoin protocol and common on developing and tests. What i want to say is that the formula is still not a provement that the bitcoin have a limit. and i understand the subsidy function and iam not a troll when i say that the process of mining is unlimited. Thats means automatically you can mine infinitely and because the difficulty is not a problem when you use a quantum computer. And i bet that nobody here have the knowledge as bitcoin really works. And the reason why bitcoin is worked is the Hash cash algorithm of Adam Black. my english is not the best but but you can do a favor rather than to deny everything and criticize times think what I really want to say so and why I want to say it. The sources that Mr Satoshi a mathematics Proffessor is oh my god. There are far too many rumors in this world. The Troll feed as funny. I only want a favor because creators lie to you because owners exploited the max coins detail to rise the value of coins. And I know the subsidy function and much more you of which you don't have heard anything in 10 years. My purpose is to you to face honestly. As I soon open a decentralized market its important for me that the users of this forum know that honestly its more important for as money.

Full stop 

But I bet that OP lost a lot more of his brain cells as a side effect of whatever he was drinking/smoking when he had this brilliant idea.

Onkel Paul

i just lost several of my precious braincells reading OP (and his grammar wasn't the only reason)  

Maybe you should check and understand the GetBlockSubsidy() function...

/** The maximum allowed size for a serialized block, in bytes (network rule) */

FOR A BLOCK NOT FOR ALL BLOCKS

static const unsigned int MAX_BLOCK_SIZE = 1000000;
/** The maximum allowed number of signature check operations
static const CAmount MAX_MONEY = 21000000 * COIN;


bool CheckTransaction(const CTransaction& tx, CValidationState &state)
{
    // Basic checks that don't depend on any context
    if (tx.vin.empty())
        return state.DoS(10, false, REJECT_INVALID, "bad-txns-vin-empty");
    if (tx.vout.empty())
        return state.DoS(10, false, REJECT_INVALID, "bad-txns-vout-empty");
    // Size limits
    if (::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION) > MAX_BLOCK_SIZE)
        return state.DoS(100, false, REJECT_INVALID, "bad-txns-oversize");

    // Check for negative or overflow output values
    CAmount nValueOut = 0;
    BOOST_FOREACH(const CTxOut& txout, tx.vout)
    {
        if (txout.nValue < 0)
            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-negative");
       if (txout.nValue > MAX_MONEY)
            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-toolarge");
        nValueOut += txout.nValue;
        if (!MoneyRange(nValueOut))
            return state.DoS(100, false, REJECT_INVALID, "bad-txns-txouttotal-toolarge");
    }

THIS LIMITS IS VALID FOR A TRANSACTION NOT FOR ALL TRANSACTIONS. THATS MEANING BITCOIN IS NOT LIMITED ONLY THE BLOCK HAVE LIMITED SIZES NOT THE PROTOCOL.


source
https://github.com/bitcoin/bitcoin/search?utf8=%E2%9C%93&q=MAX_MONEY&type=Code


a genius you do not recognize at the conclusion. But on his abilities. And someone who is studying does not mean that he must be a genius.