10#include <botan/ber_dec.h>
11#include <botan/der_enc.h>
12#include <botan/mutex.h>
13#include <botan/numthry.h>
14#include <botan/pss_params.h>
15#include <botan/internal/algorithm_spec.h>
16#include <botan/internal/barrett.h>
17#include <botan/internal/ct_utils.h>
18#include <botan/internal/divide.h>
19#include <botan/internal/fmt.h>
20#include <botan/internal/keypair.h>
21#include <botan/internal/mod_inv.h>
22#include <botan/internal/monty.h>
23#include <botan/internal/monty_exp.h>
24#include <botan/internal/mp_core.h>
25#include <botan/internal/parsing.h>
26#include <botan/internal/pk_ops_impl.h>
27#include <botan/internal/pk_options_impl.h>
28#include <botan/internal/sig_padding.h>
29#include <botan/internal/target_info.h>
30#include <botan/internal/workfactor.h>
32#if defined(BOTAN_HAS_THREAD_UTILS)
33 #include <botan/internal/thread_pool.h>
36#if defined(BOTAN_HAS_THREAD_UTILS) && !defined(BOTAN_HAS_VALGRIND)
37 #define BOTAN_RSA_USE_ASYNC
45constexpr size_t MAX_RSA_BITS = 16384;
49class RSA_Public_Data final {
51 RSA_Public_Data(BigInt&& n, BigInt&& e) :
54 m_mod_n(Barrett_Reduction::for_public_modulus(m_n)),
55 m_monty_n(m_n, m_mod_n),
56 m_public_modulus_bits(m_n.bits()),
57 m_public_modulus_bytes(m_n.bytes()) {}
59 BigInt public_op(
const BigInt& m)
const {
60 const size_t powm_window = 1;
65 const BigInt& get_n()
const {
return m_n; }
67 const BigInt& get_e()
const {
return m_e; }
69 size_t public_modulus_bits()
const {
return m_public_modulus_bits; }
71 size_t public_modulus_bytes()
const {
return m_public_modulus_bytes; }
73 const Montgomery_Params& monty_n()
const {
return m_monty_n; }
75 const Barrett_Reduction& reducer_mod_n()
const {
return m_mod_n; }
80 Barrett_Reduction m_mod_n;
81 const Montgomery_Params m_monty_n;
82 size_t m_public_modulus_bits;
83 size_t m_public_modulus_bytes;
105 const size_t n_words = 2 * p_words;
123 const BigInt h = h_monty.value();
131 bigint_mul(r.data(), r.size(), h._data(), h.size(), p_words, q._data(), q.size(), p_words, ws.data(), ws.size());
134 const word carry =
bigint_add2(r.data(), n_words, j2._data(), p_words);
146 const size_t m_words = m.
size();
147 const size_t p_words = p_minus_1.size();
152 bigint_mul(z.data(), z.size(), m._data(), m_words, m_words, p_minus_1._data(), p_words, p_words,
nullptr, 0);
153 const word carry =
bigint_add2(z.data(), z.size(), d._data(), d.size());
161class RSA_Private_Data final {
163 RSA_Private_Data(std::shared_ptr<const RSA_Public_Data> pub,
170 m_public(std::move(pub)),
177 m_p_minus_1(m_p - 1),
178 m_q_minus_1(m_q - 1),
181 m_c_monty(m_monty_p, m_c),
182 m_p_bits(m_p.bits()),
183 m_q_bits(m_q.bits()) {}
185 const BigInt& get_d()
const {
return m_d; }
187 const BigInt& get_p()
const {
return m_p; }
189 const BigInt& get_q()
const {
return m_q; }
191 const BigInt& get_d1()
const {
return m_d1; }
193 const BigInt& get_d2()
const {
return m_d2; }
195 BigInt blinded_d1(
const BigInt& m)
const {
return blind_exponent(m_d1, m, m_p_minus_1); }
197 BigInt blinded_d2(
const BigInt& m)
const {
return blind_exponent(m_d2, m, m_q_minus_1); }
199 const BigInt& get_c()
const {
return m_c; }
201 const Montgomery_Int& get_c_monty()
const {
return m_c_monty; }
203 const Montgomery_Params& monty_p()
const {
return m_monty_p; }
205 const Montgomery_Params& monty_q()
const {
return m_monty_q; }
207 size_t p_bits()
const {
return m_p_bits; }
209 size_t q_bits()
const {
return m_q_bits; }
211 bool primes_imbalanced()
const {
return p_bits() != q_bits(); }
213 void _const_time_poison()
const {
229 void _const_time_unpoison()
const {
252 std::pair<BigInt, BigInt> next_blinding_pair(RandomNumberGenerator& rng)
const {
255 if(m_blinding_uses == 0 || m_blinding_uses >= BlindingReinitInterval) {
258 const BigInt k(rng, m_public->public_modulus_bits() - 1);
260 auto [fwd, inv] = fresh_blinding_pair(k);
261 m_blinding_fwd = std::move(fwd);
262 m_blinding_inv = std::move(inv);
265 const auto& mod_n = m_public->reducer_mod_n();
266 m_blinding_fwd = mod_n.square(m_blinding_fwd);
267 m_blinding_inv = mod_n.square(m_blinding_inv);
270 m_blinding_uses += 1;
271 return {m_blinding_fwd, m_blinding_inv};
275 static constexpr size_t BlindingReinitInterval = 64;
278 std::pair<BigInt, BigInt> fresh_blinding_pair(
const BigInt& k)
const {
279 if(primes_imbalanced()) {
282 return crt_blinding_pair(m_public->get_e(), k);
291 std::pair<BigInt, BigInt> crt_blinding_pair(
const BigInt& e,
const BigInt& k)
const {
294 const BigInt kp = kp_monty.value();
295 const BigInt kq = kq_monty.value();
298 if(kp.is_zero() || kq.is_zero()) {
303 auto half = [&e](
const Montgomery_Int& k_monty,
const BigInt& k_mod,
const BigInt& prime) {
304 const size_t powm_window = 1;
307 return std::make_pair(std::move(fwd), std::move(inv));
310#if defined(BOTAN_RSA_USE_ASYNC)
317 const auto [fwd_q, inv_q] = half(kq_monty, kq, m_q);
319#if defined(BOTAN_RSA_USE_ASYNC)
320 const auto [fwd_p, inv_p] = future_p.get();
322 const auto [fwd_p, inv_p] = half(kp_monty, kp, m_p);
325 const BigInt fwd_q_v = fwd_q.value();
326 const Montgomery_Int inv_p_monty(m_monty_p, inv_p);
333 std::shared_ptr<const RSA_Public_Data> m_public;
343 const Montgomery_Params m_monty_p;
344 const Montgomery_Params m_monty_q;
345 Montgomery_Int m_c_monty;
350 mutable BigInt m_blinding_fwd;
351 mutable BigInt m_blinding_inv;
352 mutable size_t m_blinding_uses = 0;
362 }
else if(field ==
"e") {
370 return std::make_unique<RSA_PrivateKey>(rng,
m_public->public_modulus_bits(), 65537);
382 if(n.signum() <= 0 || n.is_even() || n.bits() < 384 || n.bits() > MAX_RSA_BITS) {
385 if(e.is_even() || e <= 1 || e >= n || e.bits() > 256) {
388 m_public = std::make_shared<RSA_Public_Data>(std::move(n), std::move(e));
404 init(std::move(n), std::move(e));
415 init(std::move(n), std::move(e));
419 return m_public->public_modulus_bits();
431 throw Not_Implemented(
"an RSA public key does not provide a raw binary representation.");
435 std::vector<uint8_t> output;
459 .
encode(
static_cast<size_t>(0))
473 return m_private->get_p();
477 return m_private->get_q();
481 return m_private->get_d();
485 return m_private->get_c();
489 return m_private->get_d1();
493 return m_private->get_d2();
499 if(n.
bits() > MAX_RSA_BITS || p < 3 || q < 3 || p == q || p >= n || q >= n) {
503 throw Decoding_Error(
"Invalid RSA private key: p * q != n");
515 throw Decoding_Error(
"Invalid RSA private key: e * d != 1 mod lcm(p-1, q-1)");
522 check_rsa_private_key_params(
get_n(), p, q);
534 if(d < 2 || d >=
get_n()) {
535 throw Decoding_Error(
"Invalid RSA private key exponent");
537 if(d1 < 1 || d1 >= p || d2 < 1 || d2 >= q || c < 1 || c >= p) {
538 throw Decoding_Error(
"Invalid RSA private key CRT parameters");
541 m_private = std::make_shared<RSA_Private_Data>(
542 m_public, std::move(d), std::move(p), std::move(q), std::move(d1), std::move(d2), std::move(c));
547 throw Decoding_Error(
"Unexpected parameters for RSA private key");
575 RSA_PrivateKey::init(std::move(d), std::move(p), std::move(q), std::move(d1), std::move(d2), std::move(c));
594 check_rsa_private_key_params(
get_n(), p, q);
597 const bool compute_d = d.
is_zero();
600 check_rsa_secret_exponent(
get_e(), d, p, q);
605 const BigInt p_minus_1 = p - 1;
606 const BigInt q_minus_1 = q - 1;
609 const BigInt phi_n =
lcm(p_minus_1, q_minus_1);
611 d = std::move(*d_inv);
613 throw Decoding_Error(
"Invalid RSA private key: e has no inverse modulo lcm(p-1, q-1)");
628 RSA_PrivateKey::init(std::move(d), std::move(p), std::move(q), std::move(d1), std::move(d2), std::move(c));
635 constexpr size_t MIN_RSA_BITS = 1024;
636 constexpr size_t MOD_RSA_BITS = 8;
638 if(bits < MIN_RSA_BITS) {
639 throw Invalid_Argument(
fmt(
"Cannot create an RSA key of {} bits: must be at least {} bits", bits, MIN_RSA_BITS));
640 }
else if(bits > MAX_RSA_BITS) {
642 fmt(
"Cannot create an RSA key of {} bits: must be no more than {} bits", bits, MAX_RSA_BITS));
643 }
else if(bits % MOD_RSA_BITS != 0) {
645 fmt(
"Cannot create an RSA key of {} bits: must be a multiple of {} bits", bits, MOD_RSA_BITS));
648 if(exp < 3 || exp % 2 == 0) {
652 const size_t p_bits = (bits + 1) / 2;
653 const size_t q_bits = bits - p_bits;
660 for(
size_t attempt = 0;; ++attempt) {
670 const BigInt diff = p - q;
671 if(diff.
bits() < (bits / 2) - 100) {
678 if(n.
bits() != bits) {
685 const BigInt p_minus_1 = p - 1;
686 const BigInt q_minus_1 = q - 1;
688 const BigInt phi_n =
lcm(p_minus_1, q_minus_1);
704 RSA_PrivateKey::init(std::move(*d), std::move(p), std::move(q), std::move(d1), std::move(d2), std::move(c));
709 return m_private->get_p();
710 }
else if(field ==
"q") {
711 return m_private->get_q();
712 }
else if(field ==
"d") {
713 return m_private->get_d();
714 }
else if(field ==
"c") {
715 return m_private->get_c();
716 }
else if(field ==
"d1") {
717 return m_private->get_d1();
718 }
else if(field ==
"d2") {
719 return m_private->get_d2();
726 return std::make_unique<RSA_PublicKey>(
get_n(),
get_e());
761 const size_t prob = (strong) ? 128 : 12;
775#if defined(BOTAN_HAS_PSS) && defined(BOTAN_HAS_SHA_256)
776 const std::string padding =
"PSS(SHA-256)";
778 const std::string padding =
"Raw";
792class RSA_Private_Operation {
794 size_t public_modulus_bits()
const {
return m_public->public_modulus_bits(); }
796 size_t public_modulus_bytes()
const {
return m_public->public_modulus_bytes(); }
798 explicit RSA_Private_Operation(
const RSA_PrivateKey& rsa, RandomNumberGenerator& rng) :
799 m_public(rsa.public_data()),
800 m_private(rsa.private_data()),
803 m_max_d1_bits(m_private->p_bits() + m_blinding_bits),
804 m_max_d2_bits(m_private->q_bits() + m_blinding_bits) {}
806 void raw_op(std::span<uint8_t> out, std::span<const uint8_t> input) {
809 if(input.size() > public_modulus_bytes()) {
810 throw Decoding_Error(
"RSA input is too long for this key");
812 const BigInt input_bn(input.data(), input.size());
813 if(input_bn.is_zero() || input_bn >= m_public->get_n()) {
814 throw Decoding_Error(
"RSA input is not in the valid range");
819 const auto [blind_fwd, blind_inv] = m_private->next_blinding_pair(m_rng);
820 const auto& mod_n = m_public->reducer_mod_n();
822 const BigInt recovered = mod_n.multiply(rsa_private_op(mod_n.multiply(input_bn, blind_fwd)), blind_inv);
825 BOTAN_ASSERT(input_bn == m_public->public_op(recovered),
"RSA consistency check");
826 BOTAN_ASSERT(m_public->public_modulus_bytes() == out.size(),
"output size check");
827 recovered.serialize_to(out);
831 BigInt rsa_private_op(
const BigInt& m)
const {
836 if(m_private->primes_imbalanced()) {
837 return monty_exp(m_public->monty_n(), m, m_private->get_d(), m_public->get_n().bits()).
value();
840 static constexpr size_t powm_window = 4;
843 const BigInt d1_mask(m_rng, m_blinding_bits);
846#if defined(BOTAN_RSA_USE_ASYNC)
856 const BigInt masked_d1 = m_private->blinded_d1(d1_mask);
857 const auto powm_d1_p =
859 auto j1 =
monty_execute(*powm_d1_p, masked_d1, m_max_d1_bits);
861#if defined(BOTAN_RSA_USE_ASYNC)
866 const BigInt d2_mask(m_rng, m_blinding_bits);
868 const BigInt masked_d2 = m_private->blinded_d2(d2_mask);
872#if defined(BOTAN_RSA_USE_ASYNC)
873 const auto j1 = future_j1.get();
879 return crt_recombine(j1, j2_p, j2, m_private->get_c_monty(), m_private->get_p(), m_private->get_q());
882 std::shared_ptr<const RSA_Public_Data> m_public;
883 std::shared_ptr<const RSA_Private_Data> m_private;
885 RandomNumberGenerator& m_rng;
886 const size_t m_blinding_bits;
887 const size_t m_max_d1_bits;
888 const size_t m_max_d2_bits;
892 private RSA_Private_Operation {
894 void update(std::span<const uint8_t> msg)
override { m_padding->
update(msg.data(), msg.size()); }
896 std::vector<uint8_t> sign(RandomNumberGenerator& rng)
override {
897 const size_t max_input_bits = public_modulus_bits() - 1;
898 const auto msg = m_padding->raw_data();
899 const auto padded = m_padding->encoding_of(msg, max_input_bits, rng);
901 std::vector<uint8_t> out(public_modulus_bytes());
906 size_t signature_length()
const override {
return public_modulus_bytes(); }
908 AlgorithmIdentifier algorithm_identifier()
const override;
910 std::string hash_function()
const override {
912 return m_padding->hash_function();
915 RSA_Signature_Operation(
const RSA_PrivateKey& rsa,
916 const PK_Signature_Options_Reader& options,
917 RandomNumberGenerator& rng) :
918 RSA_Private_Operation(rsa, rng), m_padding(SignaturePaddingScheme::create_or_throw(options)) {}
921 std::unique_ptr<SignaturePaddingScheme> m_padding;
925 const std::string padding_name = m_padding->name();
928 const std::string full_name =
"RSA/" + padding_name;
929 const OID oid = OID::from_string(full_name);
931 return AlgorithmIdentifier(oid, AlgorithmIdentifier::USE_NULL_PARAM);
932 }
catch(Lookup_Error&) {}
934 if(padding_name.starts_with(
"PSS(")) {
935 const auto parameters = PSS_Params::from_padding_name(m_padding->name()).serialize();
936 return AlgorithmIdentifier(
"RSA/PSS", parameters);
939 throw Invalid_Argument(
fmt(
"Signatures using RSA/{} are not supported", padding_name));
942class RSA_Decryption_Operation final :
public PK_Ops::Decryption_with_Padding,
943 private RSA_Private_Operation {
945 RSA_Decryption_Operation(
const RSA_PrivateKey& rsa,
946 const PK_Encryption_Options_Reader& options,
947 RandomNumberGenerator& rng) :
948 PK_Ops::Decryption_with_Padding(options), RSA_Private_Operation(rsa, rng) {}
950 size_t plaintext_length(
size_t )
const override {
return public_modulus_bytes(); }
952 size_t ciphertext_length(
size_t )
const override {
return public_modulus_bytes(); }
954 secure_vector<uint8_t> raw_decrypt(std::span<const uint8_t> input)
override {
961 if(input.size() != public_modulus_bytes()) {
962 throw Decoding_Error(
"RSA ciphertext is an incorrect size for this public key");
964 secure_vector<uint8_t> out(public_modulus_bytes());
970class RSA_KEM_Decryption_Operation final :
public PK_Ops::KEM_Decryption_with_KDF,
971 private RSA_Private_Operation {
973 RSA_KEM_Decryption_Operation(
const RSA_PrivateKey& key,
974 const PK_KEM_Options_Reader& options,
975 RandomNumberGenerator& rng) :
977 RSA_Private_Operation(key, rng) {}
979 size_t raw_kem_shared_key_length()
const override {
return public_modulus_bytes(); }
981 size_t encapsulated_key_length()
const override {
return public_modulus_bytes(); }
983 void raw_kem_decrypt(std::span<uint8_t> out_shared_key, std::span<const uint8_t> encapsulated_key)
override {
993 if(encapsulated_key.size() != public_modulus_bytes()) {
994 throw Decoding_Error(
"Invalid RSA-KEM ciphertext length");
996 raw_op(out_shared_key, encapsulated_key);
1003class RSA_Public_Operation {
1005 explicit RSA_Public_Operation(
const RSA_PublicKey& rsa) : m_public(rsa.public_data()) {}
1007 size_t public_modulus_bits()
const {
return m_public->public_modulus_bits(); }
1010 BigInt public_op(
const BigInt& m)
const {
1011 if(m >= m_public->get_n()) {
1012 throw Decoding_Error(
"RSA public op - input is too large");
1015 return m_public->public_op(m);
1018 size_t public_modulus_bytes()
const {
return m_public->public_modulus_bytes(); }
1020 const BigInt& get_n()
const {
return m_public->get_n(); }
1023 std::shared_ptr<const RSA_Public_Data> m_public;
1026class RSA_Encryption_Operation final :
public PK_Ops::Encryption_with_Padding,
1027 private RSA_Public_Operation {
1029 RSA_Encryption_Operation(
const RSA_PublicKey& rsa,
const PK_Encryption_Options_Reader& options) :
1030 PK_Ops::Encryption_with_Padding(options), RSA_Public_Operation(rsa) {}
1032 size_t ciphertext_length(
size_t )
const override {
return public_modulus_bytes(); }
1034 size_t max_ptext_input_bits()
const override {
return public_modulus_bits() - 1; }
1036 std::vector<uint8_t> raw_encrypt(std::span<const uint8_t> input, RandomNumberGenerator& )
override {
1037 const BigInt input_bn(input);
1038 CT::poison(input_bn);
1039 const BigInt c = public_op(input_bn);
1041 return c.serialize(public_modulus_bytes());
1045class RSA_Verify_Operation final :
public PK_Ops::Verification,
1046 private RSA_Public_Operation {
1048 void update(std::span<const uint8_t> msg)
override { m_padding->update(msg.data(), msg.size()); }
1050 bool is_valid_signature(std::span<const uint8_t> sig)
override {
1051 const auto msg = m_padding->raw_data();
1052 const auto message_repr = recover_message_repr(sig.data(), sig.size());
1053 return m_padding->verify(message_repr, msg, public_modulus_bits() - 1);
1056 RSA_Verify_Operation(
const RSA_PublicKey& rsa,
const PK_Signature_Options_Reader& options) :
1057 RSA_Public_Operation(rsa), m_padding(SignaturePaddingScheme::create_or_throw(options)) {}
1059 std::string hash_function()
const override {
return m_padding->hash_function(); }
1062 std::vector<uint8_t> recover_message_repr(
const uint8_t input[],
size_t input_len) {
1067 if(input_len != public_modulus_bytes()) {
1068 throw Decoding_Error(
"RSA signature is an incorrect size for this public key");
1070 const BigInt input_bn(input, input_len);
1071 return public_op(input_bn).serialize();
1074 std::unique_ptr<SignaturePaddingScheme> m_padding;
1077class RSA_KEM_Encryption_Operation final :
public PK_Ops::KEM_Encryption_with_KDF,
1078 private RSA_Public_Operation {
1080 RSA_KEM_Encryption_Operation(
const RSA_PublicKey& key,
const PK_KEM_Options_Reader& options) :
1082 RSA_Public_Operation(key) {}
1085 size_t raw_kem_shared_key_length()
const override {
return public_modulus_bytes(); }
1087 size_t encapsulated_key_length()
const override {
return public_modulus_bytes(); }
1089 void raw_kem_encrypt(std::span<uint8_t> out_encapsulated_key,
1090 std::span<uint8_t> raw_shared_key,
1091 RandomNumberGenerator& rng)
override {
1092 const BigInt r = BigInt::random_integer(rng, BigInt::one(), get_n());
1094 const BigInt c = public_op(r);
1097 c.serialize_to(out_encapsulated_key);
1098 r.serialize_to(raw_shared_key);
1099 CT::unpoison(raw_shared_key);
1110 return std::make_unique<RSA_Encryption_Operation>(*
this, options);
1117 return std::make_unique<RSA_KEM_Encryption_Operation>(*
this, options);
1124 return std::make_unique<RSA_Verify_Operation>(*
this, options);
1132 throw Decoding_Error(
"Unknown AlgorithmIdentifier for RSA X.509 signatures");
1135 const auto sig_info =
split_on(*oid_name,
'/');
1137 if(sig_info.empty() || sig_info.size() != 2 || sig_info[0] !=
"RSA") {
1138 throw Decoding_Error(
"Unknown AlgorithmIdentifier for RSA X.509 signatures");
1141 const std::string& padding = sig_info[1];
1143 if(padding !=
"PSS") {
1145 throw Decoding_Error(
"Non-PSS RSA signature algorithm OID has unexpected parameters");
1149 if(padding ==
"PSS") {
1152 throw Decoding_Error(
"PSS params must be provided");
1155 const PSS_Params pss_params(alg_id.
parameters());
1159 const auto hash_algo = pss_params.hash_algid().oid().registered_name();
1160 if(hash_algo !=
"SHA-1" && hash_algo !=
"SHA-224" && hash_algo !=
"SHA-256" && hash_algo !=
"SHA-384" &&
1161 hash_algo !=
"SHA-512" && hash_algo !=
"SHA-3(224)" && hash_algo !=
"SHA-3(256)" &&
1162 hash_algo !=
"SHA-3(384)" && hash_algo !=
"SHA-3(512)") {
1163 throw Decoding_Error(
"Unacceptable hash for PSS signatures");
1166 if(pss_params.mgf_algid().oid().registered_name() !=
"MGF1") {
1167 throw Decoding_Error(
"Unacceptable MGF for PSS signatures");
1172 if(pss_params.hash_algid() != pss_params.mgf_hash_algid()) {
1173 throw Decoding_Error(
"Unacceptable MGF hash for PSS signatures");
1176 if(pss_params.trailer_field() != 1) {
1177 throw Decoding_Error(
"Unacceptable trailer field for PSS signatures");
1180 return PK_Signature_Options().with_padding(
"PSS").with_hash(*hash_algo).with_salt_size(pss_params.salt_length());
1182 const AlgorithmSpec spec(padding);
1184 const auto m = spec.match(
"PKCS1v15({hash})");
1186 throw Decoding_Error(
"Unexpected OID for RSA signatures");
1189 return PK_Signature_Options().with_padding(
"PKCS1v15").with_hash(m->str(
"hash"));
1196 std::string_view provider)
const {
1197 if(provider ==
"base" || provider.empty()) {
1198 return std::make_unique<RSA_Verify_Operation>(
1209 return std::make_unique<RSA_Decryption_Operation>(*
this, options, rng);
1216 return std::make_unique<RSA_KEM_Decryption_Operation>(*
this, options, rng);
1223 return std::make_unique<RSA_Signature_Operation>(*
this, options, rng);
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_DEBUG_ASSERT(expr)
#define BOTAN_ASSERT_NONNULL(ptr)
#define BOTAN_ASSERT(expr, assertion_made)
bool parameters_are_null_or_empty() const
const std::vector< uint8_t > & parameters() const
virtual const BigInt & get_int_field(std::string_view field) const
virtual OID object_identifier() const
BER_Decoder & decode(bool &out)
BER_Decoder & verify_end()
BER_Decoder start_sequence()
BER_Decoder & decode_and_check(const T &expected, std::string_view error_msg)
static BigInt _from_words(secure_vector< word > &words)
static BigInt from_u64(uint64_t n)
secure_vector< uint8_t > get_contents()
DER_Encoder & start_sequence()
DER_Encoder & encode(bool b)
static Montgomery_Int from_wide_int(const Montgomery_Params ¶ms, const BigInt &x)
std::optional< std::string > registered_name() const
virtual void update(std::span< const uint8_t > input)=0
static PK_Signature_Options_Reader for_verification(const PK_Signature_Options &options)
const BigInt & get_q() const
const BigInt & get_int_field(std::string_view field) const override
std::shared_ptr< const RSA_Private_Data > private_data() const
const BigInt & get_c() const
RSA_PrivateKey(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)
const BigInt & get_p() const
const BigInt & get_d2() const
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const override
const BigInt & get_d() const
std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const override
secure_vector< uint8_t > private_key_bits() const override
std::unique_ptr< Public_Key > public_key() const override
const BigInt & get_d1() const
std::unique_ptr< PK_Ops::Decryption > _create_decryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const override
std::unique_ptr< PK_Ops::Encryption > _create_encryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const override
std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const override
void init(BigInt &&n, BigInt &&e)
size_t key_length() const override
std::string algo_name() const override
std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &alg_id, std::string_view provider) const override
const BigInt & get_int_field(std::string_view field) const override
bool check_key(RandomNumberGenerator &rng, bool strong) const override
std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const override
const BigInt & get_n() const
size_t estimated_strength() const override
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const override
std::vector< uint8_t > raw_public_key_bits() const override
AlgorithmIdentifier algorithm_identifier() const override
std::vector< uint8_t > public_key_bits() const override
std::shared_ptr< const RSA_Public_Data > m_public
std::shared_ptr< const RSA_Public_Data > public_data() const
const BigInt & get_e() const
bool supports_operation(PublicKeyOperation op) const override
auto run(F &&f, Args &&... args) -> Joining_Future< std::invoke_result_t< F, Args... > >
static Thread_Pool & global_instance()
constexpr decltype(auto) driveby_unpoison(T &&v)
constexpr void poison_all(const Ts &... ts)
constexpr auto scoped_poison(const Ts &... xs)
constexpr void unpoison_all(const Ts &... ts)
constexpr void unpoison(const T *p, size_t n)
constexpr void poison(const T *p, size_t n)
bool signature_consistency_check(RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, std::string_view padding)
BigInt inverse_mod_secret_prime(const BigInt &x, const BigInt &p)
constexpr auto bigint_add2(W x[], size_t x_size, const W y[], size_t y_size) -> W
std::optional< BigInt > compute_rsa_secret_exponent(const BigInt &e, const BigInt &phi_n, const BigInt &p, const BigInt &q)
std::string fmt(std::string_view format, const T &... args)
BigInt lcm(const BigInt &a, const BigInt &b)
std::vector< std::string > split_on(std::string_view str, char delim)
size_t low_zero_bits(const BigInt &n)
void bigint_mul(word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, const word y[], size_t y_size, size_t y_sw, word workspace[], size_t ws_size)
secure_vector< T > lock(const std::vector< T > &in)
bool is_prime(const BigInt &n, RandomNumberGenerator &rng, size_t prob, bool is_random)
std::shared_ptr< const Montgomery_Exponentiation_State > monty_precompute(const Montgomery_Int &g, size_t window_bits)
BigInt ct_modulo(const BigInt &x, const BigInt &y)
void require_software_provider(const OptionsT &options, std::string_view algo_name)
BigInt generate_rsa_prime(RandomNumberGenerator &keygen_rng, RandomNumberGenerator &prime_test_rng, size_t bits, const BigInt &coprime, size_t prob)
Montgomery_Int monty_execute_vartime(const Montgomery_Exponentiation_State &precomputed_state, const BigInt &k)
std::vector< T, secure_allocator< T > > secure_vector
lock_guard< T > lock_guard_type
BigInt inverse_mod_rsa_public_modulus(const BigInt &x, const BigInt &n)
size_t if_work_factor(size_t bits)
std::conditional_t< HasNative64BitRegisters, std::uint64_t, uint32_t > word
The native machine word, used as the limb type for multiprecision integers.
Montgomery_Int monty_exp(const Montgomery_Params ¶ms_p, const BigInt &g, const BigInt &k, size_t max_k_bits)
Montgomery_Int monty_execute(const Montgomery_Exponentiation_State &precomputed_state, const BigInt &k, size_t max_k_bits)