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