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