?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This commit was manufactured by cvs2svn to create tag
[heimdal.git] / kdc / kerberos5.c
blob4a475b4c74999cf1920288eaaf6d4ab0d265371a
1 /*
2 * Copyright (c) 1997-2003 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 RCSID("$Id$");
37
38 #define MAX_TIME ((time_t)((1U << 31) - 1))
39
40 static void
41 fix_time(time_t **t)
42 {
43 if(*t == NULL){
44 ALLOC(*t);
45 **t = MAX_TIME;
46 }
47 if(**t == 0) **t = MAX_TIME; /* fix for old clients */
48 }
49
50 static void
51 set_salt_padata (METHOD_DATA **m, Salt *salt)
52 {
53 if (salt) {
54 ALLOC(*m);
55 (*m)->len = 1;
56 ALLOC((*m)->val);
57 (*m)->val->padata_type = salt->type;
58 copy_octet_string(&salt->salt,
59 &(*m)->val->padata_value);
60 }
61 }
62
63 static PA_DATA*
64 find_padata(KDC_REQ *req, int *start, int type)
65 {
66 while(*start < req->padata->len){
67 (*start)++;
68 if(req->padata->val[*start - 1].padata_type == type)
69 return &req->padata->val[*start - 1];
70 }
71 return NULL;
72 }
73
74 /*
75 * return the first appropriate key of `princ' in `ret_key'. Look for
76 * all the etypes in (`etypes', `len'), stopping as soon as we find
77 * one, but preferring one that has default salt
78 */
79
80 static krb5_error_code
81 find_etype(hdb_entry *princ, krb5_enctype *etypes, unsigned len,
82 Key **ret_key, krb5_enctype *ret_etype)
83 {
84 int i;
85 krb5_error_code ret = KRB5KDC_ERR_ETYPE_NOSUPP;
86
87 for(i = 0; ret != 0 && i < len ; i++) {
88 Key *key = NULL;
89
90 while (hdb_next_enctype2key(context, princ, etypes[i], &key) == 0) {
91 if (key->key.keyvalue.length == 0) {
92 ret = KRB5KDC_ERR_NULL_KEY;
93 continue;
94 }
95 *ret_key = key;
96 *ret_etype = etypes[i];
97 ret = 0;
98 if (key->salt == NULL)
99 return ret;
100 }
101 }
102 return ret;
103 }
104
105 static krb5_error_code
106 find_keys(hdb_entry *client,
107 hdb_entry *server,
108 Key **ckey,
109 krb5_enctype *cetype,
110 Key **skey,
111 krb5_enctype *setype,
112 krb5_enctype *etypes,
113 unsigned num_etypes)
114 {
115 krb5_error_code ret;
116
117 if(client){
118 /* find client key */
119 ret = find_etype(client, etypes, num_etypes, ckey, cetype);
120 if (ret) {
121 kdc_log(0, "Client has no support for etypes");
122 return ret;
123 }
124 }
125
126 if(server){
127 /* find server key */
128 ret = find_etype(server, etypes, num_etypes, skey, setype);
129 if (ret) {
130 kdc_log(0, "Server has no support for etypes");
131 return ret;
132 }
133 }
134 return 0;
135 }
136
137 static krb5_error_code
138 make_anonymous_principalname (PrincipalName *pn)
139 {
140 pn->name_type = KRB5_NT_PRINCIPAL;
141 pn->name_string.len = 1;
142 pn->name_string.val = malloc(sizeof(*pn->name_string.val));
143 if (pn->name_string.val == NULL)
144 return ENOMEM;
145 pn->name_string.val[0] = strdup("anonymous");
146 if (pn->name_string.val[0] == NULL) {
147 free(pn->name_string.val);
148 pn->name_string.val = NULL;
149 return ENOMEM;
150 }
151 return 0;
152 }
153
154 static krb5_error_code
155 encode_reply(KDC_REP *rep, EncTicketPart *et, EncKDCRepPart *ek,
156 krb5_enctype etype,
157 int skvno, EncryptionKey *skey,
158 int ckvno, EncryptionKey *ckey,
159 const char **e_text,
160 krb5_data *reply)
161 {
162 unsigned char *buf;
163 size_t buf_size;
164 size_t len;
165 krb5_error_code ret;
166 krb5_crypto crypto;
167
168 ASN1_MALLOC_ENCODE(EncTicketPart, buf, buf_size, et, &len, ret);
169 if(ret) {
170 kdc_log(0, "Failed to encode ticket: %s",
171 krb5_get_err_text(context, ret));
172 return ret;
173 }
174 if(buf_size != len) {
175 free(buf);
176 kdc_log(0, "Internal error in ASN.1 encoder");
177 *e_text = "KDC internal error";
178 return KRB5KRB_ERR_GENERIC;
179 }
180
181 ret = krb5_crypto_init(context, skey, etype, &crypto);
182 if (ret) {
183 free(buf);
184 kdc_log(0, "krb5_crypto_init failed: %s",
185 krb5_get_err_text(context, ret));
186 return ret;
187 }
188
189 ret = krb5_encrypt_EncryptedData(context,
190 crypto,
191 KRB5_KU_TICKET,
192 buf,
193 len,
194 skvno,
195 &rep->ticket.enc_part);
196 free(buf);
197 krb5_crypto_destroy(context, crypto);
198 if(ret) {
199 kdc_log(0, "Failed to encrypt data: %s",
200 krb5_get_err_text(context, ret));
201 return ret;
202 }
203
204 if(rep->msg_type == krb_as_rep && !encode_as_rep_as_tgs_rep)
205 ASN1_MALLOC_ENCODE(EncASRepPart, buf, buf_size, ek, &len, ret);
206 else
207 ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
208 if(ret) {
209 kdc_log(0, "Failed to encode KDC-REP: %s",
210 krb5_get_err_text(context, ret));
211 return ret;
212 }
213 if(buf_size != len) {
214 free(buf);
215 kdc_log(0, "Internal error in ASN.1 encoder");
216 *e_text = "KDC internal error";
217 return KRB5KRB_ERR_GENERIC;
218 }
219 ret = krb5_crypto_init(context, ckey, 0, &crypto);
220 if (ret) {
221 free(buf);
222 kdc_log(0, "krb5_crypto_init failed: %s",
223 krb5_get_err_text(context, ret));
224 return ret;
225 }
226 if(rep->msg_type == krb_as_rep) {
227 krb5_encrypt_EncryptedData(context,
228 crypto,
229 KRB5_KU_AS_REP_ENC_PART,
230 buf,
231 len,
232 ckvno,
233 &rep->enc_part);
234 free(buf);
235 ASN1_MALLOC_ENCODE(AS_REP, buf, buf_size, rep, &len, ret);
236 } else {
237 krb5_encrypt_EncryptedData(context,
238 crypto,
239 KRB5_KU_TGS_REP_ENC_PART_SESSION,
240 buf,
241 len,
242 ckvno,
243 &rep->enc_part);
244 free(buf);
245 ASN1_MALLOC_ENCODE(TGS_REP, buf, buf_size, rep, &len, ret);
246 }
247 krb5_crypto_destroy(context, crypto);
248 if(ret) {
249 kdc_log(0, "Failed to encode KDC-REP: %s",
250 krb5_get_err_text(context, ret));
251 return ret;
252 }
253 if(buf_size != len) {
254 free(buf);
255 kdc_log(0, "Internal error in ASN.1 encoder");
256 *e_text = "KDC internal error";
257 return KRB5KRB_ERR_GENERIC;
258 }
259 reply->data = buf;
260 reply->length = buf_size;
261 return 0;
262 }
263
264 static int
265 realloc_method_data(METHOD_DATA *md)
266 {
267 PA_DATA *pa;
268 pa = realloc(md->val, (md->len + 1) * sizeof(*md->val));
269 if(pa == NULL)
270 return ENOMEM;
271 md->val = pa;
272 md->len++;
273 return 0;
274 }
275
276 static krb5_error_code
277 make_etype_info_entry(ETYPE_INFO_ENTRY *ent, Key *key)
278 {
279 ent->etype = key->key.keytype;
280 if(key->salt){
281 ALLOC(ent->salttype);
282 #if 0
283 if(key->salt->type == hdb_pw_salt)
284 *ent->salttype = 0; /* or 1? or NULL? */
285 else if(key->salt->type == hdb_afs3_salt)
286 *ent->salttype = 2;
287 else {
288 kdc_log(0, "unknown salt-type: %d",
289 key->salt->type);
290 return KRB5KRB_ERR_GENERIC;
291 }
292 /* according to `the specs', we can't send a salt if
293 we have AFS3 salted key, but that requires that you
294 *know* what cell you are using (e.g by assuming
295 that the cell is the same as the realm in lower
296 case) */
297 #else
298 *ent->salttype = key->salt->type;
299 #endif
300 krb5_copy_data(context, &key->salt->salt,
301 &ent->salt);
302 } else {
303 /* we return no salt type at all, as that should indicate
304 * the default salt type and make everybody happy. some
305 * systems (like w2k) dislike being told the salt type
306 * here. */
307
308 ent->salttype = NULL;
309 ent->salt = NULL;
310 }
311 return 0;
312 }
313
314 static krb5_error_code
315 get_pa_etype_info(METHOD_DATA *md, hdb_entry *client,
316 ENCTYPE *etypes, unsigned int etypes_len)
317 {
318 krb5_error_code ret = 0;
319 int i, j;
320 unsigned int n = 0;
321 ETYPE_INFO pa;
322 unsigned char *buf;
323 size_t len;
324
325
326 pa.len = client->keys.len;
327 if(pa.len > UINT_MAX/sizeof(*pa.val))
328 return ERANGE;
329 pa.val = malloc(pa.len * sizeof(*pa.val));
330 if(pa.val == NULL)
331 return ENOMEM;
332
333 for(j = 0; j < etypes_len; j++) {
334 for (i = 0; i < n; i++)
335 if (pa.val[i].etype == etypes[j])
336 goto skip1;
337 for(i = 0; i < client->keys.len; i++) {
338 if(client->keys.val[i].key.keytype == etypes[j])
339 if((ret = make_etype_info_entry(&pa.val[n++],
340 &client->keys.val[i])) != 0) {
341 free_ETYPE_INFO(&pa);
342 return ret;
343 }
344 }
345 skip1:;
346 }
347 for(i = 0; i < client->keys.len; i++) {
348 for(j = 0; j < etypes_len; j++) {
349 if(client->keys.val[i].key.keytype == etypes[j])
350 goto skip2;
351 }
352 if((ret = make_etype_info_entry(&pa.val[n++],
353 &client->keys.val[i])) != 0) {
354 free_ETYPE_INFO(&pa);
355 return ret;
356 }
357 skip2:;
358 }
359
360 if(n != pa.len) {
361 char *name;
362 krb5_unparse_name(context, client->principal, &name);
363 kdc_log(0, "internal error in get_pa_etype_info(%s): %d != %d",
364 name, n, pa.len);
365 free(name);
366 pa.len = n;
367 }
368
369 ASN1_MALLOC_ENCODE(ETYPE_INFO, buf, len, &pa, &len, ret);
370 free_ETYPE_INFO(&pa);
371 if(ret)
372 return ret;
373 ret = realloc_method_data(md);
374 if(ret) {
375 free(buf);
376 return ret;
377 }
378 md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO;
379 md->val[md->len - 1].padata_value.length = len;
380 md->val[md->len - 1].padata_value.data = buf;
381 return 0;
382 }
383
384 /*
385 * verify the flags on `client' and `server', returning 0
386 * if they are OK and generating an error messages and returning
387 * and error code otherwise.
388 */
389
390 krb5_error_code
391 check_flags(hdb_entry *client, const char *client_name,
392 hdb_entry *server, const char *server_name,
393 krb5_boolean is_as_req)
394 {
395 if(client != NULL) {
396 /* check client */
397 if (client->flags.invalid) {
398 kdc_log(0, "Client (%s) has invalid bit set", client_name);
399 return KRB5KDC_ERR_POLICY;
400 }
401
402 if(!client->flags.client){
403 kdc_log(0, "Principal may not act as client -- %s",
404 client_name);
405 return KRB5KDC_ERR_POLICY;
406 }
407
408 if (client->valid_start && *client->valid_start > kdc_time) {
409 kdc_log(0, "Client not yet valid -- %s", client_name);
410 return KRB5KDC_ERR_CLIENT_NOTYET;
411 }
412
413 if (client->valid_end && *client->valid_end < kdc_time) {
414 kdc_log(0, "Client expired -- %s", client_name);
415 return KRB5KDC_ERR_NAME_EXP;
416 }
417
418 if (client->pw_end && *client->pw_end < kdc_time
419 && !server->flags.change_pw) {
420 kdc_log(0, "Client's key has expired -- %s", client_name);
421 return KRB5KDC_ERR_KEY_EXPIRED;
422 }
423 }
424
425 /* check server */
426
427 if (server != NULL) {
428 if (server->flags.invalid) {
429 kdc_log(0, "Server has invalid flag set -- %s", server_name);
430 return KRB5KDC_ERR_POLICY;
431 }
432
433 if(!server->flags.server){
434 kdc_log(0, "Principal may not act as server -- %s",
435 server_name);
436 return KRB5KDC_ERR_POLICY;
437 }
438
439 if(!is_as_req && server->flags.initial) {
440 kdc_log(0, "AS-REQ is required for server -- %s", server_name);
441 return KRB5KDC_ERR_POLICY;
442 }
443
444 if (server->valid_start && *server->valid_start > kdc_time) {
445 kdc_log(0, "Server not yet valid -- %s", server_name);
446 return KRB5KDC_ERR_SERVICE_NOTYET;
447 }
448
449 if (server->valid_end && *server->valid_end < kdc_time) {
450 kdc_log(0, "Server expired -- %s", server_name);
451 return KRB5KDC_ERR_SERVICE_EXP;
452 }
453
454 if (server->pw_end && *server->pw_end < kdc_time) {
455 kdc_log(0, "Server's key has expired -- %s", server_name);
456 return KRB5KDC_ERR_KEY_EXPIRED;
457 }
458 }
459 return 0;
460 }
461
462 /*
463 * Return TRUE if `from' is part of `addresses' taking into consideration
464 * the configuration variables that tells us how strict we should be about
465 * these checks
466 */
467
468 static krb5_boolean
469 check_addresses(HostAddresses *addresses, const struct sockaddr *from)
470 {
471 krb5_error_code ret;
472 krb5_address addr;
473 krb5_boolean result;
474
475 if(check_ticket_addresses == 0)
476 return TRUE;
477
478 if(addresses == NULL)
479 return allow_null_ticket_addresses;
480
481 ret = krb5_sockaddr2address (context, from, &addr);
482 if(ret)
483 return FALSE;
484
485 result = krb5_address_search(context, &addr, addresses);
486 krb5_free_address (context, &addr);
487 return result;
488 }
489
490 krb5_error_code
491 as_rep(KDC_REQ *req,
492 krb5_data *reply,
493 const char *from,
494 struct sockaddr *from_addr)
495 {
496 KDC_REQ_BODY *b = &req->req_body;
497 AS_REP rep;
498 KDCOptions f = b->kdc_options;
499 hdb_entry *client = NULL, *server = NULL;
500 krb5_enctype cetype, setype;
501 EncTicketPart et;
502 EncKDCRepPart ek;
503 krb5_principal client_princ = NULL, server_princ = NULL;
504 char *client_name = NULL, *server_name = NULL;
505 krb5_error_code ret = 0;
506 const char *e_text = NULL;
507 krb5_crypto crypto;
508 Key *ckey, *skey;
509
510 memset(&rep, 0, sizeof(rep));
511
512 if(b->sname == NULL){
513 ret = KRB5KRB_ERR_GENERIC;
514 e_text = "No server in request";
515 } else{
516 principalname2krb5_principal (&server_princ, *(b->sname), b->realm);
517 krb5_unparse_name(context, server_princ, &server_name);
518 }
519 if (ret) {
520 kdc_log(0, "AS-REQ malformed server name from %s", from);
521 goto out;
522 }
523
524 if(b->cname == NULL){
525 ret = KRB5KRB_ERR_GENERIC;
526 e_text = "No client in request";
527 } else {
528 principalname2krb5_principal (&client_princ, *(b->cname), b->realm);
529 krb5_unparse_name(context, client_princ, &client_name);
530 }
531 if (ret) {
532 kdc_log(0, "AS-REQ malformed client name from %s", from);
533 goto out;
534 }
535
536 kdc_log(0, "AS-REQ %s from %s for %s", client_name, from, server_name);
537
538 ret = db_fetch(client_princ, &client);
539 if(ret){
540 kdc_log(0, "UNKNOWN -- %s: %s", client_name,
541 krb5_get_err_text(context, ret));
542 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
543 goto out;
544 }
545
546 ret = db_fetch(server_princ, &server);
547 if(ret){
548 kdc_log(0, "UNKNOWN -- %s: %s", server_name,
549 krb5_get_err_text(context, ret));
550 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
551 goto out;
552 }
553
554 ret = check_flags(client, client_name, server, server_name, TRUE);
555 if(ret)
556 goto out;
557
558 memset(&et, 0, sizeof(et));
559 memset(&ek, 0, sizeof(ek));
560
561 if(req->padata){
562 int i = 0;
563 PA_DATA *pa;
564 int found_pa = 0;
565 kdc_log(5, "Looking for pa-data -- %s", client_name);
566 while((pa = find_padata(req, &i, KRB5_PADATA_ENC_TIMESTAMP))){
567 krb5_data ts_data;
568 PA_ENC_TS_ENC p;
569 time_t patime;
570 size_t len;
571 EncryptedData enc_data;
572 Key *pa_key;
573
574 found_pa = 1;
575
576 ret = decode_EncryptedData(pa->padata_value.data,
577 pa->padata_value.length,
578 &enc_data,
579 &len);
580 if (ret) {
581 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
582 kdc_log(5, "Failed to decode PA-DATA -- %s",
583 client_name);
584 goto out;
585 }
586
587 ret = hdb_enctype2key(context, client, enc_data.etype, &pa_key);
588 if(ret){
589 char *estr;
590 e_text = "No key matches pa-data";
591 ret = KRB5KDC_ERR_PREAUTH_FAILED;
592 if(krb5_enctype_to_string(context, enc_data.etype, &estr))
593 estr = NULL;
594 if(estr == NULL)
595 kdc_log(5, "No client key matching pa-data (%d) -- %s",
596 enc_data.etype, client_name);
597 else
598 kdc_log(5, "No client key matching pa-data (%s) -- %s",
599 estr, client_name);
600 free(estr);
601
602 free_EncryptedData(&enc_data);
603 continue;
604 }
605
606 try_next_key:
607 ret = krb5_crypto_init(context, &pa_key->key, 0, &crypto);
608 if (ret) {
609 kdc_log(0, "krb5_crypto_init failed: %s",
610 krb5_get_err_text(context, ret));
611 free_EncryptedData(&enc_data);
612 continue;
613 }
614
615 ret = krb5_decrypt_EncryptedData (context,
616 crypto,
617 KRB5_KU_PA_ENC_TIMESTAMP,
618 &enc_data,
619 &ts_data);
620 krb5_crypto_destroy(context, crypto);
621 if(ret){
622 if(hdb_next_enctype2key(context, client,
623 enc_data.etype, &pa_key) == 0)
624 goto try_next_key;
625 free_EncryptedData(&enc_data);
626 e_text = "Failed to decrypt PA-DATA";
627 kdc_log (5, "Failed to decrypt PA-DATA -- %s",
628 client_name);
629 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
630 continue;
631 }
632 free_EncryptedData(&enc_data);
633 ret = decode_PA_ENC_TS_ENC(ts_data.data,
634 ts_data.length,
635 &p,
636 &len);
637 krb5_data_free(&ts_data);
638 if(ret){
639 e_text = "Failed to decode PA-ENC-TS-ENC";
640 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
641 kdc_log (5, "Failed to decode PA-ENC-TS_ENC -- %s",
642 client_name);
643 continue;
644 }
645 patime = p.patimestamp;
646 free_PA_ENC_TS_ENC(&p);
647 if (abs(kdc_time - p.patimestamp) > context->max_skew) {
648 ret = KRB5KDC_ERR_PREAUTH_FAILED;
649 e_text = "Too large time skew";
650 kdc_log(0, "Too large time skew -- %s", client_name);
651 goto out;
652 }
653 et.flags.pre_authent = 1;
654 kdc_log(2, "Pre-authentication succeded -- %s", client_name);
655 break;
656 }
657 if(found_pa == 0 && require_preauth)
658 goto use_pa;
659 /* We come here if we found a pa-enc-timestamp, but if there
660 was some problem with it, other than too large skew */
661 if(found_pa && et.flags.pre_authent == 0){
662 kdc_log(0, "%s -- %s", e_text, client_name);
663 e_text = NULL;
664 goto out;
665 }
666 }else if (require_preauth
667 || client->flags.require_preauth
668 || server->flags.require_preauth) {
669 METHOD_DATA method_data;
670 PA_DATA *pa;
671 unsigned char *buf;
672 size_t len;
673 krb5_data foo_data;
674
675 use_pa:
676 method_data.len = 0;
677 method_data.val = NULL;
678
679 ret = realloc_method_data(&method_data);
680 pa = &method_data.val[method_data.len-1];
681 pa->padata_type = KRB5_PADATA_ENC_TIMESTAMP;
682 pa->padata_value.length = 0;
683 pa->padata_value.data = NULL;
684
685 ret = get_pa_etype_info(&method_data, client,
686 b->etype.val, b->etype.len); /* XXX check ret */
687
688 ASN1_MALLOC_ENCODE(METHOD_DATA, buf, len, &method_data, &len, ret);
689 free_METHOD_DATA(&method_data);
690 foo_data.data = buf;
691 foo_data.length = len;
692
693 ret = KRB5KDC_ERR_PREAUTH_REQUIRED;
694 krb5_mk_error(context,
695 ret,
696 "Need to use PA-ENC-TIMESTAMP",
697 &foo_data,
698 client_princ,
699 server_princ,
700 NULL,
701 NULL,
702 reply);
703 free(buf);
704 kdc_log(0, "No PA-ENC-TIMESTAMP -- %s", client_name);
705 ret = 0;
706 goto out2;
707 }
708
709 ret = find_keys(client, server, &ckey, &cetype, &skey, &setype,
710 b->etype.val, b->etype.len);
711 if(ret) {
712 kdc_log(0, "Server/client has no support for etypes");
713 goto out;
714 }
715
716 {
717 char *cet;
718 char *set;
719
720 ret = krb5_enctype_to_string(context, cetype, &cet);
721 if(ret == 0) {
722 ret = krb5_enctype_to_string(context, setype, &set);
723 if (ret == 0) {
724 kdc_log(5, "Using %s/%s", cet, set);
725 free(set);
726 }
727 free(cet);
728 }
729 if (ret != 0)
730 kdc_log(5, "Using e-types %d/%d", cetype, setype);
731 }
732
733 {
734 char str[128];
735 unparse_flags(KDCOptions2int(f), KDCOptions_units, str, sizeof(str));
736 if(*str)
737 kdc_log(2, "Requested flags: %s", str);
738 }
739
740
741 if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey
742 || (f.request_anonymous && !allow_anonymous)) {
743 ret = KRB5KDC_ERR_BADOPTION;
744 kdc_log(0, "Bad KDC options -- %s", client_name);
745 goto out;
746 }
747
748 rep.pvno = 5;
749 rep.msg_type = krb_as_rep;
750 copy_Realm(&b->realm, &rep.crealm);
751 if (f.request_anonymous)
752 make_anonymous_principalname (&rep.cname);
753 else
754 copy_PrincipalName(b->cname, &rep.cname);
755 rep.ticket.tkt_vno = 5;
756 copy_Realm(&b->realm, &rep.ticket.realm);
757 copy_PrincipalName(b->sname, &rep.ticket.sname);
758
759 et.flags.initial = 1;
760 if(client->flags.forwardable && server->flags.forwardable)
761 et.flags.forwardable = f.forwardable;
762 else if (f.forwardable) {
763 ret = KRB5KDC_ERR_POLICY;
764 kdc_log(0, "Ticket may not be forwardable -- %s", client_name);
765 goto out;
766 }
767 if(client->flags.proxiable && server->flags.proxiable)
768 et.flags.proxiable = f.proxiable;
769 else if (f.proxiable) {
770 ret = KRB5KDC_ERR_POLICY;
771 kdc_log(0, "Ticket may not be proxiable -- %s", client_name);
772 goto out;
773 }
774 if(client->flags.postdate && server->flags.postdate)
775 et.flags.may_postdate = f.allow_postdate;
776 else if (f.allow_postdate){
777 ret = KRB5KDC_ERR_POLICY;
778 kdc_log(0, "Ticket may not be postdatable -- %s", client_name);
779 goto out;
780 }
781
782 /* check for valid set of addresses */
783 if(!check_addresses(b->addresses, from_addr)) {
784 ret = KRB5KRB_AP_ERR_BADADDR;
785 kdc_log(0, "Bad address list requested -- %s", client_name);
786 goto out;
787 }
788
789 krb5_generate_random_keyblock(context, setype, &et.key);
790 copy_PrincipalName(&rep.cname, &et.cname);
791 copy_Realm(&b->realm, &et.crealm);
792
793 {
794 time_t start;
795 time_t t;
796
797 start = et.authtime = kdc_time;
798
799 if(f.postdated && req->req_body.from){
800 ALLOC(et.starttime);
801 start = *et.starttime = *req->req_body.from;
802 et.flags.invalid = 1;
803 et.flags.postdated = 1; /* XXX ??? */
804 }
805 fix_time(&b->till);
806 t = *b->till;
807
808 /* be careful not overflowing */
809
810 if(client->max_life)
811 t = start + min(t - start, *client->max_life);
812 if(server->max_life)
813 t = start + min(t - start, *server->max_life);
814 #if 0
815 t = min(t, start + realm->max_life);
816 #endif
817 et.endtime = t;
818 if(f.renewable_ok && et.endtime < *b->till){
819 f.renewable = 1;
820 if(b->rtime == NULL){
821 ALLOC(b->rtime);
822 *b->rtime = 0;
823 }
824 if(*b->rtime < *b->till)
825 *b->rtime = *b->till;
826 }
827 if(f.renewable && b->rtime){
828 t = *b->rtime;
829 if(t == 0)
830 t = MAX_TIME;
831 if(client->max_renew)
832 t = start + min(t - start, *client->max_renew);
833 if(server->max_renew)
834 t = start + min(t - start, *server->max_renew);
835 #if 0
836 t = min(t, start + realm->max_renew);
837 #endif
838 ALLOC(et.renew_till);
839 *et.renew_till = t;
840 et.flags.renewable = 1;
841 }
842 }
843
844 if (f.request_anonymous)
845 et.flags.anonymous = 1;
846
847 if(b->addresses){
848 ALLOC(et.caddr);
849 copy_HostAddresses(b->addresses, et.caddr);
850 }
851
852 et.transited.tr_type = DOMAIN_X500_COMPRESS;
853 krb5_data_zero(&et.transited.contents);
854
855 copy_EncryptionKey(&et.key, &ek.key);
856
857 /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
858 * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
859 * incapable of correctly decoding SEQUENCE OF's of zero length.
860 *
861 * To fix this, always send at least one no-op last_req
862 *
863 * If there's a pw_end or valid_end we will use that,
864 * otherwise just a dummy lr.
865 */
866 ek.last_req.val = malloc(2 * sizeof(*ek.last_req.val));
867 ek.last_req.len = 0;
868 if (client->pw_end
869 && (kdc_warn_pwexpire == 0
870 || kdc_time + kdc_warn_pwexpire <= *client->pw_end)) {
871 ek.last_req.val[ek.last_req.len].lr_type = LR_PW_EXPTIME;
872 ek.last_req.val[ek.last_req.len].lr_value = *client->pw_end;
873 ++ek.last_req.len;
874 }
875 if (client->valid_end) {
876 ek.last_req.val[ek.last_req.len].lr_type = LR_ACCT_EXPTIME;
877 ek.last_req.val[ek.last_req.len].lr_value = *client->valid_end;
878 ++ek.last_req.len;
879 }
880 if (ek.last_req.len == 0) {
881 ek.last_req.val[ek.last_req.len].lr_type = LR_NONE;
882 ek.last_req.val[ek.last_req.len].lr_value = 0;
883 ++ek.last_req.len;
884 }
885 ek.nonce = b->nonce;
886 if (client->valid_end || client->pw_end) {
887 ALLOC(ek.key_expiration);
888 if (client->valid_end) {
889 if (client->pw_end)
890 *ek.key_expiration = min(*client->valid_end, *client->pw_end);
891 else
892 *ek.key_expiration = *client->valid_end;
893 } else
894 *ek.key_expiration = *client->pw_end;
895 } else
896 ek.key_expiration = NULL;
897 ek.flags = et.flags;
898 ek.authtime = et.authtime;
899 if (et.starttime) {
900 ALLOC(ek.starttime);
901 *ek.starttime = *et.starttime;
902 }
903 ek.endtime = et.endtime;
904 if (et.renew_till) {
905 ALLOC(ek.renew_till);
906 *ek.renew_till = *et.renew_till;
907 }
908 copy_Realm(&rep.ticket.realm, &ek.srealm);
909 copy_PrincipalName(&rep.ticket.sname, &ek.sname);
910 if(et.caddr){
911 ALLOC(ek.caddr);
912 copy_HostAddresses(et.caddr, ek.caddr);
913 }
914
915 set_salt_padata (&rep.padata, ckey->salt);
916 ret = encode_reply(&rep, &et, &ek, setype, server->kvno, &skey->key,
917 client->kvno, &ckey->key, &e_text, reply);
918 free_EncTicketPart(&et);
919 free_EncKDCRepPart(&ek);
920 out:
921 free_AS_REP(&rep);
922 if(ret){
923 krb5_mk_error(context,
924 ret,
925 e_text,
926 NULL,
927 client_princ,
928 server_princ,
929 NULL,
930 NULL,
931 reply);
932 ret = 0;
933 }
934 out2:
935 if (client_princ)
936 krb5_free_principal(context, client_princ);
937 free(client_name);
938 if (server_princ)
939 krb5_free_principal(context, server_princ);
940 free(server_name);
941 if(client)
942 free_ent(client);
943 if(server)
944 free_ent(server);
945 return ret;
946 }
947
948
949 static krb5_error_code
950 check_tgs_flags(KDC_REQ_BODY *b, EncTicketPart *tgt, EncTicketPart *et)
951 {
952 KDCOptions f = b->kdc_options;
953
954 if(f.validate){
955 if(!tgt->flags.invalid || tgt->starttime == NULL){
956 kdc_log(0, "Bad request to validate ticket");
957 return KRB5KDC_ERR_BADOPTION;
958 }
959 if(*tgt->starttime > kdc_time){
960 kdc_log(0, "Early request to validate ticket");
961 return KRB5KRB_AP_ERR_TKT_NYV;
962 }
963 /* XXX tkt = tgt */
964 et->flags.invalid = 0;
965 }else if(tgt->flags.invalid){
966 kdc_log(0, "Ticket-granting ticket has INVALID flag set");
967 return KRB5KRB_AP_ERR_TKT_INVALID;
968 }
969
970 if(f.forwardable){
971 if(!tgt->flags.forwardable){
972 kdc_log(0, "Bad request for forwardable ticket");
973 return KRB5KDC_ERR_BADOPTION;
974 }
975 et->flags.forwardable = 1;
976 }
977 if(f.forwarded){
978 if(!tgt->flags.forwardable){
979 kdc_log(0, "Request to forward non-forwardable ticket");
980 return KRB5KDC_ERR_BADOPTION;
981 }
982 et->flags.forwarded = 1;
983 et->caddr = b->addresses;
984 }
985 if(tgt->flags.forwarded)
986 et->flags.forwarded = 1;
987
988 if(f.proxiable){
989 if(!tgt->flags.proxiable){
990 kdc_log(0, "Bad request for proxiable ticket");
991 return KRB5KDC_ERR_BADOPTION;
992 }
993 et->flags.proxiable = 1;
994 }
995 if(f.proxy){
996 if(!tgt->flags.proxiable){
997 kdc_log(0, "Request to proxy non-proxiable ticket");
998 return KRB5KDC_ERR_BADOPTION;
999 }
1000 et->flags.proxy = 1;
1001 et->caddr = b->addresses;
1002 }
1003 if(tgt->flags.proxy)
1004 et->flags.proxy = 1;
1005
1006 if(f.allow_postdate){
1007 if(!tgt->flags.may_postdate){
1008 kdc_log(0, "Bad request for post-datable ticket");
1009 return KRB5KDC_ERR_BADOPTION;
1010 }
1011 et->flags.may_postdate = 1;
1012 }
1013 if(f.postdated){
1014 if(!tgt->flags.may_postdate){
1015 kdc_log(0, "Bad request for postdated ticket");
1016 return KRB5KDC_ERR_BADOPTION;
1017 }
1018 if(b->from)
1019 *et->starttime = *b->from;
1020 et->flags.postdated = 1;
1021 et->flags.invalid = 1;
1022 }else if(b->from && *b->from > kdc_time + context->max_skew){
1023 kdc_log(0, "Ticket cannot be postdated");
1024 return KRB5KDC_ERR_CANNOT_POSTDATE;
1025 }
1026
1027 if(f.renewable){
1028 if(!tgt->flags.renewable){
1029 kdc_log(0, "Bad request for renewable ticket");
1030 return KRB5KDC_ERR_BADOPTION;
1031 }
1032 et->flags.renewable = 1;
1033 ALLOC(et->renew_till);
1034 fix_time(&b->rtime);
1035 *et->renew_till = *b->rtime;
1036 }
1037 if(f.renew){
1038 time_t old_life;
1039 if(!tgt->flags.renewable || tgt->renew_till == NULL){
1040 kdc_log(0, "Request to renew non-renewable ticket");
1041 return KRB5KDC_ERR_BADOPTION;
1042 }
1043 old_life = tgt->endtime;
1044 if(tgt->starttime)
1045 old_life -= *tgt->starttime;
1046 else
1047 old_life -= tgt->authtime;
1048 et->endtime = *et->starttime + old_life;
1049 if (et->renew_till != NULL)
1050 et->endtime = min(*et->renew_till, et->endtime);
1051 }
1052
1053 /* checks for excess flags */
1054 if(f.request_anonymous && !allow_anonymous){
1055 kdc_log(0, "Request for anonymous ticket");
1056 return KRB5KDC_ERR_BADOPTION;
1057 }
1058 return 0;
1059 }
1060
1061 static krb5_error_code
1062 fix_transited_encoding(krb5_boolean check_policy,
1063 TransitedEncoding *tr,
1064 EncTicketPart *et,
1065 const char *client_realm,
1066 const char *server_realm,
1067 const char *tgt_realm)
1068 {
1069 krb5_error_code ret = 0;
1070 char **realms, **tmp;
1071 int num_realms;
1072 int i;
1073
1074 if(tr->tr_type != DOMAIN_X500_COMPRESS) {
1075 kdc_log(0, "Unknown transited type: %u", tr->tr_type);
1076 return KRB5KDC_ERR_TRTYPE_NOSUPP;
1077 }
1078
1079 ret = krb5_domain_x500_decode(context,
1080 tr->contents,
1081 &realms,
1082 &num_realms,
1083 client_realm,
1084 server_realm);
1085 if(ret){
1086 krb5_warn(context, ret, "Decoding transited encoding");
1087 return ret;
1088 }
1089 if(strcmp(client_realm, tgt_realm) && strcmp(server_realm, tgt_realm)) {
1090 /* not us, so add the previous realm to transited set */
1091 if (num_realms < 0 || num_realms + 1 > UINT_MAX/sizeof(*realms)) {
1092 ret = ERANGE;
1093 goto free_realms;
1094 }
1095 tmp = realloc(realms, (num_realms + 1) * sizeof(*realms));
1096 if(tmp == NULL){
1097 ret = ENOMEM;
1098 goto free_realms;
1099 }
1100 realms = tmp;
1101 realms[num_realms] = strdup(tgt_realm);
1102 if(realms[num_realms] == NULL){
1103 ret = ENOMEM;
1104 goto free_realms;
1105 }
1106 num_realms++;
1107 }
1108 if(num_realms == 0) {
1109 if(strcmp(client_realm, server_realm))
1110 kdc_log(0, "cross-realm %s -> %s", client_realm, server_realm);
1111 } else {
1112 size_t l = 0;
1113 char *rs;
1114 for(i = 0; i < num_realms; i++)
1115 l += strlen(realms[i]) + 2;
1116 rs = malloc(l);
1117 if(rs != NULL) {
1118 *rs = '\0';
1119 for(i = 0; i < num_realms; i++) {
1120 if(i > 0)
1121 strlcat(rs, ", ", l);
1122 strlcat(rs, realms[i], l);
1123 }
1124 kdc_log(0, "cross-realm %s -> %s via [%s]", client_realm, server_realm, rs);
1125 free(rs);
1126 }
1127 }
1128 if(check_policy) {
1129 ret = krb5_check_transited(context, client_realm,
1130 server_realm,
1131 realms, num_realms, NULL);
1132 if(ret) {
1133 krb5_warn(context, ret, "cross-realm %s -> %s",
1134 client_realm, server_realm);
1135 goto free_realms;
1136 }
1137 et->flags.transited_policy_checked = 1;
1138 }
1139 et->transited.tr_type = DOMAIN_X500_COMPRESS;
1140 ret = krb5_domain_x500_encode(realms, num_realms, &et->transited.contents);
1141 if(ret)
1142 krb5_warn(context, ret, "Encoding transited encoding");
1143 free_realms:
1144 for(i = 0; i < num_realms; i++)
1145 free(realms[i]);
1146 free(realms);
1147 return ret;
1148 }
1149
1150
1151 static krb5_error_code
1152 tgs_make_reply(KDC_REQ_BODY *b,
1153 EncTicketPart *tgt,
1154 EncTicketPart *adtkt,
1155 AuthorizationData *auth_data,
1156 hdb_entry *server,
1157 hdb_entry *client,
1158 krb5_principal client_principal,
1159 hdb_entry *krbtgt,
1160 krb5_enctype cetype,
1161 const char **e_text,
1162 krb5_data *reply)
1163 {
1164 KDC_REP rep;
1165 EncKDCRepPart ek;
1166 EncTicketPart et;
1167 KDCOptions f = b->kdc_options;
1168 krb5_error_code ret;
1169 krb5_enctype etype;
1170 Key *skey;
1171 EncryptionKey *ekey;
1172
1173 if(adtkt) {
1174 int i;
1175 krb5_keytype kt;
1176 ekey = &adtkt->key;
1177 for(i = 0; i < b->etype.len; i++){
1178 ret = krb5_enctype_to_keytype(context, b->etype.val[i], &kt);
1179 if(ret)
1180 continue;
1181 if(adtkt->key.keytype == kt)
1182 break;
1183 }
1184 if(i == b->etype.len)
1185 return KRB5KDC_ERR_ETYPE_NOSUPP;
1186 etype = b->etype.val[i];
1187 }else{
1188 ret = find_keys(NULL, server, NULL, NULL, &skey, &etype,
1189 b->etype.val, b->etype.len);
1190 if(ret) {
1191 kdc_log(0, "Server has no support for etypes");
1192 return ret;
1193 }
1194 ekey = &skey->key;
1195 }
1196
1197 memset(&rep, 0, sizeof(rep));
1198 memset(&et, 0, sizeof(et));
1199 memset(&ek, 0, sizeof(ek));
1200
1201 rep.pvno = 5;
1202 rep.msg_type = krb_tgs_rep;
1203
1204 et.authtime = tgt->authtime;
1205 fix_time(&b->till);
1206 et.endtime = min(tgt->endtime, *b->till);
1207 ALLOC(et.starttime);
1208 *et.starttime = kdc_time;
1209
1210 ret = check_tgs_flags(b, tgt, &et);
1211 if(ret)
1212 goto out;
1213
1214 /* We should check the transited encoding if:
1215 1) the request doesn't ask not to be checked
1216 2) globally enforcing a check
1217 3) principal requires checking
1218 4) we allow non-check per-principal, but principal isn't marked as allowing this
1219 5) we don't globally allow this
1220 */
1221
1222 #define GLOBAL_FORCE_TRANSITED_CHECK (trpolicy == TRPOLICY_ALWAYS_CHECK)
1223 #define GLOBAL_ALLOW_PER_PRINCIPAL (trpolicy == TRPOLICY_ALLOW_PER_PRINCIPAL)
1224 #define GLOBAL_ALLOW_DISABLE_TRANSITED_CHECK (trpolicy == TRPOLICY_ALWAYS_HONOUR_REQUEST)
1225 /* these will consult the database in future release */
1226 #define PRINCIPAL_FORCE_TRANSITED_CHECK(P) 0
1227 #define PRINCIPAL_ALLOW_DISABLE_TRANSITED_CHECK(P) 0
1228
1229 ret = fix_transited_encoding(!f.disable_transited_check ||
1230 GLOBAL_FORCE_TRANSITED_CHECK ||
1231 PRINCIPAL_FORCE_TRANSITED_CHECK(server) ||
1232 !((GLOBAL_ALLOW_PER_PRINCIPAL &&
1233 PRINCIPAL_ALLOW_DISABLE_TRANSITED_CHECK(server)) ||
1234 GLOBAL_ALLOW_DISABLE_TRANSITED_CHECK),
1235 &tgt->transited, &et,
1236 *krb5_princ_realm(context, client_principal),
1237 *krb5_princ_realm(context, server->principal),
1238 *krb5_princ_realm(context, krbtgt->principal));
1239 if(ret)
1240 goto out;
1241
1242 copy_Realm(krb5_princ_realm(context, server->principal),
1243 &rep.ticket.realm);
1244 krb5_principal2principalname(&rep.ticket.sname, server->principal);
1245 copy_Realm(&tgt->crealm, &rep.crealm);
1246 if (f.request_anonymous)
1247 make_anonymous_principalname (&tgt->cname);
1248 else
1249 copy_PrincipalName(&tgt->cname, &rep.cname);
1250 rep.ticket.tkt_vno = 5;
1251
1252 ek.caddr = et.caddr;
1253 if(et.caddr == NULL)
1254 et.caddr = tgt->caddr;
1255
1256 {
1257 time_t life;
1258 life = et.endtime - *et.starttime;
1259 if(client && client->max_life)
1260 life = min(life, *client->max_life);
1261 if(server->max_life)
1262 life = min(life, *server->max_life);
1263 et.endtime = *et.starttime + life;
1264 }
1265 if(f.renewable_ok && tgt->flags.renewable &&
1266 et.renew_till == NULL && et.endtime < *b->till){
1267 et.flags.renewable = 1;
1268 ALLOC(et.renew_till);
1269 *et.renew_till = *b->till;
1270 }
1271 if(et.renew_till){
1272 time_t renew;
1273 renew = *et.renew_till - et.authtime;
1274 if(client && client->max_renew)
1275 renew = min(renew, *client->max_renew);
1276 if(server->max_renew)
1277 renew = min(renew, *server->max_renew);
1278 *et.renew_till = et.authtime + renew;
1279 }
1280
1281 if(et.renew_till){
1282 *et.renew_till = min(*et.renew_till, *tgt->renew_till);
1283 *et.starttime = min(*et.starttime, *et.renew_till);
1284 et.endtime = min(et.endtime, *et.renew_till);
1285 }
1286
1287 *et.starttime = min(*et.starttime, et.endtime);
1288
1289 if(*et.starttime == et.endtime){
1290 ret = KRB5KDC_ERR_NEVER_VALID;
1291 goto out;
1292 }
1293 if(et.renew_till && et.endtime == *et.renew_till){
1294 free(et.renew_till);
1295 et.renew_till = NULL;
1296 et.flags.renewable = 0;
1297 }
1298
1299 et.flags.pre_authent = tgt->flags.pre_authent;
1300 et.flags.hw_authent = tgt->flags.hw_authent;
1301 et.flags.anonymous = tgt->flags.anonymous;
1302
1303 /* XXX Check enc-authorization-data */
1304 et.authorization_data = auth_data;
1305
1306 krb5_generate_random_keyblock(context, etype, &et.key);
1307 et.crealm = tgt->crealm;
1308 et.cname = tgt->cname;
1309
1310 ek.key = et.key;
1311 /* MIT must have at least one last_req */
1312 ek.last_req.len = 1;
1313 ek.last_req.val = calloc(1, sizeof(*ek.last_req.val));
1314 ek.nonce = b->nonce;
1315 ek.flags = et.flags;
1316 ek.authtime = et.authtime;
1317 ek.starttime = et.starttime;
1318 ek.endtime = et.endtime;
1319 ek.renew_till = et.renew_till;
1320 ek.srealm = rep.ticket.realm;
1321 ek.sname = rep.ticket.sname;
1322
1323 /* It is somewhat unclear where the etype in the following
1324 encryption should come from. What we have is a session
1325 key in the passed tgt, and a list of preferred etypes
1326 *for the new ticket*. Should we pick the best possible
1327 etype, given the keytype in the tgt, or should we look
1328 at the etype list here as well? What if the tgt
1329 session key is DES3 and we want a ticket with a (say)
1330 CAST session key. Should the DES3 etype be added to the
1331 etype list, even if we don't want a session key with
1332 DES3? */
1333 ret = encode_reply(&rep, &et, &ek, etype, adtkt ? 0 : server->kvno, ekey,
1334 0, &tgt->key, e_text, reply);
1335 out:
1336 free_TGS_REP(&rep);
1337 free_TransitedEncoding(&et.transited);
1338 if(et.starttime)
1339 free(et.starttime);
1340 if(et.renew_till)
1341 free(et.renew_till);
1342 free_LastReq(&ek.last_req);
1343 memset(et.key.keyvalue.data, 0, et.key.keyvalue.length);
1344 free_EncryptionKey(&et.key);
1345 return ret;
1346 }
1347
1348 static krb5_error_code
1349 tgs_check_authenticator(krb5_auth_context ac,
1350 KDC_REQ_BODY *b,
1351 const char **e_text,
1352 krb5_keyblock *key)
1353 {
1354 krb5_authenticator auth;
1355 size_t len;
1356 unsigned char *buf;
1357 size_t buf_size;
1358 krb5_error_code ret;
1359 krb5_crypto crypto;
1360
1361 krb5_auth_con_getauthenticator(context, ac, &auth);
1362 if(auth->cksum == NULL){
1363 kdc_log(0, "No authenticator in request");
1364 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
1365 goto out;
1366 }
1367 /*
1368 * according to RFC1510 it doesn't need to be keyed,
1369 * but according to the latest draft it needs to.
1370 */
1371 if (
1372 #if 0
1373 !krb5_checksum_is_keyed(context, auth->cksum->cksumtype)
1374 ||
1375 #endif
1376 !krb5_checksum_is_collision_proof(context, auth->cksum->cksumtype)) {
1377 kdc_log(0, "Bad checksum type in authenticator: %d",
1378 auth->cksum->cksumtype);
1379 ret = KRB5KRB_AP_ERR_INAPP_CKSUM;
1380 goto out;
1381 }
1382
1383 /* XXX should not re-encode this */
1384 ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, buf_size, b, &len, ret);
1385 if(ret){
1386 kdc_log(0, "Failed to encode KDC-REQ-BODY: %s",
1387 krb5_get_err_text(context, ret));
1388 goto out;
1389 }
1390 if(buf_size != len) {
1391 free(buf);
1392 kdc_log(0, "Internal error in ASN.1 encoder");
1393 *e_text = "KDC internal error";
1394 ret = KRB5KRB_ERR_GENERIC;
1395 goto out;
1396 }
1397 ret = krb5_crypto_init(context, key, 0, &crypto);
1398 if (ret) {
1399 free(buf);
1400 kdc_log(0, "krb5_crypto_init failed: %s",
1401 krb5_get_err_text(context, ret));
1402 goto out;
1403 }
1404 ret = krb5_verify_checksum(context,
1405 crypto,
1406 KRB5_KU_TGS_REQ_AUTH_CKSUM,
1407 buf,
1408 len,
1409 auth->cksum);
1410 free(buf);
1411 krb5_crypto_destroy(context, crypto);
1412 if(ret){
1413 kdc_log(0, "Failed to verify checksum: %s",
1414 krb5_get_err_text(context, ret));
1415 }
1416 out:
1417 free_Authenticator(auth);
1418 free(auth);
1419 return ret;
1420 }
1421
1422 /*
1423 * return the realm of a krbtgt-ticket or NULL
1424 */
1425
1426 static Realm
1427 get_krbtgt_realm(const PrincipalName *p)
1428 {
1429 if(p->name_string.len == 2
1430 && strcmp(p->name_string.val[0], KRB5_TGS_NAME) == 0)
1431 return p->name_string.val[1];
1432 else
1433 return NULL;
1434 }
1435
1436 static Realm
1437 find_rpath(Realm crealm, Realm srealm)
1438 {
1439 const char *new_realm = krb5_config_get_string(context,
1440 NULL,
1441 "capaths",
1442 crealm,
1443 srealm,
1444 NULL);
1445 return (Realm)new_realm;
1446 }
1447
1448
1449 static krb5_boolean
1450 need_referral(krb5_principal server, krb5_realm **realms)
1451 {
1452 if(server->name.name_type != KRB5_NT_SRV_INST ||
1453 server->name.name_string.len != 2)
1454 return FALSE;
1455
1456 return krb5_get_host_realm_int(context, server->name.name_string.val[1],
1457 FALSE, realms) == 0;
1458 }
1459
1460 static krb5_error_code
1461 tgs_rep2(KDC_REQ_BODY *b,
1462 PA_DATA *tgs_req,
1463 krb5_data *reply,
1464 const char *from,
1465 const struct sockaddr *from_addr,
1466 time_t **csec,
1467 int **cusec)
1468 {
1469 krb5_ap_req ap_req;
1470 krb5_error_code ret;
1471 krb5_principal princ;
1472 krb5_auth_context ac = NULL;
1473 krb5_ticket *ticket = NULL;
1474 krb5_flags ap_req_options;
1475 krb5_flags verify_ap_req_flags;
1476 const char *e_text = NULL;
1477 krb5_crypto crypto;
1478
1479 hdb_entry *krbtgt = NULL;
1480 EncTicketPart *tgt;
1481 Key *tkey;
1482 krb5_enctype cetype;
1483 krb5_principal cp = NULL;
1484 krb5_principal sp = NULL;
1485 AuthorizationData *auth_data = NULL;
1486
1487 *csec = NULL;
1488 *cusec = NULL;
1489
1490 memset(&ap_req, 0, sizeof(ap_req));
1491 ret = krb5_decode_ap_req(context, &tgs_req->padata_value, &ap_req);
1492 if(ret){
1493 kdc_log(0, "Failed to decode AP-REQ: %s",
1494 krb5_get_err_text(context, ret));
1495 goto out2;
1496 }
1497
1498 if(!get_krbtgt_realm(&ap_req.ticket.sname)){
1499 /* XXX check for ticket.sname == req.sname */
1500 kdc_log(0, "PA-DATA is not a ticket-granting ticket");
1501 ret = KRB5KDC_ERR_POLICY; /* ? */
1502 goto out2;
1503 }
1504
1505 principalname2krb5_principal(&princ,
1506 ap_req.ticket.sname,
1507 ap_req.ticket.realm);
1508
1509 ret = db_fetch(princ, &krbtgt);
1510
1511 if(ret) {
1512 char *p;
1513 krb5_unparse_name(context, princ, &p);
1514 krb5_free_principal(context, princ);
1515 kdc_log(0, "Ticket-granting ticket not found in database: %s: %s",
1516 p, krb5_get_err_text(context, ret));
1517 free(p);
1518 ret = KRB5KRB_AP_ERR_NOT_US;
1519 goto out2;
1520 }
1521
1522 if(ap_req.ticket.enc_part.kvno &&
1523 *ap_req.ticket.enc_part.kvno != krbtgt->kvno){
1524 char *p;
1525
1526 krb5_unparse_name (context, princ, &p);
1527 krb5_free_principal(context, princ);
1528 kdc_log(0, "Ticket kvno = %d, DB kvno = %d (%s)",
1529 *ap_req.ticket.enc_part.kvno,
1530 krbtgt->kvno,
1531 p);
1532 free (p);
1533 ret = KRB5KRB_AP_ERR_BADKEYVER;
1534 goto out2;
1535 }
1536
1537 ret = hdb_enctype2key(context, krbtgt, ap_req.ticket.enc_part.etype, &tkey);
1538 if(ret){
1539 char *str;
1540 krb5_enctype_to_string(context, ap_req.ticket.enc_part.etype, &str);
1541 kdc_log(0, "No server key found for %s", str);
1542 free(str);
1543 ret = KRB5KRB_AP_ERR_BADKEYVER;
1544 goto out2;
1545 }
1546
1547 if (b->kdc_options.validate)
1548 verify_ap_req_flags = KRB5_VERIFY_AP_REQ_IGNORE_INVALID;
1549 else
1550 verify_ap_req_flags = 0;
1551
1552 ret = krb5_verify_ap_req2(context,
1553 &ac,
1554 &ap_req,
1555 princ,
1556 &tkey->key,
1557 verify_ap_req_flags,
1558 &ap_req_options,
1559 &ticket,
1560 KRB5_KU_TGS_REQ_AUTH);
1561
1562 krb5_free_principal(context, princ);
1563 if(ret) {
1564 kdc_log(0, "Failed to verify AP-REQ: %s",
1565 krb5_get_err_text(context, ret));
1566 goto out2;
1567 }
1568
1569 {
1570 krb5_authenticator auth;
1571
1572 ret = krb5_auth_con_getauthenticator(context, ac, &auth);
1573 if (ret == 0) {
1574 *csec = malloc(sizeof(**csec));
1575 if (*csec == NULL) {
1576 krb5_free_authenticator(context, &auth);
1577 kdc_log(0, "malloc failed");
1578 goto out2;
1579 }
1580 **csec = auth->ctime;
1581 *cusec = malloc(sizeof(**cusec));
1582 if (*cusec == NULL) {
1583 krb5_free_authenticator(context, &auth);
1584 kdc_log(0, "malloc failed");
1585 goto out2;
1586 }
1587 **csec = auth->cusec;
1588 krb5_free_authenticator(context, &auth);
1589 }
1590 }
1591
1592 cetype = ap_req.authenticator.etype;
1593
1594 tgt = &ticket->ticket;
1595
1596 ret = tgs_check_authenticator(ac, b, &e_text, &tgt->key);
1597
1598 if (b->enc_authorization_data) {
1599 krb5_keyblock *subkey;
1600 krb5_data ad;
1601 ret = krb5_auth_con_getremotesubkey(context,
1602 ac,
1603 &subkey);
1604 if(ret){
1605 krb5_auth_con_free(context, ac);
1606 kdc_log(0, "Failed to get remote subkey: %s",
1607 krb5_get_err_text(context, ret));
1608 goto out2;
1609 }
1610 if(subkey == NULL){
1611 ret = krb5_auth_con_getkey(context, ac, &subkey);
1612 if(ret) {
1613 krb5_auth_con_free(context, ac);
1614 kdc_log(0, "Failed to get session key: %s",
1615 krb5_get_err_text(context, ret));
1616 goto out2;
1617 }
1618 }
1619 if(subkey == NULL){
1620 krb5_auth_con_free(context, ac);
1621 kdc_log(0, "Failed to get key for enc-authorization-data");
1622 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1623 goto out2;
1624 }
1625 ret = krb5_crypto_init(context, subkey, 0, &crypto);
1626 if (ret) {
1627 krb5_auth_con_free(context, ac);
1628 kdc_log(0, "krb5_crypto_init failed: %s",
1629 krb5_get_err_text(context, ret));
1630 goto out2;
1631 }
1632 ret = krb5_decrypt_EncryptedData (context,
1633 crypto,
1634 KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY,
1635 b->enc_authorization_data,
1636 &ad);
1637 krb5_crypto_destroy(context, crypto);
1638 if(ret){
1639 krb5_auth_con_free(context, ac);
1640 kdc_log(0, "Failed to decrypt enc-authorization-data");
1641 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1642 goto out2;
1643 }
1644 krb5_free_keyblock(context, subkey);
1645 ALLOC(auth_data);
1646 ret = decode_AuthorizationData(ad.data, ad.length, auth_data, NULL);
1647 if(ret){
1648 krb5_auth_con_free(context, ac);
1649 free(auth_data);
1650 auth_data = NULL;
1651 kdc_log(0, "Failed to decode authorization data");
1652 ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
1653 goto out2;
1654 }
1655 }
1656
1657 krb5_auth_con_free(context, ac);
1658
1659 if(ret){
1660 kdc_log(0, "Failed to verify authenticator: %s",
1661 krb5_get_err_text(context, ret));
1662 goto out2;
1663 }
1664
1665 {
1666 PrincipalName *s;
1667 Realm r;
1668 char *spn = NULL, *cpn = NULL;
1669 hdb_entry *server = NULL, *client = NULL;
1670 int loop = 0;
1671 EncTicketPart adtkt;
1672 char opt_str[128];
1673
1674 s = b->sname;
1675 r = b->realm;
1676 if(b->kdc_options.enc_tkt_in_skey){
1677 Ticket *t;
1678 hdb_entry *uu;
1679 krb5_principal p;
1680 Key *tkey;
1681
1682 if(b->additional_tickets == NULL ||
1683 b->additional_tickets->len == 0){
1684 ret = KRB5KDC_ERR_BADOPTION; /* ? */
1685 kdc_log(0, "No second ticket present in request");
1686 goto out;
1687 }
1688 t = &b->additional_tickets->val[0];
1689 if(!get_krbtgt_realm(&t->sname)){
1690 kdc_log(0, "Additional ticket is not a ticket-granting ticket");
1691 ret = KRB5KDC_ERR_POLICY;
1692 goto out2;
1693 }
1694 principalname2krb5_principal(&p, t->sname, t->realm);
1695 ret = db_fetch(p, &uu);
1696 krb5_free_principal(context, p);
1697 if(ret){
1698 if (ret == HDB_ERR_NOENTRY)
1699 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1700 goto out;
1701 }
1702 ret = hdb_enctype2key(context, uu, t->enc_part.etype, &tkey);
1703 if(ret){
1704 ret = KRB5KDC_ERR_ETYPE_NOSUPP; /* XXX */
1705 goto out;
1706 }
1707 ret = krb5_decrypt_ticket(context, t, &tkey->key, &adtkt, 0);
1708
1709 if(ret)
1710 goto out;
1711 s = &adtkt.cname;
1712 r = adtkt.crealm;
1713 }
1714
1715 principalname2krb5_principal(&sp, *s, r);
1716 krb5_unparse_name(context, sp, &spn);
1717 principalname2krb5_principal(&cp, tgt->cname, tgt->crealm);
1718 krb5_unparse_name(context, cp, &cpn);
1719 unparse_flags (KDCOptions2int(b->kdc_options), KDCOptions_units,
1720 opt_str, sizeof(opt_str));
1721 if(*opt_str)
1722 kdc_log(0, "TGS-REQ %s from %s for %s [%s]",
1723 cpn, from, spn, opt_str);
1724 else
1725 kdc_log(0, "TGS-REQ %s from %s for %s", cpn, from, spn);
1726 server_lookup:
1727 ret = db_fetch(sp, &server);
1728
1729 if(ret){
1730 Realm req_rlm, new_rlm;
1731 krb5_realm *realms;
1732
1733 if ((req_rlm = get_krbtgt_realm(&sp->name)) != NULL) {
1734 if(loop++ < 2) {
1735 new_rlm = find_rpath(tgt->crealm, req_rlm);
1736 if(new_rlm) {
1737 kdc_log(5, "krbtgt for realm %s not found, trying %s",
1738 req_rlm, new_rlm);
1739 krb5_free_principal(context, sp);
1740 free(spn);
1741 krb5_make_principal(context, &sp, r,
1742 KRB5_TGS_NAME, new_rlm, NULL);
1743 krb5_unparse_name(context, sp, &spn);
1744 goto server_lookup;
1745 }
1746 }
1747 } else if(need_referral(sp, &realms)) {
1748 if (strcmp(realms[0], sp->realm) != 0) {
1749 kdc_log(5, "returning a referral to realm %s for "
1750 "server %s that was not found",
1751 realms[0], spn);
1752 krb5_free_principal(context, sp);
1753 free(spn);
1754 krb5_make_principal(context, &sp, r, KRB5_TGS_NAME,
1755 realms[0], NULL);
1756 krb5_unparse_name(context, sp, &spn);
1757 krb5_free_host_realm(context, realms);
1758 goto server_lookup;
1759 }
1760 krb5_free_host_realm(context, realms);
1761 }
1762 kdc_log(0, "Server not found in database: %s: %s", spn,
1763 krb5_get_err_text(context, ret));
1764 if (ret == HDB_ERR_NOENTRY)
1765 ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1766 goto out;
1767 }
1768
1769 ret = db_fetch(cp, &client);
1770 if(ret)
1771 kdc_log(1, "Client not found in database: %s: %s",
1772 cpn, krb5_get_err_text(context, ret));
1773 #if 0
1774 /* XXX check client only if same realm as krbtgt-instance */
1775 if(ret){
1776 kdc_log(0, "Client not found in database: %s: %s",
1777 cpn, krb5_get_err_text(context, ret));
1778 if (ret == HDB_ERR_NOENTRY)
1779 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1780 goto out;
1781 }
1782 #endif
1783
1784 if(strcmp(krb5_principal_get_realm(context, sp),
1785 krb5_principal_get_comp_string(context, krbtgt->principal, 1)) != 0) {
1786 char *tpn;
1787 ret = krb5_unparse_name(context, krbtgt->principal, &tpn);
1788 kdc_log(0, "Request with wrong krbtgt: %s", (ret == 0) ? tpn : "<unknown>");
1789 if(ret == 0)
1790 free(tpn);
1791 ret = KRB5KRB_AP_ERR_NOT_US;
1792 goto out;
1793
1794 }
1795
1796 ret = check_flags(client, cpn, server, spn, FALSE);
1797 if(ret)
1798 goto out;
1799
1800 if((b->kdc_options.validate || b->kdc_options.renew) &&
1801 !krb5_principal_compare(context,
1802 krbtgt->principal,
1803 server->principal)){
1804 kdc_log(0, "Inconsistent request.");
1805 ret = KRB5KDC_ERR_SERVER_NOMATCH;
1806 goto out;
1807 }
1808
1809 /* check for valid set of addresses */
1810 if(!check_addresses(tgt->caddr, from_addr)) {
1811 ret = KRB5KRB_AP_ERR_BADADDR;
1812 kdc_log(0, "Request from wrong address");
1813 goto out;
1814 }
1815
1816 ret = tgs_make_reply(b,
1817 tgt,
1818 b->kdc_options.enc_tkt_in_skey ? &adtkt : NULL,
1819 auth_data,
1820 server,
1821 client,
1822 cp,
1823 krbtgt,
1824 cetype,
1825 &e_text,
1826 reply);
1827
1828 out:
1829 free(spn);
1830 free(cpn);
1831
1832 if(server)
1833 free_ent(server);
1834 if(client)
1835 free_ent(client);
1836 }
1837 out2:
1838 if(ret) {
1839 krb5_mk_error(context,
1840 ret,
1841 e_text,
1842 NULL,
1843 cp,
1844 sp,
1845 NULL,
1846 NULL,
1847 reply);
1848 free(*csec);
1849 free(*cusec);
1850 *csec = NULL;
1851 *cusec = NULL;
1852 }
1853 krb5_free_principal(context, cp);
1854 krb5_free_principal(context, sp);
1855 if (ticket) {
1856 krb5_free_ticket(context, ticket);
1857 free(ticket);
1858 }
1859 free_AP_REQ(&ap_req);
1860 if(auth_data){
1861 free_AuthorizationData(auth_data);
1862 free(auth_data);
1863 }
1864
1865 if(krbtgt)
1866 free_ent(krbtgt);
1867
1868 return ret;
1869 }
1870
1871
1872 krb5_error_code
1873 tgs_rep(KDC_REQ *req,
1874 krb5_data *data,
1875 const char *from,
1876 struct sockaddr *from_addr)
1877 {
1878 krb5_error_code ret;
1879 int i = 0;
1880 PA_DATA *tgs_req = NULL;
1881 time_t *csec = NULL;
1882 int *cusec = NULL;
1883
1884 if(req->padata == NULL){
1885 ret = KRB5KDC_ERR_PREAUTH_REQUIRED; /* XXX ??? */
1886 kdc_log(0, "TGS-REQ from %s without PA-DATA", from);
1887 goto out;
1888 }
1889
1890 tgs_req = find_padata(req, &i, KRB5_PADATA_TGS_REQ);
1891
1892 if(tgs_req == NULL){
1893 ret = KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
1894
1895 kdc_log(0, "TGS-REQ from %s without PA-TGS-REQ", from);
1896 goto out;
1897 }
1898 ret = tgs_rep2(&req->req_body, tgs_req, data, from, from_addr,
1899 &csec, &cusec);
1900 out:
1901 if(ret && data->data == NULL){
1902 krb5_mk_error(context,
1903 ret,
1904 NULL,
1905 NULL,
1906 NULL,
1907 NULL,
1908 csec,
1909 cusec,
1910 data);
1911 }
1912 free(csec);
1913 free(cusec);
1914 return 0;
1915 }
Heimdal