|
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() |
|
33 { |
|
34 CMD2Impl* self=new (ELeave) CMD2Impl(); |
|
35 return self; |
|
36 } |
|
37 |
|
38 CMD2Impl* CMD2Impl::NewLC() |
|
39 { |
|
40 CMD2Impl* self=NewL(); |
|
41 CleanupStack::PushL(self); |
|
42 return self; |
|
43 } |
|
44 |
|
45 CMD2Impl::CMD2Impl() : 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 TPtrC8 CMD2Impl::Hash(const TDesC8& aMessage) |
|
101 { |
|
102 TPtrC8 ptr(KNullDesC8()); |
|
103 DoUpdate(aMessage.Ptr(),aMessage.Size()); |
|
104 StoreState(); |
|
105 DoFinal(); |
|
106 ptr.Set(iHash); |
|
107 RestoreState(); |
|
108 return ptr; |
|
109 } |
|
110 |
|
111 void CMD2Impl::Update(const TDesC8& aMessage) |
|
112 { |
|
113 DoUpdate(aMessage.Ptr(),aMessage.Size()); |
|
114 } |
|
115 |
|
116 TPtrC8 CMD2Impl::Final(const TDesC8& aMessage) |
|
117 { |
|
118 TPtrC8 ptr(KNullDesC8()); |
|
119 if (aMessage!=KNullDesC8()) |
|
120 { |
|
121 DoUpdate(aMessage.Ptr(),aMessage.Size()); |
|
122 } |
|
123 DoFinal(); |
|
124 ptr.Set(iHash); |
|
125 Reset(); |
|
126 return ptr; |
|
127 } |
|
128 |
|
129 MHash* CMD2Impl::ReplicateL() |
|
130 { |
|
131 return NewL(); |
|
132 } |
|
133 |
|
134 MHash* CMD2Impl::CopyL() |
|
135 { |
|
136 return new(ELeave) CMD2Impl(*this); |
|
137 } |
|
138 |
|
139 void CMD2Impl::RestoreState() |
|
140 { |
|
141 Mem::Copy(&iData[0], &iDataTemp[0], KMD2BlockSize); |
|
142 Mem::Copy(&iChecksum[0], &iChecksumTemp[0], KMD2BlockSize*sizeof(TUint)); |
|
143 Mem::Copy(&iState[0], &iStateTemp[0], KMD2BlockSize*sizeof(TUint)); |
|
144 } |
|
145 |
|
146 void CMD2Impl::StoreState() |
|
147 { |
|
148 Mem::Copy(&iDataTemp[0], &iData[0], KMD2BlockSize); |
|
149 Mem::Copy(&iChecksumTemp[0], &iChecksum[0], KMD2BlockSize*sizeof(TUint)); |
|
150 Mem::Copy(&iStateTemp[0], &iState[0], KMD2BlockSize*sizeof(TUint)); |
|
151 } |
|
152 |
|
153 |
|
154 TUid CMD2Impl::ImplementationUid() |
|
155 { |
|
156 return KCryptoPluginMd2Uid; |
|
157 } |
|
158 |
|
159 static inline TUint CMD2_S(TUint& elt,TUint8 val) |
|
160 { |
|
161 return elt^=val; |
|
162 } |
|
163 |
|
164 void CMD2Impl::DoUpdate(const TUint8* aData,TUint aLength) |
|
165 { |
|
166 TBool carryOn=ETrue; |
|
167 if (iNum) |
|
168 { |
|
169 if (iNum+aLength>=(TUint)KMD2BlockSize) |
|
170 { |
|
171 const TUint temp=KMD2BlockSize-iNum; |
|
172 (void)Mem::Copy(iData+iNum,aData,temp); |
|
173 Block(iData); |
|
174 aData+=temp; |
|
175 aLength-=temp; |
|
176 iNum=0; |
|
177 } |
|
178 else |
|
179 { |
|
180 (void)Mem::Copy(iData+iNum,aData,aLength); |
|
181 iNum+=aLength; |
|
182 carryOn=EFalse; |
|
183 } |
|
184 } |
|
185 // processing by block of KMD2BlockSize |
|
186 if (carryOn) |
|
187 { |
|
188 while (aLength>=(TUint)KMD2BlockSize) |
|
189 { |
|
190 Block(aData); |
|
191 aData+=KMD2BlockSize; |
|
192 aLength-=KMD2BlockSize; |
|
193 } |
|
194 (void)Mem::Copy(iData,aData,aLength); |
|
195 iNum=aLength; |
|
196 } |
|
197 } |
|
198 |
|
199 void CMD2Impl::DoFinal() |
|
200 { |
|
201 const TUint pad=KMD2BlockSize-iNum; |
|
202 if (pad>0) |
|
203 Mem::Fill(iData+iNum,(TUint8)pad,pad); |
|
204 Block(iData); |
|
205 |
|
206 TUint8* pData=iData; |
|
207 const TUint8* pEnd=iData+KMD2BlockSize; |
|
208 const TUint* pChecksum=iChecksum; |
|
209 while (pData<pEnd) |
|
210 { |
|
211 *pData=(TUint8)*pChecksum;//checksum is always less than 255 |
|
212 pData++; |
|
213 pChecksum++; |
|
214 } |
|
215 Block(iData); |
|
216 |
|
217 TUint* pState=iState; |
|
218 for (TUint i=0;i<(TUint)KMD2BlockSize;i++,pState++) //safe: iState and iHash have got same size |
|
219 iHash[i]=(TUint8)(*pState&0xff); |
|
220 } |
|
221 |
|
222 void CMD2Impl::Block(const TUint8* aData) |
|
223 { |
|
224 static const TUint8 S[256]={ |
|
225 0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01, |
|
226 0x3D, 0x36, 0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13, |
|
227 0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C, |
|
228 0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA, |
|
229 0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16, |
|
230 0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12, |
|
231 0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49, |
|
232 0xA0, 0xFB, 0xF5, 0x8E, 0xBB, 0x2F, 0xEE, 0x7A, |
|
233 0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F, |
|
234 0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21, |
|
235 0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27, |
|
236 0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03, |
|
237 0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1, |
|
238 0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56, 0xAA, 0xC6, |
|
239 0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6, |
|
240 0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1, |
|
241 0x45, 0x9D, 0x70, 0x59, 0x64, 0x71, 0x87, 0x20, |
|
242 0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02, |
|
243 0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6, |
|
244 0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F, |
|
245 0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A, |
|
246 0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26, |
|
247 0x2C, 0x53, 0x0D, 0x6E, 0x85, 0x28, 0x84, 0x09, |
|
248 0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52, |
|
249 0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA, |
|
250 0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A, |
|
251 0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D, |
|
252 0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39, |
|
253 0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58, 0xD0, 0xE4, |
|
254 0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A, |
|
255 0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A, |
|
256 0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14, |
|
257 }; |
|
258 TUint state[KMD2BlockSize*3]; |
|
259 TUint j=iChecksum[KMD2BlockSize-1]; |
|
260 TUint i=0,temp=0; |
|
261 while (i<(TUint)KMD2BlockSize) |
|
262 { |
|
263 const TUint tempState=iState[i]; |
|
264 temp=aData[i]; |
|
265 state[i]=tempState; |
|
266 state[i+16]=temp; |
|
267 state[i+32]=temp^tempState; |
|
268 j=CMD2_S(iChecksum[i++],S[temp^j]); |
|
269 } |
|
270 temp=0; |
|
271 TUint* pstate=state; |
|
272 const TUint *pend=state+(KMD2BlockSize*3); |
|
273 for (i=0; i<18; i++) |
|
274 { |
|
275 while (pstate<pend) |
|
276 { |
|
277 temp=CMD2_S(*pstate,S[temp]);pstate++; |
|
278 temp=CMD2_S(*pstate,S[temp]);pstate++; |
|
279 temp=CMD2_S(*pstate,S[temp]);pstate++; |
|
280 temp=CMD2_S(*pstate,S[temp]);pstate++; |
|
281 temp=CMD2_S(*pstate,S[temp]);pstate++; |
|
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 } |
|
286 pstate=state; |
|
287 temp=(temp+i)&0xff; |
|
288 } |
|
289 (void)Mem::Copy(iState,state,KMD2BlockSize*sizeof(TUint)); |
|
290 } |
|
291 |
|
292 |
|
293 // Implemented in hmacimpl.cpp or softwarehashbase.cpp |
|
294 // but required as derived from MHash. No coverage here. |
|
295 #ifdef _BullseyeCoverage |
|
296 #pragma suppress_warnings on |
|
297 #pragma BullseyeCoverage off |
|
298 #pragma suppress_warnings off |
|
299 #endif |
|
300 |
|
301 TAny* CMD2Impl::GetExtension(TUid /*aExtensionId*/) |
|
302 { |
|
303 return NULL; |
|
304 } |
|
305 |
|
306 void CMD2Impl::SetOperationModeL(TUid /*aOperationMode*/) |
|
307 { |
|
308 User::Leave(KErrNotSupported); |
|
309 } |
|
310 |
|
311 void CMD2Impl::SetKeyL(const CKey& /*aKey*/) |
|
312 { |
|
313 User::Leave(KErrNotSupported); |
|
314 } |
|
315 |