libxslt update

third_party/libxslt/libexslt/crypto.c

 #define IN_LIBEXSLT
 #include "libexslt/libexslt.h"
 
 #if defined(WIN32) && !defined (__CYGWIN__) && (!__MINGW32__)
 #include <win32config.h>
 #else
 #include "config.h"
 #endif
 
 #include <libxml/tree.h>
@@ skipping 122 matching lines @@
                    FORMAT_MESSAGE_FROM_SYSTEM, NULL, dw,
                    MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                    (LPTSTR) & lpMsgBuf, 0, NULL);
 
     xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
                         "exslt:crypto error (line %d). %s", line,
                         lpMsgBuf);
     LocalFree (lpMsgBuf);
 }
 
-HCRYPTHASH
+static HCRYPTHASH
 exsltCryptoCryptoApiCreateHash (xmlXPathParserContextPtr ctxt,
                                 HCRYPTPROV hCryptProv, ALG_ID algorithm,
                                 const char *msg, unsigned int msglen,
                                 char *dest, unsigned int destlen)
 {
     HCRYPTHASH hHash = 0;
     DWORD dwHashLen = destlen;
 
     if (!CryptCreateHash (hCryptProv, algorithm, 0, 0, &hHash)) {
         exsltCryptoCryptoApiReportError (ctxt, __LINE__);
@@ skipping 42 matching lines @@
     hHash = exsltCryptoCryptoApiCreateHash (ctxt, hCryptProv,
                                             algorithm, msg, msglen,
                                             dest, HASH_DIGEST_LENGTH);
     if (0 != hHash) {
         CryptDestroyHash (hHash);
     }
 
     CryptReleaseContext (hCryptProv, 0);
 }
 
-void
+static void
 exsltCryptoCryptoApiRc4Encrypt (xmlXPathParserContextPtr ctxt,
                                 const unsigned char *key,
                                 const unsigned char *msg, int msglen,
                                 unsigned char *dest, int destlen) {
     HCRYPTPROV hCryptProv;
     HCRYPTKEY hKey;
     HCRYPTHASH hHash;
     DWORD dwDataLen;
     unsigned char hash[HASH_DIGEST_LENGTH];
 
@@ skipping 30 matching lines @@
 
   fail:
     if (0 != hHash) {
         CryptDestroyHash (hHash);
     }
 
     CryptDestroyKey (hKey);
     CryptReleaseContext (hCryptProv, 0);
 }
 
-void
+static void
 exsltCryptoCryptoApiRc4Decrypt (xmlXPathParserContextPtr ctxt,
                                 const unsigned char *key,
                                 const unsigned char *msg, int msglen,
                                 unsigned char *dest, int destlen) {
     HCRYPTPROV hCryptProv;
     HCRYPTKEY hKey;
     HCRYPTHASH hHash;
     DWORD dwDataLen;
     unsigned char hash[HASH_DIGEST_LENGTH];
 
@@ skipping 42 matching lines @@
 #if defined(HAVE_GCRYPT)
 
 #define HAVE_CRYPTO
 #define PLATFORM_HASH   exsltCryptoGcryptHash
 #define PLATFORM_RC4_ENCRYPT exsltCryptoGcryptRc4Encrypt
 #define PLATFORM_RC4_DECRYPT exsltCryptoGcryptRc4Decrypt
 #define PLATFORM_MD4 GCRY_MD_MD4
 #define PLATFORM_MD5 GCRY_MD_MD5
 #define PLATFORM_SHA1 GCRY_MD_SHA1
 
-#ifdef HAVE_SYS_TYPES_H                                                        
-# include <sys/types.h>                                                        
-#endif                                                                         
-#ifdef HAVE_STDINT_H                                                           
-# include <stdint.h>                                                           
-#endif                                                                         
-  
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+
 #ifdef HAVE_SYS_SELECT_H
 #include <sys/select.h>         /* needed by gcrypt.h 4 Jul 04 */
 #endif
 #include <gcrypt.h>
 
 static void
 exsltCryptoGcryptInit (void) {
     static int gcrypt_init;
     xmlLockLibrary ();
 
@@ skipping 251 matching lines @@
  *
  * computes the sha1 hash of a string and returns as hex
  */
 static void
 exsltCryptoRc4EncryptFunction (xmlXPathParserContextPtr ctxt, int nargs) {
 
     int key_len = 0, key_size = 0;
     int str_len = 0, bin_len = 0, hex_len = 0;
     xmlChar *key = NULL, *str = NULL, *padkey = NULL;
     xmlChar *bin = NULL, *hex = NULL;
+    xsltTransformContextPtr tctxt = NULL;
 
-    if ((nargs < 1) || (nargs > 3)) {
+    if (nargs != 2) {
         xmlXPathSetArityError (ctxt);
         return;
     }
+    tctxt = xsltXPathGetTransformContext(ctxt);
 
     str = xmlXPathPopString (ctxt);
     str_len = xmlUTF8Strlen (str);
 
     if (str_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (str);
         return;
     }
 
     key = xmlXPathPopString (ctxt);
-    key_len = xmlUTF8Strlen (str);
+    key_len = xmlUTF8Strlen (key);
 
     if (key_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (key);
         xmlFree (str);
         return;
     }
 
-    padkey = xmlMallocAtomic (RC4_KEY_LENGTH);
+    padkey = xmlMallocAtomic (RC4_KEY_LENGTH + 1);
+    if (padkey == NULL) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: Failed to allocate padkey\n");
+        tctxt->state = XSLT_STATE_STOPPED;
+        xmlXPathReturnEmptyString (ctxt);
+        goto done;
+    }
+    memset(padkey, 0, RC4_KEY_LENGTH + 1);
+
     key_size = xmlUTF8Strsize (key, key_len);
+    if ((key_size > RC4_KEY_LENGTH) || (key_size < 0)) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: key size too long or key broken\n");
+        tctxt->state = XSLT_STATE_STOPPED;
+        xmlXPathReturnEmptyString (ctxt);
+        goto done;
+    }
     memcpy (padkey, key, key_size);
-    memset (padkey + key_size, '\0', sizeof (padkey));
 
 /* encrypt it */
     bin_len = str_len;
     bin = xmlStrdup (str);
     if (bin == NULL) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: Failed to allocate string\n");
+        tctxt->state = XSLT_STATE_STOPPED;
         xmlXPathReturnEmptyString (ctxt);
         goto done;
     }
     PLATFORM_RC4_ENCRYPT (ctxt, padkey, str, str_len, bin, bin_len);
 
 /* encode it */
     hex_len = str_len * 2 + 1;
     hex = xmlMallocAtomic (hex_len);
     if (hex == NULL) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: Failed to allocate result\n");
+        tctxt->state = XSLT_STATE_STOPPED;
         xmlXPathReturnEmptyString (ctxt);
         goto done;
     }
 
     exsltCryptoBin2Hex (bin, str_len, hex, hex_len);
     xmlXPathReturnString (ctxt, hex);
 
 done:
     if (key != NULL)
         xmlFree (key);
@@ skipping 12 matching lines @@
  *
  * computes the sha1 hash of a string and returns as hex
  */
 static void
 exsltCryptoRc4DecryptFunction (xmlXPathParserContextPtr ctxt, int nargs) {
 
     int key_len = 0, key_size = 0;
     int str_len = 0, bin_len = 0, ret_len = 0;
     xmlChar *key = NULL, *str = NULL, *padkey = NULL, *bin =
         NULL, *ret = NULL;
+    xsltTransformContextPtr tctxt = NULL;
 
-    if ((nargs < 1) || (nargs > 3)) {
+    if (nargs != 2) {
         xmlXPathSetArityError (ctxt);
         return;
     }
+    tctxt = xsltXPathGetTransformContext(ctxt);
 
     str = xmlXPathPopString (ctxt);
     str_len = xmlUTF8Strlen (str);
 
     if (str_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (str);
         return;
     }
 
     key = xmlXPathPopString (ctxt);
-    key_len = xmlUTF8Strlen (str);
+    key_len = xmlUTF8Strlen (key);
 
     if (key_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (key);
         xmlFree (str);
         return;
     }
 
-    padkey = xmlMallocAtomic (RC4_KEY_LENGTH);
+    padkey = xmlMallocAtomic (RC4_KEY_LENGTH + 1);
+    if (padkey == NULL) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: Failed to allocate padkey\n");
+        tctxt->state = XSLT_STATE_STOPPED;
+        xmlXPathReturnEmptyString (ctxt);
+        goto done;
+    }
+    memset(padkey, 0, RC4_KEY_LENGTH + 1);
     key_size = xmlUTF8Strsize (key, key_len);
+    if ((key_size > RC4_KEY_LENGTH) || (key_size < 0)) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: key size too long or key broken\n");
+        tctxt->state = XSLT_STATE_STOPPED;
+        xmlXPathReturnEmptyString (ctxt);
+        goto done;
+    }
     memcpy (padkey, key, key_size);
-    memset (padkey + key_size, '\0', sizeof (padkey));
 
 /* decode hex to binary */
     bin_len = str_len;
     bin = xmlMallocAtomic (bin_len);
+    if (bin == NULL) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: Failed to allocate string\n");
+        tctxt->state = XSLT_STATE_STOPPED;
+        xmlXPathReturnEmptyString (ctxt);
+        goto done;
+    }
     ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len);
 
 /* decrypt the binary blob */
     ret = xmlMallocAtomic (ret_len);
+    if (ret == NULL) {
+        xsltTransformError(tctxt, NULL, tctxt->inst,
+            "exsltCryptoRc4EncryptFunction: Failed to allocate result\n");
+        tctxt->state = XSLT_STATE_STOPPED;
+        xmlXPathReturnEmptyString (ctxt);
+        goto done;
+    }
     PLATFORM_RC4_DECRYPT (ctxt, padkey, bin, ret_len, ret, ret_len);
 
     xmlXPathReturnString (ctxt, ret);
 
+done:
     if (key != NULL)
         xmlFree (key);
     if (str != NULL)
         xmlFree (str);
     if (padkey != NULL)
         xmlFree (padkey);
     if (bin != NULL)
         xmlFree (bin);
 }
 
@@ skipping 16 matching lines @@
                                    exsltCryptoSha1Function);
     xsltRegisterExtModuleFunction ((const xmlChar *) "rc4_encrypt",
                                    EXSLT_CRYPTO_NAMESPACE,
                                    exsltCryptoRc4EncryptFunction);
     xsltRegisterExtModuleFunction ((const xmlChar *) "rc4_decrypt",
                                    EXSLT_CRYPTO_NAMESPACE,
                                    exsltCryptoRc4DecryptFunction);
 }
 
 #else
+/**
+ * exsltCryptoRegister:
+ *
+ * Registers the EXSLT - Crypto module
+ */
 void
 exsltCryptoRegister (void) {
 }
 
 #endif /* defined(HAVE_CRYPTO) */
 
 #endif /* EXSLT_CRYPTO_ENABLED */