rsatest

Documentation

Index

• func DecryptOAEP(t testing.TB, hash hash.Hash, random io.Reader, priv *rsa.PrivateKey, ...) []byte
• func DecryptPKCS1v15(t testing.TB, random io.Reader, priv *rsa.PrivateKey, ciphertext []byte) []byte
• func DecryptPKCS1v15SessionKey(t testing.TB, random io.Reader, priv *rsa.PrivateKey, ciphertext []byte, ...)
• func EncryptOAEP(t testing.TB, hash hash.Hash, random io.Reader, pub *rsa.PublicKey, msg []byte, ...) []byte
• func EncryptPKCS1v15(t testing.TB, random io.Reader, pub *rsa.PublicKey, msg []byte) []byte
• func GenerateKey(t testing.TB, random io.Reader, bits int) *rsa.PrivateKey
• func GenerateMultiPrimeKey(t testing.TB, random io.Reader, nprimes int, bits int) *rsa.PrivateKey
• func SignPKCS1v15(t testing.TB, random io.Reader, priv *rsa.PrivateKey, hash crypto.Hash, ...) []byte
• func SignPSS(t testing.TB, rand io.Reader, priv *rsa.PrivateKey, hash crypto.Hash, ...) []byte
• func VerifyPKCS1v15(t testing.TB, pub *rsa.PublicKey, hash crypto.Hash, hashed []byte, sig []byte)
• func VerifyPSS(t testing.TB, pub *rsa.PublicKey, hash crypto.Hash, digest []byte, sig []byte, ...)

Functions

func DecryptOAEP

func DecryptOAEP(t testing.TB, hash hash.Hash, random io.Reader, priv *rsa.PrivateKey, ciphertext []byte, label []byte) []byte

DecryptOAEP decrypts ciphertext using RSA-OAEP.

OAEP is parameterised by a hash function that is used as a random oracle. Encryption and decryption of a given message must use the same hash function and sha256.New() is a reasonable choice.

The random parameter is legacy and ignored, and it can be nil.

The label parameter must match the value given when encrypting. See EncryptOAEP for details.

func DecryptPKCS1v15

func DecryptPKCS1v15(t testing.TB, random io.Reader, priv *rsa.PrivateKey, ciphertext []byte) []byte

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 DecryptPKCS1v15SessionKey

func DecryptPKCS1v15SessionKey(t testing.TB, random io.Reader, priv *rsa.PrivateKey, ciphertext []byte, key []byte)

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 EncryptOAEP

func EncryptOAEP(t testing.TB, hash hash.Hash, random io.Reader, pub *rsa.PublicKey, msg []byte, label []byte) []byte

EncryptOAEP encrypts the given message with RSA-OAEP.

OAEP is parameterised by a hash function that is used as a random oracle. Encryption and decryption of a given message must use the same hash function and sha256.New() is a reasonable choice.

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.

The label parameter may contain arbitrary data that will not be encrypted, but which gives important context to the message. For example, if a given public key is used to encrypt two types of messages then distinct label values could be used to ensure that a ciphertext for one purpose cannot be used for another by an attacker. If not required it can be empty.

The message must be no longer than the length of the public modulus minus twice the hash length, minus a further 2.

func EncryptPKCS1v15

func EncryptPKCS1v15(t testing.TB, random io.Reader, pub *rsa.PublicKey, msg []byte) []byte

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 GenerateKey

func GenerateKey(t testing.TB, random io.Reader, bits int) *rsa.PrivateKey

GenerateKey generates a random RSA private key of the given bit size.

Most applications should use crypto/rand.Reader as rand. Note that the returned key does not depend deterministically on the bytes read from rand, and may change between calls and/or between versions.

func GenerateMultiPrimeKey

func GenerateMultiPrimeKey(t testing.TB, random io.Reader, nprimes int, bits int) *rsa.PrivateKey

GenerateMultiPrimeKey generates a multi-prime RSA keypair of the given bit size and the given random source.

Table 1 in "On the Security of Multi-prime RSA" suggests maximum numbers of primes for a given bit size.

Although the public keys are compatible (actually, indistinguishable) from the 2-prime case, the private keys are not. Thus it may not be possible to export multi-prime private keys in certain formats or to subsequently import them into other code.

This package does not implement CRT optimizations for multi-prime RSA, so the keys with more than two primes will have worse performance.

Deprecated: The use of this function with a number of primes different from two is not recommended for the above security, compatibility, and performance reasons. Use GenerateKey instead.

func SignPKCS1v15

func SignPKCS1v15(t testing.TB, random io.Reader, priv *rsa.PrivateKey, hash crypto.Hash, hashed []byte) []byte

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 SignPSS

func SignPSS(t testing.TB, rand io.Reader, priv *rsa.PrivateKey, hash crypto.Hash, digest []byte, opts *rsa.PSSOptions) []byte

SignPSS calculates the signature of digest using PSS.

digest must be the result of hashing the input message using the given hash function. The opts argument may be nil, in which case sensible defaults are used. If opts.Hash is set, it overrides hash.

The signature is randomized depending on the message, key, and salt size, using bytes from rand. Most applications should use crypto/rand.Reader as rand.

func VerifyPKCS1v15

func VerifyPKCS1v15(t testing.TB, pub *rsa.PublicKey, hash crypto.Hash, hashed []byte, sig []byte)

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.

The inputs are not considered confidential, and may leak through timing side channels, or if an attacker has control of part of the inputs.

func VerifyPSS

func VerifyPSS(t testing.TB, pub *rsa.PublicKey, hash crypto.Hash, digest []byte, sig []byte, opts *rsa.PSSOptions)

VerifyPSS verifies a PSS signature.

A valid signature is indicated by returning a nil error. digest must be the result of hashing the input message using the given hash function. The opts argument may be nil, in which case sensible defaults are used. opts.Hash is ignored.

The inputs are not considered confidential, and may leak through timing side channels, or if an attacker has control of part of the inputs.