Skip to content

M
mariadb
Commit 75c13cbe authored by svoj@mysql.com's avatar svoj@mysql.com
Browse files
Options

Merge with latest yaSSL. 

Fixes IsAligned yaSSL assertion failure.
parent 155c322c
Show whitespace changes
Inline Side-by-side
Showing with 338 additions and 309 deletions
extra/yassl/include/buffer.hpp
View file @ 75c13cbe
......@@ -29,7 +29,6 @@
#include <assert.h> // assert
#include "yassl_types.hpp" // ysDelete
#include "yassl_error.hpp" // Error
#include "memory.hpp" // mySTL::auto_ptr
#include "algorithm.hpp" // mySTL::swap
......
extra/yassl/include/factory.hpp
View file @ 75c13cbe
......@@ -33,7 +33,6 @@
#include "vector.hpp"
#include "pair.hpp"
#include "yassl_error.hpp"
......
extra/yassl/include/openssl/ssl.h
View file @ 75c13cbe
......@@ -34,6 +34,7 @@ namespace yaSSL {
extern "C" {
#endif
#undef X509_NAME /* wincrypt.h clash */
#if defined(__cplusplus) && !defined(YASSL_MYSQL_COMPATIBLE)
class SSL;
......
extra/yassl/include/yassl_int.hpp
View file @ 75c13cbe
......@@ -29,6 +29,7 @@
#define yaSSL_INT_HPP
#include "yassl_imp.hpp"
#include "yassl_error.hpp"
#include "crypto_wrapper.hpp"
#include "cert_wrapper.hpp"
#include "log.hpp"
......@@ -129,6 +130,8 @@ private:
};
#undef X509_NAME // wincrypt.h clash
// openSSL X509 names
class X509_NAME {
char* name_;
......
extra/yassl/include/yassl_types.hpp
View file @ 75c13cbe
......@@ -71,7 +71,7 @@ void ysArrayDelete(T* ptr)
// to resolve compiler generated operator delete on base classes with
// virtual destructors, make sure doesn't get called
// virtual destructors (when on stack), make sure doesn't get called
class virtual_base {
public:
static void operator delete(void*) { assert(0); }
......
extra/yassl/mySTL/stdexcept.hpp
View file @ 75c13cbe
......@@ -29,6 +29,8 @@
#include <string.h> // strncpy
#include <assert.h> // assert
#include <stdlib.h> // size_t
namespace mySTL {
......@@ -37,9 +39,15 @@ namespace mySTL {
class exception {
public:
exception() {}
virtual ~exception() {}
virtual ~exception() {} // to shut up compiler warnings
virtual const char* what() const { return ""; }
// for compiler generated call, never used
static void operator delete(void*) { assert(0); }
private:
// don't allow dynamic creation of exceptions
static void* operator new(size_t);
};
......
extra/yassl/src/buffer.cpp
View file @ 75c13cbe
......@@ -24,6 +24,7 @@
* with SSL types and sockets
*/
#include <string.h> // memcpy
#include "buffer.hpp"
#include "yassl_types.hpp"
......
extra/yassl/src/socket_wrapper.cpp
View file @ 75c13cbe
......@@ -27,7 +27,6 @@
#include "socket_wrapper.hpp"
#include "yassl_error.hpp"
#ifndef WIN32
#include <errno.h>
......
extra/yassl/src/ssl.cpp
View file @ 75c13cbe
......@@ -38,6 +38,7 @@
#include <stdio.h>
#include "runtime.hpp"
namespace yaSSL {
using mySTL::min;
......
extra/yassl/taocrypt/include/block.hpp
View file @ 75c13cbe
......@@ -28,7 +28,6 @@
#define TAO_CRYPT_BLOCK_HPP
#include "algorithm.hpp" // mySTL::swap
#include "stdexcept.hpp" // mySTL::runtime_error
#include "misc.hpp"
#include <string.h> // memcpy
#include <stddef.h> // ptrdiff_t
......
extra/yassl/taocrypt/include/hash.hpp
View file @ 75c13cbe
......@@ -49,20 +49,20 @@ public:
// HASH with Transform
class HASHwithTransform : public HASH {
public:
HASHwithTransform(word32 digSz, word32 buffSz)
: digest_(new (tc) word32[digSz]), buffer_(new (tc) byte[buffSz]) {}
virtual ~HASHwithTransform() { tcArrayDelete(buffer_);
tcArrayDelete(digest_); }
HASHwithTransform(word32 digSz, word32 buffSz);
virtual ~HASHwithTransform() {}
virtual ByteOrder getByteOrder() const = 0;
virtual word32 getPadSize() const = 0;
virtual void Update(const byte*, word32);
virtual void Final(byte*);
enum { MaxDigestSz = 5, MaxBufferSz = 64 };
protected:
word32 buffLen_;
word32 length_; // in Bits
word32* digest_;
byte* buffer_;
word32 digest_[MaxDigestSz];
word32 buffer_[MaxBufferSz / sizeof(word32)];
virtual void Transform() = 0;
};
......
extra/yassl/taocrypt/include/hmac.hpp
View file @ 75c13cbe
......@@ -37,19 +37,32 @@ class HMAC {
public:
enum { IPAD = 0x36, OPAD = 0x5C };
HMAC() { Init(); }
HMAC() : ipad_(reinterpret_cast<byte*>(&ip_)),
opad_(reinterpret_cast<byte*>(&op_)),
innerHash_(reinterpret_cast<byte*>(&innerH_))
{
Init();
}
void Update(const byte*, word32);
void Final(byte*);
void Init();
void SetKey(const byte*, word32);
private:
byte ipad_[T::BLOCK_SIZE];
byte opad_[T::BLOCK_SIZE];
byte innerHash_[T::DIGEST_SIZE];
byte* ipad_;
byte* opad_;
byte* innerHash_;
bool innerHashKeyed_;
T mac_;
// MSVC 6 HACK, gives compiler error if calculated in array
enum { BSIZE = T::BLOCK_SIZE / sizeof(word32),
DSIZE = T::DIGEST_SIZE / sizeof(word32) };
word32 ip_[BSIZE]; // align ipad_ on word32
word32 op_[BSIZE]; // align opad_ on word32
word32 innerH_[DSIZE]; // align innerHash_ on word32
void KeyInnerHash();
HMAC(const HMAC&);
......
extra/yassl/taocrypt/include/integer.hpp
View file @ 75c13cbe
......@@ -25,6 +25,17 @@
#ifndef TAO_CRYPT_INTEGER_HPP
#define TAO_CRYPT_INTEGER_HPP
#ifdef _MSC_VER
// 4250: dominance
// 4660: explicitly instantiating a class already implicitly instantiated
// 4661: no suitable definition provided for explicit template request
// 4786: identifer was truncated in debug information
// 4355: 'this' : used in base member initializer list
# pragma warning(disable: 4250 4660 4661 4786 4355)
#endif
#include "misc.hpp"
#include "block.hpp"
#include "random.hpp"
......
extra/yassl/taocrypt/include/modes.hpp
View file @ 75c13cbe
......@@ -60,7 +60,12 @@ class Mode_BASE : public virtual_base {
public:
enum { MaxBlockSz = 16 };
explicit Mode_BASE(int sz) : blockSz_(sz) { assert(sz <= MaxBlockSz); }
explicit Mode_BASE(int sz)
: blockSz_(sz), reg_(reinterpret_cast<byte*>(r_)),
tmp_(reinterpret_cast<byte*>(t_))
{
assert(sz <= MaxBlockSz);
}
virtual ~Mode_BASE() {}
virtual void ProcessAndXorBlock(const byte*, const byte*, byte*) const = 0;
......@@ -71,9 +76,13 @@ public:
void SetIV(const byte* iv) { memcpy(reg_, iv, blockSz_); }
private:
byte reg_[MaxBlockSz];
byte tmp_[MaxBlockSz];
int blockSz_;
byte* reg_;
byte* tmp_;
word32 r_[MaxBlockSz / sizeof(word32)]; // align reg_ on word32
word32 t_[MaxBlockSz / sizeof(word32)]; // align tmp_ on word32
Mode_BASE(const Mode_BASE&); // hide copy
Mode_BASE& operator=(const Mode_BASE&); // and assign
......
extra/yassl/taocrypt/include/rsa.hpp
View file @ 75c13cbe
......@@ -27,7 +27,6 @@
#include "integer.hpp"
#include "random.hpp"
#include "stdexcept.hpp"
namespace TaoCrypt {
......
extra/yassl/taocrypt/src/aes.cpp
View file @ 75c13cbe
......@@ -23,7 +23,6 @@
#include "runtime.hpp"
#include "aes.hpp"
#include "stdexcept.hpp"
namespace TaoCrypt {
......
extra/yassl/taocrypt/src/dsa.cpp
View file @ 75c13cbe
......@@ -24,7 +24,6 @@
#include "sha.hpp"
#include "asn.hpp"
#include "modarith.hpp"
#include "stdexcept.hpp"
namespace TaoCrypt {
......
extra/yassl/taocrypt/src/hash.cpp
View file @ 75c13cbe
......@@ -24,6 +24,7 @@
#include "runtime.hpp"
#include <string.h>
#include <assert.h>
#include "hash.hpp"
......@@ -31,21 +32,30 @@
namespace TaoCrypt {
HASHwithTransform::HASHwithTransform(word32 digSz, word32 buffSz)
{
assert(digSz <= MaxDigestSz);
assert(buffSz <= MaxBufferSz);
}
// Update digest with data of size len, do in blocks
void HASHwithTransform::Update(const byte* data, word32 len)
{
// do block size increments
word32 blockSz = getBlockSize();
byte* local = reinterpret_cast<byte*>(buffer_);
while (len) {
word32 add = min(len, blockSz - buffLen_);
memcpy(&buffer_[buffLen_], data, add);
memcpy(&local[buffLen_], data, add);
buffLen_ += add;
data += add;
len -= add;
if (buffLen_ == blockSz) {
ByteReverseIf(buffer_, buffer_, blockSz, getByteOrder());
ByteReverseIf(local, local, blockSz, getByteOrder());
Transform();
}
}
......@@ -60,22 +70,23 @@ void HASHwithTransform::Final(byte* hash)
word32 padSz = getPadSize();
ByteOrder order = getByteOrder();
word32 prePadLen = length_ + buffLen_ * 8; // in bits
byte* local = reinterpret_cast<byte*>(buffer_);
buffer_[buffLen_++] = 0x80; // add 1
local[buffLen_++] = 0x80; // add 1
// pad with zeros
if (buffLen_ > padSz) {
while (buffLen_ < blockSz) buffer_[buffLen_++] = 0;
ByteReverseIf(buffer_, buffer_, blockSz, order);
while (buffLen_ < blockSz) local[buffLen_++] = 0;
ByteReverseIf(local, local, blockSz, order);
Transform();
}
while (buffLen_ < padSz) buffer_[buffLen_++] = 0;
while (buffLen_ < padSz) local[buffLen_++] = 0;
ByteReverseIf(buffer_, buffer_, blockSz, order);
ByteReverseIf(local, local, blockSz, order);
word32 hiSize = 0; // for future 64 bit length TODO:
memcpy(&buffer_[padSz], order ? &hiSize : &prePadLen, sizeof(prePadLen));
memcpy(&buffer_[padSz+4], order ? &prePadLen : &hiSize, sizeof(prePadLen));
memcpy(&local[padSz], order ? &hiSize : &prePadLen, sizeof(prePadLen));
memcpy(&local[padSz+4], order ? &prePadLen : &hiSize, sizeof(prePadLen));
Transform();
......
extra/yassl/taocrypt/src/integer.cpp
View file @ 75c13cbe
......@@ -23,19 +23,9 @@
/* based on Wei Dai's integer.cpp from CryptoPP */
#ifdef _MSC_VER
// 4250: dominance
// 4660: explicitly instantiating a class already implicitly instantiated
// 4661: no suitable definition provided for explicit template request
// 4786: identifer was truncated in debug information
// 4355: 'this' : used in base member initializer list
# pragma warning(disable: 4250 4660 4661 4786 4355)
#endif
#include "integer.hpp"
#include "modarith.hpp"
#include "asn.hpp"
#include "stdexcept.hpp"
......
extra/yassl/taocrypt/src/md5.cpp
View file @ 75c13cbe
......@@ -61,10 +61,11 @@ MD5& MD5::operator= (const MD5& that)
void MD5::Swap(MD5& other)
{
mySTL::swap(buffer_, other.buffer_);
mySTL::swap(buffLen_, other.buffLen_);
mySTL::swap(digest_, other.digest_);
mySTL::swap(length_, other.length_);
mySTL::swap(buffLen_, other.buffLen_);
memcpy(digest_, other.digest_, DIGEST_SIZE);
memcpy(buffer_, other.buffer_, BLOCK_SIZE);
}
......@@ -84,73 +85,73 @@ void MD5::Transform()
word32 c = digest_[2];
word32 d = digest_[3];
MD5STEP(F1, a, b, c, d, *(word32*)&buffer_[0*4] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, *(word32*)&buffer_[1*4] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, *(word32*)&buffer_[2*4] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, *(word32*)&buffer_[3*4] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, *(word32*)&buffer_[4*4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, *(word32*)&buffer_[5*4] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, *(word32*)&buffer_[6*4] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, *(word32*)&buffer_[7*4] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, *(word32*)&buffer_[8*4] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, *(word32*)&buffer_[9*4] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, *(word32*)&buffer_[10*4] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, *(word32*)&buffer_[11*4] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, *(word32*)&buffer_[12*4] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, *(word32*)&buffer_[13*4] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, *(word32*)&buffer_[14*4] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, *(word32*)&buffer_[15*4] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, *(word32*)&buffer_[1*4] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, *(word32*)&buffer_[6*4] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, *(word32*)&buffer_[11*4] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, *(word32*)&buffer_[0*4] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, *(word32*)&buffer_[5*4] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, *(word32*)&buffer_[10*4] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, *(word32*)&buffer_[15*4] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, *(word32*)&buffer_[4*4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, *(word32*)&buffer_[9*4] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, *(word32*)&buffer_[14*4] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, *(word32*)&buffer_[3*4] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, *(word32*)&buffer_[8*4] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, *(word32*)&buffer_[13*4] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, *(word32*)&buffer_[2*4] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, *(word32*)&buffer_[7*4] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, *(word32*)&buffer_[12*4] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, *(word32*)&buffer_[5*4] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, *(word32*)&buffer_[8*4] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, *(word32*)&buffer_[11*4] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, *(word32*)&buffer_[14*4] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, *(word32*)&buffer_[1*4] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, *(word32*)&buffer_[4*4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, *(word32*)&buffer_[7*4] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, *(word32*)&buffer_[10*4] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, *(word32*)&buffer_[13*4] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, *(word32*)&buffer_[0*4] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, *(word32*)&buffer_[3*4] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, *(word32*)&buffer_[6*4] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, *(word32*)&buffer_[9*4] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, *(word32*)&buffer_[12*4] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, *(word32*)&buffer_[15*4] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, *(word32*)&buffer_[2*4] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, *(word32*)&buffer_[0*4] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, *(word32*)&buffer_[7*4] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, *(word32*)&buffer_[14*4] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, *(word32*)&buffer_[5*4] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, *(word32*)&buffer_[12*4] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, *(word32*)&buffer_[3*4] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, *(word32*)&buffer_[10*4] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, *(word32*)&buffer_[1*4] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, *(word32*)&buffer_[8*4] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, *(word32*)&buffer_[15*4] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, *(word32*)&buffer_[6*4] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, *(word32*)&buffer_[13*4] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, *(word32*)&buffer_[4*4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, *(word32*)&buffer_[11*4] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, *(word32*)&buffer_[2*4] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, *(word32*)&buffer_[9*4] + 0xeb86d391, 21);
MD5STEP(F1, a, b, c, d, buffer_[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, buffer_[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, buffer_[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, buffer_[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, buffer_[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, buffer_[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, buffer_[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, buffer_[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, buffer_[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, buffer_[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, buffer_[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, buffer_[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, buffer_[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, buffer_[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, buffer_[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, buffer_[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, buffer_[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, buffer_[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, buffer_[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, buffer_[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, buffer_[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, buffer_[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, buffer_[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, buffer_[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, buffer_[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, buffer_[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, buffer_[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, buffer_[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, buffer_[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, buffer_[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, buffer_[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, buffer_[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, buffer_[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, buffer_[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, buffer_[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, buffer_[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, buffer_[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, buffer_[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, buffer_[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, buffer_[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, buffer_[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, buffer_[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, buffer_[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, buffer_[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, buffer_[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, buffer_[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, buffer_[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, buffer_[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, buffer_[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, buffer_[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, buffer_[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, buffer_[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, buffer_[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, buffer_[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, buffer_[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, buffer_[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, buffer_[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, buffer_[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, buffer_[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, buffer_[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, buffer_[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, buffer_[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, buffer_[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, buffer_[9] + 0xeb86d391, 21);
// Add the working vars back into digest state[]
digest_[0] += a;
......
extra/yassl/taocrypt/src/misc.cpp
View file @ 75c13cbe
......@@ -55,27 +55,13 @@ void operator delete[](void* ptr, TaoCrypt::new_t)
/* uncomment to test
// make sure not using globals anywhere by forgetting to use overloaded
void* operator new(size_t sz)
{
assert(0);
return malloc(sz);
}
void* operator new(size_t sz);
void operator delete(void* ptr)
{
assert(0);
}
void operator delete(void* ptr);
void* operator new[](size_t sz)
{
assert(0);
return malloc(sz);
}
void* operator new[](size_t sz);
void operator delete[](void* ptr)
{
assert(0);
}
void operator delete[](void* ptr);
*/
/* namespace GCC_ABI {
......
extra/yassl/taocrypt/src/ripemd.cpp
View file @ 75c13cbe
......@@ -63,10 +63,11 @@ RIPEMD160& RIPEMD160::operator= (const RIPEMD160& that)
void RIPEMD160::Swap(RIPEMD160& other)
{
mySTL::swap(buffer_, other.buffer_);
mySTL::swap(buffLen_, other.buffLen_);
mySTL::swap(digest_, other.digest_);
mySTL::swap(length_, other.length_);
mySTL::swap(buffLen_, other.buffLen_);
memcpy(digest_, other.digest_, DIGEST_SIZE);
memcpy(buffer_, other.buffer_, BLOCK_SIZE);
}
......@@ -104,175 +105,175 @@ void RIPEMD160::Transform()
d1 = d2 = digest_[3];
e1 = e2 = digest_[4];
Subround(F, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 0*4], 11, k0);
Subround(F, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 1*4], 14, k0);
Subround(F, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 2*4], 15, k0);
Subround(F, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 3*4], 12, k0);
Subround(F, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 4*4], 5, k0);
Subround(F, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 5*4], 8, k0);
Subround(F, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 6*4], 7, k0);
Subround(F, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 7*4], 9, k0);
Subround(F, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 8*4], 11, k0);
Subround(F, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 9*4], 13, k0);
Subround(F, a1, b1, c1, d1, e1, *(word32*)&buffer_[10*4], 14, k0);
Subround(F, e1, a1, b1, c1, d1, *(word32*)&buffer_[11*4], 15, k0);
Subround(F, d1, e1, a1, b1, c1, *(word32*)&buffer_[12*4], 6, k0);
Subround(F, c1, d1, e1, a1, b1, *(word32*)&buffer_[13*4], 7, k0);
Subround(F, b1, c1, d1, e1, a1, *(word32*)&buffer_[14*4], 9, k0);
Subround(F, a1, b1, c1, d1, e1, *(word32*)&buffer_[15*4], 8, k0);
Subround(G, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 7*4], 7, k1);
Subround(G, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 4*4], 6, k1);
Subround(G, c1, d1, e1, a1, b1, *(word32*)&buffer_[13*4], 8, k1);
Subround(G, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 1*4], 13, k1);
Subround(G, a1, b1, c1, d1, e1, *(word32*)&buffer_[10*4], 11, k1);
Subround(G, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 6*4], 9, k1);
Subround(G, d1, e1, a1, b1, c1, *(word32*)&buffer_[15*4], 7, k1);
Subround(G, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 3*4], 15, k1);
Subround(G, b1, c1, d1, e1, a1, *(word32*)&buffer_[12*4], 7, k1);
Subround(G, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 0*4], 12, k1);
Subround(G, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 9*4], 15, k1);
Subround(G, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 5*4], 9, k1);
Subround(G, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 2*4], 11, k1);
Subround(G, b1, c1, d1, e1, a1, *(word32*)&buffer_[14*4], 7, k1);
Subround(G, a1, b1, c1, d1, e1, *(word32*)&buffer_[11*4], 13, k1);
Subround(G, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 8*4], 12, k1);
Subround(H, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 3*4], 11, k2);
Subround(H, c1, d1, e1, a1, b1, *(word32*)&buffer_[10*4], 13, k2);
Subround(H, b1, c1, d1, e1, a1, *(word32*)&buffer_[14*4], 6, k2);
Subround(H, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 4*4], 7, k2);
Subround(H, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 9*4], 14, k2);
Subround(H, d1, e1, a1, b1, c1, *(word32*)&buffer_[15*4], 9, k2);
Subround(H, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 8*4], 13, k2);
Subround(H, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 1*4], 15, k2);
Subround(H, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 2*4], 14, k2);
Subround(H, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 7*4], 8, k2);
Subround(H, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 0*4], 13, k2);
Subround(H, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 6*4], 6, k2);
Subround(H, b1, c1, d1, e1, a1, *(word32*)&buffer_[13*4], 5, k2);
Subround(H, a1, b1, c1, d1, e1, *(word32*)&buffer_[11*4], 12, k2);
Subround(H, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 5*4], 7, k2);
Subround(H, d1, e1, a1, b1, c1, *(word32*)&buffer_[12*4], 5, k2);
Subround(I, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 1*4], 11, k3);
Subround(I, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 9*4], 12, k3);
Subround(I, a1, b1, c1, d1, e1, *(word32*)&buffer_[11*4], 14, k3);
Subround(I, e1, a1, b1, c1, d1, *(word32*)&buffer_[10*4], 15, k3);
Subround(I, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 0*4], 14, k3);
Subround(I, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 8*4], 15, k3);
Subround(I, b1, c1, d1, e1, a1, *(word32*)&buffer_[12*4], 9, k3);
Subround(I, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 4*4], 8, k3);
Subround(I, e1, a1, b1, c1, d1, *(word32*)&buffer_[13*4], 9, k3);
Subround(I, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 3*4], 14, k3);
Subround(I, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 7*4], 5, k3);
Subround(I, b1, c1, d1, e1, a1, *(word32*)&buffer_[15*4], 6, k3);
Subround(I, a1, b1, c1, d1, e1, *(word32*)&buffer_[14*4], 8, k3);
Subround(I, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 5*4], 6, k3);
Subround(I, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 6*4], 5, k3);
Subround(I, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 2*4], 12, k3);
Subround(J, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 4*4], 9, k4);
Subround(J, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 0*4], 15, k4);
Subround(J, e1, a1, b1, c1, d1, *(word32*)&buffer_[ 5*4], 5, k4);
Subround(J, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 9*4], 11, k4);
Subround(J, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 7*4], 6, k4);
Subround(J, b1, c1, d1, e1, a1, *(word32*)&buffer_[12*4], 8, k4);
Subround(J, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 2*4], 13, k4);
Subround(J, e1, a1, b1, c1, d1, *(word32*)&buffer_[10*4], 12, k4);
Subround(J, d1, e1, a1, b1, c1, *(word32*)&buffer_[14*4], 5, k4);
Subround(J, c1, d1, e1, a1, b1, *(word32*)&buffer_[ 1*4], 12, k4);
Subround(J, b1, c1, d1, e1, a1, *(word32*)&buffer_[ 3*4], 13, k4);
Subround(J, a1, b1, c1, d1, e1, *(word32*)&buffer_[ 8*4], 14, k4);
Subround(J, e1, a1, b1, c1, d1, *(word32*)&buffer_[11*4], 11, k4);
Subround(J, d1, e1, a1, b1, c1, *(word32*)&buffer_[ 6*4], 8, k4);
Subround(J, c1, d1, e1, a1, b1, *(word32*)&buffer_[15*4], 5, k4);
Subround(J, b1, c1, d1, e1, a1, *(word32*)&buffer_[13*4], 6, k4);
Subround(J, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 5*4], 8, k5);
Subround(J, e2, a2, b2, c2, d2, *(word32*)&buffer_[14*4], 9, k5);
Subround(J, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 7*4], 9, k5);
Subround(J, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 0*4], 11, k5);
Subround(J, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 9*4], 13, k5);
Subround(J, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 2*4], 15, k5);
Subround(J, e2, a2, b2, c2, d2, *(word32*)&buffer_[11*4], 15, k5);
Subround(J, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 4*4], 5, k5);
Subround(J, c2, d2, e2, a2, b2, *(word32*)&buffer_[13*4], 7, k5);
Subround(J, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 6*4], 7, k5);
Subround(J, a2, b2, c2, d2, e2, *(word32*)&buffer_[15*4], 8, k5);
Subround(J, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 8*4], 11, k5);
Subround(J, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 1*4], 14, k5);
Subround(J, c2, d2, e2, a2, b2, *(word32*)&buffer_[10*4], 14, k5);
Subround(J, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 3*4], 12, k5);
Subround(J, a2, b2, c2, d2, e2, *(word32*)&buffer_[12*4], 6, k5);
Subround(I, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 6*4], 9, k6);
Subround(I, d2, e2, a2, b2, c2, *(word32*)&buffer_[11*4], 13, k6);
Subround(I, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 3*4], 15, k6);
Subround(I, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 7*4], 7, k6);
Subround(I, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 0*4], 12, k6);
Subround(I, e2, a2, b2, c2, d2, *(word32*)&buffer_[13*4], 8, k6);
Subround(I, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 5*4], 9, k6);
Subround(I, c2, d2, e2, a2, b2, *(word32*)&buffer_[10*4], 11, k6);
Subround(I, b2, c2, d2, e2, a2, *(word32*)&buffer_[14*4], 7, k6);
Subround(I, a2, b2, c2, d2, e2, *(word32*)&buffer_[15*4], 7, k6);
Subround(I, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 8*4], 12, k6);
Subround(I, d2, e2, a2, b2, c2, *(word32*)&buffer_[12*4], 7, k6);
Subround(I, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 4*4], 6, k6);
Subround(I, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 9*4], 15, k6);
Subround(I, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 1*4], 13, k6);
Subround(I, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 2*4], 11, k6);
Subround(H, d2, e2, a2, b2, c2, *(word32*)&buffer_[15*4], 9, k7);
Subround(H, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 5*4], 7, k7);
Subround(H, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 1*4], 15, k7);
Subround(H, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 3*4], 11, k7);
Subround(H, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 7*4], 8, k7);
Subround(H, d2, e2, a2, b2, c2, *(word32*)&buffer_[14*4], 6, k7);
Subround(H, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 6*4], 6, k7);
Subround(H, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 9*4], 14, k7);
Subround(H, a2, b2, c2, d2, e2, *(word32*)&buffer_[11*4], 12, k7);
Subround(H, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 8*4], 13, k7);
Subround(H, d2, e2, a2, b2, c2, *(word32*)&buffer_[12*4], 5, k7);
Subround(H, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 2*4], 14, k7);
Subround(H, b2, c2, d2, e2, a2, *(word32*)&buffer_[10*4], 13, k7);
Subround(H, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 0*4], 13, k7);
Subround(H, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 4*4], 7, k7);
Subround(H, d2, e2, a2, b2, c2, *(word32*)&buffer_[13*4], 5, k7);
Subround(G, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 8*4], 15, k8);
Subround(G, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 6*4], 5, k8);
Subround(G, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 4*4], 8, k8);
Subround(G, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 1*4], 11, k8);
Subround(G, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 3*4], 14, k8);
Subround(G, c2, d2, e2, a2, b2, *(word32*)&buffer_[11*4], 14, k8);
Subround(G, b2, c2, d2, e2, a2, *(word32*)&buffer_[15*4], 6, k8);
Subround(G, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 0*4], 14, k8);
Subround(G, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 5*4], 6, k8);
Subround(G, d2, e2, a2, b2, c2, *(word32*)&buffer_[12*4], 9, k8);
Subround(G, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 2*4], 12, k8);
Subround(G, b2, c2, d2, e2, a2, *(word32*)&buffer_[13*4], 9, k8);
Subround(G, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 9*4], 12, k8);
Subround(G, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 7*4], 5, k8);
Subround(G, d2, e2, a2, b2, c2, *(word32*)&buffer_[10*4], 15, k8);
Subround(G, c2, d2, e2, a2, b2, *(word32*)&buffer_[14*4], 8, k8);
Subround(F, b2, c2, d2, e2, a2, *(word32*)&buffer_[12*4], 8, k9);
Subround(F, a2, b2, c2, d2, e2, *(word32*)&buffer_[15*4], 5, k9);
Subround(F, e2, a2, b2, c2, d2, *(word32*)&buffer_[10*4], 12, k9);
Subround(F, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 4*4], 9, k9);
Subround(F, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 1*4], 12, k9);
Subround(F, b2, c2, d2, e2, a2, *(word32*)&buffer_[ 5*4], 5, k9);
Subround(F, a2, b2, c2, d2, e2, *(word32*)&buffer_[ 8*4], 14, k9);
Subround(F, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 7*4], 6, k9);
Subround(F, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 6*4], 8, k9);
Subround(F, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 2*4], 13, k9);
Subround(F, b2, c2, d2, e2, a2, *(word32*)&buffer_[13*4], 6, k9);
Subround(F, a2, b2, c2, d2, e2, *(word32*)&buffer_[14*4], 5, k9);
Subround(F, e2, a2, b2, c2, d2, *(word32*)&buffer_[ 0*4], 15, k9);
Subround(F, d2, e2, a2, b2, c2, *(word32*)&buffer_[ 3*4], 13, k9);
Subround(F, c2, d2, e2, a2, b2, *(word32*)&buffer_[ 9*4], 11, k9);
Subround(F, b2, c2, d2, e2, a2, *(word32*)&buffer_[11*4], 11, k9);
Subround(F, a1, b1, c1, d1, e1, buffer_[ 0], 11, k0);
Subround(F, e1, a1, b1, c1, d1, buffer_[ 1], 14, k0);
Subround(F, d1, e1, a1, b1, c1, buffer_[ 2], 15, k0);
Subround(F, c1, d1, e1, a1, b1, buffer_[ 3], 12, k0);
Subround(F, b1, c1, d1, e1, a1, buffer_[ 4], 5, k0);
Subround(F, a1, b1, c1, d1, e1, buffer_[ 5], 8, k0);
Subround(F, e1, a1, b1, c1, d1, buffer_[ 6], 7, k0);
Subround(F, d1, e1, a1, b1, c1, buffer_[ 7], 9, k0);
Subround(F, c1, d1, e1, a1, b1, buffer_[ 8], 11, k0);
Subround(F, b1, c1, d1, e1, a1, buffer_[ 9], 13, k0);
Subround(F, a1, b1, c1, d1, e1, buffer_[10], 14, k0);
Subround(F, e1, a1, b1, c1, d1, buffer_[11], 15, k0);
Subround(F, d1, e1, a1, b1, c1, buffer_[12], 6, k0);
Subround(F, c1, d1, e1, a1, b1, buffer_[13], 7, k0);
Subround(F, b1, c1, d1, e1, a1, buffer_[14], 9, k0);
Subround(F, a1, b1, c1, d1, e1, buffer_[15], 8, k0);
Subround(G, e1, a1, b1, c1, d1, buffer_[ 7], 7, k1);
Subround(G, d1, e1, a1, b1, c1, buffer_[ 4], 6, k1);
Subround(G, c1, d1, e1, a1, b1, buffer_[13], 8, k1);
Subround(G, b1, c1, d1, e1, a1, buffer_[ 1], 13, k1);
Subround(G, a1, b1, c1, d1, e1, buffer_[10], 11, k1);
Subround(G, e1, a1, b1, c1, d1, buffer_[ 6], 9, k1);
Subround(G, d1, e1, a1, b1, c1, buffer_[15], 7, k1);
Subround(G, c1, d1, e1, a1, b1, buffer_[ 3], 15, k1);
Subround(G, b1, c1, d1, e1, a1, buffer_[12], 7, k1);
Subround(G, a1, b1, c1, d1, e1, buffer_[ 0], 12, k1);
Subround(G, e1, a1, b1, c1, d1, buffer_[ 9], 15, k1);
Subround(G, d1, e1, a1, b1, c1, buffer_[ 5], 9, k1);
Subround(G, c1, d1, e1, a1, b1, buffer_[ 2], 11, k1);
Subround(G, b1, c1, d1, e1, a1, buffer_[14], 7, k1);
Subround(G, a1, b1, c1, d1, e1, buffer_[11], 13, k1);
Subround(G, e1, a1, b1, c1, d1, buffer_[ 8], 12, k1);
Subround(H, d1, e1, a1, b1, c1, buffer_[ 3], 11, k2);
Subround(H, c1, d1, e1, a1, b1, buffer_[10], 13, k2);
Subround(H, b1, c1, d1, e1, a1, buffer_[14], 6, k2);
Subround(H, a1, b1, c1, d1, e1, buffer_[ 4], 7, k2);
Subround(H, e1, a1, b1, c1, d1, buffer_[ 9], 14, k2);
Subround(H, d1, e1, a1, b1, c1, buffer_[15], 9, k2);
Subround(H, c1, d1, e1, a1, b1, buffer_[ 8], 13, k2);
Subround(H, b1, c1, d1, e1, a1, buffer_[ 1], 15, k2);
Subround(H, a1, b1, c1, d1, e1, buffer_[ 2], 14, k2);
Subround(H, e1, a1, b1, c1, d1, buffer_[ 7], 8, k2);
Subround(H, d1, e1, a1, b1, c1, buffer_[ 0], 13, k2);
Subround(H, c1, d1, e1, a1, b1, buffer_[ 6], 6, k2);
Subround(H, b1, c1, d1, e1, a1, buffer_[13], 5, k2);
Subround(H, a1, b1, c1, d1, e1, buffer_[11], 12, k2);
Subround(H, e1, a1, b1, c1, d1, buffer_[ 5], 7, k2);
Subround(H, d1, e1, a1, b1, c1, buffer_[12], 5, k2);
Subround(I, c1, d1, e1, a1, b1, buffer_[ 1], 11, k3);
Subround(I, b1, c1, d1, e1, a1, buffer_[ 9], 12, k3);
Subround(I, a1, b1, c1, d1, e1, buffer_[11], 14, k3);
Subround(I, e1, a1, b1, c1, d1, buffer_[10], 15, k3);
Subround(I, d1, e1, a1, b1, c1, buffer_[ 0], 14, k3);
Subround(I, c1, d1, e1, a1, b1, buffer_[ 8], 15, k3);
Subround(I, b1, c1, d1, e1, a1, buffer_[12], 9, k3);
Subround(I, a1, b1, c1, d1, e1, buffer_[ 4], 8, k3);
Subround(I, e1, a1, b1, c1, d1, buffer_[13], 9, k3);
Subround(I, d1, e1, a1, b1, c1, buffer_[ 3], 14, k3);
Subround(I, c1, d1, e1, a1, b1, buffer_[ 7], 5, k3);
Subround(I, b1, c1, d1, e1, a1, buffer_[15], 6, k3);
Subround(I, a1, b1, c1, d1, e1, buffer_[14], 8, k3);
Subround(I, e1, a1, b1, c1, d1, buffer_[ 5], 6, k3);
Subround(I, d1, e1, a1, b1, c1, buffer_[ 6], 5, k3);
Subround(I, c1, d1, e1, a1, b1, buffer_[ 2], 12, k3);
Subround(J, b1, c1, d1, e1, a1, buffer_[ 4], 9, k4);
Subround(J, a1, b1, c1, d1, e1, buffer_[ 0], 15, k4);
Subround(J, e1, a1, b1, c1, d1, buffer_[ 5], 5, k4);
Subround(J, d1, e1, a1, b1, c1, buffer_[ 9], 11, k4);
Subround(J, c1, d1, e1, a1, b1, buffer_[ 7], 6, k4);
Subround(J, b1, c1, d1, e1, a1, buffer_[12], 8, k4);
Subround(J, a1, b1, c1, d1, e1, buffer_[ 2], 13, k4);
Subround(J, e1, a1, b1, c1, d1, buffer_[10], 12, k4);
Subround(J, d1, e1, a1, b1, c1, buffer_[14], 5, k4);
Subround(J, c1, d1, e1, a1, b1, buffer_[ 1], 12, k4);
Subround(J, b1, c1, d1, e1, a1, buffer_[ 3], 13, k4);
Subround(J, a1, b1, c1, d1, e1, buffer_[ 8], 14, k4);
Subround(J, e1, a1, b1, c1, d1, buffer_[11], 11, k4);
Subround(J, d1, e1, a1, b1, c1, buffer_[ 6], 8, k4);
Subround(J, c1, d1, e1, a1, b1, buffer_[15], 5, k4);
Subround(J, b1, c1, d1, e1, a1, buffer_[13], 6, k4);
Subround(J, a2, b2, c2, d2, e2, buffer_[ 5], 8, k5);
Subround(J, e2, a2, b2, c2, d2, buffer_[14], 9, k5);
Subround(J, d2, e2, a2, b2, c2, buffer_[ 7], 9, k5);
Subround(J, c2, d2, e2, a2, b2, buffer_[ 0], 11, k5);
Subround(J, b2, c2, d2, e2, a2, buffer_[ 9], 13, k5);
Subround(J, a2, b2, c2, d2, e2, buffer_[ 2], 15, k5);
Subround(J, e2, a2, b2, c2, d2, buffer_[11], 15, k5);
Subround(J, d2, e2, a2, b2, c2, buffer_[ 4], 5, k5);
Subround(J, c2, d2, e2, a2, b2, buffer_[13], 7, k5);
Subround(J, b2, c2, d2, e2, a2, buffer_[ 6], 7, k5);
Subround(J, a2, b2, c2, d2, e2, buffer_[15], 8, k5);
Subround(J, e2, a2, b2, c2, d2, buffer_[ 8], 11, k5);
Subround(J, d2, e2, a2, b2, c2, buffer_[ 1], 14, k5);
Subround(J, c2, d2, e2, a2, b2, buffer_[10], 14, k5);
Subround(J, b2, c2, d2, e2, a2, buffer_[ 3], 12, k5);
Subround(J, a2, b2, c2, d2, e2, buffer_[12], 6, k5);
Subround(I, e2, a2, b2, c2, d2, buffer_[ 6], 9, k6);
Subround(I, d2, e2, a2, b2, c2, buffer_[11], 13, k6);
Subround(I, c2, d2, e2, a2, b2, buffer_[ 3], 15, k6);
Subround(I, b2, c2, d2, e2, a2, buffer_[ 7], 7, k6);
Subround(I, a2, b2, c2, d2, e2, buffer_[ 0], 12, k6);
Subround(I, e2, a2, b2, c2, d2, buffer_[13], 8, k6);
Subround(I, d2, e2, a2, b2, c2, buffer_[ 5], 9, k6);
Subround(I, c2, d2, e2, a2, b2, buffer_[10], 11, k6);
Subround(I, b2, c2, d2, e2, a2, buffer_[14], 7, k6);
Subround(I, a2, b2, c2, d2, e2, buffer_[15], 7, k6);
Subround(I, e2, a2, b2, c2, d2, buffer_[ 8], 12, k6);
Subround(I, d2, e2, a2, b2, c2, buffer_[12], 7, k6);
Subround(I, c2, d2, e2, a2, b2, buffer_[ 4], 6, k6);
Subround(I, b2, c2, d2, e2, a2, buffer_[ 9], 15, k6);
Subround(I, a2, b2, c2, d2, e2, buffer_[ 1], 13, k6);
Subround(I, e2, a2, b2, c2, d2, buffer_[ 2], 11, k6);
Subround(H, d2, e2, a2, b2, c2, buffer_[15], 9, k7);
Subround(H, c2, d2, e2, a2, b2, buffer_[ 5], 7, k7);
Subround(H, b2, c2, d2, e2, a2, buffer_[ 1], 15, k7);
Subround(H, a2, b2, c2, d2, e2, buffer_[ 3], 11, k7);
Subround(H, e2, a2, b2, c2, d2, buffer_[ 7], 8, k7);
Subround(H, d2, e2, a2, b2, c2, buffer_[14], 6, k7);
Subround(H, c2, d2, e2, a2, b2, buffer_[ 6], 6, k7);
Subround(H, b2, c2, d2, e2, a2, buffer_[ 9], 14, k7);
Subround(H, a2, b2, c2, d2, e2, buffer_[11], 12, k7);
Subround(H, e2, a2, b2, c2, d2, buffer_[ 8], 13, k7);
Subround(H, d2, e2, a2, b2, c2, buffer_[12], 5, k7);
Subround(H, c2, d2, e2, a2, b2, buffer_[ 2], 14, k7);
Subround(H, b2, c2, d2, e2, a2, buffer_[10], 13, k7);
Subround(H, a2, b2, c2, d2, e2, buffer_[ 0], 13, k7);
Subround(H, e2, a2, b2, c2, d2, buffer_[ 4], 7, k7);
Subround(H, d2, e2, a2, b2, c2, buffer_[13], 5, k7);
Subround(G, c2, d2, e2, a2, b2, buffer_[ 8], 15, k8);
Subround(G, b2, c2, d2, e2, a2, buffer_[ 6], 5, k8);
Subround(G, a2, b2, c2, d2, e2, buffer_[ 4], 8, k8);
Subround(G, e2, a2, b2, c2, d2, buffer_[ 1], 11, k8);
Subround(G, d2, e2, a2, b2, c2, buffer_[ 3], 14, k8);
Subround(G, c2, d2, e2, a2, b2, buffer_[11], 14, k8);
Subround(G, b2, c2, d2, e2, a2, buffer_[15], 6, k8);
Subround(G, a2, b2, c2, d2, e2, buffer_[ 0], 14, k8);
Subround(G, e2, a2, b2, c2, d2, buffer_[ 5], 6, k8);
Subround(G, d2, e2, a2, b2, c2, buffer_[12], 9, k8);
Subround(G, c2, d2, e2, a2, b2, buffer_[ 2], 12, k8);
Subround(G, b2, c2, d2, e2, a2, buffer_[13], 9, k8);
Subround(G, a2, b2, c2, d2, e2, buffer_[ 9], 12, k8);
Subround(G, e2, a2, b2, c2, d2, buffer_[ 7], 5, k8);
Subround(G, d2, e2, a2, b2, c2, buffer_[10], 15, k8);
Subround(G, c2, d2, e2, a2, b2, buffer_[14], 8, k8);
Subround(F, b2, c2, d2, e2, a2, buffer_[12], 8, k9);
Subround(F, a2, b2, c2, d2, e2, buffer_[15], 5, k9);
Subround(F, e2, a2, b2, c2, d2, buffer_[10], 12, k9);
Subround(F, d2, e2, a2, b2, c2, buffer_[ 4], 9, k9);
Subround(F, c2, d2, e2, a2, b2, buffer_[ 1], 12, k9);
Subround(F, b2, c2, d2, e2, a2, buffer_[ 5], 5, k9);
Subround(F, a2, b2, c2, d2, e2, buffer_[ 8], 14, k9);
Subround(F, e2, a2, b2, c2, d2, buffer_[ 7], 6, k9);
Subround(F, d2, e2, a2, b2, c2, buffer_[ 6], 8, k9);
Subround(F, c2, d2, e2, a2, b2, buffer_[ 2], 13, k9);
Subround(F, b2, c2, d2, e2, a2, buffer_[13], 6, k9);
Subround(F, a2, b2, c2, d2, e2, buffer_[14], 5, k9);
Subround(F, e2, a2, b2, c2, d2, buffer_[ 0], 15, k9);
Subround(F, d2, e2, a2, b2, c2, buffer_[ 3], 13, k9);
Subround(F, c2, d2, e2, a2, b2, buffer_[ 9], 11, k9);
Subround(F, b2, c2, d2, e2, a2, buffer_[11], 11, k9);
c1 = digest_[1] + c1 + d2;
digest_[1] = digest_[2] + d1 + e2;
......
extra/yassl/taocrypt/src/rsa.cpp
View file @ 75c13cbe
......@@ -24,7 +24,6 @@
#include "rsa.hpp"
#include "asn.hpp"
#include "modarith.hpp"
#include "stdexcept.hpp"
......
extra/yassl/taocrypt/src/sha.cpp
View file @ 75c13cbe
......@@ -29,7 +29,7 @@
namespace TaoCrypt {
#define blk0(i) (W[i] = (*reinterpret_cast<word32*>(&buffer_[i*4])))
#define blk0(i) (W[i] = buffer_[i])
#define blk1(i) (W[i&15] = \
rotlFixed(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15],1))
......@@ -85,10 +85,11 @@ SHA& SHA::operator= (const SHA& that)
void SHA::Swap(SHA& other)
{
mySTL::swap(buffer_, other.buffer_);
mySTL::swap(buffLen_, other.buffLen_);
mySTL::swap(digest_, other.digest_);
mySTL::swap(length_, other.length_);
mySTL::swap(buffLen_, other.buffLen_);
memcpy(digest_, other.digest_, DIGEST_SIZE);
memcpy(buffer_, other.buffer_, BLOCK_SIZE);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7