OpenSSL 3.0 support

.github/workflows/build.yml

@@ -96,7 +96,7 @@ jobs:
  container: ${{ matrix.container }}
  strategy:
  matrix:
- container: ['ubuntu:18.04', 'ubuntu:20.04', 'ubuntu:21.10']
+ container: ['ubuntu:18.04', 'ubuntu:20.04', 'ubuntu:21.10', 'ubuntu:22.04']
  env:
  DEBIAN_FRONTEND: noninteractive
  DEBFULLNAME: 'github-actions'
@@ -139,7 +139,7 @@ jobs:
  include:
  - toolset: 143
  image: windows-2022
- vcver: 14.31
+ vcver: 14.32
  vcvars: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvarsall.bat"
  - toolset: 142
  image: windows-2019

prepare_osx_build_environment.sh

@@ -5,7 +5,7 @@ XERCES_DIR=xerces-c-3.2.3
 XALAN_DIR=xalan_c-1.12
 XMLSEC_DIR=xml-security-c-2.0.4
 XSD=xsd-4.0.0-i686-macosx
-OPENSSL_DIR=openssl-1.1.1n
+OPENSSL_DIR=openssl-1.1.1o
 LIBXML2_DIR=libxml2-2.9.10
 ANDROID_NDK=android-ndk-r23b
 FREETYPE_DIR=freetype-2.10.1

src/SignatureXAdES_B.cpp

@@ -710,10 +710,7 @@ void SignatureXAdES_B::checkKeyInfo() const
  }();
 
  // lets check digest with x509 that was in keyInfo
- Digest certDigestCalc(certDigest.digestMethod().algorithm());
- certDigestCalc.update(x509);
- vector<unsigned char> calcDigest = certDigestCalc.result();
-
+ vector<unsigned char> calcDigest = Digest(certDigest.digestMethod().algorithm()).result(x509);
  if(certDigest.digestValue().size() != calcDigest.size() ||
  memcmp(calcDigest.data(), certDigest.digestValue().data(), certDigest.digestValue().size()) != 0)
  {
@@ -754,7 +751,7 @@ void SignatureXAdES_B::checkSignatureValue() const
  try
  {
  vector<unsigned char> sha = dataToSign();
- DEBUGMEM("Digest", sha.data(), sha.size());
+ DEBUGMEM("Digest to sign", sha.data(), sha.size());
  if(!X509Crypto(signingCertificate()).verify(signatureMethod(), sha, getSignatureValue()))
  THROW_OPENSSLEXCEPTION("Signature is not valid.");
  }
@@ -832,10 +829,9 @@ void SignatureXAdES_B::setSigningCertificate(const X509Cert& x509)
 {
  // Calculate digest of the X.509 certificate.
  Digest digest;
- digest.update(x509);
  CertIDListType signingCertificate;
  signingCertificate.cert().push_back(CertIDType(
- DigestAlgAndValueType(DigestMethodType(digest.uri()), toBase64(digest.result())),
+ DigestAlgAndValueType(DigestMethodType(digest.uri()), toBase64(digest.result(x509))),
  X509IssuerSerialType(x509.issuerName(), x509.serial())));
  getSignedSignatureProperties().signingCertificate(signingCertificate);
 }
@@ -850,10 +846,9 @@ void SignatureXAdES_B::setSigningCertificateV2(const X509Cert& x509)
 {
  // Calculate digest of the X.509 certificate.
  Digest digest;
- digest.update(x509);
  CertIDListV2Type signingCertificate;
  signingCertificate.cert().push_back(CertIDTypeV2(
- DigestAlgAndValueType(DigestMethodType(digest.uri()), toBase64(digest.result()))));
+ DigestAlgAndValueType(DigestMethodType(digest.uri()), toBase64(digest.result(x509)))));
  getSignedSignatureProperties().signingCertificateV2(signingCertificate);
 }
 

src/SignatureXAdES_LT.cpp

@@ -155,9 +155,7 @@ void SignatureXAdES_LT::validate(const std::string &policy) const
  string method = Digest::digestInfoUri(ocsp.nonce());
  if(method.empty())
  THROW("Nonce digest method is missing");
- Digest calc(method);
- calc.update(getSignatureValue());
- vector<unsigned char> digest = calc.result();
+ vector<unsigned char> digest = Digest(method).result(getSignatureValue());
  vector<unsigned char> respDigest = Digest::digestInfoDigest(ocsp.nonce());
  if(digest != respDigest)
  {
@@ -216,8 +214,7 @@ void SignatureXAdES_LT::extendSignatureProfile(const std::string &profile)
 
  // Calculate NONCE value.
  Digest calc;
- calc.update(getSignatureValue());
- vector<unsigned char> nonce = Digest::addDigestInfo(calc.result(), calc.uri());
+ vector<unsigned char> nonce = Digest::addDigestInfo(calc.result(getSignatureValue()), calc.uri());
  DEBUGMEM("OID + Calculated signature HASH (nonce):", nonce.data(), nonce.size());
 
  // Get issuer certificate from certificate store.

src/crypto/Connect.cpp

@@ -122,6 +122,7 @@ Connect::Connect(const string &_url, const string &method, int timeout, const st
  THROW_NETWORKEXCEPTION("Failed to create ssl connection with host: '%s'", hostname.c_str())
  SSL_CTX_set_mode(ssl.get(), SSL_MODE_AUTO_RETRY);
  SSL_CTX_set_quiet_shutdown(ssl.get(), 1);
+ SSL_CTX_set_options(ssl.get(), SSL_OP_LEGACY_SERVER_CONNECT);
  if(!certs.empty())
  {
  SSL_CTX_set_verify(ssl.get(), SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);

src/crypto/Digest.cpp

@@ -290,3 +290,14 @@ vector<unsigned char> Digest::result() const
  THROW_OPENSSLEXCEPTION("Failed to create %s digest", uri().c_str());
  return *d;
 }
+
+vector<unsigned char> Digest::result(const vector<unsigned char> &data)
+{
+ return result(data.data(), data.size());
+}
+
+vector<unsigned char> Digest::result(const unsigned char *data, size_t length)
+{
+ update(data, length);
+ return result();
+}

src/crypto/Digest.h

@@ -69,6 +69,8 @@ namespace digidoc
  void reset(const std::string &uri = {});
  void update(const std::vector<unsigned char> &data);
  void update(const unsigned char *data, size_t length);
+ std::vector<unsigned char> result(const std::vector<unsigned char> &data);
+ std::vector<unsigned char> result(const unsigned char *data, size_t length);
  std::vector<unsigned char> result() const;
  std::string uri() const;
 

src/crypto/OpenSSLHelpers.h

@@ -68,7 +68,9 @@ class OpenSSLException : public Exception
  {
  Exception e(ERR_lib_error_string(error), 0, ERR_error_string(error, nullptr));
  if(ERR_GET_LIB(error) == ERR_R_BIO_LIB &&
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
  ERR_GET_FUNC(error) == BIO_F_BIO_LOOKUP_EX &&
+#endif
  ERR_GET_REASON(error) == ERR_R_SYS_LIB)
  e.setCode(ExceptionCode::HostNotFound);
  addCause(e);

src/crypto/PKCS12Signer.cpp

@@ -24,6 +24,8 @@
 #include "crypto/X509Cert.h"
 #include "log.h"
 
+#include <algorithm>
+
 using namespace digidoc;
 using namespace std;
 
@@ -71,53 +73,48 @@ vector<unsigned char> PKCS12Signer::sign(const string &method, const vector<unsi
 
  int result = 0;
  vector<unsigned char> signature;
+ size_t size = 0;
+ SCOPE(EVP_PKEY_CTX, ctx, EVP_PKEY_CTX_new(d->key, nullptr));
+ if(!ctx || EVP_PKEY_sign_init(ctx.get()) <= 0)
+ THROW_OPENSSLEXCEPTION("Failed to sign the digest");
  switch(EVP_PKEY_base_id(d->key))
  {
  case EVP_PKEY_RSA:
  {
- RSA *rsa = EVP_PKEY_get0_RSA(d->key);
- signature.resize(size_t(RSA_size(rsa)));
- int nid = Digest::toMethod(method);
  if(Digest::isRsaPssUri(method)) {
- vector<unsigned char> em(signature.size());
- if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa, em.data(), digest.data(), EVP_get_digestbynid(nid), nullptr, RSA_PSS_SALTLEN_DIGEST))
+ if(EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PSS_PADDING) <= 0 ||
+  EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx.get(), RSA_PSS_SALTLEN_DIGEST) <= 0)
  break;
- if(RSA_private_encrypt(RSA_size(rsa), em.data(), signature.data(), rsa, RSA_NO_PADDING) == RSA_size(rsa))
- result = 1;
- } else {
- unsigned int size = (unsigned int)signature.size();
- result = RSA_sign(nid, digest.data(), (unsigned int)digest.size(), signature.data(), &size, rsa);
- }
+ } else if(EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PADDING) <= 0)
+ break;
+ if(EVP_PKEY_CTX_set_signature_md(ctx.get(), EVP_get_digestbynid(Digest::toMethod(method))) <= 0 ||
+ EVP_PKEY_sign(ctx.get(), nullptr, &size, digest.data(), digest.size()) <= 0)
+ break;
+ signature.resize(size);
+ result = EVP_PKEY_sign(ctx.get(), signature.data(), &size, digest.data(), digest.size());
  break;
  }
 #ifndef OPENSSL_NO_ECDSA
  case EVP_PKEY_EC:
  {
- EC_KEY *ec = EVP_PKEY_get0_EC_KEY(d->key);
- SCOPE(ECDSA_SIG, sig, ECDSA_do_sign(digest.data(), int(digest.size()), ec));
- if(!sig)
- break;
-
- size_t keyLen = 0;
- if(const EC_GROUP *group = EC_KEY_get0_group(ec))
- {
- BIGNUM *order = BN_new();
- if (EC_GROUP_get_order(group, order, nullptr))
- keyLen = size_t(BN_num_bytes(order));
- BN_clear_free(order);
- }
- if(keyLen == 0)
- THROW("Error caclulating signature size");
- signature.resize(keyLen * 2);
-
+ if(EVP_PKEY_sign(ctx.get(), nullptr, &size, digest.data(), digest.size()) <= 0)
+ break;
+ vector<unsigned char> asn1(size);
+ result = EVP_PKEY_sign(ctx.get(), asn1.data(), &size, digest.data(), digest.size());
+ if(result <= 0)
+ break;
+ const unsigned char *p = asn1.data();
+ SCOPE(ECDSA_SIG, sig, d2i_ECDSA_SIG(nullptr, &p, long(asn1.size())));
  const BIGNUM *r = nullptr, *s = nullptr;
  ECDSA_SIG_get0(sig.get(), &r, &s);
- if(BN_bn2bin(r, &signature[keyLen - size_t(BN_num_bytes(r))]) <= 0)
+ size_t r_len = size_t(BN_num_bytes(r));
+ size_t s_len = size_t(BN_num_bytes(s));
+ size_t keyLen = max(r_len, s_len);
+ signature.resize(keyLen * 2);
+ if(BN_bn2bin(r, &signature[keyLen - r_len]) <= 0)
  THROW("Error copying signature 'r' value to buffer");
- if(BN_bn2bin(s, &signature[keyLen*2 - size_t(BN_num_bytes(s))]) <= 0)
+ if(BN_bn2bin(s, &signature[keyLen*2 - s_len]) <= 0)
  THROW("Error copying signature 's' value to buffer");
-
- result = 1;
  break;
  }
 #endif

src/crypto/X509CertStore.cpp

@@ -28,8 +28,11 @@
 #include "util/File.h"
 
 #include <openssl/conf.h>
-#include <openssl/x509v3.h>
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#include <openssl/provider.h>
+#endif
 #include <openssl/ssl.h>
+#include <openssl/x509v3.h>
 
 #include <algorithm>
 #include <iomanip>
@@ -70,6 +73,10 @@ class X509CertStore::Private: public vector<TSL::Service> {
 X509CertStore::X509CertStore()
  : d(new Private)
 {
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+ void(OSSL_PROVIDER_load(nullptr, "legacy"));
+ void(OSSL_PROVIDER_load(nullptr, "default"));
+#endif
  SSL_load_error_strings();
  SSL_library_init();
  d->update();

src/crypto/X509Crypto.cpp

@@ -211,28 +211,33 @@ bool X509Crypto::verify(const string &method, const vector<unsigned char> &diges
  if(!key)
  THROW("Certificate does not have a public key, can not verify signature.");
 
+ SCOPE(EVP_PKEY_CTX, ctx, EVP_PKEY_CTX_new(key, nullptr));
  int result = 0;
  switch(EVP_PKEY_base_id(key))
  {
  case EVP_PKEY_RSA:
  {
- RSA *rsa = EVP_PKEY_get0_RSA(key);
- auto decrypt = [rsa, &signature](int padding) {
- vector<unsigned char> decrypted(size_t(RSA_size(rsa)));
- int size = RSA_public_decrypt(int(signature.size()), signature.data(), decrypted.data(), rsa, padding);
- if(size <= 0)
- decrypted.clear();
- return decrypted;
- };
  int nid = Digest::toMethod(method);
-
  if(Digest::isRsaPssUri(method)) {
- vector<unsigned char> decrypted = decrypt(RSA_NO_PADDING);
- result = RSA_verify_PKCS1_PSS_mgf1(rsa, digest.data(), EVP_get_digestbynid(nid), nullptr, decrypted.data(), RSA_PSS_SALTLEN_DIGEST);
+ if(ctx &&
+ EVP_PKEY_verify_init(ctx.get()) == 1 &&
+ EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PSS_PADDING) == 1 &&
+ EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx.get(), RSA_PSS_SALTLEN_DIGEST) == 1 &&
+ EVP_PKEY_CTX_set_signature_md(ctx.get(), EVP_get_digestbynid(nid)) == 1)
+ result = EVP_PKEY_verify(ctx.get(), signature.data(), signature.size(), digest.data(), digest.size());
  } else {
- vector<unsigned char> out = decrypt(RSA_PKCS1_PADDING);
- const unsigned char *p = out.data();
- SCOPE(X509_SIG, sig, d2i_X509_SIG(nullptr, &p, long(out.size())));
+ size_t size = 0;
+ if(!ctx ||
+ EVP_PKEY_verify_recover_init(ctx.get()) <= 0 ||
+ EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PADDING) <= 0 ||
+ EVP_PKEY_verify_recover(ctx.get(), nullptr, &size, signature.data(), signature.size()) <= 0)
+ break;
+ vector<unsigned char> decrypted(size);
+ if(EVP_PKEY_verify_recover(ctx.get(), decrypted.data(), &size, signature.data(), signature.size()) <= 0)
+ break;
+ decrypted.resize(size);
+ const unsigned char *p = decrypted.data();
+ SCOPE(X509_SIG, sig, d2i_X509_SIG(nullptr, &p, long(decrypted.size())));
  if(!sig)
  break;
  const X509_ALGOR *algor = nullptr;
@@ -251,12 +256,13 @@ bool X509Crypto::verify(const string &method, const vector<unsigned char> &diges
 #ifndef OPENSSL_NO_ECDSA
  case EVP_PKEY_EC:
  {
- EC_KEY *ec = EVP_PKEY_get0_EC_KEY(key);
  SCOPE(ECDSA_SIG, sig, ECDSA_SIG_new());
  ECDSA_SIG_set0(sig.get(),
  BN_bin2bn(signature.data(), int(signature.size()/2), nullptr),
  BN_bin2bn(&signature[signature.size()/2], int(signature.size()/2), nullptr));
- result = ECDSA_do_verify(digest.data(), int(digest.size()), sig.get(), ec);
+ vector<unsigned char> asn1 = i2d(sig.get(), i2d_ECDSA_SIG);
+ if(ctx && EVP_PKEY_verify_init(ctx.get()) == 1)
+ result = EVP_PKEY_verify(ctx.get(), asn1.data(), asn1.size(), digest.data(), digest.size());
  break;
  }
 #endif