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

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

CA认证

开发平台：

WINDOWS

alg2268.c：源码内容
  1. /*
  2.  * alg2268.c - implementation of the algorithm in RFC 2268
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public
  5.  * License Version 1.1 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.mozilla.org/MPL/
  8.  * 
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  * 
  14.  * The Original Code is the Netscape security libraries.
  15.  * 
  16.  * The Initial Developer of the Original Code is Netscape
  17.  * Communications Corporation.  Portions created by Netscape are 
  18.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  19.  * Rights Reserved.
  20.  * 
  21.  * Contributor(s):
  22.  * 
  23.  * Alternatively, the contents of this file may be used under the
  24.  * terms of the GNU General Public License Version 2 or later (the
  25.  * "GPL"), in which case the provisions of the GPL are applicable 
  26.  * instead of those above.  If you wish to allow use of your 
  27.  * version of this file only under the terms of the GPL and not to
  28.  * allow others to use your version of this file under the MPL,
  29.  * indicate your decision by deleting the provisions above and
  30.  * replace them with the notice and other provisions required by
  31.  * the GPL.  If you do not delete the provisions above, a recipient
  32.  * may use your version of this file under either the MPL or the
  33.  * GPL.
  34.  *
  35.  * $Id: alg2268.c,v 1.1 2000/05/27 01:29:35 nelsonb%netscape.com Exp $
  36.  */
  39. #include "blapi.h"
  40. #include "secerr.h"
  41. #ifdef XP_UNIX_XXX
  42. #include <stddef.h> /* for ptrdiff_t */
  43. #endif
  45. /*
  46. ** RC2 symmetric block cypher
  47. */
  49. typedef SECStatus (rc2Func)(RC2Context *cx, unsigned char *output,
  50.            unsigned char *input, unsigned int inputLen);
  52. /* forward declarations */
  53. static rc2Func rc2_EncryptECB;
  54. static rc2Func rc2_DecryptECB;
  55. static rc2Func rc2_EncryptCBC;
  56. static rc2Func rc2_DecryptCBC;
  58. typedef union {
  59.     PRUint32 l[2];
  60.     PRUint16 s[4];
  61.     PRUint8 b[8];
  62. } RC2Block;
  64. struct RC2ContextStr {
  65.     union {
  66.      PRUint8  Kb[128];
  67. PRUint16 Kw[64];
  68.     } u;
  69.     RC2Block     iv;
  70.     rc2Func      *enc;
  71.     rc2Func      *dec;
  72. };
  74. #define B u.Kb
  75. #define K u.Kw
  76. #define BYTESWAP(x) ((x) << 8 | (x) >> 8)
  77. #define SWAPK(i)  cx->K[i] = (tmpS = cx->K[i], BYTESWAP(tmpS))
  78. #define RC2_BLOCK_SIZE 8
  80. #define LOAD_HARD(R) 
  81.     R[0] = (PRUint16)input[1] << 8 | input[0]; 
  82.     R[1] = (PRUint16)input[3] << 8 | input[2]; 
  83.     R[2] = (PRUint16)input[5] << 8 | input[4]; 
  84.     R[3] = (PRUint16)input[7] << 8 | input[6];
  85. #define LOAD_EASY(R) 
  86.     R[0] = ((PRUint16 *)input)[0]; 
  87.     R[1] = ((PRUint16 *)input)[1]; 
  88.     R[2] = ((PRUint16 *)input)[2]; 
  89.     R[3] = ((PRUint16 *)input)[3];
  90. #define STORE_HARD(R) 
  91.     output[0] =  (PRUint8)(R[0]);   output[1] = (PRUint8)(R[0] >> 8); 
  92.     output[2] =  (PRUint8)(R[1]);   output[3] = (PRUint8)(R[1] >> 8); 
  93.     output[4] =  (PRUint8)(R[2]);   output[5] = (PRUint8)(R[2] >> 8); 
  94.     output[6] =  (PRUint8)(R[3]);   output[7] = (PRUint8)(R[3] >> 8);
  95. #define STORE_EASY(R) 
  96.     ((PRUint16 *)output)[0] =  R[0]; 
  97.     ((PRUint16 *)output)[1] =  R[1]; 
  98.     ((PRUint16 *)output)[2] =  R[2]; 
  99.     ((PRUint16 *)output)[3] =  R[3];   
  101. #if defined (_X86_)
  102. #define LOAD(R)  LOAD_EASY(R)
  103. #define STORE(R) STORE_EASY(R)
  104. #elif !defined(IS_LITTLE_ENDIAN)
  105. #define LOAD(R)  LOAD_HARD(R)
  106. #define STORE(R) STORE_HARD(R)
  107. #else
  108. #define LOAD(R) if ((ptrdiff_t)input & 1) { LOAD_HARD(R) } else { LOAD_EASY(R) }
  109. #define STORE(R) if ((ptrdiff_t)input & 1) { STORE_HARD(R) } else { STORE_EASY(R) }
  110. #endif
  112. static const PRUint8 S[256] = {
  113. 0331,0170,0371,0304,0031,0335,0265,0355,0050,0351,0375,0171,0112,0240,0330,0235,
  114. 0306,0176,0067,0203,0053,0166,0123,0216,0142,0114,0144,0210,0104,0213,0373,0242,
  115. 0027,0232,0131,0365,0207,0263,0117,0023,0141,0105,0155,0215,0011,0201,0175,0062,
  116. 0275,0217,0100,0353,0206,0267,0173,0013,0360,0225,0041,0042,0134,0153,0116,0202,
  117. 0124,0326,0145,0223,0316,0140,0262,0034,0163,0126,0300,0024,0247,0214,0361,0334,
  118. 0022,0165,0312,0037,0073,0276,0344,0321,0102,0075,0324,0060,0243,0074,0266,0046,
  119. 0157,0277,0016,0332,0106,0151,0007,0127,0047,0362,0035,0233,0274,0224,0103,0003,
  120. 0370,0021,0307,0366,0220,0357,0076,0347,0006,0303,0325,0057,0310,0146,0036,0327,
  121. 0010,0350,0352,0336,0200,0122,0356,0367,0204,0252,0162,0254,0065,0115,0152,0052,
  122. 0226,0032,0322,0161,0132,0025,0111,0164,0113,0237,0320,0136,0004,0030,0244,0354,
  123. 0302,0340,0101,0156,0017,0121,0313,0314,0044,0221,0257,0120,0241,0364,0160,0071,
  124. 0231,0174,0072,0205,0043,0270,0264,0172,0374,0002,0066,0133,0045,0125,0227,0061,
  125. 0055,0135,0372,0230,0343,0212,0222,0256,0005,0337,0051,0020,0147,0154,0272,0311,
  126. 0323,0000,0346,0317,0341,0236,0250,0054,0143,0026,0001,0077,0130,0342,0211,0251,
  127. 0015,0070,0064,0033,0253,0063,0377,0260,0273,0110,0014,0137,0271,0261,0315,0056,
  128. 0305,0363,0333,0107,0345,0245,0234,0167,0012,0246,0040,0150,0376,0177,0301,0255
  129. };
  131. /*
  132. ** Create a new RC2 context suitable for RC2 encryption/decryption.
  133. **  "key" raw key data
  134. **  "len" the number of bytes of key data
  135. **  "iv" is the CBC initialization vector (if mode is NSS_RC2_CBC)
  136. **  "mode" one of NSS_RC2 or NSS_RC2_CBC
  137. ** "effectiveKeyLen" in bytes, not bits.
  138. **
  139. ** When mode is set to NSS_RC2_CBC the RC2 cipher is run in "cipher block
  140. ** chaining" mode.
  141. */
  142. RC2Context *
  143. RC2_CreateContext(unsigned char *key, unsigned int len,
  144.   unsigned char *input, int mode, unsigned efLen8)
  145. {
  146.     RC2Context *cx;
  147.     PRUint8    *L,*L2;
  148.     int         i;
  149.     PRUint16    tmpS;
  150.     PRUint8     tmpB;
  152.     if (!key || len == 0 || len > (sizeof cx->B) || efLen8 > (sizeof cx->B)) {
  153.      return NULL;
  154.     }
  155.     if (mode == NSS_RC2) {
  156.      /* groovy */
  157.     } else if (mode == NSS_RC2_CBC) {
  158.      if (!input) {
  159.     return NULL; /* not groovy */
  160. }
  161.     } else {
  162.      return NULL;
  163.     }
  165.     cx = PORT_ZNew(RC2Context);
  166.     if (!cx)
  167.      return cx;
  169.     if (mode == NSS_RC2_CBC) {
  170.      cx->enc = & rc2_EncryptCBC;
  171. cx->dec = & rc2_DecryptCBC;
  172. LOAD(cx->iv.s);
  173.     } else {
  174.      cx->enc = & rc2_EncryptECB;
  175. cx->dec = & rc2_DecryptECB;
  176.     }
  178.     /* Step 0. Copy key into table. */
  179.     memcpy(cx->B, key, len);
  181.     /* Step 1. Compute all values to the right of the key. */
  182.     L2 = cx->B;
  183.     L = L2 + len;
  184.     tmpB = L[-1];
  185.     for (i = (sizeof cx->B) - len; i > 0; --i) {
  186. *L++ = tmpB = S[ (PRUint8)(tmpB + *L2++) ];
  187.     }
  189.     /* step 2. Adjust left most byte of effective key. */
  190.     i = (sizeof cx->B) - efLen8;
  191.     L = cx->B + i;
  192.     *L = tmpB = S[*L]; /* mask is always 0xff */
  194.     /* step 3. Recompute all values to the left of effective key. */
  195.     L2 = --L + efLen8;
  196.     while(L >= cx->B) {
  197. *L-- = tmpB = S[ tmpB ^ *L2-- ];
  198.     }
  200. #if !defined(IS_LITTLE_ENDIAN)
  201.     for (i = 63; i >= 0; --i) {
  202.         SWAPK(i); /* candidate for unrolling */
  203.     }
  204. #endif
  205.     return cx;
  206. }
  208. /*
  209. ** Destroy an RC2 encryption/decryption context.
  210. ** "cx" the context
  211. ** "freeit" if PR_TRUE then free the object as well as its sub-objects
  212. */
  213. void 
  214. RC2_DestroyContext(RC2Context *cx, PRBool freeit)
  215. {
  216.     if (cx) {
  217. memset(cx, 0, sizeof *cx);
  218. if (freeit) {
  219.     PORT_Free(cx);
  220. }
  221.     }
  222. }
  224. #define ROL(x,k) (x << k | x >> (16-k))
  225. #define MIX(j) 
  226.     R0 = R0 + cx->K[ 4*j+0] + (R3 & R2) + (~R3 & R1);  R0 = ROL(R0,1);
  227.     R1 = R1 + cx->K[ 4*j+1] + (R0 & R3) + (~R0 & R2);  R1 = ROL(R1,2);
  228.     R2 = R2 + cx->K[ 4*j+2] + (R1 & R0) + (~R1 & R3);  R2 = ROL(R2,3);
  229.     R3 = R3 + cx->K[ 4*j+3] + (R2 & R1) + (~R2 & R0);  R3 = ROL(R3,5)
  230. #define MASH 
  231.     R0 = R0 + cx->K[R3 & 63];
  232.     R1 = R1 + cx->K[R0 & 63];
  233.     R2 = R2 + cx->K[R1 & 63];
  234.     R3 = R3 + cx->K[R2 & 63]
  236. /* Encrypt one block */
  237. static void 
  238. rc2_Encrypt1Block(RC2Context *cx, RC2Block *output, RC2Block *input)
  239. {
  240.     register PRUint16 R0, R1, R2, R3;
  242.     /* step 1. Initialize input. */
  243.     R0 = input->s[0];
  244.     R1 = input->s[1];
  245.     R2 = input->s[2];
  246.     R3 = input->s[3];
  248.     /* step 2.  Expand Key (already done, in context) */
  249.     /* step 3.  j = 0 */
  250.     /* step 4.  Perform 5 mixing rounds. */
  252.     MIX(0);
  253.     MIX(1);
  254.     MIX(2);
  255.     MIX(3);
  256.     MIX(4);
  258.     /* step 5. Perform 1 mashing round. */
  259.     MASH;
  261.     /* step 6. Perform 6 mixing rounds. */
  263.     MIX(5);
  264.     MIX(6);
  265.     MIX(7);
  266.     MIX(8);
  267.     MIX(9);
  268.     MIX(10);
  270.     /* step 7. Perform 1 mashing round. */
  271.     MASH;
  273.     /* step 8. Perform 5 mixing rounds. */
  275.     MIX(11);
  276.     MIX(12);
  277.     MIX(13);
  278.     MIX(14);
  279.     MIX(15);
  281.     /* output results */
  282.     output->s[0] = R0;
  283.     output->s[1] = R1;
  284.     output->s[2] = R2;
  285.     output->s[3] = R3;
  286. }
  288. #define ROR(x,k) (x >> k | x << (16-k))
  289. #define R_MIX(j) 
  290.     R3 = ROR(R3,5); R3 = R3 - cx->K[ 4*j+3] - (R2 & R1) - (~R2 & R0);  
  291.     R2 = ROR(R2,3); R2 = R2 - cx->K[ 4*j+2] - (R1 & R0) - (~R1 & R3);  
  292.     R1 = ROR(R1,2); R1 = R1 - cx->K[ 4*j+1] - (R0 & R3) - (~R0 & R2);  
  293.     R0 = ROR(R0,1); R0 = R0 - cx->K[ 4*j+0] - (R3 & R2) - (~R3 & R1)
  294. #define R_MASH 
  295.     R3 = R3 - cx->K[R2 & 63];
  296.     R2 = R2 - cx->K[R1 & 63];
  297.     R1 = R1 - cx->K[R0 & 63];
  298.     R0 = R0 - cx->K[R3 & 63]
  300. /* Encrypt one block */
  301. static void 
  302. rc2_Decrypt1Block(RC2Context *cx, RC2Block *output, RC2Block *input)
  303. {
  304.     register PRUint16 R0, R1, R2, R3;
  306.     /* step 1. Initialize input. */
  307.     R0 = input->s[0];
  308.     R1 = input->s[1];
  309.     R2 = input->s[2];
  310.     R3 = input->s[3];
  312.     /* step 2.  Expand Key (already done, in context) */
  313.     /* step 3.  j = 63 */
  314.     /* step 4.  Perform 5 r_mixing rounds. */
  315.     R_MIX(15);
  316.     R_MIX(14);
  317.     R_MIX(13);
  318.     R_MIX(12);
  319.     R_MIX(11);
  321.     /* step 5.  Perform 1 r_mashing round. */
  322.     R_MASH;
  324.     /* step 6.  Perform 6 r_mixing rounds. */
  325.     R_MIX(10);
  326.     R_MIX(9);
  327.     R_MIX(8);
  328.     R_MIX(7);
  329.     R_MIX(6);
  330.     R_MIX(5);
  332.     /* step 7.  Perform 1 r_mashing round. */
  333.     R_MASH;
  335.     /* step 8.  Perform 5 r_mixing rounds. */
  336.     R_MIX(4);
  337.     R_MIX(3);
  338.     R_MIX(2);
  339.     R_MIX(1);
  340.     R_MIX(0);
  342.     /* output results */
  343.     output->s[0] = R0;
  344.     output->s[1] = R1;
  345.     output->s[2] = R2;
  346.     output->s[3] = R3;
  347. }
  349. static SECStatus
  350. rc2_EncryptECB(RC2Context *cx, unsigned char *output,
  351.        unsigned char *input, unsigned int inputLen)
  352. {
  353.     RC2Block  iBlock;
  355.     while (inputLen > 0) {
  356.      LOAD(iBlock.s)
  357. rc2_Encrypt1Block(cx, &iBlock, &iBlock);
  358. STORE(iBlock.s)
  359. output   += RC2_BLOCK_SIZE;
  360. input    += RC2_BLOCK_SIZE;
  361. inputLen -= RC2_BLOCK_SIZE;
  362.     }
  363.     return SECSuccess;
  364. }
  366. static SECStatus
  367. rc2_DecryptECB(RC2Context *cx, unsigned char *output,
  368.        unsigned char *input, unsigned int inputLen)
  369. {
  370.     RC2Block  iBlock;
  372.     while (inputLen > 0) {
  373.      LOAD(iBlock.s)
  374. rc2_Decrypt1Block(cx, &iBlock, &iBlock);
  375. STORE(iBlock.s)
  376. output   += RC2_BLOCK_SIZE;
  377. input    += RC2_BLOCK_SIZE;
  378. inputLen -= RC2_BLOCK_SIZE;
  379.     }
  380.     return SECSuccess;
  381. }
  383. static SECStatus
  384. rc2_EncryptCBC(RC2Context *cx, unsigned char *output,
  385.        unsigned char *input, unsigned int inputLen)
  386. {
  387.     RC2Block  iBlock;
  389.     while (inputLen > 0) {
  391. LOAD(iBlock.s)
  392. iBlock.l[0] ^= cx->iv.l[0];
  393. iBlock.l[1] ^= cx->iv.l[1];
  394. rc2_Encrypt1Block(cx, &iBlock, &iBlock);
  395. cx->iv = iBlock;
  396. STORE(iBlock.s)
  397. output   += RC2_BLOCK_SIZE;
  398. input    += RC2_BLOCK_SIZE;
  399. inputLen -= RC2_BLOCK_SIZE;
  400.     }
  401.     return SECSuccess;
  402. }
  404. static SECStatus
  405. rc2_DecryptCBC(RC2Context *cx, unsigned char *output,
  406.        unsigned char *input, unsigned int inputLen)
  407. {
  408.     RC2Block  iBlock;
  409.     RC2Block  oBlock;
  411.     while (inputLen > 0) {
  412. LOAD(iBlock.s)
  413. rc2_Decrypt1Block(cx, &oBlock, &iBlock);
  414. oBlock.l[0] ^= cx->iv.l[0];
  415. oBlock.l[1] ^= cx->iv.l[1];
  416. cx->iv = iBlock;
  417. STORE(oBlock.s)
  418. output   += RC2_BLOCK_SIZE;
  419. input    += RC2_BLOCK_SIZE;
  420. inputLen -= RC2_BLOCK_SIZE;
  421.     }
  422.     return SECSuccess;
  423. }
  426. /*
  427. ** Perform RC2 encryption.
  428. ** "cx" the context
  429. ** "output" the output buffer to store the encrypted data.
  430. ** "outputLen" how much data is stored in "output". Set by the routine
  431. **    after some data is stored in output.
  432. ** "maxOutputLen" the maximum amount of data that can ever be
  433. **    stored in "output"
  434. ** "input" the input data
  435. ** "inputLen" the amount of input data
  436. */
  437. SECStatus RC2_Encrypt(RC2Context *cx, unsigned char *output,
  438.       unsigned int *outputLen, unsigned int maxOutputLen,
  439.       unsigned char *input, unsigned int inputLen)
  440. {
  441.     SECStatus rv = SECSuccess;
  442.     if (inputLen) {
  443. if (inputLen % RC2_BLOCK_SIZE) {
  444.     PORT_SetError(SEC_ERROR_INPUT_LEN);
  445.     return SECFailure;
  446. }
  447. if (maxOutputLen < inputLen) {
  448.     PORT_SetError(SEC_ERROR_OUTPUT_LEN);
  449.     return SECFailure;
  450. }
  451. rv = (*cx->enc)(cx, output, input, inputLen);
  452.     }
  453.     if (rv == SECSuccess) {
  454.      *outputLen = inputLen;
  455.     }
  456.     return rv;
  457. }
  459. /*
  460. ** Perform RC2 decryption.
  461. ** "cx" the context
  462. ** "output" the output buffer to store the decrypted data.
  463. ** "outputLen" how much data is stored in "output". Set by the routine
  464. **    after some data is stored in output.
  465. ** "maxOutputLen" the maximum amount of data that can ever be
  466. **    stored in "output"
  467. ** "input" the input data
  468. ** "inputLen" the amount of input data
  469. */
  470. SECStatus RC2_Decrypt(RC2Context *cx, unsigned char *output,
  471.       unsigned int *outputLen, unsigned int maxOutputLen,
  472.       unsigned char *input, unsigned int inputLen)
  473. {
  474.     SECStatus rv = SECSuccess;
  475.     if (inputLen) {
  476. if (inputLen % RC2_BLOCK_SIZE) {
  477.     PORT_SetError(SEC_ERROR_INPUT_LEN);
  478.     return SECFailure;
  479. }
  480. if (maxOutputLen < inputLen) {
  481.     PORT_SetError(SEC_ERROR_OUTPUT_LEN);
  482.     return SECFailure;
  483. }
  484. rv = (*cx->dec)(cx, output, input, inputLen);
  485.     }
  486.     if (rv == SECSuccess) {
  487. *outputLen = inputLen;
  488.     }
  489.     return rv;
  490. }