399 lines
12 KiB
C++
399 lines
12 KiB
C++
#include "TessesFramework/Crypto/MbedHelpers.hpp"
|
|
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
#include <mbedtls/sha1.h>
|
|
#include <mbedtls/sha256.h>
|
|
#include <mbedtls/sha512.h>
|
|
#include <mbedtls/base64.h>
|
|
|
|
#include <mbedtls/pkcs5.h>
|
|
#include <mbedtls/entropy.h>
|
|
#include <mbedtls/ctr_drbg.h>
|
|
#endif
|
|
namespace Tesses::Framework::Crypto
|
|
{
|
|
bool HaveCrypto()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
std::string Base64_Encode(std::vector<uint8_t> data)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
std::string str={};
|
|
size_t olen=0;
|
|
mbedtls_base64_encode((uint8_t*)str.data(), 0, &olen, data.data(),data.size());
|
|
str.resize(olen-1);
|
|
|
|
|
|
if(mbedtls_base64_encode((uint8_t*)str.data(), olen, &olen, data.data(),data.size())==0)
|
|
{
|
|
return str;
|
|
}
|
|
|
|
#endif
|
|
return "";
|
|
}
|
|
std::vector<uint8_t> Base64_Decode(std::string str)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
size_t olen;
|
|
|
|
std::vector<uint8_t> data;
|
|
|
|
|
|
mbedtls_base64_decode(data.data(), 0, &olen, (const uint8_t*)str.data(),str.size());
|
|
data.resize(olen);
|
|
|
|
|
|
if(mbedtls_base64_decode(data.data(), olen, &olen, (const uint8_t*)str.data(),str.size())==0)
|
|
{
|
|
return data;
|
|
}
|
|
#endif
|
|
return {};
|
|
}
|
|
Sha1::Sha1()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
mbedtls_sha1_context* ctx = new mbedtls_sha1_context();
|
|
this->inner = ctx;
|
|
mbedtls_sha1_init(ctx);
|
|
|
|
#endif
|
|
}
|
|
bool Sha1::Start()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha1_context*>(this->inner);
|
|
mbedtls_sha1_starts(ctx);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha1::Update(const uint8_t* buffer, size_t sz)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha1_context*>(this->inner);
|
|
mbedtls_sha1_update(ctx,buffer,sz);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha1::Update(Tesses::Framework::Streams::Stream* strm)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
if(strm == nullptr) return false;
|
|
uint8_t buffer[1024];
|
|
size_t read;
|
|
do {
|
|
read = strm->Read(buffer,sizeof(buffer));
|
|
if(!Update(buffer,read)) return false;
|
|
} while(read != 0);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha1::Update(Tesses::Framework::Streams::Stream& strm)
|
|
{
|
|
return Update(&strm);
|
|
}
|
|
std::vector<uint8_t> Sha1::Finish()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha1_context*>(this->inner);
|
|
std::vector<uint8_t> hash;
|
|
hash.resize(20);
|
|
mbedtls_sha1_finish(ctx,hash.data());
|
|
return hash;
|
|
#endif
|
|
return {};
|
|
}
|
|
Sha1::~Sha1()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha1_context*>(this->inner);
|
|
mbedtls_sha1_free(ctx);
|
|
delete ctx;
|
|
#endif
|
|
}
|
|
std::vector<uint8_t> Sha1::ComputeHash(const uint8_t* buffer, size_t len)
|
|
{
|
|
Sha1 sha1;
|
|
if(!sha1.Start()) return {};
|
|
if(!sha1.Update(buffer,len)) return {};
|
|
return sha1.Finish();
|
|
}
|
|
std::vector<uint8_t> Sha1::ComputeHash(Tesses::Framework::Streams::Stream* strm)
|
|
{
|
|
Sha1 sha1;
|
|
if(!sha1.Start()) return {};
|
|
if(!sha1.Update(strm)) return {};
|
|
return sha1.Finish();
|
|
}
|
|
std::vector<uint8_t> Sha1::ComputeHash(Tesses::Framework::Streams::Stream& strm)
|
|
{
|
|
Sha1 sha1;
|
|
if(!sha1.Start()) return {};
|
|
if(!sha1.Update(strm)) return {};
|
|
return sha1.Finish();
|
|
}
|
|
|
|
Sha256::Sha256()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
mbedtls_sha256_context* ctx = new mbedtls_sha256_context();
|
|
this->inner = ctx;
|
|
mbedtls_sha256_init(ctx);
|
|
|
|
#endif
|
|
}
|
|
bool Sha256::Start(bool is224)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha256_context*>(this->inner);
|
|
this->is224=is224;
|
|
mbedtls_sha256_starts(ctx,is224);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha256::Is224()
|
|
{
|
|
return this->is224;
|
|
}
|
|
bool Sha256::Update(const uint8_t* buffer, size_t sz)
|
|
{
|
|
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha256_context*>(this->inner);
|
|
mbedtls_sha256_update(ctx,buffer,sz);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha256::Update(Tesses::Framework::Streams::Stream* strm)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
if(strm == nullptr) return false;
|
|
uint8_t buffer[1024];
|
|
size_t read;
|
|
do {
|
|
read = strm->Read(buffer,sizeof(buffer));
|
|
if(!Update(buffer,read)) return false;
|
|
} while(read != 0);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha256::Update(Tesses::Framework::Streams::Stream& strm)
|
|
{
|
|
return Update(&strm);
|
|
}
|
|
std::vector<uint8_t> Sha256::Finish()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha256_context*>(this->inner);
|
|
std::vector<uint8_t> hash;
|
|
hash.resize(32);
|
|
mbedtls_sha256_finish(ctx,hash.data());
|
|
return hash;
|
|
#endif
|
|
return {};
|
|
}
|
|
Sha256::~Sha256()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha256_context*>(this->inner);
|
|
mbedtls_sha256_free(ctx);
|
|
delete ctx;
|
|
#endif
|
|
}
|
|
std::vector<uint8_t> Sha256::ComputeHash(const uint8_t* buffer, size_t len,bool is224)
|
|
{
|
|
Sha256 sha256;
|
|
if(!sha256.Start(is224)) return {};
|
|
if(!sha256.Update(buffer,len)) return {};
|
|
return sha256.Finish();
|
|
}
|
|
std::vector<uint8_t> Sha256::ComputeHash(Tesses::Framework::Streams::Stream* strm,bool is224)
|
|
{
|
|
Sha256 sha256;
|
|
if(!sha256.Start(is224)) return {};
|
|
if(!sha256.Update(strm)) return {};
|
|
return sha256.Finish();
|
|
}
|
|
std::vector<uint8_t> Sha256::ComputeHash(Tesses::Framework::Streams::Stream& strm,bool is224)
|
|
{
|
|
Sha256 sha256;
|
|
if(!sha256.Start(is224)) return {};
|
|
if(!sha256.Update(strm)) return {};
|
|
return sha256.Finish();
|
|
}
|
|
|
|
Sha512::Sha512()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
mbedtls_sha512_context* ctx = new mbedtls_sha512_context();
|
|
this->inner = ctx;
|
|
mbedtls_sha512_init(ctx);
|
|
#endif
|
|
}
|
|
bool Sha512::Start(bool is384)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha512_context*>(this->inner);
|
|
this->is384=is384;
|
|
mbedtls_sha512_starts(ctx,is384);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha512::Is384()
|
|
{
|
|
return this->is384;
|
|
}
|
|
bool Sha512::Update(const uint8_t* buffer, size_t sz)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha512_context*>(this->inner);
|
|
mbedtls_sha512_update(ctx,buffer,sz);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha512::Update(Tesses::Framework::Streams::Stream* strm)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
if(strm == nullptr) return false;
|
|
uint8_t buffer[1024];
|
|
size_t read;
|
|
do {
|
|
read = strm->Read(buffer,sizeof(buffer));
|
|
if(!Update(buffer,read)) return false;
|
|
} while(read != 0);
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool Sha512::Update(Tesses::Framework::Streams::Stream& strm)
|
|
{
|
|
return Update(&strm);
|
|
}
|
|
std::vector<uint8_t> Sha512::Finish()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha512_context*>(this->inner);
|
|
std::vector<uint8_t> hash;
|
|
hash.resize(64);
|
|
mbedtls_sha512_finish(ctx,hash.data());
|
|
return hash;
|
|
#endif
|
|
return {};
|
|
}
|
|
Sha512::~Sha512()
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
auto ctx = static_cast<mbedtls_sha512_context*>(this->inner);
|
|
mbedtls_sha512_free(ctx);
|
|
delete ctx;
|
|
#endif
|
|
}
|
|
|
|
std::vector<uint8_t> Sha512::ComputeHash(const uint8_t* buffer, size_t len,bool is384)
|
|
{
|
|
Sha512 sha512;
|
|
if(!sha512.Start(is384)) return {};
|
|
if(!sha512.Update(buffer,len)) return {};
|
|
return sha512.Finish();
|
|
}
|
|
std::vector<uint8_t> Sha512::ComputeHash(Tesses::Framework::Streams::Stream* strm,bool is384)
|
|
{
|
|
Sha512 sha512;
|
|
if(!sha512.Start(is384)) return {};
|
|
if(!sha512.Update(strm)) return {};
|
|
return sha512.Finish();
|
|
}
|
|
std::vector<uint8_t> Sha512::ComputeHash(Tesses::Framework::Streams::Stream& strm,bool is384)
|
|
{
|
|
Sha512 sha512;
|
|
if(!sha512.Start(is384)) return {};
|
|
if(!sha512.Update(strm)) return {};
|
|
return sha512.Finish();
|
|
}
|
|
|
|
|
|
bool PBKDF2(std::vector<uint8_t>& output,std::string pass, std::vector<uint8_t>& salt, long itterations, ShaVersion version)
|
|
{
|
|
#if defined(TESSESFRAMEWORK_ENABLE_MBED)
|
|
|
|
mbedtls_md_context_t ctx;
|
|
mbedtls_md_init(&ctx);
|
|
const mbedtls_md_info_t* info = NULL;
|
|
switch(version)
|
|
{
|
|
case ShaVersion::VERSION_SHA1:
|
|
info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
|
|
break;
|
|
case ShaVersion::VERSION_SHA224:
|
|
info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA224);
|
|
break;
|
|
case ShaVersion::VERSION_SHA256:
|
|
info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
|
|
break;
|
|
default:
|
|
case ShaVersion::VERSION_SHA384:
|
|
info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA384);
|
|
break;
|
|
case ShaVersion::VERSION_SHA512:
|
|
info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA512);
|
|
break;
|
|
}
|
|
|
|
|
|
mbedtls_md_setup(&ctx, info, 1);
|
|
|
|
|
|
|
|
if(mbedtls_pkcs5_pbkdf2_hmac(&ctx, (const unsigned char*)pass.c_str(), pass.size(), salt.data(), salt.size(), (int)itterations,(uint32_t)output.size(),output.data()) == 0)
|
|
{
|
|
mbedtls_md_free(&ctx);
|
|
return true;
|
|
}
|
|
mbedtls_md_free(&ctx);
|
|
return false;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
bool RandomBytes(std::vector<uint8_t>& output, std::string personal_str)
|
|
{
|
|
mbedtls_entropy_context entropy;
|
|
mbedtls_ctr_drbg_context ctr_drbg;
|
|
|
|
mbedtls_entropy_init(&entropy);
|
|
mbedtls_ctr_drbg_init(&ctr_drbg);
|
|
|
|
int ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *) personal_str.c_str(), personal_str.size());
|
|
if(ret != 0)
|
|
{
|
|
mbedtls_ctr_drbg_free(&ctr_drbg);
|
|
mbedtls_entropy_free(&entropy);
|
|
return false;
|
|
}
|
|
ret = mbedtls_ctr_drbg_random(&ctr_drbg, output.data(),output.size());
|
|
if (ret != 0)
|
|
{
|
|
mbedtls_ctr_drbg_free(&ctr_drbg);
|
|
mbedtls_entropy_free(&entropy);
|
|
return false;
|
|
}
|
|
mbedtls_ctr_drbg_free(&ctr_drbg);
|
|
mbedtls_entropy_free(&entropy);
|
|
return true;
|
|
}
|
|
}
|