CryptoPP: Pruned unused files
git-svn-id: http://mc-server.googlecode.com/svn/trunk@1304 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com
parent
2a9fb624ce
commit
561f105394
@ -1,139 +0,0 @@
|
||||
// 3way.cpp - modifed by Wei Dai from Joan Daemen's 3way.c
|
||||
// The original code and all modifications are in the public domain.
|
||||
|
||||
#include "pch.h"
|
||||
#include "3way.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void ThreeWay_TestInstantiations()
|
||||
{
|
||||
ThreeWay::Encryption x1;
|
||||
ThreeWay::Decryption x2;
|
||||
}
|
||||
|
||||
static const word32 START_E = 0x0b0b; // round constant of first encryption round
|
||||
static const word32 START_D = 0xb1b1; // round constant of first decryption round
|
||||
static const word32 RC_MODULUS = 0x11011;
|
||||
|
||||
static inline word32 reverseBits(word32 a)
|
||||
{
|
||||
a = ((a & 0xAAAAAAAA) >> 1) | ((a & 0x55555555) << 1);
|
||||
a = ((a & 0xCCCCCCCC) >> 2) | ((a & 0x33333333) << 2);
|
||||
return ((a & 0xF0F0F0F0) >> 4) | ((a & 0x0F0F0F0F) << 4);
|
||||
}
|
||||
|
||||
#define mu(a0, a1, a2) \
|
||||
{ \
|
||||
a1 = reverseBits(a1); \
|
||||
word32 t = reverseBits(a0); \
|
||||
a0 = reverseBits(a2); \
|
||||
a2 = t; \
|
||||
}
|
||||
|
||||
#define pi_gamma_pi(a0, a1, a2) \
|
||||
{ \
|
||||
word32 b0, b2; \
|
||||
b2 = rotlFixed(a2, 1U); \
|
||||
b0 = rotlFixed(a0, 22U); \
|
||||
a0 = rotlFixed(b0 ^ (a1|(~b2)), 1U); \
|
||||
a2 = rotlFixed(b2 ^ (b0|(~a1)), 22U);\
|
||||
a1 ^= (b2|(~b0)); \
|
||||
}
|
||||
|
||||
// thanks to Paulo Barreto for this optimized theta()
|
||||
#define theta(a0, a1, a2) \
|
||||
{ \
|
||||
word32 b0, b1, c; \
|
||||
c = a0 ^ a1 ^ a2; \
|
||||
c = rotlFixed(c, 16U) ^ rotlFixed(c, 8U); \
|
||||
b0 = (a0 << 24) ^ (a2 >> 8) ^ (a1 << 8) ^ (a0 >> 24); \
|
||||
b1 = (a1 << 24) ^ (a0 >> 8) ^ (a2 << 8) ^ (a1 >> 24); \
|
||||
a0 ^= c ^ b0; \
|
||||
a1 ^= c ^ b1; \
|
||||
a2 ^= c ^ (b0 >> 16) ^ (b1 << 16); \
|
||||
}
|
||||
|
||||
#define rho(a0, a1, a2) \
|
||||
{ \
|
||||
theta(a0, a1, a2); \
|
||||
pi_gamma_pi(a0, a1, a2); \
|
||||
}
|
||||
|
||||
void ThreeWay::Base::UncheckedSetKey(const byte *uk, unsigned int length, const NameValuePairs ¶ms)
|
||||
{
|
||||
AssertValidKeyLength(length);
|
||||
|
||||
m_rounds = GetRoundsAndThrowIfInvalid(params, this);
|
||||
|
||||
for (unsigned int i=0; i<3; i++)
|
||||
m_k[i] = (word32)uk[4*i+3] | ((word32)uk[4*i+2]<<8) | ((word32)uk[4*i+1]<<16) | ((word32)uk[4*i]<<24);
|
||||
|
||||
if (!IsForwardTransformation())
|
||||
{
|
||||
theta(m_k[0], m_k[1], m_k[2]);
|
||||
mu(m_k[0], m_k[1], m_k[2]);
|
||||
m_k[0] = ByteReverse(m_k[0]);
|
||||
m_k[1] = ByteReverse(m_k[1]);
|
||||
m_k[2] = ByteReverse(m_k[2]);
|
||||
}
|
||||
}
|
||||
|
||||
void ThreeWay::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
typedef BlockGetAndPut<word32, BigEndian> Block;
|
||||
|
||||
word32 a0, a1, a2;
|
||||
Block::Get(inBlock)(a0)(a1)(a2);
|
||||
|
||||
word32 rc = START_E;
|
||||
|
||||
for(unsigned i=0; i<m_rounds; i++)
|
||||
{
|
||||
a0 ^= m_k[0] ^ (rc<<16);
|
||||
a1 ^= m_k[1];
|
||||
a2 ^= m_k[2] ^ rc;
|
||||
rho(a0, a1, a2);
|
||||
|
||||
rc <<= 1;
|
||||
if (rc&0x10000) rc ^= 0x11011;
|
||||
}
|
||||
a0 ^= m_k[0] ^ (rc<<16);
|
||||
a1 ^= m_k[1];
|
||||
a2 ^= m_k[2] ^ rc;
|
||||
theta(a0, a1, a2);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a0)(a1)(a2);
|
||||
}
|
||||
|
||||
void ThreeWay::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
typedef BlockGetAndPut<word32, LittleEndian> Block;
|
||||
|
||||
word32 a0, a1, a2;
|
||||
Block::Get(inBlock)(a0)(a1)(a2);
|
||||
|
||||
word32 rc = START_D;
|
||||
|
||||
mu(a0, a1, a2);
|
||||
for(unsigned i=0; i<m_rounds; i++)
|
||||
{
|
||||
a0 ^= m_k[0] ^ (rc<<16);
|
||||
a1 ^= m_k[1];
|
||||
a2 ^= m_k[2] ^ rc;
|
||||
rho(a0, a1, a2);
|
||||
|
||||
rc <<= 1;
|
||||
if (rc&0x10000) rc ^= 0x11011;
|
||||
}
|
||||
a0 ^= m_k[0] ^ (rc<<16);
|
||||
a1 ^= m_k[1];
|
||||
a2 ^= m_k[2] ^ rc;
|
||||
theta(a0, a1, a2);
|
||||
mu(a0, a1, a2);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a0)(a1)(a2);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,53 +0,0 @@
|
||||
#ifndef CRYPTOPP_THREEWAY_H
|
||||
#define CRYPTOPP_THREEWAY_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct ThreeWay_Info : public FixedBlockSize<12>, public FixedKeyLength<12>, public VariableRounds<11>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "3-Way";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#3-Way">3-Way</a>
|
||||
class ThreeWay : public ThreeWay_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<ThreeWay_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
unsigned int m_rounds;
|
||||
FixedSizeSecBlock<word32, 3> m_k;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef ThreeWay::Encryption ThreeWayEncryption;
|
||||
typedef ThreeWay::Decryption ThreeWayDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,120 +0,0 @@
|
||||
// arc4.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
// The ARC4 algorithm was first revealed in an anonymous email to the
|
||||
// cypherpunks mailing list. This file originally contained some
|
||||
// code copied from this email. The code has since been rewritten in order
|
||||
// to clarify the copyright status of this file. It should now be
|
||||
// completely in the public domain.
|
||||
|
||||
#include "pch.h"
|
||||
#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
|
||||
#include "arc4.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
namespace Weak1 {
|
||||
|
||||
void ARC4_TestInstantiations()
|
||||
{
|
||||
ARC4 x;
|
||||
}
|
||||
|
||||
ARC4_Base::~ARC4_Base()
|
||||
{
|
||||
m_x = m_y = 0;
|
||||
}
|
||||
|
||||
void ARC4_Base::UncheckedSetKey(const byte *key, unsigned int keyLen, const NameValuePairs ¶ms)
|
||||
{
|
||||
AssertValidKeyLength(keyLen);
|
||||
|
||||
m_x = 1;
|
||||
m_y = 0;
|
||||
|
||||
unsigned int i;
|
||||
for (i=0; i<256; i++)
|
||||
m_state[i] = i;
|
||||
|
||||
unsigned int keyIndex = 0, stateIndex = 0;
|
||||
for (i=0; i<256; i++)
|
||||
{
|
||||
unsigned int a = m_state[i];
|
||||
stateIndex += key[keyIndex] + a;
|
||||
stateIndex &= 0xff;
|
||||
m_state[i] = m_state[stateIndex];
|
||||
m_state[stateIndex] = a;
|
||||
if (++keyIndex >= keyLen)
|
||||
keyIndex = 0;
|
||||
}
|
||||
|
||||
int discardBytes = params.GetIntValueWithDefault("DiscardBytes", GetDefaultDiscardBytes());
|
||||
DiscardBytes(discardBytes);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static inline unsigned int MakeByte(T &x, T &y, byte *s)
|
||||
{
|
||||
unsigned int a = s[x];
|
||||
y = (y+a) & 0xff;
|
||||
unsigned int b = s[y];
|
||||
s[x] = b;
|
||||
s[y] = a;
|
||||
x = (x+1) & 0xff;
|
||||
return s[(a+b) & 0xff];
|
||||
}
|
||||
|
||||
void ARC4_Base::GenerateBlock(byte *output, size_t size)
|
||||
{
|
||||
while (size--)
|
||||
*output++ = MakeByte(m_x, m_y, m_state);
|
||||
}
|
||||
|
||||
void ARC4_Base::ProcessData(byte *outString, const byte *inString, size_t length)
|
||||
{
|
||||
if (length == 0)
|
||||
return;
|
||||
|
||||
byte *const s = m_state;
|
||||
unsigned int x = m_x;
|
||||
unsigned int y = m_y;
|
||||
|
||||
if (inString == outString)
|
||||
{
|
||||
do
|
||||
{
|
||||
*outString++ ^= MakeByte(x, y, s);
|
||||
} while (--length);
|
||||
}
|
||||
else
|
||||
{
|
||||
do
|
||||
{
|
||||
*outString++ = *inString++ ^ MakeByte(x, y, s);
|
||||
}
|
||||
while(--length);
|
||||
}
|
||||
|
||||
m_x = x;
|
||||
m_y = y;
|
||||
}
|
||||
|
||||
void ARC4_Base::DiscardBytes(size_t length)
|
||||
{
|
||||
if (length == 0)
|
||||
return;
|
||||
|
||||
byte *const s = m_state;
|
||||
unsigned int x = m_x;
|
||||
unsigned int y = m_y;
|
||||
|
||||
do
|
||||
{
|
||||
MakeByte(x, y, s);
|
||||
}
|
||||
while(--length);
|
||||
|
||||
m_x = x;
|
||||
m_y = y;
|
||||
}
|
||||
|
||||
}
|
||||
NAMESPACE_END
|
||||
@ -1,71 +0,0 @@
|
||||
#ifndef CRYPTOPP_ARC4_H
|
||||
#define CRYPTOPP_ARC4_H
|
||||
|
||||
#include "strciphr.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
namespace Weak1 {
|
||||
|
||||
//! _
|
||||
class CRYPTOPP_NO_VTABLE ARC4_Base : public VariableKeyLength<16, 1, 256>, public RandomNumberGenerator, public SymmetricCipher, public SymmetricCipherDocumentation
|
||||
{
|
||||
public:
|
||||
~ARC4_Base();
|
||||
|
||||
static const char *StaticAlgorithmName() {return "ARC4";}
|
||||
|
||||
void GenerateBlock(byte *output, size_t size);
|
||||
void DiscardBytes(size_t n);
|
||||
|
||||
void ProcessData(byte *outString, const byte *inString, size_t length);
|
||||
|
||||
bool IsRandomAccess() const {return false;}
|
||||
bool IsSelfInverting() const {return true;}
|
||||
bool IsForwardTransformation() const {return true;}
|
||||
|
||||
typedef SymmetricCipherFinal<ARC4_Base> Encryption;
|
||||
typedef SymmetricCipherFinal<ARC4_Base> Decryption;
|
||||
|
||||
protected:
|
||||
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms);
|
||||
virtual unsigned int GetDefaultDiscardBytes() const {return 0;}
|
||||
|
||||
FixedSizeSecBlock<byte, 256> m_state;
|
||||
byte m_x, m_y;
|
||||
};
|
||||
|
||||
//! <a href="http://www.weidai.com/scan-mirror/cs.html#RC4">Alleged RC4</a>
|
||||
DOCUMENTED_TYPEDEF(SymmetricCipherFinal<ARC4_Base>, ARC4)
|
||||
|
||||
//! _
|
||||
class CRYPTOPP_NO_VTABLE MARC4_Base : public ARC4_Base
|
||||
{
|
||||
public:
|
||||
static const char *StaticAlgorithmName() {return "MARC4";}
|
||||
|
||||
typedef SymmetricCipherFinal<MARC4_Base> Encryption;
|
||||
typedef SymmetricCipherFinal<MARC4_Base> Decryption;
|
||||
|
||||
protected:
|
||||
unsigned int GetDefaultDiscardBytes() const {return 256;}
|
||||
};
|
||||
|
||||
//! Modified ARC4: it discards the first 256 bytes of keystream which may be weaker than the rest
|
||||
DOCUMENTED_TYPEDEF(SymmetricCipherFinal<MARC4_Base>, MARC4)
|
||||
|
||||
}
|
||||
#if CRYPTOPP_ENABLE_NAMESPACE_WEAK >= 1
|
||||
namespace Weak {using namespace Weak1;} // import Weak1 into CryptoPP::Weak
|
||||
#else
|
||||
using namespace Weak1; // import Weak1 into CryptoPP with warning
|
||||
#ifdef __GNUC__
|
||||
#warning "You may be using a weak algorithm that has been retained for backwards compatibility. Please '#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1' before including this .h file and prepend the class name with 'Weak::' to remove this warning."
|
||||
#else
|
||||
#pragma message("You may be using a weak algorithm that has been retained for backwards compatibility. Please '#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1' before including this .h file and prepend the class name with 'Weak::' to remove this warning.")
|
||||
#endif
|
||||
#endif
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,277 +0,0 @@
|
||||
#include "pch.h"
|
||||
#include "blowfish.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
const word32 Blowfish::Base::p_init[Blowfish::ROUNDS+2] =
|
||||
{
|
||||
608135816U, 2242054355U, 320440878U, 57701188U,
|
||||
2752067618U, 698298832U, 137296536U, 3964562569U,
|
||||
1160258022U, 953160567U, 3193202383U, 887688300U,
|
||||
3232508343U, 3380367581U, 1065670069U, 3041331479U,
|
||||
2450970073U, 2306472731U
|
||||
} ;
|
||||
|
||||
const word32 Blowfish::Base::s_init[4*256] = {
|
||||
3509652390U, 2564797868U, 805139163U, 3491422135U,
|
||||
3101798381U, 1780907670U, 3128725573U, 4046225305U,
|
||||
614570311U, 3012652279U, 134345442U, 2240740374U,
|
||||
1667834072U, 1901547113U, 2757295779U, 4103290238U,
|
||||
227898511U, 1921955416U, 1904987480U, 2182433518U,
|
||||
2069144605U, 3260701109U, 2620446009U, 720527379U,
|
||||
3318853667U, 677414384U, 3393288472U, 3101374703U,
|
||||
2390351024U, 1614419982U, 1822297739U, 2954791486U,
|
||||
3608508353U, 3174124327U, 2024746970U, 1432378464U,
|
||||
3864339955U, 2857741204U, 1464375394U, 1676153920U,
|
||||
1439316330U, 715854006U, 3033291828U, 289532110U,
|
||||
2706671279U, 2087905683U, 3018724369U, 1668267050U,
|
||||
732546397U, 1947742710U, 3462151702U, 2609353502U,
|
||||
2950085171U, 1814351708U, 2050118529U, 680887927U,
|
||||
999245976U, 1800124847U, 3300911131U, 1713906067U,
|
||||
1641548236U, 4213287313U, 1216130144U, 1575780402U,
|
||||
4018429277U, 3917837745U, 3693486850U, 3949271944U,
|
||||
596196993U, 3549867205U, 258830323U, 2213823033U,
|
||||
772490370U, 2760122372U, 1774776394U, 2652871518U,
|
||||
566650946U, 4142492826U, 1728879713U, 2882767088U,
|
||||
1783734482U, 3629395816U, 2517608232U, 2874225571U,
|
||||
1861159788U, 326777828U, 3124490320U, 2130389656U,
|
||||
2716951837U, 967770486U, 1724537150U, 2185432712U,
|
||||
2364442137U, 1164943284U, 2105845187U, 998989502U,
|
||||
3765401048U, 2244026483U, 1075463327U, 1455516326U,
|
||||
1322494562U, 910128902U, 469688178U, 1117454909U,
|
||||
936433444U, 3490320968U, 3675253459U, 1240580251U,
|
||||
122909385U, 2157517691U, 634681816U, 4142456567U,
|
||||
3825094682U, 3061402683U, 2540495037U, 79693498U,
|
||||
3249098678U, 1084186820U, 1583128258U, 426386531U,
|
||||
1761308591U, 1047286709U, 322548459U, 995290223U,
|
||||
1845252383U, 2603652396U, 3431023940U, 2942221577U,
|
||||
3202600964U, 3727903485U, 1712269319U, 422464435U,
|
||||
3234572375U, 1170764815U, 3523960633U, 3117677531U,
|
||||
1434042557U, 442511882U, 3600875718U, 1076654713U,
|
||||
1738483198U, 4213154764U, 2393238008U, 3677496056U,
|
||||
1014306527U, 4251020053U, 793779912U, 2902807211U,
|
||||
842905082U, 4246964064U, 1395751752U, 1040244610U,
|
||||
2656851899U, 3396308128U, 445077038U, 3742853595U,
|
||||
3577915638U, 679411651U, 2892444358U, 2354009459U,
|
||||
1767581616U, 3150600392U, 3791627101U, 3102740896U,
|
||||
284835224U, 4246832056U, 1258075500U, 768725851U,
|
||||
2589189241U, 3069724005U, 3532540348U, 1274779536U,
|
||||
3789419226U, 2764799539U, 1660621633U, 3471099624U,
|
||||
4011903706U, 913787905U, 3497959166U, 737222580U,
|
||||
2514213453U, 2928710040U, 3937242737U, 1804850592U,
|
||||
3499020752U, 2949064160U, 2386320175U, 2390070455U,
|
||||
2415321851U, 4061277028U, 2290661394U, 2416832540U,
|
||||
1336762016U, 1754252060U, 3520065937U, 3014181293U,
|
||||
791618072U, 3188594551U, 3933548030U, 2332172193U,
|
||||
3852520463U, 3043980520U, 413987798U, 3465142937U,
|
||||
3030929376U, 4245938359U, 2093235073U, 3534596313U,
|
||||
375366246U, 2157278981U, 2479649556U, 555357303U,
|
||||
3870105701U, 2008414854U, 3344188149U, 4221384143U,
|
||||
3956125452U, 2067696032U, 3594591187U, 2921233993U,
|
||||
2428461U, 544322398U, 577241275U, 1471733935U,
|
||||
610547355U, 4027169054U, 1432588573U, 1507829418U,
|
||||
2025931657U, 3646575487U, 545086370U, 48609733U,
|
||||
2200306550U, 1653985193U, 298326376U, 1316178497U,
|
||||
3007786442U, 2064951626U, 458293330U, 2589141269U,
|
||||
3591329599U, 3164325604U, 727753846U, 2179363840U,
|
||||
146436021U, 1461446943U, 4069977195U, 705550613U,
|
||||
3059967265U, 3887724982U, 4281599278U, 3313849956U,
|
||||
1404054877U, 2845806497U, 146425753U, 1854211946U,
|
||||
|
||||
1266315497U, 3048417604U, 3681880366U, 3289982499U,
|
||||
2909710000U, 1235738493U, 2632868024U, 2414719590U,
|
||||
3970600049U, 1771706367U, 1449415276U, 3266420449U,
|
||||
422970021U, 1963543593U, 2690192192U, 3826793022U,
|
||||
1062508698U, 1531092325U, 1804592342U, 2583117782U,
|
||||
2714934279U, 4024971509U, 1294809318U, 4028980673U,
|
||||
1289560198U, 2221992742U, 1669523910U, 35572830U,
|
||||
157838143U, 1052438473U, 1016535060U, 1802137761U,
|
||||
1753167236U, 1386275462U, 3080475397U, 2857371447U,
|
||||
1040679964U, 2145300060U, 2390574316U, 1461121720U,
|
||||
2956646967U, 4031777805U, 4028374788U, 33600511U,
|
||||
2920084762U, 1018524850U, 629373528U, 3691585981U,
|
||||
3515945977U, 2091462646U, 2486323059U, 586499841U,
|
||||
988145025U, 935516892U, 3367335476U, 2599673255U,
|
||||
2839830854U, 265290510U, 3972581182U, 2759138881U,
|
||||
3795373465U, 1005194799U, 847297441U, 406762289U,
|
||||
1314163512U, 1332590856U, 1866599683U, 4127851711U,
|
||||
750260880U, 613907577U, 1450815602U, 3165620655U,
|
||||
3734664991U, 3650291728U, 3012275730U, 3704569646U,
|
||||
1427272223U, 778793252U, 1343938022U, 2676280711U,
|
||||
2052605720U, 1946737175U, 3164576444U, 3914038668U,
|
||||
3967478842U, 3682934266U, 1661551462U, 3294938066U,
|
||||
4011595847U, 840292616U, 3712170807U, 616741398U,
|
||||
312560963U, 711312465U, 1351876610U, 322626781U,
|
||||
1910503582U, 271666773U, 2175563734U, 1594956187U,
|
||||
70604529U, 3617834859U, 1007753275U, 1495573769U,
|
||||
4069517037U, 2549218298U, 2663038764U, 504708206U,
|
||||
2263041392U, 3941167025U, 2249088522U, 1514023603U,
|
||||
1998579484U, 1312622330U, 694541497U, 2582060303U,
|
||||
2151582166U, 1382467621U, 776784248U, 2618340202U,
|
||||
3323268794U, 2497899128U, 2784771155U, 503983604U,
|
||||
4076293799U, 907881277U, 423175695U, 432175456U,
|
||||
1378068232U, 4145222326U, 3954048622U, 3938656102U,
|
||||
3820766613U, 2793130115U, 2977904593U, 26017576U,
|
||||
3274890735U, 3194772133U, 1700274565U, 1756076034U,
|
||||
4006520079U, 3677328699U, 720338349U, 1533947780U,
|
||||
354530856U, 688349552U, 3973924725U, 1637815568U,
|
||||
332179504U, 3949051286U, 53804574U, 2852348879U,
|
||||
3044236432U, 1282449977U, 3583942155U, 3416972820U,
|
||||
4006381244U, 1617046695U, 2628476075U, 3002303598U,
|
||||
1686838959U, 431878346U, 2686675385U, 1700445008U,
|
||||
1080580658U, 1009431731U, 832498133U, 3223435511U,
|
||||
2605976345U, 2271191193U, 2516031870U, 1648197032U,
|
||||
4164389018U, 2548247927U, 300782431U, 375919233U,
|
||||
238389289U, 3353747414U, 2531188641U, 2019080857U,
|
||||
1475708069U, 455242339U, 2609103871U, 448939670U,
|
||||
3451063019U, 1395535956U, 2413381860U, 1841049896U,
|
||||
1491858159U, 885456874U, 4264095073U, 4001119347U,
|
||||
1565136089U, 3898914787U, 1108368660U, 540939232U,
|
||||
1173283510U, 2745871338U, 3681308437U, 4207628240U,
|
||||
3343053890U, 4016749493U, 1699691293U, 1103962373U,
|
||||
3625875870U, 2256883143U, 3830138730U, 1031889488U,
|
||||
3479347698U, 1535977030U, 4236805024U, 3251091107U,
|
||||
2132092099U, 1774941330U, 1199868427U, 1452454533U,
|
||||
157007616U, 2904115357U, 342012276U, 595725824U,
|
||||
1480756522U, 206960106U, 497939518U, 591360097U,
|
||||
863170706U, 2375253569U, 3596610801U, 1814182875U,
|
||||
2094937945U, 3421402208U, 1082520231U, 3463918190U,
|
||||
2785509508U, 435703966U, 3908032597U, 1641649973U,
|
||||
2842273706U, 3305899714U, 1510255612U, 2148256476U,
|
||||
2655287854U, 3276092548U, 4258621189U, 236887753U,
|
||||
3681803219U, 274041037U, 1734335097U, 3815195456U,
|
||||
3317970021U, 1899903192U, 1026095262U, 4050517792U,
|
||||
356393447U, 2410691914U, 3873677099U, 3682840055U,
|
||||
|
||||
3913112168U, 2491498743U, 4132185628U, 2489919796U,
|
||||
1091903735U, 1979897079U, 3170134830U, 3567386728U,
|
||||
3557303409U, 857797738U, 1136121015U, 1342202287U,
|
||||
507115054U, 2535736646U, 337727348U, 3213592640U,
|
||||
1301675037U, 2528481711U, 1895095763U, 1721773893U,
|
||||
3216771564U, 62756741U, 2142006736U, 835421444U,
|
||||
2531993523U, 1442658625U, 3659876326U, 2882144922U,
|
||||
676362277U, 1392781812U, 170690266U, 3921047035U,
|
||||
1759253602U, 3611846912U, 1745797284U, 664899054U,
|
||||
1329594018U, 3901205900U, 3045908486U, 2062866102U,
|
||||
2865634940U, 3543621612U, 3464012697U, 1080764994U,
|
||||
553557557U, 3656615353U, 3996768171U, 991055499U,
|
||||
499776247U, 1265440854U, 648242737U, 3940784050U,
|
||||
980351604U, 3713745714U, 1749149687U, 3396870395U,
|
||||
4211799374U, 3640570775U, 1161844396U, 3125318951U,
|
||||
1431517754U, 545492359U, 4268468663U, 3499529547U,
|
||||
1437099964U, 2702547544U, 3433638243U, 2581715763U,
|
||||
2787789398U, 1060185593U, 1593081372U, 2418618748U,
|
||||
4260947970U, 69676912U, 2159744348U, 86519011U,
|
||||
2512459080U, 3838209314U, 1220612927U, 3339683548U,
|
||||
133810670U, 1090789135U, 1078426020U, 1569222167U,
|
||||
845107691U, 3583754449U, 4072456591U, 1091646820U,
|
||||
628848692U, 1613405280U, 3757631651U, 526609435U,
|
||||
236106946U, 48312990U, 2942717905U, 3402727701U,
|
||||
1797494240U, 859738849U, 992217954U, 4005476642U,
|
||||
2243076622U, 3870952857U, 3732016268U, 765654824U,
|
||||
3490871365U, 2511836413U, 1685915746U, 3888969200U,
|
||||
1414112111U, 2273134842U, 3281911079U, 4080962846U,
|
||||
172450625U, 2569994100U, 980381355U, 4109958455U,
|
||||
2819808352U, 2716589560U, 2568741196U, 3681446669U,
|
||||
3329971472U, 1835478071U, 660984891U, 3704678404U,
|
||||
4045999559U, 3422617507U, 3040415634U, 1762651403U,
|
||||
1719377915U, 3470491036U, 2693910283U, 3642056355U,
|
||||
3138596744U, 1364962596U, 2073328063U, 1983633131U,
|
||||
926494387U, 3423689081U, 2150032023U, 4096667949U,
|
||||
1749200295U, 3328846651U, 309677260U, 2016342300U,
|
||||
1779581495U, 3079819751U, 111262694U, 1274766160U,
|
||||
443224088U, 298511866U, 1025883608U, 3806446537U,
|
||||
1145181785U, 168956806U, 3641502830U, 3584813610U,
|
||||
1689216846U, 3666258015U, 3200248200U, 1692713982U,
|
||||
2646376535U, 4042768518U, 1618508792U, 1610833997U,
|
||||
3523052358U, 4130873264U, 2001055236U, 3610705100U,
|
||||
2202168115U, 4028541809U, 2961195399U, 1006657119U,
|
||||
2006996926U, 3186142756U, 1430667929U, 3210227297U,
|
||||
1314452623U, 4074634658U, 4101304120U, 2273951170U,
|
||||
1399257539U, 3367210612U, 3027628629U, 1190975929U,
|
||||
2062231137U, 2333990788U, 2221543033U, 2438960610U,
|
||||
1181637006U, 548689776U, 2362791313U, 3372408396U,
|
||||
3104550113U, 3145860560U, 296247880U, 1970579870U,
|
||||
3078560182U, 3769228297U, 1714227617U, 3291629107U,
|
||||
3898220290U, 166772364U, 1251581989U, 493813264U,
|
||||
448347421U, 195405023U, 2709975567U, 677966185U,
|
||||
3703036547U, 1463355134U, 2715995803U, 1338867538U,
|
||||
1343315457U, 2802222074U, 2684532164U, 233230375U,
|
||||
2599980071U, 2000651841U, 3277868038U, 1638401717U,
|
||||
4028070440U, 3237316320U, 6314154U, 819756386U,
|
||||
300326615U, 590932579U, 1405279636U, 3267499572U,
|
||||
3150704214U, 2428286686U, 3959192993U, 3461946742U,
|
||||
1862657033U, 1266418056U, 963775037U, 2089974820U,
|
||||
2263052895U, 1917689273U, 448879540U, 3550394620U,
|
||||
3981727096U, 150775221U, 3627908307U, 1303187396U,
|
||||
508620638U, 2975983352U, 2726630617U, 1817252668U,
|
||||
1876281319U, 1457606340U, 908771278U, 3720792119U,
|
||||
3617206836U, 2455994898U, 1729034894U, 1080033504U,
|
||||
|
||||
976866871U, 3556439503U, 2881648439U, 1522871579U,
|
||||
1555064734U, 1336096578U, 3548522304U, 2579274686U,
|
||||
3574697629U, 3205460757U, 3593280638U, 3338716283U,
|
||||
3079412587U, 564236357U, 2993598910U, 1781952180U,
|
||||
1464380207U, 3163844217U, 3332601554U, 1699332808U,
|
||||
1393555694U, 1183702653U, 3581086237U, 1288719814U,
|
||||
691649499U, 2847557200U, 2895455976U, 3193889540U,
|
||||
2717570544U, 1781354906U, 1676643554U, 2592534050U,
|
||||
3230253752U, 1126444790U, 2770207658U, 2633158820U,
|
||||
2210423226U, 2615765581U, 2414155088U, 3127139286U,
|
||||
673620729U, 2805611233U, 1269405062U, 4015350505U,
|
||||
3341807571U, 4149409754U, 1057255273U, 2012875353U,
|
||||
2162469141U, 2276492801U, 2601117357U, 993977747U,
|
||||
3918593370U, 2654263191U, 753973209U, 36408145U,
|
||||
2530585658U, 25011837U, 3520020182U, 2088578344U,
|
||||
530523599U, 2918365339U, 1524020338U, 1518925132U,
|
||||
3760827505U, 3759777254U, 1202760957U, 3985898139U,
|
||||
3906192525U, 674977740U, 4174734889U, 2031300136U,
|
||||
2019492241U, 3983892565U, 4153806404U, 3822280332U,
|
||||
352677332U, 2297720250U, 60907813U, 90501309U,
|
||||
3286998549U, 1016092578U, 2535922412U, 2839152426U,
|
||||
457141659U, 509813237U, 4120667899U, 652014361U,
|
||||
1966332200U, 2975202805U, 55981186U, 2327461051U,
|
||||
676427537U, 3255491064U, 2882294119U, 3433927263U,
|
||||
1307055953U, 942726286U, 933058658U, 2468411793U,
|
||||
3933900994U, 4215176142U, 1361170020U, 2001714738U,
|
||||
2830558078U, 3274259782U, 1222529897U, 1679025792U,
|
||||
2729314320U, 3714953764U, 1770335741U, 151462246U,
|
||||
3013232138U, 1682292957U, 1483529935U, 471910574U,
|
||||
1539241949U, 458788160U, 3436315007U, 1807016891U,
|
||||
3718408830U, 978976581U, 1043663428U, 3165965781U,
|
||||
1927990952U, 4200891579U, 2372276910U, 3208408903U,
|
||||
3533431907U, 1412390302U, 2931980059U, 4132332400U,
|
||||
1947078029U, 3881505623U, 4168226417U, 2941484381U,
|
||||
1077988104U, 1320477388U, 886195818U, 18198404U,
|
||||
3786409000U, 2509781533U, 112762804U, 3463356488U,
|
||||
1866414978U, 891333506U, 18488651U, 661792760U,
|
||||
1628790961U, 3885187036U, 3141171499U, 876946877U,
|
||||
2693282273U, 1372485963U, 791857591U, 2686433993U,
|
||||
3759982718U, 3167212022U, 3472953795U, 2716379847U,
|
||||
445679433U, 3561995674U, 3504004811U, 3574258232U,
|
||||
54117162U, 3331405415U, 2381918588U, 3769707343U,
|
||||
4154350007U, 1140177722U, 4074052095U, 668550556U,
|
||||
3214352940U, 367459370U, 261225585U, 2610173221U,
|
||||
4209349473U, 3468074219U, 3265815641U, 314222801U,
|
||||
3066103646U, 3808782860U, 282218597U, 3406013506U,
|
||||
3773591054U, 379116347U, 1285071038U, 846784868U,
|
||||
2669647154U, 3771962079U, 3550491691U, 2305946142U,
|
||||
453669953U, 1268987020U, 3317592352U, 3279303384U,
|
||||
3744833421U, 2610507566U, 3859509063U, 266596637U,
|
||||
3847019092U, 517658769U, 3462560207U, 3443424879U,
|
||||
370717030U, 4247526661U, 2224018117U, 4143653529U,
|
||||
4112773975U, 2788324899U, 2477274417U, 1456262402U,
|
||||
2901442914U, 1517677493U, 1846949527U, 2295493580U,
|
||||
3734397586U, 2176403920U, 1280348187U, 1908823572U,
|
||||
3871786941U, 846861322U, 1172426758U, 3287448474U,
|
||||
3383383037U, 1655181056U, 3139813346U, 901632758U,
|
||||
1897031941U, 2986607138U, 3066810236U, 3447102507U,
|
||||
1393639104U, 373351379U, 950779232U, 625454576U,
|
||||
3124240540U, 4148612726U, 2007998917U, 544563296U,
|
||||
2244738638U, 2330496472U, 2058025392U, 1291430526U,
|
||||
424198748U, 50039436U, 29584100U, 3605783033U,
|
||||
2429876329U, 2791104160U, 1057563949U, 3255363231U,
|
||||
3075367218U, 3463963227U, 1469046755U, 985887462U
|
||||
};
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,99 +0,0 @@
|
||||
// blowfish.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "blowfish.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void Blowfish::Base::UncheckedSetKey(const byte *key_string, unsigned int keylength, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(keylength);
|
||||
|
||||
unsigned i, j=0, k;
|
||||
word32 data, dspace[2] = {0, 0};
|
||||
|
||||
memcpy(pbox, p_init, sizeof(p_init));
|
||||
memcpy(sbox, s_init, sizeof(s_init));
|
||||
|
||||
// Xor key string into encryption key vector
|
||||
for (i=0 ; i<ROUNDS+2 ; ++i)
|
||||
{
|
||||
data = 0 ;
|
||||
for (k=0 ; k<4 ; ++k )
|
||||
data = (data << 8) | key_string[j++ % keylength];
|
||||
pbox[i] ^= data;
|
||||
}
|
||||
|
||||
crypt_block(dspace, pbox);
|
||||
|
||||
for (i=0; i<ROUNDS; i+=2)
|
||||
crypt_block(pbox+i, pbox+i+2);
|
||||
|
||||
crypt_block(pbox+ROUNDS, sbox);
|
||||
|
||||
for (i=0; i<4*256-2; i+=2)
|
||||
crypt_block(sbox+i, sbox+i+2);
|
||||
|
||||
if (!IsForwardTransformation())
|
||||
for (i=0; i<(ROUNDS+2)/2; i++)
|
||||
std::swap(pbox[i], pbox[ROUNDS+1-i]);
|
||||
}
|
||||
|
||||
// this version is only used to make pbox and sbox
|
||||
void Blowfish::Base::crypt_block(const word32 in[2], word32 out[2]) const
|
||||
{
|
||||
word32 left = in[0];
|
||||
word32 right = in[1];
|
||||
|
||||
const word32 *const s=sbox;
|
||||
const word32 *p=pbox;
|
||||
|
||||
left ^= p[0];
|
||||
|
||||
for (unsigned i=0; i<ROUNDS/2; i++)
|
||||
{
|
||||
right ^= (((s[GETBYTE(left,3)] + s[256+GETBYTE(left,2)])
|
||||
^ s[2*256+GETBYTE(left,1)]) + s[3*256+GETBYTE(left,0)])
|
||||
^ p[2*i+1];
|
||||
|
||||
left ^= (((s[GETBYTE(right,3)] + s[256+GETBYTE(right,2)])
|
||||
^ s[2*256+GETBYTE(right,1)]) + s[3*256+GETBYTE(right,0)])
|
||||
^ p[2*i+2];
|
||||
}
|
||||
|
||||
right ^= p[ROUNDS+1];
|
||||
|
||||
out[0] = right;
|
||||
out[1] = left;
|
||||
}
|
||||
|
||||
void Blowfish::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
typedef BlockGetAndPut<word32, BigEndian> Block;
|
||||
|
||||
word32 left, right;
|
||||
Block::Get(inBlock)(left)(right);
|
||||
|
||||
const word32 *const s=sbox;
|
||||
const word32 *p=pbox;
|
||||
|
||||
left ^= p[0];
|
||||
|
||||
for (unsigned i=0; i<ROUNDS/2; i++)
|
||||
{
|
||||
right ^= (((s[GETBYTE(left,3)] + s[256+GETBYTE(left,2)])
|
||||
^ s[2*256+GETBYTE(left,1)]) + s[3*256+GETBYTE(left,0)])
|
||||
^ p[2*i+1];
|
||||
|
||||
left ^= (((s[GETBYTE(right,3)] + s[256+GETBYTE(right,2)])
|
||||
^ s[2*256+GETBYTE(right,1)]) + s[3*256+GETBYTE(right,0)])
|
||||
^ p[2*i+2];
|
||||
}
|
||||
|
||||
right ^= p[ROUNDS+1];
|
||||
|
||||
Block::Put(xorBlock, outBlock)(right)(left);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,46 +0,0 @@
|
||||
#ifndef CRYPTOPP_BLOWFISH_H
|
||||
#define CRYPTOPP_BLOWFISH_H
|
||||
|
||||
/** \file */
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct Blowfish_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 4, 56>, public FixedRounds<16>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "Blowfish";}
|
||||
};
|
||||
|
||||
//! <a href="http://www.weidai.com/scan-mirror/cs.html#Blowfish">Blowfish</a>
|
||||
class Blowfish : public Blowfish_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<Blowfish_Info>
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
void UncheckedSetKey(const byte *key_string, unsigned int keylength, const NameValuePairs ¶ms);
|
||||
|
||||
private:
|
||||
void crypt_block(const word32 in[2], word32 out[2]) const;
|
||||
|
||||
static const word32 p_init[ROUNDS+2];
|
||||
static const word32 s_init[4*256];
|
||||
|
||||
FixedSizeSecBlock<word32, ROUNDS+2> pbox;
|
||||
FixedSizeSecBlock<word32, 4*256> sbox;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
|
||||
};
|
||||
|
||||
typedef Blowfish::Encryption BlowfishEncryption;
|
||||
typedef Blowfish::Decryption BlowfishDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,63 +0,0 @@
|
||||
// blumshub.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "blumshub.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
PublicBlumBlumShub::PublicBlumBlumShub(const Integer &n, const Integer &seed)
|
||||
: modn(n),
|
||||
maxBits(BitPrecision(n.BitCount())-1)
|
||||
{
|
||||
current = modn.Square(modn.Square(seed));
|
||||
bitsLeft = maxBits;
|
||||
}
|
||||
|
||||
unsigned int PublicBlumBlumShub::GenerateBit()
|
||||
{
|
||||
if (bitsLeft==0)
|
||||
{
|
||||
current = modn.Square(current);
|
||||
bitsLeft = maxBits;
|
||||
}
|
||||
|
||||
return current.GetBit(--bitsLeft);
|
||||
}
|
||||
|
||||
byte PublicBlumBlumShub::GenerateByte()
|
||||
{
|
||||
byte b=0;
|
||||
for (int i=0; i<8; i++)
|
||||
b = (b << 1) | PublicBlumBlumShub::GenerateBit();
|
||||
return b;
|
||||
}
|
||||
|
||||
void PublicBlumBlumShub::GenerateBlock(byte *output, size_t size)
|
||||
{
|
||||
while (size--)
|
||||
*output++ = PublicBlumBlumShub::GenerateByte();
|
||||
}
|
||||
|
||||
void PublicBlumBlumShub::ProcessData(byte *outString, const byte *inString, size_t length)
|
||||
{
|
||||
while (length--)
|
||||
*outString++ = *inString++ ^ PublicBlumBlumShub::GenerateByte();
|
||||
}
|
||||
|
||||
BlumBlumShub::BlumBlumShub(const Integer &p, const Integer &q, const Integer &seed)
|
||||
: PublicBlumBlumShub(p*q, seed),
|
||||
p(p), q(q),
|
||||
x0(modn.Square(seed))
|
||||
{
|
||||
}
|
||||
|
||||
void BlumBlumShub::Seek(lword index)
|
||||
{
|
||||
Integer i(Integer::POSITIVE, index);
|
||||
i *= 8;
|
||||
Integer e = a_exp_b_mod_c (2, i / maxBits + 1, (p-1)*(q-1));
|
||||
current = modn.Exponentiate(x0, e);
|
||||
bitsLeft = maxBits - i % maxBits;
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,53 +0,0 @@
|
||||
#ifndef CRYPTOPP_BLUMSHUB_H
|
||||
#define CRYPTOPP_BLUMSHUB_H
|
||||
|
||||
#include "modarith.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
class BlumGoldwasserPublicKey;
|
||||
class BlumGoldwasserPrivateKey;
|
||||
|
||||
//! BlumBlumShub without factorization of the modulus
|
||||
class PublicBlumBlumShub : public RandomNumberGenerator,
|
||||
public StreamTransformation
|
||||
{
|
||||
public:
|
||||
PublicBlumBlumShub(const Integer &n, const Integer &seed);
|
||||
|
||||
unsigned int GenerateBit();
|
||||
byte GenerateByte();
|
||||
void GenerateBlock(byte *output, size_t size);
|
||||
void ProcessData(byte *outString, const byte *inString, size_t length);
|
||||
|
||||
bool IsSelfInverting() const {return true;}
|
||||
bool IsForwardTransformation() const {return true;}
|
||||
|
||||
protected:
|
||||
ModularArithmetic modn;
|
||||
word maxBits, bitsLeft;
|
||||
Integer current;
|
||||
|
||||
friend class BlumGoldwasserPublicKey;
|
||||
friend class BlumGoldwasserPrivateKey;
|
||||
};
|
||||
|
||||
//! BlumBlumShub with factorization of the modulus
|
||||
class BlumBlumShub : public PublicBlumBlumShub
|
||||
{
|
||||
public:
|
||||
// Make sure p and q are both primes congruent to 3 mod 4 and at least 512 bits long,
|
||||
// seed is the secret key and should be about as big as p*q
|
||||
BlumBlumShub(const Integer &p, const Integer &q, const Integer &seed);
|
||||
|
||||
bool IsRandomAccess() const {return true;}
|
||||
void Seek(lword index);
|
||||
|
||||
protected:
|
||||
const Integer p, q;
|
||||
const Integer x0;
|
||||
};
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,524 +0,0 @@
|
||||
// camellia.cpp - by Kevin Springle, 2003
|
||||
// This code is hereby placed in the public domain.
|
||||
|
||||
/*
|
||||
Optimisations and defense against timing attacks added in Jan 2007 by Wei Dai.
|
||||
|
||||
The first 2 rounds and the last round seem especially vulnerable to timing
|
||||
attacks. The protection is similar to what was implemented for Rijndael.
|
||||
See comments at top of rijndael.cpp for more details.
|
||||
*/
|
||||
|
||||
#include "pch.h"
|
||||
|
||||
#include "camellia.h"
|
||||
#include "misc.h"
|
||||
#include "cpu.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
// round implementation that uses a small table for protection against timing attacks
|
||||
#define SLOW_ROUND(lh, ll, rh, rl, kh, kl) { \
|
||||
word32 zr = ll ^ kl; \
|
||||
word32 zl = lh ^ kh; \
|
||||
zr= rotlFixed(s1[GETBYTE(zr, 3)], 1) | \
|
||||
(rotrFixed(s1[GETBYTE(zr, 2)], 1) << 24) | \
|
||||
(s1[rotlFixed(CRYPTOPP_GET_BYTE_AS_BYTE(zr, 1),1)] << 16) | \
|
||||
(s1[GETBYTE(zr, 0)] << 8); \
|
||||
zl= (s1[GETBYTE(zl, 3)] << 24) | \
|
||||
(rotlFixed(s1[GETBYTE(zl, 2)], 1) << 16) | \
|
||||
(rotrFixed(s1[GETBYTE(zl, 1)], 1) << 8) | \
|
||||
s1[rotlFixed(CRYPTOPP_GET_BYTE_AS_BYTE(zl, 0), 1)]; \
|
||||
zl ^= zr; \
|
||||
zr = zl ^ rotlFixed(zr, 8); \
|
||||
zl = zr ^ rotrFixed(zl, 8); \
|
||||
rh ^= rotlFixed(zr, 16); \
|
||||
rh ^= zl; \
|
||||
rl ^= rotlFixed(zl, 8); \
|
||||
}
|
||||
|
||||
// normal round - same output as above but using larger tables for faster speed
|
||||
#define ROUND(lh, ll, rh, rl, kh, kl) { \
|
||||
word32 th = lh ^ kh; \
|
||||
word32 tl = ll ^ kl; \
|
||||
word32 d = SP[0][GETBYTE(tl,0)] ^ SP[1][GETBYTE(tl,3)] ^ SP[2][GETBYTE(tl,2)] ^ SP[3][GETBYTE(tl,1)]; \
|
||||
word32 u = SP[0][GETBYTE(th,3)] ^ SP[1][GETBYTE(th,2)] ^ SP[2][GETBYTE(th,1)] ^ SP[3][GETBYTE(th,0)]; \
|
||||
d ^= u; \
|
||||
rh ^= d; \
|
||||
rl ^= d; \
|
||||
rl ^= rotrFixed(u, 8);}
|
||||
|
||||
#define DOUBLE_ROUND(lh, ll, rh, rl, k0, k1, k2, k3) \
|
||||
ROUND(lh, ll, rh, rl, k0, k1) \
|
||||
ROUND(rh, rl, lh, ll, k2, k3)
|
||||
|
||||
#ifdef IS_LITTLE_ENDIAN
|
||||
#define EFI(i) (1-(i))
|
||||
#else
|
||||
#define EFI(i) (i)
|
||||
#endif
|
||||
|
||||
void Camellia::Base::UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs &)
|
||||
{
|
||||
m_rounds = (keylen >= 24) ? 4 : 3;
|
||||
unsigned int kslen = (8 * m_rounds + 2);
|
||||
m_key.New(kslen*2);
|
||||
word32 *ks32 = m_key.data();
|
||||
int m=0, a=0;
|
||||
if (!IsForwardTransformation())
|
||||
m = -1, a = kslen-1;
|
||||
|
||||
word32 kl0, kl1, kl2, kl3;
|
||||
GetBlock<word32, BigEndian> getBlock(key);
|
||||
getBlock(kl0)(kl1)(kl2)(kl3);
|
||||
word32 k0=kl0, k1=kl1, k2=kl2, k3=kl3;
|
||||
|
||||
#define CALC_ADDR2(base, i, j) ((byte *)(base)+8*(i)+4*(j)+((-16*(i))&m))
|
||||
#define CALC_ADDR(base, i) CALC_ADDR2(base, i, 0)
|
||||
|
||||
#if 1
|
||||
word64 kwl, kwr;
|
||||
ks32 += 2*a;
|
||||
#define PREPARE_KS_ROUNDS \
|
||||
kwl = (word64(k0) << 32) | k1; \
|
||||
kwr = (word64(k2) << 32) | k3
|
||||
#define KS_ROUND_0(i) \
|
||||
*(word64*)CALC_ADDR(ks32, i+EFI(0)) = kwl; \
|
||||
*(word64*)CALC_ADDR(ks32, i+EFI(1)) = kwr
|
||||
#define KS_ROUND(i, r, which) \
|
||||
if (which & (1<<int(r<64))) *(word64*)CALC_ADDR(ks32, i+EFI(r<64)) = (kwr << (r%64)) | (kwl >> (64 - (r%64))); \
|
||||
if (which & (1<<int(r>64))) *(word64*)CALC_ADDR(ks32, i+EFI(r>64)) = (kwl << (r%64)) | (kwr >> (64 - (r%64)))
|
||||
#else
|
||||
// SSE2 version is 30% faster on Intel Core 2. Doesn't seem worth the hassle of maintenance, but left here
|
||||
// #if'd out in case someone needs it.
|
||||
__m128i kw, kw2;
|
||||
__m128i *ks128 = (__m128i *)ks32+a/2;
|
||||
ks32 += 2*a;
|
||||
#define PREPARE_KS_ROUNDS \
|
||||
kw = _mm_set_epi32(k0, k1, k2, k3); \
|
||||
if (m) kw2 = kw, kw = _mm_shuffle_epi32(kw, _MM_SHUFFLE(1, 0, 3, 2)); \
|
||||
else kw2 = _mm_shuffle_epi32(kw, _MM_SHUFFLE(1, 0, 3, 2))
|
||||
#define KS_ROUND_0(i) \
|
||||
_mm_store_si128((__m128i *)CALC_ADDR(ks128, i), kw)
|
||||
#define KS_ROUND(i, r, which) { \
|
||||
__m128i temp; \
|
||||
if (r<64 && (which!=1 || m)) temp = _mm_or_si128(_mm_slli_epi64(kw, r%64), _mm_srli_epi64(kw2, 64-r%64)); \
|
||||
else temp = _mm_or_si128(_mm_slli_epi64(kw2, r%64), _mm_srli_epi64(kw, 64-r%64)); \
|
||||
if (which & 2) _mm_store_si128((__m128i *)CALC_ADDR(ks128, i), temp); \
|
||||
else _mm_storel_epi64((__m128i*)CALC_ADDR(ks32, i+EFI(0)), temp); \
|
||||
}
|
||||
#endif
|
||||
|
||||
if (keylen == 16)
|
||||
{
|
||||
// KL
|
||||
PREPARE_KS_ROUNDS;
|
||||
KS_ROUND_0(0);
|
||||
KS_ROUND(4, 15, 3);
|
||||
KS_ROUND(10, 45, 3);
|
||||
KS_ROUND(12, 60, 2);
|
||||
KS_ROUND(16, 77, 3);
|
||||
KS_ROUND(18, 94, 3);
|
||||
KS_ROUND(22, 111, 3);
|
||||
|
||||
// KA
|
||||
k0=kl0, k1=kl1, k2=kl2, k3=kl3;
|
||||
DOUBLE_ROUND(k0, k1, k2, k3, 0xA09E667Ful, 0x3BCC908Bul, 0xB67AE858ul, 0x4CAA73B2ul);
|
||||
k0^=kl0, k1^=kl1, k2^=kl2, k3^=kl3;
|
||||
DOUBLE_ROUND(k0, k1, k2, k3, 0xC6EF372Ful, 0xE94F82BEul, 0x54FF53A5ul, 0xF1D36F1Cul);
|
||||
|
||||
PREPARE_KS_ROUNDS;
|
||||
KS_ROUND_0(2);
|
||||
KS_ROUND(6, 15, 3);
|
||||
KS_ROUND(8, 30, 3);
|
||||
KS_ROUND(12, 45, 1);
|
||||
KS_ROUND(14, 60, 3);
|
||||
KS_ROUND(20, 94, 3);
|
||||
KS_ROUND(24, 47, 3);
|
||||
}
|
||||
else
|
||||
{
|
||||
// KL
|
||||
PREPARE_KS_ROUNDS;
|
||||
KS_ROUND_0(0);
|
||||
KS_ROUND(12, 45, 3);
|
||||
KS_ROUND(16, 60, 3);
|
||||
KS_ROUND(22, 77, 3);
|
||||
KS_ROUND(30, 111, 3);
|
||||
|
||||
// KR
|
||||
word32 kr0, kr1, kr2, kr3;
|
||||
GetBlock<word32, BigEndian>(key+16)(kr0)(kr1);
|
||||
if (keylen == 24)
|
||||
kr2 = ~kr0, kr3 = ~kr1;
|
||||
else
|
||||
GetBlock<word32, BigEndian>(key+24)(kr2)(kr3);
|
||||
k0=kr0, k1=kr1, k2=kr2, k3=kr3;
|
||||
|
||||
PREPARE_KS_ROUNDS;
|
||||
KS_ROUND(4, 15, 3);
|
||||
KS_ROUND(8, 30, 3);
|
||||
KS_ROUND(18, 60, 3);
|
||||
KS_ROUND(26, 94, 3);
|
||||
|
||||
// KA
|
||||
k0^=kl0, k1^=kl1, k2^=kl2, k3^=kl3;
|
||||
DOUBLE_ROUND(k0, k1, k2, k3, 0xA09E667Ful, 0x3BCC908Bul, 0xB67AE858ul, 0x4CAA73B2ul);
|
||||
k0^=kl0, k1^=kl1, k2^=kl2, k3^=kl3;
|
||||
DOUBLE_ROUND(k0, k1, k2, k3, 0xC6EF372Ful, 0xE94F82BEul, 0x54FF53A5ul, 0xF1D36F1Cul);
|
||||
|
||||
PREPARE_KS_ROUNDS;
|
||||
KS_ROUND(6, 15, 3);
|
||||
KS_ROUND(14, 45, 3);
|
||||
KS_ROUND(24, 77, 3);
|
||||
KS_ROUND(28, 94, 3);
|
||||
|
||||
// KB
|
||||
k0^=kr0, k1^=kr1, k2^=kr2, k3^=kr3;
|
||||
DOUBLE_ROUND(k0, k1, k2, k3, 0x10E527FAul, 0xDE682D1Dul, 0xB05688C2ul, 0xB3E6C1FDul);
|
||||
|
||||
PREPARE_KS_ROUNDS;
|
||||
KS_ROUND_0(2);
|
||||
KS_ROUND(10, 30, 3);
|
||||
KS_ROUND(20, 60, 3);
|
||||
KS_ROUND(32, 47, 3);
|
||||
}
|
||||
}
|
||||
|
||||
void Camellia::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
#define KS(i, j) ks[i*4 + EFI(j/2)*2 + EFI(j%2)]
|
||||
|
||||
#define FL(klh, kll, krh, krl) \
|
||||
ll ^= rotlFixed(lh & klh, 1); \
|
||||
lh ^= (ll | kll); \
|
||||
rh ^= (rl | krl); \
|
||||
rl ^= rotlFixed(rh & krh, 1);
|
||||
|
||||
word32 lh, ll, rh, rl;
|
||||
typedef BlockGetAndPut<word32, BigEndian> Block;
|
||||
Block::Get(inBlock)(lh)(ll)(rh)(rl);
|
||||
const word32 *ks = m_key.data();
|
||||
lh ^= KS(0,0);
|
||||
ll ^= KS(0,1);
|
||||
rh ^= KS(0,2);
|
||||
rl ^= KS(0,3);
|
||||
|
||||
// timing attack countermeasure. see comments at top for more details
|
||||
const int cacheLineSize = GetCacheLineSize();
|
||||
unsigned int i;
|
||||
word32 u = 0;
|
||||
for (i=0; i<256; i+=cacheLineSize)
|
||||
u &= *(const word32 *)(s1+i);
|
||||
u &= *(const word32 *)(s1+252);
|
||||
lh |= u; ll |= u;
|
||||
|
||||
SLOW_ROUND(lh, ll, rh, rl, KS(1,0), KS(1,1))
|
||||
SLOW_ROUND(rh, rl, lh, ll, KS(1,2), KS(1,3))
|
||||
for (i = m_rounds-1; i > 0; --i)
|
||||
{
|
||||
DOUBLE_ROUND(lh, ll, rh, rl, KS(2,0), KS(2,1), KS(2,2), KS(2,3))
|
||||
DOUBLE_ROUND(lh, ll, rh, rl, KS(3,0), KS(3,1), KS(3,2), KS(3,3))
|
||||
FL(KS(4,0), KS(4,1), KS(4,2), KS(4,3));
|
||||
DOUBLE_ROUND(lh, ll, rh, rl, KS(5,0), KS(5,1), KS(5,2), KS(5,3))
|
||||
ks += 16;
|
||||
}
|
||||
DOUBLE_ROUND(lh, ll, rh, rl, KS(2,0), KS(2,1), KS(2,2), KS(2,3))
|
||||
ROUND(lh, ll, rh, rl, KS(3,0), KS(3,1))
|
||||
SLOW_ROUND(rh, rl, lh, ll, KS(3,2), KS(3,3))
|
||||
lh ^= KS(4,0);
|
||||
ll ^= KS(4,1);
|
||||
rh ^= KS(4,2);
|
||||
rl ^= KS(4,3);
|
||||
Block::Put(xorBlock, outBlock)(rh)(rl)(lh)(ll);
|
||||
}
|
||||
|
||||
// The Camellia s-boxes
|
||||
|
||||
const byte Camellia::Base::s1[256] =
|
||||
{
|
||||
112,130,44,236,179,39,192,229,228,133,87,53,234,12,174,65,
|
||||
35,239,107,147,69,25,165,33,237,14,79,78,29,101,146,189,
|
||||
134,184,175,143,124,235,31,206,62,48,220,95,94,197,11,26,
|
||||
166,225,57,202,213,71,93,61,217,1,90,214,81,86,108,77,
|
||||
139,13,154,102,251,204,176,45,116,18,43,32,240,177,132,153,
|
||||
223,76,203,194,52,126,118,5,109,183,169,49,209,23,4,215,
|
||||
20,88,58,97,222,27,17,28,50,15,156,22,83,24,242,34,
|
||||
254,68,207,178,195,181,122,145,36,8,232,168,96,252,105,80,
|
||||
170,208,160,125,161,137,98,151,84,91,30,149,224,255,100,210,
|
||||
16,196,0,72,163,247,117,219,138,3,230,218,9,63,221,148,
|
||||
135,92,131,2,205,74,144,51,115,103,246,243,157,127,191,226,
|
||||
82,155,216,38,200,55,198,59,129,150,111,75,19,190,99,46,
|
||||
233,121,167,140,159,110,188,142,41,245,249,182,47,253,180,89,
|
||||
120,152,6,106,231,70,113,186,212,37,171,66,136,162,141,250,
|
||||
114,7,185,85,248,238,172,10,54,73,42,104,60,56,241,164,
|
||||
64,40,211,123,187,201,67,193,21,227,173,244,119,199,128,158
|
||||
};
|
||||
|
||||
const word32 Camellia::Base::SP[4][256] = {
|
||||
{
|
||||
0x70707000, 0x82828200, 0x2c2c2c00, 0xececec00,
|
||||
0xb3b3b300, 0x27272700, 0xc0c0c000, 0xe5e5e500,
|
||||
0xe4e4e400, 0x85858500, 0x57575700, 0x35353500,
|
||||
0xeaeaea00, 0x0c0c0c00, 0xaeaeae00, 0x41414100,
|
||||
0x23232300, 0xefefef00, 0x6b6b6b00, 0x93939300,
|
||||
0x45454500, 0x19191900, 0xa5a5a500, 0x21212100,
|
||||
0xededed00, 0x0e0e0e00, 0x4f4f4f00, 0x4e4e4e00,
|
||||
0x1d1d1d00, 0x65656500, 0x92929200, 0xbdbdbd00,
|
||||
0x86868600, 0xb8b8b800, 0xafafaf00, 0x8f8f8f00,
|
||||
0x7c7c7c00, 0xebebeb00, 0x1f1f1f00, 0xcecece00,
|
||||
0x3e3e3e00, 0x30303000, 0xdcdcdc00, 0x5f5f5f00,
|
||||
0x5e5e5e00, 0xc5c5c500, 0x0b0b0b00, 0x1a1a1a00,
|
||||
0xa6a6a600, 0xe1e1e100, 0x39393900, 0xcacaca00,
|
||||
0xd5d5d500, 0x47474700, 0x5d5d5d00, 0x3d3d3d00,
|
||||
0xd9d9d900, 0x01010100, 0x5a5a5a00, 0xd6d6d600,
|
||||
0x51515100, 0x56565600, 0x6c6c6c00, 0x4d4d4d00,
|
||||
0x8b8b8b00, 0x0d0d0d00, 0x9a9a9a00, 0x66666600,
|
||||
0xfbfbfb00, 0xcccccc00, 0xb0b0b000, 0x2d2d2d00,
|
||||
0x74747400, 0x12121200, 0x2b2b2b00, 0x20202000,
|
||||
0xf0f0f000, 0xb1b1b100, 0x84848400, 0x99999900,
|
||||
0xdfdfdf00, 0x4c4c4c00, 0xcbcbcb00, 0xc2c2c200,
|
||||
0x34343400, 0x7e7e7e00, 0x76767600, 0x05050500,
|
||||
0x6d6d6d00, 0xb7b7b700, 0xa9a9a900, 0x31313100,
|
||||
0xd1d1d100, 0x17171700, 0x04040400, 0xd7d7d700,
|
||||
0x14141400, 0x58585800, 0x3a3a3a00, 0x61616100,
|
||||
0xdedede00, 0x1b1b1b00, 0x11111100, 0x1c1c1c00,
|
||||
0x32323200, 0x0f0f0f00, 0x9c9c9c00, 0x16161600,
|
||||
0x53535300, 0x18181800, 0xf2f2f200, 0x22222200,
|
||||
0xfefefe00, 0x44444400, 0xcfcfcf00, 0xb2b2b200,
|
||||
0xc3c3c300, 0xb5b5b500, 0x7a7a7a00, 0x91919100,
|
||||
0x24242400, 0x08080800, 0xe8e8e800, 0xa8a8a800,
|
||||
0x60606000, 0xfcfcfc00, 0x69696900, 0x50505000,
|
||||
0xaaaaaa00, 0xd0d0d000, 0xa0a0a000, 0x7d7d7d00,
|
||||
0xa1a1a100, 0x89898900, 0x62626200, 0x97979700,
|
||||
0x54545400, 0x5b5b5b00, 0x1e1e1e00, 0x95959500,
|
||||
0xe0e0e000, 0xffffff00, 0x64646400, 0xd2d2d200,
|
||||
0x10101000, 0xc4c4c400, 0x00000000, 0x48484800,
|
||||
0xa3a3a300, 0xf7f7f700, 0x75757500, 0xdbdbdb00,
|
||||
0x8a8a8a00, 0x03030300, 0xe6e6e600, 0xdadada00,
|
||||
0x09090900, 0x3f3f3f00, 0xdddddd00, 0x94949400,
|
||||
0x87878700, 0x5c5c5c00, 0x83838300, 0x02020200,
|
||||
0xcdcdcd00, 0x4a4a4a00, 0x90909000, 0x33333300,
|
||||
0x73737300, 0x67676700, 0xf6f6f600, 0xf3f3f300,
|
||||
0x9d9d9d00, 0x7f7f7f00, 0xbfbfbf00, 0xe2e2e200,
|
||||
0x52525200, 0x9b9b9b00, 0xd8d8d800, 0x26262600,
|
||||
0xc8c8c800, 0x37373700, 0xc6c6c600, 0x3b3b3b00,
|
||||
0x81818100, 0x96969600, 0x6f6f6f00, 0x4b4b4b00,
|
||||
0x13131300, 0xbebebe00, 0x63636300, 0x2e2e2e00,
|
||||
0xe9e9e900, 0x79797900, 0xa7a7a700, 0x8c8c8c00,
|
||||
0x9f9f9f00, 0x6e6e6e00, 0xbcbcbc00, 0x8e8e8e00,
|
||||
0x29292900, 0xf5f5f500, 0xf9f9f900, 0xb6b6b600,
|
||||
0x2f2f2f00, 0xfdfdfd00, 0xb4b4b400, 0x59595900,
|
||||
0x78787800, 0x98989800, 0x06060600, 0x6a6a6a00,
|
||||
0xe7e7e700, 0x46464600, 0x71717100, 0xbababa00,
|
||||
0xd4d4d400, 0x25252500, 0xababab00, 0x42424200,
|
||||
0x88888800, 0xa2a2a200, 0x8d8d8d00, 0xfafafa00,
|
||||
0x72727200, 0x07070700, 0xb9b9b900, 0x55555500,
|
||||
0xf8f8f800, 0xeeeeee00, 0xacacac00, 0x0a0a0a00,
|
||||
0x36363600, 0x49494900, 0x2a2a2a00, 0x68686800,
|
||||
0x3c3c3c00, 0x38383800, 0xf1f1f100, 0xa4a4a400,
|
||||
0x40404000, 0x28282800, 0xd3d3d300, 0x7b7b7b00,
|
||||
0xbbbbbb00, 0xc9c9c900, 0x43434300, 0xc1c1c100,
|
||||
0x15151500, 0xe3e3e300, 0xadadad00, 0xf4f4f400,
|
||||
0x77777700, 0xc7c7c700, 0x80808000, 0x9e9e9e00
|
||||
},
|
||||
{
|
||||
0x00e0e0e0, 0x00050505, 0x00585858, 0x00d9d9d9,
|
||||
0x00676767, 0x004e4e4e, 0x00818181, 0x00cbcbcb,
|
||||
0x00c9c9c9, 0x000b0b0b, 0x00aeaeae, 0x006a6a6a,
|
||||
0x00d5d5d5, 0x00181818, 0x005d5d5d, 0x00828282,
|
||||
0x00464646, 0x00dfdfdf, 0x00d6d6d6, 0x00272727,
|
||||
0x008a8a8a, 0x00323232, 0x004b4b4b, 0x00424242,
|
||||
0x00dbdbdb, 0x001c1c1c, 0x009e9e9e, 0x009c9c9c,
|
||||
0x003a3a3a, 0x00cacaca, 0x00252525, 0x007b7b7b,
|
||||
0x000d0d0d, 0x00717171, 0x005f5f5f, 0x001f1f1f,
|
||||
0x00f8f8f8, 0x00d7d7d7, 0x003e3e3e, 0x009d9d9d,
|
||||
0x007c7c7c, 0x00606060, 0x00b9b9b9, 0x00bebebe,
|
||||
0x00bcbcbc, 0x008b8b8b, 0x00161616, 0x00343434,
|
||||
0x004d4d4d, 0x00c3c3c3, 0x00727272, 0x00959595,
|
||||
0x00ababab, 0x008e8e8e, 0x00bababa, 0x007a7a7a,
|
||||
0x00b3b3b3, 0x00020202, 0x00b4b4b4, 0x00adadad,
|
||||
0x00a2a2a2, 0x00acacac, 0x00d8d8d8, 0x009a9a9a,
|
||||
0x00171717, 0x001a1a1a, 0x00353535, 0x00cccccc,
|
||||
0x00f7f7f7, 0x00999999, 0x00616161, 0x005a5a5a,
|
||||
0x00e8e8e8, 0x00242424, 0x00565656, 0x00404040,
|
||||
0x00e1e1e1, 0x00636363, 0x00090909, 0x00333333,
|
||||
0x00bfbfbf, 0x00989898, 0x00979797, 0x00858585,
|
||||
0x00686868, 0x00fcfcfc, 0x00ececec, 0x000a0a0a,
|
||||
0x00dadada, 0x006f6f6f, 0x00535353, 0x00626262,
|
||||
0x00a3a3a3, 0x002e2e2e, 0x00080808, 0x00afafaf,
|
||||
0x00282828, 0x00b0b0b0, 0x00747474, 0x00c2c2c2,
|
||||
0x00bdbdbd, 0x00363636, 0x00222222, 0x00383838,
|
||||
0x00646464, 0x001e1e1e, 0x00393939, 0x002c2c2c,
|
||||
0x00a6a6a6, 0x00303030, 0x00e5e5e5, 0x00444444,
|
||||
0x00fdfdfd, 0x00888888, 0x009f9f9f, 0x00656565,
|
||||
0x00878787, 0x006b6b6b, 0x00f4f4f4, 0x00232323,
|
||||
0x00484848, 0x00101010, 0x00d1d1d1, 0x00515151,
|
||||
0x00c0c0c0, 0x00f9f9f9, 0x00d2d2d2, 0x00a0a0a0,
|
||||
0x00555555, 0x00a1a1a1, 0x00414141, 0x00fafafa,
|
||||
0x00434343, 0x00131313, 0x00c4c4c4, 0x002f2f2f,
|
||||
0x00a8a8a8, 0x00b6b6b6, 0x003c3c3c, 0x002b2b2b,
|
||||
0x00c1c1c1, 0x00ffffff, 0x00c8c8c8, 0x00a5a5a5,
|
||||
0x00202020, 0x00898989, 0x00000000, 0x00909090,
|
||||
0x00474747, 0x00efefef, 0x00eaeaea, 0x00b7b7b7,
|
||||
0x00151515, 0x00060606, 0x00cdcdcd, 0x00b5b5b5,
|
||||
0x00121212, 0x007e7e7e, 0x00bbbbbb, 0x00292929,
|
||||
0x000f0f0f, 0x00b8b8b8, 0x00070707, 0x00040404,
|
||||
0x009b9b9b, 0x00949494, 0x00212121, 0x00666666,
|
||||
0x00e6e6e6, 0x00cecece, 0x00ededed, 0x00e7e7e7,
|
||||
0x003b3b3b, 0x00fefefe, 0x007f7f7f, 0x00c5c5c5,
|
||||
0x00a4a4a4, 0x00373737, 0x00b1b1b1, 0x004c4c4c,
|
||||
0x00919191, 0x006e6e6e, 0x008d8d8d, 0x00767676,
|
||||
0x00030303, 0x002d2d2d, 0x00dedede, 0x00969696,
|
||||
0x00262626, 0x007d7d7d, 0x00c6c6c6, 0x005c5c5c,
|
||||
0x00d3d3d3, 0x00f2f2f2, 0x004f4f4f, 0x00191919,
|
||||
0x003f3f3f, 0x00dcdcdc, 0x00797979, 0x001d1d1d,
|
||||
0x00525252, 0x00ebebeb, 0x00f3f3f3, 0x006d6d6d,
|
||||
0x005e5e5e, 0x00fbfbfb, 0x00696969, 0x00b2b2b2,
|
||||
0x00f0f0f0, 0x00313131, 0x000c0c0c, 0x00d4d4d4,
|
||||
0x00cfcfcf, 0x008c8c8c, 0x00e2e2e2, 0x00757575,
|
||||
0x00a9a9a9, 0x004a4a4a, 0x00575757, 0x00848484,
|
||||
0x00111111, 0x00454545, 0x001b1b1b, 0x00f5f5f5,
|
||||
0x00e4e4e4, 0x000e0e0e, 0x00737373, 0x00aaaaaa,
|
||||
0x00f1f1f1, 0x00dddddd, 0x00595959, 0x00141414,
|
||||
0x006c6c6c, 0x00929292, 0x00545454, 0x00d0d0d0,
|
||||
0x00787878, 0x00707070, 0x00e3e3e3, 0x00494949,
|
||||
0x00808080, 0x00505050, 0x00a7a7a7, 0x00f6f6f6,
|
||||
0x00777777, 0x00939393, 0x00868686, 0x00838383,
|
||||
0x002a2a2a, 0x00c7c7c7, 0x005b5b5b, 0x00e9e9e9,
|
||||
0x00eeeeee, 0x008f8f8f, 0x00010101, 0x003d3d3d
|
||||
},
|
||||
{
|
||||
0x38003838, 0x41004141, 0x16001616, 0x76007676,
|
||||
0xd900d9d9, 0x93009393, 0x60006060, 0xf200f2f2,
|
||||
0x72007272, 0xc200c2c2, 0xab00abab, 0x9a009a9a,
|
||||
0x75007575, 0x06000606, 0x57005757, 0xa000a0a0,
|
||||
0x91009191, 0xf700f7f7, 0xb500b5b5, 0xc900c9c9,
|
||||
0xa200a2a2, 0x8c008c8c, 0xd200d2d2, 0x90009090,
|
||||
0xf600f6f6, 0x07000707, 0xa700a7a7, 0x27002727,
|
||||
0x8e008e8e, 0xb200b2b2, 0x49004949, 0xde00dede,
|
||||
0x43004343, 0x5c005c5c, 0xd700d7d7, 0xc700c7c7,
|
||||
0x3e003e3e, 0xf500f5f5, 0x8f008f8f, 0x67006767,
|
||||
0x1f001f1f, 0x18001818, 0x6e006e6e, 0xaf00afaf,
|
||||
0x2f002f2f, 0xe200e2e2, 0x85008585, 0x0d000d0d,
|
||||
0x53005353, 0xf000f0f0, 0x9c009c9c, 0x65006565,
|
||||
0xea00eaea, 0xa300a3a3, 0xae00aeae, 0x9e009e9e,
|
||||
0xec00ecec, 0x80008080, 0x2d002d2d, 0x6b006b6b,
|
||||
0xa800a8a8, 0x2b002b2b, 0x36003636, 0xa600a6a6,
|
||||
0xc500c5c5, 0x86008686, 0x4d004d4d, 0x33003333,
|
||||
0xfd00fdfd, 0x66006666, 0x58005858, 0x96009696,
|
||||
0x3a003a3a, 0x09000909, 0x95009595, 0x10001010,
|
||||
0x78007878, 0xd800d8d8, 0x42004242, 0xcc00cccc,
|
||||
0xef00efef, 0x26002626, 0xe500e5e5, 0x61006161,
|
||||
0x1a001a1a, 0x3f003f3f, 0x3b003b3b, 0x82008282,
|
||||
0xb600b6b6, 0xdb00dbdb, 0xd400d4d4, 0x98009898,
|
||||
0xe800e8e8, 0x8b008b8b, 0x02000202, 0xeb00ebeb,
|
||||
0x0a000a0a, 0x2c002c2c, 0x1d001d1d, 0xb000b0b0,
|
||||
0x6f006f6f, 0x8d008d8d, 0x88008888, 0x0e000e0e,
|
||||
0x19001919, 0x87008787, 0x4e004e4e, 0x0b000b0b,
|
||||
0xa900a9a9, 0x0c000c0c, 0x79007979, 0x11001111,
|
||||
0x7f007f7f, 0x22002222, 0xe700e7e7, 0x59005959,
|
||||
0xe100e1e1, 0xda00dada, 0x3d003d3d, 0xc800c8c8,
|
||||
0x12001212, 0x04000404, 0x74007474, 0x54005454,
|
||||
0x30003030, 0x7e007e7e, 0xb400b4b4, 0x28002828,
|
||||
0x55005555, 0x68006868, 0x50005050, 0xbe00bebe,
|
||||
0xd000d0d0, 0xc400c4c4, 0x31003131, 0xcb00cbcb,
|
||||
0x2a002a2a, 0xad00adad, 0x0f000f0f, 0xca00caca,
|
||||
0x70007070, 0xff00ffff, 0x32003232, 0x69006969,
|
||||
0x08000808, 0x62006262, 0x00000000, 0x24002424,
|
||||
0xd100d1d1, 0xfb00fbfb, 0xba00baba, 0xed00eded,
|
||||
0x45004545, 0x81008181, 0x73007373, 0x6d006d6d,
|
||||
0x84008484, 0x9f009f9f, 0xee00eeee, 0x4a004a4a,
|
||||
0xc300c3c3, 0x2e002e2e, 0xc100c1c1, 0x01000101,
|
||||
0xe600e6e6, 0x25002525, 0x48004848, 0x99009999,
|
||||
0xb900b9b9, 0xb300b3b3, 0x7b007b7b, 0xf900f9f9,
|
||||
0xce00cece, 0xbf00bfbf, 0xdf00dfdf, 0x71007171,
|
||||
0x29002929, 0xcd00cdcd, 0x6c006c6c, 0x13001313,
|
||||
0x64006464, 0x9b009b9b, 0x63006363, 0x9d009d9d,
|
||||
0xc000c0c0, 0x4b004b4b, 0xb700b7b7, 0xa500a5a5,
|
||||
0x89008989, 0x5f005f5f, 0xb100b1b1, 0x17001717,
|
||||
0xf400f4f4, 0xbc00bcbc, 0xd300d3d3, 0x46004646,
|
||||
0xcf00cfcf, 0x37003737, 0x5e005e5e, 0x47004747,
|
||||
0x94009494, 0xfa00fafa, 0xfc00fcfc, 0x5b005b5b,
|
||||
0x97009797, 0xfe00fefe, 0x5a005a5a, 0xac00acac,
|
||||
0x3c003c3c, 0x4c004c4c, 0x03000303, 0x35003535,
|
||||
0xf300f3f3, 0x23002323, 0xb800b8b8, 0x5d005d5d,
|
||||
0x6a006a6a, 0x92009292, 0xd500d5d5, 0x21002121,
|
||||
0x44004444, 0x51005151, 0xc600c6c6, 0x7d007d7d,
|
||||
0x39003939, 0x83008383, 0xdc00dcdc, 0xaa00aaaa,
|
||||
0x7c007c7c, 0x77007777, 0x56005656, 0x05000505,
|
||||
0x1b001b1b, 0xa400a4a4, 0x15001515, 0x34003434,
|
||||
0x1e001e1e, 0x1c001c1c, 0xf800f8f8, 0x52005252,
|
||||
0x20002020, 0x14001414, 0xe900e9e9, 0xbd00bdbd,
|
||||
0xdd00dddd, 0xe400e4e4, 0xa100a1a1, 0xe000e0e0,
|
||||
0x8a008a8a, 0xf100f1f1, 0xd600d6d6, 0x7a007a7a,
|
||||
0xbb00bbbb, 0xe300e3e3, 0x40004040, 0x4f004f4f
|
||||
},
|
||||
{
|
||||
0x70700070, 0x2c2c002c, 0xb3b300b3, 0xc0c000c0,
|
||||
0xe4e400e4, 0x57570057, 0xeaea00ea, 0xaeae00ae,
|
||||
0x23230023, 0x6b6b006b, 0x45450045, 0xa5a500a5,
|
||||
0xeded00ed, 0x4f4f004f, 0x1d1d001d, 0x92920092,
|
||||
0x86860086, 0xafaf00af, 0x7c7c007c, 0x1f1f001f,
|
||||
0x3e3e003e, 0xdcdc00dc, 0x5e5e005e, 0x0b0b000b,
|
||||
0xa6a600a6, 0x39390039, 0xd5d500d5, 0x5d5d005d,
|
||||
0xd9d900d9, 0x5a5a005a, 0x51510051, 0x6c6c006c,
|
||||
0x8b8b008b, 0x9a9a009a, 0xfbfb00fb, 0xb0b000b0,
|
||||
0x74740074, 0x2b2b002b, 0xf0f000f0, 0x84840084,
|
||||
0xdfdf00df, 0xcbcb00cb, 0x34340034, 0x76760076,
|
||||
0x6d6d006d, 0xa9a900a9, 0xd1d100d1, 0x04040004,
|
||||
0x14140014, 0x3a3a003a, 0xdede00de, 0x11110011,
|
||||
0x32320032, 0x9c9c009c, 0x53530053, 0xf2f200f2,
|
||||
0xfefe00fe, 0xcfcf00cf, 0xc3c300c3, 0x7a7a007a,
|
||||
0x24240024, 0xe8e800e8, 0x60600060, 0x69690069,
|
||||
0xaaaa00aa, 0xa0a000a0, 0xa1a100a1, 0x62620062,
|
||||
0x54540054, 0x1e1e001e, 0xe0e000e0, 0x64640064,
|
||||
0x10100010, 0x00000000, 0xa3a300a3, 0x75750075,
|
||||
0x8a8a008a, 0xe6e600e6, 0x09090009, 0xdddd00dd,
|
||||
0x87870087, 0x83830083, 0xcdcd00cd, 0x90900090,
|
||||
0x73730073, 0xf6f600f6, 0x9d9d009d, 0xbfbf00bf,
|
||||
0x52520052, 0xd8d800d8, 0xc8c800c8, 0xc6c600c6,
|
||||
0x81810081, 0x6f6f006f, 0x13130013, 0x63630063,
|
||||
0xe9e900e9, 0xa7a700a7, 0x9f9f009f, 0xbcbc00bc,
|
||||
0x29290029, 0xf9f900f9, 0x2f2f002f, 0xb4b400b4,
|
||||
0x78780078, 0x06060006, 0xe7e700e7, 0x71710071,
|
||||
0xd4d400d4, 0xabab00ab, 0x88880088, 0x8d8d008d,
|
||||
0x72720072, 0xb9b900b9, 0xf8f800f8, 0xacac00ac,
|
||||
0x36360036, 0x2a2a002a, 0x3c3c003c, 0xf1f100f1,
|
||||
0x40400040, 0xd3d300d3, 0xbbbb00bb, 0x43430043,
|
||||
0x15150015, 0xadad00ad, 0x77770077, 0x80800080,
|
||||
0x82820082, 0xecec00ec, 0x27270027, 0xe5e500e5,
|
||||
0x85850085, 0x35350035, 0x0c0c000c, 0x41410041,
|
||||
0xefef00ef, 0x93930093, 0x19190019, 0x21210021,
|
||||
0x0e0e000e, 0x4e4e004e, 0x65650065, 0xbdbd00bd,
|
||||
0xb8b800b8, 0x8f8f008f, 0xebeb00eb, 0xcece00ce,
|
||||
0x30300030, 0x5f5f005f, 0xc5c500c5, 0x1a1a001a,
|
||||
0xe1e100e1, 0xcaca00ca, 0x47470047, 0x3d3d003d,
|
||||
0x01010001, 0xd6d600d6, 0x56560056, 0x4d4d004d,
|
||||
0x0d0d000d, 0x66660066, 0xcccc00cc, 0x2d2d002d,
|
||||
0x12120012, 0x20200020, 0xb1b100b1, 0x99990099,
|
||||
0x4c4c004c, 0xc2c200c2, 0x7e7e007e, 0x05050005,
|
||||
0xb7b700b7, 0x31310031, 0x17170017, 0xd7d700d7,
|
||||
0x58580058, 0x61610061, 0x1b1b001b, 0x1c1c001c,
|
||||
0x0f0f000f, 0x16160016, 0x18180018, 0x22220022,
|
||||
0x44440044, 0xb2b200b2, 0xb5b500b5, 0x91910091,
|
||||
0x08080008, 0xa8a800a8, 0xfcfc00fc, 0x50500050,
|
||||
0xd0d000d0, 0x7d7d007d, 0x89890089, 0x97970097,
|
||||
0x5b5b005b, 0x95950095, 0xffff00ff, 0xd2d200d2,
|
||||
0xc4c400c4, 0x48480048, 0xf7f700f7, 0xdbdb00db,
|
||||
0x03030003, 0xdada00da, 0x3f3f003f, 0x94940094,
|
||||
0x5c5c005c, 0x02020002, 0x4a4a004a, 0x33330033,
|
||||
0x67670067, 0xf3f300f3, 0x7f7f007f, 0xe2e200e2,
|
||||
0x9b9b009b, 0x26260026, 0x37370037, 0x3b3b003b,
|
||||
0x96960096, 0x4b4b004b, 0xbebe00be, 0x2e2e002e,
|
||||
0x79790079, 0x8c8c008c, 0x6e6e006e, 0x8e8e008e,
|
||||
0xf5f500f5, 0xb6b600b6, 0xfdfd00fd, 0x59590059,
|
||||
0x98980098, 0x6a6a006a, 0x46460046, 0xbaba00ba,
|
||||
0x25250025, 0x42420042, 0xa2a200a2, 0xfafa00fa,
|
||||
0x07070007, 0x55550055, 0xeeee00ee, 0x0a0a000a,
|
||||
0x49490049, 0x68680068, 0x38380038, 0xa4a400a4,
|
||||
0x28280028, 0x7b7b007b, 0xc9c900c9, 0xc1c100c1,
|
||||
0xe3e300e3, 0xf4f400f4, 0xc7c700c7, 0x9e9e009e
|
||||
}};
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,47 +0,0 @@
|
||||
#ifndef CRYPTOPP_CAMELLIA_H
|
||||
#define CRYPTOPP_CAMELLIA_H
|
||||
|
||||
#include "config.h"
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct Camellia_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "Camellia";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#Camellia">Camellia</a>
|
||||
class Camellia : public Camellia_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<Camellia_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs ¶ms);
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
|
||||
protected:
|
||||
static const byte s1[256];
|
||||
static const word32 SP[4][256];
|
||||
|
||||
unsigned int m_rounds;
|
||||
SecBlock<word32> m_key;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
|
||||
};
|
||||
|
||||
typedef Camellia::Encryption CamelliaEncryption;
|
||||
typedef Camellia::Decryption CamelliaDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,296 +0,0 @@
|
||||
// cast.cpp - written and placed in the public domain by Wei Dai and Leonard Janke
|
||||
// based on Steve Reid's public domain cast.c
|
||||
|
||||
#include "pch.h"
|
||||
#include "cast.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
/* Macros to access 8-bit bytes out of a 32-bit word */
|
||||
#define U8a(x) GETBYTE(x,3)
|
||||
#define U8b(x) GETBYTE(x,2)
|
||||
#define U8c(x) GETBYTE(x,1)
|
||||
#define U8d(x) GETBYTE(x,0)
|
||||
|
||||
/* CAST uses three different round functions */
|
||||
#define f1(l, r, km, kr) \
|
||||
t = rotlVariable(km + r, kr); \
|
||||
l ^= ((S[0][U8a(t)] ^ S[1][U8b(t)]) - \
|
||||
S[2][U8c(t)]) + S[3][U8d(t)];
|
||||
#define f2(l, r, km, kr) \
|
||||
t = rotlVariable(km ^ r, kr); \
|
||||
l ^= ((S[0][U8a(t)] - S[1][U8b(t)]) + \
|
||||
S[2][U8c(t)]) ^ S[3][U8d(t)];
|
||||
#define f3(l, r, km, kr) \
|
||||
t = rotlVariable(km - r, kr); \
|
||||
l ^= ((S[0][U8a(t)] + S[1][U8b(t)]) ^ \
|
||||
S[2][U8c(t)]) - S[3][U8d(t)];
|
||||
|
||||
#define F1(l, r, i, j) f1(l, r, K[i], K[i+j])
|
||||
#define F2(l, r, i, j) f2(l, r, K[i], K[i+j])
|
||||
#define F3(l, r, i, j) f3(l, r, K[i], K[i+j])
|
||||
|
||||
typedef BlockGetAndPut<word32, BigEndian> Block;
|
||||
|
||||
void CAST128::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 t, l, r;
|
||||
|
||||
/* Get inblock into l,r */
|
||||
Block::Get(inBlock)(l)(r);
|
||||
/* Do the work */
|
||||
F1(l, r, 0, 16);
|
||||
F2(r, l, 1, 16);
|
||||
F3(l, r, 2, 16);
|
||||
F1(r, l, 3, 16);
|
||||
F2(l, r, 4, 16);
|
||||
F3(r, l, 5, 16);
|
||||
F1(l, r, 6, 16);
|
||||
F2(r, l, 7, 16);
|
||||
F3(l, r, 8, 16);
|
||||
F1(r, l, 9, 16);
|
||||
F2(l, r, 10, 16);
|
||||
F3(r, l, 11, 16);
|
||||
/* Only do full 16 rounds if key length > 80 bits */
|
||||
if (!reduced) {
|
||||
F1(l, r, 12, 16);
|
||||
F2(r, l, 13, 16);
|
||||
F3(l, r, 14, 16);
|
||||
F1(r, l, 15, 16);
|
||||
}
|
||||
/* Put l,r into outblock */
|
||||
Block::Put(xorBlock, outBlock)(r)(l);
|
||||
}
|
||||
|
||||
void CAST128::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 t, l, r;
|
||||
|
||||
/* Get inblock into l,r */
|
||||
Block::Get(inBlock)(r)(l);
|
||||
/* Only do full 16 rounds if key length > 80 bits */
|
||||
if (!reduced) {
|
||||
F1(r, l, 15, 16);
|
||||
F3(l, r, 14, 16);
|
||||
F2(r, l, 13, 16);
|
||||
F1(l, r, 12, 16);
|
||||
}
|
||||
F3(r, l, 11, 16);
|
||||
F2(l, r, 10, 16);
|
||||
F1(r, l, 9, 16);
|
||||
F3(l, r, 8, 16);
|
||||
F2(r, l, 7, 16);
|
||||
F1(l, r, 6, 16);
|
||||
F3(r, l, 5, 16);
|
||||
F2(l, r, 4, 16);
|
||||
F1(r, l, 3, 16);
|
||||
F3(l, r, 2, 16);
|
||||
F2(r, l, 1, 16);
|
||||
F1(l, r, 0, 16);
|
||||
/* Put l,r into outblock */
|
||||
Block::Put(xorBlock, outBlock)(l)(r);
|
||||
/* Wipe clean */
|
||||
t = l = r = 0;
|
||||
}
|
||||
|
||||
void CAST128::Base::UncheckedSetKey(const byte *userKey, unsigned int keylength, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(keylength);
|
||||
|
||||
reduced = (keylength <= 10);
|
||||
|
||||
word32 X[4], Z[4];
|
||||
GetUserKey(BIG_ENDIAN_ORDER, X, 4, userKey, keylength);
|
||||
|
||||
#define x(i) GETBYTE(X[i/4], 3-i%4)
|
||||
#define z(i) GETBYTE(Z[i/4], 3-i%4)
|
||||
|
||||
unsigned int i;
|
||||
for (i=0; i<=16; i+=16)
|
||||
{
|
||||
// this part is copied directly from RFC 2144 (with some search and replace) by Wei Dai
|
||||
Z[0] = X[0] ^ S[4][x(0xD)] ^ S[5][x(0xF)] ^ S[6][x(0xC)] ^ S[7][x(0xE)] ^ S[6][x(0x8)];
|
||||
Z[1] = X[2] ^ S[4][z(0x0)] ^ S[5][z(0x2)] ^ S[6][z(0x1)] ^ S[7][z(0x3)] ^ S[7][x(0xA)];
|
||||
Z[2] = X[3] ^ S[4][z(0x7)] ^ S[5][z(0x6)] ^ S[6][z(0x5)] ^ S[7][z(0x4)] ^ S[4][x(0x9)];
|
||||
Z[3] = X[1] ^ S[4][z(0xA)] ^ S[5][z(0x9)] ^ S[6][z(0xB)] ^ S[7][z(0x8)] ^ S[5][x(0xB)];
|
||||
K[i+0] = S[4][z(0x8)] ^ S[5][z(0x9)] ^ S[6][z(0x7)] ^ S[7][z(0x6)] ^ S[4][z(0x2)];
|
||||
K[i+1] = S[4][z(0xA)] ^ S[5][z(0xB)] ^ S[6][z(0x5)] ^ S[7][z(0x4)] ^ S[5][z(0x6)];
|
||||
K[i+2] = S[4][z(0xC)] ^ S[5][z(0xD)] ^ S[6][z(0x3)] ^ S[7][z(0x2)] ^ S[6][z(0x9)];
|
||||
K[i+3] = S[4][z(0xE)] ^ S[5][z(0xF)] ^ S[6][z(0x1)] ^ S[7][z(0x0)] ^ S[7][z(0xC)];
|
||||
X[0] = Z[2] ^ S[4][z(0x5)] ^ S[5][z(0x7)] ^ S[6][z(0x4)] ^ S[7][z(0x6)] ^ S[6][z(0x0)];
|
||||
X[1] = Z[0] ^ S[4][x(0x0)] ^ S[5][x(0x2)] ^ S[6][x(0x1)] ^ S[7][x(0x3)] ^ S[7][z(0x2)];
|
||||
X[2] = Z[1] ^ S[4][x(0x7)] ^ S[5][x(0x6)] ^ S[6][x(0x5)] ^ S[7][x(0x4)] ^ S[4][z(0x1)];
|
||||
X[3] = Z[3] ^ S[4][x(0xA)] ^ S[5][x(0x9)] ^ S[6][x(0xB)] ^ S[7][x(0x8)] ^ S[5][z(0x3)];
|
||||
K[i+4] = S[4][x(0x3)] ^ S[5][x(0x2)] ^ S[6][x(0xC)] ^ S[7][x(0xD)] ^ S[4][x(0x8)];
|
||||
K[i+5] = S[4][x(0x1)] ^ S[5][x(0x0)] ^ S[6][x(0xE)] ^ S[7][x(0xF)] ^ S[5][x(0xD)];
|
||||
K[i+6] = S[4][x(0x7)] ^ S[5][x(0x6)] ^ S[6][x(0x8)] ^ S[7][x(0x9)] ^ S[6][x(0x3)];
|
||||
K[i+7] = S[4][x(0x5)] ^ S[5][x(0x4)] ^ S[6][x(0xA)] ^ S[7][x(0xB)] ^ S[7][x(0x7)];
|
||||
Z[0] = X[0] ^ S[4][x(0xD)] ^ S[5][x(0xF)] ^ S[6][x(0xC)] ^ S[7][x(0xE)] ^ S[6][x(0x8)];
|
||||
Z[1] = X[2] ^ S[4][z(0x0)] ^ S[5][z(0x2)] ^ S[6][z(0x1)] ^ S[7][z(0x3)] ^ S[7][x(0xA)];
|
||||
Z[2] = X[3] ^ S[4][z(0x7)] ^ S[5][z(0x6)] ^ S[6][z(0x5)] ^ S[7][z(0x4)] ^ S[4][x(0x9)];
|
||||
Z[3] = X[1] ^ S[4][z(0xA)] ^ S[5][z(0x9)] ^ S[6][z(0xB)] ^ S[7][z(0x8)] ^ S[5][x(0xB)];
|
||||
K[i+8] = S[4][z(0x3)] ^ S[5][z(0x2)] ^ S[6][z(0xC)] ^ S[7][z(0xD)] ^ S[4][z(0x9)];
|
||||
K[i+9] = S[4][z(0x1)] ^ S[5][z(0x0)] ^ S[6][z(0xE)] ^ S[7][z(0xF)] ^ S[5][z(0xC)];
|
||||
K[i+10] = S[4][z(0x7)] ^ S[5][z(0x6)] ^ S[6][z(0x8)] ^ S[7][z(0x9)] ^ S[6][z(0x2)];
|
||||
K[i+11] = S[4][z(0x5)] ^ S[5][z(0x4)] ^ S[6][z(0xA)] ^ S[7][z(0xB)] ^ S[7][z(0x6)];
|
||||
X[0] = Z[2] ^ S[4][z(0x5)] ^ S[5][z(0x7)] ^ S[6][z(0x4)] ^ S[7][z(0x6)] ^ S[6][z(0x0)];
|
||||
X[1] = Z[0] ^ S[4][x(0x0)] ^ S[5][x(0x2)] ^ S[6][x(0x1)] ^ S[7][x(0x3)] ^ S[7][z(0x2)];
|
||||
X[2] = Z[1] ^ S[4][x(0x7)] ^ S[5][x(0x6)] ^ S[6][x(0x5)] ^ S[7][x(0x4)] ^ S[4][z(0x1)];
|
||||
X[3] = Z[3] ^ S[4][x(0xA)] ^ S[5][x(0x9)] ^ S[6][x(0xB)] ^ S[7][x(0x8)] ^ S[5][z(0x3)];
|
||||
K[i+12] = S[4][x(0x8)] ^ S[5][x(0x9)] ^ S[6][x(0x7)] ^ S[7][x(0x6)] ^ S[4][x(0x3)];
|
||||
K[i+13] = S[4][x(0xA)] ^ S[5][x(0xB)] ^ S[6][x(0x5)] ^ S[7][x(0x4)] ^ S[5][x(0x7)];
|
||||
K[i+14] = S[4][x(0xC)] ^ S[5][x(0xD)] ^ S[6][x(0x3)] ^ S[7][x(0x2)] ^ S[6][x(0x8)];
|
||||
K[i+15] = S[4][x(0xE)] ^ S[5][x(0xF)] ^ S[6][x(0x1)] ^ S[7][x(0x0)] ^ S[7][x(0xD)];
|
||||
}
|
||||
|
||||
for (i=16; i<32; i++)
|
||||
K[i] &= 0x1f;
|
||||
}
|
||||
|
||||
// The following CAST-256 implementation was contributed by Leonard Janke
|
||||
|
||||
const word32 CAST256::Base::t_m[8][24]={
|
||||
{ 0x5a827999, 0xd151d6a1, 0x482133a9, 0xbef090b1, 0x35bfedb9, 0xac8f4ac1,
|
||||
0x235ea7c9, 0x9a2e04d1, 0x10fd61d9, 0x87ccbee1, 0xfe9c1be9, 0x756b78f1,
|
||||
0xec3ad5f9, 0x630a3301, 0xd9d99009, 0x50a8ed11, 0xc7784a19, 0x3e47a721,
|
||||
0xb5170429, 0x2be66131, 0xa2b5be39, 0x19851b41, 0x90547849, 0x0723d551},
|
||||
{ 0xc95c653a, 0x402bc242, 0xb6fb1f4a, 0x2dca7c52, 0xa499d95a, 0x1b693662,
|
||||
0x9238936a, 0x0907f072, 0x7fd74d7a, 0xf6a6aa82, 0x6d76078a, 0xe4456492,
|
||||
0x5b14c19a, 0xd1e41ea2, 0x48b37baa, 0xbf82d8b2, 0x365235ba, 0xad2192c2,
|
||||
0x23f0efca, 0x9ac04cd2, 0x118fa9da, 0x885f06e2, 0xff2e63ea, 0x75fdc0f2},
|
||||
{ 0x383650db, 0xaf05ade3, 0x25d50aeb, 0x9ca467f3, 0x1373c4fb, 0x8a432203,
|
||||
0x01127f0b, 0x77e1dc13, 0xeeb1391b, 0x65809623, 0xdc4ff32b, 0x531f5033,
|
||||
0xc9eead3b, 0x40be0a43, 0xb78d674b, 0x2e5cc453, 0xa52c215b, 0x1bfb7e63,
|
||||
0x92cadb6b, 0x099a3873, 0x8069957b, 0xf738f283, 0x6e084f8b, 0xe4d7ac93},
|
||||
{ 0xa7103c7c, 0x1ddf9984, 0x94aef68c, 0x0b7e5394, 0x824db09c, 0xf91d0da4,
|
||||
0x6fec6aac, 0xe6bbc7b4, 0x5d8b24bc, 0xd45a81c4, 0x4b29decc, 0xc1f93bd4,
|
||||
0x38c898dc, 0xaf97f5e4, 0x266752ec, 0x9d36aff4, 0x14060cfc, 0x8ad56a04,
|
||||
0x01a4c70c, 0x78742414, 0xef43811c, 0x6612de24, 0xdce23b2c, 0x53b19834},
|
||||
{ 0x15ea281d, 0x8cb98525, 0x0388e22d, 0x7a583f35, 0xf1279c3d, 0x67f6f945,
|
||||
0xdec6564d, 0x5595b355, 0xcc65105d, 0x43346d65, 0xba03ca6d, 0x30d32775,
|
||||
0xa7a2847d, 0x1e71e185, 0x95413e8d, 0x0c109b95, 0x82dff89d, 0xf9af55a5,
|
||||
0x707eb2ad, 0xe74e0fb5, 0x5e1d6cbd, 0xd4ecc9c5, 0x4bbc26cd, 0xc28b83d5},
|
||||
{ 0x84c413be, 0xfb9370c6, 0x7262cdce, 0xe9322ad6, 0x600187de, 0xd6d0e4e6,
|
||||
0x4da041ee, 0xc46f9ef6, 0x3b3efbfe, 0xb20e5906, 0x28ddb60e, 0x9fad1316,
|
||||
0x167c701e, 0x8d4bcd26, 0x041b2a2e, 0x7aea8736, 0xf1b9e43e, 0x68894146,
|
||||
0xdf589e4e, 0x5627fb56, 0xccf7585e, 0x43c6b566, 0xba96126e, 0x31656f76},
|
||||
{ 0xf39dff5f, 0x6a6d5c67, 0xe13cb96f, 0x580c1677, 0xcedb737f, 0x45aad087,
|
||||
0xbc7a2d8f, 0x33498a97, 0xaa18e79f, 0x20e844a7, 0x97b7a1af, 0x0e86feb7,
|
||||
0x85565bbf, 0xfc25b8c7, 0x72f515cf, 0xe9c472d7, 0x6093cfdf, 0xd7632ce7,
|
||||
0x4e3289ef, 0xc501e6f7, 0x3bd143ff, 0xb2a0a107, 0x296ffe0f, 0xa03f5b17},
|
||||
{ 0x6277eb00, 0xd9474808, 0x5016a510, 0xc6e60218, 0x3db55f20, 0xb484bc28,
|
||||
0x2b541930, 0xa2237638, 0x18f2d340, 0x8fc23048, 0x06918d50, 0x7d60ea58,
|
||||
0xf4304760, 0x6affa468, 0xe1cf0170, 0x589e5e78, 0xcf6dbb80, 0x463d1888,
|
||||
0xbd0c7590, 0x33dbd298, 0xaaab2fa0, 0x217a8ca8, 0x9849e9b0, 0x0f1946b8}
|
||||
};
|
||||
|
||||
const unsigned int CAST256::Base::t_r[8][24]={
|
||||
{19, 27, 3, 11, 19, 27, 3, 11, 19, 27, 3, 11, 19, 27, 3, 11, 19, 27, 3, 11, 19, 27, 3, 11},
|
||||
{4, 12, 20, 28, 4, 12, 20, 28, 4, 12, 20, 28, 4, 12, 20, 28, 4, 12, 20, 28, 4, 12, 20, 28},
|
||||
{21, 29, 5, 13, 21, 29, 5, 13, 21, 29, 5, 13, 21, 29, 5, 13, 21, 29, 5, 13, 21, 29, 5, 13},
|
||||
{6, 14, 22, 30, 6, 14, 22, 30, 6, 14, 22, 30, 6, 14, 22, 30, 6, 14, 22, 30, 6, 14, 22, 30},
|
||||
{23, 31, 7, 15, 23, 31, 7, 15, 23, 31, 7, 15, 23, 31, 7, 15, 23, 31, 7, 15, 23, 31, 7, 15},
|
||||
{8, 16, 24, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16, 24, 0, 8, 16, 24, 0},
|
||||
{25, 1, 9, 17, 25, 1, 9, 17, 25, 1, 9, 17, 25, 1, 9, 17, 25, 1, 9, 17, 25, 1, 9, 17},
|
||||
{10, 18, 26, 2, 10, 18, 26, 2, 10, 18, 26, 2, 10, 18, 26, 2, 10, 18, 26, 2, 10, 18, 26, 2}
|
||||
};
|
||||
|
||||
#define Q(i) \
|
||||
F1(block[2],block[3],8*i+4,-4); \
|
||||
F2(block[1],block[2],8*i+5,-4); \
|
||||
F3(block[0],block[1],8*i+6,-4); \
|
||||
F1(block[3],block[0],8*i+7,-4);
|
||||
|
||||
#define QBar(i) \
|
||||
F1(block[3],block[0],8*i+7,-4); \
|
||||
F3(block[0],block[1],8*i+6,-4); \
|
||||
F2(block[1],block[2],8*i+5,-4); \
|
||||
F1(block[2],block[3],8*i+4,-4);
|
||||
|
||||
/* CAST256's encrypt/decrypt functions are identical except for the order that
|
||||
the keys are used */
|
||||
|
||||
void CAST256::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 t, block[4];
|
||||
Block::Get(inBlock)(block[0])(block[1])(block[2])(block[3]);
|
||||
|
||||
// Perform 6 forward quad rounds
|
||||
Q(0);
|
||||
Q(1);
|
||||
Q(2);
|
||||
Q(3);
|
||||
Q(4);
|
||||
Q(5);
|
||||
|
||||
// Perform 6 reverse quad rounds
|
||||
QBar(6);
|
||||
QBar(7);
|
||||
QBar(8);
|
||||
QBar(9);
|
||||
QBar(10);
|
||||
QBar(11);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(block[0])(block[1])(block[2])(block[3]);
|
||||
}
|
||||
|
||||
/* Set up a CAST-256 key */
|
||||
|
||||
void CAST256::Base::Omega(int i, word32 kappa[8])
|
||||
{
|
||||
word32 t;
|
||||
|
||||
f1(kappa[6],kappa[7],t_m[0][i],t_r[0][i]);
|
||||
f2(kappa[5],kappa[6],t_m[1][i],t_r[1][i]);
|
||||
f3(kappa[4],kappa[5],t_m[2][i],t_r[2][i]);
|
||||
f1(kappa[3],kappa[4],t_m[3][i],t_r[3][i]);
|
||||
f2(kappa[2],kappa[3],t_m[4][i],t_r[4][i]);
|
||||
f3(kappa[1],kappa[2],t_m[5][i],t_r[5][i]);
|
||||
f1(kappa[0],kappa[1],t_m[6][i],t_r[6][i]);
|
||||
f2(kappa[7],kappa[0],t_m[7][i],t_r[7][i]);
|
||||
}
|
||||
|
||||
void CAST256::Base::UncheckedSetKey(const byte *userKey, unsigned int keylength, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(keylength);
|
||||
|
||||
word32 kappa[8];
|
||||
GetUserKey(BIG_ENDIAN_ORDER, kappa, 8, userKey, keylength);
|
||||
|
||||
for(int i=0; i<12; ++i)
|
||||
{
|
||||
Omega(2*i,kappa);
|
||||
Omega(2*i+1,kappa);
|
||||
|
||||
K[8*i]=kappa[0] & 31;
|
||||
K[8*i+1]=kappa[2] & 31;
|
||||
K[8*i+2]=kappa[4] & 31;
|
||||
K[8*i+3]=kappa[6] & 31;
|
||||
K[8*i+4]=kappa[7];
|
||||
K[8*i+5]=kappa[5];
|
||||
K[8*i+6]=kappa[3];
|
||||
K[8*i+7]=kappa[1];
|
||||
}
|
||||
|
||||
if (!IsForwardTransformation())
|
||||
{
|
||||
for(int j=0; j<6; ++j)
|
||||
{
|
||||
for(int i=0; i<4; ++i)
|
||||
{
|
||||
int i1=8*j+i;
|
||||
int i2=8*(11-j)+i;
|
||||
|
||||
assert(i1<i2);
|
||||
|
||||
std::swap(K[i1],K[i2]);
|
||||
std::swap(K[i1+4],K[i2+4]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
memset(kappa, 0, sizeof(kappa));
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,91 +0,0 @@
|
||||
#ifndef CRYPTOPP_CAST_H
|
||||
#define CRYPTOPP_CAST_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
class CAST
|
||||
{
|
||||
protected:
|
||||
static const word32 S[8][256];
|
||||
};
|
||||
|
||||
//! algorithm info
|
||||
struct CAST128_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 5, 16>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "CAST-128";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#CAST-128">CAST-128</a>
|
||||
class CAST128 : public CAST128_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl<CAST128_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
bool reduced;
|
||||
FixedSizeSecBlock<word32, 32> K;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
//! algorithm info
|
||||
struct CAST256_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "CAST-256";}
|
||||
};
|
||||
|
||||
//! <a href="http://www.weidai.com/scan-mirror/cs.html#CAST-256">CAST-256</a>
|
||||
class CAST256 : public CAST256_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl<CAST256_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
|
||||
protected:
|
||||
static const word32 t_m[8][24];
|
||||
static const unsigned int t_r[8][24];
|
||||
|
||||
static void Omega(int i, word32 kappa[8]);
|
||||
|
||||
FixedSizeSecBlock<word32, 8*12> K;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
|
||||
};
|
||||
|
||||
typedef CAST128::Encryption CAST128Encryption;
|
||||
typedef CAST128::Decryption CAST128Decryption;
|
||||
|
||||
typedef CAST256::Encryption CAST256Encryption;
|
||||
typedef CAST256::Decryption CAST256Decryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,545 +0,0 @@
|
||||
#include "pch.h"
|
||||
#include "cast.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
// CAST S-boxes
|
||||
|
||||
const word32 CAST::S[8][256] = {
|
||||
{
|
||||
0x30FB40D4UL, 0x9FA0FF0BUL, 0x6BECCD2FUL, 0x3F258C7AUL,
|
||||
0x1E213F2FUL, 0x9C004DD3UL, 0x6003E540UL, 0xCF9FC949UL,
|
||||
0xBFD4AF27UL, 0x88BBBDB5UL, 0xE2034090UL, 0x98D09675UL,
|
||||
0x6E63A0E0UL, 0x15C361D2UL, 0xC2E7661DUL, 0x22D4FF8EUL,
|
||||
0x28683B6FUL, 0xC07FD059UL, 0xFF2379C8UL, 0x775F50E2UL,
|
||||
0x43C340D3UL, 0xDF2F8656UL, 0x887CA41AUL, 0xA2D2BD2DUL,
|
||||
0xA1C9E0D6UL, 0x346C4819UL, 0x61B76D87UL, 0x22540F2FUL,
|
||||
0x2ABE32E1UL, 0xAA54166BUL, 0x22568E3AUL, 0xA2D341D0UL,
|
||||
0x66DB40C8UL, 0xA784392FUL, 0x004DFF2FUL, 0x2DB9D2DEUL,
|
||||
0x97943FACUL, 0x4A97C1D8UL, 0x527644B7UL, 0xB5F437A7UL,
|
||||
0xB82CBAEFUL, 0xD751D159UL, 0x6FF7F0EDUL, 0x5A097A1FUL,
|
||||
0x827B68D0UL, 0x90ECF52EUL, 0x22B0C054UL, 0xBC8E5935UL,
|
||||
0x4B6D2F7FUL, 0x50BB64A2UL, 0xD2664910UL, 0xBEE5812DUL,
|
||||
0xB7332290UL, 0xE93B159FUL, 0xB48EE411UL, 0x4BFF345DUL,
|
||||
0xFD45C240UL, 0xAD31973FUL, 0xC4F6D02EUL, 0x55FC8165UL,
|
||||
0xD5B1CAADUL, 0xA1AC2DAEUL, 0xA2D4B76DUL, 0xC19B0C50UL,
|
||||
0x882240F2UL, 0x0C6E4F38UL, 0xA4E4BFD7UL, 0x4F5BA272UL,
|
||||
0x564C1D2FUL, 0xC59C5319UL, 0xB949E354UL, 0xB04669FEUL,
|
||||
0xB1B6AB8AUL, 0xC71358DDUL, 0x6385C545UL, 0x110F935DUL,
|
||||
0x57538AD5UL, 0x6A390493UL, 0xE63D37E0UL, 0x2A54F6B3UL,
|
||||
0x3A787D5FUL, 0x6276A0B5UL, 0x19A6FCDFUL, 0x7A42206AUL,
|
||||
0x29F9D4D5UL, 0xF61B1891UL, 0xBB72275EUL, 0xAA508167UL,
|
||||
0x38901091UL, 0xC6B505EBUL, 0x84C7CB8CUL, 0x2AD75A0FUL,
|
||||
0x874A1427UL, 0xA2D1936BUL, 0x2AD286AFUL, 0xAA56D291UL,
|
||||
0xD7894360UL, 0x425C750DUL, 0x93B39E26UL, 0x187184C9UL,
|
||||
0x6C00B32DUL, 0x73E2BB14UL, 0xA0BEBC3CUL, 0x54623779UL,
|
||||
0x64459EABUL, 0x3F328B82UL, 0x7718CF82UL, 0x59A2CEA6UL,
|
||||
0x04EE002EUL, 0x89FE78E6UL, 0x3FAB0950UL, 0x325FF6C2UL,
|
||||
0x81383F05UL, 0x6963C5C8UL, 0x76CB5AD6UL, 0xD49974C9UL,
|
||||
0xCA180DCFUL, 0x380782D5UL, 0xC7FA5CF6UL, 0x8AC31511UL,
|
||||
0x35E79E13UL, 0x47DA91D0UL, 0xF40F9086UL, 0xA7E2419EUL,
|
||||
0x31366241UL, 0x051EF495UL, 0xAA573B04UL, 0x4A805D8DUL,
|
||||
0x548300D0UL, 0x00322A3CUL, 0xBF64CDDFUL, 0xBA57A68EUL,
|
||||
0x75C6372BUL, 0x50AFD341UL, 0xA7C13275UL, 0x915A0BF5UL,
|
||||
0x6B54BFABUL, 0x2B0B1426UL, 0xAB4CC9D7UL, 0x449CCD82UL,
|
||||
0xF7FBF265UL, 0xAB85C5F3UL, 0x1B55DB94UL, 0xAAD4E324UL,
|
||||
0xCFA4BD3FUL, 0x2DEAA3E2UL, 0x9E204D02UL, 0xC8BD25ACUL,
|
||||
0xEADF55B3UL, 0xD5BD9E98UL, 0xE31231B2UL, 0x2AD5AD6CUL,
|
||||
0x954329DEUL, 0xADBE4528UL, 0xD8710F69UL, 0xAA51C90FUL,
|
||||
0xAA786BF6UL, 0x22513F1EUL, 0xAA51A79BUL, 0x2AD344CCUL,
|
||||
0x7B5A41F0UL, 0xD37CFBADUL, 0x1B069505UL, 0x41ECE491UL,
|
||||
0xB4C332E6UL, 0x032268D4UL, 0xC9600ACCUL, 0xCE387E6DUL,
|
||||
0xBF6BB16CUL, 0x6A70FB78UL, 0x0D03D9C9UL, 0xD4DF39DEUL,
|
||||
0xE01063DAUL, 0x4736F464UL, 0x5AD328D8UL, 0xB347CC96UL,
|
||||
0x75BB0FC3UL, 0x98511BFBUL, 0x4FFBCC35UL, 0xB58BCF6AUL,
|
||||
0xE11F0ABCUL, 0xBFC5FE4AUL, 0xA70AEC10UL, 0xAC39570AUL,
|
||||
0x3F04442FUL, 0x6188B153UL, 0xE0397A2EUL, 0x5727CB79UL,
|
||||
0x9CEB418FUL, 0x1CACD68DUL, 0x2AD37C96UL, 0x0175CB9DUL,
|
||||
0xC69DFF09UL, 0xC75B65F0UL, 0xD9DB40D8UL, 0xEC0E7779UL,
|
||||
0x4744EAD4UL, 0xB11C3274UL, 0xDD24CB9EUL, 0x7E1C54BDUL,
|
||||
0xF01144F9UL, 0xD2240EB1UL, 0x9675B3FDUL, 0xA3AC3755UL,
|
||||
0xD47C27AFUL, 0x51C85F4DUL, 0x56907596UL, 0xA5BB15E6UL,
|
||||
0x580304F0UL, 0xCA042CF1UL, 0x011A37EAUL, 0x8DBFAADBUL,
|
||||
0x35BA3E4AUL, 0x3526FFA0UL, 0xC37B4D09UL, 0xBC306ED9UL,
|
||||
0x98A52666UL, 0x5648F725UL, 0xFF5E569DUL, 0x0CED63D0UL,
|
||||
0x7C63B2CFUL, 0x700B45E1UL, 0xD5EA50F1UL, 0x85A92872UL,
|
||||
0xAF1FBDA7UL, 0xD4234870UL, 0xA7870BF3UL, 0x2D3B4D79UL,
|
||||
0x42E04198UL, 0x0CD0EDE7UL, 0x26470DB8UL, 0xF881814CUL,
|
||||
0x474D6AD7UL, 0x7C0C5E5CUL, 0xD1231959UL, 0x381B7298UL,
|
||||
0xF5D2F4DBUL, 0xAB838653UL, 0x6E2F1E23UL, 0x83719C9EUL,
|
||||
0xBD91E046UL, 0x9A56456EUL, 0xDC39200CUL, 0x20C8C571UL,
|
||||
0x962BDA1CUL, 0xE1E696FFUL, 0xB141AB08UL, 0x7CCA89B9UL,
|
||||
0x1A69E783UL, 0x02CC4843UL, 0xA2F7C579UL, 0x429EF47DUL,
|
||||
0x427B169CUL, 0x5AC9F049UL, 0xDD8F0F00UL, 0x5C8165BFUL
|
||||
},
|
||||
|
||||
{
|
||||
0x1F201094UL, 0xEF0BA75BUL, 0x69E3CF7EUL, 0x393F4380UL,
|
||||
0xFE61CF7AUL, 0xEEC5207AUL, 0x55889C94UL, 0x72FC0651UL,
|
||||
0xADA7EF79UL, 0x4E1D7235UL, 0xD55A63CEUL, 0xDE0436BAUL,
|
||||
0x99C430EFUL, 0x5F0C0794UL, 0x18DCDB7DUL, 0xA1D6EFF3UL,
|
||||
0xA0B52F7BUL, 0x59E83605UL, 0xEE15B094UL, 0xE9FFD909UL,
|
||||
0xDC440086UL, 0xEF944459UL, 0xBA83CCB3UL, 0xE0C3CDFBUL,
|
||||
0xD1DA4181UL, 0x3B092AB1UL, 0xF997F1C1UL, 0xA5E6CF7BUL,
|
||||
0x01420DDBUL, 0xE4E7EF5BUL, 0x25A1FF41UL, 0xE180F806UL,
|
||||
0x1FC41080UL, 0x179BEE7AUL, 0xD37AC6A9UL, 0xFE5830A4UL,
|
||||
0x98DE8B7FUL, 0x77E83F4EUL, 0x79929269UL, 0x24FA9F7BUL,
|
||||
0xE113C85BUL, 0xACC40083UL, 0xD7503525UL, 0xF7EA615FUL,
|
||||
0x62143154UL, 0x0D554B63UL, 0x5D681121UL, 0xC866C359UL,
|
||||
0x3D63CF73UL, 0xCEE234C0UL, 0xD4D87E87UL, 0x5C672B21UL,
|
||||
0x071F6181UL, 0x39F7627FUL, 0x361E3084UL, 0xE4EB573BUL,
|
||||
0x602F64A4UL, 0xD63ACD9CUL, 0x1BBC4635UL, 0x9E81032DUL,
|
||||
0x2701F50CUL, 0x99847AB4UL, 0xA0E3DF79UL, 0xBA6CF38CUL,
|
||||
0x10843094UL, 0x2537A95EUL, 0xF46F6FFEUL, 0xA1FF3B1FUL,
|
||||
0x208CFB6AUL, 0x8F458C74UL, 0xD9E0A227UL, 0x4EC73A34UL,
|
||||
0xFC884F69UL, 0x3E4DE8DFUL, 0xEF0E0088UL, 0x3559648DUL,
|
||||
0x8A45388CUL, 0x1D804366UL, 0x721D9BFDUL, 0xA58684BBUL,
|
||||
0xE8256333UL, 0x844E8212UL, 0x128D8098UL, 0xFED33FB4UL,
|
||||
0xCE280AE1UL, 0x27E19BA5UL, 0xD5A6C252UL, 0xE49754BDUL,
|
||||
0xC5D655DDUL, 0xEB667064UL, 0x77840B4DUL, 0xA1B6A801UL,
|
||||
0x84DB26A9UL, 0xE0B56714UL, 0x21F043B7UL, 0xE5D05860UL,
|
||||
0x54F03084UL, 0x066FF472UL, 0xA31AA153UL, 0xDADC4755UL,
|
||||
0xB5625DBFUL, 0x68561BE6UL, 0x83CA6B94UL, 0x2D6ED23BUL,
|
||||
0xECCF01DBUL, 0xA6D3D0BAUL, 0xB6803D5CUL, 0xAF77A709UL,
|
||||
0x33B4A34CUL, 0x397BC8D6UL, 0x5EE22B95UL, 0x5F0E5304UL,
|
||||
0x81ED6F61UL, 0x20E74364UL, 0xB45E1378UL, 0xDE18639BUL,
|
||||
0x881CA122UL, 0xB96726D1UL, 0x8049A7E8UL, 0x22B7DA7BUL,
|
||||
0x5E552D25UL, 0x5272D237UL, 0x79D2951CUL, 0xC60D894CUL,
|
||||
0x488CB402UL, 0x1BA4FE5BUL, 0xA4B09F6BUL, 0x1CA815CFUL,
|
||||
0xA20C3005UL, 0x8871DF63UL, 0xB9DE2FCBUL, 0x0CC6C9E9UL,
|
||||
0x0BEEFF53UL, 0xE3214517UL, 0xB4542835UL, 0x9F63293CUL,
|
||||
0xEE41E729UL, 0x6E1D2D7CUL, 0x50045286UL, 0x1E6685F3UL,
|
||||
0xF33401C6UL, 0x30A22C95UL, 0x31A70850UL, 0x60930F13UL,
|
||||
0x73F98417UL, 0xA1269859UL, 0xEC645C44UL, 0x52C877A9UL,
|
||||
0xCDFF33A6UL, 0xA02B1741UL, 0x7CBAD9A2UL, 0x2180036FUL,
|
||||
0x50D99C08UL, 0xCB3F4861UL, 0xC26BD765UL, 0x64A3F6ABUL,
|
||||
0x80342676UL, 0x25A75E7BUL, 0xE4E6D1FCUL, 0x20C710E6UL,
|
||||
0xCDF0B680UL, 0x17844D3BUL, 0x31EEF84DUL, 0x7E0824E4UL,
|
||||
0x2CCB49EBUL, 0x846A3BAEUL, 0x8FF77888UL, 0xEE5D60F6UL,
|
||||
0x7AF75673UL, 0x2FDD5CDBUL, 0xA11631C1UL, 0x30F66F43UL,
|
||||
0xB3FAEC54UL, 0x157FD7FAUL, 0xEF8579CCUL, 0xD152DE58UL,
|
||||
0xDB2FFD5EUL, 0x8F32CE19UL, 0x306AF97AUL, 0x02F03EF8UL,
|
||||
0x99319AD5UL, 0xC242FA0FUL, 0xA7E3EBB0UL, 0xC68E4906UL,
|
||||
0xB8DA230CUL, 0x80823028UL, 0xDCDEF3C8UL, 0xD35FB171UL,
|
||||
0x088A1BC8UL, 0xBEC0C560UL, 0x61A3C9E8UL, 0xBCA8F54DUL,
|
||||
0xC72FEFFAUL, 0x22822E99UL, 0x82C570B4UL, 0xD8D94E89UL,
|
||||
0x8B1C34BCUL, 0x301E16E6UL, 0x273BE979UL, 0xB0FFEAA6UL,
|
||||
0x61D9B8C6UL, 0x00B24869UL, 0xB7FFCE3FUL, 0x08DC283BUL,
|
||||
0x43DAF65AUL, 0xF7E19798UL, 0x7619B72FUL, 0x8F1C9BA4UL,
|
||||
0xDC8637A0UL, 0x16A7D3B1UL, 0x9FC393B7UL, 0xA7136EEBUL,
|
||||
0xC6BCC63EUL, 0x1A513742UL, 0xEF6828BCUL, 0x520365D6UL,
|
||||
0x2D6A77ABUL, 0x3527ED4BUL, 0x821FD216UL, 0x095C6E2EUL,
|
||||
0xDB92F2FBUL, 0x5EEA29CBUL, 0x145892F5UL, 0x91584F7FUL,
|
||||
0x5483697BUL, 0x2667A8CCUL, 0x85196048UL, 0x8C4BACEAUL,
|
||||
0x833860D4UL, 0x0D23E0F9UL, 0x6C387E8AUL, 0x0AE6D249UL,
|
||||
0xB284600CUL, 0xD835731DUL, 0xDCB1C647UL, 0xAC4C56EAUL,
|
||||
0x3EBD81B3UL, 0x230EABB0UL, 0x6438BC87UL, 0xF0B5B1FAUL,
|
||||
0x8F5EA2B3UL, 0xFC184642UL, 0x0A036B7AUL, 0x4FB089BDUL,
|
||||
0x649DA589UL, 0xA345415EUL, 0x5C038323UL, 0x3E5D3BB9UL,
|
||||
0x43D79572UL, 0x7E6DD07CUL, 0x06DFDF1EUL, 0x6C6CC4EFUL,
|
||||
0x7160A539UL, 0x73BFBE70UL, 0x83877605UL, 0x4523ECF1UL
|
||||
},
|
||||
|
||||
{
|
||||
0x8DEFC240UL, 0x25FA5D9FUL, 0xEB903DBFUL, 0xE810C907UL,
|
||||
0x47607FFFUL, 0x369FE44BUL, 0x8C1FC644UL, 0xAECECA90UL,
|
||||
0xBEB1F9BFUL, 0xEEFBCAEAUL, 0xE8CF1950UL, 0x51DF07AEUL,
|
||||
0x920E8806UL, 0xF0AD0548UL, 0xE13C8D83UL, 0x927010D5UL,
|
||||
0x11107D9FUL, 0x07647DB9UL, 0xB2E3E4D4UL, 0x3D4F285EUL,
|
||||
0xB9AFA820UL, 0xFADE82E0UL, 0xA067268BUL, 0x8272792EUL,
|
||||
0x553FB2C0UL, 0x489AE22BUL, 0xD4EF9794UL, 0x125E3FBCUL,
|
||||
0x21FFFCEEUL, 0x825B1BFDUL, 0x9255C5EDUL, 0x1257A240UL,
|
||||
0x4E1A8302UL, 0xBAE07FFFUL, 0x528246E7UL, 0x8E57140EUL,
|
||||
0x3373F7BFUL, 0x8C9F8188UL, 0xA6FC4EE8UL, 0xC982B5A5UL,
|
||||
0xA8C01DB7UL, 0x579FC264UL, 0x67094F31UL, 0xF2BD3F5FUL,
|
||||
0x40FFF7C1UL, 0x1FB78DFCUL, 0x8E6BD2C1UL, 0x437BE59BUL,
|
||||
0x99B03DBFUL, 0xB5DBC64BUL, 0x638DC0E6UL, 0x55819D99UL,
|
||||
0xA197C81CUL, 0x4A012D6EUL, 0xC5884A28UL, 0xCCC36F71UL,
|
||||
0xB843C213UL, 0x6C0743F1UL, 0x8309893CUL, 0x0FEDDD5FUL,
|
||||
0x2F7FE850UL, 0xD7C07F7EUL, 0x02507FBFUL, 0x5AFB9A04UL,
|
||||
0xA747D2D0UL, 0x1651192EUL, 0xAF70BF3EUL, 0x58C31380UL,
|
||||
0x5F98302EUL, 0x727CC3C4UL, 0x0A0FB402UL, 0x0F7FEF82UL,
|
||||
0x8C96FDADUL, 0x5D2C2AAEUL, 0x8EE99A49UL, 0x50DA88B8UL,
|
||||
0x8427F4A0UL, 0x1EAC5790UL, 0x796FB449UL, 0x8252DC15UL,
|
||||
0xEFBD7D9BUL, 0xA672597DUL, 0xADA840D8UL, 0x45F54504UL,
|
||||
0xFA5D7403UL, 0xE83EC305UL, 0x4F91751AUL, 0x925669C2UL,
|
||||
0x23EFE941UL, 0xA903F12EUL, 0x60270DF2UL, 0x0276E4B6UL,
|
||||
0x94FD6574UL, 0x927985B2UL, 0x8276DBCBUL, 0x02778176UL,
|
||||
0xF8AF918DUL, 0x4E48F79EUL, 0x8F616DDFUL, 0xE29D840EUL,
|
||||
0x842F7D83UL, 0x340CE5C8UL, 0x96BBB682UL, 0x93B4B148UL,
|
||||
0xEF303CABUL, 0x984FAF28UL, 0x779FAF9BUL, 0x92DC560DUL,
|
||||
0x224D1E20UL, 0x8437AA88UL, 0x7D29DC96UL, 0x2756D3DCUL,
|
||||
0x8B907CEEUL, 0xB51FD240UL, 0xE7C07CE3UL, 0xE566B4A1UL,
|
||||
0xC3E9615EUL, 0x3CF8209DUL, 0x6094D1E3UL, 0xCD9CA341UL,
|
||||
0x5C76460EUL, 0x00EA983BUL, 0xD4D67881UL, 0xFD47572CUL,
|
||||
0xF76CEDD9UL, 0xBDA8229CUL, 0x127DADAAUL, 0x438A074EUL,
|
||||
0x1F97C090UL, 0x081BDB8AUL, 0x93A07EBEUL, 0xB938CA15UL,
|
||||
0x97B03CFFUL, 0x3DC2C0F8UL, 0x8D1AB2ECUL, 0x64380E51UL,
|
||||
0x68CC7BFBUL, 0xD90F2788UL, 0x12490181UL, 0x5DE5FFD4UL,
|
||||
0xDD7EF86AUL, 0x76A2E214UL, 0xB9A40368UL, 0x925D958FUL,
|
||||
0x4B39FFFAUL, 0xBA39AEE9UL, 0xA4FFD30BUL, 0xFAF7933BUL,
|
||||
0x6D498623UL, 0x193CBCFAUL, 0x27627545UL, 0x825CF47AUL,
|
||||
0x61BD8BA0UL, 0xD11E42D1UL, 0xCEAD04F4UL, 0x127EA392UL,
|
||||
0x10428DB7UL, 0x8272A972UL, 0x9270C4A8UL, 0x127DE50BUL,
|
||||
0x285BA1C8UL, 0x3C62F44FUL, 0x35C0EAA5UL, 0xE805D231UL,
|
||||
0x428929FBUL, 0xB4FCDF82UL, 0x4FB66A53UL, 0x0E7DC15BUL,
|
||||
0x1F081FABUL, 0x108618AEUL, 0xFCFD086DUL, 0xF9FF2889UL,
|
||||
0x694BCC11UL, 0x236A5CAEUL, 0x12DECA4DUL, 0x2C3F8CC5UL,
|
||||
0xD2D02DFEUL, 0xF8EF5896UL, 0xE4CF52DAUL, 0x95155B67UL,
|
||||
0x494A488CUL, 0xB9B6A80CUL, 0x5C8F82BCUL, 0x89D36B45UL,
|
||||
0x3A609437UL, 0xEC00C9A9UL, 0x44715253UL, 0x0A874B49UL,
|
||||
0xD773BC40UL, 0x7C34671CUL, 0x02717EF6UL, 0x4FEB5536UL,
|
||||
0xA2D02FFFUL, 0xD2BF60C4UL, 0xD43F03C0UL, 0x50B4EF6DUL,
|
||||
0x07478CD1UL, 0x006E1888UL, 0xA2E53F55UL, 0xB9E6D4BCUL,
|
||||
0xA2048016UL, 0x97573833UL, 0xD7207D67UL, 0xDE0F8F3DUL,
|
||||
0x72F87B33UL, 0xABCC4F33UL, 0x7688C55DUL, 0x7B00A6B0UL,
|
||||
0x947B0001UL, 0x570075D2UL, 0xF9BB88F8UL, 0x8942019EUL,
|
||||
0x4264A5FFUL, 0x856302E0UL, 0x72DBD92BUL, 0xEE971B69UL,
|
||||
0x6EA22FDEUL, 0x5F08AE2BUL, 0xAF7A616DUL, 0xE5C98767UL,
|
||||
0xCF1FEBD2UL, 0x61EFC8C2UL, 0xF1AC2571UL, 0xCC8239C2UL,
|
||||
0x67214CB8UL, 0xB1E583D1UL, 0xB7DC3E62UL, 0x7F10BDCEUL,
|
||||
0xF90A5C38UL, 0x0FF0443DUL, 0x606E6DC6UL, 0x60543A49UL,
|
||||
0x5727C148UL, 0x2BE98A1DUL, 0x8AB41738UL, 0x20E1BE24UL,
|
||||
0xAF96DA0FUL, 0x68458425UL, 0x99833BE5UL, 0x600D457DUL,
|
||||
0x282F9350UL, 0x8334B362UL, 0xD91D1120UL, 0x2B6D8DA0UL,
|
||||
0x642B1E31UL, 0x9C305A00UL, 0x52BCE688UL, 0x1B03588AUL,
|
||||
0xF7BAEFD5UL, 0x4142ED9CUL, 0xA4315C11UL, 0x83323EC5UL,
|
||||
0xDFEF4636UL, 0xA133C501UL, 0xE9D3531CUL, 0xEE353783UL
|
||||
},
|
||||
|
||||
{
|
||||
0x9DB30420UL, 0x1FB6E9DEUL, 0xA7BE7BEFUL, 0xD273A298UL,
|
||||
0x4A4F7BDBUL, 0x64AD8C57UL, 0x85510443UL, 0xFA020ED1UL,
|
||||
0x7E287AFFUL, 0xE60FB663UL, 0x095F35A1UL, 0x79EBF120UL,
|
||||
0xFD059D43UL, 0x6497B7B1UL, 0xF3641F63UL, 0x241E4ADFUL,
|
||||
0x28147F5FUL, 0x4FA2B8CDUL, 0xC9430040UL, 0x0CC32220UL,
|
||||
0xFDD30B30UL, 0xC0A5374FUL, 0x1D2D00D9UL, 0x24147B15UL,
|
||||
0xEE4D111AUL, 0x0FCA5167UL, 0x71FF904CUL, 0x2D195FFEUL,
|
||||
0x1A05645FUL, 0x0C13FEFEUL, 0x081B08CAUL, 0x05170121UL,
|
||||
0x80530100UL, 0xE83E5EFEUL, 0xAC9AF4F8UL, 0x7FE72701UL,
|
||||
0xD2B8EE5FUL, 0x06DF4261UL, 0xBB9E9B8AUL, 0x7293EA25UL,
|
||||
0xCE84FFDFUL, 0xF5718801UL, 0x3DD64B04UL, 0xA26F263BUL,
|
||||
0x7ED48400UL, 0x547EEBE6UL, 0x446D4CA0UL, 0x6CF3D6F5UL,
|
||||
0x2649ABDFUL, 0xAEA0C7F5UL, 0x36338CC1UL, 0x503F7E93UL,
|
||||
0xD3772061UL, 0x11B638E1UL, 0x72500E03UL, 0xF80EB2BBUL,
|
||||
0xABE0502EUL, 0xEC8D77DEUL, 0x57971E81UL, 0xE14F6746UL,
|
||||
0xC9335400UL, 0x6920318FUL, 0x081DBB99UL, 0xFFC304A5UL,
|
||||
0x4D351805UL, 0x7F3D5CE3UL, 0xA6C866C6UL, 0x5D5BCCA9UL,
|
||||
0xDAEC6FEAUL, 0x9F926F91UL, 0x9F46222FUL, 0x3991467DUL,
|
||||
0xA5BF6D8EUL, 0x1143C44FUL, 0x43958302UL, 0xD0214EEBUL,
|
||||
0x022083B8UL, 0x3FB6180CUL, 0x18F8931EUL, 0x281658E6UL,
|
||||
0x26486E3EUL, 0x8BD78A70UL, 0x7477E4C1UL, 0xB506E07CUL,
|
||||
0xF32D0A25UL, 0x79098B02UL, 0xE4EABB81UL, 0x28123B23UL,
|
||||
0x69DEAD38UL, 0x1574CA16UL, 0xDF871B62UL, 0x211C40B7UL,
|
||||
0xA51A9EF9UL, 0x0014377BUL, 0x041E8AC8UL, 0x09114003UL,
|
||||
0xBD59E4D2UL, 0xE3D156D5UL, 0x4FE876D5UL, 0x2F91A340UL,
|
||||
0x557BE8DEUL, 0x00EAE4A7UL, 0x0CE5C2ECUL, 0x4DB4BBA6UL,
|
||||
0xE756BDFFUL, 0xDD3369ACUL, 0xEC17B035UL, 0x06572327UL,
|
||||
0x99AFC8B0UL, 0x56C8C391UL, 0x6B65811CUL, 0x5E146119UL,
|
||||
0x6E85CB75UL, 0xBE07C002UL, 0xC2325577UL, 0x893FF4ECUL,
|
||||
0x5BBFC92DUL, 0xD0EC3B25UL, 0xB7801AB7UL, 0x8D6D3B24UL,
|
||||
0x20C763EFUL, 0xC366A5FCUL, 0x9C382880UL, 0x0ACE3205UL,
|
||||
0xAAC9548AUL, 0xECA1D7C7UL, 0x041AFA32UL, 0x1D16625AUL,
|
||||
0x6701902CUL, 0x9B757A54UL, 0x31D477F7UL, 0x9126B031UL,
|
||||
0x36CC6FDBUL, 0xC70B8B46UL, 0xD9E66A48UL, 0x56E55A79UL,
|
||||
0x026A4CEBUL, 0x52437EFFUL, 0x2F8F76B4UL, 0x0DF980A5UL,
|
||||
0x8674CDE3UL, 0xEDDA04EBUL, 0x17A9BE04UL, 0x2C18F4DFUL,
|
||||
0xB7747F9DUL, 0xAB2AF7B4UL, 0xEFC34D20UL, 0x2E096B7CUL,
|
||||
0x1741A254UL, 0xE5B6A035UL, 0x213D42F6UL, 0x2C1C7C26UL,
|
||||
0x61C2F50FUL, 0x6552DAF9UL, 0xD2C231F8UL, 0x25130F69UL,
|
||||
0xD8167FA2UL, 0x0418F2C8UL, 0x001A96A6UL, 0x0D1526ABUL,
|
||||
0x63315C21UL, 0x5E0A72ECUL, 0x49BAFEFDUL, 0x187908D9UL,
|
||||
0x8D0DBD86UL, 0x311170A7UL, 0x3E9B640CUL, 0xCC3E10D7UL,
|
||||
0xD5CAD3B6UL, 0x0CAEC388UL, 0xF73001E1UL, 0x6C728AFFUL,
|
||||
0x71EAE2A1UL, 0x1F9AF36EUL, 0xCFCBD12FUL, 0xC1DE8417UL,
|
||||
0xAC07BE6BUL, 0xCB44A1D8UL, 0x8B9B0F56UL, 0x013988C3UL,
|
||||
0xB1C52FCAUL, 0xB4BE31CDUL, 0xD8782806UL, 0x12A3A4E2UL,
|
||||
0x6F7DE532UL, 0x58FD7EB6UL, 0xD01EE900UL, 0x24ADFFC2UL,
|
||||
0xF4990FC5UL, 0x9711AAC5UL, 0x001D7B95UL, 0x82E5E7D2UL,
|
||||
0x109873F6UL, 0x00613096UL, 0xC32D9521UL, 0xADA121FFUL,
|
||||
0x29908415UL, 0x7FBB977FUL, 0xAF9EB3DBUL, 0x29C9ED2AUL,
|
||||
0x5CE2A465UL, 0xA730F32CUL, 0xD0AA3FE8UL, 0x8A5CC091UL,
|
||||
0xD49E2CE7UL, 0x0CE454A9UL, 0xD60ACD86UL, 0x015F1919UL,
|
||||
0x77079103UL, 0xDEA03AF6UL, 0x78A8565EUL, 0xDEE356DFUL,
|
||||
0x21F05CBEUL, 0x8B75E387UL, 0xB3C50651UL, 0xB8A5C3EFUL,
|
||||
0xD8EEB6D2UL, 0xE523BE77UL, 0xC2154529UL, 0x2F69EFDFUL,
|
||||
0xAFE67AFBUL, 0xF470C4B2UL, 0xF3E0EB5BUL, 0xD6CC9876UL,
|
||||
0x39E4460CUL, 0x1FDA8538UL, 0x1987832FUL, 0xCA007367UL,
|
||||
0xA99144F8UL, 0x296B299EUL, 0x492FC295UL, 0x9266BEABUL,
|
||||
0xB5676E69UL, 0x9BD3DDDAUL, 0xDF7E052FUL, 0xDB25701CUL,
|
||||
0x1B5E51EEUL, 0xF65324E6UL, 0x6AFCE36CUL, 0x0316CC04UL,
|
||||
0x8644213EUL, 0xB7DC59D0UL, 0x7965291FUL, 0xCCD6FD43UL,
|
||||
0x41823979UL, 0x932BCDF6UL, 0xB657C34DUL, 0x4EDFD282UL,
|
||||
0x7AE5290CUL, 0x3CB9536BUL, 0x851E20FEUL, 0x9833557EUL,
|
||||
0x13ECF0B0UL, 0xD3FFB372UL, 0x3F85C5C1UL, 0x0AEF7ED2UL
|
||||
},
|
||||
|
||||
{
|
||||
0x7EC90C04UL, 0x2C6E74B9UL, 0x9B0E66DFUL, 0xA6337911UL,
|
||||
0xB86A7FFFUL, 0x1DD358F5UL, 0x44DD9D44UL, 0x1731167FUL,
|
||||
0x08FBF1FAUL, 0xE7F511CCUL, 0xD2051B00UL, 0x735ABA00UL,
|
||||
0x2AB722D8UL, 0x386381CBUL, 0xACF6243AUL, 0x69BEFD7AUL,
|
||||
0xE6A2E77FUL, 0xF0C720CDUL, 0xC4494816UL, 0xCCF5C180UL,
|
||||
0x38851640UL, 0x15B0A848UL, 0xE68B18CBUL, 0x4CAADEFFUL,
|
||||
0x5F480A01UL, 0x0412B2AAUL, 0x259814FCUL, 0x41D0EFE2UL,
|
||||
0x4E40B48DUL, 0x248EB6FBUL, 0x8DBA1CFEUL, 0x41A99B02UL,
|
||||
0x1A550A04UL, 0xBA8F65CBUL, 0x7251F4E7UL, 0x95A51725UL,
|
||||
0xC106ECD7UL, 0x97A5980AUL, 0xC539B9AAUL, 0x4D79FE6AUL,
|
||||
0xF2F3F763UL, 0x68AF8040UL, 0xED0C9E56UL, 0x11B4958BUL,
|
||||
0xE1EB5A88UL, 0x8709E6B0UL, 0xD7E07156UL, 0x4E29FEA7UL,
|
||||
0x6366E52DUL, 0x02D1C000UL, 0xC4AC8E05UL, 0x9377F571UL,
|
||||
0x0C05372AUL, 0x578535F2UL, 0x2261BE02UL, 0xD642A0C9UL,
|
||||
0xDF13A280UL, 0x74B55BD2UL, 0x682199C0UL, 0xD421E5ECUL,
|
||||
0x53FB3CE8UL, 0xC8ADEDB3UL, 0x28A87FC9UL, 0x3D959981UL,
|
||||
0x5C1FF900UL, 0xFE38D399UL, 0x0C4EFF0BUL, 0x062407EAUL,
|
||||
0xAA2F4FB1UL, 0x4FB96976UL, 0x90C79505UL, 0xB0A8A774UL,
|
||||
0xEF55A1FFUL, 0xE59CA2C2UL, 0xA6B62D27UL, 0xE66A4263UL,
|
||||
0xDF65001FUL, 0x0EC50966UL, 0xDFDD55BCUL, 0x29DE0655UL,
|
||||
0x911E739AUL, 0x17AF8975UL, 0x32C7911CUL, 0x89F89468UL,
|
||||
0x0D01E980UL, 0x524755F4UL, 0x03B63CC9UL, 0x0CC844B2UL,
|
||||
0xBCF3F0AAUL, 0x87AC36E9UL, 0xE53A7426UL, 0x01B3D82BUL,
|
||||
0x1A9E7449UL, 0x64EE2D7EUL, 0xCDDBB1DAUL, 0x01C94910UL,
|
||||
0xB868BF80UL, 0x0D26F3FDUL, 0x9342EDE7UL, 0x04A5C284UL,
|
||||
0x636737B6UL, 0x50F5B616UL, 0xF24766E3UL, 0x8ECA36C1UL,
|
||||
0x136E05DBUL, 0xFEF18391UL, 0xFB887A37UL, 0xD6E7F7D4UL,
|
||||
0xC7FB7DC9UL, 0x3063FCDFUL, 0xB6F589DEUL, 0xEC2941DAUL,
|
||||
0x26E46695UL, 0xB7566419UL, 0xF654EFC5UL, 0xD08D58B7UL,
|
||||
0x48925401UL, 0xC1BACB7FUL, 0xE5FF550FUL, 0xB6083049UL,
|
||||
0x5BB5D0E8UL, 0x87D72E5AUL, 0xAB6A6EE1UL, 0x223A66CEUL,
|
||||
0xC62BF3CDUL, 0x9E0885F9UL, 0x68CB3E47UL, 0x086C010FUL,
|
||||
0xA21DE820UL, 0xD18B69DEUL, 0xF3F65777UL, 0xFA02C3F6UL,
|
||||
0x407EDAC3UL, 0xCBB3D550UL, 0x1793084DUL, 0xB0D70EBAUL,
|
||||
0x0AB378D5UL, 0xD951FB0CUL, 0xDED7DA56UL, 0x4124BBE4UL,
|
||||
0x94CA0B56UL, 0x0F5755D1UL, 0xE0E1E56EUL, 0x6184B5BEUL,
|
||||
0x580A249FUL, 0x94F74BC0UL, 0xE327888EUL, 0x9F7B5561UL,
|
||||
0xC3DC0280UL, 0x05687715UL, 0x646C6BD7UL, 0x44904DB3UL,
|
||||
0x66B4F0A3UL, 0xC0F1648AUL, 0x697ED5AFUL, 0x49E92FF6UL,
|
||||
0x309E374FUL, 0x2CB6356AUL, 0x85808573UL, 0x4991F840UL,
|
||||
0x76F0AE02UL, 0x083BE84DUL, 0x28421C9AUL, 0x44489406UL,
|
||||
0x736E4CB8UL, 0xC1092910UL, 0x8BC95FC6UL, 0x7D869CF4UL,
|
||||
0x134F616FUL, 0x2E77118DUL, 0xB31B2BE1UL, 0xAA90B472UL,
|
||||
0x3CA5D717UL, 0x7D161BBAUL, 0x9CAD9010UL, 0xAF462BA2UL,
|
||||
0x9FE459D2UL, 0x45D34559UL, 0xD9F2DA13UL, 0xDBC65487UL,
|
||||
0xF3E4F94EUL, 0x176D486FUL, 0x097C13EAUL, 0x631DA5C7UL,
|
||||
0x445F7382UL, 0x175683F4UL, 0xCDC66A97UL, 0x70BE0288UL,
|
||||
0xB3CDCF72UL, 0x6E5DD2F3UL, 0x20936079UL, 0x459B80A5UL,
|
||||
0xBE60E2DBUL, 0xA9C23101UL, 0xEBA5315CUL, 0x224E42F2UL,
|
||||
0x1C5C1572UL, 0xF6721B2CUL, 0x1AD2FFF3UL, 0x8C25404EUL,
|
||||
0x324ED72FUL, 0x4067B7FDUL, 0x0523138EUL, 0x5CA3BC78UL,
|
||||
0xDC0FD66EUL, 0x75922283UL, 0x784D6B17UL, 0x58EBB16EUL,
|
||||
0x44094F85UL, 0x3F481D87UL, 0xFCFEAE7BUL, 0x77B5FF76UL,
|
||||
0x8C2302BFUL, 0xAAF47556UL, 0x5F46B02AUL, 0x2B092801UL,
|
||||
0x3D38F5F7UL, 0x0CA81F36UL, 0x52AF4A8AUL, 0x66D5E7C0UL,
|
||||
0xDF3B0874UL, 0x95055110UL, 0x1B5AD7A8UL, 0xF61ED5ADUL,
|
||||
0x6CF6E479UL, 0x20758184UL, 0xD0CEFA65UL, 0x88F7BE58UL,
|
||||
0x4A046826UL, 0x0FF6F8F3UL, 0xA09C7F70UL, 0x5346ABA0UL,
|
||||
0x5CE96C28UL, 0xE176EDA3UL, 0x6BAC307FUL, 0x376829D2UL,
|
||||
0x85360FA9UL, 0x17E3FE2AUL, 0x24B79767UL, 0xF5A96B20UL,
|
||||
0xD6CD2595UL, 0x68FF1EBFUL, 0x7555442CUL, 0xF19F06BEUL,
|
||||
0xF9E0659AUL, 0xEEB9491DUL, 0x34010718UL, 0xBB30CAB8UL,
|
||||
0xE822FE15UL, 0x88570983UL, 0x750E6249UL, 0xDA627E55UL,
|
||||
0x5E76FFA8UL, 0xB1534546UL, 0x6D47DE08UL, 0xEFE9E7D4UL
|
||||
},
|
||||
|
||||
{
|
||||
0xF6FA8F9DUL, 0x2CAC6CE1UL, 0x4CA34867UL, 0xE2337F7CUL,
|
||||
0x95DB08E7UL, 0x016843B4UL, 0xECED5CBCUL, 0x325553ACUL,
|
||||
0xBF9F0960UL, 0xDFA1E2EDUL, 0x83F0579DUL, 0x63ED86B9UL,
|
||||
0x1AB6A6B8UL, 0xDE5EBE39UL, 0xF38FF732UL, 0x8989B138UL,
|
||||
0x33F14961UL, 0xC01937BDUL, 0xF506C6DAUL, 0xE4625E7EUL,
|
||||
0xA308EA99UL, 0x4E23E33CUL, 0x79CBD7CCUL, 0x48A14367UL,
|
||||
0xA3149619UL, 0xFEC94BD5UL, 0xA114174AUL, 0xEAA01866UL,
|
||||
0xA084DB2DUL, 0x09A8486FUL, 0xA888614AUL, 0x2900AF98UL,
|
||||
0x01665991UL, 0xE1992863UL, 0xC8F30C60UL, 0x2E78EF3CUL,
|
||||
0xD0D51932UL, 0xCF0FEC14UL, 0xF7CA07D2UL, 0xD0A82072UL,
|
||||
0xFD41197EUL, 0x9305A6B0UL, 0xE86BE3DAUL, 0x74BED3CDUL,
|
||||
0x372DA53CUL, 0x4C7F4448UL, 0xDAB5D440UL, 0x6DBA0EC3UL,
|
||||
0x083919A7UL, 0x9FBAEED9UL, 0x49DBCFB0UL, 0x4E670C53UL,
|
||||
0x5C3D9C01UL, 0x64BDB941UL, 0x2C0E636AUL, 0xBA7DD9CDUL,
|
||||
0xEA6F7388UL, 0xE70BC762UL, 0x35F29ADBUL, 0x5C4CDD8DUL,
|
||||
0xF0D48D8CUL, 0xB88153E2UL, 0x08A19866UL, 0x1AE2EAC8UL,
|
||||
0x284CAF89UL, 0xAA928223UL, 0x9334BE53UL, 0x3B3A21BFUL,
|
||||
0x16434BE3UL, 0x9AEA3906UL, 0xEFE8C36EUL, 0xF890CDD9UL,
|
||||
0x80226DAEUL, 0xC340A4A3UL, 0xDF7E9C09UL, 0xA694A807UL,
|
||||
0x5B7C5ECCUL, 0x221DB3A6UL, 0x9A69A02FUL, 0x68818A54UL,
|
||||
0xCEB2296FUL, 0x53C0843AUL, 0xFE893655UL, 0x25BFE68AUL,
|
||||
0xB4628ABCUL, 0xCF222EBFUL, 0x25AC6F48UL, 0xA9A99387UL,
|
||||
0x53BDDB65UL, 0xE76FFBE7UL, 0xE967FD78UL, 0x0BA93563UL,
|
||||
0x8E342BC1UL, 0xE8A11BE9UL, 0x4980740DUL, 0xC8087DFCUL,
|
||||
0x8DE4BF99UL, 0xA11101A0UL, 0x7FD37975UL, 0xDA5A26C0UL,
|
||||
0xE81F994FUL, 0x9528CD89UL, 0xFD339FEDUL, 0xB87834BFUL,
|
||||
0x5F04456DUL, 0x22258698UL, 0xC9C4C83BUL, 0x2DC156BEUL,
|
||||
0x4F628DAAUL, 0x57F55EC5UL, 0xE2220ABEUL, 0xD2916EBFUL,
|
||||
0x4EC75B95UL, 0x24F2C3C0UL, 0x42D15D99UL, 0xCD0D7FA0UL,
|
||||
0x7B6E27FFUL, 0xA8DC8AF0UL, 0x7345C106UL, 0xF41E232FUL,
|
||||
0x35162386UL, 0xE6EA8926UL, 0x3333B094UL, 0x157EC6F2UL,
|
||||
0x372B74AFUL, 0x692573E4UL, 0xE9A9D848UL, 0xF3160289UL,
|
||||
0x3A62EF1DUL, 0xA787E238UL, 0xF3A5F676UL, 0x74364853UL,
|
||||
0x20951063UL, 0x4576698DUL, 0xB6FAD407UL, 0x592AF950UL,
|
||||
0x36F73523UL, 0x4CFB6E87UL, 0x7DA4CEC0UL, 0x6C152DAAUL,
|
||||
0xCB0396A8UL, 0xC50DFE5DUL, 0xFCD707ABUL, 0x0921C42FUL,
|
||||
0x89DFF0BBUL, 0x5FE2BE78UL, 0x448F4F33UL, 0x754613C9UL,
|
||||
0x2B05D08DUL, 0x48B9D585UL, 0xDC049441UL, 0xC8098F9BUL,
|
||||
0x7DEDE786UL, 0xC39A3373UL, 0x42410005UL, 0x6A091751UL,
|
||||
0x0EF3C8A6UL, 0x890072D6UL, 0x28207682UL, 0xA9A9F7BEUL,
|
||||
0xBF32679DUL, 0xD45B5B75UL, 0xB353FD00UL, 0xCBB0E358UL,
|
||||
0x830F220AUL, 0x1F8FB214UL, 0xD372CF08UL, 0xCC3C4A13UL,
|
||||
0x8CF63166UL, 0x061C87BEUL, 0x88C98F88UL, 0x6062E397UL,
|
||||
0x47CF8E7AUL, 0xB6C85283UL, 0x3CC2ACFBUL, 0x3FC06976UL,
|
||||
0x4E8F0252UL, 0x64D8314DUL, 0xDA3870E3UL, 0x1E665459UL,
|
||||
0xC10908F0UL, 0x513021A5UL, 0x6C5B68B7UL, 0x822F8AA0UL,
|
||||
0x3007CD3EUL, 0x74719EEFUL, 0xDC872681UL, 0x073340D4UL,
|
||||
0x7E432FD9UL, 0x0C5EC241UL, 0x8809286CUL, 0xF592D891UL,
|
||||
0x08A930F6UL, 0x957EF305UL, 0xB7FBFFBDUL, 0xC266E96FUL,
|
||||
0x6FE4AC98UL, 0xB173ECC0UL, 0xBC60B42AUL, 0x953498DAUL,
|
||||
0xFBA1AE12UL, 0x2D4BD736UL, 0x0F25FAABUL, 0xA4F3FCEBUL,
|
||||
0xE2969123UL, 0x257F0C3DUL, 0x9348AF49UL, 0x361400BCUL,
|
||||
0xE8816F4AUL, 0x3814F200UL, 0xA3F94043UL, 0x9C7A54C2UL,
|
||||
0xBC704F57UL, 0xDA41E7F9UL, 0xC25AD33AUL, 0x54F4A084UL,
|
||||
0xB17F5505UL, 0x59357CBEUL, 0xEDBD15C8UL, 0x7F97C5ABUL,
|
||||
0xBA5AC7B5UL, 0xB6F6DEAFUL, 0x3A479C3AUL, 0x5302DA25UL,
|
||||
0x653D7E6AUL, 0x54268D49UL, 0x51A477EAUL, 0x5017D55BUL,
|
||||
0xD7D25D88UL, 0x44136C76UL, 0x0404A8C8UL, 0xB8E5A121UL,
|
||||
0xB81A928AUL, 0x60ED5869UL, 0x97C55B96UL, 0xEAEC991BUL,
|
||||
0x29935913UL, 0x01FDB7F1UL, 0x088E8DFAUL, 0x9AB6F6F5UL,
|
||||
0x3B4CBF9FUL, 0x4A5DE3ABUL, 0xE6051D35UL, 0xA0E1D855UL,
|
||||
0xD36B4CF1UL, 0xF544EDEBUL, 0xB0E93524UL, 0xBEBB8FBDUL,
|
||||
0xA2D762CFUL, 0x49C92F54UL, 0x38B5F331UL, 0x7128A454UL,
|
||||
0x48392905UL, 0xA65B1DB8UL, 0x851C97BDUL, 0xD675CF2FUL
|
||||
},
|
||||
|
||||
{
|
||||
0x85E04019UL, 0x332BF567UL, 0x662DBFFFUL, 0xCFC65693UL,
|
||||
0x2A8D7F6FUL, 0xAB9BC912UL, 0xDE6008A1UL, 0x2028DA1FUL,
|
||||
0x0227BCE7UL, 0x4D642916UL, 0x18FAC300UL, 0x50F18B82UL,
|
||||
0x2CB2CB11UL, 0xB232E75CUL, 0x4B3695F2UL, 0xB28707DEUL,
|
||||
0xA05FBCF6UL, 0xCD4181E9UL, 0xE150210CUL, 0xE24EF1BDUL,
|
||||
0xB168C381UL, 0xFDE4E789UL, 0x5C79B0D8UL, 0x1E8BFD43UL,
|
||||
0x4D495001UL, 0x38BE4341UL, 0x913CEE1DUL, 0x92A79C3FUL,
|
||||
0x089766BEUL, 0xBAEEADF4UL, 0x1286BECFUL, 0xB6EACB19UL,
|
||||
0x2660C200UL, 0x7565BDE4UL, 0x64241F7AUL, 0x8248DCA9UL,
|
||||
0xC3B3AD66UL, 0x28136086UL, 0x0BD8DFA8UL, 0x356D1CF2UL,
|
||||
0x107789BEUL, 0xB3B2E9CEUL, 0x0502AA8FUL, 0x0BC0351EUL,
|
||||
0x166BF52AUL, 0xEB12FF82UL, 0xE3486911UL, 0xD34D7516UL,
|
||||
0x4E7B3AFFUL, 0x5F43671BUL, 0x9CF6E037UL, 0x4981AC83UL,
|
||||
0x334266CEUL, 0x8C9341B7UL, 0xD0D854C0UL, 0xCB3A6C88UL,
|
||||
0x47BC2829UL, 0x4725BA37UL, 0xA66AD22BUL, 0x7AD61F1EUL,
|
||||
0x0C5CBAFAUL, 0x4437F107UL, 0xB6E79962UL, 0x42D2D816UL,
|
||||
0x0A961288UL, 0xE1A5C06EUL, 0x13749E67UL, 0x72FC081AUL,
|
||||
0xB1D139F7UL, 0xF9583745UL, 0xCF19DF58UL, 0xBEC3F756UL,
|
||||
0xC06EBA30UL, 0x07211B24UL, 0x45C28829UL, 0xC95E317FUL,
|
||||
0xBC8EC511UL, 0x38BC46E9UL, 0xC6E6FA14UL, 0xBAE8584AUL,
|
||||
0xAD4EBC46UL, 0x468F508BUL, 0x7829435FUL, 0xF124183BUL,
|
||||
0x821DBA9FUL, 0xAFF60FF4UL, 0xEA2C4E6DUL, 0x16E39264UL,
|
||||
0x92544A8BUL, 0x009B4FC3UL, 0xABA68CEDUL, 0x9AC96F78UL,
|
||||
0x06A5B79AUL, 0xB2856E6EUL, 0x1AEC3CA9UL, 0xBE838688UL,
|
||||
0x0E0804E9UL, 0x55F1BE56UL, 0xE7E5363BUL, 0xB3A1F25DUL,
|
||||
0xF7DEBB85UL, 0x61FE033CUL, 0x16746233UL, 0x3C034C28UL,
|
||||
0xDA6D0C74UL, 0x79AAC56CUL, 0x3CE4E1ADUL, 0x51F0C802UL,
|
||||
0x98F8F35AUL, 0x1626A49FUL, 0xEED82B29UL, 0x1D382FE3UL,
|
||||
0x0C4FB99AUL, 0xBB325778UL, 0x3EC6D97BUL, 0x6E77A6A9UL,
|
||||
0xCB658B5CUL, 0xD45230C7UL, 0x2BD1408BUL, 0x60C03EB7UL,
|
||||
0xB9068D78UL, 0xA33754F4UL, 0xF430C87DUL, 0xC8A71302UL,
|
||||
0xB96D8C32UL, 0xEBD4E7BEUL, 0xBE8B9D2DUL, 0x7979FB06UL,
|
||||
0xE7225308UL, 0x8B75CF77UL, 0x11EF8DA4UL, 0xE083C858UL,
|
||||
0x8D6B786FUL, 0x5A6317A6UL, 0xFA5CF7A0UL, 0x5DDA0033UL,
|
||||
0xF28EBFB0UL, 0xF5B9C310UL, 0xA0EAC280UL, 0x08B9767AUL,
|
||||
0xA3D9D2B0UL, 0x79D34217UL, 0x021A718DUL, 0x9AC6336AUL,
|
||||
0x2711FD60UL, 0x438050E3UL, 0x069908A8UL, 0x3D7FEDC4UL,
|
||||
0x826D2BEFUL, 0x4EEB8476UL, 0x488DCF25UL, 0x36C9D566UL,
|
||||
0x28E74E41UL, 0xC2610ACAUL, 0x3D49A9CFUL, 0xBAE3B9DFUL,
|
||||
0xB65F8DE6UL, 0x92AEAF64UL, 0x3AC7D5E6UL, 0x9EA80509UL,
|
||||
0xF22B017DUL, 0xA4173F70UL, 0xDD1E16C3UL, 0x15E0D7F9UL,
|
||||
0x50B1B887UL, 0x2B9F4FD5UL, 0x625ABA82UL, 0x6A017962UL,
|
||||
0x2EC01B9CUL, 0x15488AA9UL, 0xD716E740UL, 0x40055A2CUL,
|
||||
0x93D29A22UL, 0xE32DBF9AUL, 0x058745B9UL, 0x3453DC1EUL,
|
||||
0xD699296EUL, 0x496CFF6FUL, 0x1C9F4986UL, 0xDFE2ED07UL,
|
||||
0xB87242D1UL, 0x19DE7EAEUL, 0x053E561AUL, 0x15AD6F8CUL,
|
||||
0x66626C1CUL, 0x7154C24CUL, 0xEA082B2AUL, 0x93EB2939UL,
|
||||
0x17DCB0F0UL, 0x58D4F2AEUL, 0x9EA294FBUL, 0x52CF564CUL,
|
||||
0x9883FE66UL, 0x2EC40581UL, 0x763953C3UL, 0x01D6692EUL,
|
||||
0xD3A0C108UL, 0xA1E7160EUL, 0xE4F2DFA6UL, 0x693ED285UL,
|
||||
0x74904698UL, 0x4C2B0EDDUL, 0x4F757656UL, 0x5D393378UL,
|
||||
0xA132234FUL, 0x3D321C5DUL, 0xC3F5E194UL, 0x4B269301UL,
|
||||
0xC79F022FUL, 0x3C997E7EUL, 0x5E4F9504UL, 0x3FFAFBBDUL,
|
||||
0x76F7AD0EUL, 0x296693F4UL, 0x3D1FCE6FUL, 0xC61E45BEUL,
|
||||
0xD3B5AB34UL, 0xF72BF9B7UL, 0x1B0434C0UL, 0x4E72B567UL,
|
||||
0x5592A33DUL, 0xB5229301UL, 0xCFD2A87FUL, 0x60AEB767UL,
|
||||
0x1814386BUL, 0x30BCC33DUL, 0x38A0C07DUL, 0xFD1606F2UL,
|
||||
0xC363519BUL, 0x589DD390UL, 0x5479F8E6UL, 0x1CB8D647UL,
|
||||
0x97FD61A9UL, 0xEA7759F4UL, 0x2D57539DUL, 0x569A58CFUL,
|
||||
0xE84E63ADUL, 0x462E1B78UL, 0x6580F87EUL, 0xF3817914UL,
|
||||
0x91DA55F4UL, 0x40A230F3UL, 0xD1988F35UL, 0xB6E318D2UL,
|
||||
0x3FFA50BCUL, 0x3D40F021UL, 0xC3C0BDAEUL, 0x4958C24CUL,
|
||||
0x518F36B2UL, 0x84B1D370UL, 0x0FEDCE83UL, 0x878DDADAUL,
|
||||
0xF2A279C7UL, 0x94E01BE8UL, 0x90716F4BUL, 0x954B8AA3UL
|
||||
},
|
||||
|
||||
{
|
||||
0xE216300DUL, 0xBBDDFFFCUL, 0xA7EBDABDUL, 0x35648095UL,
|
||||
0x7789F8B7UL, 0xE6C1121BUL, 0x0E241600UL, 0x052CE8B5UL,
|
||||
0x11A9CFB0UL, 0xE5952F11UL, 0xECE7990AUL, 0x9386D174UL,
|
||||
0x2A42931CUL, 0x76E38111UL, 0xB12DEF3AUL, 0x37DDDDFCUL,
|
||||
0xDE9ADEB1UL, 0x0A0CC32CUL, 0xBE197029UL, 0x84A00940UL,
|
||||
0xBB243A0FUL, 0xB4D137CFUL, 0xB44E79F0UL, 0x049EEDFDUL,
|
||||
0x0B15A15DUL, 0x480D3168UL, 0x8BBBDE5AUL, 0x669DED42UL,
|
||||
0xC7ECE831UL, 0x3F8F95E7UL, 0x72DF191BUL, 0x7580330DUL,
|
||||
0x94074251UL, 0x5C7DCDFAUL, 0xABBE6D63UL, 0xAA402164UL,
|
||||
0xB301D40AUL, 0x02E7D1CAUL, 0x53571DAEUL, 0x7A3182A2UL,
|
||||
0x12A8DDECUL, 0xFDAA335DUL, 0x176F43E8UL, 0x71FB46D4UL,
|
||||
0x38129022UL, 0xCE949AD4UL, 0xB84769ADUL, 0x965BD862UL,
|
||||
0x82F3D055UL, 0x66FB9767UL, 0x15B80B4EUL, 0x1D5B47A0UL,
|
||||
0x4CFDE06FUL, 0xC28EC4B8UL, 0x57E8726EUL, 0x647A78FCUL,
|
||||
0x99865D44UL, 0x608BD593UL, 0x6C200E03UL, 0x39DC5FF6UL,
|
||||
0x5D0B00A3UL, 0xAE63AFF2UL, 0x7E8BD632UL, 0x70108C0CUL,
|
||||
0xBBD35049UL, 0x2998DF04UL, 0x980CF42AUL, 0x9B6DF491UL,
|
||||
0x9E7EDD53UL, 0x06918548UL, 0x58CB7E07UL, 0x3B74EF2EUL,
|
||||
0x522FFFB1UL, 0xD24708CCUL, 0x1C7E27CDUL, 0xA4EB215BUL,
|
||||
0x3CF1D2E2UL, 0x19B47A38UL, 0x424F7618UL, 0x35856039UL,
|
||||
0x9D17DEE7UL, 0x27EB35E6UL, 0xC9AFF67BUL, 0x36BAF5B8UL,
|
||||
0x09C467CDUL, 0xC18910B1UL, 0xE11DBF7BUL, 0x06CD1AF8UL,
|
||||
0x7170C608UL, 0x2D5E3354UL, 0xD4DE495AUL, 0x64C6D006UL,
|
||||
0xBCC0C62CUL, 0x3DD00DB3UL, 0x708F8F34UL, 0x77D51B42UL,
|
||||
0x264F620FUL, 0x24B8D2BFUL, 0x15C1B79EUL, 0x46A52564UL,
|
||||
0xF8D7E54EUL, 0x3E378160UL, 0x7895CDA5UL, 0x859C15A5UL,
|
||||
0xE6459788UL, 0xC37BC75FUL, 0xDB07BA0CUL, 0x0676A3ABUL,
|
||||
0x7F229B1EUL, 0x31842E7BUL, 0x24259FD7UL, 0xF8BEF472UL,
|
||||
0x835FFCB8UL, 0x6DF4C1F2UL, 0x96F5B195UL, 0xFD0AF0FCUL,
|
||||
0xB0FE134CUL, 0xE2506D3DUL, 0x4F9B12EAUL, 0xF215F225UL,
|
||||
0xA223736FUL, 0x9FB4C428UL, 0x25D04979UL, 0x34C713F8UL,
|
||||
0xC4618187UL, 0xEA7A6E98UL, 0x7CD16EFCUL, 0x1436876CUL,
|
||||
0xF1544107UL, 0xBEDEEE14UL, 0x56E9AF27UL, 0xA04AA441UL,
|
||||
0x3CF7C899UL, 0x92ECBAE6UL, 0xDD67016DUL, 0x151682EBUL,
|
||||
0xA842EEDFUL, 0xFDBA60B4UL, 0xF1907B75UL, 0x20E3030FUL,
|
||||
0x24D8C29EUL, 0xE139673BUL, 0xEFA63FB8UL, 0x71873054UL,
|
||||
0xB6F2CF3BUL, 0x9F326442UL, 0xCB15A4CCUL, 0xB01A4504UL,
|
||||
0xF1E47D8DUL, 0x844A1BE5UL, 0xBAE7DFDCUL, 0x42CBDA70UL,
|
||||
0xCD7DAE0AUL, 0x57E85B7AUL, 0xD53F5AF6UL, 0x20CF4D8CUL,
|
||||
0xCEA4D428UL, 0x79D130A4UL, 0x3486EBFBUL, 0x33D3CDDCUL,
|
||||
0x77853B53UL, 0x37EFFCB5UL, 0xC5068778UL, 0xE580B3E6UL,
|
||||
0x4E68B8F4UL, 0xC5C8B37EUL, 0x0D809EA2UL, 0x398FEB7CUL,
|
||||
0x132A4F94UL, 0x43B7950EUL, 0x2FEE7D1CUL, 0x223613BDUL,
|
||||
0xDD06CAA2UL, 0x37DF932BUL, 0xC4248289UL, 0xACF3EBC3UL,
|
||||
0x5715F6B7UL, 0xEF3478DDUL, 0xF267616FUL, 0xC148CBE4UL,
|
||||
0x9052815EUL, 0x5E410FABUL, 0xB48A2465UL, 0x2EDA7FA4UL,
|
||||
0xE87B40E4UL, 0xE98EA084UL, 0x5889E9E1UL, 0xEFD390FCUL,
|
||||
0xDD07D35BUL, 0xDB485694UL, 0x38D7E5B2UL, 0x57720101UL,
|
||||
0x730EDEBCUL, 0x5B643113UL, 0x94917E4FUL, 0x503C2FBAUL,
|
||||
0x646F1282UL, 0x7523D24AUL, 0xE0779695UL, 0xF9C17A8FUL,
|
||||
0x7A5B2121UL, 0xD187B896UL, 0x29263A4DUL, 0xBA510CDFUL,
|
||||
0x81F47C9FUL, 0xAD1163EDUL, 0xEA7B5965UL, 0x1A00726EUL,
|
||||
0x11403092UL, 0x00DA6D77UL, 0x4A0CDD61UL, 0xAD1F4603UL,
|
||||
0x605BDFB0UL, 0x9EEDC364UL, 0x22EBE6A8UL, 0xCEE7D28AUL,
|
||||
0xA0E736A0UL, 0x5564A6B9UL, 0x10853209UL, 0xC7EB8F37UL,
|
||||
0x2DE705CAUL, 0x8951570FUL, 0xDF09822BUL, 0xBD691A6CUL,
|
||||
0xAA12E4F2UL, 0x87451C0FUL, 0xE0F6A27AUL, 0x3ADA4819UL,
|
||||
0x4CF1764FUL, 0x0D771C2BUL, 0x67CDB156UL, 0x350D8384UL,
|
||||
0x5938FA0FUL, 0x42399EF3UL, 0x36997B07UL, 0x0E84093DUL,
|
||||
0x4AA93E61UL, 0x8360D87BUL, 0x1FA98B0CUL, 0x1149382CUL,
|
||||
0xE97625A5UL, 0x0614D1B7UL, 0x0E25244BUL, 0x0C768347UL,
|
||||
0x589E8D82UL, 0x0D2059D1UL, 0xA466BB1EUL, 0xF8DA0A82UL,
|
||||
0x04F19130UL, 0xBA6E4EC0UL, 0x99265164UL, 0x1EE7230DUL,
|
||||
0x50B2AD80UL, 0xEAEE6801UL, 0x8DB2A283UL, 0xEA8BF59EUL
|
||||
}};
|
||||
|
||||
NAMESPACE_END
|
||||
@ -34,7 +34,6 @@
|
||||
#include "rsa.h"
|
||||
#include "rw.h"
|
||||
#include "sha.h"
|
||||
#include "skipjack.h"
|
||||
#include "trdlocal.h"
|
||||
|
||||
#ifdef CRYPTOPP_IMPORTS
|
||||
|
||||
@ -1,601 +0,0 @@
|
||||
// fipstest.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
|
||||
#ifndef CRYPTOPP_IMPORTS
|
||||
|
||||
#define CRYPTOPP_DEFAULT_NO_DLL
|
||||
#include "dll.h"
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
#define _WIN32_WINNT 0x0400
|
||||
#include <windows.h>
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER >= 1400
|
||||
#ifdef _M_IX86
|
||||
#define _CRT_DEBUGGER_HOOK _crt_debugger_hook
|
||||
#else
|
||||
#define _CRT_DEBUGGER_HOOK __crt_debugger_hook
|
||||
#endif
|
||||
extern "C" {_CRTIMP void __cdecl _CRT_DEBUGGER_HOOK(int);}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
extern PowerUpSelfTestStatus g_powerUpSelfTestStatus;
|
||||
SecByteBlock g_actualMac;
|
||||
unsigned long g_macFileLocation = 0;
|
||||
|
||||
// use a random dummy string here, to be searched/replaced later with the real MAC
|
||||
static const byte s_moduleMac[CryptoPP::HMAC<CryptoPP::SHA1>::DIGESTSIZE] = CRYPTOPP_DUMMY_DLL_MAC;
|
||||
CRYPTOPP_COMPILE_ASSERT(sizeof(s_moduleMac) == CryptoPP::SHA1::DIGESTSIZE);
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
static HMODULE s_hModule = NULL;
|
||||
#endif
|
||||
|
||||
const byte * CRYPTOPP_API GetActualMacAndLocation(unsigned int &macSize, unsigned int &fileLocation)
|
||||
{
|
||||
macSize = (unsigned int)g_actualMac.size();
|
||||
fileLocation = g_macFileLocation;
|
||||
return g_actualMac;
|
||||
}
|
||||
|
||||
void KnownAnswerTest(RandomNumberGenerator &rng, const char *output)
|
||||
{
|
||||
EqualityComparisonFilter comparison;
|
||||
|
||||
RandomNumberStore(rng, strlen(output)/2).TransferAllTo(comparison, "0");
|
||||
StringSource(output, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
|
||||
|
||||
comparison.ChannelMessageSeriesEnd("0");
|
||||
comparison.ChannelMessageSeriesEnd("1");
|
||||
}
|
||||
|
||||
template <class CIPHER>
|
||||
void X917RNG_KnownAnswerTest(
|
||||
const char *key,
|
||||
const char *seed,
|
||||
const char *deterministicTimeVector,
|
||||
const char *output,
|
||||
CIPHER *dummy = NULL)
|
||||
{
|
||||
#ifdef OS_RNG_AVAILABLE
|
||||
std::string decodedKey, decodedSeed, decodedDeterministicTimeVector;
|
||||
StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
|
||||
StringSource(seed, true, new HexDecoder(new StringSink(decodedSeed)));
|
||||
StringSource(deterministicTimeVector, true, new HexDecoder(new StringSink(decodedDeterministicTimeVector)));
|
||||
|
||||
AutoSeededX917RNG<CIPHER> rng(false, false);
|
||||
rng.Reseed((const byte *)decodedKey.data(), decodedKey.size(), (const byte *)decodedSeed.data(), (const byte *)decodedDeterministicTimeVector.data());
|
||||
KnownAnswerTest(rng, output);
|
||||
#else
|
||||
throw 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
void KnownAnswerTest(StreamTransformation &encryption, StreamTransformation &decryption, const char *plaintext, const char *ciphertext)
|
||||
{
|
||||
EqualityComparisonFilter comparison;
|
||||
|
||||
StringSource(plaintext, true, new HexDecoder(new StreamTransformationFilter(encryption, new ChannelSwitch(comparison, "0"), StreamTransformationFilter::NO_PADDING)));
|
||||
StringSource(ciphertext, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
|
||||
|
||||
StringSource(ciphertext, true, new HexDecoder(new StreamTransformationFilter(decryption, new ChannelSwitch(comparison, "0"), StreamTransformationFilter::NO_PADDING)));
|
||||
StringSource(plaintext, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
|
||||
|
||||
comparison.ChannelMessageSeriesEnd("0");
|
||||
comparison.ChannelMessageSeriesEnd("1");
|
||||
}
|
||||
|
||||
template <class CIPHER>
|
||||
void SymmetricEncryptionKnownAnswerTest(
|
||||
const char *key,
|
||||
const char *hexIV,
|
||||
const char *plaintext,
|
||||
const char *ecb,
|
||||
const char *cbc,
|
||||
const char *cfb,
|
||||
const char *ofb,
|
||||
const char *ctr,
|
||||
CIPHER *dummy = NULL)
|
||||
{
|
||||
std::string decodedKey;
|
||||
StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
|
||||
|
||||
typename CIPHER::Encryption encryption((const byte *)decodedKey.data(), decodedKey.size());
|
||||
typename CIPHER::Decryption decryption((const byte *)decodedKey.data(), decodedKey.size());
|
||||
|
||||
SecByteBlock iv(encryption.BlockSize());
|
||||
StringSource(hexIV, true, new HexDecoder(new ArraySink(iv, iv.size())));
|
||||
|
||||
if (ecb)
|
||||
KnownAnswerTest(ECB_Mode_ExternalCipher::Encryption(encryption).Ref(), ECB_Mode_ExternalCipher::Decryption(decryption).Ref(), plaintext, ecb);
|
||||
if (cbc)
|
||||
KnownAnswerTest(CBC_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CBC_Mode_ExternalCipher::Decryption(decryption, iv).Ref(), plaintext, cbc);
|
||||
if (cfb)
|
||||
KnownAnswerTest(CFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, cfb);
|
||||
if (ofb)
|
||||
KnownAnswerTest(OFB_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), OFB_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ofb);
|
||||
if (ctr)
|
||||
KnownAnswerTest(CTR_Mode_ExternalCipher::Encryption(encryption, iv).Ref(), CTR_Mode_ExternalCipher::Decryption(encryption, iv).Ref(), plaintext, ctr);
|
||||
}
|
||||
|
||||
void KnownAnswerTest(HashTransformation &hash, const char *message, const char *digest)
|
||||
{
|
||||
EqualityComparisonFilter comparison;
|
||||
StringSource(digest, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
|
||||
StringSource(message, true, new HashFilter(hash, new ChannelSwitch(comparison, "0")));
|
||||
|
||||
comparison.ChannelMessageSeriesEnd("0");
|
||||
comparison.ChannelMessageSeriesEnd("1");
|
||||
}
|
||||
|
||||
template <class HASH>
|
||||
void SecureHashKnownAnswerTest(const char *message, const char *digest, HASH *dummy = NULL)
|
||||
{
|
||||
HASH hash;
|
||||
KnownAnswerTest(hash, message, digest);
|
||||
}
|
||||
|
||||
template <class MAC>
|
||||
void MAC_KnownAnswerTest(const char *key, const char *message, const char *digest, MAC *dummy = NULL)
|
||||
{
|
||||
std::string decodedKey;
|
||||
StringSource(key, true, new HexDecoder(new StringSink(decodedKey)));
|
||||
|
||||
MAC mac((const byte *)decodedKey.data(), decodedKey.size());
|
||||
KnownAnswerTest(mac, message, digest);
|
||||
}
|
||||
|
||||
template <class SCHEME>
|
||||
void SignatureKnownAnswerTest(const char *key, const char *message, const char *signature, SCHEME *dummy = NULL)
|
||||
{
|
||||
typename SCHEME::Signer signer(StringSource(key, true, new HexDecoder).Ref());
|
||||
typename SCHEME::Verifier verifier(signer);
|
||||
|
||||
RandomPool rng;
|
||||
EqualityComparisonFilter comparison;
|
||||
|
||||
StringSource(message, true, new SignerFilter(rng, signer, new ChannelSwitch(comparison, "0")));
|
||||
StringSource(signature, true, new HexDecoder(new ChannelSwitch(comparison, "1")));
|
||||
|
||||
comparison.ChannelMessageSeriesEnd("0");
|
||||
comparison.ChannelMessageSeriesEnd("1");
|
||||
|
||||
VerifierFilter verifierFilter(verifier, NULL, VerifierFilter::SIGNATURE_AT_BEGIN | VerifierFilter::THROW_EXCEPTION);
|
||||
StringSource(signature, true, new HexDecoder(new Redirector(verifierFilter, Redirector::DATA_ONLY)));
|
||||
StringSource(message, true, new Redirector(verifierFilter));
|
||||
}
|
||||
|
||||
void EncryptionPairwiseConsistencyTest(const PK_Encryptor &encryptor, const PK_Decryptor &decryptor)
|
||||
{
|
||||
try
|
||||
{
|
||||
RandomPool rng;
|
||||
const char *testMessage ="test message";
|
||||
std::string ciphertext, decrypted;
|
||||
|
||||
StringSource(
|
||||
testMessage,
|
||||
true,
|
||||
new PK_EncryptorFilter(
|
||||
rng,
|
||||
encryptor,
|
||||
new StringSink(ciphertext)));
|
||||
|
||||
if (ciphertext == testMessage)
|
||||
throw 0;
|
||||
|
||||
StringSource(
|
||||
ciphertext,
|
||||
true,
|
||||
new PK_DecryptorFilter(
|
||||
rng,
|
||||
decryptor,
|
||||
new StringSink(decrypted)));
|
||||
|
||||
if (decrypted != testMessage)
|
||||
throw 0;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
throw SelfTestFailure(encryptor.AlgorithmName() + ": pairwise consistency test failed");
|
||||
}
|
||||
}
|
||||
|
||||
void SignaturePairwiseConsistencyTest(const PK_Signer &signer, const PK_Verifier &verifier)
|
||||
{
|
||||
try
|
||||
{
|
||||
RandomPool rng;
|
||||
|
||||
StringSource(
|
||||
"test message",
|
||||
true,
|
||||
new SignerFilter(
|
||||
rng,
|
||||
signer,
|
||||
new VerifierFilter(verifier, NULL, VerifierFilter::THROW_EXCEPTION),
|
||||
true));
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
throw SelfTestFailure(signer.AlgorithmName() + ": pairwise consistency test failed");
|
||||
}
|
||||
}
|
||||
|
||||
template <class SCHEME>
|
||||
void SignaturePairwiseConsistencyTest(const char *key, SCHEME *dummy = NULL)
|
||||
{
|
||||
typename SCHEME::Signer signer(StringSource(key, true, new HexDecoder).Ref());
|
||||
typename SCHEME::Verifier verifier(signer);
|
||||
|
||||
SignaturePairwiseConsistencyTest(signer, verifier);
|
||||
}
|
||||
|
||||
MessageAuthenticationCode * NewIntegrityCheckingMAC()
|
||||
{
|
||||
byte key[] = {0x47, 0x1E, 0x33, 0x96, 0x65, 0xB1, 0x6A, 0xED, 0x0B, 0xF8, 0x6B, 0xFD, 0x01, 0x65, 0x05, 0xCC};
|
||||
return new HMAC<SHA1>(key, sizeof(key));
|
||||
}
|
||||
|
||||
bool IntegrityCheckModule(const char *moduleFilename, const byte *expectedModuleMac, SecByteBlock *pActualMac, unsigned long *pMacFileLocation)
|
||||
{
|
||||
std::auto_ptr<MessageAuthenticationCode> mac(NewIntegrityCheckingMAC());
|
||||
unsigned int macSize = mac->DigestSize();
|
||||
|
||||
SecByteBlock tempMac;
|
||||
SecByteBlock &actualMac = pActualMac ? *pActualMac : tempMac;
|
||||
actualMac.resize(macSize);
|
||||
|
||||
unsigned long tempLocation;
|
||||
unsigned long &macFileLocation = pMacFileLocation ? *pMacFileLocation : tempLocation;
|
||||
macFileLocation = 0;
|
||||
|
||||
MeterFilter verifier(new HashFilter(*mac, new ArraySink(actualMac, actualMac.size())));
|
||||
// MeterFilter verifier(new FileSink("c:\\dt.tmp"));
|
||||
std::ifstream moduleStream;
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
HMODULE h;
|
||||
{
|
||||
char moduleFilenameBuf[MAX_PATH] = "";
|
||||
if (moduleFilename == NULL)
|
||||
{
|
||||
#if (_MSC_VER >= 1400 && !defined(_STLPORT_VERSION)) // ifstream doesn't support wide filename on other compilers
|
||||
wchar_t wideModuleFilename[MAX_PATH];
|
||||
if (GetModuleFileNameW(s_hModule, wideModuleFilename, MAX_PATH) > 0)
|
||||
{
|
||||
moduleStream.open(wideModuleFilename, std::ios::in | std::ios::binary);
|
||||
h = GetModuleHandleW(wideModuleFilename);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
GetModuleFileNameA(s_hModule, moduleFilenameBuf, MAX_PATH);
|
||||
moduleFilename = moduleFilenameBuf;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (moduleFilename != NULL)
|
||||
{
|
||||
moduleStream.open(moduleFilename, std::ios::in | std::ios::binary);
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
h = GetModuleHandleA(moduleFilename);
|
||||
moduleFilename = NULL;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
if (!moduleStream)
|
||||
{
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
OutputDebugString("Crypto++ DLL integrity check failed. Cannot open file for reading.");
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
FileStore file(moduleStream);
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
// try to hash from memory first
|
||||
const byte *memBase = (const byte *)h;
|
||||
const IMAGE_DOS_HEADER *ph = (IMAGE_DOS_HEADER *)memBase;
|
||||
const IMAGE_NT_HEADERS *phnt = (IMAGE_NT_HEADERS *)(memBase + ph->e_lfanew);
|
||||
const IMAGE_SECTION_HEADER *phs = IMAGE_FIRST_SECTION(phnt);
|
||||
DWORD nSections = phnt->FileHeader.NumberOfSections;
|
||||
size_t currentFilePos = 0;
|
||||
|
||||
size_t checksumPos = (byte *)&phnt->OptionalHeader.CheckSum - memBase;
|
||||
size_t checksumSize = sizeof(phnt->OptionalHeader.CheckSum);
|
||||
size_t certificateTableDirectoryPos = (byte *)&phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY] - memBase;
|
||||
size_t certificateTableDirectorySize = sizeof(phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY]);
|
||||
size_t certificateTablePos = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress;
|
||||
size_t certificateTableSize = phnt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].Size;
|
||||
|
||||
verifier.AddRangeToSkip(0, checksumPos, checksumSize);
|
||||
verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
|
||||
verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
|
||||
|
||||
while (nSections--)
|
||||
{
|
||||
switch (phs->Characteristics)
|
||||
{
|
||||
default:
|
||||
break;
|
||||
case IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
|
||||
case IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ:
|
||||
unsigned int sectionSize = STDMIN(phs->SizeOfRawData, phs->Misc.VirtualSize);
|
||||
const byte *sectionMemStart = memBase + phs->VirtualAddress;
|
||||
unsigned int sectionFileStart = phs->PointerToRawData;
|
||||
size_t subSectionStart = 0, nextSubSectionStart;
|
||||
|
||||
do
|
||||
{
|
||||
const byte *subSectionMemStart = sectionMemStart + subSectionStart;
|
||||
size_t subSectionFileStart = sectionFileStart + subSectionStart;
|
||||
size_t subSectionSize = sectionSize - subSectionStart;
|
||||
nextSubSectionStart = 0;
|
||||
|
||||
unsigned int entriesToReadFromDisk[] = {IMAGE_DIRECTORY_ENTRY_IMPORT, IMAGE_DIRECTORY_ENTRY_IAT};
|
||||
for (unsigned int i=0; i<sizeof(entriesToReadFromDisk)/sizeof(entriesToReadFromDisk[0]); i++)
|
||||
{
|
||||
const IMAGE_DATA_DIRECTORY &entry = phnt->OptionalHeader.DataDirectory[entriesToReadFromDisk[i]];
|
||||
const byte *entryMemStart = memBase + entry.VirtualAddress;
|
||||
if (subSectionMemStart <= entryMemStart && entryMemStart < subSectionMemStart + subSectionSize)
|
||||
{
|
||||
subSectionSize = entryMemStart - subSectionMemStart;
|
||||
nextSubSectionStart = entryMemStart - sectionMemStart + entry.Size;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER >= 1400
|
||||
// first byte of _CRT_DEBUGGER_HOOK gets modified in memory by the debugger invisibly, so read it from file
|
||||
if (IsDebuggerPresent())
|
||||
{
|
||||
if (subSectionMemStart <= (byte *)&_CRT_DEBUGGER_HOOK && (byte *)&_CRT_DEBUGGER_HOOK < subSectionMemStart + subSectionSize)
|
||||
{
|
||||
subSectionSize = (byte *)&_CRT_DEBUGGER_HOOK - subSectionMemStart;
|
||||
nextSubSectionStart = (byte *)&_CRT_DEBUGGER_HOOK - sectionMemStart + 1;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (subSectionMemStart <= expectedModuleMac && expectedModuleMac < subSectionMemStart + subSectionSize)
|
||||
{
|
||||
// found stored MAC
|
||||
macFileLocation = (unsigned long)(subSectionFileStart + (expectedModuleMac - subSectionMemStart));
|
||||
verifier.AddRangeToSkip(0, macFileLocation, macSize);
|
||||
}
|
||||
|
||||
file.TransferTo(verifier, subSectionFileStart - currentFilePos);
|
||||
verifier.Put(subSectionMemStart, subSectionSize);
|
||||
file.Skip(subSectionSize);
|
||||
currentFilePos = subSectionFileStart + subSectionSize;
|
||||
subSectionStart = nextSubSectionStart;
|
||||
} while (nextSubSectionStart != 0);
|
||||
}
|
||||
phs++;
|
||||
}
|
||||
#endif
|
||||
file.TransferAllTo(verifier);
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
// if that fails (could be caused by debug breakpoints or DLL base relocation modifying image in memory),
|
||||
// hash from disk instead
|
||||
if (!VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
|
||||
{
|
||||
OutputDebugString("In memory integrity check failed. This may be caused by debug breakpoints or DLL relocation.\n");
|
||||
moduleStream.clear();
|
||||
moduleStream.seekg(0);
|
||||
verifier.Initialize(MakeParameters(Name::OutputBuffer(), ByteArrayParameter(actualMac, (unsigned int)actualMac.size())));
|
||||
// verifier.Initialize(MakeParameters(Name::OutputFileName(), (const char *)"c:\\dt2.tmp"));
|
||||
verifier.AddRangeToSkip(0, checksumPos, checksumSize);
|
||||
verifier.AddRangeToSkip(0, certificateTableDirectoryPos, certificateTableDirectorySize);
|
||||
verifier.AddRangeToSkip(0, certificateTablePos, certificateTableSize);
|
||||
verifier.AddRangeToSkip(0, macFileLocation, macSize);
|
||||
FileStore(moduleStream).TransferAllTo(verifier);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (VerifyBufsEqual(expectedModuleMac, actualMac, macSize))
|
||||
return true;
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
std::string hexMac;
|
||||
HexEncoder(new StringSink(hexMac)).PutMessageEnd(actualMac, actualMac.size());
|
||||
OutputDebugString((("Crypto++ DLL integrity check failed. Actual MAC is: " + hexMac) + "\n").c_str());
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
void DoPowerUpSelfTest(const char *moduleFilename, const byte *expectedModuleMac)
|
||||
{
|
||||
g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_NOT_DONE;
|
||||
SetPowerUpSelfTestInProgressOnThisThread(true);
|
||||
|
||||
try
|
||||
{
|
||||
if (FIPS_140_2_ComplianceEnabled() || expectedModuleMac != NULL)
|
||||
{
|
||||
if (!IntegrityCheckModule(moduleFilename, expectedModuleMac, &g_actualMac, &g_macFileLocation))
|
||||
throw 0; // throw here so we break in the debugger, this will be caught right away
|
||||
}
|
||||
|
||||
// algorithm tests
|
||||
|
||||
X917RNG_KnownAnswerTest<AES>(
|
||||
"2b7e151628aed2a6abf7158809cf4f3c", // key
|
||||
"000102030405060708090a0b0c0d0e0f", // seed
|
||||
"00000000000000000000000000000001", // time vector
|
||||
"D176EDD27493B0395F4D10546232B0693DC7061C03C3A554F09CECF6F6B46D945A"); // output
|
||||
|
||||
SymmetricEncryptionKnownAnswerTest<DES_EDE3>(
|
||||
"385D7189A5C3D485E1370AA5D408082B5CCCCB5E19F2D90E",
|
||||
"C141B5FCCD28DC8A",
|
||||
"6E1BD7C6120947A464A6AAB293A0F89A563D8D40D3461B68",
|
||||
"64EAAD4ACBB9CEAD6C7615E7C7E4792FE587D91F20C7D2F4",
|
||||
"6235A461AFD312973E3B4F7AA7D23E34E03371F8E8C376C9",
|
||||
"E26BA806A59B0330DE40CA38E77A3E494BE2B212F6DD624B",
|
||||
"E26BA806A59B03307DE2BCC25A08BA40A8BA335F5D604C62",
|
||||
"E26BA806A59B03303C62C2EFF32D3ACDD5D5F35EBCC53371");
|
||||
|
||||
SymmetricEncryptionKnownAnswerTest<SKIPJACK>(
|
||||
"1555E5531C3A169B2D65",
|
||||
"6EC9795701F49864",
|
||||
"00AFA48E9621E52E8CBDA312660184EDDB1F33D9DACDA8DA",
|
||||
"DBEC73562EFCAEB56204EB8AE9557EBF77473FBB52D17CD1",
|
||||
"0C7B0B74E21F99B8F2C8DF37879F6C044967F42A796DCA8B",
|
||||
"79FDDA9724E36CC2E023E9A5C717A8A8A7FDA465CADCBF63",
|
||||
"79FDDA9724E36CC26CACBD83C1ABC06EAF5B249BE5B1E040",
|
||||
"79FDDA9724E36CC211B0AEC607B95A96BCDA318440B82F49");
|
||||
|
||||
SymmetricEncryptionKnownAnswerTest<AES>(
|
||||
"2b7e151628aed2a6abf7158809cf4f3c",
|
||||
"000102030405060708090a0b0c0d0e0f",
|
||||
"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710", // plaintext
|
||||
"3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4", // ecb
|
||||
"7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7", // cbc
|
||||
"3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6", // cfb
|
||||
"3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e", // ofb
|
||||
NULL);
|
||||
|
||||
SymmetricEncryptionKnownAnswerTest<AES>(
|
||||
"2b7e151628aed2a6abf7158809cf4f3c",
|
||||
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
|
||||
"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710",
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
"874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee"); // ctr
|
||||
|
||||
|
||||
SecureHashKnownAnswerTest<SHA1>(
|
||||
"abc",
|
||||
"A9993E364706816ABA3E25717850C26C9CD0D89D");
|
||||
|
||||
SecureHashKnownAnswerTest<SHA224>(
|
||||
"abc",
|
||||
"23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7");
|
||||
|
||||
SecureHashKnownAnswerTest<SHA256>(
|
||||
"abc",
|
||||
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
|
||||
|
||||
SecureHashKnownAnswerTest<SHA384>(
|
||||
"abc",
|
||||
"cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7");
|
||||
|
||||
SecureHashKnownAnswerTest<SHA512>(
|
||||
"abc",
|
||||
"ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
|
||||
|
||||
MAC_KnownAnswerTest<HMAC<SHA1> >(
|
||||
"303132333435363738393a3b3c3d3e3f40414243",
|
||||
"Sample #2",
|
||||
"0922d3405faa3d194f82a45830737d5cc6c75d24");
|
||||
|
||||
const char *keyRSA1 =
|
||||
"30820150020100300d06092a864886f70d01010105000482013a3082013602010002400a66791dc6988168de7ab77419bb7fb0"
|
||||
"c001c62710270075142942e19a8d8c51d053b3e3782a1de5dc5af4ebe99468170114a1dfe67cdc9a9af55d655620bbab0203010001"
|
||||
"02400123c5b61ba36edb1d3679904199a89ea80c09b9122e1400c09adcf7784676d01d23356a7d44d6bd8bd50e94bfc723fa"
|
||||
"87d8862b75177691c11d757692df8881022033d48445c859e52340de704bcdda065fbb4058d740bd1d67d29e9c146c11cf61"
|
||||
"0220335e8408866b0fd38dc7002d3f972c67389a65d5d8306566d5c4f2a5aa52628b0220045ec90071525325d3d46db79695e9af"
|
||||
"acc4523964360e02b119baa366316241022015eb327360c7b60d12e5e2d16bdcd97981d17fba6b70db13b20b436e24eada590220"
|
||||
"2ca6366d72781dfa24d34a9a24cbc2ae927a9958af426563ff63fb11658a461d";
|
||||
|
||||
const char *keyRSA2 =
|
||||
"30820273020100300D06092A864886F70D01010105000482025D3082025902010002818100D40AF9"
|
||||
"A2B713034249E5780056D70FC7DE75D76E44565AA6A6B8ED9646F3C19F9E254D72D7DE6E49DB2264"
|
||||
"0C1D05AB9E2A5F901D8F3FE1F7AE02CEE2ECCE54A40ABAE55A004692752E70725AEEE7CDEA67628A"
|
||||
"82A9239B4AB660C2BC56D9F01E90CBAAB9BF0FC8E17173CEFC5709A29391A7DDF3E0B758691AAF30"
|
||||
"725B292F4F020111027F18C0BA087D082C45D75D3594E0767E4820818EB35612B80CEAB8C880ACA5"
|
||||
"44B6876DFFEF85A576C0D45B551AFAA1FD63209CD745DF75C5A0F0B580296EA466CD0338207E4752"
|
||||
"FF4E7DB724D8AE18CE5CF4153BB94C27869FBB50E64F02546E4B02997A0B8623E64017CC770759C6"
|
||||
"695DB649EEFD829D688D441BCC4E7348F1024100EF86DD7AF3F32CDE8A9F6564E43A559A0C9F8BAD"
|
||||
"36CC25330548B347AC158A345631FA90F7B873C36EFFAE2F7823227A3F580B5DD18304D5932751E7"
|
||||
"43E9234F024100E2A039854B55688740E32A51DF4AF88613D91A371CF8DDD95D780A89D7CF2119A9"
|
||||
"54F1AC0F3DCDB2F6959926E6D9D37D8BC07A4C634DE6F16315BD5F0DAC340102407ECEEDB9903572"
|
||||
"1B76909F174BA6698DCA72953D957B22C0A871C8531EDE3A1BB52984A719BC010D1CA57A555DB83F"
|
||||
"6DE54CBAB932AEC652F38D497A6F3F30CF024100854F30E4FF232E6DADB2CD99926855F484255AB7"
|
||||
"01FBCDCB27EC426F33A7046972AA700ADBCA008763DF87440F52F4E070531AC385B55AAC1C2AE7DD"
|
||||
"8F9278F1024100C313F4AF9E4A9DE1253C21080CE524251560C111550772FD08690F13FBE658342E"
|
||||
"BD2D41C9DCB12374E871B1839E26CAE252E1AE3DAAD5F1EE1F42B4D0EE7581";
|
||||
|
||||
SignatureKnownAnswerTest<RSASS<PKCS1v15, SHA1> >(
|
||||
keyRSA1,
|
||||
"Everyone gets Friday off.",
|
||||
"0610761F95FFD1B8F29DA34212947EC2AA0E358866A722F03CC3C41487ADC604A48FF54F5C6BEDB9FB7BD59F82D6E55D8F3174BA361B2214B2D74E8825E04E81");
|
||||
|
||||
SignatureKnownAnswerTest<RSASS_ISO<SHA1> >(
|
||||
keyRSA2,
|
||||
"test",
|
||||
"32F6BA41C8930DE71EE67F2627172CC539EDE04267FDE03AC295E3C50311F26C3B275D3AF513AC96"
|
||||
"8EE493BAB7DA3A754661D1A7C4A0D1A2B7EE8B313AACD8CB8BFBC5C15EFB0EF15C86A9334A1E87AD"
|
||||
"291EB961B5CA0E84930429B28780816AA94F96FC2367B71E2D2E4866FA966795B147F00600E5207E"
|
||||
"2F189C883B37477C");
|
||||
|
||||
SignaturePairwiseConsistencyTest<DSA>(
|
||||
"3082014A0201003082012B06072A8648CE3804013082011E02818100F468699A6F6EBCC0120D3B34C8E007F125EC7D81F763B8D0F33869AE3BD6B9F2ECCC7DF34DF84C0307449E9B85D30D57194BCCEB310F48141914DD13A077AAF9B624A6CBE666BBA1D7EBEA95B5BA6F54417FD5D4E4220C601E071D316A24EA814E8B0122DBF47EE8AEEFD319EBB01DD95683F10DBB4FEB023F8262A07EAEB7FD02150082AD4E034DA6EEACDFDAE68C36F2BAD614F9E53B02818071AAF73361A26081529F7D84078ADAFCA48E031DB54AD57FB1A833ADBD8672328AABAA0C756247998D7A5B10DACA359D231332CE8120B483A784FE07D46EEBFF0D7D374A10691F78653E6DC29E27CCB1B174923960DFE5B959B919B2C3816C19251832AFD8E35D810E598F82877ABF7D40A041565168BD7F0E21E3FE2A8D8C1C0416021426EBA66E846E755169F84A1DA981D86502405DDF");
|
||||
|
||||
SignaturePairwiseConsistencyTest<ECDSA<EC2N, SHA1> >(
|
||||
"302D020100301006072A8648CE3D020106052B8104000404163014020101040F0070337065E1E196980A9D00E37211");
|
||||
|
||||
SignaturePairwiseConsistencyTest<ECDSA<ECP, SHA1> >(
|
||||
"3039020100301306072A8648CE3D020106082A8648CE3D030101041F301D02010104182BB8A13C8B867010BD9471D9E81FDB01ABD0538C64D6249A");
|
||||
|
||||
SignaturePairwiseConsistencyTest<RSASS<PSS, SHA1> >(keyRSA1);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_FAILED;
|
||||
goto done;
|
||||
}
|
||||
|
||||
g_powerUpSelfTestStatus = POWER_UP_SELF_TEST_PASSED;
|
||||
|
||||
done:
|
||||
SetPowerUpSelfTestInProgressOnThisThread(false);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
|
||||
void DoDllPowerUpSelfTest()
|
||||
{
|
||||
CryptoPP::DoPowerUpSelfTest(NULL, s_moduleMac);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
void DoDllPowerUpSelfTest()
|
||||
{
|
||||
throw NotImplemented("DoDllPowerUpSelfTest() only available on Windows");
|
||||
}
|
||||
|
||||
#endif // #ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
|
||||
// DllMain needs to be in the global namespace
|
||||
BOOL APIENTRY DllMain(HANDLE hModule,
|
||||
DWORD ul_reason_for_call,
|
||||
LPVOID lpReserved)
|
||||
{
|
||||
if (ul_reason_for_call == DLL_PROCESS_ATTACH)
|
||||
{
|
||||
CryptoPP::s_hModule = (HMODULE)hModule;
|
||||
CryptoPP::DoDllPowerUpSelfTest();
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#endif // #ifdef CRYPTOPP_WIN32_AVAILABLE
|
||||
|
||||
#endif // #ifndef CRYPTOPP_IMPORTS
|
||||
@ -1,123 +0,0 @@
|
||||
#include "pch.h"
|
||||
#include "gost.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
// these are the S-boxes given in Applied Cryptography 2nd Ed., p. 333
|
||||
const byte GOST::Base::sBox[8][16]={
|
||||
{4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3},
|
||||
{14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9},
|
||||
{5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11},
|
||||
{7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3},
|
||||
{6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2},
|
||||
{4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14},
|
||||
{13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12},
|
||||
{1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12}};
|
||||
|
||||
/* // these are the S-boxes given in the GOST source code listing in Applied
|
||||
// Cryptography 2nd Ed., p. 644. they appear to be from the DES S-boxes
|
||||
{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
|
||||
{ 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
|
||||
{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
|
||||
{ 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
|
||||
{ 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
|
||||
{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
|
||||
{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
|
||||
{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 }};
|
||||
*/
|
||||
|
||||
volatile bool GOST::Base::sTableCalculated = false;
|
||||
word32 GOST::Base::sTable[4][256];
|
||||
|
||||
void GOST::Base::UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(length);
|
||||
|
||||
PrecalculateSTable();
|
||||
|
||||
GetUserKey(LITTLE_ENDIAN_ORDER, key.begin(), 8, userKey, KEYLENGTH);
|
||||
}
|
||||
|
||||
void GOST::Base::PrecalculateSTable()
|
||||
{
|
||||
if (!sTableCalculated)
|
||||
{
|
||||
for (unsigned i = 0; i < 4; i++)
|
||||
for (unsigned j = 0; j < 256; j++)
|
||||
{
|
||||
word32 temp = sBox[2*i][j%16] | (sBox[2*i+1][j/16] << 4);
|
||||
sTable[i][j] = rotlMod(temp, 11+8*i);
|
||||
}
|
||||
|
||||
sTableCalculated=true;
|
||||
}
|
||||
}
|
||||
|
||||
#define f(x) ( t=x, \
|
||||
sTable[3][GETBYTE(t, 3)] ^ sTable[2][GETBYTE(t, 2)] \
|
||||
^ sTable[1][GETBYTE(t, 1)] ^ sTable[0][GETBYTE(t, 0)] )
|
||||
|
||||
typedef BlockGetAndPut<word32, LittleEndian> Block;
|
||||
|
||||
void GOST::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 n1, n2, t;
|
||||
|
||||
Block::Get(inBlock)(n1)(n2);
|
||||
|
||||
for (unsigned int i=0; i<3; i++)
|
||||
{
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
}
|
||||
|
||||
n2 ^= f(n1+key[7]);
|
||||
n1 ^= f(n2+key[6]);
|
||||
n2 ^= f(n1+key[5]);
|
||||
n1 ^= f(n2+key[4]);
|
||||
n2 ^= f(n1+key[3]);
|
||||
n1 ^= f(n2+key[2]);
|
||||
n2 ^= f(n1+key[1]);
|
||||
n1 ^= f(n2+key[0]);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(n2)(n1);
|
||||
}
|
||||
|
||||
void GOST::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 n1, n2, t;
|
||||
|
||||
Block::Get(inBlock)(n1)(n2);
|
||||
|
||||
n2 ^= f(n1+key[0]);
|
||||
n1 ^= f(n2+key[1]);
|
||||
n2 ^= f(n1+key[2]);
|
||||
n1 ^= f(n2+key[3]);
|
||||
n2 ^= f(n1+key[4]);
|
||||
n1 ^= f(n2+key[5]);
|
||||
n2 ^= f(n1+key[6]);
|
||||
n1 ^= f(n2+key[7]);
|
||||
|
||||
for (unsigned int i=0; i<3; i++)
|
||||
{
|
||||
n2 ^= f(n1+key[7]);
|
||||
n1 ^= f(n2+key[6]);
|
||||
n2 ^= f(n1+key[5]);
|
||||
n1 ^= f(n2+key[4]);
|
||||
n2 ^= f(n1+key[3]);
|
||||
n1 ^= f(n2+key[2]);
|
||||
n2 ^= f(n1+key[1]);
|
||||
n1 ^= f(n2+key[0]);
|
||||
}
|
||||
|
||||
Block::Put(xorBlock, outBlock)(n2)(n1);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,58 +0,0 @@
|
||||
#ifndef CRYPTOPP_GOST_H
|
||||
#define CRYPTOPP_GOST_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct GOST_Info : public FixedBlockSize<8>, public FixedKeyLength<32>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "GOST";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#GOST">GOST</a>
|
||||
class GOST : public GOST_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<GOST_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
static void PrecalculateSTable();
|
||||
|
||||
static const byte sBox[8][16];
|
||||
static volatile bool sTableCalculated;
|
||||
static word32 sTable[4][256];
|
||||
|
||||
FixedSizeSecBlock<word32, 8> key;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef GOST::Encryption GOSTEncryption;
|
||||
typedef GOST::Decryption GOSTDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
421
CryptoPP/ida.cpp
421
CryptoPP/ida.cpp
@ -1,421 +0,0 @@
|
||||
// ida.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "ida.h"
|
||||
|
||||
#include "algebra.h"
|
||||
#include "gf2_32.h"
|
||||
#include "polynomi.h"
|
||||
#include <functional>
|
||||
|
||||
#include "polynomi.cpp"
|
||||
|
||||
ANONYMOUS_NAMESPACE_BEGIN
|
||||
static const CryptoPP::GF2_32 field;
|
||||
NAMESPACE_END
|
||||
|
||||
using namespace std;
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void RawIDA::IsolatedInitialize(const NameValuePairs ¶meters)
|
||||
{
|
||||
if (!parameters.GetIntValue("RecoveryThreshold", m_threshold))
|
||||
throw InvalidArgument("RawIDA: missing RecoveryThreshold argument");
|
||||
|
||||
if (m_threshold <= 0)
|
||||
throw InvalidArgument("RawIDA: RecoveryThreshold must be greater than 0");
|
||||
|
||||
m_lastMapPosition = m_inputChannelMap.end();
|
||||
m_channelsReady = 0;
|
||||
m_channelsFinished = 0;
|
||||
m_w.New(m_threshold);
|
||||
m_y.New(m_threshold);
|
||||
m_inputQueues.reserve(m_threshold);
|
||||
|
||||
m_outputChannelIds.clear();
|
||||
m_outputChannelIdStrings.clear();
|
||||
m_outputQueues.clear();
|
||||
|
||||
word32 outputChannelID;
|
||||
if (parameters.GetValue("OutputChannelID", outputChannelID))
|
||||
AddOutputChannel(outputChannelID);
|
||||
else
|
||||
{
|
||||
int nShares = parameters.GetIntValueWithDefault("NumberOfShares", m_threshold);
|
||||
for (int i=0; i<nShares; i++)
|
||||
AddOutputChannel(i);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int RawIDA::InsertInputChannel(word32 channelId)
|
||||
{
|
||||
if (m_lastMapPosition != m_inputChannelMap.end())
|
||||
{
|
||||
if (m_lastMapPosition->first == channelId)
|
||||
goto skipFind;
|
||||
++m_lastMapPosition;
|
||||
if (m_lastMapPosition != m_inputChannelMap.end() && m_lastMapPosition->first == channelId)
|
||||
goto skipFind;
|
||||
}
|
||||
m_lastMapPosition = m_inputChannelMap.find(channelId);
|
||||
|
||||
skipFind:
|
||||
if (m_lastMapPosition == m_inputChannelMap.end())
|
||||
{
|
||||
if (m_inputChannelIds.size() == m_threshold)
|
||||
return m_threshold;
|
||||
|
||||
m_lastMapPosition = m_inputChannelMap.insert(InputChannelMap::value_type(channelId, (unsigned int)m_inputChannelIds.size())).first;
|
||||
m_inputQueues.push_back(MessageQueue());
|
||||
m_inputChannelIds.push_back(channelId);
|
||||
|
||||
if (m_inputChannelIds.size() == m_threshold)
|
||||
PrepareInterpolation();
|
||||
}
|
||||
return m_lastMapPosition->second;
|
||||
}
|
||||
|
||||
unsigned int RawIDA::LookupInputChannel(word32 channelId) const
|
||||
{
|
||||
map<word32, unsigned int>::const_iterator it = m_inputChannelMap.find(channelId);
|
||||
if (it == m_inputChannelMap.end())
|
||||
return m_threshold;
|
||||
else
|
||||
return it->second;
|
||||
}
|
||||
|
||||
void RawIDA::ChannelData(word32 channelId, const byte *inString, size_t length, bool messageEnd)
|
||||
{
|
||||
int i = InsertInputChannel(channelId);
|
||||
if (i < m_threshold)
|
||||
{
|
||||
lword size = m_inputQueues[i].MaxRetrievable();
|
||||
m_inputQueues[i].Put(inString, length);
|
||||
if (size < 4 && size + length >= 4)
|
||||
{
|
||||
m_channelsReady++;
|
||||
if (m_channelsReady == m_threshold)
|
||||
ProcessInputQueues();
|
||||
}
|
||||
|
||||
if (messageEnd)
|
||||
{
|
||||
m_inputQueues[i].MessageEnd();
|
||||
if (m_inputQueues[i].NumberOfMessages() == 1)
|
||||
{
|
||||
m_channelsFinished++;
|
||||
if (m_channelsFinished == m_threshold)
|
||||
{
|
||||
m_channelsReady = 0;
|
||||
for (i=0; i<m_threshold; i++)
|
||||
m_channelsReady += m_inputQueues[i].AnyRetrievable();
|
||||
ProcessInputQueues();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lword RawIDA::InputBuffered(word32 channelId) const
|
||||
{
|
||||
int i = LookupInputChannel(channelId);
|
||||
return i < m_threshold ? m_inputQueues[i].MaxRetrievable() : 0;
|
||||
}
|
||||
|
||||
void RawIDA::ComputeV(unsigned int i)
|
||||
{
|
||||
if (i >= m_v.size())
|
||||
{
|
||||
m_v.resize(i+1);
|
||||
m_outputToInput.resize(i+1);
|
||||
}
|
||||
|
||||
m_outputToInput[i] = LookupInputChannel(m_outputChannelIds[i]);
|
||||
if (m_outputToInput[i] == m_threshold && i * m_threshold <= 1000*1000)
|
||||
{
|
||||
m_v[i].resize(m_threshold);
|
||||
PrepareBulkPolynomialInterpolationAt(field, m_v[i].begin(), m_outputChannelIds[i], &(m_inputChannelIds[0]), m_w.begin(), m_threshold);
|
||||
}
|
||||
}
|
||||
|
||||
void RawIDA::AddOutputChannel(word32 channelId)
|
||||
{
|
||||
m_outputChannelIds.push_back(channelId);
|
||||
m_outputChannelIdStrings.push_back(WordToString(channelId));
|
||||
m_outputQueues.push_back(ByteQueue());
|
||||
if (m_inputChannelIds.size() == m_threshold)
|
||||
ComputeV((unsigned int)m_outputChannelIds.size() - 1);
|
||||
}
|
||||
|
||||
void RawIDA::PrepareInterpolation()
|
||||
{
|
||||
assert(m_inputChannelIds.size() == m_threshold);
|
||||
PrepareBulkPolynomialInterpolation(field, m_w.begin(), &(m_inputChannelIds[0]), m_threshold);
|
||||
for (unsigned int i=0; i<m_outputChannelIds.size(); i++)
|
||||
ComputeV(i);
|
||||
}
|
||||
|
||||
void RawIDA::ProcessInputQueues()
|
||||
{
|
||||
bool finished = (m_channelsFinished == m_threshold);
|
||||
int i;
|
||||
|
||||
while (finished ? m_channelsReady > 0 : m_channelsReady == m_threshold)
|
||||
{
|
||||
m_channelsReady = 0;
|
||||
for (i=0; i<m_threshold; i++)
|
||||
{
|
||||
MessageQueue &queue = m_inputQueues[i];
|
||||
queue.GetWord32(m_y[i]);
|
||||
|
||||
if (finished)
|
||||
m_channelsReady += queue.AnyRetrievable();
|
||||
else
|
||||
m_channelsReady += queue.NumberOfMessages() > 0 || queue.MaxRetrievable() >= 4;
|
||||
}
|
||||
|
||||
for (i=0; (unsigned int)i<m_outputChannelIds.size(); i++)
|
||||
{
|
||||
if (m_outputToInput[i] != m_threshold)
|
||||
m_outputQueues[i].PutWord32(m_y[m_outputToInput[i]]);
|
||||
else if (m_v[i].size() == m_threshold)
|
||||
m_outputQueues[i].PutWord32(BulkPolynomialInterpolateAt(field, m_y.begin(), m_v[i].begin(), m_threshold));
|
||||
else
|
||||
{
|
||||
m_u.resize(m_threshold);
|
||||
PrepareBulkPolynomialInterpolationAt(field, m_u.begin(), m_outputChannelIds[i], &(m_inputChannelIds[0]), m_w.begin(), m_threshold);
|
||||
m_outputQueues[i].PutWord32(BulkPolynomialInterpolateAt(field, m_y.begin(), m_u.begin(), m_threshold));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (m_outputChannelIds.size() > 0 && m_outputQueues[0].AnyRetrievable())
|
||||
FlushOutputQueues();
|
||||
|
||||
if (finished)
|
||||
{
|
||||
OutputMessageEnds();
|
||||
|
||||
m_channelsReady = 0;
|
||||
m_channelsFinished = 0;
|
||||
m_v.clear();
|
||||
|
||||
vector<MessageQueue> inputQueues;
|
||||
vector<word32> inputChannelIds;
|
||||
|
||||
inputQueues.swap(m_inputQueues);
|
||||
inputChannelIds.swap(m_inputChannelIds);
|
||||
m_inputChannelMap.clear();
|
||||
m_lastMapPosition = m_inputChannelMap.end();
|
||||
|
||||
for (i=0; i<m_threshold; i++)
|
||||
{
|
||||
inputQueues[i].GetNextMessage();
|
||||
inputQueues[i].TransferAllTo(*AttachedTransformation(), WordToString(inputChannelIds[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RawIDA::FlushOutputQueues()
|
||||
{
|
||||
for (unsigned int i=0; i<m_outputChannelIds.size(); i++)
|
||||
m_outputQueues[i].TransferAllTo(*AttachedTransformation(), m_outputChannelIdStrings[i]);
|
||||
}
|
||||
|
||||
void RawIDA::OutputMessageEnds()
|
||||
{
|
||||
if (GetAutoSignalPropagation() != 0)
|
||||
{
|
||||
for (unsigned int i=0; i<m_outputChannelIds.size(); i++)
|
||||
AttachedTransformation()->ChannelMessageEnd(m_outputChannelIdStrings[i], GetAutoSignalPropagation()-1);
|
||||
}
|
||||
}
|
||||
|
||||
// ****************************************************************
|
||||
|
||||
void SecretSharing::IsolatedInitialize(const NameValuePairs ¶meters)
|
||||
{
|
||||
m_pad = parameters.GetValueWithDefault("AddPadding", true);
|
||||
m_ida.IsolatedInitialize(parameters);
|
||||
}
|
||||
|
||||
size_t SecretSharing::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
|
||||
{
|
||||
if (!blocking)
|
||||
throw BlockingInputOnly("SecretSharing");
|
||||
|
||||
SecByteBlock buf(UnsignedMin(256, length));
|
||||
unsigned int threshold = m_ida.GetThreshold();
|
||||
while (length > 0)
|
||||
{
|
||||
size_t len = STDMIN(length, buf.size());
|
||||
m_ida.ChannelData(0xffffffff, begin, len, false);
|
||||
for (unsigned int i=0; i<threshold-1; i++)
|
||||
{
|
||||
m_rng.GenerateBlock(buf, len);
|
||||
m_ida.ChannelData(i, buf, len, false);
|
||||
}
|
||||
length -= len;
|
||||
begin += len;
|
||||
}
|
||||
|
||||
if (messageEnd)
|
||||
{
|
||||
m_ida.SetAutoSignalPropagation(messageEnd-1);
|
||||
if (m_pad)
|
||||
{
|
||||
SecretSharing::Put(1);
|
||||
while (m_ida.InputBuffered(0xffffffff) > 0)
|
||||
SecretSharing::Put(0);
|
||||
}
|
||||
m_ida.ChannelData(0xffffffff, NULL, 0, true);
|
||||
for (unsigned int i=0; i<m_ida.GetThreshold()-1; i++)
|
||||
m_ida.ChannelData(i, NULL, 0, true);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void SecretRecovery::IsolatedInitialize(const NameValuePairs ¶meters)
|
||||
{
|
||||
m_pad = parameters.GetValueWithDefault("RemovePadding", true);
|
||||
RawIDA::IsolatedInitialize(CombinedNameValuePairs(parameters, MakeParameters("OutputChannelID", (word32)0xffffffff)));
|
||||
}
|
||||
|
||||
void SecretRecovery::FlushOutputQueues()
|
||||
{
|
||||
if (m_pad)
|
||||
m_outputQueues[0].TransferTo(*AttachedTransformation(), m_outputQueues[0].MaxRetrievable()-4);
|
||||
else
|
||||
m_outputQueues[0].TransferTo(*AttachedTransformation());
|
||||
}
|
||||
|
||||
void SecretRecovery::OutputMessageEnds()
|
||||
{
|
||||
if (m_pad)
|
||||
{
|
||||
PaddingRemover paddingRemover(new Redirector(*AttachedTransformation()));
|
||||
m_outputQueues[0].TransferAllTo(paddingRemover);
|
||||
}
|
||||
|
||||
if (GetAutoSignalPropagation() != 0)
|
||||
AttachedTransformation()->MessageEnd(GetAutoSignalPropagation()-1);
|
||||
}
|
||||
|
||||
// ****************************************************************
|
||||
|
||||
void InformationDispersal::IsolatedInitialize(const NameValuePairs ¶meters)
|
||||
{
|
||||
m_nextChannel = 0;
|
||||
m_pad = parameters.GetValueWithDefault("AddPadding", true);
|
||||
m_ida.IsolatedInitialize(parameters);
|
||||
}
|
||||
|
||||
size_t InformationDispersal::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
|
||||
{
|
||||
if (!blocking)
|
||||
throw BlockingInputOnly("InformationDispersal");
|
||||
|
||||
while (length--)
|
||||
{
|
||||
m_ida.ChannelData(m_nextChannel, begin, 1, false);
|
||||
begin++;
|
||||
m_nextChannel++;
|
||||
if (m_nextChannel == m_ida.GetThreshold())
|
||||
m_nextChannel = 0;
|
||||
}
|
||||
|
||||
if (messageEnd)
|
||||
{
|
||||
m_ida.SetAutoSignalPropagation(messageEnd-1);
|
||||
if (m_pad)
|
||||
InformationDispersal::Put(1);
|
||||
for (word32 i=0; i<m_ida.GetThreshold(); i++)
|
||||
m_ida.ChannelData(i, NULL, 0, true);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void InformationRecovery::IsolatedInitialize(const NameValuePairs ¶meters)
|
||||
{
|
||||
m_pad = parameters.GetValueWithDefault("RemovePadding", true);
|
||||
RawIDA::IsolatedInitialize(parameters);
|
||||
}
|
||||
|
||||
void InformationRecovery::FlushOutputQueues()
|
||||
{
|
||||
while (m_outputQueues[0].AnyRetrievable())
|
||||
{
|
||||
for (unsigned int i=0; i<m_outputChannelIds.size(); i++)
|
||||
m_outputQueues[i].TransferTo(m_queue, 1);
|
||||
}
|
||||
|
||||
if (m_pad)
|
||||
m_queue.TransferTo(*AttachedTransformation(), m_queue.MaxRetrievable()-4*m_threshold);
|
||||
else
|
||||
m_queue.TransferTo(*AttachedTransformation());
|
||||
}
|
||||
|
||||
void InformationRecovery::OutputMessageEnds()
|
||||
{
|
||||
if (m_pad)
|
||||
{
|
||||
PaddingRemover paddingRemover(new Redirector(*AttachedTransformation()));
|
||||
m_queue.TransferAllTo(paddingRemover);
|
||||
}
|
||||
|
||||
if (GetAutoSignalPropagation() != 0)
|
||||
AttachedTransformation()->MessageEnd(GetAutoSignalPropagation()-1);
|
||||
}
|
||||
|
||||
size_t PaddingRemover::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
|
||||
{
|
||||
if (!blocking)
|
||||
throw BlockingInputOnly("PaddingRemover");
|
||||
|
||||
const byte *const end = begin + length;
|
||||
|
||||
if (m_possiblePadding)
|
||||
{
|
||||
size_t len = find_if(begin, end, bind2nd(not_equal_to<byte>(), 0)) - begin;
|
||||
m_zeroCount += len;
|
||||
begin += len;
|
||||
if (begin == end)
|
||||
return 0;
|
||||
|
||||
AttachedTransformation()->Put(1);
|
||||
while (m_zeroCount--)
|
||||
AttachedTransformation()->Put(0);
|
||||
AttachedTransformation()->Put(*begin++);
|
||||
m_possiblePadding = false;
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) && !defined(__MWERKS__) && (_MSC_VER <= 1300)
|
||||
// VC60 and VC7 workaround: built-in reverse_iterator has two template parameters, Dinkumware only has one
|
||||
typedef reverse_bidirectional_iterator<const byte *, const byte> RevIt;
|
||||
#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
|
||||
typedef reverse_iterator<const byte *, random_access_iterator_tag, const byte> RevIt;
|
||||
#else
|
||||
typedef reverse_iterator<const byte *> RevIt;
|
||||
#endif
|
||||
const byte *x = find_if(RevIt(end), RevIt(begin), bind2nd(not_equal_to<byte>(), 0)).base();
|
||||
if (x != begin && *(x-1) == 1)
|
||||
{
|
||||
AttachedTransformation()->Put(begin, x-begin-1);
|
||||
m_possiblePadding = true;
|
||||
m_zeroCount = end - x;
|
||||
}
|
||||
else
|
||||
AttachedTransformation()->Put(begin, end-begin);
|
||||
|
||||
if (messageEnd)
|
||||
{
|
||||
m_possiblePadding = false;
|
||||
Output(0, begin, length, messageEnd, blocking);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
152
CryptoPP/ida.h
152
CryptoPP/ida.h
@ -1,152 +0,0 @@
|
||||
#ifndef CRYPTOPP_IDA_H
|
||||
#define CRYPTOPP_IDA_H
|
||||
|
||||
#include "mqueue.h"
|
||||
#include "filters.h"
|
||||
#include "channels.h"
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
/// base class for secret sharing and information dispersal
|
||||
class RawIDA : public AutoSignaling<Unflushable<Multichannel<Filter> > >
|
||||
{
|
||||
public:
|
||||
RawIDA(BufferedTransformation *attachment=NULL)
|
||||
{Detach(attachment);}
|
||||
|
||||
unsigned int GetThreshold() const {return m_threshold;}
|
||||
void AddOutputChannel(word32 channelId);
|
||||
void ChannelData(word32 channelId, const byte *inString, size_t length, bool messageEnd);
|
||||
lword InputBuffered(word32 channelId) const;
|
||||
|
||||
void IsolatedInitialize(const NameValuePairs ¶meters=g_nullNameValuePairs);
|
||||
size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
|
||||
{
|
||||
if (!blocking)
|
||||
throw BlockingInputOnly("RawIDA");
|
||||
ChannelData(StringToWord<word32>(channel), begin, length, messageEnd != 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual void FlushOutputQueues();
|
||||
virtual void OutputMessageEnds();
|
||||
|
||||
unsigned int InsertInputChannel(word32 channelId);
|
||||
unsigned int LookupInputChannel(word32 channelId) const;
|
||||
void ComputeV(unsigned int);
|
||||
void PrepareInterpolation();
|
||||
void ProcessInputQueues();
|
||||
|
||||
typedef std::map<word32, unsigned int> InputChannelMap;
|
||||
InputChannelMap m_inputChannelMap;
|
||||
InputChannelMap::iterator m_lastMapPosition;
|
||||
std::vector<MessageQueue> m_inputQueues;
|
||||
std::vector<word32> m_inputChannelIds, m_outputChannelIds, m_outputToInput;
|
||||
std::vector<std::string> m_outputChannelIdStrings;
|
||||
std::vector<ByteQueue> m_outputQueues;
|
||||
int m_threshold;
|
||||
unsigned int m_channelsReady, m_channelsFinished;
|
||||
std::vector<SecBlock<word32> > m_v;
|
||||
SecBlock<word32> m_u, m_w, m_y;
|
||||
};
|
||||
|
||||
/// a variant of Shamir's Secret Sharing Algorithm
|
||||
class SecretSharing : public CustomFlushPropagation<Filter>
|
||||
{
|
||||
public:
|
||||
SecretSharing(RandomNumberGenerator &rng, int threshold, int nShares, BufferedTransformation *attachment=NULL, bool addPadding=true)
|
||||
: m_rng(rng), m_ida(new OutputProxy(*this, true))
|
||||
{
|
||||
Detach(attachment);
|
||||
IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("NumberOfShares", nShares)("AddPadding", addPadding));
|
||||
}
|
||||
|
||||
void IsolatedInitialize(const NameValuePairs ¶meters=g_nullNameValuePairs);
|
||||
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
|
||||
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) {return m_ida.Flush(hardFlush, propagation, blocking);}
|
||||
|
||||
protected:
|
||||
RandomNumberGenerator &m_rng;
|
||||
RawIDA m_ida;
|
||||
bool m_pad;
|
||||
};
|
||||
|
||||
/// a variant of Shamir's Secret Sharing Algorithm
|
||||
class SecretRecovery : public RawIDA
|
||||
{
|
||||
public:
|
||||
SecretRecovery(int threshold, BufferedTransformation *attachment=NULL, bool removePadding=true)
|
||||
: RawIDA(attachment)
|
||||
{IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("RemovePadding", removePadding));}
|
||||
|
||||
void IsolatedInitialize(const NameValuePairs ¶meters=g_nullNameValuePairs);
|
||||
|
||||
protected:
|
||||
void FlushOutputQueues();
|
||||
void OutputMessageEnds();
|
||||
|
||||
bool m_pad;
|
||||
};
|
||||
|
||||
/// a variant of Rabin's Information Dispersal Algorithm
|
||||
class InformationDispersal : public CustomFlushPropagation<Filter>
|
||||
{
|
||||
public:
|
||||
InformationDispersal(int threshold, int nShares, BufferedTransformation *attachment=NULL, bool addPadding=true)
|
||||
: m_ida(new OutputProxy(*this, true))
|
||||
{
|
||||
Detach(attachment);
|
||||
IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("NumberOfShares", nShares)("AddPadding", addPadding));
|
||||
}
|
||||
|
||||
void IsolatedInitialize(const NameValuePairs ¶meters=g_nullNameValuePairs);
|
||||
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
|
||||
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) {return m_ida.Flush(hardFlush, propagation, blocking);}
|
||||
|
||||
protected:
|
||||
RawIDA m_ida;
|
||||
bool m_pad;
|
||||
unsigned int m_nextChannel;
|
||||
};
|
||||
|
||||
/// a variant of Rabin's Information Dispersal Algorithm
|
||||
class InformationRecovery : public RawIDA
|
||||
{
|
||||
public:
|
||||
InformationRecovery(int threshold, BufferedTransformation *attachment=NULL, bool removePadding=true)
|
||||
: RawIDA(attachment)
|
||||
{IsolatedInitialize(MakeParameters("RecoveryThreshold", threshold)("RemovePadding", removePadding));}
|
||||
|
||||
void IsolatedInitialize(const NameValuePairs ¶meters=g_nullNameValuePairs);
|
||||
|
||||
protected:
|
||||
void FlushOutputQueues();
|
||||
void OutputMessageEnds();
|
||||
|
||||
bool m_pad;
|
||||
ByteQueue m_queue;
|
||||
};
|
||||
|
||||
class PaddingRemover : public Unflushable<Filter>
|
||||
{
|
||||
public:
|
||||
PaddingRemover(BufferedTransformation *attachment=NULL)
|
||||
: m_possiblePadding(false) {Detach(attachment);}
|
||||
|
||||
void IsolatedInitialize(const NameValuePairs ¶meters) {m_possiblePadding = false;}
|
||||
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
|
||||
|
||||
// GetPossiblePadding() == false at the end of a message indicates incorrect padding
|
||||
bool GetPossiblePadding() const {return m_possiblePadding;}
|
||||
|
||||
private:
|
||||
bool m_possiblePadding;
|
||||
lword m_zeroCount;
|
||||
};
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,192 +0,0 @@
|
||||
// idea.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "idea.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
static const int IDEA_KEYLEN=(6*IDEA::ROUNDS+4); // key schedule length in # of word16s
|
||||
|
||||
#define low16(x) ((x)&0xffff) // compiler should be able to optimize this away if word is 16 bits
|
||||
#define high16(x) ((x)>>16)
|
||||
|
||||
CRYPTOPP_COMPILE_ASSERT(sizeof(IDEA::Word) >= 2);
|
||||
|
||||
// should use an inline function but macros are still faster in MSVC 4.0
|
||||
#define DirectMUL(a,b) \
|
||||
{ \
|
||||
assert(b <= 0xffff); \
|
||||
\
|
||||
word32 p=(word32)low16(a)*b; \
|
||||
\
|
||||
if (p) \
|
||||
{ \
|
||||
p = low16(p) - high16(p); \
|
||||
a = (IDEA::Word)p - (IDEA::Word)high16(p); \
|
||||
} \
|
||||
else \
|
||||
a = 1-a-b; \
|
||||
}
|
||||
|
||||
#ifdef IDEA_LARGECACHE
|
||||
volatile bool IDEA::Base::tablesBuilt = false;
|
||||
word16 IDEA::Base::log[0x10000];
|
||||
word16 IDEA::Base::antilog[0x10000];
|
||||
|
||||
void IDEA::Base::BuildLogTables()
|
||||
{
|
||||
if (tablesBuilt)
|
||||
return;
|
||||
else
|
||||
{
|
||||
tablesBuilt = true;
|
||||
|
||||
IDEA::Word x=1;
|
||||
word32 i;
|
||||
|
||||
for (i=0; i<0x10000; i++)
|
||||
{
|
||||
antilog[i] = (word16)x;
|
||||
DirectMUL(x, 3);
|
||||
}
|
||||
|
||||
for (i=0; i<0x10000; i++)
|
||||
log[antilog[i]] = (word16)i;
|
||||
}
|
||||
}
|
||||
|
||||
void IDEA::Base::LookupKeyLogs()
|
||||
{
|
||||
IDEA::Word* Z=key;
|
||||
int r=ROUNDS;
|
||||
do
|
||||
{
|
||||
Z[0] = log[Z[0]];
|
||||
Z[3] = log[Z[3]];
|
||||
Z[4] = log[Z[4]];
|
||||
Z[5] = log[Z[5]];
|
||||
Z+=6;
|
||||
} while (--r);
|
||||
Z[0] = log[Z[0]];
|
||||
Z[3] = log[Z[3]];
|
||||
}
|
||||
|
||||
inline void IDEA::Base::LookupMUL(IDEA::Word &a, IDEA::Word b)
|
||||
{
|
||||
a = antilog[low16(log[low16(a)]+b)];
|
||||
}
|
||||
#endif // IDEA_LARGECACHE
|
||||
|
||||
void IDEA::Base::UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(length);
|
||||
|
||||
#ifdef IDEA_LARGECACHE
|
||||
BuildLogTables();
|
||||
#endif
|
||||
|
||||
EnKey(userKey);
|
||||
|
||||
if (!IsForwardTransformation())
|
||||
DeKey();
|
||||
|
||||
#ifdef IDEA_LARGECACHE
|
||||
LookupKeyLogs();
|
||||
#endif
|
||||
}
|
||||
|
||||
void IDEA::Base::EnKey (const byte *userKey)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i=0; i<8; i++)
|
||||
m_key[i] = ((IDEA::Word)userKey[2*i]<<8) | userKey[2*i+1];
|
||||
|
||||
for (; i<IDEA_KEYLEN; i++)
|
||||
{
|
||||
unsigned int j = RoundDownToMultipleOf(i,8U)-8;
|
||||
m_key[i] = low16((m_key[j+(i+1)%8] << 9) | (m_key[j+(i+2)%8] >> 7));
|
||||
}
|
||||
}
|
||||
|
||||
static IDEA::Word MulInv(IDEA::Word x)
|
||||
{
|
||||
IDEA::Word y=x;
|
||||
for (unsigned i=0; i<15; i++)
|
||||
{
|
||||
DirectMUL(y,low16(y));
|
||||
DirectMUL(y,x);
|
||||
}
|
||||
return low16(y);
|
||||
}
|
||||
|
||||
static inline IDEA::Word AddInv(IDEA::Word x)
|
||||
{
|
||||
return low16(0-x);
|
||||
}
|
||||
|
||||
void IDEA::Base::DeKey()
|
||||
{
|
||||
FixedSizeSecBlock<IDEA::Word, 6*ROUNDS+4> tempkey;
|
||||
size_t i;
|
||||
|
||||
for (i=0; i<ROUNDS; i++)
|
||||
{
|
||||
tempkey[i*6+0] = MulInv(m_key[(ROUNDS-i)*6+0]);
|
||||
tempkey[i*6+1] = AddInv(m_key[(ROUNDS-i)*6+1+(i>0)]);
|
||||
tempkey[i*6+2] = AddInv(m_key[(ROUNDS-i)*6+2-(i>0)]);
|
||||
tempkey[i*6+3] = MulInv(m_key[(ROUNDS-i)*6+3]);
|
||||
tempkey[i*6+4] = m_key[(ROUNDS-1-i)*6+4];
|
||||
tempkey[i*6+5] = m_key[(ROUNDS-1-i)*6+5];
|
||||
}
|
||||
|
||||
tempkey[i*6+0] = MulInv(m_key[(ROUNDS-i)*6+0]);
|
||||
tempkey[i*6+1] = AddInv(m_key[(ROUNDS-i)*6+1]);
|
||||
tempkey[i*6+2] = AddInv(m_key[(ROUNDS-i)*6+2]);
|
||||
tempkey[i*6+3] = MulInv(m_key[(ROUNDS-i)*6+3]);
|
||||
|
||||
m_key = tempkey;
|
||||
}
|
||||
|
||||
#ifdef IDEA_LARGECACHE
|
||||
#define MUL(a,b) LookupMUL(a,b)
|
||||
#else
|
||||
#define MUL(a,b) DirectMUL(a,b)
|
||||
#endif
|
||||
|
||||
void IDEA::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
typedef BlockGetAndPut<word16, BigEndian> Block;
|
||||
|
||||
const IDEA::Word *key = m_key;
|
||||
IDEA::Word x0,x1,x2,x3,t0,t1;
|
||||
Block::Get(inBlock)(x0)(x1)(x2)(x3);
|
||||
|
||||
for (unsigned int i=0; i<ROUNDS; i++)
|
||||
{
|
||||
MUL(x0, key[i*6+0]);
|
||||
x1 += key[i*6+1];
|
||||
x2 += key[i*6+2];
|
||||
MUL(x3, key[i*6+3]);
|
||||
t0 = x0^x2;
|
||||
MUL(t0, key[i*6+4]);
|
||||
t1 = t0 + (x1^x3);
|
||||
MUL(t1, key[i*6+5]);
|
||||
t0 += t1;
|
||||
x0 ^= t1;
|
||||
x3 ^= t0;
|
||||
t0 ^= x1;
|
||||
x1 = x2^t1;
|
||||
x2 = t0;
|
||||
}
|
||||
|
||||
MUL(x0, key[ROUNDS*6+0]);
|
||||
x2 += key[ROUNDS*6+1];
|
||||
x1 += key[ROUNDS*6+2];
|
||||
MUL(x3, key[ROUNDS*6+3]);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(x0)(x2)(x1)(x3);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,61 +0,0 @@
|
||||
#ifndef CRYPTOPP_IDEA_H
|
||||
#define CRYPTOPP_IDEA_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct IDEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public FixedRounds<8>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "IDEA";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#IDEA">IDEA</a>
|
||||
class IDEA : public IDEA_Info, public BlockCipherDocumentation
|
||||
{
|
||||
public: // made public for internal purposes
|
||||
#ifdef CRYPTOPP_NATIVE_DWORD_AVAILABLE
|
||||
typedef word Word;
|
||||
#else
|
||||
typedef hword Word;
|
||||
#endif
|
||||
|
||||
private:
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<IDEA_Info>
|
||||
{
|
||||
public:
|
||||
unsigned int OptimalDataAlignment() const {return 2;}
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
private:
|
||||
void EnKey(const byte *);
|
||||
void DeKey();
|
||||
FixedSizeSecBlock<Word, 6*ROUNDS+4> m_key;
|
||||
|
||||
#ifdef IDEA_LARGECACHE
|
||||
static inline void LookupMUL(word &a, word b);
|
||||
void LookupKeyLogs();
|
||||
static void BuildLogTables();
|
||||
static volatile bool tablesBuilt;
|
||||
static word16 log[0x10000], antilog[0x10000];
|
||||
#endif
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
|
||||
};
|
||||
|
||||
typedef IDEA::Encryption IDEAEncryption;
|
||||
typedef IDEA::Decryption IDEADecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,154 +0,0 @@
|
||||
// mars.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
// includes IBM's key setup "tweak" proposed in August 1999 (http://www.research.ibm.com/security/key-setup.txt)
|
||||
|
||||
#include "pch.h"
|
||||
#include "mars.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void MARS::Base::UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(length);
|
||||
|
||||
// Initialize T[] with the key data
|
||||
FixedSizeSecBlock<word32, 15> T;
|
||||
GetUserKey(LITTLE_ENDIAN_ORDER, T.begin(), 15, userKey, length);
|
||||
T[length/4] = length/4;
|
||||
|
||||
for (unsigned int j=0; j<4; j++) // compute 10 words of K[] in each iteration
|
||||
{
|
||||
unsigned int i;
|
||||
// Do linear transformation
|
||||
for (i=0; i<15; i++)
|
||||
T[i] = T[i] ^ rotlFixed(T[(i+8)%15] ^ T[(i+13)%15], 3) ^ (4*i+j);
|
||||
|
||||
// Do four rounds of stirring
|
||||
for (unsigned int k=0; k<4; k++)
|
||||
for (i=0; i<15; i++)
|
||||
T[i] = rotlFixed(T[i] + Sbox[T[(i+14)%15]%512], 9);
|
||||
|
||||
// Store next 10 key words into K[]
|
||||
for (i=0; i<10; i++)
|
||||
m_k[10*j+i] = T[4*i%15];
|
||||
}
|
||||
|
||||
// Modify multiplication key-words
|
||||
for(unsigned int i = 5; i < 37; i += 2)
|
||||
{
|
||||
word32 m, w = m_k[i] | 3;
|
||||
m = (~w ^ (w<<1)) & (~w ^ (w>>1)) & 0x7ffffffe;
|
||||
m &= m>>1; m &= m>>2; m &= m>>4;
|
||||
m |= m<<1; m |= m<<2; m |= m<<4;
|
||||
m &= 0x7ffffffc;
|
||||
w ^= rotlMod(Sbox[265 + (m_k[i] & 3)], m_k[i-1]) & m;
|
||||
m_k[i] = w;
|
||||
}
|
||||
}
|
||||
|
||||
#define S(a) Sbox[(a)&0x1ff]
|
||||
#define S0(a) Sbox[(a)&0xff]
|
||||
#define S1(a) Sbox[((a)&0xff) + 256]
|
||||
|
||||
typedef BlockGetAndPut<word32, LittleEndian> Block;
|
||||
|
||||
void MARS::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
unsigned int i;
|
||||
word32 a, b, c, d, l, m, r, t;
|
||||
const word32 *k = m_k;
|
||||
|
||||
Block::Get(inBlock)(a)(b)(c)(d);
|
||||
|
||||
a += k[0]; b += k[1]; c += k[2]; d += k[3];
|
||||
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
b = (b ^ S0(a)) + S1(a>>8);
|
||||
c += S0(a>>16);
|
||||
a = rotrFixed(a, 24);
|
||||
d ^= S1(a);
|
||||
a += (i%4==0) ? d : 0;
|
||||
a += (i%4==1) ? b : 0;
|
||||
t = a; a = b; b = c; c = d; d = t;
|
||||
}
|
||||
|
||||
for (i=0; i<16; i++)
|
||||
{
|
||||
t = rotlFixed(a, 13);
|
||||
r = rotlFixed(t * k[2*i+5], 10);
|
||||
m = a + k[2*i+4];
|
||||
l = rotlMod((S(m) ^ rotrFixed(r, 5) ^ r), r);
|
||||
c += rotlMod(m, rotrFixed(r, 5));
|
||||
(i<8 ? b : d) += l;
|
||||
(i<8 ? d : b) ^= r;
|
||||
a = b; b = c; c = d; d = t;
|
||||
}
|
||||
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
a -= (i%4==2) ? d : 0;
|
||||
a -= (i%4==3) ? b : 0;
|
||||
b ^= S1(a);
|
||||
c -= S0(a>>24);
|
||||
t = rotlFixed(a, 24);
|
||||
d = (d - S1(a>>16)) ^ S0(t);
|
||||
a = b; b = c; c = d; d = t;
|
||||
}
|
||||
|
||||
a -= k[36]; b -= k[37]; c -= k[38]; d -= k[39];
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a)(b)(c)(d);
|
||||
}
|
||||
|
||||
void MARS::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
unsigned int i;
|
||||
word32 a, b, c, d, l, m, r, t;
|
||||
const word32 *k = m_k;
|
||||
|
||||
Block::Get(inBlock)(d)(c)(b)(a);
|
||||
|
||||
d += k[36]; c += k[37]; b += k[38]; a += k[39];
|
||||
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
b = (b ^ S0(a)) + S1(a>>8);
|
||||
c += S0(a>>16);
|
||||
a = rotrFixed(a, 24);
|
||||
d ^= S1(a);
|
||||
a += (i%4==0) ? d : 0;
|
||||
a += (i%4==1) ? b : 0;
|
||||
t = a; a = b; b = c; c = d; d = t;
|
||||
}
|
||||
|
||||
for (i=0; i<16; i++)
|
||||
{
|
||||
t = rotrFixed(a, 13);
|
||||
r = rotlFixed(a * k[35-2*i], 10);
|
||||
m = t + k[34-2*i];
|
||||
l = rotlMod((S(m) ^ rotrFixed(r, 5) ^ r), r);
|
||||
c -= rotlMod(m, rotrFixed(r, 5));
|
||||
(i<8 ? b : d) -= l;
|
||||
(i<8 ? d : b) ^= r;
|
||||
a = b; b = c; c = d; d = t;
|
||||
}
|
||||
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
a -= (i%4==2) ? d : 0;
|
||||
a -= (i%4==3) ? b : 0;
|
||||
b ^= S1(a);
|
||||
c -= S0(a>>24);
|
||||
t = rotlFixed(a, 24);
|
||||
d = (d - S1(a>>16)) ^ S0(t);
|
||||
a = b; b = c; c = d; d = t;
|
||||
}
|
||||
|
||||
d -= k[0]; c -= k[1]; b -= k[2]; a -= k[3];
|
||||
|
||||
Block::Put(xorBlock, outBlock)(d)(c)(b)(a);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,54 +0,0 @@
|
||||
#ifndef CRYPTOPP_MARS_H
|
||||
#define CRYPTOPP_MARS_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct MARS_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 56, 4>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "MARS";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#MARS">MARS</a>
|
||||
class MARS : public MARS_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<MARS_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
static const word32 Sbox[512];
|
||||
|
||||
FixedSizeSecBlock<word32, 40> m_k;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef MARS::Encryption MARSEncryption;
|
||||
typedef MARS::Decryption MARSDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,139 +0,0 @@
|
||||
// MARS S-Box
|
||||
|
||||
#include "pch.h"
|
||||
#include "mars.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
const word32 MARS::Base::Sbox[512] = {
|
||||
0x09d0c479, 0x28c8ffe0, 0x84aa6c39, 0x9dad7287,
|
||||
0x7dff9be3, 0xd4268361, 0xc96da1d4, 0x7974cc93,
|
||||
0x85d0582e, 0x2a4b5705, 0x1ca16a62, 0xc3bd279d,
|
||||
0x0f1f25e5, 0x5160372f, 0xc695c1fb, 0x4d7ff1e4,
|
||||
0xae5f6bf4, 0x0d72ee46, 0xff23de8a, 0xb1cf8e83,
|
||||
0xf14902e2, 0x3e981e42, 0x8bf53eb6, 0x7f4bf8ac,
|
||||
0x83631f83, 0x25970205, 0x76afe784, 0x3a7931d4,
|
||||
0x4f846450, 0x5c64c3f6, 0x210a5f18, 0xc6986a26,
|
||||
0x28f4e826, 0x3a60a81c, 0xd340a664, 0x7ea820c4,
|
||||
0x526687c5, 0x7eddd12b, 0x32a11d1d, 0x9c9ef086,
|
||||
0x80f6e831, 0xab6f04ad, 0x56fb9b53, 0x8b2e095c,
|
||||
0xb68556ae, 0xd2250b0d, 0x294a7721, 0xe21fb253,
|
||||
0xae136749, 0xe82aae86, 0x93365104, 0x99404a66,
|
||||
0x78a784dc, 0xb69ba84b, 0x04046793, 0x23db5c1e,
|
||||
0x46cae1d6, 0x2fe28134, 0x5a223942, 0x1863cd5b,
|
||||
0xc190c6e3, 0x07dfb846, 0x6eb88816, 0x2d0dcc4a,
|
||||
0xa4ccae59, 0x3798670d, 0xcbfa9493, 0x4f481d45,
|
||||
0xeafc8ca8, 0xdb1129d6, 0xb0449e20, 0x0f5407fb,
|
||||
0x6167d9a8, 0xd1f45763, 0x4daa96c3, 0x3bec5958,
|
||||
0xababa014, 0xb6ccd201, 0x38d6279f, 0x02682215,
|
||||
0x8f376cd5, 0x092c237e, 0xbfc56593, 0x32889d2c,
|
||||
0x854b3e95, 0x05bb9b43, 0x7dcd5dcd, 0xa02e926c,
|
||||
0xfae527e5, 0x36a1c330, 0x3412e1ae, 0xf257f462,
|
||||
0x3c4f1d71, 0x30a2e809, 0x68e5f551, 0x9c61ba44,
|
||||
0x5ded0ab8, 0x75ce09c8, 0x9654f93e, 0x698c0cca,
|
||||
0x243cb3e4, 0x2b062b97, 0x0f3b8d9e, 0x00e050df,
|
||||
0xfc5d6166, 0xe35f9288, 0xc079550d, 0x0591aee8,
|
||||
0x8e531e74, 0x75fe3578, 0x2f6d829a, 0xf60b21ae,
|
||||
0x95e8eb8d, 0x6699486b, 0x901d7d9b, 0xfd6d6e31,
|
||||
0x1090acef, 0xe0670dd8, 0xdab2e692, 0xcd6d4365,
|
||||
0xe5393514, 0x3af345f0, 0x6241fc4d, 0x460da3a3,
|
||||
0x7bcf3729, 0x8bf1d1e0, 0x14aac070, 0x1587ed55,
|
||||
0x3afd7d3e, 0xd2f29e01, 0x29a9d1f6, 0xefb10c53,
|
||||
0xcf3b870f, 0xb414935c, 0x664465ed, 0x024acac7,
|
||||
0x59a744c1, 0x1d2936a7, 0xdc580aa6, 0xcf574ca8,
|
||||
0x040a7a10, 0x6cd81807, 0x8a98be4c, 0xaccea063,
|
||||
0xc33e92b5, 0xd1e0e03d, 0xb322517e, 0x2092bd13,
|
||||
0x386b2c4a, 0x52e8dd58, 0x58656dfb, 0x50820371,
|
||||
0x41811896, 0xe337ef7e, 0xd39fb119, 0xc97f0df6,
|
||||
0x68fea01b, 0xa150a6e5, 0x55258962, 0xeb6ff41b,
|
||||
0xd7c9cd7a, 0xa619cd9e, 0xbcf09576, 0x2672c073,
|
||||
0xf003fb3c, 0x4ab7a50b, 0x1484126a, 0x487ba9b1,
|
||||
0xa64fc9c6, 0xf6957d49, 0x38b06a75, 0xdd805fcd,
|
||||
0x63d094cf, 0xf51c999e, 0x1aa4d343, 0xb8495294,
|
||||
0xce9f8e99, 0xbffcd770, 0xc7c275cc, 0x378453a7,
|
||||
0x7b21be33, 0x397f41bd, 0x4e94d131, 0x92cc1f98,
|
||||
0x5915ea51, 0x99f861b7, 0xc9980a88, 0x1d74fd5f,
|
||||
0xb0a495f8, 0x614deed0, 0xb5778eea, 0x5941792d,
|
||||
0xfa90c1f8, 0x33f824b4, 0xc4965372, 0x3ff6d550,
|
||||
0x4ca5fec0, 0x8630e964, 0x5b3fbbd6, 0x7da26a48,
|
||||
0xb203231a, 0x04297514, 0x2d639306, 0x2eb13149,
|
||||
0x16a45272, 0x532459a0, 0x8e5f4872, 0xf966c7d9,
|
||||
0x07128dc0, 0x0d44db62, 0xafc8d52d, 0x06316131,
|
||||
0xd838e7ce, 0x1bc41d00, 0x3a2e8c0f, 0xea83837e,
|
||||
0xb984737d, 0x13ba4891, 0xc4f8b949, 0xa6d6acb3,
|
||||
0xa215cdce, 0x8359838b, 0x6bd1aa31, 0xf579dd52,
|
||||
0x21b93f93, 0xf5176781, 0x187dfdde, 0xe94aeb76,
|
||||
0x2b38fd54, 0x431de1da, 0xab394825, 0x9ad3048f,
|
||||
0xdfea32aa, 0x659473e3, 0x623f7863, 0xf3346c59,
|
||||
0xab3ab685, 0x3346a90b, 0x6b56443e, 0xc6de01f8,
|
||||
0x8d421fc0, 0x9b0ed10c, 0x88f1a1e9, 0x54c1f029,
|
||||
0x7dead57b, 0x8d7ba426, 0x4cf5178a, 0x551a7cca,
|
||||
0x1a9a5f08, 0xfcd651b9, 0x25605182, 0xe11fc6c3,
|
||||
0xb6fd9676, 0x337b3027, 0xb7c8eb14, 0x9e5fd030,
|
||||
0x6b57e354, 0xad913cf7, 0x7e16688d, 0x58872a69,
|
||||
0x2c2fc7df, 0xe389ccc6, 0x30738df1, 0x0824a734,
|
||||
0xe1797a8b, 0xa4a8d57b, 0x5b5d193b, 0xc8a8309b,
|
||||
0x73f9a978, 0x73398d32, 0x0f59573e, 0xe9df2b03,
|
||||
0xe8a5b6c8, 0x848d0704, 0x98df93c2, 0x720a1dc3,
|
||||
0x684f259a, 0x943ba848, 0xa6370152, 0x863b5ea3,
|
||||
0xd17b978b, 0x6d9b58ef, 0x0a700dd4, 0xa73d36bf,
|
||||
0x8e6a0829, 0x8695bc14, 0xe35b3447, 0x933ac568,
|
||||
0x8894b022, 0x2f511c27, 0xddfbcc3c, 0x006662b6,
|
||||
0x117c83fe, 0x4e12b414, 0xc2bca766, 0x3a2fec10,
|
||||
0xf4562420, 0x55792e2a, 0x46f5d857, 0xceda25ce,
|
||||
0xc3601d3b, 0x6c00ab46, 0xefac9c28, 0xb3c35047,
|
||||
0x611dfee3, 0x257c3207, 0xfdd58482, 0x3b14d84f,
|
||||
0x23becb64, 0xa075f3a3, 0x088f8ead, 0x07adf158,
|
||||
0x7796943c, 0xfacabf3d, 0xc09730cd, 0xf7679969,
|
||||
0xda44e9ed, 0x2c854c12, 0x35935fa3, 0x2f057d9f,
|
||||
0x690624f8, 0x1cb0bafd, 0x7b0dbdc6, 0x810f23bb,
|
||||
0xfa929a1a, 0x6d969a17, 0x6742979b, 0x74ac7d05,
|
||||
0x010e65c4, 0x86a3d963, 0xf907b5a0, 0xd0042bd3,
|
||||
0x158d7d03, 0x287a8255, 0xbba8366f, 0x096edc33,
|
||||
0x21916a7b, 0x77b56b86, 0x951622f9, 0xa6c5e650,
|
||||
0x8cea17d1, 0xcd8c62bc, 0xa3d63433, 0x358a68fd,
|
||||
0x0f9b9d3c, 0xd6aa295b, 0xfe33384a, 0xc000738e,
|
||||
0xcd67eb2f, 0xe2eb6dc2, 0x97338b02, 0x06c9f246,
|
||||
0x419cf1ad, 0x2b83c045, 0x3723f18a, 0xcb5b3089,
|
||||
0x160bead7, 0x5d494656, 0x35f8a74b, 0x1e4e6c9e,
|
||||
0x000399bd, 0x67466880, 0xb4174831, 0xacf423b2,
|
||||
0xca815ab3, 0x5a6395e7, 0x302a67c5, 0x8bdb446b,
|
||||
0x108f8fa4, 0x10223eda, 0x92b8b48b, 0x7f38d0ee,
|
||||
0xab2701d4, 0x0262d415, 0xaf224a30, 0xb3d88aba,
|
||||
0xf8b2c3af, 0xdaf7ef70, 0xcc97d3b7, 0xe9614b6c,
|
||||
0x2baebff4, 0x70f687cf, 0x386c9156, 0xce092ee5,
|
||||
0x01e87da6, 0x6ce91e6a, 0xbb7bcc84, 0xc7922c20,
|
||||
0x9d3b71fd, 0x060e41c6, 0xd7590f15, 0x4e03bb47,
|
||||
0x183c198e, 0x63eeb240, 0x2ddbf49a, 0x6d5cba54,
|
||||
0x923750af, 0xf9e14236, 0x7838162b, 0x59726c72,
|
||||
0x81b66760, 0xbb2926c1, 0x48a0ce0d, 0xa6c0496d,
|
||||
0xad43507b, 0x718d496a, 0x9df057af, 0x44b1bde6,
|
||||
0x054356dc, 0xde7ced35, 0xd51a138b, 0x62088cc9,
|
||||
0x35830311, 0xc96efca2, 0x686f86ec, 0x8e77cb68,
|
||||
0x63e1d6b8, 0xc80f9778, 0x79c491fd, 0x1b4c67f2,
|
||||
0x72698d7d, 0x5e368c31, 0xf7d95e2e, 0xa1d3493f,
|
||||
0xdcd9433e, 0x896f1552, 0x4bc4ca7a, 0xa6d1baf4,
|
||||
0xa5a96dcc, 0x0bef8b46, 0xa169fda7, 0x74df40b7,
|
||||
0x4e208804, 0x9a756607, 0x038e87c8, 0x20211e44,
|
||||
0x8b7ad4bf, 0xc6403f35, 0x1848e36d, 0x80bdb038,
|
||||
0x1e62891c, 0x643d2107, 0xbf04d6f8, 0x21092c8c,
|
||||
0xf644f389, 0x0778404e, 0x7b78adb8, 0xa2c52d53,
|
||||
0x42157abe, 0xa2253e2e, 0x7bf3f4ae, 0x80f594f9,
|
||||
0x953194e7, 0x77eb92ed, 0xb3816930, 0xda8d9336,
|
||||
0xbf447469, 0xf26d9483, 0xee6faed5, 0x71371235,
|
||||
0xde425f73, 0xb4e59f43, 0x7dbe2d4e, 0x2d37b185,
|
||||
0x49dc9a63, 0x98c39d98, 0x1301c9a2, 0x389b1bbf,
|
||||
0x0c18588d, 0xa421c1ba, 0x7aa3865c, 0x71e08558,
|
||||
0x3c5cfcaa, 0x7d239ca4, 0x0297d9dd, 0xd7dc2830,
|
||||
0x4b37802b, 0x7428ab54, 0xaeee0347, 0x4b3fbb85,
|
||||
0x692f2f08, 0x134e578e, 0x36d9e0bf, 0xae8b5fcf,
|
||||
0xedb93ecf, 0x2b27248e, 0x170eb1ef, 0x7dc57fd6,
|
||||
0x1e760f16, 0xb1136601, 0x864e1b9b, 0xd7ea7319,
|
||||
0x3ab871bd, 0xcfa4d76f, 0xe31bd782, 0x0dbeb469,
|
||||
0xabb96061, 0x5370f85d, 0xffb07e37, 0xda30d0fb,
|
||||
0xebc977b6, 0x0b98b40f, 0x3a4d0fe6, 0xdf4fc26b,
|
||||
0x159cf22a, 0xc298d6e2, 0x2b78ef6a, 0x61a94ac0,
|
||||
0xab561187, 0x14eea0f0, 0xdf0d4164, 0x19af70ee
|
||||
};
|
||||
|
||||
NAMESPACE_END
|
||||
118
CryptoPP/rc2.cpp
118
CryptoPP/rc2.cpp
@ -1,118 +0,0 @@
|
||||
// rc2.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "rc2.h"
|
||||
#include "misc.h"
|
||||
#include "argnames.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void RC2::Base::UncheckedSetKey(const byte *key, unsigned int keyLen, const NameValuePairs ¶ms)
|
||||
{
|
||||
AssertValidKeyLength(keyLen);
|
||||
|
||||
int effectiveLen = params.GetIntValueWithDefault(Name::EffectiveKeyLength(), DEFAULT_EFFECTIVE_KEYLENGTH);
|
||||
if (effectiveLen > MAX_EFFECTIVE_KEYLENGTH)
|
||||
throw InvalidArgument("RC2: effective key length parameter exceeds maximum");
|
||||
|
||||
static const unsigned char PITABLE[256] = {
|
||||
217,120,249,196, 25,221,181,237, 40,233,253,121, 74,160,216,157,
|
||||
198,126, 55,131, 43,118, 83,142, 98, 76,100,136, 68,139,251,162,
|
||||
23,154, 89,245,135,179, 79, 19, 97, 69,109,141, 9,129,125, 50,
|
||||
189,143, 64,235,134,183,123, 11,240,149, 33, 34, 92,107, 78,130,
|
||||
84,214,101,147,206, 96,178, 28,115, 86,192, 20,167,140,241,220,
|
||||
18,117,202, 31, 59,190,228,209, 66, 61,212, 48,163, 60,182, 38,
|
||||
111,191, 14,218, 70,105, 7, 87, 39,242, 29,155,188,148, 67, 3,
|
||||
248, 17,199,246,144,239, 62,231, 6,195,213, 47,200,102, 30,215,
|
||||
8,232,234,222,128, 82,238,247,132,170,114,172, 53, 77,106, 42,
|
||||
150, 26,210,113, 90, 21, 73,116, 75,159,208, 94, 4, 24,164,236,
|
||||
194,224, 65,110, 15, 81,203,204, 36,145,175, 80,161,244,112, 57,
|
||||
153,124, 58,133, 35,184,180,122,252, 2, 54, 91, 37, 85,151, 49,
|
||||
45, 93,250,152,227,138,146,174, 5,223, 41, 16,103,108,186,201,
|
||||
211, 0,230,207,225,158,168, 44, 99, 22, 1, 63, 88,226,137,169,
|
||||
13, 56, 52, 27,171, 51,255,176,187, 72, 12, 95,185,177,205, 46,
|
||||
197,243,219, 71,229,165,156,119, 10,166, 32,104,254,127,193,173};
|
||||
|
||||
SecByteBlock L(128);
|
||||
memcpy(L, key, keyLen);
|
||||
|
||||
int i;
|
||||
for (i=keyLen; i<128; i++)
|
||||
L[i] = PITABLE[(L[i-1] + L[i-keyLen]) & 255];
|
||||
|
||||
unsigned int T8 = (effectiveLen+7) / 8;
|
||||
byte TM = 255 >> ((8-(effectiveLen%8))%8);
|
||||
L[128-T8] = PITABLE[L[128-T8] & TM];
|
||||
|
||||
for (i=127-T8; i>=0; i--)
|
||||
L[i] = PITABLE[L[i+1] ^ L[i+T8]];
|
||||
|
||||
for (i=0; i<64; i++)
|
||||
K[i] = L[2*i] + (L[2*i+1] << 8);
|
||||
}
|
||||
|
||||
typedef BlockGetAndPut<word16, LittleEndian> Block;
|
||||
|
||||
void RC2::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word16 R0, R1, R2, R3;
|
||||
Block::Get(inBlock)(R0)(R1)(R2)(R3);
|
||||
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
R0 += (R1 & ~R3) + (R2 & R3) + K[4*i+0];
|
||||
R0 = rotlFixed(R0, 1);
|
||||
|
||||
R1 += (R2 & ~R0) + (R3 & R0) + K[4*i+1];
|
||||
R1 = rotlFixed(R1, 2);
|
||||
|
||||
R2 += (R3 & ~R1) + (R0 & R1) + K[4*i+2];
|
||||
R2 = rotlFixed(R2, 3);
|
||||
|
||||
R3 += (R0 & ~R2) + (R1 & R2) + K[4*i+3];
|
||||
R3 = rotlFixed(R3, 5);
|
||||
|
||||
if (i == 4 || i == 10)
|
||||
{
|
||||
R0 += K[R3 & 63];
|
||||
R1 += K[R0 & 63];
|
||||
R2 += K[R1 & 63];
|
||||
R3 += K[R2 & 63];
|
||||
}
|
||||
}
|
||||
|
||||
Block::Put(xorBlock, outBlock)(R0)(R1)(R2)(R3);
|
||||
}
|
||||
|
||||
void RC2::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word16 R0, R1, R2, R3;
|
||||
Block::Get(inBlock)(R0)(R1)(R2)(R3);
|
||||
|
||||
for (int i = 15; i >= 0; i--)
|
||||
{
|
||||
if (i == 4 || i == 10)
|
||||
{
|
||||
R3 -= K[R2 & 63];
|
||||
R2 -= K[R1 & 63];
|
||||
R1 -= K[R0 & 63];
|
||||
R0 -= K[R3 & 63];
|
||||
}
|
||||
|
||||
R3 = rotrFixed(R3, 5);
|
||||
R3 -= (R0 & ~R2) + (R1 & R2) + K[4*i+3];
|
||||
|
||||
R2 = rotrFixed(R2, 3);
|
||||
R2 -= (R3 & ~R1) + (R0 & R1) + K[4*i+2];
|
||||
|
||||
R1 = rotrFixed(R1, 2);
|
||||
R1 -= (R2 & ~R0) + (R3 & R0) + K[4*i+1];
|
||||
|
||||
R0 = rotrFixed(R0, 1);
|
||||
R0 -= (R1 & ~R3) + (R2 & R3) + K[4*i+0];
|
||||
}
|
||||
|
||||
Block::Put(xorBlock, outBlock)(R0)(R1)(R2)(R3);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,73 +0,0 @@
|
||||
#ifndef CRYPTOPP_RC2_H
|
||||
#define CRYPTOPP_RC2_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
#include "algparam.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct RC2_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 1, 128>
|
||||
{
|
||||
CRYPTOPP_CONSTANT(DEFAULT_EFFECTIVE_KEYLENGTH = 1024)
|
||||
CRYPTOPP_CONSTANT(MAX_EFFECTIVE_KEYLENGTH = 1024)
|
||||
static const char *StaticAlgorithmName() {return "RC2";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#RC2">RC2</a>
|
||||
class RC2 : public RC2_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<RC2_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
unsigned int OptimalDataAlignment() const {return GetAlignmentOf<word16>();}
|
||||
|
||||
protected:
|
||||
FixedSizeSecBlock<word16, 64> K; // expanded key table
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
class Encryption : public BlockCipherFinal<ENCRYPTION, Enc>
|
||||
{
|
||||
public:
|
||||
Encryption() {}
|
||||
Encryption(const byte *key, size_t keyLen=DEFAULT_KEYLENGTH)
|
||||
{SetKey(key, keyLen);}
|
||||
Encryption(const byte *key, size_t keyLen, int effectiveKeyLen)
|
||||
{SetKey(key, keyLen, MakeParameters("EffectiveKeyLength", effectiveKeyLen));}
|
||||
};
|
||||
|
||||
class Decryption : public BlockCipherFinal<DECRYPTION, Dec>
|
||||
{
|
||||
public:
|
||||
Decryption() {}
|
||||
Decryption(const byte *key, size_t keyLen=DEFAULT_KEYLENGTH)
|
||||
{SetKey(key, keyLen);}
|
||||
Decryption(const byte *key, size_t keyLen, int effectiveKeyLen)
|
||||
{SetKey(key, keyLen, MakeParameters("EffectiveKeyLength", effectiveKeyLen));}
|
||||
};
|
||||
};
|
||||
|
||||
typedef RC2::Encryption RC2Encryption;
|
||||
typedef RC2::Decryption RC2Decryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,79 +0,0 @@
|
||||
// rc5.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "rc5.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void RC5::Base::UncheckedSetKey(const byte *k, unsigned int keylen, const NameValuePairs ¶ms)
|
||||
{
|
||||
AssertValidKeyLength(keylen);
|
||||
|
||||
r = GetRoundsAndThrowIfInvalid(params, this);
|
||||
sTable.New(2*(r+1));
|
||||
|
||||
static const RC5_WORD MAGIC_P = 0xb7e15163L; // magic constant P for wordsize
|
||||
static const RC5_WORD MAGIC_Q = 0x9e3779b9L; // magic constant Q for wordsize
|
||||
static const int U=sizeof(RC5_WORD);
|
||||
|
||||
const unsigned int c = STDMAX((keylen+U-1)/U, 1U); // RC6 paper says c=1 if keylen==0
|
||||
SecBlock<RC5_WORD> l(c);
|
||||
|
||||
GetUserKey(LITTLE_ENDIAN_ORDER, l.begin(), c, k, keylen);
|
||||
|
||||
sTable[0] = MAGIC_P;
|
||||
for (unsigned j=1; j<sTable.size();j++)
|
||||
sTable[j] = sTable[j-1] + MAGIC_Q;
|
||||
|
||||
RC5_WORD a=0, b=0;
|
||||
const unsigned n = 3*STDMAX((unsigned int)sTable.size(), c);
|
||||
|
||||
for (unsigned h=0; h < n; h++)
|
||||
{
|
||||
a = sTable[h % sTable.size()] = rotlFixed((sTable[h % sTable.size()] + a + b), 3);
|
||||
b = l[h % c] = rotlMod((l[h % c] + a + b), (a+b));
|
||||
}
|
||||
}
|
||||
|
||||
typedef BlockGetAndPut<RC5::RC5_WORD, LittleEndian> Block;
|
||||
|
||||
void RC5::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
const RC5_WORD *sptr = sTable;
|
||||
RC5_WORD a, b;
|
||||
|
||||
Block::Get(inBlock)(a)(b);
|
||||
a += sptr[0];
|
||||
b += sptr[1];
|
||||
sptr += 2;
|
||||
|
||||
for(unsigned i=0; i<r; i++)
|
||||
{
|
||||
a = rotlMod(a^b,b) + sptr[2*i+0];
|
||||
b = rotlMod(a^b,a) + sptr[2*i+1];
|
||||
}
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a)(b);
|
||||
}
|
||||
|
||||
void RC5::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
const RC5_WORD *sptr = sTable.end();
|
||||
RC5_WORD a, b;
|
||||
|
||||
Block::Get(inBlock)(a)(b);
|
||||
|
||||
for (unsigned i=0; i<r; i++)
|
||||
{
|
||||
sptr-=2;
|
||||
b = rotrMod(b-sptr[1], a) ^ a;
|
||||
a = rotrMod(a-sptr[0], b) ^ b;
|
||||
}
|
||||
b -= sTable[1];
|
||||
a -= sTable[0];
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a)(b);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,54 +0,0 @@
|
||||
#ifndef CRYPTOPP_RC5_H
|
||||
#define CRYPTOPP_RC5_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct RC5_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 0, 255>, public VariableRounds<16>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "RC5";}
|
||||
typedef word32 RC5_WORD;
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#RC5">RC5</a>
|
||||
class RC5 : public RC5_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<RC5_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
unsigned int r; // number of rounds
|
||||
SecBlock<RC5_WORD> sTable; // expanded key table
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef RC5::Encryption RC5Encryption;
|
||||
typedef RC5::Decryption RC5Decryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,96 +0,0 @@
|
||||
// rc6.cpp - written and placed in the public domain by Sean Woods
|
||||
// based on Wei Dai's RC5 code.
|
||||
|
||||
#include "pch.h"
|
||||
#include "rc6.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void RC6::Base::UncheckedSetKey(const byte *k, unsigned int keylen, const NameValuePairs ¶ms)
|
||||
{
|
||||
AssertValidKeyLength(keylen);
|
||||
|
||||
r = GetRoundsAndThrowIfInvalid(params, this);
|
||||
sTable.New(2*(r+2));
|
||||
|
||||
static const RC6_WORD MAGIC_P = 0xb7e15163L; // magic constant P for wordsize
|
||||
static const RC6_WORD MAGIC_Q = 0x9e3779b9L; // magic constant Q for wordsize
|
||||
static const int U=sizeof(RC6_WORD);
|
||||
|
||||
const unsigned int c = STDMAX((keylen+U-1)/U, 1U); // RC6 paper says c=1 if keylen==0
|
||||
SecBlock<RC6_WORD> l(c);
|
||||
|
||||
GetUserKey(LITTLE_ENDIAN_ORDER, l.begin(), c, k, keylen);
|
||||
|
||||
sTable[0] = MAGIC_P;
|
||||
for (unsigned j=1; j<sTable.size();j++)
|
||||
sTable[j] = sTable[j-1] + MAGIC_Q;
|
||||
|
||||
RC6_WORD a=0, b=0;
|
||||
const unsigned n = 3*STDMAX((unsigned int)sTable.size(), c);
|
||||
|
||||
for (unsigned h=0; h < n; h++)
|
||||
{
|
||||
a = sTable[h % sTable.size()] = rotlFixed((sTable[h % sTable.size()] + a + b), 3);
|
||||
b = l[h % c] = rotlMod((l[h % c] + a + b), (a+b));
|
||||
}
|
||||
}
|
||||
|
||||
typedef BlockGetAndPut<RC6::RC6_WORD, LittleEndian> Block;
|
||||
|
||||
void RC6::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
const RC6_WORD *sptr = sTable;
|
||||
RC6_WORD a, b, c, d, t, u;
|
||||
|
||||
Block::Get(inBlock)(a)(b)(c)(d);
|
||||
b += sptr[0];
|
||||
d += sptr[1];
|
||||
sptr += 2;
|
||||
|
||||
for(unsigned i=0; i<r; i++)
|
||||
{
|
||||
t = rotlFixed(b*(2*b+1), 5);
|
||||
u = rotlFixed(d*(2*d+1), 5);
|
||||
a = rotlMod(a^t,u) + sptr[0];
|
||||
c = rotlMod(c^u,t) + sptr[1];
|
||||
t = a; a = b; b = c; c = d; d = t;
|
||||
sptr += 2;
|
||||
}
|
||||
|
||||
a += sptr[0];
|
||||
c += sptr[1];
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a)(b)(c)(d);
|
||||
}
|
||||
|
||||
void RC6::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
const RC6_WORD *sptr = sTable.end();
|
||||
RC6_WORD a, b, c, d, t, u;
|
||||
|
||||
Block::Get(inBlock)(a)(b)(c)(d);
|
||||
|
||||
sptr -= 2;
|
||||
c -= sptr[1];
|
||||
a -= sptr[0];
|
||||
|
||||
for (unsigned i=0; i < r; i++)
|
||||
{
|
||||
sptr -= 2;
|
||||
t = a; a = d; d = c; c = b; b = t;
|
||||
u = rotlFixed(d*(2*d+1), 5);
|
||||
t = rotlFixed(b*(2*b+1), 5);
|
||||
c = rotrMod(c-sptr[1], t) ^ u;
|
||||
a = rotrMod(a-sptr[0], u) ^ t;
|
||||
}
|
||||
|
||||
sptr -= 2;
|
||||
d -= sTable[1];
|
||||
b -= sTable[0];
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a)(b)(c)(d);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,54 +0,0 @@
|
||||
#ifndef CRYPTOPP_RC6_H
|
||||
#define CRYPTOPP_RC6_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct RC6_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 0, 255>, public VariableRounds<20>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "RC6";}
|
||||
typedef word32 RC6_WORD;
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#RC6">RC6</a>
|
||||
class RC6 : public RC6_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<RC6_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
unsigned int r; // number of rounds
|
||||
SecBlock<RC6_WORD> sTable; // expanded key table
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef RC6::Encryption RC6Encryption;
|
||||
typedef RC6::Decryption RC6Decryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,803 +0,0 @@
|
||||
// ripemd.cpp
|
||||
// RIPEMD-160 written and placed in the public domain by Wei Dai
|
||||
// RIPEMD-320, RIPEMD-128, RIPEMD-256 written by Kevin Springle
|
||||
// and also placed in the public domain
|
||||
|
||||
#include "pch.h"
|
||||
#include "ripemd.h"
|
||||
#include "misc.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
#define F(x, y, z) (x ^ y ^ z)
|
||||
#define G(x, y, z) (z ^ (x & (y^z)))
|
||||
#define H(x, y, z) (z ^ (x | ~y))
|
||||
#define I(x, y, z) (y ^ (z & (x^y)))
|
||||
#define J(x, y, z) (x ^ (y | ~z))
|
||||
|
||||
#define k0 0
|
||||
#define k1 0x5a827999UL
|
||||
#define k2 0x6ed9eba1UL
|
||||
#define k3 0x8f1bbcdcUL
|
||||
#define k4 0xa953fd4eUL
|
||||
#define k5 0x50a28be6UL
|
||||
#define k6 0x5c4dd124UL
|
||||
#define k7 0x6d703ef3UL
|
||||
#define k8 0x7a6d76e9UL
|
||||
#define k9 0
|
||||
|
||||
// *************************************************************
|
||||
|
||||
// for 160 and 320
|
||||
#define Subround(f, a, b, c, d, e, x, s, k) \
|
||||
a += f(b, c, d) + x + k;\
|
||||
a = rotlFixed((word32)a, s) + e;\
|
||||
c = rotlFixed((word32)c, 10U)
|
||||
|
||||
void RIPEMD160::InitState(HashWordType *state)
|
||||
{
|
||||
state[0] = 0x67452301L;
|
||||
state[1] = 0xefcdab89L;
|
||||
state[2] = 0x98badcfeL;
|
||||
state[3] = 0x10325476L;
|
||||
state[4] = 0xc3d2e1f0L;
|
||||
}
|
||||
|
||||
void RIPEMD160::Transform (word32 *digest, const word32 *X)
|
||||
{
|
||||
unsigned long a1, b1, c1, d1, e1, a2, b2, c2, d2, e2;
|
||||
a1 = a2 = digest[0];
|
||||
b1 = b2 = digest[1];
|
||||
c1 = c2 = digest[2];
|
||||
d1 = d2 = digest[3];
|
||||
e1 = e2 = digest[4];
|
||||
|
||||
Subround(F, a1, b1, c1, d1, e1, X[ 0], 11, k0);
|
||||
Subround(F, e1, a1, b1, c1, d1, X[ 1], 14, k0);
|
||||
Subround(F, d1, e1, a1, b1, c1, X[ 2], 15, k0);
|
||||
Subround(F, c1, d1, e1, a1, b1, X[ 3], 12, k0);
|
||||
Subround(F, b1, c1, d1, e1, a1, X[ 4], 5, k0);
|
||||
Subround(F, a1, b1, c1, d1, e1, X[ 5], 8, k0);
|
||||
Subround(F, e1, a1, b1, c1, d1, X[ 6], 7, k0);
|
||||
Subround(F, d1, e1, a1, b1, c1, X[ 7], 9, k0);
|
||||
Subround(F, c1, d1, e1, a1, b1, X[ 8], 11, k0);
|
||||
Subround(F, b1, c1, d1, e1, a1, X[ 9], 13, k0);
|
||||
Subround(F, a1, b1, c1, d1, e1, X[10], 14, k0);
|
||||
Subround(F, e1, a1, b1, c1, d1, X[11], 15, k0);
|
||||
Subround(F, d1, e1, a1, b1, c1, X[12], 6, k0);
|
||||
Subround(F, c1, d1, e1, a1, b1, X[13], 7, k0);
|
||||
Subround(F, b1, c1, d1, e1, a1, X[14], 9, k0);
|
||||
Subround(F, a1, b1, c1, d1, e1, X[15], 8, k0);
|
||||
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 7], 7, k1);
|
||||
Subround(G, d1, e1, a1, b1, c1, X[ 4], 6, k1);
|
||||
Subround(G, c1, d1, e1, a1, b1, X[13], 8, k1);
|
||||
Subround(G, b1, c1, d1, e1, a1, X[ 1], 13, k1);
|
||||
Subround(G, a1, b1, c1, d1, e1, X[10], 11, k1);
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 6], 9, k1);
|
||||
Subround(G, d1, e1, a1, b1, c1, X[15], 7, k1);
|
||||
Subround(G, c1, d1, e1, a1, b1, X[ 3], 15, k1);
|
||||
Subround(G, b1, c1, d1, e1, a1, X[12], 7, k1);
|
||||
Subround(G, a1, b1, c1, d1, e1, X[ 0], 12, k1);
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 9], 15, k1);
|
||||
Subround(G, d1, e1, a1, b1, c1, X[ 5], 9, k1);
|
||||
Subround(G, c1, d1, e1, a1, b1, X[ 2], 11, k1);
|
||||
Subround(G, b1, c1, d1, e1, a1, X[14], 7, k1);
|
||||
Subround(G, a1, b1, c1, d1, e1, X[11], 13, k1);
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 8], 12, k1);
|
||||
|
||||
Subround(H, d1, e1, a1, b1, c1, X[ 3], 11, k2);
|
||||
Subround(H, c1, d1, e1, a1, b1, X[10], 13, k2);
|
||||
Subround(H, b1, c1, d1, e1, a1, X[14], 6, k2);
|
||||
Subround(H, a1, b1, c1, d1, e1, X[ 4], 7, k2);
|
||||
Subround(H, e1, a1, b1, c1, d1, X[ 9], 14, k2);
|
||||
Subround(H, d1, e1, a1, b1, c1, X[15], 9, k2);
|
||||
Subround(H, c1, d1, e1, a1, b1, X[ 8], 13, k2);
|
||||
Subround(H, b1, c1, d1, e1, a1, X[ 1], 15, k2);
|
||||
Subround(H, a1, b1, c1, d1, e1, X[ 2], 14, k2);
|
||||
Subround(H, e1, a1, b1, c1, d1, X[ 7], 8, k2);
|
||||
Subround(H, d1, e1, a1, b1, c1, X[ 0], 13, k2);
|
||||
Subround(H, c1, d1, e1, a1, b1, X[ 6], 6, k2);
|
||||
Subround(H, b1, c1, d1, e1, a1, X[13], 5, k2);
|
||||
Subround(H, a1, b1, c1, d1, e1, X[11], 12, k2);
|
||||
Subround(H, e1, a1, b1, c1, d1, X[ 5], 7, k2);
|
||||
Subround(H, d1, e1, a1, b1, c1, X[12], 5, k2);
|
||||
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 1], 11, k3);
|
||||
Subround(I, b1, c1, d1, e1, a1, X[ 9], 12, k3);
|
||||
Subround(I, a1, b1, c1, d1, e1, X[11], 14, k3);
|
||||
Subround(I, e1, a1, b1, c1, d1, X[10], 15, k3);
|
||||
Subround(I, d1, e1, a1, b1, c1, X[ 0], 14, k3);
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 8], 15, k3);
|
||||
Subround(I, b1, c1, d1, e1, a1, X[12], 9, k3);
|
||||
Subround(I, a1, b1, c1, d1, e1, X[ 4], 8, k3);
|
||||
Subround(I, e1, a1, b1, c1, d1, X[13], 9, k3);
|
||||
Subround(I, d1, e1, a1, b1, c1, X[ 3], 14, k3);
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 7], 5, k3);
|
||||
Subround(I, b1, c1, d1, e1, a1, X[15], 6, k3);
|
||||
Subround(I, a1, b1, c1, d1, e1, X[14], 8, k3);
|
||||
Subround(I, e1, a1, b1, c1, d1, X[ 5], 6, k3);
|
||||
Subround(I, d1, e1, a1, b1, c1, X[ 6], 5, k3);
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 2], 12, k3);
|
||||
|
||||
Subround(J, b1, c1, d1, e1, a1, X[ 4], 9, k4);
|
||||
Subround(J, a1, b1, c1, d1, e1, X[ 0], 15, k4);
|
||||
Subround(J, e1, a1, b1, c1, d1, X[ 5], 5, k4);
|
||||
Subround(J, d1, e1, a1, b1, c1, X[ 9], 11, k4);
|
||||
Subround(J, c1, d1, e1, a1, b1, X[ 7], 6, k4);
|
||||
Subround(J, b1, c1, d1, e1, a1, X[12], 8, k4);
|
||||
Subround(J, a1, b1, c1, d1, e1, X[ 2], 13, k4);
|
||||
Subround(J, e1, a1, b1, c1, d1, X[10], 12, k4);
|
||||
Subround(J, d1, e1, a1, b1, c1, X[14], 5, k4);
|
||||
Subround(J, c1, d1, e1, a1, b1, X[ 1], 12, k4);
|
||||
Subround(J, b1, c1, d1, e1, a1, X[ 3], 13, k4);
|
||||
Subround(J, a1, b1, c1, d1, e1, X[ 8], 14, k4);
|
||||
Subround(J, e1, a1, b1, c1, d1, X[11], 11, k4);
|
||||
Subround(J, d1, e1, a1, b1, c1, X[ 6], 8, k4);
|
||||
Subround(J, c1, d1, e1, a1, b1, X[15], 5, k4);
|
||||
Subround(J, b1, c1, d1, e1, a1, X[13], 6, k4);
|
||||
|
||||
Subround(J, a2, b2, c2, d2, e2, X[ 5], 8, k5);
|
||||
Subround(J, e2, a2, b2, c2, d2, X[14], 9, k5);
|
||||
Subround(J, d2, e2, a2, b2, c2, X[ 7], 9, k5);
|
||||
Subround(J, c2, d2, e2, a2, b2, X[ 0], 11, k5);
|
||||
Subround(J, b2, c2, d2, e2, a2, X[ 9], 13, k5);
|
||||
Subround(J, a2, b2, c2, d2, e2, X[ 2], 15, k5);
|
||||
Subround(J, e2, a2, b2, c2, d2, X[11], 15, k5);
|
||||
Subround(J, d2, e2, a2, b2, c2, X[ 4], 5, k5);
|
||||
Subround(J, c2, d2, e2, a2, b2, X[13], 7, k5);
|
||||
Subround(J, b2, c2, d2, e2, a2, X[ 6], 7, k5);
|
||||
Subround(J, a2, b2, c2, d2, e2, X[15], 8, k5);
|
||||
Subround(J, e2, a2, b2, c2, d2, X[ 8], 11, k5);
|
||||
Subround(J, d2, e2, a2, b2, c2, X[ 1], 14, k5);
|
||||
Subround(J, c2, d2, e2, a2, b2, X[10], 14, k5);
|
||||
Subround(J, b2, c2, d2, e2, a2, X[ 3], 12, k5);
|
||||
Subround(J, a2, b2, c2, d2, e2, X[12], 6, k5);
|
||||
|
||||
Subround(I, e2, a2, b2, c2, d2, X[ 6], 9, k6);
|
||||
Subround(I, d2, e2, a2, b2, c2, X[11], 13, k6);
|
||||
Subround(I, c2, d2, e2, a2, b2, X[ 3], 15, k6);
|
||||
Subround(I, b2, c2, d2, e2, a2, X[ 7], 7, k6);
|
||||
Subround(I, a2, b2, c2, d2, e2, X[ 0], 12, k6);
|
||||
Subround(I, e2, a2, b2, c2, d2, X[13], 8, k6);
|
||||
Subround(I, d2, e2, a2, b2, c2, X[ 5], 9, k6);
|
||||
Subround(I, c2, d2, e2, a2, b2, X[10], 11, k6);
|
||||
Subround(I, b2, c2, d2, e2, a2, X[14], 7, k6);
|
||||
Subround(I, a2, b2, c2, d2, e2, X[15], 7, k6);
|
||||
Subround(I, e2, a2, b2, c2, d2, X[ 8], 12, k6);
|
||||
Subround(I, d2, e2, a2, b2, c2, X[12], 7, k6);
|
||||
Subround(I, c2, d2, e2, a2, b2, X[ 4], 6, k6);
|
||||
Subround(I, b2, c2, d2, e2, a2, X[ 9], 15, k6);
|
||||
Subround(I, a2, b2, c2, d2, e2, X[ 1], 13, k6);
|
||||
Subround(I, e2, a2, b2, c2, d2, X[ 2], 11, k6);
|
||||
|
||||
Subround(H, d2, e2, a2, b2, c2, X[15], 9, k7);
|
||||
Subround(H, c2, d2, e2, a2, b2, X[ 5], 7, k7);
|
||||
Subround(H, b2, c2, d2, e2, a2, X[ 1], 15, k7);
|
||||
Subround(H, a2, b2, c2, d2, e2, X[ 3], 11, k7);
|
||||
Subround(H, e2, a2, b2, c2, d2, X[ 7], 8, k7);
|
||||
Subround(H, d2, e2, a2, b2, c2, X[14], 6, k7);
|
||||
Subround(H, c2, d2, e2, a2, b2, X[ 6], 6, k7);
|
||||
Subround(H, b2, c2, d2, e2, a2, X[ 9], 14, k7);
|
||||
Subround(H, a2, b2, c2, d2, e2, X[11], 12, k7);
|
||||
Subround(H, e2, a2, b2, c2, d2, X[ 8], 13, k7);
|
||||
Subround(H, d2, e2, a2, b2, c2, X[12], 5, k7);
|
||||
Subround(H, c2, d2, e2, a2, b2, X[ 2], 14, k7);
|
||||
Subround(H, b2, c2, d2, e2, a2, X[10], 13, k7);
|
||||
Subround(H, a2, b2, c2, d2, e2, X[ 0], 13, k7);
|
||||
Subround(H, e2, a2, b2, c2, d2, X[ 4], 7, k7);
|
||||
Subround(H, d2, e2, a2, b2, c2, X[13], 5, k7);
|
||||
|
||||
Subround(G, c2, d2, e2, a2, b2, X[ 8], 15, k8);
|
||||
Subround(G, b2, c2, d2, e2, a2, X[ 6], 5, k8);
|
||||
Subround(G, a2, b2, c2, d2, e2, X[ 4], 8, k8);
|
||||
Subround(G, e2, a2, b2, c2, d2, X[ 1], 11, k8);
|
||||
Subround(G, d2, e2, a2, b2, c2, X[ 3], 14, k8);
|
||||
Subround(G, c2, d2, e2, a2, b2, X[11], 14, k8);
|
||||
Subround(G, b2, c2, d2, e2, a2, X[15], 6, k8);
|
||||
Subround(G, a2, b2, c2, d2, e2, X[ 0], 14, k8);
|
||||
Subround(G, e2, a2, b2, c2, d2, X[ 5], 6, k8);
|
||||
Subround(G, d2, e2, a2, b2, c2, X[12], 9, k8);
|
||||
Subround(G, c2, d2, e2, a2, b2, X[ 2], 12, k8);
|
||||
Subround(G, b2, c2, d2, e2, a2, X[13], 9, k8);
|
||||
Subround(G, a2, b2, c2, d2, e2, X[ 9], 12, k8);
|
||||
Subround(G, e2, a2, b2, c2, d2, X[ 7], 5, k8);
|
||||
Subround(G, d2, e2, a2, b2, c2, X[10], 15, k8);
|
||||
Subround(G, c2, d2, e2, a2, b2, X[14], 8, k8);
|
||||
|
||||
Subround(F, b2, c2, d2, e2, a2, X[12], 8, k9);
|
||||
Subround(F, a2, b2, c2, d2, e2, X[15], 5, k9);
|
||||
Subround(F, e2, a2, b2, c2, d2, X[10], 12, k9);
|
||||
Subround(F, d2, e2, a2, b2, c2, X[ 4], 9, k9);
|
||||
Subround(F, c2, d2, e2, a2, b2, X[ 1], 12, k9);
|
||||
Subround(F, b2, c2, d2, e2, a2, X[ 5], 5, k9);
|
||||
Subround(F, a2, b2, c2, d2, e2, X[ 8], 14, k9);
|
||||
Subround(F, e2, a2, b2, c2, d2, X[ 7], 6, k9);
|
||||
Subround(F, d2, e2, a2, b2, c2, X[ 6], 8, k9);
|
||||
Subround(F, c2, d2, e2, a2, b2, X[ 2], 13, k9);
|
||||
Subround(F, b2, c2, d2, e2, a2, X[13], 6, k9);
|
||||
Subround(F, a2, b2, c2, d2, e2, X[14], 5, k9);
|
||||
Subround(F, e2, a2, b2, c2, d2, X[ 0], 15, k9);
|
||||
Subround(F, d2, e2, a2, b2, c2, X[ 3], 13, k9);
|
||||
Subround(F, c2, d2, e2, a2, b2, X[ 9], 11, k9);
|
||||
Subround(F, b2, c2, d2, e2, a2, X[11], 11, k9);
|
||||
|
||||
c1 = digest[1] + c1 + d2;
|
||||
digest[1] = digest[2] + d1 + e2;
|
||||
digest[2] = digest[3] + e1 + a2;
|
||||
digest[3] = digest[4] + a1 + b2;
|
||||
digest[4] = digest[0] + b1 + c2;
|
||||
digest[0] = c1;
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
|
||||
void RIPEMD320::InitState(HashWordType *state)
|
||||
{
|
||||
state[0] = 0x67452301L;
|
||||
state[1] = 0xefcdab89L;
|
||||
state[2] = 0x98badcfeL;
|
||||
state[3] = 0x10325476L;
|
||||
state[4] = 0xc3d2e1f0L;
|
||||
state[5] = 0x76543210L;
|
||||
state[6] = 0xfedcba98L;
|
||||
state[7] = 0x89abcdefL;
|
||||
state[8] = 0x01234567L;
|
||||
state[9] = 0x3c2d1e0fL;
|
||||
}
|
||||
|
||||
void RIPEMD320::Transform (word32 *digest, const word32 *X)
|
||||
{
|
||||
unsigned long a1, b1, c1, d1, e1, a2, b2, c2, d2, e2, t;
|
||||
a1 = digest[0];
|
||||
b1 = digest[1];
|
||||
c1 = digest[2];
|
||||
d1 = digest[3];
|
||||
e1 = digest[4];
|
||||
a2 = digest[5];
|
||||
b2 = digest[6];
|
||||
c2 = digest[7];
|
||||
d2 = digest[8];
|
||||
e2 = digest[9];
|
||||
|
||||
Subround(F, a1, b1, c1, d1, e1, X[ 0], 11, k0);
|
||||
Subround(F, e1, a1, b1, c1, d1, X[ 1], 14, k0);
|
||||
Subround(F, d1, e1, a1, b1, c1, X[ 2], 15, k0);
|
||||
Subround(F, c1, d1, e1, a1, b1, X[ 3], 12, k0);
|
||||
Subround(F, b1, c1, d1, e1, a1, X[ 4], 5, k0);
|
||||
Subround(F, a1, b1, c1, d1, e1, X[ 5], 8, k0);
|
||||
Subround(F, e1, a1, b1, c1, d1, X[ 6], 7, k0);
|
||||
Subround(F, d1, e1, a1, b1, c1, X[ 7], 9, k0);
|
||||
Subround(F, c1, d1, e1, a1, b1, X[ 8], 11, k0);
|
||||
Subround(F, b1, c1, d1, e1, a1, X[ 9], 13, k0);
|
||||
Subround(F, a1, b1, c1, d1, e1, X[10], 14, k0);
|
||||
Subround(F, e1, a1, b1, c1, d1, X[11], 15, k0);
|
||||
Subround(F, d1, e1, a1, b1, c1, X[12], 6, k0);
|
||||
Subround(F, c1, d1, e1, a1, b1, X[13], 7, k0);
|
||||
Subround(F, b1, c1, d1, e1, a1, X[14], 9, k0);
|
||||
Subround(F, a1, b1, c1, d1, e1, X[15], 8, k0);
|
||||
|
||||
Subround(J, a2, b2, c2, d2, e2, X[ 5], 8, k5);
|
||||
Subround(J, e2, a2, b2, c2, d2, X[14], 9, k5);
|
||||
Subround(J, d2, e2, a2, b2, c2, X[ 7], 9, k5);
|
||||
Subround(J, c2, d2, e2, a2, b2, X[ 0], 11, k5);
|
||||
Subround(J, b2, c2, d2, e2, a2, X[ 9], 13, k5);
|
||||
Subround(J, a2, b2, c2, d2, e2, X[ 2], 15, k5);
|
||||
Subround(J, e2, a2, b2, c2, d2, X[11], 15, k5);
|
||||
Subround(J, d2, e2, a2, b2, c2, X[ 4], 5, k5);
|
||||
Subround(J, c2, d2, e2, a2, b2, X[13], 7, k5);
|
||||
Subround(J, b2, c2, d2, e2, a2, X[ 6], 7, k5);
|
||||
Subround(J, a2, b2, c2, d2, e2, X[15], 8, k5);
|
||||
Subround(J, e2, a2, b2, c2, d2, X[ 8], 11, k5);
|
||||
Subround(J, d2, e2, a2, b2, c2, X[ 1], 14, k5);
|
||||
Subround(J, c2, d2, e2, a2, b2, X[10], 14, k5);
|
||||
Subround(J, b2, c2, d2, e2, a2, X[ 3], 12, k5);
|
||||
Subround(J, a2, b2, c2, d2, e2, X[12], 6, k5);
|
||||
|
||||
t = a1; a1 = a2; a2 = t;
|
||||
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 7], 7, k1);
|
||||
Subround(G, d1, e1, a1, b1, c1, X[ 4], 6, k1);
|
||||
Subround(G, c1, d1, e1, a1, b1, X[13], 8, k1);
|
||||
Subround(G, b1, c1, d1, e1, a1, X[ 1], 13, k1);
|
||||
Subround(G, a1, b1, c1, d1, e1, X[10], 11, k1);
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 6], 9, k1);
|
||||
Subround(G, d1, e1, a1, b1, c1, X[15], 7, k1);
|
||||
Subround(G, c1, d1, e1, a1, b1, X[ 3], 15, k1);
|
||||
Subround(G, b1, c1, d1, e1, a1, X[12], 7, k1);
|
||||
Subround(G, a1, b1, c1, d1, e1, X[ 0], 12, k1);
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 9], 15, k1);
|
||||
Subround(G, d1, e1, a1, b1, c1, X[ 5], 9, k1);
|
||||
Subround(G, c1, d1, e1, a1, b1, X[ 2], 11, k1);
|
||||
Subround(G, b1, c1, d1, e1, a1, X[14], 7, k1);
|
||||
Subround(G, a1, b1, c1, d1, e1, X[11], 13, k1);
|
||||
Subround(G, e1, a1, b1, c1, d1, X[ 8], 12, k1);
|
||||
|
||||
Subround(I, e2, a2, b2, c2, d2, X[ 6], 9, k6);
|
||||
Subround(I, d2, e2, a2, b2, c2, X[11], 13, k6);
|
||||
Subround(I, c2, d2, e2, a2, b2, X[ 3], 15, k6);
|
||||
Subround(I, b2, c2, d2, e2, a2, X[ 7], 7, k6);
|
||||
Subround(I, a2, b2, c2, d2, e2, X[ 0], 12, k6);
|
||||
Subround(I, e2, a2, b2, c2, d2, X[13], 8, k6);
|
||||
Subround(I, d2, e2, a2, b2, c2, X[ 5], 9, k6);
|
||||
Subround(I, c2, d2, e2, a2, b2, X[10], 11, k6);
|
||||
Subround(I, b2, c2, d2, e2, a2, X[14], 7, k6);
|
||||
Subround(I, a2, b2, c2, d2, e2, X[15], 7, k6);
|
||||
Subround(I, e2, a2, b2, c2, d2, X[ 8], 12, k6);
|
||||
Subround(I, d2, e2, a2, b2, c2, X[12], 7, k6);
|
||||
Subround(I, c2, d2, e2, a2, b2, X[ 4], 6, k6);
|
||||
Subround(I, b2, c2, d2, e2, a2, X[ 9], 15, k6);
|
||||
Subround(I, a2, b2, c2, d2, e2, X[ 1], 13, k6);
|
||||
Subround(I, e2, a2, b2, c2, d2, X[ 2], 11, k6);
|
||||
|
||||
t = b1; b1 = b2; b2 = t;
|
||||
|
||||
Subround(H, d1, e1, a1, b1, c1, X[ 3], 11, k2);
|
||||
Subround(H, c1, d1, e1, a1, b1, X[10], 13, k2);
|
||||
Subround(H, b1, c1, d1, e1, a1, X[14], 6, k2);
|
||||
Subround(H, a1, b1, c1, d1, e1, X[ 4], 7, k2);
|
||||
Subround(H, e1, a1, b1, c1, d1, X[ 9], 14, k2);
|
||||
Subround(H, d1, e1, a1, b1, c1, X[15], 9, k2);
|
||||
Subround(H, c1, d1, e1, a1, b1, X[ 8], 13, k2);
|
||||
Subround(H, b1, c1, d1, e1, a1, X[ 1], 15, k2);
|
||||
Subround(H, a1, b1, c1, d1, e1, X[ 2], 14, k2);
|
||||
Subround(H, e1, a1, b1, c1, d1, X[ 7], 8, k2);
|
||||
Subround(H, d1, e1, a1, b1, c1, X[ 0], 13, k2);
|
||||
Subround(H, c1, d1, e1, a1, b1, X[ 6], 6, k2);
|
||||
Subround(H, b1, c1, d1, e1, a1, X[13], 5, k2);
|
||||
Subround(H, a1, b1, c1, d1, e1, X[11], 12, k2);
|
||||
Subround(H, e1, a1, b1, c1, d1, X[ 5], 7, k2);
|
||||
Subround(H, d1, e1, a1, b1, c1, X[12], 5, k2);
|
||||
|
||||
Subround(H, d2, e2, a2, b2, c2, X[15], 9, k7);
|
||||
Subround(H, c2, d2, e2, a2, b2, X[ 5], 7, k7);
|
||||
Subround(H, b2, c2, d2, e2, a2, X[ 1], 15, k7);
|
||||
Subround(H, a2, b2, c2, d2, e2, X[ 3], 11, k7);
|
||||
Subround(H, e2, a2, b2, c2, d2, X[ 7], 8, k7);
|
||||
Subround(H, d2, e2, a2, b2, c2, X[14], 6, k7);
|
||||
Subround(H, c2, d2, e2, a2, b2, X[ 6], 6, k7);
|
||||
Subround(H, b2, c2, d2, e2, a2, X[ 9], 14, k7);
|
||||
Subround(H, a2, b2, c2, d2, e2, X[11], 12, k7);
|
||||
Subround(H, e2, a2, b2, c2, d2, X[ 8], 13, k7);
|
||||
Subround(H, d2, e2, a2, b2, c2, X[12], 5, k7);
|
||||
Subround(H, c2, d2, e2, a2, b2, X[ 2], 14, k7);
|
||||
Subround(H, b2, c2, d2, e2, a2, X[10], 13, k7);
|
||||
Subround(H, a2, b2, c2, d2, e2, X[ 0], 13, k7);
|
||||
Subround(H, e2, a2, b2, c2, d2, X[ 4], 7, k7);
|
||||
Subround(H, d2, e2, a2, b2, c2, X[13], 5, k7);
|
||||
|
||||
t = c1; c1 = c2; c2 = t;
|
||||
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 1], 11, k3);
|
||||
Subround(I, b1, c1, d1, e1, a1, X[ 9], 12, k3);
|
||||
Subround(I, a1, b1, c1, d1, e1, X[11], 14, k3);
|
||||
Subround(I, e1, a1, b1, c1, d1, X[10], 15, k3);
|
||||
Subround(I, d1, e1, a1, b1, c1, X[ 0], 14, k3);
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 8], 15, k3);
|
||||
Subround(I, b1, c1, d1, e1, a1, X[12], 9, k3);
|
||||
Subround(I, a1, b1, c1, d1, e1, X[ 4], 8, k3);
|
||||
Subround(I, e1, a1, b1, c1, d1, X[13], 9, k3);
|
||||
Subround(I, d1, e1, a1, b1, c1, X[ 3], 14, k3);
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 7], 5, k3);
|
||||
Subround(I, b1, c1, d1, e1, a1, X[15], 6, k3);
|
||||
Subround(I, a1, b1, c1, d1, e1, X[14], 8, k3);
|
||||
Subround(I, e1, a1, b1, c1, d1, X[ 5], 6, k3);
|
||||
Subround(I, d1, e1, a1, b1, c1, X[ 6], 5, k3);
|
||||
Subround(I, c1, d1, e1, a1, b1, X[ 2], 12, k3);
|
||||
|
||||
Subround(G, c2, d2, e2, a2, b2, X[ 8], 15, k8);
|
||||
Subround(G, b2, c2, d2, e2, a2, X[ 6], 5, k8);
|
||||
Subround(G, a2, b2, c2, d2, e2, X[ 4], 8, k8);
|
||||
Subround(G, e2, a2, b2, c2, d2, X[ 1], 11, k8);
|
||||
Subround(G, d2, e2, a2, b2, c2, X[ 3], 14, k8);
|
||||
Subround(G, c2, d2, e2, a2, b2, X[11], 14, k8);
|
||||
Subround(G, b2, c2, d2, e2, a2, X[15], 6, k8);
|
||||
Subround(G, a2, b2, c2, d2, e2, X[ 0], 14, k8);
|
||||
Subround(G, e2, a2, b2, c2, d2, X[ 5], 6, k8);
|
||||
Subround(G, d2, e2, a2, b2, c2, X[12], 9, k8);
|
||||
Subround(G, c2, d2, e2, a2, b2, X[ 2], 12, k8);
|
||||
Subround(G, b2, c2, d2, e2, a2, X[13], 9, k8);
|
||||
Subround(G, a2, b2, c2, d2, e2, X[ 9], 12, k8);
|
||||
Subround(G, e2, a2, b2, c2, d2, X[ 7], 5, k8);
|
||||
Subround(G, d2, e2, a2, b2, c2, X[10], 15, k8);
|
||||
Subround(G, c2, d2, e2, a2, b2, X[14], 8, k8);
|
||||
|
||||
t = d1; d1 = d2; d2 = t;
|
||||
|
||||
Subround(J, b1, c1, d1, e1, a1, X[ 4], 9, k4);
|
||||
Subround(J, a1, b1, c1, d1, e1, X[ 0], 15, k4);
|
||||
Subround(J, e1, a1, b1, c1, d1, X[ 5], 5, k4);
|
||||
Subround(J, d1, e1, a1, b1, c1, X[ 9], 11, k4);
|
||||
Subround(J, c1, d1, e1, a1, b1, X[ 7], 6, k4);
|
||||
Subround(J, b1, c1, d1, e1, a1, X[12], 8, k4);
|
||||
Subround(J, a1, b1, c1, d1, e1, X[ 2], 13, k4);
|
||||
Subround(J, e1, a1, b1, c1, d1, X[10], 12, k4);
|
||||
Subround(J, d1, e1, a1, b1, c1, X[14], 5, k4);
|
||||
Subround(J, c1, d1, e1, a1, b1, X[ 1], 12, k4);
|
||||
Subround(J, b1, c1, d1, e1, a1, X[ 3], 13, k4);
|
||||
Subround(J, a1, b1, c1, d1, e1, X[ 8], 14, k4);
|
||||
Subround(J, e1, a1, b1, c1, d1, X[11], 11, k4);
|
||||
Subround(J, d1, e1, a1, b1, c1, X[ 6], 8, k4);
|
||||
Subround(J, c1, d1, e1, a1, b1, X[15], 5, k4);
|
||||
Subround(J, b1, c1, d1, e1, a1, X[13], 6, k4);
|
||||
|
||||
Subround(F, b2, c2, d2, e2, a2, X[12], 8, k9);
|
||||
Subround(F, a2, b2, c2, d2, e2, X[15], 5, k9);
|
||||
Subround(F, e2, a2, b2, c2, d2, X[10], 12, k9);
|
||||
Subround(F, d2, e2, a2, b2, c2, X[ 4], 9, k9);
|
||||
Subround(F, c2, d2, e2, a2, b2, X[ 1], 12, k9);
|
||||
Subround(F, b2, c2, d2, e2, a2, X[ 5], 5, k9);
|
||||
Subround(F, a2, b2, c2, d2, e2, X[ 8], 14, k9);
|
||||
Subround(F, e2, a2, b2, c2, d2, X[ 7], 6, k9);
|
||||
Subround(F, d2, e2, a2, b2, c2, X[ 6], 8, k9);
|
||||
Subround(F, c2, d2, e2, a2, b2, X[ 2], 13, k9);
|
||||
Subround(F, b2, c2, d2, e2, a2, X[13], 6, k9);
|
||||
Subround(F, a2, b2, c2, d2, e2, X[14], 5, k9);
|
||||
Subround(F, e2, a2, b2, c2, d2, X[ 0], 15, k9);
|
||||
Subround(F, d2, e2, a2, b2, c2, X[ 3], 13, k9);
|
||||
Subround(F, c2, d2, e2, a2, b2, X[ 9], 11, k9);
|
||||
Subround(F, b2, c2, d2, e2, a2, X[11], 11, k9);
|
||||
|
||||
t = e1; e1 = e2; e2 = t;
|
||||
|
||||
digest[0] += a1;
|
||||
digest[1] += b1;
|
||||
digest[2] += c1;
|
||||
digest[3] += d1;
|
||||
digest[4] += e1;
|
||||
digest[5] += a2;
|
||||
digest[6] += b2;
|
||||
digest[7] += c2;
|
||||
digest[8] += d2;
|
||||
digest[9] += e2;
|
||||
}
|
||||
|
||||
#undef Subround
|
||||
|
||||
// *************************************************************
|
||||
|
||||
// for 128 and 256
|
||||
#define Subround(f, a, b, c, d, x, s, k) \
|
||||
a += f(b, c, d) + x + k;\
|
||||
a = rotlFixed((word32)a, s);
|
||||
|
||||
void RIPEMD128::InitState(HashWordType *state)
|
||||
{
|
||||
state[0] = 0x67452301L;
|
||||
state[1] = 0xefcdab89L;
|
||||
state[2] = 0x98badcfeL;
|
||||
state[3] = 0x10325476L;
|
||||
}
|
||||
|
||||
void RIPEMD128::Transform (word32 *digest, const word32 *X)
|
||||
{
|
||||
unsigned long a1, b1, c1, d1, a2, b2, c2, d2;
|
||||
a1 = a2 = digest[0];
|
||||
b1 = b2 = digest[1];
|
||||
c1 = c2 = digest[2];
|
||||
d1 = d2 = digest[3];
|
||||
|
||||
Subround(F, a1, b1, c1, d1, X[ 0], 11, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[ 1], 14, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[ 2], 15, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[ 3], 12, k0);
|
||||
Subround(F, a1, b1, c1, d1, X[ 4], 5, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[ 5], 8, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[ 6], 7, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[ 7], 9, k0);
|
||||
Subround(F, a1, b1, c1, d1, X[ 8], 11, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[ 9], 13, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[10], 14, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[11], 15, k0);
|
||||
Subround(F, a1, b1, c1, d1, X[12], 6, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[13], 7, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[14], 9, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[15], 8, k0);
|
||||
|
||||
Subround(G, a1, b1, c1, d1, X[ 7], 7, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[ 4], 6, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[13], 8, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 1], 13, k1);
|
||||
Subround(G, a1, b1, c1, d1, X[10], 11, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[ 6], 9, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[15], 7, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 3], 15, k1);
|
||||
Subround(G, a1, b1, c1, d1, X[12], 7, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[ 0], 12, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[ 9], 15, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 5], 9, k1);
|
||||
Subround(G, a1, b1, c1, d1, X[ 2], 11, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[14], 7, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[11], 13, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 8], 12, k1);
|
||||
|
||||
Subround(H, a1, b1, c1, d1, X[ 3], 11, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[10], 13, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[14], 6, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[ 4], 7, k2);
|
||||
Subround(H, a1, b1, c1, d1, X[ 9], 14, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[15], 9, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[ 8], 13, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[ 1], 15, k2);
|
||||
Subround(H, a1, b1, c1, d1, X[ 2], 14, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[ 7], 8, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[ 0], 13, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[ 6], 6, k2);
|
||||
Subround(H, a1, b1, c1, d1, X[13], 5, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[11], 12, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[ 5], 7, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[12], 5, k2);
|
||||
|
||||
Subround(I, a1, b1, c1, d1, X[ 1], 11, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 9], 12, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[11], 14, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[10], 15, k3);
|
||||
Subround(I, a1, b1, c1, d1, X[ 0], 14, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 8], 15, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[12], 9, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[ 4], 8, k3);
|
||||
Subround(I, a1, b1, c1, d1, X[13], 9, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 3], 14, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[ 7], 5, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[15], 6, k3);
|
||||
Subround(I, a1, b1, c1, d1, X[14], 8, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 5], 6, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[ 6], 5, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[ 2], 12, k3);
|
||||
|
||||
Subround(I, a2, b2, c2, d2, X[ 5], 8, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[14], 9, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[ 7], 9, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[ 0], 11, k5);
|
||||
Subround(I, a2, b2, c2, d2, X[ 9], 13, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[ 2], 15, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[11], 15, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[ 4], 5, k5);
|
||||
Subround(I, a2, b2, c2, d2, X[13], 7, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[ 6], 7, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[15], 8, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[ 8], 11, k5);
|
||||
Subround(I, a2, b2, c2, d2, X[ 1], 14, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[10], 14, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[ 3], 12, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[12], 6, k5);
|
||||
|
||||
Subround(H, a2, b2, c2, d2, X[ 6], 9, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[11], 13, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 3], 15, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[ 7], 7, k6);
|
||||
Subround(H, a2, b2, c2, d2, X[ 0], 12, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[13], 8, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 5], 9, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[10], 11, k6);
|
||||
Subround(H, a2, b2, c2, d2, X[14], 7, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[15], 7, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 8], 12, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[12], 7, k6);
|
||||
Subround(H, a2, b2, c2, d2, X[ 4], 6, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[ 9], 15, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 1], 13, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[ 2], 11, k6);
|
||||
|
||||
Subround(G, a2, b2, c2, d2, X[15], 9, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[ 5], 7, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[ 1], 15, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[ 3], 11, k7);
|
||||
Subround(G, a2, b2, c2, d2, X[ 7], 8, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[14], 6, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[ 6], 6, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[ 9], 14, k7);
|
||||
Subround(G, a2, b2, c2, d2, X[11], 12, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[ 8], 13, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[12], 5, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[ 2], 14, k7);
|
||||
Subround(G, a2, b2, c2, d2, X[10], 13, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[ 0], 13, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[ 4], 7, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[13], 5, k7);
|
||||
|
||||
Subround(F, a2, b2, c2, d2, X[ 8], 15, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[ 6], 5, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[ 4], 8, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[ 1], 11, k9);
|
||||
Subround(F, a2, b2, c2, d2, X[ 3], 14, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[11], 14, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[15], 6, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[ 0], 14, k9);
|
||||
Subround(F, a2, b2, c2, d2, X[ 5], 6, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[12], 9, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[ 2], 12, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[13], 9, k9);
|
||||
Subround(F, a2, b2, c2, d2, X[ 9], 12, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[ 7], 5, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[10], 15, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[14], 8, k9);
|
||||
|
||||
c1 = digest[1] + c1 + d2;
|
||||
digest[1] = digest[2] + d1 + a2;
|
||||
digest[2] = digest[3] + a1 + b2;
|
||||
digest[3] = digest[0] + b1 + c2;
|
||||
digest[0] = c1;
|
||||
}
|
||||
|
||||
// *************************************************************
|
||||
|
||||
void RIPEMD256::InitState(HashWordType *state)
|
||||
{
|
||||
state[0] = 0x67452301L;
|
||||
state[1] = 0xefcdab89L;
|
||||
state[2] = 0x98badcfeL;
|
||||
state[3] = 0x10325476L;
|
||||
state[4] = 0x76543210L;
|
||||
state[5] = 0xfedcba98L;
|
||||
state[6] = 0x89abcdefL;
|
||||
state[7] = 0x01234567L;
|
||||
}
|
||||
|
||||
void RIPEMD256::Transform (word32 *digest, const word32 *X)
|
||||
{
|
||||
unsigned long a1, b1, c1, d1, a2, b2, c2, d2, t;
|
||||
a1 = digest[0];
|
||||
b1 = digest[1];
|
||||
c1 = digest[2];
|
||||
d1 = digest[3];
|
||||
a2 = digest[4];
|
||||
b2 = digest[5];
|
||||
c2 = digest[6];
|
||||
d2 = digest[7];
|
||||
|
||||
Subround(F, a1, b1, c1, d1, X[ 0], 11, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[ 1], 14, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[ 2], 15, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[ 3], 12, k0);
|
||||
Subround(F, a1, b1, c1, d1, X[ 4], 5, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[ 5], 8, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[ 6], 7, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[ 7], 9, k0);
|
||||
Subround(F, a1, b1, c1, d1, X[ 8], 11, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[ 9], 13, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[10], 14, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[11], 15, k0);
|
||||
Subround(F, a1, b1, c1, d1, X[12], 6, k0);
|
||||
Subround(F, d1, a1, b1, c1, X[13], 7, k0);
|
||||
Subround(F, c1, d1, a1, b1, X[14], 9, k0);
|
||||
Subround(F, b1, c1, d1, a1, X[15], 8, k0);
|
||||
|
||||
Subround(I, a2, b2, c2, d2, X[ 5], 8, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[14], 9, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[ 7], 9, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[ 0], 11, k5);
|
||||
Subround(I, a2, b2, c2, d2, X[ 9], 13, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[ 2], 15, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[11], 15, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[ 4], 5, k5);
|
||||
Subround(I, a2, b2, c2, d2, X[13], 7, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[ 6], 7, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[15], 8, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[ 8], 11, k5);
|
||||
Subround(I, a2, b2, c2, d2, X[ 1], 14, k5);
|
||||
Subround(I, d2, a2, b2, c2, X[10], 14, k5);
|
||||
Subround(I, c2, d2, a2, b2, X[ 3], 12, k5);
|
||||
Subround(I, b2, c2, d2, a2, X[12], 6, k5);
|
||||
|
||||
t = a1; a1 = a2; a2 = t;
|
||||
|
||||
Subround(G, a1, b1, c1, d1, X[ 7], 7, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[ 4], 6, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[13], 8, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 1], 13, k1);
|
||||
Subround(G, a1, b1, c1, d1, X[10], 11, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[ 6], 9, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[15], 7, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 3], 15, k1);
|
||||
Subround(G, a1, b1, c1, d1, X[12], 7, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[ 0], 12, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[ 9], 15, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 5], 9, k1);
|
||||
Subround(G, a1, b1, c1, d1, X[ 2], 11, k1);
|
||||
Subround(G, d1, a1, b1, c1, X[14], 7, k1);
|
||||
Subround(G, c1, d1, a1, b1, X[11], 13, k1);
|
||||
Subround(G, b1, c1, d1, a1, X[ 8], 12, k1);
|
||||
|
||||
Subround(H, a2, b2, c2, d2, X[ 6], 9, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[11], 13, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 3], 15, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[ 7], 7, k6);
|
||||
Subround(H, a2, b2, c2, d2, X[ 0], 12, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[13], 8, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 5], 9, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[10], 11, k6);
|
||||
Subround(H, a2, b2, c2, d2, X[14], 7, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[15], 7, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 8], 12, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[12], 7, k6);
|
||||
Subround(H, a2, b2, c2, d2, X[ 4], 6, k6);
|
||||
Subround(H, d2, a2, b2, c2, X[ 9], 15, k6);
|
||||
Subround(H, c2, d2, a2, b2, X[ 1], 13, k6);
|
||||
Subround(H, b2, c2, d2, a2, X[ 2], 11, k6);
|
||||
|
||||
t = b1; b1 = b2; b2 = t;
|
||||
|
||||
Subround(H, a1, b1, c1, d1, X[ 3], 11, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[10], 13, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[14], 6, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[ 4], 7, k2);
|
||||
Subround(H, a1, b1, c1, d1, X[ 9], 14, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[15], 9, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[ 8], 13, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[ 1], 15, k2);
|
||||
Subround(H, a1, b1, c1, d1, X[ 2], 14, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[ 7], 8, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[ 0], 13, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[ 6], 6, k2);
|
||||
Subround(H, a1, b1, c1, d1, X[13], 5, k2);
|
||||
Subround(H, d1, a1, b1, c1, X[11], 12, k2);
|
||||
Subround(H, c1, d1, a1, b1, X[ 5], 7, k2);
|
||||
Subround(H, b1, c1, d1, a1, X[12], 5, k2);
|
||||
|
||||
Subround(G, a2, b2, c2, d2, X[15], 9, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[ 5], 7, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[ 1], 15, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[ 3], 11, k7);
|
||||
Subround(G, a2, b2, c2, d2, X[ 7], 8, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[14], 6, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[ 6], 6, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[ 9], 14, k7);
|
||||
Subround(G, a2, b2, c2, d2, X[11], 12, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[ 8], 13, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[12], 5, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[ 2], 14, k7);
|
||||
Subround(G, a2, b2, c2, d2, X[10], 13, k7);
|
||||
Subround(G, d2, a2, b2, c2, X[ 0], 13, k7);
|
||||
Subround(G, c2, d2, a2, b2, X[ 4], 7, k7);
|
||||
Subround(G, b2, c2, d2, a2, X[13], 5, k7);
|
||||
|
||||
t = c1; c1 = c2; c2 = t;
|
||||
|
||||
Subround(I, a1, b1, c1, d1, X[ 1], 11, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 9], 12, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[11], 14, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[10], 15, k3);
|
||||
Subround(I, a1, b1, c1, d1, X[ 0], 14, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 8], 15, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[12], 9, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[ 4], 8, k3);
|
||||
Subround(I, a1, b1, c1, d1, X[13], 9, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 3], 14, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[ 7], 5, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[15], 6, k3);
|
||||
Subround(I, a1, b1, c1, d1, X[14], 8, k3);
|
||||
Subround(I, d1, a1, b1, c1, X[ 5], 6, k3);
|
||||
Subround(I, c1, d1, a1, b1, X[ 6], 5, k3);
|
||||
Subround(I, b1, c1, d1, a1, X[ 2], 12, k3);
|
||||
|
||||
Subround(F, a2, b2, c2, d2, X[ 8], 15, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[ 6], 5, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[ 4], 8, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[ 1], 11, k9);
|
||||
Subround(F, a2, b2, c2, d2, X[ 3], 14, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[11], 14, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[15], 6, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[ 0], 14, k9);
|
||||
Subround(F, a2, b2, c2, d2, X[ 5], 6, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[12], 9, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[ 2], 12, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[13], 9, k9);
|
||||
Subround(F, a2, b2, c2, d2, X[ 9], 12, k9);
|
||||
Subround(F, d2, a2, b2, c2, X[ 7], 5, k9);
|
||||
Subround(F, c2, d2, a2, b2, X[10], 15, k9);
|
||||
Subround(F, b2, c2, d2, a2, X[14], 8, k9);
|
||||
|
||||
t = d1; d1 = d2; d2 = t;
|
||||
|
||||
digest[0] += a1;
|
||||
digest[1] += b1;
|
||||
digest[2] += c1;
|
||||
digest[3] += d1;
|
||||
digest[4] += a2;
|
||||
digest[5] += b2;
|
||||
digest[6] += c2;
|
||||
digest[7] += d2;
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,49 +0,0 @@
|
||||
#ifndef CRYPTOPP_RIPEMD_H
|
||||
#define CRYPTOPP_RIPEMD_H
|
||||
|
||||
#include "iterhash.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! <a href="http://www.weidai.com/scan-mirror/md.html#RIPEMD-160">RIPEMD-160</a>
|
||||
/*! Digest Length = 160 bits */
|
||||
class RIPEMD160 : public IteratedHashWithStaticTransform<word32, LittleEndian, 64, 20, RIPEMD160>
|
||||
{
|
||||
public:
|
||||
static void InitState(HashWordType *state);
|
||||
static void Transform(word32 *digest, const word32 *data);
|
||||
static const char * StaticAlgorithmName() {return "RIPEMD-160";}
|
||||
};
|
||||
|
||||
/*! Digest Length = 320 bits, Security is similar to RIPEMD-160 */
|
||||
class RIPEMD320 : public IteratedHashWithStaticTransform<word32, LittleEndian, 64, 40, RIPEMD320>
|
||||
{
|
||||
public:
|
||||
static void InitState(HashWordType *state);
|
||||
static void Transform(word32 *digest, const word32 *data);
|
||||
static const char * StaticAlgorithmName() {return "RIPEMD-320";}
|
||||
};
|
||||
|
||||
/*! \warning RIPEMD-128 is considered insecure, and should not be used
|
||||
unless you absolutely need it for compatibility. */
|
||||
class RIPEMD128 : public IteratedHashWithStaticTransform<word32, LittleEndian, 64, 16, RIPEMD128>
|
||||
{
|
||||
public:
|
||||
static void InitState(HashWordType *state);
|
||||
static void Transform(word32 *digest, const word32 *data);
|
||||
static const char * StaticAlgorithmName() {return "RIPEMD-128";}
|
||||
};
|
||||
|
||||
/*! \warning RIPEMD-256 is considered insecure, and should not be used
|
||||
unless you absolutely need it for compatibility. */
|
||||
class RIPEMD256 : public IteratedHashWithStaticTransform<word32, LittleEndian, 64, 32, RIPEMD256>
|
||||
{
|
||||
public:
|
||||
static void InitState(HashWordType *state);
|
||||
static void Transform(word32 *digest, const word32 *data);
|
||||
static const char * StaticAlgorithmName() {return "RIPEMD-256";}
|
||||
};
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,123 +0,0 @@
|
||||
// serpent.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "serpent.h"
|
||||
#include "misc.h"
|
||||
|
||||
#include "serpentp.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
void Serpent_KeySchedule(word32 *k, unsigned int rounds, const byte *userKey, size_t keylen)
|
||||
{
|
||||
FixedSizeSecBlock<word32, 8> k0;
|
||||
GetUserKey(LITTLE_ENDIAN_ORDER, k0.begin(), 8, userKey, keylen);
|
||||
if (keylen < 32)
|
||||
k0[keylen/4] |= word32(1) << ((keylen%4)*8);
|
||||
|
||||
word32 t = k0[7];
|
||||
unsigned int i;
|
||||
for (i = 0; i < 8; ++i)
|
||||
k[i] = k0[i] = t = rotlFixed(k0[i] ^ k0[(i+3)%8] ^ k0[(i+5)%8] ^ t ^ 0x9e3779b9 ^ i, 11);
|
||||
for (i = 8; i < 4*(rounds+1); ++i)
|
||||
k[i] = t = rotlFixed(k[i-8] ^ k[i-5] ^ k[i-3] ^ t ^ 0x9e3779b9 ^ i, 11);
|
||||
k -= 20;
|
||||
|
||||
word32 a,b,c,d,e;
|
||||
for (i=0; i<rounds/8; i++)
|
||||
{
|
||||
afterS2(LK); afterS2(S3); afterS3(SK);
|
||||
afterS1(LK); afterS1(S2); afterS2(SK);
|
||||
afterS0(LK); afterS0(S1); afterS1(SK);
|
||||
beforeS0(LK); beforeS0(S0); afterS0(SK);
|
||||
k += 8*4;
|
||||
afterS6(LK); afterS6(S7); afterS7(SK);
|
||||
afterS5(LK); afterS5(S6); afterS6(SK);
|
||||
afterS4(LK); afterS4(S5); afterS5(SK);
|
||||
afterS3(LK); afterS3(S4); afterS4(SK);
|
||||
}
|
||||
afterS2(LK); afterS2(S3); afterS3(SK);
|
||||
}
|
||||
|
||||
void Serpent::Base::UncheckedSetKey(const byte *userKey, unsigned int keylen, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(keylen);
|
||||
Serpent_KeySchedule(m_key, 32, userKey, keylen);
|
||||
}
|
||||
|
||||
typedef BlockGetAndPut<word32, LittleEndian> Block;
|
||||
|
||||
void Serpent::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 a, b, c, d, e;
|
||||
|
||||
Block::Get(inBlock)(a)(b)(c)(d);
|
||||
|
||||
const word32 *k = m_key;
|
||||
unsigned int i=1;
|
||||
|
||||
do
|
||||
{
|
||||
beforeS0(KX); beforeS0(S0); afterS0(LT);
|
||||
afterS0(KX); afterS0(S1); afterS1(LT);
|
||||
afterS1(KX); afterS1(S2); afterS2(LT);
|
||||
afterS2(KX); afterS2(S3); afterS3(LT);
|
||||
afterS3(KX); afterS3(S4); afterS4(LT);
|
||||
afterS4(KX); afterS4(S5); afterS5(LT);
|
||||
afterS5(KX); afterS5(S6); afterS6(LT);
|
||||
afterS6(KX); afterS6(S7);
|
||||
|
||||
if (i == 4)
|
||||
break;
|
||||
|
||||
++i;
|
||||
c = b;
|
||||
b = e;
|
||||
e = d;
|
||||
d = a;
|
||||
a = e;
|
||||
k += 32;
|
||||
beforeS0(LT);
|
||||
}
|
||||
while (true);
|
||||
|
||||
afterS7(KX);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(d)(e)(b)(a);
|
||||
}
|
||||
|
||||
void Serpent::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word32 a, b, c, d, e;
|
||||
|
||||
Block::Get(inBlock)(a)(b)(c)(d);
|
||||
|
||||
const word32 *k = m_key + 96;
|
||||
unsigned int i=4;
|
||||
|
||||
beforeI7(KX);
|
||||
goto start;
|
||||
|
||||
do
|
||||
{
|
||||
c = b;
|
||||
b = d;
|
||||
d = e;
|
||||
k -= 32;
|
||||
beforeI7(ILT);
|
||||
start:
|
||||
beforeI7(I7); afterI7(KX);
|
||||
afterI7(ILT); afterI7(I6); afterI6(KX);
|
||||
afterI6(ILT); afterI6(I5); afterI5(KX);
|
||||
afterI5(ILT); afterI5(I4); afterI4(KX);
|
||||
afterI4(ILT); afterI4(I3); afterI3(KX);
|
||||
afterI3(ILT); afterI3(I2); afterI2(KX);
|
||||
afterI2(ILT); afterI2(I1); afterI1(KX);
|
||||
afterI1(ILT); afterI1(I0); afterI0(KX);
|
||||
}
|
||||
while (--i != 0);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(a)(d)(b)(e);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,52 +0,0 @@
|
||||
#ifndef CRYPTOPP_SERPENT_H
|
||||
#define CRYPTOPP_SERPENT_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct Serpent_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 0, 32>, public FixedRounds<32>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "Serpent";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#Serpent">Serpent</a>
|
||||
class Serpent : public Serpent_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<Serpent_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
|
||||
|
||||
protected:
|
||||
FixedSizeSecBlock<word32, 33*4> m_key;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef Serpent::Encryption SerpentEncryption;
|
||||
typedef Serpent::Decryption SerpentDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
@ -1,434 +0,0 @@
|
||||
// private header for Serpent and Sosemanuk
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
// linear transformation
|
||||
#define LT(i,a,b,c,d,e) {\
|
||||
a = rotlFixed(a, 13); \
|
||||
c = rotlFixed(c, 3); \
|
||||
d = rotlFixed(d ^ c ^ (a << 3), 7); \
|
||||
b = rotlFixed(b ^ a ^ c, 1); \
|
||||
a = rotlFixed(a ^ b ^ d, 5); \
|
||||
c = rotlFixed(c ^ d ^ (b << 7), 22);}
|
||||
|
||||
// inverse linear transformation
|
||||
#define ILT(i,a,b,c,d,e) {\
|
||||
c = rotrFixed(c, 22); \
|
||||
a = rotrFixed(a, 5); \
|
||||
c ^= d ^ (b << 7); \
|
||||
a ^= b ^ d; \
|
||||
b = rotrFixed(b, 1); \
|
||||
d = rotrFixed(d, 7) ^ c ^ (a << 3); \
|
||||
b ^= a ^ c; \
|
||||
c = rotrFixed(c, 3); \
|
||||
a = rotrFixed(a, 13);}
|
||||
|
||||
// order of output from S-box functions
|
||||
#define beforeS0(f) f(0,a,b,c,d,e)
|
||||
#define afterS0(f) f(1,b,e,c,a,d)
|
||||
#define afterS1(f) f(2,c,b,a,e,d)
|
||||
#define afterS2(f) f(3,a,e,b,d,c)
|
||||
#define afterS3(f) f(4,e,b,d,c,a)
|
||||
#define afterS4(f) f(5,b,a,e,c,d)
|
||||
#define afterS5(f) f(6,a,c,b,e,d)
|
||||
#define afterS6(f) f(7,a,c,d,b,e)
|
||||
#define afterS7(f) f(8,d,e,b,a,c)
|
||||
|
||||
// order of output from inverse S-box functions
|
||||
#define beforeI7(f) f(8,a,b,c,d,e)
|
||||
#define afterI7(f) f(7,d,a,b,e,c)
|
||||
#define afterI6(f) f(6,a,b,c,e,d)
|
||||
#define afterI5(f) f(5,b,d,e,c,a)
|
||||
#define afterI4(f) f(4,b,c,e,a,d)
|
||||
#define afterI3(f) f(3,a,b,e,c,d)
|
||||
#define afterI2(f) f(2,b,d,e,c,a)
|
||||
#define afterI1(f) f(1,a,b,c,e,d)
|
||||
#define afterI0(f) f(0,a,d,b,e,c)
|
||||
|
||||
// The instruction sequences for the S-box functions
|
||||
// come from Dag Arne Osvik's paper "Speeding up Serpent".
|
||||
|
||||
#define S0(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r3 ^= r0; \
|
||||
r4 = r1; \
|
||||
r1 &= r3; \
|
||||
r4 ^= r2; \
|
||||
r1 ^= r0; \
|
||||
r0 |= r3; \
|
||||
r0 ^= r4; \
|
||||
r4 ^= r3; \
|
||||
r3 ^= r2; \
|
||||
r2 |= r1; \
|
||||
r2 ^= r4; \
|
||||
r4 = ~r4; \
|
||||
r4 |= r1; \
|
||||
r1 ^= r3; \
|
||||
r1 ^= r4; \
|
||||
r3 |= r0; \
|
||||
r1 ^= r3; \
|
||||
r4 ^= r3; \
|
||||
}
|
||||
|
||||
#define I0(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r2 = ~r2; \
|
||||
r4 = r1; \
|
||||
r1 |= r0; \
|
||||
r4 = ~r4; \
|
||||
r1 ^= r2; \
|
||||
r2 |= r4; \
|
||||
r1 ^= r3; \
|
||||
r0 ^= r4; \
|
||||
r2 ^= r0; \
|
||||
r0 &= r3; \
|
||||
r4 ^= r0; \
|
||||
r0 |= r1; \
|
||||
r0 ^= r2; \
|
||||
r3 ^= r4; \
|
||||
r2 ^= r1; \
|
||||
r3 ^= r0; \
|
||||
r3 ^= r1; \
|
||||
r2 &= r3; \
|
||||
r4 ^= r2; \
|
||||
}
|
||||
|
||||
#define S1(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r0 = ~r0; \
|
||||
r2 = ~r2; \
|
||||
r4 = r0; \
|
||||
r0 &= r1; \
|
||||
r2 ^= r0; \
|
||||
r0 |= r3; \
|
||||
r3 ^= r2; \
|
||||
r1 ^= r0; \
|
||||
r0 ^= r4; \
|
||||
r4 |= r1; \
|
||||
r1 ^= r3; \
|
||||
r2 |= r0; \
|
||||
r2 &= r4; \
|
||||
r0 ^= r1; \
|
||||
r1 &= r2; \
|
||||
r1 ^= r0; \
|
||||
r0 &= r2; \
|
||||
r0 ^= r4; \
|
||||
}
|
||||
|
||||
#define I1(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r1; \
|
||||
r1 ^= r3; \
|
||||
r3 &= r1; \
|
||||
r4 ^= r2; \
|
||||
r3 ^= r0; \
|
||||
r0 |= r1; \
|
||||
r2 ^= r3; \
|
||||
r0 ^= r4; \
|
||||
r0 |= r2; \
|
||||
r1 ^= r3; \
|
||||
r0 ^= r1; \
|
||||
r1 |= r3; \
|
||||
r1 ^= r0; \
|
||||
r4 = ~r4; \
|
||||
r4 ^= r1; \
|
||||
r1 |= r0; \
|
||||
r1 ^= r0; \
|
||||
r1 |= r4; \
|
||||
r3 ^= r1; \
|
||||
}
|
||||
|
||||
#define S2(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r0; \
|
||||
r0 &= r2; \
|
||||
r0 ^= r3; \
|
||||
r2 ^= r1; \
|
||||
r2 ^= r0; \
|
||||
r3 |= r4; \
|
||||
r3 ^= r1; \
|
||||
r4 ^= r2; \
|
||||
r1 = r3; \
|
||||
r3 |= r4; \
|
||||
r3 ^= r0; \
|
||||
r0 &= r1; \
|
||||
r4 ^= r0; \
|
||||
r1 ^= r3; \
|
||||
r1 ^= r4; \
|
||||
r4 = ~r4; \
|
||||
}
|
||||
|
||||
#define I2(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r2 ^= r3; \
|
||||
r3 ^= r0; \
|
||||
r4 = r3; \
|
||||
r3 &= r2; \
|
||||
r3 ^= r1; \
|
||||
r1 |= r2; \
|
||||
r1 ^= r4; \
|
||||
r4 &= r3; \
|
||||
r2 ^= r3; \
|
||||
r4 &= r0; \
|
||||
r4 ^= r2; \
|
||||
r2 &= r1; \
|
||||
r2 |= r0; \
|
||||
r3 = ~r3; \
|
||||
r2 ^= r3; \
|
||||
r0 ^= r3; \
|
||||
r0 &= r1; \
|
||||
r3 ^= r4; \
|
||||
r3 ^= r0; \
|
||||
}
|
||||
|
||||
#define S3(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r0; \
|
||||
r0 |= r3; \
|
||||
r3 ^= r1; \
|
||||
r1 &= r4; \
|
||||
r4 ^= r2; \
|
||||
r2 ^= r3; \
|
||||
r3 &= r0; \
|
||||
r4 |= r1; \
|
||||
r3 ^= r4; \
|
||||
r0 ^= r1; \
|
||||
r4 &= r0; \
|
||||
r1 ^= r3; \
|
||||
r4 ^= r2; \
|
||||
r1 |= r0; \
|
||||
r1 ^= r2; \
|
||||
r0 ^= r3; \
|
||||
r2 = r1; \
|
||||
r1 |= r3; \
|
||||
r1 ^= r0; \
|
||||
}
|
||||
|
||||
#define I3(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r2; \
|
||||
r2 ^= r1; \
|
||||
r1 &= r2; \
|
||||
r1 ^= r0; \
|
||||
r0 &= r4; \
|
||||
r4 ^= r3; \
|
||||
r3 |= r1; \
|
||||
r3 ^= r2; \
|
||||
r0 ^= r4; \
|
||||
r2 ^= r0; \
|
||||
r0 |= r3; \
|
||||
r0 ^= r1; \
|
||||
r4 ^= r2; \
|
||||
r2 &= r3; \
|
||||
r1 |= r3; \
|
||||
r1 ^= r2; \
|
||||
r4 ^= r0; \
|
||||
r2 ^= r4; \
|
||||
}
|
||||
|
||||
#define S4(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r1 ^= r3; \
|
||||
r3 = ~r3; \
|
||||
r2 ^= r3; \
|
||||
r3 ^= r0; \
|
||||
r4 = r1; \
|
||||
r1 &= r3; \
|
||||
r1 ^= r2; \
|
||||
r4 ^= r3; \
|
||||
r0 ^= r4; \
|
||||
r2 &= r4; \
|
||||
r2 ^= r0; \
|
||||
r0 &= r1; \
|
||||
r3 ^= r0; \
|
||||
r4 |= r1; \
|
||||
r4 ^= r0; \
|
||||
r0 |= r3; \
|
||||
r0 ^= r2; \
|
||||
r2 &= r3; \
|
||||
r0 = ~r0; \
|
||||
r4 ^= r2; \
|
||||
}
|
||||
|
||||
#define I4(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r2; \
|
||||
r2 &= r3; \
|
||||
r2 ^= r1; \
|
||||
r1 |= r3; \
|
||||
r1 &= r0; \
|
||||
r4 ^= r2; \
|
||||
r4 ^= r1; \
|
||||
r1 &= r2; \
|
||||
r0 = ~r0; \
|
||||
r3 ^= r4; \
|
||||
r1 ^= r3; \
|
||||
r3 &= r0; \
|
||||
r3 ^= r2; \
|
||||
r0 ^= r1; \
|
||||
r2 &= r0; \
|
||||
r3 ^= r0; \
|
||||
r2 ^= r4; \
|
||||
r2 |= r3; \
|
||||
r3 ^= r0; \
|
||||
r2 ^= r1; \
|
||||
}
|
||||
|
||||
#define S5(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r0 ^= r1; \
|
||||
r1 ^= r3; \
|
||||
r3 = ~r3; \
|
||||
r4 = r1; \
|
||||
r1 &= r0; \
|
||||
r2 ^= r3; \
|
||||
r1 ^= r2; \
|
||||
r2 |= r4; \
|
||||
r4 ^= r3; \
|
||||
r3 &= r1; \
|
||||
r3 ^= r0; \
|
||||
r4 ^= r1; \
|
||||
r4 ^= r2; \
|
||||
r2 ^= r0; \
|
||||
r0 &= r3; \
|
||||
r2 = ~r2; \
|
||||
r0 ^= r4; \
|
||||
r4 |= r3; \
|
||||
r2 ^= r4; \
|
||||
}
|
||||
|
||||
#define I5(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r1 = ~r1; \
|
||||
r4 = r3; \
|
||||
r2 ^= r1; \
|
||||
r3 |= r0; \
|
||||
r3 ^= r2; \
|
||||
r2 |= r1; \
|
||||
r2 &= r0; \
|
||||
r4 ^= r3; \
|
||||
r2 ^= r4; \
|
||||
r4 |= r0; \
|
||||
r4 ^= r1; \
|
||||
r1 &= r2; \
|
||||
r1 ^= r3; \
|
||||
r4 ^= r2; \
|
||||
r3 &= r4; \
|
||||
r4 ^= r1; \
|
||||
r3 ^= r0; \
|
||||
r3 ^= r4; \
|
||||
r4 = ~r4; \
|
||||
}
|
||||
|
||||
#define S6(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r2 = ~r2; \
|
||||
r4 = r3; \
|
||||
r3 &= r0; \
|
||||
r0 ^= r4; \
|
||||
r3 ^= r2; \
|
||||
r2 |= r4; \
|
||||
r1 ^= r3; \
|
||||
r2 ^= r0; \
|
||||
r0 |= r1; \
|
||||
r2 ^= r1; \
|
||||
r4 ^= r0; \
|
||||
r0 |= r3; \
|
||||
r0 ^= r2; \
|
||||
r4 ^= r3; \
|
||||
r4 ^= r0; \
|
||||
r3 = ~r3; \
|
||||
r2 &= r4; \
|
||||
r2 ^= r3; \
|
||||
}
|
||||
|
||||
#define I6(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r0 ^= r2; \
|
||||
r4 = r2; \
|
||||
r2 &= r0; \
|
||||
r4 ^= r3; \
|
||||
r2 = ~r2; \
|
||||
r3 ^= r1; \
|
||||
r2 ^= r3; \
|
||||
r4 |= r0; \
|
||||
r0 ^= r2; \
|
||||
r3 ^= r4; \
|
||||
r4 ^= r1; \
|
||||
r1 &= r3; \
|
||||
r1 ^= r0; \
|
||||
r0 ^= r3; \
|
||||
r0 |= r2; \
|
||||
r3 ^= r1; \
|
||||
r4 ^= r0; \
|
||||
}
|
||||
|
||||
#define S7(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r2; \
|
||||
r2 &= r1; \
|
||||
r2 ^= r3; \
|
||||
r3 &= r1; \
|
||||
r4 ^= r2; \
|
||||
r2 ^= r1; \
|
||||
r1 ^= r0; \
|
||||
r0 |= r4; \
|
||||
r0 ^= r2; \
|
||||
r3 ^= r1; \
|
||||
r2 ^= r3; \
|
||||
r3 &= r0; \
|
||||
r3 ^= r4; \
|
||||
r4 ^= r2; \
|
||||
r2 &= r0; \
|
||||
r4 = ~r4; \
|
||||
r2 ^= r4; \
|
||||
r4 &= r0; \
|
||||
r1 ^= r3; \
|
||||
r4 ^= r1; \
|
||||
}
|
||||
|
||||
#define I7(i, r0, r1, r2, r3, r4) \
|
||||
{ \
|
||||
r4 = r2; \
|
||||
r2 ^= r0; \
|
||||
r0 &= r3; \
|
||||
r2 = ~r2; \
|
||||
r4 |= r3; \
|
||||
r3 ^= r1; \
|
||||
r1 |= r0; \
|
||||
r0 ^= r2; \
|
||||
r2 &= r4; \
|
||||
r1 ^= r2; \
|
||||
r2 ^= r0; \
|
||||
r0 |= r2; \
|
||||
r3 &= r4; \
|
||||
r0 ^= r3; \
|
||||
r4 ^= r1; \
|
||||
r3 ^= r4; \
|
||||
r4 |= r0; \
|
||||
r3 ^= r2; \
|
||||
r4 ^= r2; \
|
||||
}
|
||||
|
||||
// key xor
|
||||
#define KX(r, a, b, c, d, e) {\
|
||||
a ^= k[4 * r + 0]; \
|
||||
b ^= k[4 * r + 1]; \
|
||||
c ^= k[4 * r + 2]; \
|
||||
d ^= k[4 * r + 3];}
|
||||
|
||||
#define LK(r, a, b, c, d, e) {\
|
||||
a = k[(8-r)*4 + 0]; \
|
||||
b = k[(8-r)*4 + 1]; \
|
||||
c = k[(8-r)*4 + 2]; \
|
||||
d = k[(8-r)*4 + 3];}
|
||||
|
||||
#define SK(r, a, b, c, d, e) {\
|
||||
k[(8-r)*4 + 4] = a; \
|
||||
k[(8-r)*4 + 5] = b; \
|
||||
k[(8-r)*4 + 6] = c; \
|
||||
k[(8-r)*4 + 7] = d;}
|
||||
|
||||
void Serpent_KeySchedule(word32 *k, unsigned int rounds, const byte *userKey, size_t keylen);
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,136 +0,0 @@
|
||||
// shark.cpp - written and placed in the public domain by Wei Dai
|
||||
|
||||
#include "pch.h"
|
||||
#include "shark.h"
|
||||
#include "misc.h"
|
||||
#include "modes.h"
|
||||
#include "gf256.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
static word64 SHARKTransform(word64 a)
|
||||
{
|
||||
static const byte iG[8][8] = {
|
||||
0xe7, 0x30, 0x90, 0x85, 0xd0, 0x4b, 0x91, 0x41,
|
||||
0x53, 0x95, 0x9b, 0xa5, 0x96, 0xbc, 0xa1, 0x68,
|
||||
0x02, 0x45, 0xf7, 0x65, 0x5c, 0x1f, 0xb6, 0x52,
|
||||
0xa2, 0xca, 0x22, 0x94, 0x44, 0x63, 0x2a, 0xa2,
|
||||
0xfc, 0x67, 0x8e, 0x10, 0x29, 0x75, 0x85, 0x71,
|
||||
0x24, 0x45, 0xa2, 0xcf, 0x2f, 0x22, 0xc1, 0x0e,
|
||||
0xa1, 0xf1, 0x71, 0x40, 0x91, 0x27, 0x18, 0xa5,
|
||||
0x56, 0xf4, 0xaf, 0x32, 0xd2, 0xa4, 0xdc, 0x71,
|
||||
};
|
||||
|
||||
word64 result=0;
|
||||
GF256 gf256(0xf5);
|
||||
for (unsigned int i=0; i<8; i++)
|
||||
for(unsigned int j=0; j<8; j++)
|
||||
result ^= word64(gf256.Multiply(iG[i][j], GF256::Element(a>>(56-8*j)))) << (56-8*i);
|
||||
return result;
|
||||
}
|
||||
|
||||
void SHARK::Base::UncheckedSetKey(const byte *key, unsigned int keyLen, const NameValuePairs ¶ms)
|
||||
{
|
||||
AssertValidKeyLength(keyLen);
|
||||
|
||||
m_rounds = GetRoundsAndThrowIfInvalid(params, this);
|
||||
m_roundKeys.New(m_rounds+1);
|
||||
|
||||
// concatenate key enought times to fill a
|
||||
for (unsigned int i=0; i<(m_rounds+1)*8; i++)
|
||||
((byte *)m_roundKeys.begin())[i] = key[i%keyLen];
|
||||
|
||||
SHARK::Encryption e;
|
||||
e.InitForKeySetup();
|
||||
byte IV[8] = {0,0,0,0,0,0,0,0};
|
||||
CFB_Mode_ExternalCipher::Encryption cfb(e, IV);
|
||||
|
||||
cfb.ProcessString((byte *)m_roundKeys.begin(), (m_rounds+1)*8);
|
||||
|
||||
ConditionalByteReverse(BIG_ENDIAN_ORDER, m_roundKeys.begin(), m_roundKeys.begin(), (m_rounds+1)*8);
|
||||
|
||||
m_roundKeys[m_rounds] = SHARKTransform(m_roundKeys[m_rounds]);
|
||||
|
||||
if (!IsForwardTransformation())
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
// transform encryption round keys into decryption round keys
|
||||
for (i=0; i<m_rounds/2; i++)
|
||||
std::swap(m_roundKeys[i], m_roundKeys[m_rounds-i]);
|
||||
|
||||
for (i=1; i<m_rounds; i++)
|
||||
m_roundKeys[i] = SHARKTransform(m_roundKeys[i]);
|
||||
}
|
||||
|
||||
#ifdef IS_LITTLE_ENDIAN
|
||||
m_roundKeys[0] = ByteReverse(m_roundKeys[0]);
|
||||
m_roundKeys[m_rounds] = ByteReverse(m_roundKeys[m_rounds]);
|
||||
#endif
|
||||
}
|
||||
|
||||
// construct an SHARK_Enc object with fixed round keys, to be used to initialize actual round keys
|
||||
void SHARK::Enc::InitForKeySetup()
|
||||
{
|
||||
m_rounds = DEFAULT_ROUNDS;
|
||||
m_roundKeys.New(DEFAULT_ROUNDS+1);
|
||||
|
||||
for (unsigned int i=0; i<DEFAULT_ROUNDS; i++)
|
||||
m_roundKeys[i] = cbox[0][i];
|
||||
|
||||
m_roundKeys[DEFAULT_ROUNDS] = SHARKTransform(cbox[0][DEFAULT_ROUNDS]);
|
||||
|
||||
#ifdef IS_LITTLE_ENDIAN
|
||||
m_roundKeys[0] = ByteReverse(m_roundKeys[0]);
|
||||
m_roundKeys[m_rounds] = ByteReverse(m_roundKeys[m_rounds]);
|
||||
#endif
|
||||
}
|
||||
|
||||
typedef word64 ArrayOf256Word64s[256];
|
||||
|
||||
template <const byte *sbox, const ArrayOf256Word64s *cbox>
|
||||
struct SharkProcessAndXorBlock{ // VC60 workaround: problem with template functions
|
||||
inline SharkProcessAndXorBlock(const word64 *roundKeys, unsigned int rounds, const byte *inBlock, const byte *xorBlock, byte *outBlock)
|
||||
{
|
||||
word64 tmp = *(word64 *)inBlock ^ roundKeys[0];
|
||||
|
||||
ByteOrder order = GetNativeByteOrder();
|
||||
tmp = cbox[0][GetByte(order, tmp, 0)] ^ cbox[1][GetByte(order, tmp, 1)]
|
||||
^ cbox[2][GetByte(order, tmp, 2)] ^ cbox[3][GetByte(order, tmp, 3)]
|
||||
^ cbox[4][GetByte(order, tmp, 4)] ^ cbox[5][GetByte(order, tmp, 5)]
|
||||
^ cbox[6][GetByte(order, tmp, 6)] ^ cbox[7][GetByte(order, tmp, 7)]
|
||||
^ roundKeys[1];
|
||||
|
||||
for(unsigned int i=2; i<rounds; i++)
|
||||
{
|
||||
tmp = cbox[0][GETBYTE(tmp, 7)] ^ cbox[1][GETBYTE(tmp, 6)]
|
||||
^ cbox[2][GETBYTE(tmp, 5)] ^ cbox[3][GETBYTE(tmp, 4)]
|
||||
^ cbox[4][GETBYTE(tmp, 3)] ^ cbox[5][GETBYTE(tmp, 2)]
|
||||
^ cbox[6][GETBYTE(tmp, 1)] ^ cbox[7][GETBYTE(tmp, 0)]
|
||||
^ roundKeys[i];
|
||||
}
|
||||
|
||||
PutBlock<byte, BigEndian>(xorBlock, outBlock)
|
||||
(sbox[GETBYTE(tmp, 7)])
|
||||
(sbox[GETBYTE(tmp, 6)])
|
||||
(sbox[GETBYTE(tmp, 5)])
|
||||
(sbox[GETBYTE(tmp, 4)])
|
||||
(sbox[GETBYTE(tmp, 3)])
|
||||
(sbox[GETBYTE(tmp, 2)])
|
||||
(sbox[GETBYTE(tmp, 1)])
|
||||
(sbox[GETBYTE(tmp, 0)]);
|
||||
|
||||
*(word64 *)outBlock ^= roundKeys[rounds];
|
||||
}};
|
||||
|
||||
void SHARK::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
SharkProcessAndXorBlock<sbox, cbox>(m_roundKeys, m_rounds, inBlock, xorBlock, outBlock);
|
||||
}
|
||||
|
||||
void SHARK::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
SharkProcessAndXorBlock<sbox, cbox>(m_roundKeys, m_rounds, inBlock, xorBlock, outBlock);
|
||||
}
|
||||
|
||||
NAMESPACE_END
|
||||
@ -1,65 +0,0 @@
|
||||
#ifndef CRYPTOPP_SHARK_H
|
||||
#define CRYPTOPP_SHARK_H
|
||||
|
||||
/** \file
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include "seckey.h"
|
||||
#include "secblock.h"
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
//! _
|
||||
struct SHARK_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 1, 16>, public VariableRounds<6, 2>
|
||||
{
|
||||
static const char *StaticAlgorithmName() {return "SHARK-E";}
|
||||
};
|
||||
|
||||
/// <a href="http://www.weidai.com/scan-mirror/cs.html#SHARK-E">SHARK-E</a>
|
||||
class SHARK : public SHARK_Info, public BlockCipherDocumentation
|
||||
{
|
||||
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<SHARK_Info>
|
||||
{
|
||||
public:
|
||||
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶m);
|
||||
|
||||
protected:
|
||||
unsigned int m_rounds;
|
||||
SecBlock<word64> m_roundKeys;
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Enc : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
|
||||
// used by Base to do key setup
|
||||
void InitForKeySetup();
|
||||
|
||||
private:
|
||||
static const byte sbox[256];
|
||||
static const word64 cbox[8][256];
|
||||
};
|
||||
|
||||
class CRYPTOPP_NO_VTABLE Dec : public Base
|
||||
{
|
||||
public:
|
||||
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
|
||||
|
||||
private:
|
||||
static const byte sbox[256];
|
||||
static const word64 cbox[8][256];
|
||||
};
|
||||
|
||||
public:
|
||||
typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
|
||||
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
|
||||
};
|
||||
|
||||
typedef SHARK::Encryption SHARKEncryption;
|
||||
typedef SHARK::Decryption SHARKDecryption;
|
||||
|
||||
NAMESPACE_END
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,202 +0,0 @@
|
||||
// skipjack.cpp - modified by Wei Dai from Paulo Barreto's skipjack32.c,
|
||||
// which is public domain according to his web site.
|
||||
|
||||
#include "pch.h"
|
||||
|
||||
#ifndef CRYPTOPP_IMPORTS
|
||||
|
||||
#include "skipjack.h"
|
||||
|
||||
/*
|
||||
* Optimized implementation of SKIPJACK algorithm
|
||||
*
|
||||
* originally written by Panu Rissanen <bande@lut.fi> 1998.06.24
|
||||
* optimized by Mark Tillotson <markt@chaos.org.uk> 1998.06.25
|
||||
* optimized by Paulo Barreto <pbarreto@nw.com.br> 1998.06.30
|
||||
*/
|
||||
|
||||
NAMESPACE_BEGIN(CryptoPP)
|
||||
|
||||
/**
|
||||
* The F-table byte permutation (see description of the G-box permutation)
|
||||
*/
|
||||
const byte SKIPJACK::Base::fTable[256] = {
|
||||
0xa3,0xd7,0x09,0x83,0xf8,0x48,0xf6,0xf4,0xb3,0x21,0x15,0x78,0x99,0xb1,0xaf,0xf9,
|
||||
0xe7,0x2d,0x4d,0x8a,0xce,0x4c,0xca,0x2e,0x52,0x95,0xd9,0x1e,0x4e,0x38,0x44,0x28,
|
||||
0x0a,0xdf,0x02,0xa0,0x17,0xf1,0x60,0x68,0x12,0xb7,0x7a,0xc3,0xe9,0xfa,0x3d,0x53,
|
||||
0x96,0x84,0x6b,0xba,0xf2,0x63,0x9a,0x19,0x7c,0xae,0xe5,0xf5,0xf7,0x16,0x6a,0xa2,
|
||||
0x39,0xb6,0x7b,0x0f,0xc1,0x93,0x81,0x1b,0xee,0xb4,0x1a,0xea,0xd0,0x91,0x2f,0xb8,
|
||||
0x55,0xb9,0xda,0x85,0x3f,0x41,0xbf,0xe0,0x5a,0x58,0x80,0x5f,0x66,0x0b,0xd8,0x90,
|
||||
0x35,0xd5,0xc0,0xa7,0x33,0x06,0x65,0x69,0x45,0x00,0x94,0x56,0x6d,0x98,0x9b,0x76,
|
||||
0x97,0xfc,0xb2,0xc2,0xb0,0xfe,0xdb,0x20,0xe1,0xeb,0xd6,0xe4,0xdd,0x47,0x4a,0x1d,
|
||||
0x42,0xed,0x9e,0x6e,0x49,0x3c,0xcd,0x43,0x27,0xd2,0x07,0xd4,0xde,0xc7,0x67,0x18,
|
||||
0x89,0xcb,0x30,0x1f,0x8d,0xc6,0x8f,0xaa,0xc8,0x74,0xdc,0xc9,0x5d,0x5c,0x31,0xa4,
|
||||
0x70,0x88,0x61,0x2c,0x9f,0x0d,0x2b,0x87,0x50,0x82,0x54,0x64,0x26,0x7d,0x03,0x40,
|
||||
0x34,0x4b,0x1c,0x73,0xd1,0xc4,0xfd,0x3b,0xcc,0xfb,0x7f,0xab,0xe6,0x3e,0x5b,0xa5,
|
||||
0xad,0x04,0x23,0x9c,0x14,0x51,0x22,0xf0,0x29,0x79,0x71,0x7e,0xff,0x8c,0x0e,0xe2,
|
||||
0x0c,0xef,0xbc,0x72,0x75,0x6f,0x37,0xa1,0xec,0xd3,0x8e,0x62,0x8b,0x86,0x10,0xe8,
|
||||
0x08,0x77,0x11,0xbe,0x92,0x4f,0x24,0xc5,0x32,0x36,0x9d,0xcf,0xf3,0xa6,0xbb,0xac,
|
||||
0x5e,0x6c,0xa9,0x13,0x57,0x25,0xb5,0xe3,0xbd,0xa8,0x3a,0x01,0x05,0x59,0x2a,0x46
|
||||
};
|
||||
|
||||
/**
|
||||
* The key-dependent permutation G on V^16 is a four-round Feistel network.
|
||||
* The round function is a fixed byte-substitution table (permutation on V^8),
|
||||
* the F-table. Each round of G incorporates a single byte from the key.
|
||||
*/
|
||||
#define g(tab, w, i, j, k, l) \
|
||||
{ \
|
||||
w ^= (word)tab[i*256 + (w & 0xff)] << 8; \
|
||||
w ^= (word)tab[j*256 + (w >> 8)]; \
|
||||
w ^= (word)tab[k*256 + (w & 0xff)] << 8; \
|
||||
w ^= (word)tab[l*256 + (w >> 8)]; \
|
||||
}
|
||||
|
||||
#define g0(tab, w) g(tab, w, 0, 1, 2, 3)
|
||||
#define g1(tab, w) g(tab, w, 4, 5, 6, 7)
|
||||
#define g2(tab, w) g(tab, w, 8, 9, 0, 1)
|
||||
#define g3(tab, w) g(tab, w, 2, 3, 4, 5)
|
||||
#define g4(tab, w) g(tab, w, 6, 7, 8, 9)
|
||||
|
||||
/**
|
||||
* The inverse of the G permutation.
|
||||
*/
|
||||
#define h(tab, w, i, j, k, l) \
|
||||
{ \
|
||||
w ^= (word)tab[l*256 + (w >> 8)]; \
|
||||
w ^= (word)tab[k*256 + (w & 0xff)] << 8; \
|
||||
w ^= (word)tab[j*256 + (w >> 8)]; \
|
||||
w ^= (word)tab[i*256 + (w & 0xff)] << 8; \
|
||||
}
|
||||
|
||||
#define h0(tab, w) h(tab, w, 0, 1, 2, 3)
|
||||
#define h1(tab, w) h(tab, w, 4, 5, 6, 7)
|
||||
#define h2(tab, w) h(tab, w, 8, 9, 0, 1)
|
||||
#define h3(tab, w) h(tab, w, 2, 3, 4, 5)
|
||||
#define h4(tab, w) h(tab, w, 6, 7, 8, 9)
|
||||
|
||||
/**
|
||||
* Preprocess a user key into a table to save an XOR at each F-table access.
|
||||
*/
|
||||
void SKIPJACK::Base::UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &)
|
||||
{
|
||||
AssertValidKeyLength(length);
|
||||
|
||||
/* tab[i][c] = fTable[c ^ key[i]] */
|
||||
int i;
|
||||
for (i = 0; i < 10; i++) {
|
||||
byte *t = tab+i*256, k = key[9-i];
|
||||
int c;
|
||||
for (c = 0; c < 256; c++) {
|
||||
t[c] = fTable[c ^ k];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typedef BlockGetAndPut<word16, LittleEndian> Block;
|
||||
|
||||
/**
|
||||
* Encrypt a single block of data.
|
||||
*/
|
||||
void SKIPJACK::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word16 w1, w2, w3, w4;
|
||||
Block::Get(inBlock)(w4)(w3)(w2)(w1);
|
||||
|
||||
/* stepping rule A: */
|
||||
g0(tab, w1); w4 ^= w1 ^ 1;
|
||||
g1(tab, w4); w3 ^= w4 ^ 2;
|
||||
g2(tab, w3); w2 ^= w3 ^ 3;
|
||||
g3(tab, w2); w1 ^= w2 ^ 4;
|
||||
g4(tab, w1); w4 ^= w1 ^ 5;
|
||||
g0(tab, w4); w3 ^= w4 ^ 6;
|
||||
g1(tab, w3); w2 ^= w3 ^ 7;
|
||||
g2(tab, w2); w1 ^= w2 ^ 8;
|
||||
|
||||
/* stepping rule B: */
|
||||
w2 ^= w1 ^ 9; g3(tab, w1);
|
||||
w1 ^= w4 ^ 10; g4(tab, w4);
|
||||
w4 ^= w3 ^ 11; g0(tab, w3);
|
||||
w3 ^= w2 ^ 12; g1(tab, w2);
|
||||
w2 ^= w1 ^ 13; g2(tab, w1);
|
||||
w1 ^= w4 ^ 14; g3(tab, w4);
|
||||
w4 ^= w3 ^ 15; g4(tab, w3);
|
||||
w3 ^= w2 ^ 16; g0(tab, w2);
|
||||
|
||||
/* stepping rule A: */
|
||||
g1(tab, w1); w4 ^= w1 ^ 17;
|
||||
g2(tab, w4); w3 ^= w4 ^ 18;
|
||||
g3(tab, w3); w2 ^= w3 ^ 19;
|
||||
g4(tab, w2); w1 ^= w2 ^ 20;
|
||||
g0(tab, w1); w4 ^= w1 ^ 21;
|
||||
g1(tab, w4); w3 ^= w4 ^ 22;
|
||||
g2(tab, w3); w2 ^= w3 ^ 23;
|
||||
g3(tab, w2); w1 ^= w2 ^ 24;
|
||||
|
||||
/* stepping rule B: */
|
||||
w2 ^= w1 ^ 25; g4(tab, w1);
|
||||
w1 ^= w4 ^ 26; g0(tab, w4);
|
||||
w4 ^= w3 ^ 27; g1(tab, w3);
|
||||
w3 ^= w2 ^ 28; g2(tab, w2);
|
||||
w2 ^= w1 ^ 29; g3(tab, w1);
|
||||
w1 ^= w4 ^ 30; g4(tab, w4);
|
||||
w4 ^= w3 ^ 31; g0(tab, w3);
|
||||
w3 ^= w2 ^ 32; g1(tab, w2);
|
||||
|
||||
Block::Put(xorBlock, outBlock)(w4)(w3)(w2)(w1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypt a single block of data.
|
||||
*/
|
||||
void SKIPJACK::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
|
||||
{
|
||||
word16 w1, w2, w3, w4;
|
||||
Block::Get(inBlock)(w4)(w3)(w2)(w1);
|
||||
|
||||
/* stepping rule A: */
|
||||
h1(tab, w2); w3 ^= w2 ^ 32;
|
||||
h0(tab, w3); w4 ^= w3 ^ 31;
|
||||
h4(tab, w4); w1 ^= w4 ^ 30;
|
||||
h3(tab, w1); w2 ^= w1 ^ 29;
|
||||
h2(tab, w2); w3 ^= w2 ^ 28;
|
||||
h1(tab, w3); w4 ^= w3 ^ 27;
|
||||
h0(tab, w4); w1 ^= w4 ^ 26;
|
||||
h4(tab, w1); w2 ^= w1 ^ 25;
|
||||
|
||||
/* stepping rule B: */
|
||||
w1 ^= w2 ^ 24; h3(tab, w2);
|
||||
w2 ^= w3 ^ 23; h2(tab, w3);
|
||||
w3 ^= w4 ^ 22; h1(tab, w4);
|
||||
w4 ^= w1 ^ 21; h0(tab, w1);
|
||||
w1 ^= w2 ^ 20; h4(tab, w2);
|
||||
w2 ^= w3 ^ 19; h3(tab, w3);
|
||||
w3 ^= w4 ^ 18; h2(tab, w4);
|
||||
w4 ^= w1 ^ 17; h1(tab, w1);
|
||||
|
||||
/* stepping rule A: */
|
||||
h0(tab, w2); w3 ^= w2 ^ 16;
|
||||
h4(tab, w3); w4 ^= w3 ^ 15;
|
||||
h3(tab, w4); w1 ^= w4 ^ 14;
|
||||
h2(tab, w1); w2 ^= w1 ^ 13;
|
||||
h1(tab, w2); w3 ^= w2 ^ 12;
|
||||
h0(tab, w3); w4 ^= w3 ^ 11;
|
||||
h4(tab, w4); w1 ^= w4 ^ 10;
|
||||
h3(tab, w1); w2 ^= w1 ^ 9;
|
||||
|
||||
| ||||