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