From 310e58bc621803917179c80b399013cf8b80e245 Mon Sep 17 00:00:00 2001 From: Tatsuhiro Tsujikawa Date: Thu, 13 Oct 2011 21:40:07 +0900 Subject: [PATCH] Stored hash value as raw byte string, instead of hex digest. --- src/BtPieceMessage.cc | 5 ++-- src/Checksum.h | 2 +- src/DownloadCommand.cc | 16 ++++++------- src/GrowSegment.cc | 2 +- src/GrowSegment.h | 2 +- src/HttpResponse.cc | 7 +++--- src/IteratableChecksumValidator.cc | 5 ++-- src/IteratableChunkChecksumValidator.cc | 13 +++++----- src/MessageDigest.cc | 4 ++-- src/MessageDigest.h | 6 ++--- src/MetalinkParserController.cc | 6 ++--- src/Piece.cc | 4 ++-- src/Piece.h | 4 ++-- src/PiecedSegment.cc | 4 ++-- src/PiecedSegment.h | 2 +- src/Segment.h | 2 +- src/bittorrent_helper.cc | 4 ++-- src/download_helper.cc | 2 +- src/message_digest_helper.cc | 8 +++---- src/message_digest_helper.h | 6 ++--- test/BittorrentHelperTest.cc | 6 ++--- test/GZipDecodingStreamFilterTest.cc | 2 +- test/HttpResponseTest.cc | 4 ++-- test/IteratableChecksumValidatorTest.cc | 6 +++-- test/IteratableChunkChecksumValidatorTest.cc | 15 ++++++------ test/MessageDigestHelperTest.cc | 14 +++++------ test/MessageDigestTest.cc | 8 +++---- test/Metalink2RequestGroupTest.cc | 4 ++-- test/MetalinkParserControllerTest.cc | 8 +++---- test/MetalinkProcessorTest.cc | 25 ++++++++++---------- test/MockSegment.h | 2 +- test/PieceTest.cc | 4 +++- test/TestUtil.cc | 3 ++- 33 files changed, 107 insertions(+), 98 deletions(-) diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc index 800f0751..b58ab647 100644 --- a/src/BtPieceMessage.cc +++ b/src/BtPieceMessage.cc @@ -223,11 +223,10 @@ bool BtPieceMessage::checkPieceHash(const SharedHandle& piece) A2_LOG_DEBUG(fmt("Hash is available!! index=%lu", static_cast(piece->getIndex()))); return - piece->getHashString()==downloadContext_->getPieceHash(piece->getIndex()); + piece->getDigest() == downloadContext_->getPieceHash(piece->getIndex()); } else { off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength(); - - return message_digest::staticSHA1DigestHexDigest + return message_digest::staticSHA1Digest (getPieceStorage()->getDiskAdaptor(), offset, piece->getLength()) == downloadContext_->getPieceHash(piece->getIndex()); } diff --git a/src/Checksum.h b/src/Checksum.h index f95d9c68..5fcf3182 100644 --- a/src/Checksum.h +++ b/src/Checksum.h @@ -46,7 +46,7 @@ private: std::string hashType_; std::string digest_; public: - // messageDigest_ is ascii hexadecimal notation. + // digest_ is raw byte array of hash value, not ascii hexadecimal notation. Checksum(const std::string& hashType, const std::string& digest); Checksum(); ~Checksum(); diff --git a/src/DownloadCommand.cc b/src/DownloadCommand.cc index 498309e0..d6beb2fe 100644 --- a/src/DownloadCommand.cc +++ b/src/DownloadCommand.cc @@ -231,12 +231,12 @@ bool DownloadCommand::executeInternal() { A2_LOG_DEBUG(fmt("Hash is available! index=%lu", static_cast(segment->getIndex()))); validatePieceHash - (segment, expectedPieceHash, segment->getHashString()); + (segment, expectedPieceHash, segment->getDigest()); } else { messageDigest_->reset(); validatePieceHash (segment, expectedPieceHash, - message_digest::hexDigest + message_digest::digest (messageDigest_, getPieceStorage()->getDiskAdaptor(), segment->getPosition(), @@ -350,18 +350,18 @@ bool DownloadCommand::prepareForNextSegment() { #ifdef ENABLE_MESSAGE_DIGEST void DownloadCommand::validatePieceHash(const SharedHandle& segment, - const std::string& expectedPieceHash, - const std::string& actualPieceHash) + const std::string& expectedHash, + const std::string& actualHash) { - if(actualPieceHash == expectedPieceHash) { - A2_LOG_INFO(fmt(MSG_GOOD_CHUNK_CHECKSUM, actualPieceHash.c_str())); + if(actualHash == expectedHash) { + A2_LOG_INFO(fmt(MSG_GOOD_CHUNK_CHECKSUM, util::toHex(actualHash).c_str())); getSegmentMan()->completeSegment(getCuid(), segment); } else { A2_LOG_INFO(fmt(EX_INVALID_CHUNK_CHECKSUM, static_cast(segment->getIndex()), util::itos(segment->getPosition(), true).c_str(), - expectedPieceHash.c_str(), - actualPieceHash.c_str())); + util::toHex(expectedHash).c_str(), + util::toHex(actualHash).c_str())); segment->clear(); getSegmentMan()->cancelSegment(getCuid()); throw DL_RETRY_EX diff --git a/src/GrowSegment.cc b/src/GrowSegment.cc index 266d05f1..fcbdbb22 100644 --- a/src/GrowSegment.cc +++ b/src/GrowSegment.cc @@ -52,7 +52,7 @@ void GrowSegment::updateWrittenLength(size_t bytes) #ifdef ENABLE_MESSAGE_DIGEST -std::string GrowSegment::getHashString() +std::string GrowSegment::getDigest() { return A2STR::NIL; } diff --git a/src/GrowSegment.h b/src/GrowSegment.h index 382567b3..0e553c15 100644 --- a/src/GrowSegment.h +++ b/src/GrowSegment.h @@ -98,7 +98,7 @@ public: return false; } - virtual std::string getHashString(); + virtual std::string getDigest(); #endif // ENABLE_MESSAGE_DIGEST diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc index e1381ad1..0c879291 100644 --- a/src/HttpResponse.cc +++ b/src/HttpResponse.cc @@ -408,11 +408,12 @@ void HttpResponse::getDigest(std::vector& result) const break; } util::lowercase(hashType); - std::string hexDigest = util::toHex(Base64::decode(digest)); - if(!MessageDigest::isValidHash(hashType, hexDigest)) { + digest = Base64::decode(digest); + if(!MessageDigest::supports(hashType) || + MessageDigest::getDigestLength(hashType) != digest.size()) { continue; } - result.push_back(Checksum(hashType, hexDigest)); + result.push_back(Checksum(hashType, digest)); } } std::sort(result.begin(), result.end(), HashTypeStronger()); diff --git a/src/IteratableChecksumValidator.cc b/src/IteratableChecksumValidator.cc index 36cd7518..20b1b5cc 100644 --- a/src/IteratableChecksumValidator.cc +++ b/src/IteratableChecksumValidator.cc @@ -75,12 +75,13 @@ void IteratableChecksumValidator::validateChunk() ctx_->update(buffer_, length); currentOffset_ += length; if(finished()) { - std::string actualDigest = ctx_->hexDigest(); + std::string actualDigest = ctx_->digest(); if(dctx_->getDigest() == actualDigest) { pieceStorage_->markAllPiecesDone(); } else { A2_LOG_INFO(fmt("Checksum validation failed. expected=%s, actual=%s", - dctx_->getDigest().c_str(), actualDigest.c_str())); + util::toHex(dctx_->getDigest()).c_str(), + util::toHex(actualDigest).c_str())); BitfieldMan bitfield(dctx_->getPieceLength(), dctx_->getTotalLength()); pieceStorage_->setBitfield(bitfield.getBitfield(), bitfield.getBitfieldLength()); } diff --git a/src/IteratableChunkChecksumValidator.cc b/src/IteratableChunkChecksumValidator.cc index 475e3b06..81f236d6 100644 --- a/src/IteratableChunkChecksumValidator.cc +++ b/src/IteratableChunkChecksumValidator.cc @@ -82,11 +82,12 @@ void IteratableChunkChecksumValidator::validateChunk() if(actualChecksum == dctx_->getPieceHashes()[currentIndex_]) { bitfield_->setBit(currentIndex_); } else { - A2_LOG_INFO(fmt(EX_INVALID_CHUNK_CHECKSUM, - static_cast(currentIndex_), - util::itos(getCurrentOffset(), true).c_str(), - dctx_->getPieceHashes()[currentIndex_].c_str(), - actualChecksum.c_str())); + A2_LOG_INFO + (fmt(EX_INVALID_CHUNK_CHECKSUM, + static_cast(currentIndex_), + util::itos(getCurrentOffset(), true).c_str(), + util::toHex(dctx_->getPieceHashes()[currentIndex_]).c_str(), + util::toHex(actualChecksum).c_str())); bitfield_->unsetBit(currentIndex_); } } catch(RecoverableException& ex) { @@ -156,7 +157,7 @@ std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length curoffset += r; woffset = 0; } - return ctx_->hexDigest(); + return ctx_->digest(); } diff --git a/src/MessageDigest.cc b/src/MessageDigest.cc index 4c2ea17e..87010f78 100644 --- a/src/MessageDigest.cc +++ b/src/MessageDigest.cc @@ -172,12 +172,12 @@ void MessageDigest::digest(unsigned char* md) pImpl_->digest(md); } -std::string MessageDigest::hexDigest() +std::string MessageDigest::digest() { size_t length = pImpl_->getDigestLength(); array_ptr buf(new unsigned char[length]); pImpl_->digest(buf); - std::string hd = util::toHex(buf, length); + std::string hd(&buf[0], &buf[length]); return hd; } diff --git a/src/MessageDigest.h b/src/MessageDigest.h index 7f24a1db..6441e748 100644 --- a/src/MessageDigest.h +++ b/src/MessageDigest.h @@ -101,9 +101,9 @@ public: // reset(). void digest(unsigned char* md); - // Returns hex digest. This call can only be called once. To reuse - // this object, call reset(). - std::string hexDigest(); + // Returns raw digest, not hex digest. This call can only be called + // once. To reuse this object, call reset(). + std::string digest(); }; } // namespace aria2 diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc index 0b2add57..0d886a49 100644 --- a/src/MetalinkParserController.cc +++ b/src/MetalinkParserController.cc @@ -284,7 +284,7 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md) return; } if(MessageDigest::isValidHash(tChecksum_->getHashType(), md)) { - tChecksum_->setDigest(md); + tChecksum_->setDigest(util::fromHex(md)); } else { cancelChecksumTransaction(); } @@ -360,7 +360,7 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md) return; } if(MessageDigest::isValidHash(tChunkChecksumV4_->getHashType(), md)) { - tempChunkChecksumsV4_.push_back(md); + tempChunkChecksumsV4_.push_back(util::fromHex(md)); } else { cancelChunkChecksumTransactionV4(); } @@ -463,7 +463,7 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string return; } if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) { - tempHashPair_.second = md; + tempHashPair_.second = util::fromHex(md); } else { cancelChunkChecksumTransaction(); } diff --git a/src/Piece.cc b/src/Piece.cc index f6f8c63a..a0698c3e 100644 --- a/src/Piece.cc +++ b/src/Piece.cc @@ -218,12 +218,12 @@ bool Piece::isHashCalculated() const return mdctx_ && nextBegin_ == length_; } -std::string Piece::getHashString() +std::string Piece::getDigest() { if(!mdctx_) { return A2STR::NIL; } else { - std::string hash = mdctx_->hexDigest(); + std::string hash = mdctx_->digest(); destroyHashContext(); return hash; } diff --git a/src/Piece.h b/src/Piece.h index 128c83a1..ae3b108a 100644 --- a/src/Piece.h +++ b/src/Piece.h @@ -164,11 +164,11 @@ public: bool isHashCalculated() const; - // Returns hash value in ASCII hexadecimal form, which is calculated + // Returns raw hash value, not hex digest, which is calculated // by updateHash(). Please note that this function returns hash // value only once. Second invocation without updateHash() returns // empty string. - std::string getHashString(); + std::string getDigest(); void destroyHashContext(); diff --git a/src/PiecedSegment.cc b/src/PiecedSegment.cc index bf6dd2b1..7cfd6fa9 100644 --- a/src/PiecedSegment.cc +++ b/src/PiecedSegment.cc @@ -102,9 +102,9 @@ bool PiecedSegment::isHashCalculated() const return piece_->isHashCalculated(); } -std::string PiecedSegment::getHashString() +std::string PiecedSegment::getDigest() { - return piece_->getHashString(); + return piece_->getDigest(); } #endif // ENABLE_MESSAGE_DIGEST diff --git a/src/PiecedSegment.h b/src/PiecedSegment.h index 00d3a386..85461358 100644 --- a/src/PiecedSegment.h +++ b/src/PiecedSegment.h @@ -84,7 +84,7 @@ public: virtual bool isHashCalculated() const; - virtual std::string getHashString(); + virtual std::string getDigest(); #endif // ENABLE_MESSAGE_DIGEST diff --git a/src/Segment.h b/src/Segment.h index b8f38c9f..153288d3 100644 --- a/src/Segment.h +++ b/src/Segment.h @@ -74,7 +74,7 @@ public: virtual bool isHashCalculated() const = 0; - virtual std::string getHashString() = 0; + virtual std::string getDigest() = 0; #endif // ENABLE_MESSAGE_DIGEST diff --git a/src/bittorrent_helper.cc b/src/bittorrent_helper.cc index 9d7f4505..050ba342 100644 --- a/src/bittorrent_helper.cc +++ b/src/bittorrent_helper.cc @@ -119,8 +119,8 @@ void extractPieceHash(const SharedHandle& ctx, std::vector pieceHashes; pieceHashes.reserve(numPieces); for(size_t i = 0; i < numPieces; ++i) { - pieceHashes.push_back(util::toHex(hashData.data()+i*hashLength, - hashLength)); + const char* p = hashData.data()+i*hashLength; + pieceHashes.push_back(std::string(p, p+hashLength)); } ctx->setPieceHashes("sha-1", pieceHashes.begin(), pieceHashes.end()); } diff --git a/src/download_helper.cc b/src/download_helper.cc index 8201ac58..bfecf467 100644 --- a/src/download_helper.cc +++ b/src/download_helper.cc @@ -238,7 +238,7 @@ SharedHandle createRequestGroup util::divide(p, checksum, '='); util::lowercase(p.first); util::lowercase(p.second); - dctx->setDigest(p.first, p.second); + dctx->setDigest(p.first, util::fromHex(p.second)); } #endif // ENABLE_MESSAGE_DIGEST rg->setDownloadContext(dctx); diff --git a/src/message_digest_helper.cc b/src/message_digest_helper.cc index b30d2179..b0fa8d3d 100644 --- a/src/message_digest_helper.cc +++ b/src/message_digest_helper.cc @@ -65,14 +65,14 @@ void staticSHA1DigestFree() sha1Ctx_.reset(); } -std::string staticSHA1DigestHexDigest +std::string staticSHA1Digest (const BinaryStreamHandle& bs, off_t offset, uint64_t length) { sha1Ctx_->reset(); - return hexDigest(sha1Ctx_, bs, offset, length); + return digest(sha1Ctx_, bs, offset, length); } -std::string hexDigest +std::string digest (const SharedHandle& ctx, const SharedHandle& bs, off_t offset, uint64_t length) @@ -97,7 +97,7 @@ std::string hexDigest } ctx->update(BUF, readLength); } - return ctx->hexDigest(); + return ctx->digest(); } void digest diff --git a/src/message_digest_helper.h b/src/message_digest_helper.h index 27f9ed81..4bf5d582 100644 --- a/src/message_digest_helper.h +++ b/src/message_digest_helper.h @@ -62,14 +62,14 @@ void staticSHA1DigestInit(); */ void staticSHA1DigestFree(); -std::string staticSHA1DigestHexDigest +std::string staticSHA1Digest (const SharedHandle& bs, off_t offset, uint64_t length); /** * ctx must be initialized or reseted before calling this function. - * Returns hex digest string, not *raw* digest + * Returns raw digest string, not hex digest */ -std::string hexDigest +std::string digest (const SharedHandle& ctx, const SharedHandle& bs, off_t offset, uint64_t length); diff --git a/test/BittorrentHelperTest.cc b/test/BittorrentHelperTest.cc index 94e6cbe2..832e1997 100644 --- a/test/BittorrentHelperTest.cc +++ b/test/BittorrentHelperTest.cc @@ -148,11 +148,11 @@ void BittorrentHelperTest::testGetPieceHash() { SharedHandle dctx(new DownloadContext()); load(A2_TEST_DIR"/test.torrent", dctx, option_); - CPPUNIT_ASSERT_EQUAL(util::toHex("AAAAAAAAAAAAAAAAAAAA", 20), + CPPUNIT_ASSERT_EQUAL(std::string("AAAAAAAAAAAAAAAAAAAA"), dctx->getPieceHash(0)); - CPPUNIT_ASSERT_EQUAL(util::toHex("BBBBBBBBBBBBBBBBBBBB", 20), + CPPUNIT_ASSERT_EQUAL(std::string("BBBBBBBBBBBBBBBBBBBB"), dctx->getPieceHash(1)); - CPPUNIT_ASSERT_EQUAL(util::toHex("CCCCCCCCCCCCCCCCCCCC", 20), + CPPUNIT_ASSERT_EQUAL(std::string("CCCCCCCCCCCCCCCCCCCC"), dctx->getPieceHash(2)); CPPUNIT_ASSERT_EQUAL(std::string(""), dctx->getPieceHash(3)); diff --git a/test/GZipDecodingStreamFilterTest.cc b/test/GZipDecodingStreamFilterTest.cc index de030401..264edbfc 100644 --- a/test/GZipDecodingStreamFilterTest.cc +++ b/test/GZipDecodingStreamFilterTest.cc @@ -76,7 +76,7 @@ void GZipDecodingStreamFilterTest::testTransform() SharedHandle sha1(MessageDigest::sha1()); sha1->update(data.data(), data.size()); CPPUNIT_ASSERT_EQUAL(std::string("8b577b33c0411b2be9d4fa74c7402d54a8d21f96"), - sha1->hexDigest()); + util::toHex(sha1->digest())); #endif // ENABLE_MESSAGE_DIGEST } diff --git a/test/HttpResponseTest.cc b/test/HttpResponseTest.cc index d04676f1..793d8bea 100644 --- a/test/HttpResponseTest.cc +++ b/test/HttpResponseTest.cc @@ -681,12 +681,12 @@ void HttpResponseTest::testGetDigest() Checksum c = result[0]; CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getHashType()); CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"), - c.getDigest()); + util::toHex(c.getDigest())); c = result[1]; CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getHashType()); CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"), - c.getDigest()); + util::toHex(c.getDigest())); } #endif // ENABLE_MESSAGE_DIGEST diff --git a/test/IteratableChecksumValidatorTest.cc b/test/IteratableChecksumValidatorTest.cc index 4729e32b..8bc7f1e1 100644 --- a/test/IteratableChecksumValidatorTest.cc +++ b/test/IteratableChecksumValidatorTest.cc @@ -34,7 +34,8 @@ void IteratableChecksumValidatorTest::testValidate() { Option option; SharedHandle dctx (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt")); - dctx->setDigest("sha-1", "898a81b8e0181280ae2ee1b81e269196d91e869a"); + dctx->setDigest("sha-1", + util::fromHex("898a81b8e0181280ae2ee1b81e269196d91e869a")); SharedHandle ps(new DefaultPieceStorage(dctx, &option)); ps->initStorage(); ps->getDiskAdaptor()->enableReadOnly(); @@ -53,7 +54,8 @@ void IteratableChecksumValidatorTest::testValidate_fail() { Option option; SharedHandle dctx (new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt")); - dctx->setDigest("sha-1", std::string(40, '0')); // set wrong checksum + dctx->setDigest("sha-1", + util::fromHex(std::string(40, '0'))); // set wrong checksum SharedHandle ps(new DefaultPieceStorage(dctx, &option)); ps->initStorage(); ps->getDiskAdaptor()->enableReadOnly(); diff --git a/test/IteratableChunkChecksumValidatorTest.cc b/test/IteratableChunkChecksumValidatorTest.cc index 63328013..921e9338 100644 --- a/test/IteratableChunkChecksumValidatorTest.cc +++ b/test/IteratableChunkChecksumValidatorTest.cc @@ -19,7 +19,7 @@ class IteratableChunkChecksumValidatorTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE_END(); private: - static const char* csArray[]; + static const std::string csArray[]; public: void setUp() { } @@ -31,9 +31,10 @@ public: CPPUNIT_TEST_SUITE_REGISTRATION( IteratableChunkChecksumValidatorTest ); -const char* IteratableChunkChecksumValidatorTest::csArray[] = { "29b0e7878271645fffb7eec7db4a7473a1c00bc1", - "4df75a661cb7eb2733d9cdaa7f772eae3a4e2976", - "0a4ea2f7dd7c52ddf2099a444ab2184b4d341bdb" }; +const std::string IteratableChunkChecksumValidatorTest::csArray[] = + { util::fromHex("29b0e7878271645fffb7eec7db4a7473a1c00bc1"), + util::fromHex("4df75a661cb7eb2733d9cdaa7f772eae3a4e2976"), + util::fromHex("0a4ea2f7dd7c52ddf2099a444ab2184b4d341bdb") }; void IteratableChunkChecksumValidatorTest::testValidate() { Option option; @@ -59,7 +60,7 @@ void IteratableChunkChecksumValidatorTest::testValidate() { // make the test fail std::deque badHashes(&csArray[0], &csArray[3]); - badHashes[1] = "ffffffffffffffffffffffffffffffffffffffff"; + badHashes[1] = util::fromHex("ffffffffffffffffffffffffffffffffffffffff"); dctx->setPieceHashes("sha-1", badHashes.begin(), badHashes.end()); validator.init(); @@ -77,8 +78,8 @@ void IteratableChunkChecksumValidatorTest::testValidate_readError() { SharedHandle dctx (new DownloadContext(100, 500, A2_TEST_DIR"/chunkChecksumTestFile250.txt")); std::deque hashes(&csArray[0], &csArray[3]); - hashes.push_back("ffffffffffffffffffffffffffffffffffffffff"); - hashes.push_back("ffffffffffffffffffffffffffffffffffffffff"); + hashes.push_back(util::fromHex("ffffffffffffffffffffffffffffffffffffffff")); + hashes.push_back(util::fromHex("ffffffffffffffffffffffffffffffffffffffff")); dctx->setPieceHashes("sha-1", hashes.begin(), hashes.end()); SharedHandle ps(new DefaultPieceStorage(dctx, &option)); ps->initStorage(); diff --git a/test/MessageDigestHelperTest.cc b/test/MessageDigestHelperTest.cc index 83e4b10b..784dee5c 100644 --- a/test/MessageDigestHelperTest.cc +++ b/test/MessageDigestHelperTest.cc @@ -11,7 +11,7 @@ namespace aria2 { class MessageDigestHelperTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE(MessageDigestHelperTest); - CPPUNIT_TEST(testHexDigestDiskWriter); + CPPUNIT_TEST(testDigestDiskWriter); CPPUNIT_TEST_SUITE_END(); private: @@ -19,24 +19,24 @@ public: void setUp() { } - void testHexDigestDiskWriter(); + void testDigestDiskWriter(); }; CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestHelperTest ); -void MessageDigestHelperTest::testHexDigestDiskWriter() { +void MessageDigestHelperTest::testDigestDiskWriter() { SharedHandle diskio (new DefaultDiskWriter(A2_TEST_DIR"/4096chunk.txt")); diskio->enableReadOnly(); diskio->openExistingFile(); CPPUNIT_ASSERT_EQUAL(std::string("608cabc0f2fa18c260cafd974516865c772363d5"), - message_digest::hexDigest - (MessageDigest::sha1(), diskio, 0, 4096)); + util::toHex(message_digest::digest + (MessageDigest::sha1(), diskio, 0, 4096))); CPPUNIT_ASSERT_EQUAL(std::string("7a4a9ae537ebbbb826b1060e704490ad0f365ead"), - message_digest::hexDigest - (MessageDigest::sha1(), diskio, 5, 100)); + util::toHex(message_digest::digest + (MessageDigest::sha1(), diskio, 5, 100))); } } // namespace aria2 diff --git a/test/MessageDigestTest.cc b/test/MessageDigestTest.cc index 627597da..c1b25e40 100644 --- a/test/MessageDigestTest.cc +++ b/test/MessageDigestTest.cc @@ -9,7 +9,7 @@ namespace aria2 { class MessageDigestTest:public CppUnit::TestFixture { CPPUNIT_TEST_SUITE(MessageDigestTest); - CPPUNIT_TEST(testHexDigest); + CPPUNIT_TEST(testDigest); CPPUNIT_TEST(testSupports); CPPUNIT_TEST(testGetDigestLength); CPPUNIT_TEST(testIsStronger); @@ -24,7 +24,7 @@ public: sha1_ = MessageDigest::sha1(); } - void testHexDigest(); + void testDigest(); void testSupports(); void testGetDigestLength(); void testIsStronger(); @@ -35,11 +35,11 @@ public: CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestTest ); -void MessageDigestTest::testHexDigest() +void MessageDigestTest::testDigest() { sha1_->update("aria2", 5); CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"), - sha1_->hexDigest()); + util::toHex(sha1_->digest())); } void MessageDigestTest::testSupports() diff --git a/test/Metalink2RequestGroupTest.cc b/test/Metalink2RequestGroupTest.cc index 089c49ec..a69df183 100644 --- a/test/Metalink2RequestGroupTest.cc +++ b/test/Metalink2RequestGroupTest.cc @@ -63,7 +63,7 @@ void Metalink2RequestGroupTest::testGenerate() CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType()); CPPUNIT_ASSERT_EQUAL (std::string("a96cf3f0266b91d87d5124cf94326422800b627d"), - dctx->getDigest()); + util::toHex(dctx->getDigest())); #endif // ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT(dctx->getSignature()); CPPUNIT_ASSERT_EQUAL(std::string("pgp"), dctx->getSignature()->getType()); @@ -85,7 +85,7 @@ void Metalink2RequestGroupTest::testGenerate() CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType()); CPPUNIT_ASSERT_EQUAL (std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"), - dctx->getDigest()); + util::toHex(dctx->getDigest())); #endif // ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT(!dctx->getSignature()); } diff --git a/test/MetalinkParserControllerTest.cc b/test/MetalinkParserControllerTest.cc index 89fb3880..1b1747b0 100644 --- a/test/MetalinkParserControllerTest.cc +++ b/test/MetalinkParserControllerTest.cc @@ -207,7 +207,7 @@ void MetalinkParserControllerTest::testChecksumTransaction() SharedHandle md = m->getEntries().front()->checksum; CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType()); CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"), - md->getDigest()); + util::toHex(md->getDigest())); } ctrl.newEntryTransaction(); ctrl.newChecksumTransaction(); @@ -288,13 +288,13 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4() CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash()); CPPUNIT_ASSERT_EQUAL (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"), - md->getPieceHashes()[0]); + util::toHex(md->getPieceHashes()[0])); CPPUNIT_ASSERT_EQUAL (std::string("9413ee70957a09d55704123687478e07f18c7b29"), - md->getPieceHashes()[1]); + util::toHex(md->getPieceHashes()[1])); CPPUNIT_ASSERT_EQUAL (std::string("44213f9f4d59b557314fadcd233232eebcac8012"), - md->getPieceHashes()[2]); + util::toHex(md->getPieceHashes()[2])); } ctrl.newEntryTransaction(); ctrl.newChunkChecksumTransactionV4(); diff --git a/test/MetalinkProcessorTest.cc b/test/MetalinkProcessorTest.cc index 64e0cd5d..8dd2d10b 100644 --- a/test/MetalinkProcessorTest.cc +++ b/test/MetalinkProcessorTest.cc @@ -20,6 +20,7 @@ #include "Signature.h" #include "fmt.h" #include "RecoverableException.h" +#include "util.h" namespace aria2 { @@ -93,7 +94,7 @@ void MetalinkProcessorTest::testParseFileV4() CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), - e->checksum->getDigest()); + util::toHex(e->checksum->getDigest())); CPPUNIT_ASSERT(e->checksum); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getHashType()); CPPUNIT_ASSERT(e->chunkChecksum); @@ -102,24 +103,24 @@ void MetalinkProcessorTest::testParseFileV4() CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength()); CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash()); CPPUNIT_ASSERT_EQUAL(std::string("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"), - e->chunkChecksum->getPieceHash(0)); + util::toHex(e->chunkChecksum->getPieceHash(0))); CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"), - e->chunkChecksum->getPieceHash(1)); + util::toHex(e->chunkChecksum->getPieceHash(1))); CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"), - e->chunkChecksum->getPieceHash(2)); + util::toHex(e->chunkChecksum->getPieceHash(2))); } else { CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getHashType()); CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength()); CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash()); CPPUNIT_ASSERT_EQUAL (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"), - e->chunkChecksum->getPieceHash(0)); + util::toHex(e->chunkChecksum->getPieceHash(0))); CPPUNIT_ASSERT_EQUAL (std::string("9413ee70957a09d55704123687478e07f18c7b29"), - e->chunkChecksum->getPieceHash(1)); + util::toHex(e->chunkChecksum->getPieceHash(1))); CPPUNIT_ASSERT_EQUAL (std::string("44213f9f4d59b557314fadcd233232eebcac8012"), - e->chunkChecksum->getPieceHash(2)); + util::toHex(e->chunkChecksum->getPieceHash(2))); } #endif // ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT(e->getSignature()); @@ -508,7 +509,7 @@ void MetalinkProcessorTest::testParseFile() CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"), - entry1->checksum->getDigest()); + util::toHex(entry1->checksum->getDigest())); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getHashType()); #endif // ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT(entry1->getSignature()); @@ -557,13 +558,13 @@ void MetalinkProcessorTest::testParseFile() CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections); #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"), - entry2->checksum->getDigest()); + util::toHex(entry2->checksum->getDigest())); CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countPieceHash()); CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getPieceLength()); CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"), - entry2->chunkChecksum->getPieceHash(0)); + util::toHex(entry2->chunkChecksum->getPieceHash(0))); CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"), - entry2->chunkChecksum->getPieceHash(1)); + util::toHex(entry2->chunkChecksum->getPieceHash(1))); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getHashType()); #endif // ENABLE_MESSAGE_DIGEST // See that signature is null @@ -587,7 +588,7 @@ void MetalinkProcessorTest::testParseFile() #ifdef ENABLE_MESSAGE_DIGEST CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType()); CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"), - entry4->checksum->getDigest()); + util::toHex(entry4->checksum->getDigest())); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getHashType()); #endif // ENABLE_MESSAGE_DIGEST diff --git a/test/MockSegment.h b/test/MockSegment.h index 5be67fc8..baef109b 100644 --- a/test/MockSegment.h +++ b/test/MockSegment.h @@ -60,7 +60,7 @@ public: return false; } - virtual std::string getHashString() + virtual std::string getDigest() { return A2STR::NIL; } diff --git a/test/PieceTest.cc b/test/PieceTest.cc index e714952e..92bd1271 100644 --- a/test/PieceTest.cc +++ b/test/PieceTest.cc @@ -4,6 +4,8 @@ #include +#include "util.h" + namespace aria2 { class PieceTest:public CppUnit::TestFixture { @@ -81,7 +83,7 @@ void PieceTest::testUpdateHash() CPPUNIT_ASSERT(p.isHashCalculated()); CPPUNIT_ASSERT_EQUAL(std::string("d9189aff79e075a2e60271b9556a710dc1bc7de7"), - p.getHashString()); + util::toHex(p.getDigest())); } #endif // ENABLE_MESSAGE_DIGEST diff --git a/test/TestUtil.cc b/test/TestUtil.cc index 70ad6e7d..fee39055 100644 --- a/test/TestUtil.cc +++ b/test/TestUtil.cc @@ -14,6 +14,7 @@ #include "Cookie.h" #include "DefaultDiskWriter.h" #include "fmt.h" +#include "util.h" #ifdef ENABLE_MESSAGE_DIGEST # include "message_digest_helper.h" #endif // ENABLE_MESSAGE_DIGEST @@ -81,7 +82,7 @@ std::string fileHexDigest { SharedHandle writer(new DefaultDiskWriter(filename)); writer->openExistingFile(); - return message_digest::hexDigest(ctx, writer, 0, writer->size()); + return util::toHex(message_digest::digest(ctx, writer, 0, writer->size())); } #endif // ENABLE_MESSAGE_DIGEST