Source file src/pkg/crypto/rsa/pkcs1v15.go
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. 4 5 package rsa 6 7 import ( 8 "crypto" 9 "crypto/subtle" 10 "errors" 11 "io" 12 "math/big" 13 ) 14 15 // This file implements encryption and decryption using PKCS#1 v1.5 padding. 16 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 23 if len(msg) > k-11 { 24 err = ErrMessageTooLong 25 return 26 } 27 28 // EM = 0x02 || PS || 0x00 || M 29 em := make([]byte, k-1) 30 em[0] = 2 31 ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):] 32 err = nonZeroRandomBytes(ps, rand) 33 if err != nil { 34 return 35 } 36 em[len(em)-len(msg)-1] = 0 37 copy(mm, msg) 38 39 m := new(big.Int).SetBytes(em) 40 c := encrypt(new(big.Int), pub, m) 41 out = c.Bytes() 42 return 43 } 44 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 { 50 err = ErrDecryption 51 } 52 53 return 54 } 55 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 68 // (Crypto '98). 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 { 72 err = ErrDecryption 73 return 74 } 75 76 valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext) 77 if err != nil { 78 return 79 } 80 81 valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key))) 82 subtle.ConstantTimeCopy(valid, key, msg) 83 return 84 } 85 86 func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, msg []byte, err error) { 87 k := (priv.N.BitLen() + 7) / 8 88 if k < 11 { 89 err = ErrDecryption 90 return 91 } 92 93 c := new(big.Int).SetBytes(ciphertext) 94 m, err := decrypt(rand, priv, c) 95 if err != nil { 96 return 97 } 98 99 em := leftPad(m.Bytes(), k) 100 firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0) 101 secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2) 102 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 108 lookingForIndex = 1 109 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) 114 } 115 116 valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1) 117 msg = em[index+1:] 118 return 119 } 120 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) 124 if err != nil { 125 return 126 } 127 128 for i := 0; i < len(s); i++ { 129 for s[i] == 0 { 130 _, err = io.ReadFull(rand, s[i:i+1]) 131 if err != nil { 132 return 133 } 134 // In tests, the PRNG may return all zeros so we do 135 // this to break the loop. 136 s[i] ^= 0x42 137 } 138 } 139 140 return 141 } 142 143 // These are ASN1 DER structures: 144 // DigestInfo ::= SEQUENCE { 145 // digestAlgorithm AlgorithmIdentifier, 146 // digest OCTET STRING 147 // } 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}, 159 } 160 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)) 166 if err != nil { 167 return 168 } 169 170 tLen := len(prefix) + hashLen 171 k := (priv.N.BitLen() + 7) / 8 172 if k < tLen+11 { 173 return nil, ErrMessageTooLong 174 } 175 176 // EM = 0x00 || 0x01 || PS || 0x00 || T 177 em := make([]byte, k) 178 em[1] = 1 179 for i := 2; i < k-tLen-1; i++ { 180 em[i] = 0xff 181 } 182 copy(em[k-tLen:k-hashLen], prefix) 183 copy(em[k-hashLen:k], hashed) 184 185 m := new(big.Int).SetBytes(em) 186 c, err := decrypt(rand, priv, m) 187 if err == nil { 188 s = c.Bytes() 189 } 190 return 191 } 192 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)) 199 if err != nil { 200 return 201 } 202 203 tLen := len(prefix) + hashLen 204 k := (pub.N.BitLen() + 7) / 8 205 if k < tLen+11 { 206 err = ErrVerification 207 return 208 } 209 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 214 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) 220 221 for i := 2; i < k-tLen-1; i++ { 222 ok &= subtle.ConstantTimeByteEq(em[i], 0xff) 223 } 224 225 if ok != 1 { 226 return ErrVerification 227 } 228 229 return nil 230 } 231 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") 236 } 237 prefix, ok := hashPrefixes[hash] 238 if !ok { 239 return 0, nil, errors.New("unsupported hash function") 240 } 241 return 242 }