//static
std::unique_ptr<PasswordHashFamily>
PasswordHashFamily::create_or_throw(const std::string& algo,
const std::string& provider)
{
if(auto pbkdf = PasswordHashFamily::create(algo, provider))
{
return pbkdf;
}
throw Lookup_Error("PasswordHashFamily", algo, provider);
}
std::unique_ptr<PK_Ops::Signature>
make_openssl_ecdsa_sig_op(const ECDSA_PrivateKey& key, const std::string& params)
{
const int nid = OpenSSL_EC_nid_for(key.domain().get_oid());
if(nid < 0)
{
throw Lookup_Error("OpenSSL ECDSA does not support this curve");
}
return std::unique_ptr<PK_Ops::Signature>(new OpenSSL_ECDSA_Signing_Operation(key, params));
}
//static
std::unique_ptr<KDF>
KDF::create_or_throw(const std::string& algo,
const std::string& provider)
{
if(auto kdf = KDF::create(algo, provider))
{
return kdf;
}
throw Lookup_Error("KDF", algo, provider);
}
//static
std::unique_ptr<BlockCipher>
BlockCipher::create_or_throw(const std::string& algo,
const std::string& provider)
{
if(auto bc = BlockCipher::create(algo, provider))
{
return bc;
}
throw Lookup_Error("Block cipher", algo, provider);
}
std::unique_ptr<PK_Ops::Verification>
make_openssl_ecdsa_ver_op(const ECDSA_PublicKey& key, const std::string& params)
{
const int nid = OpenSSL_EC_nid_for(key.domain().get_oid());
if(nid < 0)
{
throw Lookup_Error("OpenSSL ECDSA does not support this curve");
}
return std::unique_ptr<PK_Ops::Verification>(new OpenSSL_ECDSA_Verification_Operation(key, params, nid));
}
//static
std::unique_ptr<HashFunction>
HashFunction::create_or_throw(const std::string& algo,
const std::string& provider)
{
if(auto hash = HashFunction::create(algo, provider))
{
return hash;
}
throw Lookup_Error("Hash", algo, provider);
}
//static
std::unique_ptr<StreamCipher>
StreamCipher::create_or_throw(const std::string& algo,
const std::string& provider)
{
if(auto sc = StreamCipher::create(algo, provider))
{
return sc;
}
throw Lookup_Error("Stream cipher", algo, provider);
}
EC_Group::EC_Group(const OID& domain_oid)
{
const std::string pem = PEM_for_named_group(OIDS::lookup(domain_oid));
if(pem == "")
throw Lookup_Error("No ECC domain data for " + domain_oid.as_string());
*this = EC_Group(pem);
m_oid = domain_oid.as_string();
}
std::unique_ptr<PK_Ops::Key_Agreement>
make_openssl_ecdh_ka_op(const ECDH_PrivateKey& key, const std::string& params)
{
const int nid = OpenSSL_EC_nid_for(key.domain().get_oid());
if(nid < 0)
{
throw Lookup_Error("OpenSSL ECDH does not support this curve");
}
return std::unique_ptr<PK_Ops::Key_Agreement>(new OpenSSL_ECDH_KA_Operation(key, params));
}
std::shared_ptr<const X509_Certificate>
Certificate_Store_MacOS::find_cert(const X509_DN& subject_dn,
const std::vector<uint8_t>& key_id) const
{
const auto certs = find_all_certs(subject_dn, key_id);
if(certs.empty())
{
return nullptr; // certificate not found
}
if(certs.size() != 1)
{
throw Lookup_Error("ambiguous certificate result");
}
return certs.front();
}