// 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:

// sadb.cpp - IPv6/IPv4 IPSEC security association database

//

#include <networking/pfkeyv2.h>

#include "sadb.h"

#include "sa_crypt.h"

#include "pfkeymsg.h"

#include <networking/ipsecerr.h>

#include "ipseclog.h"

#ifdef SYMBIAN_IPSEC_VOIP_SUPPORT

#include "spdb.h"

#endif // SYMBIAN_IPSEC_VOIP_SUPPORT

// This ungainly manoevure is forced on us because the offset is not evaluated early enough by GCC3.4 to be

// passed as a template parameter

#if defined(__X86GCC__) || defined(__GCCE__)

#define KSecurityAssocTimeoutOffset 256

__ASSERT_COMPILE(KSecurityAssocTimeoutOffset == _FOFF(CSecurityAssoc, iTimeout));

#else

#define KSecurityAssocTimeoutOffset _FOFF(CSecurityAssoc, iTimeout)

#endif

class CSecurityAssocTimeoutLinkage : public TimeoutLinkage<CSecurityAssoc, KSecurityAssocTimeoutOffset>

	/**

	* Relay Timeout callback.

	*

	* This "linkage" receives the timeout callback from RTimeout::iTimeout

	* and relays the event to CSecurityAssoc::TimerExprired() function. 

	*/

	{

public:

	static void Timeout(RTimeout &aLink, const TTime &aNow, TAny *aPtr)

		{

		Object(aLink)->TimerExpired(*(MAssociationManager*)aPtr, aNow);

		}

	};

TLifetime::TLifetime(const struct sadb_lifetime &aLifetime)

	/**

	* Construct a lifetime object from the PF_KEY sadb_lifetime value.

	*

	* @param aLifetime The PFKEY lifetime value.

	*/

	{

	iAllocations = aLifetime.sadb_lifetime_allocations;

	iBytes = aLifetime.sadb_lifetime_bytes;

	// Load the seconds values as is into TTime to be used

	// later in Freeze to convert into a real time stamp.

	iAddtime = aLifetime.sadb_lifetime_addtime;

	iUsetime = aLifetime.sadb_lifetime_usetime;

	}

TLifetime::TLifetime() : iAllocations(0), iBytes(0), iAddtime(0), iUsetime(0)

	/**

	* Default Lifetime initializer.

	*/

	{

	}

void TLifetime::Freeze(TTime &aTime, const TTime &aNow)

	/**

	* Freeze the lifetime.

	*

	* Convert the relative time (aTime) stored in a TTime as seconds

	* into absolute time counting from the given time stamp (aNow).

	*

	* @param aTime	The time to freeze

	* @param aNow	The current time.

	*/

	{

	TInt64 x = aTime.Int64();

	aTime = Time::MaxTTime();

	if (x <= 0)

		// Zero is used to indicate no limit. PFKEY has 64 bit

		// unsigned int values, but EPOC32 64 bit value is signed.

		// if the requested value is large enough to set the sign,

		// treat it the same as 0, use MaxTTime.

		return;

	if (x > aTime.Int64() / 1000000)

		// Conversion to Microseconds would cause overflow, use MaxTTime

		return;

	x *= 1000000;

	if (aTime.Int64() - x < aNow.Int64())

		// Adding x to now would overflow, use MaxTTime

		return;

	// It is safe to add interval to now

	aTime = aNow;

	aTime += TTimeIntervalMicroSeconds(x);

	}

CSecurityAssoc::CSecurityAssoc(const TPfkeyMessage &aMsg) : iTimeout(CSecurityAssocTimeoutLinkage::Timeout)

	/**

	* Construct SA

	*

	* This constructor is only used through the GETSPI and ADD.

	* It creates a larval SA

	*

	*		<base, address, SPI range>

	*		<base, SA, (lifetimes(HS),) address(SD), (address(P)), ...>

	*

	* Only base, address and SPI from SA are handled by the constructor.

	* ADD must call UpdateL() to get the remainging extensions processed!

	*

	* @li	Lifetimes are initialized, but the TIMER is not activated

	*		here, because timer activation may cause an immediate

	*		expiration and deletion of CSecurityAssoc.

	*

	* @param aMsg	The PFKEY message

	*/

	{

	// iBase must always be present!

	iType = aMsg.iBase.iMsg->sadb_msg_satype;

	iState = SADB_SASTATE_LARVAL;

	if (aMsg.iSa.iExt)

		iSPI = aMsg.iSa.iExt->sadb_sa_spi;

	// When src_specific is off from the SA spsecification, then

	// the incoming SA has the dst unspecified, and outgoing SA

	// has the src unspecified. Unspecified can be expressed either

	// by explicitly setting the address as unspecified or just

	// leaving the extension out from the PFKEY message. Need to

	// test the presense of extension in both src and dst.

	// (By default everything is unspecified).

	if (aMsg.iDstAddr.iExt)

		{

		iDst = aMsg.iDstAddr.iAddr;

		iInfo.iPortDst = aMsg.iDstAddr.iPort;

		}

	if (aMsg.iSrcAddr.iExt)

		{

		iSrc = aMsg.iSrcAddr.iAddr;

		iInfo.iPortSrc = aMsg.iSrcAddr.iPort;

		}

	if (aMsg.iProxyAddr.iExt)

		{

		iInfo.iSrc = aMsg.iProxyAddr.iAddr;

		}

	// Set some current times

	TTime time_now;

	time_now.UniversalTime();

	iCurrent.iAddtime = time_now;

	iCurrent.iUsetime = Time::NullTTime();	// as iUsed==0

	TLifetime::Freeze(iSoft.iAddtime, time_now);

	// Set the hard lifetime to the default Larval timeout

	iHard.iAddtime = KLifetime_LARVAL_DEFAULT;

	TLifetime::Freeze(iHard.iAddtime, time_now);

	// All Other fields are assumed to contain initial

	// default values (NULL, 0)

	}

CSecurityAssoc::CSecurityAssoc

	(

	const TSecurityAssocSpec &aSpec,

	const RIpAddress &aSrc,

	const RIpAddress &aDst,

	const RAssociationInfo &aInfo

	) : iTimeout(CSecurityAssocTimeoutLinkage::Timeout)

	/**

	* Construct "larval" SA.

	*

	* This constructor is used for the outgoing packet and it creates

	* a special LARVAL EGG SA (SPI == 0). Called only for ACQUIRE

	* processing.

	*

	* @param aSpec The SA template

	* @param aSrc The SA src address

	* @param aDst The SA dst address

	* @param aInfo Additional information

	*/

	{

	//

	// Contrary to PFKEY text, this implementation contains two kinds of

	// "larval" SA's. This constructor creates an "pre-larval" SA, an "egg"

	// which is recognized from the fact that SPI == 0 (this implementation

	// reserves 0 for internal use and never gives it out as an SPI value)

	iType = aSpec.iType;

	iSPI = 0;

	iDst = aDst;

	iSrc = aSrc;

	iInfo = aInfo;

	// Reference objects, if present need to be refcounted on copy

	if (iInfo.iSrcIdentity)

		iInfo.iSrcIdentity->Open();

	if (iInfo.iDstIdentity)

		iInfo.iDstIdentity->Open();

	iState = SADB_SASTATE_LARVAL;

	iFlags = aSpec.iPfs ? SADB_SAFLAGS_PFS : 0;

	iReplayCheck = (aSpec.iReplayWindowLength != 0);

	//

	// Larval egg does not activate algorithm engines

	// (they need to be created by update!)

	iAalg = aSpec.iAalg;

	iEalg = aSpec.iEalg;

	//

	// Set some base times

	//

	TTime time_now;

	time_now.UniversalTime();

	iCurrent.iAddtime = time_now;

	iCurrent.iUsetime = Time::NullTTime();	// as iUsed==0

	//

	// Set the hard lifetime from the specification, soft

	// lifetime is left as initial infinite. Unspecified

	// iLarvalLifetime is a request to use the default

	// timeout (one cannot request 'infinite' for this)

	iHard.iAddtime = aSpec.iLarvalLifetime ?

		aSpec.iLarvalLifetime : KLifetime_LARVAL_DEFAULT;

	TLifetime::Freeze(iSoft.iAddtime, time_now);

	TLifetime::Freeze(iHard.iAddtime, time_now);

	}

TInt CSecurityAssoc::UpdateL(MAssociationManager &aManager, const TPfkeyMessage &aMsg, CIpsecCryptoManager *aLib)

	/**

	* Update SA from PFKEY message.

	*

	* Initialize CSecurityAssoc from TPfkeyMessage. This is a "blind"

	* operation, most fields are just updated unconditionally, it is

	* assumed that the calling function has verified the legality of

	* this operation. (Some basic checks are done)

	*

	* @param aManager The association manager

	* @param aMsg The PFKEY message

	* @param aLib The crypto manager

	*/

	{

	TInt set_hard = 0;

	// Loading Security Association

	if (aMsg.iSa.iExt)

		{

		//

		// If state is LARVAL, need to "defuse" the internal

		// timeout from the HARD lifetime field, if set.

		// (do this only if aMsg doesn't already rewrite the time)

		//

		set_hard = (iState == SADB_SASTATE_LARVAL);

		if (aMsg.iSa.iExt->sadb_sa_state != SADB_SASTATE_MATURE)

			return KErrGeneral;	 // Only MATURE state can be set.

		if (iSPI && iSPI != aMsg.iSa.iExt->sadb_sa_spi)

			return KErrGeneral;	 // Once SPI is set, it cannot be changed!

		iSPI = aMsg.iSa.iExt->sadb_sa_spi;

		iFlags = aMsg.iSa.iExt->sadb_sa_flags;

		iReplayCheck = (aMsg.iSa.iExt->sadb_sa_replay != 0);

		// This information can only be set for new SA, it cannot

		// be changed or updated (applies to all 'selector' info,

		// including Identity.

		if (aMsg.iSrcAddr.iExt)

			{

			iSrc = aMsg.iSrcAddr.iAddr;

			iInfo.iPortSrc = aMsg.iSrcAddr.iPort;

			}

		if (aMsg.iDstAddr.iExt)

			{

			iDst = aMsg.iDstAddr.iAddr;

			iInfo.iPortDst = aMsg.iDstAddr.iPort;

			iInfo.iProtocol = aMsg.iDstAddr.iExt->sadb_address_proto;

			}

		if (aMsg.iProxyAddr.iExt)

			{

			iInfo.iSrc = aMsg.iProxyAddr.iAddr;

			//

			// Do a special hack: if the proxy address portion is unspecified

			// address, but scope id non-zero, then assume the scope id is

			// actually the interface index of the VPN tunnel interface.

			// (NOTE: this is only useful for inbound SA's?)

			if (iInfo.iSrc().IsUnspecified() && iInfo.iSrc().iScope != 0)

				{

				iTunnelIndex = iInfo.iSrc().iScope;

				iInfo.iSrc.Close();

				}

			}

		}

	// Updating identities should probably only be allowed

	// for larval SA's

	if (aMsg.iDstIdent.iExt && iInfo.iDstIdentity == NULL)

		iInfo.iDstIdentity = CIdentity::NewL(aMsg.iDstIdent.iData, aMsg.iDstIdent.iExt->sadb_ident_type);

	if (aMsg.iSrcIdent.iExt && iInfo.iSrcIdentity == NULL)

		iInfo.iSrcIdentity = CIdentity::NewL(aMsg.iSrcIdent.iData, aMsg.iSrcIdent.iExt->sadb_ident_type);

	//	time_now is used in initialize of the IV and

	//	for lifetimes, so declare and initialize it here

	TTime time_now;

	time_now.UniversalTime();

	// Activating crypto engines

	//		but only if neither of them have been activated before.

	//		If already active,just silently ignore the parameters

	//		in the Message.

	//		(the test below leaves NULL/NULL auth/encrypt situation

	//		open to later update!)

	if (aMsg.iSa.iExt && !iAeng && !iEeng)

		{

		iAalg = aMsg.iSa.iExt->sadb_sa_auth;

		if (iAalg)

			{

#ifdef SYMBIAN_IPSEC_VOIP_SUPPORT	

			if (iAalg == SADB_AALG_AES_XCBC_MAC)

				{

				iAeng = aLib->NewMacL(iAalg, aMsg.iAuthKey.iData);

				}

			else

				{

#endif // SYMBIAN_IPSEC_VOIP_SUPPORT				

				iAeng = aLib->NewAuthL(iAalg, aMsg.iAuthKey.iData);

#ifdef SYMBIAN_IPSEC_VOIP_SUPPORT				

				}

#endif 				

			if (!iAeng)

				User::Leave(KErrNotFound);	// Conf. Error: algorithm not installed!

			}	

		iEalg = aMsg.iSa.iExt->sadb_sa_encrypt;

		if (iEalg)

			{

			iEeng = aLib->NewEncryptL(iEalg, aMsg.iEncryptKey.iData);

			if (!iEeng)

				User::Leave(KErrNotFound);	// Conf. Error: algorithm not installed!

			}

		if (iEeng)

			{

			// NOTE: this must be allocated even if 0 length!

			delete iIV;		// ..just in case...

			iIV = NULL;		// ..just in case

			iIV = HBufC8::NewL(iEeng->IVSize());

			// The initial content of the IV should be some random

			// bit pattern (important thing is to have something that

			// changes, and is not always Zero, thus the time_now is

			// used). [Using uninitialized memory would be a security

			// risk -- it might even contain the key information!!!]

			// (Use of time is a dubious thing, as it might provide

			// information to be used in some other attacks, as it

			// reveals the exact CPU clock time; but it will do for now!)

			TPtr8 iv(iIV->Des());

			TPtr8 fill = TPtr8((TUint8 *)&time_now, sizeof(time_now), sizeof(time_now));

			// Do not use iv.MaxLength(), it may be larger IV size!

			TInt n = iEeng->IVSize();

			while (n > 0)

				{

				if (fill.Length() > n)

					fill.SetLength(n);

				iv.Append(fill);

				n -= fill.Length(); // This loop will hang, if fill.Length() == 0!!

				}

			}

		}

	//	Loading lifetimes

	//		(Done after all "leaving" and error returns, so that initial life

	//		timers won't get overridden by Update, if it fails

	if (aMsg.iHard.iExt)

		{

		iHard = TLifetime(*aMsg.iHard.iExt);

		if (iUsed)

			TLifetime::Freeze(iHard.iUsetime, iCurrent.iUsetime);

		TLifetime::Freeze(iHard.iAddtime, time_now);

		}

	else if (set_hard)

		{

		iHard = TLifetime();

		TLifetime::Freeze(iHard.iAddtime, time_now);

		}

	if (aMsg.iSoft.iExt)

		{

		iSoft = TLifetime(*aMsg.iSoft.iExt);

		if (iUsed)

			TLifetime::Freeze(iSoft.iUsetime, iCurrent.iUsetime);

		TLifetime::Freeze(iSoft.iAddtime, time_now);

		}

	// Load Traffic Selector

	if (aMsg.iTs.iExt)

		{

		iTS.Reset();

		RTrafficSelector dummy;

		for (TInt i = 0; i < aMsg.iTs.iExt->sadb_x_ts_numsel; ++i)

			{

			User::LeaveIfError(iTS.Append(dummy));

			RTrafficSelector &ts = iTS[i];

			const T_sadb_selector &in_ts = aMsg.iTs.Selector(i);

			ts.iProtocol = in_ts.sadb_x_selector_proto;

			ts.iPortSrc = in_ts.iSrc.Port();

			ts.iPortDst = in_ts.iDst.Port();

			User::LeaveIfError(ts.iSrc.Open(aManager.EndPointCollection(), in_ts.iSrc));

			User::LeaveIfError(ts.iDst.Open(aManager.EndPointCollection(), in_ts.iDst));

			}

		}

	// Replace CNatTraversal object to handle ESP UDP encapsulation (created if required)

	delete iNatTraversal;

	iNatTraversal = CNatTraversal::New(iFlags, aMsg.iPrivateExtension);

	// 'set_hard' is only defined when Update wants to change the SA

	// state into MATURE. The actual state change is delayed until

	// here, in case update fails before this. The SA will most likely

	// be unusable, but at least it won't be MATURE either...

	if (set_hard)

		iState = SADB_SASTATE_MATURE;

	return KErrNone;

	}

void CSecurityAssoc::Cleanup()

	/**

	* Release all memory resources attached to a SA.

	*/

	{

	iTimeout.Cancel();

	if (iInfo.iSrcIdentity)

		{

		iInfo.iSrcIdentity->Close();

		iInfo.iSrcIdentity = NULL;

		}

	if (iInfo.iDstIdentity)

		{

		iInfo.iDstIdentity->Close();

		iInfo.iDstIdentity = NULL;

		}

	iTS.Reset();

	delete iIV; iIV = NULL;

	// Detach all handles

	while (!iHandles.IsDetached())

		{

		RSecurityAssociation *handle = (RSecurityAssociation *)iHandles.iNext;

		ASSERT(handle->iAssociation == this);

		 /* Since the iAssociation was never set, so the iErrValue is set over here

	       * which will be used by sc_prt6.cpp to pass the error value

           * from the kmd to the tcp/ip stack

           */

		handle->SetError(iErrValue);

		handle->None();

		(handle->iCallback)(*handle);

		}

	delete iEeng; iEeng = NULL;

	delete iAeng; iAeng = NULL;

	delete iNatTraversal; iNatTraversal = NULL;

	}

CSecurityAssoc::~CSecurityAssoc()

	/**

	* Destructor.

	*/

	{

	Cleanup();

	}

TInt CSecurityAssoc::Close()

	/**

	* Decrement the reference count.

	*

	* @return

	*	@li KErrNone, if association still exists

	*	@li KErrDied, if association has been deleted.

	*/

	{

	if (--iRefs < 0)

		{

		delete this;

		return KErrDied;

		}

	return KErrNone;

	}

TBool RTrafficSelector::operator<=(const RTrafficSelector &aSel) const

	/**

	* The <= comparison for selector values.

	*

	* Every field must fullfull the "<="-condition individually for

	* this to return true. This operator should only be used to

	* compare individual packet values against a min and max

	* range:

	* @code min <= packetdata <= max

	* @endcode

	*

	* @param aSel The selector (packet or max). With 'packet', this = min, and

	* with 'max', this is 'packet'.

	*

	* @see CSecurityAssoc::Match

	*/

	{

	return

		iProtocol <= aSel.iProtocol &&

		iPortSrc <= aSel.iPortSrc &&

		iPortDst <= aSel.iPortDst &&

		iSrc() <= aSel.iSrc() &&

		iDst() <= aSel.iDst();

	}

// This is defined based on the assumption that RArray<>::Reset()/Close()

// does not run destructor on the array elements. Because RTrafficSelector

// holds handles for addresses, they must be closed before the actual

// RArray methods are called.

void RTrafficSelectorSet::Reset()

	{

	/**

	* Release Traffic Selector space