included crypto++ lib

CMakeLists.txt

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

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 '0': return 0; 
-    case '1': return 1U;
+    case '1': return 1;
-    case '2': return 2U;
+    case '2': return 2;
-    case '3': return 3U;
+    case '3': return 3;
-    case '4': return 4U;
+    case '4': return 4;
-    case '5': return 5U;
+    case '5': return 5;
-    case '6': return 6U;
+    case '6': return 6;
-    case '7': return 7U;
+    case '7': return 7;
-    case '8': return 8U;
+    case '8': return 8;
-    case '9': return 9U;
+    case '9': return 9;
-    case 'a': return 10U;
+    case 'a': return 10;
-    case 'b': return 11U;
+    case 'b': return 11;
-    case 'c': return 12U;
+    case 'c': return 12;
-    case 'd': return 13U;
+    case 'd': return 13;
-    case 'e': return 14U;
+    case 'e': return 14;
-    case 'f': return 15U;
+    case 'f': return 15;
-    case 'A': return 10U;
+    case 'A': return 10;
-    case 'B': return 11U;
+    case 'B': return 11;
-    case 'C': return 12U;
+    case 'C': return 12;
-    case 'D': return 13U;
+    case 'D': return 13;
-    case 'E': return 14U;
+    case 'E': return 14;
-    case 'F': return 15U;
+    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 ) {
+    if (i%2) {
-      hval = nibble << 4U;
+      hval = nibble << 4;
     } else {
       hval |= nibble;
-      b.data[256U - (i/2U)]= hval;
+      b.data[256 - (i/2)]= hval;
-      hval = 0U;
+      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[248]=(value >> 56 & 0xff);
-  b.data[249U]=static_cast<uint8_t>(value >> 48 & 0xffU);
+  b.data[249]=(value >> 48 & 0xff);
-  b.data[250U]=static_cast<uint8_t>(value >> 40U & 0xffU);
+  b.data[250]=(value >> 40 & 0xff);
-  b.data[251U]=static_cast<uint8_t>(value >> 32U & 0xffU);
+  b.data[251]=(value >> 32 & 0xff);
-  b.data[252U]=static_cast<uint8_t>(value >> 24U & 0xffU);
+  b.data[252]=(value >> 24 & 0xff);
-  b.data[253U]=static_cast<uint8_t>(value >> 16U & 0xffU);
+  b.data[253]=(value >> 16 & 0xff);
-  b.data[254U]=static_cast<uint8_t>(value >> 8U & 0xffU);
+  b.data[254]=(value >> 8 & 0xff);
-  b.data[255U]=static_cast<uint8_t>(value & 0xffU);
+  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;
+  uint8_t first_digit = 0;
-  for (size_t i = 0U; i<256U;i++) {
+  for (size_t i = 0; i<256;i++) {
     b = data[i];
-    if (first_digit==0U) {
+    if (first_digit==0) {
-      if (b==0U) {
+      if (b==0) {
-	      continue;
+	continue;
-      } else if (b>0xfU) {
+      } else if (b>0xf) {
-	      s.push_back(hex_char[b >> 4]);
+	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 OC_ISSUER_BIG_INT_HPP
+#ifndef BIG_INT_HPP
-#define OC_ISSUER_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

src/json_serialisation.cpp

@@ -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 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) {
+  for (auto item : array)
-    l.emplace_back(item);
+    l.push_back(item);
-  }
+  return crow::json::wvalue(l);
-    return {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());

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)
+      .methods(crow::HTTPMethod::POST)([&model](const crow::request &req) {
-    ([&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)
+  CROW_ROUTE(app, "/mkcs")
-    ([&model](const crow::request &request) {
+      .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)
+  CROW_ROUTE(app, "/mint")
-    ([&model](const crow::request &request) {
+      .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
+	  /// \todo change argument transaction_reference to bigint
-          auto minted =
+          auto minted = model->mint(req->transaction_reference.to_string(), req->blinds);
-              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() = 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 {
+  tl::expected<CDDC *, bool> getCurrentCDDC() override {
-        cout << __FUNCTION__ << "(" << cdd_serial << ")" << endl; // NOLINT(clion-misra-cpp2008-5-2-12)
+    cout << __FUNCTION__ << "()" << endl;
-        return &m_cddc;
-    };
 
-    tl::expected<CDDC *, bool> get_current_cddc() override {
+    return &m_cddc;
-        cout << __FUNCTION__ << "()" << endl;
+  }
 
-        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>
+    return res;
-    mint(const std::string & UNUSED(transaction_reference),
+  }
-         const std::vector<Blind> &UNUSED(blinds)) override {
-        std::vector<BlindSignature> res;
-        cout << __FUNCTION__ << "("
-             << ")" << endl;
 
-        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>
+  bool redeem(const std::vector<Coin> &UNUSED(coins)) override {
-    getMKCs(const std::vector<unsigned int> & UNUSED(denominations),
+    cout << __FUNCTION__ << endl;
-            const std::vector<BigInt> & UNUSED(mint_key_ids)) override {
+    return false;
-        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::get_model(const std::string & /*backend_name*/) {
+std::unique_ptr<Model> Model::getModel(const std::string & /*backend_name*/) {
-    cout << __FUNCTION__ << endl;
+  cout << __FUNCTION__ << endl;
-    //:wq
+  //:wq
-    // if (backend_name=="default")
+  // if (backend_name=="default")
-    return std::make_unique<DefaultModel>();
+  return std::make_unique<DefaultModel>();
 }

src/model.hpp

@@ -1,5 +1,5 @@
-#ifndef OC_ISSUER_MODEL_HPP
+#ifndef MODEL_HPP
-#define OC_ISSUER_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 {
@@ -184,15 +184,15 @@ struct Coin {
     BigInt mint_key_id;
     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

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

test/test_big_int.cpp

@@ -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) {
+  for (size_t i= 0; i<sizeof(VALID)/sizeof(VALID[0]);i++) {
-    auto b = BigInt::from_string(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..";

test/test_crypto.cpp

@@ -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;
-}