os/security/cryptoplugins/cryptospiplugins/source/softwarecrypto/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.
sl@0
     1
/*
sl@0
     2
* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0
     3
* All rights reserved.
sl@0
     4
* This component and the accompanying materials are made available
sl@0
     5
* under the terms of the License "Eclipse Public License v1.0"
sl@0
     6
* which accompanies this distribution, and is available
sl@0
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0
     8
*
sl@0
     9
* Initial Contributors:
sl@0
    10
* Nokia Corporation - initial contribution.
sl@0
    11
*
sl@0
    12
* Contributors:
sl@0
    13
*
sl@0
    14
* Description: 
sl@0
    15
* software md2 implementation
sl@0
    16
* software md2 implementation
sl@0
    17
*
sl@0
    18
*/
sl@0
    19
sl@0
    20
sl@0
    21
/**
sl@0
    22
 @file
sl@0
    23
*/
sl@0
    24
sl@0
    25
#include "md2impl.h"
sl@0
    26
sl@0
    27
#include <cryptospi/hashplugin.h>
sl@0
    28
#include "pluginconfig.h"
sl@0
    29
sl@0
    30
using namespace SoftwareCrypto;
sl@0
    31
	
sl@0
    32
CMD2Impl* CMD2Impl::NewL()
sl@0
    33
	{
sl@0
    34
	CMD2Impl* self=new (ELeave) CMD2Impl();
sl@0
    35
	return self;						
sl@0
    36
	}
sl@0
    37
														
sl@0
    38
CMD2Impl* CMD2Impl::NewLC()
sl@0
    39
	{
sl@0
    40
	CMD2Impl* self=NewL();
sl@0
    41
	CleanupStack::PushL(self);
sl@0
    42
	return self;						
sl@0
    43
	}
sl@0
    44
														
sl@0
    45
CMD2Impl::CMD2Impl() : iHash(KMD2HashSize)
sl@0
    46
	{		
sl@0
    47
	}
sl@0
    48
	
sl@0
    49
CMD2Impl::CMD2Impl(const CMD2Impl& aCMD2Impl)
sl@0
    50
: iHash(aCMD2Impl.iHash),iNum(aCMD2Impl.iNum)
sl@0
    51
	{
sl@0
    52
	(void)Mem::Copy(iData, aCMD2Impl.iData, sizeof(iData));
sl@0
    53
	(void)Mem::Copy(iChecksum, aCMD2Impl.iChecksum, sizeof(iChecksum));
sl@0
    54
	(void)Mem::Copy(iState, aCMD2Impl.iState, sizeof(iState));		
sl@0
    55
	}
sl@0
    56
		
sl@0
    57
CMD2Impl::~CMD2Impl()
sl@0
    58
	{	
sl@0
    59
	}
sl@0
    60
	
sl@0
    61
void CMD2Impl::Reset()
sl@0
    62
	{
sl@0
    63
	Mem::FillZ(iData,sizeof(iData));
sl@0
    64
	Mem::FillZ(iChecksum,sizeof(iChecksum));
sl@0
    65
	Mem::FillZ(iState,sizeof(iState));
sl@0
    66
	iNum=0;		
sl@0
    67
	}
sl@0
    68
	
sl@0
    69
void CMD2Impl::Close()
sl@0
    70
	{
sl@0
    71
	delete this;	
sl@0
    72
	}
sl@0
    73
	
sl@0
    74
void CMD2Impl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
sl@0
    75
	{
sl@0
    76
	aPluginCharacteristics=NULL;
sl@0
    77
	TInt hashNum=sizeof(KHashCharacteristics)/sizeof(THashCharacteristics*);
sl@0
    78
	for (TInt i=0;i<hashNum;i++)
sl@0
    79
		{
sl@0
    80
		if (KHashCharacteristics[i]->cmn.iImplementationUID==ImplementationUid().iUid)
sl@0
    81
			{
sl@0
    82
			aPluginCharacteristics = KHashCharacteristics[i];
sl@0
    83
			break;
sl@0
    84
			}
sl@0
    85
		}	
sl@0
    86
	}
sl@0
    87
	
sl@0
    88
CExtendedCharacteristics* CMD2Impl::CreateExtendedCharacteristicsL()
sl@0
    89
	{
sl@0
    90
	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved
sl@0
    91
	// for exclusive use and are not CERTIFIED to be standards compliant.
sl@0
    92
	return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);
sl@0
    93
	}
sl@0
    94
sl@0
    95
const CExtendedCharacteristics* CMD2Impl::GetExtendedCharacteristicsL()
sl@0
    96
	{
sl@0
    97
	return CMD2Impl::CreateExtendedCharacteristicsL();
sl@0
    98
	}
sl@0
    99
sl@0
   100
TPtrC8 CMD2Impl::Hash(const TDesC8& aMessage)
sl@0
   101
	{
sl@0
   102
	TPtrC8 ptr(KNullDesC8());
sl@0
   103
	DoUpdate(aMessage.Ptr(),aMessage.Size());
sl@0
   104
	StoreState();	
sl@0
   105
	DoFinal();
sl@0
   106
	ptr.Set(iHash);
sl@0
   107
	RestoreState();	
sl@0
   108
	return ptr;		
sl@0
   109
	}		
sl@0
   110
	
sl@0
   111
void CMD2Impl::Update(const TDesC8& aMessage)
sl@0
   112
	{
sl@0
   113
	DoUpdate(aMessage.Ptr(),aMessage.Size());	
sl@0
   114
	}
sl@0
   115
	
sl@0
   116
TPtrC8 CMD2Impl::Final(const TDesC8& aMessage)
sl@0
   117
	{
sl@0
   118
	TPtrC8 ptr(KNullDesC8());
sl@0
   119
	if (aMessage!=KNullDesC8())
sl@0
   120
		{
sl@0
   121
		DoUpdate(aMessage.Ptr(),aMessage.Size());			
sl@0
   122
		}
sl@0
   123
	DoFinal();
sl@0
   124
	ptr.Set(iHash);
sl@0
   125
	Reset();
sl@0
   126
	return ptr;
sl@0
   127
	}
sl@0
   128
	
sl@0
   129
MHash* CMD2Impl::ReplicateL()
sl@0
   130
	{
sl@0
   131
	return NewL();	
sl@0
   132
	}
sl@0
   133
	
sl@0
   134
MHash* CMD2Impl::CopyL()
sl@0
   135
	{
sl@0
   136
	return new(ELeave) CMD2Impl(*this);	
sl@0
   137
	}
sl@0
   138
sl@0
   139
void CMD2Impl::RestoreState()
sl@0
   140
	{
sl@0
   141
	Mem::Copy(&iData[0], &iDataTemp[0], KMD2BlockSize);
sl@0
   142
	Mem::Copy(&iChecksum[0], &iChecksumTemp[0], KMD2BlockSize*sizeof(TUint));
sl@0
   143
	Mem::Copy(&iState[0], &iStateTemp[0], KMD2BlockSize*sizeof(TUint));		
sl@0
   144
	}
sl@0
   145
	
sl@0
   146
void CMD2Impl::StoreState()
sl@0
   147
	{
sl@0
   148
	Mem::Copy(&iDataTemp[0], &iData[0], KMD2BlockSize);
sl@0
   149
	Mem::Copy(&iChecksumTemp[0], &iChecksum[0], KMD2BlockSize*sizeof(TUint));
sl@0
   150
	Mem::Copy(&iStateTemp[0], &iState[0], KMD2BlockSize*sizeof(TUint));		
sl@0
   151
	}
sl@0
   152
sl@0
   153
sl@0
   154
TUid CMD2Impl::ImplementationUid()
sl@0
   155
	{
sl@0
   156
	return KCryptoPluginMd2Uid;
sl@0
   157
	}
sl@0
   158
sl@0
   159
static inline TUint CMD2_S(TUint& elt,TUint8 val)
sl@0
   160
	{
sl@0
   161
	return elt^=val;
sl@0
   162
	}
sl@0
   163
sl@0
   164
void CMD2Impl::DoUpdate(const TUint8* aData,TUint aLength)
sl@0
   165
	{
sl@0
   166
	TBool carryOn=ETrue;
sl@0
   167
	if (iNum)
sl@0
   168
		{
sl@0
   169
		if (iNum+aLength>=(TUint)KMD2BlockSize)
sl@0
   170
			{
sl@0
   171
			const TUint temp=KMD2BlockSize-iNum;
sl@0
   172
			(void)Mem::Copy(iData+iNum,aData,temp);
sl@0
   173
			Block(iData);
sl@0
   174
			aData+=temp;
sl@0
   175
			aLength-=temp;
sl@0
   176
			iNum=0;
sl@0
   177
			}
sl@0
   178
		else
sl@0
   179
			{
sl@0
   180
			(void)Mem::Copy(iData+iNum,aData,aLength);
sl@0
   181
			iNum+=aLength;
sl@0
   182
			carryOn=EFalse;
sl@0
   183
			}
sl@0
   184
		}
sl@0
   185
	// processing by block of KMD2BlockSize
sl@0
   186
	if (carryOn)
sl@0
   187
		{
sl@0
   188
		while (aLength>=(TUint)KMD2BlockSize)
sl@0
   189
			{
sl@0
   190
			Block(aData);
sl@0
   191
			aData+=KMD2BlockSize;
sl@0
   192
			aLength-=KMD2BlockSize;
sl@0
   193
			}
sl@0
   194
		(void)Mem::Copy(iData,aData,aLength);
sl@0
   195
		iNum=aLength;
sl@0
   196
		}		
sl@0
   197
	}
sl@0
   198
	
sl@0
   199
void CMD2Impl::DoFinal()
sl@0
   200
	{
sl@0
   201
	const TUint pad=KMD2BlockSize-iNum;
sl@0
   202
	if (pad>0)
sl@0
   203
		Mem::Fill(iData+iNum,(TUint8)pad,pad);
sl@0
   204
	Block(iData);
sl@0
   205
sl@0
   206
	TUint8* pData=iData;
sl@0
   207
	const TUint8* pEnd=iData+KMD2BlockSize;
sl@0
   208
	const TUint* pChecksum=iChecksum;
sl@0
   209
	while (pData<pEnd)
sl@0
   210
		{
sl@0
   211
		*pData=(TUint8)*pChecksum;//checksum is always less than 255 
sl@0
   212
		pData++;
sl@0
   213
		pChecksum++;
sl@0
   214
		}
sl@0
   215
	Block(iData);
sl@0
   216
sl@0
   217
	TUint* pState=iState;
sl@0
   218
	for (TUint i=0;i<(TUint)KMD2BlockSize;i++,pState++) //safe: iState and iHash have got same size
sl@0
   219
		iHash[i]=(TUint8)(*pState&0xff);		
sl@0
   220
	}
sl@0
   221
	
sl@0
   222
void CMD2Impl::Block(const TUint8* aData)
sl@0
   223
	{
sl@0
   224
	static const TUint8 S[256]={
sl@0
   225
		0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01,
sl@0
   226
		0x3D, 0x36, 0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13,
sl@0
   227
		0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C,
sl@0
   228
		0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA,
sl@0
   229
		0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16,
sl@0
   230
		0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12,
sl@0
   231
		0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49,
sl@0
   232
		0xA0, 0xFB, 0xF5, 0x8E, 0xBB, 0x2F, 0xEE, 0x7A,
sl@0
   233
		0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F,
sl@0
   234
		0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21,
sl@0
   235
		0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27,
sl@0
   236
		0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03,
sl@0
   237
		0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1,
sl@0
   238
		0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56, 0xAA, 0xC6,
sl@0
   239
		0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,
sl@0
   240
		0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1,
sl@0
   241
		0x45, 0x9D, 0x70, 0x59, 0x64, 0x71, 0x87, 0x20,
sl@0
   242
		0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02,
sl@0
   243
		0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6,
sl@0
   244
		0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F,
sl@0
   245
		0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A,
sl@0
   246
		0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26,
sl@0
   247
		0x2C, 0x53, 0x0D, 0x6E, 0x85, 0x28, 0x84, 0x09,
sl@0
   248
		0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52,
sl@0
   249
		0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA,
sl@0
   250
		0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A,
sl@0
   251
		0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D,
sl@0
   252
		0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39,
sl@0
   253
		0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58, 0xD0, 0xE4,
sl@0
   254
		0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,
sl@0
   255
		0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A,
sl@0
   256
		0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14,
sl@0
   257
		};
sl@0
   258
	TUint state[KMD2BlockSize*3];
sl@0
   259
	TUint j=iChecksum[KMD2BlockSize-1];
sl@0
   260
	TUint i=0,temp=0;
sl@0
   261
	while (i<(TUint)KMD2BlockSize)
sl@0
   262
		{
sl@0
   263
		const TUint tempState=iState[i];
sl@0
   264
		temp=aData[i];
sl@0
   265
		state[i]=tempState;
sl@0
   266
		state[i+16]=temp;
sl@0
   267
		state[i+32]=temp^tempState;
sl@0
   268
		j=CMD2_S(iChecksum[i++],S[temp^j]);
sl@0
   269
		}
sl@0
   270
	temp=0;
sl@0
   271
	TUint* pstate=state;
sl@0
   272
	const TUint *pend=state+(KMD2BlockSize*3);
sl@0
   273
	for (i=0; i<18; i++)
sl@0
   274
		{
sl@0
   275
		while (pstate<pend)
sl@0
   276
			{
sl@0
   277
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   278
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   279
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   280
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   281
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   282
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   283
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   284
			temp=CMD2_S(*pstate,S[temp]);pstate++;
sl@0
   285
			}
sl@0
   286
		pstate=state;
sl@0
   287
		temp=(temp+i)&0xff;
sl@0
   288
		}
sl@0
   289
	(void)Mem::Copy(iState,state,KMD2BlockSize*sizeof(TUint));		
sl@0
   290
	}
sl@0
   291
sl@0
   292
sl@0
   293
// Implemented in hmacimpl.cpp or softwarehashbase.cpp
sl@0
   294
// but required as derived from MHash. No coverage here.
sl@0
   295
#ifdef _BullseyeCoverage
sl@0
   296
#pragma suppress_warnings on
sl@0
   297
#pragma BullseyeCoverage off
sl@0
   298
#pragma suppress_warnings off
sl@0
   299
#endif
sl@0
   300
sl@0
   301
TAny* CMD2Impl::GetExtension(TUid /*aExtensionId*/)
sl@0
   302
	{
sl@0
   303
	return NULL;	
sl@0
   304
	}
sl@0
   305
sl@0
   306
void CMD2Impl::SetOperationModeL(TUid /*aOperationMode*/)
sl@0
   307
	{
sl@0
   308
	User::Leave(KErrNotSupported);
sl@0
   309
	}
sl@0
   310
sl@0
   311
void CMD2Impl::SetKeyL(const CKey& /*aKey*/)
sl@0
   312
	{
sl@0
   313
	User::Leave(KErrNotSupported);
sl@0
   314
	}
sl@0
   315