Removes all unnecessary WINE_DEFAULT_DEBUG_CHANNEL and respective wine/debug.h includes.
[wine] / dlls / rsaenh / implglue.c
1 /*
2  * dlls/rsaenh/implglue.c
3  * Glueing the RSAENH specific code to the crypto library
4  *
5  * Copyright (c) 2004, 2005 Michael Jung
6  *
7  * based on code by Mike McCormack and David Hammerton
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23 #include "config.h"
24
25 #include "wine/port.h"
26 #include "wine/library.h"
27
28 #include "windef.h"
29 #include "wincrypt.h"
30
31 #include "implglue.h"
32
33 #include <stdio.h>
34
35 /* Function prototypes copied from dlls/advapi32/crypt_md4.c */
36 VOID WINAPI MD4Init( MD4_CTX *ctx );
37 VOID WINAPI MD4Update( MD4_CTX *ctx, const unsigned char *buf, unsigned int len );
38 VOID WINAPI MD4Final( MD4_CTX *ctx );
39 /* Function prototypes copied from dlls/advapi32/crypt_md5.c */
40 VOID WINAPI MD5Init( MD5_CTX *ctx );
41 VOID WINAPI MD5Update( MD5_CTX *ctx, const unsigned char *buf, unsigned int len );
42 VOID WINAPI MD5Final( MD5_CTX *ctx );
43 /* Function prototypes copied from dlls/advapi32/crypt_sha.c */
44 VOID WINAPI A_SHAInit(PSHA_CTX Context);
45 VOID WINAPI A_SHAUpdate(PSHA_CTX Context, PCHAR Buffer, UINT BufferSize);
46 VOID WINAPI A_SHAFinal(PSHA_CTX Context, PULONG Result);
47 /* Function prototype copied from dlls/advapi32/crypt.c */
48 BOOL WINAPI SystemFunction036(PVOID pbBuffer, ULONG dwLen);
49         
50 BOOL init_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext) 
51 {
52     switch (aiAlgid) 
53     {
54         case CALG_MD2:
55             md2_init(&pHashContext->md2);
56             break;
57         
58         case CALG_MD4:
59             MD4Init(&pHashContext->md4);
60             break;
61         
62         case CALG_MD5:
63             MD5Init(&pHashContext->md5);
64             break;
65         
66         case CALG_SHA:
67             A_SHAInit(&pHashContext->sha);
68             break;
69     }
70
71     return TRUE;
72 }
73
74 BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, CONST BYTE *pbData, 
75                       DWORD dwDataLen) 
76 {
77     switch (aiAlgid)
78     {
79         case CALG_MD2:
80             md2_process(&pHashContext->md2, pbData, dwDataLen);
81             break;
82         
83         case CALG_MD4:
84             MD4Update(&pHashContext->md4, pbData, dwDataLen);
85             break;
86     
87         case CALG_MD5:
88             MD5Update(&pHashContext->md5, pbData, dwDataLen);
89             break;
90         
91         case CALG_SHA:
92             A_SHAUpdate(&pHashContext->sha, (PCHAR)pbData, dwDataLen);
93             break;
94         
95         default:
96             SetLastError(NTE_BAD_ALGID);
97             return FALSE;
98     }
99
100     return TRUE;
101 }
102
103 BOOL finalize_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, BYTE *pbHashValue) 
104 {
105     switch (aiAlgid)
106     {
107         case CALG_MD2:
108             md2_done(&pHashContext->md2, pbHashValue);
109             break;
110         
111         case CALG_MD4:
112             MD4Final(&pHashContext->md4);
113             memcpy(pbHashValue, pHashContext->md4.digest, 16);
114             break;
115         
116         case CALG_MD5:
117             MD5Final(&pHashContext->md5);
118             memcpy(pbHashValue, pHashContext->md5.digest, 16);
119             break;
120         
121         case CALG_SHA:
122             A_SHAFinal(&pHashContext->sha, (PULONG)pbHashValue);
123             break;
124         
125         default:
126             SetLastError(NTE_BAD_ALGID);
127             return FALSE;
128     }
129
130     return TRUE;
131 }
132
133 BOOL duplicate_hash_impl(ALG_ID aiAlgid, CONST HASH_CONTEXT *pSrcHashContext, 
134                          HASH_CONTEXT *pDestHashContext) 
135 {
136     memcpy(pDestHashContext, pSrcHashContext, sizeof(HASH_CONTEXT));
137
138     return TRUE;
139 }
140
141 BOOL new_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen) 
142 {
143     switch (aiAlgid)
144     {
145         case CALG_RSA_KEYX:
146         case CALG_RSA_SIGN:
147             if (rsa_make_key((int)dwKeyLen, 65537, &pKeyContext->rsa) != CRYPT_OK) {
148                 SetLastError(NTE_FAIL);
149                 return FALSE;
150             }
151             return TRUE;
152     }
153
154     return TRUE;
155 }
156
157 BOOL free_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext)
158 {
159     switch (aiAlgid)
160     {
161         case CALG_RSA_KEYX:
162         case CALG_RSA_SIGN:
163             rsa_free(&pKeyContext->rsa);
164     }
165
166     return TRUE;
167 }
168
169 BOOL setup_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, DWORD dwSaltLen, 
170                     BYTE *abKeyValue) 
171 {
172     switch (aiAlgid) 
173     {
174         case CALG_RC4:
175             rc4_start(&pKeyContext->rc4);
176             rc4_add_entropy(abKeyValue, dwKeyLen + dwSaltLen, &pKeyContext->rc4);
177             rc4_ready(&pKeyContext->rc4);
178             break;
179         
180         case CALG_RC2:
181             rc2_setup(abKeyValue, dwKeyLen + dwSaltLen, dwKeyLen << 3, 0, &pKeyContext->rc2);
182             break;
183         
184         case CALG_3DES:
185             des3_setup(abKeyValue, 24, 0, &pKeyContext->des3);
186             break;
187
188         case CALG_3DES_112:
189             memcpy(abKeyValue+16, abKeyValue, 8);
190             des3_setup(abKeyValue, 24, 0, &pKeyContext->des3);
191             break;
192         
193         case CALG_DES:
194             des_setup(abKeyValue, 8, 0, &pKeyContext->des);
195             break;
196     }
197
198     return TRUE;
199 }
200
201 BOOL duplicate_key_impl(ALG_ID aiAlgid, CONST KEY_CONTEXT *pSrcKeyContext,
202                         KEY_CONTEXT *pDestKeyContext) 
203 {
204     switch (aiAlgid) 
205     {
206         case CALG_RC4:
207         case CALG_RC2:
208         case CALG_3DES:
209         case CALG_3DES_112:
210         case CALG_DES:
211             memcpy(pDestKeyContext, pSrcKeyContext, sizeof(KEY_CONTEXT));
212             break;
213         case CALG_RSA_KEYX:
214         case CALG_RSA_SIGN:
215             pDestKeyContext->rsa.type = pSrcKeyContext->rsa.type;
216             mp_init_copy(&pDestKeyContext->rsa.e, &pSrcKeyContext->rsa.e);
217             mp_init_copy(&pDestKeyContext->rsa.d, &pSrcKeyContext->rsa.d);
218             mp_init_copy(&pDestKeyContext->rsa.N, &pSrcKeyContext->rsa.N);
219             mp_init_copy(&pDestKeyContext->rsa.p, &pSrcKeyContext->rsa.p);
220             mp_init_copy(&pDestKeyContext->rsa.q, &pSrcKeyContext->rsa.q);
221             mp_init_copy(&pDestKeyContext->rsa.qP, &pSrcKeyContext->rsa.qP);
222             mp_init_copy(&pDestKeyContext->rsa.dP, &pSrcKeyContext->rsa.dP);
223             mp_init_copy(&pDestKeyContext->rsa.dQ, &pSrcKeyContext->rsa.dQ);
224             break;
225         
226         default:
227             SetLastError(NTE_BAD_ALGID);
228             return FALSE;
229     }
230
231     return TRUE;
232 }
233
234 static inline void reverse_bytes(BYTE *pbData, DWORD dwLen) {
235     BYTE swap;
236     DWORD i;
237
238     for (i=0; i<dwLen/2; i++) {
239         swap = pbData[i];
240         pbData[i] = pbData[dwLen-i-1];
241         pbData[dwLen-i-1] = swap;
242     }
243 }
244
245 BOOL encrypt_block_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, CONST BYTE *in, BYTE *out, 
246                         DWORD enc) 
247 {
248     unsigned long inlen, outlen;
249     BYTE *in_reversed = NULL;
250     int key;
251         
252     switch (aiAlgid) {
253         case CALG_RC2:
254             if (enc) {
255                 rc2_ecb_encrypt(in, out, &pKeyContext->rc2);
256             } else {
257                 rc2_ecb_decrypt(in, out, &pKeyContext->rc2);
258             }
259             break;
260
261         case CALG_3DES:
262         case CALG_3DES_112:
263             if (enc) {
264                 des3_ecb_encrypt(in, out, &pKeyContext->des3);
265             } else {
266                 des3_ecb_decrypt(in, out, &pKeyContext->des3);
267             }
268             break;
269
270         case CALG_DES:
271             if (enc) {
272                 des_ecb_encrypt(in, out, &pKeyContext->des);
273             } else {
274                 des_ecb_decrypt(in, out, &pKeyContext->des);
275             }
276             break;
277
278         case CALG_RSA_KEYX:
279         case CALG_RSA_SIGN:
280             outlen = inlen = (mp_count_bits(&pKeyContext->rsa.N)+7)/8;
281             if (enc) {
282                 if (aiAlgid == CALG_RSA_SIGN) {
283                     key = PK_PRIVATE;
284                 } else {
285                     key = PK_PUBLIC;
286                 }
287                 if (rsa_exptmod(in, inlen, out, &outlen, key, &pKeyContext->rsa) != CRYPT_OK) {
288                     SetLastError(NTE_FAIL);
289                     return FALSE;
290                 }
291                 reverse_bytes(out, outlen);
292             } else {
293                 if (aiAlgid == CALG_RSA_SIGN) {
294                     key = PK_PUBLIC;
295                 } else {
296                     key = PK_PRIVATE;
297                 }
298                 in_reversed = HeapAlloc(GetProcessHeap(), 0, inlen);
299                 if (!in_reversed) {
300                     SetLastError(NTE_NO_MEMORY);
301                     return FALSE;
302                 }
303                 memcpy(in_reversed, in, inlen);
304                 reverse_bytes(in_reversed, inlen);
305                 if (rsa_exptmod(in_reversed, inlen, out, &outlen, key, &pKeyContext->rsa) != CRYPT_OK) {
306                     HeapFree(GetProcessHeap(), 0, in_reversed);
307                     SetLastError(NTE_FAIL);
308                     return FALSE;
309                 }
310                 HeapFree(GetProcessHeap(), 0, in_reversed);
311             }
312             break;
313
314         default:
315             SetLastError(NTE_BAD_ALGID);
316             return FALSE;
317     }
318
319     return TRUE;
320 }
321
322 BOOL encrypt_stream_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, BYTE *stream, DWORD dwLen)
323 {
324     switch (aiAlgid) {
325         case CALG_RC4:
326             rc4_read(stream, dwLen, &pKeyContext->rc4);
327             break;
328
329         default:
330             SetLastError(NTE_BAD_ALGID);
331             return FALSE;
332     }
333
334     return TRUE;
335 }
336
337 BOOL gen_rand_impl(BYTE *pbBuffer, DWORD dwLen)
338 {
339     return SystemFunction036(pbBuffer, dwLen);
340 }
341
342 BOOL export_public_key_impl(BYTE *pbDest, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,DWORD *pdwPubExp)
343 {
344     mp_to_unsigned_bin(&pKeyContext->rsa.N, pbDest);
345     reverse_bytes(pbDest, dwKeyLen);
346     *pdwPubExp = (DWORD)mp_get_int(&pKeyContext->rsa.e);
347     return TRUE;
348 }
349
350 BOOL import_public_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
351                             DWORD dwPubExp)
352 {
353     BYTE *pbTemp;
354
355     if (mp_init_multi(&pKeyContext->rsa.e, &pKeyContext->rsa.d, &pKeyContext->rsa.N, 
356                       &pKeyContext->rsa.dQ,&pKeyContext->rsa.dP,&pKeyContext->rsa.qP, 
357                       &pKeyContext->rsa.p, &pKeyContext->rsa.q, NULL) != MP_OKAY)
358     {
359         SetLastError(NTE_FAIL);
360         return FALSE;
361     }
362
363     pbTemp = HeapAlloc(GetProcessHeap(), 0, dwKeyLen);
364     if (!pbTemp) return FALSE;
365     memcpy(pbTemp, pbSrc, dwKeyLen);
366     
367     pKeyContext->rsa.type = PK_PUBLIC;
368     reverse_bytes(pbTemp, dwKeyLen);
369     mp_read_unsigned_bin(&pKeyContext->rsa.N, pbTemp, dwKeyLen);
370     HeapFree(GetProcessHeap(), 0, pbTemp);
371     mp_set_int(&pKeyContext->rsa.e, dwPubExp);
372
373     return TRUE;    
374 }
375
376 BOOL export_private_key_impl(BYTE *pbDest, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
377                              DWORD *pdwPubExp)
378 {
379     mp_to_unsigned_bin(&pKeyContext->rsa.N, pbDest);
380     reverse_bytes(pbDest, dwKeyLen);
381     pbDest += dwKeyLen;
382     mp_to_unsigned_bin(&pKeyContext->rsa.p, pbDest);
383     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
384     pbDest += (dwKeyLen+1)>>1;
385     mp_to_unsigned_bin(&pKeyContext->rsa.q, pbDest);
386     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
387     pbDest += (dwKeyLen+1)>>1;
388     mp_to_unsigned_bin(&pKeyContext->rsa.dP, pbDest);
389     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
390     pbDest += (dwKeyLen+1)>>1;
391     mp_to_unsigned_bin(&pKeyContext->rsa.dQ, pbDest);
392     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
393     pbDest += (dwKeyLen+1)>>1;
394     mp_to_unsigned_bin(&pKeyContext->rsa.qP, pbDest);
395     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
396     pbDest += (dwKeyLen+1)>>1;
397     mp_to_unsigned_bin(&pKeyContext->rsa.d, pbDest);
398     reverse_bytes(pbDest, dwKeyLen);
399     *pdwPubExp = (DWORD)mp_get_int(&pKeyContext->rsa.e);
400
401     return TRUE;
402 }
403
404 BOOL import_private_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
405                              DWORD dwPubExp)
406 {
407     BYTE *pbTemp, *pbBigNum;
408
409     if (mp_init_multi(&pKeyContext->rsa.e, &pKeyContext->rsa.d, &pKeyContext->rsa.N, 
410                       &pKeyContext->rsa.dQ,&pKeyContext->rsa.dP,&pKeyContext->rsa.qP, 
411                       &pKeyContext->rsa.p, &pKeyContext->rsa.q, NULL) != MP_OKAY)
412     {
413         SetLastError(NTE_FAIL);
414         return FALSE;
415     }
416
417     pbTemp = HeapAlloc(GetProcessHeap(), 0, 2*dwKeyLen+5*((dwKeyLen+1)>>1));
418     if (!pbTemp) return FALSE;
419     memcpy(pbTemp, pbSrc, 2*dwKeyLen+5*((dwKeyLen+1)>>1));
420     pbBigNum = pbTemp;
421
422     pKeyContext->rsa.type = PK_PRIVATE;
423     reverse_bytes(pbBigNum, dwKeyLen);
424     mp_read_unsigned_bin(&pKeyContext->rsa.N, pbBigNum, dwKeyLen);
425     pbBigNum += dwKeyLen;
426     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
427     mp_read_unsigned_bin(&pKeyContext->rsa.p, pbBigNum, (dwKeyLen+1)>>1);
428     pbBigNum += (dwKeyLen+1)>>1;
429     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
430     mp_read_unsigned_bin(&pKeyContext->rsa.q, pbBigNum, (dwKeyLen+1)>>1);
431     pbBigNum += (dwKeyLen+1)>>1;
432     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
433     mp_read_unsigned_bin(&pKeyContext->rsa.dP, pbBigNum, (dwKeyLen+1)>>1);
434     pbBigNum += (dwKeyLen+1)>>1;
435     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
436     mp_read_unsigned_bin(&pKeyContext->rsa.dQ, pbBigNum, (dwKeyLen+1)>>1);
437     pbBigNum += (dwKeyLen+1)>>1;
438     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
439     mp_read_unsigned_bin(&pKeyContext->rsa.qP, pbBigNum, (dwKeyLen+1)>>1);
440     pbBigNum += (dwKeyLen+1)>>1;
441     reverse_bytes(pbBigNum, dwKeyLen);
442     mp_read_unsigned_bin(&pKeyContext->rsa.d, pbBigNum, dwKeyLen);
443     mp_set_int(&pKeyContext->rsa.e, dwPubExp);
444     
445     HeapFree(GetProcessHeap(), 0, pbTemp);
446     return TRUE;
447 }