/*

 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 * ** IMPORTANT **  API's in this file are published to 3rd party developers via the 

 * Symbian website. Changes to these API's should be treated as PublishedAll API changes and the Security TA should be consulted.

 * Padding codes

 *

 */

 /**

  @file 

  @publishedAll

  @released

 */

 #ifndef __PADDING_H__

 #define __PADDING_H__

 #include <random.h>

 /** 

 * Abstract base class defining the interface to padding schemes.

 *

 * It is designed to be used by both symmetric and asymmetric ciphers.

 *

 */

 class CPadding : public CBase

 	{

 public:

 	/** 

 	* Pads aInput to be BlockSize() bytes long and places the result in aOutput.  

 	*

 	* @param aInput		Data to be padded.  The size must be less than or equal to

 	* 					BlockSize() minus MinPaddingLength().

 	* @param aOutput	On return, the resulting padded, block size aligned data

 	*					appended to aOutput.  

 	*/

 	IMPORT_C void PadL(const TDesC8& aInput,TDes8& aOutput);

 	/**

 	* Pads aInput to be BlockSize() long and places the result in aOutput.  

 	*

 	* Deriving implementations of DoPadL() can assume that aInput is less than or

 	* equal to BlockSize() minus MinPaddingLength().

 	*

 	* @param aInput		Data to be padded.  

 	* @param aOutput	On return, the resulting padded, aBlockBytes aligned data 

 	*					appended to aOutput.  

 	*/

 	virtual void DoPadL(const TDesC8& aInput,TDes8& aOutput) = 0;

 	/**

 	* Removes padding from aInput and appends unpadded result to aOutput.

 	* 

 	* @param aInput		Data to be unpadded.

 	* @param aOutput	On return, the unpadded data.

 	*/

 	virtual void UnPadL(const TDesC8& aInput,TDes8& aOutput) = 0;

 	/**

 	* Sets the block size for this padding system.

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C void SetBlockSize(TInt aBlockBytes);

 	/**

 	* Retrieves the block size for this padding system.

 	*

 	* @return	The block size in bytes.

 	*/

 	IMPORT_C TInt BlockSize(void) const;

 	/**

 	* Gets the smallest number of bytes that PadL() will ever add to aInput in

 	* order to get a valid block aligned aOutput.  

 	*

 	* For example, in SSLv3 padding, if the block size is 8 and aInput is 7 bytes,

 	* it will append 1 byte of padding. For SSLv3 padding, this is the smallest 

 	* amount possible as an 8 byte input will add another block size (8 more bytes)

 	* of padded data.

 	* 

 	* @return	A TInt containing the smallest number of padding bytes possible.

 	*/

 	virtual TInt MinPaddingLength(void) const = 0;

 	/**

 	* Gets the size of the aOutput buffer, in a call to PadL(), must be in

 	* order to accommodate a block size of BlockSize() and an input size of

 	* aInputBytes.

 	* 

 	* @note	By default, this function returns the output of BlockSize().  If

 	*		a derived padding system outputs more than a single block of padding,

 	*		one must override this function and return the appropriate value.

 	*

 	* @param aInputBytes	The amount of data to be padded out in bytes.

 	* @return				A TInt representing the maximum amount of padded output data

 	*						(in bytes) for a given block and input size.

 	*/

 	IMPORT_C virtual TInt MaxPaddedLength(TInt aInputBytes) const;

 	/**

 	* Gets the size of the aOutput buffer, in a call to UnPadL(), must be in

 	* order to accommodate an input size of aInputBytes.

 	*

 	* @note	By default, this function returns the value of aInputBytes minus MinPaddingBytes().

 	*		Most padding systems cannot determine anything about the unpadded length

 	*		without looking at the data.  If your padding system allows you to give a

 	*		better bound, then you should reimplement this function.

 	*

 	* @param aInputBytes	The amount of data to be unpadded in bytes.

 	* @return				A TInt containing the maximum amount of unpadded output data

 	*						(in bytes) for a given padded input.

 	*/

 	IMPORT_C virtual TInt MaxUnPaddedLength(TInt aInputBytes) const;

 protected:

 	/** 

 	* Constructor

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C CPadding(TInt aBlockBytes);

 private:

 	CPadding(void);

 	CPadding(const CPadding&);

 	CPadding& operator=(const CPadding&);

 private:

 	TInt iBlockBytes;

 	};

 /**

 * This concrete subclass of CPadding appends no padding.

 *

 * aOutput will be a copy of aInput after any call to PadL() or UnPadL().

 *

 */

 class CPaddingNone:public CPadding

 	{

 public:

 	/**

 	* Creates a new CPaddingNone object.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingNone object.

 	*/

 	IMPORT_C static CPaddingNone* NewL(TInt aBlockBytes=KMaxTInt);

 	/**

 	* Creates a new CPaddingNone object and leaves a pointer to it on the cleanup stack.

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingNone object.

 	*/

 	IMPORT_C static CPaddingNone* NewLC(TInt aBlockBytes=KMaxTInt);

 	void DoPadL(const TDesC8& aInput,TDes8& aOutput);

 	void UnPadL(const TDesC8& aInput,TDes8& aOutput);

 	TInt MinPaddingLength(void) const;

 	TInt MaxPaddedLength(TInt aInputBytes) const;

 protected:

 	/** 

 	* Constructor

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C CPaddingNone(TInt aBlockBytes);

 private:

 	CPaddingNone(void);

 	CPaddingNone(const CPaddingNone&);

 	CPaddingNone& operator=(const CPaddingNone&);

 	};

 /**

 * This concrete subclass of CPadding implements PKCS#1 v1.5 signature padding.

 *

 * It is intended for use with RSA signing/verifying.

 *

 */

 class CPaddingPKCS1Signature : public CPadding

 	{

 public:

 	/**

 	* Creates a new CPaddingPKCS1Signature object.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingPKCS1Signature object.

 	*/

 	IMPORT_C static CPaddingPKCS1Signature* NewL(TInt aBlockBytes);

 	/**

 	* Creates a new CPaddingPKCS1Signature object and leaves a pointer to it on the

 	* cleanup stack.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingPKCS1Signature object.

 	*/

 	IMPORT_C static CPaddingPKCS1Signature* NewLC(

 		TInt aBlockBytes);

 	void DoPadL(const TDesC8& aInput,TDes8& aOutput);

 	void UnPadL(const TDesC8& aInput,TDes8& aOutput);

 	TInt MinPaddingLength(void) const;

 protected:

 	/** 

 	* Constructor

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C CPaddingPKCS1Signature(TInt aBlockBytes);

 private:

 	CPaddingPKCS1Signature(void);

 	CPaddingPKCS1Signature(const CPaddingPKCS1Signature&);

 	CPaddingPKCS1Signature& operator=(const CPaddingPKCS1Signature&);

 	};

 /**

 * This concrete subclass of CPadding implements PKCS#1 v1.5 encryption padding.

 * It is intended for use with RSA encryption/decryption.

 *

 */

 class CPaddingPKCS1Encryption : public CPadding

 	{

 public:

 	/**

 	* Creates a new CPaddingPKCS1Encryption object.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingPKCS1Encryption object.

 	*/

 	IMPORT_C static CPaddingPKCS1Encryption* NewL(TInt aBlockBytes);

 	/**

 	* Creates a new CPaddingPKCS1Encryption object and leaves a pointer to it on the

 	* cleanup stack.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingPKCS1Encryption object.

 	*/

 	IMPORT_C static CPaddingPKCS1Encryption* NewLC(TInt aBlockBytes);

 	void DoPadL(const TDesC8& aInput,TDes8& aOutput);

 	void UnPadL(const TDesC8& aInput,TDes8& aOutput);

 	TInt MinPaddingLength(void) const;

 protected:

 	/** 

 	* Constructor

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C CPaddingPKCS1Encryption(TInt aBlockBytes);

 private:

 	CPaddingPKCS1Encryption(void);

 	CPaddingPKCS1Encryption(const CPaddingPKCS1Encryption&);

 	CPaddingPKCS1Encryption& operator=(const CPaddingPKCS1Encryption&);

 	};

 /**

 * This concrete subclass of CPadding implements padding according to 

 * the SSLv3/TLS standard.

 *

 * The SSL 3.0 spec does not specifiy the padding bytes to be used - it is

 * assumed to be arbitrary (and the openssl implementation uses non-zero random

 * data).  The TLS spec however states that padding bytes should be the length

 * of the padding - 1.  This class implements the latter when padding, but does

 * not check the padding byes when unpadding, so as to be interoperable with SSL

 * 3.0.

 * 

 */

 class CPaddingSSLv3 : public CPadding

 	{

 public:

 	/**

 	* Creates a new CPaddingSSLv3 object.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingSSLv3 object.

 	*/

 	IMPORT_C static CPaddingSSLv3* NewL(TInt aBlockBytes);

 	/**

 	* Creates a new CPaddingSSLv3 object and leaves a pointer to it on the cleanup stack.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingSSLv3 object.

 	*/

 	IMPORT_C static CPaddingSSLv3* NewLC(TInt aBlockBytes);

 	void DoPadL(const TDesC8& aInput,TDes8& aOutput);

 	void UnPadL(const TDesC8& aInput,TDes8& aOutput);

 	TInt MinPaddingLength(void) const;

 	TInt MaxPaddedLength(TInt aInputBytes) const;

 protected:

 	/** 

 	* Constructor

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C CPaddingSSLv3(TInt aBlockBytes);

 private:

 	CPaddingSSLv3(void);

 	CPaddingSSLv3(const CPaddingSSLv3&);

 	CPaddingSSLv3& operator=(const CPaddingSSLv3&);

 	};

 /**

 * This concrete subclass of CPadding implements padding according to 

 * the PKCS#7/TLS standard.

 *

 */

 class CPaddingPKCS7 : public CPadding

 	{

 public:

 	/**

 	* Creates a new CPaddingPKCS7 object.

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingPKCS7 object.

 	*/

 	IMPORT_C static CPaddingPKCS7* NewL(TInt aBlockBytes);

 	/**

 	* Creates a new CPaddingPKCS7 object and leaves a pointer to it on the cleanup stack.

 	*

 	* @param aBlockBytes	The block size in bytes.

 	* @return				A pointer to the new CPaddingPKCS7 object.

 	*/

 	IMPORT_C static CPaddingPKCS7* NewLC(TInt aBlockBytes);

 	void DoPadL(const TDesC8& aInput,TDes8& aOutput);

 	void UnPadL(const TDesC8& aInput,TDes8& aOutput);

 	TInt MinPaddingLength(void) const;

 	TInt MaxPaddedLength(TInt aInputBytes) const;

 protected:

 	/** 

 	* Constructor

 	* 

 	* @param aBlockBytes	The block size in bytes.

 	*/

 	IMPORT_C CPaddingPKCS7(TInt aBlockBytes);

 private:

 	CPaddingPKCS7(void);

 	CPaddingPKCS7(const CPaddingPKCS7&);

 	CPaddingPKCS7& operator=(const CPaddingPKCS7&);

 	};

 #endif