/* -*- C -*-
 *
 *
 * © 2010 Hewlett-Packard Development Company, L.P.
 *
 * Confidential computer software. Valid license from HP and/or its
 * subsidiaries required for possession, use, or copying.
 *
 * Consistent with FAR 12.211 and 12.212, Commercial Computer Software,
 * Computer Software Documentation, and Technical Data for Commercial Items
 * are licensed to the U.S. Government under vendor's standard commercial
 * license.
 *
 * Neither HP nor any of its subsidiaries shall be liable for technical or
 * editorial errors or omissions contained herein. The information in this
 * document is provided "as is" without warranty of any kind and is subject to
 * change without notice. The warranties for HP products are set forth in the
 * express limited warranty statements accompanying such products. Nothing
 * herein should be construed as constituting an additional warranty.
 *
 *
 */

/*
 * Revision history
 *
 * Rev    Author                Date         Comments
 * ---    ------                ----         --------
 * 001    Rupesh Shantamurty    03-Sep-2010  Initial version
 *
 * 002    Prasad SG             08-Sep-2010  Format changes. Added more comments.
 *                                           Made changes to des_cbc_once() function
 *                                           to pass correct address to descriptors.
 */

/*
 * This program demonstrates the use of the OpenVMS ENCRYPT API to 
 * achieve Triple DES encryption ( CBC mode ).
 *
 * The program may be compiled using either C or C++.
 *
 * Sample output
 * $ cc ENCRYPT_3DES
 * $ link ENCRYPT_3DES
 * $ run ENCRYPT_3DES
 *
 * Type the text that needs to be encrypted(max 32 chars) : Now is the time for all
 *  The Input text in hex is :
 * 4E6F77206973207468652074696D6520666F7220616C6C00
 *  The IV in hex is : 1234567890ABCDEF
 *  The 192 bit Key in hex is :
 * 0123456789ABCDEFFEDCBA9876543210ABCDEF0123456789
 *  The Cipher text in hex is :
 * 80B31486E9FE855A033837A54A4DDF1A0E2599734035BEF0
 *  The Deciphered text in hex is :
 * 4E6F77206973207468652074696D6520666F7220616C6C00
 *  The Deciphered text is :
 * Now is the time for all
 * $
 * 
 */
/* The cipher text generated can be verified using the Cryptosys API
 * ( www.cryptosys.net ,the Personal Edition is free for personal 
 *   use on a stand-alone computer) 
 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <descrip>
#include <ssdef>
#include <time>
#include <libdtdef>
#include <lib$routines.h>
#include "ENCRYPT$EXAMPLES:encrypt_def.h"
#include <string.h>

#define KEY_VALUE_FLAG 1

/* Forward decleration */
char *des_cbc_once(char *data,char *key, char *iv,int option);

void main ()
{
  /* Note: The key has been hardcoded to avoid any endian conflicts,
   * Refer to OpenVMS FAQ for more information on endian considerations.
   */
  unsigned char mykey[24]= { 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
                             0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10,
                             0xab,0xcd,0xef,0x01,0x23,0x45,0x67,0x89
                            };
  /* The initialization vector has been hardcoded */
  unsigned char iv[8]={0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};

  unsigned char input_data[32];  /* The data to be encrypted and read from user */
  int input_length;              /* Length of user data in input_data */
  int noof64bit;                 /* Number of 64 bits in input_data */

  unsigned char my_data[32];     /* A copy of input_data, used for processing */
  unsigned char key1[8];         /* First 8 bytes of mykey variable */
  unsigned char key2[8];         /* Second 8 bytes of mykey variable */
  unsigned char key3[8];         /* Third 8 bytes of mykey variable */

  unsigned char decryp_data[32]; /* The data obtained after decrypting */
  unsigned char cbc_iv[8];       /* initialization vector for DES operation.
                                  * This will be initially set to "iv" variable
                                  * and changes during subsequent DES operation.
                                  */
  unsigned char cipher[32];      /* Encrypted data */

  unsigned char *output;         /* Intermedial buffer address used while calling des_cbc_once() */
  unsigned char des_data[8];     /* Intermedial buffer used while calling des_cbc_once() */
  int i;                         /* Indexing variable. */

  /* Get User Input for the Data to be encrypted from STDIN */
  printf("\nType the text that needs to be encrypted(max 32 chars) : ");
  gets((char *)input_data);
  input_length = strlen((char *)input_data);

  /* How much number of 64 bits are present in users data */
  noof64bit = ceil((float)input_length/8);

  /* Clear the my_data and copy user input to my_data */
  memset(my_data,0,32);
  memcpy(my_data, input_data, noof64bit*8);

  printf("\n The Input text in hex is : \n");
  for (i=0;i<noof64bit*8;i++)
     printf("%.2X",(unsigned char *)my_data[i]);

  /* Set the IV to its initial value */
  memcpy(cbc_iv,iv,8);

  printf("\n The IV in hex is : ");
  for (i=0;i<8;i++)
     printf("%.2X",(unsigned char *)cbc_iv[i]);

  printf("\n The 192 bit Key in hex is : \n");
  for (i=0;i<24;i++)
     printf("%.2X",(unsigned char *)mykey[i]);

  /* Copy 8 bytes each of mykey to key1, key2 and key3 */
  memcpy(key1,mykey,8);
  memcpy(key2,mykey+8,8);
  memcpy(key3,mykey+16,8);
  
  /********************/
  /* Encryption Phase */
  /********************/

  for (i=1;i<=noof64bit; i++)
  {
     /*
      * Copy the next 8 bytes from the my_data
      * to des_data for encryption.
      */
     memset(des_data,0,8);
     memcpy( des_data,my_data+((i-1)*8),8);

     /*------------------------------------------*/
     /* The Core part of encryption in TCBC mode */
     /*------------------------------------------*/

     /* First encrypt using key1 , use IV also */
     output = (unsigned char *)des_cbc_once((char *)des_data,
                                            (char *)key1,
                                            (char *)cbc_iv,
                                            1);

     /* Decrypt the output of previous step using key2, with no IV */
     output = (unsigned char *)des_cbc_once((char *)output,
                                            (char *)key2,
                                            NULL,
                                            0);

     /* Finally encrypt the output of previous step using key3, with no IV */
     output = (unsigned char *)des_cbc_once((char *)output,
                                            (char *)key3,
                                            NULL,
                                            1);

     /*
      * Copy the final 8 byte encrypted output
      * to the next 8 bytes of cipher variable.
      */
     memcpy(cipher+((i-1)*8),output,8);

     /*
      * Use the final 8 byte encrypted output
      * as iv for the next round.
      */
     memcpy(cbc_iv,output,8);
  }

  printf("\n The Cipher text in hex is : \n");
  for (i=0;i<noof64bit*8;i++)
     printf("%.2X",(unsigned char *)cipher[i]);
  
  /********************/
  /* Decryption Phase */
  /********************/

  /* Set the IV to its initial value */  
  memcpy(cbc_iv,iv,8);

  for (i=1;i<=noof64bit;i++)
  {
     /*
      * Copy the next 8 bytes from the cipher
      * to des_data for decryption.
      */
     memset(des_data,0,8);
     memcpy( des_data, cipher+((i-1)*8),8);

     /*------------------------------------------*/
     /* The Core part of deryption in TCBC mode */
     /*------------------------------------------*/

     /* First decrypt using key3, with no IV */
     output = (unsigned char *)des_cbc_once((char *)des_data,
                                            (char *)key3,
                                            NULL,
                                            0);
     
     /* Encrypt the output of previous step using key2, with no IV */
     output = (unsigned char *)des_cbc_once((char *)output,
                                            (char *)key2,
                                            NULL,
                                            1);

     /* Finally decrypt the output of previous step using key1, use IV also */
     output = (unsigned char *)des_cbc_once((char *)output,
                                            (char *)key1,
                                            (char *)cbc_iv,
                                            0);

     /*
      * Copy the final 8 byte decrypted output
      * to the next 8 bytes of decryp_data variable.
      */
     memcpy(decryp_data+((i-1)*8),output,8);
     memcpy(cbc_iv, des_data,8);
  }

  printf("\n The Deciphered text in hex is : \n");
  for (i=0;i<noof64bit*8;i++)
   printf("%.2X",(unsigned char *)decryp_data[i]);
  
  printf("\n The Deciphered text is : \n");
  puts((char*) decryp_data);

} /* End of main */



/*
 * Function to do CBC, using DES API, once.
 * Arguments:
 * Input:
 *   data   : The Data to be encrypted or decrypted
 *   key    : The key used for encryption or decryption
 *   iv     : Initilization vector used for encryption or decryption
 *   option : If 1, encryption is performed on data. If 0 decryption is performed.
 * Returns:
 *   output : The resulting encrypted or decrypted data
 */
char * des_cbc_once(char *data, char *key, char *iv, int option)
{
  char int_data[8]; /* Copy of data Argument */
  char int_key[8];  /* Copy of Key Argument */
  char int_iv[8];   /* Copy of iv Argument */

  static char cbc_out[8]; /* The encrypted/decrypted data
                           * returned from this function
                           */

  /* Variables used for calling encrypt$...() API's */
  unsigned long context = 0;
  unsigned long key_type = KEY_VALUE_FLAG;
  int encr_out_len = 0;
  long status = 0;

  /* Copy the Input arguments */
  memcpy(int_data,data,8);
  memcpy(int_key,key,8);
  if(iv!=NULL)
     memcpy(int_iv,iv,8);
  else
    int_iv[0]='\0';

  /* Clear the return data */
  memset(cbc_out,0,8);

  /* Define input, output, algo and key descriptors */
  $DESCRIPTOR(input_desc,   "");
  $DESCRIPTOR(output_desc,  "");
  $DESCRIPTOR(algo_desc,    "DESCBC");
  $DESCRIPTOR(key_buf_desc, "");

  input_desc.dsc$b_dtype = DSC$K_DTYPE_NU ;  /* Numeric String Unsigned  */
  input_desc.dsc$a_pointer = (char *)int_data;
  input_desc.dsc$w_length  = 8;

  output_desc.dsc$b_dtype = DSC$K_DTYPE_NU ;
  output_desc.dsc$a_pointer = (char *)cbc_out;
  output_desc.dsc$w_length = 8;

  key_buf_desc.dsc$b_dtype = DSC$K_DTYPE_NU ;
  key_buf_desc.dsc$a_pointer = (char *)int_key;
  key_buf_desc.dsc$w_length  = 8 ;

  status  = encrypt$init (&context, &algo_desc, &key_type, &key_buf_desc, int_iv);

  if (!(status & 1))
  {
    printf ("\nencrypt$init() function failed\n");
    lib$signal (status);
    return (0);
  }



  /* If option is 1 then do encryption, else do decryption */
  if(option==1)
  {  
     status = encrypt$encrypt( &context, &input_desc,
                 &output_desc, &encr_out_len );
     if (!(status & 1))
     {
       printf ("\n encrypt$encrypt() function failed.\n");
       lib$signal (status);
       return (0);
     }
  } 
  else
  {  
     status = encrypt$decrypt(&context, &input_desc ,
               &output_desc, &encr_out_len );
     if (!(status & 1))
     {
       printf ("\n encrypt$decrypt() function failed.\n");
       lib$signal (status);
       return (0);
     }
  }

  status = encrypt$fini (&context);
  if (!(status & 1))
  {
    printf ("\n encrypt$fini() function failed.\n");
    lib$signal (status);
    return (0);
  }
  return cbc_out;
}