Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
1 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source4/heimdal/kdc/default_config.c

    r414 r745  
    22 * Copyright (c) 1997-2007 Kungliga Tekniska Högskolan
    33 * (Royal Institute of Technology, Stockholm, Sweden).
    4  *
    54 * All rights reserved.
     5 *
     6 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
    67 *
    78 * Redistribution and use in source and binary forms, with or without
    … …  
    3637#include <getarg.h>
    3738#include <parse_bytes.h>
    38 
    39 RCSID("$Id$");
    4039
    4140krb5_error_code
    … …  
    216215
    217216
    218 #ifdef PKINIT
    219217    c->enable_pkinit =
    220218        krb5_config_get_bool_default(context,
    … …  
    224222                                     "enable-pkinit",
    225223                                     NULL);
    226     if (c->enable_pkinit) {
    227         const char *user_id, *anchors, *file;
    228         char **pool_list, **revoke_list;
    229 
    230         user_id =
    231             krb5_config_get_string(context, NULL,
    232                                    "kdc", "pkinit_identity", NULL);
    233         if (user_id == NULL)
    234             krb5_errx(context, 1, "pkinit enabled but no identity");
    235 
    236         anchors = krb5_config_get_string(context, NULL,
    237                                          "kdc", "pkinit_anchors", NULL);
    238         if (anchors == NULL)
    239             krb5_errx(context, 1, "pkinit enabled but no X509 anchors");
    240 
    241         pool_list =
    242             krb5_config_get_strings(context, NULL,
    243                                     "kdc", "pkinit_pool", NULL);
    244 
    245         revoke_list =
    246             krb5_config_get_strings(context, NULL,
    247                                     "kdc", "pkinit_revoke", NULL);
    248 
    249         file = krb5_config_get_string(context, NULL,
    250                                       "kdc", "pkinit_kdc_ocsp", NULL);
    251         if (file) {
    252             c->pkinit_kdc_ocsp_file = strdup(file);
    253             if (c->pkinit_kdc_ocsp_file == NULL)
    254                 krb5_errx(context, 1, "out of memory");
    255         }
    256 
    257         file = krb5_config_get_string(context, NULL,
    258                                       "kdc", "pkinit_kdc_friendly_name", NULL);
    259         if (file) {
    260             c->pkinit_kdc_friendly_name = strdup(file);
    261             if (c->pkinit_kdc_friendly_name == NULL)
    262                 krb5_errx(context, 1, "out of memory");
    263         }
    264 
    265 
    266         _kdc_pk_initialize(context, c, user_id, anchors,
    267                            pool_list, revoke_list);
    268 
    269         krb5_config_free_strings(pool_list);
    270         krb5_config_free_strings(revoke_list);
    271 
    272         c->pkinit_princ_in_cert =
    273             krb5_config_get_bool_default(context, NULL,
    274                                          c->pkinit_princ_in_cert,
    275                                          "kdc",
    276                                          "pkinit_principal_in_certificate",
    277                                          NULL);
    278 
    279         c->pkinit_require_binding =
    280             krb5_config_get_bool_default(context, NULL,
    281                                          c->pkinit_require_binding,
    282                                          "kdc",
    283                                          "pkinit_win2k_require_binding",
    284                                          NULL);
    285     }
    286 
     224
     225
     226    c->pkinit_kdc_identity =
     227        krb5_config_get_string(context, NULL,
     228                               "kdc", "pkinit_identity", NULL);
     229    c->pkinit_kdc_anchors =
     230        krb5_config_get_string(context, NULL,
     231                               "kdc", "pkinit_anchors", NULL);
     232    c->pkinit_kdc_cert_pool =
     233        krb5_config_get_strings(context, NULL,
     234                                "kdc", "pkinit_pool", NULL);
     235    c->pkinit_kdc_revoke =
     236        krb5_config_get_strings(context, NULL,
     237                                "kdc", "pkinit_revoke", NULL);
     238    c->pkinit_kdc_ocsp_file =
     239        krb5_config_get_string(context, NULL,
     240                               "kdc", "pkinit_kdc_ocsp", NULL);
     241    c->pkinit_kdc_friendly_name =
     242        krb5_config_get_string(context, NULL,
     243                               "kdc", "pkinit_kdc_friendly_name", NULL);
     244    c->pkinit_princ_in_cert =
     245        krb5_config_get_bool_default(context, NULL,
     246                                     c->pkinit_princ_in_cert,
     247                                     "kdc",
     248                                     "pkinit_principal_in_certificate",
     249                                     NULL);
     250    c->pkinit_require_binding =
     251        krb5_config_get_bool_default(context, NULL,
     252                                     c->pkinit_require_binding,
     253                                     "kdc",
     254                                     "pkinit_win2k_require_binding",
     255                                     NULL);
    287256    c->pkinit_dh_min_bits =
    288257        krb5_config_get_int_default(context, NULL,
    … …  
    290259                                    "kdc", "pkinit_dh_min_bits", NULL);
    291260
    292 #endif
    293 
    294261    *config = c;
    295262
    296263    return 0;
    297264}
     265
     266krb5_error_code
     267krb5_kdc_pkinit_config(krb5_context context, krb5_kdc_configuration *config)
     268{
     269#ifdef PKINIT
     270#ifdef __APPLE__
     271    config->enable_pkinit = 1;
     272
     273    if (config->pkinit_kdc_identity == NULL) {
     274        if (config->pkinit_kdc_friendly_name == NULL)
     275            config->pkinit_kdc_friendly_name =
     276                strdup("O=System Identity,CN=com.apple.kerberos.kdc");
     277        config->pkinit_kdc_identity = strdup("KEYCHAIN:");
     278    }
     279    if (config->pkinit_kdc_anchors == NULL)
     280        config->pkinit_kdc_anchors = strdup("KEYCHAIN:");
     281
     282#endif /* __APPLE__ */
     283
     284    if (config->enable_pkinit) {
     285        if (config->pkinit_kdc_identity == NULL)
     286            krb5_errx(context, 1, "pkinit enabled but no identity");
     287 
     288        if (config->pkinit_kdc_anchors == NULL)
     289            krb5_errx(context, 1, "pkinit enabled but no X509 anchors");
     290
     291        krb5_kdc_pk_initialize(context, config,
     292                               config->pkinit_kdc_identity,
     293                               config->pkinit_kdc_anchors,
     294                               config->pkinit_kdc_cert_pool,
     295                               config->pkinit_kdc_revoke);
     296
     297    }
     298
     299    return 0;
     300#endif /* PKINIT */
     301}   

  • trunk/server/source4/heimdal/kdc/digest.c

    r414 r745  
    178178
    179179    ret = _kdc_db_fetch(context, config, clientprincipal,
    180                         HDB_F_GET_CLIENT, &db, &user);
     180                        HDB_F_GET_CLIENT, NULL, &db, &user);
    181181    krb5_free_principal(context, clientprincipal);
    182182    if (ret)
    … …  
    293293
    294294        ret = _kdc_db_fetch(context, config, principal,
    295                             HDB_F_GET_SERVER, NULL, &server);
     295                            HDB_F_GET_SERVER, NULL, NULL, &server);
    296296        if (ret)
    297297            goto out;
    … …  
    315315
    316316        ret = _kdc_db_fetch(context, config, principal,
    317                             HDB_F_GET_CLIENT, NULL, &client);
     317                            HDB_F_GET_CLIENT, NULL, NULL, &client);
    318318        krb5_free_principal(context, principal);
    319319        if (ret)
    … …  
    614614
    615615        if (strcasecmp(ireq.u.digestRequest.type, "CHAP") == 0) {
    616             MD5_CTX ctx;
     616            EVP_MD_CTX *ctx;
    617617            unsigned char md[MD5_DIGEST_LENGTH];
    618618            char *mdx;
    … …  
    643643                goto out;
    644644
    645             MD5_Init(&ctx);
    646             MD5_Update(&ctx, &id, 1);
    647             MD5_Update(&ctx, password, strlen(password));
    648             MD5_Update(&ctx, serverNonce.data, serverNonce.length);
    649             MD5_Final(md, &ctx);
     645            ctx = EVP_MD_CTX_create();
     646
     647            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
     648            EVP_DigestUpdate(ctx, &id, 1);
     649            EVP_DigestUpdate(ctx, password, strlen(password));
     650            EVP_DigestUpdate(ctx, serverNonce.data, serverNonce.length);
     651            EVP_DigestFinal_ex(ctx, md, NULL);
     652
     653            EVP_MD_CTX_destroy(ctx);
    650654
    651655            hex_encode(md, sizeof(md), &mdx);
    … …  
    670674
    671675        } else if (strcasecmp(ireq.u.digestRequest.type, "SASL-DIGEST-MD5") == 0) {
    672             MD5_CTX ctx;
     676            EVP_MD_CTX *ctx;
    673677            unsigned char md[MD5_DIGEST_LENGTH];
    674678            char *mdx;
    … …  
    695699                goto failed;
    696700
    697             MD5_Init(&ctx);
    698             MD5_Update(&ctx, ireq.u.digestRequest.username,
     701            ctx = EVP_MD_CTX_create();
     702
     703            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
     704            EVP_DigestUpdate(ctx, ireq.u.digestRequest.username,
    699705                       strlen(ireq.u.digestRequest.username));
    700             MD5_Update(&ctx, ":", 1);
    701             MD5_Update(&ctx, *ireq.u.digestRequest.realm,
     706            EVP_DigestUpdate(ctx, ":", 1);
     707            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.realm,
    702708                       strlen(*ireq.u.digestRequest.realm));
    703             MD5_Update(&ctx, ":", 1);
    704             MD5_Update(&ctx, password, strlen(password));
    705             MD5_Final(md, &ctx);
    706        
    707             MD5_Init(&ctx);
    708             MD5_Update(&ctx, md, sizeof(md));
    709             MD5_Update(&ctx, ":", 1);
    710             MD5_Update(&ctx, ireq.u.digestRequest.serverNonce,
     709            EVP_DigestUpdate(ctx, ":", 1);
     710            EVP_DigestUpdate(ctx, password, strlen(password));
     711            EVP_DigestFinal_ex(ctx, md, NULL);
     712       
     713            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
     714            EVP_DigestUpdate(ctx, md, sizeof(md));
     715            EVP_DigestUpdate(ctx, ":", 1);
     716            EVP_DigestUpdate(ctx, ireq.u.digestRequest.serverNonce,
    711717                       strlen(ireq.u.digestRequest.serverNonce));
    712             MD5_Update(&ctx, ":", 1);
    713             MD5_Update(&ctx, *ireq.u.digestRequest.nonceCount,
     718            EVP_DigestUpdate(ctx, ":", 1);
     719            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.nonceCount,
    714720                       strlen(*ireq.u.digestRequest.nonceCount));
    715721            if (ireq.u.digestRequest.authid) {
    716                 MD5_Update(&ctx, ":", 1);
    717                 MD5_Update(&ctx, *ireq.u.digestRequest.authid,
     722                EVP_DigestUpdate(ctx, ":", 1);
     723                EVP_DigestUpdate(ctx, *ireq.u.digestRequest.authid,
    718724                           strlen(*ireq.u.digestRequest.authid));
    719725            }
    720             MD5_Final(md, &ctx);
     726            EVP_DigestFinal_ex(ctx, md, NULL);
    721727            hex_encode(md, sizeof(md), &A1);
    722728            if (A1 == NULL) {
    723729                ret = ENOMEM;
    724730                krb5_set_error_message(context, ret, "malloc: out of memory");
     731                EVP_MD_CTX_destroy(ctx);
    725732                goto failed;
    726733            }
    727734       
    728             MD5_Init(&ctx);
    729             MD5_Update(&ctx, "AUTHENTICATE:", sizeof("AUTHENTICATE:") - 1);
    730             MD5_Update(&ctx, *ireq.u.digestRequest.uri,
     735            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
     736            EVP_DigestUpdate(ctx,
     737                             "AUTHENTICATE:", sizeof("AUTHENTICATE:") - 1);
     738            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.uri,
    731739                       strlen(*ireq.u.digestRequest.uri));
    732740       
    … …  
    734742            if (strcmp(ireq.u.digestRequest.digest, "clear") != 0) {
    735743                static char conf_zeros[] = ":00000000000000000000000000000000";
    736                 MD5_Update(&ctx, conf_zeros, sizeof(conf_zeros) - 1);
    737             }
    738        
    739             MD5_Final(md, &ctx);
     744                EVP_DigestUpdate(ctx, conf_zeros, sizeof(conf_zeros) - 1);
     745            }
     746       
     747            EVP_DigestFinal_ex(ctx, md, NULL);
     748
    740749            hex_encode(md, sizeof(md), &A2);
    741750            if (A2 == NULL) {
    … …  
    746755            }
    747756
    748             MD5_Init(&ctx);
    749             MD5_Update(&ctx, A1, strlen(A2));
    750             MD5_Update(&ctx, ":", 1);
    751             MD5_Update(&ctx, ireq.u.digestRequest.serverNonce,
     757            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
     758            EVP_DigestUpdate(ctx, A1, strlen(A2));
     759            EVP_DigestUpdate(ctx, ":", 1);
     760            EVP_DigestUpdate(ctx, ireq.u.digestRequest.serverNonce,
    752761                       strlen(ireq.u.digestRequest.serverNonce));
    753             MD5_Update(&ctx, ":", 1);
    754             MD5_Update(&ctx, *ireq.u.digestRequest.nonceCount,
     762            EVP_DigestUpdate(ctx, ":", 1);
     763            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.nonceCount,
    755764                       strlen(*ireq.u.digestRequest.nonceCount));
    756             MD5_Update(&ctx, ":", 1);
    757             MD5_Update(&ctx, *ireq.u.digestRequest.clientNonce,
     765            EVP_DigestUpdate(ctx, ":", 1);
     766            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.clientNonce,
    758767                       strlen(*ireq.u.digestRequest.clientNonce));
    759             MD5_Update(&ctx, ":", 1);
    760             MD5_Update(&ctx, *ireq.u.digestRequest.qop,
     768            EVP_DigestUpdate(ctx, ":", 1);
     769            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.qop,
    761770                       strlen(*ireq.u.digestRequest.qop));
    762             MD5_Update(&ctx, ":", 1);
    763             MD5_Update(&ctx, A2, strlen(A2));
    764 
    765             MD5_Final(md, &ctx);
     771            EVP_DigestUpdate(ctx, ":", 1);
     772            EVP_DigestUpdate(ctx, A2, strlen(A2));
     773
     774            EVP_DigestFinal_ex(ctx, md, NULL);
     775
     776            EVP_MD_CTX_destroy(ctx);
    766777
    767778            free(A1);
    … …  
    794805            struct ntlm_buf answer;
    795806            Key *key = NULL;
    796             SHA_CTX ctx;
     807            EVP_MD_CTX *ctx;
    797808
    798809            if ((config->digests_allowed & MS_CHAP_V2) == 0) {
    … …  
    821832                username++;
    822833
     834            ctx = EVP_MD_CTX_create();
     835
    823836            /* ChallangeHash */
    824             SHA1_Init(&ctx);
     837            EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);
    825838            {
    826839                ssize_t ssize;
    … …  
    831844                if (clientNonce.data == NULL) {
    832845                    ret = ENOMEM;
    833                     krb5_set_error_message(context, ret, "malloc: out of memory");
     846                    krb5_set_error_message(context, ret,
     847                                           "malloc: out of memory");
     848                    EVP_MD_CTX_destroy(ctx);
    834849                    goto out;
    835850                }
    … …  
    841856                    krb5_set_error_message(context, ret,
    842857                                           "Failed to decode clientNonce");
     858                    EVP_MD_CTX_destroy(ctx);
    843859                    goto out;
    844860                }
    845                 SHA1_Update(&ctx, clientNonce.data, ssize);
     861                EVP_DigestUpdate(ctx, clientNonce.data, ssize);
    846862                free(clientNonce.data);
    847863            }
    848             SHA1_Update(&ctx, serverNonce.data, serverNonce.length);
    849             SHA1_Update(&ctx, username, strlen(username));
    850             SHA1_Final(challange, &ctx);
     864            EVP_DigestUpdate(ctx, serverNonce.data, serverNonce.length);
     865            EVP_DigestUpdate(ctx, username, strlen(username));
     866
     867            EVP_DigestFinal_ex(ctx, challange, NULL);
     868
     869            EVP_MD_CTX_destroy(ctx);
    851870
    852871            /* NtPasswordHash */
    … …  
    856875       
    857876            ret = _kdc_db_fetch(context, config, clientprincipal,
    858                                 HDB_F_GET_CLIENT, NULL, &user);
     877                                HDB_F_GET_CLIENT, NULL, NULL, &user);
    859878            krb5_free_principal(context, clientprincipal);
    860879            if (ret) {
    … …  
    905924            if (r.u.response.success) {
    906925                unsigned char hashhash[MD4_DIGEST_LENGTH];
     926                EVP_MD_CTX *ctx;
     927
     928                ctx = EVP_MD_CTX_create();
    907929
    908930                /* hashhash */
    909931                {
    910                     MD4_CTX hctx;
    911 
    912                     MD4_Init(&hctx);
    913                     MD4_Update(&hctx, key->key.keyvalue.data,
    914                                key->key.keyvalue.length);
    915                     MD4_Final(hashhash, &hctx);
     932                    EVP_DigestInit_ex(ctx, EVP_md4(), NULL);
     933                    EVP_DigestUpdate(ctx,
     934                                     key->key.keyvalue.data,
     935                                     key->key.keyvalue.length);
     936                    EVP_DigestFinal_ex(ctx, hashhash, NULL);
    916937                }
    917938
    918939                /* GenerateAuthenticatorResponse */
    919                 SHA1_Init(&ctx);
    920                 SHA1_Update(&ctx, hashhash, sizeof(hashhash));
    921                 SHA1_Update(&ctx, answer.data, answer.length);
    922                 SHA1_Update(&ctx, ms_chap_v2_magic1,sizeof(ms_chap_v2_magic1));
    923                 SHA1_Final(md, &ctx);
    924 
    925                 SHA1_Init(&ctx);
    926                 SHA1_Update(&ctx, md, sizeof(md));
    927                 SHA1_Update(&ctx, challange, 8);
    928                 SHA1_Update(&ctx, ms_chap_v2_magic2, sizeof(ms_chap_v2_magic2));
    929                 SHA1_Final(md, &ctx);
     940                EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);
     941                EVP_DigestUpdate(ctx, hashhash, sizeof(hashhash));
     942                EVP_DigestUpdate(ctx, answer.data, answer.length);
     943                EVP_DigestUpdate(ctx, ms_chap_v2_magic1,
     944                                 sizeof(ms_chap_v2_magic1));
     945                EVP_DigestFinal_ex(ctx, md, NULL);
     946
     947                EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);
     948                EVP_DigestUpdate(ctx, md, sizeof(md));
     949                EVP_DigestUpdate(ctx, challange, 8);
     950                EVP_DigestUpdate(ctx, ms_chap_v2_magic2,
     951                                 sizeof(ms_chap_v2_magic2));
     952                EVP_DigestFinal_ex(ctx, md, NULL);
    930953
    931954                r.u.response.rsp = calloc(1, sizeof(*r.u.response.rsp));
    … …  
    933956                    free(answer.data);
    934957                    krb5_clear_error_message(context);
     958                    EVP_MD_CTX_destroy(ctx);
    935959                    ret = ENOMEM;
    936960                    goto out;
    … …  
    941965                    free(answer.data);
    942966                    krb5_clear_error_message(context);
     967                    EVP_MD_CTX_destroy(ctx);
    943968                    ret = ENOMEM;
    944969                    goto out;
    … …  
    946971
    947972                /* get_master, rfc 3079 3.4 */
    948                 SHA1_Init(&ctx);
    949                 SHA1_Update(&ctx, hashhash, 16); /* md4(hash) */
    950                 SHA1_Update(&ctx, answer.data, answer.length);
    951                 SHA1_Update(&ctx, ms_rfc3079_magic1, sizeof(ms_rfc3079_magic1));
    952                 SHA1_Final(md, &ctx);
     973                EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);
     974                EVP_DigestUpdate(ctx, hashhash, 16);
     975                EVP_DigestUpdate(ctx, answer.data, answer.length);
     976                EVP_DigestUpdate(ctx, ms_rfc3079_magic1,
     977                                 sizeof(ms_rfc3079_magic1));
     978                EVP_DigestFinal_ex(ctx, md, NULL);
    953979
    954980                free(answer.data);
     981
     982                EVP_MD_CTX_destroy(ctx);
    955983
    956984                r.u.response.session_key =
    … …  
    11311159
    11321160        ret = _kdc_db_fetch(context, config, clientprincipal,
    1133                             HDB_F_GET_CLIENT, NULL, &user);
     1161                            HDB_F_GET_CLIENT, NULL, NULL, &user);
    11341162        krb5_free_principal(context, clientprincipal);
    11351163        if (ret) {
    … …  
    12381266            if (flags & NTLM_NEG_NTLM2_SESSION) {
    12391267                unsigned char sessionhash[MD5_DIGEST_LENGTH];
    1240                 MD5_CTX md5ctx;
     1268                EVP_MD_CTX *ctx;
    12411269               
    12421270                if ((config->digests_allowed & NTLM_V1_SESSION) == 0) {
    … …  
    12531281                }
    12541282               
    1255                 MD5_Init(&md5ctx);
    1256                 MD5_Update(&md5ctx, challange, sizeof(challange));
    1257                 MD5_Update(&md5ctx, ireq.u.ntlmRequest.lm.data, 8);
    1258                 MD5_Final(sessionhash, &md5ctx);
     1283                ctx = EVP_MD_CTX_create();
     1284
     1285                EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
     1286
     1287                EVP_DigestUpdate(ctx, challange, sizeof(challange));
     1288                EVP_DigestUpdate(ctx, ireq.u.ntlmRequest.lm.data, 8);
     1289                EVP_DigestFinal_ex(ctx, sessionhash, NULL);
    12591290                memcpy(challange, sessionhash, sizeof(challange));
     1291
     1292                EVP_MD_CTX_destroy(ctx);
     1293
    12601294            } else {
    12611295                if ((config->digests_allowed & NTLM_V1) == 0) {
    … …  
    12841318
    12851319            {
    1286                 MD4_CTX ctx;
    1287 
    1288                 MD4_Init(&ctx);
    1289                 MD4_Update(&ctx,
    1290                            key->key.keyvalue.data, key->key.keyvalue.length);
    1291                 MD4_Final(sessionkey, &ctx);
     1320                EVP_MD_CTX *ctx;
     1321
     1322                ctx = EVP_MD_CTX_create();
     1323
     1324                EVP_DigestInit_ex(ctx, EVP_md4(), NULL);
     1325                EVP_DigestUpdate(ctx,
     1326                                 key->key.keyvalue.data,
     1327                                 key->key.keyvalue.length);
     1328                EVP_DigestFinal_ex(ctx, sessionkey, NULL);
     1329
     1330                EVP_MD_CTX_destroy(ctx);
    12921331            }
    12931332        }
    … …  
    12951334        if (ireq.u.ntlmRequest.sessionkey) {
    12961335            unsigned char masterkey[MD4_DIGEST_LENGTH];
    1297             RC4_KEY rc4;
     1336            EVP_CIPHER_CTX rc4;
    12981337            size_t len;
    12991338       
    … …  
    13151354            }
    13161355       
    1317             RC4_set_key(&rc4, sizeof(sessionkey), sessionkey);
    1318        
    1319             RC4(&rc4, sizeof(masterkey),
    1320                 ireq.u.ntlmRequest.sessionkey->data,
    1321                 masterkey);
    1322             memset(&rc4, 0, sizeof(rc4));
     1356
     1357            EVP_CIPHER_CTX_init(&rc4);
     1358            EVP_CipherInit_ex(&rc4, EVP_rc4(), NULL, sessionkey, NULL, 1);
     1359            EVP_Cipher(&rc4,
     1360                       masterkey, ireq.u.ntlmRequest.sessionkey->data,
     1361                       sizeof(masterkey));
     1362            EVP_CIPHER_CTX_cleanup(&rc4);
    13231363       
    13241364            r.u.ntlmResponse.sessionkey =

  • trunk/server/source4/heimdal/kdc/headers.h

    r414 r745  
    3939#define __HEADERS_H__
    4040
    41 #ifdef HAVE_CONFIG_H
    4241#include <config.h>
    43 #endif
     42
    4443#include <limits.h>
    4544#include <stdio.h>
    … …  
    109108
    110109#undef ALLOC
    111 #define ALLOC(X) ((X) = malloc(sizeof(*(X))))
     110#define ALLOC(X) ((X) = calloc(1, sizeof(*(X))))
    112111#undef ALLOC_SEQ
    113112#define ALLOC_SEQ(X, N) do { (X)->len = (N); \

  • trunk/server/source4/heimdal/kdc/kdc.h

    r414 r745  
    4242#define __KDC_H__
    4343
     44#include <hdb.h>
    4445#include <krb5.h>
    4546
    … …  
    7576    krb5_boolean enable_pkinit;
    7677    krb5_boolean pkinit_princ_in_cert;
    77     char *pkinit_kdc_ocsp_file;
    78     char *pkinit_kdc_friendly_name;
     78    const char *pkinit_kdc_identity;
     79    const char *pkinit_kdc_anchors;
     80    const char *pkinit_kdc_friendly_name;
     81    const char *pkinit_kdc_ocsp_file;
     82    char **pkinit_kdc_cert_pool;
     83    char **pkinit_kdc_revoke;
    7984    int pkinit_dh_min_bits;
    8085    int pkinit_require_binding;

  • trunk/server/source4/heimdal/kdc/kdc_locl.h

    r414 r745  
    4747
    4848extern sig_atomic_t exit_flag;
    49 extern size_t max_request;
     49extern size_t max_request_udp;
     50extern size_t max_request_tcp;
    5051extern const char *request_log;
    5152extern const char *port_str;
    … …  
    7778configure(krb5_context context, int argc, char **argv);
    7879
     80#ifdef __APPLE__
     81void bonjour_announce(krb5_context, krb5_kdc_configuration *);
     82#endif
     83
    7984#endif /* __KDC_LOCL_H__ */

  • trunk/server/source4/heimdal/kdc/kerberos5.c

    r414 r745  
    3434#include "kdc_locl.h"
    3535
    36 RCSID("$Id$");
    37 
    3836#define MAX_TIME ((time_t)((1U << 31) - 1))
    3937
    … …  
    6159
    6260static void
    63 set_salt_padata (METHOD_DATA *md, Salt *salt)
     61set_salt_padata(METHOD_DATA *md, Salt *salt)
    6462{
    6563    if (salt) {
    66         realloc_method_data(md);
    67         md->val[md->len - 1].padata_type = salt->type;
    68         der_copy_octet_string(&salt->salt,
    69                               &md->val[md->len - 1].padata_value);
     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);
    7068    }
    7169}
    … …  
    128126_kdc_find_etype(krb5_context context, const hdb_entry_ex *princ,
    129127                krb5_enctype *etypes, unsigned len,
    130                 Key **ret_key, krb5_enctype *ret_etype)
     128                Key **ret_key)
    131129{
    132130    int i;
    … …  
    149147            }
    150148            *ret_key   = key;
    151             *ret_etype = etypes[i];
    152149            ret = 0;
    153150            if (is_default_salt_p(&def_salt, key)) {
    … …  
    262259                  int skvno, const EncryptionKey *skey,
    263260                  int ckvno, const EncryptionKey *reply_key,
     261                  int rk_is_subkey,
    264262                  const char **e_text,
    265263                  krb5_data *reply)
    … …  
    273271    ASN1_MALLOC_ENCODE(EncTicketPart, buf, buf_size, et, &len, ret);
    274272    if(ret) {
    275         kdc_log(context, config, 0, "Failed to encode ticket: %s",
    276                 krb5_get_err_text(context, ret));
     273        const char *msg = krb5_get_error_message(context, ret);
     274        kdc_log(context, config, 0, "Failed to encode ticket: %s", msg);
     275        krb5_free_error_message(context, msg);
    277276        return ret;
    278277    }
    … …  
    286285    ret = krb5_crypto_init(context, skey, etype, &crypto);
    287286    if (ret) {
     287        const char *msg;
    288288        free(buf);
    289         kdc_log(context, config, 0, "krb5_crypto_init failed: %s",
    290                 krb5_get_err_text(context, ret));
     289        msg = krb5_get_error_message(context, ret);
     290        kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
     291        krb5_free_error_message(context, msg);
    291292        return ret;
    292293    }
    … …  
    302303    krb5_crypto_destroy(context, crypto);
    303304    if(ret) {
    304         kdc_log(context, config, 0, "Failed to encrypt data: %s",
    305                 krb5_get_err_text(context, ret));
     305        const char *msg = krb5_get_error_message(context, ret);
     306        kdc_log(context, config, 0, "Failed to encrypt data: %s", msg);
     307        krb5_free_error_message(context, msg);
    306308        return ret;
    307309    }
    … …  
    312314        ASN1_MALLOC_ENCODE(EncTGSRepPart, buf, buf_size, ek, &len, ret);
    313315    if(ret) {
    314         kdc_log(context, config, 0, "Failed to encode KDC-REP: %s",
    315                 krb5_get_err_text(context, ret));
     316        const char *msg = krb5_get_error_message(context, ret);
     317        kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
     318        krb5_free_error_message(context, msg);
    316319        return ret;
    317320    }
    … …  
    324327    ret = krb5_crypto_init(context, reply_key, 0, &crypto);
    325328    if (ret) {
     329        const char *msg = krb5_get_error_message(context, ret);
    326330        free(buf);
    327         kdc_log(context, config, 0, "krb5_crypto_init failed: %s",
    328                 krb5_get_err_text(context, ret));
     331        kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
     332        krb5_free_error_message(context, msg);
    329333        return ret;
    330334    }
    … …  
    342346        krb5_encrypt_EncryptedData(context,
    343347                                   crypto,
    344                                    KRB5_KU_TGS_REP_ENC_PART_SESSION,
     348                                   rk_is_subkey ? KRB5_KU_TGS_REP_ENC_PART_SUB_KEY : KRB5_KU_TGS_REP_ENC_PART_SESSION,
    345349                                   buf,
    346350                                   len,
    … …  
    352356    krb5_crypto_destroy(context, crypto);
    353357    if(ret) {
    354         kdc_log(context, config, 0, "Failed to encode KDC-REP: %s",
    355                 krb5_get_err_text(context, ret));
     358        const char *msg = krb5_get_error_message(context, ret);
     359        kdc_log(context, config, 0, "Failed to encode KDC-REP: %s", msg);
     360        krb5_free_error_message(context, msg);
    356361        return ret;
    357362    }
    … …  
    896901    hdb_entry_ex *client = NULL, *server = NULL;
    897902    HDB *clientdb;
    898     krb5_enctype cetype, setype, sessionetype;
     903    krb5_enctype setype, sessionetype;
    899904    krb5_data e_data;
    900905    EncTicketPart et;
    … …  
    906911    krb5_crypto crypto;
    907912    Key *ckey, *skey;
    908     EncryptionKey *reply_key;
     913    EncryptionKey *reply_key = NULL, session_key;
    909914    int flags = 0;
    910915#ifdef PKINIT
    … …  
    913918
    914919    memset(&rep, 0, sizeof(rep));
     920    memset(&session_key, 0, sizeof(session_key));
    915921    krb5_data_zero(&e_data);
     922
     923    ALLOC(rep.padata);
     924    rep.padata->len = 0;
     925    rep.padata->val = NULL;
    916926
    917927    if (f.canonicalize)
    … …  
    979989
    980990    ret = _kdc_db_fetch(context, config, client_princ,
    981                         HDB_F_GET_CLIENT | flags, &clientdb, &client);
    982     if(ret){
    983         kdc_log(context, config, 0, "UNKNOWN -- %s: %s", client_name,
    984                 krb5_get_err_text(context, ret));
     991                        HDB_F_GET_CLIENT | flags, NULL,
     992                        &clientdb, &client);
     993    if(ret == HDB_ERR_NOT_FOUND_HERE) {
     994        kdc_log(context, config, 5, "client %s does not have secrets at this KDC, need to proxy", client_name);
     995        goto out;
     996    } else if(ret){
     997        const char *msg = krb5_get_error_message(context, ret);
     998        kdc_log(context, config, 0, "UNKNOWN -- %s: %s", client_name, msg);
     999        krb5_free_error_message(context, msg);
    9851000        ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
    9861001        goto out;
    9871002    }
    988 
    9891003    ret = _kdc_db_fetch(context, config, server_princ,
    990                         HDB_F_GET_SERVER|HDB_F_GET_KRBTGT,
    991                         NULL, &server);
    992     if(ret){
    993         kdc_log(context, config, 0, "UNKNOWN -- %s: %s", server_name,
    994                 krb5_get_err_text(context, ret));
     1004                        HDB_F_GET_SERVER|HDB_F_GET_KRBTGT | flags,
     1005                        NULL, NULL, &server);
     1006    if(ret == HDB_ERR_NOT_FOUND_HERE) {
     1007        kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", server_name);
     1008        goto out;
     1009    } else if(ret){
     1010        const char *msg = krb5_get_error_message(context, ret);
     1011        kdc_log(context, config, 0, "UNKNOWN -- %s: %s", server_name, msg);
     1012        krb5_free_error_message(context, msg);
    9951013        ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
    9961014        goto out;
    … …  
    10011019
    10021020    /*
    1003      * Find the client key for reply encryption and pa-type salt, Pick
    1004      * the client key upfront before the other keys because that is
    1005      * going to affect what enctypes we are going to use in
    1006      * ETYPE-INFO{,2}.
     1021     * Select a session enctype from the list of the crypto systems
     1022     * supported enctype, is supported by the client and is one of the
     1023     * enctype of the enctype of the krbtgt.
     1024     *
     1025     * The later is used as a hint what enctype all KDC are supporting
     1026     * to make sure a newer version of KDC wont generate a session
     1027     * enctype that and older version of a KDC in the same realm can't
     1028     * decrypt.
     1029     *
     1030     * But if the KDC admin is paranoid and doesn't want to have "no
     1031     * the best" enctypes on the krbtgt, lets save the best pick from
     1032     * the client list and hope that that will work for any other
     1033     * KDCs.
    10071034     */
    1008 
    1009     ret = _kdc_find_etype(context, client, b->etype.val, b->etype.len,
    1010                           &ckey, &cetype);
    1011     if (ret) {
    1012         kdc_log(context, config, 0,
    1013                 "Client (%s) has no support for etypes", client_name);
    1014         goto out;
     1035    {
     1036        const krb5_enctype *p;
     1037        krb5_enctype clientbest = ETYPE_NULL;
     1038        int i, j;
     1039
     1040        p = krb5_kerberos_enctypes(context);
     1041
     1042        sessionetype = ETYPE_NULL;
     1043
     1044        for (i = 0; p[i] != ETYPE_NULL && sessionetype == ETYPE_NULL; i++) {
     1045            if (krb5_enctype_valid(context, p[i]) != 0)
     1046                continue;
     1047
     1048            for (j = 0; j < b->etype.len && sessionetype == ETYPE_NULL; j++) {
     1049                Key *dummy;
     1050                /* check with client */
     1051                if (p[i] != b->etype.val[j])
     1052                    continue;
     1053                /* save best of union of { client, crypto system } */
     1054                if (clientbest == ETYPE_NULL)
     1055                    clientbest = p[i];
     1056                /* check with krbtgt */
     1057                ret = hdb_enctype2key(context, &server->entry, p[i], &dummy);
     1058                if (ret)
     1059                    continue;
     1060                sessionetype = p[i];
     1061            }
     1062        }
     1063        /* if krbtgt had no shared keys with client, pick clients best */
     1064        if (clientbest != ETYPE_NULL && sessionetype == ETYPE_NULL) {
     1065            sessionetype = clientbest;
     1066        } else if (sessionetype == ETYPE_NULL) {
     1067            kdc_log(context, config, 0,
     1068                    "Client (%s) from %s has no common enctypes with KDC"
     1069                    "to use for the session key",
     1070                    client_name, from);
     1071            goto out;
     1072        }
    10151073    }
    10161074
    … …  
    11361194            ret = krb5_crypto_init(context, &pa_key->key, 0, &crypto);
    11371195            if (ret) {
    1138                 kdc_log(context, config, 0, "krb5_crypto_init failed: %s",
    1139                         krb5_get_err_text(context, ret));
     1196                const char *msg = krb5_get_error_message(context, ret);
     1197                kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
     1198                krb5_free_error_message(context, msg);
    11401199                free_EncryptedData(&enc_data);
    11411200                continue;
    … …  
    11551214            if(ret){
    11561215                krb5_error_code ret2;
     1216                const char *msg = krb5_get_error_message(context, ret);
     1217
    11571218                ret2 = krb5_enctype_to_string(context,
    11581219                                              pa_key->key.keytype, &str);
    … …  
    11621223                        "Failed to decrypt PA-DATA -- %s "
    11631224                        "(enctype %s) error %s",
    1164                         client_name,
    1165                         str ? str : "unknown enctype",
    1166                         krb5_get_err_text(context, ret));
     1225                        client_name, str ? str : "unknown enctype", msg);
     1226                krb5_free_error_message(context, msg);
    11671227                free(str);
    11681228
    … …  
    12201280            et.flags.pre_authent = 1;
    12211281
    1222             ret = krb5_enctype_to_string(context,pa_key->key.keytype, &str);
     1282            set_salt_padata(rep.padata, pa_key->salt);
     1283
     1284            reply_key = &pa_key->key;
     1285
     1286            ret = krb5_enctype_to_string(context, pa_key->key.keytype, &str);
    12231287            if (ret)
    12241288                str = NULL;
    … …  
    12901354         * If there is a client key, send ETYPE_INFO{,2}
    12911355         */
    1292         if (ckey) {
     1356        ret = _kdc_find_etype(context, client, b->etype.val, b->etype.len,
     1357                              &ckey);
     1358        if (ret == 0) {
    12931359
    12941360            /*
    … …  
    13611427        goto out;
    13621428
    1363     /*
    1364      * Select a session enctype from the list of the crypto systems
    1365      * supported enctype, is supported by the client and is one of the
    1366      * enctype of the enctype of the krbtgt.
    1367      *
    1368      * The later is used as a hint what enctype all KDC are supporting
    1369      * to make sure a newer version of KDC wont generate a session
    1370      * enctype that and older version of a KDC in the same realm can't
    1371      * decrypt.
    1372      *
    1373      * But if the KDC admin is paranoid and doesn't want to have "no
    1374      * the best" enctypes on the krbtgt, lets save the best pick from
    1375      * the client list and hope that that will work for any other
    1376      * KDCs.
    1377      */
    1378     {
    1379         const krb5_enctype *p;
    1380         krb5_enctype clientbest = ETYPE_NULL;
    1381         int i, j;
    1382 
    1383         p = krb5_kerberos_enctypes(context);
    1384 
    1385         sessionetype = ETYPE_NULL;
    1386 
    1387         for (i = 0; p[i] != ETYPE_NULL && sessionetype == ETYPE_NULL; i++) {
    1388             if (krb5_enctype_valid(context, p[i]) != 0)
    1389                 continue;
    1390 
    1391             for (j = 0; j < b->etype.len && sessionetype == ETYPE_NULL; j++) {
    1392                 Key *dummy;
    1393                 /* check with client */
    1394                 if (p[i] != b->etype.val[j])
    1395                     continue;
    1396                 /* save best of union of { client, crypto system } */
    1397                 if (clientbest == ETYPE_NULL)
    1398                     clientbest = p[i];
    1399                 /* check with krbtgt */
    1400                 ret = hdb_enctype2key(context, &server->entry, p[i], &dummy);
    1401                 if (ret)
    1402                     continue;
    1403                 sessionetype = p[i];
    1404             }
    1405         }
    1406         /* if krbtgt had no shared keys with client, pick clients best */
    1407         if (clientbest != ETYPE_NULL && sessionetype == ETYPE_NULL) {
    1408             sessionetype = clientbest;
    1409         } else if (sessionetype == ETYPE_NULL) {
    1410             kdc_log(context, config, 0,
    1411                     "Client (%s) from %s has no common enctypes with KDC"
    1412                     "to use for the session key",
    1413                     client_name, from);
    1414             goto out;
    1415         }
    1416     }
    1417 
    1418     log_as_req(context, config, cetype, setype, b);
    1419 
    14201429    if(f.renew || f.validate || f.proxy || f.forwarded || f.enc_tkt_in_skey
    14211430       || (f.request_anonymous && !config->allow_anonymous)) {
    14221431        ret = KRB5KDC_ERR_BADOPTION;
     1432        e_text = "Bad KDC options";
    14231433        kdc_log(context, config, 0, "Bad KDC options -- %s", client_name);
    14241434        goto out;
    … …  
    14501460        et.flags.forwardable = f.forwardable;
    14511461    else if (f.forwardable) {
     1462        e_text = "Ticket may not be forwardable";
    14521463        ret = KRB5KDC_ERR_POLICY;
    14531464        kdc_log(context, config, 0,
    … …  
    14581469        et.flags.proxiable = f.proxiable;
    14591470    else if (f.proxiable) {
     1471        e_text = "Ticket may not be proxiable";
    14601472        ret = KRB5KDC_ERR_POLICY;
    14611473        kdc_log(context, config, 0,
    … …  
    14661478        et.flags.may_postdate = f.allow_postdate;
    14671479    else if (f.allow_postdate){
     1480        e_text = "Ticket may not be postdate";
    14681481        ret = KRB5KDC_ERR_POLICY;
    14691482        kdc_log(context, config, 0,
    … …  
    14741487    /* check for valid set of addresses */
    14751488    if(!_kdc_check_addresses(context, config, b->addresses, from_addr)) {
     1489        e_text = "Bad address list in requested";
    14761490        ret = KRB5KRB_AP_ERR_BADADDR;
    14771491        kdc_log(context, config, 0,
    … …  
    16121626    }
    16131627
    1614     ALLOC(rep.padata);
    1615     rep.padata->len = 0;
    1616     rep.padata->val = NULL;
    1617 
    16181628#if PKINIT
    16191629    if (pkp) {
    … …  
    16301640        if (ret)
    16311641            goto out;
     1642
    16321643    } else
    16331644#endif
    1634     if (ckey) {
    1635         reply_key = &ckey->key;
     1645    {
    16361646        ret = krb5_generate_random_keyblock(context, sessionetype, &et.key);
    16371647        if (ret)
    16381648            goto out;
    1639     } else {
     1649    }
     1650
     1651    if (reply_key == NULL) {
    16401652        e_text = "Client have no reply key";
    16411653        ret = KRB5KDC_ERR_CLIENT_NOTYET;
    … …  
    16461658    if (ret)
    16471659        goto out;
    1648 
    1649     if (ckey)
    1650         set_salt_padata (rep.padata, ckey->salt);
    16511660
    16521661    /* Add signing of alias referral */
    … …  
    17481757                                  server,
    17491758                                  setype,
     1759                                  client->entry.principal,
    17501760                                  NULL,
    17511761                                  NULL,
    … …  
    17541764        goto out;
    17551765
     1766    log_as_req(context, config, reply_key->keytype, setype, b);
     1767
    17561768    ret = _kdc_encode_reply(context, config,
    17571769                            &rep, &et, &ek, setype, server->entry.kvno,
    17581770                            &skey->key, client->entry.kvno,
    1759                             reply_key, &e_text, reply);
     1771                            reply_key, 0, &e_text, reply);
    17601772    free_EncTicketPart(&et);
    17611773    free_EncKDCRepPart(&ek);
    … …  
    17721784out:
    17731785    free_AS_REP(&rep);
    1774     if(ret){
     1786    if(ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE){
    17751787        krb5_mk_error(context,
    17761788                      ret,

  • trunk/server/source4/heimdal/kdc/krb5tgs.c

    r414 r745  
    3434#include "kdc_locl.h"
    3535
    36 RCSID("$Id$");
    37 
    3836/*
    3937 * return the realm of a krbtgt-ticket or NULL
    … …  
    107105                        hdb_entry_ex *krbtgt,
    108106                        krb5_enctype enctype,
     107                        krb5_principal client,
    109108                        krb5_const_principal server,
    110109                        krb5_principals principals,
    … …  
    126125        KRB5SignedPathData spd;
    127126       
    128         spd.encticket = *tkt;
     127        spd.client = client;
     128        spd.authtime = tkt->authtime;
    129129        spd.delegated = principals;
     130        spd.method_data = NULL;
    130131       
    131132        ASN1_MALLOC_ENCODE(KRB5SignedPathData, data.data, data.length,
    … …  
    154155    sp.etype = enctype;
    155156    sp.delegated = principals;
     157    sp.method_data = NULL;
    156158
    157159    ret = krb5_create_checksum(context, crypto, KRB5_KU_KRB5SIGNEDPATH, 0,
    … …  
    186188                     krb5_kdc_configuration *config,
    187189                     hdb_entry_ex *krbtgt,
     190                     krb5_principal cp,
    188191                     EncTicketPart *tkt,
    189192                     krb5_principals *delegated,
    … …  
    201204        KRB5SignedPathData spd;
    202205        KRB5SignedPath sp;
    203         AuthorizationData *ad;
    204206        size_t size;
    205207
    … …  
    209211            return ret;
    210212
    211         spd.encticket = *tkt;
    212         /* the KRB5SignedPath is the last entry */
    213         ad = spd.encticket.authorization_data;
    214         if (--ad->len == 0)
    215             spd.encticket.authorization_data = NULL;
     213        spd.client = cp;
     214        spd.authtime = tkt->authtime;
    216215        spd.delegated = sp.delegated;
     216        spd.method_data = sp.method_data;
    217217
    218218        ASN1_MALLOC_ENCODE(KRB5SignedPathData, data.data, data.length,
    219219                           &spd, &size, ret);
    220         ad->len++;
    221         spd.encticket.authorization_data = ad;
    222220        if (ret) {
    223221            free_KRB5SignedPath(&sp);
    … …  
    245243        if (ret) {
    246244            free_KRB5SignedPath(&sp);
    247             return ret;
     245            kdc_log(context, config, 5,
     246                    "KRB5SignedPath not signed correctly, not marking as signed");
     247            return 0;
    248248        }
    249249
    … …  
    282282          hdb_entry_ex *client,
    283283          hdb_entry_ex *server,
     284          hdb_entry_ex *krbtgt,
    284285          const EncryptionKey *server_key,
    285           const EncryptionKey *krbtgt_key,
     286          const EncryptionKey *krbtgt_check_key,
     287          const EncryptionKey *krbtgt_sign_key,
    286288          EncTicketPart *tkt,
    287289          krb5_data *rspac,
    … …  
    313315
    314316            if (child.val[j].ad_type == KRB5_AUTHDATA_WIN2K_PAC) {
     317                int signed_pac = 0;
    315318                krb5_pac pac;
    316319
    … …  
    326329                ret = krb5_pac_verify(context, pac, tkt->authtime,
    327330                                      client_principal,
    328                                       krbtgt_key, NULL);
     331                                      krbtgt_check_key, NULL);
    329332                if (ret) {
    330333                    krb5_pac_free(context, pac);
    … …  
    333336
    334337                ret = _kdc_pac_verify(context, client_principal,
    335                                       client, server, &pac);
     338                                      client, server, krbtgt, &pac, &signed_pac);
    336339                if (ret) {
    337340                    krb5_pac_free(context, pac);
    338341                    return ret;
    339342                }
    340                 *signedpath = 1;
    341 
    342                 ret = _krb5_pac_sign(context, pac, tkt->authtime,
    343                                      client_principal,
    344                                      server_key, krbtgt_key, rspac);
    345 
     343
     344                /*
     345                 * Only re-sign PAC if we could verify it with the PAC
     346                 * function. The no-verify case happens when we get in
     347                 * a PAC from cross realm from a Windows domain and
     348                 * that there is no PAC verification function.
     349                 */
     350                if (signed_pac) {
     351                    *signedpath = 1;
     352                    ret = _krb5_pac_sign(context, pac, tkt->authtime,
     353                                         client_principal,
     354                                         server_key, krbtgt_sign_key, rspac);
     355                }
    346356                krb5_pac_free(context, pac);
    347 
     357               
    348358                return ret;
    349359            }
    … …  
    448458
    449459    if(f.renewable){
    450         if(!tgt->flags.renewable){
     460        if(!tgt->flags.renewable || tgt->renew_till == NULL){
    451461            kdc_log(context, config, 0,
    452462                    "Bad request for renewable ticket");
    … …  
    487497
    488498/*
    489  *
     499 * Determine if constrained delegation is allowed from this client to this server
    490500 */
    491501
    … …  
    526536    kdc_log(context, config, 0,
    527537            "Bad request for constrained delegation");
     538    return ret;
     539}
     540
     541/*
     542 * Determine if s4u2self is allowed from this client to this server
     543 *
     544 * For example, regardless of the principal being impersonated, if the
     545 * 'client' and 'server' are the same, then it's safe.
     546 */
     547
     548static krb5_error_code
     549check_s4u2self(krb5_context context,
     550               krb5_kdc_configuration *config,
     551               HDB *clientdb,
     552               hdb_entry_ex *client,
     553               krb5_const_principal server)
     554{
     555    krb5_error_code ret;
     556
     557    /* if client does a s4u2self to itself, that ok */
     558    if (krb5_principal_compare(context, client->entry.principal, server) == TRUE)
     559        return 0;
     560
     561    if (clientdb->hdb_check_s4u2self) {
     562        ret = clientdb->hdb_check_s4u2self(context, clientdb, client, server);
     563        if (ret == 0)
     564            return 0;
     565    } else {
     566        ret = KRB5KDC_ERR_BADOPTION;
     567    }
    528568    return ret;
    529569}
    … …  
    670710               krb5_const_principal tgt_name,
    671711               const EncTicketPart *tgt,
     712               const krb5_keyblock *replykey,
     713               int rk_is_subkey,
    672714               const EncryptionKey *serverkey,
    673715               const krb5_keyblock *sessionkey,
    … …  
    769811    }
    770812    if(f.renewable_ok && tgt->flags.renewable &&
    771        et.renew_till == NULL && et.endtime < *b->till){
     813       et.renew_till == NULL && et.endtime < *b->till &&
     814       tgt->renew_till != NULL)
     815    {
    772816        et.flags.renewable = 1;
    773817        ALLOC(et.renew_till);
    … …  
    822866
    823867        /* XXX check authdata */
     868
    824869        if (et.authorization_data == NULL) {
    825             ret = ENOMEM;
    826             krb5_set_error_message(context, ret, "malloc: out of memory");
    827             goto out;
     870            et.authorization_data = calloc(1, sizeof(*et.authorization_data));
     871            if (et.authorization_data == NULL) {
     872                ret = ENOMEM;
     873                krb5_set_error_message(context, ret, "malloc: out of memory");
     874                goto out;
     875            }
    828876        }
    829877        for(i = 0; i < auth_data->len ; i++) {
    … …  
    885933                                          krbtgt,
    886934                                          krbtgt_etype,
     935                                          client_principal,
    887936                                          NULL,
    888937                                          spp,
    … …  
    925974                            &rep, &et, &ek, et.key.keytype,
    926975                            kvno,
    927                             serverkey, 0, &tgt->key, e_text, reply);
     976                            serverkey, 0, replykey, rk_is_subkey,
     977                            e_text, reply);
    928978    if (is_weak)
    929979        krb5_enctype_disable(context, et.key.keytype);
    … …  
    9861036    ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, buf_size, b, &len, ret);
    9871037    if(ret){
    988         kdc_log(context, config, 0, "Failed to encode KDC-REQ-BODY: %s",
    989                 krb5_get_err_text(context, ret));
     1038        const char *msg = krb5_get_error_message(context, ret);
     1039        kdc_log(context, config, 0, "Failed to encode KDC-REQ-BODY: %s", msg);
     1040        krb5_free_error_message(context, msg);
    9901041        goto out;
    9911042    }
    … …  
    9991050    ret = krb5_crypto_init(context, key, 0, &crypto);
    10001051    if (ret) {
     1052        const char *msg = krb5_get_error_message(context, ret);
    10011053        free(buf);
    1002         kdc_log(context, config, 0, "krb5_crypto_init failed: %s",
    1003                 krb5_get_err_text(context, ret));
     1054        kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
     1055        krb5_free_error_message(context, msg);
    10041056        goto out;
    10051057    }
    … …  
    10131065    krb5_crypto_destroy(context, crypto);
    10141066    if(ret){
     1067        const char *msg = krb5_get_error_message(context, ret);
    10151068        kdc_log(context, config, 0,
    1016                 "Failed to verify authenticator checksum: %s",
    1017                 krb5_get_err_text(context, ret));
     1069                "Failed to verify authenticator checksum: %s", msg);
     1070        krb5_free_error_message(context, msg);
    10181071    }
    10191072out:
    … …  
    10751128                  time_t **csec,
    10761129                  int **cusec,
    1077                   AuthorizationData **auth_data)
     1130                  AuthorizationData **auth_data,
     1131                  krb5_keyblock **replykey,
     1132                  int *rk_is_subkey)
    10781133{
    10791134    krb5_ap_req ap_req;
    … …  
    10851140    krb5_crypto crypto;
    10861141    Key *tkey;
     1142    krb5_keyblock *subkey = NULL;
     1143    unsigned usage;
    10871144
    10881145    *auth_data = NULL;
    10891146    *csec  = NULL;
    10901147    *cusec = NULL;
     1148    *replykey = NULL;
    10911149
    10921150    memset(&ap_req, 0, sizeof(ap_req));
    10931151    ret = krb5_decode_ap_req(context, &tgs_req->padata_value, &ap_req);
    10941152    if(ret){
    1095         kdc_log(context, config, 0, "Failed to decode AP-REQ: %s",
    1096                 krb5_get_err_text(context, ret));
     1153        const char *msg = krb5_get_error_message(context, ret);
     1154        kdc_log(context, config, 0, "Failed to decode AP-REQ: %s", msg);
     1155        krb5_free_error_message(context, msg);
    10971156        goto out;
    10981157    }
    … …  
    11101169                                       ap_req.ticket.realm);
    11111170
    1112     ret = _kdc_db_fetch(context, config, princ, HDB_F_GET_KRBTGT, NULL, krbtgt);
    1113 
    1114     if(ret) {
     1171    ret = _kdc_db_fetch(context, config, princ, HDB_F_GET_KRBTGT, ap_req.ticket.enc_part.kvno, NULL, krbtgt);
     1172
     1173    if(ret == HDB_ERR_NOT_FOUND_HERE) {
     1174        char *p;
     1175        ret = krb5_unparse_name(context, princ, &p);
     1176        if (ret != 0)
     1177            p = "<unparse_name failed>";
     1178        krb5_free_principal(context, princ);
     1179        kdc_log(context, config, 5, "Ticket-granting ticket account %s does not have secrets at this KDC, need to proxy", p);
     1180        if (ret == 0)
     1181            free(p);
     1182        ret = HDB_ERR_NOT_FOUND_HERE;
     1183        goto out;
     1184    } else if(ret){
     1185        const char *msg = krb5_get_error_message(context, ret);
    11151186        char *p;
    11161187        ret = krb5_unparse_name(context, princ, &p);
    … …  
    11191190        krb5_free_principal(context, princ);
    11201191        kdc_log(context, config, 0,
    1121                 "Ticket-granting ticket not found in database: %s: %s",
    1122                 p, krb5_get_err_text(context, ret));
     1192                "Ticket-granting ticket not found in database: %s", msg);
     1193        krb5_free_error_message(context, msg);
    11231194        if (ret == 0)
    11241195            free(p);
    … …  
    11821253    krb5_free_principal(context, princ);
    11831254    if(ret) {
    1184         kdc_log(context, config, 0, "Failed to verify AP-REQ: %s",
    1185                 krb5_get_err_text(context, ret));
     1255        const char *msg = krb5_get_error_message(context, ret);
     1256        kdc_log(context, config, 0, "Failed to verify AP-REQ: %s", msg);
     1257        krb5_free_error_message(context, msg);
    11861258        goto out;
    11871259    }
    … …  
    12171289    }
    12181290
     1291    usage = KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY;
     1292    *rk_is_subkey = 1;
     1293
     1294    ret = krb5_auth_con_getremotesubkey(context, ac, &subkey);
     1295    if(ret){
     1296        const char *msg = krb5_get_error_message(context, ret);
     1297        krb5_auth_con_free(context, ac);
     1298        kdc_log(context, config, 0, "Failed to get remote subkey: %s", msg);
     1299        krb5_free_error_message(context, msg);
     1300        goto out;
     1301    }
     1302    if(subkey == NULL){
     1303        usage = KRB5_KU_TGS_REQ_AUTH_DAT_SESSION;
     1304        *rk_is_subkey = 0;
     1305
     1306        ret = krb5_auth_con_getkey(context, ac, &subkey);
     1307        if(ret) {
     1308            const char *msg = krb5_get_error_message(context, ret);
     1309            krb5_auth_con_free(context, ac);
     1310            kdc_log(context, config, 0, "Failed to get session key: %s", msg);
     1311            krb5_free_error_message(context, msg);
     1312            goto out;
     1313        }
     1314    }
     1315    if(subkey == NULL){
     1316        krb5_auth_con_free(context, ac);
     1317        kdc_log(context, config, 0,
     1318                "Failed to get key for enc-authorization-data");
     1319        ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
     1320        goto out;
     1321    }
     1322
     1323    *replykey = subkey;
     1324
    12191325    if (b->enc_authorization_data) {
    1220         unsigned usage = KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY;
    1221         krb5_keyblock *subkey;
    12221326        krb5_data ad;
    12231327
    1224         ret = krb5_auth_con_getremotesubkey(context, ac, &subkey);
    1225         if(ret){
     1328        ret = krb5_crypto_init(context, subkey, 0, &crypto);
     1329        if (ret) {
     1330            const char *msg = krb5_get_error_message(context, ret);
    12261331            krb5_auth_con_free(context, ac);
    1227             kdc_log(context, config, 0, "Failed to get remote subkey: %s",
    1228                     krb5_get_err_text(context, ret));
    1229             goto out;
    1230         }
    1231         if(subkey == NULL){
    1232             usage = KRB5_KU_TGS_REQ_AUTH_DAT_SESSION;
    1233             ret = krb5_auth_con_getkey(context, ac, &subkey);
    1234             if(ret) {
    1235                 krb5_auth_con_free(context, ac);
    1236                 kdc_log(context, config, 0, "Failed to get session key: %s",
    1237                         krb5_get_err_text(context, ret));
    1238                 goto out;
    1239             }
    1240         }
    1241         if(subkey == NULL){
    1242             krb5_auth_con_free(context, ac);
    1243             kdc_log(context, config, 0,
    1244                     "Failed to get key for enc-authorization-data");
    1245             ret = KRB5KRB_AP_ERR_BAD_INTEGRITY; /* ? */
    1246             goto out;
    1247         }
    1248         ret = krb5_crypto_init(context, subkey, 0, &crypto);
    1249         krb5_free_keyblock(context, subkey);
    1250         if (ret) {
    1251             krb5_auth_con_free(context, ac);
    1252             kdc_log(context, config, 0, "krb5_crypto_init failed: %s",
    1253                     krb5_get_err_text(context, ret));
     1332            kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
     1333            krb5_free_error_message(context, msg);
    12541334            goto out;
    12551335        }
    … …  
    13751455                hdb_entry_ex *krbtgt,
    13761456                krb5_enctype krbtgt_etype,
     1457                const krb5_keyblock *replykey,
     1458                int rk_is_subkey,
    13771459                krb5_ticket *ticket,
    13781460                krb5_data *reply,
    … …  
    13851467    krb5_principal cp = NULL, sp = NULL;
    13861468    krb5_principal client_principal = NULL;
     1469    krb5_principal krbtgt_principal = NULL;
    13871470    char *spn = NULL, *cpn = NULL;
    1388     hdb_entry_ex *server = NULL, *client = NULL;
    1389     HDB *clientdb;
     1471    hdb_entry_ex *server = NULL, *client = NULL, *s4u2self_impersonated_client = NULL;
     1472    HDB *clientdb, *s4u2self_impersonated_clientdb;
    13901473    krb5_realm ref_realm = NULL;
    13911474    EncTicketPart *tgt = &ticket->ticket;
    … …  
    13961479    krb5_data rspac;
    13971480
     1481    hdb_entry_ex *krbtgt_out = NULL;
     1482
    13981483    METHOD_DATA enc_pa_data;
    13991484
    … …  
    14051490    int signedpath = 0;
    14061491
    1407     Key *tkey;
     1492    Key *tkey_check;
     1493    Key *tkey_sign;
    14081494
    14091495    memset(&sessionkey, 0, sizeof(sessionkey));
    … …  
    14371523        _krb5_principalname2krb5_principal(context, &p, t->sname, t->realm);
    14381524        ret = _kdc_db_fetch(context, config, p,
    1439                             HDB_F_GET_CLIENT|HDB_F_GET_SERVER,
     1525                            HDB_F_GET_KRBTGT, t->enc_part.kvno,
    14401526                            NULL, &uu);
    14411527        krb5_free_principal(context, p);
    … …  
    14901576server_lookup:
    14911577    ret = _kdc_db_fetch(context, config, sp, HDB_F_GET_SERVER | HDB_F_CANON,
    1492                         NULL, &server);
    1493 
    1494     if(ret){
    1495         const char *new_rlm;
     1578                        NULL, NULL, &server);
     1579
     1580    if(ret == HDB_ERR_NOT_FOUND_HERE) {
     1581        kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", sp);
     1582        goto out;
     1583    } else if(ret){
     1584        const char *new_rlm, *msg;
    14961585        Realm req_rlm;
    14971586        krb5_realm *realms;
    … …  
    15411630            krb5_free_host_realm(context, realms);
    15421631        }
     1632        msg = krb5_get_error_message(context, ret);
    15431633        kdc_log(context, config, 0,
    1544                 "Server not found in database: %s: %s", spn,
    1545                 krb5_get_err_text(context, ret));
     1634                "Server not found in database: %s: %s", spn, msg);
     1635        krb5_free_error_message(context, msg);
    15461636        if (ret == HDB_ERR_NOENTRY)
    15471637            ret = KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN;
    15481638        goto out;
    1549     }
    1550 
    1551     ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | HDB_F_CANON,
    1552                         &clientdb, &client);
    1553     if(ret) {
    1554         const char *krbtgt_realm;
    1555 
    1556         /*
    1557          * If the client belongs to the same realm as our krbtgt, it
    1558          * should exist in the local database.
    1559          *
    1560          */
    1561 
    1562         krbtgt_realm =
    1563             krb5_principal_get_comp_string(context,
    1564                                            krbtgt->entry.principal, 1);
    1565 
    1566         if(strcmp(krb5_principal_get_realm(context, cp), krbtgt_realm) == 0) {
    1567             if (ret == HDB_ERR_NOENTRY)
    1568                 ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
    1569             kdc_log(context, config, 1, "Client no longer in database: %s",
    1570                     cpn);
    1571             goto out;
    1572         }
    1573        
    1574         kdc_log(context, config, 1, "Client not found in database: %s: %s",
    1575                 cpn, krb5_get_err_text(context, ret));
    15761639    }
    15771640
    … …  
    16011664            Key *skey;
    16021665       
    1603             ret = _kdc_find_etype(context, server, b->etype.val, b->etype.len,
    1604                                   &skey, &etype);
     1666            ret = _kdc_find_etype(context, server,
     1667                                  b->etype.val, b->etype.len, &skey);
    16051668            if(ret) {
    16061669                kdc_log(context, config, 0,
    … …  
    16091672            }
    16101673            ekey = &skey->key;
     1674            etype = skey->key.keytype;
    16111675            kvno = server->entry.kvno;
    16121676        }
    … …  
    16231687     */
    16241688
    1625     if (strcmp(krb5_principal_get_realm(context, sp),
    1626                krb5_principal_get_comp_string(context,
    1627                                               krbtgt->entry.principal,
    1628                                               1)) != 0) {
     1689    /*
     1690     * Validate authoriation data
     1691     */
     1692
     1693    ret = hdb_enctype2key(context, &krbtgt->entry,
     1694                          krbtgt_etype, &tkey_check);
     1695    if(ret) {
     1696        kdc_log(context, config, 0,
     1697                    "Failed to find key for krbtgt PAC check");
     1698        goto out;
     1699    }
     1700
     1701    /* Now refetch the primary krbtgt, and get the current kvno (the
     1702     * sign check may have been on an old kvno, and the server may
     1703     * have been an incoming trust) */
     1704    ret = krb5_make_principal(context, &krbtgt_principal,
     1705                              krb5_principal_get_comp_string(context,
     1706                                                             krbtgt->entry.principal,
     1707                                                             1),
     1708                              KRB5_TGS_NAME,
     1709                              krb5_principal_get_comp_string(context,
     1710                                                             krbtgt->entry.principal,
     1711                                                             1), NULL);
     1712    if(ret) {
     1713        kdc_log(context, config, 0,
     1714                    "Failed to generate krbtgt principal");
     1715        goto out;
     1716    }
     1717
     1718    ret = _kdc_db_fetch(context, config, krbtgt_principal, HDB_F_GET_KRBTGT, NULL, NULL, &krbtgt_out);
     1719    krb5_free_principal(context, krbtgt_principal);
     1720    if (ret) {
     1721        krb5_error_code ret2;
     1722        char *tpn, *tpn2;
     1723        ret = krb5_unparse_name(context, krbtgt->entry.principal, &tpn);
     1724        ret2 = krb5_unparse_name(context, krbtgt->entry.principal, &tpn2);
     1725        kdc_log(context, config, 0,
     1726                "Request with wrong krbtgt: %s, %s not found in our database",
     1727                (ret == 0) ? tpn : "<unknown>", (ret2 == 0) ? tpn2 : "<unknown>");
     1728        if(ret == 0)
     1729            free(tpn);
     1730        if(ret2 == 0)
     1731            free(tpn2);
     1732        ret = KRB5KRB_AP_ERR_NOT_US;
     1733        goto out;
     1734    }
     1735
     1736    /* The first realm is the realm of the service, the second is
     1737     * krbtgt/<this>/@REALM component of the krbtgt DN the request was
     1738     * encrypted to.  The redirection via the krbtgt_out entry allows
     1739     * the DB to possibly correct the case of the realm (Samba4 does
     1740     * this) before the strcmp() */
     1741    if (strcmp(krb5_principal_get_realm(context, server->entry.principal),
     1742               krb5_principal_get_realm(context, krbtgt_out->entry.principal)) != 0) {
    16291743        char *tpn;
    1630         ret = krb5_unparse_name(context, krbtgt->entry.principal, &tpn);
     1744        ret = krb5_unparse_name(context, krbtgt_out->entry.principal, &tpn);
    16311745        kdc_log(context, config, 0,
    16321746                "Request with wrong krbtgt: %s",
    … …  
    16351749            free(tpn);
    16361750        ret = KRB5KRB_AP_ERR_NOT_US;
    1637         goto out;
    1638     }
    1639 
    1640     /*
    1641      * Validate authoriation data
    1642      */
    1643 
    1644     ret = hdb_enctype2key(context, &krbtgt->entry,
    1645                           krbtgt_etype, &tkey);
     1751    }
     1752
     1753    ret = hdb_enctype2key(context, &krbtgt_out->entry,
     1754                          krbtgt_etype, &tkey_sign);
    16461755    if(ret) {
    16471756        kdc_log(context, config, 0,
    1648                     "Failed to find key for krbtgt PAC check");
    1649         goto out;
     1757                    "Failed to find key for krbtgt PAC signature");
     1758        goto out;
     1759    }
     1760
     1761    ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | HDB_F_CANON,
     1762                        NULL, &clientdb, &client);
     1763    if(ret == HDB_ERR_NOT_FOUND_HERE) {
     1764        /* This is OK, we are just trying to find out if they have
     1765         * been disabled or deleted in the meantime, missing secrets
     1766         * is OK */
     1767    } else if(ret){
     1768        const char *krbtgt_realm, *msg;
     1769
     1770        /*
     1771         * If the client belongs to the same realm as our krbtgt, it
     1772         * should exist in the local database.
     1773         *
     1774         */
     1775
     1776        krbtgt_realm = krb5_principal_get_realm(context, krbtgt_out->entry.principal);
     1777
     1778        if(strcmp(krb5_principal_get_realm(context, cp), krbtgt_realm) == 0) {
     1779            if (ret == HDB_ERR_NOENTRY)
     1780                ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
     1781            kdc_log(context, config, 1, "Client no longer in database: %s",
     1782                    cpn);
     1783            goto out;
     1784        }
     1785
     1786        msg = krb5_get_error_message(context, ret);
     1787        kdc_log(context, config, 1, "Client not found in database: %s", msg);
     1788        krb5_free_error_message(context, msg);
    16501789    }
    16511790
    16521791    ret = check_PAC(context, config, cp,
    1653                     client, server, ekey, &tkey->key,
     1792                    client, server, krbtgt, ekey, &tkey_check->key, &tkey_sign->key,
    16541793                    tgt, &rspac, &signedpath);
    16551794    if (ret) {
     1795        const char *msg = krb5_get_error_message(context, ret);
    16561796        kdc_log(context, config, 0,
    16571797                "Verify PAC failed for %s (%s) from %s with %s",
    1658                 spn, cpn, from, krb5_get_err_text(context, ret));
     1798                spn, cpn, from, msg);
     1799        krb5_free_error_message(context, msg);
    16591800        goto out;
    16601801    }
    … …  
    16641805                               config,
    16651806                               krbtgt,
     1807                               cp,
    16661808                               tgt,
    16671809                               &spp,
    16681810                               &signedpath);
    16691811    if (ret) {
     1812        const char *msg = krb5_get_error_message(context, ret);
    16701813        kdc_log(context, config, 0,
    16711814                "KRB5SignedPath check failed for %s (%s) from %s with %s",
    1672                 spn, cpn, from, krb5_get_err_text(context, ret));
     1815                spn, cpn, from, msg);
     1816        krb5_free_error_message(context, msg);
    16731817        goto out;
    16741818    }
    … …  
    17061850            ret = krb5_crypto_init(context, &tgt->key, 0, &crypto);
    17071851            if (ret) {
     1852                const char *msg = krb5_get_error_message(context, ret);
    17081853                free_PA_S4U2Self(&self);
    17091854                krb5_data_free(&datack);
    1710                 kdc_log(context, config, 0, "krb5_crypto_init failed: %s",
    1711                         krb5_get_err_text(context, ret));
     1855                kdc_log(context, config, 0, "krb5_crypto_init failed: %s", msg);
     1856                krb5_free_error_message(context, msg);
    17121857                goto out;
    17131858            }
    … …  
    17221867            krb5_crypto_destroy(context, crypto);
    17231868            if (ret) {
     1869                const char *msg = krb5_get_error_message(context, ret);
    17241870                free_PA_S4U2Self(&self);
    17251871                kdc_log(context, config, 0,
    1726                         "krb5_verify_checksum failed for S4U2Self: %s",
    1727                         krb5_get_err_text(context, ret));
     1872                        "krb5_verify_checksum failed for S4U2Self: %s", msg);
     1873                krb5_free_error_message(context, msg);
    17281874                goto out;
    17291875            }
    … …  
    17411887                goto out;
    17421888
     1889            /* If we were about to put a PAC into the ticket, we better fix it to be the right PAC */
     1890            if(rspac.data) {
     1891                krb5_pac p = NULL;
     1892                krb5_data_free(&rspac);
     1893                ret = _kdc_db_fetch(context, config, client_principal, HDB_F_GET_CLIENT | HDB_F_CANON,
     1894                                    NULL, &s4u2self_impersonated_clientdb, &s4u2self_impersonated_client);
     1895                if (ret) {
     1896                    const char *msg;
     1897
     1898                    /*
     1899                     * If the client belongs to the same realm as our krbtgt, it
     1900                     * should exist in the local database.
     1901                     *
     1902                     */
     1903
     1904                    if (ret == HDB_ERR_NOENTRY)
     1905                        ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
     1906                    msg = krb5_get_error_message(context, ret);
     1907                    kdc_log(context, config, 1, "S2U4Self principal to impersonate %s not found in database: %s", cpn, msg);
     1908                    krb5_free_error_message(context, msg);
     1909                    goto out;
     1910                }
     1911                ret = _kdc_pac_generate(context, s4u2self_impersonated_client, &p);
     1912                if (ret) {
     1913                    kdc_log(context, config, 0, "PAC generation failed for -- %s",
     1914                            selfcpn);
     1915                    goto out;
     1916                }
     1917                if (p != NULL) {
     1918                    ret = _krb5_pac_sign(context, p, ticket->ticket.authtime,
     1919                                         s4u2self_impersonated_client->entry.principal,
     1920                                         ekey, &tkey_sign->key,
     1921                                         &rspac);
     1922                    krb5_pac_free(context, p);
     1923                    if (ret) {
     1924                        kdc_log(context, config, 0, "PAC signing failed for -- %s",
     1925                                selfcpn);
     1926                        goto out;
     1927                    }
     1928                }
     1929            }
     1930
    17431931            /*
    17441932             * Check that service doing the impersonating is
    17451933             * requesting a ticket to it-self.
    17461934             */
    1747             if (krb5_principal_compare(context, cp, sp) != TRUE) {
     1935            ret = check_s4u2self(context, config, clientdb, client, sp);
     1936            if (ret) {
    17481937                kdc_log(context, config, 0, "S4U2Self: %s is not allowed "
    1749                         "to impersonate some other user "
     1938                        "to impersonate to service "
    17501939                        "(tried for user %s to service %s)",
    17511940                        cpn, selfcpn, spn);
    17521941                free(selfcpn);
    1753                 ret = KRB5KDC_ERR_BADOPTION; /* ? */
    17541942                goto out;
    17551943            }
    … …  
    18562044                                   config,
    18572045                                   krbtgt,
     2046                                   cp,
    18582047                                   &adtkt,
    18592048                                   NULL,
    … …  
    18622051            ret = KRB5KDC_ERR_BADOPTION;
    18632052        if (ret) {
     2053            const char *msg = krb5_get_error_message(context, ret);
    18642054            kdc_log(context, config, 0,
    18652055                    "KRB5SignedPath check from service %s failed "
    18662056                    "for delegation to %s for client %s "
    18672057                    "from %s failed with %s",
    1868                     spn, str, cpn, from, krb5_get_err_text(context, ret));
     2058                    spn, str, cpn, from, msg);
     2059            krb5_free_error_message(context, msg);
    18692060            free(str);
    18702061            goto out;
    … …  
    19462137                         client_principal,
    19472138                         tgt,
     2139                         replykey,
     2140                         rk_is_subkey,
    19482141                         ekey,
    19492142                         &sessionkey,
    … …  
    19512144                         *auth_data,
    19522145                         server,
    1953                          sp,
     2146                         server->entry.principal,
    19542147                         spn,
    19552148                         client,
    19562149                         cp,
    1957                          krbtgt,
     2150                         krbtgt_out,
    19582151                         krbtgt_etype,
    19592152                         spp,
    … …  
    19692162    krb5_data_free(&rspac);
    19702163    krb5_free_keyblock_contents(context, &sessionkey);
     2164    if(krbtgt_out)
     2165        _kdc_free_ent(context, krbtgt_out);
    19712166    if(server)
    19722167        _kdc_free_ent(context, server);
    19732168    if(client)
    19742169        _kdc_free_ent(context, client);
     2170    if(s4u2self_impersonated_client)
     2171        _kdc_free_ent(context, s4u2self_impersonated_client);
    19752172
    19762173    if (client_principal && client_principal != cp)
    … …  
    20122209    krb5_enctype krbtgt_etype = ETYPE_NULL;
    20132210
     2211    krb5_keyblock *replykey = NULL;
     2212    int rk_is_subkey = 0;
    20142213    time_t *csec = NULL;
    20152214    int *cusec = NULL;
    … …  
    20392238                            from, from_addr,
    20402239                            &csec, &cusec,
    2041                             &auth_data);
     2240                            &auth_data,
     2241                            &replykey,
     2242                            &rk_is_subkey);
     2243    if (ret == HDB_ERR_NOT_FOUND_HERE) {
     2244        /* kdc_log() is called in tgs_parse_request() */
     2245        goto out;
     2246    }
    20422247    if (ret) {
    20432248        kdc_log(context, config, 0,
    … …  
    20522257                          krbtgt,
    20532258                          krbtgt_etype,
     2259                          replykey,
     2260                          rk_is_subkey,
    20542261                          ticket,
    20552262                          data,
    … …  
    20722279
    20732280out:
    2074     if(ret && data->data == NULL){
     2281    if (replykey)
     2282        krb5_free_keyblock(context, replykey);
     2283    if(ret && ret != HDB_ERR_NOT_FOUND_HERE && data->data == NULL){
    20752284        krb5_mk_error(context,
    20762285                      ret,
    … …  
    20822291                      cusec,
    20832292                      data);
     2293        ret = 0;
    20842294    }
    20852295    free(csec);
    … …  
    20952305    }
    20962306
    2097     return 0;
     2307    return ret;
    20982308}

  • trunk/server/source4/heimdal/kdc/kx509.c

    r414 r745  
    144144                  krb5_data *certificate)
    145145{
    146     hx509_context hxctx = NULL;
    147146    hx509_ca_tbs tbs = NULL;
    148147    hx509_env env = NULL;
    … …  
    156155    }
    157156
    158     ret = hx509_context_init(&hxctx);
    159     if (ret)
    160         goto out;
    161 
    162     ret = hx509_env_add(hxctx, &env, "principal-name",
     157    ret = hx509_env_add(context->hx509ctx, &env, "principal-name",
    163158                        krb5_principal_get_comp_string(context, principal, 0));
    164159    if (ret)
    … …  
    169164        hx509_query *q;
    170165
    171         ret = hx509_certs_init(hxctx, config->kx509_ca, 0,
     166        ret = hx509_certs_init(context->hx509ctx, config->kx509_ca, 0,
    172167                               NULL, &certs);
    173168        if (ret) {
    … …  
    176171            goto out;
    177172        }
    178         ret = hx509_query_alloc(hxctx, &q);
     173        ret = hx509_query_alloc(context->hx509ctx, &q);
    179174        if (ret) {
    180175            hx509_certs_free(&certs);
    … …  
    185180        hx509_query_match_option(q, HX509_QUERY_OPTION_KU_KEYCERTSIGN);
    186181
    187         ret = hx509_certs_find(hxctx, certs, q, &signer);
    188         hx509_query_free(hxctx, q);
     182        ret = hx509_certs_find(context->hx509ctx, certs, q, &signer);
     183        hx509_query_free(context->hx509ctx, q);
    189184        hx509_certs_free(&certs);
    190185        if (ret) {
    … …  
    195190    }
    196191
    197     ret = hx509_ca_tbs_init(hxctx, &tbs);
     192    ret = hx509_ca_tbs_init(context->hx509ctx, &tbs);
    198193    if (ret)
    199194        goto out;
    … …  
    215210        spki.algorithm.parameters = &any;
    216211
    217         ret = hx509_ca_tbs_set_spki(hxctx, tbs, &spki);
     212        ret = hx509_ca_tbs_set_spki(context->hx509ctx, tbs, &spki);
    218213        der_free_oid(&spki.algorithm.algorithm);
    219214        if (ret)
    … …  
    225220        hx509_cert template;
    226221
    227         ret = hx509_certs_init(hxctx, config->kx509_template, 0,
     222        ret = hx509_certs_init(context->hx509ctx, config->kx509_template, 0,
    228223                               NULL, &certs);
    229224        if (ret) {
    … …  
    232227            goto out;
    233228        }
    234         ret = hx509_get_one_cert(hxctx, certs, &template);
     229        ret = hx509_get_one_cert(context->hx509ctx, certs, &template);
    235230        hx509_certs_free(&certs);
    236231        if (ret) {
    … …  
    239234            goto out;
    240235        }
    241         ret = hx509_ca_tbs_set_template(hxctx, tbs,
     236        ret = hx509_ca_tbs_set_template(context->hx509ctx, tbs,
    242237                                        HX509_CA_TEMPLATE_SUBJECT|
    243238                                        HX509_CA_TEMPLATE_KU|
    … …  
    249244    }
    250245
    251     hx509_ca_tbs_set_notAfter(hxctx, tbs, endtime);
    252 
    253     hx509_ca_tbs_subject_expand(hxctx, tbs, env);
     246    hx509_ca_tbs_set_notAfter(context->hx509ctx, tbs, endtime);
     247
     248    hx509_ca_tbs_subject_expand(context->hx509ctx, tbs, env);
    254249    hx509_env_free(&env);
    255250
    256     ret = hx509_ca_sign(hxctx, tbs, signer, &cert);
     251    ret = hx509_ca_sign(context->hx509ctx, tbs, signer, &cert);
    257252    hx509_cert_free(signer);
    258253    if (ret)
    … …  
    261256    hx509_ca_tbs_free(&tbs);
    262257
    263     ret = hx509_cert_binary(hxctx, cert, certificate);
     258    ret = hx509_cert_binary(context->hx509ctx, cert, certificate);
    264259    hx509_cert_free(cert);
    265260    if (ret)
    266261        goto out;
    267262               
    268     hx509_context_free(&hxctx);
    269 
    270263    return 0;
    271264out:
    … …  
    276269    if (signer)
    277270        hx509_cert_free(signer);
    278     if (hxctx)
    279         hx509_context_free(&hxctx);
    280271    krb5_set_error_message(context, ret, "cert creation failed");
    281272    return ret;
    … …  
    355346        krb5_free_principal(context, principal);
    356347        if (ret != TRUE) {
     348            char *expected, *used;
     349
     350            ret = krb5_unparse_name(context, sprincipal, &expected);
     351            if (ret)
     352                goto out;
     353            ret = krb5_unparse_name(context, principal, &used);
     354            if (ret) {
     355                krb5_xfree(expected);
     356                goto out;
     357            }
     358           
    357359            ret = KRB5KDC_ERR_SERVER_NOMATCH;
    358360            krb5_set_error_message(context, ret,
    359                                    "User %s used wrong Kx509 service principal",
    360                                    cname);
     361                                   "User %s used wrong Kx509 service "
     362                                   "principal, expected: %s, used %s",
     363                                   cname, expected, used);
     364            krb5_xfree(expected);
     365            krb5_xfree(used);
    361366            goto out;
    362367        }

  • trunk/server/source4/heimdal/kdc/log.c

    r414 r745  
    33 * (Royal Institute of Technology, Stockholm, Sweden).
    44 * All rights reserved.
     5 *
     6 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
    57 *
    68 * Redistribution and use in source and binary forms, with or without
    … …  
    3335
    3436#include "kdc_locl.h"
    35 RCSID("$Id$");
    3637
    3738void
    3839kdc_openlog(krb5_context context,
     40            const char *service,
    3941            krb5_kdc_configuration *config)
    4042{
    4143    char **s = NULL, **p;
    4244    krb5_initlog(context, "kdc", &config->logf);
    43     s = krb5_config_get_strings(context, NULL, "kdc", "logging", NULL);
     45    s = krb5_config_get_strings(context, NULL, service, "logging", NULL);
    4446    if(s == NULL)
    45         s = krb5_config_get_strings(context, NULL, "logging", "kdc", NULL);
     47        s = krb5_config_get_strings(context, NULL, "logging", service, NULL);
    4648    if(s){
    4749        for(p = s; *p; p++)

  • trunk/server/source4/heimdal/kdc/misc.c

    r414 r745  
    3434#include "kdc_locl.h"
    3535
    36 RCSID("$Id$");
    37 
    3836struct timeval _kdc_now;
    3937
    … …  
    4341              krb5_const_principal principal,
    4442              unsigned flags,
     43              krb5int32 *kvno_ptr,
    4544              HDB **db,
    4645              hdb_entry_ex **h)
    4746{
    4847    hdb_entry_ex *ent;
    49     krb5_error_code ret;
     48    krb5_error_code ret = HDB_ERR_NOENTRY;
    5049    int i;
     50    unsigned kvno = 0;
     51
     52    if (kvno_ptr) {
     53            kvno = *kvno_ptr;
     54            flags |= HDB_F_KVNO_SPECIFIED;
     55    }
    5156
    5257    ent = calloc (1, sizeof (*ent));
    … …  
    8186        ret = config->db[i]->hdb_open(context, config->db[i], O_RDONLY, 0);
    8287        if (ret) {
    83             kdc_log(context, config, 0, "Failed to open database: %s",
    84                     krb5_get_err_text(context, ret));
     88            const char *msg = krb5_get_error_message(context, ret);
     89            kdc_log(context, config, 0, "Failed to open database: %s", msg);
     90            krb5_free_error_message(context, msg);
    8591            continue;
    8692        }
    8793
    88         ret = config->db[i]->hdb_fetch(context,
    89                                        config->db[i],
    90                                        principal,
    91                                        flags | HDB_F_DECRYPT,
    92                                        ent);
     94        ret = config->db[i]->hdb_fetch_kvno(context,
     95                                            config->db[i],
     96                                            principal,
     97                                            flags | HDB_F_DECRYPT,
     98                                            kvno,
     99                                            ent);
     100
    93101        krb5_free_principal(context, enterprise_principal);
    94102
    … …  
    102110    }
    103111    free(ent);
    104     krb5_set_error_message(context, HDB_ERR_NOENTRY,
     112    krb5_set_error_message(context, ret,
    105113                           "no such entry found in hdb");
    106     return HDB_ERR_NOENTRY;
     114    return ret;
    107115}
    108116

  • trunk/server/source4/heimdal/kdc/pkinit.c

    r414 r745  
    33 * (Royal Institute of Technology, Stockholm, Sweden).
    44 * All rights reserved.
     5 *
     6 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
    57 *
    68 * Redistribution and use in source and binary forms, with or without
    … …  
    3436#include "kdc_locl.h"
    3537
    36 RCSID("$Id$");
    37 
    3838#ifdef PKINIT
    3939
    … …  
    228228        }
    229229
    230         dh_gen_keylen = DH_size(client_params->u.dh.key);
    231         size = BN_num_bytes(client_params->u.dh.key->p);
    232         if (size < dh_gen_keylen)
    233             size = dh_gen_keylen;
     230        size = DH_size(client_params->u.dh.key);
    234231
    235232        dh_gen_key = malloc(size);
    … …  
    239236            goto out;
    240237        }
    241         memset(dh_gen_key, 0, size - dh_gen_keylen);
    242 
    243         dh_gen_keylen = DH_compute_key(dh_gen_key + (size - dh_gen_keylen),
    244                                        client_params->u.dh.public_key,
    245                                        client_params->u.dh.key);
     238
     239        dh_gen_keylen = DH_compute_key(dh_gen_key,client_params->u.dh.public_key, client_params->u.dh.key);
    246240        if (dh_gen_keylen == -1) {
    247241            ret = KRB5KRB_ERR_GENERIC;
    … …  
    250244            goto out;
    251245        }
     246        if (dh_gen_keylen < size) {
     247            size -= dh_gen_keylen;
     248            memmove(dh_gen_key + size, dh_gen_key, dh_gen_keylen);
     249            memset(dh_gen_key, 0, size);
     250        }
     251
    252252        ret = 0;
    253253#ifdef HAVE_OPENSSL
    … …  
    518518    }
    519519
    520     ret = hx509_certs_init(kdc_identity->hx509ctx,
     520    ret = hx509_certs_init(context->hx509ctx,
    521521                           "MEMORY:trust-anchors",
    522522                           0, NULL, &trust_anchors);
    … …  
    526526    }
    527527
    528     ret = hx509_certs_merge(kdc_identity->hx509ctx, trust_anchors,
     528    ret = hx509_certs_merge(context->hx509ctx, trust_anchors,
    529529                            kdc_identity->anchors);
    530530    if (ret) {
    … …  
    541541       
    542542        for (i = 0; i < pc->len; i++) {
    543             ret = hx509_cert_init_data(kdc_identity->hx509ctx,
     543            ret = hx509_cert_init_data(context->hx509ctx,
    544544                                       pc->val[i].cert.data,
    545545                                       pc->val[i].cert.length,
    … …  
    547547            if (ret)
    548548                continue;
    549             hx509_certs_add(kdc_identity->hx509ctx, trust_anchors, cert);
     549            hx509_certs_add(context->hx509ctx, trust_anchors, cert);
    550550            hx509_cert_free(cert);
    551551        }
    552552    }
    553553
    554     ret = hx509_verify_init_ctx(kdc_identity->hx509ctx, &cp->verify_ctx);
     554    ret = hx509_verify_init_ctx(context->hx509ctx, &cp->verify_ctx);
    555555    if (ret) {
    556556        hx509_certs_free(&trust_anchors);
    … …  
    619619            unsigned int i, maxedi;
    620620
    621             ret = hx509_certs_init(kdc_identity->hx509ctx,
     621            ret = hx509_certs_init(context->hx509ctx,
    622622                                   "MEMORY:client-anchors",
    623623                                   0, NULL,
    … …  
    646646                    continue;
    647647
    648                 ret = hx509_query_alloc(kdc_identity->hx509ctx, &q);
     648                ret = hx509_query_alloc(context->hx509ctx, &q);
    649649                if (ret) {
    650650                    krb5_set_error_message(context, ret,
    … …  
    658658                                                   &size);
    659659                if (ret) {
    660                     hx509_query_free(kdc_identity->hx509ctx, q);
     660                    hx509_query_free(context->hx509ctx, q);
    661661                    continue;
    662662                }
    … …  
    664664                free_IssuerAndSerialNumber(&iasn);
    665665                if (ret) {
    666                     hx509_query_free(kdc_identity->hx509ctx, q);
     666                    hx509_query_free(context->hx509ctx, q);
    667667                    continue;
    668668                }
    669669
    670                 ret = hx509_certs_find(kdc_identity->hx509ctx,
     670                ret = hx509_certs_find(context->hx509ctx,
    671671                                       kdc_identity->certs,
    672672                                       q,
    673673                                       &cert);
    674                 hx509_query_free(kdc_identity->hx509ctx, q);
     674                hx509_query_free(context->hx509ctx, q);
    675675                if (ret)
    676676                    continue;
    677                 hx509_certs_add(kdc_identity->hx509ctx,
     677                hx509_certs_add(context->hx509ctx,
    678678                                cp->client_anchors, cert);
    679679                hx509_cert_free(cert);
    … …  
    720720            flags |= HX509_CMS_VS_ALLOW_ZERO_SIGNER;
    721721
    722         ret = hx509_cms_verify_signed(kdc_identity->hx509ctx,
     722        ret = hx509_cms_verify_signed(context->hx509ctx,
    723723                                      cp->verify_ctx,
    724724                                      flags,
    … …  
    731731                                      &signer_certs);
    732732        if (ret) {
    733             char *s = hx509_get_error_string(kdc_identity->hx509ctx, ret);
     733            char *s = hx509_get_error_string(context->hx509ctx, ret);
    734734            krb5_warnx(context, "PKINIT: failed to verify signature: %s: %d",
    735735                       s, ret);
    … …  
    739739
    740740        if (signer_certs) {
    741             ret = hx509_get_one_cert(kdc_identity->hx509ctx, signer_certs,
     741            ret = hx509_get_one_cert(context->hx509ctx, signer_certs,
    742742                                     &cp->cert);
    743743            hx509_certs_free(&signer_certs);
    … …  
    844844            cp->keyex = USE_RSA;
    845845
    846         ret = hx509_peer_info_alloc(kdc_identity->hx509ctx,
     846        ret = hx509_peer_info_alloc(context->hx509ctx,
    847847                                        &cp->peer);
    848848        if (ret) {
    … …  
    852852       
    853853        if (ap.supportedCMSTypes) {
    854             ret = hx509_peer_info_set_cms_algs(kdc_identity->hx509ctx,
     854            ret = hx509_peer_info_set_cms_algs(context->hx509ctx,
    855855                                               cp->peer,
    856856                                               ap.supportedCMSTypes->val,
    … …  
    862862        } else {
    863863            /* assume old client */
    864             hx509_peer_info_add_cms_alg(kdc_identity->hx509ctx, cp->peer,
     864            hx509_peer_info_add_cms_alg(context->hx509ctx, cp->peer,
    865865                                        hx509_crypto_des_rsdi_ede3_cbc());
    866             hx509_peer_info_add_cms_alg(kdc_identity->hx509ctx, cp->peer,
     866            hx509_peer_info_add_cms_alg(context->hx509ctx, cp->peer,
    867867                                        hx509_signature_rsa_with_sha1());
    868             hx509_peer_info_add_cms_alg(kdc_identity->hx509ctx, cp->peer,
     868            hx509_peer_info_add_cms_alg(context->hx509ctx, cp->peer,
    869869                                        hx509_signature_sha1());
    870870        }
    … …  
    10171017        hx509_cert cert;
    10181018       
    1019         ret = hx509_query_alloc(kdc_identity->hx509ctx, &q);
     1019        ret = hx509_query_alloc(context->hx509ctx, &q);
    10201020        if (ret)
    10211021            goto out;
    … …  
    10251025            hx509_query_match_friendly_name(q, config->pkinit_kdc_friendly_name);
    10261026       
    1027         ret = hx509_certs_find(kdc_identity->hx509ctx,
     1027        ret = hx509_certs_find(context->hx509ctx,
    10281028                               kdc_identity->certs,
    10291029                               q,
    10301030                               &cert);
    1031         hx509_query_free(kdc_identity->hx509ctx, q);
     1031        hx509_query_free(context->hx509ctx, q);
    10321032        if (ret)
    10331033            goto out;
    10341034       
    1035         ret = hx509_cms_create_signed_1(kdc_identity->hx509ctx,
     1035        ret = hx509_cms_create_signed_1(context->hx509ctx,
    10361036                                        0,
    10371037                                        sdAlg,
    … …  
    10611061    }
    10621062
    1063     ret = hx509_cms_envelope_1(kdc_identity->hx509ctx,
     1063    ret = hx509_cms_envelope_1(context->hx509ctx,
    10641064                               HX509_CMS_EV_NO_KU_CHECK,
    10651065                               cp->cert,
    … …  
    11731173     */
    11741174
    1175     ret = hx509_query_alloc(kdc_identity->hx509ctx, &q);
     1175    ret = hx509_query_alloc(context->hx509ctx, &q);
    11761176    if (ret)
    11771177        goto out;
    … …  
    11811181        hx509_query_match_friendly_name(q, config->pkinit_kdc_friendly_name);
    11821182   
    1183     ret = hx509_certs_find(kdc_identity->hx509ctx,
     1183    ret = hx509_certs_find(context->hx509ctx,
    11841184                           kdc_identity->certs,
    11851185                           q,
    11861186                           &cert);
    1187     hx509_query_free(kdc_identity->hx509ctx, q);
     1187    hx509_query_free(context->hx509ctx, q);
    11881188    if (ret)
    11891189        goto out;
    11901190   
    1191     ret = hx509_cms_create_signed_1(kdc_identity->hx509ctx,
     1191    ret = hx509_cms_create_signed_1(context->hx509ctx,
    11921192                                    0,
    11931193                                    &asn1_oid_id_pkdhkeydata,
    … …  
    13801380        }
    13811381
    1382         ASN1_MALLOC_ENCODE(PA_PK_AS_REP, buf, len, &rep, &size, ret);
     1382#define use_btmm_with_enckey 0
     1383        if (use_btmm_with_enckey && rep.element == choice_PA_PK_AS_REP_encKeyPack) {
     1384            PA_PK_AS_REP_BTMM btmm;
     1385            heim_any any;
     1386
     1387            any.data = rep.u.encKeyPack.data;
     1388            any.length = rep.u.encKeyPack.length;
     1389
     1390            btmm.dhSignedData = NULL;
     1391            btmm.encKeyPack = &any;
     1392
     1393            ASN1_MALLOC_ENCODE(PA_PK_AS_REP_BTMM, buf, len, &btmm, &size, ret);
     1394        } else {
     1395            ASN1_MALLOC_ENCODE(PA_PK_AS_REP, buf, len, &rep, &size, ret);
     1396        }
     1397
    13831398        free_PA_PK_AS_REP(&rep);
    13841399        if (ret) {
    … …  
    15101525            }
    15111526
    1512             ret = hx509_ocsp_verify(kdc_identity->hx509ctx,
     1527            ret = hx509_ocsp_verify(context->hx509ctx,
    15131528                                    kdc_time,
    15141529                                    kdc_cert,
    … …  
    15811596                                       &kn, &size);
    15821597        if (ret) {
     1598            const char *msg = krb5_get_error_message(context, ret);
    15831599            kdc_log(context, config, 0,
    1584                     "Decoding kerberos name in certificate failed: %s",
    1585                     krb5_get_err_text(context, ret));
     1600                    "Decoding kerberos name in certificate failed: %s", msg);
     1601            krb5_free_error_message(context, msg);
    15861602            break;
    15871603        }
    … …  
    16451661        goto out;
    16461662    }
     1663    if (size != list.val[0].length) {
     1664        free_MS_UPN_SAN(&upn);
     1665        kdc_log(context, config, 0, "Trailing data in ");
     1666        ret = KRB5_KDC_ERR_CLIENT_NAME_MISMATCH;
     1667        goto out;
     1668    }
    16471669
    16481670    kdc_log(context, config, 0, "found MS UPN SAN: %s", upn);
    … …  
    16981720    }
    16991721
    1700     ret = hx509_cert_get_base_subject(kdc_identity->hx509ctx,
     1722    ret = hx509_cert_get_base_subject(context->hx509ctx,
    17011723                                      cp->cert,
    17021724                                      &name);
    … …  
    17191741       
    17201742        for (i = 0; i < pc->len; i++) {
    1721             ret = hx509_cert_init_data(kdc_identity->hx509ctx,
     1743            ret = hx509_cert_init_data(context->hx509ctx,
    17221744                                       pc->val[i].cert.data,
    17231745                                       pc->val[i].cert.length,
    … …  
    17381760    if (config->pkinit_princ_in_cert) {
    17391761        ret = match_rfc_san(context, config,
    1740                             kdc_identity->hx509ctx,
     1762                            context->hx509ctx,
    17411763                            cp->cert,
    17421764                            client->entry.principal);
    … …  
    17471769        }
    17481770        ret = match_ms_upn_san(context, config,
    1749                                kdc_identity->hx509ctx,
     1771                               context->hx509ctx,
    17501772                               cp->cert,
    17511773                               clientdb,
    … …  
    19221944
    19231945krb5_error_code
    1924 _kdc_pk_initialize(krb5_context context,
    1925                    krb5_kdc_configuration *config,
    1926                    const char *user_id,
    1927                    const char *anchors,
    1928                    char **pool,
    1929                    char **revoke_list)
     1946krb5_kdc_pk_initialize(krb5_context context,
     1947                       krb5_kdc_configuration *config,
     1948                       const char *user_id,
     1949                       const char *anchors,
     1950                       char **pool,
     1951                       char **revoke_list)
    19301952{
    19311953    const char *file;
    … …  
    19451967    ret = _krb5_pk_load_id(context,
    19461968                           &kdc_identity,
    1947                            0,
    19481969                           user_id,
    19491970                           anchors,
    … …  
    19631984        hx509_cert cert;
    19641985       
    1965         ret = hx509_query_alloc(kdc_identity->hx509ctx, &q);
     1986        ret = hx509_query_alloc(context->hx509ctx, &q);
    19661987        if (ret) {
    19671988            krb5_warnx(context, "PKINIT: out of memory");
    … …  
    19731994            hx509_query_match_friendly_name(q, config->pkinit_kdc_friendly_name);
    19741995       
    1975         ret = hx509_certs_find(kdc_identity->hx509ctx,
     1996        ret = hx509_certs_find(context->hx509ctx,
    19761997                               kdc_identity->certs,
    19771998                               q,
    19781999                               &cert);
    1979         hx509_query_free(kdc_identity->hx509ctx, q);
     2000        hx509_query_free(context->hx509ctx, q);
    19802001        if (ret == 0) {
    1981             if (hx509_cert_check_eku(kdc_identity->hx509ctx, cert,
     2002            if (hx509_cert_check_eku(context->hx509ctx, cert,
    19822003                                     &asn1_oid_id_pkkdcekuoid, 0)) {
    19832004                hx509_name name;

  • trunk/server/source4/heimdal/kdc/process.c

    r414 r745  
    162162
    163163
    164 #ifdef KRB4
    165 
    166 static krb5_error_code
    167 kdc_524(krb5_context context,
    168         krb5_kdc_configuration *config,
    169         krb5_data *req_buffer,
    170         krb5_data *reply,
    171         const char *from,
    172         struct sockaddr *addr,
    173         int datagram_reply,
    174         int *claim)
    175 {
    176     krb5_error_code ret;
    177     Ticket ticket;
    178     size_t len;
    179 
    180     ret = decode_Ticket(req_buffer->data, req_buffer->length, &ticket, &len);
    181     if (ret)
    182         return ret;
    183 
    184     *claim = 1;
    185 
    186     ret = _kdc_do_524(context, config, &ticket, reply, from, addr);
    187     free_Ticket(&ticket);
    188     return ret;
    189 }
    190 
    191 static krb5_error_code
    192 kdc_krb4(krb5_context context,
    193          krb5_kdc_configuration *config,
    194          krb5_data *req_buffer,
    195          krb5_data *reply,
    196          const char *from,
    197          struct sockaddr *addr,
    198          int datagram_reply,
    199          int *claim)
    200 {
    201     if (_kdc_maybe_version4(req_buffer->data, req_buffer->length) == 0)
    202         return -1;
    203 
    204     *claim = 1;
    205 
    206     return _kdc_do_version4(context, config,
    207                            req_buffer->data, req_buffer->length,
    208                            reply, from,
    209                            (struct sockaddr_in*)addr);
    210 }
    211 
    212 static krb5_error_code
    213 kdc_kaserver(krb5_context context,
    214              krb5_kdc_configuration *config,
    215              krb5_data *req_buffer,
    216              krb5_data *reply,
    217              const char *from,
    218              struct sockaddr *addr,
    219              int datagram_reply,
    220              int *claim)
    221 {
    222     if (config->enable_kaserver == 0)
    223         return -1;
    224 
    225     *claim = 1;
    226 
    227     return _kdc_do_kaserver(context, config,
    228                             req_buffer->data, req_buffer->length,
    229                             reply, from,
    230                             (struct sockaddr_in*)addr);
    231 }
    232 
    233 #endif /* KRB4 */
    234 
    235 
    236164static struct krb5_kdc_service services[] =  {
    237165    { KS_KRB5,          kdc_as_req },
    … …  
    242170#ifdef KX509
    243171    { 0,                kdc_kx509 },
    244 #endif
    245 #ifdef KRB4
    246     { 0,                kdc_524 },
    247     { KS_NO_LENGTH,     kdc_krb4 },
    248     { 0,                kdc_kaserver },
    249172#endif
    250173    { 0, NULL }

  • trunk/server/source4/heimdal/kdc/windc.c

    r414 r745  
    3434#include "kdc_locl.h"
    3535
    36 RCSID("$Id$");
    37 
    3836static krb5plugin_windc_ftable *windcft;
    3937static void *windcctx;
    … …  
    5654
    5755        windcft = _krb5_plugin_get_symbol(e);
    58         if (windcft->minor_version < KRB5_WINDC_PLUGING_MINOR)
     56        if (windcft->minor_version < KRB5_WINDC_PLUGIN_MINOR)
    5957            continue;
    6058       
    … …  
    6260        break;
    6361    }
     62    _krb5_plugin_free(list);
    6463    if (e == NULL) {
    65         _krb5_plugin_free(list);
    6664        krb5_set_error_message(context, ENOENT, "Did not find any WINDC plugin");
    6765        windcft = NULL;
    … …  
    8987                hdb_entry_ex *client,
    9088                hdb_entry_ex *server,
    91                 krb5_pac *pac)
     89                hdb_entry_ex *krbtgt,
     90                krb5_pac *pac,
     91                int *verified)
    9292{
    93     if (windcft == NULL) {
    94         krb5_set_error_message(context, EINVAL, "Can't verify PAC, no function");
    95         return EINVAL;
    96     }
    97     return (windcft->pac_verify)(windcctx, context,
    98                                  client_principal, client, server, pac);
     93    krb5_error_code ret;
     94
     95    if (windcft == NULL)
     96        return 0;
     97
     98    ret = windcft->pac_verify(windcctx, context,
     99                              client_principal, client, server, krbtgt, pac);
     100    if (ret == 0)
     101        *verified = 1;
     102    return ret;
    99103}
    100104

  • trunk/server/source4/heimdal/kdc/windc_plugin.h

    r414 r745  
    6161                               struct hdb_entry_ex *,
    6262                               struct hdb_entry_ex *,
     63                               struct hdb_entry_ex *,
    6364                               krb5_pac *);
    6465
    … …  
    7374
    7475#define KRB5_WINDC_PLUGING_MINOR                4
     76#define KRB5_WINDC_PLUGIN_MINOR                 4
    7577
    7678typedef struct krb5plugin_windc_ftable {
Note: See TracChangeset for help on using the changeset viewer.