/* 
**	File: ENCRYPT$1_MBYTE_RANDOM-KEY.C 
**	
**	Encrypt 1 MB (of zeros), using a random key and AES, then Decrypt 
**	and compare data. Cycle through all the AES block and stream modes
**	using the various key sizes.
*/

/* 
** Change History 
**	Paul Mosteika 21-Jun-2006 
**		Create example for ENCRYPT$EXAMPLES
**	Paul Mosteika 26-May-2006 
**		Make separate random key (keygen) 1MB test.
**	Paul Mosteika 25-Jan-2006 
**		Created.
*/

/* 
** Build and usage notes:
**
**	Compile as normal, but for extra trace output define 
**	DEBUG_TRACE, for example:
**
**	    $ cc /define=DEBUG_TRACE ENCRYPT$1_MBYTE_RANDOM-KEY
**	    $ link ENCRYPT$1_MBYTE_RANDOM-KEY
**	    $ r ENCRYPT$1_MBYTE_RANDOM-KEY
**
**	Also look at the encrypted data in ECB mode and compare with
**	enciphered data in CBC mode. Then try changing the IV between 
**	blocks, or in this case, 64K bytes of data.
**
*/

#include <descrip>
#include <stdio>
#include <stdlib>
#include <string>
#include <ssdef>
#include <time>
#include <libdtdef>
#include <lib$routines.h>
#include "ENCRYPT$EXAMPLES:encrypt_messages.h"
#include "ENCRYPT$EXAMPLES:encrypt_def.h"
#include "ENCRYPT$EXAMPLES:encrypt_structures.h"



/* 
**	Electronic code book (ECB) and cipher block chaining (CBC) are 16 
**	character block modes. 
**	
**	Cipher feedback (CFB) and output feedback (OFB) are single character
**	stream modes.
**	
**	128 bit = 16 byte keys, 192 bit = 24, and 256 bit = 32
*/	
#define ecb128 "AESECB128" 
#define cbc128 "AESCBC128" 
#define cfb128 "AESCFB128" 
#define ofb128 "AESOFB128" 
#define ecb192 "AESECB192" 
#define cbc192 "AESCBC192" 
#define cfb192 "AESCFB192" 
#define ofb192 "AESOFB192" 
#define ecb256 "AESECB256" 
#define cbc256 "AESCBC256" 
#define cfb256 "AESCFB256" 
#define ofb256 "AESOFB256" 
#define aesmac    "AESMAC"

#define KEY_NAME_FLAG 0
#define KEY_VALUE_FLAG 1



/*
** Macro(s)
**           ENCRYPT$_SUCCESS = %d18513921 = %X11A8001
*/

#define check(status,string) \
      if (status != SS$_NORMAL && status != ENCRYPT$_SUCCESS) \
        { printf("%s\n", string); lib$signal(status); return(0); }



/* function prototypes: */

int test_aes_randomkey_1mb (char *algmodkey);   /* Encrypt - Decrrypt 1MB     */
						/* direct literal random key  */



typedef long quadw [2];

long    status = SS$_NORMAL ;












int main( int argc , char *argv[] )
{

/* 
** 	Correlate '*algmodkey[]' (pointers to the algorithm strings) 
**	that we pass as parameters to ENCRYPT$INIT() with the 
**	enumerated 'mode' that we use in the for loops.
*/

char *algmodkey[]={ ecb128 , ecb192 , ecb256 ,
		    cbc128 , cbc192 , cbc256 , 
		    cfb128 , cfb192 , cfb256 , 
		    ofb128 , ofb192 , ofb256 , 
		    aesmac }; 
int i;
/* AES */
enum modes {ECB128,	/* Electronic Code Book (ECB) block mode 	   */
	    ECB192,
	    ECB256,
	    CBC128,	/* Cipher Block Chaining (CBC) block mode 	   */
	    CBC192,
	    CBC256,
	    CFB128,	/* Cipher Feedback (CFB) stream mode 	  	   */
	    CFB192,
	    CFB256,
	    OFB128,	/* Cipher Feedback (CFB) stream mode 		   */
	    OFB192,
	    OFB256,
	    AESMAC } ;	/* A keyed file message authentication code 	   */
enum modes mode ;





    /* 
    ** - TEST_AES_RANDOMKEY_1MB - 
    **   -----------------------
    ** Test each mode and key size AESECB128, AESCBC128 . . . AESOFB256
    ** Use a litreal key direct to init, encrypt, decrypt, check results,
    ** fini (CXT).  1MB Test
    */

    for ( mode = ECB128 ; mode < AESMAC ; mode ++ )
    {
	status = test_aes_randomkey_1mb( algmodkey[mode] );

    	if (status & 1)
            printf ("\n test_aes_randomkey_1mb() MODE = %s exit status: Success\n", algmodkey[mode] );
    	else
        {
	    printf ("\n !!!!!  test_aes_randomkey_1mb() MODE = %s exit status: Failed, = %X = %d \n", 
			algmodkey[mode] , status , status );
	    return(1);
	}
    } /* End - test_aes_randomkey_1mb() */



} /* end main - and all tests */






int test_aes_randomkey_1mb (char *algmodkey)
{
/*
**	const char *algmodkey = (e.g.) "AESECB128" 	
** 
** 	Given the parameter input of the algorithm, mode, and key size,
**	test AES encryption with 1024 * 1024 data. Compare the deciphered 
**	data results in memory with original plaintext data. 
**
** 	Test each mode and key size AESECB128, AESCBC128 . . . AESOFB256
** 	Use a literal HEX value key, init, encrypt, decrypt, check results,
** 	fini (CXT).
*/

    struct stat_record stat_buf = { 0 };

    unsigned long  context     = 0;
    unsigned long  key_type    = KEY_VALUE_FLAG ;    /* Type = name or value  */
    unsigned char  key_buf[32+16] = {' '}; 	     /* Make 'key_buf' longer */
    long           status      = 0;
    long           stat1       = 0;
    long           stat_code   = 1;
    long           code        = 0;
    long           cpu_seconds = 0;
    quadw          init_vec[2] = {0x33221100,0x77665544,0xBBAA9988,0xFFEEDDCC};
    long           ret_len     = 0;
    char	   *input_buf_addrs[16];	/* 16 Pointers to 64K each */ 
    char	   *encr_out_bufs[16];
    char           *decr_out_bufs[16];
    int 	   encr_out_lens [16] = {0}; /* Make int for word size 	   */
    long           row;			     /* Index for each 64K buffer  */
    int		   i;



/*	LITERAL KEY DESCRIPTORs		
**
**      Encrypt Installation and Reference Manual: ENCRYPT$INIT()
**	---------------------------------------------------------
**
**	If the key-name argument is used to specify a key value (that is, 
**	if key-type has been specified as 1), the key-name string descriptor 
**	type field determines whether the key value is to be treated as a 
**	char_string (compressable), or as a binary value that is to be used 
**	exactly as specified.
**
**	If the descriptor type is DSC$K_DTYPE_T (char_string), DSC$K_DTYPE_VT
**	(varying char_string), or DSC$K_DTYPE_Z (unspecified), the value is 
**	treated as a text string to be compressed - DES keys only. AES
**	keys are not compressed for the final release of Encrypt V2.0 for 
**	OpenVMS 8.3.
**
**	All other descriptor types are treated as though the key value is to 
**	be used exactly as specified.
*/



    $DESCRIPTOR(key_buf_desc, "");              /* $GENERATE_KEY() random Key */
    $DESCRIPTOR(fac_a_desc,     __TIME__);      /* Randomization Factors for  */
    $DESCRIPTOR(fac_b_desc,     __DATE__);	/* $GENERATE_KEY()            */
    $DESCRIPTOR(fac_c_desc,     __FILE__);	/*     "                      */
    unsigned short key_length  = 32;		/* Size in bytes of KEYGEN Key*/
    key_buf_desc.dsc$b_dtype = DSC$K_DTYPE_NU ;	/* Numeric String Unsigned    */
    key_buf_desc.dsc$a_pointer = (char *)&key_buf; /* Random Key KEYGEN Desc. */
    key_buf_desc.dsc$w_length  = sizeof(key_buf) ;

/* Define algorithm, mode, key size */
    struct dsc$descriptor_s algo_desc;

/* Define input, output and statistics descriptors */ 
    $DESCRIPTOR(input_desc,     "");
    $DESCRIPTOR(output_desc,    "");
    $DESCRIPTOR(stat_buf_desc,  "");

    algo_desc.dsc$w_length = strlen(algmodkey) ;
    algo_desc.dsc$b_dtype  = DSC$K_DTYPE_T ;
    algo_desc.dsc$b_class  = DSC$K_CLASS_S ;
    algo_desc.dsc$a_pointer = algmodkey ;

    stat_buf_desc.dsc$a_pointer = (char *)&stat_buf;
    stat_buf_desc.dsc$w_length  = sizeof(stat_buf);

    output_desc.dsc$w_length = 64*1024-1;

    status = SS$_NORMAL;

#ifdef DEBUG_TRACE
    printf("\n\n ----- test_aes_randomkey_1mb() begins %s -----\n", 
	algmodkey );
#endif
    printf ("\n Testing %s\n", algmodkey ); 



    /* Test generation of a random key */
    memset( key_buf , 0, sizeof(key_buf) ) ;

    status = encrypt$generate_key ( &algo_desc , &key_length , &fac_a_desc , 
				&fac_b_desc , &fac_c_desc , &key_buf_desc );

    if ( (status != ENCRYPT$_SUCCESS) || (strcmp ((const char *)key_buf, "") == 0) )
        {
        printf ("\nROW-LITERAL encrypt$generate_key() function failed.\n");
        lib$signal (status);
        return (0);
        }





    /* initialize encrypt context: */
#ifdef DEBUG_TRACE
    printf("\n 1. ******************** Initializing Encrypt CXT ******************** \n");
#endif
    context = 0;
    /* Switch to $GENERATE_KEY()'s random KEYGEN key_buf and decriptor        */

    /* Note: initialization vector(IV) is optional */
    status  = encrypt$init ( &context , &algo_desc , 
			     &key_type , &key_buf_desc , /* Random Key  */
			     init_vec );
    if (!(status & 1))
        {
        printf ("\nROW-LITERAL encrypt$init() function failed, ENCRYPT CXT.\n");
        lib$signal (status);
	return (0);
        }

#ifdef DEBUG_TRACE
    printf("\n 2. ******************** ENCRYPTING ******************** \n");
#endif

    /*
    **	Allocate and clear 16*64KB  = 1 Mbyte each
    **	input, encrypt, and decrypt buffers
    */

    for (row = 0; row < 16; row++)
    {
    	input_buf_addrs[row] = calloc(1024*64,1);
	encr_out_bufs[row]= calloc(1024*64+16,1);
	decr_out_bufs[row] = calloc(1024*64,1);

  	if ( NULL == input_buf_addrs[row] || 
		NULL == encr_out_bufs[row] || 
		NULL == decr_out_bufs[row] )
    	{
	    printf ("\n Encrypt1MB calloc() failed, NULL = no memory allocated.\n");
	    return (0);
    	}	
    }

    /* test 16*64*1024 = 1 MB encryption */
    for ( row = 0; row < 16 ; row++ )
    {
        input_desc.dsc$w_length   = 1024*64-16 ;	/* Leave room for Block mode - padding */
        input_desc.dsc$a_pointer  = input_buf_addrs[row] ;
        output_desc.dsc$a_pointer = encr_out_bufs[row] ;
#ifdef DEBUG_TRACE        
        printf("\n ------ Plaintext I/P size 64 KB Buffer[%d] = Addr. %X ------ \n",
		 row , input_buf_addrs[row] );
#endif
	/* !!! Note IV and Output Length are Optional !!! */
        status = encrypt$encrypt( &context , 
				  &input_desc , 
				  &output_desc , 
				  &encr_out_lens[row] ,
				  init_vec);

#ifdef DEBUG_TRACE
        printf("\n Encrypt 1MB Encrypt Cipher O/P Buffer[%d] length, encr_out_lens[row] = 0x%0X = %d", 
		row , encr_out_lens[row] , encr_out_lens[row] ); 
#endif
    	if (!(status & 1))
        {
            printf ("\n Encrypt1MB encrypt$encrypt() function failed.\n");
            lib$signal (status);
	    return ( 0 );
        }
    } /* End - for */

    /* release encryption context: */
#ifdef DEBUG_TRACE
    printf("\n 3. *********************** FINI ***************************\n");
#endif
    status = encrypt$fini (&context);
    if (!(status & 1))
    {
    	printf ("\n Encrypt1MB encrypt$fini() function failed.\n");
	lib$signal (status);
	return (0);
    }







    /* initialize decryption context: */
#ifdef DEBUG_TRACE
    printf("\n 4. ***************** INIT DECRYPT CXT *********************\n");
#endif
    /* Switch to $GENERATE_KEY()'s random KEYGEN key_buf and decriptor        */
    status  = encrypt$init ( &context , &algo_desc , &key_type , 
				&key_buf_desc , init_vec ); // RANKEY
    if (!(status & 1))
    {
	printf ("\n Encrypt1MB encrypt$init() function failed, DECRYPT CXT.\n");
        lib$signal (status);
	return (0);
    }

#ifdef DEBUG_TRACE
    printf("\n 5. ******************** DECRYPTING *************************\n");
#endif

    /* test 16*64*1024 = 1 MB decryption */
    for ( row = 0; row < 16; row++)
    {
    	input_desc.dsc$w_length   = encr_out_lens[row] ;
        input_desc.dsc$a_pointer  = encr_out_bufs[row] ;
        output_desc.dsc$a_pointer = decr_out_bufs[row] ;

#ifdef DEBUG_TRACE
        printf("\n Encrypt1MB Decrypt Cipher I/P Row[%d] length, \
		encr_out_lens[row] = 0x%0X = %d", 
		row , encr_out_lens[row] , input_desc.dsc$w_length ); 
 	printf("\n ------ Ciphertext I/P size Row[%d] = %d ------ ",  
		row , encr_out_lens [row] );
#endif
        status = encrypt$decrypt( &context , 
				  &input_desc , 
				  &output_desc , 
				  &ret_len , 
				  init_vec ); 		   /* IV is optional */
	if (!(status & 1))
    	{
	    printf ("\n Encrypt1MB encrypt$decrypt() function failed.\n");
            lib$signal (status);
	    return (0);
    	}
#ifdef DEBUG_TRACE
	printf("\n ------ Decrypt O/P Plaintext size Row[%d] = 0x%0X == %d ------ ",  
		row , ret_len , ret_len );
#endif

    } /* End - For */

#ifdef DEBUG_TRACE
    printf("\n 6. *********************** COMPARE ***************************\n");
#endif

    for (row = 0; row < 16; row++)
    {
        if ( strncmp( input_buf_addrs[row] , 	      /* Text I/P */
		decr_out_bufs[row] , 		      /* Decrypted Memory O/P */
		strlen( input_buf_addrs[row] )) != 0) /* Plaintext I/P length */
        {
            printf (" Encrypt1MB encryption/decryption failed at row %d.\n", 
		row);
	    printf ("\n Good data = \n\"%s\" ", input_buf_addrs[row] );
	    printf ("\n Bad  data = \n\"%s\" ", decr_out_bufs[row] );
            return (0);
        }
	else
	{
#ifdef DEBUG_TRACE
            printf (" Encrypt 1MB encryption/decryption successful at row %d.", 
			row);
	    printf ("\n Good data = \n\"%s\" ", input_buf_addrs[row] );
	    printf ("\n Decr data = \n\"%s\"\n\n ", decr_out_bufs[row] );
#endif
	}
    } /* End - For */



    /* Clear out the decrypted data buffer */

    memset( decr_out_bufs , 0, sizeof(decr_out_bufs));



    /* Exercise the statistics function: */

    status = encrypt$statistics (&context, &stat_code, &stat_buf_desc, 
				&ret_len );
    if (!(status & 1) || (ret_len != sizeof(stat_buf)) )
    {
	printf ("\nThe encrypt$statistics() function failed.\n");
        lib$signal (status);
	return (0);
    }

#ifdef DEBUG_TRACE
    printf ("\n\n");
    printf ("7. Example statistics from ENCRYPT statistics function:\n");
    printf ("   ---------------------------------------------------\n");
    printf ("\t Total records by ENCRYPT: %10d\n", stat_buf.encrypt$l_stat_total_records);
    printf ("\t Bytes processed by ENCRYPT: %8Ld\n", stat_buf.encrypt$q_stat_total_bytes);
    printf ("\t Total time %25Ld\n", stat_buf.encrypt$q_stat_total_time);
    status = lib$cvt_from_internal_time (&code, &cpu_seconds, &stat_buf.encrypt$q_stat_total_time);
    printf ("\t CPU time in ENCRYPT, seconds: %6d\n", cpu_seconds);
    printf ("\n");
#endif



    /* release encryption context: */
    status = encrypt$fini (&context);

#ifdef DEBUG_TRACE
    printf("\n\n ----- end Encrypt1MB() %s -----\n\n", 
	algmodkey );
#endif

    return (1);

} /* end - test_aes_randomkey_1mb() */