// Main créé pour tester la librairie IPPCP
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
/*
* Documentation visible à cette adresse: 
* https://software.intel.com/sites/default/files/managed/f6/6f/ippcp-ref.pdf
*
*Main compilé avec les liens suivants
*gcc -c -I /home/Cyril/intel/compilers_and_libraries_2018.0.128/linux/ipp/lib/intel64/ -I /home/Cyril/intel/compilers_and_libraries_2018.0.128/linux/ippcp/lib/intel64/ main-total-bis-test-autres-courbes.c
*gcc -o main-total-bis-test-autres-courbes main-total-bis-test-autres-courbes.o /home/Cyril/intel/compilers_and_libraries_2018.0.128/linux/ipp/lib/intel64/libippcore.a /home/Cyril/intel/compilers_and_libraries_2018.0.128/linux/ippcp/lib/intel64/libippcp.a
*/
#include "/home/Cyril/intel/compilers_and_libraries_2018.0.128/linux/ippcp/include/ippcp.h"
//Chemin actuel du fichier ippcp.h


//Lecture du fichier a signer
void reading_file(unsigned char * tmp, int choix)
{
	FILE *fp;
	char tmp2;
	int i=0;
	switch(choix)
	{
		case 0:
			{
			fp = fopen("Article_Guardian_CaliFire.txt","r");
			if (fp!=NULL)
				{
				do
				{
				tmp2=fgetc(fp);
				tmp[i]=tmp2;		
				i++;
				}while(tmp2 != EOF);
				}
				else	
					{
					printf("probleme lecture fichier \n");
					}	
				fclose(fp);
			break;
			}
		default:
			{
			fp = fopen("Article_Monde_KJ1.txt","r");
			if (fp!=NULL)
				{
				do
				{
				tmp2=fgetc(fp);
				tmp[i]=tmp2;		
				i++;
				}while(i <= 256);
				}
				else	
					{
					printf("probleme lecture fichier \n");
					}	
				fclose(fp);
			break;
			}
	}
}

int main( )
{
	IppsBigNumState* pPrivate=NULL; //pointeur vers la cle privee
	IppsECCPPointState* pPublic=NULL; //pointeur vers la cle publique
	IppsECCPState* pECC=NULL; //pointeur vers le contexte de la courbe elliptique
	IppsBigNumState* pMsgDigest=NULL; //pointeur vers le message a signer
	IppsBigNumState* pSignX=NULL; //pointeur vers la 1ere partie de la signature
	IppsBigNumState* pSignY=NULL; //pointeur vers la 2nde partie de la signature
	IppECResult* pResult=NULL; //testeur du couple cle publique/privee
	void* pRndParam=NULL; // Pointeur vers le contexte du generateur d alea
	IppBitSupplier rndFunc; // Generateur d alea soit ippsPRNGGen soit ippsPRNGGen_BN
	IppsPRNGState* pRNGCtx; // Pointeur vers contexte de generateur alea
	//Il faut faire cette initialisation prealable
	int feBitSize;
	int *length; //Longueur du message a signer
	int *pSize=NULL;
	Ipp8u *pMD=NULL;//Pointeur vers le Message digest
	Ipp8u *pSrcMesg=NULL; //Pointeur vers le Message à chiffrer
	IppsBigNumState *pSeed=NULL; //Pointeur vers la graine	
	unsigned char tmp[256];
	//IppsBigNumState* pMsgDigest=NULL;//Pointeur vers le Big Number Digest
	reading_file(tmp,1);
	pSrcMesg=tmp;
	int test=10;
	pSize=malloc(sizeof(*pSize));
	length=malloc(sizeof(*length));
	pResult=malloc(sizeof(IppECResult));
	//Il faut creer de l alea
	if(ippsPRNGGetSize(pSize )!=ippStsNoErr)
		{
		printf("Erreur obtention taille RNG \n");
		}
	pRNGCtx=malloc(*pSize);
	if(ippsPRNGInit(160,pRNGCtx)!=ippStsNoErr)
		{
		printf("Probleme initialisation RNG \n");
		}
	//On creee la seed
	feBitSize=((sizeof(pSrcMesg)+3)/4);
	//pSeed=malloc(*pSize); // to surely delete	
	if(ippsBigNumGetSize(feBitSize, pSize)!=ippStsNoErr)
		{
		printf("Erreur BigNumGetSize Seed \n");
		}
	pSeed=malloc(*pSize);
	if(ippsBigNumInit(feBitSize,pSeed)!=ippStsNoErr)
		{
		printf("Erreur initialisation Seed en Big nm, %d \n",feBitSize);
		}
	//We convert the octet string into a positive  big number: pSeed
	if(ippsSetOctString_BN(pSrcMesg,feBitSize, pSeed)!=ippStsNoErr)
		{
		printf("Erreur conversion seed en Big nm \n");
		}
	if(ippsPRNGSetSeed(pSeed, pRNGCtx )!=ippStsNoErr)
		{
		printf("Erreur dans la definition de la graine \n");
		}


//////////////////////////////////Hachage du message ////////////////////////////
	
	unsigned char tmp2[1363];
	reading_file(tmp2,0);
	pSrcMesg=tmp2;
	//We first hash the message
	//// SHA256
	printf("SHA 256 est utilise \n");
	IppsSHA256State* pCtx=NULL; //pointeur for the use of SHA256
	if(ippsSHA256GetSize(pSize)!=ippStsNoErr)
	{
		printf("Erreur avec le GetSizeSHA256 \n");
	}
	else
	{
		pCtx=malloc((*pSize));
		if(ippsSHA256Init(pCtx)!=ippStsNoErr)
		{
			printf("Erreur initialisation contexte SHA 256 \n");
		}		
	}
	pMD=malloc(257); //For SHA256
	if(ippsSHA256MessageDigest(pSrcMesg, 1363, pMD)!=ippStsNoErr)
	{
		printf("Erreur avec SHA256 \n");
	}
	
	//We create the cryptosystem context
	feBitSize=((sizeof(pMD)-1+3)/4);
	//We compute the size of the BigNum
	if(ippsBigNumGetSize(feBitSize, pSize)!=ippStsNoErr)
	{
		printf("erreur BNGetSize \n");
	}
	//We allocate the required memory space
	pMsgDigest=malloc(*pSize);
	if(ippsBigNumInit(feBitSize,pMsgDigest)!=ippStsNoErr)
	{
		printf("erreur initialisation en Big nm, %d \n",feBitSize);
		if(ippsBigNumInit(feBitSize,pMsgDigest)==ippStsLengthErr)
		{
			printf("ippStsLengthErr \n");
		}
		else if(ippsBigNumInit(feBitSize,pMsgDigest)==ippStsNullPtrErr)
		{
			printf("ippStsNullPtrErr \n");
		}
	}
	//We convert the message digest into a big number
	if(ippsSetOctString_BN(pMD,feBitSize, pMsgDigest)!=ippStsNoErr)
	{
		printf("erreur conversion en Big nm \n");
		if(ippsSetOctString_BN(pMD,feBitSize, pMsgDigest)==ippStsContextMatchErr)
		{
			printf("ippStsContextMatchErr \n");
		}
		else if(ippsSetOctString_BN(pMD,feBitSize, pMsgDigest)==ippStsLengthErr)
		{
			printf(" ippStsLengthErr\n");
		}
		else if(ippsSetOctString_BN(pMD,feBitSize, pMsgDigest)==ippStsNullPtrErr)
		{
			printf(" ippStsNullPtrErr\n");
		}
		else if(ippsSetOctString_BN(pMD,feBitSize, pMsgDigest)==ippStsSizeErr)
		{
			printf(" ippStsSizeErr\n");
		}
	}
	//*/

	//We now create the curve we will work on (here it is NISTP160)
	feBitSize=168; // size of the field we will work on 		
	int lengthtest=(feBitSize+31)/32; // size of the elements we will work with the size is in 32u
	int sizetest=0;
	int cofactor=1;
	if(ippsBigNumGetSize(lengthtest ,&sizetest)!=ippStsNoErr)
	{
		printf("probleme creation Big Num Get Size \n");
		if(ippsBigNumGetSize(lengthtest/32 +1 ,&sizetest)==ippStsNullPtrErr)
		{
			printf("	Probleme de pointeur nul \n");
		}
		if(ippsBigNumGetSize(lengthtest/32 +1 ,&sizetest)==ippStsLengthErr)
		{
			printf("	Probleme de longueur \n");
		}
	}
	Ipp8u a[sizetest];
	// We declare variables for the specification of the elliptic curve we want to try
	IppsBigNumState *pPrime = NULL;
	IppsBigNumState *pA = NULL;
	IppsBigNumState *pB = NULL;
	IppsBigNumState *pGX = NULL;
	IppsBigNumState *pGY = NULL;
	IppsBigNumState *pOrder = NULL;
	//IppsECCPState *pECC=NULL;
	sizetest=sizetest*sizeof(char);
	// We allocate the memory
	pPrime=malloc(sizetest);
	pA=malloc(sizetest);
	pB=malloc(sizetest);
	pGX=malloc(sizetest);
	pGY=malloc(sizetest);
	pOrder=malloc(sizetest);

	if(ippsBigNumInit(lengthtest ,pPrime)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
		if(ippsBigNumInit(lengthtest ,pPrime)==ippStsNullPtrErr)
		{
			printf("	Probleme de pointeur nul\n");
		}
		if(ippsBigNumInit(lengthtest ,pPrime)==ippStsLengthErr)				
		{
			printf("	Probleme de longueur \n");
		}
	}
	if(ippsBigNumInit(lengthtest ,pA)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	if(ippsBigNumInit(lengthtest ,pB)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	if(ippsBigNumInit(lengthtest ,pGX)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	if(ippsBigNumInit(lengthtest ,pGY)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	if(ippsBigNumInit(lengthtest ,pOrder)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	Ipp8u desiredBNvalue[]="\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFF";	//p	
	if(ippsSetOctString_BN(desiredBNvalue,sizeof(desiredBNvalue)-1,pPrime)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt1 \n");
	}
	Ipp8u desiredBNvalue1[]="\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFC";	//pA=p-3
	if(ippsSetOctString_BN(desiredBNvalue1,sizeof(desiredBNvalue1)-1,pA)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt2 \n");
	}
	Ipp8u desiredBNvalue2[]="\x1C\x97\xBE\xFC\x54\xBD\x7A\x8B\x65\xAC\xF8\x9F\x81\xD4\xD4\xAD\xC5\x65\xFA\x45";	//pB
	if(ippsSetOctString_BN(desiredBNvalue2,sizeof(desiredBNvalue2)-1,pB)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt3 \n");
		if(ippsSetOctString_BN(desiredBNvalue2,sizeof(desiredBNvalue2)-1,pB)==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr \n");
		}
		else if(ippsSetOctString_BN(desiredBNvalue2,sizeof(desiredBNvalue2)-1,pB)==ippStsContextMatchErr)
		{
			printf("	ippStsContextMatchErr\n");
		}
		else if(ippsSetOctString_BN(desiredBNvalue2,sizeof(desiredBNvalue2)-1,pB)==ippStsLengthErr)
		{
			printf("	ippStsLengthErr\n");
		}
		else if(ippsSetOctString_BN(desiredBNvalue2,sizeof(desiredBNvalue2)-1,pB)==ippStsSizeErr)
		{
			printf("	ippStsSizeErr\n");
		}
	}
	Ipp8u desiredBNvalue3[]="\x4A\x96\xB5\x68\x8E\xF5\x73\x28\x46\x64\x69\x89\x68\xC3\x8B\xB9\x13\xCB\xFC\x82"; //pGX
	if(ippsSetOctString_BN(desiredBNvalue3,sizeof(desiredBNvalue3)-1,pGX)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt4 \n");
	}
	Ipp8u desiredBNvalue4[]="\x23\xA6\x28\x55\x31\x68\x94\x7D\x59\xDC\xC9\x12\x04\x23\x51\x37\x7A\xC5\xFB\x32"; //pGY 
	if(ippsSetOctString_BN(desiredBNvalue4,sizeof(desiredBNvalue4)-1,pGY)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt5 \n");
	}
	Ipp8u desiredBNvalue5[]="\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xF4\xC8\xF9\x27\xAE\xD3\xCA\x75\x22\x57";	//order of G
	if(ippsSetOctString_BN(desiredBNvalue,sizeof(desiredBNvalue5)-1,pOrder)!=ippStsNoErr) 
	{
		printf("probleme dans SetOCt6 \n");
	}
	if(ippsECCPGetSize(feBitSize,pSize)!=ippStsNoErr)
	{
		printf("erreur calcul taille contexte \n");
	}
	pECC=malloc(*pSize);
	if(ippsECCPInit(feBitSize,pECC)!=ippStsNoErr)
	{
		printf("erreur calcul taille contexte \n");
	}
	if(ippsECCPSet(pPrime , pA, pB, pGX, pGY, pOrder, 1 , pECC )!=ippStsNoErr) 
	{
		printf("probleme creation courbe originale 2 \n");
		if(ippsECCPSet(pPrime , pA, pB, pGX, pGY,pOrder, 1 , pECC )==ippStsContextMatchErr)
		{
			printf("	Contexte d une des valeurs n est pas valide\n");
		}
		if(ippsECCPSet(pPrime , pA, pB, pGX, pGY,pOrder, 1 , pECC )==ippStsRangeErr) // problem with pGY, pOrder 
		{ 
			printf("	Range d une des valeurs n est pas valide (id est febitsize bits ne sont pas suffisant pour un element)\n");
		}
		if(ippsECCPSet(pPrime , pB, pB, pB, pB,pOrder, 1 , pECC )==ippStsNullPtrErr)
		{
			printf("	Pointeur nul\n");
		}
	}
	else
	{
		*pResult=ippStsContextMatchErr;
		if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,"01234365")!=ippStsNoErr)
		{
			printf("Probleme de validation de la courbe 3 \n");
			if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,"01234365")==ippStsNullPtrErr)
			{
				printf("	ippStsNullPtrErr \n");
			}
			if(ippsECCPValidate(pECC,pECC,pECC,pECC,pECC)==ippStsNullPtrErr)
			{
				printf("	ippStsNullPtrErr pECC \n");
			}
		}
		else
		{	
			if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,"01234365")==ippStsContextMatchErr)
			{
				printf("	ippStsContextMatchErr \n");
			}
			if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,"01234365")==ippStsBadArgErr)
			{
				printf("	ippStsppStsBadArgErr \n");
			}
			if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,"01234365")==ippStsNullPtrErr)
			{
				printf("	ippStsNullPtrErr \n");
			}
		}
		if(*pResult==ippECValid)
		{
			printf("Validation de la courbe ok \n");
		}
		else
		{
			printf("probleme de validation de la courbe 4\n");
			if(*pResult==ippECCompositeBase)
			{
				printf("	ippECCompositeBase\n");
			}
			if(*pResult==ippECPointIsNotValid)
			{
				printf("	ippECPointIsNotValid Le basepoint G n est pas defini sur la courbe \n");
				//we get this error message each time that the number of points of the curve is different from the characteristic of the prime field, viewed on  Fp101 and on SECP160R1
			}
			if(*pResult==ippECInvalidOrder)
			{
				printf("	ippECInvalidOrder n*G !=0 ICI bas \n");
			}
			if(*pResult==ippECIsWeakMOV)
			{
				printf("	ippECIsWeakMOV\n");
			}
			if(*pResult==ippECIsWeakSSSA)
			{
				printf("	ippECIsWeakSSSA l ordre de la courbe est le meme que celui du corps fini\n");
			}
		}
	}
	
/////////////////////////CREATION DES PAIRES DE CLE ///////////////////////////////////////////

	//1- Initialisation of variables
	//We create the couple of privates and public keys
	*length=feBitSize;
	(*length)=(*length+31)/(sizeof(Ipp32u)*8);
	// We initialize pointeurs for the signing with as much memory as the order of the 
	// group of points of the curve
	if(ippsBigNumGetSize((*length),pSize)!=ippStsNoErr) //result in bytes
		{
		printf("PROBLEME obtention taille big num \n");
		}
	pSignX=malloc((*pSize)); 
	pSignY=malloc((*pSize)); 
	// We initialise the private key too
	pPrivate=malloc((*pSize)); 
	// We initialise pPrivate, pSignX, pSignY	
	if(ippsBigNumInit(*length, pPrivate)!=ippStsNoErr)
		{
		printf("Probleme init pPrivate \n");
		}
	if(ippsBigNumInit(*length, pSignX)!=ippStsNoErr)
		{
		printf("Probleme init pSignX \n");
		}
	if(ippsBigNumInit(*length, pSignY)!=ippStsNoErr)
		{
		printf("Probleme init pSignY \n");
		}
	//We compute the storage needed for points of the curve
	if(ippsECCPPointGetSize(feBitSize, pSize)!=ippStsNoErr) //donne la taille en octets
		{
		printf("Erreur dans Point Get Size \n");
		}
	printf("la taille pour stocker les points %d \n", *pSize);
	pPublic=malloc((*pSize));
	//We initialise pPublic
	if(ippsECCPPointInit(feBitSize, pPublic )!=ippStsNoErr)
		{
		printf("Erreur dans l initialisation de pPublic\n");
		}
	printf("On va tester si les parametres sont valides \n");
	*pResult=ippStsContextMatchErr;
	if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,01234365)!=ippStsNoErr)
	{
		printf("Probleme de validation de la courbe \n");
		if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,01234365)==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr \n");
		}
	}
	else
	{	
		if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,01234365)==ippStsContextMatchErr)
		{
			printf("	ippStsContextMatchErr \n");
		}
		if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,01234365)==ippStsBadArgErr)
		{
			printf("	ippStsBadArgErr \n");
		}
		if(ippsECCPValidate(7,pResult,pECC,ippsPRNGen,01234365)==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr \n");
		}
	}
	if(*pResult==ippECValid)
	{
		printf("Validation de la courbe ok \n");
	}
	else
	{
		printf("probleme de validation de la courbe \n");
		if(*pResult==ippECCompositeBase)
		{
			printf("	ippECCompositeBase\n");
		}
		if(*pResult==ippECPointIsNotValid)
		{
			printf("	iippECPointIsNotValid\n");
		}
		if(*pResult==ippECInvalidOrder)
		{
			printf("	ippECInvalidOrder\n");
		}
		if(*pResult==ippECIsWeakMOV)
		{
			printf("	ippECIsWeakMOV\n");
		}
		if(*pResult==ippECIsWeakSSSA)
		{
			printf("	ippECIsWeakSSSA\n");
		}
	}
	
	//2- Setting those values
	//We create the couple of keys	
	printf("test a l interieur , %d \n",test);
	if(ippsPRNGInit(8,pRNGCtx)!=ippStsNoErr)
	{
		printf("Probleme initialisation RNG \n");
		if(ippsPRNGInit(8,pRNGCtx)==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr\n");
		}
		if(ippsPRNGInit(8,pRNGCtx)==ippStsLengthErr)
		{
			printf("	ippStsLengthErr\n");
		}
	}
	//We specify ourselves the public key and the private key
	feBitSize=8;		
	lengthtest=1;
	sizetest=0;
	cofactor=1;
	if(ippsBigNumGetSize(lengthtest ,&sizetest)!=ippStsNoErr)
	{
		printf("probleme creation Big Num Get Size \n");
		if(ippsBigNumGetSize(lengthtest/32 +1 ,&sizetest)==ippStsNullPtrErr)
		{
			printf("	Probleme de pointeur nul \n");
		}
		if(ippsBigNumGetSize(lengthtest/32 +1 ,&sizetest)==ippStsLengthErr)
		{
			printf("	Probleme de longueur \n");
		}
	}
	//Ipp8u abis[sizetest];
	IppsBigNumState *pX = NULL;
	IppsBigNumState *pY = NULL;
	sizetest=sizetest*sizeof(char);
	pX=malloc(sizetest);
	pY=malloc(sizetest);
	if(ippsBigNumInit(lengthtest ,pX)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	if(ippsBigNumInit(lengthtest ,pY)!=ippStsNoErr)
	{
		printf("probleme dans BigNumInit \n");
	}
	//On est oblige de redeclarer les variables...
	Ipp8u desiredBNvalue10[]="\x25";	//32
	if(ippsSetOctString_BN(desiredBNvalue10,sizeof(desiredBNvalue10)-1,pPrivate)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt 10 \n");
		if(ippsSetOctString_BN(desiredBNvalue10,sizeof(desiredBNvalue10)-1,pPrivate)==ippStsNullPtrErr)
		{
			printf("	Probleme de pointeur nul\n");
		}
		if(ippsSetOctString_BN(desiredBNvalue10,sizeof(desiredBNvalue10)-1,pPrivate)==ippStsLengthErr)				
		{
			printf("	Probleme de longueur \n");
		}
		if(ippsSetOctString_BN(desiredBNvalue10,sizeof(desiredBNvalue10)-1,pPrivate)==ippStsSizeErr)				
		{
			printf("	Probleme de place \n");
		}
	}
	Ipp8u desiredBNvalue11[]="\x31";	//49 le nom des variables choisi par economie
	if(ippsSetOctString_BN(desiredBNvalue11,sizeof(desiredBNvalue11)-1,pX)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt 11 \n");
	}
	Ipp8u desiredBNvalue12[]="\x2E";	//60 le nom des variables choisi par economie
	if(ippsSetOctString_BN(desiredBNvalue12,sizeof(desiredBNvalue12)-1,pY)!=ippStsNoErr)
	{
		printf("probleme dans SetOCt 12 \n");
	}


	if(ippsECCPSetPoint( pX, pY, pPublic, pECC ) !=ippStsNoErr)
	{
		printf("probleme dans ECCPSetPoint\n");
		if(ippsECCPSetPoint(  pX, pY, pPublic, pECC)==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr\n");
		}
		if(ippsECCPSetPoint( pX, pY, pPublic, pECC )==ippStsContextMatchErr)
		{
			printf("	ippStsContextMatchErr\n");
		}
	}
		
	if(ippsECCPSetKeyPair(pPrivate, pPublic, ippFalse, pECC )!=ippStsNoErr)
	{
		printf("Problemes dans la creation de cle \n");
		if(ippsECCPSetKeyPair(pPrivate, pPublic, ippFalse,pECC)==ippStsContextMatchErr)
			{
			printf("	ippStsContextMatchErr \n");
			}
	}
	pResult=malloc(sizeof(IppECResult));
	*pResult=ippStsContextMatchErr;
	if(ippsECCPValidateKeyPair(pPrivate, pPublic, pResult, pECC )!=ippStsNoErr)
	{
		printf("Probleme test de validation couple cle \n");
		if(ippsECCPValidateKeyPair(pPrivate, pPublic, pResult, pECC )==ippStsContextMatchErr)
		{
			printf("	ippStsContextMatchErr\n");
		}
		else if (ippsECCPValidateKeyPair(pPrivate, pPublic, pResult, pECC )==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr \n");
		}
	}
	if(*pResult==ippECValid)
		printf("	couple de cles valides \n");
	else if(*pResult==ippECInvalidKeyPair)
		printf("	ippECInvalidKeyPair \n");
	else if(*pResult==ippECInvalidPrivateKey)
		printf("	ippECInvalidPrivateKey \n");
	else if(*pResult==ippECPointIsAtInfinite)
		printf("	ippECPointIsAtInfinite \n");
	else if(*pResult==ippECInvalidPublicKey)
		printf("	ippECInvalidPublicKey \n");
	printf("on va tester signer \n");
	//We test the signing of the document	
	if(ippsECCPSignDSA(pMsgDigest, pPrivate, pSignX, pSignY, pECC)!=ippStsNoErr)
	{		
		printf("problemes dans la signature \n");
		if(ippsECCPSignDSA( pMsgDigest, pPrivate, pSignX, pSignY, pSignY)==ippStsNullPtrErr)
		{
			printf("	ippStsNullPtrErr \n");
		}
		else if(ippsECCPSignDSA(pMsgDigest, pPrivate, pSignX, pSignY, pECC)==ippStsEphemeralKeyErr)
		{
			printf("	ippStsEphemeralKeyErr \n");
		}
		else if(ippsECCPSignDSA(pMsgDigest, pPrivate, pSignX, pSignY, pECC)==ippStsContextMatchErr)
		{
			printf("	ippStsContextMatchErr \n");
		}
		else if(ippsECCPSignDSA(pMsgDigest, pPrivate, pSignX, pSignY, pECC)==ippStsMessageErr)
		{
			printf("	ippStsMessageErr \n");
		}
		else if(ippsECCPSignDSA(pMsgDigest, pPrivate, pSignX, pSignY, pECC)==ippStsRangeErr)
		{
			printf("	ippStsRangeErr \n");
		}
	}	
	return 0;
}