kumi/danicoin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Restructured language sources to be singletons

Browse source
This commit is contained in:
Oran Juice 2014-10-02 18:15:18 +05:30
parent 6c3b85de21
commit 4517bac7f3
No known key found for this signature in database
GPG key ID: 71C5AF46CCB28124
13 changed files with 9801 additions and 9878 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

358
src/mnemonics/electrum-words.cpp
View file

@ -41,6 +41,7 @@
#include <map>
#include <cstdint>
#include <vector>
#include <unordered_map>
#include <boost/algorithm/string.hpp>
#include "crypto/crypto.h" // for declaration of crypto::secret_key
#include <fstream>
@ -55,98 +56,94 @@
#include "portuguese.h"
#include "japanese.h"
#include "old_english.h"
#include "language_base.h"
#include "singleton.h"
namespace
{
int num_words = 0;
const int seed_length = 24;
std::map<std::string,uint32_t> words_map;
std::vector<std::string> words_array;
bool is_old_style_word_list = false;
const std::string WORD_LISTS_DIRECTORY = "wordlists";
const std::string LANGUAGES_DIRECTORY = "languages";
const std::string OLD_WORD_FILE = "old-word-list";
const int unique_prefix_length = 4;
/*!
* \brief Tells if the module hasn't been initialized with a word list file.
* \return true if the module hasn't been initialized with a word list file false otherwise.
* \brief Finds the word list that contains the seed words and puts the indices
* where matches occured in matched_indices.
* \param seed List of words to match.
* \param has_checksum If word list passed checksum test, we need to only do a prefix check.
* \param matched_indices The indices where the seed words were found are added to this.
* \return true if all the words were present in some language false if not.
*/
bool is_uninitialized()
bool find_seed_language(const std::vector<std::string> &seed,
bool has_checksum, std::vector<uint32_t> &matched_indices, uint32_t &word_list_length,
std::string &language_name)
{
return num_words == 0 ? true : false;
}
/*!
* \brief Create word list map and array data structres for use during inter-conversion between
* words and secret key.
* \param word_file Path to the word list file from pwd.
* \param has_checksum True if checksum was supplied false if not.
*/
void create_data_structures(const std::string &word_file, bool has_checksum)
{
words_array.clear();
words_map.clear();
num_words = 0;
std::ifstream input_stream;
input_stream.open(word_file.c_str(), std::ifstream::in);
if (!input_stream)
throw std::runtime_error("Word list file couldn't be opened.");
std::string word;
while (input_stream >> word)
{
if (word.length() == 0 || word[0] == '#')
{
// Skip empty and comment lines
continue;
}
words_array.push_back(word);
// If there's a new language added, add an instance of it here.
std::vector<Language::Base*> language_instances({
Language::Singleton<Language::English>::instance(),
Language::Singleton<Language::Spanish>::instance(),
Language::Singleton<Language::Portuguese>::instance(),
Language::Singleton<Language::Japanese>::instance(),
Language::Singleton<Language::OldEnglish>::instance()
});
// To hold trimmed seed words in case of a checksum being present.
std::vector<std::string> trimmed_seed;
if (has_checksum)
{
// Only if checksum was passed should we stick to just 4 char checks to be lenient about typos.
words_map[word.substr(0, unique_prefix_length)] = num_words;
}
else
// If it had a checksum, we'll just compare the unique prefix
// So we create a list of trimmed seed words
for (std::vector<std::string>::const_iterator it = seed.begin(); it != seed.end(); it++)
{
words_map[word] = num_words;
trimmed_seed.push_back(it->length() > Language::unique_prefix_length ?
it->substr(0, Language::unique_prefix_length) : *it);
}
num_words++;
}
input_stream.close();
}
std::unordered_map<std::string, uint32_t> word_map;
std::unordered_map<std::string, uint32_t> trimmed_word_map;
// Iterate through all the languages and find a match
for (std::vector<Language::Base*>::iterator it1 = language_instances.begin();
it1 != language_instances.end(); it1++)
{
word_map = (*it1)->get_word_map();
trimmed_word_map = (*it1)->get_trimmed_word_map();
// To iterate through seed words
std::vector<std::string>::const_iterator it2;
// To iterate through trimmed seed words
std::vector<std::string>::iterator it3;
bool full_match = true;
/*!
* \brief Tells if all the words passed in wlist was present in current word list file.
* \param wlist List of words to match.
* \param has_checksum If word list passed checksum test, we need to only do a 4 char check.
* \return true if all the words were present false if not.
*/
bool word_list_file_match(const std::vector<std::string> &wlist, bool has_checksum)
{
for (std::vector<std::string>::const_iterator it = wlist.begin(); it != wlist.end(); it++)
// Iterate through all the words and see if they're all present
for (it2 = seed.begin(), it3 = trimmed_seed.begin();
it2 != seed.end() && it3 != trimmed_seed.end(); it2++, it3++)
{
if (has_checksum)
{
if (words_map.count(it->substr(0, unique_prefix_length)) == 0)
// Use the trimmed words and map
if (trimmed_word_map.count(*it3) == 0)
{
return false;
full_match = false;
break;
}
matched_indices.push_back(trimmed_word_map[*it3]);
}
else
{
if (words_map.count(*it) == 0)
if (word_map.count(*it2) == 0)
{
return false;
}
full_match = false;
break;
}
matched_indices.push_back(word_map[*it2]);
}
}
if (full_match)
{
word_list_length = (*it1)->get_word_list().size();
language_name = (*it1)->get_language_name();
return true;
}
// Some didn't match. Clear the index array.
matched_indices.clear();
}
return false;
}
/*!
* \brief Creates a checksum index in the word list array on the list of words.
@ -155,16 +152,43 @@ namespace
*/
uint32_t create_checksum_index(const std::vector<std::string> &word_list)
{
std::string four_char_words = "";
std::string trimmed_words = "";
for (std::vector<std::string>::const_iterator it = word_list.begin(); it != word_list.end(); it++)
{
four_char_words += it->substr(0, unique_prefix_length);
if (it->length() > 4)
{
trimmed_words += it->substr(0, Language::unique_prefix_length);
}
else
{
trimmed_words += *it;
}
}
boost::crc_32_type result;
result.process_bytes(four_char_words.data(), four_char_words.length());
result.process_bytes(trimmed_words.data(), trimmed_words.length());
return result.checksum() % seed_length;
}
/*!
* \brief Does the checksum test on the seed passed.
* \param seed Vector of seed words
* \return True if the test passed false if not.
*/
bool checksum_test(std::vector<std::string> seed)
{
// The last word is the checksum.
std::string last_word = seed.back();
seed.pop_back();
std::string checksum = seed[create_checksum_index(seed)];
std::string trimmed_checksum = checksum.length() > 4 ? checksum.substr(0, Language::unique_prefix_length) :
checksum;
std::string trimmed_last_word = checksum.length() > 4 ? last_word.substr(0, Language::unique_prefix_length) :
last_word;
return trimmed_checksum == trimmed_last_word;
}
}
/*!
@ -181,115 +205,63 @@ namespace crypto
*/
namespace ElectrumWords
{
/*!
* \brief Called to initialize it to work with a word list file.
* \param language Language of the word list file.
* \param has_checksum True if the checksum was passed false if not.
* \param old_word_list true it is to use the old style word list file false if not.
*/
void init(const std::string &language, bool has_checksum, bool old_word_list)
{
if (old_word_list)
{
// Use the old word list file if told to.
create_data_structures(WORD_LISTS_DIRECTORY + '/' + OLD_WORD_FILE, has_checksum);
is_old_style_word_list = true;
}
else
{
create_data_structures(WORD_LISTS_DIRECTORY + '/' + LANGUAGES_DIRECTORY + '/' + language, has_checksum);
is_old_style_word_list = false;
}
if (num_words == 0)
{
throw std::runtime_error(std::string("Word list file is empty: ") +
(old_word_list ? OLD_WORD_FILE : (LANGUAGES_DIRECTORY + '/' + language)));
}
}
/*!
* \brief Converts seed words to bytes (secret key).
* \param words String containing the words separated by spaces.
* \param dst To put the secret key restored from the words.
* \param language_name Language of the seed as found gets written here.
* \return false if not a multiple of 3 words, or if word is not in the words list
*/
bool words_to_bytes(const std::string& words, crypto::secret_key& dst)
bool words_to_bytes(const std::string& words, crypto::secret_key& dst,
std::string &language_name)
{
std::vector<std::string> wlist;
std::vector<std::string> seed;
boost::split(wlist, words, boost::is_any_of(" "));
boost::split(seed, words, boost::is_any_of(" "));
// error on non-compliant word list
if (seed.size() != seed_length/2 && seed.size() != seed_length &&
seed.size() != seed_length + 1)
{
return false;
}
// If it is seed with a checksum.
bool has_checksum = (wlist.size() == seed_length + 1);
bool has_checksum = seed.size() == (seed_length + 1);
if (has_checksum)
{
// The last word is the checksum.
std::string last_word = wlist.back();
wlist.pop_back();
std::string checksum = wlist[create_checksum_index(wlist)];
if (checksum.substr(0, unique_prefix_length) != last_word.substr(0, unique_prefix_length))
if (!checksum_test(seed))
{
// Checksum fail
return false;
}
}
// Try to find a word list file that contains all the words in the word list.
std::vector<std::string> languages;
get_language_list(languages);
std::vector<std::string>::iterator it;
for (it = languages.begin(); it != languages.end(); it++)
{
init(*it, has_checksum);
if (word_list_file_match(wlist, has_checksum))
{
break;
}
}
// If no such file was found, see if the old style word list file has them all.
if (it == languages.end())
{
init("", has_checksum, true);
if (!word_list_file_match(wlist, has_checksum))
std::vector<uint32_t> matched_indices;
uint32_t word_list_length;
if (!find_seed_language(seed, has_checksum, matched_indices, word_list_length, language_name))
{
return false;
}
}
int n = num_words;
// error on non-compliant word list
if (wlist.size() != 12 && wlist.size() != 24) return false;
for (unsigned int i=0; i < wlist.size() / 3; i++)
for (unsigned int i=0; i < seed.size() / 3; i++)
{
uint32_t val;
uint32_t w1, w2, w3;
w1 = matched_indices[i*3];
w2 = matched_indices[i*3 + 1];
w3 = matched_indices[i*3 + 2];
if (has_checksum)
{
w1 = words_map.at(wlist[i*3].substr(0, unique_prefix_length));
w2 = words_map.at(wlist[i*3 + 1].substr(0, unique_prefix_length));
w3 = words_map.at(wlist[i*3 + 2].substr(0, unique_prefix_length));
}
else
{
w1 = words_map.at(wlist[i*3]);
w2 = words_map.at(wlist[i*3 + 1]);
w3 = words_map.at(wlist[i*3 + 2]);
}
val = w1 + word_list_length * (((word_list_length - w1) + w2) % word_list_length) +
word_list_length * word_list_length * (((word_list_length - w2) + w3) % word_list_length);
val = w1 + n * (((n - w1) + w2) % n) + n * n * (((n - w2) + w3) % n);
if (!(val % n == w1)) return false;
if (!(val % word_list_length == w1)) return false;
memcpy(dst.data + i * 4, &val, 4); // copy 4 bytes to position
}
std::string wlist_copy = words;
if (wlist.size() == 12)
if (seed.size() == seed_length/2)
{
memcpy(dst.data, dst.data + 16, 16); // if electrum 12-word seed, duplicate
wlist_copy += ' ';
@ -303,21 +275,42 @@ namespace crypto
* \brief Converts bytes (secret key) to seed words.
* \param src Secret key
* \param words Space delimited concatenated words get written here.
* \param language_name Seed language name
* \return true if successful false if not. Unsuccessful if wrong key size.
*/
bool bytes_to_words(const crypto::secret_key& src, std::string& words)
bool bytes_to_words(const crypto::secret_key& src, std::string& words,
const std::string &language_name)
{
if (is_uninitialized())
{
init("english", true);
}
// To store the words for random access to add the checksum word later.
std::vector<std::string> words_store;
int n = num_words;
if (sizeof(src.data) % 4 != 0 || sizeof(src.data) == 0) return false;
std::vector<std::string> word_list;
Language::Base *language;
if (language_name == "English")
{
language = Language::Singleton<Language::English>::instance();
}
else if (language_name == "Spanish")
{
language = Language::Singleton<Language::Spanish>::instance();
}
else if (language_name == "Portuguese")
{
language = Language::Singleton<Language::Portuguese>::instance();
}
else if (language_name == "Japanese")
{
language = Language::Singleton<Language::Japanese>::instance();
}
else
{
return false;
}
word_list = language->get_word_list();
// To store the words for random access to add the checksum word later.
std::vector<std::string> words_store;
uint32_t word_list_length = word_list.size();
// 8 bytes -> 3 words. 8 digits base 16 -> 3 digits base 1626
for (unsigned int i=0; i < sizeof(src.data)/4; i++, words += ' ')
{
@ -327,19 +320,19 @@ namespace crypto
memcpy(&val, (src.data) + (i * 4), 4);
w1 = val % n;
w2 = ((val / n) + w1) % n;
w3 = (((val / n) / n) + w2) % n;
w1 = val % word_list_length;
w2 = ((val / word_list_length) + w1) % word_list_length;
w3 = (((val / word_list_length) / word_list_length) + w2) % word_list_length;
words += words_array[w1];
words += word_list[w1];
words += ' ';
words += words_array[w2];
words += word_list[w2];
words += ' ';
words += words_array[w3];
words += word_list[w3];
words_store.push_back(words_array[w1]);
words_store.push_back(words_array[w2]);
words_store.push_back(words_array[w3]);
words_store.push_back(word_list[w1]);
words_store.push_back(word_list[w2]);
words_store.push_back(word_list[w3]);
}
words.pop_back();
@ -353,31 +346,18 @@ namespace crypto
*/
void get_language_list(std::vector<std::string> &languages)
{
languages.clear();
boost::filesystem::path languages_directory("wordlists/languages");
if (!boost::filesystem::exists(languages_directory) ||
!boost::filesystem::is_directory(languages_directory))
std::vector<Language::Base*> language_instances({
Language::Singleton<Language::English>::instance(),
Language::Singleton<Language::Spanish>::instance(),
Language::Singleton<Language::Portuguese>::instance(),
Language::Singleton<Language::Japanese>::instance(),
Language::Singleton<Language::OldEnglish>::instance()
});
for (std::vector<Language::Base*>::iterator it = language_instances.begin();
it != language_instances.end(); it++)
{
throw std::runtime_error("Word list languages directory is missing.");
languages.push_back((*it)->get_language_name());
}
boost::filesystem::directory_iterator end;
for (boost::filesystem::directory_iterator it(languages_directory); it != end; it++)
{
languages.push_back(it->path().filename().string());
}
}
/*!
* \brief Tells if the module is currenly using an old style word list.
* \return true if it is currenly using an old style word list false if not.
*/
bool get_is_old_style_word_list()
{
if (is_uninitialized())
{
throw std::runtime_error("ElectrumWords hasn't been initialized with a word list yet.");
}
return is_old_style_word_list;
}
/*!
@ -387,9 +367,9 @@ namespace crypto
*/
bool get_is_old_style_seed(const std::string &seed)
{
std::vector<std::string> wlist;
boost::split(wlist, seed, boost::is_any_of(" "));
return wlist.size() != (seed_length + 1);
std::vector<std::string> word_list;
boost::split(word_list, seed, boost::is_any_of(" "));
return word_list.size() != (seed_length + 1);
}
}

26
src/mnemonics/electrum-words.h
View file

@ -36,6 +36,9 @@
* that method of "backing up" one's wallet keys.
*/
#ifndef ELECTRUM_WORDS_H
#define ELECTRUM_WORDS_H
#include <string>
#include <cstdint>
#include <map>
@ -55,29 +58,26 @@ namespace crypto
*/
namespace ElectrumWords
{
/*!
* \brief Called to initialize it to work with a word list file.
* \param language Language of the word list file.
* \param has_checksum True if the checksum was passed false if not.
* \param old_word_list true it is to use the old style word list file false if not.
*/
void init(const std::string &language, bool has_checksum=true, bool old_word_list=false);
/*!
* \brief Converts seed words to bytes (secret key).
* \param words String containing the words separated by spaces.
* \param dst To put the secret key restored from the words.
* \param language_name Language of the seed as found gets written here.
* \return false if not a multiple of 3 words, or if word is not in the words list
*/
bool words_to_bytes(const std::string& words, crypto::secret_key& dst);
bool words_to_bytes(const std::string& words, crypto::secret_key& dst,
std::string &language_name);
/*!
* \brief Converts bytes (secret key) to seed words.
* \param src Secret key
* \param words Space delimited concatenated words get written here.
* \param language_name Seed language name
* \return true if successful false if not. Unsuccessful if wrong key size.
*/
bool bytes_to_words(const crypto::secret_key& src, std::string& words);
bool bytes_to_words(const crypto::secret_key& src, std::string& words,
const std::string &language_name);
/*!
* \brief Gets a list of seed languages that are supported.
@ -85,12 +85,6 @@ namespace crypto
*/
void get_language_list(std::vector<std::string> &languages);
/*!
* \brief If the module is currenly using an old style word list.
* \return true if it is currenly using an old style word list false if not.
*/
bool get_is_old_style_word_list();
/*!
* \brief Tells if the seed passed is an old style seed or not.
* \param seed The seed to check (a space delimited concatenated word list)
@ -99,3 +93,5 @@ namespace crypto
bool get_is_old_style_seed(const std::string &seed);
}
}
#endif

64
src/mnemonics/english.h
View file

@ -1,9 +1,19 @@
#ifndef ENGLISH_H
#define ENGLISH_H
#include <vector>
#include <unordered_map>
#include "language_base.h"
#include <string>
std::vector<std::string>& word_list_english()
namespace Language
{
static std::vector<std::string> word_list(
class English: public Base
{
public:
English()
{
word_list = new std::vector<std::string>({
"abandon",
"ability",
"able",
@ -2052,47 +2062,13 @@ std::vector<std::string>& word_list_english()
"zero",
"zone",
"zoo"
);
return word_list;
});
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "English";
populate_maps();
}
};
}
std::unordered_map<std::string, unsigned int>& word_map_english()
{
static std::unordered_map<std::string, unsigned int> word_map;
if (word_map.size() > 0)
{
return word_map;
}
std::vector<std::string> word_list = word_list_english();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
word_map[*it] = ii;
}
return word_map;
}
std::unordered_map<std::string, unsigned int>& trimmed_word_map_english()
{
static std::unordered_map<std::string, unsigned int> trimmed_word_map;
if (trimmed_word_map.size() > 0)
{
return trimmed_word_map;
}
std::vector<std::string> word_list = word_list_english();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
if (it->length() > 4)
{
trimmed_word_map[it->substr(0, 4)] = ii;
}
else
{
trimmed_word_map[*it] = ii;
}
}
return trimmed_word_map;
}
#endif

64
src/mnemonics/japanese.h
View file

@ -1,9 +1,19 @@
#ifndef JAPANESE_H
#define JAPANESE_H
#include <vector>
#include <unordered_map>
#include "language_base.h"
#include <string>
std::vector<std::string>& word_list_japanese()
namespace Language
{
static std::vector<std::string> word_list(
class Japanese: public Base
{
public:
Japanese()
{
word_list = new std::vector<std::string>({
"あい",
"あいこくしん",
"あう",
@ -2052,47 +2062,13 @@ std::vector<std::string>& word_list_japanese()
"ろんぶん",
"ろんり",
"わじまし"
);
return word_list;
});
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "Japanese";
populate_maps();
}
};
}
std::unordered_map<std::string, unsigned int>& word_map_japanese()
{
static std::unordered_map<std::string, unsigned int> word_map;
if (word_map.size() > 0)
{
return word_map;
}
std::vector<std::string> word_list = word_list_japanese();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
word_map[*it] = ii;
}
return word_map;
}
std::unordered_map<std::string, unsigned int>& trimmed_word_map_japanese()
{
static std::unordered_map<std::string, unsigned int> trimmed_word_map;
if (trimmed_word_map.size() > 0)
{
return trimmed_word_map;
}
std::vector<std::string> word_list = word_list_japanese();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
if (it->length() > 4)
{
trimmed_word_map[it->substr(0, 4)] = ii;
}
else
{
trimmed_word_map[*it] = ii;
}
}
return trimmed_word_map;
}
#endif

61
src/mnemonics/language_base.h Normal file
View file

@ -0,0 +1,61 @@
#ifndef LANGUAGE_BASE_H
#define LANGUAGE_BASE_H
#include <vector>
#include <unordered_map>
#include <string>
namespace Language
{
const int unique_prefix_length = 4;
class Base
{
protected:
std::vector<std::string> *word_list;
std::unordered_map<std::string, uint32_t> *word_map;
std::unordered_map<std::string, uint32_t> *trimmed_word_map;
std::string language_name;
void populate_maps()
{
int ii;
std::vector<std::string>::iterator it;
for (it = word_list->begin(), ii = 0; it != word_list->end(); it++, ii++)
{
(*word_map)[*it] = ii;
if (it->length() > 4)
{
(*trimmed_word_map)[it->substr(0, 4)] = ii;
}
else
{
(*trimmed_word_map)[*it] = ii;
}
}
}
public:
Base()
{
word_list = new std::vector<std::string>;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
}
const std::vector<std::string>& get_word_list() const
{
return *word_list;
}
const std::unordered_map<std::string, uint32_t>& get_word_map() const
{
return *word_map;
}
const std::unordered_map<std::string, uint32_t>& get_trimmed_word_map() const
{
return *trimmed_word_map;
}
std::string get_language_name() const
{
return language_name;
}
};
}
#endif

64
src/mnemonics/old_english.h
View file

@ -1,9 +1,19 @@
#ifndef OLD_ENGLISH_H
#define OLD_ENGLISH_H
#include <vector>
#include <unordered_map>
#include "language_base.h"
#include <string>
std::vector<std::string>& word_list_old_english()
namespace Language
{
static std::vector<std::string> word_list(
class OldEnglish: public Base
{
public:
OldEnglish()
{
word_list = new std::vector<std::string>({
"like",
"just",
"love",
@ -1630,47 +1640,13 @@ std::vector<std::string>& word_list_old_english()
"unseen",
"weapon",
"weary"
);
return word_list;
});
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "OldEnglish";
populate_maps();
}
};
}
std::unordered_map<std::string, unsigned int>& word_map_old_english()
{
static std::unordered_map<std::string, unsigned int> word_map;
if (word_map.size() > 0)
{
return word_map;
}
std::vector<std::string> word_list = word_list_old_english();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
word_map[*it] = ii;
}
return word_map;
}
std::unordered_map<std::string, unsigned int>& trimmed_word_map_old_english()
{
static std::unordered_map<std::string, unsigned int> trimmed_word_map;
if (trimmed_word_map.size() > 0)
{
return trimmed_word_map;
}
std::vector<std::string> word_list = word_list_old_english();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
if (it->length() > 4)
{
trimmed_word_map[it->substr(0, 4)] = ii;
}
else
{
trimmed_word_map[*it] = ii;
}
}
return trimmed_word_map;
}
#endif

65
src/mnemonics/portuguese.h
View file

@ -1,9 +1,19 @@
#ifndef PORTUGUESE_H
#define PORTUGUESE_H
#include <vector>
#include <unordered_map>
#include "language_base.h"
#include <string>
std::vector<std::string>& word_list_portuguese()
namespace Language
{
static std::vector<std::string> word_list(
class Portuguese: public Base
{
public:
Portuguese()
{
word_list = new std::vector<std::string>({
"abaular",
"abdominal",
"abeto",
@ -1630,48 +1640,13 @@ std::vector<std::string>& word_list_portuguese()
"zeloso",
"zenite",
"zumbi"
);
return word_list;
});
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "Portuguese";
populate_maps();
}
};
}
std::unordered_map<std::string, unsigned int>& word_map_portuguese()
{
static std::unordered_map<std::string, unsigned int> word_map;
if (word_map.size() > 0)
{
return word_map;
}
std::vector<std::string> word_list = word_list_portuguese();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
word_map[*it] = ii;
}
return word_map;
}
std::unordered_map<std::string, unsigned int>& trimmed_word_map_portuguese()
{
static std::unordered_map<std::string, unsigned int> trimmed_word_map;
if (trimmed_word_map.size() > 0)
{
return trimmed_word_map;
}
std::vector<std::string> word_list = word_list_portuguese();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
if (it->length() > 4)
{
trimmed_word_map[it->substr(0, 4)] = ii;
}
else
{
trimmed_word_map[*it] = ii;
}
}
return trimmed_word_map;
}
#endif

16
src/mnemonics/singleton.h Normal file
View file

@ -0,0 +1,16 @@
namespace Language
{
template <class T>
class Singleton
{
Singleton() {}
Singleton(Singleton &s) {}
Singleton& operator=(const Singleton&) {}
public:
static T* instance()
{
static T* obj = new T;
return obj;
}
};
}

64
src/mnemonics/spanish.h
View file

@ -1,9 +1,19 @@
#ifndef SPANISH_H
#define SPANISH_H
#include <vector>
#include <unordered_map>
#include "language_base.h"
#include <string>
std::vector<std::string>& word_list_spanish()
namespace Language
{
static std::vector<std::string> word_list(
class Spanish: public Base
{
public:
Spanish()
{
word_list = new std::vector<std::string>({
"ábaco",
"abdomen",
"abeja",
@ -2052,47 +2062,13 @@ std::vector<std::string>& word_list_spanish()
"zorro",
"zumo",
"zurdo"
);
return word_list;
});
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "Spanish";
populate_maps();
}
};
}
std::unordered_map<std::string, unsigned int>& word_map_spanish()
{
static std::unordered_map<std::string, unsigned int> word_map;
if (word_map.size() > 0)
{
return word_map;
}
std::vector<std::string> word_list = word_list_spanish();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
word_map[*it] = ii;
}
return word_map;
}
std::unordered_map<std::string, unsigned int>& trimmed_word_map_spanish()
{
static std::unordered_map<std::string, unsigned int> trimmed_word_map;
if (trimmed_word_map.size() > 0)
{
return trimmed_word_map;
}
std::vector<std::string> word_list = word_list_spanish();
int ii;
std::vector<std::string>::iterator it;
for (it = word_list.begin(), ii = 0; it != word_list.end(); it++, ii++)
{
if (it->length() > 4)
{
trimmed_word_map[it->substr(0, 4)] = ii;
}
else
{
trimmed_word_map[*it] = ii;
}
}
return trimmed_word_map;
}
#endif

47
src/simplewallet/simplewallet.cpp
View file

@ -368,6 +368,7 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
{
if (m_wallet_file.empty()) m_wallet_file = m_generate_new; // alias for simplicity later
std::string old_language;
// check for recover flag. if present, require electrum word list (only recovery option for now).
if (m_restore_deterministic_wallet)
{
@ -387,21 +388,14 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
}
}
try
{
if (!crypto::ElectrumWords::words_to_bytes(m_electrum_seed, m_recovery_key))
if (!crypto::ElectrumWords::words_to_bytes(m_electrum_seed, m_recovery_key, old_language))
{
fail_msg_writer() << "electrum-style word list failed verification";
return false;
}
}
catch (std::runtime_error &e)
{
fail_msg_writer() << e.what() << std::endl;
return false;
}
}
bool r = new_wallet(m_wallet_file, pwd_container.password(), m_recovery_key, m_restore_deterministic_wallet, m_non_deterministic, testnet);
bool r = new_wallet(m_wallet_file, pwd_container.password(), m_recovery_key, m_restore_deterministic_wallet,
m_non_deterministic, testnet, old_language);
CHECK_AND_ASSERT_MES(r, false, "account creation failed");
}
else
@ -471,7 +465,7 @@ std::string simple_wallet::get_mnemonic_language()
try
{
language_number = std::stoi(language_choice);
if (!((language_number >= 0) && (static_cast<uint>(language_number) < language_list.size())))
if (!((language_number >= 0) && (static_cast<unsigned int>(language_number) < language_list.size())))
{
language_number = -1;
fail_msg_writer() << "Invalid language choice passed. Please try again.\n";
@ -486,7 +480,8 @@ std::string simple_wallet::get_mnemonic_language()
}
//----------------------------------------------------------------------------------------------------
bool simple_wallet::new_wallet(const string &wallet_file, const std::string& password, const crypto::secret_key& recovery_key, bool recover, bool two_random, bool testnet)
bool simple_wallet::new_wallet(const std::string &wallet_file, const std::string& password, const crypto::secret_key& recovery_key,
bool recover, bool two_random, bool testnet, const std::string &old_language)
{
m_wallet_file = wallet_file;
@ -512,10 +507,10 @@ bool simple_wallet::new_wallet(const string &wallet_file, const std::string& pas
// convert rng value to electrum-style word list
std::string electrum_words;
bool was_deprecated_wallet = m_restore_deterministic_wallet &&
(crypto::ElectrumWords::get_is_old_style_word_list() ||
crypto::ElectrumWords::get_is_old_style_seed(m_electrum_seed));
bool was_deprecated_wallet = (old_language == "OldEnglish") ||
crypto::ElectrumWords::get_is_old_style_seed(m_electrum_seed);
std::string mnemonic_language = old_language;
// Ask for seed language if it is not a wallet restore or if it was a deprecated wallet
// that was earlier used before this restore.
if (!m_restore_deterministic_wallet || was_deprecated_wallet)
@ -526,26 +521,10 @@ bool simple_wallet::new_wallet(const string &wallet_file, const std::string& pas
message_writer(epee::log_space::console_color_green, false) << "\nYou had been using " <<
"a deprecated version of the wallet. Please use the new seed that we provide.\n";
}
std::string mnemonic_language = get_mnemonic_language();
try
{
crypto::ElectrumWords::init(mnemonic_language);
}
catch (std::runtime_error &e)
{
fail_msg_writer() << e.what() << std::endl;
return false;
}
}
try
{
crypto::ElectrumWords::bytes_to_words(recovery_val, electrum_words);
}
catch (std::runtime_error &e)
{
fail_msg_writer() << e.what() << std::endl;
return false;
mnemonic_language = get_mnemonic_language();
}
crypto::ElectrumWords::bytes_to_words(recovery_val, electrum_words, mnemonic_language);
m_wallet->set_seed_language(mnemonic_language);
std::string print_electrum = "";

3
src/simplewallet/simplewallet.h
View file

@ -74,7 +74,8 @@ namespace cryptonote
bool run_console_handler();
bool new_wallet(const std::string &wallet_file, const std::string& password, const crypto::secret_key& recovery_key = crypto::secret_key(), bool recover = false, bool two_random = false, bool testnet = false);
bool new_wallet(const std::string &wallet_file, const std::string& password, const crypto::secret_key& recovery_key,
bool recover, bool two_random, bool testnet, const std::string &old_language);
bool open_wallet(const std::string &wallet_file, const std::string& password, bool testnet);
bool close_wallet();

9
src/wallet/wallet2.cpp
View file

@ -88,7 +88,7 @@ void wallet2::init(const std::string& daemon_address, uint64_t upper_transaction
//----------------------------------------------------------------------------------------------------
bool wallet2::get_seed(std::string& electrum_words)
{
crypto::ElectrumWords::bytes_to_words(get_account().get_keys().m_spend_secret_key, electrum_words);
crypto::ElectrumWords::bytes_to_words(get_account().get_keys().m_spend_secret_key, electrum_words, seed_language);
crypto::secret_key second;
keccak((uint8_t *)&get_account().get_keys().m_spend_secret_key, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
@ -97,6 +97,13 @@ bool wallet2::get_seed(std::string& electrum_words)
return memcmp(second.data,get_account().get_keys().m_view_secret_key.data, sizeof(crypto::secret_key)) == 0;
}
/*!
* \brief Sets the seed language
*/
void wallet2::set_seed_language(const std::string &language)
{
seed_language = language;
}
//----------------------------------------------------------------------------------------------------
void wallet2::process_new_transaction(const cryptonote::transaction& tx, uint64_t height)
{

6
src/wallet/wallet2.h
View file

@ -152,7 +152,10 @@ namespace tools
void callback(i_wallet2_callback* callback) { m_callback = callback; }
bool get_seed(std::string& electrum_words);
/*!
* \brief Sets the seed language
*/
void set_seed_language(const std::string &language);
void refresh();
void refresh(uint64_t start_height, size_t & blocks_fetched);
void refresh(uint64_t start_height, size_t & blocks_fetched, bool& received_money);
@ -236,6 +239,7 @@ namespace tools
i_wallet2_callback* m_callback;
bool m_testnet;
std::string seed_language;
};
}
BOOST_CLASS_VERSION(tools::wallet2, 7)