crypto/rsa

const (
        // PSSSaltLengthAuto导致PSS签名中的salt一样大
        // 签名时尽可能，并在验证时自动检测。
        PSSSaltLengthAuto = 0
        // PSSSaltLengthEqualsHash使salt长度等于长度
        // 签名中使用的哈希值
        PSSSaltLengthEqualsHash = -1
)

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

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

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

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

ciphertext, _ := hex.DecodeString("4d1ee10e8f286390258c51a5e80802844c3e6358ad6690b7285218a7c7ed7fc3a4c7b950fbd04d4b0239cc060dcc7065ca6f84c1756deb71ca5685cadbb82be025e16449b905c568a19c088a1abfad54bf7ecc67a7df39943ec511091a34c0f2348d04e058fcff4d55644de3cd1d580791d4524b92f3e91695582e6e340a1c50b6c6d78e80b4e42c5b4d45e479b492de42bbd39cc642ebb80226bb5200020d501b24a37bcc2ec7f34e596b4fd6b063de4858dbf5a4e3dd18e262eda0ec2d19dbd8e890d672b63d368768360b20c0b6b8592a438fa275e5fa7f60bef0dd39673fd3989cc54d2cb80c08fcd19dacbc265ee1c6014616b0e04ea0328c2a04e73460")
label := []byte("orders")

// crypto / rand.Reader是阻塞RSA的良好熵源
// 操作。
rng := rand.Reader

plaintext, err := DecryptOAEP(sha256.New(), rng, test2048Key, ciphertext, label)
if err != nil {
        fmt.Fprintf(os.Stderr, "Error from decryption: %s\n", err)
        return
}

fmt.Printf("Plaintext: %s\n", string(plaintext))

// 请记住，加密仅提供机密性。该
// 密文应该在假定真实性之前签署，甚至
// 甚至，考虑消息可能会被重新排序。

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

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

// crypto/rand.Reader是阻塞RSA的良好熵源
// 操作。
rng := rand.Reader

// 混合方案应该使用至少一个16字节的对称密钥。 这里
// 我们读取了RSA解密时不会使用的随机密钥
// 良好的。
key := make([]byte, 32)
if _, err := io.ReadFull(rng, key); err != nil {
        panic("RNG failure")
}

rsaCiphertext, _ := hex.DecodeString("aabbccddeeff")

if err := DecryptPKCS1v15SessionKey(rng, rsaPrivateKey, rsaCiphertext, key); err != nil {
        // 任何导致的错误都将是“public” - 意味着它们
        // 可以确定没有任何秘密信息。 （对于
        // 例如，如果给定RSA，则密钥的长度是不可能的
        // 公钥。）
        fmt.Fprintf(os.Stderr, "Error from RSA decryption: %s\n", err)
        return
}

// 给定得到的密钥，可以使用对称方案来解密a
// 更大的密文。
block, err := aes.NewCipher(key)
if err != nil {
        panic("aes.NewCipher failed: " + err.Error())
}

// 由于密钥是随机的，因此使用固定的随机数是可以接受的
// 根据需要，（key, nonce）对仍然是唯一的。
var zeroNonce [12]byte
aead, err := cipher.NewGCM(block)
if err != nil {
        panic("cipher.NewGCM failed: " + err.Error())
}
ciphertext, _ := hex.DecodeString("00112233445566")
plaintext, err := aead.Open(nil, zeroNonce[:], ciphertext, nil)
if err != nil {
        // RSA密文形成错误; 解密会
        // 因为AES-GCM密钥不正确而在这里失败。
        fmt.Fprintf(os.Stderr, "Error decrypting: %s\n", err)
        return
}

fmt.Printf("Plaintext: %s\n", string(plaintext))

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

secretMessage := []byte("send reinforcements, we're going to advance")
label := []byte("orders")

// crypto/rand.Reader是随机化的一个很好的熵源
// 加密函数。
rng := rand.Reader

ciphertext, err := EncryptOAEP(sha256.New(), rng, &test2048Key.PublicKey, secretMessage, label)
if err != nil {
        fmt.Fprintf(os.Stderr, "Error from encryption: %s\n", err)
        return
}

// 由于加密是随机函数，密文将是
// 每次都不一样。
fmt.Printf("Ciphertext: %x\n", ciphertext)

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

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

// crypto/rand.Reader是阻塞RSA的良好熵源
// 操作
rng := rand.Reader

message := []byte("message to be signed")

// 只能直接签署小邮件; 因此以下的哈希
// 消息，而不是消息本身，签署。 这需要
// 哈希函数是抗冲突的。 SHA-256是
// 当时应该使用的最强哈希函数
// writing（2016）。
hashed := sha256.Sum256(message)

signature, err := SignPKCS1v15(rng, rsaPrivateKey, crypto.SHA256, hashed[:])
if err != nil {
        fmt.Fprintf(os.Stderr, "Error from signing: %s\n", err)
        return
}

fmt.Printf("Signature: %x\n", signature)

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

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

message := []byte("message to be signed")
signature, _ := hex.DecodeString("ad2766728615cc7a746cc553916380ca7bfa4f8983b990913bc69eb0556539a350ff0f8fe65ddfd3ebe91fe1c299c2fac135bc8c61e26be44ee259f2f80c1530")

// 只能直接签署小邮件; 因此以下的哈希
// 消息，而不是消息本身，签署。 这需要
// 哈希函数是抗冲突的。 SHA-256是
// 当时应该使用的最强哈希函数
// writing (2016)。
hashed := sha256.Sum256(message)

err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, crypto.SHA256, hashed[:], signature)
if err != nil {
        fmt.Fprintf(os.Stderr, "Error from verification: %s\n", err)
        return
}

// 签名是来自公钥的消息的有效签名。

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

type CRTValue struct {
        Exp   *big.Int // D mod (prime-1).
        Coeff *big.Int // R·Coeff ≡ 1 mod Prime.
        R     *big.Int // 在此之前的素数乘积（inc p和q）。
}

type OAEPOptions struct {
        // 散列是生成掩码时将使用的散列函数。
        Hash crypto.Hash
        // Label是一个任意字节字符串，必须等于该值
        // 加密时使用。
        Label []byte
}

type PKCS1v15DecryptOptions struct {
        // SessionKeyLen是正在进行的会话密钥的长度
        // 解密。 如果不为零，则解密期间的填充错误将
        // 导致返回此长度的随机明文而不是
        // 一个错误。 这些替代方案在不断的时间内发
        SessionKeyLen int
}

type PSSOptions struct {
        // SaltLength 控制 PSS 中使用的salt 的长度
        // 签名。 它可以是多个字节，也可以是特殊字节之一
        // PSSSaltLength常数。
        SaltLength int

        // 散列（如果不为零）会覆盖传递给SignPSS的散列函数。
        // 这是使用时指定哈希函数的唯一方法
        // crypto.Signer接口。
        Hash crypto.Hash
}

func (pssOpts *PSSOptions) HashFunc() crypto.Hash

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 PrivateKey struct {
        PublicKey            // 公共部分。
        D         *big.Int   // 私有指数
        Primes    []*big.Int // N的素因子有> = 2个元素。

        // 预计算包含加速私有的预计算值
        // 操作，如果有的话。
        Precomputed PrecomputedValues
}

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

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

func (priv *PrivateKey) Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)

func (priv *PrivateKey) Precompute()

func (priv *PrivateKey) Public() crypto.PublicKey

func (priv *PrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.SignerOpts) ([]byte, error)

func (priv *PrivateKey) Validate() error

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