Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.digests;
  
Implementation of Chinese SM3 digest as described at http://tools.ietf.org/html/draft-shen-sm3-hash-00 and at .... ( Chinese PDF )

The specification says "process a bit stream", but this is written to process bytes in blocks of 4, meaning this will process 32-bit word groups. But so do also most other digest specifications, including the SHA-256 which was a origin for this specification.

 
 public class SM3Digest
     extends GeneralDigest
 {
     private static final int DIGEST_LENGTH = 32;   // bytes
     private static final int BLOCK_SIZE = 64 / 4; // of 32 bit ints (16 ints)
 
     private int[] V = new int[ / 4]; // in 32 bit ints (8 ints)
     private int[] inwords = new int[];
     private int xOff;
 
     // Work-bufs used within processBlock()
     private int[] W = new int[68];
     private int[] W1 = new int[64];
 
     // Round constant T for processBlock() which is 32 bit integer rolled left up to (63 MOD 32) bit positions.
     private static final int[] T = new int[64];
 
     static
     {
         for (int i = 0; i < 16; ++i)
         {
             int t = 0x79CC4519;
             [i] = (t << i) | (t >>> (32 - i));
         }
         for (int i = 16; i < 64; ++i)
         {
             int n = i % 32;
             int t = 0x7A879D8A;
             [i] = (t << n) | (t >>> (32 - n));
         }
     }


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

    
Copy constructor. This will copy the state of the provided message digest.
 
     public SM3Digest(SM3Digest t)
     {
         super(t);
 
         copyIn(t);
     }
 
     private void copyIn(SM3Digest t)
     {
         System.arraycopy(t.V, 0, this., 0, this..length);
         System.arraycopy(t.inwords, 0, this., 0, this..length);
          = t.xOff;
     }
 
     public String getAlgorithmName()
     {
         return "SM3";
     }
 
     public int getDigestSize()
     {
         return ;
     }
 
 
     public Memoable copy()
     {
         return new SM3Digest(this);
     }
 
     public void reset(Memoable other)
     {
         SM3Digest d = (SM3Digest)other;
 
         super.copyIn(d);
         copyIn(d);
     }


    
reset the chaining variables
    public void reset()
    {
        super.reset();
        this.[0] = 0x7380166F;
        this.[1] = 0x4914B2B9;
        this.[2] = 0x172442D7;
        this.[3] = 0xDA8A0600;
        this.[4] = 0xA96F30BC;
        this.[5] = 0x163138AA;
        this.[6] = 0xE38DEE4D;
        this.[7] = 0xB0FB0E4E;
        this. = 0;
    }
    public int doFinal(byte[] out,
                       int outOff)
    {
        finish();
        Pack.intToBigEndian(this.[0], outoutOff + 0);
        Pack.intToBigEndian(this.[1], outoutOff + 4);
        Pack.intToBigEndian(this.[2], outoutOff + 8);
        Pack.intToBigEndian(this.[3], outoutOff + 12);
        Pack.intToBigEndian(this.[4], outoutOff + 16);
        Pack.intToBigEndian(this.[5], outoutOff + 20);
        Pack.intToBigEndian(this.[6], outoutOff + 24);
        Pack.intToBigEndian(this.[7], outoutOff + 28);
        reset();
        return ;
    }
    protected void processWord(byte[] in,
                               int inOff)
    {
        // Note: Inlined for performance
        // this.inwords[xOff] = Pack.bigEndianToInt(in, inOff);
        int n = (((in[inOff] & 0xff) << 24) |
            ((in[++inOff] & 0xff) << 16) |
            ((in[++inOff] & 0xff) << 8) |
            ((in[++inOff] & 0xff)));
        this.[this.] = n;
        ++this.;
        if (this. >= 16)
        {
            processBlock();
        }
    }
    protected void processLength(long bitLength)
    {
        if (this. > ( - 2))
        {
            // xOff == 15  --> can't fit the 64 bit length field at tail..
            this.[this.] = 0; // fill with zero
            ++this.;
            processBlock();
        }
        // Fill with zero words, until reach 2nd to last slot
        while (this. < ( - 2))
        {
            this.[this.] = 0;
            ++this.;
        }
        // Store input data length in BITS
        this.[this.++] = (int)(bitLength >>> 32);
        this.[this.++] = (int)(bitLength);
    }
/*
3.4.2.  Constants
   Tj = 79cc4519        when 0  < = j < = 15
   Tj = 7a879d8a        when 16 < = j < = 63
3.4.3.  Boolean function
   FFj(X;Y;Z) = X XOR Y XOR Z                       when 0  < = j < = 15
              = (X AND Y) OR (X AND Z) OR (Y AND Z) when 16 < = j < = 63
   GGj(X;Y;Z) = X XOR Y XOR Z                       when 0  < = j < = 15
              = (X AND Y) OR (NOT X AND Z)          when 16 < = j < = 63
   The X, Y, Z in the fomular are words!GBP
3.4.4.  Permutation function
   P0(X) = X XOR (X <<<  9) XOR (X <<< 17)   ## ROLL, not SHIFT
   P1(X) = X XOR (X <<< 15) XOR (X <<< 23)   ## ROLL, not SHIFT
   The X in the fomular are a word.
----------
Each ROLL converted to Java expression:
ROLL 9  :  ((x <<  9) | (x >>> (32-9))))
ROLL 17 :  ((x << 17) | (x >>> (32-17)))
ROLL 15 :  ((x << 15) | (x >>> (32-15)))
ROLL 23 :  ((x << 23) | (x >>> (32-23)))
 */
    private int P0(final int x)
    {
        final int r9 = ((x << 9) | (x >>> (32 - 9)));
        final int r17 = ((x << 17) | (x >>> (32 - 17)));
        return (x ^ r9 ^ r17);
    }
    private int P1(final int x)
    {
        final int r15 = ((x << 15) | (x >>> (32 - 15)));
        final int r23 = ((x << 23) | (x >>> (32 - 23)));
        return (x ^ r15 ^ r23);
    }
    private int FF0(final int xfinal int yfinal int z)
    {
        return (x ^ y ^ z);
    }
    private int FF1(final int xfinal int yfinal int z)
    {
        return ((x & y) | (x & z) | (y & z));
    }
    private int GG0(final int xfinal int yfinal int z)
    {
        return (x ^ y ^ z);
    }
    private int GG1(final int xfinal int yfinal int z)
    {
        return ((x & y) | ((~x) & z));
    }
    protected void processBlock()
    {
        for (int j = 0; j < 16; ++j)
        {
            this.[j] = this.[j];
        }
        for (int j = 16; j < 68; ++j)
        {
            int wj3 = this.[j - 3];
            int r15 = ((wj3 << 15) | (wj3 >>> (32 - 15)));
            int wj13 = this.[j - 13];
            int r7 = ((wj13 << 7) | (wj13 >>> (32 - 7)));
            this.[j] = P1(this.[j - 16] ^ this.[j - 9] ^ r15) ^ r7 ^ this.[j - 6];
        }
        for (int j = 0; j < 64; ++j)
        {
            this.[j] = this.[j] ^ this.[j + 4];
        }
        int A = this.[0];
        int B = this.[1];
        int C = this.[2];
        int D = this.[3];
        int E = this.[4];
        int F = this.[5];
        int G = this.[6];
        int H = this.[7];
        for (int j = 0; j < 16; ++j)
        {
            int a12 = ((A << 12) | (A >>> (32 - 12)));
            int s1_ = a12 + E + [j];
            int SS1 = ((s1_ << 7) | (s1_ >>> (32 - 7)));
            int SS2 = SS1 ^ a12;
            int TT1 = FF0(ABC) + D + SS2 + this.[j];
            int TT2 = GG0(EFG) + H + SS1 + this.[j];
            D = C;
            C = ((B << 9) | (B >>> (32 - 9)));
            B = A;
            A = TT1;
            H = G;
            G = ((F << 19) | (F >>> (32 - 19)));
            F = E;
            E = P0(TT2);
        }
        // Different FF,GG functions on rounds 16..63
        for (int j = 16; j < 64; ++j)
        {
            int a12 = ((A << 12) | (A >>> (32 - 12)));
            int s1_ = a12 + E + [j];
            int SS1 = ((s1_ << 7) | (s1_ >>> (32 - 7)));
            int SS2 = SS1 ^ a12;
            int TT1 = FF1(ABC) + D + SS2 + this.[j];
            int TT2 = GG1(EFG) + H + SS1 + this.[j];
            D = C;
            C = ((B << 9) | (B >>> (32 - 9)));
            B = A;
            A = TT1;
            H = G;
            G = ((F << 19) | (F >>> (32 - 19)));
            F = E;
            E = P0(TT2);
        }
        this.[0] ^= A;
        this.[1] ^= B;
        this.[2] ^= C;
        this.[3] ^= D;
        this.[4] ^= E;
        this.[5] ^= F;
        this.[6] ^= G;
        this.[7] ^= H;
        this. = 0;
    }
New to GrepCode? Check out our FAQ X