2 * Copyright (c) 1997-2006 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
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.
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
36 RCSID("$Id: kerberos5.c,v 1.231 2007/01/04 13:27:27 lha Exp $");
38 #define MAX_TIME ((time_t)((1U << 31) - 1))
41 _kdc_fix_time(time_t **t
)
47 if(**t
== 0) **t
= MAX_TIME
; /* fix for old clients */
51 realloc_method_data(METHOD_DATA
*md
)
54 pa
= realloc(md
->val
, (md
->len
+ 1) * sizeof(*md
->val
));
63 set_salt_padata (METHOD_DATA
*md
, Salt
*salt
)
66 realloc_method_data(md
);
67 md
->val
[md
->len
- 1].padata_type
= salt
->type
;
68 der_copy_octet_string(&salt
->salt
,
69 &md
->val
[md
->len
- 1].padata_value
);
74 _kdc_find_padata(KDC_REQ
*req
, int *start
, int type
)
76 while(*start
< req
->padata
->len
){
78 if(req
->padata
->val
[*start
- 1].padata_type
== type
)
79 return &req
->padata
->val
[*start
- 1];
85 * return the first appropriate key of `princ' in `ret_key'. Look for
86 * all the etypes in (`etypes', `len'), stopping as soon as we find
87 * one, but preferring one that has default salt
91 _kdc_find_etype(krb5_context context
, const hdb_entry_ex
*princ
,
92 krb5_enctype
*etypes
, unsigned len
,
93 Key
**ret_key
, krb5_enctype
*ret_etype
)
96 krb5_error_code ret
= KRB5KDC_ERR_ETYPE_NOSUPP
;
98 for(i
= 0; ret
!= 0 && i
< len
; i
++) {
101 if (krb5_enctype_valid(context
, etypes
[i
]) != 0)
104 while (hdb_next_enctype2key(context
, &princ
->entry
, etypes
[i
], &key
) == 0) {
105 if (key
->key
.keyvalue
.length
== 0) {
106 ret
= KRB5KDC_ERR_NULL_KEY
;
110 *ret_etype
= etypes
[i
];
112 if (key
->salt
== NULL
)
120 _kdc_make_anonymous_principalname (PrincipalName
*pn
)
122 pn
->name_type
= KRB5_NT_PRINCIPAL
;
123 pn
->name_string
.len
= 1;
124 pn
->name_string
.val
= malloc(sizeof(*pn
->name_string
.val
));
125 if (pn
->name_string
.val
== NULL
)
127 pn
->name_string
.val
[0] = strdup("anonymous");
128 if (pn
->name_string
.val
[0] == NULL
) {
129 free(pn
->name_string
.val
);
130 pn
->name_string
.val
= NULL
;
137 _kdc_log_timestamp(krb5_context context
,
138 krb5_kdc_configuration
*config
,
140 KerberosTime authtime
, KerberosTime
*starttime
,
141 KerberosTime endtime
, KerberosTime
*renew_till
)
143 char authtime_str
[100], starttime_str
[100],
144 endtime_str
[100], renewtime_str
[100];
146 krb5_format_time(context
, authtime
,
147 authtime_str
, sizeof(authtime_str
), TRUE
);
149 krb5_format_time(context
, *starttime
,
150 starttime_str
, sizeof(starttime_str
), TRUE
);
152 strlcpy(starttime_str
, "unset", sizeof(starttime_str
));
153 krb5_format_time(context
, endtime
,
154 endtime_str
, sizeof(endtime_str
), TRUE
);
156 krb5_format_time(context
, *renew_till
,
157 renewtime_str
, sizeof(renewtime_str
), TRUE
);
159 strlcpy(renewtime_str
, "unset", sizeof(renewtime_str
));
161 kdc_log(context
, config
, 5,
162 "%s authtime: %s starttime: %s endtime: %s renew till: %s",
163 type
, authtime_str
, starttime_str
, endtime_str
, renewtime_str
);
167 log_patypes(krb5_context context
,
168 krb5_kdc_configuration
*config
,
171 struct rk_strpool
*p
= NULL
;
175 for (i
= 0; i
< padata
->len
; i
++) {
176 switch(padata
->val
[i
].padata_type
) {
177 case KRB5_PADATA_PK_AS_REQ
:
178 p
= rk_strpoolprintf(p
, "PK-INIT(ietf)");
180 case KRB5_PADATA_PK_AS_REQ_WIN
:
181 p
= rk_strpoolprintf(p
, "PK-INIT(win2k)");
183 case KRB5_PADATA_PA_PK_OCSP_RESPONSE
:
184 p
= rk_strpoolprintf(p
, "OCSP");
186 case KRB5_PADATA_ENC_TIMESTAMP
:
187 p
= rk_strpoolprintf(p
, "encrypted-timestamp");
190 p
= rk_strpoolprintf(p
, "%d", padata
->val
[i
].padata_type
);
193 if (p
&& i
+ 1 < padata
->len
)
194 p
= rk_strpoolprintf(p
, ", ");
196 kdc_log(context
, config
, 0, "out of memory");
201 p
= rk_strpoolprintf(p
, "none");
203 str
= rk_strpoolcollect(p
);
204 kdc_log(context
, config
, 0, "Client sent patypes: %s", str
);
214 _kdc_encode_reply(krb5_context context
,
215 krb5_kdc_configuration
*config
,
216 KDC_REP
*rep
, const EncTicketPart
*et
, EncKDCRepPart
*ek
,
218 int skvno
, const EncryptionKey
*skey
,
219 int ckvno
, const EncryptionKey
*ckey
,
229 ASN1_MALLOC_ENCODE(EncTicketPart
, buf
, buf_size
, et
, &len
, ret
);
231 kdc_log(context
, config
, 0, "Failed to encode ticket: %s",
232 krb5_get_err_text(context
, ret
));
235 if(buf_size
!= len
) {
237 kdc_log(context
, config
, 0, "Internal error in ASN.1 encoder");
238 *e_text
= "KDC internal error";
239 return KRB5KRB_ERR_GENERIC
;
242 ret
= krb5_crypto_init(context
, skey
, etype
, &crypto
);
245 kdc_log(context
, config
, 0, "krb5_crypto_init failed: %s",
246 krb5_get_err_text(context
, ret
));
250 ret
= krb5_encrypt_EncryptedData(context
,
256 &rep
->ticket
.enc_part
);
258 krb5_crypto_destroy(context
, crypto
);
260 kdc_log(context
, config
, 0, "Failed to encrypt data: %s",
261 krb5_get_err_text(context
, ret
));
265 if(rep
->msg_type
== krb_as_rep
&& !config
->encode_as_rep_as_tgs_rep
)
266 ASN1_MALLOC_ENCODE(EncASRepPart
, buf
, buf_size
, ek
, &len
, ret
);
268 ASN1_MALLOC_ENCODE(EncTGSRepPart
, buf
, buf_size
, ek
, &len
, ret
);
270 kdc_log(context
, config
, 0, "Failed to encode KDC-REP: %s",
271 krb5_get_err_text(context
, ret
));
274 if(buf_size
!= len
) {
276 kdc_log(context
, config
, 0, "Internal error in ASN.1 encoder");
277 *e_text
= "KDC internal error";
278 return KRB5KRB_ERR_GENERIC
;
280 ret
= krb5_crypto_init(context
, ckey
, 0, &crypto
);
283 kdc_log(context
, config
, 0, "krb5_crypto_init failed: %s",
284 krb5_get_err_text(context
, ret
));
287 if(rep
->msg_type
== krb_as_rep
) {
288 krb5_encrypt_EncryptedData(context
,
290 KRB5_KU_AS_REP_ENC_PART
,
296 ASN1_MALLOC_ENCODE(AS_REP
, buf
, buf_size
, rep
, &len
, ret
);
298 krb5_encrypt_EncryptedData(context
,
300 KRB5_KU_TGS_REP_ENC_PART_SESSION
,
306 ASN1_MALLOC_ENCODE(TGS_REP
, buf
, buf_size
, rep
, &len
, ret
);
308 krb5_crypto_destroy(context
, crypto
);
310 kdc_log(context
, config
, 0, "Failed to encode KDC-REP: %s",
311 krb5_get_err_text(context
, ret
));
314 if(buf_size
!= len
) {
316 kdc_log(context
, config
, 0, "Internal error in ASN.1 encoder");
317 *e_text
= "KDC internal error";
318 return KRB5KRB_ERR_GENERIC
;
321 reply
->length
= buf_size
;
325 static krb5_error_code
326 make_etype_info_entry(krb5_context context
, ETYPE_INFO_ENTRY
*ent
, Key
*key
)
328 ent
->etype
= key
->key
.keytype
;
331 ALLOC(ent
->salttype
);
333 if(key
->salt
->type
== hdb_pw_salt
)
334 *ent
->salttype
= 0; /* or 1? or NULL? */
335 else if(key
->salt
->type
== hdb_afs3_salt
)
338 kdc_log(context
, config
, 0, "unknown salt-type: %d",
340 return KRB5KRB_ERR_GENERIC
;
342 /* according to `the specs', we can't send a salt if
343 we have AFS3 salted key, but that requires that you
344 *know* what cell you are using (e.g by assuming
345 that the cell is the same as the realm in lower
348 ALLOC(ent
->salttype
);
349 *ent
->salttype
= key
->salt
->type
;
352 * We shouldn't sent salttype since its incompatible with the
353 * specification and its break windows clients. The afs
354 * salting problem is solved by using KRB5-PADATA-AFS3-SALT
355 * implemented in Heimdal 0.7 and later.
357 ent
->salttype
= NULL
;
359 krb5_copy_data(context
, &key
->salt
->salt
,
362 /* we return no salt type at all, as that should indicate
363 * the default salt type and make everybody happy. some
364 * systems (like w2k) dislike being told the salt type
367 ent
->salttype
= NULL
;
373 static krb5_error_code
374 get_pa_etype_info(krb5_context context
,
375 krb5_kdc_configuration
*config
,
376 METHOD_DATA
*md
, hdb_entry
*client
,
377 ENCTYPE
*etypes
, unsigned int etypes_len
)
379 krb5_error_code ret
= 0;
387 pa
.len
= client
->keys
.len
;
388 if(pa
.len
> UINT_MAX
/sizeof(*pa
.val
))
390 pa
.val
= malloc(pa
.len
* sizeof(*pa
.val
));
393 memset(pa
.val
, 0, pa
.len
* sizeof(*pa
.val
));
395 for(j
= 0; j
< etypes_len
; j
++) {
396 for (i
= 0; i
< n
; i
++)
397 if (pa
.val
[i
].etype
== etypes
[j
])
399 for(i
= 0; i
< client
->keys
.len
; i
++) {
400 if(client
->keys
.val
[i
].key
.keytype
== etypes
[j
]) {
401 if (krb5_enctype_valid(context
, etypes
[j
]) != 0)
403 if((ret
= make_etype_info_entry(context
,
405 &client
->keys
.val
[i
])) != 0) {
406 free_ETYPE_INFO(&pa
);
413 for(i
= 0; i
< client
->keys
.len
; i
++) {
414 for(j
= 0; j
< etypes_len
; j
++) {
415 if(client
->keys
.val
[i
].key
.keytype
== etypes
[j
])
418 if (krb5_enctype_valid(context
, client
->keys
.val
[i
].key
.keytype
) != 0)
420 if((ret
= make_etype_info_entry(context
,
422 &client
->keys
.val
[i
])) != 0) {
423 free_ETYPE_INFO(&pa
);
431 ret
= krb5_unparse_name(context
, client
->principal
, &name
);
433 name
= rk_UNCONST("<unparse_name failed>");
434 kdc_log(context
, config
, 0, "internal error in get_pa_etype_info(%s): %d != %d",
441 ASN1_MALLOC_ENCODE(ETYPE_INFO
, buf
, len
, &pa
, &len
, ret
);
442 free_ETYPE_INFO(&pa
);
445 ret
= realloc_method_data(md
);
450 md
->val
[md
->len
- 1].padata_type
= KRB5_PADATA_ETYPE_INFO
;
451 md
->val
[md
->len
- 1].padata_value
.length
= len
;
452 md
->val
[md
->len
- 1].padata_value
.data
= buf
;
460 extern int _krb5_AES_string_to_default_iterator
;
462 static krb5_error_code
463 make_etype_info2_entry(ETYPE_INFO2_ENTRY
*ent
, Key
*key
)
465 ent
->etype
= key
->key
.keytype
;
468 if (ent
->salt
== NULL
)
470 *ent
->salt
= malloc(key
->salt
->salt
.length
+ 1);
471 if (*ent
->salt
== NULL
) {
476 memcpy(*ent
->salt
, key
->salt
->salt
.data
, key
->salt
->salt
.length
);
477 (*ent
->salt
)[key
->salt
->salt
.length
] = '\0';
481 ent
->s2kparams
= NULL
;
483 switch (key
->key
.keytype
) {
484 case ETYPE_AES128_CTS_HMAC_SHA1_96
:
485 case ETYPE_AES256_CTS_HMAC_SHA1_96
:
486 ALLOC(ent
->s2kparams
);
487 if (ent
->s2kparams
== NULL
)
489 ent
->s2kparams
->length
= 4;
490 ent
->s2kparams
->data
= malloc(ent
->s2kparams
->length
);
491 if (ent
->s2kparams
->data
== NULL
) {
492 free(ent
->s2kparams
);
493 ent
->s2kparams
= NULL
;
496 _krb5_put_int(ent
->s2kparams
->data
,
497 _krb5_AES_string_to_default_iterator
,
498 ent
->s2kparams
->length
);
500 case ETYPE_DES_CBC_CRC
:
501 case ETYPE_DES_CBC_MD4
:
502 case ETYPE_DES_CBC_MD5
:
503 /* Check if this was a AFS3 salted key */
504 if(key
->salt
&& key
->salt
->type
== hdb_afs3_salt
){
505 ALLOC(ent
->s2kparams
);
506 if (ent
->s2kparams
== NULL
)
508 ent
->s2kparams
->length
= 1;
509 ent
->s2kparams
->data
= malloc(ent
->s2kparams
->length
);
510 if (ent
->s2kparams
->data
== NULL
) {
511 free(ent
->s2kparams
);
512 ent
->s2kparams
= NULL
;
515 _krb5_put_int(ent
->s2kparams
->data
,
517 ent
->s2kparams
->length
);
527 * Return 1 if the client have only older enctypes, this is for
528 * determining if the server should send ETYPE_INFO2 or not.
532 only_older_enctype_p(const KDC_REQ
*req
)
536 for(i
= 0; i
< req
->req_body
.etype
.len
; i
++) {
537 switch (req
->req_body
.etype
.val
[i
]) {
538 case ETYPE_DES_CBC_CRC
:
539 case ETYPE_DES_CBC_MD4
:
540 case ETYPE_DES_CBC_MD5
:
541 case ETYPE_DES3_CBC_SHA1
:
542 case ETYPE_ARCFOUR_HMAC_MD5
:
543 case ETYPE_ARCFOUR_HMAC_MD5_56
:
556 static krb5_error_code
557 get_pa_etype_info2(krb5_context context
,
558 krb5_kdc_configuration
*config
,
559 METHOD_DATA
*md
, hdb_entry
*client
,
560 ENCTYPE
*etypes
, unsigned int etypes_len
)
562 krb5_error_code ret
= 0;
569 pa
.len
= client
->keys
.len
;
570 if(pa
.len
> UINT_MAX
/sizeof(*pa
.val
))
572 pa
.val
= malloc(pa
.len
* sizeof(*pa
.val
));
575 memset(pa
.val
, 0, pa
.len
* sizeof(*pa
.val
));
577 for(j
= 0; j
< etypes_len
; j
++) {
578 for (i
= 0; i
< n
; i
++)
579 if (pa
.val
[i
].etype
== etypes
[j
])
581 for(i
= 0; i
< client
->keys
.len
; i
++) {
582 if(client
->keys
.val
[i
].key
.keytype
== etypes
[j
]) {
583 if (krb5_enctype_valid(context
, etypes
[j
]) != 0)
585 if((ret
= make_etype_info2_entry(&pa
.val
[n
++],
586 &client
->keys
.val
[i
])) != 0) {
587 free_ETYPE_INFO2(&pa
);
594 for(i
= 0; i
< client
->keys
.len
; i
++) {
595 for(j
= 0; j
< etypes_len
; j
++) {
596 if(client
->keys
.val
[i
].key
.keytype
== etypes
[j
])
599 if (krb5_enctype_valid(context
, client
->keys
.val
[i
].key
.keytype
) != 0)
601 if((ret
= make_etype_info2_entry(&pa
.val
[n
++],
602 &client
->keys
.val
[i
])) != 0) {
603 free_ETYPE_INFO2(&pa
);
611 ret
= krb5_unparse_name(context
, client
->principal
, &name
);
613 name
= rk_UNCONST("<unparse_name failed>");
614 kdc_log(context
, config
, 0,
615 "internal error in get_pa_etype_info2(%s): %d != %d",
622 ASN1_MALLOC_ENCODE(ETYPE_INFO2
, buf
, len
, &pa
, &len
, ret
);
623 free_ETYPE_INFO2(&pa
);
626 ret
= realloc_method_data(md
);
631 md
->val
[md
->len
- 1].padata_type
= KRB5_PADATA_ETYPE_INFO2
;
632 md
->val
[md
->len
- 1].padata_value
.length
= len
;
633 md
->val
[md
->len
- 1].padata_value
.data
= buf
;
642 log_as_req(krb5_context context
,
643 krb5_kdc_configuration
*config
,
646 const KDC_REQ_BODY
*b
)
649 struct rk_strpool
*p
= NULL
;
653 for (i
= 0; i
< b
->etype
.len
; i
++) {
654 ret
= krb5_enctype_to_string(context
, b
->etype
.val
[i
], &str
);
656 p
= rk_strpoolprintf(p
, "%s", str
);
659 p
= rk_strpoolprintf(p
, "%d", b
->etype
.val
[i
]);
660 if (p
&& i
+ 1 < b
->etype
.len
)
661 p
= rk_strpoolprintf(p
, ", ");
663 kdc_log(context
, config
, 0, "out of memory");
668 p
= rk_strpoolprintf(p
, "no encryption types");
670 str
= rk_strpoolcollect(p
);
671 kdc_log(context
, config
, 0, "Client supported enctypes: %s", str
);
678 ret
= krb5_enctype_to_string(context
, cetype
, &cet
);
680 ret
= krb5_enctype_to_string(context
, setype
, &set
);
682 kdc_log(context
, config
, 5, "Using %s/%s", cet
, set
);
688 kdc_log(context
, config
, 5, "Using e-types %d/%d", cetype
, setype
);
693 unparse_flags(KDCOptions2int(b
->kdc_options
), asn1_KDCOptions_units(),
696 kdc_log(context
, config
, 2, "Requested flags: %s", _str
);
701 * verify the flags on `client' and `server', returning 0
702 * if they are OK and generating an error messages and returning
703 * and error code otherwise.
707 _kdc_check_flags(krb5_context context
,
708 krb5_kdc_configuration
*config
,
709 hdb_entry_ex
*client_ex
, const char *client_name
,
710 hdb_entry_ex
*server_ex
, const char *server_name
,
711 krb5_boolean is_as_req
)
713 if(client_ex
!= NULL
) {
714 hdb_entry
*client
= &client_ex
->entry
;
717 if (client
->flags
.invalid
) {
718 kdc_log(context
, config
, 0,
719 "Client (%s) has invalid bit set", client_name
);
720 return KRB5KDC_ERR_POLICY
;
723 if(!client
->flags
.client
){
724 kdc_log(context
, config
, 0,
725 "Principal may not act as client -- %s", client_name
);
726 return KRB5KDC_ERR_POLICY
;
729 if (client
->valid_start
&& *client
->valid_start
> kdc_time
) {
730 char starttime_str
[100];
731 krb5_format_time(context
, *client
->valid_start
,
732 starttime_str
, sizeof(starttime_str
), TRUE
);
733 kdc_log(context
, config
, 0,
734 "Client not yet valid until %s -- %s",
735 starttime_str
, client_name
);
736 return KRB5KDC_ERR_CLIENT_NOTYET
;
739 if (client
->valid_end
&& *client
->valid_end
< kdc_time
) {
740 char endtime_str
[100];
741 krb5_format_time(context
, *client
->valid_end
,
742 endtime_str
, sizeof(endtime_str
), TRUE
);
743 kdc_log(context
, config
, 0,
744 "Client expired at %s -- %s",
745 endtime_str
, client_name
);
746 return KRB5KDC_ERR_NAME_EXP
;
749 if (client
->pw_end
&& *client
->pw_end
< kdc_time
750 && (server_ex
== NULL
|| !server_ex
->entry
.flags
.change_pw
)) {
752 krb5_format_time(context
, *client
->pw_end
,
753 pwend_str
, sizeof(pwend_str
), TRUE
);
754 kdc_log(context
, config
, 0,
755 "Client's key has expired at %s -- %s",
756 pwend_str
, client_name
);
757 return KRB5KDC_ERR_KEY_EXPIRED
;
763 if (server_ex
!= NULL
) {
764 hdb_entry
*server
= &server_ex
->entry
;
766 if (server
->flags
.invalid
) {
767 kdc_log(context
, config
, 0,
768 "Server has invalid flag set -- %s", server_name
);
769 return KRB5KDC_ERR_POLICY
;
772 if(!server
->flags
.server
){
773 kdc_log(context
, config
, 0,
774 "Principal may not act as server -- %s", server_name
);
775 return KRB5KDC_ERR_POLICY
;
778 if(!is_as_req
&& server
->flags
.initial
) {
779 kdc_log(context
, config
, 0,
780 "AS-REQ is required for server -- %s", server_name
);
781 return KRB5KDC_ERR_POLICY
;
784 if (server
->valid_start
&& *server
->valid_start
> kdc_time
) {
785 char starttime_str
[100];
786 krb5_format_time(context
, *server
->valid_start
,
787 starttime_str
, sizeof(starttime_str
), TRUE
);
788 kdc_log(context
, config
, 0,
789 "Server not yet valid until %s -- %s",
790 starttime_str
, server_name
);
791 return KRB5KDC_ERR_SERVICE_NOTYET
;
794 if (server
->valid_end
&& *server
->valid_end
< kdc_time
) {
795 char endtime_str
[100];
796 krb5_format_time(context
, *server
->valid_end
,
797 endtime_str
, sizeof(endtime_str
), TRUE
);
798 kdc_log(context
, config
, 0,
799 "Server expired at %s -- %s",
800 endtime_str
, server_name
);
801 return KRB5KDC_ERR_SERVICE_EXP
;
804 if (server
->pw_end
&& *server
->pw_end
< kdc_time
) {
806 krb5_format_time(context
, *server
->pw_end
,
807 pwend_str
, sizeof(pwend_str
), TRUE
);
808 kdc_log(context
, config
, 0,
809 "Server's key has expired at -- %s",
810 pwend_str
, server_name
);
811 return KRB5KDC_ERR_KEY_EXPIRED
;
818 * Return TRUE if `from' is part of `addresses' taking into consideration
819 * the configuration variables that tells us how strict we should be about
824 _kdc_check_addresses(krb5_context context
,
825 krb5_kdc_configuration
*config
,
826 HostAddresses
*addresses
, const struct sockaddr
*from
)
831 krb5_boolean only_netbios
= TRUE
;
834 if(config
->check_ticket_addresses
== 0)
837 if(addresses
== NULL
)
838 return config
->allow_null_ticket_addresses
;
840 for (i
= 0; i
< addresses
->len
; ++i
) {
841 if (addresses
->val
[i
].addr_type
!= KRB5_ADDRESS_NETBIOS
) {
842 only_netbios
= FALSE
;
846 /* Windows sends it's netbios name, which I can only assume is
847 * used for the 'allowed workstations' check. This is painful,
848 * but we still want to check IP addresses if they happen to be
853 return config
->allow_null_ticket_addresses
;
855 ret
= krb5_sockaddr2address (context
, from
, &addr
);
859 result
= krb5_address_search(context
, &addr
, addresses
);
860 krb5_free_address (context
, &addr
);
869 send_pac_p(krb5_context context
, KDC_REQ
*req
)
872 PA_PAC_REQUEST pacreq
;
876 pa
= _kdc_find_padata(req
, &i
, KRB5_PADATA_PA_PAC_REQUEST
);
880 ret
= decode_PA_PAC_REQUEST(pa
->padata_value
.data
,
881 pa
->padata_value
.length
,
886 i
= pacreq
.include_pac
;
887 free_PA_PAC_REQUEST(&pacreq
);
898 _kdc_as_rep(krb5_context context
,
899 krb5_kdc_configuration
*config
,
901 const krb5_data
*req_buffer
,
904 struct sockaddr
*from_addr
,
907 KDC_REQ_BODY
*b
= &req
->req_body
;
909 KDCOptions f
= b
->kdc_options
;
910 hdb_entry_ex
*client
= NULL
, *server
= NULL
;
911 krb5_enctype cetype
, setype
, sessionetype
;
914 krb5_principal client_princ
= NULL
, server_princ
= NULL
;
915 char *client_name
= NULL
, *server_name
= NULL
;
916 krb5_error_code ret
= 0;
917 const char *e_text
= NULL
;
921 EncryptionKey
*reply_key
;
923 pk_client_params
*pkp
= NULL
;
926 memset(&rep
, 0, sizeof(rep
));
927 memset(&e_data
, 0, sizeof(e_data
));
929 if(b
->sname
== NULL
){
930 ret
= KRB5KRB_ERR_GENERIC
;
931 e_text
= "No server in request";
933 _krb5_principalname2krb5_principal (context
,
937 ret
= krb5_unparse_name(context
, server_princ
, &server_name
);
940 kdc_log(context
, config
, 0,
941 "AS-REQ malformed server name from %s", from
);
945 if(b
->cname
== NULL
){
946 ret
= KRB5KRB_ERR_GENERIC
;
947 e_text
= "No client in request";
949 _krb5_principalname2krb5_principal (context
,
953 ret
= krb5_unparse_name(context
, client_princ
, &client_name
);
956 kdc_log(context
, config
, 0,
957 "AS-REQ malformed client name from %s", from
);
961 kdc_log(context
, config
, 0, "AS-REQ %s from %s for %s",
962 client_name
, from
, server_name
);
964 ret
= _kdc_db_fetch(context
, config
, client_princ
,
965 HDB_F_GET_CLIENT
, NULL
, &client
);
967 kdc_log(context
, config
, 0, "UNKNOWN -- %s: %s", client_name
,
968 krb5_get_err_text(context
, ret
));
969 ret
= KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN
;
973 ret
= _kdc_db_fetch(context
, config
, server_princ
,
974 HDB_F_GET_SERVER
|HDB_F_GET_KRBTGT
,
977 kdc_log(context
, config
, 0, "UNKNOWN -- %s: %s", server_name
,
978 krb5_get_err_text(context
, ret
));
979 ret
= KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN
;
983 ret
= _kdc_windc_client_access(context
, client
, req
);
987 ret
= _kdc_check_flags(context
, config
,
994 memset(&et
, 0, sizeof(et
));
995 memset(&ek
, 0, sizeof(ek
));
1002 log_patypes(context
, config
, req
->padata
);
1005 kdc_log(context
, config
, 5,
1006 "Looking for PKINIT pa-data -- %s", client_name
);
1008 e_text
= "No PKINIT PA found";
1011 if ((pa
= _kdc_find_padata(req
, &i
, KRB5_PADATA_PK_AS_REQ
)))
1015 if((pa
= _kdc_find_padata(req
, &i
, KRB5_PADATA_PK_AS_REQ_WIN
)))
1019 char *client_cert
= NULL
;
1021 ret
= _kdc_pk_rd_padata(context
, config
, req
, pa
, &pkp
);
1023 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
1024 kdc_log(context
, config
, 5,
1025 "Failed to decode PKINIT PA-DATA -- %s",
1029 if (ret
== 0 && pkp
== NULL
)
1032 ret
= _kdc_pk_check_client(context
,
1038 e_text
= "PKINIT certificate not allowed to "
1039 "impersonate principal";
1040 _kdc_pk_free_client_param(context
, pkp
);
1042 kdc_log(context
, config
, 0, "%s", e_text
);
1047 et
.flags
.pre_authent
= 1;
1048 kdc_log(context
, config
, 0,
1049 "PKINIT pre-authentication succeeded -- %s using %s",
1050 client_name
, client_cert
);
1057 kdc_log(context
, config
, 5, "Looking for ENC-TS pa-data -- %s",
1061 e_text
= "No ENC-TS found";
1062 while((pa
= _kdc_find_padata(req
, &i
, KRB5_PADATA_ENC_TIMESTAMP
))){
1066 EncryptedData enc_data
;
1072 ret
= decode_EncryptedData(pa
->padata_value
.data
,
1073 pa
->padata_value
.length
,
1077 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
1078 kdc_log(context
, config
, 5, "Failed to decode PA-DATA -- %s",
1083 ret
= hdb_enctype2key(context
, &client
->entry
,
1084 enc_data
.etype
, &pa_key
);
1087 e_text
= "No key matches pa-data";
1088 ret
= KRB5KDC_ERR_ETYPE_NOSUPP
;
1089 if(krb5_enctype_to_string(context
, enc_data
.etype
, &estr
))
1092 kdc_log(context
, config
, 5,
1093 "No client key matching pa-data (%d) -- %s",
1094 enc_data
.etype
, client_name
);
1096 kdc_log(context
, config
, 5,
1097 "No client key matching pa-data (%s) -- %s",
1101 free_EncryptedData(&enc_data
);
1106 ret
= krb5_crypto_init(context
, &pa_key
->key
, 0, &crypto
);
1108 kdc_log(context
, config
, 0, "krb5_crypto_init failed: %s",
1109 krb5_get_err_text(context
, ret
));
1110 free_EncryptedData(&enc_data
);
1114 ret
= krb5_decrypt_EncryptedData (context
,
1116 KRB5_KU_PA_ENC_TIMESTAMP
,
1119 krb5_crypto_destroy(context
, crypto
);
1121 krb5_error_code ret2
;
1122 ret2
= krb5_enctype_to_string(context
,
1123 pa_key
->key
.keytype
, &str
);
1126 kdc_log(context
, config
, 5,
1127 "Failed to decrypt PA-DATA -- %s "
1128 "(enctype %s) error %s",
1130 str
? str
: "unknown enctype",
1131 krb5_get_err_text(context
, ret
));
1134 if(hdb_next_enctype2key(context
, &client
->entry
,
1135 enc_data
.etype
, &pa_key
) == 0)
1137 e_text
= "Failed to decrypt PA-DATA";
1139 free_EncryptedData(&enc_data
);
1140 ret
= KRB5KDC_ERR_PREAUTH_FAILED
;
1143 free_EncryptedData(&enc_data
);
1144 ret
= decode_PA_ENC_TS_ENC(ts_data
.data
,
1148 krb5_data_free(&ts_data
);
1150 e_text
= "Failed to decode PA-ENC-TS-ENC";
1151 ret
= KRB5KDC_ERR_PREAUTH_FAILED
;
1152 kdc_log(context
, config
,
1153 5, "Failed to decode PA-ENC-TS_ENC -- %s",
1157 free_PA_ENC_TS_ENC(&p
);
1158 if (abs(kdc_time
- p
.patimestamp
) > context
->max_skew
) {
1159 char client_time
[100];
1161 krb5_format_time(context
, p
.patimestamp
,
1162 client_time
, sizeof(client_time
), TRUE
);
1164 ret
= KRB5KRB_AP_ERR_SKEW
;
1165 kdc_log(context
, config
, 0,
1166 "Too large time skew, "
1167 "client time %s is out by %u > %u seconds -- %s",
1169 (unsigned)abs(kdc_time
- p
.patimestamp
),
1173 * the following is needed to make windows clients
1174 * to retry using the timestamp in the error message
1176 * this is maybe a bug in windows to not trying when e_text
1182 et
.flags
.pre_authent
= 1;
1184 ret
= krb5_enctype_to_string(context
,pa_key
->key
.keytype
, &str
);
1188 kdc_log(context
, config
, 2,
1189 "ENC-TS Pre-authentication succeeded -- %s using %s",
1190 client_name
, str
? str
: "unknown enctype");
1197 if(found_pa
== 0 && config
->require_preauth
)
1199 /* We come here if we found a pa-enc-timestamp, but if there
1200 was some problem with it, other than too large skew */
1201 if(found_pa
&& et
.flags
.pre_authent
== 0){
1202 kdc_log(context
, config
, 0, "%s -- %s", e_text
, client_name
);
1206 }else if (config
->require_preauth
1207 || client
->entry
.flags
.require_preauth
1208 || server
->entry
.flags
.require_preauth
) {
1209 METHOD_DATA method_data
;
1215 method_data
.len
= 0;
1216 method_data
.val
= NULL
;
1218 ret
= realloc_method_data(&method_data
);
1219 pa
= &method_data
.val
[method_data
.len
-1];
1220 pa
->padata_type
= KRB5_PADATA_ENC_TIMESTAMP
;
1221 pa
->padata_value
.length
= 0;
1222 pa
->padata_value
.data
= NULL
;
1225 ret
= realloc_method_data(&method_data
);
1226 pa
= &method_data
.val
[method_data
.len
-1];
1227 pa
->padata_type
= KRB5_PADATA_PK_AS_REQ
;
1228 pa
->padata_value
.length
= 0;
1229 pa
->padata_value
.data
= NULL
;
1234 * - If the client only knows about old enctypes, then send
1235 * both info replies (we send 'info' first in the list).
1236 * - If the client is 'modern', because it knows about 'new'
1237 * enctype types, then only send the 'info2' reply.
1241 if (only_older_enctype_p(req
))
1242 ret
= get_pa_etype_info(context
, config
,
1243 &method_data
, &client
->entry
,
1244 b
->etype
.val
, b
->etype
.len
);
1246 ret
= get_pa_etype_info2(context
, config
, &method_data
,
1247 &client
->entry
, b
->etype
.val
, b
->etype
.len
);
1250 ASN1_MALLOC_ENCODE(METHOD_DATA
, buf
, len
, &method_data
, &len
, ret
);
1251 free_METHOD_DATA(&method_data
);
1254 e_data
.length
= len
;
1255 e_text
="Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ",
1256 ret
= KRB5KDC_ERR_PREAUTH_REQUIRED
;
1258 kdc_log(context
, config
, 0,
1259 "No preauth found, returning PREAUTH-REQUIRED -- %s",
1266 * Find the client key (for preauth ENC-TS verification and reply
1267 * encryption). Then the best encryption type for the KDC and
1268 * last the best session key that shared between the client and
1269 * KDC runtime enctypes.
1272 ret
= _kdc_find_etype(context
, client
, b
->etype
.val
, b
->etype
.len
,
1275 kdc_log(context
, config
, 0,
1276 "Client (%s) has no support for etypes", client_name
);
1280 ret
= _kdc_get_preferred_key(context
, config
,
1281 server
, server_name
,
1287 const krb5_enctype
*p
;
1290 p
= krb5_kerberos_enctypes(context
);
1292 sessionetype
= ETYPE_NULL
;
1294 for (i
= 0; p
[i
] != ETYPE_NULL
&& sessionetype
== ETYPE_NULL
; i
++) {
1295 /* check it's valid */
1296 if (krb5_enctype_valid(context
, p
[i
]) != 0)
1299 /* check if the client supports it */
1300 for (j
= 0; j
< b
->etype
.len
&& sessionetype
== ETYPE_NULL
; j
++) {
1301 if (p
[i
] == b
->etype
.val
[j
]) {
1303 * if the server (krbtgt) has explicit etypes,
1304 * check if it also supports it
1306 if (server
->entry
.etypes
) {
1307 for (y
= 0; y
< server
->entry
.etypes
->len
; y
++) {
1308 if (p
[i
] == server
->entry
.etypes
->val
[y
]) {
1309 sessionetype
= p
[i
];
1314 sessionetype
= p
[i
];
1320 if (sessionetype
== ETYPE_NULL
) {
1321 kdc_log(context
, config
, 0,
1322 "Client (%s) from %s has no common enctypes with KDC"
1323 "to use for the session key",
1329 log_as_req(context
, config
, cetype
, setype
, b
);
1331 if(f
.renew
|| f
.validate
|| f
.proxy
|| f
.forwarded
|| f
.enc_tkt_in_skey
1332 || (f
.request_anonymous
&& !config
->allow_anonymous
)) {
1333 ret
= KRB5KDC_ERR_BADOPTION
;
1334 kdc_log(context
, config
, 0, "Bad KDC options -- %s", client_name
);
1339 rep
.msg_type
= krb_as_rep
;
1340 copy_Realm(&client
->entry
.principal
->realm
, &rep
.crealm
);
1341 if (f
.request_anonymous
)
1342 _kdc_make_anonymous_principalname (&rep
.cname
);
1344 _krb5_principal2principalname(&rep
.cname
,
1345 client
->entry
.principal
);
1346 rep
.ticket
.tkt_vno
= 5;
1347 copy_Realm(&server
->entry
.principal
->realm
, &rep
.ticket
.realm
);
1348 _krb5_principal2principalname(&rep
.ticket
.sname
,
1349 server
->entry
.principal
);
1351 et
.flags
.initial
= 1;
1352 if(client
->entry
.flags
.forwardable
&& server
->entry
.flags
.forwardable
)
1353 et
.flags
.forwardable
= f
.forwardable
;
1354 else if (f
.forwardable
) {
1355 ret
= KRB5KDC_ERR_POLICY
;
1356 kdc_log(context
, config
, 0,
1357 "Ticket may not be forwardable -- %s", client_name
);
1360 if(client
->entry
.flags
.proxiable
&& server
->entry
.flags
.proxiable
)
1361 et
.flags
.proxiable
= f
.proxiable
;
1362 else if (f
.proxiable
) {
1363 ret
= KRB5KDC_ERR_POLICY
;
1364 kdc_log(context
, config
, 0,
1365 "Ticket may not be proxiable -- %s", client_name
);
1368 if(client
->entry
.flags
.postdate
&& server
->entry
.flags
.postdate
)
1369 et
.flags
.may_postdate
= f
.allow_postdate
;
1370 else if (f
.allow_postdate
){
1371 ret
= KRB5KDC_ERR_POLICY
;
1372 kdc_log(context
, config
, 0,
1373 "Ticket may not be postdatable -- %s", client_name
);
1377 /* check for valid set of addresses */
1378 if(!_kdc_check_addresses(context
, config
, b
->addresses
, from_addr
)) {
1379 ret
= KRB5KRB_AP_ERR_BADADDR
;
1380 kdc_log(context
, config
, 0,
1381 "Bad address list requested -- %s", client_name
);
1385 ret
= krb5_generate_random_keyblock(context
, sessionetype
, &et
.key
);
1388 copy_PrincipalName(&rep
.cname
, &et
.cname
);
1389 copy_Realm(&rep
.crealm
, &et
.crealm
);
1395 start
= et
.authtime
= kdc_time
;
1397 if(f
.postdated
&& req
->req_body
.from
){
1398 ALLOC(et
.starttime
);
1399 start
= *et
.starttime
= *req
->req_body
.from
;
1400 et
.flags
.invalid
= 1;
1401 et
.flags
.postdated
= 1; /* XXX ??? */
1403 _kdc_fix_time(&b
->till
);
1406 /* be careful not overflowing */
1408 if(client
->entry
.max_life
)
1409 t
= start
+ min(t
- start
, *client
->entry
.max_life
);
1410 if(server
->entry
.max_life
)
1411 t
= start
+ min(t
- start
, *server
->entry
.max_life
);
1413 t
= min(t
, start
+ realm
->max_life
);
1416 if(f
.renewable_ok
&& et
.endtime
< *b
->till
){
1418 if(b
->rtime
== NULL
){
1422 if(*b
->rtime
< *b
->till
)
1423 *b
->rtime
= *b
->till
;
1425 if(f
.renewable
&& b
->rtime
){
1429 if(client
->entry
.max_renew
)
1430 t
= start
+ min(t
- start
, *client
->entry
.max_renew
);
1431 if(server
->entry
.max_renew
)
1432 t
= start
+ min(t
- start
, *server
->entry
.max_renew
);
1434 t
= min(t
, start
+ realm
->max_renew
);
1436 ALLOC(et
.renew_till
);
1438 et
.flags
.renewable
= 1;
1442 if (f
.request_anonymous
)
1443 et
.flags
.anonymous
= 1;
1447 copy_HostAddresses(b
->addresses
, et
.caddr
);
1450 et
.transited
.tr_type
= DOMAIN_X500_COMPRESS
;
1451 krb5_data_zero(&et
.transited
.contents
);
1453 copy_EncryptionKey(&et
.key
, &ek
.key
);
1455 /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
1456 * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
1457 * incapable of correctly decoding SEQUENCE OF's of zero length.
1459 * To fix this, always send at least one no-op last_req
1461 * If there's a pw_end or valid_end we will use that,
1462 * otherwise just a dummy lr.
1464 ek
.last_req
.val
= malloc(2 * sizeof(*ek
.last_req
.val
));
1465 ek
.last_req
.len
= 0;
1466 if (client
->entry
.pw_end
1467 && (config
->kdc_warn_pwexpire
== 0
1468 || kdc_time
+ config
->kdc_warn_pwexpire
>= *client
->entry
.pw_end
)) {
1469 ek
.last_req
.val
[ek
.last_req
.len
].lr_type
= LR_PW_EXPTIME
;
1470 ek
.last_req
.val
[ek
.last_req
.len
].lr_value
= *client
->entry
.pw_end
;
1473 if (client
->entry
.valid_end
) {
1474 ek
.last_req
.val
[ek
.last_req
.len
].lr_type
= LR_ACCT_EXPTIME
;
1475 ek
.last_req
.val
[ek
.last_req
.len
].lr_value
= *client
->entry
.valid_end
;
1478 if (ek
.last_req
.len
== 0) {
1479 ek
.last_req
.val
[ek
.last_req
.len
].lr_type
= LR_NONE
;
1480 ek
.last_req
.val
[ek
.last_req
.len
].lr_value
= 0;
1483 ek
.nonce
= b
->nonce
;
1484 if (client
->entry
.valid_end
|| client
->entry
.pw_end
) {
1485 ALLOC(ek
.key_expiration
);
1486 if (client
->entry
.valid_end
) {
1487 if (client
->entry
.pw_end
)
1488 *ek
.key_expiration
= min(*client
->entry
.valid_end
,
1489 *client
->entry
.pw_end
);
1491 *ek
.key_expiration
= *client
->entry
.valid_end
;
1493 *ek
.key_expiration
= *client
->entry
.pw_end
;
1495 ek
.key_expiration
= NULL
;
1496 ek
.flags
= et
.flags
;
1497 ek
.authtime
= et
.authtime
;
1499 ALLOC(ek
.starttime
);
1500 *ek
.starttime
= *et
.starttime
;
1502 ek
.endtime
= et
.endtime
;
1503 if (et
.renew_till
) {
1504 ALLOC(ek
.renew_till
);
1505 *ek
.renew_till
= *et
.renew_till
;
1507 copy_Realm(&rep
.ticket
.realm
, &ek
.srealm
);
1508 copy_PrincipalName(&rep
.ticket
.sname
, &ek
.sname
);
1511 copy_HostAddresses(et
.caddr
, ek
.caddr
);
1515 rep
.padata
->len
= 0;
1516 rep
.padata
->val
= NULL
;
1518 reply_key
= &ckey
->key
;
1521 ret
= _kdc_pk_mk_pa_reply(context
, config
, pkp
, client
,
1523 &reply_key
, rep
.padata
);
1526 ret
= _kdc_add_inital_verified_cas(context
,
1535 set_salt_padata (rep
.padata
, ckey
->salt
);
1537 if (rep
.padata
->len
== 0) {
1543 if (send_pac_p(context
, req
)) {
1547 ret
= _kdc_pac_generate(context
, client
, &p
);
1549 kdc_log(context
, config
, 0, "PAC generation failed for -- %s",
1554 ret
= _krb5_pac_sign(context
, p
, et
.authtime
,
1555 client
->entry
.principal
,
1556 &skey
->key
, /* Server key */
1557 &skey
->key
, /* FIXME: should be krbtgt key */
1559 krb5_pac_free(context
, p
);
1561 kdc_log(context
, config
, 0, "PAC signing failed for -- %s",
1566 ret
= _kdc_tkt_add_if_relevant_ad(context
, &et
,
1567 KRB5_AUTHDATA_WIN2K_PAC
,
1569 krb5_data_free(&data
);
1575 _kdc_log_timestamp(context
, config
, "AS-REQ", et
.authtime
, et
.starttime
,
1576 et
.endtime
, et
.renew_till
);
1578 /* do this as the last thing since this signs the EncTicketPart */
1579 ret
= _kdc_add_KRB5SignedPath(context
,
1589 ret
= _kdc_encode_reply(context
, config
,
1590 &rep
, &et
, &ek
, setype
, server
->entry
.kvno
,
1591 &skey
->key
, client
->entry
.kvno
,
1592 reply_key
, &e_text
, reply
);
1593 free_EncTicketPart(&et
);
1594 free_EncKDCRepPart(&ek
);
1599 if (datagram_reply
&& reply
->length
> config
->max_datagram_reply_length
) {
1600 krb5_data_free(reply
);
1601 ret
= KRB5KRB_ERR_RESPONSE_TOO_BIG
;
1602 e_text
= "Reply packet too large";
1608 krb5_mk_error(context
,
1611 (e_data
.data
? &e_data
: NULL
),
1621 _kdc_pk_free_client_param(context
, pkp
);
1626 krb5_free_principal(context
, client_princ
);
1629 krb5_free_principal(context
, server_princ
);
1632 _kdc_free_ent(context
, client
);
1634 _kdc_free_ent(context
, server
);
1639 * Add the AuthorizationData `data´ of `type´ to the last element in
1640 * the sequence of authorization_data in `tkt´ wrapped in an IF_RELEVANT
1644 _kdc_tkt_add_if_relevant_ad(krb5_context context
,
1647 const krb5_data
*data
)
1649 krb5_error_code ret
;
1652 if (tkt
->authorization_data
== NULL
) {
1653 tkt
->authorization_data
= calloc(1, sizeof(*tkt
->authorization_data
));
1654 if (tkt
->authorization_data
== NULL
) {
1655 krb5_set_error_string(context
, "out of memory");
1660 /* add the entry to the last element */
1662 AuthorizationData ad
= { 0, NULL
};
1663 AuthorizationDataElement ade
;
1666 ade
.ad_data
= *data
;
1668 ret
= add_AuthorizationData(&ad
, &ade
);
1670 krb5_set_error_string(context
, "add AuthorizationData failed");
1674 ade
.ad_type
= KRB5_AUTHDATA_IF_RELEVANT
;
1676 ASN1_MALLOC_ENCODE(AuthorizationData
,
1677 ade
.ad_data
.data
, ade
.ad_data
.length
,
1679 free_AuthorizationData(&ad
);
1681 krb5_set_error_string(context
, "ASN.1 encode of "
1682 "AuthorizationData failed");
1685 if (ade
.ad_data
.length
!= size
)
1686 krb5_abortx(context
, "internal asn.1 encoder error");
1688 ret
= add_AuthorizationData(tkt
->authorization_data
, &ade
);
1689 der_free_octet_string(&ade
.ad_data
);
1691 krb5_set_error_string(context
, "add AuthorizationData failed");