git.oblomov.eu Git - wine/blob - 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 }