ScuroNeko
/
VMProtect
mirror of https://github.com/Obfuscator-Collections/VMProtect.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
VMProtect/runtime/crypto.cc

1086 lines
25 KiB
C++
Raw Blame History

#include "common.h"
#include "crypto.h"
uint32_t rand32()
{
uint32_t v1 = rand();
uint32_t v2 = rand();
return (v1 << 16) | v2;
}
uint64_t rand64()
{
uint64_t v1 = rand32();
uint64_t v2 = rand32();
return (v1 << 32) | v2;
}
/**
* CipherRC5
*/
CipherRC5::CipherRC5(const RC5Key &key)
{
#ifndef RUNTIME
P = key.P;
Q = key.Q;
#endif
uint32_t i, j, k, u = w / 8, A, B, L[c];
for (i = b - 1, L[c - 1] = 0; i != (uint32_t)-1; i--) //-V621
L[i / u] = (L[i / u] << 8) + key.Value[i];
for (S[0] = P, i = 1; i < t; i++)
S[i] = S[i - 1] + Q;
for (A = B = i = j = k = 0; k < 3 * t; k++, i = (i + 1) % t, j = (j + 1) % c) /* 3*t > 3*c */
{
A = S[i] = _rotl32(S[i] + (A + B), 3);
B = L[j] = _rotl32(L[j] + (A + B), (A + B));
}
}
void CipherRC5::Encrypt(const uint32_t *in, uint32_t *out) const
{
uint32_t i, A = in[0] + S[0], B = in[1] + S[1];
for (i = 1; i <= r; i++)
{
A = _rotl32(A ^ B, B) + S[2 * i];
B = _rotl32(B ^ A, A) + S[2 * i + 1];
}
out[0] = A;
out[1] = B;
}
void CipherRC5::Decrypt(const uint32_t *in, uint32_t *out) const
{
uint32_t i, B = in[1], A = in[0];
for (i = r; i > 0; i--) {
B = _rotr32(B - S[2 * i + 1], A) ^ A;
A = _rotr32(A - S[2 * i], B) ^ B;
}
out[1] = B - S[1];
out[0] = A - S[0];
}
void CipherRC5::Encrypt(uint8_t *buff, size_t count) const
{
for (size_t i = 0; i < count; i += 8) {
Encrypt(reinterpret_cast<uint32_t *>(buff + i), reinterpret_cast<uint32_t *>(buff + i));
}
}
void CipherRC5::Decrypt(const uint8_t *in, uint8_t *out, size_t count) const
{
for (size_t i = 0; i < count; i += 8) {
Decrypt(reinterpret_cast<const uint32_t *>(in + i), reinterpret_cast<uint32_t *>(out + i));
}
}
/**
* RC5Key
*/
void RC5Key::Create()
{
#ifdef RUNTIME
uint64_t key = __rdtsc();
key ^= ~key << 32;
uint8_t *p = reinterpret_cast<uint8_t *>(&key);
for (size_t i = 0; i < _countof(Value); i++) {
Value[i] = p[i];
}
#else
for (size_t i = 0; i < _countof(Value); i++) {
Value[i] = rand();
}
P = rand32();
Q = rand32();
#endif
}
/**
* BigNumber
*/
BigNumber::BigNumber()
{
init(0);
}
BigNumber::BigNumber(const uint8_t *data, size_t size, bool inverse_order)
{
size_t w, i;
w = (size + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES; /* bytes->words */
init(w);
if (inverse_order) {
if (size)
memcpy(&data_[1], data, size);
} else {
for (i = size; i--;) {
uint8_t byte = *data++;
bignum_set_word(data_ + 1 + i / BIGNUM_INT_BYTES, bignum_get_word(data_ + 1 + i / BIGNUM_INT_BYTES) | byte << (8*i % BIGNUM_INT_BITS));
}
}
while (bignum_get_word(data_ + 0) > 1 && bignum_get_word(data_ + bignum_get_word(data_ + 0)) == 0)
bignum_set_word(data_ + 0, bignum_get_word(data_ + 0) - 1);
}
BigNumber::BigNumber(const BigNumber &src)
{
size_t size = src.data(0);
init(size);
for (size_t i = 1; i <= size; i++) {
bignum_set_word(data_ + i, src.data(i));
}
}
BigNumber::BigNumber(Bignum data, const BignumInt *salt)
{
data_ = data;
#ifdef RUNTIME
for (size_t i = 0; i < _countof(salt_); i++) {
salt_[i] = salt[i];
}
#endif
}
BigNumber::~BigNumber()
{
delete [] data_;
}
bool BigNumber::operator < (const BigNumber &b) const
{
return (bignum_cmp(b) < 0);
}
size_t BigNumber::size() const
{
return data(0) * BIGNUM_INT_BYTES;
}
uint8_t BigNumber::operator [] (size_t index) const
{
return bignum_byte(data_, index);
}
#define MUL_WORD(w1, w2) ((BignumDblInt)w1 * w2)
#define DIVMOD_WORD(q, r, hi, lo, w) { \
BignumDblInt n = (((BignumDblInt)hi) << BIGNUM_INT_BITS) | lo; \
q = n / w; \
r = n % w; \
}
BignumInt BigNumber::bignum_get_word(Bignum b) const
{
#ifdef RUNTIME
size_t addr = reinterpret_cast<size_t>(b);
size_t offset = (addr + (addr >> 7)) % _countof(salt_);
size_t salt = salt_[offset] + 0x73 + (addr >> 4);
return static_cast<BignumInt>((*b ^ salt) + addr);
#else
return *b;
#endif
}
void BigNumber::bignum_set_word(Bignum b, BignumInt value) const
{
#ifdef RUNTIME
size_t addr = reinterpret_cast<size_t>(b);
size_t offset = (addr + (addr >> 7)) % _countof(salt_);
size_t salt = salt_[offset] + 0x73 + (addr >> 4);
*b = static_cast<BignumInt>((value - addr) ^ salt);
#else
*b = value;
#endif
}
void BigNumber::init(size_t length)
{
data_ = new BignumInt[length + 1];
#ifdef RUNTIME
{
uint64_t rand = __rdtsc();
SHA1 hash;
hash.Input(reinterpret_cast<const uint8_t *>(&rand), sizeof(rand));
hash.Input(reinterpret_cast<const uint8_t *>(&data_), sizeof(data_));
const BignumInt *p = reinterpret_cast<const BignumInt *>(hash.Result());
for (size_t i = 0; i < _countof(salt_); i++) {
salt_[i] = p[i];
}
}
#endif
bignum_set_word(data_, (BignumInt)length);
for (size_t i = 1; i <= length; i++)
bignum_set_word(data_ + i, 0);
}
void BigNumber::internal_mul(BignumInt *a, BignumInt *b, BignumInt *c, int len) const
{
int i, j;
BignumDblInt t;
for (j = 0; j < 2 * len; j++)
bignum_set_word(c + j, 0);
for (i = len - 1; i >= 0; i--) {
t = 0;
for (j = len - 1; j >= 0; j--) {
t += MUL_WORD(bignum_get_word(a + i), (BignumDblInt) bignum_get_word(b + j));
t += (BignumDblInt) bignum_get_word(c + i + j + 1);
bignum_set_word(c + i + j + 1, (BignumInt) t);
t = t >> BIGNUM_INT_BITS;
}
bignum_set_word(c + i, (BignumInt) t);
}
}
void BigNumber::internal_add_shifted(BignumInt *number, unsigned n, int shift) const
{
int word = 1 + (shift / BIGNUM_INT_BITS);
int bshift = shift % BIGNUM_INT_BITS;
BignumDblInt addend;
addend = (BignumDblInt)n << bshift;
while (addend) {
addend += bignum_get_word(number + word);
bignum_set_word(number + word, (BignumInt) addend & BIGNUM_INT_MASK);
addend >>= BIGNUM_INT_BITS;
word++;
}
}
void BigNumber::internal_mod(BignumInt *a, int alen,
BignumInt *m, int mlen,
BignumInt *quot, int qshift) const
{
BignumInt m0, m1;
unsigned int h;
int i, k;
m0 = bignum_get_word(m + 0);
m1 = (mlen > 1) ? bignum_get_word(m + 1) : 0;
for (i = 0; i <= alen - mlen; i++) {
BignumDblInt t;
unsigned int q, r, c, ai1;
if (i == 0) {
h = 0;
} else {
h = bignum_get_word(a + i - 1);
bignum_set_word(a + i - 1, 0);
}
if (i == alen - 1)
ai1 = 0;
else
ai1 = bignum_get_word(a + i + 1);
/* Find q = h:a[i] / m0 */
DIVMOD_WORD(q, r, h, bignum_get_word(a + i), m0);
/* Refine our estimate of q by looking at h:a[i]:a[i+1] / m0:m1 */
t = MUL_WORD(m1, q);
if (t > ((BignumDblInt) r << BIGNUM_INT_BITS) + ai1) {
q--;
t -= m1;
r = (r + m0) & BIGNUM_INT_MASK; /* overflow? */
if (r >= (BignumDblInt) m0 &&
t > ((BignumDblInt) r << BIGNUM_INT_BITS) + ai1) q--;
}
/* Subtract q * m from a[i...] */
c = 0;
for (k = mlen - 1; k >= 0; k--) {
t = MUL_WORD(q, bignum_get_word(m + k));
t += c;
c = t >> BIGNUM_INT_BITS;
if ((BignumInt) t > bignum_get_word(a + i + k))
c++;
bignum_set_word(a + i + k, bignum_get_word(a + i + k) - (BignumInt) t);
}
/* Add back m in case of borrow */
if (c != h) {
t = 0;
for (k = mlen - 1; k >= 0; k--) {
t += bignum_get_word(m + k);
t += bignum_get_word(a + i + k);
bignum_set_word(a + i + k, (BignumInt) t);
t = t >> BIGNUM_INT_BITS;
}
q--;
}
if (quot)
internal_add_shifted(quot, q, qshift + BIGNUM_INT_BITS * (alen - mlen - i));
}
}
BigNumber BigNumber::modpow(const BigNumber &exp, const BigNumber &mod) const
{
BignumInt *a, *b, *n, *m;
int mshift;
int i,j,mlen;
Bignum result;
/* Allocate m of size mlen, copy mod to m */
/* We use big endian internally */
mlen = mod.data(0);
#ifdef WIN_DRIVER
NT_ASSERT(mlen > 0);
#else
assert(mlen > 0);
#endif
if(mlen <= 0) return BigNumber();
m = new BignumInt[mlen];
for (j = 0; j < mlen; j++)
bignum_set_word(m + j, mod.data(mlen - j));
/* Shift m left to make msb bit set */
for (mshift = 0; mshift < BIGNUM_INT_BITS-1; mshift++)
if ((bignum_get_word(m + 0) << mshift) & BIGNUM_TOP_BIT)
break;
if (mshift) {
for (i = 0; i < mlen - 1; i++)
m[i] = (bignum_get_word(m + i) << mshift) | (bignum_get_word(m + i + 1) >> (BIGNUM_INT_BITS - mshift));
bignum_set_word(m + mlen - 1, bignum_get_word(m + mlen - 1) << mshift);
}
/* Allocate n of size mlen, copy base to n */
int blen = data(0);
n = new BignumInt[mlen];
i = mlen - blen;
for (j = 0; j < i; j++)
bignum_set_word(n + j, 0);
for (j = 0; j < blen; j++)
bignum_set_word(n + i + j, data(blen - j));
/* Allocate a and b of size 2*mlen. Set a = 1 */
a = new BignumInt[2 * mlen];
b = new BignumInt[2 * mlen];
for (i = 0; i < 2 * mlen; i++)
bignum_set_word(a + i, 0);
bignum_set_word(a + 2 * mlen - 1, 1);
/* Skip leading zero bits of exp. */
i = 0;
j = BIGNUM_INT_BITS-1;
int elen = exp.data(0);
while (i < elen && (exp.data(elen - i) & (1 << j)) == 0) {
j--;
if (j < 0) {
i++;
j = BIGNUM_INT_BITS-1;
}
}
/* Main computation */
while (i < elen) {
while (j >= 0) {
internal_mul(a + mlen, a + mlen, b, mlen);
internal_mod(b, mlen * 2, m, mlen, NULL, 0);
if ((exp.data(elen - i) & (1 << j)) != 0) {
internal_mul(b + mlen, n, a, mlen);
internal_mod(a, mlen * 2, m, mlen, NULL, 0);
} else {
BignumInt *t;
t = a;
a = b;
b = t;
}
j--;
}
i++;
j = BIGNUM_INT_BITS-1;
}
/* Fixup result in case the modulus was shifted */
if (mshift) {
for (i = mlen - 1; i < 2 * mlen - 1; i++)
a[i] = (bignum_get_word(a + i) << mshift) | (bignum_get_word(a + i + 1) >> (BIGNUM_INT_BITS - mshift));
bignum_set_word(a + 2 * mlen - 1, bignum_get_word(a + 2 * mlen - 1) << mshift);
internal_mod(a, mlen * 2, m, mlen, NULL, 0);
for (i = 2 * mlen - 1; i >= mlen; i--)
bignum_set_word(a + i, (bignum_get_word(a + i) >> mshift) | (bignum_get_word(a + i - 1) << (BIGNUM_INT_BITS - mshift)));
}
/* Copy result to buffer */
result = new BignumInt[mlen + 1];
bignum_set_word(result, (BignumInt)mlen);
for (i = 0; i < mlen; i++)
bignum_set_word(result + mlen - i, bignum_get_word(a + i + mlen));
while (bignum_get_word(result + 0) > 1 && bignum_get_word(result + bignum_get_word(result + 0)) == 0)
bignum_set_word(result + 0, bignum_get_word(result + 0) - 1);
/* Free temporary arrays */
delete [] a;
delete [] b;
delete [] m;
delete [] n;
return BigNumber(result,
#ifdef RUNTIME
salt_
#else
NULL
#endif
);
}
CryptoContainer *BigNumber::modpow(const CryptoContainer &source, size_t exp_offset, size_t exp_size, size_t mod_offset, size_t mod_size) const
{
BignumInt *a, *b, *n, *m, *e, *mem, *next;
int mshift;
int i, j, mlen, elen, blen;
Bignum result;
size_t k;
size_t arrays[5];
mlen = (int)(mod_size + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES;
elen = (int)(exp_size + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES;
#ifdef WIN_DRIVER
NT_ASSERT(mlen > 0);
#else
assert(mlen > 0);
#endif
if (mlen <= 0 || data(0) > mlen) return NULL;
for (k = 0; k < _countof(arrays); k++) {
arrays[k] = k;
}
for (k = 0; k < _countof(arrays); k++) {
uint64_t rand = __rdtsc();
size_t r = static_cast<size_t>(rand ^ (rand >> 32)) % _countof(arrays);
size_t t = arrays[k];
arrays[k] = arrays[r];
arrays[r] = t;
}
// Allocate memory for temporary arrays
mem = new BignumInt[mlen + mlen + mlen * 2 + mlen * 2 + elen];
next = mem;
for (k = 0; k < _countof(arrays); k++) {
switch (arrays[k]) {
case 0:
/* Allocate m of size mlen, copy mod to m */
m = next;
next = m + mlen;
for (j = 0; j < mlen; j++) {
BignumInt value = 0;
for (i = 0; i < BIGNUM_INT_BYTES; i++) {
value = (value << 8) | source.GetByte(mod_offset++);
}
bignum_set_word(m + j, value);
}
/* Shift m left to make msb bit set */
for (mshift = 0; mshift < BIGNUM_INT_BITS - 1; mshift++)
if ((bignum_get_word(m + 0) << mshift) & BIGNUM_TOP_BIT)
break;
if (mshift) {
for (i = 0; i < mlen - 1; i++)
m[i] = (bignum_get_word(m + i) << mshift) | (bignum_get_word(m + i + 1) >> (BIGNUM_INT_BITS - mshift));
bignum_set_word(m + mlen - 1, bignum_get_word(m + mlen - 1) << mshift);
}
break;
case 1:
/* Allocate e of size elen, copy exp to e */
e = next;
next = next + elen;
for (j = 0; j < elen; j++) {
BignumInt value = 0;
for (i = 0; i < BIGNUM_INT_BYTES; i++) {
value = (value << 8) | source.GetByte(exp_offset++);
}
bignum_set_word(e + j, value);
}
break;
case 2:
/* Allocate n of size mlen, copy base to n */
n = next;
next = next + mlen;
blen = data(0);
i = mlen - blen;
for (j = 0; j < i; j++)
bignum_set_word(n + j, 0);
for (j = 0; j < blen; j++)
bignum_set_word(n + i + j, data(blen - j));
break;
case 3:
/* Allocate a of size 2*mlen. Set a = 1 */
a = next;
next = next + 2 * mlen;
for (i = 0; i < 2 * mlen; i++)
bignum_set_word(a + i, 0);
bignum_set_word(a + 2 * mlen - 1, 1);
break;
case 4:
/* Allocate b of size 2*mlen */
b = next;
next = next + 2 * mlen;
break;
}
}
/* Skip leading zero bits of exp. */
i = 0;
j = BIGNUM_INT_BITS - 1;
while (i < elen && (bignum_get_word(e + i) & (1 << j)) == 0) {
j--;
if (j < 0) {
i++;
j = BIGNUM_INT_BITS - 1;
}
}
/* Main computation */
while (i < elen) {
while (j >= 0) {
internal_mul(a + mlen, a + mlen, b, mlen);
internal_mod(b, mlen * 2, m, mlen, NULL, 0);
if ((bignum_get_word(e + i) & (1 << j)) != 0) {
internal_mul(b + mlen, n, a, mlen);
internal_mod(a, mlen * 2, m, mlen, NULL, 0);
}
else {
BignumInt *t;
t = a;
a = b;
b = t;
}
j--;
}
i++;
j = BIGNUM_INT_BITS - 1;
}
/* Fixup result in case the modulus was shifted */
if (mshift) {
for (i = mlen - 1; i < 2 * mlen - 1; i++)
a[i] = (bignum_get_word(a + i) << mshift) | (bignum_get_word(a + i + 1) >> (BIGNUM_INT_BITS - mshift));
bignum_set_word(a + 2 * mlen - 1, bignum_get_word(a + 2 * mlen - 1) << mshift);
internal_mod(a, mlen * 2, m, mlen, NULL, 0);
for (i = 2 * mlen - 1; i >= mlen; i--)
bignum_set_word(a + i, (bignum_get_word(a + i) >> mshift) | (bignum_get_word(a + i - 1) << (BIGNUM_INT_BITS - mshift)));
}
/* Copy result to buffer */
result = b;
for (i = 0; i < mlen; i++)
bignum_set_word(result + mlen - i, bignum_get_word(a + i + mlen));
while (mlen > 1 && bignum_get_word(result + mlen) == 0)
mlen--;
bignum_set_word(result, (BignumInt)mlen);
size_t size = bignum_get_word(result + 0) * BIGNUM_INT_BYTES;
RC5Key key;
key.Create();
CryptoContainer *res = new CryptoContainer(size, key);
for (k = 0; k < size; k++) {
// BigNumber has inverse order of bytes
res->SetByte(k, bignum_byte(result, size - 1 - k));
}
/* Free temporary arrays */
delete[] mem;
return res;
}
NOINLINE uint8_t BigNumber::bignum_byte(Bignum bn, size_t i) const
{
if (i >= BIGNUM_INT_BYTES * (size_t)bignum_get_word(bn + 0))
return 0; /* beyond the end */
else
return (bignum_get_word(bn + i / BIGNUM_INT_BYTES + 1) >>
((i % BIGNUM_INT_BYTES)*8)) & 0xFF;
}
int BigNumber::bignum_cmp(const BigNumber &b) const
{
int amax = data(0), bmax = b.data(0);
int i = (amax > bmax ? amax : bmax);
while (i) {
BignumInt aval = (i > amax ? 0 : data(i));
BignumInt bval = (i > bmax ? 0 : b.data(i));
if (aval < bval)
return -1;
if (aval > bval)
return +1;
i--;
}
return 0;
}
/**
* CryptoContainer
*/
CryptoContainer::CryptoContainer(size_t size, const RC5Key &key)
: is_own_data_(true), size_(size)
{
// align size
size = (size + RC5_BLOCK_SIZE - 1) / RC5_BLOCK_SIZE * RC5_BLOCK_SIZE;
data_ = new uint32_t[size / sizeof(uint32_t)];
cipher_ = new CipherRC5(key);
}
CryptoContainer::CryptoContainer(uint8_t *data, size_t size, const RC5Key &key)
: is_own_data_(false), data_(reinterpret_cast<uint32_t *>(data)), size_(size)
{
cipher_ = new CipherRC5(key);
}
CryptoContainer::CryptoContainer(const BigNumber &bn)
: is_own_data_(true)
{
RC5Key key;
key.Create();
cipher_ = new CipherRC5(key);
// align size
size_t len = bn.size();
size_ = (len + RC5_BLOCK_SIZE - 1) / RC5_BLOCK_SIZE * RC5_BLOCK_SIZE;
data_ = new uint32_t[size_ / sizeof(uint32_t)];
for (size_t i = 0; i < len; i++) {
// BigNumber has inverse order of bytes
SetByte(i, bn[len - 1 - i]);
}
}
CryptoContainer::~CryptoContainer()
{
delete cipher_;
if (is_own_data_)
delete [] data_;
}
bool CryptoContainer::EncryptValue(size_t pos, uint8_t *value, size_t value_size) const
{
if (pos > size_ - value_size)
return false;
uint32_t buff[4];
size_t block_pos = pos / RC5_BLOCK_SIZE;
pos = pos % RC5_BLOCK_SIZE;
size_t block_count = (pos <= RC5_BLOCK_SIZE - value_size) ? 1 : 2;
for (size_t i = 0; i < block_count; i++) {
cipher_->Decrypt(&data_[block_pos * 2 + i * 2], &buff[i * 2]);
}
uint8_t *p = reinterpret_cast<uint8_t *>(buff);
for (size_t i = 0; i < value_size; i++) {
p[pos + i] = value[i];
}
for (size_t i = 0; i < block_count; i++) {
cipher_->Encrypt(&buff[i * 2], &data_[block_pos * 2 + i * 2]);
}
return true;
}
bool CryptoContainer::DecryptValue(size_t pos, uint8_t *value, size_t value_size) const
{
if (pos > size_ - value_size)
return false;
uint32_t buff[4];
size_t block_pos = pos / RC5_BLOCK_SIZE;
pos = pos % RC5_BLOCK_SIZE;
size_t block_count = (pos <= RC5_BLOCK_SIZE - value_size) ? 1 : 2;
for (size_t i = 0; i < block_count; i++) {
cipher_->Decrypt(&data_[block_pos * 2 + i * 2], &buff[i * 2]);
}
uint8_t *p = reinterpret_cast<uint8_t *>(buff);
for (size_t i = 0; i < value_size; i++) {
value[i] = p[pos + i];
}
return true;
}
uint32_t CryptoContainer::GetDWord(size_t pos) const
{
uint32_t res;
if (DecryptValue(pos, reinterpret_cast<uint8_t *>(&res), sizeof(res)))
return res;
return -1;
}
uint16_t CryptoContainer::GetWord(size_t pos) const
{
uint16_t res;
if (DecryptValue(pos, reinterpret_cast<uint8_t *>(&res), sizeof(res)))
return res;
return -1;
}
uint8_t CryptoContainer::GetByte(size_t pos) const
{
uint8_t res;
if (DecryptValue(pos, reinterpret_cast<uint8_t *>(&res), sizeof(res)))
return res;
return -1;
}
uint64_t CryptoContainer::GetQWord(size_t pos) const
{
uint64_t res;
if (DecryptValue(pos, reinterpret_cast<uint8_t *>(&res), sizeof(res)))
return res;
return -1;
}
bool CryptoContainer::SetDWord(size_t pos, uint32_t value) const
{
return EncryptValue(pos, reinterpret_cast<uint8_t *>(&value), sizeof(value));
}
bool CryptoContainer::SetWord(size_t pos, uint16_t value) const
{
return EncryptValue(pos, reinterpret_cast<uint8_t *>(&value), sizeof(value));
}
bool CryptoContainer::SetByte(size_t pos, uint8_t value) const
{
return EncryptValue(pos, reinterpret_cast<uint8_t *>(&value), sizeof(value));
}
static const uint8_t utf8_limits[5] = {0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
void CryptoContainer::UTF8ToUnicode(size_t offset, size_t len, VMP_WCHAR *dest, size_t dest_size) const
{
if (!dest || dest_size == 0) return; // nothing to do
size_t pos = 0;
size_t dest_pos = 0;
while (pos < len && dest_pos < dest_size) {
uint8_t b = GetByte(offset + pos++);
if (b < 0x80) {
dest[dest_pos++] = b;
continue;
}
size_t val_len;
for (val_len = 0; val_len < _countof(utf8_limits); val_len++) {
if (b < utf8_limits[val_len])
break;
}
if (val_len == 0)
continue;
uint32_t value = b - utf8_limits[val_len - 1];
for (size_t i = 0; i < val_len; i++) {
if (pos == len)
break;
b = GetByte(offset + pos++);
if (b < 0x80 || b >= 0xC0)
break;
value <<= 6;
value |= (b - 0x80);
}
if (value < 0x10000) {
dest[dest_pos++] = static_cast<uint16_t>(value);
} else if (value <= 0x10FFFF) {
value -= 0x10000;
dest[dest_pos++] = static_cast<uint16_t>(0xD800 + (value >> 10));
dest[dest_pos++] = static_cast<uint16_t>(0xDC00 + (value & 0x3FF));
}
}
if (dest_pos < dest_size - 1)
dest[dest_pos] = 0;
else
dest[dest_pos - 1] = 0;
}
/**
* Base64
*/
bool Base64Encode(const uint8_t *src, size_t src_len, char *dst, size_t &dst_len)
{
if (!src || !dst)
return false;
const char alphabet[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
const char padchar = '=';
size_t padlen = 0;
char *out = dst;
char *dst_end = dst + dst_len;
size_t i = 0;
while (i < src_len) {
uint32_t chunk = 0;
chunk |= static_cast<uint32_t>(src[i++]) << 16;
if (i == src_len) {
padlen = 2;
} else {
chunk |= static_cast<uint32_t>(src[i++]) << 8;
if (i == src_len) {
padlen = 1;
} else {
chunk |= static_cast<uint32_t>(src[i++]);
}
}
size_t j = (chunk & 0x00fc0000) >> 18;
size_t k = (chunk & 0x0003f000) >> 12;
size_t l = (chunk & 0x00000fc0) >> 6;
size_t m = (chunk & 0x0000003f);
if (out + 4 > dst_end)
return false;
*out++ = alphabet[j];
*out++ = alphabet[k];
if (padlen > 1) *out++ = padchar;
else *out++ = alphabet[l];
if (padlen > 0) *out++ = padchar;
else *out++ = alphabet[m];
}
dst_len = out - dst;
return true;
}
size_t Base64EncodeGetRequiredLength(size_t src_len)
{
return src_len * 4 / 3 + 3;
}
bool Base64Decode(const char *src, size_t src_len, uint8_t *dst, size_t &dst_len)
{
if (!src || !dst)
return false;
size_t buf = 0;
size_t nbits = 0;
size_t offset = 0;
for (size_t i = 0; i < src_len; ++i) {
char c = src[i];
int d;
if (c >= 'A' && c <= 'Z') {
d = c - 'A';
} else if (c >= 'a' && c <= 'z') {
d = c - 'a' + 26;
} else if (c >= '0' && c <= '9') {
d = c - '0' + 52;
} else if (c == '+') {
d = 62;
} else if (c == '/') {
d = 63;
} else {
d = -1;
}
if (d != -1) {
buf = (buf << 6) | d;
nbits += 6;
if (nbits >= 8) {
nbits -= 8;
if (offset == dst_len)
return false;
dst[offset++] = static_cast<uint8_t>(buf >> nbits);
buf &= size_t((1 << nbits) - 1);
}
}
}
dst_len = offset;
return true;
}
/**
* SHA1
*/
SHA1::SHA1()
{
Reset();
}
void SHA1::Reset()
{
length_low_ = 0;
length_high_ = 0;
message_block_index_ = 0;
hash_[0] = 0x67452301;
hash_[1] = 0xEFCDAB89;
hash_[2] = 0x98BADCFE;
hash_[3] = 0x10325476;
hash_[4] = 0xC3D2E1F0;
computed_ = false;
}
void SHA1::Input(const uint8_t *data, size_t size)
{
if (computed_)
return;
for (size_t i = 0; i < size; i++) {
message_block_[message_block_index_++] = data[i];
length_low_ += 8;
if (!length_low_) {
// value out of DWORD
length_high_++;
}
if (message_block_index_ == 64)
ProcessMessageBlock();
}
}
void SHA1::Input(const CryptoContainer &data, size_t offset, size_t size)
{
if (computed_)
return;
for (size_t i = 0; i < size; i++) {
message_block_[message_block_index_++] = data.GetByte(offset + i);
length_low_ += 8;
if (!length_low_) {
// value out of DWORD
length_high_++;
}
if (message_block_index_ == 64)
ProcessMessageBlock();
}
}
void SHA1::ProcessMessageBlock()
{
size_t t;
uint32_t temp, W[80], A, B, C, D, E;
for (t = 0; t < 16; t++) {
W[t] = __builtin_bswap32(*reinterpret_cast<uint32_t *>(&message_block_[t * 4]));
}
for (t = 16; t < 80; t++) {
W[t] = _rotl32(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
}
A = hash_[0];
B = hash_[1];
C = hash_[2];
D = hash_[3];
E = hash_[4];
for (t = 0; t < 20; t++) {
temp = _rotl32(A, 5) + ((B & C) | ((~B) & D)) + E + W[t] + 0x5A827999;
E = D;
D = C;
C = _rotl32(B, 30);
B = A;
A = temp;
}
for(t = 20; t < 40; t++) {
temp = _rotl32(A, 5) + (B ^ C ^ D) + E + W[t] + 0x6ED9EBA1;
E = D;
D = C;
C = _rotl32(B, 30);
B = A;
A = temp;
}
for (t = 40; t < 60; t++) {
temp = _rotl32(A, 5) + ((B & C) | (B & D) | (C & D)) + E + W[t] + 0x8F1BBCDC;
E = D;
D = C;
C = _rotl32(B, 30);
B = A;
A = temp;
}
for(t = 60; t < 80; t++) {
temp = _rotl32(A, 5) + (B ^ C ^ D) + E + W[t] + 0xCA62C1D6;
E = D;
D = C;
C = _rotl32(B, 30);
B = A;
A = temp;
}
hash_[0] += A;
hash_[1] += B;
hash_[2] += C;
hash_[3] += D;
hash_[4] += E;
message_block_index_ = 0;
}
void SHA1::PadMessage()
{
message_block_[message_block_index_++] = 0x80;
if (message_block_index_ > 56) {
for (size_t i = message_block_index_; i < _countof(message_block_); i++) {
message_block_[i] = 0;
}
ProcessMessageBlock();
}
for (size_t i = message_block_index_; i < 56; i++) {
message_block_[i] = 0;
}
*reinterpret_cast<uint32_t *>(&message_block_[56]) = __builtin_bswap32(length_high_);
*reinterpret_cast<uint32_t *>(&message_block_[60]) = __builtin_bswap32(length_low_);
ProcessMessageBlock();
}
const uint8_t * SHA1::Result()
{
if (!computed_) {
PadMessage();
computed_ = true;
}
for (size_t i = 0; i < _countof(hash_); i++) {
digest_[i] = __builtin_bswap32(hash_[i]);
}
return reinterpret_cast<const uint8_t *>(&digest_[0]);
}
/**
* CRC32
*/
#ifdef RUNTIME
NOINLINE EXPORT_API uint32_t WINAPI CalcCRC(const void *key, size_t len)
#else
uint32_t CalcCRC(const void * key, size_t len)
#endif
{
uint32_t crc = 0;
const uint8_t *p = static_cast<const uint8_t *>(key);
while (len--) {
crc = crc32_table[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
}
return ~crc;
}
Reference in New Issue View Git Blame Copy Permalink