Skip to content

M
MariaDB
Commit 1268dbe8 authored by unknown's avatar unknown
Browse files
Options

Merge with latest yaSSL. 

Fixes IsAligned yaSSL assertion failure.


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