Coverage Report

Created: 2023-03-26 10:05

/src/libxslt/libexslt/crypto.c
Line
Count
Source (jump to first uncovered line)
1
#define IN_LIBEXSLT
2
#include "libexslt/libexslt.h"
3
4
#include <libxml/tree.h>
5
#include <libxml/xpath.h>
6
#include <libxml/xpathInternals.h>
7
#include <libxml/parser.h>
8
#include <libxml/encoding.h>
9
#include <libxml/uri.h>
10
11
#include <libxslt/xsltutils.h>
12
#include <libxslt/xsltInternals.h>
13
#include <libxslt/extensions.h>
14
15
#include "exslt.h"
16
17
#ifdef EXSLT_CRYPTO_ENABLED
18
19
#define HASH_DIGEST_LENGTH 32
20
#define MD5_DIGEST_LENGTH 16
21
#define SHA1_DIGEST_LENGTH 20
22
23
/* gcrypt rc4 can do 256 bit keys, but cryptoapi limit
24
   seems to be 128 for the default provider */
25
1.89k
#define RC4_KEY_LENGTH 128
26
27
/* The following routines have been declared static - this should be
28
   reviewed to consider whether we want to expose them to the API
29
   exsltCryptoBin2Hex
30
   exsltCryptoHex2Bin
31
   exsltCryptoGcryptInit
32
   exsltCryptoGcryptHash
33
   exsltCryptoGcryptRc4Encrypt
34
   exsltCryptoGcryptRC4Decrypt
35
*/
36
37
/**
38
 * exsltCryptoBin2Hex:
39
 * @bin: binary blob to convert
40
 * @binlen: length of binary blob
41
 * @hex: buffer to store hex version of blob
42
 * @hexlen: length of buffer to store hex version of blob
43
 *
44
 * Helper function which encodes a binary blob as hex.
45
 */
46
static void
47
exsltCryptoBin2Hex (const unsigned char *bin, int binlen,
48
338
        unsigned char *hex, int hexlen) {
49
338
    static const char bin2hex[] = { '0', '1', '2', '3',
50
338
  '4', '5', '6', '7',
51
338
  '8', '9', 'a', 'b',
52
338
  'c', 'd', 'e', 'f'
53
338
    };
54
55
338
    unsigned char lo, hi;
56
338
    int i, pos;
57
554k
    for (i = 0, pos = 0; (i < binlen && pos < hexlen); i++) {
58
554k
  lo = bin[i] & 0xf;
59
554k
  hi = bin[i] >> 4;
60
554k
  hex[pos++] = bin2hex[hi];
61
554k
  hex[pos++] = bin2hex[lo];
62
554k
    }
63
64
338
    hex[pos] = '\0';
65
338
}
66
67
/**
68
 * exsltCryptoHex2Bin:
69
 * @hex: hex version of blob to convert
70
 * @hexlen: length of hex buffer
71
 * @bin: destination binary buffer
72
 * @binlen: length of binary buffer
73
 *
74
 * Helper function which decodes a hex blob to binary
75
 */
76
static int
77
exsltCryptoHex2Bin (const unsigned char *hex, int hexlen,
78
205
        unsigned char *bin, int binlen) {
79
205
    int i = 0, j = 0;
80
205
    unsigned char lo, hi, result, tmp;
81
82
33.3k
    while (i < hexlen && j < binlen) {
83
33.1k
  hi = lo = 0;
84
85
33.1k
  tmp = hex[i++];
86
33.1k
  if (tmp >= '0' && tmp <= '9')
87
8.07k
      hi = tmp - '0';
88
25.0k
  else if (tmp >= 'a' && tmp <= 'f')
89
1.20k
      hi = 10 + (tmp - 'a');
90
91
33.1k
  tmp = hex[i++];
92
33.1k
  if (tmp >= '0' && tmp <= '9')
93
8.13k
      lo = tmp - '0';
94
25.0k
  else if (tmp >= 'a' && tmp <= 'f')
95
1.17k
      lo = 10 + (tmp - 'a');
96
97
33.1k
  result = hi << 4;
98
33.1k
  result += lo;
99
33.1k
  bin[j++] = result;
100
33.1k
    }
101
102
205
    return j;
103
205
}
104
105
#if defined(_WIN32)
106
107
#define HAVE_CRYPTO
108
#define PLATFORM_HASH exsltCryptoCryptoApiHash
109
#define PLATFORM_RC4_ENCRYPT exsltCryptoCryptoApiRc4Encrypt
110
#define PLATFORM_RC4_DECRYPT exsltCryptoCryptoApiRc4Decrypt
111
#define PLATFORM_MD4 CALG_MD4
112
#define PLATFORM_MD5 CALG_MD5
113
#define PLATFORM_SHA1 CALG_SHA1
114
115
#include <windows.h>
116
#include <wincrypt.h>
117
#ifdef _MSC_VER
118
#pragma comment(lib, "advapi32.lib")
119
#endif
120
121
static void
122
exsltCryptoCryptoApiReportError (xmlXPathParserContextPtr ctxt,
123
         int line) {
124
    char *lpMsgBuf;
125
    DWORD dw = GetLastError ();
126
127
    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
128
       FORMAT_MESSAGE_FROM_SYSTEM, NULL, dw,
129
       MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
130
       (LPSTR)&lpMsgBuf, 0, NULL);
131
132
    xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
133
      "exslt:crypto error (line %d). %s", line,
134
      lpMsgBuf);
135
    LocalFree (lpMsgBuf);
136
}
137
138
static HCRYPTHASH
139
exsltCryptoCryptoApiCreateHash (xmlXPathParserContextPtr ctxt,
140
        HCRYPTPROV hCryptProv, ALG_ID algorithm,
141
        const unsigned char *msg, unsigned int msglen,
142
        char *dest, unsigned int destlen)
143
{
144
    HCRYPTHASH hHash = 0;
145
    DWORD dwHashLen = destlen;
146
147
    if (!CryptCreateHash (hCryptProv, algorithm, 0, 0, &hHash)) {
148
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
149
  return 0;
150
    }
151
152
    if (!CryptHashData (hHash, msg, msglen, 0)) {
153
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
154
  goto fail;
155
    }
156
157
    if (!CryptGetHashParam (hHash, HP_HASHVAL, (BYTE *) dest, &dwHashLen, 0)) {
158
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
159
  goto fail;
160
    }
161
162
  fail:
163
    return hHash;
164
}
165
166
/**
167
 * exsltCryptoCryptoApiHash:
168
 * @ctxt: an XPath parser context
169
 * @algorithm: hashing algorithm to use
170
 * @msg: text to be hashed
171
 * @msglen: length of text to be hashed
172
 * @dest: buffer to place hash result
173
 *
174
 * Helper function which hashes a message using MD4, MD5, or SHA1.
175
 * Uses Win32 CryptoAPI.
176
 */
177
static void
178
exsltCryptoCryptoApiHash (xmlXPathParserContextPtr ctxt,
179
        ALG_ID algorithm, const char *msg,
180
        unsigned long msglen,
181
        char dest[HASH_DIGEST_LENGTH]) {
182
    HCRYPTPROV hCryptProv;
183
    HCRYPTHASH hHash;
184
185
    if (!CryptAcquireContext (&hCryptProv, NULL, NULL, PROV_RSA_FULL,
186
            CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
187
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
188
  return;
189
    }
190
191
    hHash = exsltCryptoCryptoApiCreateHash (ctxt, hCryptProv,
192
              algorithm, (unsigned char *) msg,
193
                                            msglen, dest, HASH_DIGEST_LENGTH);
194
    if (0 != hHash) {
195
  CryptDestroyHash (hHash);
196
    }
197
198
    CryptReleaseContext (hCryptProv, 0);
199
}
200
201
static void
202
exsltCryptoCryptoApiRc4Encrypt (xmlXPathParserContextPtr ctxt,
203
        const unsigned char *key,
204
        const unsigned char *msg, int msglen,
205
        unsigned char *dest, int destlen) {
206
    HCRYPTPROV hCryptProv;
207
    HCRYPTKEY hKey;
208
    HCRYPTHASH hHash;
209
    DWORD dwDataLen;
210
    char hash[HASH_DIGEST_LENGTH];
211
212
    if (msglen > destlen) {
213
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
214
          NULL,
215
          "exslt:crypto : internal error exsltCryptoCryptoApiRc4Encrypt dest buffer too small.\n");
216
  return;
217
    }
218
219
    if (!CryptAcquireContext (&hCryptProv, NULL, NULL, PROV_RSA_FULL,
220
            CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
221
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
222
  return;
223
    }
224
225
    hHash = exsltCryptoCryptoApiCreateHash (ctxt, hCryptProv,
226
              CALG_SHA1, key,
227
              RC4_KEY_LENGTH, hash,
228
              HASH_DIGEST_LENGTH);
229
230
    if (!CryptDeriveKey
231
  (hCryptProv, CALG_RC4, hHash, 0x00800000, &hKey)) {
232
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
233
  goto fail;
234
    }
235
/* Now encrypt data. */
236
    dwDataLen = msglen;
237
    memcpy (dest, msg, msglen);
238
    if (!CryptEncrypt (hKey, 0, TRUE, 0, dest, &dwDataLen, msglen)) {
239
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
240
  goto fail;
241
    }
242
243
  fail:
244
    if (0 != hHash) {
245
  CryptDestroyHash (hHash);
246
    }
247
248
    CryptDestroyKey (hKey);
249
    CryptReleaseContext (hCryptProv, 0);
250
}
251
252
static void
253
exsltCryptoCryptoApiRc4Decrypt (xmlXPathParserContextPtr ctxt,
254
        const unsigned char *key,
255
        const unsigned char *msg, int msglen,
256
        unsigned char *dest, int destlen) {
257
    HCRYPTPROV hCryptProv;
258
    HCRYPTKEY hKey;
259
    HCRYPTHASH hHash;
260
    DWORD dwDataLen;
261
    char hash[HASH_DIGEST_LENGTH];
262
263
    if (msglen > destlen) {
264
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
265
          NULL,
266
          "exslt:crypto : internal error exsltCryptoCryptoApiRc4Encrypt dest buffer too small.\n");
267
  return;
268
    }
269
270
    if (!CryptAcquireContext (&hCryptProv, NULL, NULL, PROV_RSA_FULL,
271
            CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
272
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
273
  return;
274
    }
275
276
    hHash = exsltCryptoCryptoApiCreateHash (ctxt, hCryptProv,
277
              CALG_SHA1, key,
278
              RC4_KEY_LENGTH, hash,
279
              HASH_DIGEST_LENGTH);
280
281
    if (!CryptDeriveKey
282
  (hCryptProv, CALG_RC4, hHash, 0x00800000, &hKey)) {
283
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
284
  goto fail;
285
    }
286
/* Now encrypt data. */
287
    dwDataLen = msglen;
288
    memcpy (dest, msg, msglen);
289
    if (!CryptDecrypt (hKey, 0, TRUE, 0, dest, &dwDataLen)) {
290
  exsltCryptoCryptoApiReportError (ctxt, __LINE__);
291
  goto fail;
292
    }
293
294
  fail:
295
    if (0 != hHash) {
296
  CryptDestroyHash (hHash);
297
    }
298
299
    CryptDestroyKey (hKey);
300
    CryptReleaseContext (hCryptProv, 0);
301
}
302
303
#endif /* defined(_WIN32) */
304
305
#if defined(HAVE_GCRYPT)
306
307
#define HAVE_CRYPTO
308
101
#define PLATFORM_HASH exsltCryptoGcryptHash
309
237
#define PLATFORM_RC4_ENCRYPT exsltCryptoGcryptRc4Encrypt
310
205
#define PLATFORM_RC4_DECRYPT exsltCryptoGcryptRc4Decrypt
311
40
#define PLATFORM_MD4 GCRY_MD_MD4
312
31
#define PLATFORM_MD5 GCRY_MD_MD5
313
30
#define PLATFORM_SHA1 GCRY_MD_SHA1
314
315
#ifdef HAVE_SYS_TYPES_H
316
# include <sys/types.h>
317
#endif
318
319
#ifdef HAVE_SYS_SELECT_H
320
#include <sys/select.h>   /* needed by gcrypt.h 4 Jul 04 */
321
#endif
322
#include <gcrypt.h>
323
324
static void
325
543
exsltCryptoGcryptInit (void) {
326
543
    static int gcrypt_init;
327
543
    xmlLockLibrary ();
328
329
543
    if (!gcrypt_init) {
330
/* The function `gcry_check_version' must be called before any other
331
   function in the library, because it initializes the thread support
332
   subsystem in Libgcrypt. To achieve this in all generality, it is
333
   necessary to synchronize the call to this function with all other calls
334
   to functions in the library, using the synchronization mechanisms
335
   available in your thread library. (from gcrypt.info)
336
*/
337
195
  gcry_check_version (GCRYPT_VERSION);
338
195
  gcrypt_init = 1;
339
195
    }
340
341
543
    xmlUnlockLibrary ();
342
543
}
343
344
/**
345
 * exsltCryptoGcryptHash:
346
 * @ctxt: an XPath parser context
347
 * @algorithm: hashing algorithm to use
348
 * @msg: text to be hashed
349
 * @msglen: length of text to be hashed
350
 * @dest: buffer to place hash result
351
 *
352
 * Helper function which hashes a message using MD4, MD5, or SHA1.
353
 * using gcrypt
354
 */
355
static void
356
exsltCryptoGcryptHash (xmlXPathParserContextPtr ctxt ATTRIBUTE_UNUSED,
357
/* changed the enum to int */
358
           int algorithm, const char *msg,
359
           unsigned long msglen,
360
101
           char dest[HASH_DIGEST_LENGTH]) {
361
101
    exsltCryptoGcryptInit ();
362
101
    gcry_md_hash_buffer (algorithm, dest, msg, msglen);
363
101
}
364
365
static void
366
exsltCryptoGcryptRc4Encrypt (xmlXPathParserContextPtr ctxt,
367
           const unsigned char *key,
368
           const unsigned char *msg, int msglen,
369
237
           unsigned char *dest, int destlen) {
370
237
    gcry_cipher_hd_t cipher;
371
237
    gcry_error_t rc = 0;
372
373
237
    exsltCryptoGcryptInit ();
374
375
237
    rc = gcry_cipher_open (&cipher, GCRY_CIPHER_ARCFOUR,
376
237
         GCRY_CIPHER_MODE_STREAM, 0);
377
237
    if (rc) {
378
0
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
379
0
          NULL,
380
0
          "exslt:crypto internal error %s (gcry_cipher_open)\n",
381
0
          gcry_strerror (rc));
382
0
    }
383
384
237
    rc = gcry_cipher_setkey (cipher, key, RC4_KEY_LENGTH);
385
237
    if (rc) {
386
0
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
387
0
          NULL,
388
0
          "exslt:crypto internal error %s (gcry_cipher_setkey)\n",
389
0
          gcry_strerror (rc));
390
0
    }
391
392
237
    rc = gcry_cipher_encrypt (cipher, (unsigned char *) dest, destlen,
393
237
            (const unsigned char *) msg, msglen);
394
237
    if (rc) {
395
0
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
396
0
          NULL,
397
0
          "exslt:crypto internal error %s (gcry_cipher_encrypt)\n",
398
0
          gcry_strerror (rc));
399
0
    }
400
401
237
    gcry_cipher_close (cipher);
402
237
}
403
404
static void
405
exsltCryptoGcryptRc4Decrypt (xmlXPathParserContextPtr ctxt,
406
           const unsigned char *key,
407
           const unsigned char *msg, int msglen,
408
205
           unsigned char *dest, int destlen) {
409
205
    gcry_cipher_hd_t cipher;
410
205
    gcry_error_t rc = 0;
411
412
205
    exsltCryptoGcryptInit ();
413
414
205
    rc = gcry_cipher_open (&cipher, GCRY_CIPHER_ARCFOUR,
415
205
         GCRY_CIPHER_MODE_STREAM, 0);
416
205
    if (rc) {
417
0
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
418
0
          NULL,
419
0
          "exslt:crypto internal error %s (gcry_cipher_open)\n",
420
0
          gcry_strerror (rc));
421
0
    }
422
423
205
    rc = gcry_cipher_setkey (cipher, key, RC4_KEY_LENGTH);
424
205
    if (rc) {
425
0
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
426
0
          NULL,
427
0
          "exslt:crypto internal error %s (gcry_cipher_setkey)\n",
428
0
          gcry_strerror (rc));
429
0
    }
430
431
205
    rc = gcry_cipher_decrypt (cipher, (unsigned char *) dest, destlen,
432
205
            (const unsigned char *) msg, msglen);
433
205
    if (rc) {
434
0
  xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL,
435
0
          NULL,
436
0
          "exslt:crypto internal error %s (gcry_cipher_decrypt)\n",
437
0
          gcry_strerror (rc));
438
0
    }
439
440
205
    gcry_cipher_close (cipher);
441
205
}
442
443
#endif /* defined(HAVE_GCRYPT) */
444
445
#if defined(HAVE_CRYPTO)
446
447
/**
448
 * exsltCryptoPopString:
449
 * @ctxt: an XPath parser context
450
 * @nargs: the number of arguments
451
 *
452
 * Helper function which checks for and returns first string argument and its
453
 * length in bytes.
454
 */
455
static int
456
exsltCryptoPopString (xmlXPathParserContextPtr ctxt, int nargs,
457
199
          xmlChar ** str) {
458
459
199
    int str_len = 0;
460
461
199
    if ((nargs < 1) || (nargs > 2)) {
462
53
  xmlXPathSetArityError (ctxt);
463
53
  return 0;
464
53
    }
465
466
146
    *str = xmlXPathPopString (ctxt);
467
146
    str_len = xmlStrlen (*str);
468
469
146
    if (str_len == 0) {
470
45
  xmlXPathReturnEmptyString (ctxt);
471
45
  xmlFree (*str);
472
45
  return 0;
473
45
    }
474
475
101
    return str_len;
476
146
}
477
478
/**
479
 * exsltCryptoMd4Function:
480
 * @ctxt: an XPath parser context
481
 * @nargs: the number of arguments
482
 *
483
 * computes the md4 hash of a string and returns as hex
484
 */
485
static void
486
86
exsltCryptoMd4Function (xmlXPathParserContextPtr ctxt, int nargs) {
487
488
86
    int str_len = 0;
489
86
    xmlChar *str = NULL, *ret = NULL;
490
86
    unsigned char hash[HASH_DIGEST_LENGTH];
491
86
    unsigned char hex[MD5_DIGEST_LENGTH * 2 + 1];
492
493
86
    str_len = exsltCryptoPopString (ctxt, nargs, &str);
494
86
    if (str_len == 0)
495
46
  return;
496
497
40
    PLATFORM_HASH (ctxt, PLATFORM_MD4, (const char *) str, str_len,
498
40
       (char *) hash);
499
40
    exsltCryptoBin2Hex (hash, sizeof (hash) - 1, hex, sizeof (hex) - 1);
500
501
40
    ret = xmlStrdup ((xmlChar *) hex);
502
40
    xmlXPathReturnString (ctxt, ret);
503
504
40
    if (str != NULL)
505
40
  xmlFree (str);
506
40
}
507
508
/**
509
 * exsltCryptoMd5Function:
510
 * @ctxt: an XPath parser context
511
 * @nargs: the number of arguments
512
 *
513
 * computes the md5 hash of a string and returns as hex
514
 */
515
static void
516
64
exsltCryptoMd5Function (xmlXPathParserContextPtr ctxt, int nargs) {
517
518
64
    int str_len = 0;
519
64
    xmlChar *str = NULL, *ret = NULL;
520
64
    unsigned char hash[HASH_DIGEST_LENGTH];
521
64
    unsigned char hex[MD5_DIGEST_LENGTH * 2 + 1];
522
523
64
    str_len = exsltCryptoPopString (ctxt, nargs, &str);
524
64
    if (str_len == 0)
525
33
  return;
526
527
31
    PLATFORM_HASH (ctxt, PLATFORM_MD5, (const char *) str, str_len,
528
31
       (char *) hash);
529
31
    exsltCryptoBin2Hex (hash, sizeof (hash) - 1, hex, sizeof (hex) - 1);
530
531
31
    ret = xmlStrdup ((xmlChar *) hex);
532
31
    xmlXPathReturnString (ctxt, ret);
533
534
31
    if (str != NULL)
535
31
  xmlFree (str);
536
31
}
537
538
/**
539
 * exsltCryptoSha1Function:
540
 * @ctxt: an XPath parser context
541
 * @nargs: the number of arguments
542
 *
543
 * computes the sha1 hash of a string and returns as hex
544
 */
545
static void
546
49
exsltCryptoSha1Function (xmlXPathParserContextPtr ctxt, int nargs) {
547
548
49
    int str_len = 0;
549
49
    xmlChar *str = NULL, *ret = NULL;
550
49
    unsigned char hash[HASH_DIGEST_LENGTH];
551
49
    unsigned char hex[SHA1_DIGEST_LENGTH * 2 + 1];
552
553
49
    str_len = exsltCryptoPopString (ctxt, nargs, &str);
554
49
    if (str_len == 0)
555
19
  return;
556
557
30
    PLATFORM_HASH (ctxt, PLATFORM_SHA1, (const char *) str, str_len,
558
30
       (char *) hash);
559
30
    exsltCryptoBin2Hex (hash, sizeof (hash) - 1, hex, sizeof (hex) - 1);
560
561
30
    ret = xmlStrdup ((xmlChar *) hex);
562
30
    xmlXPathReturnString (ctxt, ret);
563
564
30
    if (str != NULL)
565
30
  xmlFree (str);
566
30
}
567
568
/**
569
 * exsltCryptoRc4EncryptFunction:
570
 * @ctxt: an XPath parser context
571
 * @nargs: the number of arguments
572
 *
573
 * computes the sha1 hash of a string and returns as hex
574
 */
575
static void
576
302
exsltCryptoRc4EncryptFunction (xmlXPathParserContextPtr ctxt, int nargs) {
577
578
302
    int key_len = 0;
579
302
    int str_len = 0, bin_len = 0, hex_len = 0;
580
302
    xmlChar *key = NULL, *str = NULL, *padkey = NULL;
581
302
    xmlChar *bin = NULL, *hex = NULL;
582
302
    xsltTransformContextPtr tctxt = NULL;
583
584
302
    if (nargs != 2) {
585
18
  xmlXPathSetArityError (ctxt);
586
18
  return;
587
18
    }
588
284
    tctxt = xsltXPathGetTransformContext(ctxt);
589
590
284
    str = xmlXPathPopString (ctxt);
591
284
    str_len = xmlStrlen (str);
592
593
284
    if (str_len == 0) {
594
19
  xmlXPathReturnEmptyString (ctxt);
595
19
  xmlFree (str);
596
19
  return;
597
19
    }
598
599
265
    key = xmlXPathPopString (ctxt);
600
265
    key_len = xmlStrlen (key);
601
602
265
    if (key_len == 0) {
603
0
  xmlXPathReturnEmptyString (ctxt);
604
0
  xmlFree (key);
605
0
  xmlFree (str);
606
0
  return;
607
0
    }
608
609
265
    padkey = xmlMallocAtomic (RC4_KEY_LENGTH + 1);
610
265
    if (padkey == NULL) {
611
0
  xsltTransformError(tctxt, NULL, tctxt->inst,
612
0
      "exsltCryptoRc4EncryptFunction: Failed to allocate padkey\n");
613
0
  tctxt->state = XSLT_STATE_STOPPED;
614
0
  xmlXPathReturnEmptyString (ctxt);
615
0
  goto done;
616
0
    }
617
265
    memset(padkey, 0, RC4_KEY_LENGTH + 1);
618
619
265
    if ((key_len > RC4_KEY_LENGTH) || (key_len < 0)) {
620
28
  xsltTransformError(tctxt, NULL, tctxt->inst,
621
28
      "exsltCryptoRc4EncryptFunction: key size too long or key broken\n");
622
28
  tctxt->state = XSLT_STATE_STOPPED;
623
28
  xmlXPathReturnEmptyString (ctxt);
624
28
  goto done;
625
28
    }
626
237
    memcpy (padkey, key, key_len);
627
628
/* encrypt it */
629
237
    bin_len = str_len;
630
237
    bin = xmlStrdup (str);
631
237
    if (bin == NULL) {
632
0
  xsltTransformError(tctxt, NULL, tctxt->inst,
633
0
      "exsltCryptoRc4EncryptFunction: Failed to allocate string\n");
634
0
  tctxt->state = XSLT_STATE_STOPPED;
635
0
  xmlXPathReturnEmptyString (ctxt);
636
0
  goto done;
637
0
    }
638
237
    PLATFORM_RC4_ENCRYPT (ctxt, padkey, str, str_len, bin, bin_len);
639
640
/* encode it */
641
237
    hex_len = str_len * 2 + 1;
642
237
    hex = xmlMallocAtomic (hex_len);
643
237
    if (hex == NULL) {
644
0
  xsltTransformError(tctxt, NULL, tctxt->inst,
645
0
      "exsltCryptoRc4EncryptFunction: Failed to allocate result\n");
646
0
  tctxt->state = XSLT_STATE_STOPPED;
647
0
  xmlXPathReturnEmptyString (ctxt);
648
0
  goto done;
649
0
    }
650
651
237
    exsltCryptoBin2Hex (bin, str_len, hex, hex_len);
652
237
    xmlXPathReturnString (ctxt, hex);
653
654
265
done:
655
265
    if (key != NULL)
656
265
  xmlFree (key);
657
265
    if (str != NULL)
658
265
  xmlFree (str);
659
265
    if (padkey != NULL)
660
265
  xmlFree (padkey);
661
265
    if (bin != NULL)
662
237
  xmlFree (bin);
663
265
}
664
665
/**
666
 * exsltCryptoRc4DecryptFunction:
667
 * @ctxt: an XPath parser context
668
 * @nargs: the number of arguments
669
 *
670
 * computes the sha1 hash of a string and returns as hex
671
 */
672
static void
673
318
exsltCryptoRc4DecryptFunction (xmlXPathParserContextPtr ctxt, int nargs) {
674
675
318
    int key_len = 0;
676
318
    int str_len = 0, bin_len = 0, ret_len = 0;
677
318
    xmlChar *key = NULL, *str = NULL, *padkey = NULL, *bin =
678
318
  NULL, *ret = NULL;
679
318
    xsltTransformContextPtr tctxt = NULL;
680
681
318
    if (nargs != 2) {
682
66
  xmlXPathSetArityError (ctxt);
683
66
  return;
684
66
    }
685
252
    tctxt = xsltXPathGetTransformContext(ctxt);
686
687
252
    str = xmlXPathPopString (ctxt);
688
252
    str_len = xmlStrlen (str);
689
690
252
    if (str_len == 0) {
691
14
  xmlXPathReturnEmptyString (ctxt);
692
14
  xmlFree (str);
693
14
  return;
694
14
    }
695
696
238
    key = xmlXPathPopString (ctxt);
697
238
    key_len = xmlStrlen (key);
698
699
238
    if (key_len == 0) {
700
20
  xmlXPathReturnEmptyString (ctxt);
701
20
  xmlFree (key);
702
20
  xmlFree (str);
703
20
  return;
704
20
    }
705
706
218
    padkey = xmlMallocAtomic (RC4_KEY_LENGTH + 1);
707
218
    if (padkey == NULL) {
708
0
  xsltTransformError(tctxt, NULL, tctxt->inst,
709
0
      "exsltCryptoRc4EncryptFunction: Failed to allocate padkey\n");
710
0
  tctxt->state = XSLT_STATE_STOPPED;
711
0
  xmlXPathReturnEmptyString (ctxt);
712
0
  goto done;
713
0
    }
714
218
    memset(padkey, 0, RC4_KEY_LENGTH + 1);
715
218
    if ((key_len > RC4_KEY_LENGTH) || (key_len < 0)) {
716
13
  xsltTransformError(tctxt, NULL, tctxt->inst,
717
13
      "exsltCryptoRc4EncryptFunction: key size too long or key broken\n");
718
13
  tctxt->state = XSLT_STATE_STOPPED;
719
13
  xmlXPathReturnEmptyString (ctxt);
720
13
  goto done;
721
13
    }
722
205
    memcpy (padkey, key, key_len);
723
724
/* decode hex to binary */
725
205
    bin_len = str_len;
726
205
    bin = xmlMallocAtomic (bin_len);
727
205
    if (bin == NULL) {
728
0
  xsltTransformError(tctxt, NULL, tctxt->inst,
729
0
      "exsltCryptoRc4EncryptFunction: Failed to allocate string\n");
730
0
  tctxt->state = XSLT_STATE_STOPPED;
731
0
  xmlXPathReturnEmptyString (ctxt);
732
0
  goto done;
733
0
    }
734
205
    ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len);
735
736
/* decrypt the binary blob */
737
205
    ret = xmlMallocAtomic (ret_len + 1);
738
205
    if (ret == NULL) {
739
0
  xsltTransformError(tctxt, NULL, tctxt->inst,
740
0
      "exsltCryptoRc4EncryptFunction: Failed to allocate result\n");
741
0
  tctxt->state = XSLT_STATE_STOPPED;
742
0
  xmlXPathReturnEmptyString (ctxt);
743
0
  goto done;
744
0
    }
745
205
    PLATFORM_RC4_DECRYPT (ctxt, padkey, bin, ret_len, ret, ret_len);
746
205
    ret[ret_len] = 0;
747
748
205
    if (xmlCheckUTF8(ret) == 0) {
749
182
  xsltTransformError(tctxt, NULL, tctxt->inst,
750
182
      "exsltCryptoRc4DecryptFunction: Invalid UTF-8\n");
751
182
        xmlFree(ret);
752
182
  xmlXPathReturnEmptyString(ctxt);
753
182
    } else {
754
23
        xmlXPathReturnString(ctxt, ret);
755
23
    }
756
757
218
done:
758
218
    if (key != NULL)
759
218
  xmlFree (key);
760
218
    if (str != NULL)
761
218
  xmlFree (str);
762
218
    if (padkey != NULL)
763
218
  xmlFree (padkey);
764
218
    if (bin != NULL)
765
205
  xmlFree (bin);
766
218
}
767
768
/**
769
 * exsltCryptoRegister:
770
 *
771
 * Registers the EXSLT - Crypto module
772
 */
773
774
void
775
3.75k
exsltCryptoRegister (void) {
776
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "md4",
777
3.75k
           EXSLT_CRYPTO_NAMESPACE,
778
3.75k
           exsltCryptoMd4Function);
779
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "md5",
780
3.75k
           EXSLT_CRYPTO_NAMESPACE,
781
3.75k
           exsltCryptoMd5Function);
782
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "sha1",
783
3.75k
           EXSLT_CRYPTO_NAMESPACE,
784
3.75k
           exsltCryptoSha1Function);
785
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "rc4_encrypt",
786
3.75k
           EXSLT_CRYPTO_NAMESPACE,
787
3.75k
           exsltCryptoRc4EncryptFunction);
788
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "rc4_decrypt",
789
3.75k
           EXSLT_CRYPTO_NAMESPACE,
790
3.75k
           exsltCryptoRc4DecryptFunction);
791
3.75k
}
792
793
#else
794
/**
795
 * exsltCryptoRegister:
796
 *
797
 * Registers the EXSLT - Crypto module
798
 */
799
void
800
exsltCryptoRegister (void) {
801
}
802
803
#endif /* defined(HAVE_CRYPTO) */
804
805
#endif /* EXSLT_CRYPTO_ENABLED */