diff --git a/src/test/cashaddrenc_tests.cpp b/src/test/cashaddrenc_tests.cpp index 26d3df56f..3c4b906d7 100644 --- a/src/test/cashaddrenc_tests.cpp +++ b/src/test/cashaddrenc_tests.cpp @@ -1,248 +1,253 @@ // Copyright (c) 2017 The Bitcoin developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include "cashaddr.h" #include "cashaddrenc.h" #include "chainparams.h" #include "random.h" #include "test/test_bitcoin.h" #include "uint256.h" #include namespace { std::vector GetNetworks() { return {CBaseChainParams::MAIN, CBaseChainParams::TESTNET, CBaseChainParams::REGTEST}; } uint160 insecure_GetRandUInt160(FastRandomContext &rand) { uint160 n; for (uint8_t *c = n.begin(); c != n.end(); ++c) { *c = static_cast(rand.rand32()); } return n; } class DstTypeChecker : public boost::static_visitor { public: void operator()(const CKeyID &id) { isKey = true; } void operator()(const CScriptID &id) { isScript = true; } void operator()(const CNoDestination &) {} static bool IsScriptDst(const CTxDestination &d) { DstTypeChecker checker; boost::apply_visitor(checker, d); return checker.isScript; } static bool IsKeyDst(const CTxDestination &d) { DstTypeChecker checker; boost::apply_visitor(checker, d); return checker.isKey; } private: DstTypeChecker() : isKey(false), isScript(false) {} bool isKey; bool isScript; }; } // anon ns BOOST_FIXTURE_TEST_SUITE(cashaddrenc_tests, BasicTestingSetup) BOOST_AUTO_TEST_CASE(encode_decode) { std::vector toTest = {CNoDestination{}, CKeyID(uint160S("badf00d")), CScriptID(uint160S("f00dbad"))}; for (auto dst : toTest) { for (auto net : GetNetworks()) { std::string encoded = EncodeCashAddr(dst, Params(net)); CTxDestination decoded = DecodeCashAddr(encoded, Params(net)); BOOST_CHECK(dst == decoded); } } } // Check that an encoded cash address is not valid on another network. BOOST_AUTO_TEST_CASE(invalid_on_wrong_network) { const CTxDestination dst = CKeyID(uint160S("c0ffee")); const CTxDestination invalidDst = CNoDestination{}; for (auto net : GetNetworks()) { for (auto otherNet : GetNetworks()) { if (net == otherNet) continue; std::string encoded = EncodeCashAddr(dst, Params(net)); CTxDestination decoded = DecodeCashAddr(encoded, Params(otherNet)); BOOST_CHECK(decoded != dst); BOOST_CHECK(decoded == invalidDst); } } } BOOST_AUTO_TEST_CASE(random_dst) { FastRandomContext rand(true); const size_t NUM_TESTS = 5000; const CChainParams ¶ms = Params(CBaseChainParams::MAIN); for (size_t i = 0; i < NUM_TESTS; ++i) { uint160 hash = insecure_GetRandUInt160(rand); const CTxDestination dst_key = CKeyID(hash); const CTxDestination dst_scr = CScriptID(hash); const std::string encoded_key = EncodeCashAddr(dst_key, params); const CTxDestination decoded_key = DecodeCashAddr(encoded_key, params); const std::string encoded_scr = EncodeCashAddr(dst_scr, params); const CTxDestination decoded_scr = DecodeCashAddr(encoded_scr, params); std::string err("cashaddr failed for hash: "); err += hash.ToString(); BOOST_CHECK_MESSAGE(dst_key == decoded_key, err); BOOST_CHECK_MESSAGE(dst_scr == decoded_scr, err); BOOST_CHECK_MESSAGE(DstTypeChecker::IsKeyDst(decoded_key), err); BOOST_CHECK_MESSAGE(DstTypeChecker::IsScriptDst(decoded_scr), err); } } /** * Cashaddr payload made of 5-bit nibbles. The last one is padded. When * converting back to bytes, this extra padding is truncated. In order to ensure * cashaddr are cannonicals, we check that the data we truncate is zeroed. */ BOOST_AUTO_TEST_CASE(check_padding) { uint8_t version = 0; std::vector data = {version}; for (size_t i = 0; i < 33; ++i) { data.push_back(1); } BOOST_CHECK_EQUAL(data.size(), 34); const CTxDestination nodst = CNoDestination{}; const CChainParams params = Params(CBaseChainParams::MAIN); for (uint8_t i = 0; i < 32; i++) { data[data.size() - 1] = i; std::string fake = cashaddr::Encode(params.CashAddrPrefix(), data); CTxDestination dst = DecodeCashAddr(fake, params); // We have 168 bits of payload encoded as 170 bits in 5 bits nimbles. As // a result, we must have 2 zeros. if (i & 0x03) { BOOST_CHECK(dst == nodst); } else { BOOST_CHECK(dst != nodst); } } } /** * We ensure type is extracted properly from the version. */ BOOST_AUTO_TEST_CASE(check_type) { std::vector data; data.resize(34); const CChainParams params = Params(CBaseChainParams::MAIN); for (uint8_t v = 0; v < 16; v++) { std::fill(begin(data), end(data), 0); data[0] = v; auto content = DecodeCashAddrContent( cashaddr::Encode(params.CashAddrPrefix(), data), params); BOOST_CHECK_EQUAL(content.type, v); BOOST_CHECK_EQUAL(content.hash.size(), 20); // Check that using the reserved bit result in a failure. data[0] |= 0x10; content = DecodeCashAddrContent( cashaddr::Encode(params.CashAddrPrefix(), data), params); BOOST_CHECK_EQUAL(content.type, 0); BOOST_CHECK_EQUAL(content.hash.size(), 0); } } /** * We ensure size is extracted and checked properly. */ BOOST_AUTO_TEST_CASE(check_size) { const CTxDestination nodst = CNoDestination{}; const CChainParams params = Params(CBaseChainParams::MAIN); // Mapp all possible size bits in the version to the expected size of the // hash in bytes. std::vector> sizes = { {0, 20}, {1, 24}, {2, 28}, {3, 32}, {4, 40}, {5, 48}, {6, 56}, {7, 64}, }; std::vector data; for (auto ps : sizes) { - size_t expectedSize = (12 + ps.second * 8) / 5; + // Number of bytes required for a 5-bit packed version of a hash, with + // version byte. Add half a byte(4) so integer math provides the next + // multiple-of-5 that would fit all the data. + size_t expectedSize = (8 * (1 + ps.second) + 4) / 5; data.resize(expectedSize); std::fill(begin(data), end(data), 0); + // After conversion from 8 bit packing to 5 bit packing, the size will + // be in the second 5-bit group, shifted left twice. data[1] = ps.first << 2; auto content = DecodeCashAddrContent( cashaddr::Encode(params.CashAddrPrefix(), data), params); BOOST_CHECK_EQUAL(content.type, 0); BOOST_CHECK_EQUAL(content.hash.size(), ps.second); data.push_back(0); content = DecodeCashAddrContent( cashaddr::Encode(params.CashAddrPrefix(), data), params); BOOST_CHECK_EQUAL(content.type, 0); BOOST_CHECK_EQUAL(content.hash.size(), 0); data.pop_back(); data.pop_back(); content = DecodeCashAddrContent( cashaddr::Encode(params.CashAddrPrefix(), data), params); BOOST_CHECK_EQUAL(content.type, 0); BOOST_CHECK_EQUAL(content.hash.size(), 0); } } BOOST_AUTO_TEST_CASE(test_addresses) { const CChainParams params = Params(CBaseChainParams::MAIN); std::vector> hash{ {118, 160, 64, 83, 189, 160, 168, 139, 218, 81, 119, 184, 106, 21, 195, 178, 159, 85, 152, 115}, {203, 72, 18, 50, 41, 156, 213, 116, 49, 81, 172, 75, 45, 99, 174, 25, 142, 123, 176, 169}, {1, 31, 40, 228, 115, 201, 95, 64, 19, 215, 213, 62, 197, 251, 195, 180, 45, 248, 237, 16}}; std::vector pubkey = { "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a", "bitcoincash:qr95sy3j9xwd2ap32xkykttr4cvcu7as4y0qverfuy", "bitcoincash:qqq3728yw0y47sqn6l2na30mcw6zm78dzqre909m2r"}; std::vector script = { "bitcoincash:ppm2qsznhks23z7629mms6s4cwef74vcwvn0h829pq", "bitcoincash:pr95sy3j9xwd2ap32xkykttr4cvcu7as4yc93ky28e", "bitcoincash:pqq3728yw0y47sqn6l2na30mcw6zm78dzq5ucqzc37"}; for (size_t i = 0; i < hash.size(); ++i) { const CTxDestination dstKey = CKeyID(uint160(hash[i])); BOOST_CHECK_EQUAL(pubkey[i], EncodeCashAddr(dstKey, params)); const CTxDestination dstScript = CScriptID(uint160(hash[i])); BOOST_CHECK_EQUAL(script[i], EncodeCashAddr(dstScript, params)); } } BOOST_AUTO_TEST_SUITE_END()