package cipher

Import Path
	crypto/cipher (on go.dev)

Dependency Relation
	imports 6 packages, and imported by 11 packages

Involved Source Files

	    cbc.go
	    cfb.go
	  d cipher.go
		Package cipher implements standard block cipher modes that can be wrapped
		around low-level block cipher implementations.
		See https://csrc.nist.gov/groups/ST/toolkit/BCM/current_modes.html
		and NIST Special Publication 800-38A.

	    ctr.go
	    gcm.go
	    io.go
	    ofb.go
Code Examples

	NewCBCDecrypter
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"encoding/hex"
			"fmt"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
			ciphertext, _ := hex.DecodeString("73c86d43a9d700a253a96c85b0f6b03ac9792e0e757f869cca306bd3cba1c62b")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// The IV needs to be unique, but not secure. Therefore it's common to
			// include it at the beginning of the ciphertext.
			if len(ciphertext) < aes.BlockSize {
				panic("ciphertext too short")
			}
			iv := ciphertext[:aes.BlockSize]
			ciphertext = ciphertext[aes.BlockSize:]
		
			// CBC mode always works in whole blocks.
			if len(ciphertext)%aes.BlockSize != 0 {
				panic("ciphertext is not a multiple of the block size")
			}
		
			mode := cipher.NewCBCDecrypter(block, iv)
		
			// CryptBlocks can work in-place if the two arguments are the same.
			mode.CryptBlocks(ciphertext, ciphertext)
		
			// If the original plaintext lengths are not a multiple of the block
			// size, padding would have to be added when encrypting, which would be
			// removed at this point. For an example, see
			// https://tools.ietf.org/html/rfc5246#section-6.2.3.2. However, it's
			// critical to note that ciphertexts must be authenticated (i.e. by
			// using crypto/hmac) before being decrypted in order to avoid creating
			// a padding oracle.
		
			fmt.Printf("%s\n", ciphertext)
		}

	NewCBCEncrypter
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"crypto/rand"
			"encoding/hex"
			"fmt"
			"io"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
			plaintext := []byte("exampleplaintext")
		
			// CBC mode works on blocks so plaintexts may need to be padded to the
			// next whole block. For an example of such padding, see
			// https://tools.ietf.org/html/rfc5246#section-6.2.3.2. Here we'll
			// assume that the plaintext is already of the correct length.
			if len(plaintext)%aes.BlockSize != 0 {
				panic("plaintext is not a multiple of the block size")
			}
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// The IV needs to be unique, but not secure. Therefore it's common to
			// include it at the beginning of the ciphertext.
			ciphertext := make([]byte, aes.BlockSize+len(plaintext))
			iv := ciphertext[:aes.BlockSize]
			if _, err := io.ReadFull(rand.Reader, iv); err != nil {
				panic(err)
			}
		
			mode := cipher.NewCBCEncrypter(block, iv)
			mode.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)
		
			// It's important to remember that ciphertexts must be authenticated
			// (i.e. by using crypto/hmac) as well as being encrypted in order to
			// be secure.
		
			fmt.Printf("%x\n", ciphertext)
		}

	NewCFBDecrypter
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"encoding/hex"
			"fmt"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
			ciphertext, _ := hex.DecodeString("7dd015f06bec7f1b8f6559dad89f4131da62261786845100056b353194ad")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// The IV needs to be unique, but not secure. Therefore it's common to
			// include it at the beginning of the ciphertext.
			if len(ciphertext) < aes.BlockSize {
				panic("ciphertext too short")
			}
			iv := ciphertext[:aes.BlockSize]
			ciphertext = ciphertext[aes.BlockSize:]
		
			stream := cipher.NewCFBDecrypter(block, iv)
		
			// XORKeyStream can work in-place if the two arguments are the same.
			stream.XORKeyStream(ciphertext, ciphertext)
			fmt.Printf("%s", ciphertext)
		}

	NewCFBEncrypter
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"crypto/rand"
			"encoding/hex"
			"fmt"
			"io"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
			plaintext := []byte("some plaintext")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// The IV needs to be unique, but not secure. Therefore it's common to
			// include it at the beginning of the ciphertext.
			ciphertext := make([]byte, aes.BlockSize+len(plaintext))
			iv := ciphertext[:aes.BlockSize]
			if _, err := io.ReadFull(rand.Reader, iv); err != nil {
				panic(err)
			}
		
			stream := cipher.NewCFBEncrypter(block, iv)
			stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
		
			// It's important to remember that ciphertexts must be authenticated
			// (i.e. by using crypto/hmac) as well as being encrypted in order to
			// be secure.
			fmt.Printf("%x\n", ciphertext)
		}

	NewCTR
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"crypto/rand"
			"encoding/hex"
			"fmt"
			"io"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
			plaintext := []byte("some plaintext")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// The IV needs to be unique, but not secure. Therefore it's common to
			// include it at the beginning of the ciphertext.
			ciphertext := make([]byte, aes.BlockSize+len(plaintext))
			iv := ciphertext[:aes.BlockSize]
			if _, err := io.ReadFull(rand.Reader, iv); err != nil {
				panic(err)
			}
		
			stream := cipher.NewCTR(block, iv)
			stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
		
			// It's important to remember that ciphertexts must be authenticated
			// (i.e. by using crypto/hmac) as well as being encrypted in order to
			// be secure.
		
			// CTR mode is the same for both encryption and decryption, so we can
			// also decrypt that ciphertext with NewCTR.
		
			plaintext2 := make([]byte, len(plaintext))
			stream = cipher.NewCTR(block, iv)
			stream.XORKeyStream(plaintext2, ciphertext[aes.BlockSize:])
		
			fmt.Printf("%s\n", plaintext2)
		}

	NewGCM_decrypt
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"encoding/hex"
			"fmt"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// Seal/Open calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			// When decoded the key should be 16 bytes (AES-128) or 32 (AES-256).
			key, _ := hex.DecodeString("6368616e676520746869732070617373776f726420746f206120736563726574")
			ciphertext, _ := hex.DecodeString("c3aaa29f002ca75870806e44086700f62ce4d43e902b3888e23ceff797a7a471")
			nonce, _ := hex.DecodeString("64a9433eae7ccceee2fc0eda")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err.Error())
			}
		
			aesgcm, err := cipher.NewGCM(block)
			if err != nil {
				panic(err.Error())
			}
		
			plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
			if err != nil {
				panic(err.Error())
			}
		
			fmt.Printf("%s\n", plaintext)
		}

	NewGCM_encrypt
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"crypto/rand"
			"encoding/hex"
			"fmt"
			"io"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// Seal/Open calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			// When decoded the key should be 16 bytes (AES-128) or 32 (AES-256).
			key, _ := hex.DecodeString("6368616e676520746869732070617373776f726420746f206120736563726574")
			plaintext := []byte("exampleplaintext")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err.Error())
			}
		
			// Never use more than 2^32 random nonces with a given key because of the risk of a repeat.
			nonce := make([]byte, 12)
			if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
				panic(err.Error())
			}
		
			aesgcm, err := cipher.NewGCM(block)
			if err != nil {
				panic(err.Error())
			}
		
			ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil)
			fmt.Printf("%x\n", ciphertext)
		}

	NewOFB
		package main
		
		import (
			"crypto/aes"
			"crypto/cipher"
			"crypto/rand"
			"encoding/hex"
			"fmt"
			"io"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
			plaintext := []byte("some plaintext")
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// The IV needs to be unique, but not secure. Therefore it's common to
			// include it at the beginning of the ciphertext.
			ciphertext := make([]byte, aes.BlockSize+len(plaintext))
			iv := ciphertext[:aes.BlockSize]
			if _, err := io.ReadFull(rand.Reader, iv); err != nil {
				panic(err)
			}
		
			stream := cipher.NewOFB(block, iv)
			stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
		
			// It's important to remember that ciphertexts must be authenticated
			// (i.e. by using crypto/hmac) as well as being encrypted in order to
			// be secure.
		
			// OFB mode is the same for both encryption and decryption, so we can
			// also decrypt that ciphertext with NewOFB.
		
			plaintext2 := make([]byte, len(plaintext))
			stream = cipher.NewOFB(block, iv)
			stream.XORKeyStream(plaintext2, ciphertext[aes.BlockSize:])
		
			fmt.Printf("%s\n", plaintext2)
		}

	StreamReader
		package main
		
		import (
			"bytes"
			"crypto/aes"
			"crypto/cipher"
			"encoding/hex"
			"io"
			"os"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
		
			encrypted, _ := hex.DecodeString("cf0495cc6f75dafc23948538e79904a9")
			bReader := bytes.NewReader(encrypted)
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// If the key is unique for each ciphertext, then it's ok to use a zero
			// IV.
			var iv [aes.BlockSize]byte
			stream := cipher.NewOFB(block, iv[:])
		
			reader := &cipher.StreamReader{S: stream, R: bReader}
			// Copy the input to the output stream, decrypting as we go.
			if _, err := io.Copy(os.Stdout, reader); err != nil {
				panic(err)
			}
		
			// Note that this example is simplistic in that it omits any
			// authentication of the encrypted data. If you were actually to use
			// StreamReader in this manner, an attacker could flip arbitrary bits in
			// the output.
		
		}

	StreamWriter
		package main
		
		import (
			"bytes"
			"crypto/aes"
			"crypto/cipher"
			"encoding/hex"
			"fmt"
			"io"
		)
		
		func main() {
			// Load your secret key from a safe place and reuse it across multiple
			// NewCipher calls. (Obviously don't use this example key for anything
			// real.) If you want to convert a passphrase to a key, use a suitable
			// package like bcrypt or scrypt.
			key, _ := hex.DecodeString("6368616e676520746869732070617373")
		
			bReader := bytes.NewReader([]byte("some secret text"))
		
			block, err := aes.NewCipher(key)
			if err != nil {
				panic(err)
			}
		
			// If the key is unique for each ciphertext, then it's ok to use a zero
			// IV.
			var iv [aes.BlockSize]byte
			stream := cipher.NewOFB(block, iv[:])
		
			var out bytes.Buffer
		
			writer := &cipher.StreamWriter{S: stream, W: &out}
			// Copy the input to the output buffer, encrypting as we go.
			if _, err := io.Copy(writer, bReader); err != nil {
				panic(err)
			}
		
			// Note that this example is simplistic in that it omits any
			// authentication of the encrypted data. If you were actually to use
			// StreamReader in this manner, an attacker could flip arbitrary bits in
			// the decrypted result.
		
			fmt.Printf("%x\n", out.Bytes())
		}


Package-Level Type Names (total 18, in which 6 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type AEAD (interface)
		AEAD is a cipher mode providing authenticated encryption with associated
		data. For a description of the methodology, see
		https://en.wikipedia.org/wiki/Authenticated_encryption.

		Methods (total 4, all are exported)
			( AEAD) NonceSize() int
				NonceSize returns the size of the nonce that must be passed to Seal
				and Open.

			( AEAD) Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error)
				Open decrypts and authenticates ciphertext, authenticates the
				additional data and, if successful, appends the resulting plaintext
				to dst, returning the updated slice. The nonce must be NonceSize()
				bytes long and both it and the additional data must match the
				value passed to Seal.
				
				To reuse ciphertext's storage for the decrypted output, use ciphertext[:0]
				as dst. Otherwise, the remaining capacity of dst must not overlap plaintext.
				
				Even if the function fails, the contents of dst, up to its capacity,
				may be overwritten.

			( AEAD) Overhead() int
				Overhead returns the maximum difference between the lengths of a
				plaintext and its ciphertext.

			( AEAD) Seal(dst, nonce, plaintext, additionalData []byte) []byte
				Seal encrypts and authenticates plaintext, authenticates the
				additional data and appends the result to dst, returning the updated
				slice. The nonce must be NonceSize() bytes long and unique for all
				time, for a given key.
				
				To reuse plaintext's storage for the encrypted output, use plaintext[:0]
				as dst. Otherwise, the remaining capacity of dst must not overlap plaintext.

		Implemented By (at least 7, none are exported)
			/* 7+ unexporteds ... *//* 7+ unexporteds: */
			*gcm
			*crypto/aes.gcmAsm
			 crypto/tls.aead (interface)
			*crypto/tls.prefixNonceAEAD
			*crypto/tls.xorNonceAEAD
			*vendor/golang.org/x/crypto/chacha20poly1305.chacha20poly1305
			*vendor/golang.org/x/crypto/chacha20poly1305.xchacha20poly1305
		As Outputs Of (at least 7, in which 6 are exported)
			func NewGCM(cipher Block) (AEAD, error)
			func NewGCMWithNonceSize(cipher Block, size int) (AEAD, error)
			func NewGCMWithTagSize(cipher Block, tagSize int) (AEAD, error)
			func crypto/internal/boring.NewGCMTLS(Block) (AEAD, error)
			func vendor/golang.org/x/crypto/chacha20poly1305.New(key []byte) (AEAD, error)
			func vendor/golang.org/x/crypto/chacha20poly1305.NewX(key []byte) (AEAD, error)
			/* at least one unexported ... *//* at least one unexported: */
			func newGCMWithNonceAndTagSize(cipher Block, nonceSize, tagSize int) (AEAD, error)

	 type Block (interface)
		A Block represents an implementation of block cipher
		using a given key. It provides the capability to encrypt
		or decrypt individual blocks. The mode implementations
		extend that capability to streams of blocks.

		Methods (total 3, all are exported)
			( Block) BlockSize() int
				BlockSize returns the cipher's block size.

			( Block) Decrypt(dst, src []byte)
				Decrypt decrypts the first block in src into dst.
				Dst and src must overlap entirely or not at all.

			( Block) Encrypt(dst, src []byte)
				Encrypt encrypts the first block in src into dst.
				Dst and src must overlap entirely or not at all.

		Implemented By (at least 5, none are exported)
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			*crypto/aes.aesCipher
			*crypto/aes.aesCipherAsm
			*crypto/aes.aesCipherGCM
			*crypto/des.desCipher
			*crypto/des.tripleDESCipher
		As Outputs Of (at least 6, in which 4 are exported)
			func crypto/aes.NewCipher(key []byte) (Block, error)
			func crypto/des.NewCipher(key []byte) (Block, error)
			func crypto/des.NewTripleDESCipher(key []byte) (Block, error)
			func crypto/internal/boring.NewAESCipher(key []byte) (Block, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func crypto/aes.newCipher(key []byte) (Block, error)
			func crypto/aes.newCipherGeneric(key []byte) (Block, error)
		As Inputs Of (at least 21, in which 14 are exported)
			func NewCBCDecrypter(b Block, iv []byte) BlockMode
			func NewCBCEncrypter(b Block, iv []byte) BlockMode
			func NewCFBDecrypter(block Block, iv []byte) Stream
			func NewCFBEncrypter(block Block, iv []byte) Stream
			func NewCTR(block Block, iv []byte) Stream
			func NewGCM(cipher Block) (AEAD, error)
			func NewGCMWithNonceSize(cipher Block, size int) (AEAD, error)
			func NewGCMWithTagSize(cipher Block, tagSize int) (AEAD, error)
			func NewOFB(b Block, iv []byte) Stream
			func crypto/internal/boring.NewGCMTLS(Block) (AEAD, error)
			func github.com/gotd/ige.DecryptBlocks(block Block, iv, dst, src []byte)
			func github.com/gotd/ige.EncryptBlocks(block Block, iv, dst, src []byte)
			func github.com/gotd/ige.NewIGEDecrypter(b Block, iv []byte) ige.IGE
			func github.com/gotd/ige.NewIGEEncrypter(b Block, iv []byte) ige.IGE
			/* 7+ unexporteds ... *//* 7+ unexporteds: */
			func newCBC(b Block, iv []byte) *cbc
			func newCBCGenericDecrypter(b Block, iv []byte) BlockMode
			func newCBCGenericEncrypter(b Block, iv []byte) BlockMode
			func newCFB(block Block, iv []byte, decrypt bool) Stream
			func newGCMWithNonceAndTagSize(cipher Block, nonceSize, tagSize int) (AEAD, error)
			func github.com/gotd/ige.checkIV(b Block, iv []byte) error
			func github.com/gotd/ige.newIGE(b Block, iv []byte) *ige.ige

	 type BlockMode (interface)
		A BlockMode represents a block cipher running in a block-based mode (CBC,
		ECB etc).

		Methods (total 2, both are exported)
			( BlockMode) BlockSize() int
				BlockSize returns the mode's block size.

			( BlockMode) CryptBlocks(dst, src []byte)
				CryptBlocks 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), CryptBlocks should panic. It is acceptable
				to pass a dst bigger than src, and in that case, CryptBlocks will
				only update dst[:len(src)] and will not touch the rest of dst.
				
				Multiple calls to CryptBlocks behave as if the concatenation of
				the src buffers was passed in a single run. That is, BlockMode
				maintains state and does not reset at each CryptBlocks call.

		Implemented By (at least 6, in which 1 is exported)
			 github.com/gotd/ige.IGE (interface)
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			*cbcDecrypter
			*cbcEncrypter
			 crypto/tls.cbcMode (interface)
			*github.com/gotd/ige.igeDecrypter
			*github.com/gotd/ige.igeEncrypter
		Implements (at least one exported)
			 BlockMode : github.com/gotd/ige.IGE
		As Outputs Of (at least 4, in which 2 are exported)
			func NewCBCDecrypter(b Block, iv []byte) BlockMode
			func NewCBCEncrypter(b Block, iv []byte) BlockMode
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newCBCGenericDecrypter(b Block, iv []byte) BlockMode
			func newCBCGenericEncrypter(b Block, iv []byte) BlockMode

	 type Stream (interface)
		A Stream represents a stream cipher.

		Methods (only one, which is exported)
			( Stream) XORKeyStream(dst, src []byte)
				XORKeyStream XORs each byte in the given slice with a byte from the
				cipher's key stream. Dst and src must overlap entirely or not at all.
				
				If len(dst) < len(src), XORKeyStream should panic. It is acceptable
				to pass a dst bigger than src, and in that case, XORKeyStream will
				only update dst[:len(src)] and will not touch the rest of dst.
				
				Multiple calls to XORKeyStream behave as if the concatenation of
				the src buffers was passed in a single run. That is, Stream
				maintains state and does not reset at each XORKeyStream call.

		Implemented By (at least 5, in which 2 are exported)
			*crypto/rc4.Cipher
			*vendor/golang.org/x/crypto/chacha20.Cipher
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*cfb
			*ctr
			*ofb
		As Outputs Of (at least 6, in which 4 are exported)
			func NewCFBDecrypter(block Block, iv []byte) Stream
			func NewCFBEncrypter(block Block, iv []byte) Stream
			func NewCTR(block Block, iv []byte) Stream
			func NewOFB(b Block, iv []byte) Stream
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newCFB(block Block, iv []byte, decrypt bool) Stream
			func github.com/gotd/td/internal/mtproxy/obfuscated2.createCTR(key, iv []byte) (Stream, error)

	 type StreamReader (struct)
		StreamReader wraps a Stream into an io.Reader. It calls XORKeyStream
		to process each slice of data which passes through.

		Fields (total 2, both are exported)
			R io.Reader
			S Stream
		Methods (only one, which is exported)
			( StreamReader) Read(dst []byte) (n int, err error)
		Implements (at least one exported)
			 StreamReader : io.Reader

	 type StreamWriter (struct)
		StreamWriter wraps a Stream into an io.Writer. It calls XORKeyStream
		to process each slice of data which passes through. If any Write call
		returns short then the StreamWriter is out of sync and must be discarded.
		A StreamWriter has no internal buffering; Close does not need
		to be called to flush write data.

		Fields (total 3, all are exported)
			Err error
				// unused

			S Stream
			W io.Writer
		Methods (total 2, both are exported)
			( StreamWriter) Close() error
				Close closes the underlying Writer and returns its Close return value, if the Writer
				is also an io.Closer. Otherwise it returns nil.

			( StreamWriter) Write(src []byte) (n int, err error)
		Implements (at least 5, in which 4 are exported)
			 StreamWriter : internal/bisect.Writer
			 StreamWriter : io.Closer
			 StreamWriter : io.WriteCloser
			 StreamWriter : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			 StreamWriter : crypto/tls.transcriptHash

	/* 12 unexporteds ... *//* 12 unexporteds: */
	 type cbc (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			b Block
			blockSize int
			iv []byte
			tmp []byte
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newCBC(b Block, iv []byte) *cbc

	 type cbcDecAble (interface)
		cbcDecAble is an interface implemented by ciphers that have a specific
		optimized implementation of CBC decryption, like crypto/aes.
		NewCBCDecrypter will check for this interface and return the specific
		BlockMode if found.

		Methods (only one, which is exported)
			( cbcDecAble) NewCBCDecrypter(iv []byte) BlockMode
		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 crypto/aes.cbcDecAble (interface)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 cbcDecAble : crypto/aes.cbcDecAble

	 type cbcDecrypter cbc (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			b Block
			blockSize int
			iv []byte
			tmp []byte
		Methods (total 3, all are exported)
			(*cbcDecrypter) BlockSize() int
			(*cbcDecrypter) CryptBlocks(dst, src []byte)
			(*cbcDecrypter) SetIV(iv []byte)
		Implements (at least 3, in which 2 are exported)
			*cbcDecrypter : BlockMode
			*cbcDecrypter : github.com/gotd/ige.IGE
			/* at least one unexported ... *//* at least one unexported: */
			*cbcDecrypter : crypto/tls.cbcMode

	 type cbcEncAble (interface)
		cbcEncAble is an interface implemented by ciphers that have a specific
		optimized implementation of CBC encryption, like crypto/aes.
		NewCBCEncrypter will check for this interface and return the specific
		BlockMode if found.

		Methods (only one, which is exported)
			( cbcEncAble) NewCBCEncrypter(iv []byte) BlockMode
		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 crypto/aes.cbcEncAble (interface)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 cbcEncAble : crypto/aes.cbcEncAble

	 type cbcEncrypter cbc (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			b Block
			blockSize int
			iv []byte
			tmp []byte
		Methods (total 3, all are exported)
			(*cbcEncrypter) BlockSize() int
			(*cbcEncrypter) CryptBlocks(dst, src []byte)
			(*cbcEncrypter) SetIV(iv []byte)
		Implements (at least 3, in which 2 are exported)
			*cbcEncrypter : BlockMode
			*cbcEncrypter : github.com/gotd/ige.IGE
			/* at least one unexported ... *//* at least one unexported: */
			*cbcEncrypter : crypto/tls.cbcMode

	 type cfb (struct)

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			b Block
			decrypt bool
			next []byte
			out []byte
			outUsed int
		Methods (only one, which is exported)
			(*cfb) XORKeyStream(dst, src []byte)
		Implements (at least one exported)
			*cfb : Stream

	 type ctr (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			b Block
			ctr []byte
			out []byte
			outUsed int
		Methods (total 2, in which 1 is exported)
			(*ctr) XORKeyStream(dst, src []byte)
			/* one unexported ... *//* one unexported: */
			(*ctr) refill()
		Implements (at least one exported)
			*ctr : Stream

	 type ctrAble (interface)
		ctrAble is an interface implemented by ciphers that have a specific optimized
		implementation of CTR, like crypto/aes. NewCTR will check for this interface
		and return the specific Stream if found.

		Methods (only one, which is exported)
			( ctrAble) NewCTR(iv []byte) Stream
		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 crypto/aes.ctrAble (interface)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 ctrAble : crypto/aes.ctrAble

	 type gcm (struct)
		gcm represents a Galois Counter Mode with a specific key. See
		https://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-revised-spec.pdf

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			cipher Block
			nonceSize int
			productTable [16]gcmFieldElement
				productTable contains the first sixteen powers of the key, H.
				However, they are in bit reversed order. See NewGCMWithNonceSize.

			tagSize int
		Methods (total 10, in which 4 are exported)
			(*gcm) NonceSize() int
			(*gcm) Open(dst, nonce, ciphertext, data []byte) ([]byte, error)
			(*gcm) Overhead() int
			(*gcm) Seal(dst, nonce, plaintext, data []byte) []byte
			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*gcm) auth(out, ciphertext, additionalData []byte, tagMask *[16]byte)
				auth calculates GHASH(ciphertext, additionalData), masks the result with
				tagMask and writes the result to out.

			(*gcm) counterCrypt(out, in []byte, counter *[16]byte)
				counterCrypt crypts in to out using g.cipher in counter mode.

			(*gcm) deriveCounter(counter *[16]byte, nonce []byte)
				deriveCounter computes the initial GCM counter state from the given nonce.
				See NIST SP 800-38D, section 7.1. This assumes that counter is filled with
				zeros on entry.

			(*gcm) mul(y *gcmFieldElement)
				mul sets y to y*H, where H is the GCM key, fixed during NewGCMWithNonceSize.

			(*gcm) update(y *gcmFieldElement, data []byte)
				update extends y with more polynomial terms from data. If data is not a
				multiple of gcmBlockSize bytes long then the remainder is zero padded.

			(*gcm) updateBlocks(y *gcmFieldElement, blocks []byte)
				updateBlocks extends y with more polynomial terms from blocks, based on
				Horner's rule. There must be a multiple of gcmBlockSize bytes in blocks.

		Implements (at least one exported)
			*gcm : AEAD

	 type gcmAble (interface)
		gcmAble is an interface implemented by ciphers that have a specific optimized
		implementation of GCM, like crypto/aes. NewGCM will check for this interface
		and return the specific AEAD if found.

		Methods (only one, which is exported)
			( gcmAble) NewGCM(nonceSize, tagSize int) (AEAD, error)
		Implemented By (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*crypto/aes.aesCipherGCM
			 crypto/aes.gcmAble (interface)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 gcmAble : crypto/aes.gcmAble

	 type gcmFieldElement (struct)
		gcmFieldElement represents a value in GF(2¹²⁸). In order to reflect the GCM
		standard and make binary.BigEndian suitable for marshaling these values, the
		bits are stored in big endian order. For example:
		
			the coefficient of x⁰ can be obtained by v.low >> 63.
			the coefficient of x⁶³ can be obtained by v.low & 1.
			the coefficient of x⁶⁴ can be obtained by v.high >> 63.
			the coefficient of x¹²⁷ can be obtained by v.high & 1.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			high uint64
			low uint64
		As Outputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func gcmAdd(x, y *gcmFieldElement) gcmFieldElement
			func gcmDouble(x *gcmFieldElement) (double gcmFieldElement)
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func gcmAdd(x, y *gcmFieldElement) gcmFieldElement
			func gcmDouble(x *gcmFieldElement) (double gcmFieldElement)

	 type ofb (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			b Block
			cipher []byte
			out []byte
			outUsed int
		Methods (total 2, in which 1 is exported)
			(*ofb) XORKeyStream(dst, src []byte)
			/* one unexported ... *//* one unexported: */
			(*ofb) refill()
		Implements (at least one exported)
			*ofb : Stream


Package-Level Functions (total 19, in which 9 are exported)

	 func NewCBCDecrypter(b Block, iv []byte) BlockMode
		NewCBCDecrypter returns a BlockMode which decrypts in cipher block chaining
		mode, using the given Block. The length of iv must be the same as the
		Block's block size and must match the iv used to encrypt the data.

	 func NewCBCEncrypter(b Block, iv []byte) BlockMode
		NewCBCEncrypter returns a BlockMode which encrypts in cipher block chaining
		mode, using the given Block. The length of iv must be the same as the
		Block's block size.

	 func NewCFBDecrypter(block Block, iv []byte) Stream
		NewCFBDecrypter returns a Stream which decrypts with cipher feedback mode,
		using the given Block. The iv must be the same length as the Block's block
		size.

	 func NewCFBEncrypter(block Block, iv []byte) Stream
		NewCFBEncrypter returns a Stream which encrypts with cipher feedback mode,
		using the given Block. The iv must be the same length as the Block's block
		size.

	 func NewCTR(block Block, iv []byte) Stream
		NewCTR returns a Stream which encrypts/decrypts using the given Block in
		counter mode. The length of iv must be the same as the Block's block size.

	 func NewGCM(cipher Block) (AEAD, error)
		NewGCM returns the given 128-bit, block cipher wrapped in Galois Counter Mode
		with the standard nonce length.
		
		In general, the GHASH operation performed by this implementation of GCM is not constant-time.
		An exception is when the underlying Block was created by aes.NewCipher
		on systems with hardware support for AES. See the crypto/aes package documentation for details.

	 func NewGCMWithNonceSize(cipher Block, size int) (AEAD, error)
		NewGCMWithNonceSize returns the given 128-bit, block cipher wrapped in Galois
		Counter Mode, which accepts nonces of the given length. The length must not
		be zero.
		
		Only use this function if you require compatibility with an existing
		cryptosystem that uses non-standard nonce lengths. All other users should use
		NewGCM, which is faster and more resistant to misuse.

	 func NewGCMWithTagSize(cipher Block, tagSize int) (AEAD, error)
		NewGCMWithTagSize returns the given 128-bit, block cipher wrapped in Galois
		Counter Mode, which generates tags with the given length.
		
		Tag sizes between 12 and 16 bytes are allowed.
		
		Only use this function if you require compatibility with an existing
		cryptosystem that uses non-standard tag lengths. All other users should use
		NewGCM, which is more resistant to misuse.

	 func NewOFB(b Block, iv []byte) Stream
		NewOFB returns a Stream that encrypts or decrypts using the block cipher b
		in output feedback mode. The initialization vector iv's length must be equal
		to b's block size.

	/* 10 unexporteds ... *//* 10 unexporteds: */
	 func gcmAdd(x, y *gcmFieldElement) gcmFieldElement
		gcmAdd adds two elements of GF(2¹²⁸) and returns the sum.

	 func gcmDouble(x *gcmFieldElement) (double gcmFieldElement)
		gcmDouble returns the result of doubling an element of GF(2¹²⁸).

	 func gcmInc32(counterBlock *[16]byte)
		gcmInc32 treats the final four bytes of counterBlock as a big-endian value
		and increments it.

	 func newCBC(b Block, iv []byte) *cbc
	 func newCBCGenericDecrypter(b Block, iv []byte) BlockMode
		newCBCGenericDecrypter returns a BlockMode which encrypts in cipher block chaining
		mode, using the given Block. The length of iv must be the same as the
		Block's block size. This always returns the generic non-asm decrypter for use in
		fuzz testing.

	 func newCBCGenericEncrypter(b Block, iv []byte) BlockMode
		newCBCGenericEncrypter returns a BlockMode which encrypts in cipher block chaining
		mode, using the given Block. The length of iv must be the same as the
		Block's block size. This always returns the generic non-asm encrypter for use
		in fuzz testing.

	 func newCFB(block Block, iv []byte, decrypt bool) Stream
	 func newGCMWithNonceAndTagSize(cipher Block, nonceSize, tagSize int) (AEAD, error)
	 func reverseBits(i int) int
		reverseBits reverses the order of the bits of 4-bit number in i.

	 func sliceForAppend(in []byte, n int) (head, tail []byte)
		sliceForAppend takes a slice and a requested number of bytes. It returns a
		slice with the contents of the given slice followed by that many bytes and a
		second slice that aliases into it and contains only the extra bytes. If the
		original slice has sufficient capacity then no allocation is performed.


Package-Level Variables (total 2, neither is exported)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var errOpen error
	  var gcmReductionTable []uint16
Package-Level Constants (total 5, none are exported)

	/* 5 unexporteds ... *//* 5 unexporteds: */
	const gcmBlockSize = 16
	const gcmMinimumTagSize = 12 // NIST SP 800-38D recommends tags with 12 or more bytes.
	const gcmStandardNonceSize = 12
	const gcmTagSize = 16
	const streamBufferSize = 512

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.