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