← Back to branch summary

~ubuntu-branches/ubuntu/raring/heimdal/raring

« back to all changes in this revision

Viewing changes to .pc/nfs_des/kdc/kerberos5.c

  • Committer: Package Import Robot
  • Author(s): Jelmer Vernooij
  • Date: 2011-10-03 23:50:05 UTC
  • mfrom: (1.1.15) (2.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20111003235005-0voibbgdhyqmtp6w
Tags: 1.5.dfsg.1-3
http://bugs.debian.org/644138
Add conflicts with kcc to heimdal-clients. Closes: #644138

Show diffs side-by-side

added added

removed removed

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