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.28 2000/06/20 01:39:40 markus 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 = xstrdup(names);
184 for ((p = strtok(ciphers, CIPHER_SEP)); p; (p = strtok(NULL, CIPHER_SEP))) {
185 i = cipher_number(p);
186 if (i == -1 || !(cipher_mask2() & (1 << i))) {
196 * Parses the name of the cipher. Returns the number of the corresponding
197 * cipher, or -1 on error.
201 cipher_number(const char *name)
206 for (i = 0; i < sizeof(cipher_names) / sizeof(cipher_names[0]); i++)
207 if (strcmp(cipher_names[i], name) == 0 &&
208 (cipher_mask() & (1 << i)))
214 * Selects the cipher, and keys if by computing the MD5 checksum of the
215 * passphrase and using the resulting 16 bytes as the key.
219 cipher_set_key_string(CipherContext *context, int cipher, const char *passphrase)
222 unsigned char digest[16];
225 MD5_Update(&md, (const unsigned char *) passphrase, strlen(passphrase));
226 MD5_Final(digest, &md);
228 cipher_set_key(context, cipher, digest, 16);
230 memset(digest, 0, sizeof(digest));
231 memset(&md, 0, sizeof(md));
234 /* Selects the cipher to use and sets the key. */
237 cipher_set_key(CipherContext *context, int cipher, const unsigned char *key,
240 unsigned char padded[32];
242 /* Set cipher type. */
243 context->type = cipher;
245 /* Get 32 bytes of key data. Pad if necessary. (So that code
246 below does not need to worry about key size). */
247 memset(padded, 0, sizeof(padded));
248 memcpy(padded, key, keylen < sizeof(padded) ? keylen : sizeof(padded));
250 /* Initialize the initialization vector. */
252 case SSH_CIPHER_NONE:
254 * Has to stay for authfile saving of private key with no
259 case SSH_CIPHER_3DES:
261 * Note: the least significant bit of each byte of key is
262 * parity, and must be ignored by the implementation. 16
263 * bytes of key are used (first and last keys are the same).
266 error("Key length %d is insufficient for 3DES.", keylen);
267 des_set_key((void *) padded, context->u.des3.key1);
268 des_set_key((void *) (padded + 8), context->u.des3.key2);
270 des_set_key((void *) padded, context->u.des3.key3);
272 des_set_key((void *) (padded + 16), context->u.des3.key3);
273 memset(context->u.des3.iv2, 0, sizeof(context->u.des3.iv2));
274 memset(context->u.des3.iv3, 0, sizeof(context->u.des3.iv3));
277 case SSH_CIPHER_BLOWFISH:
279 error("Key length %d is insufficient for blowfish.", keylen);
280 BF_set_key(&context->u.bf.key, keylen, padded);
281 memset(context->u.bf.iv, 0, 8);
284 case SSH_CIPHER_3DES_CBC:
285 case SSH_CIPHER_BLOWFISH_CBC:
286 case SSH_CIPHER_ARCFOUR:
287 case SSH_CIPHER_CAST128_CBC:
288 fatal("cipher_set_key: illegal cipher: %s", cipher_name(cipher));
292 fatal("cipher_set_key: unknown cipher: %s", cipher_name(cipher));
294 memset(padded, 0, sizeof(padded));
298 cipher_set_key_iv(CipherContext * context, int cipher,
299 const unsigned char *key, int keylen,
300 const unsigned char *iv, int ivlen)
302 /* Set cipher type. */
303 context->type = cipher;
305 /* Initialize the initialization vector. */
307 case SSH_CIPHER_NONE:
310 case SSH_CIPHER_3DES:
311 case SSH_CIPHER_BLOWFISH:
312 fatal("cipher_set_key_iv: illegal cipher: %s", cipher_name(cipher));
315 case SSH_CIPHER_3DES_CBC:
317 error("Key length %d is insufficient for 3des-cbc.", keylen);
318 des_set_key((void *) key, context->u.des3.key1);
319 des_set_key((void *) (key+8), context->u.des3.key2);
320 des_set_key((void *) (key+16), context->u.des3.key3);
322 error("IV length %d is insufficient for 3des-cbc.", ivlen);
323 memcpy(context->u.des3.iv3, (char *)iv, 8);
326 case SSH_CIPHER_BLOWFISH_CBC:
328 error("Key length %d is insufficient for blowfish.", keylen);
330 error("IV length %d is insufficient for blowfish.", ivlen);
331 BF_set_key(&context->u.bf.key, keylen, (unsigned char *)key);
332 memcpy(context->u.bf.iv, (char *)iv, 8);
335 case SSH_CIPHER_ARCFOUR:
337 error("Key length %d is insufficient for arcfour.", keylen);
338 RC4_set_key(&context->u.rc4, keylen, (unsigned char *)key);
341 case SSH_CIPHER_CAST128_CBC:
343 error("Key length %d is insufficient for cast128.", keylen);
345 error("IV length %d is insufficient for cast128.", ivlen);
346 CAST_set_key(&context->u.cast.key, keylen, (unsigned char *) key);
347 memcpy(context->u.cast.iv, (char *)iv, 8);
351 fatal("cipher_set_key: unknown cipher: %s", cipher_name(cipher));
355 /* Encrypts data using the cipher. */
358 cipher_encrypt(CipherContext *context, unsigned char *dest,
359 const unsigned char *src, unsigned int len)
362 fatal("cipher_encrypt: bad plaintext length %d", len);
364 switch (context->type) {
365 case SSH_CIPHER_NONE:
366 memcpy(dest, src, len);
369 case SSH_CIPHER_3DES:
370 SSH_3CBC_ENCRYPT(context->u.des3.key1,
371 context->u.des3.key2, &context->u.des3.iv2,
372 context->u.des3.key3, &context->u.des3.iv3,
373 dest, (unsigned char *) src, len);
376 case SSH_CIPHER_BLOWFISH:
377 swap_bytes(src, dest, len);
378 BF_cbc_encrypt(dest, dest, len,
379 &context->u.bf.key, context->u.bf.iv,
381 swap_bytes(dest, dest, len);
384 case SSH_CIPHER_BLOWFISH_CBC:
385 BF_cbc_encrypt((void *)src, dest, len,
386 &context->u.bf.key, context->u.bf.iv,
390 case SSH_CIPHER_3DES_CBC:
391 des_ede3_cbc_encrypt(src, dest, len,
392 context->u.des3.key1, context->u.des3.key2,
393 context->u.des3.key3, &context->u.des3.iv3, DES_ENCRYPT);
396 case SSH_CIPHER_ARCFOUR:
397 RC4(&context->u.rc4, len, (unsigned char *)src, dest);
400 case SSH_CIPHER_CAST128_CBC:
401 CAST_cbc_encrypt(src, dest, len,
402 &context->u.cast.key, context->u.cast.iv, CAST_ENCRYPT);
406 fatal("cipher_encrypt: unknown cipher: %s", cipher_name(context->type));
410 /* Decrypts data using the cipher. */
413 cipher_decrypt(CipherContext *context, unsigned char *dest,
414 const unsigned char *src, unsigned int len)
417 fatal("cipher_decrypt: bad ciphertext length %d", len);
419 switch (context->type) {
420 case SSH_CIPHER_NONE:
421 memcpy(dest, src, len);
424 case SSH_CIPHER_3DES:
425 SSH_3CBC_DECRYPT(context->u.des3.key1,
426 context->u.des3.key2, &context->u.des3.iv2,
427 context->u.des3.key3, &context->u.des3.iv3,
428 dest, (unsigned char *) src, len);
431 case SSH_CIPHER_BLOWFISH:
432 swap_bytes(src, dest, len);
433 BF_cbc_encrypt((void *) dest, dest, len,
434 &context->u.bf.key, context->u.bf.iv,
436 swap_bytes(dest, dest, len);
439 case SSH_CIPHER_BLOWFISH_CBC:
440 BF_cbc_encrypt((void *) src, dest, len,
441 &context->u.bf.key, context->u.bf.iv,
445 case SSH_CIPHER_3DES_CBC:
446 des_ede3_cbc_encrypt(src, dest, len,
447 context->u.des3.key1, context->u.des3.key2,
448 context->u.des3.key3, &context->u.des3.iv3, DES_DECRYPT);
451 case SSH_CIPHER_ARCFOUR:
452 RC4(&context->u.rc4, len, (unsigned char *)src, dest);
455 case SSH_CIPHER_CAST128_CBC:
456 CAST_cbc_encrypt(src, dest, len,
457 &context->u.cast.key, context->u.cast.iv, CAST_DECRYPT);
461 fatal("cipher_decrypt: unknown cipher: %s", cipher_name(context->type));