[RSAENH]

* Sync with Wine 1.7.17.
CORE-8080

svn path=/trunk/; revision=62813

diff --git a/reactos/dll/win32/rsaenh/handle.c b/reactos/dll/win32/rsaenh/handle.c
index 0812dcc..86d8c0c 100644 (file)
--- a/reactos/dll/win32/rsaenh/handle.c
+++ b/reactos/dll/win32/rsaenh/handle.c
@@ -90,13 +90,13 @@ void destroy_handle_table(struct handle_table *lpTable)
  *  dwType  [I] A magic value that identifies the referenced object's type.
  *
  * RETURNS
  *  dwType  [I] A magic value that identifies the referenced object's type.
  *
  * RETURNS

- *  non zero,  if handle is valid.
- *  zero,      if handle is not valid.
+ *  TRUE,      if handle is valid.
+ *  FALSE,     if handle is not valid.

  */
  */

-int is_valid_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
+BOOL is_valid_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)

 {
     unsigned int index = HANDLE2INDEX(handle);
 {
     unsigned int index = HANDLE2INDEX(handle);

-    int ret = 0;
+    BOOL ret = FALSE;

 
     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
     
 
     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
     


@@ -113,8 +113,8 @@ int is_valid_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType
     
     /* Check if this handle references an object of the correct type. */
     if (lpTable->paEntries[index].pObject->dwType != dwType) goto exit;
     
     /* Check if this handle references an object of the correct type. */
     if (lpTable->paEntries[index].pObject->dwType != dwType) goto exit;

-    
-    ret = 1;
+
+    ret = TRUE;

 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;
 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;


@@ -129,13 +129,13 @@ exit:
  *  lpTable [I] Pointer to the table, which is to be grown
  *
  * RETURNS
  *  lpTable [I] Pointer to the table, which is to be grown
  *
  * RETURNS

- *  non zero,  if successful
- *  zero,      if not successful (out of memory on process heap)
+ *  TRUE,      if successful
+ *  FALSE,     if not successful (out of memory on process heap)

  *
  * NOTES
  *  This is a support function for alloc_handle. Do not call!
  */
  *
  * NOTES
  *  This is a support function for alloc_handle. Do not call!
  */

-static int grow_handle_table(struct handle_table *lpTable) 
+static BOOL grow_handle_table(struct handle_table *lpTable)

 {
     struct handle_table_entry *newEntries;
     unsigned int i, newIEntries;
 {
     struct handle_table_entry *newEntries;
     unsigned int i, newIEntries;


@@ -143,8 +143,8 @@ static int grow_handle_table(struct handle_table *lpTable)
     newIEntries = lpTable->iEntries + TABLE_SIZE_INCREMENT;
 
     newEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(struct handle_table_entry)*newIEntries);
     newIEntries = lpTable->iEntries + TABLE_SIZE_INCREMENT;
 
     newEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(struct handle_table_entry)*newIEntries);

-    if (!newEntries) 
-        return 0;
+    if (!newEntries)
+        return FALSE;

 
     if (lpTable->paEntries)
     {
 
     if (lpTable->paEntries)
     {


@@ -161,7 +161,7 @@ static int grow_handle_table(struct handle_table *lpTable)
     lpTable->paEntries = newEntries;
     lpTable->iEntries = newIEntries;
 
     lpTable->paEntries = newEntries;
     lpTable->iEntries = newIEntries;
 

-    return 1;
+    return TRUE;

 }
 
 /******************************************************************************
 }
 
 /******************************************************************************


@@ -177,12 +177,12 @@ static int grow_handle_table(struct handle_table *lpTable)
  *               be stored. If not successful, this will be 
  *               INVALID_HANDLE_VALUE
  * RETURNS
  *               be stored. If not successful, this will be 
  *               INVALID_HANDLE_VALUE
  * RETURNS

- *  non zero,  if successful
- *  zero,      if not successful (no free handle)
+ *  TRUE,      if successful
+ *  FALSE,     if not successful (no free handle)

  */
  */

-static int alloc_handle(struct handle_table *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)
+static BOOL alloc_handle(struct handle_table *lpTable, OBJECTHDR *lpObject, HCRYPTKEY *lpHandle)

 {
 {

-    int ret = 0;
+    BOOL ret = FALSE;

 
     TRACE("(lpTable=%p, lpObject=%p, lpHandle=%p)\n", lpTable, lpObject, lpHandle);
         
 
     TRACE("(lpTable=%p, lpObject=%p, lpHandle=%p)\n", lpTable, lpObject, lpHandle);
         


@@ -200,7 +200,7 @@ static int alloc_handle(struct handle_table *lpTable, OBJECTHDR *lpObject, HCRYP
     lpTable->iFirstFree = lpTable->paEntries[lpTable->iFirstFree].iNextFree;
     InterlockedIncrement(&lpObject->refcount);
 
     lpTable->iFirstFree = lpTable->paEntries[lpTable->iFirstFree].iNextFree;
     InterlockedIncrement(&lpObject->refcount);
 

-    ret = 1;
+    ret = TRUE;

 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;
 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;


@@ -224,14 +224,14 @@ exit:
  *              to be released.
  *
  * RETURNS
  *              to be released.
  *
  * RETURNS

- *  non zero,  if successful
- *  zero,      if not successful (invalid handle)
+ *  TRUE,      if successful
+ *  FALSE,     if not successful (invalid handle)

  */
  */

-int release_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
+BOOL release_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)

 {
     unsigned int index = HANDLE2INDEX(handle);
     OBJECTHDR *pObject;
 {
     unsigned int index = HANDLE2INDEX(handle);
     OBJECTHDR *pObject;

-    int ret = 0;
+    BOOL ret = FALSE;

 
     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
     
 
     TRACE("(lpTable=%p, handle=%ld)\n", lpTable, handle);
     


@@ -251,8 +251,8 @@ int release_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType)
     lpTable->paEntries[index].pObject = NULL;
     lpTable->paEntries[index].iNextFree = lpTable->iFirstFree;
     lpTable->iFirstFree = index;
     lpTable->paEntries[index].pObject = NULL;
     lpTable->paEntries[index].iNextFree = lpTable->iFirstFree;
     lpTable->iFirstFree = index;

-   
-    ret = 1;
+
+    ret = TRUE;

 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;
 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;


@@ -266,16 +266,16 @@ exit:
  * PARAMS
  *  lpTable    [I] Pointer to the handle table, in which the handle is looked up.
  *  handle     [I] The handle, which is to be looked up
  * PARAMS
  *  lpTable    [I] Pointer to the handle table, in which the handle is looked up.
  *  handle     [I] The handle, which is to be looked up

- *    lplpObject [O] Pointer to the variable, into which the pointer to the 
- *                   object looked up is copied.
+ *  lplpObject [O] Pointer to the variable, into which the pointer to the
+ *                 object looked up is copied.

  * RETURNS
  * RETURNS

- *  non zero,  if successful
- *  zero,      if not successful (invalid handle)
+ *  TRUE,      if successful
+ *  FALSE,     if not successful (invalid handle)

  */
  */

-int lookup_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)
+BOOL lookup_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject)

 {
 {

-    int ret = 0;
-    
+    BOOL ret = FALSE;
+

     TRACE("(lpTable=%p, handle=%ld, lplpObject=%p)\n", lpTable, handle, lplpObject);
     
     EnterCriticalSection(&lpTable->mutex);
     TRACE("(lpTable=%p, handle=%ld, lplpObject=%p)\n", lpTable, handle, lplpObject);
     
     EnterCriticalSection(&lpTable->mutex);


@@ -286,7 +286,7 @@ int lookup_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType,
     }
     *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject;
 
     }
     *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject;
 

-    ret = 1;
+    ret = TRUE;

 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;
 exit:
     LeaveCriticalSection(&lpTable->mutex);
     return ret;


@@ -304,14 +304,14 @@ exit:
  *  copy    [O] Pointer to a handle variable, where the copied handle is put.
  *
  * RETURNS
  *  copy    [O] Pointer to a handle variable, where the copied handle is put.
  *
  * RETURNS

- *  non zero,  if successful
- *  zero,      if not successful (invalid handle or out of memory)
+ *  TRUE,      if successful
+ *  FALSE,     if not successful (invalid handle or out of memory)

  */
  */

-int copy_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)
+BOOL copy_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy)

 {
     OBJECTHDR *pObject;
 {
     OBJECTHDR *pObject;

-    int ret;
-        
+    BOOL ret;
+

     TRACE("(lpTable=%p, handle=%ld, copy=%p)\n", lpTable, handle, copy);
 
     EnterCriticalSection(&lpTable->mutex);
     TRACE("(lpTable=%p, handle=%ld, copy=%p)\n", lpTable, handle, copy);
 
     EnterCriticalSection(&lpTable->mutex);


@@ -319,7 +319,7 @@ int copy_handle(struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HC
     {
         *copy = (HCRYPTKEY)INVALID_HANDLE_VALUE;
         LeaveCriticalSection(&lpTable->mutex);
     {
         *copy = (HCRYPTKEY)INVALID_HANDLE_VALUE;
         LeaveCriticalSection(&lpTable->mutex);

-        return 0;
+        return FALSE;

     }
 
     ret = alloc_handle(lpTable, pObject, copy);
     }
 
     ret = alloc_handle(lpTable, pObject, copy);

diff --git a/reactos/dll/win32/rsaenh/handle.h b/reactos/dll/win32/rsaenh/handle.h
index 7dc7020..d3207a5 100644 (file)
--- a/reactos/dll/win32/rsaenh/handle.h
+++ b/reactos/dll/win32/rsaenh/handle.h
@@ -58,10 +58,10 @@ struct handle_table
 
 void init_handle_table   (struct handle_table *lpTable) DECLSPEC_HIDDEN;
 void destroy_handle_table(struct handle_table *lpTable) DECLSPEC_HIDDEN;
 
 void init_handle_table   (struct handle_table *lpTable) DECLSPEC_HIDDEN;
 void destroy_handle_table(struct handle_table *lpTable) DECLSPEC_HIDDEN;

-int  release_handle      (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType) DECLSPEC_HIDDEN;
-int  copy_handle         (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy) DECLSPEC_HIDDEN;
-int  lookup_handle       (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject) DECLSPEC_HIDDEN;
-int  is_valid_handle     (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType) DECLSPEC_HIDDEN;
+BOOL release_handle      (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType) DECLSPEC_HIDDEN;
+BOOL copy_handle         (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, HCRYPTKEY *copy) DECLSPEC_HIDDEN;
+BOOL lookup_handle       (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType, OBJECTHDR **lplpObject) DECLSPEC_HIDDEN;
+BOOL is_valid_handle     (struct handle_table *lpTable, HCRYPTKEY handle, DWORD dwType) DECLSPEC_HIDDEN;

 
 HCRYPTKEY new_object     (struct handle_table *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
                            OBJECTHDR **ppObject) DECLSPEC_HIDDEN;
 
 HCRYPTKEY new_object     (struct handle_table *lpTable, size_t cbSize, DWORD dwType, DESTRUCTOR destructor,
                            OBJECTHDR **ppObject) DECLSPEC_HIDDEN;

diff --git a/reactos/dll/win32/rsaenh/implglue.c b/reactos/dll/win32/rsaenh/implglue.c
index 2084b1f..3115973 100644 (file)
--- a/reactos/dll/win32/rsaenh/implglue.c
+++ b/reactos/dll/win32/rsaenh/implglue.c
@@ -87,7 +87,7 @@ BOOL init_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext)
     return TRUE;
 }
 
     return TRUE;
 }
 

-BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, CONST BYTE *pbData, 
+BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, const BYTE *pbData,

                       DWORD dwDataLen) 
 {
     switch (aiAlgid)
                       DWORD dwDataLen) 
 {
     switch (aiAlgid)


@@ -170,7 +170,7 @@ BOOL finalize_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, BYTE *pbHash
     return TRUE;
 }
 
     return TRUE;
 }
 

-BOOL duplicate_hash_impl(ALG_ID aiAlgid, CONST HASH_CONTEXT *pSrcHashContext, 
+BOOL duplicate_hash_impl(ALG_ID aiAlgid, const HASH_CONTEXT *pSrcHashContext,

                          HASH_CONTEXT *pDestHashContext) 
 {
     *pDestHashContext = *pSrcHashContext;
                          HASH_CONTEXT *pDestHashContext) 
 {
     *pDestHashContext = *pSrcHashContext;


@@ -252,7 +252,7 @@ BOOL setup_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
     return TRUE;
 }
 
     return TRUE;
 }
 

-BOOL duplicate_key_impl(ALG_ID aiAlgid, CONST KEY_CONTEXT *pSrcKeyContext,
+BOOL duplicate_key_impl(ALG_ID aiAlgid, const KEY_CONTEXT *pSrcKeyContext,

                         KEY_CONTEXT *pDestKeyContext) 
 {
     switch (aiAlgid) 
                         KEY_CONTEXT *pDestKeyContext) 
 {
     switch (aiAlgid) 


@@ -300,8 +300,8 @@ static inline void reverse_bytes(BYTE *pbData, DWORD dwLen) {
     }
 }
 
     }
 }
 

-BOOL encrypt_block_impl(ALG_ID aiAlgid, DWORD dwKeySpec, KEY_CONTEXT *pKeyContext, CONST BYTE *in, BYTE *out, 
-                        DWORD enc) 
+BOOL encrypt_block_impl(ALG_ID aiAlgid, DWORD dwKeySpec, KEY_CONTEXT *pKeyContext, const BYTE *in,
+                        BYTE *out, DWORD enc)

 {
     unsigned long inlen, outlen;
     BYTE *in_reversed = NULL;
 {
     unsigned long inlen, outlen;
     BYTE *in_reversed = NULL;


@@ -409,7 +409,7 @@ BOOL export_public_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD
     return TRUE;
 }
 
     return TRUE;
 }
 

-BOOL import_public_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
+BOOL import_public_key_impl(const BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,

                             DWORD dwPubExp)
 {
     BYTE *pbTemp;
                             DWORD dwPubExp)
 {
     BYTE *pbTemp;


@@ -484,7 +484,7 @@ BOOL export_private_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD
     return TRUE;
 }
 
     return TRUE;
 }
 

-BOOL import_private_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
+BOOL import_private_key_impl(const BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,

                              DWORD dwDataLen, DWORD dwPubExp)
 {
     BYTE *pbTemp, *pbBigNum;
                              DWORD dwDataLen, DWORD dwPubExp)
 {
     BYTE *pbTemp, *pbBigNum;

diff --git a/reactos/dll/win32/rsaenh/implglue.h b/reactos/dll/win32/rsaenh/implglue.h
index efb5891..3ac7eef 100644 (file)
--- a/reactos/dll/win32/rsaenh/implglue.h
+++ b/reactos/dll/win32/rsaenh/implglue.h
@@ -73,31 +73,31 @@ typedef union tagKEY_CONTEXT {
 } KEY_CONTEXT;
 
 BOOL init_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext) DECLSPEC_HIDDEN;
 } KEY_CONTEXT;
 
 BOOL init_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext) DECLSPEC_HIDDEN;

-BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, CONST BYTE *pbData, 
+BOOL update_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, const BYTE *pbData,

                       DWORD dwDataLen) DECLSPEC_HIDDEN;
 BOOL finalize_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, BYTE *pbHashValue) DECLSPEC_HIDDEN;
                       DWORD dwDataLen) DECLSPEC_HIDDEN;
 BOOL finalize_hash_impl(ALG_ID aiAlgid, HASH_CONTEXT *pHashContext, BYTE *pbHashValue) DECLSPEC_HIDDEN;

-BOOL duplicate_hash_impl(ALG_ID aiAlgid, CONST HASH_CONTEXT *pSrcHashContext, 
+BOOL duplicate_hash_impl(ALG_ID aiAlgid, const HASH_CONTEXT *pSrcHashContext,

                          HASH_CONTEXT *pDestHashContext) DECLSPEC_HIDDEN;
 
 BOOL new_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen) DECLSPEC_HIDDEN;
 BOOL free_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext) DECLSPEC_HIDDEN;
 BOOL setup_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
                     DWORD dwEffectiveKeyLen, DWORD dwSaltLen, BYTE *abKeyValue) DECLSPEC_HIDDEN;
                          HASH_CONTEXT *pDestHashContext) DECLSPEC_HIDDEN;
 
 BOOL new_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen) DECLSPEC_HIDDEN;
 BOOL free_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext) DECLSPEC_HIDDEN;
 BOOL setup_key_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
                     DWORD dwEffectiveKeyLen, DWORD dwSaltLen, BYTE *abKeyValue) DECLSPEC_HIDDEN;

-BOOL duplicate_key_impl(ALG_ID aiAlgid, CONST KEY_CONTEXT *pSrcKeyContext, 
+BOOL duplicate_key_impl(ALG_ID aiAlgid, const KEY_CONTEXT *pSrcKeyContext,

                         KEY_CONTEXT *pDestKeyContext) DECLSPEC_HIDDEN;
 
 /* dwKeySpec is optional for symmetric key algorithms */
                         KEY_CONTEXT *pDestKeyContext) DECLSPEC_HIDDEN;
 
 /* dwKeySpec is optional for symmetric key algorithms */

-BOOL encrypt_block_impl(ALG_ID aiAlgid, DWORD dwKeySpec, KEY_CONTEXT *pKeyContext, CONST BYTE *pbIn, BYTE *pbOut, 
-                        DWORD enc) DECLSPEC_HIDDEN;
+BOOL encrypt_block_impl(ALG_ID aiAlgid, DWORD dwKeySpec, KEY_CONTEXT *pKeyContext, const BYTE *pbIn,
+                        BYTE *pbOut, DWORD enc) DECLSPEC_HIDDEN;

 BOOL encrypt_stream_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, BYTE *pbInOut, DWORD dwLen) DECLSPEC_HIDDEN;
 
 BOOL export_public_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
                             DWORD *pdwPubExp) DECLSPEC_HIDDEN;
 BOOL encrypt_stream_impl(ALG_ID aiAlgid, KEY_CONTEXT *pKeyContext, BYTE *pbInOut, DWORD dwLen) DECLSPEC_HIDDEN;
 
 BOOL export_public_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
                             DWORD *pdwPubExp) DECLSPEC_HIDDEN;

-BOOL import_public_key_impl(CONST BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
+BOOL import_public_key_impl(const BYTE *pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,

                             DWORD dwPubExp) DECLSPEC_HIDDEN;
 BOOL export_private_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
                              DWORD *pdwPubExp) DECLSPEC_HIDDEN;
                             DWORD dwPubExp) DECLSPEC_HIDDEN;
 BOOL export_private_key_impl(BYTE *pbDest, const KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,
                              DWORD *pdwPubExp) DECLSPEC_HIDDEN;

-BOOL import_private_key_impl(CONST BYTE* pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen, 
+BOOL import_private_key_impl(const BYTE* pbSrc, KEY_CONTEXT *pKeyContext, DWORD dwKeyLen,

                              DWORD dwDataLen, DWORD dwPubExp) DECLSPEC_HIDDEN;
 
 BOOL gen_rand_impl(BYTE *pbBuffer, DWORD dwLen) DECLSPEC_HIDDEN;
                              DWORD dwDataLen, DWORD dwPubExp) DECLSPEC_HIDDEN;
 
 BOOL gen_rand_impl(BYTE *pbBuffer, DWORD dwLen) DECLSPEC_HIDDEN;

diff --git a/reactos/dll/win32/rsaenh/mpi.c b/reactos/dll/win32/rsaenh/mpi.c
index 8feefa3..73bdf5f 100644 (file)
--- a/reactos/dll/win32/rsaenh/mpi.c
+++ b/reactos/dll/win32/rsaenh/mpi.c
@@ -1387,7 +1387,7 @@ static int mp_lshd (mp_int * a, int b)
 {
   int     x, res;
 
 {
   int     x, res;
 

-  /* if its less than zero return */
+  /* if it's less than zero return */

   if (b <= 0) {
     return MP_OKAY;
   }
   if (b <= 0) {
     return MP_OKAY;
   }


@@ -1624,7 +1624,7 @@ static int mp_div (const mp_int * a, const mp_int * b, mp_int * c, mp_int * d)
      norm = 0;
   }
 
      norm = 0;
   }
 

-  /* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
+  /* note hac does 0 based, so if used==5 then it's 0,1,2,3,4, e.g. use 4 */

   n = x.used - 1;
   t = y.used - 1;
 
   n = x.used - 1;
   t = y.used - 1;
 


@@ -1745,17 +1745,17 @@ __Q:mp_clear (&q);
   return res;
 }
 
   return res;
 }
 

-static int s_is_power_of_two(mp_digit b, int *p)
+static BOOL s_is_power_of_two(mp_digit b, int *p)

 {
    int x;
 
    for (x = 1; x < DIGIT_BIT; x++) {
       if (b == (((mp_digit)1)<<x)) {
          *p = x;
 {
    int x;
 
    for (x = 1; x < DIGIT_BIT; x++) {
       if (b == (((mp_digit)1)<<x)) {
          *p = x;

-         return 1;
+         return TRUE;

       }
    }
       }
    }

-   return 0;
+   return FALSE;

 }
 
 /* single digit division (based on routine from MPI) */
 }
 
 /* single digit division (based on routine from MPI) */


@@ -2536,7 +2536,7 @@ top:
     goto __ERR;
   }
 
     goto __ERR;
   }
 

-  /* if its too low */
+  /* if it's too low */

   while (mp_cmp_d(&C, 0) == MP_LT) {
       if ((res = mp_add(&C, b, &C)) != MP_OKAY) {
          goto __ERR;
   while (mp_cmp_d(&C, 0) == MP_LT) {
       if ((res = mp_add(&C, b, &C)) != MP_OKAY) {
          goto __ERR;


@@ -2821,13 +2821,13 @@ int mp_lcm (const mp_int * a, const mp_int * b, mp_int * c)
 
   /* divide the smallest by the GCD */
   if (mp_cmp_mag(a, b) == MP_LT) {
 
   /* divide the smallest by the GCD */
   if (mp_cmp_mag(a, b) == MP_LT) {

-     /* store quotient in t2 such that t2 * b is the LCM */
+     /* store quotient in t2 so that t2 * b is the LCM */

      if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) {
         goto __T;
      }
      res = mp_mul(b, &t2, c);
   } else {
      if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) {
         goto __T;
      }
      res = mp_mul(b, &t2, c);
   } else {

-     /* store quotient in t2 such that t2 * a is the LCM */
+     /* store quotient in t2 so that t2 * a is the LCM */

      if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) {
         goto __T;
      }
      if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) {
         goto __T;
      }

diff --git a/reactos/dll/win32/rsaenh/rsaenh.c b/reactos/dll/win32/rsaenh/rsaenh.c
index 2ac8aca..f3f9ffd 100644 (file)
--- a/reactos/dll/win32/rsaenh/rsaenh.c
+++ b/reactos/dll/win32/rsaenh/rsaenh.c
@@ -37,11 +37,12 @@
 #include <windef.h>
 //#include "winbase.h"
 #include <winreg.h>
 #include <windef.h>
 //#include "winbase.h"
 #include <winreg.h>

-//#include "wincrypt.h"
+#include <wincrypt.h>

 #include "handle.h"
 #include "implglue.h"
 #include <objbase.h>
 #include <rpcproxy.h>
 #include "handle.h"
 #include "implglue.h"
 #include <objbase.h>
 #include <rpcproxy.h>

+#include <aclapi.h>

 
 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
 
 
 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
 


@@ -335,7 +336,7 @@ static BOOL crypt_export_key(
 
 static BOOL import_key(
     HCRYPTPROV hProv, 
 
 static BOOL import_key(
     HCRYPTPROV hProv, 

-    CONST BYTE *pbData, 
+    const BYTE *pbData,

     DWORD dwDataLen, 
     HCRYPTKEY hPubKey, 
     DWORD dwFlags, 
     DWORD dwDataLen, 
     HCRYPTKEY hPubKey, 
     DWORD dwFlags, 


@@ -347,7 +348,7 @@ BOOL WINAPI
 RSAENH_CPHashData(
     HCRYPTPROV hProv, 
     HCRYPTHASH hHash, 
 RSAENH_CPHashData(
     HCRYPTPROV hProv, 
     HCRYPTHASH hHash, 

-    CONST BYTE *pbData, 
+    const BYTE *pbData,

     DWORD dwDataLen, 
     DWORD dwFlags
 );
     DWORD dwDataLen, 
     DWORD dwFlags
 );


@@ -398,8 +399,8 @@ BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, PVOID reserved)
  *  Success: TRUE (pbParam was copied into pbBuffer or pbBuffer is NULL)
  *  Failure: FALSE (pbBuffer is not large enough to hold pbParam). Last error: ERROR_MORE_DATA
  */
  *  Success: TRUE (pbParam was copied into pbBuffer or pbBuffer is NULL)
  *  Failure: FALSE (pbBuffer is not large enough to hold pbParam). Last error: ERROR_MORE_DATA
  */

-static inline BOOL copy_param(
-    BYTE *pbBuffer, DWORD *pdwBufferSize, CONST BYTE *pbParam, DWORD dwParamSize) 
+static inline BOOL copy_param(BYTE *pbBuffer, DWORD *pdwBufferSize, const BYTE *pbParam,
+                              DWORD dwParamSize)

 {
     if (pbBuffer) 
     {
 {
     if (pbBuffer) 
     {


@@ -461,7 +462,8 @@ static inline const PROV_ENUMALGS_EX* get_algid_info(HCRYPTPROV hProv, ALG_ID al
  * NOTES
  *  Use free_data_blob to release resources occupied by copy_data_blob.
  */
  * NOTES
  *  Use free_data_blob to release resources occupied by copy_data_blob.
  */

-static inline BOOL copy_data_blob(PCRYPT_DATA_BLOB dst, CONST PCRYPT_DATA_BLOB src) {
+static inline BOOL copy_data_blob(PCRYPT_DATA_BLOB dst, const PCRYPT_DATA_BLOB src)
+{

     dst->pbData = HeapAlloc(GetProcessHeap(), 0, src->cbData);
     if (!dst->pbData) {
         SetLastError(NTE_NO_MEMORY);
     dst->pbData = HeapAlloc(GetProcessHeap(), 0, src->cbData);
     if (!dst->pbData) {
         SetLastError(NTE_NO_MEMORY);


@@ -489,8 +491,8 @@ static inline BOOL copy_data_blob(PCRYPT_DATA_BLOB dst, CONST PCRYPT_DATA_BLOB s
  * NOTES
  *  Release resources occupied by concat_data_blobs with free_data_blobs
  */
  * NOTES
  *  Release resources occupied by concat_data_blobs with free_data_blobs
  */

-static inline BOOL concat_data_blobs(PCRYPT_DATA_BLOB dst, CONST PCRYPT_DATA_BLOB src1, 
-                                     CONST PCRYPT_DATA_BLOB src2) 
+static inline BOOL concat_data_blobs(PCRYPT_DATA_BLOB dst, const PCRYPT_DATA_BLOB src1,
+                                     const PCRYPT_DATA_BLOB src2)

 {
     dst->cbData = src1->cbData + src2->cbData;
     dst->pbData = HeapAlloc(GetProcessHeap(), 0, dst->cbData);
 {
     dst->cbData = src1->cbData + src2->cbData;
     dst->pbData = HeapAlloc(GetProcessHeap(), 0, dst->cbData);


@@ -655,7 +657,8 @@ static inline BOOL init_hash(CRYPTHASH *pCryptHash) {
  *  pbData     [I] Pointer to data stream to be hashed.
  *  dwDataLen  [I] Length of data stream.
  */
  *  pbData     [I] Pointer to data stream to be hashed.
  *  dwDataLen  [I] Length of data stream.
  */

-static inline void update_hash(CRYPTHASH *pCryptHash, CONST BYTE *pbData, DWORD dwDataLen) {
+static inline void update_hash(CRYPTHASH *pCryptHash, const BYTE *pbData, DWORD dwDataLen)
+{

     BYTE *pbTemp;
 
     switch (pCryptHash->aiAlgid)
     BYTE *pbTemp;
 
     switch (pCryptHash->aiAlgid)


@@ -1099,7 +1102,7 @@ static BOOL create_container_key(KEYCONTAINER *pKeyContainer, REGSAM sam, HKEY *
  *  dwFlags          [I] Flags indicating which keyset to be opened.
  *  phKey            [O] Returned key
  */
  *  dwFlags          [I] Flags indicating which keyset to be opened.
  *  phKey            [O] Returned key
  */

-static BOOL open_container_key(LPCSTR pszContainerName, DWORD dwFlags, HKEY *phKey)
+static BOOL open_container_key(LPCSTR pszContainerName, DWORD dwFlags, REGSAM access, HKEY *phKey)

 {
     CHAR szRSABase[MAX_PATH];
     HKEY hRootKey;
 {
     CHAR szRSABase[MAX_PATH];
     HKEY hRootKey;


@@ -1113,7 +1116,7 @@ static BOOL open_container_key(LPCSTR pszContainerName, DWORD dwFlags, HKEY *phK
 
     /* @@ Wine registry key: HKLM\Software\Wine\Crypto\RSA */
     /* @@ Wine registry key: HKCU\Software\Wine\Crypto\RSA */
 
     /* @@ Wine registry key: HKLM\Software\Wine\Crypto\RSA */
     /* @@ Wine registry key: HKCU\Software\Wine\Crypto\RSA */

-    return RegOpenKeyExA(hRootKey, szRSABase, 0, KEY_READ, phKey) ==
+    return RegOpenKeyExA(hRootKey, szRSABase, 0, access, phKey) ==

                          ERROR_SUCCESS;
 }
 
                          ERROR_SUCCESS;
 }
 


@@ -1383,7 +1386,7 @@ static HCRYPTPROV read_key_container(PCHAR pszContainerName, DWORD dwFlags, cons
     HCRYPTPROV hKeyContainer;
     HCRYPTKEY hCryptKey;
 
     HCRYPTPROV hKeyContainer;
     HCRYPTKEY hCryptKey;
 

-    if (!open_container_key(pszContainerName, dwFlags, &hKey))
+    if (!open_container_key(pszContainerName, dwFlags, KEY_READ, &hKey))

     {
         SetLastError(NTE_BAD_KEYSET);
         return (HCRYPTPROV)INVALID_HANDLE_VALUE;
     {
         SetLastError(NTE_BAD_KEYSET);
         return (HCRYPTPROV)INVALID_HANDLE_VALUE;


@@ -1434,14 +1437,14 @@ static HCRYPTPROV read_key_container(PCHAR pszContainerName, DWORD dwFlags, cons
  *  Failure: FALSE (NTE_BAD_ALGID)
  */
 static BOOL build_hash_signature(BYTE *pbSignature, DWORD dwLen, ALG_ID aiAlgid, 
  *  Failure: FALSE (NTE_BAD_ALGID)
  */
 static BOOL build_hash_signature(BYTE *pbSignature, DWORD dwLen, ALG_ID aiAlgid, 

-                                 CONST BYTE *abHashValue, DWORD dwHashLen, DWORD dwFlags) 
+                                 const BYTE *abHashValue, DWORD dwHashLen, DWORD dwFlags)

 {
     /* These prefixes are meant to be concatenated with hash values of the
      * respective kind to form a PKCS #7 DigestInfo. */
     static const struct tagOIDDescriptor {
         ALG_ID aiAlgid;
         DWORD dwLen;
 {
     /* These prefixes are meant to be concatenated with hash values of the
      * respective kind to form a PKCS #7 DigestInfo. */
     static const struct tagOIDDescriptor {
         ALG_ID aiAlgid;
         DWORD dwLen;

-        CONST BYTE abOID[19];
+        const BYTE abOID[19];

     } aOIDDescriptor[] = {
         { CALG_MD2, 18, { 0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48,
                           0x86, 0xf7, 0x0d, 0x02, 0x02, 0x05, 0x00, 0x04, 0x10 } },
     } aOIDDescriptor[] = {
         { CALG_MD2, 18, { 0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48,
                           0x86, 0xf7, 0x0d, 0x02, 0x02, 0x05, 0x00, 0x04, 0x10 } },


@@ -1529,7 +1532,8 @@ static BOOL build_hash_signature(BYTE *pbSignature, DWORD dwLen, ALG_ID aiAlgid,
  *  Success: TRUE
  *  Failure: FALSE
  */
  *  Success: TRUE
  *  Failure: FALSE
  */

-static BOOL tls1_p(HCRYPTHASH hHMAC, CONST PCRYPT_DATA_BLOB pblobSeed, PBYTE pbBuffer, DWORD dwBufferLen)
+static BOOL tls1_p(HCRYPTHASH hHMAC, const PCRYPT_DATA_BLOB pblobSeed, BYTE *pbBuffer,
+                   DWORD dwBufferLen)

 {
     CRYPTHASH *pHMAC;
     BYTE abAi[RSAENH_MAX_HASH_SIZE];
 {
     CRYPTHASH *pHMAC;
     BYTE abAi[RSAENH_MAX_HASH_SIZE];


@@ -1587,8 +1591,8 @@ static BOOL tls1_p(HCRYPTHASH hHMAC, CONST PCRYPT_DATA_BLOB pblobSeed, PBYTE pbB
  *  Success: TRUE
  *  Failure: FALSE
  */ 
  *  Success: TRUE
  *  Failure: FALSE
  */ 

-static BOOL tls1_prf(HCRYPTPROV hProv, HCRYPTPROV hSecret, CONST PCRYPT_DATA_BLOB pblobLabel,
-                     CONST PCRYPT_DATA_BLOB pblobSeed, PBYTE pbBuffer, DWORD dwBufferLen)
+static BOOL tls1_prf(HCRYPTPROV hProv, HCRYPTPROV hSecret, const PCRYPT_DATA_BLOB pblobLabel,
+                     const PCRYPT_DATA_BLOB pblobSeed, BYTE *pbBuffer, DWORD dwBufferLen)

 {
     HMAC_INFO hmacInfo = { 0, NULL, 0, NULL, 0 };
     HCRYPTHASH hHMAC = (HCRYPTHASH)INVALID_HANDLE_VALUE;
 {
     HMAC_INFO hmacInfo = { 0, NULL, 0, NULL, 0 };
     HCRYPTHASH hHMAC = (HCRYPTHASH)INVALID_HANDLE_VALUE;


@@ -1656,7 +1660,7 @@ exit:
  *  Success: TRUE
  *  Failure: FALSE (NTE_BAD_LEN, too much data to pad)
  */
  *  Success: TRUE
  *  Failure: FALSE (NTE_BAD_LEN, too much data to pad)
  */

-static BOOL pad_data(CONST BYTE *abData, DWORD dwDataLen, BYTE *abBuffer, DWORD dwBufferLen, 
+static BOOL pad_data(const BYTE *abData, DWORD dwDataLen, BYTE *abBuffer, DWORD dwBufferLen,

                      DWORD dwFlags)
 {
     DWORD i;
                      DWORD dwFlags)
 {
     DWORD i;


@@ -1697,7 +1701,7 @@ static BOOL pad_data(CONST BYTE *abData, DWORD dwDataLen, BYTE *abBuffer, DWORD
  *  Success: TRUE
  *  Failure: FALSE, (NTE_BAD_DATA, no valid PKCS1 padding or buffer too small)
  */
  *  Success: TRUE
  *  Failure: FALSE, (NTE_BAD_DATA, no valid PKCS1 padding or buffer too small)
  */

-static BOOL unpad_data(CONST BYTE *abData, DWORD dwDataLen, BYTE *abBuffer, DWORD *dwBufferLen, 
+static BOOL unpad_data(const BYTE *abData, DWORD dwDataLen, BYTE *abBuffer, DWORD *dwBufferLen,

                        DWORD dwFlags)
 {
     DWORD i;
                        DWORD dwFlags)
 {
     DWORD i;


@@ -2721,13 +2725,13 @@ static void release_and_install_key(HCRYPTPROV hProv, HCRYPTKEY src,
  *  Success: TRUE.
  *  Failure: FALSE.
  */
  *  Success: TRUE.
  *  Failure: FALSE.
  */

-static BOOL import_private_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen,
+static BOOL import_private_key(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen,

                                DWORD dwFlags, BOOL fStoreKey, HCRYPTKEY *phKey)
 {
     KEYCONTAINER *pKeyContainer;
     CRYPTKEY *pCryptKey;
                                DWORD dwFlags, BOOL fStoreKey, HCRYPTKEY *phKey)
 {
     KEYCONTAINER *pKeyContainer;
     CRYPTKEY *pCryptKey;

-    CONST BLOBHEADER *pBlobHeader = (CONST BLOBHEADER*)pbData;
-    CONST RSAPUBKEY *pRSAPubKey = (CONST RSAPUBKEY*)(pBlobHeader+1);
+    const BLOBHEADER *pBlobHeader = (const BLOBHEADER*)pbData;
+    const RSAPUBKEY *pRSAPubKey = (const RSAPUBKEY*)(pBlobHeader+1);

     BOOL ret;
 
     if (dwFlags & CRYPT_IPSEC_HMAC_KEY)
     BOOL ret;
 
     if (dwFlags & CRYPT_IPSEC_HMAC_KEY)


@@ -2771,7 +2775,7 @@ static BOOL import_private_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDat
     *phKey = new_key(hProv, pBlobHeader->aiKeyAlg, MAKELONG(0,pRSAPubKey->bitlen), &pCryptKey);
     if (*phKey == (HCRYPTKEY)INVALID_HANDLE_VALUE) return FALSE;
     setup_key(pCryptKey);
     *phKey = new_key(hProv, pBlobHeader->aiKeyAlg, MAKELONG(0,pRSAPubKey->bitlen), &pCryptKey);
     if (*phKey == (HCRYPTKEY)INVALID_HANDLE_VALUE) return FALSE;
     setup_key(pCryptKey);

-    ret = import_private_key_impl((CONST BYTE*)(pRSAPubKey+1), &pCryptKey->context,
+    ret = import_private_key_impl((const BYTE*)(pRSAPubKey+1), &pCryptKey->context,

                                    pRSAPubKey->bitlen/8, dwDataLen, pRSAPubKey->pubexp);
     if (ret) {
         if (dwFlags & CRYPT_EXPORTABLE)
                                    pRSAPubKey->bitlen/8, dwDataLen, pRSAPubKey->pubexp);
     if (ret) {
         if (dwFlags & CRYPT_EXPORTABLE)


@@ -2818,13 +2822,13 @@ static BOOL import_private_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDat
  *  Success: TRUE.
  *  Failure: FALSE.
  */
  *  Success: TRUE.
  *  Failure: FALSE.
  */

-static BOOL import_public_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen,
+static BOOL import_public_key(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen,

                               DWORD dwFlags, BOOL fStoreKey, HCRYPTKEY *phKey)
 {
     KEYCONTAINER *pKeyContainer;
     CRYPTKEY *pCryptKey;
                               DWORD dwFlags, BOOL fStoreKey, HCRYPTKEY *phKey)
 {
     KEYCONTAINER *pKeyContainer;
     CRYPTKEY *pCryptKey;

-    CONST BLOBHEADER *pBlobHeader = (CONST BLOBHEADER*)pbData;
-    CONST RSAPUBKEY *pRSAPubKey = (CONST RSAPUBKEY*)(pBlobHeader+1);
+    const BLOBHEADER *pBlobHeader = (const BLOBHEADER*)pbData;
+    const RSAPUBKEY *pRSAPubKey = (const RSAPUBKEY*)(pBlobHeader+1);

     ALG_ID algID;
     BOOL ret;
 
     ALG_ID algID;
     BOOL ret;
 


@@ -2856,7 +2860,7 @@ static BOOL import_public_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwData
     *phKey = new_key(hProv, algID, MAKELONG(0,pRSAPubKey->bitlen), &pCryptKey);
     if (*phKey == (HCRYPTKEY)INVALID_HANDLE_VALUE) return FALSE;
     setup_key(pCryptKey);
     *phKey = new_key(hProv, algID, MAKELONG(0,pRSAPubKey->bitlen), &pCryptKey);
     if (*phKey == (HCRYPTKEY)INVALID_HANDLE_VALUE) return FALSE;
     setup_key(pCryptKey);

-    ret = import_public_key_impl((CONST BYTE*)(pRSAPubKey+1), &pCryptKey->context,
+    ret = import_public_key_impl((const BYTE*)(pRSAPubKey+1), &pCryptKey->context,

                                   pRSAPubKey->bitlen >> 3, pRSAPubKey->pubexp);
     if (ret) {
         if (dwFlags & CRYPT_EXPORTABLE)
                                   pRSAPubKey->bitlen >> 3, pRSAPubKey->pubexp);
     if (ret) {
         if (dwFlags & CRYPT_EXPORTABLE)


@@ -2897,14 +2901,13 @@ static BOOL import_public_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwData
  *  Success: TRUE.
  *  Failure: FALSE.
  */
  *  Success: TRUE.
  *  Failure: FALSE.
  */

-static BOOL import_symmetric_key(HCRYPTPROV hProv, CONST BYTE *pbData,
-                                 DWORD dwDataLen, HCRYPTKEY hPubKey,
-                                 DWORD dwFlags, HCRYPTKEY *phKey)
+static BOOL import_symmetric_key(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen,
+                                 HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)

 {
     CRYPTKEY *pCryptKey, *pPubKey;
 {
     CRYPTKEY *pCryptKey, *pPubKey;

-    CONST BLOBHEADER *pBlobHeader = (CONST BLOBHEADER*)pbData;
-    CONST ALG_ID *pAlgid = (CONST ALG_ID*)(pBlobHeader+1);
-    CONST BYTE *pbKeyStream = (CONST BYTE*)(pAlgid + 1);
+    const BLOBHEADER *pBlobHeader = (const BLOBHEADER*)pbData;
+    const ALG_ID *pAlgid = (const ALG_ID*)(pBlobHeader+1);
+    const BYTE *pbKeyStream = (const BYTE*)(pAlgid + 1);

     BYTE *pbDecrypted;
     DWORD dwKeyLen;
 
     BYTE *pbDecrypted;
     DWORD dwKeyLen;
 


@@ -2974,14 +2977,13 @@ static BOOL import_symmetric_key(HCRYPTPROV hProv, CONST BYTE *pbData,
  *  Success: TRUE.
  *  Failure: FALSE.
  */
  *  Success: TRUE.
  *  Failure: FALSE.
  */

-static BOOL import_plaintext_key(HCRYPTPROV hProv, CONST BYTE *pbData,
-                                 DWORD dwDataLen, DWORD dwFlags,
-                                 HCRYPTKEY *phKey)
+static BOOL import_plaintext_key(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen,
+                                 DWORD dwFlags, HCRYPTKEY *phKey)

 {
     CRYPTKEY *pCryptKey;
 {
     CRYPTKEY *pCryptKey;

-    CONST BLOBHEADER *pBlobHeader = (CONST BLOBHEADER*)pbData;
-    CONST DWORD *pKeyLen = (CONST DWORD *)(pBlobHeader + 1);
-    CONST BYTE *pbKeyStream = (CONST BYTE*)(pKeyLen + 1);
+    const BLOBHEADER *pBlobHeader = (const BLOBHEADER*)pbData;
+    const DWORD *pKeyLen = (const DWORD *)(pBlobHeader + 1);
+    const BYTE *pbKeyStream = (const BYTE*)(pKeyLen + 1);

 
     if (dwDataLen < sizeof(BLOBHEADER)+sizeof(DWORD)+*pKeyLen)
     {
 
     if (dwDataLen < sizeof(BLOBHEADER)+sizeof(DWORD)+*pKeyLen)
     {


@@ -3053,12 +3055,11 @@ static BOOL import_plaintext_key(HCRYPTPROV hProv, CONST BYTE *pbData,
  *  Success: TRUE.
  *  Failure: FALSE.
  */
  *  Success: TRUE.
  *  Failure: FALSE.
  */

-static BOOL import_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen,
-                       HCRYPTKEY hPubKey, DWORD dwFlags, BOOL fStoreKey,
-                       HCRYPTKEY *phKey)
+static BOOL import_key(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey,
+                       DWORD dwFlags, BOOL fStoreKey, HCRYPTKEY *phKey)

 {
     KEYCONTAINER *pKeyContainer;
 {
     KEYCONTAINER *pKeyContainer;

-    CONST BLOBHEADER *pBlobHeader = (CONST BLOBHEADER*)pbData;
+    const BLOBHEADER *pBlobHeader = (const BLOBHEADER*)pbData;

 
     if (!lookup_handle(&handle_table, hProv, RSAENH_MAGIC_CONTAINER,
                        (OBJECTHDR**)&pKeyContainer)) 
 
     if (!lookup_handle(&handle_table, hProv, RSAENH_MAGIC_CONTAINER,
                        (OBJECTHDR**)&pKeyContainer)) 


@@ -3124,7 +3125,7 @@ static BOOL import_key(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen,
  *  Success: TRUE.
  *  Failure: FALSE.
  */
  *  Success: TRUE.
  *  Failure: FALSE.
  */

-BOOL WINAPI RSAENH_CPImportKey(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen,
+BOOL WINAPI RSAENH_CPImportKey(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen,

                                HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
 {
     TRACE("(hProv=%08lx, pbData=%p, dwDataLen=%d, hPubKey=%08lx, dwFlags=%08x, phKey=%p)\n",
                                HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
 {
     TRACE("(hProv=%08lx, pbData=%p, dwDataLen=%d, hPubKey=%08lx, dwFlags=%08x, phKey=%p)\n",


@@ -3321,11 +3322,11 @@ BOOL WINAPI RSAENH_CPGetHashParam(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwPa
     switch (dwParam)
     {
         case HP_ALGID:
     switch (dwParam)
     {
         case HP_ALGID:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&pCryptHash->aiAlgid, 
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&pCryptHash->aiAlgid,

                               sizeof(ALG_ID));
 
         case HP_HASHSIZE:
                               sizeof(ALG_ID));
 
         case HP_HASHSIZE:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&pCryptHash->dwHashSize, 
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&pCryptHash->dwHashSize,

                               sizeof(DWORD));
 
         case HP_HASHVAL:
                               sizeof(DWORD));
 
         case HP_HASHVAL:


@@ -3619,37 +3620,37 @@ BOOL WINAPI RSAENH_CPGetKeyParam(HCRYPTPROV hProv, HCRYPTKEY hKey, DWORD dwParam
 
         case KP_PADDING:
             dwValue = PKCS5_PADDING;
 
         case KP_PADDING:
             dwValue = PKCS5_PADDING;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwValue, sizeof(DWORD));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwValue, sizeof(DWORD));

 
         case KP_KEYLEN:
             dwValue = pCryptKey->dwKeyLen << 3;
 
         case KP_KEYLEN:
             dwValue = pCryptKey->dwKeyLen << 3;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwValue, sizeof(DWORD));
-        
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwValue, sizeof(DWORD));
+

         case KP_EFFECTIVE_KEYLEN:
             if (pCryptKey->dwEffectiveKeyLen)
                 dwValue = pCryptKey->dwEffectiveKeyLen;
             else
                 dwValue = pCryptKey->dwKeyLen << 3;
         case KP_EFFECTIVE_KEYLEN:
             if (pCryptKey->dwEffectiveKeyLen)
                 dwValue = pCryptKey->dwEffectiveKeyLen;
             else
                 dwValue = pCryptKey->dwKeyLen << 3;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwValue, sizeof(DWORD));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwValue, sizeof(DWORD));

 
         case KP_BLOCKLEN:
             dwValue = pCryptKey->dwBlockLen << 3;
 
         case KP_BLOCKLEN:
             dwValue = pCryptKey->dwBlockLen << 3;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwValue, sizeof(DWORD));
-    
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwValue, sizeof(DWORD));
+

         case KP_MODE:
         case KP_MODE:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&pCryptKey->dwMode, sizeof(DWORD));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&pCryptKey->dwMode, sizeof(DWORD));

 
         case KP_MODE_BITS:
 
         case KP_MODE_BITS:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&pCryptKey->dwModeBits, 
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&pCryptKey->dwModeBits,

                               sizeof(DWORD));
                               sizeof(DWORD));

-    
+

         case KP_PERMISSIONS:
         case KP_PERMISSIONS:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&pCryptKey->dwPermissions, 
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&pCryptKey->dwPermissions,

                               sizeof(DWORD));
 
         case KP_ALGID:
                               sizeof(DWORD));
 
         case KP_ALGID:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&pCryptKey->aiAlgid, sizeof(DWORD));
-            
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&pCryptKey->aiAlgid, sizeof(DWORD));
+

         default:
             SetLastError(NTE_BAD_TYPE);
             return FALSE;
         default:
             SetLastError(NTE_BAD_TYPE);
             return FALSE;


@@ -3678,6 +3679,7 @@ BOOL WINAPI RSAENH_CPGetKeyParam(HCRYPTPROV hProv, HCRYPTKEY hKey, DWORD dwParam
  *   - PP_SIG_KEYSIZE_INC: RSA signature keywidth granularity in bits.
  *   - PP_KEYX_KEYSIZE_INC: RSA key-exchange keywidth granularity in bits.
  *   - PP_ENUMALGS{_EX}: Query provider capabilities.
  *   - PP_SIG_KEYSIZE_INC: RSA signature keywidth granularity in bits.
  *   - PP_KEYX_KEYSIZE_INC: RSA key-exchange keywidth granularity in bits.
  *   - PP_ENUMALGS{_EX}: Query provider capabilities.

+ *   - PP_KEYSET_SEC_DESCR: Retrieve security descriptor on container.

  */
 BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, 
                                   DWORD *pdwDataLen, DWORD dwFlags)
  */
 BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, 
                                   DWORD *pdwDataLen, DWORD dwFlags)


@@ -3692,7 +3694,7 @@ BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
      * Returning this BLOB seems to satisfy IE. The marked 0x00 seem 
      * to be 'don't care's. If you know anything more specific about
      * this provider parameter, please report to wine-devel@winehq.org */
      * Returning this BLOB seems to satisfy IE. The marked 0x00 seem 
      * to be 'don't care's. If you know anything more specific about
      * this provider parameter, please report to wine-devel@winehq.org */

-    static CONST BYTE abWTF[96] = { 
+    static const BYTE abWTF[96] = {

         0xb0, 0x25,     0x63,     0x86, 0x9c, 0xab,     0xb6,     0x37, 
         0xe8, 0x82, /**/0x00,/**/ 0x72, 0x06, 0xb2, /**/0x00,/**/ 0x3b, 
         0x60, 0x35, /**/0x00,/**/ 0x3b, 0x88, 0xce, /**/0x00,/**/ 0x82, 
         0xb0, 0x25,     0x63,     0x86, 0x9c, 0xab,     0xb6,     0x37, 
         0xe8, 0x82, /**/0x00,/**/ 0x72, 0x06, 0xb2, /**/0x00,/**/ 0x3b, 
         0x60, 0x35, /**/0x00,/**/ 0x3b, 0x88, 0xce, /**/0x00,/**/ 0x82, 


@@ -3727,42 +3729,42 @@ BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
     {
         case PP_CONTAINER:
         case PP_UNIQUE_CONTAINER:/* MSDN says we can return the same value as PP_CONTAINER */
     {
         case PP_CONTAINER:
         case PP_UNIQUE_CONTAINER:/* MSDN says we can return the same value as PP_CONTAINER */

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)pKeyContainer->szName, 
+            return copy_param(pbData, pdwDataLen, (const BYTE*)pKeyContainer->szName,

                               strlen(pKeyContainer->szName)+1);
 
         case PP_NAME:
                               strlen(pKeyContainer->szName)+1);
 
         case PP_NAME:

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)pKeyContainer->szProvName, 
+            return copy_param(pbData, pdwDataLen, (const BYTE*)pKeyContainer->szProvName,

                               strlen(pKeyContainer->szProvName)+1);
 
         case PP_PROVTYPE:
             dwTemp = PROV_RSA_FULL;
                               strlen(pKeyContainer->szProvName)+1);
 
         case PP_PROVTYPE:
             dwTemp = PROV_RSA_FULL;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));

 
         case PP_KEYSPEC:
             dwTemp = AT_SIGNATURE | AT_KEYEXCHANGE;
 
         case PP_KEYSPEC:
             dwTemp = AT_SIGNATURE | AT_KEYEXCHANGE;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));

 
         case PP_KEYSET_TYPE:
             dwTemp = pKeyContainer->dwFlags & CRYPT_MACHINE_KEYSET;
 
         case PP_KEYSET_TYPE:
             dwTemp = pKeyContainer->dwFlags & CRYPT_MACHINE_KEYSET;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));

 
         case PP_KEYSTORAGE:
             dwTemp = CRYPT_SEC_DESCR;
 
         case PP_KEYSTORAGE:
             dwTemp = CRYPT_SEC_DESCR;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));

 
         case PP_SIG_KEYSIZE_INC:
         case PP_KEYX_KEYSIZE_INC:
             dwTemp = 8;
 
         case PP_SIG_KEYSIZE_INC:
         case PP_KEYX_KEYSIZE_INC:
             dwTemp = 8;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));

 
         case PP_IMPTYPE:
             dwTemp = CRYPT_IMPL_SOFTWARE;
 
         case PP_IMPTYPE:
             dwTemp = CRYPT_IMPL_SOFTWARE;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));

 
         case PP_VERSION:
             dwTemp = 0x00000200;
 
         case PP_VERSION:
             dwTemp = 0x00000200;

-            return copy_param(pbData, pdwDataLen, (CONST BYTE*)&dwTemp, sizeof(dwTemp));
-            
+            return copy_param(pbData, pdwDataLen, (const BYTE*)&dwTemp, sizeof(dwTemp));
+

         case PP_ENUMCONTAINERS:
             if ((dwFlags & CRYPT_FIRST) == CRYPT_FIRST) pKeyContainer->dwEnumContainersCtr = 0;
 
         case PP_ENUMCONTAINERS:
             if ((dwFlags & CRYPT_FIRST) == CRYPT_FIRST) pKeyContainer->dwEnumContainersCtr = 0;
 


@@ -3771,7 +3773,7 @@ BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
                 return TRUE;
             }
  
                 return TRUE;
             }
  

-            if (!open_container_key("", dwFlags, &hKey))
+            if (!open_container_key("", dwFlags, KEY_READ, &hKey))

             {
                 SetLastError(ERROR_NO_MORE_ITEMS);
                 return FALSE;
             {
                 SetLastError(ERROR_NO_MORE_ITEMS);
                 return FALSE;


@@ -3821,16 +3823,16 @@ BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
                 memcpy(provEnumalgs.szName, aProvEnumAlgsEx
                        [pKeyContainer->dwPersonality][pKeyContainer->dwEnumAlgsCtr].szName, 
                        20*sizeof(CHAR));
                 memcpy(provEnumalgs.szName, aProvEnumAlgsEx
                        [pKeyContainer->dwPersonality][pKeyContainer->dwEnumAlgsCtr].szName, 
                        20*sizeof(CHAR));

-            
-                return copy_param(pbData, pdwDataLen, (CONST BYTE*)&provEnumalgs, 
+
+                return copy_param(pbData, pdwDataLen, (const BYTE*)&provEnumalgs,

                                   sizeof(PROV_ENUMALGS));
             } else {
                 if (pbData && (*pdwDataLen >= sizeof(PROV_ENUMALGS_EX))) 
                     pKeyContainer->dwEnumAlgsCtr = ((dwFlags & CRYPT_FIRST) == CRYPT_FIRST) ? 
                         0 : pKeyContainer->dwEnumAlgsCtr+1;
                                   sizeof(PROV_ENUMALGS));
             } else {
                 if (pbData && (*pdwDataLen >= sizeof(PROV_ENUMALGS_EX))) 
                     pKeyContainer->dwEnumAlgsCtr = ((dwFlags & CRYPT_FIRST) == CRYPT_FIRST) ? 
                         0 : pKeyContainer->dwEnumAlgsCtr+1;

-            
+

                 return copy_param(pbData, pdwDataLen, 
                 return copy_param(pbData, pdwDataLen, 

-                                  (CONST BYTE*)&aProvEnumAlgsEx
+                                  (const BYTE*)&aProvEnumAlgsEx

                                       [pKeyContainer->dwPersonality][pKeyContainer->dwEnumAlgsCtr], 
                                   sizeof(PROV_ENUMALGS_EX));
             }
                                       [pKeyContainer->dwPersonality][pKeyContainer->dwEnumAlgsCtr], 
                                   sizeof(PROV_ENUMALGS_EX));
             }


@@ -3838,6 +3840,34 @@ BOOL WINAPI RSAENH_CPGetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData,
         case PP_CRYPT_COUNT_KEY_USE: /* Asked for by IE About dialog */
             return copy_param(pbData, pdwDataLen, abWTF, sizeof(abWTF));
 
         case PP_CRYPT_COUNT_KEY_USE: /* Asked for by IE About dialog */
             return copy_param(pbData, pdwDataLen, abWTF, sizeof(abWTF));
 

+        case PP_KEYSET_SEC_DESCR:
+        {
+            SECURITY_DESCRIPTOR *sd;
+            DWORD err, len, flags = (pKeyContainer->dwFlags & CRYPT_MACHINE_KEYSET);
+
+            if (!open_container_key(pKeyContainer->szName, flags, KEY_READ, &hKey))
+            {
+                SetLastError(NTE_BAD_KEYSET);
+                return FALSE;
+            }
+
+            err = GetSecurityInfo(hKey, SE_REGISTRY_KEY, dwFlags, NULL, NULL, NULL, NULL, (void **)&sd);
+            RegCloseKey(hKey);
+            if (err)
+            {
+                SetLastError(err);
+                return FALSE;
+            }
+
+            len = GetSecurityDescriptorLength(sd);
+            if (*pdwDataLen >= len) memcpy(pbData, sd, len);
+            else SetLastError(ERROR_INSUFFICIENT_BUFFER);
+            *pdwDataLen = len;
+
+            LocalFree(sd);
+            return TRUE;
+        }
+

         default:
             /* MSDN: Unknown parameter number in dwParam */
             SetLastError(NTE_BAD_TYPE);
         default:
             /* MSDN: Unknown parameter number in dwParam */
             SetLastError(NTE_BAD_TYPE);


@@ -4080,7 +4110,7 @@ BOOL WINAPI RSAENH_CPGetUserKey(HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *ph
  *  The actual hash value is queried with CPGetHashParam, which will finalize 
  *  the hash. Updating a finalized hash will fail with a last error NTE_BAD_HASH_STATE.
  */
  *  The actual hash value is queried with CPGetHashParam, which will finalize 
  *  the hash. Updating a finalized hash will fail with a last error NTE_BAD_HASH_STATE.
  */

-BOOL WINAPI RSAENH_CPHashData(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pbData, 
+BOOL WINAPI RSAENH_CPHashData(HCRYPTPROV hProv, HCRYPTHASH hHash, const BYTE *pbData,

                               DWORD dwDataLen, DWORD dwFlags)
 {
     CRYPTHASH *pCryptHash;
                               DWORD dwDataLen, DWORD dwFlags)
 {
     CRYPTHASH *pCryptHash;


@@ -4088,7 +4118,7 @@ BOOL WINAPI RSAENH_CPHashData(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pb
     TRACE("(hProv=%08lx, hHash=%08lx, pbData=%p, dwDataLen=%d, dwFlags=%08x)\n",
           hProv, hHash, pbData, dwDataLen, dwFlags);
 
     TRACE("(hProv=%08lx, hHash=%08lx, pbData=%p, dwDataLen=%d, dwFlags=%08x)\n",
           hProv, hHash, pbData, dwDataLen, dwFlags);
 

-    if (dwFlags)
+    if (dwFlags & ~CRYPT_USERDATA)

     {
         SetLastError(NTE_BAD_FLAGS);
         return FALSE;
     {
         SetLastError(NTE_BAD_FLAGS);
         return FALSE;


@@ -4313,8 +4343,56 @@ BOOL WINAPI RSAENH_CPSetHashParam(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwPa
  */
 BOOL WINAPI RSAENH_CPSetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
 {
  */
 BOOL WINAPI RSAENH_CPSetProvParam(HCRYPTPROV hProv, DWORD dwParam, BYTE *pbData, DWORD dwFlags)
 {

-    FIXME("(stub)\n");
-    return FALSE;
+    KEYCONTAINER *pKeyContainer;
+    HKEY hKey;
+
+    TRACE("(hProv=%08lx, dwParam=%08x, pbData=%p, dwFlags=%08x)\n", hProv, dwParam, pbData, dwFlags);
+
+    if (!lookup_handle(&handle_table, hProv, RSAENH_MAGIC_CONTAINER, (OBJECTHDR **)&pKeyContainer))
+    {
+        SetLastError(NTE_BAD_UID);
+        return FALSE;
+    }
+
+    switch (dwParam)
+    {
+    case PP_KEYSET_SEC_DESCR:
+    {
+        SECURITY_DESCRIPTOR *sd = (SECURITY_DESCRIPTOR *)pbData;
+        DWORD err, flags = (pKeyContainer->dwFlags & CRYPT_MACHINE_KEYSET);
+        BOOL def, present;
+        REGSAM access = WRITE_DAC | WRITE_OWNER | ACCESS_SYSTEM_SECURITY;
+        PSID owner = NULL, group = NULL;
+        PACL dacl = NULL, sacl = NULL;
+
+        if (!open_container_key(pKeyContainer->szName, flags, access, &hKey))
+        {
+            SetLastError(NTE_BAD_KEYSET);
+            return FALSE;
+        }
+
+        if ((dwFlags & OWNER_SECURITY_INFORMATION && !GetSecurityDescriptorOwner(sd, &owner, &def)) ||
+            (dwFlags & GROUP_SECURITY_INFORMATION && !GetSecurityDescriptorGroup(sd, &group, &def)) ||
+            (dwFlags & DACL_SECURITY_INFORMATION && !GetSecurityDescriptorDacl(sd, &present, &dacl, &def)) ||
+            (dwFlags & SACL_SECURITY_INFORMATION && !GetSecurityDescriptorSacl(sd, &present, &sacl, &def)))
+        {
+            RegCloseKey(hKey);
+            return FALSE;
+        }
+
+        err = SetSecurityInfo(hKey, SE_REGISTRY_KEY, dwFlags, owner, group, dacl, sacl);
+        RegCloseKey(hKey);
+        if (err)
+        {
+            SetLastError(err);
+            return FALSE;
+        }
+        return TRUE;
+    }
+    default:
+        FIXME("unimplemented parameter %08x\n", dwParam);
+        return FALSE;
+    }

 }
 
 /******************************************************************************
 }
 
 /******************************************************************************


@@ -4378,7 +4456,7 @@ BOOL WINAPI RSAENH_CPSignHash(HCRYPTPROV hProv, HCRYPTHASH hHash, DWORD dwKeySpe
     *pdwSigLen = pCryptKey->dwKeyLen;
 
     if (sDescription) {
     *pdwSigLen = pCryptKey->dwKeyLen;
 
     if (sDescription) {

-        if (!RSAENH_CPHashData(hProv, hHash, (CONST BYTE*)sDescription, 
+        if (!RSAENH_CPHashData(hProv, hHash, (const BYTE*)sDescription,

                                 (DWORD)lstrlenW(sDescription)*sizeof(WCHAR), 0))
         {
             goto out;
                                 (DWORD)lstrlenW(sDescription)*sizeof(WCHAR), 0))
         {
             goto out;


@@ -4420,7 +4498,7 @@ out:
  *  Success: TRUE  (Signature is valid)
  *  Failure: FALSE (GetLastError() == NTE_BAD_SIGNATURE, if signature is invalid)
  */
  *  Success: TRUE  (Signature is valid)
  *  Failure: FALSE (GetLastError() == NTE_BAD_SIGNATURE, if signature is invalid)
  */

-BOOL WINAPI RSAENH_CPVerifySignature(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST BYTE *pbSignature, 
+BOOL WINAPI RSAENH_CPVerifySignature(HCRYPTPROV hProv, HCRYPTHASH hHash, const BYTE *pbSignature,

                                      DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, 
                                      DWORD dwFlags)
 {
                                      DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, 
                                      DWORD dwFlags)
 {


@@ -4469,7 +4547,7 @@ BOOL WINAPI RSAENH_CPVerifySignature(HCRYPTPROV hProv, HCRYPTHASH hHash, CONST B
     }
 
     if (sDescription) {
     }
 
     if (sDescription) {

-        if (!RSAENH_CPHashData(hProv, hHash, (CONST BYTE*)sDescription, 
+        if (!RSAENH_CPHashData(hProv, hHash, (const BYTE*)sDescription,

                                 (DWORD)lstrlenW(sDescription)*sizeof(WCHAR), 0))
         {
             return FALSE;
                                 (DWORD)lstrlenW(sDescription)*sizeof(WCHAR), 0))
         {
             return FALSE;

diff --git a/reactos/media/doc/README.WINE b/reactos/media/doc/README.WINE
index fc459e9..e9b129c 100644 (file)
--- a/reactos/media/doc/README.WINE
+++ b/reactos/media/doc/README.WINE
@@ -167,7 +167,7 @@ reactos/dll/win32/riched20         # Synced to Wine-1.7.1
 reactos/dll/win32/riched32         # Synced to Wine-1.7.1
 reactos/dll/win32/rpcrt4           # Synced to Wine-1.7.1
 reactos/dll/win32/rsabase          # Synced to Wine-1.7.1
 reactos/dll/win32/riched32         # Synced to Wine-1.7.1
 reactos/dll/win32/rpcrt4           # Synced to Wine-1.7.1
 reactos/dll/win32/rsabase          # Synced to Wine-1.7.1

-reactos/dll/win32/rsaenh           # Synced to Wine-1.7.1
+reactos/dll/win32/rsaenh           # Synced to Wine-1.7.17

 reactos/dll/win32/sccbase          # Synced to Wine-1.7.1
 reactos/dll/win32/schannel         # Synced to Wine-1.7.1
 reactos/dll/win32/scrrun           # Synced to Wine-1.7.1
 reactos/dll/win32/sccbase          # Synced to Wine-1.7.1
 reactos/dll/win32/schannel         # Synced to Wine-1.7.1
 reactos/dll/win32/scrrun           # Synced to Wine-1.7.1