test/test_wcc_random_ZZZ.c.in - incubator-milagro-crypto-c - Git at Google

 /*
     Licensed to the Apache Software Foundation (ASF) under one
     or more contributor license agreements.  See the NOTICE file
     distributed with this work for additional information
     regarding copyright ownership.  The ASF licenses this file
     to you under the Apache License, Version 2.0 (the
     "License"); you may not use this file except in compliance
     with the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing,
     software distributed under the License is distributed on an
     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
     KIND, either express or implied.  See the License for the
     specific language governing permissions and limitations
     under the License.
 */
 /**
  * @file test_wcc_random.c
  * @author Kealan McCusker
  * @brief Test WCC with two TAs for random values
  *
  */

 /* Smoke test: Test WCC with two TAs for random values */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include "utils.h"
 #include "config_curve_ZZZ.h"
 #include "config_test.h"
 #include "randapi.h"
 #if CURVE_SECURITY_ZZZ == 128
 #include "wcc_ZZZ.h"
 #elif CURVE_SECURITY_ZZZ == 192
 #include "wcc192_ZZZ.h"
 #elif CURVE_SECURITY_ZZZ == 256
 #include "wcc256_ZZZ.h"
 #endif

 #if CURVE_SECURITY_ZZZ == 128
 #define G2LEN 4*WCC_PFS_ZZZ
 #elif CURVE_SECURITY_ZZZ == 192
 #define G2LEN 8*WCC_PFS_ZZZ
 #elif CURVE_SECURITY_ZZZ == 256
 #define G2LEN 16*WCC_PFS_ZZZ
 #endif
 // #define DEBUG

 void rand_str(octet* dest, csprng *RNG)
 {
     BIG_XXX r;
     char charset[] = "0123456789@.*"
                      "abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

     for(; dest->len < dest->max; dest->len++)
     {
         BIG_XXX_random(r,RNG);
         size_t index = r[0] % (sizeof charset -1);
         dest->val[dest->len] = charset[index];
     }
 }

 int main()
 {
     int i,rtn,iter;

     /* Master secret shares */
     char ms1[WCC_PGS_ZZZ], ms2[WCC_PGS_ZZZ];
     octet MS1= {0,sizeof(ms1),ms1};
     octet MS2= {0,sizeof(ms2),ms2};

     // Sender keys
     char a1keyG1[2*WCC_PFS_ZZZ+1], a2keyG1[2*WCC_PFS_ZZZ+1];
     octet A1KeyG1= {0,sizeof(a1keyG1), a1keyG1};
     octet A2KeyG1= {0,sizeof(a2keyG1), a2keyG1};
     char akeyG1[2*WCC_PFS_ZZZ+1];
     octet AKeyG1= {0,sizeof(akeyG1), akeyG1};

     // Receiver keys
     char b1keyG2[G2LEN], b2keyG2[G2LEN];
     octet B1KeyG2= {0,sizeof(b1keyG2), b1keyG2};
     octet B2KeyG2= {0,sizeof(b2keyG2), b2keyG2};
     char bkeyG2[G2LEN];
     octet BKeyG2= {0,sizeof(bkeyG2), bkeyG2};

     // Identities
     char alice_id[256],bob_id[256];
     octet IdA= {0,sizeof(alice_id),alice_id};
     octet IdB= {0,sizeof(bob_id),bob_id};

     // Hash of the identities
     char hida[WCC_PFS_ZZZ], hidb[WCC_PFS_ZZZ];
     octet HIdA = {0,sizeof(hida),hida};
     octet HIdB = {0,sizeof(hidb),hidb};

     char x[WCC_PGS_ZZZ];
     octet X= {0,sizeof(x),x};
     char y[WCC_PGS_ZZZ];
     octet Y= {0,sizeof(y),y};
     char w[WCC_PGS_ZZZ];
     octet W= {0,sizeof(w),w};
     char pia[WCC_PGS_ZZZ];
     octet PIA= {0,sizeof(pia),pia};
     char pib[WCC_PGS_ZZZ];
     octet PIB= {0,sizeof(pib),pib};

     char pgg1[2*WCC_PFS_ZZZ+1];
     octet PgG1= {0,sizeof(pgg1), pgg1};

     char pag1[2*WCC_PFS_ZZZ+1];
     octet PaG1= {0,sizeof(pag1), pag1};

     char pbg2[G2LEN];
     octet PbG2= {0,sizeof(pbg2), pbg2};

     char message1[256];
     char message2[256];
     octet MESSAGE1 = {0, sizeof(message1), message1};
     octet MESSAGE2 = {0, sizeof(message2), message2};

     char t1[PTAG];  // Tag
     char t2[PTAG];  // Tag
     char k1[AESKEY_ZZZ];  // AES Key
     char k2[AESKEY_ZZZ];  // AES Key
     char iv[PIV]; // IV - Initialization vector
     char c[100];  // Ciphertext
     char p[100];  // Recovered Plaintext
     octet T1= {sizeof(t1),sizeof(t1),t1};
     octet T2= {sizeof(t2),sizeof(t2),t2};
     octet K1= {0,sizeof(k1),k1};
     octet K2= {0,sizeof(k2),k2};
     octet IV= {0,sizeof(iv),iv};
     octet C= {0,sizeof(c),c};
     octet P= {0,sizeof(p),p};

     // Zero octet
     char zero[AESKEY_ZZZ];
     octet ZERO= {0,sizeof(zero),zero};
     for(i=0; i<AESKEY_ZZZ; i++)
     {
         ZERO.val[i]=0;
     }

     OCT_jstring(&MESSAGE1,"Hello Bob");
     OCT_jstring(&MESSAGE2,"Hello Alice");

     int byte_count = 32;
     char seed[32] = {0};
     octet SEED = {sizeof(seed),sizeof(seed),seed};
     csprng RNG;

 #ifdef __linux__
     FILE *fp;
     fp = fopen("/dev/urandom", "r");
     if (fread(&seed, 1, byte_count, fp)) {};
     fclose(fp);
 #else
     /* non random seed value! */
     unsigned long ran;
     time((time_t *)&ran);
     SEED.val[0]=ran;
     SEED.val[1]=ran>>8;
     SEED.val[2]=ran>>16;
     SEED.val[3]=ran>>24;
     for (i=4; i<byte_count; i++) SEED.val[i]=i+1;
 #endif
     printf("SEED 0x");
     OCT_output(&SEED);

     /* initialise random number generator */
     CREATE_CSPRNG(&RNG,&SEED);

     for(iter=1; iter<nRandomTests+1; iter++)
     {
         /* Generate Client master secret for MILAGRO and Customer */
         rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS1);
         if (rtn != 0)
         {
             printf("TA WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS1) Error %d\n", rtn);
             return 1;
         }
         rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS2);
         if (rtn != 0)
         {
             printf("TA WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS2) Error %d\n", rtn);
             return 1;
         }
         printf("TA1 MASTER SECRET: ");
         OCT_output(&MS1);
         printf("TA2 MASTER SECRET: ");
         OCT_output(&MS2);

         // Alice's ID
         rand_str(&IdA,&RNG);
         printf("ALICE ID:");
         OCT_output_string(&IdA);
         printf("\n");

         // Hash Alice's Id
         HASH_ID(HASH_TYPE_ZZZ,&IdA,&HIdA);

         // TA: Generate Alice's sender key
         rtn = WCC_ZZZ_GET_G1_MULTIPLE(&MS1,&HIdA,&A1KeyG1);
         if (rtn != 0)
         {
             printf("TA WCC_ZZZ_GET_G1_MULTIPLE(&MS1,&HIdA,&A1KeyG1) Error %d\n", rtn);
             return 1;
         }
         rtn = WCC_ZZZ_GET_G1_MULTIPLE(&MS2,&HIdA,&A2KeyG1);
         if (rtn != 0)
         {
             printf("TA WCC_ZZZ_GET_G1_MULTIPLE(&MS2,&HIdA,&A2KeyG1) Error %d\n", rtn);
             return 1;
         }
         printf("TA A1KeyG1: ");
         OCT_output(&A1KeyG1);
         printf("TA A2KeyG1: ");
         OCT_output(&A2KeyG1);

         rtn = WCC_ZZZ_RECOMBINE_G1(&A1KeyG1, &A2KeyG1, &AKeyG1);
         if (rtn != 0)
         {
             printf("TA WCC_ZZZ_RECOMBINE_G1(&A1KeyG1, &A2KeyG1, &AKeyG1) Error %d\n", rtn);
             return 1;
         }
         printf("TA Alice's sender key: ");
         OCT_output(&AKeyG1);

         // Bob's ID
         rand_str(&IdB,&RNG);
         printf("BOB ID:");
         OCT_output_string(&IdB);
         printf("\n");

         // Hash Bob's Id
         HASH_ID(HASH_TYPE_ZZZ,&IdB,&HIdB);

         // TA: Generate Bob's receiver key
         rtn = WCC_ZZZ_GET_G2_MULTIPLE(&MS1,&HIdB,&B1KeyG2);
         if (rtn != 0)
         {
             printf("TA WCC_ZZZ_GET_G2_MULTIPLE(&MS1,&HIdB,&B1KeyG2) Error %d\n", rtn);
             return 1;
         }
         rtn = WCC_ZZZ_GET_G2_MULTIPLE(&MS2,&HIdB,&B2KeyG2);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_GET_G2_MULTIPLE(&MS2,&HIdB,&B2KeyG2) Error %d\n", rtn);
             return 1;
         }
         printf("TA B1KeyG2: ");
         OCT_output(&B1KeyG2);
         printf("TA B2KeyG2: ");
         OCT_output(&B2KeyG2);

         rtn = WCC_ZZZ_RECOMBINE_G2(&B1KeyG2, &B2KeyG2, &BKeyG2);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_RECOMBINE_G2(&B1KeyG1, &B2KeyG1, &BKeyG2) Error %d\n", rtn);
             return 1;
         }
         printf("TA Bob's receiver key: ");
         OCT_output(&BKeyG2);

         printf("Alice\n");

         rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&X);
         if (rtn != 0)
         {
             printf("Alice WCC_ZZZ_RANDOM_GENERATE(&RNG,&X) Error %d\n", rtn);
             return 1;
         }
 #ifdef DEBUG
         printf("Alice X: ");
         OCT_output(&X);
         printf("\n");
 #endif

         rtn = WCC_ZZZ_GET_G1_MULTIPLE(&X,&HIdA,&PaG1);
         if (rtn != 0)
         {
             printf("Alice WCC_ZZZ_GET_G1_MULTIPLE(&X,&HIdA,&PaG1) Error %d\n", rtn);
             return 1;
         }

         printf("Alice sends IdA and PaG1 to Bob\n\n");
         printf("Alice IdA: ");
         OCT_output_string(&IdA);
         printf("\n");
         printf("Alice PaG1: ");
         OCT_output(&PaG1);
         printf("\n");

         printf("Bob\n");

         rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&W);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_RANDOM_GENERATE(&RNG,&W) Error %d\n", rtn);
             return 1;
         }
 #ifdef DEBUG
         printf("Bob W: ");
         OCT_output(&W);
         printf("\n");
 #endif
         rtn = WCC_ZZZ_GET_G1_MULTIPLE(&W,&HIdA,&PgG1);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_GET_G1_MULTIPLE(&W,&HIdA,&PgG1) Error %d\n", rtn);
             return 1;
         }
 #ifdef DEBUG
         printf("PgG1: ");
         OCT_output(&PgG1);
         printf("\n");
 #endif

         rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&Y);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_RANDOM_GENERATE(&RNG,&Y) Error %d\n", rtn);
             return 1;
         }
 #ifdef DEBUG
         printf("Bob Y: ");
         OCT_output(&Y);
         printf("\n");
 #endif
         rtn = WCC_ZZZ_GET_G2_MULTIPLE(&Y,&HIdB,&PbG2);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_GET_G1_MULTIPLE(&Y,&HIdB,&PbG2) Error %d\n", rtn);
             return 1;
         }
 #ifdef DEBUG
         printf("Bob PbG2: ");
         OCT_output(&PbG2);
         printf("\n");
 #endif

         // pia = Hq(PaG1,PbG2,PgG1,IdB)
         WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PaG1,&PbG2,&PgG1,&IdB,&PIA);

         // pib = Hq(PbG2,PaG1,PgG1,IdA)
         WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PbG2,&PaG1,&PgG1,&IdA,&PIB);

 #ifdef DEBUG
         printf("Bob PIA: ");
         OCT_output(&PIA);
         printf("\n");
         printf("Bob PIB: ");
         OCT_output(&PIB);
         printf("\n");
 #endif

         // Bob calculates AES Key
         rtn = WCC_ZZZ_RECEIVER_KEY(HASH_TYPE_ZZZ,&Y,&W,&PIA,&PIB,&PaG1,&PgG1,&BKeyG2,&IdA,&K2);
         if (rtn != 0)
         {
             printf("Bob WCC_ZZZ_RECEIVER_KEY() Error %d\n", rtn);
             return 1;
         }
         printf("Bob AES Key: ");
         OCT_output(&K2);
         if (OCT_comp(&K2,&ZERO))
         {
             printf("Bob WCC_ZZZ_RECEIVER_KEY() Error: generated key is zero\n");
             return 1;
         }

         printf("Bob sends IdB, PbG2 and PgG1 to Alice\n\n");
         printf("Bob IdB: ");
         OCT_output_string(&IdB);
         printf("\n");
         printf("Bob PbG2: ");
         OCT_output(&PbG2);
         printf("\n");
         printf("Bob PgG1: ");
         OCT_output(&PgG1);
         printf("\n");

         printf("Alice\n");

         // pia = Hq(PaG1,PbG2,PgG1,IdB)
         WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PaG1,&PbG2,&PgG1,&IdB,&PIA);

         // pib = Hq(PbG2,PaG1,PgG1,IdA)
         WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PbG2,&PaG1,&PgG1,&IdA,&PIB);

 #ifdef DEBUG
         printf("Alice PIA: ");
         OCT_output(&PIA);
         printf("\n");
         printf("Alice PIB: ");
         OCT_output(&PIB);
         printf("\n");
 #endif

         // Alice calculates AES Key
         rtn = WCC_ZZZ_SENDER_KEY(HASH_TYPE_ZZZ,&X,&PIA,&PIB,&PbG2,&PgG1,&AKeyG1,&IdB,&K1);
         if (rtn != 0)
         {
             printf("Alice WCC_ZZZ_SENDER_KEY() Error %d\n", rtn);
             return 1;
         }
         printf("Alice AES Key: ");
         OCT_output(&K1);
         if (OCT_comp(&K1,&ZERO))
         {
             printf("Alice WCC_ZZZ_SENDER_KEY() Error: generated key is zero\n");
             return 1;
         }

         // Send message
         IV.len=12;
         for (i=0; i<IV.len; i++)
             IV.val[i]=i+1;
         printf("Alice: IV ");
         OCT_output(&IV);

         printf("Alice: Message to encrypt for Bob: ");
         OCT_output_string(&MESSAGE1);
         printf("\n");

         AES_GCM_ENCRYPT(&K1,&IV,&IdA,&MESSAGE1,&C,&T1);

         printf("Alice: Ciphertext: ");
         OCT_output(&C);

         printf("Alice: Encryption Tag: ");
         OCT_output(&T1);
         printf("\n");

         AES_GCM_DECRYPT(&K2,&IV,&IdA,&C,&P,&T2);

         printf("Bob: Decrypted message received from Alice: ");
         OCT_output_string(&P);
         printf("\n");

         printf("Bob: Decryption Tag: ");
         OCT_output(&T2);
         printf("\n");

         if (!OCT_comp(&MESSAGE1,&P))
         {
             printf("FAILURE Decryption\n");
             return 1;
         }

         if (!OCT_comp(&T1,&T2))
         {
             printf("FAILURE TAG mismatch\n");
             return 1;
         }
         printf("Iteration %d SUCCESS \n\n", iter);
     }

     KILL_CSPRNG(&RNG);
     return 0;
 }
	/*
	Licensed to the Apache Software Foundation (ASF) under one
	or more contributor license agreements. See the NOTICE file
	distributed with this work for additional information
	regarding copyright ownership. The ASF licenses this file
	to you under the Apache License, Version 2.0 (the
	"License"); you may not use this file except in compliance
	with the License. You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing,
	software distributed under the License is distributed on an
	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	KIND, either express or implied. See the License for the
	specific language governing permissions and limitations
	under the License.
	*/
	/**
	* @file test_wcc_random.c
	* @author Kealan McCusker
	* @brief Test WCC with two TAs for random values
	*
	*/

	/* Smoke test: Test WCC with two TAs for random values */

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include "utils.h"
	#include "config_curve_ZZZ.h"
	#include "config_test.h"
	#include "randapi.h"
	#if CURVE_SECURITY_ZZZ == 128
	#include "wcc_ZZZ.h"
	#elif CURVE_SECURITY_ZZZ == 192
	#include "wcc192_ZZZ.h"
	#elif CURVE_SECURITY_ZZZ == 256
	#include "wcc256_ZZZ.h"
	#endif

	#if CURVE_SECURITY_ZZZ == 128
	#define G2LEN 4*WCC_PFS_ZZZ
	#elif CURVE_SECURITY_ZZZ == 192
	#define G2LEN 8*WCC_PFS_ZZZ
	#elif CURVE_SECURITY_ZZZ == 256
	#define G2LEN 16*WCC_PFS_ZZZ
	#endif
	// #define DEBUG

	void rand_str(octet* dest, csprng *RNG)
	{
	BIG_XXX r;
	char charset[] = "0123456789@.*"
	"abcdefghijklmnopqrstuvwxyz"
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ";

	for(; dest->len < dest->max; dest->len++)
	{
	BIG_XXX_random(r,RNG);
	size_t index = r[0] % (sizeof charset -1);
	dest->val[dest->len] = charset[index];
	}
	}

	int main()
	{
	int i,rtn,iter;

	/* Master secret shares */
	char ms1[WCC_PGS_ZZZ], ms2[WCC_PGS_ZZZ];
	octet MS1= {0,sizeof(ms1),ms1};
	octet MS2= {0,sizeof(ms2),ms2};

	// Sender keys
	char a1keyG1[2WCC_PFS_ZZZ+1], a2keyG1[2WCC_PFS_ZZZ+1];
	octet A1KeyG1= {0,sizeof(a1keyG1), a1keyG1};
	octet A2KeyG1= {0,sizeof(a2keyG1), a2keyG1};
	char akeyG1[2*WCC_PFS_ZZZ+1];
	octet AKeyG1= {0,sizeof(akeyG1), akeyG1};

	// Receiver keys
	char b1keyG2[G2LEN], b2keyG2[G2LEN];
	octet B1KeyG2= {0,sizeof(b1keyG2), b1keyG2};
	octet B2KeyG2= {0,sizeof(b2keyG2), b2keyG2};
	char bkeyG2[G2LEN];
	octet BKeyG2= {0,sizeof(bkeyG2), bkeyG2};

	// Identities
	char alice_id[256],bob_id[256];
	octet IdA= {0,sizeof(alice_id),alice_id};
	octet IdB= {0,sizeof(bob_id),bob_id};

	// Hash of the identities
	char hida[WCC_PFS_ZZZ], hidb[WCC_PFS_ZZZ];
	octet HIdA = {0,sizeof(hida),hida};
	octet HIdB = {0,sizeof(hidb),hidb};

	char x[WCC_PGS_ZZZ];
	octet X= {0,sizeof(x),x};
	char y[WCC_PGS_ZZZ];
	octet Y= {0,sizeof(y),y};
	char w[WCC_PGS_ZZZ];
	octet W= {0,sizeof(w),w};
	char pia[WCC_PGS_ZZZ];
	octet PIA= {0,sizeof(pia),pia};
	char pib[WCC_PGS_ZZZ];
	octet PIB= {0,sizeof(pib),pib};

	char pgg1[2*WCC_PFS_ZZZ+1];
	octet PgG1= {0,sizeof(pgg1), pgg1};

	char pag1[2*WCC_PFS_ZZZ+1];
	octet PaG1= {0,sizeof(pag1), pag1};

	char pbg2[G2LEN];
	octet PbG2= {0,sizeof(pbg2), pbg2};

	char message1[256];
	char message2[256];
	octet MESSAGE1 = {0, sizeof(message1), message1};
	octet MESSAGE2 = {0, sizeof(message2), message2};

	char t1[PTAG]; // Tag
	char t2[PTAG]; // Tag
	char k1[AESKEY_ZZZ]; // AES Key
	char k2[AESKEY_ZZZ]; // AES Key
	char iv[PIV]; // IV - Initialization vector
	char c[100]; // Ciphertext
	char p[100]; // Recovered Plaintext
	octet T1= {sizeof(t1),sizeof(t1),t1};
	octet T2= {sizeof(t2),sizeof(t2),t2};
	octet K1= {0,sizeof(k1),k1};
	octet K2= {0,sizeof(k2),k2};
	octet IV= {0,sizeof(iv),iv};
	octet C= {0,sizeof(c),c};
	octet P= {0,sizeof(p),p};

	// Zero octet
	char zero[AESKEY_ZZZ];
	octet ZERO= {0,sizeof(zero),zero};
	for(i=0; i<AESKEY_ZZZ; i++)
	{
	ZERO.val[i]=0;
	}

	OCT_jstring(&MESSAGE1,"Hello Bob");
	OCT_jstring(&MESSAGE2,"Hello Alice");

	int byte_count = 32;
	char seed[32] = {0};
	octet SEED = {sizeof(seed),sizeof(seed),seed};
	csprng RNG;

	#ifdef __linux__
	FILE *fp;
	fp = fopen("/dev/urandom", "r");
	if (fread(&seed, 1, byte_count, fp)) {};
	fclose(fp);
	#else
	/* non random seed value! */
	unsigned long ran;
	time((time_t *)&ran);
	SEED.val[0]=ran;
	SEED.val[1]=ran>>8;
	SEED.val[2]=ran>>16;
	SEED.val[3]=ran>>24;
	for (i=4; i<byte_count; i++) SEED.val[i]=i+1;
	#endif
	printf("SEED 0x");
	OCT_output(&SEED);

	/* initialise random number generator */
	CREATE_CSPRNG(&RNG,&SEED);

	for(iter=1; iter<nRandomTests+1; iter++)
	{
	/* Generate Client master secret for MILAGRO and Customer */
	rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS1);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS1) Error %d\n", rtn);
	return 1;
	}
	rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS2);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS2) Error %d\n", rtn);
	return 1;
	}
	printf("TA1 MASTER SECRET: ");
	OCT_output(&MS1);
	printf("TA2 MASTER SECRET: ");
	OCT_output(&MS2);

	// Alice's ID
	rand_str(&IdA,&RNG);
	printf("ALICE ID:");
	OCT_output_string(&IdA);
	printf("\n");

	// Hash Alice's Id
	HASH_ID(HASH_TYPE_ZZZ,&IdA,&HIdA);

	// TA: Generate Alice's sender key
	rtn = WCC_ZZZ_GET_G1_MULTIPLE(&MS1,&HIdA,&A1KeyG1);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_GET_G1_MULTIPLE(&MS1,&HIdA,&A1KeyG1) Error %d\n", rtn);
	return 1;
	}
	rtn = WCC_ZZZ_GET_G1_MULTIPLE(&MS2,&HIdA,&A2KeyG1);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_GET_G1_MULTIPLE(&MS2,&HIdA,&A2KeyG1) Error %d\n", rtn);
	return 1;
	}
	printf("TA A1KeyG1: ");
	OCT_output(&A1KeyG1);
	printf("TA A2KeyG1: ");
	OCT_output(&A2KeyG1);

	rtn = WCC_ZZZ_RECOMBINE_G1(&A1KeyG1, &A2KeyG1, &AKeyG1);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_RECOMBINE_G1(&A1KeyG1, &A2KeyG1, &AKeyG1) Error %d\n", rtn);
	return 1;
	}
	printf("TA Alice's sender key: ");
	OCT_output(&AKeyG1);

	// Bob's ID
	rand_str(&IdB,&RNG);
	printf("BOB ID:");
	OCT_output_string(&IdB);
	printf("\n");

	// Hash Bob's Id
	HASH_ID(HASH_TYPE_ZZZ,&IdB,&HIdB);

	// TA: Generate Bob's receiver key
	rtn = WCC_ZZZ_GET_G2_MULTIPLE(&MS1,&HIdB,&B1KeyG2);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_GET_G2_MULTIPLE(&MS1,&HIdB,&B1KeyG2) Error %d\n", rtn);
	return 1;
	}
	rtn = WCC_ZZZ_GET_G2_MULTIPLE(&MS2,&HIdB,&B2KeyG2);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_GET_G2_MULTIPLE(&MS2,&HIdB,&B2KeyG2) Error %d\n", rtn);
	return 1;
	}
	printf("TA B1KeyG2: ");
	OCT_output(&B1KeyG2);
	printf("TA B2KeyG2: ");
	OCT_output(&B2KeyG2);

	rtn = WCC_ZZZ_RECOMBINE_G2(&B1KeyG2, &B2KeyG2, &BKeyG2);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_RECOMBINE_G2(&B1KeyG1, &B2KeyG1, &BKeyG2) Error %d\n", rtn);
	return 1;
	}
	printf("TA Bob's receiver key: ");
	OCT_output(&BKeyG2);

	printf("Alice\n");

	rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&X);
	if (rtn != 0)
	{
	printf("Alice WCC_ZZZ_RANDOM_GENERATE(&RNG,&X) Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("Alice X: ");
	OCT_output(&X);
	printf("\n");
	#endif

	rtn = WCC_ZZZ_GET_G1_MULTIPLE(&X,&HIdA,&PaG1);
	if (rtn != 0)
	{
	printf("Alice WCC_ZZZ_GET_G1_MULTIPLE(&X,&HIdA,&PaG1) Error %d\n", rtn);
	return 1;
	}

	printf("Alice sends IdA and PaG1 to Bob\n\n");
	printf("Alice IdA: ");
	OCT_output_string(&IdA);
	printf("\n");
	printf("Alice PaG1: ");
	OCT_output(&PaG1);
	printf("\n");

	printf("Bob\n");

	rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&W);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_RANDOM_GENERATE(&RNG,&W) Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("Bob W: ");
	OCT_output(&W);
	printf("\n");
	#endif
	rtn = WCC_ZZZ_GET_G1_MULTIPLE(&W,&HIdA,&PgG1);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_GET_G1_MULTIPLE(&W,&HIdA,&PgG1) Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("PgG1: ");
	OCT_output(&PgG1);
	printf("\n");
	#endif

	rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&Y);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_RANDOM_GENERATE(&RNG,&Y) Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("Bob Y: ");
	OCT_output(&Y);
	printf("\n");
	#endif
	rtn = WCC_ZZZ_GET_G2_MULTIPLE(&Y,&HIdB,&PbG2);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_GET_G1_MULTIPLE(&Y,&HIdB,&PbG2) Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("Bob PbG2: ");
	OCT_output(&PbG2);
	printf("\n");
	#endif

	// pia = Hq(PaG1,PbG2,PgG1,IdB)
	WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PaG1,&PbG2,&PgG1,&IdB,&PIA);

	// pib = Hq(PbG2,PaG1,PgG1,IdA)
	WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PbG2,&PaG1,&PgG1,&IdA,&PIB);

	#ifdef DEBUG
	printf("Bob PIA: ");
	OCT_output(&PIA);
	printf("\n");
	printf("Bob PIB: ");
	OCT_output(&PIB);
	printf("\n");
	#endif

	// Bob calculates AES Key
	rtn = WCC_ZZZ_RECEIVER_KEY(HASH_TYPE_ZZZ,&Y,&W,&PIA,&PIB,&PaG1,&PgG1,&BKeyG2,&IdA,&K2);
	if (rtn != 0)
	{
	printf("Bob WCC_ZZZ_RECEIVER_KEY() Error %d\n", rtn);
	return 1;
	}
	printf("Bob AES Key: ");
	OCT_output(&K2);
	if (OCT_comp(&K2,&ZERO))
	{
	printf("Bob WCC_ZZZ_RECEIVER_KEY() Error: generated key is zero\n");
	return 1;
	}

	printf("Bob sends IdB, PbG2 and PgG1 to Alice\n\n");
	printf("Bob IdB: ");
	OCT_output_string(&IdB);
	printf("\n");
	printf("Bob PbG2: ");
	OCT_output(&PbG2);
	printf("\n");
	printf("Bob PgG1: ");
	OCT_output(&PgG1);
	printf("\n");

	printf("Alice\n");

	// pia = Hq(PaG1,PbG2,PgG1,IdB)
	WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PaG1,&PbG2,&PgG1,&IdB,&PIA);

	// pib = Hq(PbG2,PaG1,PgG1,IdA)
	WCC_ZZZ_Hq(HASH_TYPE_ZZZ,&PbG2,&PaG1,&PgG1,&IdA,&PIB);

	#ifdef DEBUG
	printf("Alice PIA: ");
	OCT_output(&PIA);
	printf("\n");
	printf("Alice PIB: ");
	OCT_output(&PIB);
	printf("\n");
	#endif

	// Alice calculates AES Key
	rtn = WCC_ZZZ_SENDER_KEY(HASH_TYPE_ZZZ,&X,&PIA,&PIB,&PbG2,&PgG1,&AKeyG1,&IdB,&K1);
	if (rtn != 0)
	{
	printf("Alice WCC_ZZZ_SENDER_KEY() Error %d\n", rtn);
	return 1;
	}
	printf("Alice AES Key: ");
	OCT_output(&K1);
	if (OCT_comp(&K1,&ZERO))
	{
	printf("Alice WCC_ZZZ_SENDER_KEY() Error: generated key is zero\n");
	return 1;
	}

	// Send message
	IV.len=12;
	for (i=0; i<IV.len; i++)
	IV.val[i]=i+1;
	printf("Alice: IV ");
	OCT_output(&IV);

	printf("Alice: Message to encrypt for Bob: ");
	OCT_output_string(&MESSAGE1);
	printf("\n");

	AES_GCM_ENCRYPT(&K1,&IV,&IdA,&MESSAGE1,&C,&T1);

	printf("Alice: Ciphertext: ");
	OCT_output(&C);

	printf("Alice: Encryption Tag: ");
	OCT_output(&T1);
	printf("\n");

	AES_GCM_DECRYPT(&K2,&IV,&IdA,&C,&P,&T2);

	printf("Bob: Decrypted message received from Alice: ");
	OCT_output_string(&P);
	printf("\n");

	printf("Bob: Decryption Tag: ");
	OCT_output(&T2);
	printf("\n");

	if (!OCT_comp(&MESSAGE1,&P))
	{
	printf("FAILURE Decryption\n");
	return 1;
	}

	if (!OCT_comp(&T1,&T2))
	{
	printf("FAILURE TAG mismatch\n");
	return 1;
	}
	printf("Iteration %d SUCCESS \n\n", iter);
	}

	KILL_CSPRNG(&RNG);
	return 0;
	}