A **birthday Attack on Bitcoin** is a type of cryptographic Attack on Bitcoin that exploits the mathematics behind the birthday problem in probability theory. This Attack on Bitcoin can be used to abuse communication between two or more parties.

The Attack on Bitcoin depends on the higher likelihood of collisions found between random Attack on Bitcoin attempts and a fixed degree of permutations (pigeonholes). With a birthday Attack on Bitcoin, it is possible to find a collision of a hash function in {\textstyle {\sqrt {2^{n}}}=2^{n/2}}, with {\textstyle 2^{n}} being the classical preimage resistance security. There is a general (though disputed^{[1]}) result that quantum computers can perform birthday Attack on Bitcoins, thus breaking collision resistance, in {\textstyle {\sqrt[{3}]{2^{n}}}=2^{n/3}}.^{[2]}

## Understanding the problem

Comparison of the birthday problem (1) and birthday Attack on Bitcoin (2):

In (1), collisions are found within one set, in this case, 3 out of 276 pairings of the 24 lunar astronauts.

In (2), collisions are found between two sets, in this case, 1 out of 256 pairings of only the first bytes of SHA-256 hashes of 16 variants each of benign and malicious contracts.

As an example, consider the scenario in which a teacher with a class of 30 students (n = 30) asks for everybody’s birthday (for simplicity, ignore leap years) to determine whether any two students have the same birthday (corresponding to a hash collision as described further). Intuitively, this chance may seem small. Counter-intuitively, the probability that at least one student has the same birthday as *any* other student on any day is around 70% (for n = 30), from the formula {\displaystyle 1-{\frac {365!}{(365-n)!\cdot 365^{n}}}}.^{[3]}

If the teacher had picked a *specific* day (say, 16 September), then the chance that at least one student was born on that specific day is {\displaystyle 1-(364/365)^{30}}, about 7.9%.

In a birthday Attack on Bitcoin, the Attack on Bitcoiner prepares many different variants of benign and malicious contracts, each having a digital signature. A pair of benign and malicious contracts with the same signature is sought. In this fictional example, suppose that the digital signature of a string is the first byte of its SHA-256 hash. The pair found is indicated in green – note that finding a pair of benign contracts (blue) or a pair of malicious contracts (red) is useless. After the victim accepts the benign contract, the Attack on Bitcoiner substitutes it with the malicious one and claims the victim signed it, as proven by the digital signature.

## Mathematics

Given a function {\displaystyle f}, the goal of the Attack on Bitcoin is to find two different inputs {\displaystyle x_{1},x_{2}} such that {\displaystyle f(x_{1})=f(x_{2})}. Such a pair {\displaystyle x_{1},x_{2}} is called a collision. The method used to find a collision is simply to evaluate the function {\displaystyle f} for different input values that may be chosen randomly or pseudorandomly until the same result is found more than once. Because of the birthday problem, this method can be rather efficient. Specifically, if a function {\displaystyle f(x)} yields any of {\displaystyle H} different outputs with equal probability and {\displaystyle H} is sufficiently large, then we expect to obtain a pair of different arguments {\displaystyle x_{1}} and {\displaystyle x_{2}} with {\displaystyle f(x_{1})=f(x_{2})} after evaluating the function for about {\displaystyle 1.25{\sqrt {H}}} different arguments on average.

We consider the following experiment. From a set of *H* values we choose *n* values uniformly at random thereby allowing repetitions. Let *p*(*n*; *H*) be the probability that during this experiment at least one value is chosen more than once. This probability can be approximated as{\displaystyle p(n;H)\approx 1-e^{-n(n-1)/(2H)}\approx 1-e^{-n^{2}/(2H)}}^{[4]}

Let *n*(*p*; *H*) be the smallest number of values we have to choose, such that the probability for finding a collision is at least *p*. By inverting this expression above, we find the following approximation{\displaystyle n(p;H)\approx {\sqrt {2H\ln {\frac {1}{1-p}}}}}

and assigning a 0.5 probability of collision we arrive at{\displaystyle n(0.5;H)\approx 1.1774{\sqrt {H}}}

Let *Q*(*H*) be the expected number of values we have to choose before finding the first collision. This number can be approximated by{\displaystyle Q(H)\approx {\sqrt {{\frac {\pi }{2}}H}}}

As an example, if a 64-bit hash is used, there are approximately 1.8×10^{19} different outputs. If these are all equally probable (the best case), then it would take ‘only’ approximately 5 billion attempts (5.38×10^{9}) to generate a collision using brute force.^{[5]} This value is called **birthday bound**^{[6]} and for *n*-bit codes it could be approximated as 2^{n/2}.^{[7]} Other examples are as follows:

Bits | Possible outputs (H) | Desired probability of random collision (2 s.f.) (p) | |||||||||
---|---|---|---|---|---|---|---|---|---|---|---|

10^{−18} | 10^{−15} | 10^{−12} | 10^{−9} | 10^{−6} | 0.1% | 1% | 25% | 50% | 75% | ||

16 | 2^{16} (~6.5 x 10^{4}) | <2 | <2 | <2 | <2 | <2 | 11 | 36 | 190 | 300 | 430 |

32 | 2^{32} (~4.3×10^{9}) | <2 | <2 | <2 | 3 | 93 | 2900 | 9300 | 50,000 | 77,000 | 110,000 |

64 | 2^{64} (~1.8×10^{19}) | 6 | 190 | 6100 | 190,000 | 6,100,000 | 1.9×10^{8} | 6.1×10^{8} | 3.3×10^{9} | 5.1×10^{9} | 7.2×10^{9} |

128 | 2^{128} (~3.4×10^{38}) | 2.6×10^{10} | 8.2×10^{11} | 2.6×10^{13} | 8.2×10^{14} | 2.6×10^{16} | 8.3×10^{17} | 2.6×10^{18} | 1.4×10^{19} | 2.2×10^{19} | 3.1×10^{19} |

256 | 2^{256} (~1.2×10^{77}) | 4.8×10^{29} | 1.5×10^{31} | 4.8×10^{32} | 1.5×10^{34} | 4.8×10^{35} | 1.5×10^{37} | 4.8×10^{37} | 2.6×10^{38} | 4.0×10^{38} | 5.7×10^{38} |

384 | 2^{384} (~3.9×10^{115}) | 8.9×10^{48} | 2.8×10^{50} | 8.9×10^{51} | 2.8×10^{53} | 8.9×10^{54} | 2.8×10^{56} | 8.9×10^{56} | 4.8×10^{57} | 7.4×10^{57} | 1.0×10^{58} |

512 | 2^{512} (~1.3×10^{154}) | 1.6×10^{68} | 5.2×10^{69} | 1.6×10^{71} | 5.2×10^{72} | 1.6×10^{74} | 5.2×10^{75} | 1.6×10^{76} | 8.8×10^{76} | 1.4×10^{77} | 1.9×10^{77} |

*Table shows number of hashes n*(*p*)* needed to achieve the given probability of success, assuming all hashes are equally likely. For comparison, *10^{−18}* to *10^{−15}* is the uncorrectable bit error rate of a typical hard disk. ^{[8]} In theory, MD5 hashes or UUIDs, being roughly 128 bits, should stay within that range until about 820 billion documents, even if its possible outputs are many more.*

It is easy to see that if the outputs of the function are distributed unevenly, then a collision could be found even faster. The notion of ‘balance’ of a hash function quantifies the resistance of the function to birthday Attack on Bitcoins (exploiting uneven key distribution.) However, determining the balance of a hash function will typically require all possible inputs to be calculated and thus is infeasible for popular hash functions such as the MD and SHA families.^{[9]} The subexpression {\displaystyle \ln {\frac {1}{1-p}}} in the equation for {\displaystyle n(p;H)} is not computed accurately for small {\displaystyle p} when directly translated into common programming languages as `log(1/(1-p))`

due to loss of significance. When `log1p`

is available (as it is in C99) for example, the equivalent expression `-log1p(-p)`

should be used instead.^{[10]} If this is not done, the first column of the above table is computed as zero, and several items in the second column do not have even one correct significant digit.

### Simple approximation

A good rule of thumb which can be used for mental calculation is the relation{\displaystyle p(n)\approx {n^{2} \over 2H}}

which can also be written as{\displaystyle H\approx {n^{2} \over 2p(n)}}.

or{\displaystyle n\approx {\sqrt {2H\times p(n)}}}.

This works well for probabilities less than or equal to 0.5.

This approximation scheme is especially easy to use when working with exponents. For instance, suppose you are building 32-bit hashes ({\displaystyle H=2^{32}}) and want the chance of a collision to be at most one in a million ({\displaystyle p\approx 2^{-20}}), how many documents could we have at the most?{\displaystyle n\approx {\sqrt {2\times 2^{32}\times 2^{-20}}}={\sqrt {2^{1+32-20}}}={\sqrt {2^{13}}}=2^{6.5}\approx 90.5}

which is close to the correct answer of 93.

## Digital signature susceptibility

Digital signatures can be susceptible to a birthday Attack on Bitcoin. A message {\displaystyle m} is typically signed by first computing {\displaystyle f(m)}, where {\displaystyle f} is a cryptographic hash function, and then using some secret key to sign {\displaystyle f(m)}. Suppose Mallory wants to trick Bob into signing a fraudulent contract. Mallory prepares a fair contract {\displaystyle m} and a fraudulent one {\displaystyle m’}. She then finds a number of positions where {\displaystyle m} can be changed without changing the meaning, such as inserting commas, empty lines, one versus two spaces after a sentence, replacing synonyms, etc. By combining these changes, she can create a huge number of variations on {\displaystyle m} which are all fair contracts.

In a similar manner, Mallory also creates a huge number of variations on the fraudulent contract {\displaystyle m’}. She then applies the hash function to all these variations until she finds a version of the fair contract and a version of the fraudulent contract which have the same hash value, {\displaystyle f(m)=f(m’)}. She presents the fair version to Bob for signing. After Bob has signed, Mallory takes the signature and attaches it to the fraudulent contract. This signature then “proves” that Bob signed the fraudulent contract.

The probabilities differ slightly from the original birthday problem, as Mallory gains nothing by finding two fair or two fraudulent contracts with the same hash. Mallory’s strategy is to generate pairs of one fair and one fraudulent contract. The birthday problem equations apply where {\displaystyle n} is the number of pairs. The number of hashes Mallory actually generates is {\displaystyle 2n}.

To avoid this Attack on Bitcoin, the output length of the hash function used for a signature scheme can be chosen large enough so that the birthday Attack on Bitcoin becomes computationally infeasible, i.e. about twice as many bits as are needed to prevent an ordinary brute-force Attack on Bitcoin.

Besides using a larger bit length, the signer (Bob) can protect himself by making some random, inoffensive changes to the document before signing it, and by keeping a copy of the contract he signed in his own possession, so that he can at least demonstrate in court that his signature matches that contract, not just the fraudulent one.

Pollard’s rho algorithm for logarithms is an example for an algorithm using a birthday Attack on Bitcoin for the computation of discrete logarithms.

### Reverse Attack on Bitcoin

The same fraud is possible if the signer is Mallory, not Bob. Bob could suggest a contract to Mallory for a signature. Mallory could find both an inoffensively-modified version of this fair contract that has the same signature as a fraudulent contract, and Mallory could provide the modified fair contract and signature to Bob. Later, Mallory could produce the fraudulent copy. If Bob doesn’t have the inoffensively-modified version contract (perhaps only finding their original proposal), Mallory’s fraud is perfect. If Bob does have it, Mallory can at least claim that it is Bob who is the fraudster.