mirror of
https://github.com/XRPLF/rippled.git
synced 2026-07-24 15:40:26 +00:00
459 lines
14 KiB
C++
459 lines
14 KiB
C++
#include <xrpl/basics/Slice.h>
|
|
#include <xrpl/beast/unit_test/suite.h>
|
|
#include <xrpl/protocol/KeyType.h>
|
|
#include <xrpl/protocol/PublicKey.h>
|
|
#include <xrpl/protocol/SecretKey.h>
|
|
#include <xrpl/protocol/Seed.h>
|
|
#include <xrpl/protocol/tokens.h>
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace xrpl {
|
|
|
|
class PublicKey_test : public beast::unit_test::Suite
|
|
{
|
|
public:
|
|
using blob = std::vector<std::uint8_t>;
|
|
|
|
template <class FwdIter, class Container>
|
|
static void
|
|
hexToBinary(FwdIter first, FwdIter last, Container& out)
|
|
{
|
|
struct Table
|
|
{
|
|
int val[256]{};
|
|
Table()
|
|
{
|
|
std::fill(val, val + 256, 0);
|
|
for (int i = 0; i < 10; ++i)
|
|
val['0' + i] = i;
|
|
for (int i = 0; i < 6; ++i)
|
|
{
|
|
val['A' + i] = 10 + i;
|
|
val['a' + i] = 10 + i;
|
|
}
|
|
}
|
|
int
|
|
operator[](int i)
|
|
{
|
|
return val[i];
|
|
}
|
|
};
|
|
|
|
static Table kLut;
|
|
out.reserve(std::distance(first, last) / 2);
|
|
while (first != last)
|
|
{
|
|
auto const hi(kLut[(*first++)]);
|
|
auto const lo(kLut[(*first++)]);
|
|
out.push_back((hi * 16) + lo);
|
|
}
|
|
}
|
|
|
|
static blob
|
|
sig(std::string const& hex)
|
|
{
|
|
blob b;
|
|
hexToBinary(hex.begin(), hex.end(), b);
|
|
return b;
|
|
}
|
|
|
|
static bool
|
|
check(std::optional<ECDSACanonicality> answer, std::string const& s)
|
|
{
|
|
return ecdsaCanonicality(makeSlice(sig(s))) == answer;
|
|
}
|
|
|
|
void
|
|
testCanonical()
|
|
{
|
|
testcase("Canonical");
|
|
|
|
// Fully canonical
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3045"
|
|
"022100FF478110D1D4294471EC76E0157540C2181F47DEBD25D7F9E7DDCCCD47EE"
|
|
"E905"
|
|
"0220078F07CDAE6C240855D084AD91D1479609533C147C93B0AEF19BC9724D003F"
|
|
"28"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3045"
|
|
"0221009218248292F1762D8A51BE80F8A7F2CD288D810CE781D5955700DA1684DF"
|
|
"1D2D"
|
|
"022041A1EE1746BFD72C9760CC93A7AAA8047D52C8833A03A20EAAE92EA19717B4"
|
|
"54"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3044"
|
|
"02206A9E43775F73B6D1EC420E4DDD222A80D4C6DF5D1BEECC431A91B63C928B75"
|
|
"81"
|
|
"022023E9CC2D61DDA6F73EAA6BCB12688BEB0F434769276B3127E4044ED895C9D9"
|
|
"6B"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3044"
|
|
"022056E720007221F3CD4EFBB6352741D8E5A0968D48D8D032C2FBC4F6304AD1D0"
|
|
"4E"
|
|
"02201F39EB392C20D7801C3E8D81D487E742FA84A1665E923225BD6323847C7187"
|
|
"9F"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3045"
|
|
"022100FDFD5AD05518CEA0017A2DCB5C4DF61E7C73B6D3A38E7AE93210A1564E8C"
|
|
"2F12"
|
|
"0220214FF061CCC123C81D0BB9D0EDEA04CD40D96BF1425D311DA62A7096BB18EA"
|
|
"18"));
|
|
|
|
// Canonical but not fully canonical
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::Canonical,
|
|
"3046"
|
|
"022100F477B3FA6F31C7CB3A0D1AD94A231FDD24B8D78862EE334CEA7CD08F6CBC"
|
|
"0A1B"
|
|
"022100928E6BCF1ED2684679730C5414AEC48FD62282B090041C41453C1D064AF5"
|
|
"97A1"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::Canonical,
|
|
"3045"
|
|
"022063E7C7CA93CB2400E413A342C027D00665F8BAB9C22EF0A7B8AE3AAF092230"
|
|
"B6"
|
|
"0221008F2E8BB7D09521ABBC277717B14B93170AE6465C5A1B36561099319C4BEB"
|
|
"254C"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::Canonical,
|
|
"3046"
|
|
"02210099DCA1188663DDEA506A06A7B20C2B7D8C26AFF41DECE69D6C5F7C967D32"
|
|
"625F"
|
|
"022100897658A6B1F9EEE5D140D7A332DA0BD73BB98974EA53F6201B01C1B594F2"
|
|
"86EA"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::Canonical,
|
|
"3045"
|
|
"02200855DE366E4E323AA2CE2A25674401A7D11F72EC432770D07F7B57DF7387AE"
|
|
"C0"
|
|
"022100DA4C6ADDEA14888858DE2AC5B91ED9050D6972BB388DEF582628CEE32869"
|
|
"AE35"));
|
|
|
|
// valid
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3006"
|
|
"020101"
|
|
"020102"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::FullyCanonical,
|
|
"3044"
|
|
"02203932c892e2e550f3af8ee4ce9c215a87f9bb831dcac87b2838e2c2eaa891df"
|
|
"0c"
|
|
"022030b61dd36543125d56b9f9f3a1f53189e5af33cdda8d77a5209aec03978fa0"
|
|
"01"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::Canonical,
|
|
"3045"
|
|
"0220076045be6f9eca28ff1ec606b833d0b87e70b2a630f5e3a496b110967a40f9"
|
|
"0a"
|
|
"0221008fffd599910eefe00bc803c688eca1d2ba7f6b180620eaa03488e6585db6"
|
|
"ba01"));
|
|
BEAST_EXPECT(check(
|
|
ECDSACanonicality::Canonical,
|
|
"3046"
|
|
"022100876045be6f9eca28ff1ec606b833d0b87e70b2a630f5e3a496b110967a40"
|
|
"f90a"
|
|
"0221008fffd599910eefe00bc803c688c2eca1d2ba7f6b180620eaa03488e6585d"
|
|
"b6ba"));
|
|
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3005"
|
|
"0201FF"
|
|
"0200"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020101"
|
|
"020202"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020701"
|
|
"020102"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020401"
|
|
"020102"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020501"
|
|
"020102"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020201"
|
|
"020102"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020301"
|
|
"020202"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3006"
|
|
"020401"
|
|
"020202"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3047"
|
|
"0221005990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba"
|
|
"6105"
|
|
"022200002d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e56"
|
|
"6695ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3144"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3045"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"301F"
|
|
"01205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3045"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed00"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3044"
|
|
"01205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3024"
|
|
"0200"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3044"
|
|
"02208990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3045"
|
|
"0221005990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba"
|
|
"6105"
|
|
"02202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3044"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05012"
|
|
"02d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695e"
|
|
"d"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3024"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"0200"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3044"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"0220fd5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695"
|
|
"ed"));
|
|
BEAST_EXPECT(check(
|
|
std::nullopt,
|
|
"3045"
|
|
"02205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61"
|
|
"05"
|
|
"0221002d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e5666"
|
|
"95ed"));
|
|
}
|
|
|
|
void
|
|
testBase58(KeyType keyType)
|
|
{
|
|
// Try converting short, long and malformed data
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, ""));
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, " "));
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, "!ty89234gh45"));
|
|
|
|
auto const good =
|
|
toBase58(TokenType::NodePublic, derivePublicKey(keyType, randomSecretKey()));
|
|
|
|
// Short (non-empty) strings
|
|
{
|
|
auto s = good;
|
|
|
|
// Remove all characters from the string in random order:
|
|
std::hash<std::string> const r;
|
|
|
|
while (!s.empty())
|
|
{
|
|
s.erase(r(s) % s.size(), 1);
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, s));
|
|
}
|
|
}
|
|
|
|
// Long strings
|
|
for (std::size_t i = 1; i != 16; i++)
|
|
{
|
|
auto s = good;
|
|
s.resize(s.size() + i, s[i % s.size()]);
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, s));
|
|
}
|
|
|
|
// Strings with invalid Base58 characters
|
|
for (auto c : std::string("0IOl"))
|
|
{
|
|
for (std::size_t i = 0; i != good.size(); ++i)
|
|
{
|
|
auto s = good;
|
|
s[i % s.size()] = c;
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, s));
|
|
}
|
|
}
|
|
|
|
// Strings with incorrect prefix
|
|
{
|
|
auto s = good;
|
|
|
|
for (auto c : std::string("apsrJqtv7"))
|
|
{
|
|
s[0] = c;
|
|
BEAST_EXPECT(!parseBase58<PublicKey>(TokenType::NodePublic, s));
|
|
}
|
|
}
|
|
|
|
// Try some random secret keys
|
|
std::vector<PublicKey> keys;
|
|
keys.reserve(32);
|
|
|
|
for (std::size_t i = 0; i != keys.capacity(); ++i)
|
|
keys.emplace_back(derivePublicKey(keyType, randomSecretKey()));
|
|
BEAST_EXPECT(keys.size() == 32);
|
|
|
|
for (std::size_t i = 0; i != keys.size(); ++i)
|
|
{
|
|
auto const si = toBase58(TokenType::NodePublic, keys[i]);
|
|
BEAST_EXPECT(!si.empty());
|
|
|
|
auto const ski = parseBase58<PublicKey>(TokenType::NodePublic, si);
|
|
BEAST_EXPECT(ski && (keys[i] == *ski));
|
|
|
|
for (std::size_t j = i; j != keys.size(); ++j)
|
|
{
|
|
BEAST_EXPECT((keys[i] == keys[j]) == (i == j));
|
|
|
|
auto const sj = toBase58(TokenType::NodePublic, keys[j]);
|
|
|
|
BEAST_EXPECT((si == sj) == (i == j));
|
|
|
|
auto const skj = parseBase58<PublicKey>(TokenType::NodePublic, sj);
|
|
BEAST_EXPECT(skj && (keys[j] == *skj));
|
|
|
|
BEAST_EXPECT(
|
|
(*ski == *skj) == (i == j)); // NOLINT(bugprone-unchecked-optional-access)
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
testBase58()
|
|
{
|
|
testcase("Base58: secp256k1");
|
|
|
|
{
|
|
auto const pk1 = derivePublicKey(
|
|
KeyType::Secp256k1,
|
|
generateSecretKey(KeyType::Secp256k1, generateSeed("masterpassphrase")));
|
|
|
|
auto const pk2 = parseBase58<PublicKey>(
|
|
TokenType::NodePublic, "n94a1u4jAz288pZLtw6yFWVbi89YamiC6JBXPVUj5zmExe5fTVg9");
|
|
BEAST_EXPECT(pk2);
|
|
|
|
BEAST_EXPECT(pk1 == *pk2); // NOLINT(bugprone-unchecked-optional-access)
|
|
}
|
|
|
|
testBase58(KeyType::Secp256k1);
|
|
|
|
testcase("Base58: ed25519");
|
|
|
|
{
|
|
auto const pk1 = derivePublicKey(
|
|
KeyType::Ed25519,
|
|
generateSecretKey(KeyType::Ed25519, generateSeed("masterpassphrase")));
|
|
|
|
auto const pk2 = parseBase58<PublicKey>(
|
|
TokenType::NodePublic, "nHUeeJCSY2dM71oxM8Cgjouf5ekTuev2mwDpc374aLMxzDLXNmjf");
|
|
BEAST_EXPECT(pk2);
|
|
|
|
BEAST_EXPECT(pk1 == *pk2); // NOLINT(bugprone-unchecked-optional-access)
|
|
}
|
|
|
|
testBase58(KeyType::Ed25519);
|
|
}
|
|
|
|
void
|
|
testMiscOperations()
|
|
{
|
|
testcase("Miscellaneous operations");
|
|
|
|
auto const pk1 = derivePublicKey(
|
|
KeyType::Secp256k1,
|
|
generateSecretKey(KeyType::Secp256k1, generateSeed("masterpassphrase")));
|
|
|
|
PublicKey const pk2(pk1);
|
|
BEAST_EXPECT(pk1 == pk2);
|
|
BEAST_EXPECT(pk2 == pk1);
|
|
|
|
PublicKey pk3 = derivePublicKey(
|
|
KeyType::Secp256k1,
|
|
generateSecretKey(KeyType::Secp256k1, generateSeed("arbitraryPassPhrase")));
|
|
// Testing the copy assignment operation of PublicKey class
|
|
pk3 = pk2;
|
|
BEAST_EXPECT(pk3 == pk2);
|
|
BEAST_EXPECT(pk1 == pk3);
|
|
}
|
|
|
|
void
|
|
run() override
|
|
{
|
|
testBase58();
|
|
testCanonical();
|
|
testMiscOperations();
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(PublicKey, protocol, xrpl);
|
|
|
|
} // namespace xrpl
|