ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format first-party source according to .clang-format

Browse Source
This commit is contained in:
Pretty Printer
2020-04-17 09:56:34 -05:00
committed by manojsdoshi
parent 65dfc5d19e
commit 50760c6935
1076 changed files with 86161 additions and 77449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
src/ripple/protocol/impl/PublicKey.cpp
View File

@@ -17,11 +17,11 @@
*/
//==============================================================================
#include <ripple/basics/contract.h>
#include <ripple/basics/strHex.h>
#include <ripple/protocol/PublicKey.h>
#include <ripple/protocol/digest.h>
#include <ripple/protocol/impl/secp256k1.h>
#include <ripple/basics/contract.h>
#include <ripple/basics/strHex.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <ed25519-donna/ed25519.h>
#include <type_traits>
@@ -35,9 +35,9 @@ operator<<(std::ostream& os, PublicKey const& pk)
return os;
}
template<>
template <>
boost::optional<PublicKey>
parseBase58 (TokenType type, std::string const& s)
parseBase58(TokenType type, std::string const& s)
{
auto const result = decodeBase58Token(s, type);
auto const pks = makeSlice(result);
@@ -50,9 +50,8 @@ parseBase58 (TokenType type, std::string const& s)
// Parse a length-prefixed number
// Format: 0x02 <length-byte> <number>
static
boost::optional<Slice>
sigPart (Slice& buf)
static boost::optional<Slice>
sigPart(Slice& buf)
{
if (buf.size() < 3 || buf[0] != 0x02)
return boost::none;
@@ -77,9 +76,8 @@ sigPart (Slice& buf)
return number;
}
static
std::string
sliceToHex (Slice const& slice)
static std::string
sliceToHex(Slice const& slice)
{
std::string s;
if (slice[0] & 0x80)
@@ -92,10 +90,10 @@ sliceToHex (Slice const& slice)
s.reserve(2 * (slice.size() + 1));
s = "0x";
}
for(int i = 0; i < slice.size(); ++i)
for (int i = 0; i < slice.size(); ++i)
{
s += "0123456789ABCDEF"[((slice[i]&0xf0)>>4)];
s += "0123456789ABCDEF"[((slice[i]&0x0f)>>0)];
s += "0123456789ABCDEF"[((slice[i] & 0xf0) >> 4)];
s += "0123456789ABCDEF"[((slice[i] & 0x0f) >> 0)];
}
return s;
}
@@ -113,12 +111,15 @@ sliceToHex (Slice const& slice)
https://github.com/sipa/bitcoin/commit/58bc86e37fda1aec270bccb3df6c20fbd2a6591c
*/
boost::optional<ECDSACanonicality>
ecdsaCanonicality (Slice const& sig)
ecdsaCanonicality(Slice const& sig)
{
using uint264 = boost::multiprecision::number<
boost::multiprecision::cpp_int_backend<
264, 264, boost::multiprecision::signed_magnitude,
boost::multiprecision::unchecked, void>>;
using uint264 =
boost::multiprecision::number<boost::multiprecision::cpp_int_backend<
264,
264,
boost::multiprecision::signed_magnitude,
boost::multiprecision::unchecked,
void>>;
static uint264 const G(
"0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
@@ -132,7 +133,7 @@ ecdsaCanonicality (Slice const& sig)
Slice p = sig + 2;
auto r = sigPart(p);
auto s = sigPart(p);
if (! r || ! s || ! p.empty())
if (!r || !s || !p.empty())
return boost::none;
uint264 R(sliceToHex(*r));
@@ -151,19 +152,16 @@ ecdsaCanonicality (Slice const& sig)
return ECDSACanonicality::fullyCanonical;
}
static
bool
ed25519Canonical (Slice const& sig)
static bool
ed25519Canonical(Slice const& sig)
{
if (sig.size() != 64)
return false;
// Big-endian Order, the Ed25519 subgroup order
std::uint8_t const Order[] =
{
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x14, 0xDE, 0xF9, 0xDE, 0xA2, 0xF7, 0x9C, 0xD6,
0x58, 0x12, 0x63, 0x1A, 0x5C, 0xF5, 0xD3, 0xED,
std::uint8_t const Order[] = {
0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0xDE, 0xF9, 0xDE, 0xA2, 0xF7,
0x9C, 0xD6, 0x58, 0x12, 0x63, 0x1A, 0x5C, 0xF5, 0xD3, 0xED,
};
// Take the second half of signature
// and byte-reverse it to big-endian.
@@ -171,22 +169,20 @@ ed25519Canonical (Slice const& sig)
std::uint8_t S[32];
std::reverse_copy(le, le + 32, S);
// Must be less than Order
return std::lexicographical_compare(
S, S + 32, Order, Order + 32);
return std::lexicographical_compare(S, S + 32, Order, Order + 32);
}
//------------------------------------------------------------------------------
PublicKey::PublicKey (Slice const& slice)
PublicKey::PublicKey(Slice const& slice)
{
if(! publicKeyType(slice))
if (!publicKeyType(slice))
LogicError("PublicKey::PublicKey invalid type");
size_ = slice.size();
std::memcpy(buf_, slice.data(), size_);
}
PublicKey::PublicKey (PublicKey const& other)
: size_ (other.size_)
PublicKey::PublicKey(PublicKey const& other) : size_(other.size_)
{
if (size_)
std::memcpy(buf_, other.buf_, size_);
@@ -204,7 +200,7 @@ PublicKey::operator=(PublicKey const& other)
//------------------------------------------------------------------------------
boost::optional<KeyType>
publicKeyType (Slice const& slice)
publicKeyType(Slice const& slice)
{
if (slice.size() == 33)
{
@@ -219,7 +215,8 @@ publicKeyType (Slice const& slice)
}
bool
verifyDigest (PublicKey const& publicKey,
verifyDigest(
PublicKey const& publicKey,
uint256 const& digest,
Slice const& sig,
bool mustBeFullyCanonical)
@@ -227,54 +224,49 @@ verifyDigest (PublicKey const& publicKey,
if (publicKeyType(publicKey) != KeyType::secp256k1)
LogicError("sign: secp256k1 required for digest signing");
auto const canonicality = ecdsaCanonicality(sig);
if (! canonicality)
if (!canonicality)
return false;
if (mustBeFullyCanonical &&
(*canonicality != ECDSACanonicality::fullyCanonical))
return false;
secp256k1_pubkey pubkey_imp;
if(secp256k1_ec_pubkey_parse(
if (secp256k1_ec_pubkey_parse(
secp256k1Context(),
&pubkey_imp,
reinterpret_cast<unsigned char const*>(
publicKey.data()),
reinterpret_cast<unsigned char const*>(publicKey.data()),
publicKey.size()) != 1)
return false;
secp256k1_ecdsa_signature sig_imp;
if(secp256k1_ecdsa_signature_parse_der(
if (secp256k1_ecdsa_signature_parse_der(
secp256k1Context(),
&sig_imp,
reinterpret_cast<unsigned char const*>(
sig.data()),
reinterpret_cast<unsigned char const*>(sig.data()),
sig.size()) != 1)
return false;
if (*canonicality != ECDSACanonicality::fullyCanonical)
{
secp256k1_ecdsa_signature sig_norm;
if(secp256k1_ecdsa_signature_normalize(
secp256k1Context(),
&sig_norm,
&sig_imp) != 1)
if (secp256k1_ecdsa_signature_normalize(
secp256k1Context(), &sig_norm, &sig_imp) != 1)
return false;
return secp256k1_ecdsa_verify(
secp256k1Context(),
&sig_norm,
reinterpret_cast<unsigned char const*>(
digest.data()),
&pubkey_imp) == 1;
secp256k1Context(),
&sig_norm,
reinterpret_cast<unsigned char const*>(digest.data()),
&pubkey_imp) == 1;
}
return secp256k1_ecdsa_verify(
secp256k1Context(),
&sig_imp,
reinterpret_cast<unsigned char const*>(
digest.data()),
&pubkey_imp) == 1;
secp256k1Context(),
&sig_imp,
reinterpret_cast<unsigned char const*>(digest.data()),
&pubkey_imp) == 1;
}
bool
verify (PublicKey const& publicKey,
verify(
PublicKey const& publicKey,
Slice const& m,
Slice const& sig,
bool mustBeFullyCanonical)
@@ -283,12 +275,12 @@ verify (PublicKey const& publicKey,
{
if (*type == KeyType::secp256k1)
{
return verifyDigest (publicKey,
sha512Half(m), sig, mustBeFullyCanonical);
return verifyDigest(
publicKey, sha512Half(m), sig, mustBeFullyCanonical);
}
else if (*type == KeyType::ed25519)
{
if (! ed25519Canonical(sig))
if (!ed25519Canonical(sig))
return false;
// We internally prefix Ed25519 keys with a 0xED
@@ -296,27 +288,23 @@ verify (PublicKey const& publicKey,
// so when verifying the signature, we need to
// first strip that prefix.
return ed25519_sign_open(
m.data(), m.size(), publicKey.data() + 1,
sig.data()) == 0;
m.data(), m.size(), publicKey.data() + 1, sig.data()) ==
0;
}
}
return false;
}
NodeID
calcNodeID (PublicKey const& pk)
calcNodeID(PublicKey const& pk)
{
ripesha_hasher h;
h(pk.data(), pk.size());
auto const digest = static_cast<
ripesha_hasher::result_type>(h);
static_assert(NodeID::bytes ==
sizeof(ripesha_hasher::result_type), "");
auto const digest = static_cast<ripesha_hasher::result_type>(h);
static_assert(NodeID::bytes == sizeof(ripesha_hasher::result_type), "");
NodeID result;
std::memcpy(result.data(),
digest.data(), digest.size());
std::memcpy(result.data(), digest.data(), digest.size());
return result;
}
} // ripple
} // namespace ripple