Browse Source

merge lp:~mvo/apt/sha512-template to add support for sha512

debian/1.8.y
Michael Vogt 12 years ago
parent
commit
12cd178d6e
  1. 6
      apt-pkg/acquire-item.cc
  2. 7
      apt-pkg/acquire-method.cc
  3. 1
      apt-pkg/acquire-method.h
  4. 9
      apt-pkg/contrib/hashes.cc
  5. 5
      apt-pkg/contrib/hashes.h
  6. 87
      apt-pkg/contrib/hashsum_template.h
  7. 57
      apt-pkg/contrib/md5.cc
  8. 23
      apt-pkg/contrib/md5.h
  9. 65
      apt-pkg/contrib/sha1.cc
  10. 23
      apt-pkg/contrib/sha1.h
  11. 43
      apt-pkg/contrib/sha2.cc
  12. 114
      apt-pkg/contrib/sha2.h
  13. 424
      apt-pkg/contrib/sha256.cc
  14. 68
      apt-pkg/contrib/sha256.h
  15. 1065
      apt-pkg/contrib/sha2_internal.cc
  16. 197
      apt-pkg/contrib/sha2_internal.h
  17. 10
      apt-pkg/deb/debrecords.cc
  18. 1
      apt-pkg/deb/debrecords.h
  19. 8
      apt-pkg/makefile
  20. 1
      apt-pkg/pkgrecords.h
  21. 1
      apt-pkg/tagfile.cc
  22. 2
      cmdline/apt-get.cc
  23. 3
      debian/changelog
  24. 40
      ftparchive/cachedb.cc
  25. 20
      ftparchive/cachedb.h
  26. 34
      ftparchive/writer.cc
  27. 1
      ftparchive/writer.h
  28. 26
      test/hash.cc

6
apt-pkg/acquire-item.cc

@ -1682,6 +1682,8 @@ bool pkgAcqArchive::QueueNext()
string PkgFile = Parse.FileName();
if (ForceHash.empty() == false)
{
if(stringcasecmp(ForceHash, "sha512") == 0)
ExpectedHash = HashString("SHA512", Parse.SHA512Hash());
if(stringcasecmp(ForceHash, "sha256") == 0)
ExpectedHash = HashString("SHA256", Parse.SHA256Hash());
else if (stringcasecmp(ForceHash, "sha1") == 0)
@ -1692,7 +1694,9 @@ bool pkgAcqArchive::QueueNext()
else
{
string Hash;
if ((Hash = Parse.SHA256Hash()).empty() == false)
if ((Hash = Parse.SHA512Hash()).empty() == false)
ExpectedHash = HashString("SHA512", Hash);
else if ((Hash = Parse.SHA256Hash()).empty() == false)
ExpectedHash = HashString("SHA256", Hash);
else if ((Hash = Parse.SHA1Hash()).empty() == false)
ExpectedHash = HashString("SHA1", Hash);

7
apt-pkg/acquire-method.cc

@ -166,6 +166,8 @@ void pkgAcqMethod::URIDone(FetchResult &Res, FetchResult *Alt)
std::cout << "SHA1-Hash: " << Res.SHA1Sum << "\n";
if (Res.SHA256Sum.empty() == false)
std::cout << "SHA256-Hash: " << Res.SHA256Sum << "\n";
if (Res.SHA512Sum.empty() == false)
std::cout << "SHA512-Hash: " << Res.SHA512Sum << "\n";
if (UsedMirror.empty() == false)
std::cout << "UsedMirror: " << UsedMirror << "\n";
if (Res.GPGVOutput.empty() == false)
@ -199,7 +201,9 @@ void pkgAcqMethod::URIDone(FetchResult &Res, FetchResult *Alt)
std::cout << "Alt-SHA1-Hash: " << Alt->SHA1Sum << "\n";
if (Alt->SHA256Sum.empty() == false)
std::cout << "Alt-SHA256-Hash: " << Alt->SHA256Sum << "\n";
if (Alt->SHA512Sum.empty() == false)
std::cout << "Alt-SHA512-Hash: " << Alt->SHA512Sum << "\n";
if (Alt->IMSHit == true)
std::cout << "Alt-IMS-Hit: true\n";
}
@ -460,5 +464,6 @@ void pkgAcqMethod::FetchResult::TakeHashes(Hashes &Hash)
MD5Sum = Hash.MD5.Result();
SHA1Sum = Hash.SHA1.Result();
SHA256Sum = Hash.SHA256.Result();
SHA512Sum = Hash.SHA512.Result();
}
/*}}}*/

1
apt-pkg/acquire-method.h

@ -46,6 +46,7 @@ class pkgAcqMethod
string MD5Sum;
string SHA1Sum;
string SHA256Sum;
string SHA512Sum;
vector<string> GPGVOutput;
time_t LastModified;
bool IMSHit;

9
apt-pkg/contrib/hashes.cc

@ -23,7 +23,7 @@
const char* HashString::_SupportedHashes[] =
{
"SHA256", "SHA1", "MD5Sum", NULL
"SHA512", "SHA256", "SHA1", "MD5Sum", NULL
};
HashString::HashString()
@ -57,6 +57,7 @@ bool HashString::VerifyFile(string filename) const /*{{{*/
MD5Summation MD5;
SHA1Summation SHA1;
SHA256Summation SHA256;
SHA256Summation SHA512;
string fileHash;
FileFd Fd(filename, FileFd::ReadOnly);
@ -75,6 +76,11 @@ bool HashString::VerifyFile(string filename) const /*{{{*/
SHA256.AddFD(Fd.Fd(), Fd.Size());
fileHash = (string)SHA256.Result();
}
else if (Type == "SHA512")
{
SHA512.AddFD(Fd.Fd(), Fd.Size());
fileHash = (string)SHA512.Result();
}
Fd.Close();
if(_config->FindB("Debug::Hashes",false) == true)
@ -119,6 +125,7 @@ bool Hashes::AddFD(int Fd,unsigned long Size)
MD5.Add(Buf,Res);
SHA1.Add(Buf,Res);
SHA256.Add(Buf,Res);
SHA512.Add(Buf,Res);
}
return true;
}

5
apt-pkg/contrib/hashes.h

@ -16,7 +16,7 @@
#include <apt-pkg/md5.h>
#include <apt-pkg/sha1.h>
#include <apt-pkg/sha256.h>
#include <apt-pkg/sha2.h>
#include <algorithm>
#include <vector>
@ -60,10 +60,11 @@ class Hashes
MD5Summation MD5;
SHA1Summation SHA1;
SHA256Summation SHA256;
SHA512Summation SHA512;
inline bool Add(const unsigned char *Data,unsigned long Size)
{
return MD5.Add(Data,Size) && SHA1.Add(Data,Size) && SHA256.Add(Data,Size);
return MD5.Add(Data,Size) && SHA1.Add(Data,Size) && SHA256.Add(Data,Size) && SHA512.Add(Data,Size);
};
inline bool Add(const char *Data) {return Add((unsigned char *)Data,strlen(Data));};
bool AddFD(int Fd,unsigned long Size);

87
apt-pkg/contrib/hashsum_template.h

@ -0,0 +1,87 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: hashsum_template.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
/* ######################################################################
HashSumValueTemplate - Generic Storage for a hash value
##################################################################### */
/*}}}*/
#ifndef APTPKG_HASHSUM_TEMPLATE_H
#define APTPKG_HASHSUM_TEMPLATE_H
#include <string>
#include <cstring>
#include <algorithm>
#include <stdint.h>
using std::string;
using std::min;
template<int N>
class HashSumValue
{
unsigned char Sum[N/8];
public:
// Accessors
bool operator ==(const HashSumValue &rhs) const
{
return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
};
string Value() const
{
char Conv[16] =
{ '0','1','2','3','4','5','6','7','8','9','a','b',
'c','d','e','f'
};
char Result[((N/8)*2)+1];
Result[(N/8)*2] = 0;
// Convert each char into two letters
int J = 0;
int I = 0;
for (; I != (N/8)*2; J++,I += 2)
{
Result[I] = Conv[Sum[J] >> 4];
Result[I + 1] = Conv[Sum[J] & 0xF];
}
return string(Result);
};
inline void Value(unsigned char S[N/8])
{
for (int I = 0; I != sizeof(Sum); I++)
S[I] = Sum[I];
};
inline operator string() const
{
return Value();
};
bool Set(string Str)
{
return Hex2Num(Str,Sum,sizeof(Sum));
};
inline void Set(unsigned char S[N/8])
{
for (int I = 0; I != sizeof(Sum); I++)
Sum[I] = S[I];
};
HashSumValue(string Str)
{
memset(Sum,0,sizeof(Sum));
Set(Str);
}
HashSumValue()
{
memset(Sum,0,sizeof(Sum));
}
};
#endif

57
apt-pkg/contrib/md5.cc

@ -165,61 +165,6 @@ static void MD5Transform(uint32_t buf[4], uint32_t const in[16])
buf[3] += d;
}
/*}}}*/
// MD5SumValue::MD5SumValue - Constructs the summation from a string /*{{{*/
// ---------------------------------------------------------------------
/* The string form of a MD5 is a 32 character hex number */
MD5SumValue::MD5SumValue(string Str)
{
memset(Sum,0,sizeof(Sum));
Set(Str);
}
/*}}}*/
// MD5SumValue::MD5SumValue - Default constructor /*{{{*/
// ---------------------------------------------------------------------
/* Sets the value to 0 */
MD5SumValue::MD5SumValue()
{
memset(Sum,0,sizeof(Sum));
}
/*}}}*/
// MD5SumValue::Set - Set the sum from a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the hex string into a set of chars */
bool MD5SumValue::Set(string Str)
{
return Hex2Num(Str,Sum,sizeof(Sum));
}
/*}}}*/
// MD5SumValue::Value - Convert the number into a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the set of chars into a hex string in lower case */
string MD5SumValue::Value() const
{
char Conv[16] = {'0','1','2','3','4','5','6','7','8','9','a','b',
'c','d','e','f'};
char Result[33];
Result[32] = 0;
// Convert each char into two letters
int J = 0;
int I = 0;
for (; I != 32; J++, I += 2)
{
Result[I] = Conv[Sum[J] >> 4];
Result[I + 1] = Conv[Sum[J] & 0xF];
}
return string(Result);
}
/*}}}*/
// MD5SumValue::operator == - Comparitor /*{{{*/
// ---------------------------------------------------------------------
/* Call memcmp on the buffer */
bool MD5SumValue::operator ==(const MD5SumValue &rhs) const
{
return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
}
/*}}}*/
// MD5Summation::MD5Summation - Initialize the summer /*{{{*/
// ---------------------------------------------------------------------
/* This assigns the deep magic initial values */
@ -353,7 +298,7 @@ MD5SumValue MD5Summation::Result()
}
MD5SumValue V;
memcpy(V.Sum,buf,16);
V.Set((char *)buf);
return V;
}
/*}}}*/

23
apt-pkg/contrib/md5.h

@ -32,28 +32,11 @@
using std::string;
using std::min;
class MD5Summation;
#include "hashsum_template.h"
class MD5SumValue
{
friend class MD5Summation;
unsigned char Sum[4*4];
public:
// Accessors
bool operator ==(const MD5SumValue &rhs) const;
string Value() const;
inline void Value(unsigned char S[16])
{for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
inline operator string() const {return Value();};
bool Set(string Str);
inline void Set(unsigned char S[16])
{for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};
class MD5Summation;
MD5SumValue(string Str);
MD5SumValue();
};
typedef HashSumValue<128> MD5SumValue;
class MD5Summation
{

65
apt-pkg/contrib/sha1.cc

@ -178,67 +178,6 @@ static void SHA1Transform(uint32_t state[5],uint8_t const buffer[64])
}
/*}}}*/
// SHA1SumValue::SHA1SumValue - Constructs the summation from a string /*{{{*/
// ---------------------------------------------------------------------
/* The string form of a SHA1 is a 40 character hex number */
SHA1SumValue::SHA1SumValue(string Str)
{
memset(Sum,0,sizeof(Sum));
Set(Str);
}
/*}}} */
// SHA1SumValue::SHA1SumValue - Default constructor /*{{{*/
// ---------------------------------------------------------------------
/* Sets the value to 0 */
SHA1SumValue::SHA1SumValue()
{
memset(Sum,0,sizeof(Sum));
}
/*}}} */
// SHA1SumValue::Set - Set the sum from a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the hex string into a set of chars */
bool SHA1SumValue::Set(string Str)
{
return Hex2Num(Str,Sum,sizeof(Sum));
}
/*}}} */
// SHA1SumValue::Value - Convert the number into a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the set of chars into a hex string in lower case */
string SHA1SumValue::Value() const
{
char Conv[16] =
{ '0','1','2','3','4','5','6','7','8','9','a','b',
'c','d','e','f'
};
char Result[41];
Result[40] = 0;
// Convert each char into two letters
int J = 0;
int I = 0;
for (; I != 40; J++,I += 2)
{
Result[I] = Conv[Sum[J] >> 4];
Result[I + 1] = Conv[Sum[J] & 0xF];
}
return string(Result);
}
/*}}} */
// SHA1SumValue::operator == - Comparator /*{{{*/
// ---------------------------------------------------------------------
/* Call memcmp on the buffer */
bool SHA1SumValue::operator == (const SHA1SumValue & rhs) const
{
return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
}
/*}}}*/
// SHA1Summation::SHA1Summation - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
@ -290,11 +229,13 @@ SHA1SumValue SHA1Summation::Result()
// Transfer over the result
SHA1SumValue Value;
char res[20];
for (unsigned i = 0; i < 20; i++)
{
Value.Sum[i] = (unsigned char)
res[i] = (unsigned char)
((state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
}
Value.Set(res);
return Value;
}
/*}}}*/

23
apt-pkg/contrib/sha1.h

@ -21,28 +21,11 @@
using std::string;
using std::min;
class SHA1Summation;
#include "hashsum_template.h"
class SHA1SumValue
{
friend class SHA1Summation;
unsigned char Sum[20];
public:
// Accessors
bool operator ==(const SHA1SumValue &rhs) const;
string Value() const;
inline void Value(unsigned char S[20])
{for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
inline operator string() const {return Value();};
bool Set(string Str);
inline void Set(unsigned char S[20])
{for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};
class SHA1Summation;
SHA1SumValue(string Str);
SHA1SumValue();
};
typedef HashSumValue<160> SHA1SumValue;
class SHA1Summation
{

43
apt-pkg/contrib/sha2.cc

@ -0,0 +1,43 @@
/*
* Cryptographic API. {{{
*
* SHA-512, as specified in
* http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
*/ /*}}}*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/sha2.h"
#endif
#include <apt-pkg/sha2.h>
#include <apt-pkg/strutl.h>
// SHA2Summation::AddFD - Add content of file into the checksum /*{{{*/
// ---------------------------------------------------------------------
/* */
bool SHA2SummationBase::AddFD(int Fd,unsigned long Size){
unsigned char Buf[64 * 64];
int Res = 0;
int ToEOF = (Size == 0);
while (Size != 0 || ToEOF)
{
unsigned n = sizeof(Buf);
if (!ToEOF) n = min(Size,(unsigned long)n);
Res = read(Fd,Buf,n);
if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read
return false;
if (ToEOF && Res == 0) // EOF
break;
Size -= Res;
Add(Buf,Res);
}
return true;
}
/*}}}*/

114
apt-pkg/contrib/sha2.h

@ -0,0 +1,114 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: sha512.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
/* ######################################################################
SHA{512,256}SumValue - Storage for a SHA-{512,256} hash.
SHA{512,256}Summation - SHA-{512,256} Secure Hash Algorithm.
This is a C++ interface to a set of SHA{512,256}Sum functions, that mirrors
the equivalent MD5 & SHA1 classes.
##################################################################### */
/*}}}*/
#ifndef APTPKG_SHA2_H
#define APTPKG_SHA2_H
#include <string>
#include <cstring>
#include <algorithm>
#include <stdint.h>
#include "sha2_internal.h"
#include "hashsum_template.h"
using std::string;
using std::min;
class SHA512Summation;
class SHA256Summation;
typedef HashSumValue<512> SHA512SumValue;
typedef HashSumValue<256> SHA256SumValue;
class SHA2SummationBase
{
protected:
bool Done;
public:
virtual bool Add(const unsigned char *inbuf,unsigned long inlen) = 0;
virtual bool AddFD(int Fd,unsigned long Size);
inline bool Add(const char *Data)
{
return Add((unsigned char *)Data,strlen(Data));
};
inline bool Add(const unsigned char *Beg,const unsigned char *End)
{
return Add(Beg,End-Beg);
};
void Result();
};
class SHA256Summation : public SHA2SummationBase
{
SHA256_CTX ctx;
unsigned char Sum[32];
public:
virtual bool Add(const unsigned char *inbuf, unsigned long len)
{
if (Done)
return false;
SHA256_Update(&ctx, inbuf, len);
return true;
};
SHA256SumValue Result()
{
if (!Done) {
SHA256_Final(Sum, &ctx);
Done = true;
}
SHA256SumValue res;
res.Set(Sum);
return res;
};
SHA256Summation()
{
SHA256_Init(&ctx);
Done = false;
};
};
class SHA512Summation : public SHA2SummationBase
{
SHA512_CTX ctx;
unsigned char Sum[64];
public:
virtual bool Add(const unsigned char *inbuf, unsigned long len)
{
if (Done)
return false;
SHA512_Update(&ctx, inbuf, len);
return true;
};
SHA512SumValue Result()
{
if (!Done) {
SHA512_Final(Sum, &ctx);
Done = true;
}
SHA512SumValue res;
res.Set(Sum);
return res;
};
SHA512Summation()
{
SHA512_Init(&ctx);
Done = false;
};
};
#endif

424
apt-pkg/contrib/sha256.cc

@ -1,424 +0,0 @@
/*
* Cryptographic API. {{{
*
* SHA-256, as specified in
* http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf
*
* SHA-256 code by Jean-Luc Cooke <jlcooke@certainkey.com>.
*
* Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com>
* Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
* Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
*
* Ported from the Linux kernel to Apt by Anthony Towns <ajt@debian.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
*/ /*}}}*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/sha256.h"
#endif
#define SHA256_DIGEST_SIZE 32
#define SHA256_HMAC_BLOCK_SIZE 64
#define ror32(value,bits) (((value) >> (bits)) | ((value) << (32 - (bits))))
#include <apt-pkg/sha256.h>
#include <apt-pkg/strutl.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <arpa/inet.h>
typedef uint32_t u32;
typedef uint8_t u8;
static inline u32 Ch(u32 x, u32 y, u32 z)
{
return z ^ (x & (y ^ z));
}
static inline u32 Maj(u32 x, u32 y, u32 z)
{
return (x & y) | (z & (x | y));
}
#define e0(x) (ror32(x, 2) ^ ror32(x,13) ^ ror32(x,22))
#define e1(x) (ror32(x, 6) ^ ror32(x,11) ^ ror32(x,25))
#define s0(x) (ror32(x, 7) ^ ror32(x,18) ^ (x >> 3))
#define s1(x) (ror32(x,17) ^ ror32(x,19) ^ (x >> 10))
#define H0 0x6a09e667
#define H1 0xbb67ae85
#define H2 0x3c6ef372
#define H3 0xa54ff53a
#define H4 0x510e527f
#define H5 0x9b05688c
#define H6 0x1f83d9ab
#define H7 0x5be0cd19
static inline void LOAD_OP(int I, u32 *W, const u8 *input) /*{{{*/
{
W[I] = ( ((u32) input[I * 4 + 0] << 24)
| ((u32) input[I * 4 + 1] << 16)
| ((u32) input[I * 4 + 2] << 8)
| ((u32) input[I * 4 + 3]));
}
/*}}}*/
static inline void BLEND_OP(int I, u32 *W)
{
W[I] = s1(W[I-2]) + W[I-7] + s0(W[I-15]) + W[I-16];
}
static void sha256_transform(u32 *state, const u8 *input) /*{{{*/
{
u32 a, b, c, d, e, f, g, h, t1, t2;
u32 W[64];
int i;
/* load the input */
for (i = 0; i < 16; i++)
LOAD_OP(i, W, input);
/* now blend */
for (i = 16; i < 64; i++)
BLEND_OP(i, W);
/* load the state into our registers */
a=state[0]; b=state[1]; c=state[2]; d=state[3];
e=state[4]; f=state[5]; g=state[6]; h=state[7];
/* now iterate */
t1 = h + e1(e) + Ch(e,f,g) + 0x428a2f98 + W[ 0];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x71374491 + W[ 1];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0xb5c0fbcf + W[ 2];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0xe9b5dba5 + W[ 3];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x3956c25b + W[ 4];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x59f111f1 + W[ 5];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x923f82a4 + W[ 6];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0xab1c5ed5 + W[ 7];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0xd807aa98 + W[ 8];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x12835b01 + W[ 9];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x243185be + W[10];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x550c7dc3 + W[11];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x72be5d74 + W[12];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x80deb1fe + W[13];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x9bdc06a7 + W[14];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0xc19bf174 + W[15];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0xe49b69c1 + W[16];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0xefbe4786 + W[17];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x0fc19dc6 + W[18];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x240ca1cc + W[19];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x2de92c6f + W[20];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x4a7484aa + W[21];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x5cb0a9dc + W[22];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x76f988da + W[23];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0x983e5152 + W[24];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0xa831c66d + W[25];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0xb00327c8 + W[26];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0xbf597fc7 + W[27];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0xc6e00bf3 + W[28];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0xd5a79147 + W[29];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x06ca6351 + W[30];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x14292967 + W[31];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0x27b70a85 + W[32];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x2e1b2138 + W[33];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x4d2c6dfc + W[34];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x53380d13 + W[35];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x650a7354 + W[36];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x766a0abb + W[37];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x81c2c92e + W[38];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x92722c85 + W[39];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0xa2bfe8a1 + W[40];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0xa81a664b + W[41];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0xc24b8b70 + W[42];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0xc76c51a3 + W[43];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0xd192e819 + W[44];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0xd6990624 + W[45];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0xf40e3585 + W[46];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x106aa070 + W[47];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0x19a4c116 + W[48];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x1e376c08 + W[49];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x2748774c + W[50];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x34b0bcb5 + W[51];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x391c0cb3 + W[52];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0x4ed8aa4a + W[53];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0x5b9cca4f + W[54];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0x682e6ff3 + W[55];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
t1 = h + e1(e) + Ch(e,f,g) + 0x748f82ee + W[56];
t2 = e0(a) + Maj(a,b,c); d+=t1; h=t1+t2;
t1 = g + e1(d) + Ch(d,e,f) + 0x78a5636f + W[57];
t2 = e0(h) + Maj(h,a,b); c+=t1; g=t1+t2;
t1 = f + e1(c) + Ch(c,d,e) + 0x84c87814 + W[58];
t2 = e0(g) + Maj(g,h,a); b+=t1; f=t1+t2;
t1 = e + e1(b) + Ch(b,c,d) + 0x8cc70208 + W[59];
t2 = e0(f) + Maj(f,g,h); a+=t1; e=t1+t2;
t1 = d + e1(a) + Ch(a,b,c) + 0x90befffa + W[60];
t2 = e0(e) + Maj(e,f,g); h+=t1; d=t1+t2;
t1 = c + e1(h) + Ch(h,a,b) + 0xa4506ceb + W[61];
t2 = e0(d) + Maj(d,e,f); g+=t1; c=t1+t2;
t1 = b + e1(g) + Ch(g,h,a) + 0xbef9a3f7 + W[62];
t2 = e0(c) + Maj(c,d,e); f+=t1; b=t1+t2;
t1 = a + e1(f) + Ch(f,g,h) + 0xc67178f2 + W[63];
t2 = e0(b) + Maj(b,c,d); e+=t1; a=t1+t2;
state[0] += a; state[1] += b; state[2] += c; state[3] += d;
state[4] += e; state[5] += f; state[6] += g; state[7] += h;
/* clear any sensitive info... */
a = b = c = d = e = f = g = h = t1 = t2 = 0;
memset(W, 0, 64 * sizeof(u32));
}
/*}}}*/
SHA256Summation::SHA256Summation() /*{{{*/
{
Sum.state[0] = H0;
Sum.state[1] = H1;
Sum.state[2] = H2;
Sum.state[3] = H3;
Sum.state[4] = H4;
Sum.state[5] = H5;
Sum.state[6] = H6;
Sum.state[7] = H7;
Sum.count[0] = Sum.count[1] = 0;
memset(Sum.buf, 0, sizeof(Sum.buf));
Done = false;
}
/*}}}*/
bool SHA256Summation::Add(const u8 *data, unsigned long len) /*{{{*/
{
struct sha256_ctx *sctx = &Sum;
unsigned int i, index, part_len;
if (Done) return false;
/* Compute number of bytes mod 128 */
index = (unsigned int)((sctx->count[0] >> 3) & 0x3f);
/* Update number of bits */
if ((sctx->count[0] += (len << 3)) < (len << 3)) {
sctx->count[1]++;
sctx->count[1] += (len >> 29);
}
part_len = 64 - index;
/* Transform as many times as possible. */
if (len >= part_len) {
memcpy(&sctx->buf[index], data, part_len);
sha256_transform(sctx->state, sctx->buf);
for (i = part_len; i + 63 < len; i += 64)
sha256_transform(sctx->state, &data[i]);
index = 0;
} else {
i = 0;
}
/* Buffer remaining input */
memcpy(&sctx->buf[index], &data[i], len-i);
return true;
}
/*}}}*/
SHA256SumValue SHA256Summation::Result() /*{{{*/
{
struct sha256_ctx *sctx = &Sum;
if (!Done) {
u8 bits[8];
unsigned int index, pad_len, t;
static const u8 padding[64] = { 0x80, };
/* Save number of bits */
t = sctx->count[0];
bits[7] = t; t >>= 8;
bits[6] = t; t >>= 8;
bits[5] = t; t >>= 8;
bits[4] = t;
t = sctx->count[1];
bits[3] = t; t >>= 8;
bits[2] = t; t >>= 8;
bits[1] = t; t >>= 8;
bits[0] = t;
/* Pad out to 56 mod 64. */
index = (sctx->count[0] >> 3) & 0x3f;
pad_len = (index < 56) ? (56 - index) : ((64+56) - index);
Add(padding, pad_len);
/* Append length (before padding) */
Add(bits, 8);
}
Done = true;
/* Store state in digest */
SHA256SumValue res;
u8 *out = res.Sum;
int i, j;
unsigned int t;
for (i = j = 0; i < 8; i++, j += 4) {
t = sctx->state[i];
out[j+3] = t; t >>= 8;
out[j+2] = t; t >>= 8;
out[j+1] = t; t >>= 8;
out[j ] = t;
}
return res;
}
/*}}}*/
// SHA256SumValue::SHA256SumValue - Constructs the sum from a string /*{{{*/
// ---------------------------------------------------------------------
/* The string form of a SHA256 is a 64 character hex number */
SHA256SumValue::SHA256SumValue(string Str)
{
memset(Sum,0,sizeof(Sum));
Set(Str);
}
/*}}}*/
// SHA256SumValue::SHA256SumValue - Default constructor /*{{{*/
// ---------------------------------------------------------------------
/* Sets the value to 0 */
SHA256SumValue::SHA256SumValue()
{
memset(Sum,0,sizeof(Sum));
}
/*}}}*/
// SHA256SumValue::Set - Set the sum from a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the hex string into a set of chars */
bool SHA256SumValue::Set(string Str)
{
return Hex2Num(Str,Sum,sizeof(Sum));
}
/*}}}*/
// SHA256SumValue::Value - Convert the number into a string /*{{{*/
// ---------------------------------------------------------------------
/* Converts the set of chars into a hex string in lower case */
string SHA256SumValue::Value() const
{
char Conv[16] =
{ '0','1','2','3','4','5','6','7','8','9','a','b',
'c','d','e','f'
};
char Result[65];
Result[64] = 0;
// Convert each char into two letters
int J = 0;
int I = 0;
for (; I != 64; J++,I += 2)
{
Result[I] = Conv[Sum[J] >> 4];
Result[I + 1] = Conv[Sum[J] & 0xF];
}
return string(Result);
}
/*}}}*/
// SHA256SumValue::operator == - Comparator /*{{{*/
// ---------------------------------------------------------------------
/* Call memcmp on the buffer */
bool SHA256SumValue::operator == (const SHA256SumValue & rhs) const
{
return memcmp(Sum,rhs.Sum,sizeof(Sum)) == 0;
}
/*}}}*/
// SHA256Summation::AddFD - Add content of file into the checksum /*{{{*/
// ---------------------------------------------------------------------
/* */
bool SHA256Summation::AddFD(int Fd,unsigned long Size)
{
unsigned char Buf[64 * 64];
int Res = 0;
int ToEOF = (Size == 0);
while (Size != 0 || ToEOF)
{
unsigned n = sizeof(Buf);
if (!ToEOF) n = min(Size,(unsigned long)n);
Res = read(Fd,Buf,n);
if (Res < 0 || (!ToEOF && (unsigned) Res != n)) // error, or short read
return false;
if (ToEOF && Res == 0) // EOF
break;
Size -= Res;
Add(Buf,Res);
}
return true;
}
/*}}}*/

68
apt-pkg/contrib/sha256.h

@ -1,72 +1,8 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: sha1.h,v 1.3 2001/05/07 05:05:47 jgg Exp $
/* ######################################################################
SHA256SumValue - Storage for a SHA-256 hash.
SHA256Summation - SHA-256 Secure Hash Algorithm.
This is a C++ interface to a set of SHA256Sum functions, that mirrors
the equivalent MD5 & SHA1 classes.
##################################################################### */
/*}}}*/
#ifndef APTPKG_SHA256_H
#define APTPKG_SHA256_H
#include <string>
#include <cstring>
#include <algorithm>
#include <stdint.h>
using std::string;
using std::min;
class SHA256Summation;
class SHA256SumValue
{
friend class SHA256Summation;
unsigned char Sum[32];
public:
// Accessors
bool operator ==(const SHA256SumValue &rhs) const;
string Value() const;
inline void Value(unsigned char S[32])
{for (int I = 0; I != sizeof(Sum); I++) S[I] = Sum[I];};
inline operator string() const {return Value();};
bool Set(string Str);
inline void Set(unsigned char S[32])
{for (int I = 0; I != sizeof(Sum); I++) Sum[I] = S[I];};
SHA256SumValue(string Str);
SHA256SumValue();
};
struct sha256_ctx {
uint32_t count[2];
uint32_t state[8];
uint8_t buf[128];
};
class SHA256Summation
{
struct sha256_ctx Sum;
bool Done;
public:
#include "sha2.h"
bool Add(const unsigned char *inbuf,unsigned long inlen);
inline bool Add(const char *Data) {return Add((unsigned char *)Data,strlen(Data));};
bool AddFD(int Fd,unsigned long Size);
inline bool Add(const unsigned char *Beg,const unsigned char *End)
{return Add(Beg,End-Beg);};
SHA256SumValue Result();
SHA256Summation();
};
#warn "This header is deprecated, please include sha2.h instead"
#endif

1065
apt-pkg/contrib/sha2_internal.cc

File diff suppressed because it is too large

197
apt-pkg/contrib/sha2_internal.h

@ -0,0 +1,197 @@
/*
* FILE: sha2.h
* AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/
*
* Copyright (c) 2000-2001, Aaron D. Gifford
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
*/
#ifndef __SHA2_H__
#define __SHA2_H__
#ifdef __cplusplus
extern "C" {
#endif
/*
* Import u_intXX_t size_t type definitions from system headers. You
* may need to change this, or define these things yourself in this
* file.
*/
#include <sys/types.h>
#ifdef SHA2_USE_INTTYPES_H
#include <inttypes.h>
#endif /* SHA2_USE_INTTYPES_H */
/*** SHA-256/384/512 Various Length Definitions ***********************/
#define SHA256_BLOCK_LENGTH 64
#define SHA256_DIGEST_LENGTH 32
#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
#define SHA384_BLOCK_LENGTH 128
#define SHA384_DIGEST_LENGTH 48
#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1)
#define SHA512_BLOCK_LENGTH 128
#define SHA512_DIGEST_LENGTH 64
#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
/*** SHA-256/384/512 Context Structures *******************************/
/* NOTE: If your architecture does not define either u_intXX_t types or
* uintXX_t (from inttypes.h), you may need to define things by hand
* for your system:
*/
#if 0
typedef unsigned char u_int8_t; /* 1-byte (8-bits) */
typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */
typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */
#endif
/*
* Most BSD systems already define u_intXX_t types, as does Linux.
* Some systems, however, like Compaq's Tru64 Unix instead can use
* uintXX_t types defined by very recent ANSI C standards and included
* in the file:
*
* #include <inttypes.h>
*
* If you choose to use <inttypes.h> then please define:
*
* #define SHA2_USE_INTTYPES_H
*
* Or on the command line during compile:
*
* cc -DSHA2_USE_INTTYPES_H ...
*/
#ifdef SHA2_USE_INTTYPES_H
typedef struct _SHA256_CTX {
uint32_t state[8];
uint64_t bitcount;
uint8_t buffer[SHA256_BLOCK_LENGTH];
} SHA256_CTX;
typedef struct _SHA512_CTX {
uint64_t state[8];
uint64_t bitcount[2];
uint8_t buffer[SHA512_BLOCK_LENGTH];
} SHA512_CTX;
#else /* SHA2_USE_INTTYPES_H */
typedef struct _SHA256_CTX {
u_int32_t state[8];
u_int64_t bitcount;
u_int8_t buffer[SHA256_BLOCK_LENGTH];
} SHA256_CTX;
typedef struct _SHA512_CTX {
u_int64_t state[8];
u_int64_t bitcount[2];
u_int8_t buffer[SHA512_BLOCK_LENGTH];
} SHA512_CTX;
#endif /* SHA2_USE_INTTYPES_H */
typedef SHA512_CTX SHA384_CTX;
/*** SHA-256/384/512 Function Prototypes ******************************/
#ifndef NOPROTO
#ifdef SHA2_USE_INTTYPES_H
void SHA256_Init(SHA256_CTX *);
void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
void SHA384_Init(SHA384_CTX*);
void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
void SHA512_Init(SHA512_CTX*);
void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#else /* SHA2_USE_INTTYPES_H */
void SHA256_Init(SHA256_CTX *);
void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
void SHA384_Init(SHA384_CTX*);
void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
void SHA512_Init(SHA512_CTX*);
void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#endif /* SHA2_USE_INTTYPES_H */
#else /* NOPROTO */
void SHA256_Init();
void SHA256_Update();
void SHA256_Final();
char* SHA256_End();
char* SHA256_Data();
void SHA384_Init();
void SHA384_Update();
void SHA384_Final();
char* SHA384_End();
char* SHA384_Data();
void SHA512_Init();
void SHA512_Update();
void SHA512_Final();
char* SHA512_End();
char* SHA512_Data();
#endif /* NOPROTO */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __SHA2_H__ */

10
apt-pkg/deb/debrecords.cc

@ -77,7 +77,7 @@ string debRecordParser::SHA1Hash()
return Section.FindS("SHA1");
}
/*}}}*/
// RecordParser::SHA1Hash - Return the archive hash /*{{{*/
// RecordParser::SHA256Hash - Return the archive hash /*{{{*/
// ---------------------------------------------------------------------
/* */
string debRecordParser::SHA256Hash()
@ -85,6 +85,14 @@ string debRecordParser::SHA256Hash()
return Section.FindS("SHA256");
}
/*}}}*/
// RecordParser::SHA512Hash - Return the archive hash /*{{{*/
// ---------------------------------------------------------------------
/* */
string debRecordParser::SHA512Hash()
{
return Section.FindS("SHA512");
}
/*}}}*/
// RecordParser::Maintainer - Return the maintainer email /*{{{*/
// ---------------------------------------------------------------------
/* */

1
apt-pkg/deb/debrecords.h

@ -36,6 +36,7 @@ class debRecordParser : public pkgRecords::Parser
virtual string MD5Hash();
virtual string SHA1Hash();
virtual string SHA256Hash();
virtual string SHA512Hash();
virtual string SourcePkg();
virtual string SourceVer();

8
apt-pkg/makefile

@ -20,11 +20,15 @@ APT_DOMAIN:=libapt-pkg$(LIBAPTPKG_MAJOR)
# Source code for the contributed non-core things
SOURCE = contrib/mmap.cc contrib/error.cc contrib/strutl.cc \
contrib/configuration.cc contrib/progress.cc contrib/cmndline.cc \
contrib/md5.cc contrib/sha1.cc contrib/sha256.cc contrib/hashes.cc \
contrib/md5.cc contrib/sha1.cc contrib/sha2.cc \
contrib/sha2_internal.cc\
contrib/hashes.cc \
contrib/cdromutl.cc contrib/crc-16.cc contrib/netrc.cc \
contrib/fileutl.cc
HEADERS = mmap.h error.h configuration.h fileutl.h cmndline.h netrc.h\
md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha256.h hashes.h \
md5.h crc-16.h cdromutl.h strutl.h sptr.h sha1.h sha2.h \
sha2_internal.h \
hashes.h hashsum_template.h\
macros.h weakptr.h
# Source code for the core main library

1
apt-pkg/pkgrecords.h

@ -58,6 +58,7 @@ class pkgRecords::Parser /*{{{*/
virtual string MD5Hash() {return string();};
virtual string SHA1Hash() {return string();};
virtual string SHA256Hash() {return string();};
virtual string SHA512Hash() {return string();};
virtual string SourcePkg() {return string();};
virtual string SourceVer() {return string();};

1
apt-pkg/tagfile.cc

@ -457,6 +457,7 @@ static const char *iTFRewritePackageOrder[] = {
"MD5Sum",
"SHA1",
"SHA256",
"SHA512",
"MSDOS-Filename", // Obsolete
"Description",
0};

2
cmdline/apt-get.cc

@ -2299,6 +2299,8 @@ bool DoDownload(CommandLine &CmdL)
strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.