[apt.git] / test / libapt / hashsums_test.cc

#include <config.h>

#include <apt-pkg/configuration.h>
#include <apt-pkg/md5.h>
#include <apt-pkg/sha1.h>
#include <apt-pkg/sha2.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/hashes.h>
#include <apt-pkg/fileutl.h>

#include <iostream>
#include <stdlib.h>
#include <string>

#include <gtest/gtest.h>

#include "file-helpers.h"

template <class T> void Test(const char *In,const char *Out)
{
   T Sum;
   Sum.Add(In);
   equals(Sum.Result().Value(), Out);
}


TEST(HashSumsTest,SummationStrings)
{
#define EXPECT_SUM(Summation, In, Out) \
   { \
      Summation Sum; \
      Sum.Add(In); \
      EXPECT_EQ(Sum.Result().Value(), Out) << #Summation << " for '" << In << "'"; \
   }

   // From  FIPS PUB 180-1
   EXPECT_SUM(SHA1Summation, "","da39a3ee5e6b4b0d3255bfef95601890afd80709");
   EXPECT_SUM(SHA1Summation, "abc","a9993e364706816aba3e25717850c26c9cd0d89d");
   EXPECT_SUM(SHA1Summation, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
	 "84983e441c3bd26ebaae4aa1f95129e5e54670f1");

   // MD5 tests from RFC 1321
   EXPECT_SUM(MD5Summation, "","d41d8cd98f00b204e9800998ecf8427e");
   EXPECT_SUM(MD5Summation, "a","0cc175b9c0f1b6a831c399e269772661");
   EXPECT_SUM(MD5Summation, "abc","900150983cd24fb0d6963f7d28e17f72");
   EXPECT_SUM(MD5Summation, "message digest","f96b697d7cb7938d525a2f31aaf161d0");
   EXPECT_SUM(MD5Summation, "abcdefghijklmnopqrstuvwxyz","c3fcd3d76192e4007dfb496cca67e13b");
   EXPECT_SUM(MD5Summation, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
	 "d174ab98d277d9f5a5611c2c9f419d9f");
   EXPECT_SUM(MD5Summation, "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
	 "57edf4a22be3c955ac49da2e2107b67a");

   // SHA-256, From FIPS 180-2
   EXPECT_SUM(SHA256Summation, "", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
   EXPECT_SUM(SHA256Summation, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
	 "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");

   // SHA-512
   EXPECT_SUM(SHA512Summation, "",
	 "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce"
	 "47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
   EXPECT_SUM(SHA512Summation, "abc",
	 "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
	 "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");


   EXPECT_SUM(MD5Summation, "The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6");
   EXPECT_SUM(MD5Summation, "The quick brown fox jumps over the lazy dog.", "e4d909c290d0fb1ca068ffaddf22cbd0");
   EXPECT_SUM(SHA1Summation, "The quick brown fox jumps over the lazy dog", "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
   EXPECT_SUM(SHA1Summation, "The quick brown fox jumps over the lazy cog", "de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3");
   EXPECT_SUM(SHA256Summation, "The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
   EXPECT_SUM(SHA256Summation, "The quick brown fox jumps over the lazy dog.", "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c");
   EXPECT_SUM(SHA512Summation, "The quick brown fox jumps over the lazy dog", "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb64"
	 "2e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6");
   EXPECT_SUM(SHA512Summation, "The quick brown fox jumps over the lazy dog.", "91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bb"
	 "c6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed");

#undef EXPECT_SUM
}
TEST(HashSumsTest, Mill)
{
   SHA1Summation Sum1;

   const unsigned char As[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   size_t const AsCount = sizeof(As)/sizeof(As[0]) - 1;
   size_t Count = 1000000;
   while (Count != 0)
   {
      if (Count >= AsCount)
      {
	 Sum1.Add(As, AsCount);
	 Count -= AsCount;
      }
      else
      {
	 Sum1.Add(As,Count);
	 Count = 0;
      }
   }

   EXPECT_EQ("34aa973cd4c4daa4f61eeb2bdbad27316534016f", Sum1.Result().Value());
}

static void getSummationString(char const * const type, std::string &sum)
{
   /* to compare our result with an independent source we call the specific binaries
      and read their result back. We do this with a little trick by claiming that the
      summation is a compressor – and open the 'compressed' file later on directly to
      read out the summation sum calculated by it */
   APT::Configuration::Compressor compress(type, ".ext", type, NULL, NULL, 99);
   std::string name("apt-test-");
   name.append("hashsums").append(".XXXXXX");
   char * tempfile = strdup(name.c_str());
   int tempfile_fd = mkstemp(tempfile);
   close(tempfile_fd);
   ASSERT_NE(-1, tempfile_fd);

   FileFd fd;
   ASSERT_TRUE(fd.Open(tempfile, FileFd::WriteOnly | FileFd::Empty, compress));
   ASSERT_TRUE(fd.IsOpen());
   FileFd input(__FILE__, FileFd::ReadOnly);
   ASSERT_TRUE(input.IsOpen());
   ASSERT_NE(0, input.FileSize());
   ASSERT_TRUE(CopyFile(input, fd));
   ASSERT_TRUE(input.IsOpen());
   ASSERT_TRUE(fd.IsOpen());
   ASSERT_FALSE(fd.Failed());
   input.Close();
   fd.Close();
   ASSERT_TRUE(fd.Open(tempfile, FileFd::ReadOnly, FileFd::None));
   ASSERT_TRUE(fd.IsOpen());
   ASSERT_NE(0, fd.FileSize());
   ASSERT_FALSE(fd.Failed());
   unlink(tempfile);
   free(tempfile);
   char readback[2000];
   unsigned long long actual;
   ASSERT_TRUE(fd.Read(readback, sizeof(readback)/sizeof(readback[0]), &actual));
   actual -= 4;
   readback[actual] = '\0';
   sum = readback;
}
TEST(HashSumsTest, FileBased)
{
   std::string summation;

   getSummationString("md5sum", summation);
   MD5SumValue md5(summation);
   EXPECT_EQ(md5.Value(), summation);

   getSummationString("sha1sum", summation);
   SHA1SumValue sha1(summation);
   EXPECT_EQ(sha1.Value(), summation);

   getSummationString("sha256sum", summation);
   SHA256SumValue sha256(summation);
   EXPECT_EQ(sha256.Value(), summation);

   getSummationString("sha512sum", summation);
   SHA512SumValue sha512(summation);
   EXPECT_EQ(sha512.Value(), summation);

   FileFd fd(__FILE__, FileFd::ReadOnly);
   EXPECT_TRUE(fd.IsOpen());
   std::string FileSize;
   strprintf(FileSize, "%llu", fd.FileSize());

   {
      Hashes hashes;
      hashes.AddFD(fd.Fd());
      HashStringList list = hashes.GetHashStringList();
      EXPECT_FALSE(list.empty());
      EXPECT_EQ(5, list.size());
      EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
      EXPECT_EQ(sha1.Value(), list.find("SHA1")->HashValue());
      EXPECT_EQ(sha256.Value(), list.find("SHA256")->HashValue());
      EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
      EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
   }
   unsigned long long sz = fd.FileSize();
   fd.Seek(0);
   {
      Hashes hashes;
      hashes.AddFD(fd.Fd(), sz);
      HashStringList list = hashes.GetHashStringList();
      EXPECT_FALSE(list.empty());
      EXPECT_EQ(5, list.size());
      EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
      EXPECT_EQ(sha1.Value(), list.find("SHA1")->HashValue());
      EXPECT_EQ(sha256.Value(), list.find("SHA256")->HashValue());
      EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
      EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
   }
   fd.Seek(0);
   {
      Hashes hashes(Hashes::MD5SUM | Hashes::SHA512SUM);
      hashes.AddFD(fd);
      HashStringList list = hashes.GetHashStringList();
      EXPECT_FALSE(list.empty());
      EXPECT_EQ(3, list.size());
      EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
      EXPECT_EQ(NULL, list.find("SHA1"));
      EXPECT_EQ(NULL, list.find("SHA256"));
      EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
      EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
      fd.Seek(0);
      Hashes hashes2(list);
      hashes2.AddFD(fd);
      list = hashes2.GetHashStringList();
      EXPECT_FALSE(list.empty());
      EXPECT_EQ(3, list.size());
      EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
      EXPECT_EQ(NULL, list.find("SHA1"));
      EXPECT_EQ(NULL, list.find("SHA256"));
      EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
      EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
   }
   fd.Seek(0);
   {
      MD5Summation MD5;
      MD5.AddFD(fd.Fd());
      EXPECT_EQ(md5.Value(), MD5.Result().Value());
   }
   fd.Seek(0);
   {
      SHA1Summation SHA1;
      SHA1.AddFD(fd.Fd());
      EXPECT_EQ(sha1.Value(), SHA1.Result().Value());
   }
   fd.Seek(0);
   {
      SHA256Summation SHA2;
      SHA2.AddFD(fd.Fd());
      EXPECT_EQ(sha256.Value(), SHA2.Result().Value());
   }
   fd.Seek(0);
   {
      SHA512Summation SHA2;
      SHA2.AddFD(fd.Fd());
      EXPECT_EQ(sha512.Value(), SHA2.Result().Value());
   }
   fd.Close();

   HashString sha2file("SHA512", sha512.Value());
   EXPECT_TRUE(sha2file.VerifyFile(__FILE__));
   HashString sha2wrong("SHA512", "00000000000");
   EXPECT_FALSE(sha2wrong.VerifyFile(__FILE__));
   EXPECT_EQ(sha2file, sha2file);
   EXPECT_TRUE(sha2file == sha2file);
   EXPECT_NE(sha2file, sha2wrong);
   EXPECT_TRUE(sha2file != sha2wrong);

   HashString sha2big("SHA256", sha256.Value());
   EXPECT_TRUE(sha2big.VerifyFile(__FILE__));
   HashString sha2small("sha256:" + sha256.Value());
   EXPECT_TRUE(sha2small.VerifyFile(__FILE__));
   EXPECT_EQ(sha2big, sha2small);
   EXPECT_TRUE(sha2big == sha2small);
   EXPECT_FALSE(sha2big != sha2small);

   HashStringList hashes;
   EXPECT_TRUE(hashes.empty());
   EXPECT_TRUE(hashes.push_back(sha2file));
   EXPECT_FALSE(hashes.empty());
   EXPECT_EQ(1, hashes.size());

   HashStringList wrong;
   EXPECT_TRUE(wrong.push_back(sha2wrong));
   EXPECT_NE(wrong, hashes);
   EXPECT_FALSE(wrong == hashes);
   EXPECT_TRUE(wrong != hashes);

   HashStringList similar;
   EXPECT_TRUE(similar.push_back(sha2big));
   EXPECT_NE(similar, hashes);
   EXPECT_FALSE(similar == hashes);
   EXPECT_TRUE(similar != hashes);

   EXPECT_TRUE(hashes.push_back(sha2big));
   EXPECT_EQ(2, hashes.size());
   EXPECT_TRUE(hashes.push_back(sha2small));
   EXPECT_EQ(2, hashes.size());
   EXPECT_FALSE(hashes.push_back(sha2wrong));
   EXPECT_EQ(2, hashes.size());
   EXPECT_TRUE(hashes.VerifyFile(__FILE__));

   EXPECT_EQ(similar, hashes);
   EXPECT_TRUE(similar == hashes);
   EXPECT_FALSE(similar != hashes);
   similar.clear();
   EXPECT_TRUE(similar.empty());
   EXPECT_EQ(0, similar.size());
   EXPECT_NE(similar, hashes);
   EXPECT_FALSE(similar == hashes);
   EXPECT_TRUE(similar != hashes);
}
TEST(HashSumsTest, HashStringList)
{
   _config->Clear("Acquire::ForceHash");

   HashStringList list;
   EXPECT_TRUE(list.empty());
   EXPECT_FALSE(list.usable());
   EXPECT_EQ(0, list.size());
   EXPECT_EQ(NULL, list.find(NULL));
   EXPECT_EQ(NULL, list.find(""));
   EXPECT_EQ(NULL, list.find("MD5Sum"));
   EXPECT_EQ(NULL, list.find("ROT26"));
   EXPECT_EQ(NULL, list.find("SHA1"));
   EXPECT_EQ(0, list.FileSize());

   // empty lists aren't equal
   HashStringList list2;
   EXPECT_FALSE(list == list2);
   EXPECT_TRUE(list != list2);

   // some hashes don't really contribute to usability
   list.push_back(HashString("Checksum-FileSize", "29"));
   EXPECT_FALSE(list.empty());
   EXPECT_FALSE(list.usable());
   EXPECT_EQ(1, list.size());
   EXPECT_EQ(29, list.FileSize());
   list.push_back(HashString("MD5Sum", "d41d8cd98f00b204e9800998ecf8427e"));
   EXPECT_FALSE(list.empty());
   EXPECT_FALSE(list.usable());
   EXPECT_EQ(2, list.size());
   EXPECT_EQ(29, list.FileSize());
   EXPECT_TRUE(NULL != list.find("MD5Sum"));
   list.push_back(HashString("SHA1", "cacecbd74968bc90ea3342767e6b94f46ddbcafc"));
   EXPECT_TRUE(list.usable());
   EXPECT_EQ(3, list.size());
   EXPECT_EQ(29, list.FileSize());
   EXPECT_TRUE(NULL != list.find("MD5Sum"));
   EXPECT_TRUE(NULL != list.find("SHA1"));

   Hashes hashes;
   hashes.Add("The quick brown fox jumps over the lazy dog");
   list = hashes.GetHashStringList();
   EXPECT_FALSE(list.empty());
   EXPECT_TRUE(list.usable());
   EXPECT_EQ(5, list.size());
   EXPECT_TRUE(NULL != list.find(NULL));
   EXPECT_TRUE(NULL != list.find(""));
   EXPECT_TRUE(NULL != list.find("MD5Sum"));
   EXPECT_TRUE(NULL != list.find("Checksum-FileSize"));
   EXPECT_TRUE(NULL == list.find("ROT26"));

   _config->Set("Acquire::ForceHash", "MD5Sum");
   EXPECT_FALSE(list.empty());
   EXPECT_TRUE(list.usable());
   EXPECT_EQ(5, list.size());
   EXPECT_TRUE(NULL != list.find(NULL));
   EXPECT_TRUE(NULL != list.find(""));
   EXPECT_TRUE(NULL != list.find("MD5Sum"));
   EXPECT_TRUE(NULL != list.find("Checksum-FileSize"));
   EXPECT_TRUE(NULL == list.find("ROT26"));

   _config->Set("Acquire::ForceHash", "ROT26");
   EXPECT_FALSE(list.empty());
   EXPECT_FALSE(list.usable());
   EXPECT_EQ(5, list.size());
   EXPECT_TRUE(NULL == list.find(NULL));
   EXPECT_TRUE(NULL == list.find(""));
   EXPECT_TRUE(NULL != list.find("MD5Sum"));
   EXPECT_TRUE(NULL != list.find("Checksum-FileSize"));
   EXPECT_TRUE(NULL == list.find("ROT26"));

   _config->Clear("Acquire::ForceHash");

   list2.push_back(*list.find("MD5Sum"));
   EXPECT_TRUE(list == list2);
   EXPECT_FALSE(list != list2);

   // introduce a mismatch to the list
   list2.push_back(HashString("SHA1", "cacecbd74968bc90ea3342767e6b94f46ddbcafc"));
   EXPECT_FALSE(list == list2);
   EXPECT_TRUE(list != list2);

   _config->Set("Acquire::ForceHash", "MD5Sum");
   EXPECT_TRUE(list == list2);
   EXPECT_FALSE(list != list2);

   _config->Clear("Acquire::ForceHash");
}
Commit	Line	Data
453b82a3 DK	1	#include <config.h>
453b82a3 DK	2
b3501edb	3	#include <apt-pkg/configuration.h>
67dc3830 DK	4	#include <apt-pkg/md5.h>
	5	#include <apt-pkg/sha1.h>
	6	#include <apt-pkg/sha2.h>
	7	#include <apt-pkg/strutl.h>
	8	#include <apt-pkg/hashes.h>
163d39cc	9	#include <apt-pkg/fileutl.h>
67dc3830	10
453b82a3 DK	11	#include <iostream>
	12	#include <stdlib.h>
	13	#include <string>
67dc3830	14
f00832cc DK	15	#include <gtest/gtest.h>
	16
	17	#include "file-helpers.h"
67dc3830 DK	18
	19	template <class T> void Test(const char In,const char Out)
	20	{
	21	T Sum;
	22	Sum.Add(In);
	23	equals(Sum.Result().Value(), Out);
	24	}
	25
f00832cc DK	26
	27
	28	TEST(HashSumsTest,SummationStrings)
67dc3830	29	{
f00832cc DK	30	#define EXPECT_SUM(Summation, In, Out) \
	31	{ \
	32	Summation Sum; \
	33	Sum.Add(In); \
	34	EXPECT_EQ(Sum.Result().Value(), Out) << #Summation << " for '" << In << "'"; \
	35	}
	36
	37	// From FIPS PUB 180-1
	38	EXPECT_SUM(SHA1Summation, "","da39a3ee5e6b4b0d3255bfef95601890afd80709");
	39	EXPECT_SUM(SHA1Summation, "abc","a9993e364706816aba3e25717850c26c9cd0d89d");
	40	EXPECT_SUM(SHA1Summation, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
	41	"84983e441c3bd26ebaae4aa1f95129e5e54670f1");
	42
	43	// MD5 tests from RFC 1321
	44	EXPECT_SUM(MD5Summation, "","d41d8cd98f00b204e9800998ecf8427e");
	45	EXPECT_SUM(MD5Summation, "a","0cc175b9c0f1b6a831c399e269772661");
	46	EXPECT_SUM(MD5Summation, "abc","900150983cd24fb0d6963f7d28e17f72");
	47	EXPECT_SUM(MD5Summation, "message digest","f96b697d7cb7938d525a2f31aaf161d0");
	48	EXPECT_SUM(MD5Summation, "abcdefghijklmnopqrstuvwxyz","c3fcd3d76192e4007dfb496cca67e13b");
	49	EXPECT_SUM(MD5Summation, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
	50	"d174ab98d277d9f5a5611c2c9f419d9f");
	51	EXPECT_SUM(MD5Summation, "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
	52	"57edf4a22be3c955ac49da2e2107b67a");
67dc3830	53
f00832cc DK	54	// SHA-256, From FIPS 180-2
	55	EXPECT_SUM(SHA256Summation, "", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
	56	EXPECT_SUM(SHA256Summation, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
	57	"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");
	58
	59	// SHA-512
	60	EXPECT_SUM(SHA512Summation, "",
	61	"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce"
	62	"47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e");
	63	EXPECT_SUM(SHA512Summation, "abc",
	64	"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
	65	"2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
	66
	67
	68	EXPECT_SUM(MD5Summation, "The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6");
	69	EXPECT_SUM(MD5Summation, "The quick brown fox jumps over the lazy dog.", "e4d909c290d0fb1ca068ffaddf22cbd0");
	70	EXPECT_SUM(SHA1Summation, "The quick brown fox jumps over the lazy dog", "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
	71	EXPECT_SUM(SHA1Summation, "The quick brown fox jumps over the lazy cog", "de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3");
	72	EXPECT_SUM(SHA256Summation, "The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
	73	EXPECT_SUM(SHA256Summation, "The quick brown fox jumps over the lazy dog.", "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c");
	74	EXPECT_SUM(SHA512Summation, "The quick brown fox jumps over the lazy dog", "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb64"
	75	"2e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6");
	76	EXPECT_SUM(SHA512Summation, "The quick brown fox jumps over the lazy dog.", "91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bb"
	77	"c6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed");
	78
	79	#undef EXPECT_SUM
	80	}
	81	TEST(HashSumsTest, Mill)
	82	{
	83	SHA1Summation Sum1;
	84
	85	const unsigned char As[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
	86	size_t const AsCount = sizeof(As)/sizeof(As[0]) - 1;
	87	size_t Count = 1000000;
	88	while (Count != 0)
67dc3830	89	{
f00832cc	90	if (Count >= AsCount)
67dc3830	91	{
f00832cc DK	92	Sum1.Add(As, AsCount);
f00832cc DK	93	Count -= AsCount;
67dc3830 DK	94	}
	95	else
	96	{
f00832cc	97	Sum1.Add(As,Count);
67dc3830 DK	98	Count = 0;
	99	}
	100	}
	101
f00832cc	102	EXPECT_EQ("34aa973cd4c4daa4f61eeb2bdbad27316534016f", Sum1.Result().Value());
67dc3830 DK	103	}
67dc3830 DK	104
f00832cc	105	static void getSummationString(char const * const type, std::string &sum)
67dc3830	106	{
f00832cc DK	107	/* to compare our result with an independent source we call the specific binaries
	108	and read their result back. We do this with a little trick by claiming that the
	109	summation is a compressor – and open the 'compressed' file later on directly to
	110	read out the summation sum calculated by it */
	111	APT::Configuration::Compressor compress(type, ".ext", type, NULL, NULL, 99);
	112	std::string name("apt-test-");
	113	name.append("hashsums").append(".XXXXXX");
	114	char * tempfile = strdup(name.c_str());
	115	int tempfile_fd = mkstemp(tempfile);
	116	close(tempfile_fd);
	117	ASSERT_NE(-1, tempfile_fd);
	118
	119	FileFd fd;
	120	ASSERT_TRUE(fd.Open(tempfile, FileFd::WriteOnly \| FileFd::Empty, compress));
	121	ASSERT_TRUE(fd.IsOpen());
	122	FileFd input(__FILE__, FileFd::ReadOnly);
	123	ASSERT_TRUE(input.IsOpen());
	124	ASSERT_NE(0, input.FileSize());
	125	ASSERT_TRUE(CopyFile(input, fd));
	126	ASSERT_TRUE(input.IsOpen());
	127	ASSERT_TRUE(fd.IsOpen());
	128	ASSERT_FALSE(fd.Failed());
	129	input.Close();
	130	fd.Close();
	131	ASSERT_TRUE(fd.Open(tempfile, FileFd::ReadOnly, FileFd::None));
	132	ASSERT_TRUE(fd.IsOpen());
	133	ASSERT_NE(0, fd.FileSize());
	134	ASSERT_FALSE(fd.Failed());
	135	unlink(tempfile);
	136	free(tempfile);
	137	char readback[2000];
	138	unsigned long long actual;
	139	ASSERT_TRUE(fd.Read(readback, sizeof(readback)/sizeof(readback[0]), &actual));
	140	actual -= 4;
	141	readback[actual] = '\0';
	142	sum = readback;
	143	}
	144	TEST(HashSumsTest, FileBased)
	145	{
	146	std::string summation;
65512241	147
f00832cc DK	148	getSummationString("md5sum", summation);
	149	MD5SumValue md5(summation);
	150	EXPECT_EQ(md5.Value(), summation);
9a4ffe57	151
f00832cc DK	152	getSummationString("sha1sum", summation);
	153	SHA1SumValue sha1(summation);
	154	EXPECT_EQ(sha1.Value(), summation);
67dc3830	155
f00832cc DK	156	getSummationString("sha256sum", summation);
	157	SHA256SumValue sha256(summation);
	158	EXPECT_EQ(sha256.Value(), summation);
67dc3830	159
f00832cc DK	160	getSummationString("sha512sum", summation);
	161	SHA512SumValue sha512(summation);
	162	EXPECT_EQ(sha512.Value(), summation);
	163
	164	FileFd fd(__FILE__, FileFd::ReadOnly);
	165	EXPECT_TRUE(fd.IsOpen());
23397c9d DK	166	std::string FileSize;
23397c9d DK	167	strprintf(FileSize, "%llu", fd.FileSize());
67dc3830	168
96c9fb17	169	{
f00832cc DK	170	Hashes hashes;
f00832cc DK	171	hashes.AddFD(fd.Fd());
b3501edb DK	172	HashStringList list = hashes.GetHashStringList();
b3501edb DK	173	EXPECT_FALSE(list.empty());
23397c9d	174	EXPECT_EQ(5, list.size());
b3501edb DK	175	EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
	176	EXPECT_EQ(sha1.Value(), list.find("SHA1")->HashValue());
	177	EXPECT_EQ(sha256.Value(), list.find("SHA256")->HashValue());
	178	EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
23397c9d	179	EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
96c9fb17	180	}
23397c9d	181	unsigned long long sz = fd.FileSize();
163d39cc	182	fd.Seek(0);
96c9fb17	183	{
f00832cc DK	184	Hashes hashes;
f00832cc DK	185	hashes.AddFD(fd.Fd(), sz);
b3501edb DK	186	HashStringList list = hashes.GetHashStringList();
b3501edb DK	187	EXPECT_FALSE(list.empty());
23397c9d	188	EXPECT_EQ(5, list.size());
b3501edb DK	189	EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
	190	EXPECT_EQ(sha1.Value(), list.find("SHA1")->HashValue());
	191	EXPECT_EQ(sha256.Value(), list.find("SHA256")->HashValue());
	192	EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
23397c9d	193	EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
96c9fb17	194	}
163d39cc	195	fd.Seek(0);
9224ce3d DK	196	{
	197	Hashes hashes(Hashes::MD5SUM \| Hashes::SHA512SUM);
	198	hashes.AddFD(fd);
	199	HashStringList list = hashes.GetHashStringList();
	200	EXPECT_FALSE(list.empty());
	201	EXPECT_EQ(3, list.size());
	202	EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
	203	EXPECT_EQ(NULL, list.find("SHA1"));
	204	EXPECT_EQ(NULL, list.find("SHA256"));
	205	EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
	206	EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
	207	fd.Seek(0);
	208	Hashes hashes2(list);
	209	hashes2.AddFD(fd);
	210	list = hashes2.GetHashStringList();
	211	EXPECT_FALSE(list.empty());
	212	EXPECT_EQ(3, list.size());
	213	EXPECT_EQ(md5.Value(), list.find("MD5Sum")->HashValue());
	214	EXPECT_EQ(NULL, list.find("SHA1"));
	215	EXPECT_EQ(NULL, list.find("SHA256"));
	216	EXPECT_EQ(sha512.Value(), list.find("SHA512")->HashValue());
	217	EXPECT_EQ(FileSize, list.find("Checksum-FileSize")->HashValue());
	218	}
	219	fd.Seek(0);
96c9fb17	220	{
f00832cc DK	221	MD5Summation MD5;
	222	MD5.AddFD(fd.Fd());
	223	EXPECT_EQ(md5.Value(), MD5.Result().Value());
96c9fb17	224	}
163d39cc	225	fd.Seek(0);
96c9fb17	226	{
f00832cc DK	227	SHA1Summation SHA1;
	228	SHA1.AddFD(fd.Fd());
	229	EXPECT_EQ(sha1.Value(), SHA1.Result().Value());
96c9fb17	230	}
163d39cc	231	fd.Seek(0);
96c9fb17	232	{
f00832cc DK	233	SHA256Summation SHA2;
	234	SHA2.AddFD(fd.Fd());
	235	EXPECT_EQ(sha256.Value(), SHA2.Result().Value());
96c9fb17	236	}
163d39cc	237	fd.Seek(0);
96c9fb17	238	{
f00832cc DK	239	SHA512Summation SHA2;
	240	SHA2.AddFD(fd.Fd());
	241	EXPECT_EQ(sha512.Value(), SHA2.Result().Value());
96c9fb17	242	}
163d39cc	243	fd.Close();
e99a544c	244
f4c3850e DK	245	HashString sha2file("SHA512", sha512.Value());
	246	EXPECT_TRUE(sha2file.VerifyFile(__FILE__));
	247	HashString sha2wrong("SHA512", "00000000000");
	248	EXPECT_FALSE(sha2wrong.VerifyFile(__FILE__));
	249	EXPECT_EQ(sha2file, sha2file);
	250	EXPECT_TRUE(sha2file == sha2file);
	251	EXPECT_NE(sha2file, sha2wrong);
	252	EXPECT_TRUE(sha2file != sha2wrong);
	253
	254	HashString sha2big("SHA256", sha256.Value());
	255	EXPECT_TRUE(sha2big.VerifyFile(__FILE__));
	256	HashString sha2small("sha256:" + sha256.Value());
	257	EXPECT_TRUE(sha2small.VerifyFile(__FILE__));
	258	EXPECT_EQ(sha2big, sha2small);
	259	EXPECT_TRUE(sha2big == sha2small);
	260	EXPECT_FALSE(sha2big != sha2small);
	261
	262	HashStringList hashes;
	263	EXPECT_TRUE(hashes.empty());
	264	EXPECT_TRUE(hashes.push_back(sha2file));
	265	EXPECT_FALSE(hashes.empty());
	266	EXPECT_EQ(1, hashes.size());
	267
	268	HashStringList wrong;
	269	EXPECT_TRUE(wrong.push_back(sha2wrong));
	270	EXPECT_NE(wrong, hashes);
	271	EXPECT_FALSE(wrong == hashes);
	272	EXPECT_TRUE(wrong != hashes);
	273
	274	HashStringList similar;
	275	EXPECT_TRUE(similar.push_back(sha2big));
	276	EXPECT_NE(similar, hashes);
	277	EXPECT_FALSE(similar == hashes);
	278	EXPECT_TRUE(similar != hashes);
	279
	280	EXPECT_TRUE(hashes.push_back(sha2big));
	281	EXPECT_EQ(2, hashes.size());
	282	EXPECT_TRUE(hashes.push_back(sha2small));
	283	EXPECT_EQ(2, hashes.size());
	284	EXPECT_FALSE(hashes.push_back(sha2wrong));
	285	EXPECT_EQ(2, hashes.size());
	286	EXPECT_TRUE(hashes.VerifyFile(__FILE__));
	287
	288	EXPECT_EQ(similar, hashes);
	289	EXPECT_TRUE(similar == hashes);
	290	EXPECT_FALSE(similar != hashes);
	291	similar.clear();
	292	EXPECT_TRUE(similar.empty());
	293	EXPECT_EQ(0, similar.size());
	294	EXPECT_NE(similar, hashes);
	295	EXPECT_FALSE(similar == hashes);
	296	EXPECT_TRUE(similar != hashes);
67dc3830	297	}
b3501edb DK	298	TEST(HashSumsTest, HashStringList)
	299	{
	300	_config->Clear("Acquire::ForceHash");
	301
	302	HashStringList list;
	303	EXPECT_TRUE(list.empty());
	304	EXPECT_FALSE(list.usable());
	305	EXPECT_EQ(0, list.size());
	306	EXPECT_EQ(NULL, list.find(NULL));
	307	EXPECT_EQ(NULL, list.find(""));
	308	EXPECT_EQ(NULL, list.find("MD5Sum"));
63d60998 DK	309	EXPECT_EQ(NULL, list.find("ROT26"));
63d60998 DK	310	EXPECT_EQ(NULL, list.find("SHA1"));
448c38bd	311	EXPECT_EQ(0, list.FileSize());
b3501edb	312
23397c9d	313	// empty lists aren't equal
b3501edb DK	314	HashStringList list2;
	315	EXPECT_FALSE(list == list2);
	316	EXPECT_TRUE(list != list2);
	317
23397c9d DK	318	// some hashes don't really contribute to usability
	319	list.push_back(HashString("Checksum-FileSize", "29"));
	320	EXPECT_FALSE(list.empty());
	321	EXPECT_FALSE(list.usable());
448c38bd DK	322	EXPECT_EQ(1, list.size());
448c38bd DK	323	EXPECT_EQ(29, list.FileSize());
63d60998 DK	324	list.push_back(HashString("MD5Sum", "d41d8cd98f00b204e9800998ecf8427e"));
	325	EXPECT_FALSE(list.empty());
	326	EXPECT_FALSE(list.usable());
	327	EXPECT_EQ(2, list.size());
	328	EXPECT_EQ(29, list.FileSize());
	329	EXPECT_TRUE(NULL != list.find("MD5Sum"));
	330	list.push_back(HashString("SHA1", "cacecbd74968bc90ea3342767e6b94f46ddbcafc"));
	331	EXPECT_TRUE(list.usable());
	332	EXPECT_EQ(3, list.size());
	333	EXPECT_EQ(29, list.FileSize());
	334	EXPECT_TRUE(NULL != list.find("MD5Sum"));
	335	EXPECT_TRUE(NULL != list.find("SHA1"));
23397c9d	336
b3501edb DK	337	Hashes hashes;
	338	hashes.Add("The quick brown fox jumps over the lazy dog");
	339	list = hashes.GetHashStringList();
	340	EXPECT_FALSE(list.empty());
	341	EXPECT_TRUE(list.usable());
23397c9d	342	EXPECT_EQ(5, list.size());
b3501edb DK	343	EXPECT_TRUE(NULL != list.find(NULL));
	344	EXPECT_TRUE(NULL != list.find(""));
	345	EXPECT_TRUE(NULL != list.find("MD5Sum"));
23397c9d	346	EXPECT_TRUE(NULL != list.find("Checksum-FileSize"));
b3501edb DK	347	EXPECT_TRUE(NULL == list.find("ROT26"));
	348
	349	_config->Set("Acquire::ForceHash", "MD5Sum");
	350	EXPECT_FALSE(list.empty());
	351	EXPECT_TRUE(list.usable());
23397c9d	352	EXPECT_EQ(5, list.size());
b3501edb DK	353	EXPECT_TRUE(NULL != list.find(NULL));
	354	EXPECT_TRUE(NULL != list.find(""));
	355	EXPECT_TRUE(NULL != list.find("MD5Sum"));
23397c9d	356	EXPECT_TRUE(NULL != list.find("Checksum-FileSize"));
b3501edb DK	357	EXPECT_TRUE(NULL == list.find("ROT26"));
	358
	359	_config->Set("Acquire::ForceHash", "ROT26");
	360	EXPECT_FALSE(list.empty());
	361	EXPECT_FALSE(list.usable());
23397c9d	362	EXPECT_EQ(5, list.size());
b3501edb DK	363	EXPECT_TRUE(NULL == list.find(NULL));
	364	EXPECT_TRUE(NULL == list.find(""));
	365	EXPECT_TRUE(NULL != list.find("MD5Sum"));
23397c9d	366	EXPECT_TRUE(NULL != list.find("Checksum-FileSize"));
b3501edb DK	367	EXPECT_TRUE(NULL == list.find("ROT26"));
	368
	369	_config->Clear("Acquire::ForceHash");
	370
	371	list2.push_back(*list.find("MD5Sum"));
	372	EXPECT_TRUE(list == list2);
	373	EXPECT_FALSE(list != list2);
	374
	375	// introduce a mismatch to the list
	376	list2.push_back(HashString("SHA1", "cacecbd74968bc90ea3342767e6b94f46ddbcafc"));
	377	EXPECT_FALSE(list == list2);
	378	EXPECT_TRUE(list != list2);
	379
	380	_config->Set("Acquire::ForceHash", "MD5Sum");
	381	EXPECT_TRUE(list == list2);
	382	EXPECT_FALSE(list != list2);
	383
	384	_config->Clear("Acquire::ForceHash");
	385	}