added test_crypto.cpp with first code for rsa blinding

CMakeLists.txt

@@ -16,6 +16,8 @@ endif()
 
 project(oc-issuer VERSION 0.0.2 LANGUAGES CXX)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 include(FetchContent)
 
 #
@@ -96,7 +98,10 @@ 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.cpp)
+add_executable(tests test/test_big_int.cpp
+                     test/test_json_s8n.cpp
+                     test/test_crypto.cpp)
+                     
 target_link_libraries(tests
                       oc-mint-lib
 		      Catch2::Catch2WithMain)

README.md

@@ -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::getCurrentCDDC() |
-| RequestCDDC       | /cddc        | ResponseCDDC                  | Model::getCurrentCDDC()                            |
+| RequestCDDCSerial | /cddc/serial | ResponseCDDCSerial            | cdd.cdd_serial of Model::get_current_cddc() |
+| RequestCDDC       | /cddc        | ResponseCDDC                  | Model::get_current_cddc()                            |
 | RequestMKCs       | /mkcs        | ResponseMKCs                  | Model::getMKCs                                     |
 | RequestMint       | /mint        | ResponseMint                  | Model::mint                                        |
 | RequestRenew      | /renew       | ResponseMint or ResponseDelay | ?                                                  |

src/big_int.cpp

@@ -1,82 +1,76 @@
 #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 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;
+    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;
     default:
-      return 0xff;
+      return 0xffU;
   }
 }
+#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=0;
+  uint8_t hval=0U;
   uint8_t nibble;
-  size_t i = str.size()+1;
+  size_t i = str.size()+1U;
 
   for(auto c : str) {
     nibble = hex(c);
-    if (nibble ==0xFF) {
+    if (nibble ==0xFFU) {
       return tl::make_unexpected(eError::PARSE_ERROR);
     }
-    if (i%2) {
-      hval = nibble << 4;
+    if ( i%2U != 0U ) {
+      hval = nibble << 4U;
     } else {
       hval |= nibble;
-      b.data[256 - (i/2)]= hval;
-      hval = 0;
+      b.data[256U - (i/2U)]= hval;
+      hval = 0U;
     }
     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[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);
+  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);
   return b;
 }
 
@@ -85,14 +79,16 @@ std::string BigInt::to_string() const
 {
   std::string s;
   uint8_t b;
-  uint8_t first_digit = 0;
-  for (size_t i = 0; i<256;i++) {
+  uint8_t first_digit = 0U;
+  for (size_t i = 0U; i<256U;i++) {
     b = data[i];
-    if (first_digit==0) {
-      if (b==0) {
-	continue;
-      } else if (b>0xf) {
-	s.push_back(hex_char[b >> 4]);
+    if (first_digit==0U) {
+      if (b==0U) {
+	      continue;
+      } else if (b>0xfU) {
+	      s.push_back(hex_char[b >> 4]);
+      } else {
+        /* nothing to do here */
       }
       s.push_back(hex_char[b & 0xf]);
       first_digit = b;

src/big_int.hpp

@@ -1,5 +1,5 @@
-#ifndef BIG_INT_HPP
-#define BIG_INT_HPP
+#ifndef OC_ISSUER_BIG_INT_HPP
+#define OC_ISSUER_BIG_INT_HPP
 
 #include <string>
 #include <array>
@@ -9,19 +9,19 @@
 struct BigInt {
 
   BigInt() : data() {}
-  virtual ~BigInt() {}
+  virtual ~BigInt() = default;
 
   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);
-  std::string to_string() const;
+  [[nodiscard]] std::string to_string() const;
 
   friend bool operator == (const BigInt& rhs, const BigInt& lhs);
 private:
-  std::array<uint8_t,256> data;
+  std::array<uint8_t,256U> data;
 };
 
 bool operator==(const BigInt &rhs, const BigInt &lhs);
 
-#endif // #ifndef #ifndef BIG_INT_HPP
+#endif // #ifndef #ifndef OC_ISSUER_BIG_INT_HPP

src/json_serialisation.cpp

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

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::getModel("simple");
+  std::shared_ptr<Model> model = Model::get_model("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->getCDDC(req_cddc->cdd_serial);
+          auto cddc = model->get_cddc(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->getCurrentCDDC();
+          auto cddc = model->get_current_cddc();
           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,8 +70,9 @@ 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;

src/model.cpp

@@ -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() {}
-  tl::expected<CDDC *, bool> getCDDC(unsigned int cdd_serial) override {
-    cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl;
-    return &m_cddc;
-  };
+    DefaultModel() = default;
 
-  tl::expected<CDDC *, bool> getCurrentCDDC() override {
-    cout << __FUNCTION__ << "()" << endl;
+    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;
+    };
 
-    return &m_cddc;
-  }
+    tl::expected<CDDC *, bool> get_current_cddc() override {
+        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 &m_cddc;
+    }
 
-    return res;
-  }
+    std::vector<BlindSignature>
+    mint(const std::string & UNUSED(transaction_reference),
+         const std::vector<Blind> &UNUSED(blinds)) override {
+        std::vector<BlindSignature> res;
+        cout << __FUNCTION__ << "("
+             << ")" << endl;
 
-  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;
-  }
+        return res;
+    }
 
-  bool redeem(const std::vector<Coin> &UNUSED(coins)) override {
-    cout << __FUNCTION__ << endl;
-    return false;
-  }
+    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;
+    }
 
 private:
-  CDDC m_cddc;
+    CDDC m_cddc;
 };
 
-std::unique_ptr<Model> Model::getModel(const std::string & /*backend_name*/) {
-  cout << __FUNCTION__ << endl;
-  //:wq
-  // if (backend_name=="default")
-  return std::make_unique<DefaultModel>();
+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>();
 }

src/model.hpp

@@ -1,5 +1,5 @@
-#ifndef MODEL_HPP
-#define MODEL_HPP
+#ifndef OC_ISSUER_MODEL_HPP
+#define OC_ISSUER_MODEL_HPP
 
 #include <chrono>
 #include <memory>
@@ -15,14 +15,14 @@ struct PublicKey {
   BigInt modulus; //: "daaa63ddda38c189b8c49020c8276adbe0a695685a...",
   BigInt public_exponent;//: 65537,
 
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] crow::json::wvalue to_json() const;
 };
 
 struct WeightedUrl {
   uint32_t weight;
   std::string url;
 
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] 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;
 
-  crow::json::wvalue to_json() const;
+  [[nodiscard]] crow::json::wvalue to_json() const;
 };
 
 struct CDDC {
   CDD cdd;
   std::string signature;
 
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] 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"
-  crow::json::wvalue to_json() const;
+  [[nodiscard]] crow::json::wvalue to_json() const;
 };
 
 struct MintKeyCert {
   MintKey mint_key;
   std::string signature;
 
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] crow::json::wvalue to_json() const;
 };
 
 enum class eError {
@@ -103,7 +103,7 @@ struct Response {
   unsigned int status_code;
   std::string status_description;
 
-  virtual crow::json::wvalue to_json() const;
+    [[nodiscard]] virtual crow::json::wvalue to_json() const=0;
 };
 
 struct RequestCDDCSerial {
@@ -114,9 +114,9 @@ struct RequestCDDCSerial {
 };
 
 struct ResponseCDDCSerial : Response {
-  unsigned int cdd_serial;
+  unsigned int cdd_serial{0U};
 
-  crow::json::wvalue to_json() const override;
+    [[nodiscard]] crow::json::wvalue to_json() const override;
 };
 
 struct RequestCDDC {
@@ -129,7 +129,7 @@ struct RequestCDDC {
 struct ResponseCDDC : Response {
   CDDC cddc;
 
-  crow::json::wvalue to_json() const override;
+    [[nodiscard]] crow::json::wvalue to_json() const override;
 };
 
 struct RequestMKCs {
@@ -144,21 +144,21 @@ struct RequestMKCs {
 struct ResponseMKCs : Response {
   std::vector<MintKeyCert> keys;
 
-  crow::json::wvalue to_json() const override;
+    [[nodiscard]] crow::json::wvalue to_json() const override;
 };
 
 struct Blind {
   BigInt blinded_payload_hash; //bigint
   BigInt mint_key_id; //bigint
   std::string reference;
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] 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;
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] crow::json::wvalue to_json() const;
 };
 
 struct RequestMint {
@@ -173,7 +173,7 @@ struct RequestMint {
 struct ResponseMint : Response {
   std::vector<BlindSignature> blind_signatures;
 
-  crow::json::wvalue to_json() const override;
+    [[nodiscard]] crow::json::wvalue to_json() const override;
 };
 
 struct Coin {
@@ -184,15 +184,15 @@ struct Coin {
     BigInt mint_key_id;
     std::string protocol_version;
     BigInt serial;
-    
-    crow::json::wvalue to_json() const;  
+
+      [[nodiscard]] crow::json::wvalue to_json() const;
     static tl::expected<Payload,eError> from_json(const crow::json::rvalue& json);
   };
 
   Payload payload;
   std::string signature;
 
-  crow::json::wvalue to_json() const;
+    [[nodiscard]] 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"
-  crow::json::wvalue to_json() const;
+  [[nodiscard]]  crow::json::wvalue to_json() const;
 };
 
 struct RequestRenew {
@@ -214,7 +214,7 @@ struct RequestRenew {
 };
 
 struct ResponseDelay : Response {
-  crow::json::wvalue to_json() const override;
+    [[nodiscard]] crow::json::wvalue to_json() const override;
 };
 
 struct RequestResume {
@@ -236,12 +236,12 @@ struct RequestRedeem {
 };
 
 struct ResponseRedeem : Response {
-  crow::json::wvalue to_json() const override;
+    [[nodiscard]] crow::json::wvalue to_json() const override;
 };
 
 class Model {
 public:
-  virtual ~Model(){};
+  virtual ~Model()=default;
 
   /** 
    * 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> getCDDC(unsigned int cdd_serial) = 0;
+  virtual tl::expected<CDDC *, bool> get_cddc(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> getCurrentCDDC() = 0;
+   */virtual tl::expected<CDDC *, bool> get_current_cddc() = 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 const std::vector<MintKeyCert>
+  virtual 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> getModel(const std::string &backend_name);
+  static std::unique_ptr<Model> get_model(const std::string &backend_name);
 
 private:
 };
 
-#endif // #ifndef MODEL_HPP
+#endif // #ifndef OC_ISSUER_MODEL_HPP

test/test_big_int.cpp

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

test/test_crypto.cpp

@@ -0,0 +1,163 @@
+
+#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;
+}

test/test_json_s8n.cpp

@@ -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() == 3 );
+  REQUIRE( json.keys().size() == 3U );
 }
 
 TEST_CASE("RequestCDDCSerial::from_string", "[from_string]") {