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 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23 #include "config.h"
  24
  25 #include "wine/port.h"
  26 #include "wine/library.h"
  27 #include "wine/debug.h"
  28
  29 #include "windef.h"
  30 #include "wincrypt.h"
  31
  32 #include "implglue.h"
  33
  34 #include <stdio.h>
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  37
  38 /* Function prototypes copied from dlls/advapi32/crypt_md4.c */
  39 VOID WINAPI MD4Init( MD4_CTX *ctx );
  40 VOID WINAPI MD4Update( MD4_CTX *ctx, const unsigned char *buf, unsigned int len );
  41 VOID WINAPI MD4Final( MD4_CTX *ctx );
  42 /* Function prototypes copied from dlls/advapi32/crypt_md5.c */
  43 VOID WINAPI MD5Init( MD5_CTX *ctx );
  44 VOID WINAPI MD5Update( MD5_CTX *ctx, const unsigned char *buf, unsigned int len );
  45 VOID WINAPI MD5Final( MD5_CTX *ctx );
  46 /* Function prototypes copied from dlls/advapi32/crypt_sha.c */
  47 VOID WINAPI A_SHAInit(PSHA_CTX Context);
  48 VOID WINAPI A_SHAUpdate(PSHA_CTX Context, PCHAR Buffer, UINT BufferSize);
  49 VOID WINAPI A_SHAFinal(PSHA_CTX Context, PULONG Result);
  50
  51 BOOL init_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext)
  52 {
  53     switch (aiAlgid)
  54     {
  55         case CALG_MD2:
  56             md2_init(&pHashContext->md2);
  57             break;
  58
  59         case CALG_MD4:
  60             MD4Init(&pHashContext->md4);
  61             break;
  62
  63         case CALG_MD5:
  64             MD5Init(&pHashContext->md5);
  65             break;
  66
  67         case CALG_SHA:
  68             A_SHAInit(&pHashContext->sha);
  69             break;
  70
  71         default:
  72             SetLastError(NTE_BAD_ALGID);
  73             return FALSE;
  74     }
  75
  76     return TRUE;
  77 }
  78
  79 BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, CONST BYTE *pbData,
  80                       DWORD dwDataLen)
  81 {
  82     switch (aiAlgid)
  83     {
  84         case CALG_MD2:
  85             md2_process(&pHashContext->md2, pbData, dwDataLen);
  86             break;
  87
  88         case CALG_MD4:
  89             MD4Update(&pHashContext->md4, pbData, dwDataLen);
  90             break;
  91
  92         case CALG_MD5:
  93             MD5Update(&pHashContext->md5, pbData, dwDataLen);
  94             break;
  95
  96         case CALG_SHA:
  97             A_SHAUpdate(&pHashContext->sha, (PCHAR)pbData, dwDataLen);
  98             break;
  99
 100         default:
 101             SetLastError(NTE_BAD_ALGID);
 102             return FALSE;
 103     }
 104
 105     return TRUE;
 106 }
 107
 108 BOOL finalize_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, BYTE *pbHashValue)
 109 {
 110     switch (aiAlgid)
 111     {
 112         case CALG_MD2:
 113             md2_done(&pHashContext->md2, pbHashValue);
 114             break;
 115
 116         case CALG_MD4:
 117             MD4Final(&pHashContext->md4);
 118             memcpy(pbHashValue, pHashContext->md4.digest, 16);
 119             break;
 120
 121         case CALG_MD5:
 122             MD5Final(&pHashContext->md5);
 123             memcpy(pbHashValue, pHashContext->md5.digest, 16);
 124             break;
 125
 126         case CALG_SHA:
 127             A_SHAFinal(&pHashContext->sha, (PULONG)pbHashValue);
 128             break;
 129
 130         default:
 131             SetLastError(NTE_BAD_ALGID);
 132             return FALSE;
 133     }
 134
 135     return TRUE;
 136 }
 137
 138 BOOL duplicate_hash_impl(ALG_ID aiAlgid, CONST HASH_CONTEXT *pSrcHashContext,
 139                          HASH_CONTEXT *pDestHashContext)
 140 {
 141     memcpy(pDestHashContext, pSrcHashContext, sizeof(HASH_CONTEXT));
 142
 143     return TRUE;
 144 }
 145
 146 BOOL new_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen)
 147 {
 148     switch (aiAlgid)
 149     {
 150         case CALG_RSA_KEYX:
 151         case CALG_RSA_SIGN:
 152             if (rsa_make_key((int)dwKeyLen, 65537, &pKeyContext->rsa) != CRYPT_OK) {
 153                 SetLastError(NTE_FAIL);
 154                 return FALSE;
 155             }
 156             return TRUE;
 157     }
 158
 159     return TRUE;
 160 }
 161
 162 BOOL free_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext)
 163 {
 164     switch (aiAlgid)
 165     {
 166         case CALG_RSA_KEYX:
 167         case CALG_RSA_SIGN:
 168             rsa_free(&pKeyContext->rsa);
 169     }
 170
 171     return TRUE;
 172 }
 173
 174 BOOL setup_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, DWORD dwSaltLen,
 175                     BYTE *abKeyValue)
 176 {
 177     switch (aiAlgid)
 178     {
 179         case CALG_RC4:
 180             rc4_start(&pKeyContext->rc4);
 181             rc4_add_entropy(abKeyValue, dwKeyLen + dwSaltLen, &pKeyContext->rc4);
 182             rc4_ready(&pKeyContext->rc4);
 183             break;
 184
 185         case CALG_RC2:
 186             rc2_setup(abKeyValue, dwKeyLen + dwSaltLen, dwKeyLen << 3, 0, &pKeyContext->rc2);
 187             break;
 188
 189         case CALG_3DES:
 190             des3_setup(abKeyValue, 24, 0, &pKeyContext->des3);
 191             break;
 192
 193         case CALG_3DES_112:
 194             memcpy(abKeyValue+16, abKeyValue, 8);
 195             des3_setup(abKeyValue, 24, 0, &pKeyContext->des3);
 196             break;
 197
 198         case CALG_DES:
 199             des_setup(abKeyValue, 8, 0, &pKeyContext->des);
 200             break;
 201
 202         case CALG_RSA_SIGN:
 203         case CALG_RSA_KEYX:
 204             break;
 205
 206         default:
 207             SetLastError(NTE_BAD_ALGID);
 208             return FALSE;
 209     }
 210
 211     return TRUE;
 212 }
 213
 214 BOOL duplicate_key_impl(ALG_ID aiAlgid, CONST KEY_CONTEXT *pSrcKeyContext,
 215                         KEY_CONTEXT *pDestKeyContext)
 216 {
 217     switch (aiAlgid)
 218     {
 219         case CALG_RC4:
 220         case CALG_RC2:
 221         case CALG_3DES:
 222         case CALG_3DES_112:
 223         case CALG_DES:
 224             memcpy(pDestKeyContext, pSrcKeyContext, sizeof(KEY_CONTEXT));
 225             break;
 226         case CALG_RSA_KEYX:
 227         case CALG_RSA_SIGN:
 228             pDestKeyContext->rsa.type = pSrcKeyContext->rsa.type;
 229             mp_init_copy(&pDestKeyContext->rsa.e, &pSrcKeyContext->rsa.e);
 230             mp_init_copy(&pDestKeyContext->rsa.d, &pSrcKeyContext->rsa.d);
 231             mp_init_copy(&pDestKeyContext->rsa.N, &pSrcKeyContext->rsa.N);
 232             mp_init_copy(&pDestKeyContext->rsa.p, &pSrcKeyContext->rsa.p);
 233             mp_init_copy(&pDestKeyContext->rsa.q, &pSrcKeyContext->rsa.q);
 234             mp_init_copy(&pDestKeyContext->rsa.qP, &pSrcKeyContext->rsa.qP);
 235             mp_init_copy(&pDestKeyContext->rsa.dP, &pSrcKeyContext->rsa.dP);
 236             mp_init_copy(&pDestKeyContext->rsa.dQ, &pSrcKeyContext->rsa.dQ);
 237             break;
 238
 239         default:
 240             SetLastError(NTE_BAD_ALGID);
 241             return FALSE;
 242     }
 243
 244     return TRUE;
 245 }
 246
 247 static inline void reverse_bytes(BYTE *pbData, DWORD dwLen) {
 248     BYTE swap;
 249     DWORD i;
 250
 251     for (i=0; i<dwLen/2; i++) {
 252         swap = pbData[i];
 253         pbData[i] = pbData[dwLen-i-1];
 254         pbData[dwLen-i-1] = swap;
 255     }
 256 }
 257
 258 BOOL encrypt_block_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, CONST BYTE *in, BYTE *out,
 259                         DWORD enc)
 260 {
 261     unsigned long inlen, outlen;
 262     BYTE *in_reversed = NULL;
 263     int key;
 264
 265     switch (aiAlgid) {
 266         case CALG_RC2:
 267             if (enc) {
 268                 rc2_ecb_encrypt(in, out, &pKeyContext->rc2);
 269             } else {
 270                 rc2_ecb_decrypt(in, out, &pKeyContext->rc2);
 271             }
 272             break;
 273
 274         case CALG_3DES:
 275         case CALG_3DES_112:
 276             if (enc) {
 277                 des3_ecb_encrypt(in, out, &pKeyContext->des3);
 278             } else {
 279                 des3_ecb_decrypt(in, out, &pKeyContext->des3);
 280             }
 281             break;
 282
 283         case CALG_DES:
 284             if (enc) {
 285                 des_ecb_encrypt(in, out, &pKeyContext->des);
 286             } else {
 287                 des_ecb_decrypt(in, out, &pKeyContext->des);
 288             }
 289             break;
 290
 291         case CALG_RSA_KEYX:
 292         case CALG_RSA_SIGN:
 293             outlen = inlen = (mp_count_bits(&pKeyContext->rsa.N)+7)/8;
 294             if (enc) {
 295                 if (aiAlgid == CALG_RSA_SIGN) {
 296                     key = PK_PRIVATE;
 297                 } else {
 298                     key = PK_PUBLIC;
 299                 }
 300                 if (rsa_exptmod(in, inlen, out, &outlen, key, &pKeyContext->rsa) != CRYPT_OK) {
 301                     SetLastError(NTE_FAIL);
 302                     return FALSE;
 303                 }
 304                 reverse_bytes(out, outlen);
 305             } else {
 306                 if (aiAlgid == CALG_RSA_SIGN) {
 307                     key = PK_PUBLIC;
 308                 } else {
 309                     key = PK_PRIVATE;
 310                 }
 311                 in_reversed = HeapAlloc(GetProcessHeap(), 0, inlen);
 312                 if (!in_reversed) {
 313                     SetLastError(NTE_NO_MEMORY);
 314                     return FALSE;
 315                 }
 316                 memcpy(in_reversed, in, inlen);
 317                 reverse_bytes(in_reversed, inlen);
 318                 if (rsa_exptmod(in_reversed, inlen, out, &outlen, key, &pKeyContext->rsa) != CRYPT_OK) {
 319                     HeapFree(GetProcessHeap(), 0, in_reversed);
 320                     SetLastError(NTE_FAIL);
 321                     return FALSE;
 322                 }
 323                 HeapFree(GetProcessHeap(), 0, in_reversed);
 324             }
 325             break;
 326
 327         default:
 328             SetLastError(NTE_BAD_ALGID);
 329             return FALSE;
 330     }
 331
 332     return TRUE;
 333 }
 334
 335 BOOL encrypt_stream_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, BYTE *stream, DWORD dwLen)
 336 {
 337     switch (aiAlgid) {
 338         case CALG_RC4:
 339             rc4_read(stream, dwLen, &pKeyContext->rc4);
 340             break;
 341
 342         default:
 343             SetLastError(NTE_BAD_ALGID);
 344             return FALSE;
 345     }
 346
 347     return TRUE;
 348 }
 349
 350 BOOL gen_rand_impl(BYTE *pbBuffer, DWORD dwLen)
 351 {
 352     int dev_random;
 353
 354     /* FIXME: /dev/urandom does not provide random numbers of a sufficient
 355      * quality for cryptographic applications. /dev/random is much better,
 356      * but it blocks if the kernel has not yet collected enough entropy for
 357      * the request, which will suspend the calling thread for an indefinite
 358      * amount of time. */
 359     dev_random = open("/dev/urandom", O_RDONLY);
 360     if (dev_random != -1)
 361     {
 362         if (read(dev_random, pbBuffer, dwLen) == (ssize_t)dwLen)
 363         {
 364             close(dev_random);
 365             return TRUE;
 366         }
 367         close(dev_random);
 368     }
 369     SetLastError(NTE_FAIL);
 370     return FALSE;
 371 }
 372
 373 BOOL export_public_key_impl(BYTE *pbDest, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,DWORD *pdwPubExp)
 374 {
 375     mp_to_unsigned_bin(&pKeyContext->rsa.N, pbDest);
 376     reverse_bytes(pbDest, dwKeyLen);
 377     *pdwPubExp = (DWORD)mp_get_int(&pKeyContext->rsa.e);
 378     return TRUE;
 379 }
 380
 381 BOOL import_public_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
 382                             DWORD dwPubExp)
 383 {
 384     BYTE *pbTemp;
 385
 386     if (mp_init_multi(&pKeyContext->rsa.e, &pKeyContext->rsa.d, &pKeyContext->rsa.N,
 387                       &pKeyContext->rsa.dQ,&pKeyContext->rsa.dP,&pKeyContext->rsa.qP,
 388                       &pKeyContext->rsa.p, &pKeyContext->rsa.q, NULL) != MP_OKAY)
 389     {
 390         SetLastError(NTE_FAIL);
 391         return FALSE;
 392     }
 393
 394     pbTemp = (BYTE*)HeapAlloc(GetProcessHeap(), 0, dwKeyLen);
 395     if (!pbTemp) return FALSE;
 396     memcpy(pbTemp, pbSrc, dwKeyLen);
 397
 398     pKeyContext->rsa.type = PK_PUBLIC;
 399     reverse_bytes(pbTemp, dwKeyLen);
 400     mp_read_unsigned_bin(&pKeyContext->rsa.N, pbTemp, dwKeyLen);
 401     HeapFree(GetProcessHeap(), 0, pbTemp);
 402     mp_set_int(&pKeyContext->rsa.e, dwPubExp);
 403
 404     return TRUE;
 405 }
 406
 407 BOOL export_private_key_impl(BYTE *pbDest, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
 408                              DWORD *pdwPubExp)
 409 {
 410     mp_to_unsigned_bin(&pKeyContext->rsa.N, pbDest);
 411     reverse_bytes(pbDest, dwKeyLen);
 412     pbDest += dwKeyLen;
 413     mp_to_unsigned_bin(&pKeyContext->rsa.p, pbDest);
 414     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
 415     pbDest += (dwKeyLen+1)>>1;
 416     mp_to_unsigned_bin(&pKeyContext->rsa.q, pbDest);
 417     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
 418     pbDest += (dwKeyLen+1)>>1;
 419     mp_to_unsigned_bin(&pKeyContext->rsa.dP, pbDest);
 420     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
 421     pbDest += (dwKeyLen+1)>>1;
 422     mp_to_unsigned_bin(&pKeyContext->rsa.dQ, pbDest);
 423     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
 424     pbDest += (dwKeyLen+1)>>1;
 425     mp_to_unsigned_bin(&pKeyContext->rsa.qP, pbDest);
 426     reverse_bytes(pbDest, (dwKeyLen+1)>>1);
 427     pbDest += (dwKeyLen+1)>>1;
 428     mp_to_unsigned_bin(&pKeyContext->rsa.d, pbDest);
 429     reverse_bytes(pbDest, dwKeyLen);
 430     *pdwPubExp = (DWORD)mp_get_int(&pKeyContext->rsa.e);
 431
 432     return TRUE;
 433 }
 434
 435 BOOL import_private_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
 436                              DWORD dwPubExp)
 437 {
 438     BYTE *pbTemp, *pbBigNum;
 439
 440     if (mp_init_multi(&pKeyContext->rsa.e, &pKeyContext->rsa.d, &pKeyContext->rsa.N,
 441                       &pKeyContext->rsa.dQ,&pKeyContext->rsa.dP,&pKeyContext->rsa.qP,
 442                       &pKeyContext->rsa.p, &pKeyContext->rsa.q, NULL) != MP_OKAY)
 443     {
 444         SetLastError(NTE_FAIL);
 445         return FALSE;
 446     }
 447
 448     pbTemp = HeapAlloc(GetProcessHeap(), 0, 2*dwKeyLen+5*((dwKeyLen+1)>>1));
 449     if (!pbTemp) return FALSE;
 450     memcpy(pbTemp, pbSrc, 2*dwKeyLen+5*((dwKeyLen+1)>>1));
 451     pbBigNum = pbTemp;
 452
 453     pKeyContext->rsa.type = PK_PRIVATE;
 454     reverse_bytes(pbBigNum, dwKeyLen);
 455     mp_read_unsigned_bin(&pKeyContext->rsa.N, pbBigNum, dwKeyLen);
 456     pbBigNum += dwKeyLen;
 457     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
 458     mp_read_unsigned_bin(&pKeyContext->rsa.p, pbBigNum, (dwKeyLen+1)>>1);
 459     pbBigNum += (dwKeyLen+1)>>1;
 460     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
 461     mp_read_unsigned_bin(&pKeyContext->rsa.q, pbBigNum, (dwKeyLen+1)>>1);
 462     pbBigNum += (dwKeyLen+1)>>1;
 463     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
 464     mp_read_unsigned_bin(&pKeyContext->rsa.dP, pbBigNum, (dwKeyLen+1)>>1);
 465     pbBigNum += (dwKeyLen+1)>>1;
 466     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
 467     mp_read_unsigned_bin(&pKeyContext->rsa.dQ, pbBigNum, (dwKeyLen+1)>>1);
 468     pbBigNum += (dwKeyLen+1)>>1;
 469     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
 470     mp_read_unsigned_bin(&pKeyContext->rsa.qP, pbBigNum, (dwKeyLen+1)>>1);
 471     pbBigNum += (dwKeyLen+1)>>1;
 472     reverse_bytes(pbBigNum, dwKeyLen);
 473     mp_read_unsigned_bin(&pKeyContext->rsa.d, pbBigNum, dwKeyLen);
 474     mp_set_int(&pKeyContext->rsa.e, dwPubExp);
 475
 476     HeapFree(GetProcessHeap(), 0, pbTemp);
 477     return TRUE;
 478 }