kdc/kerberos5.c

   1 /*
   2  * Copyright (c) 1997-2007 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "kdc_locl.h"
  35
  36 #define MAX_TIME ((time_t)((1U << 31) - 1))
  37
  38 void
  39 _kdc_fix_time(time_t **t)
  40 {
  41     if(*t == NULL){
  42         ALLOC(*t);
  43         **t = MAX_TIME;
  44     }
  45     if(**t == 0) **t = MAX_TIME; /* fix for old clients */
  46 }
  47
  48 static int
  49 realloc_method_data(METHOD_DATA *md)
  50 {
  51     PA_DATA *pa;
  52     pa = realloc(md->val, (md->len + 1) * sizeof(*md->val));
  53     if(pa == NULL)
  54         return ENOMEM;
  55     md->val = pa;
  56     md->len++;
  57     return 0;
  58 }
  59
  60 static void
  61 set_salt_padata(METHOD_DATA *md, Salt *salt)
  62 {
  63     if (salt) {
  64        realloc_method_data(md);
  65        md->val[md->len - 1].padata_type = salt->type;
  66        der_copy_octet_string(&salt->salt,
  67                              &md->val[md->len - 1].padata_value);
  68     }
  69 }
  70
  71 const PA_DATA*
  72 _kdc_find_padata(const KDC_REQ *req, int *start, int type)
  73 {
  74     if (req->padata == NULL)
  75         return NULL;
  76
  77     while((size_t)*start < req->padata->len){
  78         (*start)++;
  79         if(req->padata->val[*start - 1].padata_type == (unsigned)type)
  80             return &req->padata->val[*start - 1];
  81     }
  82     return NULL;
  83 }
  84
  85 /*
  86  * This is a hack to allow predefined weak services, like afs to
  87  * still use weak types
  88  */
  89
  90 krb5_boolean
  91 _kdc_is_weak_exception(krb5_principal principal, krb5_enctype etype)
  92 {
  93     if (principal->name.name_string.len > 0 &&
  94         strcmp(principal->name.name_string.val[0], "afs") == 0 &&
  95         (etype == (krb5_enctype)ETYPE_DES_CBC_CRC
  96          || etype == (krb5_enctype)ETYPE_DES_CBC_MD4
  97          || etype == (krb5_enctype)ETYPE_DES_CBC_MD5))
  98         return TRUE;
  99     return FALSE;
 100 }
 101
 102
 103 /*
 104  * Detect if `key' is the using the the precomputed `default_salt'.
 105  */
 106
 107 static krb5_boolean
 108 is_default_salt_p(const krb5_salt *default_salt, const Key *key)
 109 {
 110     if (key->salt == NULL)
 111         return TRUE;
 112     if (default_salt->salttype != key->salt->type)
 113         return FALSE;
 114     if (krb5_data_cmp(&default_salt->saltvalue, &key->salt->salt))
 115         return FALSE;
 116     return TRUE;
 117 }
 118
 119 /*
 120  * return the first appropriate key of `princ' in `ret_key'.  Look for
 121  * all the etypes in (`etypes', `len'), stopping as soon as we find
 122  * one, but preferring one that has default salt.
 123  */
 124
 125 krb5_error_code
 126 _kdc_find_etype(krb5_context context, krb5_boolean use_strongest_session_key,
 127                 krb5_boolean is_preauth, hdb_entry_ex *princ,
 128                 krb5_principal request_princ, krb5_enctype *etypes, unsigned len,
 129                 krb5_enctype *ret_enctype, Key **ret_key,
 130                 krb5_boolean *ret_default_salt)
 131 {
 132     krb5_error_code ret;
 133     krb5_salt def_salt;
 134     krb5_enctype enctype = (krb5_enctype)ETYPE_NULL;
 135     const krb5_enctype *p;
 136     Key *key = NULL;
 137     int i, k;
 138
 139     /* We'll want to avoid keys with v4 salted keys in the pre-auth case... */
 140     ret = krb5_get_pw_salt(context, request_princ, &def_salt);
 141     if (ret)
 142         return ret;
 143
 144     ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 145
 146     if (use_strongest_session_key) {
 147
 148         /*
 149          * Pick the strongest key that the KDC, target service, and
 150          * client all support, using the local cryptosystem enctype
 151          * list in strongest-to-weakest order to drive the search.
 152          *
 153          * This is not what RFC4120 says to do, but it encourages
 154          * adoption of stronger enctypes.  This doesn't play well with
 155          * clients that have multiple Kerberos client implementations
 156          * available with different supported enctype lists.
 157          */
 158
 159         /* drive the search with local supported enctypes list */
 160         p = krb5_kerberos_enctypes(context);
 161         for (i = 0;
 162             p[i] != (krb5_enctype)ETYPE_NULL && enctype == (krb5_enctype)ETYPE_NULL;
 163             i++) {
 164             if (krb5_enctype_valid(context, p[i]) != 0 &&
 165                 !_kdc_is_weak_exception(princ->entry.principal, p[i]))
 166                 continue;
 167
 168             /* check that the client supports it too */
 169             for (k = 0; k < len && enctype == (krb5_enctype)ETYPE_NULL; k++) {
 170
 171                 if (p[i] != etypes[k])
 172                     continue;
 173
 174                 /* check target princ support */
 175                 key = NULL;
 176                 while (hdb_next_enctype2key(context, &princ->entry, NULL,
 177                                              p[i], &key) == 0) {
 178                     if (key->key.keyvalue.length == 0) {
 179                         ret = KRB5KDC_ERR_NULL_KEY;
 180                         continue;
 181                     }
 182                     enctype = p[i];
 183                     ret = 0;
 184                     if (is_preauth && ret_key != NULL &&
 185                         !is_default_salt_p(&def_salt, key))
 186                         continue;
 187                 }
 188             }
 189         }
 190     } else {
 191         /*
 192          * Pick the first key from the client's enctype list that is
 193          * supported by the cryptosystem and by the given principal.
 194          *
 195          * RFC4120 says we SHOULD pick the first _strong_ key from the
 196          * client's list... not the first key...  If the admin disallows
 197          * weak enctypes in krb5.conf and selects this key selection
 198          * algorithm, then we get exactly what RFC4120 says.
 199          */
 200         for(i = 0; ret != 0 && i < len; i++) {
 201
 202             if (krb5_enctype_valid(context, etypes[i]) != 0 &&
 203                 !_kdc_is_weak_exception(princ->entry.principal, etypes[i]))
 204                 continue;
 205
 206             key = NULL;
 207             while (ret != 0 &&
 208                    hdb_next_enctype2key(context, &princ->entry, NULL,
 209                                         etypes[i], &key) == 0) {
 210                 if (key->key.keyvalue.length == 0) {
 211                     ret = KRB5KDC_ERR_NULL_KEY;
 212                     continue;
 213                 }
 214                 enctype = etypes[i];
 215                 ret = 0;
 216                 if (is_preauth && ret_key != NULL &&
 217                     !is_default_salt_p(&def_salt, key))
 218                     continue;
 219             }
 220         }
 221     }
 222
 223     if (enctype == (krb5_enctype)ETYPE_NULL) {
 224         /*
 225          * if the service principal is one for which there is a known 1DES
 226          * exception and no other enctype matches both the client request and
 227          * the service key list, provide a DES-CBC-CRC key.
 228          */
 229         if (ret_key == NULL &&
 230             _kdc_is_weak_exception(princ->entry.principal, ETYPE_DES_CBC_CRC)) {
 231             ret = 0;
 232             enctype = ETYPE_DES_CBC_CRC;
 233         } else {
 234             ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 235         }
 236     }
 237
 238     if (ret == 0) {
 239         if (ret_enctype != NULL)
 240             *ret_enctype = enctype;
 241         if (ret_key != NULL)
 242             *ret_key = key;
 243         if (ret_default_salt != NULL)
 244             *ret_default_salt = is_default_salt_p(&def_salt, key);
 245     }
 246
 247     krb5_free_salt (context, def_salt);
 248     return ret;
 249 }
 250
 251 krb5_error_code
 252 _kdc_make_anonymous_principalname (PrincipalName *pn)
 253 {
 254     pn->name_type = KRB5_NT_PRINCIPAL;
 255     pn->name_string.len = 1;
 256     pn->name_string.val = malloc(sizeof(*pn->name_string.val));
 257     if (pn->name_string.val == NULL)
 258         return ENOMEM;
 259     pn->name_string.val[0] = strdup("anonymous");
 260     if (pn->name_string.val[0] == NULL) {
 261         free(pn->name_string.val);
 262         pn->name_string.val = NULL;
 263         return ENOMEM;
 264     }
 265     return 0;
 266 }
 267
 268 static void
 269 _kdc_r_log(kdc_request_t r, int level, const char *fmt, ...)
 270 {
 271     va_list ap;
 272     char *s;
 273     va_start(ap, fmt);
 274     s = kdc_log_msg_va(r->context, r->config, level, fmt, ap);
 275     if(s) free(s);
 276     va_end(ap);
 277 }
 278
 279 static void
 280 _kdc_set_e_text(kdc_request_t r, const char *e_text)
 281 {
 282     r->e_text = e_text;
 283     kdc_log(r->context, r->config, 0, "%s", e_text);
 284 }
 285
 286 void
 287 _kdc_log_timestamp(krb5_context context,
 288                    krb5_kdc_configuration *config,
 289                    const char *type,
 290                    KerberosTime authtime, KerberosTime *starttime,
 291                    KerberosTime endtime, KerberosTime *renew_till)
 292 {
 293     char authtime_str[100], starttime_str[100],
 294         endtime_str[100], renewtime_str[100];
 295
 296     krb5_format_time(context, authtime,
 297                      authtime_str, sizeof(authtime_str), TRUE);
 298     if (starttime)
 299         krb5_format_time(context, *starttime,
 300                          starttime_str, sizeof(starttime_str), TRUE);
 301     else
 302         strlcpy(starttime_str, "unset", sizeof(starttime_str));
 303     krb5_format_time(context, endtime,
 304                      endtime_str, sizeof(endtime_str), TRUE);
 305     if (renew_till)
 306         krb5_format_time(context, *renew_till,
 307                          renewtime_str, sizeof(renewtime_str), TRUE);
 308     else
 309         strlcpy(renewtime_str, "unset", sizeof(renewtime_str));
 310
 311     kdc_log(context, config, 5,
 312             "%s authtime: %s starttime: %s endtime: %s renew till: %s",
 313             type, authtime_str, starttime_str, endtime_str, renewtime_str);
 314 }
 315
 316 /*
 317  *
 318  */
 319
 320 #ifdef PKINIT
 321
 322 static krb5_error_code
 323 pa_pkinit_validate(kdc_request_t r, const PA_DATA *pa)
 324 {
 325     pk_client_params *pkp = NULL;
 326     char *client_cert = NULL;
 327     krb5_error_code ret;
 328
 329     ret = _kdc_pk_rd_padata(r->context, r->config, &r->req, pa, r->client, &pkp);
 330     if (ret || pkp == NULL) {
 331         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 332         _kdc_r_log(r, 5, "Failed to decode PKINIT PA-DATA -- %s",
 333                    r->client_name);
 334         goto out;
 335     }
 336
 337     ret = _kdc_pk_check_client(r->context,
 338                                r->config,
 339                                r->clientdb,
 340                                r->client,
 341                                pkp,
 342                                &client_cert);
 343     if (ret) {
 344         _kdc_set_e_text(r, "PKINIT certificate not allowed to "
 345                         "impersonate principal");
 346         goto out;
 347     }
 348
 349     _kdc_r_log(r, 0, "PKINIT pre-authentication succeeded -- %s using %s",
 350                r->client_name, client_cert);
 351     free(client_cert);
 352
 353     ret = _kdc_pk_mk_pa_reply(r->context, r->config, pkp, r->client,
 354                               r->sessionetype, &r->req, &r->request,
 355                               &r->reply_key, &r->session_key, &r->outpadata);
 356     if (ret) {
 357         _kdc_set_e_text(r, "Failed to build PK-INIT reply");
 358         goto out;
 359     }
 360 #if 0
 361     ret = _kdc_add_initial_verified_cas(r->context, r->config,
 362                                         pkp, &r->et);
 363 #endif
 364  out:
 365     if (pkp)
 366         _kdc_pk_free_client_param(r->context, pkp);
 367
 368     return ret;
 369 }
 370
 371 #endif /* PKINIT */
 372
 373 /*
 374  *
 375  */
 376
 377 static krb5_error_code
 378 make_pa_enc_challange(krb5_context context, METHOD_DATA *md,
 379                       krb5_crypto crypto)
 380 {
 381     PA_ENC_TS_ENC p;
 382     unsigned char *buf;
 383     size_t buf_size;
 384     size_t len;
 385     EncryptedData encdata;
 386     krb5_error_code ret;
 387     int32_t usec;
 388     int usec2;
 389
 390     krb5_us_timeofday (context, &p.patimestamp, &usec);
 391     usec2         = usec;
 392     p.pausec      = &usec2;
 393
 394     ASN1_MALLOC_ENCODE(PA_ENC_TS_ENC, buf, buf_size, &p, &len, ret);
 395     if (ret)
 396         return ret;
 397     if(buf_size != len)
 398         krb5_abortx(context, "internal error in ASN.1 encoder");
 399
 400     ret = krb5_encrypt_EncryptedData(context,
 401                                      crypto,
 402                                      KRB5_KU_ENC_CHALLENGE_KDC,
 403                                      buf,
 404                                      len,
 405                                      0,
 406                                      &encdata);
 407     free(buf);
 408     if (ret)
 409         return ret;
 410
 411     ASN1_MALLOC_ENCODE(EncryptedData, buf, buf_size, &encdata, &len, ret);
 412     free_EncryptedData(&encdata);
 413     if (ret)
 414         return ret;
 415     if(buf_size != len)
 416         krb5_abortx(context, "internal error in ASN.1 encoder");
 417
 418     ret = krb5_padata_add(context, md, KRB5_PADATA_ENCRYPTED_CHALLENGE, buf, len);
 419     if (ret)
 420         free(buf);
 421     return ret;
 422 }
 423
 424 static krb5_error_code
 425 pa_enc_chal_validate(kdc_request_t r, const PA_DATA *pa)
 426 {
 427     krb5_data pepper1, pepper2, ts_data;
 428     KDC_REQ_BODY *b = &r->req.req_body;
 429     int invalidPassword = 0;
 430     EncryptedData enc_data;
 431     krb5_enctype aenctype;
 432     krb5_error_code ret;
 433     struct Key *k;
 434     size_t size;
 435     int i;
 436
 437     heim_assert(r->armor_crypto != NULL, "ENC-CHAL called for non FAST");
 438
 439     if (_kdc_is_anon_request(b)) {
 440         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 441         kdc_log(r->context, r->config, 0, "ENC-CHALL doesn't support anon");
 442         return ret;
 443     }
 444
 445     ret = decode_EncryptedData(pa->padata_value.data,
 446                                pa->padata_value.length,
 447                                &enc_data,
 448                                &size);
 449     if (ret) {
 450         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 451         _kdc_r_log(r, 5, "Failed to decode PA-DATA -- %s",
 452                    r->client_name);
 453         return ret;
 454     }
 455
 456     pepper1.data = "clientchallengearmor";
 457     pepper1.length = strlen(pepper1.data);
 458     pepper2.data = "challengelongterm";
 459     pepper2.length = strlen(pepper2.data);
 460
 461     krb5_crypto_getenctype(r->context, r->armor_crypto, &aenctype);
 462
 463     for (i = 0; i < r->client->entry.keys.len; i++) {
 464         krb5_crypto challangecrypto, longtermcrypto;
 465         krb5_keyblock challangekey;
 466         PA_ENC_TS_ENC p;
 467
 468         k = &r->client->entry.keys.val[i];
 469
 470         ret = krb5_crypto_init(r->context, &k->key, 0, &longtermcrypto);
 471         if (ret)
 472             continue;
 473
 474         ret = krb5_crypto_fx_cf2(r->context, r->armor_crypto, longtermcrypto,
 475                                  &pepper1, &pepper2, aenctype,
 476                                  &challangekey);
 477         krb5_crypto_destroy(r->context, longtermcrypto);
 478         if (ret)
 479             continue;
 480
 481         ret = krb5_crypto_init(r->context, &challangekey, 0,
 482                                &challangecrypto);
 483         if (ret)
 484             continue;
 485
 486         ret = krb5_decrypt_EncryptedData(r->context, challangecrypto,
 487                                          KRB5_KU_ENC_CHALLENGE_CLIENT,
 488                                          &enc_data,
 489                                          &ts_data);
 490         if (ret) {
 491             const char *msg = krb5_get_error_message(r->context, ret);
 492             krb5_error_code ret2;
 493             char *str = NULL;
 494
 495             invalidPassword = 1;
 496
 497             ret2 = krb5_enctype_to_string(r->context, k->key.keytype, &str);
 498             if (ret2)
 499                 str = NULL;
 500             _kdc_r_log(r, 5, "Failed to decrypt ENC-CHAL -- %s "
 501                        "(enctype %s) error %s",
 502                        r->client_name, str ? str : "unknown enctype", msg);
 503             krb5_free_error_message(r->context, msg);
 504             free(str);
 505
 506             continue;
 507         }
 508
 509         ret = decode_PA_ENC_TS_ENC(ts_data.data,
 510                                    ts_data.length,
 511                                    &p,
 512                                    &size);
 513         krb5_data_free(&ts_data);
 514         if(ret){
 515             krb5_crypto_destroy(r->context, challangecrypto);
 516             ret = KRB5KDC_ERR_PREAUTH_FAILED;
 517             _kdc_r_log(r, 5, "Failed to decode PA-ENC-TS_ENC -- %s",
 518                        r->client_name);
 519             continue;
 520         }
 521
 522         if (labs(kdc_time - p.patimestamp) > r->context->max_skew) {
 523             char client_time[100];
 524
 525             krb5_crypto_destroy(r->context, challangecrypto);
 526
 527             krb5_format_time(r->context, p.patimestamp,
 528                              client_time, sizeof(client_time), TRUE);
 529
 530             ret = KRB5KRB_AP_ERR_SKEW;
 531             _kdc_r_log(r, 0, "Too large time skew, "
 532                        "client time %s is out by %u > %u seconds -- %s",
 533                        client_time,
 534                        (unsigned)labs(kdc_time - p.patimestamp),
 535                        r->context->max_skew,
 536                        r->client_name);
 537
 538             free_PA_ENC_TS_ENC(&p);
 539             goto out;
 540         }
 541
 542         free_PA_ENC_TS_ENC(&p);
 543
 544         ret = make_pa_enc_challange(r->context, &r->outpadata,
 545                                     challangecrypto);
 546         krb5_crypto_destroy(r->context, challangecrypto);
 547         if (ret)
 548             goto out;
 549
 550         set_salt_padata(&r->outpadata, k->salt);
 551         krb5_free_keyblock_contents(r->context,  &r->reply_key);
 552         ret = krb5_copy_keyblock_contents(r->context, &k->key, &r->reply_key);
 553         if (ret)
 554             goto out;
 555
 556         /*
 557          * Success
 558          */
 559         if (r->clientdb->hdb_auth_status)
 560             r->clientdb->hdb_auth_status(r->context, r->clientdb, r->client,
 561                                          HDB_AUTH_SUCCESS);
 562         goto out;
 563     }
 564
 565     if (invalidPassword && r->clientdb->hdb_auth_status) {
 566         r->clientdb->hdb_auth_status(r->context, r->clientdb, r->client,
 567                                      HDB_AUTH_WRONG_PASSWORD);
 568         ret = KRB5KDC_ERR_PREAUTH_FAILED;
 569     }
 570  out:
 571     free_EncryptedData(&enc_data);
 572
 573     return ret;
 574 }
 575
 576 static krb5_error_code
 577 pa_enc_ts_validate(kdc_request_t r, const PA_DATA *pa)
 578 {
 579     EncryptedData enc_data;
 580     krb5_error_code ret;
 581     krb5_crypto crypto;
 582     krb5_data ts_data;
 583     PA_ENC_TS_ENC p;
 584     size_t len;
 585     Key *pa_key;
 586     char *str;
 587
 588     if (_kdc_is_anon_request(&r->req.req_body)) {
 589         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 590         _kdc_set_e_text(r, "ENC-TS doesn't support anon");
 591         goto out;
 592     }
 593
 594     ret = decode_EncryptedData(pa->padata_value.data,
 595                                pa->padata_value.length,
 596                                &enc_data,
 597                                &len);
 598     if (ret) {
 599         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 600         _kdc_r_log(r, 5, "Failed to decode PA-DATA -- %s",
 601                    r->client_name);
 602         goto out;
 603     }
 604
 605     ret = hdb_enctype2key(r->context, &r->client->entry, NULL,
 606                           enc_data.etype, &pa_key);
 607     if(ret){
 608         char *estr;
 609         _kdc_set_e_text(r, "No key matching entype");
 610         ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 611         if(krb5_enctype_to_string(r->context, enc_data.etype, &estr))
 612             estr = NULL;
 613         if(estr == NULL)
 614             _kdc_r_log(r, 5,
 615                        "No client key matching pa-data (%d) -- %s",
 616                        enc_data.etype, r->client_name);
 617         else
 618             _kdc_r_log(r, 5,
 619                        "No client key matching pa-data (%s) -- %s",
 620                        estr, r->client_name);
 621         free(estr);
 622         free_EncryptedData(&enc_data);
 623         goto out;
 624     }
 625
 626  try_next_key:
 627     ret = krb5_crypto_init(r->context, &pa_key->key, 0, &crypto);
 628     if (ret) {
 629         const char *msg = krb5_get_error_message(r->context, ret);
 630         _kdc_r_log(r, 0, "krb5_crypto_init failed: %s", msg);
 631         krb5_free_error_message(r->context, msg);
 632         free_EncryptedData(&enc_data);
 633         goto out;
 634     }
 635
 636     ret = krb5_decrypt_EncryptedData (r->context,
 637                                       crypto,
 638                                       KRB5_KU_PA_ENC_TIMESTAMP,
 639                                       &enc_data,
 640                                       &ts_data);
 641     krb5_crypto_destroy(r->context, crypto);
 642     /*
 643      * Since the user might have several keys with the same
 644      * enctype but with diffrent salting, we need to try all
 645      * the keys with the same enctype.
 646      */
 647     if(ret){
 648         krb5_error_code ret2;
 649         const char *msg = krb5_get_error_message(r->context, ret);
 650
 651         ret2 = krb5_enctype_to_string(r->context,
 652                                       pa_key->key.keytype, &str);
 653         if (ret2)
 654             str = NULL;
 655         _kdc_r_log(r, 5, "Failed to decrypt PA-DATA -- %s "
 656                    "(enctype %s) error %s",
 657                    r->client_name, str ? str : "unknown enctype", msg);
 658         krb5_free_error_message(r->context, msg);
 659         free(str);
 660
 661         if(hdb_next_enctype2key(r->context, &r->client->entry, NULL,
 662                                 enc_data.etype, &pa_key) == 0)
 663             goto try_next_key;
 664
 665         free_EncryptedData(&enc_data);
 666
 667         if (r->clientdb->hdb_auth_status)
 668             r->clientdb->hdb_auth_status(r->context, r->clientdb, r->client,
 669                                          HDB_AUTH_WRONG_PASSWORD);
 670
 671         ret = KRB5KDC_ERR_PREAUTH_FAILED;
 672         goto out;
 673     }
 674     free_EncryptedData(&enc_data);
 675     ret = decode_PA_ENC_TS_ENC(ts_data.data,
 676                                ts_data.length,
 677                                &p,
 678                                &len);
 679     krb5_data_free(&ts_data);
 680     if(ret){
 681         ret = KRB5KDC_ERR_PREAUTH_FAILED;
 682         _kdc_r_log(r, 5, "Failed to decode PA-ENC-TS_ENC -- %s",
 683                    r->client_name);
 684         goto out;
 685     }
 686     if (labs(kdc_time - p.patimestamp) > r->context->max_skew) {
 687         char client_time[100];
 688
 689         krb5_format_time(r->context, p.patimestamp,
 690                          client_time, sizeof(client_time), TRUE);
 691
 692         ret = KRB5KRB_AP_ERR_SKEW;
 693         _kdc_r_log(r, 0, "Too large time skew, "
 694                    "client time %s is out by %u > %u seconds -- %s",
 695                    client_time,
 696                    (unsigned)labs(kdc_time - p.patimestamp),
 697                    r->context->max_skew,
 698                    r->client_name);
 699
 700         /*
 701          * The following is needed to make windows clients to
 702          * retry using the timestamp in the error message, if
 703          * there is a e_text, they become unhappy.
 704          */
 705         r->e_text = NULL;
 706         free_PA_ENC_TS_ENC(&p);
 707         goto out;
 708     }
 709     free_PA_ENC_TS_ENC(&p);
 710
 711     set_salt_padata(&r->outpadata, pa_key->salt);
 712
 713     ret = krb5_copy_keyblock_contents(r->context, &pa_key->key, &r->reply_key);
 714     if (ret)
 715         return ret;
 716
 717     ret = krb5_enctype_to_string(r->context, pa_key->key.keytype, &str);
 718     if (ret)
 719         str = NULL;
 720     _kdc_r_log(r, 2, "ENC-TS Pre-authentication succeeded -- %s using %s",
 721                r->client_name, str ? str : "unknown enctype");
 722     free(str);
 723
 724     ret = 0;
 725
 726  out:
 727
 728     return ret;
 729 }
 730
 731 struct kdc_patypes {
 732     int type;
 733     char *name;
 734     unsigned int flags;
 735 #define PA_ANNOUNCE     1
 736 #define PA_REQ_FAST     2 /* only use inside fast */
 737     krb5_error_code (*validate)(kdc_request_t, const PA_DATA *pa);
 738 };
 739
 740 static const struct kdc_patypes pat[] = {
 741 #ifdef PKINIT
 742     {
 743         KRB5_PADATA_PK_AS_REQ, "PK-INIT(ietf)", PA_ANNOUNCE,
 744         pa_pkinit_validate
 745     },
 746     {
 747         KRB5_PADATA_PK_AS_REQ_WIN, "PK-INIT(win2k)", PA_ANNOUNCE,
 748         pa_pkinit_validate
 749     },
 750     {
 751         KRB5_PADATA_PKINIT_KX, "Anonymous PK-INIT", PA_ANNOUNCE,
 752         NULL
 753     },
 754 #else
 755     { KRB5_PADATA_PK_AS_REQ, "PK-INIT(ietf)", 0, NULL },
 756     { KRB5_PADATA_PK_AS_REQ_WIN, "PK-INIT(win2k)", 0, NULL },
 757     { KRB5_PADATA_PKINIT_KX, "Anonymous PK-INIT", 0, NULL },
 758 #endif
 759     { KRB5_PADATA_PA_PK_OCSP_RESPONSE , "OCSP", 0, NULL },
 760     {
 761         KRB5_PADATA_ENC_TIMESTAMP , "ENC-TS",
 762         PA_ANNOUNCE,
 763         pa_enc_ts_validate
 764     },
 765     {
 766         KRB5_PADATA_ENCRYPTED_CHALLENGE , "ENC-CHAL",
 767         PA_ANNOUNCE | PA_REQ_FAST,
 768         pa_enc_chal_validate
 769     },
 770     { KRB5_PADATA_REQ_ENC_PA_REP , "REQ-ENC-PA-REP", 0, NULL },
 771     { KRB5_PADATA_FX_FAST, "FX-FAST", PA_ANNOUNCE, NULL },
 772     { KRB5_PADATA_FX_ERROR, "FX-ERROR", 0, NULL },
 773     { KRB5_PADATA_FX_COOKIE, "FX-COOKIE", 0, NULL }
 774 };
 775
 776 static void
 777 log_patypes(krb5_context context,
 778             krb5_kdc_configuration *config,
 779             METHOD_DATA *padata)
 780 {
 781     struct rk_strpool *p = NULL;
 782     char *str;
 783     size_t n, m;
 784
 785     for (n = 0; n < padata->len; n++) {
 786         for (m = 0; m < sizeof(pat) / sizeof(pat[0]); m++) {
 787             if (padata->val[n].padata_type == pat[m].type) {
 788                 p = rk_strpoolprintf(p, "%s", pat[m].name);
 789                 break;
 790             }
 791         }
 792         if (m == sizeof(pat) / sizeof(pat[0]))
 793             p = rk_strpoolprintf(p, "%d", padata->val[n].padata_type);
 794         if (p && n + 1 < padata->len)
 795             p = rk_strpoolprintf(p, ", ");
 796         if (p == NULL) {
 797             kdc_log(context, config, 0, "out of memory");
 798             return;
 799         }
 800     }
 801     if (p == NULL)
 802         p = rk_strpoolprintf(p, "none");
 803
 804     str = rk_strpoolcollect(p);
 805     kdc_log(context, config, 0, "Client sent patypes: %s", str);
 806     free(str);
 807 }
 808
 809 /*
 810  *
 811  */
 812
 813 krb5_error_code
 814 _kdc_encode_reply(krb5_context context,
 815                   krb5_kdc_configuration *config,
 816                   krb5_crypto armor_crypto, uint32_t nonce,
 817                   KDC_REP *rep, EncTicketPart *et, EncKDCRepPart *ek,
 818                   krb5_enctype etype,
 819                   int skvno, const EncryptionKey *skey,
 820                   int ckvno, const EncryptionKey *reply_key,
 821                   int rk_is_subkey,
 822                   const char **e_text,
 823                   krb5_data *reply)
 824 {
 825     unsigned char *buf;
 826     size_t buf_size;
 827     size_t len = 0;
 828     krb5_error_code ret;
 829     krb5_crypto crypto;
 830
 831     ASN1_MALLOC_ENCODE(EncTicketPart, buf, buf_size, et, &len, ret);
 832     if(ret) {
 833         const char *msg = krb5_get_error_message(context, ret);
 834         kdc_log(context, config, 0, "Failed to encode ticket: %s", msg);
 835         krb5_free_error_message(context, msg);
 836         return ret;
 837     }
 838     if(buf_size != len)
 839         krb5_abortx(context, "Internal error in ASN.1 encoder");
 840
 841     ret = krb5_crypto_init(context, skey, etype, &crypto);
 842     if (ret) {
 843         const char *msg = krb5_get_error_message(context, ret);
 844         kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
 845         krb5_free_error_message(context, msg);
 846         free(buf);
 847         return ret;
 848     }
 849
 850     ret = krb5_encrypt_EncryptedData(context,
 851                                      crypto,
 852                                      KRB5_KU_TICKET,
 853                                      buf,
 854                                      len,
 855                                      skvno,
 856                                      &rep->ticket.enc_part);
 857     free(buf);
 858     krb5_crypto_destroy(context, crypto);
 859     if(ret) {
 860         const char *msg = krb5_get_error_message(context, ret);
 861         kdc_log(context, config, 0, "Failed to encrypt data: %s", msg);
 862         krb5_free_error_message(context, msg);
 863         return ret;
 864     }
 865
 866     if (armor_crypto) {
 867         krb5_data data;
 868         krb5_keyblock *strengthen_key = NULL;
 869         KrbFastFinished finished;
 870
 871         kdc_log(context, config, 0, "FAST armor protection");
 872
 873         memset(&finished, 0, sizeof(finished));
 874         krb5_data_zero(&data);
 875
 876         finished.timestamp = kdc_time;
 877         finished.usec = 0;
 878         finished.crealm = et->crealm;
 879         finished.cname = et->cname;
 880
 881         ASN1_MALLOC_ENCODE(Ticket, data.data, data.length,
 882                            &rep->ticket, &len, ret);
 883         if (ret)
 884             return ret;
 885         if (data.length != len)
 886             krb5_abortx(context, "internal asn.1 error");
 887
 888         ret = krb5_create_checksum(context, armor_crypto,
 889                                    KRB5_KU_FAST_FINISHED, 0,
 890                                    data.data, data.length,
 891                                    &finished.ticket_checksum);
 892         krb5_data_free(&data);
 893         if (ret)
 894             return ret;
 895
 896         ret = _kdc_fast_mk_response(context, armor_crypto,
 897                                     rep->padata, strengthen_key, &finished,
 898                                     nonce, &data);
 899         free_Checksum(&finished.ticket_checksum);
 900         if (ret)
 901             return ret;
 902
 903         if (rep->padata) {
 904             free_METHOD_DATA(rep->padata);
 905         } else {
 906             rep->padata = calloc(1, sizeof(*(rep->padata)));
 907             if (rep->padata == NULL) {
 908                 krb5_data_free(&data);
 909                 return ENOMEM;
 910             }
 911         }
 912
 913         ret = krb5_padata_add(context, rep->padata,
 914                               KRB5_PADATA_FX_FAST,
 915                               data.data, data.length);
 916         if (ret)
 917             return ret;
 918
 919         /*
 920          * Hide client name of privacy reasons
 921          */
 922         if (1 /* r->fast_options.hide_client_names */) {
 923             rep->crealm[0] = '\0';
 924             free_PrincipalName(&rep->cname);
 925             rep->cname.name_type = 0;
 926         }
 927     }
 928
 929     if(rep->msg_type == krb_as_rep && !config->encode_as_rep_as_tgs_rep)
 930         ASN1_MALLOC_ENCODE(EncASRepPart, buf, buf_size, ek, &len, ret);
 931     else
 932         ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
 933     if(ret) {
 934         const char *msg = krb5_get_error_message(context, ret);
 935         kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
 936         krb5_free_error_message(context, msg);
 937         return ret;
 938     }
 939     if(buf_size != len) {
 940         free(buf);
 941         kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
 942         *e_text = "KDC internal error";
 943         return KRB5KRB_ERR_GENERIC;
 944     }
 945     ret = krb5_crypto_init(context, reply_key, 0, &crypto);
 946     if (ret) {
 947         const char *msg = krb5_get_error_message(context, ret);
 948         free(buf);
 949         kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
 950         krb5_free_error_message(context, msg);
 951         return ret;
 952     }
 953     if(rep->msg_type == krb_as_rep) {
 954         krb5_encrypt_EncryptedData(context,
 955                                    crypto,
 956                                    KRB5_KU_AS_REP_ENC_PART,
 957                                    buf,
 958                                    len,
 959                                    ckvno,
 960                                    &rep->enc_part);
 961         free(buf);
 962         ASN1_MALLOC_ENCODE(AS_REP, buf, buf_size, rep, &len, ret);
 963     } else {
 964         krb5_encrypt_EncryptedData(context,
 965                                    crypto,
 966                                    rk_is_subkey ? KRB5_KU_TGS_REP_ENC_PART_SUB_KEY : KRB5_KU_TGS_REP_ENC_PART_SESSION,
 967                                    buf,
 968                                    len,
 969                                    ckvno,
 970                                    &rep->enc_part);
 971         free(buf);
 972         ASN1_MALLOC_ENCODE(TGS_REP, buf, buf_size, rep, &len, ret);
 973     }
 974     krb5_crypto_destroy(context, crypto);
 975     if(ret) {
 976         const char *msg = krb5_get_error_message(context, ret);
 977         kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
 978         krb5_free_error_message(context, msg);
 979         return ret;
 980     }
 981     if(buf_size != len) {
 982         free(buf);
 983         kdc_log(context, config, 0, "Internal error in ASN.1 encoder");
 984         *e_text = "KDC internal error";
 985         return KRB5KRB_ERR_GENERIC;
 986     }
 987     reply->data = buf;
 988     reply->length = buf_size;
 989     return 0;
 990 }
 991
 992 /*
 993  * Return 1 if the client have only older enctypes, this is for
 994  * determining if the server should send ETYPE_INFO2 or not.
 995  */
 996
 997 static int
 998 older_enctype(krb5_enctype enctype)
 999 {
1000     switch (enctype) {
1001     case ETYPE_DES_CBC_CRC:
1002     case ETYPE_DES_CBC_MD4:
1003     case ETYPE_DES_CBC_MD5:
1004     case ETYPE_DES3_CBC_SHA1:
1005     case ETYPE_ARCFOUR_HMAC_MD5:
1006     case ETYPE_ARCFOUR_HMAC_MD5_56:
1007     /*
1008      * The following three is "old" windows enctypes and is needed for
1009      * windows 2000 hosts.
1010      */
1011     case ETYPE_ARCFOUR_MD4:
1012     case ETYPE_ARCFOUR_HMAC_OLD:
1013     case ETYPE_ARCFOUR_HMAC_OLD_EXP:
1014         return 1;
1015     default:
1016         return 0;
1017     }
1018 }
1019
1020 /*
1021  *
1022  */
1023
1024 static krb5_error_code
1025 make_etype_info_entry(krb5_context context,
1026                       ETYPE_INFO_ENTRY *ent,
1027                       Key *key,
1028                       krb5_boolean include_salt)
1029 {
1030     ent->etype = key->key.keytype;
1031     if (key->salt && include_salt){
1032 #if 0
1033         ALLOC(ent->salttype);
1034
1035         if(key->salt->type == hdb_pw_salt)
1036             *ent->salttype = 0; /* or 1? or NULL? */
1037         else if(key->salt->type == hdb_afs3_salt)
1038             *ent->salttype = 2;
1039         else {
1040             kdc_log(context, config, 0, "unknown salt-type: %d",
1041                     key->salt->type);
1042             return KRB5KRB_ERR_GENERIC;
1043         }
1044         /* according to `the specs', we can't send a salt if
1045            we have AFS3 salted key, but that requires that you
1046            *know* what cell you are using (e.g by assuming
1047            that the cell is the same as the realm in lower
1048            case) */
1049 #elif 0
1050         ALLOC(ent->salttype);
1051         *ent->salttype = key->salt->type;
1052 #else
1053         /*
1054          * We shouldn't sent salttype since it is incompatible with the
1055          * specification and it breaks windows clients.  The afs
1056          * salting problem is solved by using KRB5-PADATA-AFS3-SALT
1057          * implemented in Heimdal 0.7 and later.
1058          */
1059         ent->salttype = NULL;
1060 #endif
1061         krb5_copy_data(context, &key->salt->salt,
1062                        &ent->salt);
1063     } else {
1064         /* we return no salt type at all, as that should indicate
1065          * the default salt type and make everybody happy.  some
1066          * systems (like w2k) dislike being told the salt type
1067          * here. */
1068
1069         ent->salttype = NULL;
1070         ent->salt = NULL;
1071     }
1072     return 0;
1073 }
1074
1075 static krb5_error_code
1076 get_pa_etype_info(krb5_context context,
1077                   krb5_kdc_configuration *config,
1078                   METHOD_DATA *md, Key *ckey,
1079                   krb5_boolean include_salt)
1080 {
1081     krb5_error_code ret = 0;
1082     ETYPE_INFO pa;
1083     unsigned char *buf;
1084     size_t len;
1085
1086
1087     pa.len = 1;
1088     pa.val = calloc(1, sizeof(pa.val[0]));
1089     if(pa.val == NULL)
1090         return ENOMEM;
1091
1092     ret = make_etype_info_entry(context, &pa.val[0], ckey, include_salt);
1093     if (ret) {
1094         free_ETYPE_INFO(&pa);
1095         return ret;
1096     }
1097
1098     ASN1_MALLOC_ENCODE(ETYPE_INFO, buf, len, &pa, &len, ret);
1099     free_ETYPE_INFO(&pa);
1100     if(ret)
1101         return ret;
1102     ret = realloc_method_data(md);
1103     if(ret) {
1104         free(buf);
1105         return ret;
1106     }
1107     md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO;
1108     md->val[md->len - 1].padata_value.length = len;
1109     md->val[md->len - 1].padata_value.data = buf;
1110     return 0;
1111 }
1112
1113 /*
1114  *
1115  */
1116
1117 extern int _krb5_AES_SHA1_string_to_default_iterator;
1118 extern int _krb5_AES_SHA2_string_to_default_iterator;
1119
1120 static krb5_error_code
1121 make_s2kparams(int value, size_t len, krb5_data **ps2kparams)
1122 {
1123     krb5_data *s2kparams;
1124     krb5_error_code ret;
1125
1126     ALLOC(s2kparams);
1127     if (s2kparams == NULL)
1128         return ENOMEM;
1129     ret = krb5_data_alloc(s2kparams, len);
1130     if (ret) {
1131         free(s2kparams);
1132         return ret;
1133     }
1134     _krb5_put_int(s2kparams->data, value, len);
1135     *ps2kparams = s2kparams;
1136     return 0;
1137 }
1138
1139 static krb5_error_code
1140 make_etype_info2_entry(ETYPE_INFO2_ENTRY *ent,
1141                        Key *key,
1142                        krb5_boolean include_salt)
1143 {
1144     krb5_error_code ret;
1145
1146     ent->etype = key->key.keytype;
1147     if (key->salt && include_salt) {
1148         ALLOC(ent->salt);
1149         if (ent->salt == NULL)
1150             return ENOMEM;
1151         *ent->salt = malloc(key->salt->salt.length + 1);
1152         if (*ent->salt == NULL) {
1153             free(ent->salt);
1154             ent->salt = NULL;
1155             return ENOMEM;
1156         }
1157         memcpy(*ent->salt, key->salt->salt.data, key->salt->salt.length);
1158         (*ent->salt)[key->salt->salt.length] = '\0';
1159     } else
1160         ent->salt = NULL;
1161
1162     ent->s2kparams = NULL;
1163
1164     switch (key->key.keytype) {
1165     case ETYPE_AES128_CTS_HMAC_SHA1_96:
1166     case ETYPE_AES256_CTS_HMAC_SHA1_96:
1167         ret = make_s2kparams(_krb5_AES_SHA1_string_to_default_iterator,
1168                              4, &ent->s2kparams);
1169         break;
1170     case KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128:
1171     case KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192:
1172         ret = make_s2kparams(_krb5_AES_SHA2_string_to_default_iterator,
1173                              4, &ent->s2kparams);
1174         break;
1175     case ETYPE_DES_CBC_CRC:
1176     case ETYPE_DES_CBC_MD4:
1177     case ETYPE_DES_CBC_MD5:
1178         /* Check if this was a AFS3 salted key */
1179         if(key->salt && key->salt->type == hdb_afs3_salt)
1180             ret = make_s2kparams(1, 1, &ent->s2kparams);
1181         else
1182             ret = 0;
1183         break;
1184     default:
1185         ret = 0;
1186         break;
1187     }
1188     return ret;
1189 }
1190
1191 /*
1192  * Return an ETYPE-INFO2. Enctypes are storted the same way as in the
1193  * database (client supported enctypes first, then the unsupported
1194  * enctypes).
1195  */
1196
1197 static krb5_error_code
1198 get_pa_etype_info2(krb5_context context,
1199                    krb5_kdc_configuration *config,
1200                    METHOD_DATA *md, Key *ckey,
1201                    krb5_boolean include_salt)
1202 {
1203     krb5_error_code ret = 0;
1204     ETYPE_INFO2 pa;
1205     unsigned char *buf;
1206     size_t len;
1207
1208     pa.len = 1;
1209     pa.val = calloc(1, sizeof(pa.val[0]));
1210     if(pa.val == NULL)
1211         return ENOMEM;
1212
1213     ret = make_etype_info2_entry(&pa.val[0], ckey, include_salt);
1214     if (ret) {
1215         free_ETYPE_INFO2(&pa);
1216         return ret;
1217     }
1218
1219     ASN1_MALLOC_ENCODE(ETYPE_INFO2, buf, len, &pa, &len, ret);
1220     free_ETYPE_INFO2(&pa);
1221     if(ret)
1222         return ret;
1223     ret = realloc_method_data(md);
1224     if(ret) {
1225         free(buf);
1226         return ret;
1227     }
1228     md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO2;
1229     md->val[md->len - 1].padata_value.length = len;
1230     md->val[md->len - 1].padata_value.data = buf;
1231     return 0;
1232 }
1233
1234 static int
1235 newer_enctype_present(struct KDC_REQ_BODY_etype *etype_list)
1236 {
1237     size_t i;
1238
1239     for (i = 0; i < etype_list->len; i++) {
1240         if (!older_enctype(etype_list->val[i]))
1241             return 1;
1242     }
1243     return 0;
1244 }
1245
1246 static krb5_error_code
1247 get_pa_etype_info_both(krb5_context context,
1248                        krb5_kdc_configuration *config,
1249                        struct KDC_REQ_BODY_etype *etype_list,
1250                        METHOD_DATA *md, Key *ckey,
1251                        krb5_boolean include_salt)
1252 {
1253     krb5_error_code ret;
1254
1255     /*
1256      * RFC4120 requires:
1257      *   When the AS server is to include pre-authentication data in a
1258      *   KRB-ERROR or in an AS-REP, it MUST use PA-ETYPE-INFO2, not
1259      *   PA-ETYPE-INFO, if the etype field of the client's AS-REQ lists
1260      *   at least one "newer" encryption type.  Otherwise (when the etype
1261      *   field of the client's AS-REQ does not list any "newer" encryption
1262      *   types), it MUST send both PA-ETYPE-INFO2 and PA-ETYPE-INFO (both
1263      *   with an entry for each enctype).  A "newer" enctype is any enctype
1264      *   first officially specified concurrently with or subsequent to the
1265      *   issue of this RFC.  The enctypes DES, 3DES, or RC4 and any defined
1266      *   in [RFC1510] are not "newer" enctypes.
1267      *
1268      * It goes on to state:
1269      *   The preferred ordering of the "hint" pre-authentication data that
1270      *   affect client key selection is: ETYPE-INFO2, followed by ETYPE-INFO,
1271      *   followed by PW-SALT.  As noted in Section 3.1.3, a KDC MUST NOT send
1272      *   ETYPE-INFO or PW-SALT when the client's AS-REQ includes at least one
1273      *   "newer" etype.
1274      */
1275
1276     ret = get_pa_etype_info2(context, config, md, ckey, include_salt);
1277     if (ret)
1278         return ret;
1279
1280     if (!newer_enctype_present(etype_list))
1281         ret = get_pa_etype_info(context, config, md, ckey, include_salt);
1282
1283     return ret;
1284 }
1285
1286 /*
1287  *
1288  */
1289
1290 static void
1291 log_as_req(krb5_context context,
1292            krb5_kdc_configuration *config,
1293            krb5_enctype cetype,
1294            krb5_enctype setype,
1295            const KDC_REQ_BODY *b)
1296 {
1297     krb5_error_code ret;
1298     struct rk_strpool *p;
1299     char *str;
1300     size_t i;
1301
1302     p = rk_strpoolprintf(NULL, "%s", "Client supported enctypes: ");
1303
1304     for (i = 0; i < b->etype.len; i++) {
1305         ret = krb5_enctype_to_string(context, b->etype.val[i], &str);
1306         if (ret == 0) {
1307             p = rk_strpoolprintf(p, "%s", str);
1308             free(str);
1309         } else
1310             p = rk_strpoolprintf(p, "%d", b->etype.val[i]);
1311         if (p && i + 1 < b->etype.len)
1312             p = rk_strpoolprintf(p, ", ");
1313         if (p == NULL) {
1314             kdc_log(context, config, 0, "out of memory");
1315             return;
1316         }
1317     }
1318     if (p == NULL)
1319         p = rk_strpoolprintf(p, "no encryption types");
1320
1321     {
1322         char *cet;
1323         char *set;
1324
1325         ret = krb5_enctype_to_string(context, cetype, &cet);
1326         if(ret == 0) {
1327             ret = krb5_enctype_to_string(context, setype, &set);
1328             if (ret == 0) {
1329                 p = rk_strpoolprintf(p, ", using %s/%s", cet, set);
1330                 free(set);
1331             }
1332             free(cet);
1333         }
1334         if (ret != 0)
1335             p = rk_strpoolprintf(p, ", using enctypes %d/%d",
1336                                  cetype, setype);
1337     }
1338
1339     str = rk_strpoolcollect(p);
1340     kdc_log(context, config, 0, "%s", str);
1341     free(str);
1342
1343     {
1344         char fixedstr[128];
1345         unparse_flags(KDCOptions2int(b->kdc_options), asn1_KDCOptions_units(),
1346                       fixedstr, sizeof(fixedstr));
1347         if(*fixedstr)
1348             kdc_log(context, config, 0, "Requested flags: %s", fixedstr);
1349     }
1350 }
1351
1352 /*
1353  * verify the flags on `client' and `server', returning 0
1354  * if they are OK and generating an error messages and returning
1355  * and error code otherwise.
1356  */
1357
1358 krb5_error_code
1359 kdc_check_flags(krb5_context context,
1360                 krb5_kdc_configuration *config,
1361                 hdb_entry_ex *client_ex, const char *client_name,
1362                 hdb_entry_ex *server_ex, const char *server_name,
1363                 krb5_boolean is_as_req)
1364 {
1365     if(client_ex != NULL) {
1366         hdb_entry *client = &client_ex->entry;
1367
1368         /* check client */
1369         if (client->flags.locked_out) {
1370             kdc_log(context, config, 0,
1371                     "Client (%s) is locked out", client_name);
1372             return KRB5KDC_ERR_POLICY;
1373         }
1374
1375         if (client->flags.invalid) {
1376             kdc_log(context, config, 0,
1377                     "Client (%s) has invalid bit set", client_name);
1378             return KRB5KDC_ERR_POLICY;
1379         }
1380
1381         if(!client->flags.client){
1382             kdc_log(context, config, 0,
1383                     "Principal may not act as client -- %s", client_name);
1384             return KRB5KDC_ERR_POLICY;
1385         }
1386
1387         if (client->valid_start && *client->valid_start > kdc_time) {
1388             char starttime_str[100];
1389             krb5_format_time(context, *client->valid_start,
1390                              starttime_str, sizeof(starttime_str), TRUE);
1391             kdc_log(context, config, 0,
1392                     "Client not yet valid until %s -- %s",
1393                     starttime_str, client_name);
1394             return KRB5KDC_ERR_CLIENT_NOTYET;
1395         }
1396
1397         if (client->valid_end && *client->valid_end < kdc_time) {
1398             char endtime_str[100];
1399             krb5_format_time(context, *client->valid_end,
1400                              endtime_str, sizeof(endtime_str), TRUE);
1401             kdc_log(context, config, 0,
1402                     "Client expired at %s -- %s",
1403                     endtime_str, client_name);
1404             return KRB5KDC_ERR_NAME_EXP;
1405         }
1406
1407         if (client->flags.require_pwchange &&
1408             (server_ex == NULL || !server_ex->entry.flags.change_pw)) {
1409             kdc_log(context, config, 0,
1410                     "Client's key must be changed -- %s", client_name);
1411             return KRB5KDC_ERR_KEY_EXPIRED;
1412         }
1413
1414         if (client->pw_end && *client->pw_end < kdc_time
1415             && (server_ex == NULL || !server_ex->entry.flags.change_pw)) {
1416             char pwend_str[100];
1417             krb5_format_time(context, *client->pw_end,
1418                              pwend_str, sizeof(pwend_str), TRUE);
1419             kdc_log(context, config, 0,
1420                     "Client's key has expired at %s -- %s",
1421                     pwend_str, client_name);
1422             return KRB5KDC_ERR_KEY_EXPIRED;
1423         }
1424     }
1425
1426     /* check server */
1427
1428     if (server_ex != NULL) {
1429         hdb_entry *server = &server_ex->entry;
1430
1431         if (server->flags.locked_out) {
1432             kdc_log(context, config, 0,
1433                     "Client server locked out -- %s", server_name);
1434             return KRB5KDC_ERR_POLICY;
1435         }
1436         if (server->flags.invalid) {
1437             kdc_log(context, config, 0,
1438                     "Server has invalid flag set -- %s", server_name);
1439             return KRB5KDC_ERR_POLICY;
1440         }
1441
1442         if(!server->flags.server){
1443             kdc_log(context, config, 0,
1444                     "Principal may not act as server -- %s", server_name);
1445             return KRB5KDC_ERR_POLICY;
1446         }
1447
1448         if(!is_as_req && server->flags.initial) {
1449             kdc_log(context, config, 0,
1450                     "AS-REQ is required for server -- %s", server_name);
1451             return KRB5KDC_ERR_POLICY;
1452         }
1453
1454         if (server->valid_start && *server->valid_start > kdc_time) {
1455             char starttime_str[100];
1456             krb5_format_time(context, *server->valid_start,
1457                              starttime_str, sizeof(starttime_str), TRUE);
1458             kdc_log(context, config, 0,
1459                     "Server not yet valid until %s -- %s",
1460                     starttime_str, server_name);
1461             return KRB5KDC_ERR_SERVICE_NOTYET;
1462         }
1463
1464         if (server->valid_end && *server->valid_end < kdc_time) {
1465             char endtime_str[100];
1466             krb5_format_time(context, *server->valid_end,
1467                              endtime_str, sizeof(endtime_str), TRUE);
1468             kdc_log(context, config, 0,
1469                     "Server expired at %s -- %s",
1470                     endtime_str, server_name);
1471             return KRB5KDC_ERR_SERVICE_EXP;
1472         }
1473
1474         if (server->pw_end && *server->pw_end < kdc_time) {
1475             char pwend_str[100];
1476             krb5_format_time(context, *server->pw_end,
1477                              pwend_str, sizeof(pwend_str), TRUE);
1478             kdc_log(context, config, 0,
1479                     "Server's key has expired at -- %s",
1480                     pwend_str, server_name);
1481             return KRB5KDC_ERR_KEY_EXPIRED;
1482         }
1483     }
1484     return 0;
1485 }
1486
1487 /*
1488  * Return TRUE if `from' is part of `addresses' taking into consideration
1489  * the configuration variables that tells us how strict we should be about
1490  * these checks
1491  */
1492
1493 krb5_boolean
1494 _kdc_check_addresses(krb5_context context,
1495                      krb5_kdc_configuration *config,
1496                      HostAddresses *addresses, const struct sockaddr *from)
1497 {
1498     krb5_error_code ret;
1499     krb5_address addr;
1500     krb5_boolean result;
1501     krb5_boolean only_netbios = TRUE;
1502     size_t i;
1503
1504     if(config->check_ticket_addresses == 0)
1505         return TRUE;
1506
1507     if(addresses == NULL)
1508         return config->allow_null_ticket_addresses;
1509
1510     for (i = 0; i < addresses->len; ++i) {
1511         if (addresses->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
1512             only_netbios = FALSE;
1513         }
1514     }
1515
1516     /* Windows sends it's netbios name, which I can only assume is
1517      * used for the 'allowed workstations' check.  This is painful,
1518      * but we still want to check IP addresses if they happen to be
1519      * present.
1520      */
1521
1522     if(only_netbios)
1523         return config->allow_null_ticket_addresses;
1524
1525     ret = krb5_sockaddr2address (context, from, &addr);
1526     if(ret)
1527         return FALSE;
1528
1529     result = krb5_address_search(context, &addr, addresses);
1530     krb5_free_address (context, &addr);
1531     return result;
1532 }
1533
1534 /*
1535  *
1536  */
1537
1538 static krb5_boolean
1539 send_pac_p(krb5_context context, KDC_REQ *req)
1540 {
1541     krb5_error_code ret;
1542     PA_PAC_REQUEST pacreq;
1543     const PA_DATA *pa;
1544     int i = 0;
1545
1546     pa = _kdc_find_padata(req, &i, KRB5_PADATA_PA_PAC_REQUEST);
1547     if (pa == NULL)
1548         return TRUE;
1549
1550     ret = decode_PA_PAC_REQUEST(pa->padata_value.data,
1551                                 pa->padata_value.length,
1552                                 &pacreq,
1553                                 NULL);
1554     if (ret)
1555         return TRUE;
1556     i = pacreq.include_pac;
1557     free_PA_PAC_REQUEST(&pacreq);
1558     if (i == 0)
1559         return FALSE;
1560     return TRUE;
1561 }
1562
1563 /*
1564  *
1565  */
1566
1567 static krb5_error_code
1568 generate_pac(kdc_request_t r, Key *skey)
1569 {
1570     krb5_error_code ret;
1571     krb5_pac p = NULL;
1572     krb5_data data;
1573
1574     ret = _kdc_pac_generate(r->context, r->client, &p);
1575     if (ret) {
1576         _kdc_r_log(r, 0, "PAC generation failed for -- %s",
1577                    r->client_name);
1578         return ret;
1579     }
1580     if (p == NULL)
1581         return 0;
1582
1583     ret = _krb5_pac_sign(r->context, p, r->et.authtime,
1584                          r->client->entry.principal,
1585                          &skey->key, /* Server key */
1586                          &skey->key, /* FIXME: should be krbtgt key */
1587                          &data);
1588     krb5_pac_free(r->context, p);
1589     if (ret) {
1590         _kdc_r_log(r, 0, "PAC signing failed for -- %s",
1591                    r->client_name);
1592         return ret;
1593     }
1594
1595     ret = _kdc_tkt_add_if_relevant_ad(r->context, &r->et,
1596                                       KRB5_AUTHDATA_WIN2K_PAC,
1597                                       &data);
1598     krb5_data_free(&data);
1599
1600     return ret;
1601 }
1602
1603 /*
1604  *
1605  */
1606
1607 krb5_boolean
1608 _kdc_is_anonymous(krb5_context context, krb5_principal principal)
1609 {
1610     if ((principal->name.name_type != KRB5_NT_WELLKNOWN &&
1611          principal->name.name_type != KRB5_NT_UNKNOWN) ||
1612         principal->name.name_string.len != 2 ||
1613         strcmp(principal->name.name_string.val[0], KRB5_WELLKNOWN_NAME) != 0 ||
1614         strcmp(principal->name.name_string.val[1], KRB5_ANON_NAME) != 0)
1615         return 0;
1616     return 1;
1617 }
1618
1619 static int
1620 require_preauth_p(kdc_request_t r)
1621 {
1622     return r->config->require_preauth
1623         || r->client->entry.flags.require_preauth
1624         || r->server->entry.flags.require_preauth;
1625 }
1626
1627
1628 /*
1629  *
1630  */
1631
1632 static krb5_error_code
1633 add_enc_pa_rep(kdc_request_t r)
1634 {
1635     krb5_error_code ret;
1636     krb5_crypto crypto;
1637     Checksum checksum;
1638     krb5_data cdata;
1639     size_t len;
1640
1641     ret = krb5_crypto_init(r->context, &r->reply_key, 0, &crypto);
1642     if (ret)
1643         return ret;
1644
1645     ret = krb5_create_checksum(r->context, crypto,
1646                                KRB5_KU_AS_REQ, 0,
1647                                r->request.data, r->request.length,
1648                                &checksum);
1649     krb5_crypto_destroy(r->context, crypto);
1650     if (ret)
1651         return ret;
1652
1653     ASN1_MALLOC_ENCODE(Checksum, cdata.data, cdata.length,
1654                        &checksum, &len, ret);
1655     free_Checksum(&checksum);
1656     if (ret)
1657         return ret;
1658     heim_assert(cdata.length == len, "ASN.1 internal error");
1659
1660     if (r->ek.encrypted_pa_data == NULL) {
1661         ALLOC(r->ek.encrypted_pa_data);
1662         if (r->ek.encrypted_pa_data == NULL)
1663             return ENOMEM;
1664     }
1665     ret = krb5_padata_add(r->context, r->ek.encrypted_pa_data,
1666                           KRB5_PADATA_REQ_ENC_PA_REP, cdata.data, cdata.length);
1667     if (ret)
1668         return ret;
1669
1670     return krb5_padata_add(r->context, r->ek.encrypted_pa_data,
1671                            KRB5_PADATA_FX_FAST, NULL, 0);
1672 }
1673
1674 /*
1675  *
1676  */
1677
1678 krb5_error_code
1679 _kdc_as_rep(kdc_request_t r,
1680             krb5_data *reply,
1681             const char *from,
1682             struct sockaddr *from_addr,
1683             int datagram_reply)
1684 {
1685     krb5_context context = r->context;
1686     krb5_kdc_configuration *config = r->config;
1687     KDC_REQ *req = &r->req;
1688     KDC_REQ_BODY *b = NULL;
1689     AS_REP rep;
1690     KDCOptions f;
1691     krb5_enctype setype;
1692     krb5_error_code ret = 0;
1693     Key *skey;
1694     int found_pa = 0;
1695     int i, flags = HDB_F_FOR_AS_REQ;
1696     METHOD_DATA error_method;
1697     const PA_DATA *pa;
1698     krb5_boolean is_tgs;
1699
1700     memset(&rep, 0, sizeof(rep));
1701     error_method.len = 0;
1702     error_method.val = NULL;
1703
1704     /*
1705      * Look for FAST armor and unwrap
1706      */
1707     ret = _kdc_fast_unwrap_request(r);
1708     if (ret) {
1709         _kdc_r_log(r, 0, "FAST unwrap request from %s failed: %d", from, ret);
1710         goto out;
1711     }
1712
1713     b = &req->req_body;
1714     f = b->kdc_options;
1715
1716     if (f.canonicalize)
1717         flags |= HDB_F_CANON;
1718
1719     if(b->sname == NULL){
1720         ret = KRB5KRB_ERR_GENERIC;
1721         _kdc_set_e_text(r, "No server in request");
1722     } else{
1723         ret = _krb5_principalname2krb5_principal (context,
1724                                                   &r->server_princ,
1725                                                   *(b->sname),
1726                                                   b->realm);
1727         if (ret == 0)
1728             ret = krb5_unparse_name(context, r->server_princ, &r->server_name);
1729     }
1730     if (ret) {
1731         kdc_log(context, config, 0,
1732                 "AS-REQ malformed server name from %s", from);
1733         goto out;
1734     }
1735     if(b->cname == NULL){
1736         ret = KRB5KRB_ERR_GENERIC;
1737         _kdc_set_e_text(r, "No client in request");
1738     } else {
1739         ret = _krb5_principalname2krb5_principal (context,
1740                                                   &r->client_princ,
1741                                                   *(b->cname),
1742                                                   b->realm);
1743         if (ret)
1744             goto out;
1745
1746         ret = krb5_unparse_name(context, r->client_princ, &r->client_name);
1747     }
1748     if (ret) {
1749         kdc_log(context, config, 0,
1750                 "AS-REQ malformed client name from %s", from);
1751         goto out;
1752     }
1753
1754     kdc_log(context, config, 0, "AS-REQ %s from %s for %s",
1755             r->client_name, from, r->server_name);
1756
1757     is_tgs = krb5_principal_is_krbtgt(context, r->server_princ);
1758
1759     /*
1760      *
1761      */
1762
1763     if (_kdc_is_anonymous(context, r->client_princ)) {
1764         if (!_kdc_is_anon_request(b)) {
1765             kdc_log(context, config, 0, "Anonymous ticket w/o anonymous flag");
1766             ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1767             goto out;
1768         }
1769     } else if (_kdc_is_anon_request(b)) {
1770         kdc_log(context, config, 0,
1771                 "Request for a anonymous ticket with non "
1772                 "anonymous client name: %s", r->client_name);
1773         ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1774         goto out;
1775     }
1776
1777     /*
1778      *
1779      */
1780
1781     ret = _kdc_db_fetch(context, config, r->client_princ,
1782                         HDB_F_GET_CLIENT | flags, NULL,
1783                         &r->clientdb, &r->client);
1784     if(ret == HDB_ERR_NOT_FOUND_HERE) {
1785         kdc_log(context, config, 5, "client %s does not have secrets at this KDC, need to proxy",
1786                 r->client_name);
1787         goto out;
1788     } else if (ret == HDB_ERR_WRONG_REALM) {
1789         char *fixed_client_name = NULL;
1790
1791         ret = krb5_unparse_name(context, r->client->entry.principal,
1792                                 &fixed_client_name);
1793         if (ret) {
1794             goto out;
1795         }
1796
1797         kdc_log(context, config, 0, "WRONG_REALM - %s -> %s",
1798                 r->client_name, fixed_client_name);
1799         free(fixed_client_name);
1800
1801         ret = _kdc_fast_mk_error(context, r,
1802                                  &error_method,
1803                                  r->armor_crypto,
1804                                  &req->req_body,
1805                                  KRB5_KDC_ERR_WRONG_REALM,
1806                                  NULL,
1807                                  r->server_princ,
1808                                  NULL,
1809                                  &r->client->entry.principal->realm,
1810                                  NULL, NULL,
1811                                  reply);
1812         goto out;
1813     } else if(ret){
1814         const char *msg = krb5_get_error_message(context, ret);
1815         kdc_log(context, config, 0, "UNKNOWN -- %s: %s", r->client_name, msg);
1816         krb5_free_error_message(context, msg);
1817         ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
1818         goto out;
1819     }
1820     ret = _kdc_db_fetch(context, config, r->server_princ,
1821                         HDB_F_GET_SERVER | flags | (is_tgs ? HDB_F_GET_KRBTGT : 0),
1822                         NULL, NULL, &r->server);
1823     if(ret == HDB_ERR_NOT_FOUND_HERE) {
1824         kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy",
1825                 r->server_name);
1826         goto out;
1827     } else if(ret){
1828         const char *msg = krb5_get_error_message(context, ret);
1829         kdc_log(context, config, 0, "UNKNOWN -- %s: %s", r->server_name, msg);
1830         krb5_free_error_message(context, msg);
1831         ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
1832         goto out;
1833     }
1834
1835     /*
1836      * Select a session enctype from the list of the crypto system
1837      * supported enctypes that is supported by the client and is one of
1838      * the enctype of the enctype of the service (likely krbtgt).
1839      *
1840      * The latter is used as a hint of what enctypes all KDC support,
1841      * to make sure a newer version of KDC won't generate a session
1842      * enctype that an older version of a KDC in the same realm can't
1843      * decrypt.
1844      */
1845
1846     ret = _kdc_find_etype(context,
1847                           is_tgs ? config->tgt_use_strongest_session_key
1848                                  : config->svc_use_strongest_session_key,
1849                           FALSE, r->client, r->client_princ,
1850                           b->etype.val, b->etype.len,
1851                           &r->sessionetype, NULL, NULL);
1852     if (ret) {
1853         kdc_log(context, config, 0,
1854                 "Client (%s) from %s has no common enctypes with KDC "
1855                 "to use for the session key",
1856                 r->client_name, from);
1857         goto out;
1858     }
1859
1860     /*
1861      * Pre-auth processing
1862      */
1863
1864     if(req->padata){
1865         unsigned int n;
1866
1867         log_patypes(context, config, req->padata);
1868
1869         /* Check if preauth matching */
1870
1871         for (n = 0; !found_pa && n < sizeof(pat) / sizeof(pat[0]); n++) {
1872             if (pat[n].validate == NULL)
1873                 continue;
1874             if (r->armor_crypto == NULL && (pat[n].flags & PA_REQ_FAST))
1875                 continue;
1876
1877             kdc_log(context, config, 5,
1878                     "Looking for %s pa-data -- %s", pat[n].name, r->client_name);
1879             i = 0;
1880             pa = _kdc_find_padata(req, &i, pat[n].type);
1881             if (pa) {
1882                 ret = pat[n].validate(r, pa);
1883                 if (ret != 0) {
1884                     krb5_error_code  ret2;
1885                     Key *ckey = NULL;
1886                     krb5_boolean default_salt;
1887
1888                     /*
1889                      * If there is a client key, send ETYPE_INFO{,2}
1890                      */
1891                     ret2 = _kdc_find_etype(context,
1892                                            config->preauth_use_strongest_session_key,
1893                                            TRUE, r->client, r->client_princ, b->etype.val,
1894                                            b->etype.len, NULL, &ckey, &default_salt);
1895                     if (ret2 == 0) {
1896                         ret2 = get_pa_etype_info_both(context, config, &b->etype,
1897                                                       &error_method, ckey, !default_salt);
1898                         if (ret2 != 0)
1899                             ret = ret2;
1900                     }
1901                     goto out;
1902                 }
1903                 kdc_log(context, config, 0,
1904                         "%s pre-authentication succeeded -- %s",
1905                         pat[n].name, r->client_name);
1906                 found_pa = 1;
1907                 r->et.flags.pre_authent = 1;
1908             }
1909         }
1910     }
1911
1912     if (found_pa == 0) {
1913         Key *ckey = NULL;
1914         size_t n;
1915         krb5_boolean default_salt;
1916
1917         for (n = 0; n < sizeof(pat) / sizeof(pat[0]); n++) {
1918             if ((pat[n].flags & PA_ANNOUNCE) == 0)
1919                 continue;
1920             ret = krb5_padata_add(context, &error_method,
1921                                   pat[n].type, NULL, 0);
1922             if (ret)
1923                 goto out;
1924         }
1925
1926         /*
1927          * If there is a client key, send ETYPE_INFO{,2}
1928          */
1929         ret = _kdc_find_etype(context,
1930                               config->preauth_use_strongest_session_key, TRUE,
1931                               r->client, r->client_princ,
1932                               b->etype.val, b->etype.len, NULL,
1933                               &ckey, &default_salt);
1934         if (ret == 0) {
1935             ret = get_pa_etype_info_both(context, config, &b->etype,
1936                                          &error_method, ckey, !default_salt);
1937             if (ret)
1938                 goto out;
1939         }
1940
1941         /*
1942          * send requre preauth is its required or anon is requested,
1943          * anon is today only allowed via preauth mechanisms.
1944          */
1945         if (require_preauth_p(r) || _kdc_is_anon_request(b)) {
1946             ret = KRB5KDC_ERR_PREAUTH_REQUIRED;
1947             _kdc_set_e_text(r, "Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ");
1948             goto out;
1949         }
1950
1951         if (ckey == NULL) {
1952             ret = KRB5KDC_ERR_CLIENT_NOTYET;
1953             _kdc_set_e_text(r, "Doesn't have a client key available");
1954             goto out;
1955         }
1956         krb5_free_keyblock_contents(r->context,  &r->reply_key);
1957         ret = krb5_copy_keyblock_contents(r->context, &ckey->key, &r->reply_key);
1958         if (ret)
1959             goto out;
1960     }
1961
1962     if (r->clientdb->hdb_auth_status) {
1963         r->clientdb->hdb_auth_status(context, r->clientdb, r->client,
1964                                      HDB_AUTH_SUCCESS);
1965     }
1966
1967     /*
1968      * Verify flags after the user been required to prove its identity
1969      * with in a preauth mech.
1970      */
1971
1972     ret = _kdc_check_access(context, config, r->client, r->client_name,
1973                             r->server, r->server_name,
1974                             req, &error_method);
1975     if(ret)
1976         goto out;
1977
1978     /*
1979      * Select the best encryption type for the KDC with out regard to
1980      * the client since the client never needs to read that data.
1981      */
1982
1983     ret = _kdc_get_preferred_key(context, config,
1984                                  r->server, r->server_name,
1985                                  &setype, &skey);
1986     if(ret)
1987         goto out;
1988
1989     if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey
1990        || (_kdc_is_anon_request(b) && !config->allow_anonymous)) {
1991         ret = KRB5KDC_ERR_BADOPTION;
1992         _kdc_set_e_text(r, "Bad KDC options");
1993         goto out;
1994     }
1995
1996     /*
1997      * Build reply
1998      */
1999
2000     rep.pvno = 5;
2001     rep.msg_type = krb_as_rep;
2002
2003     if (_kdc_is_anonymous(context, r->client_princ)) {
2004         Realm anon_realm=KRB5_ANON_REALM;
2005         ret = copy_Realm(&anon_realm, &rep.crealm);
2006     } else if (f.canonicalize || r->client->entry.flags.force_canonicalize)
2007         ret = copy_Realm(&r->client->entry.principal->realm, &rep.crealm);
2008     else
2009         ret = copy_Realm(&r->client_princ->realm, &rep.crealm);
2010     if (ret)
2011         goto out;
2012     if (f.canonicalize || r->client->entry.flags.force_canonicalize)
2013         ret = _krb5_principal2principalname(&rep.cname, r->client->entry.principal);
2014     else
2015         ret = _krb5_principal2principalname(&rep.cname, r->client_princ);
2016     if (ret)
2017         goto out;
2018
2019     rep.ticket.tkt_vno = 5;
2020     if (f.canonicalize || r->server->entry.flags.force_canonicalize)
2021         ret = copy_Realm(&r->server->entry.principal->realm, &rep.ticket.realm);
2022     else
2023         ret = copy_Realm(&r->server_princ->realm, &rep.ticket.realm);
2024     if (ret)
2025         goto out;
2026     if (f.canonicalize || r->server->entry.flags.force_canonicalize)
2027         _krb5_principal2principalname(&rep.ticket.sname,
2028                                       r->server->entry.principal);
2029     else
2030         _krb5_principal2principalname(&rep.ticket.sname,
2031                                       r->server_princ);
2032     /* java 1.6 expects the name to be the same type, lets allow that
2033      * uncomplicated name-types. */
2034 #define CNT(sp,t) (((sp)->sname->name_type) == KRB5_NT_##t)
2035     if (CNT(b, UNKNOWN) || CNT(b, PRINCIPAL) || CNT(b, SRV_INST) || CNT(b, SRV_HST) || CNT(b, SRV_XHST))
2036         rep.ticket.sname.name_type = b->sname->name_type;
2037 #undef CNT
2038
2039     r->et.flags.initial = 1;
2040     if(r->client->entry.flags.forwardable && r->server->entry.flags.forwardable)
2041         r->et.flags.forwardable = f.forwardable;
2042     else if (f.forwardable) {
2043         _kdc_set_e_text(r, "Ticket may not be forwardable");
2044         ret = KRB5KDC_ERR_POLICY;
2045         goto out;
2046     }
2047     if(r->client->entry.flags.proxiable && r->server->entry.flags.proxiable)
2048         r->et.flags.proxiable = f.proxiable;
2049     else if (f.proxiable) {
2050         _kdc_set_e_text(r, "Ticket may not be proxiable");
2051         ret = KRB5KDC_ERR_POLICY;
2052         goto out;
2053     }
2054     if(r->client->entry.flags.postdate && r->server->entry.flags.postdate)
2055         r->et.flags.may_postdate = f.allow_postdate;
2056     else if (f.allow_postdate){
2057         _kdc_set_e_text(r, "Ticket may not be postdate");
2058         ret = KRB5KDC_ERR_POLICY;
2059         goto out;
2060     }
2061
2062     /* check for valid set of addresses */
2063     if(!_kdc_check_addresses(context, config, b->addresses, from_addr)) {
2064         _kdc_set_e_text(r, "Bad address list in requested");
2065         ret = KRB5KRB_AP_ERR_BADADDR;
2066         goto out;
2067     }
2068
2069     ret = copy_PrincipalName(&rep.cname, &r->et.cname);
2070     if (ret)
2071         goto out;
2072     ret = copy_Realm(&rep.crealm, &r->et.crealm);
2073     if (ret)
2074         goto out;
2075
2076     {
2077         time_t start;
2078         time_t t;
2079
2080         start = r->et.authtime = kdc_time;
2081
2082         if(f.postdated && req->req_body.from){
2083             ALLOC(r->et.starttime);
2084             start = *r->et.starttime = *req->req_body.from;
2085             r->et.flags.invalid = 1;
2086             r->et.flags.postdated = 1; /* XXX ??? */
2087         }
2088         _kdc_fix_time(&b->till);
2089         t = *b->till;
2090
2091         /* be careful not overflowing */
2092
2093         if(r->client->entry.max_life)
2094             t = start + min(t - start, *r->client->entry.max_life);
2095         if(r->server->entry.max_life)
2096             t = start + min(t - start, *r->server->entry.max_life);
2097 #if 0
2098         t = min(t, start + realm->max_life);
2099 #endif
2100         r->et.endtime = t;
2101         if(f.renewable_ok && r->et.endtime < *b->till){
2102             f.renewable = 1;
2103             if(b->rtime == NULL){
2104                 ALLOC(b->rtime);
2105                 *b->rtime = 0;
2106             }
2107             if(*b->rtime < *b->till)
2108                 *b->rtime = *b->till;
2109         }
2110         if(f.renewable && b->rtime){
2111             t = *b->rtime;
2112             if(t == 0)
2113                 t = MAX_TIME;
2114             if(r->client->entry.max_renew)
2115                 t = start + min(t - start, *r->client->entry.max_renew);
2116             if(r->server->entry.max_renew)
2117                 t = start + min(t - start, *r->server->entry.max_renew);
2118 #if 0
2119             t = min(t, start + realm->max_renew);
2120 #endif
2121             ALLOC(r->et.renew_till);
2122             *r->et.renew_till = t;
2123             r->et.flags.renewable = 1;
2124         }
2125     }
2126
2127     if (_kdc_is_anon_request(b))
2128         r->et.flags.anonymous = 1;
2129
2130     if(b->addresses){
2131         ALLOC(r->et.caddr);
2132         copy_HostAddresses(b->addresses, r->et.caddr);
2133     }
2134
2135     r->et.transited.tr_type = DOMAIN_X500_COMPRESS;
2136     krb5_data_zero(&r->et.transited.contents);
2137
2138     /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
2139      * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
2140      * incapable of correctly decoding SEQUENCE OF's of zero length.
2141      *
2142      * To fix this, always send at least one no-op last_req
2143      *
2144      * If there's a pw_end or valid_end we will use that,
2145      * otherwise just a dummy lr.
2146      */
2147     r->ek.last_req.val = malloc(2 * sizeof(*r->ek.last_req.val));
2148     if (r->ek.last_req.val == NULL) {
2149         ret = ENOMEM;
2150         goto out;
2151     }
2152     r->ek.last_req.len = 0;
2153     if (r->client->entry.pw_end
2154         && (config->kdc_warn_pwexpire == 0
2155             || kdc_time + config->kdc_warn_pwexpire >= *r->client->entry.pw_end)) {
2156         r->ek.last_req.val[r->ek.last_req.len].lr_type  = LR_PW_EXPTIME;
2157         r->ek.last_req.val[r->ek.last_req.len].lr_value = *r->client->entry.pw_end;
2158         ++r->ek.last_req.len;
2159     }
2160     if (r->client->entry.valid_end) {
2161         r->ek.last_req.val[r->ek.last_req.len].lr_type  = LR_ACCT_EXPTIME;
2162         r->ek.last_req.val[r->ek.last_req.len].lr_value = *r->client->entry.valid_end;
2163         ++r->ek.last_req.len;
2164     }
2165     if (r->ek.last_req.len == 0) {
2166         r->ek.last_req.val[r->ek.last_req.len].lr_type  = LR_NONE;
2167         r->ek.last_req.val[r->ek.last_req.len].lr_value = 0;
2168         ++r->ek.last_req.len;
2169     }
2170     r->ek.nonce = b->nonce;
2171     if (r->client->entry.valid_end || r->client->entry.pw_end) {
2172         ALLOC(r->ek.key_expiration);
2173         if (r->client->entry.valid_end) {
2174             if (r->client->entry.pw_end)
2175                 *r->ek.key_expiration = min(*r->client->entry.valid_end,
2176                                          *r->client->entry.pw_end);
2177             else
2178                 *r->ek.key_expiration = *r->client->entry.valid_end;
2179         } else
2180             *r->ek.key_expiration = *r->client->entry.pw_end;
2181     } else
2182         r->ek.key_expiration = NULL;
2183     r->ek.flags = r->et.flags;
2184     r->ek.authtime = r->et.authtime;
2185     if (r->et.starttime) {
2186         ALLOC(r->ek.starttime);
2187         *r->ek.starttime = *r->et.starttime;
2188     }
2189     r->ek.endtime = r->et.endtime;
2190     if (r->et.renew_till) {
2191         ALLOC(r->ek.renew_till);
2192         *r->ek.renew_till = *r->et.renew_till;
2193     }
2194     ret = copy_Realm(&rep.ticket.realm, &r->ek.srealm);
2195     if (ret)
2196         goto out;
2197     ret = copy_PrincipalName(&rep.ticket.sname, &r->ek.sname);
2198     if (ret)
2199         goto out;
2200     if(r->et.caddr){
2201         ALLOC(r->ek.caddr);
2202         copy_HostAddresses(r->et.caddr, r->ek.caddr);
2203     }
2204
2205     /*
2206      * Check and session and reply keys
2207      */
2208
2209     if (r->session_key.keytype == ETYPE_NULL) {
2210         ret = krb5_generate_random_keyblock(context, r->sessionetype, &r->session_key);
2211         if (ret)
2212             goto out;
2213     }
2214
2215     if (r->reply_key.keytype == ETYPE_NULL) {
2216         _kdc_set_e_text(r, "Client have no reply key");
2217         ret = KRB5KDC_ERR_CLIENT_NOTYET;
2218         goto out;
2219     }
2220
2221     ret = copy_EncryptionKey(&r->session_key, &r->et.key);
2222     if (ret)
2223         goto out;
2224
2225     ret = copy_EncryptionKey(&r->session_key, &r->ek.key);
2226     if (ret)
2227         goto out;
2228
2229     if (r->outpadata.len) {
2230
2231         ALLOC(rep.padata);
2232         if (rep.padata == NULL) {
2233             ret = ENOMEM;
2234             goto out;
2235         }
2236         ret = copy_METHOD_DATA(&r->outpadata, rep.padata);
2237         if (ret)
2238             goto out;
2239     }
2240
2241     /* Add the PAC */
2242     if (send_pac_p(context, req)) {
2243         generate_pac(r, skey);
2244     }
2245
2246     _kdc_log_timestamp(context, config, "AS-REQ", r->et.authtime, r->et.starttime,
2247                        r->et.endtime, r->et.renew_till);
2248
2249     /* do this as the last thing since this signs the EncTicketPart */
2250     ret = _kdc_add_KRB5SignedPath(context,
2251                                   config,
2252                                   r->server,
2253                                   setype,
2254                                   r->client->entry.principal,
2255                                   NULL,
2256                                   NULL,
2257                                   &r->et);
2258     if (ret)
2259         goto out;
2260
2261     log_as_req(context, config, r->reply_key.keytype, setype, b);
2262
2263     /*
2264      * We always say we support FAST/enc-pa-rep
2265      */
2266
2267     r->et.flags.enc_pa_rep = r->ek.flags.enc_pa_rep = 1;
2268
2269     /*
2270      * Add REQ_ENC_PA_REP if client supports it
2271      */
2272
2273     i = 0;
2274     pa = _kdc_find_padata(req, &i, KRB5_PADATA_REQ_ENC_PA_REP);
2275     if (pa) {
2276
2277         ret = add_enc_pa_rep(r);
2278         if (ret) {
2279             const char *msg = krb5_get_error_message(r->context, ret);
2280             _kdc_r_log(r, 0, "add_enc_pa_rep failed: %s: %d", msg, ret);
2281             krb5_free_error_message(r->context, msg);
2282             goto out;
2283         }
2284     }
2285
2286     /*
2287      *
2288      */
2289
2290     ret = _kdc_encode_reply(context, config,
2291                             r->armor_crypto, req->req_body.nonce,
2292                             &rep, &r->et, &r->ek, setype, r->server->entry.kvno,
2293                             &skey->key, r->client->entry.kvno,
2294                             &r->reply_key, 0, &r->e_text, reply);
2295     if (ret)
2296         goto out;
2297
2298     /*
2299      * Check if message too large
2300      */
2301     if (datagram_reply && reply->length > config->max_datagram_reply_length) {
2302         krb5_data_free(reply);
2303         ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2304         _kdc_set_e_text(r, "Reply packet too large");
2305     }
2306
2307 out:
2308     free_AS_REP(&rep);
2309
2310     /*
2311      * In case of a non proxy error, build an error message.
2312      */
2313     if (ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE && reply->length == 0) {
2314         ret = _kdc_fast_mk_error(context, r,
2315                                  &error_method,
2316                                  r->armor_crypto,
2317                                  &req->req_body,
2318                                  ret, r->e_text,
2319                                  r->server_princ,
2320                                  r->client_princ ?
2321                                      &r->client_princ->name : NULL,
2322                                  r->client_princ ?
2323                                      &r->client_princ->realm : NULL,
2324                                  NULL, NULL,
2325                                  reply);
2326         if (ret)
2327             goto out2;
2328     }
2329 out2:
2330     free_EncTicketPart(&r->et);
2331     free_EncKDCRepPart(&r->ek);
2332     free_KDCFastState(&r->fast);
2333
2334     if (error_method.len)
2335         free_METHOD_DATA(&error_method);
2336     if (r->outpadata.len)
2337         free_METHOD_DATA(&r->outpadata);
2338     if (r->client_princ) {
2339         krb5_free_principal(context, r->client_princ);
2340         r->client_princ = NULL;
2341     }
2342     if (r->client_name) {
2343         free(r->client_name);
2344         r->client_name = NULL;
2345     }
2346     if (r->server_princ){
2347         krb5_free_principal(context, r->server_princ);
2348         r->server_princ = NULL;
2349     }
2350     if (r->server_name) {
2351         free(r->server_name);
2352         r->server_name = NULL;
2353     }
2354     if (r->client)
2355         _kdc_free_ent(context, r->client);
2356     if (r->server)
2357         _kdc_free_ent(context, r->server);
2358     if (r->armor_crypto) {
2359         krb5_crypto_destroy(r->context, r->armor_crypto);
2360         r->armor_crypto = NULL;
2361     }
2362     krb5_free_keyblock_contents(r->context, &r->reply_key);
2363     krb5_free_keyblock_contents(r->context, &r->session_key);
2364     return ret;
2365 }
2366
2367 /*
2368  * Add the AuthorizationData `data´ of `type´ to the last element in
2369  * the sequence of authorization_data in `tkt´ wrapped in an IF_RELEVANT
2370  */
2371
2372 krb5_error_code
2373 _kdc_tkt_add_if_relevant_ad(krb5_context context,
2374                             EncTicketPart *tkt,
2375                             int type,
2376                             const krb5_data *data)
2377 {
2378     krb5_error_code ret;
2379     size_t size = 0;
2380
2381     if (tkt->authorization_data == NULL) {
2382         tkt->authorization_data = calloc(1, sizeof(*tkt->authorization_data));
2383         if (tkt->authorization_data == NULL) {
2384             krb5_set_error_message(context, ENOMEM, "out of memory");
2385             return ENOMEM;
2386         }
2387     }
2388
2389     /* add the entry to the last element */
2390     {
2391         AuthorizationData ad = { 0, NULL };
2392         AuthorizationDataElement ade;
2393
2394         ade.ad_type = type;
2395         ade.ad_data = *data;
2396
2397         ret = add_AuthorizationData(&ad, &ade);
2398         if (ret) {
2399             krb5_set_error_message(context, ret, "add AuthorizationData failed");
2400             return ret;
2401         }
2402
2403         ade.ad_type = KRB5_AUTHDATA_IF_RELEVANT;
2404
2405         ASN1_MALLOC_ENCODE(AuthorizationData,
2406                            ade.ad_data.data, ade.ad_data.length,
2407                            &ad, &size, ret);
2408         free_AuthorizationData(&ad);
2409         if (ret) {
2410             krb5_set_error_message(context, ret, "ASN.1 encode of "
2411                                    "AuthorizationData failed");
2412             return ret;
2413         }
2414         if (ade.ad_data.length != size)
2415             krb5_abortx(context, "internal asn.1 encoder error");
2416
2417         ret = add_AuthorizationData(tkt->authorization_data, &ade);
2418         der_free_octet_string(&ade.ad_data);
2419         if (ret) {
2420             krb5_set_error_message(context, ret, "add AuthorizationData failed");
2421             return ret;
2422         }
2423     }
2424
2425     return 0;
2426 }
2427
2428 krb5_boolean
2429 _kdc_is_anon_request(const KDC_REQ_BODY *b)
2430 {
2431         /* some versions of heimdal use bit 14 instead of 16 for
2432            request_anonymous, as indicated in the anonymous draft prior to
2433            version 11. Bit 14 is assigned to S4U2Proxy, but all S4U2Proxy
2434            requests will have a second ticket; don't consider those anonymous */
2435         return (b->kdc_options.request_anonymous ||
2436                 (b->kdc_options.constrained_delegation && !b->additional_tickets));
2437 }