Version 5.0 The LEDA User Manual

CryptKey k(const byte ∗ bytes, uint16 num key bytes);
initializes k with a copy of the array bytes of size num bytes.
CryptKey k(const CryptByteString& byte str);
initializes k with byte str.
CryptKey k(const char ∗ hex str);
initializes k with the hexadecimal representation in hex str.
Key generation
A key generation algorithm takes as input a (partially) secret seed s of arbitrary length
and outputs a key k of the desired size. The gist of this process is to apply a secure hash
function H to the seed and to use the returned hash value as the key, i.e. k = H(s). In
our implementation we use the checksum of the SHACoder, which is 20 bytes long. Since
we want to be able to generate a key of size n ≠ 20 we use the following approach: We
divide the key into p = ⌈n/20⌉ portions k 1 , . . . , k p , where the size of k 1 , . . . , k p−1 is 20
and the size of k p is at most 20. We set k i = H(s ◦ n ◦ i). (Here “x ◦ y” denotes the
concatenation of x and y, and k p is possibly a proper suffix of the returned hash value.)
Then we have k = k 1 ◦ . . . ◦ k p .
The question is now what to use as seed for the key generation. The first idea that comes
to mind is to use the passphrase supplied by the user. In that case the process would be
vulnerable to the so-called dictionary attack. This works as follows: Since many users
tend to choose their passphrases carelessly, the attacker builds a dictionary of common
phrases and their corresponding keys. This gives him a set of “likely” keys which he
tries first to break the system. One way to make this attack harder is to apply the hash
function several times, i.e. instead of k = H(s) we set k = H(H(. . . H(s))). Even if
we apply H some thousand times it does not slow down the generation of a single key
noticably. However, it should slow the generation of a whole dictionary considerably.
An even more effective counter measure is to use something that is called salt. This is a
string which is appended to the passphrase to form the actual seed for the key generation.
The salt does not have to be kept secret, the important point is that each key generation
uses a different salt. So it is impossible to reuse a dictionary built for a specific salt. The
salt is also useful if you want to reuse a passphrase. E.g., if you want to authenticate and
to encrypt a file you might refrain from remembering two different phrases. But since it is
not a good idea to use the same key twice you could generate two different keys by using
two different salts.
CryptKey
CryptKey :: generate key(uint16 key size,
const CryptByteString& seed,
uint32 num iterations)
generates a key of size key size by applying a hash
function num iterations times to the given seed.