1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
15 // This file implements encryption and decryption using PKCS#1 v1.5 padding.
17 // EncryptPKCS1v15 encrypts the given message with RSA and the padding scheme from PKCS#1 v1.5.
18 // The message must be no longer than the length of the public modulus minus 11 bytes.
19 // WARNING: use of this function to encrypt plaintexts other than session keys
20 // is dangerous. Use RSA OAEP in new protocols.
21 func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err error) {
22 k := (pub.N.BitLen() + 7) / 8
24 err = ErrMessageTooLong
28 // EM = 0x02 || PS || 0x00 || M
29 em := make([]byte, k-1)
31 ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):]
32 err = nonZeroRandomBytes(ps, rand)
36 em[len(em)-len(msg)-1] = 0
39 m := new(big.Int).SetBytes(em)
40 c := encrypt(new(big.Int), pub, m)
45 // DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from PKCS#1 v1.5.
46 // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks.
47 func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err error) {
48 valid, out, err := decryptPKCS1v15(rand, priv, ciphertext)
49 if err == nil && valid == 0 {
56 // DecryptPKCS1v15SessionKey decrypts a session key using RSA and the padding scheme from PKCS#1 v1.5.
57 // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks.
58 // It returns an error if the ciphertext is the wrong length or if the
59 // ciphertext is greater than the public modulus. Otherwise, no error is
60 // returned. If the padding is valid, the resulting plaintext message is copied
61 // into key. Otherwise, key is unchanged. These alternatives occur in constant
62 // time. It is intended that the user of this function generate a random
63 // session key beforehand and continue the protocol with the resulting value.
64 // This will remove any possibility that an attacker can learn any information
65 // about the plaintext.
66 // See ``Chosen Ciphertext Attacks Against Protocols Based on the RSA
67 // Encryption Standard PKCS #1'', Daniel Bleichenbacher, Advances in Cryptology
69 func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err error) {
70 k := (priv.N.BitLen() + 7) / 8
71 if k-(len(key)+3+8) < 0 {
76 valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext)
81 valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key)))
82 subtle.ConstantTimeCopy(valid, key, msg)
86 func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, msg []byte, err error) {
87 k := (priv.N.BitLen() + 7) / 8
93 c := new(big.Int).SetBytes(ciphertext)
94 m, err := decrypt(rand, priv, c)
99 em := leftPad(m.Bytes(), k)
100 firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0)
101 secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2)
103 // The remainder of the plaintext must be a string of non-zero random
104 // octets, followed by a 0, followed by the message.
105 // lookingForIndex: 1 iff we are still looking for the zero.
106 // index: the offset of the first zero byte.
107 var lookingForIndex, index int
110 for i := 2; i < len(em); i++ {
111 equals0 := subtle.ConstantTimeByteEq(em[i], 0)
112 index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index)
113 lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex)
116 valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1)
121 // nonZeroRandomBytes fills the given slice with non-zero random octets.
122 func nonZeroRandomBytes(s []byte, rand io.Reader) (err error) {
123 _, err = io.ReadFull(rand, s)
128 for i := 0; i < len(s); i++ {
130 _, err = io.ReadFull(rand, s[i:i+1])
134 // In tests, the PRNG may return all zeros so we do
135 // this to break the loop.
143 // These are ASN1 DER structures:
144 // DigestInfo ::= SEQUENCE {
145 // digestAlgorithm AlgorithmIdentifier,
146 // digest OCTET STRING
148 // For performance, we don't use the generic ASN1 encoder. Rather, we
149 // precompute a prefix of the digest value that makes a valid ASN1 DER string
150 // with the correct contents.
151 var hashPrefixes = map[crypto.Hash][]byte{
152 crypto.MD5: {0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10},
153 crypto.SHA1: {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14},
154 crypto.SHA256: {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20},
155 crypto.SHA384: {0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30},
156 crypto.SHA512: {0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40},
157 crypto.MD5SHA1: {}, // A special TLS case which doesn't use an ASN1 prefix.
158 crypto.RIPEMD160: {0x30, 0x20, 0x30, 0x08, 0x06, 0x06, 0x28, 0xcf, 0x06, 0x03, 0x00, 0x31, 0x04, 0x14},
161 // SignPKCS1v15 calculates the signature of hashed using RSASSA-PKCS1-V1_5-SIGN from RSA PKCS#1 v1.5.
162 // Note that hashed must be the result of hashing the input message using the
163 // given hash function.
164 func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) (s []byte, err error) {
165 hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed))
170 tLen := len(prefix) + hashLen
171 k := (priv.N.BitLen() + 7) / 8
173 return nil, ErrMessageTooLong
176 // EM = 0x00 || 0x01 || PS || 0x00 || T
177 em := make([]byte, k)
179 for i := 2; i < k-tLen-1; i++ {
182 copy(em[k-tLen:k-hashLen], prefix)
183 copy(em[k-hashLen:k], hashed)
185 m := new(big.Int).SetBytes(em)
186 c, err := decrypt(rand, priv, m)
193 // VerifyPKCS1v15 verifies an RSA PKCS#1 v1.5 signature.
194 // hashed is the result of hashing the input message using the given hash
195 // function and sig is the signature. A valid signature is indicated by
196 // returning a nil error.
197 func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) (err error) {
198 hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed))
203 tLen := len(prefix) + hashLen
204 k := (pub.N.BitLen() + 7) / 8
206 err = ErrVerification
210 c := new(big.Int).SetBytes(sig)
211 m := encrypt(new(big.Int), pub, c)
212 em := leftPad(m.Bytes(), k)
213 // EM = 0x00 || 0x01 || PS || 0x00 || T
215 ok := subtle.ConstantTimeByteEq(em[0], 0)
216 ok &= subtle.ConstantTimeByteEq(em[1], 1)
217 ok &= subtle.ConstantTimeCompare(em[k-hashLen:k], hashed)
218 ok &= subtle.ConstantTimeCompare(em[k-tLen:k-hashLen], prefix)
219 ok &= subtle.ConstantTimeByteEq(em[k-tLen-1], 0)
221 for i := 2; i < k-tLen-1; i++ {
222 ok &= subtle.ConstantTimeByteEq(em[i], 0xff)
226 return ErrVerification
232 func pkcs1v15HashInfo(hash crypto.Hash, inLen int) (hashLen int, prefix []byte, err error) {
233 hashLen = hash.Size()
234 if inLen != hashLen {
235 return 0, nil, errors.New("input must be hashed message")
237 prefix, ok := hashPrefixes[hash]
239 return 0, nil, errors.New("unsupported hash function")