crypto::ElectrumWords Namespace Reference

Mnemonic seed word generation and wallet restoration helper functions. More...

Functions
std::vector< const Language::Base * >	get_language_list ()
bool	words_to_bytes (const epee::wipeable_string &words, epee::wipeable_string &dst, size_t len, bool duplicate, std::string &language_name)
	Converts seed words to bytes (secret key).
bool	words_to_bytes (const epee::wipeable_string &words, crypto::secret_key &dst, std::string &language_name)
	Converts seed words to bytes (secret key).
bool	bytes_to_words (const char *src, size_t len, epee::wipeable_string &words, const std::string &language_name)
	Converts bytes (secret key) to seed words.
bool	bytes_to_words (const crypto::secret_key &src, epee::wipeable_string &words, const std::string &language_name)
	Converts bytes (secret key) to seed words.
void	get_language_list (std::vector< std::string > &languages, bool english)
	Gets a list of seed languages that are supported.
bool	get_is_old_style_seed (const epee::wipeable_string &seed)
	Tells if the seed passed is an old style seed or not.
std::string	get_english_name_for (const std::string &name)
	Returns the name of a language in English.

Variables
const int	seed_length = 24
const std::string	old_language_name = "EnglishOld"

Detailed Description

Mnemonic seed word generation and wallet restoration helper functions.

Function Documentation

bytes_to_words() [1/2]

bool crypto::ElectrumWords::bytes_to_words	(	const char *	src,
		size_t	len,
		epee::wipeable_string &	words,
		const std::string &	language_name )

Converts bytes (secret key) to seed words.

Converts bytes to seed words.

Parameters

src	Secret key
words	Space delimited concatenated words get written here.
language_name	Seed language name

Returns

true if successful false if not. Unsuccessful if wrong key size.

Parameters

src	Secret data
len	Secret data length in bytes (positive multiples of 4 only)
words	Space delimited concatenated words get written here.
language_name	Seed language name

Returns

true if successful false if not. Unsuccessful if wrong key size.

Definition at line 383 of file electrum-words.cpp.

    {
 
      if (len % 4 != 0 || len == 0) return false;
 
      const Language::Base *language = NULL;
      const std::vector<const Language::Base*> language_list = crypto::ElectrumWords::get_language_list();
      for (const Language::Base *l: language_list)
      {
        if (language_name == l->get_language_name() || language_name == l->get_english_language_name())
          language = l;
      }
      if (!language)
      {
        return false;
      }
      const std::vector<std::string> &word_list = language->get_word_list();
      // To store the words for random access to add the checksum word later.
      std::vector<epee::wipeable_string> words_store;
 
      uint32_t word_list_length = word_list.size();
      // 4 bytes -> 3 words.  8 digits base 16 -> 3 digits base 1626
      for (unsigned int i=0; i < len/4; i++, words.push_back(' '))
      {
        uint32_t w[4];
 
        w[0] = SWAP32LE(*(const uint32_t*)(src + (i * 4)));
 
        w[1] = w[0] % word_list_length;
        w[2] = ((w[0] / word_list_length) + w[1]) % word_list_length;
        w[3] = (((w[0] / word_list_length) / word_list_length) + w[2]) % word_list_length;
 
        words += word_list[w[1]];
        words += ' ';
        words += word_list[w[2]];
        words += ' ';
        words += word_list[w[3]];
 
        words_store.push_back(word_list[w[1]]);
        words_store.push_back(word_list[w[2]]);
        words_store.push_back(word_list[w[3]]);
 
        memwipe(w, sizeof(w));
      }
 
      words += words_store[create_checksum_index(words_store, language)];
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bytes_to_words() [2/2]

bool crypto::ElectrumWords::bytes_to_words	(	const crypto::secret_key &	src,
		epee::wipeable_string &	words,
		const std::string &	language_name )

Converts bytes (secret key) to seed words.

Parameters

src	Secret key
words	Space delimited concatenated words get written here.
language_name	Seed language name

Returns

true if successful false if not. Unsuccessful if wrong key size.

Definition at line 433 of file electrum-words.cpp.

    {
      return bytes_to_words(src.data, sizeof(src), words, language_name);
    }

Here is the call graph for this function:

get_english_name_for()

std::string crypto::ElectrumWords::get_english_name_for

(

const std::string &

name

)

Returns the name of a language in English.

Parameters

name	the name of the language in its own language

Returns

the name of the language in English

Definition at line 484 of file electrum-words.cpp.

    {
      const std::vector<const Language::Base*> language_instances = get_language_list();
      for (std::vector<const Language::Base*>::const_iterator it = language_instances.begin();
        it != language_instances.end(); it++)
      {
        if ((*it)->get_language_name() == name)
          return (*it)->get_english_language_name();
      }
      return "<language not found>";
    }

Here is the call graph for this function:

get_is_old_style_seed()

bool crypto::ElectrumWords::get_is_old_style_seed

(

const epee::wipeable_string &

seed

)

Tells if the seed passed is an old style seed or not.

Parameters

seed	The seed to check (a space delimited concatenated word list)

Returns

true if the seed passed is a old style seed false if not.

Definition at line 477 of file electrum-words.cpp.

    {
      std::vector<epee::wipeable_string> word_list;
      seed.split(word_list);
      return word_list.size() != (seed_length + 1);
    }

Here is the call graph for this function:

get_language_list() [1/2]

std::vector< const Language::Base * > crypto::ElectrumWords::get_language_list

(

)

Definition at line 439 of file electrum-words.cpp.

    {
      static const std::vector<const Language::Base*> language_instances({
        Language::Singleton<Language::German>::instance(),
        Language::Singleton<Language::English>::instance(),
        Language::Singleton<Language::Spanish>::instance(),
        Language::Singleton<Language::French>::instance(),
        Language::Singleton<Language::Italian>::instance(),
        Language::Singleton<Language::Dutch>::instance(),
        Language::Singleton<Language::Portuguese>::instance(),
        Language::Singleton<Language::Russian>::instance(),
        Language::Singleton<Language::Japanese>::instance(),
        Language::Singleton<Language::Chinese_Simplified>::instance(),
        Language::Singleton<Language::Esperanto>::instance(),
        Language::Singleton<Language::Lojban>::instance()
      });
      return language_instances;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_language_list() [2/2]

void crypto::ElectrumWords::get_language_list	(	std::vector< std::string > &	languages,
		bool	english )

Gets a list of seed languages that are supported.

Parameters

languages	The vector is set to the list of languages.
languages	A vector is set to the list of languages.
english	whether to get the names in English or the language language

Definition at line 462 of file electrum-words.cpp.

    {
      const std::vector<const Language::Base*> language_instances = get_language_list();
      for (std::vector<const Language::Base*>::const_iterator it = language_instances.begin();
        it != language_instances.end(); it++)
      {
        languages.push_back(english ? (*it)->get_english_language_name() : (*it)->get_language_name());
      }
    }

Here is the call graph for this function:

words_to_bytes() [1/2]

bool crypto::ElectrumWords::words_to_bytes	(	const epee::wipeable_string &	words,
		crypto::secret_key &	dst,
		std::string &	language_name )

Converts seed words to bytes (secret key).

Parameters

words	String containing the words separated by spaces.
dst	To put the secret key restored from the words.
language_name	Language of the seed as found gets written here.

Returns

false if not a multiple of 3 words, or if word is not in the words list

Definition at line 358 of file electrum-words.cpp.

    {
      epee::wipeable_string s;
      if (!words_to_bytes(words, s, sizeof(dst), true, language_name))
      {
        MERROR("Invalid seed: failed to convert words to bytes");
        return false;
      }
      if (s.size() != sizeof(dst))
      {
        MERROR("Invalid seed: wrong output size");
        return false;
      }
      dst = *(const crypto::secret_key*)s.data();
      return true;
    }

Here is the call graph for this function:

words_to_bytes() [2/2]

bool crypto::ElectrumWords::words_to_bytes	(	const epee::wipeable_string &	words,
		epee::wipeable_string &	dst,
		size_t	len,
		bool	duplicate,
		std::string &	language_name )

Converts seed words to bytes (secret key).

Parameters

words	String containing the words separated by spaces.
dst	To put the secret data restored from the words.
len	The number of bytes to expect, 0 if unknown
duplicate	If true and len is not zero, we accept half the data, and duplicate it
language_name	Language of the seed as found gets written here.

Returns

false if not a multiple of 3 words, or if word is not in the words list

Definition at line 266 of file electrum-words.cpp.

    {
      std::vector<epee::wipeable_string> seed;
 
      words.split(seed);
 
      if (len % 4)
      {
        MERROR("Invalid seed: not a multiple of 4");
        return false;
      }
 
      bool has_checksum = true;
      if (len)
      {
        // error on non-compliant word list
        const size_t expected = len * 8 * 3 / 32;
        if (seed.size() != expected/2 && seed.size() != expected &&
          seed.size() != expected + 1)
        {
          MERROR("Invalid seed: unexpected number of words");
          return false;
        }
 
        // If it is seed with a checksum.
        has_checksum = seed.size() == (expected + 1);
      }
 
      std::vector<uint32_t> matched_indices;
      auto wiper = epee::misc_utils::create_scope_leave_handler([&](){memwipe(matched_indices.data(), matched_indices.size() * sizeof(matched_indices[0]));});
      Language::Base *language;
      if (!find_seed_language(seed, has_checksum, matched_indices, &language))
      {
        MERROR("Invalid seed: language not found");
        return false;
      }
      language_name = language->get_language_name();
      uint32_t word_list_length = language->get_word_list().size();
 
      if (has_checksum)
      {
        if (!checksum_test(seed, language))
        {
          // Checksum fail
          MERROR("Invalid seed: invalid checksum");
          return false;
        }
        seed.pop_back();
      }
 
      for (unsigned int i=0; i < seed.size() / 3; i++)
      {
        uint32_t w[4];
        w[1] = matched_indices[i*3];
        w[2] = matched_indices[i*3 + 1];
        w[3] = matched_indices[i*3 + 2];
 
        w[0]= w[1] + word_list_length * (((word_list_length - w[1]) + w[2]) % word_list_length) +
          word_list_length * word_list_length * (((word_list_length - w[2]) + w[3]) % word_list_length);
 
        if (!(w[0]% word_list_length == w[1]))
        {
          memwipe(w, sizeof(w));
          MERROR("Invalid seed: mumble mumble");
          return false;
        }
 
        w[0] = SWAP32LE(w[0]);
        dst.append((const char*)&w[0], 4);  // copy 4 bytes to position
        memwipe(w, sizeof(w));
      }
 
      if (len > 0 && duplicate)
      {
        const size_t expected = len * 3 / 32;
        if (seed.size() == expected/2)
        {
          dst.append(dst.data(), dst.size()); // if electrum 12-word seed, duplicate
        }
      }
 
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

old_language_name

const std::string crypto::ElectrumWords::old_language_name = "EnglishOld"

Definition at line 65 of file electrum-words.h.

seed_length

const int crypto::ElectrumWords::seed_length = 24

Definition at line 64 of file electrum-words.h.