29:I[49813,["/_next/static/chunks/3z--bwudlglfp.js","/_next/static/chunks/2u04xn-9yg2co.js","/_next/static/chunks/1b5-8ftwqgmtb.js","/_next/static/chunks/3nqo6bdos11l6.js","/_next/static/chunks/0fz0mlrjifmq7.js","/_next/static/chunks/034_kq3j28m99.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/3meo7law-jljp.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2a:T3497,/** * Copyright (c) 2011-2026 libbitcoin developers * * This file is part of libbitcoin. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ #include #include #include #include #include #include #include #include #include namespace libbitcoin { namespace system { namespace wallet { // Helper class for managing decoding overflow bug. // ============================================================================ // github.com/spesmilo/electrum/issues/3149 // "While (32-long) hex seeds necessarily map to (12-long) seed // words/"mnemonics", the inverse is not always true. For example, 'hurry idiot // prefer sunset mention mist jaw inhale impossible kingdom rare squeeze' // maps to 025d2f2d005036911003ca78900ca155c (33 chars)." // By word triplet this is: [025d2f2d][00503691][1003ca789][00ca155c], where // 'jaw inhale impossible' maps to 1003ca789 (33 bits, overflowing uint32). // It is the distance between words that creates the overflow. // Electrum v1 failed to catch this overflow, so "old seed" checks presently // allow it, despite the invalidity. In other words, any list of 12/24 electrum // v1 (en) words is considered valid v1 by later versions of electrum. It // passes the decoded entropy to the strecher, creating the master private key // despite the error. These seed words cannot be recovered from entropy as the // encoding algorithm only parses 32 bits of entropy for each word triplet. // But electrum itself cannot round trip these seeds, so we do not support it. // Electrum concatenates hex characters for each triplet. // The result can be an odd number of characters (9 total max). // print('%08x' % x) emits >= 8 hex characters, and can be odd length. v1_decoding::v1_decoding() NOEXCEPT : v1_decoding({}, {}) { } v1_decoding::v1_decoding(const data_chunk& entropy) NOEXCEPT : v1_decoding(entropy, {}) { } v1_decoding::v1_decoding(const data_chunk& entropy, const overflow& overflows) NOEXCEPT : entropy_(entropy), overflows_(overflows) { } const data_chunk& v1_decoding::entropy() const NOEXCEPT { return entropy_; } const v1_decoding::overflow& v1_decoding::overflows() const NOEXCEPT { return overflows_; } // Electrum hashes the base16 encoded ascii *text* of the seed. data_chunk v1_decoding::seed_entropy() const NOEXCEPT { // overflows is empty for entropy constructions. if (overflows_.empty()) return to_chunk(encode_base16(entropy_)); // overflow count must always be the count of entropy uint32_t. if (overflows_.size() * sizeof(uint32_t) != entropy_.size()) return {}; read::bytes::copy in(entropy_); auto it = overflows_.cbegin(); std::string hexadecimal; while (!in.is_exhausted()) { // This is a big-endian read of a big-endian byte stream. const auto value = in.read_bytes(sizeof(uint32_t)); // This inserts any overflow bits. // See comments on the decoder overflow bug. hexadecimal.append((*it++ ? "1" : "") + encode_base16(value)); } return to_chunk(hexadecimal); } // ============================================================================ // Guard: decoder 'value' cannot exceed 0x1003ca7a7, safe in int64_t but can // overflow int32_t/uint32_t. Only one bit (0x[1][003ca7a7]) can overflow. // So we upcast indexes to int64 and later check the result for overflow. static_assert((1625 * 1) + (1625 * 1626) + (1625 * 1626 * 1626ll) == 0x1003ca7a7, "upper bound on electrum_v1 decoded triplet"); // local constants // ---------------------------------------------------------------------------- constexpr auto size = electrum_v1::dictionary::size(); constexpr auto size0 = power(0u); constexpr auto size1 = power(1u); constexpr auto size2 = power(2u); // private static // ---------------------------------------------------------------------------- const electrum_v1::dictionaries electrum_v1::dictionaries_ { { electrum_v1::dictionary{ language::en, words::electrum_v1::en }, electrum_v1::dictionary{ language::pt, words::electrum_v1::pt } } }; // protected static (coders) // ---------------------------------------------------------------------------- // electrum/old_mnemonic.py#L1669 string_list electrum_v1::encoder(const data_chunk& entropy, language identifier) NOEXCEPT { string_list words; words.reserve(word_count(entropy)); read::bytes::copy reader(entropy); while (!reader.is_exhausted()) { // Guard: entropy verified as multiples of four bytes. // Guard: below cannot overflow even if this reads max_uint32. const int64_t value = reader.read_4_bytes_big_endian(); // [(value/size0 + 0)%size1] is a nop, shown for consistency. // Pos quotient integer div/mod is floor in C++ and python[2/3]. const auto uno = (floored_divide(value, size0) + 0x0) % size1; const auto dos = (floored_divide(value, size1) + uno) % size1; const auto tre = (floored_divide(value, size2) + dos) % size1; // Guard: dictionary membership has been verified. // Guard: any positive number modulo 1626 is always [0-1625]. words.push_back(dictionaries_.at( possible_narrow_sign_cast(uno), identifier)); words.push_back(dictionaries_.at( possible_narrow_sign_cast(dos), identifier)); words.push_back(dictionaries_.at( possible_narrow_sign_cast(tre), identifier)); } return words; } // electrum/old_mnemonic.py#L1682 v1_decoding electrum_v1::decoder(const string_list& words, language identifier) NOEXCEPT { data_chunk entropy; entropy.reserve(entropy_size(words)); write::bytes::data out(entropy); // See comments above on electrum v1 decoder overflow bug. v1_decoding::overflow overflows(words.size() / word_multiple); auto overflow = overflows.begin(); // Word count and dictionary membership must have been validated. for (auto word = words.cbegin(); word != words.cend();) { // Electrum modulos dos and tri by size1, which is a nop. const int64_t uno = dictionaries_.index(*word++, identifier); const int64_t dos = dictionaries_.index(*word++, identifier); const int64_t tre = dictionaries_.index(*word++, identifier); // [floored_modulo(uno-0, size1)*size0] is a nop, shown for consistency. // Neg quotient integer div/mod is ceil in C++ and floor in python[2/3]. const auto value = floored_modulo(uno - 0x0, size1) * size0 + floored_modulo(dos - uno, size1) * size1 + floored_modulo(tre - dos, size1) * size2; // Overflow: if true then this mnemonic was not encoded from entropy. *overflow++ = is_greater(value, max_uint32); // Guard: floored modulo with positive divisor is always positive. // Casting away a non-zero (overflow bit) will prevent round trip. out.write_4_bytes_big_endian(possible_narrow_sign_cast(value)); } out.flush(); return { entropy, overflows }; } // electrum/keystore.py#L692 hash_digest electrum_v1::strecher(const data_chunk& seed_entropy) NOEXCEPT { constexpr size_t hash_iterations = 100000; data_chunk streched{ seed_entropy }; for (size_t count = 0; count < hash_iterations; ++count) streched = sha256_chunk(splice(streched, seed_entropy)); return unsafe_array_cast(streched.data()); } // protected static (sizers) // ---------------------------------------------------------------------------- size_t electrum_v1::entropy_bits(const data_slice& entropy) NOEXCEPT { return to_bits(entropy.size()); } size_t electrum_v1::entropy_bits(const string_list& words) NOEXCEPT { return (words.size() * sizeof(uint32_t)) / word_multiple; } size_t electrum_v1::entropy_size(const string_list& words) NOEXCEPT { return to_floored_bytes(entropy_bits(words)); } size_t electrum_v1::word_count(const data_slice& entropy) NOEXCEPT { return entropy_bits(entropy) / sizeof(uint32_t); } // public static // ---------------------------------------------------------------------------- language electrum_v1::contained_by(const string_list& words, language identifier) NOEXCEPT { return dictionaries_.contains(words, identifier); } bool electrum_v1::is_valid_dictionary(language identifier) NOEXCEPT { return dictionaries_.exists(identifier); } bool electrum_v1::is_valid_entropy_size(size_t value) NOEXCEPT { return value == entropy_minimum || value == entropy_maximum; } bool electrum_v1::is_valid_word_count(size_t count) NOEXCEPT { return count == word_minimum || count == word_maximum; } // construction // ---------------------------------------------------------------------------- electrum_v1::electrum_v1() NOEXCEPT : languages(), overflows_() { } electrum_v1::electrum_v1(const std::string& sentence, language identifier) NOEXCEPT : electrum_v1(split(sentence, identifier), identifier) { } electrum_v1::electrum_v1(const string_list& words, language identifier) NOEXCEPT : electrum_v1(from_words(words, identifier)) { } electrum_v1::electrum_v1(const data_chunk& entropy, language identifier) NOEXCEPT : electrum_v1(from_entropy(entropy, identifier)) { } electrum_v1::electrum_v1(const minimum_entropy& entropy, language identifier) NOEXCEPT : electrum_v1(from_entropy(to_chunk(entropy), identifier)) { } electrum_v1::electrum_v1(const maximum_entropy& entropy, language identifier) NOEXCEPT : electrum_v1(from_entropy(to_chunk(entropy), identifier)) { } // protected electrum_v1::electrum_v1(const data_chunk& entropy, const string_list& words, language identifier) NOEXCEPT : electrum_v1(v1_decoding(entropy), words, identifier) { } // protected electrum_v1::electrum_v1(const v1_decoding& decoding, const string_list& words, language identifier) NOEXCEPT : languages(decoding.entropy(), words, identifier), overflows_(decoding.overflows()) { } // protected static (factories) // ---------------------------------------------------------------------------- electrum_v1 electrum_v1::from_entropy(const data_chunk& entropy, language identifier) NOEXCEPT { if (!is_valid_entropy_size(entropy.size())) return {}; if (!dictionaries_.exists(identifier)) return {}; // Save entropy and derived words. return { entropy, encoder(entropy, identifier), identifier }; } electrum_v1 electrum_v1::from_words(const string_list& words, language identifier) NOEXCEPT { if (!is_valid_word_count(words.size())) return {}; // Normalize to improve chance of dictionary matching. const auto tokens = try_normalize(words); const auto lexicon = contained_by(tokens, identifier); if (lexicon == language::none) return {}; // Save derived entropy and dictionary words, originals are discarded. return { decoder(tokens, lexicon), tokens, lexicon }; } // overflow methods // ---------------------------------------------------------------------------- // Manage overflow bug and conversion to idiosyncratic textual seed data. // public bool electrum_v1::overflow() const NOEXCEPT { return std::any_of(overflows_.cbegin(), overflows_.cend(), [](bool value) { return value; }); } const v1_decoding::overflow& electrum_v1::overflows() const NOEXCEPT { return overflows_; } data_chunk electrum_v1::seed_entropy() const NOEXCEPT { return v1_decoding(entropy_, overflows_).seed_entropy(); } // public methods // ---------------------------------------------------------------------------- ec_private electrum_v1::to_seed(const context& context) const NOEXCEPT { if (!(*this)) return {}; // Set public key compression to false as is the electrum convention. // Causes derived payment addresses to use the uncompressed public key. constexpr auto compression = false; // Strech entropy into the seed, which is also the master private key. const auto seed = strecher(seed_entropy()); // Context sets the version byte for derived payment addresses. return { ec_scalar(seed), context.versions(), compression }; } ec_public electrum_v1::to_public_key(const context& context) const NOEXCEPT { if (!(*this)) return {}; return to_seed(context).to_public(); } } // namespace wallet } // namespace system } // namespace libbitcoin 12:["$","$L29",null,{"project":{"id":"cmuidb72x000001s1932ifphv","owner":"libbitcoin","repo":"libbitcoin-system","displayName":"libbitcoin/libbitcoin-system","defaultBranch":"master"},"commit":{"sha":"121d29eceaf821490dfef9f329758891c584ae57","message":"Disable clang-cl warnings in system headers.","authorLogin":"evoskuil","authorName":"Eric Voskuil","date":"2026-10-30T18:12:39.000Z","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/commit/121d29eceaf821490dfef9f329758891c584ae57","isHead":false,"headSha":"5e1386d3959012e423ad11fa89e9faaae66ade16"},"gitRef":"121d29eceaf821490dfef9f329758891c584ae57","path":"src/wallet/mnemonics/electrum_v1.cpp","target":{"kind":"file","file":{"path":"src/wallet/mnemonics/electrum_v1.cpp","size":13463,"content":"$2a","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/121d29eceaf821490dfef9f329758891c584ae57/src/wallet/mnemonics/electrum_v1.cpp","mutants":[],"mutantsAtOtherRevisions":0}},"treeCache":{"":[{"name":".github","path":".github","type":"dir","size":null},{"name":".vscode","path":".vscode","type":"dir","size":null},{"name":"builds","path":"builds","type":"dir","size":null},{"name":"doc","path":"doc","type":"dir","size":null},{"name":"include","path":"include","type":"dir","size":null},{"name":"src","path":"src","type":"dir","size":null},{"name":"test","path":"test","type":"dir","size":null},{"name":"tools","path":"tools","type":"dir","size":null},{"name":".gitignore","path":".gitignore","type":"file","size":1037},{"name":"COPYING","path":"COPYING","type":"file","size":33899},{"name":"README.md","path":"README.md","type":"file","size":9650}],"src":[{"name":"chain","path":"src/chain","type":"dir","size":null},{"name":"config","path":"src/config","type":"dir","size":null},{"name":"crypto","path":"src/crypto","type":"dir","size":null},{"name":"data","path":"src/data","type":"dir","size":null},{"name":"endian","path":"src/endian","type":"dir","size":null},{"name":"error","path":"src/error","type":"dir","size":null},{"name":"filter","path":"src/filter","type":"dir","size":null},{"name":"hash","path":"src/hash","type":"dir","size":null},{"name":"math","path":"src/math","type":"dir","size":null},{"name":"radix","path":"src/radix","type":"dir","size":null},{"name":"serial","path":"src/serial","type":"dir","size":null},{"name":"stream","path":"src/stream","type":"dir","size":null},{"name":"unicode","path":"src/unicode","type":"dir","size":null},{"name":"wallet","path":"src/wallet","type":"dir","size":null},{"name":"words","path":"src/words","type":"dir","size":null},{"name":"x509","path":"src/x509","type":"dir","size":null},{"name":"arena.cpp","path":"src/arena.cpp","type":"file","size":2137},{"name":"define.cpp","path":"src/define.cpp","type":"file","size":5804},{"name":"execution.cpp","path":"src/execution.cpp","type":"file","size":2110},{"name":"settings.cpp","path":"src/settings.cpp","type":"file","size":32380}],"src/wallet":[{"name":"addresses","path":"src/wallet/addresses","type":"dir","size":null},{"name":"keys","path":"src/wallet/keys","type":"dir","size":null},{"name":"mnemonics","path":"src/wallet/mnemonics","type":"dir","size":null},{"name":"psbt","path":"src/wallet/psbt","type":"dir","size":null},{"name":"context.cpp","path":"src/wallet/context.cpp","type":"file","size":1249},{"name":"descriptor.cpp","path":"src/wallet/descriptor.cpp","type":"file","size":22977},{"name":"message.cpp","path":"src/wallet/message.cpp","type":"file","size":5196},{"name":"neutrino.cpp","path":"src/wallet/neutrino.cpp","type":"file","size":7763},{"name":"point_value.cpp","path":"src/wallet/point_value.cpp","type":"file","size":2006},{"name":"points_value.cpp","path":"src/wallet/points_value.cpp","type":"file","size":4604}],"src/wallet/mnemonics":[{"name":"electrum_v1.cpp","path":"src/wallet/mnemonics/electrum_v1.cpp","type":"file","size":13463},{"name":"electrum.cpp","path":"src/wallet/mnemonics/electrum.cpp","type":"file","size":22151},{"name":"mnemonic.cpp","path":"src/wallet/mnemonics/mnemonic.cpp","type":"file","size":8833},{"name":"slip39.cpp","path":"src/wallet/mnemonics/slip39.cpp","type":"file","size":17211}]},"revisions":[{"commitSha":"c37c9b73278f1f97e6eb6421f3544f5e58edba2f","branch":null,"commitMessage":"Merge pull request #2132 from evoskuil/master","commitDate":"2026-10-29T20:40:10.000Z","mutantCount":36},{"commitSha":"9fa0f9a07f31c5cc9ebe5efa05e6d4a6d12ba183","branch":null,"commitMessage":"Test script pattern length guards and the sixteen key multisig builder boundary.","commitDate":"2026-09-29T18:05:00.000Z","mutantCount":129},{"commitSha":"98db5bfd7c7b65532e42309c7b71419d82ec5ea8","branch":null,"commitMessage":"Merge pull request #2017 from evoskuil/master","commitDate":"2026-09-28T17:24:16.000Z","mutantCount":230},{"commitSha":"827fb29d0fecbdf7a157e05b1bea59bc916787aa","branch":null,"commitMessage":"Test multisig sighash cache reset across distinct subscripts","commitDate":"2026-09-26T12:24:47.000Z","mutantCount":1},{"commitSha":"8e7a9fdcb4ca72bc5bfe9961815aaa9bc33b64a0","branch":null,"commitMessage":"Remove dead include.","commitDate":"2026-09-25T06:52:28.000Z","mutantCount":90}],"signedIn":false,"pullRequest":{"id":"cmvwrgy0h00ex01n1ycl8rckj","number":2134,"title":"Expanded CI coverage. (clang-cl, Arm, mac x64).","headSha":"121d29eceaf821490dfef9f329758891c584ae57","state":"MERGED","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/pull/2134","ranges":[],"fileInDiff":false,"atHead":true}}]