| Hey, quick question.
| 
| If one wants to have multiple keys, but for ease-of-use considerations
| want to only have the user enter one, is there a preferred way to
| derive multiple keys that, while not independent, are "computationally
| independent"?
| 
| I was thinking of hashing the passphrase with a unique string for each
| one; is this sufficient?  If sufficient, is a cryptographically strong
| hash necessary?
The property you presumably want is that knowing n generated keys gives
you "no information" about the n+1'st generated key.  The usual way
that's proposed to do this is to take the master secret, concatenate
some identifying data - say k encoded in 32 bits for the k'th secret -
and run the result though a cryptographic one-way function.  This
*seems* like it ought to work - "you can't invert the function", etc.,
etc. - but even if the one-way function has all the usual properties,
it's not clear they really give you the property you need.  (In fact,
the arguments have the flavor of older arguments that you can "easily"
construct a keyed checksum from a hash by "just" prepending, or
appending, secret keying material.  In fact, you need to use something
more clever, like HMAC.   Using HMAC here looks like a good try, but
it's no clear that it does the trick either.)

Of course, there is a primitive that does have the right property,
namely an encryption function.  Suppose we took k and decrypted it
with the secret master key.  Any good encryption function will
certainly have, as part of its assumed properties, that seeing the
decryption of n blocks gives you no information about the decryption
of any other block (at least as long as n is small compared to the
2^(block size), which it certainly will be).
 
| I got a clarification about the "use CRCs to process passphrase" idea
| someone mentioned.  The salient bit is that he was using several CRCs
| (not sure if it's random or carefully chosen), and each one is run on
| the passphrase, and the output of all of them concatenated to
| initialize a PRNG seed.  The passphrase and seed are both secret, so
| according to him there's no need to use a cryptographically strong
| hash, and CRCs have a well-understood mathematical basis.
|
| I presume this would be insufficient for deriving independent keys,
| but perhaps there is a way to do that with careful selection of the
| CRC polys?
He's perhaps relying Rabin's "fingerprinting using random polynomials"
results.  What it basically says is that, even though it's easy to
attack a CRC any *known* polynomial, if I choose a polynomial *at
random* and keep it secret, your chance of modifying something I
checksum with that CRC and getting away with it is essentially just
1 in 2^n (for an n-bit checksum).  Of course, I have to keep both
the polynomial and the checksum secret; and there is some math involved
to pick a primitive polynomial randomly.

However, coupling all this with seeding a PRNG makes it highly likely
that he's cross the line from "obviously no vulnerabilities" to "no
obvious vulnerabilities".
                                                        -- Jerry

---------------------------------------------------------------------
The Cryptography Mailing List
Unsubscribe by sending "unsubscribe cryptography" to [EMAIL PROTECTED]

Reply via email to