9#include <botan/p11_mechanism.h>
11#include <botan/pk_options.h>
12#include <botan/pk_options_readers.h>
13#include <botan/internal/algorithm_spec.h>
14#include <botan/internal/fmt.h>
15#include <botan/internal/parsing.h>
16#include <botan/internal/pk_options_impl.h>
22using PKCS11_PSS_Params = std::tuple<size_t, MechanismType, MGF>;
25const std::map<MechanismType, PKCS11_PSS_Params>& PssOptions() {
26 static const std::map<MechanismType, PKCS11_PSS_Params> pss_options = {
41 MechanismData(
const MechanismData& other) =
default;
42 MechanismData(MechanismData&& other) =
default;
44 MechanismData& operator=(
const MechanismData& other) =
default;
45 MechanismData& operator=(MechanismData&& other) =
default;
47 virtual ~MechanismData() =
default;
56class RSA_SignMechanism final :
public MechanismData {
60 const auto pss_option = PssOptions().find(type());
61 if(pss_option != PssOptions().end()) {
62 m_hash = std::get<1>(pss_option->second);
63 m_mgf = std::get<2>(pss_option->second);
64 m_salt_size = std::get<0>(pss_option->second);
70 MGF mgf()
const {
return m_mgf; }
72 size_t salt_size()
const {
return m_salt_size; }
98 throw Lookup_Error(
"PKCS#11 RSA encrypt/decrypt requires specifying a padding scheme");
101 const std::string& padding = options.
padding().value();
103 if(padding ==
"Raw") {
105 mech.m_padding_size = 0;
109 if(padding ==
"PKCS1v15") {
111 mech.m_padding_size = 11;
115 if(padding ==
"OAEP") {
120 size_t output_length;
123 static const std::map<std::string_view, OaepHash> OaepHashes = {
132 throw Lookup_Error(
"PKCS#11 RSA OAEP requires specifying a hash function");
136 const auto hash = OaepHashes.find(hash_name);
137 if(hash == OaepHashes.end()) {
138 throw Lookup_Error(
fmt(
"PKCS#11 RSA OAEP does not support hash function '{}'", hash_name));
141 MGF mgf = hash->second.mgf;
144 const auto mgf1_hash = OaepHashes.find(mgf1_hash_name);
145 if(mgf1_hash == OaepHashes.end()) {
146 throw Lookup_Error(
fmt(
"PKCS#11 RSA OAEP does not support MGF1 hash function '{}'", mgf1_hash_name));
148 mgf = mgf1_hash->second.mgf;
152 mech.m_parameters = std::make_shared<MechanismParameters>();
153 mech.m_parameters->oaep_params.hashAlg =
static_cast<CK_MECHANISM_TYPE>(hash->second.hash);
157 if(
const auto& label = options.
context(); label.has_value() && !label->empty()) {
158 mech.m_oaep_label = std::make_shared<const std::vector<uint8_t>>(*label);
159 mech.m_parameters->oaep_params.pSourceData =
const_cast<uint8_t*
>(mech.m_oaep_label->data());
160 mech.m_parameters->oaep_params.ulSourceDataLen =
checked_ulong_cast(mech.m_oaep_label->size());
162 mech.m_parameters->oaep_params.pSourceData =
nullptr;
163 mech.m_parameters->oaep_params.ulSourceDataLen = 0;
166 mech.m_mechanism.
pParameter = mech.m_parameters.get();
168 mech.m_padding_size = 2 + 2 * hash->second.output_length;
172 throw Lookup_Error(
fmt(
"PKCS#11 RSA encrypt/decrypt does not support padding with '{}'", padding));
177 static const std::map<std::string_view, RSA_SignMechanism> SignMechanisms = {
249 const std::string padding = [&]() {
254 const std::string scheme = options.
padding().value();
259 throw Not_Implemented(
fmt(
"PKCS#11 RSA {} signing of an externally computed {} prehash", scheme, *prehash));
261 return (scheme ==
"Raw") ? scheme :
fmt(
"{}(Raw)", scheme);
274 const auto mechanism_info_it = SignMechanisms.find(padding);
275 if(mechanism_info_it == SignMechanisms.end()) {
277 throw Lookup_Error(
fmt(
"PKCS#11 RSA sign/verify does not support padding with '{}'", padding));
279 const RSA_SignMechanism mechanism_info = mechanism_info_it->second;
283 throw Invalid_Argument(
fmt(
"PKCS#11 RSA signing with {} cannot produce deterministic signatures", padding));
287 if(PssOptions().contains(mechanism_info.type())) {
288 mech.m_parameters = std::make_shared<MechanismParameters>();
289 mech.m_parameters->pss_params.hashAlg =
static_cast<CK_MECHANISM_TYPE>(mechanism_info.hash());
292 mech.m_mechanism.
pParameter = mech.m_parameters.get();
300 static const std::map<std::string_view, MechanismType> EcdsaHash = {{
"Raw",
MechanismType::Ecdsa},
307 const std::string hash_spec(hash_spec_view);
308 auto mechanism = EcdsaHash.find(hash_spec);
309 if(mechanism != EcdsaHash.end()) {
315 if(
auto m = req.
match(
"EMSA1({hash})")) {
316 mechanism = EcdsaHash.find(m->str(
"hash"));
317 if(mechanism != EcdsaHash.end()) {
322 throw Lookup_Error(
fmt(
"PKCS #11 ECDSA sign/verify does not support {}", hash_spec));
327 static const std::map<std::string_view, KeyDerivation> EcdhHash = {{
"Raw",
KeyDerivation::Null},
334 const std::vector<std::string> param_parts =
split_on(params,
',');
336 if(param_parts.empty() || param_parts.size() > 2) {
341 bool use_cofactor =
false;
342 std::string kdf_name;
343 for(
const auto& part : param_parts) {
344 if(part ==
"Cofactor") {
350 if(!kdf_name.empty()) {
357 if(kdf_name.empty()) {
361 const auto kdf = EcdhHash.find(kdf_name);
362 if(kdf == EcdhHash.end()) {
363 throw Lookup_Error(
"PKCS#11 ECDH key derivation does not support KDF " + kdf_name);
366 mech.m_parameters = std::make_shared<MechanismParameters>();
367 mech.m_parameters->ecdh_params.kdf =
static_cast<CK_EC_KDF_TYPE>(kdf->second);
368 mech.m_mechanism.
pParameter = mech.m_parameters.get();
std::optional< AlgorithmMatch > match(const AlgorithmPattern &pattern) const &
static MechanismWrapper create_rsa_sign_mechanism(const PK_Signature_Options_Reader &options)
static MechanismWrapper create_ecdh_mechanism(std::string_view params)
MechanismType mechanism_type() const
static MechanismWrapper create_ecdsa_mechanism(std::string_view hash)
MechanismWrapper(MechanismType mechanism_type)
static MechanismWrapper create_rsa_crypt_mechanism(const PK_Encryption_Options_Reader &options)
bool using_padding() const
bool using_mgf1_hash() const
const std::optional< std::vector< uint8_t > > & context() const
const std::optional< std::string > & padding() const
const std::optional< std::string > & mgf1_hash_function() const
const std::string & hash_function_name() const
const std::optional< std::string > & padding() const
bool using_externally_computed_prehash() const
bool using_padding() const
const std::string & hash_function_name() const
bool using_salt_size() const
bool using_deterministic_signature() const
const std::optional< size_t > & salt_size() const
CK_RSA_PKCS_OAEP_PARAMS RsaPkcsOaepParams
Ulong checked_ulong_cast(size_t v)
CK_ECDH1_DERIVE_PARAMS Ecdh1DeriveParams
CK_RSA_PKCS_PSS_PARAMS RsaPkcsPssParams
std::string fmt(std::string_view format, const T &... args)
std::vector< std::string > split_on(std::string_view str, char delim)
std::optional< std::string > externally_computed_prehash_name(const PK_Signature_Options_Reader &options)
#define CKZ_DATA_SPECIFIED
CK_ULONG CK_RSA_PKCS_MGF_TYPE
CK_ULONG CK_MECHANISM_TYPE