codec.cpp

最新版本的sqlite封装for delphi

  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); 
  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); 
  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);  
  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); 

  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); 
  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); 
  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); 
  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); 
  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);  
  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); 
  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);  
  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); 
  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); 

  buf[0] += a;
  buf[1] += b;
  buf[2] += c;
  buf[3] += d;
}
 

// ---------------------------
// RC4 implementation
// ---------------------------

/**
* RC4 is the standard encryption algorithm used in PDF format
*/

void
Codec::RC4(unsigned char* key, int keylen,
           unsigned char* textin, int textlen,
           unsigned char* textout)
{
  int i;
  int j;
  int t;
  unsigned char rc4[256];

  for (i = 0; i < 256; i++)
  {
    rc4[i] = i;
  }
  j = 0;
  for (i = 0; i < 256; i++)
  {
    t = rc4[i];
    j = (j + t + key[i % keylen]) % 256;
    rc4[i] = rc4[j];
    rc4[j] = t;
  }

  int a = 0;
  int b = 0;
  unsigned char k;
  for (i = 0; i < textlen; i++)
  {
    a = (a + 1) % 256;
    t = rc4[a];
    b = (b + t) % 256;
    rc4[a] = rc4[b];
    rc4[b] = t;
    k = rc4[(rc4[a] + rc4[b]) % 256];
    textout[i] = textin[i] ^ k;
  }
}

void
Codec::GetMD5Binary(const unsigned char* data, int length, unsigned char* digest)
{
  MD5_CTX ctx;
  MD5Init(&ctx);
  MD5Update(&ctx, data, length);
  MD5Final(digest,&ctx);
}

#define MODMULT(a, b, c, m, s) q = s / a; s = b * (s - a * q) - c * q; if (s < 0) s += m

void
Codec::GenerateInitialVector(int seed, unsigned char iv[16])
{
  unsigned char initkey[MD5_HASHBYTES];
  int j, q;
  int z = seed + 1;
  for (j = 0; j < 4; j++)
  {
    MODMULT(52774, 40692,  3791, 2147483399L, z);
    initkey[4*j+0] = 0xff &  z;
    initkey[4*j+1] = 0xff & (z >>  8);
    initkey[4*j+2] = 0xff & (z >> 16);
    initkey[4*j+3] = 0xff & (z >> 24);
  }
  GetMD5Binary((const unsigned char*) initkey, 16, iv);
}

void
Codec::AES(int page, bool encrypt, unsigned char encryptionKey[MD5_HASHBYTES],
           unsigned char* datain, int datalen, unsigned char* dataout)
{
  unsigned char initial[MD5_HASHBYTES];
  unsigned char pagekey[MD5_HASHBYTES];
  unsigned char nkey[MD5_HASHBYTES+4+4];
  int keyLength = MD5_HASHBYTES;
  int nkeylen = keyLength + 4 + 4;
  int j;
  for (j = 0; j < keyLength; j++)
  {
    nkey[j] = encryptionKey[j];
  }
  nkey[keyLength+0] = 0xff &  page;
  nkey[keyLength+1] = 0xff & (page >>  8);
  nkey[keyLength+2] = 0xff & (page >> 16);
  nkey[keyLength+3] = 0xff & (page >> 24);

  // AES encryption needs some 'salt'
  nkey[keyLength+4] = 0x73;
  nkey[keyLength+5] = 0x41;
  nkey[keyLength+6] = 0x6c;
  nkey[keyLength+7] = 0x54;

  GetMD5Binary(nkey, nkeylen, pagekey);
  GenerateInitialVector(page, initial);

  Rijndael::Direction direction = (encrypt) ? Rijndael::Encrypt : Rijndael::Decrypt;
  m_aes.init(Rijndael::CBC, direction, pagekey, Rijndael::Key16Bytes, initial);
  int len = 0;
  if (encrypt)
  {
    len = m_aes.blockEncrypt(datain, datalen*8, dataout);
  }
  else
  {
    len = m_aes.blockDecrypt(datain, datalen*8, dataout);
  }
  
  // It is a good idea to check the error code
  if (len < 0)
  {
    // AES: Error on encrypting.
  }
}

static unsigned char padding[] =
  "\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A";

Codec::Codec()
{
  m_isEncrypted = false;
  m_hasReadKey  = false;
  m_hasWriteKey = false;
}

Codec::~Codec()
{
}

void
Codec::Copy(Codec& other)
{
  int j;
  m_isEncrypted = other.m_isEncrypted;
  m_hasReadKey  = other.m_hasReadKey;
  m_hasWriteKey = other.m_hasWriteKey;
  for (j = 0; j < 16; j++)
  {
    m_readKey[j]  = other.m_readKey[j];
    m_writeKey[j] = other.m_writeKey[j];
  }
  m_bt = other.m_bt;
  m_aes.invalidate();
}

void
Codec::CopyKey(bool read2write)
{
  int j;
  if (read2write)
  {
    for (j = 0; j < 16; j++)
    {
      m_writeKey[j] = m_readKey[j];
    }
  }
  else
  {
    for (j = 0; j < 16; j++)
    {
      m_readKey[j] = m_writeKey[j];
    }
  }
}

void
Codec::PadPassword(const char* password, int pswdlen, unsigned char pswd[32])
{
  int m = pswdlen;
  if (m > 32) m = 32;

  int j;
  int p = 0;
  for (j = 0; j < m; j++)
  {
    pswd[p++] = (unsigned char) password[j];
  }
  for (j = 0; p < 32 && j < 32; j++)
  {
    pswd[p++] = padding[j];
  }
}

void
Codec::GenerateReadKey(const char* userPassword, int passwordLength)
{
  GenerateEncryptionKey(userPassword, passwordLength, m_readKey);
}

void
Codec::GenerateWriteKey(const char* userPassword, int passwordLength)
{
  GenerateEncryptionKey(userPassword, passwordLength, m_writeKey);
}

void
Codec::GenerateEncryptionKey(const char* userPassword, int passwordLength, unsigned char encryptionKey[KEYLENGTH])
{
  unsigned char userPad[32];
  unsigned char ownerPad[32];
  unsigned char ownerKey[32];

  unsigned char mkey[MD5_HASHBYTES];
  unsigned char digest[MD5_HASHBYTES];
  int keyLength = MD5_HASHBYTES;
  int i, j, k;

  // Pad passwords
  PadPassword(userPassword, passwordLength, userPad);
  PadPassword("", 0, ownerPad);

  // Compute owner key

  MD5_CTX ctx;
  MD5Init(&ctx);
  MD5Update(&ctx, ownerPad, 32);
  MD5Final(digest,&ctx);

  // only use for the input as many bit as the key consists of
  for (k = 0; k < 50; ++k)
  {
    MD5Init(&ctx);
    MD5Update(&ctx, digest, keyLength);
    MD5Final(digest,&ctx);
  }
  memcpy(ownerKey, userPad, 32);
  for (i = 0; i < 20; ++i)
  {
    for (j = 0; j < keyLength ; ++j)
    {
      mkey[j] = (digest[j] ^ i);
    }
    RC4(mkey, keyLength, ownerKey, 32, ownerKey);
  }

  // Compute encryption key

  MD5Init(&ctx);
  MD5Update(&ctx, userPad, 32);
  MD5Update(&ctx, ownerKey, 32);
  MD5Final(digest,&ctx);

  // only use the really needed bits as input for the hash
  for (k = 0; k < 50; ++k)
  {
    MD5Init(&ctx);
    MD5Update(&ctx, digest, keyLength);
    MD5Final(digest, &ctx);
  }
  memcpy(encryptionKey, digest, keyLength);
}

void
Codec::Encrypt(int page, unsigned char* data, int len, bool useWriteKey)
{
  unsigned char* key = (useWriteKey) ? m_writeKey : m_readKey;
  AES(page, true, key, data, len, data);

}

void
Codec::Decrypt(int page, unsigned char* data, int len)
{
  AES(page, false, m_readKey, data, len, data);
}