f8d9fa9e80
This upgrades all of libgo other than the runtime package to the Go 1.4 release. In Go 1.4 much of the runtime was rewritten into Go. Merging that code will take more time and will not change the API, so I'm putting it off for now. There are a few runtime changes anyhow, to accomodate other packages that rely on minor modifications to the runtime support. The compiler changes slightly to add a one-bit flag to each type descriptor kind that is stored directly in an interface, which for gccgo is currently only pointer types. Another one-bit flag (gcprog) is reserved because it is used by the gc compiler, but gccgo does not currently use it. There is another error check in the compiler since I ran across it during testing. gotools/: * Makefile.am (go_cmd_go_files): Sort entries. Add generate.go. * Makefile.in: Rebuild. From-SVN: r219627
127 lines
4.0 KiB
Go
127 lines
4.0 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
|
|
}
|
|
|
|
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
|
|
maxHash
|
|
)
|
|
|
|
var digestSizes = []uint8{
|
|
MD4: 16,
|
|
MD5: 16,
|
|
SHA1: 20,
|
|
SHA224: 28,
|
|
SHA256: 32,
|
|
SHA384: 48,
|
|
SHA512: 64,
|
|
SHA3_224: 28,
|
|
SHA3_256: 32,
|
|
SHA3_384: 48,
|
|
SHA3_512: 64,
|
|
MD5SHA1: 36,
|
|
RIPEMD160: 20,
|
|
}
|
|
|
|
// 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.
|
|
type PublicKey interface{}
|
|
|
|
// PrivateKey represents a private key using an unspecified algorithm.
|
|
type PrivateKey interface{}
|
|
|
|
// 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 msg 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.
|
|
Sign(rand io.Reader, msg []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
|
|
}
|