5 * Author: Tatu Ylonen <ylo@cs.hut.fi>
7 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
10 * Created: Wed Apr 19 17:41:39 1995 ylo
15 RCSID("$OpenBSD: cipher.c,v 1.29 2000/07/10 16:30:25 ho Exp $");
21 #include <openssl/md5.h>
24 * This is used by SSH1:
26 * What kind of triple DES are these 2 routines?
28 * Why is there a redundant initialization vector?
30 * If only iv3 was used, then, this would till effect have been
31 * outer-cbc. However, there is also a private iv1 == iv2 which
32 * perhaps makes differential analysis easier. On the other hand, the
33 * private iv1 probably makes the CRC-32 attack ineffective. This is a
34 * result of that there is no longer any known iv1 to use when
35 * choosing the X block.
38 SSH_3CBC_ENCRYPT(des_key_schedule ks1,
39 des_key_schedule ks2, des_cblock * iv2,
40 des_key_schedule ks3, des_cblock * iv3,
41 unsigned char *dest, unsigned char *src,
48 des_cbc_encrypt(src, dest, len, ks1, &iv1, DES_ENCRYPT);
49 memcpy(&iv1, dest + len - 8, 8);
51 des_cbc_encrypt(dest, dest, len, ks2, iv2, DES_DECRYPT);
52 memcpy(iv2, &iv1, 8); /* Note how iv1 == iv2 on entry and exit. */
54 des_cbc_encrypt(dest, dest, len, ks3, iv3, DES_ENCRYPT);
55 memcpy(iv3, dest + len - 8, 8);
59 SSH_3CBC_DECRYPT(des_key_schedule ks1,
60 des_key_schedule ks2, des_cblock * iv2,
61 des_key_schedule ks3, des_cblock * iv3,
62 unsigned char *dest, unsigned char *src,
69 des_cbc_encrypt(src, dest, len, ks3, iv3, DES_DECRYPT);
70 memcpy(iv3, src + len - 8, 8);
72 des_cbc_encrypt(dest, dest, len, ks2, iv2, DES_ENCRYPT);
73 memcpy(iv2, dest + len - 8, 8);
75 des_cbc_encrypt(dest, dest, len, ks1, &iv1, DES_DECRYPT);
76 /* memcpy(&iv1, iv2, 8); */
77 /* Note how iv1 == iv2 on entry and exit. */
81 * SSH1 uses a variation on Blowfish, all bytes must be swapped before
82 * and after encryption/decryption. Thus the swap_bytes stuff (yuk).
85 swap_bytes(const unsigned char *src, unsigned char *dst_, int n)
87 /* dst must be properly aligned. */
88 u_int32_t *dst = (u_int32_t *) dst_;
94 /* Process 8 bytes every lap. */
95 for (n = n / 8; n > 0; n--) {
111 * Names of all encryption algorithms.
112 * These must match the numbers defined in cipher.h.
114 static char *cipher_names[] =
131 * Returns a bit mask indicating which ciphers are supported by this
132 * implementation. The bit mask has the corresponding bit set of each
139 unsigned int mask = 0;
140 mask |= 1 << SSH_CIPHER_3DES; /* Mandatory */
141 mask |= 1 << SSH_CIPHER_BLOWFISH;
147 unsigned int mask = 0;
148 mask |= 1 << SSH_CIPHER_BLOWFISH_CBC;
149 mask |= 1 << SSH_CIPHER_3DES_CBC;
150 mask |= 1 << SSH_CIPHER_ARCFOUR;
151 mask |= 1 << SSH_CIPHER_CAST128_CBC;
157 return cipher_mask1() | cipher_mask2();
160 /* Returns the name of the cipher. */
163 cipher_name(int cipher)
165 if (cipher < 0 || cipher >= sizeof(cipher_names) / sizeof(cipher_names[0]) ||
166 cipher_names[cipher] == NULL)
167 fatal("cipher_name: bad cipher name: %d", cipher);
168 return cipher_names[cipher];
171 /* Returns 1 if the name of the ciphers are valid. */
173 #define CIPHER_SEP ","
175 ciphers_valid(const char *names)
181 if (names == NULL || strcmp(names, "") == 0)
183 ciphers = cp = xstrdup(names);
184 for ((p = strsep(&cp, CIPHER_SEP)); p && *p != '\0';
185 (p = strsep(&cp, CIPHER_SEP))) {
186 i = cipher_number(p);
187 if (i == -1 || !(cipher_mask2() & (1 << i))) {
197 * Parses the name of the cipher. Returns the number of the corresponding
198 * cipher, or -1 on error.
202 cipher_number(const char *name)
207 for (i = 0; i < sizeof(cipher_names) / sizeof(cipher_names[0]); i++)
208 if (strcmp(cipher_names[i], name) == 0 &&
209 (cipher_mask() & (1 << i)))
215 * Selects the cipher, and keys if by computing the MD5 checksum of the
216 * passphrase and using the resulting 16 bytes as the key.
220 cipher_set_key_string(CipherContext *context, int cipher, const char *passphrase)
223 unsigned char digest[16];
226 MD5_Update(&md, (const unsigned char *) passphrase, strlen(passphrase));
227 MD5_Final(digest, &md);
229 cipher_set_key(context, cipher, digest, 16);
231 memset(digest, 0, sizeof(digest));
232 memset(&md, 0, sizeof(md));
235 /* Selects the cipher to use and sets the key. */
238 cipher_set_key(CipherContext *context, int cipher, const unsigned char *key,
241 unsigned char padded[32];
243 /* Set cipher type. */
244 context->type = cipher;
246 /* Get 32 bytes of key data. Pad if necessary. (So that code
247 below does not need to worry about key size). */
248 memset(padded, 0, sizeof(padded));
249 memcpy(padded, key, keylen < sizeof(padded) ? keylen : sizeof(padded));
251 /* Initialize the initialization vector. */
253 case SSH_CIPHER_NONE:
255 * Has to stay for authfile saving of private key with no
260 case SSH_CIPHER_3DES:
262 * Note: the least significant bit of each byte of key is
263 * parity, and must be ignored by the implementation. 16
264 * bytes of key are used (first and last keys are the same).
267 error("Key length %d is insufficient for 3DES.", keylen);
268 des_set_key((void *) padded, context->u.des3.key1);
269 des_set_key((void *) (padded + 8), context->u.des3.key2);
271 des_set_key((void *) padded, context->u.des3.key3);
273 des_set_key((void *) (padded + 16), context->u.des3.key3);
274 memset(context->u.des3.iv2, 0, sizeof(context->u.des3.iv2));
275 memset(context->u.des3.iv3, 0, sizeof(context->u.des3.iv3));
278 case SSH_CIPHER_BLOWFISH:
280 error("Key length %d is insufficient for blowfish.", keylen);
281 BF_set_key(&context->u.bf.key, keylen, padded);
282 memset(context->u.bf.iv, 0, 8);
285 case SSH_CIPHER_3DES_CBC:
286 case SSH_CIPHER_BLOWFISH_CBC:
287 case SSH_CIPHER_ARCFOUR:
288 case SSH_CIPHER_CAST128_CBC:
289 fatal("cipher_set_key: illegal cipher: %s", cipher_name(cipher));
293 fatal("cipher_set_key: unknown cipher: %s", cipher_name(cipher));
295 memset(padded, 0, sizeof(padded));
299 cipher_set_key_iv(CipherContext * context, int cipher,
300 const unsigned char *key, int keylen,
301 const unsigned char *iv, int ivlen)
303 /* Set cipher type. */
304 context->type = cipher;
306 /* Initialize the initialization vector. */
308 case SSH_CIPHER_NONE:
311 case SSH_CIPHER_3DES:
312 case SSH_CIPHER_BLOWFISH:
313 fatal("cipher_set_key_iv: illegal cipher: %s", cipher_name(cipher));
316 case SSH_CIPHER_3DES_CBC:
318 error("Key length %d is insufficient for 3des-cbc.", keylen);
319 des_set_key((void *) key, context->u.des3.key1);
320 des_set_key((void *) (key+8), context->u.des3.key2);
321 des_set_key((void *) (key+16), context->u.des3.key3);
323 error("IV length %d is insufficient for 3des-cbc.", ivlen);
324 memcpy(context->u.des3.iv3, (char *)iv, 8);
327 case SSH_CIPHER_BLOWFISH_CBC:
329 error("Key length %d is insufficient for blowfish.", keylen);
331 error("IV length %d is insufficient for blowfish.", ivlen);
332 BF_set_key(&context->u.bf.key, keylen, (unsigned char *)key);
333 memcpy(context->u.bf.iv, (char *)iv, 8);
336 case SSH_CIPHER_ARCFOUR:
338 error("Key length %d is insufficient for arcfour.", keylen);
339 RC4_set_key(&context->u.rc4, keylen, (unsigned char *)key);
342 case SSH_CIPHER_CAST128_CBC:
344 error("Key length %d is insufficient for cast128.", keylen);
346 error("IV length %d is insufficient for cast128.", ivlen);
347 CAST_set_key(&context->u.cast.key, keylen, (unsigned char *) key);
348 memcpy(context->u.cast.iv, (char *)iv, 8);
352 fatal("cipher_set_key: unknown cipher: %s", cipher_name(cipher));
356 /* Encrypts data using the cipher. */
359 cipher_encrypt(CipherContext *context, unsigned char *dest,
360 const unsigned char *src, unsigned int len)
363 fatal("cipher_encrypt: bad plaintext length %d", len);
365 switch (context->type) {
366 case SSH_CIPHER_NONE:
367 memcpy(dest, src, len);
370 case SSH_CIPHER_3DES:
371 SSH_3CBC_ENCRYPT(context->u.des3.key1,
372 context->u.des3.key2, &context->u.des3.iv2,
373 context->u.des3.key3, &context->u.des3.iv3,
374 dest, (unsigned char *) src, len);
377 case SSH_CIPHER_BLOWFISH:
378 swap_bytes(src, dest, len);
379 BF_cbc_encrypt(dest, dest, len,
380 &context->u.bf.key, context->u.bf.iv,
382 swap_bytes(dest, dest, len);
385 case SSH_CIPHER_BLOWFISH_CBC:
386 BF_cbc_encrypt((void *)src, dest, len,
387 &context->u.bf.key, context->u.bf.iv,
391 case SSH_CIPHER_3DES_CBC:
392 des_ede3_cbc_encrypt(src, dest, len,
393 context->u.des3.key1, context->u.des3.key2,
394 context->u.des3.key3, &context->u.des3.iv3, DES_ENCRYPT);
397 case SSH_CIPHER_ARCFOUR:
398 RC4(&context->u.rc4, len, (unsigned char *)src, dest);
401 case SSH_CIPHER_CAST128_CBC:
402 CAST_cbc_encrypt(src, dest, len,
403 &context->u.cast.key, context->u.cast.iv, CAST_ENCRYPT);
407 fatal("cipher_encrypt: unknown cipher: %s", cipher_name(context->type));
411 /* Decrypts data using the cipher. */
414 cipher_decrypt(CipherContext *context, unsigned char *dest,
415 const unsigned char *src, unsigned int len)
418 fatal("cipher_decrypt: bad ciphertext length %d", len);
420 switch (context->type) {
421 case SSH_CIPHER_NONE:
422 memcpy(dest, src, len);
425 case SSH_CIPHER_3DES:
426 SSH_3CBC_DECRYPT(context->u.des3.key1,
427 context->u.des3.key2, &context->u.des3.iv2,
428 context->u.des3.key3, &context->u.des3.iv3,
429 dest, (unsigned char *) src, len);
432 case SSH_CIPHER_BLOWFISH:
433 swap_bytes(src, dest, len);
434 BF_cbc_encrypt((void *) dest, dest, len,
435 &context->u.bf.key, context->u.bf.iv,
437 swap_bytes(dest, dest, len);
440 case SSH_CIPHER_BLOWFISH_CBC:
441 BF_cbc_encrypt((void *) src, dest, len,
442 &context->u.bf.key, context->u.bf.iv,
446 case SSH_CIPHER_3DES_CBC:
447 des_ede3_cbc_encrypt(src, dest, len,
448 context->u.des3.key1, context->u.des3.key2,
449 context->u.des3.key3, &context->u.des3.iv3, DES_DECRYPT);
452 case SSH_CIPHER_ARCFOUR:
453 RC4(&context->u.rc4, len, (unsigned char *)src, dest);
456 case SSH_CIPHER_CAST128_CBC:
457 CAST_cbc_encrypt(src, dest, len,
458 &context->u.cast.key, context->u.cast.iv, CAST_DECRYPT);
462 fatal("cipher_decrypt: unknown cipher: %s", cipher_name(context->type));