Import of code from heimdal
[openafs.git] / src / external / heimdal / krb5 / crypto.c
1 /*
2  * Copyright (c) 1997 - 2008 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
36 struct _krb5_key_usage {
37     unsigned usage;
38     struct _krb5_key_data key;
39 };
40
41
42 #ifndef HEIMDAL_SMALLER
43 #define DES3_OLD_ENCTYPE 1
44 #endif
45
46 static krb5_error_code _get_derived_key(krb5_context, krb5_crypto,
47                                         unsigned, struct _krb5_key_data**);
48 static struct _krb5_key_data *_new_derived_key(krb5_crypto crypto, unsigned usage);
49
50 static void free_key_schedule(krb5_context,
51                               struct _krb5_key_data *,
52                               struct _krb5_encryption_type *);
53
54 /*
55  * Converts etype to a user readable string and sets as a side effect
56  * the krb5_error_message containing this string. Returns
57  * KRB5_PROG_ETYPE_NOSUPP in not the conversion of the etype failed in
58  * which case the error code of the etype convesion is returned.
59  */
60
61 static krb5_error_code
62 unsupported_enctype(krb5_context context, krb5_enctype etype)
63 {
64     krb5_error_code ret;
65     char *name;
66
67     ret = krb5_enctype_to_string(context, etype, &name);
68     if (ret)
69         return ret;
70
71     krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
72                            N_("Encryption type %s not supported", ""),
73                            name);
74     free(name);
75     return KRB5_PROG_ETYPE_NOSUPP;
76 }
77
78 /*
79  *
80  */
81
82 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
83 krb5_enctype_keysize(krb5_context context,
84                      krb5_enctype type,
85                      size_t *keysize)
86 {
87     struct _krb5_encryption_type *et = _krb5_find_enctype(type);
88     if(et == NULL) {
89         return unsupported_enctype (context, type);
90     }
91     *keysize = et->keytype->size;
92     return 0;
93 }
94
95 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
96 krb5_enctype_keybits(krb5_context context,
97                      krb5_enctype type,
98                      size_t *keybits)
99 {
100     struct _krb5_encryption_type *et = _krb5_find_enctype(type);
101     if(et == NULL) {
102         return unsupported_enctype (context, type);
103     }
104     *keybits = et->keytype->bits;
105     return 0;
106 }
107
108 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
109 krb5_generate_random_keyblock(krb5_context context,
110                               krb5_enctype type,
111                               krb5_keyblock *key)
112 {
113     krb5_error_code ret;
114     struct _krb5_encryption_type *et = _krb5_find_enctype(type);
115     if(et == NULL) {
116         return unsupported_enctype (context, type);
117     }
118     ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
119     if(ret)
120         return ret;
121     key->keytype = type;
122     if(et->keytype->random_key)
123         (*et->keytype->random_key)(context, key);
124     else
125         krb5_generate_random_block(key->keyvalue.data,
126                                    key->keyvalue.length);
127     return 0;
128 }
129
130 static krb5_error_code
131 _key_schedule(krb5_context context,
132               struct _krb5_key_data *key)
133 {
134     krb5_error_code ret;
135     struct _krb5_encryption_type *et = _krb5_find_enctype(key->key->keytype);
136     struct _krb5_key_type *kt;
137
138     if (et == NULL) {
139         return unsupported_enctype (context,
140                                key->key->keytype);
141     }
142
143     kt = et->keytype;
144
145     if(kt->schedule == NULL)
146         return 0;
147     if (key->schedule != NULL)
148         return 0;
149     ALLOC(key->schedule, 1);
150     if (key->schedule == NULL)
151         return krb5_enomem(context);
152     ret = krb5_data_alloc(key->schedule, kt->schedule_size);
153     if(ret) {
154         free(key->schedule);
155         key->schedule = NULL;
156         return ret;
157     }
158     (*kt->schedule)(context, kt, key);
159     return 0;
160 }
161
162 /************************************************************
163  *                                                          *
164  ************************************************************/
165
166 static krb5_error_code
167 SHA1_checksum(krb5_context context,
168               struct _krb5_key_data *key,
169               const void *data,
170               size_t len,
171               unsigned usage,
172               Checksum *C)
173 {
174     if (EVP_Digest(data, len, C->checksum.data, NULL, EVP_sha1(), NULL) != 1)
175         krb5_abortx(context, "sha1 checksum failed");
176     return 0;
177 }
178
179 /* HMAC according to RFC2104 */
180 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
181 _krb5_internal_hmac(krb5_context context,
182                     struct _krb5_checksum_type *cm,
183                     const void *data,
184                     size_t len,
185                     unsigned usage,
186                     struct _krb5_key_data *keyblock,
187                     Checksum *result)
188 {
189     unsigned char *ipad, *opad;
190     unsigned char *key;
191     size_t key_len;
192     size_t i;
193
194     ipad = malloc(cm->blocksize + len);
195     if (ipad == NULL)
196         return ENOMEM;
197     opad = malloc(cm->blocksize + cm->checksumsize);
198     if (opad == NULL) {
199         free(ipad);
200         return ENOMEM;
201     }
202     memset(ipad, 0x36, cm->blocksize);
203     memset(opad, 0x5c, cm->blocksize);
204
205     if(keyblock->key->keyvalue.length > cm->blocksize){
206         (*cm->checksum)(context,
207                         keyblock,
208                         keyblock->key->keyvalue.data,
209                         keyblock->key->keyvalue.length,
210                         usage,
211                         result);
212         key = result->checksum.data;
213         key_len = result->checksum.length;
214     } else {
215         key = keyblock->key->keyvalue.data;
216         key_len = keyblock->key->keyvalue.length;
217     }
218     for(i = 0; i < key_len; i++){
219         ipad[i] ^= key[i];
220         opad[i] ^= key[i];
221     }
222     memcpy(ipad + cm->blocksize, data, len);
223     (*cm->checksum)(context, keyblock, ipad, cm->blocksize + len,
224                     usage, result);
225     memcpy(opad + cm->blocksize, result->checksum.data,
226            result->checksum.length);
227     (*cm->checksum)(context, keyblock, opad,
228                     cm->blocksize + cm->checksumsize, usage, result);
229     memset(ipad, 0, cm->blocksize + len);
230     free(ipad);
231     memset(opad, 0, cm->blocksize + cm->checksumsize);
232     free(opad);
233
234     return 0;
235 }
236
237 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
238 krb5_hmac(krb5_context context,
239           krb5_cksumtype cktype,
240           const void *data,
241           size_t len,
242           unsigned usage,
243           krb5_keyblock *key,
244           Checksum *result)
245 {
246     struct _krb5_checksum_type *c = _krb5_find_checksum(cktype);
247     struct _krb5_key_data kd;
248     krb5_error_code ret;
249
250     if (c == NULL) {
251         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
252                                 N_("checksum type %d not supported", ""),
253                                 cktype);
254         return KRB5_PROG_SUMTYPE_NOSUPP;
255     }
256
257     kd.key = key;
258     kd.schedule = NULL;
259
260     ret = _krb5_internal_hmac(context, c, data, len, usage, &kd, result);
261
262     if (kd.schedule)
263         krb5_free_data(context, kd.schedule);
264
265     return ret;
266 }
267
268 krb5_error_code
269 _krb5_SP_HMAC_SHA1_checksum(krb5_context context,
270                             struct _krb5_key_data *key,
271                             const void *data,
272                             size_t len,
273                             unsigned usage,
274                             Checksum *result)
275 {
276     struct _krb5_checksum_type *c = _krb5_find_checksum(CKSUMTYPE_SHA1);
277     Checksum res;
278     char sha1_data[20];
279     krb5_error_code ret;
280
281     res.checksum.data = sha1_data;
282     res.checksum.length = sizeof(sha1_data);
283
284     ret = _krb5_internal_hmac(context, c, data, len, usage, key, &res);
285     if (ret)
286         krb5_abortx(context, "hmac failed");
287     memcpy(result->checksum.data, res.checksum.data, result->checksum.length);
288     return 0;
289 }
290
291 struct _krb5_checksum_type _krb5_checksum_sha1 = {
292     CKSUMTYPE_SHA1,
293     "sha1",
294     64,
295     20,
296     F_CPROOF,
297     SHA1_checksum,
298     NULL
299 };
300
301 KRB5_LIB_FUNCTION struct _krb5_checksum_type * KRB5_LIB_CALL
302 _krb5_find_checksum(krb5_cksumtype type)
303 {
304     int i;
305     for(i = 0; i < _krb5_num_checksums; i++)
306         if(_krb5_checksum_types[i]->type == type)
307             return _krb5_checksum_types[i];
308     return NULL;
309 }
310
311 static krb5_error_code
312 get_checksum_key(krb5_context context,
313                  krb5_crypto crypto,
314                  unsigned usage,  /* not krb5_key_usage */
315                  struct _krb5_checksum_type *ct,
316                  struct _krb5_key_data **key)
317 {
318     krb5_error_code ret = 0;
319
320     if(ct->flags & F_DERIVED)
321         ret = _get_derived_key(context, crypto, usage, key);
322     else if(ct->flags & F_VARIANT) {
323         size_t i;
324
325         *key = _new_derived_key(crypto, 0xff/* KRB5_KU_RFC1510_VARIANT */);
326         if (*key == NULL)
327             return krb5_enomem(context);
328         ret = krb5_copy_keyblock(context, crypto->key.key, &(*key)->key);
329         if(ret)
330             return ret;
331         for(i = 0; i < (*key)->key->keyvalue.length; i++)
332             ((unsigned char*)(*key)->key->keyvalue.data)[i] ^= 0xF0;
333     } else {
334         *key = &crypto->key;
335     }
336     if(ret == 0)
337         ret = _key_schedule(context, *key);
338     return ret;
339 }
340
341 static krb5_error_code
342 create_checksum (krb5_context context,
343                  struct _krb5_checksum_type *ct,
344                  krb5_crypto crypto,
345                  unsigned usage,
346                  void *data,
347                  size_t len,
348                  Checksum *result)
349 {
350     krb5_error_code ret;
351     struct _krb5_key_data *dkey;
352     int keyed_checksum;
353
354     if (ct->flags & F_DISABLED) {
355         krb5_clear_error_message (context);
356         return KRB5_PROG_SUMTYPE_NOSUPP;
357     }
358     keyed_checksum = (ct->flags & F_KEYED) != 0;
359     if(keyed_checksum && crypto == NULL) {
360         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
361                                 N_("Checksum type %s is keyed but no "
362                                    "crypto context (key) was passed in", ""),
363                                 ct->name);
364         return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
365     }
366     if(keyed_checksum) {
367         ret = get_checksum_key(context, crypto, usage, ct, &dkey);
368         if (ret)
369             return ret;
370     } else
371         dkey = NULL;
372     result->cksumtype = ct->type;
373     ret = krb5_data_alloc(&result->checksum, ct->checksumsize);
374     if (ret)
375         return (ret);
376     return (*ct->checksum)(context, dkey, data, len, usage, result);
377 }
378
379 static int
380 arcfour_checksum_p(struct _krb5_checksum_type *ct, krb5_crypto crypto)
381 {
382     return (ct->type == CKSUMTYPE_HMAC_MD5) &&
383         (crypto->key.key->keytype == KEYTYPE_ARCFOUR);
384 }
385
386 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
387 krb5_create_checksum(krb5_context context,
388                      krb5_crypto crypto,
389                      krb5_key_usage usage,
390                      int type,
391                      void *data,
392                      size_t len,
393                      Checksum *result)
394 {
395     struct _krb5_checksum_type *ct = NULL;
396     unsigned keyusage;
397
398     /* type 0 -> pick from crypto */
399     if (type) {
400         ct = _krb5_find_checksum(type);
401     } else if (crypto) {
402         ct = crypto->et->keyed_checksum;
403         if (ct == NULL)
404             ct = crypto->et->checksum;
405     }
406
407     if(ct == NULL) {
408         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
409                                 N_("checksum type %d not supported", ""),
410                                 type);
411         return KRB5_PROG_SUMTYPE_NOSUPP;
412     }
413
414     if (arcfour_checksum_p(ct, crypto)) {
415         keyusage = usage;
416         _krb5_usage2arcfour(context, &keyusage);
417     } else
418         keyusage = CHECKSUM_USAGE(usage);
419
420     return create_checksum(context, ct, crypto, keyusage,
421                            data, len, result);
422 }
423
424 static krb5_error_code
425 verify_checksum(krb5_context context,
426                 krb5_crypto crypto,
427                 unsigned usage, /* not krb5_key_usage */
428                 void *data,
429                 size_t len,
430                 Checksum *cksum)
431 {
432     krb5_error_code ret;
433     struct _krb5_key_data *dkey;
434     int keyed_checksum;
435     Checksum c;
436     struct _krb5_checksum_type *ct;
437
438     ct = _krb5_find_checksum(cksum->cksumtype);
439     if (ct == NULL || (ct->flags & F_DISABLED)) {
440         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
441                                 N_("checksum type %d not supported", ""),
442                                 cksum->cksumtype);
443         return KRB5_PROG_SUMTYPE_NOSUPP;
444     }
445     if(ct->checksumsize != cksum->checksum.length) {
446         krb5_clear_error_message (context);
447         krb5_set_error_message(context, KRB5KRB_AP_ERR_BAD_INTEGRITY,
448                                N_("Decrypt integrity check failed for checksum type %s, "
449                                   "length was %u, expected %u", ""),
450                                ct->name, (unsigned)cksum->checksum.length,
451                                (unsigned)ct->checksumsize);
452
453         return KRB5KRB_AP_ERR_BAD_INTEGRITY; /* XXX */
454     }
455     keyed_checksum = (ct->flags & F_KEYED) != 0;
456     if(keyed_checksum) {
457         struct _krb5_checksum_type *kct;
458         if (crypto == NULL) {
459             krb5_set_error_message(context, KRB5_PROG_SUMTYPE_NOSUPP,
460                                    N_("Checksum type %s is keyed but no "
461                                       "crypto context (key) was passed in", ""),
462                                    ct->name);
463             return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
464         }
465         kct = crypto->et->keyed_checksum;
466         if (kct == NULL || kct->type != ct->type) {
467             krb5_set_error_message(context, KRB5_PROG_SUMTYPE_NOSUPP,
468                                    N_("Checksum type %s is keyed, but "
469                                       "the key type %s passed didnt have that checksum "
470                                       "type as the keyed type", ""),
471                                     ct->name, crypto->et->name);
472             return KRB5_PROG_SUMTYPE_NOSUPP; /* XXX */
473         }
474
475         ret = get_checksum_key(context, crypto, usage, ct, &dkey);
476         if (ret)
477             return ret;
478     } else
479         dkey = NULL;
480
481     /*
482      * If checksum have a verify function, lets use that instead of
483      * calling ->checksum and then compare result.
484      */
485
486     if(ct->verify) {
487         ret = (*ct->verify)(context, dkey, data, len, usage, cksum);
488         if (ret)
489             krb5_set_error_message(context, ret,
490                                    N_("Decrypt integrity check failed for checksum "
491                                       "type %s, key type %s", ""),
492                                    ct->name, (crypto != NULL)? crypto->et->name : "(none)");
493         return ret;
494     }
495
496     ret = krb5_data_alloc (&c.checksum, ct->checksumsize);
497     if (ret)
498         return ret;
499
500     ret = (*ct->checksum)(context, dkey, data, len, usage, &c);
501     if (ret) {
502         krb5_data_free(&c.checksum);
503         return ret;
504     }
505
506     if(krb5_data_ct_cmp(&c.checksum, &cksum->checksum) != 0) {
507         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
508         krb5_set_error_message(context, ret,
509                                N_("Decrypt integrity check failed for checksum "
510                                   "type %s, key type %s", ""),
511                                ct->name, crypto ? crypto->et->name : "(unkeyed)");
512     } else {
513         ret = 0;
514     }
515     krb5_data_free (&c.checksum);
516     return ret;
517 }
518
519 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
520 krb5_verify_checksum(krb5_context context,
521                      krb5_crypto crypto,
522                      krb5_key_usage usage,
523                      void *data,
524                      size_t len,
525                      Checksum *cksum)
526 {
527     struct _krb5_checksum_type *ct;
528     unsigned keyusage;
529
530     ct = _krb5_find_checksum(cksum->cksumtype);
531     if(ct == NULL) {
532         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
533                                 N_("checksum type %d not supported", ""),
534                                 cksum->cksumtype);
535         return KRB5_PROG_SUMTYPE_NOSUPP;
536     }
537
538     if (arcfour_checksum_p(ct, crypto)) {
539         keyusage = usage;
540         _krb5_usage2arcfour(context, &keyusage);
541     } else
542         keyusage = CHECKSUM_USAGE(usage);
543
544     return verify_checksum(context, crypto, keyusage,
545                            data, len, cksum);
546 }
547
548 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
549 krb5_crypto_get_checksum_type(krb5_context context,
550                               krb5_crypto crypto,
551                               krb5_cksumtype *type)
552 {
553     struct _krb5_checksum_type *ct = NULL;
554
555     if (crypto != NULL) {
556         ct = crypto->et->keyed_checksum;
557         if (ct == NULL)
558             ct = crypto->et->checksum;
559     }
560
561     if (ct == NULL) {
562         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
563                                 N_("checksum type not found", ""));
564         return KRB5_PROG_SUMTYPE_NOSUPP;
565     }
566
567     *type = ct->type;
568
569     return 0;
570 }
571
572
573 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
574 krb5_checksumsize(krb5_context context,
575                   krb5_cksumtype type,
576                   size_t *size)
577 {
578     struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
579     if(ct == NULL) {
580         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
581                                 N_("checksum type %d not supported", ""),
582                                 type);
583         return KRB5_PROG_SUMTYPE_NOSUPP;
584     }
585     *size = ct->checksumsize;
586     return 0;
587 }
588
589 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
590 krb5_checksum_is_keyed(krb5_context context,
591                        krb5_cksumtype type)
592 {
593     struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
594     if(ct == NULL) {
595         if (context)
596             krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
597                                     N_("checksum type %d not supported", ""),
598                                     type);
599         return KRB5_PROG_SUMTYPE_NOSUPP;
600     }
601     return ct->flags & F_KEYED;
602 }
603
604 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
605 krb5_checksum_is_collision_proof(krb5_context context,
606                                  krb5_cksumtype type)
607 {
608     struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
609     if(ct == NULL) {
610         if (context)
611             krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
612                                     N_("checksum type %d not supported", ""),
613                                     type);
614         return KRB5_PROG_SUMTYPE_NOSUPP;
615     }
616     return ct->flags & F_CPROOF;
617 }
618
619 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
620 krb5_checksum_disable(krb5_context context,
621                       krb5_cksumtype type)
622 {
623     struct _krb5_checksum_type *ct = _krb5_find_checksum(type);
624     if(ct == NULL) {
625         if (context)
626             krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
627                                     N_("checksum type %d not supported", ""),
628                                     type);
629         return KRB5_PROG_SUMTYPE_NOSUPP;
630     }
631     ct->flags |= F_DISABLED;
632     return 0;
633 }
634
635 /************************************************************
636  *                                                          *
637  ************************************************************/
638
639 KRB5_LIB_FUNCTION struct _krb5_encryption_type * KRB5_LIB_CALL
640 _krb5_find_enctype(krb5_enctype type)
641 {
642     int i;
643     for(i = 0; i < _krb5_num_etypes; i++)
644         if(_krb5_etypes[i]->type == type)
645             return _krb5_etypes[i];
646     return NULL;
647 }
648
649
650 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
651 krb5_enctype_to_string(krb5_context context,
652                        krb5_enctype etype,
653                        char **string)
654 {
655     struct _krb5_encryption_type *e;
656     e = _krb5_find_enctype(etype);
657     if(e == NULL) {
658         krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
659                                 N_("encryption type %d not supported", ""),
660                                 etype);
661         *string = NULL;
662         return KRB5_PROG_ETYPE_NOSUPP;
663     }
664     *string = strdup(e->name);
665     if (*string == NULL)
666         return krb5_enomem(context);
667     return 0;
668 }
669
670 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
671 krb5_string_to_enctype(krb5_context context,
672                        const char *string,
673                        krb5_enctype *etype)
674 {
675     int i;
676     for(i = 0; i < _krb5_num_etypes; i++) {
677         if(strcasecmp(_krb5_etypes[i]->name, string) == 0){
678             *etype = _krb5_etypes[i]->type;
679             return 0;
680         }
681         if(_krb5_etypes[i]->alias != NULL &&
682            strcasecmp(_krb5_etypes[i]->alias, string) == 0){
683             *etype = _krb5_etypes[i]->type;
684             return 0;
685         }
686     }
687     krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
688                             N_("encryption type %s not supported", ""),
689                             string);
690     return KRB5_PROG_ETYPE_NOSUPP;
691 }
692
693 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
694 krb5_enctype_to_keytype(krb5_context context,
695                         krb5_enctype etype,
696                         krb5_keytype *keytype)
697 {
698     struct _krb5_encryption_type *e = _krb5_find_enctype(etype);
699     if(e == NULL) {
700         return unsupported_enctype (context, etype);
701     }
702     *keytype = e->keytype->type; /* XXX */
703     return 0;
704 }
705
706 /**
707  * Check if a enctype is valid, return 0 if it is.
708  *
709  * @param context Kerberos context
710  * @param etype enctype to check if its valid or not
711  *
712  * @return Return an error code for an failure or 0 on success (enctype valid).
713  * @ingroup krb5_crypto
714  */
715
716 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
717 krb5_enctype_valid(krb5_context context,
718                    krb5_enctype etype)
719 {
720     struct _krb5_encryption_type *e = _krb5_find_enctype(etype);
721     if(e && (e->flags & F_DISABLED) == 0)
722         return 0;
723     if (context == NULL)
724         return KRB5_PROG_ETYPE_NOSUPP;
725     if(e == NULL) {
726         return unsupported_enctype (context, etype);
727     }
728     /* Must be (e->flags & F_DISABLED) */
729     krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
730                             N_("encryption type %s is disabled", ""),
731                             e->name);
732     return KRB5_PROG_ETYPE_NOSUPP;
733 }
734
735 /**
736  * Return the coresponding encryption type for a checksum type.
737  *
738  * @param context Kerberos context
739  * @param ctype The checksum type to get the result enctype for
740  * @param etype The returned encryption, when the matching etype is
741  * not found, etype is set to ETYPE_NULL.
742  *
743  * @return Return an error code for an failure or 0 on success.
744  * @ingroup krb5_crypto
745  */
746
747
748 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
749 krb5_cksumtype_to_enctype(krb5_context context,
750                           krb5_cksumtype ctype,
751                           krb5_enctype *etype)
752 {
753     int i;
754
755     *etype = ETYPE_NULL;
756
757     for(i = 0; i < _krb5_num_etypes; i++) {
758         if(_krb5_etypes[i]->keyed_checksum &&
759            _krb5_etypes[i]->keyed_checksum->type == ctype)
760             {
761                 *etype = _krb5_etypes[i]->type;
762                 return 0;
763             }
764     }
765
766     krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
767                             N_("checksum type %d not supported", ""),
768                             (int)ctype);
769     return KRB5_PROG_SUMTYPE_NOSUPP;
770 }
771
772
773 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
774 krb5_cksumtype_valid(krb5_context context,
775                      krb5_cksumtype ctype)
776 {
777     struct _krb5_checksum_type *c = _krb5_find_checksum(ctype);
778     if (c == NULL) {
779         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
780                                 N_("checksum type %d not supported", ""),
781                                 ctype);
782         return KRB5_PROG_SUMTYPE_NOSUPP;
783     }
784     if (c->flags & F_DISABLED) {
785         krb5_set_error_message (context, KRB5_PROG_SUMTYPE_NOSUPP,
786                                 N_("checksum type %s is disabled", ""),
787                                 c->name);
788         return KRB5_PROG_SUMTYPE_NOSUPP;
789     }
790     return 0;
791 }
792
793
794 static krb5_boolean
795 derived_crypto(krb5_context context,
796                krb5_crypto crypto)
797 {
798     return (crypto->et->flags & F_DERIVED) != 0;
799 }
800
801 static krb5_boolean
802 special_crypto(krb5_context context,
803                krb5_crypto crypto)
804 {
805     return (crypto->et->flags & F_SPECIAL) != 0;
806 }
807
808 #define CHECKSUMSIZE(C) ((C)->checksumsize)
809 #define CHECKSUMTYPE(C) ((C)->type)
810
811 static krb5_error_code
812 encrypt_internal_derived(krb5_context context,
813                          krb5_crypto crypto,
814                          unsigned usage,
815                          const void *data,
816                          size_t len,
817                          krb5_data *result,
818                          void *ivec)
819 {
820     size_t sz, block_sz, checksum_sz, total_sz;
821     Checksum cksum;
822     unsigned char *p, *q;
823     krb5_error_code ret;
824     struct _krb5_key_data *dkey;
825     const struct _krb5_encryption_type *et = crypto->et;
826
827     checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
828
829     sz = et->confoundersize + len;
830     block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
831     total_sz = block_sz + checksum_sz;
832     p = calloc(1, total_sz);
833     if (p == NULL)
834         return krb5_enomem(context);
835
836     q = p;
837     krb5_generate_random_block(q, et->confoundersize); /* XXX */
838     q += et->confoundersize;
839     memcpy(q, data, len);
840
841     ret = create_checksum(context,
842                           et->keyed_checksum,
843                           crypto,
844                           INTEGRITY_USAGE(usage),
845                           p,
846                           block_sz,
847                           &cksum);
848     if(ret == 0 && cksum.checksum.length != checksum_sz) {
849         free_Checksum (&cksum);
850         krb5_clear_error_message (context);
851         ret = KRB5_CRYPTO_INTERNAL;
852     }
853     if(ret)
854         goto fail;
855     memcpy(p + block_sz, cksum.checksum.data, cksum.checksum.length);
856     free_Checksum (&cksum);
857     ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
858     if(ret)
859         goto fail;
860     ret = _key_schedule(context, dkey);
861     if(ret)
862         goto fail;
863     ret = (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
864     if (ret)
865         goto fail;
866     result->data = p;
867     result->length = total_sz;
868     return 0;
869  fail:
870     memset(p, 0, total_sz);
871     free(p);
872     return ret;
873 }
874
875
876 static krb5_error_code
877 encrypt_internal(krb5_context context,
878                  krb5_crypto crypto,
879                  const void *data,
880                  size_t len,
881                  krb5_data *result,
882                  void *ivec)
883 {
884     size_t sz, block_sz, checksum_sz;
885     Checksum cksum;
886     unsigned char *p, *q;
887     krb5_error_code ret;
888     const struct _krb5_encryption_type *et = crypto->et;
889
890     checksum_sz = CHECKSUMSIZE(et->checksum);
891
892     sz = et->confoundersize + checksum_sz + len;
893     block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
894     p = calloc(1, block_sz);
895     if (p == NULL)
896         return krb5_enomem(context);
897
898     q = p;
899     krb5_generate_random_block(q, et->confoundersize); /* XXX */
900     q += et->confoundersize;
901     memset(q, 0, checksum_sz);
902     q += checksum_sz;
903     memcpy(q, data, len);
904
905     ret = create_checksum(context,
906                           et->checksum,
907                           crypto,
908                           0,
909                           p,
910                           block_sz,
911                           &cksum);
912     if(ret == 0 && cksum.checksum.length != checksum_sz) {
913         krb5_clear_error_message (context);
914         free_Checksum(&cksum);
915         ret = KRB5_CRYPTO_INTERNAL;
916     }
917     if(ret)
918         goto fail;
919     memcpy(p + et->confoundersize, cksum.checksum.data, cksum.checksum.length);
920     free_Checksum(&cksum);
921     ret = _key_schedule(context, &crypto->key);
922     if(ret)
923         goto fail;
924     ret = (*et->encrypt)(context, &crypto->key, p, block_sz, 1, 0, ivec);
925     if (ret) {
926         memset(p, 0, block_sz);
927         free(p);
928         return ret;
929     }
930     result->data = p;
931     result->length = block_sz;
932     return 0;
933  fail:
934     memset(p, 0, block_sz);
935     free(p);
936     return ret;
937 }
938
939 static krb5_error_code
940 encrypt_internal_special(krb5_context context,
941                          krb5_crypto crypto,
942                          int usage,
943                          const void *data,
944                          size_t len,
945                          krb5_data *result,
946                          void *ivec)
947 {
948     struct _krb5_encryption_type *et = crypto->et;
949     size_t cksum_sz = CHECKSUMSIZE(et->checksum);
950     size_t sz = len + cksum_sz + et->confoundersize;
951     char *tmp, *p;
952     krb5_error_code ret;
953
954     tmp = malloc (sz);
955     if (tmp == NULL)
956         return krb5_enomem(context);
957     p = tmp;
958     memset (p, 0, cksum_sz);
959     p += cksum_sz;
960     krb5_generate_random_block(p, et->confoundersize);
961     p += et->confoundersize;
962     memcpy (p, data, len);
963     ret = (*et->encrypt)(context, &crypto->key, tmp, sz, TRUE, usage, ivec);
964     if (ret) {
965         memset(tmp, 0, sz);
966         free(tmp);
967         return ret;
968     }
969     result->data   = tmp;
970     result->length = sz;
971     return 0;
972 }
973
974 static krb5_error_code
975 decrypt_internal_derived(krb5_context context,
976                          krb5_crypto crypto,
977                          unsigned usage,
978                          void *data,
979                          size_t len,
980                          krb5_data *result,
981                          void *ivec)
982 {
983     size_t checksum_sz;
984     Checksum cksum;
985     unsigned char *p;
986     krb5_error_code ret;
987     struct _krb5_key_data *dkey;
988     struct _krb5_encryption_type *et = crypto->et;
989     unsigned long l;
990
991     checksum_sz = CHECKSUMSIZE(et->keyed_checksum);
992     if (len < checksum_sz + et->confoundersize) {
993         krb5_set_error_message(context, KRB5_BAD_MSIZE,
994                                N_("Encrypted data shorter then "
995                                   "checksum + confunder", ""));
996         return KRB5_BAD_MSIZE;
997     }
998
999     if (((len - checksum_sz) % et->padsize) != 0) {
1000         krb5_clear_error_message(context);
1001         return KRB5_BAD_MSIZE;
1002     }
1003
1004     p = malloc(len);
1005     if (len != 0 && p == NULL)
1006         return krb5_enomem(context);
1007     memcpy(p, data, len);
1008
1009     len -= checksum_sz;
1010
1011     ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1012     if(ret) {
1013         free(p);
1014         return ret;
1015     }
1016     ret = _key_schedule(context, dkey);
1017     if(ret) {
1018         free(p);
1019         return ret;
1020     }
1021     ret = (*et->encrypt)(context, dkey, p, len, 0, usage, ivec);
1022     if (ret) {
1023         free(p);
1024         return ret;
1025     }
1026
1027     cksum.checksum.data   = p + len;
1028     cksum.checksum.length = checksum_sz;
1029     cksum.cksumtype       = CHECKSUMTYPE(et->keyed_checksum);
1030
1031     ret = verify_checksum(context,
1032                           crypto,
1033                           INTEGRITY_USAGE(usage),
1034                           p,
1035                           len,
1036                           &cksum);
1037     if(ret) {
1038         free(p);
1039         return ret;
1040     }
1041     l = len - et->confoundersize;
1042     memmove(p, p + et->confoundersize, l);
1043     result->data = realloc(p, l);
1044     if(result->data == NULL && l != 0) {
1045         free(p);
1046         return krb5_enomem(context);
1047     }
1048     result->length = l;
1049     return 0;
1050 }
1051
1052 static krb5_error_code
1053 decrypt_internal(krb5_context context,
1054                  krb5_crypto crypto,
1055                  void *data,
1056                  size_t len,
1057                  krb5_data *result,
1058                  void *ivec)
1059 {
1060     krb5_error_code ret;
1061     unsigned char *p;
1062     Checksum cksum;
1063     size_t checksum_sz, l;
1064     struct _krb5_encryption_type *et = crypto->et;
1065
1066     if ((len % et->padsize) != 0) {
1067         krb5_clear_error_message(context);
1068         return KRB5_BAD_MSIZE;
1069     }
1070     checksum_sz = CHECKSUMSIZE(et->checksum);
1071     if (len < checksum_sz + et->confoundersize) {
1072         krb5_set_error_message(context, KRB5_BAD_MSIZE,
1073                                N_("Encrypted data shorter then "
1074                                   "checksum + confunder", ""));
1075         return KRB5_BAD_MSIZE;
1076     }
1077
1078     p = malloc(len);
1079     if (len != 0 && p == NULL)
1080         return krb5_enomem(context);
1081     memcpy(p, data, len);
1082
1083     ret = _key_schedule(context, &crypto->key);
1084     if(ret) {
1085         free(p);
1086         return ret;
1087     }
1088     ret = (*et->encrypt)(context, &crypto->key, p, len, 0, 0, ivec);
1089     if (ret) {
1090         free(p);
1091         return ret;
1092     }
1093     ret = krb5_data_copy(&cksum.checksum, p + et->confoundersize, checksum_sz);
1094     if(ret) {
1095         free(p);
1096         return ret;
1097     }
1098     memset(p + et->confoundersize, 0, checksum_sz);
1099     cksum.cksumtype = CHECKSUMTYPE(et->checksum);
1100     ret = verify_checksum(context, NULL, 0, p, len, &cksum);
1101     free_Checksum(&cksum);
1102     if(ret) {
1103         free(p);
1104         return ret;
1105     }
1106     l = len - et->confoundersize - checksum_sz;
1107     memmove(p, p + et->confoundersize + checksum_sz, l);
1108     result->data = realloc(p, l);
1109     if(result->data == NULL && l != 0) {
1110         free(p);
1111         return krb5_enomem(context);
1112     }
1113     result->length = l;
1114     return 0;
1115 }
1116
1117 static krb5_error_code
1118 decrypt_internal_special(krb5_context context,
1119                          krb5_crypto crypto,
1120                          int usage,
1121                          void *data,
1122                          size_t len,
1123                          krb5_data *result,
1124                          void *ivec)
1125 {
1126     struct _krb5_encryption_type *et = crypto->et;
1127     size_t cksum_sz = CHECKSUMSIZE(et->checksum);
1128     size_t sz = len - cksum_sz - et->confoundersize;
1129     unsigned char *p;
1130     krb5_error_code ret;
1131
1132     if ((len % et->padsize) != 0) {
1133         krb5_clear_error_message(context);
1134         return KRB5_BAD_MSIZE;
1135     }
1136     if (len < cksum_sz + et->confoundersize) {
1137         krb5_set_error_message(context, KRB5_BAD_MSIZE,
1138                                N_("Encrypted data shorter then "
1139                                   "checksum + confunder", ""));
1140         return KRB5_BAD_MSIZE;
1141     }
1142
1143     p = malloc (len);
1144     if (p == NULL)
1145         return krb5_enomem(context);
1146     memcpy(p, data, len);
1147
1148     ret = (*et->encrypt)(context, &crypto->key, p, len, FALSE, usage, ivec);
1149     if (ret) {
1150         free(p);
1151         return ret;
1152     }
1153
1154     memmove (p, p + cksum_sz + et->confoundersize, sz);
1155     result->data = realloc(p, sz);
1156     if(result->data == NULL && sz != 0) {
1157         free(p);
1158         return krb5_enomem(context);
1159     }
1160     result->length = sz;
1161     return 0;
1162 }
1163
1164 static krb5_crypto_iov *
1165 find_iv(krb5_crypto_iov *data, size_t num_data, unsigned type)
1166 {
1167     size_t i;
1168     for (i = 0; i < num_data; i++)
1169         if (data[i].flags == type)
1170             return &data[i];
1171     return NULL;
1172 }
1173
1174 /**
1175  * Inline encrypt a kerberos message
1176  *
1177  * @param context Kerberos context
1178  * @param crypto Kerberos crypto context
1179  * @param usage Key usage for this buffer
1180  * @param data array of buffers to process
1181  * @param num_data length of array
1182  * @param ivec initial cbc/cts vector
1183  *
1184  * @return Return an error code or 0.
1185  * @ingroup krb5_crypto
1186  *
1187  * Kerberos encrypted data look like this:
1188  *
1189  * 1. KRB5_CRYPTO_TYPE_HEADER
1190  * 2. array [1,...] KRB5_CRYPTO_TYPE_DATA and array [0,...]
1191  *    KRB5_CRYPTO_TYPE_SIGN_ONLY in any order, however the receiver
1192  *    have to aware of the order. KRB5_CRYPTO_TYPE_SIGN_ONLY is
1193  *    commonly used headers and trailers.
1194  * 3. KRB5_CRYPTO_TYPE_PADDING, at least on padsize long if padsize > 1
1195  * 4. KRB5_CRYPTO_TYPE_TRAILER
1196  */
1197
1198 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1199 krb5_encrypt_iov_ivec(krb5_context context,
1200                       krb5_crypto crypto,
1201                       unsigned usage,
1202                       krb5_crypto_iov *data,
1203                       int num_data,
1204                       void *ivec)
1205 {
1206     size_t headersz, trailersz, len;
1207     int i;
1208     size_t sz, block_sz, pad_sz;
1209     Checksum cksum;
1210     unsigned char *p, *q;
1211     krb5_error_code ret;
1212     struct _krb5_key_data *dkey;
1213     const struct _krb5_encryption_type *et = crypto->et;
1214     krb5_crypto_iov *tiv, *piv, *hiv;
1215
1216     if (num_data < 0) {
1217         krb5_clear_error_message(context);
1218         return KRB5_CRYPTO_INTERNAL;
1219     }
1220
1221     if(!derived_crypto(context, crypto)) {
1222         krb5_clear_error_message(context);
1223         return KRB5_CRYPTO_INTERNAL;
1224     }
1225
1226     headersz = et->confoundersize;
1227     trailersz = CHECKSUMSIZE(et->keyed_checksum);
1228
1229     for (len = 0, i = 0; i < num_data; i++) {
1230         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1231             continue;
1232         len += data[i].data.length;
1233     }
1234
1235     sz = headersz + len;
1236     block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */
1237
1238     pad_sz = block_sz - sz;
1239
1240     /* header */
1241
1242     hiv = find_iv(data, num_data, KRB5_CRYPTO_TYPE_HEADER);
1243     if (hiv == NULL || hiv->data.length != headersz)
1244         return KRB5_BAD_MSIZE;
1245
1246     krb5_generate_random_block(hiv->data.data, hiv->data.length);
1247
1248     /* padding */
1249     piv = find_iv(data, num_data, KRB5_CRYPTO_TYPE_PADDING);
1250     /* its ok to have no TYPE_PADDING if there is no padding */
1251     if (piv == NULL && pad_sz != 0)
1252         return KRB5_BAD_MSIZE;
1253     if (piv) {
1254         if (piv->data.length < pad_sz)
1255             return KRB5_BAD_MSIZE;
1256         piv->data.length = pad_sz;
1257         if (pad_sz)
1258             memset(piv->data.data, pad_sz, pad_sz);
1259         else
1260             piv = NULL;
1261     }
1262
1263     /* trailer */
1264     tiv = find_iv(data, num_data, KRB5_CRYPTO_TYPE_TRAILER);
1265     if (tiv == NULL || tiv->data.length != trailersz)
1266         return KRB5_BAD_MSIZE;
1267
1268     /*
1269      * XXX replace with EVP_Sign? at least make create_checksum an iov
1270      * function.
1271      * XXX CTS EVP is broken, can't handle multi buffers :(
1272      */
1273
1274     len = block_sz;
1275     for (i = 0; i < num_data; i++) {
1276         if (data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1277             continue;
1278         len += data[i].data.length;
1279     }
1280
1281     p = q = malloc(len);
1282
1283     memcpy(q, hiv->data.data, hiv->data.length);
1284     q += hiv->data.length;
1285     for (i = 0; i < num_data; i++) {
1286         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1287             data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1288             continue;
1289         memcpy(q, data[i].data.data, data[i].data.length);
1290         q += data[i].data.length;
1291     }
1292     if (piv)
1293         memset(q, 0, piv->data.length);
1294
1295     ret = create_checksum(context,
1296                           et->keyed_checksum,
1297                           crypto,
1298                           INTEGRITY_USAGE(usage),
1299                           p,
1300                           len,
1301                           &cksum);
1302     free(p);
1303     if(ret == 0 && cksum.checksum.length != trailersz) {
1304         free_Checksum (&cksum);
1305         krb5_clear_error_message (context);
1306         ret = KRB5_CRYPTO_INTERNAL;
1307     }
1308     if(ret)
1309         return ret;
1310
1311     /* save cksum at end */
1312     memcpy(tiv->data.data, cksum.checksum.data, cksum.checksum.length);
1313     free_Checksum (&cksum);
1314
1315     /* XXX replace with EVP_Cipher */
1316     p = q = malloc(block_sz);
1317     if(p == NULL)
1318         return ENOMEM;
1319
1320     memcpy(q, hiv->data.data, hiv->data.length);
1321     q += hiv->data.length;
1322
1323     for (i = 0; i < num_data; i++) {
1324         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1325             continue;
1326         memcpy(q, data[i].data.data, data[i].data.length);
1327         q += data[i].data.length;
1328     }
1329     if (piv)
1330         memset(q, 0, piv->data.length);
1331
1332
1333     ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1334     if(ret) {
1335         free(p);
1336         return ret;
1337     }
1338     ret = _key_schedule(context, dkey);
1339     if(ret) {
1340         free(p);
1341         return ret;
1342     }
1343
1344     ret = (*et->encrypt)(context, dkey, p, block_sz, 1, usage, ivec);
1345     if (ret) {
1346         free(p);
1347         return ret;
1348     }
1349
1350     /* now copy data back to buffers */
1351     q = p;
1352
1353     memcpy(hiv->data.data, q, hiv->data.length);
1354     q += hiv->data.length;
1355
1356     for (i = 0; i < num_data; i++) {
1357         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1358             continue;
1359         memcpy(data[i].data.data, q, data[i].data.length);
1360         q += data[i].data.length;
1361     }
1362     if (piv)
1363         memcpy(piv->data.data, q, pad_sz);
1364
1365     free(p);
1366
1367     return ret;
1368 }
1369
1370 /**
1371  * Inline decrypt a Kerberos message.
1372  *
1373  * @param context Kerberos context
1374  * @param crypto Kerberos crypto context
1375  * @param usage Key usage for this buffer
1376  * @param data array of buffers to process
1377  * @param num_data length of array
1378  * @param ivec initial cbc/cts vector
1379  *
1380  * @return Return an error code or 0.
1381  * @ingroup krb5_crypto
1382  *
1383  * 1. KRB5_CRYPTO_TYPE_HEADER
1384  * 2. one KRB5_CRYPTO_TYPE_DATA and array [0,...] of KRB5_CRYPTO_TYPE_SIGN_ONLY in
1385  *  any order, however the receiver have to aware of the
1386  *  order. KRB5_CRYPTO_TYPE_SIGN_ONLY is commonly used unencrypoted
1387  *  protocol headers and trailers. The output data will be of same
1388  *  size as the input data or shorter.
1389  */
1390
1391 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1392 krb5_decrypt_iov_ivec(krb5_context context,
1393                       krb5_crypto crypto,
1394                       unsigned usage,
1395                       krb5_crypto_iov *data,
1396                       unsigned int num_data,
1397                       void *ivec)
1398 {
1399     unsigned int i;
1400     size_t headersz, trailersz, len;
1401     Checksum cksum;
1402     unsigned char *p, *q;
1403     krb5_error_code ret;
1404     struct _krb5_key_data *dkey;
1405     struct _krb5_encryption_type *et = crypto->et;
1406     krb5_crypto_iov *tiv, *hiv;
1407
1408     if(!derived_crypto(context, crypto)) {
1409         krb5_clear_error_message(context);
1410         return KRB5_CRYPTO_INTERNAL;
1411     }
1412
1413     headersz = et->confoundersize;
1414
1415     hiv = find_iv(data, num_data, KRB5_CRYPTO_TYPE_HEADER);
1416     if (hiv == NULL || hiv->data.length != headersz)
1417         return KRB5_BAD_MSIZE;
1418
1419     /* trailer */
1420     trailersz = CHECKSUMSIZE(et->keyed_checksum);
1421
1422     tiv = find_iv(data, num_data, KRB5_CRYPTO_TYPE_TRAILER);
1423     if (tiv->data.length != trailersz)
1424         return KRB5_BAD_MSIZE;
1425
1426     /* Find length of data we will decrypt */
1427
1428     len = headersz;
1429     for (i = 0; i < num_data; i++) {
1430         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1431             continue;
1432         len += data[i].data.length;
1433     }
1434
1435     if ((len % et->padsize) != 0) {
1436         krb5_clear_error_message(context);
1437         return KRB5_BAD_MSIZE;
1438     }
1439
1440     /* XXX replace with EVP_Cipher */
1441
1442     p = q = malloc(len);
1443     if (p == NULL)
1444         return ENOMEM;
1445
1446     memcpy(q, hiv->data.data, hiv->data.length);
1447     q += hiv->data.length;
1448
1449     for (i = 0; i < num_data; i++) {
1450         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1451             continue;
1452         memcpy(q, data[i].data.data, data[i].data.length);
1453         q += data[i].data.length;
1454     }
1455
1456     ret = _get_derived_key(context, crypto, ENCRYPTION_USAGE(usage), &dkey);
1457     if(ret) {
1458         free(p);
1459         return ret;
1460     }
1461     ret = _key_schedule(context, dkey);
1462     if(ret) {
1463         free(p);
1464         return ret;
1465     }
1466
1467     ret = (*et->encrypt)(context, dkey, p, len, 0, usage, ivec);
1468     if (ret) {
1469         free(p);
1470         return ret;
1471     }
1472
1473     /* copy data back to buffers */
1474     memcpy(hiv->data.data, p, hiv->data.length);
1475     q = p + hiv->data.length;
1476     for (i = 0; i < num_data; i++) {
1477         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA)
1478             continue;
1479         memcpy(data[i].data.data, q, data[i].data.length);
1480         q += data[i].data.length;
1481     }
1482
1483     free(p);
1484
1485     /* check signature */
1486     for (i = 0; i < num_data; i++) {
1487         if (data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1488             continue;
1489         len += data[i].data.length;
1490     }
1491
1492     p = q = malloc(len);
1493     if (p == NULL)
1494         return ENOMEM;
1495
1496     memcpy(q, hiv->data.data, hiv->data.length);
1497     q += hiv->data.length;
1498     for (i = 0; i < num_data; i++) {
1499         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1500             data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1501             continue;
1502         memcpy(q, data[i].data.data, data[i].data.length);
1503         q += data[i].data.length;
1504     }
1505
1506     cksum.checksum.data   = tiv->data.data;
1507     cksum.checksum.length = tiv->data.length;
1508     cksum.cksumtype       = CHECKSUMTYPE(et->keyed_checksum);
1509
1510     ret = verify_checksum(context,
1511                           crypto,
1512                           INTEGRITY_USAGE(usage),
1513                           p,
1514                           len,
1515                           &cksum);
1516     free(p);
1517     return ret;
1518 }
1519
1520 /**
1521  * Create a Kerberos message checksum.
1522  *
1523  * @param context Kerberos context
1524  * @param crypto Kerberos crypto context
1525  * @param usage Key usage for this buffer
1526  * @param data array of buffers to process
1527  * @param num_data length of array
1528  * @param type output data
1529  *
1530  * @return Return an error code or 0.
1531  * @ingroup krb5_crypto
1532  */
1533
1534 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1535 krb5_create_checksum_iov(krb5_context context,
1536                          krb5_crypto crypto,
1537                          unsigned usage,
1538                          krb5_crypto_iov *data,
1539                          unsigned int num_data,
1540                          krb5_cksumtype *type)
1541 {
1542     Checksum cksum;
1543     krb5_crypto_iov *civ;
1544     krb5_error_code ret;
1545     size_t i;
1546     size_t len;
1547     char *p, *q;
1548
1549     if(!derived_crypto(context, crypto)) {
1550         krb5_clear_error_message(context);
1551         return KRB5_CRYPTO_INTERNAL;
1552     }
1553
1554     civ = find_iv(data, num_data, KRB5_CRYPTO_TYPE_CHECKSUM);
1555     if (civ == NULL)
1556         return KRB5_BAD_MSIZE;
1557
1558     len = 0;
1559     for (i = 0; i < num_data; i++) {
1560         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1561             data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1562             continue;
1563         len += data[i].data.length;
1564     }
1565
1566     p = q = malloc(len);
1567
1568     for (i = 0; i < num_data; i++) {
1569         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1570             data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1571             continue;
1572         memcpy(q, data[i].data.data, data[i].data.length);
1573         q += data[i].data.length;
1574     }
1575
1576     ret = krb5_create_checksum(context, crypto, usage, 0, p, len, &cksum);
1577     free(p);
1578     if (ret)
1579         return ret;
1580
1581     if (type)
1582         *type = cksum.cksumtype;
1583
1584     if (cksum.checksum.length > civ->data.length) {
1585         krb5_set_error_message(context, KRB5_BAD_MSIZE,
1586                                N_("Checksum larger then input buffer", ""));
1587         free_Checksum(&cksum);
1588         return KRB5_BAD_MSIZE;
1589     }
1590
1591     civ->data.length = cksum.checksum.length;
1592     memcpy(civ->data.data, cksum.checksum.data, civ->data.length);
1593     free_Checksum(&cksum);
1594
1595     return 0;
1596 }
1597
1598 /**
1599  * Verify a Kerberos message checksum.
1600  *
1601  * @param context Kerberos context
1602  * @param crypto Kerberos crypto context
1603  * @param usage Key usage for this buffer
1604  * @param data array of buffers to process
1605  * @param num_data length of array
1606  * @param type return checksum type if not NULL
1607  *
1608  * @return Return an error code or 0.
1609  * @ingroup krb5_crypto
1610  */
1611
1612 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1613 krb5_verify_checksum_iov(krb5_context context,
1614                          krb5_crypto crypto,
1615                          unsigned usage,
1616                          krb5_crypto_iov *data,
1617                          unsigned int num_data,
1618                          krb5_cksumtype *type)
1619 {
1620     struct _krb5_encryption_type *et = crypto->et;
1621     Checksum cksum;
1622     krb5_crypto_iov *civ;
1623     krb5_error_code ret;
1624     size_t i;
1625     size_t len;
1626     char *p, *q;
1627
1628     if(!derived_crypto(context, crypto)) {
1629         krb5_clear_error_message(context);
1630         return KRB5_CRYPTO_INTERNAL;
1631     }
1632
1633     civ = find_iv(data, num_data, KRB5_CRYPTO_TYPE_CHECKSUM);
1634     if (civ == NULL)
1635         return KRB5_BAD_MSIZE;
1636
1637     len = 0;
1638     for (i = 0; i < num_data; i++) {
1639         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1640             data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1641             continue;
1642         len += data[i].data.length;
1643     }
1644
1645     p = q = malloc(len);
1646
1647     for (i = 0; i < num_data; i++) {
1648         if (data[i].flags != KRB5_CRYPTO_TYPE_DATA &&
1649             data[i].flags != KRB5_CRYPTO_TYPE_SIGN_ONLY)
1650             continue;
1651         memcpy(q, data[i].data.data, data[i].data.length);
1652         q += data[i].data.length;
1653     }
1654
1655     cksum.cksumtype = CHECKSUMTYPE(et->keyed_checksum);
1656     cksum.checksum.length = civ->data.length;
1657     cksum.checksum.data = civ->data.data;
1658
1659     ret = krb5_verify_checksum(context, crypto, usage, p, len, &cksum);
1660     free(p);
1661
1662     if (ret == 0 && type)
1663         *type = cksum.cksumtype;
1664
1665     return ret;
1666 }
1667
1668
1669 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1670 krb5_crypto_length(krb5_context context,
1671                    krb5_crypto crypto,
1672                    int type,
1673                    size_t *len)
1674 {
1675     if (!derived_crypto(context, crypto)) {
1676         krb5_set_error_message(context, EINVAL, "not a derived crypto");
1677         return EINVAL;
1678     }
1679
1680     switch(type) {
1681     case KRB5_CRYPTO_TYPE_EMPTY:
1682         *len = 0;
1683         return 0;
1684     case KRB5_CRYPTO_TYPE_HEADER:
1685         *len = crypto->et->blocksize;
1686         return 0;
1687     case KRB5_CRYPTO_TYPE_DATA:
1688     case KRB5_CRYPTO_TYPE_SIGN_ONLY:
1689         /* len must already been filled in */
1690         return 0;
1691     case KRB5_CRYPTO_TYPE_PADDING:
1692         if (crypto->et->padsize > 1)
1693             *len = crypto->et->padsize;
1694         else
1695             *len = 0;
1696         return 0;
1697     case KRB5_CRYPTO_TYPE_TRAILER:
1698         *len = CHECKSUMSIZE(crypto->et->keyed_checksum);
1699         return 0;
1700     case KRB5_CRYPTO_TYPE_CHECKSUM:
1701         if (crypto->et->keyed_checksum)
1702             *len = CHECKSUMSIZE(crypto->et->keyed_checksum);
1703         else
1704             *len = CHECKSUMSIZE(crypto->et->checksum);
1705         return 0;
1706     }
1707     krb5_set_error_message(context, EINVAL,
1708                            "%d not a supported type", type);
1709     return EINVAL;
1710 }
1711
1712
1713 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1714 krb5_crypto_length_iov(krb5_context context,
1715                        krb5_crypto crypto,
1716                        krb5_crypto_iov *data,
1717                        unsigned int num_data)
1718 {
1719     krb5_error_code ret;
1720     size_t i;
1721
1722     for (i = 0; i < num_data; i++) {
1723         ret = krb5_crypto_length(context, crypto,
1724                                  data[i].flags,
1725                                  &data[i].data.length);
1726         if (ret)
1727             return ret;
1728     }
1729     return 0;
1730 }
1731
1732
1733 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1734 krb5_encrypt_ivec(krb5_context context,
1735                   krb5_crypto crypto,
1736                   unsigned usage,
1737                   const void *data,
1738                   size_t len,
1739                   krb5_data *result,
1740                   void *ivec)
1741 {
1742     if(derived_crypto(context, crypto))
1743         return encrypt_internal_derived(context, crypto, usage,
1744                                         data, len, result, ivec);
1745     else if (special_crypto(context, crypto))
1746         return encrypt_internal_special (context, crypto, usage,
1747                                          data, len, result, ivec);
1748     else
1749         return encrypt_internal(context, crypto, data, len, result, ivec);
1750 }
1751
1752 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1753 krb5_encrypt(krb5_context context,
1754              krb5_crypto crypto,
1755              unsigned usage,
1756              const void *data,
1757              size_t len,
1758              krb5_data *result)
1759 {
1760     return krb5_encrypt_ivec(context, crypto, usage, data, len, result, NULL);
1761 }
1762
1763 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1764 krb5_encrypt_EncryptedData(krb5_context context,
1765                            krb5_crypto crypto,
1766                            unsigned usage,
1767                            void *data,
1768                            size_t len,
1769                            int kvno,
1770                            EncryptedData *result)
1771 {
1772     result->etype = CRYPTO_ETYPE(crypto);
1773     if(kvno){
1774         ALLOC(result->kvno, 1);
1775         *result->kvno = kvno;
1776     }else
1777         result->kvno = NULL;
1778     return krb5_encrypt(context, crypto, usage, data, len, &result->cipher);
1779 }
1780
1781 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1782 krb5_decrypt_ivec(krb5_context context,
1783                   krb5_crypto crypto,
1784                   unsigned usage,
1785                   void *data,
1786                   size_t len,
1787                   krb5_data *result,
1788                   void *ivec)
1789 {
1790     if(derived_crypto(context, crypto))
1791         return decrypt_internal_derived(context, crypto, usage,
1792                                         data, len, result, ivec);
1793     else if (special_crypto (context, crypto))
1794         return decrypt_internal_special(context, crypto, usage,
1795                                         data, len, result, ivec);
1796     else
1797         return decrypt_internal(context, crypto, data, len, result, ivec);
1798 }
1799
1800 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1801 krb5_decrypt(krb5_context context,
1802              krb5_crypto crypto,
1803              unsigned usage,
1804              void *data,
1805              size_t len,
1806              krb5_data *result)
1807 {
1808     return krb5_decrypt_ivec (context, crypto, usage, data, len, result,
1809                               NULL);
1810 }
1811
1812 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1813 krb5_decrypt_EncryptedData(krb5_context context,
1814                            krb5_crypto crypto,
1815                            unsigned usage,
1816                            const EncryptedData *e,
1817                            krb5_data *result)
1818 {
1819     return krb5_decrypt(context, crypto, usage,
1820                         e->cipher.data, e->cipher.length, result);
1821 }
1822
1823 /************************************************************
1824  *                                                          *
1825  ************************************************************/
1826
1827 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1828 _krb5_derive_key(krb5_context context,
1829                  struct _krb5_encryption_type *et,
1830                  struct _krb5_key_data *key,
1831                  const void *constant,
1832                  size_t len)
1833 {
1834     unsigned char *k = NULL;
1835     unsigned int nblocks = 0, i;
1836     krb5_error_code ret = 0;
1837     struct _krb5_key_type *kt = et->keytype;
1838
1839     ret = _key_schedule(context, key);
1840     if(ret)
1841         return ret;
1842     if(et->blocksize * 8 < kt->bits || len != et->blocksize) {
1843         nblocks = (kt->bits + et->blocksize * 8 - 1) / (et->blocksize * 8);
1844         k = malloc(nblocks * et->blocksize);
1845         if(k == NULL) {
1846             ret = krb5_enomem(context);
1847             goto out;
1848         }
1849         ret = _krb5_n_fold(constant, len, k, et->blocksize);
1850         if (ret) {
1851             krb5_enomem(context);
1852             goto out;
1853         }
1854
1855         for(i = 0; i < nblocks; i++) {
1856             if(i > 0)
1857                 memcpy(k + i * et->blocksize,
1858                        k + (i - 1) * et->blocksize,
1859                        et->blocksize);
1860             (*et->encrypt)(context, key, k + i * et->blocksize, et->blocksize,
1861                            1, 0, NULL);
1862         }
1863     } else {
1864         /* this case is probably broken, but won't be run anyway */
1865         void *c = malloc(len);
1866         size_t res_len = (kt->bits + 7) / 8;
1867
1868         if(len != 0 && c == NULL) {
1869             ret = krb5_enomem(context);
1870             goto out;
1871         }
1872         memcpy(c, constant, len);
1873         (*et->encrypt)(context, key, c, len, 1, 0, NULL);
1874         k = malloc(res_len);
1875         if(res_len != 0 && k == NULL) {
1876             free(c);
1877             ret = krb5_enomem(context);
1878             goto out;
1879         }
1880         ret = _krb5_n_fold(c, len, k, res_len);
1881         free(c);
1882         if (ret) {
1883             krb5_enomem(context);
1884             goto out;
1885         }
1886     }
1887
1888     /* XXX keytype dependent post-processing */
1889     switch(kt->type) {
1890     case KRB5_ENCTYPE_OLD_DES3_CBC_SHA1:
1891         _krb5_DES3_random_to_key(context, key->key, k, nblocks * et->blocksize);
1892         break;
1893     case KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96:
1894     case KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96:
1895         memcpy(key->key->keyvalue.data, k, key->key->keyvalue.length);
1896         break;
1897     default:
1898         ret = KRB5_CRYPTO_INTERNAL;
1899         krb5_set_error_message(context, ret,
1900                                N_("derive_key() called with unknown keytype (%u)", ""),
1901                                kt->type);
1902         break;
1903     }
1904  out:
1905     if (key->schedule) {
1906         free_key_schedule(context, key, et);
1907         key->schedule = NULL;
1908     }
1909     if (k) {
1910         memset(k, 0, nblocks * et->blocksize);
1911         free(k);
1912     }
1913     return ret;
1914 }
1915
1916 static struct _krb5_key_data *
1917 _new_derived_key(krb5_crypto crypto, unsigned usage)
1918 {
1919     struct _krb5_key_usage *d = crypto->key_usage;
1920     d = realloc(d, (crypto->num_key_usage + 1) * sizeof(*d));
1921     if(d == NULL)
1922         return NULL;
1923     crypto->key_usage = d;
1924     d += crypto->num_key_usage++;
1925     memset(d, 0, sizeof(*d));
1926     d->usage = usage;
1927     return &d->key;
1928 }
1929
1930 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
1931 krb5_derive_key(krb5_context context,
1932                 const krb5_keyblock *key,
1933                 krb5_enctype etype,
1934                 const void *constant,
1935                 size_t constant_len,
1936                 krb5_keyblock **derived_key)
1937 {
1938     krb5_error_code ret;
1939     struct _krb5_encryption_type *et;
1940     struct _krb5_key_data d;
1941
1942     *derived_key = NULL;
1943
1944     et = _krb5_find_enctype (etype);
1945     if (et == NULL) {
1946         return unsupported_enctype (context, etype);
1947     }
1948
1949     ret = krb5_copy_keyblock(context, key, &d.key);
1950     if (ret)
1951         return ret;
1952
1953     d.schedule = NULL;
1954     ret = _krb5_derive_key(context, et, &d, constant, constant_len);
1955     if (ret == 0)
1956         ret = krb5_copy_keyblock(context, d.key, derived_key);
1957     _krb5_free_key_data(context, &d, et);
1958     return ret;
1959 }
1960
1961 static krb5_error_code
1962 _get_derived_key(krb5_context context,
1963                  krb5_crypto crypto,
1964                  unsigned usage,
1965                  struct _krb5_key_data **key)
1966 {
1967     int i;
1968     struct _krb5_key_data *d;
1969     unsigned char constant[5];
1970
1971     for(i = 0; i < crypto->num_key_usage; i++)
1972         if(crypto->key_usage[i].usage == usage) {
1973             *key = &crypto->key_usage[i].key;
1974             return 0;
1975         }
1976     d = _new_derived_key(crypto, usage);
1977     if (d == NULL)
1978         return krb5_enomem(context);
1979     krb5_copy_keyblock(context, crypto->key.key, &d->key);
1980     _krb5_put_int(constant, usage, 5);
1981     _krb5_derive_key(context, crypto->et, d, constant, sizeof(constant));
1982     *key = d;
1983     return 0;
1984 }
1985
1986 /**
1987  * Create a crypto context used for all encryption and signature
1988  * operation. The encryption type to use is taken from the key, but
1989  * can be overridden with the enctype parameter.  This can be useful
1990  * for encryptions types which is compatiable (DES for example).
1991  *
1992  * To free the crypto context, use krb5_crypto_destroy().
1993  *
1994  * @param context Kerberos context
1995  * @param key the key block information with all key data
1996  * @param etype the encryption type
1997  * @param crypto the resulting crypto context
1998  *
1999  * @return Return an error code or 0.
2000  *
2001  * @ingroup krb5_crypto
2002  */
2003
2004 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2005 krb5_crypto_init(krb5_context context,
2006                  const krb5_keyblock *key,
2007                  krb5_enctype etype,
2008                  krb5_crypto *crypto)
2009 {
2010     krb5_error_code ret;
2011     ALLOC(*crypto, 1);
2012     if (*crypto == NULL)
2013         return krb5_enomem(context);
2014     if(etype == (krb5_enctype)ETYPE_NULL)
2015         etype = key->keytype;
2016     (*crypto)->et = _krb5_find_enctype(etype);
2017     if((*crypto)->et == NULL || ((*crypto)->et->flags & F_DISABLED)) {
2018         free(*crypto);
2019         *crypto = NULL;
2020         return unsupported_enctype(context, etype);
2021     }
2022     if((*crypto)->et->keytype->size != key->keyvalue.length) {
2023         free(*crypto);
2024         *crypto = NULL;
2025         krb5_set_error_message (context, KRB5_BAD_KEYSIZE,
2026                                 "encryption key has bad length");
2027         return KRB5_BAD_KEYSIZE;
2028     }
2029     ret = krb5_copy_keyblock(context, key, &(*crypto)->key.key);
2030     if(ret) {
2031         free(*crypto);
2032         *crypto = NULL;
2033         return ret;
2034     }
2035     (*crypto)->key.schedule = NULL;
2036     (*crypto)->num_key_usage = 0;
2037     (*crypto)->key_usage = NULL;
2038     return 0;
2039 }
2040
2041 static void
2042 free_key_schedule(krb5_context context,
2043                   struct _krb5_key_data *key,
2044                   struct _krb5_encryption_type *et)
2045 {
2046     if (et->keytype->cleanup)
2047         (*et->keytype->cleanup)(context, key);
2048     memset(key->schedule->data, 0, key->schedule->length);
2049     krb5_free_data(context, key->schedule);
2050 }
2051
2052 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
2053 _krb5_free_key_data(krb5_context context, struct _krb5_key_data *key,
2054               struct _krb5_encryption_type *et)
2055 {
2056     krb5_free_keyblock(context, key->key);
2057     if(key->schedule) {
2058         free_key_schedule(context, key, et);
2059         key->schedule = NULL;
2060     }
2061 }
2062
2063 static void
2064 free_key_usage(krb5_context context, struct _krb5_key_usage *ku,
2065                struct _krb5_encryption_type *et)
2066 {
2067     _krb5_free_key_data(context, &ku->key, et);
2068 }
2069
2070 /**
2071  * Free a crypto context created by krb5_crypto_init().
2072  *
2073  * @param context Kerberos context
2074  * @param crypto crypto context to free
2075  *
2076  * @return Return an error code or 0.
2077  *
2078  * @ingroup krb5_crypto
2079  */
2080
2081 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2082 krb5_crypto_destroy(krb5_context context,
2083                     krb5_crypto crypto)
2084 {
2085     int i;
2086
2087     for(i = 0; i < crypto->num_key_usage; i++)
2088         free_key_usage(context, &crypto->key_usage[i], crypto->et);
2089     free(crypto->key_usage);
2090     _krb5_free_key_data(context, &crypto->key, crypto->et);
2091     free (crypto);
2092     return 0;
2093 }
2094
2095 /**
2096  * Return the blocksize used algorithm referenced by the crypto context
2097  *
2098  * @param context Kerberos context
2099  * @param crypto crypto context to query
2100  * @param blocksize the resulting blocksize
2101  *
2102  * @return Return an error code or 0.
2103  *
2104  * @ingroup krb5_crypto
2105  */
2106
2107 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2108 krb5_crypto_getblocksize(krb5_context context,
2109                          krb5_crypto crypto,
2110                          size_t *blocksize)
2111 {
2112     *blocksize = crypto->et->blocksize;
2113     return 0;
2114 }
2115
2116 /**
2117  * Return the encryption type used by the crypto context
2118  *
2119  * @param context Kerberos context
2120  * @param crypto crypto context to query
2121  * @param enctype the resulting encryption type
2122  *
2123  * @return Return an error code or 0.
2124  *
2125  * @ingroup krb5_crypto
2126  */
2127
2128 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2129 krb5_crypto_getenctype(krb5_context context,
2130                        krb5_crypto crypto,
2131                        krb5_enctype *enctype)
2132 {
2133     *enctype = crypto->et->type;
2134     return 0;
2135 }
2136
2137 /**
2138  * Return the padding size used by the crypto context
2139  *
2140  * @param context Kerberos context
2141  * @param crypto crypto context to query
2142  * @param padsize the return padding size
2143  *
2144  * @return Return an error code or 0.
2145  *
2146  * @ingroup krb5_crypto
2147  */
2148
2149 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2150 krb5_crypto_getpadsize(krb5_context context,
2151                        krb5_crypto crypto,
2152                        size_t *padsize)
2153 {
2154     *padsize = crypto->et->padsize;
2155     return 0;
2156 }
2157
2158 /**
2159  * Return the confounder size used by the crypto context
2160  *
2161  * @param context Kerberos context
2162  * @param crypto crypto context to query
2163  * @param confoundersize the returned confounder size
2164  *
2165  * @return Return an error code or 0.
2166  *
2167  * @ingroup krb5_crypto
2168  */
2169
2170 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2171 krb5_crypto_getconfoundersize(krb5_context context,
2172                               krb5_crypto crypto,
2173                               size_t *confoundersize)
2174 {
2175     *confoundersize = crypto->et->confoundersize;
2176     return 0;
2177 }
2178
2179
2180 /**
2181  * Disable encryption type
2182  *
2183  * @param context Kerberos 5 context
2184  * @param enctype encryption type to disable
2185  *
2186  * @return Return an error code or 0.
2187  *
2188  * @ingroup krb5_crypto
2189  */
2190
2191 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2192 krb5_enctype_disable(krb5_context context,
2193                      krb5_enctype enctype)
2194 {
2195     struct _krb5_encryption_type *et = _krb5_find_enctype(enctype);
2196     if(et == NULL) {
2197         if (context)
2198             krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
2199                                     N_("encryption type %d not supported", ""),
2200                                     enctype);
2201         return KRB5_PROG_ETYPE_NOSUPP;
2202     }
2203     et->flags |= F_DISABLED;
2204     return 0;
2205 }
2206
2207 /**
2208  * Enable encryption type
2209  *
2210  * @param context Kerberos 5 context
2211  * @param enctype encryption type to enable
2212  *
2213  * @return Return an error code or 0.
2214  *
2215  * @ingroup krb5_crypto
2216  */
2217
2218 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2219 krb5_enctype_enable(krb5_context context,
2220                     krb5_enctype enctype)
2221 {
2222     struct _krb5_encryption_type *et = _krb5_find_enctype(enctype);
2223     if(et == NULL) {
2224         if (context)
2225             krb5_set_error_message (context, KRB5_PROG_ETYPE_NOSUPP,
2226                                     N_("encryption type %d not supported", ""),
2227                                     enctype);
2228         return KRB5_PROG_ETYPE_NOSUPP;
2229     }
2230     et->flags &= ~F_DISABLED;
2231     return 0;
2232 }
2233
2234 /**
2235  * Enable or disable all weak encryption types
2236  *
2237  * @param context Kerberos 5 context
2238  * @param enable true to enable, false to disable
2239  *
2240  * @return Return an error code or 0.
2241  *
2242  * @ingroup krb5_crypto
2243  */
2244
2245 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2246 krb5_allow_weak_crypto(krb5_context context,
2247                        krb5_boolean enable)
2248 {
2249     int i;
2250
2251     for(i = 0; i < _krb5_num_etypes; i++)
2252         if(_krb5_etypes[i]->flags & F_WEAK) {
2253             if(enable)
2254                 _krb5_etypes[i]->flags &= ~F_DISABLED;
2255             else
2256                 _krb5_etypes[i]->flags |= F_DISABLED;
2257         }
2258     return 0;
2259 }
2260
2261 /**
2262  * Returns is the encryption is strong or weak
2263  *
2264  * @param context Kerberos 5 context
2265  * @param enctype encryption type to probe
2266  *
2267  * @return Returns true if encryption type is weak or is not supported.
2268  *
2269  * @ingroup krb5_crypto
2270  */
2271
2272 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
2273 krb5_is_enctype_weak(krb5_context context, krb5_enctype enctype)
2274 {
2275     struct _krb5_encryption_type *et = _krb5_find_enctype(enctype);
2276     if(et == NULL || (et->flags & F_WEAK))
2277         return TRUE;
2278     return FALSE;
2279 }
2280
2281 static size_t
2282 wrapped_length (krb5_context context,
2283                 krb5_crypto  crypto,
2284                 size_t       data_len)
2285 {
2286     struct _krb5_encryption_type *et = crypto->et;
2287     size_t padsize = et->padsize;
2288     size_t checksumsize = CHECKSUMSIZE(et->checksum);
2289     size_t res;
2290
2291     res =  et->confoundersize + checksumsize + data_len;
2292     res =  (res + padsize - 1) / padsize * padsize;
2293     return res;
2294 }
2295
2296 static size_t
2297 wrapped_length_dervied (krb5_context context,
2298                         krb5_crypto  crypto,
2299                         size_t       data_len)
2300 {
2301     struct _krb5_encryption_type *et = crypto->et;
2302     size_t padsize = et->padsize;
2303     size_t res;
2304
2305     res =  et->confoundersize + data_len;
2306     res =  (res + padsize - 1) / padsize * padsize;
2307     if (et->keyed_checksum)
2308         res += et->keyed_checksum->checksumsize;
2309     else
2310         res += et->checksum->checksumsize;
2311     return res;
2312 }
2313
2314 /*
2315  * Return the size of an encrypted packet of length `data_len'
2316  */
2317
2318 KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL
2319 krb5_get_wrapped_length (krb5_context context,
2320                          krb5_crypto  crypto,
2321                          size_t       data_len)
2322 {
2323     if (derived_crypto (context, crypto))
2324         return wrapped_length_dervied (context, crypto, data_len);
2325     else
2326         return wrapped_length (context, crypto, data_len);
2327 }
2328
2329 /*
2330  * Return the size of an encrypted packet of length `data_len'
2331  */
2332
2333 static size_t
2334 crypto_overhead (krb5_context context,
2335                  krb5_crypto  crypto)
2336 {
2337     struct _krb5_encryption_type *et = crypto->et;
2338     size_t res;
2339
2340     res = CHECKSUMSIZE(et->checksum);
2341     res += et->confoundersize;
2342     if (et->padsize > 1)
2343         res += et->padsize;
2344     return res;
2345 }
2346
2347 static size_t
2348 crypto_overhead_dervied (krb5_context context,
2349                          krb5_crypto  crypto)
2350 {
2351     struct _krb5_encryption_type *et = crypto->et;
2352     size_t res;
2353
2354     if (et->keyed_checksum)
2355         res = CHECKSUMSIZE(et->keyed_checksum);
2356     else
2357         res = CHECKSUMSIZE(et->checksum);
2358     res += et->confoundersize;
2359     if (et->padsize > 1)
2360         res += et->padsize;
2361     return res;
2362 }
2363
2364 KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL
2365 krb5_crypto_overhead (krb5_context context, krb5_crypto crypto)
2366 {
2367     if (derived_crypto (context, crypto))
2368         return crypto_overhead_dervied (context, crypto);
2369     else
2370         return crypto_overhead (context, crypto);
2371 }
2372
2373 /**
2374  * Converts the random bytestring to a protocol key according to
2375  * Kerberos crypto frame work. It may be assumed that all the bits of
2376  * the input string are equally random, even though the entropy
2377  * present in the random source may be limited.
2378  *
2379  * @param context Kerberos 5 context
2380  * @param type the enctype resulting key will be of
2381  * @param data input random data to convert to a key
2382  * @param size size of input random data, at least krb5_enctype_keysize() long
2383  * @param key key, output key, free with krb5_free_keyblock_contents()
2384  *
2385  * @return Return an error code or 0.
2386  *
2387  * @ingroup krb5_crypto
2388  */
2389
2390 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2391 krb5_random_to_key(krb5_context context,
2392                    krb5_enctype type,
2393                    const void *data,
2394                    size_t size,
2395                    krb5_keyblock *key)
2396 {
2397     krb5_error_code ret;
2398     struct _krb5_encryption_type *et = _krb5_find_enctype(type);
2399     if(et == NULL) {
2400         krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2401                                N_("encryption type %d not supported", ""),
2402                                type);
2403         return KRB5_PROG_ETYPE_NOSUPP;
2404     }
2405     if ((et->keytype->bits + 7) / 8 > size) {
2406         krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2407                                N_("encryption key %s needs %d bytes "
2408                                   "of random to make an encryption key "
2409                                   "out of it", ""),
2410                                et->name, (int)et->keytype->size);
2411         return KRB5_PROG_ETYPE_NOSUPP;
2412     }
2413     ret = krb5_data_alloc(&key->keyvalue, et->keytype->size);
2414     if(ret)
2415         return ret;
2416     key->keytype = type;
2417     if (et->keytype->random_to_key)
2418         (*et->keytype->random_to_key)(context, key, data, size);
2419     else
2420         memcpy(key->keyvalue.data, data, et->keytype->size);
2421
2422     return 0;
2423 }
2424
2425
2426
2427 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2428 krb5_crypto_prf_length(krb5_context context,
2429                        krb5_enctype type,
2430                        size_t *length)
2431 {
2432     struct _krb5_encryption_type *et = _krb5_find_enctype(type);
2433
2434     if(et == NULL || et->prf_length == 0) {
2435         krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2436                                N_("encryption type %d not supported", ""),
2437                                type);
2438         return KRB5_PROG_ETYPE_NOSUPP;
2439     }
2440
2441     *length = et->prf_length;
2442     return 0;
2443 }
2444
2445 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2446 krb5_crypto_prf(krb5_context context,
2447                 const krb5_crypto crypto,
2448                 const krb5_data *input,
2449                 krb5_data *output)
2450 {
2451     struct _krb5_encryption_type *et = crypto->et;
2452
2453     krb5_data_zero(output);
2454
2455     if(et->prf == NULL) {
2456         krb5_set_error_message(context, KRB5_PROG_ETYPE_NOSUPP,
2457                                "kerberos prf for %s not supported",
2458                                et->name);
2459         return KRB5_PROG_ETYPE_NOSUPP;
2460     }
2461
2462     return (*et->prf)(context, crypto, input, output);
2463 }
2464
2465 static krb5_error_code
2466 krb5_crypto_prfplus(krb5_context context,
2467                     const krb5_crypto crypto,
2468                     const krb5_data *input,
2469                     size_t length,
2470                     krb5_data *output)
2471 {
2472     krb5_error_code ret;
2473     krb5_data input2;
2474     unsigned char i = 1;
2475     unsigned char *p;
2476
2477     krb5_data_zero(&input2);
2478     krb5_data_zero(output);
2479
2480     krb5_clear_error_message(context);
2481
2482     ret = krb5_data_alloc(output, length);
2483     if (ret) goto out;
2484     ret = krb5_data_alloc(&input2, input->length + 1);
2485     if (ret) goto out;
2486
2487     krb5_clear_error_message(context);
2488
2489     memcpy(((unsigned char *)input2.data) + 1, input->data, input->length);
2490
2491     p = output->data;
2492
2493     while (length) {
2494         krb5_data block;
2495
2496         ((unsigned char *)input2.data)[0] = i++;
2497
2498         ret = krb5_crypto_prf(context, crypto, &input2, &block);
2499         if (ret)
2500             goto out;
2501
2502         if (block.length < length) {
2503             memcpy(p, block.data, block.length);
2504             length -= block.length;
2505         } else {
2506             memcpy(p, block.data, length);
2507             length = 0;
2508         }
2509         p += block.length;
2510         krb5_data_free(&block);
2511     }
2512
2513  out:
2514     krb5_data_free(&input2);
2515     if (ret)
2516         krb5_data_free(output);
2517     return ret;
2518 }
2519
2520 /**
2521  * The FX-CF2 key derivation function, used in FAST and preauth framework.
2522  *
2523  * @param context Kerberos 5 context
2524  * @param crypto1 first key to combine
2525  * @param crypto2 second key to combine
2526  * @param pepper1 factor to combine with first key to garante uniqueness
2527  * @param pepper2 factor to combine with second key to garante uniqueness
2528  * @param enctype the encryption type of the resulting key
2529  * @param res allocated key, free with krb5_free_keyblock_contents()
2530  *
2531  * @return Return an error code or 0.
2532  *
2533  * @ingroup krb5_crypto
2534  */
2535
2536 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2537 krb5_crypto_fx_cf2(krb5_context context,
2538                    const krb5_crypto crypto1,
2539                    const krb5_crypto crypto2,
2540                    krb5_data *pepper1,
2541                    krb5_data *pepper2,
2542                    krb5_enctype enctype,
2543                    krb5_keyblock *res)
2544 {
2545     krb5_error_code ret;
2546     krb5_data os1, os2;
2547     size_t i, keysize;
2548
2549     memset(res, 0, sizeof(*res));
2550     krb5_data_zero(&os1);
2551     krb5_data_zero(&os2);
2552
2553     ret = krb5_enctype_keysize(context, enctype, &keysize);
2554     if (ret)
2555         return ret;
2556
2557     ret = krb5_data_alloc(&res->keyvalue, keysize);
2558     if (ret)
2559         goto out;
2560     ret = krb5_crypto_prfplus(context, crypto1, pepper1, keysize, &os1);
2561     if (ret)
2562         goto out;
2563     ret = krb5_crypto_prfplus(context, crypto2, pepper2, keysize, &os2);
2564     if (ret)
2565         goto out;
2566
2567     res->keytype = enctype;
2568     {
2569         unsigned char *p1 = os1.data, *p2 = os2.data, *p3 = res->keyvalue.data;
2570         for (i = 0; i < keysize; i++)
2571             p3[i] = p1[i] ^ p2[i];
2572     }
2573  out:
2574     if (ret)
2575         krb5_data_free(&res->keyvalue);
2576     krb5_data_free(&os1);
2577     krb5_data_free(&os2);
2578
2579     return ret;
2580 }
2581
2582
2583
2584 #ifndef HEIMDAL_SMALLER
2585
2586 /**
2587  * Deprecated: keytypes doesn't exists, they are really enctypes.
2588  *
2589  * @ingroup krb5_deprecated
2590  */
2591
2592 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
2593 krb5_keytype_to_enctypes (krb5_context context,
2594                           krb5_keytype keytype,
2595                           unsigned *len,
2596                           krb5_enctype **val)
2597     KRB5_DEPRECATED_FUNCTION("Use X instead")
2598 {
2599     int i;
2600     unsigned n = 0;
2601     krb5_enctype *ret;
2602
2603     for (i = _krb5_num_etypes - 1; i >= 0; --i) {
2604         if (_krb5_etypes[i]->keytype->type == keytype
2605             && !(_krb5_etypes[i]->flags & F_PSEUDO)
2606             && krb5_enctype_valid(context, _krb5_etypes[i]->type) == 0)
2607             ++n;
2608     }
2609     if (n == 0) {
2610         krb5_set_error_message(context, KRB5_PROG_KEYTYPE_NOSUPP,
2611                                "Keytype have no mapping");
2612         return KRB5_PROG_KEYTYPE_NOSUPP;
2613     }
2614
2615     ret = malloc(n * sizeof(*ret));
2616     if (ret == NULL && n != 0)
2617         return krb5_enomem(context);
2618     n = 0;
2619     for (i = _krb5_num_etypes - 1; i >= 0; --i) {
2620         if (_krb5_etypes[i]->keytype->type == keytype
2621             && !(_krb5_etypes[i]->flags & F_PSEUDO)
2622             && krb5_enctype_valid(context, _krb5_etypes[i]->type) == 0)
2623             ret[n++] = _krb5_etypes[i]->type;
2624     }
2625     *len = n;
2626     *val = ret;
2627     return 0;
2628 }
2629
2630 /**
2631  * Deprecated: keytypes doesn't exists, they are really enctypes.
2632  *
2633  * @ingroup krb5_deprecated
2634  */
2635
2636 /* if two enctypes have compatible keys */
2637 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
2638 krb5_enctypes_compatible_keys(krb5_context context,
2639                               krb5_enctype etype1,
2640                               krb5_enctype etype2)
2641     KRB5_DEPRECATED_FUNCTION("Use X instead")
2642 {
2643     struct _krb5_encryption_type *e1 = _krb5_find_enctype(etype1);
2644     struct _krb5_encryption_type *e2 = _krb5_find_enctype(etype2);
2645     return e1 != NULL && e2 != NULL && e1->keytype == e2->keytype;
2646 }
2647
2648 #endif /* HEIMDAL_SMALLER */