| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include <xsec/framework/XSECDefs.hpp> |
| #if defined (XSEC_HAVE_OPENSSL) |
| #include <openssl/evp.h> |
| #include <openssl/dsa.h> |
| #include <xsec/enc/OpenSSL/OpenSSLSupport.hpp> |
| |
| const BIGNUM *DSA_get0_pubkey(const DSA *dsa) |
| { |
| #if (OPENSSL_VERSION_NUMBER < 0x10100000L) |
| return dsa->pub_key; |
| #else |
| const BIGNUM *result; |
| DSA_get0_key(dsa, &result, NULL); |
| return result; |
| #endif |
| } |
| |
| const BIGNUM *DSA_get0_privkey(const DSA *dsa) |
| { |
| #if (OPENSSL_VERSION_NUMBER < 0x10100000L) |
| return dsa->priv_key; |
| #else |
| const BIGNUM *result; |
| DSA_get0_key(dsa, NULL, &result); |
| return result; |
| #endif |
| } |
| |
| #if (OPENSSL_VERSION_NUMBER < 0x10100000L) |
| |
| void DSA_get0_key(const DSA *d, |
| const BIGNUM **pub_key, const BIGNUM **priv_key) |
| { |
| if (pub_key != NULL) |
| *pub_key = d->pub_key; |
| if (priv_key != NULL) |
| *priv_key = d->priv_key; |
| } |
| |
| int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key) |
| { |
| /* If the field pub_key in d is NULL, the corresponding input |
| * parameters MUST be non-NULL. The priv_key field may |
| * be left NULL. |
| */ |
| if (d->pub_key == NULL && pub_key == NULL) |
| return 0; |
| |
| if (pub_key != NULL) { |
| BN_free(d->pub_key); |
| d->pub_key = pub_key; |
| } |
| if (priv_key != NULL) { |
| BN_free(d->priv_key); |
| d->priv_key = priv_key; |
| } |
| |
| return 1; |
| } |
| |
| void DSA_get0_pqg(const DSA *d, |
| const BIGNUM **p, const BIGNUM **q, const BIGNUM **g) |
| { |
| if (p != NULL) |
| *p = d->p; |
| if (q != NULL) |
| *q = d->q; |
| if (g != NULL) |
| *g = d->g; |
| } |
| |
| int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g) |
| { |
| /* If the fields p, q and g in d are NULL, the corresponding input |
| * parameters MUST be non-NULL. |
| */ |
| if ((d->p == NULL && p == NULL) |
| || (d->q == NULL && q == NULL) |
| || (d->g == NULL && g == NULL)) |
| return 0; |
| |
| if (p != NULL) { |
| BN_free(d->p); |
| d->p = p; |
| } |
| if (q != NULL) { |
| BN_free(d->q); |
| d->q = q; |
| } |
| if (g != NULL) { |
| BN_free(d->g); |
| d->g = g; |
| } |
| |
| return 1; |
| } |
| |
| void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps) |
| { |
| if (pr != NULL) |
| *pr = sig->r; |
| if (ps != NULL) |
| *ps = sig->s; |
| } |
| |
| int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s) |
| { |
| if (r == NULL || s == NULL) |
| return 0; |
| BN_clear_free(sig->r); |
| BN_clear_free(sig->s); |
| sig->r = r; |
| sig->s = s; |
| return 1; |
| } |
| |
| DSA *EVP_PKEY_get0_DSA(EVP_PKEY *pkey) |
| { |
| if (pkey->type != EVP_PKEY_DSA) { |
| return NULL; |
| } |
| return pkey->pkey.dsa; |
| } |
| |
| int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d) |
| { |
| /* If the fields n and e in r are NULL, the corresponding input |
| * parameters MUST be non-NULL for n and e. d may be |
| * left NULL (in case only the public key is used). |
| */ |
| if ((r->n == NULL && n == NULL) |
| || (r->e == NULL && e == NULL)) |
| return 0; |
| |
| if (n != NULL) { |
| BN_free(r->n); |
| r->n = n; |
| } |
| if (e != NULL) { |
| BN_free(r->e); |
| r->e = e; |
| } |
| if (d != NULL) { |
| BN_free(r->d); |
| r->d = d; |
| } |
| |
| return 1; |
| } |
| |
| int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q) |
| { |
| /* If the fields p and q in r are NULL, the corresponding input |
| * parameters MUST be non-NULL. |
| */ |
| if ((r->p == NULL && p == NULL) |
| || (r->q == NULL && q == NULL)) |
| return 0; |
| |
| if (p != NULL) { |
| BN_free(r->p); |
| r->p = p; |
| } |
| if (q != NULL) { |
| BN_free(r->q); |
| r->q = q; |
| } |
| |
| return 1; |
| } |
| |
| int RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp) |
| { |
| /* If the fields dmp1, dmq1 and iqmp in r are NULL, the corresponding input |
| * parameters MUST be non-NULL. |
| */ |
| if ((r->dmp1 == NULL && dmp1 == NULL) |
| || (r->dmq1 == NULL && dmq1 == NULL) |
| || (r->iqmp == NULL && iqmp == NULL)) |
| return 0; |
| |
| if (dmp1 != NULL) { |
| BN_free(r->dmp1); |
| r->dmp1 = dmp1; |
| } |
| if (dmq1 != NULL) { |
| BN_free(r->dmq1); |
| r->dmq1 = dmq1; |
| } |
| if (iqmp != NULL) { |
| BN_free(r->iqmp); |
| r->iqmp = iqmp; |
| } |
| |
| return 1; |
| } |
| |
| void RSA_get0_key(const RSA *r, |
| const BIGNUM **n, const BIGNUM **e, const BIGNUM **d) |
| { |
| if (n != NULL) |
| *n = r->n; |
| if (e != NULL) |
| *e = r->e; |
| if (d != NULL) |
| *d = r->d; |
| } |
| |
| void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q) |
| { |
| if (p != NULL) |
| *p = r->p; |
| if (q != NULL) |
| *q = r->q; |
| } |
| |
| void RSA_get0_crt_params(const RSA *r, |
| const BIGNUM **dmp1, const BIGNUM **dmq1, |
| const BIGNUM **iqmp) |
| { |
| if (dmp1 != NULL) |
| *dmp1 = r->dmp1; |
| if (dmq1 != NULL) |
| *dmq1 = r->dmq1; |
| if (iqmp != NULL) |
| *iqmp = r->iqmp; |
| } |
| |
| |
| #if defined (XSEC_OPENSSL_HAVE_EC) |
| |
| #include <openssl/ecdsa.h> |
| |
| void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps) |
| { |
| if (pr != NULL) |
| *pr = sig->r; |
| if (ps != NULL) |
| *ps = sig->s; |
| } |
| |
| int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s) |
| { |
| if (r == NULL || s == NULL) |
| return 0; |
| BN_clear_free(sig->r); |
| BN_clear_free(sig->s); |
| sig->r = r; |
| sig->s = s; |
| return 1; |
| } |
| |
| #endif |
| |
| #endif |
| |
| #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || \ |
| ((defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x30500000L)) |
| EvpEncodeCtxRAII::EvpEncodeCtxRAII() : mp_ctx(&mp_ctx_store) { }; |
| EvpEncodeCtxRAII::~EvpEncodeCtxRAII() { } |
| #else |
| EvpEncodeCtxRAII::EvpEncodeCtxRAII() : mp_ctx(EVP_ENCODE_CTX_new()) { }; |
| EvpEncodeCtxRAII::~EvpEncodeCtxRAII() { |
| if (mp_ctx) |
| EVP_ENCODE_CTX_free(mp_ctx); |
| } |
| #endif |
| |
| EVP_ENCODE_CTX |
| *EvpEncodeCtxRAII::of() { |
| return mp_ctx; |
| } |
| |
| #endif |