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 #ifdef TIME_T_SIGNED
  37 #if SIZEOF_TIME_T == 4
  38 #define MAX_TIME ((time_t)INT32_MAX)
  39 #elif SIZEOF_TIME_T == 8
  40 #define MAX_TIME ((time_t)INT64_MAX)
  41 #else
  42 #error "Unexpected sizeof(time_t)"
  43 #endif
  44 #else
  45
  46 #if SIZEOF_TIME_T == 4
  47 #define MAX_TIME ((time_t)UINT32_MAX)
  48 #else
  49 #define MAX_TIME ((time_t)UINT64_MAX)
  50 #endif
  51 #endif
  52
  53 #undef __attribute__
  54 #define __attribute__(X)
  55
  56 void
  57 _kdc_fix_time(time_t **t)
  58 {
  59     if(*t == NULL){
  60         ALLOC(*t);
  61         **t = MAX_TIME;
  62     }
  63     if(**t == 0) **t = MAX_TIME; /* fix for old clients */
  64 }
  65
  66 static int
  67 realloc_method_data(METHOD_DATA *md)
  68 {
  69     PA_DATA *pa;
  70     pa = realloc(md->val, (md->len + 1) * sizeof(*md->val));
  71     if(pa == NULL)
  72         return ENOMEM;
  73     md->val = pa;
  74     md->len++;
  75     return 0;
  76 }
  77
  78 static krb5_error_code
  79 get_pa_etype_info2(krb5_context context,
  80                    krb5_kdc_configuration *config,
  81                    METHOD_DATA *md, Key *ckey,
  82                    krb5_boolean include_salt);
  83
  84 static krb5_error_code
  85 set_salt_padata(krb5_context context,
  86                 krb5_kdc_configuration *config,
  87                 METHOD_DATA *md, Key *key)
  88 {
  89     if (!key->salt)
  90         return 0;
  91
  92     return get_pa_etype_info2(context, config, md, key, TRUE);
  93 }
  94
  95 const PA_DATA*
  96 _kdc_find_padata(const KDC_REQ *req, int *start, int type)
  97 {
  98     if (req->padata == NULL)
  99         return NULL;
 100
 101     while((size_t)*start < req->padata->len){
 102         (*start)++;
 103         if(req->padata->val[*start - 1].padata_type == (unsigned)type)
 104             return &req->padata->val[*start - 1];
 105     }
 106     return NULL;
 107 }
 108
 109 /*
 110  * This is a hack to allow predefined weak services, like afs to
 111  * still use weak types
 112  */
 113
 114 krb5_boolean
 115 _kdc_is_weak_exception(krb5_principal principal, krb5_enctype etype)
 116 {
 117     if (principal->name.name_string.len > 0 &&
 118         strcmp(principal->name.name_string.val[0], "afs") == 0 &&
 119         (etype == ETYPE_DES_CBC_CRC
 120          || etype == ETYPE_DES_CBC_MD4
 121          || etype == ETYPE_DES_CBC_MD5))
 122         return TRUE;
 123     return FALSE;
 124 }
 125
 126
 127 /*
 128  * Detect if `key' is the using the the precomputed `default_salt'.
 129  */
 130
 131 static krb5_boolean
 132 is_default_salt_p(const krb5_salt *default_salt, const Key *key)
 133 {
 134     if (key->salt == NULL)
 135         return TRUE;
 136     if (default_salt->salttype != key->salt->type)
 137         return FALSE;
 138     if (krb5_data_cmp(&default_salt->saltvalue, &key->salt->salt) != 0)
 139         return FALSE;
 140     return TRUE;
 141 }
 142
 143 /*
 144  * Detect if `key' is the using the the precomputed `default_salt'
 145  * (for des-cbc-crc) or any salt otherwise.
 146  *
 147  * This is for avoiding Kerberos v4 (yes really) keys in AS-REQ as
 148  * that salt is strange, and a buggy client will try to use the
 149  * principal as the salt and not the returned value.
 150  */
 151
 152 static krb5_boolean
 153 is_good_salt_p(const krb5_salt *default_salt, const Key *key)
 154 {
 155     if (key->key.keytype == KRB5_ENCTYPE_DES_CBC_CRC)
 156         return is_default_salt_p(default_salt, key);
 157
 158     return TRUE;
 159 }
 160
 161 krb5_boolean
 162 _kdc_is_anon_request(const KDC_REQ *req)
 163 {
 164     const KDC_REQ_BODY *b = &req->req_body;
 165
 166     /*
 167      * Versions of Heimdal from 0.9rc1 through 1.50 use bit 14 instead
 168      * of 16 for request_anonymous, as indicated in the anonymous draft
 169      * prior to version 11. Bit 14 is assigned to S4U2Proxy, but S4U2Proxy
 170      * requests are only sent to the TGS and, in any case, would have an
 171      * additional ticket present.
 172      */
 173     return b->kdc_options.request_anonymous ||
 174            (b->kdc_options.cname_in_addl_tkt && !b->additional_tickets);
 175 }
 176
 177 /*
 178  * return the first appropriate key of `princ' in `ret_key'.  Look for
 179  * all the etypes in (`etypes', `len'), stopping as soon as we find
 180  * one, but preferring one that has default salt.
 181  *
 182  * XXX This function does way way too much.  Split it up!
 183  *
 184  * XXX `etypes' and `len' are always `b->etype.val' and `b->etype.len' -- the
 185  *     etype list from the KDC-REQ-BODY, which is available here as
 186  *     `r->req->req_body', so we could just stop having it passed in.
 187  *
 188  * XXX Picking an enctype(s) for PA-ETYPE-INFO* is rather different than
 189  *     picking an enctype for a ticket's session key.  The former is what we do
 190  *     here when `(flags & KFE_IS_PREAUTH)', the latter otherwise.
 191  */
 192
 193 krb5_error_code
 194 _kdc_find_etype(astgs_request_t r, uint32_t flags,
 195                 krb5_enctype *etypes, unsigned len,
 196                 krb5_enctype *ret_enctype, Key **ret_key,
 197                 krb5_boolean *ret_default_salt)
 198 {
 199     krb5_boolean use_strongest_session_key;
 200     krb5_boolean is_preauth = flags & KFE_IS_PREAUTH;
 201     krb5_boolean is_tgs = flags & KFE_IS_TGS;
 202     hdb_entry *princ;
 203     krb5_principal request_princ;
 204     krb5_error_code ret;
 205     krb5_salt def_salt;
 206     krb5_enctype enctype = ETYPE_NULL;
 207     const krb5_enctype *p;
 208     Key *key = NULL;
 209     size_t i, k, m;
 210
 211     if (is_preauth && (flags & KFE_USE_CLIENT) &&
 212         r->client->flags.synthetic)
 213         return KRB5KDC_ERR_ETYPE_NOSUPP;
 214
 215     if ((flags & KFE_USE_CLIENT) && !r->client->flags.synthetic) {
 216         princ = r->client;
 217         request_princ = r->client_princ;
 218     } else {
 219         princ = r->server;
 220         request_princ = r->server->principal;
 221     }
 222
 223     use_strongest_session_key =
 224         is_preauth ? r->config->preauth_use_strongest_session_key
 225             : (is_tgs ? r->config->tgt_use_strongest_session_key :
 226                         r->config->svc_use_strongest_session_key);
 227
 228     /* We'll want to avoid keys with v4 salted keys in the pre-auth case... */
 229     ret = krb5_get_pw_salt(r->context, request_princ, &def_salt);
 230     if (ret)
 231         return ret;
 232
 233     ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 234
 235     /*
 236      * Pick an enctype that is in the intersection of:
 237      *
 238      *  - permitted_enctypes (local policy)
 239      *  - requested enctypes (KDC-REQ-BODY's etype list)
 240      *  - the client's long-term keys' enctypes
 241      *    OR
 242      *    the server's configured etype list
 243      *
 244      * There are two sub-cases:
 245      *
 246      *  - use local enctype preference (local policy)
 247      *  - use the client's preference list
 248      */
 249
 250     if (use_strongest_session_key) {
 251         /*
 252          * Pick the strongest key that the KDC, target service, and
 253          * client all support, using the local cryptosystem enctype
 254          * list in strongest-to-weakest order to drive the search.
 255          *
 256          * This is not what RFC4120 says to do, but it encourages
 257          * adoption of stronger enctypes.  This doesn't play well with
 258          * clients that have multiple Kerberos client implementations
 259          * with different supported enctype lists sharing the same ccache.
 260          */
 261
 262         /* drive the search with local supported enctypes list */
 263         p = krb5_kerberos_enctypes(r->context);
 264         for (i = 0;
 265             p[i] != ETYPE_NULL && enctype == ETYPE_NULL;
 266             i++) {
 267             if (krb5_enctype_valid(r->context, p[i]) != 0 &&
 268                 !_kdc_is_weak_exception(princ->principal, p[i]))
 269                 continue;
 270
 271             /* check that the client supports it too */
 272             for (k = 0; k < len && enctype == ETYPE_NULL; k++) {
 273
 274                 if (p[i] != etypes[k])
 275                     continue;
 276
 277                 if (!is_preauth && (flags & KFE_USE_CLIENT)) {
 278                     /*
 279                      * It suffices that the client says it supports this
 280                      * enctype in its KDC-REQ-BODY's etype list, which is what
 281                      * `etypes' is here.
 282                      */
 283                     enctype = p[i];
 284                     ret = 0;
 285                     break;
 286                 }
 287
 288                 /* check target princ support */
 289                 key = NULL;
 290                 if (!is_preauth && !(flags & KFE_USE_CLIENT) && princ->etypes) {
 291                     /*
 292                      * Use the etypes list from the server's HDB entry instead
 293                      * of deriving it from its long-term keys.  This allows an
 294                      * entry to have just one long-term key but record support
 295                      * for multiple enctypes.
 296                      */
 297                     for (m = 0; m < princ->etypes->len; m++) {
 298                         if (p[i] == princ->etypes->val[m]) {
 299                             enctype = p[i];
 300                             ret = 0;
 301                             break;
 302                         }
 303                     }
 304                 } else {
 305                     /*
 306                      * Use the entry's long-term keys as the source of its
 307                      * supported enctypes, either because we're making
 308                      * PA-ETYPE-INFO* or because we're selecting a session key
 309                      * enctype.
 310                      */
 311                     while (hdb_next_enctype2key(r->context, princ, NULL,
 312                                                  p[i], &key) == 0) {
 313                         if (key->key.keyvalue.length == 0) {
 314                             ret = KRB5KDC_ERR_NULL_KEY;
 315                             continue;
 316                         }
 317                         enctype = p[i];
 318                         ret = 0;
 319                         if (is_preauth && ret_key != NULL &&
 320                             !is_good_salt_p(&def_salt, key))
 321                             continue;
 322                     }
 323                 }
 324             }
 325         }
 326     } else {
 327         /*
 328          * Pick the first key from the client's enctype list that is
 329          * supported by the cryptosystem and by the given principal.
 330          *
 331          * RFC4120 says we SHOULD pick the first _strong_ key from the
 332          * client's list... not the first key...  If the admin disallows
 333          * weak enctypes in krb5.conf and selects this key selection
 334          * algorithm, then we get exactly what RFC4120 says.
 335          */
 336         for(i = 0; ret != 0 && i < len; i++) {
 337
 338             if (krb5_enctype_valid(r->context, etypes[i]) != 0 &&
 339                 !_kdc_is_weak_exception(princ->principal, etypes[i]))
 340                 continue;
 341
 342             key = NULL;
 343             while (ret != 0 &&
 344                    hdb_next_enctype2key(r->context, princ, NULL,
 345                                         etypes[i], &key) == 0) {
 346                 if (key->key.keyvalue.length == 0) {
 347                     ret = KRB5KDC_ERR_NULL_KEY;
 348                     continue;
 349                 }
 350                 enctype = etypes[i];
 351                 ret = 0;
 352                 if (is_preauth && ret_key != NULL &&
 353                     !is_good_salt_p(&def_salt, key))
 354                     continue;
 355             }
 356         }
 357     }
 358
 359     if (ret == 0 && enctype == ETYPE_NULL) {
 360         /*
 361          * if the service principal is one for which there is a known 1DES
 362          * exception and no other enctype matches both the client request and
 363          * the service key list, provide a DES-CBC-CRC key.
 364          */
 365         if (ret_key == NULL &&
 366             _kdc_is_weak_exception(princ->principal, ETYPE_DES_CBC_CRC)) {
 367             ret = 0;
 368             enctype = ETYPE_DES_CBC_CRC;
 369         } else {
 370             ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 371         }
 372     }
 373
 374     if (ret == 0) {
 375         if (ret_enctype != NULL)
 376             *ret_enctype = enctype;
 377         if (ret_key != NULL)
 378             *ret_key = key;
 379         if (ret_default_salt != NULL)
 380             *ret_default_salt = is_default_salt_p(&def_salt, key);
 381     }
 382
 383     krb5_free_salt (r->context, def_salt);
 384     return ret;
 385 }
 386
 387 /*
 388  * The principal's session_etypes must be sorted in order of strength, with
 389  * preferred etype first.
 390 */
 391 krb5_error_code
 392 _kdc_find_session_etype(astgs_request_t r,
 393                         krb5_enctype *etypes, size_t len,
 394                         const hdb_entry *princ,
 395                         krb5_enctype *ret_enctype)
 396 {
 397     size_t i;
 398
 399     if (princ->session_etypes == NULL) {
 400         /* The principal must have session etypes available. */
 401         return KRB5KDC_ERR_ETYPE_NOSUPP;
 402     }
 403
 404     /* Loop over the client's specified etypes. */
 405     for (i = 0; i < len; ++i) {
 406         size_t j;
 407
 408         /* Check that the server also supports the etype. */
 409         for (j = 0; j < princ->session_etypes->len; ++j) {
 410             if (princ->session_etypes->val[j] == etypes[i]) {
 411                 *ret_enctype = etypes[i];
 412                 return 0;
 413             }
 414         }
 415     }
 416
 417     return KRB5KDC_ERR_ETYPE_NOSUPP;
 418 }
 419
 420 krb5_error_code
 421 _kdc_make_anonymous_principalname (PrincipalName *pn)
 422 {
 423     pn->name_type = KRB5_NT_WELLKNOWN;
 424     pn->name_string.len = 2;
 425     pn->name_string.val = calloc(2, sizeof(*pn->name_string.val));
 426     if (pn->name_string.val == NULL)
 427         goto failed;
 428
 429     pn->name_string.val[0] = strdup(KRB5_WELLKNOWN_NAME);
 430     if (pn->name_string.val[0] == NULL)
 431         goto failed;
 432
 433     pn->name_string.val[1] = strdup(KRB5_ANON_NAME);
 434     if (pn->name_string.val[1] == NULL)
 435         goto failed;
 436
 437     return 0;
 438
 439 failed:
 440     free_PrincipalName(pn);
 441
 442     pn->name_type = KRB5_NT_UNKNOWN;
 443     pn->name_string.len = 0;
 444     pn->name_string.val = NULL;
 445
 446     return ENOMEM;
 447 }
 448
 449 static void
 450 _kdc_r_log(astgs_request_t r, int level, const char *fmt, ...)
 451         __attribute__ ((__format__ (__printf__, 3, 4)))
 452 {
 453     va_list ap;
 454     char *s;
 455     va_start(ap, fmt);
 456     s = kdc_log_msg_va(r->context, r->config, level, fmt, ap);
 457     if(s) free(s);
 458     va_end(ap);
 459 }
 460
 461 void
 462 _kdc_set_const_e_text(astgs_request_t r, const char *e_text)
 463 {
 464     /* We should never see this */
 465     if (r->e_text) {
 466         kdc_log(r->context, r->config, 1,
 467                 "trying to replace e-text \"%s\" with \"%s\"\n",
 468                 r->e_text, e_text);
 469         return;
 470     }
 471
 472     r->e_text = e_text;
 473     kdc_log(r->context, r->config, 4, "%s", e_text);
 474 }
 475
 476 void
 477 _kdc_set_e_text(astgs_request_t r, const char *fmt, ...)
 478         __attribute__ ((__format__ (__printf__, 2, 3)))
 479 {
 480     va_list ap;
 481     char *e_text = NULL;
 482     int vasprintf_ret;
 483
 484     va_start(ap, fmt);
 485     vasprintf_ret = vasprintf(&e_text, fmt, ap);
 486     va_end(ap);
 487
 488     if (vasprintf_ret < 0 || !e_text) {
 489         /* not much else to do... */
 490         kdc_log(r->context, r->config, 1,
 491                 "Could not set e_text: %s (out of memory)", fmt);
 492         return;
 493     }
 494
 495     /* We should never see this */
 496     if (r->e_text) {
 497         kdc_log(r->context, r->config, 1, "trying to replace e-text: %s\n",
 498                 e_text);
 499         free(e_text);
 500         return;
 501     }
 502
 503     r->e_text = e_text;
 504     r->e_text_buf = e_text;
 505     kdc_log(r->context, r->config, 4, "%s", e_text);
 506 }
 507
 508 void
 509 _kdc_log_timestamp(astgs_request_t r, const char *type,
 510                    KerberosTime authtime, KerberosTime *starttime,
 511                    KerberosTime endtime, KerberosTime *renew_till)
 512 {
 513     krb5_kdc_configuration *config = r->config;
 514     char authtime_str[100], starttime_str[100],
 515         endtime_str[100], renewtime_str[100];
 516
 517     if (authtime)
 518         kdc_audit_setkv_number((kdc_request_t)r, "auth", authtime);
 519     if (starttime && *starttime)
 520         kdc_audit_setkv_number((kdc_request_t)r, "start", *starttime);
 521     if (endtime)
 522         kdc_audit_setkv_number((kdc_request_t)r, "end", endtime);
 523     if (renew_till && *renew_till)
 524         kdc_audit_setkv_number((kdc_request_t)r, "renew", *renew_till);
 525
 526     krb5_format_time(r->context, authtime,
 527                      authtime_str, sizeof(authtime_str), TRUE);
 528     if (starttime)
 529         krb5_format_time(r->context, *starttime,
 530                          starttime_str, sizeof(starttime_str), TRUE);
 531     else
 532         strlcpy(starttime_str, "unset", sizeof(starttime_str));
 533     krb5_format_time(r->context, endtime,
 534                      endtime_str, sizeof(endtime_str), TRUE);
 535     if (renew_till)
 536         krb5_format_time(r->context, *renew_till,
 537                          renewtime_str, sizeof(renewtime_str), TRUE);
 538     else
 539         strlcpy(renewtime_str, "unset", sizeof(renewtime_str));
 540
 541     kdc_log(r->context, config, 4,
 542             "%s authtime: %s starttime: %s endtime: %s renew till: %s",
 543             type, authtime_str, starttime_str, endtime_str, renewtime_str);
 544 }
 545
 546 /*
 547  *
 548  */
 549
 550 #ifdef PKINIT
 551
 552 static krb5_error_code
 553 pa_pkinit_validate(astgs_request_t r, const PA_DATA *pa)
 554 {
 555     pk_client_params *pkp = NULL;
 556     char *client_cert = NULL;
 557     krb5_error_code ret;
 558
 559     ret = _kdc_pk_rd_padata(r, pa, &pkp);
 560     if (ret || pkp == NULL) {
 561         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 562         _kdc_r_log(r, 4, "Failed to decode PKINIT PA-DATA -- %s",
 563                    r->cname);
 564         goto out;
 565     }
 566
 567     ret = _kdc_pk_check_client(r, pkp, &client_cert);
 568     if (client_cert)
 569         kdc_audit_addkv((kdc_request_t)r, 0, KDC_REQUEST_KV_PKINIT_CLIENT_CERT,
 570                         "%s", client_cert);
 571     if (ret) {
 572         _kdc_set_e_text(r, "PKINIT certificate not allowed to "
 573                         "impersonate principal");
 574         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 575                                KDC_AUTH_EVENT_CLIENT_NAME_UNAUTHORIZED);
 576         goto out;
 577     }
 578
 579     r->pa_endtime = _kdc_pk_endtime(pkp);
 580     if (!r->client->flags.synthetic)
 581         r->pa_max_life = _kdc_pk_max_life(pkp);
 582
 583     _kdc_r_log(r, 4, "PKINIT pre-authentication succeeded -- %s using %s",
 584                r->cname, client_cert);
 585
 586     ret = _kdc_pk_mk_pa_reply(r, pkp);
 587     if (ret) {
 588         _kdc_set_e_text(r, "Failed to build PK-INIT reply");
 589         goto out;
 590     }
 591     ret = _kdc_add_initial_verified_cas(r->context, r->config,
 592                                         pkp, &r->et);
 593
 594     kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 595                            KDC_AUTH_EVENT_PREAUTH_SUCCEEDED);
 596
 597  out:
 598     if (pkp)
 599         _kdc_pk_free_client_param(r->context, pkp);
 600     free(client_cert);
 601
 602     return ret;
 603 }
 604
 605 #endif /* PKINIT */
 606
 607 static krb5_error_code
 608 pa_gss_validate(astgs_request_t r, const PA_DATA *pa)
 609 {
 610     gss_client_params *gcp = NULL;
 611     char *client_name = NULL;
 612     krb5_error_code ret;
 613     int open = 0;
 614
 615     ret = _kdc_gss_rd_padata(r, pa, &gcp, &open);
 616     if (ret && gcp == NULL)
 617         return ret;
 618
 619     if (open) {
 620         ret = _kdc_gss_check_client(r, gcp, &client_name);
 621         if (client_name)
 622             kdc_audit_addkv((kdc_request_t)r, 0, KDC_REQUEST_KV_GSS_INITIATOR,
 623                             "%s", client_name);
 624         if (ret) {
 625             _kdc_set_e_text(r, "GSS-API client not allowed to "
 626                             "impersonate principal");
 627             kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 628                                    KDC_AUTH_EVENT_CLIENT_NAME_UNAUTHORIZED);
 629             goto out;
 630         }
 631
 632         r->pa_endtime = _kdc_gss_endtime(r, gcp);
 633
 634         _kdc_r_log(r, 4, "GSS pre-authentication succeeded -- %s using %s",
 635                    r->cname, client_name);
 636         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 637                                KDC_AUTH_EVENT_PREAUTH_SUCCEEDED);
 638
 639         ret = _kdc_gss_mk_composite_name_ad(r, gcp);
 640         if (ret) {
 641             _kdc_set_e_text(r, "Failed to build GSS authorization data");
 642             goto out;
 643         }
 644     }
 645
 646     ret = _kdc_gss_mk_pa_reply(r, gcp);
 647     if (ret) {
 648         if (ret != KRB5_KDC_ERR_MORE_PREAUTH_DATA_REQUIRED)
 649             _kdc_set_e_text(r, "Failed to build GSS pre-authentication reply");
 650         goto out;
 651     }
 652
 653     ret = kdc_request_set_attribute((kdc_request_t)r,
 654                                     HSTR("org.h5l.pa-gss-client-params"), gcp);
 655     if (ret)
 656         goto out;
 657
 658 out:
 659     kdc_object_release(gcp);
 660     free(client_name);
 661
 662     return ret;
 663 }
 664
 665 static krb5_error_code
 666 pa_gss_finalize_pac(astgs_request_t r)
 667 {
 668     gss_client_params *gcp;
 669
 670     gcp = kdc_request_get_attribute((kdc_request_t)r, HSTR("org.h5l.pa-gss-client-params"));
 671
 672     heim_assert(gcp != NULL, "invalid GSS-API client params");
 673
 674     return _kdc_gss_finalize_pac(r, gcp);
 675 }
 676
 677 static krb5_error_code
 678 pa_enc_chal_validate(astgs_request_t r, const PA_DATA *pa)
 679 {
 680     krb5_data pepper1, pepper2;
 681     int invalidPassword = 0;
 682     EncryptedData enc_data;
 683     krb5_enctype aenctype;
 684     krb5_error_code ret;
 685     struct Key *k;
 686     size_t size;
 687     int i;
 688
 689     heim_assert(r->armor_crypto != NULL, "ENC-CHAL called for non FAST");
 690
 691     if (_kdc_is_anon_request(&r->req)) {
 692         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 693         kdc_log(r->context, r->config, 4, "ENC-CHALL doesn't support anon");
 694         return ret;
 695     }
 696
 697     if (r->client->flags.locked_out) {
 698        ret = KRB5KDC_ERR_CLIENT_REVOKED;
 699        kdc_log(r->context, r->config, 0,
 700                "Client (%s) is locked out", r->cname);
 701        kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 702                               KDC_AUTH_EVENT_CLIENT_LOCKED_OUT);
 703        return ret;
 704     }
 705
 706     ret = decode_EncryptedData(pa->padata_value.data,
 707                                pa->padata_value.length,
 708                                &enc_data,
 709                                &size);
 710     if (ret) {
 711         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 712         _kdc_r_log(r, 4, "Failed to decode PA-DATA -- %s",
 713                    r->cname);
 714         return ret;
 715     }
 716
 717     pepper1.data = "clientchallengearmor";
 718     pepper1.length = strlen(pepper1.data);
 719     pepper2.data = "challengelongterm";
 720     pepper2.length = strlen(pepper2.data);
 721
 722     krb5_crypto_getenctype(r->context, r->armor_crypto, &aenctype);
 723
 724     kdc_log(r->context, r->config, 5, "FAST armor enctype is: %d", (int)aenctype);
 725
 726     for (i = 0; i < r->client->keys.len; i++) {
 727         krb5_crypto challengecrypto, longtermcrypto;
 728         krb5_keyblock challengekey;
 729
 730         k = &r->client->keys.val[i];
 731
 732         ret = krb5_crypto_init(r->context, &k->key, 0, &longtermcrypto);
 733         if (ret)
 734             continue;
 735
 736         ret = krb5_crypto_fx_cf2(r->context, r->armor_crypto, longtermcrypto,
 737                                  &pepper1, &pepper2, aenctype,
 738                                  &challengekey);
 739         if (ret) {
 740             krb5_crypto_destroy(r->context, longtermcrypto);
 741             continue;
 742         }
 743
 744         ret = krb5_crypto_init(r->context, &challengekey, 0,
 745                                &challengecrypto);
 746         krb5_free_keyblock_contents(r->context, &challengekey);
 747         if (ret) {
 748             krb5_crypto_destroy(r->context, longtermcrypto);
 749             continue;
 750         }
 751
 752         ret = _krb5_validate_pa_enc_challenge(r->context,
 753                                               challengecrypto,
 754                                               KRB5_KU_ENC_CHALLENGE_CLIENT,
 755                                               &enc_data,
 756                                               r->cname);
 757         krb5_crypto_destroy(r->context, challengecrypto);
 758         if (ret) {
 759             const char *msg;
 760             krb5_error_code ret2;
 761             char *str = NULL;
 762
 763             krb5_crypto_destroy(r->context, longtermcrypto);
 764
 765             invalidPassword = (ret == KRB5KRB_AP_ERR_BAD_INTEGRITY);
 766             if (!invalidPassword) {
 767                 goto out;
 768             }
 769
 770             ret2 = krb5_enctype_to_string(r->context, k->key.keytype, &str);
 771             if (ret2)
 772                 str = NULL;
 773             msg = krb5_get_error_message(r->context, ret);
 774             _kdc_r_log(r, 2, "Failed to decrypt ENC-CHAL -- %s "
 775                        "(enctype %s) error %s",
 776                        r->cname, str ? str : "unknown enctype", msg);
 777             krb5_free_error_message(r->context, msg);
 778             free(str);
 779
 780             continue;
 781         }
 782
 783         /*
 784          * Found a key that the client used, lets pick that as the reply key
 785          */
 786
 787         krb5_free_keyblock_contents(r->context, &r->reply_key);
 788         ret = krb5_copy_keyblock_contents(r->context, &k->key, &r->reply_key);
 789         if (ret) {
 790             krb5_crypto_destroy(r->context, longtermcrypto);
 791             goto out;
 792         }
 793
 794         krb5_free_keyblock_contents(r->context, &challengekey);
 795
 796         /*
 797          * Provide KDC authentication to the client, uses a different
 798          * challenge key (different pepper).
 799          */
 800
 801         pepper1.data = "kdcchallengearmor";
 802         pepper1.length = strlen(pepper1.data);
 803
 804         ret = krb5_crypto_fx_cf2(r->context, r->armor_crypto, longtermcrypto,
 805                                  &pepper1, &pepper2, aenctype,
 806                                  &challengekey);
 807         krb5_crypto_destroy(r->context, longtermcrypto);
 808         if (ret)
 809             goto out;
 810
 811         ret = krb5_crypto_init(r->context, &challengekey, 0, &challengecrypto);
 812         krb5_free_keyblock_contents(r->context, &challengekey);
 813         if (ret)
 814             goto out;
 815
 816         ret = _krb5_make_pa_enc_challenge(r->context, challengecrypto,
 817                                           KRB5_KU_ENC_CHALLENGE_KDC,
 818                                           r->rep.padata);
 819         krb5_crypto_destroy(r->context, challengecrypto);
 820         if (ret)
 821             goto out;
 822
 823         if (ret == 0)
 824             ret = set_salt_padata(r->context, r->config,
 825                                   r->rep.padata, k);
 826
 827         /*
 828          * Success
 829          */
 830         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 831                                KDC_AUTH_EVENT_VALIDATED_LONG_TERM_KEY);
 832         goto out;
 833     }
 834
 835     if (invalidPassword) {
 836         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 837                                KDC_AUTH_EVENT_WRONG_LONG_TERM_KEY);
 838         ret = KRB5KDC_ERR_PREAUTH_FAILED;
 839     } else {
 840         ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 841     }
 842  out:
 843     free_EncryptedData(&enc_data);
 844
 845     return ret;
 846 }
 847
 848 static krb5_error_code
 849 pa_enc_ts_validate(astgs_request_t r, const PA_DATA *pa)
 850 {
 851     EncryptedData enc_data;
 852     krb5_error_code ret;
 853     krb5_crypto crypto;
 854     krb5_data ts_data;
 855     PA_ENC_TS_ENC p;
 856     size_t len;
 857     Key *pa_key;
 858     char *str;
 859
 860     if (r->armor_crypto && !r->config->enable_armored_pa_enc_timestamp) {
 861        ret = KRB5KDC_ERR_POLICY;
 862        kdc_log(r->context, r->config, 0,
 863                "Armored encrypted timestamp pre-authentication is disabled");
 864        return ret;
 865     } else if (!r->armor_crypto && !r->config->enable_unarmored_pa_enc_timestamp) {
 866        ret = KRB5KDC_ERR_POLICY;
 867        kdc_log(r->context, r->config, 0,
 868                "Unarmored encrypted timestamp pre-authentication is disabled");
 869        return ret;
 870     }
 871
 872     if (r->client->flags.locked_out) {
 873        ret = KRB5KDC_ERR_CLIENT_REVOKED;
 874        kdc_log(r->context, r->config, 0,
 875                "Client (%s) is locked out", r->cname);
 876        kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 877                               KDC_AUTH_EVENT_CLIENT_LOCKED_OUT);
 878        return ret;
 879     }
 880
 881     ret = decode_EncryptedData(pa->padata_value.data,
 882                                pa->padata_value.length,
 883                                &enc_data,
 884                                &len);
 885     if (ret) {
 886         ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
 887         _kdc_r_log(r, 4, "Failed to decode PA-DATA -- %s",
 888                    r->cname);
 889         goto out;
 890     }
 891
 892     ret = hdb_enctype2key(r->context, r->client, NULL,
 893                           enc_data.etype, &pa_key);
 894     if(ret){
 895         char *estr;
 896         _kdc_set_e_text(r, "No key matching entype");
 897         ret = KRB5KDC_ERR_ETYPE_NOSUPP;
 898         if(krb5_enctype_to_string(r->context, enc_data.etype, &estr))
 899             estr = NULL;
 900         if(estr == NULL)
 901             _kdc_r_log(r, 4,
 902                        "No client key matching pa-data (%d) -- %s",
 903                        enc_data.etype, r->cname);
 904         else
 905             _kdc_r_log(r, 4,
 906                        "No client key matching pa-data (%s) -- %s",
 907                        estr, r->cname);
 908         free(estr);
 909         free_EncryptedData(&enc_data);
 910         goto out;
 911     }
 912
 913  try_next_key:
 914     ret = krb5_crypto_init(r->context, &pa_key->key, 0, &crypto);
 915     if (ret) {
 916         const char *msg = krb5_get_error_message(r->context, ret);
 917         _kdc_r_log(r, 4, "krb5_crypto_init failed: %s", msg);
 918         krb5_free_error_message(r->context, msg);
 919         free_EncryptedData(&enc_data);
 920         goto out;
 921     }
 922
 923     ret = krb5_decrypt_EncryptedData (r->context,
 924                                       crypto,
 925                                       KRB5_KU_PA_ENC_TIMESTAMP,
 926                                       &enc_data,
 927                                       &ts_data);
 928     krb5_crypto_destroy(r->context, crypto);
 929     /*
 930      * Since the user might have several keys with the same
 931      * enctype but with diffrent salting, we need to try all
 932      * the keys with the same enctype.
 933      */
 934     if(ret){
 935         krb5_error_code ret2;
 936         const char *msg = krb5_get_error_message(r->context, ret);
 937
 938         ret2 = krb5_enctype_to_string(r->context,
 939                                       pa_key->key.keytype, &str);
 940         if (ret2)
 941             str = NULL;
 942         _kdc_r_log(r, 2, "Failed to decrypt PA-DATA -- %s "
 943                    "(enctype %s) error %s",
 944                    r->cname, str ? str : "unknown enctype", msg);
 945         krb5_xfree(str);
 946         krb5_free_error_message(r->context, msg);
 947         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_PA_ETYPE,
 948                                pa_key->key.keytype);
 949         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 950                                KDC_AUTH_EVENT_WRONG_LONG_TERM_KEY);
 951         if(hdb_next_enctype2key(r->context, r->client, NULL,
 952                                 enc_data.etype, &pa_key) == 0)
 953             goto try_next_key;
 954
 955         free_EncryptedData(&enc_data);
 956
 957         ret = KRB5KDC_ERR_PREAUTH_FAILED;
 958         goto out;
 959     }
 960     free_EncryptedData(&enc_data);
 961     ret = decode_PA_ENC_TS_ENC(ts_data.data,
 962                                ts_data.length,
 963                                &p,
 964                                &len);
 965     krb5_data_free(&ts_data);
 966     if(ret){
 967         ret = KRB5KDC_ERR_PREAUTH_FAILED;
 968         _kdc_r_log(r, 4, "Failed to decode PA-ENC-TS_ENC -- %s",
 969                    r->cname);
 970         goto out;
 971     }
 972     if (labs(kdc_time - p.patimestamp) > r->context->max_skew) {
 973         char client_time[100];
 974
 975         krb5_format_time(r->context, p.patimestamp,
 976                          client_time, sizeof(client_time), TRUE);
 977
 978         ret = KRB5KRB_AP_ERR_SKEW;
 979         _kdc_r_log(r, 4, "Too large time skew, "
 980                    "client time %s is out by %u > %u seconds -- %s",
 981                    client_time,
 982                    (unsigned)labs(kdc_time - p.patimestamp),
 983                    r->context->max_skew,
 984                    r->cname);
 985         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
 986                                KDC_AUTH_EVENT_CLIENT_TIME_SKEW);
 987
 988         /*
 989          * The following is needed to make windows clients to
 990          * retry using the timestamp in the error message, if
 991          * there is a e_text, they become unhappy.
 992          */
 993         r->e_text = NULL;
 994         free_PA_ENC_TS_ENC(&p);
 995         goto out;
 996     }
 997     free_PA_ENC_TS_ENC(&p);
 998
 999     ret = set_salt_padata(r->context, r->config,
1000                           r->rep.padata, pa_key);
1001     if (ret == 0)
1002         ret = krb5_copy_keyblock_contents(r->context, &pa_key->key, &r->reply_key);
1003     if (ret)
1004         return ret;
1005
1006     ret = krb5_enctype_to_string(r->context, pa_key->key.keytype, &str);
1007     if (ret)
1008         str = NULL;
1009     _kdc_r_log(r, 4, "ENC-TS Pre-authentication succeeded -- %s using %s",
1010                r->cname, str ? str : "unknown enctype");
1011     krb5_xfree(str);
1012     kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_PA_ETYPE,
1013                            pa_key->key.keytype);
1014     kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
1015                            KDC_AUTH_EVENT_VALIDATED_LONG_TERM_KEY);
1016
1017     ret = 0;
1018
1019  out:
1020
1021     return ret;
1022 }
1023
1024 struct kdc_patypes {
1025     int type;
1026     char *name;
1027     unsigned int flags;
1028 #define PA_ANNOUNCE     1
1029 #define PA_REQ_FAST     2 /* only use inside fast */
1030 #define PA_SYNTHETIC_OK 4
1031 #define PA_REPLACE_REPLY_KEY    8   /* PA mech replaces reply key */
1032 #define PA_USES_LONG_TERM_KEY   16  /* PA mech uses client's long-term key */
1033     krb5_error_code (*validate)(astgs_request_t, const PA_DATA *pa);
1034     krb5_error_code (*finalize_pac)(astgs_request_t r);
1035     void (*cleanup)(astgs_request_t r);
1036 };
1037
1038 static const struct kdc_patypes pat[] = {
1039 #ifdef PKINIT
1040     {
1041         KRB5_PADATA_PK_AS_REQ, "PK-INIT(ietf)",
1042         PA_ANNOUNCE | PA_SYNTHETIC_OK | PA_REPLACE_REPLY_KEY,
1043         pa_pkinit_validate, NULL, NULL
1044     },
1045     {
1046         KRB5_PADATA_PK_AS_REQ_WIN, "PK-INIT(win2k)", PA_ANNOUNCE | PA_REPLACE_REPLY_KEY,
1047         pa_pkinit_validate, NULL, NULL
1048     },
1049     {
1050         KRB5_PADATA_PKINIT_KX, "Anonymous PK-INIT", PA_ANNOUNCE,
1051         NULL, NULL, NULL
1052     },
1053 #else
1054     { KRB5_PADATA_PK_AS_REQ, "PK-INIT(ietf)", 0, NULL , NULL, NULL },
1055     { KRB5_PADATA_PK_AS_REQ_WIN, "PK-INIT(win2k)", 0, NULL, NULL, NULL },
1056     { KRB5_PADATA_PKINIT_KX, "Anonymous PK-INIT", 0, NULL, NULL, NULL },
1057 #endif
1058     { KRB5_PADATA_PA_PK_OCSP_RESPONSE , "OCSP", 0, NULL, NULL, NULL },
1059     {
1060         KRB5_PADATA_ENC_TIMESTAMP , "ENC-TS",
1061         PA_ANNOUNCE | PA_USES_LONG_TERM_KEY,
1062         pa_enc_ts_validate, NULL, NULL
1063     },
1064     {
1065         KRB5_PADATA_ENCRYPTED_CHALLENGE , "ENC-CHAL",
1066         PA_ANNOUNCE | PA_USES_LONG_TERM_KEY | PA_REQ_FAST,
1067         pa_enc_chal_validate, NULL, NULL
1068     },
1069     { KRB5_PADATA_REQ_ENC_PA_REP , "REQ-ENC-PA-REP", 0, NULL, NULL, NULL },
1070     { KRB5_PADATA_FX_FAST, "FX-FAST", PA_ANNOUNCE, NULL, NULL, NULL },
1071     { KRB5_PADATA_FX_ERROR, "FX-ERROR", 0, NULL, NULL, NULL },
1072     { KRB5_PADATA_FX_COOKIE, "FX-COOKIE", 0, NULL, NULL, NULL },
1073     {
1074         KRB5_PADATA_GSS , "GSS",
1075         PA_ANNOUNCE | PA_SYNTHETIC_OK | PA_REPLACE_REPLY_KEY,
1076         pa_gss_validate, pa_gss_finalize_pac, NULL
1077     },
1078 };
1079
1080 static void
1081 log_patypes(astgs_request_t r, METHOD_DATA *padata)
1082 {
1083     krb5_kdc_configuration *config = r->config;
1084     struct rk_strpool *p = NULL;
1085     char *str;
1086     size_t n, m;
1087
1088     for (n = 0; n < padata->len; n++) {
1089         for (m = 0; m < sizeof(pat) / sizeof(pat[0]); m++) {
1090             if (padata->val[n].padata_type == pat[m].type) {
1091                 p = rk_strpoolprintf(p, "%s", pat[m].name);
1092                 break;
1093             }
1094         }
1095         if (m == sizeof(pat) / sizeof(pat[0]))
1096             p = rk_strpoolprintf(p, "%d", padata->val[n].padata_type);
1097         if (p && n + 1 < padata->len)
1098             p = rk_strpoolprintf(p, ", ");
1099         if (p == NULL) {
1100             kdc_log(r->context, config, 1, "out of memory");
1101             return;
1102         }
1103     }
1104     if (p == NULL)
1105         p = rk_strpoolprintf(p, "none");
1106
1107     str = rk_strpoolcollect(p);
1108     kdc_log(r->context, config, 4, "Client sent patypes: %s", str);
1109     kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_EATWHITE,
1110                     "client-pa", "%s", str);
1111     free(str);
1112 }
1113
1114 static krb5_boolean
1115 pa_used_flag_isset(astgs_request_t r, unsigned int flag)
1116 {
1117     if (r->pa_used == NULL)
1118         return FALSE;
1119
1120     return (r->pa_used->flags & flag) == flag;
1121 }
1122
1123 /*
1124  *
1125  */
1126
1127 krb5_error_code
1128 _kdc_encode_reply(krb5_context context,
1129                   krb5_kdc_configuration *config,
1130                   astgs_request_t r, uint32_t nonce,
1131                   krb5_enctype etype,
1132                   int skvno, const EncryptionKey *skey,
1133                   int ckvno,
1134                   int rk_is_subkey,
1135                   krb5_data *reply)
1136 {
1137     unsigned char *buf;
1138     size_t buf_size;
1139     size_t len = 0;
1140     krb5_error_code ret;
1141     krb5_crypto crypto;
1142     KDC_REP *rep = &r->rep;
1143     EncTicketPart *et = &r->et;
1144     EncKDCRepPart *ek = &r->ek;
1145
1146     heim_assert(rep->padata != NULL, "reply padata uninitialized");
1147
1148     ASN1_MALLOC_ENCODE(EncTicketPart, buf, buf_size, et, &len, ret);
1149     if(ret) {
1150         const char *msg = krb5_get_error_message(context, ret);
1151         kdc_log(context, config, 4, "Failed to encode ticket: %s", msg);
1152         krb5_free_error_message(context, msg);
1153         return ret;
1154     }
1155     if(buf_size != len)
1156         krb5_abortx(context, "Internal error in ASN.1 encoder");
1157
1158     ret = krb5_crypto_init(context, skey, etype, &crypto);
1159     if (ret) {
1160         const char *msg = krb5_get_error_message(context, ret);
1161         kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
1162         krb5_free_error_message(context, msg);
1163         free(buf);
1164         return ret;
1165     }
1166
1167     ret = krb5_encrypt_EncryptedData(context,
1168                                      crypto,
1169                                      KRB5_KU_TICKET,
1170                                      buf,
1171                                      len,
1172                                      skvno,
1173                                      &rep->ticket.enc_part);
1174     free(buf);
1175     krb5_crypto_destroy(context, crypto);
1176     if(ret) {
1177         const char *msg = krb5_get_error_message(context, ret);
1178         kdc_log(context, config, 4, "Failed to encrypt data: %s", msg);
1179         krb5_free_error_message(context, msg);
1180         return ret;
1181     }
1182
1183     if (r && r->armor_crypto) {
1184         KrbFastFinished finished;
1185         krb5_data data;
1186
1187         kdc_log(context, config, 4, "FAST armor protection");
1188
1189         memset(&finished, 0, sizeof(finished));
1190         krb5_data_zero(&data);
1191
1192         finished.timestamp = kdc_time;
1193         finished.usec = 0;
1194         finished.crealm = et->crealm;
1195         finished.cname = et->cname;
1196
1197         ASN1_MALLOC_ENCODE(Ticket, data.data, data.length,
1198                            &rep->ticket, &len, ret);
1199         if (ret)
1200             return ret;
1201         if (data.length != len)
1202             krb5_abortx(context, "internal asn.1 error");
1203
1204         ret = krb5_create_checksum(context, r->armor_crypto,
1205                                    KRB5_KU_FAST_FINISHED, 0,
1206                                    data.data, data.length,
1207                                    &finished.ticket_checksum);
1208         krb5_data_free(&data);
1209         if (ret)
1210             return ret;
1211
1212         ret = _kdc_fast_mk_response(context, r->armor_crypto,
1213                                     rep->padata, &r->strengthen_key, &finished,
1214                                     nonce, &data);
1215         free_Checksum(&finished.ticket_checksum);
1216         if (ret)
1217             return ret;
1218
1219         free_METHOD_DATA(r->rep.padata);
1220
1221         ret = krb5_padata_add(context, rep->padata,
1222                               KRB5_PADATA_FX_FAST,
1223                               data.data, data.length);
1224         if (ret)
1225             return ret;
1226
1227         /*
1228          * Hide client name for privacy reasons
1229          */
1230         if (r->fast.flags.requested_hidden_names) {
1231             Realm anon_realm = KRB5_ANON_REALM;
1232
1233             free_Realm(&rep->crealm);
1234             ret = copy_Realm(&anon_realm, &rep->crealm);
1235             if (ret == 0) {
1236                 free_PrincipalName(&rep->cname);
1237                 ret = _kdc_make_anonymous_principalname(&rep->cname);
1238             }
1239             if (ret)
1240                 return ret;
1241         }
1242     }
1243
1244     if (rep->padata->len == 0) {
1245         free_METHOD_DATA(rep->padata);
1246         free(rep->padata);
1247         rep->padata = NULL;
1248     }
1249
1250     if(rep->msg_type == krb_as_rep && !config->encode_as_rep_as_tgs_rep)
1251         ASN1_MALLOC_ENCODE(EncASRepPart, buf, buf_size, ek, &len, ret);
1252     else
1253         ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
1254     if(ret) {
1255         const char *msg = krb5_get_error_message(context, ret);
1256         kdc_log(context, config, 4, "Failed to encode KDC-REP: %s", msg);
1257         krb5_free_error_message(context, msg);
1258         return ret;
1259     }
1260     if(buf_size != len) {
1261         free(buf);
1262         kdc_log(context, config, 4, "Internal error in ASN.1 encoder");
1263         _kdc_set_e_text(r, "KDC internal error");
1264         return KRB5KRB_ERR_GENERIC;
1265     }
1266     ret = krb5_crypto_init(context, &r->reply_key, 0, &crypto);
1267     if (ret) {
1268         const char *msg = krb5_get_error_message(context, ret);
1269         free(buf);
1270         kdc_log(context, config, 4, "krb5_crypto_init failed: %s", msg);
1271         krb5_free_error_message(context, msg);
1272         return ret;
1273     }
1274     if(rep->msg_type == krb_as_rep) {
1275         ret = krb5_encrypt_EncryptedData(context,
1276                                          crypto,
1277                                          KRB5_KU_AS_REP_ENC_PART,
1278                                          buf,
1279                                          len,
1280                                          ckvno,
1281                                          &rep->enc_part);
1282         free(buf);
1283         if (ret == 0)
1284             ASN1_MALLOC_ENCODE(AS_REP, buf, buf_size, rep, &len, ret);
1285     } else {
1286         ret = krb5_encrypt_EncryptedData(context,
1287                                          crypto,
1288                                          rk_is_subkey ?
1289                                              KRB5_KU_TGS_REP_ENC_PART_SUB_KEY :
1290                                              KRB5_KU_TGS_REP_ENC_PART_SESSION,
1291                                          buf,
1292                                          len,
1293                                          ckvno,
1294                                          &rep->enc_part);
1295         free(buf);
1296         if (ret == 0)
1297             ASN1_MALLOC_ENCODE(TGS_REP, buf, buf_size, rep, &len, ret);
1298     }
1299     krb5_crypto_destroy(context, crypto);
1300     if(ret) {
1301         const char *msg = krb5_get_error_message(context, ret);
1302         kdc_log(context, config, 4, "Failed to encode KDC-REP: %s", msg);
1303         krb5_free_error_message(context, msg);
1304         return ret;
1305     }
1306     if(buf_size != len) {
1307         free(buf);
1308         kdc_log(context, config, 4, "Internal error in ASN.1 encoder");
1309         _kdc_set_e_text(r, "KDC internal error");
1310         return KRB5KRB_ERR_GENERIC;
1311     }
1312     reply->data = buf;
1313     reply->length = buf_size;
1314     return 0;
1315 }
1316
1317 /*
1318  *
1319  */
1320
1321 static krb5_error_code
1322 get_pa_etype_info(krb5_context context,
1323                   krb5_kdc_configuration *config,
1324                   METHOD_DATA *md, Key *ckey,
1325                   krb5_boolean include_salt)
1326 {
1327     krb5_error_code ret = 0;
1328     ETYPE_INFO_ENTRY eie; /* do not free this one */
1329     ETYPE_INFO ei;
1330     PA_DATA pa;
1331     size_t len;
1332
1333     /*
1334      * Code moved here from what used to be make_etype_info_entry() because
1335      * using the ASN.1 compiler-generated SEQUENCE OF add functions makes that
1336      * old function's body and this one's small and clean.
1337      *
1338      * The following comment blocks were there:
1339      *
1340      *  According to `the specs', we can't send a salt if we have AFS3 salted
1341      *  key, but that requires that you *know* what cell you are using (e.g by
1342      *  assuming that the cell is the same as the realm in lower case)
1343      *
1344      *  We shouldn't sent salttype since it is incompatible with the
1345      *  specification and it breaks windows clients.  The afs salting problem
1346      *  is solved by using KRB5-PADATA-AFS3-SALT implemented in Heimdal 0.7 and
1347      *  later.
1348      *
1349      *  We return no salt type at all, as that should indicate the default salt
1350      *  type and make everybody happy.  some systems (like w2k) dislike being
1351      *  told the salt type here.
1352      */
1353
1354     pa.padata_type = KRB5_PADATA_ETYPE_INFO;
1355     pa.padata_value.data = NULL;
1356     pa.padata_value.length = 0;
1357     ei.len = 0;
1358     ei.val = NULL;
1359     eie.etype = ckey->key.keytype;
1360     eie.salttype = NULL;
1361     eie.salt = NULL;
1362     if (include_salt && ckey->salt)
1363         eie.salt = &ckey->salt->salt;
1364     ret = add_ETYPE_INFO(&ei, &eie);
1365     if (ret == 0)
1366         ASN1_MALLOC_ENCODE(ETYPE_INFO, pa.padata_value.data, pa.padata_value.length,
1367                            &ei, &len, ret);
1368     if (ret == 0)
1369         add_METHOD_DATA(md, &pa);
1370     free_ETYPE_INFO(&ei);
1371     free_PA_DATA(&pa);
1372     return ret;
1373 }
1374
1375 /*
1376  *
1377  */
1378
1379 extern int _krb5_AES_SHA1_string_to_default_iterator;
1380 extern int _krb5_AES_SHA2_string_to_default_iterator;
1381
1382 static krb5_error_code
1383 make_s2kparams(int value, size_t len, krb5_data **ps2kparams)
1384 {
1385     krb5_data *s2kparams;
1386     krb5_error_code ret;
1387
1388     ALLOC(s2kparams);
1389     if (s2kparams == NULL)
1390         return ENOMEM;
1391     ret = krb5_data_alloc(s2kparams, len);
1392     if (ret) {
1393         free(s2kparams);
1394         return ret;
1395     }
1396     _krb5_put_int(s2kparams->data, value, len);
1397     *ps2kparams = s2kparams;
1398     return 0;
1399 }
1400
1401 static krb5_error_code
1402 make_etype_info2_entry(ETYPE_INFO2_ENTRY *ent,
1403                        Key *key,
1404                        krb5_boolean include_salt)
1405 {
1406     krb5_error_code ret;
1407
1408     ent->etype = key->key.keytype;
1409     if (key->salt && include_salt) {
1410         ALLOC(ent->salt);
1411         if (ent->salt == NULL)
1412             return ENOMEM;
1413         *ent->salt = malloc(key->salt->salt.length + 1);
1414         if (*ent->salt == NULL) {
1415             free(ent->salt);
1416             ent->salt = NULL;
1417             return ENOMEM;
1418         }
1419         memcpy(*ent->salt, key->salt->salt.data, key->salt->salt.length);
1420         (*ent->salt)[key->salt->salt.length] = '\0';
1421     } else
1422         ent->salt = NULL;
1423
1424     ent->s2kparams = NULL;
1425
1426     switch (key->key.keytype) {
1427     case ETYPE_AES128_CTS_HMAC_SHA1_96:
1428     case ETYPE_AES256_CTS_HMAC_SHA1_96:
1429         ret = make_s2kparams(_krb5_AES_SHA1_string_to_default_iterator,
1430                              4, &ent->s2kparams);
1431         break;
1432     case KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128:
1433     case KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192:
1434         ret = make_s2kparams(_krb5_AES_SHA2_string_to_default_iterator,
1435                              4, &ent->s2kparams);
1436         break;
1437     case ETYPE_DES_CBC_CRC:
1438     case ETYPE_DES_CBC_MD4:
1439     case ETYPE_DES_CBC_MD5:
1440         /* Check if this was a AFS3 salted key */
1441         if(key->salt && key->salt->type == hdb_afs3_salt)
1442             ret = make_s2kparams(1, 1, &ent->s2kparams);
1443         else
1444             ret = 0;
1445         break;
1446     default:
1447         ret = 0;
1448         break;
1449     }
1450     return ret;
1451 }
1452
1453 /*
1454  * Return an ETYPE-INFO2. Enctypes are storted the same way as in the
1455  * database (client supported enctypes first, then the unsupported
1456  * enctypes).
1457  */
1458
1459 static krb5_error_code
1460 get_pa_etype_info2(krb5_context context,
1461                    krb5_kdc_configuration *config,
1462                    METHOD_DATA *md, Key *ckey,
1463                    krb5_boolean include_salt)
1464 {
1465     krb5_error_code ret = 0;
1466     ETYPE_INFO2 pa;
1467     unsigned char *buf;
1468     size_t len;
1469
1470     pa.len = 1;
1471     pa.val = calloc(1, sizeof(pa.val[0]));
1472     if(pa.val == NULL)
1473         return ENOMEM;
1474
1475     ret = make_etype_info2_entry(&pa.val[0], ckey, include_salt);
1476     if (ret) {
1477         free_ETYPE_INFO2(&pa);
1478         return ret;
1479     }
1480
1481     ASN1_MALLOC_ENCODE(ETYPE_INFO2, buf, len, &pa, &len, ret);
1482     free_ETYPE_INFO2(&pa);
1483     if(ret)
1484         return ret;
1485     ret = realloc_method_data(md);
1486     if(ret) {
1487         free(buf);
1488         return ret;
1489     }
1490     md->val[md->len - 1].padata_type = KRB5_PADATA_ETYPE_INFO2;
1491     md->val[md->len - 1].padata_value.length = len;
1492     md->val[md->len - 1].padata_value.data = buf;
1493     return 0;
1494 }
1495
1496 /*
1497  * Return 0 if the client have only older enctypes, this is for
1498  * determining if the server should send ETYPE_INFO2 or not.
1499  */
1500
1501 static int
1502 newer_enctype_present(krb5_context context,
1503                       struct KDC_REQ_BODY_etype *etype_list)
1504 {
1505     size_t i;
1506
1507     for (i = 0; i < etype_list->len; i++) {
1508         if (!krb5_is_enctype_old(context, etype_list->val[i]))
1509             return 1;
1510     }
1511     return 0;
1512 }
1513
1514 static krb5_error_code
1515 get_pa_etype_info_both(krb5_context context,
1516                        krb5_kdc_configuration *config,
1517                        struct KDC_REQ_BODY_etype *etype_list,
1518                        METHOD_DATA *md, Key *ckey,
1519                        krb5_boolean include_salt)
1520 {
1521     krb5_error_code ret;
1522
1523     /*
1524      * Windows 2019 (and earlier versions) always sends the salt
1525      * and Samba has testsuites that check this behaviour, so a
1526      * Samba AD DC will set this flag to match the AS-REP packet
1527      * more closely.
1528      */
1529     if (config->force_include_pa_etype_salt)
1530         include_salt = TRUE;
1531
1532     /*
1533      * RFC4120 requires:
1534      *   When the AS server is to include pre-authentication data in a
1535      *   KRB-ERROR or in an AS-REP, it MUST use PA-ETYPE-INFO2, not
1536      *   PA-ETYPE-INFO, if the etype field of the client's AS-REQ lists
1537      *   at least one "newer" encryption type.  Otherwise (when the etype
1538      *   field of the client's AS-REQ does not list any "newer" encryption
1539      *   types), it MUST send both PA-ETYPE-INFO2 and PA-ETYPE-INFO (both
1540      *   with an entry for each enctype).  A "newer" enctype is any enctype
1541      *   first officially specified concurrently with or subsequent to the
1542      *   issue of this RFC.  The enctypes DES, 3DES, or RC4 and any defined
1543      *   in [RFC1510] are not "newer" enctypes.
1544      *
1545      * It goes on to state:
1546      *   The preferred ordering of the "hint" pre-authentication data that
1547      *   affect client key selection is: ETYPE-INFO2, followed by ETYPE-INFO,
1548      *   followed by PW-SALT.  As noted in Section 3.1.3, a KDC MUST NOT send
1549      *   ETYPE-INFO or PW-SALT when the client's AS-REQ includes at least one
1550      *   "newer" etype.
1551      */
1552
1553     ret = get_pa_etype_info2(context, config, md, ckey, include_salt);
1554     if (ret)
1555         return ret;
1556
1557     if (!newer_enctype_present(context, etype_list))
1558         ret = get_pa_etype_info(context, config, md, ckey, include_salt);
1559
1560     return ret;
1561 }
1562
1563 /*
1564  *
1565  */
1566
1567 void
1568 _log_astgs_req(astgs_request_t r, krb5_enctype setype)
1569 {
1570     const KDC_REQ_BODY *b = &r->req.req_body;
1571     krb5_enctype cetype = r->reply_key.keytype;
1572     krb5_error_code ret;
1573     struct rk_strpool *p;
1574     struct rk_strpool *s = NULL;
1575     char *str;
1576     char *cet;
1577     char *set;
1578     size_t i;
1579
1580     /*
1581      * we are collecting ``p'' and ``s''.  The former is a textual
1582      * representation of the enctypes as strings which will be used
1583      * for debugging.  The latter is a terse comma separated list of
1584      * the %d's of the enctypes to emit into our audit trail to
1585      * conserve space in the logs.
1586      */
1587
1588     p = rk_strpoolprintf(NULL, "%s", "Client supported enctypes: ");
1589
1590     for (i = 0; i < b->etype.len; i++) {
1591         ret = krb5_enctype_to_string(r->context, b->etype.val[i], &str);
1592         if (ret == 0) {
1593             p = rk_strpoolprintf(p, "%s", str);
1594             free(str);
1595         } else
1596             p = rk_strpoolprintf(p, "%d", b->etype.val[i]);
1597         if (p == NULL) {
1598             rk_strpoolfree(s);
1599             _kdc_r_log(r, 4, "out of memory");
1600             return;
1601         }
1602         s = rk_strpoolprintf(s, "%d", b->etype.val[i]);
1603         if (i + 1 < b->etype.len) {
1604             p = rk_strpoolprintf(p, ", ");
1605             s = rk_strpoolprintf(s, ",");
1606         }
1607     }
1608     if (p == NULL)
1609         p = rk_strpoolprintf(p, "no encryption types");
1610
1611     str = rk_strpoolcollect(s);
1612     if (str)
1613         kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_EATWHITE, "etypes", "%s",
1614                         str);
1615     free(str);
1616
1617     ret = krb5_enctype_to_string(r->context, cetype, &cet);
1618     if(ret == 0) {
1619         ret = krb5_enctype_to_string(r->context, setype, &set);
1620         if (ret == 0) {
1621             p = rk_strpoolprintf(p, ", using %s/%s", cet, set);
1622             free(set);
1623         }
1624         free(cet);
1625     }
1626     if (ret != 0)
1627         p = rk_strpoolprintf(p, ", using enctypes %d/%d",
1628                              cetype, setype);
1629
1630     str = rk_strpoolcollect(p);
1631     if (str)
1632         _kdc_r_log(r, 4, "%s", str);
1633     free(str);
1634
1635     kdc_audit_addkv((kdc_request_t)r, 0, "etype", "%d/%d", cetype, setype);
1636
1637     {
1638         char fixedstr[128];
1639         int result;
1640
1641         result = unparse_flags(KDCOptions2int(b->kdc_options), asn1_KDCOptions_units(),
1642                                fixedstr, sizeof(fixedstr));
1643         if (result > 0) {
1644             _kdc_r_log(r, 4, "Requested flags: %s", fixedstr);
1645             kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_EATWHITE,
1646                             "flags", "%s", fixedstr);
1647         }
1648     }
1649 }
1650
1651 /*
1652  * verify the flags on `client' and `server', returning 0
1653  * if they are OK and generating an error messages and returning
1654  * and error code otherwise.
1655  */
1656
1657 KDC_LIB_FUNCTION krb5_error_code KDC_LIB_CALL
1658 kdc_check_flags(astgs_request_t r,
1659                 krb5_boolean is_as_req,
1660                 hdb_entry *client,
1661                 hdb_entry *server)
1662 {
1663     if (client != NULL) {
1664         /* check client */
1665         if (client->flags.locked_out) {
1666             kdc_audit_addreason((kdc_request_t)r, "Client is locked out");
1667             return KRB5KDC_ERR_CLIENT_REVOKED;
1668         }
1669
1670         if (client->flags.invalid) {
1671             kdc_audit_addreason((kdc_request_t)r,
1672                                 "Client has invalid bit set");
1673             return KRB5KDC_ERR_POLICY;
1674         }
1675
1676         if (!client->flags.client) {
1677             kdc_audit_addreason((kdc_request_t)r,
1678                                 "Principal may not act as client");
1679             return KRB5KDC_ERR_POLICY;
1680         }
1681
1682         if (client->valid_start && *client->valid_start > kdc_time) {
1683             char starttime_str[100];
1684             krb5_format_time(r->context, *client->valid_start,
1685                              starttime_str, sizeof(starttime_str), TRUE);
1686             kdc_audit_addreason((kdc_request_t)r, "Client not yet valid "
1687                                 "until %s", starttime_str);
1688             return KRB5KDC_ERR_CLIENT_NOTYET;
1689         }
1690
1691         if (client->valid_end && *client->valid_end < kdc_time) {
1692             char endtime_str[100];
1693             krb5_format_time(r->context, *client->valid_end,
1694                              endtime_str, sizeof(endtime_str), TRUE);
1695             kdc_audit_addreason((kdc_request_t)r, "Client expired at %s",
1696                                 endtime_str);
1697             return  KRB5KDC_ERR_NAME_EXP;
1698         }
1699
1700         if (client->flags.require_pwchange &&
1701             (server == NULL || !server->flags.change_pw))
1702             return KRB5KDC_ERR_KEY_EXPIRED;
1703
1704         if (client->pw_end && *client->pw_end < kdc_time
1705             && (server == NULL || !server->flags.change_pw)) {
1706             char pwend_str[100];
1707             krb5_format_time(r->context, *client->pw_end,
1708                              pwend_str, sizeof(pwend_str), TRUE);
1709             kdc_audit_addreason((kdc_request_t)r, "Client's key has expired "
1710                                 "at %s", pwend_str);
1711             return KRB5KDC_ERR_KEY_EXPIRED;
1712         }
1713     }
1714
1715     /* check server */
1716
1717     if (server != NULL) {
1718         if (server->flags.locked_out) {
1719             kdc_audit_addreason((kdc_request_t)r, "Server locked out");
1720             return KRB5KDC_ERR_SERVICE_REVOKED;
1721         }
1722         if (server->flags.invalid) {
1723             kdc_audit_addreason((kdc_request_t)r,
1724                                 "Server has invalid flag set");
1725             return KRB5KDC_ERR_POLICY;
1726         }
1727         if (!server->flags.server) {
1728             kdc_audit_addreason((kdc_request_t)r,
1729                                 "Principal may not act as server");
1730             return KRB5KDC_ERR_POLICY;
1731         }
1732
1733         if (!is_as_req && server->flags.initial) {
1734             kdc_audit_addreason((kdc_request_t)r,
1735                                 "AS-REQ is required for server");
1736             return KRB5KDC_ERR_POLICY;
1737         }
1738
1739         if (server->valid_start && *server->valid_start > kdc_time) {
1740             char starttime_str[100];
1741             krb5_format_time(r->context, *server->valid_start,
1742                              starttime_str, sizeof(starttime_str), TRUE);
1743             kdc_audit_addreason((kdc_request_t)r, "Server not yet valid "
1744                                 "until %s", starttime_str);
1745             return KRB5KDC_ERR_SERVICE_NOTYET;
1746         }
1747
1748         if (server->valid_end && *server->valid_end < kdc_time) {
1749             char endtime_str[100];
1750             krb5_format_time(r->context, *server->valid_end,
1751                              endtime_str, sizeof(endtime_str), TRUE);
1752             kdc_audit_addreason((kdc_request_t)r, "Server expired at %s",
1753                                 endtime_str);
1754             return KRB5KDC_ERR_SERVICE_EXP;
1755         }
1756
1757         if (server->pw_end && *server->pw_end < kdc_time) {
1758             char pwend_str[100];
1759             krb5_format_time(r->context, *server->pw_end,
1760                              pwend_str, sizeof(pwend_str), TRUE);
1761             kdc_audit_addreason((kdc_request_t)r, "Server's key has expired "
1762                                 "at %s", pwend_str);
1763             return KRB5KDC_ERR_KEY_EXPIRED;
1764         }
1765     }
1766     return 0;
1767 }
1768
1769 /*
1770  * Return TRUE if `from' is part of `addresses' taking into consideration
1771  * the configuration variables that tells us how strict we should be about
1772  * these checks
1773  */
1774
1775 krb5_boolean
1776 _kdc_check_addresses(astgs_request_t r, HostAddresses *addresses,
1777                      const struct sockaddr *from)
1778 {
1779     krb5_kdc_configuration *config = r->config;
1780     krb5_error_code ret;
1781     krb5_address addr;
1782     krb5_boolean result;
1783     krb5_boolean only_netbios = TRUE;
1784     size_t i;
1785
1786     if (!config->check_ticket_addresses && !config->warn_ticket_addresses)
1787         return TRUE;
1788
1789     /*
1790      * Fields of HostAddresses type are always OPTIONAL and should be non-
1791      * empty, but we check for empty just in case as our compiler doesn't
1792      * support size constraints on SEQUENCE OF.
1793      */
1794     if (addresses == NULL || addresses->len == 0)
1795         return config->allow_null_ticket_addresses;
1796
1797     for (i = 0; i < addresses->len; ++i) {
1798         if (addresses->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
1799             only_netbios = FALSE;
1800         }
1801     }
1802
1803     /* Windows sends it's netbios name, which I can only assume is
1804      * used for the 'allowed workstations' check.  This is painful,
1805      * but we still want to check IP addresses if they happen to be
1806      * present.
1807      */
1808
1809     if(only_netbios)
1810         return config->allow_null_ticket_addresses;
1811
1812     ret = krb5_sockaddr2address (r->context, from, &addr);
1813     if(ret)
1814         return FALSE;
1815
1816     result = krb5_address_search(r->context, &addr, addresses);
1817     krb5_free_address (r->context, &addr);
1818     return result;
1819 }
1820
1821 /*
1822  *
1823  */
1824 krb5_error_code
1825 _kdc_check_anon_policy(astgs_request_t r)
1826 {
1827     if (!r->config->allow_anonymous) {
1828         kdc_audit_addreason((kdc_request_t)r,
1829                             "Anonymous tickets denied by local policy");
1830         return KRB5KDC_ERR_POLICY;
1831     }
1832
1833     return 0;
1834 }
1835
1836 /*
1837  * Determine whether the client requested a PAC be included
1838  * or excluded explictly, or whether it doesn't care.
1839  */
1840
1841 static uint64_t
1842 get_pac_attributes(krb5_context context, KDC_REQ *req)
1843 {
1844     krb5_error_code ret;
1845     PA_PAC_REQUEST pacreq;
1846     const PA_DATA *pa;
1847     int i = 0;
1848     uint32_t pac_attributes;
1849
1850     pa = _kdc_find_padata(req, &i, KRB5_PADATA_PA_PAC_REQUEST);
1851     if (pa == NULL)
1852         return KRB5_PAC_WAS_GIVEN_IMPLICITLY;
1853
1854     ret = decode_PA_PAC_REQUEST(pa->padata_value.data,
1855                                 pa->padata_value.length,
1856                                 &pacreq,
1857                                 NULL);
1858     if (ret)
1859         return KRB5_PAC_WAS_GIVEN_IMPLICITLY;
1860
1861     pac_attributes = pacreq.include_pac ? KRB5_PAC_WAS_REQUESTED : 0;
1862     free_PA_PAC_REQUEST(&pacreq);
1863     return pac_attributes;
1864 }
1865
1866 /*
1867  *
1868  */
1869
1870 static krb5_error_code
1871 generate_pac(astgs_request_t r, const Key *skey, const Key *tkey,
1872              krb5_boolean is_tgs)
1873 {
1874     krb5_error_code ret;
1875     krb5_data data;
1876     uint16_t rodc_id;
1877     krb5_principal client;
1878     krb5_const_principal canon_princ = NULL;
1879
1880     r->pac_attributes = get_pac_attributes(r->context, &r->req);
1881     kdc_audit_setkv_number((kdc_request_t)r, "pac_attributes",
1882                            r->pac_attributes);
1883
1884     if (!is_tgs && !(r->pac_attributes & (KRB5_PAC_WAS_REQUESTED | KRB5_PAC_WAS_GIVEN_IMPLICITLY)))
1885         return 0;
1886
1887     /*
1888      * When a PA mech does not use the client's long-term key, the PAC
1889      * may include the client's long-term key (encrypted in the reply key)
1890      * for use by other shared secret authentication protocols, e.g. NTLM.
1891      * Validate a PA mech was actually used before doing this.
1892      */
1893
1894     ret = _kdc_pac_generate(r,
1895                             r->client,
1896                             r->server,
1897                             r->pa_used && !pa_used_flag_isset(r, PA_USES_LONG_TERM_KEY)
1898                                 ? &r->reply_key : NULL,
1899                             r->pac_attributes,
1900                             &r->pac);
1901     if (ret) {
1902         _kdc_r_log(r, 4, "PAC generation failed for -- %s",
1903                    r->cname);
1904         return ret;
1905     }
1906     if (r->pac == NULL)
1907         return 0;
1908
1909     rodc_id = r->server->kvno >> 16;
1910
1911     /* libkrb5 expects ticket and PAC client names to match */
1912     ret = _krb5_principalname2krb5_principal(r->context, &client,
1913                                              r->et.cname, r->et.crealm);
1914     if (ret)
1915         return ret;
1916
1917     /*
1918      * Include the canonical name of the principal in the authorization
1919      * data, if the realms match (if they don't, then the KDC could
1920      * impersonate any realm. Windows always canonicalizes the realm,
1921      * but Heimdal permits aliases between realms.)
1922      */
1923     if (krb5_realm_compare(r->context, client, r->canon_client_princ)) {
1924         char *cpn = NULL;
1925
1926         canon_princ = r->canon_client_princ;
1927
1928         (void) krb5_unparse_name(r->context, canon_princ, &cpn);
1929         kdc_audit_addkv((kdc_request_t)r, 0, "canon_client_name", "%s",
1930                         cpn ? cpn : "<unknown>");
1931         krb5_xfree(cpn);
1932     }
1933
1934     if (r->pa_used && r->pa_used->finalize_pac) {
1935         ret = r->pa_used->finalize_pac(r);
1936         if (ret)
1937             return ret;
1938     }
1939
1940     ret = _krb5_pac_sign(r->context,
1941                          r->pac,
1942                          r->et.authtime,
1943                          client,
1944                          &skey->key, /* Server key */
1945                          &tkey->key, /* TGS key */
1946                          rodc_id,
1947                          NULL, /* UPN */
1948                          canon_princ,
1949                          false, /* add_full_sig */
1950                          is_tgs ? &r->pac_attributes : NULL,
1951                          &data);
1952     krb5_free_principal(r->context, client);
1953     krb5_pac_free(r->context, r->pac);
1954     r->pac = NULL;
1955     if (ret) {
1956         _kdc_r_log(r, 4, "PAC signing failed for -- %s",
1957                    r->cname);
1958         return ret;
1959     }
1960
1961     ret = _kdc_tkt_insert_pac(r->context, &r->et, &data);
1962     krb5_data_free(&data);
1963
1964     return ret;
1965 }
1966
1967 /*
1968  *
1969  */
1970
1971 krb5_boolean
1972 _kdc_is_anonymous(krb5_context context, krb5_const_principal principal)
1973 {
1974     return krb5_principal_is_anonymous(context, principal, KRB5_ANON_MATCH_ANY);
1975 }
1976
1977 /*
1978  * Returns TRUE if principal is the unauthenticated anonymous identity,
1979  * i.e. WELLKNOWN/ANONYMOUS@WELLKNOWN:ANONYMOUS. Unfortunately due to
1980  * backwards compatibility logic in krb5_principal_is_anonymous() we
1981  * have to use our own implementation.
1982  */
1983
1984 krb5_boolean
1985 _kdc_is_anonymous_pkinit(krb5_context context, krb5_const_principal principal)
1986 {
1987     return _kdc_is_anonymous(context, principal) &&
1988         strcmp(principal->realm, KRB5_ANON_REALM) == 0;
1989 }
1990
1991 static int
1992 require_preauth_p(astgs_request_t r)
1993 {
1994     return r->config->require_preauth
1995         || r->client->flags.require_preauth
1996         || r->server->flags.require_preauth;
1997 }
1998
1999
2000 /*
2001  *
2002  */
2003
2004 static krb5_error_code
2005 add_enc_pa_rep(astgs_request_t r)
2006 {
2007     krb5_error_code ret;
2008     krb5_crypto crypto;
2009     Checksum checksum;
2010     krb5_data cdata;
2011     size_t len;
2012
2013     ret = krb5_crypto_init(r->context, &r->reply_key, 0, &crypto);
2014     if (ret)
2015         return ret;
2016
2017     ret = krb5_create_checksum(r->context, crypto,
2018                                KRB5_KU_AS_REQ, 0,
2019                                r->request.data, r->request.length,
2020                                &checksum);
2021     krb5_crypto_destroy(r->context, crypto);
2022     if (ret)
2023         return ret;
2024
2025     ASN1_MALLOC_ENCODE(Checksum, cdata.data, cdata.length,
2026                        &checksum, &len, ret);
2027     free_Checksum(&checksum);
2028     if (ret)
2029         return ret;
2030     heim_assert(cdata.length == len, "ASN.1 internal error");
2031
2032     if (r->ek.encrypted_pa_data == NULL) {
2033         ALLOC(r->ek.encrypted_pa_data);
2034         if (r->ek.encrypted_pa_data == NULL)
2035             return ENOMEM;
2036     }
2037     ret = krb5_padata_add(r->context, r->ek.encrypted_pa_data,
2038                           KRB5_PADATA_REQ_ENC_PA_REP, cdata.data, cdata.length);
2039     if (ret)
2040         return ret;
2041
2042     return krb5_padata_add(r->context, r->ek.encrypted_pa_data,
2043                            KRB5_PADATA_FX_FAST, NULL, 0);
2044 }
2045
2046 /*
2047  * Add an authorization data element indicating that a synthetic
2048  * principal was used, so that the TGS does not accidentally
2049  * synthesize a non-synthetic principal that has since been deleted.
2050  */
2051 static krb5_error_code
2052 add_synthetic_princ_ad(astgs_request_t r)
2053 {
2054     krb5_data data;
2055
2056     krb5_data_zero(&data);
2057
2058     return _kdc_tkt_add_if_relevant_ad(r->context, &r->et,
2059                                        KRB5_AUTHDATA_SYNTHETIC_PRINC_USED,
2060                                        &data);
2061 }
2062
2063 static krb5_error_code
2064 get_local_tgs(krb5_context context,
2065               krb5_kdc_configuration *config,
2066               krb5_const_realm realm,
2067               HDB **krbtgtdb,
2068               hdb_entry **krbtgt)
2069 {
2070     krb5_error_code ret;
2071     krb5_principal tgs_name;
2072
2073     *krbtgtdb = NULL;
2074     *krbtgt = NULL;
2075
2076     ret = krb5_make_principal(context,
2077                               &tgs_name,
2078                               realm,
2079                               KRB5_TGS_NAME,
2080                               realm,
2081                               NULL);
2082     if (ret == 0)
2083         ret = _kdc_db_fetch(context, config, tgs_name,
2084                      HDB_F_GET_KRBTGT, NULL, krbtgtdb, krbtgt);
2085
2086     krb5_free_principal(context, tgs_name);
2087     return ret;
2088 }
2089
2090 /*
2091  *
2092  */
2093
2094 krb5_error_code
2095 _kdc_as_rep(astgs_request_t r)
2096 {
2097     krb5_kdc_configuration *config = r->config;
2098     KDC_REQ *req = &r->req;
2099     const char *from = r->from;
2100     KDC_REQ_BODY *b = NULL;
2101     KDC_REP *rep = &r->rep;
2102     KDCOptions f;
2103     krb5_enctype setype;
2104     krb5_error_code ret = 0;
2105     Key *skey;
2106     int found_pa = 0;
2107     int i, flags = HDB_F_FOR_AS_REQ;
2108     const PA_DATA *pa;
2109     krb5_boolean is_tgs;
2110     const char *msg;
2111     Key *krbtgt_key;
2112
2113     memset(rep, 0, sizeof(*rep));
2114
2115     ALLOC(rep->padata);
2116     if (rep->padata == NULL) {
2117         ret = ENOMEM;
2118         krb5_set_error_message(r->context, ret, N_("malloc: out of memory", ""));
2119         goto out;
2120     }
2121
2122     /*
2123      * Look for FAST armor and unwrap
2124      */
2125     ret = _kdc_fast_unwrap_request(r, NULL, NULL);
2126     if (ret) {
2127         _kdc_r_log(r, 1, "FAST unwrap request from %s failed: %d", from, ret);
2128         goto out;
2129     }
2130
2131     b = &req->req_body;
2132     f = b->kdc_options;
2133
2134     if (f.canonicalize)
2135         flags |= HDB_F_CANON;
2136
2137     if (b->sname == NULL) {
2138         ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
2139         _kdc_set_e_text(r, "No server in request");
2140         goto out;
2141     }
2142
2143     ret = _krb5_principalname2krb5_principal(r->context, &r->server_princ,
2144                                              *(b->sname), b->realm);
2145     if (!ret)
2146         ret = krb5_unparse_name(r->context, r->server_princ, &r->sname);
2147     if (ret) {
2148         kdc_log(r->context, config, 2,
2149                 "AS_REQ malformed server name from %s", from);
2150         goto out;
2151     }
2152
2153     if (b->cname == NULL) {
2154         ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2155         _kdc_set_e_text(r, "No client in request");
2156         goto out;
2157     }
2158
2159     ret = _krb5_principalname2krb5_principal(r->context, &r->client_princ,
2160                                              *(b->cname), b->realm);
2161     if (!ret)
2162         ret = krb5_unparse_name(r->context, r->client_princ, &r->cname);
2163     if (ret) {
2164         kdc_log(r->context, config, 2,
2165                 "AS-REQ malformed client name from %s", from);
2166         goto out;
2167     }
2168
2169     kdc_log(r->context, config, 4, "AS-REQ %s from %s for %s",
2170             r->cname, r->from, r->sname);
2171
2172     is_tgs = krb5_principal_is_krbtgt(r->context, r->server_princ);
2173
2174     if (_kdc_is_anonymous(r->context, r->client_princ) &&
2175         !_kdc_is_anon_request(req)) {
2176         kdc_log(r->context, config, 2, "Anonymous client w/o anonymous flag");
2177         ret = KRB5KDC_ERR_BADOPTION;
2178         goto out;
2179     }
2180
2181     ret = _kdc_db_fetch(r->context, config, r->client_princ,
2182                         HDB_F_GET_CLIENT | HDB_F_SYNTHETIC_OK | flags, NULL,
2183                         &r->clientdb, &r->client);
2184     switch (ret) {
2185     case 0:     /* Success */
2186         break;
2187     case HDB_ERR_NOT_FOUND_HERE:
2188         kdc_log(r->context, config, 5, "client %s does not have secrets at this KDC, need to proxy",
2189                 r->cname);
2190         goto out;
2191     case HDB_ERR_WRONG_REALM: {
2192         char *fixed_client_name = NULL;
2193
2194         ret = krb5_unparse_name(r->context, r->client->principal,
2195                                 &fixed_client_name);
2196         if (ret) {
2197             goto out;
2198         }
2199
2200         kdc_log(r->context, config, 4, "WRONG_REALM - %s -> %s",
2201                 r->cname, fixed_client_name);
2202         free(fixed_client_name);
2203
2204         r->e_text = NULL;
2205         ret = _kdc_fast_mk_error(r, r->rep.padata, r->armor_crypto,
2206                                  &req->req_body,
2207                                  r->error_code = KRB5_KDC_ERR_WRONG_REALM,
2208                                  r->client->principal, r->server_princ,
2209                                  NULL, NULL, r->reply);
2210         goto out;
2211     }
2212     default:
2213     {
2214         msg = krb5_get_error_message(r->context, ret);
2215         kdc_log(r->context, config, 4, "UNKNOWN -- %s: %s", r->cname, msg);
2216         krb5_free_error_message(r->context, msg);
2217         ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2218         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2219                                KDC_AUTH_EVENT_CLIENT_UNKNOWN);
2220         goto out;
2221     }
2222     }
2223     ret = _kdc_db_fetch(r->context, config, r->server_princ,
2224                         HDB_F_GET_SERVER | HDB_F_DELAY_NEW_KEYS |
2225                         flags | (is_tgs ? HDB_F_GET_KRBTGT : 0),
2226                         NULL, &r->serverdb, &r->server);
2227     switch (ret) {
2228     case 0:     /* Success */
2229         break;
2230     case HDB_ERR_NOT_FOUND_HERE:
2231         kdc_log(r->context, config, 5, "target %s does not have secrets at this KDC, need to proxy",
2232                 r->sname);
2233         goto out;
2234     default:
2235         msg = krb5_get_error_message(r->context, ret);
2236         kdc_log(r->context, config, 4, "UNKNOWN -- %s: %s", r->sname, msg);
2237         krb5_free_error_message(r->context, msg);
2238         ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
2239         goto out;
2240     }
2241
2242     /*
2243      * This has to be here (not later), because we need to have r->sessionetype
2244      * set prior to calling pa_pkinit_validate(), which in turn calls
2245      * _kdc_pk_mk_pa_reply(), during padata validation.
2246      */
2247
2248     /*
2249      * Select an enctype for the to-be-issued ticket's session key using the
2250      * intersection of the client's requested enctypes and the server's (like a
2251      * root krbtgt, but not necessarily) etypes from its HDB entry.
2252      */
2253     ret = _kdc_find_session_etype(r, b->etype.val, b->etype.len,
2254                                   r->server, &r->sessionetype);
2255     if (ret) {
2256         kdc_log(r->context, config, 4,
2257                 "Client (%s) from %s has no common enctypes with KDC "
2258                 "to use for the session key",
2259                 r->cname, from);
2260         goto out;
2261     }
2262
2263     /*
2264      * Pre-auth processing
2265      */
2266
2267     if(req->padata){
2268         unsigned int n;
2269
2270         log_patypes(r, req->padata);
2271
2272         /* Check if preauth matching */
2273
2274         for (n = 0; !found_pa && n < sizeof(pat) / sizeof(pat[0]); n++) {
2275             if (pat[n].validate == NULL)
2276                 continue;
2277             if (r->armor_crypto == NULL && (pat[n].flags & PA_REQ_FAST))
2278                 continue;
2279
2280             kdc_log(r->context, config, 5,
2281                     "Looking for %s pa-data -- %s", pat[n].name, r->cname);
2282             i = 0;
2283             pa = _kdc_find_padata(req, &i, pat[n].type);
2284             if (pa) {
2285                 if (r->client->flags.synthetic &&
2286                     !(pat[n].flags & PA_SYNTHETIC_OK)) {
2287                     kdc_log(r->context, config, 4, "UNKNOWN -- %s", r->cname);
2288                     ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2289                     goto out;
2290                 }
2291                 kdc_audit_addkv((kdc_request_t)r, KDC_AUDIT_VIS, "pa", "%s",
2292                                 pat[n].name);
2293                 ret = pat[n].validate(r, pa);
2294                 if (ret != 0) {
2295                     krb5_error_code  ret2;
2296                     Key *ckey = NULL;
2297                     krb5_boolean default_salt;
2298
2299                     if (ret != KRB5_KDC_ERR_MORE_PREAUTH_DATA_REQUIRED &&
2300                         !kdc_audit_getkv((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT))
2301                         kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2302                                                KDC_AUTH_EVENT_PREAUTH_FAILED);
2303
2304                     /*
2305                      * If there is a client key, send ETYPE_INFO{,2}
2306                      */
2307                     ret2 = _kdc_find_etype(r, KFE_IS_PREAUTH|KFE_USE_CLIENT,
2308                                            b->etype.val, b->etype.len,
2309                                            NULL, &ckey, &default_salt);
2310                     if (ret2 == 0) {
2311                         ret2 = get_pa_etype_info_both(r->context, config, &b->etype,
2312                                                       r->rep.padata, ckey, !default_salt);
2313                         if (ret2 != 0)
2314                             ret = ret2;
2315                     }
2316                     goto out;
2317                 }
2318                 if (!kdc_audit_getkv((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT))
2319                     kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2320                                            KDC_AUTH_EVENT_PREAUTH_SUCCEEDED);
2321                 kdc_log(r->context, config, 4,
2322                         "%s pre-authentication succeeded -- %s",
2323                         pat[n].name, r->cname);
2324                 found_pa = 1;
2325                 r->pa_used = &pat[n];
2326                 r->et.flags.pre_authent = 1;
2327             }
2328         }
2329     }
2330
2331     if (found_pa == 0) {
2332         Key *ckey = NULL;
2333         size_t n;
2334         krb5_boolean default_salt;
2335
2336         if (r->client->flags.synthetic) {
2337             kdc_log(r->context, config, 4, "UNKNOWN -- %s", r->cname);
2338             ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
2339             goto out;
2340         }
2341
2342         for (n = 0; n < sizeof(pat) / sizeof(pat[0]); n++) {
2343             if ((pat[n].flags & PA_ANNOUNCE) == 0)
2344                 continue;
2345
2346             if (!r->armor_crypto && (pat[n].flags & PA_REQ_FAST))
2347                 continue;
2348             if (pat[n].type == KRB5_PADATA_ENC_TIMESTAMP) {
2349                 if (r->armor_crypto && !r->config->enable_armored_pa_enc_timestamp)
2350                     continue;
2351                 if (!r->armor_crypto && !r->config->enable_unarmored_pa_enc_timestamp)
2352                     continue;
2353             }
2354
2355             ret = krb5_padata_add(r->context, r->rep.padata,
2356                                   pat[n].type, NULL, 0);
2357             if (ret)
2358                 goto out;
2359         }
2360
2361         /*
2362          * If there is a client key, send ETYPE_INFO{,2}
2363          */
2364         ret = _kdc_find_etype(r, KFE_IS_PREAUTH|KFE_USE_CLIENT,
2365                               b->etype.val, b->etype.len,
2366                               NULL, &ckey, &default_salt);
2367         if (ret == 0) {
2368             ret = get_pa_etype_info_both(r->context, config, &b->etype,
2369                                          r->rep.padata, ckey, !default_salt);
2370             if (ret)
2371                 goto out;
2372         }
2373
2374         /*
2375          * send requre preauth is its required or anon is requested,
2376          * anon is today only allowed via preauth mechanisms.
2377          */
2378         if (require_preauth_p(r) || _kdc_is_anon_request(&r->req)) {
2379             ret = KRB5KDC_ERR_PREAUTH_REQUIRED;
2380             _kdc_set_e_text(r, "Need to use PA-ENC-TIMESTAMP/PA-PK-AS-REQ");
2381             goto out;
2382         }
2383
2384         if (ckey == NULL) {
2385             ret = KRB5KDC_ERR_CLIENT_NOTYET;
2386             _kdc_set_e_text(r, "Doesn't have a client key available");
2387             goto out;
2388         }
2389         krb5_free_keyblock_contents(r->context,  &r->reply_key);
2390         ret = krb5_copy_keyblock_contents(r->context, &ckey->key, &r->reply_key);
2391         if (ret)
2392             goto out;
2393     }
2394
2395     r->canon_client_princ = r->client->principal;
2396
2397     /*
2398      * Verify flags after the user been required to prove its identity
2399      * with in a preauth mech.
2400      */
2401
2402     ret = _kdc_check_access(r);
2403     if(ret)
2404         goto out;
2405
2406     if (_kdc_is_anon_request(&r->req)) {
2407         ret = _kdc_check_anon_policy(r);
2408         if (ret) {
2409             _kdc_set_e_text(r, "Anonymous ticket requests are disabled");
2410             goto out;
2411         }
2412
2413         r->et.flags.anonymous = 1;
2414     }
2415
2416     kdc_audit_setkv_number((kdc_request_t)r, KDC_REQUEST_KV_AUTH_EVENT,
2417                            KDC_AUTH_EVENT_CLIENT_AUTHORIZED);
2418
2419     /*
2420      * Select the best encryption type for the KDC with out regard to
2421      * the client since the client never needs to read that data.
2422      */
2423
2424     ret = _kdc_get_preferred_key(r->context, config,
2425                                  r->server, r->sname,
2426                                  &setype, &skey);
2427     if(ret)
2428         goto out;
2429
2430     /* If server is not krbtgt, fetch local krbtgt key for signing authdata */
2431     if (is_tgs) {
2432         krbtgt_key = skey;
2433     } else {
2434         ret = get_local_tgs(r->context, config, r->server_princ->realm,
2435                             &r->krbtgtdb, &r->krbtgt);
2436         if (ret)
2437             goto out;
2438
2439         ret = _kdc_get_preferred_key(r->context, config, r->krbtgt,
2440                                       r->server_princ->realm,
2441                                       NULL, &krbtgt_key);
2442         if (ret)
2443             goto out;
2444     }
2445
2446     if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey) {
2447         ret = KRB5KDC_ERR_BADOPTION;
2448         _kdc_set_e_text(r, "Bad KDC options");
2449         goto out;
2450     }
2451
2452     /*
2453      * Build reply
2454      */
2455     rep->pvno = 5;
2456     rep->msg_type = krb_as_rep;
2457
2458     if (!config->historical_anon_realm &&
2459         _kdc_is_anonymous(r->context, r->client_princ)) {
2460         Realm anon_realm = KRB5_ANON_REALM;
2461         ret = copy_Realm(&anon_realm, &rep->crealm);
2462     } else if (f.canonicalize || r->client->flags.force_canonicalize)
2463         ret = copy_Realm(&r->canon_client_princ->realm, &rep->crealm);
2464     else
2465         ret = copy_Realm(&r->client_princ->realm, &rep->crealm);
2466     if (ret)
2467         goto out;
2468     if (r->et.flags.anonymous)
2469         ret = _kdc_make_anonymous_principalname(&rep->cname);
2470     else if (f.canonicalize || r->client->flags.force_canonicalize)
2471         ret = _krb5_principal2principalname(&rep->cname, r->canon_client_princ);
2472     else
2473         ret = _krb5_principal2principalname(&rep->cname, r->client_princ);
2474     if (ret)
2475         goto out;
2476
2477     rep->ticket.tkt_vno = 5;
2478     if (f.canonicalize || r->server->flags.force_canonicalize)
2479         ret = copy_Realm(&r->server->principal->realm, &rep->ticket.realm);
2480     else
2481         ret = copy_Realm(&r->server_princ->realm, &rep->ticket.realm);
2482     if (ret)
2483         goto out;
2484     if (f.canonicalize || r->server->flags.force_canonicalize)
2485         _krb5_principal2principalname(&rep->ticket.sname,
2486                                       r->server->principal);
2487     else
2488         _krb5_principal2principalname(&rep->ticket.sname,
2489                                       r->server_princ);
2490     /* java 1.6 expects the name to be the same type, lets allow that
2491      * uncomplicated name-types, when f.canonicalize is not set (to
2492      * match Windows Server 1709). */
2493 #define CNT(sp,t) (((sp)->sname->name_type) == KRB5_NT_##t)
2494     if (!f.canonicalize
2495         && (CNT(b, UNKNOWN) || CNT(b, PRINCIPAL) || CNT(b, SRV_INST) || CNT(b, SRV_HST) || CNT(b, SRV_XHST))) {
2496         rep->ticket.sname.name_type = b->sname->name_type;
2497     }
2498 #undef CNT
2499
2500     r->et.flags.initial = 1;
2501     if(r->client->flags.forwardable && r->server->flags.forwardable)
2502         r->et.flags.forwardable = f.forwardable;
2503     if(r->client->flags.proxiable && r->server->flags.proxiable)
2504         r->et.flags.proxiable = f.proxiable;
2505     else if (f.proxiable) {
2506         _kdc_set_e_text(r, "Ticket may not be proxiable");
2507         ret = KRB5KDC_ERR_POLICY;
2508         goto out;
2509     }
2510     if(r->client->flags.postdate && r->server->flags.postdate)
2511         r->et.flags.may_postdate = f.allow_postdate;
2512     else if (f.allow_postdate){
2513         _kdc_set_e_text(r, "Ticket may not be postdate");
2514         ret = KRB5KDC_ERR_POLICY;
2515         goto out;
2516     }
2517
2518     if (b->addresses)
2519         kdc_audit_addaddrs((kdc_request_t)r, b->addresses, "reqaddrs");
2520
2521     /* check for valid set of addresses */
2522     if (!_kdc_check_addresses(r, b->addresses, r->addr)) {
2523         if (r->config->warn_ticket_addresses) {
2524             kdc_audit_setkv_bool((kdc_request_t)r, "wrongaddr", TRUE);
2525         } else {
2526             _kdc_set_e_text(r, "Request from wrong address");
2527             ret = KRB5KRB_AP_ERR_BADADDR;
2528             goto out;
2529         }
2530     }
2531
2532     ret = copy_PrincipalName(&rep->cname, &r->et.cname);
2533     if (ret)
2534         goto out;
2535     ret = copy_Realm(&rep->crealm, &r->et.crealm);
2536     if (ret)
2537         goto out;
2538
2539     {
2540         time_t start;
2541         time_t t;
2542
2543         start = r->et.authtime = kdc_time;
2544
2545         if(f.postdated && req->req_body.from){
2546             ALLOC(r->et.starttime);
2547             start = *r->et.starttime = *req->req_body.from;
2548             r->et.flags.invalid = 1;
2549             r->et.flags.postdated = 1; /* XXX ??? */
2550         }
2551         _kdc_fix_time(&b->till);
2552         t = *b->till;
2553
2554         /* be careful not overflowing */
2555
2556         /*
2557          * Pre-auth can override r->client->max_life if configured.
2558          *
2559          * See pre-auth methods, specifically PKINIT, which can get or derive
2560          * this from the client's certificate.
2561          */
2562         if (r->pa_max_life > 0)
2563             t = rk_time_add(start, min(rk_time_sub(t, start), r->pa_max_life));
2564         else if (r->client->max_life)
2565             t = rk_time_add(start, min(rk_time_sub(t, start),
2566                                        *r->client->max_life));
2567
2568         if (r->server->max_life)
2569             t = rk_time_add(start, min(rk_time_sub(t, start),
2570                                        *r->server->max_life));
2571
2572         /* Pre-auth can bound endtime as well */
2573         if (r->pa_endtime > 0)
2574             t = rk_time_add(start, min(rk_time_sub(t, start), r->pa_endtime));
2575 #if 0
2576         t = min(t, rk_time_add(start, realm->max_life));
2577 #endif
2578         r->et.endtime = t;
2579
2580         if (start > r->et.endtime) {
2581             _kdc_set_e_text(r, "Requested effective lifetime is negative or too short");
2582             ret = KRB5KDC_ERR_NEVER_VALID;
2583             goto out;
2584         }
2585
2586         if(f.renewable_ok && r->et.endtime < *b->till){
2587             f.renewable = 1;
2588             if(b->rtime == NULL){
2589                 ALLOC(b->rtime);
2590                 *b->rtime = 0;
2591             }
2592             if(*b->rtime < *b->till)
2593                 *b->rtime = *b->till;
2594         }
2595         if(f.renewable && b->rtime){
2596             t = *b->rtime;
2597             if(t == 0)
2598                 t = MAX_TIME;
2599             if(r->client->max_renew)
2600                 t = rk_time_add(start, min(rk_time_sub(t, start),
2601                                            *r->client->max_renew));
2602             if(r->server->max_renew)
2603                 t = rk_time_add(start, min(rk_time_sub(t, start),
2604                                            *r->server->max_renew));
2605 #if 0
2606             t = min(t, rk_time_add(start, realm->max_renew));
2607 #endif
2608             ALLOC(r->et.renew_till);
2609             *r->et.renew_till = t;
2610             r->et.flags.renewable = 1;
2611         }
2612     }
2613
2614     if(b->addresses){
2615         ALLOC(r->et.caddr);
2616         copy_HostAddresses(b->addresses, r->et.caddr);
2617     }
2618
2619     r->et.transited.tr_type = domain_X500_Compress;
2620     krb5_data_zero(&r->et.transited.contents);
2621
2622     /* The MIT ASN.1 library (obviously) doesn't tell lengths encoded
2623      * as 0 and as 0x80 (meaning indefinite length) apart, and is thus
2624      * incapable of correctly decoding SEQUENCE OF's of zero length.
2625      *
2626      * To fix this, always send at least one no-op last_req
2627      *
2628      * If there's a pw_end or valid_end we will use that,
2629      * otherwise just a dummy lr.
2630      */
2631     r->ek.last_req.val = malloc(2 * sizeof(*r->ek.last_req.val));
2632     if (r->ek.last_req.val == NULL) {
2633         ret = ENOMEM;
2634         goto out;
2635     }
2636     r->ek.last_req.len = 0;
2637     if (r->client->pw_end
2638         && (config->kdc_warn_pwexpire == 0
2639             || kdc_time + config->kdc_warn_pwexpire >= *r->client->pw_end)) {
2640         r->ek.last_req.val[r->ek.last_req.len].lr_type  = LR_PW_EXPTIME;
2641         r->ek.last_req.val[r->ek.last_req.len].lr_value = *r->client->pw_end;
2642         ++r->ek.last_req.len;
2643     }
2644     if (r->client->valid_end) {
2645         r->ek.last_req.val[r->ek.last_req.len].lr_type  = LR_ACCT_EXPTIME;
2646         r->ek.last_req.val[r->ek.last_req.len].lr_value = *r->client->valid_end;
2647         ++r->ek.last_req.len;
2648     }
2649     if (r->ek.last_req.len == 0) {
2650         r->ek.last_req.val[r->ek.last_req.len].lr_type  = LR_NONE;
2651         r->ek.last_req.val[r->ek.last_req.len].lr_value = 0;
2652         ++r->ek.last_req.len;
2653     }
2654     r->ek.nonce = b->nonce;
2655     if (r->client->valid_end || r->client->pw_end) {
2656         ALLOC(r->ek.key_expiration);
2657         if (r->client->valid_end) {
2658             if (r->client->pw_end)
2659                 *r->ek.key_expiration = min(*r->client->valid_end,
2660                                          *r->client->pw_end);
2661             else
2662                 *r->ek.key_expiration = *r->client->valid_end;
2663         } else
2664             *r->ek.key_expiration = *r->client->pw_end;
2665     } else
2666         r->ek.key_expiration = NULL;
2667     r->ek.flags = r->et.flags;
2668     r->ek.authtime = r->et.authtime;
2669     if (r->et.starttime) {
2670         ALLOC(r->ek.starttime);
2671         *r->ek.starttime = *r->et.starttime;
2672     }
2673     r->ek.endtime = r->et.endtime;
2674     if (r->et.renew_till) {
2675         ALLOC(r->ek.renew_till);
2676         *r->ek.renew_till = *r->et.renew_till;
2677     }
2678     ret = copy_Realm(&rep->ticket.realm, &r->ek.srealm);
2679     if (ret)
2680         goto out;
2681     ret = copy_PrincipalName(&rep->ticket.sname, &r->ek.sname);
2682     if (ret)
2683         goto out;
2684     if(r->et.caddr){
2685         ALLOC(r->ek.caddr);
2686         copy_HostAddresses(r->et.caddr, r->ek.caddr);
2687     }
2688
2689     /*
2690      * Check and session and reply keys
2691      */
2692
2693     if (r->session_key.keytype == ETYPE_NULL) {
2694         ret = krb5_generate_random_keyblock(r->context, r->sessionetype, &r->session_key);
2695         if (ret)
2696             goto out;
2697     }
2698
2699     if (r->reply_key.keytype == ETYPE_NULL) {
2700         _kdc_set_e_text(r, "Client have no reply key");
2701         ret = KRB5KDC_ERR_CLIENT_NOTYET;
2702         goto out;
2703     }
2704
2705     ret = copy_EncryptionKey(&r->session_key, &r->et.key);
2706     if (ret)
2707         goto out;
2708
2709     ret = copy_EncryptionKey(&r->session_key, &r->ek.key);
2710     if (ret)
2711         goto out;
2712
2713     /* Add the PAC */
2714     if (!r->et.flags.anonymous) {
2715         ret = generate_pac(r, skey, krbtgt_key, is_tgs);
2716         if (ret)
2717             goto out;
2718     }
2719
2720     if (r->client->flags.synthetic) {
2721         ret = add_synthetic_princ_ad(r);
2722         if (ret)
2723             goto out;
2724     }
2725
2726     _kdc_log_timestamp(r, "AS-REQ", r->et.authtime,
2727                        r->et.starttime, r->et.endtime,
2728                        r->et.renew_till);
2729
2730     _log_astgs_req(r, setype);
2731
2732     /*
2733      * We always say we support FAST/enc-pa-rep
2734      */
2735
2736     r->et.flags.enc_pa_rep = r->ek.flags.enc_pa_rep = 1;
2737
2738     /*
2739      * update reply-key with strengthen-key
2740      */
2741
2742     ret = _kdc_fast_strengthen_reply_key(r);
2743     if (ret)
2744         goto out;
2745
2746     /*
2747      * Add REQ_ENC_PA_REP if client supports it
2748      */
2749
2750     i = 0;
2751     pa = _kdc_find_padata(req, &i, KRB5_PADATA_REQ_ENC_PA_REP);
2752     if (pa) {
2753
2754         ret = add_enc_pa_rep(r);
2755         if (ret) {
2756             msg = krb5_get_error_message(r->context, ret);
2757             _kdc_r_log(r, 4, "add_enc_pa_rep failed: %s: %d", msg, ret);
2758             krb5_free_error_message(r->context, msg);
2759             goto out;
2760         }
2761     }
2762
2763     /*
2764      * Last chance for plugins to update reply
2765      */
2766     ret = _kdc_finalize_reply(r);
2767     if (ret)
2768         goto out;
2769
2770     /*
2771      * Don't send kvno from client entry if the pre-authentication
2772      * mechanism replaced the reply key.
2773      */
2774
2775     ret = _kdc_encode_reply(r->context, config,
2776                             r, req->req_body.nonce, setype,
2777                             r->server->kvno, &skey->key,
2778                             pa_used_flag_isset(r, PA_REPLACE_REPLY_KEY) ? 0 : r->client->kvno,
2779                             0, r->reply);
2780     if (ret)
2781         goto out;
2782
2783     /*
2784      * Check if message too large
2785      */
2786     if (r->datagram_reply && r->reply->length > config->max_datagram_reply_length) {
2787         krb5_data_free(r->reply);
2788         ret = KRB5KRB_ERR_RESPONSE_TOO_BIG;
2789         _kdc_set_e_text(r, "Reply packet too large");
2790     }
2791
2792 out:
2793     r->error_code = ret;
2794     {
2795         krb5_error_code ret2 = _kdc_audit_request(r);
2796         if (ret2) {
2797             krb5_data_free(r->reply);
2798             ret = ret2;
2799         }
2800     }
2801
2802     /*
2803      * In case of a non proxy error, build an error message.
2804      */
2805     if (ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE && r->reply->length == 0) {
2806         kdc_log(r->context, config, 5, "as-req: sending error: %d to client", ret);
2807         ret = _kdc_fast_mk_error(r,
2808                                  r->rep.padata,
2809                                  r->armor_crypto,
2810                                  &req->req_body,
2811                                  r->error_code,
2812                                  r->client_princ,
2813                                  r->server_princ,
2814                                  NULL, NULL,
2815                                  r->reply);
2816     }
2817
2818     if (r->pa_used && r->pa_used->cleanup)
2819         r->pa_used->cleanup(r);
2820
2821     free_AS_REP(&r->rep);
2822     free_EncTicketPart(&r->et);
2823     free_EncKDCRepPart(&r->ek);
2824     _kdc_free_fast_state(&r->fast);
2825
2826     if (r->client_princ) {
2827         krb5_free_principal(r->context, r->client_princ);
2828         r->client_princ = NULL;
2829     }
2830     if (r->server_princ){
2831         krb5_free_principal(r->context, r->server_princ);
2832         r->server_princ = NULL;
2833     }
2834     if (r->client)
2835         _kdc_free_ent(r->context, r->clientdb, r->client);
2836     if (r->server)
2837         _kdc_free_ent(r->context, r->serverdb, r->server);
2838     if (r->krbtgt)
2839         _kdc_free_ent(r->context, r->krbtgtdb, r->krbtgt);
2840     if (r->armor_crypto) {
2841         krb5_crypto_destroy(r->context, r->armor_crypto);
2842         r->armor_crypto = NULL;
2843     }
2844     if (r->armor_ticket)
2845         krb5_free_ticket(r->context, r->armor_ticket);
2846     if (r->armor_server)
2847         _kdc_free_ent(r->context, r->armor_serverdb, r->armor_server);
2848     krb5_free_keyblock_contents(r->context, &r->reply_key);
2849     krb5_free_keyblock_contents(r->context, &r->session_key);
2850     krb5_free_keyblock_contents(r->context, &r->strengthen_key);
2851     krb5_pac_free(r->context, r->pac);
2852
2853     return ret;
2854 }