source: trunk/server/source4/heimdal/kdc/kerberos5.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

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