Revision: 200945
authorMikko Sunikka <mikko.sunikka@nokia.com>
Fri, 06 Nov 2009 13:21:00 +0200
changeset 19 cd501b96611d
parent 15 da2ae96f639b
child 20 1afc808f187d
child 29 ece3df019add
Revision: 200945 Kit: 200945
authorisation/userpromptservice/group/bld.inf
contentmgmt/cafrecogniserconfig/ABLD.BAT
contentmgmt/contentaccessfwfordrm/group/bld.inf
contentmgmt/contentaccessfwfordrm/group/tcaf.mmp
contentmgmt/contentaccessfwfordrm/group/testagent.mmp
contentmgmt/referencedrmagent/RefTestAgent/RefTestAgent/Reftestagentmanager.cpp
contentmgmt/referencedrmagent/RefTestAgent/group/ABLD.BAT
contentmgmt/referencedrmagent/RefTestAgent/group/reftestagent.mmp
contentmgmt/referencedrmagent/RefTestAgent/group/sraclient.mmp
contentmgmt/referencedrmagent/RefTestAgent/group/sraplugin.mmp
contentmgmt/referencedrmagent/RefTestAgent/group/sraserver.mmp
contentmgmt/referencedrmagent/RefTestAgent/group/srautils.mmp
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sraclient.h
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sracommon.h
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sraserver.h
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/srautils.h
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/client/sraclient.cpp
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/server/sraserver.cpp
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/server/srasession.cpp
contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/utils/srautils.cpp
contentmgmt/referencedrmagent/TestAgent/testagentmanager.cpp
contentmgmt/referencedrmagent/tcaf/source/SupplierStep.cpp
contentmgmt/referencedrmagent/tcaf/source/SupplierStep.h
contentmgmt/referencedrmagent/tcaf/source/cafserver.cpp
crypto/weakcryptospi/group/ABLD.BAT
crypto/weakcryptospi/group/bld.inf
crypto/weakcryptospi/group/randsvr.mmp
crypto/weakcryptospi/inc/randsvr.h
crypto/weakcryptospi/source/asymmetric/asymmetric.cpp
crypto/weakcryptospi/source/asymmetric/dh.cpp
crypto/weakcryptospi/source/asymmetric/dhkeypairshim.cpp
crypto/weakcryptospi/source/asymmetric/dhkeypairshim.h
crypto/weakcryptospi/source/asymmetric/dhkeys.cpp
crypto/weakcryptospi/source/asymmetric/dsakeypairshim.cpp
crypto/weakcryptospi/source/asymmetric/dsakeypairshim.h
crypto/weakcryptospi/source/asymmetric/dsakeys.cpp
crypto/weakcryptospi/source/asymmetric/dsashim.cpp
crypto/weakcryptospi/source/asymmetric/dsashim.h
crypto/weakcryptospi/source/asymmetric/dsasigner.cpp
crypto/weakcryptospi/source/asymmetric/dsaverifier.cpp
crypto/weakcryptospi/source/asymmetric/rsadecryptor.cpp
crypto/weakcryptospi/source/asymmetric/rsaencryptor.cpp
crypto/weakcryptospi/source/asymmetric/rsakeypairshim.cpp
crypto/weakcryptospi/source/asymmetric/rsakeypairshim.h
crypto/weakcryptospi/source/asymmetric/rsakeys.cpp
crypto/weakcryptospi/source/asymmetric/rsashim.cpp
crypto/weakcryptospi/source/asymmetric/rsashim.h
crypto/weakcryptospi/source/asymmetric/rsasigner.cpp
crypto/weakcryptospi/source/asymmetric/rsaverifier.cpp
crypto/weakcryptospi/source/bigint/algorithms.cpp
crypto/weakcryptospi/source/bigint/algorithms.h
crypto/weakcryptospi/source/bigint/bigint.cpp
crypto/weakcryptospi/source/bigint/gcchelp.cpp
crypto/weakcryptospi/source/bigint/mont.cpp
crypto/weakcryptospi/source/bigint/mont.h
crypto/weakcryptospi/source/bigint/primes.cpp
crypto/weakcryptospi/source/bigint/primes.h
crypto/weakcryptospi/source/bigint/rinteger.cpp
crypto/weakcryptospi/source/bigint/stackinteger.h
crypto/weakcryptospi/source/bigint/vchelp.cpp
crypto/weakcryptospi/source/bigint/windowslider.cpp
crypto/weakcryptospi/source/bigint/windowslider.h
crypto/weakcryptospi/source/bigint/words.h
crypto/weakcryptospi/source/common/cryptostrength.cpp
crypto/weakcryptospi/source/common/inlines.h
crypto/weakcryptospi/source/common/keyconverter.cpp
crypto/weakcryptospi/source/common/keyidentifierutil.cpp
crypto/weakcryptospi/source/cryptoswitch/cryptography_stubs.h
crypto/weakcryptospi/source/cryptoswitch/cryptoswitch.cpp
crypto/weakcryptospi/source/hash/hash.cpp
crypto/weakcryptospi/source/hash/hashshim.cpp
crypto/weakcryptospi/source/hash/hashshim.h
crypto/weakcryptospi/source/hash/hmac.cpp
crypto/weakcryptospi/source/hash/md2.cpp
crypto/weakcryptospi/source/hash/md4.cpp
crypto/weakcryptospi/source/hash/md5.cpp
crypto/weakcryptospi/source/hash/sha1.cpp
crypto/weakcryptospi/source/hash/sha2.cpp
crypto/weakcryptospi/source/padding/padding.cpp
crypto/weakcryptospi/source/padding/paddingshim.cpp
crypto/weakcryptospi/source/padding/paddingshim.h
crypto/weakcryptospi/source/padding/pkcs7.cpp
crypto/weakcryptospi/source/pbe/pbe.cpp
crypto/weakcryptospi/source/pbe/pbedata.cpp
crypto/weakcryptospi/source/pbe/pbefactory.cpp
crypto/weakcryptospi/source/pbe/pbencryptor.cpp
crypto/weakcryptospi/source/pbe/pbencryptorset.cpp
crypto/weakcryptospi/source/pbe/pbeset.cpp
crypto/weakcryptospi/source/pbe/pbesymmetricfactory.cpp
crypto/weakcryptospi/source/pbe/pbesymmetricfactory.h
crypto/weakcryptospi/source/pkcs12kdf/GenTestDKs.java
crypto/weakcryptospi/source/pkcs12kdf/Pkcs12Pbe.java
crypto/weakcryptospi/source/pkcs12kdf/pkcs12kdf.cpp
crypto/weakcryptospi/source/pkcs5kdf/pkcs5kdf.cpp
crypto/weakcryptospi/source/random/messagedigest.cpp
crypto/weakcryptospi/source/random/random.cpp
crypto/weakcryptospi/source/random/randomshim.cpp
crypto/weakcryptospi/source/random/randomshim.h
crypto/weakcryptospi/source/random/randsvr.cpp
crypto/weakcryptospi/source/random/sha1impl.cpp
crypto/weakcryptospi/source/random/sha1shim.cpp
crypto/weakcryptospi/source/random/sha1shim.h
crypto/weakcryptospi/source/random/threadrandom.cpp
crypto/weakcryptospi/source/symmetric/3des.cpp
crypto/weakcryptospi/source/symmetric/3desshim.cpp
crypto/weakcryptospi/source/symmetric/3desshim.h
crypto/weakcryptospi/source/symmetric/arc4.cpp
crypto/weakcryptospi/source/symmetric/arc4shim.cpp
crypto/weakcryptospi/source/symmetric/arc4shim.h
crypto/weakcryptospi/source/symmetric/blocktransformation.cpp
crypto/weakcryptospi/source/symmetric/bufferedtransformation.cpp
crypto/weakcryptospi/source/symmetric/bufferedtransformationshim.cpp
crypto/weakcryptospi/source/symmetric/bufferedtransformationshim.h
crypto/weakcryptospi/source/symmetric/cbcmode.cpp
crypto/weakcryptospi/source/symmetric/cbcmodeshim.cpp
crypto/weakcryptospi/source/symmetric/cbcmodeshim.h
crypto/weakcryptospi/source/symmetric/des.cpp
crypto/weakcryptospi/source/symmetric/desshim.cpp
crypto/weakcryptospi/source/symmetric/desshim.h
crypto/weakcryptospi/source/symmetric/destables.h
crypto/weakcryptospi/source/symmetric/mstreamcipher.cpp
crypto/weakcryptospi/source/symmetric/nullcipher.cpp
crypto/weakcryptospi/source/symmetric/rc2.cpp
crypto/weakcryptospi/source/symmetric/rc2shim.cpp
crypto/weakcryptospi/source/symmetric/rc2shim.h
crypto/weakcryptospi/source/symmetric/rc2table.h
crypto/weakcryptospi/source/symmetric/rijndael.cpp
crypto/weakcryptospi/source/symmetric/rijndaelshim.cpp
crypto/weakcryptospi/source/symmetric/rijndaelshim.h
crypto/weakcryptospi/source/symmetric/rijndaeltables.h
crypto/weakcryptospi/strong/bld.inf
crypto/weakcryptospi/strong/strong_crypto.mmp
crypto/weakcryptospi/test/kms/driver/product/kmskext/kmskext.cpp
crypto/weakcryptospi/test/kms/private_include/test/kmslddtest.h
crypto/weakcryptospi/test/kms/server/test/kmstest/kmstest.cpp
cryptomgmtlibs/cryptotokenfw/group/bld.inf
cryptomgmtlibs/securitycommonutils/test/source/scstest/scstest.cpp
cryptomgmtlibs/securitytestfw/group/bld.inf
cryptomgmtlibs/securitytestfw/inc/captestframework.h
cryptomgmtlibs/securitytestfw/inc/captestutility.h
cryptomgmtlibs/securitytestfw/test/autotesting/runcertman_9.5.bat
cryptomgmtlibs/securitytestfw/test/autotesting/test_spec_sdp_9.5.txt
cryptoplugins/cryptospiplugins/source/softwarecrypto/3desimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/3desimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/arc4impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/arc4impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/asymmetriccipherimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/asymmetriccipherimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/cmacimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/cmacimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/des.inl
cryptoplugins/cryptospiplugins/source/softwarecrypto/desimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/desimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/destables.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/dhimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/dhimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/dhkeypairgenimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/dhkeypairgenimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/dsakeypairgenimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/dsakeypairgenimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/dsasignerimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/dsasignerimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/dsaverifyimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/dsaverifyimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/hmacimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/hmacimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/keyagreementimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/keyagreementimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/keypairgenimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/keypairgenimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/macimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/macimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/md2impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/md2impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/md4impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/md4impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/md5impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/md5impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/pluginconfig.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/pluginentry.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/pluginentry.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/randomimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/randomimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rc2impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rc2impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rc2table.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rijndaelimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rijndaelimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rijndaeltables.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsafunction.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsafunction.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsakeypairgenimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsakeypairgenimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsasignerimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsasignerimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaverifyimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaverifyimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha1impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha1impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha224and256impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha224and256impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha2impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha2impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha384and512impl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/sha384and512impl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/shacommon.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/signerimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/signerimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/softwarehashbase.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/softwarehashbase.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/symmetriccipherimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/symmetriccipherimpl.h
cryptoplugins/cryptospiplugins/source/softwarecrypto/verifierimpl.cpp
cryptoplugins/cryptospiplugins/source/softwarecrypto/verifierimpl.h
cryptoplugins/cryptospiplugins/test/h4drv/crypto_h4/tcrypto.cpp
cryptoservices/certificateandkeymgmt/crypto/Signed.cpp
cryptoservices/certificateandkeymgmt/group/bld.inf
cryptoservices/certificateandkeymgmt/inc/certmantests.iby
cryptoservices/certificateandkeymgmt/inc/signed.h
cryptoservices/certificateandkeymgmt/inc/x509cert.h
cryptoservices/certificateandkeymgmt/tcertstore/scripts/t_certstore_sha2.ini
cryptoservices/certificateandkeymgmt/tcertstore/scripts/t_certstore_sha2.script
cryptoservices/certificateandkeymgmt/tcertstore/scripts/t_certstore_sha2.txt
cryptoservices/certificateandkeymgmt/x509/x509cert.cpp
cryptoservices/filebasedcertificateandkeystores/test/tcryptotokenhai/tcryptotokenhai.cpp
cryptoservices/filebasedcertificateandkeystores/test/thwkeystore/common/tkeydetails.cpp
cryptoservices/filebasedcertificateandkeystores/test/tkeystore/t_open.cpp
--- a/authorisation/userpromptservice/group/bld.inf	Mon Oct 12 10:17:04 2009 +0300
+++ b/authorisation/userpromptservice/group/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -24,7 +24,7 @@
 #include "../examples/bld.inf"
 
 PRJ_EXPORTS
-../inc/ups.hrh			SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(ups/ups.hrh)
+../inc/ups.hrh			/epoc32/include/ups/ups.hrh
 ../inc/upsconst.h		SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(ups/upsconst.h)
 ../inc/upserr.h			SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(ups/upserr.h)
 ../inc/upstypes.h		SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(ups/upstypes.h)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/contentmgmt/cafrecogniserconfig/ABLD.BAT	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,15 @@
+@ECHO OFF
+
+REM Bldmake-generated batch file - ABLD.BAT
+REM ** DO NOT EDIT **
+
+perl -S ABLD.PL "\sf\os\security\contentmgmt\cafrecogniserconfig\\" %1 %2 %3 %4 %5 %6 %7 %8 %9
+if errorlevel==1 goto CheckPerl
+goto End
+
+:CheckPerl
+perl -v >NUL
+if errorlevel==1 echo Is Perl, version 5.003_07 or later, installed?
+goto End
+
+:End
--- a/contentmgmt/contentaccessfwfordrm/group/bld.inf	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/contentaccessfwfordrm/group/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -123,7 +123,7 @@
 ../../referencedrmagent/tcaf/scripts/contentstep.ini 				z:/tcaf/contentstep.ini
 ../../referencedrmagent/tcaf/scripts/oom.script 				z:/tcaf/oom.script
 ../../referencedrmagent/tcaf/scripts/oom.ini 					z:/tcaf/oom.ini
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 ../../referencedrmagent/tcaf/scripts/supply.script 				z:/tcaf/supply.script
 #else
 ../../referencedrmagent/tcaf/scripts/supply_without_http.script z:/tcaf/supply.script
--- a/contentmgmt/contentaccessfwfordrm/group/tcaf.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/contentaccessfwfordrm/group/tcaf.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -68,7 +68,7 @@
 LIBRARY		apgrfx.lib
 LIBRARY		hal.lib
 
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		http.lib
 #endif
 
--- a/contentmgmt/contentaccessfwfordrm/group/testagent.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/contentaccessfwfordrm/group/testagent.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -51,7 +51,7 @@
 LIBRARY		bafl.lib
 LIBRARY		estor.lib
 
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		http.lib
 #endif
 
--- a/contentmgmt/referencedrmagent/RefTestAgent/RefTestAgent/Reftestagentmanager.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/RefTestAgent/Reftestagentmanager.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -17,8 +17,10 @@
 
 
 #include <caf/caf.h>
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <http.h>
 #include <http/rhttpheaders.h>
+#endif
 #include <stringpool.h>
 
 #include "Reftestagentmanager.h"
@@ -332,7 +334,7 @@
 // make leavescan happy, the options are: 1. TRAP leave calls
 // and ignore the errors. 2. Panic. Both options could potentially
 // break RTA clients' testcases. Hence just leave it the way it is.
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 void CRefTestAgentManager::PrepareHTTPRequestHeaders(RStringPool& aStringPool, RHTTPHeaders& aRequestHeaders) const
 	{
 	// Add the accept header for the reference test agent
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/contentmgmt/referencedrmagent/RefTestAgent/group/ABLD.BAT	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,15 @@
+@ECHO OFF
+
+REM Bldmake-generated batch file - ABLD.BAT
+REM ** DO NOT EDIT **
+
+perl -S ABLD.PL "\sf\os\security\contentmgmt\referencedrmagent\RefTestAgent\group\\" %1 %2 %3 %4 %5 %6 %7 %8 %9
+if errorlevel==1 goto CheckPerl
+goto End
+
+:CheckPerl
+perl -v >NUL
+if errorlevel==1 echo Is Perl, version 5.003_07 or later, installed?
+goto End
+
+:End
--- a/contentmgmt/referencedrmagent/RefTestAgent/group/reftestagent.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/group/reftestagent.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -59,7 +59,7 @@
 LIBRARY		rtaclient.lib
 LIBRARY		bafl.lib
 
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		http.lib
 #endif
 
--- a/contentmgmt/referencedrmagent/RefTestAgent/group/sraclient.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/group/sraclient.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -36,7 +36,9 @@
 LIBRARY 	euser.lib 
 LIBRARY		estor.lib
 LIBRARY		cafutils.lib
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		sdpcodec.lib
+#endif
 LIBRARY 	streamingcaf.lib 
 LIBRARY	    efsrv.lib
 SMPSAFE
--- a/contentmgmt/referencedrmagent/RefTestAgent/group/sraplugin.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/group/sraplugin.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -39,7 +39,9 @@
 
 LIBRARY 	euser.lib
 LIBRARY		streamingcaf.lib
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		sdpcodec.lib 
+#endif
 LIBRARY		sraclient.lib srautils.lib
 
 START RESOURCE 10285A34.rss
--- a/contentmgmt/referencedrmagent/RefTestAgent/group/sraserver.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/group/sraserver.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -40,7 +40,9 @@
 LIBRARY		efsrv.lib
 LIBRARY		cafutils.lib
 LIBRARY		estor.lib
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		sdpcodec.lib
+#endif
 LIBRARY		bafl.lib
 LIBRARY 	streamingcaf.lib
 LIBRARY 	srautils.lib
--- a/contentmgmt/referencedrmagent/RefTestAgent/group/srautils.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/group/srautils.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -41,7 +41,9 @@
 LIBRARY 	euser.lib
 LIBRARY 	estor.lib
 LIBRARY		streamingcaf.lib
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 LIBRARY		sdpcodec.lib
+#endif
 LIBRARY     efsrv.lib 
 LIBRARY		bafl.lib
 SMPSAFE
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sraclient.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sraclient.h	Fri Nov 06 13:21:00 2009 +0200
@@ -32,7 +32,9 @@
 
 //Forward declarations
 class CRightsObject;
-	
+class CSdpMediaField;
+class CSdpDocument;
+
 NONSHARABLE_CLASS(RSraClient) : public RSessionBase
 /**
 	The Key Stream Decoder uses this class to establish a connection with the Streaming Reference
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sracommon.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sracommon.h	Fri Nov 06 13:21:00 2009 +0200
@@ -33,12 +33,15 @@
 #include <e32uid.h>
 #include <s32mem.h>
 #include <stringpool.h>
+
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <sdpdocument.h>
 #include <sdpmediafield.h>
 #include <sdpattributefield.h>
 #include <sdpcodecstringpool.h>
 #include <sdpfmtattributefield.h>
 #include <sdpcodecstringconstants.h>
+#endif
 
 #include <caf/streaming/streamcaftypes.h>
 #include <caf/streaming/keyassociation.h>
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sraserver.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/sraserver.h	Fri Nov 06 13:21:00 2009 +0200
@@ -96,9 +96,11 @@
 private:
 	CSraProcessor* iProcessor;
 	CKeyStreamSink* iKeyStreamSink;
+	CSraRightsObject* iRo;
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	CSdpMediaField* iSdp;
-	CSraRightsObject* iRo;
 	CSdpDocument* iSdpDoc;
+#endif
 	/**
 	 A handle to a mutex which is used to signal the client that the key has been implemented. 
 	 Not necessary in real-life agents and is present here only for testing.
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/srautils.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/inc/srautils.h	Fri Nov 06 13:21:00 2009 +0200
@@ -27,9 +27,14 @@
 #define SRAUTILS_H
 
 #include "srarightsobject.h"
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <sdpmediafield.h>
+#else
+class CSdpMediaField;
+#endif
 #include <f32file.h>
 
+
 IMPORT_C TBool CheckKeyStreamSupportedL(const CSdpMediaField& aSdpKeyStream, const TDesC8& aSupportedKmsIds);
 IMPORT_C void DoSetSdpMediaFieldL(RFs& aFs, CSdpMediaField*& aSdp, CSraRightsObject*& aRo, const TDesC8& aSdpData, const TDesC& aPrivateFolder);
 IMPORT_C void DoSetRightsObjectL(RFs& aFs, CSdpMediaField& aSdp, CSraRightsObject*& aRo, const TDesC& aPrivateFolder);
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/client/sraclient.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/client/sraclient.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -185,11 +185,14 @@
  	@param aKey An SDP object data.
  */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	HBufC8* sdpBuf(0);
 	TPtr8 ptr(EncodeLC(aSdp, sdpBuf));
-	
 	User::LeaveIfError(RSessionBase::SendReceive(ESetSdpKeyStream, TIpcArgs(&ptr)));
 	CleanupStack::PopAndDestroy(sdpBuf);
+#else
+	(void) aSdp;
+#endif
 	}
 
 EXPORT_C void RSraClient::SendSdpDocumentL(const CSdpDocument& aSdpDoc) const
@@ -198,9 +201,13 @@
  	@param aKey An SDP object data.
  */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	HBufC8* sdpDocBuf(0);
 	TPtr8 ptr(EncodeLC(aSdpDoc, sdpDocBuf));
-	
 	User::LeaveIfError(RSessionBase::SendReceive(ESetSdpDocument, TIpcArgs(&ptr)));
 	CleanupStack::PopAndDestroy(sdpDocBuf);
+#else
+	(void) aSdpDoc;
+#endif
+
 	}
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/server/sraserver.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/server/sraserver.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -61,7 +61,9 @@
 	
 	delete iShutdownTimer;
 	iFs.Close();
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	SdpCodecStringPool::Close();
+#endif
 	}
 
 
@@ -79,7 +81,9 @@
 	User::LeaveIfError(iFs.Connect());
 	User::LeaveIfError(iFs.ShareProtected());
 	User::LeaveIfError(iFs.CreatePrivatePath(iFs.GetSystemDrive()));
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	SdpCodecStringPool::OpenL();
+#endif
 	StartL(KSraName);
 	iShutdownTimer = CShutdownTimer::NewL(KSraShutdownPeriod);
 	iShutdownTimer->Restart();
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/server/srasession.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/server/srasession.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -23,7 +23,9 @@
 #include "sraprocessor.h"
 #include "srautils.h"
 #include <s32file.h>
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <sdpconnectionfield.h>
+#endif
 
 CSraSession::CSraSession()
 //constructor
@@ -40,8 +42,10 @@
 		
 	delete iKeyStreamSink;
 	delete iRo;
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	delete iSdp;
 	delete iSdpDoc;
+#endif
 	delete iProcessor;
 	iMutex.Close();
 	}
@@ -327,6 +331,7 @@
  	@param	aMessage	Standard server-side handle to message.
   */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	TInt len = aMessage.GetDesMaxLengthL(0);
 	HBufC8* des = HBufC8::NewLC(len);
 	TPtr8 ptr(des->Des());
@@ -350,6 +355,10 @@
 		}
 	StartProcessorL();
 	aMessage.Complete(KErrNone);
+#else
+	(void) aMessage;
+	User::Leave(KErrCANoRights);
+#endif
 	}
 
 
@@ -360,6 +369,7 @@
  	@param	aMessage	Standard server-side handle to message.
   */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	TInt len = aMessage.GetDesMaxLengthL(0);
 	HBufC8* des = HBufC8::NewLC(len);
 	TPtr8 ptr(des->Des());
@@ -374,6 +384,9 @@
 	CleanupStack::PopAndDestroy(des);
 	
 	aMessage.Complete(KErrNone);
+#else
+	(void) aMessage;
+#endif
 	}
 
 
@@ -383,6 +396,7 @@
  	and then process that by using the key stream sink.
  */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	// Mutex is used to synchronise the agent with the test harness.
 	// A real-life agent should not need to use a mutex object.
 	User::LeaveIfError(iMutex.CreateGlobal(KSraMutexName));
@@ -419,4 +433,5 @@
 	
 	// Launch the processor
 	iProcessor->StartProcessing();
+#endif
 	}
--- a/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/utils/srautils.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/RefTestAgent/streamingrefagent/source/utils/srautils.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -19,9 +19,11 @@
 
 #include "srautils.h"
 #include <s32file.h>
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <sdpfmtattributefield.h>
 #include <sdpcodecstringpool.h>
 #include <sdpattributefield.h>
+#endif
 
 HBufC8* ExtractKmsIdLC(const TDesC8& aValue)
 /**
@@ -72,6 +74,8 @@
 	@return EFalse if the test stream agent fails to recognize the SDP format or is unable to decode the key stream.
  */
 	{
+	TBool supported = EFalse;
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	//FormatAttributeFields method is not constant. So create a new instance.
 	CSdpMediaField* sdp = aSdpKeyStream.CloneL();
 	CleanupStack::PushL(sdp);
@@ -83,7 +87,6 @@
 		return EFalse;
 		}
 
-	TBool supported = EFalse;
 	HBufC8* kmsid(0);
 	
 	for(TInt i=0; i<attributesCount && !supported; ++i)
@@ -100,7 +103,10 @@
 		CleanupStack::PopAndDestroy(kmsid);
 		}
 	CleanupStack::PopAndDestroy(sdp);
-	
+#else 
+	(void) aSdpKeyStream;
+	(void) aSupportedKmsIds;
+#endif
 	return supported;
 	}
 
@@ -169,6 +175,7 @@
  	Finds and loads the Rights Object specified in the SDP given.
  */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	// Find the rights object if it is defined in the SDP
 	CSdpAttributeField* roAttrField = NULL;
 	TInt count = aSdp.AttributeFields().Count();
@@ -202,6 +209,12 @@
 		{//the rights object is defined in the SDP
 		FindAndLoadRightsObjectL(aFs, roAttrField->Value(), aPrivateFolder, aRo);
 		}
+#else
+	(void) aFs;
+	(void) aSdp;
+	(void) aRo;
+	(void) aPrivateFolder;
+#endif
 	}
 
 EXPORT_C void DoSetSdpMediaFieldL(RFs& aFs, CSdpMediaField*& aSdp, CSraRightsObject*& aRo, const TDesC8& aSdpData, const TDesC& aPrivateFolder)
@@ -215,9 +228,17 @@
  	@param aPrivateFolder The private folder of the agent.
   */
 	{
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	ASSERT(!aSdp);
 	// Decode the received message into an SDP object
 	aSdp = CSdpMediaField::DecodeL(aSdpData,ETrue);
 	// Set the specified RO
 	DoSetRightsObjectL(aFs, *aSdp, aRo, aPrivateFolder);
+#else
+	(void) aFs;
+	(void) aSdp;
+	(void) aRo;
+	(void) aSdpData;
+	(void) aPrivateFolder;
+#endif
 	}
--- a/contentmgmt/referencedrmagent/TestAgent/testagentmanager.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/TestAgent/testagentmanager.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -23,8 +23,10 @@
 #include "TestAgentFile.h"
 #include "TestAgentDrmContent.h"
 #include <stringpool.h>
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <http.h>
 #include <http/rhttpheaders.h>
+#endif
 #include <stringpool.h>
 using namespace ContentAccess;
 
@@ -404,7 +406,7 @@
 // make leavescan happy, the options are: 1. TRAP leave calls
 // and ignore the errors. 2. Panic. Both options could potentially
 // break RTA clients' testcases. Hence just leave it the way it is.
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 void CTestAgentManager::PrepareHTTPRequestHeaders(RStringPool& aStringPool, RHTTPHeaders& aRequestHeaders) const
 	{
 	TBuf8 <KMaxDataTypeLength> mimeType;
--- a/contentmgmt/referencedrmagent/tcaf/source/SupplierStep.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/tcaf/source/SupplierStep.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -29,7 +29,7 @@
 #include "bitset.h"
 
 #include <uri8.h>
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <http.h>
 #include <http/rhttpsession.h>
 #include <http/rhttptransaction.h>
@@ -602,7 +602,7 @@
 	return TestStepResult();
 	}
 
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 
 /* 
  * Check that applications can retrieve the HTTP request headers
--- a/contentmgmt/referencedrmagent/tcaf/source/SupplierStep.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/tcaf/source/SupplierStep.h	Fri Nov 06 13:21:00 2009 +0200
@@ -25,7 +25,7 @@
 #include "cafstep.h"
 #include "importfile.h"
 
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 #include <http/mhttptransactioncallback.h>
 #endif
 
@@ -34,7 +34,7 @@
 _LIT(KCAFSupplierAsyncStep,"CAFSupplierAsyncStep");
 _LIT(KCAFSupplierSerializeStep,"CAFSupplierSerializeStep");
 _LIT(KCAFClientOutputSupplierStep,"CAFClientOutputSupplierStep");
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 _LIT(KCAFHTTPRequestHeadersStep,"CAFHTTPRequestHeaders");
 #endif
 class CCAFServer;
@@ -105,7 +105,7 @@
 	};
 
 
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 /* 
 * Used to test that an application can retrieve HTTP request headers
 * @internalComponent Exposure internally
--- a/contentmgmt/referencedrmagent/tcaf/source/cafserver.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/contentmgmt/referencedrmagent/tcaf/source/cafserver.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -258,7 +258,7 @@
 		testStep = new CCafRightsInfoStep(*this);	
 	else if(aStepName == KCAFStreamablePtrArrayStep)
 		testStep = new CCafStreamablePtrArrayStep(*this);
-#ifndef SYMBIAN_DISABLE_UPWARD_DEPENDENCY
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
 	else if(aStepName == KCAFHTTPRequestHeadersStep)
 		testStep = new CCAFHTTPRequestHeadersStep(*this);
 #endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/group/ABLD.BAT	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,15 @@
+@ECHO OFF
+
+REM Bldmake-generated batch file - ABLD.BAT
+REM ** DO NOT EDIT **
+
+perl -S ABLD.PL "\sf\os\security\crypto\weakcryptospi\group\\" %1 %2 %3 %4 %5 %6 %7 %8 %9
+if errorlevel==1 goto CheckPerl
+goto End
+
+:CheckPerl
+perl -v >NUL
+if errorlevel==1 echo Is Perl, version 5.003_07 or later, installed?
+goto End
+
+:End
--- a/crypto/weakcryptospi/group/bld.inf	Mon Oct 12 10:17:04 2009 +0300
+++ b/crypto/weakcryptospi/group/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -82,7 +82,6 @@
 ../inc/hash.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(hash.h)
 ../inc/random.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(random.h)
 ../inc/keyidentifierutil.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(keyidentifierutil.h)
-../inc/randsvr.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(randsvr.h)
 ../inc/randcliserv.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(randcliserv.h)
 ../inc/pkcs5kdf.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(pkcs5kdf.h)
 ../inc/pkcs12kdf.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(pkcs12kdf.h)
--- a/crypto/weakcryptospi/group/randsvr.mmp	Mon Oct 12 10:17:04 2009 +0300
+++ b/crypto/weakcryptospi/group/randsvr.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -24,10 +24,10 @@
 
 TARGET			randsvr.exe
 CAPABILITY ProtServ
-TARGETTYPE		EXEXP
+TARGETTYPE		EXE
 UNPAGED
 
-UID      0x1000008d 0x100066dc
+UID      0x0 0x100066dc
 VENDORID 0x70000001
 
 SOURCEPATH	../source/random
--- a/crypto/weakcryptospi/inc/randsvr.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/crypto/weakcryptospi/inc/randsvr.h	Fri Nov 06 13:21:00 2009 +0200
@@ -19,7 +19,7 @@
 
 /**
  @file 
- @publishedPartner
+ @internalComponent
  @released
 */
  
@@ -33,6 +33,6 @@
 #include <randsvrimpl.h>
 #endif
 
-IMPORT_C TInt RunRandomServer(TAny* /*someParameters*/);
+TInt RunRandomServer(TAny* /*someParameters*/);
 
 #endif // __RANDSVR_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/asymmetric.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,124 @@
+/*
+* Copyright (c) 2003-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 <asymmetric.h>
+#include <bigint.h>
+
+/* MCryptoSystem */
+
+EXPORT_C MCryptoSystem::MCryptoSystem(void)
+	{
+	}
+
+/* CEncryptor */
+
+EXPORT_C CEncryptor::CEncryptor(void)
+	{
+	}
+
+/* CDecryptor */
+
+EXPORT_C CDecryptor::CDecryptor(void)
+	{
+	}
+
+/* MSignatureSystem */
+
+EXPORT_C MSignatureSystem::MSignatureSystem(void)
+	{
+	}
+
+/* CRSASignature */ 
+
+EXPORT_C CRSASignature* CRSASignature::NewL(RInteger& aS)
+	{
+	CRSASignature* self = new(ELeave)CRSASignature(aS);
+	return self;
+	}
+
+EXPORT_C CRSASignature* CRSASignature::NewLC(RInteger& aS)
+	{
+	CRSASignature* self = NewL(aS);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C const TInteger& CRSASignature::S(void) const
+	{
+	return iS;
+	}
+
+EXPORT_C TBool CRSASignature::operator==(const CRSASignature& aSig) const
+	{
+	return ( S() == aSig.S() );
+	}
+
+EXPORT_C CRSASignature::~CRSASignature(void)
+	{
+	iS.Close();
+	}
+
+EXPORT_C CRSASignature::CRSASignature(RInteger& aS) : iS(aS)
+	{
+	}
+
+/* CDSASignature */
+
+EXPORT_C CDSASignature* CDSASignature::NewL(RInteger& aR, RInteger& aS)
+	{
+	CDSASignature* self = new(ELeave)CDSASignature(aR, aS);
+	return self;
+	}
+
+EXPORT_C CDSASignature* CDSASignature::NewLC(RInteger& aR, RInteger& aS)
+	{
+	CDSASignature* self = NewL(aR, aS);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C const TInteger& CDSASignature::R(void) const
+	{
+	return iR;
+	}
+
+EXPORT_C const TInteger& CDSASignature::S(void) const
+	{
+	return iS;
+	}
+
+EXPORT_C TBool CDSASignature::operator==(const CDSASignature& aSig) const
+	{
+	return ( R() == aSig.R() && S() == aSig.S() );
+	}
+
+EXPORT_C CDSASignature::~CDSASignature(void)
+	{
+	iR.Close();
+	iS.Close();
+	}
+
+EXPORT_C CDSASignature::CDSASignature()
+	{
+	}
+
+EXPORT_C CDSASignature::CDSASignature(RInteger& aR, RInteger& aS) 
+	: iR(aR), iS(aS)
+	{
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dh.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,107 @@
+/*
+* Copyright (c) 2003-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 <asymmetric.h>
+#include <asymmetrickeys.h>
+#include "keys.h"
+#include "keyconverter.h"
+#include "cryptokeyagreementapi.h"
+#include <cryptospi/cryptospidef.h>
+
+using namespace CryptoSpi;
+
+CKeyAgreement* GetKeyAgreementCryptoInterfaceLC(TUid aKeyAgreementAlgoUid,
+	  CKey& aPrivateKey, CCryptoParams* aParams)
+	{
+	CKeyAgreement* keyAgreementImpl =  0;
+	CKeyAgreementFactory::CreateKeyAgreementL(keyAgreementImpl,
+												aKeyAgreementAlgoUid, aPrivateKey,
+												aParams);
+	CleanupStack::PushL(keyAgreementImpl);
+	return keyAgreementImpl;
+	}
+
+EXPORT_C CDH* CDH::NewL(const CDHPrivateKey& aPrivateKey)
+	{
+	CDH* self = CDH::NewLC(aPrivateKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CDH* CDH::NewLC(const CDHPrivateKey& aPrivateKey)
+	{
+	CDH* self = new (ELeave) CDH(aPrivateKey);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C HBufC8* CDH::AgreeL(const CDHPublicKey& aPublicKey) const
+	{
+	/*
+	 * both DH keys (ie our private and their public keys) must use the same N and G parameters
+	 */
+	if ((aPublicKey.N() != iPrivateKey.N()) || (aPublicKey.G() != iPrivateKey.G()))
+		{
+		User::Leave(KErrArgument);
+		}
+
+	CKey* privateKey = KeyConverter::CreateKeyL(iPrivateKey);
+	CleanupStack::PushL(privateKey);
+
+	/*
+	 *  package the common parameters N and G into a crypto params array
+	 * we've already checked that both the private and public keys have the 
+	 * same N and G so we only need build this array once for both creating 
+	 * and calling the interface
+	 */
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPublicKey.N(), KDhKeyParameterNUid);
+	keyParameters->AddL(aPublicKey.G(), KDhKeyParameterGUid);
+
+	/* 
+	 * get a DH key agreement interface
+	 */
+	CKeyAgreement* keyAgreementImpl =  GetKeyAgreementCryptoInterfaceLC(KDHAgreementUid, *privateKey, keyParameters);
+
+	/* 
+	 * call the api to get a DH agreed key
+	 */
+	CKey* publicKey = KeyConverter::CreateKeyL(aPublicKey);
+	CleanupStack::PushL(publicKey);
+
+	CKey* agreedKey = keyAgreementImpl->AgreeL(*publicKey, keyParameters);
+	CleanupStack::PushL(agreedKey);
+
+	/*
+	 * extract the agreed key
+	 */
+	const TInteger& agreedKeyData = agreedKey->GetBigIntL(KSymmetricKeyParameterUid);
+	HBufC8 *agreedKeyToReturn = agreedKeyData.BufferLC();
+	CleanupStack::Pop(agreedKeyToReturn);
+
+	/* 
+	 * cleanup stack - it should contain privateKey, keyAgreementImpl, publicKey, keyParameters and agreedKey
+	 */
+	CleanupStack::PopAndDestroy(5, privateKey);
+
+	return agreedKeyToReturn;
+	}
+
+EXPORT_C CDH::CDH(const CDHPrivateKey& aPrivateKey) : iPrivateKey(aPrivateKey)
+	{
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dhkeypairshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,153 @@
+/*
+* Copyright (c) 2007-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 "dhkeypairshim.h"
+#include <bigint.h>
+#include "cryptokeypairgeneratorapi.h"
+#include "keypair.h"
+#include <cryptospi/cryptoparams.h>
+#include <cryptospi/cryptospidef.h>
+
+
+using namespace CryptoSpi;
+
+
+/* CDHKeyPair */
+CDHKeyPairShim* CDHKeyPairShim::NewLC(RInteger& aN, RInteger& aG)
+	{
+	CDHKeyPairShim* self = new(ELeave) CDHKeyPairShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aN, aG);
+	return self;
+	}
+
+CDHKeyPairShim* CDHKeyPairShim::NewLC(RInteger& aN, RInteger& aG, RInteger& ax)
+	{
+	CDHKeyPairShim* self = new(ELeave) CDHKeyPairShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aN, aG, ax);
+	return self;
+	}
+
+CDHKeyPairShim::~CDHKeyPairShim(void)
+	{
+	}
+
+CDHKeyPairShim::CDHKeyPairShim(void)
+	{
+	}	
+
+void CDHKeyPairShim::ConstructL(RInteger& aN, RInteger& aG)
+	{
+	RInteger x = RInteger::NewL();
+	CleanupClosePushL(x);
+	KeyConstructorL(aN, aG, x, EFalse);
+	CleanupStack::PopAndDestroy(1, &x);
+	}
+
+void CDHKeyPairShim::ConstructL(RInteger& aN, RInteger& aG, RInteger& ax)
+	{
+	KeyConstructorL(aN, aG, ax, ETrue);
+	}
+
+void CDHKeyPairShim::KeyConstructorL(RInteger& aN, RInteger& aG, RInteger& ax, TBool xIncluded)
+	{
+	RInteger& nminus2 = aN;
+	
+	/*
+	 * do some sanity checks
+	 */
+	--nminus2;
+	--nminus2;
+	if( aG < TInteger::Two() || aG > nminus2 )
+		{
+		User::Leave(KErrArgument);
+		}
+
+	if (xIncluded)
+		{
+		if( ax < TInteger::One() || ax > nminus2 )
+			{
+			User::Leave(KErrArgument);
+			}
+		}
+
+	/*
+	 *find out how big the key should be - the key must be in the range x | 1 <= x <= n-2
+	 * nminus2 is the largest the key can be so get the number of bits required to represent that number
+	 */
+	const TInt keySize = nminus2.BitCount();
+
+	// increment aN back to its original value
+	++nminus2;
+	++nminus2;
+
+	// obtain an RSA key pair generator interface
+	
+	CKeyPairGenerator* keyPairGeneratorImpl=NULL;
+	CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(
+											keyPairGeneratorImpl,
+											KDHKeyPairGeneratorUid,
+											NULL);
+	CleanupStack::PushL(keyPairGeneratorImpl);
+	
+	/* 
+	 * put the DH parameters into an array
+	 */
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aN, KDhKeyParameterNUid);
+	keyParameters->AddL(aG, KDhKeyParameterGUid);
+	if (xIncluded)
+		{
+		// the private key x has been supplied so add it to the params array so the key generator algo can use it
+		keyParameters->AddL(ax, KDhKeyParameterxUid);
+		ax.Close();
+		}
+
+	/* 
+	 * call the api to create a DH key pair
+	 */
+	CKeyPair* keyPair = 0;
+	keyPairGeneratorImpl->GenerateKeyPairL(keySize, *keyParameters, keyPair);
+	CleanupStack::PushL(keyPair);
+
+	/* 
+	 * for compatibility convert the CKeyPair to CDHPrivateKey and CDHPublicKey
+	 */
+
+	// create new RInteger copies of aN, aG and x so the private key can own them
+	RInteger NCopy = RInteger::NewL(aN);
+	CleanupClosePushL(NCopy);
+	RInteger GCopy = RInteger::NewL(aG);
+	CleanupClosePushL(GCopy);
+	RInteger x = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KDhKeyParameterxUid));
+	CleanupClosePushL(x);
+	iPrivate = CDHPrivateKey::NewL(NCopy, GCopy, x);
+	CleanupStack::Pop(3, &NCopy);
+	
+	// the public key becomes the owner of aN, aG and X
+	RInteger X = RInteger::NewL(keyPair->PublicKey().GetBigIntL(KDhKeyParameterXUid));
+	CleanupClosePushL(X);
+	iPublic = CDHPublicKey::NewL(aN, aG, X);
+	CleanupStack::Pop(&X);	
+
+	/* 
+	 * cleanup stack - it should contain keyPairGeneratorImpl, keyParameters, keyPair, X, NCopy, GCopy and x
+	 */	
+	CleanupStack::PopAndDestroy(3, keyPairGeneratorImpl);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dhkeypairshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,103 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __DHKEYPAIRSHIM_H__
+#define __DHKEYPAIRSHIM_H__
+
+#include "asymmetrickeys.h"
+
+	
+/** 
+* This class is capable of generating a Diffie-Hellman (DH) public/private key pair using the new crypto SPI interface.
+*/
+NONSHARABLE_CLASS(CDHKeyPairShim) : public CDHKeyPair
+	{
+public:
+	/**
+	 * Creates a new DH key pair from a random large integer,
+	 * and a specified large prime and generator.
+	 *
+	 * The returned pointer is put onto the cleanup stack.
+	 *
+	 * @param aN	The DH parameter, n (a large prime)
+	 * @param aG	The DH parameter, g (the generator)
+	 * @return A pointer to a CDHKeyPairShim instance
+	 * 
+	 * @leave KErrArgument	If aG is out of bounds 
+	 */
+	static CDHKeyPairShim* NewLC(RInteger& aN, RInteger& aG);
+
+	/**
+	 * Creates a new DH key pair from a specified 
+	 * large prime, generator, and random large integer.
+	 *
+	 * The returned pointer is put onto the cleanup stack.
+	 *
+	 * @param aN	The DH parameter, n (a large prime)
+	 * @param aG	The DH parameter, g (the generator)
+	 * @param ax	The DH value, x (a random large integer)
+	 * @return A pointer to a CDHKeyPairShim instance
+	 * 
+	 * @leave KErrArgument	If either aG or ax are out of bounds 
+	 */
+	static CDHKeyPairShim* NewLC(RInteger& aN, RInteger& aG, RInteger& ax);
+
+	/** The destructor frees all resources owned by the object, prior to its destruction. */
+	~CDHKeyPairShim(void);
+protected:
+	/** Default constructor */
+	CDHKeyPairShim(void);
+
+	/** 
+	 * Constructor
+	 *
+	 * @param aN	The DH parameter, n (a large prime)
+	 * @param aG	The DH parameter, g (the generator)
+	 */
+	void ConstructL(RInteger& aN, RInteger& aG);
+
+	/** 
+	 * Constructor
+	 *
+	 * @param aN	The DH parameter, n (a large prime)
+	 * @param aG	The DH parameter, g (the generator)
+	 * @param ax	The DH value, x (a random large integer)
+	 */
+	void ConstructL(RInteger& aN, RInteger& aG, RInteger& ax);
+	
+	/**
+	Creates the DH keypair from the given parameters
+	@param aN	The DH parameter, n (a large prime)
+	@param aG	The DH parameter, g (the generator)
+	@param ax	The DH value, x (a random large integer)
+	@param xIncluded if the x is included or not.
+	*/
+	void KeyConstructorL(RInteger& aN, RInteger& aG, RInteger& ax, TBool xIncluded);
+	
+private:
+	CDHKeyPairShim(const CDHKeyPairShim&);
+	CDHKeyPairShim& operator=(const CDHKeyPairShim&);
+	};
+
+#endif	//	__DHKEYPAIRSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dhkeys.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,225 @@
+/*
+* Copyright (c) 2003-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 <asymmetrickeys.h>
+#include "dhkeypairshim.h"
+
+
+/* CDHParameters */
+EXPORT_C const TInteger& CDHParameters::N(void) const
+	{
+	return iN;
+	}
+
+EXPORT_C const TInteger& CDHParameters::G(void) const
+	{
+	return iG;
+	}
+
+EXPORT_C CDHParameters::~CDHParameters(void)
+	{
+	iN.Close();
+	iG.Close();
+	}
+
+EXPORT_C CDHParameters::CDHParameters(RInteger& aN, RInteger& aG) : iN(aN), iG(aG)
+	{
+	}
+
+/* CDHPublicKey */
+EXPORT_C CDHPublicKey* CDHPublicKey::NewL(RInteger& aN, RInteger& aG, 
+	RInteger& aX)
+	{
+	CDHPublicKey* self = new(ELeave) CDHPublicKey(aN, aG, aX);
+	return self;
+	}
+
+EXPORT_C CDHPublicKey* CDHPublicKey::NewLC(RInteger& aN, RInteger& aG, 
+	RInteger& aX)
+	{
+	CDHPublicKey* self = NewL(aN, aG, aX);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C const TInteger& CDHPublicKey::X(void) const
+	{
+	return iX;
+	}
+
+EXPORT_C CDHPublicKey::CDHPublicKey(RInteger& aN, RInteger& aG, RInteger& aX)
+	: CDHParameters(aN, aG), iX(aX)
+	{
+	}
+
+EXPORT_C CDHPublicKey::~CDHPublicKey(void)
+	{
+	iX.Close();
+	}
+
+/* CDHPrivateKey */
+EXPORT_C CDHPrivateKey* CDHPrivateKey::NewL(RInteger& aN, RInteger& aG, 
+	RInteger& ax)
+	{
+	CDHPrivateKey* self = new(ELeave) CDHPrivateKey(aN, aG, ax);
+	return self;
+	}
+
+EXPORT_C CDHPrivateKey* CDHPrivateKey::NewLC(RInteger& aN, RInteger& aG, 
+	RInteger& ax)
+	{
+	CDHPrivateKey* self = NewL(aN, aG, ax);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C const TInteger& CDHPrivateKey::x(void) const
+	{
+	return ix;
+	}
+
+EXPORT_C CDHPrivateKey::CDHPrivateKey(RInteger& aN, RInteger& aG, RInteger& ax)
+	: CDHParameters(aN, aG), ix(ax)
+	{
+	}
+
+EXPORT_C CDHPrivateKey::~CDHPrivateKey(void)
+	{
+	ix.Close();
+	}
+
+/* CDHKeyPair */
+
+EXPORT_C CDHKeyPair* CDHKeyPair::NewL(RInteger& aN, RInteger& aG)
+	{
+	CDHKeyPairShim* self = CDHKeyPairShim::NewLC(aN, aG);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CDHKeyPair* CDHKeyPair::NewLC(RInteger& aN, RInteger& aG)
+	{
+	CDHKeyPairShim* self = CDHKeyPairShim::NewLC(aN, aG);
+	return self;
+	}
+
+EXPORT_C CDHKeyPair* CDHKeyPair::NewL(RInteger& aN, RInteger& aG, RInteger& ax)
+	{
+	CDHKeyPairShim* self = CDHKeyPairShim::NewLC(aN, aG, ax);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CDHKeyPair* CDHKeyPair::NewLC(RInteger& aN, RInteger& aG, RInteger& ax)
+	{
+	CDHKeyPairShim* self = CDHKeyPairShim::NewLC(aN, aG, ax);
+	return self;
+	}
+
+EXPORT_C const CDHPublicKey& CDHKeyPair::PublicKey(void) const
+	{
+	return *iPublic;
+	}
+
+EXPORT_C const CDHPrivateKey& CDHKeyPair::PrivateKey(void) const
+	{
+	return *iPrivate;
+	}
+
+EXPORT_C CDHKeyPair::~CDHKeyPair(void)
+	{
+	delete iPublic;
+	delete iPrivate;
+	}
+
+EXPORT_C CDHKeyPair::CDHKeyPair(void)
+	{
+	}
+
+// Excluded from coverage due to shim replacements.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+EXPORT_C void CDHKeyPair::ConstructL(RInteger& aN, RInteger& aG)
+	{
+	//declaring a reference just for clarity in NewRandomL statement
+	RInteger& nminus2 = aN;
+	--nminus2;
+	--nminus2;
+
+	//find a random x | 1 <= x <= n-2
+	RInteger x = RInteger::NewRandomL(TInteger::One(), nminus2);
+	CleanupStack::PushL(x);
+	++nminus2;
+	++nminus2; // reincrement aN
+
+	ConstructL(aN, aG, x);
+
+	CleanupStack::Pop(&x);
+	}
+
+EXPORT_C void CDHKeyPair::ConstructL(RInteger& aN, RInteger& aG, RInteger& ax)
+	{
+	//declaring a reference just for clarity in if statements
+	RInteger& nminus2 = aN;
+	--nminus2;
+	--nminus2;
+	
+	if( aG < TInteger::Two() || aG > nminus2 )
+		{
+		User::Leave(KErrArgument);
+		}
+	//In the case of the other ConstructL calling this function this if
+	//statement is redundant.  However, we need to check as this is can be
+	//called without going through the other api.
+	if( ax < TInteger::One() || ax > nminus2 )
+		{
+		User::Leave(KErrArgument);
+		}
+
+	++nminus2;
+	++nminus2; // reincrement aN
+
+	// Calculate X = g^(x) mod n; (note the case sensitivity)
+	RInteger X = TInteger::ModularExponentiateL(aG, ax, aN);
+	CleanupStack::PushL(X);
+
+	RInteger n1 = RInteger::NewL(aN);
+	CleanupStack::PushL(n1);
+	RInteger g1 = RInteger::NewL(aG);
+	CleanupStack::PushL(g1);
+	iPublic = CDHPublicKey::NewL(n1, g1, X);
+	CleanupStack::Pop(3, &X); // g1, n1, X all owned by iPublic
+	
+	iPrivate = CDHPrivateKey::NewL(aN, aG, ax);
+	}
+
+// Unused exported and protected members. So, exclude them from coverage.
+EXPORT_C CDHParameters::CDHParameters(void)
+	{
+	}
+
+EXPORT_C CDHPrivateKey::CDHPrivateKey(void)
+	{
+	}
+
+EXPORT_C CDHPublicKey::CDHPublicKey(void)
+	{
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsakeypairshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,112 @@
+/*
+* Copyright (c) 2007-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 "dsakeypairshim.h"
+#include "cryptokeypairgeneratorapi.h"
+#include "keypair.h"
+#include <cryptospi/cryptoparams.h>
+#include <cryptospi/cryptospidef.h>
+
+
+using namespace CryptoSpi;
+
+
+/* CDSAKeyPair */
+CDSAKeyPairShim* CDSAKeyPairShim::NewLC(TUint aKeyBits)
+	{
+	CDSAKeyPairShim* self = new(ELeave) CDSAKeyPairShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKeyBits);
+	return self;
+	}
+
+CDSAKeyPairShim::~CDSAKeyPairShim()
+	{
+	}
+
+CDSAKeyPairShim::CDSAKeyPairShim()
+	{
+	}
+
+void CDSAKeyPairShim::ConstructL(TUint aKeyBits)
+	{
+	CKeyPairGenerator* keyPairGeneratorImpl=NULL;
+	CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(
+											keyPairGeneratorImpl,
+											KDSAKeyPairGeneratorUid,
+											NULL);
+	CleanupStack::PushL(keyPairGeneratorImpl);
+	
+	
+	
+	
+	// put the DSA parameters into an array
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+
+	// call the api to create an DSA key pair
+	CKeyPair* keyPair = 0;
+	keyPairGeneratorImpl->GenerateKeyPairL(aKeyBits, *keyParameters, keyPair);
+	CleanupStack::PushL(keyPair);
+	
+	//Just to keep BC
+	if (keyParameters->IsPresent(KDsaKeyGenerationSeedUid))
+		{
+		const TDesC8& seed = keyParameters->GetTDesC8L(KDsaKeyGenerationSeedUid);
+		TInt counter=keyParameters->GetTIntL(KDsaKeyGenerationCounterUid);
+		iPrimeCertificate=CDSAPrimeCertificate::NewL(seed, counter);	
+		}
+	
+	//
+	//for compatibility convert the CKeyPair to CDSAPrivateKey and CDSAPublicKey
+	//
+	// the public key becomes the owner of P,Q,G,Y
+	const CKey& publicKey = keyPair->PublicKey();
+	RInteger P = RInteger::NewL(publicKey.GetBigIntL(KDsaKeyParameterPUid));
+	CleanupClosePushL(P);
+
+	RInteger Q = RInteger::NewL(publicKey.GetBigIntL(KDsaKeyParameterQUid));
+	CleanupClosePushL(Q);
+	
+	RInteger G = RInteger::NewL(publicKey.GetBigIntL(KDsaKeyParameterGUid));
+	CleanupClosePushL(G);
+	
+	RInteger Y = RInteger::NewL(publicKey.GetBigIntL(KDsaKeyParameterYUid));
+	CleanupClosePushL(Y);
+	
+	iPublic = CDSAPublicKey::NewL(P, Q, G, Y);
+	CleanupStack::Pop(4, &P); //Y,G,Q,P
+
+	// the private key becomes the owner of P1,Q1,G1,X
+	const CKey& privateKey = keyPair->PrivateKey();
+	RInteger P1 = RInteger::NewL(privateKey.GetBigIntL(KDsaKeyParameterPUid));
+	CleanupClosePushL(P1);
+
+	RInteger Q1 = RInteger::NewL(privateKey.GetBigIntL(KDsaKeyParameterQUid));
+	CleanupClosePushL(Q1);
+	
+	RInteger G1 = RInteger::NewL(privateKey.GetBigIntL(KDsaKeyParameterGUid));
+	CleanupClosePushL(G1);
+
+	RInteger X = RInteger::NewL(privateKey.GetBigIntL(KDsaKeyParameterXUid));
+	CleanupClosePushL(X);
+
+	iPrivate = CDSAPrivateKey::NewL(P1, Q1, G1, X);
+	CleanupStack::Pop(4, &P1); //X,G1,Q1,P1
+	
+	CleanupStack::PopAndDestroy(3, keyPairGeneratorImpl); // keyPair, keyParameters, keyPairGeneratorImpl
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsakeypairshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,58 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __DSAKEYPAIRSHIM_H__
+#define __DSAKEYPAIRSHIM_H__
+
+#include "asymmetrickeys.h"
+
+/** 
+* This class generates an DSA public/private key pair via CryptoSPI
+*/
+
+NONSHARABLE_CLASS(CDSAKeyPairShim) : public CDSAKeyPair
+	{
+public:
+	/**
+	 * Creates a new DSA key pair
+	 */
+	static CDSAKeyPairShim* NewLC(TUint aKeyBits);
+
+	~CDSAKeyPairShim(void);
+
+protected:
+	/** Constructor */
+	CDSAKeyPairShim(void);
+
+	/** 
+	 * 2nd stage constructor
+	 */
+	void ConstructL(TUint aKeyBits);
+
+private:
+	CDSAKeyPairShim(const CDSAKeyPairShim&);
+	CDSAKeyPairShim& operator=(const CDSAKeyPairShim&);	
+	};
+
+#endif	//	__DSAKEYPAIRSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsakeys.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,403 @@
+/*
+* Copyright (c) 2003-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 <asymmetrickeys.h>
+#include <bigint.h>
+#include <random.h>
+#include <hash.h>
+#include "../common/inlines.h"
+#include "../bigint/mont.h"
+#include "dsakeypairshim.h"
+
+const TUint SHASIZE = 20;
+const TUint KMinPrimeLength = 512;
+const TUint KMaxPrimeLength = 1024;
+const TUint KPrimeLengthMultiple = 64;
+
+/* CDSAParameters */
+
+EXPORT_C const TInteger& CDSAParameters::P(void) const
+	{
+	return iP;
+	}
+
+EXPORT_C const TInteger& CDSAParameters::Q(void) const
+	{
+	return iQ;
+	}
+
+EXPORT_C const TInteger& CDSAParameters::G(void) const
+	{
+	return iG;
+	}
+
+EXPORT_C CDSAParameters::~CDSAParameters(void)
+	{
+	iP.Close();
+	iQ.Close();
+	iG.Close();
+	}
+
+EXPORT_C CDSAParameters* CDSAParameters::NewL(RInteger& aP, RInteger& aQ, 
+	RInteger& aG)
+	{
+	CDSAParameters* me = new (ELeave) CDSAParameters(aP, aQ, aG);
+	return (me);
+	}
+
+EXPORT_C TBool CDSAParameters::ValidatePrimesL(const CDSAPrimeCertificate& aCert)
+	const
+	{
+	TBool result = EFalse;
+	RInteger p;
+	RInteger q;
+	//Regenerate primes using aCert's seed and counter
+	TUint counter = aCert.Counter();
+	if(!CDSAParameters::GeneratePrimesL(aCert.Seed(), counter, p, 
+		P().BitCount(), q, ETrue))
+		{
+		return result;
+		}
+	//this doesn't leave, no need to push p and q
+	if(p == P() && q == Q() && counter == aCert.Counter())
+		{
+		result = ETrue;
+		}
+	p.Close();
+	q.Close();
+	return result;
+	}
+
+EXPORT_C TBool CDSAParameters::ValidPrimeLength(TUint aPrimeBits)
+	{
+	return (aPrimeBits >= KMinPrimeLength &&
+		aPrimeBits <= KMaxPrimeLength &&
+		aPrimeBits % KPrimeLengthMultiple == 0);
+	}
+
+EXPORT_C CDSAParameters::CDSAParameters(RInteger& aP, RInteger& aQ, 	
+	RInteger& aG) : iP(aP), iQ(aQ), iG(aG)
+	{
+	}
+
+EXPORT_C CDSAParameters::CDSAParameters(void)
+	{
+	}
+
+TBool CDSAParameters::GeneratePrimesL(const TDesC8& aSeed, TUint& aCounter, 
+	RInteger& aP, TUint aL, RInteger& aQ, TBool aUseInputCounter)
+	{
+	//This follows the steps in FIPS 186-2 
+	//See DSS Appendix 2.2
+	//Note. Step 1 is performed prior to calling GeneratePrimesL, so that this
+	//routine can be used for both generation and validation.
+	//Step 1.  Choose an arbitrary sequence of at least 160 bits and call it
+	//SEED.  Let g be the length of SEED in bits.
+
+	if(!CDSAParameters::ValidPrimeLength(aL))
+		{
+		User::Leave(KErrNotSupported);
+		}
+	
+	CSHA1* sha1 = CSHA1::NewL();
+	CleanupStack::PushL(sha1);
+
+	HBufC8* seedBuf = aSeed.AllocLC();
+	TPtr8 seed = seedBuf->Des();
+	TUint gBytes = aSeed.Size();
+	//Note that the DSS's g = BytesToBits(gBytes) ie. the number of random bits
+	//in the seed.  
+	//This function has made the assumption (for ease of computation) that g%8
+	//is 0.  Ie the seed is a whole number of random bytes.
+	TBuf8<SHASIZE> U; 
+	TBuf8<SHASIZE> temp; 
+	const TUint n = (aL-1)/160;
+	const TUint b = (aL-1)%160;
+	HBufC8* Wbuf = HBufC8::NewMaxLC((n+1) * SHASIZE);
+	TUint8* W = const_cast<TUint8*>(Wbuf->Ptr());
+
+	U.Copy(sha1->Final(seed));
+	
+	//Step 2. U = SHA-1[SEED] XOR SHA-1[(SEED+1) mod 2^g]
+	for(TInt i=gBytes - 1, carry=ETrue; i>=0 && carry; i--)
+		{
+		//!++(TUint) adds one to the current word which if it overflows to zero
+		//sets carry to 1 thus letting the loop continue.  It's a poor man's
+		//multi-word addition.  Swift eh?
+		carry = !++(seed[i]);
+		}
+
+	temp.Copy(sha1->Final(seed));
+	XorBuf(const_cast<TUint8*>(U.Ptr()), temp.Ptr(), SHASIZE);
+
+	//Step 3. Form q from U by setting the most significant bit (2^159)
+	//and the least significant bit to 1.
+	U[0] |= 0x80;
+	U[SHASIZE-1] |= 1;
+
+	aQ = RInteger::NewL(U);
+	CleanupStack::PushL(aQ);
+
+	//Step 4. Use a robust primality testing algo to test if q is prime
+	//The robust part is the calling codes problem.  This will use whatever
+	//random number generator you set for the thread.  To attempt FIPS 186-2
+	//compliance, set a FIPS 186-2 compliant RNG.
+	if( !aQ.IsPrimeL() )
+		{
+		//Step 5. If not exit and get a new seed
+		CleanupStack::PopAndDestroy(&aQ);
+		CleanupStack::PopAndDestroy(Wbuf);
+		CleanupStack::PopAndDestroy(seedBuf);
+		CleanupStack::PopAndDestroy(sha1);
+		return EFalse;
+		}
+	
+	TUint counterEnd = aUseInputCounter ? aCounter+1 : 4096;
+	
+	//Step 6. Let counter = 0 and offset = 2
+	//Note 1. that the DSS speaks of SEED + offset + k because they always
+	//refer to a constant SEED.  We update our seed as we go so the offset
+	//variable has already been added to seed in the previous iterations.
+	//Note 2. We've already added 1 to our seed, so the first time through this
+	//the offset in DSS speak will be 2.
+	for(TUint counter=0; counter < counterEnd; counter++)
+		{
+		//Step 7. For k=0, ..., n let
+		// Vk = SHA-1[(SEED + offset + k) mod 2^g]
+		//I'm storing the Vk's inside of a big W buffer.
+		for(TUint k=0; k<=n; k++)
+			{
+			for(TInt i=gBytes-1, carry=ETrue; i>=0 && carry; i--)
+				{
+				carry = !++(seed[i]);
+				}
+			if(!aUseInputCounter || counter == aCounter)
+				{
+				TPtr8 Wptr(W+(n-k)*SHASIZE, gBytes);
+				Wptr.Copy(sha1->Final(seed));
+				}
+			}
+		if(!aUseInputCounter || counter == aCounter)
+			{
+			//Step 8. Let W be the integer...  and let X = W + 2^(L-1)
+			const_cast<TUint8&>((*Wbuf)[SHASIZE - 1 - b/8]) |= 0x80;
+			TPtr8 Wptr(W + SHASIZE - 1 - b/8, aL/8, aL/8);
+			RInteger X = RInteger::NewL(Wptr);
+			CleanupStack::PushL(X);
+			//Step 9. Let c = X mod 2q and set p = X - (c-1)
+			RInteger twoQ = aQ.TimesL(TInteger::Two());
+			CleanupStack::PushL(twoQ);
+			RInteger c = X.ModuloL(twoQ);
+			CleanupStack::PushL(c);
+			--c;
+			aP = X.MinusL(c);
+			CleanupStack::PopAndDestroy(3, &X); //twoQ, c, X
+			CleanupStack::PushL(aP);
+			
+			//Step 10 and 11: if p >= 2^(L-1) and p is prime
+			if( aP.Bit(aL-1) && aP.IsPrimeL() )
+				{
+				aCounter = counter;
+				CleanupStack::Pop(&aP);
+				CleanupStack::Pop(&aQ);
+				CleanupStack::PopAndDestroy(Wbuf);
+				CleanupStack::PopAndDestroy(seedBuf);
+				CleanupStack::PopAndDestroy(sha1);
+				return ETrue;
+				}
+			CleanupStack::PopAndDestroy(&aP);
+			}
+		}
+	CleanupStack::PopAndDestroy(&aQ);
+	CleanupStack::PopAndDestroy(Wbuf);
+	CleanupStack::PopAndDestroy(seedBuf);
+	CleanupStack::PopAndDestroy(sha1);
+	return EFalse;
+	}
+
+/* CDSAPublicKey */
+
+EXPORT_C CDSAPublicKey* CDSAPublicKey::NewL(RInteger& aP, RInteger& aQ, 
+	RInteger& aG, RInteger& aY)
+	{
+	CDSAPublicKey* self = new(ELeave) CDSAPublicKey(aP, aQ, aG, aY);
+	return self;
+	}
+
+EXPORT_C CDSAPublicKey* CDSAPublicKey::NewLC(RInteger& aP, RInteger& aQ, 
+	RInteger& aG, RInteger& aY)
+	{
+	CDSAPublicKey* self = NewL(aP, aQ, aG, aY);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C const TInteger& CDSAPublicKey::Y(void) const
+	{
+	return iY;
+	}
+
+EXPORT_C CDSAPublicKey::CDSAPublicKey(void)
+	{
+	} 
+
+EXPORT_C CDSAPublicKey::CDSAPublicKey(RInteger& aP, RInteger& aQ, RInteger& aG, 
+	RInteger& aY) : CDSAParameters(aP, aQ, aG), iY(aY)
+	{
+	}
+
+EXPORT_C CDSAPublicKey::~CDSAPublicKey(void)
+	{
+	iY.Close();
+	}
+
+/* CDSAPrivateKey */
+
+EXPORT_C CDSAPrivateKey* CDSAPrivateKey::NewL(RInteger& aP, RInteger& aQ, 
+	RInteger& aG, RInteger& aX)
+	{
+	CDSAPrivateKey* self = new(ELeave) CDSAPrivateKey(aP, aQ, aG, aX);
+	return self;
+	}
+
+EXPORT_C CDSAPrivateKey* CDSAPrivateKey::NewLC(RInteger& aP, RInteger& aQ, 
+	RInteger& aG, RInteger& aX)
+	{
+	CDSAPrivateKey* self = NewL(aP, aQ, aG, aX);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C const TInteger& CDSAPrivateKey::X(void) const
+	{
+	return iX;
+	}
+
+EXPORT_C CDSAPrivateKey::CDSAPrivateKey(RInteger& aP, RInteger& aQ, RInteger& aG, 
+	RInteger& aX) : CDSAParameters(aP, aQ, aG), iX(aX)
+	{
+	}
+
+EXPORT_C CDSAPrivateKey::~CDSAPrivateKey(void)
+	{
+	iX.Close();
+	}
+
+/* CDSAKeyPair */
+
+EXPORT_C CDSAKeyPair* CDSAKeyPair::NewL(TUint aKeyBits)
+	{
+ 	CDSAKeyPairShim* self = CDSAKeyPairShim::NewLC(aKeyBits);
+ 	CleanupStack::Pop();
+ 	return self;
+	}
+
+EXPORT_C CDSAKeyPair* CDSAKeyPair::NewLC(TUint aKeyBits)
+	{
+ 	CDSAKeyPairShim* self = CDSAKeyPairShim::NewLC(aKeyBits);
+ 	return self;
+	}
+
+EXPORT_C const CDSAPublicKey& CDSAKeyPair::PublicKey(void) const
+	{
+	return *iPublic;
+	}
+	
+EXPORT_C const CDSAPrivateKey& CDSAKeyPair::PrivateKey(void) const
+	{
+	return *iPrivate;
+	}
+
+EXPORT_C CDSAKeyPair::~CDSAKeyPair(void) 
+	{
+	delete iPublic;
+	delete iPrivate;
+	delete iPrimeCertificate;
+	}
+
+EXPORT_C CDSAKeyPair::CDSAKeyPair(void) 
+	{
+	}
+
+EXPORT_C const CDSAPrimeCertificate& CDSAKeyPair::PrimeCertificate(void) const
+	{
+	return *iPrimeCertificate;
+	}
+
+/* CDSAPrimeCertificate */
+
+EXPORT_C CDSAPrimeCertificate* CDSAPrimeCertificate::NewL(const TDesC8& aSeed,
+	TUint aCounter)
+	{
+	CDSAPrimeCertificate* self = NewLC(aSeed, aCounter);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CDSAPrimeCertificate* CDSAPrimeCertificate::NewLC(const TDesC8& aSeed,
+	TUint aCounter)
+	{
+	CDSAPrimeCertificate* self = new(ELeave) CDSAPrimeCertificate(aCounter);
+	CleanupStack::PushL(self);
+	self->ConstructL(aSeed);
+	return self;
+	}
+
+EXPORT_C const TDesC8& CDSAPrimeCertificate::Seed(void) const
+	{
+	return *iSeed;
+	}
+
+EXPORT_C TUint CDSAPrimeCertificate::Counter(void) const
+	{
+	return iCounter;
+	}
+
+EXPORT_C CDSAPrimeCertificate::~CDSAPrimeCertificate(void) 
+	{
+	delete const_cast<HBufC8*>(iSeed);
+	}
+
+void CDSAPrimeCertificate::ConstructL(const TDesC8& aSeed)
+	{
+	iSeed = aSeed.AllocL();
+	}
+
+EXPORT_C CDSAPrimeCertificate::CDSAPrimeCertificate(TUint aCounter) 
+	: iCounter(aCounter)
+	{
+	}
+
+// Over taken by  shim version. so, exclude it from coverage.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+void CDSAKeyPair::ConstructL(TUint /*aPBits*/)
+	{
+	}
+
+// Unused exported and protected method can be excluded from coverage.
+EXPORT_C CDSAPrimeCertificate::CDSAPrimeCertificate(void) 
+	{
+	}
+
+EXPORT_C CDSAPrivateKey::CDSAPrivateKey(void)
+	{
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsashim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,182 @@
+/*
+* Copyright (c) 2007-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 "dsashim.h"
+#include "cryptosignatureapi.h"
+#include <cryptospi/cryptospidef.h>
+#include "keys.h"
+#include "keyconverter.h"
+
+#include "../common/inlines.h"
+
+
+using namespace CryptoSpi;
+
+// CDsaSignerShim ////////////////////////////////////////////////////////
+
+CDsaSignerShim* CDsaSignerShim::NewL(const CDSAPrivateKey& aKey)
+	{
+	CDsaSignerShim* self = CDsaSignerShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDsaSignerShim* CDsaSignerShim::NewLC(const CDSAPrivateKey& aKey)
+	{
+	CDsaSignerShim* self = new (ELeave) CDsaSignerShim(aKey);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CDsaSignerShim::CDsaSignerShim(const CDSAPrivateKey& aKey)
+	: CDSASigner(aKey)
+	{
+	}
+
+CDsaSignerShim::~CDsaSignerShim()
+	{
+	delete iSignerImpl;
+	delete iKey;
+	}
+
+void CDsaSignerShim::ConstructL(const CDSAPrivateKey& aKey)
+	{
+	iKey = KeyConverter::CreateKeyL(aKey);
+	CSignatureFactory::CreateSignerL(
+									iSignerImpl,
+									KDsaSignerUid,
+									*iKey,
+									KPaddingModeNoneUid,
+									NULL);
+	}
+
+
+CDSASignature* CDsaSignerShim::SignL(const TDesC8& aInput) const
+	{
+	//Sign the input data
+	CCryptoParams* signature = CCryptoParams::NewLC();
+	iSignerImpl->SignL(aInput, *signature);
+	
+	//Retrieve the R&S in DSA signature from the array 
+	const TInteger& cR=signature->GetBigIntL(KDsaSignatureParameterRUid);
+	const TInteger& cS=signature->GetBigIntL(KDsaSignatureParameterSUid);
+	
+	
+	//Make copies of the DSA signature
+	RInteger r=RInteger::NewL(cR);
+	CleanupClosePushL(r);
+	RInteger s=RInteger::NewL(cS);
+	CleanupClosePushL(s);	
+	
+	//Create the DSA signature object, the ownership of r&s is transfered to dsaSig
+	CDSASignature* dsaSig=CDSASignature::NewL(r, s);
+	
+	//Cleanup
+	CleanupStack::Pop(2, &r); 	
+	CleanupStack::PopAndDestroy(signature);
+	
+	return dsaSig;
+	}
+
+TInt CDsaSignerShim::MaxInputLength() const
+	{
+	TInt maxInputLength=0; 
+	TRAPD(err, maxInputLength=iSignerImpl->GetMaximumInputLengthL())
+	if (err==KErrNone)
+		{
+		return maxInputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+
+// CDsaVerifierShim ////////////////////////////////////////////////////////
+CDsaVerifierShim* CDsaVerifierShim::NewL(const CDSAPublicKey& aKey)
+	{
+	CDsaVerifierShim* self = CDsaVerifierShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDsaVerifierShim* CDsaVerifierShim::NewLC(const CDSAPublicKey& aKey)
+	{
+	CDsaVerifierShim* self = new (ELeave) CDsaVerifierShim(aKey);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CDsaVerifierShim::CDsaVerifierShim(const CDSAPublicKey& aKey)
+	: CDSAVerifier(aKey)
+	{
+	}
+
+CDsaVerifierShim::~CDsaVerifierShim()
+	{
+	delete iVerifierImpl;
+	delete iKey;
+	}
+
+void CDsaVerifierShim::ConstructL(const CDSAPublicKey& aKey)
+	{
+	iKey = KeyConverter::CreateKeyL(aKey);
+	CSignatureFactory::CreateVerifierL(
+									iVerifierImpl,
+									KDsaVerifierUid,
+									*iKey,
+									KPaddingModeNoneUid,
+									NULL);
+											
+	}
+
+TBool CDsaVerifierShim::VerifyL(const TDesC8& aInput, const CDSASignature& aSignature) const
+	{
+	//create the array format dsa signature for the new crypto spi
+	CCryptoParams* dsaSig = CCryptoParams::NewLC();
+
+	dsaSig->AddL(aSignature.R(), KDsaSignatureParameterRUid);
+	dsaSig->AddL(aSignature.S(), KDsaSignatureParameterSUid);
+
+	//pass the signature and input to the new crypto spi to be verified
+	TBool verificationResult=EFalse;
+	iVerifierImpl->VerifyL(aInput, *dsaSig, verificationResult);
+
+	//Cleanup the array
+	CleanupStack::PopAndDestroy(dsaSig);
+
+	return verificationResult;
+	}
+
+TInt CDsaVerifierShim::MaxInputLength() const
+	{
+	TInt maxInputLength=0; 
+	TRAPD(err, maxInputLength=iVerifierImpl->GetMaximumInputLengthL())
+	if (err==KErrNone)
+		{
+		return maxInputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsashim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,138 @@
+/*
+* Copyright (c) 2006-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: 
+* DSA shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __DSASHIM_H__
+#define __DSASHIM_H__
+
+#include <asymmetric.h>
+
+namespace CryptoSpi
+	{
+	class CSigner;
+	class CVerifier;
+	class CKey;
+	}
+	
+NONSHARABLE_CLASS(CDsaSignerShim) : public CDSASigner
+{
+public:
+	/**
+	Creates an CDsaSignerShim object which has the same interface
+	as CDSASigner but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The signing key
+	@return A pointer to a CDsaSignerShim instance
+	*/
+	static CDsaSignerShim* NewL(const CDSAPrivateKey& aKey);
+	
+	/**
+	Creates an CDsaSignerShim object which has the same interface
+	as CDSASigner but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The signing key
+	@return A pointer to a CDsaSignerShim instance
+	*/
+	static CDsaSignerShim* NewLC(const CDSAPrivateKey& aKey);
+	
+	/**
+	Digitally signs the specified input message 
+	Note that in order to be interoperable and compliant with the DSS, aInput
+	must be the result of a SHA-1 hash.
+
+	@param aInput	A SHA-1 hash of the message to sign
+	@return			A pointer to a new CSignature object
+	@panic ECryptoPanicInputTooLarge	If aInput is larger than MaxInputLength(),
+										which is likely to happen if the caller
+										has passed in something that has not been hashed.
+	*/
+	virtual CDSASignature* SignL(const TDesC8& aInput) const;
+
+	//From MSignatureSystem
+	virtual TInt MaxInputLength() const;
+	
+	/// Destructor
+	~CDsaSignerShim();
+	
+private:
+	/// Constructor
+	CDsaSignerShim(const CDSAPrivateKey& aKey);
+	void ConstructL(const CDSAPrivateKey& aKey);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CSigner* iSignerImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+};
+
+NONSHARABLE_CLASS(CDsaVerifierShim) : public CDSAVerifier
+{
+public:
+	/**
+	Creates an CDsaVerifierShim object which has the same interface
+	as CDSAVerifier but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The verification key
+	@return A pointer to a CDsaVerifierShim instance
+	*/
+	static CDsaVerifierShim* NewL(const CDSAPublicKey& aKey);
+	
+	/**
+	Creates an CDsaVerifierShim object which has the same interface
+	as CDSAVerifier but delegates all work to a Crypto SPI plug-in.
+
+	A pointer to the new object is placed on the cleanup stack
+
+	@param aKey The verification key
+	@return A pointer to a CDsaVerifierShim instance
+	*/
+	static CDsaVerifierShim* NewLC(const CDSAPublicKey& aKey);
+
+	//From CVerifier	
+	virtual TBool VerifyL(const TDesC8& aInput, const CDSASignature& aSignature) const;
+
+	//From MSignatureSystem
+	virtual TInt MaxInputLength() const;
+
+	// Destructor
+	~CDsaVerifierShim();
+	
+private:
+	// Constructor
+	CDsaVerifierShim(const CDSAPublicKey& aKey);
+	void ConstructL(const CDSAPublicKey& aKey);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CVerifier* iVerifierImpl;
+	
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+};
+
+#endif // __DSASHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsasigner.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2003-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 "dsashim.h"
+
+EXPORT_C CDSASigner* CDSASigner::NewL(const CDSAPrivateKey& aKey)
+	{
+	return CDsaSignerShim::NewL(aKey);
+	}
+
+EXPORT_C CDSASigner* CDSASigner::NewLC(const CDSAPrivateKey& aKey) 
+	{
+	return CDsaSignerShim::NewLC(aKey);
+	}
+
+CDSASigner::CDSASigner(const CDSAPrivateKey& aKey) 
+	: iPrivateKey(aKey)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CDSASigner::MaxInputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+CDSASignature* CDSASigner::SignL(const TDesC8& /*aInput*/) const
+	{
+	// Method replaced by shim
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/dsaverifier.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2003-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 "dsashim.h"
+
+EXPORT_C CDSAVerifier* CDSAVerifier::NewL(const CDSAPublicKey& aKey)
+	{
+	return CDsaVerifierShim::NewL(aKey);
+	}
+
+EXPORT_C CDSAVerifier* CDSAVerifier::NewLC(const CDSAPublicKey& aKey)
+	{
+	return CDsaVerifierShim::NewLC(aKey);
+	}
+
+CDSAVerifier::CDSAVerifier(const CDSAPublicKey& aKey)  
+	: iPublicKey(aKey)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CDSAVerifier::MaxInputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+TBool CDSAVerifier::VerifyL(const TDesC8& /*aInput*/, const CDSASignature& /*aSignature*/) const
+	{
+	// Method replaced by shim
+	User::Leave(KErrNotSupported);
+	return EFalse;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsadecryptor.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,75 @@
+/*
+* Copyright (c) 2003-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 "rsashim.h"
+
+
+/* CRSAPKCS1v15Decryptor */
+
+EXPORT_C CRSAPKCS1v15Decryptor* CRSAPKCS1v15Decryptor::NewL(
+	const CRSAPrivateKey& aKey)
+	{
+	return CRSAPKCS1v15DecryptorShim::NewL(aKey);
+	}
+
+EXPORT_C CRSAPKCS1v15Decryptor* CRSAPKCS1v15Decryptor::NewLC(
+	const CRSAPrivateKey& aKey)
+	{
+	return CRSAPKCS1v15DecryptorShim::NewLC(aKey);
+	}
+
+CRSAPKCS1v15Decryptor::CRSAPKCS1v15Decryptor(const CRSAPrivateKey& aKey)
+	: iPrivateKey(aKey)
+	{
+	}
+
+CRSAPKCS1v15Decryptor::~CRSAPKCS1v15Decryptor(void)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CRSAPKCS1v15Decryptor::MaxInputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+TInt CRSAPKCS1v15Decryptor::MaxOutputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+void CRSAPKCS1v15Decryptor::DecryptL(const TDesC8& /*aInput*/, TDes8& /*aOutput*/) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+void CRSAPKCS1v15Decryptor::ConstructL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsaencryptor.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,72 @@
+/*
+* Copyright (c) 2003-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 "rsashim.h"
+
+EXPORT_C CRSAPKCS1v15Encryptor* CRSAPKCS1v15Encryptor::NewL(
+	const CRSAPublicKey& aKey)
+	{
+	return CRSAPKCS1v15EncryptorShim::NewL(aKey);
+	}
+
+EXPORT_C CRSAPKCS1v15Encryptor* CRSAPKCS1v15Encryptor::NewLC(
+	const CRSAPublicKey& aKey)
+	{
+	return CRSAPKCS1v15EncryptorShim::NewLC(aKey);
+	}
+
+CRSAPKCS1v15Encryptor::CRSAPKCS1v15Encryptor(const CRSAPublicKey& aKey)
+	: iPublicKey(aKey)
+	{
+	}
+
+CRSAPKCS1v15Encryptor::~CRSAPKCS1v15Encryptor(void)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CRSAPKCS1v15Encryptor::MaxInputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+TInt CRSAPKCS1v15Encryptor::MaxOutputLength() const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+void CRSAPKCS1v15Encryptor::EncryptL(const TDesC8& /*aInput*/, TDes8& /*aOutput*/) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+void CRSAPKCS1v15Encryptor::ConstructL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsakeypairshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,115 @@
+/*
+* Copyright (c) 2007-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 "rsakeypairshim.h"
+#include "cryptokeypairgeneratorapi.h"
+#include "keypair.h"
+#include <cryptospi/cryptoparams.h>
+#include <cryptospi/cryptospidef.h>
+
+using namespace CryptoSpi;
+
+/* CRSAKeyPair */
+
+const TUint KFermat4 = 65537;
+
+CRSAKeyPairShim* CRSAKeyPairShim::NewLC(TUint aModulusBits, TRSAPrivateKeyType aKeyType)
+	{
+	CRSAKeyPairShim* self = new(ELeave) CRSAKeyPairShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aModulusBits, aKeyType, KFermat4);
+	return self;
+	}
+
+CRSAKeyPairShim::~CRSAKeyPairShim(void)
+	{
+	}
+
+CRSAKeyPairShim::CRSAKeyPairShim(void)
+	{
+	}
+
+void CRSAKeyPairShim::ConstructL(TUint aModulusBits, TRSAPrivateKeyType aKeyType, TInt aPublicExponent)
+	{
+	CKeyPairGenerator* keyPairGeneratorImpl=NULL;
+	CKeyPairGeneratorFactory::CreateKeyPairGeneratorL(
+											keyPairGeneratorImpl,
+											KRSAKeyPairGeneratorUid,
+											NULL);
+	CleanupStack::PushL(keyPairGeneratorImpl);
+
+	// put the RSA parameters into an array
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPublicExponent, KRsaKeyParameterEUid);
+	if (aKeyType == EStandard)
+		{
+		keyParameters->AddL(KRsaPrivateKeyStandard, KRsaKeyTypeUid);
+		}
+	else if (aKeyType == EStandardCRT)
+		{
+		keyParameters->AddL(KRsaPrivateKeyCRT, KRsaKeyTypeUid);
+		}
+
+	// call the api to create an RSA key pair
+	CKeyPair* keyPair = 0;
+	keyPairGeneratorImpl->GenerateKeyPairL(aModulusBits, *keyParameters, keyPair);
+	
+	CleanupStack::PushL(keyPair);
+
+	/* 
+	 * Convert the CKeyPair to CRSAPrivateKey{CRT/Standard} and CRSAPublicKey
+	 * The public key becomes the owner of n and e RIntegers
+	 */
+	RInteger n = RInteger::NewL(keyPair->PublicKey().GetBigIntL(KRsaKeyParameterNUid));
+	CleanupClosePushL(n);
+	RInteger e = RInteger::NewL(keyPair->PublicKey().GetBigIntL(KRsaKeyParameterEUid));
+	CleanupClosePushL(e);
+	iPublic = CRSAPublicKey::NewL(n, e);
+
+	if (aKeyType == EStandard)
+		{
+		RInteger n = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterNUid));
+		CleanupClosePushL(n);
+		RInteger d = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterDUid));
+		CleanupClosePushL(d);
+		iPrivate = CRSAPrivateKeyStandard::NewL(n, d);
+		CleanupStack::Pop(2, &n);
+		}
+	else if (aKeyType == EStandardCRT)
+		{
+		RInteger n = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterNUid));
+		CleanupClosePushL(n);
+		RInteger p = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterPUid));
+		CleanupClosePushL(p);
+		RInteger q = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterQUid));
+		CleanupClosePushL(q);
+		RInteger dp = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterDPUid));
+		CleanupClosePushL(p);
+		RInteger dq = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterDQUid));
+		CleanupClosePushL(q);
+		RInteger qinv = RInteger::NewL(keyPair->PrivateKey().GetBigIntL(KRsaKeyParameterQInvUid));
+		CleanupClosePushL(qinv);
+		iPrivate = CRSAPrivateKeyCRT::NewL(n, p, q, dp, dq, qinv);
+		CleanupStack::Pop(6, &n);
+		}
+	/*
+	 * cleanup stack - it should contain keyPairGeneratorImpl, keyParameters, keyPair, n, e
+	 */
+	CleanupStack::Pop(2, &n);
+	CleanupStack::PopAndDestroy(3, keyPairGeneratorImpl);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsakeypairshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,58 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RSAKEYPAIRSHIM_H__
+#define __RSAKEYPAIRSHIM_H__
+
+#include "asymmetrickeys.h"
+
+/** 
+* This class generates an RSA public/private key pair via CryptoSPI
+*/
+
+NONSHARABLE_CLASS(CRSAKeyPairShim) : public CRSAKeyPair
+	{
+public:
+	/**
+	 * Creates a new RSA key pair
+	 */
+	static CRSAKeyPairShim* NewLC(TUint aModulusBits, TRSAPrivateKeyType aKeyType);
+
+	~CRSAKeyPairShim(void);
+
+protected:
+	/** Constructor */
+	CRSAKeyPairShim(void);
+
+	/** 
+	 * 2nd stage constructor
+	 */
+	void ConstructL(TUint aModulusBits, TRSAPrivateKeyType aKeyType, TInt aPublicExponent);
+
+private:
+	CRSAKeyPairShim(const CRSAKeyPairShim&);
+	CRSAKeyPairShim& operator=(const CRSAKeyPairShim&);	
+	};
+
+#endif	//	__RSAKEYPAIRSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsakeys.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,271 @@
+/*
+* Copyright (c) 2003-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 <asymmetrickeys.h>
+#include "rsakeypairshim.h"
+#include "../common/inlines.h"
+
+/* CRSAParameters */
+
+EXPORT_C const TInteger& CRSAParameters::N(void) const
+	{
+	return iN;
+	}
+
+EXPORT_C CRSAParameters::~CRSAParameters(void)
+	{
+	iN.Close();
+	}
+
+EXPORT_C CRSAParameters::CRSAParameters(RInteger& aN) : iN(aN)
+	{
+	}
+
+EXPORT_C CRSAParameters::CRSAParameters(void)
+	{
+	}
+
+/* CRSAPublicKey */
+
+EXPORT_C CRSAPublicKey* CRSAPublicKey::NewL(RInteger& aN, RInteger& aE)
+	{
+	CRSAPublicKey* self = NewLC(aN, aE);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CRSAPublicKey* CRSAPublicKey::NewLC(RInteger& aN, RInteger& aE)
+	{
+	CRSAPublicKey* self = new(ELeave) CRSAPublicKey(aN, aE);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+
+void CRSAPublicKey::ConstructL()
+	{
+	// Check that the modulus and exponent are positive integers 
+	// as specified by RSA
+	if(!N().IsPositive() || !E().IsPositive() || (E() <= 1))
+		{
+		// If we need to leave during construction we must release ownership
+		// of the RInteger parameters that were passed in.
+		// These parameters should be on the cleanup stack so if we don't 
+		// release ownership they will be deleted twice, causing a panic
+		iN = RInteger();
+		iE = RInteger();
+		User::Leave(KErrArgument);
+		}
+	}
+
+
+EXPORT_C const TInteger& CRSAPublicKey::E(void) const
+	{
+	return iE;
+	}
+
+EXPORT_C CRSAPublicKey::CRSAPublicKey()
+	{
+	}
+
+EXPORT_C CRSAPublicKey::CRSAPublicKey(RInteger& aN, RInteger& aE)
+	: CRSAParameters(aN), iE(aE)
+	{
+	}
+
+EXPORT_C CRSAPublicKey::~CRSAPublicKey(void)
+	{
+	iE.Close();
+	}
+
+/* CRSAPrivateKeyType */
+
+CRSAPrivateKey::CRSAPrivateKey(const TRSAPrivateKeyType aKeyType, RInteger& aN)
+:	CRSAParameters(aN), iKeyType(aKeyType)
+{}
+
+
+/* CRSAPrivateKeyStandard */
+
+EXPORT_C CRSAPrivateKeyStandard* CRSAPrivateKeyStandard::NewL(RInteger& aN, 
+	RInteger& aD)
+	{
+	CRSAPrivateKeyStandard* self = NewLC(aN, aD);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CRSAPrivateKeyStandard* CRSAPrivateKeyStandard::NewLC(RInteger& aN,
+	RInteger& aD)
+	{
+	CRSAPrivateKeyStandard* self = new(ELeave) CRSAPrivateKeyStandard(aN, aD);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CRSAPrivateKeyStandard::ConstructL()
+	{
+	// Check that the modulus and exponent are positive integers
+	if(!N().IsPositive() || !D().IsPositive() || (D() <= 1))
+		{
+		// If we need to leave during construction we must release ownership
+		// of the RInteger parameters that were passed in.
+		// These parameters should be on the cleanup stack so if we don't 
+		// release ownership they will be deleted twice, causing a panic
+		iN = RInteger();
+		iD = RInteger();
+		User::Leave(KErrArgument);
+		}
+	}
+
+EXPORT_C const TInteger& CRSAPrivateKeyStandard::D(void) const
+	{
+	return iD;
+	}
+
+EXPORT_C CRSAPrivateKeyStandard::CRSAPrivateKeyStandard(RInteger& aN, 
+	RInteger& aD) : CRSAPrivateKey(EStandard, aN), iD(aD)
+	{
+	}
+
+EXPORT_C CRSAPrivateKeyStandard::~CRSAPrivateKeyStandard()
+	{	
+	iD.Close();
+	}
+
+/* CRSAPrivateKeyCRT */
+
+EXPORT_C CRSAPrivateKeyCRT* CRSAPrivateKeyCRT::NewL(RInteger& aN, RInteger& aP,
+	RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv)
+	{
+	CRSAPrivateKeyCRT* self = NewLC(aN, aP, aQ, aDP, aDQ, aQInv);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CRSAPrivateKeyCRT* CRSAPrivateKeyCRT::NewLC(RInteger& aN, RInteger& aP, 
+	RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv)
+	{
+	CRSAPrivateKeyCRT* self = new(ELeave) CRSAPrivateKeyCRT(aN, aP, aQ, 
+		aDP, aDQ, aQInv);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+EXPORT_C CRSAPrivateKeyCRT::CRSAPrivateKeyCRT(RInteger& aN, RInteger& aP, 
+	RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv) 
+	: CRSAPrivateKey(EStandardCRT, aN), iP(aP), iQ(aQ), iDP(aDP), iDQ(aDQ), 
+		iQInv(aQInv)
+	{
+	}
+
+void CRSAPrivateKeyCRT::ConstructL()
+	{
+	// Check that all parameters are positive integers
+	if(!P().IsPositive() || !Q().IsPositive() || !DP().IsPositive() 
+		|| !DQ().IsPositive() || !QInv().IsPositive())
+		{
+		// If we need to leave during construction we must release ownership
+		// of the RInteger parameters that were passed in.
+		// These parameters should be on the cleanup stack so if we don't 
+		// release ownership they will be deleted twice, causing a panic
+		iN = RInteger();
+		iP = RInteger();
+		iQ = RInteger();
+		iDP = RInteger();
+		iDQ = RInteger();
+		iQInv = RInteger();
+		User::Leave(KErrArgument);
+		}
+	}
+
+
+EXPORT_C CRSAPrivateKeyCRT::~CRSAPrivateKeyCRT()
+	{	
+	iP.Close();
+	iQ.Close();
+	iDP.Close();
+	iDQ.Close();
+	iQInv.Close();
+	}
+
+EXPORT_C const TInteger& CRSAPrivateKeyCRT::P(void) const
+	{
+	return iP;
+	}
+
+EXPORT_C const TInteger& CRSAPrivateKeyCRT::Q(void) const
+	{
+	return iQ;
+	}
+
+EXPORT_C const TInteger& CRSAPrivateKeyCRT::DP(void) const
+	{
+	return iDP;
+	}
+
+EXPORT_C const TInteger& CRSAPrivateKeyCRT::DQ(void) const
+	{
+	return iDQ;
+	}
+
+EXPORT_C const TInteger& CRSAPrivateKeyCRT::QInv(void) const
+	{
+	return iQInv;
+	}
+
+/* CRSAKeyPair */
+
+EXPORT_C CRSAKeyPair* CRSAKeyPair::NewL(TUint aModulusBits, 
+	TRSAPrivateKeyType aKeyType /*= EStandardCRT*/)
+	{
+	CRSAKeyPairShim* self = CRSAKeyPairShim::NewLC(aModulusBits, aKeyType);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CRSAKeyPair* CRSAKeyPair::NewLC(TUint aModulusBits, 
+	TRSAPrivateKeyType aKeyType /*= EStandardCRT*/)
+	{
+	CRSAKeyPairShim* self = CRSAKeyPairShim::NewLC(aModulusBits, aKeyType);
+	return self;
+	}
+
+EXPORT_C const CRSAPublicKey& CRSAKeyPair::PublicKey(void) const
+	{
+	return *iPublic;
+	}
+	
+EXPORT_C const CRSAPrivateKey& CRSAKeyPair::PrivateKey(void) const
+	{
+	return *iPrivate;
+	}
+
+EXPORT_C CRSAKeyPair::~CRSAKeyPair(void)
+	{
+	delete iPublic;
+	delete iPrivate;
+	}
+
+EXPORT_C CRSAKeyPair::CRSAKeyPair(void)
+	{
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsashim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,365 @@
+/*
+* Copyright (c) 2006-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 "rsashim.h"
+#include "cryptoasymmetriccipherapi.h"
+#include "cryptosignatureapi.h"
+#include <cryptospi/cryptospidef.h>
+#include "keyconverter.h"
+#include "keys.h"
+
+#include "../common/inlines.h"
+
+
+using namespace CryptoSpi;
+
+// CRSAPKCS1v15EncryptorShim ////////////////////////////////////////////////////////
+
+CRSAPKCS1v15EncryptorShim* CRSAPKCS1v15EncryptorShim::NewL(const CRSAPublicKey& aKey)
+	{
+	CRSAPKCS1v15EncryptorShim* self = CRSAPKCS1v15EncryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRSAPKCS1v15EncryptorShim* CRSAPKCS1v15EncryptorShim::NewLC(const CRSAPublicKey& aKey)
+	{
+	CRSAPKCS1v15EncryptorShim* self = new (ELeave) CRSAPKCS1v15EncryptorShim(aKey);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CRSAPKCS1v15EncryptorShim::CRSAPKCS1v15EncryptorShim(const CRSAPublicKey& aKey)
+	: CRSAPKCS1v15Encryptor(aKey)
+	{
+	}
+
+CRSAPKCS1v15EncryptorShim::~CRSAPKCS1v15EncryptorShim()
+	{
+	delete iAsymmetricCipherImpl;
+	delete iKey;
+	}
+
+void CRSAPKCS1v15EncryptorShim::ConstructL(const CRSAPublicKey& aKey)
+	{
+	iKey = KeyConverter::CreateKeyL(aKey);
+	CAsymmetricCipherFactory::CreateAsymmetricCipherL(
+												iAsymmetricCipherImpl,
+												KRsaCipherUid,
+												*iKey,
+												KCryptoModeEncryptUid,
+												KPaddingModePkcs1_v1_5_EncryptionUid,
+												NULL);
+	}
+
+void CRSAPKCS1v15EncryptorShim::EncryptL(const TDesC8& aInput, TDes8& aOutput) const
+	{
+	iAsymmetricCipherImpl->ProcessL(aInput, aOutput);
+	}
+
+TInt CRSAPKCS1v15EncryptorShim::MaxInputLength(void) const
+	{
+	TInt maxInputLength=0; 
+	TRAPD(err, maxInputLength=iAsymmetricCipherImpl->GetMaximumInputLengthL())
+	if (err==KErrNone)
+		{
+		return maxInputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+TInt CRSAPKCS1v15EncryptorShim::MaxOutputLength(void) const
+	{
+	TInt maxOutputLength=0; 
+	TRAPD(err, maxOutputLength=iAsymmetricCipherImpl->GetMaximumOutputLengthL())
+	if (err==KErrNone)
+		{
+		return maxOutputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+// CRSAPKCS1v15DecryptorShim ////////////////////////////////////////////////////////
+CRSAPKCS1v15DecryptorShim* CRSAPKCS1v15DecryptorShim::NewL(const CRSAPrivateKey& aKey)
+	{
+	CRSAPKCS1v15DecryptorShim* self = CRSAPKCS1v15DecryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+CRSAPKCS1v15DecryptorShim* CRSAPKCS1v15DecryptorShim::NewLC(const CRSAPrivateKey& aKey)
+	{
+	CRSAPKCS1v15DecryptorShim* self = new (ELeave) CRSAPKCS1v15DecryptorShim(aKey);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CRSAPKCS1v15DecryptorShim::CRSAPKCS1v15DecryptorShim(const CRSAPrivateKey& aKey)
+	: CRSAPKCS1v15Decryptor(aKey)
+	{
+	}
+
+CRSAPKCS1v15DecryptorShim::~CRSAPKCS1v15DecryptorShim()
+	{
+	delete iAsymmetricCipherImpl;
+	delete iKey;
+	}
+
+void CRSAPKCS1v15DecryptorShim::ConstructL(const CRSAPrivateKey& aKey)
+	{
+	iKey = KeyConverter::CreateKeyL(aKey);
+	CAsymmetricCipherFactory::CreateAsymmetricCipherL(
+												iAsymmetricCipherImpl,
+												KRsaCipherUid,
+												*iKey,
+												KCryptoModeDecryptUid,
+												KPaddingModePkcs1_v1_5_EncryptionUid,
+												NULL);
+	}
+
+void CRSAPKCS1v15DecryptorShim::DecryptL(const TDesC8& aInput, TDes8& aOutput) const
+	{
+	iAsymmetricCipherImpl->ProcessL(aInput, aOutput);
+	}
+
+TInt CRSAPKCS1v15DecryptorShim::MaxInputLength(void) const
+	{
+	TInt maxInputLength=0; 
+	TRAPD(err, maxInputLength=iAsymmetricCipherImpl->GetMaximumInputLengthL())
+	if (err==KErrNone)
+		{
+		return maxInputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+TInt CRSAPKCS1v15DecryptorShim::MaxOutputLength(void) const
+	{
+	TInt maxOutputLength=0; 
+	TRAPD(err, maxOutputLength=iAsymmetricCipherImpl->GetMaximumOutputLengthL())
+	if (err==KErrNone)
+		{
+		return maxOutputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+// CRSAPKCS1v15SignerShim ////////////////////////////////////////////////////////
+CRSAPKCS1v15SignerShim* CRSAPKCS1v15SignerShim::NewL(const CRSAPrivateKey& aKey)
+	{
+	CRSAPKCS1v15SignerShim* self = CRSAPKCS1v15SignerShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRSAPKCS1v15SignerShim* CRSAPKCS1v15SignerShim::NewLC(const CRSAPrivateKey& aKey)
+	{
+	CRSAPKCS1v15SignerShim* self = new (ELeave) CRSAPKCS1v15SignerShim(aKey);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CRSASignature* CRSAPKCS1v15SignerShim::SignL(const TDesC8& aInput) const
+	{
+	//Sign the input data
+	CCryptoParams* signature = CCryptoParams::NewLC();
+	iSignerImpl->SignL(aInput, *signature);
+
+	//Retrieve the S in RSA signature from the array
+	const TInteger& cS=signature->GetBigIntL(KRsaSignatureParameterSUid);
+
+	//Make copies of the RSA signature
+	RInteger s=RInteger::NewL(cS);
+	CleanupClosePushL(s);	
+
+	//Create the RSA signature object, the ownership of s is transfered to rsaSig
+	CRSASignature* rsaSig=CRSASignature::NewL(s);
+
+	//Cleanup
+	CleanupStack::Pop(&s);
+	CleanupStack::PopAndDestroy(signature);
+	return rsaSig;
+	}
+
+TInt CRSAPKCS1v15SignerShim::MaxInputLength(void) const
+	{
+	TInt maxInputLength=0; 
+	TRAPD(err, maxInputLength=iSignerImpl->GetMaximumInputLengthL())
+	if (err==KErrNone)
+		{
+		return maxInputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+	
+TInt CRSAPKCS1v15SignerShim::MaxOutputLength(void) const
+	{
+	TInt maxOutputLength=0; 
+	TRAPD(err, maxOutputLength=iSignerImpl->GetMaximumOutputLengthL())
+	if (err==KErrNone)
+		{
+		return maxOutputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+CRSAPKCS1v15SignerShim::~CRSAPKCS1v15SignerShim(void)
+	{
+	delete iSignerImpl;
+	delete iKey;
+	}
+
+CRSAPKCS1v15SignerShim::CRSAPKCS1v15SignerShim(const CRSAPrivateKey& aKey)
+	: CRSAPKCS1v15Signer(aKey)
+	{
+	}
+	
+void CRSAPKCS1v15SignerShim::ConstructL(const CRSAPrivateKey& aKey)
+	{
+	iKey = KeyConverter::CreateKeyL(aKey);
+	CSignatureFactory::CreateSignerL(
+									iSignerImpl,
+									KRsaSignerUid,
+									*iKey,
+									KPaddingModePkcs1_v1_5_SignatureUid,
+									NULL);
+	}
+
+// CRSAPKCS1v15VerifierShim ////////////////////////////////////////////////////////
+CRSAPKCS1v15VerifierShim* CRSAPKCS1v15VerifierShim::NewL(const CRSAPublicKey& aKey)
+	{
+	CRSAPKCS1v15VerifierShim* self = CRSAPKCS1v15VerifierShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRSAPKCS1v15VerifierShim* CRSAPKCS1v15VerifierShim::NewLC(const CRSAPublicKey& aKey)
+	{
+	CRSAPKCS1v15VerifierShim* self = new (ELeave) CRSAPKCS1v15VerifierShim(aKey);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+	
+TBool CRSAPKCS1v15VerifierShim::VerifyL(const TDesC8& aInput, const CRSASignature& aSignature) const
+	{
+	//create the array format rsa signature for the new crypto spi
+	CCryptoParams* rsaSig = CCryptoParams::NewLC();
+
+	rsaSig->AddL(aSignature.S(), KRsaSignatureParameterSUid);
+
+	//pass the signature and input to crypto spi to be verified
+	TBool verificationResult = EFalse;	
+	iVerifierImpl->VerifyL(aInput, *rsaSig, verificationResult);
+
+	//Cleanup the array
+	CleanupStack::PopAndDestroy(rsaSig);
+	return verificationResult;
+	}
+
+HBufC8* CRSAPKCS1v15VerifierShim::InverseSignLC(const CRSASignature& aSignature) const
+	{
+	//create the array format rsa signature for the new crypto spi
+	CCryptoParams* rsaSig = CCryptoParams::NewLC();
+
+	rsaSig->AddL(aSignature.S(), KRsaSignatureParameterSUid);
+
+	//pass the signature and input to crypto spi to be verified
+	HBufC8* output = NULL;
+	iVerifierImpl->InverseSignL(output, *rsaSig);
+
+	//Cleanup the array
+	CleanupStack::PopAndDestroy(rsaSig);
+
+	// leave output on the cleanup stack
+	CleanupStack::PushL(output);
+	return output;
+	}
+
+TInt CRSAPKCS1v15VerifierShim::MaxInputLength(void) const
+	{
+	TInt maxInputLength=0; 
+	TRAPD(err, maxInputLength=iVerifierImpl->GetMaximumInputLengthL())
+	if (err==KErrNone)
+		{
+		return maxInputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+	
+TInt CRSAPKCS1v15VerifierShim::MaxOutputLength(void) const
+	{
+	TInt maxOutputLength=0; 
+	TRAPD(err, maxOutputLength=iVerifierImpl->GetMaximumOutputLengthL())
+	if (err==KErrNone)
+		{
+		return maxOutputLength;
+		}
+	else
+		{
+		return err;
+		}
+	}
+
+CRSAPKCS1v15VerifierShim::~CRSAPKCS1v15VerifierShim(void)
+	{
+	delete iVerifierImpl;
+	delete iKey;
+	}
+
+CRSAPKCS1v15VerifierShim::CRSAPKCS1v15VerifierShim(const CRSAPublicKey& aKey)
+	: CRSAPKCS1v15Verifier(aKey)
+	{
+	}
+
+void CRSAPKCS1v15VerifierShim::ConstructL(const CRSAPublicKey& aKey)
+	{
+	iKey = KeyConverter::CreateKeyL(aKey);
+	CSignatureFactory::CreateVerifierL(
+									iVerifierImpl,
+									KRsaVerifierUid,
+									*iKey,
+									KPaddingModePkcs1_v1_5_SignatureUid,
+									NULL);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsashim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,238 @@
+/*
+* Copyright (c) 2006-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: 
+* RSA shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RSASHIM_H__
+#define __RSASHIM_H__
+
+#include <asymmetric.h>
+
+namespace CryptoSpi
+	{
+	class CAsymmetricCipher;
+	class CKey;
+	class CSigner;
+	class CVerifier;
+	}
+	
+NONSHARABLE_CLASS(CRSAPKCS1v15EncryptorShim) : public CRSAPKCS1v15Encryptor
+{
+public:
+	/**
+	Creates an RSAPKCS1v15EncryptorShim object which has the same interface
+	as CRSAPKCS1v15Encryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The encryption key
+	@return A pointer to a CRSAPKCS1v15EncryptorShim instance
+	*/
+	static CRSAPKCS1v15EncryptorShim* NewL(const CRSAPublicKey& aKey);
+
+	/**
+	Creates an RSAPKCS1v15EncryptorShim object which has the same interface
+	as CRSAPKCS1v15Encryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The encryption key
+	@return A pointer to a CRSAPKCS1v15EncryptorShim instance
+	*/
+	static CRSAPKCS1v15EncryptorShim* NewLC(const CRSAPublicKey& aKey);
+	
+	// From CRSAPKCS1v15Encryptor
+	void EncryptL(const TDesC8& aInput, TDes8& aOutput) const;
+	TInt MaxInputLength(void) const;
+	TInt MaxOutputLength(void) const;
+	
+	/// Destructor
+	~CRSAPKCS1v15EncryptorShim();
+	
+private:
+	/// Constructor
+	CRSAPKCS1v15EncryptorShim(const CRSAPublicKey& aKey);
+	void ConstructL(const CRSAPublicKey& aKey);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CAsymmetricCipher* iAsymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+};
+
+NONSHARABLE_CLASS(CRSAPKCS1v15DecryptorShim) : public CRSAPKCS1v15Decryptor
+{
+public:
+	/**
+	Creates an RSAPKCS1v15DecryptorShim object which has the same interface
+	as CRSAPKCS1v15Decryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The decryption key
+	@return A pointer to a CRSAPKCS1v15DecryptorShim instance
+	*/
+	static CRSAPKCS1v15DecryptorShim* NewL(const CRSAPrivateKey& aKey);
+	
+	/**
+	Creates an RSAPKCS1v15EncryptorShim object which has the same interface
+	as CRSAPKCS1v15Decryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The decryption key
+	@return A pointer to a CRSAPKCS1v15DecryptorShim instance
+	*/
+	static CRSAPKCS1v15DecryptorShim* NewLC(const CRSAPrivateKey& aKey);
+	
+	// From CRSAPKCS1v15Decryptor
+	void DecryptL(const TDesC8& aInput, TDes8& aOutput) const;
+	TInt MaxInputLength(void) const;
+	TInt MaxOutputLength(void) const;
+	
+	/// Destructor
+	~CRSAPKCS1v15DecryptorShim();
+	
+private:
+	/// Constructor
+	CRSAPKCS1v15DecryptorShim(const CRSAPrivateKey& aKey);
+	void ConstructL(const CRSAPrivateKey& aKey);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CAsymmetricCipher* iAsymmetricCipherImpl;
+	
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+};
+
+NONSHARABLE_CLASS(CRSAPKCS1v15SignerShim) : public CRSAPKCS1v15Signer
+	{
+public:
+	/**
+	Creates a new CRSAPKCS1v15SignerShim object which has the same interface
+	as CRSAPKCS1v15Signer but delegates all work to a Crypto SPI plug-in.
+
+	 @param aKey	The RSA private key to be used for signing
+	 @return A pointer to a CRSAPKCS1v15SignerShim instance
+	 @leave KErrKeySize	If the key length is too small
+	 */
+	static CRSAPKCS1v15SignerShim* NewL(const CRSAPrivateKey& aKey);
+
+	/**
+	Creates a new CRSAPKCS1v15SignerShim object which has the same interface
+	as CRSAPKCS1v15Signer but delegates all work to a Crypto SPI plug-in.
+
+	 @param aKey	The RSA private key to be used for signing
+	 @return A pointer to a CRSAPKCS1v15SignerShim instance
+	 @leave KErrKeySize	If the key length is too small
+	 */
+	static CRSAPKCS1v15SignerShim* NewLC(const CRSAPrivateKey& aKey);
+
+	// From CRSAPKCS1v15Signer
+	virtual CRSASignature* SignL(const TDesC8& aInput) const;
+	virtual TInt MaxInputLength(void) const;
+	virtual TInt MaxOutputLength(void) const;
+	/** The destructor frees all resources owned by the object, prior to its destruction.*/
+	~CRSAPKCS1v15SignerShim(void);
+protected:
+	
+	CRSAPKCS1v15SignerShim(const CRSAPrivateKey& aKey);
+	void ConstructL(const CRSAPrivateKey& aKey);
+
+protected:
+	/// SPI delegate
+	CryptoSpi::CSigner* iSignerImpl;
+
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+private:
+	CRSAPKCS1v15SignerShim(const CRSAPKCS1v15SignerShim&);
+	CRSAPKCS1v15SignerShim& operator=(const CRSAPKCS1v15SignerShim&);
+	};
+
+/**
+* This class verifies RSA signatures given a message and its supposed
+* signature.  It follows the RSA PKCS#1 v1.5 with PKCS#1 v1.5 padding specification
+* with the following exception: the VerifyL() function does <b>not</b> hash or
+* in any way manipulate the input data before checking.  Thus in order to verify
+* RSA signatures in PKCS#1 v1.5 format, the input data needs to follow PKCS#1 v1.5 
+* specification, i.e. be ASN.1 encoded and prefixed  by ASN.1 encoded digestId.
+* 
+* @internalComponent
+* @released 
+*/
+NONSHARABLE_CLASS(CRSAPKCS1v15VerifierShim) : public CRSAPKCS1v15Verifier
+	{
+public:
+	/**
+	@internalComponent
+	
+	Creates a new CRSAPKCS1v15VerifierShim object which has the same interface
+	as CRSAPKCS1v15Verifier but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey	The RSA public key to be used for verifying
+	@return A pointer to a CRSAPKCS1v15VerifierShim instance
+	@leave KErrKeySize	If the key length is too small
+	 */
+	static CRSAPKCS1v15VerifierShim* NewL(const CRSAPublicKey& aKey);
+
+	/**
+	@internalComponent
+	
+	Creates a new CRSAPKCS1v15VerifierShim object which has the same interface
+	as CRSAPKCS1v15Verifier but delegates all work to a Crypto SPI plug-in.
+
+	 The returned pointer is put onto the cleanup stack.
+
+	 @param aKey	The RSA public key to be used for verifying
+	 @return A pointer to a CRSAPKCS1v15VerifierShim instance
+
+	 @leave KErrKeySize	If the key length is too small
+	 */
+	static CRSAPKCS1v15VerifierShim* NewLC(const CRSAPublicKey& aKey);
+	
+	// CRSAPKCS1v15Verifier
+	virtual TInt MaxInputLength(void) const;
+	virtual TInt MaxOutputLength(void) const;
+
+	// RSAVerifier
+	virtual TBool VerifyL(const TDesC8& aInput, const CRSASignature& aSignature) const;
+	virtual HBufC8* InverseSignLC(const CRSASignature& aSignature) const;
+
+	/** The destructor frees all resources owned by the object, prior to its destruction. */
+	virtual ~CRSAPKCS1v15VerifierShim(void);
+protected:
+	CRSAPKCS1v15VerifierShim(const CRSAPublicKey& aKey);
+	void ConstructL(const CRSAPublicKey& aKey);
+
+protected:
+	/// SPI delegate
+	CryptoSpi::CVerifier* iVerifierImpl;
+
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+private:
+	CRSAPKCS1v15VerifierShim(const CRSAPKCS1v15VerifierShim&);
+	CRSAPKCS1v15VerifierShim& operator=(const CRSAPKCS1v15VerifierShim&);
+	};
+
+#endif // __RSASHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsasigner.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,78 @@
+/*
+* Copyright (c) 2003-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 "rsashim.h"
+
+/* CRSASigner */
+
+EXPORT_C CRSASigner::CRSASigner(void)
+	{
+	}
+
+/* CRSAPKCS1v15Signer */
+EXPORT_C CRSAPKCS1v15Signer* CRSAPKCS1v15Signer::NewL(const CRSAPrivateKey& aKey)
+	{
+	return CRSAPKCS1v15SignerShim::NewL(aKey);
+	}
+
+EXPORT_C CRSAPKCS1v15Signer* CRSAPKCS1v15Signer::NewLC(const CRSAPrivateKey& aKey)
+	{
+	return CRSAPKCS1v15SignerShim::NewLC(aKey);
+	}
+
+CRSAPKCS1v15Signer::CRSAPKCS1v15Signer(const CRSAPrivateKey& aKey)
+	: iPrivateKey(aKey)
+	{
+	}
+
+CRSAPKCS1v15Signer::~CRSAPKCS1v15Signer(void)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CRSAPKCS1v15Signer::MaxInputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+TInt CRSAPKCS1v15Signer::MaxOutputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+CRSASignature* CRSAPKCS1v15Signer::SignL(const TDesC8& /*aInput*/) const
+	{
+	// Method replaced by shim
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
+
+void CRSAPKCS1v15Signer::ConstructL(void)
+	{
+	// Method replaced by shim
+	User::Leave(KErrNotSupported);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/asymmetric/rsaverifier.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,92 @@
+/*
+* Copyright (c) 2003-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 "rsashim.h"
+
+/* CRSAVerifier */
+
+EXPORT_C CRSAVerifier::CRSAVerifier(void)
+	{
+	}
+
+/* CRSAPKCS1v15Verifier */
+EXPORT_C CRSAPKCS1v15Verifier* CRSAPKCS1v15Verifier::NewL(const CRSAPublicKey& aKey)
+	{
+	return CRSAPKCS1v15VerifierShim::NewL(aKey);
+	}
+
+EXPORT_C CRSAPKCS1v15Verifier* CRSAPKCS1v15Verifier::NewLC(const CRSAPublicKey& aKey)
+	{
+	return CRSAPKCS1v15VerifierShim::NewLC(aKey);
+	}
+
+CRSAPKCS1v15Verifier::~CRSAPKCS1v15Verifier(void)
+	{
+	}
+
+CRSAPKCS1v15Verifier::CRSAPKCS1v15Verifier(const CRSAPublicKey& aKey)
+	: iPublicKey(aKey)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CRSAPKCS1v15Verifier::MaxInputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+TInt CRSAPKCS1v15Verifier::MaxOutputLength(void) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+HBufC8* CRSAPKCS1v15Verifier::InverseSignLC(const CRSASignature& /*aSignature*/) const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+void CRSAPKCS1v15Verifier::ConstructL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+// InverseSignLC is replaced by shim. So, VerifyL also can not be used properly, hence excluded from coverage.
+EXPORT_C TBool CRSAVerifier::VerifyL(const TDesC8& aInput, const CRSASignature& aSignature) const
+	{
+	TBool retval = EFalse;
+	HBufC8* inverseSign = InverseSignLC(aSignature);
+	
+	if (inverseSign->Compare(aInput)==0)
+		{
+		retval = ETrue;
+		}
+	CleanupStack::PopAndDestroy(inverseSign);
+	return retval;	
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/algorithms.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,1160 @@
+/*
+* Copyright (c) 2003-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 "words.h"
+#include "algorithms.h"
+
+word Add(word *C, const word *A, const word *B, unsigned int N)
+{
+	assert (N%2 == 0);
+	word carry = 0;
+	for (unsigned int i = 0; i < N; i+=2)
+	{
+		dword u = (dword) carry + A[i] + B[i];
+		C[i] = LOW_WORD(u);
+		u = (dword) HIGH_WORD(u) + A[i+1] + B[i+1];
+		C[i+1] = LOW_WORD(u);
+		carry = HIGH_WORD(u);
+	}
+	return carry;
+}
+
+word Subtract(word *C, const word *A, const word *B, unsigned int N)
+{
+	assert (N%2 == 0);
+	word borrow=0;
+	for (unsigned i = 0; i < N; i+=2)
+	{
+		dword u = (dword) A[i] - B[i] - borrow;
+		C[i] = LOW_WORD(u);
+		u = (dword) A[i+1] - B[i+1] - (word)(0-HIGH_WORD(u));
+		C[i+1] = LOW_WORD(u);
+		borrow = 0-HIGH_WORD(u);
+	}
+	return borrow;
+}
+
+int Compare(const word *A, const word *B, unsigned int N)
+{
+	while (N--)
+		if (A[N] > B[N])
+			return 1;
+		else if (A[N] < B[N])
+			return -1;
+
+	return 0;
+}
+
+// It is the job of the calling code to ensure that this won't carry.
+// If you aren't sure, use the next version that will tell you if you need to
+// grow your integer.
+// Having two of these creates ever so slightly more code but avoids having
+// ifdefs all over the rest of the code checking the following type stuff which
+// causes warnings in certain compilers about unused parameters in release
+// builds.  We can't have that can we!
+/*
+Allows avoid this all over bigint.cpp and primes.cpp
+ifdef _DEBUG
+	TUint carry = Increment(Ptr(), Size());
+	assert(!carry);
+else
+	Increment(Ptr(), Size())
+endif
+*/
+void IncrementNoCarry(word *A, unsigned int N, word B)
+{
+	assert(N);
+	word t = A[0];
+	A[0] = t+B;
+	if (A[0] >= t)
+		return;
+	for (unsigned i=1; i<N; i++)
+		if (++A[i])
+			return;
+	assert(0);
+}
+
+word Increment(word *A, unsigned int N, word B)
+{
+	assert(N);
+	word t = A[0];
+	A[0] = t+B;
+	if (A[0] >= t)
+		return 0;
+	for (unsigned i=1; i<N; i++)
+		if (++A[i])
+			return 0;
+	return 1;
+}
+
+//See commments above about IncrementNoCarry
+void DecrementNoCarry(word *A, unsigned int N, word B)
+{
+	assert(N);
+	word t = A[0];
+	A[0] = t-B;
+	if (A[0] <= t)
+		return;
+	for (unsigned i=1; i<N; i++)
+		if (A[i]--)
+			return;
+	assert(0);
+}
+
+word Decrement(word *A, unsigned int N, word B)
+{
+	assert(N);
+	word t = A[0];
+	A[0] = t-B;
+	if (A[0] <= t)
+		return 0;
+	for (unsigned i=1; i<N; i++)
+		if (A[i]--)
+			return 0;
+	return 1;
+}
+
+void TwosComplement(word *A, unsigned int N)
+{
+	Decrement(A, N);
+	for (unsigned i=0; i<N; i++)
+		A[i] = ~A[i];
+}
+
+static word LinearMultiply(word *C, const word *A, word B, unsigned int N)
+{
+	word carry=0;
+	for(unsigned i=0; i<N; i++)
+	{
+		dword p = (dword)A[i] * B + carry;
+		C[i] = LOW_WORD(p);
+		carry = HIGH_WORD(p);
+	}
+	return carry;
+}
+
+static void AtomicMultiply(word *C, const word *A, const word *B)
+{
+/*
+	word s;
+	dword d;
+
+	if (A1 >= A0)
+		if (B0 >= B1)
+		{
+			s = 0;
+			d = (dword)(A1-A0)*(B0-B1);
+		}
+		else
+		{
+			s = (A1-A0);
+			d = (dword)s*(word)(B0-B1);
+		}
+	else
+		if (B0 > B1)
+		{
+			s = (B0-B1);
+			d = (word)(A1-A0)*(dword)s;
+		}
+		else
+		{
+			s = 0;
+			d = (dword)(A0-A1)*(B1-B0);
+		}
+*/
+	// this segment is the branchless equivalent of above
+	word D[4] = {A[1]-A[0], A[0]-A[1], B[0]-B[1], B[1]-B[0]};
+	unsigned int ai = A[1] < A[0];
+	unsigned int bi = B[0] < B[1];
+	unsigned int di = ai & bi;
+	dword d = (dword)D[di]*D[di+2];
+	D[1] = D[3] = 0;
+	unsigned int si = ai + !bi;
+	word s = D[si];
+
+	dword A0B0 = (dword)A[0]*B[0];
+	C[0] = LOW_WORD(A0B0);
+
+	dword A1B1 = (dword)A[1]*B[1];
+	dword t = (dword) HIGH_WORD(A0B0) + LOW_WORD(A0B0) + LOW_WORD(d) + LOW_WORD(A1B1);
+	C[1] = LOW_WORD(t);
+
+	t = A1B1 + HIGH_WORD(t) + HIGH_WORD(A0B0) + HIGH_WORD(d) + HIGH_WORD(A1B1) - s;
+	C[2] = LOW_WORD(t);
+	C[3] = HIGH_WORD(t);
+}
+
+static word AtomicMultiplyAdd(word *C, const word *A, const word *B)
+{
+	word D[4] = {A[1]-A[0], A[0]-A[1], B[0]-B[1], B[1]-B[0]};
+	unsigned int ai = A[1] < A[0];
+	unsigned int bi = B[0] < B[1];
+	unsigned int di = ai & bi;
+	dword d = (dword)D[di]*D[di+2];
+	D[1] = D[3] = 0;
+	unsigned int si = ai + !bi;
+	word s = D[si];
+
+	dword A0B0 = (dword)A[0]*B[0];
+	dword t = A0B0 + C[0];
+	C[0] = LOW_WORD(t);
+
+	dword A1B1 = (dword)A[1]*B[1];
+	t = (dword) HIGH_WORD(t) + LOW_WORD(A0B0) + LOW_WORD(d) + LOW_WORD(A1B1) + C[1];
+	C[1] = LOW_WORD(t);
+
+	t = (dword) HIGH_WORD(t) + LOW_WORD(A1B1) + HIGH_WORD(A0B0) + HIGH_WORD(d) + HIGH_WORD(A1B1) - s + C[2];
+	C[2] = LOW_WORD(t);
+
+	t = (dword) HIGH_WORD(t) + HIGH_WORD(A1B1) + C[3];
+	C[3] = LOW_WORD(t);
+	return HIGH_WORD(t);
+}
+
+static inline void AtomicMultiplyBottom(word *C, const word *A, const word *B)
+{
+	dword t = (dword)A[0]*B[0];
+	C[0] = LOW_WORD(t);
+	C[1] = HIGH_WORD(t) + A[0]*B[1] + A[1]*B[0];
+}
+
+#define MulAcc(x, y)								\
+	p = (dword)A[x] * B[y] + c; 					\
+	c = LOW_WORD(p);								\
+	p = (dword)d + HIGH_WORD(p);					\
+	d = LOW_WORD(p);								\
+	e += HIGH_WORD(p);
+
+#define SaveMulAcc(s, x, y) 						\
+	R[s] = c;										\
+	p = (dword)A[x] * B[y] + d; 					\
+	c = LOW_WORD(p);								\
+	p = (dword)e + HIGH_WORD(p);					\
+	d = LOW_WORD(p);								\
+	e = HIGH_WORD(p);
+
+#define MulAcc1(x, y)								\
+	p = (dword)A[x] * A[y] + c; 					\
+	c = LOW_WORD(p);								\
+	p = (dword)d + HIGH_WORD(p);					\
+	d = LOW_WORD(p);								\
+	e += HIGH_WORD(p);
+
+#define SaveMulAcc1(s, x, y) 						\
+	R[s] = c;										\
+	p = (dword)A[x] * A[y] + d; 					\
+	c = LOW_WORD(p);								\
+	p = (dword)e + HIGH_WORD(p);					\
+	d = LOW_WORD(p);								\
+	e = HIGH_WORD(p);
+
+#define SquAcc(x, y)								\
+	p = (dword)A[x] * A[y];	\
+	p = p + p + c; 					\
+	c = LOW_WORD(p);								\
+	p = (dword)d + HIGH_WORD(p);					\
+	d = LOW_WORD(p);								\
+	e += HIGH_WORD(p);
+
+#define SaveSquAcc(s, x, y) 						\
+	R[s] = c;										\
+	p = (dword)A[x] * A[y];	\
+	p = p + p + d; 					\
+	c = LOW_WORD(p);								\
+	p = (dword)e + HIGH_WORD(p);					\
+	d = LOW_WORD(p);								\
+	e = HIGH_WORD(p);
+
+// VC60 workaround: MSVC 6.0 has an optimization problem that makes
+// (dword)A*B where either A or B has been cast to a dword before
+// very expensive. Revisit a CombaSquare4() function when this
+// problem is fixed.               
+
+// WARNING: KeithR.  05/08/03 This routine doesn't work with gcc on hardware
+// either.  I've completely removed it.  It may be worth looking into sometime
+// in the future.
+/*#ifndef __WINS__
+static void CombaSquare4(word *R, const word *A)
+{
+	dword p;
+	word c, d, e;
+
+	p = (dword)A[0] * A[0];
+	R[0] = LOW_WORD(p);
+	c = HIGH_WORD(p);
+	d = e = 0;
+
+	SquAcc(0, 1);
+
+	SaveSquAcc(1, 2, 0);
+	MulAcc1(1, 1);
+
+	SaveSquAcc(2, 0, 3);
+	SquAcc(1, 2);
+
+	SaveSquAcc(3, 3, 1);
+	MulAcc1(2, 2);
+
+	SaveSquAcc(4, 2, 3);
+
+	R[5] = c;
+	p = (dword)A[3] * A[3] + d;
+	R[6] = LOW_WORD(p);
+	R[7] = e + HIGH_WORD(p);
+}
+#endif */
+
+static void CombaMultiply4(word *R, const word *A, const word *B)
+{
+	dword p;
+	word c, d, e;
+
+	p = (dword)A[0] * B[0];
+	R[0] = LOW_WORD(p);
+	c = HIGH_WORD(p);
+	d = e = 0;
+
+	MulAcc(0, 1);
+	MulAcc(1, 0);
+
+	SaveMulAcc(1, 2, 0);
+	MulAcc(1, 1);
+	MulAcc(0, 2);
+
+	SaveMulAcc(2, 0, 3);
+	MulAcc(1, 2);
+	MulAcc(2, 1);
+	MulAcc(3, 0);
+
+	SaveMulAcc(3, 3, 1);
+	MulAcc(2, 2);
+	MulAcc(1, 3);
+
+	SaveMulAcc(4, 2, 3);
+	MulAcc(3, 2);
+
+	R[5] = c;
+	p = (dword)A[3] * B[3] + d;
+	R[6] = LOW_WORD(p);
+	R[7] = e + HIGH_WORD(p);
+}
+
+static void CombaMultiply8(word *R, const word *A, const word *B)
+{
+	dword p;
+	word c, d, e;
+
+	p = (dword)A[0] * B[0];
+	R[0] = LOW_WORD(p);
+	c = HIGH_WORD(p);
+	d = e = 0;
+
+	MulAcc(0, 1);
+	MulAcc(1, 0);
+
+	SaveMulAcc(1, 2, 0);
+	MulAcc(1, 1);
+	MulAcc(0, 2);
+
+	SaveMulAcc(2, 0, 3);
+	MulAcc(1, 2);
+	MulAcc(2, 1);
+	MulAcc(3, 0);
+
+	SaveMulAcc(3, 0, 4);
+	MulAcc(1, 3);
+	MulAcc(2, 2);
+	MulAcc(3, 1);
+	MulAcc(4, 0);
+
+	SaveMulAcc(4, 0, 5);
+	MulAcc(1, 4);
+	MulAcc(2, 3);
+	MulAcc(3, 2);
+	MulAcc(4, 1);
+	MulAcc(5, 0);
+
+	SaveMulAcc(5, 0, 6);
+	MulAcc(1, 5);
+	MulAcc(2, 4);
+	MulAcc(3, 3);
+	MulAcc(4, 2);
+	MulAcc(5, 1);
+	MulAcc(6, 0);
+
+	SaveMulAcc(6, 0, 7);
+	MulAcc(1, 6);
+	MulAcc(2, 5);
+	MulAcc(3, 4);
+	MulAcc(4, 3);
+	MulAcc(5, 2);
+	MulAcc(6, 1);
+	MulAcc(7, 0);
+
+	SaveMulAcc(7, 1, 7);
+	MulAcc(2, 6);
+	MulAcc(3, 5);
+	MulAcc(4, 4);
+	MulAcc(5, 3);
+	MulAcc(6, 2);
+	MulAcc(7, 1);
+
+	SaveMulAcc(8, 2, 7);
+	MulAcc(3, 6);
+	MulAcc(4, 5);
+	MulAcc(5, 4);
+	MulAcc(6, 3);
+	MulAcc(7, 2);
+
+	SaveMulAcc(9, 3, 7);
+	MulAcc(4, 6);
+	MulAcc(5, 5);
+	MulAcc(6, 4);
+	MulAcc(7, 3);
+
+	SaveMulAcc(10, 4, 7);
+	MulAcc(5, 6);
+	MulAcc(6, 5);
+	MulAcc(7, 4);
+
+	SaveMulAcc(11, 5, 7);
+	MulAcc(6, 6);
+	MulAcc(7, 5);
+
+	SaveMulAcc(12, 6, 7);
+	MulAcc(7, 6);
+
+	R[13] = c;
+	p = (dword)A[7] * B[7] + d;
+	R[14] = LOW_WORD(p);
+	R[15] = e + HIGH_WORD(p);
+}
+
+static void CombaMultiplyBottom4(word *R, const word *A, const word *B)
+{
+	dword p;
+	word c, d, e;
+
+	p = (dword)A[0] * B[0];
+	R[0] = LOW_WORD(p);
+	c = HIGH_WORD(p);
+	d = e = 0;
+
+	MulAcc(0, 1);
+	MulAcc(1, 0);
+
+	SaveMulAcc(1, 2, 0);
+	MulAcc(1, 1);
+	MulAcc(0, 2);
+
+	R[2] = c;
+	R[3] = d + A[0] * B[3] + A[1] * B[2] + A[2] * B[1] + A[3] * B[0];
+}
+
+static void CombaMultiplyBottom8(word *R, const word *A, const word *B)
+{
+	dword p;
+	word c, d, e;
+
+	p = (dword)A[0] * B[0];
+	R[0] = LOW_WORD(p);
+	c = HIGH_WORD(p);
+	d = e = 0;
+
+	MulAcc(0, 1);
+	MulAcc(1, 0);
+
+	SaveMulAcc(1, 2, 0);
+	MulAcc(1, 1);
+	MulAcc(0, 2);
+
+	SaveMulAcc(2, 0, 3);
+	MulAcc(1, 2);
+	MulAcc(2, 1);
+	MulAcc(3, 0);
+
+	SaveMulAcc(3, 0, 4);
+	MulAcc(1, 3);
+	MulAcc(2, 2);
+	MulAcc(3, 1);
+	MulAcc(4, 0);
+
+	SaveMulAcc(4, 0, 5);
+	MulAcc(1, 4);
+	MulAcc(2, 3);
+	MulAcc(3, 2);
+	MulAcc(4, 1);
+	MulAcc(5, 0);
+
+	SaveMulAcc(5, 0, 6);
+	MulAcc(1, 5);
+	MulAcc(2, 4);
+	MulAcc(3, 3);
+	MulAcc(4, 2);
+	MulAcc(5, 1);
+	MulAcc(6, 0);
+
+	R[6] = c;
+	R[7] = d + A[0] * B[7] + A[1] * B[6] + A[2] * B[5] + A[3] * B[4] +
+				A[4] * B[3] + A[5] * B[2] + A[6] * B[1] + A[7] * B[0];
+}
+
+#undef MulAcc
+#undef SaveMulAcc
+static void AtomicInverseModPower2(word *C, word A0, word A1)
+{
+	assert(A0%2==1);
+
+	dword A=MAKE_DWORD(A0, A1), R=A0%8;
+
+	for (unsigned i=3; i<2*WORD_BITS; i*=2)
+		R = R*(2-R*A);
+
+	assert(R*A==1);
+
+	C[0] = LOW_WORD(R);
+	C[1] = HIGH_WORD(R);
+}
+// ********************************************************
+
+#define A0		A
+#define A1		(A+N2)
+#define B0		B
+#define B1		(B+N2)
+
+#define T0		T
+#define T1		(T+N2)
+#define T2		(T+N)
+#define T3		(T+N+N2)
+
+#define R0		R
+#define R1		(R+N2)
+#define R2		(R+N)
+#define R3		(R+N+N2)
+
+// R[2*N] - result = A*B
+// T[2*N] - temporary work space
+// A[N] --- multiplier
+// B[N] --- multiplicant
+
+void RecursiveMultiply(word *R, word *T, const word *A, const word *B, unsigned int N)
+{
+	assert(N>=2 && N%2==0);
+
+	if (N==2)
+		AtomicMultiply(R, A, B);
+	else if (N==4)
+		CombaMultiply4(R, A, B);
+	else if (N==8)
+		CombaMultiply8(R, A, B);
+	else
+	{
+		const unsigned int N2 = N/2;
+		int carry;
+
+		int aComp = Compare(A0, A1, N2);
+		int bComp = Compare(B0, B1, N2);
+
+		switch (2*aComp + aComp + bComp)
+		{
+		case -4:
+			Subtract(R0, A1, A0, N2);
+			Subtract(R1, B0, B1, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			Subtract(T1, T1, R0, N2);
+			carry = -1;
+			break;
+		case -2:
+			Subtract(R0, A1, A0, N2);
+			Subtract(R1, B0, B1, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			carry = 0;
+			break;
+		case 2:
+			Subtract(R0, A0, A1, N2);
+			Subtract(R1, B1, B0, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			carry = 0;
+			break;
+		case 4:
+			Subtract(R0, A1, A0, N2);
+			Subtract(R1, B0, B1, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			Subtract(T1, T1, R1, N2);
+			carry = -1;
+			break;
+		default:
+			SetWords(T0, 0, N);
+			carry = 0;
+		}
+
+		RecursiveMultiply(R0, T2, A0, B0, N2);
+		RecursiveMultiply(R2, T2, A1, B1, N2);
+
+		// now T[01] holds (A1-A0)*(B0-B1), R[01] holds A0*B0, R[23] holds A1*B1
+
+		carry += Add(T0, T0, R0, N);
+		carry += Add(T0, T0, R2, N);
+		carry += Add(R1, R1, T0, N);
+
+		assert (carry >= 0 && carry <= 2);
+		Increment(R3, N2, carry);
+	}
+}
+
+// R[2*N] - result = A*A
+// T[2*N] - temporary work space
+// A[N] --- number to be squared
+
+void RecursiveSquare(word *R, word *T, const word *A, unsigned int N)
+{
+	assert(N && N%2==0);
+
+	if (N==2)
+		AtomicMultiply(R, A, A);
+	else if (N==4)
+	{
+		// VC60 workaround: MSVC 6.0 has an optimization problem that makes
+		// (dword)A*B where either A or B has been cast to a dword before
+		// very expensive. Revisit a CombaSquare4() function when this
+		// problem is fixed.               
+
+// WARNING: KeithR. 05/08/03 This routine doesn't work with gcc on hardware
+// either.  I've completely removed it.  It may be worth looking into sometime
+// in the future.  Therefore, we use the CombaMultiply4 on all targets.
+//#ifdef __WINS__
+		CombaMultiply4(R, A, A);
+/*#else
+		CombaSquare4(R, A);
+#endif*/
+	}
+	else
+	{
+		const unsigned int N2 = N/2;
+
+		RecursiveSquare(R0, T2, A0, N2);
+		RecursiveSquare(R2, T2, A1, N2);
+		RecursiveMultiply(T0, T2, A0, A1, N2);
+
+		word carry = Add(R1, R1, T0, N);
+		carry += Add(R1, R1, T0, N);
+		Increment(R3, N2, carry);
+	}
+}
+// R[N] - bottom half of A*B
+// T[N] - temporary work space
+// A[N] - multiplier
+// B[N] - multiplicant
+
+void RecursiveMultiplyBottom(word *R, word *T, const word *A, const word *B, unsigned int N)
+{
+	assert(N>=2 && N%2==0);
+
+	if (N==2)
+		AtomicMultiplyBottom(R, A, B);
+	else if (N==4)
+		CombaMultiplyBottom4(R, A, B);
+	else if (N==8)
+		CombaMultiplyBottom8(R, A, B);
+	else
+	{
+		const unsigned int N2 = N/2;
+
+		RecursiveMultiply(R, T, A0, B0, N2);
+		RecursiveMultiplyBottom(T0, T1, A1, B0, N2);
+		Add(R1, R1, T0, N2);
+		RecursiveMultiplyBottom(T0, T1, A0, B1, N2);
+		Add(R1, R1, T0, N2);
+	}
+}
+
+// R[N] --- upper half of A*B
+// T[2*N] - temporary work space
+// L[N] --- lower half of A*B
+// A[N] --- multiplier
+// B[N] --- multiplicant
+
+void RecursiveMultiplyTop(word *R, word *T, const word *L, const word *A, const word *B, unsigned int N)
+{
+	assert(N>=2 && N%2==0);
+
+	if (N==2)
+	{
+		AtomicMultiply(T, A, B);
+		((dword *)R)[0] = ((dword *)T)[1];
+	}
+	else if (N==4)
+	{
+		CombaMultiply4(T, A, B);
+		((dword *)R)[0] = ((dword *)T)[2];
+		((dword *)R)[1] = ((dword *)T)[3];
+	}
+	else
+	{
+		const unsigned int N2 = N/2;
+		int carry;
+
+		int aComp = Compare(A0, A1, N2);
+		int bComp = Compare(B0, B1, N2);
+
+		switch (2*aComp + aComp + bComp)
+		{
+		case -4:
+			Subtract(R0, A1, A0, N2);
+			Subtract(R1, B0, B1, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			Subtract(T1, T1, R0, N2);
+			carry = -1;
+			break;
+		case -2:
+			Subtract(R0, A1, A0, N2);
+			Subtract(R1, B0, B1, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			carry = 0;
+			break;
+		case 2:
+			Subtract(R0, A0, A1, N2);
+			Subtract(R1, B1, B0, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			carry = 0;
+			break;
+		case 4:
+			Subtract(R0, A1, A0, N2);
+			Subtract(R1, B0, B1, N2);
+			RecursiveMultiply(T0, T2, R0, R1, N2);
+			Subtract(T1, T1, R1, N2);
+			carry = -1;
+			break;
+		default:
+			SetWords(T0, 0, N);
+			carry = 0;
+		}
+
+		RecursiveMultiply(T2, R0, A1, B1, N2);
+
+		// now T[01] holds (A1-A0)*(B0-B1), T[23] holds A1*B1
+
+		CopyWords(R0, L+N2, N2);
+		word c2 = Subtract(R0, R0, L, N2);
+		c2 += Subtract(R0, R0, T0, N2);
+		word t = (Compare(R0, T2, N2) == -1);
+
+		carry += t;
+		carry += Increment(R0, N2, c2+t);
+		carry += Add(R0, R0, T1, N2);
+		carry += Add(R0, R0, T3, N2);
+
+		CopyWords(R1, T3, N2);
+		assert (carry >= 0 && carry <= 2);
+		Increment(R1, N2, carry);
+	}
+}
+
+// R[NA+NB] - result = A*B
+// T[NA+NB] - temporary work space
+// A[NA] ---- multiplier
+// B[NB] ---- multiplicant
+
+void AsymmetricMultiply(word *R, word *T, const word *A, unsigned int NA, const word *B, unsigned int NB)
+{
+	if (NA == NB)
+	{
+		if (A == B)
+			RecursiveSquare(R, T, A, NA);
+		else
+			RecursiveMultiply(R, T, A, B, NA);
+
+		return;
+	}
+
+	if (NA > NB)
+	{
+		TClassSwap(A, B);
+		TClassSwap(NA, NB);
+		//std::swap(A, B);
+		//std::swap(NA, NB);
+	}
+
+	assert(NB % NA == 0);
+	assert((NB/NA)%2 == 0); 	// NB is an even multiple of NA
+
+	if (NA==2 && !A[1])
+	{
+		switch (A[0])
+		{
+		case 0:
+			SetWords(R, 0, NB+2);
+			return;
+		case 1:
+			CopyWords(R, B, NB);
+			R[NB] = R[NB+1] = 0;
+			return;
+		default:
+			R[NB] = LinearMultiply(R, B, A[0], NB);
+			R[NB+1] = 0;
+			return;
+		}
+	}
+
+	RecursiveMultiply(R, T, A, B, NA);
+	CopyWords(T+2*NA, R+NA, NA);
+
+	unsigned i;
+
+	for (i=2*NA; i<NB; i+=2*NA)
+		RecursiveMultiply(T+NA+i, T, A, B+i, NA);
+	for (i=NA; i<NB; i+=2*NA)
+		RecursiveMultiply(R+i, T, A, B+i, NA);
+
+	if (Add(R+NA, R+NA, T+2*NA, NB-NA))
+		Increment(R+NB, NA);
+}
+// R[N] ----- result = A inverse mod 2**(WORD_BITS*N)
+// T[3*N/2] - temporary work space
+// A[N] ----- an odd number as input
+
+void RecursiveInverseModPower2(word *R, word *T, const word *A, unsigned int N)
+{
+	if (N==2)
+		AtomicInverseModPower2(R, A[0], A[1]);
+	else
+	{
+		const unsigned int N2 = N/2;
+		RecursiveInverseModPower2(R0, T0, A0, N2);
+		T0[0] = 1;
+		SetWords(T0+1, 0, N2-1);
+		RecursiveMultiplyTop(R1, T1, T0, R0, A0, N2);
+		RecursiveMultiplyBottom(T0, T1, R0, A1, N2);
+		Add(T0, R1, T0, N2);
+		TwosComplement(T0, N2);
+		RecursiveMultiplyBottom(R1, T1, R0, T0, N2);
+	}
+}
+#undef A0
+#undef A1
+#undef B0
+#undef B1
+
+#undef T0
+#undef T1
+#undef T2
+#undef T3
+
+#undef R0
+#undef R1
+#undef R2
+#undef R3
+
+// R[N] --- result = X/(2**(WORD_BITS*N)) mod M
+// T[3*N] - temporary work space
+// X[2*N] - number to be reduced
+// M[N] --- modulus
+// U[N] --- multiplicative inverse of M mod 2**(WORD_BITS*N)
+
+void MontgomeryReduce(word *R, word *T, const word *X, const word *M, const word *U, unsigned int N)
+{
+	RecursiveMultiplyBottom(R, T, X, U, N);
+	RecursiveMultiplyTop(T, T+N, X, R, M, N);
+	if (Subtract(R, X+N, T, N))
+	{
+#ifdef _DEBUG
+		word carry = Add(R, R, M, N);
+		assert(carry);
+#else
+		Add(R, R, M, N);
+#endif
+	}
+}
+
+// do a 3 word by 2 word divide, returns quotient and leaves remainder in A
+static word SubatomicDivide(word *A, word B0, word B1)
+{
+	// assert {A[2],A[1]} < {B1,B0}, so quotient can fit in a word
+	assert(A[2] < B1 || (A[2]==B1 && A[1] < B0));
+
+	dword p, u;
+	word Q;
+
+	// estimate the quotient: do a 2 word by 1 word divide
+	if (B1+1 == 0)
+		Q = A[2];
+	else
+		Q = word(MAKE_DWORD(A[1], A[2]) / (B1+1));
+
+	// now subtract Q*B from A
+	p = (dword) B0*Q;
+	u = (dword) A[0] - LOW_WORD(p);
+	A[0] = LOW_WORD(u);
+	u = (dword) A[1] - HIGH_WORD(p) - (word)(0-HIGH_WORD(u)) - (dword)B1*Q;
+	A[1] = LOW_WORD(u);
+	A[2] += HIGH_WORD(u);
+
+	// Q <= actual quotient, so fix it
+	while (A[2] || A[1] > B1 || (A[1]==B1 && A[0]>=B0))
+	{
+		u = (dword) A[0] - B0;
+		A[0] = LOW_WORD(u);
+		u = (dword) A[1] - B1 - (word)(0-HIGH_WORD(u));
+		A[1] = LOW_WORD(u);
+		A[2] += HIGH_WORD(u);
+		Q++;
+		assert(Q);	// shouldn't overflow
+	}
+
+	return Q;
+}
+
+// do a 4 word by 2 word divide, returns 2 word quotient in Q0 and Q1
+static inline void AtomicDivide(word *Q, const word *A, const word *B)
+{
+	if (!B[0] && !B[1]) // if divisor is 0, we assume divisor==2**(2*WORD_BITS)
+	{
+		Q[0] = A[2];
+		Q[1] = A[3];
+	}
+	else
+	{
+		word T[4];
+		T[0] = A[0]; T[1] = A[1]; T[2] = A[2]; T[3] = A[3];
+		Q[1] = SubatomicDivide(T+1, B[0], B[1]);
+		Q[0] = SubatomicDivide(T, B[0], B[1]);
+
+#ifdef _DEBUG
+		// multiply quotient and divisor and add remainder, make sure it equals dividend
+		assert(!T[2] && !T[3] && (T[1] < B[1] || (T[1]==B[1] && T[0]<B[0])));
+		word P[4];
+		AtomicMultiply(P, Q, B);
+		Add(P, P, T, 4);
+		assert(Mem::Compare((TUint8*)P, 4*WORD_SIZE, (TUint8*)A, 4*WORD_SIZE)==0);
+#endif
+	}
+}
+
+// for use by Divide(), corrects the underestimated quotient {Q1,Q0}
+static void CorrectQuotientEstimate(word *R, word *T, word *Q, const word *B, unsigned int N)
+{
+	assert(N && N%2==0);
+
+	if (Q[1])
+	{
+		T[N] = T[N+1] = 0;
+		unsigned i;
+		for (i=0; i<N; i+=4)
+			AtomicMultiply(T+i, Q, B+i);
+		for (i=2; i<N; i+=4)
+			if (AtomicMultiplyAdd(T+i, Q, B+i))
+				T[i+5] += (++T[i+4]==0);
+	}
+	else
+	{
+		T[N] = LinearMultiply(T, B, Q[0], N);
+		T[N+1] = 0;
+	}
+
+#ifdef _DEBUG
+	word borrow = Subtract(R, R, T, N+2);
+	assert(!borrow && !R[N+1]);
+#else
+	Subtract(R, R, T, N+2);
+#endif
+
+	while (R[N] || Compare(R, B, N) >= 0)
+	{
+		R[N] -= Subtract(R, R, B, N);
+		Q[1] += (++Q[0]==0);
+		assert(Q[0] || Q[1]); // no overflow
+	}
+}
+
+// R[NB] -------- remainder = A%B
+// Q[NA-NB+2] --- quotient	= A/B
+// T[NA+2*NB+4] - temp work space
+// A[NA] -------- dividend
+// B[NB] -------- divisor
+
+void Divide(word *R, word *Q, word *T, const word *A, unsigned int NA, const word *B, unsigned int NB)
+{
+	assert(NA && NB && NA%2==0 && NB%2==0);
+	assert(B[NB-1] || B[NB-2]);
+	assert(NB <= NA);
+
+	// set up temporary work space
+	word *const TA=T;
+	word *const TB=T+NA+2;
+	word *const TP=T+NA+2+NB;
+
+	// copy B into TB and normalize it so that TB has highest bit set to 1
+	unsigned shiftWords = (B[NB-1]==0);
+	TB[0] = TB[NB-1] = 0;
+	CopyWords(TB+shiftWords, B, NB-shiftWords);
+	unsigned shiftBits = WORD_BITS - BitPrecision(TB[NB-1]);
+	assert(shiftBits < WORD_BITS);
+	ShiftWordsLeftByBits(TB, NB, shiftBits);
+
+	// copy A into TA and normalize it
+	TA[0] = TA[NA] = TA[NA+1] = 0;
+	CopyWords(TA+shiftWords, A, NA);
+	ShiftWordsLeftByBits(TA, NA+2, shiftBits);
+
+	if (TA[NA+1]==0 && TA[NA] <= 1)
+	{
+		Q[NA-NB+1] = Q[NA-NB] = 0;
+		while (TA[NA] || Compare(TA+NA-NB, TB, NB) >= 0)
+		{
+			TA[NA] -= Subtract(TA+NA-NB, TA+NA-NB, TB, NB);
+			++Q[NA-NB];
+		}
+	}
+	else
+	{
+		NA+=2;
+		assert(Compare(TA+NA-NB, TB, NB) < 0);
+	}
+
+	word BT[2];
+	BT[0] = TB[NB-2] + 1;
+	BT[1] = TB[NB-1] + (BT[0]==0);
+
+	// start reducing TA mod TB, 2 words at a time
+	for (unsigned i=NA-2; i>=NB; i-=2)
+	{
+		AtomicDivide(Q+i-NB, TA+i-2, BT);
+		CorrectQuotientEstimate(TA+i-NB, TP, Q+i-NB, TB, NB);
+	}
+
+	// copy TA into R, and denormalize it
+	CopyWords(R, TA+shiftWords, NB);
+	ShiftWordsRightByBits(R, NB, shiftBits);
+}
+
+static inline unsigned int EvenWordCount(const word *X, unsigned int N)
+{
+	while (N && X[N-2]==0 && X[N-1]==0)
+		N-=2;
+	return N;
+}
+
+// return k
+// R[N] --- result = A^(-1) * 2^k mod M
+// T[4*N] - temporary work space
+// A[NA] -- number to take inverse of
+// M[N] --- modulus
+
+unsigned int AlmostInverse(word *R, word *T, const word *A, unsigned int NA, const word *M, unsigned int N)
+{
+	assert(NA<=N && N && N%2==0);
+
+	word *b = T;
+	word *c = T+N;
+	word *f = T+2*N;
+	word *g = T+3*N;
+	unsigned int bcLen=2, fgLen=EvenWordCount(M, N);
+	unsigned int k=0, s=0;
+
+	SetWords(T, 0, 3*N);
+	b[0]=1;
+	CopyWords(f, A, NA);
+	CopyWords(g, M, N);
+
+	FOREVER
+	{
+		word t=f[0];
+		while (!t)
+		{
+			if (EvenWordCount(f, fgLen)==0)
+			{
+				SetWords(R, 0, N);
+				return 0;
+			}
+
+			ShiftWordsRightByWords(f, fgLen, 1);
+			if (c[bcLen-1]) bcLen+=2;
+			assert(bcLen <= N);
+			ShiftWordsLeftByWords(c, bcLen, 1);
+			k+=WORD_BITS;
+			t=f[0];
+		}
+
+		unsigned int i=0;
+		while (t%2 == 0)
+		{
+			t>>=1;
+			i++;
+		}
+		k+=i;
+
+		if (t==1 && f[1]==0 && EvenWordCount(f, fgLen)==2)
+		{
+			if (s%2==0)
+				CopyWords(R, b, N);
+			else
+				Subtract(R, M, b, N);
+			return k;
+		}
+
+		ShiftWordsRightByBits(f, fgLen, i);
+		t=ShiftWordsLeftByBits(c, bcLen, i);
+		if (t)
+		{
+			c[bcLen] = t;
+			bcLen+=2;
+			assert(bcLen <= N);
+		}
+
+		if (f[fgLen-2]==0 && g[fgLen-2]==0 && f[fgLen-1]==0 && g[fgLen-1]==0)
+			fgLen-=2;
+
+		if (Compare(f, g, fgLen)==-1)
+		{
+			TClassSwap<word*>(f,g);
+			TClassSwap<word*>(b,c);
+			s++;
+		}
+
+		Subtract(f, f, g, fgLen);
+
+		if (Add(b, b, c, bcLen))
+		{
+			b[bcLen] = 1;
+			bcLen+=2;
+			assert(bcLen <= N);
+		}
+	}
+}
+
+// R[N] - result = A/(2^k) mod M
+// A[N] - input
+// M[N] - modulus
+
+void DivideByPower2Mod(word *R, const word *A, unsigned int k, const word *M, unsigned int N)
+{
+	CopyWords(R, A, N);
+
+	while (k--)
+	{
+		if (R[0]%2==0)
+			ShiftWordsRightByBits(R, N, 1);
+		else
+		{
+			word carry = Add(R, R, M, N);
+			ShiftWordsRightByBits(R, N, 1);
+			R[N-1] += carry<<(WORD_BITS-1);
+		}
+	}
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/algorithms.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,51 @@
+/*
+* Copyright (c) 2003-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: 
+* Bigint algorithms header file
+*
+*/
+
+
+/**
+ @file 
+ @internalTechnology
+*/
+ 
+#ifndef __ALGORITHMS_H__
+#define __ALGORITHMS_H__
+
+#include "../common/inlines.h"
+
+word Add(word* C, const word* A, const word* B, unsigned int N);
+word Subtract(word* C, const word* A, const word* B, unsigned int N);
+int Compare(const word *A, const word *B, unsigned int N);
+void IncrementNoCarry(word *A, unsigned int N, word B=1);
+word Increment(word *A, unsigned int N, word B=1);
+void DecrementNoCarry(word *A, unsigned int N, word B=1);
+word Decrement(word *A, unsigned int N, word B=1);
+void TwosComplement(word *A, unsigned int N);
+void Divide(word* R, word* Q, word* T, const word* A, unsigned int NA,
+	const word* B, unsigned int NB);
+unsigned int AlmostInverse(word *R, word *T, const word *A, unsigned int NA, 
+	const word *M, unsigned int N);
+void DivideByPower2Mod(word *R, const word *A, unsigned int k, const word *M, 
+	unsigned int N);
+void RecursiveInverseModPower2(word *R, word *T, const word *A, unsigned int N);
+void AsymmetricMultiply(word *R, word *T, const word *A, unsigned int NA, 
+	const word *B, unsigned int NB);
+void MontgomeryReduce(word *R, word *T, const word *X, const word *M, 
+	const word *U, unsigned int N);
+void RecursiveSquare(word *R, word *T, const word *A, unsigned int N);
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/bigint.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,1174 @@
+/*
+* Copyright (c) 2003-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 <random.h>
+#include <bigint.h>
+#include <e32std.h>
+#include <euserext.h>
+#include <securityerr.h>
+#include "words.h"
+#include "algorithms.h"
+#include "windowslider.h"
+#include "stackinteger.h"
+#include "mont.h"
+
+
+/**
+* Creates a new buffer containing the big-endian binary representation of this
+* integer.
+*
+* Note that it does not support the exporting of negative integers.
+*
+* @return	The new buffer.
+* 
+* @leave KErrNegativeExportNotSupported	If this instance is a negative integer.
+*
+*/
+EXPORT_C HBufC8* TInteger::BufferLC() const
+	{
+	if(IsNegative())
+		{
+		User::Leave(KErrNegativeExportNotSupported);
+		}
+	TUint bytes = ByteCount();
+	HBufC8* buf = HBufC8::NewMaxLC(bytes);
+	TUint8* bufPtr = (TUint8*)(buf->Ptr());
+	TUint8* regPtr = (TUint8*)Ptr();
+
+	// we internally store the number little endian, as a string we want it big
+	// endian
+	for(TUint i=0,j=bytes-1; i<bytes; )
+		{
+		bufPtr[i++] = regPtr[j--];
+		}
+	return buf;
+	}
+
+EXPORT_C HBufC8* TInteger::BufferWithNoTruncationLC() const
+ 	{
+ 	if(IsNegative())
+ 		{
+ 		User::Leave(KErrNegativeExportNotSupported);
+ 		}
+ 	
+ 	TUint wordCount = Size();
+ 	TUint bytes = (wordCount)*WORD_SIZE;
+     
+  	HBufC8* buf = HBufC8::NewMaxLC(bytes);
+ 	TUint8* bufPtr = (TUint8*)(buf->Ptr());
+	TUint8* regPtr = (TUint8*)Ptr();
+	for(TUint i=0,j=bytes-1; i<bytes; )
+ 		{
+ 		bufPtr[i++] = regPtr[j--];
+ 		}
+  
+	return buf;
+	}
+
+/** 
+* Gets the number of words required to represent this RInteger.
+* 
+* @return	The size of the integer in words.
+*
+*/
+EXPORT_C TUint TInteger::WordCount() const
+	{
+	return CountWords(Ptr(), Size());
+	}
+
+/**
+* Gets the number of bytes required to represent this RInteger.
+* 
+* @return	The size of the integer in bytes.
+* 
+*/
+EXPORT_C TUint TInteger::ByteCount() const
+	{
+	TUint wordCount = WordCount();
+	if(wordCount)
+		{
+		return (wordCount-1)*WORD_SIZE + BytePrecision((Ptr())[wordCount-1]);
+		}
+	else 
+		{
+		return 0;
+		}
+	}
+
+/** 
+* Get the number of bits required to represent this RInteger.
+* 
+* @return	The size of the integer in bits.
+* 
+*/
+EXPORT_C TUint TInteger::BitCount() const
+	{
+	TUint wordCount = WordCount();
+	if(wordCount)
+		{
+		return (wordCount-1)*WORD_BITS + BitPrecision(Ptr()[wordCount-1]);
+		}
+	else 
+		{
+		return 0;
+		}
+	}
+
+
+//These 3 declarations instantiate a constant 0, 1, 2 for ease of use and
+//quick construction elsewhere in the code.  Note that the functions
+//returning references to this static data return const references as you can't
+//modify the ROM ;)
+//word 0: Size of storage in words
+//word 1: Pointer to storage
+//word 2: LSW of storage
+//word 3: MSW of storage
+//Note that the flag bits in word 1 (Ptr()) are zero in the case of a positive
+//stack based integer (SignBit == 0, IsHeapBasedBit == 0)
+const TUint KBigintZero[4] = {2, (TUint)(KBigintZero+2), 0, 0};
+const TUint KBigintOne[4] = {2, (TUint)(KBigintOne+2), 1, 0};
+const TUint KBigintTwo[4] = {2, (TUint)(KBigintTwo+2), 2, 0};
+
+/** 
+ * Gets the TInteger that represents zero
+ *
+ * @return	The TInteger representing zero
+ */
+EXPORT_C const TInteger& TInteger::Zero(void)
+	{
+	return *reinterpret_cast<const TStackInteger64*>(KBigintZero);
+	}
+
+/** 
+ * Gets the TInteger that represents one
+ *
+ * @return	The TInteger representing one
+ */
+EXPORT_C const TInteger& TInteger::One(void)
+	{
+	return *reinterpret_cast<const TStackInteger64*>(KBigintOne);
+	}
+	
+/** 
+ * Gets the TInteger that represents two
+ *
+ * @return	The TInteger representing two
+ */
+EXPORT_C const TInteger& TInteger::Two(void)
+	{
+	return *reinterpret_cast<const TStackInteger64*>(KBigintTwo);
+	}
+
+EXPORT_C RInteger TInteger::PlusL(const TInteger& aOperand) const
+	{
+	RInteger sum;
+    if (NotNegative())
+		{
+        if (aOperand.NotNegative())
+            sum = PositiveAddL(*this, aOperand);
+        else
+            sum = PositiveSubtractL(*this, aOperand);
+		}
+    else
+		{
+        if (aOperand.NotNegative())
+            sum = PositiveSubtractL(aOperand, *this);
+        else
+			{
+            sum = PositiveAddL(*this, aOperand);
+			sum.SetSign(TInteger::ENegative);
+			}
+		}
+	return sum;
+	}
+
+EXPORT_C RInteger TInteger::MinusL(const TInteger& aOperand) const
+	{
+	RInteger diff;
+    if (NotNegative())
+		{
+        if (aOperand.NotNegative())
+            diff = PositiveSubtractL(*this, aOperand);
+        else
+            diff = PositiveAddL(*this, aOperand);
+		}
+    else
+		{
+        if (aOperand.NotNegative())
+			{
+            diff = PositiveAddL(*this, aOperand);
+			diff.SetSign(TInteger::ENegative);
+			}
+        else
+            diff = PositiveSubtractL(aOperand, *this);
+		}
+	return diff;
+	}
+
+EXPORT_C RInteger TInteger::TimesL(const TInteger& aOperand) const
+	{
+	RInteger product = PositiveMultiplyL(*this, aOperand);
+
+	if (NotNegative() != aOperand.NotNegative())
+		{
+		product.Negate();
+		}
+	return product;
+	}
+
+EXPORT_C RInteger TInteger::DividedByL(const TInteger& aOperand) const
+	{
+	RInteger quotient;
+	RInteger remainder;
+	DivideL(remainder, quotient, *this, aOperand);
+	remainder.Close();
+	return quotient;
+	}
+
+EXPORT_C RInteger TInteger::ModuloL(const TInteger& aOperand) const
+	{
+	RInteger remainder;
+	RInteger quotient;
+	DivideL(remainder, quotient, *this, aOperand);
+	quotient.Close();
+	return remainder;
+	}
+
+EXPORT_C TUint TInteger::ModuloL(TUint aOperand) const
+	{
+	if(!aOperand)
+		{
+		User::Leave(KErrDivideByZero);
+		}
+	return Modulo(*this, aOperand);
+	}
+
+EXPORT_C RInteger TInteger::ModularMultiplyL(const TInteger& aA, const TInteger& aB,
+	const TInteger& aMod) 
+	{
+	RInteger product = aA.TimesL(aB);
+	CleanupStack::PushL(product);
+	RInteger reduced = product.ModuloL(aMod);
+	CleanupStack::PopAndDestroy(&product); 
+	return reduced;
+	}
+
+EXPORT_C RInteger TInteger::ModularExponentiateL(const TInteger& aBase, 
+	const TInteger& aExp, const TInteger& aMod) 
+	{
+	CMontgomeryStructure* mont = CMontgomeryStructure::NewLC(aMod);
+	RInteger result = RInteger::NewL(mont->ExponentiateL(aBase, aExp));
+	CleanupStack::PopAndDestroy(mont);
+	return result;
+	}
+
+EXPORT_C RInteger TInteger::GCDL(const TInteger& aOperand) const
+	{
+	//Binary GCD algorithm -- see HAC 14.4.1
+	//with a slight variation -- our g counts shifts rather than actually
+	//shifting.  We then do one shift at the end.
+	assert(NotNegative());
+	assert(aOperand.NotNegative());
+
+	RInteger x = RInteger::NewL(*this);
+	CleanupStack::PushL(x);
+	RInteger y = RInteger::NewL(aOperand);
+	CleanupStack::PushL(y);
+
+	// 1 Ensure x >= y
+	if( x < y )
+		{
+		TClassSwap(x, y);
+		}
+
+	TUint g = 0;
+	// 2 while x and y even x <- x/2, y <- y/2
+	while( x.IsEven() && y.IsEven() )
+		{
+		x >>= 1;
+		y >>= 1;
+		++g;
+		}
+	// 3 while x != 0
+	while( x.NotZero() )
+		{
+		// 3.1 while x even x <- x/2
+		while( x.IsEven() )
+			{
+			x >>= 1;
+			}
+		// 3.2 while y even y <- y/2
+		while( y.IsEven() )
+			{
+			y >>= 1;
+			}
+		// 3.3 t <- abs(x-y)/2
+		RInteger t = x.MinusL(y);
+		t >>= 1;
+		t.SetSign(TInteger::EPositive);
+
+		// 3.4 If x>=y then x <- t else y <- t
+		if( x >= y )
+			{
+			x.Set(t);
+			}
+		else 
+			{
+			y.Set(t);
+			}
+		}
+	
+	// 4 Return (g*y) (equiv to y<<=g as our g was counting shifts not actually
+	//shifting)
+	y <<= g;
+	CleanupStack::Pop(&y);
+	CleanupStack::PopAndDestroy(&x); 
+	return y;
+	}
+
+EXPORT_C RInteger TInteger::InverseModL(const TInteger& aMod) const
+	{
+	assert(aMod.NotNegative());
+
+	RInteger result;
+	if(IsNegative() || *this>=aMod)
+		{
+		RInteger temp = ModuloL(aMod);
+		CleanupClosePushL(temp);
+		result = temp.InverseModL(aMod);
+		CleanupStack::PopAndDestroy(&temp);
+		return result;
+		}
+
+	if(aMod.IsEven())
+		{
+		if( !aMod || IsEven() )
+			{
+			return RInteger::NewL(Zero());
+			}
+		if( *this == One() )
+			{
+			return RInteger::NewL(One());
+			}
+		RInteger u = aMod.InverseModL(*this); 
+		CleanupClosePushL(u);
+		if(!u)
+			{
+			result = RInteger::NewL(Zero());
+			}
+		else 
+			{
+			//calculates (aMod*(*this-u)+1)/(*this) 
+			result = MinusL(u);
+			CleanupClosePushL(result);
+			result *= aMod;
+			++result;
+			result /= *this;
+			CleanupStack::Pop(&result); 
+			}
+		CleanupStack::PopAndDestroy(&u);
+		return result;
+		}
+
+	result = RInteger::NewEmptyL(aMod.Size());
+	CleanupClosePushL(result);
+	RInteger workspace = RInteger::NewEmptyL(aMod.Size() * 4);
+	TUint k = AlmostInverse(result.Ptr(), workspace.Ptr(), Ptr(), Size(),
+		aMod.Ptr(), aMod.Size());
+	DivideByPower2Mod(result.Ptr(), result.Ptr(), k, aMod.Ptr(), aMod.Size());
+	workspace.Close();
+	CleanupStack::Pop(&result);
+
+	return result;
+	}
+
+EXPORT_C TInteger& TInteger::operator+=(const TInteger& aOperand)
+	{
+	this->Set(PlusL(aOperand));
+    return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator-=(const TInteger& aOperand)
+	{
+	this->Set(MinusL(aOperand));
+    return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator*=(const TInteger& aOperand)
+	{
+	this->Set(TimesL(aOperand));
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator/=(const TInteger& aOperand)
+	{
+	this->Set(DividedByL(aOperand));
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator%=(const TInteger& aOperand)
+	{
+	this->Set(ModuloL(aOperand));
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator+=(TInt aOperand)
+	{
+	TStackInteger64 operand(aOperand);
+	*this += operand;
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator-=(TInt aOperand)
+	{
+	TStackInteger64 operand(aOperand);
+	*this -= operand;
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator*=(TInt aOperand)
+	{
+	TStackInteger64 operand(aOperand);
+	*this *= operand;
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator--()
+	{
+    if (IsNegative())
+		{
+        if (Increment(Ptr(), Size()))
+			{
+            CleanGrowL(2*Size());
+            (Ptr())[Size()/2]=1;
+			}
+		}
+    else
+		{
+        if (Decrement(Ptr(), Size()))
+			{
+			this->CopyL(-1);
+			}
+		}
+    return *this;	
+	}
+
+EXPORT_C TInteger& TInteger::operator++()
+	{
+	if(NotNegative())
+		{
+		if(Increment(Ptr(), Size()))
+			{
+			CleanGrowL(2*Size());
+			(Ptr())[Size()/2]=1;
+			}
+		}
+	else
+		{
+		DecrementNoCarry(Ptr(), Size());
+		if(WordCount()==0)
+			{
+			this->CopyL(Zero());
+			}
+		}
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator <<=(TUint aBits)
+	{
+	const TUint wordCount = WordCount();
+	const TUint shiftWords = aBits / WORD_BITS;
+	const TUint shiftBits = aBits % WORD_BITS;
+
+	CleanGrowL(wordCount+BitsToWords(aBits));
+	ShiftWordsLeftByWords(Ptr(), wordCount + shiftWords, shiftWords);
+	ShiftWordsLeftByBits(Ptr()+shiftWords, wordCount + BitsToWords(shiftBits), 
+		shiftBits);
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator >>=(TUint aBits)
+	{
+	const TUint wordCount = WordCount();
+	const TUint shiftWords = aBits / WORD_BITS;
+	const TUint shiftBits = aBits % WORD_BITS;
+
+	ShiftWordsRightByWords(Ptr(), wordCount, shiftWords);
+	if(wordCount > shiftWords)
+		{
+		ShiftWordsRightByBits(Ptr(), wordCount - shiftWords, shiftBits);
+		}
+	if(IsNegative() && WordCount()==0) // avoid negative 0
+		{
+		SetSign(EPositive);
+		}
+	return *this;
+	}
+
+EXPORT_C TInt TInteger::UnsignedCompare(const TInteger& aThat) const
+	{
+	TUint size = WordCount();
+	TUint thatSize = aThat.WordCount();
+
+	if( size == thatSize )
+		return Compare(Ptr(), aThat.Ptr(), size);
+	else
+		return size > thatSize ? 1 : -1;
+	}
+
+EXPORT_C TInt TInteger::SignedCompare(const TInteger& aThat) const
+	{
+    if (NotNegative())
+		{
+        if (aThat.NotNegative())
+            return UnsignedCompare(aThat);
+        else
+            return 1;
+		}
+    else
+		{
+        if (aThat.NotNegative())
+            return -1;
+        else
+            return -UnsignedCompare(aThat);
+		}
+	}
+
+EXPORT_C TBool TInteger::operator!() const
+	{
+	//Ptr()[0] is just a quick way of weeding out non-zero numbers without
+	//doing a full WordCount() == 0.  Very good odds that a non-zero number
+	//will have a bit set in the least significant word
+	return IsNegative() ? EFalse : (Ptr()[0]==0 && WordCount()==0);
+	}
+
+EXPORT_C TInt TInteger::SignedCompare(TInt aInteger) const
+	{
+	TStackInteger64 temp(aInteger);
+	return SignedCompare(temp);
+	}
+
+/* TBool IsPrimeL(void) const 
+ * and all primality related functions are implemented in primes.cpp */
+
+EXPORT_C TBool TInteger::Bit(TUint aBitPos) const
+	{
+	if( aBitPos/WORD_BITS >= Size() )
+		{
+		return 0;
+		}
+	else 
+		{
+		return (((Ptr())[aBitPos/WORD_BITS] >> (aBitPos % WORD_BITS)) & 1);
+		}
+	}
+
+EXPORT_C void TInteger::SetBit(TUint aBitPos) 
+	{
+	if( aBitPos/WORD_BITS < Size() )
+		{
+		ArraySetBit(Ptr(), aBitPos);
+		}
+	}
+
+EXPORT_C void TInteger::Negate() 
+	{
+	if(!!(*this)) //don't flip sign if *this==0
+		{
+		SetSign(TSign((~Sign())&KSignMask));
+		}
+	}
+
+EXPORT_C void TInteger::CopyL(const TInteger& aInteger, TBool aAllowShrink)
+	{
+	if(aAllowShrink)
+		{
+		CleanResizeL(aInteger.Size());
+		}
+	else
+		{
+		CleanGrowL(aInteger.Size());
+		}
+	Construct(aInteger);
+	}
+
+EXPORT_C void TInteger::CopyL(TInt aInteger, TBool aAllowShrink)
+	{
+	if(aAllowShrink)
+		{
+		CleanResizeL(2);
+		}
+	else
+		{
+		CleanGrowL(2);
+		}
+	Construct(aInteger);
+	}
+
+EXPORT_C void TInteger::Set(const RInteger& aInteger)
+	{
+	assert(IsHeapBased());
+	Mem::FillZ(Ptr(), WordsToBytes(Size()));
+	User::Free(Ptr());
+	iPtr = aInteger.iPtr;
+	iSize = aInteger.iSize;
+	}
+
+RInteger TInteger::PositiveAddL(const TInteger &aA, const TInteger& aB) const
+	{
+	RInteger sum = RInteger::NewEmptyL(CryptoMax(aA.Size(), aB.Size()));
+	const word aSize = aA.Size();
+	const word bSize = aB.Size();
+	const word* const aReg = aA.Ptr();
+	const word* const bReg = aB.Ptr();
+	word* const sumReg = sum.Ptr();
+
+	word carry;
+	if (aSize == bSize)
+		carry = Add(sumReg, aReg, bReg, aSize);
+	else if (aSize > bSize)
+		{
+		carry = Add(sumReg, aReg, bReg, bSize);
+		CopyWords(sumReg+bSize, aReg+bSize, aSize-bSize);
+		carry = Increment(sumReg+bSize, aSize-bSize, carry);
+		}
+	else
+		{
+		carry = Add(sumReg, aReg, bReg, aSize);
+		CopyWords(sumReg+aSize, bReg+aSize, bSize-aSize);
+		carry = Increment(sumReg+aSize, bSize-aSize, carry);
+		}
+
+	if (carry)
+		{
+		CleanupStack::PushL(sum);
+		sum.CleanGrowL(2*sum.Size());
+		CleanupStack::Pop(&sum);
+		sum.Ptr()[sum.Size()/2] = 1;
+		}
+	sum.SetSign(TInteger::EPositive);
+	return sum;
+	}
+
+RInteger TInteger::PositiveSubtractL(const TInteger &aA, const TInteger& aB) const
+	{
+	RInteger diff = RInteger::NewEmptyL(CryptoMax(aA.Size(), aB.Size()));
+	unsigned aSize = aA.WordCount();
+	aSize += aSize%2;
+	unsigned bSize = aB.WordCount();
+	bSize += bSize%2;
+	const word* const aReg = aA.Ptr();
+	const word* const bReg = aB.Ptr();
+	word* const diffReg = diff.Ptr();
+
+	if (aSize == bSize)
+		{
+		if (Compare(aReg, bReg, aSize) >= 0)
+			{
+			Subtract(diffReg, aReg, bReg, aSize);
+			diff.SetSign(TInteger::EPositive);
+			}
+		else
+			{
+			Subtract(diffReg, bReg, aReg, aSize);
+			diff.SetSign(TInteger::ENegative);
+			}
+		}
+	else if (aSize > bSize)
+		{
+		word borrow = Subtract(diffReg, aReg, bReg, bSize);
+		CopyWords(diffReg+bSize, aReg+bSize, aSize-bSize);
+		borrow = Decrement(diffReg+bSize, aSize-bSize, borrow);
+		assert(!borrow);
+		diff.SetSign(TInteger::EPositive);
+		}
+	else
+		{
+		word borrow = Subtract(diffReg, bReg, aReg, aSize);
+		CopyWords(diffReg+aSize, bReg+aSize, bSize-aSize);
+		borrow = Decrement(diffReg+aSize, bSize-aSize, borrow);
+		assert(!borrow);
+		diff.SetSign(TInteger::ENegative);
+		}
+	return diff;
+	}
+
+RInteger TInteger::PositiveMultiplyL(const TInteger &aA, const TInteger &aB) const
+	{
+	unsigned aSize = RoundupSize(aA.WordCount());
+	unsigned bSize = RoundupSize(aB.WordCount());
+
+	RInteger product = RInteger::NewEmptyL(aSize+bSize);
+	CleanupClosePushL(product);
+
+	RInteger workspace = RInteger::NewEmptyL(aSize + bSize);
+	AsymmetricMultiply(product.Ptr(), workspace.Ptr(), aA.Ptr(), aSize, aB.Ptr(), 
+		bSize);
+	workspace.Close();
+	CleanupStack::Pop(&product);
+	return product;
+	}
+
+TUint TInteger::Modulo(const TInteger& aDividend, TUint aDivisor) const
+	{
+	assert(aDivisor);
+	TUint i = aDividend.WordCount();
+	TUint remainder = 0;
+	while(i--)
+		{
+		remainder = TUint(MAKE_DWORD(aDividend.Ptr()[i], remainder) % aDivisor);
+		}
+	return remainder;
+	}
+
+void TInteger::PositiveDivideL(RInteger &aRemainder, RInteger &aQuotient,
+	const TInteger &aDividend, const TInteger &aDivisor) const
+	{
+	unsigned dividendSize = aDividend.WordCount();
+	unsigned divisorSize = aDivisor.WordCount();
+
+	if (!divisorSize)
+		{
+		User::Leave(KErrDivideByZero);
+		}
+
+	if (aDividend.UnsignedCompare(aDivisor) == -1)
+		{
+		aRemainder.CreateNewL(aDividend.Size());
+		CleanupStack::PushL(aRemainder);
+		aRemainder.CopyL(aDividend); //set remainder to a
+		aRemainder.SetSign(TInteger::EPositive);
+		aQuotient.CleanNewL(2); //Set quotient to zero
+		CleanupStack::Pop(&aRemainder);
+		return;
+		}
+
+	dividendSize += dividendSize%2;	// round up to next even number
+	divisorSize += divisorSize%2;
+
+	aRemainder.CleanNewL(divisorSize);
+	CleanupStack::PushL(aRemainder);
+	aQuotient.CleanNewL(dividendSize-divisorSize+2);
+	CleanupStack::PushL(aQuotient);
+
+	RInteger T = RInteger::NewEmptyL(dividendSize+2*divisorSize+4);
+	Divide(aRemainder.Ptr(), aQuotient.Ptr(), T.Ptr(), aDividend.Ptr(), 
+		dividendSize, aDivisor.Ptr(), divisorSize);
+	T.Close();
+	CleanupStack::Pop(2, &aRemainder); //aQuotient, aRemainder
+	}
+
+void TInteger::DivideL(RInteger& aRemainder, RInteger& aQuotient, 
+	const TInteger& aDividend, const TInteger& aDivisor) const
+    {
+    PositiveDivideL(aRemainder, aQuotient, aDividend, aDivisor);
+
+    if (aDividend.IsNegative())
+        {
+        aQuotient.Negate();
+        if (aRemainder.NotZero())
+            {
+            --aQuotient;
+			assert(aRemainder.Size() <= aDivisor.Size());
+			Subtract(aRemainder.Ptr(), aDivisor.Ptr(), aRemainder.Ptr(), 
+				aRemainder.Size());
+            }
+        }
+
+    if (aDivisor.IsNegative())
+        aQuotient.Negate();
+    }
+
+void TInteger::RandomizeL(TUint aBits, TRandomAttribute aAttr)
+	{
+	if(!aBits)
+		{
+		return;
+		}
+	const TUint bytes = BitsToBytes(aBits);
+	const TUint words = BitsToWords(aBits);
+	CleanGrowL(words);
+	TPtr8 buf((TUint8*)(Ptr()), bytes, WordsToBytes(Size()));
+	TUint bitpos = aBits % BYTE_BITS;
+	GenerateRandomBytesL(buf);
+	//mask with 0 all bits above the num requested in the most significant byte
+	if(bitpos)
+		{
+		buf[bytes-1] = TUint8( buf[bytes-1] & ((1L << bitpos) - 1) );
+		}
+	//set most significant (top) bit 
+	if(aAttr == ETopBitSet || aAttr == ETop2BitsSet)
+		{
+		SetBit(aBits-1); //Set bit counts from 0
+		assert(BitCount() == aBits);
+		assert(Bit(aBits-1));
+		}
+	//set 2nd bit from top
+	if(aAttr == ETop2BitsSet)
+		{
+		SetBit(aBits-2); //Set bit counts from 0
+		assert(BitCount() == aBits);
+		assert(Bit(aBits-1));
+		assert(Bit(aBits-2));
+		}
+	}
+
+void TInteger::RandomizeL(const TInteger& aMin, const TInteger& aMax)
+	{
+	assert(aMax > aMin);
+	assert(aMin.NotNegative());
+	RInteger range = RInteger::NewL(aMax);
+	CleanupStack::PushL(range);
+	range -= aMin;
+	const TUint bits = range.BitCount();
+
+	//if we find a number < range then aMin+range < aMax 
+	do
+		{
+		RandomizeL(bits, EAllBitsRandom);
+		} 
+	while(*this > range);
+
+	*this += aMin;
+	CleanupStack::PopAndDestroy(&range);
+	}
+
+/* void PrimeRandomizeL(TUint aBits, TRandomAttribute aAttr)
+ * and all primality related functions are implemented in primes.cpp */
+
+void TInteger::CreateNewL(TUint aNewSize)
+	{
+	//should only be called on construction
+	assert(!iPtr);
+	
+	TUint newSize = RoundupSize(aNewSize);
+	SetPtr((TUint*)User::AllocL(WordsToBytes(newSize)));
+	SetSize(newSize);
+	SetHeapBased();
+	}
+
+void TInteger::CleanNewL(TUint aNewSize)
+	{
+	CreateNewL(aNewSize);
+	Mem::FillZ(Ptr(), WordsToBytes(Size())); //clear integer storage
+	}
+
+void TInteger::CleanGrowL(TUint aNewSize)
+	{
+	assert(IsHeapBased());
+	TUint newSize = RoundupSize(aNewSize);
+	TUint oldSize = Size();
+	if(newSize > oldSize)
+		{
+		TUint* oldPtr = Ptr();
+		//1) allocate new memory and set ptr and size
+		SetPtr((TUint*)User::AllocL(WordsToBytes(newSize)));
+		SetSize(newSize);
+		//2) copy old mem to new mem
+		Mem::Copy(Ptr(), oldPtr, WordsToBytes(oldSize));
+		//3) zero all old memory
+		Mem::FillZ(oldPtr, WordsToBytes(oldSize));
+		//4) give back old memory
+		User::Free(oldPtr);
+		//5) zero new memory from end of copy to end of growth
+		Mem::FillZ(Ptr() + oldSize, WordsToBytes(newSize-oldSize));
+		}
+	}
+
+void TInteger::CleanResizeL(TUint aNewSize)
+	{
+	assert(IsHeapBased());
+	TUint newSize = RoundupSize(aNewSize);
+	TUint oldSize = Size();
+	if(newSize > oldSize)
+		{
+		CleanGrowL(aNewSize);
+		}
+	else if(newSize < oldSize)
+		{
+		TUint* oldPtr = Ptr();
+		//1) zero memory above newsize
+		Mem::FillZ(oldPtr+WordsToBytes(aNewSize),WordsToBytes(oldSize-newSize));
+		//2) ReAlloc cell.  Since our newsize is less than oldsize, it is
+		//guarenteed not to move.  Thus this is just freeing part of our old
+		//cell to the heap for other uses.
+		SetPtr((TUint*)User::ReAllocL(Ptr(), WordsToBytes(newSize)));
+		SetSize(newSize);
+		}
+	}
+
+EXPORT_C TInteger::TInteger() : iSize(0), iPtr(0)
+	{
+	}
+
+void TInteger::Construct(const TDesC8& aValue)
+	{
+	assert(Size() >= BytesToWords(aValue.Size()));
+	if(aValue.Size() > 0)
+		{
+		//People write numbers with the most significant digits first (big
+		//endian) but we store our numbers in little endian.  Hence we need to
+		//reverse the string by bytes.
+
+		TUint bytes = aValue.Size();
+		TUint8* i = (TUint8*)Ptr();
+		TUint8* j = (TUint8*)aValue.Ptr() + bytes;
+
+		//Swap the endianess of the number itself
+		// (msb) 01 02 03 04 05 06 (lsb) becomes ->
+		// (lsb) 06 05 04 03 02 01 (msb)
+		while( j != (TUint8*)aValue.Ptr() )
+			{
+			*i++ = *--j;
+			}
+		Mem::FillZ((TUint8*)Ptr() + bytes, WordsToBytes(Size()) - bytes);
+		}
+	else
+		{
+		//if size is zero, we zero the whole register
+		Mem::FillZ((TUint8*)Ptr(), WordsToBytes(Size()));
+		}
+	SetSign(EPositive);
+	}
+
+void TInteger::Construct(const TInteger& aInteger)
+	{
+	assert(Size() >= aInteger.Size());
+	CopyWords(Ptr(), aInteger.Ptr(), aInteger.Size());
+	if(Size() > aInteger.Size())
+		{
+		Mem::FillZ(Ptr()+aInteger.Size(), WordsToBytes(Size()-aInteger.Size()));
+		}
+	SetSign(aInteger.Sign());
+	}
+
+void TInteger::Construct(TInt aInteger)
+	{
+	Construct((TUint)aInteger);
+	if(aInteger < 0)
+		{
+		SetSign(ENegative);
+		Ptr()[0] = -aInteger;
+		}
+	}
+
+void TInteger::Construct(TUint aInteger)
+	{
+	assert(Size() >= 2);
+	SetSign(EPositive);
+	Ptr()[0] = aInteger;
+	Mem::FillZ(Ptr()+1, WordsToBytes(Size()-1));
+	}
+
+void TInteger::ConstructStack(TUint aWords, TUint aInteger)
+	{
+	SetPtr((TUint*)(this)+2);
+	//SetStackBased(); //Not strictly needed as stackbased is a 0 at bit 1
+	SetSize(aWords);
+	assert(Size() >= 2);
+	Ptr()[0] = aInteger;
+	Mem::FillZ(&(Ptr()[1]), WordsToBytes(Size()-1));
+	}
+
+void TInteger::ConstructStack(TUint aWords, const TInteger& aInteger)
+	{
+	SetPtr((TUint*)(this)+2);
+	//SetStackBased(); //Not strictly needed as stackbased is a 0 at bit 1
+	SetSize(aWords);
+	assert( Size() >= RoundupSize(aInteger.WordCount()) );
+	CopyWords(Ptr(), aInteger.Ptr(), aInteger.Size());
+	Mem::FillZ(Ptr()+aInteger.Size(), WordsToBytes(Size()-aInteger.Size()));
+	}
+
+// Methods are excluded from coverage due to the problem with BullsEye on ONB.
+// Manually verified that these methods are functionally covered.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+EXPORT_C TInteger& TInteger::operator/=(TInt aOperand)
+	{
+	TStackInteger64 operand(aOperand);
+	*this /= operand;
+	return *this;
+	}
+
+EXPORT_C TInteger& TInteger::operator%=(TInt aOperand)
+	{
+	TStackInteger64 operand(aOperand);
+	assert(operand.NotNegative());
+	*this %= operand;
+	return *this;
+	}
+
+EXPORT_C TInt TInteger::ConvertToLongL(void) const
+	{
+	if(!IsConvertableToLong())
+		{
+		User::Leave(KErrTotalLossOfPrecision);
+		}
+	return ConvertToLong();
+	}
+
+TInt TInteger::ConvertToLong(void) const
+	{
+	TUint value = ConvertToUnsignedLong();
+	return Sign() == EPositive ? value : -(static_cast<TInt>(value));
+	}
+
+TBool TInteger::IsConvertableToLong(void) const
+	{
+	if(WordCount() > 1)
+		{
+		return EFalse;
+		}
+	TUint value = (Ptr())[0];
+	if(Sign() == EPositive)
+		{
+		return static_cast<TInt>(value) >= 0;
+		}
+	else
+		{
+		return -(static_cast<TInt>(value)) < 0;
+		}
+	}
+
+EXPORT_C RInteger TInteger::SquaredL() const
+	{
+	//PositiveMultiplyL optimises for the squaring case already
+	//Any number squared is positive, no need for negative handling in TimesL
+	return PositiveMultiplyL(*this, *this);
+	}
+
+EXPORT_C RInteger TInteger::DividedByL(TUint aOperand) const
+	{
+	TUint remainder;
+	RInteger quotient;
+	DivideL(remainder, quotient, *this, aOperand);
+	return quotient;
+	}
+
+EXPORT_C RInteger TInteger::ExponentiateL(const TInteger& aExponent) const
+	{
+	//See HAC 14.85
+
+	// 1.1 Precomputation
+	// g1 <- g
+	// g2 <- g^2
+	RInteger g2 = SquaredL();
+	CleanupStack::PushL(g2);
+	RInteger g1 = RInteger::NewL(*this);
+	CleanupStack::PushL(g1);
+	TWindowSlider slider(aExponent);
+
+	// 1.2 
+	// For i from 1 to (2^(k-1) -1) do g2i+1 <- g2i-1 * g2
+	TUint count = (1 << (slider.WindowSize()-1)) - 1; //2^(k-1) -1
+	RRArray<RInteger> powerArray(count+1); //+1 because we append g1
+	User::LeaveIfError(powerArray.Append(g1));
+	CleanupStack::Pop(); //g1
+	CleanupClosePushL(powerArray);
+	for(TUint k=1; k <= count; k++)
+		{
+		RInteger g2iplus1 = g2.TimesL(powerArray[k-1]);
+		//This append can't fail as the granularity is set high enough
+		//plus we've already called Append once which will alloc to the 
+		//set granularity
+		powerArray.Append(g2iplus1);
+		}
+
+	// 2 A <- 1, i <- t
+	RInteger A = RInteger::NewL(One());
+	CleanupStack::PushL(A);
+	TInt i = aExponent.BitCount() - 1;
+
+	// 3 While i>=0 do:
+	while( i>=0 )
+		{
+		// 3.1 If ei == 0 then A <- A^2
+		if(!aExponent.Bit(i))
+			{
+			A *= A;
+			i--;
+			}
+		// 3.2 Find longest bitstring ei,ei-1,...,el s.t. i-l+1<=k and el==1
+		// and do:
+		// A <- (A^2^(i-l+1)) * g[the index indicated by the bitstring value]
+		else
+			{
+			slider.FindNextWindow(i);
+			assert(slider.Length() >= 1);
+			for(TUint j=0; j<slider.Length(); j++)
+				{
+				A *= A;
+				}
+			A *= powerArray[slider.Value()>>1];
+			i -= slider.Length();
+			}
+		}
+	CleanupStack::Pop(&A);
+	CleanupStack::PopAndDestroy(2, &g2); //powerArray, g2
+	return A;
+	}
+
+void TInteger::DivideL(TUint& aRemainder, RInteger& aQuotient,
+	const TInteger& aDividend, TUint aDivisor) const
+	{
+	if(!aDivisor)
+		{
+		User::Leave(KErrDivideByZero);
+		}
+	
+	TUint i = aDividend.WordCount();
+	aQuotient.CleanNewL(RoundupSize(i));
+	PositiveDivide(aRemainder, aQuotient, aDividend, aDivisor);
+
+	if(aDividend.NotNegative())
+		{
+		aQuotient.SetSign(TInteger::EPositive);
+		}
+	else
+		{
+		aQuotient.SetSign(TInteger::ENegative);
+		if(aRemainder)
+			{
+			--aQuotient;
+			aRemainder = aDivisor = aRemainder;
+			}
+		}
+	}
+
+void TInteger::PositiveDivide(TUint& aRemainder, TInteger& aQuotient, 
+	const TInteger& aDividend, TUint aDivisor) const
+	{
+	assert(aDivisor);
+
+	TUint i = aDividend.WordCount();
+	assert(aQuotient.Size() >= RoundupSize(i));
+	assert(aQuotient.Sign() == TInteger::EPositive);
+	aRemainder = 0;
+	while(i--)
+		{
+		aQuotient.Ptr()[i] = 
+			TUint(MAKE_DWORD(aDividend.Ptr()[i], aRemainder) / aDivisor);
+		aRemainder = 
+			TUint(MAKE_DWORD(aDividend.Ptr()[i], aRemainder) % aDivisor);
+		}
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/gcchelp.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,395 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+/**
+ @file
+*/
+
+
+#include <kernel\u32std.h>	// need this for __NAKED__, __JUMP and __POPRET
+
+extern "C" {
+#ifdef __GCC32__
+__NAKED__ long long __divdi3(long long /*dividend*/, long long /*divisor*/)
+//
+// Dividend in r1:r0, divisor in r3:r2, Return quotient in r1:r0
+//
+	{
+	asm("stmfd sp!, {r4-r8,lr} ");
+	asm("eor r8, r1, r3 ");				// sign of result into r8
+	asm("movs r1, r1 ");
+	asm("bpl 1f ");
+	asm("rsbs r0, r0, #0 ");			// ABS(dividend)
+	asm("rsc r1, r1, #0 ");
+	asm("1: ");
+	asm("movs r3, r3 ");
+	asm("bpl 2f ");
+	asm("rsbs r2, r2, #0 ");			// ABS(divisor)
+	asm("rsc r3, r3, #0 ");
+	asm("2: ");
+	asm("bl UDiv01 ");					// do the division, result in r4,r5
+	asm("eors r0, r4, r8, asr #32 ");	// quotient into r1:r0, inverted if quotient -ve
+	asm("eors r1, r5, r8, asr #32 ");
+	asm("adcs r0, r0, #0 ");		// if quotient -ve, add 1
+	asm("adcs r1, r1, #0 ");
+	__POPRET("r4-r8,");
+	}
+
+__NAKED__ long long __moddi3(long long /*dividend*/, long long /*divisor*/)	/* signed */
+	{
+	asm("stmfd sp!, {r4-r8,lr} ");
+	asm("movs r8, r1 ");				// sign of remainder (=sign of dividend) into r8
+	asm("bpl 1f ");
+	asm("rsbs r0, r0, #0 ");			// ABS(dividend)
+	asm("rsc r1, r1, #0 ");
+	asm("1: ");
+	asm("movs r3, r3 ");
+	asm("bpl 2f ");
+	asm("rsbs r2, r2, #0 ");			// ABS(divisor)
+	asm("rsc r3, r3, #0 ");
+	asm("2: ");
+	asm("bl UDiv01 ");					// do the division, remainder in r3,r6
+	asm("eors r0, r3, r8, asr #32 ");	// remainder into r1:r0, inverted if dividend -ve
+	asm("eors r1, r6, r8, asr #32 ");
+	asm("adcs r0, r0, #0 ");			// if dividend -ve, add 1
+	asm("adcs r1, r1, #0 ");
+	__POPRET("r4-r8,");
+	}
+
+__NAKED__ long long __umoddi3(unsigned long long /*dividend*/, unsigned long long /*divisor*/)	/* unsigned */
+	{
+	asm("stmfd sp!, {r4-r7,lr} ");
+	asm("bl UDiv01 ");					// do the division, remainder in r6:r3
+	asm("mov r0, r3 ");
+	asm("mov r1, r6 ");
+	__POPRET("r4-r7,");
+	}
+
+__NAKED__ long long __ashrdi3(long long /*value*/, unsigned int /*count*/)
+	{
+	asm("cmp r2, #63 ");
+	asm("movhi r2, #63 ");			// count>63 same as count=63
+	asm("cmp r2, #32 ");
+	asm("bcs Asr01 ");				// jump if shift count >=32
+	asm("rsb r12, r2, #32 ");		// r12=32-shift count
+	asm("mov r0, r0, lsr r2 ");		// shift ls word right
+	asm("orr r0, r0, r1, lsl r12 ");	// or in bits shifted out of ms word
+	asm("mov r1, r1, asr r2 ");		// shift ms word right
+	__JUMP(,lr);
+	asm("Asr01: ");
+	asm("sub r2, r2, #32 ");		// r2=shift count-32
+	asm("mov r0, r1, asr r2 ");		// ls word = ms word >> (count-32)
+	asm("mov r1, r1, asr #32 ");	// ms word of result=sign extension of r1
+	__JUMP(,lr);
+	}
+
+__NAKED__ long long __ashldi3(long long /*value*/, unsigned int /*count*/)
+	{
+	asm("cmp r2, #63 ");
+	asm("movhi r2, #64 ");			// count>63 same as count=64
+	asm("cmp r2, #32 ");
+	asm("bcs Asl01 ");				// jump if shift count >=32
+	asm("rsb r12, r2, #32 ");		// r12=32-shift count
+	asm("mov r1, r1, asl r2 ");		// shift ms word left
+	asm("orr r1, r1, r0, lsr r12 ");	// or in bits shifted out of ls word
+	asm("mov r0, r0, asl r2 ");		// shift ls word left
+	__JUMP(,lr);
+	asm("Asl01: ");
+	asm("sub r2, r2, #32 ");		// r2=shift count-32
+	asm("mov r1, r0, asl r2 ");		// result ms word = ls word << (count-32)
+	asm("mov r0, #0 ");				// ls word of result is zero
+	__JUMP(,lr);
+	}
+
+__NAKED__ unsigned long long __lshrdi3(unsigned long long /*value*/, unsigned int /*count*/)
+	{
+	asm("cmp r2, #63 ");
+	asm("movhi r2, #64 ");			// count>63 same as count=64
+	asm("cmp r2, #32 ");
+	asm("bcs Lsr01 ");				// jump if shift count >=32
+	asm("rsb r12, r2, #32 ");		// r12=32-shift count
+	asm("mov r0, r0, lsr r2 ");		// shift ls word right
+	asm("orr r0, r0, r1, lsl r12 ");	// or in bits shifted out of ms word
+	asm("mov r1, r1, lsr r2 ");		// shift ms word right
+	__JUMP(,lr);
+	asm("Lsr01: ");
+	asm("sub r2, r2, #32 ");		// r2=shift count-32
+	asm("mov r0, r1, lsr r2 ");		// ls word = ms word >> (count-32)
+	asm("mov r1, #0 ");				// ms word of result = 0
+	__JUMP(,lr);
+	}
+
+__NAKED__ long long __muldi3(long long /*multiplicand*/, long long /*multiplier*/)
+	{
+	asm("mul r1, r2, r1 ");				// r1=low2*high1
+	asm("mov ip, r0 ");					// ip=low1
+	asm("mla r1, r0, r3, r1 ");			// r1+=low1*high2
+	asm("mov r0, #0 ");
+	asm("umlal r0, r1, r2, ip ");		// r1:r0 += high1*low1
+	__JUMP(,lr);
+	}
+
+__NAKED__ long long __negdi2(long long /*argument*/)
+	{
+	asm("rsbs r0, r0, #0 ");		// r0=0-r0, set carry
+	asm("rscs r1, r1, #0 ");		// r1=0-r1-(1-C)
+	__JUMP(,lr);
+	}
+
+__NAKED__ unsigned long long __udivmoddi4 (unsigned long long /*dividend*/,
+													unsigned long long /*divisor*/,
+													unsigned long long* /*p_remainder*/)
+	{
+	asm("stmfd sp!, {r4-r7,lr} ");
+	asm("bl UDiv01 ");					// do the division, quotient in r5:r4 remainder in r6:r3
+	asm("ldr r7, [sp, #20] ");			// r7=p_remainder
+	asm("mov r0, r4 ");					// r0=quotient low
+	asm("stmia r7, {r3,r6} ");			// store remainder
+	asm("mov r1, r5 ");					// r0=quotient high
+	__POPRET("r4-r7,");
+	}
+
+__NAKED__ int __cmpdi2(long long /*a*/, long long /*b*/)
+	{
+	// return 0 if a<b, 1 if a=b, 2 if a>b
+	asm("subs r0, r2, r0 ");
+	asm("sbcs r1, r3, r1 ");			// r1:r0 = b-a, set flags
+	asm("movlt r0, #2 ");				// if b<a r0=2
+	__JUMP(lt,lr);						// if b<a return
+	asm("cmpeq r0, #0 ");				// if top word of difference=0, look at bottom
+	asm("moveq r0, #1 ");				// if a=b, r0=1
+	asm("movne r0, #0 ");				// else r=0
+	__JUMP(,lr);
+	}
+
+__NAKED__ int __ucmpdi2(unsigned long long /*a*/, unsigned long long /*b*/)
+	{
+	// return 0 if a<b, 1 if a=b, 2 if a>b
+	asm("cmp r1, r3 ");
+	asm("cmpeq r0, r2 ");				// compare r1:r0 - r3:r2
+	asm("movhi r0, #2 ");				// r0=2 if a>b
+	asm("moveq r0, #1 ");				// r0=1 if a=b
+	asm("movlo r0, #0 ");				// r0=0 if a<b
+	__JUMP(,lr);
+	}
+#endif
+
+#if defined(__GCC32__)
+void __division_by_zero();
+#define DIV_BY_ZERO " __division_by_zero "
+#elif defined(__ARMCC__)
+void __rt_div0 (void);
+#define DIV_BY_ZERO " __cpp(__rt_div0) "
+#endif
+
+void __division_by_zero()
+	{
+	RThread().RaiseException(EExcIntegerDivideByZero);
+    }
+
+__NAKED__ unsigned long long __udivdi3(unsigned long long /*dividend*/, unsigned long long /*divisor*/)
+//
+// Dividend in r1:r0, divisor in r3:r2, Return quotient in r1:r0
+//
+	{
+	asm("stmfd sp!, {r4-r7,lr} ");
+	asm("bl UDiv01 ");					// do the division, result in r4,r5
+	asm("mov r0, r4 ");
+	asm("mov r1, r5 ");
+	__POPRET("r4-r7,");
+
+	// Unsigned 64-bit division. Dividend in r0,r1, divisor in r2,r3
+	// Quotient returned in r4,r5, Remainder in r3,r6
+	// Registers r0-r7,r12 used, r8-r11 unmodified
+	asm(".global UDiv01 ");
+	asm("UDiv01: ");
+	asm("movs r3, r3 ");				// check if divisor fits in 32 bits
+	asm("bne udiv64a ");				// branch if not
+	asm("movs r2, r2 ");				// check if divisor fits in 31 bits
+	asm("bmi udiv64e ");				// branch if not
+	asm("beq udiv64_divby0 ");			// if divisor=0, branch to error routine
+
+	// Divisor is <0x80000000
+	// This means that a 32-bit accumulator is sufficient
+	asm("mov r4, #0 ");					// use r3 as acc, result in r4, r5
+	asm("mov r5, #0 ");
+	asm("mov r6, #8 ");					// do 2 set of 32 iterations
+	asm("udiv64b: ");
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("subs r6, r6, #1 ");			// loop
+	asm("bne udiv64b ");
+	asm("mov r6, #8 ");					// 2nd set of 32 iterations
+	asm("udiv64c: ");
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("subs r6, r6, #1 ");			// loop
+	asm("bne udiv64c ");
+	__JUMP(,lr);
+
+	// 2^31 <= Divisor < 2^32
+	// Need 33-bit accumulator - use carry flag as 33rd bit
+	asm("udiv64e: ");
+	asm("mov r4, #0 ");					// use r3 as acc, result in r4, r5
+	asm("mov r5, #0 ");
+	asm("mov r6, #8 ");					// do 2 set of 32 iterations
+	asm("udiv64f: ");
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r1, r1, r1 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r5, r5, r5 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("subs r6, r6, #1 ");			// loop
+	asm("bne udiv64f ");
+	asm("mov r6, #8 ");					// 2nd set of 32 iterations
+	asm("udiv64g: ");
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r3, r3, r3 ");
+	asm("subcs r3, r3, r2 ");
+	asm("subccs r3, r3, r2 ");			// subtract divisor from acc
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("addcc r3, r3, r2 ");			// if borrow, add back
+	asm("subs r6, r6, #1 ");			// loop
+	asm("bne udiv64g ");
+	__JUMP(,lr);
+	
+	// Divisor >= 2^32, so quotient < 2^32
+	// Use 64 bit accumulator, 32 bit quotient
+	asm("udiv64a: ");
+	asm("mov r4, #0 ");					// quotient in r4, use r1, r6 as accumulator
+	asm("mov r6, #0 ");
+	asm("mov r5, #8 ");					// do 32 iterations
+	asm("udiv64d: ");
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r1, r1, r1 ");
+	asm("adcs r6, r6, r6 ");
+	asm("subs r7, r1, r2 ");			// subtract divisor from acc, result into r7,r12
+	asm("sbcs r12, r6, r3 ");
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("movcs r1, r7 ");				// if no borrow, update acc
+	asm("movcs r6, r12 ");
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r1, r1, r1 ");
+	asm("adcs r6, r6, r6 ");
+	asm("subs r7, r1, r2 ");			// subtract divisor from acc, result into r7,r12
+	asm("sbcs r12, r6, r3 ");
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("movcs r1, r7 ");				// if no borrow, update acc
+	asm("movcs r6, r12 ");
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r1, r1, r1 ");
+	asm("adcs r6, r6, r6 ");
+	asm("subs r7, r1, r2 ");			// subtract divisor from acc, result into r7,r12
+	asm("sbcs r12, r6, r3 ");
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("movcs r1, r7 ");				// if no borrow, update acc
+	asm("movcs r6, r12 ");
+	asm("adds r0, r0, r0 ");			// shift dividend left into acc
+	asm("adcs r1, r1, r1 ");
+	asm("adcs r6, r6, r6 ");
+	asm("subs r7, r1, r2 ");			// subtract divisor from acc, result into r7,r12
+	asm("sbcs r12, r6, r3 ");
+	asm("adc r4, r4, r4 ");				// shift result bit left into quotient
+	asm("movcs r1, r7 ");				// if no borrow, update acc
+	asm("movcs r6, r12 ");
+	asm("subs r5, r5, #1 ");			// loop
+	asm("bne udiv64d ");
+	asm("mov r3, r1 ");					// remainder in r3,r6
+	__JUMP(,lr);
+
+	asm("udiv64_divby0: ");
+	asm("str lr, [sp, #-4]! ");
+	asm("bl " DIV_BY_ZERO);
+	__POPRET("");
+	}
+
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/mont.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,243 @@
+/*
+* Copyright (c) 2003-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 <bigint.h>
+#include <euserext.h>
+#include "algorithms.h"
+#include "words.h"
+#include "windowslider.h"
+#include "mont.h"
+
+EXPORT_C CMontgomeryStructure* CMontgomeryStructure::NewLC(
+	const TInteger& aModulus)
+	{
+	CMontgomeryStructure* self = new(ELeave) CMontgomeryStructure;
+	CleanupStack::PushL(self);
+	self->ConstructL(aModulus);
+	return self;
+	}
+
+CMontgomeryStructure::~CMontgomeryStructure()
+	{
+	iModulus.Close();
+	iModulusInv.Close();
+	iWorkspace.Close();
+	iResult.Close();
+	}
+
+void CMontgomeryStructure::ConstructL(const TInteger& aModulus)
+	{
+	User::LeaveIfError(aModulus.IsOdd() ? KErrNone : KErrArgument);
+	
+	iModulusInv = RInteger::NewEmptyL(aModulus.Size());
+	iWorkspace = RInteger::NewEmptyL(5*aModulus.Size());
+	iModulus = RInteger::NewL(aModulus);
+	iResult = RInteger::NewEmptyL(aModulus.Size());
+	RecursiveInverseModPower2(iModulusInv.Ptr(), iWorkspace.Ptr(), 
+		iModulus.Ptr(), iModulus.Size());
+	}
+
+CMontgomeryStructure::CMontgomeryStructure()
+	{
+	}
+
+TInteger& CMontgomeryStructure::ConvertIn(TInteger& aInteger) const
+	{
+	aInteger <<= WordsToBits(iModulus.Size());
+	aInteger %= iModulus;
+	return aInteger;
+	}
+
+TInteger& CMontgomeryStructure::ConvertOutL(TInteger& aInteger) const
+	{
+	TUint* const T = iWorkspace.Ptr();
+	TUint* const R = aInteger.Ptr();
+	const TUint N = iModulus.Size();
+	User::LeaveIfError((aInteger.Size() <= N) ? KErrNone : KErrArgument);
+
+	CopyWords(T, aInteger.Ptr(), aInteger.Size());
+	SetWords(T + aInteger.Size(), 0, 2*N - aInteger.Size());
+	MontgomeryReduce(R, T+2*N, T, iModulus.Ptr(), iModulusInv.Ptr(), N);
+	return aInteger;
+	}
+
+void CMontgomeryStructure::DoMultiplyL(TInteger& aResult, const TInteger& aA,
+	const TInteger& aB) const
+	{
+	User::LeaveIfError((aResult.Size() == iModulus.Size()) ? KErrNone : KErrArgument);
+					   
+	TUint* const T = iWorkspace.Ptr();
+	TUint* const R = aResult.Ptr();
+	const TUint N = iModulus.Size();
+	const TUint* const aReg = aA.Ptr();
+	const TUint* const bReg = aB.Ptr();
+	const TUint aSize = aA.Size();
+	const TUint bSize = aB.Size();
+	User::LeaveIfError((aSize <= N && bSize <= N) ? KErrNone : KErrArgument);
+
+	AsymmetricMultiply(T, T+2*N, aReg, aSize, bReg, bSize);
+	SetWords(T+aSize+bSize, 0, 2*N - aSize - bSize);
+	MontgomeryReduce(R, T+2*N, T, iModulus.Ptr(), iModulusInv.Ptr(), N);
+	}
+
+const TInteger& CMontgomeryStructure::SquareL(const TInteger& aA) const
+	{
+	RInteger a = RInteger::NewL(aA);
+	CleanupStack::PushL(a);
+	DoSquareL(iResult, ConvertIn(a));
+	ConvertOutL(iResult);
+	CleanupStack::PopAndDestroy(&a);
+	return iResult;
+	}
+
+void CMontgomeryStructure::DoSquareL(TInteger& aResult, const TInteger& aA) const
+	{
+	User::LeaveIfError((aResult.Size() == iModulus.Size()) ? KErrNone : KErrArgument);
+	TUint* const T = iWorkspace.Ptr();
+	TUint* const R = aResult.Ptr();
+	const TUint N = iModulus.Size();
+	const TUint* const aReg = aA.Ptr();
+	const TUint aSize = aA.Size();
+
+	User::LeaveIfError((aSize <= N) ? KErrNone : KErrArgument);
+
+	RecursiveSquare(T, T+2*N, aReg, aSize);
+	SetWords(T+2*aSize, 0, 2*N-2*aSize);
+	MontgomeryReduce(R, T+2*N, T, iModulus.Ptr(), iModulusInv.Ptr(), N);
+	}
+
+EXPORT_C const TInteger& CMontgomeryStructure::ExponentiateL(
+	const TInteger& aBase, const TInteger& aExponent) const
+	{
+	//See HAC 14.85
+	if ((iResult.Size() != iModulus.Size()) ||
+		(aBase >= iModulus) ||
+		(!aBase.IsPositive()) ||
+		(!aExponent.IsPositive()))
+		{
+		User::Leave(KErrArgument);
+		}
+
+	// 1.1 Precomputation
+	// g1 <- g
+	// g2 <- g^2
+	RInteger g2 = RInteger::NewL(aBase);
+	CleanupStack::PushL(g2);
+	ConvertIn(g2);
+	//ConvertIn can shrink g2, because we call DoSquare on g2, g2 must be the same size as the modulus
+	g2.CleanGrowL(iModulus.Size());
+	RInteger g1 = RInteger::NewL(g2);
+	CleanupStack::PushL(g1);
+	DoSquareL(g2, g2);
+
+	TWindowSlider slider(aExponent);
+
+	// 1.2 
+	// For i from 1 to (2^(k-1) -1) do g2i+1 <- g2i-1 * g2
+	TUint count = (1 << (slider.WindowSize()-1)) - 1; //2^(k-1) -1
+	RRArray<RInteger> powerArray(count+1); //+1 because we append g1
+	User::LeaveIfError(powerArray.Append(g1));
+	CleanupStack::Pop(&g1); 
+	CleanupClosePushL(powerArray);
+	for(TUint k=1; k <= count; k++)
+		{
+		RInteger gi = RInteger::NewEmptyL(iModulus.Size());
+		DoMultiplyL(gi, g2, powerArray[k-1]);
+		User::LeaveIfError(powerArray.Append(gi));
+		}
+	
+	// 2 A <- 1, i <- t
+	RInteger temp = RInteger::NewL(TInteger::One());
+	CleanupStack::PushL(temp);
+	ConvertIn(temp);
+
+	RInteger& A = iResult;
+	//Set A to one converted in for this modulus without changing the memory size of A (iResult)
+	A.CopyL(temp, EFalse); 
+	CleanupStack::PopAndDestroy(&temp);
+
+	TInt i = aExponent.BitCount() - 1;
+
+	// 3 While i>=0 do:
+	while( i>=0 )
+		{
+		// 3.1 If ei == 0 then A <- A^2
+		if(!aExponent.Bit(i))
+			{
+			DoSquareL(A, A);
+			i--;
+			}
+		// 3.2 Find longest bitstring ei,ei-1,...,el s.t. i-l+1<=k and el==1
+		// and do:
+		// A <- (A^2^(i-l+1)) * g[the index indicated by the bitstring value]
+		else
+			{
+			slider.FindNextWindow(i);
+			assert(slider.Length() >= 1);
+			for(TUint j=0; j<slider.Length(); j++)
+				{
+				DoSquareL(A, A);
+				}
+			DoMultiplyL(A, A, powerArray[slider.Value()>>1]);
+			i -= slider.Length();
+			}
+		}
+	CleanupStack::PopAndDestroy(2, &g2); //powerArray, g2
+	return ConvertOutL(A); // A == iResult
+	}
+
+// Methods are excluded from coverage due to the problem with BullsEye on ONB.
+// Manually verified that these methods are functionally covered.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+const TInteger& CMontgomeryStructure::ReduceL(
+	const TInteger& aInteger) const
+	{
+	RInteger temp = RInteger::NewL(aInteger);
+	CleanupStack::PushL(temp);
+	ConvertIn(temp);
+	iResult.CopyL(ConvertOutL(temp), EFalse);
+	CleanupStack::PopAndDestroy(&temp);
+	return iResult;
+	}
+
+CMontgomeryStructure* CMontgomeryStructure::NewL(
+	const TInteger& aModulus)
+	{
+	CMontgomeryStructure* self = CMontgomeryStructure::NewLC(aModulus);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+const TInteger& CMontgomeryStructure::MultiplyL(const TInteger& aA, 
+	const TInteger& aB) const
+	{
+	RInteger a = RInteger::NewL(aA);
+	CleanupStack::PushL(a);
+	RInteger b = RInteger::NewL(aB);
+	CleanupStack::PushL(b);
+	DoMultiplyL(iResult, ConvertIn(a), ConvertIn(b));
+	ConvertOutL(iResult);
+	CleanupStack::PopAndDestroy(&b); 
+	CleanupStack::PopAndDestroy(&a); 
+	return iResult;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/mont.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,59 @@
+/*
+* Copyright (c) 2003-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: 
+* CMontgomeryStructure class implementation
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent
+*/
+ 
+#ifndef __MONT_H__
+#define __MONT_H__
+
+class TInteger;
+class RInteger;
+
+/** A special representation of integers allowing efficient multiplication
+ * and exponentiation under special conditions.
+ * @internalComponent
+ */
+class CMontgomeryStructure : public CBase
+	{
+public:
+	static CMontgomeryStructure* NewL(const TInteger& aModulus);
+	IMPORT_C static CMontgomeryStructure* NewLC(const TInteger& aModulus);
+	~CMontgomeryStructure();
+	const TInteger& ReduceL(const TInteger& aInteger) const;
+	const TInteger& MultiplyL(const TInteger& aA, const TInteger& aB) const;
+	IMPORT_C const TInteger& ExponentiateL(const TInteger& aBase, const TInteger& aExponent) const;
+	const TInteger& SquareL(const TInteger& aA) const;
+protected:
+	void DoMultiplyL(TInteger& aResult, const TInteger& aA, const TInteger& aB) const;
+	void DoSquareL(TInteger& aResult, const TInteger& aA) const;
+	TInteger& ConvertIn(TInteger& aInteger) const;
+	TInteger& ConvertOutL(TInteger& aInteger) const;
+	CMontgomeryStructure();
+private:
+	void ConstructL(const TInteger& aModulus);
+	RInteger iModulus;
+	RInteger iModulusInv;
+	RInteger iWorkspace;
+	mutable RInteger iResult;
+	};
+
+#endif // __MONT_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/primes.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,450 @@
+/*
+* Copyright (c) 2003-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 <bigint.h>
+#include <e32std.h>
+#include <securityerr.h>
+#include "words.h"
+#include "primes.h"
+#include "algorithms.h"
+#include "mont.h"
+#include "stackinteger.h"
+
+static TBool IsSmallPrime(TUint aK);
+
+static inline void EliminateComposites(TUint* aS, TUint aPrime, TUint aJ, 
+	TUint aMaxIndex)
+	{
+	for(; aJ<aMaxIndex; aJ+=aPrime)
+		ArraySetBit(aS, aJ);
+	}
+
+static inline TInt FindLeastSignificantZero(TUint aX)
+	{
+	aX = ~aX;
+	int i = 0;
+	if( aX << 16 == 0 ) aX>>=16, i+=16;
+	if( aX << 24 == 0 ) aX>>=8, i+=8;
+	if( aX << 28 == 0 ) aX>>=4, i+=4;
+	if( aX << 30 == 0 ) aX>>=2, i+=2;
+	if( aX << 31 == 0 ) ++i;
+	return i;
+	}
+
+static inline TInt FindFirstPrimeCandidate(TUint* aS, TUint aBitLength)
+	{
+	assert(aBitLength % WORD_BITS == 0);
+	TUint i=0;
+	//The empty statement at the end of this is stop warnings in all compilers
+	for(; aS[i] == KMaxTUint && i<BitsToWords(aBitLength); i++) {;}
+
+	if(i == BitsToWords(aBitLength))
+		return -1;
+	else
+		{
+		assert( FindLeastSignificantZero((TUint)(aS[i])) >= 0 );
+		assert( FindLeastSignificantZero((TUint)(aS[i])) <= 31 );
+		return i*WORD_BITS + FindLeastSignificantZero((TUint32)(aS[i]));
+		}
+	}
+
+static inline TUint FindSmallestIndex(TUint aPrime, TUint aRemainder)
+	{
+	TUint& j = aRemainder;
+	if(j)
+		{
+		j = aPrime - aRemainder;
+		if( j & 0x1L )
+			{
+			//if j is odd then this + j is even so we actually want 
+			//the next number for which (this + j % p == 0) st this + j is odd
+			//that is: this + j + p == 0 mod p
+			j += aPrime;
+			}
+		//Turn j into an index for a bit array representing odd numbers only
+		j>>=1;
+		}
+	return j;
+	}
+
+static inline TUint RabinMillerRounds(TUint aBits) 
+	{
+	//See HAC Table 4.4
+	if(aBits > 1300)
+		return 2;
+	if (aBits > 850)
+		return 3;
+	if (aBits > 650)
+		return 4;
+	if (aBits > 550)
+		return 5;
+	if (aBits > 450)
+		return 6;
+	if (aBits > 400)
+		return 7;
+	if (aBits > 350)
+		return 8;
+	if (aBits > 300)
+		return 9;
+	if (aBits > 250)
+		return 12;
+	if (aBits > 200)
+		return 15;
+	if (aBits > 150)
+		return 18;
+	if (aBits > 100)
+		return 27;
+	//All of the above are optimisations on the worst case.  The worst case
+	//chance of odd composite integers being declared prime by Rabin-Miller is
+	//(1/4)^t where t is the number of rounds.  Thus, t = 40 means that the
+	//chance of declaring a composite integer prime is less than 2^(-80).  See
+	//HAC Fact 4.25 and most of chapter 4 for more details.
+	return 40;
+	}
+
+static TBool HasSmallDivisorL(const TInteger& aPossiblePrime)
+	{
+	assert(aPossiblePrime.IsOdd());
+	//Start checking at the first odd prime, whether it is even should have
+	//already been checked
+	for( TUint i=1; i < KPrimeTableSize; i++ )
+		{
+		if( aPossiblePrime.ModuloL(KPrimeTable[i]) == 0 )
+			{
+			return ETrue;
+			}
+		}
+	return EFalse;
+	}
+
+static TBool RabinMillerIterationL(const CMontgomeryStructure& aMont, 
+	const TInteger& aProbablePrime, const TInteger& aBase)
+	{
+	//see HAC 4.24
+	const TInteger& n = aProbablePrime;
+	assert(n > KLastSmallPrimeSquared);
+	assert(n.IsOdd());
+	assert(aBase > TInteger::One());
+
+	RInteger nminus1 = n.MinusL(TInteger::One());
+	CleanupStack::PushL(nminus1);
+	assert(aBase < nminus1);
+
+	// 1) find (s | 2^s*r == n-1) where r is odd
+	// we want the largest power of 2 that divides n-1
+	TUint s=0;
+	for(;;s++)
+		{
+		if(nminus1.Bit(s))
+			{
+			break;
+			}
+		}
+	// (r = (n-1) / 2^s) which is equiv to (n-1 >>= s)
+	RInteger r = RInteger::NewL(nminus1);
+	CleanupStack::PushL(r);
+	r >>= s;
+
+	//At no point do we own y, aMont owns it
+	const TInteger* y = &(aMont.ExponentiateL(aBase, r));
+
+	TBool probablePrime = EFalse;
+	
+	TUint j=1;
+	if( *y == TInteger::One() || *y == nminus1 )
+		{
+		probablePrime = ETrue;
+		}
+	else
+		{
+		for(j=1; j<s; j++)
+			{
+			y = &(aMont.SquareL(*y));
+			if(*y == nminus1)
+				{
+				probablePrime = ETrue;
+				break;
+				}
+			}
+		}
+	CleanupStack::PopAndDestroy(&r);
+	CleanupStack::PopAndDestroy(&nminus1);//y,r,nminus1
+	return probablePrime;
+	}
+
+static TBool RabinMillerTestL(const CMontgomeryStructure& aMont, 
+	const TInteger& aProbablePrime, TUint aRounds) 
+	{
+	const TInteger& n = aProbablePrime;
+	assert(n > KLastSmallPrimeSquared);
+	
+	RInteger nminus2 = n.MinusL(TInteger::Two());
+	CleanupStack::PushL(nminus2);
+
+	for(TUint i=0; i<aRounds; i++)
+		{
+		RInteger base = RInteger::NewRandomL(TInteger::Two(), nminus2);
+		CleanupStack::PushL(base);
+		if(!RabinMillerIterationL(aMont, n, base))
+			{
+			CleanupStack::PopAndDestroy(2, &nminus2);//base, nminus2
+			return EFalse;
+			}
+		CleanupStack::PopAndDestroy(&base);
+		}
+	CleanupStack::PopAndDestroy(&nminus2);
+	return ETrue;
+	}
+
+static TBool IsStrongProbablePrimeL(const TInteger& aPrime) 
+	{
+	CMontgomeryStructure* mont = CMontgomeryStructure::NewLC(aPrime);
+	//This should be using short circuit evaluation
+	TBool probablePrime = RabinMillerIterationL(*mont, aPrime, TInteger::Two())
+		&& RabinMillerTestL(*mont, aPrime,RabinMillerRounds(aPrime.BitCount()));
+	CleanupStack::PopAndDestroy(mont);
+	return probablePrime;
+	}
+
+/* In the _vast_ majority of cases this simply checks that your chosen random
+ * number is >= KLastSmallPrimeSquared and return EFalse and lets the normal
+ * prime generation routines handle the situation.  In the case where it is
+ * smaller, it generates a provable prime and returns ETrue.  The algorithm for
+ * finding a provable prime < KLastPrimeSquared is not the most efficient in the
+ * world, but two points come to mind
+ * 1) The two if statements hardly _ever_ evaluate to ETrue in real life.
+ * 2) Even when it is, the distribution of primes < KLastPrimeSquared is pretty
+ * dense, so you aren't going to have check many.
+ * This function is essentially here for two reasons:
+ * 1) Ensures that it is possible to generate primes < KLastPrimeSquared (the
+ * test code does this)
+ * 2) Ensures that if you request a prime of a large bit size that there is an
+ * even probability distribution across all integers < 2^aBits
+ */
+TBool TInteger::SmallPrimeRandomizeL(void)
+	{
+	TBool foundPrime = EFalse;
+	//If the random number we've chosen is less than KLastSmallPrime,
+	//testing for primality is easy.
+	if(*this <= KLastSmallPrime)
+		{
+		//If Zero or One, or two, next prime number is two
+		if(IsZero() || *this == One() || *this == Two())
+			{
+			CopyL(TInteger::Two());
+			foundPrime = ETrue;
+			}
+		else
+			{
+			//Make sure any number we bother testing is at least odd
+			SetBit(0);
+			//Binary search the small primes.
+			while(!IsSmallPrime(ConvertToUnsignedLong()))
+				{
+				//If not prime, add two and try the next odd number.
+
+				//will never carry as the minimum size of an RInteger is 2
+				//words.  Much bigger than KLastSmallPrime on 32bit
+				//architectures.
+				IncrementNoCarry(Ptr(), Size(), 2);
+				}
+			assert(IsSmallPrime(ConvertToUnsignedLong()));
+			foundPrime = ETrue;
+			}
+		}
+	else if(*this <= KLastSmallPrimeSquared)
+		{
+		//Make sure any number we bother testing is at least odd
+		SetBit(0);
+
+		while(HasSmallDivisorL(*this) && *this <= KLastSmallPrimeSquared)
+			{
+			//If not prime, add two and try the next odd number.
+
+			//will never carry as the minimum size of an RInteger is 2
+			//words.  Much bigger than KLastSmallPrime on 32bit
+			//architectures.
+			IncrementNoCarry(Ptr(), Size(), 2);
+			}
+		//If we exited while loop because it had no small divisor then it is
+		//prime.  Otherwise, we've exceeded the limit of what we can provably
+		//generate.  Therefore the normal prime gen routines will be run on it
+		//now.
+		if(*this < KLastSmallPrimeSquared)
+			{
+			foundPrime = ETrue;
+			}
+		}
+	//This doesn't mean there is no such prime, simply means that the number
+	//wasn't less than KSmallPrimeSquared and needs to be handled by the normal
+	//prime generation routines.
+	return foundPrime;
+	}
+
+void TInteger::PrimeRandomizeL(TUint aBits, TRandomAttribute aAttr)
+	{
+	assert(aBits > 1); 
+	
+	//"this" is "empty" currently.  Consists of Size() words of 0's.  This is just
+	//checking that sign flag is positive as we don't set it later.
+	assert(NotNegative());
+
+	//Flag for the whole function saying if we've found a prime
+	TBool foundProbablePrime = EFalse;
+
+	//Find 2^aBits + 1 -- any prime we find must be less than this.
+	RInteger max = RInteger::NewEmptyL(BitsToWords(aBits)+1);
+	CleanupStack::PushL(max);
+	max.SetBit(aBits);
+	assert(max.BitCount()-1 == aBits);
+
+	// aBits 	| approx number of odd numbers you must try to have a 50% 
+	//			chance of finding a prime
+	//---------------------------------------------------------
+	// 512		| 122		
+	// 1024		| 245
+	// 2048		| 1023
+	//Therefore if we are generating larger than 1024 bit numbers we'll use a
+	//bigger bit array to have a better chance of avoiding re-generating it.
+	TUint sLength = aBits > 1024 ? 1024 : 512;
+	RInteger S = RInteger::NewEmptyL(BitsToWords(sLength));
+	CleanupStack::PushL(S);
+
+	while(!foundProbablePrime)
+		{
+		//Randomly choose aBits
+		RandomizeL(aBits, aAttr);
+
+		//If the random number chosen is less than KSmallPrimeSquared, we have a
+		//special set of routines.
+		if(SmallPrimeRandomizeL())
+			{
+			foundProbablePrime = ETrue;
+			}
+		else
+			{
+			//if it was <= KLastSmallPrimeSquared then it would have been
+			//handled by SmallPrimeRandomizeL()
+			assert(*this > KLastSmallPrimeSquared);
+
+			//Make sure any number we bother testing is at least odd
+			SetBit(0);
+
+			//Ensure that this + 2*sLength < max
+			RInteger temp = max.MinusL(*this);
+			CleanupStack::PushL(temp);
+			++temp;
+			temp >>=1;
+			if(temp < sLength)
+				{
+				//if this + 2*sLength >= max then we use a smaller sLength to
+				//ensure we don't find a number that is outside of our bounds
+				//(and bigger than our allocated memory for this)
+
+				//temp must be less than KMaxTUint as sLength is a TUint 
+				sLength = temp.ConvertToUnsignedLong();	
+				}
+			CleanupStack::PopAndDestroy(&temp);
+
+			//Start at 1 as no point in checking against 2 (all odd numbers)
+			for(TUint i=1; i<KPrimeTableSize; i++)
+				{
+				//no need to call ModuloL as we know KPrimeTable[i] is not 0
+				TUint remainder = Modulo(*this, KPrimeTable[i]);
+				TUint index = FindSmallestIndex(KPrimeTable[i], remainder);
+				EliminateComposites(S.Ptr(), KPrimeTable[i], index, sLength);
+				}
+			TInt j = FindFirstPrimeCandidate(S.Ptr(), sLength);
+			TInt prev = 0;
+			for(; j>=0; j=FindFirstPrimeCandidate(S.Ptr(), sLength))
+				{
+				ArraySetBit(S.Ptr(), j);
+
+				//should never carry as we earlier made sure that 2*j + this < max
+				//where max is 1 bit more than we asked for.
+				IncrementNoCarry(Ptr(), Size(), 2*(j-prev));
+
+				assert(*this < max);
+				assert(!HasSmallDivisorL(*this));
+
+				prev = j;
+
+				if( IsStrongProbablePrimeL(*this) )
+					{
+					foundProbablePrime = ETrue;
+					break;
+					}
+				}
+			//This clears the memory
+			S.CopyL(0, EFalse);
+			}
+		}
+	CleanupStack::PopAndDestroy(2, &max);
+	}
+
+EXPORT_C TBool TInteger::IsPrimeL(void) const
+	{
+	if( NotPositive() )
+		{
+		return EFalse;
+		}
+	else if( IsEven() )
+		{
+		return *this == Two();
+		}
+	else if( *this <= KLastSmallPrime )
+		{
+		assert(KLastSmallPrime < KMaxTUint);
+		return IsSmallPrime(this->ConvertToUnsignedLong());
+		}
+	else if( *this <= KLastSmallPrimeSquared )
+		{
+		return !HasSmallDivisorL(*this);
+		}
+	else 
+		{
+		return !HasSmallDivisorL(*this) && IsStrongProbablePrimeL(*this);
+		}
+	}
+
+// Method is excluded from coverage due to the problem with BullsEye on ONB.
+// Manually verified that this method is functionally covered.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+static TBool IsSmallPrime(TUint aK) 
+	{
+	//This is just a binary search of our small prime table.
+	TUint l = 0;
+	TUint u = KPrimeTableSize;
+	while( u > l )
+		{
+		TUint m = (l+u)>>1;
+		TUint p = KPrimeTable[m];
+		if(aK < p)
+			u = m;
+		else if (aK > p)
+			l = m + 1;
+		else
+			return ETrue;
+		}
+	return EFalse;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/primes.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,297 @@
+/*
+* Copyright (c) 2003-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:  Table of prime numbers.
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent
+*/
+ 
+#ifndef __BIGINT_PRIMES_H__
+#define __BIGINT_PRIMES_H__
+
+#include <e32std.h>
+
+const TUint16 KPrimeTable[] = 
+	{
+	2, 3, 5, 7, 11, 13, 17, 19,
+	23, 29, 31, 37, 41, 43, 47, 53,
+	59, 61, 67, 71, 73, 79, 83, 89,
+	97, 101, 103, 107, 109, 113, 127, 131,
+	137, 139, 149, 151, 157, 163, 167, 173,
+	179, 181, 191, 193, 197, 199, 211, 223,
+	227, 229, 233, 239, 241, 251, 257, 263,
+	269, 271, 277, 281, 283, 293, 307, 311,
+	313, 317, 331, 337, 347, 349, 353, 359,
+	367, 373, 379, 383, 389, 397, 401, 409,
+	419, 421, 431, 433, 439, 443, 449, 457,
+	461, 463, 467, 479, 487, 491, 499, 503,
+	509, 521, 523, 541, 547, 557, 563, 569,
+	571, 577, 587, 593, 599, 601, 607, 613,
+	617, 619, 631, 641, 643, 647, 653, 659,
+	661, 673, 677, 683, 691, 701, 709, 719,
+	727, 733, 739, 743, 751, 757, 761, 769,
+	773, 787, 797, 809, 811, 821, 823, 827,
+	829, 839, 853, 857, 859, 863, 877, 881,
+	883, 887, 907, 911, 919, 929, 937, 941,
+	947, 953, 967, 971, 977, 983, 991, 997,
+	1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049,
+	1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097,
+	1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163,
+	1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
+	1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283,
+	1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321,
+	1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423,
+	1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459,
+	1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
+	1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571,
+	1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619,
+	1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693,
+	1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747,
+	1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
+	1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877,
+	1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949,
+	1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003,
+	2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069,
+	2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129,
+	2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203,
+	2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267,
+	2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311,
+	2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377,
+	2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423,
+	2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503,
+	2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579,
+	2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657,
+	2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693,
+	2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741,
+	2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801,
+	2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861,
+	2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939,
+	2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011,
+	3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079,
+	3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167,
+	3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221,
+	3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301,
+	3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347,
+	3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413,
+	3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491,
+	3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541,
+	3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607,
+	3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671,
+	3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727,
+	3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797,
+	3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863,
+	3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923,
+	3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003,
+	4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 
+	4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 
+	4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 
+	4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 
+	4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 
+	4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 
+	4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 
+	4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 
+	4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 
+	4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 
+	4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 
+	4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 
+	4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 
+	4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 
+	4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 
+	5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 
+	5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 
+	5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 
+	5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 
+	5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 
+	5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 
+	5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 
+	5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 
+	5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 
+	5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 
+	5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 
+	5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 
+	5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 
+	5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 
+	6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 
+	6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 
+	6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 
+	6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 
+	6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 
+	6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 
+	6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 
+	6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 
+	6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 
+	6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 
+	6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 
+	6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 
+	6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 
+	6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 
+	6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 
+	7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 
+	7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 
+	7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 
+	7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 
+	7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 
+	7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 
+	7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 
+	7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 
+	7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 
+	7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 
+	7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 
+	7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 
+	7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 
+	8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 
+	8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 
+	8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 
+	8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 
+	8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 
+	8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 
+	8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 
+	8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 
+	8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 
+	8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 
+	8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 
+	8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 
+	8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 
+	8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 
+	9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 
+	9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 
+	9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 
+	9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 
+	9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 
+	9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 
+	9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 
+	9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 
+	9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 
+	9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 
+	9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 
+	9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 
+	9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 
+	9931, 9941, 9949, 9967, 9973, 10007, 10009, 10037, 
+	10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 
+	10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 
+	10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 
+	10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 
+	10313, 10321, 10331, 10333, 10337, 10343, 10357, 10369, 
+	10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 
+	10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 
+	10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 
+	10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 
+	10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 
+	10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 
+	10861, 10867, 10883, 10889, 10891, 10903, 10909, 10937, 
+	10939, 10949, 10957, 10973, 10979, 10987, 10993, 11003, 
+	11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 
+	11093, 11113, 11117, 11119, 11131, 11149, 11159, 11161, 
+	11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 
+	11257, 11261, 11273, 11279, 11287, 11299, 11311, 11317, 
+	11321, 11329, 11351, 11353, 11369, 11383, 11393, 11399, 
+	11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 
+	11489, 11491, 11497, 11503, 11519, 11527, 11549, 11551, 
+	11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657, 
+	11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 
+	11743, 11777, 11779, 11783, 11789, 11801, 11807, 11813, 
+	11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 
+	11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 
+	11953, 11959, 11969, 11971, 11981, 11987, 12007, 12011, 
+	12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 
+	12107, 12109, 12113, 12119, 12143, 12149, 12157, 12161, 
+	12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 
+	12253, 12263, 12269, 12277, 12281, 12289, 12301, 12323, 
+	12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 
+	12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 
+	12479, 12487, 12491, 12497, 12503, 12511, 12517, 12527, 
+	12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 
+	12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 
+	12659, 12671, 12689, 12697, 12703, 12713, 12721, 12739, 
+	12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 
+	12823, 12829, 12841, 12853, 12889, 12893, 12899, 12907, 
+	12911, 12917, 12919, 12923, 12941, 12953, 12959, 12967, 
+	12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 
+	13037, 13043, 13049, 13063, 13093, 13099, 13103, 13109, 
+	13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 
+	13183, 13187, 13217, 13219, 13229, 13241, 13249, 13259, 
+	13267, 13291, 13297, 13309, 13313, 13327, 13331, 13337, 
+	13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 
+	13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 
+	13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597, 
+	13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 
+	13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 
+	13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 
+	13807, 13829, 13831, 13841, 13859, 13873, 13877, 13879, 
+	13883, 13901, 13903, 13907, 13913, 13921, 13931, 13933, 
+	13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 
+	14051, 14057, 14071, 14081, 14083, 14087, 14107, 14143, 
+	14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 
+	14243, 14249, 14251, 14281, 14293, 14303, 14321, 14323, 
+	14327, 14341, 14347, 14369, 14387, 14389, 14401, 14407, 
+	14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 
+	14479, 14489, 14503, 14519, 14533, 14537, 14543, 14549, 
+	14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627, 
+	14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 
+	14713, 14717, 14723, 14731, 14737, 14741, 14747, 14753, 
+	14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 
+	14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 
+	14891, 14897, 14923, 14929, 14939, 14947, 14951, 14957, 
+	14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 
+	15077, 15083, 15091, 15101, 15107, 15121, 15131, 15137, 
+	15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 
+	15227, 15233, 15241, 15259, 15263, 15269, 15271, 15277, 
+	15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 
+	15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 
+	15413, 15427, 15439, 15443, 15451, 15461, 15467, 15473, 
+	15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569, 
+	15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 
+	15647, 15649, 15661, 15667, 15671, 15679, 15683, 15727, 
+	15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 
+	15787, 15791, 15797, 15803, 15809, 15817, 15823, 15859, 
+	15877, 15881, 15887, 15889, 15901, 15907, 15913, 15919, 
+	15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 
+	16033, 16057, 16061, 16063, 16067, 16069, 16073, 16087, 
+	16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 
+	16187, 16189, 16193, 16217, 16223, 16229, 16231, 16249, 
+	16253, 16267, 16273, 16301, 16319, 16333, 16339, 16349, 
+	16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 
+	16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 
+	16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603, 
+	16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 
+	16673, 16691, 16693, 16699, 16703, 16729, 16741, 16747, 
+	16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 
+	16871, 16879, 16883, 16889, 16901, 16903, 16921, 16927, 
+	16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 
+	17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 
+	17077, 17093, 17099, 17107, 17117, 17123, 17137, 17159, 
+	17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 
+	17239, 17257, 17291, 17293, 17299, 17317, 17321, 17327, 
+	17333, 17341, 17351, 17359, 17377, 17383, 17387, 17389, 
+	17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 
+	17471, 17477, 17483, 17489, 17491, 17497, 17509, 17519, 
+	17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599, 
+	17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 
+	17707, 17713, 17729, 17737, 17747, 17749, 17761, 17783, 
+	17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863 
+};
+
+const TUint KPrimeTableSize = sizeof(KPrimeTable)/sizeof(TUint16);
+const TUint KLastSmallPrime = 17863; 
+//Next line doesn't work on arm4 as it doesn't make this calculation at compile
+//time but leaves it for runtime. Therefore we would have uninitialised const
+//data.
+//const TUint KLastSmallPrime = KPrimeTable[KPrimeTableSize-1];
+const TUint KLastSmallPrimeSquared = KLastSmallPrime*KLastSmallPrime;
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/rinteger.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,262 @@
+/*
+* Copyright (c) 2003-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 <bigint.h>
+#include <e32std.h>
+#include <random.h>
+#include "../common/inlines.h"
+
+
+/** 
+ * Copy constructor
+ *
+ * This function performs a shallow copy, 
+ * i.e. the memory holding the integer is not copied.
+ */
+EXPORT_C RInteger::RInteger(const RInteger& aInteger)
+	{
+	*this = aInteger;
+	}
+
+/** 
+ * Assignment operator
+ * 
+ * This function performs a shallow copy, 
+ * i.e. the memory holding the integer is not copied.
+ */
+EXPORT_C RInteger& RInteger::operator=(const RInteger& aInteger)
+	{
+	iSize = aInteger.iSize;
+	iPtr = aInteger.iPtr;
+	return *this;
+	}
+
+
+/** 
+ * Creates a new integer representing 0.
+ * 
+ * @return	An RInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(void)
+	{
+	return NewL(TInteger::Zero());
+	}
+
+/** 
+ * Creates a new integer object representing a specified value.
+ * 
+ * @param aValue	A descriptor containing the big-endian binary
+ * 					representation of the value.
+ * @return			An RInteger object representing the value.
+ */
+EXPORT_C RInteger RInteger::NewL(const TDesC8& aValue)
+	{
+	RInteger self;
+	//Construct zero's memory beyond the size of aValue after construction
+	self.CreateNewL(BytesToWords(aValue.Size()));
+	self.Construct(aValue);
+	return self;
+	}
+
+/** 
+ * Creates an exact copy of an \c aInteger object.
+ * 
+ * @param aInteger	The integer you wish to copy
+ * @return			An RInteger object representing an exact copy of 
+ *					aInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(const TInteger& aInteger)
+	{
+	RInteger self;
+	//don't need to CleanNewL as we'll copy straight from aInteger
+	self.CreateNewL(aInteger.Size());
+	self.Construct(aInteger);
+	return self;
+	}
+
+/** 
+ * Creates a random integer uniformly distributed over [0, 2^aBits].
+ * 
+ * @param aBits	The number of bits you wish to randomly select.
+ * @param aAttr	Enum specifying whether specific bits in the random number should
+ *				be set.  See TRandomAttribute for more information.
+ * @return		A random RInteger object in the range specified.
+ */
+EXPORT_C RInteger RInteger::NewRandomL(TUint aBits, TRandomAttribute aAttr)
+	{
+	RInteger self;
+	self.CleanNewL(BitsToWords(aBits));
+	CleanupStack::PushL(self);
+	self.RandomizeL(aBits, aAttr);
+	CleanupStack::Pop(&self); 
+	return self;
+	}
+
+/** 
+ * Creates a random integer uniformly distributed over [x | min <= x <= max].
+ * 
+ * @param aMin	The smallest possible value for the random integer (inclusive).
+ * @param aMax	The largest possible value for the random integer (inclusive).
+ * @return		A random RInteger object in the range specified.
+ */
+EXPORT_C RInteger RInteger::NewRandomL(const TInteger& aMin,
+	const TInteger& aMax)
+	{
+	RInteger self;
+	self.CleanNewL(aMax.Size());
+	CleanupStack::PushL(self);
+	self.RandomizeL(aMin, aMax);
+	CleanupStack::Pop(&self);
+	return self;
+	}
+
+/** 
+ * Finds a random prime integer in the range of [2, 2^aBits].
+ *
+ * This is done by picking a random integer and using that as a starting point
+ * for a sequential search for a prime.  To verify the primality of number, 
+ * this algorithm uses a probablistic primality test.  This means that it is
+ * possible, although extremely improbable, that the number returned is a pseudoprime.
+ *
+ * @param aBits	The number of bits you wish to randomly select your prime from.
+ * @param aAttr	Enum specifying whether specific bits in the random number should
+ *				be set.  See TRandomAttribute for more information.
+ * @return		A random RInteger representing a probable prime (with very high
+ *				probablity) in the range specified.
+ */
+EXPORT_C RInteger RInteger::NewPrimeL(TUint aBits, TRandomAttribute aAttr)
+	{
+	RInteger self;
+	self.CleanNewL(BitsToWords(aBits));
+	CleanupStack::PushL(self);
+	self.PrimeRandomizeL(aBits, aAttr);
+	CleanupStack::Pop(&self);
+	return self;
+	}
+
+/** 
+ * Creates a new integer from the value represented by \c aInteger.
+ * 
+ * @param aInteger	A signed word sized integer.
+ * @return			An RInteger representation of aInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(TInt aInteger)
+	{
+	RInteger self;
+	self.CreateNewL(2);
+	self.Construct(aInteger);
+	return self;
+	}
+
+/** 
+ * Creates a new integer with a preallocated internal storage of \c aNumWords all
+ * initialised to zero.
+ *
+ * The resulting RInteger object is logically equivalent to RInteger::NewL(0).
+ * The only difference is that the internal storage requirements have been 
+ * specified to be larger than the default. This is useful if you are about 
+ * to perform an operation on this integer, that you know the resulting size
+ * requirements of, and wish to avoid a heap resize.
+ *
+ * @param aNumWords	The number of words for to preallocated and zero fill.
+ * @return			An RInteger object representing 0 with a preallocated 
+ *					zero-filled internal storage of aNumWords.
+ */
+EXPORT_C RInteger RInteger::NewEmptyL(TUint aNumWords)
+	{
+	RInteger self;
+	self.CleanNewL(aNumWords);
+	//There's no construct as there isn't anything to do
+	return self;
+	}
+
+/**
+ * Creates an RInteger object with no associated internal (heap) storage.
+ * 
+ * All data members are initialised to zero.  It is safe (although not strictly necessary)
+ * to push such an RInteger object onto the CleanupStack.  This is useful, for example, if
+ * you want to pass an RInteger object by reference into a function and have it create
+ * the representation of the actual integer for you.  
+ *
+ * Note that performing any operation on such an RInteger object other than the default
+ * assignment operator or copy constructor will panic your code.
+ * 
+ * @return	A stack based class that has no associated internal storage and thus
+ *			does not represent any number.
+ */
+EXPORT_C RInteger::RInteger(void)  
+	{
+	}
+
+/** 
+ * An overloaded TCleanupItem() allowing the RIntegers to be pushed,
+ * popped, and destroyed via the CleanupStack like any other CBase derived object.
+ */
+EXPORT_C RInteger::operator TCleanupItem(void)
+	{
+	return TCleanupItem(&RInteger::CallClose, this);
+	}
+
+/** 
+ * Helper function registered with the cleanup stack that just calls Close() for
+ * this RInteger object.
+ * 
+ * @param aPtr	A pointer to the object for which clean-up is to be performed. 
+ */
+EXPORT_C void RInteger::CallClose(TAny* aPtr)
+	{
+	((RInteger*)aPtr)->Close();	
+	}
+
+/** 
+ * Zeros and then frees any memory owned by this RInteger object.
+ *  
+ * An RInteger object that has been closed can safely fall off the stack.
+ */
+EXPORT_C void RInteger::Close(void)
+	{
+	if (iPtr)
+		{
+		Mem::FillZ(Ptr(), Size()*4);
+		User::Free(Ptr());
+		iSize = 0;
+		iPtr = NULL;
+		}
+	}
+
+// Method is excluded from coverage due to the problem with BullsEye on ONB.
+// Manually verified that this method is functionally covered.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+/** 
+ * Creates a new integer from the value represented by \c aInteger.
+ *
+ * @param aInteger	An unsigned word sized integer.
+ * @return			An RInteger representation of aInteger by value.
+ */
+EXPORT_C RInteger RInteger::NewL(TUint aInteger)
+	{
+	RInteger self;
+	self.CreateNewL(2);
+	self.Construct(aInteger);
+	return self;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/stackinteger.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,59 @@
+/*
+* Copyright (c) 2003-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: 
+* TStackInteger class implementation
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent
+*/
+ 
+#ifndef __STACK_INTEGER_H__
+#define __STACK_INTEGER_H__
+
+#include "bigint.h"
+
+/** An integer that can be created on the stack.\n\n
+ * The resulting integers are
+ * fixed in size and any code that tries to modify their memory allocation
+ * will panic.  Stack based integers may be modified as long as you can
+ * guarantee that the resulting integer will fit in the current amount of
+ * allocated memory.
+ * If you are not sure which integer you want, you want an RInteger.
+ * @internalComponent
+ * @prototype
+ * @see RInteger
+ */
+template <TUint W=2> 
+class TStackInteger : public TInteger
+	{
+public:
+	inline TStackInteger<W>(TUint aInteger) {ConstructStack(W, aInteger);}
+	inline TStackInteger<W>(const TInteger& aInteger) {ConstructStack(W, aInteger);}
+protected:
+	TUint32 iBuf[W];
+	};
+
+typedef TStackInteger<2> TStackInteger64;
+typedef TStackInteger<4> TStackInteger128;
+typedef TStackInteger<8> TStackInteger256;
+typedef TStackInteger<16> TStackInteger512;
+typedef TStackInteger<32> TStackInteger1024;
+typedef TStackInteger<64> TStackInteger2048;
+//Don't make them any bigger than this :).  The last one is 66 words (264 bytes)
+
+#endif // __STACK_INTEGER_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/vchelp.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,351 @@
+/*
+* Copyright (c) 1995-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: 
+* e32\nklib\x86\vchelp.cpp
+*
+*/
+
+
+#ifndef __NAKED__
+#define __NAKED__	__declspec(naked)
+#endif
+
+#include <e32def.h>
+
+#pragma warning ( disable : 4414 )  // short jump to function converted to near
+
+extern "C" {
+__NAKED__ void _allmul()
+//
+// Multiply two 64 bit integers returning a 64 bit result
+// On entry:
+//		[esp+4], [esp+8] = arg 1
+//		[esp+12], [esp+16] = arg 1
+// Return result in edx:eax
+// Remove arguments from stack
+//
+	{
+	_asm mov eax, [esp+4]			// eax = low1
+	_asm mul dword ptr [esp+16]		// edx:eax = low1*high2
+	_asm mov ecx, eax				// keep low 32 bits of product
+	_asm mov eax, [esp+8]			// eax = high1
+	_asm mul dword ptr [esp+12]		// edx:eax = high1*low2
+	_asm add ecx, eax				// accumulate low 32 bits of product
+	_asm mov eax, [esp+4]			// eax = low1
+	_asm mul dword ptr [esp+12]		// edx:eax = low1*low2
+	_asm add edx, ecx				// add cross terms to high 32 bits
+	_asm ret 16
+	}
+
+void udiv64_divby0()
+	{
+	_asm int 0						// division by zero exception
+	_asm ret
+	}
+
+__NAKED__ void UDiv64()
+	{
+	// unsigned divide edx:eax by edi:esi
+	// quotient in ebx:eax, remainder in edi:edx
+	// ecx, ebp, esi also modified
+	_asm test edi, edi
+	_asm jnz short UDiv64a				// branch if divisor >= 2^32
+	_asm test esi, esi
+//	_ASM_j(z,DivisionByZero)			// if divisor=0, branch to error routine
+	_asm jz udiv64_divby0
+	_asm mov ebx, eax					// ebx=dividend low
+	_asm mov eax, edx					// eax=dividend high
+	_asm xor edx, edx					// edx=0
+	_asm div esi						// quotient high now in eax
+	_asm xchg eax, ebx					// quotient high in ebx, dividend low in eax
+	_asm div esi						// quotient now in ebx:eax, remainder in edi:edx
+	_asm ret
+	UDiv64e:
+	_asm xor eax, eax					// set result to 0xFFFFFFFF
+	_asm dec eax
+	_asm jmp short UDiv64f
+	UDiv64a:
+	_asm js short UDiv64b				// skip if divisor msb set
+	_asm bsr ecx, edi					// ecx=bit number of divisor msb - 32
+	_asm inc cl
+	_asm push edi						// save divisor high
+	_asm push esi						// save divisor low
+	_asm shrd esi, edi, cl				// shift divisor right so that msb is bit 31
+	_asm mov ebx, edx					// dividend into ebx:ebp
+	_asm mov ebp, eax
+	_asm shrd eax, edx, cl				// shift dividend right same number of bits
+	_asm shr edx, cl
+	_asm cmp edx, esi					// check if approx quotient will be 2^32
+	_asm jae short UDiv64e				// if so, true result must be 0xFFFFFFFF
+	_asm div esi						// approximate quotient now in eax
+	UDiv64f:
+	_asm mov ecx, eax					// into ecx
+	_asm mul edi						// multiply approx. quotient by divisor high
+	_asm mov esi, eax					// ls dword into esi, ms into edi
+	_asm mov edi, edx
+	_asm mov eax, ecx					// approx. quotient into eax
+	_asm mul dword ptr [esp]			// multiply approx. quotient by divisor low
+	_asm add edx, esi					// edi:edx:eax now equals approx. quotient * divisor
+	_asm adc edi, 0
+	_asm xor esi, esi
+	_asm sub ebp, eax					// subtract dividend - approx. quotient *divisor
+	_asm sbb ebx, edx
+	_asm sbb esi, edi
+	_asm jnc short UDiv64c				// if no borrow, result OK
+	_asm dec ecx						// else result is one too big
+	_asm add ebp, [esp]					// and add divisor to get correct remainder
+	_asm adc ebx, [esp+4]
+	UDiv64c:
+	_asm mov eax, ecx					// result into ebx:eax, remainder into edi:edx
+	_asm mov edi, ebx
+	_asm mov edx, ebp
+	_asm xor ebx, ebx
+	_asm add esp, 8						// remove temporary values from stack
+	_asm ret
+	UDiv64b:
+	_asm mov ebx, 1
+	_asm sub eax, esi					// subtract divisor from dividend
+	_asm sbb edx, edi
+	_asm jnc short UDiv64d				// if no borrow, result=1, remainder in edx:eax
+	_asm add eax, esi					// else add back
+	_asm adc edx, edi
+	_asm dec ebx						// and decrement quotient
+	UDiv64d:
+	_asm mov edi, edx					// remainder into edi:edx
+	_asm mov edx, eax
+	_asm mov eax, ebx					// result in ebx:eax
+	_asm xor ebx, ebx
+	_asm ret
+	}
+
+__NAKED__ void _aulldiv()
+//
+// Divide two 64 bit unsigned integers returning a 64 bit result
+// On entry:
+//		[esp+4], [esp+8] = dividend
+//		[esp+12], [esp+16] = divisor
+// Return result in edx:eax
+// Remove arguments from stack
+//
+	{
+	_asm push ebp
+	_asm push edi
+	_asm push esi
+	_asm push ebx
+	_asm mov eax, [esp+20]
+	_asm mov edx, [esp+24]
+	_asm mov esi, [esp+28]
+	_asm mov edi, [esp+32]
+	_asm call UDiv64
+	_asm mov edx, ebx
+	_asm pop ebx
+	_asm pop esi
+	_asm pop edi
+	_asm pop ebp
+	_asm ret 16
+	}
+
+__NAKED__ void _alldiv()
+//
+// Divide two 64 bit signed integers returning a 64 bit result
+// On entry:
+//		[esp+4], [esp+8] = dividend
+//		[esp+12], [esp+16] = divisor
+// Return result in edx:eax
+// Remove arguments from stack
+//
+	{
+	_asm push ebp
+	_asm push edi
+	_asm push esi
+	_asm push ebx
+	_asm mov eax, [esp+20]
+	_asm mov edx, [esp+24]
+	_asm mov esi, [esp+28]
+	_asm mov edi, [esp+32]
+	_asm test edx, edx
+	_asm jns dividend_nonnegative
+	_asm neg edx
+	_asm neg eax
+	_asm sbb edx, 0
+	dividend_nonnegative:
+	_asm test edi, edi
+	_asm jns divisor_nonnegative
+	_asm neg edi
+	_asm neg esi
+	_asm sbb edi, 0
+	divisor_nonnegative:
+	_asm call UDiv64
+	_asm mov ecx, [esp+24]
+	_asm mov edx, ebx
+	_asm xor ecx, [esp+32]
+	_asm jns quotient_nonnegative
+	_asm neg edx
+	_asm neg eax
+	_asm sbb edx, 0
+	quotient_nonnegative:
+	_asm pop ebx
+	_asm pop esi
+	_asm pop edi
+	_asm pop ebp
+	_asm ret 16
+	}
+
+__NAKED__ void _aullrem()
+//
+// Divide two 64 bit unsigned integers and return 64 bit remainder
+// On entry:
+//		[esp+4], [esp+8] = dividend
+//		[esp+12], [esp+16] = divisor
+// Return result in edx:eax
+// Remove arguments from stack
+//
+	{
+	_asm push ebp
+	_asm push edi
+	_asm push esi
+	_asm push ebx
+	_asm mov eax, [esp+20]
+	_asm mov edx, [esp+24]
+	_asm mov esi, [esp+28]
+	_asm mov edi, [esp+32]
+	_asm call UDiv64
+	_asm mov eax, edx
+	_asm mov edx, edi
+	_asm pop ebx
+	_asm pop esi
+	_asm pop edi
+	_asm pop ebp
+	_asm ret 16
+	}
+
+__NAKED__ void _allrem()
+//
+// Divide two 64 bit signed integers and return 64 bit remainder
+// On entry:
+//		[esp+4], [esp+8] = dividend
+//		[esp+12], [esp+16] = divisor
+// Return result in edx:eax
+// Remove arguments from stack
+//
+	{
+	_asm push ebp
+	_asm push edi
+	_asm push esi
+	_asm push ebx
+	_asm mov eax, [esp+20]
+	_asm mov edx, [esp+24]
+	_asm mov esi, [esp+28]
+	_asm mov edi, [esp+32]
+	_asm test edx, edx
+	_asm jns dividend_nonnegative
+	_asm neg edx
+	_asm neg eax
+	_asm sbb edx, 0
+	dividend_nonnegative:
+	_asm test edi, edi
+	_asm jns divisor_nonnegative
+	_asm neg edi
+	_asm neg esi
+	_asm sbb edi, 0
+	divisor_nonnegative:
+	_asm call UDiv64
+	_asm mov eax, edx
+	_asm mov edx, edi
+	_asm cmp dword ptr [esp+24], 0
+	_asm jns rem_nonnegative
+	_asm neg edx
+	_asm neg eax
+	_asm sbb edx, 0
+	rem_nonnegative:
+	_asm pop ebx
+	_asm pop esi
+	_asm pop edi
+	_asm pop ebp
+	_asm ret 16
+	}
+
+__NAKED__ void _allshr()
+//
+// Arithmetic shift right EDX:EAX by ECX
+//
+	{
+	_asm cmp ecx, 64
+	_asm jae asr_count_ge_64
+	_asm cmp cl, 32
+	_asm jae asr_count_ge_32
+	_asm shrd eax, edx, cl
+	_asm sar edx, cl
+	_asm ret
+	asr_count_ge_32:
+	_asm sub cl, 32
+	_asm mov eax, edx
+	_asm cdq
+	_asm sar eax, cl
+	_asm ret
+	asr_count_ge_64:
+	_asm sar edx, 32
+	_asm mov eax, edx
+	_asm ret
+	}
+
+__NAKED__ void _allshl()
+//
+// shift left EDX:EAX by ECX
+//
+	{
+	_asm cmp ecx, 64
+	_asm jae lsl_count_ge_64
+	_asm cmp cl, 32
+	_asm jae lsl_count_ge_32
+	_asm shld edx, eax, cl
+	_asm shl eax, cl
+	_asm ret
+	lsl_count_ge_32:
+	_asm sub cl, 32
+	_asm mov edx, eax
+	_asm xor eax, eax
+	_asm shl edx, cl
+	_asm ret
+	lsl_count_ge_64:
+	_asm xor edx, edx
+	_asm xor eax, eax
+	_asm ret
+	}
+
+__NAKED__ void _aullshr()
+//
+// Logical shift right EDX:EAX by ECX
+//
+	{
+	_asm cmp ecx, 64
+	_asm jae lsr_count_ge_64
+	_asm cmp cl, 32
+	_asm jae lsr_count_ge_32
+	_asm shrd eax, edx, cl
+	_asm shr edx, cl
+	_asm ret
+	lsr_count_ge_32:
+	_asm sub cl, 32
+	_asm mov eax, edx
+	_asm xor edx, edx
+	_asm shr eax, cl
+	_asm ret
+	lsr_count_ge_64:
+	_asm xor edx, edx
+	_asm xor eax, eax
+	_asm ret
+	}
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/windowslider.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,73 @@
+/*
+* Copyright (c) 2003-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 <bigint.h>
+#include "windowslider.h"
+#include "../common/inlines.h"
+
+TWindowSlider::TWindowSlider(const TInteger& aExp, TUint aWindowSize)
+	: iExp(aExp), iSize(aWindowSize)
+	{
+	if(iSize == 0)
+		{
+		TUint expLen = iExp.BitCount();
+		//These numbers are more or less arbitrary and can be tuned for empirical
+		//performance results if desired.  It's a trade off between amount of
+		//precomputation (more if larger iSize) and number of iterations
+		//(more if smaller iSize).  The current defaults were obtained
+		//from crypto++
+		if( expLen <= 17 )
+			iSize = 1;
+		else if( expLen <= 24 )
+			iSize = 2;
+		else if( expLen <= 70 )
+			iSize = 3;
+		else if( expLen <= 197 )
+			iSize = 4;
+		else if( expLen <= 539 )
+			iSize = 5;
+		else if( expLen <= 1434 )
+			iSize = 6;
+		else 
+			iSize = 7;
+		}
+	assert(iSize>=1 && iSize<=7);
+	}
+
+void TWindowSlider::FindNextWindow(TUint aBegin)
+	{
+	assert(iExp.Bit(aBegin)); //initial bit must be 1
+	TInt end = aBegin;
+	TUint temp = 0;
+	iValue = 0;
+	TUint j = 0;
+	for(TInt i=aBegin; i>=0 && j<iSize; i--, j++)
+		{
+		TUint saveMask = WORD_BITS - j - 1;
+		temp |= iExp.Bit(i) << saveMask;
+		if( temp & (1 << saveMask) )
+			{
+			end = i;
+			iValue |= temp; //last valid substring
+			}
+		}
+
+	iLength = aBegin - end + 1;
+	iValue >>= (WORD_BITS - iLength);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/windowslider.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,62 @@
+/*
+* Copyright (c) 2003-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: 
+* TWindowSlider class implementation
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent
+*/
+ 
+#ifndef __WINDOWSLIDER_H__
+#define __WINDOWSLIDER_H__
+
+#include <e32std.h>
+
+class TInteger; 
+/** Utility class used by our fast exponentiation routines.\n\n
+ * See HAC 14.85 for an explanation of how window sliding helps speed things up.
+ * @internalComponent
+ */
+class TWindowSlider
+{
+public:
+	/** 
+	 * @param aExp The exponent you are using.
+	 * @param aWindowSize The window size.  Leave as default value for the
+	 * constructor to pick a window size appropriate for the given aExp
+	 * @internalComponent
+	 */
+	TWindowSlider(const TInteger& aExp, TUint aWindowSize=0);
+	/**
+	 * Finds the next "window" as defined by HAC 14.85.  The actual bitstring
+	 * value is in iValue and it's length in iLength.  These remain valid until
+	 * the next call to FindNextWindow()
+	 */
+	void FindNextWindow(TUint aBegin);
+	inline TUint WindowSize(void) {return iSize;}
+	inline TUint Value(void) {return iValue;}
+	inline TUint Length(void) {return iLength;}
+
+private:
+	const TInteger& iExp; ///the exponent all this is being calculated on
+	TUint iSize;  ///The size of the sliding window
+	TUint iValue; ///the value found by the most recent FindNextWindow() call
+	TUint iLength;///the bit length of the iValue
+};
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/bigint/words.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,147 @@
+/*
+* Copyright (c) 2003-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: 
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent
+*/
+ 
+#ifndef __BIGINT_WORDS_H__
+#define __BIGINT_WORDS_H__
+
+#include "../common/inlines.h"
+
+inline void ArraySetBit(TUint* aS, TUint aJ)
+	{
+	aS[aJ/WORD_BITS] |= (1L << (aJ%WORD_BITS));
+	}
+
+inline TUint CountWords(const TUint *X, TUint N)
+	{
+	while (N && X[N-1]==0)
+		N--;
+	return N;
+	}
+
+inline void SetWords(TUint *r, TUint a, TUint n)
+	{
+	Mem::Fill(r, WordsToBytes(n), a);
+	}
+
+inline void CopyWords(TUint *r, const TUint *a, TUint n)
+	{
+	Mem::Copy(r, a, WordsToBytes(n));
+	}
+
+inline TUint ShiftWordsLeftByBits(TUint *r, TUint n, TUint shiftBits)
+	{
+	assert (shiftBits<WORD_BITS);
+	TUint u, carry=0;
+	if (shiftBits)
+		for (TUint i=0; i<n; i++)
+			{
+			u = r[i];
+			r[i] = (u << shiftBits) | carry;
+			carry = u >> (WORD_BITS-shiftBits);
+			}
+	return carry;
+	}
+
+inline TUint ShiftWordsRightByBits(TUint *r, TUint n, TUint shiftBits)
+{
+	assert (shiftBits<WORD_BITS);
+	TUint u, carry=0;
+	if (shiftBits)
+		for (int i=n-1; i>=0; i--)
+			{
+			u = r[i];
+			r[i] = (u >> shiftBits) | carry;
+			carry = u << (WORD_BITS-shiftBits);
+			}
+	return carry;
+	}
+
+inline TUint CryptoMin(TUint aLeft, TUint aRight) 
+	{
+	return(aLeft<aRight ? aLeft : aRight);
+	}
+
+inline TUint CryptoMax(TUint aLeft, TUint aRight)
+	{
+	return(aLeft<aRight ? aRight : aLeft);
+	}
+
+inline void ShiftWordsLeftByWords(TUint *r, TUint n, TUint shiftWords)
+	{
+	shiftWords = CryptoMin(shiftWords, n);
+	if (shiftWords)
+		{
+		for (TUint i=n-1; i>=shiftWords; i--)
+			r[i] = r[i-shiftWords];
+		SetWords(r, 0, shiftWords);
+		}
+	}
+
+inline void ShiftWordsRightByWords(TUint *r, TUint n, TUint shiftWords)
+	{
+	shiftWords = CryptoMin(shiftWords, n);
+	if (shiftWords)
+		{
+		for (TUint i=0; i+shiftWords<n; i++)
+			r[i] = r[i+shiftWords];
+		SetWords(r+n-shiftWords, 0, shiftWords);
+		}
+	}
+
+inline TUint BytePrecision(TUint aValue)
+	{
+	TUint x=4;
+	if(aValue < 0x10000) aValue <<=16, x-=2;
+	if(aValue < 0x1000000) x--;
+	if(!aValue) x=0;
+	return x;
+	}
+
+inline TUint BitPrecision(TUint aValue)
+	{
+	if(!aValue) return 0;
+	TUint x=32;
+	if(aValue < 0x10000)    aValue<<=16, x-=16;
+	if(aValue < 0x1000000)  aValue<<=8, x-=8;
+	if(aValue < 0x10000000) aValue<<=4, x-=4;
+	if(aValue < 0x40000000) aValue<<=2, x-=2;
+	if(aValue < 0x80000000) --x;
+	return x;
+	}
+
+static const TUint RoundupSizeTable[] = {2, 2, 2, 4, 4, 8, 8, 8, 8};
+    
+static inline TUint RoundupSize(TUint n)
+	{
+    if (n<=8)
+        return RoundupSizeTable[n];
+    else if (n<=16)
+        return 16;
+    else if (n<=32)
+        return 32;
+    else if (n<=64)
+        return 64;
+    else return 1U << BitPrecision(n-1);
+	}
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/common/cryptostrength.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,55 @@
+/*
+* Copyright (c) 2002-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 <e32base.h>
+#include "cryptostrength.h"
+#include <securityerr.h>
+
+#ifdef CRYPTO_STRONG_BUILD
+const TInt KDTIMaxSymmetricKeyBits = KMaxTInt;
+const TInt KDTIMaxAsymmetricKeyBits = KMaxTInt;
+const TCrypto::TStrength KCryptoStrength=TCrypto::EStrong;
+#else //CRYPTO_WEAK_BUILD
+const TInt KDTIMaxSymmetricKeyBits = 56;
+const TInt KDTIMaxAsymmetricKeyBits = 512;
+const TCrypto::TStrength KCryptoStrength=TCrypto::EWeak;
+#endif //CRYPTO_STRONG_BUILD
+
+EXPORT_C TCrypto::TStrength TCrypto::Strength(void)
+	{
+	return (KCryptoStrength);
+	}
+
+EXPORT_C TBool TCrypto::IsSymmetricWeakEnoughL(TInt aSymmetricKeyBits)
+	{
+	if(aSymmetricKeyBits > KDTIMaxSymmetricKeyBits)
+		{
+		User::Leave(KErrKeyNotWeakEnough);
+		}
+	return ETrue;
+	}
+
+EXPORT_C TBool TCrypto::IsAsymmetricWeakEnoughL(TInt aAsymmetricKeyBits)
+	{
+	if(aAsymmetricKeyBits > KDTIMaxAsymmetricKeyBits)
+		{
+		User::Leave(KErrKeyNotWeakEnough);
+		}
+	return ETrue;
+	}
+ 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/common/inlines.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,272 @@
+/*
+* Copyright (c) 2003-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: 
+*
+*/
+
+
+/**
+ @file 
+ @internalTechnology
+*/
+ 
+#ifndef __INLINES_H__
+#define __INLINES_H__
+
+#include <e32base.h>
+
+#define assert(x) __ASSERT_DEBUG((x), User::Panic(_L("crypto.dll"), 1))
+
+#if defined(__GCC32__)
+typedef long long Int64;
+typedef unsigned long long Uint64;
+#elif defined(__VC32__)
+typedef __int64 Int64;
+typedef unsigned __int64 Uint64;
+#elif defined(__CW32__)
+#pragma longlong on
+typedef long long Int64;
+typedef unsigned long long Uint64;
+#endif
+
+typedef Uint64 dword;
+typedef TUint word;
+typedef TUint32 word32;
+
+const TUint WORD_SIZE = sizeof(TUint); 
+const TUint WORD_BYTES = WORD_SIZE;
+const TUint BYTE_BITS = 8;
+const TUint WORD_BITS = WORD_SIZE*BYTE_BITS;
+
+//These next two versions of GETBYTE compile to LDR's of words and then shifts
+//and ands to get it down to a byte.
+//#define GETBYTE(x, y) (TUint)(((x)>>(8*(y)))&255)
+//#define GETBYTE(x, y) (TUint)TUint8((x)>>(8*(y)))
+
+//This next version gets the best assembler on gcc and armv4 (it uses LDRB
+//rather than shifts and ands
+#define GETBYTE(x, y) (((TUint8 *)&(x))[y])
+
+#define MAKE_DWORD(lowWord, highWord) ((dword(highWord)<<WORD_BITS) | (lowWord))
+#define LOW_WORD(x) (TUint32)(x)
+#define HIGH_WORD(x) (TUint32)((x)>>WORD_BITS)
+
+template <class T> inline void TClassSwap(T& a, T& b)
+	{
+	T temp(a);
+	a = b;
+	b = temp;
+	}
+	
+// Returns log2 of aNum where aNum is a power
+// of two	
+inline TUint8 CryptoLog2(TUint8 aNum)
+	{
+	switch (aNum)
+		{		
+		case 1:
+			return 0;
+		case 1 << 1:
+			return 1;
+		case 1 << 2:
+			return 2;
+		case 1 << 3:
+			return 3;
+		case 1 << 4:
+			return 4;
+		case 1 << 5:
+			return 5;
+		case 1 << 6:
+			return 6;
+		case 1 << 7:
+			return 7;
+		default:
+			ASSERT(EFalse);
+		}
+	return 0;
+	}
+	
+inline TUint BitsToBytes(TUint bitCount)
+	{
+	return ((bitCount+7)/(BYTE_BITS));
+	}
+
+inline TUint BytesToWords(TUint byteCount)
+	{
+	return ((byteCount+WORD_SIZE-1)/WORD_SIZE);
+	}
+
+inline TUint BitsToWords(TUint bitCount)
+	{
+	return ((bitCount+WORD_BITS-1)/(WORD_BITS));
+	}
+
+inline TUint WordsToBits(TUint wordCount)
+	{
+	return wordCount * WORD_BITS;
+	}
+
+inline TUint BytesToBits(TUint byteCount)
+	{	
+	return byteCount * BYTE_BITS;
+	}
+
+inline TUint WordsToBytes(TUint wordCount)
+	{
+	return wordCount * WORD_BYTES;
+	}
+
+inline void XorWords(TUint32* r, const TUint32* a, TUint n)
+	{
+	assert(((TUint32)r & 3) == 0); // Catch alignment problems
+	
+	for (TUint i=0; i<n; i++)
+		r[i] ^= a[i];
+	}
+
+inline void XorBuf(TUint8* buf, const TUint8* mask, TUint count)
+	{
+	if (((TUint)buf | (TUint)mask | count) % WORD_SIZE == 0) 
+		{
+		XorWords((TUint32*)buf, (const TUint32*)mask, count/WORD_SIZE); 
+		}
+	else
+		{
+		for (TUint i=0; i<count; i++)
+			buf[i] ^= mask[i];
+		}
+	}
+
+// ************** rotate functions ***************
+template <class T> inline T rotlFixed(T x, TUint y)
+	{
+	assert(y < sizeof(T)*8);
+	return ( (T)((x<<y) | (x>>(sizeof(T)*8-y))) );
+	}
+
+template <class T> inline T rotrFixed(T x, TUint y)
+	{
+	assert(y < sizeof(T)*8);
+	return ((T)((x>>y) | (x<<(sizeof(T)*8-y))));
+	}
+
+inline TUint32 byteReverse(TUint32 value)
+	{
+	value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
+	return rotlFixed(value, 16U);
+	}
+
+template <class T>
+void byteReverse(T* out, const T* in, TUint32 byteCount)
+	{
+	TUint count = (byteCount+sizeof(T)-1)/sizeof(T);
+	for (TUint i=0; i<count; i++)
+		out[i] = byteReverse(in[i]);
+	}
+
+template <class T>
+inline void GetUserKeyLittleEndian(T *out, TUint32 outlen, const TUint8* in, TUint32 inlen)
+	{
+	const TUint U = sizeof(T);
+	assert(inlen <= outlen*U);
+	Mem::Copy(out, in, inlen);
+	Mem::FillZ((TUint8*)out+inlen, outlen*U-inlen);
+	}
+
+template <class T>
+inline void GetUserKeyBigEndian(T *out, TUint32 outlen, const TUint8* in, TUint32 inlen)
+	{
+	const TUint U = sizeof(T);
+	assert(inlen <= outlen*U);
+	Mem::Copy(out, in, inlen);
+	Mem::FillZ((TUint8*)out+inlen, outlen*U-inlen);
+	byteReverse(out, out, inlen);
+	}
+
+// The following methods have be changed to use byte rather than word accesses,
+// as if the input pointer is not be word aligned a fault occurs on arm
+// hardware.  This isn't optimal from a performance point of view, but it is
+// neccessary because the crypto interfaces (CSymmetricCipher,
+// CBlockTransformation) allow clients to pass non-aligned data.
+
+// Fetch 4 words from user's buffer into "a", "b", "c", "d" in LITTLE-endian order
+inline void GetBlockLittleEndian(const TUint8* block, TUint16 &a, TUint16 &b, TUint16 &c, TUint16 &d)
+	{
+	a = (TUint16)(block[0] | block[1] << 8);
+	b = (TUint16)(block[2] | block[3] << 8);
+	c = (TUint16)(block[4] | block[5] << 8);
+	d = (TUint16)(block[6] | block[7] << 8);
+	}
+
+// Put 4 words back into user's buffer in LITTLE-endian order
+inline void PutBlockLittleEndian(TUint8* block, TUint16 a, TUint16 b, TUint16 c, TUint16 d)
+	{
+	block[0] = (TUint8)(a & 0xff);
+	block[1] = (TUint8)(a >> 8);
+	block[2] = (TUint8)(b & 0xff);
+	block[3] = (TUint8)(b >> 8);
+	block[4] = (TUint8)(c & 0xff);
+	block[5] = (TUint8)(c >> 8);
+	block[6] = (TUint8)(d & 0xff);
+	block[7] = (TUint8)(d >> 8);
+	}
+
+// Fetch 1 word from user's buffer in BIG-endian order
+inline void GetWordBigEndian(const TUint8* block, TUint32 &a)
+	{
+	a = block[0] << 24 | block[1] << 16 | block[2] << 8 | block[3];
+	}
+
+// Put 1 word back into user's buffer in BIG-endian order
+inline void PutWordBigEndian(TUint8* block, TUint32 a)
+	{
+	block[0] = (TUint8)(a >> 24);
+	block[1] = (TUint8)((a >> 16) & 0xff);
+	block[2] = (TUint8)((a >> 8) & 0xff);
+	block[3] = (TUint8)(a & 0xff);
+	}
+
+// Fetch 2 words from user's buffer into "a", "b" in BIG-endian order
+inline void GetBlockBigEndian(const TUint8* block, TUint32 &a, TUint32& b)
+	{
+	GetWordBigEndian(block, a);
+	GetWordBigEndian(block + 4, b);
+	}
+
+// Put 2 words back into user's buffer in BIG-endian order
+inline void PutBlockBigEndian(TUint8* block, TUint32 a, TUint32 b)
+	{
+	PutWordBigEndian(block, a);
+	PutWordBigEndian(block + 4, b);
+	}
+
+// Fetch 4 words from user's buffer into "a", "b", "c", "d" in BIG-endian order
+inline void GetBlockBigEndian(const TUint8* block, TUint32& a, TUint32& b, TUint32& c, TUint32& d)
+	{
+	GetWordBigEndian(block, a);
+	GetWordBigEndian(block + 4, b);
+	GetWordBigEndian(block + 8, c);
+	GetWordBigEndian(block + 12, d);
+	}
+
+// Put 4 words back into user's buffer in BIG-endian order
+inline void PutBlockBigEndian(TUint8* block, TUint32 a, TUint32 b, TUint32 c, TUint32 d)
+	{
+	PutWordBigEndian(block, a);
+	PutWordBigEndian(block + 4, b);
+	PutWordBigEndian(block + 8, c);
+	PutWordBigEndian(block + 12, d);
+	}
+
+#endif // __INLINES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/common/keyconverter.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,210 @@
+/*
+* Copyright (c) 2007-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 "keyconverter.h"
+#include <cryptospi/cryptoparams.h>
+#include <cryptospi/cryptospidef.h>
+#include "keys.h"
+#include "keypair.h"
+
+using namespace CryptoSpi;
+
+/* CKeyConverter */
+
+CKey* KeyConverter::CreateKeyL(const CDHPrivateKey& aPrivateKey)
+	{
+	/*
+	 * setup key attributes
+	 */
+	TKeyProperty keyProperty;
+	keyProperty.iAlgorithmUid = KDHAgreementUid;
+
+	/*
+	 * extract key parameters from the compatibility dh key object
+	 */
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPrivateKey.N(), KDhKeyParameterNUid);
+	keyParameters->AddL(aPrivateKey.G(), KDhKeyParameterGUid);
+	keyParameters->AddL(aPrivateKey.x(), KDhKeyParameterxUid);
+
+	/*
+	 * create a CKey from the parameters
+	 */
+	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
+
+	CleanupStack::PopAndDestroy(1, keyParameters);
+	return newPrivateKey;
+	}
+
+CKey* KeyConverter::CreateKeyL(const CDHPublicKey& aPublicKey)
+	{
+	/*
+	 * setup key attributes
+	 */
+	TKeyProperty keyProperty;
+	keyProperty.iAlgorithmUid = KDHAgreementUid;
+
+	/*
+	 * extract key parameters from the compatibility dh key object
+	 */
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPublicKey.N(), KDhKeyParameterNUid);
+	keyParameters->AddL(aPublicKey.G(), KDhKeyParameterGUid);
+	keyParameters->AddL(aPublicKey.X(), KDhKeyParameterXUid);
+
+	/*
+	 * create a CKey from the parameters
+	 */
+	CKey* newPublicKey = CKey::NewL(keyProperty, *keyParameters);
+
+	CleanupStack::PopAndDestroy(1, keyParameters);
+	return newPublicKey;
+	}
+
+CKey* KeyConverter::CreateKeyL(const CDSAPrivateKey& aPrivateKey)
+	{
+	TKeyProperty keyProperty = {KDsaSignerUid, KNullUid, KDsaPrivateKeyUid, KNonEmbeddedKeyUid};
+
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPrivateKey.P(), KDsaKeyParameterPUid);
+	keyParameters->AddL(aPrivateKey.Q(), KDsaKeyParameterQUid);
+	keyParameters->AddL(aPrivateKey.G(), KDsaKeyParameterGUid);
+	keyParameters->AddL(aPrivateKey.X(), KDsaKeyParameterXUid);
+		
+	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
+	CleanupStack::PopAndDestroy(keyParameters);
+	return newPrivateKey;
+	}
+	
+CKey* KeyConverter::CreateKeyL(const CDSAPublicKey& aPublicKey)
+	{
+	TKeyProperty keyProperty = {KDsaSignerUid, KNullUid, KDsaPublicKeyUid, KNonEmbeddedKeyUid};
+
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPublicKey.P(), KDsaKeyParameterPUid);
+	keyParameters->AddL(aPublicKey.Q(), KDsaKeyParameterQUid);
+	keyParameters->AddL(aPublicKey.G(), KDsaKeyParameterGUid);
+	keyParameters->AddL(aPublicKey.Y(), KDsaKeyParameterYUid);
+
+	CKey* newPublicKey = CKey::NewL(keyProperty, *keyParameters);
+	CleanupStack::PopAndDestroy(keyParameters);
+	return newPublicKey;
+	}
+
+// RSA convertors ///////////////////////////////////////////////////////////////////////////
+CKey* KeyConverter::CreateKeyL(const CRSAPrivateKeyCRT& aPrivateKey)
+	{
+	TKeyProperty keyProperty = {KRsaCipherUid,
+		NULL,
+		KRsaPrivateKeyCRTUid,
+		KNonEmbeddedKeyUid };
+
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPrivateKey.N(), KRsaKeyParameterNUid);
+	keyParameters->AddL(aPrivateKey.P(), KRsaKeyParameterPUid);
+	keyParameters->AddL(aPrivateKey.Q(), KRsaKeyParameterQUid);
+	keyParameters->AddL(aPrivateKey.QInv(), KRsaKeyParameterQInvUid);
+	keyParameters->AddL(aPrivateKey.DP(), KRsaKeyParameterDPUid);
+	keyParameters->AddL(aPrivateKey.DQ(), KRsaKeyParameterDQUid);
+		
+	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
+	CleanupStack::PopAndDestroy(keyParameters);
+	return newPrivateKey;
+	}
+	
+CKey* KeyConverter::CreateKeyL(const CRSAPrivateKeyStandard& aPrivateKey)
+	{
+	TKeyProperty keyProperty = {KRsaCipherUid,
+		NULL,
+		KRsaPrivateKeyStandardUid,
+		KNonEmbeddedKeyUid };
+
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();
+	keyParameters->AddL(aPrivateKey.N(), KRsaKeyParameterNUid);
+	keyParameters->AddL(aPrivateKey.D(), KRsaKeyParameterDUid);
+		
+	CKey* newPrivateKey = CKey::NewL(keyProperty, *keyParameters);
+	CleanupStack::PopAndDestroy(keyParameters);
+	return newPrivateKey;
+	}
+	
+CKey* KeyConverter::CreateKeyL(const CRSAPublicKey& aPublicKey)
+	{
+	TKeyProperty keyProperty = {KRsaCipherUid,
+		NULL,
+		KRsaPublicKeyUid,
+		KNonEmbeddedKeyUid };
+
+	CCryptoParams* keyParameters = CCryptoParams::NewLC();	
+	keyParameters->AddL(aPublicKey.N(), KRsaKeyParameterNUid);
+	keyParameters->AddL(aPublicKey.E(), KRsaKeyParameterEUid);
+
+	CKey* newPublicKey = CKey::NewL(keyProperty, *keyParameters);
+	CleanupStack::PopAndDestroy(keyParameters);
+	return newPublicKey;
+	}
+
+CKey* KeyConverter::CreateKeyL(const CRSAPrivateKey& aPrivateKey)
+	{
+	// Determine which type of private key
+	if (aPrivateKey.PrivateKeyType() == EStandard)
+		{
+		const CRSAPrivateKeyStandard* stdKey = static_cast<const CRSAPrivateKeyStandard*>(&aPrivateKey);
+		return KeyConverter::CreateKeyL(*stdKey);
+		}
+	else if (aPrivateKey.PrivateKeyType() == EStandardCRT)
+		{
+		const CRSAPrivateKeyCRT* crtKey = static_cast<const CRSAPrivateKeyCRT*>(&aPrivateKey);
+		return KeyConverter::CreateKeyL(*crtKey);
+		}
+	return NULL;  // Keep the compiler happy
+	}
+
+// Methods which are not supported or not exposed out of library can be excluded from the coverage.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+CKeyPair* KeyConverter::CreateKeyPairL(const CDSAKeyPair& /*aKeyPair*/)
+	{
+	return NULL;	
+	}
+
+CKeyPair* KeyConverter::CreateKeyPairL(const CRSAKeyPair& aKeyPair)
+	{
+	CKey* newPrivateKey = KeyConverter::CreateKeyL(aKeyPair.PrivateKey());
+	CleanupStack::PushL(newPrivateKey);
+	CKey* newPublicKey = KeyConverter::CreateKeyL(aKeyPair.PublicKey());
+	CleanupStack::PushL(newPublicKey);
+	CKeyPair* newKeyPair = CKeyPair::NewL(newPublicKey, newPrivateKey);
+	CleanupStack::Pop(2, newPrivateKey);
+	return newKeyPair;
+	}
+
+CKeyPair* KeyConverter::CreateKeyPairL(const CDHKeyPair& aKeyPair)
+	{
+	CKey* newPrivateKey = KeyConverter::CreateKeyL(aKeyPair.PrivateKey());
+	CleanupStack::PushL(newPrivateKey);
+	CKey* newPublicKey = KeyConverter::CreateKeyL(aKeyPair.PublicKey());
+	CleanupStack::PushL(newPublicKey);
+	CKeyPair* newKeyPair = CKeyPair::NewL(newPublicKey, newPrivateKey);
+	CleanupStack::Pop(2, newPrivateKey);
+	return newKeyPair;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/common/keyidentifierutil.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,68 @@
+/*
+* Copyright (c) 2003-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 "keyidentifierutil.h"
+#include "hash.h"
+#include "asymmetrickeys.h"
+
+EXPORT_C void KeyIdentifierUtil::RSAKeyIdentifierL(
+		const CRSAPublicKey& aKey, TKeyIdentifier& aIdentifier)
+	{
+	aIdentifier.FillZ();
+
+	// Generate a hash of the appropriate data (for TKeyIdentifier)	
+	const TInteger& keyModulus = aKey.N();
+	HBufC8* modulusData = keyModulus.BufferLC();
+	CSHA1* sha1 = CSHA1::NewL();
+	CleanupStack::PushL(sha1);
+	TPtrC8 hash = sha1->Final(*modulusData);
+	aIdentifier.Copy(hash);
+	CleanupStack::PopAndDestroy(2);	//	sha1, modulusData
+	}
+
+EXPORT_C void KeyIdentifierUtil::DSAKeyIdentifierL(
+		const CDSAPublicKey& aKey, TKeyIdentifier& aIdentifier)
+	{
+	aIdentifier.FillZ();
+
+	// Generate a hash of the appropriate data (for TKeyIdentifier)	
+	const TInteger& Y = aKey.Y();
+	HBufC8* YData = Y.BufferLC();					
+	CSHA1* sha1 = CSHA1::NewL();
+	CleanupStack::PushL(sha1);
+	TPtrC8 hash = sha1->Final(*YData);
+	aIdentifier.Copy(hash);
+	CleanupStack::PopAndDestroy(2);	//	sha1, YData				
+	}
+
+EXPORT_C void KeyIdentifierUtil::DHKeyIdentifierL(
+		const RInteger& aKey, TKeyIdentifier& aIdentifier)
+	{
+	if (aKey.IsZero())
+		User::Leave(KErrArgument);
+
+	aIdentifier.FillZ();
+
+	// Generate a hash of the appropriate data (for TKeyIdentifier)	
+	HBufC8* XData = aKey.BufferLC();								
+	CSHA1* sha1 = CSHA1::NewL();
+	CleanupStack::PushL(sha1);
+	TPtrC8 hash = sha1->Final(*XData);
+	aIdentifier.Copy(hash);
+	CleanupStack::PopAndDestroy(2);	//	sha1, XData
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/cryptoswitch/cryptography_stubs.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,2613 @@
+/*
+* Copyright (c) 2005-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: 
+* Generated from cryptographyU.def
+*
+*/
+
+
+
+
+/**
+ @file
+ @internalComponent 
+*/
+
+extern "C" {
+
+void common_dispatch();
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_1 ()
+	{
+	// ; protected: __thiscall CBlockChainingMode::CBlockChainingMode(void)
+	_asm mov eax, 1
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_2 ()
+	{
+	// ; protected: __thiscall CDH::CDH(class CDHPrivateKey const &)
+	_asm mov eax, 2
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_3 ()
+	{
+	// ; protected: __thiscall CDHKeyPair::CDHKeyPair(void)
+	_asm mov eax, 3
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_4 ()
+	{
+	// ; protected: __thiscall CDHParameters::CDHParameters(class RInteger &,class RInteger &)
+	_asm mov eax, 4
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_5 ()
+	{
+	// ; protected: __thiscall CDHParameters::CDHParameters(void)
+	_asm mov eax, 5
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_6 ()
+	{
+	// ; protected: __thiscall CDHPrivateKey::CDHPrivateKey(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 6
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_7 ()
+	{
+	// ; protected: __thiscall CDHPrivateKey::CDHPrivateKey(void)
+	_asm mov eax, 7
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_8 ()
+	{
+	// ; protected: __thiscall CDHPublicKey::CDHPublicKey(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 8
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_9 ()
+	{
+	// ; protected: __thiscall CDHPublicKey::CDHPublicKey(void)
+	_asm mov eax, 9
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_10 ()
+	{
+	// ; protected: __thiscall CDSAKeyPair::CDSAKeyPair(void)
+	_asm mov eax, 10
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_11 ()
+	{
+	// ; protected: __thiscall CDSAParameters::CDSAParameters(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 11
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_12 ()
+	{
+	// ; protected: __thiscall CDSAParameters::CDSAParameters(void)
+	_asm mov eax, 12
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_13 ()
+	{
+	// ; protected: __thiscall CDSAPrimeCertificate::CDSAPrimeCertificate(unsigned int)
+	_asm mov eax, 13
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_14 ()
+	{
+	// ; protected: __thiscall CDSAPrimeCertificate::CDSAPrimeCertificate(void)
+	_asm mov eax, 14
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_15 ()
+	{
+	// ; protected: __thiscall CDSAPrivateKey::CDSAPrivateKey(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 15
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_16 ()
+	{
+	// ; protected: __thiscall CDSAPrivateKey::CDSAPrivateKey(void)
+	_asm mov eax, 16
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_17 ()
+	{
+	// ; protected: __thiscall CDSAPublicKey::CDSAPublicKey(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 17
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_18 ()
+	{
+	// ; protected: __thiscall CDSAPublicKey::CDSAPublicKey(void)
+	_asm mov eax, 18
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_19 ()
+	{
+	// ; protected: __thiscall CDSASignature::CDSASignature(class RInteger &,class RInteger &)
+	_asm mov eax, 19
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_20 ()
+	{
+	// ; protected: __thiscall CDSASignature::CDSASignature(void)
+	_asm mov eax, 20
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_21 ()
+	{
+	// ; protected: __thiscall CPadding::CPadding(int)
+	_asm mov eax, 21
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_22 ()
+	{
+	// ; protected: __thiscall CPaddingNone::CPaddingNone(int)
+	_asm mov eax, 22
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_23 ()
+	{
+	// ; protected: __thiscall CPaddingPKCS1Encryption::CPaddingPKCS1Encryption(int)
+	_asm mov eax, 23
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_24 ()
+	{
+	// ; protected: __thiscall CPaddingPKCS1Signature::CPaddingPKCS1Signature(int)
+	_asm mov eax, 24
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_25 ()
+	{
+	// ; protected: __thiscall CPaddingSSLv3::CPaddingSSLv3(int)
+	_asm mov eax, 25
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_26 ()
+	{
+	// ; protected: __thiscall CRSAKeyPair::CRSAKeyPair(void)
+	_asm mov eax, 26
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_27 ()
+	{
+	// ; protected: __thiscall CRSAParameters::CRSAParameters(class RInteger &)
+	_asm mov eax, 27
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_28 ()
+	{
+	// ; protected: __thiscall CRSAParameters::CRSAParameters(void)
+	_asm mov eax, 28
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_29 ()
+	{
+	// ; protected: __thiscall CRSAPrivateKeyCRT::CRSAPrivateKeyCRT(class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 29
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_30 ()
+	{
+	// ; protected: __thiscall CRSAPrivateKeyStandard::CRSAPrivateKeyStandard(class RInteger &,class RInteger &)
+	_asm mov eax, 30
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_31 ()
+	{
+	// ; protected: __thiscall CRSAPublicKey::CRSAPublicKey(class RInteger &,class RInteger &)
+	_asm mov eax, 31
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_32 ()
+	{
+	// ; protected: __thiscall CRSAPublicKey::CRSAPublicKey(void)
+	_asm mov eax, 32
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_33 ()
+	{
+	// ; protected: __thiscall CRSASignature::CRSASignature(class RInteger &)
+	_asm mov eax, 33
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_34 ()
+	{
+	// ; protected: __thiscall CRijndael::CRijndael(void)
+	_asm mov eax, 34
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_35 ()
+	{
+	// ; protected: __thiscall MCryptoSystem::MCryptoSystem(void)
+	_asm mov eax, 35
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_36 ()
+	{
+	// ; protected: __thiscall CDecryptor::CDecryptor(void)
+	_asm mov eax, 36
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_37 ()
+	{
+	// ; protected: __thiscall CEncryptor::CEncryptor(void)
+	_asm mov eax, 37
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_38 ()
+	{
+	// ; protected: __thiscall MSignatureSystem::MSignatureSystem(void)
+	_asm mov eax, 38
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_39 ()
+	{
+	// ; public: __thiscall RInteger::RInteger(void)
+	_asm mov eax, 39
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_40 ()
+	{
+	// ; protected: __thiscall TInteger::TInteger(void)
+	_asm mov eax, 40
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_41 ()
+	{
+	// ; protected: virtual __thiscall CBlockChainingMode::~CBlockChainingMode(void)
+	_asm mov eax, 41
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_42 ()
+	{
+	// ; public: virtual __thiscall CBufferedTransformation::~CBufferedTransformation(void)
+	_asm mov eax, 42
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_43 ()
+	{
+	// ; public: virtual __thiscall CDHKeyPair::~CDHKeyPair(void)
+	_asm mov eax, 43
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_44 ()
+	{
+	// ; public: virtual __thiscall CDHParameters::~CDHParameters(void)
+	_asm mov eax, 44
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_45 ()
+	{
+	// ; public: virtual __thiscall CDHPrivateKey::~CDHPrivateKey(void)
+	_asm mov eax, 45
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_46 ()
+	{
+	// ; public: virtual __thiscall CDHPublicKey::~CDHPublicKey(void)
+	_asm mov eax, 46
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_47 ()
+	{
+	// ; public: virtual __thiscall CDSAKeyPair::~CDSAKeyPair(void)
+	_asm mov eax, 47
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_48 ()
+	{
+	// ; public: virtual __thiscall CDSAParameters::~CDSAParameters(void)
+	_asm mov eax, 48
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_49 ()
+	{
+	// ; public: virtual __thiscall CDSAPrimeCertificate::~CDSAPrimeCertificate(void)
+	_asm mov eax, 49
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_50 ()
+	{
+	// ; public: virtual __thiscall CDSAPrivateKey::~CDSAPrivateKey(void)
+	_asm mov eax, 50
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_51 ()
+	{
+	// ; public: virtual __thiscall CDSAPublicKey::~CDSAPublicKey(void)
+	_asm mov eax, 51
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_52 ()
+	{
+	// ; public: virtual __thiscall CDSASignature::~CDSASignature(void)
+	_asm mov eax, 52
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_53 ()
+	{
+	// ; public: virtual __thiscall CRSAKeyPair::~CRSAKeyPair(void)
+	_asm mov eax, 53
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_54 ()
+	{
+	// ; public: virtual __thiscall CRSAParameters::~CRSAParameters(void)
+	_asm mov eax, 54
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_55 ()
+	{
+	// ; public: virtual __thiscall CRSAPrivateKeyCRT::~CRSAPrivateKeyCRT(void)
+	_asm mov eax, 55
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_56 ()
+	{
+	// ; public: virtual __thiscall CRSAPrivateKeyStandard::~CRSAPrivateKeyStandard(void)
+	_asm mov eax, 56
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_57 ()
+	{
+	// ; public: virtual __thiscall CRSAPublicKey::~CRSAPublicKey(void)
+	_asm mov eax, 57
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_58 ()
+	{
+	// ; public: virtual __thiscall CRSASignature::~CRSASignature(void)
+	_asm mov eax, 58
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_59 ()
+	{
+	// ; public: virtual __thiscall CRijndael::~CRijndael(void)
+	_asm mov eax, 59
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_60 ()
+	{
+	// ; public: int __thiscall TInteger::operator!(void)const 
+	_asm mov eax, 60
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_61 ()
+	{
+	// ; public: int __thiscall CDSASignature::operator==(class CDSASignature const &)const 
+	_asm mov eax, 61
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_62 ()
+	{
+	// ; public: int __thiscall CRSASignature::operator==(class CRSASignature const &)const 
+	_asm mov eax, 62
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_63 ()
+	{
+	// ; public: __thiscall RInteger::operator class TCleanupItem(void)
+	_asm mov eax, 63
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_64 ()
+	{
+	// ; public: class HBufC8 const * __thiscall CDH::AgreeL(class CDHPublicKey const &)const 
+	_asm mov eax, 64
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_65 ()
+	{
+	// ; public: unsigned int __thiscall TInteger::BitCount(void)const 
+	_asm mov eax, 65
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_66 ()
+	{
+	// ; public: int __thiscall CPadding::BlockSize(void)const 
+	_asm mov eax, 66
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_67 ()
+	{
+	// ; public: virtual int __thiscall CStreamCipher::BlockSize(void)const 
+	_asm mov eax, 67
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_68 ()
+	{
+	// ; public: class CBlockTransformation * __thiscall CBufferedTransformation::BlockTransformer(void)const 
+	_asm mov eax, 68
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_69 ()
+	{
+	// ; public: class HBufC8 * __thiscall TInteger::BufferLC(void)const 
+	_asm mov eax, 69
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_70 ()
+	{
+	// ; public: unsigned int __thiscall TInteger::ByteCount(void)const 
+	_asm mov eax, 70
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_71 ()
+	{
+	// ; public: static void __cdecl RInteger::CallClose(void *)
+	_asm mov eax, 71
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_72 ()
+	{
+	// ; public: void __thiscall RInteger::Close(void)
+	_asm mov eax, 72
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_73 ()
+	{
+	// ; protected: void __thiscall CBlockChainingMode::ConstructL(class CBlockTransformation *,class TDesC8 const &)
+	_asm mov eax, 73
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_74 ()
+	{
+	// ; protected: void __thiscall CDHKeyPair::ConstructL(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 74
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_75 ()
+	{
+	// ; protected: void __thiscall CDHKeyPair::ConstructL(class RInteger &,class RInteger &)
+	_asm mov eax, 75
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_76 ()
+	{
+	// ; public: unsigned int __thiscall CDSAPrimeCertificate::Counter(void)const 
+	_asm mov eax, 76
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_77 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPrivateKeyStandard::D(void)const 
+	_asm mov eax, 77
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_78 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::DP(void)const 
+	_asm mov eax, 78
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_79 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::DQ(void)const 
+	_asm mov eax, 79
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_80 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPublicKey::E(void)const 
+	_asm mov eax, 80
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_81 ()
+	{
+	// ; public: class TInteger const & __thiscall CDHParameters::G(void)const 
+	_asm mov eax, 81
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_82 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSAParameters::G(void)const 
+	_asm mov eax, 82
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_83 ()
+	{
+	// ; protected: __thiscall CRSASigner::CRSASigner(void)
+	_asm mov eax, 83
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_84 ()
+	{
+	// ; public: virtual int __thiscall CStreamCipher::MaxFinalOutputLength(int)const 
+	_asm mov eax, 84
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_85 ()
+	{
+	// ; protected: __thiscall CRSAVerifier::CRSAVerifier(void)
+	_asm mov eax, 85
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_86 ()
+	{
+	// ; public virtual int CRSAVerifer::VerifyL(class TDesC8 const &,class CRSASignature const &)const
+	_asm mov eax, 86
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_87 ()
+	{
+	// ; public: virtual int __thiscall CStreamCipher::MaxOutputLength(int)const 
+	_asm mov eax, 87
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_88 ()
+	{
+	// ; public: virtual int __thiscall CPadding::MaxPaddedLength(int)const 
+	_asm mov eax, 88
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_89 ()
+	{
+	// ; public: virtual int __thiscall CPadding::MaxUnPaddedLength(int)const 
+	_asm mov eax, 89
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_90 ()
+	{
+	// ; public: static class RInteger  __cdecl TInteger::ModularExponentiateL(class TInteger const &,class TInteger const &,class TInteger const &)
+	_asm mov eax, 90
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_91 ()
+	{
+	// ; public: class TInteger const & __thiscall CDHParameters::N(void)const 
+	_asm mov eax, 91
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_92 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAParameters::N(void)const 
+	_asm mov eax, 92
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_93 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewEmptyL(unsigned int)
+	_asm mov eax, 93
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_94 ()
+	{
+	// ; public: static class C3DESDecryptor * __cdecl C3DESDecryptor::NewL(class TDesC8 const &)
+	_asm mov eax, 94
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_95 ()
+	{
+	// ; public: static class C3DESEncryptor * __cdecl C3DESEncryptor::NewL(class TDesC8 const &)
+	_asm mov eax, 95
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_96 ()
+	{
+	// ; public: static class CAESDecryptor * __cdecl CAESDecryptor::NewL(class TDesC8 const &)
+	_asm mov eax, 96
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_97 ()
+	{
+	// ; public: static class CAESEncryptor * __cdecl CAESEncryptor::NewL(class TDesC8 const &)
+	_asm mov eax, 97
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_98 ()
+	{
+	// ; public: static class CARC4 * __cdecl CARC4::NewL(class TDesC8 const &,unsigned int)
+	_asm mov eax, 98
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_99 ()
+	{
+	// ; public: static class CBufferedDecryptor * __cdecl CBufferedDecryptor::NewL(class CBlockTransformation *,class CPadding *)
+	_asm mov eax, 99
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_100 ()
+	{
+	// ; public: static class CBufferedEncryptor * __cdecl CBufferedEncryptor::NewL(class CBlockTransformation *,class CPadding *)
+	_asm mov eax, 100
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_101 ()
+	{
+	// ; public: static class CDESDecryptor * __cdecl CDESDecryptor::NewL(class TDesC8 const &,int)
+	_asm mov eax, 101
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_102 ()
+	{
+	// ; public: static class CDESEncryptor * __cdecl CDESEncryptor::NewL(class TDesC8 const &,int)
+	_asm mov eax, 102
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_103 ()
+	{
+	// ; public: static class CDH * __cdecl CDH::NewL(class CDHPrivateKey const &)
+	_asm mov eax, 103
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_104 ()
+	{
+	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewL(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 104
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_105 ()
+	{
+	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewL(class RInteger &,class RInteger &)
+	_asm mov eax, 105
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_106 ()
+	{
+	// ; public: static class CDHPrivateKey * __cdecl CDHPrivateKey::NewL(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 106
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_107 ()
+	{
+	// ; public: static class CDHPublicKey * __cdecl CDHPublicKey::NewL(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 107
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_108 ()
+	{
+	// ; public: static class CDSAKeyPair * __cdecl CDSAKeyPair::NewL(unsigned int)
+	_asm mov eax, 108
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_109 ()
+	{
+	// ; public: static class CDSAParameters * __cdecl CDSAParameters::NewL(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 109
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_110 ()
+	{
+	// ; public: static class CDSAPrimeCertificate * __cdecl CDSAPrimeCertificate::NewL(class TDesC8 const &,unsigned int)
+	_asm mov eax, 110
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_111 ()
+	{
+	// ; public: static class CDSAPrivateKey * __cdecl CDSAPrivateKey::NewL(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 111
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_112 ()
+	{
+	// ; public: static class CDSAPublicKey * __cdecl CDSAPublicKey::NewL(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 112
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_113 ()
+	{
+	// ; public: static class CDSASignature * __cdecl CDSASignature::NewL(class RInteger &,class RInteger &)
+	_asm mov eax, 113
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_114 ()
+	{
+	// ; public: static class CDSASigner * __cdecl CDSASigner::NewL(class CDSAPrivateKey const &)
+	_asm mov eax, 114
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_115 ()
+	{
+	// ; public: static class CDSAVerifier * __cdecl CDSAVerifier::NewL(class CDSAPublicKey const &)
+	_asm mov eax, 115
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_116 ()
+	{
+	// ; public: static class CModeCBCDecryptor * __cdecl CModeCBCDecryptor::NewL(class CBlockTransformation *,class TDesC8 const &)
+	_asm mov eax, 116
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_117 ()
+	{
+	// ; public: static class CModeCBCEncryptor * __cdecl CModeCBCEncryptor::NewL(class CBlockTransformation *,class TDesC8 const &)
+	_asm mov eax, 117
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_118 ()
+	{
+	// ; public: static class CNullCipher * __cdecl CNullCipher::NewL(void)
+	_asm mov eax, 118
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_119 ()
+	{
+	// ; public: static class CPaddingNone * __cdecl CPaddingNone::NewL(int)
+	_asm mov eax, 119
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_120 ()
+	{
+	// ; public: static class CPaddingPKCS1Encryption * __cdecl CPaddingPKCS1Encryption::NewL(int)
+	_asm mov eax, 120
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_121 ()
+	{
+	// ; public: static class CPaddingPKCS1Signature * __cdecl CPaddingPKCS1Signature::NewL(int)
+	_asm mov eax, 121
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_122 ()
+	{
+	// ; public: static class CPaddingSSLv3 * __cdecl CPaddingSSLv3::NewL(int)
+	_asm mov eax, 122
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_123 ()
+	{
+	// ; public: static class CRC2Decryptor * __cdecl CRC2Decryptor::NewL(class TDesC8 const &,int)
+	_asm mov eax, 123
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_124 ()
+	{
+	// ; public: static class CRC2Encryptor * __cdecl CRC2Encryptor::NewL(class TDesC8 const &,int)
+	_asm mov eax, 124
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_125 ()
+	{
+	// ; public: static class CRSAKeyPair * __cdecl CRSAKeyPair::NewL(unsigned int,enum TRSAPrivateKeyType)
+	_asm mov eax, 125
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_126 ()
+	{
+	// ; public: static class CRSAPKCS1v15Decryptor * __cdecl CRSAPKCS1v15Decryptor::NewL(class CRSAPrivateKey const &)
+	_asm mov eax, 126
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_127 ()
+	{
+	// ; public: static class CRSAPKCS1v15Encryptor * __cdecl CRSAPKCS1v15Encryptor::NewL(class CRSAPublicKey const &)
+	_asm mov eax, 127
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_128 ()
+	{
+	// ; public: static class CRSAPKCS1v15Signer * __cdecl CRSAPKCS1v15Signer::NewL(class CRSAPrivateKey const &)
+	_asm mov eax, 128
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_129 ()
+	{
+	// ; public: static class CRSAPKCS1v15Verifier * __cdecl CRSAPKCS1v15Verifier::NewL(class CRSAPublicKey const &)
+	_asm mov eax, 129
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_130 ()
+	{
+	// ; public: static class CRSAPrivateKeyCRT * __cdecl CRSAPrivateKeyCRT::NewL(class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 130
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_131 ()
+	{
+	// ; public: static class CRSAPrivateKeyStandard * __cdecl CRSAPrivateKeyStandard::NewL(class RInteger &,class RInteger &)
+	_asm mov eax, 131
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_132 ()
+	{
+	// ; public: static class CRSAPublicKey * __cdecl CRSAPublicKey::NewL(class RInteger &,class RInteger &)
+	_asm mov eax, 132
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_133 ()
+	{
+	// ; public: static class CRSASignature * __cdecl CRSASignature::NewL(class RInteger &)
+	_asm mov eax, 133
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_134 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewL(class TDesC8 const &)
+	_asm mov eax, 134
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_135 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewL(class TInteger const &)
+	_asm mov eax, 135
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_136 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewL(int)
+	_asm mov eax, 136
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_137 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewL(unsigned int)
+	_asm mov eax, 137
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_138 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewL(void)
+	_asm mov eax, 138
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_139 ()
+	{
+	// ; public: static class C3DESDecryptor * __cdecl C3DESDecryptor::NewLC(class TDesC8 const &)
+	_asm mov eax, 139
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_140 ()
+	{
+	// ; public: static class C3DESEncryptor * __cdecl C3DESEncryptor::NewLC(class TDesC8 const &)
+	_asm mov eax, 140
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_141 ()
+	{
+	// ; public: static class CAESDecryptor * __cdecl CAESDecryptor::NewLC(class TDesC8 const &)
+	_asm mov eax, 141
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_142 ()
+	{
+	// ; public: static class CAESEncryptor * __cdecl CAESEncryptor::NewLC(class TDesC8 const &)
+	_asm mov eax, 142
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_143 ()
+	{
+	// ; public: static class CARC4 * __cdecl CARC4::NewLC(class TDesC8 const &,unsigned int)
+	_asm mov eax, 143
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_144 ()
+	{
+	// ; public: static class CBufferedDecryptor * __cdecl CBufferedDecryptor::NewLC(class CBlockTransformation *,class CPadding *)
+	_asm mov eax, 144
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_145 ()
+	{
+	// ; public: static class CBufferedEncryptor * __cdecl CBufferedEncryptor::NewLC(class CBlockTransformation *,class CPadding *)
+	_asm mov eax, 145
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_146 ()
+	{
+	// ; public: static class CDESDecryptor * __cdecl CDESDecryptor::NewLC(class TDesC8 const &,int)
+	_asm mov eax, 146
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_147 ()
+	{
+	// ; public: static class CDESEncryptor * __cdecl CDESEncryptor::NewLC(class TDesC8 const &,int)
+	_asm mov eax, 147
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_148 ()
+	{
+	// ; public: static class CDH * __cdecl CDH::NewLC(class CDHPrivateKey const &)
+	_asm mov eax, 148
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_149 ()
+	{
+	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewLC(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 149
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_150 ()
+	{
+	// ; public: static class CDHKeyPair * __cdecl CDHKeyPair::NewLC(class RInteger &,class RInteger &)
+	_asm mov eax, 150
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_151 ()
+	{
+	// ; public: static class CDHPrivateKey * __cdecl CDHPrivateKey::NewLC(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 151
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_152 ()
+	{
+	// ; public: static class CDHPublicKey * __cdecl CDHPublicKey::NewLC(class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 152
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_153 ()
+	{
+	// ; public: static class CDSAKeyPair * __cdecl CDSAKeyPair::NewLC(unsigned int)
+	_asm mov eax, 153
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_154 ()
+	{
+	// ; public: static class CDSAPrimeCertificate * __cdecl CDSAPrimeCertificate::NewLC(class TDesC8 const &,unsigned int)
+	_asm mov eax, 154
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_155 ()
+	{
+	// ; public: static class CDSAPrivateKey * __cdecl CDSAPrivateKey::NewLC(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 155
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_156 ()
+	{
+	// ; public: static class CDSAPublicKey * __cdecl CDSAPublicKey::NewLC(class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 156
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_157 ()
+	{
+	// ; public: static class CDSASignature * __cdecl CDSASignature::NewLC(class RInteger &,class RInteger &)
+	_asm mov eax, 157
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_158 ()
+	{
+	// ; public: static class CDSASigner * __cdecl CDSASigner::NewLC(class CDSAPrivateKey const &)
+	_asm mov eax, 158
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_159 ()
+	{
+	// ; public: static class CDSAVerifier * __cdecl CDSAVerifier::NewLC(class CDSAPublicKey const &)
+	_asm mov eax, 159
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_160 ()
+	{
+	// ; public: static class CModeCBCDecryptor * __cdecl CModeCBCDecryptor::NewLC(class CBlockTransformation *,class TDesC8 const &)
+	_asm mov eax, 160
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_161 ()
+	{
+	// ; public: static class CModeCBCEncryptor * __cdecl CModeCBCEncryptor::NewLC(class CBlockTransformation *,class TDesC8 const &)
+	_asm mov eax, 161
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_162 ()
+	{
+	// ; public: static class CNullCipher * __cdecl CNullCipher::NewLC(void)
+	_asm mov eax, 162
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_163 ()
+	{
+	// ; public: static class CPaddingNone * __cdecl CPaddingNone::NewLC(int)
+	_asm mov eax, 163
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_164 ()
+	{
+	// ; public: static class CPaddingPKCS1Encryption * __cdecl CPaddingPKCS1Encryption::NewLC(int)
+	_asm mov eax, 164
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_165 ()
+	{
+	// ; public: static class CPaddingPKCS1Signature * __cdecl CPaddingPKCS1Signature::NewLC(int)
+	_asm mov eax, 165
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_166 ()
+	{
+	// ; public: static class CPaddingSSLv3 * __cdecl CPaddingSSLv3::NewLC(int)
+	_asm mov eax, 166
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_167 ()
+	{
+	// ; public: static class CRC2Decryptor * __cdecl CRC2Decryptor::NewLC(class TDesC8 const &,int)
+	_asm mov eax, 167
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_168 ()
+	{
+	// ; public: static class CRC2Encryptor * __cdecl CRC2Encryptor::NewLC(class TDesC8 const &,int)
+	_asm mov eax, 168
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_169 ()
+	{
+	// ; public: static class CRSAKeyPair * __cdecl CRSAKeyPair::NewLC(unsigned int,enum TRSAPrivateKeyType)
+	_asm mov eax, 169
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_170 ()
+	{
+	// ; public: static class CRSAPKCS1v15Decryptor * __cdecl CRSAPKCS1v15Decryptor::NewLC(class CRSAPrivateKey const &)
+	_asm mov eax, 170
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_171 ()
+	{
+	// ; public: static class CRSAPKCS1v15Encryptor * __cdecl CRSAPKCS1v15Encryptor::NewLC(class CRSAPublicKey const &)
+	_asm mov eax, 171
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_172 ()
+	{
+	// ; public: static class CRSAPKCS1v15Signer * __cdecl CRSAPKCS1v15Signer::NewLC(class CRSAPrivateKey const &)
+	_asm mov eax, 172
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_173 ()
+	{
+	// ; public: static class CRSAPKCS1v15Verifier * __cdecl CRSAPKCS1v15Verifier::NewLC(class CRSAPublicKey const &)
+	_asm mov eax, 173
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_174 ()
+	{
+	// ; public: static class CRSAPrivateKeyCRT * __cdecl CRSAPrivateKeyCRT::NewLC(class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &,class RInteger &)
+	_asm mov eax, 174
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_175 ()
+	{
+	// ; public: static class CRSAPrivateKeyStandard * __cdecl CRSAPrivateKeyStandard::NewLC(class RInteger &,class RInteger &)
+	_asm mov eax, 175
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_176 ()
+	{
+	// ; public: static class CRSAPublicKey * __cdecl CRSAPublicKey::NewLC(class RInteger &,class RInteger &)
+	_asm mov eax, 176
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_177 ()
+	{
+	// ; public: static class CRSASignature * __cdecl CRSASignature::NewLC(class RInteger &)
+	_asm mov eax, 177
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_178 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewPrimeL(unsigned int,int)
+	_asm mov eax, 178
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_179 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewRandomL(class TInteger const &,class TInteger const &)
+	_asm mov eax, 179
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_180 ()
+	{
+	// ; public: static class RInteger  __cdecl RInteger::NewRandomL(unsigned int,int)
+	_asm mov eax, 180
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_181 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSAParameters::P(void)const 
+	_asm mov eax, 181
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_182 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::P(void)const 
+	_asm mov eax, 182
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_183 ()
+	{
+	// ; public: void __thiscall CPadding::PadL(class TDesC8 const &,class TDes8 &)
+	_asm mov eax, 183
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_184 ()
+	{
+	// ; public: class CDSAPrimeCertificate const & __thiscall CDSAKeyPair::PrimeCertificate(void)const 
+	_asm mov eax, 184
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_185 ()
+	{
+	// ; public: class CDHPrivateKey const & __thiscall CDHKeyPair::PrivateKey(void)const 
+	_asm mov eax, 185
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_186 ()
+	{
+	// ; public: class CDSAPrivateKey const & __thiscall CDSAKeyPair::PrivateKey(void)const 
+	_asm mov eax, 186
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_187 ()
+	{
+	// ; public: class CRSAPrivateKey const & __thiscall CRSAKeyPair::PrivateKey(void)const 
+	_asm mov eax, 187
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_188 ()
+	{
+	// ; public: virtual void __thiscall CStreamCipher::Process(class TDesC8 const &,class TDes8 &)
+	_asm mov eax, 188
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_189 ()
+	{
+	// ; public: virtual void __thiscall CStreamCipher::ProcessFinalL(class TDesC8 const &,class TDes8 &)
+	_asm mov eax, 189
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_190 ()
+	{
+	// ; public: class CDHPublicKey const & __thiscall CDHKeyPair::PublicKey(void)const 
+	_asm mov eax, 190
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_191 ()
+	{
+	// ; public: class CDSAPublicKey const & __thiscall CDSAKeyPair::PublicKey(void)const 
+	_asm mov eax, 191
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_192 ()
+	{
+	// ; public: class CRSAPublicKey const & __thiscall CRSAKeyPair::PublicKey(void)const 
+	_asm mov eax, 192
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_193 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSAParameters::Q(void)const 
+	_asm mov eax, 193
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_194 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::Q(void)const 
+	_asm mov eax, 194
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_195 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSAPrivateKeyCRT::QInv(void)const 
+	_asm mov eax, 195
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_196 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSASignature::R(void)const 
+	_asm mov eax, 196
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_197 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSASignature::S(void)const 
+	_asm mov eax, 197
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_198 ()
+	{
+	// ; public: class TInteger const & __thiscall CRSASignature::S(void)const 
+	_asm mov eax, 198
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_199 ()
+	{
+	// ; public: class TDesC8 const & __thiscall CDSAPrimeCertificate::Seed(void)const 
+	_asm mov eax, 199
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_200 ()
+	{
+	// ; public: void __thiscall CPadding::SetBlockSize(int)
+	_asm mov eax, 200
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_201 ()
+	{
+	// ; public: static enum TCrypto::TStrength  __cdecl TCrypto::Strength(void)
+	_asm mov eax, 201
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_202 ()
+	{
+	// ; public: static int __cdecl CDSAParameters::ValidPrimeLength(unsigned int)
+	_asm mov eax, 202
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_203 ()
+	{
+	// ; public: int __thiscall CDSAParameters::ValidatePrimesL(class CDSAPrimeCertificate const &)const 
+	_asm mov eax, 203
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_204 ()
+	{
+	// ; public: unsigned int __thiscall TInteger::WordCount(void)const 
+	_asm mov eax, 204
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_205 ()
+	{
+	// ; public: class TInteger const & __thiscall CDHPublicKey::X(void)const 
+	_asm mov eax, 205
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_206 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSAPrivateKey::X(void)const 
+	_asm mov eax, 206
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_207 ()
+	{
+	// ; public: class TInteger const & __thiscall CDSAPublicKey::Y(void)const 
+	_asm mov eax, 207
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_208 ()
+	{
+	// ; public: class TInteger const & __thiscall CDHPrivateKey::x(void)const 
+	_asm mov eax, 208
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_209 ()
+	{
+	// ; public: static int __cdecl TCrypto::IsAsymmetricWeakEnoughL(int)
+	_asm mov eax, 209
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_210 ()
+	{
+	// ; public: static int __cdecl TCrypto::IsSymmetricWeakEnoughL(int)
+	_asm mov eax, 210
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_211 ()
+	{
+	// ; CPaddingPKCS7::CPaddingPKCS7(int)
+	_asm mov eax, 211
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_212 ()
+	{
+	// ; class CPaddingPKCS7 * CPaddingPKCS7::NewL(int)
+	_asm mov eax, 212
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_213 ()
+	{
+	// ; class CPaddingPKCS7 * CPaddingPKCS7::NewLC(int)
+	_asm mov eax, 213
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_214 ()
+	{
+	// ; void KeyIdentifierUtil::DHKeyIdentifierL(class RInteger const &, class TBuf8<20> &)
+	_asm mov eax, 214
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_215 ()
+	{
+	// ; void KeyIdentifierUtil::DSAKeyIdentifierL(class CDSAPublicKey const &, class TBuf8<20> &)
+	_asm mov eax, 215
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_216 ()
+	{
+	// ; void KeyIdentifierUtil::RSAKeyIdentifierL(class CRSAPublicKey const &, class TBuf8<20> &)
+	_asm mov eax, 216
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_217 ()
+	{
+	// ; class TInteger & TInteger::operator++(void)
+	_asm mov eax, 217
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_218 ()
+	{
+	// ; class TInteger & TInteger::operator--(void)
+	_asm mov eax, 218
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_219 ()
+	{
+	// ; class RInteger TInteger::InverseModL(class TInteger const &) const
+	_asm mov eax, 219
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_220 ()
+	{
+	// ; class RInteger TInteger::TimesL(class TInteger const &) const
+	_asm mov eax, 220
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_221 ()
+	{
+	// ; public: __thiscall RInteger::RInteger(class RInteger const &)
+	_asm mov eax, 221
+	_asm jmp common_dispatch
+	}
+
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_222 ()
+	{
+	// ; public: class RInteger & __thiscall RInteger::operator=(class RInteger const &)
+	_asm mov eax, 222
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_223 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator*=(class TInteger const &)
+	_asm mov eax, 223
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_224 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator*=(int)
+	_asm mov eax, 224
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_225 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator+=(class TInteger const &)
+	_asm mov eax, 225
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_226 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator+=(int)
+	_asm mov eax, 226
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_227 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator-=(class TInteger const &)
+	_asm mov eax, 227
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_228 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator-=(int)
+	_asm mov eax, 228
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_229 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator/=(class TInteger const &)
+	_asm mov eax, 229
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_230 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator/=(int)
+	_asm mov eax, 230
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_231 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator%=(class TInteger const &)
+	_asm mov eax, 231
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_232 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator%=(int)
+	_asm mov eax, 232
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_233 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator>>=(unsigned int)
+	_asm mov eax, 233
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_234 ()
+	{
+	// ; public: class TInteger & __thiscall TInteger::operator<<=(unsigned int)
+	_asm mov eax, 234
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_235 ()
+	{
+	// ; public: int __thiscall TInteger::Bit(unsigned int)const 
+	_asm mov eax, 235
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_236 ()
+	{
+	// ; public: int __thiscall TInteger::ConvertToLongL(void)const 
+	_asm mov eax, 236
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_237 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::DividedByL(class TInteger const &)const 
+	_asm mov eax, 237
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_238 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::DividedByL(unsigned int)const 
+	_asm mov eax, 238
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_239 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::ExponentiateL(class TInteger const &)const 
+	_asm mov eax, 239
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_240 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::GCDL(class TInteger const &)const 
+	_asm mov eax, 240
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_241 ()
+	{
+	// ; public: int __thiscall TInteger::IsPrimeL(void)const 
+	_asm mov eax, 241
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_242 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::MinusL(class TInteger const &)const 
+	_asm mov eax, 242
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_243 ()
+	{
+	// ; public: static class RInteger  __cdecl TInteger::ModularMultiplyL(class TInteger const &,class TInteger const &,class TInteger const &)
+	_asm mov eax, 243
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_244 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::ModuloL(class TInteger const &)const 
+	_asm mov eax, 244
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_245 ()
+	{
+	// ; public: unsigned int __thiscall TInteger::ModuloL(unsigned int)const 
+	_asm mov eax, 245
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_246 ()
+	{
+	// ; public: void __thiscall TInteger::Negate(void)
+	_asm mov eax, 246
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_247 ()
+	{
+	// ; public: static class TInteger const & __cdecl TInteger::One(void)
+	_asm mov eax, 247
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_248 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::PlusL(class TInteger const &)const 
+	_asm mov eax, 248
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_249 ()
+	{
+	// ; public: void __thiscall TInteger::SetBit(unsigned int)
+	_asm mov eax, 249
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_250 ()
+	{
+	// ; public: int __thiscall TInteger::SignedCompare(class TInteger const &)const 
+	_asm mov eax, 250
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_251 ()
+	{
+	// ; public: int __thiscall TInteger::SignedCompare(int)const 
+	_asm mov eax, 251
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_252 ()
+	{
+	// ; public: class RInteger  __thiscall TInteger::SquaredL(void)const 
+	_asm mov eax, 252
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_253 ()
+	{
+	// ; public: static class TInteger const & __cdecl TInteger::Two(void)
+	_asm mov eax, 253
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_254 ()
+	{
+	// ; public: int __thiscall TInteger::UnsignedCompare(class TInteger const &)const 
+	_asm mov eax, 254
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_255 ()
+	{
+	// ; public: static class TInteger const & __cdecl TInteger::Zero(void)
+	_asm mov eax, 255
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_256 ()
+	{
+	// ; public: void __thiscall TInteger::CopyL(class TInteger const &,int)
+	_asm mov eax, 256
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_257 ()
+	{
+	// ; public: void __thiscall TInteger::CopyL(int,int)
+	_asm mov eax, 257
+	_asm jmp common_dispatch
+	}
+
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_258 ()
+	{
+	// ; public: void __thiscall TInteger::Set(class RInteger const &)
+	_asm mov eax, 258
+	_asm jmp common_dispatch
+	}
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_259 ()
+	{
+	// ; public: TBool __thiscall CDES::IsWeakKey(const TDesC8& aKey)
+	_asm mov eax, 259
+	_asm jmp common_dispatch
+	}	
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_260 ()
+	{
+	// ; public: class HBufC8 * __thiscall TInteger::BufferWithNoTruncationLC(void)const 
+	_asm mov eax, 260
+	_asm jmp common_dispatch
+	}
+			
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_261 ()
+	{
+	// ; public: void __thiscall CMontgomeryStructure::NewLC(const TInteger&)
+	_asm mov eax, 261
+	_asm jmp common_dispatch
+	}	
+	
+__declspec(dllexport)
+__declspec(naked)
+void call_vector_262 ()
+	{
+	// ; public: void __thiscall CMontgomeryStructure::ExponentiateL(const TInteger&, const TInteger&) const
+	//
+	_asm mov eax, 262
+	_asm jmp common_dispatch
+	}	
+}
+#define MAX_ORDINAL 262
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/cryptoswitch/cryptoswitch.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,83 @@
+/*
+* 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 <emulator.h>
+
+
+extern "C" {
+
+#include "cryptography_stubs.h"
+
+FARPROC vector[MAX_ORDINAL+1];
+
+void fill_vector(HINSTANCE aDll)
+	{
+	int i;
+	for (i=1;i<=MAX_ORDINAL;i++)
+		{
+		vector[i] = GetProcAddress(aDll, (LPCSTR)i);
+		}
+	vector[0] = (FARPROC)1;		// initialised
+	}
+
+void init_vector()
+	{
+	__LOCK_HOST;		// prevent deadlock with EKA2 scheduler
+
+	HINSTANCE instance;
+	
+	// Try for strong cryptography
+	//
+	instance = LoadLibraryA("strong_cryptography.dll"); 
+	if (instance != NULL)
+		{
+		fill_vector(instance);
+		return;
+		}
+		
+	// Try for weak cryptography
+	//
+	instance = LoadLibraryA("weak_cryptography.dll"); 
+	if (instance != NULL)
+		{
+		fill_vector(instance);
+		return;
+		}
+	
+	// die
+	//
+	OutputDebugStringA("Unable to load cryptography implementation");
+	_asm int 3;
+	}
+	
+__declspec(naked) void common_dispatch()
+	{
+	_asm cmp	dword ptr vector,0		// initialised?
+	_asm jne  	call_though_vector
+	_asm push	eax
+	_asm push	ecx
+	_asm push	edx
+	_asm call	init_vector
+	_asm pop	edx
+	_asm pop 	ecx
+	_asm pop 	eax
+call_though_vector:
+	_asm jmp	[vector+eax*4]
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/hash.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,138 @@
+/*
+* Copyright (c) 2005-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: 
+* (c) 1999-2003 Symbian Ltd. All rights reserved
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <e32std.h>
+#include <hash.h>
+#define EXPANDLOOP
+
+EXPORT_C CMessageDigest::CMessageDigest(void):CBase()
+{}
+
+EXPORT_C CMessageDigest::CMessageDigest(const CMessageDigest& /*aMD*/):CBase()
+{}
+
+EXPORT_C CMessageDigest::~CMessageDigest(void)
+{}
+
+/* Note that the shifts here are NOT guaranteed to work if s == 0, and it is
+ * assumed in R() (and hence in all inline) that a is unsigned. */
+// CMD_R - rotate a left by n bits; the main bottleneck of the algorithm 
+// implementation
+/*
+C++ version compiles to:
+
+CMD_R__FUiUi:
+	add	r3, r0, #0
+	lsl	r3, r3, r1
+	mov	r2, #32
+	sub	r2, r2, r1
+	lsr	r0, r0, r2
+	add	r3, r3, r0
+	add	r0, r3, #0
+	bx	lr
+
+*/
+
+TInt CMessageDigest::GetExtension(TUint aExtensionId, TAny*& a0, TAny* a1)
+	{
+	return Extension_(aExtensionId, a0, a1);
+	}
+
+
+//////////////////////////////////////////////////////////////////
+//	Factory class to create CMessageDigest derived objects
+//////////////////////////////////////////////////////////////////
+EXPORT_C CMessageDigest* CMessageDigestFactory::NewDigestL(CMessageDigest::THashId aHashId)
+{
+	CMessageDigest* hash = NULL;
+	switch (aHashId)
+	{
+	case (CMessageDigest::EMD2):
+		{
+			hash = CMD2::NewL();
+			break;
+		}
+	case (CMessageDigest::EMD5):
+		{
+			hash = CMD5::NewL();
+			break;
+		}
+	case (CMessageDigest::ESHA1):
+		{
+			hash = CSHA1::NewL();
+			break;
+		}
+	case (CMessageDigest::EMD4):
+		{
+			hash = CMD4::NewL();
+			break;
+		}
+	case (CMessageDigest::ESHA224):
+		{
+			hash = CSHA2::NewL(E224Bit);
+			break;
+		}
+	case (CMessageDigest::ESHA256):
+		{
+			hash = CSHA2::NewL(E256Bit);
+			break;
+		}
+	case (CMessageDigest::ESHA384):
+		{
+			hash = CSHA2::NewL(E384Bit);
+			break;
+		}
+	case (CMessageDigest::ESHA512):
+		{
+			hash = CSHA2::NewL(E512Bit);
+			break;
+		}
+	case (CMessageDigest::HMAC):
+	default:	
+		User::Leave(KErrNotSupported);
+	}
+
+	return (hash);
+}
+
+EXPORT_C CMessageDigest* CMessageDigestFactory::NewDigestLC(CMessageDigest::THashId aHashId)
+{
+	CMessageDigest* hash = CMessageDigestFactory::NewDigestL(aHashId);
+	CleanupStack::PushL(hash);
+	return (hash);
+}
+
+EXPORT_C CMessageDigest* CMessageDigestFactory::NewHMACL(CMessageDigest::THashId aHashId, const TDesC8& aKey)
+{
+	CMessageDigest* hash = CMessageDigestFactory::NewDigestLC(aHashId);
+	CMessageDigest* hmac = CHMAC::NewL(aKey, hash);
+	CleanupStack::Pop(hash);	//	Now owned by hmac
+	return (hmac);
+}
+
+EXPORT_C CMessageDigest* CMessageDigestFactory::NewHMACLC(CMessageDigest::THashId aHashId, const TDesC8& aKey)
+{
+	CMessageDigest* hmac = CMessageDigestFactory::NewHMACL(aHashId, aKey);
+	CleanupStack::PushL(hmac);
+	return (hmac);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/hashshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,856 @@
+/*
+* Copyright (c) 2006-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: 
+* hash shim implementation
+* hash shim implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "hashshim.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "keys.h"
+
+
+using namespace CryptoSpi;
+
+//
+// MD2 shim implementation
+//
+CMD2Shim* CMD2Shim::NewL()
+	{
+	CMD2Shim* self=CMD2Shim::NewLC();
+	CleanupStack::Pop();
+	return self;	
+	}
+
+CMD2Shim* CMD2Shim::NewLC()
+	{
+	CMD2Shim* self=new(ELeave) CMD2Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;	
+	}
+
+TInt CMD2Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (KHashInterfaceUid.iUid==aExtensionId && iHashImpl)
+		{
+		a0=iHashImpl;
+		ret=KErrNone;	
+		}
+		
+	return ret;
+	}
+
+CMD2Shim::CMD2Shim()
+	{		
+	}
+
+CMD2Shim::~CMD2Shim()
+	{
+	delete iHashImpl;				
+	}
+
+
+void CMD2Shim::ConstructL()
+	{	
+	CHashFactory::CreateHashL(iHashImpl,
+							KMd2Uid,
+							KHashModeUid,
+							NULL, NULL);
+	}
+
+CMessageDigest* CMD2Shim::CopyL()
+	{
+	CMD2Shim* copy=new(ELeave) CMD2Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->CopyL();
+	CleanupStack::Pop();
+	return copy;
+	}
+	
+CMessageDigest* CMD2Shim::ReplicateL()
+	{
+	CMD2Shim* copy=new(ELeave) CMD2Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->ReplicateL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+
+TInt CMD2Shim::BlockSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iBlockSize/8;
+	}
+
+TInt CMD2Shim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}	
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+	}
+
+void CMD2Shim::Update(const TDesC8& aMessage)
+	{
+	iHashImpl->Update(aMessage);	
+	}
+	
+	
+TPtrC8 CMD2Shim::Final(const TDesC8& aMessage)
+	{
+	return iHashImpl->Final(aMessage);
+	}
+
+TPtrC8 CMD2Shim::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+	return iHashImpl->Final(ptr);
+	}
+		
+void CMD2Shim::Reset()
+	{
+	iHashImpl->Reset();
+	}
+	
+
+TPtrC8 CMD2Shim::Hash(const TDesC8& aMessage)
+	{
+	return iHashImpl->Hash(aMessage);
+	}
+
+//
+// Implementation of MD5 shim
+//
+CMD5Shim* CMD5Shim::NewL()
+	{
+	CMD5Shim* self=CMD5Shim::NewLC();
+	CleanupStack::Pop();
+	return self;	
+	}
+
+CMD5Shim* CMD5Shim::NewLC()
+	{
+	
+	CMD5Shim* self=new(ELeave) CMD5Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;	
+	
+	}
+
+CMD5Shim::CMD5Shim()
+	{		
+	}
+	
+TInt CMD5Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (KHashInterfaceUid.iUid==aExtensionId && iHashImpl)
+		{
+		a0=iHashImpl;
+		ret=KErrNone;	
+		}
+		
+	return ret;
+	}
+
+CMD5Shim::~CMD5Shim()
+	{
+	delete iHashImpl;				
+	}
+
+
+void CMD5Shim::ConstructL()
+	{	
+	CHashFactory::CreateHashL(iHashImpl,
+							KMd5Uid,
+							KHashModeUid,
+							NULL,
+							NULL);
+	}
+
+CMessageDigest* CMD5Shim::CopyL()
+	{
+	CMD5Shim* copy=new(ELeave) CMD5Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->CopyL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+CMessageDigest* CMD5Shim::ReplicateL()
+	{
+	CMD5Shim* copy=new(ELeave) CMD5Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->ReplicateL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+TInt CMD5Shim::BlockSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}		
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iBlockSize/8;
+	}
+
+TInt CMD5Shim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}		
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+	}
+
+void CMD5Shim::Update(const TDesC8& aMessage)
+	{
+	iHashImpl->Update(aMessage);	
+	}
+	
+TPtrC8 CMD5Shim::Final(const TDesC8& aMessage)
+	{
+	return iHashImpl->Final(aMessage);
+	}
+
+TPtrC8 CMD5Shim::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+	return iHashImpl->Final(ptr);
+	}
+		
+void CMD5Shim::Reset()
+	{
+	iHashImpl->Reset();
+	}
+	
+
+TPtrC8 CMD5Shim::Hash(const TDesC8& aMessage)
+	{
+	return iHashImpl->Hash(aMessage);
+	}
+	
+//
+// Implementation of SHA1 shim
+//	
+	
+CSHA1Shim* CSHA1Shim::NewL()
+	{
+	CSHA1Shim* self=CSHA1Shim::NewLC();
+	CleanupStack::Pop();
+	return self;	
+	}
+
+CSHA1Shim* CSHA1Shim::NewLC()
+	{
+	
+	CSHA1Shim* self=new(ELeave) CSHA1Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;	
+	
+	}
+
+CSHA1Shim::CSHA1Shim()
+	{		
+	}
+	
+	
+TInt CSHA1Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (KHashInterfaceUid.iUid==aExtensionId && iHashImpl)
+		{
+		a0=iHashImpl;
+		ret=KErrNone;	
+		}
+		
+	return ret;
+	}
+
+CSHA1Shim::~CSHA1Shim()
+	{
+	delete iHashImpl;			
+	}
+
+
+void CSHA1Shim::ConstructL()
+	{
+	CHashFactory::CreateHashL(iHashImpl,
+							KSha1Uid,
+							KHashModeUid,
+							NULL,
+							NULL);
+	}
+
+CMessageDigest* CSHA1Shim::CopyL()
+	{
+	CSHA1Shim* copy=new(ELeave) CSHA1Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->CopyL();
+	CleanupStack::Pop();
+	return copy;
+	}
+	
+CMessageDigest* CSHA1Shim::ReplicateL()
+	{
+	CSHA1Shim* copy=new(ELeave) CSHA1Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->ReplicateL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+TInt CSHA1Shim::BlockSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}	
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iBlockSize/8;
+	}
+
+TInt CSHA1Shim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+	}
+
+void CSHA1Shim::Update(const TDesC8& aMessage)
+	{
+	iHashImpl->Update(aMessage);	
+	}
+	
+TPtrC8 CSHA1Shim::Final(const TDesC8& aMessage)
+	{
+	return iHashImpl->Final(aMessage);
+	}
+
+TPtrC8 CSHA1Shim::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+	return iHashImpl->Final(ptr);
+	}
+		
+void CSHA1Shim::Reset()
+	{
+	iHashImpl->Reset();
+	}
+
+TPtrC8 CSHA1Shim::Hash(const TDesC8& aMessage)
+	{
+	return iHashImpl->Hash(aMessage);
+	}
+	
+
+//
+// Implementation of SHA2 shim
+//	
+	
+CSHA2Shim* CSHA2Shim::NewL(TSH2Algo aAlgorithmId)
+	{
+	CSHA2Shim* self=CSHA2Shim::NewLC(aAlgorithmId);
+	CleanupStack::Pop();
+	return self;	
+	}
+
+CSHA2Shim* CSHA2Shim::NewLC(TSH2Algo aAlgorithmId)
+	{
+	
+	CSHA2Shim* self=new(ELeave) CSHA2Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aAlgorithmId);
+	return self;
+	}
+
+CSHA2Shim::CSHA2Shim()
+	{		
+	}
+	
+TInt CSHA2Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (KHashInterfaceUid.iUid==aExtensionId && iHashImpl)
+		{
+		a0=iHashImpl;
+		ret=KErrNone;	
+		}
+	return ret;
+	}
+
+CSHA2Shim::~CSHA2Shim()
+	{
+	delete iHashImpl;			
+	}
+
+void CSHA2Shim::ConstructL(TSH2Algo aAlgorithmId)
+	{
+	TUid algoId = {0};
+	switch(aAlgorithmId)
+		{
+		case E224Bit:
+			{
+			algoId = KSha224Uid;
+			break;
+			}
+		case E256Bit:
+			{
+			algoId = KSha256Uid;
+			break;
+			}
+		case E384Bit:
+			{
+			algoId = KSha384Uid;
+			break;
+			}
+		case E512Bit:
+			{
+			algoId = KSha512Uid;
+			break;
+			}
+		default:
+			User::Leave(KErrNotSupported);
+		}
+	
+	CHashFactory::CreateHashL(iHashImpl,
+							  algoId,
+							  KHashModeUid,
+							  NULL,
+							  NULL);				
+	}
+
+CMessageDigest* CSHA2Shim::CopyL()
+	{
+	CSHA2Shim* copy=new(ELeave) CSHA2Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->CopyL();
+	CleanupStack::Pop();
+	return copy;
+	}
+	
+CMessageDigest* CSHA2Shim::ReplicateL()
+	{
+	CSHA2Shim* copy=new(ELeave) CSHA2Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->ReplicateL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+TInt CSHA2Shim::BlockSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}	
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iBlockSize/8;
+	}
+
+TInt CSHA2Shim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+	}
+
+void CSHA2Shim::Update(const TDesC8& aMessage)
+	{
+	iHashImpl->Update(aMessage);	
+	}
+	
+TPtrC8 CSHA2Shim::Final(const TDesC8& aMessage)
+	{
+	return iHashImpl->Final(aMessage);
+	}
+
+TPtrC8 CSHA2Shim::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+	return iHashImpl->Final(ptr);
+	}
+		
+void CSHA2Shim::Reset()
+	{
+	iHashImpl->Reset();
+	}
+
+TPtrC8 CSHA2Shim::Hash(const TDesC8& aMessage)
+	{
+	return iHashImpl->Hash(aMessage);
+	}
+
+//
+// Implementation of HMAC shim
+//	
+
+CHMACShim* CHMACShim::NewL(const TDesC8& aKey, CMessageDigest* aDigest)
+	{
+	CHMACShim* self(0);
+	
+	// Check whether the hash contains an SPI plug-in
+	TAny* implPtr(0);
+	TInt err = aDigest->GetExtension(CryptoSpi::KHashInterface, implPtr, NULL);	
+	if (err == KErrNone && implPtr)
+		{
+		CryptoSpi::CHash* impl(static_cast<CryptoSpi::CHash*>(implPtr));
+		const CryptoSpi::TCharacteristics* c(0);
+		impl->GetCharacteristicsL(c);
+		const CryptoSpi::THashCharacteristics* hashCharacteristics(static_cast<const CryptoSpi::THashCharacteristics*>(c));
+			
+		
+		// Verify that the plug-in supports Hmac mode
+		if (hashCharacteristics->IsOperationModeSupported(CryptoSpi::KHmacModeUid))
+			{
+			
+	#ifndef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT				
+			// Make an own copy
+			CHash* myHash=impl->ReplicateL();
+			CleanupStack::PushL(myHash);	
+	#endif	
+			// Set the key
+			TKeyProperty keyProperty = {KHmacModeUid, KNullUid, KSymmetricKey, KNonEmbeddedKeyUid};
+		 	CCryptoParams* keyParam =CCryptoParams::NewLC();
+		 	keyParam->AddL(aKey, KHmacKeyParameterUid);
+		 	CKey* uniKey= CKey::NewLC(keyProperty, *keyParam);
+	#ifndef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT		
+		 	myHash->SetKeyL(*uniKey);		 			 	
+		 	CleanupStack::PopAndDestroy(2, keyParam);
+			// Set hash to Hmac mode			
+			myHash->SetOperationModeL(CryptoSpi::KHmacModeUid);
+			self = new(ELeave) CHMACShim(myHash, aDigest);
+			CleanupStack::Pop(myHash);
+	#else 	
+		 	TUid algorithmUID = algorithmUID.Uid(hashCharacteristics->cmn.iAlgorithmUID);
+			//Create a pointer for the Mac Implementation Object
+			CMac* macImpl = NULL;
+			CMacFactory::CreateMacL(macImpl,algorithmUID,*uniKey, NULL);
+			CleanupStack::PushL(macImpl);
+		 	self = new(ELeave) CHMACShim(macImpl, aDigest,uniKey, algorithmUID);
+		 	CleanupStack::Pop(macImpl);
+		 	CleanupStack::Pop(uniKey);			
+		 	CleanupStack::PopAndDestroy(keyParam);
+	#endif		 	
+			}
+		}				
+	return self;
+	}
+	
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+
+CHMACShim::CHMACShim(CryptoSpi::CMac* aImpl, CMessageDigest* aDigest, CryptoSpi::CKey* aKey, TUid aAlgorithmUid)
+	: CHMAC(aDigest), iMacImpl(aImpl), iKey(aKey), iAlgorithmUid(aAlgorithmUid)
+	{		
+	}
+
+#else
+
+CHMACShim::CHMACShim(CryptoSpi::CHash* aImpl, CMessageDigest* aDigest)
+	: CHMAC(aDigest), iMacImpl(aImpl)
+	{		
+	}
+
+#endif
+
+CHMACShim::CHMACShim()
+	{		
+	}
+
+CHMACShim::~CHMACShim()
+	{
+	delete iMacImpl;
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT		
+	delete iKey;
+#endif
+	}
+
+TInt CHMACShim::BlockSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iMacImpl->GetCharacteristicsL(ptr));
+
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}
+
+#ifndef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT			
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iBlockSize/8;
+#else		
+	const TMacCharacteristics* macPtr=static_cast<const TMacCharacteristics*>(ptr);
+	return macPtr->iHashAlgorithmChar->iBlockSize/8;
+#endif	
+	}
+
+TInt CHMACShim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iMacImpl->GetCharacteristicsL(ptr));
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}
+
+#ifndef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT			
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+#else			
+	const TMacCharacteristics* macPtr=static_cast<const TMacCharacteristics*>(ptr);
+	return macPtr->iHashAlgorithmChar->iOutputSize/8;
+#endif	
+	}
+
+void CHMACShim::Update(const TDesC8& aMessage)
+	{
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
+	// The error is ignored as the legacy code methods are non-leaving and they call 
+	// the new MAC interfaces which uses leaving methods for processing MAC value. 	
+	// This call always call the non-leaving legacy method.	
+	TRAP_IGNORE(iMacImpl->UpdateL(aMessage));
+#else
+	iMacImpl->Update(aMessage);
+#endif	
+	}
+	
+TPtrC8 CHMACShim::Final(const TDesC8& aMessage)
+	{
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
+	TPtrC8 macPtr(KNullDesC8());
+	// The error is ignored as the legacy code methods are non-leaving and they call 
+	// the new MAC interfaces which uses leaving methods for processing MAC value. 	
+	// This call always call the non-leaving legacy method.	
+	TRAP_IGNORE(macPtr.Set(iMacImpl->FinalL(aMessage)));	
+	return macPtr;
+#else
+	return iMacImpl->Final(aMessage);
+#endif	
+	}
+
+TPtrC8 CHMACShim::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
+	TPtrC8 macPtr(KNullDesC8());
+	// The error is ignored as the legacy code methods are non-leaving and they call 
+	// the new MAC interfaces which uses leaving methods for processing MAC value. 	
+	// This call always call the non-leaving legacy method.	
+	TRAP_IGNORE(macPtr.Set(iMacImpl->FinalL(ptr)));	
+	return macPtr;
+#else
+	return iMacImpl->Final(ptr);
+#endif	
+	}
+		
+void CHMACShim::Reset()
+	{
+	iMacImpl->Reset();
+	}
+	
+TPtrC8 CHMACShim::Hash(const TDesC8& aMessage)
+	{
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	TPtrC8 macPtr(KNullDesC8());
+	// The error is ignored as the legacy code methods are non-leaving and they call 
+	// the new MAC interfaces which uses leaving methods for processing MAC value. 	
+	// This call always call the non-leaving legacy method.	
+	TRAP_IGNORE(macPtr.Set(iMacImpl->MacL(aMessage)));	
+	return macPtr;
+#else
+	return iMacImpl->Hash(aMessage);
+#endif	
+	}
+	
+CMessageDigest* CHMACShim::ReplicateL()
+	{
+	CHMACShim* copy=new(ELeave) CHMACShim();
+	CleanupStack::PushL(copy);
+	copy->iMacImpl=iMacImpl->ReplicateL();
+	CleanupStack::Pop(copy);
+	return copy;	
+	}
+	
+CMessageDigest* CHMACShim::CopyL()
+	{
+	CHMACShim* copy=new(ELeave) CHMACShim();
+	CleanupStack::PushL(copy);
+	copy->iMacImpl=iMacImpl->CopyL();
+	CleanupStack::Pop(copy);
+	return copy;	
+	}
+
+//
+// Implemetation of MD4 shim
+//
+CMD4Shim* CMD4Shim::NewL()
+	{
+	CMD4Shim* self=CMD4Shim::NewLC();
+	CleanupStack::Pop();
+	return self;	
+	}
+
+CMD4Shim* CMD4Shim::NewLC()
+	{
+	CMD4Shim* self=new(ELeave) CMD4Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;	
+	}
+
+CMD4Shim::CMD4Shim()
+	{		
+	}
+	
+TInt CMD4Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (KHashInterfaceUid.iUid==aExtensionId && iHashImpl)
+		{
+		a0=iHashImpl;
+		ret=KErrNone;	
+		}
+		
+	return ret;
+	}
+
+CMD4Shim::~CMD4Shim()
+	{
+	delete iHashImpl;				
+	}
+
+
+void CMD4Shim::ConstructL()
+	{	
+	CHashFactory::CreateHashL(iHashImpl,KMd4Uid,KHashModeUid,NULL,NULL);
+	}
+
+CMessageDigest* CMD4Shim::CopyL()
+	{
+	CMD4Shim* copy=new(ELeave) CMD4Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->CopyL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+CMessageDigest* CMD4Shim::ReplicateL()
+	{
+	CMD4Shim* copy=new(ELeave) CMD4Shim();
+	CleanupStack::PushL(copy);
+	copy->iHashImpl=iHashImpl->ReplicateL();
+	CleanupStack::Pop();
+	return copy;
+	}
+
+TInt CMD4Shim::BlockSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}		
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iBlockSize/8;
+	}
+
+TInt CMD4Shim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return ((err>0)? KErrGeneral : err);
+		}		
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+	}
+
+void CMD4Shim::Update(const TDesC8& aMessage)
+	{
+	iHashImpl->Update(aMessage);	
+	}
+	
+TPtrC8 CMD4Shim::Final(const TDesC8& aMessage)
+	{
+	return iHashImpl->Final(aMessage);
+	}
+
+TPtrC8 CMD4Shim::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+	return iHashImpl->Final(ptr);
+	}
+		
+void CMD4Shim::Reset()
+	{
+	iHashImpl->Reset();
+	}
+	
+
+TPtrC8 CMD4Shim::Hash(const TDesC8& aMessage)
+	{
+	return iHashImpl->Hash(aMessage);
+	}
+	
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/hashshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,244 @@
+/*
+* Copyright (c) 2006-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: 
+* hash shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __HASHSHIM_H__
+#define __HASHSHIM_H__
+
+#include <e32def.h>
+#include <hash.h>
+#include <cryptospi/cryptohashapi.h>
+#include "keys.h"
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT
+	#include <cryptospi/cryptomacapi.h>
+#endif
+
+//
+// MD2 shim class
+//
+NONSHARABLE_CLASS(CMD2Shim) : public CMD2
+	{
+public:
+
+	static CMD2Shim* NewL();
+	static CMD2Shim* NewLC();
+	~CMD2Shim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize()	;
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);	
+	CMessageDigest* ReplicateL();
+	
+protected:
+	//virtual from CBase
+	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	CMD2Shim();
+	void ConstructL();
+	
+private:
+	CryptoSpi::CHash* iHashImpl;
+	};
+
+
+//
+// MD5 shim class
+//
+
+NONSHARABLE_CLASS(CMD5Shim) : public CMD5
+	{
+public:
+	static CMD5Shim* NewL();
+	static CMD5Shim* NewLC();
+	~CMD5Shim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize()	;
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);
+	CMessageDigest* ReplicateL();
+	
+protected:
+	//virtual from CBase
+	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	CMD5Shim();
+	void ConstructL();
+	
+private:
+	CryptoSpi::CHash* iHashImpl;
+	};
+
+
+
+//
+// SHA1 shim class
+//
+
+NONSHARABLE_CLASS(CSHA1Shim) : public CSHA1
+	{
+public:
+	static CSHA1Shim* NewL();
+	static CSHA1Shim* NewLC();
+	~CSHA1Shim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize()	;
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);
+	CMessageDigest* ReplicateL();
+	
+protected:
+	//virtual from CBase
+	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	CSHA1Shim();
+	void ConstructL();
+	
+private:
+	CryptoSpi::CHash* iHashImpl;
+	};
+
+//
+// SHA2 shim class
+//
+
+NONSHARABLE_CLASS(CSHA2Shim) : public CSHA2
+	{
+public:
+	static CSHA2Shim* NewL(TSH2Algo aAlgorithmId);
+	static CSHA2Shim* NewLC(TSH2Algo aAlgorithmId);
+	~CSHA2Shim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize()	;
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);
+	CMessageDigest* ReplicateL();
+	
+protected:
+	//virtual from CBase
+	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	CSHA2Shim();
+	void ConstructL(TSH2Algo aAlgorithmId);
+	
+private:
+	CryptoSpi::CHash* iHashImpl;
+	};
+
+
+
+//
+// HMac shim class
+//
+
+NONSHARABLE_CLASS(CHMACShim) : public CHMAC
+	{
+public:	
+	static CHMACShim* NewL(const TDesC8& aKey, CMessageDigest* aDigest);
+	static CHMACShim* NewLC(const TDesC8& aKey, CMessageDigest* aDigest);
+	~CHMACShim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize()	;
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);
+	CMessageDigest* ReplicateL();
+
+private:
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	CHMACShim(CryptoSpi::CMac* aImpl, CMessageDigest* aDigest, CryptoSpi::CKey* aKey, TUid aAlgorithmUid);
+#else
+	CHMACShim(CryptoSpi::CHash* aImpl, CMessageDigest* aDigest);
+#endif	
+	CHMACShim();
+	void ConstructL(const TDesC8& aKey, TUid aAlgorithmUid, CMessageDigest* aDigest);
+	
+private:
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	CryptoSpi::CMac* iMacImpl;
+	CryptoSpi::CKey* iKey;
+	TUid iAlgorithmUid;
+#else
+	CryptoSpi::CHash* iMacImpl;
+#endif
+	};
+
+//
+// MD4 shim class
+//
+
+NONSHARABLE_CLASS(CMD4Shim) : public CMD4
+	{
+public:
+	static CMD4Shim* NewL();
+	static CMD4Shim* NewLC();
+	~CMD4Shim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize();
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);
+	CMessageDigest* ReplicateL();
+	
+protected:
+	//virtual from CBase
+	virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	CMD4Shim();
+	void ConstructL();
+	
+private:
+	CryptoSpi::CHash* iHashImpl;
+	};
+
+#endif // __HASHSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/hmac.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,256 @@
+/*
+* Copyright (c) 2005-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 <e32std.h>
+#include <hash.h>
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/cryptohashapi.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "hashshim.h"
+
+
+#define EXPANDLOOP
+
+//
+// HMAC implementation
+//
+
+CHMAC::CHMAC()
+	{
+	}
+
+
+CHMAC::CHMAC(CMessageDigest* aDigest)
+	:CMessageDigest(),
+	iDigest(aDigest),
+	iInnerPad(KMaxBlockSize),
+	iOuterPad(KMaxBlockSize)
+	{
+	}
+
+CHMAC::CHMAC(const CHMAC& aMD)
+	:CMessageDigest(aMD), 
+	iDigest(NULL),
+	iInnerPad(aMD.iInnerPad), 
+	iOuterPad(aMD.iOuterPad),
+	iBlockSize(aMD.iBlockSize)
+	{
+	}
+
+EXPORT_C CHMAC::~CHMAC(void)
+	{
+	delete iDigest;
+	}
+
+EXPORT_C CHMAC* CHMAC::NewL(const TDesC8& aKey,CMessageDigest* aDigest)
+	{		
+	CHMAC* self = CHMACShim::NewL(aKey, aDigest);
+	if (! self)
+		{			
+		// not able to use CryptoSpi, possibly due to an exterally 
+		// derived legacy class so fallback to old implementation.			
+		self=new(ELeave) CHMAC(aDigest);
+		CleanupStack::PushL(self);
+		self->InitialiseL(aKey);
+		CleanupStack::Pop(self);
+		}
+	return self;	
+	}
+
+
+// These methods are now deprecated. This is because hashes and HMACs
+// should be implemented as plugins to the SPI framework. However, for
+// binary compatibility reasons, these methods must be left here.
+// There are no tests (hence no coverage) for HMACs outside the plugin
+// framework, but this original code is left unmodified.
+//
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+
+void CHMAC::InitialiseL(const TDesC8& aKey)
+	{
+	InitBlockSizeL();
+	// initialisation
+	if (iDigest)
+		{
+		iDigest->Reset();
+		if( (TUint32)aKey.Size() > iBlockSize)
+			{
+			iInnerPad = iDigest->Final(aKey);
+			}
+		else 
+			{
+			iInnerPad = aKey;
+			}
+			
+		TUint i;
+		for (i=iInnerPad.Size();i<iBlockSize;i++)
+			iInnerPad.Append(0);
+
+		iOuterPad=iInnerPad;
+
+		const TUint8 Magic1=0x36, Magic2=0x5c;
+		for (i=0;i<iBlockSize;i++)
+		{
+			iInnerPad[i]^=Magic1;
+			iOuterPad[i]^=Magic2;
+		}
+		//start inner hash
+		iDigest->Hash(iInnerPad);
+		}
+	}
+
+void CHMAC::InitBlockSizeL()
+ 	{
+	 if (iDigest)
+		{
+	 	iBlockSize = iDigest->BlockSize();
+		}
+	 if(iBlockSize > KMaxBlockSize)
+		 {
+		 User::Leave(KErrNotSupported);
+		 }
+ 	 
+ 	 iInnerPad.SetLength(iBlockSize);
+ 	 iOuterPad.SetLength(iBlockSize);
+ 	 iInnerPadCopy.SetLength(iBlockSize);
+ 	 iOuterPadCopy.SetLength(iBlockSize);
+   	}
+
+EXPORT_C CMessageDigest* CHMAC::CopyL(void)
+	{
+	CHMAC* that=new(ELeave) CHMAC(*this);
+	CleanupStack::PushL(that);
+	that->iDigest=iDigest ? iDigest->CopyL() : NULL;
+	CleanupStack::Pop();
+	return that;
+	}
+	
+EXPORT_C CMessageDigest*  CHMAC::ReplicateL(void)
+	{
+	CHMAC* that=new(ELeave) CHMAC(*this);
+	CleanupStack::PushL(that);
+	that->iDigest=iDigest ? iDigest->ReplicateL() : NULL;
+	that->Reset();
+	CleanupStack::Pop();
+	return that;
+	}
+
+EXPORT_C TInt CHMAC::BlockSize(void)
+	{
+	return iBlockSize;
+	}
+
+EXPORT_C TInt CHMAC::HashSize(void)
+	{
+	return iDigest ? iDigest->HashSize() : 0;
+	}
+	
+EXPORT_C void CHMAC::Reset(void)
+	{
+	if (iDigest)
+		{
+		iDigest->Reset();
+		iDigest->Update(iInnerPad);
+		}
+	}
+
+//	JCS, There may be a more efficient method but I can't find it
+//	because using the DoFinal/DoUpdate functions directly calls
+//	Store/Restore at inappropriate times and scribbles over stored
+//	data
+//	This is the only way I've found to both generate a hash value
+//	and get this in the correctly updated state
+EXPORT_C TPtrC8 CHMAC::Hash(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	TPtrC8 finalPtr(KNullDesC8());
+	StoreState();
+	if (iDigest)
+	{
+		ptr.Set(iDigest->Final(aMessage));
+		iDigest->Update(iOuterPad);
+		finalPtr.Set(iDigest->Final(ptr));
+	}
+
+	RestoreState();
+
+	if(iDigest)
+		{
+		iDigest->Update(aMessage);
+		}
+
+	return (finalPtr);
+	}
+
+EXPORT_C void CHMAC::Update(const TDesC8& aMessage)
+	{
+	if(iDigest)
+		{
+		iDigest->Update(aMessage);
+		}
+	}
+
+EXPORT_C TPtrC8 CHMAC::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if(iDigest)
+		{
+		ptr.Set(iDigest->Final(aMessage));
+		iDigest->Update(iOuterPad);
+		iDigest->Final(ptr);
+		Reset();
+		}
+	return (ptr);
+	}
+
+EXPORT_C TPtrC8 CHMAC::Final()
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if(iDigest)
+		{
+		ptr.Set(iDigest->Final());
+		iDigest->Update(iOuterPad);
+		iDigest->Final(ptr);
+		Reset();
+		}
+	return (ptr);
+	}
+
+void CHMAC::RestoreState()
+	{
+	iOuterPad.Copy(iOuterPadCopy);
+	iInnerPad.Copy(iInnerPadCopy);
+	if (iDigest)
+		iDigest->RestoreState();
+	}
+
+void CHMAC::StoreState()
+	{
+	iOuterPadCopy.Copy(iOuterPad);
+	iInnerPadCopy.Copy(iInnerPad);
+	if (iDigest)
+		iDigest->StoreState();
+	}
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/md2.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,118 @@
+/*
+* Copyright (c) 2003-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 <e32std.h>
+#include <hash.h>
+#include "hashshim.h"
+
+#define EXPANDLOOP
+
+//
+// 32bit endianness independent MD2 implementation
+//
+CMD2::CMD2()
+	{		
+	}
+	
+EXPORT_C CMD2* CMD2::NewL(void)
+	{
+	return CMD2Shim::NewL();
+	}
+	
+EXPORT_C CMD2::~CMD2(void)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+EXPORT_C CMessageDigest* CMD2::ReplicateL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	return NULL;	
+	}
+	
+EXPORT_C TPtrC8 CMD2::Hash(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	return KNullDesC8();
+	}
+
+EXPORT_C CMessageDigest* CMD2::CopyL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	return NULL;	
+	}
+
+EXPORT_C TInt CMD2::BlockSize(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+	
+EXPORT_C TInt CMD2::HashSize(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+	
+EXPORT_C void CMD2::Reset(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+EXPORT_C void CMD2::Update(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+EXPORT_C TPtrC8 CMD2::Final(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+EXPORT_C TPtrC8 CMD2::Final()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+void CMD2::RestoreState()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);		
+	}
+
+void CMD2::StoreState()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);		
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/md4.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,123 @@
+/*
+* Copyright (c) 2007-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 <e32std.h>
+#include <hash.h>
+#include "hashshim.h"
+
+#define EXPANDLOOP
+
+
+CMD4::CMD4()
+	{
+	}
+	
+EXPORT_C CMD4* CMD4::NewL(void)
+	{
+	CMD4Shim* self=CMD4Shim::NewL();
+	self->Reset();
+	return self;		
+	}
+
+EXPORT_C CMD4::~CMD4(void)
+	{
+	}
+ 
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+		
+EXPORT_C CMessageDigest* CMD4::ReplicateL(void)
+	{
+	// Method replaced by shim
+ 	ASSERT(EFalse);
+
+	return NULL;	
+	}
+	
+
+EXPORT_C TPtrC8 CMD4::Hash(const TDesC8& /*aMessage*/)
+	{
+    // Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+EXPORT_C CMessageDigest* CMD4::CopyL(void)
+	{
+    // Method replaced by shim
+	ASSERT(EFalse);
+	return NULL;	
+	}
+	
+EXPORT_C TInt CMD4::BlockSize(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+	
+EXPORT_C TInt CMD4::HashSize(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+	
+EXPORT_C void CMD4::Reset(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+EXPORT_C void CMD4::Update(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+	
+EXPORT_C TPtrC8 CMD4::Final(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+EXPORT_C TPtrC8 CMD4::Final()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+void CMD4::RestoreState()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+void CMD4::StoreState()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+	
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/md5.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,120 @@
+/*
+* Copyright (c) 2003-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 <e32std.h>
+#include <hash.h>
+#include "hashshim.h"
+
+#define EXPANDLOOP
+
+//
+// 32bit endianness independent MD5 implementation
+//
+CMD5::CMD5()
+	{
+	}
+	
+EXPORT_C CMD5* CMD5::NewL(void)
+	{
+	CMD5Shim* self=CMD5Shim::NewL();
+	self->Reset();
+	return self;		
+	}
+		
+EXPORT_C CMD5::~CMD5(void)
+	{
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+EXPORT_C CMessageDigest* CMD5::ReplicateL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return NULL;	
+	}
+	
+EXPORT_C TPtrC8 CMD5::Hash(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+EXPORT_C CMessageDigest* CMD5::CopyL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return NULL;	
+	}
+	
+EXPORT_C TInt CMD5::BlockSize(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+	
+EXPORT_C TInt CMD5::HashSize(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+	
+EXPORT_C void CMD5::Reset(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+EXPORT_C void CMD5::Update(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+	
+EXPORT_C TPtrC8 CMD5::Final(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+EXPORT_C TPtrC8 CMD5::Final()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+void CMD5::RestoreState()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+void CMD5::StoreState()
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/sha1.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,190 @@
+/*
+* Copyright (c) 2003-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 <e32std.h>
+#include <hash.h>
+#include "hashshim.h"
+
+#define EXPANDLOOP
+
+//
+// 32bit endian-independent SHA-1 implementation
+//
+CSHA1::CSHA1()
+	{		
+	}
+	
+EXPORT_C CSHA1* CSHA1::NewL(void)
+	{
+	CSHA1* self=CSHA1Shim::NewL();
+	self->Reset();
+	return self;
+	}
+	
+EXPORT_C CSHA1::~CSHA1(void)
+	{
+	}
+	
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+EXPORT_C CMessageDigest* CSHA1::ReplicateL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	return NULL;
+	}
+
+EXPORT_C TPtrC8 CSHA1::Hash(const TDesC8& /*aMessage*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	return KNullDesC8();
+	}
+
+EXPORT_C CMessageDigest* CSHA1::CopyL(void)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	return NULL;
+	}
+	
+EXPORT_C TInt CSHA1::BlockSize(void)
+	{
+	ASSERT(EFalse);	
+	return KErrNotSupported;
+	}
+	
+EXPORT_C TInt CSHA1::HashSize(void)
+	{
+	ASSERT(EFalse);
+	return KErrNotSupported;
+	}
+
+EXPORT_C void CSHA1::Reset(void)
+	{
+	ASSERT(EFalse);
+	}
+
+EXPORT_C void CSHA1::Update(const TDesC8& /*aMessage*/)
+	{
+	ASSERT(EFalse);
+	}
+
+EXPORT_C TPtrC8 CSHA1::Final(const TDesC8& /*aMessage*/)
+	{
+	ASSERT(EFalse);	
+	return KNullDesC8();
+	}
+
+EXPORT_C TPtrC8 CSHA1::Final()
+	{
+	ASSERT(EFalse);
+	return KNullDesC8();
+	}
+
+void CSHA1::RestoreState()
+	{
+	ASSERT(EFalse);
+	}
+
+void CSHA1::StoreState()
+	{
+	ASSERT(EFalse);
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+//	CSHA code is deprecated
+///////////////////////////////////////////////////////////////////////////////////////
+
+_LIT(KSHA, "HASH::CSHA");
+
+EXPORT_C CSHA* CSHA::NewL(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (NULL);	//	Shut compiler up
+}
+
+EXPORT_C CSHA::~CSHA(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+}
+
+EXPORT_C TPtrC8 CSHA::Hash(const TDesC8& /*aMessage*/)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (KNullDesC8());	//	Shut compiler up
+}
+
+EXPORT_C TInt CSHA::HashSize(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (-1);	//	Shut compiler up
+}
+
+EXPORT_C TInt CSHA::BlockSize(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (-1);	//	Shut compiler up
+}
+
+EXPORT_C CMessageDigest* CSHA::CopyL(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (NULL);	//	Shut compiler up
+}
+
+EXPORT_C CMessageDigest* CSHA::ReplicateL(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (NULL);	//	Shut compiler up
+}
+
+EXPORT_C void CSHA::Reset(void)
+{
+	User::Panic(KSHA, KErrNotSupported);
+}
+
+EXPORT_C void CSHA::Update(const TDesC8& /*aMessage*/)
+{
+	User::Panic(KSHA, KErrNotSupported);
+}
+
+EXPORT_C TPtrC8 CSHA::Final(const TDesC8& /*aMessage*/)
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (KNullDesC8());	//	Shut compiler up
+}
+
+EXPORT_C TPtrC8 CSHA::Final()
+{
+	User::Panic(KSHA, KErrNotSupported);
+	return (KNullDesC8());	//	Shut compiler up
+}
+
+void CSHA::RestoreState()
+{
+	User::Panic(KSHA, KErrNotSupported);
+}
+void CSHA::StoreState()
+{
+	User::Panic(KSHA, KErrNotSupported);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/hash/sha2.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,63 @@
+/*
+* Copyright (c) 2007-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 <e32std.h>
+#include <hash.h>
+#include "hashshim.h"
+
+//
+// SHA-2 implementation
+//
+CSHA2::CSHA2()
+	{		
+	}
+	
+EXPORT_C CSHA2* CSHA2::NewL(TSH2Algo aAlgorithmId)
+	{
+	CSHA2* self = CSHA2::NewLC(aAlgorithmId);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CSHA2* CSHA2::NewLC(TSH2Algo aAlgorithmId)
+	{
+	CSHA2* self =CSHA2Shim::NewLC(aAlgorithmId);
+	self->Reset();
+	return self;						
+	}	
+	
+EXPORT_C CSHA2::~CSHA2(void)
+	{
+	}
+	
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void CSHA2::RestoreState()
+	{
+	ASSERT(EFalse);
+	}
+
+void CSHA2::StoreState()
+	{
+	ASSERT(EFalse);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/padding/padding.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,370 @@
+/*
+* Copyright (c) 1999-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 <e32base.h>
+#include <random.h>
+#include <padding.h>
+#include <securityerr.h>
+#include <cryptopanic.h>
+
+#include "paddingshim.h"
+
+/* CPadding */
+CPadding::CPadding(void) : iBlockBytes(-1)
+	{
+	}
+
+EXPORT_C CPadding::CPadding(TInt aBlockBytes) : iBlockBytes(aBlockBytes)
+	{
+	__ASSERT_ALWAYS(aBlockBytes > 0, User::Invariant());
+	}
+
+EXPORT_C void CPadding::SetBlockSize(TInt aBlockBytes)
+	{
+	__ASSERT_ALWAYS(aBlockBytes > 0, User::Invariant());
+	iBlockBytes = aBlockBytes;
+	}
+
+EXPORT_C TInt CPadding::BlockSize(void) const
+	{
+	return iBlockBytes;
+	}
+
+EXPORT_C TInt CPadding::MaxPaddedLength(TInt /*aInputBytes*/) const
+	{
+	return BlockSize();
+	}
+
+EXPORT_C TInt CPadding::MaxUnPaddedLength(TInt aInputBytes) const
+	{
+	return aInputBytes - MinPaddingLength();
+	}
+
+EXPORT_C void CPadding::PadL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	// Check that the input is small enough to fit inside one padded block
+	// Won't leave if input text is equal to blocksize. Let DoPadL handle such situations
+	if(aInput.Length() > BlockSize() - MinPaddingLength()
+			&& aInput.Length() != BlockSize()) 	
+		User::Leave(KErrArgument);
+	
+	// Check that the output descriptor supplied is large enough to store the result
+	if(aOutput.MaxLength() < MaxPaddedLength(aInput.Length())) 	
+		User::Leave(KErrOverflow);
+
+	// Call the virtual function, implemented by derived classes
+	DoPadL(aInput, aOutput);
+	}
+
+TInt CPadding::GetExtension(TUint aExtensionId, TAny*& a0, TAny* a1)
+	{
+	return Extension_(aExtensionId, a0, a1);
+	}
+
+/* CPaddingNone */
+EXPORT_C CPaddingNone* CPaddingNone::NewL(TInt aBlockBytes)
+	{
+	__ASSERT_ALWAYS(aBlockBytes > 0, User::Leave(KErrArgument));
+	return CPaddingNoneShim::NewL(aBlockBytes);
+	}
+
+EXPORT_C CPaddingNone* CPaddingNone::NewLC(TInt aBlockBytes)
+	{
+	CPaddingNone* self = CPaddingNone::NewL(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C CPaddingNone::CPaddingNone(TInt aBlockBytes):CPadding(aBlockBytes)
+	{
+	}
+
+void CPaddingNone::DoPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	aOutput.Append(aInput);
+	}
+
+void CPaddingNone::UnPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxPaddedLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+	aOutput.Append(aInput);
+	}
+
+TInt CPaddingNone::MinPaddingLength(void) const
+	{
+	return 0;
+	}
+
+TInt CPaddingNone::MaxPaddedLength(TInt aInputSize) const
+	{
+	return aInputSize;
+	}
+
+/* CPaddingSSLv3 */
+EXPORT_C CPaddingSSLv3* CPaddingSSLv3::NewL(TInt aBlockBytes)
+	{
+	__ASSERT_ALWAYS(aBlockBytes > 0, User::Leave(KErrArgument));
+	return CPaddingSSLv3Shim::NewL(aBlockBytes);	
+	}
+
+EXPORT_C CPaddingSSLv3* CPaddingSSLv3::NewLC(TInt aBlockBytes)
+	{
+	CPaddingSSLv3* self = CPaddingSSLv3::NewL(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C CPaddingSSLv3::CPaddingSSLv3(TInt aBlockBytes):CPadding(aBlockBytes)
+	{
+	}
+
+void CPaddingSSLv3::DoPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	TInt paddingBytes=BlockSize()-(aInput.Length()%BlockSize());
+	aOutput.Append(aInput);
+	aOutput.SetLength(aOutput.Length()+paddingBytes);
+	for (TInt i=1;i<=paddingBytes;i++)
+		{
+		aOutput[aOutput.Length()-i]=(TUint8)(paddingBytes-1);
+		}
+	}
+
+void CPaddingSSLv3::UnPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	TInt paddingLen = aInput[aInput.Length()-1] + 1;
+
+	if (paddingLen > aInput.Length())
+		{
+		User::Leave(KErrInvalidPadding);
+		}
+
+	TInt outlen = aInput.Length() - paddingLen;
+
+	__ASSERT_DEBUG(aOutput.MaxLength() >= outlen, User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	aOutput.Append(aInput.Left(outlen));
+	}
+
+TInt CPaddingSSLv3::MinPaddingLength(void) const
+	{
+	//if aInputBytes is 1 less than the blocksize then we get 1 byte of padding
+	return 1;
+	}
+
+TInt CPaddingSSLv3::MaxPaddedLength(TInt aInputBytes) const
+	{
+	TUint padBytes = BlockSize() - (aInputBytes % BlockSize());
+	return padBytes + aInputBytes;
+	}
+
+/* CPaddingPKCS1Signature */
+EXPORT_C CPaddingPKCS1Signature* CPaddingPKCS1Signature::NewL(TInt aBlockBytes)
+	{
+	return CPaddingPKCS1SignatureShim::NewL(aBlockBytes);
+	}
+
+EXPORT_C CPaddingPKCS1Signature* CPaddingPKCS1Signature::NewLC(TInt aBlockBytes)
+	{
+	CPaddingPKCS1Signature* self = CPaddingPKCS1Signature::NewL(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C CPaddingPKCS1Signature::CPaddingPKCS1Signature(TInt aBlockBytes)
+	: CPadding(aBlockBytes)
+	{
+	}
+
+void CPaddingPKCS1Signature::DoPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	aOutput.SetLength(BlockSize());
+	TInt i;
+	TInt j;
+	aOutput[0]=0;
+	TInt startOfData=BlockSize()-aInput.Length();
+	// PKCS1 also specifies a block type 0 for private key operations but
+	// does not recommend its use. This block type (0) is compatible with 
+	// unpadded data though so you can create PKCS1 type 0 blocks using 
+	// CPaddingNone.
+	aOutput[1]=1;				// Block type 1 (private key operation)
+	for (i=2;i<(startOfData-1);i++)
+		{
+		aOutput[i]=0xff;
+		}
+	j=0;
+	aOutput[startOfData-1]=0;				// separator
+	for (i=startOfData;i<BlockSize();i++,j++)
+		{
+		aOutput[i]=aInput[j];
+		}
+	}
+	
+void CPaddingPKCS1Signature::UnPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	// erm, oops, this is not quite as simplistic as it first looks...
+	// our integer class will strip any leading zeros so we might actually
+	// get some real data that starts out looking like padding but isn't 
+	// really
+	
+	TInt inputLen = aInput.Length();
+	if (inputLen <=0 )				
+		User::Leave(KErrInvalidPadding);	//	Invalid padding data
+
+	// Leading zero may have been stripped off by integer class
+	TInt dataStart=0;
+	if (aInput[dataStart] == 0)
+		{
+		++dataStart;
+		}
+
+	if (dataStart < inputLen && aInput[dataStart])		//	might be mode one or mode zero,
+		{
+		++dataStart;
+		while (dataStart < inputLen && aInput[dataStart] == 0xff)
+			{
+			++dataStart;
+			}
+		
+		if (dataStart == inputLen || aInput[dataStart])	//	this would mean theres no zero between 0x01ff and data...so its not mode one
+			dataStart=0;			//	mode zero, start from begining of data
+		else
+			++dataStart;
+		}
+	else							//	We've definitely got a mode zero 
+		{							//	or broken data, assume mode zero
+		dataStart=0;		
+		}
+
+	TInt len=inputLen-dataStart;
+
+	__ASSERT_DEBUG(aOutput.MaxLength() >= len, User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	aOutput.SetLength(len);
+	TInt i=0;
+	while (dataStart<inputLen)
+		{
+		aOutput[i++]=aInput[dataStart++];
+		}
+	}
+
+TInt CPaddingPKCS1Signature::MinPaddingLength(void) const
+	{
+	return 11; //0x00, 0x01, <MIN of 8 0xFF octets> , 0x00
+	}
+
+/* CPaddingPKCS1Encryption */
+EXPORT_C CPaddingPKCS1Encryption* CPaddingPKCS1Encryption::NewL(
+	TInt aBlockBytes)
+	{
+	return CPaddingPKCS1EncryptionShim::NewL(aBlockBytes);
+	}
+
+EXPORT_C CPaddingPKCS1Encryption* CPaddingPKCS1Encryption::NewLC(
+	TInt aBlockBytes)
+	{
+	CPaddingPKCS1Encryption* self = CPaddingPKCS1Encryption::NewL(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C CPaddingPKCS1Encryption::CPaddingPKCS1Encryption(TInt aBlockBytes)
+	: CPadding(aBlockBytes)
+	{
+	}
+
+void CPaddingPKCS1Encryption::DoPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	aOutput.SetLength(BlockSize());
+	
+	aOutput[0]=0;
+	TInt startOfData=BlockSize()-aInput.Length();
+	aOutput[1]=2;				// Block type 2 (public key operation)
+	TBuf8<256> rnd(256);
+	GenerateRandomBytesL(rnd);
+
+	TInt i = 2;
+	TInt j = 0;
+	for (; i<(startOfData-1);)
+		{
+		if (rnd[j])
+			{
+			aOutput[i++]=rnd[j];
+			}
+		if (++j==256)
+			{
+			GenerateRandomBytesL(rnd);
+			j=0;
+			}
+		}
+
+	j=0;
+	aOutput[startOfData-1]=0;				// separator
+	for (i=startOfData;i<BlockSize();i++,j++)
+		{
+		aOutput[i]=aInput[j];
+		}
+	}
+	
+void CPaddingPKCS1Encryption::UnPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	TInt inputLen = aInput.Length();
+	if (inputLen <= 0)				
+		User::Leave(KErrInvalidPadding);	//	Invalid padding data
+
+	// Leading zero may have been stripped off by integer class
+	TInt dataStart=0;
+	if (aInput[dataStart] == 0)
+		{
+		++dataStart;
+		}
+	
+	// expecting mode 2 padding, otherwise broken
+	if (dataStart == inputLen || aInput[dataStart] != 2)	
+		{
+		User::Leave(KErrInvalidPadding);
+		}
+	++dataStart;
+
+	// skip random non zero bytes
+	while (dataStart < inputLen && aInput[dataStart])
+		{
+		++dataStart;
+		}
+
+	// expecting zero separator
+	if (dataStart == inputLen || aInput[dataStart] != 0)
+		{
+		User::Leave(KErrInvalidPadding);		
+		}
+	++dataStart;
+
+	TInt len = inputLen - dataStart;
+	__ASSERT_DEBUG(aOutput.MaxLength() >= len, User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	aOutput.SetLength(len);
+	TInt i=0;
+	while (dataStart<inputLen)
+		{
+		aOutput[i++]=aInput[dataStart++];
+		}
+	}
+
+TInt CPaddingPKCS1Encryption::MinPaddingLength(void) const
+	{
+	return 11; //0x00, 0x02, <min of 8 random octets>, 0x00
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/padding/paddingshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,190 @@
+/*
+* Copyright (c) 2006-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 "paddingshim.h"
+#include <cryptospi/cryptospidef.h>
+
+// CPaddingNoneShim
+CPaddingNoneShim* CPaddingNoneShim::NewL(TInt aBlockBytes)
+	{
+	CPaddingNoneShim* self = CPaddingNoneShim::NewLC(aBlockBytes);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CPaddingNoneShim* CPaddingNoneShim::NewLC(TInt aBlockBytes)
+	{
+	CPaddingNoneShim* self = new(ELeave) CPaddingNoneShim(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+	
+TInt CPaddingNoneShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt err(KErrNone);
+	if (aExtensionId == CryptoSpi::KPaddingInterface)
+		{
+		TUid* uid(static_cast<TUid*>(a0));
+		*uid = CryptoSpi::KPaddingModeNoneUid;
+		}
+	else 
+		{
+		err = KErrExtensionNotSupported;
+		}
+	return err;
+	}
+
+CPaddingNoneShim::CPaddingNoneShim(TInt aBlockBytes) :
+	CPaddingNone(aBlockBytes)
+	{
+	}
+
+// CPaddingPKCS1SignatureShim
+CPaddingPKCS1SignatureShim* CPaddingPKCS1SignatureShim::NewL(TInt aBlockBytes)
+	{
+	CPaddingPKCS1SignatureShim* self = CPaddingPKCS1SignatureShim::NewLC(aBlockBytes);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CPaddingPKCS1SignatureShim* CPaddingPKCS1SignatureShim::NewLC(TInt aBlockBytes)
+	{
+	CPaddingPKCS1SignatureShim* self = new(ELeave) CPaddingPKCS1SignatureShim(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+	
+TInt CPaddingPKCS1SignatureShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt err(KErrNone);
+	if (aExtensionId == CryptoSpi::KPaddingInterface)
+		{
+		TUid* uid(static_cast<TUid*>(a0));
+		*uid = CryptoSpi::KPaddingModePkcs1_v1_5_SignatureUid;
+		}
+	else 
+		{
+		err = KErrExtensionNotSupported;
+		}
+	return err;
+	}
+
+CPaddingPKCS1SignatureShim::CPaddingPKCS1SignatureShim(TInt aBlockBytes) :
+	CPaddingPKCS1Signature(aBlockBytes)
+	{
+	}
+	
+// CPaddingPKCS1EncryptionShim
+CPaddingPKCS1EncryptionShim* CPaddingPKCS1EncryptionShim::NewL(TInt aBlockBytes)
+	{
+	CPaddingPKCS1EncryptionShim* self = CPaddingPKCS1EncryptionShim::NewLC(aBlockBytes);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CPaddingPKCS1EncryptionShim* CPaddingPKCS1EncryptionShim::NewLC(TInt aBlockBytes)
+	{
+	CPaddingPKCS1EncryptionShim* self = new(ELeave) CPaddingPKCS1EncryptionShim(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+	
+TInt CPaddingPKCS1EncryptionShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt err(KErrNone);
+	if (aExtensionId == CryptoSpi::KPaddingInterface)
+		{
+		TUid* uid(static_cast<TUid*>(a0));
+		*uid = CryptoSpi::KPaddingModePkcs1_v1_5_EncryptionUid;
+		}
+	else 
+		{
+		err = KErrExtensionNotSupported;
+		}
+	return err;
+	}
+
+CPaddingPKCS1EncryptionShim::CPaddingPKCS1EncryptionShim(TInt aBlockBytes) :
+	CPaddingPKCS1Encryption(aBlockBytes)
+	{
+	}
+	
+// CPaddingSSLv3Shim
+CPaddingSSLv3Shim* CPaddingSSLv3Shim::NewL(TInt aBlockBytes)
+	{
+	CPaddingSSLv3Shim* self = CPaddingSSLv3Shim::NewLC(aBlockBytes);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CPaddingSSLv3Shim* CPaddingSSLv3Shim::NewLC(TInt aBlockBytes)
+	{
+	CPaddingSSLv3Shim* self = new(ELeave) CPaddingSSLv3Shim(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+	
+TInt CPaddingSSLv3Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt err(KErrNone);
+	if (aExtensionId == CryptoSpi::KPaddingInterface)
+		{
+		TUid* uid(static_cast<TUid*>(a0));
+		*uid = CryptoSpi::KPaddingModeSSLv3Uid;
+		}
+	else 
+		{
+		err = KErrExtensionNotSupported;
+		}
+	return err;
+	}
+
+CPaddingSSLv3Shim::CPaddingSSLv3Shim(TInt aBlockBytes) :
+	CPaddingSSLv3(aBlockBytes)
+	{
+	}	
+	
+// CPaddingPKCS7Shim
+CPaddingPKCS7Shim* CPaddingPKCS7Shim::NewL(TInt aBlockBytes)
+	{
+	CPaddingPKCS7Shim* self = CPaddingPKCS7Shim::NewLC(aBlockBytes);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CPaddingPKCS7Shim* CPaddingPKCS7Shim::NewLC(TInt aBlockBytes)
+	{
+	CPaddingPKCS7Shim* self = new(ELeave) CPaddingPKCS7Shim(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+	
+TInt CPaddingPKCS7Shim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt err(KErrNone);
+	if (aExtensionId == CryptoSpi::KPaddingInterface)
+		{
+		TUid* uid(static_cast<TUid*>(a0));
+		*uid = CryptoSpi::KPaddingModePKCS7Uid;
+		}
+	else 
+		{
+		err = KErrExtensionNotSupported;
+		}
+	return err;	
+	}
+
+CPaddingPKCS7Shim::CPaddingPKCS7Shim(TInt aBlockBytes) :
+	CPaddingPKCS7(aBlockBytes)
+	{
+	}			
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/padding/paddingshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,169 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __PADDINGSHIM_H__
+#define __PADDINGSHIM_H__
+
+/**
+@file
+@internalComponent
+@released
+*/
+
+#include <padding.h>
+
+/**
+Shim class for CPaddingNone. This should only be created by CPaddingNone.
+*/
+NONSHARABLE_CLASS(CPaddingNoneShim) : public CPaddingNone
+	{
+public:
+	static CPaddingNoneShim* NewL(TInt aBlockBytes);
+	static CPaddingNoneShim* NewLC(TInt aBlockBytes);
+	
+protected:
+	// From CBase
+	/**
+	Used by the CBufferedTransformShim class to determine the type of 
+	the padding mode selected. The SPI plug-in is then configured to use
+	the selected padding mdoe.
+	
+	@param aExtensionId The requested interface
+	@param a0 Not used. This function does NOT return a real interface.
+	@param a1 Not used.
+	@return KErrNone if aExtensionId is CryptoSpi::KPaddingModeNoneUid; 
+	otherwise, KErrNotFound is returned.
+	*/
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);		
+private:
+	CPaddingNoneShim(TInt aBlockBytes);
+	};
+
+/**
+Shim class for CPaddingPKCS1Signature. This should only be created by 
+CPaddingPKCS1Signature.
+*/
+NONSHARABLE_CLASS(CPaddingPKCS1SignatureShim) : public CPaddingPKCS1Signature
+	{
+public:
+	static CPaddingPKCS1SignatureShim* NewL(TInt aBlockBytes);
+	static CPaddingPKCS1SignatureShim* NewLC(TInt aBlockBytes);
+	
+protected:
+	// From CBase
+	/**
+	Used by the CBufferedTransformShim class to determine the type of 
+	the padding mode selected. The SPI plug-in is then configured to use
+	the selected padding mdoe.
+	
+	@param aExtensionId The requested interface
+	@param a0 Not used. This function does NOT return a real interface.
+	@param a1 Not used.
+	@return KErrNone if aExtensionId is CryptoSpi::KPaddingModeNoneUid; 
+	otherwise, KErrNotFound is returned.
+	*/
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);		
+private:
+	CPaddingPKCS1SignatureShim(TInt aBlockBytes);
+	};
+	
+/**
+Shim class for CPaddingPKCS1Encryption. This should only be created by 
+CPaddingPKCS1Encryption.
+*/
+NONSHARABLE_CLASS(CPaddingPKCS1EncryptionShim) : public CPaddingPKCS1Encryption
+	{
+public:
+	static CPaddingPKCS1EncryptionShim* NewL(TInt aBlockBytes);
+	static CPaddingPKCS1EncryptionShim* NewLC(TInt aBlockBytes);
+	
+protected:
+	// From CBase
+	/**
+	Used by the CBufferedTransformShim class to determine the type of 
+	the padding mode selected. The SPI plug-in is then configured to use
+	the selected padding mdoe.
+	
+	@param aExtensionId The requested interface
+	@param a0 Not used. This function does NOT return a real interface.
+	@param a1 Not used.
+	@return KErrNone if aExtensionId is CryptoSpi::KPaddingModeNoneUid; 
+	otherwise, KErrNotFound is returned.
+	*/
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);		
+private:
+	CPaddingPKCS1EncryptionShim(TInt aBlockBytes);
+	};	
+
+/**
+Shim class for CPaddingSSLv3. This should only be created by 
+CPaddingSSLv3.
+*/
+NONSHARABLE_CLASS(CPaddingSSLv3Shim) : public CPaddingSSLv3
+	{
+public:
+	static CPaddingSSLv3Shim* NewL(TInt aBlockBytes);
+	static CPaddingSSLv3Shim* NewLC(TInt aBlockBytes);
+	
+protected:
+	// From CBase
+	/**
+	Used by the CBufferedTransformShim class to determine the type of 
+	the padding mode selected. The SPI plug-in is then configured to use
+	the selected padding mdoe.
+	
+	@param aExtensionId The requested interface
+	@param a0 Not used. This function does NOT return a real interface.
+	@param a1 Not used.
+	@return KErrNone if aExtensionId is CryptoSpi::KPaddingModeNoneUid; 
+	otherwise, KErrNotFound is returned.
+	*/
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);		
+private:
+	CPaddingSSLv3Shim(TInt aBlockBytes);
+	};	
+
+/**
+Shim class for CPaddingPKCS7. This should only be created by 
+CPaddingPKCS7.
+*/
+NONSHARABLE_CLASS(CPaddingPKCS7Shim) : public CPaddingPKCS7
+	{
+public:
+	static CPaddingPKCS7Shim* NewL(TInt aBlockBytes);
+	static CPaddingPKCS7Shim* NewLC(TInt aBlockBytes);
+	
+protected:
+	// From CBase
+	/**
+	Used by the CBufferedTransformShim class to determine the type of 
+	the padding mode selected. The SPI plug-in is then configured to use
+	the selected padding mdoe.
+	
+	@param aExtensionId The requested interface
+	@param a0 Not used. This function does NOT return a real interface.
+	@param a1 Not used.
+	@return KErrNone if aExtensionId is CryptoSpi::KPaddingModeNoneUid; 
+	otherwise, KErrNotFound is returned.
+	*/
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);		
+private:
+	CPaddingPKCS7Shim(TInt aBlockBytes);
+	};	
+
+#endif // __PADDINGSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/padding/pkcs7.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,91 @@
+/*
+* Copyright (c) 2003-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 <e32base.h>
+#include <padding.h>
+#include <securityerr.h>
+#include <cryptopanic.h>
+
+#include "paddingshim.h"
+
+/* CPaddingPKCS7 */
+EXPORT_C CPaddingPKCS7* CPaddingPKCS7::NewL(TInt aBlockBytes)
+	{
+	__ASSERT_ALWAYS(aBlockBytes > 0, User::Leave(KErrArgument));
+	return CPaddingPKCS7Shim::NewL(aBlockBytes);
+	}
+
+EXPORT_C CPaddingPKCS7* CPaddingPKCS7::NewLC(TInt aBlockBytes)
+	{
+	CPaddingPKCS7* self = CPaddingPKCS7::NewL(aBlockBytes);
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+EXPORT_C CPaddingPKCS7::CPaddingPKCS7(TInt aBlockBytes):CPadding(aBlockBytes)
+	{
+	}
+
+void CPaddingPKCS7::DoPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	TInt paddingBytes = BlockSize()-(aInput.Length()%BlockSize());		
+	aOutput.Append(aInput);
+	aOutput.SetLength(aOutput.Length()+paddingBytes);
+	for (TInt i=1;i<=paddingBytes;i++)
+		{
+		aOutput[aOutput.Length()-i]=(TUint8)(paddingBytes);
+		}
+	}
+
+void CPaddingPKCS7::UnPadL(const TDesC8& aInput,TDes8& aOutput)
+	{
+	TUint inputLen = aInput.Length();
+ 	TUint paddingLen = (TUint)(aInput[inputLen - 1]);
+
+	if (paddingLen > inputLen)
+ 		{
+ 		User::Leave(KErrInvalidPadding);
+ 		}
+   
+	TInt outlen = aInput.Length() - paddingLen;
+
+	__ASSERT_DEBUG(aOutput.MaxLength() >= outlen, User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	aOutput.Append(aInput.Left(outlen));
+	for (TInt i=outlen;i<inputLen;i++)
+		{
+		//All padding bytes must equal the length of padding expected
+		if (aInput[i]!=paddingLen)
+			{
+			User::Leave(KErrInvalidPadding);
+			}
+		}
+	}
+
+TInt CPaddingPKCS7::MinPaddingLength(void) const
+	{
+	//if aInputBytes is 1 less than the blocksize then we get 1 byte of padding
+	return 1;
+	}
+
+TInt CPaddingPKCS7::MaxPaddedLength(TInt aInputBytes) const
+	{
+	TUint padBytes = BlockSize() - (aInputBytes % BlockSize());
+	return padBytes + aInputBytes;
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbe.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,266 @@
+/*
+* Copyright (c) 2002-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 <e32std.h>
+#include <random.h>
+#include <cryptostrength.h>
+#include <securityerr.h>
+#include <pbedata.h>
+#include "pkcs5kdf.h"
+#include "pbe.h"
+#include <pbencryptor.h>
+#include "pbesymmetricfactory.h"
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(const TPBPassword& aPassword)
+	{
+	CPBEncryptElement* self = NewLC(aPassword);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(const TPBPassword& aPassword)
+	{
+	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword.Password());
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(const TPBPassword& aPassword, 
+	const TPBECipher aCipher)
+	{
+	CPBEncryptElement* self = NewLC(aPassword, aCipher);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(const TPBPassword& aPassword, 
+	const TPBECipher aCipher)
+	{
+	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword.Password(), aCipher);
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(const TPBPassword& aPassword, 
+	const CPBEncryptParms& aParms)
+	{
+	CPBEncryptElement* self = NewLC(aPassword, aParms);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(const TPBPassword& aPassword, 
+	const CPBEncryptParms& aParms)
+	{
+	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword.Password(), aParms);
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(
+	const CPBEncryptionData& aData, const TPBPassword& aPassword)
+	{
+	CPBEncryptElement* self = CPBEncryptElement::NewLC(aData, aPassword);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(
+	const CPBEncryptionData& aData, const TPBPassword& aPassword)
+	{
+	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;
+	CleanupStack::PushL(self);
+	self->ConstructL(aData, aPassword);
+	return self;
+	}
+
+CPBEncryptElement::CPBEncryptElement(void) 
+	{
+	}
+
+CPBEncryptElement::~CPBEncryptElement(void)
+	{
+	delete iData;
+	delete iEncryptKey;
+	}
+
+void CPBEncryptElement::ConstructL(const TDesC8& aPassword)
+	{
+	// Construct based on cryptography strength
+	if (TCrypto::Strength() == TCrypto::EStrong)
+		{
+		ConstructL(aPassword, KPBEDefaultStrongCipher);
+		}
+	else
+		{
+		ConstructL(aPassword, KPBEDefaultWeakCipher);
+		}
+	}
+
+void CPBEncryptElement::ConstructL(const TDesC8& aPassword, TPBECipher aCipher)
+	{
+	TBuf8<KPBEMaxCipherIVBytes> iv(KPBEMaxCipherIVBytes);
+	iv.SetLength(PBE::GetBlockBytes(aCipher));
+	TRandom::RandomL(iv);
+
+	TBuf8<KPBEDefaultSaltBytes> encryptSalt(KPBEDefaultSaltBytes);
+	TRandom::RandomL(encryptSalt);
+
+	TBuf8<KPBEDefaultSaltBytes> authSalt(KPBEDefaultSaltBytes);
+	TRandom::RandomL(authSalt);
+
+	iData = CPBEncryptionData::NewL(aPassword, aCipher, authSalt, encryptSalt,
+		iv, KDefaultIterations);
+
+	MakeEncryptKeyL(PBE::GetKeyBytes(aCipher), aPassword);
+	}
+
+void CPBEncryptElement::ConstructL(const CPBEncryptionData& aData, 
+	const TPBPassword& aPassword)
+	{
+	iData = CPBEncryptionData::NewL(aData);
+	if(!AuthenticateL(aPassword))
+		{
+		User::Leave(KErrBadPassphrase);
+		}
+	}
+
+void CPBEncryptElement::ConstructL(const TDesC8& aPassword,
+	const CPBEncryptParms& aParms)
+	{
+	TUint keySize = PBE::GetKeyBytes(aParms.Cipher());
+
+	TBuf8<KPBEDefaultSaltBytes> authSalt(KPBEDefaultSaltBytes);
+	TRandom::RandomL(authSalt);
+
+	//Recreate parms with given data and create a totally new auth
+	iData = CPBEncryptionData::NewL(aPassword, authSalt, aParms);
+	MakeEncryptKeyL(keySize, aPassword);
+	}
+
+const CPBEncryptionData& CPBEncryptElement::EncryptionData(void) const
+	{
+	return *iData;
+	}
+
+CPBEncryptor* CPBEncryptElement::NewEncryptL() const 
+	{
+	CPBEncryptor* encryptor = NewEncryptLC();
+	CleanupStack::Pop();
+	return encryptor;
+	}
+
+CPBEncryptor* CPBEncryptElement::NewEncryptLC() const
+	{
+	CPBEncryptor* encryptor = CPBEncryptorElement::NewLC( 
+		iData->EncryptParms().Cipher(), *iEncryptKey, 
+		iData->EncryptParms().IV());
+	return encryptor;
+	}
+
+TBool CPBEncryptElement::AuthenticateL(const TPBPassword& aPassword)
+	{
+	TBool retval = EFalse;
+
+	//create a new auth to test against the existing one
+	//therefore we use the same key size, and salt as the current one
+	CPBAuthData* auth = CPBAuthData::NewLC(aPassword.Password(),
+		iData->AuthData().Salt(), iData->AuthData().Key().Size(),
+		iData->AuthData().Iterations());
+	if(*auth==iData->AuthData())
+		{
+		//We've got a valid password, regenerate the key so they can decrypt
+		//stuff.  We don't the change the length of iEncryptKey as we assume the
+		//previous key size is appropriate for the new one
+		MakeEncryptKeyL(PBE::GetKeyBytes(iData->EncryptParms().Cipher()),
+			aPassword.Password());
+		retval = ETrue;
+		}
+	CleanupStack::PopAndDestroy(auth);
+	return retval;
+	}
+
+CPBDecryptor* CPBEncryptElement::NewDecryptL() const
+	{
+	CPBDecryptor* decryptor = NewDecryptLC();
+	CleanupStack::Pop();
+	return decryptor;
+	}
+
+CPBDecryptor* CPBEncryptElement::NewDecryptLC() const
+	{
+	CPBDecryptor* decryptor = CPBDecryptorElement::NewLC(
+		iData->EncryptParms().Cipher(), *iEncryptKey,
+		iData->EncryptParms().IV());
+	return decryptor;
+	}
+
+// Warning: This function is only valid BEFORE you call NewEncryptL
+// After creating the cipher, ask it about itself, not me!
+// This is _very_ dodgy as I assume all sorts of things about the encryptor.
+// 1) That it uses SSLv3 or similar style padding
+// 2) That it stores the IV for that stream at the front.
+// This is here for specific application that requires this and aren't able to
+// actually construct the cipher and ask it.  In almost all other cases you
+// should construct the cipher and ask it.
+TInt CPBEncryptElement::MaxCiphertextLength(TInt aPlaintextLength) const
+	{
+	TUint blocksize = PBE::GetBlockBytes(iData->EncryptParms().Cipher());
+	TUint padding = blocksize - aPlaintextLength % blocksize;
+	//len = inputLength + padding
+	return aPlaintextLength + padding;
+	}
+
+// Warning: This function is only valid BEFORE you call NewDecryptL
+// After creating the cipher, ask it about itself, not me!
+TInt CPBEncryptElement::MaxPlaintextLength(TInt aCiphertextLength) const
+	{
+	/*It's impossible to determine anything about how much padding will be
+	 * removed.  So we'll return a max length that is longer than will
+	 * ever happen by at most a blocksize - 1.
+	 */
+	//totallength = inputlength - 1 byte of padding min
+	return aCiphertextLength - 1;
+	}
+
+void CPBEncryptElement::MakeEncryptKeyL(TUint aKeySize, const TDesC8& aPassword)
+	{
+	iEncryptKey = HBufC8::NewMaxL(aKeySize);
+	TPtr8 encryptKeyBuf = iEncryptKey->Des();
+	iData->EncryptParms().DeriveKeyL(aPassword, encryptKeyBuf);
+	}
+
+EXPORT_C TPBPassword::TPBPassword(const TDesC8& aPassword)
+	{
+	iPassword.Set(aPassword);
+	}
+
+EXPORT_C TPBPassword::TPBPassword(const TDesC16& aPassword)
+	{
+	iPassword.Set(reinterpret_cast<const TUint8*>(aPassword.Ptr()), aPassword.Size());
+	}
+
+EXPORT_C const TDesC8& TPBPassword::Password(void) const
+	{
+	return iPassword;
+	}
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbedata.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,482 @@
+/*
+* Copyright (c) 2002-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 "pkcs5kdf.h"
+#include "pkcs12kdf.h"
+#include "pbedata.h"
+#include "pbesymmetricfactory.h"
+#include "cryptostrength.h"
+
+EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(const TDesC8& aPassword,
+	TPBECipher aCipher, const TDesC8& aAuthSalt, 
+	const TDesC8& aEncryptSalt, const TDesC8& aIV, TUint aIterations)
+	{
+	CPBEncryptionData* self = NewLC(aPassword, aCipher, aAuthSalt, aEncryptSalt,
+		aIV, aIterations);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBEncryptionData* CPBEncryptionData::NewLC(const TDesC8& aPassword,
+	TPBECipher aCipher, const TDesC8& aAuthSalt, 
+	const TDesC8& aEncryptSalt, const TDesC8& aIV, TUint aIterations)
+	{
+	CPBEncryptionData* self = new(ELeave)CPBEncryptionData();
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword, aCipher, aAuthSalt, aEncryptSalt, aIV,
+		aIterations);
+	return self;
+	}
+
+EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(
+	const CPBEncryptionData& aData)
+	{
+	CPBEncryptionData* self = NewLC(aData);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBEncryptionData* CPBEncryptionData::NewLC(
+	const CPBEncryptionData& aData)
+	{
+	CPBEncryptionData* self = new(ELeave)CPBEncryptionData(); 
+	CleanupStack::PushL(self);
+	self->ConstructL(aData);
+	return self;
+	}
+
+EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(
+	const TDesC8& aPassword, const TDesC8& aAuthSalt,
+	const CPBEncryptParms& aParms)
+/**
+	This factory function takes the user-supplied password
+	and the randomly-generated authentication salt, along
+	with the encryption paramaters.  It is provided so the
+	encryption parameters can be extended without having to
+	provide multiple factory functions.
+
+	@param	aPassword		User-supplied password.  This
+							password is not transformed so
+							if it needs to be in a particular
+							format, e.g. for PKCS#12, the
+							transformation must be applied before
+							this function is called.
+	@param	aAuthSalt		The salt is used to derive the
+							authentication key; not the encryption
+							key.
+	@param	aParms			Encryption parameters describe how the
+							data is encrypted.
+	@return					New instance of CPBEncryptionData.
+ */
+	{
+	CPBEncryptionData* self = new(ELeave) CPBEncryptionData;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword, aAuthSalt, aParms);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CPBEncryptionData::ConstructL(
+	const TDesC8& aPassword, const TDesC8& aAuthSalt,
+	const CPBEncryptParms& aParms)
+/**
+	Second-phase constructor for factory function with
+	same signature.
+ */
+	{
+	iParms = CPBEncryptParms::NewL(aParms);
+	iAuth = CPBAuthData::NewL(
+		aPassword,
+		aAuthSalt,
+		PBE::GetKeyBytes(aParms.Cipher()),
+		aParms.Iterations());
+	}
+
+// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
+// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
+EXPORT_C CPBEncryptionData::CPBEncryptionData(void)
+	{
+	}
+
+// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
+// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
+CPBEncryptionData::~CPBEncryptionData(void)
+	{
+	delete iParms;
+	delete iAuth;
+	}
+
+void CPBEncryptionData::ConstructL(const TDesC8& aPassword,
+	TPBECipher aCipher, const TDesC8& aAuthSalt, 
+	const TDesC8& aEncryptSalt, const TDesC8& aIV, TUint aIterations)
+	{
+	iParms = CPBEncryptParms::NewL(aCipher, aEncryptSalt, aIV, aIterations);
+	iAuth = CPBAuthData::NewL(aPassword, aAuthSalt,
+		PBE::GetKeyBytes(aCipher), aIterations);
+	}
+
+void CPBEncryptionData::ConstructL(const CPBEncryptionData& aData)
+	{
+	iParms = CPBEncryptParms::NewL(aData.EncryptParms());
+	iAuth = CPBAuthData::NewL(aData.AuthData());
+	}
+
+EXPORT_C const CPBEncryptParms& CPBEncryptionData::EncryptParms(void) const
+	{
+	return *iParms;
+	} 
+EXPORT_C const CPBAuthData& CPBEncryptionData::AuthData(void) const
+	{
+	return *iAuth;
+	}
+
+/* CPBEncryptParms */
+EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL()
+/**
+	This factory function allocates an encryption
+	parameters object with default settings.  The
+	individual settings can be retrieved and modified
+	with the accessor and mutator functions after
+	this object has been created.
+
+	This factory function is provided so that individual
+	parameters can be modified without providing many
+	factory functions.
+
+	@return					New instance of CPBEncryptParms.
+ */
+	{
+	CPBEncryptParms* self = NewLC();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC()
+/**
+	Similar to the NewL overload which takes no
+	arguments, this function additionally puts the
+	allocated instance of CPBEncryptParms on the
+	cleanup stack.
+
+	@return					New instance of CPBEncryptParms.
+ */
+	{
+	CPBEncryptParms* self = new(ELeave) CPBEncryptParms;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CPBEncryptParms::ConstructL()
+/**
+	Initialize this object with default cipher, kdf (PKCS#5,)
+	salt length, iteration count, and IV.
+ */
+	{
+	iData = new(ELeave) TParamsData;
+	iData->iKdf = EKdfPkcs5;
+	
+	iSalt = HBufC8::NewMaxL(KPBEDefaultSaltBytes);
+	TPtr8 saltDes = iSalt->Des();
+	TRandom::RandomL(saltDes);
+	
+	iIterations = KDefaultIterations;
+	
+	iIV = HBufC8::NewMaxL(KPBEMaxCipherIVBytes);
+	
+	SetCipher(
+			(TCrypto::Strength() == TCrypto::EStrong)
+		?	KPBEDefaultStrongCipher : KPBEDefaultWeakCipher );
+	}
+
+EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL(TPBECipher aCipher,
+	const TDesC8& aSalt, const TDesC8& aIV, TUint aIterations)
+	{
+	CPBEncryptParms* self = NewLC(aCipher, aSalt, aIV, aIterations);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC(TPBECipher aCipher,
+	const TDesC8& aSalt, const TDesC8& aIV, TUint aIterations) 
+	{
+	CPBEncryptParms* self = new(ELeave)CPBEncryptParms();
+	CleanupStack::PushL(self);
+	self->ConstructL(aCipher, aSalt, aIV, aIterations);
+	return self;
+	}
+
+EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL(const CPBEncryptParms& aParms)
+	{
+	CPBEncryptParms* self = NewLC(aParms);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC(const CPBEncryptParms& aParms)
+	{
+	CPBEncryptParms* self = new(ELeave)CPBEncryptParms();
+	CleanupStack::PushL(self);
+	self->ConstructL(aParms);
+	return self;
+	}
+
+// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
+// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
+EXPORT_C CPBEncryptParms::CPBEncryptParms()
+	{
+	}
+
+// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
+// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
+CPBEncryptParms::~CPBEncryptParms()
+	{
+	delete iData;
+	delete iSalt;
+	delete iIV;	
+	}
+
+void CPBEncryptParms::ConstructL(TPBECipher aCipher, const TDesC8& aSalt,
+	const TDesC8& aIV, TUint aIterations)
+	{
+	iData = new(ELeave) TParamsData;
+	iData->iCipher = aCipher;
+	iData->iKdf = EKdfPkcs5;
+	iSalt = aSalt.AllocL();
+	iIV = aIV.AllocL();
+	iIterations = aIterations;
+	}
+
+void CPBEncryptParms::ConstructL(const CPBEncryptParms& aParms)
+	{
+	iData = new(ELeave) TParamsData;
+	iData->iCipher = aParms.Cipher();
+	iData->iKdf = aParms.iData->iKdf;
+	iSalt = aParms.Salt().AllocL();
+	iIterations = aParms.Iterations();
+	iIV = aParms.IV().AllocL();
+	}
+
+EXPORT_C TPBECipher CPBEncryptParms::Cipher() const
+	{
+	return iData->iCipher;
+	}
+
+EXPORT_C void CPBEncryptParms::SetCipher(TPBECipher aCipher)
+ /**
+  *	Replace the current cipher.  This function resizes the
+  *	IV and replaces its existing contents.
+  *	
+  *	@param aCipher	New cipher.
+  * 
+  * @deprecated		Use SetCipherL instead.
+  * @see			SetCipherL
+  */
+	{
+	TPtr8 ivDes = iIV->Des();
+	ivDes.SetLength(PBE::GetBlockBytes(aCipher));
+	TRandom::RandomL(ivDes);
+	
+	iData->iCipher = aCipher;
+	}
+
+EXPORT_C CPBEncryptParms::TKdf CPBEncryptParms::Kdf() const
+/**
+	Accessor function returns the key derivation function
+	(KDF) specified by this object.
+
+	@return					KDF specified by this object.
+ */
+	{
+	return iData->iKdf;
+	}
+
+EXPORT_C void CPBEncryptParms::SetKdf(CPBEncryptParms::TKdf aKdf)
+/**
+	Replace the current key derivation function.
+
+	@param	aKdf			Key derivation function.
+ */
+	{
+	iData->iKdf = aKdf;
+	}
+
+EXPORT_C TPtrC8 CPBEncryptParms::Salt() const
+	{
+	return TPtrC8(*iSalt);
+	}
+
+EXPORT_C void CPBEncryptParms::ResizeSaltL(TInt aNewLen)
+/**
+	Resize the current salt and replace its contents.
+
+	@param	aNewLen			New salt length.
+ */
+	{
+	iSalt = iSalt->ReAllocL(aNewLen);
+	TPtr8 saltDes = iSalt->Des();
+	TRandom::RandomL(saltDes);
+	}
+
+EXPORT_C TInt CPBEncryptParms::Iterations() const
+	{
+	return iIterations;
+	}
+
+EXPORT_C void CPBEncryptParms::SetIterations(TInt aIterCount)
+/**
+	Replace the current iteration count with the supplied value.
+	
+	@param	aIterCount		Number of iterations to apply in
+							the KDF.
+ */
+	{
+	ASSERT(aIterCount >= 0);
+	iIterations = aIterCount;
+	}
+
+EXPORT_C TPtrC8 CPBEncryptParms::IV() const
+	{
+	return TPtrC8(*iIV);
+	}
+
+EXPORT_C void CPBEncryptParms::SetIV(const TDesC8& aNewIv)
+/**
+	Replace the initialization vector.
+	
+	@param	aNewIv			New initialization vector length.
+							This must have no more than
+							KPBEMaxCipherIVBytes bytes.
+ */
+	{
+	iIV->Des().Copy(aNewIv);
+	}
+
+void CPBEncryptParms::DeriveKeyL(const TDesC8& aPassword, TDes8& aKeyBuf) const
+/**
+	Derive a key from this object's kdf, salt, amd iteration count.
+	
+	@param	aPassword		User-supplied password used to generate key.
+	@param	aKeyBuf			Buffer to populate with new key.
+							On entry it must be set to the required
+							key length.
+ */
+	{
+	switch (iData->iKdf)
+		{
+	case CPBEncryptParms::EKdfPkcs5:
+		TPKCS5KDF::DeriveKeyL(aKeyBuf, aPassword, *iSalt, iIterations);
+		break;
+	
+	case CPBEncryptParms::EKdfPkcs12:
+		PKCS12KDF::DeriveKeyL(aKeyBuf, PKCS12KDF::EIDByteEncryptKey, aPassword, *iSalt, iIterations);
+		break;
+	
+	default:
+		ASSERT(EFalse);
+		break;
+		}
+	}
+
+/* CPBAuthData */
+
+EXPORT_C CPBAuthData* CPBAuthData::NewL(const TDesC8& aPassword,
+	const TDesC8& aSalt, TUint aKeySize, TUint aIterations)
+	{
+	CPBAuthData* self = NewLC(aPassword, aSalt, aKeySize, aIterations);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBAuthData* CPBAuthData::NewLC(const TDesC8& aPassword,
+	const TDesC8& aSalt, TUint aKeySize, TUint aIterations) 
+	{
+	CPBAuthData* self = new(ELeave)CPBAuthData();
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword, aSalt, aKeySize, aIterations);
+	return self;
+	}
+
+EXPORT_C CPBAuthData* CPBAuthData::NewL(const CPBAuthData& aData)
+	{
+	CPBAuthData* self = NewLC(aData);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CPBAuthData* CPBAuthData::NewLC(const CPBAuthData& aData)
+	{
+	CPBAuthData* self = new(ELeave)CPBAuthData();
+	CleanupStack::PushL(self);
+	self->ConstructL(aData);
+	return self;
+	}
+
+// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
+// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
+EXPORT_C CPBAuthData::CPBAuthData()
+	{
+	}
+
+// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
+// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
+CPBAuthData::~CPBAuthData()
+	{
+	delete iAuthKey;
+	delete iSalt;
+	}
+
+void CPBAuthData::ConstructL(const TDesC8& aPassword, const TDesC8& aSalt, 
+	TUint aKeySize, TUint aIterations)
+	{
+	iSalt = aSalt.AllocL();
+	iIterations = aIterations;
+	iAuthKey = HBufC8::NewMaxL(aKeySize);
+	TPtr8 authKeyPtr = iAuthKey->Des();
+	TPKCS5KDF::DeriveKeyL(authKeyPtr, aPassword, *iSalt, iIterations);
+	}
+
+void CPBAuthData::ConstructL(const CPBAuthData& aData)
+	{
+	iAuthKey = aData.Key().AllocL();
+	iSalt = aData.Salt().AllocL();
+	iIterations = aData.Iterations();
+	}
+
+EXPORT_C TPtrC8 CPBAuthData::Key() const
+	{
+	return TPtrC8(*iAuthKey);
+	}
+
+EXPORT_C TPtrC8 CPBAuthData::Salt() const
+	{
+	return TPtrC8(*iSalt);
+	}
+
+EXPORT_C TInt CPBAuthData::Iterations() const
+	{
+	return iIterations;
+	}
+
+EXPORT_C TBool CPBAuthData::operator==(const CPBAuthData& aAuth) const
+	{
+	//if the key's are equal, the its true, as the other members are used in key derivation
+	return (*iAuthKey == aAuth.Key());
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbefactory.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,115 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <pbebase.h>
+#include <pbe.h>
+
+EXPORT_C CPBEncryptElementBase* TPBEncryptionFactory::NewPBEncryptElementL(
+	const TDesC& aPassword)
+	{
+	CPBEncryptElementBase* encrypt = NewPBEncryptElementLC(aPassword);
+	CleanupStack::Pop();
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptElementBase* TPBEncryptionFactory::NewPBEncryptElementLC(
+	const TDesC& aPassword)
+	{
+	CPBEncryptElement* encrypt = CPBEncryptElement::NewLC(aPassword);
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptElementBase* TPBEncryptionFactory::NewPBEncryptElementL(
+	const TDesC& aPassword, const TPBEncryptParms& aEncryptParms)
+	{
+	CPBEncryptElementBase* encrypt = NewPBEncryptElementLC(aPassword,aEncryptParms);
+	CleanupStack::Pop();
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptElementBase* TPBEncryptionFactory::NewPBEncryptElementLC(
+	const TDesC& aPassword, const TPBEncryptParms& aEncryptParms)
+	{
+	CPBEncryptElement* encrypt = CPBEncryptElement::NewLC(aPassword,
+		aEncryptParms);
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptElementBase* TPBEncryptionFactory::NewPBEncryptElementL(
+	const TPBEncryptionData& aData)
+	{
+	CPBEncryptElementBase* encrypt = NewPBEncryptElementLC(aData);
+	CleanupStack::Pop();
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptElementBase* TPBEncryptionFactory::NewPBEncryptElementLC(
+	const TPBEncryptionData& aData)
+	{
+	CPBEncryptElement* encrypt = CPBEncryptElement::NewLC(aData);
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptSetBase* TPBEncryptionFactory::NewPBEncryptSetL(
+	const TDesC& aPassword)
+	{
+	CPBEncryptSetBase* encrypt = NewPBEncryptSetLC(aPassword);
+	CleanupStack::Pop();
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptSetBase* TPBEncryptionFactory::NewPBEncryptSetLC(
+	const TDesC& aPassword)
+	{
+	CPBEncryptSet* encrypt = CPBEncryptSet::NewLC(aPassword);
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptSetBase* TPBEncryptionFactory::NewPBEncryptSetL(
+	const TDesC& aPassword, const TPBEncryptParms& aEncryptParms)
+	{
+	CPBEncryptSetBase* encrypt = NewPBEncryptSetLC(aPassword, aEncryptParms);
+	CleanupStack::Pop();
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptSetBase* TPBEncryptionFactory::NewPBEncryptSetLC(
+	const TDesC& aPassword, const TPBEncryptParms& aEncryptParms)
+	{
+	CPBEncryptSet* encrypt = CPBEncryptSet::NewLC(aPassword, aEncryptParms);
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptSetBase* TPBEncryptionFactory::NewPBEncryptSetL(
+	const TPBEncryptionData& aData, const TDesC8& aEncryptedMasterKey)
+	{
+	CPBEncryptSetBase* encrypt = NewPBEncryptSetLC(aData, aEncryptedMasterKey);
+	CleanupStack::Pop();
+	return encrypt;
+	}
+
+EXPORT_C CPBEncryptSetBase* TPBEncryptionFactory::NewPBEncryptSetLC(
+	const TPBEncryptionData& aData, const TDesC8& aEncryptedMasterKey)
+	{
+	CPBEncryptSet* encrypt = CPBEncryptSet::NewLC(aData, aEncryptedMasterKey);
+	return encrypt;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbencryptor.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,126 @@
+/*
+* Copyright (c) 2002-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 <e32std.h>
+#include <random.h>
+#include <pbencryptor.h>
+#include "pbesymmetricfactory.h"
+
+EXPORT_C CPBEncryptorElement* CPBEncryptorElement::NewL(
+	const TPBECipher aCipher, const TDesC8& aKey, const TDesC8& aIV)
+	{
+	CPBEncryptorElement* self = NewLC(aCipher, aKey, aIV);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptorElement* CPBEncryptorElement::NewLC(
+	const TPBECipher aCipher, const TDesC8& aKey, const TDesC8& aIV)
+	{
+	CPBEncryptorElement* self = new(ELeave) CPBEncryptorElement;
+	CleanupStack::PushL(self);
+	self->ConstructL(aCipher, aKey, aIV);
+	return self;
+	}
+
+void CPBEncryptorElement::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iCipher->Process(aInput, aOutput);
+	}
+
+void CPBEncryptorElement::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iCipher->ProcessFinalL(aInput, aOutput);
+	}
+
+void CPBEncryptorElement::ConstructL(const TPBECipher aCipher,
+	const TDesC8& aKey, const TDesC8& aIV)
+	{
+	iCipher = PBE::MakeEncryptorL(aCipher, aKey, aIV);
+	}
+
+CPBEncryptorElement::CPBEncryptorElement()
+	{
+	}
+
+CPBEncryptorElement::~CPBEncryptorElement()
+	{
+	delete iCipher;
+	}
+
+TInt CPBEncryptorElement::MaxOutputLength(TUint aMaxInputLength) const
+	{
+	return iCipher->MaxOutputLength(aMaxInputLength);
+	}
+
+TInt CPBEncryptorElement::MaxFinalOutputLength(TUint aMaxInputLength) const
+	{
+	return iCipher->MaxFinalOutputLength(aMaxInputLength);
+	}
+
+EXPORT_C CPBDecryptorElement* CPBDecryptorElement::NewL(
+	const TPBECipher aCipher, const TDesC8& aKey, const TDesC8& aIV)
+	{
+	CPBDecryptorElement* self = NewLC(aCipher, aKey, aIV);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBDecryptorElement* CPBDecryptorElement::NewLC(
+	const TPBECipher aCipher, const TDesC8& aKey, const TDesC8& aIV)
+	{
+	CPBDecryptorElement* self = new(ELeave) CPBDecryptorElement;
+	CleanupStack::PushL(self);
+	self->ConstructL(aCipher, aKey, aIV);
+	return self;
+	}
+
+void CPBDecryptorElement::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iCipher->Process(aInput, aOutput);
+	}
+
+void CPBDecryptorElement::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iCipher->ProcessFinalL(aInput, aOutput);
+	}
+
+void CPBDecryptorElement::ConstructL(const TPBECipher aCipher, 
+	const TDesC8& aKey, const TDesC8& aIV)
+	{
+	iCipher = PBE::MakeDecryptorL(aCipher, aKey, aIV);
+	}
+
+CPBDecryptorElement::CPBDecryptorElement()
+	{
+	}
+
+CPBDecryptorElement::~CPBDecryptorElement()
+	{
+	delete iCipher;
+	}
+
+TInt CPBDecryptorElement::MaxOutputLength(TUint aMaxInputLength) const
+	{
+	return iCipher->MaxOutputLength(aMaxInputLength);
+	}
+
+TInt CPBDecryptorElement::MaxFinalOutputLength(TUint aMaxInputLength) const
+	{
+	return iCipher->MaxFinalOutputLength(aMaxInputLength);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbencryptorset.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,217 @@
+/*
+* Copyright (c) 2002-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 <e32std.h>
+#include <random.h>
+
+#include <pbencryptor.h>
+#include "pbesymmetricfactory.h"
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+/** The maximum block size supported (in bytes) */
+const TUint KMaxBlockSizeSupported = 32;
+#endif
+
+EXPORT_C CPBEncryptorSet* CPBEncryptorSet::NewL(
+	const TPBECipher aCipher, const TDesC8& aKey) 
+	{
+	CPBEncryptorSet* self = NewLC(aCipher, aKey);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptorSet* CPBEncryptorSet::NewLC(
+	const TPBECipher aCipher, const TDesC8& aKey)
+	{
+	CPBEncryptorSet* self = new(ELeave) CPBEncryptorSet;
+	CleanupStack::PushL(self);
+
+	self->ConstructL(aCipher, aKey);
+	
+	return self;
+	}
+
+void CPBEncryptorSet::ConstructL(const TPBECipher aCipher,const TDesC8& aKey)
+	{
+	TInt blocksize = PBE::GetBlockBytes(aCipher);
+	iIV = HBufC8::NewMaxL(blocksize); 
+	TPtr8 iv = iIV->Des();
+	TRandom::RandomL(iv);
+
+	iCipher = PBE::MakeEncryptorL(aCipher, aKey, iv);
+	}
+
+void CPBEncryptorSet::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	if(!iIVSent)
+		{
+		aOutput.Append(*iIV);
+		iIVSent = ETrue;
+		}
+	iCipher->Process(aInput, aOutput);
+	}
+
+void CPBEncryptorSet::ProcessFinalL(const TDesC8& aInput, 
+	TDes8& aOutput)
+	{
+	if(!iIVSent)
+		{
+		aOutput.Append(*iIV);
+		iIVSent = ETrue;
+		}
+	
+	iCipher->ProcessFinalL(aInput, aOutput);
+	}
+
+
+CPBEncryptorSet::CPBEncryptorSet() : iIVSent(EFalse)
+	{
+	}
+
+CPBEncryptorSet::~CPBEncryptorSet()
+	{
+	delete iIV;
+	delete iCipher;	//	Don't delete iCBCDecryptor, this belongs to iCipher
+	}
+
+TInt CPBEncryptorSet::MaxOutputLength(TUint aMaxInputLength) const
+    {
+	if(iIVSent)
+		{
+		return (iCipher->MaxOutputLength(aMaxInputLength));
+		}
+	else 
+		{//	If we've not sent the iv yet then its the length 
+		//	from the cipher plus a blocksize for the iv
+		return (iCipher->MaxOutputLength(aMaxInputLength + iCipher->BlockSize()));
+		}
+    }
+
+TInt CPBEncryptorSet::MaxFinalOutputLength(TUint aMaxInputLength) const
+    {
+	if(iIVSent)
+		{
+		return (iCipher->MaxFinalOutputLength(aMaxInputLength));
+		}
+	else 
+		{//	If we've not sent the iv yet then its the length 
+		//	from the cipher plus a blocksize for the iv
+		return (iCipher->MaxFinalOutputLength(aMaxInputLength + iCipher->BlockSize()));
+		}
+    }
+
+EXPORT_C CPBDecryptorSet* CPBDecryptorSet::NewL(const TPBECipher aCipher, 
+	const TDesC8& aKey)
+	{
+	CPBDecryptorSet* self = NewLC(aCipher, aKey);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBDecryptorSet* CPBDecryptorSet::NewLC(const TPBECipher aCipher,
+	const TDesC8& aKey)
+	{
+	CPBDecryptorSet* self = new(ELeave) CPBDecryptorSet;
+	CleanupStack::PushL(self);
+	TBuf8<KMaxBlockSizeSupported> fakeIV;
+	fakeIV.SetLength(PBE::GetBlockBytes(aCipher));
+	self->ConstructL(aCipher, aKey, fakeIV);
+	return self;
+	}
+
+void CPBDecryptorSet::ConstructL(const TPBECipher aCipher, 
+	const TDesC8& aKey, const TDesC8& aIV)
+	{
+	iCipher = PBE::MakeDecryptorL(aCipher, aKey, aIV);
+	iIVBuf = HBufC8::NewL(PBE::GetBlockBytes(aCipher));
+	}
+
+void CPBDecryptorSet::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TPtrC8 input = ProcessIV(aInput);
+	iCipher->Process(input, aOutput);
+	}
+
+void CPBDecryptorSet::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TPtrC8 input = ProcessIV(aInput);
+	iCipher->ProcessFinalL(input, aOutput);
+	}
+
+TPtrC8 CPBDecryptorSet::ProcessIV(const TDesC8& aInput)
+	{
+	if(!iIVSent)
+		{
+		TPtr8 iIVBufPtr(iIVBuf->Des());
+		if(aInput.Length() + iIVBufPtr.Length() < iCipher->BlockSize())
+			{
+			iIVBufPtr.Append(aInput);
+			return TPtrC8();
+			}
+		else 
+			{
+			TInt rem = iCipher->BlockSize() - iIVBufPtr.Length();
+			iIVBufPtr.Append(aInput.Mid(0, rem));
+			CBufferedDecryptor* blockDecryptor = static_cast<CBufferedDecryptor*>(iCipher);
+			static_cast<CModeCBCDecryptor*>(blockDecryptor->BlockTransformer())->SetIV(iIVBufPtr);
+			iIVSent = ETrue;
+			return aInput.Mid(rem);
+			}
+		}
+	else 
+		{
+		return aInput;
+		}
+	}
+
+CPBDecryptorSet::CPBDecryptorSet() : iIVSent(EFalse)
+	{
+	}
+
+CPBDecryptorSet::~CPBDecryptorSet()
+	{
+	delete iCipher;
+	//iCipher owns iCBCDecryptor we _don't_ need to delete it
+	delete iIVBuf;
+	}
+
+TInt CPBDecryptorSet::MaxOutputLength(TUint aMaxInputLength) const
+    {
+	if(iIVSent)
+		{
+		return (iCipher->MaxOutputLength(aMaxInputLength));
+		}
+	else	//	if we haven't sent the iv yet, then the length the max length of the
+		{	//	cipher minus a BlockSize where the IV was sitting (as the iv would be part
+			//	of the length they've sent us)
+		return (iCipher->MaxOutputLength(aMaxInputLength - iCipher->BlockSize()));
+		}
+    }
+
+TInt CPBDecryptorSet::MaxFinalOutputLength(TUint aMaxInputLength) const
+    {
+	if(iIVSent)
+		{
+		return (iCipher->MaxFinalOutputLength(aMaxInputLength));
+		}
+	else	//	if we haven't sent the iv yet, then the length the max length of the
+		{	//	cipher minus a BlockSize where the IV was sitting (as the iv would be part
+			//	of the length they've sent us)
+		return (iCipher->MaxFinalOutputLength(aMaxInputLength - iCipher->BlockSize()));
+		}
+    }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbeset.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,261 @@
+/*
+* Copyright (c) 2002-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 <e32std.h>
+#include <random.h>
+#include <pbedata.h>
+#include "pkcs5kdf.h"
+#include <pbencryptor.h>
+#include "pbe.h"
+#include <securityerr.h>
+#include "pbesymmetricfactory.h"
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewL(const TPBPassword& aPassword)
+	{
+	CPBEncryptSet* self = NewLC(aPassword);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewLC(const TPBPassword& aPassword)
+	{
+	CPBEncryptSet* self = new(ELeave) CPBEncryptSet;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword.Password());
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewL(const TPBPassword& aPassword, 
+	const TPBECipher aCipher)
+	{
+	CPBEncryptSet* self = NewLC(aPassword, aCipher);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewLC(const TPBPassword& aPassword, 
+	const TPBECipher aCipher)
+	{
+	CPBEncryptSet* self = new(ELeave) CPBEncryptSet;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword.Password(), aCipher);
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewL(const TPBPassword& aPassword,
+	const CPBEncryptParms& aParms)
+	{
+	CPBEncryptSet* self = NewLC(aPassword, aParms);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewLC(const TPBPassword& aPassword, 
+	const CPBEncryptParms& aParms)
+	{
+	CPBEncryptSet* self = new(ELeave) CPBEncryptSet;
+	CleanupStack::PushL(self);
+	self->ConstructL(aPassword.Password(), aParms);
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewL(const CPBEncryptionData& aData, 
+	const TDesC8& aEncryptedKey, const TPBPassword& aPassword)
+	{
+	CPBEncryptSet* self = NewLC(aData, aEncryptedKey, aPassword);
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CPBEncryptSet* CPBEncryptSet::NewLC(const CPBEncryptionData& aData,
+	const TDesC8& aEncryptedKey, const TPBPassword& aPassword)
+	{
+	CPBEncryptSet* self = new(ELeave) CPBEncryptSet;
+	CleanupStack::PushL(self);
+	self->ConstructL(aData, aEncryptedKey, aPassword);
+	return self;
+	}
+
+void CPBEncryptSet::ConstructL(const TDesC8& aPassword)
+	{
+	CPBEncryptElement::ConstructL(aPassword);
+	ConstructMasterKeyL();
+	}
+
+void CPBEncryptSet::ConstructL(const TDesC8& aPassword,
+	const TPBECipher aCipher)
+	{
+	CPBEncryptElement::ConstructL(aPassword, aCipher);
+	ConstructMasterKeyL();
+	}
+
+void CPBEncryptSet::ConstructL(const TDesC8& aPassword, 
+	const CPBEncryptParms& aParms)
+	{
+	CPBEncryptElement::ConstructL(aPassword, aParms);
+	ConstructMasterKeyL();
+	}
+
+void CPBEncryptSet::ConstructMasterKeyL(void)
+	{
+	TBuf8<KAESKeyBytes256> masterKey(KAESKeyBytes256);
+	TRandom::RandomL(masterKey);
+	iEncryptedMasterKey = HBufC8::NewL(KAESKeyBytes256);
+	EncryptMasterKeyL(masterKey);
+	}
+
+void CPBEncryptSet::ConstructL(const CPBEncryptionData& aData,
+	const TDesC8& aEncryptedMasterKey, const TPBPassword& aPassword)
+	{
+	CPBEncryptElement::ConstructL(aData, aPassword);
+	iEncryptedMasterKey = aEncryptedMasterKey.AllocL();
+	}
+
+EXPORT_C void CPBEncryptSet::ChangePasswordL(const TPBPassword& aNewPassword)
+	{
+	//1) Decrypt master key with old encrypt key 
+	TBuf8<KPBEMaxCipherKeyBytes> masterKey;
+	DecryptMasterKeyL(masterKey);
+
+	//2) create new encrypt parms
+
+	TBuf8<KPBEMaxSaltBytes> authSalt(KPBEMaxSaltBytes);
+	TRandom::RandomL(authSalt);
+
+	//3) create a totally new CPBEncryptionData representing the new password
+	CPBEncryptionData* newData = CPBEncryptionData::NewL(
+		aNewPassword.Password(), authSalt, iData->EncryptParms());
+
+	delete iData;
+	iData = newData;
+
+	// regenerate the password using a maximum length salt.
+	CPBEncryptParms& epNonConst =
+		const_cast<CPBEncryptParms&>(iData->EncryptParms());
+	epNonConst.ResizeSaltL(KPBEMaxSaltBytes);
+
+	TPtr8 iEncryptKeyBuf(iEncryptKey->Des());
+	iEncryptKeyBuf.SetLength(PBE::GetKeyBytes(iData->EncryptParms().Cipher()));
+	
+	iData->EncryptParms().DeriveKeyL(aNewPassword.Password(), iEncryptKeyBuf);
+
+	//4) Encrypt master key with new encrypt key
+	EncryptMasterKeyL(masterKey);
+	}
+
+EXPORT_C const TDesC8& CPBEncryptSet::EncryptedMasterKey(void) const
+	{
+	return *iEncryptedMasterKey;
+	}
+
+CPBEncryptor* CPBEncryptSet::NewEncryptLC(void) const
+	{
+	CPBEncryptor* encryptor = NewEncryptL();
+	CleanupStack::PushL(encryptor);
+	return encryptor;
+	}
+
+CPBEncryptor* CPBEncryptSet::NewEncryptL(void) const
+	{
+	TBuf8<KPBEMaxCipherKeyBytes> masterKey;
+	DecryptMasterKeyL(masterKey);
+
+	CPBEncryptor* encryptor = 0;
+	//make sure the masterkey we pass is exactly the right length for the cipher
+	encryptor = CPBEncryptorSet::NewL(iData->EncryptParms().Cipher(),
+		masterKey.Left(PBE::GetKeyBytes(iData->EncryptParms().Cipher())));		
+	return encryptor;
+	}
+
+CPBDecryptor* CPBEncryptSet::NewDecryptLC(void) const
+	{
+	CPBDecryptor* decryptor = NewDecryptL();
+	CleanupStack::PushL(decryptor);
+	return decryptor;
+	}
+
+CPBDecryptor* CPBEncryptSet::NewDecryptL(void) const
+	{
+	TBuf8<KPBEMaxCipherKeyBytes> masterKey;
+	DecryptMasterKeyL(masterKey);
+
+	CPBDecryptor* decryptor = 0;
+	//make sure the masterkey we pass is exactly the right length for the cipher
+	decryptor = CPBDecryptorSet::NewL(iData->EncryptParms().Cipher(),
+		masterKey.Left(PBE::GetKeyBytes(iData->EncryptParms().Cipher())));		
+	return decryptor;
+	}
+
+void CPBEncryptSet::DecryptMasterKeyL(TDes8& aMasterKey) const
+	{
+	CPBDecryptorElement* decryptor = CPBDecryptorElement::NewLC(
+		iData->EncryptParms().Cipher(), *iEncryptKey, iData->EncryptParms().IV());
+	aMasterKey.SetLength(0);
+	decryptor->Process(*iEncryptedMasterKey, aMasterKey);
+	CleanupStack::PopAndDestroy(decryptor);
+	}
+
+void CPBEncryptSet::EncryptMasterKeyL(const TDesC8& aMasterKey)
+	{
+	CPBEncryptorElement* encryptor = CPBEncryptorElement::NewLC(
+		iData->EncryptParms().Cipher(), *iEncryptKey, iData->EncryptParms().IV());
+	TPtr8 encryptedMasterKeyBuf(iEncryptedMasterKey->Des());
+	encryptedMasterKeyBuf.SetLength(0);
+	encryptor->Process(aMasterKey, encryptedMasterKeyBuf);
+	CleanupStack::PopAndDestroy(encryptor);
+	}
+
+CPBEncryptSet::CPBEncryptSet()
+	{
+	}
+
+CPBEncryptSet::~CPBEncryptSet()
+	{
+	delete iEncryptedMasterKey;
+	}
+
+// Warning: This function is only valid BEFORE you call NewEncryptL
+// After creating the cipher, ask it about itself, not me!
+// This is _very_ dodgy as I assume all sorts of things about the encryptor.
+// 1) That it uses SSLv3 or similar style padding
+// 2) That it stores the IV for that stream at the front.
+// This is here for specific application that requires this and aren't able to
+// actually construct the cipher and ask it.  In almost all other cases you
+// should construct the cipher and ask it.
+TInt CPBEncryptSet::MaxCiphertextLength(TInt aPlaintextLength) const
+    {
+	TUint blocksize = PBE::GetBlockBytes(iData->EncryptParms().Cipher());
+	TUint padding = blocksize - aPlaintextLength % blocksize;
+	//totallength = blocksize of iv hidden at beginning + inputLength + padding
+	return blocksize + aPlaintextLength + padding;
+    }
+
+// Warning: This function is only valid BEFORE you call NewDecryptL
+// After creating the cipher, ask it about itself, not me!
+TInt CPBEncryptSet::MaxPlaintextLength(TInt aCiphertextLength) const
+    {
+	/*It's impossible to determine anything about how much padding will be
+	 * removed.  So we'll return a max length that is longer than will ever
+	 * happen by at most a blocksize - 1.
+	 */
+	//In all cases SSLv3 padding has at least one byte of padding.
+	TUint blocksize = PBE::GetBlockBytes(iData->EncryptParms().Cipher());
+	//totallength = inputlength - iv hidden at beginning - 1 byte of padding
+    return aCiphertextLength - blocksize - 1;
+    }
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbesymmetricfactory.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,245 @@
+/*
+* Copyright (c) 2002-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 <symmetric.h>
+#include "pbesymmetricfactory.h"
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+
+/** OpenSSL PKCS8 Effective Key Length Compatibility.*/
+const TUint KPkcs8CompatibilityBits = 128;
+
+/** PKCS12 PBE Effective Key Length Compatibility.*/
+const TUint KPkcs12CompatibilityBits = 40;
+
+#endif
+
+TUint PBE::GetBlockBytes(TPBECipher aCipher)
+	{
+	switch(aCipher)
+		{
+		case ECipherAES_CBC_128:
+		case ECipherAES_CBC_192:
+		case ECipherAES_CBC_256:
+			return KAESBlockBytes;
+		case ECipherDES_CBC:
+		case ECipher3DES_CBC:
+
+		case ECipher2Key3DES_CBC: 
+
+			return KDESBlockBytes;
+		case ECipherRC2_CBC_128_16:
+		case ECipherRC2_CBC_40_16:
+		case ECipherRC2_CBC_128:
+		case ECipherRC2_CBC_40:
+
+		case ECipherRC2_CBC_40_5:
+
+			return KRC2BlockBytes;
+
+		case ECipherARC4_128:
+		case ECipherARC4_40:
+			return 1; // 1 byte block for stream cipher
+
+		default:
+			User::Panic(_L("Invalid PBE cipher"), 1);
+		}
+	return (KErrNone); //	For the compiler
+	}
+
+TUint PBE::GetKeyBytes(TPBECipher aCipher)
+	{
+	switch(aCipher)
+		{
+		case ECipherAES_CBC_128:
+			return KAESKeyBytes128;
+		case ECipherAES_CBC_192:
+			return KAESKeyBytes192;
+		case ECipherAES_CBC_256:
+			return KAESKeyBytes256;
+		case ECipherDES_CBC:
+			return KDESKeyBytes;
+		case ECipher3DES_CBC:
+			return K3DESKeyBytes;
+
+		case ECipher2Key3DES_CBC:
+			return K2Key3DESKeyBytes;
+
+ 		case ECipherRC2_CBC_128:
+ 		case ECipherRC2_CBC_128_16:
+			return KRC2KeyBytes128;
+		case ECipherRC2_CBC_40:
+		case ECipherRC2_CBC_40_16:
+
+		case ECipherRC2_CBC_40_5:
+
+			return KRC2KeyBytes40;
+
+		case ECipherARC4_128:
+			return KRC4KeyBytes128;
+		case ECipherARC4_40:	
+			return KRC4KeyBytes40;
+
+		default:
+			User::Panic(_L("Invalid PBE cipher"), 1);
+		}
+	return (KErrNone);	//	For the compiler
+	}
+
+CSymmetricCipher* PBE::MakeEncryptorL(TPBECipher aCipher, const TDesC8& aKey, 
+	const TDesC8& aIV)
+	{
+	CSymmetricCipher* cipher = 0;	
+	CBlockTransformation* block = 0;
+	switch(aCipher)
+		{
+
+		// stream cipher
+		case ECipherARC4_40:
+		case ECipherARC4_128:
+			cipher = CARC4::NewL(aKey, 0);
+			break;	
+
+		// block cipher	
+		case ECipherAES_CBC_128:
+		case ECipherAES_CBC_192:
+		case ECipherAES_CBC_256:
+			block = CAESEncryptor::NewLC(aKey);
+			break;
+
+		case ECipherDES_CBC:
+			block = CDESEncryptor::NewLC(aKey);
+			break;
+			
+		case ECipher3DES_CBC:		
+			block = C3DESEncryptor::NewLC(aKey);
+			break;
+	
+		case ECipher2Key3DES_CBC:
+			{
+			// Construct 3key from 2 key ( copy first key to 3rd key ) each key 8 bytes
+			TBuf8<K3DESKeyBytes>  encryptKey(aKey);			
+			encryptKey.Append(aKey.Ptr(),KDESKeyBytes);
+			block = C3DESEncryptor::NewLC(encryptKey);			
+			break;
+			}
+
+		case ECipherRC2_CBC_40:
+		case ECipherRC2_CBC_128:		
+			block = CRC2Encryptor::NewLC(aKey);
+			break;
+
+		case ECipherRC2_CBC_40_16:
+		case ECipherRC2_CBC_128_16:
+			block = CRC2Encryptor::NewLC(aKey, KPkcs8CompatibilityBits);
+			break;
+
+		case ECipherRC2_CBC_40_5:
+			block = CRC2Encryptor::NewLC(aKey, KPkcs12CompatibilityBits);
+			break;	
+
+		default:
+			User::Panic(_L("Invalid PBE encryptor"), 1);
+		}
+
+	// if aCipher is not stream cipher, create block cipher object
+	if(aCipher != ECipherARC4_40 && aCipher != ECipherARC4_128)
+		{			
+		block = CModeCBCEncryptor::NewL(block, aIV);
+		CleanupStack::Pop(); //1st block owned by 2nd
+		CleanupStack::PushL(block);//2nd block
+		CPadding* padding = CPaddingSSLv3::NewLC(GetBlockBytes(aCipher));
+		cipher = CBufferedEncryptor::NewL(block, padding);
+		CleanupStack::Pop(padding); //owned by cipher
+		CleanupStack::Pop(block); //owned by cipher
+		}
+
+	return cipher;
+	}
+
+
+CSymmetricCipher* PBE::MakeDecryptorL(TPBECipher aCipher, const TDesC8& aKey, 
+	const TDesC8& aIV)
+	{
+	CSymmetricCipher* cipher = 0;
+	CBlockTransformation* block = 0;
+	switch(aCipher)
+		{
+		// stream cipher
+		case ECipherARC4_40:
+		case ECipherARC4_128:
+			cipher = CARC4::NewL(aKey, 0);
+			break;	
+
+		// block cipher	
+		case ECipherAES_CBC_128:
+		case ECipherAES_CBC_192:
+		case ECipherAES_CBC_256:
+			block = CAESDecryptor::NewLC(aKey);
+			break;
+
+		case ECipherDES_CBC:
+			block = CDESDecryptor::NewLC(aKey);
+			break;
+			
+		case ECipher3DES_CBC:		
+			block = C3DESDecryptor::NewLC(aKey);
+			break;
+
+		case ECipher2Key3DES_CBC:
+			{
+			// Construct 3key from 2 key ( copy first key to 3rd key ) each key 8 bytes
+			TBuf8<K3DESKeyBytes>  encryptKey(aKey);			
+			encryptKey.Append(aKey.Ptr(),KDESKeyBytes);
+			block = C3DESDecryptor::NewLC(encryptKey);			
+			break;
+			}
+
+		case ECipherRC2_CBC_40:
+		case ECipherRC2_CBC_128:
+		  	block = CRC2Decryptor::NewLC(aKey);
+			break;
+			
+		case ECipherRC2_CBC_40_16:
+		case ECipherRC2_CBC_128_16:
+		  	block = CRC2Decryptor::NewLC(aKey, KPkcs8CompatibilityBits);
+			break;
+
+		case ECipherRC2_CBC_40_5:
+			block = CRC2Decryptor::NewLC(aKey, KPkcs12CompatibilityBits);
+			break;	
+
+		default:
+			User::Panic(_L("Invalid PBE decryptor"), 1);
+		}
+
+	// if aCipher is not stream cipher, create block cipher object
+	if(aCipher != ECipherARC4_40 && aCipher != ECipherARC4_128)
+		{	
+		block = CModeCBCDecryptor::NewL(block, aIV);
+		CleanupStack::Pop(); //1st block owned by 2nd
+		CleanupStack::PushL(block);//2nd block
+
+		CPadding* padding = CPaddingSSLv3::NewLC(GetBlockBytes(aCipher));
+		cipher = CBufferedDecryptor::NewL(block, padding);
+		CleanupStack::Pop(padding); //owned by cipher
+		CleanupStack::Pop(block); //owned by cipher
+		}
+
+	return cipher;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pbe/pbesymmetricfactory.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,72 @@
+/*
+* Copyright (c) 2003-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: 
+* PBE symmetric factory
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent 
+*/
+ 
+#ifndef __PBESYMMETRICFACTORY_H__
+#define __PBESYMMETRICFACTORY_H__
+
+#include <symmetric.h>
+#include <pbe.h>
+
+const TUint KAESBlockBytes = 16;
+const TUint KAESKeyBytes128 = 16;
+const TUint KAESKeyBytes192 = 24;
+const TUint KAESKeyBytes256 = 32;
+
+const TUint KDESBlockBytes = 8;
+const TUint KDESKeyBytes = 8;
+const TUint K3DESKeyBytes = 24;
+
+const TUint K2Key3DESKeyBytes = 16;
+const TUint  KRC4KeyBytes128 = 16;
+const TUint  KRC4KeyBytes40 = 5;
+
+const TUint KRC2BlockBytes = 8;
+const TUint KRC2KeyBytes40 = 5;
+const TUint KRC2KeyBytes128 = 16;
+
+const TPBECipher KPBEDefaultStrongCipher = ECipherAES_CBC_128;
+const TPBECipher KPBEDefaultWeakCipher = ECipherDES_CBC;
+const TUint KPBEDefaultSaltBytes = 16; //pkcs5 recommends min 64 bits (8 bytes);
+
+const TUint KPBEMaxCipherIVBytes = KAESBlockBytes;
+const TUint KPBEMaxCipherKeyBytes = KAESKeyBytes256;
+const TUint KPBEMaxSaltBytes = 16; //pkcs5 recommends min 64 bits (8 bytes);
+
+class PBE
+	{
+public:
+	static TUint GetKeyBytes(TPBECipher aCipher);
+	static TUint GetBlockBytes(TPBECipher aCipher);
+
+	static CSymmetricCipher* MakeEncryptorL(TPBECipher aCipher, 
+		const TDesC8& aKey, const TDesC8& aIV);
+	static CSymmetricCipher* MakeDecryptorL(TPBECipher aCipher, 
+		const TDesC8& aKey, const TDesC8& aIV);
+private:
+	PBE(void);
+	PBE(const PBE&);
+	PBE& operator=(const PBE&);	
+	};
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pkcs12kdf/GenTestDKs.java	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,150 @@
+/*
+* Copyright (c) 1998-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: 
+* This program generates keys with Bouncy Castle for compatibility testing.
+*
+*/
+
+
+import java.security.SecureRandom; 
+import org.bouncycastle.crypto.PBEParametersGenerator;
+import org.bouncycastle.crypto.digests.SHA1Digest;
+import org.bouncycastle.crypto.generators.PKCS12ParametersGenerator;
+import org.bouncycastle.crypto.params.KeyParameter;
+
+public class GenTestDKs
+{
+	public static void main(String[] args)
+	{
+		PKCS12ParametersGenerator pgen = new PKCS12ParametersGenerator(new SHA1Digest());
+
+		// SB.4: key lengths for defined OIDs
+		// (168 for triple DES will first exercise chaining.)
+		final int[] keyLens = {40, 128, 168, 368};
+		
+		// SB.4 iteration count is recommended to be 1024 or more
+		final int[] iterCounts = {1, 2, 4, 8, 128, 1024, 1536, 2048};
+		
+		// SB.4 salt should be same length as hash function output
+		// (=160 bits for SHA1.)
+		byte[][] salts = new byte[3][];
+		salts[0] = new byte[] {'S', 'A', 'L', 'T'};
+		System.out.println("4 byte salt");
+		printByteArray(salts[0]);
+		
+		// calls to nextBytes() are only executed once
+/*		SecureRandom sr;
+		try { sr = SecureRandom.getInstance("SHA1PRNG", "SUN"); }
+		catch (Exception e)
+		{
+			System.err.println("UNABLE TO GET RANDOM SOURCE");
+			return;
+		}
+*/		
+//		salts[1] = new byte[160 / 8];
+//		sr.nextBytes(salts[1]);
+		salts[1] = new byte[]
+		{
+			(byte) 0x1d, (byte) 0x56, (byte) 0x50, (byte) 0x78,
+			(byte) 0xc3, (byte) 0x50, (byte) 0x6f, (byte) 0x89,
+			(byte) 0xbd, (byte) 0xa7, (byte) 0x3b, (byte) 0xb6,
+			(byte) 0xe3, (byte) 0xe5, (byte) 0xb8, (byte) 0xa3,
+			(byte) 0x68, (byte) 0x3d, (byte) 0xd3, (byte) 0x62
+		};
+		System.out.println("20 byte salt (same size as SHA1 output)");
+		printByteArray(salts[1]);
+		
+//		salts[2] = new byte[200 / 8];
+//		sr.nextBytes(salts[2]);
+		salts[2] = new byte[]
+        {
+			(byte) 0xe2, (byte) 0x2c, (byte) 0x7b, (byte) 0x03,
+			(byte) 0x16, (byte) 0x3a, (byte) 0xe5, (byte) 0x47,
+			(byte) 0xf8, (byte) 0x23, (byte) 0x9d, (byte) 0xa4,
+			(byte) 0x0d, (byte) 0x6f, (byte) 0x46, (byte) 0xd7,
+			(byte) 0x9e, (byte) 0xa3, (byte) 0xc6, (byte) 0xff,
+			(byte) 0xb3, (byte) 0xf0, (byte) 0x4e, (byte) 0xbe,
+			(byte) 0x61
+        };
+		System.out.println("25 byte salt");
+		printByteArray(salts[2]);
+		
+		final String passwds[] = {"0000", "0001", "PSWD", "password", "abcdefghijklmnopqrstuvwxyz"}; 
+		
+		for (int keyLenIdx = 0; keyLenIdx < keyLens.length; ++keyLenIdx)
+		{
+			for (int iterIdx = 0; iterIdx < iterCounts.length; ++iterIdx)
+			{
+				for (int saltIdx = 0; saltIdx < salts.length; ++saltIdx)
+				{
+					for (int pwdIdx = 0; pwdIdx < passwds.length; ++pwdIdx)
+					{
+						testKey(pgen, keyLens[keyLenIdx], iterCounts[iterIdx], passwds[pwdIdx], salts[saltIdx]);
+					}	// for (int pwdIdx = 0; pwdIdx < passwds.length; ++pwdIdx)
+				}	// for (int saltIdx = 0; saltIdx < salts.length; ++saltIdx)
+			}	// for (int iterIdx = 0; iterIdx < iterCounts.length; ++iterIdx)
+		}	// for (int keyLenIdx = 0; keyLenIdx < keyLens.length; ++keyLenIdx)
+	}
+	
+	private static void testKey(
+		PKCS12ParametersGenerator pgen,
+		int keyLen, int iterCount, String password, byte[] salt)
+	{
+		System.out.println(
+				"key len = " + keyLen + ", iter count = " + iterCount
+			+	", password = \"" + password + "\", salt len = " + salt.length);
+
+		char[] pwChars = password.toCharArray();
+		byte[] pwBytes = PBEParametersGenerator.PKCS12PasswordToBytes(pwChars);
+		
+		pgen.init(pwBytes, salt, iterCount);
+		KeyParameter kp = (KeyParameter) pgen.generateDerivedParameters(keyLen);
+		printByteArray(kp.getKey());
+	}
+	
+	private static void printByteArray(byte[] a)
+	{
+		final int BLOCK_SIZE = 16;
+		int keyLen = a.length;
+		int rowCount = keyLen / BLOCK_SIZE;
+		if ((keyLen % BLOCK_SIZE) != 0)
+			++rowCount;
+		
+		for (int row = 0; row < rowCount; ++row)
+			{
+			int start = row * BLOCK_SIZE;
+			int end = Math.min(start + BLOCK_SIZE, keyLen);
+			
+			StringBuffer line = new StringBuffer("[" + hexStr(start, 4) + "]");
+			
+			for (int i = start; i < end; ++i)
+				line.append(" " + hexStr(a[i], 2));
+			System.out.println(line);
+			}
+		System.out.println();
+	}
+	
+	private static String hexStr(int val, int width)
+	{
+		StringBuffer result = new StringBuffer();
+		while (--width >= 0)
+		{
+			int bitPos = 4 * width;
+			int nybble = (val & (0xf << bitPos)) >> bitPos;
+			result.append(Integer.toHexString(nybble));
+		}
+		
+		return result.toString();
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pkcs12kdf/Pkcs12Pbe.java	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,130 @@
+/*
+* Copyright (c) 2006-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: 
+* This program uses the Bouncy Castle APIs PKCS#12 KDF to generate encryption keys + ivs 
+* and mac keys for use with compatibility testing.
+*
+*/
+
+
+package com.symbian.security;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import org.bouncycastle.crypto.PBEParametersGenerator;
+import org.bouncycastle.crypto.digests.SHA1Digest;
+import org.bouncycastle.crypto.generators.PKCS12ParametersGenerator;
+import org.bouncycastle.crypto.CipherParameters;
+import org.bouncycastle.crypto.params.KeyParameter;
+import org.bouncycastle.crypto.params.ParametersWithIV;
+
+public class Pkcs12Pbe {
+	private PKCS12ParametersGenerator pgen;
+
+	public Pkcs12Pbe() {
+		pgen = new PKCS12ParametersGenerator(new SHA1Digest());
+	}
+
+	public static void main(String args[]) {
+		try {
+			if (args.length < 5) {
+				usage();
+				System.exit(-1);
+				
+			}
+			int keyLength = Integer.parseInt(args[0]);
+			int blockSize = Integer.parseInt(args[1]);
+			int iterations = Integer.parseInt(args[2]);
+			String salt = args[3];
+			String password = args[4];		
+			byte[] saltBytes = hexToByteArray(salt);
+	
+			Pkcs12Pbe pbe = new Pkcs12Pbe();
+			pbe.getKey(keyLength, blockSize, iterations, password, saltBytes);			
+		}
+		catch (Exception e) {
+			System.exit(-1);
+		}
+	}
+	
+	private static byte[] hexToByteArray(String hex) throws Exception {
+		if (hex.length() % 2 != 0) {
+			throw new Exception("hexToByteArray: odd number of nibbles");
+		}
+		StringBuffer hexBuffer = new StringBuffer(hex);
+		
+		byte[] byteBuffer = new byte[hexBuffer.length() / 2];
+		for (int i = 0; i < hexBuffer.length(); i+=2) {
+			try {
+				byteBuffer[i / 2] = (byte) Integer.parseInt(hexBuffer.substring(i, i+2), 16);
+			}
+			catch (NumberFormatException e) {
+				System.err.println("hexToByteArray: invalid hex string: " + hex);
+				throw e;
+			}
+		}
+		return byteBuffer;
+	}
+
+	private static void usage() {
+		System.err
+				.println("Usage: pkcs12pbe <key length> <block_size> <iterations> <salt> <password>\n");
+	}
+	
+	private void getKey(int keyLen, int ivLen, int iterCount, String password,
+			byte[] salt) {
+		System.out.print("key len = " + keyLen + ", iter count = "
+				+ iterCount + ", password = \"" + password + "\", salt = ");		
+		printUnformattedByteArray(salt);
+
+		char[] pwChars = password.toCharArray();
+		byte[] pwBytes = PBEParametersGenerator.PKCS12PasswordToBytes(pwChars);
+
+		pgen.init(pwBytes, salt, iterCount);
+		CipherParameters cp = pgen.generateDerivedParameters(keyLen, ivLen);
+
+		ParametersWithIV ivp = (ParametersWithIV) cp;
+		KeyParameter kp = (KeyParameter) ivp.getParameters();
+
+		System.out.print("key ");
+		printUnformattedByteArray((kp.getKey()));
+		System.out.print("iv ");
+		printUnformattedByteArray(ivp.getIV());
+
+		kp = (KeyParameter) pgen.generateDerivedMacParameters(160);
+		System.out.print("160bit hmac key ");
+		printUnformattedByteArray((kp.getKey()));
+
+	}
+
+	// unformatted hex strings that can be passed as arguments to openssl
+	private void printUnformattedByteArray(byte[] a) {
+		StringBuffer line = new StringBuffer();
+		
+		for (int i = 0; i < a.length; i++) {
+			line.append(hexStr(a[i], 2));
+		}
+		System.out.println(line);
+	}	
+
+	private String hexStr(int val, int width) {
+		StringBuffer result = new StringBuffer();
+		while (--width >= 0) {
+			int bitPos = 4 * width;
+			int nybble = (val & (0xf << bitPos)) >> bitPos;
+			result.append(Integer.toHexString(nybble));
+		}
+		return result.toString();
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pkcs12kdf/pkcs12kdf.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,274 @@
+/*
+* Copyright (c) 2005-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 <hash.h>
+#include <bigint.h>
+#include "pkcs12kdf.h"
+
+
+EXPORT_C HBufC8* PKCS12KDF::GeneratePasswordLC(const TDesC& aDes)
+/**
+	Convert the supplied string to a byte string, as described
+	in SB.1 of the PKCS 12 v1.0.
+	
+	Each character is converted to a big endian two-byte value,
+	and a terminating NULL character is appended to the end.
+	
+	@param	aDes			String to use as password.
+ */
+	{
+	const TInt len = aDes.Length();
+	HBufC8* pwdBytes = HBufC8::NewMaxLC((len + 1) * 2);
+	TPtr8 pbDes = pwdBytes->Des();
+	
+	TInt i = 0;
+	while (i < len)
+		{
+		TUint16 ch = aDes[i];
+		pbDes[i * 2] = ch >> 8;
+		pbDes[(i * 2) + 1] = ch;
+		++i;
+		}
+	pbDes[i * 2] = pbDes[(i * 2) + 1] = 0;
+	
+	return pwdBytes;
+	}
+
+static TInt CeilDiv(TInt aNumerator, TInt aDenominator)
+/**
+	Utility function returns ceil(aNumerator / aDenominator).
+
+	@param	aNumerator		The numerator.
+	@param	aDenominator	Denominator, which cannot be zero.
+	@return					ceil(aNumerator / aDenominator)
+ */
+	{
+	TInt result = aNumerator / aDenominator;
+	if ((aNumerator % aDenominator) > 0)
+		++result;
+	return result;
+	}
+
+EXPORT_C void PKCS12KDF::DeriveKeyL(
+	TDes8& aKey, TIDByteType aIDType,
+	const TDesC8& aPasswd, const TDesC8& aSalt, const TUint aIterations)
+/**
+	Generate a key for the supplied password and salt.
+	This implementation uses SHA1 as the hashing algorithm.
+	
+	@param	aKey			Descriptor which will hold key.  On entry
+							its length must be set to the expected key length.
+	@param	aIDType			Whether this function is being called to generate
+							an (en|de)cryption key, an initialization vector,
+							or a key for MAC-ing.  See SB.3 of spec.
+	@param	aPasswd			Password string.  To comply with PKCS#12 spec,
+							this must have 2-byte big-endian characters with
+							a terminating null character.
+	@param	aSalt			Used with aPasswd to generate key.
+	@param	aIterations		Number of times to call the hash function for
+							each block in the key.
+	
+	@panic	PKCS#12 16		Password is empty (debug only.)
+	@panic	PKCS#12 17		Password does not contain an even number of bytes,
+							and so can't use double-byte characters (debug only.)
+	@panic	PKCS#12 18		The final two-byte character is not a null terminator,
+							or a null terminator occurs before the end (debug only.)
+ */
+	{
+	__ASSERT_DEBUG(aPasswd.Length() >= 2, Panic(EDKEmptyPswd));
+	__ASSERT_DEBUG((aPasswd.Length() % 2) == 0, Panic(EDKOddPswdByteCount));
+	TInt useCharCount = aPasswd.Length() / 2;
+	TPtrC16 pswd16(reinterpret_cast<const TUint16*>(aPasswd.Ptr()), useCharCount);
+	TInt nullPos = pswd16.Locate(L'\0');
+	__ASSERT_DEBUG(nullPos == (useCharCount - 1), Panic(EDKBadNullTerminator));
+
+	// use the same notation as the standard
+	const TUint8 ID = static_cast<TUint8>(aIDType);
+	const TInt u = 160;					// chaining variable length for SHA-1
+	const TInt v = 512;					// message input length for SHA-1
+	const TInt n = aKey.Length() * 8;	// number of bits required in key
+	const TInt p = aPasswd.Length();
+	const TInt s = aSalt.Length();
+	const TInt r = aIterations;
+	
+	// (numbered steps are from the standard)
+	// 1. Construct a string, D (the "diversifier"), by concatenating
+	// v/8 copies of ID.
+	const TInt D_LEN = v / 8;
+	HBufC8* D_ = HBufC8::NewMaxLC(D_LEN);
+	TPtr8 D = D_->Des();
+	D.Fill(ID);
+	
+	// 2. Concatenate copies of the salt together to create a string S
+	// of length v * ceil(s/v) bits (the final copy of the salt may be
+	// truncated to create S).  Note that if the salt is the empty string,
+	// then so is S.
+	const TInt S_OVER_V_CEIL = CeilDiv(s, v);
+	const TInt S_LEN = (v * S_OVER_V_CEIL) / 8;
+	HBufC8* S_ = HBufC8::NewMaxLC(S_LEN);
+	TPtr8 S = S_->Des();
+	S.Repeat(aSalt);
+	
+	// 3. Concatenate copies of the password together to create a string P
+	// of length v * ceil(p/v) bits (the final copy of the password may be
+	// truncated to create P).  Note that if the password is the empty string
+	// then so is P.
+	const TInt P_OVER_V_CEIL = CeilDiv(p, v);
+	const TInt P_LEN = (v * P_OVER_V_CEIL) / 8;
+	HBufC8* P_ = HBufC8::NewMaxLC(P_LEN);
+	TPtr8 P = P_->Des();
+	P.Repeat(aPasswd);
+	
+	// 4. Set I=S||P to be the concatenation of S and P.
+	const TInt I_LEN = S_LEN + P_LEN;
+	HBufC8* I_ = HBufC8::NewLC(I_LEN);
+	TPtr8 I = I_->Des();
+	I.Copy(S);
+	I.Append(P);
+	
+	// 5. Set c=ceil(n/u).
+	const TInt c = CeilDiv(n, u);
+	
+	// ahead 7: allocate result buffer A
+	// (Each Ai has SHA1_HASH bytes.)
+	HBufC8* A_ = HBufC8::NewLC(c * SHA1_HASH);
+	TPtr8 A = A_->Des();
+	
+	// 6. For i=1, 2, ..., c, do the following
+	
+	// pre-allocate SHA1 object, DI, and B buffers
+	CSHA1* sha1 = CSHA1::NewL();
+	CleanupStack::PushL(sha1);
+	
+	const TInt DI_LEN = D_LEN + I_LEN;
+	HBufC8* DI_ = HBufC8::NewLC(DI_LEN);
+	TPtr8 DI = DI_->Des();
+	
+	const TInt B_LEN = v / 8;
+	HBufC8* B_ = HBufC8::NewMaxLC(B_LEN);
+	TPtr8 B = B_->Des();
+	
+	for (TInt i = 1; i <= c; ++i)
+		{
+		// 6a) Set Ai = H^r(D||I).  (i.e. the rth hash of D||I,
+		// H(H(H(...H(D||I))))
+		DI.Copy(D);
+		DI.Append(I);
+		
+		sha1->Reset();
+		TBuf8<SHA1_HASH> Ai(sha1->Final(DI));
+		
+		for (TInt iterCount = 2; iterCount <= r; ++iterCount)
+			{
+			Ai.Copy(sha1->Final(Ai));
+			}
+		
+		// 6b) Concatenate copies of Ai to create a string B of length
+		// v bits (the final copy of Ai may be truncated to create B).
+		B.Repeat(Ai);
+		
+		// 6c) Treating I as a concatenation I0, I1, ..., Ik-1 of
+		// v-bit blocks, where k=ceil(s/v)+ceil(p/v), modify I by
+		// setting Ij=(Ij+B+1) mod 2^v for each j.
+
+		const TInt k = S_OVER_V_CEIL + P_OVER_V_CEIL;
+		for (TInt j = 0; j < k; ++j)
+			{
+			TPtr8 section = I.MidTPtr((v/8) * j, v/8);
+			Process6cL(section, B, v);
+			}
+		
+		// 7. Concatenate A1, A2, ..., Ac together to form a pseudo-random
+		// bit string, A.
+		A.Append(Ai);
+		
+		// stop building A if already have enough bits for key
+		if (A.Length() >= n / 8)
+			break;
+		}
+
+	// Use the first n bits of A as the output of this entire process.
+	aKey.Copy(A.Left(n / 8));
+	
+	CleanupStack::PopAndDestroy(8, D_);	// B_, DI_, sha1, A_, I_, P_, S_, D_
+	}
+
+void PKCS12KDF::Process6cL(TDes8& Ij, const TDesC8& B, TInt v)
+/**
+	Helper function for DeriveKeyL modifies part of I,
+	as described in step 6c of SB.2.
+	
+	@param	Ij		Section of I (S || P).
+	@param	B		rth hash of D || I.
+	@param	v		Number of bits to preserve in result.
+ */
+	{
+	// 6c) Treating I as a concatenation I0, I1, ..., Ik-1 of
+	// v-bit blocks, where k=ceil(s/v)+ceil(p/v), modify I by
+	// setting Ij=(Ij+B+1) mod 2^v for each j.
+	
+	RInteger RI_Ij = RInteger::NewL(Ij);
+	TCleanupItem ciIj = RI_Ij;
+	CleanupStack::PushL(ciIj);
+	
+	RInteger RI_B = RInteger::NewL(B);
+	TCleanupItem ciB = RI_B;
+	CleanupStack::PushL(ciB);
+	
+	// these additions can leave
+	RI_Ij += RI_B;
+	RI_Ij += 1;
+	
+	HBufC8* result = RI_Ij.BufferLC();
+	
+	Ij.Zero();
+	TInt resultLen = result->Length();
+	
+	TInt bytesToPreserve = v / 8;
+	TInt leadingZeroes = bytesToPreserve - resultLen;
+	if (leadingZeroes <= 0)
+		Ij.Copy(result->Right(bytesToPreserve));
+	else
+		{
+		Ij.FillZ(leadingZeroes);
+		Ij.Append(*result);
+		}
+	
+	CleanupStack::PopAndDestroy(3, &RI_Ij);	// result, ciB, ciIj
+	}
+
+#ifdef _DEBUG
+
+void PKCS12KDF::Panic(PKCS12KDF::TPanic aPanic)
+/**
+	This function is used in debug builds to halt
+	the current thread when a logic error is detected.
+	
+	The current thread is panicked with category "PKCS12KDF"
+	and the supplied reason.
+	
+	@param	aPanic			Converted to numeric value and
+							used for the panic reason.
+ */
+	{
+	_LIT(KPanicCat, "PKCS12KDF");
+	User::Panic(KPanicCat, aPanic);
+	}
+
+#endif
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/pkcs5kdf/pkcs5kdf.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,115 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "pkcs5kdf.h"
+
+/* Before complaining about the variable names in this file, 
+ * read the pkcs5 spec and all will become clear.
+ */
+
+EXPORT_C void TPKCS5KDF::DeriveKeyL(TDes8& aKey, const TDesC8& aPasswd, const TDesC8& aSalt, 
+	const TUint aIterations)
+{
+	CSHA1* sha1 = CSHA1::NewL();
+	CleanupStack::PushL(sha1);
+	CHMAC* hmac = CHMAC::NewL(aPasswd, sha1);
+	CleanupStack::Pop(sha1); //hmac now owns it
+	CleanupStack::PushL(hmac);
+
+	TUint hashBytes = hmac->HashSize();
+	TUint c = aIterations;
+	TUint l = aKey.Length() / hashBytes; 
+	if(aKey.Length() % hashBytes != 0) //round up if mod !=0
+		{
+		l+=1;
+		}
+	TUint r = aKey.Length() - (l-1) * hashBytes; //r == length of last block
+	
+	HBufC8* TiTemp = HBufC8::NewLC(hashBytes);
+	TUint32* Ti = (TUint32*)(TiTemp->Ptr());
+	aKey.SetLength(0); //we've already saved the length we want
+
+	HBufC8* STemp = HBufC8::NewLC(aSalt.Length() + sizeof(TUint32));
+	TUint32* S = (TUint32*)(STemp->Ptr());
+
+	HBufC8* UiTemp = HBufC8::NewLC(hashBytes);
+	TUint32* Ui = (TUint32*)(UiTemp->Ptr());
+
+	const TUint32* salt = (TUint32*)(aSalt.Ptr());
+	TUint saltBytes = aSalt.Length();
+
+	for(TUint i = 1; i<=l; i++)
+		{
+		F(*hmac, Ti, S, Ui, hashBytes, salt, saltBytes, c, i);
+		if(i == l)
+			aKey.Append((TUint8*)Ti, r);
+		else 
+			aKey.Append((TUint8*)Ti, hashBytes);
+		}
+
+	CleanupStack::PopAndDestroy(UiTemp);
+	CleanupStack::PopAndDestroy(STemp);
+	CleanupStack::PopAndDestroy(TiTemp);
+	CleanupStack::PopAndDestroy(hmac);
+	}
+
+void TPKCS5KDF::F(CMessageDigest& aDigest, TUint32* aAccumulator, 
+	TUint32* S, TUint32* Ui, TUint aHashBytes, const TUint32* aSalt, 
+	TUint aSaltBytes, TUint c, TUint i)
+	{
+	TUint8 itmp[4];
+	itmp[0] = (TUint8)((i >> 24) & 0xff);
+	itmp[1] = (TUint8)((i >> 16) & 0xff);
+	itmp[2] = (TUint8)((i >> 8) & 0xff);
+	itmp[3] = (TUint8)(i & 0xff);
+	TUint8* endOfS = Mem::Copy(S, aSalt, aSaltBytes);
+	Mem::Copy((TUint32*)endOfS, (TUint32*)&itmp, 4);
+
+	TPtr8 sptr((TUint8*)S, aSaltBytes+4);
+	sptr.SetLength(aSaltBytes+4);
+	Mem::Copy(aAccumulator, (TUint32*)((aDigest.Final(sptr)).Ptr()),aHashBytes);
+	Mem::Copy(Ui, aAccumulator, aHashBytes);
+
+	for(TUint j=1; j<c; j++)
+		{
+		TPtr8 uiptr((TUint8*)Ui, aHashBytes);
+		uiptr.SetLength(aHashBytes);
+		Mem::Copy(Ui, (TUint32*)((aDigest.Final(uiptr)).Ptr()), aHashBytes);
+		XORString(Ui, aAccumulator, aHashBytes);
+		}
+	}
+
+inline void TPKCS5KDF::XORString(const TUint32* aOp1, TUint32* aOp2,
+	TUint aLength)
+	{
+	const TUint32* i = aOp1;
+
+	//this will overflow the whole final word if aLength % 4 != 0 
+	//but I can't see this mattering cuz all memory allocation is on a word by word basis
+	//i don't want to do this byte by byte as it'll be way slower
+	//also, every sane digest is going to be a multiple of 4 -- so this isn't a problem
+	for( ; aOp1 != (TUint32*)((TUint8*)i + aLength); )
+		{
+			*aOp2++ ^= *aOp1++;	
+		}
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/messagedigest.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,70 @@
+/*
+* Copyright (c) 2005-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: 
+* hash.cpp
+* (c) 1999-2003 Symbian Ltd. All rights reserved
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <e32std.h>
+#include <hash.h>
+#include "sha1shim.h"
+
+CMessageDigest::CMessageDigest(void):CBase()
+{}
+
+CMessageDigest::CMessageDigest(const CMessageDigest& /*aMD*/):CBase()
+{}
+
+CMessageDigest::~CMessageDigest(void)
+{}
+
+TInt CMessageDigest::GetExtension(TUint aExtensionId, TAny*& a0, TAny* a1)
+	{
+	return Extension_(aExtensionId, a0, a1);
+	}
+
+
+//////////////////////////////////////////////////////////////////
+//	Factory class to create CMessageDigest derived objects
+//////////////////////////////////////////////////////////////////
+CMessageDigest* CMessageDigestFactory::NewDigestL(CMessageDigest::THashId aHashId)
+{
+	CMessageDigest* hash = NULL;
+	switch (aHashId)
+	{
+	case (CMessageDigest::ESHA1):
+		{
+			hash = CSHA1Shim::NewL();
+			break;
+		}
+	default:	
+		User::Leave(KErrNotSupported);
+	}
+
+	return (hash);
+}
+
+CMessageDigest* CMessageDigestFactory::NewDigestLC(CMessageDigest::THashId aHashId)
+{
+	CMessageDigest* hash = CMessageDigestFactory::NewDigestL(aHashId);
+	CleanupStack::PushL(hash);
+	return (hash);
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/random.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,117 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <e32std.h>
+#include <e32math.h>
+#include <random.h>
+#include <hash.h>
+
+#include "randsvr.h"
+#include "randcliserv.h"
+#include "randomshim.h"
+
+extern "C" {
+EXPORT_C void RAND_bytes(unsigned char* buf,int bytes)
+	{
+	TPtr8 ptr(buf,bytes,bytes);
+	buf[0]++;
+	TRandom::Random(ptr);
+	}
+}
+
+EXPORT_C CRandom::CRandom(void)
+	{
+	}
+
+EXPORT_C CSystemRandom* CSystemRandom::NewL(void)
+	{
+	CSystemRandom* self = NewLC();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CSystemRandom* CSystemRandom::NewLC(void)
+	{
+	CSystemRandom* self = new(ELeave)CSystemRandom();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CSystemRandom::GenerateBytesL(TDes8& aDest)
+	{
+	iShim->GenerateBytesL(aDest);
+	}
+
+CSystemRandom::CSystemRandom(void)
+	{
+	}
+
+CSystemRandom::~CSystemRandom()
+	{
+	delete iShim;
+	}
+
+void CSystemRandom::ConstructL()
+	{
+	iShim = CRandomShim::NewL();
+	}
+
+// Methods replace by shim are excluded from coverage.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+EXPORT_C void TRandom::Random(TDes8& aDestination)
+	{
+	// Method replaced by shim
+	TRandomShim::Random(aDestination);
+	}
+
+EXPORT_C void TRandom::RandomL(TDes8& aDestination)
+	{
+	// Method replaced by shim
+	TRandomShim::RandomL(aDestination);
+	}
+
+EXPORT_C RRandomSession::RRandomSession(void)
+	{
+	}
+
+EXPORT_C void RRandomSession::ConnectL(void)
+	{
+	// All of the ConnectL() code has moved to randomimpl.cpp
+	// in the new CryptoSPI pluggable framework. This is just
+	// a stub now that is retained for binary compatibility.
+
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+EXPORT_C TInt RRandomSession::GetRandom(TDes8& aDestination)
+	{
+	// Method replaced by shim
+	TRandomShim::Random(aDestination);
+	return KErrNone;
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/randomshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,105 @@
+/*
+* Copyright (c) 2006-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: 
+* random shim implementation
+* random shim implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "randomshim.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/cryptorandomapi.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "keys.h"
+#include <e32debug.h>
+
+
+using namespace CryptoSpi;
+
+_LIT(KRandomFail, "Cannot obtain randomness");
+
+//
+// Random shim implementation
+//
+CRandomShim* CRandomShim::NewL()
+	{
+	CRandomShim* self = CRandomShim::NewLC();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CRandomShim* CRandomShim::NewLC()
+	{
+	CRandomShim* self = new(ELeave) CRandomShim();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CRandomShim::GenerateBytesL(TDes8& aDest)
+	{
+	iRandomImpl->GenerateRandomBytesL(aDest);
+	}
+
+CRandomShim::CRandomShim()
+	{
+	}
+
+CRandomShim::~CRandomShim()
+	{
+	delete iRandomImpl;
+	}
+
+void CRandomShim::ConstructL()
+	{
+	CRandomFactory::CreateRandomL(iRandomImpl, KRandomUid, NULL);
+	}
+
+/**
+ * @deprecated Use RandomL() instead
+ * @panic This function can panic under low memory conditions
+ * See PDEF097319: TRandom::Random panics during OOM
+ * This method is preserved only for BC reasons
+ */
+void TRandomShim::Random(TDes8& aDest)
+	{
+	CRandomShim* rand = NULL;
+	TRAPD(ret, rand = CRandomShim::NewL());
+	if (ret != KErrNone)
+		{
+		User::Panic(KRandomFail, ret);
+		}
+	TRAPD(ret2, rand->GenerateBytesL(aDest));
+	delete rand;
+	if (ret2 != KErrNone)
+		{
+		// this method can't leave so the cleanup stack can't be used (because of PushL()) 
+		// so we just delete the randon shim here if GenerateBytesL() leaves
+		User::Panic(KRandomFail, ret);
+		}
+	}
+
+void TRandomShim::RandomL(TDes8& aDest)
+	{
+	CRandomShim* rand = CRandomShim::NewL();
+	CleanupStack::PushL(rand);
+	rand->GenerateBytesL(aDest);
+	CleanupStack::PopAndDestroy(rand); // Use a singleton, avoid new overhead?
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/randomshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,61 @@
+/*
+* Copyright (c) 2006-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: 
+* random shim class definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RANDOMSHIM_H__
+#define __RANDOMSHIM_H__
+
+#include <e32def.h>
+#include <random.h>
+#include <cryptospi/cryptorandomapi.h>
+
+//
+// CRandom shim class
+//
+NONSHARABLE_CLASS(CRandomShim) : public CBase
+	{
+public:
+	static CRandomShim* NewL();
+	static CRandomShim* NewLC();
+	~CRandomShim();
+	virtual void GenerateBytesL(TDes8& aDest);
+	
+private:
+	CRandomShim();
+	CRandomShim(const CRandomShim&);
+	CRandomShim& operator=(const CRandomShim&);
+	void ConstructL();
+
+private:
+	CryptoSpi::CRandom* iRandomImpl;
+	};
+
+class TRandomShim
+	{
+public:
+	static void Random(TDes8& aDestination);
+	static void RandomL(TDes8& aDestination);
+	};
+
+#endif // __RANDOMSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/randsvr.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,255 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "randsvr.h"
+#include "randcliserv.h"
+#include "sha1shim.h"
+#include <e32math.h>
+#include "randsvrimpl.h"
+
+//const TInt KFastTickTimer=1000000;			// These are testing numbers!
+//const TInt KSlowTickTimer=30000000;
+const TInt KThreshold=1024;
+
+const TInt KFastTickTimer=30000000;			// These are the real numbers!
+const TInt KSlowTickTimer=0x7fffffff;
+
+using namespace CryptoSpi;
+
+void SignalClient()
+//
+// Signal the owning thread that the server has started successfully
+// This may itself fail
+//
+	{
+	RProcess::Rendezvous(KErrNone);
+	}
+
+
+TInt RunRandomServer(TAny* /*aUnused*/)
+	{
+
+	__UHEAP_MARK;
+
+	CTrapCleanup* cleanup=CTrapCleanup::New();
+	if (!cleanup)
+		{
+		return KErrNoMemory;
+		}
+
+	TInt ret = User::RenameThread(KRandomServerName);
+
+	__ASSERT_ALWAYS(ret==KErrNone,User::Panic(KRandomServerName,KErrServerTerminated));
+
+	if (CRandomScheduler::New())
+		return KErrNoMemory;
+	CRandomServer* random(0);
+	TRAP(ret, random = CRandomServer::NewL());
+	if (ret != KErrNone)
+		return ret;
+	random->Start(KRandomServerName);
+	// Initialisation complete, now signal the client
+	SignalClient();
+	
+	CRandomScheduler::Start();
+	delete random;
+	delete cleanup;
+
+	__UHEAP_MARKEND;
+	return KErrNone;
+	}
+
+TBool CRandomScheduler::New(void)
+	{
+	CRandomScheduler* rs;
+	rs=new CRandomScheduler;
+	CRandomScheduler::Install(rs);
+	return (rs == NULL);
+	}
+
+void CRandomScheduler::Error(TInt /*aError*/) const 
+	{
+	User::Panic(KRandomServerName, 3);
+	}
+
+CRandomServer::CRandomServer(void) : CServer2(EPriorityLow)
+	{
+	}
+
+CRandomServer::~CRandomServer(void)
+	{
+	// This should never happen....but in case it does:
+	delete iHash;
+	delete iTicker;
+	delete iPool;
+	}
+
+CRandomServer* CRandomServer::NewL(void)
+	{
+	CRandomServer* self = new (ELeave) CRandomServer;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CRandomServer::ConstructL(void)
+	{
+	iPool=new (ELeave) TUint8[KRandomPoolSize];
+	iHash=CSHA1Shim::NewL();
+	iPoolIn=0;
+	iPoolOut=0;
+	iTicker=CPeriodic::NewL(EPriorityLow);
+	TCallBack callback(Tick,this);
+	iTicker->Start(KFastTickTimer,KFastTickTimer,callback);		// **** these figures might need tweaking!
+	iQuality=0;
+	iFast=ETrue;
+	}
+
+TInt CRandomServer::Tick(TAny* aServer)
+	{
+	CRandomServer* svr=(CRandomServer*)aServer;
+	svr->Stir();
+	svr->iQuality+=30;
+	if (svr->iFast)
+		{
+		if (svr->iQuality>KThreshold)
+			{
+			TCallBack callback(Tick,svr);
+			svr->iTicker->Cancel();
+			svr->iTicker->Start(KSlowTickTimer,KSlowTickTimer,callback);		// **** these figures might need tweaking!
+			svr->iFast=EFalse;
+			}
+		}
+	if (svr->iQuality>(KRandomPoolSize<<3))
+		{
+		svr->iQuality=(KRandomPoolSize<<3);
+		}
+	return ETrue;
+	}
+
+CSession2* CRandomServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const
+	{
+	return CRandomSession::NewL(const_cast<CRandomServer*>(this));
+	//CRandomSession::NewL(CONST_CAST(CRandomServer*,this),Message().Client());
+	}
+
+TPtrC8 CRandomServer::GetRandom(void)
+	{
+	TPtr8 res(&iPool[iPoolOut],iHash->HashSize(),iHash->HashSize());
+	iPoolOut+=iHash->HashSize();
+	if ((iPoolOut+iHash->HashSize())>KRandomPoolSize)
+		{
+		iPoolOut=0;
+		}
+	return iHash->Hash(res);
+	}
+
+CMessageDigest* CRandomServer::Hash(void) const
+	{
+	return iHash;
+	}
+
+void CRandomServer::Stir(void) 
+	{
+	TInt rnd;
+	rnd=Math::Random();
+	TPtrC8 r((TUint8*)&rnd,sizeof(TInt));
+	iHash->Hash(r);
+	TPtr8 dest(&iPool[iPoolIn],iHash->HashSize());
+	dest.Copy(iHash->Hash(dest));
+	iPoolIn+=iHash->HashSize();
+	if ((iPoolIn+iHash->HashSize())>KRandomPoolSize)
+		{
+		iPoolIn=0;
+		}
+	}
+
+CRandomSession* CRandomSession::NewL(CRandomServer* aServer)
+	{
+	CRandomSession* self;
+	self=new (ELeave) CRandomSession(aServer);
+	return self;
+	}
+
+CRandomSession::CRandomSession(CRandomServer* aServer) : CSession2(), iServer(aServer)
+	{
+	}
+
+CRandomSession::~CRandomSession(void)
+	{
+	}
+
+void CRandomSession::ServiceL(const RMessage2& aMessage)
+	{
+	switch (aMessage.Function())
+		{
+	case KRandomRequest:
+		{
+		TInt ret = FillBuffer(aMessage);
+		aMessage.Complete(ret);
+		break;
+		}
+	default:
+		aMessage.Complete(KErrNotSupported);
+		break;
+		};
+	}
+
+TInt CRandomSession::FillBuffer(const RMessage2& aMessage)
+	{
+	TInt length = aMessage.Int1();
+	iServer->iQuality -= length;
+	if (iServer->iQuality<0)
+		{
+		iServer->iQuality=0;
+		}
+	if (!iServer->iFast)
+		{
+		if (iServer->iQuality<KThreshold)
+			{
+			TCallBack callback(CRandomServer::Tick,iServer);
+			iServer->iTicker->Cancel();
+			iServer->iTicker->Start(KFastTickTimer,KFastTickTimer,callback);		// **** these figures might need tweaking!
+			iServer->iFast=ETrue;
+			}
+		}
+	TBuf8<KRandomBlockSize> buf(0);
+	iServer->Stir();
+	TInt i;
+	TInt hashsize=iServer->Hash()->HashSize();
+	for (i=0; i+hashsize < length; i+=hashsize)
+		{
+		buf.Append(iServer->GetRandom());
+		iServer->Stir();
+		}
+	TPtrC8 ptr(iServer->GetRandom().Ptr(), length-i);
+	buf.Append(ptr);
+	
+	TRAPD(ret, aMessage.WriteL(0, buf));
+	return ret;
+	}
+
+GLDEF_C TInt E32Main(void)
+	{
+	return RunRandomServer(NULL);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/sha1impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,743 @@
+/*
+* Copyright (c) 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: 
+* software sha1 implementation
+* software sha1 implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "sha1impl.h"
+
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+#define EXPANDLOOP
+
+
+using namespace SoftwareCrypto;
+	
+CSHA1Impl* CSHA1Impl::NewL()
+	{
+	CSHA1Impl* self=new (ELeave) CSHA1Impl();
+	self->Reset();
+	return self;						
+	}
+												
+CSHA1Impl::CSHA1Impl() : iHash(KSHA1HashSize)
+	{		
+	}
+
+void CSHA1Impl::Reset()
+	{
+	iA=0x67452301;
+	iB=0xefcdab89;
+	iC=0x98badcfe;
+	iD=0x10325476;
+	iE=0xc3d2e1f0;
+	iNh=0;
+	iNl=0;
+	}
+	
+TUid CSHA1Impl::ImplementationUid()
+	{
+	return KCryptoPluginSha1Uid;
+	}
+
+void CSHA1Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+	for (TInt i=0;i<hashNum;i++)
+		{
+		if (KHashCharacteristics[i]->cmn.iImplementationUID == ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KHashCharacteristics[i];
+			break;
+			}
+		}	
+	}
+
+TPtrC8 CSHA1Impl::Hash(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	DoUpdate(aMessage.Ptr(),aMessage.Size());
+	StoreState();
+	DoFinal();
+	ptr.Set(iHash);
+	RestoreState();
+	return ptr;
+	}
+
+// This assumes a big-endian architecture
+void CSHA1Impl::DoUpdate(const TUint8* aData,TUint aLength)
+	{
+	while((aLength / 4) > 0 && (iNl % 4 == 0))
+		{
+		iData[iNl>>2] = aData[0] << 24 | aData[1] << 16 | aData[2] << 8 | aData[3];
+		iNl+=4;
+		aData+=4;
+		aLength-=4;
+		if(iNl==64) 
+			{
+			Block();
+			iNh+=64;
+			iNl=0;
+			}
+		}
+
+	while(aLength--)
+		{
+		switch (iNl&3) 
+			{
+			case 0:
+				iData[iNl>>2]=((TUint)(*aData))<<24;
+				break;
+			case 1:
+				iData[iNl>>2]|=((TUint)(*aData))<<16;
+				break;
+			case 2:
+				iData[iNl>>2]|=((TUint)(*aData))<<8;
+				break;
+			case 3:
+				iData[iNl>>2]|=((TUint)(*aData));
+				break;
+			default:
+				break;
+			};
+			aData++;
+			iNl++;
+			if(iNl==64) 
+				{
+				Block();
+				iNh+=64;
+				iNl=0;
+				}
+		}
+	}
+
+static inline TUint CSHA1_F(const TUint x,const TUint y,const TUint z)
+	{
+	return (x&y) | (~x&z);
+	}
+
+static inline TUint CSHA1_G(const TUint x,const TUint y,const TUint z)
+	{
+	return x^y^z;
+	}
+
+static inline TUint CSHA1_H(const TUint x,const TUint y,const TUint z)
+	{
+	return (x&y) | (x&z) | (y&z);
+	}
+
+/*static inline TUint CSHA1_I(const TUint x,const TUint y,const TUint z)
+	{
+	return x^y^z;
+	}*/
+
+#ifdef EXPANDLOOP
+
+#ifdef MACRO
+
+#define CSHA1_16(x,y,z,u,t,v,w)					v=CMD_R(x,5)+CSHA1_F(y,z,u)+t+w+0x5a827999;\
+												y=CMD_R(y,30);t=v;
+#define CSHA1_20(x,y,z,u,t,v,w0,w3,w8,w14,w16)  v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												CSHA1_16(x,y,z,u,t,v,w0);
+#define CSHA1_40(x,y,z,u,t,v,w0,w3,w8,w14,w16)	v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												v=CMD_R(x,5)+CSHA1_G(y,z,u)+t+w0+0x6ed9eba1;\
+												y=CMD_R(y,30);t=v;
+#define CSHA1_60(x,y,z,u,t,v,w0,w3,w8,w14,w16)	v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												v=CMD_R(x,5)+CSHA1_H(y,z,u)+t+w0+0x8f1bbcdc;\
+												y=CMD_R(y,30);t=v;
+#define CSHA1_80(x,y,z,u,t,v,w0,w3,w8,w14,w16)	v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												v=CMD_R(x,5)+CSHA1_G(y,z,u)+t+w0+0xca62c1d6;\
+												y=CMD_R(y,30);t=v;
+#else
+
+static inline void CSHA1_16(const TUint x, TUint& y, const TUint z,
+							const TUint u, TUint& t, TUint& v, const TUint w)
+	{
+	v = CMD_R(x,5) + CSHA1_F(y,z,u) + t + w + 0x5a827999;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+static inline void CSHA1_20(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	CSHA1_16(x,y,z,u,t,v,w0);
+	}
+
+static inline void CSHA1_40(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	v = CMD_R(x,5) + CSHA1_G(y,z,u) + t + w0 + 0x6ed9eba1;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+static inline void CSHA1_60(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	v = CMD_R(x,5) + CSHA1_H(y,z,u) + t + w0 + 0x8f1bbcdc;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+static inline void CSHA1_80(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	v = CMD_R(x,5) + CSHA1_G(y,z,u) + t + w0 + 0xca62c1d6;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+#endif // MACRO
+#endif // EXPANDLOOP
+
+#ifdef WEIDAI
+
+template <class T> inline T rotlFixed(T x, unsigned int y)
+{
+	ASSERT(y < sizeof(T)*8);
+	return (x<<y) | (x>>(sizeof(T)*8-y));
+}
+
+template<> inline TUint32 rotlFixed<TUint32>(TUint32 x, unsigned int y)
+{
+	ASSERT(y < 32);
+	return y ? CMD_R(x, y) : x;
+}
+
+#define blk0(i) (W[i] = iData[i])
+#define blk1(i) (W[i&15] = rotlFixed(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15],1))
+
+#define f1(x,y,z) (z^(x&(y^z)))
+#define f2(x,y,z) (x^y^z)
+#define f3(x,y,z) ((x&y)|(z&(x|y)))
+#define f4(x,y,z) (x^y^z)
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=f1(w,x,y)+blk0(i)+0x5A827999+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R1(v,w,x,y,z,i) z+=f1(w,x,y)+blk1(i)+0x5A827999+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R2(v,w,x,y,z,i) z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R3(v,w,x,y,z,i) z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R4(v,w,x,y,z,i) z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rotlFixed(v,5);w=rotlFixed(w,30);
+
+#endif // WEIDAI
+
+void CSHA1Impl::Block()
+	{
+#ifdef WEIDAI
+	TUint32 W[16];
+    /* Copy context->state[] to working vars */
+    TUint32 a = iA;
+    TUint32 b = iB;
+    TUint32 c = iC;
+    TUint32 d = iD;
+    TUint32 e = iE;
+    
+	/* 4 rounds of 20 operations each. Loop unrolled. */
+    
+	R0(a,b,c,d,e, 0); 
+	R0(e,a,b,c,d, 1); 
+	R0(d,e,a,b,c, 2); 
+	R0(c,d,e,a,b, 3);
+    R0(b,c,d,e,a, 4); 
+	R0(a,b,c,d,e, 5); 
+	R0(e,a,b,c,d, 6); 
+	R0(d,e,a,b,c, 7);
+    R0(c,d,e,a,b, 8); 
+	R0(b,c,d,e,a, 9); 
+	R0(a,b,c,d,e,10); 
+	R0(e,a,b,c,d,11);
+    R0(d,e,a,b,c,12); 
+	R0(c,d,e,a,b,13); 
+	R0(b,c,d,e,a,14); 
+	R0(a,b,c,d,e,15);
+
+    R1(e,a,b,c,d,16); 
+	R1(d,e,a,b,c,17); 
+	R1(c,d,e,a,b,18); 
+	R1(b,c,d,e,a,19);
+
+    R2(a,b,c,d,e,20); 
+	R2(e,a,b,c,d,21); 
+	R2(d,e,a,b,c,22); 
+	R2(c,d,e,a,b,23);
+    R2(b,c,d,e,a,24); 
+	R2(a,b,c,d,e,25); 
+	R2(e,a,b,c,d,26); 
+	R2(d,e,a,b,c,27);
+    R2(c,d,e,a,b,28); 
+	R2(b,c,d,e,a,29); 
+	R2(a,b,c,d,e,30); 
+	R2(e,a,b,c,d,31);
+    R2(d,e,a,b,c,32); 
+	R2(c,d,e,a,b,33); 
+	R2(b,c,d,e,a,34); 
+	R2(a,b,c,d,e,35);
+    R2(e,a,b,c,d,36); 
+	R2(d,e,a,b,c,37); 
+	R2(c,d,e,a,b,38); 
+	R2(b,c,d,e,a,39);
+
+    R3(a,b,c,d,e,40); 
+	R3(e,a,b,c,d,41); 
+	R3(d,e,a,b,c,42); 
+	R3(c,d,e,a,b,43);
+    R3(b,c,d,e,a,44); 
+	R3(a,b,c,d,e,45); 
+	R3(e,a,b,c,d,46); 
+	R3(d,e,a,b,c,47);
+    R3(c,d,e,a,b,48); 
+	R3(b,c,d,e,a,49); 
+	R3(a,b,c,d,e,50); 
+	R3(e,a,b,c,d,51);
+    R3(d,e,a,b,c,52); 
+	R3(c,d,e,a,b,53); 
+	R3(b,c,d,e,a,54); 
+	R3(a,b,c,d,e,55);
+    R3(e,a,b,c,d,56); 
+	R3(d,e,a,b,c,57); 
+	R3(c,d,e,a,b,58); 
+	R3(b,c,d,e,a,59);
+
+    R4(a,b,c,d,e,60); 
+	R4(e,a,b,c,d,61); 
+	R4(d,e,a,b,c,62); 
+	R4(c,d,e,a,b,63);
+    R4(b,c,d,e,a,64); 
+	R4(a,b,c,d,e,65); 
+	R4(e,a,b,c,d,66); 
+	R4(d,e,a,b,c,67);
+    R4(c,d,e,a,b,68); 
+	R4(b,c,d,e,a,69); 
+	R4(a,b,c,d,e,70); 
+	R4(e,a,b,c,d,71);
+    R4(d,e,a,b,c,72); 
+	R4(c,d,e,a,b,73); 
+	R4(b,c,d,e,a,74); 
+	R4(a,b,c,d,e,75);
+    R4(e,a,b,c,d,76); 
+	R4(d,e,a,b,c,77); 
+	R4(c,d,e,a,b,78); 
+	R4(b,c,d,e,a,79);
+    
+	/* Add the working vars back into context.state[] */
+    iA += a;
+    iB += b;
+    iC += c;
+    iD += d;
+    iE += e;
+    /* Wipe variables */
+    a = b = c = d = e = 0;
+	Mem::FillZ(W, sizeof(W));
+#else
+	TUint tempA=iA;
+	TUint tempB=iB;
+	TUint tempC=iC;
+	TUint tempD=iD;
+	TUint tempE=iE;
+	TUint temp=0;
+
+#ifdef EXPANDLOOP
+	CSHA1_16(tempA,tempB,tempC,tempD,tempE,temp,iData[0]);
+	CSHA1_16(temp,tempA,tempB,tempC,tempD,tempE,iData[1]);
+	CSHA1_16(tempE,temp,tempA,tempB,tempC,tempD,iData[2]);
+	CSHA1_16(tempD,tempE,temp,tempA,tempB,tempC,iData[3]);
+	CSHA1_16(tempC,tempD,tempE,temp,tempA,tempB,iData[4]);
+	CSHA1_16(tempB,tempC,tempD,tempE,temp,tempA,iData[5]);
+	CSHA1_16(tempA,tempB,tempC,tempD,tempE,temp,iData[6]);
+	CSHA1_16(temp,tempA,tempB,tempC,tempD,tempE,iData[7]);
+	CSHA1_16(tempE,temp,tempA,tempB,tempC,tempD,iData[8]);
+	CSHA1_16(tempD,tempE,temp,tempA,tempB,tempC,iData[9]);
+	CSHA1_16(tempC,tempD,tempE,temp,tempA,tempB,iData[10]);
+	CSHA1_16(tempB,tempC,tempD,tempE,temp,tempA,iData[11]);
+	CSHA1_16(tempA,tempB,tempC,tempD,tempE,temp,iData[12]);
+	CSHA1_16(temp,tempA,tempB,tempC,tempD,tempE,iData[13]);
+	CSHA1_16(tempE,temp,tempA,tempB,tempC,tempD,iData[14]);
+	CSHA1_16(tempD,tempE,temp,tempA,tempB,tempC,iData[15]);
+	/*
+	i = 16;
+	TUint temp1 = tempA;
+	tempA = 
+	*/
+#else
+    TUint i=0;
+	while (i<16) 
+		{
+		temp = CMD_R(tempA,5) + CSHA1_F(tempB,tempC,tempD) + tempE + iData[i++] + 0x5a827999;
+		tempE = tempD;
+		tempD = tempC;
+		tempC = CMD_R(tempB,30);
+		tempB = tempA;
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_20(tempC,tempD,tempE,temp,tempA,tempB,iData[16],iData[13],iData[8],iData[2],iData[0]);
+	CSHA1_20(tempB,tempC,tempD,tempE,temp,tempA,iData[17],iData[14],iData[9],iData[3],iData[1]);
+	CSHA1_20(tempA,tempB,tempC,tempD,tempE,temp,iData[18],iData[15],iData[10],iData[4],iData[2]);
+	CSHA1_20(temp,tempA,tempB,tempC,tempD,tempE,iData[19],iData[16],iData[11],iData[5],iData[3]);
+	//i = 20;
+#else
+	while (i<20) 
+		{
+		temp=iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i]=CMD_R(temp,1);
+		temp = CMD_R(tempA,5) + CSHA1_F(tempB,tempC,tempD) + tempE + iData[i++] + 0x5a827999; 
+		tempE = tempD;
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[20],iData[17],iData[12],iData[6],iData[4]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[21],iData[18],iData[13],iData[7],iData[5]);
+	CSHA1_40(tempC,tempD,tempE,temp,tempA,tempB,iData[22],iData[19],iData[14],iData[8],iData[6]);
+	CSHA1_40(tempB,tempC,tempD,tempE,temp,tempA,iData[23],iData[20],iData[15],iData[9],iData[7]);
+	CSHA1_40(tempA,tempB,tempC,tempD,tempE,temp,iData[24],iData[21],iData[16],iData[10],iData[8]);
+	CSHA1_40(temp,tempA,tempB,tempC,tempD,tempE,iData[25],iData[22],iData[17],iData[11],iData[9]);
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[26],iData[23],iData[18],iData[12],iData[10]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[27],iData[24],iData[19],iData[13],iData[11]);
+	CSHA1_40(tempC,tempD,tempE,temp,tempA,tempB,iData[28],iData[25],iData[20],iData[14],iData[12]);
+	CSHA1_40(tempB,tempC,tempD,tempE,temp,tempA,iData[29],iData[26],iData[21],iData[15],iData[13]);
+	CSHA1_40(tempA,tempB,tempC,tempD,tempE,temp,iData[30],iData[27],iData[22],iData[16],iData[14]);
+	CSHA1_40(temp,tempA,tempB,tempC,tempD,tempE,iData[31],iData[28],iData[23],iData[17],iData[15]);
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[32],iData[29],iData[24],iData[18],iData[16]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[33],iData[30],iData[25],iData[19],iData[17]);
+	CSHA1_40(tempC,tempD,tempE,temp,tempA,tempB,iData[34],iData[31],iData[26],iData[20],iData[18]);
+	CSHA1_40(tempB,tempC,tempD,tempE,temp,tempA,iData[35],iData[32],iData[27],iData[21],iData[19]);
+	CSHA1_40(tempA,tempB,tempC,tempD,tempE,temp,iData[36],iData[33],iData[28],iData[22],iData[20]);
+	CSHA1_40(temp,tempA,tempB,tempC,tempD,tempE,iData[37],iData[34],iData[29],iData[23],iData[21]);
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[38],iData[35],iData[30],iData[24],iData[22]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[39],iData[36],iData[31],iData[25],iData[23]);
+	//i = 40;
+#else
+	while (i<40) 
+		{
+		temp = iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i] = CMD_R(temp,1);
+
+		temp = CMD_R(tempA,5) + CSHA1_G(tempB,tempC,tempD) + tempE + iData[i++] + 0x6ed9eba1; 
+		tempE = tempD; 
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[40],iData[37],iData[32],iData[26],iData[24]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[41],iData[38],iData[33],iData[27],iData[25]);
+	CSHA1_60(tempA,tempB,tempC,tempD,tempE,temp,iData[42],iData[39],iData[34],iData[28],iData[26]);
+	CSHA1_60(temp,tempA,tempB,tempC,tempD,tempE,iData[43],iData[40],iData[35],iData[29],iData[27]);
+	CSHA1_60(tempE,temp,tempA,tempB,tempC,tempD,iData[44],iData[41],iData[36],iData[30],iData[28]);
+	CSHA1_60(tempD,tempE,temp,tempA,tempB,tempC,iData[45],iData[42],iData[37],iData[31],iData[29]);
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[46],iData[43],iData[38],iData[32],iData[30]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[47],iData[44],iData[39],iData[33],iData[31]);
+	CSHA1_60(tempA,tempB,tempC,tempD,tempE,temp,iData[48],iData[45],iData[40],iData[34],iData[32]);
+	CSHA1_60(temp,tempA,tempB,tempC,tempD,tempE,iData[49],iData[46],iData[41],iData[35],iData[33]);
+	CSHA1_60(tempE,temp,tempA,tempB,tempC,tempD,iData[50],iData[47],iData[42],iData[36],iData[34]);
+	CSHA1_60(tempD,tempE,temp,tempA,tempB,tempC,iData[51],iData[48],iData[43],iData[37],iData[35]);
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[52],iData[49],iData[44],iData[38],iData[36]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[53],iData[50],iData[45],iData[39],iData[37]);
+	CSHA1_60(tempA,tempB,tempC,tempD,tempE,temp,iData[54],iData[51],iData[46],iData[40],iData[38]);
+	CSHA1_60(temp,tempA,tempB,tempC,tempD,tempE,iData[55],iData[52],iData[47],iData[41],iData[39]);
+	CSHA1_60(tempE,temp,tempA,tempB,tempC,tempD,iData[56],iData[53],iData[48],iData[42],iData[40]);
+	CSHA1_60(tempD,tempE,temp,tempA,tempB,tempC,iData[57],iData[54],iData[49],iData[43],iData[41]);
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[58],iData[55],iData[50],iData[44],iData[42]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[59],iData[56],iData[51],iData[45],iData[43]);
+	//i = 60;
+#else
+	while (i<60) 
+		{
+		temp = iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i] = CMD_R(temp,1);
+
+		temp = CMD_R(tempA,5) + CSHA1_H(tempB,tempC,tempD) + tempE + iData[i++] + 0x8f1bbcdc; 
+		tempE = tempD; 
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[60],iData[57],iData[52],iData[46],iData[44]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[61],iData[58],iData[53],iData[47],iData[45]);
+	CSHA1_80(tempE,temp,tempA,tempB,tempC,tempD,iData[62],iData[59],iData[54],iData[48],iData[46]);
+	CSHA1_80(tempD,tempE,temp,tempA,tempB,tempC,iData[63],iData[60],iData[55],iData[49],iData[47]);
+	CSHA1_80(tempC,tempD,tempE,temp,tempA,tempB,iData[64],iData[61],iData[56],iData[50],iData[48]);
+	CSHA1_80(tempB,tempC,tempD,tempE,temp,tempA,iData[65],iData[62],iData[57],iData[51],iData[49]);
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[66],iData[63],iData[58],iData[52],iData[50]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[67],iData[64],iData[59],iData[53],iData[51]);
+	CSHA1_80(tempE,temp,tempA,tempB,tempC,tempD,iData[68],iData[65],iData[60],iData[54],iData[52]);
+	CSHA1_80(tempD,tempE,temp,tempA,tempB,tempC,iData[69],iData[66],iData[61],iData[55],iData[53]);
+	CSHA1_80(tempC,tempD,tempE,temp,tempA,tempB,iData[70],iData[67],iData[62],iData[56],iData[54]);
+	CSHA1_80(tempB,tempC,tempD,tempE,temp,tempA,iData[71],iData[68],iData[63],iData[57],iData[55]);
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[72],iData[69],iData[64],iData[58],iData[56]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[73],iData[70],iData[65],iData[59],iData[57]);
+	CSHA1_80(tempE,temp,tempA,tempB,tempC,tempD,iData[74],iData[71],iData[66],iData[60],iData[58]);
+	CSHA1_80(tempD,tempE,temp,tempA,tempB,tempC,iData[75],iData[72],iData[67],iData[61],iData[59]);
+	CSHA1_80(tempC,tempD,tempE,temp,tempA,tempB,iData[76],iData[73],iData[68],iData[62],iData[60]);
+	CSHA1_80(tempB,tempC,tempD,tempE,temp,tempA,iData[77],iData[74],iData[69],iData[63],iData[61]);
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[78],iData[75],iData[70],iData[64],iData[62]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[79],iData[76],iData[71],iData[65],iData[63]);
+#else
+	const TUint total=KSHA1BlockSize*5; // 16 * 5 = 80
+	while (i<total) 
+		{
+		temp = iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i] = CMD_R(temp,1);
+
+		temp = CMD_R(tempA,5) + CSHA1_I(tempB,tempC,tempD) + tempE + iData[i++] + 0xca62c1d6; 
+		tempE = tempD; 
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	iA+=tempE;
+	iB+=temp;
+	iC+=tempA;
+	iD+=tempB;
+	iE+=tempC;
+#else
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	iE+=tempE;
+#endif // EXPANDLOOP
+#endif // WEIDAI
+	}
+
+void CSHA1Impl::DoFinal()
+	{
+	iNh += iNl;
+	const TUint ul128=128;
+	switch (iNl&3) 
+		{
+		case 0:
+			iData[iNl>>2] = ul128<<24;
+			break;
+		case 1:
+			iData[iNl>>2] += ul128<<16;
+			break;
+		case 2:
+			iData[iNl>>2] += ul128<<8;
+			break;
+		case 3:
+			iData[iNl>>2] += ul128;
+			break;
+		default:
+			break;
+		};
+	if (iNl>=56) 
+		{
+		if (iNl<60)
+			iData[15]=0;		
+		Block();
+		Mem::FillZ(iData,14*sizeof(TUint));
+		} 
+	else
+		{
+		const TUint offset=(iNl+4)>>2; //+4 to account for the word added in the
+		//switch statement above
+		Mem::FillZ(iData+offset,(14-offset)*sizeof(TUint));
+		}
+
+	// this will fail if the total input length is longer than 2^32 in bits
+	//(2^31 in bytes) which is roughly half a gig.
+	iData[14]=0;
+	iData[15]=iNh<<3;//number in bits
+	Block();
+	//
+	// Generate hash value into iHash
+	//
+	TUint tmp=iA;
+	iHash[3]=(TUint8)(tmp & 255);
+	iHash[2]=(TUint8)((tmp >>= 8) & 255);
+	iHash[1]=(TUint8)((tmp >>= 8) & 255);
+	iHash[0]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iB;
+	iHash[7]=(TUint8)(tmp & 255);
+	iHash[6]=(TUint8)((tmp >>= 8) & 255);
+	iHash[5]=(TUint8)((tmp >>= 8) & 255);
+	iHash[4]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iC;
+	iHash[11]=(TUint8)(tmp & 255);
+	iHash[10]=(TUint8)((tmp >>= 8) & 255);
+	iHash[9]=(TUint8)((tmp >>= 8) & 255);
+	iHash[8]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iD;
+	iHash[15]=(TUint8)(tmp & 255);
+	iHash[14]=(TUint8)((tmp >>= 8) & 255);
+	iHash[13]=(TUint8)((tmp >>= 8) & 255);
+	iHash[12]=(TUint8)((tmp >>= 8) & 255);
+	
+	tmp=iE;
+	iHash[19]=(TUint8)(tmp & 255);
+	iHash[18]=(TUint8)((tmp >>= 8) & 255);
+	iHash[17]=(TUint8)((tmp >>= 8) & 255);
+	iHash[16]=(TUint8)((tmp >>= 8) & 255);
+	}
+
+void CSHA1Impl::RestoreState()
+	{
+	iA = iACopy;
+	iB = iBCopy;
+	iC = iCCopy;
+	iD = iDCopy;
+	iE = iECopy;
+	iNl = iNlCopy;
+	iNh = iNhCopy;	
+	Mem::Copy(&iData[0], &iDataCopy[0], KSHA1BlockSize*5*sizeof(TUint)); 
+	}
+
+void CSHA1Impl::StoreState()
+	{
+	iACopy = iA;
+	iBCopy = iB;
+	iCCopy = iC;
+	iDCopy = iD;
+	iECopy = iE;
+	iNlCopy = iNl;
+	iNhCopy = iNh;	
+	Mem::Copy(&iDataCopy[0], &iData[0], KSHA1BlockSize*5*sizeof(TUint));
+	}
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void CSHA1Impl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CSHA1Impl::SetKeyL(const CKey& /*aKey*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+TAny* CSHA1Impl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+
+CExtendedCharacteristics* CSHA1Impl::CreateExtendedCharacteristicsL()
+	{
+	// Not supported
+	return NULL;
+	}
+
+// The following methods are kept for compatibility but are not used by 
+// randsvr.exe (via SHA1Shim). So, Turn off coverage for these.
+MHash* CSHA1Impl::ReplicateL()
+	{	 
+	return CSHA1Impl::NewL();
+	}
+	
+MHash* CSHA1Impl::CopyL()
+	{
+	return new(ELeave) CSHA1Impl(*this);	
+	}
+
+void CSHA1Impl::Update(const TDesC8& aMessage)
+	{
+	DoUpdate(aMessage.Ptr(),aMessage.Size());	
+	}
+	
+TPtrC8 CSHA1Impl::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdate(aMessage.Ptr(),aMessage.Size());			
+		}
+	DoFinal();
+	ptr.Set(iHash);
+	Reset();
+	return ptr;
+	}
+
+// Since CreateExtendedCharacteristicsL is not supported, the method which using it also can not be supported.
+const CExtendedCharacteristics* CSHA1Impl::GetExtendedCharacteristicsL()
+	{
+	return CSHA1Impl::CreateExtendedCharacteristicsL();
+	}
+
+// These methods can only be covered from SHA1Shim, but not get covered because the 
+// SHA1Shim not get destroyed anywhere(may be a long runing service). So, these are excluded.
+CSHA1Impl::CSHA1Impl(const CSHA1Impl& aSHA1Impl)
+	: iHash(aSHA1Impl.iHash),iA(aSHA1Impl.iA),iB(aSHA1Impl.iB),iC(aSHA1Impl.iC),iD(aSHA1Impl.iD),iE(aSHA1Impl.iE),
+	iNl(aSHA1Impl.iNl),iNh(aSHA1Impl.iNh)
+	{
+	(void)Mem::Copy(iData, aSHA1Impl.iData, KSHA1BlockSize*5);
+	}
+
+CSHA1Impl* CSHA1Impl::NewLC()
+	{
+	CSHA1Impl* self=NewL();
+	CleanupStack::PushL(self);
+	return self;						
+	}
+
+void CSHA1Impl::Close()
+	{
+	delete this;	
+	}
+
+CSHA1Impl::~CSHA1Impl()
+	{	
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/sha1shim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,151 @@
+/*
+* Copyright (c) 2006-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: 
+* hashshim.cpp
+* hash shim implementation
+* hash shim implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "sha1shim.h"
+#include "sha1impl.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+
+
+using namespace CryptoSpi;
+using namespace SoftwareCrypto;
+
+//
+// Implementation of SHA1 shim
+//	
+	
+CSHA1Shim* CSHA1Shim::NewL()
+	{
+	CSHA1Shim* self=CSHA1Shim::NewLC();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CSHA1Shim* CSHA1Shim::NewLC()
+	{
+	CSHA1Shim* self=new(ELeave) CSHA1Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+CSHA1Shim::CSHA1Shim()
+	{
+	}
+	
+CSHA1Shim::~CSHA1Shim()
+	{
+	iHashImpl->Close();
+	}
+
+void CSHA1Shim::ConstructL()
+	{
+	iHashImpl=CSHA1Impl::NewL();
+	}
+
+TInt CSHA1Shim::HashSize()
+	{
+	const TCharacteristics* ptr(NULL);
+	TRAPD(err, iHashImpl->GetCharacteristicsL(ptr);)
+	if (err)
+		{
+		return err;
+		}
+	const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	return hashPtr->iOutputSize/8;
+	}
+
+TPtrC8 CSHA1Shim::Hash(const TDesC8& aMessage)
+	{
+	return iHashImpl->Hash(aMessage);
+	}
+
+// The following methods are kept for linkage compatibility
+// but are not used by randsvr.exe. Turn off coverage for these
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void CSHA1Shim::Reset()
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	}
+
+void CSHA1Shim::RestoreState()
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	}
+
+void CSHA1Shim::StoreState()
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	}
+
+CMessageDigest* CSHA1Shim::CopyL()
+	{
+	// Provide a stub for compatibility; not used in random server
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+CMessageDigest* CSHA1Shim::ReplicateL()
+	{
+	// Provide a stub for compatibility; not used in random server
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+TInt CSHA1Shim::BlockSize()
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	return 0;
+	}
+
+TPtrC8 CSHA1Shim::Final(const TDesC8& /*aMessage*/)
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	return NULL;
+	}
+
+TPtrC8 CSHA1Shim::Final()
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	return NULL;
+	}
+
+void CSHA1Shim::Update(const TDesC8& /*aMessage*/)
+	{
+	// Provide a stub for compatibility; not used in random server
+	ASSERT(EFalse);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/sha1shim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,65 @@
+/*
+* Copyright (c) 2006-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: 
+* hashshim.h
+* hash shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __HASHSHIM_H__
+#define __HASHSHIM_H__
+
+#include <e32def.h>
+#include <hash.h>
+#include <cryptospi/cryptohashapi.h>
+#include "sha1impl.h"
+
+//
+// SHA1 shim class
+//
+
+NONSHARABLE_CLASS(CSHA1Shim) : public CMessageDigest
+	{
+public:
+	static CSHA1Shim* NewL();
+	static CSHA1Shim* NewLC();
+	~CSHA1Shim();
+	CMessageDigest* CopyL();
+	TInt BlockSize();
+	TInt HashSize()	;
+	void Update(const TDesC8& aMessage);
+	TPtrC8 Final(const TDesC8& aMessage);
+	TPtrC8 Final();
+	void Reset();
+	TPtrC8 Hash(const TDesC8& aMessage);
+	CMessageDigest* ReplicateL();
+	void RestoreState();
+	void StoreState();
+	
+private:	
+	CSHA1Shim();
+	void ConstructL();
+	
+private:
+	SoftwareCrypto::CSHA1Impl* iHashImpl;
+	};
+
+#endif
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/random/threadrandom.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,67 @@
+/*
+* Copyright (c) 2003-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 <random.h>
+#include <e32debug.h>
+#include "randomshim.h"
+
+_LIT(KThreadRandom, "threadrandom.cpp");
+
+EXPORT_C void SetThreadRandomL(CRandom* aRNG)
+	{
+	User::LeaveIfError(Dll::SetTls(aRNG));	
+	}
+
+EXPORT_C void SetThreadRandomLC(CRandom* aRNG)
+	{
+	CleanupStack::PushL(aRNG);
+	SetThreadRandomL(aRNG);
+	//This pop before the push isn't a problem as the PushL can't fail. 
+	//We just did a push before this and thus there is enough room on the
+	//cleanupstack such that OOM is not possible.
+	CleanupStack::Pop(aRNG);
+	CleanupStack::PushL(TCleanupItem(&DeleteThreadRandom, Dll::Tls()));
+	}
+
+void DeleteThreadRandom(TAny* aPtr)
+	{
+	CRandom* random = reinterpret_cast<CRandom*>(aPtr);
+	delete random;
+	TInt result = Dll::SetTls(0);
+	__ASSERT_ALWAYS(result == 0, User::Panic(KThreadRandom, 1));
+	}
+
+EXPORT_C void DestroyThreadRandom(void)
+	{
+	delete (CRandom*)(Dll::Tls());
+	TInt result = Dll::SetTls(0);
+	__ASSERT_ALWAYS(result == 0, User::Panic(KThreadRandom, 1));
+	}
+
+EXPORT_C void GenerateRandomBytesL(TDes8& aDest)
+	{
+	TAny* tls = Dll::Tls();
+	if(tls)
+		{
+		((CRandom*)tls)->GenerateBytesL(aDest);
+		}
+	else
+		{
+		TRandomShim::RandomL(aDest);
+		}
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/3des.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,106 @@
+/*
+* Copyright (c) 2002-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 "3des.h"
+#include "3desshim.h"
+
+const TInt K3DESBlockBytes = 8;
+const TInt K3DESKeyBytes = 24;
+
+C3DES::C3DES()
+	{
+	}
+
+/* C3DESEncryptor */
+EXPORT_C C3DESEncryptor* C3DESEncryptor::NewL(const TDesC8& aKey)
+	{
+	return C3DESEncryptorShim::NewL(aKey);
+	}
+
+EXPORT_C C3DESEncryptor* C3DESEncryptor::NewLC(const TDesC8& aKey)
+	{
+	return C3DESEncryptorShim::NewLC(aKey);
+	}
+
+/* C3DESDecryptor */
+EXPORT_C C3DESDecryptor* C3DESDecryptor::NewL(const TDesC8& aKey)
+	{
+	return C3DESDecryptorShim::NewL(aKey);
+	}
+
+EXPORT_C C3DESDecryptor* C3DESDecryptor::NewLC(const TDesC8& aKey)
+	{
+	return C3DESDecryptorShim::NewLC(aKey);
+	}
+	
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void C3DES::Transform(TDes8& /*aBlock*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);		
+	}
+	
+void C3DES::Reset()
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	}
+	
+TInt C3DES::BlockSize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);
+	return K3DESBlockBytes;			
+	}	
+
+TInt C3DES::KeySize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);
+	return K3DESKeyBytes;		
+	}
+	
+void C3DES::DoSetKey(const TDesC8& /*aKey*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);				
+	}
+	
+void C3DES::ConstructL(const TDesC8& /*aKey*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	}	
+
+void C3DESEncryptor::DoSetKey(const TDesC8& /*aKey*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);				
+	}	
+
+void C3DESDecryptor::DoSetKey(const TDesC8& /*aKey*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);				
+	}		
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/3desshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,191 @@
+/*
+* Copyright (c) 2006-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 "3desshim.h"
+
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "keys.h"
+#include <cryptostrength.h>
+#include "../common/inlines.h"
+
+using namespace CryptoSpi;
+
+// C3DESEncryptorShim ////////////////////////////////////////////////////////
+C3DESEncryptorShim* C3DESEncryptorShim::NewL(const TDesC8& aKey)
+	{
+	C3DESEncryptorShim* self = C3DESEncryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+C3DESEncryptorShim* C3DESEncryptorShim::NewLC(const TDesC8& aKey)
+	{
+	C3DESEncryptorShim* self = new (ELeave) C3DESEncryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	// DES only used 7 bits out of every key byte
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()) - aKey.Size());
+	return self;
+	}
+
+C3DESEncryptorShim::C3DESEncryptorShim()
+	{
+	}
+
+C3DESEncryptorShim::~C3DESEncryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;
+	}	
+
+void C3DESEncryptorShim::ConstructL(const TDesC8& aKey)
+	{
+	TKeyProperty keyProperty = {K3DesUid, KNullUid, KSymmetricKey, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+											iSymmetricCipherImpl,
+											K3DesUid,
+											*iKey,
+											KCryptoModeEncryptUid,
+											KOperationModeECBUid,
+											KPaddingModeNoneUid,
+											NULL);
+	}		
+
+TInt C3DESEncryptorShim::BlockSize() const
+	{
+	// SPI returns block size in BITS
+	return iSymmetricCipherImpl->BlockSize() >> 3;
+	}	
+
+TInt C3DESEncryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void C3DESEncryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;
+	}
+
+void C3DESEncryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}	
+
+TInt C3DESEncryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}	
+
+// C3DESDecryptorShim ////////////////////////////////////////////////////////
+C3DESDecryptorShim* C3DESDecryptorShim::NewL(const TDesC8& aKey)
+	{
+	C3DESDecryptorShim* self = C3DESDecryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+C3DESDecryptorShim* C3DESDecryptorShim::NewLC(const TDesC8& aKey)
+	{
+	C3DESDecryptorShim* self = new (ELeave) C3DESDecryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	// DES only used 7 bits out of every key byte
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()) - aKey.Size());
+	return self;
+	}
+
+C3DESDecryptorShim::C3DESDecryptorShim()
+	{	
+	}
+
+C3DESDecryptorShim::~C3DESDecryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;
+	}
+
+
+void C3DESDecryptorShim::ConstructL(const TDesC8& aKey)
+	{
+	TKeyProperty keyProperty = {K3DesUid, KNullUid, KSymmetricKey, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+											iSymmetricCipherImpl,
+											K3DesUid,
+											*iKey,
+											KCryptoModeDecryptUid,
+											KOperationModeECBUid,
+											KPaddingModeNoneUid,
+											NULL);	
+	}	
+
+TInt C3DESDecryptorShim::BlockSize() const
+	{
+	// SPI returns block size in BITS
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt C3DESDecryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void C3DESDecryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;	
+	}
+
+void C3DESDecryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+
+TInt C3DESDecryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/3desshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,145 @@
+/*
+* Copyright (c) 2006-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: 
+* 3DES shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __3DESSHIM_H__
+#define __3DESSHIM_H__
+
+#include <3des.h>
+
+namespace CryptoSpi
+	{
+	class CSymmetricCipher;
+	class CKey;
+	}
+	
+NONSHARABLE_CLASS(C3DESEncryptorShim) : public C3DESEncryptor
+{
+public:
+	/**
+	Creates an C3DESEncryptorShim object which has the same interface
+	as 3DESEncryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The encryption key
+	@return A pointer to a C3DESEncryptorShim instance
+	*/
+	static C3DESEncryptorShim* NewL(const TDesC8& aKey);
+	
+	/**
+	Creates an C3DESEncryptorShim object which has the same interface
+	as 3DESEncryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The encryption key
+	@return A pointer to a C3DESEncryptorShim instance
+	*/
+	static C3DESEncryptorShim* NewLC(const TDesC8& aKey);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~C3DESEncryptorShim();
+		
+private:
+	/// Constructor
+	C3DESEncryptorShim();
+	void ConstructL(const TDesC8& aKey);	
+	
+	// From CBase
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// 3DES uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+};
+
+NONSHARABLE_CLASS(C3DESDecryptorShim) : public C3DESDecryptor
+{
+public:
+	/**
+	Creates an C3DESDecryptorShim object which has the same interface
+	as 3DESDecryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The decryption key
+	@return A pointer to a C3DESDecryptorShim instance
+	*/
+	static C3DESDecryptorShim* NewL(const TDesC8& aKey);
+	
+	/**
+	Creates an C3DESDecryptorShim object which has the same interface
+	as 3DESDecryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The decryption key
+	@return A pointer to a C3DESDecryptorShim instance
+	*/
+	static C3DESDecryptorShim* NewLC(const TDesC8& aKey);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~C3DESDecryptorShim();
+	
+private:
+	/// Constructor	
+	C3DESDecryptorShim();	
+	void ConstructL(const TDesC8& aKey);	
+	
+	/**
+	From CBase, to allow CBufferedTransform & CBlockChainingMode
+	to determine whether the functionality may be delegated to
+	the SPI object.
+	*/ 
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// 3DES uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+};
+
+#endif // __3DESSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/arc4.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,62 @@
+/*
+* Copyright (c) 2002-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 "arc4.h"
+#include "arc4shim.h"
+
+
+EXPORT_C CARC4* CARC4::NewL(const TDesC8& aKey, TUint aDiscardBytes)
+	{
+	return CArc4Shim::NewL(aKey, aDiscardBytes);
+	}
+
+EXPORT_C CARC4* CARC4::NewLC(const TDesC8& aKey, TUint aDiscardBytes)
+	{
+	return CArc4Shim::NewLC(aKey, aDiscardBytes);
+	}
+
+CARC4::CARC4()
+	{	
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void CARC4::Reset()
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);		
+	}
+	
+TInt CARC4::KeySize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);	
+	return 0;
+	}
+
+void CARC4::DoProcess(TDes8& /*aData*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);	
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/arc4shim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,113 @@
+/*
+* Copyright (c) 2006-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 "arc4shim.h"
+
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include <cryptostrength.h>
+#include "../common/inlines.h"
+#include "keys.h"
+
+using namespace CryptoSpi;
+
+CArc4Shim* CArc4Shim::NewL(const TDesC8& aKey, TUint aDiscardBytes)
+	{
+	CArc4Shim* self = NewLC(aKey, aDiscardBytes);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CArc4Shim* CArc4Shim::NewLC(const TDesC8& aKey, TUint aDiscardBytes)
+	{
+	CArc4Shim* self = new (ELeave) CArc4Shim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aDiscardBytes);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()));
+	return self;
+	}
+
+void CArc4Shim::ConstructL(const TDesC8& aKey, TUint aDiscardBytes)
+	{
+	TKeyProperty keyProperty = {KArc4Uid, KNullUid, KSymmetricKey, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	
+	iAlgorithmParams = CCryptoParams::NewL();
+	iAlgorithmParams->AddL(aDiscardBytes, KARC4DiscardBytes);
+
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+												iSymmetricCipherImpl,
+												KArc4Uid,
+												*iKey,
+												KCryptoModeNoneUid,
+												KOperationModeNoneUid,
+												KPaddingModeNoneUid,
+												iAlgorithmParams);
+	}
+
+CArc4Shim::~CArc4Shim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;	
+	delete iAlgorithmParams;
+	}
+
+void CArc4Shim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+
+TInt CArc4Shim::BlockSize() const
+	{
+	return iSymmetricCipherImpl->BlockSize() >> 3; // Convert to bits
+	}
+
+TInt CArc4Shim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}
+
+void CArc4Shim::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aInput, aOutput);)
+	}
+
+void CArc4Shim::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iSymmetricCipherImpl->ProcessFinalL(aInput, aOutput);
+	}
+
+TInt CArc4Shim::MaxOutputLength(TInt aInputLength) const
+	{
+	return iSymmetricCipherImpl->MaxOutputLength(aInputLength);
+	}
+
+TInt CArc4Shim::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	return iSymmetricCipherImpl->MaxFinalOutputLength(aInputLength);
+	}
+
+CArc4Shim::CArc4Shim()
+	{		
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/arc4shim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,107 @@
+/*
+* Copyright (c) 2006-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: 
+* ARC4 shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef ARC4SHIM_H
+#define ARC4SHIM_H
+
+#include <arc4.h>
+
+namespace CryptoSpi
+	{
+	class CCryptoParams;
+	class CSymmetricCipher;
+	class CKey;
+	}
+	
+NONSHARABLE_CLASS(CArc4Shim) : public CARC4
+{
+public:
+	/**
+	Creates a CArc4Shim object which has the same interface as CARC4 
+	but delegates all work to a Crypto SPI plug-in.
+	@param aKey					The key to use. aKey must be less 
+								than or equal to KRC4MaxKeySizeBytes.  
+	@param aDiscardBytes		The number of bytes to drop from the 
+								beginning of the key stream.
+	@return						A pointer to a CArc4Shim instance
+	@leave KErrKeyNotWeakEnough	If the key size is larger than that 
+								allowed by the cipher strength 
+								restrictions of the crypto library.
+								See TCrypto::IsSymmetricWeakEnoughL()
+	*/
+	static CArc4Shim* NewL(const TDesC8& aKey, TUint aDiscardBytes);
+	
+	/**
+	Creates a CArc4Shim object which has the same interface as CARC4,
+	and leave it on the cleanup stack. but delegates all work to a 
+	Crypto SPI plug-in.
+	@param aKey					The key to use. aKey must be less 
+								than or equal to KRC4MaxKeySizeBytes.  
+	@param aDiscardBytes		The number of bytes to drop from the 
+								beginning of the key stream.
+	@return						A pointer to a CArc4Shim instance
+	@leave KErrKeyNotWeakEnough	If the key size is larger than that 
+								allowed by the cipher strength 
+								restrictions of the crypto library.
+								See TCrypto::IsSymmetricWeakEnoughL()
+	*/
+	static CArc4Shim* NewLC(const TDesC8& aKey, TUint aDiscardBytes);
+
+	/**
+	Destructor
+	*/
+	~CArc4Shim();
+
+	// From CSymmetricCipher class
+	void Reset();
+	TInt BlockSize() const;
+	TInt KeySize() const;		
+	void Process(const TDesC8& aInput, TDes8& aOutput);
+	void ProcessFinalL(const TDesC8& aInput, TDes8& aOutput);
+	TInt MaxOutputLength(TInt aInputLength) const;
+	TInt MaxFinalOutputLength(TInt aInputLength) const;
+
+private:
+	/** 
+	Constructor
+	*/
+	CArc4Shim();
+
+	/**
+	Second Phase Constructor
+	*/
+	void ConstructL(const TDesC8& aKey, TUint aDiscardBytes);
+		
+private:
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;
+	
+	CryptoSpi::CCryptoParams* iAlgorithmParams;
+};
+
+#endif // ARC4SHIM_H
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/blocktransformation.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,25 @@
+/*
+* Copyright (c) 2006-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 "blocktransformation.h"
+
+
+TInt CBlockTransformation::GetExtension(TUint aExtensionId, TAny*& a0, TAny* a1)
+	{
+	return Extension_(aExtensionId, a0, a1);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/bufferedtransformation.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,260 @@
+/*
+* Copyright (c) 2002-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 "bufferedtransformation.h"
+
+#include <cryptospi/cryptospidef.h>
+#include <cryptopanic.h>
+#include <e32cmn.h>
+#include "symmetriccipherplugin.h"
+
+#include "blocktransformation.h"
+#include "bufferedtransformationshim.h"
+#include "padding.h"
+#include "../common/inlines.h"
+
+EXPORT_C CBufferedTransformation::~CBufferedTransformation()
+	{
+	delete iBT;
+	delete iPadding;
+	delete iInputStoreBuf;
+	}
+
+void CBufferedTransformation::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	TInt blockSize = iBT->BlockSize();
+
+	if ( (aInput.Size() + iInputStore.Size()) < blockSize )
+		{
+		iInputStore.Append(aInput);
+		}
+	else
+		{
+		TInt outputIndex = aOutput.Size();
+		aOutput.Append(iInputStore);
+
+		TInt inputIndex = blockSize - iInputStore.Size();
+		aOutput.Append(aInput.Mid(0, inputIndex));
+
+		TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, blockSize,
+			blockSize);
+		//This should read: 
+		//TPtr8 transformBuf(aOutput.Mid(outputIndex, blockSize));
+		//but in the wonderful world of descriptors, Mid returns a TPtrC8 even
+		//when called on a TPtr8.  Fantastic eh?
+		iBT->Transform(transformBuf);
+
+		outputIndex += blockSize;
+
+		TInt len = aInput.Size() - blockSize;
+
+		for (; inputIndex<=len; inputIndex+=blockSize)
+			{
+			aOutput.Append(aInput.Mid(inputIndex, blockSize));			
+			transformBuf.Set((TUint8*)(aOutput.Ptr()) + outputIndex, blockSize,
+				blockSize);
+			iBT->Transform(transformBuf);
+			outputIndex += blockSize;
+			}
+
+		iInputStore.Zero();
+		if (inputIndex < aInput.Size())
+			iInputStore.Append(aInput.Mid(inputIndex));
+		}
+	}
+
+TInt CBufferedTransformation::MaxOutputLength(TInt aInputLength) const
+	{
+	TInt rem = (aInputLength + iInputStore.Size()) % (iBT->BlockSize());
+	return ((aInputLength + iInputStore.Size()) - rem);
+	}
+
+void CBufferedTransformation::Reset()
+	{
+	iBT->Reset();
+	iInputStore.Zero();
+	}
+
+TInt CBufferedTransformation::BlockSize() const
+	{
+	return (iBT->BlockSize());
+	}
+
+TInt CBufferedTransformation::KeySize() const
+	{
+	return (iBT->KeySize());
+	}
+
+EXPORT_C CBlockTransformation* CBufferedTransformation::BlockTransformer() const
+{
+	return (iBT);
+}
+
+CBufferedTransformation::CBufferedTransformation()
+	: iInputStore(0,0,0)
+	{
+	}
+
+void CBufferedTransformation::ConstructL(CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	iInputStoreBuf = HBufC8::NewL(aBT->BlockSize());
+	iInputStore.Set(iInputStoreBuf->Des());
+
+	// Take ownership last - doesn't take ownership if we leave
+	iBT = aBT;
+	iPadding = aPadding;
+	}
+
+
+// CBufferedEncryptor
+
+EXPORT_C CBufferedEncryptor* CBufferedEncryptor::NewL(
+	CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedEncryptor* self = CBufferedEncryptorShim::NewL(aBT, aPadding);
+	if (! self)
+		{			
+		// not able to use CryptoSpi, possibly due to an exterally 
+		// derived legacy class so fallback to old implementation.			
+		self = NewLC(aBT,aPadding);
+		CleanupStack::Pop(self);
+		}	
+	return self;
+	}
+
+EXPORT_C CBufferedEncryptor* CBufferedEncryptor::NewLC(
+	CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedEncryptor* self = new (ELeave) CBufferedEncryptor();
+	CleanupStack::PushL(self);
+	self->ConstructL(aBT, aPadding);
+	return self;
+	}
+
+void CBufferedEncryptor::ConstructL(CBlockTransformation* aBT, CPadding* aPadding) 
+	{
+	CBufferedTransformation::ConstructL(aBT, aPadding);
+	}
+
+CBufferedEncryptor::CBufferedEncryptor()
+	{
+	}
+
+void CBufferedEncryptor::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxFinalOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+	Process(aInput, aOutput);
+	
+	TInt outputIndex = aOutput.Size();
+	iPadding->PadL(iInputStore, aOutput);
+	assert(aOutput.Size() % iBT->BlockSize() == 0);
+
+	TUint blockSize = iBT->BlockSize();
+	TInt len = aOutput.Size() - outputIndex;
+	
+	for(TInt i=len; i>0; i-=blockSize)
+		{
+		TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, blockSize,
+			blockSize);
+		iBT->Transform(transformBuf);
+		outputIndex+=blockSize;
+		}
+
+	iInputStore.Zero();
+	}
+
+TInt CBufferedEncryptor::MaxFinalOutputLength(TInt aInputLength) const
+	{
+    return iPadding->MaxPaddedLength(iInputStore.Size() + aInputLength);
+	}
+
+// CBufferedDecryptor
+
+EXPORT_C CBufferedDecryptor* CBufferedDecryptor::NewL(
+	CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedDecryptor* self = CBufferedDecryptorShim::NewL(aBT, aPadding);
+	if (! self)
+		{			
+		// not able to use CryptoSpi, possibly due to an exterally 
+		// derived legacy class so fallback to old implementation.			
+		self = NewLC(aBT,aPadding);
+		CleanupStack::Pop(self);
+		}	
+	return self;
+	}
+
+EXPORT_C CBufferedDecryptor* CBufferedDecryptor::NewLC(
+	CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedDecryptor* self = new (ELeave) CBufferedDecryptor();
+	CleanupStack::PushL(self);
+	self->ConstructL(aBT, aPadding);
+	return self;
+	}
+
+CBufferedDecryptor::CBufferedDecryptor()
+	{
+	}
+
+void CBufferedDecryptor::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxFinalOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	assert((aInput.Size() + iInputStore.Size()) % iPadding->BlockSize()==0);
+	assert(aInput.Size() + iInputStore.Size() !=0 );
+	assert(iPadding->BlockSize() % BlockSize() == 0);
+	//1) Decrypt into aOutput up till the last full _padding_ blocksize
+	//If this panics with descriptor problems, you've probably called
+	//ProcessFinalL with a non-_padding_ blocksized aligned amount of data.
+	TInt lenToDecrypt = aInput.Size() - iPadding->BlockSize();
+	if(lenToDecrypt > 0)
+		{
+		Process(aInput.Left(lenToDecrypt), aOutput);
+		assert(iInputStore.Size()==0);
+		}
+	else
+		{
+		lenToDecrypt = 0;
+		}
+	
+	//2) Decrypt the last _padding_ blocksize into a new buffer
+	HBufC8* padBuf = HBufC8::NewLC(iPadding->BlockSize());
+	TPtr8 padPtr = padBuf->Des(); 
+	Process(aInput.Mid(lenToDecrypt), padPtr);
+	assert(iInputStore.Size()==0);
+		
+	//3) Unpad that last _padding_ blocksize into aOutput
+	// Note that padding systems must always, like everything else in crypto,
+	// _append_ data.
+	iPadding->UnPadL(padPtr, aOutput);
+
+	CleanupStack::PopAndDestroy(padBuf);
+	}
+
+TInt CBufferedDecryptor::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	return iPadding->MaxUnPaddedLength(aInputLength + iInputStore.Size());
+	}
+
+void CBufferedDecryptor::ConstructL(CBlockTransformation* aBT, CPadding* aPadding) 
+	{
+	CBufferedTransformation::ConstructL(aBT, aPadding);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/bufferedtransformationshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,189 @@
+/*
+* Copyright (c) 2006-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: 
+* blocktransformationshim.cpp
+*
+*/
+
+
+#include "bufferedtransformationshim.h"
+
+#include <cryptospi/cryptospidef.h>
+#include <padding.h>
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/plugincharacteristics.h>
+#include "../common/inlines.h"
+
+// CBufferedEncryptorShim
+CBufferedEncryptorShim::CBufferedEncryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl) :
+	iSymmetricCipherImpl(aSymmetricCipherImpl)
+	{
+	}
+
+CBufferedEncryptorShim* CBufferedEncryptorShim::NewL(CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedEncryptorShim* self(0);
+	
+	// Check whether the block transform contains an SPI plug-in
+	TAny* implPtr(0);
+	TInt err = aBT->GetExtension(CryptoSpi::KSymmetricCipherInterface, implPtr, NULL);	
+	if (err == KErrNone && implPtr)
+		{
+		CryptoSpi::CSymmetricCipher* impl(static_cast<CryptoSpi::CSymmetricCipher*>(implPtr));
+		
+		const CryptoSpi::TCharacteristics* c(0);
+		impl->GetCharacteristicsL(c);
+	
+		const CryptoSpi::TSymmetricCipherCharacteristics* cipherCharacteristics(
+			static_cast<const CryptoSpi::TSymmetricCipherCharacteristics*>(c));
+			
+		// See if the padding mode is recognised by CryptoSpi and if so, check
+		// whether the plug-in supports that padding mode.
+		TUid paddingMode;
+		TAny* paddingPtr = &paddingMode;		
+		err = aPadding->GetExtension(CryptoSpi::KPaddingInterface, paddingPtr, 0);		
+		if (err == KErrNone && cipherCharacteristics->IsPaddingModeSupported(paddingMode))
+			{
+			impl->SetCryptoModeL(CryptoSpi::KCryptoModeEncryptUid);
+			impl->SetPaddingModeL(paddingMode);		
+			self = new(ELeave) CBufferedEncryptorShim(impl);
+			CleanupStack::PushL(self);
+			self->ConstructL(aBT, aPadding);
+			CleanupStack::Pop(self);
+			}
+		}				
+	return self;
+	}
+
+void CBufferedEncryptorShim::ConstructL(CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedEncryptor::ConstructL(aBT, aPadding);
+	}
+
+void CBufferedEncryptorShim::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aInput, aOutput);)
+	}
+	
+TInt CBufferedEncryptorShim::MaxOutputLength(TInt aInputLength) const
+	{
+	return iSymmetricCipherImpl->MaxOutputLength(aInputLength);
+	}
+	
+void CBufferedEncryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+	
+TInt CBufferedEncryptorShim::BlockSize() const
+	{
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CBufferedEncryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}
+	
+void CBufferedEncryptorShim::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iSymmetricCipherImpl->ProcessFinalL(aInput, aOutput);
+	}
+	
+TInt CBufferedEncryptorShim::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	return iSymmetricCipherImpl->MaxFinalOutputLength(aInputLength);
+	}
+
+// CBufferedDecryptorShim
+CBufferedDecryptorShim::CBufferedDecryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl) :
+	iSymmetricCipherImpl(aSymmetricCipherImpl)
+	{
+	}
+
+CBufferedDecryptorShim* CBufferedDecryptorShim::NewL(CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedDecryptorShim* self(0);
+	
+	// Check whether the block transform contains an SPI plug-in
+	TAny* implPtr(0);
+	TInt err = aBT->GetExtension(CryptoSpi::KSymmetricCipherInterface, implPtr, NULL);	
+	if (err == KErrNone && implPtr)
+		{
+		CryptoSpi::CSymmetricCipher* impl(static_cast<CryptoSpi::CSymmetricCipher*>(implPtr));
+		
+		const CryptoSpi::TCharacteristics* c(0);
+		impl->GetCharacteristicsL(c);
+	
+		const CryptoSpi::TSymmetricCipherCharacteristics* cipherCharacteristics(
+			static_cast<const CryptoSpi::TSymmetricCipherCharacteristics*>(c));
+			
+		// See if the padding mode is recognised by CryptoSpi and if so, check
+		// whether the plug-in supports that padding mode.
+		TUid paddingMode;
+		TAny* paddingPtr = &paddingMode;		
+		err = aPadding->GetExtension(CryptoSpi::KPaddingInterface, paddingPtr, 0);		
+		if (err == KErrNone && cipherCharacteristics->IsPaddingModeSupported(paddingMode))
+			{
+			impl->SetCryptoModeL(CryptoSpi::KCryptoModeDecryptUid);			
+			impl->SetPaddingModeL(paddingMode);
+			
+			self = new(ELeave) CBufferedDecryptorShim(impl);
+			CleanupStack::PushL(self);
+			self->ConstructL(aBT, aPadding);
+			CleanupStack::Pop(self);
+			}
+		}				
+	return self;
+	}
+
+void CBufferedDecryptorShim::ConstructL(CBlockTransformation* aBT, CPadding* aPadding)
+	{
+	CBufferedDecryptor::ConstructL(aBT, aPadding);
+	}
+
+void CBufferedDecryptorShim::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aInput, aOutput);)
+	}
+	
+TInt CBufferedDecryptorShim::MaxOutputLength(TInt aInputLength) const
+	{
+	return iSymmetricCipherImpl->MaxOutputLength(aInputLength);
+	}
+	
+void CBufferedDecryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+	
+TInt CBufferedDecryptorShim::BlockSize() const
+	{
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CBufferedDecryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}
+	
+void CBufferedDecryptorShim::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	iSymmetricCipherImpl->ProcessFinalL(aInput, aOutput);
+	}
+	
+TInt CBufferedDecryptorShim::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	return iSymmetricCipherImpl->MaxFinalOutputLength(aInputLength);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/bufferedtransformationshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,99 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __BUFFEREDTRANSFORMATIONSHIM_H__
+#define __BUFFEREDTRANSFORMATIONSHIM_H__
+
+#include <bufferedtransformation.h>
+
+/**
+@file
+@internalComponent
+@released
+*/
+
+namespace CryptoSpi 
+	{
+	class CSymmetricCipher;
+	}
+
+/**
+ Shim class that delegates all operations to an Crypto Spi object.
+ This object is constructed automatically by CBufferedEncryptorShim and should
+ not be used directly.
+ */
+NONSHARABLE_CLASS(CBufferedEncryptorShim) : public CBufferedEncryptor
+{
+public:
+	/**
+	Creates a new CBufferedEncryptorShim.
+	N.B. It is the reponsiblity of the CALLER to check that block transform
+	object contains an SPI delegate and that the delegate supports the specified
+	padding mode.
+	*/
+	static CBufferedEncryptorShim* NewL(CBlockTransformation* aBT, CPadding* aPadding);
+	
+	// From CBufferedTransformation
+	void Process(const TDesC8& aInput, TDes8& aOutput);
+	TInt MaxOutputLength(TInt aInputLength) const;
+	void Reset();
+	TInt BlockSize() const;
+	TInt KeySize() const;	
+	void ProcessFinalL(const TDesC8& aInput, TDes8& aOutput);
+	TInt MaxFinalOutputLength(TInt aInputLength) const;
+private:	
+	CBufferedEncryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl);
+	void ConstructL(CBlockTransformation* aBT, CPadding* aPadding);
+	
+	// owned by block transform - iBT
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+};
+
+/**
+ Shim class that delegates all operations to an Crypto Spi object.
+ This object is constructed automatically by CBufferedEncryptorShim and should
+ not be used directly.
+ */
+NONSHARABLE_CLASS(CBufferedDecryptorShim) : public CBufferedDecryptor
+{
+public:
+	/**
+	Creates a new CBufferedDecryptorShim.
+	N.B. It is the reponsiblity of the CALLER to check that block transform
+	object contains an SPI delegate and that the delegate supports the specified
+	padding mode.
+	*/
+	static CBufferedDecryptorShim* NewL(CBlockTransformation* aBT, CPadding* aPadding);
+	
+	// From CBufferedTransformation	
+	void Process(const TDesC8& aInput, TDes8& aOutput);
+	TInt MaxOutputLength(TInt aInputLength) const;
+	void Reset();
+	TInt BlockSize() const;
+	TInt KeySize() const;	
+	void ProcessFinalL(const TDesC8& aInput, TDes8& aOutput);
+	TInt MaxFinalOutputLength(TInt aInputLength) const;
+private:	
+	CBufferedDecryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl);
+	void ConstructL(CBlockTransformation* aBT, CPadding* aPadding);
+	
+	// owned by block transform - iBT
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+};
+
+#endif	//	__BUFFEREDTRANSFORMATIONSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/cbcmode.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,170 @@
+/*
+* Copyright (c) 2002-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 <cbcmode.h>
+
+#include "cbcmodeshim.h"
+#include "../common/inlines.h"
+
+void CBlockChainingMode::Reset()
+	{
+	iRegister.Copy(iIV);
+	iBT->Reset();
+	}
+
+TInt CBlockChainingMode::BlockSize() const
+	{
+	return (iBT->BlockSize());
+	}
+
+TInt CBlockChainingMode::KeySize() const
+	{
+	return (iBT->KeySize());
+	}
+
+void CBlockChainingMode::SetIV(const TDesC8& aIV)
+	{
+	//We are making the stipulation that anybody calling SetIV is not setting it
+	//to a longer IV than they originally did.  Otherwise SetIV needs to leave.
+	assert(aIV.Size() <= iIV.Size());
+	iIV.Copy(aIV);
+	Reset();
+	}
+
+EXPORT_C CBlockChainingMode::CBlockChainingMode() 
+	: iBT(NULL), iRegister(0,0,0), iIV(0,0,0)
+	{
+	}
+
+EXPORT_C CBlockChainingMode::~CBlockChainingMode()
+	{
+	delete iBT;
+	delete iRegisterBuf;
+	delete iIVBuf;
+	}
+
+EXPORT_C void CBlockChainingMode::ConstructL(CBlockTransformation* aBT, const TDesC8& aIV)
+	{
+	iRegisterBuf = aIV.AllocL();
+	iRegister.Set(iRegisterBuf->Des());
+	iIVBuf = aIV.AllocL();
+	iIV.Set(iIVBuf->Des());
+
+	// Take ownership last - doesn't take ownership if we leave
+	iBT = aBT;
+	}
+
+/* CModeCBCEncryptor */
+EXPORT_C CModeCBCEncryptor* CModeCBCEncryptor::NewL(CBlockTransformation* aBT, 
+	const TDesC8& aIV)
+	{	
+	CModeCBCEncryptor* self = CModeCBCEncryptorShim::NewL(aBT, aIV);
+	if (! self)
+		{			
+		// not able to use CryptoSpi, possibly due to an exterally 
+		// derived legacy class so fallback to old implementation.			
+		self = NewLC(aBT,aIV);
+		CleanupStack::Pop(self);
+		}	
+	return self;	
+	}
+
+EXPORT_C CModeCBCEncryptor* CModeCBCEncryptor::NewLC(CBlockTransformation* aBT,
+	const TDesC8& aIV)
+	{
+	CModeCBCEncryptor* self = new (ELeave)CModeCBCEncryptor();	
+	CleanupStack::PushL(self);
+	self->ConstructL(aBT, aIV);
+	return self;
+	}
+
+CModeCBCEncryptor::CModeCBCEncryptor()
+	{
+	}
+
+void CModeCBCEncryptor::Transform(TDes8& aBlock)
+	{
+	assert(aBlock.Size() == iBT->BlockSize());
+	assert(iRegister.Size() == aBlock.Size());
+
+	XorBuf(const_cast<TUint8*>(iRegister.Ptr()), aBlock.Ptr(), aBlock.Size());
+	iBT->Transform(iRegister);
+	aBlock.Copy(iRegister);
+	}
+
+/* CModeCBCDecryptor */
+EXPORT_C CModeCBCDecryptor* CModeCBCDecryptor::NewL(CBlockTransformation* aBT, 
+	const TDesC8& aIV)
+	{
+	CModeCBCDecryptor* self = CModeCBCDecryptorShim::NewL(aBT, aIV);
+	if (! self)
+		{			
+		// not able to use CryptoSpi, possibly due to an exterally 
+		// derived legacy class so fallback to old implementation.			
+		self = NewLC(aBT,aIV);
+		CleanupStack::Pop(self);
+		}	
+	return self;	
+	}
+
+EXPORT_C CModeCBCDecryptor* CModeCBCDecryptor::NewLC(CBlockTransformation* aBT, 
+	const TDesC8& aIV)
+	{
+	CModeCBCDecryptor* self = new (ELeave)CModeCBCDecryptor();	
+	CleanupStack::PushL(self);
+	self->ConstructL(aBT, aIV);
+	return self;	
+	}
+
+void CModeCBCDecryptor::ConstructL(CBlockTransformation* aBT, const TDesC8& aIV)
+	{
+	iIVBakBuf = aIV.AllocL();
+	iIVBak.Set(iIVBakBuf->Des());
+	CBlockChainingMode::ConstructL(aBT, aIV);
+	}
+
+CModeCBCDecryptor::~CModeCBCDecryptor(void)
+	{
+	delete iIVBakBuf;
+	}
+
+CModeCBCDecryptor::CModeCBCDecryptor()
+	: iIVBak(0,0,0)
+	{
+	}
+
+void CModeCBCDecryptor::Transform(TDes8& aBlock)
+	{
+	assert(aBlock.Size() == iBT->BlockSize());
+	assert(iRegister.Size() == aBlock.Size());
+	assert(iIVBak.Size() == aBlock.Size());
+	
+	// Take a copy of incoming block
+	iIVBak.Copy(aBlock);
+
+	// transform the block
+	iBT->Transform(aBlock);
+
+	// xor the output with the register
+	XorBuf(const_cast<TUint8*>(aBlock.Ptr()), iRegister.Ptr(), 
+		aBlock.Size());
+
+	// Update the register to be the original block
+	iRegister.Copy(iIVBak);
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/cbcmodeshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,214 @@
+/*
+* Copyright (c) 2006-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 "cbcmodeshim.h"
+
+#include <cryptopanic.h>
+#include <cryptospi/cryptospidef.h>
+#include <padding.h>
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/plugincharacteristics.h>
+#include "../common/inlines.h"
+
+// CModeCBCEncryptorShim
+CModeCBCEncryptorShim::CModeCBCEncryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl) :
+	iSymmetricCipherImpl(aSymmetricCipherImpl)
+	{
+	}
+
+CModeCBCEncryptorShim* CModeCBCEncryptorShim::NewL(CBlockTransformation* aBT, const TDesC8& aIv)
+	{
+	CModeCBCEncryptorShim* self(0);
+	
+	// Check whether the block transform contains an SPI plug-in
+	TAny* implPtr(0);
+	TInt err = aBT->GetExtension(CryptoSpi::KSymmetricCipherInterface, implPtr, NULL);	
+	if (err == KErrNone && implPtr)
+		{
+		CryptoSpi::CSymmetricCipher* impl(static_cast<CryptoSpi::CSymmetricCipher*>(implPtr));
+		
+		const CryptoSpi::TCharacteristics* c(0);
+		impl->GetCharacteristicsL(c);
+	
+		const CryptoSpi::TSymmetricCipherCharacteristics* cipherCharacteristics(
+			static_cast<const CryptoSpi::TSymmetricCipherCharacteristics*>(c));
+			
+		// Verify that the plug-in supports CBC mode
+		if (err == KErrNone && 
+			cipherCharacteristics->IsOperationModeSupported(CryptoSpi::KOperationModeCBCUid))
+			{
+			// Set block transform to encrypt-cbc
+			impl->SetCryptoModeL(CryptoSpi::KCryptoModeEncryptUid);
+			impl->SetOperationModeL(CryptoSpi::KOperationModeCBCUid);
+			impl->SetIvL(aIv);		
+			self = new(ELeave) CModeCBCEncryptorShim(impl);
+			CleanupStack::PushL(self);
+			self->ConstructL(aBT, aIv);
+			CleanupStack::Pop(self);
+			}
+		}				
+	return self;
+	}
+
+void CModeCBCEncryptorShim::ConstructL(CBlockTransformation* aBT, const TDesC8& aIv)
+	{
+	CModeCBCEncryptor::ConstructL(aBT, aIv);
+	}
+
+void CModeCBCEncryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+	
+TInt CModeCBCEncryptorShim::BlockSize() const
+	{
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CModeCBCEncryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}
+	
+void CModeCBCEncryptorShim::Transform(TDes8& aBlock) 
+	{
+	// This function will never get called if a buffered
+	// encryptor is used because Process and ProcessFinalL call
+	// iSymmetricCipherImpl directly
+	iBT->Transform(aBlock);	
+	}
+	
+void CModeCBCEncryptorShim::SetIV(const TDesC8& aIv)
+	{
+	TRAPD(err, iSymmetricCipherImpl->SetIvL(aIv));
+	if (err == KErrOverflow)
+		{
+		User::Panic(KCryptoPanic, ECryptoPanicInputTooLarge);
+		}
+	else if (err != KErrNone)
+		{
+		// SetIvL should only leave if the aIv is incorrect
+		User::Panic(KCryptoPanic, KErrArgument);
+		}
+	}
+
+TInt CModeCBCEncryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId)
+		{		
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}		
+
+// CModeCBCDecryptorShim
+CModeCBCDecryptorShim::CModeCBCDecryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl) :
+	iSymmetricCipherImpl(aSymmetricCipherImpl)
+	{
+	}
+
+CModeCBCDecryptorShim* CModeCBCDecryptorShim::NewL(CBlockTransformation* aBT, const TDesC8& aIv)
+	{
+	CModeCBCDecryptorShim* self(0);
+	
+	// Check whether the block transform contains an SPI plug-in
+	TAny* implPtr(0);
+	TInt err = aBT->GetExtension(CryptoSpi::KSymmetricCipherInterface, implPtr, NULL);	
+	if (err == KErrNone && implPtr)
+		{
+		CryptoSpi::CSymmetricCipher* impl(static_cast<CryptoSpi::CSymmetricCipher*>(implPtr));
+		
+		const CryptoSpi::TCharacteristics* c(0);
+		impl->GetCharacteristicsL(c);
+	
+		const CryptoSpi::TSymmetricCipherCharacteristics* cipherCharacteristics(
+			static_cast<const CryptoSpi::TSymmetricCipherCharacteristics*>(c));
+			
+		// Verify that the plug-in supports CBC mode
+		if (err == KErrNone && 
+			cipherCharacteristics->IsOperationModeSupported(CryptoSpi::KOperationModeCBCUid))
+			{
+			// Set block transform to encrypt-cbc
+			impl->SetCryptoModeL(CryptoSpi::KCryptoModeDecryptUid);
+			impl->SetOperationModeL(CryptoSpi::KOperationModeCBCUid);
+			impl->SetIvL(aIv);				
+			self = new(ELeave) CModeCBCDecryptorShim(impl);
+			CleanupStack::PushL(self);
+			self->ConstructL(aBT, aIv);
+			CleanupStack::Pop(self);
+			}
+		}				
+	return self;
+	}
+
+void CModeCBCDecryptorShim::ConstructL(CBlockTransformation* aBT, const TDesC8& aIv)
+	{
+	CModeCBCDecryptor::ConstructL(aBT, aIv);
+	}
+	
+void CModeCBCDecryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+	
+TInt CModeCBCDecryptorShim::BlockSize() const
+	{
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CModeCBCDecryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}
+
+void CModeCBCDecryptorShim::Transform(TDes8& aBlock) 
+	{
+	// This function will never get called if a buffered
+	// encryptor is used because Process and ProcessFinalL call
+	// iSymmetricCipherImpl directly
+	iBT->Transform(aBlock);	
+	}
+
+void CModeCBCDecryptorShim::SetIV(const TDesC8& aIv)
+	{
+	TRAPD(err, iSymmetricCipherImpl->SetIvL(aIv));
+	if (err == KErrOverflow)
+		{
+		User::Panic(KCryptoPanic, ECryptoPanicInputTooLarge);
+		}
+	else if (err != KErrNone)
+		{
+		// SetIvL should only leave if the aIv is incorrect
+		User::Panic(KCryptoPanic, KErrArgument);
+		}
+	}
+	
+TInt CModeCBCDecryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId)
+		{		
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}	
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/cbcmodeshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,113 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __CBCMODESHIM_H__
+#define __CBCMODESHIM_H__
+
+#include <cbcmode.h>
+
+/**
+@file
+@internalComponent
+@released
+*/
+
+namespace CryptoSpi 
+	{
+	class CSymmetricCipher;
+	}
+
+/**
+CBC mode encryptor shim class that delegates all work to CModeCBCEncryptor.
+This should only be instantiated by CModeCBCEncryptor::NewLC
+*/
+NONSHARABLE_CLASS(CModeCBCEncryptorShim) : public CModeCBCEncryptor
+{
+public:
+	/**
+	Creates a new CModeCBCEncryptorShim. If the block transfer 
+	@param aBT A pointer to the block transform object.
+	@param aIV The initialisation vector to use.
+	@return A pointer to a CModeCBCEncryptorShim instance or NULL if the block transform
+	does not support SPI or the SPI plug-in does not support CBC mode
+	*/
+	static CModeCBCEncryptorShim* NewL(CBlockTransformation* aBT, const TDesC8& aIV);
+
+	// From CBase
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+
+	// From CBlockTransformation
+	void Reset();
+	TInt BlockSize() const;
+	TInt KeySize() const;
+	void Transform(TDes8& aBlock);	
+
+	// From CBlockChainingMode
+	void SetIV(const TDesC8& aIv);
+	
+private:
+	/// Constructor
+	CModeCBCEncryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl);
+	
+	// Just invokes ContructL in super-class
+	void ConstructL(CBlockTransformation* aBT, const TDesC8& aIv);
+	
+	// owned by block transform - iBT
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;		
+};
+
+/**
+CBC mode decryptor shim class that delegates all work to CModeCBCDecryptor.
+This should only be instantiated by CModeCBCDecryptor::NewLC
+*/
+NONSHARABLE_CLASS(CModeCBCDecryptorShim) : public CModeCBCDecryptor
+{
+public:
+	/**
+	Creates a new CModeCBCEncryptorShim.
+	@param aBT A pointer to the block transform object.
+	@param aIV The initialisation vector to use.
+	@return A pointer to a CModeCBCDecryptorShim instance or NULL if the block transform
+	does not support SPI or the SPI plug-in does not support CBC mode
+	*/
+	static CModeCBCDecryptorShim* NewL(CBlockTransformation* aBT, const TDesC8& aIV);
+
+	// From CBase
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+
+	// From CBlockTransformation
+	void Reset();
+	TInt BlockSize() const;
+	TInt KeySize() const;
+	void Transform(TDes8& aBlock);	
+
+	// From CBlockChainingMode
+	void SetIV(const TDesC8& aIv);
+	
+private:
+	/// Constructor
+	CModeCBCDecryptorShim(CryptoSpi::CSymmetricCipher* aSymmetricCipherImpl);
+	
+	// Just invokes ContructL in super-class
+	void ConstructL(CBlockTransformation* aBT, const TDesC8& aIv);
+		
+	// owned by block transform - iBT
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+};
+
+#endif	//	__CBCMODESHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/des.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,159 @@
+/*
+* Copyright (c) 2002-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 <des.h>
+#include "desshim.h"
+
+const TInt KDESBlockBytes = 8;
+const TInt KDESKeyBytes = 8;
+
+CDES::~CDES()
+	{
+	}
+
+CDES::CDES()
+	{
+	}
+
+typedef TUint8 TKeyDES[KDESKeyBytes];
+const TInt KKnownWeakKeysCount = 16;
+
+const TKeyDES weak_keys[KKnownWeakKeysCount] =
+	{
+	/* weak keys */
+	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+	{0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE},
+	{0x1E,0x1E,0x1E,0x1E,0x0E,0x0E,0x0E,0x0E},
+	{0xE0,0xE0,0xE0,0xE0,0xF0,0xF0,0xF0,0xF0},
+	{0x00,0xFE,0x00,0xFE,0x00,0xFE,0x00,0xFE},
+	{0xFE,0x00,0xFE,0x00,0xFE,0x00,0xFE,0x00},
+	{0x1E,0xE0,0x1E,0xE0,0x0E,0xF0,0x0E,0xF0},
+	{0xE0,0x1E,0xE0,0x1E,0xF0,0x0E,0xF0,0x0E},
+	{0x00,0xE0,0x00,0xE0,0x00,0xF0,0x00,0xF0},
+	{0xE0,0x00,0xE0,0x00,0xF0,0x00,0xF0,0x00},
+	{0x1E,0xFE,0x1E,0xFE,0x0E,0xFE,0x0E,0xFE},
+	{0xFE,0x1E,0xFE,0x1E,0xFE,0x0E,0xFE,0x0E},
+	{0x00,0x1E,0x00,0x1E,0x00,0x0E,0x00,0x0E},
+	{0x1E,0x00,0x1E,0x00,0x0E,0x00,0x0E,0x00},
+	{0xE0,0xFE,0xE0,0xFE,0xF0,0xFE,0xF0,0xFE},
+	{0xFE,0xE0,0xFE,0xE0,0xFE,0xF0,0xFE,0xF0}
+	};
+	
+EXPORT_C TBool CDES::IsWeakKey(const TDesC8& aKey)
+	{
+	TKeyDES key;
+	TInt index = 0;
+	//Reset parity bits
+	for(; index < KDESKeyBytes; index++)
+		{
+		key[index] = aKey[index] & 0xFE;
+		}
+		
+	TBool weak = EFalse;	
+	//Compare key with potential weak keys without parity	
+	for (index=0; index < KKnownWeakKeysCount; index++)
+		{
+		if (Mem::Compare(weak_keys[index], KDESKeyBytes, &key[0], KDESKeyBytes)==0)
+			{
+			weak = ETrue;
+			break;
+			}
+		}
+	return weak;
+	}
+
+/* CDESEncryptor */
+EXPORT_C CDESEncryptor* CDESEncryptor::NewL(const TDesC8& aKey, TBool /*aCheckWeakKey*/)
+	{
+	return CDESEncryptorShim::NewL(aKey);
+	}
+
+EXPORT_C CDESEncryptor* CDESEncryptor::NewLC(const TDesC8& aKey, TBool /*aCheckWeakKey*/)
+	{
+	return CDESEncryptorShim::NewLC(aKey);
+	}
+
+CDESEncryptor::CDESEncryptor()
+	{
+	}
+
+/* CDESDecryptor */
+EXPORT_C CDESDecryptor* CDESDecryptor::NewL(const TDesC8& aKey, TBool /*aCheckWeakKey*/)
+	{
+	return CDESDecryptorShim::NewL(aKey);
+	}
+
+EXPORT_C CDESDecryptor* CDESDecryptor::NewLC(const TDesC8& aKey, TBool /*aCheckWeakKey*/)
+	{
+	return CDESDecryptorShim::NewLC(aKey);
+	}
+
+CDESDecryptor::CDESDecryptor()
+	{	
+	}
+	
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void CDES::Transform(TDes8& /*aBlock*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);	
+	}
+
+TInt CDES::BlockSize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	return KDESBlockBytes;
+	}
+
+TInt CDES::KeySize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	return KDESKeyBytes;
+	}
+	
+void CDES::Reset()
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	}	
+	
+void CDES::SetKey(const TDesC8& /*aKey*/, TUint32* /*aKeyBuffer*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);				
+	}
+	
+void CDES::ConstructL(const TDesC8& /*aKey*/, TBool /*aCheckWeakKey*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	}
+
+void CDESDecryptor::SetKey(const TDesC8& /*aKey*/, TUint32* /*aKeyBuffer*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);	
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/desshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,191 @@
+/*
+* Copyright (c) 2006-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 "desshim.h"
+
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "keys.h"
+#include <cryptostrength.h>
+
+#include "../common/inlines.h"
+
+using namespace CryptoSpi;
+
+// CDESEncryptorShim ////////////////////////////////////////////////////////
+CDESEncryptorShim* CDESEncryptorShim::NewL(const TDesC8& aKey)
+	{
+	CDESEncryptorShim* self = CDESEncryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDESEncryptorShim* CDESEncryptorShim::NewLC(const TDesC8& aKey)
+	{
+	CDESEncryptorShim* self = new (ELeave) CDESEncryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	// DES only used 7 bits out of every key byte
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()) - aKey.Size());
+	return self;
+	}
+
+CDESEncryptorShim::CDESEncryptorShim()
+	{
+	}
+
+CDESEncryptorShim::~CDESEncryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;			
+	}	
+
+void CDESEncryptorShim::ConstructL(const TDesC8& aKey)
+	{
+	TKeyProperty keyProperty = {KDesUid, KNullUid, KSymmetricKey, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+											iSymmetricCipherImpl,
+											KDesUid,
+											*iKey,
+											KCryptoModeEncryptUid,
+											KOperationModeECBUid,
+											KPaddingModeNoneUid,
+											NULL);
+	}		
+
+TInt CDESEncryptorShim::BlockSize() const
+	{
+	// SPI returns block size in BITS
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}	
+
+TInt CDESEncryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void CDESEncryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;
+	}
+
+void CDESEncryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}	
+
+TInt CDESEncryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}	
+
+// CDESDecryptorShim ////////////////////////////////////////////////////////
+CDESDecryptorShim* CDESDecryptorShim::NewL(const TDesC8& aKey)
+	{
+	CDESDecryptorShim* self = CDESDecryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+CDESDecryptorShim* CDESDecryptorShim::NewLC(const TDesC8& aKey)
+	{
+	CDESDecryptorShim* self = new (ELeave) CDESDecryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	// DES only used 7 bits out of every key byte
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()) - aKey.Size());
+	return self;
+	}
+
+CDESDecryptorShim::CDESDecryptorShim()
+	{	
+	}
+
+CDESDecryptorShim::~CDESDecryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;			
+	}
+
+
+void CDESDecryptorShim::ConstructL(const TDesC8& aKey)
+	{
+	TKeyProperty keyProperty = {KDesUid, KNullUid, KSymmetricKey, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+											iSymmetricCipherImpl,
+											KDesUid,
+											*iKey,
+											KCryptoModeDecryptUid,
+											KOperationModeECBUid,
+											KPaddingModeNoneUid,
+											NULL);	
+	}	
+
+TInt CDESDecryptorShim::BlockSize() const
+	{
+	// SPI returns block size in BITS
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CDESDecryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void CDESDecryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();	
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;	
+	}
+
+void CDESDecryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+
+TInt CDESDecryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/desshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,145 @@
+/*
+* Copyright (c) 2006-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: 
+* DES shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __DESSHIM_H__
+#define __DESSHIM_H__
+
+#include <des.h>
+
+namespace CryptoSpi
+	{
+	class CSymmetricCipher;
+	class CKey;
+	}
+	
+NONSHARABLE_CLASS(CDESEncryptorShim) : public CDESEncryptor
+{
+public:
+	/**
+	Creates an CDESEncryptorShim object which has the same interface
+	as DESEncryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The encryption key
+	@return A pointer to a CDESEncryptorShim instance
+	*/
+	static CDESEncryptorShim* NewL(const TDesC8& aKey);
+	
+	/**
+	Creates an CDESEncryptorShim object which has the same interface
+	as DESEncryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The encryption key
+	@return A pointer to a CDESEncryptorShim instance
+	*/
+	static CDESEncryptorShim* NewLC(const TDesC8& aKey);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~CDESEncryptorShim();
+		
+private:
+	/// Constructor
+	CDESEncryptorShim();
+	void ConstructL(const TDesC8& aKey);	
+	
+	// From CBase
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// DES uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+};
+
+NONSHARABLE_CLASS(CDESDecryptorShim) : public CDESDecryptor
+{
+public:
+	/**
+	Creates an CDESDecryptorShim object which has the same interface
+	as DESDecryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The decryption key
+	@return A pointer to a CDESDecryptorShim instance
+	*/
+	static CDESDecryptorShim* NewL(const TDesC8& aKey);
+	
+	/**
+	Creates an CDESDecryptorShim object which has the same interface
+	as DESDecryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The decryption key
+	@return A pointer to a CDESDecryptorShim instance
+	*/
+	static CDESDecryptorShim* NewLC(const TDesC8& aKey);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~CDESDecryptorShim();
+	
+private:
+	/// Constructor	
+	CDESDecryptorShim();	
+	void ConstructL(const TDesC8& aKey);	
+	
+	/**
+	From CBase, to allow CBufferedTransform & CBlockChainingMode
+	to determine whether the functionality may be delegated to
+	the SPI object.
+	*/ 
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// DES uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+};
+
+#endif // __DESSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/destables.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,184 @@
+/*
+* Copyright (c) 2002-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: 
+* DES Tables
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent 
+*/
+ 
+#ifndef __DESTABLES_H__
+#define __DESTABLES_H__
+
+#include <e32std.h>
+
+namespace DES_TABLE
+{
+/* initial permutation IP */
+const TUint8 ip[] = {
+	   58, 50, 42, 34, 26, 18, 10,  2,
+	   60, 52, 44, 36, 28, 20, 12,  4,
+	   62, 54, 46, 38, 30, 22, 14,  6,
+	   64, 56, 48, 40, 32, 24, 16,  8,
+	   57, 49, 41, 33, 25, 17,  9,  1,
+	   59, 51, 43, 35, 27, 19, 11,  3,
+	   61, 53, 45, 37, 29, 21, 13,  5,
+	   63, 55, 47, 39, 31, 23, 15,  7
+};
+
+/* final permutation IP^-1 */
+const TUint8 fp[] = {
+	   40,  8, 48, 16, 56, 24, 64, 32,
+	   39,  7, 47, 15, 55, 23, 63, 31,
+	   38,  6, 46, 14, 54, 22, 62, 30,
+	   37,  5, 45, 13, 53, 21, 61, 29,
+	   36,  4, 44, 12, 52, 20, 60, 28,
+	   35,  3, 43, 11, 51, 19, 59, 27,
+	   34,  2, 42, 10, 50, 18, 58, 26,
+	   33,  1, 41,  9, 49, 17, 57, 25
+};
+
+/* expansion operation matrix */
+const TUint8 ei[] = {
+	   32,  1,  2,  3,  4,  5,
+		4,  5,  6,  7,  8,  9,
+		8,  9, 10, 11, 12, 13,
+	   12, 13, 14, 15, 16, 17,
+	   16, 17, 18, 19, 20, 21,
+	   20, 21, 22, 23, 24, 25,
+	   24, 25, 26, 27, 28, 29,
+	   28, 29, 30, 31, 32,  1
+};
+
+const TUint32 sbox[8][64] = {
+{
+0x01010400,0x00000000,0x00010000,0x01010404, 0x01010004,0x00010404,0x00000004,0x00010000,
+0x00000400,0x01010400,0x01010404,0x00000400, 0x01000404,0x01010004,0x01000000,0x00000004,
+0x00000404,0x01000400,0x01000400,0x00010400, 0x00010400,0x01010000,0x01010000,0x01000404,
+0x00010004,0x01000004,0x01000004,0x00010004, 0x00000000,0x00000404,0x00010404,0x01000000,
+0x00010000,0x01010404,0x00000004,0x01010000, 0x01010400,0x01000000,0x01000000,0x00000400,
+0x01010004,0x00010000,0x00010400,0x01000004, 0x00000400,0x00000004,0x01000404,0x00010404,
+0x01010404,0x00010004,0x01010000,0x01000404, 0x01000004,0x00000404,0x00010404,0x01010400,
+0x00000404,0x01000400,0x01000400,0x00000000, 0x00010004,0x00010400,0x00000000,0x01010004},
+{
+0x80108020,0x80008000,0x00008000,0x00108020, 0x00100000,0x00000020,0x80100020,0x80008020,
+0x80000020,0x80108020,0x80108000,0x80000000, 0x80008000,0x00100000,0x00000020,0x80100020,
+0x00108000,0x00100020,0x80008020,0x00000000, 0x80000000,0x00008000,0x00108020,0x80100000,
+0x00100020,0x80000020,0x00000000,0x00108000, 0x00008020,0x80108000,0x80100000,0x00008020,
+0x00000000,0x00108020,0x80100020,0x00100000, 0x80008020,0x80100000,0x80108000,0x00008000,
+0x80100000,0x80008000,0x00000020,0x80108020, 0x00108020,0x00000020,0x00008000,0x80000000,
+0x00008020,0x80108000,0x00100000,0x80000020, 0x00100020,0x80008020,0x80000020,0x00100020,
+0x00108000,0x00000000,0x80008000,0x00008020, 0x80000000,0x80100020,0x80108020,0x00108000},
+{
+0x00000208,0x08020200,0x00000000,0x08020008, 0x08000200,0x00000000,0x00020208,0x08000200,
+0x00020008,0x08000008,0x08000008,0x00020000, 0x08020208,0x00020008,0x08020000,0x00000208,
+0x08000000,0x00000008,0x08020200,0x00000200, 0x00020200,0x08020000,0x08020008,0x00020208,
+0x08000208,0x00020200,0x00020000,0x08000208, 0x00000008,0x08020208,0x00000200,0x08000000,
+0x08020200,0x08000000,0x00020008,0x00000208, 0x00020000,0x08020200,0x08000200,0x00000000,
+0x00000200,0x00020008,0x08020208,0x08000200, 0x08000008,0x00000200,0x00000000,0x08020008,
+0x08000208,0x00020000,0x08000000,0x08020208, 0x00000008,0x00020208,0x00020200,0x08000008,
+0x08020000,0x08000208,0x00000208,0x08020000, 0x00020208,0x00000008,0x08020008,0x00020200},
+{
+0x00802001,0x00002081,0x00002081,0x00000080, 0x00802080,0x00800081,0x00800001,0x00002001,
+0x00000000,0x00802000,0x00802000,0x00802081, 0x00000081,0x00000000,0x00800080,0x00800001,
+0x00000001,0x00002000,0x00800000,0x00802001, 0x00000080,0x00800000,0x00002001,0x00002080,
+0x00800081,0x00000001,0x00002080,0x00800080, 0x00002000,0x00802080,0x00802081,0x00000081,
+0x00800080,0x00800001,0x00802000,0x00802081, 0x00000081,0x00000000,0x00000000,0x00802000,
+0x00002080,0x00800080,0x00800081,0x00000001, 0x00802001,0x00002081,0x00002081,0x00000080,
+0x00802081,0x00000081,0x00000001,0x00002000, 0x00800001,0x00002001,0x00802080,0x00800081,
+0x00002001,0x00002080,0x00800000,0x00802001, 0x00000080,0x00800000,0x00002000,0x00802080},
+{
+0x00000100,0x02080100,0x02080000,0x42000100, 0x00080000,0x00000100,0x40000000,0x02080000,
+0x40080100,0x00080000,0x02000100,0x40080100, 0x42000100,0x42080000,0x00080100,0x40000000,
+0x02000000,0x40080000,0x40080000,0x00000000, 0x40000100,0x42080100,0x42080100,0x02000100,
+0x42080000,0x40000100,0x00000000,0x42000000, 0x02080100,0x02000000,0x42000000,0x00080100,
+0x00080000,0x42000100,0x00000100,0x02000000, 0x40000000,0x02080000,0x42000100,0x40080100,
+0x02000100,0x40000000,0x42080000,0x02080100, 0x40080100,0x00000100,0x02000000,0x42080000,
+0x42080100,0x00080100,0x42000000,0x42080100, 0x02080000,0x00000000,0x40080000,0x42000000,
+0x00080100,0x02000100,0x40000100,0x00080000, 0x00000000,0x40080000,0x02080100,0x40000100},
+{
+0x20000010,0x20400000,0x00004000,0x20404010, 0x20400000,0x00000010,0x20404010,0x00400000,
+0x20004000,0x00404010,0x00400000,0x20000010, 0x00400010,0x20004000,0x20000000,0x00004010,
+0x00000000,0x00400010,0x20004010,0x00004000, 0x00404000,0x20004010,0x00000010,0x20400010,
+0x20400010,0x00000000,0x00404010,0x20404000, 0x00004010,0x00404000,0x20404000,0x20000000,
+0x20004000,0x00000010,0x20400010,0x00404000, 0x20404010,0x00400000,0x00004010,0x20000010,
+0x00400000,0x20004000,0x20000000,0x00004010, 0x20000010,0x20404010,0x00404000,0x20400000,
+0x00404010,0x20404000,0x00000000,0x20400010, 0x00000010,0x00004000,0x20400000,0x00404010,
+0x00004000,0x00400010,0x20004010,0x00000000, 0x20404000,0x20000000,0x00400010,0x20004010},
+{
+0x00200000,0x04200002,0x04000802,0x00000000, 0x00000800,0x04000802,0x00200802,0x04200800,
+0x04200802,0x00200000,0x00000000,0x04000002, 0x00000002,0x04000000,0x04200002,0x00000802,
+0x04000800,0x00200802,0x00200002,0x04000800, 0x04000002,0x04200000,0x04200800,0x00200002,
+0x04200000,0x00000800,0x00000802,0x04200802, 0x00200800,0x00000002,0x04000000,0x00200800,
+0x04000000,0x00200800,0x00200000,0x04000802, 0x04000802,0x04200002,0x04200002,0x00000002,
+0x00200002,0x04000000,0x04000800,0x00200000, 0x04200800,0x00000802,0x00200802,0x04200800,
+0x00000802,0x04000002,0x04200802,0x04200000, 0x00200800,0x00000000,0x00000002,0x04200802,
+0x00000000,0x00200802,0x04200000,0x00000800, 0x04000002,0x04000800,0x00000800,0x00200002},
+{
+0x10001040,0x00001000,0x00040000,0x10041040, 0x10000000,0x10001040,0x00000040,0x10000000,
+0x00040040,0x10040000,0x10041040,0x00041000, 0x10041000,0x00041040,0x00001000,0x00000040,
+0x10040000,0x10000040,0x10001000,0x00001040, 0x00041000,0x00040040,0x10040040,0x10041000,
+0x00001040,0x00000000,0x00000000,0x10040040, 0x10000040,0x10001000,0x00041040,0x00040000,
+0x00041040,0x00040000,0x10041000,0x00001000, 0x00000040,0x10040040,0x00001000,0x00041040,
+0x10001000,0x00000040,0x10000040,0x10040000, 0x10040040,0x10000000,0x00040000,0x10001040,
+0x00000000,0x10041040,0x00040040,0x10000040, 0x10040000,0x10001000,0x10001040,0x00000000,
+0x10041040,0x00041000,0x00041000,0x00001040, 0x00001040,0x00040040,0x10000000,0x10041000}
+};
+
+
+/* 32-bit permutation function P used on the output of the S-boxes */
+const TUint8 p32i[] = {
+	   16,  7, 20, 21,
+	   29, 12, 28, 17,
+		1, 15, 23, 26,
+		5, 18, 31, 10,
+		2,  8, 24, 14,
+	   32, 27,  3,  9,
+	   19, 13, 30,  6,
+	   22, 11,  4, 25
+};
+
+/* permuted choice table (key) */
+const TUint8 pc1[] = {
+	   57, 49, 41, 33, 25, 17,  9,
+		1, 58, 50, 42, 34, 26, 18,
+	   10,  2, 59, 51, 43, 35, 27,
+	   19, 11,  3, 60, 52, 44, 36,
+
+	   63, 55, 47, 39, 31, 23, 15,
+		7, 62, 54, 46, 38, 30, 22,
+	   14,  6, 61, 53, 45, 37, 29,
+	   21, 13,  5, 28, 20, 12,  4
+};
+
+/* number left rotations of pc1 */
+const TUint8 totrot[] = {1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28};
+
+/* permuted choice key (table) */
+const TUint8 pc2[] = {
+	   14, 17, 11, 24,  1,  5,
+		3, 28, 15,  6, 21, 10,
+	   23, 19, 12,  4, 26,  8,
+	   16,  7, 27, 20, 13,  2,
+	   41, 52, 31, 37, 47, 55,
+	   30, 40, 51, 45, 33, 48,
+	   44, 49, 39, 56, 34, 53,
+	   46, 42, 50, 36, 29, 32
+};
+}	//	namespace DES_TABLE
+#endif	//	__DESTABLES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/mstreamcipher.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,57 @@
+/*
+* Copyright (c) 2002-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: 
+* streamcipher.cpp
+*
+*/
+
+
+#include "streamcipher.h"
+#include <cryptopanic.h>
+
+EXPORT_C void CStreamCipher::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	Process(aInput, aOutput);
+	}
+
+EXPORT_C void CStreamCipher::Process(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TInt outputIndex = aOutput.Size();
+
+	// aOutput may already have outputIndex bytes of data in it
+	// check there will still be enough space to process the result
+	__ASSERT_DEBUG(aOutput.MaxLength() - outputIndex >= MaxOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	aOutput.Append(aInput);
+
+	TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, aInput.Size(),
+		aInput.Size());
+	DoProcess(transformBuf);
+	}
+
+EXPORT_C TInt CStreamCipher::BlockSize() const
+	{
+	return (1);
+	}
+
+EXPORT_C TInt CStreamCipher::MaxOutputLength(TInt aInputLength) const
+	{
+	return aInputLength;
+	}
+
+EXPORT_C TInt CStreamCipher::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	return aInputLength;
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/nullcipher.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,51 @@
+/*
+* Copyright (c) 2002-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 "nullcipher.h"
+
+const TUint KNullKeyBytes = 0;
+
+EXPORT_C CNullCipher* CNullCipher::NewL(void)
+	{
+	CNullCipher* self = new(ELeave)CNullCipher;
+	return self;
+	}
+
+EXPORT_C CNullCipher* CNullCipher::NewLC(void)
+	{
+	CNullCipher *self = NewL();
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+void CNullCipher::Reset(void)
+	{
+	}
+
+TInt CNullCipher::KeySize(void) const
+	{
+	return KNullKeyBytes;
+	}
+
+void CNullCipher::DoProcess(TDes8& /*aData*/)
+	{
+	}
+
+CNullCipher::CNullCipher(void)
+	{
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rc2.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,100 @@
+/*
+* Copyright (c) 2002-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 <rc2.h>
+#include "rc2shim.h"
+
+CRC2::CRC2()
+	{
+	}
+
+/* CRC2Encryptor */
+EXPORT_C CRC2Encryptor* CRC2Encryptor::NewL(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	return CRC2EncryptorShim::NewL(aKey, aEffectiveKeyLenBits);
+	}
+
+EXPORT_C CRC2Encryptor* CRC2Encryptor::NewLC(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	return CRC2EncryptorShim::NewLC(aKey, aEffectiveKeyLenBits);
+	}
+	
+CRC2Encryptor::CRC2Encryptor()
+	{
+	}
+
+/* CRC2Decryptor */
+EXPORT_C CRC2Decryptor* CRC2Decryptor::NewL(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	return CRC2DecryptorShim::NewL(aKey, aEffectiveKeyLenBits);
+	}
+
+EXPORT_C CRC2Decryptor* CRC2Decryptor::NewLC(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	return CRC2DecryptorShim::NewLC(aKey, aEffectiveKeyLenBits);
+	}
+
+CRC2Decryptor::CRC2Decryptor()
+	{	
+	}
+	
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TInt CRC2::BlockSize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	return 0;
+	}
+
+TInt CRC2::KeySize() const
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	return 0;
+	}
+	
+void CRC2::Reset()
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);			
+	}	
+	
+void CRC2::SetKey(const TDesC8& /*aKey*/, TInt /*aEffectiveKeyLenBits*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);				
+	}	
+
+void CRC2Decryptor::Transform(TDes8& /*aBlock*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);	
+	}		
+
+void CRC2Encryptor::Transform(TDes8& /*aBlock*/)
+	{
+	// Method replaced by shim 
+	ASSERT(EFalse);	
+	}	
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rc2shim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,204 @@
+/*
+* Copyright (c) 2006-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 "rc2shim.h"
+
+#include <cryptospi/cryptoparams.h>
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "keys.h"
+#include <cryptostrength.h>
+
+#include "../common/inlines.h"
+
+using namespace CryptoSpi;
+
+// CRC2EncryptorShim ////////////////////////////////////////////////////////
+CRC2EncryptorShim* CRC2EncryptorShim::NewL(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	CRC2EncryptorShim* self = CRC2EncryptorShim::NewLC(aKey, aEffectiveKeyLenBits);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRC2EncryptorShim* CRC2EncryptorShim::NewLC(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	CRC2EncryptorShim* self = new (ELeave) CRC2EncryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aEffectiveKeyLenBits);
+	// weak enough if either aKey or aEffectiveKeyLenBits is weak
+	TInt minKeySize = Min(aEffectiveKeyLenBits, BytesToBits(aKey.Size()));
+	TCrypto::IsSymmetricWeakEnoughL(minKeySize);
+	return self;
+	}
+
+CRC2EncryptorShim::CRC2EncryptorShim()
+	{
+	}
+
+CRC2EncryptorShim::~CRC2EncryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;	
+	delete iAlgorithmParams;
+	}	
+
+void CRC2EncryptorShim::ConstructL(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	TKeyProperty keyProperty = {KRc2Uid, KNullUid, KSymmetricKeyUid, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	
+	iAlgorithmParams = CCryptoParams::NewL();
+	iAlgorithmParams->AddL(aEffectiveKeyLenBits, KRC2EffectiveKeyLenBits);
+	
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+											iSymmetricCipherImpl,
+											KRc2Uid,
+											*iKey,
+											KCryptoModeEncryptUid,
+											KOperationModeECBUid,
+											KPaddingModeNoneUid,
+											iAlgorithmParams);
+	}		
+
+TInt CRC2EncryptorShim::BlockSize() const
+	{
+	// SPI returns block size in BITS
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}	
+
+TInt CRC2EncryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void CRC2EncryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;
+	}
+
+void CRC2EncryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}	
+
+TInt CRC2EncryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}	
+
+// CRC2DecryptorShim ////////////////////////////////////////////////////////
+CRC2DecryptorShim* CRC2DecryptorShim::NewL(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	CRC2DecryptorShim* self = CRC2DecryptorShim::NewLC(aKey, aEffectiveKeyLenBits);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+CRC2DecryptorShim* CRC2DecryptorShim::NewLC(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	CRC2DecryptorShim* self = new (ELeave) CRC2DecryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aEffectiveKeyLenBits);
+	// weak enough if either aKey or aEffectiveKeyLenBits is weak
+	TInt minKeySize = Min(aEffectiveKeyLenBits, BytesToBits(aKey.Size()));
+	TCrypto::IsSymmetricWeakEnoughL(minKeySize);
+	return self;
+	}
+
+CRC2DecryptorShim::CRC2DecryptorShim()
+	{	
+	}
+
+CRC2DecryptorShim::~CRC2DecryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;
+	delete iAlgorithmParams;			
+	}
+
+
+void CRC2DecryptorShim::ConstructL(const TDesC8& aKey, TInt aEffectiveKeyLenBits)
+	{
+	TKeyProperty keyProperty = {KRc2Uid, KNullUid, KSymmetricKeyUid, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+
+	iAlgorithmParams = CCryptoParams::NewL();
+	iAlgorithmParams->AddL(aEffectiveKeyLenBits, KRC2EffectiveKeyLenBits);
+	
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+												iSymmetricCipherImpl,
+												KRc2Uid,
+												*iKey,
+												KCryptoModeDecryptUid,
+												KOperationModeECBUid,
+												KPaddingModeNoneUid,
+												iAlgorithmParams);	
+	}	
+
+TInt CRC2DecryptorShim::BlockSize() const
+	{
+	// SPI returns block size in BITS
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CRC2DecryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void CRC2DecryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();	
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;	
+	}
+
+void CRC2DecryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+
+TInt CRC2DecryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rc2shim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,154 @@
+/*
+* Copyright (c) 2006-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: 
+* RC2 shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RC2SHIM_H__
+#define __RC2SHIM_H__
+
+#include <rc2.h>
+
+namespace CryptoSpi
+	{
+	class CCryptoParams;
+	class CSymmetricCipher;
+	class CKey;
+	}
+	
+NONSHARABLE_CLASS(CRC2EncryptorShim) : public CRC2Encryptor
+{
+public:
+	/**
+	Creates an CRC2EncryptorShim object which has the same interface
+	as RC2 Encryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The encryption key
+	@return A pointer to a CRC2EncryptorShim instance
+	*/
+	static CRC2EncryptorShim* NewL(const TDesC8& aKey, TInt aEffectiveKeyLenBits);
+	
+	/**
+	Creates an CRC2EncryptorShim object which has the same interface
+	as RC2 Encryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The encryption key
+	@return A pointer to a CRC2EncryptorShim instance
+	*/
+	static CRC2EncryptorShim* NewLC(const TDesC8& aKey, TInt aEffectiveKeyLenBits);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~CRC2EncryptorShim();
+		
+private:
+	/// Constructor
+	CRC2EncryptorShim();
+	void ConstructL(const TDesC8& aKey, TInt aEffectiveKeyLenBits);	
+	
+	// From CBase
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// RC2 uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+	
+	/// The effective key length is passed as an algorithm
+	/// parameter. This allows it to be externalised.
+	CryptoSpi::CCryptoParams* iAlgorithmParams;	
+};
+
+NONSHARABLE_CLASS(CRC2DecryptorShim) : public CRC2Decryptor
+{
+public:
+	/**
+	Creates an CRC2DecryptorShim object which has the same interface
+	as RC2 Decryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The decryption key
+	@return A pointer to a CRC2DecryptorShim instance
+	*/
+	static CRC2DecryptorShim* NewL(const TDesC8& aKey, TInt aEffectiveKeyLenBits);
+	
+	/**
+	Creates an CRC2DecryptorShim object which has the same interface
+	as RC2 Decryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The decryption key
+	@return A pointer to a CRC2DecryptorShim instance
+	*/
+	static CRC2DecryptorShim* NewLC(const TDesC8& aKey, TInt aEffectiveKeyLenBits);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~CRC2DecryptorShim();
+	
+private:
+	/// Constructor	
+	CRC2DecryptorShim();	
+	void ConstructL(const TDesC8& aKey, TInt aEffectiveKeyLenBits);	
+	
+	/**
+	From CBase, to allow CBufferedTransform & CBlockChainingMode
+	to determine whether the functionality may be delegated to
+	the SPI object.
+	*/ 
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// RC2 uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+	
+	/// The effective key length is passed as an algorithm
+	/// parameter. This allows it to be externalised.
+	CryptoSpi::CCryptoParams* iAlgorithmParams;
+};
+
+#endif // __RC2SHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rc2table.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2002-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: 
+* RC2 Table
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent 
+*/
+ 
+#ifndef __RC2TABLES_H__
+#define __RC2TABLES_H__
+
+#include <e32std.h>
+
+namespace RC2_TABLE
+{
+	const TUint8 PITABLE[256] = 
+	{
+		217,120,249,196, 25,221,181,237, 40,233,253,121, 74,160,216,157,
+		198,126, 55,131, 43,118, 83,142, 98, 76,100,136, 68,139,251,162,
+		 23,154, 89,245,135,179, 79, 19, 97, 69,109,141,  9,129,125, 50,
+		189,143, 64,235,134,183,123, 11,240,149, 33, 34, 92,107, 78,130,
+		 84,214,101,147,206, 96,178, 28,115, 86,192, 20,167,140,241,220,
+		 18,117,202, 31, 59,190,228,209, 66, 61,212, 48,163, 60,182, 38,
+		111,191, 14,218, 70,105,  7, 87, 39,242, 29,155,188,148, 67,  3,
+		248, 17,199,246,144,239, 62,231,  6,195,213, 47,200,102, 30,215,
+		  8,232,234,222,128, 82,238,247,132,170,114,172, 53, 77,106, 42,
+		150, 26,210,113, 90, 21, 73,116, 75,159,208, 94,  4, 24,164,236,
+		194,224, 65,110, 15, 81,203,204, 36,145,175, 80,161,244,112, 57,
+		153,124, 58,133, 35,184,180,122,252,  2, 54, 91, 37, 85,151, 49,
+		 45, 93,250,152,227,138,146,174,  5,223, 41, 16,103,108,186,201,
+		211,  0,230,207,225,158,168, 44, 99, 22,  1, 63, 88,226,137,169,
+		 13, 56, 52, 27,171, 51,255,176,187, 72, 12, 95,185,177,205, 46,
+		197,243,219, 71,229,165,156,119, 10,166, 32,104,254,127,193,173
+	};
+}
+	//	namespace RC2_TABLE
+#endif	//	__RC2TABLES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rijndael.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,225 @@
+/*
+* Copyright (c) 2002-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 "rijndael.h"
+#include "rijndaelshim.h"
+#include "rijndaeltables.h"
+#include "../common/inlines.h"
+#include <cryptostrength.h>
+
+const TUint KAESKeyBytes128 = 16;
+const TUint KAESKeyBytes192 = 24;
+const TUint KAESKeyBytes256 = 32;
+const TUint KAESBlockBytes = 16;
+
+/* CRijndael */
+EXPORT_C CRijndael::CRijndael(void)
+	{
+	}
+
+void CRijndael::Reset()
+	{
+	// CRijndael is externally derivable. Don't delete this code
+	SetKey(*iKey);
+	}
+
+TInt CRijndael::KeySize() const
+	{
+	// CRijndael is externally derivable. Don't delete this code
+	return (4*(iRounds+1));
+	}
+
+EXPORT_C CRijndael::~CRijndael()
+	{
+	// CRijndael is externally derivable. Don't delete this code
+	delete iKey;
+	}
+
+void CRijndael::ConstructL(const TDesC8& aKey)
+	{
+	// CRijndael is externally derivable. Don't delete this code
+	TUint keySize = aKey.Size();
+	assert((keySize==KAESKeyBytes128)||(keySize==KAESKeyBytes192)||(keySize==KAESKeyBytes256));
+	iKey = aKey.AllocL();
+	iRounds = keySize/4 + 6;
+	SetKey(aKey);
+	}
+
+void CRijndael::SetKey(const TDesC8& aKey)
+	{
+	// CRijndael is externally derivable. Don't delete this code
+	TUint keySize = aKey.Size();
+	TUint32 temp; 
+	TUint32* rk = &iK[0];
+
+	TUint i = 0;
+
+	GetUserKeyBigEndian(rk, keySize/4, &aKey[0], keySize);
+
+	switch(keySize)
+		{
+		case (KAESKeyBytes128):
+			{
+			FOREVER
+				{
+				temp  = rk[3];
+				rk[4] = rk[0] ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
+					RIJNDAEL_TABLE::rcon[i];
+				rk[5] = rk[1] ^ rk[4];
+				rk[6] = rk[2] ^ rk[5];
+				rk[7] = rk[3] ^ rk[6];
+				if (++i == 10)
+					break;
+				rk += 4;
+				}
+			}
+		break;
+
+		case (KAESKeyBytes192):
+			{
+			FOREVER
+				{
+				temp = rk[ 5];
+				rk[ 6] = rk[ 0] ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
+					RIJNDAEL_TABLE::rcon[i];
+				rk[ 7] = rk[ 1] ^ rk[ 6];
+				rk[ 8] = rk[ 2] ^ rk[ 7];
+				rk[ 9] = rk[ 3] ^ rk[ 8];
+				if (++i == 8)
+					break;
+				rk[10] = rk[ 4] ^ rk[ 9];
+				rk[11] = rk[ 5] ^ rk[10];
+				rk += 6;
+				}
+			}
+		break;
+
+		case (KAESKeyBytes256):
+			{
+			FOREVER
+				{
+        		temp = rk[ 7];
+        		rk[ 8] = rk[ 0] ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
+        			RIJNDAEL_TABLE::rcon[i];
+        		rk[ 9] = rk[ 1] ^ rk[ 8];
+        		rk[10] = rk[ 2] ^ rk[ 9];
+        		rk[11] = rk[ 3] ^ rk[10];
+				if (++i == 7)
+					break;
+        		temp = rk[11];
+        		rk[12] = rk[ 4] ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0xff000000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0x00ff0000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x0000ff00) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x000000ff);
+        		rk[13] = rk[ 5] ^ rk[12];
+        		rk[14] = rk[ 6] ^ rk[13];
+        		rk[15] = rk[ 7] ^ rk[14];
+
+				rk += 8;
+				}
+			}
+		break;
+
+		default:
+			assert(0);	//	Shouldn't get here, keeps compiler happy
+		}
+	}
+
+
+/* CAESEncryptor */
+EXPORT_C CAESEncryptor* CAESEncryptor::NewL(const TDesC8& aKey)
+	{
+	return CAESEncryptorShim::NewL(aKey);
+	}
+
+EXPORT_C CAESEncryptor* CAESEncryptor::NewLC(const TDesC8& aKey)
+	{
+	return CAESEncryptorShim::NewLC(aKey);
+	}
+
+CAESEncryptor::CAESEncryptor()
+	{
+	}
+
+/* CAESDecryptor */
+EXPORT_C CAESDecryptor* CAESDecryptor::NewL(const TDesC8& aKey)
+	{
+	return CAESDecryptorShim::NewL(aKey);
+	}
+
+EXPORT_C CAESDecryptor* CAESDecryptor::NewLC(const TDesC8& aKey)
+	{
+	return CAESDecryptorShim::NewLC(aKey);
+	}
+
+CAESDecryptor::CAESDecryptor()
+	{	
+	}
+
+// All these methods have been replaced by the shim
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TInt CAESDecryptor::BlockSize() const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return 0;
+	}
+
+void CAESDecryptor::Transform(TDes8& /*aBlock*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);	
+	}
+
+void CAESDecryptor::SetKey(const TDesC8& /*aKey*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	}
+
+TInt CAESEncryptor::BlockSize() const
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);
+	return KAESBlockBytes;
+	}
+
+void CAESEncryptor::Transform(TDes8& /*aBlock*/)
+	{
+	// Method replaced by shim
+	ASSERT(EFalse);		
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rijndaelshim.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,187 @@
+/*
+* Copyright (c) 2006-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 "rijndaelshim.h"
+
+#include "cryptosymmetriccipherapi.h"
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "keys.h"
+#include <cryptostrength.h>
+
+#include "../common/inlines.h"
+
+using namespace CryptoSpi;
+
+// CAESEncryptorShim ////////////////////////////////////////////////////////
+CAESEncryptorShim* CAESEncryptorShim::NewL(const TDesC8& aKey)
+	{
+	CAESEncryptorShim* self = CAESEncryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CAESEncryptorShim* CAESEncryptorShim::NewLC(const TDesC8& aKey)
+	{
+	CAESEncryptorShim* self = new (ELeave) CAESEncryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()));
+	return self;
+	}
+
+CAESEncryptorShim::CAESEncryptorShim()
+	{
+	}
+
+CAESEncryptorShim::~CAESEncryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;
+	}	
+
+void CAESEncryptorShim::ConstructL(const TDesC8& aKey)
+	{
+	TKeyProperty keyProperty = {KAesUid, KNullUid, KSymmetricKeyUid, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+												iSymmetricCipherImpl,
+												KAesUid,
+												*iKey,
+												KCryptoModeEncryptUid,
+												KOperationModeECBUid,
+												KPaddingModeNoneUid,
+												NULL);
+	}		
+
+TInt CAESEncryptorShim::BlockSize() const
+	{
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}	
+
+TInt CAESEncryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void CAESEncryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;
+	}
+
+void CAESEncryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}	
+
+TInt CAESEncryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}	
+
+// CAESDecryptorShim ////////////////////////////////////////////////////////		
+
+CAESDecryptorShim* CAESDecryptorShim::NewL(const TDesC8& aKey)
+	{
+	CAESDecryptorShim* self = CAESDecryptorShim::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+CAESDecryptorShim* CAESDecryptorShim::NewLC(const TDesC8& aKey)
+	{
+	CAESDecryptorShim* self = new (ELeave) CAESDecryptorShim();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(aKey.Size()));
+	return self;
+	}
+
+CAESDecryptorShim::CAESDecryptorShim()
+	{	
+	}
+
+CAESDecryptorShim::~CAESDecryptorShim()
+	{
+	delete iSymmetricCipherImpl;
+	delete iKey;			
+	}
+
+void CAESDecryptorShim::ConstructL(const TDesC8& aKey)
+	{
+	TKeyProperty keyProperty = {KAesUid, KNullUid, KSymmetricKeyUid, KNonEmbeddedKeyUid};
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+	keyParam->AddL(aKey, KSymmetricKeyParameterUid);
+	iKey=CKey::NewL(keyProperty, *keyParam);
+	CleanupStack::PopAndDestroy(keyParam);
+	CSymmetricCipherFactory::CreateSymmetricCipherL(
+												iSymmetricCipherImpl,
+												KAesUid,
+												*iKey,
+												KCryptoModeDecryptUid,
+												KOperationModeECBUid,
+												KPaddingModeNoneUid,
+												NULL);	
+	}	
+
+TInt CAESDecryptorShim::BlockSize() const
+	{
+	return BitsToBytes(iSymmetricCipherImpl->BlockSize());
+	}
+	
+TInt CAESDecryptorShim::KeySize() const
+	{
+	return iSymmetricCipherImpl->KeySize();
+	}	
+
+void CAESDecryptorShim::Transform(TDes8& aBlock)
+	{
+	iOutputBlock.Zero();	
+	TRAP_IGNORE(iSymmetricCipherImpl->ProcessL(aBlock, iOutputBlock);)
+	aBlock = iOutputBlock;	
+	}
+
+void CAESDecryptorShim::Reset()
+	{
+	iSymmetricCipherImpl->Reset();
+	}
+
+TInt CAESDecryptorShim::Extension_(TUint aExtensionId, TAny*& a0, TAny* /*a1*/)
+	{
+	TInt ret(KErrExtensionNotSupported);
+	
+	if (CryptoSpi::KSymmetricCipherInterface == aExtensionId && iSymmetricCipherImpl)
+		{
+		a0=iSymmetricCipherImpl;
+		ret=KErrNone;	
+		}		
+	return ret;
+	}		
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rijndaelshim.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,145 @@
+/*
+* Copyright (c) 2006-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: 
+* rijndael shim classes definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RIJNDAELSHIM_H__
+#define __RIJNDAELSHIM_H__
+
+#include <rijndael.h>
+
+namespace CryptoSpi
+	{
+	class CSymmetricCipher;
+	class CKey;
+	}
+	
+NONSHARABLE_CLASS(CAESEncryptorShim) : public CAESEncryptor
+{
+public:
+	/**
+	Creates an CAESEncryptorShim object which has the same interface
+	as AESEncryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The encryption key
+	@return A pointer to a CAESEncryptorShim instance
+	*/
+	static CAESEncryptorShim* NewL(const TDesC8& aKey);
+	
+	/**
+	Creates an CAESEncryptorShim object which has the same interface
+	as AESEncryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The encryption key
+	@return A pointer to a CAESEncryptorShim instance
+	*/
+	static CAESEncryptorShim* NewLC(const TDesC8& aKey);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~CAESEncryptorShim();
+		
+private:
+	/// Constructor
+	CAESEncryptorShim();
+	void ConstructL(const TDesC8& aKey);	
+	
+	// From CBase
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// AES uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+};
+
+NONSHARABLE_CLASS(CAESDecryptorShim) : public CAESDecryptor
+{
+public:
+	/**
+	Creates an CAESDecryptorShim object which has the same interface
+	as AESDecryptor but delegates all work to a Crypto SPI plug-in.
+	
+	@param aKey The decryption key
+	@return A pointer to a CAESDecryptorShim instance
+	*/
+	static CAESDecryptorShim* NewL(const TDesC8& aKey);
+	
+	/**
+	Creates an CAESDecryptorShim object which has the same interface
+	as AESDecryptor but delegates all work to a Crypto SPI plug-in.
+	
+	A pointer to the new object is placed on the cleanup stack
+	
+	@param aKey The decryption key
+	@return A pointer to a CAESDecryptorShim instance
+	*/
+	static CAESDecryptorShim* NewLC(const TDesC8& aKey);
+	
+	// From CBlockTransform
+	TInt BlockSize() const;
+	void Transform(TDes8& aBlock);
+	void Reset(void);
+	TInt KeySize(void) const;
+	
+	/// Destructor
+	~CAESDecryptorShim();
+	
+private:
+	/// Constructor	
+	CAESDecryptorShim();	
+	void ConstructL(const TDesC8& aKey);	
+	
+	/**
+	From CBase, to allow CBufferedTransform & CBlockChainingMode
+	to determine whether the functionality may be delegated to
+	the SPI object.
+	*/ 
+	TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
+	
+private:	
+	/// SPI delegate
+	CryptoSpi::CSymmetricCipher* iSymmetricCipherImpl;
+		
+	/// SPI requires all key to passed as key-objects
+	CryptoSpi::CKey* iKey;		
+	
+	/// Temporary output block, SPI does not overwrite input
+	/// AES uses 64bit blocks
+	TBuf8<16> iOutputBlock;
+};
+
+#endif // __RIJNDAELSHIM_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/source/symmetric/rijndaeltables.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,723 @@
+/*
+* Copyright (c) 2002-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: 
+* Rijndael Tables
+*
+*/
+
+
+/**
+ @file 
+ @internalComponent 
+*/
+ 
+#ifndef __RIJNDAELTABLES_H__
+#define __RIJNDAELTABLES_H__
+
+#include <e32std.h>
+
+namespace RIJNDAEL_TABLE
+{
+
+/*
+Te0[x] = S [x].[02, 01, 01, 03];
+Te1[x] = S [x].[03, 02, 01, 01];
+Te2[x] = S [x].[01, 03, 02, 01];
+Te3[x] = S [x].[01, 01, 03, 02];
+Te4[x] = S [x].[01, 01, 01, 01];
+
+Td0[x] = Si[x].[0e, 09, 0d, 0b];
+Td1[x] = Si[x].[0b, 0e, 09, 0d];
+Td2[x] = Si[x].[0d, 0b, 0e, 09];
+Td3[x] = Si[x].[09, 0d, 0b, 0e];
+Td4[x] = Si[x].[01, 01, 01, 01];
+*/
+
+const TUint32 Te0[256] = {
+    0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
+    0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,
+    0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,
+    0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,
+    0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,
+    0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,
+    0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,
+    0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,
+    0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,
+    0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,
+    0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,
+    0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,
+    0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,
+    0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,
+    0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,
+    0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,
+    0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,
+    0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,
+    0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,
+    0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,
+    0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,
+    0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,
+    0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,
+    0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,
+    0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,
+    0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,
+    0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,
+    0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,
+    0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,
+    0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,
+    0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,
+    0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,
+    0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,
+    0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,
+    0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,
+    0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,
+    0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,
+    0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,
+    0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,
+    0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,
+    0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,
+    0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,
+    0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,
+    0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,
+    0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,
+    0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,
+    0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,
+    0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,
+    0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,
+    0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,
+    0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,
+    0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,
+    0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,
+    0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,
+    0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,
+    0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,
+    0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,
+    0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,
+    0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,
+    0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,
+    0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,
+    0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,
+    0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
+    0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
+};
+const TUint32 Te1[256] = {
+    0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,
+    0x0dfff2f2U, 0xbdd66b6bU, 0xb1de6f6fU, 0x5491c5c5U,
+    0x50603030U, 0x03020101U, 0xa9ce6767U, 0x7d562b2bU,
+    0x19e7fefeU, 0x62b5d7d7U, 0xe64dababU, 0x9aec7676U,
+    0x458fcacaU, 0x9d1f8282U, 0x4089c9c9U, 0x87fa7d7dU,
+    0x15effafaU, 0xebb25959U, 0xc98e4747U, 0x0bfbf0f0U,
+    0xec41adadU, 0x67b3d4d4U, 0xfd5fa2a2U, 0xea45afafU,
+    0xbf239c9cU, 0xf753a4a4U, 0x96e47272U, 0x5b9bc0c0U,
+    0xc275b7b7U, 0x1ce1fdfdU, 0xae3d9393U, 0x6a4c2626U,
+    0x5a6c3636U, 0x417e3f3fU, 0x02f5f7f7U, 0x4f83ccccU,
+    0x5c683434U, 0xf451a5a5U, 0x34d1e5e5U, 0x08f9f1f1U,
+    0x93e27171U, 0x73abd8d8U, 0x53623131U, 0x3f2a1515U,
+    0x0c080404U, 0x5295c7c7U, 0x65462323U, 0x5e9dc3c3U,
+    0x28301818U, 0xa1379696U, 0x0f0a0505U, 0xb52f9a9aU,
+    0x090e0707U, 0x36241212U, 0x9b1b8080U, 0x3ddfe2e2U,
+    0x26cdebebU, 0x694e2727U, 0xcd7fb2b2U, 0x9fea7575U,
+    0x1b120909U, 0x9e1d8383U, 0x74582c2cU, 0x2e341a1aU,
+    0x2d361b1bU, 0xb2dc6e6eU, 0xeeb45a5aU, 0xfb5ba0a0U,
+    0xf6a45252U, 0x4d763b3bU, 0x61b7d6d6U, 0xce7db3b3U,
+    0x7b522929U, 0x3edde3e3U, 0x715e2f2fU, 0x97138484U,
+    0xf5a65353U, 0x68b9d1d1U, 0x00000000U, 0x2cc1ededU,
+    0x60402020U, 0x1fe3fcfcU, 0xc879b1b1U, 0xedb65b5bU,
+    0xbed46a6aU, 0x468dcbcbU, 0xd967bebeU, 0x4b723939U,
+    0xde944a4aU, 0xd4984c4cU, 0xe8b05858U, 0x4a85cfcfU,
+    0x6bbbd0d0U, 0x2ac5efefU, 0xe54faaaaU, 0x16edfbfbU,
+    0xc5864343U, 0xd79a4d4dU, 0x55663333U, 0x94118585U,
+    0xcf8a4545U, 0x10e9f9f9U, 0x06040202U, 0x81fe7f7fU,
+    0xf0a05050U, 0x44783c3cU, 0xba259f9fU, 0xe34ba8a8U,
+    0xf3a25151U, 0xfe5da3a3U, 0xc0804040U, 0x8a058f8fU,
+    0xad3f9292U, 0xbc219d9dU, 0x48703838U, 0x04f1f5f5U,
+    0xdf63bcbcU, 0xc177b6b6U, 0x75afdadaU, 0x63422121U,
+    0x30201010U, 0x1ae5ffffU, 0x0efdf3f3U, 0x6dbfd2d2U,
+    0x4c81cdcdU, 0x14180c0cU, 0x35261313U, 0x2fc3ececU,
+    0xe1be5f5fU, 0xa2359797U, 0xcc884444U, 0x392e1717U,
+    0x5793c4c4U, 0xf255a7a7U, 0x82fc7e7eU, 0x477a3d3dU,
+    0xacc86464U, 0xe7ba5d5dU, 0x2b321919U, 0x95e67373U,
+    0xa0c06060U, 0x98198181U, 0xd19e4f4fU, 0x7fa3dcdcU,
+    0x66442222U, 0x7e542a2aU, 0xab3b9090U, 0x830b8888U,
+    0xca8c4646U, 0x29c7eeeeU, 0xd36bb8b8U, 0x3c281414U,
+    0x79a7dedeU, 0xe2bc5e5eU, 0x1d160b0bU, 0x76addbdbU,
+    0x3bdbe0e0U, 0x56643232U, 0x4e743a3aU, 0x1e140a0aU,
+    0xdb924949U, 0x0a0c0606U, 0x6c482424U, 0xe4b85c5cU,
+    0x5d9fc2c2U, 0x6ebdd3d3U, 0xef43acacU, 0xa6c46262U,
+    0xa8399191U, 0xa4319595U, 0x37d3e4e4U, 0x8bf27979U,
+    0x32d5e7e7U, 0x438bc8c8U, 0x596e3737U, 0xb7da6d6dU,
+    0x8c018d8dU, 0x64b1d5d5U, 0xd29c4e4eU, 0xe049a9a9U,
+    0xb4d86c6cU, 0xfaac5656U, 0x07f3f4f4U, 0x25cfeaeaU,
+    0xafca6565U, 0x8ef47a7aU, 0xe947aeaeU, 0x18100808U,
+    0xd56fbabaU, 0x88f07878U, 0x6f4a2525U, 0x725c2e2eU,
+    0x24381c1cU, 0xf157a6a6U, 0xc773b4b4U, 0x5197c6c6U,
+    0x23cbe8e8U, 0x7ca1ddddU, 0x9ce87474U, 0x213e1f1fU,
+    0xdd964b4bU, 0xdc61bdbdU, 0x860d8b8bU, 0x850f8a8aU,
+    0x90e07070U, 0x427c3e3eU, 0xc471b5b5U, 0xaacc6666U,
+    0xd8904848U, 0x05060303U, 0x01f7f6f6U, 0x121c0e0eU,
+    0xa3c26161U, 0x5f6a3535U, 0xf9ae5757U, 0xd069b9b9U,
+    0x91178686U, 0x5899c1c1U, 0x273a1d1dU, 0xb9279e9eU,
+    0x38d9e1e1U, 0x13ebf8f8U, 0xb32b9898U, 0x33221111U,
+    0xbbd26969U, 0x70a9d9d9U, 0x89078e8eU, 0xa7339494U,
+    0xb62d9b9bU, 0x223c1e1eU, 0x92158787U, 0x20c9e9e9U,
+    0x4987ceceU, 0xffaa5555U, 0x78502828U, 0x7aa5dfdfU,
+    0x8f038c8cU, 0xf859a1a1U, 0x80098989U, 0x171a0d0dU,
+    0xda65bfbfU, 0x31d7e6e6U, 0xc6844242U, 0xb8d06868U,
+    0xc3824141U, 0xb0299999U, 0x775a2d2dU, 0x111e0f0fU,
+    0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,
+};
+const TUint32 Te2[256] = {
+    0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,
+    0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,
+    0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,
+    0xfe19e7feU, 0xd762b5d7U, 0xabe64dabU, 0x769aec76U,
+    0xca458fcaU, 0x829d1f82U, 0xc94089c9U, 0x7d87fa7dU,
+    0xfa15effaU, 0x59ebb259U, 0x47c98e47U, 0xf00bfbf0U,
+    0xadec41adU, 0xd467b3d4U, 0xa2fd5fa2U, 0xafea45afU,
+    0x9cbf239cU, 0xa4f753a4U, 0x7296e472U, 0xc05b9bc0U,
+    0xb7c275b7U, 0xfd1ce1fdU, 0x93ae3d93U, 0x266a4c26U,
+    0x365a6c36U, 0x3f417e3fU, 0xf702f5f7U, 0xcc4f83ccU,
+    0x345c6834U, 0xa5f451a5U, 0xe534d1e5U, 0xf108f9f1U,
+    0x7193e271U, 0xd873abd8U, 0x31536231U, 0x153f2a15U,
+    0x040c0804U, 0xc75295c7U, 0x23654623U, 0xc35e9dc3U,
+    0x18283018U, 0x96a13796U, 0x050f0a05U, 0x9ab52f9aU,
+    0x07090e07U, 0x12362412U, 0x809b1b80U, 0xe23ddfe2U,
+    0xeb26cdebU, 0x27694e27U, 0xb2cd7fb2U, 0x759fea75U,
+    0x091b1209U, 0x839e1d83U, 0x2c74582cU, 0x1a2e341aU,
+    0x1b2d361bU, 0x6eb2dc6eU, 0x5aeeb45aU, 0xa0fb5ba0U,
+    0x52f6a452U, 0x3b4d763bU, 0xd661b7d6U, 0xb3ce7db3U,
+    0x297b5229U, 0xe33edde3U, 0x2f715e2fU, 0x84971384U,
+    0x53f5a653U, 0xd168b9d1U, 0x00000000U, 0xed2cc1edU,
+    0x20604020U, 0xfc1fe3fcU, 0xb1c879b1U, 0x5bedb65bU,
+    0x6abed46aU, 0xcb468dcbU, 0xbed967beU, 0x394b7239U,
+    0x4ade944aU, 0x4cd4984cU, 0x58e8b058U, 0xcf4a85cfU,
+    0xd06bbbd0U, 0xef2ac5efU, 0xaae54faaU, 0xfb16edfbU,
+    0x43c58643U, 0x4dd79a4dU, 0x33556633U, 0x85941185U,
+    0x45cf8a45U, 0xf910e9f9U, 0x02060402U, 0x7f81fe7fU,
+    0x50f0a050U, 0x3c44783cU, 0x9fba259fU, 0xa8e34ba8U,
+    0x51f3a251U, 0xa3fe5da3U, 0x40c08040U, 0x8f8a058fU,
+    0x92ad3f92U, 0x9dbc219dU, 0x38487038U, 0xf504f1f5U,
+    0xbcdf63bcU, 0xb6c177b6U, 0xda75afdaU, 0x21634221U,
+    0x10302010U, 0xff1ae5ffU, 0xf30efdf3U, 0xd26dbfd2U,
+    0xcd4c81cdU, 0x0c14180cU, 0x13352613U, 0xec2fc3ecU,
+    0x5fe1be5fU, 0x97a23597U, 0x44cc8844U, 0x17392e17U,
+    0xc45793c4U, 0xa7f255a7U, 0x7e82fc7eU, 0x3d477a3dU,
+    0x64acc864U, 0x5de7ba5dU, 0x192b3219U, 0x7395e673U,
+    0x60a0c060U, 0x81981981U, 0x4fd19e4fU, 0xdc7fa3dcU,
+    0x22664422U, 0x2a7e542aU, 0x90ab3b90U, 0x88830b88U,
+    0x46ca8c46U, 0xee29c7eeU, 0xb8d36bb8U, 0x143c2814U,
+    0xde79a7deU, 0x5ee2bc5eU, 0x0b1d160bU, 0xdb76addbU,
+    0xe03bdbe0U, 0x32566432U, 0x3a4e743aU, 0x0a1e140aU,
+    0x49db9249U, 0x060a0c06U, 0x246c4824U, 0x5ce4b85cU,
+    0xc25d9fc2U, 0xd36ebdd3U, 0xacef43acU, 0x62a6c462U,
+    0x91a83991U, 0x95a43195U, 0xe437d3e4U, 0x798bf279U,
+    0xe732d5e7U, 0xc8438bc8U, 0x37596e37U, 0x6db7da6dU,
+    0x8d8c018dU, 0xd564b1d5U, 0x4ed29c4eU, 0xa9e049a9U,
+    0x6cb4d86cU, 0x56faac56U, 0xf407f3f4U, 0xea25cfeaU,
+    0x65afca65U, 0x7a8ef47aU, 0xaee947aeU, 0x08181008U,
+    0xbad56fbaU, 0x7888f078U, 0x256f4a25U, 0x2e725c2eU,
+    0x1c24381cU, 0xa6f157a6U, 0xb4c773b4U, 0xc65197c6U,
+    0xe823cbe8U, 0xdd7ca1ddU, 0x749ce874U, 0x1f213e1fU,
+    0x4bdd964bU, 0xbddc61bdU, 0x8b860d8bU, 0x8a850f8aU,
+    0x7090e070U, 0x3e427c3eU, 0xb5c471b5U, 0x66aacc66U,
+    0x48d89048U, 0x03050603U, 0xf601f7f6U, 0x0e121c0eU,
+    0x61a3c261U, 0x355f6a35U, 0x57f9ae57U, 0xb9d069b9U,
+    0x86911786U, 0xc15899c1U, 0x1d273a1dU, 0x9eb9279eU,
+    0xe138d9e1U, 0xf813ebf8U, 0x98b32b98U, 0x11332211U,
+    0x69bbd269U, 0xd970a9d9U, 0x8e89078eU, 0x94a73394U,
+    0x9bb62d9bU, 0x1e223c1eU, 0x87921587U, 0xe920c9e9U,
+    0xce4987ceU, 0x55ffaa55U, 0x28785028U, 0xdf7aa5dfU,
+    0x8c8f038cU, 0xa1f859a1U, 0x89800989U, 0x0d171a0dU,
+    0xbfda65bfU, 0xe631d7e6U, 0x42c68442U, 0x68b8d068U,
+    0x41c38241U, 0x99b02999U, 0x2d775a2dU, 0x0f111e0fU,
+    0xb0cb7bb0U, 0x54fca854U, 0xbbd66dbbU, 0x163a2c16U,
+};
+
+const TUint32 Te3[256] = {
+    0x6363a5c6U, 0x7c7c84f8U, 0x777799eeU, 0x7b7b8df6U,
+    0xf2f20dffU, 0x6b6bbdd6U, 0x6f6fb1deU, 0xc5c55491U,
+    0x30305060U, 0x01010302U, 0x6767a9ceU, 0x2b2b7d56U,
+    0xfefe19e7U, 0xd7d762b5U, 0xababe64dU, 0x76769aecU,
+    0xcaca458fU, 0x82829d1fU, 0xc9c94089U, 0x7d7d87faU,
+    0xfafa15efU, 0x5959ebb2U, 0x4747c98eU, 0xf0f00bfbU,
+    0xadadec41U, 0xd4d467b3U, 0xa2a2fd5fU, 0xafafea45U,
+    0x9c9cbf23U, 0xa4a4f753U, 0x727296e4U, 0xc0c05b9bU,
+    0xb7b7c275U, 0xfdfd1ce1U, 0x9393ae3dU, 0x26266a4cU,
+    0x36365a6cU, 0x3f3f417eU, 0xf7f702f5U, 0xcccc4f83U,
+    0x34345c68U, 0xa5a5f451U, 0xe5e534d1U, 0xf1f108f9U,
+    0x717193e2U, 0xd8d873abU, 0x31315362U, 0x15153f2aU,
+    0x04040c08U, 0xc7c75295U, 0x23236546U, 0xc3c35e9dU,
+    0x18182830U, 0x9696a137U, 0x05050f0aU, 0x9a9ab52fU,
+    0x0707090eU, 0x12123624U, 0x80809b1bU, 0xe2e23ddfU,
+    0xebeb26cdU, 0x2727694eU, 0xb2b2cd7fU, 0x75759feaU,
+    0x09091b12U, 0x83839e1dU, 0x2c2c7458U, 0x1a1a2e34U,
+    0x1b1b2d36U, 0x6e6eb2dcU, 0x5a5aeeb4U, 0xa0a0fb5bU,
+    0x5252f6a4U, 0x3b3b4d76U, 0xd6d661b7U, 0xb3b3ce7dU,
+    0x29297b52U, 0xe3e33eddU, 0x2f2f715eU, 0x84849713U,
+    0x5353f5a6U, 0xd1d168b9U, 0x00000000U, 0xeded2cc1U,
+    0x20206040U, 0xfcfc1fe3U, 0xb1b1c879U, 0x5b5bedb6U,
+    0x6a6abed4U, 0xcbcb468dU, 0xbebed967U, 0x39394b72U,
+    0x4a4ade94U, 0x4c4cd498U, 0x5858e8b0U, 0xcfcf4a85U,
+    0xd0d06bbbU, 0xefef2ac5U, 0xaaaae54fU, 0xfbfb16edU,
+    0x4343c586U, 0x4d4dd79aU, 0x33335566U, 0x85859411U,
+    0x4545cf8aU, 0xf9f910e9U, 0x02020604U, 0x7f7f81feU,
+    0x5050f0a0U, 0x3c3c4478U, 0x9f9fba25U, 0xa8a8e34bU,
+    0x5151f3a2U, 0xa3a3fe5dU, 0x4040c080U, 0x8f8f8a05U,
+    0x9292ad3fU, 0x9d9dbc21U, 0x38384870U, 0xf5f504f1U,
+    0xbcbcdf63U, 0xb6b6c177U, 0xdada75afU, 0x21216342U,
+    0x10103020U, 0xffff1ae5U, 0xf3f30efdU, 0xd2d26dbfU,
+    0xcdcd4c81U, 0x0c0c1418U, 0x13133526U, 0xecec2fc3U,
+    0x5f5fe1beU, 0x9797a235U, 0x4444cc88U, 0x1717392eU,
+    0xc4c45793U, 0xa7a7f255U, 0x7e7e82fcU, 0x3d3d477aU,
+    0x6464acc8U, 0x5d5de7baU, 0x19192b32U, 0x737395e6U,
+    0x6060a0c0U, 0x81819819U, 0x4f4fd19eU, 0xdcdc7fa3U,
+    0x22226644U, 0x2a2a7e54U, 0x9090ab3bU, 0x8888830bU,
+    0x4646ca8cU, 0xeeee29c7U, 0xb8b8d36bU, 0x14143c28U,
+    0xdede79a7U, 0x5e5ee2bcU, 0x0b0b1d16U, 0xdbdb76adU,
+    0xe0e03bdbU, 0x32325664U, 0x3a3a4e74U, 0x0a0a1e14U,
+    0x4949db92U, 0x06060a0cU, 0x24246c48U, 0x5c5ce4b8U,
+    0xc2c25d9fU, 0xd3d36ebdU, 0xacacef43U, 0x6262a6c4U,
+    0x9191a839U, 0x9595a431U, 0xe4e437d3U, 0x79798bf2U,
+    0xe7e732d5U, 0xc8c8438bU, 0x3737596eU, 0x6d6db7daU,
+    0x8d8d8c01U, 0xd5d564b1U, 0x4e4ed29cU, 0xa9a9e049U,
+    0x6c6cb4d8U, 0x5656faacU, 0xf4f407f3U, 0xeaea25cfU,
+    0x6565afcaU, 0x7a7a8ef4U, 0xaeaee947U, 0x08081810U,
+    0xbabad56fU, 0x787888f0U, 0x25256f4aU, 0x2e2e725cU,
+    0x1c1c2438U, 0xa6a6f157U, 0xb4b4c773U, 0xc6c65197U,
+    0xe8e823cbU, 0xdddd7ca1U, 0x74749ce8U, 0x1f1f213eU,
+    0x4b4bdd96U, 0xbdbddc61U, 0x8b8b860dU, 0x8a8a850fU,
+    0x707090e0U, 0x3e3e427cU, 0xb5b5c471U, 0x6666aaccU,
+    0x4848d890U, 0x03030506U, 0xf6f601f7U, 0x0e0e121cU,
+    0x6161a3c2U, 0x35355f6aU, 0x5757f9aeU, 0xb9b9d069U,
+    0x86869117U, 0xc1c15899U, 0x1d1d273aU, 0x9e9eb927U,
+    0xe1e138d9U, 0xf8f813ebU, 0x9898b32bU, 0x11113322U,
+    0x6969bbd2U, 0xd9d970a9U, 0x8e8e8907U, 0x9494a733U,
+    0x9b9bb62dU, 0x1e1e223cU, 0x87879215U, 0xe9e920c9U,
+    0xcece4987U, 0x5555ffaaU, 0x28287850U, 0xdfdf7aa5U,
+    0x8c8c8f03U, 0xa1a1f859U, 0x89898009U, 0x0d0d171aU,
+    0xbfbfda65U, 0xe6e631d7U, 0x4242c684U, 0x6868b8d0U,
+    0x4141c382U, 0x9999b029U, 0x2d2d775aU, 0x0f0f111eU,
+    0xb0b0cb7bU, 0x5454fca8U, 0xbbbbd66dU, 0x16163a2cU,
+};
+
+const TUint32 Te4[256] = {
+    0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,
+    0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,
+    0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,
+    0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,
+    0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,
+    0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,
+    0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,
+    0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,
+    0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,
+    0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,
+    0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,
+    0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,
+    0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,
+    0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,
+    0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,
+    0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,
+    0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,
+    0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,
+    0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,
+    0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,
+    0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,
+    0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,
+    0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,
+    0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,
+    0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,
+    0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,
+    0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,
+    0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,
+    0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,
+    0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,
+    0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,
+    0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,
+    0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,
+    0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,
+    0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,
+    0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,
+    0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,
+    0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,
+    0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,
+    0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,
+    0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,
+    0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,
+    0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,
+    0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,
+    0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,
+    0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,
+    0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,
+    0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,
+    0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,
+    0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,
+    0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,
+    0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,
+    0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,
+    0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,
+    0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,
+    0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,
+    0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,
+    0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,
+    0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,
+    0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,
+    0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,
+    0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,
+    0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,
+    0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,
+};
+
+const TUint32 Td0[256] = {
+    0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,
+    0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,
+    0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,
+    0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,
+    0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,
+    0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,
+    0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,
+    0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,
+    0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,
+    0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,
+    0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,
+    0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,
+    0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,
+    0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,
+    0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,
+    0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,
+    0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,
+    0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,
+    0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,
+    0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,
+    0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,
+    0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,
+    0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,
+    0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,
+    0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,
+    0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,
+    0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,
+    0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,
+    0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,
+    0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,
+    0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,
+    0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,
+    0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,
+    0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,
+    0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,
+    0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,
+    0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,
+    0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,
+    0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,
+    0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,
+    0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,
+    0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,
+    0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,
+    0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,
+    0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,
+    0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,
+    0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,
+    0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,
+    0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,
+    0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,
+    0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,
+    0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,
+    0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,
+    0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,
+    0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,
+    0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,
+    0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,
+    0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,
+    0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,
+    0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,
+    0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,
+    0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,
+    0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,
+    0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,
+};
+
+const TUint32 Td1[256] = {
+    0x5051f4a7U, 0x537e4165U, 0xc31a17a4U, 0x963a275eU,
+    0xcb3bab6bU, 0xf11f9d45U, 0xabacfa58U, 0x934be303U,
+    0x552030faU, 0xf6ad766dU, 0x9188cc76U, 0x25f5024cU,
+    0xfc4fe5d7U, 0xd7c52acbU, 0x80263544U, 0x8fb562a3U,
+    0x49deb15aU, 0x6725ba1bU, 0x9845ea0eU, 0xe15dfec0U,
+    0x02c32f75U, 0x12814cf0U, 0xa38d4697U, 0xc66bd3f9U,
+    0xe7038f5fU, 0x9515929cU, 0xebbf6d7aU, 0xda955259U,
+    0x2dd4be83U, 0xd3587421U, 0x2949e069U, 0x448ec9c8U,
+    0x6a75c289U, 0x78f48e79U, 0x6b99583eU, 0xdd27b971U,
+    0xb6bee14fU, 0x17f088adU, 0x66c920acU, 0xb47dce3aU,
+    0x1863df4aU, 0x82e51a31U, 0x60975133U, 0x4562537fU,
+    0xe0b16477U, 0x84bb6baeU, 0x1cfe81a0U, 0x94f9082bU,
+    0x58704868U, 0x198f45fdU, 0x8794de6cU, 0xb7527bf8U,
+    0x23ab73d3U, 0xe2724b02U, 0x57e31f8fU, 0x2a6655abU,
+    0x07b2eb28U, 0x032fb5c2U, 0x9a86c57bU, 0xa5d33708U,
+    0xf2302887U, 0xb223bfa5U, 0xba02036aU, 0x5ced1682U,
+    0x2b8acf1cU, 0x92a779b4U, 0xf0f307f2U, 0xa14e69e2U,
+    0xcd65daf4U, 0xd50605beU, 0x1fd13462U, 0x8ac4a6feU,
+    0x9d342e53U, 0xa0a2f355U, 0x32058ae1U, 0x75a4f6ebU,
+    0x390b83ecU, 0xaa4060efU, 0x065e719fU, 0x51bd6e10U,
+    0xf93e218aU, 0x3d96dd06U, 0xaedd3e05U, 0x464de6bdU,
+    0xb591548dU, 0x0571c45dU, 0x6f0406d4U, 0xff605015U,
+    0x241998fbU, 0x97d6bde9U, 0xcc894043U, 0x7767d99eU,
+    0xbdb0e842U, 0x8807898bU, 0x38e7195bU, 0xdb79c8eeU,
+    0x47a17c0aU, 0xe97c420fU, 0xc9f8841eU, 0x00000000U,
+    0x83098086U, 0x48322bedU, 0xac1e1170U, 0x4e6c5a72U,
+    0xfbfd0effU, 0x560f8538U, 0x1e3daed5U, 0x27362d39U,
+    0x640a0fd9U, 0x21685ca6U, 0xd19b5b54U, 0x3a24362eU,
+    0xb10c0a67U, 0x0f9357e7U, 0xd2b4ee96U, 0x9e1b9b91U,
+    0x4f80c0c5U, 0xa261dc20U, 0x695a774bU, 0x161c121aU,
+    0x0ae293baU, 0xe5c0a02aU, 0x433c22e0U, 0x1d121b17U,
+    0x0b0e090dU, 0xadf28bc7U, 0xb92db6a8U, 0xc8141ea9U,
+    0x8557f119U, 0x4caf7507U, 0xbbee99ddU, 0xfda37f60U,
+    0x9ff70126U, 0xbc5c72f5U, 0xc544663bU, 0x345bfb7eU,
+    0x768b4329U, 0xdccb23c6U, 0x68b6edfcU, 0x63b8e4f1U,
+    0xcad731dcU, 0x10426385U, 0x40139722U, 0x2084c611U,
+    0x7d854a24U, 0xf8d2bb3dU, 0x11aef932U, 0x6dc729a1U,
+    0x4b1d9e2fU, 0xf3dcb230U, 0xec0d8652U, 0xd077c1e3U,
+    0x6c2bb316U, 0x99a970b9U, 0xfa119448U, 0x2247e964U,
+    0xc4a8fc8cU, 0x1aa0f03fU, 0xd8567d2cU, 0xef223390U,
+    0xc787494eU, 0xc1d938d1U, 0xfe8ccaa2U, 0x3698d40bU,
+    0xcfa6f581U, 0x28a57adeU, 0x26dab78eU, 0xa43fadbfU,
+    0xe42c3a9dU, 0x0d507892U, 0x9b6a5fccU, 0x62547e46U,
+    0xc2f68d13U, 0xe890d8b8U, 0x5e2e39f7U, 0xf582c3afU,
+    0xbe9f5d80U, 0x7c69d093U, 0xa96fd52dU, 0xb3cf2512U,
+    0x3bc8ac99U, 0xa710187dU, 0x6ee89c63U, 0x7bdb3bbbU,
+    0x09cd2678U, 0xf46e5918U, 0x01ec9ab7U, 0xa8834f9aU,
+    0x65e6956eU, 0x7eaaffe6U, 0x0821bccfU, 0xe6ef15e8U,
+    0xd9bae79bU, 0xce4a6f36U, 0xd4ea9f09U, 0xd629b07cU,
+    0xaf31a4b2U, 0x312a3f23U, 0x30c6a594U, 0xc035a266U,
+    0x37744ebcU, 0xa6fc82caU, 0xb0e090d0U, 0x1533a7d8U,
+    0x4af10498U, 0xf741ecdaU, 0x0e7fcd50U, 0x2f1791f6U,
+    0x8d764dd6U, 0x4d43efb0U, 0x54ccaa4dU, 0xdfe49604U,
+    0xe39ed1b5U, 0x1b4c6a88U, 0xb8c12c1fU, 0x7f466551U,
+    0x049d5eeaU, 0x5d018c35U, 0x73fa8774U, 0x2efb0b41U,
+    0x5ab3671dU, 0x5292dbd2U, 0x33e91056U, 0x136dd647U,
+    0x8c9ad761U, 0x7a37a10cU, 0x8e59f814U, 0x89eb133cU,
+    0xeecea927U, 0x35b761c9U, 0xede11ce5U, 0x3c7a47b1U,
+    0x599cd2dfU, 0x3f55f273U, 0x791814ceU, 0xbf73c737U,
+    0xea53f7cdU, 0x5b5ffdaaU, 0x14df3d6fU, 0x867844dbU,
+    0x81caaff3U, 0x3eb968c4U, 0x2c382434U, 0x5fc2a340U,
+    0x72161dc3U, 0x0cbce225U, 0x8b283c49U, 0x41ff0d95U,
+    0x7139a801U, 0xde080cb3U, 0x9cd8b4e4U, 0x906456c1U,
+    0x617bcb84U, 0x70d532b6U, 0x74486c5cU, 0x42d0b857U,
+};
+
+const TUint32 Td2[256] = {
+    0xa75051f4U, 0x65537e41U, 0xa4c31a17U, 0x5e963a27U,
+    0x6bcb3babU, 0x45f11f9dU, 0x58abacfaU, 0x03934be3U,
+    0xfa552030U, 0x6df6ad76U, 0x769188ccU, 0x4c25f502U,
+    0xd7fc4fe5U, 0xcbd7c52aU, 0x44802635U, 0xa38fb562U,
+    0x5a49deb1U, 0x1b6725baU, 0x0e9845eaU, 0xc0e15dfeU,
+    0x7502c32fU, 0xf012814cU, 0x97a38d46U, 0xf9c66bd3U,
+    0x5fe7038fU, 0x9c951592U, 0x7aebbf6dU, 0x59da9552U,
+    0x832dd4beU, 0x21d35874U, 0x692949e0U, 0xc8448ec9U,
+    0x896a75c2U, 0x7978f48eU, 0x3e6b9958U, 0x71dd27b9U,
+    0x4fb6bee1U, 0xad17f088U, 0xac66c920U, 0x3ab47dceU,
+    0x4a1863dfU, 0x3182e51aU, 0x33609751U, 0x7f456253U,
+    0x77e0b164U, 0xae84bb6bU, 0xa01cfe81U, 0x2b94f908U,
+    0x68587048U, 0xfd198f45U, 0x6c8794deU, 0xf8b7527bU,
+    0xd323ab73U, 0x02e2724bU, 0x8f57e31fU, 0xab2a6655U,
+    0x2807b2ebU, 0xc2032fb5U, 0x7b9a86c5U, 0x08a5d337U,
+    0x87f23028U, 0xa5b223bfU, 0x6aba0203U, 0x825ced16U,
+    0x1c2b8acfU, 0xb492a779U, 0xf2f0f307U, 0xe2a14e69U,
+    0xf4cd65daU, 0xbed50605U, 0x621fd134U, 0xfe8ac4a6U,
+    0x539d342eU, 0x55a0a2f3U, 0xe132058aU, 0xeb75a4f6U,
+    0xec390b83U, 0xefaa4060U, 0x9f065e71U, 0x1051bd6eU,
+
+    0x8af93e21U, 0x063d96ddU, 0x05aedd3eU, 0xbd464de6U,
+    0x8db59154U, 0x5d0571c4U, 0xd46f0406U, 0x15ff6050U,
+    0xfb241998U, 0xe997d6bdU, 0x43cc8940U, 0x9e7767d9U,
+    0x42bdb0e8U, 0x8b880789U, 0x5b38e719U, 0xeedb79c8U,
+    0x0a47a17cU, 0x0fe97c42U, 0x1ec9f884U, 0x00000000U,
+    0x86830980U, 0xed48322bU, 0x70ac1e11U, 0x724e6c5aU,
+    0xfffbfd0eU, 0x38560f85U, 0xd51e3daeU, 0x3927362dU,
+    0xd9640a0fU, 0xa621685cU, 0x54d19b5bU, 0x2e3a2436U,
+    0x67b10c0aU, 0xe70f9357U, 0x96d2b4eeU, 0x919e1b9bU,
+    0xc54f80c0U, 0x20a261dcU, 0x4b695a77U, 0x1a161c12U,
+    0xba0ae293U, 0x2ae5c0a0U, 0xe0433c22U, 0x171d121bU,
+    0x0d0b0e09U, 0xc7adf28bU, 0xa8b92db6U, 0xa9c8141eU,
+    0x198557f1U, 0x074caf75U, 0xddbbee99U, 0x60fda37fU,
+    0x269ff701U, 0xf5bc5c72U, 0x3bc54466U, 0x7e345bfbU,
+    0x29768b43U, 0xc6dccb23U, 0xfc68b6edU, 0xf163b8e4U,
+    0xdccad731U, 0x85104263U, 0x22401397U, 0x112084c6U,
+    0x247d854aU, 0x3df8d2bbU, 0x3211aef9U, 0xa16dc729U,
+    0x2f4b1d9eU, 0x30f3dcb2U, 0x52ec0d86U, 0xe3d077c1U,
+    0x166c2bb3U, 0xb999a970U, 0x48fa1194U, 0x642247e9U,
+    0x8cc4a8fcU, 0x3f1aa0f0U, 0x2cd8567dU, 0x90ef2233U,
+    0x4ec78749U, 0xd1c1d938U, 0xa2fe8ccaU, 0x0b3698d4U,
+    0x81cfa6f5U, 0xde28a57aU, 0x8e26dab7U, 0xbfa43fadU,
+    0x9de42c3aU, 0x920d5078U, 0xcc9b6a5fU, 0x4662547eU,
+    0x13c2f68dU, 0xb8e890d8U, 0xf75e2e39U, 0xaff582c3U,
+    0x80be9f5dU, 0x937c69d0U, 0x2da96fd5U, 0x12b3cf25U,
+    0x993bc8acU, 0x7da71018U, 0x636ee89cU, 0xbb7bdb3bU,
+    0x7809cd26U, 0x18f46e59U, 0xb701ec9aU, 0x9aa8834fU,
+    0x6e65e695U, 0xe67eaaffU, 0xcf0821bcU, 0xe8e6ef15U,
+    0x9bd9bae7U, 0x36ce4a6fU, 0x09d4ea9fU, 0x7cd629b0U,
+    0xb2af31a4U, 0x23312a3fU, 0x9430c6a5U, 0x66c035a2U,
+    0xbc37744eU, 0xcaa6fc82U, 0xd0b0e090U, 0xd81533a7U,
+    0x984af104U, 0xdaf741ecU, 0x500e7fcdU, 0xf62f1791U,
+    0xd68d764dU, 0xb04d43efU, 0x4d54ccaaU, 0x04dfe496U,
+    0xb5e39ed1U, 0x881b4c6aU, 0x1fb8c12cU, 0x517f4665U,
+    0xea049d5eU, 0x355d018cU, 0x7473fa87U, 0x412efb0bU,
+    0x1d5ab367U, 0xd25292dbU, 0x5633e910U, 0x47136dd6U,
+    0x618c9ad7U, 0x0c7a37a1U, 0x148e59f8U, 0x3c89eb13U,
+    0x27eecea9U, 0xc935b761U, 0xe5ede11cU, 0xb13c7a47U,
+    0xdf599cd2U, 0x733f55f2U, 0xce791814U, 0x37bf73c7U,
+    0xcdea53f7U, 0xaa5b5ffdU, 0x6f14df3dU, 0xdb867844U,
+    0xf381caafU, 0xc43eb968U, 0x342c3824U, 0x405fc2a3U,
+    0xc372161dU, 0x250cbce2U, 0x498b283cU, 0x9541ff0dU,
+    0x017139a8U, 0xb3de080cU, 0xe49cd8b4U, 0xc1906456U,
+    0x84617bcbU, 0xb670d532U, 0x5c74486cU, 0x5742d0b8U,
+};
+
+const TUint32 Td3[256] = {
+    0xf4a75051U, 0x4165537eU, 0x17a4c31aU, 0x275e963aU,
+    0xab6bcb3bU, 0x9d45f11fU, 0xfa58abacU, 0xe303934bU,
+    0x30fa5520U, 0x766df6adU, 0xcc769188U, 0x024c25f5U,
+    0xe5d7fc4fU, 0x2acbd7c5U, 0x35448026U, 0x62a38fb5U,
+    0xb15a49deU, 0xba1b6725U, 0xea0e9845U, 0xfec0e15dU,
+    0x2f7502c3U, 0x4cf01281U, 0x4697a38dU, 0xd3f9c66bU,
+    0x8f5fe703U, 0x929c9515U, 0x6d7aebbfU, 0x5259da95U,
+    0xbe832dd4U, 0x7421d358U, 0xe0692949U, 0xc9c8448eU,
+    0xc2896a75U, 0x8e7978f4U, 0x583e6b99U, 0xb971dd27U,
+    0xe14fb6beU, 0x88ad17f0U, 0x20ac66c9U, 0xce3ab47dU,
+    0xdf4a1863U, 0x1a3182e5U, 0x51336097U, 0x537f4562U,
+    0x6477e0b1U, 0x6bae84bbU, 0x81a01cfeU, 0x082b94f9U,
+    0x48685870U, 0x45fd198fU, 0xde6c8794U, 0x7bf8b752U,
+    0x73d323abU, 0x4b02e272U, 0x1f8f57e3U, 0x55ab2a66U,
+    0xeb2807b2U, 0xb5c2032fU, 0xc57b9a86U, 0x3708a5d3U,
+    0x2887f230U, 0xbfa5b223U, 0x036aba02U, 0x16825cedU,
+    0xcf1c2b8aU, 0x79b492a7U, 0x07f2f0f3U, 0x69e2a14eU,
+    0xdaf4cd65U, 0x05bed506U, 0x34621fd1U, 0xa6fe8ac4U,
+    0x2e539d34U, 0xf355a0a2U, 0x8ae13205U, 0xf6eb75a4U,
+    0x83ec390bU, 0x60efaa40U, 0x719f065eU, 0x6e1051bdU,
+    0x218af93eU, 0xdd063d96U, 0x3e05aeddU, 0xe6bd464dU,
+    0x548db591U, 0xc45d0571U, 0x06d46f04U, 0x5015ff60U,
+    0x98fb2419U, 0xbde997d6U, 0x4043cc89U, 0xd99e7767U,
+    0xe842bdb0U, 0x898b8807U, 0x195b38e7U, 0xc8eedb79U,
+    0x7c0a47a1U, 0x420fe97cU, 0x841ec9f8U, 0x00000000U,
+    0x80868309U, 0x2bed4832U, 0x1170ac1eU, 0x5a724e6cU,
+    0x0efffbfdU, 0x8538560fU, 0xaed51e3dU, 0x2d392736U,
+    0x0fd9640aU, 0x5ca62168U, 0x5b54d19bU, 0x362e3a24U,
+    0x0a67b10cU, 0x57e70f93U, 0xee96d2b4U, 0x9b919e1bU,
+    0xc0c54f80U, 0xdc20a261U, 0x774b695aU, 0x121a161cU,
+    0x93ba0ae2U, 0xa02ae5c0U, 0x22e0433cU, 0x1b171d12U,
+    0x090d0b0eU, 0x8bc7adf2U, 0xb6a8b92dU, 0x1ea9c814U,
+    0xf1198557U, 0x75074cafU, 0x99ddbbeeU, 0x7f60fda3U,
+    0x01269ff7U, 0x72f5bc5cU, 0x663bc544U, 0xfb7e345bU,
+    0x4329768bU, 0x23c6dccbU, 0xedfc68b6U, 0xe4f163b8U,
+    0x31dccad7U, 0x63851042U, 0x97224013U, 0xc6112084U,
+    0x4a247d85U, 0xbb3df8d2U, 0xf93211aeU, 0x29a16dc7U,
+    0x9e2f4b1dU, 0xb230f3dcU, 0x8652ec0dU, 0xc1e3d077U,
+    0xb3166c2bU, 0x70b999a9U, 0x9448fa11U, 0xe9642247U,
+    0xfc8cc4a8U, 0xf03f1aa0U, 0x7d2cd856U, 0x3390ef22U,
+    0x494ec787U, 0x38d1c1d9U, 0xcaa2fe8cU, 0xd40b3698U,
+    0xf581cfa6U, 0x7ade28a5U, 0xb78e26daU, 0xadbfa43fU,
+    0x3a9de42cU, 0x78920d50U, 0x5fcc9b6aU, 0x7e466254U,
+    0x8d13c2f6U, 0xd8b8e890U, 0x39f75e2eU, 0xc3aff582U,
+    0x5d80be9fU, 0xd0937c69U, 0xd52da96fU, 0x2512b3cfU,
+    0xac993bc8U, 0x187da710U, 0x9c636ee8U, 0x3bbb7bdbU,
+    0x267809cdU, 0x5918f46eU, 0x9ab701ecU, 0x4f9aa883U,
+    0x956e65e6U, 0xffe67eaaU, 0xbccf0821U, 0x15e8e6efU,
+    0xe79bd9baU, 0x6f36ce4aU, 0x9f09d4eaU, 0xb07cd629U,
+    0xa4b2af31U, 0x3f23312aU, 0xa59430c6U, 0xa266c035U,
+    0x4ebc3774U, 0x82caa6fcU, 0x90d0b0e0U, 0xa7d81533U,
+    0x04984af1U, 0xecdaf741U, 0xcd500e7fU, 0x91f62f17U,
+    0x4dd68d76U, 0xefb04d43U, 0xaa4d54ccU, 0x9604dfe4U,
+    0xd1b5e39eU, 0x6a881b4cU, 0x2c1fb8c1U, 0x65517f46U,
+    0x5eea049dU, 0x8c355d01U, 0x877473faU, 0x0b412efbU,
+    0x671d5ab3U, 0xdbd25292U, 0x105633e9U, 0xd647136dU,
+    0xd7618c9aU, 0xa10c7a37U, 0xf8148e59U, 0x133c89ebU,
+    0xa927eeceU, 0x61c935b7U, 0x1ce5ede1U, 0x47b13c7aU,
+    0xd2df599cU, 0xf2733f55U, 0x14ce7918U, 0xc737bf73U,
+    0xf7cdea53U, 0xfdaa5b5fU, 0x3d6f14dfU, 0x44db8678U,
+    0xaff381caU, 0x68c43eb9U, 0x24342c38U, 0xa3405fc2U,
+    0x1dc37216U, 0xe2250cbcU, 0x3c498b28U, 0x0d9541ffU,
+    0xa8017139U, 0x0cb3de08U, 0xb4e49cd8U, 0x56c19064U,
+    0xcb84617bU, 0x32b670d5U, 0x6c5c7448U, 0xb85742d0U,
+};
+
+const TUint32 Td4[256] = {
+    0x52525252U, 0x09090909U, 0x6a6a6a6aU, 0xd5d5d5d5U,
+    0x30303030U, 0x36363636U, 0xa5a5a5a5U, 0x38383838U,
+    0xbfbfbfbfU, 0x40404040U, 0xa3a3a3a3U, 0x9e9e9e9eU,
+    0x81818181U, 0xf3f3f3f3U, 0xd7d7d7d7U, 0xfbfbfbfbU,
+    0x7c7c7c7cU, 0xe3e3e3e3U, 0x39393939U, 0x82828282U,
+    0x9b9b9b9bU, 0x2f2f2f2fU, 0xffffffffU, 0x87878787U,
+    0x34343434U, 0x8e8e8e8eU, 0x43434343U, 0x44444444U,
+    0xc4c4c4c4U, 0xdedededeU, 0xe9e9e9e9U, 0xcbcbcbcbU,
+    0x54545454U, 0x7b7b7b7bU, 0x94949494U, 0x32323232U,
+    0xa6a6a6a6U, 0xc2c2c2c2U, 0x23232323U, 0x3d3d3d3dU,
+    0xeeeeeeeeU, 0x4c4c4c4cU, 0x95959595U, 0x0b0b0b0bU,
+    0x42424242U, 0xfafafafaU, 0xc3c3c3c3U, 0x4e4e4e4eU,
+    0x08080808U, 0x2e2e2e2eU, 0xa1a1a1a1U, 0x66666666U,
+    0x28282828U, 0xd9d9d9d9U, 0x24242424U, 0xb2b2b2b2U,
+    0x76767676U, 0x5b5b5b5bU, 0xa2a2a2a2U, 0x49494949U,
+    0x6d6d6d6dU, 0x8b8b8b8bU, 0xd1d1d1d1U, 0x25252525U,
+    0x72727272U, 0xf8f8f8f8U, 0xf6f6f6f6U, 0x64646464U,
+    0x86868686U, 0x68686868U, 0x98989898U, 0x16161616U,
+    0xd4d4d4d4U, 0xa4a4a4a4U, 0x5c5c5c5cU, 0xccccccccU,
+    0x5d5d5d5dU, 0x65656565U, 0xb6b6b6b6U, 0x92929292U,
+    0x6c6c6c6cU, 0x70707070U, 0x48484848U, 0x50505050U,
+    0xfdfdfdfdU, 0xededededU, 0xb9b9b9b9U, 0xdadadadaU,
+    0x5e5e5e5eU, 0x15151515U, 0x46464646U, 0x57575757U,
+    0xa7a7a7a7U, 0x8d8d8d8dU, 0x9d9d9d9dU, 0x84848484U,
+    0x90909090U, 0xd8d8d8d8U, 0xababababU, 0x00000000U,
+    0x8c8c8c8cU, 0xbcbcbcbcU, 0xd3d3d3d3U, 0x0a0a0a0aU,
+    0xf7f7f7f7U, 0xe4e4e4e4U, 0x58585858U, 0x05050505U,
+    0xb8b8b8b8U, 0xb3b3b3b3U, 0x45454545U, 0x06060606U,
+    0xd0d0d0d0U, 0x2c2c2c2cU, 0x1e1e1e1eU, 0x8f8f8f8fU,
+    0xcacacacaU, 0x3f3f3f3fU, 0x0f0f0f0fU, 0x02020202U,
+    0xc1c1c1c1U, 0xafafafafU, 0xbdbdbdbdU, 0x03030303U,
+    0x01010101U, 0x13131313U, 0x8a8a8a8aU, 0x6b6b6b6bU,
+    0x3a3a3a3aU, 0x91919191U, 0x11111111U, 0x41414141U,
+    0x4f4f4f4fU, 0x67676767U, 0xdcdcdcdcU, 0xeaeaeaeaU,
+    0x97979797U, 0xf2f2f2f2U, 0xcfcfcfcfU, 0xcecececeU,
+    0xf0f0f0f0U, 0xb4b4b4b4U, 0xe6e6e6e6U, 0x73737373U,
+    0x96969696U, 0xacacacacU, 0x74747474U, 0x22222222U,
+    0xe7e7e7e7U, 0xadadadadU, 0x35353535U, 0x85858585U,
+    0xe2e2e2e2U, 0xf9f9f9f9U, 0x37373737U, 0xe8e8e8e8U,
+    0x1c1c1c1cU, 0x75757575U, 0xdfdfdfdfU, 0x6e6e6e6eU,
+    0x47474747U, 0xf1f1f1f1U, 0x1a1a1a1aU, 0x71717171U,
+    0x1d1d1d1dU, 0x29292929U, 0xc5c5c5c5U, 0x89898989U,
+    0x6f6f6f6fU, 0xb7b7b7b7U, 0x62626262U, 0x0e0e0e0eU,
+    0xaaaaaaaaU, 0x18181818U, 0xbebebebeU, 0x1b1b1b1bU,
+    0xfcfcfcfcU, 0x56565656U, 0x3e3e3e3eU, 0x4b4b4b4bU,
+    0xc6c6c6c6U, 0xd2d2d2d2U, 0x79797979U, 0x20202020U,
+    0x9a9a9a9aU, 0xdbdbdbdbU, 0xc0c0c0c0U, 0xfefefefeU,
+    0x78787878U, 0xcdcdcdcdU, 0x5a5a5a5aU, 0xf4f4f4f4U,
+    0x1f1f1f1fU, 0xddddddddU, 0xa8a8a8a8U, 0x33333333U,
+    0x88888888U, 0x07070707U, 0xc7c7c7c7U, 0x31313131U,
+    0xb1b1b1b1U, 0x12121212U, 0x10101010U, 0x59595959U,
+    0x27272727U, 0x80808080U, 0xececececU, 0x5f5f5f5fU,
+    0x60606060U, 0x51515151U, 0x7f7f7f7fU, 0xa9a9a9a9U,
+    0x19191919U, 0xb5b5b5b5U, 0x4a4a4a4aU, 0x0d0d0d0dU,
+    0x2d2d2d2dU, 0xe5e5e5e5U, 0x7a7a7a7aU, 0x9f9f9f9fU,
+    0x93939393U, 0xc9c9c9c9U, 0x9c9c9c9cU, 0xefefefefU,
+    0xa0a0a0a0U, 0xe0e0e0e0U, 0x3b3b3b3bU, 0x4d4d4d4dU,
+    0xaeaeaeaeU, 0x2a2a2a2aU, 0xf5f5f5f5U, 0xb0b0b0b0U,
+    0xc8c8c8c8U, 0xebebebebU, 0xbbbbbbbbU, 0x3c3c3c3cU,
+    0x83838383U, 0x53535353U, 0x99999999U, 0x61616161U,
+    0x17171717U, 0x2b2b2b2bU, 0x04040404U, 0x7e7e7e7eU,
+    0xbabababaU, 0x77777777U, 0xd6d6d6d6U, 0x26262626U,
+    0xe1e1e1e1U, 0x69696969U, 0x14141414U, 0x63636363U,
+    0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,
+};
+
+const TUint32 rcon[] = {
+	0x01000000, 0x02000000, 0x04000000, 0x08000000,
+	0x10000000, 0x20000000, 0x40000000, 0x80000000,
+	0x1B000000, 0x36000000, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
+};
+
+}		//	namespace RIJNDAEL_TABLE
+#endif	//	__RIJNDAELTABLES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/strong/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,61 @@
+/*
+* Copyright (c) 2003-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: 
+* Builds strong cryptography
+*
+*/
+
+
+/**
+ @file
+*/
+
+PRJ_PLATFORMS
+default
+
+PRJ_EXPORTS
+../inc/bigint.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(bigint.h)
+../inc/asymmetric.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(asymmetric.h)
+../inc/asymmetric.inl SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(asymmetric.inl)
+../inc/asymmetrickeys.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(asymmetrickeys.h)
+../inc/padding.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(padding.h)
+../inc/pbebase.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(pbebase.h)
+../inc/pbe.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(pbe.h)
+../inc/pbedata.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(pbedata.h)
+../inc/3des.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(3des.h)
+../inc/arc4.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(arc4.h)
+../inc/blocktransformation.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(blocktransformation.h)
+../inc/bufferedtransformation.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(bufferedtransformation.h)
+../inc/cbcmode.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(cbcmode.h)
+../inc/des.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(des.h)
+../inc/nullcipher.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(nullcipher.h)
+../inc/rc2.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(rc2.h)
+../inc/rijndael.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(rijndael.h)
+../inc/streamcipher.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(streamcipher.h)
+../inc/symmetric.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(symmetric.h)
+../inc/msymmetriccipher.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(msymmetriccipher.h)
+../inc/mode.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(mode.h)
+../inc/cryptostrength.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(cryptostrength.h)
+../inc/pbencryptor.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(pbencryptor.h)
+
+#ifndef TOOLS // Don't build anything for tools
+#ifndef TOOLS2 // Don't build anything for tools2
+
+PRJ_MMPFILES
+#ifndef MARM_THUMB
+strong_crypto.mmp	BUILD_AS_ARM //	Don't build for thumb
+#endif
+
+#endif // TOOLS2
+#endif // TOOLS
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/strong/strong_crypto.mmp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,33 @@
+/*
+* Copyright (c) 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: 
+*
+*/
+
+/**
+@file
+
+@SYMPurpose strong_cryptography.dll Implements strong cryptography.
+*/
+
+// Export-restricted version of cryptography.dll
+
+TARGET      strong_cryptography.dll
+MACRO       CRYPTO_STRONG_BUILD
+UNPAGED
+
+#include "../group/crypto.mmh"
+
+VENDORID 0x70000001
+SMPSAFE
--- a/crypto/weakcryptospi/test/kms/driver/product/kmskext/kmskext.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/crypto/weakcryptospi/test/kms/driver/product/kmskext/kmskext.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -23,6 +23,7 @@
 
 #include <nkern/nkern.h>
 #include "kmskext.h"
+#include <e32def_private.h>
 
 // singleton keystore instance
 XKeyStore KeyStore;
--- a/crypto/weakcryptospi/test/kms/private_include/test/kmslddtest.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/crypto/weakcryptospi/test/kms/private_include/test/kmslddtest.h	Fri Nov 06 13:21:00 2009 +0200
@@ -28,6 +28,7 @@
 
 #include <e32ldr.h>
 #include <e32test.h>
+#include <e32def_private.h>
 
 #include "kmsldd.h"
 #include "kmsextrldd.h"
--- a/crypto/weakcryptospi/test/kms/server/test/kmstest/kmstest.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/crypto/weakcryptospi/test/kms/server/test/kmstest/kmstest.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -25,6 +25,7 @@
 #include <e32test.h>
 #include "kmsclient.h"
 #include "kmsservercommon.h"
+#include <e32def_private.h>
 
 #include "kmstest.h"
 
--- a/cryptomgmtlibs/cryptotokenfw/group/bld.inf	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptomgmtlibs/cryptotokenfw/group/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -38,7 +38,7 @@
 ../inc/ct/TCTTokenTypeAttribute.h						SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(ct/tcttokentypeattribute.h)
 ../inc/ct/TCTFindTokenTypesByInterface.h				SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(ct/tctfindtokentypesbyinterface.h)
 ../inc/ct/TCTFindTokenTypesByInterfaceAndAttribute.h	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(ct/tctfindtokentypesbyinterfaceandattribute.h)
-../inc/ct/InterfaceUID.hrh 								SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(ct/interfaceuid.hrh)
+../inc/ct/InterfaceUID.hrh 								/epoc32/include/ct/interfaceuid.hrh
 ../inc/CryptoTokenRegistryInfo.rh						SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(cryptotokenregistryinfo.rh)
 ../inc/ct/tcttokenhandle.h								SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(ct/tcttokenhandle.h)
 ../inc/ct/RCPointerArray.h								SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(ct/rcpointerarray.h)
--- a/cryptomgmtlibs/securitycommonutils/test/source/scstest/scstest.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptomgmtlibs/securitycommonutils/test/source/scstest/scstest.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -22,9 +22,11 @@
  @file
 */
 
+
 #include <e32ldr.h>
 #include <f32file.h>
 #include "rtestwrapper.h"
+#include <e32def_private.h>
 
 #include <scs/scscommon.h>
 #include "scstestcommon.h"
--- a/cryptomgmtlibs/securitytestfw/group/bld.inf	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptomgmtlibs/securitytestfw/group/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -76,6 +76,7 @@
 	../test/autotesting/testsecurity_9.4_mcs_vfuture.bat /epoc32/winscw/c/autohardware/testsecurity_9.4_mcs_vfuture.bat
 	../test/autotesting/testsecurity_9.4_nonmcs.bat /epoc32/winscw/c/autohardware/testsecurity_9.4_nonmcs.bat
 	../test/autotesting/runcertman_9.5.bat /epoc32/winscw/c/autohardware/runcertman_9.5.bat
+
 	../test/autotesting/testsecurity_9.5_mcs.bat /epoc32/winscw/c/autohardware/testsecurity_9.5_mcs.bat
 	../test/autotesting/testsecurity_9.6_mcs.bat /epoc32/winscw/c/autohardware/testsecurity_9.6_mcs.bat
 	../test/autotesting/testsecurity_9.5_nonmcs.bat /epoc32/winscw/c/autohardware/testsecurity_9.5_nonmcs.bat
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptomgmtlibs/securitytestfw/inc/captestframework.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,77 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+
+
+/**
+ @file
+*/
+
+#ifndef CAPTESTFRAMEWORK_H__
+#define CAPTESTFRAMEWORK_H__
+
+// Used to transfer data to the helper
+const TInt KDllNameTransferSlot=5;
+const TInt KShouldPassTransferSlot=6;
+const TInt KTestNumberTransferSlot=7;
+const TInt KLogFileTransferSlot=8;
+const TInt KFileSessionTransferSlot=9;
+const TInt KLogFileNameTransferSlot=10;
+
+
+// markers for the file used to transfer the results
+
+enum TFileMarker
+	{
+	ETestPassed,
+	ETestFailed,
+	ETestsEnded,
+	EFileEnd,
+	};
+
+
+class RFile;
+
+// classes to be implemented by the actaul test dll.
+class MCapabilityTest
+	{
+public:
+	virtual const TDesC& Name() const=0;
+	virtual const TDesC& SubName() const=0;
+	
+	virtual TCapabilitySet CapabilitiesRequired() const=0;
+	virtual TUid VidRequired() const=0;
+	virtual TUid SidRequired() const=0;
+
+	virtual void RunTestL(RFile& aLogFile)=0;
+	virtual void SetExpectPermissionDenied(TBool aExpectPermissionDenied)=0;
+	virtual ~MCapabilityTest() {};
+	};
+
+class MCapabilityTestFactory
+	{
+public:
+	virtual TInt NumberOfTests()=0;
+	virtual MCapabilityTest* Test(TInt aTestNumber)=0;
+	virtual ~MCapabilityTestFactory() {};
+	};
+
+
+
+
+#endif // #ifndef CAPTESTFRAMEWORK_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptomgmtlibs/securitytestfw/inc/captestutility.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,95 @@
+/*
+* Copyright (c) 2005-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: 
+* Implements default base classes for captestframework
+*
+*/
+
+
+
+
+/**
+ @file
+*/
+
+#ifndef CAPTESTUTILITY_H__
+#define CAPTESTUTILITY_H__
+
+#include <e32base.h>
+#include <s32file.h> 
+#include <captestframework/captestframework.h>
+
+// CDefaultCapabilityTest
+class CDefaultCapabilityTest : public CBase, public MCapabilityTest
+	{
+public:
+	IMPORT_C const TDesC& Name() const;
+	IMPORT_C const TDesC& SubName() const;
+	
+	IMPORT_C TCapabilitySet CapabilitiesRequired() const;
+	IMPORT_C TUid VidRequired() const;
+	IMPORT_C TUid SidRequired() const;
+
+	IMPORT_C ~CDefaultCapabilityTest();
+	
+protected:
+	IMPORT_C void SetNameL(const TDesC& aName);	
+	void SetExpectPermissionDenied(TBool aExpectPermissionDenied = ETrue);	
+
+	IMPORT_C void SetCapabilityRequired(const TCapability& aCapability);
+	IMPORT_C void SetSidRequired(const TUid& aSid);
+	IMPORT_C void SetVidRequired(const TUid& aVid);
+	
+	IMPORT_C TInt CheckFailL(TInt aResult, const TDesC& aTestName);
+	IMPORT_C void RunTestL(RFile& aLogFile);
+
+	void SetFail() { iFail = ETrue;}
+	virtual void RunTestL() =0;
+private:
+	HBufC* iTestName;
+	HBufC* iTestSubName;
+	
+	RFile* iLogFile;
+	RFileWriteStream* iLogWriteStream;
+	TBool iExpectPermissionDenied;
+	TCapabilitySet iCapabilitySet;
+	TUid iVidRequired;
+	TUid iSidRequired;	
+	TBool iFail;
+	};
+
+// CDefaultCapabilityTestFactory
+class CDefaultCapabilityTestFactory : public CBase, public MCapabilityTestFactory
+
+	{
+public:
+	IMPORT_C virtual TInt NumberOfTests();
+	IMPORT_C virtual MCapabilityTest* Test(TInt aTestNumber);
+	
+	IMPORT_C void AddTestL(CDefaultCapabilityTest* aTest);
+
+	IMPORT_C ~CDefaultCapabilityTestFactory();
+	
+private:
+	RPointerArray<CDefaultCapabilityTest> iTests;
+	};
+
+// inline functions from CSwiCapabilityTest
+
+inline void CDefaultCapabilityTest::SetExpectPermissionDenied(TBool aExpectPermissionDenied)
+	{
+	iExpectPermissionDenied = aExpectPermissionDenied;
+	}
+
+#endif //#ifndef CAPTESTUTILITY_H__
--- a/cryptomgmtlibs/securitytestfw/test/autotesting/runcertman_9.5.bat	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptomgmtlibs/securitytestfw/test/autotesting/runcertman_9.5.bat	Fri Nov 06 13:21:00 2009 +0200
@@ -30,6 +30,13 @@
 copy z:\tcertstore\data\TestKeyStore.txt c:\system\data\testkeystore.txt
 del c:\system\data\cacerts.dat
 
+del c:\system\data\certclients.dat
+t_certstore c:\tcertstore\scripts\t_certstore_sha2.txt c:\testresults\t_certstore_sha2.txt
+move c:\testresults\t_certstore_sha2.txt e:\testresults\t_certstore_sha2.txt
+
+t_certstore c:\tcertstore\scripts\t_certstore_sha2.script c:\testresults\t_certstore_sha2.htm
+move c:\testresults\t_certstore_sha2.htm e:\testresults\t_certstore_sha2.htm
+
 rem run tcertstore tests
 t_certstore c:\tcertstore\scripts\unifiedcertstore1-conf1.script c:\logs\testexecute\unifiedcertstore1-conf1.htm
 move c:\logs\testexecute\unifiedcertstore1-conf1.htm e:\testresults\unifiedcertstore1-conf1.htm
--- a/cryptomgmtlibs/securitytestfw/test/autotesting/test_spec_sdp_9.5.txt	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptomgmtlibs/securitytestfw/test/autotesting/test_spec_sdp_9.5.txt	Fri Nov 06 13:21:00 2009 +0200
@@ -233,11 +233,16 @@
 tocsp, \logs\testexecute\tocsp_httpinterface.htm,, -Dtextshell --    \system\tocsp\scripts\httpinterface.script \logs\testexecute\tocsp_httpinterface.htm,    300, UREL, \epoc32\winscw\c\tcertstore\scripts\batchfiles\pre_tocsp_backup.bat, 	   \epoc32\winscw\c\tcertstore\scripts\batchfiles\post_httpinterface_restore.bat
 tocsp, \logs\testexecute\tocsp_logoom.htm,, -Dtextshell -- 			\system\tocsp\scripts\xcert-oom.script     \logs\testexecute\tocsp_logoom.htm,           900, UDEB#UREL, \epoc32\winscw\c\tcertstore\scripts\batchfiles\pre_tocsp_backup.bat, 	\epoc32\winscw\c\tcertstore\scripts\batchfiles\post_tocsp_restore.bat
 
+
 # TMS SUPPORT
 t_certstore, \logs\testexecute\tcertstore_conf1.1.htm,, -Dtextshell -- \tcertstore\scripts\unifiedcertstore1-conf1.script \logs\testexecute\tcertstore_conf1.1.htm, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
 t_certstore, \logs\testexecute\tcertstore_conf1.2.htm,, -Dtextshell -- \tcertstore\scripts\unifiedcertstore2-conf1.script \logs\testexecute\tcertstore_conf1.2.htm, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
 t_certstore, \logs\testexecute\tcertstore_conf1.3.htm,, -Dtextshell -- \tcertstore\scripts\unifiedcertstore3-conf1.script \logs\testexecute\tcertstore_conf1.3.htm, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
 t_certstore, \logs\testexecute\t_handle_1.htm,, -Dtextshell -- \tcertstore\scripts\t_handle_1.script \logs\testexecute\t_handle_1.htm, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
+//As of now, not in TMS format. Should be changed to TEF.
+t_certstore, \t_certstore_sha2.txt,, -Dtextshell -- \tcertstore\scripts\t_certstore_sha2.txt \t_certstore_sha2.txt, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
+//TEF Format
+t_certstore, \logs\testexecute\t_certstore_sha2.htm,, -Dtextshell -- \tcertstore\scripts\t_certstore_sha2.script \logs\testexecute\t_certstore_sha2.htm, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
 
 # TMS SUPPORT
 t_certstore, \logs\testexecute\tcertstore_oom.conf1.1.htm,, -Dtextshell -- \tcertstore\scripts\oom1.script \logs\testexecute\tcertstore_oom.conf1.1.htm, 300, UDEB#UREL, \epoc32\winscw\c\twtlscert\scripts\batchfiles\precert_backup.bat, \epoc32\winscw\c\twtlscert\scripts\batchfiles\postcert_restore.bat
@@ -346,7 +351,6 @@
 ######### Composite Certstore Testing###################################################################################
 
 
-
 [SWI]
 # Requires the following additional components to be built: SisTools, Certman
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/3desimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,190 @@
+/*
+* Copyright (c) 2006-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 "3desimpl.h"
+
+#include "destables.h"
+#include "common/inlines.h"
+#include "des.inl"
+#include "pluginconfig.h"
+#include "symmetriccipherimpl.h"
+#include <cryptostrength.h>
+
+using namespace SoftwareCrypto;
+
+/* C3DesImpl */
+C3DesImpl::C3DesImpl(
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPadding) :
+	CDesImpl(KDesBlockBytes, aCryptoMode, aOperationMode, aPadding)
+	{
+	}
+
+C3DesImpl* C3DesImpl::NewL(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)
+	{
+	C3DesImpl* self = C3DesImpl::NewLC(aKey, aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+C3DesImpl* C3DesImpl::NewLC(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)
+	{
+	C3DesImpl* self = new(ELeave) C3DesImpl(aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+
+	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyContent.Size()) - keyContent.Size());
+	return self;
+	}
+		
+C3DesImpl::~C3DesImpl()
+	{
+	// make sure key information isn't visible to other processes if the
+	// page is reused.
+	Mem::FillZ(&iK1, sizeof(iK1));
+	Mem::FillZ(&iK2, sizeof(iK2));
+	Mem::FillZ(&iK3, sizeof(iK3));
+	}
+	
+void C3DesImpl::ConstructL(const CKey& aKey)
+	{
+	CDesImpl::ConstructL(aKey);
+	SetKeySchedule();
+	}	
+	
+CExtendedCharacteristics* C3DesImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+	
+const CExtendedCharacteristics* C3DesImpl::GetExtendedCharacteristicsL()
+	{
+	return C3DesImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid C3DesImpl::ImplementationUid() const
+	{
+	return KCryptoPlugin3DesUid;
+	}
+	
+TBool C3DesImpl::IsValidKeyLength(TInt aKeyBytes) const
+	{
+	return (aKeyBytes == K3DesKeyBytes);
+	}
+	
+TInt C3DesImpl::GetKeyStrength() const
+	{
+	// Exclude parity bits from each subkey
+	return BytesToBits(K3DesKeyBytes - (3 * 8));
+	}	
+	
+void C3DesImpl::TransformEncrypt(
+	TUint8* aBuffer,
+	TUint aNumBlocks)
+	{			
+	for (TInt i = 0; i < aNumBlocks; ++i)
+		{		
+		ModeEncryptStart(aBuffer);
+
+		TUint32 l, r;
+		// Split the block into 2 word-sized big endian portions
+		GetBlockBigEndian(aBuffer, l, r);
+
+		IPerm(l,r);
+		// The mode is applied to the entire operation and NOT 
+		// for each DES transform
+		TUid opMode = iOperationMode;
+		iOperationMode = KOperationModeECBUid;
+		DoTransform(l, r, iK1);
+		DoTransform(r, l, iK2);
+		DoTransform(l, r, iK3);
+		iOperationMode = opMode;
+		FPerm(l,r);
+
+		// Put the portions back into the block as little endian
+		PutBlockBigEndian(aBuffer, r, l);
+		ModeEncryptEnd(aBuffer);
+		aBuffer += KDesBlockBytes;
+		}
+	}
+	
+void C3DesImpl::TransformDecrypt(
+	TUint8* aBuffer,
+	const TUint aNumBlocks)
+	{	
+	for (TInt i = 0; i < aNumBlocks; ++i)
+		{		
+		ModeDecryptStart(aBuffer);
+			
+		TUint32 l, r;
+		// Split the block into 2 word-sized big endian portions
+		GetBlockBigEndian(aBuffer, l, r);
+
+		IPerm(l,r);
+		
+		// The mode is applied to the entire operation and NOT 
+		// for each DES transform
+		TUid opMode = iOperationMode;
+		iOperationMode = KOperationModeECBUid;
+		DoTransform(l, r, iK1);
+		DoTransform(r, l, iK2);
+		DoTransform(l, r, iK3);
+		iOperationMode = opMode;
+		FPerm(l,r);
+
+		// Put the portions back into the block as little endian
+		PutBlockBigEndian(aBuffer, r, l);	
+		ModeDecryptEnd(aBuffer);
+		aBuffer += K3DesBlockBytes;
+		}
+	}	
+
+void C3DesImpl::SetKeySchedule()
+	{
+	if (iCryptoMode.iUid == KCryptoModeEncrypt)
+		{
+		// Encrypt -> Decrypt -> Encrypt
+		// Encryptor key	
+		SetEncryptKeySchedule(iKey->Mid(0, KDesKeyBytes), iK1);
+		
+		// Decryptor key
+		SetDecryptKeySchedule(iKey->Mid(KDesKeyBytes, 2 * KDesKeyBytes), iK2);
+		
+		// Encryptor key
+		SetEncryptKeySchedule(iKey->Mid(2 * KDesKeyBytes), iK3);
+		}
+	else 
+		{
+		// Decrypt -> Encrypt -> Decrypt
+		// Key order is reversed !
+		
+		ASSERT(iCryptoMode.iUid == KCryptoModeDecrypt);
+		// Decryptor key	
+		SetDecryptKeySchedule(iKey->Mid(0, KDesKeyBytes), iK3);
+		
+		// Encryptor key
+		SetEncryptKeySchedule(iKey->Mid(KDesKeyBytes, 2 * KDesKeyBytes), iK2);
+		
+		// Decryptor key
+		SetDecryptKeySchedule(iKey->Mid(2 * KDesKeyBytes), iK1);
+		}	
+	}		
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/3desimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,113 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef	__3DESIMPL_H__
+#define	__3DESIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keys.h"
+#include "desimpl.h"
+
+/**
+Plug-in class for 3DES block cipher
+*/
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(C3DesImpl) : public CDesImpl
+		{
+	public:
+		/**
+		Creates an instance of a 3DES (Data Encryption Standard) symmetric cipher plug-in.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a C3DesImpl instance
+		*/
+		static C3DesImpl* NewL(const CKey& aKey, 
+			TUid aCryptoMode, TUid aOperationMode, TUid aPadding);
+
+		/**
+		Creates an instance of a 3DES (Data Encryption Standard) symmetric cipher plug-in.
+		A pointer to the plug-in instance is placed on the cleanup stack.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a C3DesImpl instance
+		*/
+		static C3DesImpl* NewLC(const CKey& aKey, 
+			TUid aCryptoMode, TUid aOperationMode, TUid aPadding);
+		
+		// From CSymmetricCipherImpl
+		TBool IsValidKeyLength(TInt aKeyBytes) const;
+		TInt GetKeyStrength() const;
+		TUid ImplementationUid() const;
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+				
+		/// 3Destructor
+		~C3DesImpl();
+
+	private:
+		/**
+		Constructor
+		@param aOperationMode The mode of operation e.g. CBC
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPaddingMode The padding mode to use. None, SSL, PKCS#7
+		*/
+		C3DesImpl(TUid aOperationMode, TUid aCryptoMode, TUid aPaddingMode);
+			
+		///	second phase of construction	
+		void ConstructL(const CKey& aKey);						
+
+		/**
+		Creates the key schedules iK1, iK2, iK3 from CBlockTransformationImpl::iKey.
+		This should be called from ConstructL and Reset
+		*/
+		void SetKeySchedule();
+
+		// From CSymmetricBlockCipherImpl
+		void TransformEncrypt(TUint8* aBuffer, TUint aNumBlocks);
+		void TransformDecrypt(TUint8* aBuffer, TUint aNumBlocks);
+		
+	private:
+		/// Size of the key schedule in words
+		static const TUint KKeyScheduleSize = 32;
+		
+		/// the key schedules
+		TUint32 iK1[KKeyScheduleSize];
+		TUint32 iK2[KKeyScheduleSize];
+		TUint32 iK3[KKeyScheduleSize];
+		
+		static const TUint8 K3DesBlockBytes = 8;
+		static const TUint8 K3DesKeyBytes = 24;
+		};
+	}
+
+#endif // __3DESIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/arc4impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,153 @@
+/*
+* Copyright (c) 2006-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 "arc4impl.h"
+#include "keys.h"
+#include "pluginconfig.h"
+#include "symmetriccipherimpl.h"
+#include <cryptostrength.h>
+#include "common/inlines.h"
+
+
+using namespace SoftwareCrypto;
+
+CArc4Impl* CArc4Impl::NewL(const CKey& aKey, TInt aDiscardBytes)
+	{
+	CArc4Impl* self = CArc4Impl::NewLC(aKey, aDiscardBytes);
+	CleanupStack::Pop(self);
+	return self;		
+	}
+
+CArc4Impl* CArc4Impl::NewLC(const CKey& aKey, TInt aDiscardBytes)
+	{
+	CArc4Impl* self = new(ELeave) CArc4Impl(aDiscardBytes);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	
+	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyContent.Size()) - keyContent.Size());
+
+	return self;		
+	}
+
+CArc4Impl::CArc4Impl(TInt aDiscardBytes)
+:ix(1), iy(0), iDiscardBytes(aDiscardBytes)
+	{
+	}
+
+CArc4Impl::~CArc4Impl()
+	{
+	}
+
+void CArc4Impl::ConstructL(const CKey& aKey)
+	{
+	CSymmetricStreamCipherImpl::ConstructL(aKey);
+	GenerateSBox();
+	}
+
+CExtendedCharacteristics* CArc4Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+	
+const CExtendedCharacteristics* CArc4Impl::GetExtendedCharacteristicsL()
+	{
+	return CArc4Impl::CreateExtendedCharacteristicsL();
+	}
+
+void CArc4Impl::DoProcess(TDes8& aData)
+	{
+	TInt blockLen = aData.Size();
+
+	if (blockLen > 0)
+		{
+		TUint8* blockPtr = (TUint8*)&aData[0];	
+		do
+			{
+			*blockPtr++ ^= GenerateByte();
+			} 
+		while (--blockLen);
+		}
+	}
+	
+TBool CArc4Impl::IsValidKeyLength(TInt aKeyBytes) const
+	{
+	return ((aKeyBytes > 0 && aKeyBytes <= KMaxARC4KeyBytes) ? ETrue : EFalse);
+	}
+
+void CArc4Impl::Reset()
+	{
+	ix = 1;
+	iy = 0;
+	GenerateSBox();
+	}
+
+TUid CArc4Impl::ImplementationUid() const
+	{
+	return KCryptoPluginArc4Uid;
+	}
+	
+TUint8 CArc4Impl::GenerateByte()
+	{
+	TUint8 a = iState[ix];
+	iy = (TUint8)((iy + a) & 0xff);
+	TUint8 b = iState[iy];
+
+	iState[ix] = b;
+	iState[iy] = a;
+	ix = (TUint8)((ix + 1) & 0xff);
+	return (iState[(a + b) & 0xff]);
+	}
+
+void CArc4Impl::DiscardBytes(TInt aDiscardBytes)
+	{	
+	if (aDiscardBytes > 0)
+		{
+		do
+			{
+			GenerateByte();
+			}
+		while(--aDiscardBytes);
+		}
+	}
+
+void CArc4Impl::GenerateSBox(void)
+	{
+	TUint keyBytes = iKey->Size();
+		
+	TInt i = 0;
+	for (; i < KSBoxSize; i++)
+		iState[i] = (TUint8)i;
+	
+	TUint keyIndex = 0, stateIndex = 0;
+	i = 0;
+	for (; i < KSBoxSize; i++)
+		{
+		TUint a = iState[i];
+		stateIndex += (*iKey)[keyIndex] + a;
+		stateIndex &= 0xff;
+		iState[i] = iState[stateIndex];
+		iState[stateIndex] = (TUint8)a;
+		if (++keyIndex >= (TUint)keyBytes)
+			keyIndex = 0;
+		}
+
+	DiscardBytes(iDiscardBytes);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/arc4impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,117 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef	ARC4IMPL_H
+#define	ARC4IMPL_H
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include "symmetriccipherimpl.h"
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keys.h"
+
+
+/**
+Plug-in class for ARC4 stream cipher
+*/
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+
+	NONSHARABLE_CLASS(CArc4Impl) : public CSymmetricStreamCipherImpl
+		{
+	public:
+		
+		/** 
+		Number of bytes to discard by default from an ARC4 key stream. 
+		*/
+		static const TUint KDefaultDiscardBytes = 768;
+
+		/** 
+		The size of the substitution box (i.e. lookup table) in bytes. 
+		*/
+		static const TInt KSBoxSize = 256;
+
+		/** 
+		Maximum ARC4 key size in bytes.2048 bits 
+		*/
+		static const TInt KMaxARC4KeyBytes = 256; 
+
+		/**
+		Creates an instance of an ARC4 symmetric cipher plug-in.
+		@param aKey The key
+		@param aDiscardBytes The number of bytes to drop from 
+							the beginning of the key stream.
+		@return A pointer to a CArc4Impl instance
+		*/
+		static CArc4Impl* NewL(const CKey& aKey, TInt aDiscardBytes);
+
+		/**
+		Creates an instance of an ARC4 symmetric cipher plug-in,
+		and leave it on the cleanup stack
+		@param aKey The key
+		@param aDiscardBytes The number of bytes to drop from 
+							the beginning of the key stream.
+		@return A pointer to a CArc4Impl instance
+		*/
+		static CArc4Impl* NewLC(const CKey& aKey, TInt aDiscardBytes);
+
+		//Destructor
+		~CArc4Impl();
+
+		//Override MPlugin virtual function
+		void Reset();
+		
+		//Override CSymmetricCipherImpl virtual functions
+		TUid ImplementationUid() const;
+		TBool IsValidKeyLength(TInt aKeyBytes) const;
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+	private:
+		//Constructor
+		CArc4Impl(TInt aDiscardBytes);
+			
+		//second phase of construction	
+		void ConstructL(const CKey& aKey);
+				
+		//Override CSymmetricStreamCipherImpl virtual functions
+		void DoProcess(TDes8& aData);	
+
+		void GenerateSBox();
+		TUint8 GenerateByte();
+		void DiscardBytes(TInt aDiscardBytes);
+
+	private:
+		TUint8 ix;
+		TUint8 iy;
+		TInt iDiscardBytes;
+		TUint8 iState[KSBoxSize];
+		};
+	}
+
+#endif //ARC4IMPL_H
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/asymmetriccipherimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,166 @@
+/*
+* Copyright (c) 2006-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 <e32def.h>
+#include "keys.h"
+#include "asymmetriccipherimpl.h"
+#include <cryptostrength.h>
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "pluginconfig.h"
+#include "common/inlines.h"
+
+using namespace SoftwareCrypto;
+
+CAsymmetricCipherImpl::CAsymmetricCipherImpl(
+	TUid aCryptoMode,
+	TUid aPaddingMode) :
+	iCryptoMode(aCryptoMode),
+	iPaddingMode(aPaddingMode)
+	{
+	}
+
+void CAsymmetricCipherImpl::ConstructL(const CKey& aKey)
+	{
+	DoSetCryptoModeL(iCryptoMode);
+	DoSetKeyL(aKey);
+	DoSetPaddingModeL(iPaddingMode);
+	}
+	
+CAsymmetricCipherImpl::~CAsymmetricCipherImpl()
+	{
+	delete iKey;
+	delete iPadding;
+	}
+		
+void CAsymmetricCipherImpl::Close()
+	{
+	delete this;
+	}
+	
+void CAsymmetricCipherImpl::Reset()
+	{
+	}
+	
+TAny* CAsymmetricCipherImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return 0;
+	}
+	
+void CAsymmetricCipherImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)
+	{
+	TInt numCiphers = sizeof(KAsymmetricCipherCharacteristics)/sizeof(TAsymmetricCipherCharacteristics*);
+	TInt32 implUid = ImplementationUid().iUid;
+	for (TInt i = 0; i < numCiphers; ++i)
+		{
+		if (KAsymmetricCipherCharacteristics[i]->cmn.iImplementationUID == implUid)
+			{
+			aPluginCharacteristics = KAsymmetricCipherCharacteristics[i];
+			break;
+			}
+		}
+	}
+
+void CAsymmetricCipherImpl::SetKeyL(const CKey& aKey)
+	{
+	DoSetKeyL(aKey);
+	}
+
+void CAsymmetricCipherImpl::DoSetKeyL(const CKey& aKey)
+	{
+	delete iKey;								// delete any previous key
+	iKey = CKey::NewL(aKey);
+	}
+
+void CAsymmetricCipherImpl::SetCryptoModeL(TUid aCryptoMode)
+	{
+	DoSetCryptoModeL(aCryptoMode);
+	Reset();
+	}
+	
+void CAsymmetricCipherImpl::DoSetCryptoModeL(TUid aCryptoMode)
+	{
+	switch (aCryptoMode.iUid)
+		{
+		case KCryptoModeEncrypt:
+		case KCryptoModeDecrypt:
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+	iCryptoMode = aCryptoMode;
+	}
+
+void CAsymmetricCipherImpl::SetPaddingModeL(TUid aPaddingMode)
+	{
+	DoSetPaddingModeL(aPaddingMode);
+	Reset();
+	}
+	
+void CAsymmetricCipherImpl::DoSetPaddingModeL(TUid aPaddingMode)
+	{
+	CPadding* padding(0);
+	TInt padlength = 0;
+	
+	switch (iCryptoMode.iUid)
+		{
+		case KCryptoModeEncrypt:
+			padlength = GetMaximumOutputLengthL();
+			break;
+		case KCryptoModeDecrypt:
+			padlength = GetMaximumInputLengthL();
+			break;
+		}
+		
+	switch (aPaddingMode.iUid)
+		{
+		case KPaddingModeNone:
+			padding = CPaddingNone::NewL(padlength);
+			break;
+		case KPaddingModePkcs1_v1_5_Encryption:
+			padding = CPaddingPKCS1Encryption::NewL(padlength);
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+		
+	delete iPadding;
+	iPadding = padding;
+	iPaddingMode = aPaddingMode;
+	}
+
+// Methods implemented in subclass. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+TInt CAsymmetricCipherImpl::GetMaximumOutputLengthL() const
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
+
+TInt CAsymmetricCipherImpl::GetMaximumInputLengthL() const
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/asymmetriccipherimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,137 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+#ifndef __ASYMMETRICCIPHERIMPL_H__
+#define __ASYMMETRICCIPHERIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <cryptospi/cryptospidef.h>
+#include <padding.h>
+#include "asymmetriccipherplugin.h"
+#include "keys.h"
+#include "common/inlines.h"
+
+/**
+ * Abstract base class for symmetric cipher plug-ins.
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CAsymmetricCipherImpl) : public CBase, public MAsymmetricCipher
+		{
+	public:
+		
+		// Override MPlugin virtual functions
+		void Close();
+		void Reset(); // Always call reset in super-class if you override this
+		TAny* GetExtension(TUid aExtensionId);
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		// End of MPlugin
+		
+		// Override MAsymmetricCipherBase virtual functions
+		void SetKeyL(const CKey& aKey);             // override DoSetKeyL instead
+		void SetCryptoModeL(TUid aCryptoMode);      // override DoSetCryptoModeL instead
+		void SetPaddingModeL(TUid aPaddingMode);    // override DoSetPaddingModeL instead
+		virtual TInt GetMaximumInputLengthL() const;
+		virtual TInt GetMaximumOutputLengthL() const;
+		// End of MAsymmetricCipherBase
+		
+		// Override MAsymmetricCipher virtual functions
+		virtual void ProcessL(const TDesC8& aInput, TDes8& aOutput) = 0;
+		// End of MAsymmetricCipher
+		
+		/// Destructor
+		~CAsymmetricCipherImpl();
+		
+	protected:
+		/**
+		Constructor
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPaddingMode The padding mode
+		*/
+		CAsymmetricCipherImpl(TUid aCryptoMode, TUid aPaddingMode);
+
+		/**
+		Second phase of construction. Always call ConstructL in the super-class
+		if you override this method.
+		
+		@param aKey The key to initialise the cipher with.
+		*/
+		virtual void ConstructL(const CKey& aKey);
+		
+		/**
+		Implemented by each cipher subclass to determine whether the
+		specified key length is valid for that cipher.
+		This is called by ConstructL and SetKeyL
+		@param aKeyBytes The key length in bytes to verify.
+		@return ETrue if key length is acceptable
+		*/
+		virtual TBool IsValidKeyLengthL(TInt aKeyBytes) const = 0;
+		
+		/**
+		Helper function implemented by concrete cipher sub-class that allows
+		GetCharacteristicsL to return the correct characteristics object.
+		@return The implemention uid
+		*/
+		virtual TUid ImplementationUid() const = 0;
+		
+		/**
+		Validates and sets the crypto mode (iCryptoMode)
+		@param aCryptoMode The crypto mode
+		*/	
+		virtual void DoSetCryptoModeL(TUid aCryptoMode);
+		
+		/**
+		Extracts the raw key from aKey and sets iKey and iKeyBytes
+		The key length is also checked to meet export restrictions and
+		to ensure that it is appropriate for the cipher.
+		@param aKey The key
+		*/
+		virtual void DoSetKeyL(const CKey& aKey);
+		
+		/**
+		Validates and sets the padding mode (iPaddingMode & iPadding)
+		@param aPadding The desired padding mode
+		*/
+		virtual void DoSetPaddingModeL(TUid aPadding);
+		
+	private:
+			
+	protected:
+		/// encryption or decryption
+		TUid iCryptoMode;
+		
+		/// the current padding scheme
+		TUid iPaddingMode;
+		
+		/// the key
+		CKey* iKey;
+		
+		/// current padding scheme implementation
+		CPadding* iPadding;
+		};
+	}
+
+#endif	//	__ASYMMETRICCIPHERIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/cmacimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,416 @@
+/*
+* 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 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: 
+* Software Mac Implementation
+* plugin-dll headers
+*
+*/
+
+
+/**
+ @file
+*/
+#include "cmacimpl.h"
+#include "pluginconfig.h"
+#include <cryptospi/cryptomacapi.h>
+
+
+using namespace SoftwareCrypto;
+using namespace CryptoSpi;
+
+/**
+ * Constants used to generate Key1, Key2 and Key3
+ */
+const TUint8 K1Constant[] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
+const TUint8 K2Constant[] = {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02};
+const TUint8 K3Constant[] = {0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03};
+
+const TInt KAesXcbcMac96Size = 12;
+
+
+CCMacImpl* CCMacImpl::NewL(const CKey& aKey, CSymmetricCipher* aSymmetricCipher, TInt32 aAlgorithmUid)
+	{
+	CCMacImpl* self = CCMacImpl::NewLC(aKey, aSymmetricCipher, aAlgorithmUid);
+	CleanupStack::Pop(self);
+	return self;
+	}
+														
+CCMacImpl* CCMacImpl::NewLC(const CKey& aKey, CSymmetricCipher* aSymmetricCipher, TInt32 aAlgorithmUid)
+	{
+	CCMacImpl* self = NULL;
+ 	TRAPD(err, self = new (ELeave) CCMacImpl(aSymmetricCipher));
+  	if(err!=KErrNone)
+  		{
+  		delete aSymmetricCipher;
+  		User::Leave(err);
+  		}
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aAlgorithmUid);
+	return self;
+	}
+
+CKey* CCMacImpl::Create128bitKeyL(const CKey& aKey)
+	{
+	TBuf8<KMacBlockSize> keybuffer;
+	CryptoSpi::CKey* key = NULL;
+	
+	const TDesC8& keyContent=aKey.GetTDesC8L(CryptoSpi::KSymmetricKeyParameterUid);
+
+	if( (TUint32)keyContent.Size() > KMacBlockSize)
+		{
+		// Create key
+		CryptoSpi::CCryptoParams* keyParams = CryptoSpi::CCryptoParams::NewLC();
+		keybuffer.SetLength(KMacBlockSize);
+		keybuffer.FillZ();
+		// 'keybuffer' is the key with 128 zero bits.
+		keyParams->AddL(keybuffer, CryptoSpi::KSymmetricKeyParameterUid);
+		key=CryptoSpi::CKey::NewLC(aKey.KeyProperty(),*keyParams);
+		// evaluate final key data.
+		SetKeyL(*key);
+		CleanupStack::PopAndDestroy(2, keyParams);
+		keybuffer.Copy(FinalL(keyContent));
+		// 'keybuffer' contains the final key data.
+		}
+	else 
+		{
+		keybuffer.Copy(keyContent);
+		TUint i;
+		for (i=keybuffer.Size();i<KMacBlockSize;++i)
+			{
+			keybuffer.Append(0);
+			}
+		// 'keybuffer' contains the final key data.
+		}
+	
+	// create a new CKey instance and assign it to iKey using 'keybuffer'.
+	CryptoSpi::CCryptoParams* keyParams = CryptoSpi::CCryptoParams::NewLC();
+	keyParams->AddL(keybuffer, CryptoSpi::KSymmetricKeyParameterUid);
+	key=CryptoSpi::CKey::NewL(aKey.KeyProperty(),*keyParams);
+	CleanupStack::PopAndDestroy(keyParams);	
+
+	// 'key' will contain the final CKey instance.
+	return key;
+	}
+
+void CCMacImpl::SetKeyL(const CKey& aKey)
+	{
+	const TPtrC8 KeyConstant1(K1Constant, KMacBlockSize);
+	const TPtrC8 KeyConstant2(K2Constant, KMacBlockSize);
+	const TPtrC8 KeyConstant3(K3Constant, KMacBlockSize);
+
+	// Initialize the cipher class to encrypt Keyconstants to generate additional keys.
+	if (iImplementationUid == CryptoSpi::KAlgorithmCipherAesXcbcPrf128)
+		{
+		// RFC 4434: keys that were not equal in length to 128 bits will no longer be
+		// rejected but instead will be made 128 bits for AES-XCBC-PRF-128 Algorithm only.
+		CryptoSpi::CKey* key = Create128bitKeyL(aKey);
+		CleanupStack::PushL(key);
+		iCipherImpl->SetKeyL(*key);
+		CleanupStack::PopAndDestroy(key);	
+		}
+	else
+		{
+		iCipherImpl->SetKeyL(aKey);
+		}
+	iCipherImpl->SetCryptoModeL(CryptoSpi::KCryptoModeEncryptUid);
+	iCipherImpl->SetOperationModeL(CryptoSpi::KOperationModeNoneUid);
+
+	// cipher class expects the output buffer to be empty.
+	iKey1.Zero();
+	iKey2.Zero();
+	iKey3.Zero();
+
+	// aKey is used to generate Key1, Key2 and Key3.
+	// Where Key1 = encrypt KeyConstant1 with aKey
+	// Where Key2 = encrypt KeyConstant2 with aKey
+	// Where Key3 = encrypt KeyConstant3 with aKey
+	
+	// Key1 is used to encrypt the data whereas
+	// Key2 and Key3 is used to XOR with the last 
+	// block.
+    iCipherImpl->ProcessFinalL(KeyConstant1, iKey1);
+	iCipherImpl->ProcessFinalL(KeyConstant2, iKey2);
+	iCipherImpl->ProcessFinalL(KeyConstant3, iKey3);
+	
+	// Create CKey instance with key1
+	CCryptoParams* keyParam =CCryptoParams::NewLC();
+ 	keyParam->AddL(iKey1, CryptoSpi::KSymmetricKeyParameterUid);
+
+ 	delete iKey;
+ 	iKey = NULL;
+ 	iKey=CKey::NewL(aKey.KeyProperty(), *keyParam);
+ 	// Initialize the cipher class for MAC calculation.
+	iCipherImpl->SetKeyL(*iKey);
+ 	iCipherImpl->SetOperationModeL(CryptoSpi::KOperationModeCBCUid);
+ 	Mem::FillZ(iE, sizeof(iE));
+ 	iCipherImpl->SetIvL(TPtrC8(iE, KMacBlockSize));
+
+ 	CleanupStack::PopAndDestroy(keyParam);
+	}
+
+CCMacImpl::~CCMacImpl()
+	{
+	delete iKey;
+	delete iCipherImpl;
+	}
+
+CCMacImpl::CCMacImpl(const CCMacImpl& aCCMacImpl)
+	{
+	iImplementationUid = aCCMacImpl.iImplementationUid;
+	iKey1.Copy(aCCMacImpl.iKey1);
+	iKey2.Copy(aCCMacImpl.iKey2);
+	iKey3.Copy(aCCMacImpl.iKey3);
+	
+	(void)Mem::Copy(iE, aCCMacImpl.iE, sizeof(iE));
+	(void)Mem::Copy(iData, aCCMacImpl.iData, sizeof(iData));
+	
+	iCurrentTotalLength = aCCMacImpl.iCurrentTotalLength;
+	}
+
+const CExtendedCharacteristics* CCMacImpl::GetExtendedCharacteristicsL()
+	{
+	return iCipherImpl->GetExtendedCharacteristicsL();
+	}
+
+CCMacImpl::CCMacImpl(CryptoSpi::CSymmetricCipher* aSymmetricCipher)
+	{
+	iCipherImpl = aSymmetricCipher;
+	aSymmetricCipher = NULL;
+	iMacValue.SetLength(KMacBlockSize);
+	}
+
+void CCMacImpl::ConstructL(const CKey& aKey, TInt32 aAlgorithmUid) 
+	{
+	iImplementationUid = aAlgorithmUid;
+	
+    switch(aAlgorithmUid)
+    	{
+    	case CryptoSpi::KAlgorithmCipherAesXcbcMac96:
+    	case CryptoSpi::KAlgorithmCipherAesXcbcPrf128:
+    		{
+    		SetKeyL(aKey);
+     		break;
+    		}
+    	default:
+    		{
+    		User::Leave(KErrNotSupported);
+    		}
+    	}
+	}
+
+/**
+ * Takes the message and XOR it with iData.
+ * 
+ * @param aKey 128bit key. This key will be XORed with iData.
+ * @param aOutput  The result of the XOR operation will be copied to this.
+ * 				   Its length should be 128bit (16bytes).
+ */
+
+void CCMacImpl::XORKeyWithData(const TDesC8& aKey, TDes8& aOutput)
+	{
+	for (TInt i = 0; i < KMacBlockSize; ++i)
+		{
+		aOutput[i] = iData[i] ^ aKey[i];
+		}
+	}
+
+/**
+ * This function is used to pad message M to make the total message
+ * length multiple of block size (128bit). The last block M[n] will be 
+ * padded with a single "1" bit followed by the number of "0" bits required
+ * to increase M[n]'s size to 128 bits (Block Size).
+ * 
+ * Used in AES-XCBC-MAC-96 and AES-XCBC-PRF-128 Mac algorithms.
+ */
+void CCMacImpl::PadMessage()
+	{
+	if(iCurrentTotalLength < KMacBlockSize)
+		{
+		iData[iCurrentTotalLength] = 0x80;
+		Mem::FillZ(iData + iCurrentTotalLength+1, KMacBlockSize - iCurrentTotalLength - 1);
+		}
+	}
+
+void CCMacImpl::Reset()
+	{
+	Mem::FillZ(iE,sizeof(iE));
+	iCurrentTotalLength =0;
+	// record for Reset, for the next time MacL, UpdateL or FinalL is called as we
+	// cannot leave in Reset.
+	TRAP(iDelayedReset, iCipherImpl->SetIvL(TPtrC8(iE, KMacBlockSize)));
+	}
+
+TPtrC8 CCMacImpl::MacL(const TDesC8& aMessage)
+	{
+	// Reset the cipher with iE as 128 zero bits as it leaved in previous call to Reset. 
+	if (iDelayedReset != KErrNone)
+		{
+		// iE was reset to 128 zero bits in previous call to Reset which leaved.
+		iCipherImpl->SetIvL(TPtrC8(iE, KMacBlockSize));
+		iDelayedReset = KErrNone; 
+		}
+	
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdateL(aMessage);			
+		}
+	
+	// Calculate MAC
+	TPtrC8 macPtr(KNullDesC8());
+	macPtr.Set(DoFinalL());
+
+	// Restore the internal state.
+	// We don't want to save any state change happened in 
+	// DoFinalL.
+	// iE is not updated in DoFinalL function and hence
+	// can be used to reset iCipherImpl to previous state.
+	iCipherImpl->SetIvL(TPtrC8(iE, KMacBlockSize));
+	
+	return macPtr;		
+	}
+
+TPtrC8 CCMacImpl::FinalL(const TDesC8& aMessage)
+	{
+	// Reset the cipher with iE as 128 zero bits as it leaved in previous call to Reset. 
+	if (iDelayedReset == KErrNone)
+		{
+		// iE was reset to 128 zero bits in previous call to Reset which leaved.
+		iCipherImpl->SetIvL(TPtrC8(iE, KMacBlockSize));
+		iDelayedReset = KErrNone;
+		}
+
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdateL(aMessage);			
+		}
+	TPtrC8 macPtr(KNullDesC8());
+	macPtr.Set(DoFinalL());
+	Reset();
+	return macPtr;
+	}
+
+void CCMacImpl::UpdateL(const TDesC8& aMessage)
+	{
+	// Reset the cipher with iE as 128 zero bits as it leaved in previous call to Reset. 
+	if (iDelayedReset == KErrNone)
+		{
+		// iE was reset to 128 zero bits in previous call to Reset which leaved.
+		iCipherImpl->SetIvL(TPtrC8(iE, KMacBlockSize));
+		iDelayedReset = KErrNone;
+		}
+
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdateL(aMessage);			
+		}
+	}
+
+void CCMacImpl::ProcessBlockL()
+	{
+	TPtrC8 dataPtr(iData, KMacBlockSize);
+	TPtr8 intermediateCipherPtr(iE,0,KMacBlockSize);
+	// iData (Block) should be XORed with iE calculated
+	// from previoue processing. If it's the first processing
+	// then iE will be zero.
+	// Here we are not doing explicit XORing because iCpherImpl 
+	// is set in CBC mode. Therefore this operation will be
+	// done by iCipherImpl
+	iCipherImpl->ProcessL(dataPtr, intermediateCipherPtr);
+	// After processing discard the block.
+	iCurrentTotalLength = 0;
+	}
+
+void CCMacImpl::DoUpdateL(const TDesC8& aMessage)
+	{
+	TInt curLength = aMessage.Length();
+	const TUint8* msgPtr = aMessage.Ptr();
+	
+	while(curLength > 0)
+		{
+		// If block is formed then process it.
+		if(iCurrentTotalLength == KMacBlockSize)
+			ProcessBlockL();
+		
+		// Check the space left in the block.
+		TUint remainingLength = KMacBlockSize - iCurrentTotalLength;
+		// If unprocesed message length is less then remainingLength
+		// then copy the entire data to iData else copy till iData
+		// if full.
+		TUint length = Min(curLength, remainingLength);
+
+		
+		// Discard the return value obtained from Mem::Copy( ) function.		
+		(void)Mem::Copy(iData+iCurrentTotalLength, msgPtr, length);
+		// Update data offset
+		iCurrentTotalLength += length;
+		curLength -= length;
+		msgPtr += length;
+		}
+ 	}
+
+TPtrC8 CCMacImpl::DoFinalL()
+	{
+	TBuf8<KMacBlockSize> finalBlock;
+	finalBlock.SetLength(KMacBlockSize);
+	
+	// If padding is required then use Key3
+	// else use Key2.
+	if(iCurrentTotalLength < KMacBlockSize)
+		{
+		PadMessage();
+		XORKeyWithData(iKey3, finalBlock);
+		}
+	else
+		{
+		XORKeyWithData(iKey2, finalBlock);
+		}
+
+	// cipher class expects the output buffer to be empty.
+	iMacValue.Zero();
+
+	iCipherImpl->ProcessFinalL(finalBlock, iMacValue);
+	
+    return (iImplementationUid == CryptoSpi::KAlgorithmCipherAesXcbcMac96)? iMacValue.Left(KAesXcbcMac96Size): TPtrC8(iMacValue);
+	}
+
+void CCMacImpl::ReInitialiseAndSetKeyL(const CKey& aKey)
+	{
+	Reset();
+	SetKeyL(aKey);
+	}
+
+
+CCMacImpl* CCMacImpl::CopyL()
+	{
+	CCMacImpl* clone = new(ELeave) CCMacImpl(*this);
+	CleanupStack::PushL(clone);
+	clone->iKey = CKey::NewL(*iKey);
+	CryptoSpi::CSymmetricCipherFactory::CreateSymmetricCipherL(clone->iCipherImpl,
+												CryptoSpi::KAesUid,
+												*iKey,
+												CryptoSpi::KCryptoModeEncryptUid,
+												CryptoSpi::KOperationModeCBCUid,
+												CryptoSpi::KPaddingModeNoneUid,
+												NULL);
+	clone->iCipherImpl->SetIvL(TPtrC8(clone->iE, KMacBlockSize));
+	CleanupStack::Pop();
+	return clone;	
+	}
+	
+CCMacImpl* CCMacImpl::ReplicateL()
+	{
+	CCMacImpl* replica = CopyL();
+	replica->Reset();
+	return replica;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/cmacimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,132 @@
+/*
+* 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 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: 
+* Cipher MAC plugin implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWARECIPHERMACIMPL_H__
+#define __CRYPTOAPI_SOFTWARECIPHERMACIMPL_H__
+
+#include "cryptosymmetriccipherapi.h"
+#include "keys.h"
+
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+		
+	/**
+	 * This is the maximum block size in bytes currently supported by CMAC implementation.
+	 * 
+	 * The cipher based algorithms currently supported are
+	 * AES-XCBC-MAC-96 and AES-XCBC-PRF-128.
+	 */  
+	const TInt KMacBlockSize = 16;		
+	
+	/** 
+	 * The class is created from following substance classes
+	 * 1. MMac
+	 * 2. CSymmetricCipher
+	 * Using the methods of the above classes we will transform/mould the Cipher methods in
+	 * a way as to be inline with the MMac interface methods. The MMac methods will
+	 * serve as the wrapper internal to which Cipher methods will work to provide the MAC value.
+	 * 
+	 * The class was created to provide consistency/similarity HMAC and CMAC works.
+	 * Also for future extensibility of other Cipher algorithms.
+	 */		
+	NONSHARABLE_CLASS(CCMacImpl) : public CBase
+		{		
+	public:
+		/**
+		 * Cipher MAC implementation instance creation methods
+		 *
+		 *The owneship of 'aSymmetricCipher' is imparted to instance of this class.
+		 */
+		static CCMacImpl* NewL(const CKey& aKey,
+			        		   CSymmetricCipher* aSymmetricCipher,	
+				               TInt32 aAlgorithmUid);
+		
+		static CCMacImpl* NewLC(const CKey& aKey, 
+							    CSymmetricCipher* aSymmetricCipher,	
+							    TInt32 aAlgorithmUid);
+		/**
+		 * Simulating Methods from MPlugin
+		 */
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		
+		// We will call CSymmetricBlockCipherImpl::Reset();
+		void Reset();
+		
+		/**
+		 *  Simulating MAC interfaces (Software based)
+		 */
+	    TPtrC8 MacL(const TDesC8& aMessage);
+        void UpdateL(const TDesC8& aMessage);
+        TPtrC8 FinalL(const TDesC8& aMessage);
+		void ReInitialiseAndSetKeyL(const CKey& aKey);    
+		void SetKeyL(const CKey& aKey);
+		~CCMacImpl();
+		CCMacImpl* CopyL();
+		CCMacImpl* ReplicateL();
+		
+	private:
+	    /**
+		 * Constructors
+		 */
+    	CCMacImpl(CryptoSpi::CSymmetricCipher* aSymmetricCipher);
+		CCMacImpl(const CCMacImpl&);
+		
+		/**
+		 * Initialize the 'iCipherImpl' instances.
+		 */
+		void ConstructL(const CKey& aKey, TInt32 aAlgorithmUid);
+		void DoUpdateL(const TDesC8& aMessage);
+		TPtrC8 DoFinalL();
+		void PadMessage();
+		void ProcessBlockL();
+		void XORKeyWithData(const TDesC8& aKey, TDes8& aOutput);
+		CKey* Create128bitKeyL(const CKey& aKey);		
+		
+	private:			
+		TInt32 iImplementationUid; 
+		CKey* iKey;
+		CryptoSpi::CSymmetricCipher* iCipherImpl;
+		
+		TBuf8<KMacBlockSize> iKey1;
+		TBuf8<KMacBlockSize> iKey2;
+		TBuf8<KMacBlockSize> iKey3;
+		TBuf8<KMacBlockSize> iMacValue;
+	
+		TUint8 iE[KMacBlockSize];
+		TUint8 iData[KMacBlockSize];
+		TInt iCurrentTotalLength;
+		// Resets the cipher with iE(128 zero bits) the next time MacL, 
+		// UpdateL or FinalL are called. This was introduced as we cannot leave from the
+		// non-leaving CCMacImpl::Reset() implementation of the MPlugin::Reset() pure 
+		// virtual. To prevent behavioral break.
+		TInt iDelayedReset;
+		};
+	}
+
+#endif // __CRYPTOAPI_SOFTWARECIPHERMACIMPL_H__
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/des.inl	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,76 @@
+/*
+* Copyright (c) 2003-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: 
+*
+*/
+
+
+#ifndef __DES_INL__
+#define __DES_INL__
+
+inline void IPerm(TUint32& left, TUint32& right)
+	{
+	TUint32 work;
+
+	right = rotlFixed(right, 4U);
+	work = (left ^ right) & 0xf0f0f0f0;
+	left ^= work;
+	right = rotrFixed(right^work, 20U);
+	work = (left ^ right) & 0xffff0000;
+	left ^= work;
+	right = rotrFixed(right^work, 18U);
+	work = (left ^ right) & 0x33333333;
+	left ^= work;
+	right = rotrFixed(right^work, 6U);
+	work = (left ^ right) & 0x00ff00ff;
+	left ^= work;
+	right = rotlFixed(right^work, 9U);
+	work = (left ^ right) & 0xaaaaaaaa;
+	left = rotlFixed(left^work, 1U);
+	right ^= work;
+	}
+
+inline void FPerm(TUint32& left, TUint32& right)
+	{
+	TUint32 work;
+
+	right = rotrFixed(right, 1U);
+	work = (left ^ right) & 0xaaaaaaaa;
+	right ^= work;
+	left = rotrFixed(left^work, 9U);
+	work = (left ^ right) & 0x00ff00ff;
+	right ^= work;
+	left = rotlFixed(left^work, 6U);
+	work = (left ^ right) & 0x33333333;
+	right ^= work;
+	left = rotlFixed(left^work, 18U);
+	work = (left ^ right) & 0xffff0000;
+	right ^= work;
+	left = rotlFixed(left^work, 20U);
+	work = (left ^ right) & 0xf0f0f0f0;
+	right ^= work;
+	left = rotrFixed(left^work, 4U);
+	}
+
+inline void ReverseKeySchedule(TUint32* aKey)
+	{
+	TInt i = 0;
+	for (; i<16; i+=2)
+		{
+		TClassSwap((*(aKey+i)), (*(aKey+(32-2-i))));
+		TClassSwap((*(aKey+i+1)), (*(aKey+(32-1-i))));
+		}
+	}
+
+#endif //__DES_INL__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/desimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,249 @@
+/*
+* Copyright (c) 2006-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 "desimpl.h"
+
+#include "destables.h"
+#include "common/inlines.h"
+#include "des.inl"
+#include "pluginconfig.h"
+#include "symmetriccipherimpl.h"
+#include <cryptostrength.h>
+
+
+//	bit 0 is left-most in byte
+static const TInt bytebit[] = {0200,0100,040,020,010,04,02,01};
+
+using namespace SoftwareCrypto;
+
+/* CDesImpl */
+CDesImpl::CDesImpl(
+	TUint8 aBlockBytes,
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPadding) :
+	CSymmetricBlockCipherImpl(aBlockBytes, aCryptoMode, aOperationMode, aPadding)
+	{
+	}
+
+CDesImpl* CDesImpl::NewL(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)
+	{
+	CDesImpl* self = CDesImpl::NewLC(aKey, aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CDesImpl* CDesImpl::NewLC(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)
+	{
+	CDesImpl* self = new(ELeave) CDesImpl(KDesBlockBytes, aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	
+	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyContent.Size()) - keyContent.Size());
+	return self;
+	}
+		
+CDesImpl::~CDesImpl()
+	{
+	// make sure key information isn't visible to other processes if the
+	// page is reused.
+	Mem::FillZ(&iK, sizeof(iK));
+	}
+	
+void CDesImpl::ConstructL(const CKey& aKey)
+	{
+	CSymmetricBlockCipherImpl::ConstructL(aKey);
+	SetKeySchedule();
+	}		
+	
+CExtendedCharacteristics* CDesImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+	
+const CExtendedCharacteristics* CDesImpl::GetExtendedCharacteristicsL()
+	{
+	return CDesImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CDesImpl::ImplementationUid() const
+	{
+	return KCryptoPluginDesUid;
+	}
+	
+TBool CDesImpl::IsValidKeyLength(TInt aKeyBytes) const
+	{
+	return (aKeyBytes == KDesKeyBytes);
+	}
+	
+TInt CDesImpl::GetKeyStrength() const
+	{
+	// parity bits are excluded
+	return BytesToBits(KDesKeyBytes - 8);
+	}	
+	
+void CDesImpl::TransformEncrypt(
+	TUint8* aBuffer,
+	TUint aNumBlocks)
+	{
+	for (TInt i = 0; i < aNumBlocks; ++i)
+		{		
+		ModeEncryptStart(aBuffer);
+		TUint32 l, r;
+		// Split the block into 2 word-sized big endian portions
+		GetBlockBigEndian(aBuffer, l, r);
+		IPerm(l,r);
+		DoTransform(l, r, iK);		
+		FPerm(l,r);
+
+		// Put the portions back into the block as little endian
+		PutBlockBigEndian(aBuffer, r, l);
+
+		ModeEncryptEnd(aBuffer);
+		aBuffer += KDesBlockBytes;
+		}
+	}	
+	
+void CDesImpl::TransformDecrypt(
+	TUint8* aBuffer,
+	TUint aNumBlocks)
+	{
+	for (TInt i = 0; i < aNumBlocks; ++i)
+		{		
+		ModeDecryptStart(aBuffer);
+
+		TUint32 l, r;
+		// Split the block into 2 word-sized big endian portions
+		GetBlockBigEndian(aBuffer, l, r);
+
+		IPerm(l,r);
+		DoTransform(l, r, iK);		
+		FPerm(l,r);
+
+		// Put the portions back into the block as little endian
+		PutBlockBigEndian(aBuffer, r, l);
+
+		ModeDecryptEnd(aBuffer);
+		aBuffer += KDesBlockBytes;
+		}
+	}
+
+void CDesImpl::SetKeySchedule()
+	{
+	if (iCryptoMode.iUid == KCryptoModeEncrypt)
+		{
+		SetEncryptKeySchedule(*iKey, iK);
+		}
+	else 
+		{
+		ASSERT(iCryptoMode.iUid == KCryptoModeDecrypt);
+		SetDecryptKeySchedule(*iKey, iK);
+		}	
+	}		
+
+void CDesImpl::DoTransform(TUint32& l, TUint32& r, const TUint32* aKeySchedule)
+	{
+	TInt i = 0;
+	for (; i<8; i++)
+		{
+		TUint32 work = rotrFixed(r, 4U) ^ aKeySchedule[4*i+0];
+		l ^= DES_TABLE::sbox[6][(work) & 0x3f]
+		  ^  DES_TABLE::sbox[4][(work >> 8) & 0x3f]
+		  ^  DES_TABLE::sbox[2][(work >> 16) & 0x3f]
+		  ^  DES_TABLE::sbox[0][(work >> 24) & 0x3f];
+		work = r ^ aKeySchedule[4*i+1];
+		l ^= DES_TABLE::sbox[7][(work) & 0x3f]
+		  ^  DES_TABLE::sbox[5][(work >> 8) & 0x3f]
+		  ^  DES_TABLE::sbox[3][(work >> 16) & 0x3f]
+		  ^  DES_TABLE::sbox[1][(work >> 24) & 0x3f];
+
+		work = rotrFixed(l, 4U) ^ aKeySchedule[4*i+2];
+		r ^= DES_TABLE::sbox[6][(work) & 0x3f]
+		  ^  DES_TABLE::sbox[4][(work >> 8) & 0x3f]
+		  ^  DES_TABLE::sbox[2][(work >> 16) & 0x3f]
+		  ^  DES_TABLE::sbox[0][(work >> 24) & 0x3f];
+		work = l ^ aKeySchedule[4*i+3];
+		r ^= DES_TABLE::sbox[7][(work) & 0x3f]
+		  ^  DES_TABLE::sbox[5][(work >> 8) & 0x3f]
+		  ^  DES_TABLE::sbox[3][(work >> 16) & 0x3f]
+		  ^  DES_TABLE::sbox[1][(work >> 24) & 0x3f];
+		}
+	}	
+
+void CDesImpl::SetEncryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule)
+	{
+	TInt i=0, j=0, l=0, m=0;
+
+//	Form a byte array from aKey, taking endianess into account (little->big)	
+	TUint8 key[8];								//	For big endian byte array	
+	Mem::Copy(&key, &aKey[0], 8);
+
+	TUint8 buffer[56+56+8];
+	TUint8* const pc1m = &buffer[0];			/* place to modify pc1 into */
+	TUint8* const pcr = pc1m + 56;				/* place to rotate pc1 into */
+	TUint8* const ks = pcr + 56;
+
+	for (j=0; j<56; j++) 
+		{/* convert pc1 to bits of key */
+		l = DES_TABLE::pc1[j]-1;				/* integer bit location  */
+		m = l & 07;								/* find bit              */
+		pc1m[j]=(key[l>>3] &					/* find which key byte l is in */
+			bytebit[m])							/* and which bit of that byte */
+			? (TUint8)1 : (TUint8)0;			/* and store 1-bit result */
+		}
+
+	for (i=0; i<16; i++) 
+		{/* key chunk for each iteration */
+		Mem::FillZ(ks,8);							/* Clear key schedule */
+		for (j=0; j<56; j++)
+		/*	rotate pc1 the right amount */
+			pcr[j] = pc1m[(l=j+DES_TABLE::totrot[i])<(j<28? 28 : 56) ? l: l-28];
+		
+		/* rotate left and right halves independently */
+		
+		for (j=0; j<48; j++)
+			{/* select bits individually */
+			/* check bit that goes to ks[j] */
+			if (pcr[DES_TABLE::pc2[j]-1])
+				{/* mask it in if it's there */
+				l= j % 6;
+				ks[j/6] |= bytebit[l] >> 2;
+				}
+			}
+
+		/* Now convert to odd/even interleaved form for use in F */
+		(*(aKeySchedule+(2*i))) = ((TUint32)ks[0] << 24)
+			| ((TUint32)ks[2] << 16)
+			| ((TUint32)ks[4] << 8)
+			| ((TUint32)ks[6]);
+		
+		(*(aKeySchedule+(2*i+1))) = ((TUint32)ks[1] << 24)
+			| ((TUint32)ks[3] << 16)
+			| ((TUint32)ks[5] << 8)
+			| ((TUint32)ks[7]);
+		}		
+	}
+
+void CDesImpl::SetDecryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule)
+	{
+	SetEncryptKeySchedule(aKey, aKeySchedule);
+	ReverseKeySchedule(aKeySchedule);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/desimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,140 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef	__DESIMPL_H__
+#define	__DESIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keys.h"
+#include "symmetriccipherimpl.h"
+
+/**
+Plug-in class for DES block cipher
+*/
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CDesImpl) : public CSymmetricBlockCipherImpl
+		{
+	public:
+		/**
+		Creates an instance of a DES (Data Encryption Standard) symmetric cipher plug-in.
+		@param aKey The key
+		@param aCryptoMode whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a CDesImpl instance
+		*/
+		static CDesImpl* NewL(const CKey& aKey, 
+			TUid aCryptoMode, TUid aOperationMode, TUid aPadding);
+
+		/**
+		Creates an instance of a DES (Data Encryption Standard) symmetric cipher plug-in.
+		A pointer to the plug-in instance is placed on the cleanup stack.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode T block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a CDesImpl instance
+		*/
+		static CDesImpl* NewLC(const CKey& aKey, 
+			TUid aCryptoMode,	TUid aOperationMode, TUid aPadding);
+		
+		// From CSymmetricCipherImpl
+		TInt GetKeyStrength() const;
+		TBool IsValidKeyLength(TInt aKeyBytes) const;
+		TUid ImplementationUid() const;
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+				
+		/// Destructor
+		~CDesImpl();		
+	protected:
+		/**
+		Constructor
+		@param aBlockBytes The block size in bytes (needed to allow
+		3DES implementation to inherit from this class)
+		@param aOperationMode The mode of operation e.g. CBC
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPaddingMode The padding mode to use. None, SSL, PKCS#7
+		*/
+		CDesImpl(TUint8 aBlockBytes, TUid aOperationMode, TUid aCryptoMode, TUid aPaddingMode);
+		
+		/**	
+		Second phase of construction
+		@param aKey The key object
+		*/
+		void ConstructL(const CKey& aKey);	
+			
+		// These protected functions are re-used by 3DES
+		/**
+		Transforms a block of data
+		@param l The left half of the block to transform
+		@param r The right half of the block to transform
+		@param aKeySchedule The keyschedule to use for the transformation
+		*/
+		void DoTransform(TUint32& l, TUint32& r, const TUint32* aKeySchedule);
+		
+		/**
+		Setup the key schedule for encryption
+		@param aKey The input key
+		@param aKeySchedule A pointer to the key schedule buffer
+		*/
+		void SetEncryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule);
+		
+		/**
+		Setup the key schedule for decryption
+		@param aKey The input key
+		@param aKeySchedule A pointer to the key schedule buffer		
+		*/
+		void SetDecryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule);
+		
+		static const TUint8 KDesBlockBytes = 8;
+		static const TUint8 KDesKeyBytes = 8;						
+
+	private:														
+
+		/**
+		Creates the key schedule iK from CBlockTransformationImpl::iKey.
+		This should be called from ConstructL and Reset
+		*/
+		void SetKeySchedule();			
+
+		// From CSymmetricBlockCipherImpl
+		void TransformEncrypt(TUint8* aBuffer, TUint aNumBlocks);
+		void TransformDecrypt(TUint8* aBuffer, TUint aNumBlocks);
+					
+	private:
+		/// Size of the key schedule in words
+		static const TUint KKeyScheduleSize = 32;
+		
+		/// the key schedule
+		TUint32 iK[KKeyScheduleSize];
+		};
+	}
+
+#endif // __DESIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/destables.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,184 @@
+/*
+* Copyright (c) 2002-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __DESTABLES_H__
+#define __DESTABLES_H__
+
+#include <e32std.h>
+
+namespace DES_TABLE
+{
+/* initial permutation IP */
+const TUint8 ip[] = {
+	   58, 50, 42, 34, 26, 18, 10,  2,
+	   60, 52, 44, 36, 28, 20, 12,  4,
+	   62, 54, 46, 38, 30, 22, 14,  6,
+	   64, 56, 48, 40, 32, 24, 16,  8,
+	   57, 49, 41, 33, 25, 17,  9,  1,
+	   59, 51, 43, 35, 27, 19, 11,  3,
+	   61, 53, 45, 37, 29, 21, 13,  5,
+	   63, 55, 47, 39, 31, 23, 15,  7
+};
+
+/* final permutation IP^-1 */
+const TUint8 fp[] = {
+	   40,  8, 48, 16, 56, 24, 64, 32,
+	   39,  7, 47, 15, 55, 23, 63, 31,
+	   38,  6, 46, 14, 54, 22, 62, 30,
+	   37,  5, 45, 13, 53, 21, 61, 29,
+	   36,  4, 44, 12, 52, 20, 60, 28,
+	   35,  3, 43, 11, 51, 19, 59, 27,
+	   34,  2, 42, 10, 50, 18, 58, 26,
+	   33,  1, 41,  9, 49, 17, 57, 25
+};
+
+/* expansion operation matrix */
+const TUint8 ei[] = {
+	   32,  1,  2,  3,  4,  5,
+		4,  5,  6,  7,  8,  9,
+		8,  9, 10, 11, 12, 13,
+	   12, 13, 14, 15, 16, 17,
+	   16, 17, 18, 19, 20, 21,
+	   20, 21, 22, 23, 24, 25,
+	   24, 25, 26, 27, 28, 29,
+	   28, 29, 30, 31, 32,  1
+};
+
+const TUint32 sbox[8][64] = {
+{
+0x01010400,0x00000000,0x00010000,0x01010404, 0x01010004,0x00010404,0x00000004,0x00010000,
+0x00000400,0x01010400,0x01010404,0x00000400, 0x01000404,0x01010004,0x01000000,0x00000004,
+0x00000404,0x01000400,0x01000400,0x00010400, 0x00010400,0x01010000,0x01010000,0x01000404,
+0x00010004,0x01000004,0x01000004,0x00010004, 0x00000000,0x00000404,0x00010404,0x01000000,
+0x00010000,0x01010404,0x00000004,0x01010000, 0x01010400,0x01000000,0x01000000,0x00000400,
+0x01010004,0x00010000,0x00010400,0x01000004, 0x00000400,0x00000004,0x01000404,0x00010404,
+0x01010404,0x00010004,0x01010000,0x01000404, 0x01000004,0x00000404,0x00010404,0x01010400,
+0x00000404,0x01000400,0x01000400,0x00000000, 0x00010004,0x00010400,0x00000000,0x01010004},
+{
+0x80108020,0x80008000,0x00008000,0x00108020, 0x00100000,0x00000020,0x80100020,0x80008020,
+0x80000020,0x80108020,0x80108000,0x80000000, 0x80008000,0x00100000,0x00000020,0x80100020,
+0x00108000,0x00100020,0x80008020,0x00000000, 0x80000000,0x00008000,0x00108020,0x80100000,
+0x00100020,0x80000020,0x00000000,0x00108000, 0x00008020,0x80108000,0x80100000,0x00008020,
+0x00000000,0x00108020,0x80100020,0x00100000, 0x80008020,0x80100000,0x80108000,0x00008000,
+0x80100000,0x80008000,0x00000020,0x80108020, 0x00108020,0x00000020,0x00008000,0x80000000,
+0x00008020,0x80108000,0x00100000,0x80000020, 0x00100020,0x80008020,0x80000020,0x00100020,
+0x00108000,0x00000000,0x80008000,0x00008020, 0x80000000,0x80100020,0x80108020,0x00108000},
+{
+0x00000208,0x08020200,0x00000000,0x08020008, 0x08000200,0x00000000,0x00020208,0x08000200,
+0x00020008,0x08000008,0x08000008,0x00020000, 0x08020208,0x00020008,0x08020000,0x00000208,
+0x08000000,0x00000008,0x08020200,0x00000200, 0x00020200,0x08020000,0x08020008,0x00020208,
+0x08000208,0x00020200,0x00020000,0x08000208, 0x00000008,0x08020208,0x00000200,0x08000000,
+0x08020200,0x08000000,0x00020008,0x00000208, 0x00020000,0x08020200,0x08000200,0x00000000,
+0x00000200,0x00020008,0x08020208,0x08000200, 0x08000008,0x00000200,0x00000000,0x08020008,
+0x08000208,0x00020000,0x08000000,0x08020208, 0x00000008,0x00020208,0x00020200,0x08000008,
+0x08020000,0x08000208,0x00000208,0x08020000, 0x00020208,0x00000008,0x08020008,0x00020200},
+{
+0x00802001,0x00002081,0x00002081,0x00000080, 0x00802080,0x00800081,0x00800001,0x00002001,
+0x00000000,0x00802000,0x00802000,0x00802081, 0x00000081,0x00000000,0x00800080,0x00800001,
+0x00000001,0x00002000,0x00800000,0x00802001, 0x00000080,0x00800000,0x00002001,0x00002080,
+0x00800081,0x00000001,0x00002080,0x00800080, 0x00002000,0x00802080,0x00802081,0x00000081,
+0x00800080,0x00800001,0x00802000,0x00802081, 0x00000081,0x00000000,0x00000000,0x00802000,
+0x00002080,0x00800080,0x00800081,0x00000001, 0x00802001,0x00002081,0x00002081,0x00000080,
+0x00802081,0x00000081,0x00000001,0x00002000, 0x00800001,0x00002001,0x00802080,0x00800081,
+0x00002001,0x00002080,0x00800000,0x00802001, 0x00000080,0x00800000,0x00002000,0x00802080},
+{
+0x00000100,0x02080100,0x02080000,0x42000100, 0x00080000,0x00000100,0x40000000,0x02080000,
+0x40080100,0x00080000,0x02000100,0x40080100, 0x42000100,0x42080000,0x00080100,0x40000000,
+0x02000000,0x40080000,0x40080000,0x00000000, 0x40000100,0x42080100,0x42080100,0x02000100,
+0x42080000,0x40000100,0x00000000,0x42000000, 0x02080100,0x02000000,0x42000000,0x00080100,
+0x00080000,0x42000100,0x00000100,0x02000000, 0x40000000,0x02080000,0x42000100,0x40080100,
+0x02000100,0x40000000,0x42080000,0x02080100, 0x40080100,0x00000100,0x02000000,0x42080000,
+0x42080100,0x00080100,0x42000000,0x42080100, 0x02080000,0x00000000,0x40080000,0x42000000,
+0x00080100,0x02000100,0x40000100,0x00080000, 0x00000000,0x40080000,0x02080100,0x40000100},
+{
+0x20000010,0x20400000,0x00004000,0x20404010, 0x20400000,0x00000010,0x20404010,0x00400000,
+0x20004000,0x00404010,0x00400000,0x20000010, 0x00400010,0x20004000,0x20000000,0x00004010,
+0x00000000,0x00400010,0x20004010,0x00004000, 0x00404000,0x20004010,0x00000010,0x20400010,
+0x20400010,0x00000000,0x00404010,0x20404000, 0x00004010,0x00404000,0x20404000,0x20000000,
+0x20004000,0x00000010,0x20400010,0x00404000, 0x20404010,0x00400000,0x00004010,0x20000010,
+0x00400000,0x20004000,0x20000000,0x00004010, 0x20000010,0x20404010,0x00404000,0x20400000,
+0x00404010,0x20404000,0x00000000,0x20400010, 0x00000010,0x00004000,0x20400000,0x00404010,
+0x00004000,0x00400010,0x20004010,0x00000000, 0x20404000,0x20000000,0x00400010,0x20004010},
+{
+0x00200000,0x04200002,0x04000802,0x00000000, 0x00000800,0x04000802,0x00200802,0x04200800,
+0x04200802,0x00200000,0x00000000,0x04000002, 0x00000002,0x04000000,0x04200002,0x00000802,
+0x04000800,0x00200802,0x00200002,0x04000800, 0x04000002,0x04200000,0x04200800,0x00200002,
+0x04200000,0x00000800,0x00000802,0x04200802, 0x00200800,0x00000002,0x04000000,0x00200800,
+0x04000000,0x00200800,0x00200000,0x04000802, 0x04000802,0x04200002,0x04200002,0x00000002,
+0x00200002,0x04000000,0x04000800,0x00200000, 0x04200800,0x00000802,0x00200802,0x04200800,
+0x00000802,0x04000002,0x04200802,0x04200000, 0x00200800,0x00000000,0x00000002,0x04200802,
+0x00000000,0x00200802,0x04200000,0x00000800, 0x04000002,0x04000800,0x00000800,0x00200002},
+{
+0x10001040,0x00001000,0x00040000,0x10041040, 0x10000000,0x10001040,0x00000040,0x10000000,
+0x00040040,0x10040000,0x10041040,0x00041000, 0x10041000,0x00041040,0x00001000,0x00000040,
+0x10040000,0x10000040,0x10001000,0x00001040, 0x00041000,0x00040040,0x10040040,0x10041000,
+0x00001040,0x00000000,0x00000000,0x10040040, 0x10000040,0x10001000,0x00041040,0x00040000,
+0x00041040,0x00040000,0x10041000,0x00001000, 0x00000040,0x10040040,0x00001000,0x00041040,
+0x10001000,0x00000040,0x10000040,0x10040000, 0x10040040,0x10000000,0x00040000,0x10001040,
+0x00000000,0x10041040,0x00040040,0x10000040, 0x10040000,0x10001000,0x10001040,0x00000000,
+0x10041040,0x00041000,0x00041000,0x00001040, 0x00001040,0x00040040,0x10000000,0x10041000}
+};
+
+
+/* 32-bit permutation function P used on the output of the S-boxes */
+const TUint8 p32i[] = {
+	   16,  7, 20, 21,
+	   29, 12, 28, 17,
+		1, 15, 23, 26,
+		5, 18, 31, 10,
+		2,  8, 24, 14,
+	   32, 27,  3,  9,
+	   19, 13, 30,  6,
+	   22, 11,  4, 25
+};
+
+/* permuted choice table (key) */
+const TUint8 pc1[] = {
+	   57, 49, 41, 33, 25, 17,  9,
+		1, 58, 50, 42, 34, 26, 18,
+	   10,  2, 59, 51, 43, 35, 27,
+	   19, 11,  3, 60, 52, 44, 36,
+
+	   63, 55, 47, 39, 31, 23, 15,
+		7, 62, 54, 46, 38, 30, 22,
+	   14,  6, 61, 53, 45, 37, 29,
+	   21, 13,  5, 28, 20, 12,  4
+};
+
+/* number left rotations of pc1 */
+const TUint8 totrot[] = {1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28};
+
+/* permuted choice key (table) */
+const TUint8 pc2[] = {
+	   14, 17, 11, 24,  1,  5,
+		3, 28, 15,  6, 21, 10,
+	   23, 19, 12,  4, 26,  8,
+	   16,  7, 27, 20, 13,  2,
+	   41, 52, 31, 37, 47, 55,
+	   30, 40, 51, 45, 33, 48,
+	   44, 49, 39, 56, 34, 53,
+	   46, 42, 50, 36, 29, 32
+};
+}	//	namespace DES_TABLE
+#endif	//	__DESTABLES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dhimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,105 @@
+/*
+* Copyright (c) 2006-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 "dhimpl.h"
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+using namespace CryptoSpi;
+
+/* CDHImpl */
+CDHImpl::CDHImpl()
+	{
+	}
+
+CDHImpl::~CDHImpl()
+	{
+	}
+
+CDHImpl* CDHImpl::NewL(const CKey& aPrivateKey, const CCryptoParams* aParams)
+	{
+	CDHImpl* self = CDHImpl::NewLC(aPrivateKey, aParams);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDHImpl* CDHImpl::NewLC(const CKey& aPrivateKey, const CCryptoParams* aParams)
+	{
+	CDHImpl* self = new(ELeave) CDHImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aPrivateKey, aParams);
+	return self;
+	}
+
+CKey* CDHImpl::AgreeL(const CKey& aOtherPublicKey, const CCryptoParams* aParams)
+	{
+	/*
+	 * unpack the parameters, we're expecting the N and G parameters
+	 */
+	const TInteger& N = aParams->GetBigIntL(KDhKeyParameterNUid);
+	const TInteger& G = aParams->GetBigIntL(KDhKeyParameterGUid);
+	const TInteger& privateN = iSharedParams->GetBigIntL(KDhKeyParameterNUid);
+	const TInteger& privateG = iSharedParams->GetBigIntL(KDhKeyParameterGUid);
+	const TInteger& X = aOtherPublicKey.GetBigIntL(KDhKeyParameterXUid);
+	const TInteger& x = iPrivateKey->GetBigIntL(KDhKeyParameterxUid);
+
+	/*
+	 * both DH keys (ie our private and their public keys) must use the same N and G parameters
+	 */
+	if ((N != privateN) || (G != privateG))
+		{
+		User::Leave(KErrArgument);
+		}
+
+	/*
+	 * do the key agreement algo X ^ x mod N
+	 */
+	RInteger result = TInteger::ModularExponentiateL(X, x, N);
+	CleanupClosePushL(result);
+
+	/*
+	 * create the agreed key
+	 */
+	CCryptoParams* agreedKeyParameters = CCryptoParams::NewLC();
+	agreedKeyParameters->AddL(result, KSymmetricKeyParameterUid);
+	TKeyProperty agreedKeyProperties = {KDHAgreementUid, KCryptoPluginDhKeyAgreementUid,
+									KDHAgreedKeyUid, KNonEmbeddedKeyUid };
+	CKey* agreedKey = CKey::NewL(agreedKeyProperties, *agreedKeyParameters);
+
+	// cleanup result, agreedKeyParameters
+	CleanupStack::PopAndDestroy(2, &result);
+	return agreedKey;
+	}
+
+TUid CDHImpl::ImplementationUid() const
+	{
+	return KCryptoPluginDhKeyAgreementUid;
+	}
+
+CExtendedCharacteristics* CDHImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be
+	// reserved for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CDHImpl::GetExtendedCharacteristicsL()
+	{
+	return CDHImpl::CreateExtendedCharacteristicsL();
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dhimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,66 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __DHIMPL_H__
+#define __DHIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include "keyagreementimpl.h"
+#include "dhimpl.h"
+
+/**
+ * Implementation of DH Key Agreement as described in PKCS#3.
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CDHImpl) : public CKeyAgreementImpl
+		{
+	public:
+		
+		static CDHImpl* NewL(const CKey& aPrivateKey, const CCryptoParams* aParams);
+		static CDHImpl* NewLC(const CKey& aPrivateKey, const CCryptoParams* aParams);
+
+		// Destructor
+		~CDHImpl();
+
+		// from MKeyAgreement
+		CKey* AgreeL(const CKey& aOtherPublicKey, const CCryptoParams* aParams);
+
+		// Override CKeyAgreementImpl virtual functions
+		TUid ImplementationUid() const;
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+
+	private:
+		/**
+		Constructor
+		*/
+		CDHImpl();
+		};
+	}
+
+#endif // __DHIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dhkeypairgenimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,154 @@
+/*
+* Copyright (c) 2007-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 "dhkeypairgenimpl.h"
+#include "pluginconfig.h"
+#include "keypair.h"
+
+using namespace SoftwareCrypto;
+using namespace CryptoSpi;
+
+/* CDHKeyPairGenImpl */
+CDHKeyPairGenImpl::CDHKeyPairGenImpl()
+	{
+	
+	}
+
+CDHKeyPairGenImpl::~CDHKeyPairGenImpl()
+	{
+	
+	}
+
+CDHKeyPairGenImpl* CDHKeyPairGenImpl::NewL(void)
+	{
+	CDHKeyPairGenImpl* self = CDHKeyPairGenImpl::NewLC();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDHKeyPairGenImpl* CDHKeyPairGenImpl::NewLC(void)
+	{
+	CDHKeyPairGenImpl* self = new(ELeave) CDHKeyPairGenImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CDHKeyPairGenImpl::ConstructL(void)
+	{
+	CKeyPairGenImpl::ConstructL();
+	}
+
+CExtendedCharacteristics* CDHKeyPairGenImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CDHKeyPairGenImpl::GetExtendedCharacteristicsL()
+	{
+	return CDHKeyPairGenImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CDHKeyPairGenImpl::ImplementationUid() const
+	{
+	return KCryptoPluginDhKeyPairGenUid;
+	}
+
+void CDHKeyPairGenImpl::Reset()
+	{
+	// does nothing in this plugin
+	}
+
+void CDHKeyPairGenImpl::GenerateKeyPairL(TInt /*aKeySize*/, const CCryptoParams& aKeyParameters, CKeyPair*& aKeyPair)
+	{
+	/*
+	 * unpack the parameters, we're expecting the N and G parameters and if present the x parameter (aka private key)
+	 */
+	const TInteger& N = aKeyParameters.GetBigIntL(KDhKeyParameterNUid);
+	const TInteger& G = aKeyParameters.GetBigIntL(KDhKeyParameterGUid);
+
+	/*
+	 * do some sanity checking
+	 */
+	RInteger nminus2 = RInteger::NewL(N);
+	CleanupStack::PushL(nminus2);
+	--nminus2;
+	--nminus2;
+
+	if ((G < TInteger::Two()) || (G > nminus2))
+		{
+		User::Leave(KErrArgument);
+		}
+
+	/*
+	 * has a private key x been supplied? if not then generate it
+	 */
+	RInteger x;
+	if (aKeyParameters.IsPresent(KDhKeyParameterxUid))
+		{
+		x = RInteger::NewL(aKeyParameters.GetBigIntL(KDhKeyParameterxUid));
+		}
+		else
+		{
+		// find a random x | 1 <= x <= n-2
+		x = RInteger::NewRandomL(TInteger::One(), nminus2);
+		}
+	CleanupClosePushL(x);
+	/*
+	 * generate the public key with X = G^(x) mod N
+	 */
+	RInteger X = TInteger::ModularExponentiateL(G, x, N);
+	CleanupClosePushL(X);
+
+	/*
+	 * create the keys parameters
+	  */
+	CCryptoParams* publicKeyParameters = CCryptoParams::NewLC();
+	publicKeyParameters->AddL(X, KDhKeyParameterXUid);
+	TKeyProperty publicKeyProperties = {KDHKeyPairGeneratorUid, 	KCryptoPluginDhKeyPairGenUid, 
+									KDHPublicKeyUid, KNonEmbeddedKeyUid };
+	CCryptoParams* privateKeyParameters = CCryptoParams::NewLC();
+	privateKeyParameters->AddL(x, KDhKeyParameterxUid);
+	TKeyProperty privateKeyProperties = {KDHKeyPairGeneratorUid, KCryptoPluginDhKeyPairGenUid,
+									KDHPrivateKeyUid, KNonEmbeddedKeyUid };
+
+	/*
+	 * create the public key
+	 */
+	CKey* publicKey = CKey::NewL(publicKeyProperties, *publicKeyParameters);
+	CleanupStack::PushL(publicKey);
+
+	/*
+	 * create the private key
+	 */
+	CKey* privateKey = CKey::NewL(privateKeyProperties, *privateKeyParameters);
+	CleanupStack::PushL(privateKey);
+
+	/*
+	 * create the key pair
+	 */
+	aKeyPair = CKeyPair::NewL(publicKey, privateKey);
+	
+	/* 
+	 * cleanup stack - it should contain nminus2, x (if allocated here), X, publicKeyParameters, privateKeyParameters, publicKey and privateKey
+	 */
+	CleanupStack::Pop(2, publicKey);
+	CleanupStack::PopAndDestroy(5, &nminus2);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dhkeypairgenimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,72 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+#ifndef __DHKEYPAIRGENIMPL_H__
+#define __DHKEYPAIRGENIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keypairgenimpl.h"
+
+/**
+ * Implementation of DH Key Pair Generation as described in PKCS#3.
+ */
+namespace SoftwareCrypto
+	{
+using namespace CryptoSpi;
+
+	NONSHARABLE_CLASS(CDHKeyPairGenImpl) : public CKeyPairGenImpl
+		{
+	public:
+
+		static CDHKeyPairGenImpl* NewL(void);
+		static CDHKeyPairGenImpl* NewLC(void);
+
+		// Destructor
+		~CDHKeyPairGenImpl();
+
+		// from MPlugin
+		void Reset();
+
+		// from MKeyPairGenerator
+		void GenerateKeyPairL(TInt aKeySize, const CCryptoParams& aKeyParameters, CKeyPair*& aKeyPair);
+
+		// Override CKeyPairGenImpl virtual functions
+		TUid ImplementationUid() const;
+
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+
+	private:
+		/**
+		Constructor
+		*/
+		CDHKeyPairGenImpl();
+		void ConstructL(void);
+
+	private:
+		};
+	}
+
+#endif // __DHKEYPAIRGENIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dsakeypairgenimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,383 @@
+/*
+* Copyright (c) 2007-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: 
+* DSA Keypair implementation
+* DSA keypair generation implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "dsakeypairgenimpl.h"
+#include "pluginconfig.h"
+#include "keypair.h"
+#include "common/inlines.h"    // For TClassSwap
+#include "mont.h"
+#include "sha1impl.h"
+#include <random.h>
+
+
+const TUint KShaSize = 20;
+const TUint KMinPrimeLength = 512;
+const TUint KMaxPrimeLength = 1024;
+const TUint KPrimeLengthMultiple = 64;
+
+using namespace SoftwareCrypto;
+
+
+/* CDSAPrimeCertificate */
+
+CDSAPrimeCertificate* CDSAPrimeCertificate::NewL(const TDesC8& aSeed, TUint aCounter)
+	{
+	CDSAPrimeCertificate* self = NewLC(aSeed, aCounter);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CDSAPrimeCertificate* CDSAPrimeCertificate::NewLC(const TDesC8& aSeed, TUint aCounter)
+	{
+	CDSAPrimeCertificate* self = new(ELeave) CDSAPrimeCertificate(aCounter);
+	CleanupStack::PushL(self);
+	self->ConstructL(aSeed);
+	return self;
+	}
+
+const TDesC8& CDSAPrimeCertificate::Seed() const
+	{
+	return *iSeed;
+	}
+
+TUint CDSAPrimeCertificate::Counter() const
+	{
+	return iCounter;
+	}
+
+CDSAPrimeCertificate::~CDSAPrimeCertificate() 
+	{
+	delete const_cast<HBufC8*>(iSeed);
+	}
+
+void CDSAPrimeCertificate::ConstructL(const TDesC8& aSeed)
+	{
+	iSeed = aSeed.AllocL();
+	}
+
+CDSAPrimeCertificate::CDSAPrimeCertificate(TUint aCounter) 
+	: iCounter(aCounter)
+	{
+	}
+
+CDSAPrimeCertificate::CDSAPrimeCertificate() 
+	{
+	}
+
+
+/* CDSAKeyPairGenImpl */
+CDSAKeyPairGenImpl::CDSAKeyPairGenImpl()
+	{
+	}
+
+CDSAKeyPairGenImpl::~CDSAKeyPairGenImpl()
+	{
+	delete iPrimeCertificate;
+	}
+
+CDSAKeyPairGenImpl* CDSAKeyPairGenImpl::NewL()
+	{
+	CDSAKeyPairGenImpl* self = CDSAKeyPairGenImpl::NewLC();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDSAKeyPairGenImpl* CDSAKeyPairGenImpl::NewLC()
+	{
+	CDSAKeyPairGenImpl* self = new(ELeave) CDSAKeyPairGenImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CDSAKeyPairGenImpl::ConstructL(void)
+	{
+	CKeyPairGenImpl::ConstructL();
+	}
+
+CExtendedCharacteristics* CDSAKeyPairGenImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CDSAKeyPairGenImpl::GetExtendedCharacteristicsL()
+	{
+	return CDSAKeyPairGenImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CDSAKeyPairGenImpl::ImplementationUid() const
+	{
+	return KCryptoPluginDsaKeyPairGenUid;
+	}
+
+void CDSAKeyPairGenImpl::Reset()
+	{
+	// does nothing in this plugin
+	}
+
+TBool CDSAKeyPairGenImpl::ValidPrimeLength(TUint aPrimeBits)
+	{
+	return (aPrimeBits >= KMinPrimeLength &&
+			aPrimeBits <= KMaxPrimeLength &&
+			aPrimeBits % KPrimeLengthMultiple == 0);
+	}
+
+TBool CDSAKeyPairGenImpl::GeneratePrimesL(const TDesC8& aSeed,
+										 TUint& aCounter, 
+										 RInteger& aP, 
+										 TUint aL, 
+										 RInteger& aQ, 
+										 TBool aUseInputCounter)
+	{
+	//This follows the steps in FIPS 186-2 
+	//See DSS Appendix 2.2
+	//Note. Step 1 is performed prior to calling GeneratePrimesL, so that this
+	//routine can be used for both generation and validation.
+	//Step 1.  Choose an arbitrary sequence of at least 160 bits and call it
+	//SEED.  Let g be the length of SEED in bits.
+
+	if(!ValidPrimeLength(aL))
+		{
+		User::Leave(KErrNotSupported);
+		}
+	
+	CSHA1Impl* sha1 = CSHA1Impl::NewL();
+	CleanupStack::PushL(sha1);
+
+	HBufC8* seedBuf = aSeed.AllocLC();
+	TPtr8 seed = seedBuf->Des();
+	TUint gBytes = aSeed.Size();
+	
+	//Note that the DSS's g = BytesToBits(gBytes) ie. the number of random bits
+	//in the seed.  
+	//This function has made the assumption (for ease of computation) that g%8
+	//is 0.  Ie the seed is a whole number of random bytes.
+	TBuf8<KShaSize> U; 
+	TBuf8<KShaSize> temp; 
+	const TUint n = (aL-1)/160;
+	const TUint b = (aL-1)%160;
+	HBufC8* Wbuf = HBufC8::NewMaxLC((n+1) * KShaSize);
+	TUint8* W = const_cast<TUint8*>(Wbuf->Ptr());
+
+	U.Copy(sha1->Final(seed));
+	
+	//Step 2. U = SHA-1[SEED] XOR SHA-1[(SEED+1) mod 2^g]
+	for(TInt i=gBytes - 1, carry=ETrue; i>=0 && carry; i--)
+		{
+		//!++(TUint) adds one to the current word which if it overflows to zero
+		//sets carry to 1 thus letting the loop continue.  It's a poor man's
+		//multi-word addition.  Swift eh?
+		carry = !++(seed[i]);
+		}
+
+	temp.Copy(sha1->Final(seed));
+	XorBuf(const_cast<TUint8*>(U.Ptr()), temp.Ptr(), KShaSize);
+
+	//Step 3. Form q from U by setting the most significant bit (2^159)
+	//and the least significant bit to 1.
+	U[0] |= 0x80;
+	U[KShaSize-1] |= 1;
+
+	aQ = RInteger::NewL(U);
+	CleanupStack::PushL(aQ);
+
+	//Step 4. Use a robust primality testing algo to test if q is prime
+	//The robust part is the calling codes problem.  This will use whatever
+	//random number generator you set for the thread.  To attempt FIPS 186-2
+	//compliance, set a FIPS 186-2 compliant RNG.
+	if( !aQ.IsPrimeL() )
+		{
+		//Step 5. If not exit and get a new seed
+		CleanupStack::PopAndDestroy(4, sha1);
+		return EFalse;
+		}
+	
+	TUint counterEnd = aUseInputCounter ? aCounter+1 : 4096;
+	
+	//Step 6. Let counter = 0 and offset = 2
+	//Note 1. that the DSS speaks of SEED + offset + k because they always
+	//refer to a constant SEED.  We update our seed as we go so the offset
+	//variable has already been added to seed in the previous iterations.
+	//Note 2. We've already added 1 to our seed, so the first time through this
+	//the offset in DSS speak will be 2.
+	for(TUint counter=0; counter < counterEnd; counter++)
+		{
+		//Step 7. For k=0, ..., n let
+		// Vk = SHA-1[(SEED + offset + k) mod 2^g]
+		//I'm storing the Vk's inside of a big W buffer.
+		for(TUint k=0; k<=n; k++)
+			{
+			for(TInt i=gBytes-1, carry=ETrue; i>=0 && carry; i--)
+				{
+				carry = !++(seed[i]);
+				}
+			if(!aUseInputCounter || counter == aCounter)
+				{
+				TPtr8 Wptr(W+(n-k)*KShaSize, gBytes);
+				Wptr.Copy(sha1->Final(seed));
+				}
+			}
+		if(!aUseInputCounter || counter == aCounter)
+			{
+			//Step 8. Let W be the integer...  and let X = W + 2^(L-1)
+			const_cast<TUint8&>((*Wbuf)[KShaSize - 1 - b/8]) |= 0x80;
+			TPtr8 Wptr(W + KShaSize - 1 - b/8, aL/8, aL/8);
+			RInteger X = RInteger::NewL(Wptr);
+			CleanupStack::PushL(X);
+			//Step 9. Let c = X mod 2q and set p = X - (c-1)
+			RInteger twoQ = aQ.TimesL(TInteger::Two());
+			CleanupStack::PushL(twoQ);
+			RInteger c = X.ModuloL(twoQ);
+			CleanupStack::PushL(c);
+			--c;
+			aP = X.MinusL(c);
+			CleanupStack::PopAndDestroy(3, &X); //twoQ, c, X
+			CleanupStack::PushL(aP);
+			
+			//Step 10 and 11: if p >= 2^(L-1) and p is prime
+			if( aP.Bit(aL-1) && aP.IsPrimeL() )
+				{
+				aCounter = counter;
+				CleanupStack::Pop(2, &aQ);
+				CleanupStack::PopAndDestroy(3, sha1);
+				return ETrue;
+				}
+			CleanupStack::PopAndDestroy(&aP);
+			}
+		}
+	CleanupStack::PopAndDestroy(4, &sha1);
+	return EFalse;
+	}
+
+void CDSAKeyPairGenImpl::GenerateKeyPairL(TInt aKeySize, 
+										const CCryptoParams& aKeyParameters,
+										CKeyPair*& aKeyPair)
+	{
+	//This is the first step of DSA prime generation.  The remaining steps are
+	//performed in CDSAParameters::GeneratePrimesL
+	//Step 1.  Choose an arbitrary sequence of at least 160 bits and call it
+	//SEED.  Let g be the length of SEED in bits.	
+	TBuf8<KShaSize> seed(KShaSize);
+	TUint c;
+	RInteger p;
+	RInteger q;
+	
+	do 
+		{
+		GenerateRandomBytesL(seed);
+		}
+	while(!GeneratePrimesL(seed, c, p, aKeySize, q));
+	
+	//Double PushL will not fail as GeneratePrimesL uses the CleanupStack
+	//(at least one push and pop ;)
+	CleanupStack::PushL(p);
+	CleanupStack::PushL(q);
+
+	iPrimeCertificate = CDSAPrimeCertificate::NewL(seed, c);
+	
+	// aKeyParameters isn't const here anymore
+	CCryptoParams& paramRef=const_cast<CCryptoParams&>(aKeyParameters);
+	paramRef.AddL(c, KDsaKeyGenerationCounterUid);
+	paramRef.AddL(seed, KDsaKeyGenerationSeedUid);
+	
+	CMontgomeryStructure* montP = CMontgomeryStructure::NewLC(p);
+	
+	--p;
+
+	// e = (p-1)/q
+	RInteger e = p.DividedByL(q);
+	CleanupStack::PushL(e);
+
+	--p; //now it's p-2 :)
+
+	RInteger h;
+	const TInteger* g = 0;
+	do
+		{
+		// find a random h | 1 < h < p-1
+		h = RInteger::NewRandomL(TInteger::Two(), p);
+		CleanupStack::PushL(h);
+		// g = h^e mod p
+		g = &(montP->ExponentiateL(h, e));
+		CleanupStack::PopAndDestroy(&h); 
+		}
+	while( *g <= TInteger::One() );
+	CleanupStack::PopAndDestroy(&e);
+
+	++p; //reincrement p to original value
+	++p;
+
+
+	RInteger g1 = RInteger::NewL(*g); //take a copy of montP's g
+	CleanupStack::PushL(g1);
+	--q;
+	// select random x | 0 < x < q
+	RInteger x = RInteger::NewRandomL(TInteger::One(), q);
+	CleanupStack::PushL(x);
+	++q;
+
+	//
+	// create the keys parameters
+	CCryptoParams* privateKeyParameters = CCryptoParams::NewLC();
+	privateKeyParameters->AddL(p, KDsaKeyParameterPUid);
+	privateKeyParameters->AddL(q, KDsaKeyParameterQUid);
+	privateKeyParameters->AddL(g1, KDsaKeyParameterGUid);
+	privateKeyParameters->AddL(x, KDsaKeyParameterXUid);
+	TKeyProperty privateKeyProperties = {KDSAKeyPairGeneratorUid, 
+										 KCryptoPluginDsaKeyPairGenUid,
+									     KDsaPrivateKeyUid, 
+									     KNonEmbeddedKeyUid};
+
+	CCryptoParams* publicKeyParameters = CCryptoParams::NewLC();
+	publicKeyParameters->AddL(p, KDsaKeyParameterPUid);
+	publicKeyParameters->AddL(q, KDsaKeyParameterQUid);
+	publicKeyParameters->AddL(g1, KDsaKeyParameterGUid);
+	RInteger y = RInteger::NewL(montP->ExponentiateL(*g, x));
+	CleanupStack::PushL(y);
+	publicKeyParameters->AddL(y, KDsaKeyParameterYUid);
+	TKeyProperty publicKeyProperties = {KDSAKeyPairGeneratorUid,
+										KCryptoPluginDsaKeyPairGenUid, 
+										KDsaPublicKeyUid,
+										KNonEmbeddedKeyUid};
+
+	//
+	// create the private key
+	//
+	CKey* privateKey = CKey::NewL(privateKeyProperties, *privateKeyParameters);
+	CleanupStack::PushL(privateKey);
+
+	//
+	// create the public key
+	//
+	CKey* publicKey = CKey::NewL(publicKeyProperties, *publicKeyParameters);
+	CleanupStack::PushL(publicKey);
+
+	aKeyPair = CKeyPair::NewL(publicKey, privateKey);
+
+	//publicKey, publicKeyParameters, y, privateKey, privateKeyParameters, x, g1, montP, q, p
+	CleanupStack::Pop(2, privateKey);
+	CleanupStack::PopAndDestroy(8, &p);	
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dsakeypairgenimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,153 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+#ifndef __DSAKEYPAIRGENIMPL_H__
+#define __DSAKEYPAIRGENIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keypairgenimpl.h"
+//#include <asymmetrickeys.h>
+
+/**
+ * Implementation of DSA key pair generation.
+ */
+namespace SoftwareCrypto
+	{
+	NONSHARABLE_CLASS(CDSAPrimeCertificate) : public CBase
+		{
+	public:
+		/** 
+		Creates a new DSA prime certificate from a specified 
+		seed and counter value.
+ 
+		@param aSeed	The seed from a DSA key generation process
+		@param aCounter	The counter value from a DSA key generation process
+		@return			A pointer to a CDSAPrimeCertificate instance
+		*/
+		static CDSAPrimeCertificate* NewL(const TDesC8& aSeed, TUint aCounter);
+
+		/** 
+		Creates a new DSA prime certificate from a specified 
+		seed and counter value.
+		
+		The returned pointer is put onto the cleanup stack.
+		
+		@param aSeed		The seed from a DSA key generation process
+		@param aCounter	The counter value from a DSA key generation process
+		@return			A pointer to a CDSAPrimeCertificate instance
+		*/
+		static CDSAPrimeCertificate* NewLC(const TDesC8& aSeed, TUint aCounter);
+
+		/**
+		Gets the seed of the DSA prime certificate
+		@return	The seed
+		*/
+		const TDesC8& Seed() const;
+		
+		/**
+		Gets the counter value of the DSA prime certificate
+
+		@return	The counter's value
+		*/
+		TUint Counter() const;
+		
+		/** 
+		Destructor 
+		*/
+		~CDSAPrimeCertificate();
+		
+	protected:
+		/** 
+		Constructor
+		@param aCounter	The DSA key generation counter
+		*/
+		CDSAPrimeCertificate(TUint aCounter);
+
+		/**
+		Default constructor
+		*/
+		CDSAPrimeCertificate();
+
+		void ConstructL(const TDesC8& aSeed);
+		
+	protected:
+		/** 
+		The DSA key generation seed 
+		*/
+		const HBufC8* iSeed;
+		/** 
+		The DSA key generation counter 
+		*/
+		TUint iCounter;
+	private:
+		CDSAPrimeCertificate(const CDSAPrimeCertificate&);
+		CDSAPrimeCertificate& operator=(const CDSAPrimeCertificate&);
+		};
+		
+	NONSHARABLE_CLASS(CDSAKeyPairGenImpl) : public CKeyPairGenImpl
+		{
+	public:
+	
+		static CDSAKeyPairGenImpl* NewL();
+		static CDSAKeyPairGenImpl* NewLC();
+
+		// from MPlugin
+		void Reset();
+
+		// from MKeyPairGenerator
+		void GenerateKeyPairL(TInt aKeySize, const CCryptoParams& aKeyParameters, CKeyPair*& aKeyPair);
+		
+		// Override CKeyPairGenImpl virtual functions
+		TUid ImplementationUid() const;
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+		// Destructor
+		~CDSAKeyPairGenImpl();
+
+		static TBool GeneratePrimesL(const TDesC8& aSeed,
+									 TUint& aCounter, 
+									 RInteger& aP, 
+									 TUint aL, 
+									 RInteger& aQ, 
+									 TBool aUseInputCounter=EFalse);
+									 
+		static TBool ValidPrimeLength(TUint aPrimeBits);
+		
+	private:
+		/**
+		Constructor
+		*/
+		CDSAKeyPairGenImpl();
+			
+		/// second phase of construction
+		void ConstructL();
+		
+		CDSAPrimeCertificate* iPrimeCertificate;
+		};
+	}
+
+#endif // __DSAKEYPAIRGENIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dsasignerimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,137 @@
+/*
+* Copyright (c) 2006-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 "dsasignerimpl.h"
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+
+// Implementation of CDSASignerImpl 
+CDSASignerImpl* CDSASignerImpl::NewL(const CKey& aKey)
+	{
+	CDSASignerImpl* self = CDSASignerImpl::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CDSASignerImpl* CDSASignerImpl::NewLC(const CKey& aKey)
+	{
+	CDSASignerImpl* self = new(ELeave) CDSASignerImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CDSASignerImpl::CDSASignerImpl() 
+	{
+	}
+	
+CDSASignerImpl::~CDSASignerImpl()
+	{
+	}
+	
+void CDSASignerImpl::ConstructL(const CKey& aKey)
+	{
+	CSignerImpl::ConstructL(aKey);
+	}
+
+CExtendedCharacteristics* CDSASignerImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CDSASignerImpl::GetExtendedCharacteristicsL()
+	{
+	return CDSASignerImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CDSASignerImpl::ImplementationUid() const
+	{
+	return KCryptoPluginDsaSignerUid;
+	}
+	
+void CDSASignerImpl::SetKeyL(const CKey& aPrivateKey) 
+	{
+	DoSetKeyL(aPrivateKey);
+	Reset();
+	}
+
+TInt CDSASignerImpl::GetMaximumInputLengthL() const 
+	{
+	return KSha1HashLength;
+	}
+
+void CDSASignerImpl::SignL(const TDesC8& aInput, CCryptoParams& aSignature) 
+	{
+	
+	//see HAC 11.56 or DSS section 5
+	//I'll follow HAC as I like its description better
+	//We don't check that r and s are non both non-null like the DSS
+	//states you _optionally_ can.  The chances of this are _incredibly_ small.
+	//You've got a much better chance of a bit failure ocurring in the hardware
+	//than this.
+
+	const TInteger& tQ=iKey->GetBigIntL(KDsaKeyParameterQUid);
+		
+	// a) Select a random secret integer (k | 0 < k < q)
+	RInteger qminus1 = RInteger::NewL(tQ);
+	CleanupStack::PushL(qminus1);
+	--qminus1;
+	RInteger k = RInteger::NewRandomL(TInteger::One(), qminus1);
+	CleanupStack::PopAndDestroy(&qminus1);
+	CleanupStack::PushL(k);
+	
+	
+	// b) compute r = (g^k mod p) mod q
+	
+	const TInteger& tG=iKey->GetBigIntL(KDsaKeyParameterGUid);
+	const TInteger& tP=iKey->GetBigIntL(KDsaKeyParameterPUid);
+	RInteger r = TInteger::ModularExponentiateL(tG, k, tP);
+	CleanupStack::PushL(r);
+	r %=tQ;
+	
+	
+	// c) compute k^(-1) mod q
+
+	RInteger kinv = k.InverseModL(tQ);
+	CleanupStack::PushL(kinv);
+
+
+	// d) compute s = k^(-1) * {h(m) + xr} mod q
+	// Note that in order to be interoperable, compliant with the DSS, and
+	// secure, aInput must be the result of a SHA-1 hash
+
+	RInteger hm = RInteger::NewL(aInput);
+	CleanupStack::PushL(hm);
+	
+	const TInteger& tX=iKey->GetBigIntL(KDsaKeyParameterXUid);	
+	RInteger s = tX.TimesL(r);
+	CleanupStack::PushL(s);
+	s += hm;
+	s *= kinv;
+	s %= tQ;
+
+
+	// e) signature for m is the pair (r,s)
+	aSignature.AddL(r, KDsaSignatureParameterRUid);
+	aSignature.AddL(s, KDsaSignatureParameterSUid);
+	
+	CleanupStack::PopAndDestroy(5, &k);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dsasignerimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,91 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __DSASIGNERIMPL_H__
+#define __DSASIGNERIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+
+#include "signerimpl.h"
+#include "common/inlines.h"
+
+/**
+ * Implementation of DSA signing
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CDSASignerImpl) : public CSignerImpl
+		{
+	public:
+		/**
+		Creates an instance of a DSA signer plug-in.
+		@param aKey The private key used to sign.
+		@return A pointer to a CDSASignerImpl instance
+		*/
+		static CDSASignerImpl* NewL(const CKey& aKey);
+		
+		/**
+		Creates an instance of a DSA signer plug-in.
+		@param aKey The private key used to sign.
+		@return A pointer to a CDSASignerImpl instance
+		*/
+		static CDSASignerImpl* NewLC(const CKey& aKey);
+		
+		// Override CSignerImpl virtual functions
+		TUid ImplementationUid() const;
+		// End of CSignerImpl
+		
+		// Override MSignatureBase virtual functions
+		void SetKeyL(const CKey& aPrivateKey);
+		TInt GetMaximumInputLengthL() const;
+		// End of MSignatureBase
+		
+		// Override MSigner virtual functions
+		void SignL(const TDesC8& aInput, CCryptoParams& aSignature);
+		// End of MSigner
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+		/// Destructor
+		~CDSASignerImpl();
+		
+	protected:
+		/// Constructor
+		CDSASignerImpl();
+			
+	protected:
+		/// second phase of construction
+		virtual void ConstructL(const CKey& aKey);
+		
+	private:
+		static const TUint KSha1HashLength = 20;
+		};
+	}
+
+#endif // __DSASIGNERIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dsaverifyimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,160 @@
+/*
+* Copyright (c) 2006-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 "dsaverifyimpl.h"
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+
+// Implementation of CDSAVerifierImpl
+CDSAVerifierImpl* CDSAVerifierImpl::NewL(const CKey& aKey)
+	{
+	CDSAVerifierImpl* self = CDSAVerifierImpl::NewLC(aKey);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CDSAVerifierImpl* CDSAVerifierImpl::NewLC(const CKey& aKey)
+	{
+	CDSAVerifierImpl* self = new(ELeave) CDSAVerifierImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+	
+CDSAVerifierImpl::CDSAVerifierImpl() 
+	{
+	}
+
+CDSAVerifierImpl::~CDSAVerifierImpl()
+	{
+	}
+	
+void CDSAVerifierImpl::ConstructL(const CKey& aKey)
+	{
+	CVerifierImpl::ConstructL(aKey);
+	}
+	
+CExtendedCharacteristics* CDSAVerifierImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+	
+const CExtendedCharacteristics* CDSAVerifierImpl::GetExtendedCharacteristicsL()
+	{
+	return CDSAVerifierImpl::CreateExtendedCharacteristicsL();
+	}
+	
+TUid CDSAVerifierImpl::ImplementationUid() const
+	{
+	return KCryptoPluginDsaVerifierUid;
+	}
+	
+void CDSAVerifierImpl::SetKeyL(const CKey& aPublicKey)
+	{
+	DoSetKeyL(aPublicKey);
+	Reset();	
+	}
+
+TInt CDSAVerifierImpl::GetMaximumInputLengthL() const
+	{
+	return KSha1HashLength;
+	}
+
+void CDSAVerifierImpl::VerifyL(const TDesC8& aInput, const CCryptoParams& aSignature, TBool& aVerificationResult)
+	{
+	//Retrieve the parameter Q from the key	
+	const TInteger& tQ=iKey->GetBigIntL(KDsaKeyParameterQUid);
+
+	//see HAC 11.56 or DSS section 6
+	//I'll follow HAC as I like the description better
+
+	// a) Obtain A's authenticate public key
+
+	// b) Verify that 0 < r < q and 0 < s < q; if not reject signature
+
+	//Retrieve the R&S in DSA signature from the array
+
+	const TInteger& tR=aSignature.GetBigIntL(KDsaSignatureParameterRUid);
+	const TInteger& tS=aSignature.GetBigIntL(KDsaSignatureParameterSUid);
+
+	if (tR <= 0 || tR >= tQ)
+		{
+		aVerificationResult=EFalse;
+		return;
+		}
+	if (tS <= 0 || tS >= tQ)
+		{
+		aVerificationResult=EFalse;
+		return;
+		}
+		
+		
+	// c) Compute w = s^(-1) mod q and h(m)
+	RInteger w = tS.InverseModL(tQ);
+	CleanupStack::PushL(w);
+	// Note that in order to be interoperable, compliant with the DSS, and
+	// secure, aInput must be the result of a SHA-1 hash
+	RInteger hm = RInteger::NewL(aInput);
+	CleanupStack::PushL(hm);
+
+	// d) Compute u1 = w * hm mod q and u2 = r * w mod q
+	RInteger u1 = TInteger::ModularMultiplyL(w, hm, tQ);
+	CleanupStack::PushL(u1);
+
+	RInteger u2 = TInteger::ModularMultiplyL(tR, w, tQ);
+	CleanupStack::PushL(u2);
+
+	// e) Compute v = ((g^u1 * y^u2) mod p) mod q
+	
+	const TInteger& tG=iKey->GetBigIntL(KDsaKeyParameterGUid);
+	const TInteger& tY=iKey->GetBigIntL(KDsaKeyParameterYUid);
+	const TInteger& tP=iKey->GetBigIntL(KDsaKeyParameterPUid);
+
+	RInteger temp = TInteger::ModularExponentiateL(tG, u1, tP);
+	CleanupStack::PushL(temp);
+	RInteger temp1 = TInteger::ModularExponentiateL(tY, u2, tP);
+	CleanupStack::PushL(temp1);
+	RInteger v = TInteger::ModularMultiplyL(temp, temp1, tP);
+	CleanupStack::PushL(v);
+	v %= tQ;
+
+	// f) Accept the signature if v == r
+	if(v == tR)
+		{
+		aVerificationResult = ETrue;
+		}
+
+	CleanupStack::PopAndDestroy(7, &w);
+	}
+
+
+// Methods which are not supported can be excluded from the coverage.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+void CDSAVerifierImpl::InverseSignL(HBufC8*& /*aOutput*/, const CCryptoParams& /*aSignature*/)
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/dsaverifyimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,92 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __DSAVERIFYIMPL_H__
+#define __DSAVERIFYIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+
+#include "verifierimpl.h"
+#include "common/inlines.h"
+
+/**
+ * Implementation of DSA verification
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CDSAVerifierImpl) : public CVerifierImpl
+		{
+	public:
+		/**
+		Creates an instance of a DSA verifier plug-in.
+		@param aKey The key
+		@return A pointer to a CDSAVerifierImpl instance
+		*/
+		static CDSAVerifierImpl* NewL(const CKey& aKey);
+
+		/**
+		Creates an instance of a DSA verifier plug-in.
+		@param aKey The key
+		@return A pointer to a CDSAVerifierImpl instance
+		*/
+		static CDSAVerifierImpl* NewLC(const CKey& aKey);
+		
+		// Override CVerifierImpl virtual functions
+		TUid ImplementationUid() const;
+		// End of CVerifierImpl
+		
+		// Override MSignatureBase virtual functions
+		void SetKeyL(const CKey& aPublicKey);
+		virtual TInt GetMaximumInputLengthL() const;
+
+		// End of MSignatureBase
+		
+		// Override MSigner virtual functions
+		void VerifyL(const TDesC8& aInput, const CCryptoParams& aSignature, TBool& aVerificationResult);
+		void InverseSignL(HBufC8*& aOutput, const CCryptoParams& aSignature);
+		// End of MSigner
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+		/// Destructor
+		~CDSAVerifierImpl();
+		
+	protected:
+		/// Constructor
+		CDSAVerifierImpl();
+		
+		/// second phase of construction
+		virtual void ConstructL(const CKey& aKey);
+			
+	private:
+		static const TUint KSha1HashLength = 20;	
+		};
+	}
+
+#endif // __DSAVERIFYIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/hmacimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,276 @@
+/*
+* Copyright (c) 2006-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: 
+* software hmac implementation
+* software hmac implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "hmacimpl.h"
+#include "pluginconfig.h"
+#include "md2impl.h"
+#include "md5impl.h"
+#include "sha1impl.h"
+#include "keys.h"
+#include "md4impl.h"
+
+
+using namespace SoftwareCrypto;
+
+CHMacImpl* CHMacImpl::NewL(const CKey& aKey, MSoftwareHash* aHash)
+	{
+	CHMacImpl* self=NewLC(aKey, aHash);
+	CleanupStack::Pop();
+	return self;
+	}
+	
+CHMacImpl* CHMacImpl::NewLC(const CKey& aKey, MSoftwareHash* aHash)
+	{
+	CHMacImpl* self=new(ELeave) CHMacImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aHash);
+	return self;
+	}
+
+CHMacImpl* CHMacImpl::NewL(MSoftwareHash* aHash)
+	{
+	CHMacImpl* self=NewLC(aHash);
+	CleanupStack::Pop();
+	return self;
+	}
+	
+CHMacImpl* CHMacImpl::NewLC(MSoftwareHash* aHash)
+	{
+	CHMacImpl* self=new(ELeave) CHMacImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aHash);
+	return self;
+	}
+
+
+CHMacImpl::CHMacImpl()
+	{
+	}
+
+CHMacImpl::CHMacImpl(const CHMacImpl& aMD)
+	: 	iDigest(NULL), iInnerPad(aMD.iInnerPad), 
+		iOuterPad(aMD.iOuterPad), iBlockSize(aMD.iBlockSize)
+	{
+	}
+
+CHMacImpl::~CHMacImpl()
+	{
+	if (iDigest)
+		{
+		iDigest->Close();	
+		}
+	}
+
+void CHMacImpl::ConstructL(const CKey& aKey, MSoftwareHash* aHash)
+	{
+	//Clone the hash implementation
+	iDigest=static_cast<MSoftwareHash*>(aHash->ReplicateL());
+	InitBlockSizeL();
+	const TDesC8& keyContent=aKey.GetTDesC8L(KHmacKeyParameterUid);
+	Initialise(keyContent);	
+	}
+
+void CHMacImpl::ConstructL(MSoftwareHash* aHash)
+	{
+	//Clone the hash implementation
+	iDigest=static_cast<MSoftwareHash*>(aHash->ReplicateL());
+	InitBlockSizeL();
+	}
+
+void CHMacImpl::InitBlockSizeL()
+	{
+	 const TCharacteristics* ptr(NULL);
+	 iDigest->GetCharacteristicsL(ptr);
+	 const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);
+	 iBlockSize = hashPtr->iBlockSize/8;
+	 
+	 iInnerPad.SetLength(iBlockSize);
+	 iOuterPad.SetLength(iBlockSize);
+	 iInnerPadCopy.SetLength(iBlockSize);
+	 iOuterPadCopy.SetLength(iBlockSize);
+	}
+
+void CHMacImpl::Initialise(const TDesC8& aKey)
+	{
+	// initialisation
+	if (iDigest)
+		{
+		iDigest->Reset();
+		if( (TUint32)aKey.Size() > iBlockSize)
+			{
+			iInnerPad = iDigest->Final(aKey);
+			}
+		else 
+			{
+			iInnerPad = aKey;
+			}
+			
+		TUint i;
+		for (i=iInnerPad.Size();i<iBlockSize;i++)
+			iInnerPad.Append(0);
+
+		iOuterPad=iInnerPad;
+
+		const TUint8 Magic1=0x36, Magic2=0x5c;
+		for (i=0;i<iBlockSize;i++)
+			{
+			iInnerPad[i]^=Magic1;
+			iOuterPad[i]^=Magic2;
+			}
+		//start inner hash
+		iDigest->Hash(iInnerPad);
+		}
+	}
+	
+MHash* CHMacImpl::CopyL()
+	{
+	CHMacImpl* that=new(ELeave) CHMacImpl(*this);
+	CleanupStack::PushL(that);
+	that->iDigest=iDigest ? static_cast<MSoftwareHash*>(iDigest->CopyL()) : NULL;
+	CleanupStack::Pop();
+	return that;
+	}
+	
+MHash* CHMacImpl::ReplicateL()
+	{
+	CHMacImpl* that=new(ELeave) CHMacImpl(*this);
+	CleanupStack::PushL(that);
+	that->iDigest=iDigest ? static_cast<MSoftwareHash*>(iDigest->ReplicateL()) : NULL;
+	that->Reset();
+	CleanupStack::Pop();
+	return that;
+	}
+	
+void CHMacImpl::Reset()
+	{
+	if (iDigest)
+		{
+		iDigest->Reset();
+		iDigest->Update(iInnerPad);
+		}
+	}
+
+TPtrC8 CHMacImpl::Hash(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	TPtrC8 finalPtr(KNullDesC8());
+	StoreState();
+	if (iDigest)
+		{
+		ptr.Set(iDigest->Final(aMessage));
+		iDigest->Update(iOuterPad);
+		finalPtr.Set(iDigest->Final(ptr));
+		}
+
+	RestoreState();
+
+	if(iDigest)
+		{
+		iDigest->Update(aMessage);
+		}
+	
+	
+		
+	return (finalPtr);
+	}
+
+void CHMacImpl::Update(const TDesC8& aMessage)
+	{
+	if(iDigest)
+		{
+		iDigest->Update(aMessage);
+		}
+	}
+
+TPtrC8 CHMacImpl::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if(iDigest)
+		{
+		ptr.Set(iDigest->Final(aMessage));
+		iDigest->Update(iOuterPad);
+		iDigest->Final(ptr);
+		Reset();
+		}
+	return (ptr);
+	}
+	
+void CHMacImpl::RestoreState()
+	{
+	iOuterPad.Copy(iOuterPadCopy);
+	iInnerPad.Copy(iInnerPadCopy);
+	if (iDigest)
+		{
+		iDigest->RestoreState();
+		}
+	}
+
+void CHMacImpl::StoreState()
+	{
+	iOuterPadCopy.Copy(iOuterPad);
+	iInnerPadCopy.Copy(iInnerPad);
+	if (iDigest)
+		{
+		iDigest->StoreState();	
+		}
+	}
+
+void CHMacImpl::SetKeyL(const CKey& aKey)
+	{
+	const TDesC8& keyContent=aKey.GetTDesC8L(KHmacKeyParameterUid);
+	Initialise(keyContent);	
+	}
+
+void CHMacImpl::Close()
+	{
+	delete this;	
+	}
+	
+void CHMacImpl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	iDigest->GetCharacteristicsL(aPluginCharacteristics);	
+	}
+	
+const CExtendedCharacteristics* CHMacImpl::GetExtendedCharacteristicsL()
+	{
+	return iDigest->GetExtendedCharacteristicsL();
+	}
+
+// Methods which are not supported can be excluded from the coverage.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CHMacImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+	
+void CHMacImpl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/hmacimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,93 @@
+/*
+* Copyright (c) 2006-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: 
+* hmac implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREHMACIMPL_H__
+#define __CRYPTOAPI_SOFTWAREHMACIMPL_H__
+
+#include "softwarehashbase.h"
+#include "keys.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	/**
+	 * This is the maximum block size currently supported by HMAC implementation.
+	 */  
+	const TInt KMaxBlockSize = 128;		
+	
+	NONSHARABLE_CLASS(CHMacImpl) : public CBase, public MSoftwareHash
+		{		
+	public:
+		//NewL & NewLC
+		static CHMacImpl* NewL(MSoftwareHash* aHash);
+		static CHMacImpl* NewLC(MSoftwareHash* aHash);
+		static CHMacImpl* NewL(const CKey& aKey, MSoftwareHash* aHash);
+		static CHMacImpl* NewLC(const CKey& aKey, MSoftwareHash* aHash);
+
+		//From MPlugin
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		
+		//From MHmac
+	    TPtrC8 Hash(const TDesC8& aMessage);
+	    void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		void SetKeyL(const CKey& aKey);
+		void SetOperationModeL(TUid aOperationMode);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+				
+	private:
+		//Constructors
+		CHMacImpl();
+		CHMacImpl(const CHMacImpl& aHMacImpl);
+		
+		//Destructor
+		~CHMacImpl();
+		void RestoreState();
+		void StoreState();
+		void ConstructL(const CKey& aKey, MSoftwareHash* aHash);
+		void ConstructL(MSoftwareHash* aHash);
+		void Initialise(const TDesC8& aKey);
+		void InitBlockSizeL();
+		
+	private:
+		TUid iImplementationUid;
+		MSoftwareHash* iDigest;
+		
+		TBuf8<KMaxBlockSize> iInnerPad;
+		TBuf8<KMaxBlockSize> iOuterPad;
+		TBuf8<KMaxBlockSize> iInnerPadCopy;
+		TBuf8<KMaxBlockSize> iOuterPadCopy;
+		
+		TInt iBlockSize;
+		};
+	}
+
+#endif // __CRYPTOAPI_SOFTWAREHMACIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/keyagreementimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,75 @@
+/*
+* Copyright (c) 2006-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 "keyagreementimpl.h"
+#include <cryptospi/plugincharacteristics.h>
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+
+CKeyAgreementImpl::CKeyAgreementImpl()
+	{
+	}
+
+void CKeyAgreementImpl::ConstructL(const CKey& aPrivateKey, const CCryptoParams* aParams)
+	{
+	SetKeyL(aPrivateKey, aParams);
+	}
+	
+CKeyAgreementImpl::~CKeyAgreementImpl()
+	{
+	delete iSharedParams;
+	delete iPrivateKey;
+	}
+
+void CKeyAgreementImpl::Close()
+	{
+	delete this;
+	}
+	
+void CKeyAgreementImpl::Reset()
+	{
+	}
+	
+TAny* CKeyAgreementImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return 0;
+	}
+
+void CKeyAgreementImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)
+	{
+	TInt numCiphers = sizeof(KKeyAgreementCharacteristics)/sizeof(TKeyAgreementCharacteristics*);
+	TInt32 implUid = ImplementationUid().iUid;
+	for (TInt i = 0; i < numCiphers; ++i)
+		{
+		if (KKeyAgreementCharacteristics[i]->cmn.iImplementationUID == implUid)
+			{
+			aPluginCharacteristics = KKeyAgreementCharacteristics[i];
+			break;
+			}
+		}
+	}
+
+void CKeyAgreementImpl::SetKeyL(const CKey& aSelfPrivateKey, const CCryptoParams* aSharedParams)
+	{
+	delete iPrivateKey;
+	iPrivateKey = CKey::NewL(aSelfPrivateKey);
+	delete iSharedParams;
+	iSharedParams = CCryptoParams::NewL();
+	iSharedParams->CopyL(*aSharedParams);			// copy contents of the object
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/keyagreementimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,87 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __KEYAGREEMENTIMPL_H__
+#define __KEYAGREEMENTIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <cryptospi/cryptospidef.h>
+#include "keys.h"
+#include "keyagreementplugin.h"
+
+/**
+ * Abstract base class for key agreement plug-ins.
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CKeyAgreementImpl) : public CBase, public MKeyAgreement
+		{
+	public:
+		
+		// Override MPlugin virtual functions
+		void Close();
+		void Reset(); // Always call reset in super-class if you override this
+		TAny* GetExtension(TUid aExtensionId);
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		// End of MPlugin
+
+		// Override MKeyAgreement virtual functions
+		void SetKeyL(const CKey& aSelfPrivateKey, const CCryptoParams* aParams);
+		// End of MKeyAgreement
+
+		/// Destructor
+		~CKeyAgreementImpl();
+		
+	protected:
+		/**
+		Constructor
+		*/
+		CKeyAgreementImpl();
+			
+		/**
+		Second phase of construction. Always call ConstructL in the super-class
+		if your override this method.
+		@param aPrivateKey The private key of one of the parties
+		@param aParams	The parameters shared between both parties
+		*/
+		virtual void ConstructL(const CKey& aPrivateKey, const CCryptoParams* aParams);
+
+		/**
+		Helper function implemented by concrete cipher sub-class that allows
+		GetCharacteristicsL to return the correct characteristics object.
+		@return The implemention uid
+		*/
+		virtual TUid ImplementationUid() const = 0;
+
+	private:
+
+	protected:
+		CKey* iPrivateKey;
+		CCryptoParams* iSharedParams;	// common parameters between our private key and their public key
+		};
+	}
+
+#endif	//	__KEYAGREEMENTIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/keypairgenimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,67 @@
+/*
+* Copyright (c) 2006-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 <e32def.h>
+#include <e32cmn.h>
+#include "keys.h"
+
+#include "keypairgenimpl.h"
+
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "pluginconfig.h"
+
+#include "common/inlines.h"
+
+using namespace SoftwareCrypto;
+
+CKeyPairGenImpl::CKeyPairGenImpl()
+	{
+	}
+
+void CKeyPairGenImpl::ConstructL()
+	{
+	}
+	
+CKeyPairGenImpl::~CKeyPairGenImpl()
+	{
+	}
+		
+void CKeyPairGenImpl::Close()
+	{
+	delete this;
+	}
+
+TAny* CKeyPairGenImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return 0;
+	}
+	
+void CKeyPairGenImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)
+	{
+	TInt numCiphers = sizeof(KKeyPairGeneratorCharacteristics)/sizeof(TAsymmetricKeypairGeneratorCharacteristics*);
+	TInt32 implUid = ImplementationUid().iUid;
+	for (TInt i = 0; i < numCiphers; ++i)
+		{
+		if (KKeyPairGeneratorCharacteristics[i]->cmn.iImplementationUID == implUid)
+			{
+			aPluginCharacteristics = KKeyPairGeneratorCharacteristics[i];
+			break;
+			}
+		}
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/keypairgenimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,72 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+#ifndef __KEYPAIRGENIMPL_H__
+#define __KEYPAIRGENIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include "cryptokeypairgeneratorapi.h"
+#include "keypairgeneratorplugin.h"
+
+/**
+ * Key pair generator plugin base class
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CKeyPairGenImpl) : public CBase, public MKeyPairGenerator
+		{
+	public:
+
+		// Override MPlugin virtual functions
+		void Close();
+		TAny* GetExtension(TUid aExtensionId);
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		// End of MPlugin
+
+		// Destructor
+		~CKeyPairGenImpl();
+
+	protected:
+		/**
+		Constructor
+		*/
+		CKeyPairGenImpl();
+			
+		/**
+		Second phase of construction. Always call ConstructL in the super-class
+		if you override this method.
+		*/
+		virtual void ConstructL();
+		
+		/**
+		Helper function implemented by concrete cipher sub-class that allows
+		GetCharacteristicsL to return the correct characteristics object.
+		@return The implemention uid
+		*/
+		virtual TUid ImplementationUid() const = 0;
+		};
+	}
+
+#endif // __KEYPAIRGENIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/macimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,302 @@
+/*
+* 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 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: 
+* Software Mac Implementation
+* Software Mac Implementation
+* MAC plugin header
+*
+*/
+
+
+/**
+ @file
+*/
+#include "macimpl.h"
+#include "pluginconfig.h"
+
+/**
+ * HMAC plugin headers
+ */ 
+#include "md2impl.h"
+#include "md4impl.h"
+#include "md5impl.h"
+#include "sha1impl.h"
+#include "sha2impl.h"
+#include "hmacimpl.h"
+
+
+using namespace SoftwareCrypto;
+using namespace CryptoSpi;
+
+
+CMacImpl* CMacImpl::NewL(const CKey& aKey, const TUid aImplementationId, const CCryptoParams* aAlgorithmParams)
+	{
+	CMacImpl* self = new (ELeave) CMacImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aImplementationId, aAlgorithmParams);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CMacImpl::CMacImpl() 
+	{
+	}
+
+void CMacImpl::ConstructL(const CKey& aKey, const TUid aImplementationId, const CCryptoParams* /*aAlgorithmParams*/) 
+	{
+	iImplementationUid = aImplementationId; 
+	iKey = CryptoSpi::CKey::NewL(aKey);
+		
+	MSoftwareHash* hashImpl = NULL;
+	
+	switch (aImplementationId.iUid)
+		{
+		case KCryptoPluginMacHashMd2:
+			{
+			hashImpl = CMD2Impl::NewL();
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashMd5:
+			{
+			hashImpl = CMD5Impl::NewL();
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashMd4:
+			{
+			hashImpl = CMD4Impl::NewL();
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashSha1:
+			{
+			hashImpl = CSHA1Impl::NewL();
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashSha224:
+			{
+			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha224);
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashSha256:
+			{
+			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha256);
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashSha384:
+			{
+			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha384);
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacHashSha512:
+			{
+			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha512);
+			CleanupClosePushL(*hashImpl);
+			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);
+			iBase = EHashBased;
+			}
+			break;
+		case KCryptoPluginMacAesXcbcMac96:
+			{
+			CSymmetricCipher* symmetricCipher = NULL;
+			CryptoSpi::CSymmetricCipherFactory::CreateSymmetricCipherL(symmetricCipher,
+														CryptoSpi::KAesUid, *iKey,
+														CryptoSpi::KCryptoModeEncryptUid,
+														CryptoSpi::KOperationModeCBCUid,
+														CryptoSpi::KPaddingModeNoneUid,
+														NULL);
+			
+			iCmacImpl= CCMacImpl::NewL(*iKey, symmetricCipher, CryptoSpi::KAlgorithmCipherAesXcbcMac96);
+			iBase = ECipherBased;
+			}
+			break;
+		case KCryptoPluginMacAesXcbcPrf128:
+			{
+			TBuf8<16> tempKey;
+			tempKey.SetLength(16);
+			
+			CryptoSpi::CCryptoParams* keyParams = CryptoSpi::CCryptoParams::NewLC();
+			keyParams->AddL(tempKey, CryptoSpi::KSymmetricKeyParameterUid);
+			CryptoSpi::CKey* key = CryptoSpi::CKey::NewLC(aKey.KeyProperty(),*keyParams);
+				
+			CSymmetricCipher* symmetricCipher = NULL;
+			CryptoSpi::CSymmetricCipherFactory::CreateSymmetricCipherL(symmetricCipher,
+														CryptoSpi::KAesUid, *key,
+														CryptoSpi::KCryptoModeEncryptUid,
+														CryptoSpi::KOperationModeCBCUid,
+														CryptoSpi::KPaddingModeNoneUid,
+														NULL);
+			CleanupStack::PopAndDestroy(2, keyParams); //key and keyParams
+			
+			iCmacImpl= CCMacImpl::NewL(*iKey, symmetricCipher, CryptoSpi::KAlgorithmCipherAesXcbcPrf128);
+			iBase = ECipherBased;
+			}
+			break;
+
+		default:
+			User::Leave(KErrNotSupported);
+		}
+
+	if(iBase == EHashBased)
+		{
+		CleanupStack::PopAndDestroy(hashImpl);
+		}
+	}
+
+CMacImpl::~CMacImpl()
+	{
+	delete iKey;
+	if(iHmacImpl)
+		{
+		iHmacImpl->Close();
+		}
+	delete iCmacImpl;
+	}
+	
+void CMacImpl::Reset()
+	{
+	if (iBase == EHashBased)
+		{
+		iHmacImpl->Reset();
+		}
+	else if (iBase == ECipherBased)
+		{
+		iCmacImpl->Reset();
+		}
+	}
+	
+void CMacImpl::Close()
+	{
+	delete this;	
+	}
+	
+void CMacImpl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt macNum=sizeof(KMacCharacteristics)/sizeof(TMacCharacteristics*);
+	for (TInt i=0;i<macNum;++i)
+		{
+		if (KMacCharacteristics[i]->iMacChar.iImplementationUID==ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KMacCharacteristics[i];
+			break;
+			}
+		}	
+	}
+
+const CExtendedCharacteristics* CMacImpl::GetExtendedCharacteristicsL()
+	{
+	return (iBase == EHashBased) ? iHmacImpl->GetExtendedCharacteristicsL(): iCmacImpl->GetExtendedCharacteristicsL();
+	}
+
+TAny* CMacImpl::GetExtension(TUid aExtensionId)
+	{
+	return (iBase == EHashBased) ? iHmacImpl->GetExtension(aExtensionId): NULL;
+	}
+
+TUid CMacImpl::ImplementationUid() const
+	{
+	return iImplementationUid;
+	}
+
+TPtrC8 CMacImpl::MacL(const TDesC8& aMessage)
+	{
+	return (iBase == EHashBased) ? iHmacImpl->Hash(aMessage):iCmacImpl->MacL(aMessage);
+	}		
+	
+void CMacImpl::UpdateL(const TDesC8& aMessage)
+	{
+	(iBase == EHashBased) ? iHmacImpl->Update(aMessage):iCmacImpl->UpdateL(aMessage);
+	}
+
+TPtrC8 CMacImpl::FinalL(const TDesC8& aMessage)
+	{
+	return (iBase == EHashBased) ? iHmacImpl->Final(aMessage):iCmacImpl->FinalL(aMessage);
+	}
+
+void CMacImpl::ReInitialiseAndSetKeyL(const CKey& aKey)
+	{
+	delete iKey;
+	iKey = NULL;
+	iKey = CryptoSpi::CKey::NewL(aKey);
+	
+	if (iBase == EHashBased)
+		{
+		iHmacImpl->SetKeyL(aKey);
+		iHmacImpl->Reset();
+		}
+	else if (iBase == ECipherBased)
+		{
+		iCmacImpl->ReInitialiseAndSetKeyL(aKey);
+		}
+	}
+
+MMac* CMacImpl::ReplicateL()
+	{
+	CMacImpl* that= new(ELeave) CMacImpl();
+	CleanupStack::PushL(that);
+	that->iImplementationUid = iImplementationUid;
+	that->iBase = iBase;
+	that->iKey=CKey::NewL(*iKey);
+	
+	if(iBase == EHashBased)
+		{
+		that->iHmacImpl=static_cast<CHMacImpl*>(iHmacImpl->ReplicateL());
+		}
+	else if (iBase == ECipherBased)
+		{
+		that->iCmacImpl= iCmacImpl->ReplicateL();
+		}
+	CleanupStack::Pop(that);
+	return that;
+	}
+	
+MMac* CMacImpl::CopyL()
+	{
+	CMacImpl* that= new(ELeave) CMacImpl();
+	CleanupStack::PushL(that);
+	that->iImplementationUid = iImplementationUid;
+	that->iBase = iBase;
+	that->iKey=CKey::NewL(*iKey);
+
+	if(iBase == EHashBased)
+		{
+		that->iHmacImpl=static_cast<CHMacImpl*>(iHmacImpl->CopyL());
+		}
+	else if (iBase == ECipherBased)
+		{
+		that->iCmacImpl= iCmacImpl->CopyL();
+		}
+	CleanupStack::Pop(that);
+	return that;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/macimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,115 @@
+/*
+* 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 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: 
+* mac plugin implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREMACIMPL_H__
+#define __CRYPTOAPI_SOFTWAREMACIMPL_H__
+
+#include <cryptospi/macplugin.h>
+#include "cryptosymmetriccipherapi.h"
+#include "softwarehashbase.h"
+#include "keys.h"
+#include "cmacimpl.h"
+#include "hmacimpl.h"
+
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+    	
+	NONSHARABLE_CLASS(CMacImpl) : public CBase, public MMac  
+		{		
+	public:
+		/**
+		 * MAC implementation instance creation methods
+		 */
+		static CMacImpl* NewL(const CKey& aKey,
+				              const TUid aImplementationId,
+				              const CCryptoParams* aAlgorithmParams);
+
+		/**
+		 * Methods from MPlugin: Base class for all the plugins
+		 */
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);	
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		void Reset();
+		// this deletes the instance of this class. The method is called at the user side
+		// indirectly through the MPlugin pointer instance.
+		void Close();		
+		
+		/**
+		 *  From MMac: MAC interface (Software based)
+		 */
+	    TPtrC8 MacL(const TDesC8& aMessage);
+        void UpdateL(const TDesC8& aMessage);
+        TPtrC8 FinalL(const TDesC8& aMessage);
+		void ReInitialiseAndSetKeyL(const CKey& aKey);    
+		MMac* ReplicateL();
+		MMac* CopyL();
+	
+	private:
+	
+		/**
+		 *  Enumerators to recognize the type of algorithm used for MAC
+		 */
+		enum TMacBase {EHashBased, ECipherBased};
+
+
+		/**
+		 * Constructors and Destructors
+		 */
+		~CMacImpl();
+    	CMacImpl();
+		CMacImpl(const CMacImpl& aMacImpl);
+		
+		/**
+		 * Initialize the 'iHmacImpl' and 'iCipherImpl' instances.
+		 */
+		void ConstructL(const CKey& aKey, const TUid aImplementationId,const CCryptoParams* aAlgorithmParams);
+		
+		/**
+		 * This will return the Uid of the specific implementation
+		 * used for the algorithm.
+		 */
+		TUid ImplementationUid() const;
+	
+	private:			
+		TUid iImplementationUid;
+		TMacBase iBase;
+		CKey* iKey;
+		
+		/**
+		 * The hash based MAC implementation. This is software based implementation.
+		 */
+		CHMacImpl* iHmacImpl;
+	
+		/**
+		 * The symmetric cipher based MAC implementation.
+		 */
+		CCMacImpl* iCmacImpl;
+		};
+	}
+
+#endif // __CRYPTOAPI_SOFTWAREMACIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/md2impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,315 @@
+/*
+* Copyright (c) 2006-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: 
+* software md2 implementation
+* software md2 implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "md2impl.h"
+
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+	
+CMD2Impl* CMD2Impl::NewL()
+	{
+	CMD2Impl* self=new (ELeave) CMD2Impl();
+	return self;						
+	}
+														
+CMD2Impl* CMD2Impl::NewLC()
+	{
+	CMD2Impl* self=NewL();
+	CleanupStack::PushL(self);
+	return self;						
+	}
+														
+CMD2Impl::CMD2Impl() : iHash(KMD2HashSize)
+	{		
+	}
+	
+CMD2Impl::CMD2Impl(const CMD2Impl& aCMD2Impl)
+: iHash(aCMD2Impl.iHash),iNum(aCMD2Impl.iNum)
+	{
+	(void)Mem::Copy(iData, aCMD2Impl.iData, sizeof(iData));
+	(void)Mem::Copy(iChecksum, aCMD2Impl.iChecksum, sizeof(iChecksum));
+	(void)Mem::Copy(iState, aCMD2Impl.iState, sizeof(iState));		
+	}
+		
+CMD2Impl::~CMD2Impl()
+	{	
+	}
+	
+void CMD2Impl::Reset()
+	{
+	Mem::FillZ(iData,sizeof(iData));
+	Mem::FillZ(iChecksum,sizeof(iChecksum));
+	Mem::FillZ(iState,sizeof(iState));
+	iNum=0;		
+	}
+	
+void CMD2Impl::Close()
+	{
+	delete this;	
+	}
+	
+void CMD2Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+	for (TInt i=0;i<hashNum;i++)
+		{
+		if (KHashCharacteristics[i]->cmn.iImplementationUID==ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KHashCharacteristics[i];
+			break;
+			}
+		}	
+	}
+	
+CExtendedCharacteristics* CMD2Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CMD2Impl::GetExtendedCharacteristicsL()
+	{
+	return CMD2Impl::CreateExtendedCharacteristicsL();
+	}
+
+TPtrC8 CMD2Impl::Hash(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	DoUpdate(aMessage.Ptr(),aMessage.Size());
+	StoreState();	
+	DoFinal();
+	ptr.Set(iHash);
+	RestoreState();	
+	return ptr;		
+	}		
+	
+void CMD2Impl::Update(const TDesC8& aMessage)
+	{
+	DoUpdate(aMessage.Ptr(),aMessage.Size());	
+	}
+	
+TPtrC8 CMD2Impl::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdate(aMessage.Ptr(),aMessage.Size());			
+		}
+	DoFinal();
+	ptr.Set(iHash);
+	Reset();
+	return ptr;
+	}
+	
+MHash* CMD2Impl::ReplicateL()
+	{
+	return NewL();	
+	}
+	
+MHash* CMD2Impl::CopyL()
+	{
+	return new(ELeave) CMD2Impl(*this);	
+	}
+
+void CMD2Impl::RestoreState()
+	{
+	Mem::Copy(&iData[0], &iDataTemp[0], KMD2BlockSize);
+	Mem::Copy(&iChecksum[0], &iChecksumTemp[0], KMD2BlockSize*sizeof(TUint));
+	Mem::Copy(&iState[0], &iStateTemp[0], KMD2BlockSize*sizeof(TUint));		
+	}
+	
+void CMD2Impl::StoreState()
+	{
+	Mem::Copy(&iDataTemp[0], &iData[0], KMD2BlockSize);
+	Mem::Copy(&iChecksumTemp[0], &iChecksum[0], KMD2BlockSize*sizeof(TUint));
+	Mem::Copy(&iStateTemp[0], &iState[0], KMD2BlockSize*sizeof(TUint));		
+	}
+
+
+TUid CMD2Impl::ImplementationUid()
+	{
+	return KCryptoPluginMd2Uid;
+	}
+
+static inline TUint CMD2_S(TUint& elt,TUint8 val)
+	{
+	return elt^=val;
+	}
+
+void CMD2Impl::DoUpdate(const TUint8* aData,TUint aLength)
+	{
+	TBool carryOn=ETrue;
+	if (iNum)
+		{
+		if (iNum+aLength>=(TUint)KMD2BlockSize)
+			{
+			const TUint temp=KMD2BlockSize-iNum;
+			(void)Mem::Copy(iData+iNum,aData,temp);
+			Block(iData);
+			aData+=temp;
+			aLength-=temp;
+			iNum=0;
+			}
+		else
+			{
+			(void)Mem::Copy(iData+iNum,aData,aLength);
+			iNum+=aLength;
+			carryOn=EFalse;
+			}
+		}
+	// processing by block of KMD2BlockSize
+	if (carryOn)
+		{
+		while (aLength>=(TUint)KMD2BlockSize)
+			{
+			Block(aData);
+			aData+=KMD2BlockSize;
+			aLength-=KMD2BlockSize;
+			}
+		(void)Mem::Copy(iData,aData,aLength);
+		iNum=aLength;
+		}		
+	}
+	
+void CMD2Impl::DoFinal()
+	{
+	const TUint pad=KMD2BlockSize-iNum;
+	if (pad>0)
+		Mem::Fill(iData+iNum,(TUint8)pad,pad);
+	Block(iData);
+
+	TUint8* pData=iData;
+	const TUint8* pEnd=iData+KMD2BlockSize;
+	const TUint* pChecksum=iChecksum;
+	while (pData<pEnd)
+		{
+		*pData=(TUint8)*pChecksum;//checksum is always less than 255 
+		pData++;
+		pChecksum++;
+		}
+	Block(iData);
+
+	TUint* pState=iState;
+	for (TUint i=0;i<(TUint)KMD2BlockSize;i++,pState++) //safe: iState and iHash have got same size
+		iHash[i]=(TUint8)(*pState&0xff);		
+	}
+	
+void CMD2Impl::Block(const TUint8* aData)
+	{
+	static const TUint8 S[256]={
+		0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01,
+		0x3D, 0x36, 0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13,
+		0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C,
+		0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA,
+		0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16,
+		0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12,
+		0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49,
+		0xA0, 0xFB, 0xF5, 0x8E, 0xBB, 0x2F, 0xEE, 0x7A,
+		0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F,
+		0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21,
+		0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27,
+		0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03,
+		0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1,
+		0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56, 0xAA, 0xC6,
+		0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,
+		0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1,
+		0x45, 0x9D, 0x70, 0x59, 0x64, 0x71, 0x87, 0x20,
+		0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02,
+		0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6,
+		0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F,
+		0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A,
+		0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26,
+		0x2C, 0x53, 0x0D, 0x6E, 0x85, 0x28, 0x84, 0x09,
+		0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52,
+		0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA,
+		0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A,
+		0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D,
+		0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39,
+		0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58, 0xD0, 0xE4,
+		0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,
+		0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A,
+		0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14,
+		};
+	TUint state[KMD2BlockSize*3];
+	TUint j=iChecksum[KMD2BlockSize-1];
+	TUint i=0,temp=0;
+	while (i<(TUint)KMD2BlockSize)
+		{
+		const TUint tempState=iState[i];
+		temp=aData[i];
+		state[i]=tempState;
+		state[i+16]=temp;
+		state[i+32]=temp^tempState;
+		j=CMD2_S(iChecksum[i++],S[temp^j]);
+		}
+	temp=0;
+	TUint* pstate=state;
+	const TUint *pend=state+(KMD2BlockSize*3);
+	for (i=0; i<18; i++)
+		{
+		while (pstate<pend)
+			{
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			temp=CMD2_S(*pstate,S[temp]);pstate++;
+			}
+		pstate=state;
+		temp=(temp+i)&0xff;
+		}
+	(void)Mem::Copy(iState,state,KMD2BlockSize*sizeof(TUint));		
+	}
+
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CMD2Impl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+
+void CMD2Impl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CMD2Impl::SetKeyL(const CKey& /*aKey*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/md2impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,95 @@
+/*
+* Copyright (c) 2006-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: 
+* Software md2 implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREMD2IMPL_H__
+#define __CRYPTOAPI_SOFTWAREMD2IMPL_H__
+
+#include "softwarehashbase.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	const TInt KMD2BlockSize = 16;
+	const TInt KMD2HashSize = 16;
+		
+	NONSHARABLE_CLASS(CMD2Impl) : public CBase, public MSoftwareHash
+		{		
+	public:
+		//NewL & NewLC	
+		static CMD2Impl* NewL();
+		static CMD2Impl* NewLC();
+		
+		//From MPlugin
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		
+		//From MHash
+	    TPtrC8 Hash(const TDesC8& aMessage);
+	    void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+		void SetKeyL(const CKey& aKey);
+		void SetOperationModeL(TUid aOperationMode);
+
+		
+		//From MSoftwareHash
+		void RestoreState();
+		void StoreState();
+		
+	private:
+		//Constructors
+		CMD2Impl();
+		CMD2Impl(const CMD2Impl& aCMD2Impl);
+		
+		//Destructor
+		~CMD2Impl();
+		
+		TUid ImplementationUid();
+		
+		void DoUpdate(const TUint8* aData,TUint aLength);
+		void DoFinal(void);
+		void Block(const TUint8* aData);
+
+		
+	private:
+	
+		TBuf8<KMD2HashSize> iHash;		
+		TInt iNum;
+		TUint8 iData[KMD2BlockSize];
+		TUint iChecksum[KMD2BlockSize];
+		TUint iState[KMD2BlockSize];
+		TUint8 iDataTemp[KMD2BlockSize];
+		TUint iChecksumTemp[KMD2BlockSize];
+		TUint iStateTemp[KMD2BlockSize];
+		};
+	}
+
+#endif //__CRYPTOAPI_SOFTWAREMD2IMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/md4impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,538 @@
+/*
+* Copyright (c) 2007-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: 
+* software md4 implementation
+* software md4 implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "md4impl.h"
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+
+
+using namespace SoftwareCrypto;
+
+	
+CMD4Impl* CMD4Impl::NewL()
+	{
+	CMD4Impl* self=new (ELeave) CMD4Impl();
+	self->Reset();
+	return self;						
+	}
+														
+CMD4Impl* CMD4Impl::NewLC()
+	{
+	CMD4Impl* self=NewL();
+	CleanupStack::PushL(self);
+	return self;						
+	}
+														
+CMD4Impl::CMD4Impl() : iHash(KMD4HashSize)
+	{		
+	}
+	
+CMD4Impl::CMD4Impl(const CMD4Impl& aCMD4Impl)
+: iHash(aCMD4Impl.iHash),iA(aCMD4Impl.iA),iB(aCMD4Impl.iB),iC(aCMD4Impl.iC),iD(aCMD4Impl.iD),
+  iNl(aCMD4Impl.iNl),iNh(aCMD4Impl.iNh)
+	{
+	(void)Mem::Copy(iData, aCMD4Impl.iData, sizeof(iData));
+	}
+	
+CMD4Impl::~CMD4Impl()
+	{	
+	}
+	
+void CMD4Impl::Reset()
+	{
+	iA=0x67452301;
+	iB=0xefcdab89;
+	iC=0x98badcfe;
+	iD=0x10325476;
+	iNh=0;
+	iNl=0;
+	}
+	
+void CMD4Impl::Close()
+	{
+	delete this;	
+	}
+	
+void CMD4Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+	for (TInt i=0;i<hashNum;i++)
+		{
+		if (KHashCharacteristics[i]->cmn.iImplementationUID == ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KHashCharacteristics[i];
+			break;
+			}
+		}	
+	}
+	
+CExtendedCharacteristics* CMD4Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+const CExtendedCharacteristics* CMD4Impl::GetExtendedCharacteristicsL()
+	{
+	return CMD4Impl::CreateExtendedCharacteristicsL();
+	}
+
+TPtrC8 CMD4Impl::Hash(const TDesC8& aMessage)
+	{
+	DoUpdate(aMessage.Ptr(),aMessage.Size());
+	StoreState();
+	DoFinal();
+	RestoreState();
+	return iHash;
+	}		
+	
+void CMD4Impl::Update(const TDesC8& aMessage)
+	{
+	DoUpdate(aMessage.Ptr(),aMessage.Size());	
+	}
+	
+TPtrC8 CMD4Impl::Final(const TDesC8& aMessage)
+	{
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdate(aMessage.Ptr(),aMessage.Size());			
+		}
+	DoFinal();
+	Reset();
+	return iHash;
+	}
+	
+MHash* CMD4Impl::ReplicateL()
+	{	 
+	return CMD4Impl::NewL();
+	}
+	
+MHash* CMD4Impl::CopyL()
+	{
+	return new(ELeave) CMD4Impl(*this);	
+	}
+
+TUid CMD4Impl::ImplementationUid()
+	{
+	return KCryptoPluginMd4Uid;
+	}
+
+void CMD4Impl::DoUpdate(const TUint8* aData,TUint aLength)
+	{
+	const TUint8* pend=aData+aLength;	
+	for (const TUint8* paData=aData;paData<pend;paData++) 
+		{
+		const TUint8 byte=*paData;
+		switch (iNl&3) 
+			{
+			case 0:
+				iData[iNl>>2]=byte;
+				break;
+			case 1:
+				iData[iNl>>2]|=byte<<8;
+				break;
+			case 2:
+				iData[iNl>>2]|=byte<<16;
+				break;
+			case 3:
+				iData[iNl>>2]|=byte<<24;
+				break;
+			default:
+				break;
+			};
+		if(++iNl==64) 
+			{
+			Block();
+			iNh+=64;
+			iNl=0;
+			}
+		}
+	}
+	
+static inline TUint CMD4_F(TUint x,TUint y,TUint z)
+	{
+	return (x&y) | (~x&z);
+	}
+static inline TUint CMD4_G(TUint x,TUint y,TUint z)
+	{
+	return (x&y) | (x&z) | (y&z);
+	}
+static inline TUint CMD4_H(TUint x,TUint y,TUint z)
+	{
+	return x^y^z;
+	}
+
+	
+#ifdef NOREFS
+static inline TUint CMD4_FF(TUint a,const TUint b,const TUint c,const TUint d,const TUint x,const TUint s)
+	{
+	a+=CMD4_F(b,c,d) + x; 
+	a=CMD_R(a,s);
+	return a;
+	}
+static inline TUint CMD4_GG(TUint a,const TUint b,const TUint c,const TUint d,const TUint x,const TUint s)
+	{
+	a+=CMD4_G(b,c,d) + x + (TUint32)0x5a827999; 
+	a=CMD_R(a,s);
+	return a;
+	}
+static inline TUint CMD4_HH(TUint a,const TUint b,const TUint c,const TUint d,const TUint x,const TUint s)
+	{
+	a+=CMD4_H(b,c,d) + x + (TUint32)0x6ed9eba1; 
+	a=CMD_R(a,s);
+	return a;
+	}
+
+void CMD4Impl::Block()
+	{
+	register TUint tempA=iA;
+	register TUint tempB=iB;
+	register TUint tempC=iC;
+	register TUint tempD=iD;
+
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[ 0],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[ 1],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[ 2],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[ 3],19);
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[ 4],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[ 5],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[ 6],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[ 7],19);
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[ 8],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[ 9],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[10],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[11],19);
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[12],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[13],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[14],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[15],19);
+
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 0],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 4],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[ 8],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[12],13);
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 1],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 5],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[ 9],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[13],13);
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 2],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 6],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[10],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[14],13);
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 3],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 7],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[11],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[15],13);
+
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 0],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[ 8],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 4],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[12],15);
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 2],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[10],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 6],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[14],15);
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 1],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[ 9],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 5],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[13],15);
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 3],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[11],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 7],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[15],15);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	}
+#else
+#ifdef MACRO
+#define CMD4_FF(a, b, c, d, x, s) (CMD_R(a += CMD4_F(b,c,d) + x, s))
+#define CMD4_GG(a, b, c, d, x, s) (CMD_R(a += CMD4_G(b,c,d) + x + (TUint32)0x5a827999, s))
+#define CMD4_HH(a, b, c, d, x, s) (CMD_R(a += CMD4_H(b,c,d) + x + (TUint32)0x6ed9eba1, s))
+void CMD4Impl::Block()
+	{
+	register TUint tempA=iA;
+	register TUint tempB=iB;
+	register TUint tempC=iC;
+	register TUint tempD=iD;
+	
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[ 0],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[ 1],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[ 2],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[ 3],19);
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[ 4],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[ 5],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[ 6],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[ 7],19);
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[ 8],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[ 9],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[10],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[11],19);
+	tempA = CMD4_FF(tempA,tempB,tempC,tempD,iData[12],3);
+	tempD = CMD4_FF(tempD,tempA,tempB,tempC,iData[13],7);
+	tempC = CMD4_FF(tempC,tempD,tempA,tempB,iData[14],11);
+	tempB = CMD4_FF(tempB,tempC,tempD,tempA,iData[15],19);
+
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 0],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 4],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[ 8],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[12],13);
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 1],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 5],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[ 9],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[13],13);
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 2],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 6],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[10],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[14],13);
+	tempA = CMD4_GG(tempA,tempB,tempC,tempD,iData[ 3],3);
+	tempD = CMD4_GG(tempD,tempA,tempB,tempC,iData[ 7],5);
+	tempC = CMD4_GG(tempC,tempD,tempA,tempB,iData[11],9);
+	tempB = CMD4_GG(tempB,tempC,tempD,tempA,iData[15],13);
+
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 0],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[ 8],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 4],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[12],15);
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 2],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[10],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 6],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[14],15);
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 1],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[ 9],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 5],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[13],15);
+	tempA = CMD4_HH(tempA,tempB,tempC,tempD,iData[ 3],3);
+	tempD = CMD4_HH(tempD,tempA,tempB,tempC,iData[11],9);
+	tempC = CMD4_HH(tempC,tempD,tempA,tempB,iData[ 7],11);
+	tempB = CMD4_HH(tempB,tempC,tempD,tempA,iData[15],15);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	}
+#else
+static inline void CMD4_FF(TUint& a,const TUint b,const TUint c,const TUint d,const TUint x,const TUint s)
+	{
+	a+=CMD4_F(b,c,d) + x; 
+	a=CMD_R(a,s);
+	}
+static inline void CMD4_GG(TUint& a,const TUint b,const TUint c,const TUint d,const TUint x,const TUint s)
+	{
+	a+=CMD4_G(b,c,d) + x + (TUint32)0x5a827999; 
+	a=CMD_R(a,s);
+	}
+static inline void CMD4_HH(TUint& a,const TUint b,const TUint c,const TUint d,const TUint x,const TUint s)
+	{
+	a+=CMD4_H(b,c,d) + x + (TUint32)0x6ed9eba1; 
+	a=CMD_R(a,s);
+	}
+
+void CMD4Impl::Block()
+	{
+	register TUint tempA=iA;
+	register TUint tempB=iB;
+	register TUint tempC=iC;
+	register TUint tempD=iD;
+
+	CMD4_FF(tempA,tempB,tempC,tempD,iData[ 0],3);
+	CMD4_FF(tempD,tempA,tempB,tempC,iData[ 1],7);
+	CMD4_FF(tempC,tempD,tempA,tempB,iData[ 2],11);
+	CMD4_FF(tempB,tempC,tempD,tempA,iData[ 3],19);
+	CMD4_FF(tempA,tempB,tempC,tempD,iData[ 4],3);
+	CMD4_FF(tempD,tempA,tempB,tempC,iData[ 5],7);
+	CMD4_FF(tempC,tempD,tempA,tempB,iData[ 6],11);
+	CMD4_FF(tempB,tempC,tempD,tempA,iData[ 7],19);
+	CMD4_FF(tempA,tempB,tempC,tempD,iData[ 8],3);
+	CMD4_FF(tempD,tempA,tempB,tempC,iData[ 9],7);
+	CMD4_FF(tempC,tempD,tempA,tempB,iData[10],11);
+	CMD4_FF(tempB,tempC,tempD,tempA,iData[11],19);
+	CMD4_FF(tempA,tempB,tempC,tempD,iData[12],3);
+	CMD4_FF(tempD,tempA,tempB,tempC,iData[13],7);
+	CMD4_FF(tempC,tempD,tempA,tempB,iData[14],11);
+	CMD4_FF(tempB,tempC,tempD,tempA,iData[15],19);
+
+	CMD4_GG(tempA,tempB,tempC,tempD,iData[ 0],3);
+	CMD4_GG(tempD,tempA,tempB,tempC,iData[ 4],5);
+	CMD4_GG(tempC,tempD,tempA,tempB,iData[ 8],9);
+	CMD4_GG(tempB,tempC,tempD,tempA,iData[12],13);
+	CMD4_GG(tempA,tempB,tempC,tempD,iData[ 1],3);
+	CMD4_GG(tempD,tempA,tempB,tempC,iData[ 5],5);
+	CMD4_GG(tempC,tempD,tempA,tempB,iData[ 9],9);
+	CMD4_GG(tempB,tempC,tempD,tempA,iData[13],13);
+	CMD4_GG(tempA,tempB,tempC,tempD,iData[ 2],3);
+	CMD4_GG(tempD,tempA,tempB,tempC,iData[ 6],5);
+	CMD4_GG(tempC,tempD,tempA,tempB,iData[10],9);
+	CMD4_GG(tempB,tempC,tempD,tempA,iData[14],13);
+	CMD4_GG(tempA,tempB,tempC,tempD,iData[ 3],3);
+	CMD4_GG(tempD,tempA,tempB,tempC,iData[ 7],5);
+	CMD4_GG(tempC,tempD,tempA,tempB,iData[11],9);
+	CMD4_GG(tempB,tempC,tempD,tempA,iData[15],13);
+
+	CMD4_HH(tempA,tempB,tempC,tempD,iData[ 0],3);
+	CMD4_HH(tempD,tempA,tempB,tempC,iData[ 8],9);
+	CMD4_HH(tempC,tempD,tempA,tempB,iData[ 4],11);
+	CMD4_HH(tempB,tempC,tempD,tempA,iData[12],15);
+	CMD4_HH(tempA,tempB,tempC,tempD,iData[ 2],3);
+	CMD4_HH(tempD,tempA,tempB,tempC,iData[10],9);
+	CMD4_HH(tempC,tempD,tempA,tempB,iData[ 6],11);
+	CMD4_HH(tempB,tempC,tempD,tempA,iData[14],15);
+	CMD4_HH(tempA,tempB,tempC,tempD,iData[ 1],3);
+	CMD4_HH(tempD,tempA,tempB,tempC,iData[ 9],9);
+	CMD4_HH(tempC,tempD,tempA,tempB,iData[ 5],11);
+	CMD4_HH(tempB,tempC,tempD,tempA,iData[13],15);
+	CMD4_HH(tempA,tempB,tempC,tempD,iData[ 3],3);
+	CMD4_HH(tempD,tempA,tempB,tempC,iData[11],9);
+	CMD4_HH(tempC,tempD,tempA,tempB,iData[ 7],11);
+	CMD4_HH(tempB,tempC,tempD,tempA,iData[15],15);
+		
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	}
+#endif
+#endif
+
+void CMD4Impl::DoFinal(void)
+	{
+	iNh += iNl;
+	const TUint ul128=128;
+	switch (iNl&3) 
+		{
+		case 0:
+			iData[iNl>>2] = ul128;
+			break;
+		case 1:
+			iData[iNl>>2] += ul128<<8;
+			break;
+		case 2:
+			iData[iNl>>2] += ul128<<16;
+			break;
+		case 3:
+			iData[iNl>>2] += ul128<<24;
+			break;
+		default:
+			break;
+		};
+	if (iNl>=56) 
+		{
+		if (iNl<60)
+			iData[15]=0;		
+		Block();
+		Mem::FillZ(iData,14*sizeof(TUint));
+		} 
+	else
+		{
+		const TUint offset=(iNl+4)>>2;
+		Mem::FillZ(iData+offset,(14-offset)*sizeof(TUint));
+		}
+   
+    iData[14]=iNh<<3;//number in bits
+	// this will fail if the total input length is longer than 2^32 in bits
+	//(2^31 in bytes) which is roughly half a gig.
+	iData[15]=0;
+
+	Block();
+	//
+	// Generate hash value into iHash
+	//
+	TUint tmp=iA;
+	iHash[0]=(TUint8)(tmp & 255);
+	iHash[1]=(TUint8)((tmp >>= 8) & 255);
+	iHash[2]=(TUint8)((tmp >>= 8) & 255);
+	iHash[3]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iB;
+	iHash[4]=(TUint8)(tmp & 255);
+	iHash[5]=(TUint8)((tmp >>= 8) & 255);
+	iHash[6]=(TUint8)((tmp >>= 8) & 255);
+	iHash[7]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iC;
+	iHash[8] =(TUint8)(tmp & 255);
+	iHash[9] =(TUint8)((tmp >>= 8) & 255);
+	iHash[10]=(TUint8)((tmp >>= 8) & 255);
+	iHash[11]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iD;
+	iHash[12]=(TUint8)(tmp & 255);
+	iHash[13]=(TUint8)((tmp >>= 8) & 255);
+	iHash[14]=(TUint8)((tmp >>= 8) & 255);
+	iHash[15]=(TUint8)((tmp >>= 8) & 255);
+	}
+
+void CMD4Impl::RestoreState()
+	{
+	iA = iACopy;
+	iB = iBCopy;
+	iC = iCCopy;
+	iD = iDCopy;
+	iNl = iNlCopy;
+	iNh = iNhCopy;	
+	Mem::Copy(&iData[0], &iDataCopy[0], KMD4BlockSize*sizeof(TUint)); 
+	}
+
+void CMD4Impl::StoreState()
+	{
+	iACopy = iA;
+	iBCopy = iB;
+	iCCopy = iC;
+	iDCopy = iD;
+	iNlCopy = iNl;
+	iNhCopy = iNh;	
+	Mem::Copy(&iDataCopy[0], &iData[0], KMD4BlockSize*sizeof(TUint));
+	}
+
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CMD4Impl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+
+void CMD4Impl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CMD4Impl::SetKeyL(const CKey& /*aKey*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/md4impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,103 @@
+/*
+* Copyright (c) 2007-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: 
+* Software md4 implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREMD4IMPL_H__
+#define __CRYPTOAPI_SOFTWAREMD4IMPL_H__
+
+#include "softwarehashbase.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	const TInt KMD4BlockSize = 16;
+	const TInt KMD4HashSize = 16;	
+	
+	NONSHARABLE_CLASS(CMD4Impl) : public CBase, public MSoftwareHash
+		{		
+	public:
+		//NewL & NewLC	
+		static CMD4Impl* NewL();
+		static CMD4Impl* NewLC();
+		
+		//From MPlugin
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		
+		//From MHash
+	    TPtrC8 Hash(const TDesC8& aMessage);
+	    void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+		void SetKeyL(const CKey& aKey);
+		void SetOperationModeL(TUid aOperationMode);		
+		
+		//From MSoftwareHash
+		void RestoreState();
+		void StoreState();
+		
+	private:
+		//Constructors
+		CMD4Impl();
+		CMD4Impl(const CMD4Impl& aCMD4Impl);
+		
+		//Destructor
+		~CMD4Impl();
+		
+		TUid ImplementationUid();
+		
+		void DoUpdate(const TUint8* aData,TUint aLength);
+		void DoFinal(void);
+		void Block();
+	
+	private:
+		TBuf8<KMD4HashSize> iHash;
+
+		TUint iA;
+		TUint iB;
+		TUint iC;
+		TUint iD;
+		TUint iNl;
+		TUint iNh;
+		TUint iData[KMD4BlockSize];
+
+		TUint iACopy;
+		TUint iBCopy;
+		TUint iCCopy;
+		TUint iDCopy;
+		TUint iNlCopy;
+		TUint iNhCopy;
+		TUint iDataCopy[KMD4BlockSize];
+		
+		};
+	}
+
+#endif //  __CRYPTOAPI_SOFTWAREMD4IMPL_H__
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/md5impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,604 @@
+/*
+* Copyright (c) 2006-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: 
+* software md5 implementation
+* software md5 implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "md5impl.h"
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+
+	
+CMD5Impl* CMD5Impl::NewL()
+	{
+	CMD5Impl* self=new (ELeave) CMD5Impl();
+	self->Reset();
+	return self;						
+	}
+														
+CMD5Impl* CMD5Impl::NewLC()
+	{
+	CMD5Impl* self=NewL();
+	CleanupStack::PushL(self);
+	return self;						
+	}
+														
+CMD5Impl::CMD5Impl() : iHash(KMD5HashSize)
+	{		
+	}
+	
+CMD5Impl::CMD5Impl(const CMD5Impl& aCMD5Impl)
+: iHash(aCMD5Impl.iHash),iA(aCMD5Impl.iA),iB(aCMD5Impl.iB),iC(aCMD5Impl.iC),iD(aCMD5Impl.iD),
+  iNl(aCMD5Impl.iNl),iNh(aCMD5Impl.iNh)
+	{
+	(void)Mem::Copy(iData, aCMD5Impl.iData, sizeof(iData));
+	}
+	
+CMD5Impl::~CMD5Impl()
+	{	
+	}
+	
+void CMD5Impl::Reset()
+	{
+	iA=0x67452301;
+	iB=0xefcdab89;
+	iC=0x98badcfe;
+	iD=0x10325476;
+	iNh=0;
+	iNl=0;
+	}
+	
+void CMD5Impl::Close()
+	{
+	delete this;	
+	}
+	
+void CMD5Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+	for (TInt i=0;i<hashNum;i++)
+		{
+		if (KHashCharacteristics[i]->cmn.iImplementationUID == ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KHashCharacteristics[i];
+			break;
+			}
+		}	
+	}
+
+CExtendedCharacteristics* CMD5Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CMD5Impl::GetExtendedCharacteristicsL()
+	{
+	return CMD5Impl::CreateExtendedCharacteristicsL();
+	}
+
+TPtrC8 CMD5Impl::Hash(const TDesC8& aMessage)
+	{
+	
+	TPtrC8 ptr(KNullDesC8());
+	DoUpdate(aMessage.Ptr(),aMessage.Size());
+	StoreState();
+	DoFinal();
+	ptr.Set(iHash);
+	RestoreState();
+	return ptr;
+	}		
+	
+void CMD5Impl::Update(const TDesC8& aMessage)
+	{
+	DoUpdate(aMessage.Ptr(),aMessage.Size());	
+	}
+	
+TPtrC8 CMD5Impl::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdate(aMessage.Ptr(),aMessage.Size());			
+		}
+	DoFinal();
+	ptr.Set(iHash);
+	Reset();
+	return ptr;
+	}
+	
+MHash* CMD5Impl::ReplicateL()
+	{	 
+	return CMD5Impl::NewL();
+	}
+	
+MHash* CMD5Impl::CopyL()
+	{
+	return new(ELeave) CMD5Impl(*this);	
+	}
+
+TUid CMD5Impl::ImplementationUid()
+	{
+	return KCryptoPluginMd5Uid;
+	}
+
+void CMD5Impl::DoUpdate(const TUint8* aData,TUint aLength)
+	{
+	const TUint8* pend=aData+aLength;	
+	for (const TUint8* paData=aData;paData<pend;paData++) 
+		{
+		const TUint8 byte=*paData;
+		switch (iNl&3) 
+			{
+			case 0:
+				iData[iNl>>2]=byte;
+				break;
+			case 1:
+				iData[iNl>>2]|=byte<<8;
+				break;
+			case 2:
+				iData[iNl>>2]|=byte<<16;
+				break;
+			case 3:
+				iData[iNl>>2]|=byte<<24;
+				break;
+			default:
+				break;
+			};
+		if(++iNl==64) 
+			{
+			Block();
+			iNh+=64;
+			iNl=0;
+			}
+		}
+	}
+	
+static inline TUint CMD5_F(TUint x,TUint y,TUint z)
+	{
+	return (x&y) | (~x&z);
+	}
+static inline TUint CMD5_G(TUint x,TUint y,TUint z)
+	{
+	return (x&z) | (y&~z);
+	}
+static inline TUint CMD5_H(TUint x,TUint y,TUint z)
+	{
+	return x^y^z;
+	}
+static inline TUint CMD5_I(TUint x,TUint y,TUint z)
+	{
+	return y^(x|~z);
+	}
+
+	
+#ifdef NOREFS
+static inline TUint CMD5_FF(TUint a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_F(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	return a;
+	}
+static inline TUint CMD5_GG(TUint a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_G(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	return a;
+	}
+static inline TUint CMD5_HH(TUint a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_H(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	return a;
+	}
+static inline TUint CMD5_II(TUint a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_I(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	return a;
+	}
+void CMD5Impl::Block()
+	{
+	register TUint tempA=iA;
+	register TUint tempB=iB;
+	register TUint tempC=iC;
+	register TUint tempD=iD;
+
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[ 0], 7, 0xd76aa478);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[ 1],12, 0xe8c7b756);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[ 2],17, 0x242070db);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[ 3],22, 0xc1bdceee);
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[ 4], 7, 0xf57c0faf);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[ 5],12, 0x4787c62a);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[ 6],17, 0xa8304613);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[ 7],22, 0xfd469501);
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[ 8], 7, 0x698098d8);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[ 9],12, 0x8b44f7af);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[10],17, 0xffff5bb1);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[11],22, 0x895cd7be);
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[12], 7, 0x6b901122);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[13],12, 0xfd987193);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[14],17, 0xa679438e);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[15],22, 0x49b40821);
+
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[ 1], 5, 0xf61e2562);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[ 6], 9, 0xc040b340);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[11],14, 0x265e5a51);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[ 0],20, 0xe9b6c7aa);
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[ 5], 5, 0xd62f105d);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[10], 9, 0x02441453);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[15],14, 0xd8a1e681);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[ 4],20, 0xe7d3fbc8);
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[ 9], 5, 0x21e1cde6);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[14], 9, 0xc33707d6);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[ 3],14, 0xf4d50d87);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[ 8],20, 0x455a14ed);
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[13], 5, 0xa9e3e905);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[ 2], 9, 0xfcefa3f8);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[ 7],14, 0x676f02d9);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[12],20, 0x8d2a4c8a);
+
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[ 5], 4, 0xfffa3942);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[ 8],11, 0x8771f681);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[11],16, 0x6d9d6122);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[14],23, 0xfde5380c);
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[ 1], 4, 0xa4beea44);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[ 4],11, 0x4bdecfa9);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[ 7],16, 0xf6bb4b60);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[10],23, 0xbebfbc70);
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[13], 4, 0x289b7ec6);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[ 0],11, 0xeaa127fa);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[ 3],16, 0xd4ef3085);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[ 6],23, 0x04881d05);
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[ 9], 4, 0xd9d4d039);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[12],11, 0xe6db99e5);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[15],16, 0x1fa27cf8);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[ 2],23, 0xc4ac5665);
+
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[ 0], 6, 0xf4292244);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[ 7],10, 0x432aff97);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[14],15, 0xab9423a7);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[ 5],21, 0xfc93a039);
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[12], 6, 0x655b59c3);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[ 3],10, 0x8f0ccc92);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[10],15, 0xffeff47d);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[ 1],21, 0x85845dd1);
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[ 8], 6, 0x6fa87e4f);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[15],10, 0xfe2ce6e0);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[ 6],15, 0xa3014314);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[13],21, 0x4e0811a1);
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[ 4], 6, 0xf7537e82);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[11],10, 0xbd3af235);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[ 2],15, 0x2ad7d2bb);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[ 9],21, 0xeb86d391);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	}
+#else
+#ifdef MACRO
+#define CMD5_FF(a, b, c, d, m, s, t) (b + CMD_R(a += CMD5_F(b,c,d) + m + t, s))
+#define CMD5_GG(a, b, c, d, m, s, t) (b + CMD_R(a += CMD5_G(b,c,d) + m + t, s))
+#define CMD5_HH(a, b, c, d, m, s, t) (b + CMD_R(a += CMD5_H(b,c,d) + m + t, s))
+#define CMD5_II(a, b, c, d, m, s, t) (b + CMD_R(a += CMD5_I(b,c,d) + m + t, s))
+void CMD5Impl::Block()
+	{
+	register TUint tempA=iA;
+	register TUint tempB=iB;
+	register TUint tempC=iC;
+	register TUint tempD=iD;
+
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[ 0], 7, 0xd76aa478);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[ 1],12, 0xe8c7b756);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[ 2],17, 0x242070db);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[ 3],22, 0xc1bdceee);
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[ 4], 7, 0xf57c0faf);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[ 5],12, 0x4787c62a);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[ 6],17, 0xa8304613);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[ 7],22, 0xfd469501);
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[ 8], 7, 0x698098d8);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[ 9],12, 0x8b44f7af);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[10],17, 0xffff5bb1);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[11],22, 0x895cd7be);
+	tempA = CMD5_FF(tempA,tempB,tempC,tempD,iData[12], 7, 0x6b901122);
+	tempD = CMD5_FF(tempD,tempA,tempB,tempC,iData[13],12, 0xfd987193);
+	tempC = CMD5_FF(tempC,tempD,tempA,tempB,iData[14],17, 0xa679438e);
+	tempB = CMD5_FF(tempB,tempC,tempD,tempA,iData[15],22, 0x49b40821);
+
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[ 1], 5, 0xf61e2562);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[ 6], 9, 0xc040b340);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[11],14, 0x265e5a51);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[ 0],20, 0xe9b6c7aa);
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[ 5], 5, 0xd62f105d);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[10], 9, 0x02441453);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[15],14, 0xd8a1e681);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[ 4],20, 0xe7d3fbc8);
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[ 9], 5, 0x21e1cde6);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[14], 9, 0xc33707d6);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[ 3],14, 0xf4d50d87);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[ 8],20, 0x455a14ed);
+	tempA = CMD5_GG(tempA,tempB,tempC,tempD,iData[13], 5, 0xa9e3e905);
+	tempD = CMD5_GG(tempD,tempA,tempB,tempC,iData[ 2], 9, 0xfcefa3f8);
+	tempC = CMD5_GG(tempC,tempD,tempA,tempB,iData[ 7],14, 0x676f02d9);
+	tempB = CMD5_GG(tempB,tempC,tempD,tempA,iData[12],20, 0x8d2a4c8a);
+
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[ 5], 4, 0xfffa3942);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[ 8],11, 0x8771f681);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[11],16, 0x6d9d6122);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[14],23, 0xfde5380c);
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[ 1], 4, 0xa4beea44);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[ 4],11, 0x4bdecfa9);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[ 7],16, 0xf6bb4b60);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[10],23, 0xbebfbc70);
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[13], 4, 0x289b7ec6);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[ 0],11, 0xeaa127fa);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[ 3],16, 0xd4ef3085);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[ 6],23, 0x04881d05);
+	tempA = CMD5_HH(tempA,tempB,tempC,tempD,iData[ 9], 4, 0xd9d4d039);
+	tempD = CMD5_HH(tempD,tempA,tempB,tempC,iData[12],11, 0xe6db99e5);
+	tempC = CMD5_HH(tempC,tempD,tempA,tempB,iData[15],16, 0x1fa27cf8);
+	tempB = CMD5_HH(tempB,tempC,tempD,tempA,iData[ 2],23, 0xc4ac5665);
+
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[ 0], 6, 0xf4292244);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[ 7],10, 0x432aff97);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[14],15, 0xab9423a7);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[ 5],21, 0xfc93a039);
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[12], 6, 0x655b59c3);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[ 3],10, 0x8f0ccc92);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[10],15, 0xffeff47d);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[ 1],21, 0x85845dd1);
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[ 8], 6, 0x6fa87e4f);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[15],10, 0xfe2ce6e0);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[ 6],15, 0xa3014314);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[13],21, 0x4e0811a1);
+	tempA = CMD5_II(tempA,tempB,tempC,tempD,iData[ 4], 6, 0xf7537e82);
+	tempD = CMD5_II(tempD,tempA,tempB,tempC,iData[11],10, 0xbd3af235);
+	tempC = CMD5_II(tempC,tempD,tempA,tempB,iData[ 2],15, 0x2ad7d2bb);
+	tempB = CMD5_II(tempB,tempC,tempD,tempA,iData[ 9],21, 0xeb86d391);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	}
+#else
+static inline void CMD5_FF(TUint& a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_F(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	}
+static inline void CMD5_GG(TUint& a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_G(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	}
+static inline void CMD5_HH(TUint& a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_H(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	}
+static inline void CMD5_II(TUint& a,const TUint b,const TUint c,const TUint d,const TUint m,const TUint s,const TUint t)
+	{
+	a+=CMD5_I(b,c,d) + m + t; 
+	a=b + CMD_R(a,s);
+	}
+void CMD5Impl::Block()
+	{
+	register TUint tempA=iA;
+	register TUint tempB=iB;
+	register TUint tempC=iC;
+	register TUint tempD=iD;
+
+	CMD5_FF(tempA,tempB,tempC,tempD,iData[ 0], 7, 0xd76aa478);
+	CMD5_FF(tempD,tempA,tempB,tempC,iData[ 1],12, 0xe8c7b756);
+	CMD5_FF(tempC,tempD,tempA,tempB,iData[ 2],17, 0x242070db);
+	CMD5_FF(tempB,tempC,tempD,tempA,iData[ 3],22, 0xc1bdceee);
+	CMD5_FF(tempA,tempB,tempC,tempD,iData[ 4], 7, 0xf57c0faf);
+	CMD5_FF(tempD,tempA,tempB,tempC,iData[ 5],12, 0x4787c62a);
+	CMD5_FF(tempC,tempD,tempA,tempB,iData[ 6],17, 0xa8304613);
+	CMD5_FF(tempB,tempC,tempD,tempA,iData[ 7],22, 0xfd469501);
+	CMD5_FF(tempA,tempB,tempC,tempD,iData[ 8], 7, 0x698098d8);
+	CMD5_FF(tempD,tempA,tempB,tempC,iData[ 9],12, 0x8b44f7af);
+	CMD5_FF(tempC,tempD,tempA,tempB,iData[10],17, 0xffff5bb1);
+	CMD5_FF(tempB,tempC,tempD,tempA,iData[11],22, 0x895cd7be);
+	CMD5_FF(tempA,tempB,tempC,tempD,iData[12], 7, 0x6b901122);
+	CMD5_FF(tempD,tempA,tempB,tempC,iData[13],12, 0xfd987193);
+	CMD5_FF(tempC,tempD,tempA,tempB,iData[14],17, 0xa679438e);
+	CMD5_FF(tempB,tempC,tempD,tempA,iData[15],22, 0x49b40821);
+
+	CMD5_GG(tempA,tempB,tempC,tempD,iData[ 1], 5, 0xf61e2562);
+	CMD5_GG(tempD,tempA,tempB,tempC,iData[ 6], 9, 0xc040b340);
+	CMD5_GG(tempC,tempD,tempA,tempB,iData[11],14, 0x265e5a51);
+	CMD5_GG(tempB,tempC,tempD,tempA,iData[ 0],20, 0xe9b6c7aa);
+	CMD5_GG(tempA,tempB,tempC,tempD,iData[ 5], 5, 0xd62f105d);
+	CMD5_GG(tempD,tempA,tempB,tempC,iData[10], 9, 0x02441453);
+	CMD5_GG(tempC,tempD,tempA,tempB,iData[15],14, 0xd8a1e681);
+	CMD5_GG(tempB,tempC,tempD,tempA,iData[ 4],20, 0xe7d3fbc8);
+	CMD5_GG(tempA,tempB,tempC,tempD,iData[ 9], 5, 0x21e1cde6);
+	CMD5_GG(tempD,tempA,tempB,tempC,iData[14], 9, 0xc33707d6);
+	CMD5_GG(tempC,tempD,tempA,tempB,iData[ 3],14, 0xf4d50d87);
+	CMD5_GG(tempB,tempC,tempD,tempA,iData[ 8],20, 0x455a14ed);
+	CMD5_GG(tempA,tempB,tempC,tempD,iData[13], 5, 0xa9e3e905);
+	CMD5_GG(tempD,tempA,tempB,tempC,iData[ 2], 9, 0xfcefa3f8);
+	CMD5_GG(tempC,tempD,tempA,tempB,iData[ 7],14, 0x676f02d9);
+	CMD5_GG(tempB,tempC,tempD,tempA,iData[12],20, 0x8d2a4c8a);
+
+	CMD5_HH(tempA,tempB,tempC,tempD,iData[ 5], 4, 0xfffa3942);
+	CMD5_HH(tempD,tempA,tempB,tempC,iData[ 8],11, 0x8771f681);
+	CMD5_HH(tempC,tempD,tempA,tempB,iData[11],16, 0x6d9d6122);
+	CMD5_HH(tempB,tempC,tempD,tempA,iData[14],23, 0xfde5380c);
+	CMD5_HH(tempA,tempB,tempC,tempD,iData[ 1], 4, 0xa4beea44);
+	CMD5_HH(tempD,tempA,tempB,tempC,iData[ 4],11, 0x4bdecfa9);
+	CMD5_HH(tempC,tempD,tempA,tempB,iData[ 7],16, 0xf6bb4b60);
+	CMD5_HH(tempB,tempC,tempD,tempA,iData[10],23, 0xbebfbc70);
+	CMD5_HH(tempA,tempB,tempC,tempD,iData[13], 4, 0x289b7ec6);
+	CMD5_HH(tempD,tempA,tempB,tempC,iData[ 0],11, 0xeaa127fa);
+	CMD5_HH(tempC,tempD,tempA,tempB,iData[ 3],16, 0xd4ef3085);
+	CMD5_HH(tempB,tempC,tempD,tempA,iData[ 6],23, 0x04881d05);
+	CMD5_HH(tempA,tempB,tempC,tempD,iData[ 9], 4, 0xd9d4d039);
+	CMD5_HH(tempD,tempA,tempB,tempC,iData[12],11, 0xe6db99e5);
+	CMD5_HH(tempC,tempD,tempA,tempB,iData[15],16, 0x1fa27cf8);
+	CMD5_HH(tempB,tempC,tempD,tempA,iData[ 2],23, 0xc4ac5665);
+
+	CMD5_II(tempA,tempB,tempC,tempD,iData[ 0], 6, 0xf4292244);
+	CMD5_II(tempD,tempA,tempB,tempC,iData[ 7],10, 0x432aff97);
+	CMD5_II(tempC,tempD,tempA,tempB,iData[14],15, 0xab9423a7);
+	CMD5_II(tempB,tempC,tempD,tempA,iData[ 5],21, 0xfc93a039);
+	CMD5_II(tempA,tempB,tempC,tempD,iData[12], 6, 0x655b59c3);
+	CMD5_II(tempD,tempA,tempB,tempC,iData[ 3],10, 0x8f0ccc92);
+	CMD5_II(tempC,tempD,tempA,tempB,iData[10],15, 0xffeff47d);
+	CMD5_II(tempB,tempC,tempD,tempA,iData[ 1],21, 0x85845dd1);
+	CMD5_II(tempA,tempB,tempC,tempD,iData[ 8], 6, 0x6fa87e4f);
+	CMD5_II(tempD,tempA,tempB,tempC,iData[15],10, 0xfe2ce6e0);
+	CMD5_II(tempC,tempD,tempA,tempB,iData[ 6],15, 0xa3014314);
+	CMD5_II(tempB,tempC,tempD,tempA,iData[13],21, 0x4e0811a1);
+	CMD5_II(tempA,tempB,tempC,tempD,iData[ 4], 6, 0xf7537e82);
+	CMD5_II(tempD,tempA,tempB,tempC,iData[11],10, 0xbd3af235);
+	CMD5_II(tempC,tempD,tempA,tempB,iData[ 2],15, 0x2ad7d2bb);
+	CMD5_II(tempB,tempC,tempD,tempA,iData[ 9],21, 0xeb86d391);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	}
+#endif
+#endif
+
+void CMD5Impl::DoFinal(void)
+	{
+	iNh += iNl;
+	const TUint ul128=128;
+	switch (iNl&3) 
+		{
+		case 0:
+			iData[iNl>>2] = ul128;
+			break;
+		case 1:
+			iData[iNl>>2] += ul128<<8;
+			break;
+		case 2:
+			iData[iNl>>2] += ul128<<16;
+			break;
+		case 3:
+			iData[iNl>>2] += ul128<<24;
+			break;
+		default:
+			break;
+		};
+	if (iNl>=56) 
+		{
+		if (iNl<60)
+			iData[15]=0;		
+		Block();
+		Mem::FillZ(iData,14*sizeof(TUint));
+		} 
+	else
+		{
+		const TUint offset=(iNl+4)>>2;
+		Mem::FillZ(iData+offset,(14-offset)*sizeof(TUint));
+		}
+
+	iData[14]=iNh<<3;//number in bits
+	// this will fail if the total input length is longer than 2^32 in bits
+	//(2^31 in bytes) which is roughly half a gig.
+	iData[15]=0;
+	Block();
+	//
+	// Generate hash value into iHash
+	//
+	TUint tmp=iA;
+	iHash[0]=(TUint8)(tmp & 255);
+	iHash[1]=(TUint8)((tmp >>= 8) & 255);
+	iHash[2]=(TUint8)((tmp >>= 8) & 255);
+	iHash[3]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iB;
+	iHash[4]=(TUint8)(tmp & 255);
+	iHash[5]=(TUint8)((tmp >>= 8) & 255);
+	iHash[6]=(TUint8)((tmp >>= 8) & 255);
+	iHash[7]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iC;
+	iHash[8]=(TUint8)(tmp & 255);
+	iHash[9]=(TUint8)((tmp >>= 8) & 255);
+	iHash[10]=(TUint8)((tmp >>= 8) & 255);
+	iHash[11]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iD;
+	iHash[12]=(TUint8)(tmp & 255);
+	iHash[13]=(TUint8)((tmp >>= 8) & 255);
+	iHash[14]=(TUint8)((tmp >>= 8) & 255);
+	iHash[15]=(TUint8)((tmp >>= 8) & 255);
+	}
+
+void CMD5Impl::RestoreState()
+	{
+	iA = iACopy;
+	iB = iBCopy;
+	iC = iCCopy;
+	iD = iDCopy;
+	iNl = iNlCopy;
+	iNh = iNhCopy;	
+	Mem::Copy(&iData[0], &iDataCopy[0], KMD5BlockSize*sizeof(TUint)); 
+	}
+
+void CMD5Impl::StoreState()
+	{
+	iACopy = iA;
+	iBCopy = iB;
+	iCCopy = iC;
+	iDCopy = iD;
+	iNlCopy = iNl;
+	iNhCopy = iNh;	
+	Mem::Copy(&iDataCopy[0], &iData[0], KMD5BlockSize*sizeof(TUint));
+	}
+
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CMD5Impl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+
+void CMD5Impl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CMD5Impl::SetKeyL(const CKey& /*aKey*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/md5impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,102 @@
+/*
+* Copyright (c) 2006-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: 
+* Software md5 implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREMD5IMPL_H__
+#define __CRYPTOAPI_SOFTWAREMD5IMPL_H__
+
+#include "softwarehashbase.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	const TInt KMD5BlockSize = 16;
+	const TInt KMD5HashSize = 16;	
+	
+	NONSHARABLE_CLASS(CMD5Impl) : public CBase, public MSoftwareHash
+		{		
+	public:
+		//NewL & NewLC	
+		static CMD5Impl* NewL();
+		static CMD5Impl* NewLC();
+		
+		//From MPlugin
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		
+		//From MHash
+	    TPtrC8 Hash(const TDesC8& aMessage);
+	    void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+		void SetKeyL(const CKey& aKey);
+		void SetOperationModeL(TUid aOperationMode);		
+		
+		//From MSoftwareHash
+		void RestoreState();
+		void StoreState();
+		
+	private:
+		//Constructors
+		CMD5Impl();
+		CMD5Impl(const CMD5Impl& aCMD5Impl);
+		
+		//Destructor
+		~CMD5Impl();
+		
+		TUid ImplementationUid();
+		
+		void DoUpdate(const TUint8* aData,TUint aLength);
+		void DoFinal(void);
+		void Block();
+	
+	private:
+		TBuf8<KMD5HashSize> iHash;
+
+		TUint iA;
+		TUint iB;
+		TUint iC;
+		TUint iD;
+		TUint iNl;
+		TUint iNh;
+		TUint iData[KMD5BlockSize];
+
+		TUint iACopy;
+		TUint iBCopy;
+		TUint iCCopy;
+		TUint iDCopy;
+		TUint iNlCopy;
+		TUint iNhCopy;
+		TUint iDataCopy[KMD5BlockSize];
+		};
+	}
+
+#endif //  __CRYPTOAPI_SOFTWAREMD5IMPL_H__
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/pluginconfig.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,538 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+/**
+ @file
+ @@internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREPLUGINCONFIG_H__
+#define __CRYPTOAPI_SOFTWAREPLUGINCONFIG_H__
+
+#include <cryptospi/cryptoparams.h>
+#include <e32cmn.h>
+#include <cryptospi/romlit.h>
+#include <cryptospi/cryptospidef.h>
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+
+	/**
+	Creator Name
+	*/
+	_ROMLIT16(KSymbian, "Symbian");
+	
+	/**
+	implementation Name
+	*/
+	_ROMLIT16(KMd2Description, "Md2");
+	_ROMLIT16(KMd4Description, "Md4");
+	_ROMLIT16(KMd5Description, "Md5");
+	_ROMLIT16(KSha1Description, "Sha1");
+	_ROMLIT16(KSha224Description, "Sha224");
+	_ROMLIT16(KSha256Description, "Sha256");
+	_ROMLIT16(KSha384Description, "Sha384");
+	_ROMLIT16(KSha512Description, "Sha512");
+
+	_ROMLIT16(KRandomDescription, "Random");
+	_ROMLIT16(KDesDescription, "Des");
+	_ROMLIT16(K3DesDescription, "3Des");
+	_ROMLIT16(KAesDescription, "Aes");
+	_ROMLIT16(KRC2Description, "RC2");
+	_ROMLIT16(KARC4Description, "ARC4");
+	_ROMLIT16(KRsaCipherDescription, "Rsa");
+	_ROMLIT16(KRsaSignerDescription, "RsaSigner");
+	_ROMLIT16(KDsaSignerDescription, "DsaSigner");
+	_ROMLIT16(KRsaVerifierDescription, "RsaVerifier");
+	_ROMLIT16(KDsaVerifierDescription, "DsaVerifier");
+	_ROMLIT16(KDHDescription, "DH");
+	_ROMLIT16(KSymmetricKeyGeneratorDescription, "Symmetric Key Generator");
+	_ROMLIT16(KRsaKeyPairDescription, "Rsa Key Pair Generator");
+	_ROMLIT16(KDsaKeyPairDescription, "Dsa Key Pair Generator");
+	_ROMLIT16(KDhKeyPairDescription, "DH Key Pair Generator");
+	/**
+	For each crypto algorithm implemented in this plugin define
+		a plugin-wide unique id to identify it
+		a UID that contains the above id
+		a table of characteristics
+	*/	
+
+	
+	/**
+	Md2 Characteristics
+	*/
+	static const TInt32 KCryptoPluginMd2 = 0x102831D0;	
+	static const TUid KCryptoPluginMd2Uid={KCryptoPluginMd2};
+	static const TInt32 KMd2OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KMd2_1 = {KHashInterface, KAlgorithmHashMd2, KCryptoPluginMd2, &KSymbian, EFalse, EFalse, 6, &KMd2Description, 100, 90, 128, 128, KMd2OperationModes, sizeof(KMd2OperationModes)/sizeof(KMd2OperationModes[0])};
+	
+	/**
+	Md5 Characteristics
+	*/
+	static const TInt32 KCryptoPluginMd5 = 0x102831D1;	
+	static const TUid KCryptoPluginMd5Uid={KCryptoPluginMd5};
+	static const TInt32 KMd5OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KMd5_1 = {KHashInterface, KAlgorithmHashMd5, KCryptoPluginMd5, &KSymbian, EFalse, EFalse, 6, &KMd5Description, 100, 90, 512, 128, KMd5OperationModes, sizeof(KMd5OperationModes)/sizeof(KMd5OperationModes[0])};	
+
+	/**
+	Sha1 Characteristics
+	*/
+	static const TInt32 KCryptoPluginSha1 = 0x102831D2;
+	static const TUid KCryptoPluginSha1Uid={KCryptoPluginSha1};
+	static const TInt32 KSha1OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KSha1_1 = {KHashInterface, KAlgorithmHashSha1, KCryptoPluginSha1, &KSymbian, EFalse, EFalse, 6, &KSha1Description, 100, 90, 512, 160, KSha1OperationModes, sizeof(KSha1OperationModes)/sizeof(KSha1OperationModes[0])};	
+	
+	/**
+	Md4 Characteristics
+	*/
+	static const TInt32 KCryptoPluginMd4 = 0x2000B340;	
+	static const TUid KCryptoPluginMd4Uid={KCryptoPluginMd4};
+	static const TInt32 KMd4OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KMd4_1 = {KHashInterface, KAlgorithmHashMd4, KCryptoPluginMd4, &KSymbian, EFalse, EFalse, 6, &KMd4Description, 100, 90, 512, 128, KMd4OperationModes, sizeof(KMd4OperationModes)/sizeof(KMd4OperationModes[0])};	
+	
+	/**
+	Sha224 Characteristics
+	*/
+	static const TInt32 KCryptoPluginSha224 = 0x2000E25C;
+	static const TUid KCryptoPluginSha224Uid={KCryptoPluginSha224};
+	static const TInt32 KSha224OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KSha224_1 = {KHashInterface, KAlgorithmHashSha224, KCryptoPluginSha224, &KSymbian, EFalse, EFalse, 6, &KSha224Description, 100, 90, 512, 224, KSha224OperationModes, sizeof(KSha224OperationModes)/sizeof(KSha224OperationModes[0])};	
+
+	/**
+	Sha256 Characteristics
+	*/
+	static const TInt32 KCryptoPluginSha256 = 0x2000E25D;
+	static const TUid KCryptoPluginSha256Uid={KCryptoPluginSha256};
+	static const TInt32 KSha256OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KSha256_1 = {KHashInterface, KAlgorithmHashSha256, KCryptoPluginSha256, &KSymbian, EFalse, EFalse, 6, &KSha256Description, 100, 90, 512, 256, KSha256OperationModes, sizeof(KSha256OperationModes)/sizeof(KSha256OperationModes[0])};	
+
+	/**
+	Sha384 Characteristics
+	*/
+	static const TInt32 KCryptoPluginSha384 = 0x2000E25E;
+	static const TUid KCryptoPluginSha384Uid={KCryptoPluginSha384};
+	static const TInt32 KSha384OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KSha384_1 = {KHashInterface, KAlgorithmHashSha384, KCryptoPluginSha384, &KSymbian, EFalse, EFalse, 6, &KSha384Description, 100, 90, 1024, 384, KSha384OperationModes, sizeof(KSha384OperationModes)/sizeof(KSha384OperationModes[0])};	
+
+	/**
+	Sha512 Characteristics
+	*/
+	static const TInt32 KCryptoPluginSha512 = 0x2000E25F;
+	static const TUid KCryptoPluginSha512Uid={KCryptoPluginSha512};
+	static const TInt32 KSha512OperationModes[]={KHashMode, KHmacMode};
+	static const THashCharacteristics KSha512_1 = {KHashInterface, KAlgorithmHashSha512, KCryptoPluginSha512, &KSymbian, EFalse, EFalse, 6, &KSha512Description, 100, 90, 1024, 512, KSha512OperationModes, sizeof(KSha512OperationModes)/sizeof(KSha512OperationModes[0])};	
+
+	
+	/**
+	Random Characteristics
+	*/
+	static const TInt32 KCryptoPluginRandom = 0x102831D3;
+	static const TUid KCryptoPluginRandomUid={KCryptoPluginRandom};
+	static const TRandomCharacteristics KRandom_1 = {KRandomInterface, KAlgorithmRandom, KCryptoPluginRandom, &KSymbian, EFalse, EFalse, 6, &KRandomDescription, 100, 90, 3};	
+
+
+	
+	/**
+	DES Characteristics
+	*/
+	static const TInt32 KCryptoPluginDes = 0x102831D4;
+	static const TUid KCryptoPluginDesUid={KCryptoPluginDes};
+	static const TInt32 KDesPaddingModes[]={KPaddingModeNone, KPaddingModeSSLv3, KPaddingModePKCS7};
+	static const TInt32 KDesCryptoModes[]={KOperationModeNone, KOperationModeECB, KOperationModeCBC, KOperationModeCTR};
+	
+	static const TSymmetricCipherCharacteristics KDes_1 = {KSymmetricCipherInterface, KAlgorithmCipherDes, KCryptoPluginDes, &KSymbian, EFalse, EFalse, 6, &KDesDescription, 100, 90, 
+	64 /* max key bits */, 64 /* block bits */, KDesPaddingModes, sizeof(KDesPaddingModes)/sizeof(KDesPaddingModes[0]), KDesCryptoModes, sizeof(KDesCryptoModes)/sizeof(KDesCryptoModes[0]), 3};
+
+	/**
+	3DES-EDE Characteristics
+	*/
+	static const TInt32 KCryptoPlugin3Des = 0x102831D5;
+	static const TUid KCryptoPlugin3DesUid={KCryptoPlugin3Des};
+	static const TInt32 K3DesPaddingModes[]={KPaddingModeNone, KPaddingModeSSLv3, KPaddingModePKCS7};
+	static const TInt32 K3DesCryptoModes[]={KOperationModeNone, KOperationModeECB, KOperationModeCBC, KOperationModeCTR};
+	
+	static const TSymmetricCipherCharacteristics K3Des_1 = {KSymmetricCipherInterface, KAlgorithmCipher3Des, KCryptoPlugin3Des, &KSymbian, EFalse, EFalse, 6, &K3DesDescription, 100, 90, 
+	192 /* max key bits */, 64 /* block bits */, K3DesPaddingModes, sizeof(K3DesPaddingModes)/sizeof(K3DesPaddingModes[0]), K3DesCryptoModes, sizeof(K3DesCryptoModes)/sizeof(K3DesCryptoModes[0]), 3};
+
+	/**
+	AES Characteristics
+	*/
+	static const TInt32 KCryptoPluginAes = 0x102831D6;
+	static const TUid KCryptoPluginAesUid={KCryptoPluginAes};
+	static const TInt32 KAesPaddingModes[]={KPaddingModeNone, KPaddingModeSSLv3, KPaddingModePKCS7};
+	static const TInt32 KAesCryptoModes[]={KOperationModeNone, KOperationModeECB, KOperationModeCBC, KOperationModeCTR};
+	
+	static const TSymmetricCipherCharacteristics KAes_1 = {KSymmetricCipherInterface, KAlgorithmCipherAes, KCryptoPluginAes, &KSymbian, EFalse, EFalse, 6, &KAesDescription, 100, 90, 
+	256 /* max key bits */, 128 /* block bits */, KAesPaddingModes, sizeof(KAesPaddingModes)/sizeof(KAesPaddingModes[0]), KAesCryptoModes, sizeof(KAesCryptoModes)/sizeof(KAesCryptoModes[0]), 3};
+
+
+	/**
+	RC2 Characteristics
+	*/
+	static const TInt32 KCryptoPluginRc2 = 0x102831D7;
+	static const TUid KCryptoPluginRc2Uid={KCryptoPluginRc2};
+	static const TInt32 KRc2PaddingModes[]={KPaddingModeNone, KPaddingModeSSLv3, KPaddingModePKCS7};
+	static const TInt32 KRc2CryptoModes[]={KOperationModeNone, KOperationModeECB, KOperationModeCBC, KOperationModeCTR};
+	
+	static const TSymmetricCipherCharacteristics KRc2_1 = {KSymmetricCipherInterface, KAlgorithmCipherRc2, KCryptoPluginRc2, &KSymbian, EFalse, EFalse, 6, &KRC2Description, 100, 90, 
+	1024 /* max key bits */, 64 /* block bits */, KRc2PaddingModes, sizeof(KRc2PaddingModes)/sizeof(KRc2PaddingModes[0]), KRc2CryptoModes, sizeof(KRc2CryptoModes)/sizeof(KRc2CryptoModes[0]), 3};
+
+
+	/**
+	ARC4 Characteristics
+	*/
+	static const TInt32 KCryptoPluginArc4 = 0x102831D8;
+	static const TUid KCryptoPluginArc4Uid={KCryptoPluginArc4};
+	static const TInt32 KArc4PaddingModes[]={KPaddingModeNone};
+	static const TInt32 KArc4CryptoModes[]={KOperationModeNone};
+	
+	static const TSymmetricCipherCharacteristics KArc4_1 = {KSymmetricCipherInterface, KAlgorithmCipherArc4, KCryptoPluginArc4, &KSymbian, EFalse, EFalse, 6, &KARC4Description, 100, 90, 
+	2048 /* max key bits */, 8 /* block bits */, KArc4PaddingModes, sizeof(KArc4PaddingModes)/sizeof(KArc4PaddingModes[0]), KArc4CryptoModes, sizeof(KArc4CryptoModes)/sizeof(KArc4CryptoModes[0]), 3};
+
+
+	/**
+	RSA Cipher Characteristics
+	*/
+	static const TInt32 KCryptoPluginRsaCipher = 0x102831D9;
+	static const TUid KCryptoPluginRsaCipherUid={KCryptoPluginRsaCipher};
+	static const TInt32 KRSACipherPaddingModes[]={KPaddingModeNone, KPaddingModePkcs1_v1_5_Encryption};
+	
+	static const TAsymmetricCipherCharacteristics KRSA_1 = {KAsymmetricCipherInterface, KAlgorithmCipherRsa, KCryptoPluginRsaCipher, &KSymbian, EFalse, EFalse, 6, &KRsaCipherDescription, 100, 90, 
+	256, KRSACipherPaddingModes, sizeof(KRSACipherPaddingModes)/sizeof(KRSACipherPaddingModes[0]), 3};
+
+
+	/**
+	RSA Signer Characteristics
+	*/
+	static const TInt32 KCryptoPluginRsaSigner = 0x102831DA;
+	static const TUid KCryptoPluginRsaSignerUid={KCryptoPluginRsaSigner};
+	static const TInt32 KRSASignerPaddingModes[]={KPaddingModeNone, KPaddingModePkcs1_v1_5_Signature};
+	
+	static const TAsymmetricSignatureCharacteristics KRSASigner_1 = {KSignerInterface, KAlgorithmSignerRsa, KCryptoPluginRsaSigner, &KSymbian, EFalse, EFalse, 6, &KRsaSignerDescription, 100, 90, 
+	256, KRSASignerPaddingModes, sizeof(KRSASignerPaddingModes)/sizeof(KRSASignerPaddingModes[0]), 3};
+
+	/**
+	DSA Signer Characteristics
+	*/
+	static const TInt32 KCryptoPluginDsaSigner = 0x102831DB;
+	static const TUid KCryptoPluginDsaSignerUid={KCryptoPluginDsaSigner};
+	static const TInt32 KDSASignerPaddingModes[]={KPaddingModeNone};
+	
+	static const TAsymmetricSignatureCharacteristics KDSASigner_1 = {KSignerInterface, KAlgorithmSignerDsa, KCryptoPluginDsaSigner, &KSymbian, EFalse, EFalse, 6, &KDsaSignerDescription, 100, 90, 
+	256, KDSASignerPaddingModes, sizeof(KDSASignerPaddingModes)/sizeof(KDSASignerPaddingModes[0]), 3};
+
+
+	/**
+	RSA verifier Characteristics
+	*/
+	static const TInt32 KCryptoPluginRsaVerifier = 0x102831DC;
+	static const TUid KCryptoPluginRsaVerifierUid={KCryptoPluginRsaVerifier};
+	static const TInt32 KRSAVerifierPaddingModes[]={KPaddingModeNone, KPaddingModePkcs1_v1_5_Signature};
+	
+	static const TAsymmetricSignatureCharacteristics KRSAVerifier_1 = {KVerifierInterface, KAlgorithmVerifierRsa, KCryptoPluginRsaVerifier, &KSymbian, EFalse, EFalse, 6, &KRsaVerifierDescription, 100, 90, 
+	256, KRSAVerifierPaddingModes, sizeof(KRSAVerifierPaddingModes)/sizeof(KRSAVerifierPaddingModes[0]), 3};
+
+	/**
+	DSA verifier Characteristics
+	*/
+	static const TInt32 KCryptoPluginDsaVerifier = 0x102831DD;
+	static const TUid KCryptoPluginDsaVerifierUid={KCryptoPluginDsaVerifier};
+	static const TInt32 KDSAVerifierPaddingModes[]={KPaddingModeNone};
+	
+	static const TAsymmetricSignatureCharacteristics KDSAVerifier_1 = {KVerifierInterface, KAlgorithmVerifierDsa, KCryptoPluginDsaVerifier, &KSymbian, EFalse, EFalse, 6, &KDsaVerifierDescription, 100, 90, 
+	256, KDSAVerifierPaddingModes, sizeof(KDSAVerifierPaddingModes)/sizeof(KDSAVerifierPaddingModes[0]), 3};
+
+	/**
+	DH Key Agreement Characteristics
+	*/
+	static const TInt32 KCryptoPluginDhKeyAgreement = 0x102831DE;	// used to identify the CKeyAgreementImpl derived class within the plugin to use
+	static const TUid KCryptoPluginDhKeyAgreementUid={KCryptoPluginDhKeyAgreement};	// returned by the CKeyAgreementImpl derived class
+	static const TKeyAgreementCharacteristics KDH_1 = {KKeyAgreementInterface, KAlgorithmKeyAgreementDH, KCryptoPluginDhKeyAgreement, &KSymbian, EFalse, EFalse, 6, &KDHDescription, 100, 90};
+
+	/**
+	DH Key Pair Generator Characteristics
+	*/
+	static const TInt32 KCryptoPluginDhKeyPairGen = 0x102831DF;
+	static const TUid KCryptoPluginDhKeyPairGenUid={KCryptoPluginDhKeyPairGen};
+	static const TAsymmetricKeypairGeneratorCharacteristics KDHKeyPairGenerator_1 = {KKeypairGeneratorInterface, KAlgorithmDHKeyPairGenerator, KCryptoPluginDhKeyPairGen, &KSymbian, EFalse, EFalse, 6, &KDhKeyPairDescription, 100, 90, 1024};
+
+	/**
+	RSA Key Pair Generator Characteristics
+	*/
+	static const TInt32 KCryptoPluginRsaKeyPairGen = 0x102831E0;
+	static const TUid KCryptoPluginRsaKeyPairGenUid={KCryptoPluginRsaKeyPairGen};
+	static const TAsymmetricKeypairGeneratorCharacteristics KRSAKeyPairGenerator_1 = {KKeypairGeneratorInterface, KAlgorithmRSAKeyPairGenerator, KCryptoPluginRsaKeyPairGen, &KSymbian, EFalse, EFalse, 6, &KRsaKeyPairDescription, 100, 90, 1024};
+
+	/**
+	DSA Key Pair Generator Characteristics
+	*/
+	static const TInt32 KCryptoPluginDsaKeyPairGen = 0x102831E1;
+	static const TUid KCryptoPluginDsaKeyPairGenUid={KCryptoPluginDsaKeyPairGen};
+	static const TAsymmetricKeypairGeneratorCharacteristics KDSAKeyPairGenerator_1 = {KKeypairGeneratorInterface, KAlgorithmDSAKeyPairGenerator, KCryptoPluginDsaKeyPairGen, &KSymbian, EFalse, EFalse, 6, &KDsaKeyPairDescription, 100, 90, 1024};
+
+
+/******************************MAC INTERFACE PLUG-INS' CHARACTERISTICS***************************/	
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	_ROMLIT16(KHmacMd2Description, "HmacMd2");
+	_ROMLIT16(KHmacMd4Description, "HmacMd4");
+	_ROMLIT16(KHmacMd5Description, "HmacMd5");
+	_ROMLIT16(KHmacSha1Description, "HmacSha1");
+	_ROMLIT16(KHmacSha224Description, "HmacSha224");
+	_ROMLIT16(KHmacSha256Description, "HmacSha256");
+	_ROMLIT16(KHmacSha384Description, "HmacSha384");
+	_ROMLIT16(KHmacSha512Description, "HmacSha512");
+	_ROMLIT16(KMacAesXcbcMac96Description, "AesXcbcMac96");
+	_ROMLIT16(KMacAesXcbcPrf128Description, "AesXcbcPrf128");
+	/**
+	 * AES-XCBC-MAC-96 MAC Plugin Characteristics
+	 */		            
+	static const TInt32 KCryptoPluginMacAesXcbcMac96 = 0x2001EDA8;	
+	static const TUid KCryptoPluginMacAesXcbcMac96Uid= {KCryptoPluginMacAesXcbcMac96};
+	static const TMacCharacteristics KMac_1 = {
+                                               KMacInterface, 
+                                               KAlgorithmCipherAesXcbcMac96, 
+			                                   KCryptoPluginMacAesXcbcMac96, 
+			                                   &KSymbian, 
+			                                   EFalse, EFalse, 6, 
+			                                   &KMacAesXcbcMac96Description, 
+			                                   100, 90, KSymmetricCipherMode,
+			                                   NULL,&KAes_1
+											   };
+	/**
+	 * AES-XCBC-PRF-128 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacAesXcbcPrf128  = 0x2001EDA9;	
+	static const TUid KCryptoPluginMacAesXcbcPrf128Uid = {KCryptoPluginMacAesXcbcPrf128};
+	static const TMacCharacteristics KMac_2 = {
+                                               KMacInterface, 
+                                               KAlgorithmCipherAesXcbcPrf128, 
+			                                   KCryptoPluginMacAesXcbcPrf128, 
+			                                   &KSymbian, 
+			                                   EFalse, EFalse, 6, 
+			                                   &KMacAesXcbcPrf128Description, 
+			                                   100, 90, KSymmetricCipherMode,
+			                                   NULL,&KAes_1
+											   };
+	/**
+	 * HASH-MD2 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashMd2  = 0x2001EDA0;	
+	static const TUid KCryptoPluginMacHashMd2Uid = {KCryptoPluginMacHashMd2};
+	static const TMacCharacteristics KMac_3 = {
+                                               KMacInterface, 
+										       KAlgorithmHashMd2, 
+				                               KCryptoPluginMacHashMd2, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacMd2Description, 
+				                               100, 90, KHmacMode,
+				                               &KMd2_1, NULL 
+						                       };
+	/**
+	 * HASH-MD4 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashMd4  = 0x2001EDA1;	
+	static const TUid KCryptoPluginMacHashMd4Uid = {KCryptoPluginMacHashMd4};
+	static const TMacCharacteristics KMac_4 = {
+                                               KMacInterface, 
+										       KAlgorithmHashMd4, 
+										       KCryptoPluginMacHashMd4, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacMd4Description, 
+				                               100, 90, KHmacMode,
+				                               &KMd4_1, NULL 
+						                       };
+	/**
+	 * HASH-MD5 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashMd5  = 0x2001EDA2;	
+	static const TUid KCryptoPluginMacHashMd5Uid = {KCryptoPluginMacHashMd5};
+	static const TMacCharacteristics KMac_5 = {
+                                               KMacInterface, 
+										       KAlgorithmHashMd5, 
+										       KCryptoPluginMacHashMd5, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacMd5Description, 
+				                               100, 90, KHmacMode,
+				                               &KMd5_1, NULL 
+						                       };
+	/**
+	 * HASH-SHA1 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashSha1  = 0x2001EDA3;	
+	static const TUid KCryptoPluginMacHashSha1Uid = {KCryptoPluginMacHashSha1};
+	static const TMacCharacteristics KMac_6 = {
+                                               KMacInterface, 
+										       KAlgorithmHashSha1, 
+										       KCryptoPluginMacHashSha1, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacSha1Description, 
+				                               100, 90, KHmacMode,
+				                               &KSha1_1, NULL 
+						                       };
+	/**
+	 * HASH-SHA224 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashSha224  = 0x2001EDA4;	
+	static const TUid KCryptoPluginMacHashSha224Uid = {KCryptoPluginMacHashSha224};
+	static const TMacCharacteristics KMac_7 = {
+                                               KMacInterface, 
+										       KAlgorithmHashSha224, 
+										       KCryptoPluginMacHashSha224, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacSha224Description, 
+				                               100, 90, KHmacMode,
+				                               &KSha224_1, NULL 
+						                       };
+	/**
+	 * HASH-SHA256 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashSha256  = 0x2001EDA5;	
+	static const TUid KCryptoPluginMacHashSha256Uid = {KCryptoPluginMacHashSha256};
+	static const TMacCharacteristics KMac_8 = {
+                                               KMacInterface, 
+										       KAlgorithmHashSha256, 
+										       KCryptoPluginMacHashSha256, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacSha256Description, 
+				                               100, 90, KHmacMode,
+				                               &KSha256_1, NULL 
+						                       };
+	/**
+	 * HASH-SHA384 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashSha384  = 0x2001EDA6;	
+	static const TUid KCryptoPluginMacHashSha384Uid = {KCryptoPluginMacHashSha384};
+	static const TMacCharacteristics KMac_9 = {
+                                               KMacInterface, 
+										       KAlgorithmHashSha384, 
+										       KCryptoPluginMacHashSha384, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacSha384Description, 
+				                               100, 90, KHmacMode,
+				                               &KSha384_1, NULL 
+						                       };
+	/**
+	 * HASH-SHA512 MAC Plugin Characteristics
+	 */		
+	static const TInt32 KCryptoPluginMacHashSha512  = 0x2001EDA7;	
+	static const TUid KCryptoPluginMacHashSha512Uid = {KCryptoPluginMacHashSha512};
+	static const TMacCharacteristics KMac_10 = {
+                                               KMacInterface, 
+										       KAlgorithmHashSha512, 
+										       KCryptoPluginMacHashSha512, 
+				                               &KSymbian, 
+				                               EFalse, EFalse, 6, 
+				                               &KHmacSha512Description, 
+				                               100, 90, KHmacMode,
+				                               &KSha512_1, NULL 
+						                       };
+	/**
+	 * Mac implementation characteristic table
+	 */
+	static const TMacCharacteristics* const KMacCharacteristics[] = {
+												&KMac_1, &KMac_2, &KMac_3, 
+												&KMac_4, &KMac_5, &KMac_6,
+												&KMac_7, &KMac_8, &KMac_9,
+												&KMac_10
+												};	
+	
+#endif
+/***********************************************************************************************/
+
+	/**
+	For each crypto algorithm type implemented in this plugin list the characteristics
+	*/
+	
+	/**
+	Hash implementation characteristic table
+	*/
+	static const THashCharacteristics* const KHashCharacteristics[] = 
+		{
+		&KMd2_1, &KMd5_1, &KSha1_1, &KMd4_1, &KSha224_1, &KSha256_1, &KSha384_1, &KSha512_1
+		};
+
+	/**
+	Random implementation characteristic table
+	*/
+	
+	static const TRandomCharacteristics* const KRandomCharacteristics[]=
+		{
+		&KRandom_1	
+		};
+		
+	/**
+	Symmetric Cipher implementation characteristic table
+	*/
+	static const TSymmetricCipherCharacteristics* const KSymmetricCipherCharacteristics[]=
+		{
+		&KDes_1, &K3Des_1, &KAes_1, &KRc2_1, &KArc4_1
+		};
+
+
+	/**
+	Asymmetric Cipher implementation characteristic table
+	*/
+	static const TAsymmetricCipherCharacteristics* const KAsymmetricCipherCharacteristics[]=
+		{
+		&KRSA_1	
+		};
+
+	/**
+	Signer implementation characteristic table
+	*/
+	static const TAsymmetricSignatureCharacteristics* const KSignerCharacteristics[]=
+		{
+		&KRSASigner_1, &KDSASigner_1
+		};
+
+
+	/**
+	Verifier implementation characteristic table
+	*/
+	static const TAsymmetricSignatureCharacteristics* const KVerifierCharacteristics[]=
+		{
+		&KRSAVerifier_1, &KDSAVerifier_1
+		};
+
+	/**
+	Key Agreement implementation characteristic table
+	*/
+	static const TKeyAgreementCharacteristics* const KKeyAgreementCharacteristics[]=
+		{
+		&KDH_1
+		};
+
+	/**
+	Key pair generator implementation characteristic table
+	*/
+	static const TAsymmetricKeypairGeneratorCharacteristics* const KKeyPairGeneratorCharacteristics[]=
+		{
+		&KDHKeyPairGenerator_1, &KRSAKeyPairGenerator_1, &KDSAKeyPairGenerator_1
+		};
+	}
+
+#endif //__CRYPTOAPI_SOFTWAREPLUGINCONFIG_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/pluginentry.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,448 @@
+/*
+* Copyright (c) 2006-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: 
+* plugin entry implementation
+* plugin entry implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "pluginentry.h"
+#include "keypair.h"
+#include "pluginconfig.h"
+#include "md2impl.h"
+#include "md5impl.h"
+#include "md4impl.h"
+#include "sha1impl.h"
+#include "hmacimpl.h"
+#include "keys.h"
+#include "3desimpl.h"
+#include "desimpl.h"
+#include "rc2impl.h"
+#include "arc4impl.h"
+#include "randomimpl.h"
+#include "rijndaelimpl.h"
+#include "randomimpl.h"
+#include "rsaimpl.h"
+#include "dhimpl.h"
+#include "dhkeypairgenimpl.h"
+#include "rsakeypairgenimpl.h"
+#include "dsakeypairgenimpl.h"
+#include "dsasignerimpl.h"
+#include "dsaverifyimpl.h"
+#include "rsasignerimpl.h"
+#include "rsaverifyimpl.h"
+#include <cryptospi/cryptospidef.h>
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	#include "macimpl.h"
+#endif
+
+
+using namespace SoftwareCrypto;
+
+EXPORT_C const TCharacteristics** CCryptoPluginEntry::Enumerate(TUid aInterface, TInt& aNumPlugins)
+	{
+	const TCharacteristics** ptr(0);
+	switch (aInterface.iUid)
+		{
+	case KHashInterface:
+		{
+		aNumPlugins=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+		ptr = (const TCharacteristics**) &KHashCharacteristics[0];
+		}
+		break;
+		
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT		
+		
+	case KMacInterface:
+		{
+		aNumPlugins=sizeof(KMacCharacteristics)/sizeof(TMacCharacteristics*);
+		ptr = (const TCharacteristics**) &KMacCharacteristics[0];
+		}
+		break;
+		
+#endif
+		
+	case KRandomInterface:
+		{
+		aNumPlugins=sizeof(KRandomCharacteristics)/sizeof(TRandomCharacteristics*);
+		ptr= (const TCharacteristics**) &KRandomCharacteristics[0];
+		}
+		break;
+
+	case KSymmetricCipherInterface:
+		{
+		aNumPlugins=sizeof(KSymmetricCipherCharacteristics)/sizeof(TSymmetricCipherCharacteristics*);
+		ptr = (const TCharacteristics**) &KSymmetricCipherCharacteristics[0];
+		}
+		break;
+
+	case KAsymmetricCipherInterface:
+		{
+		aNumPlugins=sizeof(KAsymmetricCipherCharacteristics)/sizeof(TAsymmetricCipherCharacteristics*);
+		ptr = (const TCharacteristics**) &KAsymmetricCipherCharacteristics[0];
+		}
+		break;
+
+	case KSignerInterface:
+		{
+		aNumPlugins=sizeof(KSignerCharacteristics)/sizeof(TAsymmetricSignatureCharacteristics*);
+		ptr = (const TCharacteristics**) &KSignerCharacteristics[0];
+		}
+		break;
+
+	case KVerifierInterface:
+		{
+		aNumPlugins=sizeof(KVerifierCharacteristics)/sizeof(TAsymmetricSignatureCharacteristics*);
+		ptr = (const TCharacteristics**) &KVerifierCharacteristics[0];
+		}
+		break;
+
+	case KKeyAgreementInterface:
+		{
+		aNumPlugins=sizeof(KKeyAgreementCharacteristics)/sizeof(TKeyAgreementCharacteristics*);
+		ptr = (const TCharacteristics**) &KKeyAgreementCharacteristics[0];
+		}
+		break;
+
+	case KKeypairGeneratorInterface:
+		{
+		aNumPlugins=sizeof(KKeyPairGeneratorCharacteristics)/sizeof(TAsymmetricKeypairGeneratorCharacteristics*);
+		ptr = (const TCharacteristics**) &KKeyPairGeneratorCharacteristics[0];
+		}
+		break;
+
+	case KKeyGeneratorInterface:
+		break;
+		
+	default:;
+		}
+		
+	return ptr;
+	}
+
+EXPORT_C void CCryptoPluginEntry::GetExtendedCharacteristicsL(TUid aImplementationUid, CExtendedCharacteristics*& aExt)
+	{
+	switch (aImplementationUid.iUid)
+		{
+		
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	case KCryptoPluginMacHashMd2:   
+#endif
+	
+	case KCryptoPluginMd2:
+	   aExt = CMD2Impl::CreateExtendedCharacteristicsL();
+	   break;
+	   
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	case KCryptoPluginMacHashMd5:   
+#endif
+	
+	case KCryptoPluginMd5:
+	   aExt = CMD5Impl::CreateExtendedCharacteristicsL();
+	   break;
+	   
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	case KCryptoPluginMacHashSha1:   
+#endif
+	
+	case KCryptoPluginSha1:
+	   aExt = CSHA1Impl::CreateExtendedCharacteristicsL();
+	   break;
+	   
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	case KCryptoPluginMacHashMd4:   
+#endif
+	
+	case KCryptoPluginMd4:
+	   aExt = CMD4Impl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginRandom:
+	   aExt = CRandomImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginDes:
+	   aExt = CDesImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPlugin3Des:
+	   aExt = C3DesImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginRc2:
+	   aExt = CRc2Impl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginArc4:
+	   aExt = CArc4Impl::CreateExtendedCharacteristicsL();
+	   break;
+	   
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	case KCryptoPluginMacAesXcbcMac96:   
+	case KCryptoPluginMacAesXcbcPrf128:
+#endif	
+	
+	case KCryptoPluginAes:
+	   aExt = CRijndaelImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginRsaCipher:
+	   aExt = CRSAImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginRsaSigner:
+	   aExt = CRSASignerImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginDsaSigner:
+	   aExt = CDSASignerImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginRsaVerifier:
+	   aExt = CRSAVerifierImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginDsaVerifier:
+	   aExt = CDSAVerifierImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginDhKeyAgreement:
+	   aExt = CDHImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginDhKeyPairGen:
+	   aExt = CDHKeyPairGenImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginRsaKeyPairGen:
+	   aExt = CRSAKeyPairGenImpl::CreateExtendedCharacteristicsL();
+	   break;
+	case KCryptoPluginDsaKeyPairGen:
+	   aExt = CDSAKeyPairGenImpl::CreateExtendedCharacteristicsL();
+	   break;
+	default:
+		User::Leave(KErrNotSupported);
+		}
+	}
+	
+EXPORT_C void CCryptoPluginEntry::CreateAsymmetricCipherL(MAsymmetricCipher*& aPlugin,
+														TUid aImplementationId,
+														const CKey& aKey,
+														TUid aCryptoMode,
+														TUid aPaddingMode,
+														const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	switch (aImplementationId.iUid)
+		{
+	case KCryptoPluginRsaCipher:
+		{
+		aPlugin = CRSAImpl::NewL(aKey, aCryptoMode, aPaddingMode);
+		}
+		break;
+		
+	default:
+		User::Leave(KErrNotFound);
+		}
+	}
+	
+EXPORT_C void CCryptoPluginEntry::CreateAsymmetricSignerL(MSigner*& aPlugin,
+														TUid aImplementationId,
+														const CKey& aKey,
+														TUid aPaddingMode,
+														const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	switch (aImplementationId.iUid)
+		{
+	case KCryptoPluginRsaSigner:
+		{
+		aPlugin = CRSASignerImpl::NewL(aKey, aPaddingMode);
+		}	
+		break;
+
+	case KCryptoPluginDsaSigner:
+		{
+		aPlugin = CDSASignerImpl::NewL(aKey);
+		}	
+		break;
+
+	default:
+		User::Leave(KErrNotFound);
+		}
+	}
+	
+EXPORT_C void CCryptoPluginEntry::CreateAsymmetricVerifierL(MVerifier*& aPlugin,
+															TUid aImplementationId,
+															const CKey& aKey,
+															TUid aPaddingMode,
+															const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	switch (aImplementationId.iUid)
+		{
+	case KCryptoPluginRsaVerifier:
+		aPlugin = CRSAVerifierImpl::NewL(aKey, aPaddingMode);
+		break;
+	
+	case KCryptoPluginDsaVerifier:
+		{
+		aPlugin = CDSAVerifierImpl::NewL(aKey);
+		}	
+		break;
+		
+	default:
+		User::Leave(KErrNotFound);
+		}
+	}
+
+EXPORT_C void CCryptoPluginEntry::CreateHashL(MHash*& aPlugin,
+											TUid aImplementationId,
+											TUid aOperationMode,
+											const CKey* aKey,
+											const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	aPlugin=CSoftwareHash::NewL(aImplementationId, aOperationMode, aKey);
+	}
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+
+EXPORT_C void CCryptoPluginEntry::CreateHashL(MHash*& aPlugin,
+											TUid aImplementationId,
+											const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	aPlugin=CSoftwareHash::NewL(aImplementationId);
+	}
+
+EXPORT_C void CCryptoPluginEntry::CreateMacL(MMac*& aPlugin,
+											const TUid aImplementationId,
+											const CKey& aKey,
+											const CCryptoParams* aAlgorithmParams)
+	{
+	aPlugin=CMacImpl::NewL(aKey, aImplementationId, aAlgorithmParams);
+	}
+
+#endif
+
+EXPORT_C void CCryptoPluginEntry::CreateKeyAgreementL(MKeyAgreement*& aPlugin,
+														TUid aImplementationId,
+														const CKey& aPrivateKey,
+														const CCryptoParams* aAlgorithmParams)
+	{
+	// create requested key agreement implementation in this plugin
+	switch (aImplementationId.iUid)
+		{
+	case KCryptoPluginDhKeyAgreement:
+		{
+		aPlugin = CDHImpl::NewL(aPrivateKey, aAlgorithmParams);
+		}
+		break;
+
+	default:
+		User::Leave(KErrNotFound);
+		}
+	}
+
+EXPORT_C void CCryptoPluginEntry::CreateKeyPairGeneratorL(MKeyPairGenerator*& aPlugin,
+														TUid aImplementationId,
+														const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	// create requested key pair generator implementation in this plugin
+	switch (aImplementationId.iUid)
+		{
+	case KCryptoPluginDhKeyPairGen:
+		{
+		aPlugin = CDHKeyPairGenImpl::NewL();
+		}
+		break;
+		
+	case KCryptoPluginRsaKeyPairGen:
+		{
+		aPlugin = CRSAKeyPairGenImpl::NewL();
+		}
+		break;
+		
+	case KCryptoPluginDsaKeyPairGen:
+		{
+		aPlugin = CDSAKeyPairGenImpl::NewL();
+		}
+		break;
+		
+	default:
+		User::Leave(KErrNotFound);
+		}
+	}
+	
+EXPORT_C void CCryptoPluginEntry::CreateRandomL(MRandom*& aPlugin,
+												TUid /*aImplementationId*/,
+												const CCryptoParams* /*aAlgorithmParams*/)
+	{
+	aPlugin=CRandomImpl::NewL();
+	}	
+
+EXPORT_C void CCryptoPluginEntry::CreateSymmetricCipherL(MSymmetricCipher*& aPlugin,
+														TUid aImplementationId,
+														const CKey& aKey,
+														TUid aCryptoMode,
+														TUid aOperationMode,
+														TUid aPadding,
+														const CCryptoParams* aAlgorithmParams)
+	{
+	switch (aImplementationId.iUid)
+		{
+	case KCryptoPluginAes:
+		{
+		aPlugin=CRijndaelImpl::NewL(
+			aKey, aCryptoMode, aOperationMode, aPadding);
+		}	
+		break;
+	case KCryptoPluginDes:
+		{
+		aPlugin=CDesImpl::NewL(
+			aKey, aCryptoMode, aOperationMode, aPadding);
+		}	
+		break;
+	case KCryptoPlugin3Des:
+		{
+		aPlugin=C3DesImpl::NewL(
+			aKey, aCryptoMode, aOperationMode, aPadding);
+		}	
+		break;
+	case KCryptoPluginRc2:
+		{
+		TInt effectiveKeyLenBits(CRc2Impl::KDefaultEffectiveKeyLenBits);
+			
+		if (aAlgorithmParams && aAlgorithmParams->IsPresent(KRC2EffectiveKeyLenBits))
+			{
+			effectiveKeyLenBits = aAlgorithmParams->GetTIntL(KRC2EffectiveKeyLenBits);
+			if (effectiveKeyLenBits < 0)
+				{
+				User::Leave(KErrArgument);
+				}
+			}
+		aPlugin=CRc2Impl::NewL(
+			aKey, aCryptoMode, aOperationMode, aPadding, effectiveKeyLenBits);
+		}	
+		break;				
+	
+	case KCryptoPluginArc4:
+		{
+		TInt discardBytes(CArc4Impl::KDefaultDiscardBytes);
+		if (aAlgorithmParams && aAlgorithmParams->IsPresent(KARC4DiscardBytes))
+			{
+			discardBytes = aAlgorithmParams->GetTIntL(KARC4DiscardBytes);
+			if (discardBytes < 0)
+				{
+				User::Leave(KErrArgument);
+				}
+			}		
+		aPlugin=CArc4Impl::NewL(aKey, discardBytes);
+		}
+		break;
+		
+	default:
+		User::Leave(KErrNotFound);
+		}
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/pluginentry.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,414 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __PLUGINENTRY_H__
+#define __PLUGINENTRY_H__
+
+#include <cryptospi/cryptoparams.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+#include "keys.h"
+#include <cryptospi/hashplugin.h>
+#include <cryptospi/randomplugin.h>
+#include "symmetriccipherplugin.h"
+#include "asymmetriccipherplugin.h"
+#include "signerplugin.h"
+#include "verifierplugin.h"
+#include "keypairgeneratorplugin.h"
+#include "keyagreementplugin.h"
+
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+	#include <cryptospi/macplugin.h>
+#endif
+
+using namespace CryptoSpi;
+
+class CCryptoPluginEntry
+	{
+public:
+	
+	/**
+	 * Enumerates the set of plug-ins supported by the module for a given interface
+	 * e.g. all of the hash plug-ins.
+	 *  
+	 * @param aInterface The UID of the plug-in interface type. If the UID is not recognised
+	 * then the NULL pointer must be returned.
+	 * @param aNumPlugins The number of plug-in characteristics objects in the result.
+	 * @param A pointer to an array of characteristics objects. The SPI casts this to
+	 *  the expected sub-class of TCharacteristics for the specified interface UID.
+	 */
+	IMPORT_C static const TCharacteristics** Enumerate(TUid aInterface, TInt& aNumPlugins);
+
+	/**
+	 * Retrieves the extended characteristics about a given implementation of an
+	 * algorithm within the current plug-in DLL.
+	 *	
+	 * @param aImplementationUid The UID of the implementation requested
+	 * @return A pointer to the extended characteristics, allocated on the heap,
+	 * which should be deleted once the caller has finished with it.
+	 */
+	IMPORT_C static void GetExtendedCharacteristicsL(TUid aImplementationUid, CExtendedCharacteristics*&);
+
+	/**
+	 * Creates a new instance of an asymmetric cipher
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new asymmetric cipher object.
+	 * @param aImplementationId The UID of the asymmetric cipher plug-in to instantiate.
+	 * @param aKey The encryption/decryption key.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+	IMPORT_C static void CreateAsymmetricCipherL(MAsymmetricCipher*& aPlugin,
+												 TUid aImplementationId,
+												 const CKey& aKey,
+												 TUid aCryptoMode,
+												 TUid aPaddingMode,
+												 const CCryptoParams* aAlgorithmParams);
+
+	/**
+	 * Creates a new instance of an asymmetric signer.
+     *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new asymmetric signer object.
+	 * @param aImplementationId The UID of the signer plug-in to instantiate.
+	 * @param aKey The signing key.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+	IMPORT_C static void CreateAsymmetricSignerL(MSigner*& aPlugin,
+												 TUid aImplementationId,
+												 const CKey& aKey,
+												 TUid aPaddingMode,
+												 const CCryptoParams* aAlgorithmParams);
+
+	/**
+	 * Creates a new instance of an asymmetric verifier.
+	 *	
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new asymmetric verifier object.
+	 * @param aImplementationId The UID of the verifier plug-in to instantiate.
+	 * @param aKey The key to verify the signature with.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+	IMPORT_C static void CreateAsymmetricVerifierL(MVerifier*& aPlugin,
+												   TUid aImplementationId,
+												   const CKey& aKey,
+												   TUid aPaddingMode,
+												   const CCryptoParams* aAlgorithmParams);
+										
+	/**
+	 * @deprecated
+	 * 
+	 * Creates a new instance of a Hash object.
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new hash object.
+	 * @param aImplementationId The UID of the hash plug-in to instantiate.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+	IMPORT_C static void CreateHashL(MHash*& aPlugin,
+									 TUid aImplementationId,
+									 TUid aOperationMode,
+									 const CKey* aKey,
+									 const CCryptoParams* aAlgorithmParams);
+	
+	/**
+	 * Creates a new instance of a key agreement system.
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new asymmetric key pair generator object.
+	 * @param aImplementationId The UID of the key agreement plug-in to instantiate.
+	 * @param aPrivateKey The private key to combine with the other parties public key
+	 * during the agreement.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 *  @return KErrNone if successful; otherwise, a system wide error code.		   
+	 */
+	IMPORT_C static void CreateKeyAgreementL(MKeyAgreement*& aPlugin,
+											 TUid aImplementationId,
+											 const CKey& aPrivateKey,
+											 const CCryptoParams* aAlgorithmParams);
+
+	/**
+	 * Creates a new instance of an asymmetric key pair generator.
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new asymmetric key pair generator object.
+	 * @param aImplementationId The UID of the verifier plug-in to instantiate.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+	IMPORT_C static void CreateKeyPairGeneratorL(MKeyPairGenerator*& aPlugin,
+												 TUid aImplementationId,
+												 const CCryptoParams* aAlgorithmParams);
+
+	/**
+	 * Creates a new instance of a Random object.
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to the new random object.
+	 * @param aImplementationId The UID of the random plug-in to instantiate.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 *  @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+	IMPORT_C static void CreateRandomL(MRandom*& aPlugin,
+									   TUid aImplementationId,
+									   const CCryptoParams* aAlgorithmParams);
+	
+	/**
+	 * Creates a new instance of a symmetric cipher
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new asymmetric object.
+	 * @param aImplementationId The UID of the symmetric cipher plug-in to instantiate.
+	 * @param aKey The encryption/decryption key.
+	 * @param aCryptoMode Encrypt or Decrypt.
+	 * @param aOperationMode the block cipher mode to use ECB, CBC, CTR etc
+	 * @param aPadding the padding scheme to use.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+    IMPORT_C static void CreateSymmetricCipherL(MSymmetricCipher*& aPlugin,
+												TUid aImplementationId,
+												const CKey& aKey,
+												TUid aCryptoMode,
+												TUid aOperationMode,
+												TUid aPadding,
+												const CCryptoParams* aAlgorithmParams);
+
+   /**
+	* Creates a new instance of an asymmetric cipher
+	*
+	* @param aPlugin A reference to a pointer that should be set to point to 
+	* the new asymmetric cipher object.
+	* @param aImplementationId The UID of the asymmetric cipher plug-in to instantiate.
+	* @param aKey The encryption/decryption key.
+	* @param aAlgorithmParams The parameters that are specific to a particular 
+	* algorithm. This is for extendibility and will normally be null.
+	* @return KErrNone if successful; otherwise, a system wide error code.
+	
+   IMPORT_C static void CreateAsyncAsymmetricCipherL(MAsyncAsymmetricCipher*& aPlugin,
+		   											 TUid aImplementationId,
+		   											 const CKey& aKey,
+		   											 const CCryptoParams* aAlgorithmParams);
+   */
+    
+   /**
+	* Creates a new instance of an asymmetric signer.
+	*
+	* @param aPlugin A reference to a pointer that should be set to point to 
+	* the new asymmetric signer object.
+	* @param aImplementationId The UID of the signer plug-in to instantiate.
+	* @param aKey The signing key.
+	* @param aAlgorithmParams The parameters that are specific to a particular 
+	* algorithm. This is for extendibility and will normally be null.
+	* @return KErrNone if successful; otherwise, a system wide error code.
+	
+   IMPORT_C static void CreateAsyncAsymmetricSignerL(MAsyncSigner*& aPlugin,
+		   											 TUid aImplementationId,
+		   											 const CKey& aKey,
+		   											 const CCryptoParams* aAlgorithmParams);
+	*/
+    
+   /**
+    * Creates a new instance of an asymmetric verifier.
+	*
+	* @param aPlugin A reference to a pointer that should be set to point to 
+	* the new asymmetric verifier object.
+	* @param aImplementationId The UID of the verifier plug-in to instantiate.
+	* @param aKey The key to verify the signature with.
+	* @param aAlgorithmParams The parameters that are specific to a particular 
+	* algorithm. This is for extendibility and will normally be null.
+	* @return KErrNone if successful; otherwise, a system wide error code.
+	
+   IMPORT_C static void CreateAsyncAsymmetricVerifierL(MAsyncVerifier*& aPlugin,
+		   											   TUid aImplementationId,
+		   											   const CKey& aKey,
+		   											   const CCryptoParams* aAlgorithmParams);
+	*/
+   
+   /**
+    * @deprecated
+    * 
+    * Creates a new instance of a Hash object.
+    *	
+    * @param aPlugin A reference to a pointer that should be set to point to 
+    * the new hash object.
+    * @param aImplementationId The UID of the hash plug-in to instantiate.
+    * @param aAlgorithmParams The parameters that are specific to a particular 
+    * algorithm. This is for extendibility and will normally be null.
+    * @return KErrNone if successful; otherwise, a system wide error code.
+    
+   IMPORT_C static void CreateAsyncHashL(MAsyncHash*& aPlugin,
+		   								 TUid aImplementationId,
+		   								 TUid aOperationMode,
+									 	 const CKey* aKey,
+		   								 const CCryptoParams* aAlgorithmParams);
+  	*/
+    
+   /**
+    * Creates a new instance of a key agreement system.
+    *
+    * @param aPlugin A reference to a pointer that should be set to point to 
+    * the new asymmetric key pair generator object.
+    * @param aImplementationId The UID of the key agreement plug-in to instantiate.
+    * @param aKey The private key to combine with the other parties public key
+    * during the agreement.
+    * @param aAlgorithmParams The parameters that are specific to a particular 
+    * algorithm. This is for extendibility and will normally be null.
+    * @return KErrNone if successful; otherwise, a system wide error code.		   
+   	
+   IMPORT_C static void CreateAsyncKeyAgreementL(MAsyncKeyAgreement*& aPlugin,
+		   										 TUid aImplementationId,
+		   										 const CKey& aPrivateKey,
+		   										 const CCryptoParams* aAlgorithmParams);
+  	*/
+    
+   /**
+    * Creates a new instance of an asymmetric key pair generator.
+    *
+    * @param aPlugin A reference to a pointer that should be set to point to 
+    * the new asymmetric key pair generator object.
+    * @param aImplementationId The UID of the verifier plug-in to instantiate.
+    * @param aAlgorithmParams The parameters that are specific to a particular 
+    * algorithm. This is for extendibility and will normally be null.
+    * @return KErrNone if successful; otherwise, a system wide error code.
+    	
+   IMPORT_C static void CreateAsyncKeyPairGeneratorL(MAsyncKeyPairGenerator*& aPlugin,
+		   											 TUid aImplementationId,
+		   											 const CCryptoParams* aAlgorithmParams);
+   */
+    
+   /**
+	* Creates a new instance of a Random object.
+	*
+	* @param aPlugin A reference to a pointer that should be set to point to the new random object.
+	* @param aImplementationId The UID of the random plug-in to instantiate.
+	* @param aAlgorithmParams The parameters that are specific to a particular 
+	* algorithm. This is for extendibility and will normally be null.
+	* @return KErrNone if successful; otherwise, a system wide error code.
+	
+   IMPORT_C static void CreateAsyncRandomL(MAsyncRandom*& aPlugin,
+		   								   TUid aImplementationId,
+		   								   const CCryptoParams* aAlgorithmParams);
+	*/
+
+   /**
+	* Creates a new instance of a symmetric cipher
+	*	
+	* @param aPlugin A reference to a pointer that should be set to point to 
+	* the new asymmetric object.
+	* @param aImplementationId The UID of the symmetric cipher plug-in to instantiate.
+	* @param aKey The encryption/decryption key.
+	* @param aAlgorithmParams The parameters that are specific to a particular 
+	* algorithm. This is for extendibility and will normally be null.
+	* @return KErrNone if successful; otherwise, a system wide error code.
+	
+   IMPORT_C static void CreateAsyncSymmetricCipherL(MAsyncSymmetricCipher*& aPlugin,
+		   											TUid aImplementationId,
+		   											const CKey& aKey,
+		   											TUid aMode,
+		   											TUid aPadding,
+		   											const CCryptoParams* aAlgorithmParams);
+    */
+
+#ifdef SYMBIAN_SDP_IPSEC_VOIP_SUPPORT	
+    
+    /**
+	 * Creates a new instance of a Hash object.
+	 *
+	 * @param aPlugin A reference to a pointer that should be set to point to 
+	 * the new hash object.
+	 * @param aImplementationId The UID of the hash plug-in to instantiate.
+	 * @param aAlgorithmParams The parameters that are specific to a particular 
+	 * algorithm. This is for extendibility and will normally be null.
+	 * @return KErrNone if successful; otherwise, a system wide error code.
+	 */
+    IMPORT_C static void CreateHashL(MHash*& aPlugin,
+									 TUid aImplementationId,
+									 const CCryptoParams* aAlgorithmParams);
+   /**
+    * Creates a new instance of a Hash object.
+    *	
+    * @param aPlugin A reference to a pointer that should be set to point to 
+	* the new hash object.
+    * @param aImplementationId The UID of the hash plug-in to instantiate.
+    * @param aAlgorithmParams The parameters that are specific to a particular 
+    * algorithm. This is for extendibility and will normally be null.
+    * @return KErrNone if successful; otherwise, a system wide error code.
+	    
+   IMPORT_C static void CreateAsyncHashL(MAsyncHash*& aPlugin,
+		   								 TUid aImplementationId,
+		   								 const CCryptoParams* aAlgorithmParams);
+  	*/
+	
+   /**
+    * Create a CMac instance (if implementation is software based)
+	*
+	* @param aMac 				The pointer to CMac
+	* @param aImplementationId 	The specific hash or cipher plug-in to instantiate..
+	* @param aKey             	The key for calculating message authentication code value. 
+	*                         	Based on the algorithm used we will define the properties of the key.
+	* @param aAlgorithmParams 	The parameters that are specific to a particular 
+	*                         	algorithm. This is for extendibility and will normally be null. 	
+	* @return                 	KErrNone if successful; otherwise, a system wide error code.
+	*/
+   IMPORT_C static void CreateMacL(MMac*& aPlugin,
+								   const TUid aImplementationId,
+								   const CKey& aKey,
+								   const CCryptoParams* aAlgorithmParams);
+
+   /**
+	* Create a CAsyncMac instance
+	*
+	* @param aMac 				The pointer to CAsyncMac
+	* @param aImplementationId 	The specific hash or cipher plug-in to instantiate..
+	* @param aKey             	The key for calculating message authentication code value. 
+	*                         	Based on the algorithm used we will define the properties of the key.
+	* @param aAlgorithmParams 	The parameters that are specific to a particular 
+	*                         	algorithm. This is for extendibility and will normally be null. 	
+	* @return                 	KErrNone if successful; otherwise, a system wide error code.
+	
+   IMPORT_C static void CreateAsyncMacL(MAsyncMac*& aPlugin,
+								   		const TUid aImplementationId,
+								   		const CKey& aKey,
+								   		const CCryptoParams* aAlgorithmParams);
+	*/
+   
+#endif
+   
+	};
+
+
+#endif // __PLUGINENTRY_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/randomimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,212 @@
+/*
+* Copyright (c) 2005-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: 
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <e32std.h>
+#include <e32debug.h>
+
+#include "randomimpl.h"
+#include "pluginentry.h"
+#include "pluginconfig.h"
+
+#include "randsvr.h"
+#include "randcliserv.h"
+#include "randsvrimpl.h"
+
+_LIT(KRandomServerImg,"z:\\sys\\bin\\randsvr.exe");		// DLL/EXE name
+_LIT(KRandomServerConnect, "Randsvr connect");
+_LIT(KRandomServerGet, "Randsvr get");
+
+const TUid KServerUid3={0x100066dc};
+
+
+using namespace SoftwareCrypto;
+
+
+CRandomImpl* CRandomImpl::NewL(void)
+	{
+	CRandomImpl* self = new(ELeave)CRandomImpl();
+	return self;
+	}
+
+CRandomImpl* CRandomImpl::NewLC(void)
+	{
+	CRandomImpl* self = NewL();
+	CleanupStack::PushL(self);
+	return self;
+	}
+
+void CRandomImpl::GenerateRandomBytesL(TDes8& aDest)
+	{
+	TRandomImpl::Random(aDest);
+	}
+
+CRandomImpl::CRandomImpl(void)
+	{
+	}
+
+void TRandomImpl::Random(TDes8& aDestination)
+	{
+	RRandomSessionImpl rs;
+	TRAPD(ret,rs.ConnectL());
+	if (ret != KErrNone)
+		{
+		User::Panic(KRandomServerConnect, ret);
+		}
+	TInt err=rs.GetRandom(aDestination);
+	if (err != KErrNone)
+		{
+		User::Panic(KRandomServerGet, err);
+		}
+	rs.Close();
+	}
+
+void CRandomImpl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	TInt randomNum = sizeof(KRandomCharacteristics)/sizeof(TRandomCharacteristics*);
+	for (TInt i = 0; i < randomNum; i++)
+		{
+		if (KRandomCharacteristics[i]->cmn.iImplementationUID == ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KRandomCharacteristics[i];
+			break;
+			}
+		}
+	}
+
+CExtendedCharacteristics* CRandomImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CRandomImpl::GetExtendedCharacteristicsL()
+	{
+	return CRandomImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRandomImpl::ImplementationUid() const
+	{
+	return KCryptoPluginRandomUid;
+	}
+
+CRandomImpl::~CRandomImpl()
+	{
+	}
+
+void CRandomImpl::Close()
+	{
+	delete this;
+	}
+
+// All crypto plugins must implement this, to reset
+// hardware if required. Do nothing in this version
+void CRandomImpl::Reset()
+	{
+	}
+
+RRandomSessionImpl::RRandomSessionImpl(void)
+	{
+	}
+
+static TInt StartServer()
+// Borrowed from AndrewT's server startup code.
+// Start the server process/thread which lives in an EPOCEXE object
+//
+	{
+	
+	const TUidType serverUid(KNullUid,KNullUid,KServerUid3);
+
+	//
+	// EPOC and EKA2 is easy, we just create a new server process. Simultaneous
+	// launching of two such processes should be detected when the second one
+	// attempts to create the server object, failing with KErrAlreadyExists.
+	//
+	RProcess server;
+	TInt r=server.Create(KRandomServerImg, KNullDesC, serverUid);
+
+	if (r!=KErrNone)
+		return r;
+	TRequestStatus stat;
+	server.Rendezvous(stat);
+	if (stat!=KRequestPending)
+		server.Kill(0);		// abort startup
+	else
+		server.Resume();	// logon OK - start the server
+	User::WaitForRequest(stat);		// wait for start or death
+	// we can't use the 'exit reason' if the server panicked as this
+	// is the panic 'reason' and may be '0' which cannot be distinguished
+	// from KErrNone
+	r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();
+	server.Close();
+	return r;
+
+	}
+
+void RRandomSessionImpl::ConnectL(void)
+	{
+	TInt retry=2;
+	for (;;)
+		{
+		// Magic number 1 below is the number of asynchronous message slots
+		TInt r = CreateSession(KRandomServerName,TVersion(0,0,0), 1);
+		if (r == KErrNone) return;
+		// We used to leave with KErrNone, but this is inefficient and
+		// provokes an emulator problem in User::Leave which causes tpbe to crash
+		// if (r == KErrNone) User::Leave(r);   // Connected okay
+		if (r != KErrNotFound && r != KErrServerTerminated)
+			   User::Leave(r);   // Something else happened
+		if (--retry == 0)
+			User::Leave(r);      // Give up after a while
+		r = StartServer();       // Try starting again
+		if (r != KErrNone && r != KErrAlreadyExists)
+			User::Leave(r);
+		}
+	}
+
+TInt RRandomSessionImpl::GetRandom(TDes8& aDestination)
+	{
+	TInt desclength = aDestination.Length();
+	for ( TInt i = 0; i < desclength; i += KRandomBlockSize)
+		{
+		TInt getlen = Min(KRandomBlockSize, desclength - i);
+		TPtr8 buffer(&aDestination[i], KRandomBlockSize, KRandomBlockSize);
+		TInt err = SendReceive(CRandomSession::KRandomRequest, TIpcArgs(&buffer, getlen));
+		if (err != KErrNone)
+			{
+			return err;
+			}
+		}
+	return KErrNone;
+	}
+
+// Methods which are not supported can be excluded from the coverage.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CRandomImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/randomimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,114 @@
+/*
+* Copyright (c) 2006-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: 
+* Software random implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_RANDOMIMPL_H__
+#define __CRYPTOAPI_RANDOMIMPL_H__
+
+#include <cryptospi/cryptoplugin.h>
+#include <cryptospi/randomplugin.h>
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CRandomImpl): public CBase, public MRandom
+		{
+	public:
+		// NewL & NewLC
+		static CRandomImpl* NewL();
+		static CRandomImpl* NewLC();
+		
+		// From MPlugin
+		void Reset();
+		void Close();
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		TUid ImplementationUid() const;
+		
+		// From MRandom
+		void GenerateRandomBytesL(TDes8& aDest);
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+	private:
+		//Constructor
+		CRandomImpl();
+		
+		//Destructor
+		~CRandomImpl();
+		
+	private:
+		TUid iImplementationUid;
+		};
+
+	class TRandomImpl 
+	/**
+	 * The user interface to the system cryptographically 
+	 * secure random number generator.
+	 *
+	 * @internalComponent
+	 * @released
+	 */
+		{
+	public:
+		
+		/**
+		 * Fills the provided buffer with secure random data up to its
+		 * current length, discarding any current content.
+		 *
+		 * @param aDestination The buffer in which to write the random data.
+		 */
+		static void Random(TDes8& aDestination);
+		};
+	
+	class RRandomSessionImpl : public RSessionBase
+	/**
+	 * The client interface to the system random number generator. End
+	 * users should use TRandom instead of this interface.
+	 *
+	 * @internalAll
+	 * @released
+	 */
+		{
+	public:
+		RRandomSessionImpl();
+		
+		/**
+		 * Fills the provided buffer with secure random data up to its
+		 * current length, discarding any current content.
+		 *
+		 * @param aDestination The buffer in to which to write the random data 
+		 */
+		TInt GetRandom(TDes8& aDestination);
+		
+		/**
+		 * Opens a new session with the random number server.
+		 */
+		void ConnectL();
+		};
+	}
+
+#endif // __CRYPTOAPI_RANDOMIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rc2impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,213 @@
+/*
+* Copyright (c) 2006-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 "rc2impl.h"
+#include "keys.h"
+
+#include "rc2table.h"
+#include "common/inlines.h"
+#include "pluginconfig.h"
+#include "symmetriccipherimpl.h"
+#include <cryptostrength.h>
+
+using namespace SoftwareCrypto;
+
+CRc2Impl::CRc2Impl(
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPadding) :
+	CSymmetricBlockCipherImpl(KRc2BlockBytes, aCryptoMode, aOperationMode, aPadding)
+	{
+	}
+
+CRc2Impl* CRc2Impl::NewL(
+	const CKey& aKey,
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPadding,
+	TInt aEffectiveKeyLenBits)	
+	{
+	CRc2Impl* self = CRc2Impl::NewLC(aKey, aCryptoMode, aOperationMode, aPadding, aEffectiveKeyLenBits);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CRc2Impl* CRc2Impl::NewLC(
+	const CKey& aKey,
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPadding,
+	TInt aEffectiveKeyLenBits)
+	{
+	CRc2Impl* self = new(ELeave) CRc2Impl(aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey, aEffectiveKeyLenBits);
+	
+	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyContent.Size()) - keyContent.Size());
+	return self;
+	}
+		
+CRc2Impl::~CRc2Impl()
+	{
+	Mem::FillZ(&iK, sizeof(iK));
+	}
+	
+void CRc2Impl::ConstructL(const CKey& aKey, TInt aEffectiveKeyLenBits)	
+	{
+	iEffectiveKeyLenBits = aEffectiveKeyLenBits;	
+	CSymmetricBlockCipherImpl::ConstructL(aKey);
+	SetKeySchedule();
+	}
+	
+CExtendedCharacteristics* CRc2Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CRc2Impl::GetExtendedCharacteristicsL()
+	{
+	return CRc2Impl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRc2Impl::ImplementationUid() const
+	{
+	return KCryptoPluginRc2Uid;
+	}
+
+TBool CRc2Impl::IsValidKeyLength(TInt aKeyBytes) const
+	{
+	return ((aKeyBytes > 0 && aKeyBytes <= KRc2MaxKeySizeBytes) ? ETrue : EFalse);
+	}	
+	
+TInt CRc2Impl::GetKeyStrength() const
+	{
+	return Min(iEffectiveKeyLenBits, BytesToBits(iKeyBytes));
+	}
+
+void CRc2Impl::SetKeySchedule()
+	{				
+	TUint keyLen = iKey->Length();
+	
+	TUint8 L[KRc2MaxKeySizeBytes];	
+	Mem::Copy((TUint8*)&L[0], (TUint8*)&(*iKey)[0], keyLen);
+
+	TInt i = keyLen;
+	for (; i < KRc2MaxKeySizeBytes; i++)
+		{
+		L[i] = RC2_TABLE::PITABLE[(L[i-1] + L[i-keyLen]) & 255];
+		}
+
+	TUint T8 = (iEffectiveKeyLenBits+7) / 8;
+	TUint8 TM = (TUint8)(255 >> ((8-(iEffectiveKeyLenBits%8))%8));
+	L[128-T8] = RC2_TABLE::PITABLE[L[128-T8] & TM];
+
+	for (i=127-T8; i>=0; i--)
+		L[i] = RC2_TABLE::PITABLE[L[i+1] ^ L[i+T8]];
+
+	for (i=0; i < KRc2ExpandedKeyLen; i++)
+		iK[i] = (TUint16)(L[2*i] + (L[2*i+1] << 8));
+	}
+
+#pragma warning (disable : 4244)	//	conversion from 'int' to 'unsigned short', possible loss of data
+void CRc2Impl::TransformEncrypt(
+	TUint8* aBuffer,
+	TUint aNumBlocks)
+	{
+	for (TInt blockNum = 0; blockNum < aNumBlocks; ++blockNum)
+		{		
+		ModeEncryptStart(aBuffer);
+		
+		TUint16 R0, R1, R2, R3;
+		GetBlockLittleEndian(aBuffer, R0, R1, R2, R3);
+		
+		TInt i = 0;
+		for (; i < 16; i++)
+			{
+			R0 += (R1 & ~R3) + (R2 & R3) + iK[4*i+0];
+			R0 = rotlFixed(R0, 1);
+
+			R1 += (R2 & ~R0) + (R3 & R0) + iK[4*i+1];
+			R1 = rotlFixed(R1, 2);
+
+			R2 += (R3 & ~R1) + (R0 & R1) + iK[4*i+2];
+			R2 = rotlFixed(R2, 3);
+
+			R3 += (R0 & ~R2) + (R1 & R2) + iK[4*i+3];
+			R3 = rotlFixed(R3, 5);
+
+			if (i == 4 || i == 10)
+				{
+				R0 += iK[R3 & 63];
+				R1 += iK[R0 & 63];
+				R2 += iK[R1 & 63];
+				R3 += iK[R2 & 63];
+				}
+			}
+		PutBlockLittleEndian(aBuffer, R0, R1, R2, R3);	
+		ModeEncryptEnd(aBuffer);
+		aBuffer += KRc2BlockBytes;
+		}
+	}
+#pragma warning (default : 4244)	//	conversion from 'int' to 'unsigned short', possible loss of data
+
+
+#pragma warning (disable : 4244)	//	conversion from 'int' to 'unsigned short', possible loss of data
+void CRc2Impl::TransformDecrypt(
+	TUint8* aBuffer,
+	TUint aNumBlocks)
+	{
+	for (TInt blockNum = 0; blockNum < aNumBlocks; ++blockNum)
+		{		
+		ModeDecryptStart(aBuffer);
+
+		TUint16 R0, R1, R2, R3;
+		GetBlockLittleEndian(aBuffer, R0, R1, R2, R3);
+
+		TInt i = 15;
+		for (; i >= 0; i--)
+			{
+			if (i == 4 || i == 10)
+				{
+				R3 -= iK[R2 & 63];
+				R2 -= iK[R1 & 63];
+				R1 -= iK[R0 & 63];
+				R0 -= iK[R3 & 63];
+				}
+
+			R3 = rotrFixed(R3, 5);
+			R3 -= (R0 & ~R2) + (R1 & R2) + iK[4*i+3];
+
+			R2 = rotrFixed(R2, 3);
+			R2 -= (R3 & ~R1) + (R0 & R1) + iK[4*i+2];
+
+			R1 = rotrFixed(R1, 2);
+			R1 -= (R2 & ~R0) + (R3 & R0) + iK[4*i+1];
+
+			R0 = rotrFixed(R0, 1);
+			R0 -= (R1 & ~R3) + (R2 & R3) + iK[4*i+0];
+			}
+
+		PutBlockLittleEndian(aBuffer, R0, R1, R2, R3);
+		ModeDecryptEnd(aBuffer);
+		aBuffer += KRc2BlockBytes;
+		}
+	}
+#pragma warning (default : 4244)	//	conversion from 'int' to 'unsigned short', possible loss of data
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rc2impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,118 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef	__RC2_H__
+#define	__RC2_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keys.h"
+#include "symmetriccipherimpl.h"
+
+/**
+Plug-in class for RC2 block cipher
+*/
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CRc2Impl) : public CSymmetricBlockCipherImpl
+		{
+	public:
+		/**
+		Creates an instance of an RC2 symmetric cipher plug-in.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@param aEffectiveKeyLenBits The effective key length in bits
+		@return A pointer to a CRc2Impl instance
+		*/
+		static CRc2Impl* NewL(const CKey& aKey, 
+			TUid aCryptoMode, TUid aOperationMode, TUid aPadding, TInt aEffectiveKeyLenBits);
+
+		/**
+		Creates an instance of an RC2 symmetric cipher plug-in.
+		A pointer to the plug-in instance is placed on the cleanup stack.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@param aEffectiveKeyLenBits The effective key length in bits
+		@return A pointer to a CRc2Impl instance
+		*/
+		static CRc2Impl* NewLC(const CKey& aKey, 
+			TUid aCryptoMode, TUid aOperationMode, TUid aPadding, TInt aEffectiveKeyLenBits);
+		
+		// From CSymmetricCipherImpl
+		TBool IsValidKeyLength(TInt aKeyBytes) const;
+		TUid ImplementationUid() const;
+		TInt GetKeyStrength() const;
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+				
+		/// Destructor
+		~CRc2Impl();
+		
+		/** SSL Effective Key Length Compatibility - for compatibility with SSL */
+		static const TUint KDefaultEffectiveKeyLenBits = 1024;
+
+	private:
+		/**
+		Constructor
+		@param aOperationMode The mode of operation e.g. CBC
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPaddingMode The padding mode to use. None, SSL, PKCS#7
+		*/
+		CRc2Impl(TUid aOperationMode, TUid aCryptoMode, TUid aPaddingMode);
+			
+		///	second phase of construction	
+		void ConstructL(const CKey& aKey, TInt aEffectiveKeyLenBits);
+					
+		/**
+		Expands the key (iKey) to iEffectiveKeyLenBits and stores the result in iK
+		*/
+		void SetKeySchedule();
+		
+		// From CSymmetricBlockCipherImpl
+		void TransformEncrypt(TUint8* aBuffer, TUint aNumBlocks);
+		void TransformDecrypt(TUint8* aBuffer, TUint aNumBlocks);		
+
+	private:		
+		static const TUint8 KRc2BlockBytes = 8;
+		static const TInt KRc2MaxKeySizeBytes = 128;	
+		static const TInt KRc2ExpandedKeyLen = 64;
+		/**
+	 	 The expanded key buffer.
+		 Each iK[i] is a 16-bit word.
+	 	 */
+		TUint16 iK[KRc2ExpandedKeyLen];	//	128 bytes		
+		
+		/** The effective key length in bits */
+		TInt iEffectiveKeyLenBits;	
+		};
+	}
+
+#endif //__RC2_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rc2table.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2002-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RC2TABLES_H__
+#define __RC2TABLES_H__
+
+#include <e32std.h>
+
+namespace RC2_TABLE
+{
+	const TUint8 PITABLE[256] = 
+	{
+		217,120,249,196, 25,221,181,237, 40,233,253,121, 74,160,216,157,
+		198,126, 55,131, 43,118, 83,142, 98, 76,100,136, 68,139,251,162,
+		 23,154, 89,245,135,179, 79, 19, 97, 69,109,141,  9,129,125, 50,
+		189,143, 64,235,134,183,123, 11,240,149, 33, 34, 92,107, 78,130,
+		 84,214,101,147,206, 96,178, 28,115, 86,192, 20,167,140,241,220,
+		 18,117,202, 31, 59,190,228,209, 66, 61,212, 48,163, 60,182, 38,
+		111,191, 14,218, 70,105,  7, 87, 39,242, 29,155,188,148, 67,  3,
+		248, 17,199,246,144,239, 62,231,  6,195,213, 47,200,102, 30,215,
+		  8,232,234,222,128, 82,238,247,132,170,114,172, 53, 77,106, 42,
+		150, 26,210,113, 90, 21, 73,116, 75,159,208, 94,  4, 24,164,236,
+		194,224, 65,110, 15, 81,203,204, 36,145,175, 80,161,244,112, 57,
+		153,124, 58,133, 35,184,180,122,252,  2, 54, 91, 37, 85,151, 49,
+		 45, 93,250,152,227,138,146,174,  5,223, 41, 16,103,108,186,201,
+		211,  0,230,207,225,158,168, 44, 99, 22,  1, 63, 88,226,137,169,
+		 13, 56, 52, 27,171, 51,255,176,187, 72, 12, 95,185,177,205, 46,
+		197,243,219, 71,229,165,156,119, 10,166, 32,104,254,127,193,173
+	};
+}
+	//	namespace RC2_TABLE
+#endif	//	__RC2TABLES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rijndaelimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,484 @@
+/*
+* Copyright (c) 2006-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 "rijndaelimpl.h"
+#include "keys.h"
+
+#include "rijndaeltables.h"
+#include "common/inlines.h"
+#include "pluginconfig.h"
+#include "symmetriccipherimpl.h"
+#include <cryptostrength.h>
+
+using namespace SoftwareCrypto;
+
+const TUint KAESKeyBytes128 = 16;
+const TUint KAESKeyBytes192 = 24;
+const TUint KAESKeyBytes256 = 32;
+const TUint KAESBlockBytes = 16;
+
+/* CRijndaelmpl*/
+CRijndaelImpl::CRijndaelImpl(
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPadding) :
+	CSymmetricBlockCipherImpl(KAESBlockBytes, aCryptoMode, aOperationMode, aPadding)
+	{
+	}
+
+CRijndaelImpl* CRijndaelImpl::NewL(const CKey& aKey, TUid aCryptoMode,	TUid aOperationMode, TUid aPadding)
+	{
+	CRijndaelImpl* self = CRijndaelImpl::NewLC(aKey, aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CRijndaelImpl* CRijndaelImpl::NewLC(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)
+	{
+	CRijndaelImpl* self = new(ELeave) CRijndaelImpl(aCryptoMode, aOperationMode, aPadding);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	
+	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyContent.Size()) - keyContent.Size());
+	return self;
+	}
+		
+CRijndaelImpl::~CRijndaelImpl()
+	{
+	// make sure key information isn't visible to other processes if the
+	// page is reused.
+	Mem::FillZ(&iK, sizeof(iK));
+	}
+	
+void CRijndaelImpl::ConstructL(const CKey& aKey)
+	{
+	CSymmetricBlockCipherImpl::ConstructL(aKey);			
+	SetKeySchedule();
+	}
+
+CExtendedCharacteristics* CRijndaelImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CRijndaelImpl::GetExtendedCharacteristicsL()
+	{
+	return CRijndaelImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRijndaelImpl::ImplementationUid() const
+	{
+	return KCryptoPluginAesUid;
+	}
+	
+TBool CRijndaelImpl::IsValidKeyLength(TInt aKeyBytes) const
+	{
+	switch(aKeyBytes)
+		{
+		case KAESKeyBytes128:
+		case KAESKeyBytes192:
+		case KAESKeyBytes256:
+			return ETrue;
+		default:
+			return EFalse;
+		}			
+	}
+	
+void CRijndaelImpl::SetKeySchedule()
+	{
+	iRounds = iKeyBytes/4 + 6;
+	if (iCryptoMode.iUid == KCryptoModeEncrypt)
+		{
+		SetEncryptKeySchedule(*iKey, &iK[0]);
+		}
+	else 
+		{
+		ASSERT(iCryptoMode.iUid == KCryptoModeDecrypt);
+		SetDecryptKeySchedule(*iKey, &iK[0]);
+		}	
+	}	
+
+void CRijndaelImpl::TransformEncrypt(
+	TUint8* aBuffer, 
+	TUint aNumBlocks)
+	{
+	for (TInt i = 0; i < aNumBlocks; ++i)
+		{		
+		ModeEncryptStart(aBuffer);
+			
+		TUint32 s0, s1, s2, s3, t0, t1, t2, t3;
+		const TUint32* rk = &iK[0];
+
+	/*
+	 *	map byte array block to cipher state
+	 *	and add initial round key:
+	*/
+		GetBlockBigEndian(aBuffer, s0, s1, s2, s3);
+		s0 ^= rk[0];
+		s1 ^= rk[1];
+		s2 ^= rk[2];
+		s3 ^= rk[3];
+	/*
+	 *	Nr - 1 full rounds:
+	*/
+	    TUint r = iRounds >> 1;
+		FOREVER
+			{
+	        t0 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(s0, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(s1, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(s2, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(s3, 0)] ^
+	            rk[4];
+	        t1 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(s1, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(s2, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(s3, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(s0, 0)] ^
+	            rk[5];
+	        t2 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(s2, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(s3, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(s0, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(s1, 0)] ^
+	            rk[6];
+	        t3 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(s3, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(s0, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(s1, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(s2, 0)] ^
+	            rk[7];
+
+	        rk += 8;
+	        if (--r == 0) 
+				break;
+	        
+	        s0 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(t0, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(t1, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(t2, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(t3, 0)] ^
+	            rk[0];
+	        s1 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(t1, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(t2, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(t3, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(t0, 0)] ^
+	            rk[1];
+	        s2 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(t2, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(t3, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(t0, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(t1, 0)] ^
+	            rk[2];
+	        s3 =
+	            RIJNDAEL_TABLE::Te0[GETBYTE(t3, 3)] ^
+	            RIJNDAEL_TABLE::Te1[GETBYTE(t0, 2)] ^
+	            RIJNDAEL_TABLE::Te2[GETBYTE(t1, 1)] ^
+	            RIJNDAEL_TABLE::Te3[GETBYTE(t2, 0)] ^
+	            rk[3];
+			}
+	/*
+	 *	apply last round and
+	 *	map cipher state to byte array block:
+	*/
+
+		s0 =
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t0, 3)] & 0xff000000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t1, 2)] & 0x00ff0000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t2, 1)] & 0x0000ff00) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t3, 0)] & 0x000000ff) ^
+			rk[0];
+		s1 =
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t1, 3)] & 0xff000000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t2, 2)] & 0x00ff0000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t3, 1)] & 0x0000ff00) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t0, 0)] & 0x000000ff) ^
+			rk[1];
+		s2 =
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t2, 3)] & 0xff000000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t3, 2)] & 0x00ff0000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t0, 1)] & 0x0000ff00) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t1, 0)] & 0x000000ff) ^
+			rk[2];
+		s3 =
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t3, 3)] & 0xff000000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t0, 2)] & 0x00ff0000) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t1, 1)] & 0x0000ff00) ^
+			(RIJNDAEL_TABLE::Te4[GETBYTE(t2, 0)] & 0x000000ff) ^
+			rk[3];
+
+		PutBlockBigEndian(aBuffer, s0, s1, s2, s3);
+		ModeEncryptEnd(aBuffer);
+		aBuffer += KAESBlockBytes;
+		}
+	}
+
+void CRijndaelImpl::TransformDecrypt(
+	TUint8* aBuffer,
+	TUint aNumBlocks)
+	{
+	for (TInt i = 0; i < aNumBlocks; ++i)
+		{		
+		ModeDecryptStart(aBuffer);
+		
+		TUint32 s0, s1, s2, s3, t0, t1, t2, t3;
+	    const TUint32* rk = &iK[0];
+
+	/*
+	 *	map byte array block to cipher state
+	 *	and add initial round key:
+	*/
+		GetBlockBigEndian(aBuffer, s0, s1, s2, s3);
+
+		s0 ^= rk[0];
+		s1 ^= rk[1];
+		s2 ^= rk[2];
+		s3 ^= rk[3];
+	/*
+	 *	Nr - 1 full rounds:
+	*/
+	    TUint r = iRounds >> 1;
+	    FOREVER
+			{
+	        t0 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(s0, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(s3, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(s2, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(s1, 0)] ^
+	            rk[4];
+	        t1 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(s1, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(s0, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(s3, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(s2, 0)] ^
+	            rk[5];
+	        t2 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(s2, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(s1, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(s0, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(s3, 0)] ^
+	            rk[6];
+	        t3 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(s3, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(s2, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(s1, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(s0, 0)] ^
+	            rk[7];
+
+	        rk += 8;
+	        if (--r == 0)
+	            break;
+	        
+	        s0 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(t0, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(t3, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(t2, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(t1, 0)] ^
+	            rk[0];
+	        s1 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(t1, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(t0, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(t3, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(t2, 0)] ^
+	            rk[1];
+	        s2 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(t2, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(t1, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(t0, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(t3, 0)] ^
+	            rk[2];
+	        s3 =
+	            RIJNDAEL_TABLE::Td0[GETBYTE(t3, 3)] ^
+	            RIJNDAEL_TABLE::Td1[GETBYTE(t2, 2)] ^
+	            RIJNDAEL_TABLE::Td2[GETBYTE(t1, 1)] ^
+	            RIJNDAEL_TABLE::Td3[GETBYTE(t0, 0)] ^
+	            rk[3];
+			}
+	/*
+	 *	apply last round and
+	 *	map cipher state to byte array block:
+	*/
+	   	s0 =
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t0, 3)] & 0xff000000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t3, 2)] & 0x00ff0000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t2, 1)] & 0x0000ff00) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t1, 0)] & 0x000000ff) ^
+	   		rk[0];
+	   	s1 =
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t1, 3)] & 0xff000000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t0, 2)] & 0x00ff0000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t3, 1)] & 0x0000ff00) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t2, 0)] & 0x000000ff) ^
+	   		rk[1];
+	   	s2 =
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t2, 3)] & 0xff000000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t1, 2)] & 0x00ff0000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t0, 1)] & 0x0000ff00) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t3, 0)] & 0x000000ff) ^
+	   		rk[2];
+	   	s3 =
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t3, 3)] & 0xff000000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t2, 2)] & 0x00ff0000) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t1, 1)] & 0x0000ff00) ^
+	   		(RIJNDAEL_TABLE::Td4[GETBYTE(t0, 0)] & 0x000000ff) ^
+	   		rk[3];		
+		PutBlockBigEndian(aBuffer, s0, s1, s2, s3);
+		ModeDecryptEnd(aBuffer);
+		aBuffer += KAESBlockBytes;
+		}
+	}
+
+void CRijndaelImpl::SetEncryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule)
+	{		
+	TUint keySize = aKey.Length();
+	TUint32 temp; 
+	TUint32* rk = aKeySchedule;
+
+	TUint i = 0;
+
+	GetUserKeyBigEndian(rk, keySize/4, &aKey[0], keySize);
+
+	switch(keySize)
+		{
+		case (KAESKeyBytes128):
+			{
+			FOREVER
+				{
+				temp  = rk[3];
+				rk[4] = rk[0] ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
+					RIJNDAEL_TABLE::rcon[i];
+				rk[5] = rk[1] ^ rk[4];
+				rk[6] = rk[2] ^ rk[5];
+				rk[7] = rk[3] ^ rk[6];
+				if (++i == 10)
+					break;
+				rk += 4;
+				}
+			}
+		break;
+
+		case (KAESKeyBytes192):
+			{
+			FOREVER
+				{
+				temp = rk[ 5];
+				rk[ 6] = rk[ 0] ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
+					(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
+					RIJNDAEL_TABLE::rcon[i];
+				rk[ 7] = rk[ 1] ^ rk[ 6];
+				rk[ 8] = rk[ 2] ^ rk[ 7];
+				rk[ 9] = rk[ 3] ^ rk[ 8];
+				if (++i == 8)
+					break;
+				rk[10] = rk[ 4] ^ rk[ 9];
+				rk[11] = rk[ 5] ^ rk[10];
+				rk += 6;
+				}
+			}
+		break;
+
+		case (KAESKeyBytes256):
+			{
+			FOREVER
+				{
+        		temp = rk[ 7];
+        		rk[ 8] = rk[ 0] ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0xff000000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x00ff0000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x0000ff00) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0x000000ff) ^
+        			RIJNDAEL_TABLE::rcon[i];
+        		rk[ 9] = rk[ 1] ^ rk[ 8];
+        		rk[10] = rk[ 2] ^ rk[ 9];
+        		rk[11] = rk[ 3] ^ rk[10];
+				if (++i == 7)
+					break;
+        		temp = rk[11];
+        		rk[12] = rk[ 4] ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 3)] & 0xff000000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 2)] & 0x00ff0000) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 1)] & 0x0000ff00) ^
+        			(RIJNDAEL_TABLE::Te4[GETBYTE(temp, 0)] & 0x000000ff);
+        		rk[13] = rk[ 5] ^ rk[12];
+        		rk[14] = rk[ 6] ^ rk[13];
+        		rk[15] = rk[ 7] ^ rk[14];
+
+				rk += 8;
+				}
+			}
+		break;
+
+		default:
+			assert(0);	//	Shouldn't get here, keeps compiler happy
+		}
+	}
+
+void CRijndaelImpl::SetDecryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule)
+	{
+	SetEncryptKeySchedule(aKey, aKeySchedule);
+
+	TUint i, j;
+	TUint32* rk = aKeySchedule;
+	TUint32 temp;
+
+	// invert the order of the round keys 
+	for (i = 0, j = 4*iRounds; i < j; i += 4, j -= 4)
+		{
+		temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp;
+		temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
+		temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
+		temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
+		}
+
+	// apply the inverse MixColumn transform to all round keys but the first and the last
+	for (i = 1; i < iRounds; i++)
+		{
+		rk += 4;
+		rk[0] =
+			RIJNDAEL_TABLE::Td0[RIJNDAEL_TABLE::Te4[GETBYTE(rk[0], 3)] & 0xff] ^
+			RIJNDAEL_TABLE::Td1[RIJNDAEL_TABLE::Te4[GETBYTE(rk[0], 2)] & 0xff] ^
+			RIJNDAEL_TABLE::Td2[RIJNDAEL_TABLE::Te4[GETBYTE(rk[0], 1)] & 0xff] ^
+			RIJNDAEL_TABLE::Td3[RIJNDAEL_TABLE::Te4[GETBYTE(rk[0], 0)] & 0xff];
+		rk[1] =
+			RIJNDAEL_TABLE::Td0[RIJNDAEL_TABLE::Te4[GETBYTE(rk[1], 3)] & 0xff] ^
+			RIJNDAEL_TABLE::Td1[RIJNDAEL_TABLE::Te4[GETBYTE(rk[1], 2)] & 0xff] ^
+			RIJNDAEL_TABLE::Td2[RIJNDAEL_TABLE::Te4[GETBYTE(rk[1], 1)] & 0xff] ^
+			RIJNDAEL_TABLE::Td3[RIJNDAEL_TABLE::Te4[GETBYTE(rk[1], 0)] & 0xff];
+		rk[2] =
+			RIJNDAEL_TABLE::Td0[RIJNDAEL_TABLE::Te4[GETBYTE(rk[2], 3)] & 0xff] ^
+			RIJNDAEL_TABLE::Td1[RIJNDAEL_TABLE::Te4[GETBYTE(rk[2], 2)] & 0xff] ^
+			RIJNDAEL_TABLE::Td2[RIJNDAEL_TABLE::Te4[GETBYTE(rk[2], 1)] & 0xff] ^
+			RIJNDAEL_TABLE::Td3[RIJNDAEL_TABLE::Te4[GETBYTE(rk[2], 0)] & 0xff];
+		rk[3] =
+			RIJNDAEL_TABLE::Td0[RIJNDAEL_TABLE::Te4[GETBYTE(rk[3], 3)] & 0xff] ^
+			RIJNDAEL_TABLE::Td1[RIJNDAEL_TABLE::Te4[GETBYTE(rk[3], 2)] & 0xff] ^
+			RIJNDAEL_TABLE::Td2[RIJNDAEL_TABLE::Te4[GETBYTE(rk[3], 1)] & 0xff] ^
+			RIJNDAEL_TABLE::Td3[RIJNDAEL_TABLE::Te4[GETBYTE(rk[3], 0)] & 0xff];
+		}
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rijndaelimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,128 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef	__RIJNDAELIMPL_H__
+#define	__RIJNDAELIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keys.h"
+#include "symmetriccipherimpl.h"
+
+/**
+Plug-in class for AES (Rijndael) block cipher
+*/
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CRijndaelImpl) : public CSymmetricBlockCipherImpl
+		{
+	public:
+		/**
+		Creates an instance of an AES (Rijndael) symmetric cipher plug-in.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a CRijndaelImpl instance
+		*/
+		static CRijndaelImpl* NewL(const CKey& aKey, 
+			TUid aCryptoMode, TUid aOperationMode, TUid aPadding);
+
+		/**
+		Creates an instance of an AES (Rijndael) symmetric cipher plug-in.
+		A pointer to the plug-in instance is placed on the cleanup stack.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aOperationMode The block cipher mode ECB, CBC, CTR etc
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a CRijndaelImpl instance
+		*/
+		static CRijndaelImpl* NewLC(const CKey& aKey, 
+			TUid aCryptoMode,	TUid aOperationMode, TUid aPadding);
+
+		// From CSymmetricCipherImpl
+		TBool IsValidKeyLength(TInt aKeyBytes) const;
+		TUid ImplementationUid() const;
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+				
+		/// Destructor
+		~CRijndaelImpl();
+
+	private:
+		/**
+		Constructor
+		@param aOperationMode The mode of operation e.g. CBC
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPaddingMode The padding mode to use. None, SSL, PKCS#7
+		*/
+		CRijndaelImpl(TUid aOperationMode, TUid aCryptoMode, TUid aPaddingMode);
+			
+		///	second phase of construction	
+		void ConstructL(const CKey& aKey);
+					
+		/**
+		Creates the key schedule iK from CBlockTransformationImpl::iKey.
+		This should be called from ConstructL and Reset
+		*/
+		void SetKeySchedule();
+		
+		/**
+		Setup the key schedule for encryption
+		@param aKey The input key
+		@param aKeySchedule The pointer to the key schedule buffer
+		*/
+		void SetEncryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule);
+		
+		/**
+		Setup the key schedule for decryption
+		@param aKey The input key
+		@param aKeySchedule The pointer to the key schedule buffer		
+		*/
+		void SetDecryptKeySchedule(const TDesC8& aKey, TUint32* aKeySchedule);
+
+		// From CSymmetricBlockCipherImpl
+		void TransformEncrypt(TUint8* aBuffer, TUint aNumBlocks);
+		void TransformDecrypt(TUint8* aBuffer, TUint aNumBlocks);
+				
+	private:
+	
+		/** 
+		The key-schedule size in WORDS
+		
+	 	The maximum size is (((KAESMaxBlockSize/4)+6)+1)*4
+	 	*/
+	 	static const TUint32 KKeyScheduleSize = 60;
+	 	
+	 	/// the key schedule
+		TUint32 iK[KKeyScheduleSize];
+		
+		TInt iRounds;
+		};
+	}
+
+#endif //__RIJNDAELIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rijndaeltables.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,723 @@
+/*
+* Copyright (c) 2002-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RIJNDAELTABLES_H__
+#define __RIJNDAELTABLES_H__
+
+#include <e32std.h>
+
+namespace RIJNDAEL_TABLE
+{
+
+/*
+Te0[x] = S [x].[02, 01, 01, 03];
+Te1[x] = S [x].[03, 02, 01, 01];
+Te2[x] = S [x].[01, 03, 02, 01];
+Te3[x] = S [x].[01, 01, 03, 02];
+Te4[x] = S [x].[01, 01, 01, 01];
+
+Td0[x] = Si[x].[0e, 09, 0d, 0b];
+Td1[x] = Si[x].[0b, 0e, 09, 0d];
+Td2[x] = Si[x].[0d, 0b, 0e, 09];
+Td3[x] = Si[x].[09, 0d, 0b, 0e];
+Td4[x] = Si[x].[01, 01, 01, 01];
+*/
+
+const TUint32 Te0[256] = {
+    0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
+    0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,
+    0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,
+    0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,
+    0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,
+    0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,
+    0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,
+    0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,
+    0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,
+    0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,
+    0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,
+    0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,
+    0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,
+    0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,
+    0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,
+    0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,
+    0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,
+    0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,
+    0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,
+    0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,
+    0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,
+    0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,
+    0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,
+    0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,
+    0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,
+    0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,
+    0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,
+    0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,
+    0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,
+    0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,
+    0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,
+    0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,
+    0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,
+    0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,
+    0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,
+    0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,
+    0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,
+    0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,
+    0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,
+    0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,
+    0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,
+    0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,
+    0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,
+    0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,
+    0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,
+    0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,
+    0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,
+    0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,
+    0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,
+    0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,
+    0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,
+    0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,
+    0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,
+    0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,
+    0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,
+    0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,
+    0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,
+    0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,
+    0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,
+    0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,
+    0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,
+    0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,
+    0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
+    0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
+};
+const TUint32 Te1[256] = {
+    0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,
+    0x0dfff2f2U, 0xbdd66b6bU, 0xb1de6f6fU, 0x5491c5c5U,
+    0x50603030U, 0x03020101U, 0xa9ce6767U, 0x7d562b2bU,
+    0x19e7fefeU, 0x62b5d7d7U, 0xe64dababU, 0x9aec7676U,
+    0x458fcacaU, 0x9d1f8282U, 0x4089c9c9U, 0x87fa7d7dU,
+    0x15effafaU, 0xebb25959U, 0xc98e4747U, 0x0bfbf0f0U,
+    0xec41adadU, 0x67b3d4d4U, 0xfd5fa2a2U, 0xea45afafU,
+    0xbf239c9cU, 0xf753a4a4U, 0x96e47272U, 0x5b9bc0c0U,
+    0xc275b7b7U, 0x1ce1fdfdU, 0xae3d9393U, 0x6a4c2626U,
+    0x5a6c3636U, 0x417e3f3fU, 0x02f5f7f7U, 0x4f83ccccU,
+    0x5c683434U, 0xf451a5a5U, 0x34d1e5e5U, 0x08f9f1f1U,
+    0x93e27171U, 0x73abd8d8U, 0x53623131U, 0x3f2a1515U,
+    0x0c080404U, 0x5295c7c7U, 0x65462323U, 0x5e9dc3c3U,
+    0x28301818U, 0xa1379696U, 0x0f0a0505U, 0xb52f9a9aU,
+    0x090e0707U, 0x36241212U, 0x9b1b8080U, 0x3ddfe2e2U,
+    0x26cdebebU, 0x694e2727U, 0xcd7fb2b2U, 0x9fea7575U,
+    0x1b120909U, 0x9e1d8383U, 0x74582c2cU, 0x2e341a1aU,
+    0x2d361b1bU, 0xb2dc6e6eU, 0xeeb45a5aU, 0xfb5ba0a0U,
+    0xf6a45252U, 0x4d763b3bU, 0x61b7d6d6U, 0xce7db3b3U,
+    0x7b522929U, 0x3edde3e3U, 0x715e2f2fU, 0x97138484U,
+    0xf5a65353U, 0x68b9d1d1U, 0x00000000U, 0x2cc1ededU,
+    0x60402020U, 0x1fe3fcfcU, 0xc879b1b1U, 0xedb65b5bU,
+    0xbed46a6aU, 0x468dcbcbU, 0xd967bebeU, 0x4b723939U,
+    0xde944a4aU, 0xd4984c4cU, 0xe8b05858U, 0x4a85cfcfU,
+    0x6bbbd0d0U, 0x2ac5efefU, 0xe54faaaaU, 0x16edfbfbU,
+    0xc5864343U, 0xd79a4d4dU, 0x55663333U, 0x94118585U,
+    0xcf8a4545U, 0x10e9f9f9U, 0x06040202U, 0x81fe7f7fU,
+    0xf0a05050U, 0x44783c3cU, 0xba259f9fU, 0xe34ba8a8U,
+    0xf3a25151U, 0xfe5da3a3U, 0xc0804040U, 0x8a058f8fU,
+    0xad3f9292U, 0xbc219d9dU, 0x48703838U, 0x04f1f5f5U,
+    0xdf63bcbcU, 0xc177b6b6U, 0x75afdadaU, 0x63422121U,
+    0x30201010U, 0x1ae5ffffU, 0x0efdf3f3U, 0x6dbfd2d2U,
+    0x4c81cdcdU, 0x14180c0cU, 0x35261313U, 0x2fc3ececU,
+    0xe1be5f5fU, 0xa2359797U, 0xcc884444U, 0x392e1717U,
+    0x5793c4c4U, 0xf255a7a7U, 0x82fc7e7eU, 0x477a3d3dU,
+    0xacc86464U, 0xe7ba5d5dU, 0x2b321919U, 0x95e67373U,
+    0xa0c06060U, 0x98198181U, 0xd19e4f4fU, 0x7fa3dcdcU,
+    0x66442222U, 0x7e542a2aU, 0xab3b9090U, 0x830b8888U,
+    0xca8c4646U, 0x29c7eeeeU, 0xd36bb8b8U, 0x3c281414U,
+    0x79a7dedeU, 0xe2bc5e5eU, 0x1d160b0bU, 0x76addbdbU,
+    0x3bdbe0e0U, 0x56643232U, 0x4e743a3aU, 0x1e140a0aU,
+    0xdb924949U, 0x0a0c0606U, 0x6c482424U, 0xe4b85c5cU,
+    0x5d9fc2c2U, 0x6ebdd3d3U, 0xef43acacU, 0xa6c46262U,
+    0xa8399191U, 0xa4319595U, 0x37d3e4e4U, 0x8bf27979U,
+    0x32d5e7e7U, 0x438bc8c8U, 0x596e3737U, 0xb7da6d6dU,
+    0x8c018d8dU, 0x64b1d5d5U, 0xd29c4e4eU, 0xe049a9a9U,
+    0xb4d86c6cU, 0xfaac5656U, 0x07f3f4f4U, 0x25cfeaeaU,
+    0xafca6565U, 0x8ef47a7aU, 0xe947aeaeU, 0x18100808U,
+    0xd56fbabaU, 0x88f07878U, 0x6f4a2525U, 0x725c2e2eU,
+    0x24381c1cU, 0xf157a6a6U, 0xc773b4b4U, 0x5197c6c6U,
+    0x23cbe8e8U, 0x7ca1ddddU, 0x9ce87474U, 0x213e1f1fU,
+    0xdd964b4bU, 0xdc61bdbdU, 0x860d8b8bU, 0x850f8a8aU,
+    0x90e07070U, 0x427c3e3eU, 0xc471b5b5U, 0xaacc6666U,
+    0xd8904848U, 0x05060303U, 0x01f7f6f6U, 0x121c0e0eU,
+    0xa3c26161U, 0x5f6a3535U, 0xf9ae5757U, 0xd069b9b9U,
+    0x91178686U, 0x5899c1c1U, 0x273a1d1dU, 0xb9279e9eU,
+    0x38d9e1e1U, 0x13ebf8f8U, 0xb32b9898U, 0x33221111U,
+    0xbbd26969U, 0x70a9d9d9U, 0x89078e8eU, 0xa7339494U,
+    0xb62d9b9bU, 0x223c1e1eU, 0x92158787U, 0x20c9e9e9U,
+    0x4987ceceU, 0xffaa5555U, 0x78502828U, 0x7aa5dfdfU,
+    0x8f038c8cU, 0xf859a1a1U, 0x80098989U, 0x171a0d0dU,
+    0xda65bfbfU, 0x31d7e6e6U, 0xc6844242U, 0xb8d06868U,
+    0xc3824141U, 0xb0299999U, 0x775a2d2dU, 0x111e0f0fU,
+    0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,
+};
+const TUint32 Te2[256] = {
+    0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,
+    0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,
+    0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,
+    0xfe19e7feU, 0xd762b5d7U, 0xabe64dabU, 0x769aec76U,
+    0xca458fcaU, 0x829d1f82U, 0xc94089c9U, 0x7d87fa7dU,
+    0xfa15effaU, 0x59ebb259U, 0x47c98e47U, 0xf00bfbf0U,
+    0xadec41adU, 0xd467b3d4U, 0xa2fd5fa2U, 0xafea45afU,
+    0x9cbf239cU, 0xa4f753a4U, 0x7296e472U, 0xc05b9bc0U,
+    0xb7c275b7U, 0xfd1ce1fdU, 0x93ae3d93U, 0x266a4c26U,
+    0x365a6c36U, 0x3f417e3fU, 0xf702f5f7U, 0xcc4f83ccU,
+    0x345c6834U, 0xa5f451a5U, 0xe534d1e5U, 0xf108f9f1U,
+    0x7193e271U, 0xd873abd8U, 0x31536231U, 0x153f2a15U,
+    0x040c0804U, 0xc75295c7U, 0x23654623U, 0xc35e9dc3U,
+    0x18283018U, 0x96a13796U, 0x050f0a05U, 0x9ab52f9aU,
+    0x07090e07U, 0x12362412U, 0x809b1b80U, 0xe23ddfe2U,
+    0xeb26cdebU, 0x27694e27U, 0xb2cd7fb2U, 0x759fea75U,
+    0x091b1209U, 0x839e1d83U, 0x2c74582cU, 0x1a2e341aU,
+    0x1b2d361bU, 0x6eb2dc6eU, 0x5aeeb45aU, 0xa0fb5ba0U,
+    0x52f6a452U, 0x3b4d763bU, 0xd661b7d6U, 0xb3ce7db3U,
+    0x297b5229U, 0xe33edde3U, 0x2f715e2fU, 0x84971384U,
+    0x53f5a653U, 0xd168b9d1U, 0x00000000U, 0xed2cc1edU,
+    0x20604020U, 0xfc1fe3fcU, 0xb1c879b1U, 0x5bedb65bU,
+    0x6abed46aU, 0xcb468dcbU, 0xbed967beU, 0x394b7239U,
+    0x4ade944aU, 0x4cd4984cU, 0x58e8b058U, 0xcf4a85cfU,
+    0xd06bbbd0U, 0xef2ac5efU, 0xaae54faaU, 0xfb16edfbU,
+    0x43c58643U, 0x4dd79a4dU, 0x33556633U, 0x85941185U,
+    0x45cf8a45U, 0xf910e9f9U, 0x02060402U, 0x7f81fe7fU,
+    0x50f0a050U, 0x3c44783cU, 0x9fba259fU, 0xa8e34ba8U,
+    0x51f3a251U, 0xa3fe5da3U, 0x40c08040U, 0x8f8a058fU,
+    0x92ad3f92U, 0x9dbc219dU, 0x38487038U, 0xf504f1f5U,
+    0xbcdf63bcU, 0xb6c177b6U, 0xda75afdaU, 0x21634221U,
+    0x10302010U, 0xff1ae5ffU, 0xf30efdf3U, 0xd26dbfd2U,
+    0xcd4c81cdU, 0x0c14180cU, 0x13352613U, 0xec2fc3ecU,
+    0x5fe1be5fU, 0x97a23597U, 0x44cc8844U, 0x17392e17U,
+    0xc45793c4U, 0xa7f255a7U, 0x7e82fc7eU, 0x3d477a3dU,
+    0x64acc864U, 0x5de7ba5dU, 0x192b3219U, 0x7395e673U,
+    0x60a0c060U, 0x81981981U, 0x4fd19e4fU, 0xdc7fa3dcU,
+    0x22664422U, 0x2a7e542aU, 0x90ab3b90U, 0x88830b88U,
+    0x46ca8c46U, 0xee29c7eeU, 0xb8d36bb8U, 0x143c2814U,
+    0xde79a7deU, 0x5ee2bc5eU, 0x0b1d160bU, 0xdb76addbU,
+    0xe03bdbe0U, 0x32566432U, 0x3a4e743aU, 0x0a1e140aU,
+    0x49db9249U, 0x060a0c06U, 0x246c4824U, 0x5ce4b85cU,
+    0xc25d9fc2U, 0xd36ebdd3U, 0xacef43acU, 0x62a6c462U,
+    0x91a83991U, 0x95a43195U, 0xe437d3e4U, 0x798bf279U,
+    0xe732d5e7U, 0xc8438bc8U, 0x37596e37U, 0x6db7da6dU,
+    0x8d8c018dU, 0xd564b1d5U, 0x4ed29c4eU, 0xa9e049a9U,
+    0x6cb4d86cU, 0x56faac56U, 0xf407f3f4U, 0xea25cfeaU,
+    0x65afca65U, 0x7a8ef47aU, 0xaee947aeU, 0x08181008U,
+    0xbad56fbaU, 0x7888f078U, 0x256f4a25U, 0x2e725c2eU,
+    0x1c24381cU, 0xa6f157a6U, 0xb4c773b4U, 0xc65197c6U,
+    0xe823cbe8U, 0xdd7ca1ddU, 0x749ce874U, 0x1f213e1fU,
+    0x4bdd964bU, 0xbddc61bdU, 0x8b860d8bU, 0x8a850f8aU,
+    0x7090e070U, 0x3e427c3eU, 0xb5c471b5U, 0x66aacc66U,
+    0x48d89048U, 0x03050603U, 0xf601f7f6U, 0x0e121c0eU,
+    0x61a3c261U, 0x355f6a35U, 0x57f9ae57U, 0xb9d069b9U,
+    0x86911786U, 0xc15899c1U, 0x1d273a1dU, 0x9eb9279eU,
+    0xe138d9e1U, 0xf813ebf8U, 0x98b32b98U, 0x11332211U,
+    0x69bbd269U, 0xd970a9d9U, 0x8e89078eU, 0x94a73394U,
+    0x9bb62d9bU, 0x1e223c1eU, 0x87921587U, 0xe920c9e9U,
+    0xce4987ceU, 0x55ffaa55U, 0x28785028U, 0xdf7aa5dfU,
+    0x8c8f038cU, 0xa1f859a1U, 0x89800989U, 0x0d171a0dU,
+    0xbfda65bfU, 0xe631d7e6U, 0x42c68442U, 0x68b8d068U,
+    0x41c38241U, 0x99b02999U, 0x2d775a2dU, 0x0f111e0fU,
+    0xb0cb7bb0U, 0x54fca854U, 0xbbd66dbbU, 0x163a2c16U,
+};
+
+const TUint32 Te3[256] = {
+    0x6363a5c6U, 0x7c7c84f8U, 0x777799eeU, 0x7b7b8df6U,
+    0xf2f20dffU, 0x6b6bbdd6U, 0x6f6fb1deU, 0xc5c55491U,
+    0x30305060U, 0x01010302U, 0x6767a9ceU, 0x2b2b7d56U,
+    0xfefe19e7U, 0xd7d762b5U, 0xababe64dU, 0x76769aecU,
+    0xcaca458fU, 0x82829d1fU, 0xc9c94089U, 0x7d7d87faU,
+    0xfafa15efU, 0x5959ebb2U, 0x4747c98eU, 0xf0f00bfbU,
+    0xadadec41U, 0xd4d467b3U, 0xa2a2fd5fU, 0xafafea45U,
+    0x9c9cbf23U, 0xa4a4f753U, 0x727296e4U, 0xc0c05b9bU,
+    0xb7b7c275U, 0xfdfd1ce1U, 0x9393ae3dU, 0x26266a4cU,
+    0x36365a6cU, 0x3f3f417eU, 0xf7f702f5U, 0xcccc4f83U,
+    0x34345c68U, 0xa5a5f451U, 0xe5e534d1U, 0xf1f108f9U,
+    0x717193e2U, 0xd8d873abU, 0x31315362U, 0x15153f2aU,
+    0x04040c08U, 0xc7c75295U, 0x23236546U, 0xc3c35e9dU,
+    0x18182830U, 0x9696a137U, 0x05050f0aU, 0x9a9ab52fU,
+    0x0707090eU, 0x12123624U, 0x80809b1bU, 0xe2e23ddfU,
+    0xebeb26cdU, 0x2727694eU, 0xb2b2cd7fU, 0x75759feaU,
+    0x09091b12U, 0x83839e1dU, 0x2c2c7458U, 0x1a1a2e34U,
+    0x1b1b2d36U, 0x6e6eb2dcU, 0x5a5aeeb4U, 0xa0a0fb5bU,
+    0x5252f6a4U, 0x3b3b4d76U, 0xd6d661b7U, 0xb3b3ce7dU,
+    0x29297b52U, 0xe3e33eddU, 0x2f2f715eU, 0x84849713U,
+    0x5353f5a6U, 0xd1d168b9U, 0x00000000U, 0xeded2cc1U,
+    0x20206040U, 0xfcfc1fe3U, 0xb1b1c879U, 0x5b5bedb6U,
+    0x6a6abed4U, 0xcbcb468dU, 0xbebed967U, 0x39394b72U,
+    0x4a4ade94U, 0x4c4cd498U, 0x5858e8b0U, 0xcfcf4a85U,
+    0xd0d06bbbU, 0xefef2ac5U, 0xaaaae54fU, 0xfbfb16edU,
+    0x4343c586U, 0x4d4dd79aU, 0x33335566U, 0x85859411U,
+    0x4545cf8aU, 0xf9f910e9U, 0x02020604U, 0x7f7f81feU,
+    0x5050f0a0U, 0x3c3c4478U, 0x9f9fba25U, 0xa8a8e34bU,
+    0x5151f3a2U, 0xa3a3fe5dU, 0x4040c080U, 0x8f8f8a05U,
+    0x9292ad3fU, 0x9d9dbc21U, 0x38384870U, 0xf5f504f1U,
+    0xbcbcdf63U, 0xb6b6c177U, 0xdada75afU, 0x21216342U,
+    0x10103020U, 0xffff1ae5U, 0xf3f30efdU, 0xd2d26dbfU,
+    0xcdcd4c81U, 0x0c0c1418U, 0x13133526U, 0xecec2fc3U,
+    0x5f5fe1beU, 0x9797a235U, 0x4444cc88U, 0x1717392eU,
+    0xc4c45793U, 0xa7a7f255U, 0x7e7e82fcU, 0x3d3d477aU,
+    0x6464acc8U, 0x5d5de7baU, 0x19192b32U, 0x737395e6U,
+    0x6060a0c0U, 0x81819819U, 0x4f4fd19eU, 0xdcdc7fa3U,
+    0x22226644U, 0x2a2a7e54U, 0x9090ab3bU, 0x8888830bU,
+    0x4646ca8cU, 0xeeee29c7U, 0xb8b8d36bU, 0x14143c28U,
+    0xdede79a7U, 0x5e5ee2bcU, 0x0b0b1d16U, 0xdbdb76adU,
+    0xe0e03bdbU, 0x32325664U, 0x3a3a4e74U, 0x0a0a1e14U,
+    0x4949db92U, 0x06060a0cU, 0x24246c48U, 0x5c5ce4b8U,
+    0xc2c25d9fU, 0xd3d36ebdU, 0xacacef43U, 0x6262a6c4U,
+    0x9191a839U, 0x9595a431U, 0xe4e437d3U, 0x79798bf2U,
+    0xe7e732d5U, 0xc8c8438bU, 0x3737596eU, 0x6d6db7daU,
+    0x8d8d8c01U, 0xd5d564b1U, 0x4e4ed29cU, 0xa9a9e049U,
+    0x6c6cb4d8U, 0x5656faacU, 0xf4f407f3U, 0xeaea25cfU,
+    0x6565afcaU, 0x7a7a8ef4U, 0xaeaee947U, 0x08081810U,
+    0xbabad56fU, 0x787888f0U, 0x25256f4aU, 0x2e2e725cU,
+    0x1c1c2438U, 0xa6a6f157U, 0xb4b4c773U, 0xc6c65197U,
+    0xe8e823cbU, 0xdddd7ca1U, 0x74749ce8U, 0x1f1f213eU,
+    0x4b4bdd96U, 0xbdbddc61U, 0x8b8b860dU, 0x8a8a850fU,
+    0x707090e0U, 0x3e3e427cU, 0xb5b5c471U, 0x6666aaccU,
+    0x4848d890U, 0x03030506U, 0xf6f601f7U, 0x0e0e121cU,
+    0x6161a3c2U, 0x35355f6aU, 0x5757f9aeU, 0xb9b9d069U,
+    0x86869117U, 0xc1c15899U, 0x1d1d273aU, 0x9e9eb927U,
+    0xe1e138d9U, 0xf8f813ebU, 0x9898b32bU, 0x11113322U,
+    0x6969bbd2U, 0xd9d970a9U, 0x8e8e8907U, 0x9494a733U,
+    0x9b9bb62dU, 0x1e1e223cU, 0x87879215U, 0xe9e920c9U,
+    0xcece4987U, 0x5555ffaaU, 0x28287850U, 0xdfdf7aa5U,
+    0x8c8c8f03U, 0xa1a1f859U, 0x89898009U, 0x0d0d171aU,
+    0xbfbfda65U, 0xe6e631d7U, 0x4242c684U, 0x6868b8d0U,
+    0x4141c382U, 0x9999b029U, 0x2d2d775aU, 0x0f0f111eU,
+    0xb0b0cb7bU, 0x5454fca8U, 0xbbbbd66dU, 0x16163a2cU,
+};
+
+const TUint32 Te4[256] = {
+    0x63636363U, 0x7c7c7c7cU, 0x77777777U, 0x7b7b7b7bU,
+    0xf2f2f2f2U, 0x6b6b6b6bU, 0x6f6f6f6fU, 0xc5c5c5c5U,
+    0x30303030U, 0x01010101U, 0x67676767U, 0x2b2b2b2bU,
+    0xfefefefeU, 0xd7d7d7d7U, 0xababababU, 0x76767676U,
+    0xcacacacaU, 0x82828282U, 0xc9c9c9c9U, 0x7d7d7d7dU,
+    0xfafafafaU, 0x59595959U, 0x47474747U, 0xf0f0f0f0U,
+    0xadadadadU, 0xd4d4d4d4U, 0xa2a2a2a2U, 0xafafafafU,
+    0x9c9c9c9cU, 0xa4a4a4a4U, 0x72727272U, 0xc0c0c0c0U,
+    0xb7b7b7b7U, 0xfdfdfdfdU, 0x93939393U, 0x26262626U,
+    0x36363636U, 0x3f3f3f3fU, 0xf7f7f7f7U, 0xccccccccU,
+    0x34343434U, 0xa5a5a5a5U, 0xe5e5e5e5U, 0xf1f1f1f1U,
+    0x71717171U, 0xd8d8d8d8U, 0x31313131U, 0x15151515U,
+    0x04040404U, 0xc7c7c7c7U, 0x23232323U, 0xc3c3c3c3U,
+    0x18181818U, 0x96969696U, 0x05050505U, 0x9a9a9a9aU,
+    0x07070707U, 0x12121212U, 0x80808080U, 0xe2e2e2e2U,
+    0xebebebebU, 0x27272727U, 0xb2b2b2b2U, 0x75757575U,
+    0x09090909U, 0x83838383U, 0x2c2c2c2cU, 0x1a1a1a1aU,
+    0x1b1b1b1bU, 0x6e6e6e6eU, 0x5a5a5a5aU, 0xa0a0a0a0U,
+    0x52525252U, 0x3b3b3b3bU, 0xd6d6d6d6U, 0xb3b3b3b3U,
+    0x29292929U, 0xe3e3e3e3U, 0x2f2f2f2fU, 0x84848484U,
+    0x53535353U, 0xd1d1d1d1U, 0x00000000U, 0xededededU,
+    0x20202020U, 0xfcfcfcfcU, 0xb1b1b1b1U, 0x5b5b5b5bU,
+    0x6a6a6a6aU, 0xcbcbcbcbU, 0xbebebebeU, 0x39393939U,
+    0x4a4a4a4aU, 0x4c4c4c4cU, 0x58585858U, 0xcfcfcfcfU,
+    0xd0d0d0d0U, 0xefefefefU, 0xaaaaaaaaU, 0xfbfbfbfbU,
+    0x43434343U, 0x4d4d4d4dU, 0x33333333U, 0x85858585U,
+    0x45454545U, 0xf9f9f9f9U, 0x02020202U, 0x7f7f7f7fU,
+    0x50505050U, 0x3c3c3c3cU, 0x9f9f9f9fU, 0xa8a8a8a8U,
+    0x51515151U, 0xa3a3a3a3U, 0x40404040U, 0x8f8f8f8fU,
+    0x92929292U, 0x9d9d9d9dU, 0x38383838U, 0xf5f5f5f5U,
+    0xbcbcbcbcU, 0xb6b6b6b6U, 0xdadadadaU, 0x21212121U,
+    0x10101010U, 0xffffffffU, 0xf3f3f3f3U, 0xd2d2d2d2U,
+    0xcdcdcdcdU, 0x0c0c0c0cU, 0x13131313U, 0xececececU,
+    0x5f5f5f5fU, 0x97979797U, 0x44444444U, 0x17171717U,
+    0xc4c4c4c4U, 0xa7a7a7a7U, 0x7e7e7e7eU, 0x3d3d3d3dU,
+    0x64646464U, 0x5d5d5d5dU, 0x19191919U, 0x73737373U,
+    0x60606060U, 0x81818181U, 0x4f4f4f4fU, 0xdcdcdcdcU,
+    0x22222222U, 0x2a2a2a2aU, 0x90909090U, 0x88888888U,
+    0x46464646U, 0xeeeeeeeeU, 0xb8b8b8b8U, 0x14141414U,
+    0xdedededeU, 0x5e5e5e5eU, 0x0b0b0b0bU, 0xdbdbdbdbU,
+    0xe0e0e0e0U, 0x32323232U, 0x3a3a3a3aU, 0x0a0a0a0aU,
+    0x49494949U, 0x06060606U, 0x24242424U, 0x5c5c5c5cU,
+    0xc2c2c2c2U, 0xd3d3d3d3U, 0xacacacacU, 0x62626262U,
+    0x91919191U, 0x95959595U, 0xe4e4e4e4U, 0x79797979U,
+    0xe7e7e7e7U, 0xc8c8c8c8U, 0x37373737U, 0x6d6d6d6dU,
+    0x8d8d8d8dU, 0xd5d5d5d5U, 0x4e4e4e4eU, 0xa9a9a9a9U,
+    0x6c6c6c6cU, 0x56565656U, 0xf4f4f4f4U, 0xeaeaeaeaU,
+    0x65656565U, 0x7a7a7a7aU, 0xaeaeaeaeU, 0x08080808U,
+    0xbabababaU, 0x78787878U, 0x25252525U, 0x2e2e2e2eU,
+    0x1c1c1c1cU, 0xa6a6a6a6U, 0xb4b4b4b4U, 0xc6c6c6c6U,
+    0xe8e8e8e8U, 0xddddddddU, 0x74747474U, 0x1f1f1f1fU,
+    0x4b4b4b4bU, 0xbdbdbdbdU, 0x8b8b8b8bU, 0x8a8a8a8aU,
+    0x70707070U, 0x3e3e3e3eU, 0xb5b5b5b5U, 0x66666666U,
+    0x48484848U, 0x03030303U, 0xf6f6f6f6U, 0x0e0e0e0eU,
+    0x61616161U, 0x35353535U, 0x57575757U, 0xb9b9b9b9U,
+    0x86868686U, 0xc1c1c1c1U, 0x1d1d1d1dU, 0x9e9e9e9eU,
+    0xe1e1e1e1U, 0xf8f8f8f8U, 0x98989898U, 0x11111111U,
+    0x69696969U, 0xd9d9d9d9U, 0x8e8e8e8eU, 0x94949494U,
+    0x9b9b9b9bU, 0x1e1e1e1eU, 0x87878787U, 0xe9e9e9e9U,
+    0xcecececeU, 0x55555555U, 0x28282828U, 0xdfdfdfdfU,
+    0x8c8c8c8cU, 0xa1a1a1a1U, 0x89898989U, 0x0d0d0d0dU,
+    0xbfbfbfbfU, 0xe6e6e6e6U, 0x42424242U, 0x68686868U,
+    0x41414141U, 0x99999999U, 0x2d2d2d2dU, 0x0f0f0f0fU,
+    0xb0b0b0b0U, 0x54545454U, 0xbbbbbbbbU, 0x16161616U,
+};
+
+const TUint32 Td0[256] = {
+    0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,
+    0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,
+    0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,
+    0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,
+    0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,
+    0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,
+    0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,
+    0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,
+    0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,
+    0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,
+    0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,
+    0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,
+    0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,
+    0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,
+    0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,
+    0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,
+    0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,
+    0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,
+    0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,
+    0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,
+    0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,
+    0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,
+    0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,
+    0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,
+    0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,
+    0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,
+    0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,
+    0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,
+    0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,
+    0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,
+    0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,
+    0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,
+    0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,
+    0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,
+    0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,
+    0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,
+    0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,
+    0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,
+    0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,
+    0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,
+    0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,
+    0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,
+    0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,
+    0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,
+    0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,
+    0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,
+    0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,
+    0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,
+    0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,
+    0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,
+    0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,
+    0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,
+    0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,
+    0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,
+    0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,
+    0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,
+    0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,
+    0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,
+    0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,
+    0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,
+    0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,
+    0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,
+    0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,
+    0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,
+};
+
+const TUint32 Td1[256] = {
+    0x5051f4a7U, 0x537e4165U, 0xc31a17a4U, 0x963a275eU,
+    0xcb3bab6bU, 0xf11f9d45U, 0xabacfa58U, 0x934be303U,
+    0x552030faU, 0xf6ad766dU, 0x9188cc76U, 0x25f5024cU,
+    0xfc4fe5d7U, 0xd7c52acbU, 0x80263544U, 0x8fb562a3U,
+    0x49deb15aU, 0x6725ba1bU, 0x9845ea0eU, 0xe15dfec0U,
+    0x02c32f75U, 0x12814cf0U, 0xa38d4697U, 0xc66bd3f9U,
+    0xe7038f5fU, 0x9515929cU, 0xebbf6d7aU, 0xda955259U,
+    0x2dd4be83U, 0xd3587421U, 0x2949e069U, 0x448ec9c8U,
+    0x6a75c289U, 0x78f48e79U, 0x6b99583eU, 0xdd27b971U,
+    0xb6bee14fU, 0x17f088adU, 0x66c920acU, 0xb47dce3aU,
+    0x1863df4aU, 0x82e51a31U, 0x60975133U, 0x4562537fU,
+    0xe0b16477U, 0x84bb6baeU, 0x1cfe81a0U, 0x94f9082bU,
+    0x58704868U, 0x198f45fdU, 0x8794de6cU, 0xb7527bf8U,
+    0x23ab73d3U, 0xe2724b02U, 0x57e31f8fU, 0x2a6655abU,
+    0x07b2eb28U, 0x032fb5c2U, 0x9a86c57bU, 0xa5d33708U,
+    0xf2302887U, 0xb223bfa5U, 0xba02036aU, 0x5ced1682U,
+    0x2b8acf1cU, 0x92a779b4U, 0xf0f307f2U, 0xa14e69e2U,
+    0xcd65daf4U, 0xd50605beU, 0x1fd13462U, 0x8ac4a6feU,
+    0x9d342e53U, 0xa0a2f355U, 0x32058ae1U, 0x75a4f6ebU,
+    0x390b83ecU, 0xaa4060efU, 0x065e719fU, 0x51bd6e10U,
+    0xf93e218aU, 0x3d96dd06U, 0xaedd3e05U, 0x464de6bdU,
+    0xb591548dU, 0x0571c45dU, 0x6f0406d4U, 0xff605015U,
+    0x241998fbU, 0x97d6bde9U, 0xcc894043U, 0x7767d99eU,
+    0xbdb0e842U, 0x8807898bU, 0x38e7195bU, 0xdb79c8eeU,
+    0x47a17c0aU, 0xe97c420fU, 0xc9f8841eU, 0x00000000U,
+    0x83098086U, 0x48322bedU, 0xac1e1170U, 0x4e6c5a72U,
+    0xfbfd0effU, 0x560f8538U, 0x1e3daed5U, 0x27362d39U,
+    0x640a0fd9U, 0x21685ca6U, 0xd19b5b54U, 0x3a24362eU,
+    0xb10c0a67U, 0x0f9357e7U, 0xd2b4ee96U, 0x9e1b9b91U,
+    0x4f80c0c5U, 0xa261dc20U, 0x695a774bU, 0x161c121aU,
+    0x0ae293baU, 0xe5c0a02aU, 0x433c22e0U, 0x1d121b17U,
+    0x0b0e090dU, 0xadf28bc7U, 0xb92db6a8U, 0xc8141ea9U,
+    0x8557f119U, 0x4caf7507U, 0xbbee99ddU, 0xfda37f60U,
+    0x9ff70126U, 0xbc5c72f5U, 0xc544663bU, 0x345bfb7eU,
+    0x768b4329U, 0xdccb23c6U, 0x68b6edfcU, 0x63b8e4f1U,
+    0xcad731dcU, 0x10426385U, 0x40139722U, 0x2084c611U,
+    0x7d854a24U, 0xf8d2bb3dU, 0x11aef932U, 0x6dc729a1U,
+    0x4b1d9e2fU, 0xf3dcb230U, 0xec0d8652U, 0xd077c1e3U,
+    0x6c2bb316U, 0x99a970b9U, 0xfa119448U, 0x2247e964U,
+    0xc4a8fc8cU, 0x1aa0f03fU, 0xd8567d2cU, 0xef223390U,
+    0xc787494eU, 0xc1d938d1U, 0xfe8ccaa2U, 0x3698d40bU,
+    0xcfa6f581U, 0x28a57adeU, 0x26dab78eU, 0xa43fadbfU,
+    0xe42c3a9dU, 0x0d507892U, 0x9b6a5fccU, 0x62547e46U,
+    0xc2f68d13U, 0xe890d8b8U, 0x5e2e39f7U, 0xf582c3afU,
+    0xbe9f5d80U, 0x7c69d093U, 0xa96fd52dU, 0xb3cf2512U,
+    0x3bc8ac99U, 0xa710187dU, 0x6ee89c63U, 0x7bdb3bbbU,
+    0x09cd2678U, 0xf46e5918U, 0x01ec9ab7U, 0xa8834f9aU,
+    0x65e6956eU, 0x7eaaffe6U, 0x0821bccfU, 0xe6ef15e8U,
+    0xd9bae79bU, 0xce4a6f36U, 0xd4ea9f09U, 0xd629b07cU,
+    0xaf31a4b2U, 0x312a3f23U, 0x30c6a594U, 0xc035a266U,
+    0x37744ebcU, 0xa6fc82caU, 0xb0e090d0U, 0x1533a7d8U,
+    0x4af10498U, 0xf741ecdaU, 0x0e7fcd50U, 0x2f1791f6U,
+    0x8d764dd6U, 0x4d43efb0U, 0x54ccaa4dU, 0xdfe49604U,
+    0xe39ed1b5U, 0x1b4c6a88U, 0xb8c12c1fU, 0x7f466551U,
+    0x049d5eeaU, 0x5d018c35U, 0x73fa8774U, 0x2efb0b41U,
+    0x5ab3671dU, 0x5292dbd2U, 0x33e91056U, 0x136dd647U,
+    0x8c9ad761U, 0x7a37a10cU, 0x8e59f814U, 0x89eb133cU,
+    0xeecea927U, 0x35b761c9U, 0xede11ce5U, 0x3c7a47b1U,
+    0x599cd2dfU, 0x3f55f273U, 0x791814ceU, 0xbf73c737U,
+    0xea53f7cdU, 0x5b5ffdaaU, 0x14df3d6fU, 0x867844dbU,
+    0x81caaff3U, 0x3eb968c4U, 0x2c382434U, 0x5fc2a340U,
+    0x72161dc3U, 0x0cbce225U, 0x8b283c49U, 0x41ff0d95U,
+    0x7139a801U, 0xde080cb3U, 0x9cd8b4e4U, 0x906456c1U,
+    0x617bcb84U, 0x70d532b6U, 0x74486c5cU, 0x42d0b857U,
+};
+
+const TUint32 Td2[256] = {
+    0xa75051f4U, 0x65537e41U, 0xa4c31a17U, 0x5e963a27U,
+    0x6bcb3babU, 0x45f11f9dU, 0x58abacfaU, 0x03934be3U,
+    0xfa552030U, 0x6df6ad76U, 0x769188ccU, 0x4c25f502U,
+    0xd7fc4fe5U, 0xcbd7c52aU, 0x44802635U, 0xa38fb562U,
+    0x5a49deb1U, 0x1b6725baU, 0x0e9845eaU, 0xc0e15dfeU,
+    0x7502c32fU, 0xf012814cU, 0x97a38d46U, 0xf9c66bd3U,
+    0x5fe7038fU, 0x9c951592U, 0x7aebbf6dU, 0x59da9552U,
+    0x832dd4beU, 0x21d35874U, 0x692949e0U, 0xc8448ec9U,
+    0x896a75c2U, 0x7978f48eU, 0x3e6b9958U, 0x71dd27b9U,
+    0x4fb6bee1U, 0xad17f088U, 0xac66c920U, 0x3ab47dceU,
+    0x4a1863dfU, 0x3182e51aU, 0x33609751U, 0x7f456253U,
+    0x77e0b164U, 0xae84bb6bU, 0xa01cfe81U, 0x2b94f908U,
+    0x68587048U, 0xfd198f45U, 0x6c8794deU, 0xf8b7527bU,
+    0xd323ab73U, 0x02e2724bU, 0x8f57e31fU, 0xab2a6655U,
+    0x2807b2ebU, 0xc2032fb5U, 0x7b9a86c5U, 0x08a5d337U,
+    0x87f23028U, 0xa5b223bfU, 0x6aba0203U, 0x825ced16U,
+    0x1c2b8acfU, 0xb492a779U, 0xf2f0f307U, 0xe2a14e69U,
+    0xf4cd65daU, 0xbed50605U, 0x621fd134U, 0xfe8ac4a6U,
+    0x539d342eU, 0x55a0a2f3U, 0xe132058aU, 0xeb75a4f6U,
+    0xec390b83U, 0xefaa4060U, 0x9f065e71U, 0x1051bd6eU,
+
+    0x8af93e21U, 0x063d96ddU, 0x05aedd3eU, 0xbd464de6U,
+    0x8db59154U, 0x5d0571c4U, 0xd46f0406U, 0x15ff6050U,
+    0xfb241998U, 0xe997d6bdU, 0x43cc8940U, 0x9e7767d9U,
+    0x42bdb0e8U, 0x8b880789U, 0x5b38e719U, 0xeedb79c8U,
+    0x0a47a17cU, 0x0fe97c42U, 0x1ec9f884U, 0x00000000U,
+    0x86830980U, 0xed48322bU, 0x70ac1e11U, 0x724e6c5aU,
+    0xfffbfd0eU, 0x38560f85U, 0xd51e3daeU, 0x3927362dU,
+    0xd9640a0fU, 0xa621685cU, 0x54d19b5bU, 0x2e3a2436U,
+    0x67b10c0aU, 0xe70f9357U, 0x96d2b4eeU, 0x919e1b9bU,
+    0xc54f80c0U, 0x20a261dcU, 0x4b695a77U, 0x1a161c12U,
+    0xba0ae293U, 0x2ae5c0a0U, 0xe0433c22U, 0x171d121bU,
+    0x0d0b0e09U, 0xc7adf28bU, 0xa8b92db6U, 0xa9c8141eU,
+    0x198557f1U, 0x074caf75U, 0xddbbee99U, 0x60fda37fU,
+    0x269ff701U, 0xf5bc5c72U, 0x3bc54466U, 0x7e345bfbU,
+    0x29768b43U, 0xc6dccb23U, 0xfc68b6edU, 0xf163b8e4U,
+    0xdccad731U, 0x85104263U, 0x22401397U, 0x112084c6U,
+    0x247d854aU, 0x3df8d2bbU, 0x3211aef9U, 0xa16dc729U,
+    0x2f4b1d9eU, 0x30f3dcb2U, 0x52ec0d86U, 0xe3d077c1U,
+    0x166c2bb3U, 0xb999a970U, 0x48fa1194U, 0x642247e9U,
+    0x8cc4a8fcU, 0x3f1aa0f0U, 0x2cd8567dU, 0x90ef2233U,
+    0x4ec78749U, 0xd1c1d938U, 0xa2fe8ccaU, 0x0b3698d4U,
+    0x81cfa6f5U, 0xde28a57aU, 0x8e26dab7U, 0xbfa43fadU,
+    0x9de42c3aU, 0x920d5078U, 0xcc9b6a5fU, 0x4662547eU,
+    0x13c2f68dU, 0xb8e890d8U, 0xf75e2e39U, 0xaff582c3U,
+    0x80be9f5dU, 0x937c69d0U, 0x2da96fd5U, 0x12b3cf25U,
+    0x993bc8acU, 0x7da71018U, 0x636ee89cU, 0xbb7bdb3bU,
+    0x7809cd26U, 0x18f46e59U, 0xb701ec9aU, 0x9aa8834fU,
+    0x6e65e695U, 0xe67eaaffU, 0xcf0821bcU, 0xe8e6ef15U,
+    0x9bd9bae7U, 0x36ce4a6fU, 0x09d4ea9fU, 0x7cd629b0U,
+    0xb2af31a4U, 0x23312a3fU, 0x9430c6a5U, 0x66c035a2U,
+    0xbc37744eU, 0xcaa6fc82U, 0xd0b0e090U, 0xd81533a7U,
+    0x984af104U, 0xdaf741ecU, 0x500e7fcdU, 0xf62f1791U,
+    0xd68d764dU, 0xb04d43efU, 0x4d54ccaaU, 0x04dfe496U,
+    0xb5e39ed1U, 0x881b4c6aU, 0x1fb8c12cU, 0x517f4665U,
+    0xea049d5eU, 0x355d018cU, 0x7473fa87U, 0x412efb0bU,
+    0x1d5ab367U, 0xd25292dbU, 0x5633e910U, 0x47136dd6U,
+    0x618c9ad7U, 0x0c7a37a1U, 0x148e59f8U, 0x3c89eb13U,
+    0x27eecea9U, 0xc935b761U, 0xe5ede11cU, 0xb13c7a47U,
+    0xdf599cd2U, 0x733f55f2U, 0xce791814U, 0x37bf73c7U,
+    0xcdea53f7U, 0xaa5b5ffdU, 0x6f14df3dU, 0xdb867844U,
+    0xf381caafU, 0xc43eb968U, 0x342c3824U, 0x405fc2a3U,
+    0xc372161dU, 0x250cbce2U, 0x498b283cU, 0x9541ff0dU,
+    0x017139a8U, 0xb3de080cU, 0xe49cd8b4U, 0xc1906456U,
+    0x84617bcbU, 0xb670d532U, 0x5c74486cU, 0x5742d0b8U,
+};
+
+const TUint32 Td3[256] = {
+    0xf4a75051U, 0x4165537eU, 0x17a4c31aU, 0x275e963aU,
+    0xab6bcb3bU, 0x9d45f11fU, 0xfa58abacU, 0xe303934bU,
+    0x30fa5520U, 0x766df6adU, 0xcc769188U, 0x024c25f5U,
+    0xe5d7fc4fU, 0x2acbd7c5U, 0x35448026U, 0x62a38fb5U,
+    0xb15a49deU, 0xba1b6725U, 0xea0e9845U, 0xfec0e15dU,
+    0x2f7502c3U, 0x4cf01281U, 0x4697a38dU, 0xd3f9c66bU,
+    0x8f5fe703U, 0x929c9515U, 0x6d7aebbfU, 0x5259da95U,
+    0xbe832dd4U, 0x7421d358U, 0xe0692949U, 0xc9c8448eU,
+    0xc2896a75U, 0x8e7978f4U, 0x583e6b99U, 0xb971dd27U,
+    0xe14fb6beU, 0x88ad17f0U, 0x20ac66c9U, 0xce3ab47dU,
+    0xdf4a1863U, 0x1a3182e5U, 0x51336097U, 0x537f4562U,
+    0x6477e0b1U, 0x6bae84bbU, 0x81a01cfeU, 0x082b94f9U,
+    0x48685870U, 0x45fd198fU, 0xde6c8794U, 0x7bf8b752U,
+    0x73d323abU, 0x4b02e272U, 0x1f8f57e3U, 0x55ab2a66U,
+    0xeb2807b2U, 0xb5c2032fU, 0xc57b9a86U, 0x3708a5d3U,
+    0x2887f230U, 0xbfa5b223U, 0x036aba02U, 0x16825cedU,
+    0xcf1c2b8aU, 0x79b492a7U, 0x07f2f0f3U, 0x69e2a14eU,
+    0xdaf4cd65U, 0x05bed506U, 0x34621fd1U, 0xa6fe8ac4U,
+    0x2e539d34U, 0xf355a0a2U, 0x8ae13205U, 0xf6eb75a4U,
+    0x83ec390bU, 0x60efaa40U, 0x719f065eU, 0x6e1051bdU,
+    0x218af93eU, 0xdd063d96U, 0x3e05aeddU, 0xe6bd464dU,
+    0x548db591U, 0xc45d0571U, 0x06d46f04U, 0x5015ff60U,
+    0x98fb2419U, 0xbde997d6U, 0x4043cc89U, 0xd99e7767U,
+    0xe842bdb0U, 0x898b8807U, 0x195b38e7U, 0xc8eedb79U,
+    0x7c0a47a1U, 0x420fe97cU, 0x841ec9f8U, 0x00000000U,
+    0x80868309U, 0x2bed4832U, 0x1170ac1eU, 0x5a724e6cU,
+    0x0efffbfdU, 0x8538560fU, 0xaed51e3dU, 0x2d392736U,
+    0x0fd9640aU, 0x5ca62168U, 0x5b54d19bU, 0x362e3a24U,
+    0x0a67b10cU, 0x57e70f93U, 0xee96d2b4U, 0x9b919e1bU,
+    0xc0c54f80U, 0xdc20a261U, 0x774b695aU, 0x121a161cU,
+    0x93ba0ae2U, 0xa02ae5c0U, 0x22e0433cU, 0x1b171d12U,
+    0x090d0b0eU, 0x8bc7adf2U, 0xb6a8b92dU, 0x1ea9c814U,
+    0xf1198557U, 0x75074cafU, 0x99ddbbeeU, 0x7f60fda3U,
+    0x01269ff7U, 0x72f5bc5cU, 0x663bc544U, 0xfb7e345bU,
+    0x4329768bU, 0x23c6dccbU, 0xedfc68b6U, 0xe4f163b8U,
+    0x31dccad7U, 0x63851042U, 0x97224013U, 0xc6112084U,
+    0x4a247d85U, 0xbb3df8d2U, 0xf93211aeU, 0x29a16dc7U,
+    0x9e2f4b1dU, 0xb230f3dcU, 0x8652ec0dU, 0xc1e3d077U,
+    0xb3166c2bU, 0x70b999a9U, 0x9448fa11U, 0xe9642247U,
+    0xfc8cc4a8U, 0xf03f1aa0U, 0x7d2cd856U, 0x3390ef22U,
+    0x494ec787U, 0x38d1c1d9U, 0xcaa2fe8cU, 0xd40b3698U,
+    0xf581cfa6U, 0x7ade28a5U, 0xb78e26daU, 0xadbfa43fU,
+    0x3a9de42cU, 0x78920d50U, 0x5fcc9b6aU, 0x7e466254U,
+    0x8d13c2f6U, 0xd8b8e890U, 0x39f75e2eU, 0xc3aff582U,
+    0x5d80be9fU, 0xd0937c69U, 0xd52da96fU, 0x2512b3cfU,
+    0xac993bc8U, 0x187da710U, 0x9c636ee8U, 0x3bbb7bdbU,
+    0x267809cdU, 0x5918f46eU, 0x9ab701ecU, 0x4f9aa883U,
+    0x956e65e6U, 0xffe67eaaU, 0xbccf0821U, 0x15e8e6efU,
+    0xe79bd9baU, 0x6f36ce4aU, 0x9f09d4eaU, 0xb07cd629U,
+    0xa4b2af31U, 0x3f23312aU, 0xa59430c6U, 0xa266c035U,
+    0x4ebc3774U, 0x82caa6fcU, 0x90d0b0e0U, 0xa7d81533U,
+    0x04984af1U, 0xecdaf741U, 0xcd500e7fU, 0x91f62f17U,
+    0x4dd68d76U, 0xefb04d43U, 0xaa4d54ccU, 0x9604dfe4U,
+    0xd1b5e39eU, 0x6a881b4cU, 0x2c1fb8c1U, 0x65517f46U,
+    0x5eea049dU, 0x8c355d01U, 0x877473faU, 0x0b412efbU,
+    0x671d5ab3U, 0xdbd25292U, 0x105633e9U, 0xd647136dU,
+    0xd7618c9aU, 0xa10c7a37U, 0xf8148e59U, 0x133c89ebU,
+    0xa927eeceU, 0x61c935b7U, 0x1ce5ede1U, 0x47b13c7aU,
+    0xd2df599cU, 0xf2733f55U, 0x14ce7918U, 0xc737bf73U,
+    0xf7cdea53U, 0xfdaa5b5fU, 0x3d6f14dfU, 0x44db8678U,
+    0xaff381caU, 0x68c43eb9U, 0x24342c38U, 0xa3405fc2U,
+    0x1dc37216U, 0xe2250cbcU, 0x3c498b28U, 0x0d9541ffU,
+    0xa8017139U, 0x0cb3de08U, 0xb4e49cd8U, 0x56c19064U,
+    0xcb84617bU, 0x32b670d5U, 0x6c5c7448U, 0xb85742d0U,
+};
+
+const TUint32 Td4[256] = {
+    0x52525252U, 0x09090909U, 0x6a6a6a6aU, 0xd5d5d5d5U,
+    0x30303030U, 0x36363636U, 0xa5a5a5a5U, 0x38383838U,
+    0xbfbfbfbfU, 0x40404040U, 0xa3a3a3a3U, 0x9e9e9e9eU,
+    0x81818181U, 0xf3f3f3f3U, 0xd7d7d7d7U, 0xfbfbfbfbU,
+    0x7c7c7c7cU, 0xe3e3e3e3U, 0x39393939U, 0x82828282U,
+    0x9b9b9b9bU, 0x2f2f2f2fU, 0xffffffffU, 0x87878787U,
+    0x34343434U, 0x8e8e8e8eU, 0x43434343U, 0x44444444U,
+    0xc4c4c4c4U, 0xdedededeU, 0xe9e9e9e9U, 0xcbcbcbcbU,
+    0x54545454U, 0x7b7b7b7bU, 0x94949494U, 0x32323232U,
+    0xa6a6a6a6U, 0xc2c2c2c2U, 0x23232323U, 0x3d3d3d3dU,
+    0xeeeeeeeeU, 0x4c4c4c4cU, 0x95959595U, 0x0b0b0b0bU,
+    0x42424242U, 0xfafafafaU, 0xc3c3c3c3U, 0x4e4e4e4eU,
+    0x08080808U, 0x2e2e2e2eU, 0xa1a1a1a1U, 0x66666666U,
+    0x28282828U, 0xd9d9d9d9U, 0x24242424U, 0xb2b2b2b2U,
+    0x76767676U, 0x5b5b5b5bU, 0xa2a2a2a2U, 0x49494949U,
+    0x6d6d6d6dU, 0x8b8b8b8bU, 0xd1d1d1d1U, 0x25252525U,
+    0x72727272U, 0xf8f8f8f8U, 0xf6f6f6f6U, 0x64646464U,
+    0x86868686U, 0x68686868U, 0x98989898U, 0x16161616U,
+    0xd4d4d4d4U, 0xa4a4a4a4U, 0x5c5c5c5cU, 0xccccccccU,
+    0x5d5d5d5dU, 0x65656565U, 0xb6b6b6b6U, 0x92929292U,
+    0x6c6c6c6cU, 0x70707070U, 0x48484848U, 0x50505050U,
+    0xfdfdfdfdU, 0xededededU, 0xb9b9b9b9U, 0xdadadadaU,
+    0x5e5e5e5eU, 0x15151515U, 0x46464646U, 0x57575757U,
+    0xa7a7a7a7U, 0x8d8d8d8dU, 0x9d9d9d9dU, 0x84848484U,
+    0x90909090U, 0xd8d8d8d8U, 0xababababU, 0x00000000U,
+    0x8c8c8c8cU, 0xbcbcbcbcU, 0xd3d3d3d3U, 0x0a0a0a0aU,
+    0xf7f7f7f7U, 0xe4e4e4e4U, 0x58585858U, 0x05050505U,
+    0xb8b8b8b8U, 0xb3b3b3b3U, 0x45454545U, 0x06060606U,
+    0xd0d0d0d0U, 0x2c2c2c2cU, 0x1e1e1e1eU, 0x8f8f8f8fU,
+    0xcacacacaU, 0x3f3f3f3fU, 0x0f0f0f0fU, 0x02020202U,
+    0xc1c1c1c1U, 0xafafafafU, 0xbdbdbdbdU, 0x03030303U,
+    0x01010101U, 0x13131313U, 0x8a8a8a8aU, 0x6b6b6b6bU,
+    0x3a3a3a3aU, 0x91919191U, 0x11111111U, 0x41414141U,
+    0x4f4f4f4fU, 0x67676767U, 0xdcdcdcdcU, 0xeaeaeaeaU,
+    0x97979797U, 0xf2f2f2f2U, 0xcfcfcfcfU, 0xcecececeU,
+    0xf0f0f0f0U, 0xb4b4b4b4U, 0xe6e6e6e6U, 0x73737373U,
+    0x96969696U, 0xacacacacU, 0x74747474U, 0x22222222U,
+    0xe7e7e7e7U, 0xadadadadU, 0x35353535U, 0x85858585U,
+    0xe2e2e2e2U, 0xf9f9f9f9U, 0x37373737U, 0xe8e8e8e8U,
+    0x1c1c1c1cU, 0x75757575U, 0xdfdfdfdfU, 0x6e6e6e6eU,
+    0x47474747U, 0xf1f1f1f1U, 0x1a1a1a1aU, 0x71717171U,
+    0x1d1d1d1dU, 0x29292929U, 0xc5c5c5c5U, 0x89898989U,
+    0x6f6f6f6fU, 0xb7b7b7b7U, 0x62626262U, 0x0e0e0e0eU,
+    0xaaaaaaaaU, 0x18181818U, 0xbebebebeU, 0x1b1b1b1bU,
+    0xfcfcfcfcU, 0x56565656U, 0x3e3e3e3eU, 0x4b4b4b4bU,
+    0xc6c6c6c6U, 0xd2d2d2d2U, 0x79797979U, 0x20202020U,
+    0x9a9a9a9aU, 0xdbdbdbdbU, 0xc0c0c0c0U, 0xfefefefeU,
+    0x78787878U, 0xcdcdcdcdU, 0x5a5a5a5aU, 0xf4f4f4f4U,
+    0x1f1f1f1fU, 0xddddddddU, 0xa8a8a8a8U, 0x33333333U,
+    0x88888888U, 0x07070707U, 0xc7c7c7c7U, 0x31313131U,
+    0xb1b1b1b1U, 0x12121212U, 0x10101010U, 0x59595959U,
+    0x27272727U, 0x80808080U, 0xececececU, 0x5f5f5f5fU,
+    0x60606060U, 0x51515151U, 0x7f7f7f7fU, 0xa9a9a9a9U,
+    0x19191919U, 0xb5b5b5b5U, 0x4a4a4a4aU, 0x0d0d0d0dU,
+    0x2d2d2d2dU, 0xe5e5e5e5U, 0x7a7a7a7aU, 0x9f9f9f9fU,
+    0x93939393U, 0xc9c9c9c9U, 0x9c9c9c9cU, 0xefefefefU,
+    0xa0a0a0a0U, 0xe0e0e0e0U, 0x3b3b3b3bU, 0x4d4d4d4dU,
+    0xaeaeaeaeU, 0x2a2a2a2aU, 0xf5f5f5f5U, 0xb0b0b0b0U,
+    0xc8c8c8c8U, 0xebebebebU, 0xbbbbbbbbU, 0x3c3c3c3cU,
+    0x83838383U, 0x53535353U, 0x99999999U, 0x61616161U,
+    0x17171717U, 0x2b2b2b2bU, 0x04040404U, 0x7e7e7e7eU,
+    0xbabababaU, 0x77777777U, 0xd6d6d6d6U, 0x26262626U,
+    0xe1e1e1e1U, 0x69696969U, 0x14141414U, 0x63636363U,
+    0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,
+};
+
+const TUint32 rcon[] = {
+	0x01000000, 0x02000000, 0x04000000, 0x08000000,
+	0x10000000, 0x20000000, 0x40000000, 0x80000000,
+	0x1B000000, 0x36000000, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
+};
+
+}		//	namespace RIJNDAEL_TABLE
+#endif	//	__RIJNDAELTABLES_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsafunction.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,138 @@
+/*
+* Copyright (c) 2003-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 <bigint.h>
+#include "keys.h"
+#include <asymmetrickeys.h>
+#include <cryptospi/cryptospidef.h>
+#include <cryptospi/cryptoparams.h>
+#include "rsafunction.h"
+#include "mont.h"
+
+using namespace CryptoSpi;
+
+// Public Encrypt
+void RSAFunction::EncryptL(const CKey& aPublicKey,
+	const TInteger& aInput, RInteger& aOutput)
+	{
+	const TInteger& N = aPublicKey.GetBigIntL(KRsaKeyParameterNUid);
+	const TInteger& E = aPublicKey.GetBigIntL(KRsaKeyParameterEUid);
+	FunctionL(N, E, aInput, aOutput);
+	}
+
+// Private Decrypt
+void RSAFunction::DecryptL(const CKey& aPrivateKey, const TInteger& aInput, RInteger& aOutput)
+	{
+	if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyStandardUid)
+		{
+		const TInteger& N = aPrivateKey.GetBigIntL(KRsaKeyParameterNUid);
+		const TInteger& D = aPrivateKey.GetBigIntL(KRsaKeyParameterDUid);
+		FunctionL(N, D, aInput, aOutput);
+		}
+	else if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyCRTUid)
+		{
+		FunctionCRTL(aPrivateKey, aInput, aOutput);
+		}
+	else
+		{
+		User::Leave(KErrNotSupported);
+		}
+	}
+
+// Private Encrypt
+void RSAFunction::SignL(const CKey& aPrivateKey, const TInteger& aInput, RInteger& aOutput)
+	{
+	if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyStandardUid)
+		{
+		const TInteger& N = aPrivateKey.GetBigIntL(KRsaKeyParameterNUid);
+		const TInteger& D = aPrivateKey.GetBigIntL(KRsaKeyParameterDUid);
+		FunctionL(N, D, aInput, aOutput);
+		}
+	else if (aPrivateKey.KeyProperty().iKeyType == KRsaPrivateKeyCRTUid)
+		{
+		FunctionCRTL(aPrivateKey, aInput, aOutput);
+		}
+	else
+	{
+		User::Leave(KErrNotSupported);
+	}
+}
+
+// Public Decrypt
+void RSAFunction::VerifyL(const CKey& aPublicKey,
+	const TInteger& aInput, RInteger& aOutput)
+	{
+	const TInteger& N = aPublicKey.GetBigIntL(KRsaKeyParameterNUid);
+	const TInteger& E = aPublicKey.GetBigIntL(KRsaKeyParameterEUid);
+	FunctionL(N, E, aInput, aOutput);
+	}
+	
+// The RSA Trapdoor Function
+void RSAFunction::FunctionL(const TInteger& aModulus, const TInteger& aExponent, 
+							 const TInteger& aBase, RInteger& aOutput)
+	{
+	IsInputValidL(aBase, aModulus);
+
+	aOutput = TInteger::ModularExponentiateL(aBase, aExponent, aModulus);
+	}
+
+// The CRT version of the RSA Trapdoor Function
+void RSAFunction::FunctionCRTL(const CKey& aPrivateKey,
+								const TInteger& aInput, RInteger& aOutput)
+	{
+	const TInteger& N = aPrivateKey.GetBigIntL(KRsaKeyParameterNUid);
+	IsInputValidL(aInput, N);
+
+	const TInteger& P = aPrivateKey.GetBigIntL(KRsaKeyParameterPUid);
+	const TInteger& Q = aPrivateKey.GetBigIntL(KRsaKeyParameterQUid);
+	const TInteger& DP = aPrivateKey.GetBigIntL(KRsaKeyParameterDPUid);
+	const TInteger& DQ = aPrivateKey.GetBigIntL(KRsaKeyParameterDQUid);
+	const TInteger& QInv = aPrivateKey.GetBigIntL(KRsaKeyParameterQInvUid);
+
+	CMontgomeryStructure* montP = CMontgomeryStructure::NewLC(P);
+	CMontgomeryStructure* montQ = CMontgomeryStructure::NewLC(Q);
+	
+	// m1 = c^(dP) mod(p)
+	RInteger inputReduced = aInput.ModuloL(P);
+	CleanupStack::PushL(inputReduced);
+	const TInteger& m1 = montP->ExponentiateL(inputReduced, DP);
+	CleanupStack::PopAndDestroy(&inputReduced);
+
+	// m2 = c^(dQ) mod(Q)
+	inputReduced = aInput.ModuloL(Q);
+	CleanupStack::PushL(inputReduced);
+	const TInteger& m2 = montQ->ExponentiateL(inputReduced, DQ);
+	CleanupStack::PopAndDestroy(&inputReduced);
+	
+	// Calculate CRT
+	// h = (m1-m2) qInv mod(p)
+	RInteger h = m1.MinusL(m2);
+	CleanupStack::PushL(h);
+	h *= QInv;
+	h %= P;
+
+	// m = m2 + q * h
+	h *= Q;
+	h += m2;
+
+	aOutput = h;
+	CleanupStack::Pop(&h);
+
+	CleanupStack::PopAndDestroy(montQ);
+	CleanupStack::PopAndDestroy(montP);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsafunction.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,85 @@
+/*
+* Copyright (c) 2003-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: 
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __RSAFUNCTION_H__
+#define __RSAFUNCTION_H__
+
+#include <e32base.h>
+#include "keys.h"
+
+using namespace CryptoSpi;
+
+class TInteger;
+
+class RSAFunction
+	{
+public:
+	static inline TBool IsInputValid(const TInteger& aInput, 
+		const TInteger& aModulus);
+	static inline void IsInputValidL(const TInteger& aInput, 
+		const TInteger& aModulus);
+	static void EncryptL(const CKey& aPublicKey,
+		const TInteger& aInput, RInteger& aOutput);
+	static void DecryptL(const CKey& aPrivateKey,
+		const TInteger& aInput, RInteger& aOutput);
+	static void SignL(const CKey& aPrivateKey,
+		const TInteger& aInput, RInteger& aOutput);
+	static void VerifyL(const CKey& aPublicKey,
+		const TInteger& aInput, RInteger& aOutput);
+private:
+	static void FunctionL(const TInteger& aModulus, const TInteger& aExponent,
+		const TInteger& aBase, RInteger& aOutput);
+	static void FunctionCRTL(const CKey& aPrivateKey,
+		const TInteger& aInput, RInteger& aOutput);
+private:
+	RSAFunction(void);
+	};
+
+/** Computes whether a given message representative is within the valid bounds
+ * for a given modulus, i.e. whether the message is representative within [0,n-1].
+ * @param aInput The message representative.
+ * @param aModulus The modulus.
+ * @return TBool representing whether or not the message representative is
+ * valid.
+ */
+TBool RSAFunction::IsInputValid(const TInteger& aInput, 
+	const TInteger& aModulus)
+	{
+	//See HAC 8.3 1.b
+	//Message (input) must be in the interval [0,n-1] (inclusive)
+	if( aInput.IsNegative() || aInput >= aModulus )
+		return EFalse;
+	else
+		return ETrue;
+	}
+
+void RSAFunction::IsInputValidL(const TInteger& aInput,
+	const TInteger& aModulus)
+	{
+	if(!IsInputValid(aInput, aModulus))
+		User::Leave(KErrArgument);
+	}
+
+#endif
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,178 @@
+/*
+* Copyright (c) 2006-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 "rsaimpl.h"
+#include "rsafunction.h"
+#include "pluginconfig.h"
+#include <cryptopanic.h>
+#include <cryptostrength.h>
+#include <securityerr.h>
+
+using namespace SoftwareCrypto;
+
+/* CRSAImpl */
+CRSAImpl::CRSAImpl(
+	TUid aCryptoMode,
+	TUid aPadding) :
+	CAsymmetricCipherImpl(aCryptoMode, aPadding)
+	{
+	}
+
+CRSAImpl* CRSAImpl::NewL(const CKey& aKey, TUid aCryptoMode, TUid aPadding)
+	{
+	CRSAImpl* self = CRSAImpl::NewLC(aKey, aCryptoMode, aPadding);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CRSAImpl* CRSAImpl::NewLC(const CKey& aKey, TUid aCryptoMode, TUid aPadding)
+	{
+	CRSAImpl* self = new(ELeave) CRSAImpl(aCryptoMode, aPadding);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+	
+CRSAImpl::~CRSAImpl()
+	{
+	}
+	
+TInt CRSAImpl::GetMaximumOutputLengthL() const
+	{
+	const TInteger& N = iKey->GetBigIntL(KRsaKeyParameterNUid);
+	
+	if (iCryptoMode.iUid == KCryptoModeDecrypt)
+		return N.ByteCount() - iPadding->MinPaddingLength();
+	else
+		return N.ByteCount();
+	}
+	
+TInt CRSAImpl::GetMaximumInputLengthL() const
+	{
+	const TInteger& N = iKey->GetBigIntL(KRsaKeyParameterNUid);
+	
+	if (iCryptoMode.iUid == KCryptoModeEncrypt)
+		return N.ByteCount() - iPadding->MinPaddingLength();
+	else
+		return N.ByteCount();
+	}
+	
+void CRSAImpl::ConstructL(const CKey& aKey)
+	{
+	const TInteger& N = aKey.GetBigIntL(KRsaKeyParameterNUid);
+	TCrypto::IsAsymmetricWeakEnoughL(N.BitCount());
+	CAsymmetricCipherImpl::ConstructL(aKey);
+	
+	if (! IsValidKeyLengthL(N.ByteCount()))
+		{
+		User::Leave(KErrKeySize);
+		}
+	}
+	
+CExtendedCharacteristics* CRSAImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+	
+const CExtendedCharacteristics* CRSAImpl::GetExtendedCharacteristicsL()
+	{
+	return CRSAImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRSAImpl::ImplementationUid() const
+	{
+	return KCryptoPluginRsaCipherUid;
+	}
+	
+void CRSAImpl::EncryptL(const TDesC8& aInput, TDes8& aOutput) const
+	{
+	__ASSERT_DEBUG(aOutput.MaxLength() >= GetMaximumOutputLengthL(), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+	__ASSERT_DEBUG(aInput.Length() <= GetMaximumInputLengthL(), User::Panic(KCryptoPanic, ECryptoPanicInputTooLarge));
+	
+	HBufC8* buf = HBufC8::NewLC(GetMaximumOutputLengthL());
+	TPtr8 ptr = buf->Des();
+	
+	iPadding->PadL(aInput, ptr);
+	RInteger input = RInteger::NewL(ptr);
+	CleanupStack::PushL(input);
+	
+	RInteger output;
+	RSAFunction::EncryptL(*iKey, input, output);
+	CleanupStack::PushL(output);
+	
+	aOutput.Append(*(output.BufferLC()));
+	CleanupStack::PopAndDestroy(4, buf); //BufferLC, output, input, buf
+	}
+
+void CRSAImpl::DecryptL(const TDesC8& aInput, TDes8& aOutput) const
+	{
+	__ASSERT_DEBUG(aOutput.MaxLength() >= GetMaximumOutputLengthL(), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+	__ASSERT_DEBUG(aInput.Length() <= GetMaximumInputLengthL(), User::Panic(KCryptoPanic, ECryptoPanicInputTooLarge));
+	
+	RInteger input = RInteger::NewL(aInput);
+	CleanupStack::PushL(input);
+	
+	RInteger output;
+	
+	RSAFunction::DecryptL(*iKey, input, output);
+	CleanupStack::PushL(output);
+	
+	TPtrC8 ptr = *(output.BufferLC());
+	iPadding->UnPadL(ptr, aOutput);
+	
+	CleanupStack::PopAndDestroy(3, &input); //BufferLC(), output, input
+	}
+
+void CRSAImpl::ProcessL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	if (iCryptoMode.iUid == KCryptoModeEncrypt)
+		{
+		EncryptL(aInput, aOutput);
+		}
+	else
+		{
+		DecryptL(aInput, aOutput);
+		}
+	}
+
+TBool CRSAImpl::IsValidKeyLengthL(TInt aKeyBytes) const
+	{
+	if (aKeyBytes < 1)
+		return EFalse;
+	
+	switch (iCryptoMode.iUid)
+		{
+		case KCryptoModeEncrypt:
+			// Check if GetMaximumInputLengthL() makes sense,
+			// if not the key length must be too small
+			if (GetMaximumInputLengthL() <= 0)
+				return EFalse;
+			break;
+		
+		case KCryptoModeDecrypt:
+			// Check if GetMaximumOutputLengthL() makes sense,
+			// if not the key length must be too small
+			if (GetMaximumOutputLengthL() <= 0)
+				return EFalse;
+			break;
+		}
+	return ETrue;
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,96 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __RSAIMPL_H__
+#define __RSAIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keys.h"
+#include "asymmetriccipherimpl.h"
+
+/**
+ * Implementation of RSA encryption as described in PKCS#1 v1.5.
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CRSAImpl) : public CAsymmetricCipherImpl
+		{
+	public:
+		/**
+		Creates an instance of an RSA asymmetric cipher plug-in.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a CRSAImpl instance
+		*/
+		static CRSAImpl* NewL(const CKey& aKey,
+			TUid aCryptoMode, TUid aPadding);
+
+		/**
+		Creates an instance of an RSA asymmetric cipher plug-in.
+		A pointer to the plug-in instance is placed on the cleanup stack.
+		@param aKey The key
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPadding The padding scheme to use None, SSLv3, PKCS#7
+		@return A pointer to a CRSAImpl instance
+		*/
+		static CRSAImpl* NewLC(const CKey& aKey,
+			TUid aCryptoMode, TUid aPadding);
+
+		// Override CAsymmetricCipherImpl virtual functions
+		TUid ImplementationUid() const;
+		TBool IsValidKeyLengthL(TInt aKeyBytes) const;
+		TInt GetMaximumInputLengthL() const;
+		TInt GetMaximumOutputLengthL() const;
+		void ProcessL(const TDesC8& aInput, TDes8& aOutput);
+		// End of CAsymmetricCipherImpl
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+			
+		// Destructor
+		~CRSAImpl();
+
+	private:
+		/**
+		Constructor
+		@param aCryptoMode Whether to encrypt or decrypt
+		@param aPaddingMode The padding mode to use. None, SSL, PKCS#7
+		*/
+		CRSAImpl(TUid aCryptoMode, TUid aPaddingMode);
+			
+		/// second phase of construction
+		void ConstructL(const CKey& aKey);
+		
+		/// for internal usage, called from ProcessL
+		void EncryptL(const TDesC8& aInput, TDes8& aOutput) const;
+		void DecryptL(const TDesC8& aInput, TDes8& aOutput) const;
+
+		};
+	}
+
+#endif // __RSAIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsakeypairgenimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,245 @@
+/*
+* Copyright (c) 2006-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: 
+* RSA Keypair implementation
+* RSA keypair generation implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "rsakeypairgenimpl.h"
+#include "pluginconfig.h"
+
+#include "keypair.h"
+#include <cryptospi/cryptospidef.h>
+
+#include "common/inlines.h"    // For TClassSwap
+
+using namespace SoftwareCrypto;
+
+/* CRSAKeyPairGenImpl */
+CRSAKeyPairGenImpl::CRSAKeyPairGenImpl()
+	{
+	}
+
+CRSAKeyPairGenImpl::~CRSAKeyPairGenImpl()
+	{
+	}
+
+CRSAKeyPairGenImpl* CRSAKeyPairGenImpl::NewL(void)
+	{
+	CRSAKeyPairGenImpl* self = CRSAKeyPairGenImpl::NewLC();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRSAKeyPairGenImpl* CRSAKeyPairGenImpl::NewLC(void)
+	{
+	CRSAKeyPairGenImpl* self = new(ELeave) CRSAKeyPairGenImpl();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CRSAKeyPairGenImpl::ConstructL(void)
+	{
+	CKeyPairGenImpl::ConstructL();
+	}
+
+CExtendedCharacteristics* CRSAKeyPairGenImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+}
+
+const CExtendedCharacteristics* CRSAKeyPairGenImpl::GetExtendedCharacteristicsL()
+	{
+	return CRSAKeyPairGenImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRSAKeyPairGenImpl::ImplementationUid() const
+	{
+	return KCryptoPluginRsaKeyPairGenUid;
+	}
+
+void CRSAKeyPairGenImpl::Reset()
+	{
+	// does nothing in this plugin
+	}
+
+void CRSAKeyPairGenImpl::GenerateKeyPairL(TInt aKeySize, const CCryptoParams& aKeyParameters, CKeyPair*& aKeyPair)
+	{
+	/*
+	 * extract e
+	 */ 
+	const TInt aKeyType = aKeyParameters.GetTIntL(KRsaKeyTypeUid);
+	const TInt aPublicExponent = aKeyParameters.GetTIntL(KRsaKeyParameterEUid);
+
+	RInteger e = RInteger::NewL(aPublicExponent);
+	CleanupStack::PushL(e);
+
+	/*
+	 * calculate p, q, n & d
+	 */ 
+	RInteger p;
+	RInteger q;
+	
+	//these make sure n is a least aKeySize long
+	TInt pbits=(aKeySize+1)/2;
+	TInt qbits=aKeySize-pbits;
+
+	//generate a prime p such that GCD(e,p-1) == 1
+	for (;;)
+		{
+		p = RInteger::NewPrimeL(pbits,TInteger::ETop2BitsSet);
+		CleanupStack::PushL(p);
+		--p;
+
+		RInteger gcd = e.GCDL(p);
+		if( gcd == 1 )
+			{
+			++p;
+			gcd.Close();
+			//p is still on cleanup stack
+			break;
+			}
+		CleanupStack::PopAndDestroy(&p);
+		gcd.Close();
+		}
+
+	//generate a prime q such that GCD(e,q-1) == 1 && (p != q)
+	for (;;)
+		{
+		q = RInteger::NewPrimeL(qbits,TInteger::ETop2BitsSet);
+		CleanupStack::PushL(q);
+		--q;
+
+		RInteger gcd = e.GCDL(q);
+		if( gcd == 1 )
+			{
+			++q;
+			if( p != q )
+				{
+				gcd.Close();
+				//q is still on cleanup stack
+				break;
+				}
+			}
+		CleanupStack::PopAndDestroy(&q);
+		gcd.Close();
+		}
+		
+	//make sure p > q
+	if ( p < q)
+		{
+		TClassSwap(p,q);
+		}
+
+	//calculate n = p * q
+	RInteger n = p.TimesL(q);
+	CleanupStack::PushL(n);
+
+	--p;
+	--q;
+
+	//temp = (p-1)(q-1)
+	RInteger temp = p.TimesL(q);
+	CleanupStack::PushL(temp);
+
+	//e * d = 1 mod ((p-1)(q-1))
+	//d = e^(-1) mod ((p-1)(q-1))
+	RInteger d = e.InverseModL(temp);
+	CleanupStack::PopAndDestroy(&temp); //temp
+	CleanupStack::PushL(d);
+
+	/*
+	 * create private key depending on aKeyType
+	 */ 
+	CCryptoParams* privateKeyParameters = CCryptoParams::NewLC();
+	privateKeyParameters->AddL(n, KRsaKeyParameterNUid);
+	TKeyProperty* privateKeyProperties = NULL;
+	TKeyProperty privateKeyProperties_RsaPrivateKeyCRT = {KRSAKeyPairGeneratorUid, KCryptoPluginRsaKeyPairGenUid,
+									KRsaPrivateKeyCRTUid, KNonEmbeddedKeyUid };
+	TKeyProperty privateKeyProperties_RsaPrivateKeyStandard = {KRSAKeyPairGeneratorUid, KCryptoPluginRsaKeyPairGenUid,
+									KRsaPrivateKeyStandardUid, KNonEmbeddedKeyUid };
+
+	CCryptoParams*publicKeyParameters = CCryptoParams::NewLC();
+	publicKeyParameters->AddL(n, KRsaKeyParameterNUid);
+	publicKeyParameters->AddL(e, KRsaKeyParameterEUid);
+	TKeyProperty publicKeyProperties = {KRSAKeyPairGeneratorUid, KCryptoPluginRsaKeyPairGenUid,
+									KRsaPublicKeyUid, KNonEmbeddedKeyUid };
+
+	if (aKeyType == KRsaPrivateKeyCRT)			// cleanup stack contains e, p, q, n, d and privateKeyParameters
+	{
+
+		/*
+		 * calculate dP, dQ and qInv
+		 */ 
+		//calculate dP = d mod (p-1)
+		RInteger dP = d.ModuloL(p); //p is still p-1
+		CleanupStack::PushL(dP);
+		privateKeyParameters->AddL(dP, KRsaKeyParameterDPUid);
+		CleanupStack::PopAndDestroy(&dP);
+
+		//calculate dQ = d mod (q-1)
+		RInteger dQ = d.ModuloL(q); //q is still q-1
+		CleanupStack::PushL(dQ);
+		privateKeyParameters->AddL(dQ, KRsaKeyParameterDQUid);
+		CleanupStack::PopAndDestroy(&dQ);
+
+		++p;
+		++q;
+		//calculate inverse of qInv = q^(-1)mod(p)
+		RInteger qInv = q.InverseModL(p);
+		CleanupStack::PushL(qInv);
+		privateKeyParameters->AddL(qInv, KRsaKeyParameterQInvUid);
+		CleanupStack::PopAndDestroy(&qInv);
+		
+		privateKeyParameters->AddL(p, KRsaKeyParameterPUid);
+		privateKeyParameters->AddL(q, KRsaKeyParameterQUid);
+		
+		privateKeyProperties = &privateKeyProperties_RsaPrivateKeyCRT;
+	}
+	else if (aKeyType == KRsaPrivateKeyStandard)
+	{
+		privateKeyParameters->AddL(d, KRsaKeyParameterDUid);
+		privateKeyProperties = &privateKeyProperties_RsaPrivateKeyStandard;
+	}
+	else
+	{
+		User::Leave(KErrNotSupported);
+	}
+	// cleanup stack contains e, p, q, n, d and privateKeyParameters
+	CKey* privateKey = CKey::NewL(*privateKeyProperties, *privateKeyParameters);
+	CleanupStack::PushL(privateKey);
+
+	/*
+	 * create public key
+	 */
+	CKey* publicKey = CKey::NewL(publicKeyProperties, *publicKeyParameters);
+	CleanupStack::PushL(publicKey);
+
+	/*
+	* create the key pair
+	*/
+	aKeyPair = CKeyPair::NewL(publicKey, privateKey);
+
+	CleanupStack::Pop(2, privateKey); //privateKey and publicKey
+	CleanupStack::PopAndDestroy(7, &e); //e, p, q, n, d, privateKeyParameters and publicKeyParameters
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsakeypairgenimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,70 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __RSAKEYPAIRGENIMPL_H__
+#define __RSAKEYPAIRGENIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include "keypairgenimpl.h"
+
+/**
+ * Implementation of RSA key pair generation as described in PKCS#1 v1.5.
+ */
+namespace SoftwareCrypto
+	{
+	NONSHARABLE_CLASS(CRSAKeyPairGenImpl) : public CKeyPairGenImpl
+		{
+	public:
+	
+		static CRSAKeyPairGenImpl* NewL();
+		static CRSAKeyPairGenImpl* NewLC();
+
+		// from MPlugin
+		void Reset();
+
+		// from MKeyPairGenerator
+		void GenerateKeyPairL(TInt aKeySize, const CCryptoParams& aKeyParameters, CKeyPair*& aKeyPair);
+		
+		// Override CKeyPairGenImpl virtual functions
+		TUid ImplementationUid() const;
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+		// Destructor
+		~CRSAKeyPairGenImpl();
+
+	private:
+		/**
+		Constructor
+		*/
+		CRSAKeyPairGenImpl();
+			
+		/// second phase of construction
+		void ConstructL();
+		};
+	}
+
+#endif // __RSAKEYPAIRGENIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsasignerimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,132 @@
+/*
+* Copyright (c) 2006-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 "rsasignerimpl.h"
+#include "pluginconfig.h"
+#include "rsafunction.h"
+
+using namespace SoftwareCrypto;
+
+// Implementation of CRSASignerImpl 
+CRSASignerImpl* CRSASignerImpl::NewL(const CKey& aKey, TUid aPaddingMode)
+	{
+	CRSASignerImpl* self = CRSASignerImpl::NewLC(aKey, aPaddingMode);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRSASignerImpl* CRSASignerImpl::NewLC(const CKey& aKey, TUid aPaddingMode)
+	{
+	CRSASignerImpl* self = new(ELeave) CRSASignerImpl(aPaddingMode);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CRSASignerImpl::CRSASignerImpl(TUid aPaddingMode) 
+	: iPaddingMode(aPaddingMode)
+	{
+	}
+
+CRSASignerImpl::~CRSASignerImpl()
+	{
+	delete iPadding;
+	}
+
+void CRSASignerImpl::ConstructL(const CKey& aKey)
+	{
+	CSignerImpl::ConstructL(aKey);
+	SetPaddingModeL(iPaddingMode);
+	}
+
+CExtendedCharacteristics* CRSASignerImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CRSASignerImpl::GetExtendedCharacteristicsL()
+	{
+	return CRSASignerImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRSASignerImpl::ImplementationUid() const
+	{
+	return KCryptoPluginRsaSignerUid;
+	}
+
+void CRSASignerImpl::SetKeyL(const CKey& aPrivateKey) 
+	{
+	DoSetKeyL(aPrivateKey);
+	Reset();
+	}
+
+void CRSASignerImpl::SetPaddingModeL(TUid aPaddingMode)
+	{
+	CPadding* padding(0);
+	switch (aPaddingMode.iUid)
+		{
+		case KPaddingModeNone:
+			padding = CPaddingNone::NewL(GetMaximumOutputLengthL());
+			break;
+		case KPaddingModePkcs1_v1_5_Signature:
+			padding = CPaddingPKCS1Signature::NewL(GetMaximumOutputLengthL());
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+		
+	delete iPadding;
+	iPadding = padding;
+	iPaddingMode = aPaddingMode;
+	Reset();
+	}
+
+TInt CRSASignerImpl::GetMaximumInputLengthL() const
+	{
+	return GetMaximumOutputLengthL() - iPadding->MinPaddingLength();	
+	}
+
+TInt CRSASignerImpl::GetMaximumOutputLengthL() const
+	{
+	const TInteger& paramN = iKey->GetBigIntL(KRsaKeyParameterNUid);
+	return paramN.ByteCount();	
+	}
+
+void CRSASignerImpl::SignL(const TDesC8& aInput, CCryptoParams& aSignature) 
+	{
+	HBufC8* buf = HBufC8::NewLC(GetMaximumOutputLengthL());
+	TPtr8 ptr = buf->Des();
+	
+	//The following will panic if aInput is larger than MaxOutputLength() It is
+	//likely that the caller has passed in something that has not been hashed.
+	//This is a programming, and likely a security error, in client code, not a
+	//problem here.
+	iPadding->PadL(aInput, ptr);
+
+	RInteger input = RInteger::NewL(ptr);
+	CleanupClosePushL(input);
+	RInteger output;
+
+	RSAFunction::SignL(*iKey, input, output);
+	CleanupClosePushL(output);
+
+	aSignature.AddL(output, KRsaSignatureParameterSUid);
+	CleanupStack::PopAndDestroy(3, buf); //input, buf
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsasignerimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,96 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __RSASIGNERIMPL_H__
+#define __RSASIGNERIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+
+#include "signerimpl.h"
+#include "common/inlines.h"
+
+/**
+ * Implementation of RSA signing
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CRSASignerImpl) : public CSignerImpl
+		{
+	public:
+		/**
+		Creates an instance of an RSA signer plug-in.
+		@param aKey The private key used to sign.
+		@param aPaddingMode The padding mode
+		@return A pointer to a CRSASignerImpl instance
+		*/
+		static CRSASignerImpl* NewL(const CKey& aKey, TUid aPaddingMode);
+		
+		/**
+		Creates an instance of an RSA signer plug-in.
+		@param aKey The private key used to sign.
+		@param aPaddingMode The padding mode
+		@return A pointer to a CRSASignerImpl instance
+		*/
+		static CRSASignerImpl* NewLC(const CKey& aKey, TUid aPaddingMode);
+		
+		// Override CSignerImpl virtual functions
+		TUid ImplementationUid() const;
+		// End of CSignerImpl
+		
+		// Override MSignatureBase virtual functions
+		void SetKeyL(const CKey& aPrivateKey);
+		void SetPaddingModeL(TUid aPaddingMode);
+		TInt GetMaximumInputLengthL() const;
+		TInt GetMaximumOutputLengthL() const;
+		// End of MSignatureBase
+		
+		// Override MSigner virtual functions
+		void SignL(const TDesC8& aInput, CCryptoParams& aSignature);
+		// End of MSigner
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+		/// Destructor
+		~CRSASignerImpl();
+
+	protected:
+		/// Constructor
+		CRSASignerImpl(TUid aPaddingMode);
+
+		/// second phase of construction
+		virtual void ConstructL(const CKey& aKey);
+
+	protected:
+		/// the current padding scheme
+		TUid iPaddingMode;
+		CPadding* iPadding;
+		};
+	}
+
+#endif // __RSASIGNERIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaverifyimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,143 @@
+/*
+* Copyright (c) 2006-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 "rsaverifyimpl.h"
+#include "pluginconfig.h"
+#include "rsafunction.h"
+
+using namespace SoftwareCrypto;
+
+// Implementation of CRSAVerifierImpl
+CRSAVerifierImpl* CRSAVerifierImpl::NewL(const CKey& aKey, TUid aPaddingMode)
+	{
+	CRSAVerifierImpl* self = CRSAVerifierImpl::NewLC(aKey, aPaddingMode);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CRSAVerifierImpl* CRSAVerifierImpl::NewLC(const CKey& aKey, TUid aPaddingMode)
+	{
+	CRSAVerifierImpl* self = new(ELeave) CRSAVerifierImpl(aPaddingMode);
+	CleanupStack::PushL(self);
+	self->ConstructL(aKey);
+	return self;
+	}
+
+CRSAVerifierImpl::CRSAVerifierImpl(TUid aPaddingMode)
+	: iPaddingMode(aPaddingMode)
+	{
+	}
+
+CRSAVerifierImpl::~CRSAVerifierImpl()
+	{
+	delete iPadding;
+	}
+	
+void CRSAVerifierImpl::ConstructL(const CKey& aKey)
+	{
+	CVerifierImpl::ConstructL(aKey);
+	SetPaddingModeL(iPaddingMode);
+	}
+	
+CExtendedCharacteristics* CRSAVerifierImpl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CRSAVerifierImpl::GetExtendedCharacteristicsL()
+	{
+	return CRSAVerifierImpl::CreateExtendedCharacteristicsL();
+	}
+
+TUid CRSAVerifierImpl::ImplementationUid() const
+	{
+	return KCryptoPluginRsaVerifierUid;
+	}
+
+void CRSAVerifierImpl::SetPaddingModeL(TUid aPaddingMode) 
+	{
+	CPadding* padding(0);
+	switch (aPaddingMode.iUid)
+		{
+		case KPaddingModeNone:
+			padding = CPaddingNone::NewL(GetMaximumOutputLengthL());
+			break;
+		case KPaddingModePkcs1_v1_5_Signature:
+			padding = CPaddingPKCS1Signature::NewL(GetMaximumOutputLengthL());
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+	delete iPadding;
+	iPadding = padding;
+	iPaddingMode = aPaddingMode;
+	Reset();	
+	}
+
+void CRSAVerifierImpl::SetKeyL(const CKey& aPublicKey)
+	{
+	DoSetKeyL(aPublicKey);
+	Reset();	
+	}
+
+TInt CRSAVerifierImpl::GetMaximumInputLengthL() const
+	{
+	return GetMaximumOutputLengthL() - iPadding->MinPaddingLength();	
+	}
+
+TInt CRSAVerifierImpl::GetMaximumOutputLengthL() const
+	{
+	const TInteger& paramN = iKey->GetBigIntL(KRsaKeyParameterNUid);
+	return paramN.ByteCount();	
+	}
+
+void CRSAVerifierImpl::VerifyL(const TDesC8& aInput, const CCryptoParams& aSignature, TBool& aVerificationResult)
+	{
+	HBufC8* output = NULL;
+	InverseSignL(output, aSignature);
+	CleanupStack::PushL(output);
+
+	// is the original hash the same as the hash extracted from the signature
+	aVerificationResult = EFalse;
+	if (!output->Compare(aInput))
+		{
+		aVerificationResult = ETrue;
+		}
+	CleanupStack::PopAndDestroy(output);
+	}
+
+void CRSAVerifierImpl::InverseSignL(HBufC8*& aOutput, const CCryptoParams& aSignature)
+	{
+	// extract the original hash from the signature
+	const TInteger& signature = aSignature.GetBigIntL(KRsaSignatureParameterSUid);
+	RInteger output;
+	RSAFunction::VerifyL(*iKey, signature, output);
+	CleanupClosePushL(output);
+
+	// format the extracted hash so it can be compared with the original hash
+	HBufC8* paddedHashPtr = output.BufferLC();
+	aOutput = HBufC8::NewLC(GetMaximumOutputLengthL());
+	TPtr8 unpaddedHash = aOutput->Des();
+
+	iPadding->UnPadL(*paddedHashPtr, unpaddedHash);
+
+	CleanupStack::Pop(aOutput);
+	CleanupStack::PopAndDestroy(2, &output);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/rsaverifyimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,97 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __RSAVERIFYIMPL_H__
+#define __RSAVERIFYIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+
+#include "verifierimpl.h"
+#include "common/inlines.h"
+
+/**
+ * Implementation of RSA verification
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CRSAVerifierImpl) : public CVerifierImpl
+		{
+	public:
+		/**
+		Creates an instance of an RSA verifier plug-in.
+		@param aKey The key
+		@param aPaddingMode The padding mode
+		@return A pointer to a CRSAVerifierImpl instance
+		*/
+		static CRSAVerifierImpl* NewL(const CKey& aKey, TUid aPaddingMode);
+
+		/**
+		Creates an instance of an RSA verifier plug-in.
+		@param aKey The key
+		@param aPaddingMode The padding mode
+		@return A pointer to a CRSAVerifierImpl instance
+		*/
+		static CRSAVerifierImpl* NewLC(const CKey& aKey, TUid aPaddingMode);
+		
+		// Override CVerifierImpl virtual functions
+		TUid ImplementationUid() const;
+		// End of CVerifierImpl
+		
+		// Override MSignatureBase virtual functions
+		void SetPaddingModeL(TUid aPaddingMode);
+		void SetKeyL(const CKey& aPublicKey);
+		TInt GetMaximumInputLengthL() const;
+		TInt GetMaximumOutputLengthL() const;
+		// End of MSignatureBase
+
+		// Override MSigner virtual functions
+		void VerifyL(const TDesC8& aInput, const CCryptoParams& aSignature, TBool& aVerificationResult);
+		void InverseSignL(HBufC8*& aOutput, const CCryptoParams& aSignature);
+		// End of MSigner
+		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		
+		/// Destructor
+		~CRSAVerifierImpl();
+		
+	protected:
+		/// Constructor
+		CRSAVerifierImpl(TUid aPaddingMode);
+		
+		/// second phase of construction
+		virtual void ConstructL(const CKey& aKey);
+		
+	protected:
+		/// the current padding scheme
+		TUid iPaddingMode;
+		CPadding* iPadding;
+		};
+	}
+
+#endif // __RSAVERIFYIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha1impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,741 @@
+/*
+* Copyright (c) 2006-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: 
+* software sha1 implementation
+* software sha1 implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "sha1impl.h"
+
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+#define EXPANDLOOP
+
+
+using namespace SoftwareCrypto;
+	
+CSHA1Impl* CSHA1Impl::NewL()
+	{
+	CSHA1Impl* self=new (ELeave) CSHA1Impl();
+	self->Reset();
+	return self;						
+	}
+														
+CSHA1Impl* CSHA1Impl::NewLC()
+	{
+	CSHA1Impl* self=NewL();
+	CleanupStack::PushL(self);
+	return self;						
+	}
+														
+CSHA1Impl::CSHA1Impl() : iHash(KSHA1HashSize)
+	{		
+	}
+	
+CSHA1Impl::CSHA1Impl(const CSHA1Impl& aSHA1Impl)
+: iHash(aSHA1Impl.iHash),iA(aSHA1Impl.iA),iB(aSHA1Impl.iB),iC(aSHA1Impl.iC),iD(aSHA1Impl.iD),iE(aSHA1Impl.iE),
+  iNl(aSHA1Impl.iNl),iNh(aSHA1Impl.iNh)
+	{
+	(void)Mem::Copy(iData, aSHA1Impl.iData, KSHA1BlockSize*5);
+	}
+	
+CSHA1Impl::~CSHA1Impl()
+	{	
+	}
+	
+void CSHA1Impl::Reset()
+	{
+	iA=0x67452301;
+	iB=0xefcdab89;
+	iC=0x98badcfe;
+	iD=0x10325476;
+	iE=0xc3d2e1f0;
+	iNh=0;
+	iNl=0;
+	}
+	
+void CSHA1Impl::Close()
+	{
+	delete this;	
+	}
+
+MHash* CSHA1Impl::ReplicateL()
+	{	 
+	return CSHA1Impl::NewL();
+	}
+	
+MHash* CSHA1Impl::CopyL()
+	{
+	return new(ELeave) CSHA1Impl(*this);	
+	}
+
+TUid CSHA1Impl::ImplementationUid()
+	{
+	return KCryptoPluginSha1Uid;
+	}
+
+void CSHA1Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+	for (TInt i=0;i<hashNum;i++)
+		{
+		if (KHashCharacteristics[i]->cmn.iImplementationUID == ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KHashCharacteristics[i];
+			break;
+			}
+		}	
+	}
+
+CExtendedCharacteristics* CSHA1Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CSHA1Impl::GetExtendedCharacteristicsL()
+	{
+	return CSHA1Impl::CreateExtendedCharacteristicsL();
+	}
+
+TPtrC8 CSHA1Impl::Hash(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	DoUpdate(aMessage.Ptr(),aMessage.Size());
+	StoreState();
+	DoFinal();
+	ptr.Set(iHash);
+	RestoreState();
+	return ptr;
+	}
+	
+void CSHA1Impl::Update(const TDesC8& aMessage)
+	{
+	DoUpdate(aMessage.Ptr(),aMessage.Size());	
+	}
+	
+TPtrC8 CSHA1Impl::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if (aMessage!=KNullDesC8())
+		{
+		DoUpdate(aMessage.Ptr(),aMessage.Size());			
+		}
+	DoFinal();
+	ptr.Set(iHash);
+	Reset();
+	return ptr;
+	}
+
+
+// This assumes a big-endian architecture
+void CSHA1Impl::DoUpdate(const TUint8* aData,TUint aLength)
+	{
+	while((aLength / 4) > 0 && (iNl % 4 == 0))
+		{
+		iData[iNl>>2] = aData[0] << 24 | aData[1] << 16 | aData[2] << 8 | aData[3];
+		iNl+=4;
+		aData+=4;
+		aLength-=4;
+		if(iNl==64) 
+			{
+			Block();
+			iNh+=64;
+			iNl=0;
+			}
+		}
+
+	while(aLength--)
+		{
+		switch (iNl&3) 
+			{
+			case 0:
+				iData[iNl>>2]=((TUint)(*aData))<<24;
+				break;
+			case 1:
+				iData[iNl>>2]|=((TUint)(*aData))<<16;
+				break;
+			case 2:
+				iData[iNl>>2]|=((TUint)(*aData))<<8;
+				break;
+			case 3:
+				iData[iNl>>2]|=((TUint)(*aData));
+				break;
+			default:
+				break;
+			};
+			aData++;
+			iNl++;
+			if(iNl==64) 
+				{
+				Block();
+				iNh+=64;
+				iNl=0;
+				}
+		}
+	}
+
+static inline TUint CSHA1_F(const TUint x,const TUint y,const TUint z)
+	{
+	return (x&y) | (~x&z);
+	}
+
+static inline TUint CSHA1_G(const TUint x,const TUint y,const TUint z)
+	{
+	return x^y^z;
+	}
+
+static inline TUint CSHA1_H(const TUint x,const TUint y,const TUint z)
+	{
+	return (x&y) | (x&z) | (y&z);
+	}
+
+/*static inline TUint CSHA1_I(const TUint x,const TUint y,const TUint z)
+	{
+	return x^y^z;
+	}*/
+
+#ifdef EXPANDLOOP
+
+#ifdef MACRO
+
+#define CSHA1_16(x,y,z,u,t,v,w)					v=CMD_R(x,5)+CSHA1_F(y,z,u)+t+w+0x5a827999;\
+												y=CMD_R(y,30);t=v;
+#define CSHA1_20(x,y,z,u,t,v,w0,w3,w8,w14,w16)  v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												CSHA1_16(x,y,z,u,t,v,w0);
+#define CSHA1_40(x,y,z,u,t,v,w0,w3,w8,w14,w16)	v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												v=CMD_R(x,5)+CSHA1_G(y,z,u)+t+w0+0x6ed9eba1;\
+												y=CMD_R(y,30);t=v;
+#define CSHA1_60(x,y,z,u,t,v,w0,w3,w8,w14,w16)	v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												v=CMD_R(x,5)+CSHA1_H(y,z,u)+t+w0+0x8f1bbcdc;\
+												y=CMD_R(y,30);t=v;
+#define CSHA1_80(x,y,z,u,t,v,w0,w3,w8,w14,w16)	v=w3^w8^w14^w16;w0=CMD_R(v,1);\
+												v=CMD_R(x,5)+CSHA1_G(y,z,u)+t+w0+0xca62c1d6;\
+												y=CMD_R(y,30);t=v;
+#else
+
+static inline void CSHA1_16(const TUint x, TUint& y, const TUint z,
+							const TUint u, TUint& t, TUint& v, const TUint w)
+	{
+	v = CMD_R(x,5) + CSHA1_F(y,z,u) + t + w + 0x5a827999;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+static inline void CSHA1_20(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	CSHA1_16(x,y,z,u,t,v,w0);
+	}
+
+static inline void CSHA1_40(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	v = CMD_R(x,5) + CSHA1_G(y,z,u) + t + w0 + 0x6ed9eba1;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+static inline void CSHA1_60(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	v = CMD_R(x,5) + CSHA1_H(y,z,u) + t + w0 + 0x8f1bbcdc;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+static inline void CSHA1_80(const TUint x,TUint& y,const TUint z,
+							const TUint u,TUint& t,TUint& v,
+							TUint& w0,const TUint w3,const TUint w8,
+							const TUint w14,const TUint w16)
+	{
+	v = w3 ^ w8 ^ w14 ^ w16;
+	w0 = CMD_R(v,1);
+	v = CMD_R(x,5) + CSHA1_G(y,z,u) + t + w0 + 0xca62c1d6;
+	y = CMD_R(y,30);
+	t = v;
+	}
+
+#endif // MACRO
+#endif // EXPANDLOOP
+
+#ifdef WEIDAI
+
+template <class T> inline T rotlFixed(T x, unsigned int y)
+{
+	ASSERT(y < sizeof(T)*8);
+	return (x<<y) | (x>>(sizeof(T)*8-y));
+}
+
+template<> inline TUint32 rotlFixed<TUint32>(TUint32 x, unsigned int y)
+{
+	ASSERT(y < 32);
+	return y ? CMD_R(x, y) : x;
+}
+
+#define blk0(i) (W[i] = iData[i])
+#define blk1(i) (W[i&15] = rotlFixed(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15],1))
+
+#define f1(x,y,z) (z^(x&(y^z)))
+#define f2(x,y,z) (x^y^z)
+#define f3(x,y,z) ((x&y)|(z&(x|y)))
+#define f4(x,y,z) (x^y^z)
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=f1(w,x,y)+blk0(i)+0x5A827999+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R1(v,w,x,y,z,i) z+=f1(w,x,y)+blk1(i)+0x5A827999+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R2(v,w,x,y,z,i) z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R3(v,w,x,y,z,i) z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R4(v,w,x,y,z,i) z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rotlFixed(v,5);w=rotlFixed(w,30);
+
+#endif // WEIDAI
+
+void CSHA1Impl::Block()
+	{
+#ifdef WEIDAI
+	TUint32 W[16];
+    /* Copy context->state[] to working vars */
+    TUint32 a = iA;
+    TUint32 b = iB;
+    TUint32 c = iC;
+    TUint32 d = iD;
+    TUint32 e = iE;
+    
+	/* 4 rounds of 20 operations each. Loop unrolled. */
+    
+	R0(a,b,c,d,e, 0); 
+	R0(e,a,b,c,d, 1); 
+	R0(d,e,a,b,c, 2); 
+	R0(c,d,e,a,b, 3);
+    R0(b,c,d,e,a, 4); 
+	R0(a,b,c,d,e, 5); 
+	R0(e,a,b,c,d, 6); 
+	R0(d,e,a,b,c, 7);
+    R0(c,d,e,a,b, 8); 
+	R0(b,c,d,e,a, 9); 
+	R0(a,b,c,d,e,10); 
+	R0(e,a,b,c,d,11);
+    R0(d,e,a,b,c,12); 
+	R0(c,d,e,a,b,13); 
+	R0(b,c,d,e,a,14); 
+	R0(a,b,c,d,e,15);
+
+    R1(e,a,b,c,d,16); 
+	R1(d,e,a,b,c,17); 
+	R1(c,d,e,a,b,18); 
+	R1(b,c,d,e,a,19);
+
+    R2(a,b,c,d,e,20); 
+	R2(e,a,b,c,d,21); 
+	R2(d,e,a,b,c,22); 
+	R2(c,d,e,a,b,23);
+    R2(b,c,d,e,a,24); 
+	R2(a,b,c,d,e,25); 
+	R2(e,a,b,c,d,26); 
+	R2(d,e,a,b,c,27);
+    R2(c,d,e,a,b,28); 
+	R2(b,c,d,e,a,29); 
+	R2(a,b,c,d,e,30); 
+	R2(e,a,b,c,d,31);
+    R2(d,e,a,b,c,32); 
+	R2(c,d,e,a,b,33); 
+	R2(b,c,d,e,a,34); 
+	R2(a,b,c,d,e,35);
+    R2(e,a,b,c,d,36); 
+	R2(d,e,a,b,c,37); 
+	R2(c,d,e,a,b,38); 
+	R2(b,c,d,e,a,39);
+
+    R3(a,b,c,d,e,40); 
+	R3(e,a,b,c,d,41); 
+	R3(d,e,a,b,c,42); 
+	R3(c,d,e,a,b,43);
+    R3(b,c,d,e,a,44); 
+	R3(a,b,c,d,e,45); 
+	R3(e,a,b,c,d,46); 
+	R3(d,e,a,b,c,47);
+    R3(c,d,e,a,b,48); 
+	R3(b,c,d,e,a,49); 
+	R3(a,b,c,d,e,50); 
+	R3(e,a,b,c,d,51);
+    R3(d,e,a,b,c,52); 
+	R3(c,d,e,a,b,53); 
+	R3(b,c,d,e,a,54); 
+	R3(a,b,c,d,e,55);
+    R3(e,a,b,c,d,56); 
+	R3(d,e,a,b,c,57); 
+	R3(c,d,e,a,b,58); 
+	R3(b,c,d,e,a,59);
+
+    R4(a,b,c,d,e,60); 
+	R4(e,a,b,c,d,61); 
+	R4(d,e,a,b,c,62); 
+	R4(c,d,e,a,b,63);
+    R4(b,c,d,e,a,64); 
+	R4(a,b,c,d,e,65); 
+	R4(e,a,b,c,d,66); 
+	R4(d,e,a,b,c,67);
+    R4(c,d,e,a,b,68); 
+	R4(b,c,d,e,a,69); 
+	R4(a,b,c,d,e,70); 
+	R4(e,a,b,c,d,71);
+    R4(d,e,a,b,c,72); 
+	R4(c,d,e,a,b,73); 
+	R4(b,c,d,e,a,74); 
+	R4(a,b,c,d,e,75);
+    R4(e,a,b,c,d,76); 
+	R4(d,e,a,b,c,77); 
+	R4(c,d,e,a,b,78); 
+	R4(b,c,d,e,a,79);
+    
+	/* Add the working vars back into context.state[] */
+    iA += a;
+    iB += b;
+    iC += c;
+    iD += d;
+    iE += e;
+    /* Wipe variables */
+    a = b = c = d = e = 0;
+	Mem::FillZ(W, sizeof(W));
+#else
+	TUint tempA=iA;
+	TUint tempB=iB;
+	TUint tempC=iC;
+	TUint tempD=iD;
+	TUint tempE=iE;
+	TUint temp=0;
+
+#ifdef EXPANDLOOP
+	CSHA1_16(tempA,tempB,tempC,tempD,tempE,temp,iData[0]);
+	CSHA1_16(temp,tempA,tempB,tempC,tempD,tempE,iData[1]);
+	CSHA1_16(tempE,temp,tempA,tempB,tempC,tempD,iData[2]);
+	CSHA1_16(tempD,tempE,temp,tempA,tempB,tempC,iData[3]);
+	CSHA1_16(tempC,tempD,tempE,temp,tempA,tempB,iData[4]);
+	CSHA1_16(tempB,tempC,tempD,tempE,temp,tempA,iData[5]);
+	CSHA1_16(tempA,tempB,tempC,tempD,tempE,temp,iData[6]);
+	CSHA1_16(temp,tempA,tempB,tempC,tempD,tempE,iData[7]);
+	CSHA1_16(tempE,temp,tempA,tempB,tempC,tempD,iData[8]);
+	CSHA1_16(tempD,tempE,temp,tempA,tempB,tempC,iData[9]);
+	CSHA1_16(tempC,tempD,tempE,temp,tempA,tempB,iData[10]);
+	CSHA1_16(tempB,tempC,tempD,tempE,temp,tempA,iData[11]);
+	CSHA1_16(tempA,tempB,tempC,tempD,tempE,temp,iData[12]);
+	CSHA1_16(temp,tempA,tempB,tempC,tempD,tempE,iData[13]);
+	CSHA1_16(tempE,temp,tempA,tempB,tempC,tempD,iData[14]);
+	CSHA1_16(tempD,tempE,temp,tempA,tempB,tempC,iData[15]);
+	/*
+	i = 16;
+	TUint temp1 = tempA;
+	tempA = 
+	*/
+#else
+    TUint i=0;
+	while (i<16) 
+		{
+		temp = CMD_R(tempA,5) + CSHA1_F(tempB,tempC,tempD) + tempE + iData[i++] + 0x5a827999;
+		tempE = tempD;
+		tempD = tempC;
+		tempC = CMD_R(tempB,30);
+		tempB = tempA;
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_20(tempC,tempD,tempE,temp,tempA,tempB,iData[16],iData[13],iData[8],iData[2],iData[0]);
+	CSHA1_20(tempB,tempC,tempD,tempE,temp,tempA,iData[17],iData[14],iData[9],iData[3],iData[1]);
+	CSHA1_20(tempA,tempB,tempC,tempD,tempE,temp,iData[18],iData[15],iData[10],iData[4],iData[2]);
+	CSHA1_20(temp,tempA,tempB,tempC,tempD,tempE,iData[19],iData[16],iData[11],iData[5],iData[3]);
+	//i = 20;
+#else
+	while (i<20) 
+		{
+		temp=iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i]=CMD_R(temp,1);
+		temp = CMD_R(tempA,5) + CSHA1_F(tempB,tempC,tempD) + tempE + iData[i++] + 0x5a827999; 
+		tempE = tempD;
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[20],iData[17],iData[12],iData[6],iData[4]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[21],iData[18],iData[13],iData[7],iData[5]);
+	CSHA1_40(tempC,tempD,tempE,temp,tempA,tempB,iData[22],iData[19],iData[14],iData[8],iData[6]);
+	CSHA1_40(tempB,tempC,tempD,tempE,temp,tempA,iData[23],iData[20],iData[15],iData[9],iData[7]);
+	CSHA1_40(tempA,tempB,tempC,tempD,tempE,temp,iData[24],iData[21],iData[16],iData[10],iData[8]);
+	CSHA1_40(temp,tempA,tempB,tempC,tempD,tempE,iData[25],iData[22],iData[17],iData[11],iData[9]);
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[26],iData[23],iData[18],iData[12],iData[10]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[27],iData[24],iData[19],iData[13],iData[11]);
+	CSHA1_40(tempC,tempD,tempE,temp,tempA,tempB,iData[28],iData[25],iData[20],iData[14],iData[12]);
+	CSHA1_40(tempB,tempC,tempD,tempE,temp,tempA,iData[29],iData[26],iData[21],iData[15],iData[13]);
+	CSHA1_40(tempA,tempB,tempC,tempD,tempE,temp,iData[30],iData[27],iData[22],iData[16],iData[14]);
+	CSHA1_40(temp,tempA,tempB,tempC,tempD,tempE,iData[31],iData[28],iData[23],iData[17],iData[15]);
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[32],iData[29],iData[24],iData[18],iData[16]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[33],iData[30],iData[25],iData[19],iData[17]);
+	CSHA1_40(tempC,tempD,tempE,temp,tempA,tempB,iData[34],iData[31],iData[26],iData[20],iData[18]);
+	CSHA1_40(tempB,tempC,tempD,tempE,temp,tempA,iData[35],iData[32],iData[27],iData[21],iData[19]);
+	CSHA1_40(tempA,tempB,tempC,tempD,tempE,temp,iData[36],iData[33],iData[28],iData[22],iData[20]);
+	CSHA1_40(temp,tempA,tempB,tempC,tempD,tempE,iData[37],iData[34],iData[29],iData[23],iData[21]);
+	CSHA1_40(tempE,temp,tempA,tempB,tempC,tempD,iData[38],iData[35],iData[30],iData[24],iData[22]);
+	CSHA1_40(tempD,tempE,temp,tempA,tempB,tempC,iData[39],iData[36],iData[31],iData[25],iData[23]);
+	//i = 40;
+#else
+	while (i<40) 
+		{
+		temp = iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i] = CMD_R(temp,1);
+
+		temp = CMD_R(tempA,5) + CSHA1_G(tempB,tempC,tempD) + tempE + iData[i++] + 0x6ed9eba1; 
+		tempE = tempD; 
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[40],iData[37],iData[32],iData[26],iData[24]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[41],iData[38],iData[33],iData[27],iData[25]);
+	CSHA1_60(tempA,tempB,tempC,tempD,tempE,temp,iData[42],iData[39],iData[34],iData[28],iData[26]);
+	CSHA1_60(temp,tempA,tempB,tempC,tempD,tempE,iData[43],iData[40],iData[35],iData[29],iData[27]);
+	CSHA1_60(tempE,temp,tempA,tempB,tempC,tempD,iData[44],iData[41],iData[36],iData[30],iData[28]);
+	CSHA1_60(tempD,tempE,temp,tempA,tempB,tempC,iData[45],iData[42],iData[37],iData[31],iData[29]);
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[46],iData[43],iData[38],iData[32],iData[30]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[47],iData[44],iData[39],iData[33],iData[31]);
+	CSHA1_60(tempA,tempB,tempC,tempD,tempE,temp,iData[48],iData[45],iData[40],iData[34],iData[32]);
+	CSHA1_60(temp,tempA,tempB,tempC,tempD,tempE,iData[49],iData[46],iData[41],iData[35],iData[33]);
+	CSHA1_60(tempE,temp,tempA,tempB,tempC,tempD,iData[50],iData[47],iData[42],iData[36],iData[34]);
+	CSHA1_60(tempD,tempE,temp,tempA,tempB,tempC,iData[51],iData[48],iData[43],iData[37],iData[35]);
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[52],iData[49],iData[44],iData[38],iData[36]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[53],iData[50],iData[45],iData[39],iData[37]);
+	CSHA1_60(tempA,tempB,tempC,tempD,tempE,temp,iData[54],iData[51],iData[46],iData[40],iData[38]);
+	CSHA1_60(temp,tempA,tempB,tempC,tempD,tempE,iData[55],iData[52],iData[47],iData[41],iData[39]);
+	CSHA1_60(tempE,temp,tempA,tempB,tempC,tempD,iData[56],iData[53],iData[48],iData[42],iData[40]);
+	CSHA1_60(tempD,tempE,temp,tempA,tempB,tempC,iData[57],iData[54],iData[49],iData[43],iData[41]);
+	CSHA1_60(tempC,tempD,tempE,temp,tempA,tempB,iData[58],iData[55],iData[50],iData[44],iData[42]);
+	CSHA1_60(tempB,tempC,tempD,tempE,temp,tempA,iData[59],iData[56],iData[51],iData[45],iData[43]);
+	//i = 60;
+#else
+	while (i<60) 
+		{
+		temp = iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i] = CMD_R(temp,1);
+
+		temp = CMD_R(tempA,5) + CSHA1_H(tempB,tempC,tempD) + tempE + iData[i++] + 0x8f1bbcdc; 
+		tempE = tempD; 
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[60],iData[57],iData[52],iData[46],iData[44]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[61],iData[58],iData[53],iData[47],iData[45]);
+	CSHA1_80(tempE,temp,tempA,tempB,tempC,tempD,iData[62],iData[59],iData[54],iData[48],iData[46]);
+	CSHA1_80(tempD,tempE,temp,tempA,tempB,tempC,iData[63],iData[60],iData[55],iData[49],iData[47]);
+	CSHA1_80(tempC,tempD,tempE,temp,tempA,tempB,iData[64],iData[61],iData[56],iData[50],iData[48]);
+	CSHA1_80(tempB,tempC,tempD,tempE,temp,tempA,iData[65],iData[62],iData[57],iData[51],iData[49]);
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[66],iData[63],iData[58],iData[52],iData[50]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[67],iData[64],iData[59],iData[53],iData[51]);
+	CSHA1_80(tempE,temp,tempA,tempB,tempC,tempD,iData[68],iData[65],iData[60],iData[54],iData[52]);
+	CSHA1_80(tempD,tempE,temp,tempA,tempB,tempC,iData[69],iData[66],iData[61],iData[55],iData[53]);
+	CSHA1_80(tempC,tempD,tempE,temp,tempA,tempB,iData[70],iData[67],iData[62],iData[56],iData[54]);
+	CSHA1_80(tempB,tempC,tempD,tempE,temp,tempA,iData[71],iData[68],iData[63],iData[57],iData[55]);
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[72],iData[69],iData[64],iData[58],iData[56]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[73],iData[70],iData[65],iData[59],iData[57]);
+	CSHA1_80(tempE,temp,tempA,tempB,tempC,tempD,iData[74],iData[71],iData[66],iData[60],iData[58]);
+	CSHA1_80(tempD,tempE,temp,tempA,tempB,tempC,iData[75],iData[72],iData[67],iData[61],iData[59]);
+	CSHA1_80(tempC,tempD,tempE,temp,tempA,tempB,iData[76],iData[73],iData[68],iData[62],iData[60]);
+	CSHA1_80(tempB,tempC,tempD,tempE,temp,tempA,iData[77],iData[74],iData[69],iData[63],iData[61]);
+	CSHA1_80(tempA,tempB,tempC,tempD,tempE,temp,iData[78],iData[75],iData[70],iData[64],iData[62]);
+	CSHA1_80(temp,tempA,tempB,tempC,tempD,tempE,iData[79],iData[76],iData[71],iData[65],iData[63]);
+#else
+	const TUint total=KSHA1BlockSize*5; // 16 * 5 = 80
+	while (i<total) 
+		{
+		temp = iData[i-3] ^ iData[i-8] ^ iData[i-14] ^ iData[i-16];
+		iData[i] = CMD_R(temp,1);
+
+		temp = CMD_R(tempA,5) + CSHA1_I(tempB,tempC,tempD) + tempE + iData[i++] + 0xca62c1d6; 
+		tempE = tempD; 
+		tempD = tempC; 
+		tempC = CMD_R(tempB,30); 
+		tempB = tempA; 
+		tempA = temp;
+		}
+#endif
+
+#ifdef EXPANDLOOP
+	iA+=tempE;
+	iB+=temp;
+	iC+=tempA;
+	iD+=tempB;
+	iE+=tempC;
+#else
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	iE+=tempE;
+#endif // EXPANDLOOP
+#endif // WEIDAI
+	}
+
+void CSHA1Impl::DoFinal()
+	{
+	iNh += iNl;
+	const TUint ul128=128;
+	switch (iNl&3) 
+		{
+		case 0:
+			iData[iNl>>2] = ul128<<24;
+			break;
+		case 1:
+			iData[iNl>>2] += ul128<<16;
+			break;
+		case 2:
+			iData[iNl>>2] += ul128<<8;
+			break;
+		case 3:
+			iData[iNl>>2] += ul128;
+			break;
+		default:
+			break;
+		};
+	if (iNl>=56) 
+		{
+		if (iNl<60)
+			iData[15]=0;		
+		Block();
+		Mem::FillZ(iData,14*sizeof(TUint));
+		} 
+	else
+		{
+		const TUint offset=(iNl+4)>>2; //+4 to account for the word added in the
+		//switch statement above
+		Mem::FillZ(iData+offset,(14-offset)*sizeof(TUint));
+		}
+
+	// this will fail if the total input length is longer than 2^32 in bits
+	//(2^31 in bytes) which is roughly half a gig.
+	iData[14]=0;
+	iData[15]=iNh<<3;//number in bits
+	Block();
+	//
+	// Generate hash value into iHash
+	//
+	TUint tmp=iA;
+	iHash[3]=(TUint8)(tmp & 255);
+	iHash[2]=(TUint8)((tmp >>= 8) & 255);
+	iHash[1]=(TUint8)((tmp >>= 8) & 255);
+	iHash[0]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iB;
+	iHash[7]=(TUint8)(tmp & 255);
+	iHash[6]=(TUint8)((tmp >>= 8) & 255);
+	iHash[5]=(TUint8)((tmp >>= 8) & 255);
+	iHash[4]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iC;
+	iHash[11]=(TUint8)(tmp & 255);
+	iHash[10]=(TUint8)((tmp >>= 8) & 255);
+	iHash[9]=(TUint8)((tmp >>= 8) & 255);
+	iHash[8]=(TUint8)((tmp >>= 8) & 255);
+
+	tmp=iD;
+	iHash[15]=(TUint8)(tmp & 255);
+	iHash[14]=(TUint8)((tmp >>= 8) & 255);
+	iHash[13]=(TUint8)((tmp >>= 8) & 255);
+	iHash[12]=(TUint8)((tmp >>= 8) & 255);
+	
+	tmp=iE;
+	iHash[19]=(TUint8)(tmp & 255);
+	iHash[18]=(TUint8)((tmp >>= 8) & 255);
+	iHash[17]=(TUint8)((tmp >>= 8) & 255);
+	iHash[16]=(TUint8)((tmp >>= 8) & 255);
+	}
+
+void CSHA1Impl::RestoreState()
+	{
+	iA = iACopy;
+	iB = iBCopy;
+	iC = iCCopy;
+	iD = iDCopy;
+	iE = iECopy;
+	iNl = iNlCopy;
+	iNh = iNhCopy;	
+	Mem::Copy(&iData[0], &iDataCopy[0], KSHA1BlockSize*5*sizeof(TUint)); 
+	}
+
+void CSHA1Impl::StoreState()
+	{
+	iACopy = iA;
+	iBCopy = iB;
+	iCCopy = iC;
+	iDCopy = iD;
+	iECopy = iE;
+	iNlCopy = iNl;
+	iNhCopy = iNh;	
+	Mem::Copy(&iDataCopy[0], &iData[0], KSHA1BlockSize*5*sizeof(TUint));
+	}
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CSHA1Impl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+
+void CSHA1Impl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CSHA1Impl::SetKeyL(const CKey& /*aKey*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha1impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,102 @@
+/*
+* Copyright (c) 2006-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: 
+* Software md2 implementation
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWARESHA1IMPL_H__
+#define __CRYPTOAPI_SOFTWARESHA1IMPL_H__
+
+#include "softwarehashbase.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	const TInt KSHA1BlockSize = 16;
+	const TInt KSHA1HashSize = 20;
+			
+	NONSHARABLE_CLASS(CSHA1Impl) : public CBase, public MSoftwareHash
+		{		
+	public:
+		//NewL & NewLC	
+		static CSHA1Impl* NewL();
+		static CSHA1Impl* NewLC();
+		
+		//From MPlugin
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		
+		//From MHash
+	    TPtrC8 Hash(const TDesC8& aMessage);
+	    void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+		void SetKeyL(const CKey& aKey);
+		void SetOperationModeL(TUid aOperationMode);		
+		
+		//From MSoftwareHash
+		void RestoreState();
+		void StoreState();
+		
+	private:
+		//Constructors
+		CSHA1Impl();
+		CSHA1Impl(const CSHA1Impl& aSHA1Impl);
+		
+		//Destructor
+		~CSHA1Impl();
+		
+		TUid ImplementationUid();
+		
+		void DoUpdate(const TUint8* aData,TUint aLength);
+		void DoFinal(void);
+		void Block();
+
+		
+	private:
+		TBuf8<KSHA1HashSize> iHash;
+		TUint iA;
+		TUint iB;
+		TUint iC;
+		TUint iD;
+		TUint iE;
+		TUint iNl;
+		TUint iNh;
+		TUint iData[KSHA1BlockSize*5];
+
+		TUint iACopy;
+		TUint iBCopy;
+		TUint iCCopy;
+		TUint iDCopy;
+		TUint iECopy;
+		TUint iNlCopy;
+		TUint iNhCopy;	
+		TUint iDataCopy[KSHA1BlockSize*5];
+		};
+	}
+#endif // __CRYPTOAPI_SOFTWARESHA1IMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha224and256impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,499 @@
+/*
+* Copyright (c) 2007-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: 
+* Common implementation of SHA224 and SHA256
+* RFC 4634 (US Secure Hash Algorithms (SHA and HMAC-SHA))
+*
+*/
+
+
+/**
+ @file
+*/
+
+
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+#include "sha224and256impl.h"
+
+using namespace SoftwareCrypto;
+
+/**
+ * SHA256 Constants
+ * 
+ * SHA-256 uses a sequence of sixty-four constant 32-bit words. 
+ * These words represent the first thirty-two bits of the fractional 
+ * parts of the cube roots of the first sixtyfour prime numbers.
+ * 
+ * FIPS 180-2 Section 4.2.2
+ */
+const TUint K[64] = 
+	{
+	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,	
+	0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+	0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+	0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+	0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+	0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 
+	0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 
+	0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+	0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+	};
+
+/**
+ * Define the SHA SIGMA and sigma macros 
+ * 
+ * FIPS 180-2 section 4.1.2
+ */
+// Equation 4.4
+inline TUint SHA256_SIGMA0(TUint aWord)
+	{
+	return (SHA_ROTR<TUint>( 2,aWord) ^ SHA_ROTR<TUint>(13,aWord) ^ SHA_ROTR<TUint>(22,aWord));
+	}
+// Equation 4.5
+inline TUint SHA256_SIGMA1(TUint aWord)
+	{
+	return (SHA_ROTR<TUint>( 6,aWord) ^ SHA_ROTR<TUint>(11,aWord) ^ SHA_ROTR<TUint>(25,aWord));
+	}
+// Equation 4.6
+inline TUint SHA256_sigma0(TUint aWord)
+	{
+	return (SHA_ROTR<TUint>( 7,aWord) ^ SHA_ROTR<TUint>(18,aWord) ^ SHA_SHR<TUint>( 3,aWord));
+	}
+// Equation 4.7
+inline TUint SHA256_sigma1(TUint aWord)
+	{
+	return (SHA_ROTR<TUint>(17,aWord) ^ SHA_ROTR<TUint>(19,aWord) ^ SHA_SHR<TUint>(10,aWord));
+	}
+
+
+// Macros
+inline TUint MakeWord(const TUint8* aData)
+	{
+	return (aData[0] << 24 | aData[1] << 16 | aData[2] << 8 | aData[3]);
+	}
+
+	
+CSHA224And256Impl* CSHA224And256Impl::NewL()
+	{
+	CSHA224And256Impl* self=new (ELeave) CSHA224And256Impl();
+	return self;						
+	}
+														
+CSHA224And256Impl::CSHA224And256Impl() : iHash(KSHA256HashSize)
+	{		
+	}
+	
+CSHA224And256Impl::CSHA224And256Impl(const CSHA224And256Impl& aSHA256Impl)
+				: 	iHash(aSHA256Impl.iHash),
+					iA(aSHA256Impl.iA),
+					iB(aSHA256Impl.iB),
+					iC(aSHA256Impl.iC),
+					iD(aSHA256Impl.iD),
+					iE(aSHA256Impl.iE),
+					iF(aSHA256Impl.iF),
+					iG(aSHA256Impl.iG),
+					iH(aSHA256Impl.iH),
+					iNl(aSHA256Impl.iNl),
+					iNh(aSHA256Impl.iNh)
+	{
+	Mem::Copy(iData, aSHA256Impl.iData, KSHA256BlockSize*sizeof(TUint));
+	}
+	
+void CSHA224And256Impl::Reset(const TAny* aValArray)
+	{
+	const TUint* values = static_cast<const TUint*>(aValArray);
+	/**
+	 * Initial Hash Value
+	 * 
+	 * These words were obtained by taking the first thirty-two bits 
+	 * of the fractional parts of the square roots of the first eight
+	 * prime numbers.
+	 * 
+	 * FIPS 180-2 Section 5.3.2
+	 */
+	iA=values[0];
+	iB=values[1];
+	iC=values[2];
+	iD=values[3];
+	iE=values[4];
+	iF=values[5];
+	iG=values[6];
+	iH=values[7];
+	iNh=0;
+	iNl=0;
+	}
+
+// This assumes a big-endian architecture
+void CSHA224And256Impl::Update(const TUint8* aData,TUint aLength)
+	{
+	while((aLength / 4) > 0 && (iNl % 4 == 0))
+		{
+		iData[iNl>>2] = MakeWord(aData);
+		iNl+=4;
+		aData+=4;
+		aLength-=4;
+		if(iNl==KSHA256BlockSize) 
+			{
+			Block();
+			AddLength(KSHA256BlockSize);
+			}
+		}
+
+	while(aLength--)
+		{
+		if(!(iNl&0x03))
+			{
+			iData[iNl >> 2] = 0;
+			}
+		iData[iNl >> 2] |= *aData << ((3 - iNl&0x03) << 3) ;
+		++aData;
+		++iNl;
+		if(iNl==KSHA256BlockSize) 
+			{
+			Block();
+			AddLength(KSHA256BlockSize);
+			}
+		}
+	}
+
+//This function will panic if the total input length is longer than 2^64 in bits
+_LIT(KPanicString, "Message length exceeds supported length");
+inline void CSHA224And256Impl::AddLength(const TUint aLength)
+	{
+	TUint64 temp = iNh;
+	iNh += aLength << 3;
+	__ASSERT_ALWAYS((temp <= iNh), User::Panic(KPanicString, KErrOverflow));
+	}
+
+
+static inline void CSHA256_16(	const TUint aA, 
+								const TUint aB, 
+								const TUint aC,
+								TUint& aD, 
+								const TUint aE, 
+								const TUint aF,
+								const TUint aG, 
+								TUint& aH,
+								TUint aTemp1,
+								TUint aTemp2,
+								const TUint aK,
+								const TUint aWord)
+	{
+	aTemp1 = aH + SHA256_SIGMA1(aE) + SHA_Ch(aE,aF,aG) + aK + aWord;
+	aTemp2 = SHA256_SIGMA0(aA) + SHA_Maj(aA,aB,aC);
+	aD = aD + aTemp1;
+	aH = aTemp1 + aTemp2;
+	}
+
+static inline void CSHA256_48(	const TUint aA, 
+								const TUint aB, 
+								const TUint aC,
+								TUint& aD, 
+								const TUint aE, 
+								const TUint aF,
+								const TUint aG, 
+								TUint& aH,
+								TUint aTemp1,
+								TUint aTemp2,
+								const TUint aK,
+								TUint& aWord0,
+								const TUint aWord2,
+								const TUint aWord7,
+								const TUint aWord15,
+								const TUint aWord16)
+	{
+	aWord0 = SHA256_sigma1(aWord2) + aWord7 + SHA256_sigma0(aWord15) + aWord16;
+	CSHA256_16(aA, aB, aC, aD, aE, aF, aG, aH, aTemp1, aTemp2, aK, aWord0);
+	}
+
+/**
+ * This function actually calculates the hash.
+ * Function is defined in FIPS 180-2 section 6.2.2
+ * 
+ * This function is the expanded version of the following loop.
+ *	for(TUint i = 0; i < 64; ++i)
+ *		{
+ *		if(i >= 16)
+ *			{
+ * 			iData[i] = SHA256_sigma1(iData[i-2]) + iData[i-7] + SHA256_sigma0(iData[i-15]) + iData[i-16];
+ *			}
+ *
+ *		temp1 = tempH + SHA256_SIGMA1(tempE) + SHA_Ch(tempE,tempF,tempG) + K[i] + iData[i];
+ *		temp2 = SHA256_SIGMA0(tempA) + SHA_Maj(tempA,tempB,tempC);
+ *	    tempH = tempG;
+ *	    tempG = tempF;
+ *	    tempF = tempE;
+ *	    tempE = tempD + temp1;
+ *	    tempD = tempC;
+ *	    tempC = tempB;
+ *	    tempB = tempA;
+ *	    tempA = temp1 + temp2;		
+ *		}
+ */
+void CSHA224And256Impl::Block()
+	{
+	TUint tempA=iA;
+	TUint tempB=iB;
+	TUint tempC=iC;
+	TUint tempD=iD;
+	TUint tempE=iE;
+	TUint tempF=iF;
+	TUint tempG=iG;
+	TUint tempH=iH;
+	TUint temp1=0;
+	TUint temp2=0;
+	
+	CSHA256_16(tempA,tempB,tempC,tempD,tempE,tempF,tempG,tempH,temp1,temp2,K[0],iData[0]);
+	CSHA256_16(tempH,tempA,tempB,tempC,tempD,tempE,tempF,tempG,temp1,temp2,K[1],iData[1]);
+	CSHA256_16(tempG,tempH,tempA,tempB,tempC,tempD,tempE,tempF,temp1,temp2,K[2],iData[2]);
+	CSHA256_16(tempF,tempG,tempH,tempA,tempB,tempC,tempD,tempE,temp1,temp2,K[3],iData[3]);
+	CSHA256_16(tempE,tempF,tempG,tempH,tempA,tempB,tempC,tempD,temp1,temp2,K[4],iData[4]);
+	CSHA256_16(tempD,tempE,tempF,tempG,tempH,tempA,tempB,tempC,temp1,temp2,K[5],iData[5]);
+	CSHA256_16(tempC,tempD,tempE,tempF,tempG,tempH,tempA,tempB,temp1,temp2,K[6],iData[6]);
+	CSHA256_16(tempB,tempC,tempD,tempE,tempF,tempG,tempH,tempA,temp1,temp2,K[7],iData[7]);
+
+	CSHA256_16(tempA,tempB,tempC,tempD,tempE,tempF,tempG,tempH,temp1,temp2,K[8],iData[8]);
+	CSHA256_16(tempH,tempA,tempB,tempC,tempD,tempE,tempF,tempG,temp1,temp2,K[9],iData[9]);
+	CSHA256_16(tempG,tempH,tempA,tempB,tempC,tempD,tempE,tempF,temp1,temp2,K[10],iData[10]);
+	CSHA256_16(tempF,tempG,tempH,tempA,tempB,tempC,tempD,tempE,temp1,temp2,K[11],iData[11]);
+	CSHA256_16(tempE,tempF,tempG,tempH,tempA,tempB,tempC,tempD,temp1,temp2,K[12],iData[12]);
+	CSHA256_16(tempD,tempE,tempF,tempG,tempH,tempA,tempB,tempC,temp1,temp2,K[13],iData[13]);
+	CSHA256_16(tempC,tempD,tempE,tempF,tempG,tempH,tempA,tempB,temp1,temp2,K[14],iData[14]);
+	CSHA256_16(tempB,tempC,tempD,tempE,tempF,tempG,tempH,tempA,temp1,temp2,K[15],iData[15]);
+
+	CSHA256_48(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[16], iData[16], iData[14], iData[9], iData[1], iData[0]);
+	CSHA256_48(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[17], iData[17], iData[15], iData[10], iData[2], iData[1]);
+	CSHA256_48(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[18], iData[18], iData[16], iData[11], iData[3], iData[2]);
+	CSHA256_48(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[19], iData[19], iData[17], iData[12], iData[4], iData[3]);
+	CSHA256_48(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[20], iData[20], iData[18], iData[13], iData[5], iData[4]);
+	CSHA256_48(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[21], iData[21], iData[19], iData[14], iData[6], iData[5]);
+	CSHA256_48(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[22], iData[22], iData[20], iData[15], iData[7], iData[6]);
+	CSHA256_48(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[23], iData[23], iData[21], iData[16], iData[8], iData[7]);
+
+	CSHA256_48(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[24], iData[24], iData[22], iData[17], iData[9], iData[8]);
+	CSHA256_48(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[25], iData[25], iData[23], iData[18], iData[10], iData[9]);
+	CSHA256_48(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[26], iData[26], iData[24], iData[19], iData[11], iData[10]);
+	CSHA256_48(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[27], iData[27], iData[25], iData[20], iData[12], iData[11]);
+	CSHA256_48(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[28], iData[28], iData[26], iData[21], iData[13], iData[12]);
+	CSHA256_48(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[29], iData[29], iData[27], iData[22], iData[14], iData[13]);
+	CSHA256_48(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[30], iData[30], iData[28], iData[23], iData[15], iData[14]);
+	CSHA256_48(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[31], iData[31], iData[29], iData[24], iData[16], iData[15]);
+
+	CSHA256_48(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[32], iData[32], iData[30], iData[25], iData[17], iData[16]);
+	CSHA256_48(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[33], iData[33], iData[31], iData[26], iData[18], iData[17]);
+	CSHA256_48(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[34], iData[34], iData[32], iData[27], iData[19], iData[18]);
+	CSHA256_48(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[35], iData[35], iData[33], iData[28], iData[20], iData[19]);
+	CSHA256_48(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[36], iData[36], iData[34], iData[29], iData[21], iData[20]);
+	CSHA256_48(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[37], iData[37], iData[35], iData[30], iData[22], iData[21]);
+	CSHA256_48(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[38], iData[38], iData[36], iData[31], iData[23], iData[22]);
+	CSHA256_48(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[39], iData[39], iData[37], iData[32], iData[24], iData[23]);
+
+	CSHA256_48(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[40], iData[40], iData[38], iData[33], iData[25], iData[24]);
+	CSHA256_48(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[41], iData[41], iData[39], iData[34], iData[26], iData[25]);
+	CSHA256_48(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[42], iData[42], iData[40], iData[35], iData[27], iData[26]);
+	CSHA256_48(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[43], iData[43], iData[41], iData[36], iData[28], iData[27]);
+	CSHA256_48(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[44], iData[44], iData[42], iData[37], iData[29], iData[28]);
+	CSHA256_48(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[45], iData[45], iData[43], iData[38], iData[30], iData[29]);
+	CSHA256_48(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[46], iData[46], iData[44], iData[39], iData[31], iData[30]);
+	CSHA256_48(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[47], iData[47], iData[45], iData[40], iData[32], iData[31]);
+
+	CSHA256_48(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[48], iData[48], iData[46], iData[41], iData[33], iData[32]);
+	CSHA256_48(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[49], iData[49], iData[47], iData[42], iData[34], iData[33]);
+	CSHA256_48(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[50], iData[50], iData[48], iData[43], iData[35], iData[34]);
+	CSHA256_48(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[51], iData[51], iData[49], iData[44], iData[36], iData[35]);
+	CSHA256_48(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[52], iData[52], iData[50], iData[45], iData[37], iData[36]);
+	CSHA256_48(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[53], iData[53], iData[51], iData[46], iData[38], iData[37]);
+	CSHA256_48(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[54], iData[54], iData[52], iData[47], iData[39], iData[38]);
+	CSHA256_48(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[55], iData[55], iData[53], iData[48], iData[40], iData[39]);
+
+	CSHA256_48(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[56], iData[56], iData[54], iData[49], iData[41], iData[40]);
+	CSHA256_48(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[57], iData[57], iData[55], iData[50], iData[42], iData[41]);
+	CSHA256_48(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[58], iData[58], iData[56], iData[51], iData[43], iData[42]);
+	CSHA256_48(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[59], iData[59], iData[57], iData[52], iData[44], iData[43]);
+	CSHA256_48(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[60], iData[60], iData[58], iData[53], iData[45], iData[44]);
+	CSHA256_48(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[61], iData[61], iData[59], iData[54], iData[46], iData[45]);
+	CSHA256_48(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[62], iData[62], iData[60], iData[55], iData[47], iData[46]);
+	CSHA256_48(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[63], iData[63], iData[61], iData[56], iData[48], iData[47]);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	iE+=tempE;
+	iF+=tempF;
+	iG+=tempG;
+	iH+=tempH;
+
+	iNl=0;
+	}
+
+/**
+ * According to the standard, the message must be padded to an
+ * even 512 bits. The first padding bit must be a '1'. The last
+ * 64 bits represent the length of the original message. All bits 
+ * in between should be 0. This helper function will pad the 
+ * message according to those rules by filling the iData array 
+ * accordingly. 
+ */ 
+void CSHA224And256Impl::PadMessage()
+	{
+	const TUint padByte = 0x80;
+	
+	if(!(iNl&0x03))
+		{
+		iData[iNl >> 2] = 0;
+		}
+	iData[iNl >> 2] |= padByte << ((3 - iNl&0x03) << 3) ;
+
+	if (iNl >= (KSHA256BlockSize - 2*sizeof(TUint))) 
+		{
+		if (iNl < (KSHA256BlockSize - sizeof(TUint)))
+			iData[(KSHA256BlockSize >> 2) - 1]=0;		
+		Block();
+		Mem::FillZ(iData, KSHA256BlockSize);
+		} 
+	else
+		{
+		const TUint offset=(iNl+4)>>2; //+4 to account for the word added in the
+		//switch statement above
+		Mem::FillZ(iData+offset,(KSHA256BlockSize - offset*sizeof(TUint)));
+		}
+
+	//Length in bits
+	TUint64 msgLength = iNh;
+
+	iData[(KSHA256BlockSize >> 2) - 2] = (msgLength) >> 32;
+	iData[(KSHA256BlockSize >> 2) - 1] = (msgLength & 0xFFFFFFFF);	
+	}
+
+inline void CSHA224And256Impl::CopyWordToHash(TUint aVal, TUint aIndex)
+	{
+	TUint value = MakeWord(reinterpret_cast<TUint8*>(&aVal));
+	Mem::Copy(const_cast<TUint8*>(iHash.Ptr())+ (4*aIndex), &value, sizeof(aVal));
+	}
+
+const TDes8& CSHA224And256Impl::Final()
+	{
+	AddLength(iNl);
+	PadMessage();
+	Block();
+	//
+	// Generate hash value into iHash
+	//
+	CopyWordToHash(iA, 0);
+	CopyWordToHash(iB, 1);
+	CopyWordToHash(iC, 2);
+	CopyWordToHash(iD, 3);
+	CopyWordToHash(iE, 4);
+	CopyWordToHash(iF, 5);
+	CopyWordToHash(iG, 6);
+	CopyWordToHash(iH, 7);
+	
+	return iHash;
+	}
+
+void CSHA224And256Impl::RestoreState()
+	{
+	iA = iACopy;
+	iB = iBCopy;
+	iC = iCCopy;
+	iD = iDCopy;
+	iE = iECopy;
+	iF = iFCopy;
+	iG = iGCopy;
+	iH = iHCopy;
+	iNl = iNlCopy;
+	iNh = iNhCopy;	
+	Mem::Copy(iData, iDataCopy, KSHA256BlockSize*sizeof(TUint)); 
+	}
+
+void CSHA224And256Impl::StoreState()
+	{
+	iACopy = iA;
+	iBCopy = iB;
+	iCCopy = iC;
+	iDCopy = iD;
+	iECopy = iE;
+	iFCopy = iF;
+	iGCopy = iG;
+	iHCopy = iH;
+	iNlCopy = iNl;
+	iNhCopy = iNh;	
+	Mem::Copy(iDataCopy, iData, KSHA256BlockSize*sizeof(TUint));
+	}
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha224and256impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,94 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+
+#ifndef __CRYPTOAPI_SOFTWARESHA224AND256IMPL_H_
+#define __CRYPTOAPI_SOFTWARESHA224AND256IMPL_H_
+
+
+#include "softwarehashbase.h"
+#include "shacommon.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	const TInt KSHA256BlockSize	= 64;
+	const TInt KSHA224HashSize	= 28;
+	const TInt KSHA256HashSize	= 32;
+			
+	NONSHARABLE_CLASS(CSHA224And256Impl) : public CBase, public MSHA2Impl
+		{	
+	public:
+		//NewL	
+		static CSHA224And256Impl* NewL();
+		CSHA224And256Impl(const CSHA224And256Impl& aSHA256Impl);
+		
+		// Functions from MSHA2Impl
+		virtual void RestoreState();
+		virtual void StoreState();
+		virtual void Reset(const TAny*);
+		virtual void Update(const TUint8* aData,TUint aLength);
+		virtual const TDes8& Final(void);
+	
+	private:
+		//Constructors
+		CSHA224And256Impl();
+		inline void AddLength(const TUint aLength);
+		inline void CopyWordToHash(TUint aVal, TUint aIndex);
+		void Block();
+		void PadMessage();
+
+	private:
+		TBuf8<KSHA256HashSize> iHash;
+		TUint iA;
+		TUint iB;
+		TUint iC;
+		TUint iD;
+		TUint iE;
+		TUint iF;
+		TUint iG;
+		TUint iH;
+		TUint iData[KSHA256BlockSize];
+
+		TUint iACopy;
+		TUint iBCopy;
+		TUint iCCopy;
+		TUint iDCopy;
+		TUint iECopy;
+		TUint iFCopy;
+		TUint iGCopy;
+		TUint iHCopy;
+		TUint iNlCopy;
+		TUint iNhCopy;	
+		TUint iDataCopy[KSHA256BlockSize];
+		
+		TUint iNl;
+		TUint64 iNh;
+		};
+	}
+
+#endif // __CRYPTOAPI_SOFTWARESHA224AND256IMPL_H_
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha2impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,329 @@
+/*
+* Copyright (c) 2007-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: 
+* software SHA2 implementation
+* RFC 4634 (US Secure Hash Algorithms (SHA and HMAC-SHA))
+* FIPS 180-2 (With change notice)
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "sha2impl.h"
+
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+#include "sha224and256impl.h"
+#include "sha384and512impl.h"
+
+using namespace SoftwareCrypto;
+
+// Initial Hash Values of SHA2 algorithms
+/**
+ * Initial Hash Value for SHA-224
+ * 
+ * These words were obtained by taking the first thirty-two bits 
+ * of the fractional parts of the square roots of the first eight
+ * prime numbers.
+ * 
+ * FIPS 180-2 Appendix
+ * FIPS 180-3 Section 5.3.2
+ */
+const TUint SHA224InitVals[] = 
+    			{
+    			0xc1059ed8, // A
+    			0x367cd507, // B
+    			0x3070dd17, // C
+    			0xf70e5939, // D
+    			0xffc00b31, // E
+    			0x68581511, // F
+    			0x64f98fa7, // G
+    			0xbefa4fa4  // H
+    			};
+
+/**
+ * Initial Hash Value for SHA-256
+ * 
+ * These words were obtained by taking the first thirty-two bits 
+ * of the fractional parts of the square roots of the first eight
+ * prime numbers.
+ * 
+ * FIPS 180-2 Section 5.3.2
+ */
+const TUint SHA256InitVals[] = 
+    			{
+    			0x6a09e667, // A
+    			0xbb67ae85, // B
+    			0x3c6ef372, // C
+    			0xa54ff53a, // D
+    			0x510e527f, // E
+    			0x9b05688c, // F
+    			0x1f83d9ab, // G
+    			0x5be0cd19  // H
+    			};
+
+/**
+ * Initial Hash Value for SHA-384
+ * 
+ *  These words were obtained by taking the first sixty-four bits 
+ * of the fractional parts of the square roots of the first eight
+ * prime numbers.
+ * 
+ * FIPS 180-2 Section 5.3.3
+ */
+const TUint64 SHA384InitVals[] = 
+    			{
+    			UI64LIT(0xcbbb9d5dc1059ed8), // A
+    			UI64LIT(0x629a292a367cd507), // B
+    			UI64LIT(0x9159015a3070dd17), // C
+    			UI64LIT(0x152fecd8f70e5939), // D
+    			UI64LIT(0x67332667ffc00b31), // E
+    			UI64LIT(0x8eb44a8768581511), // F
+    			UI64LIT(0xdb0c2e0d64f98fa7), // G
+    			UI64LIT(0x47b5481dbefa4fa4)  // H
+    			};
+
+/**
+ * Initial Hash Value for SHA-512
+ * 
+ * These words were obtained by taking the first sixty-four bits 
+ * of the fractional parts of the square roots of the first eight
+ * prime numbers.
+ * 
+ * FIPS 180-2 Section 5.3.4
+ */
+const TUint64 SHA512InitVals[] = 
+    			{
+    			UI64LIT(0x6a09e667f3bcc908), // A
+    			UI64LIT(0xbb67ae8584caa73b), // B
+    			UI64LIT(0x3c6ef372fe94f82b), // C
+    			UI64LIT(0xa54ff53a5f1d36f1), // D
+    			UI64LIT(0x510e527fade682d1), // E
+    			UI64LIT(0x9b05688c2b3e6c1f), // F
+    			UI64LIT(0x1f83d9abfb41bd6b), // G
+    			UI64LIT(0x5be0cd19137e2179)  // H
+    			};
+
+	
+CSHA2Impl* CSHA2Impl::NewL(TInt32 aAlgorithmId)
+	{
+	CSHA2Impl* self = CSHA2Impl::NewLC(aAlgorithmId);
+	CleanupStack::Pop(self);
+	return self;						
+	}
+														
+CSHA2Impl* CSHA2Impl::NewLC(TInt32 aAlgorithmId)
+	{
+	CSHA2Impl* self = new (ELeave) CSHA2Impl();
+	CleanupStack::PushL(self);
+	self->ConstructL(aAlgorithmId);
+	return self;						
+	}
+														
+void CSHA2Impl::ConstructL(const CSHA2Impl& aSHA2Impl)
+	{
+	iImplementationUid = aSHA2Impl.iImplementationUid;
+	iInitValues = aSHA2Impl.iInitValues;
+	iHashSize = aSHA2Impl.iHashSize;
+    switch(iImplementationUid.iUid)
+		{
+		case KCryptoPluginSha224:
+		case KCryptoPluginSha256:
+			{
+			const CSHA224And256Impl* const impl = static_cast<CSHA224And256Impl*>(aSHA2Impl.iImplementation);
+			iImplementation = new (ELeave) CSHA224And256Impl(*impl);
+			break;
+			}
+		case KCryptoPluginSha384:
+		case KCryptoPluginSha512:
+			{
+			const CSHA384And512Impl* const impl = static_cast<CSHA384And512Impl*>(aSHA2Impl.iImplementation);
+			iImplementation = new (ELeave) CSHA384And512Impl(*impl);
+			break;
+			}
+		default:
+			{
+			User::Leave(KErrNotSupported);
+			}
+		}
+	}
+
+void CSHA2Impl::ConstructL(TInt32 aAlgorithmId)
+    {
+    switch(aAlgorithmId)
+    	{
+    	case KCryptoPluginSha224:
+    		{
+    		iImplementation = CSHA224And256Impl::NewL();
+    		iInitValues = SHA224InitVals;
+    		iImplementationUid = KCryptoPluginSha224Uid;
+    		iHashSize = KSHA224HashSize;
+    		break;
+    		}
+    	case KCryptoPluginSha256:
+    		{
+    		iImplementation = CSHA224And256Impl::NewL();
+    		iInitValues = SHA256InitVals;
+    		iImplementationUid = KCryptoPluginSha256Uid;
+    		iHashSize = KSHA256HashSize;
+    		break;
+    		}
+    	case KCryptoPluginSha384:
+    		{
+    		iImplementation = CSHA384And512Impl::NewL();
+    		iInitValues = SHA384InitVals;
+    		iImplementationUid = KCryptoPluginSha384Uid;
+    		iHashSize = KSHA384HashSize;
+    		break;
+    		}
+    	case KCryptoPluginSha512:
+    		{
+    		iImplementation = CSHA384And512Impl::NewL();
+    		iInitValues = SHA512InitVals;
+    		iImplementationUid = KCryptoPluginSha512Uid;
+    		iHashSize = KSHA512HashSize;
+    		break;
+    		}
+    	default:
+    		{
+    		User::Leave(KErrNotSupported);
+    		}
+    	}
+    
+    Reset();
+    }
+
+CSHA2Impl::~CSHA2Impl()
+	{
+	delete iImplementation;
+	}
+
+void CSHA2Impl::Reset()
+	{
+	iImplementation->Reset(iInitValues);
+	}
+
+void CSHA2Impl::Close()
+	{
+	delete this;	
+	}
+
+MHash* CSHA2Impl::ReplicateL()
+	{	 
+	return CSHA2Impl::NewL(iImplementationUid.iUid);
+	}
+	
+MHash* CSHA2Impl::CopyL()
+	{
+	CSHA2Impl* hash = new(ELeave) CSHA2Impl();
+	CleanupStack::PushL(hash);
+	hash->ConstructL(*this);
+	CleanupStack::Pop(hash);
+	return hash;
+	}
+
+TUid CSHA2Impl::ImplementationUid()
+	{
+	return iImplementationUid; 
+	}
+
+void CSHA2Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	aPluginCharacteristics=NULL;
+	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
+	for (TInt i=0;i<hashNum;i++)
+		{
+		if (KHashCharacteristics[i]->cmn.iImplementationUID == ImplementationUid().iUid)
+			{
+			aPluginCharacteristics = KHashCharacteristics[i];
+			break;
+			}
+		}	
+	}
+
+CExtendedCharacteristics* CSHA2Impl::CreateExtendedCharacteristicsL()
+	{
+	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
+	// for exclusive use and are not CERTIFIED to be standards compliant.
+	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
+	}
+
+const CExtendedCharacteristics* CSHA2Impl::GetExtendedCharacteristicsL()
+	{
+	return CSHA2Impl::CreateExtendedCharacteristicsL();
+	}	
+
+TPtrC8 CSHA2Impl::Hash(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	iImplementation->Update(aMessage.Ptr(),aMessage.Size());
+	iImplementation->StoreState();
+	ptr.Set(iImplementation->Final().Ptr(), iHashSize);
+	iImplementation->RestoreState();
+	return ptr;
+	}
+	
+void CSHA2Impl::Update(const TDesC8& aMessage)
+	{
+	iImplementation->Update(aMessage.Ptr(),aMessage.Size());	
+	}
+	
+TPtrC8 CSHA2Impl::Final(const TDesC8& aMessage)
+	{
+	TPtrC8 ptr(KNullDesC8());
+	if (aMessage!=KNullDesC8())
+		{
+		iImplementation->Update(aMessage.Ptr(),aMessage.Size());			
+		}
+	ptr.Set(iImplementation->Final().Ptr(), iHashSize);
+	Reset();
+	return ptr;
+	}
+
+void CSHA2Impl::RestoreState()
+	{
+	iImplementation->RestoreState();
+	}
+
+void CSHA2Impl::StoreState()
+	{
+	iImplementation->StoreState();
+	}
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
+TAny* CSHA2Impl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return NULL;	
+	}
+
+void CSHA2Impl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
+void CSHA2Impl::SetKeyL(const CKey& /*aKey*/)
+	{
+	User::Leave(KErrNotSupported);
+	}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha2impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,85 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+
+#ifndef __CRYPTOAPI_SOFTWARESHA2IMPL_H_
+#define __CRYPTOAPI_SOFTWARESHA2IMPL_H_
+
+
+#include "softwarehashbase.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	class MSHA2Impl;
+	
+	NONSHARABLE_CLASS(CSHA2Impl) : public CBase, public MSoftwareHash
+		{
+	public:
+		//NewL & NewLC	
+		static CSHA2Impl* NewL(TInt32 aAlgorithmId);
+		static CSHA2Impl* NewLC(TInt32 aAlgorithmId);
+		
+		//From MPlugin
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		static CExtendedCharacteristics* CreateExtendedCharacteristicsL();
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		
+		//From MHash
+		TPtrC8 Hash(const TDesC8& aMessage);
+		void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+		void SetKeyL(const CKey& aKey);
+		void SetOperationModeL(TUid aOperationMode);		
+		
+		//From MSoftwareHash
+		void RestoreState();
+		void StoreState();
+		
+	private:
+		//Constructors
+		void ConstructL(TInt32 aAlgorithmId);
+		void ConstructL(const CSHA2Impl& aSHA512Impl);
+		
+		//Destructor
+		~CSHA2Impl();
+		
+		TUid ImplementationUid();
+
+	private:
+		MSHA2Impl*	iImplementation;
+		const TAny*	iInitValues;
+		TUid		iImplementationUid;
+		TUint		iHashSize;
+		};
+	}
+
+#endif //__CRYPTOAPI_SOFTWARESHA2IMPL_H_
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha384and512impl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,539 @@
+/*
+* Copyright (c) 2007-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: 
+* Common implementation of SHA384 and SHA512
+* RFC 4634 (US Secure Hash Algorithms (SHA and HMAC-SHA))
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <cryptospi/hashplugin.h>
+#include "sha384and512impl.h"
+#include "pluginconfig.h"
+
+/**
+ * SHA512 Constants
+ * 
+ * SHA-512 uses a sequence of eighty constant 64-bit words. 
+ * These words represent the first sixty-four bits of the fractional 
+ * parts of the cube roots of the first eighty prime numbers.
+ * 
+ * FIPS 180-2 Section 4.2.3
+ */
+const TUint64 K[80] = 
+	{
+	UI64LIT(0x428a2f98d728ae22), UI64LIT(0x7137449123ef65cd), UI64LIT(0xb5c0fbcfec4d3b2f), UI64LIT(0xe9b5dba58189dbbc),
+	UI64LIT(0x3956c25bf348b538), UI64LIT(0x59f111f1b605d019), UI64LIT(0x923f82a4af194f9b), UI64LIT(0xab1c5ed5da6d8118),
+	UI64LIT(0xd807aa98a3030242), UI64LIT(0x12835b0145706fbe), UI64LIT(0x243185be4ee4b28c), UI64LIT(0x550c7dc3d5ffb4e2),
+	UI64LIT(0x72be5d74f27b896f), UI64LIT(0x80deb1fe3b1696b1), UI64LIT(0x9bdc06a725c71235), UI64LIT(0xc19bf174cf692694),
+	UI64LIT(0xe49b69c19ef14ad2), UI64LIT(0xefbe4786384f25e3), UI64LIT(0x0fc19dc68b8cd5b5), UI64LIT(0x240ca1cc77ac9c65),
+	UI64LIT(0x2de92c6f592b0275), UI64LIT(0x4a7484aa6ea6e483), UI64LIT(0x5cb0a9dcbd41fbd4), UI64LIT(0x76f988da831153b5),
+	UI64LIT(0x983e5152ee66dfab), UI64LIT(0xa831c66d2db43210), UI64LIT(0xb00327c898fb213f), UI64LIT(0xbf597fc7beef0ee4),
+	UI64LIT(0xc6e00bf33da88fc2), UI64LIT(0xd5a79147930aa725), UI64LIT(0x06ca6351e003826f), UI64LIT(0x142929670a0e6e70),
+	UI64LIT(0x27b70a8546d22ffc), UI64LIT(0x2e1b21385c26c926), UI64LIT(0x4d2c6dfc5ac42aed), UI64LIT(0x53380d139d95b3df),
+	UI64LIT(0x650a73548baf63de), UI64LIT(0x766a0abb3c77b2a8), UI64LIT(0x81c2c92e47edaee6), UI64LIT(0x92722c851482353b),
+	UI64LIT(0xa2bfe8a14cf10364), UI64LIT(0xa81a664bbc423001), UI64LIT(0xc24b8b70d0f89791), UI64LIT(0xc76c51a30654be30),
+	UI64LIT(0xd192e819d6ef5218), UI64LIT(0xd69906245565a910), UI64LIT(0xf40e35855771202a), UI64LIT(0x106aa07032bbd1b8),
+	UI64LIT(0x19a4c116b8d2d0c8), UI64LIT(0x1e376c085141ab53), UI64LIT(0x2748774cdf8eeb99), UI64LIT(0x34b0bcb5e19b48a8),
+	UI64LIT(0x391c0cb3c5c95a63), UI64LIT(0x4ed8aa4ae3418acb), UI64LIT(0x5b9cca4f7763e373), UI64LIT(0x682e6ff3d6b2b8a3),
+	UI64LIT(0x748f82ee5defb2fc), UI64LIT(0x78a5636f43172f60), UI64LIT(0x84c87814a1f0ab72), UI64LIT(0x8cc702081a6439ec),
+	UI64LIT(0x90befffa23631e28), UI64LIT(0xa4506cebde82bde9), UI64LIT(0xbef9a3f7b2c67915), UI64LIT(0xc67178f2e372532b),
+	UI64LIT(0xca273eceea26619c), UI64LIT(0xd186b8c721c0c207), UI64LIT(0xeada7dd6cde0eb1e), UI64LIT(0xf57d4f7fee6ed178),
+	UI64LIT(0x06f067aa72176fba), UI64LIT(0x0a637dc5a2c898a6), UI64LIT(0x113f9804bef90dae), UI64LIT(0x1b710b35131c471b),
+	UI64LIT(0x28db77f523047d84), UI64LIT(0x32caab7b40c72493), UI64LIT(0x3c9ebe0a15c9bebc), UI64LIT(0x431d67c49c100d4c),
+	UI64LIT(0x4cc5d4becb3e42b6), UI64LIT(0x597f299cfc657e2a), UI64LIT(0x5fcb6fab3ad6faec), UI64LIT(0x6c44198c4a475817)
+	};
+
+/**
+ * Define the SHA SIGMA and sigma macros 
+ * 
+ * FIPS 180-2 section 4.1.3
+ */
+// Equation 4.10
+inline TUint64 SHA512_SIGMA0(TUint64 aWord)
+	{
+	return (SHA_ROTR<TUint64>(28,aWord) ^ SHA_ROTR<TUint64>(34,aWord) ^ SHA_ROTR<TUint64>(39,aWord));
+	}
+// Equation 4.11
+inline TUint64 SHA512_SIGMA1(TUint64 aWord)
+	{
+	return (SHA_ROTR<TUint64>(14,aWord) ^ SHA_ROTR<TUint64>(18,aWord) ^ SHA_ROTR<TUint64>(41,aWord));
+	}
+// Equation 4.12
+inline TUint64 SHA512_sigma0(TUint64 aWord)
+	{
+	return (SHA_ROTR<TUint64>(1, aWord) ^ SHA_ROTR<TUint64>(8, aWord) ^ SHA_SHR<TUint64>(7, aWord));
+	}
+// Equation 4.13
+inline TUint64 SHA512_sigma1(TUint64 aWord)
+	{
+	return (SHA_ROTR<TUint64>(19,aWord) ^ SHA_ROTR<TUint64>(61,aWord) ^ SHA_SHR<TUint64>(6,aWord));
+	}
+
+// Macros
+inline TUint64 Make64BitWord(const TUint8* aData)
+	{
+	TUint64 result = (TUint64)aData[0] << 56 | (TUint64)aData[1] << 48 | (TUint64)aData[2] << 40 | 
+					 (TUint64)aData[3] << 32 | (TUint64)aData[4] << 24 | (TUint64)aData[5] << 16 |
+					 (TUint64)aData[6] << 8 | (TUint64)aData[7];
+	return result;
+	}
+
+
+using namespace SoftwareCrypto;
+	
+CSHA384And512Impl* CSHA384And512Impl::NewL(TInt aHashSize)
+	{
+	CSHA384And512Impl* self=new (ELeave) CSHA384And512Impl(aHashSize);
+	return self;						
+	}
+														
+CSHA384And512Impl::CSHA384And512Impl(TInt aHashSize) : iHash(aHashSize)
+	{		
+	}
+	
+CSHA384And512Impl::CSHA384And512Impl(const CSHA384And512Impl& aSHA512Impl)
+				: 	iHash(aSHA512Impl.iHash),
+					iA(aSHA512Impl.iA),
+					iB(aSHA512Impl.iB),
+					iC(aSHA512Impl.iC),
+					iD(aSHA512Impl.iD),
+					iE(aSHA512Impl.iE),
+					iF(aSHA512Impl.iF),
+					iG(aSHA512Impl.iG),
+					iH(aSHA512Impl.iH),
+					iNl(aSHA512Impl.iNl),
+					iNh(aSHA512Impl.iNh),
+					iBlockIndex(aSHA512Impl.iBlockIndex)
+	{
+	Mem::Copy(iData, aSHA512Impl.iData, KSHA512BlockSize*sizeof(TUint64));
+	}
+	
+void CSHA384And512Impl::Reset(const TAny* aValueArr)
+	{
+	const TUint64* values = static_cast<const TUint64*>(aValueArr);
+	/**
+	 * Initial Hash Value
+	 * 
+	 * These words were obtained by taking the first thirty-two bits 
+	 * of the fractional parts of the square roots of the first eight
+	 * prime numbers.
+	 * 
+	 * FIPS 180-2 Section 5.3.2
+	 */
+	iA = values[0];
+	iB = values[1];
+	iC = values[2];
+	iD = values[3];
+	iE = values[4];
+	iF = values[5];
+	iG = values[6];
+	iH = values[7];
+	iNh = 0;
+	iNl = 0;
+	iBlockIndex = 0;
+	}
+
+//This function will panic if the total input length is longer than 2^128 in bits
+_LIT(KPanicString, "Message length exceeds supported length");
+inline void CSHA384And512Impl::AddLength(const TUint64 aLength)
+	{
+	TUint64 temp = iNl;
+	iNl += aLength << 3;
+	__ASSERT_ALWAYS(((iNh != KMaxTUint64) || (temp <= iNl)), User::Panic(KPanicString, KErrOverflow));
+	iNh += (temp > iNl);
+	}
+
+// This assumes a big-endian architecture
+void CSHA384And512Impl::Update(const TUint8* aData,TUint aLength)
+	{
+	while((aLength / 8) > 0 && (iBlockIndex % 8 == 0))
+		{
+		iData[iBlockIndex>>3] = Make64BitWord(aData);
+		iBlockIndex+=8;
+		aData+=8;
+		aLength-=8;
+		if(iBlockIndex==KSHA512BlockSize) 
+			{
+			Block();
+			AddLength(KSHA512BlockSize);
+			}
+		}
+
+	while(aLength--)
+		{
+		if(!(iBlockIndex&0x07))
+			{
+			iData[iBlockIndex >> 3] = 0;
+			}
+		iData[iBlockIndex >> 3] |= static_cast<TUint64>(*aData) << ((7 - iBlockIndex&0x07) << 3) ;
+		++aData;
+		++iBlockIndex;
+		if(iBlockIndex==KSHA512BlockSize) 
+			{
+			Block();
+			AddLength(KSHA512BlockSize);
+			}
+		}
+	}
+
+static inline void CSHA512_16(	const TUint64 aA, 
+								const TUint64 aB, 
+								const TUint64 aC,
+								TUint64& aD, 
+								const TUint64 aE, 
+								const TUint64 aF,
+								const TUint64 aG, 
+								TUint64& aH,
+								TUint64 aTemp1,
+								TUint64 aTemp2,
+								const TUint64 aK,
+								const TUint64 aWord)
+	{
+	aTemp1 = aH + SHA512_SIGMA1(aE) + SHA_Ch(aE,aF,aG) + aK + aWord;
+	aTemp2 = SHA512_SIGMA0(aA) + SHA_Maj(aA,aB,aC);
+	aD = aD + aTemp1;
+	aH = aTemp1 + aTemp2;
+	}
+
+static inline void CSHA512_64(	const TUint64 aA, 
+								const TUint64 aB, 
+								const TUint64 aC,
+								TUint64& aD, 
+								const TUint64 aE, 
+								const TUint64 aF,
+								const TUint64 aG, 
+								TUint64& aH,
+								TUint64 aTemp1,
+								TUint64 aTemp2,
+								const TUint64 aK,
+								TUint64& aWord0,
+								const TUint64 aWord2,
+								const TUint64 aWord7,
+								const TUint64 aWord15,
+								const TUint64 aWord16)
+	{
+	aWord0 = SHA512_sigma1(aWord2) + aWord7 + SHA512_sigma0(aWord15) + aWord16;
+	CSHA512_16(aA, aB, aC, aD, aE, aF, aG, aH, aTemp1, aTemp2, aK, aWord0);
+	}
+
+/**
+ * This function actually calculates the hash.
+ * Function is defined in FIPS 180-2 section 6.3.2
+ * 
+ * This function is the expanded version of the following loop.
+ *	for(TUint i = 0; i < 80; ++i)
+ *		{
+ *		if(i >= 16)
+ *			{
+ *			iData[i] = SHA512_sigma1(iData[i-2]) + iData[i-7] + SHA512_sigma0(iData[i-15]) + iData[i-16];
+ *			}
+ *
+ *		temp1 = tempH + SHA512_SIGMA1(tempE) + SHA_Ch(tempE,tempF,tempG) + K[i] + iData[i];
+ *	    temp2 = SHA512_SIGMA0(tempA) + SHA_Maj(tempA,tempB,tempC);
+ *	    tempH = tempG;
+ *	    tempG = tempF;
+ *	    tempF = tempE;
+ *	    tempE = tempD + temp1;
+ *	    tempD = tempC;
+ *	    tempC = tempB;
+ *	    tempB = tempA;
+ *	    tempA = temp1 + temp2;		
+ *		}
+ */
+void CSHA384And512Impl::Block()
+	{
+	TUint64 tempA=iA;
+	TUint64 tempB=iB;
+	TUint64 tempC=iC;
+	TUint64 tempD=iD;
+	TUint64 tempE=iE;
+	TUint64 tempF=iF;
+	TUint64 tempG=iG;
+	TUint64 tempH=iH;
+	TUint64 temp1=0;
+	TUint64 temp2=0;
+	
+	CSHA512_16(tempA,tempB,tempC,tempD,tempE,tempF,tempG,tempH,temp1,temp2,K[0],iData[0]);
+	CSHA512_16(tempH,tempA,tempB,tempC,tempD,tempE,tempF,tempG,temp1,temp2,K[1],iData[1]);
+	CSHA512_16(tempG,tempH,tempA,tempB,tempC,tempD,tempE,tempF,temp1,temp2,K[2],iData[2]);
+	CSHA512_16(tempF,tempG,tempH,tempA,tempB,tempC,tempD,tempE,temp1,temp2,K[3],iData[3]);
+	CSHA512_16(tempE,tempF,tempG,tempH,tempA,tempB,tempC,tempD,temp1,temp2,K[4],iData[4]);
+	CSHA512_16(tempD,tempE,tempF,tempG,tempH,tempA,tempB,tempC,temp1,temp2,K[5],iData[5]);
+	CSHA512_16(tempC,tempD,tempE,tempF,tempG,tempH,tempA,tempB,temp1,temp2,K[6],iData[6]);
+	CSHA512_16(tempB,tempC,tempD,tempE,tempF,tempG,tempH,tempA,temp1,temp2,K[7],iData[7]);
+
+	CSHA512_16(tempA,tempB,tempC,tempD,tempE,tempF,tempG,tempH,temp1,temp2,K[8],iData[8]);
+	CSHA512_16(tempH,tempA,tempB,tempC,tempD,tempE,tempF,tempG,temp1,temp2,K[9],iData[9]);
+	CSHA512_16(tempG,tempH,tempA,tempB,tempC,tempD,tempE,tempF,temp1,temp2,K[10],iData[10]);
+	CSHA512_16(tempF,tempG,tempH,tempA,tempB,tempC,tempD,tempE,temp1,temp2,K[11],iData[11]);
+	CSHA512_16(tempE,tempF,tempG,tempH,tempA,tempB,tempC,tempD,temp1,temp2,K[12],iData[12]);
+	CSHA512_16(tempD,tempE,tempF,tempG,tempH,tempA,tempB,tempC,temp1,temp2,K[13],iData[13]);
+	CSHA512_16(tempC,tempD,tempE,tempF,tempG,tempH,tempA,tempB,temp1,temp2,K[14],iData[14]);
+	CSHA512_16(tempB,tempC,tempD,tempE,tempF,tempG,tempH,tempA,temp1,temp2,K[15],iData[15]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[16], iData[16], iData[14], iData[9], iData[1], iData[0]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[17], iData[17], iData[15], iData[10], iData[2], iData[1]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[18], iData[18], iData[16], iData[11], iData[3], iData[2]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[19], iData[19], iData[17], iData[12], iData[4], iData[3]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[20], iData[20], iData[18], iData[13], iData[5], iData[4]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[21], iData[21], iData[19], iData[14], iData[6], iData[5]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[22], iData[22], iData[20], iData[15], iData[7], iData[6]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[23], iData[23], iData[21], iData[16], iData[8], iData[7]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[24], iData[24], iData[22], iData[17], iData[9], iData[8]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[25], iData[25], iData[23], iData[18], iData[10], iData[9]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[26], iData[26], iData[24], iData[19], iData[11], iData[10]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[27], iData[27], iData[25], iData[20], iData[12], iData[11]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[28], iData[28], iData[26], iData[21], iData[13], iData[12]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[29], iData[29], iData[27], iData[22], iData[14], iData[13]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[30], iData[30], iData[28], iData[23], iData[15], iData[14]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[31], iData[31], iData[29], iData[24], iData[16], iData[15]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[32], iData[32], iData[30], iData[25], iData[17], iData[16]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[33], iData[33], iData[31], iData[26], iData[18], iData[17]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[34], iData[34], iData[32], iData[27], iData[19], iData[18]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[35], iData[35], iData[33], iData[28], iData[20], iData[19]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[36], iData[36], iData[34], iData[29], iData[21], iData[20]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[37], iData[37], iData[35], iData[30], iData[22], iData[21]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[38], iData[38], iData[36], iData[31], iData[23], iData[22]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[39], iData[39], iData[37], iData[32], iData[24], iData[23]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[40], iData[40], iData[38], iData[33], iData[25], iData[24]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[41], iData[41], iData[39], iData[34], iData[26], iData[25]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[42], iData[42], iData[40], iData[35], iData[27], iData[26]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[43], iData[43], iData[41], iData[36], iData[28], iData[27]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[44], iData[44], iData[42], iData[37], iData[29], iData[28]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[45], iData[45], iData[43], iData[38], iData[30], iData[29]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[46], iData[46], iData[44], iData[39], iData[31], iData[30]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[47], iData[47], iData[45], iData[40], iData[32], iData[31]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[48], iData[48], iData[46], iData[41], iData[33], iData[32]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[49], iData[49], iData[47], iData[42], iData[34], iData[33]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[50], iData[50], iData[48], iData[43], iData[35], iData[34]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[51], iData[51], iData[49], iData[44], iData[36], iData[35]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[52], iData[52], iData[50], iData[45], iData[37], iData[36]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[53], iData[53], iData[51], iData[46], iData[38], iData[37]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[54], iData[54], iData[52], iData[47], iData[39], iData[38]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[55], iData[55], iData[53], iData[48], iData[40], iData[39]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[56], iData[56], iData[54], iData[49], iData[41], iData[40]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[57], iData[57], iData[55], iData[50], iData[42], iData[41]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[58], iData[58], iData[56], iData[51], iData[43], iData[42]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[59], iData[59], iData[57], iData[52], iData[44], iData[43]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[60], iData[60], iData[58], iData[53], iData[45], iData[44]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[61], iData[61], iData[59], iData[54], iData[46], iData[45]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[62], iData[62], iData[60], iData[55], iData[47], iData[46]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[63], iData[63], iData[61], iData[56], iData[48], iData[47]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[64], iData[64], iData[62], iData[57], iData[49], iData[48]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[65], iData[65], iData[63], iData[58], iData[50], iData[49]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[66], iData[66], iData[64], iData[59], iData[51], iData[50]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[67], iData[67], iData[65], iData[60], iData[52], iData[51]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[68], iData[68], iData[66], iData[61], iData[53], iData[52]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[69], iData[69], iData[67], iData[62], iData[54], iData[53]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[70], iData[70], iData[68], iData[63], iData[55], iData[54]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[71], iData[71], iData[69], iData[64], iData[56], iData[55]);
+
+	CSHA512_64(	tempA, tempB, tempC, tempD, tempE, tempF, tempG, tempH, temp1, temp2,
+				K[72], iData[72], iData[70], iData[65], iData[57], iData[56]);
+	CSHA512_64(	tempH, tempA, tempB, tempC, tempD, tempE, tempF, tempG, temp1, temp2,
+				K[73], iData[73], iData[71], iData[66], iData[58], iData[57]);
+	CSHA512_64(	tempG, tempH, tempA, tempB, tempC, tempD, tempE, tempF, temp1, temp2,
+				K[74], iData[74], iData[72], iData[67], iData[59], iData[58]);
+	CSHA512_64(	tempF, tempG, tempH, tempA, tempB, tempC, tempD, tempE, temp1, temp2,
+				K[75], iData[75], iData[73], iData[68], iData[60], iData[59]);
+	CSHA512_64(	tempE, tempF, tempG, tempH, tempA, tempB, tempC, tempD, temp1, temp2,
+				K[76], iData[76], iData[74], iData[69], iData[61], iData[60]);
+	CSHA512_64(	tempD, tempE, tempF, tempG, tempH, tempA, tempB, tempC, temp1, temp2,
+				K[77], iData[77], iData[75], iData[70], iData[62], iData[61]);
+	CSHA512_64(	tempC, tempD, tempE, tempF, tempG, tempH, tempA, tempB, temp1, temp2,
+				K[78], iData[78], iData[76], iData[71], iData[63], iData[62]);
+	CSHA512_64(	tempB, tempC, tempD, tempE, tempF, tempG, tempH, tempA, temp1, temp2,
+				K[79], iData[79], iData[77], iData[72], iData[64], iData[63]);
+
+	iA+=tempA;
+	iB+=tempB;
+	iC+=tempC;
+	iD+=tempD;
+	iE+=tempE;
+	iF+=tempF;
+	iG+=tempG;
+	iH+=tempH;
+
+	iBlockIndex=0;
+	}
+
+/**
+ * According to the standard, the message must be padded to an
+ * even 512 bits. The first padding bit must be a '1'. The last
+ * 64 bits represent the length of the original message. All bits 
+ * in between should be 0. This helper function will pad the 
+ * message according to those rules by filling the iData array 
+ * accordingly. 
+ */ 
+void CSHA384And512Impl::PadMessage()
+	{
+	const TUint64 padByte = 0x80;
+	
+	if(!(iBlockIndex&0x07))
+		{
+		iData[iBlockIndex >> 3] = 0;
+		}
+	iData[iBlockIndex >> 3] |= padByte << ((7 - iBlockIndex&0x07) << 3) ;
+	
+	if (iBlockIndex >= (KSHA512BlockSize - 2*sizeof(TUint64))) 
+		{
+		if (iBlockIndex < (KSHA512BlockSize - sizeof(TUint64)))
+			iData[(KSHA512BlockSize>>3)-1]=0;		
+		Block();
+		Mem::FillZ(iData,KSHA512BlockSize);
+		} 
+	else
+		{
+		const TUint offset=(iBlockIndex+8)>>3; //+8 to account for the word added in the
+		//switch statement above
+		Mem::FillZ(iData+offset, (KSHA512BlockSize - offset*sizeof(TUint64)));
+		}
+
+	iData[(KSHA512BlockSize >> 3) - 2] = iNh;
+	iData[(KSHA512BlockSize >> 3) - 1] = iNl;	
+	}
+
+inline void CSHA384And512Impl::CopyWordToHash(TUint64 aVal, TUint aIndex)
+	{
+	TUint64 value = Make64BitWord(reinterpret_cast<TUint8*>(&aVal));
+	Mem::Copy(const_cast<TUint8*>(iHash.Ptr())+ (8*aIndex), &value, sizeof(aVal));
+	}
+
+const TDesC8& CSHA384And512Impl::Final()
+	{
+	AddLength(iBlockIndex);
+	PadMessage();
+	Block();
+	//
+	// Generate hash value into iHash
+	//
+	CopyWordToHash(iA, 0);
+	CopyWordToHash(iB, 1);
+	CopyWordToHash(iC, 2);
+	CopyWordToHash(iD, 3);
+	CopyWordToHash(iE, 4);
+	CopyWordToHash(iF, 5);
+	CopyWordToHash(iG, 6);
+	CopyWordToHash(iH, 7);
+	
+	return iHash;
+	}
+
+void CSHA384And512Impl::RestoreState()
+	{
+	iA = iACopy;
+	iB = iBCopy;
+	iC = iCCopy;
+	iD = iDCopy;
+	iE = iECopy;
+	iF = iFCopy;
+	iG = iGCopy;
+	iH = iHCopy;
+	iNl = iNlCopy;
+	iNh = iNhCopy;	
+	iBlockIndex = iBlockIndexCopy;
+	Mem::Copy((TAny*)iData, (TAny*)iDataCopy, KSHA512BlockSize*sizeof(TUint64)); 
+	}
+
+void CSHA384And512Impl::StoreState()
+	{
+	iACopy = iA;
+	iBCopy = iB;
+	iCCopy = iC;
+	iDCopy = iD;
+	iECopy = iE;
+	iFCopy = iF;
+	iGCopy = iG;
+	iHCopy = iH;
+	iNlCopy = iNl;
+	iNhCopy = iNh;	
+	iBlockIndexCopy = iBlockIndex;
+	Mem::Copy((TAny*)iDataCopy, (TAny*)iData, KSHA512BlockSize*sizeof(TUint64));
+	}
+
+// Implemented in hmacimpl.cpp or softwarehashbase.cpp
+// but required as derived from MHash. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/sha384and512impl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,102 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+
+#ifndef __CRYPTOAPI_SOFTWARESHA384AND512IMPL_H_
+#define __CRYPTOAPI_SOFTWARESHA384AND512IMPL_H_
+
+
+#include "softwarehashbase.h"
+#include "shacommon.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	const TInt KSHA512BlockSize	= 128;
+	const TInt KSHA384HashSize	= 48;
+	const TInt KSHA512HashSize	= 64;
+			
+	NONSHARABLE_CLASS(CSHA384And512Impl) : public CBase, public MSHA2Impl
+		{	
+	public:
+		//NewL	
+		static CSHA384And512Impl* NewL(TInt aHashSize = KSHA512HashSize);
+		CSHA384And512Impl(const CSHA384And512Impl& aSHA512Impl);
+		
+		//From MSHAImpl
+		virtual void Reset(const TAny* aValueArr);
+		virtual const TDesC8& Final(void);
+		virtual void Update(const TUint8* aData,TUint aLength);
+		virtual void StoreState();
+		virtual void RestoreState();
+
+	private:
+		//Constructors
+		CSHA384And512Impl(TInt aHashSize);
+
+	private:
+		// Private member functions
+		/**
+		 * @param aLength - Length of message added in bytes.
+		 */ 
+		inline void AddLength(const TUint64 aLength);
+		inline void CopyWordToHash(TUint64 aVal, TUint aIndex);
+		void Block();
+		void PadMessage();
+
+	private:
+		TBuf8<KSHA512HashSize> iHash;
+		TUint64 iA;
+		TUint64 iB;
+		TUint64 iC;
+		TUint64 iD;
+		TUint64 iE;
+		TUint64 iF;
+		TUint64 iG;
+		TUint64 iH;
+		TUint64 iData[KSHA512BlockSize];
+
+		TUint64 iACopy;
+		TUint64 iBCopy;
+		TUint64 iCCopy;
+		TUint64 iDCopy;
+		TUint64 iECopy;
+		TUint64 iFCopy;
+		TUint64 iGCopy;
+		TUint64 iHCopy;
+		TUint64 iNlCopy;
+		TUint64 iNhCopy;
+		TUint	iBlockIndexCopy;
+		TUint64 iDataCopy[KSHA512BlockSize];
+		
+		TUint64 iNl; // Lower word of Message Length
+		TUint64 iNh; // Higher word of Message Length
+		TUint iBlockIndex; // Message Length in the current block
+		};
+	}
+
+#endif // __CRYPTOAPI_SOFTWARESHA384AND512IMPL_H_
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/shacommon.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,123 @@
+#ifndef __CRYPTOAPI_SOFTWARESHACOMMON_H_
+#define __CRYPTOAPI_SOFTWARESHACOMMON_H_/*
+* Copyright (c) 2007-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: 
+* sha256impl.h
+* Same as used in SHA1
+* SHA_CH		> CSHA1_F
+* SHA_Maj		> CSHA1_H
+* SHA_Parity	> CSHA1_G
+* The following definitions are equivalent and potentially faster.
+* #define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
+* #define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))
+* These functions are defined in FIPS 180-2 Section 4.1
+* Equation 4.1, 4.2, 4.3, 4.8, 4.9
+*
+*/
+
+
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+template<typename T>
+inline T SHA_Ch(T aX, T aY, T aZ)
+	{
+	return ((aX & aY) ^ ((~aX) & aZ));
+	}
+
+template<typename T>
+inline T SHA_Maj(T aX, T aY, T aZ)
+	{
+	return ((aX & aY) ^ (aX & aZ) ^ (aY & aZ));
+	}
+
+template<typename T>
+inline T SHA_Parity(T aX, T aY, T aZ)
+	{
+	return (aX ^ aY ^ aZ);
+	}
+
+/**
+ * Define the SHA shift, and rotate right macro 
+ * Defined in FIPS 180-2 Section 3.2
+ */
+/** 
+ * SHA Right Shift operation: The right shift operation SHR^n(x), 
+ * where x is a w-bit word and n is an integer with 0 <= n < w, 
+ * is defined by  SHR^n(x) = x >> n.
+ */
+template<typename T>
+inline T SHA_SHR(T aBits, T aWord)
+	{
+	return (aWord >> aBits);
+	}
+
+/**
+ * SHA Rotate Right Operation: The rotate right (circular right shift) operation
+ * ROTR^n(x), where x is a w-bit word and n is an integer with 0 <= n < w, 
+ * is defined by ROTR n(x)=(x >> n) || (x << w - n).
+ */
+template<typename T>
+inline T SHA_ROTR(T aBits, T aWord)
+	{
+	TInt totalBits = sizeof(T) << 3;
+	return ((aWord >> aBits) | (aWord << (totalBits-aBits)));
+	}
+
+namespace SoftwareCrypto
+{
+
+NONSHARABLE_CLASS(MSHA2Impl)
+	{
+public:
+	/**
+	 * This function will reset the state of hash.
+	 */
+	virtual void Reset(const TAny*) = 0;
+	/**
+	 * This function will finalize the hash and return
+	 * the calculated hash.
+	 * @return Final hash
+	 */ 
+	virtual const TDesC8& Final() = 0;
+	/**
+	 * This function will add the message to the internal
+	 * buffer and if the block size is reached then calcualte
+	 * the hash till that point.
+	 * @param aMessage Message to be updated.
+	 * @param aLength Length of the message to be updated.
+	 */ 
+	virtual void Update(const TUint8* aMessage, TUint aLength) = 0;
+	/**
+	 * This function will save the internal state of the hash.
+	 */ 
+	virtual void StoreState() = 0;
+	/**
+	 * This function will retrieve the saved the internal state 
+	 * of the hash.
+	 */ 
+	virtual void RestoreState() = 0;
+	/**
+	 * virtual distructor.
+	 */
+	virtual ~MSHA2Impl(){}
+	};
+	
+}//namespace SoftwareCrypto
+
+#endif //__CRYPTOAPI_SOFTWARESHACOMMON_H_
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/signerimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,108 @@
+/*
+* Copyright (c) 2006-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 <e32def.h>
+#include <e32cmn.h>
+#include "keys.h"
+#include <cryptospi/cryptospidef.h>
+
+#include "signerimpl.h"
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+
+CSignerImpl::CSignerImpl()
+	{
+	}
+
+CSignerImpl::~CSignerImpl()
+	{
+	delete iKey;
+	}
+
+void CSignerImpl::Close()
+	{
+	delete this;
+	}
+	
+void CSignerImpl::Reset()
+	{
+	}
+	
+TAny* CSignerImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return 0;
+	}
+	
+void CSignerImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)
+	{
+	TInt numCiphers = sizeof(KSignerCharacteristics)/sizeof(TAsymmetricSignatureCharacteristics*);
+	TInt32 implUid = ImplementationUid().iUid;
+	for (TInt i = 0; i < numCiphers; ++i)
+		{
+		if (KSignerCharacteristics[i]->cmn.iImplementationUID == implUid)
+			{
+			aPluginCharacteristics = KSignerCharacteristics[i];
+			break;
+			}
+		}
+	}
+
+void CSignerImpl::DoSetKeyL(const CKey& aPrivateKey)
+	{
+	delete iKey;
+	iKey = CKey::NewL(aPrivateKey);
+	}
+
+void CSignerImpl::ConstructL(const CKey& aPrivateKey)
+	{
+	SetKeyL(aPrivateKey);
+	}
+
+
+// Methods implemented in subclass. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+void CSignerImpl::SetPaddingModeL(TUid /*aPaddingMode*/)
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
+	
+void CSignerImpl::SetKeyL(const CKey& /*aPrivateKey*/) 
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
+
+TInt CSignerImpl::GetMaximumInputLengthL() const 
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
+
+TInt CSignerImpl::GetMaximumOutputLengthL() const
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/signerimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,95 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef __SIGNERIMPL_H__
+#define __SIGNERIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+#include "signerplugin.h"
+#include <padding.h>
+
+#include "common/inlines.h"
+
+/**
+ * Abstract base class for signer plug-ins.
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CSignerImpl) : public CBase, public MSigner
+		{
+	public:
+		// Override MPlugin virtual functions
+		void Close();
+		void Reset(); // Always call reset in super-class if you override this
+		TAny* GetExtension(TUid aExtensionId);
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		// End of MPlugin
+
+		// Override MSignatureBase virtual functions
+		virtual void SetPaddingModeL(TUid aPaddingMode);
+		virtual void SetKeyL(const CKey& aPrivateKey);
+		virtual TInt GetMaximumInputLengthL() const;
+		virtual TInt GetMaximumOutputLengthL() const;
+		// End of MSignatureBase
+
+		/// Destructor
+		~CSignerImpl();
+		
+	protected:
+		/// Constructor
+		CSignerImpl();
+
+		/**
+		Second phase of construction
+		@param aKey The signing key
+		*/
+		virtual void ConstructL(const CKey& aKey);
+		
+		/**
+		Helper function implemented by concrete cipher sub-class that allows
+		GetCharacteristicsL to return the correct characteristics object.
+		@return The implemention uid
+		*/
+		virtual TUid ImplementationUid() const = 0;
+		
+		/**
+		Store the signing key. The key length is also checked to meet export restrictions and
+		to ensure that it is appropriate for the cipher.
+		@param aKey The key
+		*/
+		virtual void DoSetKeyL(const CKey& aKey);
+
+	protected:
+		/// the key, extracted from a CKey object
+		CKey* iKey;
+
+	private:
+		};
+	}
+
+#endif // __SIGNERIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/softwarehashbase.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,326 @@
+/*
+* Copyright (c) 2007-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: 
+* software hash base class implementation
+* software hash base class implementation
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "softwarehashbase.h"
+
+#include <cryptospi/hashplugin.h>
+#include "pluginconfig.h"
+#include "keys.h"
+#include "md2impl.h"
+#include "md5impl.h"
+#include "md4impl.h"
+#include "sha1impl.h"
+#include "sha2impl.h"
+#include "hmacimpl.h"
+
+using namespace SoftwareCrypto;
+
+CSoftwareHash* CSoftwareHash::NewL(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey)
+	{
+	CSoftwareHash* self=NewLC(aAlgorithm, aOperationMode, aKey);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CSoftwareHash* CSoftwareHash::NewL(TUid aAlgorithm)
+	{
+	CSoftwareHash* self=NewLC(aAlgorithm, CryptoSpi::KHashModeUid, NULL);
+	CleanupStack::Pop();
+	return self;
+	}
+
+CSoftwareHash* CSoftwareHash::NewLC(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey)
+	{
+	CSoftwareHash* self=new (ELeave) CSoftwareHash();
+	CleanupStack::PushL(self);
+	self->ConstructL(aAlgorithm, aOperationMode, aKey);
+	return self;
+	}
+
+CSoftwareHash::CSoftwareHash()
+	{		
+	}
+
+CSoftwareHash::~CSoftwareHash()
+	{
+	if (iHashImpl)
+		{
+		iHashImpl->Close();			
+		}
+
+	if (iHmacImpl)
+		{
+		iHmacImpl->Close();
+		}
+	delete iKey;
+	}
+
+void CSoftwareHash::ConstructL(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey)
+	{
+	//
+	// Only Hash and Hmac mode are supported.
+	//
+	if (aOperationMode!=KHmacModeUid && aOperationMode!=KHashModeUid)
+		{
+		User::Leave(KErrNotSupported);			
+		}
+		
+	//Set the key if there is one
+	if (aKey)
+		{
+		SetKeyL(*aKey);
+		}
+	
+	switch (aAlgorithm.iUid)
+		{
+	case KCryptoPluginMd2:
+		{
+		iHashImpl=CMD2Impl::NewL();
+		}
+		break;
+		
+	case KCryptoPluginMd5:
+		{
+		iHashImpl=CMD5Impl::NewL();
+		}
+		break;
+		
+	case KCryptoPluginMd4:
+		{
+		iHashImpl=CMD4Impl::NewL();
+		}
+		break;
+
+	case KCryptoPluginSha1:
+		{
+		iHashImpl=CSHA1Impl::NewL();
+		}
+		break;
+		
+	case KCryptoPluginSha224:
+	case KCryptoPluginSha256:
+	case KCryptoPluginSha384:
+	case KCryptoPluginSha512:
+		{
+		iHashImpl=CSHA2Impl::NewL(aAlgorithm.iUid);
+		}
+		break;
+		
+	default:
+		User::Leave(KErrNotSupported);
+		}
+		
+	SetOperationModeL(aOperationMode);
+	}
+
+void CSoftwareHash::SetOperationModeL(TUid aOperationMode)
+	{
+	switch (aOperationMode.iUid)
+		{
+	case KHmacMode:
+		{
+		//
+		//Only create hmac implementation if there isn't one
+		//
+		if (!iHmacImpl)
+			{
+			if (iKey)
+				{
+				iHmacImpl=CHMacImpl::NewL(*iKey, iHashImpl);	
+				}
+			else
+				{
+				iHmacImpl=CHMacImpl::NewL(iHashImpl);
+				}							
+			}
+		}
+		break;
+		
+	case KHashMode:
+		{
+		Reset();	
+		}
+		break;
+		
+	default:
+		User::Leave(KErrNotSupported);
+		}
+		
+	//
+	// Set the operation mode.
+	//
+	iOperationMode=aOperationMode;
+	}
+
+MSoftwareHash* CSoftwareHash::Impl()
+	{
+	MSoftwareHash* impl=NULL;
+	if (iOperationMode==KHashModeUid)
+		{
+		impl=iHashImpl;
+		}
+	else if (iOperationMode==KHmacModeUid && iKey)
+			{
+			impl=iHmacImpl;
+			}
+	return impl;
+	}
+	
+void CSoftwareHash::SetKeyL(const CKey& aKey)
+	{
+	Reset();
+	delete iKey;
+	iKey=CKey::NewL(aKey);
+	if (iHmacImpl)
+		{
+		iHmacImpl->SetKeyL(aKey);
+		}
+	}
+	
+void CSoftwareHash::Reset()
+	{
+	if (iHashImpl)
+		{
+		iHashImpl->Reset();			
+		}
+		
+	if (iHmacImpl)
+		{
+		iHmacImpl->Reset();			
+		}
+	}
+	
+void CSoftwareHash::Close()
+	{
+	delete this;
+	}
+	
+void CSoftwareHash::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
+	{
+	MSoftwareHash* impl=Impl();
+	if (impl)
+		{
+		impl->GetCharacteristicsL(aPluginCharacteristics);			
+		}
+	else
+		{
+		User::Leave(KErrNotReady);
+		}		
+	}
+	
+const CExtendedCharacteristics* CSoftwareHash::GetExtendedCharacteristicsL()
+	{
+	MSoftwareHash* impl=Impl();
+	if (!impl)
+		{
+		User::Leave(KErrNotReady);	
+		}
+	return impl->GetExtendedCharacteristicsL();
+	}
+	
+TAny* CSoftwareHash::GetExtension(TUid aExtensionId)
+	{
+	MSoftwareHash* impl=Impl();
+	if (impl)
+		{
+		return impl->GetExtension(aExtensionId);			
+		}
+	else
+		{
+		return NULL;	
+		}
+	}
+
+TPtrC8 CSoftwareHash::Hash(const TDesC8& aMessage)
+	{
+	MSoftwareHash* impl=Impl();
+	if (impl)
+		{
+		return impl->Hash(aMessage);			
+		}
+	else
+		{
+		return KNullDesC8();
+		}
+	}
+	
+void CSoftwareHash::Update(const TDesC8& aMessage)
+	{
+	MSoftwareHash* impl=Impl();
+	if (impl)
+		{
+		return impl->Update(aMessage);
+		}
+	}
+	
+TPtrC8 CSoftwareHash::Final(const TDesC8& aMessage)
+	{
+	MSoftwareHash* impl=Impl();
+	if (impl)
+		{
+		return impl->Final(aMessage);
+		}
+	else
+		{
+		return KNullDesC8();
+		}
+	}
+	
+MHash* CSoftwareHash::ReplicateL()
+	{
+	CSoftwareHash* that=new(ELeave)CSoftwareHash();
+	CleanupStack::PushL(that);
+	if (this->iKey)
+		{
+		that->iKey=CKey::NewL(*this->iKey);			
+		}
+	that->iOperationMode=this->iOperationMode;
+	that->iHashImpl=static_cast<MSoftwareHash*>(this->iHashImpl->ReplicateL());
+	if (this->iHmacImpl)
+		{
+		that->iHmacImpl=static_cast<MSoftwareHash*>(this->iHmacImpl->ReplicateL());			
+		}
+	CleanupStack::Pop();
+	return that;
+	}
+	
+MHash* CSoftwareHash::CopyL()
+	{
+	CSoftwareHash* that=new(ELeave)CSoftwareHash();
+	CleanupStack::PushL(that);
+	if (this->iKey)
+		{
+		that->iKey=CKey::NewL(*this->iKey);			
+		}
+	that->iOperationMode=this->iOperationMode;
+	that->iHashImpl=static_cast<MSoftwareHash*>(this->iHashImpl->CopyL());
+	if (this->iHmacImpl)
+		{
+		that->iHmacImpl=static_cast<MSoftwareHash*>(this->iHmacImpl->CopyL());
+		}
+	CleanupStack::Pop();
+	return that;
+	}
+		
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/softwarehashbase.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,130 @@
+/*
+* Copyright (c) 2006-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: 
+* Software hash base definition
+*
+*/
+
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __CRYPTOAPI_SOFTWAREHASHBASE_H__
+#define __CRYPTOAPI_SOFTWAREHASHBASE_H__
+
+#include <cryptospi/hashplugin.h>
+#include "keys.h"
+
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	/**
+	Interfaces for Software Hash
+	*/
+	class MSoftwareHash : public MHash
+		{
+	public:
+		/**
+		Restores the internal state of the message digest
+		to a previously stored state.
+		*/
+		virtual void RestoreState() = 0;
+
+		/**
+		Stores the internal state of the message digest.
+		*/
+		virtual void StoreState() = 0;
+		};
+			
+	/**
+	Proxy class Software Hash and Hmac implementation
+	*/
+	NONSHARABLE_CLASS(CSoftwareHash) : public MHash, public CBase
+		{
+	public:
+		//
+		//NewL & NewLC
+		//
+		static CSoftwareHash* NewL(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey);
+		static CSoftwareHash* NewLC(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey);
+		static CSoftwareHash* NewL(TUid aAlgorithm);
+
+		//
+		// Destructor
+		//
+		~CSoftwareHash();
+		//
+		//From MPlugin
+		//
+		void Reset();
+		void Close();		
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);		
+		const CExtendedCharacteristics* GetExtendedCharacteristicsL();
+		TAny* GetExtension(TUid aExtensionId);
+		//
+		//From MHash
+		//
+	    TPtrC8 Hash(const TDesC8& aMessage);
+	    void Update(const TDesC8& aMessage);
+		TPtrC8 Final(const TDesC8& aMessage);
+		MHash* ReplicateL();		
+		MHash* CopyL();
+		void SetKeyL(const CKey& aKey);			
+		void SetOperationModeL(TUid aOperationMode);
+	
+	private:
+		//
+		//Constructor
+		// 
+		CSoftwareHash();
+		void ConstructL(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey);
+		
+		//
+		//get the active implementation
+		//
+		MSoftwareHash* Impl();
+		
+	private:
+		/**
+		The Key for HMAC mode operation
+		*/
+		CKey* iKey;
+		
+		/**
+		The Uid for the operation mode
+		*/
+		TUid iOperationMode;
+		
+		/**
+		The hash implementation
+		*/
+		MSoftwareHash* iHashImpl;
+		
+		/**
+		The Hmac implementation
+		*/
+		MSoftwareHash* iHmacImpl;
+		};
+		
+	GLDEF_C inline TUint CMD_R(TUint a,TUint s)
+		{
+		return (a<<s) | (a>>(32-s));
+		}
+	}
+	
+
+#endif // __CRYPTOAPI_SOFTWAREHASHBASE_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/symmetriccipherimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,650 @@
+/*
+* Copyright (c) 2007-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 "symmetriccipherimpl.h"
+
+#include <e32def.h>
+#include <cryptostrength.h>
+#include <cryptospi/cryptospidef.h>
+#include "keys.h"
+#include <cryptopanic.h>
+#include <cryptospi/plugincharacteristics.h>
+#include "pluginconfig.h"
+#include <securityerr.h>
+#include "common/inlines.h"
+
+using namespace SoftwareCrypto;
+
+//
+// Implementation of Symmetric Cipher class
+//
+CSymmetricCipherImpl::CSymmetricCipherImpl() 
+	{
+	}
+
+void CSymmetricCipherImpl::ConstructL(const CKey& aKey) 
+	{
+	DoSetKeyL(aKey);		
+	}
+	
+void CSymmetricCipherImpl::SecureDelete(HBufC8*& aBuffer)
+	{
+	if (aBuffer)
+		{
+		aBuffer->Des().FillZ();
+		}
+	delete aBuffer;
+	aBuffer = 0;	
+	}
+
+CSymmetricCipherImpl::~CSymmetricCipherImpl()
+	{			
+	SecureDelete(iKey);	
+	}
+		
+void CSymmetricCipherImpl::Close()
+	{
+	delete this;
+	}
+	
+TAny* CSymmetricCipherImpl::GetExtension(TUid /*aExtensionId*/) 
+	{
+	return 0;
+	}
+	
+void CSymmetricCipherImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)
+	{
+	TInt numCiphers = sizeof(KSymmetricCipherCharacteristics)/sizeof(TSymmetricCipherCharacteristics*);
+	TInt32 implUid = ImplementationUid().iUid;
+	for (TInt i = 0; i < numCiphers; ++i)
+		{
+		if (KSymmetricCipherCharacteristics[i]->cmn.iImplementationUID == implUid)
+			{
+			aPluginCharacteristics = KSymmetricCipherCharacteristics[i];
+			break;
+			}
+		}	
+	}
+
+TInt CSymmetricCipherImpl::GetKeyStrength() const
+	{
+	return BytesToBits(iKey->Length());
+	}
+	
+HBufC8* CSymmetricCipherImpl::ExtractKeyDataLC(const CKey& aKey) const
+	{
+	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);
+	return keyContent.AllocLC();
+	}
+
+TInt CSymmetricCipherImpl::KeySize() const
+	{
+	// return key size in BITS
+	return BytesToBits(iKeyBytes);
+	}
+
+void CSymmetricCipherImpl::DoSetKeyL(const CKey& aKey)
+	{
+	HBufC8* key = ExtractKeyDataLC(aKey);
+	TInt keyLength(key->Length());
+	
+	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyLength));
+	if (! IsValidKeyLength(keyLength))
+		{
+		CleanupStack::PopAndDestroy(key);
+		User::Leave(KErrNotSupported);
+		}
+	
+	SecureDelete(iKey);	
+	CleanupStack::Pop(key);
+	iKey = key;
+	iKeyBytes = keyLength;
+	}	
+
+//
+// Implementation of Symmetric Stream Cipher
+//
+CSymmetricStreamCipherImpl::CSymmetricStreamCipherImpl()
+	{
+	}
+
+CSymmetricStreamCipherImpl::~CSymmetricStreamCipherImpl()
+	{
+	}
+
+void CSymmetricStreamCipherImpl::SetKeyL(const CKey& aKey)
+	{
+	DoSetKeyL(aKey);
+	TCrypto::IsSymmetricWeakEnoughL(GetKeyStrength());
+	Reset();
+	}	
+
+void CSymmetricStreamCipherImpl::ConstructL(const CKey& aKey) 
+	{
+	CSymmetricCipherImpl::ConstructL(aKey);
+	}
+
+TInt CSymmetricStreamCipherImpl::BlockSize() const
+	{
+	// return block size in BITS
+	return BYTE_BITS;
+	}
+
+void CSymmetricStreamCipherImpl::SetCryptoModeL(TUid /*aCryptoMode*/)
+	{
+	// Call the reset method.
+	Reset();
+	}
+	
+TInt CSymmetricStreamCipherImpl::MaxOutputLength(TInt aInputLength) const
+	{
+	return aInputLength;	
+	}
+	
+TInt CSymmetricStreamCipherImpl::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	return aInputLength;	
+	}
+	
+void CSymmetricStreamCipherImpl::ProcessL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TInt outputIndex = aOutput.Size();
+
+	// aOutput may already have outputIndex bytes of data in it
+	// check there will still be enough space to process the result
+	__ASSERT_DEBUG(aOutput.MaxLength() - outputIndex >= MaxOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
+
+	aOutput.Append(aInput);
+
+	TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, aInput.Size(),
+		aInput.Size());
+	DoProcess(transformBuf);
+	}
+
+void CSymmetricStreamCipherImpl::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	ProcessL(aInput, aOutput);	
+	}
+
+//
+// Implementation of Symmetric Block Cipher
+//
+CSymmetricBlockCipherImpl::CSymmetricBlockCipherImpl(
+	TUint8 aBlockBytes,
+	TUid aCryptoMode,
+	TUid aOperationMode,
+	TUid aPaddingMode) :
+	iBlockBytes(aBlockBytes),
+	iCryptoMode(aCryptoMode),
+	iOperationMode(aOperationMode),
+	iPaddingMode(aPaddingMode),
+	iBufferedPlaintextPtr(0,0,0),
+	iCtrUnusedKeystreamPtr(0,0,0)
+	{
+	}
+
+CSymmetricBlockCipherImpl::~CSymmetricBlockCipherImpl()
+	{			
+	delete iPadding;
+	delete [] iRegister;
+	delete [] iCurrentCipherText;
+	delete iBufferedPlaintext;
+	delete iCtrUnusedKeystream;
+	iIv.Close();
+	iInputStore.Close();
+	iPaddingBlock.Close();	
+	}
+
+
+void CSymmetricBlockCipherImpl::ConstructL(const CKey& aKey) 
+	{
+	CSymmetricCipherImpl::ConstructL(aKey);
+	DoSetOperationModeL(iOperationMode);
+	DoSetCryptoModeL(iCryptoMode);	
+	DoSetPaddingModeL(iPaddingMode);
+	
+	iInputStore.ReAllocL(iBlockBytes);
+	iPaddingBlock.ReAllocL(iBlockBytes);
+
+	iRegister = new(ELeave) TUint32[iBlockBytes/4];	
+	iRegisterPtr = reinterpret_cast<TUint8*>(iRegister);
+
+	iCurrentCipherText = new(ELeave) TUint32[iBlockBytes/4];	
+	iCurrentCipherTextPtr = reinterpret_cast<TUint8*>(iCurrentCipherText);
+	
+	iBufferedPlaintext = HBufC8::NewL(iBlockBytes);
+	iBufferedPlaintextPtr.Set(iBufferedPlaintext->Des());
+	
+	iCtrUnusedKeystream = HBufC8::NewL(iBlockBytes);
+	iCtrUnusedKeystreamPtr.Set(iCtrUnusedKeystream->Des());
+	}
+
+void CSymmetricBlockCipherImpl::Reset()
+	{
+	iInputStore.Zero();
+	iPaddingBlock.Zero();
+	iCtrUnusedKeystreamPtr.Zero();
+	
+	if (iOperationMode.iUid == KOperationModeCBC)
+		{
+		// only copy the IV if it is already set
+		if (iIv.MaxLength() > 0)
+			{
+			Mem::Copy(iRegisterPtr, &iIv[0], iBlockBytes);
+			}
+		}
+	}	
+
+void CSymmetricBlockCipherImpl::SetKeyL(const CKey& aKey)
+	{
+	DoSetKeyL(aKey);
+	TCrypto::IsSymmetricWeakEnoughL(GetKeyStrength());
+	SetKeySchedule();
+	Reset();
+	}
+
+void CSymmetricBlockCipherImpl::SetOperationModeL(TUid aOperationMode)
+	{
+	DoSetOperationModeL(aOperationMode);
+	Reset();
+	}
+	
+void CSymmetricBlockCipherImpl::SetCryptoModeL(TUid aCryptoMode)
+	{
+	DoSetCryptoModeL(aCryptoMode);
+	SetKeySchedule();
+	Reset();
+	}
+	
+void CSymmetricBlockCipherImpl::SetPaddingModeL(TUid aPaddingMode)
+	{
+	DoSetPaddingModeL(aPaddingMode);
+	Reset();
+	}
+	
+void CSymmetricBlockCipherImpl::SetIvL(const TDesC8& aIv)
+	{
+	if ((iOperationMode.iUid != KOperationModeCBC) && (iOperationMode.iUid != KOperationModeCTR))
+		{
+		User::Leave(KErrNotSupported);
+		}
+	DoSetIvL(aIv);
+	Reset();
+	}
+
+void CSymmetricBlockCipherImpl::DoSetOperationModeL(TUid aOperationMode)
+	{
+	switch (aOperationMode.iUid)
+		{
+		case KOperationModeNone:
+		case KOperationModeECB:
+		case KOperationModeCBC:
+			break;
+		case KOperationModeCTR:
+			SetCryptoModeL(KCryptoModeEncryptUid);
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+	iOperationMode = aOperationMode;		
+	}
+
+void CSymmetricBlockCipherImpl::DoSetCryptoModeL(TUid aCryptoMode)
+	{
+	switch (aCryptoMode.iUid)
+		{
+		case KCryptoModeEncrypt:
+			break;
+		case KCryptoModeDecrypt:
+			if (iOperationMode.iUid == KOperationModeCTR)
+				{
+				return;
+				}
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+	iCryptoMode = aCryptoMode;		
+	}
+
+void CSymmetricBlockCipherImpl::DoSetPaddingModeL(TUid aPaddingMode)
+	{
+	CPadding* padding(0);
+	switch (aPaddingMode.iUid)
+		{
+		case KPaddingModeNone:
+			padding = CPaddingNone::NewL(iBlockBytes);
+		break;
+		case KPaddingModeSSLv3:
+			padding = CPaddingSSLv3::NewL(iBlockBytes);
+		break;
+		case KPaddingModePKCS7:
+			padding = CPaddingPKCS7::NewL(iBlockBytes);
+		break;
+		default:
+			User::Leave(KErrNotSupported);
+		}
+	delete iPadding;
+	iPadding = padding;
+	iPaddingMode = aPaddingMode;
+	}	
+
+void CSymmetricBlockCipherImpl::DoSetIvL(const TDesC8& aIv)
+	{
+	iIv.ReAllocL(iBlockBytes);
+	iIv.SetLength(iBlockBytes);
+
+	iIv.Zero();
+	if (aIv.Length() != iBlockBytes) 
+		{
+		User::Leave(KErrArgument);
+		}
+	iIv = aIv;
+	Mem::Copy(iRegisterPtr, &iIv[0], iBlockBytes);	//for CTR mode
+
+	}	
+
+TInt CSymmetricBlockCipherImpl::BlockSize() const
+	{
+	// return block size in BITS
+	if (iOperationMode.iUid == KOperationModeCTR)
+		{
+		return 8;
+		}
+	else
+		{
+		return BytesToBits(iBlockBytes);
+		}
+	}
+
+TInt CSymmetricBlockCipherImpl::MaxOutputLength(TInt aInputLength) const
+	{	
+	if (iOperationMode.iUid == KOperationModeCTR)
+		{
+		return aInputLength;
+		}
+	else
+		{
+		// The maximum output length required for Process is equal to the
+		// size of the number of whole input blocks available.
+		//
+		// The block bytes is a power of two so we can use this to avoid
+		// doing a real mod operation
+		TUint inputStoreLength(iInputStore.Length());
+		TInt rem = (aInputLength + inputStoreLength) & (iBlockBytes - 1);
+		return (aInputLength + inputStoreLength - rem);
+		}
+	}	
+
+TInt CSymmetricBlockCipherImpl::MaxFinalOutputLength(TInt aInputLength) const
+	{
+	if (iOperationMode.iUid == KOperationModeCTR)
+		{
+		return aInputLength;
+		}
+	else if (iCryptoMode.iUid == KCryptoModeEncrypt)
+		{
+		return iPadding->MaxPaddedLength(iInputStore.Length() + aInputLength);
+		}
+	else
+		{
+		return iPadding->MaxUnPaddedLength(aInputLength + iInputStore.Size());
+		}
+	}
+
+void CSymmetricBlockCipherImpl::ProcessL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	// if we're running in CBC or CTR mode then we must have an IV set before we can 
+	// do any processing ie call SetIvL() before this method
+	if ((iOperationMode.iUid == KOperationModeCBC) || (iOperationMode.iUid == KOperationModeCTR))
+		{
+		if (iIv.MaxLength() == 0)
+			{
+			User::Leave(KErrNotSupported);
+			}
+		}
+
+	TInt inputLength(aInput.Length());	
+	TInt inputStoreLength(iInputStore.Length());
+	
+	if (MaxOutputLength(inputLength) > aOutput.MaxLength())
+		{
+		User::Leave(KErrOverflow);
+		}	
+
+	if (iOperationMode.iUid == KOperationModeCTR)
+		{
+		ProcessCtrL(aInput, aOutput);
+		}	
+	else
+		{
+		TUint8 blockSizeLog = CryptoLog2(iBlockBytes);
+		TInt wholeBlocks = (inputLength + inputStoreLength) >> blockSizeLog; 
+		TInt wholeBlocksSize = wholeBlocks << blockSizeLog;
+	
+		if (wholeBlocks)
+			{
+			TInt outputLength(aOutput.Length());
+
+			if (inputStoreLength > 0)
+				{
+				aOutput.Append(iInputStore);
+				iInputStore.Zero();
+				}
+			aOutput.Append(aInput.Left(wholeBlocksSize - inputStoreLength));
+			Transform(const_cast<TUint8*>(aOutput.Ptr()) + outputLength, wholeBlocks);
+			}
+		
+		TInt remainingBytes = inputLength + inputStoreLength - wholeBlocksSize;
+		if (remainingBytes > 0)
+			{		
+			iInputStore.Append(aInput.Right(remainingBytes));
+			}
+		}
+	}
+		
+void CSymmetricBlockCipherImpl::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	if (iOperationMode.iUid == KOperationModeCTR)
+		{
+		ProcessL(aInput, aOutput);
+		}
+	else
+		{
+		// if we're running in CBC mode then we must have an IV set before we can 
+		// do any processing ie call SetIvL() before this method
+		if (iOperationMode.iUid == KOperationModeCBC)
+			{
+			if (iIv.MaxLength() == 0)
+				{
+				User::Leave(KErrNotSupported);
+				}
+			}
+
+		if (iCryptoMode.iUid == KCryptoModeEncrypt)
+			{
+			return DoProcessFinalEncryptL(aInput, aOutput);
+			}
+		else
+			{
+			return DoProcessFinalDecryptL(aInput, aOutput);
+			}
+		}
+	}
+
+void CSymmetricBlockCipherImpl::DoProcessFinalEncryptL(const TDesC8& aInput, TDes8& aOutput)
+	{	
+	if (MaxFinalOutputLength(aInput.Length()) > aOutput.MaxLength() - aOutput.Length())
+		{
+		User::Leave(KErrOverflow);
+		}
+		
+	// process everything up to the last (possibly empty block)
+	TInt outputStartIndex = aOutput.Length();
+	ProcessL(aInput, aOutput);
+
+	// pad the plaintext
+	iPadding->PadL(iInputStore, iPaddingBlock);
+	
+	// if padding required
+	if (iPaddingBlock.Length() > 0)
+		{
+		iInputStore.Zero();
+
+		// make sure the output is a multiple of the block size
+		User::LeaveIfError(((aOutput.Length() - outputStartIndex + iPaddingBlock.Length()) % iBlockBytes) == 0 ? KErrNone : KErrInvalidPadding);
+
+		outputStartIndex = aOutput.Length();
+		aOutput.Append(iPaddingBlock);
+		iPaddingBlock.Zero();
+		TransformEncrypt(const_cast<TUint8*>(aOutput.Ptr()) + outputStartIndex, 1);		
+		}
+	}
+
+void CSymmetricBlockCipherImpl::DoProcessFinalDecryptL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	if (MaxFinalOutputLength(aInput.Length()) > aOutput.MaxLength() - aOutput.Length())
+		{
+		User::Leave(KErrOverflow);
+		}
+
+	// Input length (including inputstore) must be a multiple of the 
+	// block size in length
+	if ((aInput.Length() + iInputStore.Length()) & (iBlockBytes - 1)) 
+		{
+		User::Leave(KErrArgument);
+		}
+
+	if(aInput.Length() > iBlockBytes)
+		{
+		HBufC8* processBuf = HBufC8::NewLC(MaxFinalOutputLength(aInput.Length()));
+		TPtr8 processPtr = processBuf->Des(); 
+	
+		ProcessL(aInput, processPtr);
+
+		ASSERT(iInputStore.Length()==0); // all the blocks should have been decrypted
+		
+		// Unpad processPtr into aOutput
+		iPadding->UnPadL(processPtr, aOutput);
+
+		CleanupStack::PopAndDestroy(processBuf);
+		}
+	else 
+		{
+		// now contains the final ciphertext block
+		iInputStore.Append(aInput);
+
+		// Decrypt the last _padding_ blocksize into a new buffer
+		TransformDecrypt(const_cast<TUint8*>(iInputStore.Ptr()), 1);
+		
+		// Unpad the last block and append to output
+		iPadding->UnPadL(iInputStore, aOutput);
+		}
+			
+	iPaddingBlock.Zero();
+	iInputStore.Zero();
+	}
+
+	
+/**
+CTR mode behaves like a stream cipher, accepting input of any arbitrary length. This results 
+in a significant body of code that behaves fundamentally differently to the ECB and CBC modes. 
+ProcessCtrL() is called by ProcessL() when operating in CTR mode, wrapping up all this 
+functionality into a separate method for clarity.
+
+Encrypting zero-filled bytes will return the keystream since the output of Transformation is simply 
+the input XORed with the keystream.
+	
+See: http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
+*/
+void CSymmetricBlockCipherImpl::ProcessCtrL(const TDesC8& aInput, TDes8& aOutput)
+	{
+	TInt inputLength(aInput.Length());	
+
+	TInt outputLength(aOutput.Length());
+	TInt amountToXor = Min(iCtrUnusedKeystreamPtr.Length(), inputLength);
+
+	// Try applying previously unused key stream bytes.
+	if (amountToXor > 0)
+		{
+		aOutput.Append(aInput.Left(amountToXor));
+		for (TInt i = 0; i < amountToXor; ++i)
+			{
+			aOutput[outputLength + i] ^= iCtrUnusedKeystreamPtr[i];
+			}
+		iCtrUnusedKeystreamPtr = iCtrUnusedKeystreamPtr.RightTPtr((iCtrUnusedKeystreamPtr.Length() - amountToXor));	
+		}
+		
+	TInt amountToEncode = inputLength - amountToXor;
+	
+	if ((iCtrUnusedKeystreamPtr.Length() == 0) && (amountToEncode > 0))
+		{
+		// For each whole block's worth of input, transform it.
+		TInt wholeBlocks = (amountToEncode) / iBlockBytes; 
+		TInt wholeBlocksSize = wholeBlocks * iBlockBytes;		
+		outputLength = aOutput.Length();
+		
+		if (wholeBlocks)
+			{
+			aOutput.Append(aInput.Mid(amountToXor, wholeBlocksSize));
+			Transform(const_cast<TUint8*>(aOutput.Ptr()) + outputLength, wholeBlocks);
+			}
+			
+		// CTR mode can handle arbitrary sized inputs. Here any remaining input data of less than the block size
+		// is padded with zeros and then transformed. On return this padded section of the block will contain the next
+		// sequence of keystream, which is copied to iCtrUnusedKeystream for use next time ProcessCtrL() is called.
+		TInt remainingBytes = amountToEncode - wholeBlocksSize;
+		iCtrUnusedKeystreamPtr = iCtrUnusedKeystream->Des();
+		iCtrUnusedKeystreamPtr.SetMax();
+		iCtrUnusedKeystreamPtr.FillZ();
+		iCtrUnusedKeystreamPtr.Copy(aInput.Right(remainingBytes));
+		iCtrUnusedKeystreamPtr.SetLength(iBlockBytes);	
+	
+		Transform(const_cast<TUint8*>(iCtrUnusedKeystreamPtr.Ptr()), 1);
+	
+		aOutput.Append(iCtrUnusedKeystreamPtr.Left(remainingBytes));
+			
+		iCtrUnusedKeystreamPtr = iCtrUnusedKeystreamPtr.RightTPtr((iCtrUnusedKeystreamPtr.Length() - remainingBytes));	
+		}
+	}
+
+
+
+// Methods implemented in subclass. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+void CSymmetricStreamCipherImpl::SetOperationModeL(TUid /*aOperationMode*/)
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
+	
+void CSymmetricStreamCipherImpl::SetPaddingModeL(TUid /*aPaddingMode*/)
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
+	
+void CSymmetricStreamCipherImpl::SetIvL(const TDesC8& /*aIv*/)
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/symmetriccipherimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,401 @@
+/*
+* Copyright (c) 2006-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: 
+*
+*/
+
+
+#ifndef	__SYMMETRICCIPHERIMPL_H__
+#define	__SYMMETRICCIPHERIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+#include <padding.h>
+#include "symmetriccipherplugin.h"
+
+/** The maximum block size supported (in bytes) */
+const TUint KMaxBlockSizeSupported = 32;
+
+/**
+Abstract base class for symmetric cipher plug-ins.
+*/
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+		
+	NONSHARABLE_CLASS(CSymmetricCipherImpl) : public CBase, public MSymmetricCipher
+		{
+	public:
+		/**
+		Implemented by each cipher subclass to determine whether the
+		specified key length is valid for that cipher.
+		This is called by ConstructL and SetKeyL
+		@param aKeyLength The key length in bytes to verify.
+		*/
+		virtual TBool IsValidKeyLength(TInt aKeyBytes) const = 0;
+		
+		/**
+		Helper function implemented by concrete cipher sub-class that 
+		allows GetCharacteristicsL to return the correct characteristics object.
+		@return The implemention uid
+		*/
+		virtual TUid ImplementationUid() const = 0;
+		
+		/**
+		Gets the strength of the current key, needed to check whether the cipher
+		may operate if strong cryptography is not enabled.
+		@return The strength of the current key
+		*/
+		virtual TInt GetKeyStrength() const;
+		
+				
+		// Override MPlugin virtual functions
+		void Close();
+		TAny* GetExtension(TUid aExtensionId);
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		// End of MPlugin
+		
+		// Override MSymmetricCipherBase virtual functions 
+		TInt KeySize() const;
+						
+		/// Destructor
+		~CSymmetricCipherImpl();
+
+	protected:
+		
+		//Constructor
+		CSymmetricCipherImpl();
+		
+		/**
+		Second phase of construction. Always call ConstructL in the super-class
+		if your override this method.
+		
+		@param aKey The key to initialise the cipher with.
+		*/
+		virtual void ConstructL(const CKey& aKey);		
+		
+		/**
+		Extracts the raw symmetric key from a generic key object. The buffer
+		is placed on the cleanup stack.
+		
+		@param aKey The key object
+		@return A buffer containing the raw key value
+		*/
+		HBufC8* ExtractKeyDataLC(const CKey& aKey) const;	
+	
+		/**
+		Zeros a buffer before deleting it to ensure that
+		the contents will not be visible to another process if the page
+		is re-used.
+		@param aBuffer The pointer (possibly null) to the buffer to delete. This
+		is set to null after deletion.
+		*/
+		void SecureDelete(HBufC8*& aBuffer);		
+					
+		/**
+		Extracts the raw key from aKey and sets iKey and iKeyBytes
+		The key length is also checked to meet export restrictions and
+		to ensure that it is appropriate for the cipher.
+		@param aKey The key
+		*/
+		virtual void DoSetKeyL(const CKey& aKey);
+		
+			
+	protected:
+		/// the key, extracted from a CKey object
+		HBufC8* iKey;
+		
+		/// key size in bytes
+		TUint iKeyBytes;
+		
+		};
+
+	NONSHARABLE_CLASS(CSymmetricStreamCipherImpl) : public CSymmetricCipherImpl
+		{
+	public:
+		// Destructor
+		~CSymmetricStreamCipherImpl();
+		
+		// Override MSymmetricCipherBase virtual functions 
+		TInt BlockSize() const;
+		void SetKeyL(const CKey& aKey);		// override DoSetKeyL instead
+		void SetCryptoModeL(TUid aCryptoMode);
+		void SetOperationModeL(TUid aOperationMode);
+		void SetPaddingModeL(TUid aPaddingMode);
+		void SetIvL(const TDesC8& aIv);
+		TInt MaxOutputLength(TInt aInputLength) const;
+		TInt MaxFinalOutputLength(TInt aInputLength) const;
+		// End of MSymmetricCipherBase
+		
+		// Override MSymmetricCipher virtual functions
+		void ProcessL(const TDesC8& aInput, TDes8& aOutput);
+		void ProcessFinalL(const TDesC8& aInput, TDes8& aOutput);						
+		// End of MSymmetricCipher 
+	
+	protected:
+		// Constructor
+		CSymmetricStreamCipherImpl();
+		
+		// Override CSymmetricCipherImpl virtual functions
+		virtual void ConstructL(const CKey& aKey);
+
+		/**	
+		Performs an encryption or decryption on supplied data.
+		@param aData	On input, data to be transformed; 
+						on return, transformed data.
+		*/
+		virtual void DoProcess(TDes8& aData) = 0;
+		};
+
+	NONSHARABLE_CLASS(CSymmetricBlockCipherImpl) : public CSymmetricCipherImpl
+		{
+	public:	
+
+
+		/**
+		This function is invoked by SetKey and SetCryptoMode
+		allowing the cipher sub-class to rebuild it's key schedule. 
+		N.B. It is assumed that the key schedule is NOT modified
+		by TransformEncrypt or TransformDecrypt
+		*/
+		virtual void SetKeySchedule() = 0;
+		
+		// Override MPlugin virtual functions		
+		void Reset(); // Always call reset in super-class if you override this
+		// End of MPlugin virtual functions
+
+		// Override MSymmetricCipherBase virtual functions 
+		TInt BlockSize() const;
+		void SetKeyL(const CKey& aKey);  				// override DoSetKeyL instead
+		void SetCryptoModeL(TUid aCryptoMode);			// override DoSetCryptoModeL instead
+		void SetOperationModeL(TUid aOperationMode);	// override DoSetOperationMode instead		
+		void SetPaddingModeL(TUid aPaddingMode);		// override DoSetPaddingModeL instead
+		void SetIvL(const TDesC8& aIv);
+		
+		TInt MaxOutputLength(TInt aInputLength) const;
+		TInt MaxFinalOutputLength(TInt aInputLength) const;
+		// End of MSymmetricCipherBase
+
+		// Override MSymmetricCipher virtual functions
+		void ProcessL(const TDesC8& aInput, TDes8& aOutput);
+		void ProcessFinalL(const TDesC8& aInput, TDes8& aOutput);						
+		// End of MSymmetricCipher
+
+		/// Destructor
+		~CSymmetricBlockCipherImpl();		
+	protected:	
+		/**
+		Constructor
+		@param aBlockBytes The block size in bytes
+		@param aOperationMode The mode of operation e.g. CBC
+		@param aCryptoMode Whether to encrypt or decrypt
+		*/
+		CSymmetricBlockCipherImpl(
+			TUint8 aBlockBytes,
+			TUid aOperationMode,
+			TUid aCryptoMode,
+			TUid aPaddingMode);
+			
+		// Override CSymmetricCipherImpl virtual functions
+		virtual void ConstructL(const CKey& aKey);
+
+		/**
+		Validates and sets the crypto mode (iCryptoMode)
+		@param aCryptoMode The crypto mode
+		*/	
+		virtual void DoSetCryptoModeL(TUid aCryptoMode);
+		
+		/**
+		Validates and sets the operation mode (iOperationMode)
+		@param aOperationMode The operation mode
+		*/
+		virtual void DoSetOperationModeL(TUid aOperationMode);
+		
+		/**
+		Validates and sets the padding mode (iPaddingMode & iPadding)
+		@param aPadding The desired padding mode
+		*/
+		virtual void DoSetPaddingModeL(TUid aPadding);
+		
+		void DoSetIvL(const TDesC8& aIv);
+
+		inline void ModeEncryptStart(TUint8* aBuffer);
+		inline void ModeEncryptEnd(TUint8* aBuffer);
+		inline void ModeDecryptStart(TUint8* aBuffer);
+		inline void ModeDecryptEnd(TUint8* aBuffer);
+
+	private:
+	
+		/**
+		Encrypts a number of blocks of data
+		
+		@param aBuffer The buffer containing exactly aNumBlocks of data to destructively encrypt
+		@param aNumBlocks The number of blocks of data to encrypt
+		*/
+		virtual void TransformEncrypt(TUint8* aBuffer, TUint aNumBlocks) = 0;
+		
+		/**
+		Decrypts a number of blocks of data
+				
+		@param aBuffer The buffer containing exactly aNumBlocks of data to destructively decrypt
+		@param aNumBlocks The number of blocks of data to decrypt
+		*/
+		virtual void TransformDecrypt(TUint8* aBuffer, TUint aNumBlocks) = 0;		
+			
+		/// Pad the last block and encrypt
+		void DoProcessFinalEncryptL(const TDesC8& aInput, TDes8& aOutput);
+		
+		/// Decrypt and unpad the last block
+		void DoProcessFinalDecryptL(const TDesC8& aInput, TDes8& aOutput);		
+		
+		inline void Transform(TUint8* aBuffer, TUint aNumBlocks);
+
+		void ProcessCtrL(const TDesC8& aInput, TDes8& aOutput);
+		
+	protected:
+	
+		/// block size in bytes, current largest block size is 16 bytes (AES)
+		TUint8 iBlockBytes;	
+		/// encryption or decryption
+		TUid iCryptoMode;		
+		/// The block cipher mode e.g. ECB, CBC
+		TUid iOperationMode;
+		/// the current padding scheme
+		TUid iPaddingMode;
+		
+		/// the initialisation vector
+		RBuf8 iIv;
+		
+		/// current padding scheme implementation
+		CPadding* iPadding;
+		/// buffer to store blocks
+		RBuf8 iInputStore;
+		/// buffer to store input / output of padding
+		RBuf8 iPaddingBlock;
+
+		/// The current block of cipher text - for CBC 
+		TUint32* iCurrentCipherText;	
+		/// A pointer to the current block of cipher text
+		TUint8* iCurrentCipherTextPtr;		
+		
+		/** Used in both CBC and CTR mode. In CBC mode it stores the result of the last transform. In CTR mode 
+		it stores the counter.*/
+		TUint32* iRegister;	
+		/** A pointer to iRegister.*/
+		TUint8* iRegisterPtr;			
+		
+		/** Used in CTR mode to buffer plaintext during encryption.*/
+		HBufC8* iBufferedPlaintext;
+		/** Pointer to manipulate iBufferedPlaintext.*/
+		TPtr8 iBufferedPlaintextPtr;
+		
+		/** CTR mode behaves like a stream cipher allowing arbitrary sized inputs to the encryption/decryption functions. 
+		When handling an input whose length is not a multiple of the blocksize iCtrUnusedKeystream is used to buffer
+		the unused portions of keystream for use in the next call. Cleared in Reset().*/
+		HBufC8* iCtrUnusedKeystream;
+		/** Pointer to manipulate iCtrUnusedKeystream.*/
+		TPtr8 iCtrUnusedKeystreamPtr;
+		};
+
+
+	inline void CSymmetricBlockCipherImpl::Transform(TUint8* aBuffer, TUint aNumBlocks)
+		{				
+		if (iCryptoMode.iUid == KCryptoModeEncrypt)	//if in CTR mode always in crypto mode encrypt
+			{				
+			TransformEncrypt(aBuffer, aNumBlocks);
+			}
+		else if (iCryptoMode.iUid == KCryptoModeDecrypt)
+			{				
+			TransformDecrypt(aBuffer, aNumBlocks);
+			}
+		else 
+			{
+			ASSERT(EFalse);
+			}
+		}
+			
+	inline void CSymmetricBlockCipherImpl::ModeEncryptStart(TUint8* aBuffer)
+		{
+		if (iOperationMode.iUid == KOperationModeCBC)
+			{			
+			for (TInt i = 0; i < iBlockBytes; ++i)
+				{
+				aBuffer[i] ^= iRegisterPtr[i];
+				}					
+			}
+		else if (iOperationMode.iUid == KOperationModeCTR)
+			{
+			iBufferedPlaintextPtr.Copy(aBuffer, iBlockBytes);
+			Mem::Copy(aBuffer, iRegister, iBlockBytes);				
+			}
+		}		
+	
+	inline void CSymmetricBlockCipherImpl::ModeEncryptEnd(TUint8* aBuffer)
+		{				
+		if (iOperationMode.iUid == KOperationModeCBC)
+			{
+			for (TInt i = 0; i < iBlockBytes; ++i)
+				{
+				iRegisterPtr[i] = aBuffer[i]; 
+				}													
+			}
+		else if (iOperationMode.iUid == KOperationModeCTR)
+			{
+			//XOR the plaintext with the keystream and increment counter
+			for (TInt i = 0; i < iBlockBytes; ++i)
+				{
+				aBuffer[i] ^= iBufferedPlaintextPtr[i]; 
+				}
+			for (TInt i = iBlockBytes - 1; i >= 0; --i)
+				{
+				if (++(iRegisterPtr[i]) != 0) break;				
+				}
+			}										
+		}		
+
+	inline void CSymmetricBlockCipherImpl::ModeDecryptStart(TUint8* aBuffer)
+		{
+		__ASSERT_DEBUG((iOperationMode.iUid != KOperationModeCTR), User::Panic(_L("CSymmetricBlockCipherImpl.h"), 1));
+		if (iOperationMode.iUid == KOperationModeCBC)
+			{			
+			for (TInt i = 0; i < iBlockBytes; ++i)
+				{
+				iCurrentCipherTextPtr[i] = aBuffer[i];
+				}
+			}
+		}
+
+	inline void CSymmetricBlockCipherImpl::ModeDecryptEnd(TUint8* aBuffer)
+		{
+		__ASSERT_DEBUG((iOperationMode.iUid != KOperationModeCTR), User::Panic(_L("CSymmetricBlockCipherImpl.h"), 2));		
+		if (iOperationMode.iUid == KOperationModeCBC)
+			{			
+			// xor the output with the previous cipher text
+			for (TInt i = 0; i < iBlockBytes; ++i)
+				{
+				aBuffer[i] ^= iRegisterPtr[i];
+				iRegisterPtr[i] = iCurrentCipherTextPtr[i];
+				}
+			}	
+		}		
+	}						
+
+#endif	//	__SYMMETRICCIPHERIMPL_H__
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/verifierimpl.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,108 @@
+/*
+* Copyright (c) 2006-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 <e32def.h>
+#include <e32cmn.h>
+#include "keys.h"
+
+#include "verifierimpl.h"
+
+#include <cryptospi/cryptospidef.h>
+#include "pluginconfig.h"
+
+using namespace SoftwareCrypto;
+
+CVerifierImpl::CVerifierImpl()
+	{
+	}
+
+CVerifierImpl::~CVerifierImpl()
+	{
+	delete iKey;
+	}
+
+void CVerifierImpl::Close()
+	{
+	delete this;
+	}
+	
+void CVerifierImpl::Reset()
+	{
+	}
+	
+TAny* CVerifierImpl::GetExtension(TUid /*aExtensionId*/)
+	{
+	return 0;
+	}
+	
+void CVerifierImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)
+	{
+	TInt numCiphers = sizeof(KVerifierCharacteristics)/sizeof(TAsymmetricSignatureCharacteristics*);
+	TInt32 implUid = ImplementationUid().iUid;
+	for (TInt i = 0; i < numCiphers; ++i)
+		{
+		if (KVerifierCharacteristics[i]->cmn.iImplementationUID == implUid)
+			{
+			aPluginCharacteristics = KVerifierCharacteristics[i];
+			break;
+			}
+		}
+	}
+
+void CVerifierImpl::DoSetKeyL(const CKey& aKey)
+	{
+	delete iKey;
+	iKey = CKey::NewL(aKey);
+	}
+
+void CVerifierImpl::ConstructL(const CKey& aPrivateKey)
+	{
+	SetKeyL(aPrivateKey);	
+	}
+
+// Methods implemented in subclass. No coverage here.
+#ifdef _BullseyeCoverage
+#pragma suppress_warnings on
+#pragma BullseyeCoverage off
+#pragma suppress_warnings off
+#endif
+void CVerifierImpl::SetPaddingModeL(TUid /*aPaddingMode*/) 
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
+
+void CVerifierImpl::SetKeyL(const CKey& /*aPublicKey*/)
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	}
+
+TInt CVerifierImpl::GetMaximumInputLengthL() const
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
+
+TInt CVerifierImpl::GetMaximumOutputLengthL() const
+	{
+	// Override in subclass
+	User::Leave(KErrNotSupported);
+	return 0;
+	}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/source/softwarecrypto/verifierimpl.h	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,95 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+#ifndef __VERIFIERIMPL_H__
+#define __VERIFIERIMPL_H__
+
+/**
+@file 
+@internalComponent
+@released
+*/
+
+#include <e32base.h>
+#include <e32cmn.h>
+#include <cryptospi/cryptospidef.h>
+#include <padding.h>
+#include "verifierplugin.h"
+
+#include "common/inlines.h"
+
+/**
+ * Abstract base class for verifier plug-ins.
+ */
+namespace SoftwareCrypto
+	{
+	using namespace CryptoSpi;
+	
+	NONSHARABLE_CLASS(CVerifierImpl) : public CBase, public MVerifier
+		{
+	public:
+		// Override MPlugin virtual functions
+		void Close();
+		void Reset(); // Always call reset in super-class if you override this
+		TAny* GetExtension(TUid aExtensionId);
+		void GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics);
+		// End of MPlugin
+		
+		// Override MSignatureBase virtual functions
+		virtual void SetPaddingModeL(TUid aPaddingMode);
+		virtual void SetKeyL(const CKey& aPrivateKey);
+		virtual TInt GetMaximumInputLengthL() const;
+		virtual TInt GetMaximumOutputLengthL() const;
+		// End of MSignatureBase
+		
+		// Override MVerifier virtual functions
+		virtual void VerifyL(const TDesC8& aInput, const CCryptoParams& aSignature, TBool& aVerificationResult) = 0;
+		virtual void InverseSignL(HBufC8*& aOutput, const CCryptoParams& aSignature) = 0;
+		// End of MVerifier
+		
+		/// Destructor
+		~CVerifierImpl();
+		
+	protected:
+		/// Constructor
+		CVerifierImpl();
+		
+		virtual void ConstructL(const CKey& aKey);
+			
+		/**
+		Helper function implemented by concrete cipher sub-class that allows
+		GetCharacteristicsL to return the correct characteristics object.
+		@return The implemention uid
+		*/
+		virtual TUid ImplementationUid() const = 0;
+		
+		/**
+		Store the key to use for verifying.
+		The key length is also checked to meet export restrictions and
+		to ensure that it is appropriate for the cipher.
+		@param aKey The key
+		*/
+		virtual void DoSetKeyL(const CKey& aKey);
+		
+	protected:
+		/// the key
+		CKey* iKey;
+		};
+	}
+
+#endif // __VERIFIERIMPL_H__
--- a/cryptoplugins/cryptospiplugins/test/h4drv/crypto_h4/tcrypto.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoplugins/cryptospiplugins/test/h4drv/crypto_h4/tcrypto.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -31,6 +31,8 @@
 #include <padding.h>
 #include <bufferedtransformation.h>
 #include <random.h>
+#include <e32def_private.h>
+
 _LIT(KTxtEPOC32EX,"tcrypto: mainL failed");
 _LIT(KTxtPressAnyKey," [press any key]");
 
--- a/cryptoservices/certificateandkeymgmt/crypto/Signed.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/certificateandkeymgmt/crypto/Signed.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -453,6 +453,27 @@
 		digest = CSHA1::NewL();
 		break;
 		}
+	case ESHA224:
+	    {
+	    digest = CSHA2::NewL(E224Bit);
+	    break;
+	    }
+	case ESHA256:
+	    {
+	    digest = CSHA2::NewL(E256Bit);
+	    break;
+	    }
+	case ESHA384:
+	    {
+	    digest = CSHA2::NewL(E384Bit);
+	    break;
+	    }
+	case ESHA512:
+	    {
+	    digest = CSHA2::NewL(E512Bit);
+	    break;
+	    }
+
 	default:
 		User::Leave(KErrArgument);
 		}
@@ -508,62 +529,8 @@
 	aStream.WriteInt32L(iEncoding->Length());
 	aStream.WriteL(*iEncoding);
 	}
-/*
-EXPORT_C void CSignedObject::ConstructL(RReadStream& aStream, TSignedObjectParser* aParser, TKeyFactory* aFactory)
-	{
-	if (iParser != NULL)
-		{
-		delete iParser;
-		iParser = NULL;
-		}
-	iParser = aParser;
-	if (iKeyFactory != NULL)
-		{
-		delete iKeyFactory;
-		iKeyFactory = NULL;
-		}
-	iKeyFactory = aFactory;
-	if (iEncoding != NULL)
-		{
-		User::Leave(KErrGeneral);
-		}
-	TInt len = aStream.ReadInt32L();
-	iEncoding = HBufC8::NewL(aStream,len);
-	DoConstructL();
-	}
 
-EXPORT_C void CSignedObject::ConstructL(const TPtrC8& aBinaryData, TSignedObjectParser* aParser, TKeyFactory* aFactory)
-	{
-	iParser = aParser;
-	iKeyFactory = aFactory;
-	//take a copy of the whole thing
-	iEncoding = aBinaryData.AllocL();
-	DoConstructL();
-	}
 
-EXPORT_C void CSignedObject::ConstructL(const CSignedObject& aSignedObject, TSignedObjectParser* aParser, TKeyFactory* aFactory)
-	{
-	iParser = aParser;
-	iKeyFactory = aFactory;
-	iEncoding = aSignedObject.iEncoding->AllocL();
-	iFingerprint = aSignedObject.iFingerprint->AllocL();
-	iSignature = aSignedObject.iSignature->AllocL();
-	iSigningAlgorithm = CSigningAlgorithmIdentifier::NewL(*(aSignedObject.iSigningAlgorithm));
-	}
-
-void CSignedObject::DoConstructL()
-	{
-	//generate your fingerprint
-	CMD5* hash = CMD5::NewL();
-	CleanupStack::PushL(hash);
-	iFingerprint = hash->Hash(Encoding()).AllocL();
-	CleanupStack::PopAndDestroy();
-	//ask the parser for the signature
-	iSignature = iParser->SignatureL(Encoding());
-	//ask the parser for the algorithm ID
-	iSigningAlgorithm = iParser->AlgorithmIdL(Encoding());
-	}
-*/
 //****************************************************************************************//
 //certificate base
 EXPORT_C CCertificate::~CCertificate()
--- a/cryptoservices/certificateandkeymgmt/group/bld.inf	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/certificateandkeymgmt/group/bld.inf	Fri Nov 06 13:21:00 2009 +0200
@@ -567,6 +567,10 @@
 
 ../tcertstore/scripts/t_certstore.ini				/epoc32/winscw/c/t_certstore.ini
 ../tcertstore/scripts/t_certstore_2.ini				/epoc32/winscw/c/t_certstore_2.ini
+../tcertstore/scripts/t_certstore_sha2.script			/epoc32/winscw/c/tcertstore/scripts/t_certstore_sha2.script
+../tcertstore/scripts/t_certstore_sha2.ini			/epoc32/winscw/c/tcertstore/scripts/t_certstore_sha2.ini
+../tcertstore/scripts/t_certstore_sha2.txt			/epoc32/winscw/c/tcertstore/scripts/t_certstore_sha2.txt
+
 
 
 ../tcertstore/runtest/nightrun.txt		/epoc32/winscw/c/tcertstore/runtest/nightrun.txt
--- a/cryptoservices/certificateandkeymgmt/inc/certmantests.iby	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/certificateandkeymgmt/inc/certmantests.iby	Fri Nov 06 13:21:00 2009 +0200
@@ -442,6 +442,9 @@
 data = ABI_DIR\BUILD_DIR\t_certstore.exe				sys\bin\t_certstore.exe
 
 //scripts
+data = ZDRIVE\tcertstore\scripts\t_certstore_sha2.txt			tcertstore\scripts\t_certstore_sha2.txt attrib=r
+data = ZDRIVE\tcertstore\scripts\t_certstore_sha2.script		tcertstore\scripts\t_certstore_sha2.script attrib=r
+data = ZDRIVE\tcertstore\scripts\t_certstore_sha2.ini			tcertstore\scripts\t_certstore_sha2.ini attrib=r
 data = ZDRIVE\tcertstoreconcurrent\scripts\certstoreconcurrent1.txt	tcertstoreconcurrent\scripts\certstoreconcurrent1.txt attrib=r
 data = ZDRIVE\tcertstoreconcurrent\scripts\certstoreconcurrent2.txt	tcertstoreconcurrent\scripts\certstoreconcurrent2.txt attrib=r
 data = ZDRIVE\tcertstoreconcurrent\scripts\certstoreconcurrent3.txt	tcertstoreconcurrent\scripts\certstoreconcurrent3.txt attrib=r
@@ -483,6 +486,10 @@
 
 
 // Data
+data = ZDRIVE\tcertstore\serv-rootCA-sha384.der				\tcertstore\serv-rootCA-sha384.der attrib=r
+data = ZDRIVE\tcertstore\serv-rootCA-sha256.der				\tcertstore\serv-rootCA-sha256.der attrib=r
+data = ZDRIVE\tcertstore\serv-rootCA-sha224.der				\tcertstore\serv-rootCA-sha224.der attrib=r
+data = ZDRIVE\tcertstore\serv-rootCA-sha512.der				\tcertstore\serv-rootCA-sha512.der attrib=r
 data = ZDRIVE\tcertstore\thawteserverca.cer				\tcertstore\thawteserverca.cer attrib=r
 data = ZDRIVE\tcertstore\Dsa-ca.cer					\tcertstore\Dsa-ca.cer attrib=r
 data = ZDRIVE\tcertstore\ent-wtls.cer					\tcertstore\ent-wtls.cer attrib=r
--- a/cryptoservices/certificateandkeymgmt/inc/signed.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/certificateandkeymgmt/inc/signed.h	Fri Nov 06 13:21:00 2009 +0200
@@ -51,7 +51,15 @@
 	/** A MD5 algorithm. */
 	EMD5,
 	/** A SHA-1 algorithm. */
-	ESHA1
+	ESHA1,
+	/** A SHA-224 algorithm. */
+	ESHA224,
+	/** A SHA-256 algorithm. */
+	ESHA256,
+	/** A SHA-384 algorithm. */
+	ESHA384,
+	/** A SHA-512 algorithm. */
+	ESHA512
 	};
 
 class CValidityPeriod : public CBase
--- a/cryptoservices/certificateandkeymgmt/inc/x509cert.h	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/certificateandkeymgmt/inc/x509cert.h	Fri Nov 06 13:21:00 2009 +0200
@@ -33,18 +33,31 @@
 #include <x500dn.h>
 #include <asn1enc.h>
 
+_LIT(KRSA,"1.2.840.113549.1.1.1");
 _LIT(KMD2WithRSA,"1.2.840.113549.1.1.2");
 _LIT(KMD5WithRSA,"1.2.840.113549.1.1.4");
 _LIT(KSHA1WithRSA,"1.2.840.113549.1.1.5");
-_LIT(KDSAWithSHA1,"1.2.840.10040.4.3");
+
+_LIT(KSHA256WithRSA,"1.2.840.113549.1.1.11");
+_LIT(KSHA384WithRSA,"1.2.840.113549.1.1.12");
+_LIT(KSHA512WithRSA,"1.2.840.113549.1.1.13");
+_LIT(KSHA224WithRSA,"1.2.840.113549.1.1.14");
 
-_LIT(KRSA,"1.2.840.113549.1.1.1");
+_LIT(KDSA,"1.2.840.10040.4.1");
+_LIT(KDSAWithSHA1,	"1.2.840.10040.4.3");
+
 _LIT(KDH,"1.2.840.10046.2.1");
-_LIT(KDSA,"1.2.840.10040.4.1");
+
 _LIT(KMD5,"1.2.840.113549.2.5");
 _LIT(KMD2,"1.2.840.113549.2.2");
 _LIT(KSHA1,"1.3.14.3.2.26");
 
+_LIT(KSHA256,"2.16.840.1.101.3.4.2.1");
+_LIT(KSHA384,"2.16.840.1.101.3.4.2.2");
+_LIT(KSHA512,"2.16.840.1.101.3.4.2.3");
+_LIT(KSHA224,"2.16.840.1.101.3.4.2.4");
+
+
 /** The maximum number of allowed data elements.
 * 
 * @since v7.0 */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/tcertstore/scripts/t_certstore_sha2.ini	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,148 @@
+[SEC-CERTMAN-TCERTSTORESHA2-0001-001]
+<actionbody>
+	<mode>write</mode>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-002]
+<actionbody>
+	<format>X509</format>
+	<label>Rootca-SHA224</label>
+	<issuerkey></issuerkey>
+	<subjectkey></subjectkey>
+	<certstore>0</certstore>
+	<certfile>c:\tcertstore\serv-rootca-sha224.der</certfile>
+	<certowner>ca</certowner>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-003]
+<actionbody>
+	<format>X509</format>
+	<label>Rootca-SHA256</label>
+	<issuerkey></issuerkey>
+	<subjectkey></subjectkey>
+	<certstore>0</certstore>
+	<certfile>c:\tcertstore\serv-rootca-sha256.der</certfile>
+	<certowner>ca</certowner>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-004]
+<actionbody>
+	<format>X509</format>
+	<label>Rootca-SHA384</label>
+	<issuerkey></issuerkey>
+	<subjectkey></subjectkey>
+	<certstore>0</certstore>
+	<certfile>c:\tcertstore\serv-rootca-sha384.der</certfile>
+	<certowner>ca</certowner>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-005]
+<actionbody>
+	<format>X509</format>
+	<label>Rootca-SHA512</label>
+	<issuerkey></issuerkey>
+	<subjectkey></subjectkey>
+	<certstore>0</certstore>
+	<certfile>c:\tcertstore\serv-rootca-sha512.der</certfile>
+	<certowner>ca</certowner>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-006]
+<actionbody>
+	<label>Rootca-SHA224</label>
+	<trust>1</trust>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-007]
+<actionbody>
+	<label>Rootca-SHA256</label>
+	<trust>1</trust>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-008]
+<actionbody>
+	<label>Rootca-SHA384</label>
+	<trust>1</trust>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-009]
+<actionbody>
+	<label>Rootca-SHA512</label>
+	<trust>1</trust>
+</actionbody>
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-010]
+<actionbody>
+</actionbody>
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-011]
+<actionbody>
+	<name>Server Authentication</name>
+	<uid>268441661</uid>
+</actionbody>
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-012]
+<actionbody>
+	<label>Rootca-SHA224</label>
+	<uid>268441661</uid>
+</actionbody>
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-013]
+<actionbody>
+	<label>Rootca-SHA256</label>
+	<uid>268441661</uid>
+</actionbody>
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-014]
+<actionbody>
+	<label>Rootca-SHA384</label>
+	<uid>268441661</uid>
+</actionbody>
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-015]
+<actionbody>
+	<label>Rootca-SHA512</label>
+	<uid>268441661</uid>
+</actionbody>
+
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-016]
+<actionbody>
+</actionbody>
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-017]
+<actionbody>
+	<certtype>ca</certtype>
+	<label>Rootca-SHA224</label>
+</actionbody>
+	
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-018]
+<actionbody>
+	<certtype>ca</certtype>
+	<label>Rootca-SHA256</label>
+</actionbody>
+	
+
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-019]
+<actionbody>
+	<certtype>ca</certtype>
+	<label>Rootca-SHA384</label>
+</actionbody>
+	
+
+[SEC-CERTMAN-TCERTSTORESHA2-0001-020]
+<actionbody>
+	<certtype>ca</certtype>
+	<label>Rootca-SHA512</label>
+</actionbody>
+	
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/tcertstore/scripts/t_certstore_sha2.script	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,106 @@
+//
+// Copyright (c) 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+START_TESTCASE                SEC-CERTMAN-TCERTSTORESHA2-0001
+
+//! @SYMTestCaseID            SEC-CERTMAN-TCERTSTORESHA2-0001
+
+//! @SYMTestCaseDesc          
+
+//! @SYMTestActions           1) Initializing a CUnifiedCertStore
+
+//!                           2) Add the certificate -SHA224
+
+//!                           3) Add the certificate -SHA256
+
+//!                           4) Add the certificate -SHA384
+
+//!                           5) Add the certificate -SHA512
+
+//!                           6) Set the trust for Rootca-SHA224
+
+//!                           7) Set the trust for Rootca-SHA256
+
+//!                           8) Set the trust for Rootca-SHA384
+
+//!                           9) Set the trust for Rootca-SHA512
+
+//!                           10) Creating a CertificateAppInfoManager
+
+//!                           11) Adding client TLS
+
+//!                           12) Set trusters to the Rootca-SHA224 certificate
+
+//!                           13) Set trusters to the Rootca-SHA256 certificate
+
+//!                           14) Set trusters to the Rootca-SHA384 certificate
+
+//!                           15) Set trusters to the Rootca-SHA512 certificate
+
+//!                           16) Deleting the CertificateAppInfoManager
+
+//!                           17) Deleting the certificates
+
+//!                           18) Deleting the certificates
+
+//!                           19) Deleting the certificates
+
+//!                           20) Deleting the certificates
+
+RUN_TEST_STEP                 -1    CTestHandler        init        		    t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-001
+
+RUN_TEST_STEP                 -1    CTestHandler        addcert                   t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-002
+
+RUN_TEST_STEP                 -1    CTestHandler        addcert   		    t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-003
+
+RUN_TEST_STEP                 -1    CTestHandler        addcert                   t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-004
+
+RUN_TEST_STEP                 -1    CTestHandler        addcert   		    t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-005
+
+RUN_TEST_STEP                 -1    CTestHandler        settrust  		    t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-006
+
+RUN_TEST_STEP                 -1    CTestHandler        settrust                  t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-007
+
+RUN_TEST_STEP                 -1    CTestHandler        settrust                  t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-008
+ 
+RUN_TEST_STEP                 -1    CTestHandler        settrust                  t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-009
+
+RUN_TEST_STEP                 -1    CTestHandler        initappmanager            t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-010
+
+RUN_TEST_STEP                 -1    CTestHandler        addclient                 t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-011
+
+RUN_TEST_STEP                 -1    CTestHandler        setapplications           t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-012
+
+RUN_TEST_STEP                 -1    CTestHandler        setapplications           t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-013
+
+RUN_TEST_STEP                 -1    CTestHandler        setapplications           t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-014
+
+RUN_TEST_STEP                 -1    CTestHandler        setapplications           t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-015
+
+RUN_TEST_STEP                 -1    CTestHandler        deleteappmanager          t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-016
+
+RUN_TEST_STEP                 -1    CTestHandler        deletecert                t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-017
+
+RUN_TEST_STEP                 -1    CTestHandler        deletecert                t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-018
+
+RUN_TEST_STEP                 -1    CTestHandler        deletecert                t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-019
+
+RUN_TEST_STEP                 -1    CTestHandler        deletecert                t_certstore_sha2.ini  SEC-CERTMAN-TCERTSTORESHA2-0001-020
+
+
+END_TESTCASE                  SEC-CERTMAN-TCERTSTORESHA2-0001
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoservices/certificateandkeymgmt/tcertstore/scripts/t_certstore_sha2.txt	Fri Nov 06 13:21:00 2009 +0200
@@ -0,0 +1,255 @@
+<action>
+	<actionname>Initializing a CUnifiedCertStore</actionname>
+	<actiontype>init</actiontype>
+	<actionbody>
+		<mode>write</mode>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+
+<action>
+	<actionname>Add the certificate -SHA224</actionname>
+	<actiontype>addcert</actiontype>
+	<actionbody>
+		<format>X509</format>
+		<label>Rootca-SHA224</label>
+		<issuerkey></issuerkey>
+		<subjectkey></subjectkey>
+		<certstore>0</certstore>
+		<certfile>c:\tcertstore\serv-rootca-sha224.der</certfile>
+		<certowner>ca</certowner>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Add the certificate -SHA256</actionname>
+	<actiontype>addcert</actiontype>
+	<actionbody>
+		<format>X509</format>
+		<label>Rootca-SHA256</label>
+		<issuerkey></issuerkey>
+		<subjectkey></subjectkey>
+		<certstore>0</certstore>
+		<certfile>c:\tcertstore\serv-rootca-sha256.der</certfile>
+		<certowner>ca</certowner>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Add the certificate -SHA384</actionname>
+	<actiontype>addcert</actiontype>
+	<actionbody>
+		<format>X509</format>
+		<label>Rootca-SHA384</label>
+		<issuerkey></issuerkey>
+		<subjectkey></subjectkey>
+		<certstore>0</certstore>
+		<certfile>c:\tcertstore\serv-rootca-sha384.der</certfile>
+		<certowner>ca</certowner>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Add the certificate -SHA512</actionname>
+	<actiontype>addcert</actiontype>
+	<actionbody>
+		<format>X509</format>
+		<label>Rootca-SHA512</label>
+		<issuerkey></issuerkey>
+		<subjectkey></subjectkey>
+		<certstore>0</certstore>
+		<certfile>c:\tcertstore\serv-rootca-sha512.der</certfile>
+		<certowner>ca</certowner>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+
+<action>
+	<actionname>Set the trust for Rootca-SHA224</actionname>
+	<actiontype>settrust</actiontype>
+	<actionbody>
+		<label>Rootca-SHA224</label>
+		<trust>1</trust>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set the trust for Rootca-SHA256</actionname>
+	<actiontype>settrust</actiontype>
+	<actionbody>
+		<label>Rootca-SHA256</label>
+		<trust>1</trust>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set the trust for Rootca-SHA384</actionname>
+	<actiontype>settrust</actiontype>
+	<actionbody>
+		<label>Rootca-SHA384</label>
+		<trust>1</trust>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set the trust for Rootca-SHA512</actionname>
+	<actiontype>settrust</actiontype>
+	<actionbody>
+		<label>Rootca-SHA512</label>
+		<trust>1</trust>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Creating a CertificateAppInfoManager</actionname>
+	<actiontype>initappmanager</actiontype>
+	<actionbody></actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+
+<action>
+	<actionname>Adding client TLS</actionname>
+	<actiontype>addclient</actiontype>
+	<actionbody>
+		<name>Server Authentication</name>
+		<uid>268441661</uid>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set trusters to the Rootca-SHA224 certificate</actionname>
+	<actiontype>setapplications</actiontype>
+	<actionbody>
+		<label>Rootca-SHA224</label>
+		<uid>268441661</uid>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set trusters to the Rootca-SHA256 certificate</actionname>
+	<actiontype>setapplications</actiontype>
+	<actionbody>
+		<label>Rootca-SHA256</label>
+		<uid>268441661</uid>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set trusters to the Rootca-SHA384 certificate</actionname>
+	<actiontype>setapplications</actiontype>
+	<actionbody>
+		<label>Rootca-SHA384</label>
+		<uid>268441661</uid>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Set trusters to the Rootca-SHA512 certificate</actionname>
+	<actiontype>setapplications</actiontype>
+	<actionbody>
+		<label>Rootca-SHA512</label>
+		<uid>268441661</uid>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Deleting the CertificateAppInfoManager</actionname>
+	<actiontype>deleteappmanager</actiontype>
+	<actionbody></actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Deleting the certificates</actionname>
+	<actiontype>deletecert</actiontype>
+	<actionbody>
+		<certtype>ca</certtype>
+		<label>Rootca-SHA224</label>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Deleting the certificates</actionname>
+	<actiontype>deletecert</actiontype>
+	<actionbody>
+		<certtype>ca</certtype>
+		<label>Rootca-SHA256</label>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Deleting the certificates</actionname>
+	<actiontype>deletecert</actiontype>
+	<actionbody>
+		<certtype>ca</certtype>
+		<label>Rootca-SHA384</label>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
+
+<action>
+	<actionname>Deleting the certificates</actionname>
+	<actiontype>deletecert</actiontype>
+	<actionbody>
+		<certtype>ca</certtype>
+		<label>Rootca-SHA512</label>
+	</actionbody>
+	<actionresult>
+		<return>KErrNone</return>
+	</actionresult>
+</action>
--- a/cryptoservices/certificateandkeymgmt/x509/x509cert.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/certificateandkeymgmt/x509/x509cert.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -304,6 +304,48 @@
 			CleanupStack::PopAndDestroy(2);//seq, oid
 			return;
 			}
+
+        if (oidDes == KSHA224)
+            {
+            iAlgorithmId = ESHA224;
+            TASN1DecNull null;
+            null.DecodeDERL(*gen);//just to check the syntax is OK
+            iEncodedParams = HBufC8::NewL(1);
+            *iEncodedParams = KNullDesC8;
+            CleanupStack::PopAndDestroy(2);//seq, oid
+            return;
+            }
+        if (oidDes == KSHA256)
+            {
+            iAlgorithmId = ESHA256;
+            TASN1DecNull null;
+            null.DecodeDERL(*gen);//just to check the syntax is OK
+            iEncodedParams = HBufC8::NewL(1);
+            *iEncodedParams = KNullDesC8;
+            CleanupStack::PopAndDestroy(2);//seq, oid
+            return;
+            }      
+        if (oidDes == KSHA384)
+            {
+            iAlgorithmId = ESHA384;
+            TASN1DecNull null;
+            null.DecodeDERL(*gen);//just to check the syntax is OK
+            iEncodedParams = HBufC8::NewL(1);
+            *iEncodedParams = KNullDesC8;
+            CleanupStack::PopAndDestroy(2);//seq, oid
+            return;
+            }        
+        if (oidDes == KSHA512)
+            {
+            iAlgorithmId = ESHA512;
+            TASN1DecNull null;
+            null.DecodeDERL(*gen);//just to check the syntax is OK
+            iEncodedParams = HBufC8::NewL(1);
+            *iEncodedParams = KNullDesC8;
+            CleanupStack::PopAndDestroy(2);//seq, oid
+            return;
+            }         
+	
 		}
 	User::Leave(KErrNotSupported);
 	}
@@ -340,6 +382,22 @@
 	case ESHA1:
 		oid=CASN1EncObjectIdentifier::NewLC(KSHA1);
 		break;
+
+	case ESHA224:
+		oid=CASN1EncObjectIdentifier::NewLC(KSHA224);
+		break;
+
+	case ESHA256:
+		oid=CASN1EncObjectIdentifier::NewLC(KSHA256);
+		break;
+
+	case ESHA384:
+		oid=CASN1EncObjectIdentifier::NewLC(KSHA384);
+		break;
+
+	case ESHA512:
+		oid=CASN1EncObjectIdentifier::NewLC(KSHA512);
+		break;
 		
 	default:
 		User::Leave(KErrNotSupported);
@@ -463,6 +521,39 @@
 		iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());
 		iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());
 		}
+
+	if (oidDes == KSHA224WithRSA)
+         {
+         TAlgorithmId algId = ERSA;
+         TAlgorithmId digestId = ESHA224;
+         iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());
+         iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());
+         }
+	
+	if (oidDes == KSHA256WithRSA)
+         {
+         TAlgorithmId algId = ERSA;
+         TAlgorithmId digestId = ESHA256;
+         iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());
+         iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());
+         }
+
+	if (oidDes == KSHA384WithRSA)
+         {
+         TAlgorithmId algId = ERSA;
+         TAlgorithmId digestId = ESHA384;
+         iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());
+         iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());
+         }
+
+	if (oidDes == KSHA512WithRSA)
+         {
+         TAlgorithmId algId = ERSA;
+         TAlgorithmId digestId = ESHA512;
+         iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());
+         iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());
+         }
+
 		//???not sure if we should just leave here...
 	if (iDigestAlgorithm == NULL)
 		{	
--- a/cryptoservices/filebasedcertificateandkeystores/test/tcryptotokenhai/tcryptotokenhai.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/filebasedcertificateandkeystores/test/tcryptotokenhai/tcryptotokenhai.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -595,13 +595,10 @@
 				return EFalse;
 				}
 			break;
-			
 		case TCTKeyAttributeFilter::EManageableKeys:
-			if (!aInfo.ManagementPolicy().CheckPolicy(RThread()))
-				{
-				return EFalse;
-				}
-			break;
+			// As this key store implementation is a hardware simulation,
+			// the support for managing through software interface has been diabled.
+			return EFalse;
 
 		case TCTKeyAttributeFilter::EUsableOrManageableKeys:
 			if (!aInfo.UsePolicy().CheckPolicy(RThread()) &&
--- a/cryptoservices/filebasedcertificateandkeystores/test/thwkeystore/common/tkeydetails.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/filebasedcertificateandkeystores/test/thwkeystore/common/tkeydetails.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -80,7 +80,11 @@
 	// set the access type to never extractable
 	iAccessType |= CKeyInfoBase::ENeverExtractable;
 	iAccessType |= CKeyInfoBase::ELocal;
-			
+	// Policy set for keys in hardware depends on the vendor requirements 
+	// this reference implementation assumes that accessibility of keys
+	// does not need any restriction. Hence for the testing environment policy is set to always pass.
+	TSecurityPolicy  temp(TSecurityPolicy::EAlwaysPass);
+	iUsePolicy = temp;
 	}
 
 void CKeyDetails::ExternalizeL(RWriteStream& aWriteStream) const
@@ -98,7 +102,7 @@
     TPtr8 keyPtr = iPrivateKey->Des();
     keyPtr.SetLength(stringLen);
     aWriteStream.WriteL(keyPtr);
-        
+
     stringLen = iPublicKey->Length();
     aWriteStream.WriteInt32L(stringLen);
     keyPtr = iPublicKey->Des();
@@ -127,4 +131,9 @@
     TPtr8 publicKeyPtr((TUint8*)iPublicKey->Ptr(), stringLen, stringLen);
     publicKeyPtr.FillZ(stringLen);
     aReadStream.ReadL(publicKeyPtr);
+    // Policy set for keys in hardware depends on the vendor requirements 
+    // this reference implementation assumes that accessibility of keys
+    // does not need any restriction. Hence for the testing environment policy is set to always pass.
+    TSecurityPolicy  temp(TSecurityPolicy::EAlwaysPass);
+    iUsePolicy = temp;
     }
--- a/cryptoservices/filebasedcertificateandkeystores/test/tkeystore/t_open.cpp	Mon Oct 12 10:17:04 2009 +0300
+++ b/cryptoservices/filebasedcertificateandkeystores/test/tkeystore/t_open.cpp	Fri Nov 06 13:21:00 2009 +0200
@@ -308,11 +308,10 @@
 
 void COpenKey::ConstructL(const TTestActionSpec& aTestActionSpec)
 	{
-	TInt pos = 0, err = 0;
 	CKeyStoreTestAction::ConstructL(aTestActionSpec);
 	
 #if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))
-	pos = 0;
+	TInt pos = 0, err = 0;
 	TPtrC8 operationType = Input::ParseElement(aTestActionSpec.iActionBody, KOperationTypeStart, KOperationTypeEnd, pos, err);
 	if(operationType.Compare(_L8("sign")) == 0)
 		{