?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
free ac after its used
[heimdal.git] / kdc / kerberos5.c
blobe859a9867ac1f85315d184c08363166b15ac4fda
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 && !is_default_salt_p(&def_salt, key))
178 continue;
179 enctype = p[i];
180 }
181 }
182 if (clientbest != ETYPE_NULL && enctype == ETYPE_NULL)
183 enctype = clientbest;
184 else if (enctype == ETYPE_NULL)
185 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
186 if (ret == 0 && ret_enctype != NULL)
187 *ret_enctype = enctype;
188 if (ret == 0 && ret_key != NULL)
189 *ret_key = key;
190 } else {
191 /*
192 * Pick the first key from the client's enctype list that is
193 * supported by the cryptosystem and by the given principal.
194 *
195 * RFC4120 says we SHOULD pick the first _strong_ key from the
196 * client's list... not the first key... If the admin disallows
197 * weak enctypes in krb5.conf and selects this key selection
198 * algorithm, then we get exactly what RFC4120 says.
199 */
200 for(key = NULL, i = 0; ret != 0 && i < len; i++, key = NULL) {
201
202 if (krb5_enctype_valid(context, etypes[i]) != 0 &&
203 !_kdc_is_weak_exception(princ->entry.principal, etypes[i]))
204 continue;
205
206 while (hdb_next_enctype2key(context, &princ->entry, etypes[i], &key) == 0) {
207 if (key->key.keyvalue.length == 0) {
208 ret = KRB5KDC_ERR_NULL_KEY;
209 continue;
210 }
211 if (ret_key != NULL)
212 *ret_key = key;
213 if (ret_enctype != NULL)
214 *ret_enctype = etypes[i];
215 ret = 0;
216 if (is_preauth && is_default_salt_p(&def_salt, key))
217 goto out;
218 }
219 }
220 }
221
222 out:
223 krb5_free_salt (context, def_salt);
224 return ret;
225 }
226
227 krb5_error_code
228 _kdc_make_anonymous_principalname (PrincipalName *pn)
229 {
230 pn->name_type = KRB5_NT_PRINCIPAL;
231 pn->name_string.len = 1;
232 pn->name_string.val = malloc(sizeof(*pn->name_string.val));
233 if (pn->name_string.val == NULL)
234 return ENOMEM;
235 pn->name_string.val[0] = strdup("anonymous");
236 if (pn->name_string.val[0] == NULL) {
237 free(pn->name_string.val);
238 pn->name_string.val = NULL;
239 return ENOMEM;
240 }
241 return 0;
242 }
243
244 void
245 _kdc_log_timestamp(krb5_context context,
246 krb5_kdc_configuration *config,
247 const char *type,
248 KerberosTime authtime, KerberosTime *starttime,
249 KerberosTime endtime, KerberosTime *renew_till)
250 {
251 char authtime_str[100], starttime_str[100],
252 endtime_str[100], renewtime_str[100];
253
254 krb5_format_time(context, authtime,
255 authtime_str, sizeof(authtime_str), TRUE);
256 if (starttime)
257 krb5_format_time(context, *starttime,
258 starttime_str, sizeof(starttime_str), TRUE);
259 else
260 strlcpy(starttime_str, "unset", sizeof(starttime_str));
261 krb5_format_time(context, endtime,
262 endtime_str, sizeof(endtime_str), TRUE);
263 if (renew_till)
264 krb5_format_time(context, *renew_till,
265 renewtime_str, sizeof(renewtime_str), TRUE);
266 else
267 strlcpy(renewtime_str, "unset", sizeof(renewtime_str));
268
269 kdc_log(context, config, 5,
270 "%s authtime: %s starttime: %s endtime: %s renew till: %s",
271 type, authtime_str, starttime_str, endtime_str, renewtime_str);
272 }
273
274 static void
275 log_patypes(krb5_context context,
276 krb5_kdc_configuration *config,
277 METHOD_DATA *padata)
278 {
279 struct rk_strpool *p = NULL;
280 char *str;
281 size_t i;
282
283 for (i = 0; i < padata->len; i++) {
284 switch(padata->val[i].padata_type) {
285 case KRB5_PADATA_PK_AS_REQ:
286 p = rk_strpoolprintf(p, "PK-INIT(ietf)");
287 break;
288 case KRB5_PADATA_PK_AS_REQ_WIN:
289 p = rk_strpoolprintf(p, "PK-INIT(win2k)");
290 break;
291 case KRB5_PADATA_PA_PK_OCSP_RESPONSE:
292 p = rk_strpoolprintf(p, "OCSP");
293 break;
294 case KRB5_PADATA_ENC_TIMESTAMP:
295 p = rk_strpoolprintf(p, "encrypted-timestamp");
296 break;
297 default:
298 p = rk_strpoolprintf(p, "%d", padata->val[i].padata_type);
299 break;
300 }
301 if (p && i + 1 < padata->len)
302 p = rk_strpoolprintf(p, ", ");
303 if (p == NULL) {
304 kdc_log(context, config, 0, "out of memory");
305 return;
306 }
307 }
308 if (p == NULL)
309 p = rk_strpoolprintf(p, "none");
310
311 str = rk_strpoolcollect(p);
312 kdc_log(context, config, 0, "Client sent patypes: %s", str);
313 free(str);
314 }
315
316 /*
317 *
318 */
319
320
321 krb5_error_code
322 _kdc_encode_reply(krb5_context context,
323 krb5_kdc_configuration *config,
324 krb5_crypto armor_crypto, uint32_t nonce,
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 (armor_crypto) {
380 krb5_data data;
381 krb5_keyblock *strengthen_key = NULL;
382 KrbFastFinished finished;
383
384 memset(&finished, 0, sizeof(finished));
385 krb5_data_zero(&data);
386
387 finished.timestamp = kdc_time;
388 finished.usec = 0;
389 finished.crealm = et->crealm;
390 finished.cname = et->cname;
391
392 ASN1_MALLOC_ENCODE(Ticket, data.data, data.length,
393 &rep->ticket, &len, ret);
394 if (ret)
395 return ret;
396 if (data.length != len)
397 krb5_abortx(context, "internal asn.1 error");
398
399 ret = krb5_create_checksum(context, armor_crypto,
400 KRB5_KU_FAST_FINISHED, 0,
401 data.data, data.length,
402 &finished.ticket_checksum);
403 krb5_data_free(&data);
404 if (ret)
405 return ret;
406
407 ret = _kdc_fast_mk_response(context, armor_crypto,
408 rep->padata, strengthen_key, &finished,
409 nonce, &data);
410 free_Checksum(&finished.ticket_checksum);
411 if (ret)
412 return ret;
413
414 if (rep->padata) {
415 free_METHOD_DATA(rep->padata);
416 } else {
417 rep->padata = calloc(1, sizeof(*(rep->padata)));
418 if (rep->padata == NULL) {
419 krb5_data_free(&data);
420 return ENOMEM;
421 }
422 }
423
424 ret = krb5_padata_add(context, rep->padata,
425 KRB5_PADATA_FX_FAST,
426 data.data, data.length);
427 if (ret)
428 return ret;
429 }
430
431 if(rep->msg_type == krb_as_rep && !config->encode_as_rep_as_tgs_rep)
432 ASN1_MALLOC_ENCODE(EncASRepPart, buf, buf_size, ek, &len, ret);
433 else
434 ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
435 if(ret) {
436 const char *msg = krb5_get_error_message(context, ret);
437 kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
438 krb5_free_error_message(context, msg);
439 return ret;
440 }
441 if(buf_size != len) {
442 free(buf);
443 kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
444 *e_text = "KDC internal error";
445 return KRB5KRB_ERR_GENERIC;
446 }
447 ret = krb5_crypto_init(context, reply_key, 0, &crypto);
448 if (ret) {
449 const char *msg = krb5_get_error_message(context, ret);
450 free(buf);
451 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
452 krb5_free_error_message(context, msg);
453 return ret;
454 }
455 if(rep->msg_type == krb_as_rep) {
456 krb5_encrypt_EncryptedData(context,
457 crypto,
458 KRB5_KU_AS_REP_ENC_PART,
459 buf,
460 len,
461 ckvno,
462 &rep->enc_part);
463 free(buf);
464 ASN1_MALLOC_ENCODE(AS_REP, buf, buf_size, rep, &len, ret);
465 } else {
466 krb5_encrypt_EncryptedData(context,
467 crypto,
468 rk_is_subkey ? KRB5_KU_TGS_REP_ENC_PART_SUB_KEY : KRB5_KU_TGS_REP_ENC_PART_SESSION,
469 buf,
470 len,
471 ckvno,
472 &rep->enc_part);
473 free(buf);
474 ASN1_MALLOC_ENCODE(TGS_REP, buf, buf_size, rep, &len, ret);
475 }
476 krb5_crypto_destroy(context, crypto);
477 if(ret) {
478 const char *msg = krb5_get_error_message(context, ret);
479 kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
480 krb5_free_error_message(context, msg);
481 return ret;
482 }
483 if(buf_size != len) {
484 free(buf);
485 kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
486 *e_text = "KDC internal error";
487 return KRB5KRB_ERR_GENERIC;
488 }
489 reply->data = buf;
490 reply->length = buf_size;
491 return 0;
492 }
493
494 /*
495 * Return 1 if the client have only older enctypes, this is for
496 * determining if the server should send ETYPE_INFO2 or not.
497 */
498
499 static int
500 older_enctype(krb5_enctype enctype)
501 {
502 switch (enctype) {
503 case ETYPE_DES_CBC_CRC:
504 case ETYPE_DES_CBC_MD4:
505 case ETYPE_DES_CBC_MD5:
506 case ETYPE_DES3_CBC_SHA1:
507 case ETYPE_ARCFOUR_HMAC_MD5:
508 case ETYPE_ARCFOUR_HMAC_MD5_56:
509 /*
510 * The following three is "old" windows enctypes and is needed for
511 * windows 2000 hosts.
512 */
513 case ETYPE_ARCFOUR_MD4:
514 case ETYPE_ARCFOUR_HMAC_OLD:
515 case ETYPE_ARCFOUR_HMAC_OLD_EXP:
516 return 1;
517 default:
518 return 0;
519 }
520 }
521
522 /*
523 *
524 */
525
526 static krb5_error_code
527 make_etype_info_entry(krb5_context context, ETYPE_INFO_ENTRY *ent, Key *key)
528 {
529 ent->etype = key->key.keytype;
530 if(key->salt){
531 #if 0
532 ALLOC(ent->salttype);
533
534 if(key->salt->type == hdb_pw_salt)
535 *ent->salttype = 0; /* or 1? or NULL? */
536 else if(key->salt->type == hdb_afs3_salt)
537 *ent->salttype = 2;
538 else {
539 kdc_log(context, config, 0, "unknown salt-type: %d",
540 key->salt->type);
541 return KRB5KRB_ERR_GENERIC;
542 }
543 /* according to `the specs', we can't send a salt if
544 we have AFS3 salted key, but that requires that you
545 *know* what cell you are using (e.g by assuming
546 that the cell is the same as the realm in lower
547 case) */
548 #elif 0
549 ALLOC(ent->salttype);
550 *ent->salttype = key->salt->type;
551 #else
552 /*
553 * We shouldn't sent salttype since it is incompatible with the
554 * specification and it breaks windows clients. The afs
555 * salting problem is solved by using KRB5-PADATA-AFS3-SALT
556 * implemented in Heimdal 0.7 and later.
557 */
558 ent->salttype = NULL;
559 #endif
560 krb5_copy_data(context, &key->salt->salt,
561 &ent->salt);
562 } else {
563 /* we return no salt type at all, as that should indicate
564 * the default salt type and make everybody happy. some
565 * systems (like w2k) dislike being told the salt type
566 * here. */
567
568 ent->salttype = NULL;
569 ent->salt = NULL;
570 }
571 return 0;
572 }
573
574 static krb5_error_code
575 get_pa_etype_info(krb5_context context,
576 krb5_kdc_configuration *config,
577 METHOD_DATA *md, Key *ckey)
578 {
579 krb5_error_code ret = 0;
580 ETYPE_INFO pa;
581 unsigned char *buf;
582 size_t len;
583
584
585 pa.len = 1;
586 pa.val = calloc(1, sizeof(pa.val[0]));
587 if(pa.val == NULL)
588 return ENOMEM;
589
590 ret = make_etype_info_entry(context, &pa.val[0], ckey);
591 if (ret) {
592 free_ETYPE_INFO(&pa);
593 return ret;
594 }
595
596 ASN1_MALLOC_ENCODE(ETYPE_INFO, buf, len, &pa, &len, ret);
597 free_ETYPE_INFO(&pa);
598 if(ret)
599 return ret;
600 ret = realloc_method_data(md);
601 if(ret) {
602 free(buf);
603 return ret;
604 }
605 md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO;
606 md->val[md->len - 1].padata_value.length = len;
607 md->val[md->len - 1].padata_value.data = buf;
608 return 0;
609 }
610
611 /*
612 *
613 */
614
615 extern int _krb5_AES_string_to_default_iterator;
616
617 static krb5_error_code
618 make_etype_info2_entry(ETYPE_INFO2_ENTRY *ent, Key *key)
619 {
620 ent->etype = key->key.keytype;
621 if(key->salt) {
622 ALLOC(ent->salt);
623 if (ent->salt == NULL)
624 return ENOMEM;
625 *ent->salt = malloc(key->salt->salt.length + 1);
626 if (*ent->salt == NULL) {
627 free(ent->salt);
628 ent->salt = NULL;
629 return ENOMEM;
630 }
631 memcpy(*ent->salt, key->salt->salt.data, key->salt->salt.length);
632 (*ent->salt)[key->salt->salt.length] = '\0';
633 } else
634 ent->salt = NULL;
635
636 ent->s2kparams = NULL;
637
638 switch (key->key.keytype) {
639 case ETYPE_AES128_CTS_HMAC_SHA1_96:
640 case ETYPE_AES256_CTS_HMAC_SHA1_96:
641 ALLOC(ent->s2kparams);
642 if (ent->s2kparams == NULL)
643 return ENOMEM;
644 ent->s2kparams->length = 4;
645 ent->s2kparams->data = malloc(ent->s2kparams->length);
646 if (ent->s2kparams->data == NULL) {
647 free(ent->s2kparams);
648 ent->s2kparams = NULL;
649 return ENOMEM;
650 }
651 _krb5_put_int(ent->s2kparams->data,
652 _krb5_AES_string_to_default_iterator,
653 ent->s2kparams->length);
654 break;
655 case ETYPE_DES_CBC_CRC:
656 case ETYPE_DES_CBC_MD4:
657 case ETYPE_DES_CBC_MD5:
658 /* Check if this was a AFS3 salted key */
659 if(key->salt && key->salt->type == hdb_afs3_salt){
660 ALLOC(ent->s2kparams);
661 if (ent->s2kparams == NULL)
662 return ENOMEM;
663 ent->s2kparams->length = 1;
664 ent->s2kparams->data = malloc(ent->s2kparams->length);
665 if (ent->s2kparams->data == NULL) {
666 free(ent->s2kparams);
667 ent->s2kparams = NULL;
668 return ENOMEM;
669 }
670 _krb5_put_int(ent->s2kparams->data,
671 1,
672 ent->s2kparams->length);
673 }
674 break;
675 default:
676 break;
677 }
678 return 0;
679 }
680
681 /*
682 * Return an ETYPE-INFO2. Enctypes are storted the same way as in the
683 * database (client supported enctypes first, then the unsupported
684 * enctypes).
685 */
686
687 static krb5_error_code
688 get_pa_etype_info2(krb5_context context,
689 krb5_kdc_configuration *config,
690 METHOD_DATA *md, Key *ckey)
691 {
692 krb5_error_code ret = 0;
693 ETYPE_INFO2 pa;
694 unsigned char *buf;
695 size_t len;
696
697 pa.len = 1;
698 pa.val = calloc(1, sizeof(pa.val[0]));
699 if(pa.val == NULL)
700 return ENOMEM;
701
702 ret = make_etype_info2_entry(&pa.val[0], ckey);
703 if (ret) {
704 free_ETYPE_INFO2(&pa);
705 return ret;
706 }
707
708 ASN1_MALLOC_ENCODE(ETYPE_INFO2, buf, len, &pa, &len, ret);
709 free_ETYPE_INFO2(&pa);
710 if(ret)
711 return ret;
712 ret = realloc_method_data(md);
713 if(ret) {
714 free(buf);
715 return ret;
716 }
717 md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO2;
718 md->val[md->len - 1].padata_value.length = len;
719 md->val[md->len - 1].padata_value.data = buf;
720 return 0;
721 }
722
723 /*
724 *
725 */
726
727 static void
728 log_as_req(krb5_context context,
729 krb5_kdc_configuration *config,
730 krb5_enctype cetype,
731 krb5_enctype setype,
732 const KDC_REQ_BODY *b)
733 {
734 krb5_error_code ret;
735 struct rk_strpool *p;
736 char *str;
737 size_t i;
738
739 p = rk_strpoolprintf(NULL, "%s", "Client supported enctypes: ");
740
741 for (i = 0; i < b->etype.len; i++) {
742 ret = krb5_enctype_to_string(context, b->etype.val[i], &str);
743 if (ret == 0) {
744 p = rk_strpoolprintf(p, "%s", str);
745 free(str);
746 } else
747 p = rk_strpoolprintf(p, "%d", b->etype.val[i]);
748 if (p && i + 1 < b->etype.len)
749 p = rk_strpoolprintf(p, ", ");
750 if (p == NULL) {
751 kdc_log(context, config, 0, "out of memory");
752 return;
753 }
754 }
755 if (p == NULL)
756 p = rk_strpoolprintf(p, "no encryption types");
757
758 {
759 char *cet;
760 char *set;
761
762 ret = krb5_enctype_to_string(context, cetype, &cet);
763 if(ret == 0) {
764 ret = krb5_enctype_to_string(context, setype, &set);
765 if (ret == 0) {
766 p = rk_strpoolprintf(p, ", using %s/%s", cet, set);
767 free(set);
768 }
769 free(cet);
770 }
771 if (ret != 0)
772 p = rk_strpoolprintf(p, ", using enctypes %d/%d",
773 cetype, setype);
774 }
775
776 str = rk_strpoolcollect(p);
777 kdc_log(context, config, 0, "%s", str);
778 free(str);
779
780 {
781 char fixedstr[128];
782 unparse_flags(KDCOptions2int(b->kdc_options), asn1_KDCOptions_units(),
783 fixedstr, sizeof(fixedstr));
784 if(*fixedstr)
785 kdc_log(context, config, 0, "Requested flags: %s", fixedstr);
786 }
787 }
788
789 /*
790 * verify the flags on `client' and `server', returning 0
791 * if they are OK and generating an error messages and returning
792 * and error code otherwise.
793 */
794
795 krb5_error_code
796 kdc_check_flags(krb5_context context,
797 krb5_kdc_configuration *config,
798 hdb_entry_ex *client_ex, const char *client_name,
799 hdb_entry_ex *server_ex, const char *server_name,
800 krb5_boolean is_as_req)
801 {
802 if(client_ex != NULL) {
803 hdb_entry *client = &client_ex->entry;
804
805 /* check client */
806 if (client->flags.locked_out) {
807 kdc_log(context, config, 0,
808 "Client (%s) is locked out", client_name);
809 return KRB5KDC_ERR_POLICY;
810 }
811
812 if (client->flags.invalid) {
813 kdc_log(context, config, 0,
814 "Client (%s) has invalid bit set", client_name);
815 return KRB5KDC_ERR_POLICY;
816 }
817
818 if(!client->flags.client){
819 kdc_log(context, config, 0,
820 "Principal may not act as client -- %s", client_name);
821 return KRB5KDC_ERR_POLICY;
822 }
823
824 if (client->valid_start && *client->valid_start > kdc_time) {
825 char starttime_str[100];
826 krb5_format_time(context, *client->valid_start,
827 starttime_str, sizeof(starttime_str), TRUE);
828 kdc_log(context, config, 0,
829 "Client not yet valid until %s -- %s",
830 starttime_str, client_name);
831 return KRB5KDC_ERR_CLIENT_NOTYET;
832 }
833
834 if (client->valid_end && *client->valid_end < kdc_time) {
835 char endtime_str[100];
836 krb5_format_time(context, *client->valid_end,
837 endtime_str, sizeof(endtime_str), TRUE);
838 kdc_log(context, config, 0,
839 "Client expired at %s -- %s",
840 endtime_str, client_name);
841 return KRB5KDC_ERR_NAME_EXP;
842 }
843
844 if (client->pw_end && *client->pw_end < kdc_time
845 && (server_ex == NULL || !server_ex->entry.flags.change_pw)) {
846 char pwend_str[100];
847 krb5_format_time(context, *client->pw_end,
848 pwend_str, sizeof(pwend_str), TRUE);
849 kdc_log(context, config, 0,
850 "Client's key has expired at %s -- %s",
851 pwend_str, client_name);
852 return KRB5KDC_ERR_KEY_EXPIRED;
853 }
854 }
855
856 /* check server */
857
858 if (server_ex != NULL) {
859 hdb_entry *server = &server_ex->entry;
860
861 if (server->flags.locked_out) {
862 kdc_log(context, config, 0,
863 "Client server locked out -- %s", server_name);
864 return KRB5KDC_ERR_POLICY;
865 }
866 if (server->flags.invalid) {
867 kdc_log(context, config, 0,
868 "Server has invalid flag set -- %s", server_name);
869 return KRB5KDC_ERR_POLICY;
870 }
871
872 if(!server->flags.server){
873 kdc_log(context, config, 0,
874 "Principal may not act as server -- %s", server_name);
875 return KRB5KDC_ERR_POLICY;
876 }
877
878 if(!is_as_req && server->flags.initial) {
879 kdc_log(context, config, 0,
880 "AS-REQ is required for server -- %s", server_name);
881 return KRB5KDC_ERR_POLICY;
882 }
883
884 if (server->valid_start && *server->valid_start > kdc_time) {
885 char starttime_str[100];
886 krb5_format_time(context, *server->valid_start,
887 starttime_str, sizeof(starttime_str), TRUE);
888 kdc_log(context, config, 0,
889 "Server not yet valid until %s -- %s",
890 starttime_str, server_name);
891 return KRB5KDC_ERR_SERVICE_NOTYET;
892 }
893
894 if (server->valid_end && *server->valid_end < kdc_time) {
895 char endtime_str[100];
896 krb5_format_time(context, *server->valid_end,
897 endtime_str, sizeof(endtime_str), TRUE);
898 kdc_log(context, config, 0,
899 "Server expired at %s -- %s",
900 endtime_str, server_name);
901 return KRB5KDC_ERR_SERVICE_EXP;
902 }
903
904 if (server->pw_end && *server->pw_end < kdc_time) {
905 char pwend_str[100];
906 krb5_format_time(context, *server->pw_end,
907 pwend_str, sizeof(pwend_str), TRUE);
908 kdc_log(context, config, 0,
909 "Server's key has expired at -- %s",
910 pwend_str, server_name);
911 return KRB5KDC_ERR_KEY_EXPIRED;
912 }
913 }
914 return 0;
915 }
916
917 /*
918 * Return TRUE if `from' is part of `addresses' taking into consideration
919 * the configuration variables that tells us how strict we should be about
920 * these checks
921 */
922
923 krb5_boolean
924 _kdc_check_addresses(krb5_context context,
925 krb5_kdc_configuration *config,
926 HostAddresses *addresses, const struct sockaddr *from)
927 {
928 krb5_error_code ret;
929 krb5_address addr;
930 krb5_boolean result;
931 krb5_boolean only_netbios = TRUE;
932 size_t i;
933
934 if(config->check_ticket_addresses == 0)
935 return TRUE;
936
937 if(addresses == NULL)
938 return config->allow_null_ticket_addresses;
939
940 for (i = 0; i < addresses->len; ++i) {
941 if (addresses->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
942 only_netbios = FALSE;
943 }
944 }
945
946 /* Windows sends it's netbios name, which I can only assume is
947 * used for the 'allowed workstations' check. This is painful,
948 * but we still want to check IP addresses if they happen to be
949 * present.
950 */
951
952 if(only_netbios)
953 return config->allow_null_ticket_addresses;
954
955 ret = krb5_sockaddr2address (context, from, &addr);
956 if(ret)
957 return FALSE;
958
959 result = krb5_address_search(context, &addr, addresses);
960 krb5_free_address (context, &addr);
961 return result;
962 }
963
964 /*
965 *
966 */
967
968 static krb5_boolean
969 send_pac_p(krb5_context context, KDC_REQ *req)
970 {
971 krb5_error_code ret;
972 PA_PAC_REQUEST pacreq;
973 const PA_DATA *pa;
974 int i = 0;
975
976 pa = _kdc_find_padata(req, &i, KRB5_PADATA_PA_PAC_REQUEST);
977 if (pa == NULL)
978 return TRUE;
979
980 ret = decode_PA_PAC_REQUEST(pa->padata_value.data,
981 pa->padata_value.length,
982 &pacreq,
983 NULL);
984 if (ret)
985 return TRUE;
986 i = pacreq.include_pac;
987 free_PA_PAC_REQUEST(&pacreq);
988 if (i == 0)
989 return FALSE;
990 return TRUE;
991 }
992
993 krb5_boolean
994 _kdc_is_anonymous(krb5_context context, krb5_principal principal)
995 {
996 if (principal->name.name_type != KRB5_NT_WELLKNOWN ||
997 principal->name.name_string.len != 2 ||
998 strcmp(principal->name.name_string.val[0], KRB5_WELLKNOWN_NAME) != 0 ||
999 strcmp(principal->name.name_string.val[1], KRB5_ANON_NAME) != 0)
1000 return 0;
1001 return 1;
1002 }
1003
1004 static krb5_error_code
1005 make_pa_enc_challange(krb5_context context, METHOD_DATA *md,
1006 krb5_crypto crypto)
1007 {
1008 PA_ENC_TS_ENC p;
1009 unsigned char *buf;
1010 size_t buf_size;
1011 size_t len;
1012 EncryptedData encdata;
1013 krb5_error_code ret;
1014 int32_t usec;
1015 int usec2;
1016
1017 krb5_us_timeofday (context, &p.patimestamp, &usec);
1018 usec2 = usec;
1019 p.pausec = &usec2;
1020
1021 ASN1_MALLOC_ENCODE(PA_ENC_TS_ENC, buf, buf_size, &p, &len, ret);
1022 if (ret)
1023 return ret;
1024 if(buf_size != len)
1025 krb5_abortx(context, "internal error in ASN.1 encoder");
1026
1027 ret = krb5_encrypt_EncryptedData(context,
1028 crypto,
1029 KRB5_KU_ENC_CHALLENGE_KDC,
1030 buf,
1031 len,
1032 0,
1033 &encdata);
1034 free(buf);
1035 if (ret)
1036 return ret;
1037
1038 ASN1_MALLOC_ENCODE(EncryptedData, buf, buf_size, &encdata, &len, ret);
1039 free_EncryptedData(&encdata);
1040 if (ret)
1041 return ret;
1042 if(buf_size != len)
1043 krb5_abortx(context, "internal error in ASN.1 encoder");
1044
1045 ret = krb5_padata_add(context, md, KRB5_PADATA_ENCRYPTED_CHALLENGE, buf, len);
1046 if (ret)
1047 free(buf);
1048 return ret;
1049 }
1050
1051
1052 /*
1053 *
1054 */
1055
1056 krb5_error_code
1057 _kdc_as_rep(krb5_context context,
1058 krb5_kdc_configuration *config,
1059 KDC_REQ *req,
1060 const krb5_data *req_buffer,
1061 krb5_data *reply,
1062 const char *from,
1063 struct sockaddr *from_addr,
1064 int datagram_reply)
1065 {
1066 KDC_REQ_BODY *b = NULL;
1067 AS_REP rep;
1068 KDCOptions f;
1069 hdb_entry_ex *client = NULL, *server = NULL, *armor_user = NULL;
1070 HDB *clientdb;
1071 krb5_enctype setype, sessionetype;
1072 EncTicketPart et;
1073 EncKDCRepPart ek;
1074 krb5_principal client_princ = NULL, server_princ = NULL;
1075 char *client_name = NULL, *server_name = NULL;
1076 krb5_error_code ret = 0;
1077 const char *e_text = NULL;
1078 krb5_crypto crypto;
1079 Key *ckey, *skey;
1080 EncryptionKey *reply_key = NULL, session_key;
1081 int flags = 0;
1082 #ifdef PKINIT
1083 pk_client_params *pkp = NULL;
1084 #endif
1085 METHOD_DATA error_method;
1086 krb5_crypto armor_crypto = NULL;
1087
1088 memset(&rep, 0, sizeof(rep));
1089 memset(&et, 0, sizeof(et));
1090 memset(&ek, 0, sizeof(ek));
1091 memset(&session_key, 0, sizeof(session_key));
1092 error_method.len = 0;
1093 error_method.val = NULL;
1094
1095 ALLOC(rep.padata);
1096 rep.padata->len = 0;
1097 rep.padata->val = NULL;
1098
1099 /*
1100 * Look for FAST armor and unwrap
1101 */
1102 {
1103 const PA_DATA *pa;
1104 int i = 0;
1105
1106 pa = _kdc_find_padata(req, &i, KRB5_PADATA_FX_FAST);
1107 if (pa != NULL) {
1108 krb5_crypto crypto_subkey = NULL, crypto_session = NULL;
1109 krb5_data pepper1, pepper2;
1110 PA_FX_FAST_REQUEST fxreq;
1111 krb5_principal armor_server;
1112 krb5_auth_context ac = NULL;
1113 krb5_ticket *ticket = NULL;
1114 krb5_flags ap_req_options;
1115 Key *armor_key = NULL;
1116 krb5_keyblock armorkey;
1117 krb5_ap_req ap_req;
1118 unsigned char *buf;
1119 KrbFastReq fastreq;
1120 size_t len, size;
1121 krb5_data data;
1122
1123
1124 ret = decode_PA_FX_FAST_REQUEST(pa->padata_value.data,
1125 pa->padata_value.length,
1126 &fxreq,
1127 &len);
1128 if (ret)
1129 goto out;
1130 if (len != pa->padata_value.length) {
1131 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1132 goto out;
1133 }
1134
1135 if (fxreq.element != choice_PA_FX_FAST_REQUEST_armored_data) {
1136 kdc_log(context, config, 0,
1137 "AS-REQ FAST contain unknown type");
1138 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1139 goto out;
1140 }
1141
1142 /* pull out armor key */
1143 if (fxreq.u.armored_data.armor == NULL) {
1144 kdc_log(context, config, 0,
1145 "AS-REQ armor missing");
1146 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1147 goto out;
1148 }
1149
1150 if (fxreq.u.armored_data.armor->armor_type != 1) {
1151 kdc_log(context, config, 0,
1152 "AS-REQ armor type not ap-req");
1153 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1154 goto out;
1155 }
1156
1157 ret = krb5_decode_ap_req(context,
1158 &fxreq.u.armored_data.armor->armor_value,
1159 &ap_req);
1160 if(ret) {
1161 kdc_log(context, config, 0, "AP-REQ decode failed");
1162 goto out;
1163 }
1164
1165 /* Save that principal that was in the request */
1166 ret = _krb5_principalname2krb5_principal(context,
1167 &armor_server,
1168 ap_req.ticket.sname,
1169 ap_req.ticket.realm);
1170 if (ret) {
1171 free_AP_REQ(&ap_req);
1172 goto out;
1173 }
1174
1175 ret = _kdc_db_fetch(context, config, armor_server,
1176 HDB_F_GET_SERVER, NULL, NULL, &armor_user);
1177 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1178 kdc_log(context, config, 5,
1179 "armor key does not have secrets at this KDC, "
1180 "need to proxy");
1181 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1182 goto out;
1183 } if(ret){
1184 free_AP_REQ(&ap_req);
1185 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1186 goto out;
1187 }
1188
1189 ret = hdb_enctype2key(context, &armor_user->entry,
1190 ap_req.ticket.enc_part.etype,
1191 &armor_key);
1192 if (ret) {
1193 free_AP_REQ(&ap_req);
1194 goto out;
1195 }
1196
1197 ret = krb5_verify_ap_req2(context, &ac,
1198 &ap_req,
1199 armor_server,
1200 &armor_key->key,
1201 0,
1202 &ap_req_options,
1203 &ticket,
1204 KRB5_KU_AP_REQ_AUTH);
1205 free_AP_REQ(&ap_req);
1206 if (ret)
1207 goto out;
1208
1209 if (ac->remote_subkey == NULL) {
1210 krb5_auth_con_free(context, ac);
1211 kdc_log(context, config, 0,
1212 "FAST AP-REQ remote subkey missing");
1213 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1214 goto out;
1215 }
1216
1217 ret = krb5_crypto_init(context, ac->remote_subkey,
1218 0, &crypto_subkey);
1219 if (ret) {
1220 krb5_auth_con_free(context, ac);
1221 krb5_free_ticket(context, ticket);
1222 goto out;
1223 }
1224 ret = krb5_crypto_init(context, &ticket->ticket.key,
1225 0, &crypto_session);
1226 krb5_free_ticket(context, ticket);
1227 if (ret) {
1228 krb5_auth_con_free(context, ac);
1229 krb5_crypto_destroy(context, crypto_subkey);
1230 goto out;
1231 }
1232
1233 pepper1.data = "subkeyarmor";
1234 pepper1.length = strlen(pepper1.data);
1235 pepper2.data = "ticketarmor";
1236 pepper2.length = strlen(pepper2.data);
1237
1238 ret = krb5_crypto_fx_cf2(context, crypto_subkey, crypto_session,
1239 &pepper1, &pepper2,
1240 ac->remote_subkey->keytype,
1241 &armorkey);
1242 krb5_crypto_destroy(context, crypto_subkey);
1243 krb5_crypto_destroy(context, crypto_session);
1244 krb5_auth_con_free(context, ac);
1245 if (ret)
1246 goto out;
1247
1248 ret = krb5_crypto_init(context, &armorkey, 0, &armor_crypto);
1249 if (ret)
1250 goto out;
1251 krb5_free_keyblock_contents(context, &armorkey);
1252
1253 /* verify req-checksum of the outer body */
1254
1255 ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, len, &req->req_body, &size, ret);
1256 if (ret)
1257 goto out;
1258 if (size != len) {
1259 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1260 goto out;
1261 }
1262
1263 ret = krb5_verify_checksum(context, armor_crypto,
1264 KRB5_KU_FAST_REQ_CHKSUM,
1265 buf, len,
1266 &fxreq.u.armored_data.req_checksum);
1267 free(buf);
1268 if (ret)
1269 goto out;
1270
1271 ret = krb5_decrypt_EncryptedData(context, armor_crypto,
1272 KRB5_KU_FAST_ENC,
1273 &fxreq.u.armored_data.enc_fast_req,
1274 &data);
1275 if (ret)
1276 goto out;
1277
1278 ret = decode_KrbFastReq(data.data, data.length, &fastreq, &size);
1279 if (ret) {
1280 krb5_data_free(&data);
1281 goto out;
1282 }
1283 if (data.length != size) {
1284 krb5_data_free(&data);
1285 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1286 goto out;
1287 }
1288 krb5_data_free(&data);
1289
1290 free_KDC_REQ_BODY(&req->req_body);
1291 ret = copy_KDC_REQ_BODY(&fastreq.req_body, &req->req_body);
1292 if (ret)
1293 goto out;
1294
1295 /* check for unsupported mandatory options */
1296 if (FastOptions2int(fastreq.fast_options) & 0xfffc) {
1297 kdc_log(context, config, 0,
1298 "FAST unsupported mandatory option set");
1299 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1300 goto out;
1301 }
1302
1303 /* KDC MUST ignore outer pa data preauth-14 - 6.5.5 */
1304 free_METHOD_DATA(req->padata);
1305 ret = copy_METHOD_DATA(&fastreq.padata, req->padata);
1306 if (ret)
1307 goto out;
1308
1309 free_KrbFastReq(&fastreq);
1310 free_PA_FX_FAST_REQUEST(&fxreq);
1311 }
1312 }
1313
1314 b = &req->req_body;
1315 f = b->kdc_options;
1316
1317 if (f.canonicalize)
1318 flags |= HDB_F_CANON;
1319
1320 if(b->sname == NULL){
1321 ret = KRB5KRB_ERR_GENERIC;
1322 e_text = "No server in request";
1323 } else{
1324 ret = _krb5_principalname2krb5_principal (context,
1325 &server_princ,
1326 *(b->sname),
1327 b->realm);
1328 if (ret == 0)
1329 ret = krb5_unparse_name(context, server_princ, &server_name);
1330 }
1331 if (ret) {
1332 kdc_log(context, config, 0,
1333 "AS-REQ malformed server name from %s", from);
1334 goto out;
1335 }
1336 if(b->cname == NULL){
1337 ret = KRB5KRB_ERR_GENERIC;
1338 e_text = "No client in request";
1339 } else {
1340 ret = _krb5_principalname2krb5_principal (context,
1341 &client_princ,
1342 *(b->cname),
1343 b->realm);
1344 if (ret)
1345 goto out;
1346
1347 ret = krb5_unparse_name(context, client_princ, &client_name);
1348 }
1349 if (ret) {
1350 kdc_log(context, config, 0,
1351 "AS-REQ malformed client name from %s", from);
1352 goto out;
1353 }
1354
1355 kdc_log(context, config, 0, "AS-REQ %s from %s for %s",
1356 client_name, from, server_name);
1357
1358 /*
1359 *
1360 */
1361
1362 if (_kdc_is_anonymous(context, client_princ)) {
1363 if (!b->kdc_options.request_anonymous) {
1364 kdc_log(context, config, 0, "Anonymous ticket w/o anonymous flag");
1365 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1366 goto out;
1367 }
1368 } else if (b->kdc_options.request_anonymous) {
1369 kdc_log(context, config, 0,
1370 "Request for a anonymous ticket with non "
1371 "anonymous client name: %s", client_name);
1372 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1373 goto out;
1374 }
1375
1376 /*
1377 *
1378 */
1379
1380 ret = _kdc_db_fetch(context, config, client_princ,
1381 HDB_F_GET_CLIENT | flags, NULL,
1382 &clientdb, &client);
1383 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1384 kdc_log(context, config, 5, "client %s does not have secrets at this KDC, need to proxy", client_name);
1385 goto out;
1386 } else if(ret){
1387 const char *msg = krb5_get_error_message(context, ret);
1388 kdc_log(context, config, 0, "UNKNOWN -- %s: %s", client_name, msg);
1389 krb5_free_error_message(context, msg);
1390 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1391 goto out;
1392 }
1393 ret = _kdc_db_fetch(context, config, server_princ,
1394 HDB_F_GET_SERVER|HDB_F_GET_KRBTGT | flags,
1395 NULL, NULL, &server);
1396 if(ret == HDB_ERR_NOT_FOUND_HERE) {
1397 kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", server_name);
1398 goto out;
1399 } else if(ret){
1400 const char *msg = krb5_get_error_message(context, ret);
1401 kdc_log(context, config, 0, "UNKNOWN -- %s: %s", server_name, msg);
1402 krb5_free_error_message(context, msg);
1403 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1404 goto out;
1405 }
1406
1407 memset(&et, 0, sizeof(et));
1408 memset(&ek, 0, sizeof(ek));
1409
1410 /*
1411 * Select a session enctype from the list of the crypto system
1412 * supported enctypes that is supported by the client and is one of
1413 * the enctype of the enctype of the service (likely krbtgt).
1414 *
1415 * The latter is used as a hint of what enctypes all KDC support,
1416 * to make sure a newer version of KDC won't generate a session
1417 * enctype that an older version of a KDC in the same realm can't
1418 * decrypt.
1419 */
1420 ret = _kdc_find_etype(context, config->as_use_strongest_session_key, FALSE,
1421 client, b->etype.val, b->etype.len, &sessionetype,
1422 NULL);
1423 if (ret) {
1424 kdc_log(context, config, 0,
1425 "Client (%s) from %s has no common enctypes with KDC "
1426 "to use for the session key",
1427 client_name, from);
1428 goto out;
1429 }
1430 /*
1431 * But if the KDC admin is paranoid and doesn't want to have "not
1432 * the best" enctypes on the krbtgt, lets save the best pick from
1433 * the client list and hope that that will work for any other
1434 * KDCs.
1435 */
1436
1437 /*
1438 * Pre-auth processing
1439 */
1440
1441 if(req->padata){
1442 int i;
1443 const PA_DATA *pa;
1444 int found_pa = 0;
1445
1446 log_patypes(context, config, req->padata);
1447
1448 kdc_log(context, config, 5,
1449 "Looking for ENCRYPTED-CHALLANGE pa-data -- %s", client_name);
1450
1451 e_text = "No FAST ENCRYPTED CHALLANGE found";
1452
1453 i = 0;
1454 pa = _kdc_find_padata(req, &i, KRB5_PADATA_ENCRYPTED_CHALLENGE);
1455 if (pa && armor_crypto) {
1456 krb5_data ts_data;
1457 struct Key *k;
1458 size_t size;
1459
1460 if (b->kdc_options.request_anonymous) {
1461 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1462 kdc_log(context, config, 0, "ENC-CHALL doesn't support anon");
1463 goto out;
1464 }
1465
1466 EncryptedData enc_data;
1467
1468 ret = decode_EncryptedData(pa->padata_value.data,
1469 pa->padata_value.length,
1470 &enc_data,
1471 &size);
1472 if (ret) {
1473 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1474 kdc_log(context, config, 5, "Failed to decode PA-DATA -- %s",
1475 client_name);
1476 goto out;
1477 }
1478
1479 krb5_data pepper1, pepper2;
1480
1481 pepper1.data = "clientchallengearmor";
1482 pepper1.length = strlen(pepper1.data);
1483 pepper2.data = "challengelongterm";
1484 pepper2.length = strlen(pepper2.data);
1485
1486 krb5_enctype aenctype;
1487 krb5_crypto_getenctype(context, armor_crypto, &aenctype);
1488
1489 for (i = 0; i < client->entry.keys.len; i++) {
1490 krb5_crypto challangecrypto, longtermcrypto;
1491 krb5_keyblock challangekey;
1492 PA_ENC_TS_ENC p;
1493
1494 k = &client->entry.keys.val[i];
1495
1496 ret = krb5_crypto_init(context, &k->key, 0, &longtermcrypto);
1497 if (ret)
1498 continue;
1499
1500 ret = krb5_crypto_fx_cf2(context, armor_crypto, longtermcrypto,
1501 &pepper1, &pepper2, aenctype,
1502 &challangekey);
1503 krb5_crypto_destroy(context, longtermcrypto);
1504 if (ret)
1505 continue;
1506
1507 ret = krb5_crypto_init(context, &challangekey, 0,
1508 &challangecrypto);
1509 if (ret)
1510 continue;
1511
1512 ret = krb5_decrypt_EncryptedData(context, challangecrypto,
1513 KRB5_KU_ENC_CHALLENGE_CLIENT,
1514 &enc_data,
1515 &ts_data);
1516 if (ret)
1517 continue;
1518
1519 ret = decode_PA_ENC_TS_ENC(ts_data.data,
1520 ts_data.length,
1521 &p,
1522 &size);
1523 krb5_data_free(&ts_data);
1524 if(ret){
1525 krb5_crypto_destroy(context, challangecrypto);
1526 e_text = "Failed to decode PA-ENC-TS-ENC";
1527 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1528 kdc_log(context, config,
1529 5, "Failed to decode PA-ENC-TS_ENC -- %s",
1530 client_name);
1531 continue;
1532 }
1533
1534 if (abs(kdc_time - p.patimestamp) > context->max_skew) {
1535 char client_time[100];
1536
1537 krb5_crypto_destroy(context, challangecrypto);
1538
1539 krb5_format_time(context, p.patimestamp,
1540 client_time, sizeof(client_time), TRUE);
1541
1542 ret = KRB5KRB_AP_ERR_SKEW;
1543 kdc_log(context, config, 0,
1544 "Too large time skew, "
1545 "client time %s is out by %u > %u seconds -- %s",
1546 client_time,
1547 (unsigned)abs(kdc_time - p.patimestamp),
1548 context->max_skew,
1549 client_name);
1550
1551 free_PA_ENC_TS_ENC(&p);
1552 goto out;
1553 }
1554
1555 free_PA_ENC_TS_ENC(&p);
1556 et.flags.pre_authent = 1;
1557
1558 ret = make_pa_enc_challange(context, rep.padata,
1559 challangecrypto);
1560 krb5_crypto_destroy(context, challangecrypto);
1561 if (ret)
1562 goto out;
1563
1564 set_salt_padata(rep.padata, k->salt);
1565 reply_key = &k->key;
1566
1567 goto preauth_done;
1568 }
1569 free_EncryptedData(&enc_data);
1570 }
1571
1572 #ifdef PKINIT
1573 kdc_log(context, config, 5,
1574 "Looking for PKINIT pa-data -- %s", client_name);
1575
1576 e_text = "No PKINIT PA found";
1577
1578 i = 0;
1579 pa = _kdc_find_padata(req, &i, KRB5_PADATA_PK_AS_REQ);
1580 if (pa == NULL) {
1581 i = 0;
1582 pa = _kdc_find_padata(req, &i, KRB5_PADATA_PK_AS_REQ_WIN);
1583 }
1584 if (pa) {
1585 char *client_cert = NULL;
1586
1587 ret = _kdc_pk_rd_padata(context, config, req, pa, client, &pkp);
1588 if (ret) {
1589 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1590 kdc_log(context, config, 5,
1591 "Failed to decode PKINIT PA-DATA -- %s",
1592 client_name);
1593 goto ts_enc;
1594 }
1595 if (ret == 0 && pkp == NULL)
1596 goto ts_enc;
1597
1598 ret = _kdc_pk_check_client(context,
1599 config,
1600 clientdb,
1601 client,
1602 pkp,
1603 &client_cert);
1604 if (ret) {
1605 e_text = "PKINIT certificate not allowed to "
1606 "impersonate principal";
1607 _kdc_pk_free_client_param(context, pkp);
1608
1609 kdc_log(context, config, 0, "%s", e_text);
1610 pkp = NULL;
1611 goto out;
1612 }
1613
1614 found_pa = 1;
1615 et.flags.pre_authent = 1;
1616 kdc_log(context, config, 0,
1617 "PKINIT pre-authentication succeeded -- %s using %s",
1618 client_name, client_cert);
1619 free(client_cert);
1620 if (pkp)
1621 goto preauth_done;
1622 }
1623 ts_enc:
1624 #endif
1625 kdc_log(context, config, 5, "Looking for ENC-TS pa-data -- %s",
1626 client_name);
1627
1628 i = 0;
1629 e_text = "No ENC-TS found";
1630 while((pa = _kdc_find_padata(req, &i, KRB5_PADATA_ENC_TIMESTAMP))){
1631 krb5_data ts_data;
1632 PA_ENC_TS_ENC p;
1633 size_t len;
1634 EncryptedData enc_data;
1635 Key *pa_key;
1636 char *str;
1637
1638 found_pa = 1;
1639
1640 if (b->kdc_options.request_anonymous) {
1641 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1642 kdc_log(context, config, 0, "ENC-TS doesn't support anon");
1643 goto out;
1644 }
1645
1646 ret = decode_EncryptedData(pa->padata_value.data,
1647 pa->padata_value.length,
1648 &enc_data,
1649 &len);
1650 if (ret) {
1651 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
1652 kdc_log(context, config, 5, "Failed to decode PA-DATA -- %s",
1653 client_name);
1654 goto out;
1655 }
1656
1657 ret = hdb_enctype2key(context, &client->entry,
1658 enc_data.etype, &pa_key);
1659 if(ret){
1660 char *estr;
1661 e_text = "No key matches pa-data";
1662 ret = KRB5KDC_ERR_ETYPE_NOSUPP;
1663 if(krb5_enctype_to_string(context, enc_data.etype, &estr))
1664 estr = NULL;
1665 if(estr == NULL)
1666 kdc_log(context, config, 5,
1667 "No client key matching pa-data (%d) -- %s",
1668 enc_data.etype, client_name);
1669 else
1670 kdc_log(context, config, 5,
1671 "No client key matching pa-data (%s) -- %s",
1672 estr, client_name);
1673 free(estr);
1674 free_EncryptedData(&enc_data);
1675
1676 continue;
1677 }
1678
1679 try_next_key:
1680 ret = krb5_crypto_init(context, &pa_key->key, 0, &crypto);
1681 if (ret) {
1682 const char *msg = krb5_get_error_message(context, ret);
1683 kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
1684 krb5_free_error_message(context, msg);
1685 free_EncryptedData(&enc_data);
1686 continue;
1687 }
1688
1689 ret = krb5_decrypt_EncryptedData (context,
1690 crypto,
1691 KRB5_KU_PA_ENC_TIMESTAMP,
1692 &enc_data,
1693 &ts_data);
1694 krb5_crypto_destroy(context, crypto);
1695 /*
1696 * Since the user might have several keys with the same
1697 * enctype but with diffrent salting, we need to try all
1698 * the keys with the same enctype.
1699 */
1700 if(ret){
1701 krb5_error_code ret2;
1702 const char *msg = krb5_get_error_message(context, ret);
1703
1704 ret2 = krb5_enctype_to_string(context,
1705 pa_key->key.keytype, &str);
1706 if (ret2)
1707 str = NULL;
1708 kdc_log(context, config, 5,
1709 "Failed to decrypt PA-DATA -- %s "
1710 "(enctype %s) error %s",
1711 client_name, str ? str : "unknown enctype", msg);
1712 krb5_free_error_message(context, msg);
1713 free(str);
1714
1715 if(hdb_next_enctype2key(context, &client->entry,
1716 enc_data.etype, &pa_key) == 0)
1717 goto try_next_key;
1718 e_text = "Failed to decrypt PA-DATA";
1719
1720 free_EncryptedData(&enc_data);
1721
1722 if (clientdb->hdb_auth_status)
1723 (clientdb->hdb_auth_status)(context, clientdb, client, HDB_AUTH_WRONG_PASSWORD);
1724
1725 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1726 continue;
1727 }
1728 free_EncryptedData(&enc_data);
1729 ret = decode_PA_ENC_TS_ENC(ts_data.data,
1730 ts_data.length,
1731 &p,
1732 &len);
1733 krb5_data_free(&ts_data);
1734 if(ret){
1735 e_text = "Failed to decode PA-ENC-TS-ENC";
1736 ret = KRB5KDC_ERR_PREAUTH_FAILED;
1737 kdc_log(context, config,
1738 5, "Failed to decode PA-ENC-TS_ENC -- %s",
1739 client_name);
1740 continue;
1741 }
1742 if (abs(kdc_time - p.patimestamp) > context->max_skew) {
1743 char client_time[100];
1744
1745 krb5_format_time(context, p.patimestamp,
1746 client_time, sizeof(client_time), TRUE);
1747
1748 ret = KRB5KRB_AP_ERR_SKEW;
1749 kdc_log(context, config, 0,
1750 "Too large time skew, "
1751 "client time %s is out by %u > %u seconds -- %s",
1752 client_time,
1753 (unsigned)abs(kdc_time - p.patimestamp),
1754 context->max_skew,
1755 client_name);
1756
1757 /*
1758 * The following is needed to make windows clients to
1759 * retry using the timestamp in the error message, if
1760 * there is a e_text, they become unhappy.
1761 */
1762 e_text = NULL;
1763 free_PA_ENC_TS_ENC(&p);
1764 goto out;
1765 }
1766 free_PA_ENC_TS_ENC(&p);
1767 et.flags.pre_authent = 1;
1768
1769 set_salt_padata(rep.padata, pa_key->salt);
1770
1771 reply_key = &pa_key->key;
1772
1773 ret = krb5_enctype_to_string(context, pa_key->key.keytype, &str);
1774 if (ret)
1775 str = NULL;
1776
1777 kdc_log(context, config, 2,
1778 "ENC-TS Pre-authentication succeeded -- %s using %s",
1779 client_name, str ? str : "unknown enctype");
1780 free(str);
1781 break;
1782 }
1783 #ifdef PKINIT
1784 preauth_done:
1785 #endif
1786 if(found_pa == 0 && config->require_preauth)
1787 goto use_pa;
1788 /* We come here if we found a pa-enc-timestamp, but if there
1789 was some problem with it, other than too large skew */
1790 if(found_pa && et.flags.pre_authent == 0){
1791 kdc_log(context, config, 0, "%s -- %s", e_text, client_name);
1792 e_text = NULL;
1793 goto out;
1794 }
1795 }else if (config->require_preauth
1796 || b->kdc_options.request_anonymous /* hack to force anon */
1797 || client->entry.flags.require_preauth
1798 || server->entry.flags.require_preauth) {
1799 PA_DATA *pa;
1800
1801 use_pa:
1802
1803 ret = realloc_method_data(&error_method);
1804 if (ret)
1805 goto out;
1806 pa = &error_method.val[error_method.len-1];
1807 pa->padata_type = KRB5_PADATA_ENC_TIMESTAMP;
1808 pa->padata_value.length = 0;
1809 pa->padata_value.data = NULL;
1810
1811 #ifdef PKINIT
1812 ret = realloc_method_data(&error_method);
1813 if (ret)
1814 goto out;
1815 pa = &error_method.val[error_method.len-1];
1816 pa->padata_type = KRB5_PADATA_PK_AS_REQ;
1817 pa->padata_value.length = 0;
1818 pa->padata_value.data = NULL;
1819
1820 ret = realloc_method_data(&error_method);
1821 if (ret)
1822 goto out;
1823 pa = &error_method.val[error_method.len-1];
1824 pa->padata_type = KRB5_PADATA_PK_AS_REQ_WIN;
1825 pa->padata_value.length = 0;
1826 pa->padata_value.data = NULL;
1827 #endif
1828 /*
1829 * Announce FX-FAST
1830 */
1831 ret = krb5_padata_add(context, &error_method,
1832 KRB5_PADATA_FX_FAST, NULL, 0);
1833 if (ret)
1834 goto out;
1835
1836 /*
1837 * If there is a client key, send ETYPE_INFO{,2}
1838 */
1839 ret = _kdc_find_etype(context,
1840 config->preauth_use_strongest_session_key, TRUE,
1841 client, b->etype.val, b->etype.len, NULL, &ckey);
1842 if (ret == 0) {
1843
1844 /*
1845 * RFC4120 requires:
1846 * - If the client only knows about old enctypes, then send
1847 * both info replies (we send 'info' first in the list).
1848 * - If the client is 'modern', because it knows about 'new'
1849 * enctype types, then only send the 'info2' reply.
1850 *
1851 * Before we send the full list of etype-info data, we pick
1852 * the client key we would have used anyway below, just pick
1853 * that instead.
1854 */
1855
1856 if (older_enctype(ckey->key.keytype)) {
1857 ret = get_pa_etype_info(context, config,
1858 &error_method, ckey);
1859 if (ret)
1860 goto out;
1861 }
1862 ret = get_pa_etype_info2(context, config,
1863 &error_method, ckey);
1864 if (ret)
1865 goto out;
1866 }
1867
1868 ret = KRB5KDC_ERR_PREAUTH_REQUIRED;
1869 e_text ="Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ",
1870
1871 kdc_log(context, config, 0,
1872 "No preauth found, returning PREAUTH-REQUIRED -- %s",
1873 client_name);
1874 goto out;
1875 }
1876
1877 if (clientdb->hdb_auth_status)
1878 (clientdb->hdb_auth_status)(context, clientdb, client,
1879 HDB_AUTH_SUCCESS);
1880
1881 /*
1882 * Verify flags after the user been required to prove its identity
1883 * with in a preauth mech.
1884 */
1885
1886 ret = _kdc_check_access(context, config, client, client_name,
1887 server, server_name,
1888 req, &error_method);
1889 if(ret)
1890 goto out;
1891
1892 /*
1893 * Selelct the best encryption type for the KDC with out regard to
1894 * the client since the client never needs to read that data.
1895 */
1896
1897 ret = _kdc_get_preferred_key(context, config,
1898 server, server_name,
1899 &setype, &skey);
1900 if(ret)
1901 goto out;
1902
1903 if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey
1904 || (f.request_anonymous && !config->allow_anonymous)) {
1905 ret = KRB5KDC_ERR_BADOPTION;
1906 e_text = "Bad KDC options";
1907 kdc_log(context, config, 0, "Bad KDC options -- %s", client_name);
1908 goto out;
1909 }
1910
1911 rep.pvno = 5;
1912 rep.msg_type = krb_as_rep;
1913
1914 ret = copy_Realm(&client->entry.principal->realm, &rep.crealm);
1915 if (ret)
1916 goto out;
1917 ret = _krb5_principal2principalname(&rep.cname, client->entry.principal);
1918 if (ret)
1919 goto out;
1920
1921 rep.ticket.tkt_vno = 5;
1922 copy_Realm(&server->entry.principal->realm, &rep.ticket.realm);
1923 _krb5_principal2principalname(&rep.ticket.sname,
1924 server->entry.principal);
1925 /* java 1.6 expects the name to be the same type, lets allow that
1926 * uncomplicated name-types. */
1927 #define CNT(sp,t) (((sp)->sname->name_type) == KRB5_NT_##t)
1928 if (CNT(b, UNKNOWN) || CNT(b, PRINCIPAL) || CNT(b, SRV_INST) || CNT(b, SRV_HST) || CNT(b, SRV_XHST))
1929 rep.ticket.sname.name_type = b->sname->name_type;
1930 #undef CNT
1931
1932 et.flags.initial = 1;
1933 if(client->entry.flags.forwardable && server->entry.flags.forwardable)
1934 et.flags.forwardable = f.forwardable;
1935 else if (f.forwardable) {
1936 e_text = "Ticket may not be forwardable";
1937 ret = KRB5KDC_ERR_POLICY;
1938 kdc_log(context, config, 0,
1939 "Ticket may not be forwardable -- %s", client_name);
1940 goto out;
1941 }
1942 if(client->entry.flags.proxiable && server->entry.flags.proxiable)
1943 et.flags.proxiable = f.proxiable;
1944 else if (f.proxiable) {
1945 e_text = "Ticket may not be proxiable";
1946 ret = KRB5KDC_ERR_POLICY;
1947 kdc_log(context, config, 0,
1948 "Ticket may not be proxiable -- %s", client_name);
1949 goto out;
1950 }
1951 if(client->entry.flags.postdate && server->entry.flags.postdate)
1952 et.flags.may_postdate = f.allow_postdate;
1953 else if (f.allow_postdate){
1954 e_text = "Ticket may not be postdate";
1955 ret = KRB5KDC_ERR_POLICY;
1956 kdc_log(context, config, 0,
1957 "Ticket may not be postdatable -- %s", client_name);
1958 goto out;
1959 }
1960
1961 /* check for valid set of addresses */
1962 if(!_kdc_check_addresses(context, config, b->addresses, from_addr)) {
1963 e_text = "Bad address list in requested";
1964 ret = KRB5KRB_AP_ERR_BADADDR;
1965 kdc_log(context, config, 0,
1966 "Bad address list requested -- %s", client_name);
1967 goto out;
1968 }
1969
1970 ret = copy_PrincipalName(&rep.cname, &et.cname);
1971 if (ret)
1972 goto out;
1973 ret = copy_Realm(&rep.crealm, &et.crealm);
1974 if (ret)
1975 goto out;
1976
1977 {
1978 time_t start;
1979 time_t t;
1980
1981 start = et.authtime = kdc_time;
1982
1983 if(f.postdated && req->req_body.from){
1984 ALLOC(et.starttime);
1985 start = *et.starttime = *req->req_body.from;
1986 et.flags.invalid = 1;
1987 et.flags.postdated = 1; /* XXX ??? */
1988 }
1989 _kdc_fix_time(&b->till);
1990 t = *b->till;
1991
1992 /* be careful not overflowing */
1993
1994 if(client->entry.max_life)
1995 t = start + min(t - start, *client->entry.max_life);
1996 if(server->entry.max_life)
1997 t = start + min(t - start, *server->entry.max_life);
1998 #if 0
1999 t = min(t, start + realm->max_life);
2000 #endif
2001 et.endtime = t;
2002 if(f.renewable_ok && et.endtime < *b->till){
2003 f.renewable = 1;
2004 if(b->rtime == NULL){
2005 ALLOC(b->rtime);
2006 *b->rtime = 0;
2007 }
2008 if(*b->rtime < *b->till)
2009 *b->rtime = *b->till;
2010 }
2011 if(f.renewable && b->rtime){
2012 t = *b->rtime;
2013 if(t == 0)
2014 t = MAX_TIME;
2015 if(client->entry.max_renew)
2016 t = start + min(t - start, *client->entry.max_renew);
2017 if(server->entry.max_renew)
2018 t = start + min(t - start, *server->entry.max_renew);
2019 #if 0
2020 t = min(t, start + realm->max_renew);
2021 #endif
2022 ALLOC(et.renew_till);
2023 *et.renew_till = t;
2024 et.flags.renewable = 1;
2025 }
2026 }
2027
2028 if (f.request_anonymous)
2029 et.flags.anonymous = 1;
2030
2031 if(b->addresses){
2032 ALLOC(et.caddr);
2033 copy_HostAddresses(b->addresses, et.caddr);
2034 }
2035
2036 et.transited.tr_type = DOMAIN_X500_COMPRESS;
2037 krb5_data_zero(&et.transited.contents);
2038
2039 /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
2040 * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
2041 * incapable of correctly decoding SEQUENCE OF's of zero length.
2042 *
2043 * To fix this, always send at least one no-op last_req
2044 *
2045 * If there's a pw_end or valid_end we will use that,
2046 * otherwise just a dummy lr.
2047 */
2048 ek.last_req.val = malloc(2 * sizeof(*ek.last_req.val));
2049 if (ek.last_req.val == NULL) {
2050 ret = ENOMEM;
2051 goto out;
2052 }
2053 ek.last_req.len = 0;
2054 if (client->entry.pw_end
2055 && (config->kdc_warn_pwexpire == 0
2056 || kdc_time + config->kdc_warn_pwexpire >= *client->entry.pw_end)) {
2057 ek.last_req.val[ek.last_req.len].lr_type = LR_PW_EXPTIME;
2058 ek.last_req.val[ek.last_req.len].lr_value = *client->entry.pw_end;
2059 ++ek.last_req.len;
2060 }
2061 if (client->entry.valid_end) {
2062 ek.last_req.val[ek.last_req.len].lr_type = LR_ACCT_EXPTIME;
2063 ek.last_req.val[ek.last_req.len].lr_value = *client->entry.valid_end;
2064 ++ek.last_req.len;
2065 }
2066 if (ek.last_req.len == 0) {
2067 ek.last_req.val[ek.last_req.len].lr_type = LR_NONE;
2068 ek.last_req.val[ek.last_req.len].lr_value = 0;
2069 ++ek.last_req.len;
2070 }
2071 ek.nonce = b->nonce;
2072 if (client->entry.valid_end || client->entry.pw_end) {
2073 ALLOC(ek.key_expiration);
2074 if (client->entry.valid_end) {
2075 if (client->entry.pw_end)
2076 *ek.key_expiration = min(*client->entry.valid_end,
2077 *client->entry.pw_end);
2078 else
2079 *ek.key_expiration = *client->entry.valid_end;
2080 } else
2081 *ek.key_expiration = *client->entry.pw_end;
2082 } else
2083 ek.key_expiration = NULL;
2084 ek.flags = et.flags;
2085 ek.authtime = et.authtime;
2086 if (et.starttime) {
2087 ALLOC(ek.starttime);
2088 *ek.starttime = *et.starttime;
2089 }
2090 ek.endtime = et.endtime;
2091 if (et.renew_till) {
2092 ALLOC(ek.renew_till);
2093 *ek.renew_till = *et.renew_till;
2094 }
2095 copy_Realm(&rep.ticket.realm, &ek.srealm);
2096 copy_PrincipalName(&rep.ticket.sname, &ek.sname);
2097 if(et.caddr){
2098 ALLOC(ek.caddr);
2099 copy_HostAddresses(et.caddr, ek.caddr);
2100 }
2101
2102 #if PKINIT
2103 if (pkp) {
2104 e_text = "Failed to build PK-INIT reply";
2105 ret = _kdc_pk_mk_pa_reply(context, config, pkp, client,
2106 sessionetype, req, req_buffer,
2107 &reply_key, &et.key, rep.padata);
2108 if (ret)
2109 goto out;
2110 ret = _kdc_add_inital_verified_cas(context,
2111 config,
2112 pkp,
2113 &et);
2114 if (ret)
2115 goto out;
2116
2117 } else
2118 #endif
2119 {
2120 ret = krb5_generate_random_keyblock(context, sessionetype, &et.key);
2121 if (ret)
2122 goto out;
2123 }
2124
2125 if (reply_key == NULL) {
2126 e_text = "Client have no reply key";
2127 ret = KRB5KDC_ERR_CLIENT_NOTYET;
2128 goto out;
2129 }
2130
2131 ret = copy_EncryptionKey(&et.key, &ek.key);
2132 if (ret)
2133 goto out;
2134
2135 /* Add signing of alias referral */
2136 if (f.canonicalize) {
2137 PA_ClientCanonicalized canon;
2138 krb5_data data;
2139 PA_DATA pa;
2140 krb5_crypto cryptox;
2141 size_t len = 0;
2142
2143 memset(&canon, 0, sizeof(canon));
2144
2145 canon.names.requested_name = *b->cname;
2146 canon.names.mapped_name = client->entry.principal->name;
2147
2148 ASN1_MALLOC_ENCODE(PA_ClientCanonicalizedNames, data.data, data.length,
2149 &canon.names, &len, ret);
2150 if (ret)
2151 goto out;
2152 if (data.length != len)
2153 krb5_abortx(context, "internal asn.1 error");
2154
2155 /* sign using "returned session key" */
2156 ret = krb5_crypto_init(context, &et.key, 0, &cryptox);
2157 if (ret) {
2158 free(data.data);
2159 goto out;
2160 }
2161
2162 ret = krb5_create_checksum(context, cryptox,
2163 KRB5_KU_CANONICALIZED_NAMES, 0,
2164 data.data, data.length,
2165 &canon.canon_checksum);
2166 free(data.data);
2167 krb5_crypto_destroy(context, cryptox);
2168 if (ret)
2169 goto out;
2170
2171 ASN1_MALLOC_ENCODE(PA_ClientCanonicalized, data.data, data.length,
2172 &canon, &len, ret);
2173 free_Checksum(&canon.canon_checksum);
2174 if (ret)
2175 goto out;
2176 if (data.length != len)
2177 krb5_abortx(context, "internal asn.1 error");
2178
2179 pa.padata_type = KRB5_PADATA_CLIENT_CANONICALIZED;
2180 pa.padata_value = data;
2181 ret = add_METHOD_DATA(rep.padata, &pa);
2182 free(data.data);
2183 if (ret)
2184 goto out;
2185 }
2186
2187 if (rep.padata->len == 0) {
2188 free(rep.padata);
2189 rep.padata = NULL;
2190 }
2191
2192 /* Add the PAC */
2193 if (send_pac_p(context, req)) {
2194 krb5_pac p = NULL;
2195 krb5_data data;
2196
2197 ret = _kdc_pac_generate(context, client, &p);
2198 if (ret) {
2199 kdc_log(context, config, 0, "PAC generation failed for -- %s",
2200 client_name);
2201 goto out;
2202 }
2203 if (p != NULL) {
2204 ret = _krb5_pac_sign(context, p, et.authtime,
2205 client->entry.principal,
2206 &skey->key, /* Server key */
2207 &skey->key, /* FIXME: should be krbtgt key */
2208 &data);
2209 krb5_pac_free(context, p);
2210 if (ret) {
2211 kdc_log(context, config, 0, "PAC signing failed for -- %s",
2212 client_name);
2213 goto out;
2214 }
2215
2216 ret = _kdc_tkt_add_if_relevant_ad(context, &et,
2217 KRB5_AUTHDATA_WIN2K_PAC,
2218 &data);
2219 krb5_data_free(&data);
2220 if (ret)
2221 goto out;
2222 }
2223 }
2224
2225 _kdc_log_timestamp(context, config, "AS-REQ", et.authtime, et.starttime,
2226 et.endtime, et.renew_till);
2227
2228 /* do this as the last thing since this signs the EncTicketPart */
2229 ret = _kdc_add_KRB5SignedPath(context,
2230 config,
2231 server,
2232 setype,
2233 client->entry.principal,
2234 NULL,
2235 NULL,
2236 &et);
2237 if (ret)
2238 goto out;
2239
2240 log_as_req(context, config, reply_key->keytype, setype, b);
2241
2242 ret = _kdc_encode_reply(context, config, armor_crypto, req->req_body.nonce,
2243 &rep, &et, &ek, setype, server->entry.kvno,
2244 &skey->key, client->entry.kvno,
2245 reply_key, 0, &e_text, reply);
2246 if (ret)
2247 goto out;
2248
2249 /* */
2250 if (datagram_reply && reply->length > config->max_datagram_reply_length) {
2251 krb5_data_free(reply);
2252 ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2253 e_text = "Reply packet too large";
2254 }
2255
2256 out:
2257 free_AS_REP(&rep);
2258
2259 /*
2260 * In case of a non proxy error, build an error message.
2261 */
2262 if(ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE){
2263 kdc_log(context, config, 10, "as-req: sending error: %d to client", ret);
2264 ret = _kdc_fast_mk_error(context,
2265 &error_method,
2266 armor_crypto,
2267 &req->req_body,
2268 ret, e_text,
2269 client_princ, server_princ,
2270 NULL, NULL,
2271 reply);
2272 if (ret)
2273 goto out2;
2274 }
2275 out2:
2276 #ifdef PKINIT
2277 if (pkp)
2278 _kdc_pk_free_client_param(context, pkp);
2279 #endif
2280 free_EncTicketPart(&et);
2281 free_EncKDCRepPart(&ek);
2282
2283 if (error_method.len)
2284 free_METHOD_DATA(&error_method);
2285 if (client_princ)
2286 krb5_free_principal(context, client_princ);
2287 free(client_name);
2288 if (server_princ)
2289 krb5_free_principal(context, server_princ);
2290 free(server_name);
2291 if(client)
2292 _kdc_free_ent(context, client);
2293 if(server)
2294 _kdc_free_ent(context, server);
2295 if(armor_user)
2296 _kdc_free_ent(context, armor_user);
2297 if (armor_crypto)
2298 krb5_crypto_destroy(context, armor_crypto);
2299 return ret;
2300 }
2301
2302 /*
2303 * Add the AuthorizationData `data´ of `type´ to the last element in
2304 * the sequence of authorization_data in `tkt´ wrapped in an IF_RELEVANT
2305 */
2306
2307 krb5_error_code
2308 _kdc_tkt_add_if_relevant_ad(krb5_context context,
2309 EncTicketPart *tkt,
2310 int type,
2311 const krb5_data *data)
2312 {
2313 krb5_error_code ret;
2314 size_t size = 0;
2315
2316 if (tkt->authorization_data == NULL) {
2317 tkt->authorization_data = calloc(1, sizeof(*tkt->authorization_data));
2318 if (tkt->authorization_data == NULL) {
2319 krb5_set_error_message(context, ENOMEM, "out of memory");
2320 return ENOMEM;
2321 }
2322 }
2323
2324 /* add the entry to the last element */
2325 {
2326 AuthorizationData ad = { 0, NULL };
2327 AuthorizationDataElement ade;
2328
2329 ade.ad_type = type;
2330 ade.ad_data = *data;
2331
2332 ret = add_AuthorizationData(&ad, &ade);
2333 if (ret) {
2334 krb5_set_error_message(context, ret, "add AuthorizationData failed");
2335 return ret;
2336 }
2337
2338 ade.ad_type = KRB5_AUTHDATA_IF_RELEVANT;
2339
2340 ASN1_MALLOC_ENCODE(AuthorizationData,
2341 ade.ad_data.data, ade.ad_data.length,
2342 &ad, &size, ret);
2343 free_AuthorizationData(&ad);
2344 if (ret) {
2345 krb5_set_error_message(context, ret, "ASN.1 encode of "
2346 "AuthorizationData failed");
2347 return ret;
2348 }
2349 if (ade.ad_data.length != size)
2350 krb5_abortx(context, "internal asn.1 encoder error");
2351
2352 ret = add_AuthorizationData(tkt->authorization_data, &ade);
2353 der_free_octet_string(&ade.ad_data);
2354 if (ret) {
2355 krb5_set_error_message(context, ret, "add AuthorizationData failed");
2356 return ret;
2357 }
2358 }
2359
2360 return 0;
2361 }
Heimdal