223 lines
6.8 KiB
Go
223 lines
6.8 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package crypto collects common cryptographic constants.
|
|
package crypto
|
|
|
|
import (
|
|
"hash"
|
|
"io"
|
|
"strconv"
|
|
)
|
|
|
|
// Hash identifies a cryptographic hash function that is implemented in another
|
|
// package.
|
|
type Hash uint
|
|
|
|
// HashFunc simply returns the value of h so that Hash implements SignerOpts.
|
|
func (h Hash) HashFunc() Hash {
|
|
return h
|
|
}
|
|
|
|
func (h Hash) String() string {
|
|
switch h {
|
|
case MD4:
|
|
return "MD4"
|
|
case MD5:
|
|
return "MD5"
|
|
case SHA1:
|
|
return "SHA-1"
|
|
case SHA224:
|
|
return "SHA-224"
|
|
case SHA256:
|
|
return "SHA-256"
|
|
case SHA384:
|
|
return "SHA-384"
|
|
case SHA512:
|
|
return "SHA-512"
|
|
case MD5SHA1:
|
|
return "MD5+SHA1"
|
|
case RIPEMD160:
|
|
return "RIPEMD-160"
|
|
case SHA3_224:
|
|
return "SHA3-224"
|
|
case SHA3_256:
|
|
return "SHA3-256"
|
|
case SHA3_384:
|
|
return "SHA3-384"
|
|
case SHA3_512:
|
|
return "SHA3-512"
|
|
case SHA512_224:
|
|
return "SHA-512/224"
|
|
case SHA512_256:
|
|
return "SHA-512/256"
|
|
case BLAKE2s_256:
|
|
return "BLAKE2s-256"
|
|
case BLAKE2b_256:
|
|
return "BLAKE2b-256"
|
|
case BLAKE2b_384:
|
|
return "BLAKE2b-384"
|
|
case BLAKE2b_512:
|
|
return "BLAKE2b-512"
|
|
default:
|
|
return "unknown hash value " + strconv.Itoa(int(h))
|
|
}
|
|
}
|
|
|
|
const (
|
|
MD4 Hash = 1 + iota // import golang.org/x/crypto/md4
|
|
MD5 // import crypto/md5
|
|
SHA1 // import crypto/sha1
|
|
SHA224 // import crypto/sha256
|
|
SHA256 // import crypto/sha256
|
|
SHA384 // import crypto/sha512
|
|
SHA512 // import crypto/sha512
|
|
MD5SHA1 // no implementation; MD5+SHA1 used for TLS RSA
|
|
RIPEMD160 // import golang.org/x/crypto/ripemd160
|
|
SHA3_224 // import golang.org/x/crypto/sha3
|
|
SHA3_256 // import golang.org/x/crypto/sha3
|
|
SHA3_384 // import golang.org/x/crypto/sha3
|
|
SHA3_512 // import golang.org/x/crypto/sha3
|
|
SHA512_224 // import crypto/sha512
|
|
SHA512_256 // import crypto/sha512
|
|
BLAKE2s_256 // import golang.org/x/crypto/blake2s
|
|
BLAKE2b_256 // import golang.org/x/crypto/blake2b
|
|
BLAKE2b_384 // import golang.org/x/crypto/blake2b
|
|
BLAKE2b_512 // import golang.org/x/crypto/blake2b
|
|
maxHash
|
|
)
|
|
|
|
var digestSizes = []uint8{
|
|
MD4: 16,
|
|
MD5: 16,
|
|
SHA1: 20,
|
|
SHA224: 28,
|
|
SHA256: 32,
|
|
SHA384: 48,
|
|
SHA512: 64,
|
|
SHA512_224: 28,
|
|
SHA512_256: 32,
|
|
SHA3_224: 28,
|
|
SHA3_256: 32,
|
|
SHA3_384: 48,
|
|
SHA3_512: 64,
|
|
MD5SHA1: 36,
|
|
RIPEMD160: 20,
|
|
BLAKE2s_256: 32,
|
|
BLAKE2b_256: 32,
|
|
BLAKE2b_384: 48,
|
|
BLAKE2b_512: 64,
|
|
}
|
|
|
|
// Size returns the length, in bytes, of a digest resulting from the given hash
|
|
// function. It doesn't require that the hash function in question be linked
|
|
// into the program.
|
|
func (h Hash) Size() int {
|
|
if h > 0 && h < maxHash {
|
|
return int(digestSizes[h])
|
|
}
|
|
panic("crypto: Size of unknown hash function")
|
|
}
|
|
|
|
var hashes = make([]func() hash.Hash, maxHash)
|
|
|
|
// New returns a new hash.Hash calculating the given hash function. New panics
|
|
// if the hash function is not linked into the binary.
|
|
func (h Hash) New() hash.Hash {
|
|
if h > 0 && h < maxHash {
|
|
f := hashes[h]
|
|
if f != nil {
|
|
return f()
|
|
}
|
|
}
|
|
panic("crypto: requested hash function #" + strconv.Itoa(int(h)) + " is unavailable")
|
|
}
|
|
|
|
// Available reports whether the given hash function is linked into the binary.
|
|
func (h Hash) Available() bool {
|
|
return h < maxHash && hashes[h] != nil
|
|
}
|
|
|
|
// RegisterHash registers a function that returns a new instance of the given
|
|
// hash function. This is intended to be called from the init function in
|
|
// packages that implement hash functions.
|
|
func RegisterHash(h Hash, f func() hash.Hash) {
|
|
if h >= maxHash {
|
|
panic("crypto: RegisterHash of unknown hash function")
|
|
}
|
|
hashes[h] = f
|
|
}
|
|
|
|
// PublicKey represents a public key using an unspecified algorithm.
|
|
//
|
|
// Although this type is an empty interface for backwards compatibility reasons,
|
|
// all public key types in the standard library implement the following interface
|
|
//
|
|
// interface{
|
|
// Equal(x crypto.PublicKey) bool
|
|
// }
|
|
//
|
|
// which can be used for increased type safety within applications.
|
|
type PublicKey any
|
|
|
|
// PrivateKey represents a private key using an unspecified algorithm.
|
|
//
|
|
// Although this type is an empty interface for backwards compatibility reasons,
|
|
// all private key types in the standard library implement the following interface
|
|
//
|
|
// interface{
|
|
// Public() crypto.PublicKey
|
|
// Equal(x crypto.PrivateKey) bool
|
|
// }
|
|
//
|
|
// as well as purpose-specific interfaces such as Signer and Decrypter, which
|
|
// can be used for increased type safety within applications.
|
|
type PrivateKey any
|
|
|
|
// Signer is an interface for an opaque private key that can be used for
|
|
// signing operations. For example, an RSA key kept in a hardware module.
|
|
type Signer interface {
|
|
// Public returns the public key corresponding to the opaque,
|
|
// private key.
|
|
Public() PublicKey
|
|
|
|
// Sign signs digest with the private key, possibly using entropy from
|
|
// rand. For an RSA key, the resulting signature should be either a
|
|
// PKCS #1 v1.5 or PSS signature (as indicated by opts). For an (EC)DSA
|
|
// key, it should be a DER-serialised, ASN.1 signature structure.
|
|
//
|
|
// Hash implements the SignerOpts interface and, in most cases, one can
|
|
// simply pass in the hash function used as opts. Sign may also attempt
|
|
// to type assert opts to other types in order to obtain algorithm
|
|
// specific values. See the documentation in each package for details.
|
|
//
|
|
// Note that when a signature of a hash of a larger message is needed,
|
|
// the caller is responsible for hashing the larger message and passing
|
|
// the hash (as digest) and the hash function (as opts) to Sign.
|
|
Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
|
|
}
|
|
|
|
// SignerOpts contains options for signing with a Signer.
|
|
type SignerOpts interface {
|
|
// HashFunc returns an identifier for the hash function used to produce
|
|
// the message passed to Signer.Sign, or else zero to indicate that no
|
|
// hashing was done.
|
|
HashFunc() Hash
|
|
}
|
|
|
|
// Decrypter is an interface for an opaque private key that can be used for
|
|
// asymmetric decryption operations. An example would be an RSA key
|
|
// kept in a hardware module.
|
|
type Decrypter interface {
|
|
// Public returns the public key corresponding to the opaque,
|
|
// private key.
|
|
Public() PublicKey
|
|
|
|
// Decrypt decrypts msg. The opts argument should be appropriate for
|
|
// the primitive used. See the documentation in each implementation for
|
|
// details.
|
|
Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)
|
|
}
|
|
|
|
type DecrypterOpts any
|