Class Sha256Hash

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Sha256Hash>

    public class Sha256Hash
    extends java.lang.Object
    implements java.io.Serializable, java.lang.Comparable<Sha256Hash>
    A Sha256Hash wraps a byte[] so that equals(java.lang.Object) and hashCode() work correctly, allowing it to be used as a key in a map. It also checks that the length is correct (equal to LENGTH) and provides a bit more type safety.

    Given that Sha256Hash instances can be created using wrapReversed(byte[]) or twiceOf(byte[]) or by wrapping raw bytes, there is no guarantee that if two Sha256Hash instances are found equal (via equals(Object)) that their preimages would be the same (even in the absence of a hash collision.)

    See Also:
    Serialized Form
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      int compareTo​(Sha256Hash other)  
      boolean equals​(java.lang.Object o)  
      byte[] getBytes()
      Returns the internal byte array, without defensively copying.
      byte[] getReversedBytes()
      Returns a reversed copy of the internal byte array.
      static byte[] hash​(byte[] input)
      Calculates the SHA-256 hash of the given bytes.
      static byte[] hash​(byte[] input, int offset, int length)
      Calculates the SHA-256 hash of the given byte range.
      int hashCode()
      Returns the last four bytes of the wrapped hash.
      static byte[] hashTwice​(byte[] input)
      Calculates the SHA-256 hash of the given bytes, and then hashes the resulting hash again.
      static byte[] hashTwice​(byte[] input1, byte[] input2)
      Calculates the hash of hash on the given chunks of bytes.
      static byte[] hashTwice​(byte[] input, int offset, int length)
      Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again.
      static byte[] hashTwice​(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2)
      Calculates the hash of hash on the given byte ranges.
      static java.security.MessageDigest newDigest()
      Returns a new SHA-256 MessageDigest instance.
      static Sha256Hash of​(byte[] contents)
      Creates a new instance containing the calculated (one-time) hash of the given bytes.
      static Sha256Hash of​(java.io.File file)
      Creates a new instance containing the calculated (one-time) hash of the given file's contents.
      java.math.BigInteger toBigInteger()
      Returns the bytes interpreted as a positive integer.
      java.lang.String toString()  
      static Sha256Hash twiceOf​(byte[] contents)
      Creates a new instance containing the hash of the calculated hash of the given bytes.
      static Sha256Hash twiceOf​(byte[] content1, byte[] content2)
      Creates a new instance containing the hash of the calculated hash of the given bytes.
      static Sha256Hash wrap​(byte[] rawHashBytes)
      Creates a new instance that wraps the given hash value.
      static Sha256Hash wrap​(java.lang.String hexString)
      Creates a new instance that wraps the given hash value (represented as a hex string).
      static Sha256Hash wrapReversed​(byte[] rawHashBytes)
      Creates a new instance that wraps the given hash value, but with byte order reversed.
      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, wait, wait, wait
    • Method Detail

      • wrap

        public static Sha256Hash wrap​(byte[] rawHashBytes)
        Creates a new instance that wraps the given hash value.
        Parameters:
        rawHashBytes - the raw hash bytes to wrap
        Returns:
        a new instance
        Throws:
        java.lang.IllegalArgumentException - if the given array length is not exactly 32
      • wrap

        public static Sha256Hash wrap​(java.lang.String hexString)
        Creates a new instance that wraps the given hash value (represented as a hex string).
        Parameters:
        hexString - a hash value represented as a hex string
        Returns:
        a new instance
        Throws:
        java.lang.IllegalArgumentException - if the given string is not a valid hex string, or if it does not represent exactly 32 bytes
      • wrapReversed

        public static Sha256Hash wrapReversed​(byte[] rawHashBytes)
        Creates a new instance that wraps the given hash value, but with byte order reversed.
        Parameters:
        rawHashBytes - the raw hash bytes to wrap
        Returns:
        a new instance
        Throws:
        java.lang.IllegalArgumentException - if the given array length is not exactly 32
      • of

        public static Sha256Hash of​(byte[] contents)
        Creates a new instance containing the calculated (one-time) hash of the given bytes.
        Parameters:
        contents - the bytes on which the hash value is calculated
        Returns:
        a new instance containing the calculated (one-time) hash
      • twiceOf

        public static Sha256Hash twiceOf​(byte[] contents)
        Creates a new instance containing the hash of the calculated hash of the given bytes.
        Parameters:
        contents - the bytes on which the hash value is calculated
        Returns:
        a new instance containing the calculated (two-time) hash
      • twiceOf

        public static Sha256Hash twiceOf​(byte[] content1,
                                         byte[] content2)
        Creates a new instance containing the hash of the calculated hash of the given bytes.
        Parameters:
        content1 - first bytes on which the hash value is calculated
        content2 - second bytes on which the hash value is calculated
        Returns:
        a new instance containing the calculated (two-time) hash
      • of

        public static Sha256Hash of​(java.io.File file)
                             throws java.io.IOException
        Creates a new instance containing the calculated (one-time) hash of the given file's contents. The file contents are read fully into memory, so this method should only be used with small files.
        Parameters:
        file - the file on which the hash value is calculated
        Returns:
        a new instance containing the calculated (one-time) hash
        Throws:
        java.io.IOException - if an error occurs while reading the file
      • newDigest

        public static java.security.MessageDigest newDigest()
        Returns a new SHA-256 MessageDigest instance. This is a convenience method which wraps the checked exception that can never occur with a RuntimeException.
        Returns:
        a new SHA-256 MessageDigest instance
      • hash

        public static byte[] hash​(byte[] input)
        Calculates the SHA-256 hash of the given bytes.
        Parameters:
        input - the bytes to hash
        Returns:
        the hash (in big-endian order)
      • hash

        public static byte[] hash​(byte[] input,
                                  int offset,
                                  int length)
        Calculates the SHA-256 hash of the given byte range.
        Parameters:
        input - the array containing the bytes to hash
        offset - the offset within the array of the bytes to hash
        length - the number of bytes to hash
        Returns:
        the hash (in big-endian order)
      • hashTwice

        public static byte[] hashTwice​(byte[] input)
        Calculates the SHA-256 hash of the given bytes, and then hashes the resulting hash again.
        Parameters:
        input - the bytes to hash
        Returns:
        the double-hash (in big-endian order)
      • hashTwice

        public static byte[] hashTwice​(byte[] input1,
                                       byte[] input2)
        Calculates the hash of hash on the given chunks of bytes. This is equivalent to concatenating the two chunks and then passing the result to hashTwice(byte[]).
      • hashTwice

        public static byte[] hashTwice​(byte[] input,
                                       int offset,
                                       int length)
        Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again.
        Parameters:
        input - the array containing the bytes to hash
        offset - the offset within the array of the bytes to hash
        length - the number of bytes to hash
        Returns:
        the double-hash (in big-endian order)
      • hashTwice

        public static byte[] hashTwice​(byte[] input1,
                                       int offset1,
                                       int length1,
                                       byte[] input2,
                                       int offset2,
                                       int length2)
        Calculates the hash of hash on the given byte ranges. This is equivalent to concatenating the two ranges and then passing the result to hashTwice(byte[]).
      • equals

        public boolean equals​(java.lang.Object o)
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Returns the last four bytes of the wrapped hash. This should be unique enough to be a suitable hash code even for blocks, where the goal is to try and get the first bytes to be zeros (i.e. the value as a big integer lower than the target value).
        Overrides:
        hashCode in class java.lang.Object
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • toBigInteger

        public java.math.BigInteger toBigInteger()
        Returns the bytes interpreted as a positive integer.
      • getBytes

        public byte[] getBytes()
        Returns the internal byte array, without defensively copying. Therefore do NOT modify the returned array.
      • getReversedBytes

        public byte[] getReversedBytes()
        Returns a reversed copy of the internal byte array.
      • compareTo

        public int compareTo​(Sha256Hash other)
        Specified by:
        compareTo in interface java.lang.Comparable<Sha256Hash>