// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 //

 #include "ipseckeystreamsink.h"

 #include <caf/streaming/keyassociation.h>

 #include <networking/pfkeyv2.h>

 #include <s32mem.h>

 #include "scaflog.h"

 using namespace StreamAccess;

 // The last two rules: (inbound = {}, outbound = {}) are catch-all rules - without them, all packets

 // which do not match the policy will get rejected

 _LIT8( KPolicyFormat,  

 "SECURITY_FILE_VERSION: 3\r\n[INFO]\r\n\

 Test CAF IpSec Integration Policy\r\n\

 [POLICY]\r\n\

 sa caf_sas = {\r\n\

 esp\r\n\

 encrypt_alg %d\r\n\

 auth_alg %d\r\n\

 src_specific\r\n\

 local_port_specific\r\n\

 remote_port_specific\r\n\

 }\r\n\

 inbound local %S 255.255.255.255 local_port %d remote_port %d = { caf_sas() }\r\n\

 inbound = {}\r\n\

 outbound = {}\r\n" );

 // The number is taken as the maximal recommendation from OMA DRM BCAST standard (section 9.1, IPSec management)

 const TUint KDefaultMaxSpiNumber = 3; 

 CIpSecKeyStreamSink* CIpSecKeyStreamSink::NewLC(const TInetAddr& aSrcAddr, const TInetAddr& aDstAddr)

 	{

 	CIpSecKeyStreamSink* self = new (ELeave) CIpSecKeyStreamSink(aSrcAddr, aDstAddr);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 CIpSecKeyStreamSink::CIpSecKeyStreamSink(const TInetAddr& aSrcAddr, const TInetAddr& aDstAddr) :

 						iSourceAddr(aSrcAddr), 

 						iDestinationAddr(aDstAddr), 

 						iPolicySet(EFalse),

 						iMaxSpiNumber(KDefaultMaxSpiNumber)

 	{		

 	}

 CIpSecKeyStreamSink::~CIpSecKeyStreamSink()

 	{

 	// Remove all SA-s

 	TInt submittedSaCount = iSubmittedSpiList.Count();

 	for (TInt i = 0; i < submittedSaCount; ++i)

 		{

 		TRAP_IGNORE(RemoveSaL(iSubmittedSpiList[i]));

 		}

 	if (iPolicySet)

 		{

 		TRequestStatus status;

 		iPolicyServer.UnloadPolicy( iPolicyHandle(), status );

 		User::WaitForRequest(status);

 		// Impossible to handle the error well in destructor - ignore the status code

 		}

 	iSADB.Close();

 	iSocketServ.Close();

 	iPolicyServer.Close();		

 	iSubmittedSpiList.Close();

 	}

 void CIpSecKeyStreamSink::ConstructL()

 	{

 	DEBUG_PRINTF(_L("Constructing an IPSec key stream sink."));

 	User::LeaveIfError(iSocketServ.Connect());

 	User::LeaveIfError(iSADB.Open(iSocketServ));

 	User::LeaveIfError(iPolicyServer.Connect());	

 	DEBUG_PRINTF(_L("Constructed an IPSec key stream sink."));

 	}

 CKeyStreamSink* CIpSecKeyStreamSink::CloneLC() const

 	{

 	CIpSecKeyStreamSink *ret = CIpSecKeyStreamSink::NewLC(iSourceAddr, iDestinationAddr);

   	ret->iEncAlg = this->iEncAlg;

  	ret->iAuthAlg = this->iAuthAlg;

  	return ret;

 	}

 static TUint32 ConvertToNetworkOrder(TUint32 aNum)

     {

     const TInt KMaxTUint32CStringLen = 11;

     TUint8 temp[ KMaxTUint32CStringLen ];   

     LittleEndian::Put32( temp, aNum );

     return BigEndian::Get32( temp );

     }

 TBool CIpSecKeyStreamSink::CompareReceivedMessageExtensionsL(TPfkeyRecvMsg &aReceivedReply, TUint32 aSpi) const

 	{

 	TBool spiVerified(EFalse), destAddrVerified(EFalse);

 	TPfkeyAnyExt ext;

  	// We verify that both the SPI matches and the destination address matches - this should exclude

  	// replies to unrelated messages

 	while ( !spiVerified || !destAddrVerified )

          {

          // Both extensions should be found in the reply

          User::LeaveIfError(aReceivedReply.NextExtension(ext));

          TInt extType = ext.ExtType();

          if ( extType == SADB_EXT_ADDRESS_DST )

              {

              const TInetAddr* addr = reinterpret_cast<const TInetAddr *>(ext.Ptr() + sizeof(struct sadb_address));

     		 if (*addr == iDestinationAddr)

     		 	destAddrVerified = ETrue;	

     		 else

     			return EFalse;

              }

          else if (extType == SADB_EXT_SA)

          	{

     		const sadb_sa* saExt = reinterpret_cast<const sadb_sa *>(ext.Ptr());

     		if (saExt->sadb_sa_spi == aSpi)

     			spiVerified = ETrue;

     		else

     			return EFalse;

          	}

          }

     return ETrue;

 	}

 void CIpSecKeyStreamSink::SynchronousSendAndVerifyMessageL(TPfkeySendMsg& aMessage, TInt aMessageType, TUint32 aSpi) 

 	{

 	// Wait for the message to be sent

 	TRequestStatus status;

 	iSADB.FinalizeAndSend(aMessage, status);

 	User::WaitForRequest(status);

 	User::LeaveIfError(status.Int());

 	// Receive a reply - since SADB sends replies to _all_ sockets, we need to filter out replies

 	// which do not correspond to our own request

 	for(;;)

 		{

 		TPfkeyRecvMsg receivedReply;

 		iSADB.ReadRequest(receivedReply, status);

 		User::WaitForRequest(status);

 		User::LeaveIfError(status.Int());

 		// Verify that the message is a reply to the one sent by us

 		sadb_msg &msgHeader = receivedReply.MsgHdr();

 		if (msgHeader.sadb_msg_pid != RProcess().Id())

 			continue;

 		if (msgHeader.sadb_msg_seq != iSequenceNumber)

 			continue;

 		// Do additional validation by checking whether the destination address and the SPI are the same as ours

 		TBool isResponseToRequest(ETrue);

 		switch (aMessageType)

 			{

 			case SADB_ADD: 

 			case SADB_DELETE:

 				isResponseToRequest = CompareReceivedMessageExtensionsL(receivedReply, aSpi);

 				break;

 			default:

 				ASSERT(0); // Unexpected state

 			}

 		if (!isResponseToRequest)

 			continue;

 		// If the message types does not match, then the problem is internal in IPSec - it should not answer with a different message type

 		if (msgHeader.sadb_msg_type != aMessageType)

 			User::Leave(KErrArgument); 

 		if (msgHeader.sadb_msg_errno != 0)

 			{

 			// Mimic the logic in IPSec error handling (see the Update function in key_msg.cpp)		

 			TUint16 reservedField = (TUint16)msgHeader.sadb_msg_reserved << 8;

 			TUint16 errnoField = msgHeader.sadb_msg_errno;

 			User::Leave(-(reservedField + errnoField));

 			}		

 		break;

 		}			

 	}

 void CIpSecKeyStreamSink::AddAssociationL(TPfkeySendMsg& aMessage, TUint32 aSpi) 	

 	{

 	SynchronousSendAndVerifyMessageL(aMessage, SADB_ADD, aSpi);

 	// Take care to delete old SA-s, if needed

 	iSubmittedSpiList.AppendL(aSpi); 

 	if (iSubmittedSpiList.Count() > iMaxSpiNumber)

 		{

 		RemoveSaL(iSubmittedSpiList[0]);

 		iSubmittedSpiList.Remove(0);

 		}		

 	}

 void CIpSecKeyStreamSink::ProcessNewKeyAssociationL(const CKeyAssociation& aKeyAssociation) 

 	{

 	if (!iPolicySet)

 		{

 		SetPolicyL();

 		}

 	// No official RTTI support, using static_cast - no validation that it is indeed an IPSec association

 	const CIpSecKeyAssociation* ipsecKeyAssociation = static_cast<const CIpSecKeyAssociation *>(&aKeyAssociation);

 	DEBUG_PRINTF2(_L("IPSec key stream sink - processing new association with SPI %d."), ipsecKeyAssociation->GetSpiL());

 	// We use ESP, since there is very low probability that AH will be used - it does not provide confidentiality

 	TPfkeySendMsg sendMessage(SADB_ADD, SADB_SATYPE_ESP, ++iSequenceNumber, RProcess().Id());

 	TUint32 bigEndianSpi(ConvertToNetworkOrder(ipsecKeyAssociation->GetSpiL()));

 	sendMessage.Add( Int2Type<SADB_EXT_SA>(), bigEndianSpi, iAuthAlg, iEncAlg); 

 	const HBufC8 *encryptionKey(ipsecKeyAssociation->GetEncryptionKeyL());

 	if(!encryptionKey)

 		User::Leave(KErrArgument);

 	sendMessage.Add( Int2Type<SADB_EXT_KEY_ENCRYPT>(), *encryptionKey, encryptionKey->Length() * 8);

 	if (iAuthAlg) // Authentication is optional - use it only if algorithm has been set

 		{

 		const HBufC8 *authenticationKey(ipsecKeyAssociation->GetAuthenticationKeyL());

 		if (!authenticationKey)

 			User::Leave(KErrArgument);

 		sendMessage.Add( Int2Type<SADB_EXT_KEY_AUTH>(), *authenticationKey, authenticationKey->Length() * 8);			

 		}

 	sendMessage.Add( Int2Type<SADB_EXT_ADDRESS_SRC>(), iSourceAddr);

 	sendMessage.Add( Int2Type<SADB_EXT_ADDRESS_DST>(), iDestinationAddr);

 	TRAPD(err, AddAssociationL(sendMessage, bigEndianSpi));

 	// If something went wrong, try to remove the SA, to keep the SADB in consistent state.

 	// We only do our best effort, since the error might be global to the device, or it may have occured before we've added the SA

 	if (err != KErrNone)

 		{

 		TRAP_IGNORE(RemoveSaL(bigEndianSpi));

 		TInt submittedSpiCount = iSubmittedSpiList.Count();

 		if (submittedSpiCount > 0 && iSubmittedSpiList[submittedSpiCount - 1] == bigEndianSpi)

 			iSubmittedSpiList.Remove(submittedSpiCount - 1);

 		User::Leave(err);

 		}

 	DEBUG_PRINTF2(_L("IPSec key stream sink - processed new association with SPI %d."), ipsecKeyAssociation->GetSpiL());

 	}

 void CIpSecKeyStreamSink::RemoveSaL(TUint32 aSpi)

 	{	

 	TPfkeySendMsg sendMessage(SADB_DELETE, SADB_SATYPE_ESP, ++iSequenceNumber, RProcess().Id());	

 	sendMessage.Add( Int2Type<SADB_EXT_SA>(), aSpi, iAuthAlg, iEncAlg); 

 	sendMessage.Add( Int2Type<SADB_EXT_ADDRESS_DST>(), iDestinationAddr);

 	SynchronousSendAndVerifyMessageL(sendMessage, SADB_DELETE, aSpi);

 	}

 void CIpSecKeyStreamSink::VerifyAssociationsNotSentL() const

 	{

 	if (iSubmittedSpiList.Count())

 		{

 		User::Leave(KErrNotSupported); // It is forbidden to change the algorithm once associations have been processed

 		}	

 	}

 const TUint32 SADB_AALG_AESCBC = 12; // temporarily here until IPSec supports AES constants

 void CIpSecKeyStreamSink::SetEncryptionAlgorithmL(const TEncryptionAlgorithm& aEncryptionAlgorithm)

 	{

 	VerifyAssociationsNotSentL();

 	switch (aEncryptionAlgorithm)

 		{

 		case EAES_128_CBC: iEncAlg = SADB_AALG_AESCBC; break;

 		case ENoEncryption: 

 		case EAES_128_CTR:		

 		default: User::Leave(KErrNotSupported);		

 		};

 	}

 void CIpSecKeyStreamSink::SetAuthenticationAlgorithmL(const TAuthenticationAlgorithm& aAuthenticationAlgorithm)

 	{

 	VerifyAssociationsNotSentL();

 	switch (aAuthenticationAlgorithm)

 		{

 		case EHMAC_SHA1: iAuthAlg = SADB_AALG_SHA1HMAC; break;

 		case ENoAuthentication:	iAuthAlg = 0; break;

 		default: User::Leave(KErrNotSupported);

 		};

 	}

 const TUint KInet6AddrMaxBufferSize = 40;

 void CIpSecKeyStreamSink::SetPolicyL()

 	{

 	DEBUG_PRINTF(_L("IPSec key stream sink - setting policy."));

 	ASSERT(!iPolicySet);

 	TBuf<KInet6AddrMaxBufferSize> destAddrStr;

 	iDestinationAddr.Output(destAddrStr);

 	// Convert 16-bit to 8-bit. For some strange reason, the string for IP address is returned in 16-bit.

 	TBuf8<KInet6AddrMaxBufferSize> destAddrStr8bit;

 	destAddrStr8bit.Copy(destAddrStr);

 	HBufC8 *policyData = HBufC8::NewLC( KPolicyFormat().Length() + 256); // Allow size for port and IP spec.

 	TPtr8 policyDataPtr(policyData->Des());

 	policyDataPtr.AppendFormat(KPolicyFormat, iEncAlg, iAuthAlg, &destAddrStr8bit, iDestinationAddr.Port(), 

 							   iSourceAddr.Port());	

 	// Load the server-side policy to protect all packets to a specific port

 	TRequestStatus status;

 	iPolicyServer.LoadPolicy( *policyData, iPolicyHandle, status );

 	User::WaitForRequest(status);

 	User::LeaveIfError(status.Int());

 	iPolicyServer.ActivatePolicy( iPolicyHandle(), status );

 	User::WaitForRequest(status);

 	User::LeaveIfError(status.Int());	

 	CleanupStack::PopAndDestroy(policyData);	

 	iPolicySet = ETrue;	

 	DEBUG_PRINTF(_L("IPSec key stream sink - policy set."));

 	}

 static void ReadIpAddrFromStreamL(RReadStream& aStream, TInetAddr& addr)

 	{

 	TBuf<KInet6AddrMaxBufferSize> addrStr;

 	TUint8 addrStrLen = aStream.ReadUint8L();

 	aStream.ReadL(addrStr, addrStrLen);

 	User::LeaveIfError(addr.Input(addrStr));

 	TInt port = aStream.ReadInt32L();

 	addr.SetPort(port);

 	}

 static void WriteIpAddrToStreamL(RWriteStream& aStream, const TInetAddr& addr)

 	{

 	TBuf<KInet6AddrMaxBufferSize> addrStr;

 	addr.Output(addrStr);

 	aStream.WriteUint8L(addrStr.Length());	

 	aStream.WriteL(addrStr);

 	aStream.WriteInt32L(addr.Port());	

 	}

 void CIpSecKeyStreamSink::DoExternalizeL(RWriteStream& aStream) const

 	{

 	aStream.WriteUint16L(CKeyStreamSink::EIpSecSinkId);

 	WriteIpAddrToStreamL(aStream, iDestinationAddr);

 	WriteIpAddrToStreamL(aStream, iSourceAddr);

 	aStream.WriteUint16L(iEncAlg);

 	aStream.WriteUint16L(iAuthAlg);

 	}

 CIpSecKeyStreamSink* CIpSecKeyStreamSink::NewLC(RReadStream& aReadStream)

 	{

 	TInetAddr destAddr;

 	ReadIpAddrFromStreamL(aReadStream, destAddr);

 	TInetAddr srcAddr;

 	ReadIpAddrFromStreamL(aReadStream, srcAddr);	

 	CIpSecKeyStreamSink* self = new (ELeave) CIpSecKeyStreamSink(srcAddr, destAddr);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	self->iEncAlg = aReadStream.ReadUint16L();

 	self->iAuthAlg = aReadStream.ReadUint16L();

 	return self;

 	}