In Biased Nonce Sense: Lattice Attacks against. Weak ECDSA Signatures in Cryptocurrencies Joachim Breitner and Nadia Heninger use a lattice based algorithm to recover private keys from signatures in the Bitcoin chain that were produced by insecure signers that generated biased nonces.
One large category of insecure signature that they discovered were 5,863 signatures between July 26, 2014 and June 1st, 2015 that were used in multisignature scripts where the nonces were only 64-bits in size. In the paper when a single key was used multiple times to sign multiple messages (which could be multiple inputs on a single transaction) with a small difference between the nonces their algorithim was able to determine the actual nonces used and the private keys with high probability.
Using a small nonce in multiple signatures is just an especially simple case of having a small difference. Small nonces could also be attacked with simpler brute force search approaches without requiring multiple signatures but the paper's approach was much faster than brute force. Their approach was also able to attack a number of 110 - 160 bit nonces which were used, a range that would have made a brute force search less realistic.
The authors were unaware of the origin of the 64-bit nonces but "hypothesize that this may be a faulty implementation intended for multifactor security, such as a hardware token".
What do we know about the actual origin of these signatures?
Based on the time-frame and my impression of the capabilities of the various groups developing wallet software during that period my initial guess was that the Bitpay copay software might be the source of these signatures. Copay is a multi-signature wallet which was initially released around that time.
[If there exists some tool to go grab all of the dependencies of a JS application as of some date that would have been super useful.]
return new bignum(SecureRandom.getRandomBuffer(8));
This code chooses an 8-byte (64-bit) nonce. I'm unclear as to how exactly this mistake came about-- sending 32 to a function that took bits as a size argument, for example, would have made sense--, but however it happened it wasn't caught in review and appears to have been shipped.
The vulnerability was subsequently fixed but weak signatures continued being created for some time. Because Bitpay's bitcore was promoted as an all purpose Bitcoin library it's possible that other software than copay had adopted it.
I'm unable to find any announcement of or discussion about this vulnerability other than the fix in the repository.
Though I haven't carefully analyzed it, I noticed that prior to switching out the code that codebase previously used "bitcoin-js" which-- at least in some versions-- used a weak random number generator due to a review evading subtle type error so it may well be the case that the error introducing change simply changed the software from one form of weakness to another.
It's also possible that although this software had exactly the right vulnerability introduced at the right time that it was coincidental and the bad signatures found in the paper were created by some other implementation.
I think the research and the relevant code make for a fine example of how difficult it is to get these things wrong, how even small errors can result in total security breaks, and that the mere fact that something is open source does not automatically ensure that it has received adequate review.