r16100: Patch from Michael Wood <mwood@icts.uct.ac.za>: s/then/than/ for correct...
[kai/samba.git] / source / heimdal / lib / krb5 / crypto.c
1 /*
2  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden). 
4  * All rights reserved. 
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met: 
9  *
10  * 1. Redistributions of source code must retain the above copyright 
11  *    notice, this list of conditions and the following disclaimer. 
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright 
14  *    notice, this list of conditions and the following disclaimer in the 
15  *    documentation and/or other materials provided with the distribution. 
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors 
18  *    may be used to endorse or promote products derived from this software 
19  *    without specific prior written permission. 
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
31  * SUCH DAMAGE. 
32  */
33
34 #include "krb5_locl.h"
35 RCSID("$Id: crypto.c,v 1.138 2006/05/08 13:47:24 lha Exp $");
36
37 #undef CRYPTO_DEBUG
38 #ifdef CRYPTO_DEBUG
39 static void krb5_crypto_debug(krb5_context, int, size_t, krb5_keyblock*);
40 #endif
41
42
43 struct key_data {
44     krb5_keyblock *key;
45     krb5_data *schedule;
46 };
47
48 struct key_usage {
49     unsigned usage;
50     struct key_data key;
51 };
52
53 struct krb5_crypto_data {
54     struct encryption_type *et;
55     struct key_data key;
56     int num_key_usage;
57     struct key_usage *key_usage;
58     void *params;
59 };
60
61 #define kcrypto_oid_enc(n) { sizeof(n)/sizeof(n[0]), n }
62
63 #define CRYPTO_ETYPE(C) ((C)->et->type)
64
65 /* bits for `flags' below */
66 #define F_KEYED          1      /* checksum is keyed */
67 #define F_CPROOF         2      /* checksum is collision proof */
68 #define F_DERIVED        4      /* uses derived keys */
69 #define F_VARIANT        8      /* uses `variant' keys (6.4.3) */
70 #define F_PSEUDO        16      /* not a real protocol type */
71 #define F_SPECIAL       32      /* backwards */
72 #define F_DISABLED      64      /* enctype/checksum disabled */
73
74 struct salt_type {
75     krb5_salttype type;
76     const char *name;
77     krb5_error_code (*string_to_key)(krb5_context, krb5_enctype, krb5_data, 
78                                      krb5_salt, krb5_data, krb5_keyblock*);
79 };
80
81 struct key_type {
82     krb5_keytype type; /* XXX */
83     const char *name;
84     size_t bits;
85     size_t size;
86     size_t minsize;
87     size_t schedule_size;
88 #if 0
89     krb5_enctype best_etype;
90 #endif
91     void (*random_key)(krb5_context, krb5_keyblock*);
92     void (*schedule)(krb5_context, struct key_data *, const void *);
93     struct salt_type *string_to_key;
94     void (*random_to_key)(krb5_context, krb5_keyblock*, const void*, size_t);
95     krb5_error_code (*get_params)(krb5_context, const krb5_data *,
96                                   void **, krb5_data *);
97     krb5_error_code (*set_params)(krb5_context, const void *,
98                                   const krb5_data *, krb5_data *);
99 };
100
101 struct checksum_type {
102     krb5_cksumtype type;
103     const char *name;
104     size_t blocksize;
105     size_t checksumsize;
106     unsigned flags;
107     void (*checksum)(krb5_context context,
108                      struct key_data *key,
109                      const void *buf, size_t len,
110                      unsigned usage,
111                      Checksum *csum);
112     krb5_error_code (*verify)(krb5_context context,
113                               struct key_data *key,
114                               const void *buf, size_t len,
115                               unsigned usage,
116                               Checksum *csum);
117 };
118
119 struct encryption_type {
120     krb5_enctype type;
121     const char *name;
122     heim_oid *oid;
123     size_t blocksize;
124     size_t padsize;
125     size_t confoundersize;
126     struct key_type *keytype;
127     struct checksum_type *checksum;
128     struct checksum_type *keyed_checksum;
129     unsigned flags;
130     krb5_error_code (*encrypt)(krb5_context context,
131                                struct key_data *key,
132                                void *data, size_t len,
133                                krb5_boolean encryptp,
134                                int usage,
135                                void *ivec);
136 };
137
138 #define ENCRYPTION_USAGE(U) (((U) << 8) | 0xAA)
139 #define INTEGRITY_USAGE(U) (((U) << 8) | 0x55)
140 #define CHECKSUM_USAGE(U) (((U) << 8) | 0x99)
141
142 static struct checksum_type *_find_checksum(krb5_cksumtype type);
143 static struct encryption_type *_find_enctype(krb5_enctype type);
144 static struct key_type *_find_keytype(krb5_keytype type);
145 static krb5_error_code _get_derived_key(krb5_context, krb5_crypto, 
146                                         unsigned, struct key_data**);
147 static struct key_data *_new_derived_key(krb5_crypto crypto, unsigned usage);
148 static krb5_error_code derive_key(krb5_context context,
149                                   struct encryption_type *et,
150                                   struct key_data *key,
151                                   const void *constant,
152                                   size_t len);
153 static krb5_error_code hmac(krb5_context context,
154                             struct checksum_type *cm, 
155                             const void *data, 
156                             size_t len, 
157                             unsigned usage,
158                             struct key_data *keyblock,
159                             Checksum *result);
160 static void free_key_data(krb5_context context, struct key_data *key);
161 static krb5_error_code usage2arcfour (krb5_context, unsigned *);
162 static void xor (DES_cblock *, const unsigned char *);
163
164 /************************************************************
165  *                                                          *
166  ************************************************************/
167
168 static HEIMDAL_MUTEX crypto_mutex = HEIMDAL_MUTEX_INITIALIZER;
169
170
171 static void
172 krb5_DES_random_key(krb5_context context,
173                krb5_keyblock *key)
174 {
175     DES_cblock *k = key->keyvalue.data;
176     do {
177         krb5_generate_random_block(k, sizeof(DES_cblock));
178         DES_set_odd_parity(k);
179     } while(DES_is_weak_key(k));
180 }
181
182 static void
183 krb5_DES_schedule(krb5_context context,
184                   struct key_data *key,
185                   const void *params)
186 {
187     DES_set_key(key->key->keyvalue.data, key->schedule->data);
188 }
189
190 #ifdef ENABLE_AFS_STRING_TO_KEY
191
192 /* This defines the Andrew string_to_key function.  It accepts a password
193  * string as input and converts its via a one-way encryption algorithm to a DES
194  * encryption key.  It is compatible with the original Andrew authentication
195  * service password database.
196  */
197
198 /*
199  * Short passwords, i.e 8 characters or less.
200  */
201 static void
202 krb5_DES_AFS3_CMU_string_to_key (krb5_data pw,
203                             krb5_data cell,
204                             DES_cblock *key)
205 {
206     char  password[8+1];        /* crypt is limited to 8 chars anyway */
207     int   i;
208     
209     for(i = 0; i < 8; i++) {
210         char c = ((i < pw.length) ? ((char*)pw.data)[i] : 0) ^
211                  ((i < cell.length) ?
212                   tolower(((unsigned char*)cell.data)[i]) : 0);
213         password[i] = c ? c : 'X';
214     }
215     password[8] = '\0';
216
217     memcpy(key, crypt(password, "p1") + 2, sizeof(DES_cblock));
218
219     /* parity is inserted into the LSB so left shift each byte up one
220        bit. This allows ascii characters with a zero MSB to retain as
221        much significance as possible. */
222     for (i = 0; i < sizeof(DES_cblock); i++)
223         ((unsigned char*)key)[i] <<= 1;
224     DES_set_odd_parity (key);
225 }
226
227 /*
228  * Long passwords, i.e 9 characters or more.
229  */
230 static void
231 krb5_DES_AFS3_Transarc_string_to_key (krb5_data pw,
232                                  krb5_data cell,
233                                  DES_cblock *key)
234 {
235     DES_key_schedule schedule;
236     DES_cblock temp_key;
237     DES_cblock ivec;
238     char password[512];
239     size_t passlen;
240
241     memcpy(password, pw.data, min(pw.length, sizeof(password)));
242     if(pw.length < sizeof(password)) {
243         int len = min(cell.length, sizeof(password) - pw.length);
244         int i;
245
246         memcpy(password + pw.length, cell.data, len);
247         for (i = pw.length; i < pw.length + len; ++i)
248             password[i] = tolower((unsigned char)password[i]);
249     }
250     passlen = min(sizeof(password), pw.length + cell.length);
251     memcpy(&ivec, "kerberos", 8);
252     memcpy(&temp_key, "kerberos", 8);
253     DES_set_odd_parity (&temp_key);
254     DES_set_key (&temp_key, &schedule);
255     DES_cbc_cksum ((void*)password, &ivec, passlen, &schedule, &ivec);
256
257     memcpy(&temp_key, &ivec, 8);
258     DES_set_odd_parity (&temp_key);
259     DES_set_key (&temp_key, &schedule);
260     DES_cbc_cksum ((void*)password, key, passlen, &schedule, &ivec);
261     memset(&schedule, 0, sizeof(schedule));
262     memset(&temp_key, 0, sizeof(temp_key));
263     memset(&ivec, 0, sizeof(ivec));
264     memset(password, 0, sizeof(password));
265
266     DES_set_odd_parity (key);
267 }
268
269 static krb5_error_code
270 DES_AFS3_string_to_key(krb5_context context,
271                        krb5_enctype enctype,
272                        krb5_data password,
273                        krb5_salt salt,
274                        krb5_data opaque,
275                        krb5_keyblock *key)
276 {
277     DES_cblock tmp;
278     if(password.length > 8)
279         krb5_DES_AFS3_Transarc_string_to_key(password, salt.saltvalue, &tmp);
280     else
281         krb5_DES_AFS3_CMU_string_to_key(password, salt.saltvalue, &tmp);
282     key->keytype = enctype;
283     krb5_data_copy(&key->keyvalue, tmp, sizeof(tmp));
284     memset(&key, 0, sizeof(key));
285     return 0;
286 }
287 #endif /* ENABLE_AFS_STRING_TO_KEY */
288
289 static void
290 DES_string_to_key_int(unsigned char *data, size_t length, DES_cblock *key)
291 {
292     DES_key_schedule schedule;
293     int i;
294     int reverse = 0;
295     unsigned char *p;
296
297     unsigned char swap[] = { 0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe, 
298                              0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf };
299     memset(key, 0, 8);
300     
301     p = (unsigned char*)key;
302     for (i = 0; i < length; i++) {
303         unsigned char tmp = data[i];
304         if (!reverse)
305             *p++ ^= (tmp << 1);
306         else
307             *--p ^= (swap[tmp & 0xf] << 4) | swap[(tmp & 0xf0) >> 4];
308         if((i % 8) == 7)
309             reverse = !reverse;
310     }
311     DES_set_odd_parity(key);
312     if(DES_is_weak_key(key))
313         (*key)[7] ^= 0xF0;
314     DES_set_key(key, &schedule);
315     DES_cbc_cksum((void*)data, key, length, &schedule, key);
316     memset(&schedule, 0, sizeof(schedule));
317     DES_set_odd_parity(key);
318     if(DES_is_weak_key(key))
319         (*key)[7] ^= 0xF0;
320 }
321
322 static krb5_error_code
323 krb5_DES_string_to_key(krb5_context context,
324                   krb5_enctype enctype,
325                   krb5_data password,
326                   krb5_salt salt,
327                   krb5_data opaque,
328                   krb5_keyblock *key)
329 {
330     unsigned char *s;
331     size_t len;
332     DES_cblock tmp;
333
334 #ifdef ENABLE_AFS_STRING_TO_KEY
335     if (opaque.length == 1) {
336         unsigned long v;
337         _krb5_get_int(opaque.data, &v, 1);
338         if (v == 1)
339             return DES_AFS3_string_to_key(context, enctype, password,
340                                           salt, opaque, key);
341     }
342 #endif
343
344     len = password.length + salt.saltvalue.length;
345     s = malloc(len);
346     if(len > 0 && s == NULL) {
347         krb5_set_error_string(context, "malloc: out of memory");
348         return ENOMEM;
349     }
350     memcpy(s, password.data, password.length);
351     memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length);
352     DES_string_to_key_int(s, len, &tmp);
353     key->keytype = enctype;
354     krb5_data_copy(&key->keyvalue, tmp, sizeof(tmp));
355     memset(&tmp, 0, sizeof(tmp));
356     memset(s, 0, len);
357     free(s);
358     return 0;
359 }
360
361 static void
362 krb5_DES_random_to_key(krb5_context context,
363                        krb5_keyblock *key,
364                        const void *data,
365                        size_t size)
366 {
367     DES_cblock *k = key->keyvalue.data;
368     memcpy(k, data, key->keyvalue.length);
369     DES_set_odd_parity(k);
370     if(DES_is_weak_key(k))
371         xor(k, (const unsigned char*)"\0\0\0\0\0\0\0\xf0");
372 }
373
374 /*
375  *
376  */
377
378 static void
379 DES3_random_key(krb5_context context,
380                 krb5_keyblock *key)
381 {
382     DES_cblock *k = key->keyvalue.data;
383     do {
384         krb5_generate_random_block(k, 3 * sizeof(DES_cblock));
385         DES_set_odd_parity(&k[0]);
386         DES_set_odd_parity(&k[1]);
387         DES_set_odd_parity(&k[2]);
388     } while(DES_is_weak_key(&k[0]) ||
389             DES_is_weak_key(&k[1]) ||
390             DES_is_weak_key(&k[2]));
391 }
392
393 static void
394 DES3_schedule(krb5_context context,
395               struct key_data *key,
396               const void *params)
397 {
398     DES_cblock *k = key->key->keyvalue.data;
399     DES_key_schedule *s = key->schedule->data;
400     DES_set_key(&k[0], &s[0]);
401     DES_set_key(&k[1], &s[1]);
402     DES_set_key(&k[2], &s[2]);
403 }
404
405 /*
406  * A = A xor B. A & B are 8 bytes.
407  */
408
409 static void
410 xor (DES_cblock *key, const unsigned char *b)
411 {
412     unsigned char *a = (unsigned char*)key;
413     a[0] ^= b[0];
414     a[1] ^= b[1];
415     a[2] ^= b[2];
416     a[3] ^= b[3];
417     a[4] ^= b[4];
418     a[5] ^= b[5];
419     a[6] ^= b[6];
420     a[7] ^= b[7];
421 }
422
423 static krb5_error_code
424 DES3_string_to_key(krb5_context context,
425                    krb5_enctype enctype,
426                    krb5_data password,
427                    krb5_salt salt,
428                    krb5_data opaque,
429                    krb5_keyblock *key)
430 {
431     char *str;
432     size_t len;
433     unsigned char tmp[24];
434     DES_cblock keys[3];
435     
436     len = password.length + salt.saltvalue.length;
437     str = malloc(len);
438     if(len != 0 && str == NULL) {
439         krb5_set_error_string(context, "malloc: out of memory");
440         return ENOMEM;
441     }
442     memcpy(str, password.data, password.length);
443     memcpy(str + password.length, salt.saltvalue.data, salt.saltvalue.length);
444     {
445         DES_cblock ivec;
446         DES_key_schedule s[3];
447         int i;
448         
449         _krb5_n_fold(str, len, tmp, 24);
450         
451         for(i = 0; i < 3; i++){
452             memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
453             DES_set_odd_parity(keys + i);
454             if(DES_is_weak_key(keys + i))
455                 xor(keys + i, (const unsigned char*)"\0\0\0\0\0\0\0\xf0");
456             DES_set_key(keys + i, &s[i]);
457         }
458         memset(&ivec, 0, sizeof(ivec));
459         DES_ede3_cbc_encrypt(tmp,
460                              tmp, sizeof(tmp), 
461                              &s[0], &s[1], &s[2], &ivec, DES_ENCRYPT);
462         memset(s, 0, sizeof(s));
463         memset(&ivec, 0, sizeof(ivec));
464         for(i = 0; i < 3; i++){
465             memcpy(keys + i, tmp + i * 8, sizeof(keys[i]));
466             DES_set_odd_parity(keys + i);
467             if(DES_is_weak_key(keys + i))
468                 xor(keys + i, (const unsigned char*)"\0\0\0\0\0\0\0\xf0");
469         }
470         memset(tmp, 0, sizeof(tmp));
471     }
472     key->keytype = enctype;
473     krb5_data_copy(&key->keyvalue, keys, sizeof(keys));
474     memset(keys, 0, sizeof(keys));
475     memset(str, 0, len);
476     free(str);
477     return 0;
478 }
479
480 static krb5_error_code
481 DES3_string_to_key_derived(krb5_context context,
482                            krb5_enctype enctype,
483                            krb5_data password,
484                            krb5_salt salt,
485                            krb5_data opaque,
486                            krb5_keyblock *key)
487 {
488     krb5_error_code ret;
489     size_t len = password.length + salt.saltvalue.length;
490     char *s;
491
492     s = malloc(len);
493     if(len != 0 && s == NULL) {
494         krb5_set_error_string(context, "malloc: out of memory");
495         return ENOMEM;
496     }
497     memcpy(s, password.data, password.length);
498     memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length);
499     ret = krb5_string_to_key_derived(context,
500                                      s,
501                                      len,
502                                      enctype,
503                                      key);
504     memset(s, 0, len);
505     free(s);
506     return ret;
507 }
508
509 static void
510 DES3_random_to_key(krb5_context context,
511                    krb5_keyblock *key,
512                    const void *data,
513                    size_t size)
514 {
515     unsigned char *x = key->keyvalue.data;
516     const u_char *q = data;
517     DES_cblock *k;
518     int i, j;
519
520     memset(x, 0, sizeof(x));
521     for (i = 0; i < 3; ++i) {
522         unsigned char foo;
523         for (j = 0; j < 7; ++j) {
524             unsigned char b = q[7 * i + j];
525
526             x[8 * i + j] = b;
527         }
528         foo = 0;
529         for (j = 6; j >= 0; --j) {
530             foo |= q[7 * i + j] & 1;
531             foo <<= 1;
532         }
533         x[8 * i + 7] = foo;
534     }
535     k = key->keyvalue.data;
536     for (i = 0; i < 3; i++) {
537         DES_set_odd_parity(&k[i]);
538         if(DES_is_weak_key(&k[i]))
539             xor(&k[i], (const unsigned char*)"\0\0\0\0\0\0\0\xf0");
540     }    
541 }
542
543 /*
544  * ARCFOUR
545  */
546
547 static void
548 ARCFOUR_schedule(krb5_context context, 
549                  struct key_data *kd,
550                  const void *params)
551 {
552     RC4_set_key (kd->schedule->data,
553                  kd->key->keyvalue.length, kd->key->keyvalue.data);
554 }
555
556 static krb5_error_code
557 ARCFOUR_string_to_key(krb5_context context,
558                   krb5_enctype enctype,
559                   krb5_data password,
560                   krb5_salt salt,
561                   krb5_data opaque,
562                   krb5_keyblock *key)
563 {
564     char *s, *p;
565     size_t len;
566     int i;
567     MD4_CTX m;
568
569     len = 2 * password.length;
570     s = malloc (len);
571     if (len != 0 && s == NULL) {
572         krb5_set_error_string(context, "malloc: out of memory");
573         return ENOMEM;
574     }
575     for (p = s, i = 0; i < password.length; ++i) {
576         *p++ = ((char *)password.data)[i];
577         *p++ = 0;
578     }
579     MD4_Init (&m);
580     MD4_Update (&m, s, len);
581     key->keytype = enctype;
582     krb5_data_alloc (&key->keyvalue, 16);
583     MD4_Final (key->keyvalue.data, &m);
584     memset (s, 0, len);
585     free (s);
586     return 0;
587 }
588
589 /*
590  * AES
591  */
592
593 int _krb5_AES_string_to_default_iterator = 4096;
594
595 static krb5_error_code
596 AES_string_to_key(krb5_context context,
597                   krb5_enctype enctype,
598                   krb5_data password,
599                   krb5_salt salt,
600                   krb5_data opaque,
601                   krb5_keyblock *key)
602 {
603     krb5_error_code ret;
604     uint32_t iter;
605     struct encryption_type *et;
606     struct key_data kd;
607
608     if (opaque.length == 0)
609         iter = _krb5_AES_string_to_default_iterator;
610     else if (opaque.length == 4) {
611         unsigned long v;
612         _krb5_get_int(opaque.data, &v, 4);
613         iter = ((uint32_t)v);
614     } else
615         return KRB5_PROG_KEYTYPE_NOSUPP; /* XXX */
616         
617     et = _find_enctype(enctype);
618     if (et == NULL)
619         return KRB5_PROG_KEYTYPE_NOSUPP;
620
621     key->keytype = enctype;
622     ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
623     if (ret) {
624         krb5_set_error_string(context, "Failed to allocate pkcs5 key");
625         return ret;
626     }
627     ret = krb5_copy_keyblock(context, key, &kd.key);
628     if (ret) {
629         krb5_free_keyblock(context, key);
630         return ret;
631     }
632
633     ret = PKCS5_PBKDF2_HMAC_SHA1(password.data, password.length,
634                                  salt.saltvalue.data, salt.saltvalue.length,
635                                  iter, 
636                                  et->keytype->size, kd.key->keyvalue.data);
637     kd.schedule = NULL;
638     if (ret != 1) {
639         krb5_set_error_string(context, "Error calculating s2k");
640         return KRB5_PROG_KEYTYPE_NOSUPP;
641     }
642
643     ret = derive_key(context, et, &kd, "kerberos", strlen("kerberos"));
644     if (ret == 0)
645         ret = krb5_copy_keyblock_contents(context, kd.key, key);
646     free_key_data(context, &kd);
647
648     return ret;
649 }
650
651 struct krb5_aes_schedule {
652     AES_KEY ekey;
653     AES_KEY dkey;
654 };
655
656 static void
657 AES_schedule(krb5_context context,
658              struct key_data *kd,
659              const void *params)
660 {
661     struct krb5_aes_schedule *key = kd->schedule->data;
662     int bits = kd->key->keyvalue.length * 8;
663
664     memset(key, 0, sizeof(*key));
665     AES_set_encrypt_key(kd->key->keyvalue.data, bits, &key->ekey);
666     AES_set_decrypt_key(kd->key->keyvalue.data, bits, &key->dkey);
667 }
668
669 /*
670  * RC2
671  */
672
673 struct _RC2_params {
674     int maximum_effective_key;
675 };
676
677 static krb5_error_code
678 rc2_get_params(krb5_context context,
679                const krb5_data *data,
680                void **params,
681                krb5_data *ivec)
682 {
683     RC2CBCParameter rc2params;
684     struct _RC2_params *p;
685     krb5_error_code ret;
686     size_t size;
687
688     ret = decode_RC2CBCParameter(data->data, data->length, &rc2params, &size);
689     if (ret) {
690         krb5_set_error_string(context, "Can't decode RC2 parameters");
691         return ret;
692     }
693     p = malloc(sizeof(*p));
694     if (p == NULL) {
695         free_RC2CBCParameter(&rc2params);
696         krb5_set_error_string(context, "malloc - out of memory");
697         return ENOMEM;
698     }
699     /* XXX  */
700     switch(rc2params.rc2ParameterVersion) {
701     case 160:
702         p->maximum_effective_key = 40;
703         break;
704     case 120:
705         p->maximum_effective_key = 64;
706         break;
707     case 58:
708         p->maximum_effective_key = 128;
709         break;
710         
711     }
712     if (ivec)
713         ret = copy_octet_string(&rc2params.iv, ivec);
714     free_RC2CBCParameter(&rc2params);
715     *params = p;
716
717     return ret;
718 }
719
720 static krb5_error_code
721 rc2_set_params(krb5_context context,
722                const void *params,
723                const krb5_data *ivec,
724                krb5_data *data)
725 {
726     RC2CBCParameter rc2params;
727     const struct _RC2_params *p = params;
728     int maximum_effective_key = 128;
729     krb5_error_code ret;
730     size_t size;
731
732     memset(&rc2params, 0, sizeof(rc2params));
733
734     if (p)
735         maximum_effective_key = p->maximum_effective_key;
736
737     /* XXX */
738     switch(maximum_effective_key) {
739     case 40:
740         rc2params.rc2ParameterVersion = 160;
741         break;
742     case 64:
743         rc2params.rc2ParameterVersion = 120;
744         break;
745     case 128:
746         rc2params.rc2ParameterVersion = 58;
747         break;
748     }
749     ret = copy_octet_string(ivec, &rc2params.iv);
750     if (ret)
751         return ret;
752
753     ASN1_MALLOC_ENCODE(RC2CBCParameter, data->data, data->length,
754                        &rc2params, &size, ret);
755     if (ret == 0 && size != data->length)
756         krb5_abortx(context, "Internal asn1 encoder failure");
757     free_RC2CBCParameter(&rc2params);
758
759     return ret;
760 }
761
762 static void
763 rc2_schedule(krb5_context context,
764              struct key_data *kd,
765              const void *params)
766 {
767     const struct _RC2_params *p = params;
768     int maximum_effective_key = 128;
769     if (p)
770         maximum_effective_key = p->maximum_effective_key;
771     RC2_set_key (kd->schedule->data,
772                  kd->key->keyvalue.length,
773                  kd->key->keyvalue.data,
774                  maximum_effective_key);
775 }
776
777
778 /*
779  *
780  */
781
782 static struct salt_type des_salt[] = {
783     {
784         KRB5_PW_SALT,
785         "pw-salt",
786         krb5_DES_string_to_key
787     },
788 #ifdef ENABLE_AFS_STRING_TO_KEY
789     {
790         KRB5_AFS3_SALT,
791         "afs3-salt",
792         DES_AFS3_string_to_key
793     },
794 #endif
795     { 0 }
796 };
797
798 static struct salt_type des3_salt[] = {
799     {
800         KRB5_PW_SALT,
801         "pw-salt",
802         DES3_string_to_key
803     },
804     { 0 }
805 };
806
807 static struct salt_type des3_salt_derived[] = {
808     {
809         KRB5_PW_SALT,
810         "pw-salt",
811         DES3_string_to_key_derived
812     },
813     { 0 }
814 };
815
816 static struct salt_type AES_salt[] = {
817     {
818         KRB5_PW_SALT,
819         "pw-salt",
820         AES_string_to_key
821     },
822     { 0 }
823 };
824
825 static struct salt_type arcfour_salt[] = {
826     {
827         KRB5_PW_SALT,
828         "pw-salt",
829         ARCFOUR_string_to_key
830     },
831     { 0 }
832 };
833
834 /*
835  *
836  */
837
838 static struct key_type keytype_null = {
839     KEYTYPE_NULL,
840     "null",
841     0,
842     0,
843     0,
844     0,
845     NULL,
846     NULL,
847     NULL
848 };
849
850 static struct key_type keytype_des = {
851     KEYTYPE_DES,
852     "des",
853     56,
854     sizeof(DES_cblock),
855     sizeof(DES_cblock),
856     sizeof(DES_key_schedule),
857     krb5_DES_random_key,
858     krb5_DES_schedule,
859     des_salt,
860     krb5_DES_random_to_key
861 };
862
863 static struct key_type keytype_des3 = {
864     KEYTYPE_DES3,
865     "des3",
866     168,
867     3 * sizeof(DES_cblock), 
868     3 * sizeof(DES_cblock), 
869     3 * sizeof(DES_key_schedule), 
870     DES3_random_key,
871     DES3_schedule,
872     des3_salt,
873     DES3_random_to_key
874 };
875
876 static struct key_type keytype_des3_derived = {
877     KEYTYPE_DES3,
878     "des3",
879     168,
880     3 * sizeof(DES_cblock),
881     3 * sizeof(DES_cblock),
882     3 * sizeof(DES_key_schedule), 
883     DES3_random_key,
884     DES3_schedule,
885     des3_salt_derived,
886     DES3_random_to_key
887 };
888
889 static struct key_type keytype_aes128 = {
890     KEYTYPE_AES128,
891     "aes-128",
892     128,
893     16,
894     16,
895     sizeof(struct krb5_aes_schedule),
896     NULL,
897     AES_schedule,
898     AES_salt
899 };
900
901 static struct key_type keytype_aes192 = {
902     KEYTYPE_AES192,
903     "aes-192",
904     192,
905     24,
906     24,
907     sizeof(struct krb5_aes_schedule),
908     NULL,
909     AES_schedule,
910     AES_salt
911 };
912
913 static struct key_type keytype_aes256 = {
914     KEYTYPE_AES256,
915     "aes-256",
916     256,
917     32,
918     32,
919     sizeof(struct krb5_aes_schedule),
920     NULL,
921     AES_schedule,
922     AES_salt
923 };
924
925 static struct key_type keytype_arcfour = {
926     KEYTYPE_ARCFOUR,
927     "arcfour",
928     128,
929     16,
930     16,
931     sizeof(RC4_KEY),
932     NULL,
933     ARCFOUR_schedule,
934     arcfour_salt
935 };
936
937 static struct key_type keytype_rc2 = {
938     KEYTYPE_RC2,
939     "rc2",
940     128,
941     16,
942     1,
943     sizeof(RC2_KEY),
944     NULL,
945     rc2_schedule,
946     NULL, /* XXX salt */
947     NULL,
948     rc2_get_params,
949     rc2_set_params
950 };
951
952 static struct key_type *keytypes[] = {
953     &keytype_null,
954     &keytype_des,
955     &keytype_des3_derived,
956     &keytype_des3,
957     &keytype_aes128,
958     &keytype_aes192,
959     &keytype_aes256,
960     &keytype_rc2,
961     &keytype_arcfour
962 };
963
964 static int num_keytypes = sizeof(keytypes) / sizeof(keytypes[0]);
965
966 static struct key_type *
967 _find_keytype(krb5_keytype type)
968 {
969     int i;
970     for(i = 0; i < num_keytypes; i++)
971         if(keytypes[i]->type == type)
972             return keytypes[i];
973     return NULL;
974 }
975
976
977 krb5_error_code KRB5_LIB_FUNCTION
978 krb5_salttype_to_string (krb5_context context,
979                          krb5_enctype etype,
980                          krb5_salttype stype,
981                          char **string)
982 {
983     struct encryption_type *e;
984     struct salt_type *st;
985
986     e = _find_enctype (etype);
987     if (e == NULL) {
988         krb5_set_error_string(context, "encryption type %d not supported",
989                               etype);
990         return KRB5_PROG_ETYPE_NOSUPP;
991     }
992     for (st = e->keytype->string_to_key; st && st->type; st++) {
993         if (st->type == stype) {
994             *string = strdup (st->name);
995             if (*string == NULL) {
996                 krb5_set_error_string(context, "malloc: out of memory");
997                 return ENOMEM;
998             }
999             return 0;
1000         }
1001     }
1002     krb5_set_error_string(context, "salttype %d not supported", stype);
1003     return HEIM_ERR_SALTTYPE_NOSUPP;
1004 }
1005
1006 krb5_error_code KRB5_LIB_FUNCTION
1007 krb5_string_to_salttype (krb5_context context,
1008                          krb5_enctype etype,
1009                          const char *string,
1010                          krb5_salttype *salttype)
1011 {
1012     struct encryption_type *e;
1013     struct salt_type *st;
1014
1015     e = _find_enctype (etype);
1016     if (e == NULL) {
1017         krb5_set_error_string(context, "encryption type %d not supported",
1018                               etype);
1019         return KRB5_PROG_ETYPE_NOSUPP;
1020     }
1021     for (st = e->keytype->string_to_key; st && st->type; st++) {
1022         if (strcasecmp (st->name, string) == 0) {
1023             *salttype = st->type;
1024             return 0;
1025         }
1026     }
1027     krb5_set_error_string(context, "salttype %s not supported", string);
1028     return HEIM_ERR_SALTTYPE_NOSUPP;
1029 }
1030
1031 krb5_error_code KRB5_LIB_FUNCTION
1032 krb5_get_pw_salt(krb5_context context,
1033                  krb5_const_principal principal,
1034                  krb5_salt *salt)
1035 {
1036     size_t len;
1037     int i;
1038     krb5_error_code ret;
1039     char *p;
1040      
1041     salt->salttype = KRB5_PW_SALT;
1042     len = strlen(principal->realm);
1043     for (i = 0; i < principal->name.name_string.len; ++i)
1044         len += strlen(principal->name.name_string.val[i]);
1045     ret = krb5_data_alloc (&salt->saltvalue, len);
1046     if (ret)
1047         return ret;
1048     p = salt->saltvalue.data;
1049     memcpy (p, principal->realm, strlen(principal->realm));
1050     p += strlen(principal->realm);
1051     for (i = 0; i < principal->name.name_string.len; ++i) {
1052         memcpy (p,
1053                 principal->name.name_string.val[i],
1054                 strlen(principal->name.name_string.val[i]));
1055         p += strlen(principal->name.name_string.val[i]);
1056     }
1057     return 0;
1058 }
1059
1060 krb5_error_code KRB5_LIB_FUNCTION
1061 krb5_free_salt(krb5_context context, 
1062                krb5_salt salt)
1063 {
1064     krb5_data_free(&salt.saltvalue);
1065     return 0;
1066 }
1067
1068 krb5_error_code KRB5_LIB_FUNCTION
1069 krb5_string_to_key_data (krb5_context context,
1070                          krb5_enctype enctype,
1071                          krb5_data password,
1072                          krb5_principal principal,
1073                          krb5_keyblock *key)
1074 {
1075     krb5_error_code ret;
1076     krb5_salt salt;
1077
1078     ret = krb5_get_pw_salt(context, principal, &salt);
1079     if(ret)
1080         return ret;
1081     ret = krb5_string_to_key_data_salt(context, enctype, password, salt, key);
1082     krb5_free_salt(context, salt);
1083     return ret;
1084 }
1085
1086 krb5_error_code KRB5_LIB_FUNCTION
1087 krb5_string_to_key (krb5_context context,
1088                     krb5_enctype enctype,
1089                     const char *password,
1090                     krb5_principal principal,
1091                     krb5_keyblock *key)
1092 {
1093     krb5_data pw;
1094     pw.data = rk_UNCONST(password);
1095     pw.length = strlen(password);
1096     return krb5_string_to_key_data(context, enctype, pw, principal, key);
1097 }
1098
1099 krb5_error_code KRB5_LIB_FUNCTION
1100 krb5_string_to_key_data_salt (krb5_context context,
1101                               krb5_enctype enctype,
1102                               krb5_data password,
1103                               krb5_salt salt,
1104                               krb5_keyblock *key)
1105 {
1106     krb5_data opaque;
1107     krb5_data_zero(&opaque);
1108     return krb5_string_to_key_data_salt_opaque(context, enctype, password, 
1109                                                salt, opaque, key);
1110 }
1111
1112 /*
1113  * Do a string -> key for encryption type `enctype' operation on
1114  * `password' (with salt `salt' and the enctype specific data string
1115  * `opaque'), returning the resulting key in `key'
1116  */
1117
1118 krb5_error_code KRB5_LIB_FUNCTION
1119 krb5_string_to_key_data_salt_opaque (krb5_context context,
1120                                      krb5_enctype enctype,
1121                                      krb5_data password,
1122                                      krb5_salt salt,
1123                                      krb5_data opaque,
1124                                      krb5_keyblock *key)
1125 {
1126     struct encryption_type *et =_find_enctype(enctype);
1127     struct salt_type *st;
1128     if(et == NULL) {
1129         krb5_set_error_string(context, "encryption type %d not supported",
1130                               enctype);
1131         return KRB5_PROG_ETYPE_NOSUPP;
1132     }
1133     for(st = et->keytype->string_to_key; st && st->type; st++) 
1134         if(st->type == salt.salttype)
1135             return (*st->string_to_key)(context, enctype, password, 
1136                                         salt, opaque, key);
1137     krb5_set_error_string(context, "salt type %d not supported",
1138                           salt.salttype);
1139     return HEIM_ERR_SALTTYPE_NOSUPP;
1140 }
1141
1142 /*
1143  * Do a string -> key for encryption type `enctype' operation on the
1144  * string `password' (with salt `salt'), returning the resulting key
1145  * in `key'
1146  */
1147
1148 krb5_error_code KRB5_LIB_FUNCTION
1149 krb5_string_to_key_salt (krb5_context context,
1150                          krb5_enctype enctype,
1151                          const char *password,
1152                          krb5_salt salt,
1153                          krb5_keyblock *key)
1154 {
1155     krb5_data pw;
1156     pw.data = rk_UNCONST(password);
1157     pw.length = strlen(password);
1158     return krb5_string_to_key_data_salt(context, enctype, pw, salt, key);
1159 }
1160
1161 krb5_error_code KRB5_LIB_FUNCTION
1162 krb5_string_to_key_salt_opaque (krb5_context context,
1163                                 krb5_enctype enctype,
1164                                 const char *password,
1165                                 krb5_salt salt,
1166                                 krb5_data opaque,
1167                                 krb5_keyblock *key)
1168 {
1169     krb5_data pw;
1170     pw.data = rk_UNCONST(password);
1171     pw.length = strlen(password);
1172     return krb5_string_to_key_data_salt_opaque(context, enctype, 
1173                                                pw, salt, opaque, key);
1174 }
1175
1176 krb5_error_code KRB5_LIB_FUNCTION
1177 krb5_keytype_to_string(krb5_context context,
1178                        krb5_keytype keytype,
1179                        char **string)
1180 {
1181     struct key_type *kt = _find_keytype(keytype);
1182     if(kt == NULL) {
1183         krb5_set_error_string(context, "key type %d not supported", keytype);
1184         return KRB5_PROG_KEYTYPE_NOSUPP;
1185     }
1186     *string = strdup(kt->name);
1187     if(*string == NULL) {
1188         krb5_set_error_string(context, "malloc: out of memory");
1189         return ENOMEM;
1190     }
1191     return 0;
1192 }
1193
1194 krb5_error_code KRB5_LIB_FUNCTION
1195 krb5_string_to_keytype(krb5_context context,
1196                        const char *string,
1197                        krb5_keytype *keytype)
1198 {
1199     int i;
1200     for(i = 0; i < num_keytypes; i++)
1201         if(strcasecmp(keytypes[i]->name, string) == 0){
1202             *keytype = keytypes[i]->type;
1203             return 0;
1204         }
1205     krb5_set_error_string(context, "key type %s not supported", string);
1206     return KRB5_PROG_KEYTYPE_NOSUPP;
1207 }
1208
1209 krb5_error_code KRB5_LIB_FUNCTION
1210 krb5_enctype_keysize(krb5_context context,
1211                      krb5_enctype type,
1212                      size_t *keysize)
1213 {
1214     struct encryption_type *et = _find_enctype(type);
1215     if(et == NULL) {
1216         krb5_set_error_string(context, "encryption type %d not supported",
1217                               type);
1218         return KRB5_PROG_ETYPE_NOSUPP;
1219     }
1220     *keysize = et->keytype->size;
1221     return 0;
1222 }
1223
1224 krb5_error_code KRB5_LIB_FUNCTION
1225 krb5_generate_random_keyblock(krb5_context context,
1226                               krb5_enctype type,
1227                               krb5_keyblock *key)
1228 {
1229     krb5_error_code ret;
1230     struct encryption_type *et = _find_enctype(type);
1231     if(et == NULL) {
1232         krb5_set_error_string(context, "encryption type %d not supported",
1233                               type);
1234         return KRB5_PROG_ETYPE_NOSUPP;
1235     }
1236     ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
1237     if(ret) 
1238         return ret;
1239     key->keytype = type;
1240     if(et->keytype->random_key)
1241         (*et->keytype->random_key)(context, key);
1242     else
1243         krb5_generate_random_block(key->keyvalue.data, 
1244                                    key->keyvalue.length);
1245     return 0;
1246 }
1247
1248 static krb5_error_code
1249 _key_schedule(krb5_context context,
1250               struct key_data *key,
1251               const void *params)
1252 {
1253     krb5_error_code ret;
1254     struct encryption_type *et = _find_enctype(key->key->keytype);
1255     struct key_type *kt = et->keytype;
1256
1257     if(kt->schedule == NULL)
1258         return 0;
1259     if (key->schedule != NULL)
1260         return 0;
1261     ALLOC(key->schedule, 1);
1262     if(key->schedule == NULL) {
1263         krb5_set_error_string(context, "malloc: out of memory");
1264         return ENOMEM;
1265     }
1266     ret = krb5_data_alloc(key->schedule, kt->schedule_size);
1267     if(ret) {
1268         free(key->schedule);
1269         key->schedule = NULL;
1270         return ret;
1271     }
1272     (*kt->schedule)(context, key, params);
1273     return 0;
1274 }
1275
1276 /************************************************************
1277  *                                                          *
1278  ************************************************************/
1279
1280 static void
1281 NONE_checksum(krb5_context context,
1282               struct key_data *key,
1283               const void *data,
1284               size_t len,
1285               unsigned usage,
1286               Checksum *C)
1287 {
1288 }
1289
1290 static void
1291 CRC32_checksum(krb5_context context,
1292                struct key_data *key,
1293                const void *data,
1294                size_t len,
1295                unsigned usage,
1296                Checksum *C)
1297 {
1298     uint32_t crc;
1299     unsigned char *r = C->checksum.data;
1300     _krb5_crc_init_table ();
1301     crc = _krb5_crc_update (data, len, 0);
1302     r[0] = crc & 0xff;
1303     r[1] = (crc >> 8)  & 0xff;
1304     r[2] = (crc >> 16) & 0xff;
1305     r[3] = (crc >> 24) & 0xff;
1306 }
1307
1308 static void
1309 RSA_MD4_checksum(krb5_context context,
1310                  struct key_data *key,
1311                  const void *data,
1312                  size_t len,
1313                  unsigned usage,
1314                  Checksum *C)
1315 {
1316     MD4_CTX m;
1317
1318     MD4_Init (&m);
1319     MD4_Update (&m, data, len);
1320     MD4_Final (C->checksum.data, &m);
1321 }
1322
1323 static void
1324 RSA_MD4_DES_checksum(krb5_context context, 
1325                      struct key_data *key,
1326                      const void *data, 
1327                      size_t len, 
1328                      unsigned usage,
1329                      Checksum *cksum)
1330 {
1331     MD4_CTX md4;
1332     DES_cblock ivec;
1333     unsigned char *p = cksum->checksum.data;
1334     
1335     krb5_generate_random_block(p, 8);
1336     MD4_Init (&md4);
1337     MD4_Update (&md4, p, 8);
1338     MD4_Update (&md4, data, len);
1339     MD4_Final (p + 8, &md4);
1340     memset (&ivec, 0, sizeof(ivec));
1341     DES_cbc_encrypt(p, 
1342                     p, 
1343                     24, 
1344                     key->schedule->data, 
1345                     &ivec, 
1346                     DES_ENCRYPT);
1347 }
1348
1349 static krb5_error_code
1350 RSA_MD4_DES_verify(krb5_context context,
1351                    struct key_data *key,
1352                    const void *data,
1353                    size_t len,
1354                    unsigned usage,
1355                    Checksum *C)
1356 {
1357     MD4_CTX md4;
1358     unsigned char tmp[24];
1359     unsigned char res[16];
1360     DES_cblock ivec;
1361     krb5_error_code ret = 0;
1362
1363     memset(&ivec, 0, sizeof(ivec));
1364     DES_cbc_encrypt(C->checksum.data,
1365                     (void*)tmp, 
1366                     C->checksum.length, 
1367                     key->schedule->data,
1368                     &ivec,
1369                     DES_DECRYPT);
1370     MD4_Init (&md4);
1371     MD4_Update (&md4, tmp, 8); /* confounder */
1372     MD4_Update (&md4, data, len);
1373     MD4_Final (res, &md4);
1374     if(memcmp(res, tmp + 8, sizeof(res)) != 0) {
1375         krb5_clear_error_string (context);
1376         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1377     }
1378     memset(tmp, 0, sizeof(tmp));
1379     memset(res, 0, sizeof(res));
1380     return ret;
1381 }
1382
1383 static void
1384 RSA_MD5_checksum(krb5_context context,
1385                  struct key_data *key,
1386                  const void *data,
1387                  size_t len,
1388                  unsigned usage,
1389                  Checksum *C)
1390 {
1391     MD5_CTX m;
1392
1393     MD5_Init  (&m);
1394     MD5_Update(&m, data, len);
1395     MD5_Final (C->checksum.data, &m);
1396 }
1397
1398 static void
1399 RSA_MD5_DES_checksum(krb5_context context,
1400                      struct key_data *key,
1401                      const void *data,
1402                      size_t len,
1403                      unsigned usage,
1404                      Checksum *C)
1405 {
1406     MD5_CTX md5;
1407     DES_cblock ivec;
1408     unsigned char *p = C->checksum.data;
1409     
1410     krb5_generate_random_block(p, 8);
1411     MD5_Init (&md5);
1412     MD5_Update (&md5, p, 8);
1413     MD5_Update (&md5, data, len);
1414     MD5_Final (p + 8, &md5);
1415     memset (&ivec, 0, sizeof(ivec));
1416     DES_cbc_encrypt(p, 
1417                     p, 
1418                     24, 
1419                     key->schedule->data, 
1420                     &ivec, 
1421                     DES_ENCRYPT);
1422 }
1423
1424 static krb5_error_code
1425 RSA_MD5_DES_verify(krb5_context context,
1426                    struct key_data *key,
1427                    const void *data,
1428                    size_t len,
1429                    unsigned usage,
1430                    Checksum *C)
1431 {
1432     MD5_CTX md5;
1433     unsigned char tmp[24];
1434     unsigned char res[16];
1435     DES_cblock ivec;
1436     DES_key_schedule *sched = key->schedule->data;
1437     krb5_error_code ret = 0;
1438
1439     memset(&ivec, 0, sizeof(ivec));
1440     DES_cbc_encrypt(C->checksum.data, 
1441                     (void*)tmp, 
1442                     C->checksum.length, 
1443                     &sched[0],
1444                     &ivec,
1445                     DES_DECRYPT);
1446     MD5_Init (&md5);
1447     MD5_Update (&md5, tmp, 8); /* confounder */
1448     MD5_Update (&md5, data, len);
1449     MD5_Final (res, &md5);
1450     if(memcmp(res, tmp + 8, sizeof(res)) != 0) {
1451         krb5_clear_error_string (context);
1452         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1453     }
1454     memset(tmp, 0, sizeof(tmp));
1455     memset(res, 0, sizeof(res));
1456     return ret;
1457 }
1458
1459 static void
1460 RSA_MD5_DES3_checksum(krb5_context context,
1461                       struct key_data *key,
1462                       const void *data,
1463                       size_t len,
1464                       unsigned usage,
1465                       Checksum *C)
1466 {
1467     MD5_CTX md5;
1468     DES_cblock ivec;
1469     unsigned char *p = C->checksum.data;
1470     DES_key_schedule *sched = key->schedule->data;
1471     
1472     krb5_generate_random_block(p, 8);
1473     MD5_Init (&md5);
1474     MD5_Update (&md5, p, 8);
1475     MD5_Update (&md5, data, len);
1476     MD5_Final (p + 8, &md5);
1477     memset (&ivec, 0, sizeof(ivec));
1478     DES_ede3_cbc_encrypt(p, 
1479                          p, 
1480                          24, 
1481                          &sched[0], &sched[1], &sched[2],
1482                          &ivec, 
1483                          DES_ENCRYPT);
1484 }
1485
1486 static krb5_error_code
1487 RSA_MD5_DES3_verify(krb5_context context,
1488                     struct key_data *key,
1489                     const void *data,
1490                     size_t len,
1491                     unsigned usage,
1492                     Checksum *C)
1493 {
1494     MD5_CTX md5;
1495     unsigned char tmp[24];
1496     unsigned char res[16];
1497     DES_cblock ivec;
1498     DES_key_schedule *sched = key->schedule->data;
1499     krb5_error_code ret = 0;
1500
1501     memset(&ivec, 0, sizeof(ivec));
1502     DES_ede3_cbc_encrypt(C->checksum.data, 
1503                          (void*)tmp, 
1504                          C->checksum.length, 
1505                          &sched[0], &sched[1], &sched[2],
1506                          &ivec,
1507                          DES_DECRYPT);
1508     MD5_Init (&md5);
1509     MD5_Update (&md5, tmp, 8); /* confounder */
1510     MD5_Update (&md5, data, len);
1511     MD5_Final (res, &md5);
1512     if(memcmp(res, tmp + 8, sizeof(res)) != 0) {
1513         krb5_clear_error_string (context);
1514         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1515     }
1516     memset(tmp, 0, sizeof(tmp));
1517     memset(res, 0, sizeof(res));
1518     return ret;
1519 }
1520
1521 static void
1522 SHA1_checksum(krb5_context context,
1523               struct key_data *key,
1524               const void *data,
1525               size_t len,
1526               unsigned usage,
1527               Checksum *C)
1528 {
1529     SHA_CTX m;
1530
1531     SHA1_Init(&m);
1532     SHA1_Update(&m, data, len);
1533     SHA1_Final(C->checksum.data, &m);
1534 }
1535
1536 /* HMAC according to RFC2104 */
1537 static krb5_error_code
1538 hmac(krb5_context context,
1539      struct checksum_type *cm, 
1540      const void *data, 
1541      size_t len, 
1542      unsigned usage,
1543      struct key_data *keyblock,
1544      Checksum *result)
1545 {
1546     unsigned char *ipad, *opad;
1547     unsigned char *key;
1548     size_t key_len;
1549     int i;
1550     
1551     ipad = malloc(cm->blocksize + len);
1552     if (ipad == NULL)
1553         return ENOMEM;
1554     opad = malloc(cm->blocksize + cm->checksumsize);
1555     if (opad == NULL) {
1556         free(ipad);
1557         return ENOMEM;
1558     }
1559     memset(ipad, 0x36, cm->blocksize);
1560     memset(opad, 0x5c, cm->blocksize);
1561
1562     if(keyblock->key->keyvalue.length > cm->blocksize){
1563         (*cm->checksum)(context, 
1564                         keyblock, 
1565                         keyblock->key->keyvalue.data, 
1566                         keyblock->key->keyvalue.length, 
1567                         usage,
1568                         result);
1569         key = result->checksum.data;
1570         key_len = result->checksum.length;
1571     } else {
1572         key = keyblock->key->keyvalue.data;
1573         key_len = keyblock->key->keyvalue.length;
1574     }
1575     for(i = 0; i < key_len; i++){
1576         ipad[i] ^= key[i];
1577         opad[i] ^= key[i];
1578     }
1579     memcpy(ipad + cm->blocksize, data, len);
1580     (*cm->checksum)(context, keyblock, ipad, cm->blocksize + len,
1581                     usage, result);
1582     memcpy(opad + cm->blocksize, result->checksum.data, 
1583            result->checksum.length);
1584     (*cm->checksum)(context, keyblock, opad, 
1585                     cm->blocksize + cm->checksumsize, usage, result);
1586     memset(ipad, 0, cm->blocksize + len);
1587     free(ipad);
1588     memset(opad, 0, cm->blocksize + cm->checksumsize);
1589     free(opad);
1590
1591     return 0;
1592 }
1593
1594 krb5_error_code KRB5_LIB_FUNCTION
1595 krb5_hmac(krb5_context context,
1596           krb5_cksumtype cktype,
1597           const void *data,
1598           size_t len,
1599           unsigned usage, 
1600           krb5_keyblock *key,
1601           Checksum *result)
1602 {
1603     struct checksum_type *c = _find_checksum(cktype);
1604     struct key_data kd;
1605     krb5_error_code ret;
1606
1607     if (c == NULL) {
1608         krb5_set_error_string (context, "checksum type %d not supported",
1609                                cktype);
1610         return KRB5_PROG_SUMTYPE_NOSUPP;
1611     }
1612
1613     kd.key = key;
1614     kd.schedule = NULL;
1615
1616     ret = hmac(context, c, data, len, usage, &kd, result);
1617
1618     if (kd.schedule)
1619         krb5_free_data(context, kd.schedule);
1620
1621     return ret;
1622  }
1623
1624 static void
1625 SP_HMAC_SHA1_checksum(krb5_context context,
1626                       struct key_data *key, 
1627                       const void *data, 
1628                       size_t len, 
1629                       unsigned usage,
1630                       Checksum *result)
1631 {
1632     struct checksum_type *c = _find_checksum(CKSUMTYPE_SHA1);
1633     Checksum res;
1634     char sha1_data[20];
1635     krb5_error_code ret;
1636
1637     res.checksum.data = sha1_data;
1638     res.checksum.length = sizeof(sha1_data);
1639
1640     ret = hmac(context, c, data, len, usage, key, &res);
1641     if (ret)
1642         krb5_abortx(context, "hmac failed");
1643     memcpy(result->checksum.data, res.checksum.data, result->checksum.length);
1644 }
1645
1646 /*
1647  * checksum according to section 5. of draft-brezak-win2k-krb-rc4-hmac-03.txt
1648  */
1649
1650 static void
1651 HMAC_MD5_checksum(krb5_context context,
1652                   struct key_data *key,
1653                   const void *data,
1654                   size_t len,
1655                   unsigned usage,
1656                   Checksum *result)
1657 {
1658     MD5_CTX md5;
1659     struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
1660     const char signature[] = "signaturekey";
1661     Checksum ksign_c;
1662     struct key_data ksign;
1663     krb5_keyblock kb;
1664     unsigned char t[4];
1665     unsigned char tmp[16];
1666     unsigned char ksign_c_data[16];
1667     krb5_error_code ret;
1668
1669     ksign_c.checksum.length = sizeof(ksign_c_data);
1670     ksign_c.checksum.data   = ksign_c_data;
1671     ret = hmac(context, c, signature, sizeof(signature), 0, key, &ksign_c);
1672     if (ret)
1673         krb5_abortx(context, "hmac failed");
1674     ksign.key = &kb;
1675     kb.keyvalue = ksign_c.checksum;
1676     MD5_Init (&md5);
1677     t[0] = (usage >>  0) & 0xFF;
1678     t[1] = (usage >>  8) & 0xFF;
1679     t[2] = (usage >> 16) & 0xFF;
1680     t[3] = (usage >> 24) & 0xFF;
1681     MD5_Update (&md5, t, 4);
1682     MD5_Update (&md5, data, len);
1683     MD5_Final (tmp, &md5);
1684     ret = hmac(context, c, tmp, sizeof(tmp), 0, &ksign, result);
1685     if (ret)
1686         krb5_abortx(context, "hmac failed");
1687 }
1688
1689 /*
1690  * same as previous but being used while encrypting.
1691  */
1692
1693 static void
1694 HMAC_MD5_checksum_enc(krb5_context context,
1695                       struct key_data *key,
1696                       const void *data,
1697                       size_t len,
1698                       unsigned usage,
1699                       Checksum *result)
1700 {
1701     struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
1702     Checksum ksign_c;
1703     struct key_data ksign;
1704     krb5_keyblock kb;
1705     unsigned char t[4];
1706     unsigned char ksign_c_data[16];
1707     krb5_error_code ret;
1708
1709     t[0] = (usage >>  0) & 0xFF;
1710     t[1] = (usage >>  8) & 0xFF;
1711     t[2] = (usage >> 16) & 0xFF;
1712     t[3] = (usage >> 24) & 0xFF;
1713
1714     ksign_c.checksum.length = sizeof(ksign_c_data);
1715     ksign_c.checksum.data   = ksign_c_data;
1716     ret = hmac(context, c, t, sizeof(t), 0, key, &ksign_c);
1717     if (ret)
1718         krb5_abortx(context, "hmac failed");
1719     ksign.key = &kb;
1720     kb.keyvalue = ksign_c.checksum;
1721     ret = hmac(context, c, data, len, 0, &ksign, result);
1722     if (ret)
1723         krb5_abortx(context, "hmac failed");
1724 }
1725
1726 static struct checksum_type checksum_none = {
1727     CKSUMTYPE_NONE, 
1728     "none", 
1729     1, 
1730     0, 
1731     0,
1732     NONE_checksum, 
1733     NULL
1734 };
1735 static struct checksum_type checksum_crc32 = {
1736     CKSUMTYPE_CRC32,
1737     "crc32",
1738     1,
1739     4,
1740     0,
1741     CRC32_checksum,
1742     NULL
1743 };
1744 static struct checksum_type checksum_rsa_md4 = {
1745     CKSUMTYPE_RSA_MD4,
1746     "rsa-md4",
1747     64,
1748     16,
1749     F_CPROOF,
1750     RSA_MD4_checksum,
1751     NULL
1752 };
1753 static struct checksum_type checksum_rsa_md4_des = {
1754     CKSUMTYPE_RSA_MD4_DES,
1755     "rsa-md4-des",
1756     64,
1757     24,
1758     F_KEYED | F_CPROOF | F_VARIANT,
1759     RSA_MD4_DES_checksum,
1760     RSA_MD4_DES_verify
1761 };
1762 #if 0
1763 static struct checksum_type checksum_des_mac = { 
1764     CKSUMTYPE_DES_MAC,
1765     "des-mac",
1766     0,
1767     0,
1768     0,
1769     DES_MAC_checksum
1770 };
1771 static struct checksum_type checksum_des_mac_k = {
1772     CKSUMTYPE_DES_MAC_K,
1773     "des-mac-k",
1774     0,
1775     0,
1776     0,
1777     DES_MAC_K_checksum
1778 };
1779 static struct checksum_type checksum_rsa_md4_des_k = {
1780     CKSUMTYPE_RSA_MD4_DES_K, 
1781     "rsa-md4-des-k", 
1782     0, 
1783     0, 
1784     0, 
1785     RSA_MD4_DES_K_checksum,
1786     RSA_MD4_DES_K_verify
1787 };
1788 #endif
1789 static struct checksum_type checksum_rsa_md5 = {
1790     CKSUMTYPE_RSA_MD5,
1791     "rsa-md5",
1792     64,
1793     16,
1794     F_CPROOF,
1795     RSA_MD5_checksum,
1796     NULL
1797 };
1798 static struct checksum_type checksum_rsa_md5_des = {
1799     CKSUMTYPE_RSA_MD5_DES,
1800     "rsa-md5-des",
1801     64,
1802     24,
1803     F_KEYED | F_CPROOF | F_VARIANT,
1804     RSA_MD5_DES_checksum,
1805     RSA_MD5_DES_verify
1806 };
1807 static struct checksum_type checksum_rsa_md5_des3 = {
1808     CKSUMTYPE_RSA_MD5_DES3,
1809     "rsa-md5-des3",
1810     64,
1811     24,
1812     F_KEYED | F_CPROOF | F_VARIANT,
1813     RSA_MD5_DES3_checksum,
1814     RSA_MD5_DES3_verify
1815 };
1816 static struct checksum_type checksum_sha1 = {
1817     CKSUMTYPE_SHA1,
1818     "sha1",
1819     64,
1820     20,
1821     F_CPROOF,
1822     SHA1_checksum,
1823     NULL
1824 };
1825 static struct checksum_type checksum_hmac_sha1_des3 = {
1826     CKSUMTYPE_HMAC_SHA1_DES3,
1827     "hmac-sha1-des3",
1828     64,
1829     20,
1830     F_KEYED | F_CPROOF | F_DERIVED,
1831     SP_HMAC_SHA1_checksum,
1832     NULL
1833 };
1834
1835 static struct checksum_type checksum_hmac_sha1_aes128 = {
1836     CKSUMTYPE_HMAC_SHA1_96_AES_128,
1837     "hmac-sha1-96-aes128",
1838     64,
1839     12,
1840     F_KEYED | F_CPROOF | F_DERIVED,
1841     SP_HMAC_SHA1_checksum,
1842     NULL
1843 };
1844
1845 static struct checksum_type checksum_hmac_sha1_aes256 = {
1846     CKSUMTYPE_HMAC_SHA1_96_AES_256,
1847     "hmac-sha1-96-aes256",
1848     64,
1849     12,
1850     F_KEYED | F_CPROOF | F_DERIVED,
1851     SP_HMAC_SHA1_checksum,
1852     NULL
1853 };
1854
1855 static struct checksum_type checksum_hmac_md5 = {
1856     CKSUMTYPE_HMAC_MD5,
1857     "hmac-md5",
1858     64,
1859     16,
1860     F_KEYED | F_CPROOF,
1861     HMAC_MD5_checksum,
1862     NULL
1863 };
1864
1865 static struct checksum_type checksum_hmac_md5_enc = {
1866     CKSUMTYPE_HMAC_MD5_ENC,
1867     "hmac-md5-enc",
1868     64,
1869     16,
1870     F_KEYED | F_CPROOF | F_PSEUDO,
1871     HMAC_MD5_checksum_enc,
1872     NULL
1873 };
1874
1875 static struct checksum_type *checksum_types[] = {
1876     &checksum_none,
1877     &checksum_crc32,
1878     &checksum_rsa_md4,
1879     &checksum_rsa_md4_des,
1880 #if 0
1881     &checksum_des_mac, 
1882     &checksum_des_mac_k,
1883     &checksum_rsa_md4_des_k,
1884 #endif
1885     &checksum_rsa_md5,
1886     &checksum_rsa_md5_des,
1887     &checksum_rsa_md5_des3,
1888     &checksum_sha1,
1889     &checksum_hmac_sha1_des3,
1890     &checksum_hmac_sha1_aes128,
1891     &checksum_hmac_sha1_aes256,
1892     &checksum_hmac_md5,
1893     &checksum_hmac_md5_enc
1894 };
1895
1896 static int num_checksums = sizeof(checksum_types) / sizeof(checksum_types[0]);
1897
1898 static struct checksum_type *
1899 _find_checksum(krb5_cksumtype type)
1900 {
1901     int i;
1902     for(i = 0; i < num_checksums; i++)
1903         if(checksum_types[i]->type == type)
1904             return checksum_types[i];
1905     return NULL;
1906 }
1907
1908 static krb5_error_code
1909 get_checksum_key(krb5_context context, 
1910                  krb5_crypto crypto,
1911                  unsigned usage,  /* not krb5_key_usage */
1912                  struct checksum_type *ct, 
1913                  struct key_data **key)
1914 {
1915     krb5_error_code ret = 0;
1916
1917     if(ct->flags & F_DERIVED)
1918         ret = _get_derived_key(context, crypto, usage, key);
1919     else if(ct->flags & F_VARIANT) {
1920         int i;
1921
1922         *key = _new_derived_key(crypto, 0xff/* KRB5_KU_RFC1510_VARIANT */);
1923         if(*key == NULL) {
1924             krb5_set_error_string(context, "malloc: out of memory");
1925             return ENOMEM;
1926         }
1927         ret = krb5_copy_keyblock(context, crypto->key.key, &(*key)->key);
1928         if(ret) 
1929             return ret;
1930         for(i = 0; i < (*key)->key->keyvalue.length; i++)
1931             ((unsigned char*)(*key)->key->keyvalue.data)[i] ^= 0xF0;
1932     } else {
1933         *key = &crypto->key; 
1934     }
1935     if(ret == 0)
1936         ret = _key_schedule(context, *key, crypto->params);
1937     return ret;
1938 }
1939
1940 static krb5_error_code
1941 create_checksum (krb5_context context,
1942                  struct checksum_type *ct,
1943                  krb5_crypto crypto,
1944                  unsigned usage,
1945                  void *data,
1946                  size_t len,
1947                  Checksum *result)
1948 {
1949     krb5_error_code ret;
1950     struct key_data *dkey;
1951     int keyed_checksum;
1952     
1953     if (ct->flags & F_DISABLED) {
1954         krb5_clear_error_string (context);
1955         return KRB5_PROG_SUMTYPE_NOSUPP;
1956     }
1957     keyed_checksum = (ct->flags & F_KEYED) != 0;
1958     if(keyed_checksum && crypto == NULL) {
1959         krb5_set_error_string (context, "Checksum type %s is keyed "
1960                                "but no crypto context (key) was passed in",
1961                                ct->name);
1962         return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
1963     }
1964     if(keyed_checksum) {
1965         ret = get_checksum_key(context, crypto, usage, ct, &dkey);
1966         if (ret)
1967             return ret;
1968     } else
1969         dkey = NULL;
1970     result->cksumtype = ct->type;
1971     krb5_data_alloc(&result->checksum, ct->checksumsize);
1972     (*ct->checksum)(context, dkey, data, len, usage, result);
1973     return 0;
1974 }
1975
1976 static int
1977 arcfour_checksum_p(struct checksum_type *ct, krb5_crypto crypto)
1978 {
1979     return (ct->type == CKSUMTYPE_HMAC_MD5) &&
1980         (crypto->key.key->keytype == KEYTYPE_ARCFOUR);
1981 }
1982
1983 krb5_error_code KRB5_LIB_FUNCTION
1984 krb5_create_checksum(krb5_context context,
1985                      krb5_crypto crypto,
1986                      krb5_key_usage usage,
1987                      int type,
1988                      void *data,
1989                      size_t len,
1990                      Checksum *result)
1991 {
1992     struct checksum_type *ct = NULL;
1993     unsigned keyusage;
1994
1995     /* type 0 -> pick from crypto */
1996     if (type) {
1997         ct = _find_checksum(type);
1998     } else if (crypto) {
1999         ct = crypto->et->keyed_checksum;
2000         if (ct == NULL)
2001             ct = crypto->et->checksum;
2002     }
2003
2004     if(ct == NULL) {
2005         krb5_set_error_string (context, "checksum type %d not supported",
2006                                type);
2007         return KRB5_PROG_SUMTYPE_NOSUPP;
2008     }
2009
2010     if (arcfour_checksum_p(ct, crypto)) {
2011         keyusage = usage;
2012         usage2arcfour(context, &keyusage);
2013     } else
2014         keyusage = CHECKSUM_USAGE(usage);
2015
2016     return create_checksum(context, ct, crypto, keyusage,
2017                            data, len, result);
2018 }
2019
2020 static krb5_error_code
2021 verify_checksum(krb5_context context,
2022                 krb5_crypto crypto,
2023                 unsigned usage, /* not krb5_key_usage */
2024                 void *data,
2025                 size_t len,
2026                 Checksum *cksum)
2027 {
2028     krb5_error_code ret;
2029     struct key_data *dkey;
2030     int keyed_checksum;
2031     Checksum c;
2032     struct checksum_type *ct;
2033
2034     ct = _find_checksum(cksum->cksumtype);
2035     if (ct == NULL || (ct->flags & F_DISABLED)) {
2036         krb5_set_error_string (context, "checksum type %d not supported",
2037                                cksum->cksumtype);
2038         return KRB5_PROG_SUMTYPE_NOSUPP;
2039     }
2040     if(ct->checksumsize != cksum->checksum.length) {
2041         krb5_clear_error_string (context);
2042         return KRB5KRB_AP_ERR_BAD_INTEGRITY; /* XXX */
2043     }
2044     keyed_checksum = (ct->flags & F_KEYED) != 0;
2045     if(keyed_checksum && crypto == NULL) {
2046         krb5_set_error_string (context, "Checksum type %s is keyed "
2047                                "but no crypto context (key) was passed in",
2048                                ct->name);
2049         return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
2050     }
2051     if(keyed_checksum)
2052         ret = get_checksum_key(context, crypto, usage, ct, &dkey);
2053     else
2054         dkey = NULL;
2055     if(ct->verify)
2056         return (*ct->verify)(context, dkey, data, len, usage, cksum);
2057
2058     ret = krb5_data_alloc (&c.checksum, ct->checksumsize);
2059     if (ret)
2060         return ret;
2061
2062     (*ct->checksum)(context, dkey, data, len, usage, &c);
2063
2064     if(c.checksum.length != cksum->checksum.length || 
2065        memcmp(c.checksum.data, cksum->checksum.data, c.checksum.length)) {
2066         krb5_clear_error_string (context);
2067         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
2068     } else {
2069         ret = 0;
2070     }
2071     krb5_data_free (&c.checksum);
2072     return ret;
2073 }
2074
2075 krb5_error_code KRB5_LIB_FUNCTION
2076 krb5_verify_checksum(krb5_context context,
2077                      krb5_crypto crypto,
2078                      krb5_key_usage usage, 
2079                      void *data,
2080                      size_t len,
2081                      Checksum *cksum)
2082 {
2083     struct checksum_type *ct;
2084     unsigned keyusage;
2085
2086     ct = _find_checksum(cksum->cksumtype);
2087     if(ct == NULL) {
2088         krb5_set_error_string (context, "checksum type %d not supported",
2089                                cksum->cksumtype);
2090         return KRB5_PROG_SUMTYPE_NOSUPP;
2091     }
2092
2093     if (arcfour_checksum_p(ct, crypto)) {
2094         keyusage = usage;
2095         usage2arcfour(context, &keyusage);
2096     } else
2097         keyusage = CHECKSUM_USAGE(usage);
2098
2099     return verify_checksum(context, crypto, keyusage,
2100                            data, len, cksum);
2101 }
2102
2103 krb5_error_code KRB5_LIB_FUNCTION
2104 krb5_crypto_get_checksum_type(krb5_context context,
2105                               krb5_crypto crypto,
2106                               krb5_cksumtype *type)
2107 {
2108     struct checksum_type *ct = NULL;
2109     
2110     if (crypto != NULL) {
2111         ct = crypto->et->keyed_checksum;
2112         if (ct == NULL)
2113             ct = crypto->et->checksum;
2114     }
2115     
2116     if (ct == NULL) {
2117         krb5_set_error_string (context, "checksum type not found");
2118         return KRB5_PROG_SUMTYPE_NOSUPP;
2119     }    
2120
2121     *type = ct->type;
2122     
2123     return 0;      
2124 }
2125
2126
2127 krb5_error_code KRB5_LIB_FUNCTION
2128 krb5_checksumsize(krb5_context context,
2129                   krb5_cksumtype type,
2130                   size_t *size)
2131 {
2132     struct checksum_type *ct = _find_checksum(type);
2133     if(ct == NULL) {
2134         krb5_set_error_string (context, "checksum type %d not supported",
2135                                type);
2136         return KRB5_PROG_SUMTYPE_NOSUPP;
2137     }
2138     *size = ct->checksumsize;
2139     return 0;
2140 }
2141
2142 krb5_boolean KRB5_LIB_FUNCTION
2143 krb5_checksum_is_keyed(krb5_context context,
2144                        krb5_cksumtype type)
2145 {
2146     struct checksum_type *ct = _find_checksum(type);
2147     if(ct == NULL) {
2148         if (context)
2149             krb5_set_error_string (context, "checksum type %d not supported",
2150                                    type);
2151         return KRB5_PROG_SUMTYPE_NOSUPP;
2152     }
2153     return ct->flags & F_KEYED;
2154 }
2155
2156 krb5_boolean KRB5_LIB_FUNCTION
2157 krb5_checksum_is_collision_proof(krb5_context context,
2158                                  krb5_cksumtype type)
2159 {
2160     struct checksum_type *ct = _find_checksum(type);
2161     if(ct == NULL) {
2162         if (context)
2163             krb5_set_error_string (context, "checksum type %d not supported",
2164                                    type);
2165         return KRB5_PROG_SUMTYPE_NOSUPP;
2166     }
2167     return ct->flags & F_CPROOF;
2168 }
2169
2170 krb5_error_code KRB5_LIB_FUNCTION
2171 krb5_checksum_disable(krb5_context context,
2172                       krb5_cksumtype type)
2173 {
2174     struct checksum_type *ct = _find_checksum(type);
2175     if(ct == NULL) {
2176         if (context)
2177             krb5_set_error_string (context, "checksum type %d not supported",
2178                                    type);
2179         return KRB5_PROG_SUMTYPE_NOSUPP;
2180     }
2181     ct->flags |= F_DISABLED;
2182     return 0;
2183 }
2184
2185 /************************************************************
2186  *                                                          *
2187  ************************************************************/
2188
2189 static krb5_error_code
2190 NULL_encrypt(krb5_context context,
2191              struct key_data *key, 
2192              void *data, 
2193              size_t len, 
2194              krb5_boolean encryptp,
2195              int usage,
2196              void *ivec)
2197 {
2198     return 0;
2199 }
2200
2201 static krb5_error_code
2202 DES_CBC_encrypt_null_ivec(krb5_context context,
2203                           struct key_data *key, 
2204                           void *data, 
2205                           size_t len, 
2206                           krb5_boolean encryptp,
2207                           int usage,
2208                           void *ignore_ivec)
2209 {
2210     DES_cblock ivec;
2211     DES_key_schedule *s = key->schedule->data;
2212     memset(&ivec, 0, sizeof(ivec));
2213     DES_cbc_encrypt(data, data, len, s, &ivec, encryptp);
2214     return 0;
2215 }
2216
2217 static krb5_error_code
2218 DES_CBC_encrypt_key_ivec(krb5_context context,
2219                          struct key_data *key, 
2220                          void *data, 
2221                          size_t len, 
2222                          krb5_boolean encryptp,
2223                          int usage,
2224                          void *ignore_ivec)
2225 {
2226     DES_cblock ivec;
2227     DES_key_schedule *s = key->schedule->data;
2228     memcpy(&ivec, key->key->keyvalue.data, sizeof(ivec));
2229     DES_cbc_encrypt(data, data, len, s, &ivec, encryptp);
2230     return 0;
2231 }
2232
2233 static krb5_error_code
2234 DES3_CBC_encrypt(krb5_context context,
2235                  struct key_data *key, 
2236                  void *data, 
2237                  size_t len, 
2238                  krb5_boolean encryptp,
2239                  int usage,
2240                  void *ivec)
2241 {
2242     DES_cblock local_ivec;
2243     DES_key_schedule *s = key->schedule->data;
2244     if(ivec == NULL) {
2245         ivec = &local_ivec;
2246         memset(local_ivec, 0, sizeof(local_ivec));
2247     }
2248     DES_ede3_cbc_encrypt(data, data, len, &s[0], &s[1], &s[2], ivec, encryptp);
2249     return 0;
2250 }
2251
2252 static krb5_error_code
2253 DES_CFB64_encrypt_null_ivec(krb5_context context,
2254                             struct key_data *key, 
2255                             void *data, 
2256                             size_t len, 
2257                             krb5_boolean encryptp,
2258                             int usage,
2259                             void *ignore_ivec)
2260 {
2261     DES_cblock ivec;
2262     int num = 0;
2263     DES_key_schedule *s = key->schedule->data;
2264     memset(&ivec, 0, sizeof(ivec));
2265
2266     DES_cfb64_encrypt(data, data, len, s, &ivec, &num, encryptp);
2267     return 0;
2268 }
2269
2270 static krb5_error_code
2271 DES_PCBC_encrypt_key_ivec(krb5_context context,
2272                           struct key_data *key, 
2273                           void *data, 
2274                           size_t len, 
2275                           krb5_boolean encryptp,
2276                           int usage,
2277                           void *ignore_ivec)
2278 {
2279     DES_cblock ivec;
2280     DES_key_schedule *s = key->schedule->data;
2281     memcpy(&ivec, key->key->keyvalue.data, sizeof(ivec));
2282
2283     DES_pcbc_encrypt(data, data, len, s, &ivec, encryptp);
2284     return 0;
2285 }
2286
2287 /*
2288  * AES draft-raeburn-krb-rijndael-krb-02
2289  */
2290
2291 void KRB5_LIB_FUNCTION
2292 _krb5_aes_cts_encrypt(const unsigned char *in, unsigned char *out,
2293                       size_t len, const void *aes_key,
2294                       unsigned char *ivec, const int encryptp)
2295 {
2296     unsigned char tmp[AES_BLOCK_SIZE];
2297     const AES_KEY *key = aes_key; /* XXX remove this when we always have AES */
2298     int i;
2299
2300     /*
2301      * In the framework of kerberos, the length can never be shorter
2302      * than at least one blocksize.
2303      */
2304
2305     if (encryptp) {
2306
2307         while(len > AES_BLOCK_SIZE) {
2308             for (i = 0; i < AES_BLOCK_SIZE; i++)
2309                 tmp[i] = in[i] ^ ivec[i];
2310             AES_encrypt(tmp, out, key);
2311             memcpy(ivec, out, AES_BLOCK_SIZE);
2312             len -= AES_BLOCK_SIZE;
2313             in += AES_BLOCK_SIZE;
2314             out += AES_BLOCK_SIZE;
2315         }
2316
2317         for (i = 0; i < len; i++)
2318             tmp[i] = in[i] ^ ivec[i];
2319         for (; i < AES_BLOCK_SIZE; i++)
2320             tmp[i] = 0 ^ ivec[i];
2321
2322         AES_encrypt(tmp, out - AES_BLOCK_SIZE, key);
2323
2324         memcpy(out, ivec, len);
2325         memcpy(ivec, out - AES_BLOCK_SIZE, AES_BLOCK_SIZE);
2326
2327     } else {
2328         unsigned char tmp2[AES_BLOCK_SIZE];
2329         unsigned char tmp3[AES_BLOCK_SIZE];
2330
2331         while(len > AES_BLOCK_SIZE * 2) {
2332             memcpy(tmp, in, AES_BLOCK_SIZE);
2333             AES_decrypt(in, out, key);
2334             for (i = 0; i < AES_BLOCK_SIZE; i++)
2335                 out[i] ^= ivec[i];
2336             memcpy(ivec, tmp, AES_BLOCK_SIZE);
2337             len -= AES_BLOCK_SIZE;
2338             in += AES_BLOCK_SIZE;
2339             out += AES_BLOCK_SIZE;
2340         }
2341
2342         len -= AES_BLOCK_SIZE;
2343
2344         memcpy(tmp, in, AES_BLOCK_SIZE); /* save last iv */
2345         AES_decrypt(in, tmp2, key);
2346
2347         memcpy(tmp3, in + AES_BLOCK_SIZE, len);
2348         memcpy(tmp3 + len, tmp2 + len, AES_BLOCK_SIZE - len); /* xor 0 */
2349
2350         for (i = 0; i < len; i++)
2351             out[i + AES_BLOCK_SIZE] = tmp2[i] ^ tmp3[i];
2352
2353         AES_decrypt(tmp3, out, key);
2354         for (i = 0; i < AES_BLOCK_SIZE; i++)
2355             out[i] ^= ivec[i];
2356         memcpy(ivec, tmp, AES_BLOCK_SIZE);
2357     }
2358 }
2359
2360 static krb5_error_code
2361 AES_CTS_encrypt(krb5_context context,
2362                 struct key_data *key,
2363                 void *data,
2364                 size_t len,
2365                 krb5_boolean encryptp,
2366                 int usage,
2367                 void *ivec)
2368 {
2369     struct krb5_aes_schedule *aeskey = key->schedule->data;
2370     char local_ivec[AES_BLOCK_SIZE];
2371     AES_KEY *k;
2372
2373     if (encryptp)
2374         k = &aeskey->ekey;
2375     else
2376         k = &aeskey->dkey;
2377     
2378     if (len < AES_BLOCK_SIZE)
2379         krb5_abortx(context, "invalid use of AES_CTS_encrypt");
2380     if (len == AES_BLOCK_SIZE) {
2381         if (encryptp)
2382             AES_encrypt(data, data, k);
2383         else
2384             AES_decrypt(data, data, k);
2385     } else {
2386         if(ivec == NULL) {
2387             memset(local_ivec, 0, sizeof(local_ivec));
2388             ivec = local_ivec;
2389         }
2390         _krb5_aes_cts_encrypt(data, data, len, k, ivec, encryptp);
2391     }
2392
2393     return 0;
2394 }
2395
2396 /*
2397  * section 6 of draft-brezak-win2k-krb-rc4-hmac-03
2398  *
2399  * warning: not for small children
2400  */
2401
2402 static krb5_error_code
2403 ARCFOUR_subencrypt(krb5_context context,
2404                    struct key_data *key,
2405                    void *data,
2406                    size_t len,
2407                    unsigned usage,
2408                    void *ivec)
2409 {
2410     struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
2411     Checksum k1_c, k2_c, k3_c, cksum;
2412     struct key_data ke;
2413     krb5_keyblock kb;
2414     unsigned char t[4];
2415     RC4_KEY rc4_key;
2416     unsigned char *cdata = data;
2417     unsigned char k1_c_data[16], k2_c_data[16], k3_c_data[16];
2418     krb5_error_code ret;
2419
2420     t[0] = (usage >>  0) & 0xFF;
2421     t[1] = (usage >>  8) & 0xFF;
2422     t[2] = (usage >> 16) & 0xFF;
2423     t[3] = (usage >> 24) & 0xFF;
2424
2425     k1_c.checksum.length = sizeof(k1_c_data);
2426     k1_c.checksum.data   = k1_c_data;
2427
2428     ret = hmac(NULL, c, t, sizeof(t), 0, key, &k1_c);
2429     if (ret)
2430         krb5_abortx(context, "hmac failed");
2431
2432     memcpy (k2_c_data, k1_c_data, sizeof(k1_c_data));
2433
2434     k2_c.checksum.length = sizeof(k2_c_data);
2435     k2_c.checksum.data   = k2_c_data;
2436
2437     ke.key = &kb;
2438     kb.keyvalue = k2_c.checksum;
2439
2440     cksum.checksum.length = 16;
2441     cksum.checksum.data   = data;
2442
2443     ret = hmac(NULL, c, cdata + 16, len - 16, 0, &ke, &cksum);
2444     if (ret)
2445         krb5_abortx(context, "hmac failed");
2446
2447     ke.key = &kb;
2448     kb.keyvalue = k1_c.checksum;
2449
2450     k3_c.checksum.length = sizeof(k3_c_data);
2451     k3_c.checksum.data   = k3_c_data;
2452
2453     ret = hmac(NULL, c, data, 16, 0, &ke, &k3_c);
2454     if (ret)
2455         krb5_abortx(context, "hmac failed");
2456
2457     RC4_set_key (&rc4_key, k3_c.checksum.length, k3_c.checksum.data);
2458     RC4 (&rc4_key, len - 16, cdata + 16, cdata + 16);
2459     memset (k1_c_data, 0, sizeof(k1_c_data));
2460     memset (k2_c_data, 0, sizeof(k2_c_data));
2461     memset (k3_c_data, 0, sizeof(k3_c_data));
2462     return 0;
2463 }
2464
2465 static krb5_error_code
2466 ARCFOUR_subdecrypt(krb5_context context,
2467                    struct key_data *key,
2468                    void *data,
2469                    size_t len,
2470                    unsigned usage,
2471                    void *ivec)
2472 {
2473     struct checksum_type *c = _find_checksum (CKSUMTYPE_RSA_MD5);
2474     Checksum k1_c, k2_c, k3_c, cksum;
2475     struct key_data ke;
2476     krb5_keyblock kb;
2477     unsigned char t[4];
2478     RC4_KEY rc4_key;
2479     unsigned char *cdata = data;
2480     unsigned char k1_c_data[16], k2_c_data[16], k3_c_data[16];
2481     unsigned char cksum_data[16];
2482     krb5_error_code ret;
2483
2484     t[0] = (usage >>  0) & 0xFF;
2485     t[1] = (usage >>  8) & 0xFF;
2486     t[2] = (usage >> 16) & 0xFF;
2487     t[3] = (usage >> 24) & 0xFF;
2488
2489     k1_c.checksum.length = sizeof(k1_c_data);
2490     k1_c.checksum.data   = k1_c_data;
2491
2492     ret = hmac(NULL, c, t, sizeof(t), 0, key, &k1_c);
2493     if (ret)
2494         krb5_abortx(context, "hmac failed");
2495
2496     memcpy (k2_c_data, k1_c_data, sizeof(k1_c_data));
2497
2498     k2_c.checksum.length = sizeof(k2_c_data);
2499     k2_c.checksum.data   = k2_c_data;
2500
2501     ke.key = &kb;
2502     kb.keyvalue = k1_c.checksum;
2503
2504     k3_c.checksum.length = sizeof(k3_c_data);
2505     k3_c.checksum.data   = k3_c_data;
2506
2507     ret = hmac(NULL, c, cdata, 16, 0, &ke, &k3_c);
2508     if (ret)
2509         krb5_abortx(context, "hmac failed");
2510
2511     RC4_set_key (&rc4_key, k3_c.checksum.length, k3_c.checksum.data);
2512     RC4 (&rc4_key, len - 16, cdata + 16, cdata + 16);
2513
2514     ke.key = &kb;
2515     kb.keyvalue = k2_c.checksum;
2516
2517     cksum.checksum.length = 16;
2518     cksum.checksum.data   = cksum_data;
2519
2520     ret = hmac(NULL, c, cdata + 16, len - 16, 0, &ke, &cksum);
2521     if (ret)
2522         krb5_abortx(context, "hmac failed");
2523
2524     memset (k1_c_data, 0, sizeof(k1_c_data));
2525     memset (k2_c_data, 0, sizeof(k2_c_data));
2526     memset (k3_c_data, 0, sizeof(k3_c_data));
2527
2528     if (memcmp (cksum.checksum.data, data, 16) != 0) {
2529         krb5_clear_error_string (context);
2530         return KRB5KRB_AP_ERR_BAD_INTEGRITY;
2531     } else {
2532         return 0;
2533     }
2534 }
2535
2536 /*
2537  * convert the usage numbers used in
2538  * draft-ietf-cat-kerb-key-derivation-00.txt to the ones in
2539  * draft-brezak-win2k-krb-rc4-hmac-04.txt
2540  */
2541
2542 static krb5_error_code
2543 usage2arcfour (krb5_context context, unsigned *usage)
2544 {
2545     switch (*usage) {
2546     case KRB5_KU_AS_REP_ENC_PART : /* 3 */
2547     case KRB5_KU_TGS_REP_ENC_PART_SUB_KEY : /* 9 */
2548         *usage = 8;
2549         return 0;
2550     case KRB5_KU_USAGE_SEAL :  /* 22 */
2551         *usage = 13;
2552         return 0;
2553     case KRB5_KU_USAGE_SIGN : /* 23 */
2554         *usage = 15;
2555         return 0;
2556     case KRB5_KU_USAGE_SEQ: /* 24 */
2557         *usage = 0;
2558         return 0;
2559     default :
2560         return 0;
2561     }
2562 }
2563
2564 static krb5_error_code
2565 ARCFOUR_encrypt(krb5_context context,
2566                 struct key_data *key,
2567                 void *data,
2568                 size_t len,
2569                 krb5_boolean encryptp,
2570                 int usage,
2571                 void *ivec)
2572 {
2573     krb5_error_code ret;
2574     unsigned keyusage = usage;
2575
2576     if((ret = usage2arcfour (context, &keyusage)) != 0)
2577         return ret;
2578
2579     if (encryptp)
2580         return ARCFOUR_subencrypt (context, key, data, len, keyusage, ivec);
2581     else
2582         return ARCFOUR_subdecrypt (context, key, data, len, keyusage, ivec);
2583 }
2584
2585
2586 /*
2587  * these should currently be in reverse preference order.
2588  * (only relevant for !F_PSEUDO) */
2589
2590 static struct encryption_type enctype_null = {
2591     ETYPE_NULL,
2592     "null",
2593     NULL,
2594     1,
2595     1,
2596     0,
2597     &keytype_null,
2598     &checksum_none,
2599     NULL,
2600     F_DISABLED,
2601     NULL_encrypt,
2602 };
2603 static struct encryption_type enctype_des_cbc_crc = {
2604     ETYPE_DES_CBC_CRC,
2605     "des-cbc-crc",
2606     NULL,
2607     8,
2608     8,
2609     8,
2610     &keytype_des,
2611     &checksum_crc32,
2612     NULL,
2613     0,
2614     DES_CBC_encrypt_key_ivec,
2615 };
2616 static struct encryption_type enctype_des_cbc_md4 = {
2617     ETYPE_DES_CBC_MD4,
2618     "des-cbc-md4",
2619     NULL,
2620     8,
2621     8,
2622     8,
2623     &keytype_des,
2624     &checksum_rsa_md4,
2625     &checksum_rsa_md4_des,
2626     0,
2627     DES_CBC_encrypt_null_ivec,
2628 };
2629 static struct encryption_type enctype_des_cbc_md5 = {
2630     ETYPE_DES_CBC_MD5,
2631     "des-cbc-md5",
2632     NULL,
2633     8,
2634     8,
2635     8,
2636     &keytype_des,
2637     &checksum_rsa_md5,
2638     &checksum_rsa_md5_des,
2639     0,
2640     DES_CBC_encrypt_null_ivec,
2641 };
2642 static struct encryption_type enctype_arcfour_hmac_md5 = {
2643     ETYPE_ARCFOUR_HMAC_MD5,
2644     "arcfour-hmac-md5",
2645     NULL,
2646     1,
2647     1,
2648     8,
2649     &keytype_arcfour,
2650     &checksum_hmac_md5,
2651     NULL,
2652     F_SPECIAL,
2653     ARCFOUR_encrypt
2654 };
2655 static struct encryption_type enctype_des3_cbc_md5 = { 
2656     ETYPE_DES3_CBC_MD5,
2657     "des3-cbc-md5",
2658     NULL,
2659     8,
2660     8,
2661     8,
2662     &keytype_des3,
2663     &checksum_rsa_md5,
2664     &checksum_rsa_md5_des3,
2665     0,
2666     DES3_CBC_encrypt,
2667 };
2668 static struct encryption_type enctype_des3_cbc_sha1 = {
2669     ETYPE_DES3_CBC_SHA1,
2670     "des3-cbc-sha1",
2671     NULL,
2672     8,
2673     8,
2674     8,
2675     &keytype_des3_derived,
2676     &checksum_sha1,
2677     &checksum_hmac_sha1_des3,
2678     F_DERIVED,
2679     DES3_CBC_encrypt,
2680 };
2681 static struct encryption_type enctype_old_des3_cbc_sha1 = {
2682     ETYPE_OLD_DES3_CBC_SHA1,
2683     "old-des3-cbc-sha1",
2684     NULL,
2685     8,
2686     8,
2687     8,
2688     &keytype_des3,
2689     &checksum_sha1,
2690     &checksum_hmac_sha1_des3,
2691     0,
2692     DES3_CBC_encrypt,
2693 };
2694 static struct encryption_type enctype_aes128_cts_hmac_sha1 = {
2695     ETYPE_AES128_CTS_HMAC_SHA1_96,
2696     "aes128-cts-hmac-sha1-96",
2697     NULL,
2698     16,
2699     1,
2700     16,
2701     &keytype_aes128,
2702     &checksum_sha1,
2703     &checksum_hmac_sha1_aes128,
2704     F_DERIVED,
2705     AES_CTS_encrypt,
2706 };
2707 static struct encryption_type enctype_aes256_cts_hmac_sha1 = {
2708     ETYPE_AES256_CTS_HMAC_SHA1_96,
2709     "aes256-cts-hmac-sha1-96",
2710     NULL,
2711     16,
2712     1,
2713     16,
2714     &keytype_aes256,
2715     &checksum_sha1,
2716     &checksum_hmac_sha1_aes256,
2717     F_DERIVED,
2718     AES_CTS_encrypt,
2719 };
2720 static struct encryption_type enctype_des_cbc_none = {
2721     ETYPE_DES_CBC_NONE,
2722     "des-cbc-none",
2723     NULL,
2724     8,
2725     8,
2726     0,
2727     &keytype_des,
2728     &checksum_none,
2729     NULL,
2730     F_PSEUDO,
2731     DES_CBC_encrypt_null_ivec,
2732 };
2733 static struct encryption_type enctype_des_cfb64_none = {
2734     ETYPE_DES_CFB64_NONE,
2735     "des-cfb64-none",
2736     NULL,
2737     1,
2738     1,
2739     0,
2740     &keytype_des,
2741     &checksum_none,
2742     NULL,
2743     F_PSEUDO,
2744     DES_CFB64_encrypt_null_ivec,
2745 };
2746 static struct encryption_type enctype_des_pcbc_none = {
2747     ETYPE_DES_PCBC_NONE,
2748     "des-pcbc-none",
2749     NULL,
2750     8,
2751     8,
2752     0,
2753     &keytype_des,
2754     &checksum_none,
2755     NULL,
2756     F_PSEUDO,
2757     DES_PCBC_encrypt_key_ivec,
2758 };
2759 static struct encryption_type enctype_des3_cbc_none = {
2760     ETYPE_DES3_CBC_NONE,
2761     "des3-cbc-none",
2762     NULL,
2763     8,
2764     8,
2765     0,
2766     &keytype_des3_derived,
2767     &checksum_none,
2768     NULL,
2769     F_PSEUDO,
2770     DES3_CBC_encrypt,
2771 };
2772
2773 static struct encryption_type *etypes[] = {
2774     &enctype_null,
2775     &enctype_des_cbc_crc,
2776     &enctype_des_cbc_md4,
2777     &enctype_des_cbc_md5,
2778     &enctype_arcfour_hmac_md5,
2779     &enctype_des3_cbc_md5, 
2780     &enctype_des3_cbc_sha1,
2781     &enctype_old_des3_cbc_sha1,
2782     &enctype_aes128_cts_hmac_sha1,
2783     &enctype_aes256_cts_hmac_sha1,
2784     &enctype_des_cbc_none,
2785     &enctype_des_cfb64_none,
2786     &enctype_des_pcbc_none,
2787     &enctype_des3_cbc_none
2788 };
2789
2790 static unsigned num_etypes = sizeof(etypes) / sizeof(etypes[0]);
2791
2792
2793 static struct encryption_type *
2794 _find_enctype(krb5_enctype type)
2795 {
2796     int i;
2797     for(i = 0; i < num_etypes; i++)
2798         if(etypes[i]->type == type)
2799             return etypes[i];
2800     return NULL;
2801 }
2802
2803
2804 krb5_error_code KRB5_LIB_FUNCTION
2805 krb5_enctype_to_string(krb5_context context,
2806                        krb5_enctype etype,
2807                        char **string)
2808 {
2809     struct encryption_type *e;
2810     e = _find_enctype(etype);
2811     if(e == NULL) {
2812         krb5_set_error_string (context, "encryption type %d not supported",
2813                                etype);
2814         return KRB5_PROG_ETYPE_NOSUPP;
2815     }
2816     *string = strdup(e->name);
2817     if(*string == NULL) {
2818         krb5_set_error_string(context, "malloc: out of memory");
2819         return ENOMEM;
2820     }
2821     return 0;
2822 }
2823
2824 krb5_error_code KRB5_LIB_FUNCTION
2825 krb5_string_to_enctype(krb5_context context,
2826                        const char *string,
2827                        krb5_enctype *etype)
2828 {
2829     int i;
2830     for(i = 0; i < num_etypes; i++)
2831         if(strcasecmp(etypes[i]->name, string) == 0){
2832             *etype = etypes[i]->type;
2833             return 0;
2834         }
2835     krb5_set_error_string (context, "encryption type %s not supported",
2836                            string);
2837     return KRB5_PROG_ETYPE_NOSUPP;
2838 }
2839
2840 krb5_error_code KRB5_LIB_FUNCTION
2841 krb5_enctype_to_oid(krb5_context context,
2842                     krb5_enctype etype,
2843                     heim_oid *oid)
2844 {
2845     struct encryption_type *et = _find_enctype(etype);
2846     if(et == NULL) {
2847         krb5_set_error_string (context, "encryption type %d not supported",
2848                                etype);
2849         return KRB5_PROG_ETYPE_NOSUPP;
2850     }
2851     if(et->oid == NULL) {
2852         krb5_set_error_string (context, "%s have not oid", et->name);
2853         return KRB5_PROG_ETYPE_NOSUPP;
2854     }
2855     krb5_clear_error_string(context);
2856     return copy_oid(et->oid, oid);
2857 }
2858
2859 krb5_error_code KRB5_LIB_FUNCTION
2860 _krb5_oid_to_enctype(krb5_context context,
2861                      const heim_oid *oid,
2862                      krb5_enctype *etype)
2863 {
2864     int i;
2865     for(i = 0; i < num_etypes; i++) {
2866         if(etypes[i]->oid && heim_oid_cmp(etypes[i]->oid, oid) == 0) {
2867             *etype = etypes[i]->type;
2868             return 0;
2869         }
2870     }
2871     krb5_set_error_string(context, "enctype for oid not supported");
2872     return KRB5_PROG_ETYPE_NOSUPP;
2873 }
2874
2875 krb5_error_code KRB5_LIB_FUNCTION
2876 krb5_enctype_to_keytype(krb5_context context,
2877                         krb5_enctype etype,
2878                         krb5_keytype *keytype)
2879 {
2880     struct encryption_type *e = _find_enctype(etype);
2881     if(e == NULL) {
2882         krb5_set_error_string (context, "encryption type %d not supported",
2883                                etype);
2884         return KRB5_PROG_ETYPE_NOSUPP;
2885     }
2886     *keytype = e->keytype->type; /* XXX */
2887     return 0;
2888 }
2889
2890 #if 0
2891 krb5_error_code KRB5_LIB_FUNCTION
2892 krb5_keytype_to_enctype(krb5_context context,
2893                         krb5_keytype keytype,
2894                         krb5_enctype *etype)
2895 {
2896     struct key_type *kt = _find_keytype(keytype);
2897     krb5_warnx(context, "krb5_keytype_to_enctype(%u)", keytype);
2898     if(kt == NULL)
2899         return KRB5_PROG_KEYTYPE_NOSUPP;
2900     *etype = kt->best_etype;
2901     return 0;
2902 }
2903 #endif
2904     
2905 krb5_error_code KRB5_LIB_FUNCTION
2906 krb5_keytype_to_enctypes (krb5_context context,
2907                           krb5_keytype keytype,
2908                           unsigned *len,
2909                           krb5_enctype **val)
2910 {
2911     int i;
2912     unsigned n = 0;
2913     krb5_enctype *ret;
2914
2915     for (i = num_etypes - 1; i >= 0; --i) {
2916         if (etypes[i]->keytype->type == keytype
2917             && !(etypes[i]->flags & F_PSEUDO))
2918             ++n;
2919     }
2920     ret = malloc(n * sizeof(*ret));
2921     if (ret == NULL && n != 0) {
2922         krb5_set_error_string(context, "malloc: out of memory");
2923         return ENOMEM;
2924     }
2925     n = 0;
2926     for (i = num_etypes - 1; i >= 0; --i) {
2927         if (etypes[i]->keytype->type == keytype
2928             && !(etypes[i]->flags & F_PSEUDO))
2929             ret[n++] = etypes[i]->type;
2930     }
2931     *len = n;
2932     *val = ret;
2933     return 0;
2934 }
2935
2936 /*
2937  * First take the configured list of etypes for `keytype' if available,
2938  * else, do `krb5_keytype_to_enctypes'.
2939  */
2940
2941 krb5_error_code KRB5_LIB_FUNCTION
2942 krb5_keytype_to_enctypes_default (krb5_context context,
2943                                   krb5_keytype keytype,
2944                                   unsigned *len,
2945                                   krb5_enctype **val)
2946 {
2947     int i, n;
2948     krb5_enctype *ret;
2949
2950     if (keytype != KEYTYPE_DES || context->etypes_des == NULL)
2951         return krb5_keytype_to_enctypes (context, keytype, len, val);
2952
2953     for (n = 0; context->etypes_des[n]; ++n)
2954         ;
2955     ret = malloc (n * sizeof(*ret));
2956     if (ret == NULL && n != 0) {
2957         krb5_set_error_string(context, "malloc: out of memory");
2958         return ENOMEM;
2959     }
2960     for (i = 0; i < n; ++i)
2961         ret[i] = context->etypes_des[i];
2962     *len = n;
2963     *val = ret;
2964     return 0;
2965 }
2966
2967 krb5_error_code KRB5_LIB_FUNCTION
2968 krb5_enctype_valid(krb5_context context, 
2969                  krb5_enctype etype)
2970 {
2971     struct encryption_type *e = _find_enctype(etype);
2972     if(e == NULL) {
2973         krb5_set_error_string (context, "encryption type %d not supported",
2974                                etype);
2975         return KRB5_PROG_ETYPE_NOSUPP;
2976     }
2977     if (e->flags & F_DISABLED) {
2978         krb5_set_error_string (context, "encryption type %s is disabled",
2979                                e->name);
2980         return KRB5_PROG_ETYPE_NOSUPP;
2981     }
2982     return 0;
2983 }
2984
2985 krb5_error_code KRB5_LIB_FUNCTION
2986 krb5_cksumtype_valid(krb5_context context, 
2987                      krb5_cksumtype ctype)
2988 {
2989     struct checksum_type *c = _find_checksum(ctype);
2990     if (c == NULL) {
2991         krb5_set_error_string (context, "checksum type %d not supported",
2992                                ctype);
2993         return KRB5_PROG_SUMTYPE_NOSUPP;
2994     }
2995     if (c->flags & F_DISABLED) {
2996         krb5_set_error_string (context, "checksum type %s is disabled",
2997                                c->name);
2998         return KRB5_PROG_SUMTYPE_NOSUPP;
2999     }
3000     return 0;
3001 }
3002
3003
3004 /* if two enctypes have compatible keys */
3005 krb5_boolean KRB5_LIB_FUNCTION
3006 krb5_enctypes_compatible_keys(krb5_context context,
3007                               krb5_enctype etype1,
3008                               krb5_enctype etype2)
3009 {
3010     struct encryption_type *e1 = _find_enctype(etype1);
3011     struct encryption_type *e2 = _find_enctype(etype2);
3012     return e1 != NULL && e2 != NULL && e1->keytype == e2->keytype;
3013 }
3014
3015 static krb5_boolean
3016 derived_crypto(krb5_context context,
3017                krb5_crypto crypto)
3018 {
3019     return (crypto->et->flags & F_DERIVED) != 0;
3020 }
3021
3022 static krb5_boolean
3023 special_crypto(krb5_context context,
3024                krb5_crypto crypto)
3025 {
3026     return (crypto->et->flags & F_SPECIAL) != 0;
3027 }
3028
3029 #define CHECKSUMSIZE(C) ((C)->checksumsize)
3030 #define CHECKSUMTYPE(C) ((C)->type)
3031
3032 static krb5_error_code
3033 encrypt_internal_derived(krb5_context context,
3034                          krb5_crypto crypto,
3035                          unsigned usage,
3036                          const void *data,
3037                          size_t len,
3038                          krb5_data *result,
3039                          void *ivec)
3040 {
3041     size_t sz, block_sz, checksum_sz, total_sz;
3042     Checksum cksum;
3043     unsigned char *p, *q;
3044     krb5_error_code ret;
3045     struct key_data *dkey;
3046     const struct encryption_type *et = crypto->et;
3047     
3048     checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
3049
3050     sz = et->confoundersize + len;
3051     block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
3052     total_sz = block_sz + checksum_sz;
3053     p = calloc(1, total_sz);
3054     if(p == NULL) {
3055         krb5_set_error_string(context, "malloc: out of memory");
3056         return ENOMEM;
3057     }
3058     
3059     q = p;
3060     krb5_generate_random_block(q, et->confoundersize); /* XXX */
3061     q += et->confoundersize;
3062     memcpy(q, data, len);
3063     
3064     ret = create_checksum(context, 
3065                           et->keyed_checksum,
3066                           crypto, 
3067                           INTEGRITY_USAGE(usage),
3068                           p, 
3069                           block_sz,
3070                           &cksum);
3071     if(ret == 0 && cksum.checksum.length != checksum_sz) {
3072         free_Checksum (&cksum);
3073         krb5_clear_error_string (context);
3074         ret = KRB5_CRYPTO_INTERNAL;
3075     }
3076     if(ret)
3077         goto fail;
3078     memcpy(p + block_sz, cksum.checksum.data, cksum.checksum.length);
3079     free_Checksum (&cksum);
3080     ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
3081     if(ret)
3082         goto fail;
3083     ret = _key_schedule(context, dkey, crypto->params);
3084     if(ret)
3085         goto fail;
3086 #ifdef CRYPTO_DEBUG
3087     krb5_crypto_debug(context, 1, block_sz, dkey->key);
3088 #endif
3089     ret = (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
3090     if (ret)
3091         goto fail;
3092     result->data = p;
3093     result->length = total_sz;
3094     return 0;
3095  fail:
3096     memset(p, 0, total_sz);
3097     free(p);
3098     return ret;
3099 }
3100
3101
3102 static krb5_error_code
3103 encrypt_internal(krb5_context context,
3104                  krb5_crypto crypto,
3105                  const void *data,
3106                  size_t len,
3107                  krb5_data *result,
3108                  void *ivec)
3109 {
3110     size_t sz, block_sz, checksum_sz;
3111     Checksum cksum;
3112     unsigned char *p, *q;
3113     krb5_error_code ret;
3114     const struct encryption_type *et = crypto->et;
3115     
3116     checksum_sz = CHECKSUMSIZE(et->checksum);
3117     
3118     sz = et->confoundersize + checksum_sz + len;
3119     block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
3120     p = calloc(1, block_sz);
3121     if(p == NULL) {
3122         krb5_set_error_string(context, "malloc: out of memory");
3123         return ENOMEM;
3124     }
3125     
3126     q = p;
3127     krb5_generate_random_block(q, et->confoundersize); /* XXX */
3128     q += et->confoundersize;
3129     memset(q, 0, checksum_sz);
3130     q += checksum_sz;
3131     memcpy(q, data, len);
3132
3133     ret = create_checksum(context, 
3134                           et->checksum,
3135                           crypto,
3136                           0,
3137                           p, 
3138                           block_sz,
3139                           &cksum);
3140     if(ret == 0 && cksum.checksum.length != checksum_sz) {
3141         krb5_clear_error_string (context);
3142         free_Checksum(&cksum);
3143         ret = KRB5_CRYPTO_INTERNAL;
3144     }
3145     if(ret)
3146         goto fail;
3147     memcpy(p + et->confoundersize, cksum.checksum.data, cksum.checksum.length);
3148     free_Checksum(&cksum);
3149     ret = _key_schedule(context, &crypto->key, crypto->params);
3150     if(ret)
3151         goto fail;
3152 #ifdef CRYPTO_DEBUG
3153     krb5_crypto_debug(context, 1, block_sz, crypto->key.key);
3154 #endif
3155     ret = (*et->encrypt)(context, &crypto->key, p, block_sz, 1, 0, ivec);
3156     if (ret) {
3157         memset(p, 0, block_sz);
3158         free(p);
3159         return ret;
3160     }
3161     result->data = p;
3162     result->length = block_sz;
3163     return 0;
3164  fail:
3165     memset(p, 0, block_sz);
3166     free(p);
3167     return ret;
3168 }
3169
3170 static krb5_error_code
3171 encrypt_internal_special(krb5_context context,
3172                          krb5_crypto crypto,
3173                          int usage,
3174                          const void *data,
3175                          size_t len,
3176                          krb5_data *result,
3177                          void *ivec)
3178 {
3179     struct encryption_type *et = crypto->et;
3180     size_t cksum_sz = CHECKSUMSIZE(et->checksum);
3181     size_t sz = len + cksum_sz + et->confoundersize;
3182     char *tmp, *p;
3183     krb5_error_code ret;
3184
3185     tmp = malloc (sz);
3186     if (tmp == NULL) {
3187         krb5_set_error_string(context, "malloc: out of memory");
3188         return ENOMEM;
3189     }
3190     p = tmp;
3191     memset (p, 0, cksum_sz);
3192     p += cksum_sz;
3193     krb5_generate_random_block(p, et->confoundersize);
3194     p += et->confoundersize;
3195     memcpy (p, data, len);
3196     ret = (*et->encrypt)(context, &crypto->key, tmp, sz, TRUE, usage, ivec);
3197     if (ret) {
3198         memset(tmp, 0, sz);
3199         free(tmp);
3200         return ret;
3201     }
3202     result->data   = tmp;
3203     result->length = sz;
3204     return 0;
3205 }
3206
3207 static krb5_error_code
3208 decrypt_internal_derived(krb5_context context,
3209                          krb5_crypto crypto,
3210                          unsigned usage,
3211                          void *data,
3212                          size_t len,
3213                          krb5_data *result,
3214                          void *ivec)
3215 {
3216     size_t checksum_sz;
3217     Checksum cksum;
3218     unsigned char *p;
3219     krb5_error_code ret;
3220     struct key_data *dkey;
3221     struct encryption_type *et = crypto->et;
3222     unsigned long l;
3223     
3224     checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
3225     if (len < checksum_sz) {
3226         krb5_clear_error_string (context);
3227         return EINVAL;          /* XXX - better error code? */
3228     }
3229
3230     if (((len - checksum_sz) % et->padsize) != 0) {
3231         krb5_clear_error_string(context);
3232         return KRB5_BAD_MSIZE;
3233     }
3234
3235     p = malloc(len);
3236     if(len != 0 && p == NULL) {
3237         krb5_set_error_string(context, "malloc: out of memory");
3238         return ENOMEM;
3239     }
3240     memcpy(p, data, len);
3241
3242     len -= checksum_sz;
3243
3244     ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
3245     if(ret) {
3246         free(p);
3247         return ret;
3248     }
3249     ret = _key_schedule(context, dkey, crypto->params);
3250     if(ret) {
3251         free(p);
3252         return ret;
3253     }
3254 #ifdef CRYPTO_DEBUG
3255     krb5_crypto_debug(context, 0, len, dkey->key);
3256 #endif
3257     ret = (*et->encrypt)(context, dkey, p, len, 0, usage, ivec);
3258     if (ret) {
3259         free(p);
3260         return ret;
3261     }
3262
3263     cksum.checksum.data   = p + len;
3264     cksum.checksum.length = checksum_sz;
3265     cksum.cksumtype       = CHECKSUMTYPE(et->keyed_checksum);
3266
3267     ret = verify_checksum(context,
3268                           crypto,
3269                           INTEGRITY_USAGE(usage),
3270                           p,
3271                           len,
3272                           &cksum);
3273     if(ret) {
3274         free(p);
3275         return ret;
3276     }
3277     l = len - et->confoundersize;
3278     memmove(p, p + et->confoundersize, l);
3279     result->data = realloc(p, l);
3280     if(result->data == NULL && l != 0) {
3281         free(p);
3282         krb5_set_error_string(context, "malloc: out of memory");
3283         return ENOMEM;
3284     }
3285     result->length = l;
3286     return 0;
3287 }
3288
3289 static krb5_error_code
3290 decrypt_internal(krb5_context context,
3291                  krb5_crypto crypto,
3292                  void *data,
3293                  size_t len,
3294                  krb5_data *result,
3295                  void *ivec)
3296 {
3297     krb5_error_code ret;
3298     unsigned char *p;
3299     Checksum cksum;
3300     size_t checksum_sz, l;
3301     struct encryption_type *et = crypto->et;
3302     
3303     if ((len % et->padsize) != 0) {
3304         krb5_clear_error_string(context);
3305         return KRB5_BAD_MSIZE;
3306     }
3307
3308     checksum_sz = CHECKSUMSIZE(et->checksum);
3309     p = malloc(len);
3310     if(len != 0 && p == NULL) {
3311         krb5_set_error_string(context, "malloc: out of memory");
3312         return ENOMEM;
3313     }
3314     memcpy(p, data, len);
3315     
3316     ret = _key_schedule(context, &crypto->key, crypto->params);
3317     if(ret) {
3318         free(p);
3319         return ret;
3320     }
3321 #ifdef CRYPTO_DEBUG
3322     krb5_crypto_debug(context, 0, len, crypto->key.key);
3323 #endif
3324     ret = (*et->encrypt)(context, &crypto->key, p, len, 0, 0, ivec);
3325     if (ret) {
3326         free(p);
3327         return ret;
3328     }
3329     ret = krb5_data_copy(&cksum.checksum, p + et->confoundersize, checksum_sz);
3330     if(ret) {
3331         free(p);
3332         return ret;
3333     }
3334     memset(p + et->confoundersize, 0, checksum_sz);
3335     cksum.cksumtype = CHECKSUMTYPE(et->checksum);
3336     ret = verify_checksum(context, NULL, 0, p, len, &cksum);
3337     free_Checksum(&cksum);
3338     if(ret) {
3339         free(p);
3340         return ret;
3341     }
3342     l = len - et->confoundersize - checksum_sz;
3343     memmove(p, p + et->confoundersize + checksum_sz, l);
3344     result->data = realloc(p, l);
3345     if(result->data == NULL && l != 0) {
3346         free(p);
3347         krb5_set_error_string(context, "malloc: out of memory");
3348         return ENOMEM;
3349     }
3350     result->length = l;
3351     return 0;
3352 }
3353
3354 static krb5_error_code
3355 decrypt_internal_special(krb5_context context,
3356                          krb5_crypto crypto,
3357                          int usage,
3358                          void *data,
3359                          size_t len,
3360                          krb5_data *result,
3361                          void *ivec)
3362 {
3363     struct encryption_type *et = crypto->et;
3364     size_t cksum_sz = CHECKSUMSIZE(et->checksum);
3365     size_t sz = len - cksum_sz - et->confoundersize;
3366     unsigned char *p;
3367     krb5_error_code ret;
3368
3369     if ((len % et->padsize) != 0) {
3370         krb5_clear_error_string(context);
3371         return KRB5_BAD_MSIZE;
3372     }
3373
3374     p = malloc (len);
3375     if (p == NULL) {
3376         krb5_set_error_string(context, "malloc: out of memory");
3377         return ENOMEM;
3378     }
3379     memcpy(p, data, len);
3380     
3381     ret = (*et->encrypt)(context, &crypto->key, p, len, FALSE, usage, ivec);
3382     if (ret) {
3383         free(p);
3384         return ret;
3385     }
3386
3387     memmove (p, p + cksum_sz + et->confoundersize, sz);
3388     result->data = realloc(p, sz);
3389     if(result->data == NULL && sz != 0) {
3390         free(p);
3391         krb5_set_error_string(context, "malloc: out of memory");
3392         return ENOMEM;
3393     }
3394     result->length = sz;
3395     return 0;
3396 }
3397
3398
3399 krb5_error_code KRB5_LIB_FUNCTION
3400 krb5_encrypt_ivec(krb5_context context,
3401                   krb5_crypto crypto,
3402                   unsigned usage,
3403                   const void *data,
3404                   size_t len,
3405                   krb5_data *result,
3406                   void *ivec)
3407 {
3408     if(derived_crypto(context, crypto))
3409         return encrypt_internal_derived(context, crypto, usage, 
3410                                         data, len, result, ivec);
3411     else if (special_crypto(context, crypto))
3412         return encrypt_internal_special (context, crypto, usage,
3413                                          data, len, result, ivec);
3414     else
3415         return encrypt_internal(context, crypto, data, len, result, ivec);
3416 }
3417
3418 krb5_error_code KRB5_LIB_FUNCTION
3419 krb5_encrypt(krb5_context context,
3420              krb5_crypto crypto,
3421              unsigned usage,
3422              const void *data,
3423              size_t len,
3424              krb5_data *result)
3425 {
3426     return krb5_encrypt_ivec(context, crypto, usage, data, len, result, NULL);
3427 }
3428
3429 krb5_error_code KRB5_LIB_FUNCTION
3430 krb5_encrypt_EncryptedData(krb5_context context,
3431                            krb5_crypto crypto,
3432                            unsigned usage,
3433                            void *data,
3434                            size_t len,
3435                            int kvno,
3436                            EncryptedData *result)
3437 {
3438     result->etype = CRYPTO_ETYPE(crypto);
3439     if(kvno){
3440         ALLOC(result->kvno, 1);
3441         *result->kvno = kvno;
3442     }else
3443         result->kvno = NULL;
3444     return krb5_encrypt(context, crypto, usage, data, len, &result->cipher);
3445 }
3446
3447 krb5_error_code KRB5_LIB_FUNCTION
3448 krb5_decrypt_ivec(krb5_context context,
3449                   krb5_crypto crypto,
3450                   unsigned usage,
3451                   void *data,
3452                   size_t len,
3453                   krb5_data *result,
3454                   void *ivec)
3455 {
3456     if(derived_crypto(context, crypto))
3457         return decrypt_internal_derived(context, crypto, usage, 
3458                                         data, len, result, ivec);
3459     else if (special_crypto (context, crypto))
3460         return decrypt_internal_special(context, crypto, usage,
3461                                         data, len, result, ivec);
3462     else
3463         return decrypt_internal(context, crypto, data, len, result, ivec);
3464 }
3465
3466 krb5_error_code KRB5_LIB_FUNCTION
3467 krb5_decrypt(krb5_context context,
3468              krb5_crypto crypto,
3469              unsigned usage,
3470              void *data,
3471              size_t len,
3472              krb5_data *result)
3473 {
3474     return krb5_decrypt_ivec (context, crypto, usage, data, len, result,
3475                               NULL);
3476 }
3477
3478 krb5_error_code KRB5_LIB_FUNCTION
3479 krb5_decrypt_EncryptedData(krb5_context context,
3480                            krb5_crypto crypto,
3481                            unsigned usage,
3482                            const EncryptedData *e,
3483                            krb5_data *result)
3484 {
3485     return krb5_decrypt(context, crypto, usage, 
3486                         e->cipher.data, e->cipher.length, result);
3487 }
3488
3489 /************************************************************
3490  *                                                          *
3491  ************************************************************/
3492
3493 #ifdef HAVE_OPENSSL
3494 #include <openssl/rand.h>