Ignore:
Timestamp:
Nov 24, 2016, 1:14:11 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.3

Location:
vendor/current/source4/heimdal/kdc
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source4/heimdal/kdc/default_config.c

    r740 r988  
    5252    c->kdc_warn_pwexpire = 0;
    5353    c->encode_as_rep_as_tgs_rep = FALSE;
     54    c->as_use_strongest_session_key = FALSE;
     55    c->preauth_use_strongest_session_key = FALSE;
     56    c->tgs_use_strongest_session_key = FALSE;
     57    c->use_strongest_server_key = TRUE;
    5458    c->check_ticket_addresses = TRUE;
    5559    c->allow_null_ticket_addresses = TRUE;
    5660    c->allow_anonymous = FALSE;
    5761    c->trpolicy = TRPOLICY_ALWAYS_CHECK;
    58     c->enable_v4 = FALSE;
    59     c->enable_kaserver = FALSE;
    60     c->enable_524 = FALSE;
    61     c->enable_v4_cross_realm = FALSE;
    6262    c->enable_pkinit = FALSE;
    6363    c->pkinit_princ_in_cert = TRUE;
    … …  
    7171                                     c->require_preauth,
    7272                                     "kdc", "require-preauth", NULL);
    73     c->enable_v4 =
    74         krb5_config_get_bool_default(context, NULL,
    75                                      c->enable_v4,
    76                                      "kdc", "enable-kerberos4", NULL);
    77     c->enable_v4_cross_realm =
    78         krb5_config_get_bool_default(context, NULL,
    79                                      c->enable_v4_cross_realm,
    80                                      "kdc",
    81                                      "enable-kerberos4-cross-realm", NULL);
    82     c->enable_524 =
    83         krb5_config_get_bool_default(context, NULL,
    84                                      c->enable_v4,
    85                                      "kdc", "enable-524", NULL);
    8673#ifdef DIGEST
    8774    c->enable_digest =
    … …  
    133120    }
    134121#endif
     122
     123    c->as_use_strongest_session_key =
     124        krb5_config_get_bool_default(context, NULL,
     125                                     c->as_use_strongest_session_key,
     126                                     "kdc",
     127                                     "as-use-strongest-session-key", NULL);
     128    c->preauth_use_strongest_session_key =
     129        krb5_config_get_bool_default(context, NULL,
     130                                     c->preauth_use_strongest_session_key,
     131                                     "kdc",
     132                                     "preauth-use-strongest-session-key", NULL);
     133    c->tgs_use_strongest_session_key =
     134        krb5_config_get_bool_default(context, NULL,
     135                                     c->tgs_use_strongest_session_key,
     136                                     "kdc",
     137                                     "tgs-use-strongest-session-key", NULL);
     138    c->use_strongest_server_key =
     139        krb5_config_get_bool_default(context, NULL,
     140                                     c->use_strongest_server_key,
     141                                     "kdc",
     142                                     "use-strongest-server-key", NULL);
    135143
    136144    c->check_ticket_addresses =
    … …  
    181189    }
    182190
    183     {
    184         const char *p;
    185         p = krb5_config_get_string (context, NULL,
    186                                     "kdc",
    187                                     "v4-realm",
    188                                     NULL);
    189         if(p != NULL) {
    190             c->v4_realm = strdup(p);
    191             if (c->v4_realm == NULL)
    192                 krb5_errx(context, 1, "out of memory");
    193         } else {
    194             c->v4_realm = NULL;
    195         }
    196     }
    197 
    198     c->enable_kaserver =
    199         krb5_config_get_bool_default(context,
    200                                      NULL,
    201                                      c->enable_kaserver,
    202                                      "kdc", "enable-kaserver", NULL);
    203 
    204 
    205191    c->encode_as_rep_as_tgs_rep =
    206192        krb5_config_get_bool_default(context, NULL,
    … …  
    224210
    225211
    226     c->pkinit_kdc_identity = 
     212    c->pkinit_kdc_identity =
    227213        krb5_config_get_string(context, NULL,
    228214                               "kdc", "pkinit_identity", NULL);
    … …  
    236222        krb5_config_get_strings(context, NULL,
    237223                                "kdc", "pkinit_revoke", NULL);
    238     c->pkinit_kdc_ocsp_file = 
     224    c->pkinit_kdc_ocsp_file =
    239225        krb5_config_get_string(context, NULL,
    240226                               "kdc", "pkinit_kdc_ocsp", NULL);
    … …  
    273259    if (config->pkinit_kdc_identity == NULL) {
    274260        if (config->pkinit_kdc_friendly_name == NULL)
    275             config->pkinit_kdc_friendly_name = 
     261            config->pkinit_kdc_friendly_name =
    276262                strdup("O=System Identity,CN=com.apple.kerberos.kdc");
    277263        config->pkinit_kdc_identity = strdup("KEYCHAIN:");
    … …  
    285271        if (config->pkinit_kdc_identity == NULL)
    286272            krb5_errx(context, 1, "pkinit enabled but no identity");
    287  
     273
    288274        if (config->pkinit_kdc_anchors == NULL)
    289275            krb5_errx(context, 1, "pkinit enabled but no X509 anchors");
    … …  
    299285    return 0;
    300286#endif /* PKINIT */
    301 }   
     287}

  • vendor/current/source4/heimdal/kdc/digest.c

    r740 r988  
    258258    {
    259259        krb5_principal principal = NULL;
    260         const char *p, *r;
     260        const char *p, *rr;
    261261
    262262        ret = krb5_ticket_get_server(context, ticket, &principal);
    … …  
    281281            goto out;
    282282        }
    283         r = krb5_principal_get_realm(context, principal);
    284         if (r == NULL) {
     283        rr = krb5_principal_get_realm(context, principal);
     284        if (rr == NULL) {
    285285            krb5_free_principal(context, principal);
    286286            goto out;
    287287        }
    288         if (strcmp(p, r) != 0) {
     288        if (strcmp(p, rr) != 0) {
    289289            krb5_free_principal(context, principal);
    290290            goto out;
    … …  
    357357    if (ret)
    358358        goto out;
    359        
     359
    360360    ret = decode_DigestReqInner(buf.data, buf.length, &ireq, NULL);
    361361    krb5_data_free(&buf);
    … …  
    420420            r.u.initReply.nonce = s;
    421421        }
    422        
     422
    423423        ret = krb5_store_stringz(sp, r.u.initReply.nonce);
    424424        if (ret) {
    … …  
    476476        if (ret)
    477477            goto out;
    478        
     478
    479479        ASN1_MALLOC_ENCODE(Checksum, buf.data, buf.length, &res, &size, ret);
    480480        free_Checksum(&res);
    … …  
    548548            goto out;
    549549        }
    550        
     550
    551551        ret = krb5_storage_to_data(sp, &buf);
    552552        if (ret) {
    … …  
    562562            goto out;
    563563        }
    564        
     564
    565565        /*
    566566         * CHAP does the checksum of the raw nonce, but do it for all
    … …  
    569569        {
    570570            ssize_t ssize;
    571        
     571
    572572            ssize = hex_decode(ireq.u.digestRequest.serverNonce,
    573573                               serverNonce.data, serverNonce.length);
    … …  
    598598            unsigned char *p = serverNonce.data;
    599599            uint32_t t;
    600        
     600
    601601            if (serverNonce.length < 4) {
    602602                ret = EINVAL;
    … …  
    617617            unsigned char md[MD5_DIGEST_LENGTH];
    618618            char *mdx;
    619             char id;
     619            char idx;
    620620
    621621            if ((config->digests_allowed & CHAP_MD5) == 0) {
    … …  
    630630                goto out;
    631631            }
    632        
    633             if (hex_decode(*ireq.u.digestRequest.identifier, &id, 1) != 1) {
     632
     633            if (hex_decode(*ireq.u.digestRequest.identifier, &idx, 1) != 1) {
    634634                ret = EINVAL;
    635635                krb5_set_error_message(context, ret, "failed to decode identifier");
    636636                goto out;
    637637            }
    638        
     638
    639639            ret = get_password_entry(context, config,
    640640                                     ireq.u.digestRequest.username,
    … …  
    646646
    647647            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
    648             EVP_DigestUpdate(ctx, &id, 1);
     648            EVP_DigestUpdate(ctx, &idx, 1);
    649649            EVP_DigestUpdate(ctx, password, strlen(password));
    650650            EVP_DigestUpdate(ctx, serverNonce.data, serverNonce.length);
    … …  
    692692            if (ireq.u.digestRequest.realm == NULL)
    693693                goto out;
    694        
     694
    695695            ret = get_password_entry(context, config,
    696696                                     ireq.u.digestRequest.username,
    … …  
    710710            EVP_DigestUpdate(ctx, password, strlen(password));
    711711            EVP_DigestFinal_ex(ctx, md, NULL);
    712        
     712
    713713            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
    714714            EVP_DigestUpdate(ctx, md, sizeof(md));
    … …  
    732732                goto failed;
    733733            }
    734        
     734
    735735            EVP_DigestInit_ex(ctx, EVP_md5(), NULL);
    736736            EVP_DigestUpdate(ctx,
    … …  
    738738            EVP_DigestUpdate(ctx, *ireq.u.digestRequest.uri,
    739739                       strlen(*ireq.u.digestRequest.uri));
    740        
     740
    741741            /* conf|int */
    742742            if (strcmp(ireq.u.digestRequest.digest, "clear") != 0) {
    … …  
    744744                EVP_DigestUpdate(ctx, conf_zeros, sizeof(conf_zeros) - 1);
    745745            }
    746        
     746
    747747            EVP_DigestFinal_ex(ctx, md, NULL);
    748748
    … …  
    805805            struct ntlm_buf answer;
    806806            Key *key = NULL;
    807             EVP_MD_CTX *ctx;
     807            EVP_MD_CTX *ctp;
    808808
    809809            if ((config->digests_allowed & MS_CHAP_V2) == 0) {
    … …  
    817817                                       "MS-CHAP-V2 clientNonce missing");
    818818                goto failed;
    819             }   
     819            }
    820820            if (serverNonce.length != 16) {
    821821                ret = EINVAL;
    … …  
    832832                username++;
    833833
    834             ctx = EVP_MD_CTX_create();
     834            ctp = EVP_MD_CTX_create();
    835835
    836836            /* ChallangeHash */
    837             EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);
     837            EVP_DigestInit_ex(ctp, EVP_sha1(), NULL);
    838838            {
    839839                ssize_t ssize;
    840840                krb5_data clientNonce;
    841                
     841
    842842                clientNonce.length = strlen(*ireq.u.digestRequest.clientNonce);
    843843                clientNonce.data = malloc(clientNonce.length);
    … …  
    846846                    krb5_set_error_message(context, ret,
    847847                                           "malloc: out of memory");
    848                     EVP_MD_CTX_destroy(ctx);
     848                    EVP_MD_CTX_destroy(ctp);
    849849                    goto out;
    850850                }
    … …  
    856856                    krb5_set_error_message(context, ret,
    857857                                           "Failed to decode clientNonce");
    858                     EVP_MD_CTX_destroy(ctx);
     858                    EVP_MD_CTX_destroy(ctp);
    859859                    goto out;
    860860                }
    861                 EVP_DigestUpdate(ctx, clientNonce.data, ssize);
     861                EVP_DigestUpdate(ctp, clientNonce.data, ssize);
    862862                free(clientNonce.data);
    863863            }
    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);
     864            EVP_DigestUpdate(ctp, serverNonce.data, serverNonce.length);
     865            EVP_DigestUpdate(ctp, username, strlen(username));
     866
     867            EVP_DigestFinal_ex(ctp, challange, NULL);
     868
     869            EVP_MD_CTX_destroy(ctp);
    870870
    871871            /* NtPasswordHash */
    … …  
    873873            if (ret)
    874874                goto failed;
    875        
     875
    876876            ret = _kdc_db_fetch(context, config, clientprincipal,
    877877                                HDB_F_GET_CLIENT, NULL, NULL, &user);
    … …  
    901901                goto failed;
    902902            }
    903        
     903
    904904            hex_encode(answer.data, answer.length, &mdx);
    905905            if (mdx == NULL) {
    … …  
    924924            if (r.u.response.success) {
    925925                unsigned char hashhash[MD4_DIGEST_LENGTH];
    926                 EVP_MD_CTX *ctx;
    927 
    928                 ctx = EVP_MD_CTX_create();
     926                EVP_MD_CTX *ctxp;
     927
     928                ctxp = EVP_MD_CTX_create();
    929929
    930930                /* hashhash */
    931931                {
    932                     EVP_DigestInit_ex(ctx, EVP_md4(), NULL);
    933                     EVP_DigestUpdate(ctx,
     932                    EVP_DigestInit_ex(ctxp, EVP_md4(), NULL);
     933                    EVP_DigestUpdate(ctxp,
    934934                                     key->key.keyvalue.data,
    935935                                     key->key.keyvalue.length);
    936                     EVP_DigestFinal_ex(ctx, hashhash, NULL);
     936                    EVP_DigestFinal_ex(ctxp, hashhash, NULL);
    937937                }
    938938
    939939                /* GenerateAuthenticatorResponse */
    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,
     940                EVP_DigestInit_ex(ctxp, EVP_sha1(), NULL);
     941                EVP_DigestUpdate(ctxp, hashhash, sizeof(hashhash));
     942                EVP_DigestUpdate(ctxp, answer.data, answer.length);
     943                EVP_DigestUpdate(ctxp, ms_chap_v2_magic1,
    944944                                 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,
     945                EVP_DigestFinal_ex(ctxp, md, NULL);
     946
     947                EVP_DigestInit_ex(ctxp, EVP_sha1(), NULL);
     948                EVP_DigestUpdate(ctxp, md, sizeof(md));
     949                EVP_DigestUpdate(ctxp, challange, 8);
     950                EVP_DigestUpdate(ctxp, ms_chap_v2_magic2,
    951951                                 sizeof(ms_chap_v2_magic2));
    952                 EVP_DigestFinal_ex(ctx, md, NULL);
     952                EVP_DigestFinal_ex(ctxp, md, NULL);
    953953
    954954                r.u.response.rsp = calloc(1, sizeof(*r.u.response.rsp));
    … …  
    956956                    free(answer.data);
    957957                    krb5_clear_error_message(context);
    958                     EVP_MD_CTX_destroy(ctx);
     958                    EVP_MD_CTX_destroy(ctxp);
    959959                    ret = ENOMEM;
    960960                    goto out;
    … …  
    965965                    free(answer.data);
    966966                    krb5_clear_error_message(context);
    967                     EVP_MD_CTX_destroy(ctx);
     967                    EVP_MD_CTX_destroy(ctxp);
    968968                    ret = ENOMEM;
    969969                    goto out;
    … …  
    971971
    972972                /* get_master, rfc 3079 3.4 */
    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,
     973                EVP_DigestInit_ex(ctxp, EVP_sha1(), NULL);
     974                EVP_DigestUpdate(ctxp, hashhash, 16);
     975                EVP_DigestUpdate(ctxp, answer.data, answer.length);
     976                EVP_DigestUpdate(ctxp, ms_rfc3079_magic1,
    977977                                 sizeof(ms_rfc3079_magic1));
    978                 EVP_DigestFinal_ex(ctx, md, NULL);
     978                EVP_DigestFinal_ex(ctxp, md, NULL);
    979979
    980980                free(answer.data);
    981981
    982                 EVP_MD_CTX_destroy(ctx);
     982                EVP_MD_CTX_destroy(ctxp);
    983983
    984984                r.u.response.session_key =
    … …  
    11021102            goto out;
    11031103        }
    1104        
     1104
    11051105        ret = krb5_storage_write(sp, r.u.ntlmInitReply.challange.data, 8);
    11061106        if (ret != 8) {
    … …  
    11441144        Key *key = NULL;
    11451145        int version;
    1146        
     1146
    11471147        r.element = choice_DigestRepInner_ntlmResponse;
    11481148        r.u.ntlmResponse.success = 0;
    … …  
    11881188            goto out;
    11891189        }
    1190        
     1190
    11911191        ret = krb5_storage_read(sp, challange, sizeof(challange));
    11921192        if (ret != sizeof(challange)) {
    … …  
    12671267                unsigned char sessionhash[MD5_DIGEST_LENGTH];
    12681268                EVP_MD_CTX *ctx;
    1269                
     1269
    12701270                if ((config->digests_allowed & NTLM_V1_SESSION) == 0) {
    12711271                    kdc_log(context, config, 0, "NTLM v1-session not allowed");
    … …  
    12801280                    goto failed;
    12811281                }
    1282                
     1282
    12831283                ctx = EVP_MD_CTX_create();
    12841284
    … …  
    12981298                }
    12991299            }
    1300        
     1300
    13011301            ret = heim_ntlm_calculate_ntlm1(key->key.keyvalue.data,
    13021302                                            key->key.keyvalue.length,
    … …  
    13061306                goto failed;
    13071307            }
    1308        
     1308
    13091309            if (ireq.u.ntlmRequest.ntlm.length != answer.length ||
    13101310                memcmp(ireq.u.ntlmRequest.ntlm.data, answer.data, answer.length) != 0)
    … …  
    13361336            EVP_CIPHER_CTX rc4;
    13371337            size_t len;
    1338        
     1338
    13391339            if ((flags & NTLM_NEG_KEYEX) == 0) {
    13401340                ret = EINVAL;
    … …  
    13441344                goto failed;
    13451345            }
    1346        
     1346
    13471347            len = ireq.u.ntlmRequest.sessionkey->length;
    13481348            if (len != sizeof(masterkey)){
    … …  
    13531353                goto failed;
    13541354            }
    1355        
     1355
    13561356
    13571357            EVP_CIPHER_CTX_init(&rc4);
    … …  
    13611361                       sizeof(masterkey));
    13621362            EVP_CIPHER_CTX_cleanup(&rc4);
    1363        
     1363
    13641364            r.u.ntlmResponse.sessionkey =
    13651365                malloc(sizeof(*r.u.ntlmResponse.sessionkey));
    … …  
    13691369                goto out;
    13701370            }
    1371        
     1371
    13721372            ret = krb5_data_copy(r.u.ntlmResponse.sessionkey,
    13731373                                 masterkey, sizeof(masterkey));
    … …  
    14161416            goto out;
    14171417        }
    1418        
     1418
    14191419        kdc_log(context, config, 0, "Digest failed with: %s", s);
    14201420

  • vendor/current/source4/heimdal/kdc/kdc.h

    r740 r988  
    5959
    6060    krb5_boolean encode_as_rep_as_tgs_rep; /* bug compatibility */
    61        
     61
     62    krb5_boolean as_use_strongest_session_key;
     63    krb5_boolean preauth_use_strongest_session_key;
     64    krb5_boolean tgs_use_strongest_session_key;
     65    krb5_boolean use_strongest_server_key;
     66
    6267    krb5_boolean check_ticket_addresses;
    6368    krb5_boolean allow_null_ticket_addresses;
    6469    krb5_boolean allow_anonymous;
    6570    enum krb5_kdc_trpolicy trpolicy;
    66 
    67     char *v4_realm;
    68     krb5_boolean enable_v4;
    69     krb5_boolean enable_v4_cross_realm;
    70     krb5_boolean enable_v4_per_principal;
    71 
    72     krb5_boolean enable_kaserver;
    73 
    74     krb5_boolean enable_524;
    7571
    7672    krb5_boolean enable_pkinit;

  • vendor/current/source4/heimdal/kdc/kerberos5.c

    r740 r988  
    7575        return NULL;
    7676
    77     while(*start < req->padata->len){
     77    while((size_t)*start < req->padata->len){
    7878        (*start)++;
    79         if(req->padata->val[*start - 1].padata_type == type)
     79        if(req->padata->val[*start - 1].padata_type == (unsigned)type)
    8080            return &req->padata->val[*start - 1];
    8181    }
    … …  
    124124
    125125krb5_error_code
    126 _kdc_find_etype(krb5_context context, const hdb_entry_ex *princ,
     126_kdc_find_etype(krb5_context context, krb5_boolean use_strongest_session_key,
     127                krb5_boolean is_preauth, hdb_entry_ex *princ,
    127128                krb5_enctype *etypes, unsigned len,
    128                 Key **ret_key)
    129 {
     129                krb5_enctype *ret_enctype, Key **ret_key)
     130{
     131    krb5_error_code ret;
     132    krb5_salt def_salt;
     133    krb5_enctype enctype = ETYPE_NULL;
     134    Key *key;
    130135    int i;
    131     krb5_error_code ret = KRB5KDC_ERR_ETYPE_NOSUPP;
    132     krb5_salt def_salt;
    133 
    134     krb5_get_pw_salt (context, princ->entry.principal, &def_salt);
    135 
    136     for(i = 0; ret != 0 && i < len ; i++) {
    137         Key *key = NULL;
    138 
    139         if (krb5_enctype_valid(context, etypes[i]) != 0 &&
    140             !_kdc_is_weak_exception(princ->entry.principal, etypes[i]))
    141             continue;
    142 
    143         while (hdb_next_enctype2key(context, &princ->entry, etypes[i], &key) == 0) {
    144             if (key->key.keyvalue.length == 0) {
    145                 ret = KRB5KDC_ERR_NULL_KEY;
     136
     137    /* We'll want to avoid keys with v4 salted keys in the pre-auth case... */
     138    ret = krb5_get_pw_salt(context, princ->entry.principal, &def_salt);
     139    if (ret)
     140        return ret;
     141
     142    ret = KRB5KDC_ERR_ETYPE_NOSUPP;
     143
     144    if (use_strongest_session_key) {
     145        const krb5_enctype *p;
     146        krb5_enctype clientbest = ETYPE_NULL;
     147        int j;
     148
     149        /*
     150         * Pick the strongest key that the KDC, target service, and
     151         * client all support, using the local cryptosystem enctype
     152         * list in strongest-to-weakest order to drive the search.
     153         *
     154         * This is not what RFC4120 says to do, but it encourages
     155         * adoption of stronger enctypes.  This doesn't play well with
     156         * clients that have multiple Kerberos client implementations
     157         * available with different supported enctype lists.
     158         */
     159
     160        /* drive the search with local supported enctypes list */
     161        p = krb5_kerberos_enctypes(context);
     162        for (i = 0; p[i] != ETYPE_NULL && enctype == ETYPE_NULL; i++) {
     163            if (krb5_enctype_valid(context, p[i]) != 0)
    146164                continue;
     165
     166            /* check that the client supports it too */
     167            for (j = 0; j < len && enctype == ETYPE_NULL; j++) {
     168                if (p[i] != etypes[j])
     169                    continue;
     170                /* save best of union of { client, crypto system } */
     171                if (clientbest == ETYPE_NULL)
     172                    clientbest = p[i];
     173                /* check target princ support */
     174                ret = hdb_enctype2key(context, &princ->entry, p[i], &key);
     175                if (ret)
     176                    continue;
     177                if (is_preauth && !is_default_salt_p(&def_salt, key))
     178                    continue;
     179                enctype = p[i];
    147180            }
    148             *ret_key   = key;
    149             ret = 0;
    150             if (is_default_salt_p(&def_salt, key)) {
    151                 krb5_free_salt (context, def_salt);
    152                 return ret;
     181        }
     182        if (clientbest != ETYPE_NULL && enctype == ETYPE_NULL)
     183            enctype = clientbest;
     184        else if (enctype == ETYPE_NULL)
     185            ret = KRB5KDC_ERR_ETYPE_NOSUPP;
     186        if (ret == 0 && ret_enctype != NULL)
     187            *ret_enctype = enctype;
     188        if (ret == 0 && ret_key != NULL)
     189            *ret_key = key;
     190    } else {
     191        /*
     192         * Pick the first key from the client's enctype list that is
     193         * supported by the cryptosystem and by the given principal.
     194         *
     195         * RFC4120 says we SHOULD pick the first _strong_ key from the
     196         * client's list... not the first key...  If the admin disallows
     197         * weak enctypes in krb5.conf and selects this key selection
     198         * algorithm, then we get exactly what RFC4120 says.
     199         */
     200        for(key = NULL, i = 0; ret != 0 && i < len; i++, key = NULL) {
     201
     202            if (krb5_enctype_valid(context, etypes[i]) != 0 &&
     203                !_kdc_is_weak_exception(princ->entry.principal, etypes[i]))
     204                continue;
     205
     206            while (hdb_next_enctype2key(context, &princ->entry, etypes[i], &key) == 0) {
     207                if (key->key.keyvalue.length == 0) {
     208                    ret = KRB5KDC_ERR_NULL_KEY;
     209                    continue;
     210                }
     211                if (ret_key != NULL)
     212                    *ret_key = key;
     213                if (ret_enctype != NULL)
     214                    *ret_enctype = etypes[i];
     215                ret = 0;
     216                if (is_preauth && is_default_salt_p(&def_salt, key))
     217                    goto out;
    153218            }
    154219        }
    155220    }
     221
     222out:
    156223    krb5_free_salt (context, def_salt);
    157224    return ret;
    … …  
    212279    struct rk_strpool *p = NULL;
    213280    char *str;
    214     int i;
    215        
     281    size_t i;
     282
    216283    for (i = 0; i < padata->len; i++) {
    217284        switch(padata->val[i].padata_type) {
    … …  
    241308    if (p == NULL)
    242309        p = rk_strpoolprintf(p, "none");
    243        
     310
    244311    str = rk_strpoolcollect(p);
    245312    kdc_log(context, config, 0, "Client sent patypes: %s", str);
    … …  
    265332    unsigned char *buf;
    266333    size_t buf_size;
    267     size_t len;
     334    size_t len = 0;
    268335    krb5_error_code ret;
    269336    krb5_crypto crypto;
    … …  
    615682    struct rk_strpool *p;
    616683    char *str;
    617     int i;
     684    size_t i;
    618685
    619686    p = rk_strpoolprintf(NULL, "%s", "Client supported enctypes: ");
    … …  
    687754            kdc_log(context, config, 0,
    688755                    "Client (%s) is locked out", client_name);
    689             return KRB5KDC_ERR_POLICY;
     756            return KRB5KDC_ERR_CLIENT_REVOKED;
    690757        }
    691758
    … …  
    695762            return KRB5KDC_ERR_POLICY;
    696763        }
    697        
     764
    698765        if(!client->flags.client){
    699766            kdc_log(context, config, 0,
    … …  
    701768            return KRB5KDC_ERR_POLICY;
    702769        }
    703        
     770
    704771        if (client->valid_start && *client->valid_start > kdc_time) {
    705772            char starttime_str[100];
    … …  
    711778            return KRB5KDC_ERR_CLIENT_NOTYET;
    712779        }
    713        
     780
    714781        if (client->valid_end && *client->valid_end < kdc_time) {
    715782            char endtime_str[100];
    … …  
    721788            return KRB5KDC_ERR_NAME_EXP;
    722789        }
    723        
     790
    724791        if (client->pw_end && *client->pw_end < kdc_time
    725792            && (server_ex == NULL || !server_ex->entry.flags.change_pw)) {
    … …  
    810877    krb5_boolean result;
    811878    krb5_boolean only_netbios = TRUE;
    812     int i;
     879    size_t i;
    813880
    814881    if(config->check_ticket_addresses == 0)
    … …  
    912979    Key *ckey, *skey;
    913980    EncryptionKey *reply_key = NULL, session_key;
    914     int flags = 0;
     981    int flags = HDB_F_FOR_AS_REQ;
    915982#ifdef PKINIT
    916983    pk_client_params *pkp = NULL;
    … …  
    9771044        }
    9781045    } else if (b->kdc_options.request_anonymous) {
    979         kdc_log(context, config, 0, 
     1046        kdc_log(context, config, 0,
    9801047                "Request for a anonymous ticket with non "
    9811048                "anonymous client name: %s", client_name);
    … …  
    9941061        kdc_log(context, config, 5, "client %s does not have secrets at this KDC, need to proxy", client_name);
    9951062        goto out;
     1063    } else if (ret == HDB_ERR_WRONG_REALM) {
     1064        char *fixed_client_name = NULL;
     1065
     1066        ret = krb5_unparse_name(context, client->entry.principal,
     1067                                &fixed_client_name);
     1068        if (ret) {
     1069            goto out;
     1070        }
     1071
     1072        kdc_log(context, config, 0, "WRONG_REALM - %s -> %s",
     1073                client_name, fixed_client_name);
     1074        free(fixed_client_name);
     1075
     1076        ret = krb5_mk_error_ext(context,
     1077                                KRB5_KDC_ERR_WRONG_REALM,
     1078                                NULL, /* e_text */
     1079                                NULL, /* e_data */
     1080                                server_princ,
     1081                                NULL, /* client_name */
     1082                                &client->entry.principal->realm,
     1083                                NULL, /* client_time */
     1084                                NULL, /* client_usec */
     1085                                reply);
     1086        goto out;
    9961087    } else if(ret){
    9971088        const char *msg = krb5_get_error_message(context, ret);
    … …  
    10191110
    10201111    /*
    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.
     1112     * Select a session enctype from the list of the crypto system
     1113     * supported enctypes that is supported by the client and is one of
     1114     * the enctype of the enctype of the service (likely krbtgt).
    10241115     *
    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
     1116     * The latter is used as a hint of what enctypes all KDC support,
     1117     * to make sure a newer version of KDC won't generate a session
     1118     * enctype that an older version of a KDC in the same realm can't
    10281119     * decrypt.
    1029      *
    1030      * But if the KDC admin is paranoid and doesn't want to have "no
     1120     */
     1121    ret = _kdc_find_etype(context, config->as_use_strongest_session_key, FALSE,
     1122                          client, b->etype.val, b->etype.len, &sessionetype,
     1123                          NULL);
     1124    if (ret) {
     1125        kdc_log(context, config, 0,
     1126                "Client (%s) from %s has no common enctypes with KDC "
     1127                "to use for the session key",
     1128                client_name, from);
     1129        goto out;
     1130    }
     1131    /*
     1132     * But if the KDC admin is paranoid and doesn't want to have "not
    10311133     * the best" enctypes on the krbtgt, lets save the best pick from
    10321134     * the client list and hope that that will work for any other
    10331135     * KDCs.
    10341136     */
    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         }
    1073     }
    10741137
    10751138    /*
    … …  
    11121175            ret = _kdc_pk_check_client(context,
    11131176                                       config,
    1114                                        clientdb, 
     1177                                       clientdb,
    11151178                                       client,
    11161179                                       pkp,
    … …  
    11201183                    "impersonate principal";
    11211184                _kdc_pk_free_client_param(context, pkp);
    1122                
     1185
    11231186                kdc_log(context, config, 0, "%s", e_text);
    11241187                pkp = NULL;
    … …  
    11371200    ts_enc:
    11381201#endif
     1202
     1203        if (client->entry.flags.locked_out) {
     1204            ret = KRB5KDC_ERR_CLIENT_REVOKED;
     1205            kdc_log(context, config, 0,
     1206                    "Client (%s) is locked out", client_name);
     1207            goto out;
     1208        }
     1209
    11391210        kdc_log(context, config, 5, "Looking for ENC-TS pa-data -- %s",
    11401211                client_name);
    … …  
    11491220            Key *pa_key;
    11501221            char *str;
    1151        
     1222
    11521223            found_pa = 1;
    1153        
     1224
    11541225            if (b->kdc_options.request_anonymous) {
    11551226                ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
    … …  
    11681239                goto out;
    11691240            }
    1170        
     1241
    11711242            ret = hdb_enctype2key(context, &client->entry,
    11721243                                  enc_data.etype, &pa_key);
    … …  
    12571328            if (abs(kdc_time - p.patimestamp) > context->max_skew) {
    12581329                char client_time[100];
    1259                
     1330
    12601331                krb5_format_time(context, p.patimestamp,
    12611332                                 client_time, sizeof(client_time), TRUE);
    … …  
    13541425         * If there is a client key, send ETYPE_INFO{,2}
    13551426         */
    1356         ret = _kdc_find_etype(context, client, b->etype.val, b->etype.len,
    1357                               &ckey);
     1427        ret = _kdc_find_etype(context,
     1428                              config->preauth_use_strongest_session_key, TRUE,
     1429                              client, b->etype.val, b->etype.len, NULL, &ckey);
    13581430        if (ret == 0) {
    13591431
    … …  
    13851457            }
    13861458        }
    1387        
     1459
    13881460        ASN1_MALLOC_ENCODE(METHOD_DATA, buf, len, &method_data, &len, ret);
    13891461        free_METHOD_DATA(&method_data);
    … …  
    14001472        goto out;
    14011473    }
    1402 
    1403     if (clientdb->hdb_auth_status)
    1404         (clientdb->hdb_auth_status)(context, clientdb, client,
    1405                                     HDB_AUTH_SUCCESS);
    14061474
    14071475    /*
    … …  
    14151483    if(ret)
    14161484        goto out;
     1485
     1486    if (clientdb->hdb_auth_status)
     1487        (clientdb->hdb_auth_status)(context, clientdb, client,
     1488                                    HDB_AUTH_SUCCESS);
    14171489
    14181490    /*
    … …  
    15041576        time_t start;
    15051577        time_t t;
    1506        
     1578
    15071579        start = et.authtime = kdc_time;
    15081580
    … …  
    16591731        goto out;
    16601732
    1661     /* Add signing of alias referral */
    1662     if (f.canonicalize) {
    1663         PA_ClientCanonicalized canon;
    1664         krb5_data data;
    1665         PA_DATA pa;
    1666         krb5_crypto crypto;
    1667         size_t len;
    1668 
    1669         memset(&canon, 0, sizeof(canon));
    1670 
    1671         canon.names.requested_name = *b->cname;
    1672         canon.names.mapped_name = client->entry.principal->name;
    1673 
    1674         ASN1_MALLOC_ENCODE(PA_ClientCanonicalizedNames, data.data, data.length,
    1675                            &canon.names, &len, ret);
    1676         if (ret)
    1677             goto out;
    1678         if (data.length != len)
    1679             krb5_abortx(context, "internal asn.1 error");
    1680 
    1681         /* sign using "returned session key" */
    1682         ret = krb5_crypto_init(context, &et.key, 0, &crypto);
    1683         if (ret) {
    1684             free(data.data);
    1685             goto out;
    1686         }
    1687 
    1688         ret = krb5_create_checksum(context, crypto,
    1689                                    KRB5_KU_CANONICALIZED_NAMES, 0,
    1690                                    data.data, data.length,
    1691                                    &canon.canon_checksum);
    1692         free(data.data);
    1693         krb5_crypto_destroy(context, crypto);
    1694         if (ret)
    1695             goto out;
    1696        
    1697         ASN1_MALLOC_ENCODE(PA_ClientCanonicalized, data.data, data.length,
    1698                            &canon, &len, ret);
    1699         free_Checksum(&canon.canon_checksum);
    1700         if (ret)
    1701             goto out;
    1702         if (data.length != len)
    1703             krb5_abortx(context, "internal asn.1 error");
    1704 
    1705         pa.padata_type = KRB5_PADATA_CLIENT_CANONICALIZED;
    1706         pa.padata_value = data;
    1707         ret = add_METHOD_DATA(rep.padata, &pa);
    1708         free(data.data);
    1709         if (ret)
    1710             goto out;
    1711     }
    1712 
    17131733    if (rep.padata->len == 0) {
    17141734        free(rep.padata);
    … …  
    17841804out:
    17851805    free_AS_REP(&rep);
    1786     if(ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE){
     1806    if(ret != 0 && ret != HDB_ERR_NOT_FOUND_HERE && reply->length == 0) {
    17871807        krb5_mk_error(context,
    17881808                      ret,
    … …  
    18271847{
    18281848    krb5_error_code ret;
    1829     size_t size;
     1849    size_t size = 0;
    18301850
    18311851    if (tkt->authorization_data == NULL) {
    … …  
    18361856        }
    18371857    }
    1838        
     1858
    18391859    /* add the entry to the last element */
    18401860    {
    … …  
    18641884        if (ade.ad_data.length != size)
    18651885            krb5_abortx(context, "internal asn.1 encoder error");
    1866        
     1886
    18671887        ret = add_AuthorizationData(tkt->authorization_data, &ade);
    18681888        der_free_octet_string(&ade.ad_data);

  • vendor/current/source4/heimdal/kdc/krb5tgs.c

    r740 r988  
    6565    krb5_error_code ret;
    6666    int pos;
    67        
     67
    6868    if (ad == NULL || ad->len == 0)
    6969        return KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
    … …  
    114114    krb5_data data;
    115115    krb5_crypto crypto = NULL;
    116     size_t size;
     116    size_t size = 0;
    117117
    118118    if (server && principals) {
    … …  
    124124    {
    125125        KRB5SignedPathData spd;
    126        
     126
    127127        spd.client = client;
    128128        spd.authtime = tkt->authtime;
    129129        spd.delegated = principals;
    130130        spd.method_data = NULL;
    131        
     131
    132132        ASN1_MALLOC_ENCODE(KRB5SignedPathData, data.data, data.length,
    133133                           &spd, &size, ret);
    … …  
    204204        KRB5SignedPathData spd;
    205205        KRB5SignedPath sp;
    206         size_t size;
     206        size_t size = 0;
    207207
    208208        ret = decode_KRB5SignedPath(data.data, data.length, &sp, NULL);
    … …  
    280280          krb5_kdc_configuration *config,
    281281          const krb5_principal client_principal,
     282          const krb5_principal delegated_proxy_principal,
    282283          hdb_entry_ex *client,
    283284          hdb_entry_ex *server,
    284285          hdb_entry_ex *krbtgt,
    285           const EncryptionKey *server_key,
    286           const EncryptionKey *krbtgt_check_key,
     286          const EncryptionKey *server_check_key,
     287          const EncryptionKey *server_sign_key,
    287288          const EncryptionKey *krbtgt_sign_key,
    288289          EncTicketPart *tkt,
    … …  
    329330                ret = krb5_pac_verify(context, pac, tkt->authtime,
    330331                                      client_principal,
    331                                       krbtgt_check_key, NULL);
     332                                      server_check_key, NULL);
    332333                if (ret) {
    333334                    krb5_pac_free(context, pac);
    … …  
    336337
    337338                ret = _kdc_pac_verify(context, client_principal,
     339                                      delegated_proxy_principal,
    338340                                      client, server, krbtgt, &pac, &signed_pac);
    339341                if (ret) {
    … …  
    352354                    ret = _krb5_pac_sign(context, pac, tkt->authtime,
    353355                                         client_principal,
    354                                          server_key, krbtgt_sign_key, rspac);
     356                                         server_sign_key, krbtgt_sign_key, rspac);
    355357                }
    356358                krb5_pac_free(context, pac);
    357                
     359
    358360                return ret;
    359361            }
    … …  
    374376{
    375377    KDCOptions f = b->kdc_options;
    376        
     378
    377379    if(f.validate){
    378380        if(!tgt->flags.invalid || tgt->starttime == NULL){
    … …  
    413415    if(tgt->flags.forwarded)
    414416        et->flags.forwarded = 1;
    415        
     417
    416418    if(f.proxiable){
    417419        if(!tgt->flags.proxiable){
    … …  
    483485        if (et->renew_till != NULL)
    484486            et->endtime = min(*et->renew_till, et->endtime);
    485     }   
     487    }
    486488
    487489#if 0
    … …  
    505507                             HDB *clientdb,
    506508                             hdb_entry_ex *client,
    507                              krb5_const_principal server)
     509                             hdb_entry_ex *server,
     510                             krb5_const_principal target)
    508511{
    509512    const HDB_Ext_Constrained_delegation_acl *acl;
    510513    krb5_error_code ret;
    511     int i;
    512 
    513     /* if client delegates to itself, that ok */
    514     if (krb5_principal_compare(context, client->entry.principal, server) == TRUE)
    515         return 0;
     514    size_t i;
     515
     516    /*
     517     * constrained_delegation (S4U2Proxy) only works within
     518     * the same realm. We use the already canonicalized version
     519     * of the principals here, while "target" is the principal
     520     * provided by the client.
     521     */
     522    if(!krb5_realm_compare(context, client->entry.principal, server->entry.principal)) {
     523        ret = KRB5KDC_ERR_BADOPTION;
     524        kdc_log(context, config, 0,
     525            "Bad request for constrained delegation");
     526        return ret;
     527    }
    516528
    517529    if (clientdb->hdb_check_constrained_delegation) {
    518         ret = clientdb->hdb_check_constrained_delegation(context, clientdb, client, server);
     530        ret = clientdb->hdb_check_constrained_delegation(context, clientdb, client, target);
    519531        if (ret == 0)
    520532            return 0;
    521533    } else {
     534        /* if client delegates to itself, that ok */
     535        if (krb5_principal_compare(context, client->entry.principal, server->entry.principal) == TRUE)
     536            return 0;
     537
    522538        ret = hdb_entry_get_ConstrainedDelegACL(&client->entry, &acl);
    523539        if (ret) {
    … …  
    525541            return ret;
    526542        }
    527        
     543
    528544        if (acl) {
    529545            for (i = 0; i < acl->len; i++) {
    530                 if (krb5_principal_compare(context, server, &acl->val[i]) == TRUE)
     546                if (krb5_principal_compare(context, target, &acl->val[i]) == TRUE)
    531547                    return 0;
    532548            }
    … …  
    607623    char **realms, **tmp;
    608624    unsigned int num_realms;
    609     int i;
     625    size_t i;
    610626
    611627    switch (tr->tr_type) {
    … …  
    827843        *et.renew_till = et.authtime + renew;
    828844    }
    829        
     845
    830846    if(et.renew_till){
    831847        *et.renew_till = min(*et.renew_till, *tgt->renew_till);
    … …  
    861877            goto out;
    862878    }
    863        
     879
    864880    if (auth_data) {
    865881        unsigned int i = 0;
    … …  
    901917    if (ret)
    902918        goto out;
    903     et.crealm = tgt->crealm;
     919    et.crealm = tgt_name->realm;
    904920    et.cname = tgt_name->name;
    905        
     921
    906922    ek.key = et.key;
    907923    /* MIT must have at least one last_req */
    … …  
    10051021{
    10061022    krb5_authenticator auth;
    1007     size_t len;
     1023    size_t len = 0;
    10081024    unsigned char *buf;
    10091025    size_t buf_size;
    … …  
    10321048        goto out;
    10331049    }
    1034                
     1050
    10351051    /* XXX should not re-encode this */
    10361052    ASN1_MALLOC_ENCODE(KDC_REQ_BODY, buf, buf_size, b, &len, ret);
    … …  
    10911107    return new_realm;
    10921108}
    1093        
     1109
    10941110
    10951111static krb5_boolean
    … …  
    11051121    if (server->name.name_string.len == 1)
    11061122        name = server->name.name_string.val[0];
    1107     else if (server->name.name_string.len > 1)
     1123    else if (server->name.name_string.len == 3) {
     1124        /*
     1125          This is used to give referrals for the
     1126          E3514235-4B06-11D1-AB04-00C04FC2DCD2/NTDSGUID/DNSDOMAIN
     1127          SPN form, which is used for inter-domain communication in AD
     1128         */
     1129        name = server->name.name_string.val[2];
     1130        kdc_log(context, config, 0, "Giving 3 part referral for %s", name);
     1131        *realms = malloc(sizeof(char *)*2);
     1132        if (*realms == NULL) {
     1133            krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
     1134            return FALSE;
     1135        }
     1136        (*realms)[0] = strdup(name);
     1137        (*realms)[1] = NULL;
     1138        return TRUE;
     1139    } else if (server->name.name_string.len > 1)
    11081140        name = server->name.name_string.val[1];
    11091141    else
    … …  
    11321164                  int *rk_is_subkey)
    11331165{
     1166    static char failed[] = "<unparse_name failed>";
    11341167    krb5_ap_req ap_req;
    11351168    krb5_error_code ret;
    … …  
    11751208        ret = krb5_unparse_name(context, princ, &p);
    11761209        if (ret != 0)
    1177             p = "<unparse_name failed>";
     1210            p = failed;
    11781211        krb5_free_principal(context, princ);
    11791212        kdc_log(context, config, 5, "Ticket-granting ticket account %s does not have secrets at this KDC, need to proxy", p);
    … …  
    11871220        ret = krb5_unparse_name(context, princ, &p);
    11881221        if (ret != 0)
    1189             p = "<unparse_name failed>";
     1222            p = failed;
    11901223        krb5_free_principal(context, princ);
    11911224        kdc_log(context, config, 0,
    … …  
    12051238        krb5_free_principal(context, princ);
    12061239        if (ret != 0)
    1207             p = "<unparse_name failed>";
     1240            p = failed;
    12081241        kdc_log(context, config, 0,
    12091242                "Ticket kvno = %d, DB kvno = %d (%s)",
    … …  
    12501283                              ticket,
    12511284                              KRB5_KU_TGS_REQ_AUTH);
    1252                        
     1285
    12531286    krb5_free_principal(context, princ);
    12541287    if(ret) {
    … …  
    13801413                      const PrincipalName *requested_principal,
    13811414                      krb5_data *outdata)
    1382 {               
     1415{
    13831416    PA_ServerReferralData ref;
    13841417    krb5_error_code ret;
    13851418    EncryptedData ed;
    13861419    krb5_data data;
    1387     size_t size;
     1420    size_t size = 0;
    13881421
    13891422    memset(&ref, 0, sizeof(ref));
    … …  
    14651498{
    14661499    krb5_error_code ret;
    1467     krb5_principal cp = NULL, sp = NULL;
    1468     krb5_principal client_principal = NULL;
     1500    krb5_principal cp = NULL, sp = NULL, tp = NULL, dp = NULL;
    14691501    krb5_principal krbtgt_principal = NULL;
    1470     char *spn = NULL, *cpn = NULL;
     1502    char *spn = NULL, *cpn = NULL, *tpn = NULL, *dpn = NULL;
    14711503    hdb_entry_ex *server = NULL, *client = NULL, *s4u2self_impersonated_client = NULL;
    14721504    HDB *clientdb, *s4u2self_impersonated_clientdb;
    … …  
    14921524    Key *tkey_check;
    14931525    Key *tkey_sign;
     1526    int flags = HDB_F_FOR_TGS_REQ;
    14941527
    14951528    memset(&sessionkey, 0, sizeof(sessionkey));
    … …  
    15001533    s = b->sname;
    15011534    r = b->realm;
     1535
     1536    if (b->kdc_options.canonicalize)
     1537        flags |= HDB_F_CANON;
    15021538
    15031539    if(b->kdc_options.enc_tkt_in_skey){
    … …  
    15061542        krb5_principal p;
    15071543        Key *uukey;
    1508        
     1544
    15091545        if(b->additional_tickets == NULL ||
    15101546           b->additional_tickets->len == 0){
    … …  
    15521588
    15531589    _krb5_principalname2krb5_principal(context, &sp, *s, r);
    1554     ret = krb5_unparse_name(context, sp, &spn); 
     1590    ret = krb5_unparse_name(context, sp, &spn);
    15551591    if (ret)
    15561592        goto out;
    … …  
    15751611
    15761612server_lookup:
    1577     ret = _kdc_db_fetch(context, config, sp, HDB_F_GET_SERVER | HDB_F_CANON,
     1613    ret = _kdc_db_fetch(context, config, sp, HDB_F_GET_SERVER | flags,
    15781614                        NULL, NULL, &server);
    15791615
    … …  
    15811617        kdc_log(context, config, 5, "target %s does not have secrets at this KDC, need to proxy", sp);
    15821618        goto out;
     1619    } else if (ret == HDB_ERR_WRONG_REALM) {
     1620        if (ref_realm)
     1621            free(ref_realm);
     1622        ref_realm = strdup(server->entry.principal->realm);
     1623        if (ref_realm == NULL) {
     1624            ret = ENOMEM;
     1625            goto out;
     1626        }
     1627
     1628        kdc_log(context, config, 5,
     1629                "Returning a referral to realm %s for "
     1630                "server %s.",
     1631                ref_realm, spn);
     1632        krb5_free_principal(context, sp);
     1633        sp = NULL;
     1634        free(spn);
     1635        spn = NULL;
     1636        ret = krb5_make_principal(context, &sp, r, KRB5_TGS_NAME,
     1637                                  ref_realm, NULL);
     1638        if (ret)
     1639            goto out;
     1640        ret = krb5_unparse_name(context, sp, &spn);
     1641        if (ret)
     1642            goto out;
     1643
     1644        goto server_lookup;
    15831645    } else if(ret){
    15841646        const char *new_rlm, *msg;
    … …  
    15971659                    krb5_make_principal(context, &sp, r,
    15981660                                        KRB5_TGS_NAME, new_rlm, NULL);
    1599                     ret = krb5_unparse_name(context, sp, &spn); 
     1661                    ret = krb5_unparse_name(context, sp, &spn);
    16001662                    if (ret)
    16011663                        goto out;
    … …  
    16471709
    16481710        if(b->kdc_options.enc_tkt_in_skey) {
    1649             int i;
     1711            size_t i;
    16501712            ekey = &adtkt.key;
    16511713            for(i = 0; i < b->etype.len; i++)
    … …  
    16631725        } else {
    16641726            Key *skey;
    1665        
    1666             ret = _kdc_find_etype(context, server,
    1667                                   b->etype.val, b->etype.len, &skey);
     1727
     1728            ret = _kdc_find_etype(context,
     1729                                  config->tgs_use_strongest_session_key, FALSE,
     1730                                  server, b->etype.val, b->etype.len, NULL,
     1731                                  &skey);
    16681732            if(ret) {
    16691733                kdc_log(context, config, 0,
    … …  
    16751739            kvno = server->entry.kvno;
    16761740        }
    1677        
     1741
    16781742        ret = krb5_generate_random_keyblock(context, etype, &sessionkey);
    16791743        if (ret)
    … …  
    17021766     * sign check may have been on an old kvno, and the server may
    17031767     * have been an incoming trust) */
    1704     ret = krb5_make_principal(context, &krbtgt_principal, 
     1768    ret = krb5_make_principal(context, &krbtgt_principal,
    17051769                              krb5_principal_get_comp_string(context,
    17061770                                                             krbtgt->entry.principal,
    17071771                                                             1),
    1708                               KRB5_TGS_NAME, 
     1772                              KRB5_TGS_NAME,
    17091773                              krb5_principal_get_comp_string(context,
    17101774                                                             krbtgt->entry.principal,
    … …  
    17201784    if (ret) {
    17211785        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);
     1786        char *ktpn, *ktpn2;
     1787        ret = krb5_unparse_name(context, krbtgt->entry.principal, &ktpn);
     1788        ret2 = krb5_unparse_name(context, krbtgt_principal, &ktpn2);
    17251789        kdc_log(context, config, 0,
    17261790                "Request with wrong krbtgt: %s, %s not found in our database",
    1727                 (ret == 0) ? tpn : "<unknown>", (ret2 == 0) ? tpn2 : "<unknown>");
     1791                (ret == 0) ? ktpn : "<unknown>", (ret2 == 0) ? ktpn2 : "<unknown>");
    17281792        if(ret == 0)
    1729             free(tpn);
     1793            free(ktpn);
    17301794        if(ret2 == 0)
    1731             free(tpn2);
     1795            free(ktpn2);
    17321796        ret = KRB5KRB_AP_ERR_NOT_US;
    17331797        goto out;
    … …  
    17411805    if (strcmp(krb5_principal_get_realm(context, server->entry.principal),
    17421806               krb5_principal_get_realm(context, krbtgt_out->entry.principal)) != 0) {
    1743         char *tpn;
    1744         ret = krb5_unparse_name(context, krbtgt_out->entry.principal, &tpn);
     1807        char *ktpn;
     1808        ret = krb5_unparse_name(context, krbtgt_out->entry.principal, &ktpn);
    17451809        kdc_log(context, config, 0,
    17461810                "Request with wrong krbtgt: %s",
    1747                 (ret == 0) ? tpn : "<unknown>");
     1811                (ret == 0) ? ktpn : "<unknown>");
    17481812        if(ret == 0)
    1749             free(tpn);
     1813            free(ktpn);
    17501814        ret = KRB5KRB_AP_ERR_NOT_US;
    17511815    }
    … …  
    17591823    }
    17601824
    1761     ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | HDB_F_CANON,
     1825    ret = _kdc_db_fetch(context, config, cp, HDB_F_GET_CLIENT | flags,
    17621826                        NULL, &clientdb, &client);
    17631827    if(ret == HDB_ERR_NOT_FOUND_HERE) {
    … …  
    17891853    }
    17901854
    1791     ret = check_PAC(context, config, cp,
    1792                     client, server, krbtgt, ekey, &tkey_check->key, &tkey_sign->key,
     1855    ret = check_PAC(context, config, cp, NULL,
     1856                    client, server, krbtgt,
     1857                    &tkey_check->key,
     1858                    ekey, &tkey_sign->key,
    17931859                    tgt, &rspac, &signedpath);
    17941860    if (ret) {
    … …  
    18221888     */
    18231889
    1824     client_principal = cp;
     1890    /* by default the tgt principal matches the client principal */
     1891    tp = cp;
     1892    tpn = cpn;
    18251893
    18261894    if (client) {
    … …  
    18331901            krb5_data datack;
    18341902            PA_S4U2Self self;
    1835             char *selfcpn = NULL;
    18361903            const char *str;
    18371904
    … …  
    18761943
    18771944            ret = _krb5_principalname2krb5_principal(context,
    1878                                                      &client_principal,
     1945                                                     &tp,
    18791946                                                     self.name,
    18801947                                                     self.realm);
    … …  
    18831950                goto out;
    18841951
    1885             ret = krb5_unparse_name(context, client_principal, &selfcpn);       
     1952            ret = krb5_unparse_name(context, tp, &tpn);
    18861953            if (ret)
    18871954                goto out;
    … …  
    18911958                krb5_pac p = NULL;
    18921959                krb5_data_free(&rspac);
    1893                 ret = _kdc_db_fetch(context, config, client_principal, HDB_F_GET_CLIENT | HDB_F_CANON,
     1960                ret = _kdc_db_fetch(context, config, tp, HDB_F_GET_CLIENT | flags,
    18941961                                    NULL, &s4u2self_impersonated_clientdb, &s4u2self_impersonated_client);
    18951962                if (ret) {
    … …  
    19051972                        ret = KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
    19061973                    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);
     1974                    kdc_log(context, config, 1,
     1975                            "S2U4Self principal to impersonate %s not found in database: %s",
     1976                            tpn, msg);
    19081977                    krb5_free_error_message(context, msg);
    19091978                    goto out;
    … …  
    19121981                if (ret) {
    19131982                    kdc_log(context, config, 0, "PAC generation failed for -- %s",
    1914                             selfcpn);
     1983                            tpn);
    19151984                    goto out;
    19161985                }
    … …  
    19231992                    if (ret) {
    19241993                        kdc_log(context, config, 0, "PAC signing failed for -- %s",
    1925                                 selfcpn);
     1994                                tpn);
    19261995                        goto out;
    19271996                    }
    … …  
    19382007                        "to impersonate to service "
    19392008                        "(tried for user %s to service %s)",
    1940                         cpn, selfcpn, spn);
    1941                 free(selfcpn);
     2009                        cpn, tpn, spn);
    19422010                goto out;
    19432011            }
    … …  
    19552023            }
    19562024            kdc_log(context, config, 0, "s4u2self %s impersonating %s to "
    1957                     "service %s %s", cpn, selfcpn, spn, str);
    1958             free(selfcpn);
     2025                    "service %s %s", cpn, tpn, spn, str);
    19592026        }
    19602027    }
    … …  
    19722039        Key *clientkey;
    19732040        Ticket *t;
    1974         char *str;
    19752041
    19762042        /*
    … …  
    20032069        }
    20042070
     2071        ret = _krb5_principalname2krb5_principal(context,
     2072                                                 &tp,
     2073                                                 adtkt.cname,
     2074                                                 adtkt.crealm);
     2075        if (ret)
     2076            goto out;
     2077
     2078        ret = krb5_unparse_name(context, tp, &tpn);
     2079        if (ret)
     2080            goto out;
     2081
     2082        ret = _krb5_principalname2krb5_principal(context,
     2083                                                 &dp,
     2084                                                 t->sname,
     2085                                                 t->realm);
     2086        if (ret)
     2087            goto out;
     2088
     2089        ret = krb5_unparse_name(context, dp, &dpn);
     2090        if (ret)
     2091            goto out;
     2092
    20052093        /* check that ticket is valid */
    20062094        if (adtkt.flags.forwardable == 0) {
    20072095            kdc_log(context, config, 0,
    20082096                    "Missing forwardable flag on ticket for "
    2009                     "constrained delegation from %s to %s ", cpn, spn);
     2097                    "constrained delegation from %s (%s) as %s to %s ",
     2098                    cpn, dpn, tpn, spn);
    20102099            ret = KRB5KDC_ERR_BADOPTION;
    20112100            goto out;
    20122101        }
    20132102
    2014         ret = check_constrained_delegation(context, config, clientdb, 
    2015                                            client, sp);
     2103        ret = check_constrained_delegation(context, config, clientdb,
     2104                                           client, server, sp);
    20162105        if (ret) {
    20172106            kdc_log(context, config, 0,
    2018                     "constrained delegation from %s to %s not allowed",
    2019                     cpn, spn);
    2020             goto out;
    2021         }
    2022 
    2023         ret = _krb5_principalname2krb5_principal(context,
    2024                                                  &client_principal,
    2025                                                  adtkt.cname,
    2026                                                  adtkt.crealm);
    2027         if (ret)
    2028             goto out;
    2029 
    2030         ret = krb5_unparse_name(context, client_principal, &str);
    2031         if (ret)
    2032             goto out;
    2033 
    2034         ret = verify_flags(context, config, &adtkt, str);
     2107                    "constrained delegation from %s (%s) as %s to %s not allowed",
     2108                    cpn, dpn, tpn, spn);
     2109            goto out;
     2110        }
     2111
     2112        ret = verify_flags(context, config, &adtkt, tpn);
    20352113        if (ret) {
    2036             free(str);
     2114            goto out;
     2115        }
     2116
     2117        krb5_data_free(&rspac);
     2118
     2119        /*
     2120         * generate the PAC for the user.
     2121         *
     2122         * TODO: pass in t->sname and t->realm and build
     2123         * a S4U_DELEGATION_INFO blob to the PAC.
     2124         */
     2125        ret = check_PAC(context, config, tp, dp,
     2126                        client, server, krbtgt,
     2127                        &clientkey->key,
     2128                        ekey, &tkey_sign->key,
     2129                        &adtkt, &rspac, &ad_signedpath);
     2130        if (ret) {
     2131            const char *msg = krb5_get_error_message(context, ret);
     2132            kdc_log(context, config, 0,
     2133                    "Verify delegated PAC failed to %s for client"
     2134                    "%s (%s) as %s from %s with %s",
     2135                    spn, cpn, dpn, tpn, from, msg);
     2136            krb5_free_error_message(context, msg);
    20372137            goto out;
    20382138        }
    … …  
    20482148                                   NULL,
    20492149                                   &ad_signedpath);
    2050         if (ret == 0 && !ad_signedpath)
    2051             ret = KRB5KDC_ERR_BADOPTION;
    20522150        if (ret) {
    20532151            const char *msg = krb5_get_error_message(context, ret);
    20542152            kdc_log(context, config, 0,
    20552153                    "KRB5SignedPath check from service %s failed "
    2056                     "for delegation to %s for client %s "
     2154                    "for delegation to %s for client %s (%s)"
    20572155                    "from %s failed with %s",
    2058                     spn, str, cpn, from, msg);
     2156                    spn, tpn, dpn, cpn, from, msg);
    20592157            krb5_free_error_message(context, msg);
    2060             free(str);
     2158            goto out;
     2159        }
     2160
     2161        if (!ad_signedpath) {
     2162            ret = KRB5KDC_ERR_BADOPTION;
     2163            kdc_log(context, config, 0,
     2164                    "Ticket not signed with PAC nor SignedPath service %s failed "
     2165                    "for delegation to %s for client %s (%s)"
     2166                    "from %s",
     2167                    spn, tpn, dpn, cpn, from);
    20612168            goto out;
    20622169        }
    20632170
    20642171        kdc_log(context, config, 0, "constrained delegation for %s "
    2065                 "from %s to %s", str, cpn, spn);
    2066         free(str);
     2172                "from %s (%s) to %s", tpn, cpn, dpn, spn);
    20672173    }
    20682174
    … …  
    20932199        goto out;
    20942200    }
    2095        
     2201
    20962202    /*
    20972203     * If this is an referral, add server referral data to the
    … …  
    21352241                         config,
    21362242                         b,
    2137                          client_principal,
     2243                         tp,
    21382244                         tgt,
    21392245                         replykey,
    … …  
    21552261                         e_text,
    21562262                         reply);
    2157        
     2263
    21582264out:
     2265    if (tpn != cpn)
     2266            free(tpn);
    21592267    free(spn);
    21602268    free(cpn);
    2161        
     2269    if (dpn)
     2270        free(dpn);
     2271
    21622272    krb5_data_free(&rspac);
    21632273    krb5_free_keyblock_contents(context, &sessionkey);
    … …  
    21712281        _kdc_free_ent(context, s4u2self_impersonated_client);
    21722282
    2173     if (client_principal && client_principal != cp)
    2174         krb5_free_principal(context, client_principal);
     2283    if (tp && tp != cp)
     2284        krb5_free_principal(context, tp);
    21752285    if (cp)
    21762286        krb5_free_principal(context, cp);
     2287    if (dp)
     2288        krb5_free_principal(context, dp);
    21772289    if (sp)
    21782290        krb5_free_principal(context, sp);
    … …  
    22252337    if(tgs_req == NULL){
    22262338        ret = KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
    2227        
     2339
    22282340        kdc_log(context, config, 0,
    22292341                "TGS-REQ from %s without PA-TGS-REQ", from);

  • vendor/current/source4/heimdal/kdc/kx509.c

    r740 r988  
    260260    if (ret)
    261261        goto out;
    262                
     262
    263263    return 0;
    264264out:
    … …  
    356356                goto out;
    357357            }
    358            
     358
    359359            ret = KRB5KDC_ERR_SERVER_NOMATCH;
    360360            krb5_set_error_message(context, ret,

  • vendor/current/source4/heimdal/kdc/log.c

    r740 r988  
    5151        krb5_config_free_strings(s);
    5252    }else {
    53         char *s;
    54         asprintf(&s, "0-1/FILE:%s/%s", hdb_db_dir(context), KDC_LOG_FILE);
    55         krb5_addlog_dest(context, config->logf, s);
    56         free(s);
     53        char *ss;
     54        if (asprintf(&ss, "0-1/FILE:%s/%s", hdb_db_dir(context),
     55            KDC_LOG_FILE) < 0)
     56            err(1, NULL);
     57        krb5_addlog_dest(context, config->logf, ss);
     58        free(ss);
    5759    }
    5860    krb5_set_warn_dest(context, config->logf);

  • vendor/current/source4/heimdal/kdc/misc.c

    r740 r988  
    4141              krb5_const_principal principal,
    4242              unsigned flags,
    43               krb5int32 *kvno_ptr,
     43              krb5uint32 *kvno_ptr,
    4444              HDB **db,
    4545              hdb_entry_ex **h)
    … …  
    4949    int i;
    5050    unsigned kvno = 0;
     51    krb5_principal enterprise_principal = NULL;
     52    krb5_const_principal princ;
     53
     54    *h = NULL;
    5155
    5256    if (kvno_ptr) {
    … …  
    5559    }
    5660
    57     ent = calloc (1, sizeof (*ent));
    58     if (ent == NULL) {
    59         krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
    60         return ENOMEM;
     61    ent = calloc(1, sizeof (*ent));
     62    if (ent == NULL)
     63        return krb5_enomem(context);
     64
     65    if (principal->name.name_type == KRB5_NT_ENTERPRISE_PRINCIPAL) {
     66        if (principal->name.name_string.len != 1) {
     67            ret = KRB5_PARSE_MALFORMED;
     68            krb5_set_error_message(context, ret,
     69                                   "malformed request: "
     70                                   "enterprise name with %d name components",
     71                                   principal->name.name_string.len);
     72            goto out;
     73        }
     74        ret = krb5_parse_name(context, principal->name.name_string.val[0],
     75                              &enterprise_principal);
     76        if (ret)
     77            goto out;
    6178    }
    6279
    63     for(i = 0; i < config->num_db; i++) {
    64         krb5_principal enterprise_principal = NULL;
    65         if (!(config->db[i]->hdb_capability_flags & HDB_CAP_F_HANDLE_ENTERPRISE_PRINCIPAL)
    66             && principal->name.name_type == KRB5_NT_ENTERPRISE_PRINCIPAL) {
    67             if (principal->name.name_string.len != 1) {
    68                 ret = KRB5_PARSE_MALFORMED;
    69                 krb5_set_error_message(context, ret,
    70                                        "malformed request: "
    71                                        "enterprise name with %d name components",
    72                                        principal->name.name_string.len);
    73                 free(ent);
    74                 return ret;
    75             }
    76             ret = krb5_parse_name(context, principal->name.name_string.val[0],
    77                                   &enterprise_principal);
    78             if (ret) {
    79                 free(ent);
    80                 return ret;
    81             }
    82 
    83             principal = enterprise_principal;
    84         }
    85 
     80    for (i = 0; i < config->num_db; i++) {
    8681        ret = config->db[i]->hdb_open(context, config->db[i], O_RDONLY, 0);
    8782        if (ret) {
    … …  
    9287        }
    9388
     89        princ = principal;
     90        if (!(config->db[i]->hdb_capability_flags & HDB_CAP_F_HANDLE_ENTERPRISE_PRINCIPAL) && enterprise_principal)
     91            princ = enterprise_principal;
     92
    9493        ret = config->db[i]->hdb_fetch_kvno(context,
    9594                                            config->db[i],
    96                                             principal,
     95                                            princ,
    9796                                            flags | HDB_F_DECRYPT,
    9897                                            kvno,
    9998                                            ent);
     99        config->db[i]->hdb_close(context, config->db[i]);
    100100
    101         krb5_free_principal(context, enterprise_principal);
    102 
    103         config->db[i]->hdb_close(context, config->db[i]);
    104         if(ret == 0) {
     101        switch (ret) {
     102        case HDB_ERR_WRONG_REALM:
     103            /*
     104             * the ent->entry.principal just contains hints for the client
     105             * to retry. This is important for enterprise principal routing
     106             * between trusts.
     107             */
     108            /* fall through */
     109        case 0:
    105110            if (db)
    106111                *db = config->db[i];
    107112            *h = ent;
    108             return 0;
     113            ent = NULL;
     114            goto out;
     115
     116        case HDB_ERR_NOENTRY:
     117            /* Check the other databases */
     118            continue;
     119
     120        default:
     121            /*
     122             * This is really important, because errors like
     123             * HDB_ERR_NOT_FOUND_HERE (used to indicate to Samba that
     124             * the RODC on which this code is running does not have
     125             * the key we need, and so a proxy to the KDC is required)
     126             * have specific meaning, and need to be propogated up.
     127             */
     128            goto out;
    109129        }
    110130    }
     131
     132    if (ret == HDB_ERR_NOENTRY) {
     133        krb5_set_error_message(context, ret, "no such entry found in hdb");
     134    }
     135out:
     136    krb5_free_principal(context, enterprise_principal);
    111137    free(ent);
    112     krb5_set_error_message(context, ret,
    113                            "no such entry found in hdb");
    114138    return ret;
    115139}
    … …  
    135159                       Key **key)
    136160{
    137     const krb5_enctype *p;
    138161    krb5_error_code ret;
    139162    int i;
    140163
    141     p = krb5_kerberos_enctypes(context);
     164    if (config->use_strongest_server_key) {
     165        const krb5_enctype *p = krb5_kerberos_enctypes(context);
    142166
    143     for (i = 0; p[i] != ETYPE_NULL; i++) {
    144         if (krb5_enctype_valid(context, p[i]) != 0)
    145             continue;
    146         ret = hdb_enctype2key(context, &h->entry, p[i], key);
    147         if (ret == 0) {
    148             *enctype = p[i];
     167        for (i = 0; p[i] != ETYPE_NULL; i++) {
     168            if (krb5_enctype_valid(context, p[i]) != 0)
     169                continue;
     170            ret = hdb_enctype2key(context, &h->entry, p[i], key);
     171            if (ret != 0)
     172                continue;
     173            if (enctype != NULL)
     174                *enctype = p[i];
     175            return 0;
     176        }
     177    } else {
     178        *key = NULL;
     179
     180        for (i = 0; i < h->entry.keys.len; i++) {
     181            if (krb5_enctype_valid(context, h->entry.keys.val[i].key.keytype)
     182                != 0)
     183                continue;
     184            ret = hdb_enctype2key(context, &h->entry,
     185                h->entry.keys.val[i].key.keytype, key);
     186            if (ret != 0)
     187                continue;
     188            if (enctype != NULL)
     189                *enctype = (*key)->key.keytype;
    149190            return 0;
    150191        }
    … …  
    153194    krb5_set_error_message(context, EINVAL,
    154195                           "No valid kerberos key found for %s", name);
    155     return EINVAL;
     196    return EINVAL; /* XXX */
    156197}
    157198

  • vendor/current/source4/heimdal/kdc/pkinit.c

    r740 r988  
    117117    size_t buf_size;
    118118    krb5_error_code ret;
    119     size_t len;
     119    size_t len = 0;
    120120    krb5_timestamp now;
    121121    Checksum checksum;
    … …  
    149149        return ret;
    150150    }
    151        
     151
    152152    if (a->paChecksum == NULL) {
    153153        krb5_clear_error_message(context);
    … …  
    223223        if (!DH_generate_key(client_params->u.dh.key)) {
    224224            ret = KRB5KRB_ERR_GENERIC;
    225             krb5_set_error_message(context, ret, 
     225            krb5_set_error_message(context, ret,
    226226                                   "Can't generate Diffie-Hellman keys");
    227227            goto out;
    … …  
    238238
    239239        dh_gen_keylen = DH_compute_key(dh_gen_key,client_params->u.dh.public_key, client_params->u.dh.key);
    240         if (dh_gen_keylen == -1) {
     240        if (dh_gen_keylen == (size_t)-1) {
    241241            ret = KRB5KRB_ERR_GENERIC;
    242242            krb5_set_error_message(context, ret,
    … …  
    282282        }
    283283
    284         dh_gen_keylen = ECDH_compute_key(dh_gen_key, size, 
     284        dh_gen_keylen = ECDH_compute_key(dh_gen_key, size,
    285285                                         EC_KEY_get0_public_key(client_params->u.ecdh.public_key),
    286286                                         client_params->u.ecdh.key, NULL);
    … …  
    289289    } else {
    290290        ret = KRB5KRB_ERR_GENERIC;
    291         krb5_set_error_message(context, ret, 
     291        krb5_set_error_message(context, ret,
    292292                               "Diffie-Hellman not selected keys");
    293293        goto out;
    … …  
    526526    }
    527527
    528     ret = hx509_certs_merge(context->hx509ctx, trust_anchors, 
     528    ret = hx509_certs_merge(context->hx509ctx, trust_anchors,
    529529                            kdc_identity->anchors);
    530530    if (ret) {
    … …  
    539539        hx509_cert cert;
    540540        unsigned int i;
    541        
     541
    542542        for (i = 0; i < pc->len; i++) {
    543543            ret = hx509_cert_init_data(context->hx509ctx,
    … …  
    573573        if (req->req_body.kdc_options.request_anonymous) {
    574574            ret = KRB5_KDC_ERR_PUBLIC_KEY_ENCRYPTION_NOT_SUPPORTED;
    575             krb5_set_error_message(context, ret, 
     575            krb5_set_error_message(context, ret,
    576576                                   "Anon not supported in RSA mode");
    577577            goto out;
    … …  
    587587            goto out;
    588588        }
    589        
     589
    590590        ret = hx509_cms_unwrap_ContentInfo(&r.signed_auth_pack,
    591591                                           &contentInfoOid,
    … …  
    613613            goto out;
    614614        }
    615        
     615
    616616        /* XXX look at r.kdcPkId */
    617617        if (r.trustedCertifiers) {
    … …  
    625625            if (ret) {
    626626                krb5_set_error_message(context, ret,
    627                                        "Can't allocate client anchors: %d", 
     627                                       "Can't allocate client anchors: %d",
    628628                                       ret);
    629629                goto out;
    630630
    631631            }
    632             /* 
     632            /*
    633633             * If the client sent more then 10 EDI, don't bother
    634634             * looking more then 10 of performance reasons.
    … …  
    652652                    goto out;
    653653                }
    654                
     654
    655655                ret = decode_IssuerAndSerialNumber(edi->val[i].issuerAndSerialNumber->data,
    656656                                                   edi->val[i].issuerAndSerialNumber->length,
    … …  
    705705        goto out;
    706706    }
    707        
     707
    708708    if (!have_data) {
    709709        ret = KRB5KRB_ERR_GENERIC;
    … …  
    806806            free_AuthPack(&ap);
    807807            ret = KRB5_KDC_ERR_PUBLIC_KEY_ENCRYPTION_NOT_SUPPORTED;
    808             krb5_set_error_message(context, ret, 
     808            krb5_set_error_message(context, ret,
    809809                                   "Anon not supported in RSA mode");
    810810            goto out;
    … …  
    850850            goto out;
    851851        }
    852        
     852
    853853        if (ap.supportedCMSTypes) {
    854854            ret = hx509_peer_info_set_cms_algs(context->hx509ctx,
    … …  
    886886    if (ret) {
    887887        _kdc_pk_free_client_param(context, cp);
    888     } else 
     888    } else
    889889        *ret_params = cp;
    890890    return ret;
    … …  
    922922    krb5_error_code ret;
    923923    krb5_data buf, signed_data;
    924     size_t size;
     924    size_t size = 0;
    925925    int do_win2k = 0;
    926926
    … …  
    955955    default:
    956956        krb5_abortx(context, "internal pkinit error");
    957     }   
     957    }
    958958
    959959    if (do_win2k) {
    … …  
    967967        }
    968968        kp.nonce = cp->nonce;
    969        
     969
    970970        ASN1_MALLOC_ENCODE(ReplyKeyPack_Win2k,
    971971                           buf.data, buf.length,
    … …  
    996996            goto out;
    997997        }
    998                        
     998
    999999        ret = krb5_crypto_destroy(context, ascrypto);
    10001000        if (ret) {
    … …  
    10161016        hx509_query *q;
    10171017        hx509_cert cert;
    1018        
     1018
    10191019        ret = hx509_query_alloc(context->hx509ctx, &q);
    10201020        if (ret)
    10211021            goto out;
    1022        
     1022
    10231023        hx509_query_match_option(q, HX509_QUERY_OPTION_PRIVATE_KEY);
    10241024        if (config->pkinit_kdc_friendly_name)
    10251025            hx509_query_match_friendly_name(q, config->pkinit_kdc_friendly_name);
    1026        
     1026
    10271027        ret = hx509_certs_find(context->hx509ctx,
    10281028                               kdc_identity->certs,
    … …  
    10321032        if (ret)
    10331033            goto out;
    1034        
     1034
    10351035        ret = hx509_cms_create_signed_1(context->hx509ctx,
    10361036                                        0,
    … …  
    10791079        *kdc_cert = NULL;
    10801080    }
    1081      
     1081
    10821082    krb5_data_free(&buf);
    10831083    krb5_data_free(&signed_data);
    … …  
    11021102    hx509_cert cert;
    11031103    hx509_query *q;
    1104     size_t size;
     1104    size_t size = 0;
    11051105
    11061106    memset(&contentinfo, 0, sizeof(contentinfo));
    … …  
    11181118        if (ret)
    11191119            return ret;
    1120        
     1120
    11211121        ASN1_MALLOC_ENCODE(DHPublicKey, buf.data, buf.length, &i, &size, ret);
    11221122        der_free_heim_integer(&i);
    … …  
    11281128        if (buf.length != size)
    11291129            krb5_abortx(context, "Internal ASN.1 encoder error");
    1130        
     1130
    11311131        dh_info.subjectPublicKey.length = buf.length * 8;
    11321132        dh_info.subjectPublicKey.data = buf.data;
    … …  
    11551155        krb5_abortx(context, "no keyex selected ?");
    11561156
    1157        
     1157
    11581158    dh_info.nonce = cp->nonce;
    11591159
    … …  
    11761176    if (ret)
    11771177        goto out;
    1178    
     1178
    11791179    hx509_query_match_option(q, HX509_QUERY_OPTION_PRIVATE_KEY);
    11801180    if (config->pkinit_kdc_friendly_name)
    11811181        hx509_query_match_friendly_name(q, config->pkinit_kdc_friendly_name);
    1182    
     1182
    11831183    ret = hx509_certs_find(context->hx509ctx,
    11841184                           kdc_identity->certs,
    … …  
    11881188    if (ret)
    11891189        goto out;
    1190    
     1190
    11911191    ret = hx509_cms_create_signed_1(context->hx509ctx,
    11921192                                    0,
    … …  
    12431243{
    12441244    krb5_error_code ret;
    1245     void *buf;
    1246     size_t len, size;
     1245    void *buf = NULL;
     1246    size_t len = 0, size = 0;
    12471247    krb5_enctype enctype;
    12481248    int pa_type;
    12491249    hx509_cert kdc_cert = NULL;
    1250     int i;
     1250    size_t i;
    12511251
    12521252    if (!config->enable_pkinit) {
    … …  
    12641264                                   "No valid enctype available from client");
    12651265            goto out;
    1266         }       
     1266        }
    12671267        enctype = req->req_body.etype.val[i];
    12681268    } else
    … …  
    13151315                krb5_abortx(context, "Internal ASN.1 encoder error");
    13161316
    1317             ret = krb5_generate_random_keyblock(context, sessionetype, 
     1317            ret = krb5_generate_random_keyblock(context, sessionetype,
    13181318                                                sessionkey);
    13191319            if (ret) {
    … …  
    13691369
    13701370            /* XXX KRB-FX-CF2 */
    1371             ret = krb5_generate_random_keyblock(context, sessionetype, 
     1371            ret = krb5_generate_random_keyblock(context, sessionetype,
    13721372                                                sessionkey);
    13731373            if (ret) {
    … …  
    14211421
    14221422        pa_type = KRB5_PADATA_PK_AS_REP_19;
    1423         rep.element = choice_PA_PK_AS_REP_encKeyPack;
     1423        rep.element = choice_PA_PK_AS_REP_Win2k_encKeyPack;
    14241424
    14251425        ret = krb5_generate_random_keyblock(context, enctype,
    … …  
    14641464            krb5_abortx(context, "Internal ASN.1 encoder error");
    14651465
    1466         ret = krb5_generate_random_keyblock(context, sessionetype, 
     1466        ret = krb5_generate_random_keyblock(context, sessionetype,
    14671467                                            sessionkey);
    14681468        if (ret) {
    … …  
    15081508                goto out_ocsp;
    15091509            }
    1510        
     1510
    15111511            ret = krb5_data_alloc(&ocsp.data, sb.st_size);
    15121512            if (ret) {
    … …  
    15761576{
    15771577    hx509_octet_string_list list;
    1578     int ret, i, found = 0;
     1578    int ret, found = 0;
     1579    size_t i;
    15791580
    15801581    memset(&list, 0 , sizeof(list));
    … …  
    16801681        ret = clientdb->hdb_check_pkinit_ms_upn_match(context, clientdb, client, principal);
    16811682    } else {
    1682            
     1683
    16831684        /*
    16841685         * This is very wrong, but will do for a fallback
    16851686         */
    16861687        strupr(principal->realm);
    1687            
     1688
    16881689        if (krb5_principal_compare(context, principal, client->entry.principal) == FALSE)
    16891690            ret = KRB5_KDC_ERR_CLIENT_NAME_MISMATCH;
    … …  
    17101711    krb5_error_code ret;
    17111712    hx509_name name;
    1712     int i;
     1713    size_t i;
    17131714
    17141715    if (cp->cert == NULL) {
    … …  
    17381739    if (ret == 0 && pc) {
    17391740        hx509_cert cert;
    1740         unsigned int i;
    1741        
    1742         for (i = 0; i < pc->len; i++) {
     1741        size_t j;
     1742
     1743        for (j = 0; j < pc->len; j++) {
    17431744            ret = hx509_cert_init_data(context->hx509ctx,
    1744                                        pc->val[i].cert.data,
    1745                                        pc->val[i].cert.length,
     1745                                       pc->val[j].cert.data,
     1746                                       pc->val[j].cert.length,
    17461747                                       &cert);
    17471748            if (ret)
    … …  
    17711772                               context->hx509ctx,
    17721773                               cp->cert,
    1773                                clientdb, 
     1774                               clientdb,
    17741775                               client);
    17751776        if (ret == 0) {
    … …  
    18721873    krb5_error_code ret;
    18731874    krb5_data data;
    1874     size_t size;
     1875    size_t size = 0;
    18751876
    18761877    memset(&cas, 0, sizeof(cas));
    … …  
    19381939    fclose(f);
    19391940}
    1940                
     1941
    19411942/*
    19421943 *
    … …  
    19831984        hx509_query *q;
    19841985        hx509_cert cert;
    1985        
     1986
    19861987        ret = hx509_query_alloc(context->hx509ctx, &q);
    19871988        if (ret) {
    … …  
    19891990            return ENOMEM;
    19901991        }
    1991        
     1992
    19921993        hx509_query_match_option(q, HX509_QUERY_OPTION_PRIVATE_KEY);
    19931994        if (config->pkinit_kdc_friendly_name)
    19941995            hx509_query_match_friendly_name(q, config->pkinit_kdc_friendly_name);
    1995        
     1996
    19961997        ret = hx509_certs_find(context->hx509ctx,
    19971998                               kdc_identity->certs,

  • vendor/current/source4/heimdal/kdc/process.c

    r740 r988  
    4848}
    4949
    50 static krb5_error_code 
     50static krb5_error_code
    5151kdc_as_req(krb5_context context,
    5252           krb5_kdc_configuration *config,
    … …  
    7575
    7676
    77 static krb5_error_code 
     77static krb5_error_code
    7878kdc_tgs_req(krb5_context context,
    7979            krb5_kdc_configuration *config,
    … …  
    9292    if (ret)
    9393        return ret;
    94    
     94
    9595    *claim = 1;
    9696
    97     ret = _kdc_tgs_rep(context, config, &req, reply, 
     97    ret = _kdc_tgs_rep(context, config, &req, reply,
    9898                       from, addr, datagram_reply);
    9999    free_TGS_REQ(&req);
    … …  
    103103#ifdef DIGEST
    104104
    105 static krb5_error_code 
     105static krb5_error_code
    106106kdc_digest(krb5_context context,
    107107           krb5_kdc_configuration *config,
    … …  
    133133#ifdef KX509
    134134
    135 static krb5_error_code 
     135static krb5_error_code
    136136kdc_kx509(krb5_context context,
    137137          krb5_kdc_configuration *config,
    … …  
    194194    krb5_data req_buffer;
    195195    int claim = 0;
    196    
     196
    197197    req_buffer.data = buf;
    198198    req_buffer.length = len;
    … …  
    233233    krb5_data req_buffer;
    234234    int claim = 0;
    235    
     235
    236236    req_buffer.data = buf;
    237237    req_buffer.length = len;
    … …  
    246246            return ret;
    247247    }
    248                        
     248
    249249    return -1;
    250250}

  • vendor/current/source4/heimdal/kdc/windc.c

    r740 r988  
    5656        if (windcft->minor_version < KRB5_WINDC_PLUGIN_MINOR)
    5757            continue;
    58        
     58
    5959        (*windcft->init)(context, &windcctx);
    6060        break;
    … …  
    8585_kdc_pac_verify(krb5_context context,
    8686                const krb5_principal client_principal,
     87                const krb5_principal delegated_proxy_principal,
    8788                hdb_entry_ex *client,
    8889                hdb_entry_ex *server,
    … …  
    9798
    9899    ret = windcft->pac_verify(windcctx, context,
    99                               client_principal, client, server, krbtgt, pac);
     100                              client_principal,
     101                              delegated_proxy_principal,
     102                              client, server, krbtgt, pac);
    100103    if (ret == 0)
    101104        *verified = 1;
    … …  
    117120                                   req->msg_type == krb_as_req);
    118121
    119     return (windcft->client_access)(windcctx, 
    120                                     context, config, 
    121                                     client_ex, client_name, 
    122                                     server_ex, server_name, 
     122    return (windcft->client_access)(windcctx,
     123                                    context, config,
     124                                    client_ex, client_name,
     125                                    server_ex, server_name,
    123126                                    req, e_data);
    124127}

  • vendor/current/source4/heimdal/kdc/windc_plugin.h

    r740 r988  
    5858typedef krb5_error_code
    5959(*krb5plugin_windc_pac_verify)(void *, krb5_context,
    60                                const krb5_principal,
    61                                struct hdb_entry_ex *,
    62                                struct hdb_entry_ex *,
    63                                struct hdb_entry_ex *,
     60                               const krb5_principal, /* new ticket client */
     61                               const krb5_principal, /* delegation proxy */
     62                               struct hdb_entry_ex *,/* client */
     63                               struct hdb_entry_ex *,/* server */
     64                               struct hdb_entry_ex *,/* krbtgt */
    6465                               krb5_pac *);
    6566
    6667typedef krb5_error_code
    6768(*krb5plugin_windc_client_access)(
    68         void *, krb5_context, 
     69        void *, krb5_context,
    6970        krb5_kdc_configuration *config,
    70         hdb_entry_ex *, const char *, 
    71         hdb_entry_ex *, const char *, 
     71        hdb_entry_ex *, const char *,
     72        hdb_entry_ex *, const char *,
    7273        KDC_REQ *, krb5_data *);
    7374
    7475
    75 #define KRB5_WINDC_PLUGING_MINOR                4
    76 #define KRB5_WINDC_PLUGIN_MINOR                 4
     76#define KRB5_WINDC_PLUGIN_MINOR                 6
     77#define KRB5_WINDC_PLUGING_MINOR KRB5_WINDC_PLUGIN_MINOR
    7778
    7879typedef struct krb5plugin_windc_ftable {
Note: See TracChangeset for help on using the changeset viewer.