archive
archive/tar
archive/zip
bufio
bufio（缓存）
builtin
builtin（内置包）
bytes
bytes（包字节）
compress
compress/bzip2（压缩/bzip2）
compress/flate（压缩/flate）
compress/gzip（压缩/gzip）
compress/lzw（压缩/lzw）
compress/zlib（压缩/zlib）
container
container/heap（容器数据结构heap）
container/list（容器数据结构list）
container/ring（容器数据结构ring）
context
context（上下文）
crypto
crypto（加密）
crypto/aes（加密/aes）
crypto/cipher（加密/cipher）
crypto/des（加密/des）
crypto/dsa（加密/dsa）
crypto/ecdsa（加密/ecdsa）
crypto/elliptic（加密/elliptic）
crypto/hmac（加密/hmac）
crypto/md5（加密/md5）
crypto/rand（加密/rand）
crypto/rc4（加密/rc4）
crypto/rsa（加密/rsa）
crypto/sha1（加密/sha1）
crypto/sha256（加密/sha256）
crypto/sha512（加密/sha512）
crypto/subtle（加密/subtle）
crypto/tls（加密/tls）
crypto/x509（加密/x509）
crypto/x509/pkix（加密/x509/pkix）
database
database/sql（数据库/sql）
database/sql/driver（数据库/sql/driver）
debug
debug/dwarf（调试/dwarf）
debug/elf（调试/elf）
debug/gosym（调试/gosym）
debug/macho（调试/macho）
debug/pe（调试/pe）
debug/plan9obj（调试/plan9obj）
encoding
encoding（编码）
encoding/ascii85（编码/ascii85）
encoding/asn1（编码/asn1）
encoding/base32（编码/base32）
encoding/base64（编码/base64）
encoding/binary（编码/binary）
encoding/csv（编码/csv）
encoding/gob（编码/gob）
encoding/hex（编码/hex）
encoding/json（编码/json）
encoding/pem（编码/pem）
encoding/xml（编码/xml）
errors
errors（错误）
expvar
expvar
flag
flag（命令行参数解析flag包）
fmt
fmt
go
go/ast（抽象语法树）
go/build
go/constant（常量）
go/doc（文档）
go/format（格式）
go/importer
go/parser
go/printer
go/scanner（扫描仪）
go/token（令牌）
go/types（类型）
hash
hash（散列）
hash/adler32
hash/crc32
hash/crc64
hash/fnv
html
html
html/template（模板）
image
image（图像）
image/color（颜色）
image/color/palette（调色板）
image/draw（绘图）
image/gif
image/jpeg
image/png
index
index/suffixarray
io
io
io/ioutil
log
log
log/syslog（日志系统）
math
math
math/big
math/big
math/bits
math/bits
math/cmplx
math/cmplx
math/rand
math/rand
mime
mime
mime/multipart（多部分）
mime/quotedprintable
net
net
net/http
net/http
net/http/cgi
net/http/cookiejar
net/http/fcgi
net/http/httptest
net/http/httptrace
net/http/httputil
net/http/internal
net/http/pprof
net/mail
net/mail
net/rpc
net/rpc
net/rpc/jsonrpc
net/smtp
net/smtp
net/textproto
net/textproto
net/url
net/url
os
os
os/exec
os/signal
os/user
path
path
path/filepath（文件路径）
plugin
plugin（插件）
reflect
reflect（反射）
regexp
regexp（正则表达式）
regexp/syntax
runtime
runtime（运行时）
runtime/debug（调试）
runtime/internal/sys
runtime/pprof
runtime/race（竞争）
runtime/trace（执行追踪器）
sort
sort（排序算法）
strconv
strconv（转换）
strings
strings（字符串）
sync
sync（同步）
sync/atomic（原子操作）
syscall
syscall（系统调用）
testing
testing（测试）
testing/iotest
testing/quick
text
text/scanner（扫描文本）
text/tabwriter
text/template（定义模板）
text/template/parse
time
time（时间戳）
unicode
unicode
unicode/utf16
unicode/utf8
unsafe
unsafe
©
本文档使用 PHP中文网手册 发布
文字
import "crypto/cipher"
概述
索引
示例
概述
加密包（Package cipher）实现了标准块密码模式，可以围绕低级块密码实现。请参阅http://csrc.nist.gov/groups/ST/toolkit/BCM/current_modes.html和NIST Special Publication
800-38A。
索引
type AEAD
func NewGCM(cipher Block) (AEAD, error)
func NewGCMWithNonceSize(cipher Block, size int) (AEAD, error)
type Block
type BlockMode
func NewCBCDecrypter(b Block, iv []byte) BlockMode
func NewCBCEncrypter(b Block, iv []byte) BlockMode
type Stream
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
type StreamReader
func (r StreamReader) Read(dst []byte) (n int, err error)
type StreamWriter
func (w StreamWriter) Close() error
func (w StreamWriter) Write(src []byte) (n int, err error)
示例
NewCBCDecrypter NewCBCEncrypter NewCFBDecrypter NewCFBEncrypter NewCTR NewGCM (Decrypt) NewGCM (Encrypt) NewOFB StreamReader StreamWriter
文件包
cbc.go cfb.go cipher.go ctr.go gcm.go io.go ofb.go xor.go
type AEAD
AEAD是一种密码模式，提供带有关联数据的认证加密。有关该方法的说明，请参阅
https://en.wikipedia.org/wiki/Authenticated_encryption
type AEAD interface { // NonceSize返回必须传递给Seal的随机数的大小 // and Open. NonceSize() int // Overhead返回以下两者间的最大差异 // plaintext 和 its ciphertext. Overhead() int // 密封加密和验证明文，验证 // 附加数据并将结果附加到dst，并返回更新 // slice。 nonce必须是NonceSize()字节长且对所有人都是唯一的 // time, 对于给定的密钥。 // // 明文和dst可能完全或根本不是别名。 重用 // 明文的加密输出存储，使用 plaintext[:0]作为dst。 Seal(dst, nonce, plaintext, additionalData []byte) []byte // 打开解密并验证密文，验证密文 // 额外的数据，如果成功的话，附加结果明文 // 到dst，返回更新的片。 nonce必须是NonceSize() // 字节长，它和附加数据必须匹配 // 值传递给Seal。 // // 密文和dst可以完全混淆或根本不混淆。 重用 // 密文的解密输出存储，使用ciphertext [:0]作为dst。 // // 即使该功能失败，dst的内容，直到其容量， // 可能会被覆盖。 Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error)}func NewGCM
func NewGCM(cipher Block) (AEAD, error)
NewGCM 返回给定的128-bit，以伽罗华计数器模式(Galois Counter Mode包装的分组密码，其标准随机数长度。
一般来说，这种 GCM 实施的 GHASH 操作不是一个固定时间。当硬件支持 AES 的系统上由 aes.NewCipher 创建底层 Block 时，则是个例外。有关详细信息，请参阅 crypto/aes 软件包文档。
示例（Decrypt）
package mainimport ("crypto/aes""crypto/cipher""encoding/hex""fmt")func main() {// 关键参数应该是AES密钥，16或32个字节// 选择 AES-128 或 AES-256。
key := []byte("AES256Key-32Characters1234567890")
ciphertext, _ := hex.DecodeString("1019aa66cd7c024f9efd0038899dae1973ee69427f5a6579eba292ffe1b5a260")
nonce, _ := hex.DecodeString("37b8e8a308c354048d245f6d")
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)}示例（Encrypt）
package mainimport ("crypto/aes""crypto/cipher""crypto/rand""fmt""io")func main() {// 关键参数应该是AES密钥，16或32个字节// 选择AES-128或AES-256。
key := []byte("AES256Key-32Characters1234567890")
plaintext := []byte("exampleplaintext")
block, err := aes.NewCipher(key)if err != nil {panic(err.Error())}// 由于存在重复的风险，请勿使用给定密钥使用超过2^32个随机值。
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)}func NewGCMWithNonceSize
func NewGCMWithNonceSize(cipher Block, size int) (AEAD, error)
NewGCMWithNonceSize 返回给定的 128 位，以 Galois 计数器模式包装的分组密码，它接受给定长度的随机数。
如果您需要与使用非标准随机数长度的现有密码系统兼容，请仅使用此功能。所有其他用户都应该使用 NewGCM，它更快，更耐滥用。
type Block
块表示使用给定密钥的分组密码的实现。它提供了加密或解密各个块的功能。模式实现将该能力扩展到块流。
type Block interface { // BlockSize返回密码的块大小。 BlockSize() int // 加密将src中的第一个块加密到dst中。 // Dst和src可能指向相同的内存。 Encrypt(dst, src []byte) // 解密将src中的第一个块解密为dst。 // Dst和src可能指向相同的内存。 Decrypt(dst, src []byte)}type BlockMode
BlockMode表示以基于块的模式运行的分组密码（CBC，ECB等）。
type BlockMode interface { // BlockSize返回模式的块大小。 BlockSize() int // CryptBlocks加密或解密一些块。 The length of // src必须是块大小的倍数。 Dst和src可能指向 // 相同的内存。 CryptBlocks(dst, src []byte)}func NewCBCDecrypter
func NewCBCDecrypter(b Block, iv []byte) BlockMode
NewCBCDecrypter 返回一个 BlockMode，它使用给定的Block 以密码块链接模式解密。iv 的长度必须与 Block 的块大小相同，并且必须与用于加密数据的 iv 相匹配。
示例
package mainimport ("crypto/aes""crypto/cipher""encoding/hex""fmt")func main() {
key := []byte("example key 1234")
ciphertext, _ := hex.DecodeString("f363f3ccdcb12bb883abf484ba77d9cd7d32b5baecb3d4b1b3e0e4beffdb3ded")
block, err := aes.NewCipher(key)if err != nil {panic(err)}// IV需要独特，但不安全。 所以这很常见// 将其包括在密文的开头。if len(ciphertext) < aes.BlockSize {panic("ciphertext too short")}
iv := ciphertext[:aes.BlockSize]
ciphertext = ciphertext[aes.BlockSize:]// CBC模式总是在整个模块中工作。if len(ciphertext)%aes.BlockSize != 0 {panic("ciphertext is not a multiple of the block size")}
mode := cipher.NewCBCDecrypter(block, iv)// 如果两个参数相同，CryptBlocks可以在原地工作。
mode.CryptBlocks(ciphertext, ciphertext)// 如果原始plaintext长度不是块的倍数// 大小，填充将不得不在加密时添加，这将是// 在这一点删除。 有关示例，请参阅// https://tools.ietf.org/html/rfc5246#section-6.2.3.2. 然而，// 至关重要的是要注意密文必须被认证（即通过// 使用crypto/hmac）解密之前，以避免创建// 一个填充oracle。
fmt.Printf("%s\n", ciphertext)}func NewCBCEncrypter
func NewCBCEncrypter(b Block, iv []byte) BlockMode
NewCBCEncrypter 返回一个 BlockMode，它使用给定的 Block 以密码块链接模式加密。iv 的长度必须与块的块大小相同。
示例
package mainimport ("crypto/aes""crypto/cipher""crypto/rand""fmt""io")func main() {
key := []byte("example key 1234")
plaintext := []byte("exampleplaintext")// CBC模式在块上工作，所以明文可能需要填充到块// 下一个整块。 有关这种填充的示例，请参阅// https://tools.ietf.org/html/rfc5246#section-6.2.3.2. 这里，我们将// 假定 plaintext 已经是正确的长度。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)}// IV需要独特，但不安全。 所以这很常见// 将其包括在密文的开头。
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)// 记住密文必须经过认证是很重要的// （即通过使用crypto/hmac）以及为了加密而被加密// 保持secure。
fmt.Printf("%x\n", ciphertext)}type Stream
Stream表示流密码。
type Stream interface { // XORKeyStream将给定片中的每个字节与来自该字节的一个字节异或 // 密码的密钥流。 Dst和src可能指向相同的内存。 // 如果len（dst）<len（src），XORKeyStream应该是恐慌的。 它是可以接受的 // 传递比src更大的dst，在那种情况下，XORKeyStream会 // 只更新dst[:len(src)]并且不会触及dst的其余部分。 XORKeyStream(dst, src []byte)}func NewCFBDecrypter
func NewCFBDecrypter(block Block, iv []byte) Stream
新的 CFB 解密器使用给定的块返回一个使用密码反馈模式解密的 Stream。iv 的长度必须与块的块大小相同。
示例
package mainimport ("crypto/aes""crypto/cipher""encoding/hex""fmt")func main() {
key := []byte("example key 1234")
ciphertext, _ := hex.DecodeString("22277966616d9bc47177bd02603d08c9a67d5380d0fe8cf3b44438dff7b9")
block, err := aes.NewCipher(key)if err != nil {panic(err)}// IV需要独特，但不安全。 所以这很常见// 将其包括在密文的开头。if len(ciphertext) < aes.BlockSize {panic("ciphertext too short")}
iv := ciphertext[:aes.BlockSize]
ciphertext = ciphertext[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(block, iv)// 如果两个参数相同，XORKeyStream可以在原地工作。
stream.XORKeyStream(ciphertext, ciphertext)
fmt.Printf("%s", ciphertext)}func NewCFBEncrypter
func NewCFBEncrypter(block Block, iv []byte) Stream
NewCFBEncrypter 使用给定的 Block 返回一个使用密码反馈模式加密的 Stream。iv 的长度必须与块的块大小相同。
示例
package mainimport ("crypto/aes""crypto/cipher""crypto/rand""io")func main() {
key := []byte("example key 1234")
plaintext := []byte("some plaintext")
block, err := aes.NewCipher(key)if err != nil {panic(err)}// IV需要独特，但不安全。 所以这很常见// 将其包括在密文的开头。
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)// 记住密文必须经过认证是很重要的// （即通过使用crypto/hmac）以及为了加密而被加密// 保持secure。}func NewCTR
func NewCTR(block Block, iv []byte) Stream
NewCTR 返回一个 Stream，它使用计数器模式下的给定 Block加密/解密。iv 的长度必须与块的块大小相同。
示例
package mainimport ("crypto/aes""crypto/cipher""crypto/rand""fmt""io")func main() {
key := []byte("example key 1234")
plaintext := []byte("some plaintext")
block, err := aes.NewCipher(key)if err != nil {panic(err)}// IV需要独特，但不安全。 所以这很常见// 将其包括在密文的开头。
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)// 记住密文必须经过认证是很重要的// （即通过使用crypto/hmac）以及为了加密而被加密// 保持secure。// CTR模式对于加密和解密都是一样的，所以我们可以// 也用NewCTR解密该密文。
plaintext2 := make([]byte, len(plaintext))
stream = cipher.NewCTR(block, iv)
stream.XORKeyStream(plaintext2, ciphertext[aes.BlockSize:])
fmt.Printf("%s\n", plaintext2)}func NewOFB
func NewOFB(b Block, iv []byte) Stream
NewOFB 返回一个在输出反馈模式下使用分组密码 b 进行加密或解密的 Stream。初始化矢量 iv 的长度必须等于 b 的块大小。
示例
package mainimport ("crypto/aes""crypto/cipher""crypto/rand""fmt""io")func main() {
key := []byte("example key 1234")
plaintext := []byte("some plaintext")
block, err := aes.NewCipher(key)if err != nil {panic(err)}// IV需要独特，但不安全。 所以这很常见// 将其包括在密文的开头。
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)// 记住密文必须经过认证是很重要的// （即通过使用crypto/hmac）以及为了加密而被加密// 保持secure。// OFB模式对加密和解密都是一样的，所以我们可以// 也使用 NewOFB 解密该密文。
plaintext2 := make([]byte, len(plaintext))
stream = cipher.NewOFB(block, iv)
stream.XORKeyStream(plaintext2, ciphertext[aes.BlockSize:])
fmt.Printf("%s\n", plaintext2)}type StreamReader
StreamReader 将 Stream 封装到 io.Reader 中。它调用 XORKeyStream 来处理通过的每一片数据。
type StreamReader struct {
S Stream
R io.Reader}示例
package mainimport ("crypto/aes""crypto/cipher""io""os")func main() {
key := []byte("example key 1234")
inFile, err := os.Open("encrypted-file")if err != nil {panic(err)}
defer inFile.Close()
block, err := aes.NewCipher(key)if err != nil {panic(err)}// 如果密钥对于每个密文都是唯一的，那么可以使用零// IV.var iv [aes.BlockSize]byte
stream := cipher.NewOFB(block, iv[:])
outFile, err := os.OpenFile("decrypted-file", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)if err != nil {panic(err)}
defer outFile.Close()
reader := &cipher.StreamReader{S: stream, R: inFile}// 将输入文件复制到输出文件，随着我们的解密。if _, err := io.Copy(outFile, reader); err != nil {panic(err)}// 请注意，这个例子是简单的，因为它省略了// 加密数据的认证。 如果你真的使用// StreamReader以这种方式，攻击者可以翻转任意位// 输出。}func (StreamReader) Read
func (r StreamReader) Read(dst []byte) (n int, err error)
type StreamWriter
StreamWriter 将 Stream 封装到 io.Writer 中。它调用 XORKeyStream 来处理通过的每一片数据。如果任何写入调用返回短，那么 StreamWriter 不同步并且必须被丢弃。StreamWriter 没有内部缓冲；不需要调用 Close 来刷新写入数据。
type StreamWriter struct {
S Stream
W io.Writer
Err error // unused}示例
package mainimport ("crypto/aes""crypto/cipher""io""os")func main() {
key := []byte("example key 1234")
inFile, err := os.Open("plaintext-file")if err != nil {panic(err)}
defer inFile.Close()
block, err := aes.NewCipher(key)if err != nil {panic(err)}// 如果密钥对于每个密文都是唯一的，那么可以使用zero// IV.var iv [aes.BlockSize]byte
stream := cipher.NewOFB(block, iv[:])
outFile, err := os.OpenFile("encrypted-file", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)if err != nil {panic(err)}
defer outFile.Close()
writer := &cipher.StreamWriter{S: stream, W: outFile}// 将输入文件复制到输出文件，并随时加密。if _, err := io.Copy(writer, inFile); err != nil {panic(err)}// 请注意，这个例子是简单的，因为它省略了// 加密数据的认证。 如果你真的使用// StreamReader以这种方式，攻击者可以翻转任意位// 解密的结果。}func (StreamWriter) Close
func (w StreamWriter) Close() error
Close 关闭底层 Writer 并返回其 Close 返回值，如果 Writer 也是 io.Closer。否则它返回零。
func (StreamWriter) Write
func (w StreamWriter) Write(src []byte) (n int, err error)