• hmac
  • md5
  • rand
  • rc4
  • rsa
  • sha1
  • sha256
  • sha512
  • subtle

hmac

func Equal

func Equal(mac1, mac2 []byte) bool

比较两个MAC是否相同，而不会泄露对比时间信息。（以规避时间侧信道攻击：指通过计算比较时花费的时间的长短来获取密码的信息，用于密码破解）

func New

func New(h func() hash.Hash, key []byte) hash.Hash

New函数返回一个采用hash.Hash作为底层hash接口、key作为密钥的HMAC算法的hash接口。

md5

md5包实现了MD5哈希算法，参见 RFC 1321 。

Constants

const BlockSize = 64

MD5字节块大小。

const Size = 16

MD5校验和字节数。

func Sum

func Sum(data []byte) [Size]byte

返回数据data的MD5校验和。

func New

func New() hash.Hash

返回一个新的使用MD5校验的hash.Hash接口。

func main() {
   str := "yangyangyang"
   //方法一
   data := []byte(str)
   has1 := md5.Sum(data)
   md5str1 := fmt.Sprintf("%x", has1) //将[]byte转成16进制
   fmt.Println(md5str1)
   
   str2 := "yangyangyang11"
   data2 := []byte(str2)
   has2 := md5.Sum(data2)
   md5str2 := fmt.Sprintf("%x", has2) //将[]byte转成16进制
   fmt.Println(md5str2)
}

rand

rand包实现了用于加解密的更安全的随机数生成器。

Variables

var Reader io.Reader

Reader是一个全局、共享的密码用强随机数生成器。在Unix类型系统中，会从/dev/urandom读取；而Windows中会调用CryptGenRandom API。

func Int

func Int(rand io.Reader, max *big.Int) (n *big.Int, err error)

返回一个在[0, max)区间服从均匀分布的随机值，如果max<=0则会panic。

func Prime

func Prime(rand io.Reader, bits int) (p *big.Int, err error)

返回一个具有指定字位数的数字，该数字具有很高可能性是质数。如果从rand读取时出错，或者bits<2会返回错误。

func Read

func Read(b []byte) (n int, err error)

本函数是一个使用io.ReadFull调用Reader.Read的辅助性函数。当且仅当err == nil时，返回值n == len(b)。

func main() {
   c := 10
   b := make([]byte, c)
   _, err := rand.Read(b)
   if err != nil {
      fmt.Println("error:", err)
      return
   }
   // The slice should now contain random bytes instead of only zeroes.
   fmt.Println(b)
   fmt.Println(bytes.Equal(b, make([]byte, c)))
}

rc4

rc4包实现了RC4加密算法，参见Bruce Schneier's Applied Cryptography。

type KeySizeError

type KeySizeError int

func (KeySizeError) Error

func (k KeySizeError) Error() string

type Cipher

type Cipher struct {
    s    [256]uint32
    i, j uint8
}

Cipher是一个使用特定密钥的RC4实例，本类型实现了cipher.Stream接口。

func NewCipher

func NewCipher(key []byte) (*Cipher, error)

NewCipher创建并返回一个新的Cipher。参数key是RC4密钥，至少1字节，最多256字节。

func (*Cipher) Reset

func (c *Cipher) Reset()

Reset方法会清空密钥数据，以便将其数据从程序内存中清除（以免被破解）

func (*Cipher) XORKeyStream

func (c *Cipher) XORKeyStream(dst, src []byte)

XORKeyStream方法将src的数据与秘钥生成的伪随机位流取XOR并写入dst。dst和src可指向同一内存地址；但如果指向不同则其底层内存不可重叠。

Bugs

RC4被广泛使用，但设计上的缺陷使它很少用于较新的协议中。

func main() {
   var key []byte = []byte("12345678") //初始化用于加密的KEY
   rc4obj, _ := rc4.NewCipher(key) //返回 Cipher
   rc4str := []byte("yangyangyang")  //需要加密的字符串
   plaintext := make([]byte, len(rc4str)) 
   rc4obj.XORKeyStream(plaintext, rc4str)

   stringinf1 := fmt.Sprintf("%x\n", plaintext) //转换字符串
   fmt.Println(stringinf1)
}

rsa

rsa包实现了PKCS#1规定的RSA加密算法。

Constants

const (
    // PSSSaltLengthAuto让PSS签名在签名时让盐尽可能长，并在验证时自动检测出盐。
    PSSSaltLengthAuto = 0
    // PSSSaltLengthEqualsHash让盐的长度和用于签名的哈希值的长度相同。
    PSSSaltLengthEqualsHash = -1
)

Variables

var ErrDecryption = errors.New("crypto/rsa: decryption error")

ErrDecryption代表解密数据失败。它故意写的语焉不详，以避免适应性攻击。

var ErrMessageTooLong = errors.New("crypto/rsa: message too long for RSA public key size")

当试图用公钥加密尺寸过大的数据时，就会返回ErrMessageTooLong。

var ErrVerification = errors.New("crypto/rsa: verification error")

ErrVerification代表认证签名失败。它故意写的语焉不详，以避免适应性攻击。

type CRTValue

type CRTValue struct {
    Exp   *big.Int // D mod (prime-1).
    Coeff *big.Int // R·Coeff ≡ 1 mod Prime.
    R     *big.Int // product of primes prior to this (inc p and q).
}

CRTValue包含预先计算的中国剩余定理的值。

type PrecomputedValues

type PrecomputedValues struct {
    Dp, Dq *big.Int // D mod (P-1) (or mod Q-1)
    Qinv   *big.Int // Q^-1 mod P
    // CRTValues用于保存第3个及其余的素数的预计算值。
    // 因为历史原因，头两个素数的CRT在PKCS#1中的处理是不同的。
    // 因为互操作性十分重要，我们镜像了这些素数的预计算值。
    CRTValues []CRTValue
}

type PublicKey

type PublicKey struct {
    N   *big.Int // 模
    E   int      // 公开的指数
}

代表一个RSA公钥。

type PrivateKey

type PrivateKey struct {
    PublicKey            // 公钥
    D         *big.Int   // 私有的指数
    Primes    []*big.Int // N的素因子，至少有两个
    // 包含预先计算好的值，可在某些情况下加速私钥的操作
    Precomputed PrecomputedValues
}

代表一个RSA私钥。

func GenerateKey

func GenerateKey(random io.Reader, bits int) (priv *PrivateKey, err error)

GenerateKey函数使用随机数据生成器random生成一对具有指定字位数的RSA密钥。

func GenerateMultiPrimeKey

func GenerateMultiPrimeKey(random io.Reader, nprimes int, bits int) (priv *PrivateKey, err error)

GenerateMultiPrimeKey使用指定的字位数生成一对多质数的RSA密钥，参见US patent 4405829。虽然公钥可以和二质数情况下的公钥兼容（事实上，不能区分两种公钥），私钥却不行。因此有可能无法生成特定格式的多质数的密钥对，或不能将生成的密钥用在其他（语言的）代码里。

http://www.cacr.math.uwaterloo.ca/techreports/2006/cacr2006-16.pdf 中的Table 1说明了给定字位数的密钥可以接受的质数最大数量。

func (*PrivateKey) Precompute

func (priv *PrivateKey) Precompute()

Precompute方法会预先进行一些计算，以加速未来的私钥的操作。

func (*PrivateKey) Validate

func (priv *PrivateKey) Validate() error

Validate方法进行密钥的完整性检查。如果密钥合法会返回nil，否则会返回说明问题的error值。

type PSSOptions

type PSSOptions struct {
    // SaltLength控制PSS签名中加盐的长度，可以是字节数，或者某个PSS盐长度的常数
    SaltLength int
}

PSSOptions包含用于创建和认证PSS签名的参数。

func EncryptOAEP

func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err error)

采用RSA-OAEP算法加密给出的数据。数据不能超过((公共模数的长度)-2*( hash长度)+2)字节。

func DecryptOAEP

func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) (msg []byte, err error)

DecryptOAEP解密RSA-OAEP算法加密的数据。如果random不是nil，函数会注意规避时间侧信道攻击。

func EncryptPKCS1v15

func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err error)

EncryptPKCS1v15使用PKCS#1 v1.5规定的填充方案和RSA算法加密msg。信息不能超过((公共模数的长度)-11)字节。注意：使用本函数加密明文（而不是会话密钥）是危险的，请尽量在新协议中使用RSA OAEP。

func DecryptPKCS1v15

func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err error)

DecryptPKCS1v15使用PKCS#1 v1.5规定的填充方案和RSA算法解密密文。如果random不是nil，函数会注意规避时间侧信道攻击。

func DecryptPKCS1v15SessionKey

func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err error)

DecryptPKCS1v15SessionKey使用PKCS#1 v1.5规定的填充方案和RSA算法解密会话密钥。如果random不是nil，函数会注意规避时间侧信道攻击。

如果密文长度不对，或者如果密文比公共模数的长度还长，会返回错误；否则，不会返回任何错误。如果填充是合法的，生成的明文信息会拷贝进key；否则，key不会被修改。这些情况都会在固定时间内出现（规避时间侧信道攻击）。本函数的目的是让程序的使用者事先生成一个随机的会话密钥，并用运行时的值继续协议。这样可以避免任何攻击者从明文窃取信息的可能性。

参见”Chosen Ciphertext Attacks Against Protocols Based on the RSA Encryption Standard PKCS #1”。

func SignPKCS1v15

func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) (s []byte, err error)

SignPKCS1v15使用RSA PKCS#1 v1.5规定的RSASSA-PKCS1-V1_5-SIGN签名方案计算签名。注意hashed必须是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。

func VerifyPKCS1v15

func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) (err error)

VerifyPKCS1v15认证RSA PKCS#1 v1.5签名。hashed是使用提供的hash参数对（要签名的）原始数据进行hash的结果。合法的签名会返回nil，否则表示签名不合法。

func SignPSS

func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte, opts *PSSOptions) (s []byte, err error)

SignPSS采用RSASSA-PSS方案计算签名。注意hashed必须是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。opts参数可以为nil，此时会使用默认参数。

func VerifyPSS

func VerifyPSS(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte, opts *PSSOptions) error

VerifyPSS认证一个PSS签名。hashed是使用提供给本函数的hash参数对（要签名的）原始数据进行hash的结果。合法的签名会返回nil，否则表示签名不合法。opts参数可以为nil，此时会使用默认参数。

// 生成RSA私钥和公钥，保存到文件中
// bits 证书大小
func GenerateRSAKey(bits int) {
   //GenerateKey函数使用随机数据生成器random生成一对具有指定字位数的RSA密钥
   //Reader是一个全局、共享的密码用强随机数生成器
   privateKey, err := rsa.GenerateKey(rand.Reader, bits)
   if err != nil {
      panic(err)
   }
   //保存私钥
   //通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
   X509PrivateKey := x509.MarshalPKCS1PrivateKey(privateKey)
   //使用pem格式对x509输出的内容进行编码
   //创建文件保存私钥
   privateFile, err := os.Create("private.pem")
   if err != nil {
      panic(err)
   }
   defer privateFile.Close()
   //构建一个pem.Block结构体对象
   privateBlock := pem.Block{Type: "RSA Private Key", Bytes: X509PrivateKey}
   //将数据保存到文件
   pem.Encode(privateFile, &privateBlock)

   //保存公钥
   //获取公钥的数据
   publicKey := privateKey.PublicKey
   //X509对公钥编码
   X509PublicKey, err := x509.MarshalPKIXPublicKey(&publicKey)
   if err != nil {
      panic(err)
   }
   //pem格式编码
   //创建用于保存公钥的文件
   publicFile, err := os.Create("public.pem")
   if err != nil {
      panic(err)
   }
   defer publicFile.Close()
   //创建一个pem.Block结构体对象
   publicBlock := pem.Block{Type: "RSA Public Key", Bytes: X509PublicKey}
   //保存到文件
   pem.Encode(publicFile, &publicBlock)
}

func main() {
   //生成密钥对，保存到文件
   GenerateRSAKey(2048)
}
//RSA加密
// plainText 要加密的数据
// path 公钥匙文件地址
func RSA_Encrypt(plainText []byte, path string) []byte {
   //打开文件
   file, err := os.Open(path)
   if err != nil {
      panic(err)
   }
   defer file.Close()
   //读取文件的内容
   info, _ := file.Stat()
   buf := make([]byte, info.Size())
   file.Read(buf)
   //pem解码
   block, _ := pem.Decode(buf)
   //x509解码

   publicKeyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
   if err != nil {
      panic(err)
   }
   //类型断言
   publicKey := publicKeyInterface.(*rsa.PublicKey)
   //对明文进行加密
   cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, plainText)
   if err != nil {
      panic(err)
   }
   //返回密文
   return cipherText
}

//RSA解密
// cipherText 需要解密的byte数据
// path 私钥文件路径
func RSA_Decrypt(cipherText []byte,path string) []byte{
   //打开文件
   file,err:=os.Open(path)
   if err!=nil{
      panic(err)
   }
   defer file.Close()
   //获取文件内容
   info, _ := file.Stat()
   buf:=make([]byte,info.Size())
   file.Read(buf)
   //pem解码
   block, _ := pem.Decode(buf)
   //X509解码
   privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
   if err!=nil{
      panic(err)
   }
   //对密文进行解密
   plainText,_:=rsa.DecryptPKCS1v15(rand.Reader,privateKey,cipherText)
   //返回明文
   return plainText
}

func main() {
   //加密
   data := []byte("hello world")
   encrypt := RSA_Encrypt(data, "public.pem")
   fmt.Println(string(encrypt))

   // 解密
   decrypt := RSA_Decrypt(encrypt, "private.pem")
   fmt.Println(string(decrypt))
}

sha1

sha1包实现了SHA1哈希算法，参见 RFC 3174 。

Constants

const BlockSize = 64

SHA1的块大小。

const Size = 20

SHA1校验和的字节数。

func Sum

func Sum(data []byte) [Size]byte

返回数据data的SHA1校验和。

func main() {
   data := []byte("This page intentionally left blank.")
   fmt.Printf("% x", sha1.Sum(data))
}

func New

func New() hash.Hash

返回一个新的使用SHA1校验的hash.Hash接口。

func main() {
   h := sha1.New()
   io.WriteString(h, "His money is twice tainted:")
   io.WriteString(h, " 'taint yours and 'taint mine.")
   fmt.Printf("% x", h.Sum(nil))
}

sha256

sha256包实现了SHA224和SHA256哈希算法，参见FIPS 180-4。

Constants

const BlockSize = 64

SHA224和SHA256的字节块大小。

const Size = 32

SHA256校验和的字节长度。

const Size224 = 28

SHA224校验和的字节长度。

func Sum256

func Sum256(data []byte) [Size]byte

返回数据的SHA256校验和。

func New

func New() hash.Hash

返回一个新的使用SHA256校验算法的hash.Hash接口。

func Sum224

func Sum224(data []byte) (sum224 [Size224]byte)

返回数据的SHA224校验和。

func New224

func New224() hash.Hash

返回一个新的使用SHA224校验算法的hash.Hash接口。

sha512

sha512包实现了SHA384和SHA512哈希算法，参见FIPS 180-2。

Constants

const BlockSize = 128

SHA384和SHA512的字节块大小。

const Size = 64

SHA512校验和的字节长度。

const Size384 = 48

SHA384校验和的字节长度。

func Sum512

func Sum512(data []byte) [Size]byte

返回数据的SHA512校验和。

func New

func New() hash.Hash

返回一个新的使用SHA512校验算法的hash.Hash接口。

func Sum384

func Sum384(data []byte) (sum384 [Size384]byte)

返回数据的SHA384校验和。

func New384

func New384() hash.Hash

返回一个新的使用SHA384校验算法的hash.Hash接口。

subtle

Package subtle implements functions that are often useful in cryptographic code but require careful thought to use correctly.（翻译得不满意，还是原版z好）

func ConstantTimeByteEq

func ConstantTimeByteEq(x, y uint8) int

如果x == y返回1，否则返回0。

func ConstantTimeEq

func ConstantTimeEq(x, y int32) int

如果x == y返回1，否则返回0。

func ConstantTimeLessOrEq

func ConstantTimeLessOrEq(x, y int) int

如果x <= y返回1，否则返回0；如果x或y为负数，或者大于2**31-1，函数行为是未定义的。

func ConstantTimeCompare

func ConstantTimeCompare(x, y []byte) int

如果x、y的长度和内容都相同返回1；否则返回0。消耗的时间正比于切片长度而与内容无关。

func ConstantTimeCopy

func ConstantTimeCopy(v int, x, y []byte)

如果v == 1,则将y的内容拷贝到x；如果v == 0，x不作修改；其他情况的行为是未定义并应避免的。

func ConstantTimeSelect

func ConstantTimeSelect(v, x, y int) int

如果v == 1，返回x；如果v == 0，返回y；其他情况的行为是未定义并应避免的。