neobytes-project/neobytes
neobytes-project/neobytes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
1cf3dd80a6
neobytes/src/test/key_tests.cpp

192 lines
7.8 KiB
C++
Raw Normal View History

Add licenses for tests and test data - Add license headers to source files (years based on commit dates) in `src/test` as well as `qa` - Add `README.md` to `src/test/data` specifying MIT license Fixes #3848
2014-03-18 10:11:00 +01:00
// Copyright (c) 2012-2013 The Bitcoin Core developers
Remove references to X11 licence
2014-12-13 05:09:33 +01:00
// Distributed under the MIT software license, see the accompanying
Add licenses for tests and test data - Add license headers to source files (years based on commit dates) in `src/test` as well as `qa` - Add `README.md` to `src/test/data` specifying MIT license Fixes #3848
2014-03-18 10:11:00 +01:00
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
#include "key.h"
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
#include "base58.h"
Move CScript class and dependencies to script/script
2014-08-20 17:37:40 +02:00
#include "script/script.h"
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
#include "uint256.h"
#include "util.h"
Deterministic signing
2014-11-06 15:54:50 +01:00
#include "utilstrencodings.h"
tests: add a BasicTestingSetup and apply to all tests Make sure that chainparams and logging is properly initialized. Doing this for every test may be overkill, but this initialization is so simple that that does not matter. This should fix the travis issues.
2015-03-12 09:34:42 +01:00
#include "test/test_bitcoin.h"
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
#include <string>
#include <vector>
#include <boost/test/unit_test.hpp>
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
using namespace std;
Refactor: split CKeyID/CScriptID/CTxDestination from CBitcoinAddress This introduces internal types: * CKeyID: reference (hash160) of a key * CScriptID: reference (hash160) of a script * CTxDestination: a boost::variant of the former two CBitcoinAddress is retrofitted to be a Base58 encoding of a CTxDestination. This allows all internal code to only use the internal types, and only have RPC and GUI depend on the base58 code. Furthermore, the header dependencies are a lot saner now. base58.h is at the top (right below rpc and gui) instead of at the bottom. For the rest: wallet -> script -> keystore -> key. Only keystore still requires a forward declaration of CScript. Solving that would require splitting script into two layers.
2012-05-14 23:44:52 +02:00
static const string strSecret1 ("5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj");
static const string strSecret2 ("5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3");
static const string strSecret1C ("Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw");
static const string strSecret2C ("L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g");
static const CBitcoinAddress addr1 ("1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ");
static const CBitcoinAddress addr2 ("1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ");
static const CBitcoinAddress addr1C("1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs");
static const CBitcoinAddress addr2C("1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs");
static const string strAddressBad("1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF");
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
#ifdef KEY_TESTS_DUMPINFO
void dumpKeyInfo(uint256 privkey)
{
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
CKey key;
key.resize(32);
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
memcpy(&secret[0], &privkey, 32);
vector<unsigned char> sec;
sec.resize(32);
memcpy(&sec[0], &secret[0], 32);
printf(" * secret (hex): %s\n", HexStr(sec).c_str());
for (int nCompressed=0; nCompressed<2; nCompressed++)
{
bool fCompressed = nCompressed == 1;
printf(" * %s:\n", fCompressed ? "compressed" : "uncompressed");
CBitcoinSecret bsecret;
bsecret.SetSecret(secret, fCompressed);
printf(" * secret (base58): %s\n", bsecret.ToString().c_str());
CKey key;
key.SetSecret(secret, fCompressed);
vector<unsigned char> vchPubKey = key.GetPubKey();
printf(" * pubkey (hex): %s\n", HexStr(vchPubKey).c_str());
printf(" * address (base58): %s\n", CBitcoinAddress(vchPubKey).ToString().c_str());
}
}
#endif
tests: add a BasicTestingSetup and apply to all tests Make sure that chainparams and logging is properly initialized. Doing this for every test may be overkill, but this initialization is so simple that that does not matter. This should fix the travis issues.
2015-03-12 09:34:42 +01:00
BOOST_FIXTURE_TEST_SUITE(key_tests, BasicTestingSetup)
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
BOOST_AUTO_TEST_CASE(key_test1)
{
CBitcoinSecret::SetString() now calls IsValid() to make sure it was passed something with the correct version.
2012-04-12 22:13:08 +02:00
CBitcoinSecret bsecret1, bsecret2, bsecret1C, bsecret2C, baddress1;
BOOST_CHECK( bsecret1.SetString (strSecret1));
BOOST_CHECK( bsecret2.SetString (strSecret2));
BOOST_CHECK( bsecret1C.SetString(strSecret1C));
BOOST_CHECK( bsecret2C.SetString(strSecret2C));
Refactor: split CKeyID/CScriptID/CTxDestination from CBitcoinAddress This introduces internal types: * CKeyID: reference (hash160) of a key * CScriptID: reference (hash160) of a script * CTxDestination: a boost::variant of the former two CBitcoinAddress is retrofitted to be a Base58 encoding of a CTxDestination. This allows all internal code to only use the internal types, and only have RPC and GUI depend on the base58 code. Furthermore, the header dependencies are a lot saner now. base58.h is at the top (right below rpc and gui) instead of at the bottom. For the rest: wallet -> script -> keystore -> key. Only keystore still requires a forward declaration of CScript. Solving that would require splitting script into two layers.
2012-05-14 23:44:52 +02:00
BOOST_CHECK(!baddress1.SetString(strAddressBad));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
CKey key1 = bsecret1.GetKey();
BOOST_CHECK(key1.IsCompressed() == false);
CKey key2 = bsecret2.GetKey();
BOOST_CHECK(key2.IsCompressed() == false);
CKey key1C = bsecret1C.GetKey();
BOOST_CHECK(key1C.IsCompressed() == true);
CKey key2C = bsecret2C.GetKey();
Typo in test
2014-10-13 17:57:09 +02:00
BOOST_CHECK(key2C.IsCompressed() == true);
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
CPubKey pubkey1 = key1. GetPubKey();
CPubKey pubkey2 = key2. GetPubKey();
CPubKey pubkey1C = key1C.GetPubKey();
CPubKey pubkey2C = key2C.GetPubKey();
Add sanity check after key generation Add a sanity check to prevent cosmic rays from flipping a bit in the generated public key, or bugs in the elliptic curve code. This is simply done by signing a (randomized) message, and verifying the result.
2014-11-06 10:17:48 +01:00
BOOST_CHECK(key1.VerifyPubKey(pubkey1));
BOOST_CHECK(!key1.VerifyPubKey(pubkey1C));
BOOST_CHECK(!key1.VerifyPubKey(pubkey2));
BOOST_CHECK(!key1.VerifyPubKey(pubkey2C));
BOOST_CHECK(!key1C.VerifyPubKey(pubkey1));
BOOST_CHECK(key1C.VerifyPubKey(pubkey1C));
BOOST_CHECK(!key1C.VerifyPubKey(pubkey2));
BOOST_CHECK(!key1C.VerifyPubKey(pubkey2C));
BOOST_CHECK(!key2.VerifyPubKey(pubkey1));
BOOST_CHECK(!key2.VerifyPubKey(pubkey1C));
BOOST_CHECK(key2.VerifyPubKey(pubkey2));
BOOST_CHECK(!key2.VerifyPubKey(pubkey2C));
BOOST_CHECK(!key2C.VerifyPubKey(pubkey1));
BOOST_CHECK(!key2C.VerifyPubKey(pubkey1C));
BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK(addr1.Get() == CTxDestination(pubkey1.GetID()));
BOOST_CHECK(addr2.Get() == CTxDestination(pubkey2.GetID()));
BOOST_CHECK(addr1C.Get() == CTxDestination(pubkey1C.GetID()));
BOOST_CHECK(addr2C.Get() == CTxDestination(pubkey2C.GetID()));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
for (int n=0; n<16; n++)
{
string strMsg = strprintf("Very secret message %i: 11", n);
uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
// normal signatures
vector<unsigned char> sign1, sign2, sign1C, sign2C;
BOOST_CHECK(key1.Sign (hashMsg, sign1));
BOOST_CHECK(key2.Sign (hashMsg, sign2));
BOOST_CHECK(key1C.Sign(hashMsg, sign1C));
BOOST_CHECK(key2C.Sign(hashMsg, sign2C));
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));
BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));
BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));
BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));
BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));
BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));
BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));
BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));
BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));
BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));
BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));
BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));
BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
// compact signatures (with key recovery)
vector<unsigned char> csign1, csign2, csign1C, csign2C;
BOOST_CHECK(key1.SignCompact (hashMsg, csign1));
BOOST_CHECK(key2.SignCompact (hashMsg, csign2));
BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
CPubKey rkey1, rkey2, rkey1C, rkey2C;
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));
BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));
BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
CSecret/CKey -> CKey/CPubKey split/refactor
2013-05-01 06:52:05 +02:00
BOOST_CHECK(rkey1 == pubkey1);
BOOST_CHECK(rkey2 == pubkey2);
BOOST_CHECK(rkey1C == pubkey1C);
BOOST_CHECK(rkey2C == pubkey2C);
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
}
Deterministic signing
2014-11-06 15:54:50 +01:00
// test deterministic signing
std::vector<unsigned char> detsig, detsigc;
string strMsg = "Very deterministic message";
uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
BOOST_CHECK(key1.Sign(hashMsg, detsig));
BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
BOOST_CHECK(detsig == detsigc);
BOOST_CHECK(detsig == ParseHex("304402205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d022014ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
BOOST_CHECK(key2.Sign(hashMsg, detsig));
BOOST_CHECK(key2C.Sign(hashMsg, detsigc));
BOOST_CHECK(detsig == detsigc);
BOOST_CHECK(detsig == ParseHex("3044022052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd5022061d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
BOOST_CHECK(key1.SignCompact(hashMsg, detsig));
BOOST_CHECK(key1C.SignCompact(hashMsg, detsigc));
BOOST_CHECK(detsig == ParseHex("1c5dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
BOOST_CHECK(detsigc == ParseHex("205dbbddda71772d95ce91cd2d14b592cfbc1dd0aabd6a394b6c2d377bbe59d31d14ddda21494a4e221f0824f0b8b924c43fa43c0ad57dccdaa11f81a6bd4582f6"));
BOOST_CHECK(key2.SignCompact(hashMsg, detsig));
BOOST_CHECK(key2C.SignCompact(hashMsg, detsigc));
BOOST_CHECK(detsig == ParseHex("1c52d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
BOOST_CHECK(detsigc == ParseHex("2052d8a32079c11e79db95af63bb9600c5b04f21a9ca33dc129c2bfa8ac9dc1cd561d8ae5e0f6c1a16bde3719c64c2fd70e404b6428ab9a69566962e8771b5944d"));
Unit tests for EC key routines This tests: * creation of keys from base58-encoded strings * extracting public keys and addresses * compressed public keys * compact signatures and key recovery
2012-01-08 16:59:34 +01:00
}
BOOST_AUTO_TEST_SUITE_END()
Reference in New Issue Copy Permalink