/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
* Crypto Layer to use and change any cryptolibrary easily.
* Contains all the cryptographic functions used in IKEv1.
*
*/



#include "ikev1crypto.h"
#include "ikemsgheader.h"
#include "dhparameters.h"
#include "utlcrypto.h"

CIkeKeys* CIkeKeys::NewL(const TDesC8& aN, const TDesC8& aG)
{
    CIkeKeys *keys = new (ELeave) CIkeKeys();
    keys->iDHKey = TUtlCrypto::MakeDiffieHellmanL(aN, aG);
	keys->iModuluslength = aN.Length();
    return keys;
}

CIkeKeys::~CIkeKeys()
{
    delete iDHKey;
}


HBufC8* CIkeKeys::GetPubKey()
{
    HBufC8* DHPublicKey = (HBufC8*)iPubKey;
    iPubKey = NULL; // Exclusive ownership of iPubKey buffer is returned to caller
    return DHPublicKey;
}

void CIkeKeys::XValueL()
{
    iPubKey = iDHKey->GenerateXL();
}


const HBufC8* CIkeKeys::KValueL(const TDesC8& aY) const 
{
    return iDHKey->CompleteKL(aY);
}




//Generates a group of parameters depending on the group.
CIkeKeys *CreateDHKeyL(TUint aGroupDesc)
{
    TPtrC8 prime_ptr(NULL, 0);
    TPtrC8 gen_ptr(NULL, 0);

    switch (aGroupDesc)
    {
    case MODP_768:
        prime_ptr.Set((TUint8 *)&MODP_768_PRIME[0], MODP_768_PRIME_LENGTH);
        gen_ptr.Set((TUint8 *)&MODP_768_GENERATOR[0], MODP_768_GENERATOR_LENGTH);
        break;
    case MODP_1024:
        prime_ptr.Set((TUint8 *)&MODP_1024_PRIME[0], MODP_1024_PRIME_LENGTH);
        gen_ptr.Set((TUint8 *)&MODP_1024_GENERATOR[0], MODP_1024_GENERATOR_LENGTH);
        break;
    case MODP_1536:
        prime_ptr.Set((TUint8 *)&MODP_1536_PRIME[0], MODP_1536_PRIME_LENGTH);
        gen_ptr.Set((TUint8 *)&MODP_1536_GENERATOR[0], MODP_1536_GENERATOR_LENGTH);
        break;
    case MODP_2048:
        prime_ptr.Set((TUint8 *)&MODP_2048_PRIME[0], MODP_2048_PRIME_LENGTH);
        gen_ptr.Set((TUint8 *)&MODP_2048_GENERATOR[0], MODP_2048_GENERATOR_LENGTH);
        break;
    case EC2N_155:
    case EC2N_185:
        return NULL;
    default:    //Cannot happen because checked before!!!
        return NULL;
    }
    
    CIkeKeys *arg = CIkeKeys::NewL(prime_ptr, gen_ptr);
    
    return arg;
}

CIkeKeys *GeneratePubPrivKeysL(TUint aGroupDesc)
{
    CIkeKeys *dh_key = CreateDHKeyL(aGroupDesc);
    if (!dh_key)
        return NULL;
    dh_key->XValueL();    //Initializes the public and private keys.

    return dh_key;

}

HBufC8* ComputeAgreedKeyL(TUint /*aGroupDesc*/, const TDesC8 &aPeerPublicKey, CIkeKeys *aOwnKeys)
{
    if(!aOwnKeys)
        return NULL;

	return (HBufC8*)aOwnKeys->KValueL(aPeerPublicKey);
}

void DecryptL(const TUint8* aInputPayload, TUint8* aOutputPayload, TUint32 aLength, TDes8& aIV, TDesC8& aKey, TUint16 aEncrAlg)
{
    TUtlCrypto::TUtlSymmetricCipherId CipherId = TUtlCrypto::EUtlSymmetricCipherAesCbc;  // Defaults
    TInt IVLth = AESCBC_IV_LEN;
	
    if ( aEncrAlg == DES3_CBC )
	{
		CipherId = TUtlCrypto::EUtlSymmetricCipher3DesCbc;
		IVLth    = DESCBC_IV_LEN;
    }    
    else if ( aEncrAlg == DES_CBC)
	{
		CipherId = TUtlCrypto::EUtlSymmetricCipherDesCbc;
		IVLth    = DESCBC_IV_LEN;		
    }       
    //
    //  Construct cipher object for symmetric decrypt operation
    //
    TPtrC8 iv_ptr(aIV.Ptr(), IVLth);
    TPtrC8 ciphertext(aInputPayload, aLength);
    TPtr8  plaintext(aOutputPayload, aLength);
	
	CUtlSymmetricCipher* UtlCipher = TUtlCrypto::MakeSymmetricDecryptorL(CipherId,
		                                                                 aKey,
	                                                                     iv_ptr);
	
    CleanupStack::PushL(UtlCipher);
    UtlCipher->ProcessFinalL(ciphertext, plaintext);
    CleanupStack::PopAndDestroy();
    aIV.Copy(&aInputPayload[aLength - IVLth], IVLth);   //Next IV (last 8 bytes of ciphertext)     
                                                                           
}

TBool EncryptL(TDes8& aInputPayload, TDes8& aOutputPayload, TDes8& aIV, TDesC8& aKey, TUint16 aEncrAlg)
{
    TUtlCrypto::TUtlSymmetricCipherId CipherId = TUtlCrypto::EUtlSymmetricCipherAesCbc;  // Defaults
    TInt CbLth = AESCBC_IV_LEN;
	
    if ( aEncrAlg == DES3_CBC )
	{
        CipherId = TUtlCrypto::EUtlSymmetricCipher3DesCbc;
		CbLth    = DESCBC_IV_LEN;
    }    
    else if ( aEncrAlg == DES_CBC)
	{
        CipherId = TUtlCrypto::EUtlSymmetricCipherDesCbc;
		CbLth    = DESCBC_IV_LEN;
    }
    TPtrC8 iv_ptr(aIV.Ptr(), CbLth);
    //
    // Add padding, if needed
    //
    TUint padding_bytes = (aInputPayload.Length() - ISAKMP_HDR_SIZE) % CbLth;
    if (padding_bytes != 0)   //Padd with 0 at the end if needed
    {
        TChar c(0);
        aInputPayload.AppendFill(c,CbLth-padding_bytes);    //Append at the end
    }
    //
    // ISAKMP fixed header not encrypted
    //
    TPtrC8 plaintext(aInputPayload.Ptr() + ISAKMP_HDR_SIZE, aInputPayload.Length() - ISAKMP_HDR_SIZE);//skip hdr
    aOutputPayload.Copy(aInputPayload.Ptr(), ISAKMP_HDR_SIZE);  //The same HDR in output
    
    TPtr8 ciphertext((TUint8 *)aOutputPayload.Ptr() + ISAKMP_HDR_SIZE, 0, aInputPayload.Length() - ISAKMP_HDR_SIZE);//skip hdr  
    //
    //  Construct cipher object for symmetric decrypt operation
    //
	CUtlSymmetricCipher* UtlCipher = TUtlCrypto::MakeSymmetricEncryptorL(CipherId,
	                                                                     aKey,
		                                                                 iv_ptr);
    CleanupStack::PushL(UtlCipher);     
    UtlCipher->ProcessFinalL(plaintext, ciphertext);
    CleanupStack::PopAndDestroy();     
    //
    // Next IV (last cipher block of encrypted buffer)
    //
    aOutputPayload.SetLength(ISAKMP_HDR_SIZE + ciphertext.Length());
    aIV.Copy(aOutputPayload.Ptr() + aOutputPayload.Length() - CbLth, CbLth); 
    
    return ETrue;
                                                                           
}


void MD5HashL(const TDesC8 &aInData, TDes8& aOutData)
{
    CUtlMessageDigest* Digest = TUtlCrypto::MakeMessageDigesterL(TUtlCrypto::EUtlMessageDigestMd5);
    aOutData.Copy(Digest->Final(aInData));
    delete Digest;
}

void SHA1HashL(const TDesC8 &aInData, TDes8& aOutData)
{
    CUtlMessageDigest* Digest = TUtlCrypto::MakeMessageDigesterL(TUtlCrypto::EUtlMessageDigestSha1);
    aOutData.Copy(Digest->Final(aInData));
    delete Digest;
}

void MD5HmacL(const TDesC8 &aInData, TDes8& aOutData, const TDesC8& aKeyData)
{
    CUtlMessageDigest* Digest = TUtlCrypto::MakeMessageDigesterL(TUtlCrypto::EUtlMessageDigestMd5,
                                                                 aKeyData);
    aOutData.Copy(Digest->Final(aInData));  
    delete Digest;
}

void SHA1HmacL(const TDesC8 &aInData, TDes8& aOutData, const TDesC8& aKeyData)
{
    CUtlMessageDigest* Digest = TUtlCrypto::MakeMessageDigesterL(TUtlCrypto::EUtlMessageDigestSha1,
                                                                 aKeyData);
    aOutData.Copy(Digest->Final(aInData));  
    delete Digest;
}

void Hmac3DesCbcL(const TDesC8 &aInData, TDes8& aOutData, const TDesC8& aKeyData)
{
    TUint8 *pad = new (ELeave) TUint8[PAD_SIZE];
    TInt pad_len = 0;
    CleanupStack::PushL(pad);
    TBuf8<8> iv;
    TBuf8<24> prf_key2;
    TPtrC8 prf_key_ptr;
        
    if ( aKeyData.Length() < 24)  //if less than 24 bits the rest must be 0's
    {
       prf_key2.FillZ(24);
       prf_key2.Copy(aKeyData);
       prf_key2.SetLength(24);
       prf_key_ptr.Set(prf_key2);
    }
    else
    {   
       prf_key_ptr.Set(aKeyData);
    }   
    iv.FillZ(8);
    Mem::Copy(pad, aInData.Ptr(), aInData.Length());
    pad_len = aInData.Length();
    if ( pad_len & 0x07 ) //Add padding to align to byte pieces??????????
    {
       Mem::FillZ(&pad[pad_len], 7);
       pad_len += 7;
       pad_len = (pad_len & 65528) + 8;
    }
    Cipher3DesL(pad, pad_len, prf_key_ptr, iv, aOutData);

    CleanupStack::PopAndDestroy();  //pad       
    
}

void Cipher3DesL(TUint8 *aInData, TInt aInDataLen, const TDesC8 &aPrfKey, TDes8 &aIV, TDes8 &aOutData)
{

    TPtrC8 iv_ptr(aIV.Ptr(), DESCBC_IV_LEN);
    TPtrC8 key_ptr(aPrfKey.Ptr(), 3*DESCBC_KEY_LEN);
    
    HBufC8 *des_input = HBufC8::NewL(aInDataLen + 8);
    CleanupStack::PushL(des_input);         
    TPtr8 des_input_ptr((TUint8 *)des_input->Des().Ptr(), aInDataLen + 8, aInDataLen + 8);  //Contains the PRF input text
    TPtrC8 plain_input_text(aInData, aInDataLen);//skip hdr
    //
    //  Construct cipher object for symmetric decrypt operation
    //
    CUtlSymmetricCipher* UtlCipher = TUtlCrypto::MakeSymmetricEncryptorL(TUtlCrypto::EUtlSymmetricCipher3DesCbc,
                                                                         key_ptr,
                                                                         iv_ptr);
    CleanupStack::PushL(UtlCipher);
    
    HBufC8 *des_output= HBufC8::NewL(des_input_ptr.Length() + UtlCipher->BlockSize());
    CleanupStack::PushL(des_output);            
    TPtr8 des_output_ptr((TUint8 *)des_output->Des().Ptr(), des_input_ptr.Length() + UtlCipher->BlockSize());

    UtlCipher->ProcessFinalL(plain_input_text, des_output_ptr);
    TPtrC8 tmp_input_data(&des_output_ptr[des_output_ptr.Length() - 8], 8); //Input Data to the 2nd 8-bit chunk encryption  
    UtlCipher->Reset();    //Restart
    UtlCipher->ProcessFinalL(tmp_input_data, aOutData); 
    
    // Do second eight bytes
    des_input_ptr.Copy(aOutData);
    des_input_ptr.Append(plain_input_text); //reattach the input data
    UtlCipher->Reset();    //Restart
    UtlCipher->ProcessFinalL(des_input_ptr, des_output_ptr);
    
    tmp_input_data.Set(&des_output_ptr[des_output_ptr.Length() - 8], 8);
    TPtr8 out_data_ptr((TUint8 *)aOutData.Ptr() + 8, 0, 8);
    UtlCipher->Reset();    //Restart
    UtlCipher->ProcessFinalL(tmp_input_data, out_data_ptr);
    
    // Do third eight bytes 
    Mem::Copy((TUint8 *)des_input_ptr.Ptr(), aOutData.Ptr() + 8, 8);    //last 8 bytes of previous result put at the beginning
    //The length of des_input_ptr won't change so the data after byte 8 is still used!!!    
    UtlCipher->Reset();    //Restart
    UtlCipher->ProcessFinalL(des_input_ptr, des_output_ptr);
    
    tmp_input_data.Set(&des_output_ptr[des_output_ptr.Length() - 8], 8);
    out_data_ptr.Set((TUint8 *)aOutData.Ptr() + 16, 0, 8);  //the last 8 bytes (16 to 23)
    UtlCipher->Reset();    //Restart
    UtlCipher->ProcessFinalL(tmp_input_data, out_data_ptr);
    
    aOutData.SetLength(24);

    CleanupStack::PopAndDestroy(3); // des_output, UtlCipher and  des_input     
}

TInt SymmetricCipherL(TUint8 *aInput,  TUint8 *aOutput, TInt aLength,
				      TUint8 *aKey,    TUint8 *aIV, TBool aEncr, TInt aEncAlg)
{
	(void)aEncAlg;
	TPtrC8 iv_ptr(aIV, DESCBC_IV_LEN );
	TPtrC8 key_ptr(aKey, DESCBC_IV_LEN);

	CUtlSymmetricCipher* UtlCipher; 
	if ( aEncr ) {
    	//
	    // Add padding (according RFC 1423) and encrypt data 
	    //
       TInt PaddingBytes = 8 - (aLength % 8);
	   for ( TInt i = 0; i < PaddingBytes; i++ ) {
		   *(aInput + aLength + i) = (TUint8)PaddingBytes;
	   }
	   aLength += PaddingBytes;
	   UtlCipher = TUtlCrypto::MakeSymmetricEncryptorL(TUtlCrypto::EUtlSymmetricCipherDesCbc,
			                                            key_ptr, iv_ptr);
	}	 
	else {
		//
		// Decrypt data 
		//
	   UtlCipher = TUtlCrypto::MakeSymmetricDecryptorL(TUtlCrypto::EUtlSymmetricCipherDesCbc,
		                                               key_ptr, iv_ptr);
	}
	CleanupStack::PushL(UtlCipher);
	TPtrC8 inp(aInput, aLength);
	TPtr8 outp(aOutput, aLength);
	UtlCipher->ProcessFinalL(inp, outp);
	CleanupStack::PopAndDestroy();

	if ( !aEncr ) {
	   //
	   // Remove padding from decrypted data
	   //
	   TUint8 PaddingLth = *(aOutput + aLength - 1);
	   if ( PaddingLth < 9 )
		    aLength -= (TInt)PaddingLth;      // Ok padding count
	   else aLength = 0;
	}

	return aLength;
		
}