//
// Unit tests for denial-of-service detection/prevention code
//
+#include <algorithm>
+
#include <boost/assign/list_of.hpp> // for 'map_list_of()'
+#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/foreach.hpp>
#include <stdint.h>
// Tests this internal-to-main.cpp method:
-extern void AddOrphanTx(const CDataStream& vMsg);
-extern int LimitOrphanTxSize(int nMaxOrphans);
+extern bool AddOrphanTx(const CDataStream& vMsg);
+extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
extern std::map<uint256, CDataStream*> mapOrphanTransactions;
-extern std::multimap<uint256, CDataStream*> mapOrphanTransactionsByPrev;
+extern std::map<uint256, std::map<uint256, CDataStream*> > mapOrphanTransactionsByPrev;
CService ip(uint32_t i)
{
{
CNode::ClearBanned();
CAddress addr1(ip(0xa0b0c001));
- CNode dummyNode1(INVALID_SOCKET, addr1, true);
+ CNode dummyNode1(INVALID_SOCKET, addr1, "", true);
dummyNode1.Misbehaving(100); // Should get banned
BOOST_CHECK(CNode::IsBanned(addr1));
- BOOST_CHECK(!CNode::IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different ip, not banned
+ BOOST_CHECK(!CNode::IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different IP, not banned
CAddress addr2(ip(0xa0b0c002));
- CNode dummyNode2(INVALID_SOCKET, addr2, true);
+ CNode dummyNode2(INVALID_SOCKET, addr2, "", true);
dummyNode2.Misbehaving(50);
BOOST_CHECK(!CNode::IsBanned(addr2)); // 2 not banned yet...
BOOST_CHECK(CNode::IsBanned(addr1)); // ... but 1 still should be
CNode::ClearBanned();
mapArgs["-banscore"] = "111"; // because 11 is my favorite number
CAddress addr1(ip(0xa0b0c001));
- CNode dummyNode1(INVALID_SOCKET, addr1, true);
+ CNode dummyNode1(INVALID_SOCKET, addr1, "", true);
dummyNode1.Misbehaving(100);
BOOST_CHECK(!CNode::IsBanned(addr1));
dummyNode1.Misbehaving(10);
BOOST_CHECK(!CNode::IsBanned(addr1));
dummyNode1.Misbehaving(1);
BOOST_CHECK(CNode::IsBanned(addr1));
- mapArgs["-banscore"] = "100";
+ mapArgs.erase("-banscore");
}
BOOST_AUTO_TEST_CASE(DoS_bantime)
SetMockTime(nStartTime); // Overrides future calls to GetTime()
CAddress addr(ip(0xa0b0c001));
- CNode dummyNode(INVALID_SOCKET, addr, true);
+ CNode dummyNode(INVALID_SOCKET, addr, "", true);
dummyNode.Misbehaving(100);
BOOST_CHECK(CNode::IsBanned(addr));
}
-static uint256 RandomHash()
-{
- std::vector<unsigned char> randbytes(32);
- RAND_bytes(&randbytes[0], 32);
- uint256 randomhash(randbytes);
- return randomhash;
-}
-
CTransaction RandomOrphan()
{
std::map<uint256, CDataStream*>::iterator it;
- it = mapOrphanTransactions.lower_bound(RandomHash());
+ it = mapOrphanTransactions.lower_bound(GetRandHash());
if (it == mapOrphanTransactions.end())
it = mapOrphanTransactions.begin();
const CDataStream* pvMsg = it->second;
CTransaction tx;
tx.vin.resize(1);
tx.vin[0].prevout.n = 0;
- tx.vin[0].prevout.hash = RandomHash();
+ tx.vin[0].prevout.hash = GetRandHash();
tx.vin[0].scriptSig << OP_1;
tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT;
- tx.vout[0].scriptPubKey.SetBitcoinAddress(key.GetPubKey());
+ tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
- CDataStream ds;
+ CDataStream ds(SER_DISK, CLIENT_VERSION);
ds << tx;
AddOrphanTx(ds);
}
tx.vin[0].prevout.hash = txPrev.GetHash();
tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT;
- tx.vout[0].scriptPubKey.SetBitcoinAddress(key.GetPubKey());
+ tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
SignSignature(keystore, txPrev, tx, 0);
- CDataStream ds;
+ CDataStream ds(SER_DISK, CLIENT_VERSION);
ds << tx;
AddOrphanTx(ds);
}
+ // This really-big orphan should be ignored:
+ for (int i = 0; i < 10; i++)
+ {
+ CTransaction txPrev = RandomOrphan();
+
+ CTransaction tx;
+ tx.vout.resize(1);
+ tx.vout[0].nValue = 1*CENT;
+ tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
+ tx.vin.resize(500);
+ for (unsigned int j = 0; j < tx.vin.size(); j++)
+ {
+ tx.vin[j].prevout.n = j;
+ tx.vin[j].prevout.hash = txPrev.GetHash();
+ }
+ SignSignature(keystore, txPrev, tx, 0);
+ // Re-use same signature for other inputs
+ // (they don't have to be valid for this test)
+ for (unsigned int j = 1; j < tx.vin.size(); j++)
+ tx.vin[j].scriptSig = tx.vin[0].scriptSig;
+
+ CDataStream ds(SER_DISK, CLIENT_VERSION);
+ ds << tx;
+ BOOST_CHECK(!AddOrphanTx(ds));
+ }
+
// Test LimitOrphanTxSize() function:
LimitOrphanTxSize(40);
BOOST_CHECK(mapOrphanTransactions.size() <= 40);
BOOST_CHECK(mapOrphanTransactionsByPrev.empty());
}
+BOOST_AUTO_TEST_CASE(DoS_checkSig)
+{
+ // Test signature caching code (see key.cpp Verify() methods)
+
+ CKey key;
+ key.MakeNewKey(true);
+ CBasicKeyStore keystore;
+ keystore.AddKey(key);
+
+ // 100 orphan transactions:
+ static const int NPREV=100;
+ CTransaction orphans[NPREV];
+ for (int i = 0; i < NPREV; i++)
+ {
+ CTransaction& tx = orphans[i];
+ tx.vin.resize(1);
+ tx.vin[0].prevout.n = 0;
+ tx.vin[0].prevout.hash = GetRandHash();
+ tx.vin[0].scriptSig << OP_1;
+ tx.vout.resize(1);
+ tx.vout[0].nValue = 1*CENT;
+ tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
+
+ CDataStream ds(SER_DISK, CLIENT_VERSION);
+ ds << tx;
+ AddOrphanTx(ds);
+ }
+
+ // Create a transaction that depends on orphans:
+ CTransaction tx;
+ tx.vout.resize(1);
+ tx.vout[0].nValue = 1*CENT;
+ tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
+ tx.vin.resize(NPREV);
+ for (unsigned int j = 0; j < tx.vin.size(); j++)
+ {
+ tx.vin[j].prevout.n = 0;
+ tx.vin[j].prevout.hash = orphans[j].GetHash();
+ }
+ // Creating signatures primes the cache:
+ boost::posix_time::ptime mst1 = boost::posix_time::microsec_clock::local_time();
+ for (unsigned int j = 0; j < tx.vin.size(); j++)
+ BOOST_CHECK(SignSignature(keystore, orphans[j], tx, j));
+ boost::posix_time::ptime mst2 = boost::posix_time::microsec_clock::local_time();
+ boost::posix_time::time_duration msdiff = mst2 - mst1;
+ long nOneValidate = msdiff.total_milliseconds();
+ if (fDebug) printf("DoS_Checksig sign: %ld\n", nOneValidate);
+
+ // ... now validating repeatedly should be quick:
+ // 2.8GHz machine, -g build: Sign takes ~760ms,
+ // uncached Verify takes ~250ms, cached Verify takes ~50ms
+ // (for 100 single-signature inputs)
+ mst1 = boost::posix_time::microsec_clock::local_time();
+ for (unsigned int i = 0; i < 5; i++)
+ for (unsigned int j = 0; j < tx.vin.size(); j++)
+ BOOST_CHECK(VerifySignature(orphans[j], tx, j, true, SIGHASH_ALL));
+ mst2 = boost::posix_time::microsec_clock::local_time();
+ msdiff = mst2 - mst1;
+ long nManyValidate = msdiff.total_milliseconds();
+ if (fDebug) printf("DoS_Checksig five: %ld\n", nManyValidate);
+
+ BOOST_CHECK_MESSAGE(nManyValidate < nOneValidate, "Signature cache timing failed");
+
+ // Empty a signature, validation should fail:
+ CScript save = tx.vin[0].scriptSig;
+ tx.vin[0].scriptSig = CScript();
+ BOOST_CHECK(!VerifySignature(orphans[0], tx, 0, true, SIGHASH_ALL));
+ tx.vin[0].scriptSig = save;
+
+ // Swap signatures, validation should fail:
+ std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig);
+ BOOST_CHECK(!VerifySignature(orphans[0], tx, 0, true, SIGHASH_ALL));
+ BOOST_CHECK(!VerifySignature(orphans[1], tx, 1, true, SIGHASH_ALL));
+ std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig);
+
+ // Exercise -maxsigcachesize code:
+ mapArgs["-maxsigcachesize"] = "10";
+ // Generate a new, different signature for vin[0] to trigger cache clear:
+ CScript oldSig = tx.vin[0].scriptSig;
+ BOOST_CHECK(SignSignature(keystore, orphans[0], tx, 0));
+ BOOST_CHECK(tx.vin[0].scriptSig != oldSig);
+ for (unsigned int j = 0; j < tx.vin.size(); j++)
+ BOOST_CHECK(VerifySignature(orphans[j], tx, j, true, SIGHASH_ALL));
+ mapArgs.erase("-maxsigcachesize");
+
+ LimitOrphanTxSize(0);
+}
+
BOOST_AUTO_TEST_SUITE_END()