cryptoservices/filebasedcertificateandkeystores/source/shared/TokenDataMarshaller.cpp
Move the Security package to EPL, and add the implementations of the cryptographic algorithms
/*
* Copyright (c) 2004-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 "fsmarshaller.h"
#include "fsdatatypes.h"
#include "NullStream.h"
#include <asymmetric.h>
#include <bigint.h>
#include <pbedata.h>
#include <s32mem.h>
#include <certificateapps.h>
#include <ccertattributefilter.h>
// Generic externalization stuff ///////////////////////////////////////////////
/**
* Determine how many bytes are taked up by the externalized representation of
* an object.
*/
template <class T>
TInt Size(const T& aObject)
{
RNullWriteStream stream;
TRAPD(err, stream << aObject);
if(err != KErrNone)
{
_LIT(KPanicCategory, "InValid Size");
User::Panic(KPanicCategory,ESerialisationPanic);
}
stream.Close();
return stream.BytesWritten();
}
/**
* Externalize an object to a buffer. Leaves if an error occurs.
*/
template <class T>
void WriteL(const T& aIn, TDes8& aOut)
{
RDesWriteStream stream(aOut);
stream << aIn;
stream.Close();
}
/**
* Externalize an object to a buffer. In debug mode, it will panics if an error
* occurs - eg buffer is too short. In release mode, errors are ignored.
*/
template <class T>
void Write(const T& aIn, TDes8& aOut)
{
TRAPD(err, WriteL(aIn, aOut));
if(err != KErrNone)
{
_LIT(KPanicCategory, "Writing Error");
User::Panic(KPanicCategory,ESerialisationPanic);
}
}
/**
* Implement Externalization selector for RPointerArrays to use a function.
*/
template <class T>
EXTERNALIZE_FUNCTION(RPointerArray<T>)
/**
* Function to externalize RPointerArrays.
*
* Although this is generic, it's currently only instantiated for CKeyInfo.
*/
template <class T>
void ExternalizeL(const RPointerArray<T>& aIn, RWriteStream& aOut)
{
TInt count = aIn.Count();
aOut.WriteInt32L(count);
for (TInt i = 0 ; i < count ; ++i)
{
T* object = aIn[i];
if (object == NULL)
{
User::Leave(KErrArgument);
}
aOut << *object;
}
}
/**
* Implement Externalization selector for RArrays to use a function.
*/
template <class T>
EXTERNALIZE_FUNCTION(RArray<T>)
/**
* Function to externalize RArrays.
*/
template <class T>
void ExternalizeL(const RArray<T>& aIn, RWriteStream& aOut)
{
TInt count = aIn.Count();
aOut.WriteInt32L(count);
for (TInt i = 0 ; i < count ; ++i)
{
aOut << aIn[i];
}
}
// No-so-generic internalization stuff /////////////////////////////////////////
/**
* Internalize an object from a descriptor.
*/
template <class T>
void ReadL(const TDesC8& aIn, T& aOut)
{
RDesReadStream stream(aIn);
stream >> aOut;
stream.Close();
}
/**
* Implement Internalization selector for RArrays to use a function.
*/
template <class T>
inline Internalize::Function Internalization(const RArray<T>*)
{
return Internalize::Function();
}
/**
* Function to internalize an RArray.
*/
template <class T>
void InternalizeL(RArray<T>& aOut, RReadStream& aIn)
{
ASSERT(aOut.Count() == 0);
TInt count = aIn.ReadInt32L();
for (TInt i = 0 ; i < count ; ++i)
{
T t;
aIn >> t;
User::LeaveIfError(aOut.Append(t));
}
}
/**
* Internalize an object from a stream. Creates an instance by calling the
* class' NewL(RReadStream&) method.
*/
template <class T>
inline void CreateL(RReadStream& aIn, T*& aOut)
{
aOut = T::NewL(aIn);
}
/**
* Internalize an object from a descriptor.
*/
template <class T>
void CreateL(const TDesC8& aIn, T& aOut)
{
RDesReadStream stream(aIn);
CreateL(stream, aOut);
stream.Close();
}
/**
* Internalize an object from a descriptor leaving the result on the cleanup
* stack. This is generic, but is only instantiated for RInteger.
*/
template <class T>
void CreateLC(const TDesC8& aIn, T& aOut)
{
RDesReadStream stream(aIn);
CreateLC(stream, aOut);
stream.Close();
}
/**
* Internalize a cryptotokens object from a descriptor.
*/
template <class T>
void CreateL(const TDesC8& aIn, MCTToken& aToken, T& aOut)
{
RDesReadStream stream(aIn);
CreateL(stream, aToken, aOut);
stream.Close();
}
/**
* Internalize a cryptotoken object from a stream. Creates an instance by
* calling the class' NewL(RReadStream&, MCTToken&) method.
*/
template <class T>
inline void CreateL(RReadStream& aIn, MCTToken& aToken, T*& aOut)
{
aOut = T::NewL(aIn, aToken);
}
/**
* Internalize an array of of key info objects from a stream.
*/
void CreateL(RReadStream& aIn, MCTToken& aToken, MKeyInfoArray& aOut)
{
TInt count = aIn.ReadInt32L();
for (TInt i = 0 ; i < count ; ++i)
{
CCTKeyInfo* t;
CreateL(aIn, aToken, t);
CleanupReleasePushL(*t);
User::LeaveIfError(aOut.Append(t));
CleanupStack::Pop();
}
}
// can we combine this with the one above?
/**
* Internalize an RMPointerArray of cryptotoken objects from a stream.
*/
template <class T>
void CreateL(RReadStream& aIn, MCTToken& aToken, RMPointerArray<T>& aOut)
{
TInt count = aIn.ReadInt32L();
for (TInt i = 0 ; i < count ; ++i)
{
T* t;
CreateL(aIn, aToken, t);
CleanupReleasePushL(*t);
User::LeaveIfError(aOut.Append(t));
CleanupStack::Pop();
}
}
// Serialization for RIntegers /////////////////////////////////////////////////
// This is exported as it is useful itself in the server
/**
* Implement a CreateL function for internalizing HBufC8s.
*/
inline void CreateL(RReadStream& aIn, HBufC8*& aOut)
{
aOut = HBufC8::NewL(aIn, KMaxIntegerSize);
}
/**
* Implement a CreateLC function for internalizing RIntegers.
*/
EXPORT_C void CreateLC(RReadStream& aIn, RInteger& aOut)
{
HBufC8* rBuf;
CreateL(aIn, rBuf);
CleanupStack::PushL(rBuf);
TPtr8 rPtr(rBuf->Des());
aOut = RInteger::NewL(rPtr);
CleanupStack::PopAndDestroy(rBuf);
CleanupStack::PushL(aOut);
}
/**
* Externalize an RInteger.
*/
EXPORT_C void ExternalizeL(const TInteger& aIn, RWriteStream& aOut)
{
HBufC8* sBuf = aIn.BufferLC();
aOut << *sBuf;
CleanupStack::PopAndDestroy(sBuf);
}
// Externalization for signature objects ///////////////////////////////////////
/**
* Implement Externalization selector for CDSASignature to use a function.
*/
EXTERNALIZE_FUNCTION(CDSASignature)
/**
* Externalise a DSA signature object.
*/
void ExternalizeL(const CDSASignature& aIn, RWriteStream& aOut)
{
aOut << aIn.R();
aOut << aIn.S();
}
/**
* Implement Externalization selector for CRSASignature to use a function.
*/
EXTERNALIZE_FUNCTION(CRSASignature)
/**
* Externalize an RSA signature object.
*/
void ExternalizeL(const CRSASignature& aIn, RWriteStream& aOut)
{
aOut << aIn.S();
}
// Internalization for signature objects ///////////////////////////////////////
/**
* Specialise CreateL for CRSASignature.
*/
template <>
void CreateL(RReadStream& aIn, CRSASignature*& aOut)
{
RInteger r;
CreateLC(aIn, r);
aOut = CRSASignature::NewL(r);
CleanupStack::Pop(); // r
}
/**
* Specialise CreateL for CDSASignature.
*/
template <>
void CreateL(RReadStream& aIn, CDSASignature*& aOut)
{
RInteger r;
CreateLC(aIn, r);
RInteger s;
CreateLC(aIn, s);
aOut = CDSASignature::NewL(r, s);
CleanupStack::Pop(2); // s, r
}
// Serialization for DH ojects /////////////////////////////////////////////////
/**
* Implement Externalization selector for CDHParams to use a function.
*/
EXTERNALIZE_FUNCTION(CDHParams)
/**
* Externalise a TDHParams object.
*/
void ExternalizeL(const CDHParams& aIn, RWriteStream& aOut)
{
aOut << aIn.N();
aOut << aIn.G();
}
/**
* Specialise CreateL for CDHParams.
*/
template <>
void CreateL(RReadStream& aIn, CDHParams*& aOut)
{
RInteger n;
CreateLC(aIn, n);
RInteger g;
CreateLC(aIn, g);
aOut = CDHParams::NewL(n, g);
CleanupStack::PopAndDestroy(2, &n); // g, n
}
/**
* Implement Externalization selector for CDHPublicKey to use a function.
*/
EXTERNALIZE_FUNCTION(CDHPublicKey)
/**
* Externalise a CDHPublicKey object.
*/
void ExternalizeL(const CDHPublicKey& aIn, RWriteStream& aOut)
{
aOut << aIn.N();
aOut << aIn.G();
aOut << aIn.X();
}
/**
* Specialise CreateL for CDHPublicKey.
*/
template <>
void CreateL(RReadStream& aIn, CDHPublicKey*& aOut)
{
RInteger n;
CreateLC(aIn, n);
RInteger g;
CreateLC(aIn, g);
RInteger X;
CreateLC(aIn, X);
aOut = CDHPublicKey::NewL(n, g, X);
CleanupStack::Pop(3); // X, g, n
}
// Common //////////////////////////////////////////////////////////////////////
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TUid>& aOut)
{
::ReadL(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const CKeyInfoBase& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::Write(const CKeyInfoBase& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TUid>& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::Write(const RArray<TUid>& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const MCertInfo& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::Write(const MCertInfo& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
// Client //////////////////////////////////////////////////////////////////////
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, MKeyInfoArray& aOut)
{
::CreateL(aIn, aToken, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTKeyInfo*& aOut)
{
::CreateL(aIn, aToken, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDSASignature*& aOut)
{
::CreateL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CRSASignature*& aOut)
{
::CreateL(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const CDHParams& aIn)
{
return Size(aIn.N()) + Size(aIn.G());
}
EXPORT_C void TokenDataMarshaller::WriteL(const CDHParams& aIn, TDes8& aOut)
{
::WriteL(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const CDHPublicKey& aIn)
{
return Size(aIn.N()) + Size(aIn.G()) + Size(aIn.X());
}
EXPORT_C void TokenDataMarshaller::WriteL(const CDHPublicKey& aIn, TDes8& aOut)
{
::WriteL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RInteger& aInteger)
{
::CreateLC(aIn, aInteger);
CleanupStack::Pop();
}
EXPORT_C TInt TokenDataMarshaller::Size(const CPBEncryptParms& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::Write(const CPBEncryptParms& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, RMPointerArray<CCTCertInfo>& aOut)
{
::CreateL(aIn, aToken, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, MCTToken& aToken, CCTCertInfo*& aOut)
{
::CreateL(aIn, aToken, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, RArray<TCertificateAppInfo>& aOut)
{
::ReadL(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const CCertAttributeFilter& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::WriteL(const CCertAttributeFilter& aIn, TDes8& aOut)
{
::WriteL(aIn, aOut);
}
// Server //////////////////////////////////////////////////////////////////////
EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CKeyInfo>& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CPBEncryptParms*& aOut)
{
::CreateL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CKeyInfo>& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CKeyInfo*& aOut)
{
::CreateL(aIn, aOut);
}
/**
* Determine the size of an externalized big integer. This assumes that the
* size of the buffer returned by TInteger::BufferLC() is the same as the size
* of the integer as returned by TInteger::ByteCount(). This is done to avoid
* allocating the buffer just so we can tell how big it is.
*/
EXPORT_C TInt TokenDataMarshaller::Size(const TInteger& aIn)
{
// This is an overestimate as the length is encoded with a TCardinality
return sizeof(TInt32) + aIn.ByteCount();
}
EXPORT_C TInt TokenDataMarshaller::Size(const CDSASignature& aIn)
{
return Size(aIn.R()) + Size(aIn.S());
}
EXPORT_C void TokenDataMarshaller::WriteL(const CDSASignature& aIn, TDes8& aOut)
{
::WriteL(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const CRSASignature& aIn)
{
return Size(aIn.S());
}
EXPORT_C void TokenDataMarshaller::WriteL(const CRSASignature& aIn, TDes8& aOut)
{
::WriteL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHParams*& aOut)
{
::CreateL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CDHPublicKey*& aOut)
{
::CreateL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::WriteL(const TInteger& aIn, TDes8& aOut)
{
::WriteL(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertInfo*& aOut)
{
::CreateL(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const RPointerArray<CCertInfo>& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::Write(const RPointerArray<CCertInfo>& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
EXPORT_C TInt TokenDataMarshaller::Size(const RArray<TCertificateAppInfo>& aIn)
{
return ::Size(aIn);
}
EXPORT_C void TokenDataMarshaller::Write(const RArray<TCertificateAppInfo>& aIn, TDes8& aOut)
{
::Write(aIn, aOut);
}
EXPORT_C void TokenDataMarshaller::ReadL(const TDesC8& aIn, CCertAttributeFilter*& aOut)
{
::CreateL(aIn, aOut);
}