diff --git a/crypto/openssl/crypto/cms/cms_pwri.c b/crypto/openssl/crypto/cms/cms_pwri.c index a7d609f83791..ee1b8aa6ed61 100644 --- a/crypto/openssl/crypto/cms/cms_pwri.c +++ b/crypto/openssl/crypto/cms/cms_pwri.c @@ -1,425 +1,425 @@ /* * Copyright 2009-2025 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/cryptlib.h" #include #include #include #include #include #include #include #include "internal/sizes.h" #include "crypto/asn1.h" #include "cms_local.h" int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri, unsigned char *pass, ossl_ssize_t passlen) { CMS_PasswordRecipientInfo *pwri; if (ri->type != CMS_RECIPINFO_PASS) { ERR_raise(ERR_LIB_CMS, CMS_R_NOT_PWRI); return 0; } pwri = ri->d.pwri; pwri->pass = pass; if (pass && passlen < 0) passlen = strlen((char *)pass); pwri->passlen = passlen; return 1; } CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms, int iter, int wrap_nid, int pbe_nid, unsigned char *pass, ossl_ssize_t passlen, const EVP_CIPHER *kekciph) { STACK_OF(CMS_RecipientInfo) *ris; CMS_RecipientInfo *ri = NULL; CMS_EncryptedContentInfo *ec; CMS_PasswordRecipientInfo *pwri; EVP_CIPHER_CTX *ctx = NULL; X509_ALGOR *encalg = NULL; unsigned char iv[EVP_MAX_IV_LENGTH]; int ivlen; const CMS_CTX *cms_ctx = ossl_cms_get0_cmsctx(cms); ec = ossl_cms_get0_env_enc_content(cms); if (ec == NULL) return NULL; ris = CMS_get0_RecipientInfos(cms); if (ris == NULL) return NULL; if (wrap_nid <= 0) wrap_nid = NID_id_alg_PWRI_KEK; if (pbe_nid <= 0) pbe_nid = NID_id_pbkdf2; /* Get from enveloped data */ if (kekciph == NULL) kekciph = ec->cipher; if (kekciph == NULL) { ERR_raise(ERR_LIB_CMS, CMS_R_NO_CIPHER); return NULL; } if (wrap_nid != NID_id_alg_PWRI_KEK) { ERR_raise(ERR_LIB_CMS, CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM); return NULL; } /* Setup algorithm identifier for cipher */ encalg = X509_ALGOR_new(); if (encalg == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB); goto err; } if (EVP_EncryptInit_ex(ctx, kekciph, NULL, NULL, NULL) <= 0) { ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB); goto err; } ivlen = EVP_CIPHER_CTX_get_iv_length(ctx); if (ivlen < 0) { ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB); goto err; } if (ivlen > 0) { if (RAND_bytes_ex(ossl_cms_ctx_get0_libctx(cms_ctx), iv, ivlen, 0) <= 0) goto err; if (EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv) <= 0) { ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB); goto err; } encalg->parameter = ASN1_TYPE_new(); if (!encalg->parameter) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } if (EVP_CIPHER_param_to_asn1(ctx, encalg->parameter) <= 0) { ERR_raise(ERR_LIB_CMS, CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR); goto err; } } encalg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_get_type(ctx)); EVP_CIPHER_CTX_free(ctx); ctx = NULL; /* Initialize recipient info */ ri = M_ASN1_new_of(CMS_RecipientInfo); if (ri == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } ri->d.pwri = M_ASN1_new_of(CMS_PasswordRecipientInfo); if (ri->d.pwri == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } ri->type = CMS_RECIPINFO_PASS; pwri = ri->d.pwri; pwri->cms_ctx = cms_ctx; /* Since this is overwritten, free up empty structure already there */ X509_ALGOR_free(pwri->keyEncryptionAlgorithm); pwri->keyEncryptionAlgorithm = X509_ALGOR_new(); if (pwri->keyEncryptionAlgorithm == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } pwri->keyEncryptionAlgorithm->algorithm = OBJ_nid2obj(wrap_nid); pwri->keyEncryptionAlgorithm->parameter = ASN1_TYPE_new(); if (pwri->keyEncryptionAlgorithm->parameter == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } if (!ASN1_item_pack(encalg, ASN1_ITEM_rptr(X509_ALGOR), &pwri->keyEncryptionAlgorithm->parameter-> value.sequence)) { ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB); goto err; } pwri->keyEncryptionAlgorithm->parameter->type = V_ASN1_SEQUENCE; X509_ALGOR_free(encalg); encalg = NULL; /* Setup PBE algorithm */ pwri->keyDerivationAlgorithm = PKCS5_pbkdf2_set_ex(iter, NULL, 0, -1, -1, cms_ctx->libctx); if (pwri->keyDerivationAlgorithm == NULL) goto err; CMS_RecipientInfo_set0_password(ri, pass, passlen); pwri->version = 0; if (!sk_CMS_RecipientInfo_push(ris, ri)) { ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB); goto err; } return ri; err: EVP_CIPHER_CTX_free(ctx); if (ri) M_ASN1_free_of(ri, CMS_RecipientInfo); X509_ALGOR_free(encalg); return NULL; } /* * This is an implementation of the key wrapping mechanism in RFC3211, at * some point this should go into EVP. */ static int kek_unwrap_key(unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen, EVP_CIPHER_CTX *ctx) { size_t blocklen = EVP_CIPHER_CTX_get_block_size(ctx); unsigned char *tmp; int outl, rv = 0; if (blocklen == 0) return 0; if (inlen < 2 * blocklen) { /* too small */ return 0; } if (inlen % blocklen) { /* Invalid size */ return 0; } if ((tmp = OPENSSL_malloc(inlen)) == NULL) return 0; /* setup IV by decrypting last two blocks */ if (!EVP_DecryptUpdate(ctx, tmp + inlen - 2 * blocklen, &outl, in + inlen - 2 * blocklen, blocklen * 2) /* * Do a decrypt of last decrypted block to set IV to correct value * output it to start of buffer so we don't corrupt decrypted block * this works because buffer is at least two block lengths long. */ || !EVP_DecryptUpdate(ctx, tmp, &outl, tmp + inlen - blocklen, blocklen) /* Can now decrypt first n - 1 blocks */ || !EVP_DecryptUpdate(ctx, tmp, &outl, in, inlen - blocklen) /* Reset IV to original value */ || !EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, NULL) /* Decrypt again */ || !EVP_DecryptUpdate(ctx, tmp, &outl, tmp, inlen)) goto err; /* Check check bytes */ if (((tmp[1] ^ tmp[4]) & (tmp[2] ^ tmp[5]) & (tmp[3] ^ tmp[6])) != 0xff) { /* Check byte failure */ goto err; } - if (inlen < (size_t)(tmp[0] - 4)) { + if (inlen < 4 + (size_t)tmp[0]) { /* Invalid length value */ goto err; } *outlen = (size_t)tmp[0]; memcpy(out, tmp + 4, *outlen); rv = 1; err: OPENSSL_clear_free(tmp, inlen); return rv; } static int kek_wrap_key(unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen, EVP_CIPHER_CTX *ctx, const CMS_CTX *cms_ctx) { size_t blocklen = EVP_CIPHER_CTX_get_block_size(ctx); size_t olen; int dummy; if (blocklen == 0) return 0; /* * First decide length of output buffer: need header and round up to * multiple of block length. */ olen = (inlen + 4 + blocklen - 1) / blocklen; olen *= blocklen; if (olen < 2 * blocklen) { /* Key too small */ return 0; } if (inlen > 0xFF) { /* Key too large */ return 0; } if (out) { /* Set header */ out[0] = (unsigned char)inlen; out[1] = in[0] ^ 0xFF; out[2] = in[1] ^ 0xFF; out[3] = in[2] ^ 0xFF; memcpy(out + 4, in, inlen); /* Add random padding to end */ if (olen > inlen + 4 && RAND_bytes_ex(ossl_cms_ctx_get0_libctx(cms_ctx), out + 4 + inlen, olen - 4 - inlen, 0) <= 0) return 0; /* Encrypt twice */ if (!EVP_EncryptUpdate(ctx, out, &dummy, out, olen) || !EVP_EncryptUpdate(ctx, out, &dummy, out, olen)) return 0; } *outlen = olen; return 1; } /* Encrypt/Decrypt content key in PWRI recipient info */ int ossl_cms_RecipientInfo_pwri_crypt(const CMS_ContentInfo *cms, CMS_RecipientInfo *ri, int en_de) { CMS_EncryptedContentInfo *ec; CMS_PasswordRecipientInfo *pwri; int r = 0; X509_ALGOR *algtmp, *kekalg = NULL; EVP_CIPHER_CTX *kekctx = NULL; char name[OSSL_MAX_NAME_SIZE]; EVP_CIPHER *kekcipher; unsigned char *key = NULL; size_t keylen; const CMS_CTX *cms_ctx = ossl_cms_get0_cmsctx(cms); ec = ossl_cms_get0_env_enc_content(cms); pwri = ri->d.pwri; if (pwri->pass == NULL) { ERR_raise(ERR_LIB_CMS, CMS_R_NO_PASSWORD); return 0; } algtmp = pwri->keyEncryptionAlgorithm; if (!algtmp || OBJ_obj2nid(algtmp->algorithm) != NID_id_alg_PWRI_KEK) { ERR_raise(ERR_LIB_CMS, CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM); return 0; } kekalg = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(X509_ALGOR), algtmp->parameter); if (kekalg == NULL) { ERR_raise(ERR_LIB_CMS, CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER); return 0; } OBJ_obj2txt(name, sizeof(name), kekalg->algorithm, 0); kekcipher = EVP_CIPHER_fetch(ossl_cms_ctx_get0_libctx(cms_ctx), name, ossl_cms_ctx_get0_propq(cms_ctx)); if (kekcipher == NULL) { ERR_raise(ERR_LIB_CMS, CMS_R_UNKNOWN_CIPHER); goto err; } kekctx = EVP_CIPHER_CTX_new(); if (kekctx == NULL) { ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB); goto err; } /* Fixup cipher based on AlgorithmIdentifier to set IV etc */ if (!EVP_CipherInit_ex(kekctx, kekcipher, NULL, NULL, NULL, en_de)) goto err; EVP_CIPHER_CTX_set_padding(kekctx, 0); if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) <= 0) { ERR_raise(ERR_LIB_CMS, CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR); goto err; } algtmp = pwri->keyDerivationAlgorithm; /* Finish password based key derivation to setup key in "ctx" */ if (EVP_PBE_CipherInit_ex(algtmp->algorithm, (char *)pwri->pass, pwri->passlen, algtmp->parameter, kekctx, en_de, cms_ctx->libctx, cms_ctx->propq) < 0) { ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB); goto err; } /* Finally wrap/unwrap the key */ if (en_de) { if (!kek_wrap_key(NULL, &keylen, ec->key, ec->keylen, kekctx, cms_ctx)) goto err; key = OPENSSL_malloc(keylen); if (key == NULL) goto err; if (!kek_wrap_key(key, &keylen, ec->key, ec->keylen, kekctx, cms_ctx)) goto err; pwri->encryptedKey->data = key; pwri->encryptedKey->length = keylen; } else { key = OPENSSL_malloc(pwri->encryptedKey->length); if (key == NULL) goto err; if (!kek_unwrap_key(key, &keylen, pwri->encryptedKey->data, pwri->encryptedKey->length, kekctx)) { ERR_raise(ERR_LIB_CMS, CMS_R_UNWRAP_FAILURE); goto err; } OPENSSL_clear_free(ec->key, ec->keylen); ec->key = key; ec->keylen = keylen; } r = 1; err: EVP_CIPHER_free(kekcipher); EVP_CIPHER_CTX_free(kekctx); if (!r) OPENSSL_free(key); X509_ALGOR_free(kekalg); return r; } diff --git a/crypto/openssl/crypto/ec/ecp_sm2p256.c b/crypto/openssl/crypto/ec/ecp_sm2p256.c index 7668b61378b6..ffb58399dfd0 100644 --- a/crypto/openssl/crypto/ec/ecp_sm2p256.c +++ b/crypto/openssl/crypto/ec/ecp_sm2p256.c @@ -1,790 +1,695 @@ /* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html * */ /* * SM2 low level APIs are deprecated for public use, but still ok for * internal use. */ #include "internal/deprecated.h" #include #include #include "crypto/bn.h" #include "ec_local.h" #include "internal/common.h" #include "internal/constant_time.h" #define P256_LIMBS (256 / BN_BITS2) #if !defined(OPENSSL_NO_SM2_PRECOMP) extern const BN_ULONG ecp_sm2p256_precomputed[8 * 32 * 256]; #endif typedef struct { BN_ULONG X[P256_LIMBS]; BN_ULONG Y[P256_LIMBS]; BN_ULONG Z[P256_LIMBS]; } P256_POINT; typedef struct { BN_ULONG X[P256_LIMBS]; BN_ULONG Y[P256_LIMBS]; } P256_POINT_AFFINE; #if !defined(OPENSSL_NO_SM2_PRECOMP) /* Coordinates of G, for which we have precomputed tables */ ALIGN32 static const BN_ULONG def_xG[P256_LIMBS] = { 0x715a4589334c74c7, 0x8fe30bbff2660be1, 0x5f9904466a39c994, 0x32c4ae2c1f198119 }; ALIGN32 static const BN_ULONG def_yG[P256_LIMBS] = { 0x02df32e52139f0a0, 0xd0a9877cc62a4740, 0x59bdcee36b692153, 0xbc3736a2f4f6779c, }; #endif /* p and order for SM2 according to GB/T 32918.5-2017 */ ALIGN32 static const BN_ULONG def_p[P256_LIMBS] = { 0xffffffffffffffff, 0xffffffff00000000, 0xffffffffffffffff, 0xfffffffeffffffff }; -ALIGN32 static const BN_ULONG def_ord[P256_LIMBS] = { - 0x53bbf40939d54123, 0x7203df6b21c6052b, - 0xffffffffffffffff, 0xfffffffeffffffff -}; ALIGN32 static const BN_ULONG ONE[P256_LIMBS] = {1, 0, 0, 0}; /* Functions implemented in assembly */ /* * Most of below mentioned functions *preserve* the property of inputs * being fully reduced, i.e. being in [0, modulus) range. Simply put if * inputs are fully reduced, then output is too. */ /* Right shift: a >> 1 */ void bn_rshift1(BN_ULONG *a); /* Sub: r = a - b */ void bn_sub(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b); /* Modular div by 2: r = a / 2 mod p */ void ecp_sm2p256_div_by_2(BN_ULONG *r, const BN_ULONG *a); /* Modular div by 2: r = a / 2 mod n, where n = ord(p) */ void ecp_sm2p256_div_by_2_mod_ord(BN_ULONG *r, const BN_ULONG *a); /* Modular add: r = a + b mod p */ void ecp_sm2p256_add(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b); /* Modular sub: r = a - b mod p */ void ecp_sm2p256_sub(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b); /* Modular sub: r = a - b mod n, where n = ord(p) */ void ecp_sm2p256_sub_mod_ord(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b); /* Modular mul by 3: out = 3 * a mod p */ void ecp_sm2p256_mul_by_3(BN_ULONG *r, const BN_ULONG *a); /* Modular mul: r = a * b mod p */ void ecp_sm2p256_mul(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b); /* Modular sqr: r = a ^ 2 mod p */ void ecp_sm2p256_sqr(BN_ULONG *r, const BN_ULONG *a); static ossl_inline BN_ULONG is_zeros(const BN_ULONG *a) { BN_ULONG res; res = a[0] | a[1] | a[2] | a[3]; return constant_time_is_zero_64(res); } static ossl_inline int is_equal(const BN_ULONG *a, const BN_ULONG *b) { BN_ULONG res; res = a[0] ^ b[0]; res |= a[1] ^ b[1]; res |= a[2] ^ b[2]; res |= a[3] ^ b[3]; return constant_time_is_zero_64(res); } static ossl_inline int is_greater(const BN_ULONG *a, const BN_ULONG *b) { int i; for (i = P256_LIMBS - 1; i >= 0; --i) { if (a[i] > b[i]) return 1; if (a[i] < b[i]) return -1; } return 0; } #define is_one(a) is_equal(a, ONE) #define is_even(a) !(a[0] & 1) #define is_point_equal(a, b) \ is_equal(a->X, b->X) && \ is_equal(a->Y, b->Y) && \ is_equal(a->Z, b->Z) /* Bignum and field elements conversion */ #define ecp_sm2p256_bignum_field_elem(out, in) \ bn_copy_words(out, in, P256_LIMBS) /* Binary algorithm for inversion in Fp */ #define BN_MOD_INV(out, in, mod_div, mod_sub, mod) \ do { \ ALIGN32 BN_ULONG u[4]; \ ALIGN32 BN_ULONG v[4]; \ ALIGN32 BN_ULONG x1[4] = {1, 0, 0, 0}; \ ALIGN32 BN_ULONG x2[4] = {0}; \ \ if (is_zeros(in)) \ return; \ memcpy(u, in, 32); \ memcpy(v, mod, 32); \ while (!is_one(u) && !is_one(v)) { \ while (is_even(u)) { \ bn_rshift1(u); \ mod_div(x1, x1); \ } \ while (is_even(v)) { \ bn_rshift1(v); \ mod_div(x2, x2); \ } \ if (is_greater(u, v) == 1) { \ bn_sub(u, u, v); \ mod_sub(x1, x1, x2); \ } else { \ bn_sub(v, v, u); \ mod_sub(x2, x2, x1); \ } \ } \ if (is_one(u)) \ memcpy(out, x1, 32); \ else \ memcpy(out, x2, 32); \ } while (0) /* Modular inverse |out| = |in|^(-1) mod |p|. */ static ossl_inline void ecp_sm2p256_mod_inverse(BN_ULONG* out, const BN_ULONG* in) { BN_MOD_INV(out, in, ecp_sm2p256_div_by_2, ecp_sm2p256_sub, def_p); } -/* Modular inverse mod order |out| = |in|^(-1) % |ord|. */ -static ossl_inline void ecp_sm2p256_mod_ord_inverse(BN_ULONG* out, - const BN_ULONG* in) { - BN_MOD_INV(out, in, ecp_sm2p256_div_by_2_mod_ord, ecp_sm2p256_sub_mod_ord, - def_ord); -} - /* Point double: R <- P + P */ static void ecp_sm2p256_point_double(P256_POINT *R, const P256_POINT *P) { unsigned int i; ALIGN32 BN_ULONG tmp0[P256_LIMBS]; ALIGN32 BN_ULONG tmp1[P256_LIMBS]; ALIGN32 BN_ULONG tmp2[P256_LIMBS]; /* zero-check P->Z */ if (is_zeros(P->Z)) { for (i = 0; i < P256_LIMBS; ++i) R->Z[i] = 0; return; } ecp_sm2p256_sqr(tmp0, P->Z); ecp_sm2p256_sub(tmp1, P->X, tmp0); ecp_sm2p256_add(tmp0, P->X, tmp0); ecp_sm2p256_mul(tmp1, tmp1, tmp0); ecp_sm2p256_mul_by_3(tmp1, tmp1); ecp_sm2p256_add(R->Y, P->Y, P->Y); ecp_sm2p256_mul(R->Z, R->Y, P->Z); ecp_sm2p256_sqr(R->Y, R->Y); ecp_sm2p256_mul(tmp2, R->Y, P->X); ecp_sm2p256_sqr(R->Y, R->Y); ecp_sm2p256_div_by_2(R->Y, R->Y); ecp_sm2p256_sqr(R->X, tmp1); ecp_sm2p256_add(tmp0, tmp2, tmp2); ecp_sm2p256_sub(R->X, R->X, tmp0); ecp_sm2p256_sub(tmp0, tmp2, R->X); ecp_sm2p256_mul(tmp0, tmp0, tmp1); ecp_sm2p256_sub(tmp1, tmp0, R->Y); memcpy(R->Y, tmp1, 32); } /* Point add affine: R <- P + Q */ static void ecp_sm2p256_point_add_affine(P256_POINT *R, const P256_POINT *P, const P256_POINT_AFFINE *Q) { unsigned int i; ALIGN32 BN_ULONG tmp0[P256_LIMBS] = {0}; ALIGN32 BN_ULONG tmp1[P256_LIMBS] = {0}; ALIGN32 BN_ULONG tmp2[P256_LIMBS] = {0}; ALIGN32 BN_ULONG tmp3[P256_LIMBS] = {0}; /* zero-check P->Z */ if (is_zeros(P->Z)) { for (i = 0; i < P256_LIMBS; ++i) { R->X[i] = Q->X[i]; R->Y[i] = Q->Y[i]; R->Z[i] = 0; } R->Z[0] = 1; return; } ecp_sm2p256_sqr(tmp0, P->Z); ecp_sm2p256_mul(tmp1, tmp0, P->Z); ecp_sm2p256_mul(tmp0, tmp0, Q->X); ecp_sm2p256_mul(tmp1, tmp1, Q->Y); ecp_sm2p256_sub(tmp0, tmp0, P->X); ecp_sm2p256_sub(tmp1, tmp1, P->Y); /* zero-check tmp0, tmp1 */ if (is_zeros(tmp0)) { if (is_zeros(tmp1)) { P256_POINT K; for (i = 0; i < P256_LIMBS; ++i) { K.X[i] = Q->X[i]; K.Y[i] = Q->Y[i]; K.Z[i] = 0; } K.Z[0] = 1; ecp_sm2p256_point_double(R, &K); } else { for (i = 0; i < P256_LIMBS; ++i) R->Z[i] = 0; } return; } ecp_sm2p256_mul(R->Z, P->Z, tmp0); ecp_sm2p256_sqr(tmp2, tmp0); ecp_sm2p256_mul(tmp3, tmp2, tmp0); ecp_sm2p256_mul(tmp2, tmp2, P->X); ecp_sm2p256_add(tmp0, tmp2, tmp2); ecp_sm2p256_sqr(R->X, tmp1); ecp_sm2p256_sub(R->X, R->X, tmp0); ecp_sm2p256_sub(R->X, R->X, tmp3); ecp_sm2p256_sub(tmp2, tmp2, R->X); ecp_sm2p256_mul(tmp2, tmp2, tmp1); ecp_sm2p256_mul(tmp3, tmp3, P->Y); ecp_sm2p256_sub(R->Y, tmp2, tmp3); } /* Point add: R <- P + Q */ static void ecp_sm2p256_point_add(P256_POINT *R, const P256_POINT *P, const P256_POINT *Q) { unsigned int i; ALIGN32 BN_ULONG tmp0[P256_LIMBS] = {0}; ALIGN32 BN_ULONG tmp1[P256_LIMBS] = {0}; ALIGN32 BN_ULONG tmp2[P256_LIMBS] = {0}; /* zero-check P | Q ->Z */ if (is_zeros(P->Z)) { for (i = 0; i < P256_LIMBS; ++i) { R->X[i] = Q->X[i]; R->Y[i] = Q->Y[i]; R->Z[i] = Q->Z[i]; } return; } else if (is_zeros(Q->Z)) { for (i = 0; i < P256_LIMBS; ++i) { R->X[i] = P->X[i]; R->Y[i] = P->Y[i]; R->Z[i] = P->Z[i]; } return; } else if (is_point_equal(P, Q)) { ecp_sm2p256_point_double(R, Q); return; } ecp_sm2p256_sqr(tmp0, P->Z); ecp_sm2p256_mul(tmp1, tmp0, P->Z); ecp_sm2p256_mul(tmp0, tmp0, Q->X); ecp_sm2p256_mul(tmp1, tmp1, Q->Y); ecp_sm2p256_mul(R->Y, P->Y, Q->Z); ecp_sm2p256_mul(R->Z, Q->Z, P->Z); ecp_sm2p256_sqr(tmp2, Q->Z); ecp_sm2p256_mul(R->Y, tmp2, R->Y); ecp_sm2p256_mul(R->X, tmp2, P->X); ecp_sm2p256_sub(tmp0, tmp0, R->X); ecp_sm2p256_mul(R->Z, tmp0, R->Z); ecp_sm2p256_sub(tmp1, tmp1, R->Y); ecp_sm2p256_sqr(tmp2, tmp0); ecp_sm2p256_mul(tmp0, tmp0, tmp2); ecp_sm2p256_mul(tmp2, tmp2, R->X); ecp_sm2p256_sqr(R->X, tmp1); ecp_sm2p256_sub(R->X, R->X, tmp2); ecp_sm2p256_sub(R->X, R->X, tmp2); ecp_sm2p256_sub(R->X, R->X, tmp0); ecp_sm2p256_sub(tmp2, tmp2, R->X); ecp_sm2p256_mul(tmp2, tmp1, tmp2); ecp_sm2p256_mul(tmp0, tmp0, R->Y); ecp_sm2p256_sub(R->Y, tmp2, tmp0); } #if !defined(OPENSSL_NO_SM2_PRECOMP) /* Base point mul by scalar: k - scalar, G - base point */ static void ecp_sm2p256_point_G_mul_by_scalar(P256_POINT *R, const BN_ULONG *k) { unsigned int i, index, mask = 0xff; P256_POINT_AFFINE Q; memset(R, 0, sizeof(P256_POINT)); if (is_zeros(k)) return; index = k[0] & mask; if (index) { index = index * 8; memcpy(R->X, ecp_sm2p256_precomputed + index, 32); memcpy(R->Y, ecp_sm2p256_precomputed + index + P256_LIMBS, 32); R->Z[0] = 1; } for (i = 1; i < 32; ++i) { index = (k[i / 8] >> (8 * (i % 8))) & mask; if (index) { index = index + i * 256; index = index * 8; memcpy(Q.X, ecp_sm2p256_precomputed + index, 32); memcpy(Q.Y, ecp_sm2p256_precomputed + index + P256_LIMBS, 32); ecp_sm2p256_point_add_affine(R, R, &Q); } } } #endif /* * Affine point mul by scalar: k - scalar, P - affine point */ static void ecp_sm2p256_point_P_mul_by_scalar(P256_POINT *R, const BN_ULONG *k, P256_POINT_AFFINE P) { int i, init = 0; unsigned int index, mask = 0x0f; ALIGN64 P256_POINT precomputed[16]; memset(R, 0, sizeof(P256_POINT)); if (is_zeros(k)) return; /* The first value of the precomputed table is P. */ memcpy(precomputed[1].X, P.X, 32); memcpy(precomputed[1].Y, P.Y, 32); precomputed[1].Z[0] = 1; precomputed[1].Z[1] = 0; precomputed[1].Z[2] = 0; precomputed[1].Z[3] = 0; /* The second value of the precomputed table is 2P. */ ecp_sm2p256_point_double(&precomputed[2], &precomputed[1]); /* The subsequent elements are 3P, 4P, and so on. */ for (i = 3; i < 16; ++i) ecp_sm2p256_point_add_affine(&precomputed[i], &precomputed[i - 1], &P); for (i = 64 - 1; i >= 0; --i) { index = (k[i / 16] >> (4 * (i % 16))) & mask; if (init == 0) { if (index) { memcpy(R, &precomputed[index], sizeof(P256_POINT)); init = 1; } } else { ecp_sm2p256_point_double(R, R); ecp_sm2p256_point_double(R, R); ecp_sm2p256_point_double(R, R); ecp_sm2p256_point_double(R, R); if (index) ecp_sm2p256_point_add(R, R, &precomputed[index]); } } } /* Get affine point */ static void ecp_sm2p256_point_get_affine(P256_POINT_AFFINE *R, const P256_POINT *P) { ALIGN32 BN_ULONG z_inv3[P256_LIMBS] = {0}; ALIGN32 BN_ULONG z_inv2[P256_LIMBS] = {0}; if (is_one(P->Z)) { memcpy(R->X, P->X, 32); memcpy(R->Y, P->Y, 32); return; } ecp_sm2p256_mod_inverse(z_inv3, P->Z); ecp_sm2p256_sqr(z_inv2, z_inv3); ecp_sm2p256_mul(R->X, P->X, z_inv2); ecp_sm2p256_mul(z_inv3, z_inv3, z_inv2); ecp_sm2p256_mul(R->Y, P->Y, z_inv3); } #if !defined(OPENSSL_NO_SM2_PRECOMP) static int ecp_sm2p256_is_affine_G(const EC_POINT *generator) { return (bn_get_top(generator->X) == P256_LIMBS) && (bn_get_top(generator->Y) == P256_LIMBS) && is_equal(bn_get_words(generator->X), def_xG) && is_equal(bn_get_words(generator->Y), def_yG) && (generator->Z_is_one == 1); } #endif -/* - * Convert Jacobian coordinate point into affine coordinate (x,y) - */ -static int ecp_sm2p256_get_affine(const EC_GROUP *group, - const EC_POINT *point, - BIGNUM *x, BIGNUM *y, BN_CTX *ctx) -{ - ALIGN32 BN_ULONG z_inv2[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG z_inv3[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG x_aff[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG y_aff[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG point_x[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG point_y[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG point_z[P256_LIMBS] = {0}; - - if (EC_POINT_is_at_infinity(group, point)) { - ECerr(ERR_LIB_EC, EC_R_POINT_AT_INFINITY); - return 0; - } - - if (ecp_sm2p256_bignum_field_elem(point_x, point->X) <= 0 - || ecp_sm2p256_bignum_field_elem(point_y, point->Y) <= 0 - || ecp_sm2p256_bignum_field_elem(point_z, point->Z) <= 0) { - ECerr(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE); - return 0; - } - - ecp_sm2p256_mod_inverse(z_inv3, point_z); - ecp_sm2p256_sqr(z_inv2, z_inv3); - - if (x != NULL) { - ecp_sm2p256_mul(x_aff, point_x, z_inv2); - if (!bn_set_words(x, x_aff, P256_LIMBS)) - return 0; - } - - if (y != NULL) { - ecp_sm2p256_mul(z_inv3, z_inv3, z_inv2); - ecp_sm2p256_mul(y_aff, point_y, z_inv3); - if (!bn_set_words(y, y_aff, P256_LIMBS)) - return 0; - } - - return 1; -} - /* r = sum(scalar[i]*point[i]) */ static int ecp_sm2p256_windowed_mul(const EC_GROUP *group, P256_POINT *r, const BIGNUM **scalar, const EC_POINT **point, size_t num, BN_CTX *ctx) { unsigned int i; int ret = 0; const BIGNUM **scalars = NULL; ALIGN32 BN_ULONG k[P256_LIMBS] = {0}; P256_POINT kP; ALIGN32 union { P256_POINT p; P256_POINT_AFFINE a; } t, p; if (num > OPENSSL_MALLOC_MAX_NELEMS(P256_POINT) || (scalars = OPENSSL_malloc(num * sizeof(BIGNUM *))) == NULL) { ECerr(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); goto err; } memset(r, 0, sizeof(P256_POINT)); for (i = 0; i < num; i++) { if (EC_POINT_is_at_infinity(group, point[i])) continue; if ((BN_num_bits(scalar[i]) > 256) || BN_is_negative(scalar[i])) { BIGNUM *tmp; if ((tmp = BN_CTX_get(ctx)) == NULL) goto err; if (!BN_nnmod(tmp, scalar[i], group->order, ctx)) { ECerr(ERR_LIB_EC, ERR_R_BN_LIB); goto err; } scalars[i] = tmp; } else { scalars[i] = scalar[i]; } if (ecp_sm2p256_bignum_field_elem(k, scalars[i]) <= 0 || ecp_sm2p256_bignum_field_elem(p.p.X, point[i]->X) <= 0 || ecp_sm2p256_bignum_field_elem(p.p.Y, point[i]->Y) <= 0 || ecp_sm2p256_bignum_field_elem(p.p.Z, point[i]->Z) <= 0) { ECerr(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE); goto err; } ecp_sm2p256_point_get_affine(&t.a, &p.p); ecp_sm2p256_point_P_mul_by_scalar(&kP, k, t.a); ecp_sm2p256_point_add(r, r, &kP); } ret = 1; err: OPENSSL_free(scalars); return ret; } /* r = scalar*G + sum(scalars[i]*points[i]) */ static int ecp_sm2p256_points_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar, size_t num, const EC_POINT *points[], const BIGNUM *scalars[], BN_CTX *ctx) { int ret = 0, p_is_infinity = 0; const EC_POINT *generator = NULL; ALIGN32 BN_ULONG k[P256_LIMBS] = {0}; ALIGN32 union { P256_POINT p; P256_POINT_AFFINE a; } t, p; if ((num + 1) == 0 || (num + 1) > OPENSSL_MALLOC_MAX_NELEMS(void *)) { ECerr(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); goto err; } BN_CTX_start(ctx); if (scalar) { generator = EC_GROUP_get0_generator(group); if (generator == NULL) { ECerr(ERR_LIB_EC, EC_R_UNDEFINED_GENERATOR); goto err; } if (!ecp_sm2p256_bignum_field_elem(k, scalar)) { ECerr(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE); goto err; } #if !defined(OPENSSL_NO_SM2_PRECOMP) if (ecp_sm2p256_is_affine_G(generator)) { ecp_sm2p256_point_G_mul_by_scalar(&p.p, k); } else #endif { /* if no precomputed table */ const EC_POINT *new_generator[1]; const BIGNUM *g_scalars[1]; new_generator[0] = generator; g_scalars[0] = scalar; if (!ecp_sm2p256_windowed_mul(group, &p.p, g_scalars, new_generator, (new_generator[0] != NULL && g_scalars[0] != NULL), ctx)) goto err; } } else { p_is_infinity = 1; } if (num) { P256_POINT *out = &t.p; if (p_is_infinity) out = &p.p; if (!ecp_sm2p256_windowed_mul(group, out, scalars, points, num, ctx)) goto err; if (!p_is_infinity) ecp_sm2p256_point_add(&p.p, &p.p, out); } /* Not constant-time, but we're only operating on the public output. */ if (!bn_set_words(r->X, p.p.X, P256_LIMBS) || !bn_set_words(r->Y, p.p.Y, P256_LIMBS) || !bn_set_words(r->Z, p.p.Z, P256_LIMBS)) goto err; r->Z_is_one = is_equal(bn_get_words(r->Z), ONE) & 1; ret = 1; err: BN_CTX_end(ctx); return ret; } static int ecp_sm2p256_field_mul(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) { ALIGN32 BN_ULONG a_fe[P256_LIMBS] = {0}; ALIGN32 BN_ULONG b_fe[P256_LIMBS] = {0}; ALIGN32 BN_ULONG r_fe[P256_LIMBS] = {0}; if (a == NULL || b == NULL || r == NULL) return 0; if (!ecp_sm2p256_bignum_field_elem(a_fe, a) || !ecp_sm2p256_bignum_field_elem(b_fe, b)) { ECerr(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE); return 0; } ecp_sm2p256_mul(r_fe, a_fe, b_fe); if (!bn_set_words(r, r_fe, P256_LIMBS)) return 0; return 1; } static int ecp_sm2p256_field_sqr(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) { ALIGN32 BN_ULONG a_fe[P256_LIMBS] = {0}; ALIGN32 BN_ULONG r_fe[P256_LIMBS] = {0}; if (a == NULL || r == NULL) return 0; if (!ecp_sm2p256_bignum_field_elem(a_fe, a)) { ECerr(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE); return 0; } ecp_sm2p256_sqr(r_fe, a_fe); if (!bn_set_words(r, r_fe, P256_LIMBS)) return 0; return 1; } -static int ecp_sm2p256_inv_mod_ord(const EC_GROUP *group, BIGNUM *r, - const BIGNUM *x, BN_CTX *ctx) -{ - int ret = 0; - ALIGN32 BN_ULONG t[P256_LIMBS] = {0}; - ALIGN32 BN_ULONG out[P256_LIMBS] = {0}; - - if (bn_wexpand(r, P256_LIMBS) == NULL) { - ECerr(ERR_LIB_EC, ERR_R_BN_LIB); - goto err; - } - - if ((BN_num_bits(x) > 256) || BN_is_negative(x)) { - BIGNUM *tmp; - - if ((tmp = BN_CTX_get(ctx)) == NULL - || !BN_nnmod(tmp, x, group->order, ctx)) { - ECerr(ERR_LIB_EC, ERR_R_BN_LIB); - goto err; - } - x = tmp; - } - - if (!ecp_sm2p256_bignum_field_elem(t, x)) { - ECerr(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE); - goto err; - } - - ecp_sm2p256_mod_ord_inverse(out, t); - - if (!bn_set_words(r, out, P256_LIMBS)) - goto err; - - ret = 1; -err: - return ret; -} - const EC_METHOD *EC_GFp_sm2p256_method(void) { static const EC_METHOD ret = { EC_FLAGS_DEFAULT_OCT, NID_X9_62_prime_field, ossl_ec_GFp_simple_group_init, ossl_ec_GFp_simple_group_finish, ossl_ec_GFp_simple_group_clear_finish, ossl_ec_GFp_simple_group_copy, ossl_ec_GFp_simple_group_set_curve, ossl_ec_GFp_simple_group_get_curve, ossl_ec_GFp_simple_group_get_degree, ossl_ec_group_simple_order_bits, ossl_ec_GFp_simple_group_check_discriminant, ossl_ec_GFp_simple_point_init, ossl_ec_GFp_simple_point_finish, ossl_ec_GFp_simple_point_clear_finish, ossl_ec_GFp_simple_point_copy, ossl_ec_GFp_simple_point_set_to_infinity, ossl_ec_GFp_simple_point_set_affine_coordinates, - ecp_sm2p256_get_affine, + ossl_ec_GFp_simple_point_get_affine_coordinates, 0, 0, 0, ossl_ec_GFp_simple_add, ossl_ec_GFp_simple_dbl, ossl_ec_GFp_simple_invert, ossl_ec_GFp_simple_is_at_infinity, ossl_ec_GFp_simple_is_on_curve, ossl_ec_GFp_simple_cmp, ossl_ec_GFp_simple_make_affine, ossl_ec_GFp_simple_points_make_affine, ecp_sm2p256_points_mul, /* mul */ 0 /* precompute_mult */, 0 /* have_precompute_mult */, ecp_sm2p256_field_mul, ecp_sm2p256_field_sqr, 0 /* field_div */, - 0 /* field_inv */, + ossl_ec_GFp_simple_field_inv, 0 /* field_encode */, 0 /* field_decode */, 0 /* field_set_to_one */, ossl_ec_key_simple_priv2oct, ossl_ec_key_simple_oct2priv, 0, /* set private */ ossl_ec_key_simple_generate_key, ossl_ec_key_simple_check_key, ossl_ec_key_simple_generate_public_key, 0, /* keycopy */ 0, /* keyfinish */ ossl_ecdh_simple_compute_key, ossl_ecdsa_simple_sign_setup, ossl_ecdsa_simple_sign_sig, ossl_ecdsa_simple_verify_sig, - ecp_sm2p256_inv_mod_ord, + 0, /* use constant‑time fallback for inverse mod order */ 0, /* blind_coordinates */ 0, /* ladder_pre */ 0, /* ladder_step */ 0 /* ladder_post */ }; return &ret; } diff --git a/crypto/openssl/crypto/http/http_lib.c b/crypto/openssl/crypto/http/http_lib.c index fcf8a69e07a8..022b8c194cbe 100644 --- a/crypto/openssl/crypto/http/http_lib.c +++ b/crypto/openssl/crypto/http/http_lib.c @@ -1,305 +1,306 @@ /* * Copyright 2001-2025 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include /* for sscanf() */ #include #include #include #include /* for BIO_snprintf() */ #include #include "internal/cryptlib.h" /* for ossl_assert() */ #ifndef OPENSSL_NO_SOCK # include "internal/bio_addr.h" /* for NI_MAXHOST */ #endif #ifndef NI_MAXHOST # define NI_MAXHOST 255 #endif #include "crypto/ctype.h" /* for ossl_isspace() */ static void init_pstring(char **pstr) { if (pstr != NULL) { *pstr = NULL; } } static void init_pint(int *pint) { if (pint != NULL) { *pint = 0; } } static int copy_substring(char **dest, const char *start, const char *end) { return dest == NULL || (*dest = OPENSSL_strndup(start, end - start)) != NULL; } static void free_pstring(char **pstr) { if (pstr != NULL) { OPENSSL_free(*pstr); *pstr = NULL; } } int OSSL_parse_url(const char *url, char **pscheme, char **puser, char **phost, char **pport, int *pport_num, char **ppath, char **pquery, char **pfrag) { const char *p, *tmp; const char *scheme, *scheme_end; const char *user, *user_end; const char *host, *host_end; const char *port, *port_end; unsigned int portnum = 0; const char *path, *path_end; const char *query, *query_end; const char *frag, *frag_end; init_pstring(pscheme); init_pstring(puser); init_pstring(phost); init_pstring(pport); init_pint(pport_num); init_pstring(ppath); init_pstring(pfrag); init_pstring(pquery); if (url == NULL) { ERR_raise(ERR_LIB_HTTP, ERR_R_PASSED_NULL_PARAMETER); return 0; } /* check for optional prefix "://" */ scheme = scheme_end = url; p = strstr(url, "://"); if (p == NULL) { p = url; } else { scheme_end = p; if (scheme_end == scheme) goto parse_err; p += strlen("://"); } /* parse optional "userinfo@" */ user = user_end = host = p; host = strchr(p, '@'); if (host != NULL) user_end = host++; else host = p; /* parse hostname/address as far as needed here */ if (host[0] == '[') { /* IPv6 literal, which may include ':' */ host_end = strchr(host + 1, ']'); if (host_end == NULL) goto parse_err; p = ++host_end; } else { /* look for start of optional port, path, query, or fragment */ host_end = strpbrk(host, ":/?#"); if (host_end == NULL) /* the remaining string is just the hostname */ host_end = host + strlen(host); p = host_end; } /* parse optional port specification starting with ':' */ port = "0"; /* default */ if (*p == ':') port = ++p; /* remaining port spec handling is also done for the default values */ /* make sure a decimal port number is given */ if (sscanf(port, "%u", &portnum) <= 0 || portnum > 65535) { ERR_raise_data(ERR_LIB_HTTP, HTTP_R_INVALID_PORT_NUMBER, "%s", port); goto err; } for (port_end = port; '0' <= *port_end && *port_end <= '9'; port_end++) ; if (port == p) /* port was given explicitly */ p += port_end - port; /* check for optional path starting with '/' or '?'. Else must start '#' */ path = p; if (*path != '\0' && *path != '/' && *path != '?' && *path != '#') { ERR_raise(ERR_LIB_HTTP, HTTP_R_INVALID_URL_PATH); goto parse_err; } path_end = query = query_end = frag = frag_end = path + strlen(path); /* parse optional "?query" */ tmp = strchr(p, '?'); if (tmp != NULL) { p = tmp; if (pquery != NULL) { path_end = p; query = p + 1; } } /* parse optional "#fragment" */ tmp = strchr(p, '#'); if (tmp != NULL) { if (query == path_end) /* we did not record a query component */ path_end = tmp; query_end = tmp; frag = tmp + 1; } if (!copy_substring(pscheme, scheme, scheme_end) || !copy_substring(phost, host, host_end) || !copy_substring(pport, port, port_end) || !copy_substring(puser, user, user_end) || !copy_substring(pquery, query, query_end) || !copy_substring(pfrag, frag, frag_end)) goto err; if (pport_num != NULL) *pport_num = (int)portnum; if (*path == '/') { if (!copy_substring(ppath, path, path_end)) goto err; } else if (ppath != NULL) { /* must prepend '/' */ size_t buflen = 1 + path_end - path + 1; if ((*ppath = OPENSSL_malloc(buflen)) == NULL) goto err; BIO_snprintf(*ppath, buflen, "/%s", path); } return 1; parse_err: ERR_raise(ERR_LIB_HTTP, HTTP_R_ERROR_PARSING_URL); err: free_pstring(pscheme); free_pstring(puser); free_pstring(phost); free_pstring(pport); free_pstring(ppath); free_pstring(pquery); free_pstring(pfrag); return 0; } #ifndef OPENSSL_NO_HTTP int OSSL_HTTP_parse_url(const char *url, int *pssl, char **puser, char **phost, char **pport, int *pport_num, char **ppath, char **pquery, char **pfrag) { char *scheme, *port; int ssl = 0, portnum; init_pstring(pport); if (pssl != NULL) *pssl = 0; if (!OSSL_parse_url(url, &scheme, puser, phost, &port, pport_num, ppath, pquery, pfrag)) return 0; /* check for optional HTTP scheme "http[s]" */ if (strcmp(scheme, OSSL_HTTPS_NAME) == 0) { ssl = 1; if (pssl != NULL) *pssl = ssl; } else if (*scheme != '\0' && strcmp(scheme, OSSL_HTTP_NAME) != 0) { ERR_raise(ERR_LIB_HTTP, HTTP_R_INVALID_URL_SCHEME); OPENSSL_free(scheme); OPENSSL_free(port); goto err; } OPENSSL_free(scheme); if (strcmp(port, "0") == 0) { /* set default port */ OPENSSL_free(port); port = ssl ? OSSL_HTTPS_PORT : OSSL_HTTP_PORT; if (!ossl_assert(sscanf(port, "%d", &portnum) == 1)) goto err; if (pport_num != NULL) *pport_num = portnum; if (pport != NULL) { *pport = OPENSSL_strdup(port); if (*pport == NULL) goto err; } } else { if (pport != NULL) *pport = port; else OPENSSL_free(port); } return 1; err: free_pstring(puser); free_pstring(phost); free_pstring(ppath); free_pstring(pquery); free_pstring(pfrag); return 0; } /* Respect no_proxy, taking default value from environment variable(s) */ static int use_proxy(const char *no_proxy, const char *server) { size_t sl; const char *found = NULL; char host[NI_MAXHOST]; if (!ossl_assert(server != NULL)) return 0; sl = strlen(server); if (sl >= 2 && sl < sizeof(host) + 2 && server[0] == '[' && server[sl - 1] == ']') { /* strip leading '[' and trailing ']' from escaped IPv6 address */ sl -= 2; strncpy(host, server + 1, sl); + host[sl] = '\0'; server = host; } /* * using environment variable names, both lowercase and uppercase variants, * compatible with other HTTP client implementations like wget, curl and git */ if (no_proxy == NULL) no_proxy = ossl_safe_getenv("no_proxy"); if (no_proxy == NULL) no_proxy = ossl_safe_getenv(OPENSSL_NO_PROXY); if (no_proxy != NULL) found = strstr(no_proxy, server); while (found != NULL && ((found != no_proxy && !ossl_isspace(found[-1]) && found[-1] != ',') || (found[sl] != '\0' && !ossl_isspace(found[sl]) && found[sl] != ','))) found = strstr(found + 1, server); return found == NULL; } /* Take default value from environment variable(s), respect no_proxy */ const char *OSSL_HTTP_adapt_proxy(const char *proxy, const char *no_proxy, const char *server, int use_ssl) { /* * using environment variable names, both lowercase and uppercase variants, * compatible with other HTTP client implementations like wget, curl and git */ if (proxy == NULL) proxy = ossl_safe_getenv(use_ssl ? "https_proxy" : "http_proxy"); if (proxy == NULL) proxy = ossl_safe_getenv(use_ssl ? OPENSSL_HTTPS_PROXY : OPENSSL_HTTP_PROXY); if (proxy == NULL || *proxy == '\0' || !use_proxy(no_proxy, server)) return NULL; return proxy; } #endif /* !defined(OPENSSL_NO_HTTP) */