Go Crypto Package

https://pkg.go.dev/crypto
Admin
The Go crypto package is a standard library package that collects common cryptographic constants and...
Tokens:270,764
Snippets:2,245
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### SHA-1 New (File) example output

Source: https://pkg.go.dev/crypto/sha1

Example output for the New (File) example. The output is empty.

```text
Output:
```

--------------------------------

### SHA-1 New example output

Source: https://pkg.go.dev/crypto/sha1

Example output for the New function.

```text
Output:
59 7f 6a 54 00 10 f9 4c 15 d7 18 06 a9 9a 2c 87 10 e7 47 bd
```

--------------------------------

### Example: Generate key and sign message

Source: https://pkg.go.dev/crypto/mldsa

This example demonstrates generating a key pair and signing a message, printing the public key and signature sizes. The output shows the public key size as 1312 bytes and the signature size as 2420 bytes.

```Go
Output:
public key: 1312 bytes
signature: 2420 bytes

```

--------------------------------

### SHA-1 Sum example output

Source: https://pkg.go.dev/crypto/sha1

Example output for the Sum function.

```text
Output:
af 06 49 23 bb f2 30 15 96 aa c4 c2 73 ba 32 17 8e bc 4a 96
```

--------------------------------

### QUICConn.Start

Source: https://pkg.go.dev/crypto/tls

Starts the client or server handshake protocol. It may produce connection events, which may be read with QUICConn.NextEvent. Start must be called at most once.

```APIDOC
## QUICConn.Start

### Description
Starts the client or server handshake protocol. It may produce connection events, which may be read with QUICConn.NextEvent. Start must be called at most once.

### Method Signature
func (q *QUICConn) Start(ctx context.Context) error

### Parameters
- **ctx** (context.Context) - Required - The context for the handshake.

### Returns
- **error** - An error if starting fails.

### Example
```go
err := conn.Start(ctx)
```
```

--------------------------------

### Example: Deriving a key with HMAC-SHA-1

Source: https://pkg.go.dev/crypto/pbkdf2

This example shows how to derive a 32-byte key for AES-256 using HMAC-SHA-1 with 4096 iterations. The salt should be at least 8 bytes as recommended by the RFC. Higher iteration counts increase security but slow down derivation.

```go
dk, err := pbkdf2.Key(sha1.New, "some password", salt, 4096, 32)
```

--------------------------------

### func Samples(samples []uint8, memory *ScratchBuffer) error

Source: https://pkg.go.dev/crypto/internal/entropy/v1.0.0

Starts a new entropy source, collects the requested number of samples, conducts startup health tests, and returns the samples or an error if the health tests fail.

```APIDOC
## func Samples

### Description
Starts a new entropy source, collects the requested number of samples, conducts startup health tests, and returns the samples or an error if the health tests fail. The health tests have a non-negligible chance of failing.

### Function Signature
func Samples(samples []uint8, memory *ScratchBuffer) error

### Parameters
- **samples** ([]uint8) - Required - The slice to fill with collected samples.
- **memory** (*ScratchBuffer) - Required - A scratch buffer for the entropy source.

### Return Values
- **error** - Returns an error if the health tests fail, otherwise nil.
```

--------------------------------

### Samples function signature

Source: https://pkg.go.dev/crypto/internal/entropy/v1.0.0

Declares the Samples function, which starts a new entropy source, collects samples, conducts startup health tests, and returns the samples or an error if the health tests fail.

```go
func Samples(samples []uint8, memory *ScratchBuffer) error
```

--------------------------------

### func (c *Cache[K, V]) Get(k *K, new func() (*V, error), check func(*V) bool) (*V, error)

Source: https://pkg.go.dev/crypto/internal/fips140cache

Get returns the result of new, for an associated key k. If Get was called with k before and didn't return an error, Get may return the same value it returned from the previous call if check returns true on it. If check returns false, Get will call new again and return the result. The cache is evicted some time after k becomes unreachable.

```APIDOC
## func (c *Cache[K, V]) Get(k *K, new func() (*V, error), check func(*V) bool) (*V, error)

### Description
Get returns the result of new, for an associated key k. If Get was called with k before and didn't return an error, Get may return the same value it returned from the previous call if check returns true on it. If check returns false, Get will call new again and return the result. The cache is evicted some time after k becomes unreachable.

### Method
Get

### Signature
func (c *Cache[K, V]) Get(k *K, new func() (*V, error), check func(*V) bool) (*V, error)

### Parameters
- **k** (*K) - The key to associate the value with.
- **new** (func() (*V, error)) - A function that returns a new value and an error.
- **check** (func(*V) bool) - A function that returns true if the cached value is still valid.

### Returns
- (*V, error) - The cached or newly created value, and an error if any.
```

--------------------------------

### func (c *Cache[K, V]) Register()

Source: https://pkg.go.dev/crypto/internal/boring/bcache

Registers the cache with the runtime, so that c.ptable can be cleared at the start of each GC. Register must be called during package initialization.

```APIDOC
## func (c *Cache[K, V]) Register()

### Description
Registers the cache with the runtime, so that c.ptable can be cleared at the start of each GC. Register must be called during package initialization.

### Method
Register

### Signature
func (c *Cache[K, V]) Register()

### Parameters
None

### Return
None
```

--------------------------------

### func (*CTR) XORKeyStreamAt(dst, src []byte, offset uint64)

Source: https://pkg.go.dev/crypto/internal/fips140/aes

Behaves like XORKeyStream but keeps no state, seeking into the keystream by the given bytes offset from the start. Allows random access into the keystream, up to 16 EiB from the start.

```APIDOC
## func (*CTR) XORKeyStreamAt(dst, src []byte, offset uint64)

### Description
Behaves like XORKeyStream but keeps no state, and instead seeks into the keystream by the given bytes offset from the start (ignoring any XORKeyStream calls). This allows for random access into the keystream, up to 16 EiB from the start.

### Parameters
- **dst** ([]byte) - Required - The destination buffer for the result.
- **src** ([]byte) - Required - The source buffer containing the data to be XORed.
- **offset** (uint64) - Required - The byte offset into the keystream.
```

--------------------------------

### type PublicKey

Source: https://pkg.go.dev/crypto/internal/fips140/rsa

Represents an RSA public key. It has a method to get the key size in bytes.

```APIDOC
## type PublicKey

### Description
Represents an RSA public key.

### Methods

#### func (pub *PublicKey) Size() int

Returns the size of the public key in bytes.
```

--------------------------------

### func List(pkg string) []string

Source: https://pkg.go.dev/crypto/internal/impl

List returns the names of all alternative implementations registered for the given package, whether available or not. The implicit base implementation is not included.

```APIDOC
## func List(pkg string) []string

### Description
List returns the names of all alternative implementations registered for the given package, whether available or not. The implicit base implementation is not included.

### Parameters
- **pkg** (string) - Required - The package name.

### Returns
- **[]string** - List of alternative implementation names.
```

--------------------------------

### type ExtKeyUsage

Source: https://pkg.go.dev/crypto/x509

ExtKeyUsage represents an extended key usage. It provides methods to get the OID and string representation.

```APIDOC
## type ExtKeyUsage

### Description
ExtKeyUsage represents an extended key usage. It provides methods to get the OID and string representation.

### Methods

#### func (eku ExtKeyUsage) OID() OID

Returns the OID for the extended key usage.

#### func (i ExtKeyUsage) String() string

Returns the string representation of the extended key usage.
```

--------------------------------

### Parameters String method

Source: https://pkg.go.dev/crypto/mldsa

String returns the name of the parameter set, e.g. "ML-DSA-44".

```Go
func (params Parameters) String() string
```

--------------------------------

### type TestingOnlyLargeExponentPublicKey

Source: https://pkg.go.dev/crypto/internal/fips140/rsa

Represents a testing-only RSA public key with a large exponent. It has a method to get the key size.

```APIDOC
## type TestingOnlyLargeExponentPublicKey

### Description
Represents a testing-only RSA public key with a large exponent.

### Methods

#### func (pub *TestingOnlyLargeExponentPublicKey) Size() int

Returns the size of the public key in bytes.
```

--------------------------------

### Options struct definition

Source: https://pkg.go.dev/crypto/mldsa

Options contains additional options for signing and verifying ML-DSA signatures. The Context field can be used to distinguish signatures for different purposes, must be at most 255 bytes, and is empty by default. The same context must be used when signing and verifying.

```Go
type Options struct {
	// Context can be used to distinguish signatures created for different
	// purposes. It must be at most 255 bytes long, and it is empty by default.
	//
	// The same context must be used when signing and verifying a signature.
	Context string
}
```

--------------------------------

### type TestingOnlyLargeExponentPrivateKey

Source: https://pkg.go.dev/crypto/internal/fips140/rsa

Represents a testing-only RSA private key with a large exponent. It has a method to get the key size.

```APIDOC
## type TestingOnlyLargeExponentPrivateKey

### Description
Represents a testing-only RSA private key with a large exponent.

### Methods

#### func (priv *TestingOnlyLargeExponentPrivateKey) Size() int

Returns the size of the private key in bytes.

### Constructors

#### func TestingOnlyNewLargeExponentPrivateKeyWithPrecomputation(N []byte, e []byte, d, P, Q, dP, dQ, qInv []byte) (*TestingOnlyLargeExponentPrivateKey, error)

Creates a new testing-only private key with precomputed CRT values.
```

--------------------------------

### type Setting

Source: https://pkg.go.dev/crypto/internal/fips140deps/godebug

Represents a GODEBUG setting. Use New to create a Setting and Value to retrieve its current value.

```APIDOC
## type Setting

### Description
Represents a GODEBUG setting. Use New to create a Setting and Value to retrieve its current value.

### Type Definition
```go
type Setting godebug.Setting
```

### Constructors
#### func New(name string) *Setting

### Description
Creates a new Setting for the given GODEBUG setting name.

### Function Signature
```go
func New(name string) *Setting
```

### Parameters
- **name** (string) - Required - The name of the GODEBUG setting.

### Returns
- **\*Setting** - A pointer to the new Setting.

### Methods
#### func (s *Setting) Value() string

### Description
Returns the current value of the Setting.

### Function Signature
```go
func (s *Setting) Value() string
```

### Returns
- **string** - The value of the setting.

```

--------------------------------

### func NewPublicKey[P Point[P]](c *Curve[P], key []byte) (*PublicKey, error)

Source: https://pkg.go.dev/crypto/internal/fips140/ecdh

NewPublicKey creates a new PublicKey from the given byte slice. The key must be a valid point on the curve.

```APIDOC
## func NewPublicKey[P Point[P]](c *Curve[P], key []byte) (*PublicKey, error)

### Description
NewPublicKey creates a new PublicKey from the given byte slice. The key must be a valid point on the curve.

### Function Signature
```go
func NewPublicKey[P Point[P]](c *Curve[P], key []byte) (*PublicKey, error)
```

### Parameters
- **c** (*Curve[P]) - The curve associated with the key.
- **key** ([]byte) - The public key bytes.

### Returns
- **(*PublicKey)** - The new public key.
- **error** - An error if the key is invalid.
```

--------------------------------

### BlockMode Interface

Source: https://pkg.go.dev/crypto/cipher

Defines the BlockMode interface for block cipher modes. It provides methods to get the block size and to process multiple blocks.

```APIDOC
## BlockMode Interface

### Description
Represents a block cipher running in a block-based mode (CBC, ECB, etc.). Provides a method to encrypt or decrypt a number of blocks.

### Interface Definition
```go
type BlockMode interface {
    BlockSize() int
    CryptBlocks(dst, src []byte)
}
```

### Methods
- **BlockSize()** (int) - Returns the mode's block size.
- **CryptBlocks(dst, src []byte)** - Encrypts or decrypts a number of blocks. The length of src must be a multiple of the block size. Dst and src must overlap entirely or not at all. If len(dst) < len(src), it should panic. Multiple calls behave as if the concatenation of src buffers was passed in a single run.
```

--------------------------------

### Block Interface

Source: https://pkg.go.dev/crypto/cipher

Defines the Block interface for block ciphers. It provides methods to get the block size and to encrypt or decrypt individual blocks.

```APIDOC
## Block Interface

### Description
Represents a block cipher using a given key. Provides methods to encrypt or decrypt individual blocks. Mode implementations extend this capability to streams of blocks.

### Interface Definition
```go
type Block interface {
    BlockSize() int
    Encrypt(dst, src []byte)
    Decrypt(dst, src []byte)
}
```

### Methods
- **BlockSize()** (int) - Returns the cipher's block size.
- **Encrypt(dst, src []byte)** - Encrypts the first block in src into dst. Dst and src must overlap entirely or not at all.
- **Decrypt(dst, src []byte)** - Decrypts the first block in src into dst. Dst and src must overlap entirely or not at all.
```

--------------------------------

### func (priv *PrivateKey) Precompute()

Source: https://pkg.go.dev/crypto/rsa

Precomputes values to speed up private key operations.

```APIDOC
## func (priv *PrivateKey) Precompute

### Description
Precomputes values to speed up private key operations.

### Function Signature
func (priv *PrivateKey) Precompute()

### Parameters
None.

### Return Values
None.
```

--------------------------------

### func (c *CTR) XORKeyStreamAt(dst, src []byte, offset uint64)

Source: https://pkg.go.dev/crypto/internal/fips140/aes

XORs the keystream with the source data starting at a given offset.

```APIDOC
## [METHOD] (c *CTR) XORKeyStreamAt(dst, src []byte, offset uint64)

### Description
XORs the keystream with the source data starting at a given offset.

### Method Signature
func (c *CTR) XORKeyStreamAt(dst, src []byte, offset uint64)

### Parameters
- **c** (*CTR) - Required - The CTR mode cipher instance.
- **dst** ([]byte) - Required - Destination slice for the output.
- **src** ([]byte) - Required - Source slice containing the data to be XORed.
- **offset** (uint64) - Required - The offset in the keystream to start from.

### Return Value
None.
```

--------------------------------

### func Packages() []string

Source: https://pkg.go.dev/crypto/internal/impl

Packages returns the list of all packages for which alternative implementations are registered.

```APIDOC
## func Packages() []string

### Description
Packages returns the list of all packages for which alternative implementations are registered.

### Returns
- **[]string** - List of package names.
```

--------------------------------

### func (Hash) New

Source: https://pkg.go.dev/crypto

New returns a new hash.Hash calculating the given hash function. It panics if the hash function is not linked into the binary.

```APIDOC
## func (Hash) New

### Description
New returns a new hash.Hash calculating the given hash function. It panics if the hash function is not linked into the binary.

### Signature
func (h Hash) New() hash.Hash

### Parameters
- **h** (Hash) - the receiver hash

### Returns
- **hash.Hash** - a new hash.Hash for the given hash function

```

--------------------------------

### ClientSessionCache

Source: https://pkg.go.dev/crypto/tls

ClientSessionCache is an interface for a cache of client session states, used for session resumption. It has a single method Get that searches for a ClientSessionState associated with a given key.

```APIDOC
## ClientSessionCache

### Description
ClientSessionCache is an interface for a cache of client session states, used for session resumption. It has a single method Get that searches for a ClientSessionState associated with a given key.

### Type
interface

### Methods

#### Get

##### Description
Get searches for a ClientSessionState associated with the given key. On return, ok is true if one was found.

##### Signature
Get(sessionKey string) (session *ClientSessionState, ok bool)

##### Parameters
- sessionKey (string) - Required - The key to search for.

##### Return Values
- session (*ClientSessionState) - The session state if found.
- ok (bool) - true if a session was found, false otherwise.
```

--------------------------------

### PublicKey Parameters method

Source: https://pkg.go.dev/crypto/mldsa

Parameters returns the parameter set associated with the public key.

```Go
func (pk *PublicKey) Parameters() Parameters
```

--------------------------------

### type PrivateKey interface

Source: https://pkg.go.dev/crypto/hpke

A PrivateKey is an instantiation of a KEM with a decapsulation key. It provides methods to access the KEM, serialize the private key, and get the corresponding public key.

```APIDOC
## type PrivateKey

### Description
A PrivateKey is an instantiation of a KEM (one of the three components of an HPKE ciphersuite) with a decapsulation key (i.e. the secret key). A PrivateKey is usually obtained from a method of the corresponding KEM, such as KEM.GenerateKey or KEM.NewPrivateKey.

### Interface Definition
```go
type PrivateKey interface {
	// KEM returns the instantiated KEM.
	KEM() KEM

	// Bytes returns the private key as the output of SerializePrivateKey, as
	// defined in RFC 9180.
	//
	// Note that for X25519 this might not match the input to NewPrivateKey.
	// This is a requirement of RFC 9180, Section 7.1.2.
	Bytes() ([]byte, error)

	// PublicKey returns the corresponding PublicKey.
	PublicKey() PublicKey
}
```

### Methods
- **KEM()** (KEM) - Returns the instantiated KEM.
- **Bytes()** ([]byte, error) - Returns the private key as the output of SerializePrivateKey, as defined in RFC 9180.
- **PublicKey()** (PublicKey) - Returns the corresponding PublicKey.
```

--------------------------------

### PrivateKey Equal method

Source: https://pkg.go.dev/crypto/mldsa

Equal reports whether the private key is equal to the given crypto.PrivateKey.

```Go
func (sk *PrivateKey) Equal(x crypto.PrivateKey) bool
```

--------------------------------

### func NewPublicKey(pub []byte) (*PublicKey, error)

Source: https://pkg.go.dev/crypto/internal/fips140/ed25519

Creates a new PublicKey from the given byte slice.

```APIDOC
## func NewPublicKey

### Description
Creates a new PublicKey from the given byte slice.

### Signature
`func NewPublicKey(pub []byte) (*PublicKey, error)`

### Parameters
- **pub** ([]byte) - The public key bytes.

### Returns
- **\*PublicKey** - The new public key.
- **error** - An error if the input is invalid.
```

--------------------------------

### func NewGCMWithCounterNonce

Source: https://pkg.go.dev/crypto/internal/fips140/aes/gcm

Returns a new AEAD that works like GCM, but enforces the construction of deterministic nonces. The nonce must be 96 bits, the first 32 bits must be an encoding of the module name, and the last 64 bits must be a counter. The starting value of the counter is set on the first call to Seal, and each subsequent call must increment it as a big-endian uint64. If the counter reaches the starting value minus one, Seal will panic. This complies with FIPS 140-3 IG C.H Scenario 3.

```APIDOC
## func NewGCMWithCounterNonce

### Description
Returns a new AEAD that works like GCM, but enforces the construction of deterministic nonces. The nonce must be 96 bits, the first 32 bits must be an encoding of the module name, and the last 64 bits must be a counter. The starting value of the counter is set on the first call to Seal, and each subsequent call must increment it as a big-endian uint64. If the counter reaches the starting value minus one, Seal will panic. This complies with FIPS 140-3 IG C.H Scenario 3.

### Signature
```go
func NewGCMWithCounterNonce(cipher *aes.Block) (*GCMWithCounterNonce, error)
```

### Parameters
- **cipher** (*aes.Block) - Required - The AES block cipher to use.

### Returns
- **aead** (*GCMWithCounterNonce) - The new AEAD instance.
- **error** (error) - An error if creation fails.
```

--------------------------------

### func Listen(network, laddr string, config *Config) (net.Listener, error)

Source: https://pkg.go.dev/crypto/tls

Listen creates a TLS listener accepting connections on the given network address using the provided TLS configuration.

```APIDOC
## func Listen(network, laddr string, config *Config) (net.Listener, error)

### Description
Creates a TLS listener accepting connections on the given network address using the provided TLS configuration.

### Function Signature
`func Listen(network, laddr string, config *Config) (net.Listener, error)`

### Parameters
- **network** (string) - The network type (e.g., "tcp").
- **laddr** (string) - The local address to listen on.
- **config** (*Config) - The TLS configuration.

### Returns
- **net.Listener** - A TLS listener.
- **error** - An error if the listener could not be created.
```

--------------------------------

### ClientSessionCache.Put

Source: https://pkg.go.dev/crypto/tls

Adds a ClientSessionState to the cache with the given key. It might get called multiple times in a connection if a TLS 1.3 server provides more than one session ticket. If called with a nil *ClientSessionState, it should remove the cache entry.

```APIDOC
## ClientSessionCache.Put

### Description
Adds a ClientSessionState to the cache with the given key. It might get called multiple times in a connection if a TLS 1.3 server provides more than one session ticket. If called with a nil *ClientSessionState, it should remove the cache entry.

### Method
Put

### Signature
Put(sessionKey string, cs *ClientSessionState)

### Parameters
- **sessionKey** (string) - Required - The key under which to store the session state.
- **cs** (*ClientSessionState) - Required - The session state to cache. If nil, the cache entry should be removed.

### Return
No return value.
```

--------------------------------

### func New

Source: https://pkg.go.dev/crypto/internal/fips140/aes/gcm

Creates a new GCM AEAD instance with the specified nonce and tag sizes.

```APIDOC
## func New

### Description
Creates a new GCM AEAD instance with the specified nonce and tag sizes.

### Signature
```go
func New(cipher *aes.Block, nonceSize, tagSize int) (*GCM, error)
```

### Parameters
- **cipher** (*aes.Block) - Required - The AES block cipher to use.
- **nonceSize** (int) - Required - The size of the nonce in bytes.
- **tagSize** (int) - Required - The size of the authentication tag in bytes.

### Returns
- **gcm** (*GCM) - The new GCM instance.
- **error** (error) - An error if creation fails.
```

--------------------------------

### NewPublicKey function

Source: https://pkg.go.dev/crypto/mldsa

NewPublicKey creates a public key from its encoding.

```Go
func NewPublicKey(params Parameters, encoding []byte) (*PublicKey, error)
```

--------------------------------

### func (c *Cache[K, V]) Get(k *K) *V

Source: https://pkg.go.dev/crypto/internal/boring/bcache

Returns the cached value associated with k, which is either the value v corresponding to the most recent call to Put(k, v) or nil if that cache entry has been dropped.

```APIDOC
## func (c *Cache[K, V]) Get(k *K) *V

### Description
Returns the cached value associated with k, which is either the value v corresponding to the most recent call to Put(k, v) or nil if that cache entry has been dropped.

### Method
Get

### Signature
func (c *Cache[K, V]) Get(k *K) *V

### Parameters
- **k** (*K) - Required - The key to look up in the cache.

### Return
- **&V** (*V) - The cached value associated with k, or nil if the entry has been dropped.
```

--------------------------------

### func Listen

Source: https://pkg.go.dev/crypto/tls

Creates a TLS listener accepting connections on the given network address using net.Listen.

```APIDOC
## func Listen

### Description
Creates a TLS listener accepting connections on the given network address using net.Listen. The configuration config must be non-nil and must include at least one certificate or else set GetCertificate.

### Function Signature
```go
func Listen(network, laddr string, config *Config) (net.Listener, error)
```

### Parameters
- **network** (string) - Required - The network type (e.g., "tcp").
- **laddr** (string) - Required - The local address to listen on.
- **config** (*Config) - Required - The TLS configuration, must be non-nil and include at least one certificate or set GetCertificate.

### Returns
- **net.Listener** - The TLS listener.
- **error** - An error if the listener could not be created.
```

--------------------------------

### func Open(k PrivateKey, kdf KDF, aead AEAD, info, ciphertext []byte) ([]byte, error)

Source: https://pkg.go.dev/crypto/hpke

Open instantiates a single-use HPKE receiving HPKE context like NewRecipient, and then decrypts the provided ciphertext like Recipient.Open (with no aad). ciphertext must be the concatenation of the encapsulated key and the actual ciphertext.

```APIDOC
## func Open

### Description
Open instantiates a single-use HPKE receiving HPKE context like NewRecipient, and then decrypts the provided ciphertext like Recipient.Open (with no aad). ciphertext must be the concatenation of the encapsulated key and the actual ciphertext.

### Signature
```go
func Open(k PrivateKey, kdf KDF, aead AEAD, info, ciphertext []byte) ([]byte, error)
```

### Parameters
- **k** (PrivateKey) - Required - The recipient's private key.
- **kdf** (KDF) - Required - The key derivation function.
- **aead** (AEAD) - Required - The authenticated encryption with associated data algorithm.
- **info** ([]byte) - Required - Application-specific information.
- **ciphertext** ([]byte) - Required - The concatenation of the encapsulated key and the actual ciphertext.

### Returns
- **[]byte** - The decrypted plaintext.
- **error** - An error if decryption fails.
```

--------------------------------

### func NewGCMForQUIC

Source: https://pkg.go.dev/crypto/internal/fips140/aes/gcm

Returns a new AEAD that works like GCM, but enforces the construction of nonces as specified in RFC 9001, Section 5.3. Unlike in TLS 1.3, the QUIC nonce counter does not always start at zero, as the packet number does not reset on key updates, so the XOR mask must be provided explicitly instead of being learned on the first Seal call. Note that the nonce passed to Seal must already be XOR'd with the IV, the IV is provided here only to allow Seal to enforce that the counter is strictly increasing. This complies with FIPS 140-3 IG C.H Scenario 5.

```APIDOC
## func NewGCMForQUIC

### Description
Returns a new AEAD that works like GCM, but enforces the construction of nonces as specified in RFC 9001, Section 5.3. Unlike in TLS 1.3, the QUIC nonce counter does not always start at zero, as the packet number does not reset on key updates, so the XOR mask must be provided explicitly instead of being learned on the first Seal call. Note that the nonce passed to Seal must already be XOR'd with the IV, the IV is provided here only to allow Seal to enforce that the counter is strictly increasing. This complies with FIPS 140-3 IG C.H Scenario 5.

### Signature
```go
func NewGCMForQUIC(cipher *aes.Block, iv []byte) (*GCMWithXORCounterNonce, error)
```

### Parameters
- **cipher** (*aes.Block) - Required - The AES block cipher to use.
- **iv** ([]byte) - Required - The IV (XOR mask) to use for nonce construction.

### Returns
- **aead** (*GCMWithXORCounterNonce) - The new AEAD instance.
- **error** (error) - An error if creation fails.
```

--------------------------------

### func NewGCMWithXORCounterNonce

Source: https://pkg.go.dev/crypto/internal/fips140/aes/gcm

Returns a new AEAD that works like GCM, but enforces the construction of deterministic nonces. The nonce must be 96 bits, the first 32 bits must be an encoding of the module name, and the last 64 bits must be a counter XOR'd with a fixed value. The module name and XOR mask can be set with GCMWithCounterNonce.SetNoncePrefixAndMask, or they are set on the first call to Seal, assuming the counter starts at zero. Each subsequent call must increment the counter as a big-endian uint64. If the counter reaches 2⁶⁴ minus one, Seal will panic. This complies with FIPS 140-3 IG C.H Scenario 3.

```APIDOC
## func NewGCMWithXORCounterNonce

### Description
Returns a new AEAD that works like GCM, but enforces the construction of deterministic nonces. The nonce must be 96 bits, the first 32 bits must be an encoding of the module name, and the last 64 bits must be a counter XOR'd with a fixed value. The module name and XOR mask can be set with GCMWithCounterNonce.SetNoncePrefixAndMask, or they are set on the first call to Seal, assuming the counter starts at zero. Each subsequent call must increment the counter as a big-endian uint64. If the counter reaches 2⁶⁴ minus one, Seal will panic. This complies with FIPS 140-3 IG C.H Scenario 3.

### Signature
```go
func NewGCMWithXORCounterNonce(cipher *aes.Block) (*GCMWithXORCounterNonce, error)
```

### Parameters
- **cipher** (*aes.Block) - Required - The AES block cipher to use.

### Returns
- **aead** (*GCMWithXORCounterNonce) - The new AEAD instance.
- **error** (error) - An error if creation fails.
```

--------------------------------

### func MarshalPKIXPublicKey(pub any) ([]byte, error)

Source: https://pkg.go.dev/crypto/x509

Marshals a public key into PKIX, ASN.1 DER form. The key must be a supported type (e.g., *rsa.PublicKey, *ecdsa.PublicKey).

```APIDOC
## func MarshalPKIXPublicKey

### Description
Marshals a public key into PKIX, ASN.1 DER form. The key must be a supported type (e.g., *rsa.PublicKey, *ecdsa.PublicKey).

### Function Signature
`func MarshalPKIXPublicKey(pub any) ([]byte, error)`

### Parameters
- **pub** (any) - Required - The public key to marshal.

### Return Values
- **[]byte** - The DER-encoded public key.
- **error** - An error if marshaling fails.
```

--------------------------------

### func NewPublicKey65(pk []byte) (*PublicKey, error)

Source: https://pkg.go.dev/crypto/internal/fips140/mldsa

Creates a new ML-DSA-65 public key from the given bytes.

```APIDOC
## func NewPublicKey65

### Description
Creates a new ML-DSA-65 public key from the given bytes.

### Signature
`func NewPublicKey65(pk []byte) (*PublicKey, error)`

### Parameters
- **pk** ([]byte) - Required - The public key bytes.

### Returns
- **\*PublicKey** - The parsed public key.
- **error** - An error if the input is invalid.
```

--------------------------------

### func Expand[H hash.Hash](h func() H, pseudorandomKey []byte, info string, keyLen int) []byte

Source: https://pkg.go.dev/crypto/internal/fips140/hkdf

Expand takes a pseudorandom key, an info string, and a desired output length, and returns the derived key bytes.

```APIDOC
## func Expand

### Description
Expand takes a pseudorandom key, an info string, and a desired output length, and returns the derived key bytes.

### Function Signature
```go
func Expand[H hash.Hash](h func() H, pseudorandomKey []byte, info string, keyLen int) []byte
```

### Parameters
- **h** (func() H) - Required - A function that returns a new hash.Hash instance.
- **pseudorandomKey** ([]byte) - Required - The pseudorandom key (PRK) used as input to the expansion step.
- **info** (string) - Required - Optional context and application specific information.
- **keyLen** (int) - Required - The desired length of the output key in bytes.

### Return Value
- **[]byte** - The derived key of length keyLen.
```

--------------------------------

### func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv any) ([]byte, error)

Source: https://pkg.go.dev/crypto/x509

Creates a new X.509 certificate based on the provided template and parent certificate. It uses the given random source and public/private keys to generate the certificate bytes.

```APIDOC
## func CreateCertificate

### Description
Creates a new X.509 certificate based on the provided template and parent certificate. It uses the given random source and public/private keys to generate the certificate bytes.

### Function Signature
`func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv any) ([]byte, error)`

### Parameters
- **rand** (io.Reader) - Required - Source of randomness for certificate generation.
- **template** (*Certificate) - Required - Template certificate specifying the fields for the new certificate.
- **parent** (*Certificate) - Required - Parent certificate used as the issuer.
- **pub** (any) - Required - Public key of the certificate subject.
- **priv** (any) - Required - Private key used for signing.

### Return Values
- **[]byte** - The DER-encoded certificate bytes.
- **error** - An error if certificate creation fails.
```

--------------------------------

### func (Hash) New

Source: https://pkg.go.dev/crypto

Creates a new hash.Hash instance for the given hash function. Panics if the hash function is not available.

```APIDOC
## [func] (Hash) New

### Description
New returns a new hash.Hash computing the given hash function. It panics if the hash function is not available.

### Method
New

### Signature
func (h Hash) New() hash.Hash

### Parameters
- **h** (Hash) - The hash identifier.

### Returns
- **hash.Hash** - A new hash.Hash instance.

```

--------------------------------

### NewPublicKey

Source: https://pkg.go.dev/crypto/mldsa

Creates a public key from its byte encoding.

```APIDOC
## NewPublicKey

### Description
NewPublicKey creates an in-memory ML-DSA public key from the given encoding and parameter set. It returns the public key or an error.

### Function Signature
`func NewPublicKey(params Parameters, encoding []byte) (*PublicKey, error)`

### Parameters
- **params** (Parameters) - The parameter set for the key (e.g., MLDSA44).
- **encoding** ([]byte) - The byte encoding of the public key.
```

--------------------------------

### func Register(pkg, name string, available *bool)

Source: https://pkg.go.dev/crypto/internal/impl

Register records an alternative implementation of a cryptographic primitive. The implementation might be available or not based on CPU support. If available is false, the implementation is unavailable and can't be tested on this machine. If available is true, it can be set to false to disable the implementation. If all alternative implementations but one are disabled, the remaining one must be used (i.e. disabling one implementation must not implicitly disable any other). Each package has an implicit base implementation that is selected when all alternatives are unavailable or disabled. pkg must be the package name, not path (e.g. "aes" not "crypto/aes").

```APIDOC
## func Register(pkg, name string, available *bool)

### Description
Register records an alternative implementation of a cryptographic primitive. The implementation might be available or not based on CPU support. If available is false, the implementation is unavailable and can't be tested on this machine. If available is true, it can be set to false to disable the implementation. If all alternative implementations but one are disabled, the remaining one must be used (i.e. disabling one implementation must not implicitly disable any other). Each package has an implicit base implementation that is selected when all alternatives are unavailable or disabled. pkg must be the package name, not path (e.g. "aes" not "crypto/aes").

### Parameters
- **pkg** (string) - Required - The package name (not path).
- **name** (string) - Required - The name of the alternative implementation.
- **available** (*bool) - Required - Pointer to a boolean indicating availability. If false, the implementation is unavailable. If true, it can be set to false to disable.
```

--------------------------------

### func NewHybridPublicKey(pq crypto.Encapsulator, t *ecdh.PublicKey) (PublicKey, error)

Source: https://pkg.go.dev/crypto/hpke

NewHybridPublicKey creates a PublicKey from a post-quantum encapsulator and a traditional public key.

```APIDOC
## func NewHybridPublicKey

### Description
NewHybridPublicKey creates a PublicKey from a post-quantum encapsulator and a traditional public key.

### Signature
```go
func NewHybridPublicKey(pq crypto.Encapsulator, t *ecdh.PublicKey) (PublicKey, error)
```

### Parameters
- **pq** (crypto.Encapsulator) - Required - The post-quantum encapsulator.
- **t** (*ecdh.PublicKey) - Required - The traditional public key.

### Returns
- **PublicKey** - A PublicKey.
- **error** - An error if creation fails.
```

--------------------------------

### TestingOnlyNewPrivateKeyFromSemiExpanded

Source: https://pkg.go.dev/crypto/internal/fips140/mldsa

Creates a PrivateKey from a semi-expanded private key encoding, for testing purposes. It rejects inconsistent keys. PrivateKey.Bytes must NOT be called on the resulting key, as it will produce a random value.

```APIDOC
## TestingOnlyNewPrivateKeyFromSemiExpanded

### Description
Creates a PrivateKey from a semi-expanded private key encoding, for testing purposes. It rejects inconsistent keys. PrivateKey.Bytes must NOT be called on the resulting key, as it will produce a random value.

### Function
`func TestingOnlyNewPrivateKeyFromSemiExpanded(sk []byte) (*PrivateKey, error)`

### Parameters
- **sk** ([]byte) - Required - The semi-expanded private key encoding.

### Returns
- **\*PrivateKey** - The resulting private key.
- **error** - An error if the key is inconsistent.

```

--------------------------------

### func Seed(memory *ScratchBuffer) ([48]byte, error)

Source: https://pkg.go.dev/crypto/internal/entropy/v1.0.0

Returns a 384-bit seed with full entropy. Returns an error if the entropy source startup health tests fail.

```APIDOC
## func Seed

### Description
Returns a 384-bit seed with full entropy. Returns an error if the entropy source startup health tests fail, which has a non-negligible chance of happening.

### Function Signature
func Seed(memory *ScratchBuffer) ([48]byte, error)

### Parameters
- **memory** (*ScratchBuffer) - Required - A scratch buffer for the entropy source.

### Return Values
- **[48]byte** - The 384-bit seed.
- **error** - Returns an error if the health tests fail.
```

--------------------------------

### QUICConn.ConnectionState

Source: https://pkg.go.dev/crypto/tls

Returns basic TLS details about the connection.

```APIDOC
## QUICConn.ConnectionState

### Description
Returns basic TLS details about the connection.

### Method Signature
func (q *QUICConn) ConnectionState() ConnectionState

### Parameters
None

### Returns
- **ConnectionState** - The TLS connection state.

### Example
```go
state := conn.ConnectionState()
```
```

--------------------------------

### func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error)

Source: https://pkg.go.dev/crypto/ecdsa

Signs a hash using the private key and returns the signature as a pair of integers. The signature is randomized and the reader is ignored since Go 1.26 unless GODEBUG=cryptocustomrand=1 is set.

```APIDOC
## func Sign

### Description
Sign signs a hash (which should be the result of hashing a larger message) using the private key, priv. If the hash is longer than the bit-length of the private key's curve order, the hash will be truncated to that length. It returns the signature as a pair of integers. Most applications should use SignASN1 instead of dealing directly with r, s. The signature is randomized. Since Go 1.26, a secure source of random bytes is always used, and the Reader is ignored unless GODEBUG=cryptocustomrand=1 is set. This setting will be removed in a future Go release. Instead, use testing/cryptotest.SetGlobalRandom.

### Function Signature
func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error)

### Parameters
- **rand** (io.Reader) - Required - Random source for signature generation. Ignored since Go 1.26 unless GODEBUG=cryptocustomrand=1 is set.
- **priv** (*PrivateKey) - Required - The private key used for signing.
- **hash** ([]byte) - Required - The hash of the message to sign.

### Returns
- **r** (*big.Int) - The first component of the signature.
- **s** (*big.Int) - The second component of the signature.
- **err** (error) - An error if signing fails.
```

--------------------------------

### PrivateKey Sign method

Source: https://pkg.go.dev/crypto/mldsa

Sign signs the message with the private key, implementing crypto.Signer.

```Go
func (sk *PrivateKey) Sign(_ io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error)
```

--------------------------------

### NewPublicKeyRSA

Source: https://pkg.go.dev/crypto/internal/boring

Creates a new RSA public key.

```APIDOC
## NewPublicKeyRSA

### Description
Creates a new RSA public key from the given modulus and exponent.

### Function Signature
`func NewPublicKeyRSA(N, E BigInt) (*PublicKeyRSA, error)`

### Parameters
- **N** (BigInt) - Required - The modulus.
- **E** (BigInt) - Required - The public exponent.

### Returns
- (*PublicKeyRSA) - The new public key.
- (error) - An error if the key is invalid.
```

--------------------------------

### func Version() string

Source: https://pkg.go.dev/crypto/internal/entropy/v1.0.0

Returns the version of the entropy source.

```APIDOC
## func Version

### Description
Returns the version of the entropy source. This is independent of the FIPS 140-3 module version, in order to reuse the ESV certificate across module versions.

### Function Signature
func Version() string

### Return Values
- **string** - The version string.
```

--------------------------------

### NewPublicKey65

Source: https://pkg.go.dev/crypto/internal/fips140/mldsa

Creates a public key from a byte slice for security parameter 65.

```APIDOC
## NewPublicKey65

### Description
Creates a public key from a byte slice for security parameter 65.

### Function
`func NewPublicKey65(pk []byte) (*PublicKey, error)`

### Parameters
- **pk** ([]byte) - Required - The public key bytes.

### Returns
- **\*PublicKey** - The public key.
- **error** - An error if the public key is invalid.

```

--------------------------------

### PublicKeyAlgorithm.String

Source: https://pkg.go.dev/crypto/x509

Returns the string representation of the PublicKeyAlgorithm value.

```APIDOC
## PublicKeyAlgorithm.String

### Description
Returns the string representation of the PublicKeyAlgorithm value.

### Method Signature
func (algo PublicKeyAlgorithm) String() string

### Parameters
- **algo** (PublicKeyAlgorithm) - Required - The algorithm value.

### Returns
- **string** - The string representation of the algorithm.

### Example
```go
str := algo.String()
```
```

--------------------------------

### Constants for key and signature sizes

Source: https://pkg.go.dev/crypto/mldsa

Defines constants for private key size and the public key and signature sizes for ML-DSA-44, ML-DSA-65, and ML-DSA-87 parameter sets.

```Go
const (
	PrivateKeySize = 32

	MLDSA44PublicKeySize = 1312
	MLDSA65PublicKeySize = 1952
	MLDSA87PublicKeySize = 2592

	MLDSA44SignatureSize = 2420
	MLDSA65SignatureSize = 3309
	MLDSA87SignatureSize = 4627
)
```
Tokens:
Raw