开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
rsawrapr.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：26k
源码类别：

CA认证

开发平台：

WINDOWS

rsawrapr.c：源码内容
  1. /*
  2.  * PKCS#1 encoding and decoding functions.
  3.  * This file is believed to contain no code licensed from other parties.
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public
  6.  * License Version 1.1 (the "License"); you may not use this file
  7.  * except in compliance with the License. You may obtain a copy of
  8.  * the License at http://www.mozilla.org/MPL/
  9.  * 
  10.  * Software distributed under the License is distributed on an "AS
  11.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  12.  * implied. See the License for the specific language governing
  13.  * rights and limitations under the License.
  14.  * 
  15.  * The Original Code is the Netscape security libraries.
  16.  * 
  17.  * The Initial Developer of the Original Code is Netscape
  18.  * Communications Corporation.  Portions created by Netscape are 
  19.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  20.  * Rights Reserved.
  21.  * 
  22.  * Contributor(s):
  23.  * 
  24.  * Alternatively, the contents of this file may be used under the
  25.  * terms of the GNU General Public License Version 2 or later (the
  26.  * "GPL"), in which case the provisions of the GPL are applicable 
  27.  * instead of those above.  If you wish to allow use of your 
  28.  * version of this file only under the terms of the GPL and not to
  29.  * allow others to use your version of this file under the MPL,
  30.  * indicate your decision by deleting the provisions above and
  31.  * replace them with the notice and other provisions required by
  32.  * the GPL.  If you do not delete the provisions above, a recipient
  33.  * may use your version of this file under either the MPL or the
  34.  * GPL.
  35.  *
  36.  * $Id: rsawrapr.c,v 1.1 2000/03/31 19:29:42 relyea%netscape.com Exp $
  37.  */
  39. #include "blapi.h"
  40. #include "softoken.h"
  41. #include "sechash.h"
  43. #include "keylow.h"
  44. #include "secerr.h"
  46. #define RSA_BLOCK_MIN_PAD_LEN 8
  47. #define RSA_BLOCK_FIRST_OCTET 0x00
  48. #define RSA_BLOCK_PRIVATE0_PAD_OCTET 0x00
  49. #define RSA_BLOCK_PRIVATE_PAD_OCTET 0xff
  50. #define RSA_BLOCK_AFTER_PAD_OCTET 0x00
  52. #define OAEP_SALT_LEN 8
  53. #define OAEP_PAD_LEN 8
  54. #define OAEP_PAD_OCTET 0x00
  56. #define FLAT_BUFSIZE 512 /* bytes to hold flattened SHA1Context. */
  58. static SHA1Context *
  59. SHA1_CloneContext(SHA1Context *original)
  60. {
  61.     SHA1Context *  clone = NULL;
  62.     unsigned char *pBuf;
  63.     int            sha1ContextSize = SHA1_FlattenSize(original);
  64.     SECStatus      frv;
  65.     unsigned char  buf[FLAT_BUFSIZE];
  67.     PORT_Assert(sizeof buf >= sha1ContextSize);
  68.     if (sizeof buf >= sha1ContextSize) {
  69.      pBuf = buf;
  70.     } else {
  71.         pBuf = PORT_Alloc(sha1ContextSize);
  72. if (!pBuf)
  73.     goto done;
  74.     }
  76.     frv = SHA1_Flatten(original, pBuf);
  77.     if (frv == SECSuccess) {
  78. clone = SHA1_Resurrect(pBuf, NULL);
  79. memset(pBuf, 0, sha1ContextSize);
  80.     }
  81. done:
  82.     if (pBuf != buf)
  83.      PORT_Free(pBuf);
  84.     return clone;
  85. }
  87. /*
  88.  * Modify data by XORing it with a special hash of salt.
  89.  */
  90. static SECStatus
  91. oaep_xor_with_h1(unsigned char *data, unsigned int datalen,
  92.  unsigned char *salt, unsigned int saltlen)
  93. {
  94.     SHA1Context *sha1cx;
  95.     unsigned char *dp, *dataend;
  96.     unsigned char end_octet;
  98.     sha1cx = SHA1_NewContext();
  99.     if (sha1cx == NULL) {
  100. return SECFailure;
  101.     }
  103.     /*
  104.      * Get a hash of salt started; we will use it several times,
  105.      * adding in a different end octet (x00, x01, x02, ...).
  106.      */
  107.     SHA1_Begin (sha1cx);
  108.     SHA1_Update (sha1cx, salt, saltlen);
  109.     end_octet = 0;
  111.     dp = data;
  112.     dataend = data + datalen;
  114.     while (dp < dataend) {
  115. SHA1Context *sha1cx_h1;
  116. unsigned int sha1len, sha1off;
  117. unsigned char sha1[SHA1_LENGTH];
  119. /*
  120.  * Create hash of (salt || end_octet)
  121.  */
  122. sha1cx_h1 = SHA1_CloneContext (sha1cx);
  123. SHA1_Update (sha1cx_h1, &end_octet, 1);
  124. SHA1_End (sha1cx_h1, sha1, &sha1len, sizeof(sha1));
  125. SHA1_DestroyContext (sha1cx_h1, PR_TRUE);
  126. PORT_Assert (sha1len == SHA1_LENGTH);
  128. /*
  129.  * XOR that hash with the data.
  130.  * When we have fewer than SHA1_LENGTH octets of data
  131.  * left to xor, use just the low-order ones of the hash.
  132.  */
  133. sha1off = 0;
  134. if ((dataend - dp) < SHA1_LENGTH)
  135.     sha1off = SHA1_LENGTH - (dataend - dp);
  136. while (sha1off < SHA1_LENGTH)
  137.     *dp++ ^= sha1[sha1off++];
  139. /*
  140.  * Bump for next hash chunk.
  141.  */
  142. end_octet++;
  143.     }
  145.     return SECSuccess;
  146. }
  148. /*
  149.  * Modify salt by XORing it with a special hash of data.
  150.  */
  151. static SECStatus
  152. oaep_xor_with_h2(unsigned char *salt, unsigned int saltlen,
  153.  unsigned char *data, unsigned int datalen)
  154. {
  155.     unsigned char sha1[SHA1_LENGTH];
  156.     unsigned char *psalt, *psha1, *saltend;
  157.     SECStatus rv;
  159.     /*
  160.      * Create a hash of data.
  161.      */
  162.     rv = SHA1_HashBuf (sha1, data, datalen);
  163.     if (rv != SECSuccess) {
  164. return rv;
  165.     }
  167.     /*
  168.      * XOR the low-order octets of that hash with salt.
  169.      */
  170.     PORT_Assert (saltlen <= SHA1_LENGTH);
  171.     saltend = salt + saltlen;
  172.     psalt = salt;
  173.     psha1 = sha1 + SHA1_LENGTH - saltlen;
  174.     while (psalt < saltend) {
  175. *psalt++ ^= *psha1++;
  176.     }
  178.     return SECSuccess;
  179. }
  181. /*
  182.  * Format one block of data for public/private key encryption using
  183.  * the rules defined in PKCS #1.
  184.  */
  185. unsigned char *
  186. RSA_FormatOneBlock(unsigned modulusLen, RSA_BlockType blockType,
  187.    SECItem *data)
  188. {
  189.     unsigned char *block;
  190.     unsigned char *bp;
  191.     int padLen;
  192.     int i;
  194.     block = (unsigned char *) PORT_Alloc(modulusLen);
  195.     if (block == NULL)
  196. return NULL;
  198.     bp = block;
  200.     /*
  201.      * All RSA blocks start with two octets:
  202.      * 0x00 || BlockType
  203.      */
  204.     *bp++ = RSA_BLOCK_FIRST_OCTET;
  205.     *bp++ = (unsigned char) blockType;
  207.     switch (blockType) {
  209.       /*
  210.        * Blocks intended for private-key operation.
  211.        */
  212.       case RSA_BlockPrivate0: /* essentially unused */
  213.       case RSA_BlockPrivate:  /* preferred method */
  214. /*
  215.  * 0x00 || BT || Pad || 0x00 || ActualData
  216.  *   1      1   padLen    1      data->len
  217.  * Pad is either all 0x00 or all 0xff bytes, depending on blockType.
  218.  */
  219. padLen = modulusLen - data->len - 3;
  220. PORT_Assert (padLen >= RSA_BLOCK_MIN_PAD_LEN);
  221. PORT_Memset (bp,
  222.    blockType == RSA_BlockPrivate0
  223. ? RSA_BLOCK_PRIVATE0_PAD_OCTET
  224. : RSA_BLOCK_PRIVATE_PAD_OCTET,
  225.    padLen);
  226. bp += padLen;
  227. *bp++ = RSA_BLOCK_AFTER_PAD_OCTET;
  228. PORT_Memcpy (bp, data->data, data->len);
  229. break;
  231.       /*
  232.        * Blocks intended for public-key operation.
  233.        */
  234.       case RSA_BlockPublic:
  236. /*
  237.  * 0x00 || BT || Pad || 0x00 || ActualData
  238.  *   1      1   padLen    1      data->len
  239.  * Pad is all non-zero random bytes.
  240.  */
  241. padLen = modulusLen - data->len - 3;
  242. PORT_Assert (padLen >= RSA_BLOCK_MIN_PAD_LEN);
  243. for (i = 0; i < padLen; i++) {
  244.     /* Pad with non-zero random data. */
  245.     do {
  246. RNG_GenerateGlobalRandomBytes(bp + i, 1);
  247.     } while (bp[i] == RSA_BLOCK_AFTER_PAD_OCTET);
  248. }
  249. bp += padLen;
  250. *bp++ = RSA_BLOCK_AFTER_PAD_OCTET;
  251. PORT_Memcpy (bp, data->data, data->len);
  253. break;
  255.       /*
  256.        * Blocks intended for public-key operation, using
  257.        * Optimal Asymmetric Encryption Padding (OAEP).
  258.        */
  259.       case RSA_BlockOAEP:
  260. /*
  261.  * 0x00 || BT || Modified2(Salt) || Modified1(PaddedData)
  262.  *   1      1     OAEP_SALT_LEN     OAEP_PAD_LEN + data->len [+ N]
  263.  *
  264.  * where:
  265.  *   PaddedData is "Pad1 || ActualData [|| Pad2]"
  266.  *   Salt is random data.
  267.  *   Pad1 is all zeros.
  268.  *   Pad2, if present, is random data.
  269.  *   (The "modified" fields are all the same length as the original
  270.  * unmodified values; they are just xor'd with other values.)
  271.  *
  272.  *   Modified1 is an XOR of PaddedData with a special octet
  273.  * string constructed of iterated hashing of Salt (see below).
  274.  *   Modified2 is an XOR of Salt with the low-order octets of
  275.  * the hash of Modified1 (see farther below ;-).
  276.  *
  277.  * Whew!
  278.  */
  281. /*
  282.  * Salt
  283.  */
  284. RNG_GenerateGlobalRandomBytes(bp, OAEP_SALT_LEN);
  285. bp += OAEP_SALT_LEN;
  287. /*
  288.  * Pad1
  289.  */
  290. PORT_Memset (bp, OAEP_PAD_OCTET, OAEP_PAD_LEN);
  291. bp += OAEP_PAD_LEN;
  293. /*
  294.  * Data
  295.  */
  296. PORT_Memcpy (bp, data->data, data->len);
  297. bp += data->len;
  299. /*
  300.  * Pad2
  301.  */
  302. if (bp < (block + modulusLen))
  303.     RNG_GenerateGlobalRandomBytes(bp, block - bp + modulusLen);
  305. /*
  306.  * Now we have the following:
  307.  * 0x00 || BT || Salt || PaddedData
  308.  * (From this point on, "Pad1 || Data [|| Pad2]" is treated
  309.  * as the one entity PaddedData.)
  310.  *
  311.  * We need to turn PaddedData into Modified1.
  312.  */
  313. if (oaep_xor_with_h1(block + 2 + OAEP_SALT_LEN,
  314.      modulusLen - 2 - OAEP_SALT_LEN,
  315.      block + 2, OAEP_SALT_LEN) != SECSuccess) {
  316.     PORT_Free (block);
  317.     return NULL;
  318. }
  320. /*
  321.  * Now we have:
  322.  * 0x00 || BT || Salt || Modified1(PaddedData)
  323.  *
  324.  * The remaining task is to turn Salt into Modified2.
  325.  */
  326. if (oaep_xor_with_h2(block + 2, OAEP_SALT_LEN,
  327.      block + 2 + OAEP_SALT_LEN,
  328.      modulusLen - 2 - OAEP_SALT_LEN) != SECSuccess) {
  329.     PORT_Free (block);
  330.     return NULL;
  331. }
  333. break;
  335.       default:
  336. PORT_Assert (0);
  337. PORT_Free (block);
  338. return NULL;
  339.     }
  341.     return block;
  342. }
  344. SECStatus
  345. RSA_FormatBlock(SECItem *result, unsigned modulusLen,
  346. RSA_BlockType blockType, SECItem *data)
  347. {
  348.     /*
  349.      * XXX For now assume that the data length fits in a single
  350.      * XXX encryption block; the ASSERTs below force this.
  351.      * XXX To fix it, each case will have to loop over chunks whose
  352.      * XXX lengths satisfy the assertions, until all data is handled.
  353.      * XXX (Unless RSA has more to say about how to handle data
  354.      * XXX which does not fit in a single encryption block?)
  355.      * XXX And I do not know what the result is supposed to be,
  356.      * XXX so the interface to this function may need to change
  357.      * XXX to allow for returning multiple blocks, if they are
  358.      * XXX not wanted simply concatenated one after the other.
  359.      */
  361.     switch (blockType) {
  362.       case RSA_BlockPrivate0:
  363.       case RSA_BlockPrivate:
  364.       case RSA_BlockPublic:
  365. /*
  366.  * 0x00 || BT || Pad || 0x00 || ActualData
  367.  *
  368.  * The "3" below is the first octet + the second octet + the 0x00
  369.  * octet that always comes just before the ActualData.
  370.  */
  371. PORT_Assert (data->len <= (modulusLen - (3 + RSA_BLOCK_MIN_PAD_LEN)));
  373. result->data = RSA_FormatOneBlock(modulusLen, blockType, data);
  374. if (result->data == NULL) {
  375.     result->len = 0;
  376.     return SECFailure;
  377. }
  378. result->len = modulusLen;
  380. break;
  382.       case RSA_BlockOAEP:
  383. /*
  384.  * 0x00 || BT || M1(Salt) || M2(Pad1||ActualData[||Pad2])
  385.  *
  386.  * The "2" below is the first octet + the second octet.
  387.  * (The other fields do not contain the clear values, but are
  388.  * the same length as the clear values.)
  389.  */
  390. PORT_Assert (data->len <= (modulusLen - (2 + OAEP_SALT_LEN
  391.  + OAEP_PAD_LEN)));
  393. result->data = RSA_FormatOneBlock(modulusLen, blockType, data);
  394. if (result->data == NULL) {
  395.     result->len = 0;
  396.     return SECFailure;
  397. }
  398. result->len = modulusLen;
  400. break;
  402.       case RSA_BlockRaw:
  403. /*
  404.  * Pad || ActualData
  405.  * Pad is zeros. The application is responsible for recovering
  406.  * the actual data.
  407.  */
  408. result->data = (unsigned char*)PORT_ZAlloc(modulusLen);
  409. result->len = modulusLen;
  410. PORT_Memcpy(result->data+(modulusLen-data->len),data->data,data->len);
  411. break;
  413.       default:
  414. PORT_Assert (0);
  415. result->data = NULL;
  416. result->len = 0;
  417. return SECFailure;
  418.     }
  420.     return SECSuccess;
  421. }
  423. /*
  424.  * Takes a formatted block and returns the data part.
  425.  * (This is the inverse of RSA_FormatOneBlock().)
  426.  * In some formats the start of the data is ambiguous;
  427.  * if it is non-zero, expectedLen will disambiguate.
  428.  *
  429.  * NOTE: this routine is not yet used/tested! (XXX please
  430.  * remove this comment once that is no longer the case ;-)
  431.  */
  432. unsigned char *
  433. RSA_DecodeOneBlock(unsigned char *data,
  434.    unsigned int modulusLen,
  435.    unsigned int expectedLen,
  436.    RSA_BlockType *pResultType,
  437.    unsigned int *pResultLen)
  438. {
  439.     RSA_BlockType blockType;
  440.     unsigned char *dp, *res;
  441.     unsigned int i, len, padLen;
  443.     dp = data;
  444.     if (*dp++ != RSA_BLOCK_FIRST_OCTET) {
  445. PORT_SetError (SEC_ERROR_BAD_DATA);
  446. return NULL;
  447.     }
  449.     blockType = (RSA_BlockType)*dp++;
  450.     switch (blockType) {
  451.       case RSA_BlockPrivate0:
  452. if (expectedLen) {
  453.     padLen = modulusLen - expectedLen - 3;
  454.     PORT_Assert (padLen >= RSA_BLOCK_MIN_PAD_LEN);
  455.     for (i = 0; i < padLen; i++) {
  456. if (*dp++ != RSA_BLOCK_PRIVATE0_PAD_OCTET)
  457.     break;
  458.     }
  459.     if ((i != padLen) || (*dp != RSA_BLOCK_AFTER_PAD_OCTET)) {
  460. PORT_SetError (SEC_ERROR_BAD_DATA);
  461. return NULL;
  462.     }
  463.     dp++;
  464.     len = expectedLen;
  465. } else {
  466.     for (i = 0; i < modulusLen; i++) {
  467. if (*dp++ != RSA_BLOCK_PRIVATE0_PAD_OCTET)
  468.     break;
  469.     }
  470.     if (i == modulusLen) {
  471. PORT_SetError (SEC_ERROR_BAD_DATA);
  472. return NULL;
  473.     }
  474.     if (RSA_BLOCK_PRIVATE0_PAD_OCTET == RSA_BLOCK_AFTER_PAD_OCTET)
  475. dp--;
  476.     padLen = dp - data - 2;
  477.     if ((padLen < RSA_BLOCK_MIN_PAD_LEN)
  478. || (*dp != RSA_BLOCK_AFTER_PAD_OCTET)) {
  479. PORT_SetError (SEC_ERROR_BAD_DATA);
  480. return NULL;
  481.     }
  482.     dp++;
  483.     len = modulusLen - (dp - data);
  484. }
  485. res = (unsigned char *) PORT_Alloc(len);
  486. if (res == NULL) {
  487.     return NULL;
  488. }
  489. PORT_Memcpy (res, dp, len);
  490. break;
  492.       case RSA_BlockPrivate:
  493. for (i = 0; i < modulusLen; i++) {
  494.     if (*dp++ != RSA_BLOCK_PRIVATE_PAD_OCTET)
  495. break;
  496. }
  497. if ((i == modulusLen) || (*dp != RSA_BLOCK_AFTER_PAD_OCTET)) {
  498.     PORT_SetError (SEC_ERROR_BAD_DATA);
  499.     return NULL;
  500. }
  501. padLen = dp - data - 2;
  502. dp++;
  503. len = modulusLen - (dp - data);
  504. if ((padLen < RSA_BLOCK_MIN_PAD_LEN) || (expectedLen
  505.  && (expectedLen != len))) {
  506.     PORT_SetError (SEC_ERROR_BAD_DATA);
  507.     return NULL;
  508. }
  509. res = (unsigned char *) PORT_Alloc(len);
  510. if (res == NULL) {
  511.     return NULL;
  512. }
  513. PORT_Memcpy (res, dp, len);
  514. break;
  516.       case RSA_BlockPublic:
  517. for (i = 0; i < modulusLen; i++) {
  518.     if (*dp++ == RSA_BLOCK_AFTER_PAD_OCTET)
  519. break;
  520. }
  521. if (i == modulusLen) {
  522.     PORT_SetError (SEC_ERROR_BAD_DATA);
  523.     return NULL;
  524. }
  525. padLen = dp - data - 2;
  526. dp++;
  527. len = modulusLen - (dp - data);
  528. if ((padLen < RSA_BLOCK_MIN_PAD_LEN) || (expectedLen
  529.  && (expectedLen != len))) {
  530.     PORT_SetError (SEC_ERROR_BAD_DATA);
  531.     return NULL;
  532. }
  533. res = (unsigned char *) PORT_Alloc(len);
  534. if (res == NULL) {
  535.     return NULL;
  536. }
  537. PORT_Memcpy (res, dp, len);
  538. break;
  540.       case RSA_BlockOAEP:
  541. {
  542.     unsigned char *salt, *tmp_res;
  543.     SECStatus rv;
  545.     len = modulusLen - 2 - OAEP_SALT_LEN;
  546.     /*
  547.      * dp points to:
  548.      * Modified2(Salt) || Modified1(PaddedData)
  549.      * To recover Salt we need to XOR it with the low-order hash
  550.      * of Modified1.
  551.      */
  552.     salt = (unsigned char *) PORT_Alloc(OAEP_SALT_LEN);
  553.     if (salt == NULL) {
  554. return NULL;
  555.     }
  556.     PORT_Memcpy (salt, dp, OAEP_SALT_LEN);
  557.     dp += OAEP_SALT_LEN;
  558.     rv = oaep_xor_with_h2 (salt, OAEP_SALT_LEN, dp, len);
  559.     if (rv != SECSuccess) {
  560. PORT_Free (salt);
  561. return NULL;
  562.     }
  563.     if (expectedLen) {
  564. PORT_Assert (expectedLen <= len);
  565. len = expectedLen;
  566.     }
  567.     tmp_res = (unsigned char *) PORT_Alloc(len);
  568.     if (tmp_res == NULL) {
  569. PORT_Free (salt);
  570. return NULL;
  571.     }
  572.     PORT_Memcpy (tmp_res, dp, len);
  573.     rv = oaep_xor_with_h1 (tmp_res, len, salt, OAEP_SALT_LEN);
  574.     PORT_Free (salt);
  575.     if (rv != SECSuccess) {
  576. return NULL;
  577.     }
  578.     for (i = 0; i < OAEP_PAD_LEN; i++) {
  579. if (tmp_res[i] != OAEP_PAD_OCTET) {
  580.     PORT_SetError (SEC_ERROR_BAD_DATA);
  581.     PORT_Free (tmp_res);
  582.     return NULL;
  583. }
  584.     }
  585.     len -= OAEP_PAD_LEN;
  586.     res = (unsigned char *) PORT_Alloc(len);
  587.     if (res == NULL) {
  588. PORT_Free (tmp_res);
  589. return NULL;
  590.     }
  591.     PORT_Memcpy (res, tmp_res + OAEP_PAD_LEN, len);
  592.     PORT_Free (tmp_res);
  593. }
  594. break;
  596.       default:
  597. PORT_SetError (SEC_ERROR_BAD_DATA);
  598. return NULL;
  599.     }
  601.     PORT_Assert (res != NULL);
  602.     *pResultLen = len;
  603.     *pResultType = blockType;
  604.     return res;
  605. }
  607. /* XXX Doesn't set error code */
  608. SECStatus
  609. RSA_Sign(SECKEYLowPrivateKey *key, 
  610.          unsigned char *      output, 
  611.  unsigned int *       output_len,
  612.          unsigned int         maxOutputLen, 
  613.  unsigned char *      input, 
  614.  unsigned int         input_len)
  615. {
  616.     SECStatus     rv          = SECSuccess;
  617.     unsigned int  modulus_len = SECKEY_LowPrivateModulusLen(key);
  618.     SECItem       formatted;
  619.     SECItem       unformatted;
  621.     if (maxOutputLen < modulus_len) 
  622.      return SECFailure;
  623.     PORT_Assert(key->keyType == rsaKey);
  624.     if (key->keyType != rsaKey)
  625.      return SECFailure;
  627.     unformatted.len  = input_len;
  628.     unformatted.data = input;
  629.     formatted.data   = NULL;
  630.     rv = RSA_FormatBlock(&formatted, modulus_len, RSA_BlockPrivate,
  631.  &unformatted);
  632.     if (rv != SECSuccess) 
  633.      goto done;
  635.     rv = RSA_PrivateKeyOp(&key->u.rsa, output, formatted.data);
  636.     *output_len = modulus_len;
  638.     goto done;
  640. done:
  641.     if (formatted.data != NULL) 
  642.      PORT_ZFree(formatted.data, modulus_len);
  643.     return rv;
  644. }
  646. /* XXX Doesn't set error code */
  647. SECStatus
  648. RSA_CheckSign(SECKEYLowPublicKey *key,
  649.               unsigned char *     sign, 
  650.       unsigned int        sign_len, 
  651.       unsigned char *     hash, 
  652.       unsigned int        hash_len)
  653. {
  654.     SECStatus       rv;
  655.     unsigned int    modulus_len = SECKEY_LowPublicModulusLen(key);
  656.     unsigned int    i;
  657.     unsigned char * buffer;
  659.     modulus_len = SECKEY_LowPublicModulusLen(key);
  660.     if (sign_len != modulus_len) 
  661.      goto failure;
  662.     if (hash_len > modulus_len - 8) 
  663.      goto failure;
  664.     PORT_Assert(key->keyType == rsaKey);
  665.     if (key->keyType != rsaKey)
  666.      goto failure;
  668.     buffer = (unsigned char *)PORT_Alloc(modulus_len + 1);
  669.     if (!buffer)
  670.      goto failure;
  672.     rv = RSA_PublicKeyOp(&key->u.rsa, buffer, sign);
  673.     if (rv != SECSuccess)
  674. goto loser;
  676.     /*
  677.      * check the padding that was used
  678.      */
  679.     if (buffer[0] != 0 || buffer[1] != 1) 
  680.      goto loser;
  681.     for (i = 2; i < modulus_len - hash_len - 1; i++) {
  682. if (buffer[i] == 0) 
  683.     break;
  684. if (buffer[i] != 0xff) 
  685.     goto loser;
  686.     }
  688.     /*
  689.      * make sure we get the same results
  690.      */
  691.     if (PORT_Memcmp(buffer + modulus_len - hash_len, hash, hash_len) != 0)
  692. goto loser;
  694.     PORT_Free(buffer);
  695.     return SECSuccess;
  697. loser:
  698.     PORT_Free(buffer);
  699. failure:
  700.     return SECFailure;
  701. }
  703. /* XXX Doesn't set error code */
  704. SECStatus
  705. RSA_CheckSignRecover(SECKEYLowPublicKey *key,
  706.                      unsigned char *     data,
  707.                      unsigned int *      data_len, 
  708.      unsigned int        max_output_len, 
  709.      unsigned char *     sign,
  710.      unsigned int        sign_len)
  711. {
  712.     SECStatus       rv;
  713.     unsigned int    modulus_len = SECKEY_LowPublicModulusLen(key);
  714.     unsigned int    i;
  715.     unsigned char * buffer;
  717.     if (sign_len != modulus_len) 
  718.      goto failure;
  719.     PORT_Assert(key->keyType == rsaKey);
  720.     if (key->keyType != rsaKey)
  721.      goto failure;
  723.     buffer = (unsigned char *)PORT_Alloc(modulus_len + 1);
  724.     if (!buffer)
  725.      goto failure;
  727.     rv = RSA_PublicKeyOp(&key->u.rsa, buffer, sign);
  728.     if (rv != SECSuccess)
  729.      goto loser;
  730.     *data_len = 0;
  732.     /*
  733.      * check the padding that was used
  734.      */
  735.     if (buffer[0] != 0 || buffer[1] != 1) 
  736.      goto loser;
  737.     for (i = 2; i < modulus_len; i++) {
  738. if (buffer[i] == 0) {
  739.     *data_len = modulus_len - i - 1;
  740.     break;
  741. }
  742. if (buffer[i] != 0xff) 
  743.     goto loser;
  744.     }
  745.     if (*data_len == 0) 
  746.      goto loser;
  747.     if (*data_len > max_output_len) 
  748.      goto loser;
  750.     /*
  751.      * make sure we get the same results
  752.      */
  753.     PORT_Memcpy(data,buffer + modulus_len - *data_len, *data_len);
  755.     PORT_Free(buffer);
  756.     return SECSuccess;
  758. loser:
  759.     PORT_Free(buffer);
  760. failure:
  761.     return SECFailure;
  762. }
  764. /* XXX Doesn't set error code */
  765. SECStatus
  766. RSA_EncryptBlock(SECKEYLowPublicKey *key, 
  767.                  unsigned char *     output, 
  768.  unsigned int *      output_len,
  769.                  unsigned int        max_output_len, 
  770.  unsigned char *     input, 
  771.  unsigned int        input_len)
  772. {
  773.     SECStatus     rv;
  774.     unsigned int  modulus_len = SECKEY_LowPublicModulusLen(key);
  775.     SECItem       formatted;
  776.     SECItem       unformatted;
  778.     formatted.data = NULL;
  779.     if (max_output_len < modulus_len) 
  780.      goto failure;
  781.     PORT_Assert(key->keyType == rsaKey);
  782.     if (key->keyType != rsaKey)
  783.      goto failure;
  785.     unformatted.len  = input_len;
  786.     unformatted.data = input;
  787.     formatted.data   = NULL;
  788.     rv = RSA_FormatBlock(&formatted, modulus_len, RSA_BlockPublic,
  789.  &unformatted);
  790.     if (rv != SECSuccess) 
  791. goto failure;
  793.     rv = RSA_PublicKeyOp(&key->u.rsa, output, formatted.data);
  794.     if (rv != SECSuccess) 
  795.      goto failure;
  797.     PORT_ZFree(formatted.data, modulus_len);
  798.     *output_len = modulus_len;
  799.     return SECSuccess;
  801. failure:
  802.     if (formatted.data != NULL) 
  803. PORT_ZFree(formatted.data, modulus_len);
  804.     return SECFailure;
  805. }
  807. /* XXX Doesn't set error code */
  808. SECStatus
  809. RSA_DecryptBlock(SECKEYLowPrivateKey *key, 
  810.                  unsigned char *      output, 
  811.  unsigned int *       output_len,
  812.                  unsigned int         max_output_len, 
  813.  unsigned char *      input, 
  814.  unsigned int         input_len)
  815. {
  816.     SECStatus       rv;
  817.     unsigned int    modulus_len = SECKEY_LowPrivateModulusLen(key);
  818.     unsigned int    i;
  819.     unsigned char * buffer;
  821.     PORT_Assert(key->keyType == rsaKey);
  822.     if (key->keyType != rsaKey)
  823.      goto failure;
  824.     if (input_len != modulus_len)
  825.      goto failure;
  827.     buffer = (unsigned char *)PORT_Alloc(modulus_len + 1);
  828.     if (!buffer)
  829.      goto failure;
  831.     rv = RSA_PrivateKeyOp(&key->u.rsa, buffer, input);
  832.     if (rv != SECSuccess) 
  833.      goto loser;
  835.     if (buffer[0] != 0 || buffer[1] != 2) 
  836.      goto loser;
  837.     *output_len = 0;
  838.     for (i = 2; i < modulus_len; i++) {
  839. if (buffer[i] == 0) {
  840.     *output_len = modulus_len - i - 1;
  841.     break;
  842. }
  843.     }
  844.     if (*output_len == 0) 
  845.      goto loser;
  846.     if (*output_len > max_output_len) 
  847.      goto loser;
  849.     PORT_Memcpy(output, buffer + modulus_len - *output_len, *output_len);
  851.     PORT_Free(buffer);
  852.     return SECSuccess;
  854. loser:
  855.     PORT_Free(buffer);
  856. failure:
  857.     return SECFailure;
  858. }
  860. /* XXX Doesn't set error code */
  861. /*
  862.  * added to make pkcs #11 happy
  863.  *   RAW is RSA_X_509
  864.  */
  865. SECStatus
  866. RSA_SignRaw(SECKEYLowPrivateKey *key, 
  867.             unsigned char *      output, 
  868.     unsigned int *       output_len,
  869.             unsigned int         maxOutputLen, 
  870.     unsigned char *      input, 
  871.     unsigned int         input_len)
  872. {
  873.     SECStatus    rv          = SECSuccess;
  874.     unsigned int modulus_len = SECKEY_LowPrivateModulusLen(key);
  875.     SECItem      formatted;
  876.     SECItem      unformatted;
  878.     if (maxOutputLen < modulus_len) 
  879.      return SECFailure;
  880.     PORT_Assert(key->keyType == rsaKey);
  881.     if (key->keyType != rsaKey)
  882.      return SECFailure;
  884.     unformatted.len  = input_len;
  885.     unformatted.data = input;
  886.     formatted.data   = NULL;
  887.     rv = RSA_FormatBlock(&formatted, modulus_len, RSA_BlockRaw, &unformatted);
  888.     if (rv != SECSuccess) 
  889.      goto done;
  891.     rv = RSA_PrivateKeyOp(&key->u.rsa, output, formatted.data);
  892.     *output_len = modulus_len;
  894. done:
  895.     if (formatted.data != NULL) 
  896.      PORT_ZFree(formatted.data, modulus_len);
  897.     return rv;
  898. }
  900. /* XXX Doesn't set error code */
  901. SECStatus
  902. RSA_CheckSignRaw(SECKEYLowPublicKey *key,
  903.                  unsigned char *     sign, 
  904.  unsigned int        sign_len, 
  905.  unsigned char *     hash, 
  906.  unsigned int        hash_len)
  907. {
  908.     SECStatus       rv;
  909.     unsigned int    modulus_len = SECKEY_LowPublicModulusLen(key);
  910.     unsigned char * buffer;
  912.     if (sign_len != modulus_len) 
  913.      goto failure;
  914.     if (hash_len > modulus_len) 
  915.      goto failure;
  916.     PORT_Assert(key->keyType == rsaKey);
  917.     if (key->keyType != rsaKey)
  918.      goto failure;
  920.     buffer = (unsigned char *)PORT_Alloc(modulus_len + 1);
  921.     if (!buffer)
  922.      goto failure;
  924.     rv = RSA_PublicKeyOp(&key->u.rsa, buffer, sign);
  925.     if (rv != SECSuccess)
  926. goto loser;
  928.     /*
  929.      * make sure we get the same results
  930.      */
  931.     /* NOTE: should we verify the leading zeros? */
  932.     if (PORT_Memcmp(buffer + (modulus_len-hash_len), hash, hash_len) != 0)
  933. goto loser;
  935.     PORT_Free(buffer);
  936.     return SECSuccess;
  938. loser:
  939.     PORT_Free(buffer);
  940. failure:
  941.     return SECFailure;
  942. }
  944. /* XXX Doesn't set error code */
  945. SECStatus
  946. RSA_CheckSignRecoverRaw(SECKEYLowPublicKey *key,
  947.                         unsigned char *     data,
  948.                         unsigned int *      data_len, 
  949. unsigned int        max_output_len, 
  950. unsigned char *     sign,
  951. unsigned int        sign_len)
  952. {
  953.     SECStatus      rv;
  954.     unsigned int   modulus_len = SECKEY_LowPublicModulusLen(key);
  956.     if (sign_len != modulus_len) 
  957.      goto failure;
  958.     if (max_output_len < modulus_len) 
  959.      goto failure;
  960.     PORT_Assert(key->keyType == rsaKey);
  961.     if (key->keyType != rsaKey)
  962.      goto failure;
  964.     rv = RSA_PublicKeyOp(&key->u.rsa, data, sign);
  965.     if (rv != SECSuccess)
  966. goto failure;
  968.     *data_len = modulus_len;
  969.     return SECSuccess;
  971. failure:
  972.     return SECFailure;
  973. }
  976. /* XXX Doesn't set error code */
  977. SECStatus
  978. RSA_EncryptRaw(SECKEYLowPublicKey *key, 
  979.        unsigned char *     output, 
  980.        unsigned int *      output_len,
  981.                unsigned int        max_output_len, 
  982.        unsigned char *     input, 
  983.        unsigned int        input_len)
  984. {
  985.     SECStatus rv;
  986.     unsigned int  modulus_len = SECKEY_LowPublicModulusLen(key);
  987.     SECItem       formatted;
  988.     SECItem       unformatted;
  990.     formatted.data = NULL;
  991.     if (max_output_len < modulus_len) 
  992.      goto failure;
  993.     PORT_Assert(key->keyType == rsaKey);
  994.     if (key->keyType != rsaKey)
  995.      goto failure;
  997.     unformatted.len  = input_len;
  998.     unformatted.data = input;
  999.     formatted.data   = NULL;
  1000.     rv = RSA_FormatBlock(&formatted, modulus_len, RSA_BlockRaw, &unformatted);
  1001.     if (rv != SECSuccess)
  1002. goto failure;
  1004.     rv = RSA_PublicKeyOp(&key->u.rsa, output, formatted.data);
  1005.     if (rv != SECSuccess) 
  1006.      goto failure;
  1008.     PORT_ZFree(formatted.data, modulus_len);
  1009.     *output_len = modulus_len;
  1010.     return SECSuccess;
  1012. failure:
  1013.     if (formatted.data != NULL) 
  1014. PORT_ZFree(formatted.data, modulus_len);
  1015.     return SECFailure;
  1016. }
  1018. /* XXX Doesn't set error code */
  1019. SECStatus
  1020. RSA_DecryptRaw(SECKEYLowPrivateKey *key, 
  1021.                unsigned char *      output, 
  1022.        unsigned int *       output_len,
  1023.                unsigned int         max_output_len, 
  1024.        unsigned char *      input, 
  1025.        unsigned int         input_len)
  1026. {
  1027.     SECStatus     rv;
  1028.     unsigned int  modulus_len = SECKEY_LowPrivateModulusLen(key);
  1030.     if (modulus_len <= 0) 
  1031.      goto failure;
  1032.     if (modulus_len > max_output_len) 
  1033.      goto failure;
  1034.     PORT_Assert(key->keyType == rsaKey);
  1035.     if (key->keyType != rsaKey)
  1036.      goto failure;
  1037.     if (input_len != modulus_len) 
  1038.      goto failure;
  1040.     rv = RSA_PrivateKeyOp(&key->u.rsa, output, input);
  1041.     if (rv != SECSuccess)
  1042.      goto failure;
  1044.     *output_len = modulus_len;
  1045.     return SECSuccess;
  1047. failure:
  1048.     return SECFailure;
  1049. }