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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
RIPEMD128Digest.java
资源名称：security.rar　[点击查看]
上传用户：lior1029
上传日期：2013-05-07
资源大小：209k
文件大小：10k
源码类别：

CA认证

开发平台：

Java

RIPEMD128Digest.java：源码内容
  1. package org.bouncycastle.crypto.digests;
  3. import org.bouncycastle.crypto.Digest;
  5. /**
  6.  * implementation of RIPEMD128
  7.  */
  8. public class RIPEMD128Digest
  9.     extends GeneralDigest
  10. {
  11. private static final int DIGEST_LENGTH = 16;
  13. private int H0, H1, H2, H3; // IV's
  15. private int[] X = new int[16];
  16. private int xOff;
  18. /**
  19.  * Standard constructor
  20.  */
  21. public RIPEMD128Digest()
  22. {
  23. reset();
  24. }
  26. /**
  27.  * Copy constructor.  This will copy the state of the provided
  28.  * message digest.
  29.  */
  30. public RIPEMD128Digest(RIPEMD128Digest t)
  31. {
  32. super(t);
  34. H0 = t.H0;
  35. H1 = t.H1;
  36. H2 = t.H2;
  37. H3 = t.H3;
  39. System.arraycopy(t.X, 0, X, 0, t.X.length);
  40. xOff = t.xOff;
  41. }
  43. public String getAlgorithmName()
  44. {
  45. return "RIPEMD128";
  46. }
  48. public int getDigestSize()
  49. {
  50. return DIGEST_LENGTH;
  51. }
  53. protected void processWord(
  54. byte[] in,
  55. int inOff)
  56. {
  57. X[xOff++] = (in[inOff] & 0xff) | ((in[inOff + 1] & 0xff) << 8)
  58. | ((in[inOff + 2] & 0xff) << 16) | ((in[inOff + 3] & 0xff) << 24); 
  60. if (xOff == 16)
  61. {
  62. processBlock();
  63. }
  64. }
  66. protected void processLength(
  67. long bitLength)
  68. {
  69. if (xOff > 14)
  70. {
  71. processBlock();
  72. }
  74. X[14] = (int)(bitLength & 0xffffffff);
  75. X[15] = (int)(bitLength >>> 32);
  76. }
  78. private void unpackWord(
  79. int word,
  80. byte[] out,
  81. int outOff)
  82. {
  83. out[outOff]     = (byte)word;
  84. out[outOff + 1] = (byte)(word >>> 8);
  85. out[outOff + 2] = (byte)(word >>> 16);
  86. out[outOff + 3] = (byte)(word >>> 24);
  87. }
  89. public int doFinal(
  90. byte[] out,
  91. int outOff)
  92. {
  93. finish();
  95. unpackWord(H0, out, outOff);
  96. unpackWord(H1, out, outOff + 4);
  97. unpackWord(H2, out, outOff + 8);
  98. unpackWord(H3, out, outOff + 12);
  100. reset();
  102. return DIGEST_LENGTH;
  103. }
  105. /**
  106. * reset the chaining variables to the IV values.
  107. */
  108. public void reset()
  109. {
  110. super.reset();
  112. H0 = 0x67452301;
  113. H1 = 0xefcdab89;
  114. H2 = 0x98badcfe;
  115. H3 = 0x10325476;
  117. xOff = 0;
  119. for (int i = 0; i != X.length; i++)
  120. {
  121. X[i] = 0;
  122. }
  123. }
  125. /*
  126.  * rotate int x left n bits.
  127.  */
  128. private final int RL(
  129. int x,
  130. int n)
  131. {
  132. return (x << n) | (x >>> (32 - n));
  133. }
  135. /*
  136.  * f1,f2,f3,f4 are the basic RIPEMD128 functions.
  137.  */
  139. /*
  140.  * F
  141.  */
  142. private final int f1(
  143. int x,
  144. int y,
  145. int z)
  146. {
  147. return x ^ y ^ z;
  148. }
  150. /*
  151.  * G
  152.  */
  153. private final int f2(
  154. int x,
  155. int y,
  156. int z)
  157. {
  158. return (x & y) | (~x & z);
  159. }
  161. /*
  162.  * H
  163.  */
  164. private final int f3(
  165. int x,
  166. int y,
  167. int z)
  168. {
  169. return (x | ~y) ^ z;
  170. }
  172. /*
  173.  * I
  174.  */
  175. private final int f4(
  176. int x,
  177. int y,
  178. int z)
  179. {
  180. return (x & z) | (y & ~z);
  181. }
  183.     private final int F1(
  184.         int a,
  185.         int b,
  186.         int c,
  187.         int d,
  188.         int x,
  189.         int s)
  190.     {
  191.         return RL(a + f1(b, c, d) + x, s);
  192.     }
  194.     private final int F2(
  195.         int a,
  196.         int b,
  197.         int c,
  198.         int d,
  199.         int x,
  200.         int s)
  201.     {
  202.         return RL(a + f2(b, c, d) + x + 0x5a827999, s);
  203.     }
  205.     private final int F3(
  206.         int a,
  207.         int b,
  208.         int c,
  209.         int d,
  210.         int x,
  211.         int s)
  212.     {
  213.         return RL(a + f3(b, c, d) + x + 0x6ed9eba1, s);
  214.     }
  216.     private final int F4(
  217.         int a,
  218.         int b,
  219.         int c,
  220.         int d,
  221.         int x,
  222.         int s)
  223.     {
  224.         return RL(a + f4(b, c, d) + x + 0x8f1bbcdc, s);
  225.     }
  227.     private final int FF1(
  228.         int a,
  229.         int b,
  230.         int c,
  231.         int d,
  232.         int x,
  233.         int s)
  234.     {
  235.         return RL(a + f1(b, c, d) + x, s);
  236.     }
  238.     private final int FF2(
  239.         int a,
  240.         int b,
  241.         int c,
  242.         int d,
  243.         int x,
  244.         int s)
  245.     {
  246.       return RL(a + f2(b, c, d) + x + 0x6d703ef3, s);
  247.     }
  249.     private final int FF3(
  250.         int a,
  251.         int b,
  252.         int c,
  253.         int d,
  254.         int x,
  255.         int s)
  256.     {
  257.       return RL(a + f3(b, c, d) + x + 0x5c4dd124, s);
  258.     }
  260.     private final int FF4(
  261.         int a,
  262.         int b,
  263.         int c,
  264.         int d,
  265.         int x,
  266.         int s)
  267.     {
  268.       return RL(a + f4(b, c, d) + x + 0x50a28be6, s);
  269.     }
  271. protected void processBlock()
  272. {
  273. int a, aa;
  274. int b, bb;
  275. int c, cc;
  276. int d, dd;
  278. a = aa = H0;
  279. b = bb = H1;
  280. c = cc = H2;
  281. d = dd = H3;
  283. //
  284. // Round 1
  285. //
  286.         a = F1(a, b, c, d, X[ 0], 11);
  287.         d = F1(d, a, b, c, X[ 1], 14);
  288.         c = F1(c, d, a, b, X[ 2], 15);
  289.         b = F1(b, c, d, a, X[ 3], 12);
  290.         a = F1(a, b, c, d, X[ 4],  5);
  291.         d = F1(d, a, b, c, X[ 5],  8);
  292.         c = F1(c, d, a, b, X[ 6],  7);
  293.         b = F1(b, c, d, a, X[ 7],  9);
  294.         a = F1(a, b, c, d, X[ 8], 11);
  295.         d = F1(d, a, b, c, X[ 9], 13);
  296.         c = F1(c, d, a, b, X[10], 14);
  297.         b = F1(b, c, d, a, X[11], 15);
  298.         a = F1(a, b, c, d, X[12],  6);
  299.         d = F1(d, a, b, c, X[13],  7);
  300.         c = F1(c, d, a, b, X[14],  9);
  301.         b = F1(b, c, d, a, X[15],  8);
  303. //
  304. // Round 2
  305. //
  306.         a = F2(a, b, c, d, X[ 7],  7);
  307.         d = F2(d, a, b, c, X[ 4],  6);
  308.         c = F2(c, d, a, b, X[13],  8);
  309.         b = F2(b, c, d, a, X[ 1], 13);
  310.         a = F2(a, b, c, d, X[10], 11);
  311.         d = F2(d, a, b, c, X[ 6],  9);
  312.         c = F2(c, d, a, b, X[15],  7);
  313.         b = F2(b, c, d, a, X[ 3], 15);
  314.         a = F2(a, b, c, d, X[12],  7);
  315.         d = F2(d, a, b, c, X[ 0], 12);
  316.         c = F2(c, d, a, b, X[ 9], 15);
  317.         b = F2(b, c, d, a, X[ 5],  9);
  318.         a = F2(a, b, c, d, X[ 2], 11);
  319.         d = F2(d, a, b, c, X[14],  7);
  320.         c = F2(c, d, a, b, X[11], 13);
  321.         b = F2(b, c, d, a, X[ 8], 12);
  323.         //
  324.         // Round 3
  325.         //
  326.         a = F3(a, b, c, d, X[ 3], 11);
  327.         d = F3(d, a, b, c, X[10], 13);
  328.         c = F3(c, d, a, b, X[14],  6);
  329.         b = F3(b, c, d, a, X[ 4],  7);
  330.         a = F3(a, b, c, d, X[ 9], 14);
  331.         d = F3(d, a, b, c, X[15],  9);
  332.         c = F3(c, d, a, b, X[ 8], 13);
  333.         b = F3(b, c, d, a, X[ 1], 15);
  334.         a = F3(a, b, c, d, X[ 2], 14);
  335.         d = F3(d, a, b, c, X[ 7],  8);
  336.         c = F3(c, d, a, b, X[ 0], 13);
  337.         b = F3(b, c, d, a, X[ 6],  6);
  338.         a = F3(a, b, c, d, X[13],  5);
  339.         d = F3(d, a, b, c, X[11], 12);
  340.         c = F3(c, d, a, b, X[ 5],  7);
  341.         b = F3(b, c, d, a, X[12],  5);
  343.         //
  344.         // Round 4
  345.         //
  346.         a = F4(a, b, c, d, X[ 1], 11);
  347.         d = F4(d, a, b, c, X[ 9], 12);
  348.         c = F4(c, d, a, b, X[11], 14);
  349.         b = F4(b, c, d, a, X[10], 15);
  350.         a = F4(a, b, c, d, X[ 0], 14);
  351.         d = F4(d, a, b, c, X[ 8], 15);
  352.         c = F4(c, d, a, b, X[12],  9);
  353.         b = F4(b, c, d, a, X[ 4],  8);
  354.         a = F4(a, b, c, d, X[13],  9);
  355.         d = F4(d, a, b, c, X[ 3], 14);
  356.         c = F4(c, d, a, b, X[ 7],  5);
  357.         b = F4(b, c, d, a, X[15],  6);
  358.         a = F4(a, b, c, d, X[14],  8);
  359.         d = F4(d, a, b, c, X[ 5],  6);
  360.         c = F4(c, d, a, b, X[ 6],  5);
  361.         b = F4(b, c, d, a, X[ 2], 12);
  363.         //
  364.         // Parallel round 1
  365.         //
  366.         aa = FF4(aa, bb, cc, dd, X[ 5],  8);
  367.         dd = FF4(dd, aa, bb, cc, X[14],  9);
  368.         cc = FF4(cc, dd, aa, bb, X[ 7],  9);
  369.         bb = FF4(bb, cc, dd, aa, X[ 0], 11);
  370.         aa = FF4(aa, bb, cc, dd, X[ 9], 13);
  371.         dd = FF4(dd, aa, bb, cc, X[ 2], 15);
  372.         cc = FF4(cc, dd, aa, bb, X[11], 15);
  373.         bb = FF4(bb, cc, dd, aa, X[ 4],  5);
  374.         aa = FF4(aa, bb, cc, dd, X[13],  7);
  375.         dd = FF4(dd, aa, bb, cc, X[ 6],  7);
  376.         cc = FF4(cc, dd, aa, bb, X[15],  8);
  377.         bb = FF4(bb, cc, dd, aa, X[ 8], 11);
  378.         aa = FF4(aa, bb, cc, dd, X[ 1], 14);
  379.         dd = FF4(dd, aa, bb, cc, X[10], 14);
  380.         cc = FF4(cc, dd, aa, bb, X[ 3], 12);
  381.         bb = FF4(bb, cc, dd, aa, X[12],  6);
  383.         //
  384.         // Parallel round 2
  385.         //
  386.         aa = FF3(aa, bb, cc, dd, X[ 6],  9);
  387.         dd = FF3(dd, aa, bb, cc, X[11], 13);
  388.         cc = FF3(cc, dd, aa, bb, X[ 3], 15);
  389.         bb = FF3(bb, cc, dd, aa, X[ 7],  7);
  390.         aa = FF3(aa, bb, cc, dd, X[ 0], 12);
  391.         dd = FF3(dd, aa, bb, cc, X[13],  8);
  392.         cc = FF3(cc, dd, aa, bb, X[ 5],  9);
  393.         bb = FF3(bb, cc, dd, aa, X[10], 11);
  394.         aa = FF3(aa, bb, cc, dd, X[14],  7);
  395.         dd = FF3(dd, aa, bb, cc, X[15],  7);
  396.         cc = FF3(cc, dd, aa, bb, X[ 8], 12);
  397.         bb = FF3(bb, cc, dd, aa, X[12],  7);
  398.         aa = FF3(aa, bb, cc, dd, X[ 4],  6);
  399.         dd = FF3(dd, aa, bb, cc, X[ 9], 15);
  400.         cc = FF3(cc, dd, aa, bb, X[ 1], 13);
  401.         bb = FF3(bb, cc, dd, aa, X[ 2], 11);
  403.         //
  404.         // Parallel round 3
  405.         //
  406.         aa = FF2(aa, bb, cc, dd, X[15],  9);
  407.         dd = FF2(dd, aa, bb, cc, X[ 5],  7);
  408.         cc = FF2(cc, dd, aa, bb, X[ 1], 15);
  409.         bb = FF2(bb, cc, dd, aa, X[ 3], 11);
  410.         aa = FF2(aa, bb, cc, dd, X[ 7],  8);
  411.         dd = FF2(dd, aa, bb, cc, X[14],  6);
  412.         cc = FF2(cc, dd, aa, bb, X[ 6],  6);
  413.         bb = FF2(bb, cc, dd, aa, X[ 9], 14);
  414.         aa = FF2(aa, bb, cc, dd, X[11], 12);
  415.         dd = FF2(dd, aa, bb, cc, X[ 8], 13);
  416.         cc = FF2(cc, dd, aa, bb, X[12],  5);
  417.         bb = FF2(bb, cc, dd, aa, X[ 2], 14);
  418.         aa = FF2(aa, bb, cc, dd, X[10], 13);
  419.         dd = FF2(dd, aa, bb, cc, X[ 0], 13);
  420.         cc = FF2(cc, dd, aa, bb, X[ 4],  7);
  421.         bb = FF2(bb, cc, dd, aa, X[13],  5);
  423.         //
  424.         // Parallel round 4
  425.         //
  426.         aa = FF1(aa, bb, cc, dd, X[ 8], 15);
  427.         dd = FF1(dd, aa, bb, cc, X[ 6],  5);
  428.         cc = FF1(cc, dd, aa, bb, X[ 4],  8);
  429.         bb = FF1(bb, cc, dd, aa, X[ 1], 11);
  430.         aa = FF1(aa, bb, cc, dd, X[ 3], 14);
  431.         dd = FF1(dd, aa, bb, cc, X[11], 14);
  432.         cc = FF1(cc, dd, aa, bb, X[15],  6);
  433.         bb = FF1(bb, cc, dd, aa, X[ 0], 14);
  434.         aa = FF1(aa, bb, cc, dd, X[ 5],  6);
  435.         dd = FF1(dd, aa, bb, cc, X[12],  9);
  436.         cc = FF1(cc, dd, aa, bb, X[ 2], 12);
  437.         bb = FF1(bb, cc, dd, aa, X[13],  9);
  438.         aa = FF1(aa, bb, cc, dd, X[ 9], 12);
  439.         dd = FF1(dd, aa, bb, cc, X[ 7],  5);
  440.         cc = FF1(cc, dd, aa, bb, X[10], 15);
  441.         bb = FF1(bb, cc, dd, aa, X[14],  8);
  443.         dd += c + H1;               // final result for H0
  445.         //
  446.         // combine the results
  447.         //
  448.         H1 = H2 + d + aa;
  449.         H2 = H3 + a + bb;
  450.         H3 = H0 + b + cc;
  451.         H0 = dd;
  453. //
  454. // reset the offset and clean out the word buffer.
  455. //
  456. xOff = 0;
  457. for (int i = 0; i != X.length; i++)
  458. {
  459. X[i] = 0;
  460. }
  461. }
  462. }