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