sha512.go

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package sha512 implements the SHA-384, SHA-512, SHA-512/224, and SHA-512/256
     6  // hash algorithms as defined in FIPS 180-4.
     7  //
     8  // All the hash.Hash implementations returned by this package also
     9  // implement encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to
    10  // marshal and unmarshal the internal state of the hash.
    11  package sha512
    12  
    13  import (
    14  	"crypto"
    15  	"crypto/internal/boring"
    16  	"crypto/internal/fips/sha512"
    17  	"hash"
    18  )
    19  
    20  func init() {
    21  	crypto.RegisterHash(crypto.SHA384, New384)
    22  	crypto.RegisterHash(crypto.SHA512, New)
    23  	crypto.RegisterHash(crypto.SHA512_224, New512_224)
    24  	crypto.RegisterHash(crypto.SHA512_256, New512_256)
    25  }
    26  
    27  const (
    28  	// Size is the size, in bytes, of a SHA-512 checksum.
    29  	Size = 64
    30  
    31  	// Size224 is the size, in bytes, of a SHA-512/224 checksum.
    32  	Size224 = 28
    33  
    34  	// Size256 is the size, in bytes, of a SHA-512/256 checksum.
    35  	Size256 = 32
    36  
    37  	// Size384 is the size, in bytes, of a SHA-384 checksum.
    38  	Size384 = 48
    39  
    40  	// BlockSize is the block size, in bytes, of the SHA-512/224,
    41  	// SHA-512/256, SHA-384 and SHA-512 hash functions.
    42  	BlockSize = 128
    43  )
    44  
    45  // New returns a new [hash.Hash] computing the SHA-512 checksum. The Hash
    46  // also implements [encoding.BinaryMarshaler], [encoding.BinaryAppender] and
    47  // [encoding.BinaryUnmarshaler] to marshal and unmarshal the internal
    48  // state of the hash.
    49  func New() hash.Hash {
    50  	if boring.Enabled {
    51  		return boring.NewSHA512()
    52  	}
    53  	return sha512.New()
    54  }
    55  
    56  // New512_224 returns a new [hash.Hash] computing the SHA-512/224 checksum. The Hash
    57  // also implements [encoding.BinaryMarshaler], [encoding.BinaryAppender] and
    58  // [encoding.BinaryUnmarshaler] to marshal and unmarshal the internal
    59  // state of the hash.
    60  func New512_224() hash.Hash {
    61  	return sha512.New512_224()
    62  }
    63  
    64  // New512_256 returns a new [hash.Hash] computing the SHA-512/256 checksum. The Hash
    65  // also implements [encoding.BinaryMarshaler], [encoding.BinaryAppender] and
    66  // [encoding.BinaryUnmarshaler] to marshal and unmarshal the internal
    67  // state of the hash.
    68  func New512_256() hash.Hash {
    69  	return sha512.New512_256()
    70  }
    71  
    72  // New384 returns a new [hash.Hash] computing the SHA-384 checksum. The Hash
    73  // also implements [encoding.BinaryMarshaler], [encoding.AppendBinary] and
    74  // [encoding.BinaryUnmarshaler] to marshal and unmarshal the internal
    75  // state of the hash.
    76  func New384() hash.Hash {
    77  	if boring.Enabled {
    78  		return boring.NewSHA384()
    79  	}
    80  	return sha512.New384()
    81  }
    82  
    83  // Sum512 returns the SHA512 checksum of the data.
    84  func Sum512(data []byte) [Size]byte {
    85  	if boring.Enabled {
    86  		return boring.SHA512(data)
    87  	}
    88  	h := New()
    89  	h.Write(data)
    90  	var sum [Size]byte
    91  	h.Sum(sum[:0])
    92  	return sum
    93  }
    94  
    95  // Sum384 returns the SHA384 checksum of the data.
    96  func Sum384(data []byte) [Size384]byte {
    97  	if boring.Enabled {
    98  		return boring.SHA384(data)
    99  	}
   100  	h := New384()
   101  	h.Write(data)
   102  	var sum [Size384]byte
   103  	h.Sum(sum[:0])
   104  	return sum
   105  }
   106  
   107  // Sum512_224 returns the Sum512/224 checksum of the data.
   108  func Sum512_224(data []byte) [Size224]byte {
   109  	h := New512_224()
   110  	h.Write(data)
   111  	var sum [Size224]byte
   112  	h.Sum(sum[:0])
   113  	return sum
   114  }
   115  
   116  // Sum512_256 returns the Sum512/256 checksum of the data.
   117  func Sum512_256(data []byte) [Size256]byte {
   118  	h := New512_256()
   119  	h.Write(data)
   120  	var sum [Size256]byte
   121  	h.Sum(sum[:0])
   122  	return sum
   123  }
   124
View as plain text