svn commit: r481850 - in head/devel/qca: . files
Adriaan de Groot
adridg at FreeBSD.org
Thu Oct 11 19:56:49 UTC 2018
Author: adridg
Date: Thu Oct 11 19:56:47 2018
New Revision: 481850
URL: https://svnweb.freebsd.org/changeset/ports/481850
Log:
Fix devel/qca with OpenSSL 1.1.1.
Contains portions extracted from upstream and portions created by
submitter. Upstream bits are marked with their git hash.
PR: 228902
Submitted by: Nathan <ndowens at yahoo.com>
Reported by: brnrd
Added:
head/devel/qca/files/
head/devel/qca/files/patch-git_e854f357 (contents, props changed)
head/devel/qca/files/patch-plugins_qca-ossl_libcrypto-compat.c (contents, props changed)
head/devel/qca/files/patch-plugins_qca-ossl_libcrypto-compat.h (contents, props changed)
head/devel/qca/files/patch-plugins_qca-ossl_qca-ossl.cpp (contents, props changed)
Modified:
head/devel/qca/Makefile
Modified: head/devel/qca/Makefile
==============================================================================
--- head/devel/qca/Makefile Thu Oct 11 19:54:18 2018 (r481849)
+++ head/devel/qca/Makefile Thu Oct 11 19:56:47 2018 (r481850)
@@ -3,13 +3,16 @@
PORTNAME= qca
PORTVERSION= 2.1.3
-PORTREVISION= 1
+PORTREVISION= 2
CATEGORIES= devel
MASTER_SITES= KDE/stable/qca/${PORTVERSION}/src
PKGNAMESUFFIX= -${FLAVOR}
MAINTAINER= kde at FreeBSD.org
COMMENT= Cross-platform crypto API for Qt ${FLAVOR:C/qt//}
+
+LICENSE= LGPL21
+LICENSE_FILE= ${WRKSRC}/COPYING
BUILD_DEPENDS= ${LOCALBASE}/share/certs/ca-root-nss.crt:security/ca_root_nss
RUN_DEPENDS= ${LOCALBASE}/share/certs/ca-root-nss.crt:security/ca_root_nss
Added: head/devel/qca/files/patch-git_e854f357
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/devel/qca/files/patch-git_e854f357 Thu Oct 11 19:56:47 2018 (r481850)
@@ -0,0 +1,38 @@
+From e854f357f4037e2c8c781ebd04ec5164a882b9b3 Mon Sep 17 00:00:00 2001
+From: Andreas Sturmlechner <asturm at gentoo.org>
+Date: Thu, 12 Apr 2018 00:45:50 +0200
+Subject: Make Qt5Network conditional on BUILD_TESTS
+
+Summary: I did not find it in use somewhere else.
+
+Reviewers: iromanov, sitter, rjvbb
+
+Reviewed By: rjvbb
+
+Subscribers: fvogt
+
+Differential Revision: https://phabricator.kde.org/D12129
+---
+ CMakeLists.txt | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 28b0169..65b95f8 100644
+--- CMakeLists.txt
++++ CMakeLists.txt
+@@ -59,7 +59,11 @@ if (Qt5Core_FOUND)
+ message(STATUS "Building with Qt5 support")
+ # Got from ECM
+ # Distros have no ECM. So I just copied required cmake modules.
+- find_package(Qt5Transitional REQUIRED Core Network)
++ if(BUILD_TESTS)
++ find_package(Qt5Transitional REQUIRED Core Network)
++ else()
++ find_package(Qt5Transitional REQUIRED Core)
++ endif()
+ include(ECMQt4To5Porting)
+
+ include(GNUInstallDirs)
+--
+cgit v0.11.2
+
Added: head/devel/qca/files/patch-plugins_qca-ossl_libcrypto-compat.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/devel/qca/files/patch-plugins_qca-ossl_libcrypto-compat.c Thu Oct 11 19:56:47 2018 (r481850)
@@ -0,0 +1,414 @@
+--- plugins/qca-ossl/libcrypto-compat.c.orig 2018-10-07 18:32:46 UTC
++++ plugins/qca-ossl/libcrypto-compat.c
+@@ -0,0 +1,411 @@
++/*
++ * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
++ *
++ * Licensed under the OpenSSL license (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 <openssl/evp.h>
++
++#if OPENSSL_VERSION_NUMBER < 0x10100000L
++
++#include <string.h>
++#include <openssl/engine.h>
++
++static void *OPENSSL_zalloc(size_t num)
++{
++ void *ret = OPENSSL_malloc(num);
++
++ if (ret != NULL)
++ memset(ret, 0, num);
++ return ret;
++}
++
++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;
++}
++
++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_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_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;
++}
++
++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;
++}
++
++void DH_get0_pqg(const DH *dh,
++ const BIGNUM **p, const BIGNUM **q, const BIGNUM **g)
++{
++ if (p != NULL)
++ *p = dh->p;
++ if (q != NULL)
++ *q = dh->q;
++ if (g != NULL)
++ *g = dh->g;
++}
++
++int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g)
++{
++ /* If the fields p and g in d are NULL, the corresponding input
++ * parameters MUST be non-NULL. q may remain NULL.
++ */
++ if ((dh->p == NULL && p == NULL)
++ || (dh->g == NULL && g == NULL))
++ return 0;
++
++ if (p != NULL) {
++ BN_free(dh->p);
++ dh->p = p;
++ }
++ if (q != NULL) {
++ BN_free(dh->q);
++ dh->q = q;
++ }
++ if (g != NULL) {
++ BN_free(dh->g);
++ dh->g = g;
++ }
++
++ if (q != NULL) {
++ dh->length = BN_num_bits(q);
++ }
++
++ return 1;
++}
++
++void DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key)
++{
++ if (pub_key != NULL)
++ *pub_key = dh->pub_key;
++ if (priv_key != NULL)
++ *priv_key = dh->priv_key;
++}
++
++int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key)
++{
++ /* If the field pub_key in dh is NULL, the corresponding input
++ * parameters MUST be non-NULL. The priv_key field may
++ * be left NULL.
++ */
++ if (dh->pub_key == NULL && pub_key == NULL)
++ return 0;
++
++ if (pub_key != NULL) {
++ BN_free(dh->pub_key);
++ dh->pub_key = pub_key;
++ }
++ if (priv_key != NULL) {
++ BN_free(dh->priv_key);
++ dh->priv_key = priv_key;
++ }
++
++ return 1;
++}
++
++int DH_set_length(DH *dh, long length)
++{
++ dh->length = length;
++ return 1;
++}
++
++const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx)
++{
++ return ctx->iv;
++}
++
++unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx)
++{
++ return ctx->iv;
++}
++
++EVP_MD_CTX *EVP_MD_CTX_new(void)
++{
++ return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
++}
++
++void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
++{
++ EVP_MD_CTX_cleanup(ctx);
++ OPENSSL_free(ctx);
++}
++
++RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth)
++{
++ RSA_METHOD *ret;
++
++ ret = OPENSSL_malloc(sizeof(RSA_METHOD));
++
++ if (ret != NULL) {
++ memcpy(ret, meth, sizeof(*meth));
++ ret->name = OPENSSL_strdup(meth->name);
++ if (ret->name == NULL) {
++ OPENSSL_free(ret);
++ return NULL;
++ }
++ }
++
++ return ret;
++}
++
++int RSA_meth_set1_name(RSA_METHOD *meth, const char *name)
++{
++ char *tmpname;
++
++ tmpname = OPENSSL_strdup(name);
++ if (tmpname == NULL) {
++ return 0;
++ }
++
++ OPENSSL_free((char *)meth->name);
++ meth->name = tmpname;
++
++ return 1;
++}
++
++int RSA_meth_set_priv_enc(RSA_METHOD *meth,
++ int (*priv_enc) (int flen, const unsigned char *from,
++ unsigned char *to, RSA *rsa,
++ int padding))
++{
++ meth->rsa_priv_enc = priv_enc;
++ return 1;
++}
++
++int RSA_meth_set_priv_dec(RSA_METHOD *meth,
++ int (*priv_dec) (int flen, const unsigned char *from,
++ unsigned char *to, RSA *rsa,
++ int padding))
++{
++ meth->rsa_priv_dec = priv_dec;
++ return 1;
++}
++
++int RSA_meth_set_finish(RSA_METHOD *meth, int (*finish) (RSA *rsa))
++{
++ meth->finish = finish;
++ return 1;
++}
++
++void RSA_meth_free(RSA_METHOD *meth)
++{
++ if (meth != NULL) {
++ OPENSSL_free((char *)meth->name);
++ OPENSSL_free(meth);
++ }
++}
++
++int RSA_bits(const RSA *r)
++{
++ return (BN_num_bits(r->n));
++}
++
++RSA *EVP_PKEY_get0_RSA(EVP_PKEY *pkey)
++{
++ if (pkey->type != EVP_PKEY_RSA) {
++ return NULL;
++ }
++ return pkey->pkey.rsa;
++}
++
++
++#endif /* OPENSSL_VERSION_NUMBER */
++
Added: head/devel/qca/files/patch-plugins_qca-ossl_libcrypto-compat.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/devel/qca/files/patch-plugins_qca-ossl_libcrypto-compat.h Thu Oct 11 19:56:47 2018 (r481850)
@@ -0,0 +1,61 @@
+--- plugins/qca-ossl/libcrypto-compat.h.orig 2018-10-07 18:34:21 UTC
++++ plugins/qca-ossl/libcrypto-compat.h
+@@ -0,0 +1,58 @@
++#ifndef LIBCRYPTO_COMPAT_H
++#define LIBCRYPTO_COMPAT_H
++
++#if OPENSSL_VERSION_NUMBER < 0x10100000L
++
++#include <openssl/rsa.h>
++#include <openssl/dsa.h>
++#include <openssl/ecdsa.h>
++#include <openssl/dh.h>
++#include <openssl/evp.h>
++
++int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
++int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q);
++int RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp);
++void RSA_get0_key(const RSA *r, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d);
++void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q);
++void RSA_get0_crt_params(const RSA *r, const BIGNUM **dmp1, const BIGNUM **dmq1, const BIGNUM **iqmp);
++
++void DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g);
++int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g);
++void DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key);
++int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key);
++
++void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
++int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s);
++
++void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
++int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
++
++void DH_get0_pqg(const DH *dh, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g);
++int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g);
++void DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key);
++int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key);
++int DH_set_length(DH *dh, long length);
++
++const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx);
++unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx);
++EVP_MD_CTX *EVP_MD_CTX_new(void);
++void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
++#define EVP_CIPHER_impl_ctx_size(e) e->ctx_size
++#define EVP_CIPHER_CTX_get_cipher_data(ctx) ctx->cipher_data
++
++RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth);
++int RSA_meth_set1_name(RSA_METHOD *meth, const char *name);
++#define RSA_meth_get_finish(meth) meth->finish
++int RSA_meth_set_priv_enc(RSA_METHOD *meth, int (*priv_enc) (int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding));
++int RSA_meth_set_priv_dec(RSA_METHOD *meth, int (*priv_dec) (int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding));
++int RSA_meth_set_finish(RSA_METHOD *meth, int (*finish) (RSA *rsa));
++void RSA_meth_free(RSA_METHOD *meth);
++
++int RSA_bits(const RSA *r);
++
++RSA *EVP_PKEY_get0_RSA(EVP_PKEY *pkey);
++
++#endif /* OPENSSL_VERSION_NUMBER */
++
++#endif /* LIBCRYPTO_COMPAT_H */
++
Added: head/devel/qca/files/patch-plugins_qca-ossl_qca-ossl.cpp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/devel/qca/files/patch-plugins_qca-ossl_qca-ossl.cpp Thu Oct 11 19:56:47 2018 (r481850)
@@ -0,0 +1,1506 @@
+This is an extract of upstream commit
+ https://cgit.kde.org/qca.git/commit/?id=d58e20ee652038dc4ec4fe4765dc3639ed735526
+
+--- plugins/qca-ossl/qca-ossl.cpp.orig 2017-02-06 12:29:44 UTC
++++ plugins/qca-ossl/qca-ossl.cpp
+@@ -1,6 +1,7 @@
+ /*
+ * Copyright (C) 2004-2007 Justin Karneges <justin at affinix.com>
+ * Copyright (C) 2004-2006 Brad Hards <bradh at frogmouth.net>
++ * Copyright (C) 2017 Fabian Vogt <fabian at ritter-vogt.de>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+@@ -38,6 +39,10 @@
+ #include <openssl/pkcs12.h>
+ #include <openssl/ssl.h>
+
++extern "C" {
++#include "libcrypto-compat.h"
++}
++
+ #ifndef OSSL_097
+ // comment this out if you'd rather use openssl 0.9.6
+ #define OSSL_097
+@@ -52,6 +57,73 @@
+ ((_STACK*) (1 ? p : (type*)0))
+ #endif
+
++#if OPENSSL_VERSION_NUMBER >= 0x10100000L
++ #define OSSL_110
++#endif
++
++// OpenSSL 1.1.0 compatibility macros
++#ifdef OSSL_110
++#define M_ASN1_IA5STRING_new() ASN1_IA5STRING_new()
++#else
++static HMAC_CTX *HMAC_CTX_new() { return new HMAC_CTX(); }
++static void HMAC_CTX_free(HMAC_CTX *x) { free(x); }
++static void EVP_PKEY_up_ref(EVP_PKEY *x) { CRYPTO_add(&x->references, 1, CRYPTO_LOCK_EVP_PKEY); }
++static void X509_up_ref(X509 *x) { CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509); }
++static void X509_CRL_up_ref(X509_CRL *x) { CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL); }
++static DSA *EVP_PKEY_get0_DSA(EVP_PKEY *x) { return x->pkey.dsa; }
++static DH *EVP_PKEY_get0_DH(EVP_PKEY *x) { return x->pkey.dh; }
++static int RSA_meth_set_sign(RSA_METHOD *meth,
++ int (*sign) (int type, const unsigned char *m,
++ unsigned int m_length,
++ unsigned char *sigret, unsigned int *siglen,
++ const RSA *rsa))
++{
++ meth->rsa_sign = sign;
++ return 1;
++}
++int RSA_meth_set_verify(RSA_METHOD *meth,
++ int (*verify) (int dtype, const unsigned char *m,
++ unsigned int m_length,
++ const unsigned char *sigbuf,
++ unsigned int siglen, const RSA *rsa))
++{
++ meth->rsa_verify = verify;
++ return 1;
++}
++void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
++ const X509_ALGOR **palg)
++{
++ if (psig != NULL)
++ *psig = req->signature;
++ if (palg != NULL)
++ *palg = req->sig_alg;
++}
++int X509_REQ_get_signature_nid(const X509_REQ *req)
++{
++ return OBJ_obj2nid(req->sig_alg->algorithm);
++}
++void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
++ const X509_ALGOR **palg)
++{
++ if (psig != NULL)
++ *psig = crl->signature;
++ if (palg != NULL)
++ *palg = crl->sig_alg;
++}
++int X509_CRL_get_signature_nid(const X509_CRL *crl)
++{
++ return OBJ_obj2nid(crl->sig_alg->algorithm);
++}
++const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x)
++{
++ return x->serialNumber;
++}
++const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x)
++{
++ return x->revocationDate;
++}
++#endif
++
+ using namespace QCA;
+
+ namespace opensslQCAPlugin {
+@@ -93,7 +165,7 @@ static QByteArray bio2ba(BIO *b)
+ return buf;
+ }
+
+-static BigInteger bn2bi(BIGNUM *n)
++static BigInteger bn2bi(const BIGNUM *n)
+ {
+ SecureArray buf(BN_num_bytes(n) + 1);
+ buf[0] = 0; // positive
+@@ -109,7 +181,7 @@ static BIGNUM *bi2bn(const BigInteger &n)
+
+ // take lowest bytes of BIGNUM to fit
+ // pad with high byte zeroes to fit
+-static SecureArray bn2fixedbuf(BIGNUM *n, int size)
++static SecureArray bn2fixedbuf(const BIGNUM *n, int size)
+ {
+ SecureArray buf(BN_num_bytes(n));
+ BN_bn2bin(n, (unsigned char *)buf.data());
+@@ -127,8 +199,16 @@ static SecureArray dsasig_der_to_raw(const SecureArray
+ const unsigned char *inp = (const unsigned char *)in.data();
+ d2i_DSA_SIG(&sig, &inp, in.size());
+
+- SecureArray part_r = bn2fixedbuf(sig->r, 20);
+- SecureArray part_s = bn2fixedbuf(sig->s, 20);
++ const BIGNUM *bnr, *bns;
++
++#ifdef OSSL_110
++ DSA_SIG_get0(sig, &bnr, &bns);
++#else
++ bnr = sig->r; bns = sig->s;
++#endif
++
++ SecureArray part_r = bn2fixedbuf(bnr, 20);
++ SecureArray part_s = bn2fixedbuf(bns, 20);
+ SecureArray result;
+ result.append(part_r);
+ result.append(part_s);
+@@ -143,13 +223,21 @@ static SecureArray dsasig_raw_to_der(const SecureArray
+ return SecureArray();
+
+ DSA_SIG *sig = DSA_SIG_new();
+- SecureArray part_r(20);
+- SecureArray part_s(20);
++ SecureArray part_r(20); BIGNUM *bnr;
++ SecureArray part_s(20); BIGNUM *bns;
+ memcpy(part_r.data(), in.data(), 20);
+ memcpy(part_s.data(), in.data() + 20, 20);
+- sig->r = BN_bin2bn((const unsigned char *)part_r.data(), part_r.size(), NULL);
+- sig->s = BN_bin2bn((const unsigned char *)part_s.data(), part_s.size(), NULL);
++ bnr = BN_bin2bn((const unsigned char *)part_r.data(), part_r.size(), NULL);
++ bns = BN_bin2bn((const unsigned char *)part_s.data(), part_s.size(), NULL);
+
++#ifdef OSSL_110
++ if(DSA_SIG_set0(sig, bnr, bns) == 0)
++ return SecureArray();
++ // Not documented what happens in the failure case, free bnr and bns?
++#else
++ sig->r = bnr; sig->s = bns;
++#endif
++
+ int len = i2d_DSA_SIG(sig, NULL);
+ SecureArray result(len);
+ unsigned char *p = (unsigned char *)result.data();
+@@ -1004,29 +1092,39 @@ class opensslHashContext : public HashContext (public)
+ opensslHashContext(const EVP_MD *algorithm, Provider *p, const QString &type) : HashContext(p, type)
+ {
+ m_algorithm = algorithm;
+- EVP_DigestInit( &m_context, m_algorithm );
++ m_context = EVP_MD_CTX_new();
++ EVP_DigestInit( m_context, m_algorithm );
+ }
+
++ opensslHashContext(const opensslHashContext &other)
++ : HashContext(other)
++ {
++ m_algorithm = other.m_algorithm;
++ m_context = EVP_MD_CTX_new();
++ EVP_MD_CTX_copy_ex(m_context, other.m_context);
++ }
++
+ ~opensslHashContext()
+ {
+- EVP_MD_CTX_cleanup(&m_context);
++ EVP_MD_CTX_free(m_context);
+ }
+
+ void clear()
+ {
+- EVP_MD_CTX_cleanup(&m_context);
+- EVP_DigestInit( &m_context, m_algorithm );
++ EVP_MD_CTX_free(m_context);
++ m_context = EVP_MD_CTX_new();
++ EVP_DigestInit( m_context, m_algorithm );
+ }
+
+ void update(const MemoryRegion &a)
+ {
+- EVP_DigestUpdate( &m_context, (unsigned char*)a.data(), a.size() );
++ EVP_DigestUpdate( m_context, (unsigned char*)a.data(), a.size() );
+ }
+
+ MemoryRegion final()
+ {
+ SecureArray a( EVP_MD_size( m_algorithm ) );
+- EVP_DigestFinal( &m_context, (unsigned char*)a.data(), 0 );
++ EVP_DigestFinal( m_context, (unsigned char*)a.data(), 0 );
+ return a;
+ }
+
+@@ -1037,7 +1135,7 @@ class opensslHashContext : public HashContext (public)
+
+ protected:
+ const EVP_MD *m_algorithm;
+- EVP_MD_CTX m_context;
++ EVP_MD_CTX *m_context;
+ };
+
+
+@@ -1047,9 +1145,23 @@ class opensslPbkdf1Context : public KDFContext (public
+ opensslPbkdf1Context(const EVP_MD *algorithm, Provider *p, const QString &type) : KDFContext(p, type)
+ {
+ m_algorithm = algorithm;
+- EVP_DigestInit( &m_context, m_algorithm );
++ m_context = EVP_MD_CTX_new();
++ EVP_DigestInit( m_context, m_algorithm );
+ }
+
++ opensslPbkdf1Context(const opensslPbkdf1Context &other)
++ : KDFContext(other)
++ {
++ m_algorithm = other.m_algorithm;
++ m_context = EVP_MD_CTX_new();
++ EVP_MD_CTX_copy(m_context, other.m_context);
++ }
++
++ ~opensslPbkdf1Context()
++ {
++ EVP_MD_CTX_free(m_context);
++ }
++
+ Provider::Context *clone() const
+ {
+ return new opensslPbkdf1Context( *this );
+@@ -1081,16 +1193,16 @@ class opensslPbkdf1Context : public KDFContext (public
+ DK = Tc<0..dkLen-1>
+ */
+ // calculate T_1
+- EVP_DigestUpdate( &m_context, (unsigned char*)secret.data(), secret.size() );
+- EVP_DigestUpdate( &m_context, (unsigned char*)salt.data(), salt.size() );
++ EVP_DigestUpdate( m_context, (unsigned char*)secret.data(), secret.size() );
++ EVP_DigestUpdate( m_context, (unsigned char*)salt.data(), salt.size() );
+ SecureArray a( EVP_MD_size( m_algorithm ) );
+- EVP_DigestFinal( &m_context, (unsigned char*)a.data(), 0 );
++ EVP_DigestFinal( m_context, (unsigned char*)a.data(), 0 );
+
+ // calculate T_2 up to T_c
+ for ( unsigned int i = 2; i <= iterationCount; ++i ) {
+- EVP_DigestInit( &m_context, m_algorithm );
+- EVP_DigestUpdate( &m_context, (unsigned char*)a.data(), a.size() );
+- EVP_DigestFinal( &m_context, (unsigned char*)a.data(), 0 );
++ EVP_DigestInit( m_context, m_algorithm );
++ EVP_DigestUpdate( m_context, (unsigned char*)a.data(), a.size() );
++ EVP_DigestFinal( m_context, (unsigned char*)a.data(), 0 );
+ }
+
+ // shrink a to become DK, of the required length
+@@ -1136,19 +1248,19 @@ class opensslPbkdf1Context : public KDFContext (public
+ DK = Tc<0..dkLen-1>
+ */
+ // calculate T_1
+- EVP_DigestUpdate( &m_context, (unsigned char*)secret.data(), secret.size() );
+- EVP_DigestUpdate( &m_context, (unsigned char*)salt.data(), salt.size() );
++ EVP_DigestUpdate( m_context, (unsigned char*)secret.data(), secret.size() );
++ EVP_DigestUpdate( m_context, (unsigned char*)salt.data(), salt.size() );
+ SecureArray a( EVP_MD_size( m_algorithm ) );
+- EVP_DigestFinal( &m_context, (unsigned char*)a.data(), 0 );
++ EVP_DigestFinal( m_context, (unsigned char*)a.data(), 0 );
+
+ // calculate T_2 up to T_c
+ *iterationCount = 2 - 1; // <- Have to remove 1, unless it computes one
+ timer.start(); // ^ time more than the base function
+ // ^ with the same iterationCount
+ while (timer.elapsed() < msecInterval) {
+- EVP_DigestInit( &m_context, m_algorithm );
+- EVP_DigestUpdate( &m_context, (unsigned char*)a.data(), a.size() );
+- EVP_DigestFinal( &m_context, (unsigned char*)a.data(), 0 );
++ EVP_DigestInit( m_context, m_algorithm );
++ EVP_DigestUpdate( m_context, (unsigned char*)a.data(), a.size() );
++ EVP_DigestFinal( m_context, (unsigned char*)a.data(), 0 );
+ ++(*iterationCount);
+ }
+
+@@ -1163,7 +1275,7 @@ class opensslPbkdf1Context : public KDFContext (public
+
+ protected:
+ const EVP_MD *m_algorithm;
+- EVP_MD_CTX m_context;
++ EVP_MD_CTX *m_context;
+ };
+
+ class opensslPbkdf2Context : public KDFContext
+@@ -1231,12 +1343,28 @@ class opensslHMACContext : public MACContext (public)
+ opensslHMACContext(const EVP_MD *algorithm, Provider *p, const QString &type) : MACContext(p, type)
+ {
+ m_algorithm = algorithm;
+- HMAC_CTX_init( &m_context );
++ m_context = HMAC_CTX_new();
++#ifndef OSSL_110
++ HMAC_CTX_init( m_context );
++#endif
+ }
+
++ opensslHMACContext(const opensslHMACContext &other)
++ : MACContext(other)
++ {
++ m_algorithm = other.m_algorithm;
++ m_context = HMAC_CTX_new();
++ HMAC_CTX_copy(m_context, other.m_context);
++ }
++
++ ~opensslHMACContext()
++ {
++ HMAC_CTX_free(m_context);
++ }
++
+ void setup(const SymmetricKey &key)
+ {
+- HMAC_Init_ex( &m_context, key.data(), key.size(), m_algorithm, 0 );
++ HMAC_Init_ex( m_context, key.data(), key.size(), m_algorithm, 0 );
+ }
+
+ KeyLength keyLength() const
+@@ -1246,14 +1374,18 @@ class opensslHMACContext : public MACContext (public)
+
+ void update(const MemoryRegion &a)
+ {
+- HMAC_Update( &m_context, (unsigned char *)a.data(), a.size() );
++ HMAC_Update( m_context, (unsigned char *)a.data(), a.size() );
+ }
+
+ void final(MemoryRegion *out)
+ {
+ SecureArray sa( EVP_MD_size( m_algorithm ), 0 );
+- HMAC_Final(&m_context, (unsigned char *)sa.data(), 0 );
+- HMAC_CTX_cleanup(&m_context);
++ HMAC_Final(m_context, (unsigned char *)sa.data(), 0 );
++#ifdef OSSL_110
++ HMAC_CTX_reset(m_context);
++#else
++ HMAC_CTX_cleanup(m_context);
++#endif
+ *out = sa;
+ }
+
+@@ -1263,7 +1395,7 @@ class opensslHMACContext : public MACContext (public)
+ }
+
+ protected:
+- HMAC_CTX m_context;
++ HMAC_CTX *m_context;
+ const EVP_MD *m_algorithm;
+ };
+
+@@ -1277,7 +1409,7 @@ class EVPKey
+ public:
+ enum State { Idle, SignActive, SignError, VerifyActive, VerifyError };
+ EVP_PKEY *pkey;
+- EVP_MD_CTX mdctx;
++ EVP_MD_CTX *mdctx;
+ State state;
+ bool raw_type;
+ SecureArray raw;
+@@ -1287,19 +1419,23 @@ class EVPKey
+ pkey = 0;
+ raw_type = false;
+ state = Idle;
++ mdctx = EVP_MD_CTX_new();
+ }
+
+ EVPKey(const EVPKey &from)
+ {
+ pkey = from.pkey;
+- CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
++ EVP_PKEY_up_ref(pkey);
+ raw_type = false;
+ state = Idle;
++ mdctx = EVP_MD_CTX_new();
++ EVP_MD_CTX_copy(mdctx, from.mdctx);
+ }
+
+ ~EVPKey()
+ {
+ reset();
++ EVP_MD_CTX_free(mdctx);
+ }
+
+ void reset()
+@@ -1322,8 +1458,8 @@ class EVPKey
+ else
+ {
+ raw_type = false;
+- EVP_MD_CTX_init(&mdctx);
+- if(!EVP_SignInit_ex(&mdctx, type, NULL))
++ EVP_MD_CTX_init(mdctx);
++ if(!EVP_SignInit_ex(mdctx, type, NULL))
+ state = SignError;
+ }
+ }
+@@ -1339,8 +1475,8 @@ class EVPKey
+ else
+ {
+ raw_type = false;
+- EVP_MD_CTX_init(&mdctx);
+- if(!EVP_VerifyInit_ex(&mdctx, type, NULL))
++ EVP_MD_CTX_init(mdctx);
++ if(!EVP_VerifyInit_ex(mdctx, type, NULL))
+ state = VerifyError;
+ }
+ }
+@@ -1352,7 +1488,7 @@ class EVPKey
+ if (raw_type)
+ raw += in;
+ else
+- if(!EVP_SignUpdate(&mdctx, in.data(), (unsigned int)in.size()))
++ if(!EVP_SignUpdate(mdctx, in.data(), (unsigned int)in.size()))
+ state = SignError;
+ }
+ else if(state == VerifyActive)
+@@ -1360,7 +1496,7 @@ class EVPKey
+ if (raw_type)
+ raw += in;
+ else
+- if(!EVP_VerifyUpdate(&mdctx, in.data(), (unsigned int)in.size()))
++ if(!EVP_VerifyUpdate(mdctx, in.data(), (unsigned int)in.size()))
+ state = VerifyError;
+ }
+ }
+@@ -1373,17 +1509,24 @@ class EVPKey
+ unsigned int len = out.size();
+ if (raw_type)
+ {
+- if (pkey->type == EVP_PKEY_RSA)
++ int type;
++#ifdef OSSL_110
++ type = EVP_PKEY_id(pkey);
++#else
++ type = pkey->type;
++#endif
++ if (type == EVP_PKEY_RSA)
+ {
++ RSA *rsa = EVP_PKEY_get0_RSA(pkey);
+ if(RSA_private_encrypt (raw.size(), (unsigned char *)raw.data(),
+- (unsigned char *)out.data(), pkey->pkey.rsa,
++ (unsigned char *)out.data(), rsa,
+ RSA_PKCS1_PADDING) == -1) {
+
+ state = SignError;
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-ports-all
mailing list