src/kdc/do_tgs_req.c

   1 /*
   2  * kdc/do_tgs_req.c
   3  *
   4  * Copyright 1990,1991 by the Massachusetts Institute of Technology.
   5  * All Rights Reserved.
   6  *
   7  * Export of this software from the United States of America may
   8  *   require a specific license from the United States Government.
   9  *   It is the responsibility of any person or organization contemplating
  10  *   export to obtain such a license before exporting.
  11  *
  12  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  13  * distribute this software and its documentation for any purpose and
  14  * without fee is hereby granted, provided that the above copyright
  15  * notice appear in all copies and that both that copyright notice and
  16  * this permission notice appear in supporting documentation, and that
  17  * the name of M.I.T. not be used in advertising or publicity pertaining
  18  * to distribution of the software without specific, written prior
  19  * permission.  M.I.T. makes no representations about the suitability of
  20  * this software for any purpose.  It is provided "as is" without express
  21  * or implied warranty.
  22  *
  23  *
  24  * KDC Routines to deal with TGS_REQ's
  25  */
  26
  27 #include "k5-int.h"
  28 #include "com_err.h"
  29
  30 #include <syslog.h>
  31 #ifdef KRB5_USE_INET
  32 #include <sys/types.h>
  33 #include <netinet/in.h>
  34 #ifndef hpux
  35 #include <arpa/inet.h>
  36 #endif
  37 #endif
  38
  39 #include "kdc_util.h"
  40 #include "policy.h"
  41 #include "extern.h"
  42 #include "adm_proto.h"
  43
  44
  45 static void find_alternate_tgs PROTOTYPE((krb5_kdc_req *,
  46                                           krb5_db_entry *,
  47                                           krb5_boolean *,
  48                                           int *));
  49
  50 static krb5_error_code prepare_error_tgs PROTOTYPE((krb5_kdc_req *,
  51                                                     krb5_ticket *,
  52                                                     int,
  53                                                     const char *,
  54                                                     krb5_data **));
  55
  56 /*ARGSUSED*/
  57 krb5_error_code
  58 process_tgs_req(pkt, from, portnum, response)
  59 krb5_data *pkt;
  60 const krb5_fulladdr *from;              /* who sent it ? */
  61 int     portnum;
  62 krb5_data **response;                   /* filled in with a response packet */
  63 {
  64     krb5_keyblock * subkey;
  65     krb5_encrypt_block eblock;
  66     krb5_kdc_req *request = 0;
  67     krb5_db_entry server;
  68     krb5_kdc_rep reply;
  69     krb5_enc_kdc_rep_part reply_encpart;
  70     krb5_ticket ticket_reply, *header_ticket = 0;
  71     int st_idx = 0;
  72     krb5_enc_tkt_part enc_tkt_reply;
  73     krb5_transited enc_tkt_transited;
  74     int newtransited = 0;
  75     krb5_error_code retval = 0;
  76     int nprincs = 0;
  77     krb5_boolean more;
  78     krb5_timestamp kdc_time, authtime;
  79     krb5_keyblock *session_key = 0;
  80     krb5_timestamp until, rtime;
  81     krb5_keyblock encrypting_key;
  82     krb5_key_data  *server_key;
  83     char *cname = 0, *sname = 0, *tmp = 0, *fromstring = 0;
  84     krb5_last_req_entry *nolrarray[2], nolrentry;
  85 /*    krb5_address *noaddrarray[1]; */
  86     krb5_enctype useenctype;
  87     int errcode, errcode2;
  88     register int i;
  89     int firstpass = 1;
  90     const char  *status = 0;
  91
  92     retval = decode_krb5_tgs_req(pkt, &request);
  93     if (retval)
  94         return retval;
  95
  96     /*
  97      * setup_server_realm() sets up the global realm-specific data pointer.
  98      */
  99     if ((retval = setup_server_realm(request->server)))
 100         return retval;
 101
 102 #ifdef KRB5_USE_INET
 103     if (from->address->addrtype == ADDRTYPE_INET)
 104         fromstring =
 105             (char *) inet_ntoa(*(struct in_addr *)from->address->contents);
 106 #endif
 107     if (!fromstring)
 108         fromstring = "<unknown>";
 109
 110     if ((errcode = krb5_unparse_name(kdc_context, request->server, &sname))) {
 111         status = "UNPARSING SERVER";
 112         goto cleanup;
 113     }
 114
 115    /* errcode = kdc_process_tgs_req(request, from, pkt, &req_authdat); */
 116     errcode = kdc_process_tgs_req(request, from, pkt, &header_ticket, &subkey);
 117
 118     if (header_ticket && header_ticket->enc_part2 &&
 119         (errcode2 = krb5_unparse_name(kdc_context,
 120                                       header_ticket->enc_part2->client,
 121                                       &cname))) {
 122         status = "UNPARSING CLIENT";
 123         errcode = errcode2;
 124         goto cleanup;
 125     }
 126
 127     if (errcode) {
 128         status = "PROCESS_TGS";
 129         goto cleanup;
 130     }
 131
 132     if (!header_ticket) {
 133         status="UNEXPECTED NULL in header_ticket";
 134         goto cleanup;
 135     }
 136
 137     /*
 138      * We've already dealt with the AP_REQ authentication, so we can
 139      * use header_ticket freely.  The encrypted part (if any) has been
 140      * decrypted with the session key.
 141      */
 142
 143     authtime = header_ticket->enc_part2->times.authtime;
 144
 145     /* XXX make sure server here has the proper realm...taken from AP_REQ
 146        header? */
 147
 148     nprincs = 1;
 149     if ((errcode = krb5_db_get_principal(kdc_context, request->server, &server,
 150                                         &nprincs, &more))) {
 151         status = "LOOKING_UP_SERVER";
 152         nprincs = 0;
 153         goto cleanup;
 154     }
 155 tgt_again:
 156     if (more) {
 157         status = "NON_UNIQUE_PRINCIPAL";
 158         errcode = KRB5KDC_ERR_PRINCIPAL_NOT_UNIQUE;
 159         goto cleanup;
 160     } else if (nprincs != 1) {
 161         /*
 162          * might be a request for a TGT for some other realm; we
 163          * should do our best to find such a TGS in this db
 164          */
 165         if (firstpass && krb5_princ_size(kdc_context, request->server) == 2) {
 166             krb5_data *server_1 = krb5_princ_component(kdc_context, request->server, 1);
 167             krb5_data *tgs_1 = krb5_princ_component(kdc_context, tgs_server, 1);
 168
 169             if (server_1->length != tgs_1->length ||
 170                 memcmp(server_1->data, tgs_1->data, tgs_1->length)) {
 171                 krb5_db_free_principal(kdc_context, &server, nprincs);
 172                 find_alternate_tgs(request, &server, &more, &nprincs);
 173                 firstpass = 0;
 174                 goto tgt_again;
 175             }
 176         }
 177         krb5_db_free_principal(kdc_context, &server, nprincs);
 178         status = "UNKNOWN_SERVER";
 179         errcode = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
 180         goto cleanup;
 181     }
 182
 183     if ((errcode = krb5_timeofday(kdc_context, &kdc_time))) {
 184         status = "TIME_OF_DAY";
 185         goto cleanup;
 186     }
 187
 188     if ((retval = validate_tgs_request(request, server, header_ticket,
 189                                       kdc_time, &status))) {
 190         if (!status)
 191             status = "UNKNOWN_REASON";
 192         errcode = retval + ERROR_TABLE_BASE_krb5;
 193         goto cleanup;
 194     }
 195
 196     /*
 197      * We pick the session keytype here....
 198      *
 199      * Some special care needs to be taken in the user-to-user
 200      * case, since we don't know what keytypes the application server
 201      * which is doing user-to-user authentication can support.  We
 202      * know that it at least must be able to support the encryption
 203      * type of the session key in the TGT, since otherwise it won't be
 204      * able to decrypt the U2U ticket!  So we use that in preference
 205      * to anything else.
 206      */
 207     useenctype = 0;
 208     if (isflagset(request->kdc_options, KDC_OPT_ENC_TKT_IN_SKEY)) {
 209         krb5_keyblock * st_sealing_key;
 210         krb5_kvno       st_srv_kvno;
 211         krb5_enctype    etype;
 212
 213         /*
 214          * Get the key for the second ticket, and decrypt it.
 215          */
 216         if ((errcode = kdc_get_server_key(request->second_ticket[st_idx],
 217                                          &st_sealing_key,
 218                                          &st_srv_kvno))) {
 219             status = "2ND_TKT_SERVER";
 220             goto cleanup;
 221         }
 222         errcode = krb5_decrypt_tkt_part(kdc_context, st_sealing_key,
 223                                        request->second_ticket[st_idx]);
 224         krb5_free_keyblock(kdc_context, st_sealing_key);
 225         if (errcode) {
 226             status = "2ND_TKT_DECRYPT";
 227             goto cleanup;
 228         }
 229
 230         etype = request->second_ticket[st_idx]->enc_part2->session->enctype;
 231         if (!valid_enctype(etype)) {
 232             status = "BAD_ETYPE_IN_2ND_TKT";
 233             errcode = KRB5KDC_ERR_ETYPE_NOSUPP;
 234             goto cleanup;
 235         }
 236
 237         for (i = 0; i < request->nktypes; i++) {
 238             if (request->ktype[i] == etype) {
 239                 useenctype = etype;
 240                 break;
 241             }
 242         }
 243     }
 244
 245     /*
 246      * Select the keytype for the ticket session key.
 247      */
 248     if ((useenctype == 0) &&
 249         (useenctype = select_session_keytype(kdc_context, &server,
 250                                              request->nktypes,
 251                                              request->ktype)) == 0) {
 252         /* unsupported ktype */
 253         status = "BAD_ENCRYPTION_TYPE";
 254         errcode = KRB5KDC_ERR_ETYPE_NOSUPP;
 255         goto cleanup;
 256     }
 257
 258     krb5_use_enctype(kdc_context, &eblock, useenctype);
 259     errcode = krb5_random_key(kdc_context, &eblock,
 260                              krb5_enctype_array[useenctype]->random_sequence,
 261                              &session_key);
 262     if (errcode) {
 263         /* random key failed */
 264         status = "RANDOM_KEY_FAILED";
 265         goto cleanup;
 266     }
 267
 268     ticket_reply.server = request->server; /* XXX careful for realm... */
 269
 270     enc_tkt_reply.flags = 0;
 271     enc_tkt_reply.times.starttime = 0;
 272
 273     /*
 274      * Fix header_ticket's starttime; if it's zero, fill in the
 275      * authtime's value.
 276      */
 277     if (!(header_ticket->enc_part2->times.starttime))
 278         header_ticket->enc_part2->times.starttime =
 279             header_ticket->enc_part2->times.authtime;
 280
 281     /* don't use new addresses unless forwarded, see below */
 282
 283     enc_tkt_reply.caddrs = header_ticket->enc_part2->caddrs;
 284     /* noaddrarray[0] = 0; */
 285     reply_encpart.caddrs = 0;           /* optional...don't put it in */
 286
 287     /* It should be noted that local policy may affect the  */
 288     /* processing of any of these flags.  For example, some */
 289     /* realms may refuse to issue renewable tickets         */
 290
 291     if (isflagset(request->kdc_options, KDC_OPT_FORWARDABLE))
 292         setflag(enc_tkt_reply.flags, TKT_FLG_FORWARDABLE);
 293
 294     if (isflagset(request->kdc_options, KDC_OPT_FORWARDED)) {
 295         setflag(enc_tkt_reply.flags, TKT_FLG_FORWARDED);
 296
 297         /* include new addresses in ticket & reply */
 298
 299         enc_tkt_reply.caddrs = request->addresses;
 300         reply_encpart.caddrs = request->addresses;
 301     }
 302     if (isflagset(header_ticket->enc_part2->flags, TKT_FLG_FORWARDED))
 303         setflag(enc_tkt_reply.flags, TKT_FLG_FORWARDED);
 304
 305     if (isflagset(request->kdc_options, KDC_OPT_PROXIABLE))
 306         setflag(enc_tkt_reply.flags, TKT_FLG_PROXIABLE);
 307
 308     if (isflagset(request->kdc_options, KDC_OPT_PROXY)) {
 309         setflag(enc_tkt_reply.flags, TKT_FLG_PROXY);
 310
 311         /* include new addresses in ticket & reply */
 312
 313         enc_tkt_reply.caddrs = request->addresses;
 314         reply_encpart.caddrs = request->addresses;
 315     }
 316
 317     if (isflagset(request->kdc_options, KDC_OPT_ALLOW_POSTDATE))
 318         setflag(enc_tkt_reply.flags, TKT_FLG_MAY_POSTDATE);
 319
 320     if (isflagset(request->kdc_options, KDC_OPT_POSTDATED)) {
 321         setflag(enc_tkt_reply.flags, TKT_FLG_POSTDATED);
 322         setflag(enc_tkt_reply.flags, TKT_FLG_INVALID);
 323         enc_tkt_reply.times.starttime = request->from;
 324     } else
 325         enc_tkt_reply.times.starttime = kdc_time;
 326
 327     if (isflagset(request->kdc_options, KDC_OPT_VALIDATE)) {
 328         /* BEWARE of allocation hanging off of ticket & enc_part2, it belongs
 329            to the caller */
 330         ticket_reply = *(header_ticket);
 331         enc_tkt_reply = *(header_ticket->enc_part2);
 332         clear(enc_tkt_reply.flags, TKT_FLG_INVALID);
 333     }
 334
 335     if (isflagset(request->kdc_options, KDC_OPT_RENEW)) {
 336         krb5_deltat old_life;
 337
 338         /* BEWARE of allocation hanging off of ticket & enc_part2, it belongs
 339            to the caller */
 340         ticket_reply = *(header_ticket);
 341         enc_tkt_reply = *(header_ticket->enc_part2);
 342
 343         old_life = enc_tkt_reply.times.endtime - enc_tkt_reply.times.starttime;
 344
 345         enc_tkt_reply.times.starttime = kdc_time;
 346         enc_tkt_reply.times.endtime =
 347             min(header_ticket->enc_part2->times.renew_till,
 348                 kdc_time + old_life);
 349     } else {
 350         /* not a renew request */
 351         enc_tkt_reply.times.starttime = kdc_time;
 352         until = (request->till == 0) ? kdc_infinity : request->till;
 353         enc_tkt_reply.times.endtime =
 354             min(until, min(enc_tkt_reply.times.starttime + server.max_life,
 355                            min(enc_tkt_reply.times.starttime + max_life_for_realm,
 356                                header_ticket->enc_part2->times.endtime)));
 357         if (isflagset(request->kdc_options, KDC_OPT_RENEWABLE_OK) &&
 358             (enc_tkt_reply.times.endtime < request->till) &&
 359             isflagset(header_ticket->enc_part2->flags,
 360                   TKT_FLG_RENEWABLE)) {
 361             setflag(request->kdc_options, KDC_OPT_RENEWABLE);
 362             request->rtime =
 363                 min(request->till,
 364                     header_ticket->enc_part2->times.renew_till);
 365         }
 366     }
 367     rtime = (request->rtime == 0) ? kdc_infinity : request->rtime;
 368
 369     if (isflagset(request->kdc_options, KDC_OPT_RENEWABLE)) {
 370         /* already checked above in policy check to reject request for a
 371            renewable ticket using a non-renewable ticket */
 372         setflag(enc_tkt_reply.flags, TKT_FLG_RENEWABLE);
 373         enc_tkt_reply.times.renew_till =
 374             min(rtime,
 375                 min(header_ticket->enc_part2->times.renew_till,
 376                     enc_tkt_reply.times.starttime +
 377                     min(server.max_renewable_life,
 378                         max_renewable_life_for_realm)));
 379     } else {
 380         enc_tkt_reply.times.renew_till = 0;
 381     }
 382
 383     /*
 384      * Set authtime to be the same as header_ticket's
 385      */
 386     enc_tkt_reply.times.authtime = header_ticket->enc_part2->times.authtime;
 387
 388     /*
 389      * Propagate the preauthentication flags through to the returned ticket.
 390      */
 391     if (isflagset(header_ticket->enc_part2->flags, TKT_FLG_PRE_AUTH))
 392         setflag(enc_tkt_reply.flags, TKT_FLG_PRE_AUTH);
 393
 394     if (isflagset(header_ticket->enc_part2->flags, TKT_FLG_HW_AUTH))
 395         setflag(enc_tkt_reply.flags, TKT_FLG_HW_AUTH);
 396
 397     /* starttime is optional, and treated as authtime if not present.
 398        so we can nuke it if it matches */
 399     if (enc_tkt_reply.times.starttime == enc_tkt_reply.times.authtime)
 400         enc_tkt_reply.times.starttime = 0;
 401
 402     /* assemble any authorization data */
 403     if (request->authorization_data.ciphertext.data) {
 404         krb5_encrypt_block eblock;
 405         krb5_data scratch;
 406
 407         /* decrypt the authdata in the request */
 408         if (!valid_enctype(request->authorization_data.enctype)) {
 409             status = "BAD_AUTH_ETYPE";
 410             errcode = KRB5KDC_ERR_ETYPE_NOSUPP;
 411             goto cleanup;
 412         }
 413         /* put together an eblock for this encryption */
 414
 415         krb5_use_enctype(kdc_context, &eblock,
 416                          request->authorization_data.enctype);
 417
 418         scratch.length = request->authorization_data.ciphertext.length;
 419         if (!(scratch.data =
 420               malloc(request->authorization_data.ciphertext.length))) {
 421             status = "AUTH_NOMEM";
 422             goto cleanup;
 423         }
 424         /* do any necessary key pre-processing */
 425         if ((errcode = krb5_process_key(kdc_context, &eblock,
 426                                       header_ticket->enc_part2->session))) {
 427             status = "AUTH_PROCESS_KEY";
 428             free(scratch.data);
 429             goto cleanup;
 430         }
 431
 432         /* call the encryption routine */
 433         if ((errcode = krb5_decrypt(kdc_context, (krb5_pointer) request->authorization_data.ciphertext.data,
 434                                   (krb5_pointer) scratch.data,
 435                                   scratch.length, &eblock, 0))) {
 436             status = "AUTH_ENCRYPT_FAIL";
 437             (void) krb5_finish_key(kdc_context, &eblock);
 438             free(scratch.data);
 439             goto cleanup;
 440         }
 441         if ((errcode = krb5_finish_key(kdc_context, &eblock))) {
 442             status = "AUTH_FINISH_KEY";
 443             free(scratch.data);
 444             goto cleanup;
 445         }
 446         /* scratch now has the authorization data, so we decode it */
 447         errcode = decode_krb5_authdata(&scratch, &(request->unenc_authdata));
 448         free(scratch.data);
 449         if (errcode) {
 450             status = "AUTH_DECODE";
 451             goto cleanup;
 452         }
 453
 454         if ((errcode =
 455              concat_authorization_data(request->unenc_authdata,
 456                                        header_ticket->enc_part2->authorization_data,
 457                                        &enc_tkt_reply.authorization_data))) {
 458             status = "CONCAT_AUTH";
 459             goto cleanup;
 460         }
 461     } else
 462         enc_tkt_reply.authorization_data =
 463             header_ticket->enc_part2->authorization_data;
 464
 465     enc_tkt_reply.session = session_key;
 466     enc_tkt_reply.client = header_ticket->enc_part2->client;
 467     enc_tkt_reply.transited.tr_type = KRB5_DOMAIN_X500_COMPRESS;
 468     enc_tkt_reply.transited.tr_contents = empty_string; /* equivalent of "" */
 469
 470     /*
 471      * Only add the realm of the presented tgt to the transited list if
 472      * it is different than the local realm (cross-realm) and it is different
 473      * than the realm of the client (since the realm of the client is already
 474      * implicitly part of the transited list and should not be explicitly
 475      * listed).
 476      */
 477
 478     /* realm compare is like strcmp, but knows how to deal with these args */
 479     if (realm_compare(header_ticket->server, tgs_server) ||
 480         realm_compare(header_ticket->server, enc_tkt_reply.client)) {
 481         /* tgt issued by local realm or issued by realm of client */
 482         enc_tkt_reply.transited = header_ticket->enc_part2->transited;
 483     } else {
 484         /* tgt issued by some other realm and not the realm of the client */
 485         /* assemble new transited field into allocated storage */
 486         if (header_ticket->enc_part2->transited.tr_type !=
 487             KRB5_DOMAIN_X500_COMPRESS) {
 488             status = "BAD_TRTYPE";
 489             errcode = KRB5KDC_ERR_TRTYPE_NOSUPP;
 490             goto cleanup;
 491         }
 492         enc_tkt_transited.tr_type = KRB5_DOMAIN_X500_COMPRESS;
 493         enc_tkt_transited.tr_contents.data = 0;
 494         enc_tkt_transited.tr_contents.length = 0;
 495         enc_tkt_reply.transited = enc_tkt_transited;
 496         if ((errcode =
 497              add_to_transited(&header_ticket->enc_part2->transited.tr_contents,
 498                               &enc_tkt_reply.transited.tr_contents,
 499                               header_ticket->server,
 500                               enc_tkt_reply.client,
 501                               request->server))) {
 502             status = "ADD_TR_FAIL";
 503             goto cleanup;
 504         }
 505         newtransited = 1;
 506     }
 507
 508     ticket_reply.enc_part2 = &enc_tkt_reply;
 509
 510     /*
 511      * If we are doing user-to-user authentication, then make sure
 512      * that the client for the second ticket matches the request
 513      * server, and then encrypt the ticket using the session key of
 514      * the second ticket.
 515      */
 516     if (isflagset(request->kdc_options, KDC_OPT_ENC_TKT_IN_SKEY)) {
 517         /*
 518          * Make sure the client for the second ticket matches
 519          * requested server.
 520          */
 521         if (!krb5_principal_compare(kdc_context, request->server,
 522                                     request->second_ticket[st_idx]->enc_part2->client)) {
 523                 if ((errcode = krb5_unparse_name(kdc_context,
 524                                                 request->second_ticket[st_idx]->enc_part2->client,
 525                                                 &tmp)))
 526                         tmp = 0;
 527                 krb5_klog_syslog(LOG_INFO, "TGS_REQ %s(%d): 2ND_TKT_MISMATCH: authtime %d, %s for %s, 2nd tkt client %s",
 528                        fromstring, portnum, authtime, cname, sname,
 529                        tmp ? tmp : "<unknown>");
 530                 goto cleanup;
 531         }
 532
 533         ticket_reply.enc_part.kvno = 0;
 534         ticket_reply.enc_part.enctype =
 535                 request->second_ticket[st_idx]->enc_part2->session->enctype;
 536         if ((errcode = krb5_encrypt_tkt_part(kdc_context,
 537                                             request->second_ticket[st_idx]->enc_part2->session,
 538                                             &ticket_reply))) {
 539             status = "2ND_TKT_ENCRYPT";
 540             goto cleanup;
 541         }
 542         st_idx++;
 543     } else {
 544         /*
 545          * Find the server key
 546          */
 547         if ((errcode = krb5_dbe_find_enctype(kdc_context, &server,
 548                                              -1, /* ignore keytype */
 549                                              -1, /* Ignore salttype */
 550                                              0,         /* Get highest kvno */
 551                                              &server_key))) {
 552             status = "FINDING_SERVER_KEY";
 553             goto cleanup;
 554         }
 555         /* convert server.key into a real key (it may be encrypted
 556          *        in the database) */
 557         if ((errcode = krb5_dbekd_decrypt_key_data(kdc_context,
 558                                                    &master_encblock,
 559                                                    server_key, &encrypting_key,
 560                                                    NULL))) {
 561             status = "DECRYPT_SERVER_KEY";
 562             goto cleanup;
 563         }
 564         if ((encrypting_key.enctype == ENCTYPE_DES_CBC_CRC) &&
 565             (isflagset(server.attributes, KRB5_KDB_SUPPORT_DESMD5)))
 566             encrypting_key.enctype = ENCTYPE_DES_CBC_MD5;
 567         ticket_reply.enc_part.kvno = server_key->key_data_kvno;
 568         errcode = krb5_encrypt_tkt_part(kdc_context, &encrypting_key,
 569                                         &ticket_reply);
 570         krb5_free_keyblock_contents(kdc_context, &encrypting_key);
 571         if (errcode) {
 572             status = "TKT_ENCRYPT";
 573             goto cleanup;
 574         }
 575     }
 576
 577     /* Start assembling the response */
 578     reply.msg_type = KRB5_TGS_REP;
 579     reply.padata = 0;           /* always */
 580     reply.client = header_ticket->enc_part2->client;
 581     reply.enc_part.kvno = 0;            /* We are using the session key */
 582     reply.ticket = &ticket_reply;
 583
 584     reply_encpart.session = session_key;
 585     reply_encpart.nonce = request->nonce;
 586
 587     /* copy the time fields EXCEPT for authtime; its location
 588        is used for ktime */
 589     reply_encpart.times = enc_tkt_reply.times;
 590     reply_encpart.times.authtime = header_ticket->enc_part2->times.authtime;
 591
 592     /* starttime is optional, and treated as authtime if not present.
 593        so we can nuke it if it matches */
 594     if (enc_tkt_reply.times.starttime == enc_tkt_reply.times.authtime)
 595         enc_tkt_reply.times.starttime = 0;
 596
 597     nolrentry.lr_type = KRB5_LRQ_NONE;
 598     nolrentry.value = 0;
 599     nolrarray[0] = &nolrentry;
 600     nolrarray[1] = 0;
 601     reply_encpart.last_req = nolrarray; /* not available for TGS reqs */
 602     reply_encpart.key_exp = 0;          /* ditto */
 603     reply_encpart.flags = enc_tkt_reply.flags;
 604     reply_encpart.server = ticket_reply.server;
 605
 606     /* use the session key in the ticket, unless there's a subsession key
 607        in the AP_REQ */
 608
 609     reply.enc_part.enctype = subkey ? subkey->enctype :
 610                     header_ticket->enc_part2->session->enctype;
 611     errcode = krb5_encode_kdc_rep(kdc_context, KRB5_TGS_REP, &reply_encpart,
 612                                   subkey ? subkey :
 613                                   header_ticket->enc_part2->session,
 614                                   &reply, response);
 615     if (errcode) {
 616         status = "ENCODE_KDC_REP";
 617     } else {
 618         status = "ISSUE";
 619     }
 620
 621     memset(ticket_reply.enc_part.ciphertext.data, 0,
 622            ticket_reply.enc_part.ciphertext.length);
 623     free(ticket_reply.enc_part.ciphertext.data);
 624     /* these parts are left on as a courtesy from krb5_encode_kdc_rep so we
 625        can use them in raw form if needed.  But, we don't... */
 626     memset(reply.enc_part.ciphertext.data, 0,
 627            reply.enc_part.ciphertext.length);
 628     free(reply.enc_part.ciphertext.data);
 629
 630 cleanup:
 631     if (status)
 632         krb5_klog_syslog(LOG_INFO, "TGS_REQ %s(%d): %s: authtime %d, %s for %s%s%s",
 633                fromstring, portnum, status, authtime,
 634                cname ? cname : "<unknown client>",
 635                sname ? sname : "<unknown server>",
 636                errcode ? ", " : "",
 637                errcode ? error_message(errcode) : "");
 638     if (errcode) {
 639         errcode -= ERROR_TABLE_BASE_krb5;
 640         if (errcode < 0 || errcode > 128)
 641             errcode = KRB_ERR_GENERIC;
 642
 643         retval = prepare_error_tgs(request, header_ticket, errcode,
 644                                    fromstring, response);
 645     }
 646
 647     if (header_ticket)
 648         krb5_free_ticket(kdc_context, header_ticket);
 649     if (request)
 650         krb5_free_kdc_req(kdc_context, request);
 651     if (cname)
 652         free(cname);
 653     if (sname)
 654         free(sname);
 655     if (nprincs)
 656         krb5_db_free_principal(kdc_context, &server, 1);
 657     if (session_key)
 658         krb5_free_keyblock(kdc_context, session_key);
 659     if (newtransited)
 660         free(enc_tkt_reply.transited.tr_contents.data);
 661
 662     return retval;
 663 }
 664
 665 static krb5_error_code
 666 prepare_error_tgs (request, ticket, error, ident, response)
 667 register krb5_kdc_req *request;
 668 krb5_ticket *ticket;
 669 int error;
 670 const char *ident;
 671 krb5_data **response;
 672 {
 673     krb5_error errpkt;
 674     krb5_error_code retval;
 675     krb5_data *scratch;
 676
 677     errpkt.ctime = request->nonce;
 678     errpkt.cusec = 0;
 679
 680     if ((retval = krb5_us_timeofday(kdc_context, &errpkt.stime,
 681                                     &errpkt.susec)))
 682         return(retval);
 683     errpkt.error = error;
 684     errpkt.server = request->server;
 685     if (ticket && ticket->enc_part2)
 686         errpkt.client = ticket->enc_part2->client;
 687     else
 688         errpkt.client = 0;
 689     errpkt.text.length = strlen(error_message(error+KRB5KDC_ERR_NONE))+1;
 690     if (!(errpkt.text.data = malloc(errpkt.text.length)))
 691         return ENOMEM;
 692     (void) strcpy(errpkt.text.data, error_message(error+KRB5KDC_ERR_NONE));
 693
 694     if (!(scratch = (krb5_data *)malloc(sizeof(*scratch)))) {
 695         free(errpkt.text.data);
 696         return ENOMEM;
 697     }
 698     errpkt.e_data.length = 0;
 699     errpkt.e_data.data = 0;
 700
 701     retval = krb5_mk_error(kdc_context, &errpkt, scratch);
 702     free(errpkt.text.data);
 703     *response = scratch;
 704     return retval;
 705 }
 706
 707 /*
 708  * The request seems to be for a ticket-granting service somewhere else,
 709  * but we don't have a ticket for the final TGS.  Try to give the requestor
 710  * some intermediate realm.
 711  */
 712 static void
 713 find_alternate_tgs(request, server, more, nprincs)
 714 krb5_kdc_req *request;
 715 krb5_db_entry *server;
 716 krb5_boolean *more;
 717 int *nprincs;
 718 {
 719     krb5_error_code retval;
 720     krb5_principal *plist, *pl2;
 721     krb5_data tmp;
 722
 723     *nprincs = 0;
 724     *more = FALSE;
 725
 726     if ((retval = krb5_walk_realm_tree(kdc_context,
 727                       krb5_princ_realm(kdc_context, request->server),
 728                       krb5_princ_component(kdc_context, request->server, 1),
 729                                       &plist, KRB5_REALM_BRANCH_CHAR)))
 730         return;
 731
 732     /* move to the end */
 733     for (pl2 = plist; *pl2; pl2++);
 734
 735     /* the first entry in this array is for krbtgt/local@local, so we
 736        ignore it */
 737     while (--pl2 > plist) {
 738         *nprincs = 1;
 739         tmp = *krb5_princ_realm(kdc_context, *pl2);
 740         krb5_princ_set_realm(kdc_context, *pl2,
 741                              krb5_princ_realm(kdc_context, tgs_server));
 742         retval = krb5_db_get_principal(kdc_context, *pl2, server, nprincs, more);
 743         krb5_princ_set_realm(kdc_context, *pl2, &tmp);
 744         if (retval) {
 745             *nprincs = 0;
 746             *more = FALSE;
 747             krb5_free_realm_tree(kdc_context, plist);
 748             return;
 749         }
 750         if (*more) {
 751             krb5_db_free_principal(kdc_context, server, *nprincs);
 752             continue;
 753         } else if (*nprincs == 1) {
 754             /* Found it! */
 755             krb5_principal tmpprinc;
 756             char *sname;
 757
 758             tmp = *krb5_princ_realm(kdc_context, *pl2);
 759             krb5_princ_set_realm(kdc_context, *pl2,
 760                                  krb5_princ_realm(kdc_context, tgs_server));
 761             if ((retval = krb5_copy_principal(kdc_context, *pl2, &tmpprinc))) {
 762                 krb5_db_free_principal(kdc_context, server, *nprincs);
 763                 krb5_princ_set_realm(kdc_context, *pl2, &tmp);
 764                 continue;
 765             }
 766             krb5_princ_set_realm(kdc_context, *pl2, &tmp);
 767
 768             krb5_free_principal(kdc_context, request->server);
 769             request->server = tmpprinc;
 770             if (krb5_unparse_name(kdc_context, request->server, &sname)) {
 771                 krb5_klog_syslog(LOG_INFO,
 772                        "TGS_REQ: issuing alternate <un-unparseable> TGT");
 773             } else {
 774                 krb5_klog_syslog(LOG_INFO,
 775                        "TGS_REQ: issuing TGT %s", sname);
 776                 free(sname);
 777             }
 778             return;
 779         }
 780         krb5_db_free_principal(kdc_context, server, *nprincs);
 781         continue;
 782     }
 783
 784     *nprincs = 0;
 785     *more = FALSE;
 786     krb5_free_realm_tree(kdc_context, plist);
 787     return;
 788 }
 789