// 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/internal/boring" "crypto/internal/randutil" "crypto/subtle" "errors" "io" ) // This file implements encryption and decryption using PKCS #1 v1.5 padding. // PKCS1v15DecryptOptions 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 random parameter is used as a source of entropy to ensure that // encrypting the same message twice doesn't result in the same // ciphertext. Most applications should use [crypto/rand.Reader] // as random. Note that the returned ciphertext does not depend // deterministically on the bytes read from random, and may change // between calls and/or between versions. // // 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) } return encrypt(pub, em) } // DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from PKCS #1 v1.5. // The random parameter is legacy and ignored, and it can be nil. // // 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(random 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(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. The random parameter is legacy and ignored, and it // can be nil. // // DecryptPKCS1v15SessionKey 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. // // 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 also defeats the point of this // function. Using at least a 16-byte key will protect against this attack. // // This method implements protections against Bleichenbacher chosen ciphertext // attacks [0] described in RFC 3218 Section 2.3.2 [1]. While these protections // make a Bleichenbacher attack significantly more difficult, the protections // are only effective if the rest of the protocol which uses // DecryptPKCS1v15SessionKey is designed with these considerations in mind. In // particular, if any subsequent operations which use the decrypted session key // leak any information about the key (e.g. whether it is a static or random // key) then the mitigations are defeated. This method must be used extremely // carefully, and typically should only be used when absolutely necessary for // compatibility with an existing protocol (such as TLS) that is designed with // these properties in mind. // // - [0] “Chosen Ciphertext Attacks Against Protocols Based on the RSA Encryption // Standard PKCS #1”, Daniel Bleichenbacher, Advances in Cryptology (Crypto '98) // - [1] RFC 3218, Preventing the Million Message Attack on CMS, // https://www.rfc-editor.org/rfc/rfc3218.html func DecryptPKCS1v15SessionKey(random 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(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. 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, to allow constant time padding removal. func decryptPKCS1v15(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 { em, err = decrypt(priv, ciphertext, noCheck) if err != nil { return } } 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, random io.Reader) (err error) { _, err = io.ReadFull(random, s) if err != nil { return } for i := 0; i < len(s); i++ { for s[i] == 0 { _, err = io.ReadFull(random, 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. // // The random parameter is legacy and ignored, and it can be nil. // // 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) return decrypt(priv, em, withCheck) } // 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 } em, err := encrypt(pub, sig) if err != nil { return ErrVerification } // 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 }