// Copyright (c) 2008-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:
//

#include "cpopsaslauthhelper.h"
#include <e32des8.h>
#include "POPS.PAN"   		// pop's panic codes

//string constants containing POP3 AUTH command
_LIT8(KPop3AuthCommand, "AUTH ");
_LIT8(KCramMD5Mechanism, "CRAM-MD5");
_LIT8(KPlainMechanism, "PLAIN ");
_LIT8(KPop3AuthLoginCommand, "AUTH LOGIN\r\n");
_LIT8(KPop3CrLf,"\r\n");

_LIT8(KPop3AuthBase64StringUsername,"username*"); // To match a folded 'username:' or 'username'
_LIT8(KPop3AuthBase64StringPassword,"password*"); // To match a folded 'password:' or 'password'

const TInt KMaxLengthOfPlainMessageComponent = 255;
const TInt KMd5BlockLength = 64;

#define BASE64LEN(x) ((x*4)/3) // Every 3 bytes will be turned into 4 bytes

const TInt KPreambleLength = 18; //"AUTH LOGIN\r\nPLAIN "
const TInt KMaxLengthOfPlainMessage=	KPreambleLength + 1/*NUL*/ + KMaxLengthOfPlainMessageComponent/*Username*/ + 1/*NUL*/ + KMaxLengthOfPlainMessageComponent/*Password*/ + 2/* /r/n */;
const TInt KMaxLengthOfPlainMessageBase64= BASE64LEN(KMaxLengthOfPlainMessage);


/**
Constructor for CPopAuthMechanismHelper
*/
CPopAuthMechanismHelper::CPopAuthMechanismHelper(const CImPop3Settings& aSettings) : iSettings(aSettings)
	{
	}

/** 
Allocates and constructs a CPopAuthCramMd5MechanismHelper object.
@param aSettings: Refence to CImPop3Settings 
@leave KErrNoMemory A memory allocation failed 
*/
CPopAuthCramMd5MechanismHelper* CPopAuthCramMd5MechanismHelper::NewL(const CImPop3Settings& aSettings)  
	{
	CPopAuthCramMd5MechanismHelper* self= new (ELeave) CPopAuthCramMd5MechanismHelper(aSettings);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();	                                
	return self;
	}

/**
Constructor for CPopAuthMechanismHelper
*/
CPopAuthCramMd5MechanismHelper::CPopAuthCramMd5MechanismHelper(const CImPop3Settings& aSettings) : CPopAuthMechanismHelper(aSettings)
	{
	}


/**
Second phase construction
*/
void CPopAuthCramMd5MechanismHelper::ConstructL()
	{
	iMd5Hash = CMD5::NewL();
	}

/**
Destructor
*/
CPopAuthCramMd5MechanismHelper::~CPopAuthCramMd5MechanismHelper()
	{
	delete iMd5Hash;
	}


/**
Function to form POP3 "AUTH CRAM-MD5" command and to handle base64 encoding of 
the challenges and responses as per RFC 2195
@param aNextMessage: contains response command
*/
void CPopAuthCramMd5MechanismHelper::GetNextClientMessageL(TDes8& aNextMessage)
	{
	iNextClientMessage.Zero();

	if(iInProgress)
		{
		HBufC8* authbuffer = HBufC8::NewMaxLC(KImMailMaxBufferSize); 
		TPtr8 authbufferptr = authbuffer->Des();
		HBufC8* authbuffer2 = HBufC8::NewMaxLC(KImMailMaxBufferSize);
		TPtr8 authbufferptr2 = authbuffer2->Des();
		HBufC8* authbuffer3 = HBufC8::NewMaxLC(KImMailMaxBufferSize);
		TPtr8 authbufferptr3 = authbuffer3->Des();
		
		authbufferptr = iLastServerMessage;
		// to remove "+ " from the begining of server response
		authbufferptr.Delete(0,2); 
		
		//timestamp info now in authbufferptr2
		iEncoder.Decode(authbufferptr,authbufferptr2);
		
		authbufferptr.Zero();
		authbufferptr3.Zero();
		authbufferptr = iSettings.Password();
		authbufferptr3 = FormSharedSecret(authbufferptr);
		authbufferptr.Zero();
		//now authbufferptr and authbufferptr3 contain the shared secret null padded to 64 bytes.
		authbufferptr = authbufferptr3;  
		
		TInt i=0;
		for (i=0; i<KMd5BlockLength; i++) 
			{
			authbufferptr[i] ^= 0x36; //ipad
			authbufferptr3[i] ^= 0x5c; //opad
			}

		authbufferptr.Append(authbufferptr2);

    	iMd5Hash->Reset();                                                                                                                                                                                                                                                                                                                ;
		authbufferptr2 = iMd5Hash->Hash(authbufferptr);

		authbufferptr3.Append(authbufferptr2);
		
		authbufferptr.Zero();
		iMd5Hash->Reset();
		authbufferptr = iMd5Hash->Hash(authbufferptr3);

		// MD5 algorithm ALWAYS returns 16 bytes of data - which will be converted into
		// 32 characters; each byte represented by a 2 character hex representation, 
		// eg 255="ff"
		TBuf<32> hexHash; 
		for (i=0;i<16;i++)
			{
			hexHash.AppendNumFixedWidth(authbufferptr[i],EHex,2);
			}

		authbufferptr3.Zero();
		authbufferptr3.Append(iSettings.LoginName());
		authbufferptr3.Append(_L8(" "));
		authbufferptr3.Append(hexHash);

		iEncoder.Encode(authbufferptr3, iNextClientMessage);
		iNextClientMessage.Append(KPop3CrLf);
		CleanupStack::PopAndDestroy(3);	// authbufferptr3 ,authbufferptr2, authbufferptr
		aNextMessage = iNextClientMessage;
		}
	else
		{
		iNextClientMessage.Append(KPop3AuthCommand);
		iNextClientMessage.Append(KCramMD5Mechanism);
		iNextClientMessage.Append(KPop3CrLf);
		iInProgress=ETrue;
		aNextMessage = iNextClientMessage;
		}
	}

/**
FormSharedSecret()
@param aPassword: password
*/
TPtr8 CPopAuthCramMd5MechanismHelper::FormSharedSecret(TPtr8 aPassword)
	{
	TPtr8 secret = aPassword;
	
	if (aPassword.Length() <= KMd5BlockLength)
		{
		//pad up to 64 bytes with zeros
		secret.SetLength(64);
		TInt origLen = aPassword.Length();
		TInt lengthToFill = KMd5BlockLength-aPassword.Length();
		for (TInt i = 0; i<lengthToFill; i++)
			{
			secret[origLen+i]=0x00;
			}
		}
	else
		{
		//make shared secret the Digest of the password
		secret.Zero();
		iMd5Hash->Reset();
		secret = (iMd5Hash->Hash(aPassword));
		}

	return secret;
	}


/**
To set the last message from server.
@param aPassword: password
*/
void CPopAuthCramMd5MechanismHelper::SetLastServerMessageL(const TDesC8& aLastMessage, TBool /*aIsMultiLineResponse*/)
	{
	iLastServerMessage.Set(aLastMessage);
	}


/**
Constructor
*/
CPopAuthPlainMechanismHelper::CPopAuthPlainMechanismHelper(const CImPop3Settings& aSettings) : CPopAuthMechanismHelper(aSettings)
	{
	}


/** 
Allocates and constructs a CPopAuthPlainMechanismHelper object.
@param aSettings: Refence to CImPop3Settings 
@leave KErrNoMemory A memory allocation failed 
*/
CPopAuthPlainMechanismHelper* CPopAuthPlainMechanismHelper::NewL(const CImPop3Settings& aSettings)  
	{
	CPopAuthPlainMechanismHelper* self= new (ELeave) CPopAuthPlainMechanismHelper(aSettings);
	return self;
	}

	
/**
Function to handle POP3 "AUTH PLIAN" mechanism.
Steps:
1. Get the LoginName from CImPop3Settings
2. Get the Password from CImPop3Settings
3. Add "LoginName","NUL Char" and "Password" in a Buffer
4. Convert the above buffer to BASE64
@param aNextMessage: Buffer contains BASE64 converted LoginName and Password.
*/
void CPopAuthPlainMechanismHelper::GetNextClientMessageL(TDes8& aNextMessage)
	{
	// Build up the un-encoded authorisation string in parts
 	HBufC8* authString = HBufC8::NewMaxLC(KMaxLengthOfPlainMessage); 
 	TPtr8 authStringPtr = authString->Des();

	TBuf8<1> nulChar;
	nulChar.SetLength(1);
	nulChar[0] = 0;
	authStringPtr = nulChar; // Start with the NUL

	TPtrC8 loginName = iSettings.LoginName();
	TInt length= Min(loginName.Length(),KMaxLengthOfPlainMessageComponent);
	authStringPtr.Append(loginName.Left(length));

	authStringPtr.Append(nulChar); // Separator between login and password

	length= Min(iSettings.Password().Length(), KMaxLengthOfPlainMessageComponent);
	authStringPtr.Append(iSettings.Password().Left(length));
 
	// Auth string is now built, encode it
	HBufC8* encodedBuf = HBufC8::NewMaxLC(KMaxLengthOfPlainMessageBase64); 
	TPtr8 encodedBufPtr = encodedBuf->Des();
 
	iEncoder.Encode(authStringPtr,encodedBufPtr);

	// Now build the message
	iNextClientMessage.Zero();
 	iNextClientMessage.Append(KPop3AuthCommand);
 	iNextClientMessage.Append(KPlainMechanism);
	iNextClientMessage.Append(encodedBufPtr);
 	iNextClientMessage.Append(KPop3CrLf);

 	aNextMessage = iNextClientMessage;

	CleanupStack::PopAndDestroy(2, authString); // encodedBuf, authString
	}

/**
To set the last message from server.
@param aPassword: password
*/
void CPopAuthPlainMechanismHelper::SetLastServerMessageL(const TDesC8& /*aLastMessage*/, TBool /*aIsMultiLineResponse*/)
	{
	//iLastServerMessage.Set(aLastMessage);
	}

/**
Constructor
*/
CPopAuthLoginMechanismHelper::CPopAuthLoginMechanismHelper(const CImPop3Settings& aSettings) : CPopAuthMechanismHelper(aSettings)
	{
	}

/** 
Allocates and constructs a CPopAuthLoginMechanismHelper object.
@param aSettings: Refence to CImPop3Settings 
@leave KErrNoMemory A memory allocation failed 
*/
CPopAuthLoginMechanismHelper* CPopAuthLoginMechanismHelper::NewL(const CImPop3Settings& aSettings)  
	{
	CPopAuthLoginMechanismHelper* self= new (ELeave) CPopAuthLoginMechanismHelper(aSettings);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();	                                
	return self;
	}

/**
Destructor
*/
CPopAuthLoginMechanismHelper::~CPopAuthLoginMechanismHelper()
	{
	delete iBase64LoginName;
	delete iBase64Password;
	}

/**
SecondPhase  construction
*/
void CPopAuthLoginMechanismHelper::ConstructL()
	{
	// length of LoginName in base 64 + 2 for CRLF
	TInt len=(((iSettings.LoginName().Length()/3)+1)*4)+2; 
	iBase64LoginName=HBufC8::NewL(len);
	TPtr8 authString(iBase64LoginName->Des());
	iEncoder.Encode(iSettings.LoginName(),authString);
	authString.Append(KPop3CrLf);
	
	// length of Password in base 64 + 2 for CRLF
	len=(((iSettings.Password().Length()/3)+1)*4)+2; 
	iBase64Password=HBufC8::NewL(len);
	authString.Set(iBase64Password->Des());
	iEncoder.Encode(iSettings.Password(),authString);
	authString.Append(KPop3CrLf);
	}


/**
Function to handle POP3 "AUTH LOGIN" mechanism.
@param aNextMessage: aNextMessage contains BASE64 converted LoginName/Password.
*/
void CPopAuthLoginMechanismHelper::GetNextClientMessageL(TDes8& aNextMessage)
	{
	iNextClientMessage.Zero();
	switch (iState)
		{
		case ESendingAuth:
			iNextClientMessage=KPop3AuthLoginCommand;
			break;
		case ESendingLoginName:
			iNextClientMessage=*iBase64LoginName;
			break;
		case ESendingPassword:
			iNextClientMessage=*iBase64Password;
			break;
		default:
			Panic(EPopInvalidState);
	        break;
		}
	aNextMessage=iNextClientMessage;
	}

void CPopAuthLoginMechanismHelper::SetLastServerMessageL(const TDesC8& aLastMessage, TBool /*aIsMultiLineResponse*/)
	{
	HBufC8* decodedMessage = NULL;
	TInt lastMessageLength = aLastMessage.Length();
    
    // Decode the POP response from the Base64 original
    if (lastMessageLength > 0)
        {
        decodedMessage = HBufC8::NewLC(lastMessageLength); // already on stack
        // Get pointer to response minus the "+ " at the start
        TPtrC8 response = aLastMessage.Right(lastMessageLength - 2);
        TPtr8  destination = decodedMessage->Des();
        iEncoder.Decode(response, destination);
        }
	switch (iState)
		{
		case ESendingAuth:
            if (decodedMessage)
                {
                // Match against 'username*'
                if (decodedMessage->Des().MatchF(KPop3AuthBase64StringUsername) == KErrNotFound)
					{
                    User::Leave(KErrNotSupported);
					}
				iEncoder.Initialise();
                iState = ESendingLoginName;
                }
            else
                {
				User::Leave(KErrNotSupported);
				}
			break;
		case ESendingLoginName:
			if (decodedMessage)
                {
                // Match against 'password*'
                if (decodedMessage->Des().MatchF(KPop3AuthBase64StringPassword) == KErrNotFound)
					{
                    User::Leave(KErrNotSupported);
					}
				iEncoder.Initialise();
                iState = ESendingPassword;
                }
			else
                {
				User::Leave(KErrNotSupported);
				}
			break;
		case ESendingPassword: 
		default:
			User::Leave(KErrNotSupported);
			break;
		}
		
	if (decodedMessage)
		{
		CleanupStack::PopAndDestroy(decodedMessage);
		}
	}