Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.digests;
  
  
implementation of MD4 as RFC 1320 by R. Rivest, MIT Laboratory for Computer Science and RSA Data Security, Inc.

NOTE: This algorithm is only included for backwards compatability with legacy applications, it's not secure, don't use it for anything new!

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

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

    
Copy constructor. This will copy the state of the provided message digest.
 
     public MD4Digest(MD4Digest t)
     {
         super(t);
 
         copyIn(t);
     }
 
     private void copyIn(MD4Digest t)
     {
         super.copyIn(t);
 
          = t.H1;
          = t.H2;
          = t.H3;
          = t.H4;
 
         System.arraycopy(t.X, 0, , 0, t.X.length);
          = t.xOff;
     }
 
     public String getAlgorithmName()
     {
         return "MD4";
     }
 
     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);
        reset();
        return ;
    }

    
reset the chaining variables to the IV values.
    public void reset()
    {
        super.reset();
         = 0x67452301;
         = 0xefcdab89;
         = 0x98badcfe;
         = 0x10325476;
         = 0;
        for (int i = 0; i != .i++)
        {
            [i] = 0;
        }
    }
    //
    // round 1 left rotates
    //
    private static final int S11 = 3;
    private static final int S12 = 7;
    private static final int S13 = 11;
    private static final int S14 = 19;
    //
    // round 2 left rotates
    //
    private static final int S21 = 3;
    private static final int S22 = 5;
    private static final int S23 = 9;
    private static final int S24 = 13;
    //
    // round 3 left rotates
    //
    private static final int S31 = 3;
    private static final int S32 = 9;
    private static final int S33 = 11;
    private static final int S34 = 15;
    /*
     * rotate int x left n bits.
     */
    private int rotateLeft(
        int x,
        int n)
    {
        return (x << n) | (x >>> (32 - n));
    }
    /*
     * F, G, H and I are the basic MD4 functions.
     */
    private int F(
        int u,
        int v,
        int w)
    {
        return (u & v) | (~u & w);
    }
    private int G(
        int u,
        int v,
        int w)
    {
        return (u & v) | (u & w) | (v & w);
    }
    private int H(
        int u,
        int v,
        int w)
    {
        return u ^ v ^ w;
    }
    protected void processBlock()
    {
        int a = ;
        int b = ;
        int c = ;
        int d = ;
        //
        // Round 1 - F cycle, 16 times.
        //
        a = rotateLeft(a + F(bcd) + [ 0], );
        d = rotateLeft(d + F(abc) + [ 1], );
        c = rotateLeft(c + F(dab) + [ 2], );
        b = rotateLeft(b + F(cda) + [ 3], );
        a = rotateLeft(a + F(bcd) + [ 4], );
        d = rotateLeft(d + F(abc) + [ 5], );
        c = rotateLeft(c + F(dab) + [ 6], );
        b = rotateLeft(b + F(cda) + [ 7], );
        a = rotateLeft(a + F(bcd) + [ 8], );
        d = rotateLeft(d + F(abc) + [ 9], );
        c = rotateLeft(c + F(dab) + [10], );
        b = rotateLeft(b + F(cda) + [11], );
        a = rotateLeft(a + F(bcd) + [12], );
        d = rotateLeft(d + F(abc) + [13], );
        c = rotateLeft(c + F(dab) + [14], );
        b = rotateLeft(b + F(cda) + [15], );
        //
        // Round 2 - G cycle, 16 times.
        //
        a = rotateLeft(a + G(bcd) + [ 0] + 0x5a827999, );
        d = rotateLeft(d + G(abc) + [ 4] + 0x5a827999, );
        c = rotateLeft(c + G(dab) + [ 8] + 0x5a827999, );
        b = rotateLeft(b + G(cda) + [12] + 0x5a827999, );
        a = rotateLeft(a + G(bcd) + [ 1] + 0x5a827999, );
        d = rotateLeft(d + G(abc) + [ 5] + 0x5a827999, );
        c = rotateLeft(c + G(dab) + [ 9] + 0x5a827999, );
        b = rotateLeft(b + G(cda) + [13] + 0x5a827999, );
        a = rotateLeft(a + G(bcd) + [ 2] + 0x5a827999, );
        d = rotateLeft(d + G(abc) + [ 6] + 0x5a827999, );
        c = rotateLeft(c + G(dab) + [10] + 0x5a827999, );
        b = rotateLeft(b + G(cda) + [14] + 0x5a827999, );
        a = rotateLeft(a + G(bcd) + [ 3] + 0x5a827999, );
        d = rotateLeft(d + G(abc) + [ 7] + 0x5a827999, );
        c = rotateLeft(c + G(dab) + [11] + 0x5a827999, );
        b = rotateLeft(b + G(cda) + [15] + 0x5a827999, );
        //
        // Round 3 - H cycle, 16 times.
        //
        a = rotateLeft(a + H(bcd) + [ 0] + 0x6ed9eba1, );
        d = rotateLeft(d + H(abc) + [ 8] + 0x6ed9eba1, );
        c = rotateLeft(c + H(dab) + [ 4] + 0x6ed9eba1, );
        b = rotateLeft(b + H(cda) + [12] + 0x6ed9eba1, );
        a = rotateLeft(a + H(bcd) + [ 2] + 0x6ed9eba1, );
        d = rotateLeft(d + H(abc) + [10] + 0x6ed9eba1, );
        c = rotateLeft(c + H(dab) + [ 6] + 0x6ed9eba1, );
        b = rotateLeft(b + H(cda) + [14] + 0x6ed9eba1, );
        a = rotateLeft(a + H(bcd) + [ 1] + 0x6ed9eba1, );
        d = rotateLeft(d + H(abc) + [ 9] + 0x6ed9eba1, );
        c = rotateLeft(c + H(dab) + [ 5] + 0x6ed9eba1, );
        b = rotateLeft(b + H(cda) + [13] + 0x6ed9eba1, );
        a = rotateLeft(a + H(bcd) + [ 3] + 0x6ed9eba1, );
        d = rotateLeft(d + H(abc) + [11] + 0x6ed9eba1, );
        c = rotateLeft(c + H(dab) + [ 7] + 0x6ed9eba1, );
        b = rotateLeft(b + H(cda) + [15] + 0x6ed9eba1, );
         += a;
         += b;
         += c;
         += d;
        //
        // reset the offset and clean out the word buffer.
        //
         = 0;
        for (int i = 0; i != .i++)
        {
            [i] = 0;
        }
    }
    public Memoable copy()
    {
        return new MD4Digest(this);
    }
    public void reset(Memoable other)
    {
        MD4Digest d = (MD4Digest)other;
        copyIn(d);
    }
New to GrepCode? Check out our FAQ X