mirror of
https://github.com/OpenCoin/oc-mint-cpp.git
synced 2024-12-22 23:59:41 +01:00
Compare commits
1 Commits
d0794efb1e
...
f77eb2f98e
Author | SHA1 | Date | |
---|---|---|---|
|
f77eb2f98e |
@ -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)
|
||||
|
@ -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 | ? |
|
||||
|
104
src/big_int.cpp
104
src/big_int.cpp
@ -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) {
|
||||
continue;
|
||||
} else if (b>0xfU) {
|
||||
s.push_back(hex_char[b >> 4]);
|
||||
} else {
|
||||
/* nothing to do here */
|
||||
if (first_digit==0) {
|
||||
if (b==0) {
|
||||
continue;
|
||||
} else if (b>0xf) {
|
||||
s.push_back(hex_char[b >> 4]);
|
||||
}
|
||||
s.push_back(hex_char[b & 0xf]);
|
||||
first_digit = b;
|
||||
|
@ -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
|
||||
|
@ -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());
|
||||
|
23
src/main.cpp
23
src/main.cpp
@ -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);
|
||||
@ -70,9 +70,8 @@ int main() {
|
||||
ResponseMint res;
|
||||
res.message_reference = req->message_reference;
|
||||
|
||||
/// \todo change argument transaction_reference to bigint
|
||||
auto minted =
|
||||
model->mint(req->transaction_reference.to_string(), req->blinds);
|
||||
/// \todo change argument transaction_reference to bigint
|
||||
auto minted = model->mint(req->transaction_reference.to_string(), req->blinds);
|
||||
|
||||
res.blind_signatures = minted;
|
||||
res.status_code = crow::status::OK;
|
||||
|
@ -4,53 +4,53 @@
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
#define UNUSED(s) /* s */
|
||||
|
||||
/** this is for now our sample model */
|
||||
class DefaultModel : public Model {
|
||||
public:
|
||||
DefaultModel() = default;
|
||||
DefaultModel() {}
|
||||
tl::expected<CDDC *, bool> getCDDC(unsigned int cdd_serial) override {
|
||||
cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl;
|
||||
return &m_cddc;
|
||||
};
|
||||
|
||||
tl::expected<CDDC *, bool> get_cddc(unsigned int cdd_serial) override {
|
||||
cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl; // NOLINT(clion-misra-cpp2008-5-2-12)
|
||||
return &m_cddc;
|
||||
};
|
||||
tl::expected<CDDC *, bool> getCurrentCDDC() override {
|
||||
cout << __FUNCTION__ << "()" << endl;
|
||||
|
||||
tl::expected<CDDC *, bool> get_current_cddc() override {
|
||||
cout << __FUNCTION__ << "()" << endl;
|
||||
return &m_cddc;
|
||||
}
|
||||
|
||||
return &m_cddc;
|
||||
}
|
||||
std::vector<BlindSignature>
|
||||
mint(const std::string& UNUSED(transaction_reference),
|
||||
const std::vector<Blind> &UNUSED(blinds) ) override
|
||||
{
|
||||
std::vector<BlindSignature> res;
|
||||
cout << __FUNCTION__ << "("
|
||||
<< ")" << endl;
|
||||
|
||||
std::vector<BlindSignature>
|
||||
mint(const std::string & UNUSED(transaction_reference),
|
||||
const std::vector<Blind> &UNUSED(blinds)) override {
|
||||
std::vector<BlindSignature> res;
|
||||
cout << __FUNCTION__ << "("
|
||||
<< ")" << endl;
|
||||
return res;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
const std::vector<MintKeyCert>
|
||||
getMKCs(const std::vector<unsigned int> & UNUSED(denominations),
|
||||
const std::vector<BigInt> & UNUSED(mint_key_ids) ) override
|
||||
{
|
||||
std::vector<MintKeyCert> res;
|
||||
cout << __FUNCTION__ << endl;
|
||||
return res;
|
||||
}
|
||||
|
||||
std::vector<MintKeyCert>
|
||||
getMKCs(const std::vector<unsigned int> & UNUSED(denominations),
|
||||
const std::vector<BigInt> & UNUSED(mint_key_ids)) override {
|
||||
std::vector<MintKeyCert> res;
|
||||
cout << __FUNCTION__ << endl;
|
||||
return res;
|
||||
}
|
||||
|
||||
bool redeem(const std::vector<Coin> &UNUSED(coins)) override {
|
||||
cout << __FUNCTION__ << endl;
|
||||
return false;
|
||||
}
|
||||
bool redeem(const std::vector<Coin> &UNUSED(coins)) override {
|
||||
cout << __FUNCTION__ << endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
CDDC m_cddc;
|
||||
CDDC m_cddc;
|
||||
};
|
||||
|
||||
std::unique_ptr<Model> Model::get_model(const std::string & /*backend_name*/) {
|
||||
cout << __FUNCTION__ << endl;
|
||||
//:wq
|
||||
// if (backend_name=="default")
|
||||
return std::make_unique<DefaultModel>();
|
||||
std::unique_ptr<Model> Model::getModel(const std::string & /*backend_name*/) {
|
||||
cout << __FUNCTION__ << endl;
|
||||
//:wq
|
||||
// if (backend_name=="default")
|
||||
return std::make_unique<DefaultModel>();
|
||||
}
|
||||
|
@ -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
|
||||
|
@ -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]") {
|
@ -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..";
|
||||
|
@ -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;
|
||||
}
|
Loading…
Reference in New Issue
Block a user