What changed, and why it matters
This Monero update lets wallet software decode a recovery seed using a specific language the user provides, rather than always guessing the language automatically. Some words exist in multiple language word lists, so the same seed phrase can produce different wallets depending on which language is used. The change is meant to prevent users from accidentally restoring the wrong wallet when their seed is valid in more than one language. It also lets the wallet RPC server try alternative languages when verifying a seed against an existing wallet.
Treat this as a defensive hardening/reliability improvement rather than an active vulnerability patch. Reviewers should verify that the casefolding helper handles empty and invalid UTF-8 strings safely, that the fallback logic in `words_to_bytes_ex` cannot be induced to silently select a wrong-but-matching key, and that RPC callers cannot abuse the language hint to bypass seed verification. No immediate emergency response is indicated by the diff alone.
Security signals we found
Ambiguous mnemonic decoding across languages can produce a different valid secret key than the user intended
New explicit-language parameter restricts decoding to a single language, reducing cross-language ambiguity
Wallet RPC seed verification now compares derived spend public key against the wallet's known public key before accepting a seed
Functional and unit tests demonstrate same 25-word seed decoding to different keys under English vs Spanish
Casefolding of language names may introduce normalization edge cases
Evidence from the diff
The commit adds an optional expected_language parameter to the Electrum mnemonic decoding functions in electrum-words.cpp/.h. When supplied, decoding is restricted to that language (with UTF-8 case-insensitive matching against both native and English language names). words_to_bytes_ex additionally falls back to automatic detection if the explicit hint is unsupported, and for 25-word legacy seeds it can re-decode using the hint when the initial decoding differs from the stored language. simplewallet and the wallet RPC server now pass the user-supplied or stored seed language through. The RPC server’s stop_background_sync path now also re-derives the spend key and checks it against the wallet’s spend public key, retrying with language hints if the first decode does not match.
Changed components
src/mnemonics/electrum-words.cppsrc/mnemonics/electrum-words.hsrc/simplewallet/simplewallet.cppsrc/wallet/wallet_rpc_server.cpptests/unit_tests/mnemonics.cpptests/functional_tests/wallet.pyInspect captured patch +381 / −25
### src/mnemonics/electrum-words.cpp
@@ -40,6 +40,8 @@
#include <cstdint>
#include <vector>
#include <unordered_map>
+#include <memory>
+#include <utf8proc.h>
#include "scope_guard.h"
#include "wipeable_string.h"
#include "int-util.h"
@@ -78,6 +80,42 @@ namespace
uint32_t create_checksum_index(const std::vector<epee::wipeable_string> &word_list,
const Language::Base *language);
bool checksum_test(std::vector<epee::wipeable_string> seed, const Language::Base *language);
+ bool language_is_expected(const Language::Base *language, const std::string *expected_language);
+
+ std::string casefold_language_name(const std::string &name)
+ {
+ if (name.empty())
+ return {};
+ utf8proc_uint8_t *result = nullptr;
+ const auto size = utf8proc_map(reinterpret_cast<const utf8proc_uint8_t*>(name.data()), name.size(),
+ &result, static_cast<utf8proc_option_t>(UTF8PROC_STABLE | UTF8PROC_COMPOSE | UTF8PROC_CASEFOLD));
+ if (size < 0)
+ return {};
+ std::unique_ptr<utf8proc_uint8_t, decltype(&utf8proc_free)> owner(result, &utf8proc_free);
+ return std::string(reinterpret_cast<const char*>(result), size);
+ }
+
+ bool language_name_matches(const std::string &name, const std::string &candidate)
+ {
+ if (name == candidate)
+ return true;
+ const std::string folded = casefold_language_name(name);
+ return !folded.empty() && folded == casefold_language_name(candidate);
+ }
+
+ bool language_is_expected(const Language::Base *language, const std::string *expected_language)
+ {
+ return !expected_language || language_name_matches(*expected_language, language->get_language_name()) ||
+ language_name_matches(*expected_language, language->get_english_language_name());
+ }
+
+ bool is_supported_legacy_language(const std::string &name)
+ {
+ for (const Language::Base *language: crypto::ElectrumWords::get_language_list())
+ if (language_is_expected(language, &name))
+ return true;
+ return false;
+ }
/*!
* \brief Finds the word list that contains the seed words and puts the indices
@@ -89,7 +127,8 @@ namespace
* \return true if all the words were present in some language false if not.
*/
bool find_seed_language(const std::vector<epee::wipeable_string> &seed,
- bool has_checksum, std::vector<uint32_t> &matched_indices, Language::Base **language)
+ bool has_checksum, std::vector<uint32_t> &matched_indices, Language::Base **language,
+ const std::string *expected_language = NULL)
{
// If there's a new language added, add an instance of it here.
std::vector<Language::Base*> language_instances({
@@ -116,6 +155,9 @@ namespace
for (std::vector<Language::Base*>::iterator it1 = language_instances.begin();
it1 != language_instances.end(); it1++)
{
+ if (!language_is_expected(*it1, expected_language))
+ continue;
+
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
@@ -263,6 +305,12 @@ namespace crypto
*/
bool words_to_bytes(const epee::wipeable_string &words, epee::wipeable_string& dst, size_t len, bool duplicate,
std::string &language_name)
+ {
+ return words_to_bytes(words, dst, len, duplicate, language_name, std::string());
+ }
+
+ bool words_to_bytes(const epee::wipeable_string &words, epee::wipeable_string& dst, size_t len, bool duplicate,
+ std::string &language_name, const std::string &expected_language)
{
std::vector<epee::wipeable_string> seed;
@@ -294,9 +342,11 @@ namespace crypto
const epee::scope_guard wiper([&](){
memwipe(matched_indices.data(), matched_indices.size() * sizeof(matched_indices[0]));});
Language::Base *language;
- if (!find_seed_language(seed, has_checksum, matched_indices, &language))
+ const std::string *language_hint = expected_language.empty() ? NULL : &expected_language;
+ if (!find_seed_language(seed, has_checksum, matched_indices, &language, language_hint))
{
- MERROR("Invalid seed: language not found");
+ if (expected_language.empty())
+ MERROR("Invalid seed: language not found");
return false;
}
language_name = language->get_language_name();
@@ -356,11 +406,18 @@ namespace crypto
*/
bool words_to_bytes(const epee::wipeable_string &words, crypto::secret_key& dst,
std::string &language_name)
+ {
+ return words_to_bytes(words, dst, language_name, std::string());
+ }
+
+ bool words_to_bytes(const epee::wipeable_string &words, crypto::secret_key& dst,
+ std::string &language_name, const std::string &expected_language)
{
epee::wipeable_string s;
- if (!words_to_bytes(words, s, sizeof(dst), true, language_name))
+ if (!words_to_bytes(words, s, sizeof(dst), true, language_name, expected_language))
{
- MERROR("Invalid seed: failed to convert words to bytes");
+ if (expected_language.empty())
+ MERROR("Invalid seed: failed to convert words to bytes");
return false;
}
if (s.size() != sizeof(dst))
@@ -398,6 +455,13 @@ namespace crypto
bool words_to_bytes_ex(const epee::wipeable_string &words, crypto::secret_key& dst,
std::string &language_name, bool &is_polyseed, polyseed::data &polyseed)
+ {
+ return words_to_bytes_ex(words, dst, language_name, is_polyseed, polyseed, std::string());
+ }
+
+ bool words_to_bytes_ex(const epee::wipeable_string &words, crypto::secret_key& dst,
+ std::string &language_name, bool &is_polyseed, polyseed::data &polyseed,
+ const std::string &expected_legacy_language)
{
is_polyseed = false;
polyseed::language polyseed_language;
@@ -429,7 +493,23 @@ namespace crypto
return true;
}
- return words_to_bytes(normalized_words, dst, language_name);
+ std::vector<epee::wipeable_string> seed_words;
+ normalized_words.split(seed_words);
+ const bool decoded = words_to_bytes(normalized_words, dst, language_name);
+ if (seed_words.size() != seed_length + 1 ||
+ !is_supported_legacy_language(expected_legacy_language) ||
+ (decoded && language_name == old_language_name))
+ return decoded;
+
+ crypto::secret_key alternative_key;
+ std::string alternative_language;
+ if (words_to_bytes(normalized_words, alternative_key, alternative_language, expected_legacy_language))
+ {
+ dst = alternative_key;
+ language_name = alternative_language;
+ return true;
+ }
+ return decoded;
}
/*!
### src/mnemonics/electrum-words.h
@@ -74,6 +74,18 @@ namespace crypto
*/
bool words_to_bytes(const epee::wipeable_string &words, epee::wipeable_string& dst, size_t len, bool duplicate,
std::string &language_name);
+ /*!
+ * \brief Converts seed words to bytes (secret key).
+ * \param words String containing the words separated by spaces.
+ * \param dst To put the secret data restored from the words.
+ * \param len The number of bytes to expect, 0 if unknown
+ * \param duplicate If true and len is not zero, we accept half the data, and duplicate it
+ * \param language_name Language of the seed as found gets written here.
+ * \param expected_language Language to use for decoding instead of inferring from the seed.
+ * \return false if not a multiple of 3 words, or if word is not in the words list
+ */
+ bool words_to_bytes(const epee::wipeable_string &words, epee::wipeable_string& dst, size_t len, bool duplicate,
+ std::string &language_name, const std::string &expected_language);
/*!
* \brief Converts seed words to bytes (secret key).
* \param words String containing the words separated by spaces.
@@ -83,6 +95,16 @@ namespace crypto
*/
bool words_to_bytes(const epee::wipeable_string &words, crypto::secret_key& dst,
std::string &language_name);
+ /*!
+ * \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.
+ * \param expected_language Language to use for decoding instead of inferring from the seed.
+ * \return false if not a multiple of 3 words, or if word is not in the words list
+ */
+ bool words_to_bytes(const epee::wipeable_string &words, crypto::secret_key& dst,
+ std::string &language_name, const std::string &expected_language);
/*!
* \brief Converts seed words to bytes (secret key), with Polyseed support.
@@ -95,6 +117,13 @@ namespace crypto
*/
bool words_to_bytes_ex(const epee::wipeable_string &words, crypto::secret_key& dst,
std::string &language_name, bool &is_polyseed, polyseed::data &polyseed);
+ /*!
+ * \brief Converts seed words to bytes, selecting another valid decoding of a 25-word legacy seed when requested.
+ * \param expected_legacy_language Preferred language for ambiguous 25-word legacy seeds; ignored for Polyseed and deprecated seeds.
+ */
+ bool words_to_bytes_ex(const epee::wipeable_string &words, crypto::secret_key& dst,
+ std::string &language_name, bool &is_polyseed, polyseed::data &polyseed,
+ const std::string &expected_legacy_language);
/*!
* \brief Converts bytes to seed words.
### src/simplewallet/simplewallet.cpp
@@ -4040,7 +4040,8 @@ bool simple_wallet::init(const boost::program_options::variables_map& vm)
}
else
{
- if (!crypto::ElectrumWords::words_to_bytes_ex(m_electrum_seed, m_recovery_key, old_language, is_polyseed, polyseed))
+ if (!crypto::ElectrumWords::words_to_bytes_ex(m_electrum_seed, m_recovery_key, old_language,
+ is_polyseed, polyseed, m_mnemonic_language))
{
fail_msg_writer() << tr("Mnemonic seed failed verification");
return false;
### src/wallet/wallet_rpc_server.cpp
@@ -2553,30 +2553,70 @@ namespace tools
bool is_polyseed = false;
polyseed::data polyseed(POLYSEED_MONERO);
- if (!crypto::ElectrumWords::words_to_bytes_ex(req.seed, recovery_key, language, is_polyseed, polyseed))
+ bool decoded = crypto::ElectrumWords::words_to_bytes_ex(req.seed, recovery_key, language, is_polyseed, polyseed);
+ bool matching_key = false;
+ if (decoded)
{
- er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
- er.message = "Mnemonic seed failed verification";
- return false;
- }
+ if (!req.seed_offset.empty() && !is_polyseed)
+ recovery_key = cryptonote::decrypt_key(recovery_key, req.seed_offset);
- if (!req.seed_offset.empty() && !is_polyseed)
- recovery_key = cryptonote::decrypt_key(recovery_key, req.seed_offset);
+ cryptonote::account_base account;
+ if (is_polyseed)
+ {
+ crypto::secret_key polyseed_spend_key = polyseed.generate_secret_key(req.seed_offset);
+ crypto::secret_key polyseed_storage;
+ polyseed.save(&polyseed_storage);
+ account.create_from_polyseed(polyseed_spend_key, polyseed_storage, polyseed.birthday());
+ }
+ else
+ {
+ account.generate(recovery_key, true, false);
+ }
+ spend_secret_key = account.get_keys().m_spend_secret_key;
+ matching_key = account.get_keys().m_account_address.m_spend_public_key ==
+ m_wallet->get_account().get_keys().m_account_address.m_spend_public_key;
+ }
- // generate spend key
- cryptonote::account_base account;
- if (is_polyseed)
+ // An existing wallet's spend public key can resolve a 25-word legacy seed
+ // even when automatic decoding failed or the wallet has no seed language.
+ if (!matching_key && !is_polyseed &&
+ !crypto::ElectrumWords::get_is_old_style_seed(crypto::ElectrumWords::normalize_mnemonic(req.seed)))
{
- crypto::secret_key spend_secret_key = polyseed.generate_secret_key(req.seed_offset);
- crypto::secret_key polyseed_storage;
- polyseed.save(&polyseed_storage);
- account.create_from_polyseed(spend_secret_key, polyseed_storage, polyseed.birthday());
+ std::vector<std::string> languages;
+ if (!m_wallet->get_seed_language().empty())
+ languages.push_back(m_wallet->get_seed_language());
+ crypto::ElectrumWords::get_language_list(languages, true, false);
+
+ for (const std::string &hint: languages)
+ {
+ crypto::secret_key hinted_recovery_key;
+ std::string hinted_language;
+ bool hinted_is_polyseed = false;
+ polyseed::data hinted_polyseed(POLYSEED_MONERO);
+ if (!crypto::ElectrumWords::words_to_bytes_ex(req.seed, hinted_recovery_key, hinted_language,
+ hinted_is_polyseed, hinted_polyseed, hint) || hinted_is_polyseed)
+ continue;
+
+ if (!req.seed_offset.empty())
+ hinted_recovery_key = cryptonote::decrypt_key(hinted_recovery_key, req.seed_offset);
+ cryptonote::account_base hinted_account;
+ hinted_account.generate(hinted_recovery_key, true, false);
+ if (hinted_account.get_keys().m_account_address.m_spend_public_key ==
+ m_wallet->get_account().get_keys().m_account_address.m_spend_public_key)
+ {
+ spend_secret_key = hinted_account.get_keys().m_spend_secret_key;
+ matching_key = true;
+ break;
+ }
+ }
}
- else
+
+ if (!decoded && !matching_key)
{
- account.generate(recovery_key, true, false);
+ er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+ er.message = "Mnemonic seed failed verification";
+ return false;
}
- spend_secret_key = account.get_keys().m_spend_secret_key;
}
m_wallet->stop_background_sync(req.wallet_password, spend_secret_key);
@@ -4265,7 +4305,8 @@ namespace tools
// check the given seed
if (!req.enable_multisig_experimental) {
- if (!crypto::ElectrumWords::words_to_bytes_ex(req.seed, recovery_key, old_language, is_polyseed, polyseed))
+ if (!crypto::ElectrumWords::words_to_bytes_ex(req.seed, recovery_key, old_language,
+ is_polyseed, polyseed, req.language))
{
er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
er.message = "Mnemonic seed failed verification";
### tests/functional_tests/wallet.py
@@ -111,6 +111,76 @@ def create(self):
# Don't check the returned legacy seed against the Polyseed, it's of course different
wallet.close_wallet()
+ print('Checking explicit language for an ambiguous legacy seed')
+ seed = ' '.join(['pluma'] * 25)
+ wallet.restore_deterministic_wallet(seed = seed)
+ assert wallet.query_key('spend_key').key == '3b040000' * 8
+ wallet.close_wallet()
+ wallet.restore_deterministic_wallet(seed = seed, language = 'Spanish')
+ assert wallet.query_key('spend_key').key == 'b4050000' * 8
+ wallet.close_wallet()
+ wallet.restore_deterministic_wallet(seed = seed, language = 'español')
+ assert wallet.query_key('spend_key').key == 'b4050000' * 8
+ wallet.setup_background_sync(background_sync_type = wallet.background_sync_options.reuse_password)
+ wallet.start_background_sync()
+ wallet.stop_background_sync(wallet_password = '', seed = seed.replace(' ', ' ', 1))
+ assert wallet.query_key('spend_key').key == 'b4050000' * 8
+ spanish_address = wallet.get_address().address
+ spanish_spend_key = wallet.query_key('spend_key').key
+ spanish_view_key = wallet.query_key('view_key').key
+ wallet.close_wallet()
+
+ wallet.generate_from_keys(address = spanish_address, spendkey = spanish_spend_key,
+ viewkey = spanish_view_key)
+ wallet.setup_background_sync(background_sync_type = wallet.background_sync_options.reuse_password)
+ wallet.start_background_sync()
+ wallet.stop_background_sync(wallet_password = '', seed = seed)
+ assert wallet.query_key('spend_key').key == spanish_spend_key
+ wallet.close_wallet()
+
+ wallet.generate_from_keys(address = spanish_address, spendkey = spanish_spend_key,
+ viewkey = spanish_view_key, language = 'English')
+ wallet.setup_background_sync(background_sync_type = wallet.background_sync_options.reuse_password)
+ wallet.start_background_sync()
+ wallet.stop_background_sync(wallet_password = '', seed = seed)
+ assert wallet.query_key('spend_key').key == spanish_spend_key
+ wallet.close_wallet()
+
+ seed_offset = 'background sync test'
+ wallet.restore_deterministic_wallet(seed = seed, seed_offset = seed_offset, language = 'Spanish')
+ offset_address = wallet.get_address().address
+ offset_spend_key = wallet.query_key('spend_key').key
+ offset_view_key = wallet.query_key('view_key').key
+ wallet.close_wallet()
+ wallet.generate_from_keys(address = offset_address, spendkey = offset_spend_key,
+ viewkey = offset_view_key)
+ wallet.setup_background_sync(background_sync_type = wallet.background_sync_options.reuse_password)
+ wallet.start_background_sync()
+ wallet.stop_background_sync(wallet_password = '', seed = seed, seed_offset = seed_offset)
+ assert wallet.query_key('spend_key').key == offset_spend_key
+ wallet.close_wallet()
+
+ wallet.restore_deterministic_wallet(seed = seed)
+ address = wallet.get_address().address
+ spend_key = wallet.query_key('spend_key').key
+ view_key = wallet.query_key('view_key').key
+ wallet.close_wallet()
+ wallet.generate_from_keys(address = address, spendkey = spend_key, viewkey = view_key, language = 'Spanish')
+ wallet.setup_background_sync(background_sync_type = wallet.background_sync_options.reuse_password)
+ wallet.start_background_sync()
+ wallet.stop_background_sync(wallet_password = '', seed = seed)
+ assert wallet.query_key('spend_key').key == spend_key
+ wallet.close_wallet()
+
+ french_seed = 'jungle rapport rang koala pire demain soupe queue sondage essai rustre palace truite ficher neveu vent sorte puma membre affirmer borner notice papier pincer ficher'
+ wallet.restore_deterministic_wallet(seed = french_seed, language = 'French')
+ french_spend_key = wallet.query_key('spend_key').key
+ wallet.setup_background_sync(background_sync_type = wallet.background_sync_options.reuse_password)
+ wallet.start_background_sync()
+ wallet.stop_background_sync(wallet_password = '', seed = french_seed)
+ assert wallet.query_key('spend_key').key == french_spend_key
+ wallet.close_wallet()
+
print('Creating legacy seed wallet')
wallet = Wallet()
try: wallet.close_wallet()
### tests/unit_tests/mnemonics.cpp
@@ -50,6 +50,7 @@
#include "mnemonics/lojban.h"
#include "mnemonics/english_old.h"
#include "mnemonics/singleton.h"
+#include "string_tools.h"
namespace
{
@@ -207,6 +208,140 @@ TEST(mnemonics, language_detection_with_bad_checksum)
ASSERT_STREQ(language_name.c_str(), "Português");
}
+TEST(mnemonics, explicit_language_decoding)
+{
+ crypto::secret_key key;
+ std::string language_name;
+ bool res;
+
+ const std::string seed = "pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma pluma";
+
+ res = crypto::ElectrumWords::words_to_bytes(seed, key, language_name);
+ ASSERT_EQ(true, res);
+ ASSERT_STREQ(language_name.c_str(), "English");
+ ASSERT_EQ("3b0400003b0400003b0400003b0400003b0400003b0400003b0400003b040000",
+ epee::string_tools::pod_to_hex(unwrap(unwrap(key))));
+
+ res = crypto::ElectrumWords::words_to_bytes(seed, key, language_name, "Spanish");
+ ASSERT_EQ(true, res);
+ ASSERT_STREQ(language_name.c_str(), "Español");
+ ASSERT_EQ("b4050000b4050000b4050000b4050000b4050000b4050000b4050000b4050000",
+ epee::string_tools::pod_to_hex(unwrap(unwrap(key))));
+
+ bool is_polyseed = false;
+ polyseed::data polyseed(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(seed, key, language_name, is_polyseed, polyseed, "Spanish"));
+ ASSERT_FALSE(is_polyseed);
+ ASSERT_EQ("Español", language_name);
+ ASSERT_EQ("b4050000b4050000b4050000b4050000b4050000b4050000b4050000b4050000",
+ epee::string_tools::pod_to_hex(unwrap(unwrap(key))));
+
+ polyseed::data invalid_hint_polyseed(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(seed, key, language_name, is_polyseed,
+ invalid_hint_polyseed, "not a language"));
+ ASSERT_EQ("English", language_name);
+ ASSERT_EQ("3b0400003b0400003b0400003b0400003b0400003b0400003b0400003b040000",
+ epee::string_tools::pod_to_hex(unwrap(unwrap(key))));
+}
+
+TEST(mnemonics, explicit_language_after_failed_inference)
+{
+ const std::string seed = "jungle rapport rang koala pire demain soupe queue sondage essai rustre palace truite ficher neveu vent sorte puma membre affirmer borner notice papier pincer ficher";
+ crypto::secret_key key;
+ crypto::secret_key expected_key;
+ std::string language_name;
+ ASSERT_FALSE(crypto::ElectrumWords::words_to_bytes(seed, key, language_name));
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes(seed, expected_key, language_name, "French"));
+ ASSERT_EQ("Français", language_name);
+
+ for (const std::string &hint: {"French", "french", "français"})
+ {
+ bool is_polyseed = false;
+ polyseed::data decoded(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(seed, key, language_name,
+ is_polyseed, decoded, hint));
+ ASSERT_FALSE(is_polyseed);
+ ASSERT_EQ("Français", language_name);
+ ASSERT_EQ(expected_key, key);
+ }
+}
+
+TEST(mnemonics, explicit_language_falls_back_to_automatic)
+{
+ crypto::secret_key key;
+ crypto::secret_key expected_key;
+ std::string language_name;
+ bool is_polyseed = false;
+
+ const std::string short_seed = "plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus plus";
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes(short_seed, expected_key, language_name));
+ polyseed::data short_decoded(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(short_seed, key, language_name,
+ is_polyseed, short_decoded, "French"));
+ ASSERT_FALSE(is_polyseed);
+ ASSERT_EQ("English", language_name);
+ ASSERT_EQ(expected_key, key);
+
+ const std::string english_seed = "velvet lymph giddy number token physics poetry unquoted nibs useful sabotage limits benches lifestyle eden nitrogen anvil fewest avoid batch vials washing fences goat unquoted";
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes(english_seed, expected_key, language_name));
+ polyseed::data english_decoded(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(english_seed, key, language_name,
+ is_polyseed, english_decoded, "German"));
+ ASSERT_FALSE(is_polyseed);
+ ASSERT_EQ("English", language_name);
+ ASSERT_EQ(expected_key, key);
+}
+
+TEST(mnemonics, native_language_hint_casefold)
+{
+ crypto::secret_key original{};
+ original.data[0] = 1;
+ epee::wipeable_string seed;
+ ASSERT_TRUE(crypto::ElectrumWords::bytes_to_words(original, seed, "Русский"));
+
+ crypto::secret_key restored;
+ std::string language_name;
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes(seed, restored, language_name, "русский"));
+ ASSERT_EQ("Русский", language_name);
+ ASSERT_EQ(original, restored);
+}
+
+TEST(mnemonics, language_hint_preserves_deprecated_and_polyseed)
+{
+ std::string old_words;
+ for (size_t i = 0; i < 25; ++i)
+ old_words += i == 0 ? "eye" : " eye";
+
+ crypto::secret_key restored;
+ std::string language_name;
+ bool is_polyseed = false;
+ polyseed::data old_seed(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(old_words, restored, language_name,
+ is_polyseed, old_seed, "Spanish"));
+ ASSERT_FALSE(is_polyseed);
+ ASSERT_EQ("EnglishOld", language_name);
+ const std::string expected_key = epee::string_tools::pod_to_hex(unwrap(unwrap(restored)));
+
+ std::string no_checksum(old_words);
+ no_checksum.erase(no_checksum.find_last_of(' '));
+ polyseed::data old_seed_no_checksum(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(no_checksum, restored, language_name,
+ is_polyseed, old_seed_no_checksum, "Spanish"));
+ ASSERT_FALSE(is_polyseed);
+ ASSERT_EQ("EnglishOld", language_name);
+ ASSERT_EQ(expected_key, epee::string_tools::pod_to_hex(unwrap(unwrap(restored))));
+
+ polyseed::data created(POLYSEED_MONERO);
+ created.create(0, polyseed::get_lang_by_name("English"));
+ epee::wipeable_string polyseed_words;
+ created.encode(polyseed::get_lang_by_name("English"), polyseed_words);
+ polyseed::data decoded(POLYSEED_MONERO);
+ ASSERT_TRUE(crypto::ElectrumWords::words_to_bytes_ex(polyseed_words, restored, language_name,
+ is_polyseed, decoded, "Spanish"));
+ ASSERT_TRUE(is_polyseed);
+ ASSERT_EQ("English", language_name);
+}
+
TEST(mnemonics, utf8prefix)
{
ASSERT_TRUE(Language::utf8prefix(epee::wipeable_string("foo"), 0) == "");Why this scored 47/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.