/*
* Copyright (c) 2004 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:   Implementation of the PKCS#12 parser API
*
*/


// INCLUDE FILES
#include <securityerr.h>
#include    "pkcs12.h"
#include    "crpkcs12.h"
//#include    <?include_file>

// EXTERNAL DATA STRUCTURES
//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  
//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

// ASN.1 tag values
const TInt KASN1SequenceTagValue = 0x30;
const TInt KASN1ImplicitConstructedTagValue = 0xA0;   // Implicit constructed tag
const TInt KASN1OctetStringTagValue   = 0x04;     // Octet string tag
const TInt KASN1BerConstructedBit = 0x20;

_LIT8(KPKCS12Version3, "\x02\x01\x03");
_LIT8(KPKCS7DataOID, "\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x07\x01");
_LIT8(KPKC7EncryptedDataOID, "\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x07\x06");
_LIT8(KSequenceTagInOctet,"\x04\x01\x30\x04\x01\x80");
_LIT8(KMozillaPKCS7EncryptedDataOID, 
    "\x04\x01\x06\x04\x01\x09\x04\x09\x2a\x86\x48\x86\xf7\x0d\x01\x07\x06");
_LIT8(KMozillaPKCS7DataOID, 
    "\x04\x01\x06\x04\x01\x09\x04\x09\x2a\x86\x48\x86\xf7\x0d\x01\x07\x01");

// MACROS
//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS
//const ?type ?constant_var = ?constant;
//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES
//enum ?declaration
//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES
//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS
//class ?FORWARD_CLASSNAME;

// ============================ MEMBER FUNCTIONS ===============================

// ---------------------------------------------------------
// PKCS12Factory::CreateL
// ---------------------------------------------------------
//
EXPORT_C MPKCS12* PKCS12Factory::CreateL()
    {
    return CPKCS12::NewL();
    }

// -----------------------------------------------------------------------------
// CPKCS12::CPKCS12
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPKCS12::CPKCS12()
    {
    }

// -----------------------------------------------------------------------------
// CPKCS12::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPKCS12::ConstructL()
    {        
    
    }

// -----------------------------------------------------------------------------
// CPKCS12::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPKCS12* CPKCS12::NewL()
    {
    CPKCS12* self = new( ELeave ) CPKCS12();
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

void CPKCS12::Release()
    {
    delete this;
    }

// ---------------------------------------------------------
// CPKCS12::IsPKCS12Data
// ---------------------------------------------------------
//    
TBool CPKCS12::IsPKCS12Data(const TDesC8& aBinaryData)
     {     
    // We don't decode the data because we may only have the first few bytes -
	// instead we check the ASN1 by hand.
	ASSERT(aBinaryData.Length() >= KPKCS12DataMinLength);
	TInt pos = 0;
	
	if (!IsASN1Tag(KASN1SequenceTagValue,aBinaryData, pos))
	    {
	    return EFalse;
	    }
	if (!IsExpectedData(aBinaryData, pos, KPKCS12Version3))
	    {
	    return EFalse;
	    }
    if (!IsASN1Tag(KASN1SequenceTagValue, aBinaryData, pos))
	    {
	    return EFalse;
	    } 
	if (!IsExpectedData(aBinaryData, pos, KPKCS7DataOID))
	    {
	    return EFalse;
	    } 
    if (!IsASN1Tag(KASN1ImplicitConstructedTagValue, aBinaryData, pos))
	    {
	    return EFalse;
	    } 
	// OpenSSL, IE and Opera type of PKCS#12 file    
    if (IsASN1Tag(KASN1OctetStringTagValue, aBinaryData, pos))
        {
        if (!IsASN1Tag(KASN1SequenceTagValue, aBinaryData, pos))
            {
            return EFalse;
            }
        if (!IsASN1Tag(KASN1SequenceTagValue, aBinaryData, pos))
            {
            return EFalse;
            }    
    	if  (IsExpectedData(aBinaryData, pos, KPKC7EncryptedDataOID) || 
    	     IsExpectedData(aBinaryData, pos, KPKCS7DataOID))    		
    	    {    	    
    	    return ETrue;
    	    }
    	else
    	    {
    	    return EFalse;
    	    }
        }
    // Netscape and Mozilla type of PKCS#12 file    
	else if (IsASN1Tag(KASN1OctetStringTagValue + KASN1BerConstructedBit, aBinaryData, pos))
	    {
	    if (IsExpectedData(aBinaryData, pos, KSequenceTagInOctet))
            {
            if (!IsExpectedData(aBinaryData, pos, KSequenceTagInOctet))
                {
                return EFalse;
                }    
        	if  (IsExpectedData(aBinaryData, pos, KMozillaPKCS7DataOID) ||
        		IsExpectedData(aBinaryData, pos, KMozillaPKCS7EncryptedDataOID))
        	    {    	    
        	    return ETrue;
        	    }
            }
        // Firefox version 1.5 type of PKCS#12 data    
        else if (IsASN1Tag(KASN1OctetStringTagValue, aBinaryData, pos))
            {
            if (!IsASN1Tag(KASN1SequenceTagValue, aBinaryData, pos))
                {
                return EFalse;
                }
            if (!IsASN1Tag(KASN1SequenceTagValue, aBinaryData, pos))
                {
                return EFalse;
                }    
    	    if (IsExpectedData(aBinaryData, pos, KPKC7EncryptedDataOID) || 
    	     IsExpectedData(aBinaryData, pos, KPKCS7DataOID))    		
    	        {    	    
    	        return ETrue;
    	        }
    	    else
    	        {
    	        return EFalse;
    	        }
            }
        else
            {
            return EFalse;
            }            
	    }
    else
        {            
        return EFalse;
        }
    return EFalse;    
    }
    
// ---------------------------------------------------------
// CPKCS12Recognizer::IsASN1Tag
// ---------------------------------------------------------
//  
TBool CPKCS12::IsASN1Tag(
    TInt aTag, 
    const TDesC8& aBinaryData, 
    TInt& aPos)
	{	
	// Check we have enough data
	if ((aPos + 2) >= aBinaryData.Length())
		{
		return EFalse;
		}
	// Check the outermost sequence is valid
	if (aBinaryData[aPos] != aTag)
		{
		return EFalse;
		}
	// Skip sequence length
	aPos++;
	TInt length0 = aBinaryData[aPos++];
	if (length0 & 0x80)
		{
		aPos += length0 & 0x7f;
		}
	return ETrue;
	}

// ---------------------------------------------------------
// CPKCS12Recognizer::IsExpectedData
// ---------------------------------------------------------
//  
TBool CPKCS12::IsExpectedData(
    const TDesC8& aBinaryData, 
    TInt& aPos, 
    const TDesC8& aExpectedData)
	{	
	TInt length = aExpectedData.Length();
	// Check we have enough data
	if (aPos + length >= aBinaryData.Length())
		{
		return EFalse;
		}
	// Check data matches	
	if (aBinaryData.Mid(aPos, length) != aExpectedData)
		{
		return EFalse;
		}
	aPos += length;
	return ETrue;
	}    

// -----------------------------------------------------------------------------
// CPKCS12::ParseL
// 
// -----------------------------------------------------------------------------
//
void CPKCS12::ParseL(const TDesC8& aPKCS12, const TDesC16& aPassword)
    {
    Reset();
    iCrPkcs12 = CCrPKCS12::NewL();
    iCrData = CCrData::NewL(EFalse);
    User::LeaveIfError(iCrData->Write(aPKCS12));
    TInt start = 0;
    iCrData->Seek( ESeekStart, start );
    HandleErrorL( iCrPkcs12->OpenL( *iCrData, aPassword ));
    }

// -----------------------------------------------------------------------------
// CPKCS12::HandleErrorL
// 
// -----------------------------------------------------------------------------
//
void CPKCS12::HandleErrorL( TUint16 aError ) const
    {

    switch ( aError & 0x00ff )
        {
        case KCrOK:
            return;
        case KCrNotValidPkcs12Object:
            User::Leave(KErrArgument);
        case KCrBerLibraryError:
            User::Leave(KErrGeneral);
        case KCrNotSupportedHMACalgorithm:
            User::Leave(KErrNotSupported);
        case KCrCancelled:
            User::Leave(KErrCancel);
        case KCrGeneralError:
            User::Leave(KErrGeneral);
        case KCrWrongPassWordOrCorruptedFile:
            User::Leave(KErrBadPassphrase);
        case KCrNotPasswordBasedEncryption:
            User::Leave(KErrNotSupported);
        case KCrNoMemory:
            User::Leave(KErrNoMemory);
        default:
            User::Leave(KErrGeneral);
        }
    }
    
// Destructor
CPKCS12::~CPKCS12()
    {
    Reset();
    }

// -----------------------------------------------------------------------------
// CPKCS12::Reset
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPKCS12::Reset()
    {
    if (iCrData)
        {        
        iCrData->Close();
        delete iCrData;
        iCrData = NULL;
        }    
    delete iCrPkcs12;
    iCrPkcs12 = NULL;
    }

// -----------------------------------------------------------------------------
// CPKCS12::CACertificates
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const CArrayPtr<CX509Certificate>& CPKCS12::CACertificates() const
    {
    return iCrPkcs12->CACertificates();
    }

// -----------------------------------------------------------------------------
// CPKCS12::UserCertificates
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const CArrayPtr<CX509Certificate>& CPKCS12::UserCertificates() const
    {    
    return iCrPkcs12->UserCertificates();
    }

// -----------------------------------------------------------------------------
// CPKCS12::PrivateKeys
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
const CArrayPtr<HBufC8>& CPKCS12::PrivateKeys() const
    {    
    return iCrPkcs12->PrivateKeys();
    }

// -----------------------------------------------------------------------------
// CPKCS12::SafeBagsCount
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TUint CPKCS12::SafeBagsCount() const
    {
    return iCrPkcs12->SafeBagsCount();
    }

// -----------------------------------------------------------------------------
// CPKCS12::IterCount
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//     
TUint CPKCS12::IterCount() const
    {
    return iCrPkcs12->Iter();
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================
                                                                                
// ---------------------------------------------------------
// E32Dll
// DLL entry point
// ---------------------------------------------------------
//
#ifndef EKA2
GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
    {
    return KErrNone;
    }
#endif

//  End of File