21#include <openssl/pem.h>
27#if OPENSSL_VERSION_NUMBER >= 0x30000000L
28#include <openssl/core_names.h>
29#include <openssl/params.h>
30#include <openssl/provider.h>
35#if OPENSSL_VERSION_NUMBER >= 0x30000000L
37extern OSSL_DISPATCH
const HMAC_SHA256_funcs[];
38extern OSSL_ALGORITHM
const HMAC_SHA256_algs[];
39extern OSSL_DISPATCH
const HMAC_SHA256_method[];
50#if OPENSSL_VERSION_NUMBER < 0x30000000L
54 _md = EVP_MD_meth_new(NID_sha256, NID_sha256WithRSAEncryption);
56 EVP_MD_meth_set_flags(_md, EVP_MD_FLAG_DIGALGID_ABSENT);
57 EVP_MD_meth_set_init(_md, &
Init);
59 EVP_MD_meth_set_final(_md, &Finalize);
60 EVP_MD_meth_set_copy(_md, &Copy);
61 EVP_MD_meth_set_cleanup(_md, &Cleanup);
62 EVP_MD_meth_set_input_blocksize(_md, SHA256_CBLOCK);
63 EVP_MD_meth_set_app_datasize(_md,
sizeof(EVP_MD*) +
sizeof(CTX_DATA*));
66 HMAC_SHA256_MD(HMAC_SHA256_MD
const&) =
delete;
67 HMAC_SHA256_MD(HMAC_SHA256_MD&&) =
delete;
69 HMAC_SHA256_MD& operator=(HMAC_SHA256_MD
const&) =
delete;
70 HMAC_SHA256_MD& operator=(HMAC_SHA256_MD&&) =
delete;
74 EVP_MD_meth_free(_md);
83 static int Init(EVP_MD_CTX* ctx)
89 static int UpdateData(EVP_MD_CTX* ctx,
const void* data,
size_t count)
91 CTX_DATA* ctxData =
reinterpret_cast<CTX_DATA*
>(EVP_MD_CTX_md_data(ctx));
95 ctxData->hmac->UpdateData(
reinterpret_cast<uint8 const*
>(data), count);
99 static int Finalize(EVP_MD_CTX* ctx,
unsigned char* md)
101 CTX_DATA* ctxData =
reinterpret_cast<CTX_DATA*
>(EVP_MD_CTX_md_data(ctx));
105 ctxData->hmac->Finalize();
106 memcpy(md, ctxData->hmac->GetDigest().data(), ctxData->hmac->GetDigest().size());
111 static int Copy(EVP_MD_CTX* to, EVP_MD_CTX
const* from)
113 CTX_DATA
const* ctxDataFrom =
reinterpret_cast<CTX_DATA const*
>(EVP_MD_CTX_md_data(from));
114 CTX_DATA* ctxDataTo =
reinterpret_cast<CTX_DATA*
>(EVP_MD_CTX_md_data(to));
116 if (ctxDataFrom->hmac)
122 static int Cleanup(EVP_MD_CTX* ctx)
124 CTX_DATA* data =
reinterpret_cast<CTX_DATA*
>(EVP_MD_CTX_md_data(ctx));
128 data->hmac =
nullptr;
141 _lib = OSSL_LIB_CTX_new();
142 OSSL_PROVIDER_add_builtin(_lib,
"trinity-rsa-hmac-sha256", &InitProvider);
143 _handle = OSSL_PROVIDER_try_load(_lib,
"trinity-rsa-hmac-sha256", 1);
149 OSSL_PROVIDER_unload(_handle);
151 OSSL_LIB_CTX_free(_lib);
154 OSSL_LIB_CTX* GetLib()
const
159 static int InitProvider(
const OSSL_CORE_HANDLE* ,
const OSSL_DISPATCH* ,
const OSSL_DISPATCH** out,
void** )
161 *out = HMAC_SHA256_method;
165 static OSSL_ALGORITHM
const* QueryProvider(
void* ,
int operation_id,
int* no_cache)
168 if (operation_id == OSSL_OP_DIGEST)
169 return HMAC_SHA256_algs;
174 static CTX_DATA* DigestNew()
176 CTX_DATA* data =
new CTX_DATA();
177 data->hmac =
nullptr;
181 static int DigestInit(
void* dctx, OSSL_PARAM
const*
params)
183 CTX_DATA* ctxData =
reinterpret_cast<CTX_DATA*
>(dctx);
185 delete ctxData->hmac;
186 if (OSSL_PARAM
const* keyParam = OSSL_PARAM_locate_const(
params,
"hmac-key"))
188 uint8 const* key =
nullptr;
189 size_t keyLength = 0;
190 if (OSSL_PARAM_get_octet_ptr(keyParam,
reinterpret_cast<void const**
>(&key), &keyLength))
200 static int DigestUpdate(
void* dctx,
const unsigned char* in,
size_t inl)
202 reinterpret_cast<CTX_DATA*
>(dctx)->hmac->UpdateData(in, inl);
206 static int DigestFinal(
void* dctx,
unsigned char* out,
size_t* outl,
size_t outsz)
208 CTX_DATA* ctxData =
reinterpret_cast<CTX_DATA*
>(dctx);
209 ctxData->hmac->Finalize();
210 *outl = std::min(ctxData->hmac->GetDigest().size(), outsz);
211 memcpy(out, ctxData->hmac->GetDigest().data(), *outl);
215 static void DigestFree(
void* dctx)
217 CTX_DATA* data =
reinterpret_cast<CTX_DATA*
>(dctx);
221 data->hmac =
nullptr;
226 static void* DigestDup(
void* dctx)
228 CTX_DATA
const* ctxDataFrom =
reinterpret_cast<CTX_DATA const*
>(dctx);
229 CTX_DATA* ctxDataTo = DigestNew();
230 if (ctxDataFrom->hmac)
236 static int DigestGetParams(OSSL_PARAM
params[])
238 OSSL_PARAM* p =
nullptr;
240 p = OSSL_PARAM_locate(
params, OSSL_DIGEST_PARAM_BLOCK_SIZE);
241 if (p !=
nullptr && !OSSL_PARAM_set_size_t(p, SHA256_CBLOCK))
244 p = OSSL_PARAM_locate(
params, OSSL_DIGEST_PARAM_SIZE);
248 p = OSSL_PARAM_locate(
params, OSSL_DIGEST_PARAM_XOF);
249 if (p !=
nullptr && !OSSL_PARAM_set_int(p, 0))
252 p = OSSL_PARAM_locate(
params, OSSL_DIGEST_PARAM_ALGID_ABSENT);
253 if (p !=
nullptr && !OSSL_PARAM_set_int(p, 1))
259 static OSSL_PARAM
const* DigestGettableParams()
261 static constexpr OSSL_PARAM Params[] =
263 OSSL_PARAM_size_t(OSSL_DIGEST_PARAM_BLOCK_SIZE, NULL),
264 OSSL_PARAM_size_t(OSSL_DIGEST_PARAM_SIZE, NULL),
265 OSSL_PARAM_int(OSSL_DIGEST_PARAM_XOF, NULL),
266 OSSL_PARAM_int(OSSL_DIGEST_PARAM_ALGID_ABSENT, NULL),
275 OSSL_PROVIDER* _handle;
279#if OPENSSL_VERSION_NUMBER >= 0x30000000L
281OSSL_DISPATCH
const HMAC_SHA256_funcs[] =
283 { OSSL_FUNC_DIGEST_NEWCTX, (void (*)())HMAC_SHA256_MD::DigestNew },
284 { OSSL_FUNC_DIGEST_INIT, (void (*)())HMAC_SHA256_MD::DigestInit },
285 { OSSL_FUNC_DIGEST_UPDATE, (void (*)())HMAC_SHA256_MD::DigestUpdate },
286 { OSSL_FUNC_DIGEST_FINAL, (void (*)())HMAC_SHA256_MD::DigestFinal },
287 { OSSL_FUNC_DIGEST_FREECTX, (void (*)())HMAC_SHA256_MD::DigestFree },
288 { OSSL_FUNC_DIGEST_DUPCTX, (void (*)())HMAC_SHA256_MD::DigestDup },
289 { OSSL_FUNC_DIGEST_GET_PARAMS, (void (*)())HMAC_SHA256_MD::DigestGetParams },
290 { OSSL_FUNC_DIGEST_GETTABLE_PARAMS, (void (*)())HMAC_SHA256_MD::DigestGettableParams },
294OSSL_ALGORITHM
const HMAC_SHA256_algs[] =
297 { OSSL_DIGEST_NAME_SHA2_256,
"provider=trinity-rsa-hmac-sha256", HMAC_SHA256_funcs,
"HMAC SHA265 \"digest\" for RSA" },
298 {
nullptr,
nullptr,
nullptr,
nullptr}
301OSSL_DISPATCH
const HMAC_SHA256_method[] =
303 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void(*)())HMAC_SHA256_MD::QueryProvider },
312#if OPENSSL_VERSION_NUMBER >= 0x30000000L
321 return std::unique_ptr<EVP_MD, EVP_MD_Deleter>(EVP_MD_fetch(
nullptr, OSSL_DIGEST_NAME_SHA2_256,
"provider=default"));
324OSSL_LIB_CTX* RsaSignature::SHA256::GetLib()
const
329std::unique_ptr<OSSL_PARAM[]> RsaSignature::SHA256::GetParams()
const
336 return std::unique_ptr<EVP_MD, EVP_MD_Deleter>(EVP_MD_fetch(HmacSha256Md.GetLib(), OSSL_DIGEST_NAME_SHA2_256,
"provider=trinity-rsa-hmac-sha256"));
339OSSL_LIB_CTX* RsaSignature::HMAC_SHA256::GetLib()
const
341 return HmacSha256Md.GetLib();
344std::unique_ptr<OSSL_PARAM[]> RsaSignature::HMAC_SHA256::GetParams()
const
346 return std::unique_ptr<OSSL_PARAM[]>(
new OSSL_PARAM[2]
348 OSSL_PARAM_octet_ptr(
"hmac-key",
const_cast<void**
>(
reinterpret_cast<void const* const*
>(&
_key)), _keyLength),
361 return std::unique_ptr<EVP_MD, EVP_MD_Deleter>(
const_cast<EVP_MD*
>(EVP_sha256()));
370 return std::unique_ptr<EVP_MD, EVP_MD_Deleter>(HmacSha256Md.GetMd());
375 HMAC_SHA256_MD::CTX_DATA* ctxData =
reinterpret_cast<HMAC_SHA256_MD::CTX_DATA*
>(EVP_MD_CTX_md_data(ctx));
377 delete ctxData->hmac;
394 *
this = std::move(other);
399 EVP_MD_CTX_free(
_ctx);
408 EVP_MD_CTX_copy_ex(
_ctx, right.
_ctx);
410 EVP_PKEY_up_ref(
_key);
420 _key = std::exchange(right._key, EVP_PKEY_new());
436 _key = EVP_PKEY_new();
437 if (!PEM_read_bio_PrivateKey(keyBIO.get(), &
_key,
nullptr,
nullptr))
452 const_cast<char*
>(keyPem.c_str()) ,
453 keyPem.length() + 1), BIO_free);
457 _key = EVP_PKEY_new();
458 if (!PEM_read_bio_PrivateKey(keyBIO.get(), &
_key,
nullptr,
nullptr))
466 std::unique_ptr<EVP_MD, DigestGenerator::EVP_MD_Deleter> digestGenerator = generator.
GetGenerator();
468#if OPENSSL_VERSION_NUMBER >= 0x30000000L
470 EVP_MD_CTX_set_pkey_ctx(
_ctx, keyCtx.get());
472 std::unique_ptr<OSSL_PARAM[]>
params = generator.GetParams();
473 int result = EVP_DigestSignInit_ex(
_ctx,
nullptr, EVP_MD_get0_name(digestGenerator.get()), generator.GetLib(),
nullptr,
_key,
params.get());
475 int result = EVP_DigestSignInit(
_ctx,
nullptr, digestGenerator.get(),
nullptr,
_key);
481 result = EVP_DigestSignUpdate(
_ctx, message, messageLength);
485 size_t signatureLength = 0;
486 result = EVP_DigestSignFinal(
_ctx,
nullptr, &signatureLength);
490 output.resize(signatureLength);
491 result = EVP_DigestSignFinal(
_ctx, output.data(), &signatureLength);
492 std::reverse(output.begin(), output.end());
std::unordered_set< uint32 > params[2]
virtual std::unique_ptr< EVP_MD, EVP_MD_Deleter > GetGenerator() const =0
virtual void PostInitCustomizeContext(EVP_MD_CTX *ctx)=0
void PostInitCustomizeContext(EVP_MD_CTX *ctx) override
std::unique_ptr< EVP_MD, EVP_MD_Deleter > GetGenerator() const override
void PostInitCustomizeContext(EVP_MD_CTX *ctx) override
std::unique_ptr< EVP_MD, EVP_MD_Deleter > GetGenerator() const override
bool LoadKeyFromFile(std::string const &fileName)
RsaSignature & operator=(RsaSignature const &right)
bool LoadKeyFromString(std::string const &keyPem)
bool Sign(std::array< uint8, N > const &message, DigestGenerator &generator, std::vector< uint8 > &output)
Trinity::Impl::GenericHMAC< EVP_sha256, Constants::SHA256_DIGEST_LENGTH_BYTES > HMAC_SHA256
TC_COMMON_API void Init()
auto make_unique_ptr_with_deleter(T ptr, Del &&deleter)
static constexpr size_t SHA256_DIGEST_LENGTH_BYTES
void operator()(EVP_MD *md) const
static EVP_MD_CTX * MakeCTX() noexcept