All Bitcoin Wallets On Android Vulnerable To Theft

judgecorp writes "Bitcoin users have been warned that storing them in a wallet app on Android is insecure, A weakness in Android's random number generator means its random numbers may not be so random, giving attackers a chance of breaking into the wallet. those with Bitcoins have been advised to put them elsewhere, by bitcoin.org"

Comments

How can an OS have such a fundamental problem?

[Karganeth]

It's ridiculous in this day and age that an OS can fail to make random numbers properly. That's one of the most basic operations. How lazy/incompetent are the Google programmers?

Re:How can an OS have such a fundamental problem?

[buchner.johannes]

It's a pity. Bitcoin would be a powerful payment method on mobile devices, for small amenities (e.g. coffee).

Re:How can an OS have such a fundamental problem?

[gweihir]

It is both a solved problem and an ignored problem. I find that I have to explain the risks of not using proper random numbers for anything cryptographic time and again even to customers with experience in using cryptography. I blame the CS and programmer education, which is still badly broken when it comes to security.

Re:How can an OS have such a fundamental problem?

[_merlin]

Not really - transaction processing takes far to long because the network has to agree on it.

Re:How can an OS have such a fundamental problem?

[buchner.johannes]

Not really - transaction processing takes far to long because the network has to agree on it.

How long does it take these days?

If the store uses what they would pay as fees to credit card companies as Bitcoin safety, it would probably still pay off. Also, only few people will not pay, especially not returning customers.

Re:How can an OS have such a fundamental problem?

[LordLucless]

Which is why such methods are called PRNGs - Pseudo-Random Number Generators

Re:How can an OS have such a fundamental problem?

[MickLinux]

Question: would it be correct or incorrect to...

suppose you take your best pseudo-random generated number, and xoror seed it with a word made by stringer together the second-lowest bit each from the temperature gauge, the gps-x the gps-y ,the compass, the ping time, and so on?

Would that #increase# or #decrease# the entropy on the random number generator?

Re:How can an OS have such a fundamental problem?

[bondsbw]

This doesn't mean you throw in the towel. There are bad PRNG algorithms and better PRNG algorithms, and it's worth using better ones.

Plus, these devices have so many sensors that finding a fairly complex and truly random seed isn't all that difficult. Then throw the seed into a good PRNG and it becomes practically impossible to decode the seed values and, thus, produce any mechanism for finding patterns in the seed data.

Re:How can an OS have such a fundamental problem?

[Saint Gerbil]

Number confirmed to be random as certified by a dice roll.

Re:How can an OS have such a fundamental problem?

[DanTheManMS]

I imagine that some sort of store-credit type thing would work better for this type of scenario. For instance, while credit cards give you a real-time accepted/denied decision, it still takes days for the transaction to fully process on the back-end. I imagine that Starbucks is a lot more certain that transactions will go through when paid with one of their pre-paid store cards.

It's a bit more inconvenient, I will admit. But it makes commonplace Bitcoin transactions a lot more realistic. And the concept isn't unheard of, actually. When the Bitcoin protocol adapted to make microtransactions unfeasible (as that was never truly the goal of Bitcoin, and microtransactions spam up the blockchain a lot) it basically broke all of the "daily bitcoin faucet" type websites that could no longer be profitable. In response, a third-party website popped up that stores records of your "free daily bitcoin" microtransactions, and outputs an actual Bitcoin payment once it's reached the threshold that makes it profitable again. I think I explained that poorly, for which you must forgive me. It's early on Monday morning after all.

Long story short, while this is a setback, I don't view this exploit as a game-changer, not with the momentum that Bitcoin has behind it right now.

Re: How can an OS have such a fundamental problem?

[Anonymous Coward]

"The generation of random numbers is too important to be left to chance." -- Robert R. Coveyou

Re:How can an OS have such a fundamental problem?

[Anonymous Coward]

Question: would it be correct or incorrect to...

suppose you take your best pseudo-random generated number, and xoror seed it with a word made by stringer together the second-lowest bit each from the temperature gauge, the gps-x the gps-y ,the compass, the ping time, and so on?

Would that #increase# or #decrease# the entropy on the random number generator?

It would increase it only if you aren't showing a temp of 32F and a GPS of 00N/00W heading of 0, and a ping of 0 and so on. Seeding from things that arent *surely* good and random is not a smart idea. Why didn't you mention the accelerometers? A program with a little sense to turn on the accels, ask you to shake the phone up a bit, and validate that the results aren't all the same should yield enough to do a good unpredictable RNG seed.

Re:How can an OS have such a fundamental problem?

[Joce640k]

The problem isn't doing it, the problem is in getting the "random needs effort" message though thick developer's skulls.

(Same as most other cryptographic problems, eg. correctly implementing AES isn't what makes your code secure, it's only the very first step...)

Re:How can an OS have such a fundamental problem?

[TheCarp]

Depends pm what you mean. Any time there are less than, I believe the number is 5400 blocks in two weeks, that the hardness adjusts to attempt to maintain, or about one block every 10 minutes. Technically, if someone can present a valid transaction, you could accept it instantly and say bitcoin has no delay.

Technically the transaction isn't official till its in a block, but once its transmitted out to the network valid, its almost guaranteed to be in one within 10 minutes or so, and each block that buries it, solidifies it further.

What is accepted? Last I looked, the default client didn't consider a transaction accepted until several blocks AFTER it was accepted, so we are talking 20-30 minutes or so.

But.... you could accept bitcoins "instantly" (pretty quick anyway) if you have the most recent block chain, and are sure the transaction has been transmitted out to the public network. There are some small risks in terms of the possibility of accepting a transaction while the block chain is split and a competing transaction being inserted into the other chain, which then wins.... but.... if anyone really does make exploiting such a situation practical and profitable, countermeasures could be achieved pretty easily, it wouldn't be hard to use multiple nodes to watch for block chain splits and monitor what transactions are going out.

Have a few nodes that are not peers of eachother, one transmits the transaction, all the rest watch for it, and watch for splits/competing transactions, etc. I am sure somebody can come up with a pretty safe way to fast accept bitcoins if they haven't already.

Re:How can an OS have such a fundamental problem?

[radiumsoup]

There are workarounds to this already in use. Bitinstant is one that promises trusted "instant" transactions for bitcoin with specific vendors, although they're reworking their website right now. Others will follow. It'll be a matter of dealing with trusted big-name transaction clearinghouses that settle bitcoin transactions in real-time between their own customers while also transmitting to the network for inclusion in the chain later.

Re:How can an OS have such a fundamental problem?

[bill_mcgonigle]

There are bad PRNG algorithms and better PRNG algorithms, and it's worth using better ones. Plus, these devices have so many sensors that finding a fairly complex and truly random seed isn't all that difficult.

Great insight. I don't understand why linux still uses a known-weak /dev/[u]random when BSD and OSX have used a Yarrow-based PRNG for a decade, and there was even a patch for a Fortuna-based device in the -mm tree at one point.

One of the issues is people say, "just use EGD", but most people don't know about it, don't have it running, and software often uses egd only when /dev/random doesn't exist, if it can use it at all. Having two interfaces isn't the right approach. I can see an argument for leaving something like accelerometer-based entropy gathering in userspace, but as far as I know, there's not a socket setup in place where egd can feed data to /dev/random's pool.

Perhaps we need somebody to grab hold of this issue and drive it forward. Strong crypto is becoming more and more important by the week.

Re:How can an OS have such a fundamental problem?

[telchine]

It's ridiculous in this day and age that an OS can fail to make random numbers properly. That's one of the most basic operations. How lazy/incompetent are the Google programmers?

To be fair, aren't random numbers genuinely hard to produce with a computer?

I'd have thought that a mobile phone would be a great source of genuinely random data though. Surely tapping into a compass, an accelerometer or a camera could produce genuinely random input?

Re:How can an OS have such a fundamental problem?

[telchine]

Not really - transaction processing takes far to long because the network has to agree on it.

I dunno, in a cafe you usually pay after you've eaten. I'd assume the time it takes to drink a coffee would be ample time to have a bitcoin transaction approved.

Re:How can an OS have such a fundamental problem?

[killkillkill]

The effort to create a double spend is not free. For most transaction in day to day life the effort cost and chance involved would be more than the transaction itself, so not worth trying. A transaction propagates through the network pretty much instantly and they can be on their way with a cup of coffee/groceries with less risk than a credit card being charged back. And of course, if you're not paying to Visas rates for the transaction you can afford a bit more risk even if it were present. For a car, internet purchases, an overseas transfer or any large transfer were the risk exists for a profitable double spend; an hour is reasonable to wait for full confirmation of the network.

Re:How can an OS have such a fundamental problem?

[xaxa]

I'm not a cryptographer, but....

If your random seed really is random, then it's better. But your random source might not be able to provide enough numbers (how often is it sampling the environment?), and according to http://en.wikipedia.org/wiki/Hardware_random_number_generator it's best to constantly check if the numbers are still random.

"collisions" isn't the problem, it's repeating the sequence. (Ask people to draw random dots on paper and they'll often draw quite an even distribution. That's not random!)

There are also uses of random numbers outside cryptography.I came across this: http://en.wikipedia.org/wiki/Mersenne_twister which is good for some uses, but bad for cryptography.

Re: How can an OS have such a fundamental problem?

[Statecraftsman]

Just a few corrections. The targeted rate is 2016 blocks per 14 days. The default client allows you to spend incoming coins after one confirmation.

Re:How can an OS have such a fundamental problem?

[Anonymous Coward]

NO! You can not accept a transaction without it being in the blockchain, lest you enable the spender to double-spend. It doesn't take a split. The spender can just issue a different transaction on the same sources after you've accepted the transaction and before "your" transaction goes into the blockchain.

Re:How can an OS have such a fundamental problem?

[Tyler Eaves]

History suggests that you are using a very loose definition of "trusted".

Re:How can an OS have such a fundamental problem?

[serviscope_minor]

The problem isn't doing it, the problem is in getting the "random needs effort" message though thick developer's skulls.

You think that, but you have no idea the depths of perversity developers will go to to avoid learning the simple facts that you have internalised.

This developer clearly believed that random numbers do indeed need effort:

http://thedailywtf.com/Articles/Random-Stupidity.aspx

Re:How can an OS have such a fundamental problem?

[bondsbw]

It just seems better to use the random seed in the first place rather than throw it into some PRNG.

You're not incorrect, but it's more of an obfuscation technique. Even natural data that may seem random may be prone to patterns, and sensors all too often have flaws that are unnoticeable for their designed purpose but produce subtle patterns in what would be otherwise purely random data.

My thought is to combine as many flavors of this data as is reasonable, and put it all through cryptographic-strength PRNG to help protect the original seed value and thus the randomness of it. Increased algorithmic strength means you will need to rely on polling sensors less often, which will reduce the likelihood of guessing a new value based on any known device flaws.

Re:How can an OS have such a fundamental problem?

[tlhIngan]

It's ridiculous in this day and age that an OS can fail to make random numbers properly. That's one of the most basic operations. How lazy/incompetent are the Google programmers?

Especially since most SoCs used in Android actually have hardware cryptographic accellerators, and one feature of them was a hardware RNG.

Granted, hardware RNGs vary in quality, but most do a very decent job. Even several generations old CPUs have RNG instructions (Intel CPUs, for example - they've had RNGs built in since Core2 days I believe).

Re:How can an OS have such a fundamental problem?

[WaffleMonster]

The problem isn't doing it, the problem is in getting the "random needs effort" message though thick developer's skulls.

I'm sorry this is unacceptable and dangerous. Expecting developers to get this right is inviting platform failure the same way expecting developers to get SQL and HTML escaping right has earned PHP a certain reputation or expecting Android users to understand the repercussions of allowing n00b0wnrz flashlight app to run on their device has doomed millions of end users to ownage.

In 2013 random numbers should just work by default with no effort on the developers part either by an OS managed entropy pool (e.g. /dev/urandom) and by assist of hardware features (e.g. thermal noise)

(Same as most other cryptographic problems, eg. correctly implementing AES isn't what makes your code secure, it's only the very first step...)

Implementing AES? Understanding high level crypto libraries and not ever calling AES is what gives your code any chance of being secure. The second you call AES you have already failed.

Re:How can an OS have such a fundamental problem?

[TheCarp]

Meh, you are right of course, but, there is always some tradeoff between convinence and risk. Yes, theoretically the safe bet is to wait for it to enter the block chain, and even safer, to wait for a few confirmations. You know what though, many transactions that people do, are ones where this level of risk is acceptable because the barrier to cheating outweights the benefit for low value transactions.

I mean seriously, how many vendors accept credit cards now? Do you really think the risk involved with dealing with credit card processors is lower than that of accepting bitcoin transactions instantly? Some amount of risk is always acceptable; its just a matter of where you draw that line.

Frankly, I think it should be possible to reasonably mitigate most of those concerns without much change in the system.

Re:How can an OS have such a fundamental problem?

[SlashV]

Have you ever looked at the android source code? I have done some hacking on cyanogenmod and it's amazing what kind of crap can be found in a code base that is being used by several hundred million(!) people..

Re:How can an OS have such a fundamental problem?

[SlashV]

I would say the main advantage of bitcoin is that you *don't need* "big-name transaction clearinghouses". If you use those, you might just as well just pay with your creditcard.

Re:How can an OS have such a fundamental problem?

[kasperd]

It is build on top of Linux, which has /dev/urandom. I'd like to know if this is a generic kernel bug, or if Android doesn't use /dev/urandom.

You could work around such issues in user code. You could for example have your own 20 byte random seed which you concatenate with 21 bytes from the system random number generator and 14 bytes from other sources (the later don't need to be high entropy, every extra bit helps). Now send the entire 55 bytes through SHA1 and store the output as seed for the next iteration.

Re:How can an OS have such a fundamental problem?

[Hentes]

There's a tradeoff between security and speed. Android have chosen speed since most apps using a RNG are just games that don't care much about the quality. I guess the philosophy is that apps that rely on cryptographically strong random numbers will make their own RNG or use a third-party one.

Re:How can an OS have such a fundamental problem?

[IamTheRealMike]

No, he can't. He can try and race your broadcast, but miners do not accept double spends against the mempool. You can't just arbitrarily replace transactions like that. If you receive an unconfirmed transaction, unless your opponent has a ton of mining power and can choose the exact moment he purchases from you, and the good he's buying is immediately and irreversibly deliverable, it's not typically an issue.

Re:How can an OS have such a fundamental problem?

[ultranova]

It's ridiculous in this day and age that an OS can fail to make random numbers properly. That's one of the most basic operations.

But also one of the most difficult ones, since computers are by design deterministic and we would ideally have each bit be independent of anything else in existence. So you either need specialized hardware or rely on some kludgy workaround, such as timing system events. But of course if you do use specialized hardware, you not only get more costs but are now trusting a black box to not contain any nasty surprises.

How lazy/incompetent are the Google programmers?

Probably neither, just not absolutely perfect. And that's all it takes to break a cryptosystem.

This isn't the first time that random number generation has turned out to be a weak spot.

Re:How can an OS have such a fundamental problem?

[jeffmeden]

Meh, you are right of course, but, there is always some tradeoff between convinence and risk. Yes, theoretically the safe bet is to wait for it to enter the block chain, and even safer, to wait for a few confirmations. You know what though, many transactions that people do, are ones where this level of risk is acceptable because the barrier to cheating outweights the benefit for low value transactions.

I mean seriously, how many vendors accept credit cards now? Do you really think the risk involved with dealing with credit card processors is lower than that of accepting bitcoin transactions instantly? Some amount of risk is always acceptable; its just a matter of where you draw that line.

Frankly, I think it should be possible to reasonably mitigate most of those concerns without much change in the system.

Getting a credit card in multiple places at the same time (to make instant transaction fraud practical/profitable) is pretty tricky AND illegal. Getting a bitcoin wallet in the same place at the same time is trivial AND legal. There is also a healthy margin included in credit card fees, specifically to account for fraud. People will not want to switch to a system where fraud was hot-potatoed to the last one holding the invalid bitcoin transaction, no matter how many technical advancements are layered on to make it harder. This makes Bitcoin useless as an in-person instant payment system.

Re: How can an OS have such a fundamental problem?

[TheCarp]

Understating? Maybe, thats debatable at least.

Certainly there are many cases we could be talking about. If I were doing a bitcoin exchange of 100 btc, which currently is around 10k, then yes, you better believe I would expect 2 or even 3 confirmations before it was considered accepted.... but what about.... a cup of coffee for a small fraction of a bitcoin? There are many small transactions where cheating just isn't worth it, those are the only ones I would suggest ever do something like this. Its all a matter of what risk you are willing to take.

On top of this, I do think this sort of system could mitigate some of this risk. Imagine a setup where you have a transaction processor, could be local, could be a service. The processor has several bitcoin nodes, which are not peered with eachother. Consider a transaction valid if A) It has been seen at multiple nodes (proves it is propagating) and B) There are no other seen and unprocessed transactions which would invalidate this one.

Now a double spend is technically possible, but unlikely to work. It is a risk, yes, but if all you have on the line is $3-$10 worth of coins.... it is probably an acceptable risk. If someone does double spend, you lose, but you don't loose much, and the only confidence destroyed is in the instant acceptance mechanism.

The real question is not will it be abused, but, will the convinenece bring in more profit than the losses from bad actors?

Re:How can an OS have such a fundamental problem?

[mcrbids]

I'd think that an Android device has a number of excellent sources of randomness: Wifi signal, cell signal, accellerometer inputs, and light sensor light levels in conjunction with the usual *nix generators based on system load variables (memory/cpu/io) should mean that mobile devices should have *excellent* randomness.

Re:How can an OS have such a fundamental problem?

[TheCarp]

> Getting a credit card in multiple places at the same time (to make instant transaction fraud
> practical/profitable) is pretty tricky AND illegal. Getting a bitcoin wallet in the same place at the
> same time is trivial AND legal.

Legal? Pretty sure its still fraud. Not only that but it leaves behind a signed transaction that only the fraudster could have produced. We have already seen someone lose in court after trying the "But bitcoins are not real money" excuse. They are, and a contract is a contract, even if its verbal or implicit in the transaction.

> There is also a healthy margin included in credit card fees,
> specifically to account for fraud. People will not want to switch to a system where fraud was
> hot-potatoed to the last one holding the invalid bitcoin transaction, no matter how many technical
> advancements are layered on to make it harder. This makes Bitcoin useless as an in-person instant
> payment system.

Why not? Not every fraud is equal, and vendors, at least smart ones, are willing to put up with some amount of "shrink" (as they like to call it) if reducing it to zero is not worth the cost. I think you are overrestimating people's aversion to risk. They may not like it when you describe it in those terms, but, it is really no different from other areas of business; and its just another cost of doing business.

Re:How can an OS have such a fundamental problem?

[mindwhip]

Every time RNG in Android crops up I can't but think of this discussion...
http://code.google.com/p/android/issues/detail?id=42265

Re:How can an OS have such a fundamental problem?

[slew]

There are also uses of random numbers outside cryptography.I came across this: http://en.wikipedia.org/wiki/Mersenne_twister [wikipedia.org] which is good for some uses, but bad for cryptography.

Pet peeve of mine, but people often casually use MT as an example of a "golden" PRNG when it is really the first (1997) "popular example" for generating extremely long period uniform distributions using a generalized LFSR-like technique. Unfortunatly with simplicity come certain flaws. The biggest flaw is that it takes many iterations for a seeded initial state to get to a state that is really random. For user that aren't simulating huge universe-sized things (or need an extremely large non repeating, but uniform distribution PRNG), this isn't really the best tradeoff. If you have to throw away the first million numbers to sample a few thousand, that isn't the best efficiency ratio.

Fortunatly, most things get improved over time. For example, the "WELL" PRNG (2004) claims to have a faster state randomization time and is probably suited more to the needs of people wanting a default off-the-shelf PRNG for medium sized simulation purposes (e.g, the average scientist that doesn't spend time researching the properties of PRNGs for their simulations). Sadly, WELL isn't more popular since it is a better default PRNG for nearly all uses.

If your needs are more cryptographic based, DRBGs (deterministic random bit generators) are designed to resist identification of the current state (I've heard that it only takes observing 624 iterations to identify MT19937's state vector) and to reasonably stretch any existing true-random sources. NIST has some reasonably good standardized examples of these EXCEPT for Dual_EC_DRBG which paranoid folks should probably avoid...

Re:How can an OS have such a fundamental problem?

[You're All Wrong]

"Trusted" to a cryptographer means "if this guy doesn't do what he claims to, the system breaks". It's nothing to do with being trustworthy.

Re:How can an OS have such a fundamental problem?

[Entropius]

If you need a source of entropy on the Sprint network, you could always just use the rate of dropped calls...

Re:How can an OS have such a fundamental problem?

[Pathwalker]

I believe the issue carried over from Apache Harmony, if this is the issue at fault.

Re:How can an OS have such a fundamental problem?

[IamTheRealMike]

Er, no. That's now how Bitcoin works, nor is it how it is intended to work. I suggest you review the codebase and try again.

Re:How can an OS have such a fundamental problem?

[gweihir]

Indeed. You need to know that your entropy sources provide _more_ entropy than needed in the worst case.

But the problem in this case seems to be that Java SecureRandom is broken, while the Linux kernel /dev/random is perfectly fine, yet unused. There seem to be BitCoin apps for Android that are not vulnerable, because the y use /dev/random. This basically means that the designers of Java SecureRandom on Android messed up badly. Which is a disgrace, as it means Google had nobody with actual security skills on that team. Pathetic.

Re:How can an OS have such a fundamental problem?

[gweihir]

Indeed. And add to that "secure crypto needs independent review". But I guess Google does not have enough money to pay for that. Oh, wait.

Re:How can an OS have such a fundamental problem?

[kasperd]

/dev/urandom is not a cryptographically secure source of random numbers.

Maybe you should actually have taken a look at the source before trying to educate somebody who has. It is clearly stated in the source, that /dev/urandom produces cryptographically strong random numbers.

/dev/random is (when correctly implemented). In fact, it's supposed to be better than the frivolous combining-bits-and-hashing scheme you propose.

LOL. You probably don't even know the difference between what I proposed and what /dev/random does. They are more similar than you imagine.

Re:How can an OS have such a fundamental problem?

[kasperd]

And since SHA1 has a fixed length, the 20 bytes with zero entropy you fed into it forced out some of whatever entropy the other 35 bytes contained. Luckily, in this case you only force out some of SHA1's chunk padding

Nothing is forced out. 55 bytes plus padding fits within a single block of SHA1 compression.

but you still aren't accomplishing anything useful by adding compile-time constants either.

I didn't propose usage of any constants.

Cryptography is something that really, really, really should be left for the experts rather than just hacked together on gut feeling.

I don't hack things together on gut feeling. I wouldn't have proposed an exact algorithm if there was a risk it could make security worse. Since the hash input has 21 bytes from the system random number generator, and the hash output is only 20 bytes, that output is going to have at least as much entropy per bit as the system random number generator produced in the first place (unless you find a vulnerability in SHA1). The remaining 34 bytes are only there to strengthen the random numbers in case the system random number generator, you would have used otherwise, does not provide sufficient entropy.

Re:How can an OS have such a fundamental problem?

[delt0r]

Cryptographic randomness is not easy. Its not easy in hardware either and the hardware still doesn't support a random generator.

Re:How can an OS have such a fundamental problem?

[delt0r]

It is not a solved problem. Generating truly random numbers is hard. Even with hardware, which should be part of every cpu, its not that easy either.

Re:How can an OS have such a fundamental problem?

[cbhacking]

The problem is that they're using /dev/urandom when they should be using /dev/random. /dev/urandom is a PRNG, and apparently (on Android, at least) not a very good one. Dalvik's SecureRandom should be using /dev/random instead - yes, it can block and cause loss of responsiveness (stop doing expensive operations on your UI thread, numbskulls...) - but they went for the less-secure option of using urandom for *everything*.

Re:How can an OS have such a fundamental problem?

[cbhacking]

That's why there's /dev/random and /dev/urandom. The problem is, they use /dev/urandom for everything, including their so-called SecureRandom implementation.

Re:How can an OS have such a fundamental problem?

[kasperd]

The problem is that they're using /dev/urandom when they should be using /dev/random. /dev/urandom is a PRNG, and apparently (on Android, at least) not a very good one.

A Google employee who is involved with bitcoin told me, that the way the problem got fixed was by using direct reads from /dev/urandom.

Re:How can an OS have such a fundamental problem?

[OneAhead]

It is clearly stated in the source, that /dev/urandom produces cryptographically strong random numbers.

Oh, really? Guess they'll have to update the Linux man page then...
http://stackoverflow.com/a/3690285
http://linux.die.net/man/4/urandom
http://en.wikipedia.org/wiki//dev/random#Linux

The bigger issue...

[supersat]

... is that supposedly Android's "secure" random number generation... isn't. This could potentially affect much more than Bitcoin wallets.

Does anyone know what the issue is? This article seems to suggest it's a vulnerability in the SecureRandom class, but no actual details.

Random numbers on a mobile device

[Kinthelt]

Shouldn't the RNG tap into the device's accelerometer? That should provide random data if the user gives it a few successive shakes.

Re:Random numbers on a mobile device

[gweihir]

The problem is not doing it right once you understand the issue. The problem is understanding the issue.

Re:Random numbers on a mobile device

[Thanshin]

The problem is not doing it right once you understand the issue. The problem is understanding the issue.

In my experience, the problem is not understanding the issue but either acknowledging there is an issue or even making the effort to investigate whether there might be one.

Re:Random numbers on a mobile device

[c]

Shouldn't the RNG tap into the device's accelerometer?

The Linux kernel has has the ability to push device input into the random number entropy pool for a long time (/dev/random and /dev/urandom). If the device drivers aren't pumping accelerometer events into the pool, someone really missed an opportunity.

In this case, it sounds like something went wrong with the Java/Dalvik random number generator. It's not clear to me from glancing at the various write-ups whether it's a failure to RTFM on the part of the Bitcoin wallet writers (or maybe whoever wrote a common Bitcoin reference implementation) or if there's something broken in the Android implementation of the RNG class.

Number re-use?

[Sockatume]

There aren't many details floating around but it looks like the issue is that the RNG can return the same number on two occasions. However the possibility of returning the same random number again in the future is a perfectly expected property of any RNG; presumably they mean that the probability is much higher than normal?

Re:Number re-use?

[Sockatume]

Right. If Bitcoin mistakenly assumed that the RNG "shuffled" numbers and they would not be reused, I don't think that's an Android bug. However given that Bitcoin clients work fine on every other platform I assume that's not the problem and there genuinely is something up with the RNG.

Re:Number re-use?

[Agent ME]

The chance of getting the same number twice should be equal to the chance of an attacker brute-forcing it. Judging by the fact some keys were brute-forced in well under a billion years, I'm going to assume it's much more likely that Android's RNG is broken.

Software generated random numbers are never random

[Viol8]

Since they are generated by algorithms that give repeatable results - this isn't news. The distribution is random (usually) but the sequence is not. You need to tap into some aspect of the hardware if you hope to get true randomness and even then, unless you're measuring some quantum effect the random aspect might not be quite so random as you at first think.

Re:Software generated random numbers are never ran

[Sockatume]

"Arbitrary number generator" might be a more useful name, where the numbers generated follow a given distribution and their selection is arbitrary. Calling them pseudo-random invites mistaken conclusions.

Not limited to Bitcoin?

[L. J. Beauregard]

If the problem is with Android's RNG, then any secure application on Android may be at risk.

Re:I'll just leave this here.

[Sockatume]

If this random number is ever used twice with the same private key it can be recovered. This transaction was generated by a hardware bitcoin wallet using a pseudo-random number generator that was returning the same “random” number every time.

If this is true there's a vanishingly small but nonzero chance of recovering any private key, depending on how large the random number is; poorly-written RNGs simply increase that chance spectacularly.

Re:If Android's RNG is kaput... so is Linux's

[h4rr4r]

urandom is not a replacement for /dev/random. /dev/random blocks for a very good reason. Bad Android developer bad! Do it again and I am getting a rolled up newspaper.

Some details

[grimJester]

Here

The problem is this: the elliptic curve digital signature algorithm, which Bitcoin transactions rely on for security, has three inputs: the transaction, the signerâ(TM)s private key and a random number. The algorithm then outputs two values, denoted r and s, where s is calculated with the formula k-1(z+rd), z being the hash of the message, k the random number and d the private key. r is dependent only on k. Thus, if the owner of an address signs two transactions with the same random number (and of course the same private key, as every address is linked to one private key), one can extract two s values from the two signatures, subtract them to make the rd terms cancel out, and extracting the private key from there becomes a simple division problem (a more detailed writeup can be found here). Normally, this is not a problem; given a true random number generator, the first âoecollisionâ should take place roughly at the same time as the heat death of the universe. As it turned out, however, java.security.SecureRandom proved to be not so random, generating the same âoerandomâ number twice on many occasions.

I just noticed the "found here" link goes to an article from January. That makes me both unsure they've got the right bug and annoyed it hasn't been fixed already.

Re:Some details

[supersat]

This is exactly how the PS3 got thoroughly 0wned. I'm curious what the problem with SecureRandom is.

Re:Some details

[Wookie Monster]

The problem really is the implementation on Android, from a old buggy open source library. http://armoredbarista.blogspot.com/2013/03/randomly-failed-weaknesses-in-java.html

Proper implemenation

[schneidafunk]

I am taking a stab that the random generator was not seeded correctly. Here is a good description on seeding properly.

Re:Proper implemenation

[Agent ME]

The correct and highest voted answer on that page says to avoid seeding SecureRandom yourself. It's designed to be the most secure with its default constructor. The issue is that Android's implementation of SecureRandom is bad even when you use it correctly.

Re:Proper implemenation

[Miamicanes]

Hmmm. If true, this is *catastrophically* bad, because it clouds the security of EVERY implementation of client-side cryptography under Android.

For years, java.util.SecureRandom has been the bedrock foundation of all encryption under Java (and by extension, Android, even if Android technically isn't Java). A vulnerability in SecureRandom doesn't just bork bitcoins... it screws up things like PBKDF2, DH key exchange (and by extension, SSL & RSA), and even AES (if you're using it client-side to generate a random AES encryption key).

It also means we're probably going to have to NOW mess around with yet another new class, like android.os.ReallySecureRandom (even if the bug DOES get fixed), simply because so many older phones will never see an update, and replacing it entirely with a new RNG class is the only way for an app developer to confidently know that he's not using a degenerate implementation.

Sigh.

Re:Proper implemenation

[Agent ME]

It is really concerning. I'm hoping that existing SSL/TLS libraries rely on /dev/u?random instead of (in)SecureRandom, or else there might be a lot of stored ciphertext communications getting cracked about now.

At least there's an easy way to patch it in Android apps. Here's the patch that works around the issue in the Android Bitcoin client. It patches SecureRandom to just read from /dev/urandom instead.

Re:Proper implemenation

[schneidafunk]

Thanks for the follow-up. I did not realize the default constructor was insecure and this is probably the most informative thread (to me) I've seen on slashdot in a while :)

Re:Proper implemenation

[cbhacking]

I would argue that reading /dev/random would be much better in this case - yeah, it might block, but you probably shouldn't be pulling large amounts of data out of the RNG. I mean, that's the whole reason we have crypto algorithms, rather than just using a ton of one-time pads; a nice short sequence of bits (128 of them, for typical AES usage) is enough. Yeah, you need IVs (or k-values for ECC) but those don't have to be *securely* random, only unique. In fact, by their very nature, they are public values. I believe you can use a counter for them if you want to. You certainly don't need a *secure* PRNG for them; the most important characteristic there is instead the period (time before it repeats itself),

For people who want a lot of "good" random numbers but don't care if they're "the best" random numbers, I suppose one could leave SecureRandom pulling from /dev/urandom and have NoThisTimeItIsReallyTrulySecureRandom[FactoryFactoryImpl on the end is optional] that reads from /dev/random instead...

Description of vulnerability

[schneidafunk]

Here is an article on how to implement java's securerandom function:

https://www.cigital.com/justice-league-blog/2009/08/14/proper-use-of-javas-securerandom/

Re:Description of vulnerability

[Agent ME]

By "implement" you mean "use"?

From looking at the Android Bitcoin client's code, it appears it already used SecureRandom correctly (default empty constructor). The Android implementation of SecureRandom itself is broken.

Re:Description of vulnerability

[alonz]

From a brief trawl of the Android sources, it looks like Android's new-and-shiny OpenSSL-based SecureRandom only seeds the OpenSSL random generator if you open a TLS socket. If you don't - you will be using an unseeded OpenSSL RNG.

Re:If Android's RNG is kaput... so is Linux's

[ameen.ross]

There's an interesting article over at LWN about /dev/random and /dev/urandom

http://lwn.net/Articles/489734/

Re:If Android's RNG is kaput... so is Linux's

[Agent ME]

The issue is with Android's SecureRandom class. SecureRandom does not rely on /dev/urandom or /dev/random.

Re:Software generated random numbers are never ran

[wonkey_monkey]

Calling them pseudo-random invites mistaken conclusions.

Calling them just plain random would be to do that. Pseudo- covers it off nicely, I think. Looks like, but ain't. In fact if the sequence is repeatable (given the same seed), they're demonstrably not arbitrary.

morons

[slashmydots]

They're already so far beyond stupid for doing it anyway, this is beside the point. If your phone gets stolen or your phone has a hardware failure, your wallet is toast and there goes all your money permanently. Some apps have ways to move your wallet file from a PC to a phone but then it shouldn't have a problem with random number generation since the encrypted wallet came from a PC.

Re:morons

[Anonymous Coward]

>If your phone gets stolen or your phone has a hardware failure, your wallet is toast and there goes all your money permanently.

This is why bitcoin wallets allow backup to a file encrypted with a passphrase. If you lose your device, you simply restore your wallet to a new one.

Re:Software generated random numbers are never ran

[Agent ME]

Good random number generators exist elsewhere. Most modern encryption relies on them. The fact that someone spectacularly messed up an RNG with disastorous exploitable results is news.

No wonder my craps game always comes up snake eyes

[BetaDays]

No wonder my craps game always comes up snake eyes.

Re:Software generated random numbers are never ran

[TheCarp]

Cell phones already have a great RNG, its called the "touch screen"....aka the same RNG thats used to dial random international numbers every time it decides to randomly unlock in your pocket.

Could just have the touch screen polled randomly while the screen is off, if some random portion is being pressed, extract some entropy from it and toss it in the pool. I am pretty sure the interactions between my thigh, pants, and screen could produce every bit as much entropy as wiggling a mouse around.

Burying the lead

[WaffleMonster]

I have to wonder did someone sit around a table and brainstorm the most innocuous repercussion of RNG failure possible?

"Insecure?" Unsecure?

[Control-Z]

Nitpicky guy here. Wouldn't unsecure be the right word? The meaning of insecure is primarily "Not confident or assured; uncertain or anxious."

Not just a Bitcoin problem

[mathimus1863]

This certainly affects Bitcoin the most, but a random number generator that actually produces the same "random" numbers is hardly random at all, and could present a serious problem for all types of applications. In fact, that's an entirely-broken random number generator. I'm wondering how such an egregious PRNG/seeding-algo made it this long without someone noticing. Maybe it's because Bitcoin provides a financial incentive to find these flaws, and honestly it's pretty easy to spot it from a one-minute blockchain scan -- just look for two transactions with identical r-values, plug it into the stupid-simple equation, and then steal the money.

For Android/mobile, the answer is to leverage the variety of sensors that are on-board. Using the low bits of accelerometer output should work great for seeding a PRNG if someone is actually holding the phone. If not, snap an image or take a quarter-second audio recording should suffice. There's enough noise on the camera and microphone that the hash of the output should be different even if it's sitting camera down in a quiet room. A lot of times you only 32-bytes of entropy, and a single image with 5 million pixels can give you an order of magnitude more than just from the random variations in sensor output in a dark room.

Already fixed on the app side.

[SinisterEVIL]

The issue has already been resolved. http://bitcoin.org/en/alert/2013-08-11-android

Re:I'll just leave this here.

[amorsen]

If this is true there's a vanishingly small but nonzero chance of recovering any private key, depending on how large the random number is; poorly-written RNGs simply increase that chance spectacularly.

Yes, that is how encryption works. There is also a vanishingly small but non-zero chance that I generate the same 4096-bit RSA key that you just used.

To avoid that chance you need to either switch to a one time pad (where the same chance exists, but the ciphertext can decrypt to anything, so I cannot know that I guessed correctly) or possibly certain forms of quantum encryption.

Why did they even consider using the OS's routine?

[jc42]

The most cursory search will turn up similar complaints for every OS's library random-number routine, over the history of computing. It's quite common for a random-number routine that has been good for years to suddenly become non-random in a new release. Basic advice has always been that, if it's important to have truly "random" numbers with any specific property, you should simply ignore any routines that came from vendors. You should look in "the literature" for routines with the properties you need, and have a good programmer (i.e., one who can handle basic arithmetic ;-) to code it up in whatever language you're using.

And part of your testing suite is a test of your random-number routines(s), to verify that they are still generating numbers with the appropriate level of randomness. It's funny what things like "improved" optimizations in the compiler can do to the correctness of such code.

If the bitcoin software managers are using any OS's random-number generators, well, they're just incompetent. Their job should be handed to someone with minimal understanding of the math that they're using. Someone who will ensure that other managers don't force their programmers to do it wrong.

(Yes, I have been ordered by several managers to implement incorrect arithmetic. I've generally responded by writing and distributing a proof of the incorrectness of my orders, and updated my resume. Sometimes they've responded by putting me in charge of the math routines in question. But far more often, I've found a new job. ;-)

(But this wasn't quite as funny as the case where a manager gave us written orders that clearly required that we implement messages that went faster than light. We quickly learned that his superiors supported him, so the entire team had new jobs a week later. We eventually learned that the product was finally abandoned. ;-)

Re:I'll just leave this here.

[petermgreen]

If this is true there's a vanishingly small but nonzero chance of recovering any private key

There is a vanishishingly small but nonzero chance of recovering a private key by simply guessing it's factors.

Crypto is a game of probabilities. The aim is to reduce the probability of compromise to a level you consider negligable. Usually you try to reduce what you belive to be the probability of compromise way beyond the level you consider negligable in case your assumptions in calculating the probability were wrong. Short of a one time pad (which has it's own issues) you can never reduce it to zero.

poorly-written RNGs simply increase that chance spectacularly.

Taking it from negligable to likely.

afaik

[KingBenny]

mt gox is secured (insured?) against hacking so if someone hacks me(i probably need a dongle for that) ... or en masse ... i dont lose a penny (or a bit in this case)
then again im not a blind person living under the illusion that a blockchain where every transaction is visible to everyone forever is anonimity so i wouldnt use it for
sub-
legal activities unless i really knew what i was doing or had a five star blackhat working for me ...