Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.digests;
  
FIPS 180-4 implementation of SHA-512/t
  
 public class SHA512tDigest
     extends LongDigest
 {
     private int digestLength;      // non-final due to old flow analyser.
 
     private long  H1tH2tH3tH4tH5tH6tH7tH8t;

    
Standard constructor
 
     public SHA512tDigest(int bitLength)
     {
         if (bitLength >= 512)
         {
             throw new IllegalArgumentException("bitLength cannot be >= 512");
         }
 
         if (bitLength % 8 != 0)
         {
             throw new IllegalArgumentException("bitLength needs to be a multiple of 8");
         }
 
         if (bitLength == 384)
         {
             throw new IllegalArgumentException("bitLength cannot be 384 use SHA384 instead");
         }
 
         this. = bitLength / 8;
 
         tIvGenerate( * 8);
 
         reset();
     }

    
Copy constructor. This will copy the state of the provided message digest.
 
     public SHA512tDigest(SHA512tDigest t)
     {
         super(t);
 
         this. = t.digestLength;
 
         reset(t);
     }
 
     public SHA512tDigest(byte[] encodedState)
     {
         this(readDigestLength(encodedState));
         restoreState(encodedState);
     }
 
     private static int readDigestLength(byte[] encodedState)
     {
         return Pack.bigEndianToInt(encodedStateencodedState.length - 4);
     }
 
     public String getAlgorithmName()
     {
         return "SHA-512/" + Integer.toString( * 8);
     }
 
     public int getDigestSize()
     {
         return ;
     }
 
     public int doFinal(
         byte[]  out,
         int     outOff)
     {
         finish();
 
         longToBigEndian(outoutOff);
         longToBigEndian(outoutOff + 8,  - 8);
         longToBigEndian(outoutOff + 16,  - 16);
         longToBigEndian(outoutOff + 24,  - 24);
         longToBigEndian(outoutOff + 32,  - 32);
         longToBigEndian(outoutOff + 40,  - 40);
         longToBigEndian(outoutOff + 48,  - 48);
         longToBigEndian(outoutOff + 56,  - 56);
 
         reset();
 
         return ;
     }

    
reset the chaining variables
    public void reset()
    {
        super.reset();
        /*
         * initial hash values use the iv generation algorithm for t.
         */
         = ;
         = ;
         = ;
         = ;
         = ;
         = ;
         = ;
         = ;
    }
    private void tIvGenerate(int bitLength)
    {
         = 0x6a09e667f3bcc908L ^ 0xa5a5a5a5a5a5a5a5L;
         = 0xbb67ae8584caa73bL ^ 0xa5a5a5a5a5a5a5a5L;
         = 0x3c6ef372fe94f82bL ^ 0xa5a5a5a5a5a5a5a5L;
         = 0xa54ff53a5f1d36f1L ^ 0xa5a5a5a5a5a5a5a5L;
         = 0x510e527fade682d1L ^ 0xa5a5a5a5a5a5a5a5L;
         = 0x9b05688c2b3e6c1fL ^ 0xa5a5a5a5a5a5a5a5L;
         = 0x1f83d9abfb41bd6bL ^ 0xa5a5a5a5a5a5a5a5L;
         = 0x5be0cd19137e2179L ^ 0xa5a5a5a5a5a5a5a5L;
        update((byte)0x53);
        update((byte)0x48);
        update((byte)0x41);
        update((byte)0x2D);
        update((byte)0x35);
        update((byte)0x31);
        update((byte)0x32);
        update((byte)0x2F);
        if (bitLength > 100)
        {
            update((byte)(bitLength / 100 + 0x30));
            bitLength = bitLength % 100;
            update((byte)(bitLength / 10 + 0x30));
            bitLength = bitLength % 10;
            update((byte)(bitLength + 0x30));
        }
        else if (bitLength > 10)
        {
            update((byte)(bitLength / 10 + 0x30));
            bitLength = bitLength % 10;
            update((byte)(bitLength + 0x30));
        }
        else
        {
            update((byte)(bitLength + 0x30));
        }
        finish();
         = ;
         = ;
         = ;
         = ;
         = ;
         = ;
         = ;
         = ;
    }
    private static void longToBigEndian(long nbyte[] bsint offint max)
    {
        if (max > 0)
        {
            intToBigEndian((int)(n >>> 32), bsoffmax);
            if (max > 4)
            {
                intToBigEndian((int)(n & 0xffffffffL), bsoff + 4, max - 4);
            }
        }
    }
    private static void intToBigEndian(int nbyte[] bsint offint max)
    {
        int num = Math.min(4, max);
        while (--num >= 0)
        {
            int shift = 8 * (3 - num);
            bs[off + num] = (byte)(n >>> shift);
        }
    }
    public Memoable copy()
    {
        return new SHA512tDigest(this);
    }
    public void reset(Memoable other)
    {
        SHA512tDigest t = (SHA512tDigest)other;
        if (this. != t.digestLength)
        {
            throw new MemoableResetException("digestLength inappropriate in other");
        }
        super.copyIn(t);
        this. = t.H1t;
        this. = t.H2t;
        this. = t.H3t;
        this. = t.H4t;
        this. = t.H5t;
        this. = t.H6t;
        this. = t.H7t;
        this. = t.H8t;
    }
    public byte[] getEncodedState()
    {
        final int baseSize = getEncodedStateSize();
        byte[] encoded = new byte[baseSize + 4];
        populateState(encoded);
        Pack.intToBigEndian( * 8, encodedbaseSize);
        return encoded;
    }
New to GrepCode? Check out our FAQ X