examples/example_wcc_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.
 */


 /* Demonstrate WCC with one TA */

 /* Build executable after installation:

   gcc -O0 -g ./testwcc_ZZZ.c $(pkg-config --libs --cflags amcl) -o testwcc_ZZZ

 */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include "utils.h"
 #include "config_curve_ZZZ.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

 int main()
 {
     int i,rtn;

     /* Master secret */
     char ms[WCC_PGS_ZZZ];
     octet MS= {sizeof(ms),sizeof(ms),ms};

     // sender keys
     char akeyG1[2*WCC_PFS_ZZZ+1];
     octet AKeyG1= {0,sizeof(akeyG1), akeyG1};

     // receiver keys
     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 seed[32] = {0};
     octet SEED = {0,sizeof(seed),seed};
     csprng RNG;

     char message1[256];
     octet MESSAGE1 = {0, sizeof(message1), message1};
     OCT_jstring(&MESSAGE1,"Hello Bob");

     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};

     /* non random seed value! */
     SEED.len=32;
     for (i=0; i<32; i++) SEED.val[i]=i+1;
 #ifdef DEBUG
     printf("SEED: ");
     OCT_output(&SEED);
     printf("\n");
 #endif

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

     /* TA: Generate master secret  */
     rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS);
     if (rtn != 0)
     {
         printf("TA WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS) Error %d\n", rtn);
         return 1;
     }
 #ifdef DEBUG
     printf("TA MASTER SECRET: ");
     OCT_output(&MS);
     printf("\n");
 #endif

     // Alice's ID
     OCT_jstring(&IdA,"alice@milagro.com");

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

     // TA: Generate Alices's sender key
     rtn = WCC_ZZZ_GET_G1_MULTIPLE(&MS,&HIdA,&AKeyG1);
     if (rtn != 0)
     {
         printf("TA WCC_ZZZ_GET_G1_MULTIPLE() Error %d\n", rtn);
         return 1;
     }
 #ifdef DEBUG
     printf("TA Alice's sender key: ");
     OCT_output(&AKeyG1);
 #endif

     // Bob's ID
     OCT_jstring(&IdB,"bob@milagro.com");

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

     // TA: Generate Bob's receiver key
     rtn = WCC_ZZZ_GET_G2_MULTIPLE(&MS,&HIdB,&BKeyG2);
     if (rtn != 0)
     {
         printf("TA WCC_ZZZ_GET_G2_MULTIPLE() Error %d\n", rtn);
         return 1;
     }
 #ifdef DEBUG
     printf("TA Bob's receiver key: ");
     OCT_output(&BKeyG2);
     printf("\n");
 #endif

     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() 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() 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_G2_MULTIPLE() 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
     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);

     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);


     // 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;
     }

     /* clear memory */
     OCT_clear(&MS);
     OCT_clear(&AKeyG1);
     OCT_clear(&BKeyG2);
     OCT_clear(&IdA);
     OCT_clear(&IdB);
     OCT_clear(&HIdA);
     OCT_clear(&HIdB);
     OCT_clear(&X);
     OCT_clear(&Y);
     OCT_clear(&W);
     OCT_clear(&PIA);
     OCT_clear(&PIB);
     OCT_clear(&PgG1);
     OCT_clear(&PaG1);
     OCT_clear(&PbG2);
     OCT_clear(&SEED);
     OCT_clear(&MESSAGE1);
     OCT_clear(&T1);
     OCT_clear(&T2);
     OCT_clear(&K1);
     OCT_clear(&K2);
     OCT_clear(&IV);
     OCT_clear(&C);
     OCT_clear(&P);

     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.
	*/


	/* Demonstrate WCC with one TA */

	/* Build executable after installation:

	gcc -O0 -g ./testwcc_ZZZ.c $(pkg-config --libs --cflags amcl) -o testwcc_ZZZ

	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include "utils.h"
	#include "config_curve_ZZZ.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

	int main()
	{
	int i,rtn;

	/* Master secret */
	char ms[WCC_PGS_ZZZ];
	octet MS= {sizeof(ms),sizeof(ms),ms};

	// sender keys
	char akeyG1[2*WCC_PFS_ZZZ+1];
	octet AKeyG1= {0,sizeof(akeyG1), akeyG1};

	// receiver keys
	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 seed[32] = {0};
	octet SEED = {0,sizeof(seed),seed};
	csprng RNG;

	char message1[256];
	octet MESSAGE1 = {0, sizeof(message1), message1};
	OCT_jstring(&MESSAGE1,"Hello Bob");

	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};

	/* non random seed value! */
	SEED.len=32;
	for (i=0; i<32; i++) SEED.val[i]=i+1;
	#ifdef DEBUG
	printf("SEED: ");
	OCT_output(&SEED);
	printf("\n");
	#endif

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

	/* TA: Generate master secret */
	rtn = WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_RANDOM_GENERATE(&RNG,&MS) Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("TA MASTER SECRET: ");
	OCT_output(&MS);
	printf("\n");
	#endif

	// Alice's ID
	OCT_jstring(&IdA,"alice@milagro.com");

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

	// TA: Generate Alices's sender key
	rtn = WCC_ZZZ_GET_G1_MULTIPLE(&MS,&HIdA,&AKeyG1);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_GET_G1_MULTIPLE() Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("TA Alice's sender key: ");
	OCT_output(&AKeyG1);
	#endif

	// Bob's ID
	OCT_jstring(&IdB,"bob@milagro.com");

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

	// TA: Generate Bob's receiver key
	rtn = WCC_ZZZ_GET_G2_MULTIPLE(&MS,&HIdB,&BKeyG2);
	if (rtn != 0)
	{
	printf("TA WCC_ZZZ_GET_G2_MULTIPLE() Error %d\n", rtn);
	return 1;
	}
	#ifdef DEBUG
	printf("TA Bob's receiver key: ");
	OCT_output(&BKeyG2);
	printf("\n");
	#endif

	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() 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() 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_G2_MULTIPLE() 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
	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);

	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);


	// 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;
	}

	/* clear memory */
	OCT_clear(&MS);
	OCT_clear(&AKeyG1);
	OCT_clear(&BKeyG2);
	OCT_clear(&IdA);
	OCT_clear(&IdB);
	OCT_clear(&HIdA);
	OCT_clear(&HIdB);
	OCT_clear(&X);
	OCT_clear(&Y);
	OCT_clear(&W);
	OCT_clear(&PIA);
	OCT_clear(&PIB);
	OCT_clear(&PgG1);
	OCT_clear(&PaG1);
	OCT_clear(&PbG2);
	OCT_clear(&SEED);
	OCT_clear(&MESSAGE1);
	OCT_clear(&T1);
	OCT_clear(&T2);
	OCT_clear(&K1);
	OCT_clear(&K2);
	OCT_clear(&IV);
	OCT_clear(&C);
	OCT_clear(&P);

	KILL_CSPRNG(&RNG);

	return 0;
	}