Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.digests;
  
  
implementation of RIPEMD256.

note: this algorithm offers the same level of security as RIPEMD128.

 
 public class RIPEMD256Digest
     extends GeneralDigest
 {
     private static final int DIGEST_LENGTH = 32;
 
     private int H0H1H2H3H4H5H6H7// IV's
 
     private int[] X = new int[16];
     private int xOff;

    
Standard constructor
 
     public RIPEMD256Digest()
     {
         reset();
     }

    
Copy constructor. This will copy the state of the provided message digest.
 
     public RIPEMD256Digest(RIPEMD256Digest t)
     {
         super(t);
 
         copyIn(t);
     }
 
     private void copyIn(RIPEMD256Digest t)
     {
         super.copyIn(t);
 
          = t.H0;
          = t.H1;
          = t.H2;
          = t.H3;
          = t.H4;
          = t.H5;
          = t.H6;
          = t.H7;
 
         System.arraycopy(t.X, 0, , 0, t.X.length);
          = t.xOff;
     }
 
     public String getAlgorithmName()
     {
         return "RIPEMD256";
     }
 
     public int getDigestSize()
     {
         return ;
     }
 
     protected void processWord(
         byte[] in,
         int inOff)
     {
         [++] = (in[inOff] & 0xff) | ((in[inOff + 1] & 0xff) << 8)
             | ((in[inOff + 2] & 0xff) << 16) | ((in[inOff + 3] & 0xff) << 24); 
 
         if ( == 16)
         {
             processBlock();
         }
     }
 
     protected void processLength(
         long bitLength)
     {
         if ( > 14)
         {
             processBlock();
         }
 
         [14] = (int)(bitLength & 0xffffffff);
         [15] = (int)(bitLength >>> 32);
     }
 
     private void unpackWord(
         int word,
         byte[] out,
         int outOff)
     {
         out[outOff]     = (byte)word;
         out[outOff + 1] = (byte)(word >>> 8);
         out[outOff + 2] = (byte)(word >>> 16);
        out[outOff + 3] = (byte)(word >>> 24);
    }
    public int doFinal(
        byte[] out,
        int outOff)
    {
        finish();
        unpackWord(outoutOff);
        unpackWord(outoutOff + 4);
        unpackWord(outoutOff + 8);
        unpackWord(outoutOff + 12);
        unpackWord(outoutOff + 16);
        unpackWord(outoutOff + 20);
        unpackWord(outoutOff + 24);
        unpackWord(outoutOff + 28);
        reset();
        return ;
    }

    
reset the chaining variables to the IV values.
    public void reset()
    {
        super.reset();
         = 0x67452301;
         = 0xefcdab89;
         = 0x98badcfe;
         = 0x10325476; 
         = 0x76543210; 
         = 0xFEDCBA98; 
         = 0x89ABCDEF; 
         = 0x01234567;
        
         = 0;
        for (int i = 0; i != .i++)
        {
            [i] = 0;
        }
    }
    /*
     * rotate int x left n bits.
     */
    private int RL(
        int x,
        int n)
    {
        return (x << n) | (x >>> (32 - n));
    }
    /*
     * f1,f2,f3,f4 are the basic RIPEMD128 functions.
     */
    /*
     * F
     */
    private int f1(
        int x,
        int y,
        int z)
    {
        return x ^ y ^ z;
    }
    /*
     * G
     */
    private int f2(
        int x,
        int y,
        int z)
    {
        return (x & y) | (~x & z);
    }
    /*
     * H
     */
    private int f3(
        int x,
        int y,
        int z)
    {
        return (x | ~y) ^ z;
    }
    /*
     * I
     */
    private int f4(
        int x,
        int y,
        int z)
    {
        return (x & z) | (y & ~z);
    }
    private int F1(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
        return RL(a + f1(bcd) + xs);
    }
    private int F2(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
        return RL(a + f2(bcd) + x + 0x5a827999, s);
    }
    private int F3(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
        return RL(a + f3(bcd) + x + 0x6ed9eba1, s);
    }
    private int F4(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
        return RL(a + f4(bcd) + x + 0x8f1bbcdc, s);
    }
    private int FF1(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
        return RL(a + f1(bcd) + xs);
    }
    private int FF2(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
      return RL(a + f2(bcd) + x + 0x6d703ef3, s);
    }
    private int FF3(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
      return RL(a + f3(bcd) + x + 0x5c4dd124, s);
    }
    private int FF4(
        int a,
        int b,
        int c,
        int d,
        int x,
        int s)
    {
      return RL(a + f4(bcd) + x + 0x50a28be6, s);
    }
    protected void processBlock()
    {
        int aaa;
        int bbb;
        int ccc;
        int ddd;
        int t;
        
        a = ;
        b = ;
        c = ;
        d = ;
        aa = ;
        bb = ;
        cc = ;
        dd = ;
        //
        // Round 1
        //
        
        a = F1(abcd[ 0], 11);
        d = F1(dabc[ 1], 14);
        c = F1(cdab[ 2], 15);
        b = F1(bcda[ 3], 12);
        a = F1(abcd[ 4],  5);
        d = F1(dabc[ 5],  8);
        c = F1(cdab[ 6],  7);
        b = F1(bcda[ 7],  9);
        a = F1(abcd[ 8], 11);
        d = F1(dabc[ 9], 13);
        c = F1(cdab[10], 14);
        b = F1(bcda[11], 15);
        a = F1(abcd[12],  6);
        d = F1(dabc[13],  7);
        c = F1(cdab[14],  9);
        b = F1(bcda[15],  8);
        aa = FF4(aabbccdd[ 5],  8);
        dd = FF4(ddaabbcc[14],  9);
        cc = FF4(ccddaabb[ 7],  9);
        bb = FF4(bbccddaa[ 0], 11);
        aa = FF4(aabbccdd[ 9], 13);
        dd = FF4(ddaabbcc[ 2], 15);
        cc = FF4(ccddaabb[11], 15);
        bb = FF4(bbccddaa[ 4],  5);
        aa = FF4(aabbccdd[13],  7);
        dd = FF4(ddaabbcc[ 6],  7);
        cc = FF4(ccddaabb[15],  8);
        bb = FF4(bbccddaa[ 8], 11);
        aa = FF4(aabbccdd[ 1], 14);
        dd = FF4(ddaabbcc[10], 14);
        cc = FF4(ccddaabb[ 3], 12);
        bb = FF4(bbccddaa[12],  6);
        t = aa = aaaa = t;
        
        //
        // Round 2
        //
        a = F2(abcd[ 7],  7);
        d = F2(dabc[ 4],  6);
        c = F2(cdab[13],  8);
        b = F2(bcda[ 1], 13);
        a = F2(abcd[10], 11);
        d = F2(dabc[ 6],  9);
        c = F2(cdab[15],  7);
        b = F2(bcda[ 3], 15);
        a = F2(abcd[12],  7);
        d = F2(dabc[ 0], 12);
        c = F2(cdab[ 9], 15);
        b = F2(bcda[ 5],  9);
        a = F2(abcd[ 2], 11);
        d = F2(dabc[14],  7);
        c = F2(cdab[11], 13);
        b = F2(bcda[ 8], 12);
        aa = FF3(aabbccdd[ 6],  9);
        dd = FF3(ddaabbcc[ 11], 13);
        cc = FF3(ccddaabb[3], 15);
        bb = FF3(bbccddaa[ 7],  7);
        aa = FF3(aabbccdd[0], 12);
        dd = FF3(ddaabbcc[13],  8);
        cc = FF3(ccddaabb[5],  9);
        bb = FF3(bbccddaa[10], 11);
        aa = FF3(aabbccdd[14],  7);
        dd = FF3(ddaabbcc[15],  7);
        cc = FF3(ccddaabb[ 8], 12);
        bb = FF3(bbccddaa[12],  7);
        aa = FF3(aabbccdd[ 4],  6);
        dd = FF3(ddaabbcc[ 9], 15);
        cc = FF3(ccddaabb[ 1], 13);
        bb = FF3(bbccddaa[ 2], 11);
        t = bb = bbbb = t;
        
        //
        // Round 3
        //
        a = F3(abcd[ 3], 11);
        d = F3(dabc[10], 13);
        c = F3(cdab[14],  6);
        b = F3(bcda[ 4],  7);
        a = F3(abcd[ 9], 14);
        d = F3(dabc[15],  9);
        c = F3(cdab[ 8], 13);
        b = F3(bcda[ 1], 15);
        a = F3(abcd[ 2], 14);
        d = F3(dabc[ 7],  8);
        c = F3(cdab[ 0], 13);
        b = F3(bcda[ 6],  6);
        a = F3(abcd[13],  5);
        d = F3(dabc[11], 12);
        c = F3(cdab[ 5],  7);
        b = F3(bcda[12],  5);
        aa = FF2(aabbccdd[ 15], 9);
        dd = FF2(ddaabbcc[5], 7);
        cc = FF2(ccddaabb[1], 15);
        bb = FF2(bbccddaa[ 3],  11);
        aa = FF2(aabbccdd[ 7], 8);
        dd = FF2(ddaabbcc[14],  6);
        cc = FF2(ccddaabb[ 6], 6);
        bb = FF2(bbccddaa[ 9], 14);
        aa = FF2(aabbccdd[11], 12);
        dd = FF2(ddaabbcc[ 8], 13);
        cc = FF2(ccddaabb[12],  5);
        bb = FF2(bbccddaa[ 2], 14);
        aa = FF2(aabbccdd[10], 13);
        dd = FF2(ddaabbcc[ 0], 13);
        cc = FF2(ccddaabb[ 4],  7);
        bb = FF2(bbccddaa[13],  5);
        t = cc = cccc = t;
        //
        // Round 4
        //
        a = F4(abcd[ 1], 11);
        d = F4(dabc[ 9], 12);
        c = F4(cdab[11], 14);
        b = F4(bcda[10], 15);
        a = F4(abcd[ 0], 14);
        d = F4(dabc[ 8], 15);
        c = F4(cdab[12],  9);
        b = F4(bcda[ 4],  8);
        a = F4(abcd[13],  9);
        d = F4(dabc[ 3], 14);
        c = F4(cdab[ 7],  5);
        b = F4(bcda[15],  6);
        a = F4(abcd[14],  8);
        d = F4(dabc[ 5],  6);
        c = F4(cdab[ 6],  5);
        b = F4(bcda[ 2], 12);
        aa = FF1(aabbccdd[ 8], 15);
        dd = FF1(ddaabbcc[ 6],  5);
        cc = FF1(ccddaabb[ 4],  8);
        bb = FF1(bbccddaa[ 1], 11);
        aa = FF1(aabbccdd[ 3], 14);
        dd = FF1(ddaabbcc[11], 14);
        cc = FF1(ccddaabb[15],  6);
        bb = FF1(bbccddaa[ 0], 14);
        aa = FF1(aabbccdd[ 5],  6);
        dd = FF1(ddaabbcc[12],  9);
        cc = FF1(ccddaabb[ 2],  12);
        bb = FF1(bbccddaa[13],  9);
        aa = FF1(aabbccdd[ 9],  12);
        dd = FF1(ddaabbcc[ 7],  5);
        cc = FF1(ccddaabb[10],  15);
        bb = FF1(bbccddaa[14], 8);
        t = dd = dddd = t;
         += a
         += b
         += c
         += d;
         += aa
         += bb
         += cc
         += dd;
        
        //
        // reset the offset and clean out the word buffer.
        //
         = 0;
        for (int i = 0; i != .i++)
        {
            [i] = 0;
        }
    }
    public Memoable copy()
    {
        return new RIPEMD256Digest(this);
    }
    public void reset(Memoable other)
    {
        RIPEMD256Digest d = (RIPEMD256Digest)other;
        copyIn(d);
    }
New to GrepCode? Check out our FAQ X