Upgrade to libxml 2.9.2 and libxslt 1.1.28

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>
 #include <libxml/xpath.h>
 #include <libxml/xpathInternals.h>
 #include <libxml/parser.h>
 #include <libxml/encoding.h>
 #include <libxml/uri.h>
 
 #include <libxslt/xsltconfig.h>
 #include <libxslt/xsltutils.h>
 #include <libxslt/xsltInternals.h>
 #include <libxslt/extensions.h>
 
 #include "exslt.h"
 
 #ifdef EXSLT_CRYPTO_ENABLED
 
 #define HASH_DIGEST_LENGTH 32
 #define MD5_DIGEST_LENGTH 16
 #define SHA1_DIGEST_LENGTH 20
 
-/* gcrypt rc4 can do 256 bit keys, but cryptoapi limit 
+/* gcrypt rc4 can do 256 bit keys, but cryptoapi limit
    seems to be 128 for the default provider */
 #define RC4_KEY_LENGTH 128
 
 /* The following routines have been declared static - this should be
    reviewed to consider whether we want to expose them to the API
    exsltCryptoBin2Hex
    exsltCryptoHex2Bin
    exsltCryptoGcryptInit
    exsltCryptoGcryptHash
    exsltCryptoGcryptRc4Encrypt
    exsltCryptoGcryptRC4Decrypt
 */
 
 /**
  * exsltCryptoBin2Hex:
  * @bin: binary blob to convert
  * @binlen: length of binary blob
  * @hex: buffer to store hex version of blob
  * @hexlen: length of buffer to store hex version of blob
  *
- * Helper function which encodes a binary blob as hex. 
+ * Helper function which encodes a binary blob as hex.
  */
 static void
 exsltCryptoBin2Hex (const unsigned char *bin, int binlen,
                     unsigned char *hex, int hexlen) {
     static const char bin2hex[] = { '0', '1', '2', '3',
         '4', '5', '6', '7',
         '8', '9', 'a', 'b',
         'c', 'd', 'e', 'f'
     };
 
@@ skipping 288 matching lines @@
 }
 
 /**
  * exsltCryptoGcryptHash:
  * @ctxt: an XPath parser context
  * @algorithm: hashing algorithm to use
  * @msg: text to be hashed
  * @msglen: length of text to be hashed
  * @dest: buffer to place hash result
  *
- * Helper function which hashes a message using MD4, MD5, or SHA1. 
+ * Helper function which hashes a message using MD4, MD5, or SHA1.
  * using gcrypt
  */
 static void
 exsltCryptoGcryptHash (xmlXPathParserContextPtr ctxt ATTRIBUTE_UNUSED,
 /* changed the enum to int */
                        int algorithm, const char *msg,
                        unsigned long msglen,
                        char dest[HASH_DIGEST_LENGTH]) {
     exsltCryptoGcryptInit ();
     gcry_md_hash_buffer (algorithm, dest, msg, msglen);
@@ skipping 79 matching lines @@
 
 #endif /* defined(HAVE_GCRYPT) */
 
 #if defined(HAVE_CRYPTO)
 
 /**
  * exsltCryptoPopString:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
- * Helper function which checks for and returns first string argument and its length
+ * Helper function which checks for and returns first string argument and its
+ * length in bytes.
  */
 static int
 exsltCryptoPopString (xmlXPathParserContextPtr ctxt, int nargs,
                       xmlChar ** str) {
 
     int str_len = 0;
 
     if ((nargs < 1) || (nargs > 2)) {
         xmlXPathSetArityError (ctxt);
         return 0;
     }
 
     *str = xmlXPathPopString (ctxt);
-    str_len = xmlUTF8Strlen (*str);
+    str_len = xmlStrlen (*str);
 
     if (str_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (*str);
         return 0;
     }
 
     return str_len;
 }
 
@@ skipping 99 matching lines @@
 /**
  * exsltCryptoRc4EncryptFunction:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
  * 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 key_len = 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 != 2) {
         xmlXPathSetArityError (ctxt);
         return;
     }
     tctxt = xsltXPathGetTransformContext(ctxt);
 
     str = xmlXPathPopString (ctxt);
-    str_len = xmlUTF8Strlen (str);
+    str_len = xmlStrlen (str);
 
     if (str_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (str);
         return;
     }
 
     key = xmlXPathPopString (ctxt);
-    key_len = xmlUTF8Strlen (key);
+    key_len = xmlStrlen (key);
 
     if (key_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (key);
         xmlFree (str);
         return;
     }
 
     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)) {
+    if ((key_len > RC4_KEY_LENGTH) || (key_len < 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);
+    memcpy (padkey, key, key_len);
 
 /* 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;
@@ skipping 28 matching lines @@
 /**
  * exsltCryptoRc4DecryptFunction:
  * @ctxt: an XPath parser context
  * @nargs: the number of arguments
  *
  * 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 key_len = 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 != 2) {
         xmlXPathSetArityError (ctxt);
         return;
     }
     tctxt = xsltXPathGetTransformContext(ctxt);
 
     str = xmlXPathPopString (ctxt);
-    str_len = xmlUTF8Strlen (str);
+    str_len = xmlStrlen (str);
 
     if (str_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (str);
         return;
     }
 
     key = xmlXPathPopString (ctxt);
-    key_len = xmlUTF8Strlen (key);
+    key_len = xmlStrlen (key);
 
     if (key_len == 0) {
         xmlXPathReturnEmptyString (ctxt);
         xmlFree (key);
         xmlFree (str);
         return;
     }
 
     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)) {
+    if ((key_len > RC4_KEY_LENGTH) || (key_len < 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);
+    memcpy (padkey, key, key_len);
 
 /* 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);
+    ret = xmlMallocAtomic (ret_len + 1);
     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);
+    ret[ret_len] = 0;
 
     xmlXPathReturnString (ctxt, ret);
 
 done:
     if (key != NULL)
         xmlFree (key);
     if (str != NULL)
         xmlFree (str);
     if (padkey != NULL)
         xmlFree (padkey);
@@ skipping 32 matching lines @@
  *
  * Registers the EXSLT - Crypto module
  */
 void
 exsltCryptoRegister (void) {
 }
 
 #endif /* defined(HAVE_CRYPTO) */
 
 #endif /* EXSLT_CRYPTO_ENABLED */