// 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 (
	"big";
	"bytes";
	"crypto/subtle";
	"io";
	"os";
)

// This file implements encryption and decryption using PKCS#1 v1.5 padding.

// 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.
// WARNING: use of this function to encrypt plaintexts other than session keys
// is dangerous. Use RSA OAEP in new protocols.
func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err os.Error) {
	k := (pub.N.Len() + 7)/8;
	if len(msg) > k-11 {
		err = MessageTooLongError{};
		return;
	}

	// EM = 0x02 || PS || 0x00 || M
	em := make([]byte, k-1);
	em[0] = 2;
	ps, mm := em[1 : len(em)-len(msg)-1], em[len(em)-len(msg) : len(em)];
	err = nonZeroRandomBytes(ps, rand);
	if err != nil {
		return;
	}
	em[len(em)-len(msg)-1] = 0;
	bytes.Copy(mm, msg);

	m := new(big.Int).SetBytes(em);
	c := encrypt(new(big.Int), pub, m);
	out = c.Bytes();
	return;
}

// 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.
func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err os.Error) {
	valid, out, err := decryptPKCS1v15(rand, priv, ciphertext);
	if err == nil && valid == 0 {
		err = DecryptionError{};
	}

	return;
}

// 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),
func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err os.Error) {
	k := (priv.N.Len() + 7)/8;
	if k-(len(key)+3+8) < 0 {
		err = DecryptionError{};
		return;
	}

	valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext);
	if err != nil {
		return;
	}

	valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key)));
	subtle.ConstantTimeCopy(valid, key, msg);
	return;
}

func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, msg []byte, err os.Error) {
	k := (priv.N.Len() + 7)/8;
	if k < 11 {
		err = DecryptionError{};
		return;
	}

	c := new(big.Int).SetBytes(ciphertext);
	m, err := decrypt(rand, priv, c);
	if err != nil {
		return;
	}

	em := leftPad(m.Bytes(), 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.
	var lookingForIndex, index int;
	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);
	}

	valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1);
	msg = em[index+1 : len(em)];
	return;
}

// nonZeroRandomBytes fills the given slice with non-zero random octets.
func nonZeroRandomBytes(s []byte, rand io.Reader) (err os.Error) {
	_, err = io.ReadFull(rand, s);
	if err != nil {
		return;
	}

	for i := 0; i < len(s); i++ {
		for s[i] == 0 {
			_, err = rand.Read(s[i : i+1]);
			if err != nil {
				return;
			}
		}
	}

	return;
}