Tue, 19 Jan 2010
I am currently in possession of a large number of things I really don't need to have around, including, because I'm that kind of weirdo, a couple of PCI crypto cards - an AEP2000 (donated to me by AEP so I could write drivers for botan for it) and a Hifn 7811 (an ebay impulse buy).
The AEP2000 card is basically a modular exponentiator engine - the 2000 in the name refers to the number 1024-bit private key RSA operations it can perform per second (so, 4000 512-bit exponentations per second (they were counting CRT optimizations when they made the model numbers)), and you can use moduli up to 2048 bits. In testing I found that it could indeed reach 2000 ops per second in practice. There are open source Linux drivers available for this card, but nobody has ever updated them for anything past a 2.4 kernel, and it doesn't seem like they are SMP safe either. Since I don't have the time (or inclination) to update and fix them, I would rather give the card away to an open source developer who can make use of it somehow.
The Hifn 7811 offers symmetric encryption (DES, RC4, possibly AES?), MD5 and SHA-1 hashing, and a hardware PRNG. It is similiar, but not identical, to the Soekris vpn1401. There are drivers for this card included in the Linux kernel, but only 32 bit kernels are supported (I asked Evgeniy Polyakov, the author of the driver about this, and he indicated it is a hardware limitation). The only 32-bit machines I have left are laptops and netbooks, which obviously can't really take a PCI card, leaving me with a card with no place to go.
If you would like to play with either (or both) of these cards, drop me an email and let me know. I would likely give preference to someone who will be using them to support an open source project, but feel free to contact me even if this is not the case; mostly I'd like to give them a good home where they will be doing something useful.
Posted in security at 2010/01/19 21:18; 0 comments
Thu, 08 Oct 2009
After the initial set of attacks on MD5 and SHA-1, NIST organized a series of conferences on hash function design. I was lucky enough to be able to attend the first one, and had a great time. This was the place where the suggestion of a competition in the style of the AES process to replace SHA-1 and SHA-2 was first proposed (to wide approval). This has resulted in over 60 submissions to the SHA-3 contest, of which 14 have been brought into the second round.
Of the second round contenders, I think Skein is the best choice for becoming SHA-3, and want to explain why I think so.
Posted in security at 2009/10/08 15:19; 0 comments
Wed, 21 Jan 2009
CVE Id Assigned for GNU Classpath Vulnerability
The error in the GNU Classpath PRNG that I described last month has been assigned an identifier in the Common Vulnerabilities and Exposures list: CVE-2008-5659.
Unfortunately a new version of Classpath with a fixed PRNG still remains to be released, so it seems I'm going to have to sit on the demonstration code showing how to derive DSA private keys for a while longer. At some point it would be nice to also verify that RSA and DH keys can also be compromised, perhaps with a sexy little app that compromises SSL/TLS sessions or something along those lines, but I am currently suffering a shortage of round tuits.
Posted in security at 2009/01/21 12:18; 0 comments
Tue, 09 Dec 2008
Inspired by the recent FreeBSD arc4random vulnerability, I've been taking a look at the random number generators used by various libraries and operating systems. So far, problems in the JUCE C++ library and in the GNU Classpath PRNG have been identified. (I also checked out Mozilla's NSS, but did not spot any major flaws in that implementation.)
Syllable is a desktop OS based on AtheOS that provides what seems like a pretty decent desktop experience along with POSIX APIs and the GNU toolchain. My initial interest in the project was to get it installed under KVM and port my project botan to it.
Posted in security at 2008/12/09 13:20; 0 comments
Sat, 06 Dec 2008
Serious Weakness in GNU Classpath/gcj PRNG; DSA keys are compromised
GNU Classpath is an open source implementation of the Java class libraries used by gcj, the GNU Compiler for Java. One component of the Java library is JCE, the Java Cryptography Extensions (so called because originally it was not bundled with the JVM due to United States export restrictions), which provides the basic crypto features one would expect (ciphers, hashing, signatures) for Java applications.
For many RNG purposes, including creating private keys, DSA
k values, and SRP session ids, GNU Classpath uses
gnu.crypto.security.util.PRNG.
This PRNG uses a hash function, which by default is SHA-1 though others can be used instead. It is initialized with a random seed, and then values are generated by the recurrence
V(0) = H(seed) V(i) = H(seed || V(i-1))
The PRNG has an interface allowing the addition of new seed material at a later time, for instance a GUI application might seed it with mouse click event information.
Unfortunately there are two problems with how this PRNG is used in Classpath that in combination cause serious problems. One is a convention where each object, most of the time, gets its own PRNG. It seems that it is possible in some but not all cases to override the PRNG to be used, and there seem to be at least three different conventions for how to do it in Classpath. A representative example, from the RSA key pair generator code:
/** The optional {@link SecureRandom} instance to use. */
private SecureRandom rnd = null;
/** Our default source of randomness. */
private PRNG prng = null;
[...]
private void nextRandomBytes(byte[] buffer)
{
if (rnd != null)
rnd.nextBytes(buffer);
else
getDefaultPRNG().nextBytes(buffer);
}
private PRNG getDefaultPRNG()
{
if (prng == null)
prng = PRNG.getInstance();
return prng;
}
This class will use nextRandomBytes to choose starting
points for the RSA p and q values. Note that all
access to the prng itself is private, so an application developer
cannot, for instance, add new seed data to the PRNG.
The other problem is that by default the only seed used in
gnu.crypto.security.util.PRNG is the current timestamp in
milliseconds. This can be extended by setting a property
named "gnu.crypto.prng.md.seed", but I could not find out much more
about this because it does not seem to be used by any code at all
within Classpath.
Many cryptographic algorithms require a source of cryptographically
secure random numbers. For instance, DSA
requires choosing a new random 160-bit integer k for each
signature that is generated. If this k value is ever
revealed, the private key is immediately compromised, since it is
equal to (((s*k) - H(m)) * r-1) mod q (using the notation
from FIPS 186). Since GNU Classpath (in effect) chooses k
values by simply hashing the current timestamp in milliseconds with
SHA-1, it is quite simple to search for and find k.
Experiments confirmed that the output of
gnu.crypto.security.util.PRNG, as it is returned by
PRNG.getInstance(), is easily guessable using only the local
clock as the starting point for the search. This usage matches exactly
how this class is used throughout the GNU Classpath source.
There are less than 235 millisecond values in a year, which puts an upper bound on the security of any keys generated by this RNG, assuming an attacker can guess the year, which seems a reasonably safe bet. Even a decade contains barely 238 milliseconds. These values are far less than even the toughest export restrictions the United States ever imposed, which were typically 40 to 56 bits of security.
Classpath contains a number of other RNGs including
gnu.crypto.security.util.CSPRNG, which seems (at least at
first glance) to be somewhat safer. I would recommend adding
additional seed material, which would probably be sufficient, except
it seems in many cases that is not even possible. Unfortunately since
g.c.s.u.PRNG's use is hardcoded in nearly everywhere, it may be
difficult for applications to switch.
Update 2008-12-08: I've confirmed that the private half of a DSA keypair can be derived from the public key and a single signature/message pair, simply starting with a guess of the time the signature was generated. This basically means that every DSA key which has been used in an application compiled with gcj or using GNU Classpath/GNU crypto is (or at least can easily be, at any time) compromised. Based on the CVS history, it appears this flaw was originally introduced in GNU Crypto about 6 years ago, and was then imported into Classpath without alteration.
I've entered a bug report for Classpath describing the problem, but no response yet. After this is resolved (hopefully soon), I'll post the private key derivation code for examination.
An example vulnerable application is DSASigGen.java, which uses only the normal stock Java/JCE API calls to generate a random DSA key, sign an empty string (the exact value doesn't matter, as long as the message is known), and prints the public key and signature (the private key is printed to stderr by the Java code, just so I could confirm that the search code was in fact finding the correct key).
(motoko)$ gcj --version gcj (Gentoo 4.3.2 p1.2) 4.3.2 Copyright (C) 2008 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. (motoko)$ gcj --main=DSASigGen DSASigGen.java (motoko)$ ./a.out > pubkey_and_sig Private key is 286340495355822070335047169143648712734886086939 (motoko)$ cat pubkey_and_sig 308201b83082012c ... [(DSA public key truncated for readability / not screwing up formatting)] 302c02140f22be1f12e4c5950e1a4ff4cb7e269f3cd5b6f60214060ae0e5013a05ee2b1f719b49926b394424bde0 (motoko)$ g++ -O2 find_dsa_key.cpp -lbotan -o find_dsa_key (motoko)$ time ./find_dsa_key < pubkey_and_sig Found private key 286340495355822070335047169143648712734886086939 real 0m0.716s user 0m0.634s sys 0m0.054s
Update #2: According to the Wikipedia entry, other JVMs including Kaffe and JikesRVM use GNU Classpath. I have not checked if they are vulnerable (Kaffe is not building on my machine), but the odds are good. This may be a bigger issue than I first thought.
Update #3: I should emphasize that while DSA keys are the easiest target of this flaw, it is quite likely that all private keys (RSA, DSA, Diffie-Hellman, etc) generated by Classpath can be easily found, simply by guessing PRNG seeds and running through the key generation procedure until a private key corresponding to the known public key is produced.
Posted in security at 2008/12/06 11:11; 0 comments
[1] 2 3 4 5 >>