/*
* Copyright (c) 2006 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 DevCertKeyStreamUtils
*
*/


#include <asymmetrickeys.h>
#include "DevCertKeyStreamUtils.h"
#include "DevCertKeyEncryptor.h"

// ======== GLOBAL FUNCTIONS ========

// ---------------------------------------------------------------------------
// ExternalizeL()
// RSA Public Key
// ---------------------------------------------------------------------------
//
void ExternalizeL(const CRSAPublicKey& aKey, RWriteStream& aStream)
    {
    aStream << aKey.N() << aKey.E();
    }


// ---------------------------------------------------------------------------
// ExternalizeL()
// RSA Private Key
// ---------------------------------------------------------------------------
//
void ExternalizeL(const CRSAPrivateKey& aData, RWriteStream& aStream)
    {
    CDevCertKeyEncryptor* encryptor = CDevCertKeyEncryptor::NewLC();
    if( encryptor->IsPluginExistL() )
        {
        MKeyEncryptor* encrypt = encryptor->CreateImplementationL();  

        //aStream << aData.N();
        EncryptAndStoreL(aData.N(), aStream, encrypt );

        // Check the incoming RSA private key (standard or CRT) 
        TRSAPrivateKeyType keyType = aData.PrivateKeyType();
        aStream.WriteInt32L((TInt32)keyType);

        if (EStandard==keyType)
            {
            const CRSAPrivateKeyStandard& key = static_cast<const CRSAPrivateKeyStandard&>(aData);
            //aStream << key.D();
            EncryptAndStoreL(key.D(), aStream, encrypt );
            }
        else if (EStandardCRT==keyType)
            {
            const CRSAPrivateKeyCRT& key = static_cast<const CRSAPrivateKeyCRT&>(aData);
            //aStream << key.P() << key.Q() << key.DP() << key.DQ() << key.QInv();
            EncryptAndStoreL(key.P(), aStream, encrypt );
            EncryptAndStoreL(key.Q(), aStream, encrypt );
            EncryptAndStoreL(key.DP(), aStream, encrypt );
            EncryptAndStoreL(key.DQ(), aStream, encrypt );
            EncryptAndStoreL(key.QInv(), aStream, encrypt );
            }
        else
            { 
            User::Leave(KErrNotSupported);
            }   
        }
    else
        {
        aStream << aData.N();

        // Check the incoming RSA private key (standard or CRT) 
        TRSAPrivateKeyType keyType = aData.PrivateKeyType();
        aStream.WriteInt32L((TInt32)keyType);

        if (EStandard==keyType)
            {
            const CRSAPrivateKeyStandard& key = static_cast<const CRSAPrivateKeyStandard&>(aData);
            aStream << key.D();
            }
        else if (EStandardCRT==keyType)
            {
            const CRSAPrivateKeyCRT& key = static_cast<const CRSAPrivateKeyCRT&>(aData);
            aStream << key.P() << key.Q() << key.DP() << key.DQ() << key.QInv();
            }
        else
            { 
            User::Leave(KErrNotSupported);
            }
        } 
    CleanupStack::PopAndDestroy( encryptor );        
    }


// ---------------------------------------------------------------------------
// ExternalizeL()
// DSA Public Key
// ---------------------------------------------------------------------------
//
void ExternalizeL(const CDSAPublicKey& aKey, RWriteStream& aStream)
    {
    aStream << aKey.P() << aKey.Q() << aKey.G() << aKey.Y();
    }


// ---------------------------------------------------------------------------
// ExternalizeL()
// DSA Private Key
// ---------------------------------------------------------------------------
//
void ExternalizeL(const CDSAPrivateKey& aKey, RWriteStream& aStream)
    {
    CDevCertKeyEncryptor* encryptor = CDevCertKeyEncryptor::NewLC();
    if( encryptor->IsPluginExistL() )
        {
        MKeyEncryptor* encrypt = encryptor->CreateImplementationL();  
        //aStream << aKey.P() << aKey.Q() << aKey.G() << aKey.X();
        EncryptAndStoreL(aKey.P(), aStream, encrypt );
        EncryptAndStoreL(aKey.Q(), aStream, encrypt );
        EncryptAndStoreL(aKey.G(), aStream, encrypt );
        EncryptAndStoreL(aKey.X(), aStream, encrypt );
        }
    else
        {
        aStream << aKey.P() << aKey.Q() << aKey.G() << aKey.X();  
        }
    CleanupStack::PopAndDestroy(encryptor);        
    }


// ---------------------------------------------------------------------------
// CreateL()
// RSA Public key
// ---------------------------------------------------------------------------
//
void CreateL(RReadStream& aStream, CRSAPublicKey*& aOut)
    {
    RInteger N, keyPublicExp;
    CreateLC(aStream, N);
    CreateLC(aStream, keyPublicExp);

    aOut = CRSAPublicKey::NewL(N, keyPublicExp);

    CleanupStack::Pop(2, &N); // keyPublicExp, N
    }


// ---------------------------------------------------------------------------
// CreateL()
// RSA Private key
// ---------------------------------------------------------------------------
//
void CreateL(RReadStream& aStream, CRSAPrivateKey*& aOut)
    {
    CDevCertKeyEncryptor* encryptor = CDevCertKeyEncryptor::NewLC();
    if( encryptor->IsPluginExistL() )
        {
        MKeyEncryptor* encrypt = encryptor->CreateImplementationL();

        RInteger privateN;
        DecryptAndCreateLC(aStream, privateN, encrypt);

        TRSAPrivateKeyType keyType = EStandard;
        keyType = (TRSAPrivateKeyType)aStream.ReadInt32L();

        if (EStandard==keyType)
            {
            RInteger D;
            DecryptAndCreateLC(aStream, D, encrypt);

            aOut = CRSAPrivateKeyStandard::NewL(privateN, D);

            CleanupStack::Pop(&D);
            }
        else if (EStandardCRT==keyType)
            {
            RInteger p, q, dP, dQ, qInv;
            DecryptAndCreateLC(aStream, p, encrypt);
            DecryptAndCreateLC(aStream, q, encrypt);
            DecryptAndCreateLC(aStream, dP, encrypt);
            DecryptAndCreateLC(aStream, dQ, encrypt);
            DecryptAndCreateLC(aStream, qInv, encrypt);

            aOut = CRSAPrivateKeyCRT::NewL(privateN, p, q, dP, dQ, qInv);

            CleanupStack::Pop(5, &p);
            }
        else
            {
            User::Leave(KErrNotSupported);
            }

        CleanupStack::Pop(&privateN);
        }
    else
        {
        RInteger privateN;
        CreateLC(aStream, privateN);

        TRSAPrivateKeyType keyType = EStandard;
        keyType = (TRSAPrivateKeyType)aStream.ReadInt32L();

        if (EStandard==keyType)
            {
            RInteger D;
            CreateLC(aStream, D);

            aOut = CRSAPrivateKeyStandard::NewL(privateN, D);

            CleanupStack::Pop(&D);
            }
        else if (EStandardCRT==keyType)
            {
            RInteger p, q, dP, dQ, qInv;
            CreateLC(aStream, p);
            CreateLC(aStream, q);
            CreateLC(aStream, dP);
            CreateLC(aStream, dQ);
            CreateLC(aStream, qInv);

            aOut = CRSAPrivateKeyCRT::NewL(privateN, p, q, dP, dQ, qInv);

            CleanupStack::Pop(5, &p);
            }
        else
            {
            User::Leave(KErrNotSupported);
            }

        CleanupStack::Pop(&privateN); 
        } 
    CleanupStack::PopAndDestroy(encryptor);       
    }


// ---------------------------------------------------------------------------
// CreateL()
// DSA Public key
// ---------------------------------------------------------------------------
//
void CreateL(RReadStream& aStream, CDSAPublicKey*& aOut)
    {
    RInteger P, Q, G, Y;
    CreateLC(aStream, P);
    CreateLC(aStream, Q);
    CreateLC(aStream, G);
    CreateLC(aStream, Y);

    aOut = CDSAPublicKey::NewL(P, Q, G, Y);

    CleanupStack::Pop(4, &P);
    }


// ---------------------------------------------------------------------------
// CreateL()
// DSA Private key
// ---------------------------------------------------------------------------
//
void CreateL(RReadStream& aStream, CDSAPrivateKey*& aOut)
    {
    CDevCertKeyEncryptor* encryptor = CDevCertKeyEncryptor::NewLC();
    if( encryptor->IsPluginExistL() )
        {
        MKeyEncryptor* encrypt = encryptor->CreateImplementationL();
        RInteger P, Q, G, X;
        DecryptAndCreateLC(aStream, P, encrypt);
        DecryptAndCreateLC(aStream, Q, encrypt);
        DecryptAndCreateLC(aStream, G, encrypt);
        DecryptAndCreateLC(aStream, X, encrypt);

        aOut = CDSAPrivateKey::NewL(P, Q, G, X);

        CleanupStack::Pop(4, &P);
        }
    else
        {
        RInteger P, Q, G, X;
        CreateLC(aStream, P);
        CreateLC(aStream, Q);
        CreateLC(aStream, G);
        CreateLC(aStream, X);

        aOut = CDSAPrivateKey::NewL(P, Q, G, X);

        CleanupStack::Pop(4, &P); 
        }
    CleanupStack::PopAndDestroy(encryptor);        
    }

//EOF