VirtualBox

Changeset 63831 in vbox for trunk


Ignore:
Timestamp:
Sep 14, 2016 12:03:10 PM (8 years ago)
Author:
vboxsync
Message:

RDP/client, Runtime: compile fixes for OpenSSL 1.1 (thanks Sebastian Andrzej Siewior)

Location:
trunk/src/VBox
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/RDP/client-1.8.3/ssl.c

    r55123 r63831  
    9797                  uint8 * exponent)
    9898{
     99#if OPENSSL_VERSION_NUMBER >= 0x10100000
     100        BN_CTX *ctx;
     101        BIGNUM *mod, *exp, *x, *y;
     102        uint8 inr[SEC_MAX_MODULUS_SIZE];
     103        int outlen;
     104
     105        reverse(modulus, modulus_size);
     106        reverse(exponent, SEC_EXPONENT_SIZE);
     107        memcpy(inr, in, len);
     108        reverse(inr, len);
     109
     110        ctx = BN_CTX_new();
     111        mod = BN_new();
     112        exp = BN_new();
     113        x = BN_new();
     114        y = BN_new();
     115
     116        BN_bin2bn(modulus, modulus_size, mod);
     117        BN_bin2bn(exponent, SEC_EXPONENT_SIZE, exp);
     118        BN_bin2bn(inr, len, x);
     119        BN_mod_exp(y, x, exp, mod, ctx);
     120        outlen = BN_bn2bin(y, out);
     121        reverse(out, outlen);
     122        if (outlen < (int) modulus_size)
     123                memset(out + outlen, 0, modulus_size - outlen);
     124
     125        BN_free(y);
     126        BN_clear_free(x);
     127        BN_free(exp);
     128        BN_free(mod);
     129        BN_CTX_free(ctx);
     130#else /* OPENSSL_VERSION_NUMBER < 0x10100000 */
    99131        BN_CTX *ctx;
    100132        BIGNUM mod, exp, x, y;
    … …  
    127159        BN_free(&mod);
    128160        BN_CTX_free(ctx);
     161#endif /* OPENSSL_VERSION_NUMBER < 0x10100000 */
    129162}
    130163
    … …  
    156189           Kudos to Richard Levitte for the following (. intiutive .)
    157190           lines of code that resets the OID and let's us extract the key. */
     191#if OPENSSL_VERSION_NUMBER >= 0x1010000
     192        X509_PUBKEY *x509_pk = X509_get_X509_PUBKEY(cert);
     193        X509_ALGOR *algor;
     194        const ASN1_OBJECT *alg_obj;
     195        X509_PUBKEY_get0_param(NULL, NULL, NULL, &algor, x509_pk);
     196        X509_ALGOR_get0(&alg_obj, NULL, NULL, algor);
     197        nid = OBJ_obj2nid(alg_obj);
     198        if ((nid == NID_md5WithRSAEncryption) || (nid == NID_shaWithRSAEncryption))
     199        {
     200                DEBUG_RDP5(("Re-setting algorithm type to RSA in server certificate\n"));
     201                X509_ALGOR_set0(algor, OBJ_nid2obj(NID_rsaEncryption), 0, NULL);
     202        }
     203#else /* OPENSSL_VERSION_NUMBER < 0x10100000 */
    158204        nid = OBJ_obj2nid(cert->cert_info->key->algor->algorithm);
    159205        if ((nid == NID_md5WithRSAEncryption) || (nid == NID_shaWithRSAEncryption))
    … …  
    163209                cert->cert_info->key->algor->algorithm = OBJ_nid2obj(NID_rsaEncryption);
    164210        }
     211#endif /* OPENSSL_VERSION_NUMBER < 0x10100000 */
    165212        epk = X509_get_pubkey(cert);
    166213        if (NULL == epk)
    … …  
    211258        int len;
    212259
     260#if OPENSSL_VERSION_NUMBER >= 0x10100000
     261        const BIGNUM *e, *n;
     262        RSA_get0_key(rkey, &n, &e, NULL);
     263        if ((BN_num_bytes(e) > (int) max_exp_len) ||
     264            (BN_num_bytes(n) > (int) max_mod_len))
     265        {
     266                return 1;
     267        }
     268        len = BN_bn2bin(e, exponent);
     269        reverse(exponent, len);
     270        len = BN_bn2bin(n, modulus);
     271        reverse(modulus, len);
     272#else
    213273        if ((BN_num_bytes(rkey->e) > (int) max_exp_len) ||
    214274            (BN_num_bytes(rkey->n) > (int) max_mod_len))
    … …  
    220280        len = BN_bn2bin(rkey->n, modulus);
    221281        reverse(modulus, len);
     282#endif
    222283        return 0;
    223284}
    … …  
    239300               unsigned char *md)
    240301{
     302#if OPENSSL_VERSION_NUMBER < 0x10100000
    241303        HMAC_CTX ctx;
    242304        HMAC_CTX_init(&ctx);
     305#endif
    243306        HMAC(EVP_md5(), key, key_len, msg, msg_len, md, NULL);
     307#if OPENSSL_VERSION_NUMBER < 0x10100000
    244308        HMAC_CTX_cleanup(&ctx);
    245 }
     309#endif
     310}

  • trunk/src/VBox/Runtime/VBox/VBoxRTDeps.cpp

    r62635 r63831  
    7777    (PFNRT)i2d_X509,
    7878    (PFNRT)i2d_PublicKey,
     79#if OPENSSL_VERSION_NUMBER < 0x10100000
    7980    (PFNRT)RSA_generate_key,
     81#endif
    8082    (PFNRT)RSA_generate_key_ex,
     83#if OPENSSL_VERSION_NUMBER < 0x10100000
    8184    (PFNRT)DH_generate_parameters,
     85#endif
    8286    (PFNRT)DH_generate_parameters_ex,
    8387    (PFNRT)RAND_load_file,
     88#if OPENSSL_VERSION_NUMBER < 0x10100000
    8489    (PFNRT)CRYPTO_set_dynlock_create_callback,
    8590    (PFNRT)CRYPTO_set_dynlock_lock_callback,
    8691    (PFNRT)CRYPTO_set_dynlock_destroy_callback,
     92#endif
    8793    (PFNRT)RTAssertShouldPanic,
    8894    (PFNRT)ASMAtomicReadU64,
    … …  
    9197    (PFNRT)RTBldCfgRevision,
    9298    (PFNRT)SSL_free,
     99#if OPENSSL_VERSION_NUMBER < 0x10100000
    93100    (PFNRT)SSL_library_init,
    94101    (PFNRT)SSL_load_error_strings,
     102#endif
    95103    (PFNRT)SSL_CTX_free,
    96104    (PFNRT)SSL_CTX_use_certificate_file,
    97105    (PFNRT)SSLv23_method,
     106#if OPENSSL_VERSION_NUMBER < 0x10100000
    98107    (PFNRT)TLSv1_server_method,
     108#endif
    99109    NULL
    100110};

  • trunk/src/VBox/Runtime/common/crypto/pkix-verify.cpp

    r62477 r63831  
    124124                             "EVP_get_digestbyname failed on %s (%s)", pszAlogSn, pAlgorithm->szObjId);
    125125
     126# if OPENSSL_VERSION_NUMBER >= 0x10100000
     127
     128    EVP_MD_CTX *pEvpMdCtx = EVP_MD_CTX_create();
     129    if (!pEvpMdCtx)
     130        return RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_CIPHER_ALOG_INIT_FAILED,
     131                             "EVP_MD_CTX_create failed");
     132    if (!EVP_VerifyInit_ex(pEvpMdCtx, pEvpMdType, NULL /*engine*/))
     133    {
     134        EVP_MD_CTX_destroy(pEvpMdCtx);
     135        return RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_CIPHER_ALOG_INIT_FAILED,
     136                             "EVP_VerifyInit_ex failed (algorithm type is %s / %s)", pszAlogSn, pAlgorithm->szObjId);
     137    }
     138
     139    /* Create an EVP public key. */
     140    int rcOssl;
     141    EVP_PKEY *pEvpPublicKey = EVP_PKEY_new();
     142    if (pEvpPublicKey)
     143    {
     144        EVP_PKEY_set_type(pEvpPublicKey, iAlgoNid);
     145        int keyType = EVP_PKEY_base_id(pEvpPublicKey);
     146        if (keyType != NID_undef)
     147        {
     148            const unsigned char *puchPublicKey = RTASN1BITSTRING_GET_BIT0_PTR(pPublicKey);
     149            if (d2i_PublicKey(keyType, &pEvpPublicKey, &puchPublicKey, RTASN1BITSTRING_GET_BYTE_SIZE(pPublicKey)))
     150            {
     151                /* Digest the data. */
     152                EVP_VerifyUpdate(pEvpMdCtx, pvData, cbData);
     153
     154                /* Verify the signature. */
     155                if (EVP_VerifyFinal(pEvpMdCtx,
     156                                    RTASN1BITSTRING_GET_BIT0_PTR(pSignatureValue),
     157                                    RTASN1BITSTRING_GET_BYTE_SIZE(pSignatureValue),
     158                                    pEvpPublicKey) > 0)
     159                    rcOssl = VINF_SUCCESS;
     160                else
     161                    rcOssl = RTErrInfoSet(pErrInfo, VERR_CR_PKIX_OSSL_VERIFY_FINAL_FAILED, "EVP_VerifyFinal failed");
     162            }
     163            else
     164                rcOssl = RTErrInfoSet(pErrInfo, VERR_CR_PKIX_OSSL_D2I_PUBLIC_KEY_FAILED, "d2i_PublicKey failed");
     165        }
     166        else
     167            rcOssl = RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_EVP_PKEY_TYPE_ERROR,
     168                                   "EVP_PKEY_type(%d) failed", iAlgoNid);
     169        /* Cleanup and return.*/
     170        EVP_PKEY_free(pEvpPublicKey);
     171    }
     172    else
     173        rcOssl = RTErrInfoSetF(pErrInfo, VERR_NO_MEMORY, "EVP_PKEY_new(%d) failed", iAlgoNid);
     174    EVP_MD_CTX_destroy(pEvpMdCtx);
     175
     176# else /* OPENSSL_VERSION_NUMBER < 0x1010000 */
     177
    126178    /* Initialize the EVP message digest context. */
    127179    EVP_MD_CTX EvpMdCtx;
    … …  
    167219    EVP_MD_CTX_cleanup(&EvpMdCtx);
    168220
     221# endif /* OPENSSL_VERSION_NUMBER < 0x10100000 */
     222
    169223    /*
    170224     * Check the result.
    … …  
    256310        return RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_CIPHER_ALGO_NOT_KNOWN_EVP,
    257311                             "EVP_get_digestbyname failed on %s (%s)", pszAlogSn, pszAlgObjId);
     312
     313# if OPENSSL_VERSION_NUMBER >= 0x10100000
     314
     315    /* Create an EVP public key. */
     316    int rcOssl;
     317    EVP_PKEY *pEvpPublicKey = EVP_PKEY_new();
     318    if (pEvpPublicKey)
     319    {
     320        EVP_PKEY_set_type(pEvpPublicKey, iAlgoNid);
     321        int keyType = EVP_PKEY_base_id(pEvpPublicKey);
     322        if (keyType != NID_undef)
     323        {
     324            const unsigned char *puchPublicKey = RTASN1BITSTRING_GET_BIT0_PTR(pPublicKey);
     325            if (d2i_PublicKey(keyType, &pEvpPublicKey, &puchPublicKey, RTASN1BITSTRING_GET_BYTE_SIZE(pPublicKey)))
     326            {
     327                /* Create an EVP public key context we can use to validate the digest. */
     328                EVP_PKEY_CTX *pEvpPKeyCtx = EVP_PKEY_CTX_new(pEvpPublicKey, NULL);
     329                if (pEvpPKeyCtx)
     330                {
     331                    rcOssl = EVP_PKEY_verify_init(pEvpPKeyCtx);
     332                    if (rcOssl > 0)
     333                    {
     334                        rcOssl = EVP_PKEY_CTX_set_signature_md(pEvpPKeyCtx, pEvpMdType);
     335                        if (rcOssl > 0)
     336                        {
     337                            /* Get the digest from hDigest and verify it. */
     338                            rcOssl = EVP_PKEY_verify(pEvpPKeyCtx,
     339                                                     (uint8_t const *)pvSignedDigest,
     340                                                     cbSignedDigest,
     341                                                     RTCrDigestGetHash(hDigest),
     342                                                     RTCrDigestGetHashSize(hDigest));
     343                            if (rcOssl > 0)
     344                                rcOssl = VINF_SUCCESS;
     345                            else
     346                                rcOssl = RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_VERIFY_FINAL_FAILED,
     347                                                       "EVP_PKEY_verify failed (%d)", rcOssl);
     348                        }
     349                        else
     350                            rcOssl = RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_EVP_PKEY_TYPE_ERROR,
     351                                                   "EVP_PKEY_CTX_set_signature_md failed (%d)", rcOssl);
     352                    }
     353                    else
     354                        rcOssl = RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_EVP_PKEY_TYPE_ERROR,
     355                                               "EVP_PKEY_verify_init failed (%d)", rcOssl);
     356                    EVP_PKEY_CTX_free(pEvpPKeyCtx);
     357                }
     358                else
     359                    rcOssl = RTErrInfoSet(pErrInfo, VERR_CR_PKIX_OSSL_EVP_PKEY_TYPE_ERROR, "EVP_PKEY_CTX_new failed");
     360            }
     361            else
     362                rcOssl = RTErrInfoSet(pErrInfo, VERR_CR_PKIX_OSSL_D2I_PUBLIC_KEY_FAILED, "d2i_PublicKey failed");
     363        }
     364        else
     365            rcOssl = RTErrInfoSetF(pErrInfo, VERR_CR_PKIX_OSSL_EVP_PKEY_TYPE_ERROR,
     366                                   "EVP_PKEY_type(%d) failed", iAlgoNid);
     367        /* Cleanup and return.*/
     368        EVP_PKEY_free(pEvpPublicKey);
     369    }
     370    else
     371        rcOssl = RTErrInfoSetF(pErrInfo, VERR_NO_MEMORY, "EVP_PKEY_new(%d) failed", iAlgoNid);
     372
     373# else /* OPENSSL_VERSION_NUMBER < 0x1010000 */
    258374
    259375    /* Create an EVP public key. */
    … …  
    314430        rcOssl = RTErrInfoSetF(pErrInfo, VERR_NO_MEMORY, "EVP_PKEY_new(%d) failed", pEvpMdType->required_pkey_type[0]);
    315431
     432# endif /* OPENSSL_VERSION_NUMBER < 0x1010000 */
     433
    316434    /*
    317435     * Check the result.
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette