mirror of
https://codeberg.org/anoncontributorxmr/monero.git
synced 2024-11-27 05:13:25 +01:00
Restructured language sources to be singletons
This commit is contained in:
Oran Juice
parent
6c3b85de21
commit
4517bac7f3
@ -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,97 +56,93 @@
|
||||
#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 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)
|
||||
{
|
||||
if (word.length() == 0 || word[0] == '#')
|
||||
// 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++)
|
||||
{
|
||||
// Skip empty and comment lines
|
||||
continue;
|
||||
}
|
||||
words_array.push_back(word);
|
||||
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
|
||||
{
|
||||
words_map[word] = num_words;
|
||||
}
|
||||
num_words++;
|
||||
}
|
||||
input_stream.close();
|
||||
}
|
||||
|
||||
/*!
|
||||
* \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++)
|
||||
{
|
||||
if (has_checksum)
|
||||
{
|
||||
if (words_map.count(it->substr(0, unique_prefix_length)) == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (words_map.count(*it) == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
trimmed_seed.push_back(it->length() > Language::unique_prefix_length ?
|
||||
it->substr(0, Language::unique_prefix_length) : *it);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
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;
|
||||
|
||||
// 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)
|
||||
{
|
||||
// Use the trimmed words and map
|
||||
if (trimmed_word_map.count(*it3) == 0)
|
||||
{
|
||||
full_match = false;
|
||||
break;
|
||||
}
|
||||
matched_indices.push_back(trimmed_word_map[*it3]);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (word_map.count(*it2) == 0)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
/*!
|
||||
@ -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.
|
||||
* \return false if not a multiple of 3 words, or if word is not in the words list
|
||||
* \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++)
|
||||
|
||||
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))
|
||||
{
|
||||
init(*it, has_checksum);
|
||||
if (word_list_file_match(wlist, has_checksum))
|
||||
{
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// 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))
|
||||
{
|
||||
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 += ' ';
|
||||
@ -301,23 +273,44 @@ namespace crypto
|
||||
|
||||
/*!
|
||||
* \brief Converts bytes (secret key) to seed words.
|
||||
* \param src Secret key
|
||||
* \param words Space delimited concatenated words get written here.
|
||||
* \return true if successful false if not. Unsuccessful if wrong key size.
|
||||
* \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);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -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.
|
||||
* \return false if not a multiple of 3 words, or if word is not in the words list
|
||||
* \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.
|
||||
* \return true if successful false if not. Unsuccessful if wrong key size.
|
||||
* \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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
61
src/mnemonics/language_base.h
Normal file
61
src/mnemonics/language_base.h
Normal 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
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
16
src/mnemonics/singleton.h
Normal file
16
src/mnemonics/singleton.h
Normal 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;
|
||||
}
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -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, old_language))
|
||||
{
|
||||
if (!crypto::ElectrumWords::words_to_bytes(m_electrum_seed, m_recovery_key))
|
||||
{
|
||||
fail_msg_writer() << "electrum-style word list failed verification";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
catch (std::runtime_error &e)
|
||||
{
|
||||
fail_msg_writer() << e.what() << std::endl;
|
||||
fail_msg_writer() << "electrum-style word list failed verification";
|
||||
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 = "";
|
||||
|
||||
|
||||
@ -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();
|
||||
|
||||
|
||||
@ -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)
|
||||
{
|
||||
|
||||
@ -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)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user