Working on input formats.

Author: wolfmcnally

.vscode/launch.json

@@ -7,7 +7,7 @@
             "type": "lldb",
             "request": "launch",
             "program": "${workspaceFolder}/src/seedtool",
-            "args": [],
+            "args": ["--in", "slip39", "foobar"],
             "cwd": "${workspaceFolder}/src",
             "preLaunchTask": "Build"
         }

src/Makefile.in

@@ -56,21 +56,21 @@ $(toolname): $(OBJS)
 seedtool.o: params.hpp format.hpp
 utils.o: utils.hpp
 params.o: params.hpp utils.hpp random.hpp formats-all.hpp
-random.o: random.hpp randombytes.h hkdf.h
+random.o: random.hpp randombytes.h hkdf.h utils.hpp
 randombytes.o: randombytes.h
 hkdf.o: hkdf.h
 format.o: format.hpp utils.hpp
 formats-all.hpp: format-base6.hpp format-base10.hpp format-bip39.hpp format-bits.hpp format-cards.hpp format-dice.hpp format-hex.hpp format-ints.hpp format-random.hpp format-slip39.hpp
-format-base6.o: format-base6.hpp format.hpp params.hpp
-format-base10.o: format-base10.hpp format.hpp params.hpp
-format-bip39.o: format-bip39.hpp format.hpp params.hpp
-format-bits.o: format-bits.hpp format.hpp params.hpp
-format-cards.o: format-cards.hpp format.hpp params.hpp
-format-dice.o: format-dice.hpp format.hpp params.hpp
-format-hex.o: format-hex.hpp format.hpp params.hpp
-format-ints.o: format-ints.hpp format.hpp params.hpp
-format-random.o: format-random.hpp format.hpp params.hpp
-format-slip39.o: format-slip39.hpp format.hpp params.hpp
+format-base6.o: format-base6.hpp format.hpp params.hpp random.hpp
+format-base10.o: format-base10.hpp format.hpp params.hpp random.hpp
+format-bip39.o: format-bip39.hpp format.hpp params.hpp random.hpp
+format-bits.o: format-bits.hpp format.hpp params.hpp random.hpp
+format-cards.o: format-cards.hpp format.hpp params.hpp random.hpp
+format-dice.o: format-dice.hpp format.hpp params.hpp random.hpp
+format-hex.o: format-hex.hpp format.hpp params.hpp random.hpp
+format-ints.o: format-ints.hpp format.hpp params.hpp random.hpp
+format-random.o: format-random.hpp format.hpp params.hpp random.hpp
+format-slip39.o: format-slip39.hpp format.hpp params.hpp random.hpp
 
 bindir = $(DESTDIR)/$(prefix)/bin
 

src/format-base10.cpp

@@ -6,10 +6,17 @@
 //
 
 #include "format-base10.hpp"
+
+#include <stdexcept>
+
 #include "params.hpp"
 #include "utils.hpp"
+#include "random.hpp"
 
 void FormatBase10::process_input(Params* p) {
+    auto input = p->get_one_argument();
+    auto entropy = digits_to_data(input, 0, 9);
+    p->seed = deterministic_random(entropy, p->count);
 }
 
 void FormatBase10::process_output(Params* p) {

src/format-base6.cpp

@@ -6,10 +6,17 @@
 //
 
 #include "format-base6.hpp"
+
+#include <stdexcept>
+
 #include "params.hpp"
 #include "utils.hpp"
+#include "random.hpp"
 
 void FormatBase6::process_input(Params* p) {
+    auto input = p->get_one_argument();
+    auto entropy = digits_to_data(input, 0, 5);
+    p->seed = deterministic_random(entropy, p->count);
 }
 
 void FormatBase6::process_output(Params* p) {

src/format-bip39.cpp

@@ -9,17 +9,29 @@
 
 #include <strings.h>
 #include <bc-bip39/bc-bip39.h>
+#include <stdexcept>
 
 #include "params.hpp"
 #include "utils.hpp"
 
+using namespace std;
+
 bool FormatBIP39::is_seed_length_valid(size_t seed_len) {
     if(!(12 <= seed_len && seed_len <= 32)) { return false; }
     if(seed_len % 2 != 0) { return false; }
     return true;
 }
 
 void FormatBIP39::process_input(Params* p) {
+    auto input = p->get_combined_arguments();
+    vector<uint8_t> buf;
+    buf.resize(300);
+    auto len = bip39_secret_from_mnemonics(input.c_str(), &buf[0], buf.size());
+    if(len == 0) {
+        throw runtime_error("Invalid BIP39 word sequence.");
+    }
+    buf.resize(len);
+    p->seed = buf;
 }
 
 void FormatBIP39::process_output(Params* p) {

src/format-bits.cpp

@@ -6,10 +6,17 @@
 //
 
 #include "format-bits.hpp"
+
+#include <stdexcept>
+
 #include "params.hpp"
 #include "utils.hpp"
+#include "random.hpp"
 
 void FormatBits::process_input(Params* p) {
+    auto input = p->get_one_argument();
+    auto entropy = digits_to_data(input, 0, 1);
+    p->seed = deterministic_random(entropy, p->count);
 }
 
 void FormatBits::process_output(Params* p) {

src/format-cards.cpp

@@ -6,23 +6,79 @@
 //
 
 #include "format-cards.hpp"
+
+#include <stdexcept>
+#include <cctype>
+
 #include "params.hpp"
 #include "utils.hpp"
+#include "random.hpp"
+
+using namespace std;
+
+// https://en.wikipedia.org/wiki/High_card_by_suit
+static const vector<char> card_suits = { 'd', 'c', 'h', 's' };
+static const vector<char> card_ranks = { 'a', '2', '3', '4', '5', '6', '7', '8', '9', 't', 'j', 'q', 'k'};
+
+static size_t parse_rank(char c) {
+    c = tolower(c);
+    for(size_t i = 0; i < card_ranks.size(); i++) {
+        if(c == card_ranks[i]) {
+            return i;
+        }
+    }    
+    throw runtime_error("Invalid card rank. Allowed: [A,2-9,T,J,Q,K]");
+}
+
+static size_t parse_suit(char c) {
+    c = tolower(c);
+    for(size_t i = 0; i < card_suits.size(); i++) {
+        if(c == card_suits[i]) {
+            return i;
+        }
+    }    
+    throw runtime_error("Invalid card rank. Allowed: [D,C,H,S]");
+}
 
-static const std::string card_suits[] = { "c", "d", "h", "s" };
-static const std::string card_ranks[] = { "a", "2", "3", "4", "5", "6", "7", "8", "9", "t", "j", "q", "k"};
+vector<uint8_t> cards_to_data(const string& cards) {
+    vector<uint8_t> result;
 
-static std::string to_card(size_t n) {
+    auto len = cards.length();
+    if(len % 2 != 0) {
+        throw runtime_error("Cards string must have even number of characters.");
+    }
+    auto count = len / 2;
+    result.reserve(count);
+    for(auto i = 0; i < count; i++) {
+        auto rank = parse_rank(cards[i * 2]);
+        auto suit = parse_suit(cards[i * 2 + 1]);
+        auto n = suit * 13 + rank;
+        result.push_back(n);
+    }
+
+    return result;
+}
+
+void FormatCards::process_input(Params* p) {
+    auto input = p->get_one_argument();
+    auto entropy = cards_to_data(input);
+    p->seed = deterministic_random(entropy, p->count);
+}
+
+static string to_card(size_t n) {
     if(n > 51) { return NULL; }
-    std::string buf;
+    string buf;
     size_t rank = n % 13;
     size_t suit = n / 13;
-    buf.append(card_ranks[rank]);
-    buf.append(card_suits[suit]);
-    return buf;
-}
+    buf += card_ranks[rank];
+    buf += card_suits[suit];
 
-void FormatCards::process_input(Params* p) {
+    // test value round trip
+    auto v = cards_to_data(buf);
+    assert(v.size() == 1);
+    assert(v[0] == n);
+
+    return buf;
 }
 
 void FormatCards::process_output(Params* p) {

src/format-dice.cpp

@@ -8,8 +8,12 @@
 #include "format-dice.hpp"
 #include "params.hpp"
 #include "utils.hpp"
+#include "random.hpp"
 
 void FormatDice::process_input(Params* p) {
+    auto input = p->get_one_argument();
+    auto entropy = digits_to_data(input, 1, 6);
+    p->seed = deterministic_random(entropy, p->count);
 }
 
 void FormatDice::process_output(Params* p) {

src/format-hex.cpp

@@ -6,10 +6,15 @@
 //
 
 #include "format-hex.hpp"
+
+#include <iostream>
+
 #include "params.hpp"
 #include "utils.hpp"
 
 void FormatHex::process_input(Params* p) {
+    auto input = p->get_one_argument();
+    p->seed = hex_to_data(input);
 }
 
 void FormatHex::process_output(Params* p) {

src/format-ints.cpp

@@ -6,15 +6,48 @@
 //
 
 #include "format-ints.hpp"
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <stdexcept>
+
 #include "params.hpp"
 #include "utils.hpp"
+#include "random.hpp"
+
+using namespace std;
 
 FormatInts::FormatInts() : Format(Format::Key::ints, "ints") {
     low = 0;
     high = 9;
 }
 
+static vector<uint8_t> parse_ints(const string& input) {
+    vector<uint8_t> result;
+
+    istringstream iss(input);
+
+    while(!iss.eof()) {
+        string s;
+        iss >> s;
+        int i;
+        if(!(stringstream(s) >> i)) {
+            throw runtime_error("Invalid integer. Allowed: [0-255]");
+        }
+        if(!(0 <= i && i <= 255)) {
+            throw runtime_error("Integer out of range. Allowed: [0-255]");
+        }
+        result.push_back(i);
+    }
+
+    return result;
+}
+
 void FormatInts::process_input(Params* p) {
+    auto input = p->get_combined_arguments();
+    auto entropy = parse_ints(input);
+    p->seed = deterministic_random(entropy, p->count);
 }
 
 void FormatInts::process_output(Params* p) {