MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/security/crypto/weakcryptospi/test/tplugins/src/md2impl.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 /*

     2 * Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 * software md2 implementation

    16 * software md2 implementation

    17 *

    18 */

    19 

    20 

    21 /**

    22  @file

    23 */

    24 

    25 #include "md2impl.h"

    26 

    27 #include <cryptospi/hashplugin.h>

    28 #include "pluginconfig.h"

    29 

    30 using namespace SoftwareCrypto;

    31 	

    32 CMD2Impl* CMD2Impl::NewL(TUid aImplementationUid)

    33 	{

    34 	CMD2Impl* self=new (ELeave) CMD2Impl(aImplementationUid);

    35 	return self;						

    36 	}

    37 														

    38 CMD2Impl* CMD2Impl::NewLC(TUid aImplementationUid)

    39 	{

    40 	CMD2Impl* self=NewL(aImplementationUid);

    41 	CleanupStack::PushL(self);

    42 	return self;						

    43 	}

    44 														

    45 CMD2Impl::CMD2Impl(TUid aImplementationUid) : iImplementationUid(aImplementationUid), iHash(KMD2HashSize)

    46 	{		

    47 	}

    48 	

    49 CMD2Impl::CMD2Impl(const CMD2Impl& aCMD2Impl)

    50 : iHash(aCMD2Impl.iHash),iNum(aCMD2Impl.iNum)

    51 	{

    52 	(void)Mem::Copy(iData, aCMD2Impl.iData, sizeof(iData));

    53 	(void)Mem::Copy(iChecksum, aCMD2Impl.iChecksum, sizeof(iChecksum));

    54 	(void)Mem::Copy(iState, aCMD2Impl.iState, sizeof(iState));		

    55 	}

    56 		

    57 CMD2Impl::~CMD2Impl()

    58 	{	

    59 	}

    60 	

    61 void CMD2Impl::Reset()

    62 	{

    63 	Mem::FillZ(iData,sizeof(iData));

    64 	Mem::FillZ(iChecksum,sizeof(iChecksum));

    65 	Mem::FillZ(iState,sizeof(iState));

    66 	iNum=0;		

    67 	}

    68 	

    69 void CMD2Impl::Close()

    70 	{

    71 	delete this;	

    72 	}

    73 	

    74 void CMD2Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)

    75 	{

    76 	aPluginCharacteristics=NULL;

    77 	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);

    78 	for (TInt i=0;i<hashNum;i++)

    79 		{

    80 		if (KHashCharacteristics[i]->cmn.iImplementationUID==ImplementationUid().iUid)

    81 			{

    82 			aPluginCharacteristics = KHashCharacteristics[i];

    83 			break;

    84 			}

    85 		}	

    86 	}

    87 	

    88 CExtendedCharacteristics* CMD2Impl::CreateExtendedCharacteristicsL()

    89 	{

    90 	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved

    91 	// for exclusive use and are not CERTIFIED to be standards compliant.

    92 	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);

    93 	}

    94 

    95 const CExtendedCharacteristics* CMD2Impl::GetExtendedCharacteristicsL()

    96 	{

    97 	return CMD2Impl::CreateExtendedCharacteristicsL();

    98 	}

    99 	

   100 TAny* CMD2Impl::GetExtension(TUid /*aExtensionId*/)

   101 	{

   102 	return NULL;	

   103 	}

   104 

   105 TPtrC8 CMD2Impl::Hash(const TDesC8& aMessage)

   106 	{

   107 	TPtrC8 ptr(KNullDesC8());

   108 	DoUpdate(aMessage.Ptr(),aMessage.Size());

   109 	StoreState();	

   110 	DoFinal();

   111 	ptr.Set(iHash);

   112 	RestoreState();	

   113 	return ptr;		

   114 	}		

   115 	

   116 void CMD2Impl::Update(const TDesC8& aMessage)

   117 	{

   118 	DoUpdate(aMessage.Ptr(),aMessage.Size());	

   119 	}

   120 	

   121 TPtrC8 CMD2Impl::Final(const TDesC8& aMessage)

   122 	{

   123 	TPtrC8 ptr(KNullDesC8());

   124 	if (aMessage!=KNullDesC8())

   125 		{

   126 		DoUpdate(aMessage.Ptr(),aMessage.Size());			

   127 		}

   128 	DoFinal();

   129 	ptr.Set(iHash);

   130 	Reset();

   131 	return ptr;

   132 	}

   133 	

   134 MHash* CMD2Impl::ReplicateL()

   135 	{

   136 	return NewL(iImplementationUid);	

   137 	}

   138 	

   139 MHash* CMD2Impl::CopyL()

   140 	{

   141 	return new(ELeave) CMD2Impl(*this);	

   142 	}

   143 

   144 void CMD2Impl::RestoreState()

   145 	{

   146 	Mem::Copy(&iData[0], &iDataTemp[0], KMD2BlockSize);

   147 	Mem::Copy(&iChecksum[0], &iChecksumTemp[0], KMD2BlockSize*sizeof(TUint));

   148 	Mem::Copy(&iState[0], &iStateTemp[0], KMD2BlockSize*sizeof(TUint));		

   149 	}

   150 	

   151 void CMD2Impl::StoreState()

   152 	{

   153 	Mem::Copy(&iDataTemp[0], &iData[0], KMD2BlockSize);

   154 	Mem::Copy(&iChecksumTemp[0], &iChecksum[0], KMD2BlockSize*sizeof(TUint));

   155 	Mem::Copy(&iStateTemp[0], &iState[0], KMD2BlockSize*sizeof(TUint));		

   156 	}

   157 

   158 

   159 TUid CMD2Impl::ImplementationUid()

   160 	{

   161 	return iImplementationUid;

   162 	}

   163 

   164 static inline TUint CMD2_S(TUint& elt,TUint8 val)

   165 	{

   166 	return elt^=val;

   167 	}

   168 

   169 void CMD2Impl::DoUpdate(const TUint8* aData,TUint aLength)

   170 	{

   171 	TBool carryOn=ETrue;

   172 	if (iNum)

   173 		{

   174 		if (iNum+aLength>=(TUint)KMD2BlockSize)

   175 			{

   176 			const TUint temp=KMD2BlockSize-iNum;

   177 			(void)Mem::Copy(iData+iNum,aData,temp);

   178 			Block(iData);

   179 			aData+=temp;

   180 			aLength-=temp;

   181 			iNum=0;

   182 			}

   183 		else

   184 			{

   185 			(void)Mem::Copy(iData+iNum,aData,aLength);

   186 			iNum+=aLength;

   187 			carryOn=EFalse;

   188 			}

   189 		}

   190 	// processing by block of KMD2BlockSize

   191 	if (carryOn)

   192 		{

   193 		while (aLength>=(TUint)KMD2BlockSize)

   194 			{

   195 			Block(aData);

   196 			aData+=KMD2BlockSize;

   197 			aLength-=KMD2BlockSize;

   198 			}

   199 		(void)Mem::Copy(iData,aData,aLength);

   200 		iNum=aLength;

   201 		}		

   202 	}

   203 	

   204 void CMD2Impl::DoFinal()

   205 	{

   206 	const TUint pad=KMD2BlockSize-iNum;

   207 	if (pad>0)

   208 		Mem::Fill(iData+iNum,(TUint8)pad,pad);

   209 	Block(iData);

   210 

   211 	TUint8* pData=iData;

   212 	const TUint8* pEnd=iData+KMD2BlockSize;

   213 	const TUint* pChecksum=iChecksum;

   214 	while (pData<pEnd)

   215 		{

   216 		*pData=(TUint8)*pChecksum;//checksum is always less than 255 

   217 		pData++;

   218 		pChecksum++;

   219 		}

   220 	Block(iData);

   221 

   222 	TUint* pState=iState;

   223 	for (TUint i=0;i<(TUint)KMD2BlockSize;i++,pState++) //safe: iState and iHash have got same size

   224 		iHash[i]=(TUint8)(*pState&0xff);		

   225 	}

   226 	

   227 void CMD2Impl::Block(const TUint8* aData)

   228 	{

   229 	TUint8 S[256]={

   230 		0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01,

   231 		0x3D, 0x36, 0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13,

   232 		0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C,

   233 		0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA,

   234 		0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16,

   235 		0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12,

   236 		0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49,

   237 		0xA0, 0xFB, 0xF5, 0x8E, 0xBB, 0x2F, 0xEE, 0x7A,

   238 		0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F,

   239 		0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21,

   240 		0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27,

   241 		0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03,

   242 		0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1,

   243 		0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56, 0xAA, 0xC6,

   244 		0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,

   245 		0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1,

   246 		0x45, 0x9D, 0x70, 0x59, 0x64, 0x71, 0x87, 0x20,

   247 		0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02,

   248 		0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6,

   249 		0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F,

   250 		0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A,

   251 		0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26,

   252 		0x2C, 0x53, 0x0D, 0x6E, 0x85, 0x28, 0x84, 0x09,

   253 		0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52,

   254 		0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA,

   255 		0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A,

   256 		0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D,

   257 		0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39,

   258 		0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58, 0xD0, 0xE4,

   259 		0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,

   260 		0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A,

   261 		0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14,

   262 		};

   263 	TUint state[KMD2BlockSize*3];

   264 	TUint j=iChecksum[KMD2BlockSize-1];

   265 	TUint i=0,temp=0;

   266 	while (i<(TUint)KMD2BlockSize)

   267 		{

   268 		const TUint tempState=iState[i];

   269 		temp=aData[i];

   270 		state[i]=tempState;

   271 		state[i+16]=temp;

   272 		state[i+32]=temp^tempState;

   273 		j=CMD2_S(iChecksum[i++],S[temp^j]);

   274 		}

   275 	temp=0;

   276 	TUint* pstate=state;

   277 	const TUint *pend=state+(KMD2BlockSize*3);

   278 	for (i=0; i<18; i++)

   279 		{

   280 		while (pstate<pend)

   281 			{

   282 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   283 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   284 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   285 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   286 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   287 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   288 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   289 			temp=CMD2_S(*pstate,S[temp]);pstate++;

   290 			}

   291 		pstate=state;

   292 		temp=(temp+i)&0xff;

   293 		}

   294 	(void)Mem::Copy(iState,state,KMD2BlockSize*sizeof(TUint));		

   295 	}

   296 

   297 

   298 void CMD2Impl::SetOperationModeL(TUid /*aOperationMode*/)

   299 	{

   300 	User::Leave(KErrNotSupported);

   301 	}

   302 

   303 void CMD2Impl::SetKeyL(const CKey& /*aKey*/)

   304 	{

   305 	User::Leave(KErrNotSupported);

   306 	}

   307
Symaptic