test.cpp

这个文件是windows mysql源码

// test.cpp
// test taocrypt functionality

#include <string.h>
#include <stdio.h>

#include "runtime.hpp"
#include "sha.hpp"
#include "md5.hpp"
#include "md2.hpp"
#include "md4.hpp"
#include "ripemd.hpp"
#include "hmac.hpp"
#include "arc4.hpp"
#include "des.hpp"
#include "rsa.hpp"
#include "dsa.hpp"
#include "aes.hpp"
#include "twofish.hpp"
#include "blowfish.hpp"
#include "asn.hpp"
#include "dh.hpp"
#include "coding.hpp"
#include "random.hpp"
#include "pwdbased.hpp"



using TaoCrypt::byte;
using TaoCrypt::word32;
using TaoCrypt::SHA;
using TaoCrypt::SHA256;
using TaoCrypt::SHA224;
#ifdef WORD64_AVAILABLE
    using TaoCrypt::SHA512;
    using TaoCrypt::SHA384;
#endif
using TaoCrypt::MD5;
using TaoCrypt::MD2;
using TaoCrypt::MD4;
using TaoCrypt::RIPEMD160;
using TaoCrypt::HMAC;
using TaoCrypt::ARC4;
using TaoCrypt::DES_EDE3_CBC_Encryption;
using TaoCrypt::DES_EDE3_CBC_Decryption;
using TaoCrypt::DES_CBC_Encryption;
using TaoCrypt::DES_CBC_Decryption;
using TaoCrypt::DES_ECB_Encryption;
using TaoCrypt::DES_ECB_Decryption;
using TaoCrypt::AES_CBC_Encryption;
using TaoCrypt::AES_CBC_Decryption;
using TaoCrypt::AES_ECB_Encryption;
using TaoCrypt::AES_ECB_Decryption;
using TaoCrypt::Twofish_CBC_Encryption;
using TaoCrypt::Twofish_CBC_Decryption;
using TaoCrypt::Twofish_ECB_Encryption;
using TaoCrypt::Twofish_ECB_Decryption;
using TaoCrypt::Blowfish_CBC_Encryption;
using TaoCrypt::Blowfish_CBC_Decryption;
using TaoCrypt::Blowfish_ECB_Encryption;
using TaoCrypt::Blowfish_ECB_Decryption;
using TaoCrypt::RSA_PrivateKey;
using TaoCrypt::RSA_PublicKey;
using TaoCrypt::DSA_PrivateKey;
using TaoCrypt::DSA_PublicKey;
using TaoCrypt::DSA_Signer;
using TaoCrypt::DSA_Verifier;
using TaoCrypt::RSAES_Encryptor;
using TaoCrypt::RSAES_Decryptor;
using TaoCrypt::Source;
using TaoCrypt::FileSource;
using TaoCrypt::FileSource;
using TaoCrypt::HexDecoder;
using TaoCrypt::HexEncoder;
using TaoCrypt::Base64Decoder;
using TaoCrypt::Base64Encoder;
using TaoCrypt::CertDecoder;
using TaoCrypt::DH;
using TaoCrypt::EncodeDSA_Signature;
using TaoCrypt::DecodeDSA_Signature;
using TaoCrypt::PBKDF2_HMAC;
using TaoCrypt::tcArrayDelete;
using TaoCrypt::GetCert;
using TaoCrypt::GetPKCS_Cert;


struct testVector {
    byte*  input_;
    byte*  output_; 
    size_t inLen_;
    size_t outLen_;

    testVector(const char* in, const char* out) : input_((byte*)in),
               output_((byte*)out), inLen_(strlen(in)), outLen_(strlen(out)) {}
};

int  sha_test();
int  sha256_test();
#ifdef WORD64_AVAILABLE
    int  sha512_test();
    int  sha384_test();
#endif
int  sha224_test();
int  md5_test();
int  md2_test();
int  md4_test();
int  ripemd_test();
int  hmac_test();
int  arc4_test();
int  des_test();
int  aes_test();
int  twofish_test();
int  blowfish_test();
int  rsa_test();
int  dsa_test();
int  dh_test();
int  pwdbased_test();
int  pkcs12_test();

TaoCrypt::RandomNumberGenerator rng;


void err_sys(const char* msg, int es)
{
    printf("%s", msg);
    exit(es);    
}

// func_args from test.hpp, so don't have to pull in other junk
struct func_args {
    int    argc;
    char** argv;
    int    return_code;
};


/* 
   DES, AES, Blowfish, and Twofish need aligned (4 byte) input/output for
   processing, can turn this off by setting gpBlock(assumeAligned = false)
   but would hurt performance.  yaSSL always uses dynamic memory so we have
   at least 8 byte alignment.  This test tried to force alignment for stack
   variables (for convenience) but some compiler versions and optimizations
   seemed to be off.  So we have msgTmp variable which we copy into dynamic
   memory at runtime to ensure proper alignment, along with plain/cipher.
   Whew!
*/
const byte msgTmp[] = { // "now is the time for all " w/o trailing 0
    0x6e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
    0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
    0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
};

byte* msg    = 0;   // for block cipher input
byte* plain  = 0;   // for cipher decrypt comparison 
byte* cipher = 0;   // block output


void taocrypt_test(void* args)
{
    ((func_args*)args)->return_code = -1; // error state
    
    msg    = NEW_TC byte[24];
    plain  = NEW_TC byte[24];
    cipher = NEW_TC byte[24];

    memcpy(msg, msgTmp, 24);

    int ret = 0;
    if ( (ret = sha_test()) ) 
        err_sys("SHA      test failed!\n", ret);
    else
        printf( "SHA      test passed!\n");

    if ( (ret = sha256_test()) ) 
        err_sys("SHA-256  test failed!\n", ret);
    else
        printf( "SHA-256  test passed!\n");

    if ( (ret = sha224_test()) ) 
        err_sys("SHA-224  test failed!\n", ret);
    else
        printf( "SHA-224  test passed!\n");

#ifdef WORD64_AVAILABLE

    if ( (ret = sha512_test()) ) 
        err_sys("SHA-512  test failed!\n", ret);
    else
        printf( "SHA-512  test passed!\n");

    if ( (ret = sha384_test()) ) 
        err_sys("SHA-384  test failed!\n", ret);
    else
        printf( "SHA-384  test passed!\n");

#endif

    if ( (ret = md5_test()) ) 
        err_sys("MD5      test failed!\n", ret);
    else
        printf( "MD5      test passed!\n");

    if ( (ret = md2_test()) ) 
        err_sys("MD2      test failed!\n", ret);
    else
        printf( "MD2      test passed!\n");

    if ( (ret = md4_test()) ) 
        err_sys("MD4      test failed!\n", ret);
    else
        printf( "MD4      test passed!\n");

    if ( (ret = ripemd_test()) )
        err_sys("RIPEMD   test failed!\n", ret);
    else
        printf( "RIPEMD   test passed!\n");

    if ( ( ret = hmac_test()) )
        err_sys("HMAC     test failed!\n", ret);
    else
        printf( "HMAC     test passed!\n");

    if ( (ret = arc4_test()) )
        err_sys("ARC4     test failed!\n", ret);
    else
        printf( "ARC4     test passed!\n");

    if ( (ret = des_test()) )
        err_sys("DES      test failed!\n", ret);
    else
        printf( "DES      test passed!\n");

    if ( (ret = aes_test()) )
        err_sys("AES      test failed!\n", ret);
    else
        printf( "AES      test passed!\n");

    if ( (ret = twofish_test()) )
        err_sys("Twofish  test failed!\n", ret);
    else
        printf( "Twofish  test passed!\n");

    if ( (ret = blowfish_test()) )
        err_sys("Blowfish test failed!\n", ret);
    else
        printf( "Blowfish test passed!\n");

    if ( (ret = rsa_test()) )
        err_sys("RSA      test failed!\n", ret);
    else
        printf( "RSA      test passed!\n");

    if ( (ret = dh_test()) )
        err_sys("DH       test failed!\n", ret);
    else
        printf( "DH       test passed!\n");

    if ( (ret = dsa_test()) )
        err_sys("DSA      test failed!\n", ret);
    else
        printf( "DSA      test passed!\n");

    if ( (ret = pwdbased_test()) )
        err_sys("PBKDF2   test failed!\n", ret);
    else
        printf( "PBKDF2   test passed!\n");

    /* not ready yet
    if ( (ret = pkcs12_test()) )
        err_sys("PKCS12   test failed!\n", ret);
    else
        printf( "PKCS12   test passed!\n");
    */

    tcArrayDelete(cipher);
    tcArrayDelete(plain);
    tcArrayDelete(msg);

    ((func_args*)args)->return_code = ret;
}


// so overall tests can pull in test function 
#ifndef NO_MAIN_DRIVER

    int main(int argc, char** argv)
    {
        func_args args;

        args.argc = argc;
        args.argv = argv;

        taocrypt_test(&args);
        TaoCrypt::CleanUp();

        return args.return_code;
    }

#endif // NO_MAIN_DRIVER


void file_test(const char* file, byte* check)
{
    FILE* f;
    int   i(0);
    MD5   md5;
    byte  buf[1024];
    byte  md5sum[MD5::DIGEST_SIZE];
    
    if( !( f = fopen( file, "rb" ) )) {
        printf("Can't open %s\n", file);
        return;
    }
    while( ( i = fread(buf, 1, sizeof(buf), f )) > 0 )
        md5.Update(buf, i);
    
    md5.Final(md5sum);
    memcpy(check, md5sum, sizeof(md5sum));

    for(int j = 0; j < MD5::DIGEST_SIZE; ++j ) 
        printf( "%02x", md5sum[j] );
   
    printf("  %s\n", file);

    fclose(f);
}


int sha_test()
{
    SHA  sha;
    byte hash[SHA::DIGEST_SIZE];

    testVector test_sha[] =
    {
        testVector("abc", 
                 "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2"
                 "\x6C\x9C\xD0\xD8\x9D"),
        testVector("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
                 "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29"
                 "\xE5\xE5\x46\x70\xF1"),
        testVector("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                 "aaaaaa", 
                 "\x00\x98\xBA\x82\x4B\x5C\x16\x42\x7B\xD7\xA1\x12\x2A\x5A\x44"
                 "\x2A\x25\xEC\x64\x4D"),
        testVector("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                 "aaaaaaaaaa",
                 "\xAD\x5B\x3F\xDB\xCB\x52\x67\x78\xC2\x83\x9D\x2F\x15\x1E\xA7"
                 "\x53\x99\x5E\x26\xA0")  
    };

    int times( sizeof(test_sha) / sizeof(testVector) );
    for (int i = 0; i < times; ++i) {
        sha.Update(test_sha[i].input_, test_sha[i].inLen_);
        sha.Final(hash);

        if (memcmp(hash, test_sha[i].output_, SHA::DIGEST_SIZE) != 0)
            return -1 - i;
    }

    return 0;
}


int sha256_test()
{
    SHA256 sha;
    byte   hash[SHA256::DIGEST_SIZE];

    testVector test_sha[] =
    {
        testVector("abc",
                 "\xBA\x78\x16\xBF\x8F\x01\xCF\xEA\x41\x41\x40\xDE\x5D\xAE\x22"
                 "\x23\xB0\x03\x61\xA3\x96\x17\x7A\x9C\xB4\x10\xFF\x61\xF2\x00"
                 "\x15\xAD"),
        testVector("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
                 "\x24\x8D\x6A\x61\xD2\x06\x38\xB8\xE5\xC0\x26\x93\x0C\x3E\x60"
                 "\x39\xA3\x3C\xE4\x59\x64\xFF\x21\x67\xF6\xEC\xED\xD4\x19\xDB"
                 "\x06\xC1")
    };

    int times( sizeof(test_sha) / sizeof(testVector) );
    for (int i = 0; i < times; ++i) {
        sha.Update(test_sha[i].input_, test_sha[i].inLen_);
        sha.Final(hash);

        if (memcmp(hash, test_sha[i].output_, SHA256::DIGEST_SIZE) != 0)
            return -1 - i;
    }

    return 0;
}


#ifdef WORD64_AVAILABLE

int sha512_test()
{
    SHA512 sha;
    byte   hash[SHA512::DIGEST_SIZE];