/**************************************************************************************
* Copyright (c) 2016-2017, ARM Limited or its affiliates. All rights reserved         *
*                                                                                     *
* This file and the related binary are licensed under the following license:          *
*                                                                                     *
* ARM Object Code and Header Files License, v1.0 Redistribution.                      *
*                                                                                     *
* Redistribution and use of object code, header files, and documentation, without     *
* modification, are permitted provided that the following conditions are met:         *
*                                                                                     *
* 1) Redistributions must reproduce the above copyright notice and the                *
*    following disclaimer in the documentation and/or other materials                 *
*    provided with the distribution.                                                  *
*                                                                                     *
* 2) Unless to the extent explicitly permitted by law, no reverse                     *
*    engineering, decompilation, or disassembly of is permitted.                      *
*                                                                                     *
* 3) Redistribution and use is permitted solely for the purpose of                    *
*    developing or executing applications that are targeted for use                   *
*    on an ARM-based product.                                                         *
*                                                                                     *
* DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND                  *
* CONTRIBUTORS "AS IS." ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT             *
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT,        *
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE          *
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,   *
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED            *
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR              *
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF              *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING                *
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS                  *
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                        *
**************************************************************************************/


/*!
@file
@brief This file contains all of the enums and definitions that are used for the
       CRYS SRP APIs, as well as the APIs themselves.

*/
#ifndef CRYS_SRP_H
#define CRYS_SRP_H


#include "ssi_pal_types.h"
#include "crys_error.h"
#include "crys_pka_defs_hw.h"
#include "crys_hash.h"
#include "crys_rnd.h"


#ifdef __cplusplus
extern "C"
{
#endif

/*!\internal The following describes the SRP APIs usage for the Device and the Accessory :*

        Device (User)						Accessory (Host)
*      --------------						-----------------

  1.    CRYS_SRP_HK_INIT(CRYS_SRP_USER, .......)		CRYS_SRP_HK_INIT(CRYS_SRP_HOST, .....)

  2. 								CRYS_SRP_PwdVerCreate(..)

  3. 	CRYS_SRP_UserPubKeyCreate(..)				CRYS_SRP_HostPubKeyCreate(..)

  4. 	CRYS_SRP_UserProofCalc(..)

  5. 								CRYS_SRP_HostProofVerifyAndCalc(..)

  6. 	CRYS_SRP_UserProofVerify(..)

  7. 	CRYS_SRP_Clear(..)					CRYS_SRP_Clear(..)

 */

/************************ Defines ******************************/
/*! The SRP modulus sizes. */
/*! 1024 bits modulus size. */
#define CRYS_SRP_MODULUS_SIZE_1024_BITS   1024
/*! 1536 bits modulus size. */
#define CRYS_SRP_MODULUS_SIZE_1536_BITS   1536
/*! 2048 bits modulus size. */
#define CRYS_SRP_MODULUS_SIZE_2048_BITS   2048
/*! 3072 bits modulus size. */
#define CRYS_SRP_MODULUS_SIZE_3072_BITS   3072

/*! Maximal modulus size in bits. */
#define CRYS_SRP_MAX_MODULUS_IN_BITS 		CRYS_SRP_MODULUS_SIZE_3072_BITS
/*! Maximal modulus size in bytes. */
#define CRYS_SRP_MAX_MODULUS	 		(CRYS_SRP_MAX_MODULUS_IN_BITS/SASI_BITS_IN_BYTE)
/*! Maximal modulus size in words. */
#define CRYS_SRP_MAX_MODULUS_IN_WORDS 		(CRYS_SRP_MAX_MODULUS_IN_BITS/SASI_BITS_IN_32BIT_WORD)

/*! The SRP private number size range. */
/*! Minimal private number size in bits. */
#define CRYS_SRP_PRIV_NUM_MIN_SIZE_IN_BITS 		(256)
/*! Minimal private number size in bytes. */
#define CRYS_SRP_PRIV_NUM_MIN_SIZE	 		(CRYS_SRP_PRIV_NUM_MIN_SIZE_IN_BITS/SASI_BITS_IN_BYTE)
/*! Minimal private number size in words. */
#define CRYS_SRP_PRIV_NUM_MIN_SIZE_IN_WORDS 		(CRYS_SRP_PRIV_NUM_MIN_SIZE_IN_BITS/SASI_BITS_IN_32BIT_WORD)
/*! Maximal private number size in bits. */
#define CRYS_SRP_PRIV_NUM_MAX_SIZE_IN_BITS 		(CRYS_SRP_MAX_MODULUS_IN_BITS)
/*! Maximal private number size in bytes. */
#define CRYS_SRP_PRIV_NUM_MAX_SIZE	 		(CRYS_SRP_PRIV_NUM_MAX_SIZE_IN_BITS/SASI_BITS_IN_BYTE)
/*! Maximal private number size in words. */
#define CRYS_SRP_PRIV_NUM_MAX_SIZE_IN_WORDS 		(CRYS_SRP_PRIV_NUM_MAX_SIZE_IN_BITS/SASI_BITS_IN_32BIT_WORD)

/*! Maximal SRP HASH digest size in words. */
#define CRYS_SRP_MAX_DIGEST_IN_WORDS 		CRYS_HASH_RESULT_SIZE_IN_WORDS
/*! Maximal SRP HASH digest size in bytes. */
#define CRYS_SRP_MAX_DIGEST	 		(CRYS_SRP_MAX_DIGEST_IN_WORDS*SASI_32BIT_WORD_SIZE)

/*! Minimal salt size in bytes. */
#define CRYS_SRP_MIN_SALT_SIZE		 	(8)
/*! Minimal salt size in words. */
#define CRYS_SRP_MIN_SALT_SIZE_IN_WORDS 	(CRYS_SRP_MIN_SALT_SIZE/SASI_32BIT_WORD_SIZE)
/*! Maximal salt size in bytes. */
#define CRYS_SRP_MAX_SALT_SIZE		 	(64)
/*! Maximal salt size in words. */
#define CRYS_SRP_MAX_SALT_SIZE_IN_WORDS 	(CRYS_SRP_MAX_SALT_SIZE/SASI_32BIT_WORD_SIZE)

/************************ Typedefs  ****************************/
/*! SRP modulus buffer definition. */
typedef uint8_t CRYS_SRP_Modulus_t[CRYS_SRP_MAX_MODULUS];

/*! SRP digest buffer definition. */
typedef uint8_t CRYS_SRP_Digest_t[CRYS_SRP_MAX_DIGEST];

/*! SRP secret buffer definition. */
typedef uint8_t CRYS_SRP_Secret_t[2*CRYS_SRP_MAX_DIGEST];

/************************ Enums ********************************/

/*!
SRP supported versions
*/
typedef enum {
	CRYS_SRP_VER_3	= 0,    /*!< VER 3. */
	CRYS_SRP_VER_6   = 1,    /*!< VER 6. */
	CRYS_SRP_VER_6A  = 2,    /*!< VER 6A. */
	CRYS_SRP_VER_HK  = 3,    /*!< VER 6A. */
	/*! Maximal number of supported versions.*/
	CRYS_SRP_NumOfVersions,
	/*! Reserved.*/
	CRYS_SRP_VersionLast= 0x7FFFFFFF,

}CRYS_SRP_Version_t;

/*!
SRP entity type
*/
typedef enum {
	CRYS_SRP_HOST	= 1,    /*!< Host entity, called also server, verifier, or Accessory in Home-Kit */
	CRYS_SRP_USER   = 2,    /*!< User entity, called also client, or Device in Home-Kit */
	/*! Maximal number of entities types.*/
	CRYS_SRP_NumOfEntityType,
	/*! Reserved.*/
	CRYS_SRP_EntityLast= 0x7FFFFFFF,

}CRYS_SRP_Entity_t;

/************************ Structs  ******************************/

/*! Group parameters for the SRP - defines the modulus and the generator used */
typedef struct CRYS_SRP_GroupParam_t {
	/*! SRP modulus.*/
	CRYS_SRP_Modulus_t	modulus;
	/*! SRP generator.*/
	uint8_t			gen;
	/*! SRP modulus size in bits .*/
	size_t			modSizeInBits;
	/*! SRP valid Np.*/
	uint32_t		validNp;
	/*! SRP Np buffer.*/
	uint32_t		Np[CRYS_PKA_BARRETT_MOD_TAG_BUFF_SIZE_IN_WORDS];
}CRYS_SRP_GroupParam_t;

/************************ context Structs  ******************************/
/*! The SRP context prototype */
typedef struct CRYS_SRP_Context_t {
	/*! SRP entitiy type.*/
	CRYS_SRP_Entity_t		srpType;
	/*! SRP version.*/
	CRYS_SRP_Version_t		srpVer;
	/*! Group parameter including the modulus information.*/
	CRYS_SRP_GroupParam_t		groupParam;	// N, g, Np
	/*! Hash mode.*/
	CRYS_HASH_OperationMode_t	hashMode;
	/*! Hash digest size.*/
	size_t				hashDigestSize;
	/*! Pointer to RND state.*/
	CRYS_RND_State_t 		*pRndState;
	/*! Pointer to random vector generation function.*/
	SaSiRndGenerateVectWorkFunc_t 	rndGenerateVectFunc;
	/*! Modulus.*/
	CRYS_SRP_Modulus_t		ephemPriv;	// a or b
	/*! Modulus size.*/
	size_t				ephemPrivSize;
	/*! User name digest.*/
	CRYS_SRP_Digest_t		userNameDigest;	// M
	/*! Cred digest.*/
	CRYS_SRP_Digest_t		credDigest;	// p
	/*! SRP K multiplier. */						//
	CRYS_SRP_Digest_t		kMult;		// k multiplier
}CRYS_SRP_Context_t;


/************************ SRP common Functions **********************/
/****************************************************************************************************/
/*!
@brief This function initiates the SRP context.

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h or crys_hash_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_Init(
				CRYS_SRP_Entity_t	srpType,	/*!< [in] SRP entity type. */
				CRYS_SRP_Version_t	srpVer,		/*!< [in] SRP version. */
				CRYS_SRP_Modulus_t	srpModulus,	/*!< [in] A pointer to the SRP modulus, BE byte buffer. */
				uint8_t			srpGen,		/*!< [in] The SRP generator param. */
				size_t			modSizeInBits,	/*!< [in] The SRP modulus size in bits:1024, 1536, 2048 & 3072 */
				CRYS_HASH_OperationMode_t	hashMode,       /*!< [in] Enumerator defining the HASH mode. */
				uint8_t			*pUserName,	/*!< [in] A Pointer to user name. */
				size_t                	userNameSize,	/*!< [in] The user name buffer size > 0. */
				uint8_t			*pPwd,		/*!< [in] A Pointer to user password. */
				size_t                	pwdSize,	/*!< [in] The user password buffer size > 0 if pPwd is valid. */
				void 	*pRndState,	/*!< [in] A Pointer to RND context.*/
				SaSiRndGenerateVectWorkFunc_t 	rndGenerateVectFunc, /*!< [in] Pointer to random vector generation function.*/
				CRYS_SRP_Context_t	*pCtx 		/*!< [out] A Pointer to the SRP host context.*/
);

/*! MACRO definition for a specific SRP initialization function.*/
#define CRYS_SRP_HK_INIT(srpType, srpModulus, srpGen, modSizeInBits, pUserName, userNameSize, pPwd, pwdSize, pRndState, rndGenerateVectFunc, pCtx) \
	CRYS_SRP_Init(srpType, CRYS_SRP_VER_HK, srpModulus, srpGen, modSizeInBits, CRYS_HASH_SHA512_mode, pUserName, userNameSize, pPwd, pwdSize, pRndState, rndGenerateVectFunc, pCtx)


/****************************************************************************************************/
/*!
@brief This function calculates pSalt &  password verifier

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h, crys_rnd_error.h or crys_hash_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_PwdVerCreate(
				size_t                	saltSize,	/*!< [in] The size of the random salt to generate,
										The range is between CRYS_SRP_MIN_SALT_SIZE
										to CRYS_SRP_MAX_SALT_SIZE. */
				uint8_t			*pSalt,	   	/*!< [out] A Pointer to the pSalt number (s).*/
				CRYS_SRP_Modulus_t     	pwdVerifier,	/*!< [out] A Pointer to the password verifier (v). */
				CRYS_SRP_Context_t	*pCtx 		/*!< [out] A Pointer to the SRP context.*/
);


/****************************************************************************************************/
/*!
@brief Clears the SRP context.

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_Clear(
				CRYS_SRP_Context_t	*pCtx 		/*!< [in/out] A Pointer to the SRP context.*/
);


/************************ SRP Host Functions **********************/
/****************************************************************************************************/
/*!
@brief This function generates host public & private ephemeral key, known as B & b in RFC

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h or crys_rnd_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_HostPubKeyCreate(
				size_t                	ephemPrivSize,	/*!< [in] The size of the generated ephemeral private key (b).
										The range is between CRYS_SRP_PRIV_NUM_MIN_SIZE to
										CRYS_SRP_PRIV_NUM_MAX_SIZE */
				CRYS_SRP_Modulus_t     	pwdVerifier,	/*!< [in] A Pointer to the verifier (v). */
				CRYS_SRP_Modulus_t     	hostPubKeyB,	/*!< [out] A Pointer to the host ephemeral public key (B). */
				CRYS_SRP_Context_t	*pCtx 		/*!< [in/out] A Pointer to the SRP context.*/
);


/*!
@brief Verifies the user Proof and calculates the Host message proof.

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h or crys_hash_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_HostProofVerifyAndCalc(
				size_t                	saltSize,	/*!< [in] The size of the random salt,
										The range is between CRYS_SRP_MIN_SALT_SIZE
										to CRYS_SRP_MAX_SALT_SIZE. */
				uint8_t			*pSalt,	   	/*!< [in] A Pointer to the pSalt number.*/
				CRYS_SRP_Modulus_t     	pwdVerifier,	/*!< [in] A Pointer to the password verifier (v). */
				CRYS_SRP_Modulus_t     	userPubKeyA,	/*!< [in] A Pointer to the user ephemeral public key (A). */
				CRYS_SRP_Modulus_t     	hostPubKeyB,	/*!< [in] A Pointer to the host ephemeral public key (B). */
				CRYS_SRP_Digest_t	userProof,      /*!< [in] A Pointer to the SRP user proof buffer (M1).*/
				CRYS_SRP_Digest_t	hostProof,      /*!< [out] A Pointer to the SRP host proof buffer (M2).*/
				CRYS_SRP_Secret_t	sharedSecret,   /*!< [out] A Pointer to the SRP shared secret (K).*/
				CRYS_SRP_Context_t	*pCtx 		/*!< [in] A Pointer to the SRP context.*/
);



/************************ SRP User Functions **********************/
/****************************************************************************************************/
/*!
@brief This function generates user public & private ephemeral key, known as A & a in RFC

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h or crys_rnd_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_UserPubKeyCreate(
				size_t                	ephemPrivSize,	/*!< [in] The size of the generated ephemeral private key (a).
										The range is between CRYS_SRP_PRIV_NUM_MIN_SIZE to
										CRYS_SRP_PRIV_NUM_MAX_SIZE */
				CRYS_SRP_Modulus_t     	userPubKeyA,	/*!< [out] A Pointer to the user ephemeral public key (A). */
				CRYS_SRP_Context_t	*pCtx 		/*!< [in/out] A Pointer to the SRP context.*/
);


/****************************************************************************************************/
/*!
@brief This function calculates the user proof.

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h or crys_hash_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_UserProofCalc(
				size_t                	saltSize,	/*!< [in] The size of the random salt,
										The range is between CRYS_SRP_MIN_SALT_SIZE
										to CRYS_SRP_MAX_SALT_SIZE. */
				uint8_t			*pSalt,	   	/*!< [in] A Pointer to the pSalt number.*/
				CRYS_SRP_Modulus_t	userPubKeyA,  /*!< [in] A Pointer to the user public ephmeral key (A).*/
				CRYS_SRP_Modulus_t	hostPubKeyB,  /*!< [in] A Pointer to the host public ephmeral key (B).*/
				CRYS_SRP_Digest_t	userProof,      /*!< [out] A Pointer to the SRP user proof buffer (M1).*/
				CRYS_SRP_Secret_t	sharedSecret,   /*!< [out] A Pointer to the SRP shared secret (K).*/
				CRYS_SRP_Context_t	*pCtx 		/*!< [out] A Pointer to the SRP context.*/
);

/****************************************************************************************************/
/*!
@brief This function verifies the host proof

@return CRYS_OK on success.
@return A non-zero value on failure as defined crys_srp_error.h or crys_hash_error.h.
*/
CIMPORT_C CRYSError_t  CRYS_SRP_UserProofVerify(
				CRYS_SRP_Secret_t	sharedSecret,   /*!< [in] A Pointer to the SRP shared secret (K).*/
				CRYS_SRP_Modulus_t	userPubKeyA,  /*!< [in] A Pointer to the user public ephmeral key (A).*/
				CRYS_SRP_Digest_t	userProof,      /*!< [in] A Pointer to the SRP user proof buffer (M1).*/
				CRYS_SRP_Digest_t	hostProof,     /*!< [in] A Pointer to the SRP host proof buffer (M2).*/
				CRYS_SRP_Context_t	*pCtx 		/*!< [out] A Pointer to the SRP user context.*/
);


#ifdef __cplusplus
}
#endif
#endif /* #ifndef CRYS_SRP_H */