Botan 3.14.1
Crypto and TLS for C&
pkcs1_sig_padding.cpp
Go to the documentation of this file.
1/*
2* PKCS #1 v1.5 signature padding
3* (C) 1999-2008 Jack Lloyd
4*
5* Botan is released under the Simplified BSD License (see license.txt)
6*/
7
8#include <botan/internal/pkcs1_sig_padding.h>
9
10#include <botan/assert.h>
11#include <botan/exceptn.h>
12#include <botan/hash.h>
13#include <botan/mem_ops.h>
14#include <botan/pk_options_readers.h>
15#include <botan/internal/buffer_stuffer.h>
16#include <botan/internal/fmt.h>
17#include <botan/internal/hash_id.h>
18#include <botan/internal/pk_options_impl.h>
19
20namespace Botan {
21
22namespace {
23
24std::vector<uint8_t> pkcs1v15_sig_encoding(std::span<const uint8_t> msg,
25 size_t output_bits,
26 std::span<const uint8_t> hash_id) {
27 const size_t output_length = output_bits / 8;
28
29 if(output_length < hash_id.size() + msg.size() + 2 + 8) {
30 throw Encoding_Error("pkcs1v15_sig_encoding: Output length is too small");
31 }
32
33 std::vector<uint8_t> padded(output_length);
34 BufferStuffer stuffer(padded);
35
36 stuffer.append(0x01);
37 stuffer.append(0xFF, stuffer.remaining_capacity() - (1 + hash_id.size() + msg.size()));
38 stuffer.append(0x00);
39 stuffer.append(hash_id);
40 stuffer.append(msg);
41 BOTAN_ASSERT_NOMSG(stuffer.full());
42
43 return padded;
44}
45
46} // namespace
47
48void PKCS1v15_SignaturePaddingScheme::update(const uint8_t input[], size_t length) {
49 m_hash->update(input, length);
50}
51
53 return m_hash->final_stdvec();
54}
55
56std::vector<uint8_t> PKCS1v15_SignaturePaddingScheme::encoding_of(std::span<const uint8_t> msg,
57 size_t output_bits,
58 RandomNumberGenerator& /*rng*/) {
59 if(msg.size() != m_hash->output_length()) {
60 throw Encoding_Error("PKCS1v15_SignaturePaddingScheme::encoding_of: Bad input length");
61 }
62
63 return pkcs1v15_sig_encoding(msg, output_bits, m_hash_id);
64}
65
66bool PKCS1v15_SignaturePaddingScheme::verify(std::span<const uint8_t> coded,
67 std::span<const uint8_t> raw,
68 size_t key_bits) {
69 if(raw.size() != m_hash->output_length()) {
70 return false;
71 }
72
73 try {
74 const auto pkcs1 = pkcs1v15_sig_encoding(raw, key_bits, m_hash_id);
75 return constant_time_compare(coded, pkcs1);
76 } catch(...) {
77 return false;
78 }
79}
80
82 m_hash(HashFunction::create_or_throw(options.hash_function_name())) {
84 m_hash_id = pkcs_hash_id(m_hash->name());
85}
86
88 return m_hash->name();
89}
90
92 return fmt("PKCS1v15({})", m_hash->name());
93}
94
96 if(m_hash_name.empty()) {
97 return "PKCS1v15(Raw)";
98 } else {
99 return fmt("PKCS1v15(Raw,{})", m_hash_name);
100 }
101}
102
105
107 "PKCS1v15 raw signing requires an externally computed prehash");
108
109 if(auto hash_algo = externally_computed_prehash_name(options)) {
110 std::unique_ptr<HashFunction> hash(HashFunction::create_or_throw(*hash_algo));
111 m_hash_id = pkcs_hash_id(hash->name());
112 m_hash_name = hash->name();
113 m_hash_output_len = hash->output_length();
114 } else {
115 m_hash_output_len = 0;
116 // m_hash_id, m_hash_name left empty
117 }
118}
119
120void PKCS1v15_Raw_SignaturePaddingScheme::update(const uint8_t input[], size_t length) {
121 if(length > 0) {
122 // A sanity check to prevent someone from accidentally feeding an entire message
123 // into PKCS1v15(Raw), which would have to be buffered in memory
124 if(m_message.size() + length > 16384 / 8) {
125 throw Invalid_Argument("PKCS1v15(Raw) message too long");
126 }
127 m_message.insert(m_message.end(), input, input + length);
128 }
129}
130
132 std::vector<uint8_t> ret;
133 std::swap(ret, m_message);
134
135 if(m_hash_output_len > 0 && ret.size() != m_hash_output_len) {
136 throw Encoding_Error("PKCS1v15_Raw_SignaturePaddingScheme::encoding_of: Bad input length");
137 }
138
139 return ret;
140}
141
142std::vector<uint8_t> PKCS1v15_Raw_SignaturePaddingScheme::encoding_of(std::span<const uint8_t> msg,
143 size_t output_bits,
144 RandomNumberGenerator& /*rng*/) {
145 return pkcs1v15_sig_encoding(msg, output_bits, m_hash_id);
146}
147
148bool PKCS1v15_Raw_SignaturePaddingScheme::verify(std::span<const uint8_t> coded,
149 std::span<const uint8_t> raw,
150 size_t key_bits) {
151 if(m_hash_output_len > 0 && raw.size() != m_hash_output_len) {
152 return false;
153 }
154
155 try {
156 const auto pkcs1 = pkcs1v15_sig_encoding(raw, key_bits, m_hash_id);
157 return constant_time_compare(coded, pkcs1);
158 } catch(...) {
159 return false;
160 }
161}
162
163} // namespace Botan
#define BOTAN_ASSERT_NOMSG(expr)
Definition assert.h:82
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33
Helper class to ease in-place marshalling of concatenated fixed-length values.
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:311
std::vector< uint8_t > encoding_of(std::span< const uint8_t > msg, size_t output_bits, RandomNumberGenerator &rng) override
std::vector< uint8_t > raw_data() override
void update(const uint8_t input[], size_t length) override
bool verify(std::span< const uint8_t > coded, std::span< const uint8_t > raw, size_t key_bits) override
PKCS1v15_Raw_SignaturePaddingScheme(const PK_Signature_Options_Reader &options)
void update(const uint8_t input[], size_t length) override
PKCS1v15_SignaturePaddingScheme(const PK_Signature_Options_Reader &options)
std::vector< uint8_t > encoding_of(std::span< const uint8_t > msg, size_t output_bits, RandomNumberGenerator &rng) override
std::vector< uint8_t > raw_data() override
bool verify(std::span< const uint8_t > coded, std::span< const uint8_t > raw, size_t key_bits) override
std::string hash_function() const override
static std::unique_ptr< SignaturePaddingScheme > create_or_throw(const PK_Signature_Options_Reader &options)
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
void acknowledge_always_deterministic(const PK_Signature_Options_Reader &options)
std::vector< uint8_t > pkcs_hash_id(std::string_view name)
Definition hash_id.cpp:78
std::optional< std::string > externally_computed_prehash_name(const PK_Signature_Options_Reader &options)
bool constant_time_compare(std::span< const uint8_t > x, std::span< const uint8_t > y)
Definition mem_ops.cpp:17