kdc/kerberos5.c

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