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