ReactOS Development > Doxygen

00001 /*
00002  * dlls/rsaenh/implglue.c
00003  * Glueing the RSAENH specific code to the crypto library
00004  *
00005  * Copyright (c) 2004, 2005 Michael Jung
00006  * Copyright (c) 2007 Vijay Kiran Kamuju
00007  *
00008  * based on code by Mike McCormack and David Hammerton
00009  *
00010  * This library is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free Software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  *
00015  * This library is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with this library; if not, write to the Free Software
00022  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
00023  */
00024 #include "config.h"
00025 
00026 #include "wine/port.h"
00027 #include "wine/library.h"
00028 
00029 #include "windef.h"
00030 #include "wincrypt.h"
00031 
00032 #include "implglue.h"
00033 
00034 #include <stdio.h>
00035 
00036 /* Function prototypes copied from dlls/advapi32/crypt_md4.c */
00037 VOID WINAPI MD4Init( MD4_CTX *ctx );
00038 VOID WINAPI MD4Update( MD4_CTX *ctx, const unsigned char *buf, unsigned int len );
00039 VOID WINAPI MD4Final( MD4_CTX *ctx );
00040 /* Function prototypes copied from dlls/advapi32/crypt_md5.c */
00041 VOID WINAPI MD5Init( MD5_CTX *ctx );
00042 VOID WINAPI MD5Update( MD5_CTX *ctx, const unsigned char *buf, unsigned int len );
00043 VOID WINAPI MD5Final( MD5_CTX *ctx );
00044 /* Function prototypes copied from dlls/advapi32/crypt_sha.c */
00045 VOID WINAPI A_SHAInit(PSHA_CTX Context);
00046 VOID WINAPI A_SHAUpdate(PSHA_CTX Context, const unsigned char *Buffer, UINT BufferSize);
00047 VOID WINAPI A_SHAFinal(PSHA_CTX Context, PULONG Result);
00048 /* Function prototype copied from dlls/advapi32/crypt.c */
00049 BOOL WINAPI SystemFunction036(PVOID pbBuffer, ULONG dwLen);
00050         
00051 BOOL init_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext) 
00052 {
00053     switch (aiAlgid) 
00054     {
00055         case CALG_MD2:
00056             md2_init(&pHashContext->md2);
00057             break;
00058         
00059         case CALG_MD4:
00060             MD4Init(&pHashContext->md4);
00061             break;
00062         
00063         case CALG_MD5:
00064             MD5Init(&pHashContext->md5);
00065             break;
00066         
00067         case CALG_SHA:
00068             A_SHAInit(&pHashContext->sha);
00069             break;
00070 
00071         case CALG_SHA_256:
00072             SHA256_Init(&pHashContext->sha256);
00073             break;
00074 
00075         case CALG_SHA_384:
00076             SHA384_Init(&pHashContext->sha384);
00077             break;
00078 
00079         case CALG_SHA_512:
00080             SHA512_Init(&pHashContext->sha512);
00081             break;
00082     }
00083 
00084     return TRUE;
00085 }
00086 
00087 BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, CONST BYTE *pbData, 
00088                       DWORD dwDataLen) 
00089 {
00090     switch (aiAlgid)
00091     {
00092         case CALG_MD2:
00093             md2_process(&pHashContext->md2, pbData, dwDataLen);
00094             break;
00095         
00096         case CALG_MD4:
00097             MD4Update(&pHashContext->md4, pbData, dwDataLen);
00098             break;
00099     
00100         case CALG_MD5:
00101             MD5Update(&pHashContext->md5, pbData, dwDataLen);
00102             break;
00103         
00104         case CALG_SHA:
00105             A_SHAUpdate(&pHashContext->sha, pbData, dwDataLen);
00106             break;
00107         
00108         case CALG_SHA_256:
00109             SHA256_Update(&pHashContext->sha256, pbData, dwDataLen);
00110             break;
00111 
00112         case CALG_SHA_384:
00113             SHA384_Update(&pHashContext->sha384, pbData, dwDataLen);
00114             break;
00115 
00116         case CALG_SHA_512:
00117             SHA512_Update(&pHashContext->sha512, pbData, dwDataLen);
00118             break;
00119 
00120         default:
00121             SetLastError(NTE_BAD_ALGID);
00122             return FALSE;
00123     }
00124 
00125     return TRUE;
00126 }
00127 
00128 BOOL finalize_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, BYTE *pbHashValue) 
00129 {
00130     switch (aiAlgid)
00131     {
00132         case CALG_MD2:
00133             md2_done(&pHashContext->md2, pbHashValue);
00134             break;
00135         
00136         case CALG_MD4:
00137             MD4Final(&pHashContext->md4);
00138             memcpy(pbHashValue, pHashContext->md4.digest, 16);
00139             break;
00140         
00141         case CALG_MD5:
00142             MD5Final(&pHashContext->md5);
00143             memcpy(pbHashValue, pHashContext->md5.digest, 16);
00144             break;
00145         
00146         case CALG_SHA:
00147             A_SHAFinal(&pHashContext->sha, (PULONG)pbHashValue);
00148             break;
00149         
00150         case CALG_SHA_256:
00151             SHA256_Final(pbHashValue, &pHashContext->sha256);
00152             break;
00153 
00154         case CALG_SHA_384:
00155             SHA384_Final(pbHashValue, &pHashContext->sha384);
00156             break;
00157 
00158         case CALG_SHA_512:
00159             SHA512_Final(pbHashValue, &pHashContext->sha512);
00160             break;
00161 
00162         default:
00163             SetLastError(NTE_BAD_ALGID);
00164             return FALSE;
00165     }
00166 
00167     return TRUE;
00168 }
00169 
00170 BOOL duplicate_hash_impl(ALG_ID aiAlgid, CONST HASH_CONTEXT *pSrcHashContext, 
00171                          HASH_CONTEXT *pDestHashContext) 
00172 {
00173     *pDestHashContext = *pSrcHashContext;
00174 
00175     return TRUE;
00176 }
00177 
00178 BOOL new_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen) 
00179 {
00180     switch (aiAlgid)
00181     {
00182         case CALG_RSA_KEYX:
00183         case CALG_RSA_SIGN:
00184             if (rsa_make_key((int)dwKeyLen, 65537, &pKeyContext->rsa) != CRYPT_OK) {
00185                 SetLastError(NTE_FAIL);
00186                 return FALSE;
00187             }
00188             return TRUE;
00189     }
00190 
00191     return TRUE;
00192 }
00193 
00194 BOOL free_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext)
00195 {
00196     switch (aiAlgid)
00197     {
00198         case CALG_RSA_KEYX:
00199         case CALG_RSA_SIGN:
00200             rsa_free(&pKeyContext->rsa);
00201     }
00202 
00203     return TRUE;
00204 }
00205 
00206 BOOL setup_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
00207                     DWORD dwEffectiveKeyLen, DWORD dwSaltLen, BYTE *abKeyValue)
00208 {
00209     switch (aiAlgid) 
00210     {
00211         case CALG_RC4:
00212             rc4_start(&pKeyContext->rc4);
00213             rc4_add_entropy(abKeyValue, dwKeyLen + dwSaltLen, &pKeyContext->rc4);
00214             rc4_ready(&pKeyContext->rc4);
00215             break;
00216         
00217         case CALG_RC2:
00218             rc2_setup(abKeyValue, dwKeyLen + dwSaltLen, dwEffectiveKeyLen ?
00219                       dwEffectiveKeyLen : dwKeyLen << 3, 0, &pKeyContext->rc2);
00220             break;
00221         
00222         case CALG_3DES:
00223             des3_setup(abKeyValue, 24, 0, &pKeyContext->des3);
00224             break;
00225 
00226         case CALG_3DES_112:
00227             memcpy(abKeyValue+16, abKeyValue, 8);
00228             des3_setup(abKeyValue, 24, 0, &pKeyContext->des3);
00229             break;
00230         
00231         case CALG_DES:
00232             des_setup(abKeyValue, 8, 0, &pKeyContext->des);
00233             break;
00234 
00235         case CALG_AES:
00236         case CALG_AES_128:
00237             aes_setup(abKeyValue, 16, 0, &pKeyContext->aes);
00238             break;
00239 
00240         case CALG_AES_192:
00241             aes_setup(abKeyValue, 24, 0, &pKeyContext->aes);
00242             break;
00243 
00244         case CALG_AES_256:
00245             aes_setup(abKeyValue, 32, 0, &pKeyContext->aes);
00246             break;
00247     }
00248 
00249     return TRUE;
00250 }
00251 
00252 BOOL duplicate_key_impl(ALG_ID aiAlgid, CONST KEY_CONTEXT *pSrcKeyContext,
00253                         KEY_CONTEXT *pDestKeyContext) 
00254 {
00255     switch (aiAlgid) 
00256     {
00257         case CALG_RC4:
00258         case CALG_RC2:
00259         case CALG_3DES:
00260         case CALG_3DES_112:
00261         case CALG_DES:
00262         case CALG_AES:
00263         case CALG_AES_128:
00264         case CALG_AES_192:
00265         case CALG_AES_256:
00266             *pDestKeyContext = *pSrcKeyContext;
00267             break;
00268         case CALG_RSA_KEYX:
00269         case CALG_RSA_SIGN:
00270             pDestKeyContext->rsa.type = pSrcKeyContext->rsa.type;
00271             mp_init_copy(&pDestKeyContext->rsa.e, &pSrcKeyContext->rsa.e);
00272             mp_init_copy(&pDestKeyContext->rsa.d, &pSrcKeyContext->rsa.d);
00273             mp_init_copy(&pDestKeyContext->rsa.N, &pSrcKeyContext->rsa.N);
00274             mp_init_copy(&pDestKeyContext->rsa.p, &pSrcKeyContext->rsa.p);
00275             mp_init_copy(&pDestKeyContext->rsa.q, &pSrcKeyContext->rsa.q);
00276             mp_init_copy(&pDestKeyContext->rsa.qP, &pSrcKeyContext->rsa.qP);
00277             mp_init_copy(&pDestKeyContext->rsa.dP, &pSrcKeyContext->rsa.dP);
00278             mp_init_copy(&pDestKeyContext->rsa.dQ, &pSrcKeyContext->rsa.dQ);
00279             break;
00280         
00281         default:
00282             SetLastError(NTE_BAD_ALGID);
00283             return FALSE;
00284     }
00285 
00286     return TRUE;
00287 }
00288 
00289 static inline void reverse_bytes(BYTE *pbData, DWORD dwLen) {
00290     BYTE swap;
00291     DWORD i;
00292 
00293     for (i=0; i<dwLen/2; i++) {
00294         swap = pbData[i];
00295         pbData[i] = pbData[dwLen-i-1];
00296         pbData[dwLen-i-1] = swap;
00297     }
00298 }
00299 
00300 BOOL encrypt_block_impl(ALG_ID aiAlgid, DWORD dwKeySpec, KEY_CONTEXT *pKeyContext, CONST BYTE *in, BYTE *out, 
00301                         DWORD enc) 
00302 {
00303     unsigned long inlen, outlen;
00304     BYTE *in_reversed = NULL;
00305         
00306     switch (aiAlgid) {
00307         case CALG_RC2:
00308             if (enc) {
00309                 rc2_ecb_encrypt(in, out, &pKeyContext->rc2);
00310             } else {
00311                 rc2_ecb_decrypt(in, out, &pKeyContext->rc2);
00312             }
00313             break;
00314 
00315         case CALG_3DES:
00316         case CALG_3DES_112:
00317             if (enc) {
00318                 des3_ecb_encrypt(in, out, &pKeyContext->des3);
00319             } else {
00320                 des3_ecb_decrypt(in, out, &pKeyContext->des3);
00321             }
00322             break;
00323 
00324         case CALG_DES:
00325             if (enc) {
00326                 des_ecb_encrypt(in, out, &pKeyContext->des);
00327             } else {
00328                 des_ecb_decrypt(in, out, &pKeyContext->des);
00329             }
00330             break;
00331 
00332         case CALG_AES:
00333         case CALG_AES_128:
00334         case CALG_AES_192:
00335         case CALG_AES_256:
00336             if (enc) {
00337                 aes_ecb_encrypt(in, out, &pKeyContext->aes);
00338             } else {
00339                 aes_ecb_decrypt(in, out, &pKeyContext->aes);
00340             }
00341             break;
00342 
00343         case CALG_RSA_KEYX:
00344         case CALG_RSA_SIGN:
00345         case CALG_SSL3_SHAMD5:
00346             outlen = inlen = (mp_count_bits(&pKeyContext->rsa.N)+7)/8;
00347             if (enc) {
00348                 if (rsa_exptmod(in, inlen, out, &outlen, dwKeySpec, &pKeyContext->rsa) != CRYPT_OK) {
00349                     SetLastError(NTE_FAIL);
00350                     return FALSE;
00351                 }
00352                 reverse_bytes(out, outlen);
00353             } else {
00354                 in_reversed = HeapAlloc(GetProcessHeap(), 0, inlen);
00355                 if (!in_reversed) {
00356                     SetLastError(NTE_NO_MEMORY);
00357                     return FALSE;
00358                 }
00359                 memcpy(in_reversed, in, inlen);
00360                 reverse_bytes(in_reversed, inlen);
00361                 if (rsa_exptmod(in_reversed, inlen, out, &outlen, dwKeySpec, &pKeyContext->rsa) != CRYPT_OK) {
00362                     HeapFree(GetProcessHeap(), 0, in_reversed);
00363                     SetLastError(NTE_FAIL);
00364                     return FALSE;
00365                 }
00366                 HeapFree(GetProcessHeap(), 0, in_reversed);
00367             }
00368             break;
00369 
00370         default:
00371             SetLastError(NTE_BAD_ALGID);
00372             return FALSE;
00373     }
00374 
00375     return TRUE;
00376 }
00377 
00378 BOOL encrypt_stream_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, BYTE *stream, DWORD dwLen)
00379 {
00380     switch (aiAlgid) {
00381         case CALG_RC4:
00382             rc4_read(stream, dwLen, &pKeyContext->rc4);
00383             break;
00384 
00385         default:
00386             SetLastError(NTE_BAD_ALGID);
00387             return FALSE;
00388     }
00389 
00390     return TRUE;
00391 }
00392 
00393 BOOL gen_rand_impl(BYTE *pbBuffer, DWORD dwLen)
00394 {
00395     return SystemFunction036(pbBuffer, dwLen);
00396 }
00397 
00398 BOOL export_public_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,DWORD *pdwPubExp)
00399 {
00400     mp_to_unsigned_bin(&pKeyContext->rsa.N, pbDest);
00401     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.N));
00402     if (mp_unsigned_bin_size(&pKeyContext->rsa.N) < dwKeyLen)
00403         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.N), 0,
00404                dwKeyLen - mp_unsigned_bin_size(&pKeyContext->rsa.N));
00405     *pdwPubExp = (DWORD)mp_get_int(&pKeyContext->rsa.e);
00406     return TRUE;
00407 }
00408 
00409 BOOL import_public_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
00410                             DWORD dwPubExp)
00411 {
00412     BYTE *pbTemp;
00413 
00414     if (mp_init_multi(&pKeyContext->rsa.e, &pKeyContext->rsa.d, &pKeyContext->rsa.N, 
00415                       &pKeyContext->rsa.dQ,&pKeyContext->rsa.dP,&pKeyContext->rsa.qP, 
00416                       &pKeyContext->rsa.p, &pKeyContext->rsa.q, NULL) != MP_OKAY)
00417     {
00418         SetLastError(NTE_FAIL);
00419         return FALSE;
00420     }
00421 
00422     pbTemp = HeapAlloc(GetProcessHeap(), 0, dwKeyLen);
00423     if (!pbTemp) return FALSE;
00424     memcpy(pbTemp, pbSrc, dwKeyLen);
00425     
00426     pKeyContext->rsa.type = PK_PUBLIC;
00427     reverse_bytes(pbTemp, dwKeyLen);
00428     mp_read_unsigned_bin(&pKeyContext->rsa.N, pbTemp, dwKeyLen);
00429     HeapFree(GetProcessHeap(), 0, pbTemp);
00430     mp_set_int(&pKeyContext->rsa.e, dwPubExp);
00431 
00432     return TRUE;    
00433 }
00434 
00435 BOOL export_private_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
00436                              DWORD *pdwPubExp)
00437 {
00438     mp_to_unsigned_bin(&pKeyContext->rsa.N, pbDest);
00439     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.N));
00440     if (mp_unsigned_bin_size(&pKeyContext->rsa.N) < dwKeyLen)
00441         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.N), 0,
00442                dwKeyLen - mp_unsigned_bin_size(&pKeyContext->rsa.N));
00443     pbDest += dwKeyLen;
00444     mp_to_unsigned_bin(&pKeyContext->rsa.p, pbDest);
00445     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.p));
00446     if (mp_unsigned_bin_size(&pKeyContext->rsa.p) < (dwKeyLen+1)>>1)
00447         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.p), 0,
00448                ((dwKeyLen+1)>>1) - mp_unsigned_bin_size(&pKeyContext->rsa.p));
00449     pbDest += (dwKeyLen+1)>>1;
00450     mp_to_unsigned_bin(&pKeyContext->rsa.q, pbDest);
00451     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.q));
00452     if (mp_unsigned_bin_size(&pKeyContext->rsa.q) < (dwKeyLen+1)>>1)
00453         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.q), 0,
00454                ((dwKeyLen+1)>>1) - mp_unsigned_bin_size(&pKeyContext->rsa.q));
00455     pbDest += (dwKeyLen+1)>>1;
00456     mp_to_unsigned_bin(&pKeyContext->rsa.dP, pbDest);
00457     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.dP));
00458     if (mp_unsigned_bin_size(&pKeyContext->rsa.dP) < (dwKeyLen+1)>>1)
00459         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.dP), 0,
00460                ((dwKeyLen+1)>>1) - mp_unsigned_bin_size(&pKeyContext->rsa.dP));
00461     pbDest += (dwKeyLen+1)>>1;
00462     mp_to_unsigned_bin(&pKeyContext->rsa.dQ, pbDest);
00463     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.dQ));
00464     if (mp_unsigned_bin_size(&pKeyContext->rsa.dQ) < (dwKeyLen+1)>>1)
00465         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.dQ), 0,
00466                ((dwKeyLen+1)>>1) - mp_unsigned_bin_size(&pKeyContext->rsa.dQ));
00467     pbDest += (dwKeyLen+1)>>1;
00468     mp_to_unsigned_bin(&pKeyContext->rsa.qP, pbDest);
00469     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.qP));
00470     if (mp_unsigned_bin_size(&pKeyContext->rsa.qP) < (dwKeyLen+1)>>1)
00471         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.qP), 0,
00472                ((dwKeyLen+1)>>1) - mp_unsigned_bin_size(&pKeyContext->rsa.qP));
00473     pbDest += (dwKeyLen+1)>>1;
00474     mp_to_unsigned_bin(&pKeyContext->rsa.d, pbDest);
00475     reverse_bytes(pbDest, mp_unsigned_bin_size(&pKeyContext->rsa.d));
00476     if (mp_unsigned_bin_size(&pKeyContext->rsa.d) < dwKeyLen)
00477         memset(pbDest + mp_unsigned_bin_size(&pKeyContext->rsa.d), 0,
00478                dwKeyLen - mp_unsigned_bin_size(&pKeyContext->rsa.d));
00479     *pdwPubExp = (DWORD)mp_get_int(&pKeyContext->rsa.e);
00480 
00481     return TRUE;
00482 }
00483 
00484 BOOL import_private_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
00485                              DWORD dwDataLen, DWORD dwPubExp)
00486 {
00487     BYTE *pbTemp, *pbBigNum;
00488 
00489     if (mp_init_multi(&pKeyContext->rsa.e, &pKeyContext->rsa.d, &pKeyContext->rsa.N, 
00490                       &pKeyContext->rsa.dQ,&pKeyContext->rsa.dP,&pKeyContext->rsa.qP, 
00491                       &pKeyContext->rsa.p, &pKeyContext->rsa.q, NULL) != MP_OKAY)
00492     {
00493         SetLastError(NTE_FAIL);
00494         return FALSE;
00495     }
00496 
00497     pbTemp = HeapAlloc(GetProcessHeap(), 0, 2*dwKeyLen+5*((dwKeyLen+1)>>1));
00498     if (!pbTemp) return FALSE;
00499     memcpy(pbTemp, pbSrc, min(dwDataLen, 2*dwKeyLen+5*((dwKeyLen+1)>>1)));
00500     pbBigNum = pbTemp;
00501 
00502     pKeyContext->rsa.type = PK_PRIVATE;
00503     reverse_bytes(pbBigNum, dwKeyLen);
00504     mp_read_unsigned_bin(&pKeyContext->rsa.N, pbBigNum, dwKeyLen);
00505     pbBigNum += dwKeyLen;
00506     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
00507     mp_read_unsigned_bin(&pKeyContext->rsa.p, pbBigNum, (dwKeyLen+1)>>1);
00508     pbBigNum += (dwKeyLen+1)>>1;
00509     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
00510     mp_read_unsigned_bin(&pKeyContext->rsa.q, pbBigNum, (dwKeyLen+1)>>1);
00511     pbBigNum += (dwKeyLen+1)>>1;
00512     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
00513     mp_read_unsigned_bin(&pKeyContext->rsa.dP, pbBigNum, (dwKeyLen+1)>>1);
00514     pbBigNum += (dwKeyLen+1)>>1;
00515     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
00516     mp_read_unsigned_bin(&pKeyContext->rsa.dQ, pbBigNum, (dwKeyLen+1)>>1);
00517     pbBigNum += (dwKeyLen+1)>>1;
00518     reverse_bytes(pbBigNum, (dwKeyLen+1)>>1);
00519     mp_read_unsigned_bin(&pKeyContext->rsa.qP, pbBigNum, (dwKeyLen+1)>>1);
00520     pbBigNum += (dwKeyLen+1)>>1;
00521     /* The size of the private exponent d is inferred from the remaining
00522      * data length.
00523      */
00524     dwKeyLen = min(dwKeyLen, dwDataLen - (pbBigNum - pbTemp));
00525     reverse_bytes(pbBigNum, dwKeyLen);
00526     mp_read_unsigned_bin(&pKeyContext->rsa.d, pbBigNum, dwKeyLen);
00527     mp_set_int(&pKeyContext->rsa.e, dwPubExp);
00528     
00529     HeapFree(GetProcessHeap(), 0, pbTemp);
00530     return TRUE;
00531 }
Generated on Sat May 26 2012 04:24:43 for ReactOS by
1.7.6.1