| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package rsa |
| |
| import ( |
| "crypto" |
| "crypto/subtle" |
| "errors" |
| "io" |
| "math/big" |
| |
| "crypto/internal/randutil" |
| ) |
| |
| import "crypto/internal/boring" |
| |
| // This file implements encryption and decryption using PKCS #1 v1.5 padding. |
| |
| // PKCS1v15DecrypterOpts is for passing options to PKCS #1 v1.5 decryption using |
| // the crypto.Decrypter interface. |
| type PKCS1v15DecryptOptions struct { |
| // SessionKeyLen is the length of the session key that is being |
| // decrypted. If not zero, then a padding error during decryption will |
| // cause a random plaintext of this length to be returned rather than |
| // an error. These alternatives happen in constant time. |
| SessionKeyLen int |
| } |
| |
| // EncryptPKCS1v15 encrypts the given message with RSA and the padding |
| // scheme from PKCS #1 v1.5. The message must be no longer than the |
| // length of the public modulus minus 11 bytes. |
| // |
| // The rand parameter is used as a source of entropy to ensure that |
| // encrypting the same message twice doesn't result in the same |
| // ciphertext. |
| // |
| // WARNING: use of this function to encrypt plaintexts other than |
| // session keys is dangerous. Use RSA OAEP in new protocols. |
| func EncryptPKCS1v15(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error) { |
| randutil.MaybeReadByte(random) |
| |
| if err := checkPub(pub); err != nil { |
| return nil, err |
| } |
| k := pub.Size() |
| if len(msg) > k-11 { |
| return nil, ErrMessageTooLong |
| } |
| |
| if boring.Enabled && random == boring.RandReader { |
| bkey, err := boringPublicKey(pub) |
| if err != nil { |
| return nil, err |
| } |
| return boring.EncryptRSAPKCS1(bkey, msg) |
| } |
| boring.UnreachableExceptTests() |
| |
| // EM = 0x00 || 0x02 || PS || 0x00 || M |
| em := make([]byte, k) |
| em[1] = 2 |
| ps, mm := em[2:len(em)-len(msg)-1], em[len(em)-len(msg):] |
| err := nonZeroRandomBytes(ps, random) |
| if err != nil { |
| return nil, err |
| } |
| em[len(em)-len(msg)-1] = 0 |
| copy(mm, msg) |
| |
| if boring.Enabled { |
| var bkey *boring.PublicKeyRSA |
| bkey, err = boringPublicKey(pub) |
| if err != nil { |
| return nil, err |
| } |
| return boring.EncryptRSANoPadding(bkey, em) |
| } |
| |
| m := new(big.Int).SetBytes(em) |
| c := encrypt(new(big.Int), pub, m) |
| return c.FillBytes(em), nil |
| } |
| |
| // DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from PKCS #1 v1.5. |
| // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks. |
| // |
| // Note that whether this function returns an error or not discloses secret |
| // information. If an attacker can cause this function to run repeatedly and |
| // learn whether each instance returned an error then they can decrypt and |
| // forge signatures as if they had the private key. See |
| // DecryptPKCS1v15SessionKey for a way of solving this problem. |
| func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error) { |
| if err := checkPub(&priv.PublicKey); err != nil { |
| return nil, err |
| } |
| |
| if boring.Enabled { |
| bkey, err := boringPrivateKey(priv) |
| if err != nil { |
| return nil, err |
| } |
| out, err := boring.DecryptRSAPKCS1(bkey, ciphertext) |
| if err != nil { |
| return nil, ErrDecryption |
| } |
| return out, nil |
| } |
| |
| valid, out, index, err := decryptPKCS1v15(rand, priv, ciphertext) |
| if err != nil { |
| return nil, err |
| } |
| if valid == 0 { |
| return nil, ErrDecryption |
| } |
| return out[index:], nil |
| } |
| |
| // DecryptPKCS1v15SessionKey decrypts a session key using RSA and the padding scheme from PKCS #1 v1.5. |
| // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks. |
| // It returns an error if the ciphertext is the wrong length or if the |
| // ciphertext is greater than the public modulus. Otherwise, no error is |
| // returned. If the padding is valid, the resulting plaintext message is copied |
| // into key. Otherwise, key is unchanged. These alternatives occur in constant |
| // time. It is intended that the user of this function generate a random |
| // session key beforehand and continue the protocol with the resulting value. |
| // This will remove any possibility that an attacker can learn any information |
| // about the plaintext. |
| // See “Chosen Ciphertext Attacks Against Protocols Based on the RSA |
| // Encryption Standard PKCS #1”, Daniel Bleichenbacher, Advances in Cryptology |
| // (Crypto '98). |
| // |
| // Note that if the session key is too small then it may be possible for an |
| // attacker to brute-force it. If they can do that then they can learn whether |
| // a random value was used (because it'll be different for the same ciphertext) |
| // and thus whether the padding was correct. This defeats the point of this |
| // function. Using at least a 16-byte key will protect against this attack. |
| func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error { |
| if err := checkPub(&priv.PublicKey); err != nil { |
| return err |
| } |
| k := priv.Size() |
| if k-(len(key)+3+8) < 0 { |
| return ErrDecryption |
| } |
| |
| valid, em, index, err := decryptPKCS1v15(rand, priv, ciphertext) |
| if err != nil { |
| return err |
| } |
| |
| if len(em) != k { |
| // This should be impossible because decryptPKCS1v15 always |
| // returns the full slice. |
| return ErrDecryption |
| } |
| |
| valid &= subtle.ConstantTimeEq(int32(len(em)-index), int32(len(key))) |
| subtle.ConstantTimeCopy(valid, key, em[len(em)-len(key):]) |
| return nil |
| } |
| |
| // decryptPKCS1v15 decrypts ciphertext using priv and blinds the operation if |
| // rand is not nil. It returns one or zero in valid that indicates whether the |
| // plaintext was correctly structured. In either case, the plaintext is |
| // returned in em so that it may be read independently of whether it was valid |
| // in order to maintain constant memory access patterns. If the plaintext was |
| // valid then index contains the index of the original message in em. |
| func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, em []byte, index int, err error) { |
| k := priv.Size() |
| if k < 11 { |
| err = ErrDecryption |
| return |
| } |
| |
| if boring.Enabled { |
| var bkey *boring.PrivateKeyRSA |
| bkey, err = boringPrivateKey(priv) |
| if err != nil { |
| return |
| } |
| em, err = boring.DecryptRSANoPadding(bkey, ciphertext) |
| if err != nil { |
| return |
| } |
| } else { |
| c := new(big.Int).SetBytes(ciphertext) |
| var m *big.Int |
| m, err = decrypt(rand, priv, c) |
| if err != nil { |
| return |
| } |
| em = m.FillBytes(make([]byte, k)) |
| } |
| |
| firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0) |
| secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2) |
| |
| // The remainder of the plaintext must be a string of non-zero random |
| // octets, followed by a 0, followed by the message. |
| // lookingForIndex: 1 iff we are still looking for the zero. |
| // index: the offset of the first zero byte. |
| lookingForIndex := 1 |
| |
| for i := 2; i < len(em); i++ { |
| equals0 := subtle.ConstantTimeByteEq(em[i], 0) |
| index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index) |
| lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex) |
| } |
| |
| // The PS padding must be at least 8 bytes long, and it starts two |
| // bytes into em. |
| validPS := subtle.ConstantTimeLessOrEq(2+8, index) |
| |
| valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1) & validPS |
| index = subtle.ConstantTimeSelect(valid, index+1, 0) |
| return valid, em, index, nil |
| } |
| |
| // nonZeroRandomBytes fills the given slice with non-zero random octets. |
| func nonZeroRandomBytes(s []byte, rand io.Reader) (err error) { |
| _, err = io.ReadFull(rand, s) |
| if err != nil { |
| return |
| } |
| |
| for i := 0; i < len(s); i++ { |
| for s[i] == 0 { |
| _, err = io.ReadFull(rand, s[i:i+1]) |
| if err != nil { |
| return |
| } |
| // In tests, the PRNG may return all zeros so we do |
| // this to break the loop. |
| s[i] ^= 0x42 |
| } |
| } |
| |
| return |
| } |
| |
| // These are ASN1 DER structures: |
| // |
| // DigestInfo ::= SEQUENCE { |
| // digestAlgorithm AlgorithmIdentifier, |
| // digest OCTET STRING |
| // } |
| // |
| // For performance, we don't use the generic ASN1 encoder. Rather, we |
| // precompute a prefix of the digest value that makes a valid ASN1 DER string |
| // with the correct contents. |
| var hashPrefixes = map[crypto.Hash][]byte{ |
| crypto.MD5: {0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05, 0x05, 0x00, 0x04, 0x10}, |
| crypto.SHA1: {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14}, |
| crypto.SHA224: {0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c}, |
| crypto.SHA256: {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20}, |
| crypto.SHA384: {0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30}, |
| crypto.SHA512: {0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40}, |
| crypto.MD5SHA1: {}, // A special TLS case which doesn't use an ASN1 prefix. |
| crypto.RIPEMD160: {0x30, 0x20, 0x30, 0x08, 0x06, 0x06, 0x28, 0xcf, 0x06, 0x03, 0x00, 0x31, 0x04, 0x14}, |
| } |
| |
| // SignPKCS1v15 calculates the signature of hashed using |
| // RSASSA-PKCS1-V1_5-SIGN from RSA PKCS #1 v1.5. Note that hashed must |
| // be the result of hashing the input message using the given hash |
| // function. If hash is zero, hashed is signed directly. This isn't |
| // advisable except for interoperability. |
| // |
| // If rand is not nil then RSA blinding will be used to avoid timing |
| // side-channel attacks. |
| // |
| // This function is deterministic. Thus, if the set of possible |
| // messages is small, an attacker may be able to build a map from |
| // messages to signatures and identify the signed messages. As ever, |
| // signatures provide authenticity, not confidentiality. |
| func SignPKCS1v15(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error) { |
| hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed)) |
| if err != nil { |
| return nil, err |
| } |
| |
| tLen := len(prefix) + hashLen |
| k := priv.Size() |
| if k < tLen+11 { |
| return nil, ErrMessageTooLong |
| } |
| |
| if boring.Enabled { |
| bkey, err := boringPrivateKey(priv) |
| if err != nil { |
| return nil, err |
| } |
| return boring.SignRSAPKCS1v15(bkey, hash, hashed) |
| } |
| |
| // EM = 0x00 || 0x01 || PS || 0x00 || T |
| em := make([]byte, k) |
| em[1] = 1 |
| for i := 2; i < k-tLen-1; i++ { |
| em[i] = 0xff |
| } |
| copy(em[k-tLen:k-hashLen], prefix) |
| copy(em[k-hashLen:k], hashed) |
| |
| m := new(big.Int).SetBytes(em) |
| c, err := decryptAndCheck(random, priv, m) |
| if err != nil { |
| return nil, err |
| } |
| |
| return c.FillBytes(em), nil |
| } |
| |
| // VerifyPKCS1v15 verifies an RSA PKCS #1 v1.5 signature. |
| // hashed is the result of hashing the input message using the given hash |
| // function and sig is the signature. A valid signature is indicated by |
| // returning a nil error. If hash is zero then hashed is used directly. This |
| // isn't advisable except for interoperability. |
| func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error { |
| if boring.Enabled { |
| bkey, err := boringPublicKey(pub) |
| if err != nil { |
| return err |
| } |
| if err := boring.VerifyRSAPKCS1v15(bkey, hash, hashed, sig); err != nil { |
| return ErrVerification |
| } |
| return nil |
| } |
| |
| hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed)) |
| if err != nil { |
| return err |
| } |
| |
| tLen := len(prefix) + hashLen |
| k := pub.Size() |
| if k < tLen+11 { |
| return ErrVerification |
| } |
| |
| // RFC 8017 Section 8.2.2: If the length of the signature S is not k |
| // octets (where k is the length in octets of the RSA modulus n), output |
| // "invalid signature" and stop. |
| if k != len(sig) { |
| return ErrVerification |
| } |
| |
| c := new(big.Int).SetBytes(sig) |
| m := encrypt(new(big.Int), pub, c) |
| em := m.FillBytes(make([]byte, k)) |
| // EM = 0x00 || 0x01 || PS || 0x00 || T |
| |
| ok := subtle.ConstantTimeByteEq(em[0], 0) |
| ok &= subtle.ConstantTimeByteEq(em[1], 1) |
| ok &= subtle.ConstantTimeCompare(em[k-hashLen:k], hashed) |
| ok &= subtle.ConstantTimeCompare(em[k-tLen:k-hashLen], prefix) |
| ok &= subtle.ConstantTimeByteEq(em[k-tLen-1], 0) |
| |
| for i := 2; i < k-tLen-1; i++ { |
| ok &= subtle.ConstantTimeByteEq(em[i], 0xff) |
| } |
| |
| if ok != 1 { |
| return ErrVerification |
| } |
| |
| return nil |
| } |
| |
| func pkcs1v15HashInfo(hash crypto.Hash, inLen int) (hashLen int, prefix []byte, err error) { |
| // Special case: crypto.Hash(0) is used to indicate that the data is |
| // signed directly. |
| if hash == 0 { |
| return inLen, nil, nil |
| } |
| |
| hashLen = hash.Size() |
| if inLen != hashLen { |
| return 0, nil, errors.New("crypto/rsa: input must be hashed message") |
| } |
| prefix, ok := hashPrefixes[hash] |
| if !ok { |
| return 0, nil, errors.New("crypto/rsa: unsupported hash function") |
| } |
| return |
| } |