Symaptic: os/persistentdata/persistentstorage/store/UCRYPT/UE

     1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include "UE_STD.H"

    18 #include <pbe.h>

    20 #define PBEDATA_NO_EXPORTED_CONSTRUCTORS

    21 #include <pbedata.h>

    27 EXPORT_C void RDecryptStream::OpenL(RReadStream& aHost,const CPBEncryptionBase& aKey)

    28 /**

    29 Open a decrypting read stream to aHost.

    30 Prepares the source stream owned by the specified read stream interface object for

    31 reading through a decrypting filter.

    32 @publishedPartner

    33 @leave KErrNoMemory

    34 @param aHost The read stream interface object for the source stream.

    35 This function does not take ownership of the source stream.

    36 @param aKey A Password Based Encryption object for encryption handling.

    37 */

    38 	{

    39 	CPBDecryptor* decryptor = aKey.NewDecryptLC();

    40 	iFilter.SetL(aHost.Source(),decryptor,iFilter.ERead);

    41 	CleanupStack::Pop(decryptor);

    42 	RReadStream::Attach(&iFilter);

    43 	}

    45 EXPORT_C void RDecryptStream::OpenLC(RReadStream& aHost,const CPBEncryptionBase& aKey)

    46 /**

    47 Open a decrypting read stream to aHost.

    48 Prepares the source stream owned by the specified read stream interface object for

    49 reading through a decrypting filter, and puts a cleanup item onto the cleanup stack.

    50 @publishedPartner

    51 @leave KErrNoMemory

    52 @param aHost The read stream interface object for the source stream.

    53 This function does not take ownership of the source stream.

    54 @param aKey A Password Based Encryption object for encryption handling.

    55 */

    56 {

    57 	OpenL(aHost,aKey);

    58 	PushL();

    59 	}

    61 EXPORT_C void RDecryptStream::AttachL(RReadStream& aHost,const CPBEncryptionBase& aKey)

    62 /**

    63 Attach a decrypting read stream to aHost.

    64 Takes ownership of the source stream owned by the specified read stream interface object,

    65 and prepares the stream for reading through a decrypting filter.

    66 @publishedPartner

    67 @leave KErrNoMemory

    68 @param aHost The read stream interface object for the source stream.

    69 @param aKey A Password Based Encryption object for encryption handling.

    70 */	{

    71 	AttachLC(aHost,aKey);

    72 	CleanupStack::Pop();

    73 	}

    75 EXPORT_C void RDecryptStream::AttachLC(RReadStream& aHost,const CPBEncryptionBase& aKey)

    76 /**

    77 Attach a decrypting read stream to aHost.

    78 Takes ownership of the source stream owned by the specified read stream interface object,

    79 prepares the stream for reading through a decrypting filter, and puts a cleanup item onto the cleanup stack.

    80 @publishedPartner

    81 @leave KErrNoMemory

    82 @param aHost The read stream interface object for the source stream.

    83 @param aKey A Password Based Encryption object for encryption handling.

    84 */	{

    85 	MStreamBuf* host=aHost.Source();

    86 	aHost=RReadStream();

    87 	RReadStream::Attach(host);		// initial cleanup via this

    88 	PushL();

    90 	CPBDecryptor* decryptor = aKey.NewDecryptLC();

    91 	iFilter.SetL(host,decryptor,iFilter.ERead|iFilter.EAttached);

    92 	CleanupStack::Pop(decryptor);

    94 	RReadStream::Attach(&iFilter);

    95 	}

    97 //////////////////////////////////////////////////////////////////////////////

   103 EXPORT_C void REncryptStream::OpenL(RWriteStream& aHost,const CPBEncryptionBase& aKey)

   104 /**

   105 Open an encrypting write stream over aHost.

   106 Prepares the target stream owned by the specified write stream interface object for

   107 writing through an encrypting filter.

   108 @publishedPartner

   109 @leave KErrNoMemory

   110 @param aHost The write stream interface object for the target stream. The function does not take ownership of the target stream.

   111 @param aKey A Password Based Encryption object for encryption handling.

   112 */

   113 	{

   114 	CPBEncryptor* encryptor = aKey.NewEncryptLC();

   115 	iFilter.SetL(aHost.Sink(),encryptor,iFilter.EWrite);

   116 	CleanupStack::Pop(encryptor);

   117 	RWriteStream::Attach(&iFilter);

   118     }

   120 EXPORT_C void REncryptStream::OpenLC(RWriteStream& aHost,const CPBEncryptionBase& aKey)

   121 /**

   122 Open an encrypting write stream over aHost.

   123 Prepares the target stream owned by the specified write stream interface object for

   124 writing through an encrypting filter and puts a cleanup item onto the cleanup stack.

   125 @publishedPartner

   126 @leave KErrNoMemory

   127 @param aHost The write stream interface object for the target stream. The function does not take ownership of the target stream.

   128 @param aKey A Password Based Encryption object for encryption handling.

   129 */

   130 	{

   131 	OpenL(aHost,aKey);

   132 	PushL();

   133 	}

   135 EXPORT_C void REncryptStream::AttachL(RWriteStream& aHost,const CPBEncryptionBase& aKey)

   136 /**

   137 Attach an encrypting write stream to aHost.

   138 Takes ownership of the target stream owned by the specified write stream interface object,

   139 and prepares the stream for writing through an encrypting filter.

   140 @publishedPartner

   141 @leave KErrNoMemory

   142 @param aHost The write stream interface object for the target stream

   143 @param aKey A Password Based Encryption object for encryption handling.

   144 */

   145 	{

   146 	AttachLC(aHost,aKey);

   147 	CleanupStack::Pop();

   148 	}

   150 EXPORT_C void REncryptStream::AttachLC(RWriteStream& aHost,const CPBEncryptionBase& aKey)

   151 /**

   152 Attach an encrypting write stream to aHost.

   153 Takes ownership of the target stream owned by the specified write stream interface object,

   154 prepares the stream for writing through an encrypting filter, and puts a cleanup item onto the cleanup stack.

   155 @publishedPartner

   156 @leave KErrNoMemory

   157 @param aHost The write stream interface object for the target stream

   158 @param aKey A Password Based Encryption object for encryption handling.

   159 */

   160 	{

   161 	MStreamBuf* host=aHost.Sink();

   162 	aHost=RWriteStream();

   163 	RWriteStream::Attach(host);		// initial cleanup via this

   164 	PushL();

   166 	CPBEncryptor* encryptor = aKey.NewEncryptLC();

   167 	iFilter.SetL(host,encryptor,iFilter.EWrite|iFilter.EAttached);

   168 	CleanupStack::Pop(encryptor);

   170 	RWriteStream::Attach(&iFilter);

   171 	}

   173 /////////////////////////////////////////////////////////////////////////

   174 // PBE data methods that depend on store, prevents static dependency

   175 /////////////////////////////////////////////////////////////////////////

   177 // CPBEncryptionData

   179 // HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll

   180 // This method is DUPLICATED in common/generic/security/crypto/source/pbe/pbedata.cpp

   181 CPBEncryptionData::CPBEncryptionData(void)

   182 	{

   183 	}

   185 // HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll

   186 // This method is DUPLICATED in common/generic/security/crypto/source/pbe/pbedata.cpp

   187 CPBEncryptionData::~CPBEncryptionData(void)

   188 	{

   189 	delete iParms;

   190 	delete iAuth;

   191 	}

   193 EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(RReadStream& aStream)

   194 	{

   195 	CPBEncryptionData* self = NewLC(aStream);

   196 	CleanupStack::Pop(self);

   197 	return self;

   198 	}

   200 EXPORT_C CPBEncryptionData* CPBEncryptionData::NewLC(RReadStream& aStream)

   201 	{

   202 	CPBEncryptionData* self = new(ELeave)CPBEncryptionData();

   203 	CleanupStack::PushL(self);

   204 	self->ConstructL(aStream);

   205 	return self;

   206 	}

   208 void CPBEncryptionData::ConstructL(RReadStream& aStream)

   209 	{

   210 	iAuth = CPBAuthData::NewL(aStream);

   211 	iParms = CPBEncryptParms::NewL(aStream);

   212 	}

   214 EXPORT_C void CPBEncryptionData::ExternalizeL(RWriteStream& aStream) const

   215 	{

   216 	iAuth->ExternalizeL(aStream);

   217 	iParms->ExternalizeL(aStream);

   218 	}

   220 // CPBEncryptParms

   222 // HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll

   223 // This method is DUPLICATED in common/generic/security/crypto/source/pbe/pbedata.cpp

   224 CPBEncryptParms::CPBEncryptParms()

   225 	{

   226 	}

   228 // HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll

   229 // This method is DUPLICATED in common/generic/security/crypto/source/pbe/pbedata.cpp

   230 CPBEncryptParms::~CPBEncryptParms()

   231 	{

   232 #ifdef SYMBIAN_PKCS12

   233 	delete iData;

   234 #endif	// #ifdef SYMBIAN_PKCS12

   235 	delete iSalt;

   236 	delete iIV;

   237 	}

   239 EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL(RReadStream& aStream)

   240 	{

   241 	CPBEncryptParms* self = NewLC(aStream);

   242 	CleanupStack::Pop(self);

   243 	return self;

   244 	}

   246 EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC(RReadStream& aStream)

   247 	{

   248 	CPBEncryptParms* self = new(ELeave)CPBEncryptParms();

   249 	CleanupStack::PushL(self);

   250 	self->ConstructL(aStream);

   251 	return self;

   252 	}

   254 #ifdef SYMBIAN_PKCS12

   256 void CPBEncryptParms::ConstructL(RReadStream& aStream)

   257 	{

   258 	iData = new(ELeave) TParamsData;

   260 	TCardinality cipher;

   261 	aStream >> cipher;

   262 	TInt32 cipherInt32 = (TInt32) cipher;

   263 	iData->iCipher = (TPBECipher)(cipherInt32 & ~KBit16);

   265 	// if bit 16 of the stored cipher is set, then a KDF

   266 	// follows.  (This preserves data compatability.)

   267 	if ((cipherInt32 & KBit16) == 0)

   268 		iData->iKdf = EKdfPkcs5;

   269 	else

   270 		{

   271 		TInt32 kdf;

   272 		aStream >> kdf;

   273 		iData->iKdf = (TKdf) kdf;

   274 		}

   276 	iSalt = HBufC8::NewL(aStream, KMaxTInt);

   278 	TCardinality iterations;

   279 	aStream >> iterations;

   280 	iIterations = iterations;

   282 	iIV = HBufC8::NewL(aStream, KMaxTInt);

   283 	}

   285 #else

   287 void CPBEncryptParms::ConstructL(RReadStream& aStream)

   288 	{

   289 	TCardinality cipher;

   290 	aStream >> cipher;

   291 	iCipher = (TPBECipher)((TUint)(cipher));

   293 	iSalt = HBufC8::NewL(aStream, KMaxTInt);

   295 	TCardinality iterations;

   296 	aStream >> iterations;

   297 	iIterations = iterations;

   299 	iIV = HBufC8::NewL(aStream, KMaxTInt);

   300 	}

   302 #endif	// #else #ifdef SYMBIAN_PKCS12

   304 #ifdef SYMBIAN_PKCS12

   306 EXPORT_C void CPBEncryptParms::ExternalizeL(RWriteStream& aStream) const

   307 	{

   308 	TUint32 cipherInt32 = iData->iCipher;

   309 	if (iData->iKdf != EKdfPkcs5)

   310 		cipherInt32 |= KBit16;

   311 	aStream << TCardinality(cipherInt32);

   313 	if (iData->iKdf != EKdfPkcs5)

   314 		aStream << (TInt32) iData->iKdf;

   316 	aStream << *iSalt;

   317 	aStream << TCardinality(iIterations);

   318 	aStream << *iIV;

   319 	}

   321 #else

   323 EXPORT_C void CPBEncryptParms::ExternalizeL(RWriteStream& aStream) const

   324 	{

   325 	aStream << TCardinality((TUint)iCipher);

   326 	aStream << *iSalt;

   327 	aStream << TCardinality(iIterations);

   328 	aStream << *iIV;

   329 	}

   331 #endif	// #else #ifdef SYMBIAN_PKCS12

   333 // CPBAuthData

   335 // HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll

   336 // This method is DUPLICATED in common/generic/security/crypto/source/pbe/pbedata.cpp

   337 CPBAuthData::CPBAuthData()

   338 	{

   339 	}

   341 // HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll

   342 // This method is DUPLICATED in common/generic/security/crypto/source/pbe/pbedata.cpp

   343 CPBAuthData::~CPBAuthData()

   344 	{

   345 	delete iAuthKey;

   346 	delete iSalt;

   347 	}

   349 EXPORT_C CPBAuthData* CPBAuthData::NewL(RReadStream& aStream)

   350 	{

   351 	CPBAuthData* self = NewLC(aStream);

   352 	CleanupStack::Pop(self);

   353 	return self;

   354 	}

   356 EXPORT_C CPBAuthData* CPBAuthData::NewLC(RReadStream& aStream)

   357 	{

   358 	CPBAuthData* self = new(ELeave)CPBAuthData();

   359 	CleanupStack::PushL(self);

   360 	self->ConstructL(aStream);

   361 	return self;

   362 	}

   364 void CPBAuthData::ConstructL(RReadStream& aStream)

   365 	{

   366 	iAuthKey = HBufC8::NewL(aStream, KMaxTInt);

   367 	iSalt = HBufC8::NewL(aStream, KMaxTInt);

   368 	TCardinality iterations;

   369 	aStream >> iterations;

   370 	iIterations = iterations;

   371 	}

   373 EXPORT_C void CPBAuthData::ExternalizeL(RWriteStream& aStream) const

   374 	{

   375 	aStream << *iAuthKey;

   376 	aStream << *iSalt;

   377 	aStream << TCardinality(iIterations);

   378 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--