Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

mnemonics: compare canonical words (lowercase) #5063

Merged
merged 1 commit into from
Jan 28, 2019
Merged

mnemonics: compare canonical words (lowercase) #5063

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
43 changes: 23 additions & 20 deletions src/mnemonics/electrum-words.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -76,8 +76,8 @@ namespace crypto
namespace
{
uint32_t create_checksum_index(const std::vector<epee::wipeable_string> &word_list,
uint32_t unique_prefix_length);
bool checksum_test(std::vector<epee::wipeable_string> seed, uint32_t unique_prefix_length);
const Language::Base *language);
bool checksum_test(std::vector<epee::wipeable_string> seed, const Language::Base *language);

/*!
* \brief Finds the word list that contains the seed words and puts the indices
Expand Down Expand Up @@ -116,8 +116,8 @@ namespace
for (std::vector<Language::Base*>::iterator it1 = language_instances.begin();
it1 != language_instances.end(); it1++)
{
const std::unordered_map<epee::wipeable_string, uint32_t> &word_map = (*it1)->get_word_map();
const std::unordered_map<epee::wipeable_string, uint32_t> &trimmed_word_map = (*it1)->get_trimmed_word_map();
const std::unordered_map<epee::wipeable_string, uint32_t, Language::WordHash, Language::WordEqual> &word_map = (*it1)->get_word_map();
const std::unordered_map<epee::wipeable_string, uint32_t, Language::WordHash, Language::WordEqual> &trimmed_word_map = (*it1)->get_trimmed_word_map();
// To iterate through seed words
bool full_match = true;

Expand Down Expand Up @@ -151,7 +151,7 @@ namespace
// if we were using prefix only, and we have a checksum, check it now
// to avoid false positives due to prefix set being too common
if (has_checksum)
if (!checksum_test(seed, (*it1)->get_unique_prefix_length()))
if (!checksum_test(seed, *it1))
{
fallback = *it1;
full_match = false;
Expand Down Expand Up @@ -190,20 +190,20 @@ namespace
* \return Checksum index
*/
uint32_t create_checksum_index(const std::vector<epee::wipeable_string> &word_list,
uint32_t unique_prefix_length)
const Language::Base *language)
{
epee::wipeable_string trimmed_words = "";
epee::wipeable_string trimmed_words = "", word;

const auto &word_map = language->get_word_map();
const auto &trimmed_word_map = language->get_trimmed_word_map();
const uint32_t unique_prefix_length = language->get_unique_prefix_length();
for (std::vector<epee::wipeable_string>::const_iterator it = word_list.begin(); it != word_list.end(); it++)
{
if (it->length() > unique_prefix_length)
{
trimmed_words += Language::utf8prefix(*it, unique_prefix_length);
}
else
{
trimmed_words += *it;
}
word = Language::utf8prefix(*it, unique_prefix_length);
auto it2 = trimmed_word_map.find(word);
if (it2 == trimmed_word_map.end())
throw std::runtime_error("Word \"" + std::string(word.data(), word.size()) + "\" not found in trimmed word map in " + language->get_english_language_name());
trimmed_words += it2->first;
}
boost::crc_32_type result;
result.process_bytes(trimmed_words.data(), trimmed_words.length());
Expand All @@ -216,21 +216,24 @@ namespace
* \param unique_prefix_length the prefix length of each word to use for checksum
* \return True if the test passed false if not.
*/
bool checksum_test(std::vector<epee::wipeable_string> seed, uint32_t unique_prefix_length)
bool checksum_test(std::vector<epee::wipeable_string> seed, const Language::Base *language)
{
if (seed.empty())
return false;
// The last word is the checksum.
epee::wipeable_string last_word = seed.back();
seed.pop_back();

epee::wipeable_string checksum = seed[create_checksum_index(seed, unique_prefix_length)];
const uint32_t unique_prefix_length = language->get_unique_prefix_length();

auto idx = create_checksum_index(seed, language);
epee::wipeable_string checksum = seed[idx];

epee::wipeable_string trimmed_checksum = checksum.length() > unique_prefix_length ? Language::utf8prefix(checksum, unique_prefix_length) :
checksum;
epee::wipeable_string trimmed_last_word = last_word.length() > unique_prefix_length ? Language::utf8prefix(last_word, unique_prefix_length) :
last_word;
bool ret = trimmed_checksum == trimmed_last_word;
bool ret = Language::WordEqual()(trimmed_checksum, trimmed_last_word);
MINFO("Checksum is " << (ret ? "valid" : "invalid"));
return ret;
}
Expand Down Expand Up @@ -301,7 +304,7 @@ namespace crypto

if (has_checksum)
{
if (!checksum_test(seed, language->get_unique_prefix_length()))
if (!checksum_test(seed, language))
{
// Checksum fail
MERROR("Invalid seed: invalid checksum");
Expand Down Expand Up @@ -424,7 +427,7 @@ namespace crypto
memwipe(w, sizeof(w));
}

words += words_store[create_checksum_index(words_store, language->get_unique_prefix_length())];
words += words_store[create_checksum_index(words_store, language)];
return true;
}

Expand Down
96 changes: 92 additions & 4 deletions src/mnemonics/language_base.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,9 @@
#include <vector>
#include <unordered_map>
#include <string>
#include <boost/algorithm/string.hpp>
#include "misc_log_ex.h"
#include "fnv1.h"

/*!
* \namespace Language
Expand Down Expand Up @@ -71,6 +73,92 @@ namespace Language
return prefix;
}

template<typename T>
inline T utf8canonical(const T &s)
{
T sc = "";
size_t avail = s.size();
const char *ptr = s.data();
wint_t cp = 0;
int bytes = 1;
char wbuf[8], *wptr;
while (avail--)
{
if ((*ptr & 0x80) == 0)
{
cp = *ptr++;
bytes = 1;
}
else if ((*ptr & 0xe0) == 0xc0)
{
if (avail < 1)
throw std::runtime_error("Invalid UTF-8");
cp = (*ptr++ & 0x1f) << 6;
cp |= *ptr++ & 0x3f;
--avail;
bytes = 2;
}
else if ((*ptr & 0xf0) == 0xe0)
{
if (avail < 2)
throw std::runtime_error("Invalid UTF-8");
cp = (*ptr++ & 0xf) << 12;
cp |= (*ptr++ & 0x3f) << 6;
cp |= *ptr++ & 0x3f;
avail -= 2;
bytes = 3;
}
else if ((*ptr & 0xf8) == 0xf0)
{
if (avail < 3)
throw std::runtime_error("Invalid UTF-8");
cp = (*ptr++ & 0x7) << 18;
cp |= (*ptr++ & 0x3f) << 12;
cp |= (*ptr++ & 0x3f) << 6;
cp |= *ptr++ & 0x3f;
avail -= 3;
bytes = 4;
}
else
throw std::runtime_error("Invalid UTF-8");

cp = std::towlower(cp);
wptr = wbuf;
switch (bytes)
{
case 1: *wptr++ = cp; break;
case 2: *wptr++ = 0xc0 | (cp >> 6); *wptr++ = 0x80 | (cp & 0x3f); break;
case 3: *wptr++ = 0xe0 | (cp >> 12); *wptr++ = 0x80 | ((cp >> 6) & 0x3f); *wptr++ = 0x80 | (cp & 0x3f); break;
case 4: *wptr++ = 0xf0 | (cp >> 18); *wptr += 0x80 | ((cp >> 12) & 0x3f); *wptr++ = 0x80 | ((cp >> 6) & 0x3f); *wptr++ = 0x80 | (cp & 0x3f); break;
default: throw std::runtime_error("Invalid UTF-8");
}
*wptr = 0;
sc += T(wbuf, bytes);
cp = 0;
bytes = 1;
}
return sc;
}

struct WordHash
{
std::size_t operator()(const epee::wipeable_string &s) const
{
const epee::wipeable_string sc = utf8canonical(s);
return epee::fnv::FNV1a(sc.data(), sc.size());
}
};

struct WordEqual
{
bool operator()(const epee::wipeable_string &s0, const epee::wipeable_string &s1) const
{
const epee::wipeable_string s0c = utf8canonical(s0);
const epee::wipeable_string s1c = utf8canonical(s1);
return s0c == s1c;
}
};

/*!
* \class Base
* \brief A base language class which all languages have to inherit from for
Expand All @@ -87,8 +175,8 @@ namespace Language
NWORDS = 1626
};
std::vector<std::string> word_list; /*!< A pointer to the array of words */
std::unordered_map<epee::wipeable_string, uint32_t> word_map; /*!< hash table to find word's index */
std::unordered_map<epee::wipeable_string, uint32_t> trimmed_word_map; /*!< hash table to find word's trimmed index */
std::unordered_map<epee::wipeable_string, uint32_t, WordHash, WordEqual> word_map; /*!< hash table to find word's index */
std::unordered_map<epee::wipeable_string, uint32_t, WordHash, WordEqual> trimmed_word_map; /*!< hash table to find word's trimmed index */
std::string language_name; /*!< Name of language */
std::string english_language_name; /*!< Name of language */
uint32_t unique_prefix_length; /*!< Number of unique starting characters to trim the wordlist to when matching */
Expand Down Expand Up @@ -159,15 +247,15 @@ namespace Language
* \brief Returns a pointer to the word map.
* \return A pointer to the word map.
*/
const std::unordered_map<epee::wipeable_string, uint32_t>& get_word_map() const
const std::unordered_map<epee::wipeable_string, uint32_t, WordHash, WordEqual>& get_word_map() const
{
return word_map;
}
/*!
* \brief Returns a pointer to the trimmed word map.
* \return A pointer to the trimmed word map.
*/
const std::unordered_map<epee::wipeable_string, uint32_t>& get_trimmed_word_map() const
const std::unordered_map<epee::wipeable_string, uint32_t, WordHash, WordEqual>& get_trimmed_word_map() const
{
return trimmed_word_map;
}
Expand Down