kdc/kerberos5.c

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