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

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

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

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