aestmr.c

AES加密算法的VS2005工程实现

/*
 ---------------------------------------------------------------------------
 Copyright (c) 1998-2006, Brian Gladman, Worcester, UK. All rights reserved.

 LICENSE TERMS

 The free distribution and use of this software in both source and binary
 form is allowed (with or without changes) provided that:

   1. distributions of this source code include the above copyright
      notice, this list of conditions and the following disclaimer;

   2. distributions in binary form include the above copyright
      notice, this list of conditions and the following disclaimer
      in the documentation and/or other associated materials;

   3. the copyright holder's name is not used to endorse products
      built using this software without specific written permission.

 ALTERNATIVELY, provided that this notice is retained in full, this product
 may be distributed under the terms of the GNU General Public License (GPL),
 in which case the provisions of the GPL apply INSTEAD OF those given above.

 DISCLAIMER

 This software is provided 'as is' with no explicit or implied warranties
 in respect of its properties, including, but not limited to, correctness
 and/or fitness for purpose.
 ---------------------------------------------------------------------------
 Issue 16/04/2007
*/

/* Measure the Encryption, Decryption and Key Setup Times for AES using
   the Pentium Time Stamp Counter  */

#define DUAL_CORE

#if defined( DUAL_CORE ) || defined( DLL_IMPORT ) && defined( DYNAMIC_LINK )
#include <windows.h>
#endif
#include <string.h>
#include <math.h>

#if defined( __cplusplus )
#  include "aescpp.h"
#else
#  include "aes.h"
#endif
#include "aesaux.h"
#include "aestst.h"
#include "rdtsc.h"

#if defined( DLL_IMPORT ) && defined( DYNAMIC_LINK )
fn_ptrs fn;
#endif

#if defined( _M_IX86 )
#if _M_IX86 == 500
#define PROCESSOR   "Pentium"
#elif _M_IX86 == 600
#define PROCESSOR   "P2/P3/P4"
#else
#define PROCESSOR   ""
#endif
#elif defined( _M_X64 )
#define PROCESSOR   "AMD64/EMT64"
#else
#define PROCESSOR   ""
#endif

const int loops = 100; // number of timing loops

#define SAMPLE1  1000
#define SAMPLE2 10000

int time_base(double *av, double *sig)
{   int                 i, tol, lcnt, sam_cnt;
    double              cy, av1, sig1;

    tol = 10; lcnt = sam_cnt = 0;
    while(!sam_cnt)
    {
        av1 = sig1 = 0.0;

        for(i = 0; i < SAMPLE1; ++i)
        {
            cy = (double)read_tsc();
            cy = (double)read_tsc() - cy;

            av1 += cy;
            sig1 += cy * cy;
        }

        av1 /= SAMPLE1;
        sig1 = sqrt((sig1 - av1 * av1 * SAMPLE1) / SAMPLE1);
        sig1 = (sig1 < 0.05 * av1 ? 0.05 * av1 : sig1);

        *av = *sig = 0.0;
        for(i = 0; i < SAMPLE2; ++i)
        {
            cy = (double)read_tsc();
            cy = (double)read_tsc() - cy;

            if(cy > av1 - sig1 && cy < av1 + sig1)
            {
                *av += cy;
                *sig += cy * cy;
                sam_cnt++;
            }
        }

        if(10 * sam_cnt > 9 * SAMPLE2)
        {
            *av /= sam_cnt;
            *sig = sqrt((*sig - *av * *av * sam_cnt) / sam_cnt);
            if(*sig > (tol / 100.0) * *av)
                sam_cnt = 0;
        }
        else
        {
            if(lcnt++ == 10)
            {
                lcnt = 0; tol += 5;
                if(tol > 30)
                    return FALSE;
            }
            sam_cnt = 0;
        }
    }

    return TRUE;
}

typedef unsigned long long (*aes_tmr)(void);

/*  There is a compiler optimisation bug when optimisation is turned on
    in Visual Studio 2005 for the following subroutine
*/
#if defined( _MSC_VER )
#  pragma optimize( "", off )
#endif

int time_eks8(unsigned int k_len, double *av, double *sig)
{   int                 i, tol, lcnt, sam_cnt;
    double              cy, av1, sig1;
    unsigned char       key[8][2 * AES_BLOCK_SIZE];
    f_ectx              ec[1];

    block_rndfill(key[0], 16 * AES_BLOCK_SIZE);

    tol = 10; lcnt = sam_cnt = 0;
    while(!sam_cnt)
    {
        av1 = sig1 = 0.0;

        for(i = 0; i < SAMPLE1; ++i)
        {
            cy = (double)read_tsc();
            f_enc_key(ec, key[0], k_len);
            f_enc_key(ec, key[1], k_len);
            f_enc_key(ec, key[2], k_len);
            f_enc_key(ec, key[3], k_len);
            f_enc_key(ec, key[4], k_len);
            f_enc_key(ec, key[5], k_len);
            f_enc_key(ec, key[6], k_len);
            f_enc_key(ec, key[7], k_len);
            cy = (double)read_tsc() - cy;

            av1 += cy;
            sig1 += cy * cy;
        }

        av1 /= SAMPLE1;
        sig1 = sqrt((sig1 - av1 * av1 * SAMPLE1) / SAMPLE1);
        sig1 = (sig1 < 0.05 * av1 ? 0.05 * av1 : sig1);

        f_enc_key(ec, key[0], k_len);
        *av = *sig = 0.0;
        for(i = 0; i < SAMPLE2; ++i)
        {
            cy = (double)read_tsc();
            f_enc_key(ec, key[0], k_len);
            f_enc_key(ec, key[1], k_len);
            f_enc_key(ec, key[2], k_len);
            f_enc_key(ec, key[3], k_len);
            f_enc_key(ec, key[4], k_len);
            f_enc_key(ec, key[5], k_len);
            f_enc_key(ec, key[6], k_len);
            f_enc_key(ec, key[7], k_len);
            cy = (double)read_tsc() - cy;

            if(cy > av1 - sig1 && cy < av1 + sig1)
            {
                *av += cy;
                *sig += cy * cy;
                sam_cnt++;
            }
        }

        if(10 * sam_cnt > 9 * SAMPLE2)
        {
            *av /= sam_cnt;
            *sig = sqrt((*sig - *av * *av * sam_cnt) / sam_cnt);
            if(*sig > (tol / 100.0) * *av)
                sam_cnt = 0;
        }
        else
        {
            if(lcnt++ == 10)
            {
                lcnt = 0; tol += 5;
                if(tol > 30)
                    return FALSE;
            }
            sam_cnt = 0;
        }
    }

    return TRUE;
}

#if defined( _MSC_VER )
#  pragma optimize( "", on )
#endif

int time_dks8(unsigned int k_len, double *av, double *sig)
{   int                 i, tol, lcnt, sam_cnt;
    double              cy, av1, sig1;
    unsigned char       key[8][2 * AES_BLOCK_SIZE];
    f_dctx              dc[1];

    block_rndfill(key[0], 16 * AES_BLOCK_SIZE);

    tol = 10; lcnt = sam_cnt = 0;
    while(!sam_cnt)
    {
        av1 = sig1 = 0.0;

        for(i = 0; i < SAMPLE1; ++i)
        {
            cy = (double)read_tsc();
            f_dec_key(dc, key[ 0], k_len);
            f_dec_key(dc, key[ 1], k_len);
            f_dec_key(dc, key[ 2], k_len);
            f_dec_key(dc, key[ 3], k_len);
            f_dec_key(dc, key[ 4], k_len);
            f_dec_key(dc, key[ 5], k_len);
            f_dec_key(dc, key[ 6], k_len);
            f_dec_key(dc, key[ 7], k_len);
            cy = (double)read_tsc() - cy;

            av1 += cy;
            sig1 += cy * cy;
        }

        av1 /= SAMPLE1;
        sig1 = sqrt((sig1 - av1 * av1 * SAMPLE1) / SAMPLE1);
        sig1 = (sig1 < 0.05 * av1 ? 0.05 * av1 : sig1);

        *av = *sig = 0.0;
        for(i = 0; i < SAMPLE2; ++i)
        {
            cy = (double)read_tsc();
            f_dec_key(dc, key[ 0], k_len);
            f_dec_key(dc, key[ 1], k_len);
            f_dec_key(dc, key[ 2], k_len);
            f_dec_key(dc, key[ 3], k_len);
            f_dec_key(dc, key[ 4], k_len);
            f_dec_key(dc, key[ 5], k_len);
            f_dec_key(dc, key[ 6], k_len);
            f_dec_key(dc, key[ 7], k_len);
            cy = (double)read_tsc() - cy;

            if(cy > av1 - sig1 && cy < av1 + sig1)
            {
                *av += cy;
                *sig += cy * cy;
                sam_cnt++;
            }
        }

        if(10 * sam_cnt > 9 * SAMPLE2)
        {
            *av /= sam_cnt;
            *sig = sqrt((*sig - *av * *av * sam_cnt) / sam_cnt);
            if(*sig > (tol / 100.0) * *av)
                sam_cnt = 0;
        }
        else
        {
            if(lcnt++ == 10)
            {
                lcnt = 0; tol += 5;
                if(tol > 30)
                    return FALSE;
            }
            sam_cnt = 0;
        }
    }

    return TRUE;
}

int time_enc16(unsigned int k_len, double *av, double *sig)
{   int                 i, tol, lcnt, sam_cnt;
    double              cy, av1, sig1;
    unsigned char       key[2 * AES_BLOCK_SIZE], pt[4][4 * AES_BLOCK_SIZE];
    f_ectx              ec[1];

    block_rndfill(key, 2 * AES_BLOCK_SIZE);
    f_enc_key(ec, key, k_len);
    block_rndfill(pt[0], 16 * AES_BLOCK_SIZE);

    tol = 10; lcnt = sam_cnt = 0;
    while(!sam_cnt)
    {
        av1 = sig1 = 0.0;

        for(i = 0; i < SAMPLE1; ++i)
        {
            cy = (double)read_tsc();
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            cy = (double)read_tsc() - cy;

            av1 += cy;
            sig1 += cy * cy;
        }

        av1 /= SAMPLE1;
        sig1 = sqrt((sig1 - av1 * av1 * SAMPLE1) / SAMPLE1);
        sig1 = (sig1 < 0.05 * av1 ? 0.05 * av1 : sig1);

        *av = *sig = 0.0;
        for(i = 0; i < SAMPLE2; ++i)
        {
            cy = (double)read_tsc();
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            do_enc(ec, pt[0], pt[0], 1);
            do_enc(ec, pt[1], pt[1], 1);
            do_enc(ec, pt[2], pt[2], 1);
            do_enc(ec, pt[3], pt[3], 1);
            cy = (double)read_tsc() - cy;

            if(cy > av1 - sig1 && cy < av1 + sig1)
            {
                *av += cy;
                *sig += cy * cy;
                sam_cnt++;
            }
        }

        if(10 * sam_cnt > 9 * SAMPLE2)
        {
            *av /= sam_cnt;
            *sig = sqrt((*sig - *av * *av * sam_cnt) / sam_cnt);
            if(*sig > (tol / 100.0) * *av)
                sam_cnt = 0;
        }
        else
        {
            if(lcnt++ == 10)
            {
                lcnt = 0; tol += 5;
                if(tol > 30)
                    return FALSE;
            }
            sam_cnt = 0;
        }
    }

    return TRUE;
}

int time_dec16(unsigned int k_len, double *av, double *sig)
{   int                 i, tol, lcnt, sam_cnt;
    double              cy, av1, sig1;
    unsigned char       key[2 * AES_BLOCK_SIZE], pt[4][4 * AES_BLOCK_SIZE];
    f_dctx              dc[1];

    block_rndfill(key, 2 * AES_BLOCK_SIZE);
    f_dec_key(dc, key, k_len);
    block_rndfill(pt[0], 16 * AES_BLOCK_SIZE);

    tol = 10; lcnt = sam_cnt = 0;
    while(!sam_cnt)
    {
        av1 = sig1 = 0.0;

        for(i = 0; i < SAMPLE1; ++i)
        {
            cy = (double)read_tsc();
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);
            cy = (double)read_tsc() - cy;

            av1 += cy;
            sig1 += cy * cy;
        }

        av1 /= SAMPLE1;
        sig1 = sqrt((sig1 - av1 * av1 * SAMPLE1) / SAMPLE1);
        sig1 = (sig1 < 0.05 * av1 ? 0.05 * av1 : sig1);

        *av = *sig = 0.0;
        for(i = 0; i < SAMPLE2; ++i)
        {
            cy = (double)read_tsc();
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);
            do_dec(dc, pt[0], pt[0], 1);
            do_dec(dc, pt[1], pt[1], 1);
            do_dec(dc, pt[2], pt[2], 1);
            do_dec(dc, pt[3], pt[3], 1);