Compare commits

..

1 Commits

Author SHA1 Message Date
Gulliver
f77eb2f98e included crypto++ lib 2023-01-30 22:10:07 +01:00
11 changed files with 155 additions and 322 deletions

View File

@ -16,8 +16,6 @@ endif()
project(oc-issuer VERSION 0.0.2 LANGUAGES CXX)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
include(FetchContent)
#
@ -98,10 +96,7 @@ add_executable(${PROJECT_NAME} src/main.cpp)
target_link_libraries(${PROJECT_NAME} PRIVATE oc-mint-lib INTERFACE tl::expected::expected)
## these are unittests that can be run on any platform
add_executable(tests test/test_big_int.cpp
test/test_json_s8n.cpp
test/test_crypto.cpp)
add_executable(tests test/test_big_int.cpp test/test.cpp)
target_link_libraries(tests
oc-mint-lib
Catch2::Catch2WithMain)

View File

@ -18,8 +18,8 @@ The following table gives an overview of the mapping of requests to URLs:
| Request | URL | Response | C++ Interface Method |
|:------------------|:-------------|:------------------------------|:---------------------------------------------------|
| RequestCDDCSerial | /cddc/serial | ResponseCDDCSerial | cdd.cdd_serial of Model::get_current_cddc() |
| RequestCDDC | /cddc | ResponseCDDC | Model::get_current_cddc() |
| RequestCDDCSerial | /cddc/serial | ResponseCDDCSerial | cdd.cdd_serial of Model::getCurrentCDDC() |
| RequestCDDC | /cddc | ResponseCDDC | Model::getCurrentCDDC() |
| RequestMKCs | /mkcs | ResponseMKCs | Model::getMKCs |
| RequestMint | /mint | ResponseMint | Model::mint |
| RequestRenew | /renew | ResponseMint or ResponseDelay | ? |

View File

@ -1,76 +1,82 @@
#include "big_int.hpp"
#include "tl/expected.hpp"
#include <iostream>
#include <charconv>
#include <vector>
#pragma clang diagnostic push
#pragma ide diagnostic ignored "clion-misra-cpp2008-6-4-5"
inline uint8_t hex(char c) {
switch(c) {
case '0': return 0U;
case '1': return 1U;
case '2': return 2U;
case '3': return 3U;
case '4': return 4U;
case '5': return 5U;
case '6': return 6U;
case '7': return 7U;
case '8': return 8U;
case '9': return 9U;
case 'a': return 10U;
case 'b': return 11U;
case 'c': return 12U;
case 'd': return 13U;
case 'e': return 14U;
case 'f': return 15U;
case 'A': return 10U;
case 'B': return 11U;
case 'C': return 12U;
case 'D': return 13U;
case 'E': return 14U;
case 'F': return 15U;
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': return 10;
case 'b': return 11;
case 'c': return 12;
case 'd': return 13;
case 'e': return 14;
case 'f': return 15;
case 'A': return 10;
case 'B': return 11;
case 'C': return 12;
case 'D': return 13;
case 'E': return 14;
case 'F': return 15;
default:
return 0xffU;
return 0xff;
}
}
#pragma clang diagnostic pop
tl::expected<BigInt,BigInt::eError>
BigInt::from_string(const std::string& str) {
BigInt b;
// std::cout << str << std::endl;
uint8_t hval=0U;
uint8_t hval=0;
uint8_t nibble;
size_t i = str.size()+1U;
size_t i = str.size()+1;
for(auto c : str) {
nibble = hex(c);
if (nibble ==0xFFU) {
if (nibble ==0xFF) {
return tl::make_unexpected(eError::PARSE_ERROR);
}
if ( i%2U != 0U ) {
hval = nibble << 4U;
if (i%2) {
hval = nibble << 4;
} else {
hval |= nibble;
b.data[256U - (i/2U)]= hval;
hval = 0U;
b.data[256 - (i/2)]= hval;
hval = 0;
}
i--;
}
// std::cout << std::hex;
// for (auto b: b.data)
// {
// std::cout << (int)b;
// }
// std::cout << std::dec << std::endl;
return b;
}
BigInt BigInt::from_int(uint64_t value)
{
BigInt b;
b.data[248U]=static_cast<uint8_t>(value >> 56 & 0xffU);
b.data[249U]=static_cast<uint8_t>(value >> 48 & 0xffU);
b.data[250U]=static_cast<uint8_t>(value >> 40U & 0xffU);
b.data[251U]=static_cast<uint8_t>(value >> 32U & 0xffU);
b.data[252U]=static_cast<uint8_t>(value >> 24U & 0xffU);
b.data[253U]=static_cast<uint8_t>(value >> 16U & 0xffU);
b.data[254U]=static_cast<uint8_t>(value >> 8U & 0xffU);
b.data[255U]=static_cast<uint8_t>(value & 0xffU);
b.data[248]=(value >> 56 & 0xff);
b.data[249]=(value >> 48 & 0xff);
b.data[250]=(value >> 40 & 0xff);
b.data[251]=(value >> 32 & 0xff);
b.data[252]=(value >> 24 & 0xff);
b.data[253]=(value >> 16 & 0xff);
b.data[254]=(value >> 8 & 0xff);
b.data[255]=(value & 0xff);
return b;
}
@ -79,16 +85,14 @@ std::string BigInt::to_string() const
{
std::string s;
uint8_t b;
uint8_t first_digit = 0U;
for (size_t i = 0U; i<256U;i++) {
uint8_t first_digit = 0;
for (size_t i = 0; i<256;i++) {
b = data[i];
if (first_digit==0U) {
if (b==0U) {
if (first_digit==0) {
if (b==0) {
continue;
} else if (b>0xfU) {
} else if (b>0xf) {
s.push_back(hex_char[b >> 4]);
} else {
/* nothing to do here */
}
s.push_back(hex_char[b & 0xf]);
first_digit = b;

View File

@ -1,5 +1,5 @@
#ifndef OC_ISSUER_BIG_INT_HPP
#define OC_ISSUER_BIG_INT_HPP
#ifndef BIG_INT_HPP
#define BIG_INT_HPP
#include <string>
#include <array>
@ -9,19 +9,19 @@
struct BigInt {
BigInt() : data() {}
virtual ~BigInt() = default;
virtual ~BigInt() {}
enum class eError : uint8_t { PARSE_ERROR };
static tl::expected<BigInt, eError> from_string(const std::string &str);
static BigInt from_int(uint64_t value);
[[nodiscard]] std::string to_string() const;
std::string to_string() const;
friend bool operator == (const BigInt& rhs, const BigInt& lhs);
private:
std::array<uint8_t,256U> data;
std::array<uint8_t,256> data;
};
bool operator==(const BigInt &rhs, const BigInt &lhs);
#endif // #ifndef #ifndef OC_ISSUER_BIG_INT_HPP
#endif // #ifndef #ifndef BIG_INT_HPP

View File

@ -10,18 +10,16 @@
template <class T>
crow::json::wvalue list_to_json(const std::vector<T> &array) {
crow::json::wvalue::list l;
for (const auto& item : array) {
for (auto item : array)
l.push_back(item.to_json());
}
return {l};
return crow::json::wvalue(l);
}
crow::json::wvalue list_to_json(const std::vector<unsigned int> &array) {
crow::json::wvalue::list l;
for (auto item : array) {
l.emplace_back(item);
}
return {l};
for (auto item : array)
l.push_back(item);
return crow::json::wvalue(l);
}
crow::json::wvalue PublicKey::to_json() const {
@ -37,7 +35,7 @@ crow::json::wvalue WeightedUrl::to_json() const {
crow::json::wvalue w(weight);
l.push_back(w);
l.emplace_back(url);
l.push_back(url);
return l;
}
@ -173,7 +171,7 @@ RequestMKCs::from_string(const std::string &str) {
if (denominations.t() != crow::json::type::List) {
return tl::make_unexpected(eError::JSON_WRONG_REQUEST_TYPE);
} else {
for (const auto& d : denominations.lo()) {
for (auto d : denominations.lo()) {
r.denominations.push_back(d.u());
}
}
@ -181,7 +179,7 @@ RequestMKCs::from_string(const std::string &str) {
if (mint_key_ids.t() != crow::json::type::List) {
return tl::make_unexpected(eError::JSON_WRONG_REQUEST_TYPE);
} else {
for (const auto& k: mint_key_ids.lo()) {
for (auto k: mint_key_ids.lo()) {
auto kv = BigInt::from_string(k.s());
if (!kv.has_value()) {
return tl::make_unexpected(eError::JSON_PARSE_ERROR);
@ -271,7 +269,7 @@ RequestMint::from_string(const std::string &str) {
return tl::make_unexpected(eError::JSON_WRONG_VALUE_TYPE);
}
for (const auto& item : json["blinds"]) {
for (auto item : json["blinds"]) {
auto b = Blind::from_json(item);
if (!b.has_value()) {
return tl::make_unexpected(b.error());
@ -386,7 +384,7 @@ RequestRenew::from_string(const std::string &str) {
} else {
RequestRenew r;
for (const auto& item : json["coins"]) {
for (auto item : json["coins"]) {
auto coin = Coin::from_json(item);
if (!coin.has_value()) {
return tl::make_unexpected(coin.error());
@ -395,7 +393,7 @@ RequestRenew::from_string(const std::string &str) {
}
}
for (const auto& item : json["blinds"]) {
for (auto item : json["blinds"]) {
auto blind = Blind::from_json(item);
if (!blind.has_value()) {
return tl::make_unexpected(blind.error());
@ -455,7 +453,7 @@ RequestRedeem::from_string(const std::string &str) {
return tl::make_unexpected(eError::JSON_WRONG_VALUE_TYPE);
}
for (const auto& item : json["coins"]) {
for (auto item : json["coins"]) {
auto coin = Coin::from_json(item);
if (!coin.has_value()) {
return tl::make_unexpected(coin.error());

View File

@ -1,22 +1,22 @@
#include "crow.h"
#include "crow/common.h"
#include "crow/http_parser_merged.h"
#include "crow/http_response.h"
#include "model.hpp"
int main() {
crow::SimpleApp app;
std::shared_ptr<Model> model = Model::get_model("simple");
std::shared_ptr<Model> model = Model::getModel("simple");
CROW_ROUTE(app, "/cddc")
.methods(crow::HTTPMethod::POST)
([&model](const crow::request &req) {
.methods(crow::HTTPMethod::POST)([&model](const crow::request &req) {
auto req_cddc = RequestCDDC::from_string(req.body);
if (!req_cddc) {
return crow::response(crow::status::BAD_REQUEST);
} else {
ResponseCDDC res;
res.message_reference = req_cddc->message_reference;
auto cddc = model->get_cddc(req_cddc->cdd_serial);
auto cddc = model->getCDDC(req_cddc->cdd_serial);
if (!cddc) {
res.status_code = crow::status::NOT_FOUND;
} else {
@ -36,7 +36,7 @@ int main() {
ResponseCDDCSerial res;
res.message_reference = req->message_reference;
auto cddc = model->get_current_cddc();
auto cddc = model->getCurrentCDDC();
if (!cddc) {
res.status_code = crow::status::NOT_FOUND;
} else {
@ -47,8 +47,8 @@ int main() {
}
});
CROW_ROUTE(app, "/mkcs").methods(crow::HTTPMethod::POST)
([&model](const crow::request &request) {
CROW_ROUTE(app, "/mkcs")
.methods(crow::HTTPMethod::POST)([&model](const crow::request &request) {
auto req = RequestMKCs::from_string(request.body);
if (!req) {
return crow::response(crow::status::BAD_REQUEST);
@ -61,8 +61,8 @@ int main() {
}
});
CROW_ROUTE(app, "/mint").methods(crow::HTTPMethod::POST)
([&model](const crow::request &request) {
CROW_ROUTE(app, "/mint")
.methods(crow::HTTPMethod::POST)([&model](const crow::request &request) {
auto req = RequestMint::from_string(request.body);
if (!req) {
return crow::response(crow::status::BAD_REQUEST);
@ -71,8 +71,7 @@ int main() {
res.message_reference = req->message_reference;
/// \todo change argument transaction_reference to bigint
auto minted =
model->mint(req->transaction_reference.to_string(), req->blinds);
auto minted = model->mint(req->transaction_reference.to_string(), req->blinds);
res.blind_signatures = minted;
res.status_code = crow::status::OK;

View File

@ -4,26 +4,25 @@
using std::cout;
using std::endl;
#define UNUSED(s) /* s */
/** this is for now our sample model */
class DefaultModel : public Model {
public:
DefaultModel() = default;
tl::expected<CDDC *, bool> get_cddc(unsigned int cdd_serial) override {
cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl; // NOLINT(clion-misra-cpp2008-5-2-12)
DefaultModel() {}
tl::expected<CDDC *, bool> getCDDC(unsigned int cdd_serial) override {
cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl;
return &m_cddc;
};
tl::expected<CDDC *, bool> get_current_cddc() override {
tl::expected<CDDC *, bool> getCurrentCDDC() override {
cout << __FUNCTION__ << "()" << endl;
return &m_cddc;
}
std::vector<BlindSignature>
mint(const std::string & UNUSED(transaction_reference),
const std::vector<Blind> &UNUSED(blinds)) override {
mint(const std::string& UNUSED(transaction_reference),
const std::vector<Blind> &UNUSED(blinds) ) override
{
std::vector<BlindSignature> res;
cout << __FUNCTION__ << "("
<< ")" << endl;
@ -31,9 +30,10 @@ public:
return res;
}
std::vector<MintKeyCert>
const std::vector<MintKeyCert>
getMKCs(const std::vector<unsigned int> & UNUSED(denominations),
const std::vector<BigInt> & UNUSED(mint_key_ids)) override {
const std::vector<BigInt> & UNUSED(mint_key_ids) ) override
{
std::vector<MintKeyCert> res;
cout << __FUNCTION__ << endl;
return res;
@ -48,7 +48,7 @@ private:
CDDC m_cddc;
};
std::unique_ptr<Model> Model::get_model(const std::string & /*backend_name*/) {
std::unique_ptr<Model> Model::getModel(const std::string & /*backend_name*/) {
cout << __FUNCTION__ << endl;
//:wq
// if (backend_name=="default")

View File

@ -1,5 +1,5 @@
#ifndef OC_ISSUER_MODEL_HPP
#define OC_ISSUER_MODEL_HPP
#ifndef MODEL_HPP
#define MODEL_HPP
#include <chrono>
#include <memory>
@ -15,14 +15,14 @@ struct PublicKey {
BigInt modulus; //: "daaa63ddda38c189b8c49020c8276adbe0a695685a...",
BigInt public_exponent;//: 65537,
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
struct WeightedUrl {
uint32_t weight;
std::string url;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
/** @brief currency description document
@ -58,14 +58,14 @@ struct CDD {
std::vector<WeightedUrl> redeem_service;
std::vector<WeightedUrl> renew_service;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
struct CDDC {
CDD cdd;
std::string signature;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
struct MintKey {
@ -79,14 +79,14 @@ struct MintKey {
std::string sign_coins_not_after;
std::string sign_coins_not_before;
// "type": "mint key"
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
struct MintKeyCert {
MintKey mint_key;
std::string signature;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
enum class eError {
@ -103,7 +103,7 @@ struct Response {
unsigned int status_code;
std::string status_description;
[[nodiscard]] virtual crow::json::wvalue to_json() const=0;
virtual crow::json::wvalue to_json() const;
};
struct RequestCDDCSerial {
@ -114,9 +114,9 @@ struct RequestCDDCSerial {
};
struct ResponseCDDCSerial : Response {
unsigned int cdd_serial{0U};
unsigned int cdd_serial;
[[nodiscard]] crow::json::wvalue to_json() const override;
crow::json::wvalue to_json() const override;
};
struct RequestCDDC {
@ -129,7 +129,7 @@ struct RequestCDDC {
struct ResponseCDDC : Response {
CDDC cddc;
[[nodiscard]] crow::json::wvalue to_json() const override;
crow::json::wvalue to_json() const override;
};
struct RequestMKCs {
@ -144,21 +144,21 @@ struct RequestMKCs {
struct ResponseMKCs : Response {
std::vector<MintKeyCert> keys;
[[nodiscard]] crow::json::wvalue to_json() const override;
crow::json::wvalue to_json() const override;
};
struct Blind {
BigInt blinded_payload_hash; //bigint
BigInt mint_key_id; //bigint
std::string reference;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
static tl::expected<Blind, eError> from_json(const crow::json::rvalue &json);
};
struct BlindSignature {
BigInt blind_signature;
std::string reference;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
struct RequestMint {
@ -173,7 +173,7 @@ struct RequestMint {
struct ResponseMint : Response {
std::vector<BlindSignature> blind_signatures;
[[nodiscard]] crow::json::wvalue to_json() const override;
crow::json::wvalue to_json() const override;
};
struct Coin {
@ -185,14 +185,14 @@ struct Coin {
std::string protocol_version;
BigInt serial;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
static tl::expected<Payload,eError> from_json(const crow::json::rvalue& json);
};
Payload payload;
std::string signature;
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
static tl::expected<Coin, eError> from_json(const crow::json::rvalue &json);
};
@ -200,7 +200,7 @@ struct CoinStack {
std::vector<Coin> coins;
std::string subject;
// "type": "coinstack"
[[nodiscard]] crow::json::wvalue to_json() const;
crow::json::wvalue to_json() const;
};
struct RequestRenew {
@ -214,7 +214,7 @@ struct RequestRenew {
};
struct ResponseDelay : Response {
[[nodiscard]] crow::json::wvalue to_json() const override;
crow::json::wvalue to_json() const override;
};
struct RequestResume {
@ -236,12 +236,12 @@ struct RequestRedeem {
};
struct ResponseRedeem : Response {
[[nodiscard]] crow::json::wvalue to_json() const override;
crow::json::wvalue to_json() const override;
};
class Model {
public:
virtual ~Model()=default;
virtual ~Model(){};
/**
* return the CurrencyDocumentDescription certifikate for a specific
@ -249,13 +249,13 @@ public:
* [see spec](https://opencoin.org/0.4/schemata.html#cddc)
* @return returns a pointer to the CDDC if successful, false otherwise
*/
virtual tl::expected<CDDC *, bool> get_cddc(unsigned int cdd_serial) = 0;
virtual tl::expected<CDDC *, bool> getCDDC(unsigned int cdd_serial) = 0;
/**
* return the CurrencyDocumentDescription certifikate
* [see spec](https://opencoin.org/0.4/schemata.html#cddc)
* @return returns a pointer to the CDDC if successful, false otherwise
*/virtual tl::expected<CDDC *, bool> get_current_cddc() = 0;
*/virtual tl::expected<CDDC *, bool> getCurrentCDDC() = 0;
/**
* return the MintKey certificates for a given list of denominations
@ -266,7 +266,7 @@ public:
*
* @return mint key certificates for given denominations and mint_key_ids
*/
virtual std::vector<MintKeyCert>
virtual const std::vector<MintKeyCert>
getMKCs(const std::vector<unsigned int> &denominations,
const std::vector<BigInt> &mint_key_ids) = 0;
@ -300,9 +300,9 @@ public:
*
* @return pointer to backend instance or null on invalid backend name
*/
static std::unique_ptr<Model> get_model(const std::string &backend_name);
static std::unique_ptr<Model> getModel(const std::string &backend_name);
private:
};
#endif // #ifndef OC_ISSUER_MODEL_HPP
#endif // #ifndef MODEL_HPP

View File

@ -12,7 +12,7 @@ TEST_CASE( "PublicKey::to_json", "[to_json]" ) {
REQUIRE( json["modulus"].dump() == "\"" + k.modulus.to_string() + "\"" );
REQUIRE( json["public_exponent"].dump() == "\"" + k.public_exponent.to_string()+"\"" );
REQUIRE( json["type"].dump() == "\"rsa public key\"" );
REQUIRE( json.keys().size() == 3U );
REQUIRE( json.keys().size() == 3 );
}
TEST_CASE("RequestCDDCSerial::from_string", "[from_string]") {

View File

@ -2,7 +2,7 @@
#include <catch2/catch_test_macros.hpp>
TEST_CASE("BigInt::from_string", "[big_int]") {
const std::string VALID [] = {
std::string VALID [] = {
"1",
"12",
"123",
@ -17,10 +17,10 @@ TEST_CASE("BigInt::from_string", "[big_int]") {
"abcdef1"
};
for (const auto & i : VALID) {
auto b = BigInt::from_string(i);
for (size_t i= 0; i<sizeof(VALID)/sizeof(VALID[0]);i++) {
auto b = BigInt::from_string(VALID[i]);
REQUIRE(b->to_string() == VALID[i]);
REQUIRE(b.has_value());
REQUIRE(b->to_string() == i);
}
auto invalid_hex = "aabbcc..";

View File

@ -1,163 +0,0 @@
#include <catch2/catch_test_macros.hpp>
#include "cryptlib.h"
#include "integer.h"
#include "nbtheory.h"
#include "osrng.h"
#include "rsa.h"
#include "sha.h"
#include <iostream>
#include <stdexcept>
CryptoPP::Integer blind_signature(unsigned char *msg,
size_t msg_len,
const CryptoPP::RSA::PublicKey& pub_key,
const CryptoPP::RSA::PrivateKey& priv_key) {
using namespace CryptoPP;
using std::cout;
using std::endl;
AutoSeededRandomPool prng;
// Convenience
const Integer &n = pub_key.GetModulus();
const Integer &e = pub_key.GetPublicExponent();
const Integer &d = priv_key.GetPrivateExponent();
// For sizing the hashed message buffer. This should be SHA256 size.
const size_t sig_size = UnsignedMin(SHA256::BLOCKSIZE, n.ByteCount());
// Scratch
SecByteBlock buff_1, buff_2, buff_3;
SecByteBlock orig(msg, msg_len);
Integer m(orig.data(), orig.size());
cout << "Message: " << std::hex << m << endl;
// Hash message per Rabin (1979)
buff_1.resize(sig_size);
SHA256 hash_1;
hash_1.CalculateTruncatedDigest(buff_1, buff_1.size(), orig, orig.size());
// H(m) as Integer
Integer hm(buff_1.data(), buff_1.size());
cout << "H(m): " << std::hex << hm << endl;
// Alice blinding
Integer r;
do {
r.Randomize(prng, Integer::One(), n - Integer::One());
} while (!RelativelyPrime(r, n));
// Blinding factor
Integer b = a_exp_b_mod_c(r, e, n);
cout << "Random: " << std::hex << b << endl;
// Alice blinded message
Integer mm = a_times_b_mod_c(hm, b, n);
cout << "Blind msg: " << std::hex << mm << endl;
// Bob sign
Integer ss = priv_key.CalculateInverse(prng, mm);
cout << "Blind sign: " << ss << endl;
return ss;
}
TEST_CASE("cryptopp", "[crypto]") {
using namespace CryptoPP;
using std::cout;
using std::endl;
using std::runtime_error;
// Bob artificially small key pair
AutoSeededRandomPool prng;
RSA::PrivateKey priv_key;
priv_key.GenerateRandomWithKeySize(prng, 64U);
RSA::PublicKey pub_key(priv_key);
// Convenience
const Integer &n = pub_key.GetModulus();
const Integer &e = pub_key.GetPublicExponent();
const Integer &d = priv_key.GetPrivateExponent();
// Print params
cout << "Pub mod: " << std::hex << pub_key.GetModulus() << endl;
cout << "Pub exp: " << std::hex << e << endl;
cout << "Priv mod: " << std::hex << priv_key.GetModulus() << endl;
cout << "Priv exp: " << std::hex << d << endl;
// For sizing the hashed message buffer. This should be SHA256 size.
const size_t sig_size = UnsignedMin(SHA256::BLOCKSIZE, n.ByteCount());
// Scratch
SecByteBlock buff_1, buff_2, buff_3;
// Alice original message to be signed by Bob
SecByteBlock orig((const byte *)"secret", 6U);
Integer m(orig.data(), orig.size());
cout << "Message: " << std::hex << m << endl;
// Hash message per Rabin (1979)
buff_1.resize(sig_size);
SHA256 hash_1;
hash_1.CalculateTruncatedDigest(buff_1, buff_1.size(), orig, orig.size());
// H(m) as Integer
Integer hm(buff_1.data(), buff_1.size());
cout << "H(m): " << std::hex << hm << endl;
// Alice blinding
Integer r;
do {
r.Randomize(prng, Integer::One(), n - Integer::One());
} while (!RelativelyPrime(r, n));
// Blinding factor
Integer b = a_exp_b_mod_c(r, e, n);
cout << "Random: " << std::hex << b << endl;
// Alice blinded message
Integer mm = a_times_b_mod_c(hm, b, n);
cout << "Blind msg: " << std::hex << mm << endl;
// Bob sign
Integer ss = priv_key.CalculateInverse(prng, mm);
cout << "Blind sign: " << ss << endl;
// Alice checks s(s'(x)) = x. This is from Chaum's paper
Integer c = pub_key.ApplyFunction(ss);
cout << "Check sign: " << c << endl;
if (c != mm) {
throw runtime_error("Alice cross-check failed");
}
// Alice remove blinding
Integer s = a_times_b_mod_c(ss, r.InverseMod(n), n);
cout << "Unblind sign: " << s << endl;
// Eve verifies
Integer v = pub_key.ApplyFunction(s);
cout << "Verify: " << std::hex << v << endl;
// Convert to a string
size_t req = v.MinEncodedSize();
buff_2.resize(req);
v.Encode(&buff_2[0], buff_2.size());
// Hash message per Rabin (1979)
buff_3.resize(sig_size);
SHA256 hash_2;
hash_2.CalculateTruncatedDigest(buff_3, buff_3.size(), orig, orig.size());
// Constant time compare
bool equal = buff_2.size() == buff_3.size() &&
VerifyBufsEqual(buff_2.data(), buff_3.data(), buff_3.size());
if (!equal) {
throw runtime_error("Eve verified failed");
}
cout << "Verified signature" << endl;
}