s4:heimdal: import lorikeet-heimdal-201003262338 (commit f4e0dc17709829235f057e0e100d...
[sfrench/samba-autobuild/.git] / source4 / heimdal / kdc / kerberos5.c
1 /*
2  * Copyright (c) 1997-2007 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 "kdc_locl.h"
35
36 #define MAX_TIME ((time_t)((1U << 31) - 1))
37
38 void
39 _kdc_fix_time(time_t **t)
40 {
41     if(*t == NULL){
42         ALLOC(*t);
43         **t = MAX_TIME;
44     }
45     if(**t == 0) **t = MAX_TIME; /* fix for old clients */
46 }
47
48 static int
49 realloc_method_data(METHOD_DATA *md)
50 {
51     PA_DATA *pa;
52     pa = realloc(md->val, (md->len + 1) * sizeof(*md->val));
53     if(pa == NULL)
54         return ENOMEM;
55     md->val = pa;
56     md->len++;
57     return 0;
58 }
59
60 static void
61 set_salt_padata(METHOD_DATA *md, Salt *salt)
62 {
63     if (salt) {
64        realloc_method_data(md);
65        md->val[md->len - 1].padata_type = salt->type;
66        der_copy_octet_string(&salt->salt,
67                              &md->val[md->len - 1].padata_value);
68     }
69 }
70
71 const PA_DATA*
72 _kdc_find_padata(const KDC_REQ *req, int *start, int type)
73 {
74     if (req->padata == NULL)
75         return NULL;
76
77     while(*start < req->padata->len){
78         (*start)++;
79         if(req->padata->val[*start - 1].padata_type == type)
80             return &req->padata->val[*start - 1];
81     }
82     return NULL;
83 }
84
85 /*
86  * This is a hack to allow predefined weak services, like afs to
87  * still use weak types
88  */
89
90 krb5_boolean
91 _kdc_is_weak_exception(krb5_principal principal, krb5_enctype etype)
92 {
93     if (principal->name.name_string.len > 0 &&
94         strcmp(principal->name.name_string.val[0], "afs") == 0 &&
95         (etype == ETYPE_DES_CBC_CRC
96          || etype == ETYPE_DES_CBC_MD4
97          || etype == ETYPE_DES_CBC_MD5))
98         return TRUE;
99     return FALSE;
100 }
101
102
103 /*
104  * Detect if `key' is the using the the precomputed `default_salt'.
105  */
106
107 static krb5_boolean
108 is_default_salt_p(const krb5_salt *default_salt, const Key *key)
109 {
110     if (key->salt == NULL)
111         return TRUE;
112     if (default_salt->salttype != key->salt->type)
113         return FALSE;
114     if (krb5_data_cmp(&default_salt->saltvalue, &key->salt->salt))
115         return FALSE;
116     return TRUE;
117 }
118
119 /*
120  * return the first appropriate key of `princ' in `ret_key'.  Look for
121  * all the etypes in (`etypes', `len'), stopping as soon as we find
122  * one, but preferring one that has default salt
123  */
124
125 krb5_error_code
126 _kdc_find_etype(krb5_context context, const hdb_entry_ex *princ,
127                 krb5_enctype *etypes, unsigned len,
128                 Key **ret_key)
129 {
130     int i;
131     krb5_error_code ret = KRB5KDC_ERR_ETYPE_NOSUPP;
132     krb5_salt def_salt;
133
134     krb5_get_pw_salt (context, princ->entry.principal, &def_salt);
135
136     for(i = 0; ret != 0 && i < len ; i++) {
137         Key *key = NULL;
138
139         if (krb5_enctype_valid(context, etypes[i]) != 0 &&
140             !_kdc_is_weak_exception(princ->entry.principal, etypes[i]))
141             continue;
142
143         while (hdb_next_enctype2key(context, &princ->entry, etypes[i], &key) == 0) {
144             if (key->key.keyvalue.length == 0) {
145                 ret = KRB5KDC_ERR_NULL_KEY;
146                 continue;
147             }
148             *ret_key   = key;
149             ret = 0;
150             if (is_default_salt_p(&def_salt, key)) {
151                 krb5_free_salt (context, def_salt);
152                 return ret;
153             }
154         }
155     }
156     krb5_free_salt (context, def_salt);
157     return ret;
158 }
159
160 krb5_error_code
161 _kdc_make_anonymous_principalname (PrincipalName *pn)
162 {
163     pn->name_type = KRB5_NT_PRINCIPAL;
164     pn->name_string.len = 1;
165     pn->name_string.val = malloc(sizeof(*pn->name_string.val));
166     if (pn->name_string.val == NULL)
167         return ENOMEM;
168     pn->name_string.val[0] = strdup("anonymous");
169     if (pn->name_string.val[0] == NULL) {
170         free(pn->name_string.val);
171         pn->name_string.val = NULL;
172         return ENOMEM;
173     }
174     return 0;
175 }
176
177 void
178 _kdc_log_timestamp(krb5_context context,
179                    krb5_kdc_configuration *config,
180                    const char *type,
181                    KerberosTime authtime, KerberosTime *starttime,
182                    KerberosTime endtime, KerberosTime *renew_till)
183 {
184     char authtime_str[100], starttime_str[100],
185         endtime_str[100], renewtime_str[100];
186
187     krb5_format_time(context, authtime,
188                      authtime_str, sizeof(authtime_str), TRUE);
189     if (starttime)
190         krb5_format_time(context, *starttime,
191                          starttime_str, sizeof(starttime_str), TRUE);
192     else
193         strlcpy(starttime_str, "unset", sizeof(starttime_str));
194     krb5_format_time(context, endtime,
195                      endtime_str, sizeof(endtime_str), TRUE);
196     if (renew_till)
197         krb5_format_time(context, *renew_till,
198                          renewtime_str, sizeof(renewtime_str), TRUE);
199     else
200         strlcpy(renewtime_str, "unset", sizeof(renewtime_str));
201
202     kdc_log(context, config, 5,
203             "%s authtime: %s starttime: %s endtime: %s renew till: %s",
204             type, authtime_str, starttime_str, endtime_str, renewtime_str);
205 }
206
207 static void
208 log_patypes(krb5_context context,
209             krb5_kdc_configuration *config,
210             METHOD_DATA *padata)
211 {
212     struct rk_strpool *p = NULL;
213     char *str;
214     int i;
215         
216     for (i = 0; i < padata->len; i++) {
217         switch(padata->val[i].padata_type) {
218         case KRB5_PADATA_PK_AS_REQ:
219             p = rk_strpoolprintf(p, "PK-INIT(ietf)");
220             break;
221         case KRB5_PADATA_PK_AS_REQ_WIN:
222             p = rk_strpoolprintf(p, "PK-INIT(win2k)");
223             break;
224         case KRB5_PADATA_PA_PK_OCSP_RESPONSE:
225             p = rk_strpoolprintf(p, "OCSP");
226             break;
227         case KRB5_PADATA_ENC_TIMESTAMP:
228             p = rk_strpoolprintf(p, "encrypted-timestamp");
229             break;
230         default:
231             p = rk_strpoolprintf(p, "%d", padata->val[i].padata_type);
232             break;
233         }
234         if (p && i + 1 < padata->len)
235             p = rk_strpoolprintf(p, ", ");
236         if (p == NULL) {
237             kdc_log(context, config, 0, "out of memory");
238             return;
239         }
240     }
241     if (p == NULL)
242         p = rk_strpoolprintf(p, "none");
243         
244     str = rk_strpoolcollect(p);
245     kdc_log(context, config, 0, "Client sent patypes: %s", str);
246     free(str);
247 }
248
249 /*
250  *
251  */
252
253
254 krb5_error_code
255 _kdc_encode_reply(krb5_context context,
256                   krb5_kdc_configuration *config,
257                   KDC_REP *rep, const EncTicketPart *et, EncKDCRepPart *ek,
258                   krb5_enctype etype,
259                   int skvno, const EncryptionKey *skey,
260                   int ckvno, const EncryptionKey *reply_key,
261                   int rk_is_subkey,
262                   const char **e_text,
263                   krb5_data *reply)
264 {
265     unsigned char *buf;
266     size_t buf_size;
267     size_t len;
268     krb5_error_code ret;
269     krb5_crypto crypto;
270
271     ASN1_MALLOC_ENCODE(EncTicketPart, buf, buf_size, et, &len, ret);
272     if(ret) {
273         const char *msg = krb5_get_error_message(context, ret);
274         kdc_log(context, config, 0, "Failed to encode ticket: %s", msg);
275         krb5_free_error_message(context, msg);
276         return ret;
277     }
278     if(buf_size != len) {
279         free(buf);
280         kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
281         *e_text = "KDC internal error";
282         return KRB5KRB_ERR_GENERIC;
283     }
284
285     ret = krb5_crypto_init(context, skey, etype, &crypto);
286     if (ret) {
287         const char *msg;
288         free(buf);
289         msg = krb5_get_error_message(context, ret);
290         kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
291         krb5_free_error_message(context, msg);
292         return ret;
293     }
294
295     ret = krb5_encrypt_EncryptedData(context,
296                                      crypto,
297                                      KRB5_KU_TICKET,
298                                      buf,
299                                      len,
300                                      skvno,
301                                      &rep->ticket.enc_part);
302     free(buf);
303     krb5_crypto_destroy(context, crypto);
304     if(ret) {
305         const char *msg = krb5_get_error_message(context, ret);
306         kdc_log(context, config, 0, "Failed to encrypt data: %s", msg);
307         krb5_free_error_message(context, msg);
308         return ret;
309     }
310
311     if(rep->msg_type == krb_as_rep && !config->encode_as_rep_as_tgs_rep)
312         ASN1_MALLOC_ENCODE(EncASRepPart, buf, buf_size, ek, &len, ret);
313     else
314         ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
315     if(ret) {
316         const char *msg = krb5_get_error_message(context, ret);
317         kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
318         krb5_free_error_message(context, msg);
319         return ret;
320     }
321     if(buf_size != len) {
322         free(buf);
323         kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
324         *e_text = "KDC internal error";
325         return KRB5KRB_ERR_GENERIC;
326     }
327     ret = krb5_crypto_init(context, reply_key, 0, &crypto);
328     if (ret) {
329         const char *msg = krb5_get_error_message(context, ret);
330         free(buf);
331         kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
332         krb5_free_error_message(context, msg);
333         return ret;
334     }
335     if(rep->msg_type == krb_as_rep) {
336         krb5_encrypt_EncryptedData(context,
337                                    crypto,
338                                    KRB5_KU_AS_REP_ENC_PART,
339                                    buf,
340                                    len,
341                                    ckvno,
342                                    &rep->enc_part);
343         free(buf);
344         ASN1_MALLOC_ENCODE(AS_REP, buf, buf_size, rep, &len, ret);
345     } else {
346         krb5_encrypt_EncryptedData(context,
347                                    crypto,
348                                    rk_is_subkey ? KRB5_KU_TGS_REP_ENC_PART_SUB_KEY : KRB5_KU_TGS_REP_ENC_PART_SESSION,
349                                    buf,
350                                    len,
351                                    ckvno,
352                                    &rep->enc_part);
353         free(buf);
354         ASN1_MALLOC_ENCODE(TGS_REP, buf, buf_size, rep, &len, ret);
355     }
356     krb5_crypto_destroy(context, crypto);
357     if(ret) {
358         const char *msg = krb5_get_error_message(context, ret);
359         kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
360         krb5_free_error_message(context, msg);
361         return ret;
362     }
363     if(buf_size != len) {
364         free(buf);
365         kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
366         *e_text = "KDC internal error";
367         return KRB5KRB_ERR_GENERIC;
368     }
369     reply->data = buf;
370     reply->length = buf_size;
371     return 0;
372 }
373
374 /*
375  * Return 1 if the client have only older enctypes, this is for
376  * determining if the server should send ETYPE_INFO2 or not.
377  */
378
379 static int
380 older_enctype(krb5_enctype enctype)
381 {
382     switch (enctype) {
383     case ETYPE_DES_CBC_CRC:
384     case ETYPE_DES_CBC_MD4:
385     case ETYPE_DES_CBC_MD5:
386     case ETYPE_DES3_CBC_SHA1:
387     case ETYPE_ARCFOUR_HMAC_MD5:
388     case ETYPE_ARCFOUR_HMAC_MD5_56:
389     /*
390      * The following three is "old" windows enctypes and is needed for
391      * windows 2000 hosts.
392      */
393     case ETYPE_ARCFOUR_MD4:
394     case ETYPE_ARCFOUR_HMAC_OLD:
395     case ETYPE_ARCFOUR_HMAC_OLD_EXP:
396         return 1;
397     default:
398         return 0;
399     }
400 }
401
402 /*
403  *
404  */
405
406 static krb5_error_code
407 make_etype_info_entry(krb5_context context, ETYPE_INFO_ENTRY *ent, Key *key)
408 {
409     ent->etype = key->key.keytype;
410     if(key->salt){
411 #if 0
412         ALLOC(ent->salttype);
413
414         if(key->salt->type == hdb_pw_salt)
415             *ent->salttype = 0; /* or 1? or NULL? */
416         else if(key->salt->type == hdb_afs3_salt)
417             *ent->salttype = 2;
418         else {
419             kdc_log(context, config, 0, "unknown salt-type: %d",
420                     key->salt->type);
421             return KRB5KRB_ERR_GENERIC;
422         }
423         /* according to `the specs', we can't send a salt if
424            we have AFS3 salted key, but that requires that you
425            *know* what cell you are using (e.g by assuming
426            that the cell is the same as the realm in lower
427            case) */
428 #elif 0
429         ALLOC(ent->salttype);
430         *ent->salttype = key->salt->type;
431 #else
432         /*
433          * We shouldn't sent salttype since it is incompatible with the
434          * specification and it breaks windows clients.  The afs
435          * salting problem is solved by using KRB5-PADATA-AFS3-SALT
436          * implemented in Heimdal 0.7 and later.
437          */
438         ent->salttype = NULL;
439 #endif
440         krb5_copy_data(context, &key->salt->salt,
441                        &ent->salt);
442     } else {
443         /* we return no salt type at all, as that should indicate
444          * the default salt type and make everybody happy.  some
445          * systems (like w2k) dislike being told the salt type
446          * here. */
447
448         ent->salttype = NULL;
449         ent->salt = NULL;
450     }
451     return 0;
452 }
453
454 static krb5_error_code
455 get_pa_etype_info(krb5_context context,
456                   krb5_kdc_configuration *config,
457                   METHOD_DATA *md, Key *ckey)
458 {
459     krb5_error_code ret = 0;
460     ETYPE_INFO pa;
461     unsigned char *buf;
462     size_t len;
463
464
465     pa.len = 1;
466     pa.val = calloc(1, sizeof(pa.val[0]));
467     if(pa.val == NULL)
468         return ENOMEM;
469
470     ret = make_etype_info_entry(context, &pa.val[0], ckey);
471     if (ret) {
472         free_ETYPE_INFO(&pa);
473         return ret;
474     }
475
476     ASN1_MALLOC_ENCODE(ETYPE_INFO, buf, len, &pa, &len, ret);
477     free_ETYPE_INFO(&pa);
478     if(ret)
479         return ret;
480     ret = realloc_method_data(md);
481     if(ret) {
482         free(buf);
483         return ret;
484     }
485     md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO;
486     md->val[md->len - 1].padata_value.length = len;
487     md->val[md->len - 1].padata_value.data = buf;
488     return 0;
489 }
490
491 /*
492  *
493  */
494
495 extern int _krb5_AES_string_to_default_iterator;
496
497 static krb5_error_code
498 make_etype_info2_entry(ETYPE_INFO2_ENTRY *ent, Key *key)
499 {
500     ent->etype = key->key.keytype;
501     if(key->salt) {
502         ALLOC(ent->salt);
503         if (ent->salt == NULL)
504             return ENOMEM;
505         *ent->salt = malloc(key->salt->salt.length + 1);
506         if (*ent->salt == NULL) {
507             free(ent->salt);
508             ent->salt = NULL;
509             return ENOMEM;
510         }
511         memcpy(*ent->salt, key->salt->salt.data, key->salt->salt.length);
512         (*ent->salt)[key->salt->salt.length] = '\0';
513     } else
514         ent->salt = NULL;
515
516     ent->s2kparams = NULL;
517
518     switch (key->key.keytype) {
519     case ETYPE_AES128_CTS_HMAC_SHA1_96:
520     case ETYPE_AES256_CTS_HMAC_SHA1_96:
521         ALLOC(ent->s2kparams);
522         if (ent->s2kparams == NULL)
523             return ENOMEM;
524         ent->s2kparams->length = 4;
525         ent->s2kparams->data = malloc(ent->s2kparams->length);
526         if (ent->s2kparams->data == NULL) {
527             free(ent->s2kparams);
528             ent->s2kparams = NULL;
529             return ENOMEM;
530         }
531         _krb5_put_int(ent->s2kparams->data,
532                       _krb5_AES_string_to_default_iterator,
533                       ent->s2kparams->length);
534         break;
535     case ETYPE_DES_CBC_CRC:
536     case ETYPE_DES_CBC_MD4:
537     case ETYPE_DES_CBC_MD5:
538         /* Check if this was a AFS3 salted key */
539         if(key->salt && key->salt->type == hdb_afs3_salt){
540             ALLOC(ent->s2kparams);
541             if (ent->s2kparams == NULL)
542                 return ENOMEM;
543             ent->s2kparams->length = 1;
544             ent->s2kparams->data = malloc(ent->s2kparams->length);
545             if (ent->s2kparams->data == NULL) {
546                 free(ent->s2kparams);
547                 ent->s2kparams = NULL;
548                 return ENOMEM;
549             }
550             _krb5_put_int(ent->s2kparams->data,
551                           1,
552                           ent->s2kparams->length);
553         }
554         break;
555     default:
556         break;
557     }
558     return 0;
559 }
560
561 /*
562  * Return an ETYPE-INFO2. Enctypes are storted the same way as in the
563  * database (client supported enctypes first, then the unsupported
564  * enctypes).
565  */
566
567 static krb5_error_code
568 get_pa_etype_info2(krb5_context context,
569                    krb5_kdc_configuration *config,
570                    METHOD_DATA *md, Key *ckey)
571 {
572     krb5_error_code ret = 0;
573     ETYPE_INFO2 pa;
574     unsigned char *buf;
575     size_t len;
576
577     pa.len = 1;
578     pa.val = calloc(1, sizeof(pa.val[0]));
579     if(pa.val == NULL)
580         return ENOMEM;
581
582     ret = make_etype_info2_entry(&pa.val[0], ckey);
583     if (ret) {
584         free_ETYPE_INFO2(&pa);
585         return ret;
586     }
587
588     ASN1_MALLOC_ENCODE(ETYPE_INFO2, buf, len, &pa, &len, ret);
589     free_ETYPE_INFO2(&pa);
590     if(ret)
591         return ret;
592     ret = realloc_method_data(md);
593     if(ret) {
594         free(buf);
595         return ret;
596     }
597     md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO2;
598     md->val[md->len - 1].padata_value.length = len;
599     md->val[md->len - 1].padata_value.data = buf;
600     return 0;
601 }
602
603 /*
604  *
605  */
606
607 static void
608 log_as_req(krb5_context context,
609            krb5_kdc_configuration *config,
610            krb5_enctype cetype,
611            krb5_enctype setype,
612            const KDC_REQ_BODY *b)
613 {
614     krb5_error_code ret;
615     struct rk_strpool *p;
616     char *str;
617     int i;
618
619     p = rk_strpoolprintf(NULL, "%s", "Client supported enctypes: ");
620
621     for (i = 0; i < b->etype.len; i++) {
622         ret = krb5_enctype_to_string(context, b->etype.val[i], &str);
623         if (ret == 0) {
624             p = rk_strpoolprintf(p, "%s", str);
625             free(str);
626         } else
627             p = rk_strpoolprintf(p, "%d", b->etype.val[i]);
628         if (p && i + 1 < b->etype.len)
629             p = rk_strpoolprintf(p, ", ");
630         if (p == NULL) {
631             kdc_log(context, config, 0, "out of memory");
632             return;
633         }
634     }
635     if (p == NULL)
636         p = rk_strpoolprintf(p, "no encryption types");
637
638     {
639         char *cet;
640         char *set;
641
642         ret = krb5_enctype_to_string(context, cetype, &cet);
643         if(ret == 0) {
644             ret = krb5_enctype_to_string(context, setype, &set);
645             if (ret == 0) {
646                 p = rk_strpoolprintf(p, ", using %s/%s", cet, set);
647                 free(set);
648             }
649             free(cet);
650         }
651         if (ret != 0)
652             p = rk_strpoolprintf(p, ", using enctypes %d/%d",
653                                  cetype, setype);
654     }
655
656     str = rk_strpoolcollect(p);
657     kdc_log(context, config, 0, "%s", str);
658     free(str);
659
660     {
661         char fixedstr[128];
662         unparse_flags(KDCOptions2int(b->kdc_options), asn1_KDCOptions_units(),
663                       fixedstr, sizeof(fixedstr));
664         if(*fixedstr)
665             kdc_log(context, config, 0, "Requested flags: %s", fixedstr);
666     }
667 }
668
669 /*
670  * verify the flags on `client' and `server', returning 0
671  * if they are OK and generating an error messages and returning
672  * and error code otherwise.
673  */
674
675 krb5_error_code
676 kdc_check_flags(krb5_context context,
677                 krb5_kdc_configuration *config,
678                 hdb_entry_ex *client_ex, const char *client_name,
679                 hdb_entry_ex *server_ex, const char *server_name,
680                 krb5_boolean is_as_req)
681 {
682     if(client_ex != NULL) {
683         hdb_entry *client = &client_ex->entry;
684
685         /* check client */
686         if (client->flags.locked_out) {
687             kdc_log(context, config, 0,
688                     "Client (%s) is locked out", client_name);
689             return KRB5KDC_ERR_POLICY;
690         }
691
692         if (client->flags.invalid) {
693             kdc_log(context, config, 0,
694                     "Client (%s) has invalid bit set", client_name);
695             return KRB5KDC_ERR_POLICY;
696         }
697         
698         if(!client->flags.client){
699             kdc_log(context, config, 0,
700                     "Principal may not act as client -- %s", client_name);
701             return KRB5KDC_ERR_POLICY;
702         }
703         
704         if (client->valid_start && *client->valid_start > kdc_time) {
705             char starttime_str[100];
706             krb5_format_time(context, *client->valid_start,
707                              starttime_str, sizeof(starttime_str), TRUE);
708             kdc_log(context, config, 0,
709                     "Client not yet valid until %s -- %s",
710                     starttime_str, client_name);
711             return KRB5KDC_ERR_CLIENT_NOTYET;
712         }
713         
714         if (client->valid_end && *client->valid_end < kdc_time) {
715             char endtime_str[100];
716             krb5_format_time(context, *client->valid_end,
717                              endtime_str, sizeof(endtime_str), TRUE);
718             kdc_log(context, config, 0,
719                     "Client expired at %s -- %s",
720                     endtime_str, client_name);
721             return KRB5KDC_ERR_NAME_EXP;
722         }
723         
724         if (client->pw_end && *client->pw_end < kdc_time
725             && (server_ex == NULL || !server_ex->entry.flags.change_pw)) {
726             char pwend_str[100];
727             krb5_format_time(context, *client->pw_end,
728                              pwend_str, sizeof(pwend_str), TRUE);
729             kdc_log(context, config, 0,
730                     "Client's key has expired at %s -- %s",
731                     pwend_str, client_name);
732             return KRB5KDC_ERR_KEY_EXPIRED;
733         }
734     }
735
736     /* check server */
737
738     if (server_ex != NULL) {
739         hdb_entry *server = &server_ex->entry;
740
741         if (server->flags.locked_out) {
742             kdc_log(context, config, 0,
743                     "Client server locked out -- %s", server_name);
744             return KRB5KDC_ERR_POLICY;
745         }
746         if (server->flags.invalid) {
747             kdc_log(context, config, 0,
748                     "Server has invalid flag set -- %s", server_name);
749             return KRB5KDC_ERR_POLICY;
750         }
751
752         if(!server->flags.server){
753             kdc_log(context, config, 0,
754                     "Principal may not act as server -- %s", server_name);
755             return KRB5KDC_ERR_POLICY;
756         }
757
758         if(!is_as_req && server->flags.initial) {
759             kdc_log(context, config, 0,
760                     "AS-REQ is required for server -- %s", server_name);
761             return KRB5KDC_ERR_POLICY;
762         }
763
764         if (server->valid_start && *server->valid_start > kdc_time) {
765             char starttime_str[100];
766             krb5_format_time(context, *server->valid_start,
767                              starttime_str, sizeof(starttime_str), TRUE);
768             kdc_log(context, config, 0,
769                     "Server not yet valid until %s -- %s",
770                     starttime_str, server_name);
771             return KRB5KDC_ERR_SERVICE_NOTYET;
772         }
773
774         if (server->valid_end && *server->valid_end < kdc_time) {
775             char endtime_str[100];
776             krb5_format_time(context, *server->valid_end,
777                              endtime_str, sizeof(endtime_str), TRUE);
778             kdc_log(context, config, 0,
779                     "Server expired at %s -- %s",
780                     endtime_str, server_name);
781             return KRB5KDC_ERR_SERVICE_EXP;
782         }
783
784         if (server->pw_end && *server->pw_end < kdc_time) {
785             char pwend_str[100];
786             krb5_format_time(context, *server->pw_end,
787                              pwend_str, sizeof(pwend_str), TRUE);
788             kdc_log(context, config, 0,
789                     "Server's key has expired at -- %s",
790                     pwend_str, server_name);
791             return KRB5KDC_ERR_KEY_EXPIRED;
792         }
793     }
794     return 0;
795 }
796
797 /*
798  * Return TRUE if `from' is part of `addresses' taking into consideration
799  * the configuration variables that tells us how strict we should be about
800  * these checks
801  */
802
803 krb5_boolean
804 _kdc_check_addresses(krb5_context context,
805                      krb5_kdc_configuration *config,
806                      HostAddresses *addresses, const struct sockaddr *from)
807 {
808     krb5_error_code ret;
809     krb5_address addr;
810     krb5_boolean result;
811     krb5_boolean only_netbios = TRUE;
812     int i;
813
814     if(config->check_ticket_addresses == 0)
815         return TRUE;
816
817     if(addresses == NULL)
818         return config->allow_null_ticket_addresses;
819
820     for (i = 0; i < addresses->len; ++i) {
821         if (addresses->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
822             only_netbios = FALSE;
823         }
824     }
825
826     /* Windows sends it's netbios name, which I can only assume is
827      * used for the 'allowed workstations' check.  This is painful,
828      * but we still want to check IP addresses if they happen to be
829      * present.
830      */
831
832     if(only_netbios)
833         return config->allow_null_ticket_addresses;
834
835     ret = krb5_sockaddr2address (context, from, &addr);
836     if(ret)
837         return FALSE;
838
839     result = krb5_address_search(context, &addr, addresses);
840     krb5_free_address (context, &addr);
841     return result;
842 }
843
844 /*
845  *
846  */
847
848 static krb5_boolean
849 send_pac_p(krb5_context context, KDC_REQ *req)
850 {
851     krb5_error_code ret;
852     PA_PAC_REQUEST pacreq;
853     const PA_DATA *pa;
854     int i = 0;
855
856     pa = _kdc_find_padata(req, &i, KRB5_PADATA_PA_PAC_REQUEST);
857     if (pa == NULL)
858         return TRUE;
859
860     ret = decode_PA_PAC_REQUEST(pa->padata_value.data,
861                                 pa->padata_value.length,
862                                 &pacreq,
863                                 NULL);
864     if (ret)
865         return TRUE;
866     i = pacreq.include_pac;
867     free_PA_PAC_REQUEST(&pacreq);
868     if (i == 0)
869         return FALSE;
870     return TRUE;
871 }
872
873 krb5_boolean
874 _kdc_is_anonymous(krb5_context context, krb5_principal principal)
875 {
876     if (principal->name.name_type != KRB5_NT_WELLKNOWN ||
877         principal->name.name_string.len != 2 ||
878         strcmp(principal->name.name_string.val[0], KRB5_WELLKNOWN_NAME) != 0 ||
879         strcmp(principal->name.name_string.val[1], KRB5_ANON_NAME) != 0)
880         return 0;
881     return 1;
882 }
883
884 /*
885  *
886  */
887
888 krb5_error_code
889 _kdc_as_rep(krb5_context context,
890             krb5_kdc_configuration *config,
891             KDC_REQ *req,
892             const krb5_data *req_buffer,
893             krb5_data *reply,
894             const char *from,
895             struct sockaddr *from_addr,
896             int datagram_reply)
897 {
898     KDC_REQ_BODY *b = &req->req_body;
899     AS_REP rep;
900     KDCOptions f = b->kdc_options;
901     hdb_entry_ex *client = NULL, *server = NULL;
902     HDB *clientdb;
903     krb5_enctype setype, sessionetype;
904     krb5_data e_data;
905     EncTicketPart et;
906     EncKDCRepPart ek;
907     krb5_principal client_princ = NULL, server_princ = NULL;
908     char *client_name = NULL, *server_name = NULL;
909     krb5_error_code ret = 0;
910     const char *e_text = NULL;
911     krb5_crypto crypto;
912     Key *ckey, *skey;
913     EncryptionKey *reply_key, session_key;
914     int flags = 0;
915 #ifdef PKINIT
916     pk_client_params *pkp = NULL;
917 #endif
918
919     memset(&rep, 0, sizeof(rep));
920     memset(&session_key, 0, sizeof(session_key));
921     krb5_data_zero(&e_data);
922
923     ALLOC(rep.padata);
924     rep.padata->len = 0;
925     rep.padata->val = NULL;
926
927     if (f.canonicalize)
928         flags |= HDB_F_CANON;
929
930     if(b->sname == NULL){
931         ret = KRB5KRB_ERR_GENERIC;
932         e_text = "No server in request";
933     } else{
934         ret = _krb5_principalname2krb5_principal (context,
935                                                   &server_princ,
936                                                   *(b->sname),
937                                                   b->realm);
938         if (ret == 0)
939             ret = krb5_unparse_name(context, server_princ, &server_name);
940     }
941     if (ret) {
942         kdc_log(context, config, 0,
943                 "AS-REQ malformed server name from %s", from);
944         goto out;
945     }
946     if(b->cname == NULL){
947         ret = KRB5KRB_ERR_GENERIC;
948         e_text = "No client in request";
949     } else {
950         ret = _krb5_principalname2krb5_principal (context,
951                                                   &client_princ,
952                                                   *(b->cname),
953                                                   b->realm);
954         if (ret)
955             goto out;
956
957         ret = krb5_unparse_name(context, client_princ, &client_name);
958     }
959     if (ret) {
960         kdc_log(context, config, 0,
961                 "AS-REQ malformed client name from %s", from);
962         goto out;
963     }
964
965     kdc_log(context, config, 0, "AS-REQ %s from %s for %s",
966             client_name, from, server_name);
967
968     /*
969      *
970      */
971
972     if (_kdc_is_anonymous(context, client_princ)) {
973         if (!b->kdc_options.request_anonymous) {
974             kdc_log(context, config, 0, "Anonymous ticket w/o anonymous flag");
975             ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
976             goto out;
977         }
978     } else if (b->kdc_options.request_anonymous) {
979         kdc_log(context, config, 0, 
980                 "Request for a anonymous ticket with non "
981                 "anonymous client name: %s", client_name);
982         ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
983         goto out;
984     }
985
986     /*
987      *
988      */
989
990     ret = _kdc_db_fetch(context, config, client_princ,
991                         HDB_F_GET_CLIENT | flags, &clientdb, &client);
992     if(ret){
993         const char *msg = krb5_get_error_message(context, ret);
994         kdc_log(context, config, 0, "UNKNOWN -- %s: %s", client_name, msg);
995         krb5_free_error_message(context, msg);
996         ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
997         goto out;
998     }
999
1000     ret = _kdc_db_fetch(context, config, server_princ,
1001                         HDB_F_GET_SERVER|HDB_F_GET_KRBTGT,
1002                         NULL, &server);
1003     if(ret){
1004         const char *msg = krb5_get_error_message(context, ret);
1005         kdc_log(context, config, 0, "UNKNOWN -- %s: %s", server_name, msg);
1006         krb5_free_error_message(context, msg);
1007         ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1008         goto out;
1009     }
1010
1011     memset(&et, 0, sizeof(et));
1012     memset(&ek, 0, sizeof(ek));
1013
1014     /*
1015      * Select a session enctype from the list of the crypto systems
1016      * supported enctype, is supported by the client and is one of the
1017      * enctype of the enctype of the krbtgt.
1018      *
1019      * The later is used as a hint what enctype all KDC are supporting
1020      * to make sure a newer version of KDC wont generate a session
1021      * enctype that and older version of a KDC in the same realm can't
1022      * decrypt.
1023      *
1024      * But if the KDC admin is paranoid and doesn't want to have "no
1025      * the best" enctypes on the krbtgt, lets save the best pick from
1026      * the client list and hope that that will work for any other
1027      * KDCs.
1028      */
1029     {
1030         const krb5_enctype *p;
1031         krb5_enctype clientbest = ETYPE_NULL;
1032         int i, j;
1033
1034         p = krb5_kerberos_enctypes(context);
1035
1036         sessionetype = ETYPE_NULL;
1037
1038         for (i = 0; p[i] != ETYPE_NULL && sessionetype == ETYPE_NULL; i++) {
1039             if (krb5_enctype_valid(context, p[i]) != 0)
1040                 continue;
1041
1042             for (j = 0; j < b->etype.len && sessionetype == ETYPE_NULL; j++) {
1043                 Key *dummy;
1044                 /* check with client */
1045                 if (p[i] != b->etype.val[j])
1046                     continue;
1047                 /* save best of union of { client, crypto system } */
1048                 if (clientbest == ETYPE_NULL)
1049                     clientbest = p[i];
1050                 /* check with krbtgt */
1051                 ret = hdb_enctype2key(context, &server->entry, p[i], &dummy);
1052                 if (ret)
1053                     continue;
1054                 sessionetype = p[i];
1055             }
1056         }
1057         /* if krbtgt had no shared keys with client, pick clients best */
1058         if (clientbest != ETYPE_NULL && sessionetype == ETYPE_NULL) {
1059             sessionetype = clientbest;
1060         } else if (sessionetype == ETYPE_NULL) {
1061             kdc_log(context, config, 0,
1062                     "Client (%s) from %s has no common enctypes with KDC"
1063                     "to use for the session key",
1064                     client_name, from);
1065             goto out;
1066         }
1067     }
1068
1069     /*
1070      * Pre-auth processing
1071      */
1072
1073     if(req->padata){
1074         int i;
1075         const PA_DATA *pa;
1076         int found_pa = 0;
1077
1078         log_patypes(context, config, req->padata);
1079
1080 #ifdef PKINIT
1081         kdc_log(context, config, 5,
1082                 "Looking for PKINIT pa-data -- %s", client_name);
1083
1084         e_text = "No PKINIT PA found";
1085
1086         i = 0;
1087         pa = _kdc_find_padata(req, &i, KRB5_PADATA_PK_AS_REQ);
1088         if (pa == NULL) {
1089             i = 0;
1090             pa = _kdc_find_padata(req, &i, KRB5_PADATA_PK_AS_REQ_WIN);
1091         }
1092         if (pa) {
1093             char *client_cert = NULL;
1094
1095             ret = _kdc_pk_rd_padata(context, config, req, pa, client, &pkp);
1096             if (ret) {
1097                 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1098                 kdc_log(context, config, 5,
1099                         "Failed to decode PKINIT PA-DATA -- %s",
1100                         client_name);
1101                 goto ts_enc;
1102             }
1103             if (ret == 0 && pkp == NULL)
1104                 goto ts_enc;
1105
1106             ret = _kdc_pk_check_client(context,
1107                                        config,
1108                                        clientdb, 
1109                                        client,
1110                                        pkp,
1111                                        &client_cert);
1112             if (ret) {
1113                 e_text = "PKINIT certificate not allowed to "
1114                     "impersonate principal";
1115                 _kdc_pk_free_client_param(context, pkp);
1116                 
1117                 kdc_log(context, config, 0, "%s", e_text);
1118                 pkp = NULL;
1119                 goto out;
1120             }
1121
1122             found_pa = 1;
1123             et.flags.pre_authent = 1;
1124             kdc_log(context, config, 0,
1125                     "PKINIT pre-authentication succeeded -- %s using %s",
1126                     client_name, client_cert);
1127             free(client_cert);
1128             if (pkp)
1129                 goto preauth_done;
1130         }
1131     ts_enc:
1132 #endif
1133         kdc_log(context, config, 5, "Looking for ENC-TS pa-data -- %s",
1134                 client_name);
1135
1136         i = 0;
1137         e_text = "No ENC-TS found";
1138         while((pa = _kdc_find_padata(req, &i, KRB5_PADATA_ENC_TIMESTAMP))){
1139             krb5_data ts_data;
1140             PA_ENC_TS_ENC p;
1141             size_t len;
1142             EncryptedData enc_data;
1143             Key *pa_key;
1144             char *str;
1145         
1146             found_pa = 1;
1147         
1148             if (b->kdc_options.request_anonymous) {
1149                 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1150                 kdc_log(context, config, 0, "ENC-TS doesn't support anon");
1151                 goto out;
1152             }
1153
1154             ret = decode_EncryptedData(pa->padata_value.data,
1155                                        pa->padata_value.length,
1156                                        &enc_data,
1157                                        &len);
1158             if (ret) {
1159                 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1160                 kdc_log(context, config, 5, "Failed to decode PA-DATA -- %s",
1161                         client_name);
1162                 goto out;
1163             }
1164         
1165             ret = hdb_enctype2key(context, &client->entry,
1166                                   enc_data.etype, &pa_key);
1167             if(ret){
1168                 char *estr;
1169                 e_text = "No key matches pa-data";
1170                 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
1171                 if(krb5_enctype_to_string(context, enc_data.etype, &estr))
1172                     estr = NULL;
1173                 if(estr == NULL)
1174                     kdc_log(context, config, 5,
1175                             "No client key matching pa-data (%d) -- %s",
1176                             enc_data.etype, client_name);
1177                 else
1178                     kdc_log(context, config, 5,
1179                             "No client key matching pa-data (%s) -- %s",
1180                             estr, client_name);
1181                 free(estr);
1182                 free_EncryptedData(&enc_data);
1183
1184                 continue;
1185             }
1186
1187         try_next_key:
1188             ret = krb5_crypto_init(context, &pa_key->key, 0, &crypto);
1189             if (ret) {
1190                 const char *msg = krb5_get_error_message(context, ret);
1191                 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1192                 krb5_free_error_message(context, msg);
1193                 free_EncryptedData(&enc_data);
1194                 continue;
1195             }
1196
1197             ret = krb5_decrypt_EncryptedData (context,
1198                                               crypto,
1199                                               KRB5_KU_PA_ENC_TIMESTAMP,
1200                                               &enc_data,
1201                                               &ts_data);
1202             krb5_crypto_destroy(context, crypto);
1203             /*
1204              * Since the user might have several keys with the same
1205              * enctype but with diffrent salting, we need to try all
1206              * the keys with the same enctype.
1207              */
1208             if(ret){
1209                 krb5_error_code ret2;
1210                 const char *msg = krb5_get_error_message(context, ret);
1211
1212                 ret2 = krb5_enctype_to_string(context,
1213                                               pa_key->key.keytype, &str);
1214                 if (ret2)
1215                     str = NULL;
1216                 kdc_log(context, config, 5,
1217                         "Failed to decrypt PA-DATA -- %s "
1218                         "(enctype %s) error %s",
1219                         client_name, str ? str : "unknown enctype", msg);
1220                 krb5_free_error_message(context, msg);
1221                 free(str);
1222
1223                 if(hdb_next_enctype2key(context, &client->entry,
1224                                         enc_data.etype, &pa_key) == 0)
1225                     goto try_next_key;
1226                 e_text = "Failed to decrypt PA-DATA";
1227
1228                 free_EncryptedData(&enc_data);
1229
1230                 if (clientdb->hdb_auth_status)
1231                     (clientdb->hdb_auth_status)(context, clientdb, client, HDB_AUTH_WRONG_PASSWORD);
1232
1233                 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1234                 continue;
1235             }
1236             free_EncryptedData(&enc_data);
1237             ret = decode_PA_ENC_TS_ENC(ts_data.data,
1238                                        ts_data.length,
1239                                        &p,
1240                                        &len);
1241             krb5_data_free(&ts_data);
1242             if(ret){
1243                 e_text = "Failed to decode PA-ENC-TS-ENC";
1244                 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1245                 kdc_log(context, config,
1246                         5, "Failed to decode PA-ENC-TS_ENC -- %s",
1247                         client_name);
1248                 continue;
1249             }
1250             free_PA_ENC_TS_ENC(&p);
1251             if (abs(kdc_time - p.patimestamp) > context->max_skew) {
1252                 char client_time[100];
1253                 
1254                 krb5_format_time(context, p.patimestamp,
1255                                  client_time, sizeof(client_time), TRUE);
1256
1257                 ret = KRB5KRB_AP_ERR_SKEW;
1258                 kdc_log(context, config, 0,
1259                         "Too large time skew, "
1260                         "client time %s is out by %u > %u seconds -- %s",
1261                         client_time,
1262                         (unsigned)abs(kdc_time - p.patimestamp),
1263                         context->max_skew,
1264                         client_name);
1265
1266                 /*
1267                  * The following is needed to make windows clients to
1268                  * retry using the timestamp in the error message, if
1269                  * there is a e_text, they become unhappy.
1270                  */
1271                 e_text = NULL;
1272                 goto out;
1273             }
1274             et.flags.pre_authent = 1;
1275
1276             set_salt_padata(rep.padata, pa_key->salt);
1277
1278             reply_key = &pa_key->key;
1279
1280             ret = krb5_enctype_to_string(context, pa_key->key.keytype, &str);
1281             if (ret)
1282                 str = NULL;
1283
1284             kdc_log(context, config, 2,
1285                     "ENC-TS Pre-authentication succeeded -- %s using %s",
1286                     client_name, str ? str : "unknown enctype");
1287             free(str);
1288             break;
1289         }
1290 #ifdef PKINIT
1291     preauth_done:
1292 #endif
1293         if(found_pa == 0 && config->require_preauth)
1294             goto use_pa;
1295         /* We come here if we found a pa-enc-timestamp, but if there
1296            was some problem with it, other than too large skew */
1297         if(found_pa && et.flags.pre_authent == 0){
1298             kdc_log(context, config, 0, "%s -- %s", e_text, client_name);
1299             e_text = NULL;
1300             goto out;
1301         }
1302     }else if (config->require_preauth
1303               || b->kdc_options.request_anonymous /* hack to force anon */
1304               || client->entry.flags.require_preauth
1305               || server->entry.flags.require_preauth) {
1306         METHOD_DATA method_data;
1307         PA_DATA *pa;
1308         unsigned char *buf;
1309         size_t len;
1310
1311     use_pa:
1312         method_data.len = 0;
1313         method_data.val = NULL;
1314
1315         ret = realloc_method_data(&method_data);
1316         if (ret) {
1317             free_METHOD_DATA(&method_data);
1318             goto out;
1319         }
1320         pa = &method_data.val[method_data.len-1];
1321         pa->padata_type         = KRB5_PADATA_ENC_TIMESTAMP;
1322         pa->padata_value.length = 0;
1323         pa->padata_value.data   = NULL;
1324
1325 #ifdef PKINIT
1326         ret = realloc_method_data(&method_data);
1327         if (ret) {
1328             free_METHOD_DATA(&method_data);
1329             goto out;
1330         }
1331         pa = &method_data.val[method_data.len-1];
1332         pa->padata_type         = KRB5_PADATA_PK_AS_REQ;
1333         pa->padata_value.length = 0;
1334         pa->padata_value.data   = NULL;
1335
1336         ret = realloc_method_data(&method_data);
1337         if (ret) {
1338             free_METHOD_DATA(&method_data);
1339             goto out;
1340         }
1341         pa = &method_data.val[method_data.len-1];
1342         pa->padata_type         = KRB5_PADATA_PK_AS_REQ_WIN;
1343         pa->padata_value.length = 0;
1344         pa->padata_value.data   = NULL;
1345 #endif
1346
1347         /*
1348          * If there is a client key, send ETYPE_INFO{,2}
1349          */
1350         ret = _kdc_find_etype(context, client, b->etype.val, b->etype.len,
1351                               &ckey);
1352         if (ret == 0) {
1353
1354             /*
1355              * RFC4120 requires:
1356              * - If the client only knows about old enctypes, then send
1357              *   both info replies (we send 'info' first in the list).
1358              * - If the client is 'modern', because it knows about 'new'
1359              *   enctype types, then only send the 'info2' reply.
1360              *
1361              * Before we send the full list of etype-info data, we pick
1362              * the client key we would have used anyway below, just pick
1363              * that instead.
1364              */
1365
1366             if (older_enctype(ckey->key.keytype)) {
1367                 ret = get_pa_etype_info(context, config,
1368                                         &method_data, ckey);
1369                 if (ret) {
1370                     free_METHOD_DATA(&method_data);
1371                     goto out;
1372                 }
1373             }
1374             ret = get_pa_etype_info2(context, config,
1375                                      &method_data, ckey);
1376             if (ret) {
1377                 free_METHOD_DATA(&method_data);
1378                 goto out;
1379             }
1380         }
1381         
1382         ASN1_MALLOC_ENCODE(METHOD_DATA, buf, len, &method_data, &len, ret);
1383         free_METHOD_DATA(&method_data);
1384
1385         e_data.data   = buf;
1386         e_data.length = len;
1387         e_text ="Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ",
1388
1389         ret = KRB5KDC_ERR_PREAUTH_REQUIRED;
1390
1391         kdc_log(context, config, 0,
1392                 "No preauth found, returning PREAUTH-REQUIRED -- %s",
1393                 client_name);
1394         goto out;
1395     }
1396
1397     if (clientdb->hdb_auth_status)
1398         (clientdb->hdb_auth_status)(context, clientdb, client, 
1399                                     HDB_AUTH_SUCCESS);
1400
1401     /*
1402      * Verify flags after the user been required to prove its identity
1403      * with in a preauth mech.
1404      */
1405
1406     ret = _kdc_check_access(context, config, client, client_name,
1407                             server, server_name,
1408                             req, &e_data);
1409     if(ret)
1410         goto out;
1411
1412     /*
1413      * Selelct the best encryption type for the KDC with out regard to
1414      * the client since the client never needs to read that data.
1415      */
1416
1417     ret = _kdc_get_preferred_key(context, config,
1418                                  server, server_name,
1419                                  &setype, &skey);
1420     if(ret)
1421         goto out;
1422
1423     if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey
1424        || (f.request_anonymous && !config->allow_anonymous)) {
1425         ret = KRB5KDC_ERR_BADOPTION;
1426         e_text = "Bad KDC options";
1427         kdc_log(context, config, 0, "Bad KDC options -- %s", client_name);
1428         goto out;
1429     }
1430
1431     rep.pvno = 5;
1432     rep.msg_type = krb_as_rep;
1433
1434     ret = copy_Realm(&client->entry.principal->realm, &rep.crealm);
1435     if (ret)
1436         goto out;
1437     ret = _krb5_principal2principalname(&rep.cname, client->entry.principal);
1438     if (ret)
1439         goto out;
1440
1441     rep.ticket.tkt_vno = 5;
1442     copy_Realm(&server->entry.principal->realm, &rep.ticket.realm);
1443     _krb5_principal2principalname(&rep.ticket.sname,
1444                                   server->entry.principal);
1445     /* java 1.6 expects the name to be the same type, lets allow that
1446      * uncomplicated name-types. */
1447 #define CNT(sp,t) (((sp)->sname->name_type) == KRB5_NT_##t)
1448     if (CNT(b, UNKNOWN) || CNT(b, PRINCIPAL) || CNT(b, SRV_INST) || CNT(b, SRV_HST) || CNT(b, SRV_XHST))
1449         rep.ticket.sname.name_type = b->sname->name_type;
1450 #undef CNT
1451
1452     et.flags.initial = 1;
1453     if(client->entry.flags.forwardable && server->entry.flags.forwardable)
1454         et.flags.forwardable = f.forwardable;
1455     else if (f.forwardable) {
1456         e_text = "Ticket may not be forwardable";
1457         ret = KRB5KDC_ERR_POLICY;
1458         kdc_log(context, config, 0,
1459                 "Ticket may not be forwardable -- %s", client_name);
1460         goto out;
1461     }
1462     if(client->entry.flags.proxiable && server->entry.flags.proxiable)
1463         et.flags.proxiable = f.proxiable;
1464     else if (f.proxiable) {
1465         e_text = "Ticket may not be proxiable";
1466         ret = KRB5KDC_ERR_POLICY;
1467         kdc_log(context, config, 0,
1468                 "Ticket may not be proxiable -- %s", client_name);
1469         goto out;
1470     }
1471     if(client->entry.flags.postdate && server->entry.flags.postdate)
1472         et.flags.may_postdate = f.allow_postdate;
1473     else if (f.allow_postdate){
1474         e_text = "Ticket may not be postdate";
1475         ret = KRB5KDC_ERR_POLICY;
1476         kdc_log(context, config, 0,
1477                 "Ticket may not be postdatable -- %s", client_name);
1478         goto out;
1479     }
1480
1481     /* check for valid set of addresses */
1482     if(!_kdc_check_addresses(context, config, b->addresses, from_addr)) {
1483         e_text = "Bad address list in requested";
1484         ret = KRB5KRB_AP_ERR_BADADDR;
1485         kdc_log(context, config, 0,
1486                 "Bad address list requested -- %s", client_name);
1487         goto out;
1488     }
1489
1490     ret = copy_PrincipalName(&rep.cname, &et.cname);
1491     if (ret)
1492         goto out;
1493     ret = copy_Realm(&rep.crealm, &et.crealm);
1494     if (ret)
1495         goto out;
1496
1497     {
1498         time_t start;
1499         time_t t;
1500         
1501         start = et.authtime = kdc_time;
1502
1503         if(f.postdated && req->req_body.from){
1504             ALLOC(et.starttime);
1505             start = *et.starttime = *req->req_body.from;
1506             et.flags.invalid = 1;
1507             et.flags.postdated = 1; /* XXX ??? */
1508         }
1509         _kdc_fix_time(&b->till);
1510         t = *b->till;
1511
1512         /* be careful not overflowing */
1513
1514         if(client->entry.max_life)
1515             t = start + min(t - start, *client->entry.max_life);
1516         if(server->entry.max_life)
1517             t = start + min(t - start, *server->entry.max_life);
1518 #if 0
1519         t = min(t, start + realm->max_life);
1520 #endif
1521         et.endtime = t;
1522         if(f.renewable_ok && et.endtime < *b->till){
1523             f.renewable = 1;
1524             if(b->rtime == NULL){
1525                 ALLOC(b->rtime);
1526                 *b->rtime = 0;
1527             }
1528             if(*b->rtime < *b->till)
1529                 *b->rtime = *b->till;
1530         }
1531         if(f.renewable && b->rtime){
1532             t = *b->rtime;
1533             if(t == 0)
1534                 t = MAX_TIME;
1535             if(client->entry.max_renew)
1536                 t = start + min(t - start, *client->entry.max_renew);
1537             if(server->entry.max_renew)
1538                 t = start + min(t - start, *server->entry.max_renew);
1539 #if 0
1540             t = min(t, start + realm->max_renew);
1541 #endif
1542             ALLOC(et.renew_till);
1543             *et.renew_till = t;
1544             et.flags.renewable = 1;
1545         }
1546     }
1547
1548     if (f.request_anonymous)
1549         et.flags.anonymous = 1;
1550
1551     if(b->addresses){
1552         ALLOC(et.caddr);
1553         copy_HostAddresses(b->addresses, et.caddr);
1554     }
1555
1556     et.transited.tr_type = DOMAIN_X500_COMPRESS;
1557     krb5_data_zero(&et.transited.contents);
1558
1559     /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
1560      * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
1561      * incapable of correctly decoding SEQUENCE OF's of zero length.
1562      *
1563      * To fix this, always send at least one no-op last_req
1564      *
1565      * If there's a pw_end or valid_end we will use that,
1566      * otherwise just a dummy lr.
1567      */
1568     ek.last_req.val = malloc(2 * sizeof(*ek.last_req.val));
1569     if (ek.last_req.val == NULL) {
1570         ret = ENOMEM;
1571         goto out;
1572     }
1573     ek.last_req.len = 0;
1574     if (client->entry.pw_end
1575         && (config->kdc_warn_pwexpire == 0
1576             || kdc_time + config->kdc_warn_pwexpire >= *client->entry.pw_end)) {
1577         ek.last_req.val[ek.last_req.len].lr_type  = LR_PW_EXPTIME;
1578         ek.last_req.val[ek.last_req.len].lr_value = *client->entry.pw_end;
1579         ++ek.last_req.len;
1580     }
1581     if (client->entry.valid_end) {
1582         ek.last_req.val[ek.last_req.len].lr_type  = LR_ACCT_EXPTIME;
1583         ek.last_req.val[ek.last_req.len].lr_value = *client->entry.valid_end;
1584         ++ek.last_req.len;
1585     }
1586     if (ek.last_req.len == 0) {
1587         ek.last_req.val[ek.last_req.len].lr_type  = LR_NONE;
1588         ek.last_req.val[ek.last_req.len].lr_value = 0;
1589         ++ek.last_req.len;
1590     }
1591     ek.nonce = b->nonce;
1592     if (client->entry.valid_end || client->entry.pw_end) {
1593         ALLOC(ek.key_expiration);
1594         if (client->entry.valid_end) {
1595             if (client->entry.pw_end)
1596                 *ek.key_expiration = min(*client->entry.valid_end,
1597                                          *client->entry.pw_end);
1598             else
1599                 *ek.key_expiration = *client->entry.valid_end;
1600         } else
1601             *ek.key_expiration = *client->entry.pw_end;
1602     } else
1603         ek.key_expiration = NULL;
1604     ek.flags = et.flags;
1605     ek.authtime = et.authtime;
1606     if (et.starttime) {
1607         ALLOC(ek.starttime);
1608         *ek.starttime = *et.starttime;
1609     }
1610     ek.endtime = et.endtime;
1611     if (et.renew_till) {
1612         ALLOC(ek.renew_till);
1613         *ek.renew_till = *et.renew_till;
1614     }
1615     copy_Realm(&rep.ticket.realm, &ek.srealm);
1616     copy_PrincipalName(&rep.ticket.sname, &ek.sname);
1617     if(et.caddr){
1618         ALLOC(ek.caddr);
1619         copy_HostAddresses(et.caddr, ek.caddr);
1620     }
1621
1622 #if PKINIT
1623     if (pkp) {
1624         e_text = "Failed to build PK-INIT reply";
1625         ret = _kdc_pk_mk_pa_reply(context, config, pkp, client,
1626                                   sessionetype, req, req_buffer,
1627                                   &reply_key, &et.key, rep.padata);
1628         if (ret)
1629             goto out;
1630         ret = _kdc_add_inital_verified_cas(context,
1631                                            config,
1632                                            pkp,
1633                                            &et);
1634         if (ret)
1635             goto out;
1636
1637     } else
1638 #endif
1639     {
1640         ret = krb5_generate_random_keyblock(context, sessionetype, &et.key);
1641         if (ret)
1642             goto out;
1643     }
1644
1645     if (reply_key == NULL) {
1646         e_text = "Client have no reply key";
1647         ret = KRB5KDC_ERR_CLIENT_NOTYET;
1648         goto out;
1649     }
1650
1651     ret = copy_EncryptionKey(&et.key, &ek.key);
1652     if (ret)
1653         goto out;
1654
1655     /* Add signing of alias referral */
1656     if (f.canonicalize) {
1657         PA_ClientCanonicalized canon;
1658         krb5_data data;
1659         PA_DATA pa;
1660         krb5_crypto crypto;
1661         size_t len;
1662
1663         memset(&canon, 0, sizeof(canon));
1664
1665         canon.names.requested_name = *b->cname;
1666         canon.names.mapped_name = client->entry.principal->name;
1667
1668         ASN1_MALLOC_ENCODE(PA_ClientCanonicalizedNames, data.data, data.length,
1669                            &canon.names, &len, ret);
1670         if (ret)
1671             goto out;
1672         if (data.length != len)
1673             krb5_abortx(context, "internal asn.1 error");
1674
1675         /* sign using "returned session key" */
1676         ret = krb5_crypto_init(context, &et.key, 0, &crypto);
1677         if (ret) {
1678             free(data.data);
1679             goto out;
1680         }
1681
1682         ret = krb5_create_checksum(context, crypto,
1683                                    KRB5_KU_CANONICALIZED_NAMES, 0,
1684                                    data.data, data.length,
1685                                    &canon.canon_checksum);
1686         free(data.data);
1687         krb5_crypto_destroy(context, crypto);
1688         if (ret)
1689             goto out;
1690         
1691         ASN1_MALLOC_ENCODE(PA_ClientCanonicalized, data.data, data.length,
1692                            &canon, &len, ret);
1693         free_Checksum(&canon.canon_checksum);
1694         if (ret)
1695             goto out;
1696         if (data.length != len)
1697             krb5_abortx(context, "internal asn.1 error");
1698
1699         pa.padata_type = KRB5_PADATA_CLIENT_CANONICALIZED;
1700         pa.padata_value = data;
1701         ret = add_METHOD_DATA(rep.padata, &pa);
1702         free(data.data);
1703         if (ret)
1704             goto out;
1705     }
1706
1707     if (rep.padata->len == 0) {
1708         free(rep.padata);
1709         rep.padata = NULL;
1710     }
1711
1712     /* Add the PAC */
1713     if (send_pac_p(context, req)) {
1714         krb5_pac p = NULL;
1715         krb5_data data;
1716
1717         ret = _kdc_pac_generate(context, client, &p);
1718         if (ret) {
1719             kdc_log(context, config, 0, "PAC generation failed for -- %s",
1720                     client_name);
1721             goto out;
1722         }
1723         if (p != NULL) {
1724             ret = _krb5_pac_sign(context, p, et.authtime,
1725                                  client->entry.principal,
1726                                  &skey->key, /* Server key */
1727                                  &skey->key, /* FIXME: should be krbtgt key */
1728                                  &data);
1729             krb5_pac_free(context, p);
1730             if (ret) {
1731                 kdc_log(context, config, 0, "PAC signing failed for -- %s",
1732                         client_name);
1733                 goto out;
1734             }
1735
1736             ret = _kdc_tkt_add_if_relevant_ad(context, &et,
1737                                               KRB5_AUTHDATA_WIN2K_PAC,
1738                                               &data);
1739             krb5_data_free(&data);
1740             if (ret)
1741                 goto out;
1742         }
1743     }
1744
1745     _kdc_log_timestamp(context, config, "AS-REQ", et.authtime, et.starttime,
1746                        et.endtime, et.renew_till);
1747
1748     /* do this as the last thing since this signs the EncTicketPart */
1749     ret = _kdc_add_KRB5SignedPath(context,
1750                                   config,
1751                                   server,
1752                                   setype,
1753                                   client->entry.principal,
1754                                   NULL,
1755                                   NULL,
1756                                   &et);
1757     if (ret)
1758         goto out;
1759
1760     log_as_req(context, config, reply_key->keytype, setype, b);
1761
1762     ret = _kdc_encode_reply(context, config,
1763                             &rep, &et, &ek, setype, server->entry.kvno,
1764                             &skey->key, client->entry.kvno,
1765                             reply_key, 0, &e_text, reply);
1766     free_EncTicketPart(&et);
1767     free_EncKDCRepPart(&ek);
1768     if (ret)
1769         goto out;
1770
1771     /* */
1772     if (datagram_reply && reply->length > config->max_datagram_reply_length) {
1773         krb5_data_free(reply);
1774         ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
1775         e_text = "Reply packet too large";
1776     }
1777
1778 out:
1779     free_AS_REP(&rep);
1780     if(ret){
1781         krb5_mk_error(context,
1782                       ret,
1783                       e_text,
1784                       (e_data.data ? &e_data : NULL),
1785                       client_princ,
1786                       server_princ,
1787                       NULL,
1788                       NULL,
1789                       reply);
1790         ret = 0;
1791     }
1792 #ifdef PKINIT
1793     if (pkp)
1794         _kdc_pk_free_client_param(context, pkp);
1795 #endif
1796     if (e_data.data)
1797         free(e_data.data);
1798     if (client_princ)
1799         krb5_free_principal(context, client_princ);
1800     free(client_name);
1801     if (server_princ)
1802         krb5_free_principal(context, server_princ);
1803     free(server_name);
1804     if(client)
1805         _kdc_free_ent(context, client);
1806     if(server)
1807         _kdc_free_ent(context, server);
1808     return ret;
1809 }
1810
1811 /*
1812  * Add the AuthorizationData `data´ of `type´ to the last element in
1813  * the sequence of authorization_data in `tkt´ wrapped in an IF_RELEVANT
1814  */
1815
1816 krb5_error_code
1817 _kdc_tkt_add_if_relevant_ad(krb5_context context,
1818                             EncTicketPart *tkt,
1819                             int type,
1820                             const krb5_data *data)
1821 {
1822     krb5_error_code ret;
1823     size_t size;
1824
1825     if (tkt->authorization_data == NULL) {
1826         tkt->authorization_data = calloc(1, sizeof(*tkt->authorization_data));
1827         if (tkt->authorization_data == NULL) {
1828             krb5_set_error_message(context, ENOMEM, "out of memory");
1829             return ENOMEM;
1830         }
1831     }
1832         
1833     /* add the entry to the last element */
1834     {
1835         AuthorizationData ad = { 0, NULL };
1836         AuthorizationDataElement ade;
1837
1838         ade.ad_type = type;
1839         ade.ad_data = *data;
1840
1841         ret = add_AuthorizationData(&ad, &ade);
1842         if (ret) {
1843             krb5_set_error_message(context, ret, "add AuthorizationData failed");
1844             return ret;
1845         }
1846
1847         ade.ad_type = KRB5_AUTHDATA_IF_RELEVANT;
1848
1849         ASN1_MALLOC_ENCODE(AuthorizationData,
1850                            ade.ad_data.data, ade.ad_data.length,
1851                            &ad, &size, ret);
1852         free_AuthorizationData(&ad);
1853         if (ret) {
1854             krb5_set_error_message(context, ret, "ASN.1 encode of "
1855                                    "AuthorizationData failed");
1856             return ret;
1857         }
1858         if (ade.ad_data.length != size)
1859             krb5_abortx(context, "internal asn.1 encoder error");
1860         
1861         ret = add_AuthorizationData(tkt->authorization_data, &ade);
1862         der_free_octet_string(&ade.ad_data);
1863         if (ret) {
1864             krb5_set_error_message(context, ret, "add AuthorizationData failed");
1865             return ret;
1866         }
1867     }
1868
1869     return 0;
1870 }