/* -----------------------------------------------------------------------
 *
 * Copyright (c) 2002-2005 Mr Ludovic FLAMENT <ludovic.flament@free.fr>, LIEVIN, FRANCE
 *
 * Termes :
 *
 * L'utilisation et/ou la redistribution de ce code (avec ou sans modification),
 * ainsi que de tous les composants du produit (librairies, documentation, exemples, ...)
 * est soumise aux termes de la licence qui vous est attribuée par son auteur.
 *
 * -----------------------------------------------------------------------
 */

#ifndef _ECCTK_HASH_H_
#define _ECCTK_HASH_H_

/*! \file ecctk-hash.h
 *
 * Ce fichier contiend les références des fonctions disponibles
 * pour la mise en oeuvre des algorithmes de HASH, MAC et HMAC.
 *
 * \author Ludovic FLAMENT <ludovic.flament\@free.fr>
 *
 * \warning L'utilisation et/ou la redistribution de ce code (avec ou sans modification),
 * ainsi que de tous les composants du produit (librairies, documentation, exemples, ...)
 * est soumise aux termes de la licence qui vous est attribuée par son auteur.
 */

#include <include/ecctk-prototype.h>

#ifdef EXPORT_FUNCTIONS
#define DLL_EXPORT __declspec(dllexport)
#else
#ifndef DOXYGEN
#define DLL_EXPORT
#endif
#endif

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash MD5
 */
#define ECCTK_HASH_ALGO_MD5			0x01

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash SHA-160
 */
#define ECCTK_HASH_ALGO_SHA160		0x02

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash SHA-256
 */
#define ECCTK_HASH_ALGO_SHA256		0x03

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash SHA-384
 */
#define ECCTK_HASH_ALGO_SHA384		0x04

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash SHA-512
 */
#define ECCTK_HASH_ALGO_SHA512		0x05
#endif

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash RIPEMD-128
 */
#define ECCTK_HASH_ALGO_RMD128		0x06

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash RIPEMD-160
 */
#define ECCTK_HASH_ALGO_RMD160		0x07

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash RIPEMD-256
 */
#define ECCTK_HASH_ALGO_RMD256		0x08

/*!
 * \ingroup hash_algo
 *
 * Utilisation de l'algorithme de hash RIPEMD-320
 */
#define ECCTK_HASH_ALGO_RMD320		0x09
#endif

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC MD5
 */
#define ECCTK_HASH_HMAC_ALGO_MD5	0x20

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC SHA-160
 */
#define ECCTK_HASH_HMAC_ALGO_SHA160	0x21

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC SHA-256
 */
#define ECCTK_HASH_HMAC_ALGO_SHA256	0x22

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC SHA-384
 */
#define ECCTK_HASH_HMAC_ALGO_SHA384	0x23

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC SHA-512
 */
#define ECCTK_HASH_HMAC_ALGO_SHA512	0x24
#endif

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC RIPEMD-128
 */
#define ECCTK_HASH_HMAC_ALGO_RMD128	0x25

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC RIPEMD-160
 */
#define ECCTK_HASH_HMAC_ALGO_RMD160	0x26

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC RIPEMD-256
 */
#define ECCTK_HASH_HMAC_ALGO_RMD256	0x27

/*!
 * \ingroup hmac_algo
 *
 * Utilisation de l'algorithme de HMAC RIPEMD-320
 */
#define ECCTK_HASH_HMAC_ALGO_RMD320	0x28
#endif

/*!
 * \ingroup mac_algo
 *
 * Utilisation de l'algorithme de MAC RIPEMD-128
 */
#define ECCTK_HASH_MAC_ALGO_RMD128	0x41

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup mac_algo
 *
 * Utilisation de l'algorithme de MAC RIPEMD-160
 */
#define ECCTK_HASH_MAC_ALGO_RMD160	0x42
#endif

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme MD5
 */
#define ECCTK_HASH_SIZE_MD5		16

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme SHA-160
 */
#define ECCTK_HASH_SIZE_SHA160	20

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme SHA-256
 */
#define ECCTK_HASH_SIZE_SHA256	32

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme SHA-384
 */
#define ECCTK_HASH_SIZE_SHA384	48

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme SHA-512
 */
#define ECCTK_HASH_SIZE_SHA512	64
#endif

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme RIPEMD-128
 */
#define ECCTK_HASH_SIZE_RMD128	16

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme RIPEMD-160
 */
#define ECCTK_HASH_SIZE_RMD160	20

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme RIPEMD-256
 */
#define ECCTK_HASH_SIZE_RMD256	32

/*!
 * \ingroup hash_size
 *
 * Taille d'un hash (en octet) avec l'algorithme RIPEMD-320
 */
#define ECCTK_HASH_SIZE_RMD320	40
#endif

/*!
 * \ingroup hash_error
 *
 * Aucune erreur
 */
#define ECCTK_HASH_NO_ERROR				 0

/*!
 * \ingroup hash_error
 *
 * Le fichier n'existe pas
 */
#define ECCTK_HASH_ERROR_FILE_NOT_FOUND	-1

/*!
 * \ingroup hash_error
 *
 * Ereur durant la fermeture du fichier
 */
#define ECCTK_HASH_ERROR_CLOSE_FILE		-2

/*!
 * \ingroup hash_error
 *
 * Ereur durant la lecture du fichier
 */
#define ECCTK_HASH_ERROR_READ_FILE		-3

/*!
 * \ingroup hash_error
 *
 * Argument null trouvé
 */
#define ECCTK_HASH_ERROR_NULL_ARG		-4

/*!
 * \ingroup hash_error
 *
 * Context null trouvé
 */
#define ECCTK_HASH_ERROR_NULL_CTX		-5

/*!
 * \ingroup hash_error
 *
 * Algorithme inconnu
 */
#define ECCTK_HASH_ERROR_ALGO			-6

/*!
 * \ingroup hash_error
 *
 * Erreur durant l'initialisation
 */
#define ECCTK_HASH_INIT_ERROR			-7

/*!
 * \ingroup hash_error
 *
 * Impossible de se déplacer dans le fichier
 */
#define	ECCTK_HASH_FILE_FSEEK_ERROR		-8

/*!
 * \ingroup hash_error
 *
 * Erreur interne
 */
#define	ECCTK_HASH_INTERNAL_ERROR		-9

/*!
 * \ingroup hash_valid
 *
 * Succès de la fonction de validation
 */
#define ECCTK_HASH_VALID_SUCCESS		1

/*!
 * \ingroup hash_valid
 *
 * Echec de la fonction de validation
 */
#define ECCTK_HASH_VALID_FAILED			0

#ifdef __cplusplus
extern "C" {
#endif

	/*!
	 * \ingroup hash_step_md5
	 * Context utilisé pour effectuer les opérations avec l'algorithme MD5
	 */
	typedef struct hash_ctx MD5_CTX;
	
	/*!
	 * \ingroup hash_step_md5
	 * \brief Initialisation d'un context pour l'algorithme MD5
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT MD5_CTX * MD5_Init();
	
	/*!
	 * \ingroup hash_step_md5
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MD5_Update(MD5_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_md5
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme MD5
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MD5_Final(MD5_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_md5
	 * \brief libération du context pour l'algorithme MD5
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT MD5_Free(MD5_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme MD5
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MD5_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme MD5
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MD5_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme MD5
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MD5_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme MD5
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MD5_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le MD5 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT MD5_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le HMAC-MD5 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT MD5_StreamHashMAC_Valid();
	
	/*!
	 * \ingroup hash_step_sha160
	 * Context utilisé pour effectuer les opérations avec l'algorithme SHA-160
	 */
	typedef struct hash_ctx SHA160_CTX;
	
	/*!
	 * \ingroup hash_step_sha160
	 * \brief Initialisation d'un context pour l'algorithme SHA-160
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT SHA160_CTX * SHA160_Init();
	
	/*!
	 * \ingroup hash_step_sha160
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA160_Update(SHA160_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_sha160
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme SHA-160
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA160_Final(SHA160_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_sha160
	 * \brief libération du context pour l'algorithme SHA-160
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT SHA160_Free(SHA160_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme SHA-1 (version 160 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA160_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme SHA-1 (version 160 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA160_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme SHA-1 (version 160 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA160_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme SHA-1 (version 160 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA160_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le SHA1-160 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT SHA160_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le HMAC-SHA1 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT SHA160_StreamHashMAC_Valid();
	
#ifndef ECCTK_EVALUATION
	/*!
	 * \ingroup hash_step_sha256
	 * Context utilisé pour effectuer les opérations avec l'algorithme SHA-256
	 */
	typedef struct hash_ctx SHA256_CTX;
	
	/*!
	 * \ingroup hash_step_sha256
	 * \brief Initialisation d'un context pour l'algorithme SHA-256
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT SHA256_CTX * SHA256_Init();
	
	/*!
	 * \ingroup hash_step_sha256
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA256_Update(SHA256_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_sha256
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme SHA-256
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA256_Final(SHA256_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_sha256
	 * \brief libération du context pour l'algorithme SHA-256
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT SHA256_Free(SHA256_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme SHA-1 (version 256 bits)
	 * 
	 * File		: chemin du fichier dont on veut effectuer l'empreinte
	 * Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA256_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme SHA-1 (version 256 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA256_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme SHA-1 (version 256 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA256_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme SHA-1 (version 256 bits)
	 * 
	 * Buff		: buffer dont on veut effectuer l'empreinte
	 * BuffSize	: taille du buffer
	 * Key		: clef à utiliser pour protéger l'empreinte
	 * KeySize	: taille de la clef (en octets)
	 * Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA256_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le SHA1-256 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT SHA256_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_step_sha384
	 * Context utilisé pour effectuer les opérations avec l'algorithme SHA-384
	 */
	typedef struct hash_ctx SHA384_CTX;
	
	/*!
	 * \ingroup hash_step_sha384
	 * \brief Initialisation d'un context pour l'algorithme SHA-384
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT SHA384_CTX * SHA384_Init();
	
	/*!
	 * \ingroup hash_step_sha384
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA384_Update(SHA384_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_sha384
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme SHA-384
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA384_Final(SHA384_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_sha384
	 * \brief libération du context pour l'algorithme SHA-384
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT SHA384_Free(SHA384_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme SHA-1 (version 384 bits)
	 * 
	 * File		: chemin du fichier dont on veut effectuer l'empreinte
	 * Hash		: buffer contenant l'empreinte (48 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA384_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme SHA-1 (version 384 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (48 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA384_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme SHA-1 (version 384 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (48 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA384_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme SHA-1 (version 384 bits)
	 * 
	 * Buff		: buffer dont on veut effectuer l'empreinte
	 * BuffSize	: taille du buffer
	 * Key		: clef à utiliser pour protéger l'empreinte
	 * KeySize	: taille de la clef (en octets)
	 * Hash		: buffer contenant l'empreinte (48 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA384_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le SHA1-384 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT SHA384_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_step_sha512
	 * Context utilisé pour effectuer les opérations avec l'algorithme SHA-512
	 */
	typedef struct hash_ctx SHA512_CTX;
	
	/*!
	 * \ingroup hash_step_sha512
	 * \brief Initialisation d'un context pour l'algorithme SHA-512
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT SHA512_CTX * SHA512_Init();
	
	/*!
	 * \ingroup hash_step_sha512
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA512_Update(SHA512_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_sha512
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme SHA-512
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA512_Final(SHA512_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_sha512
	 * \brief libération du context pour l'algorithme SHA-512
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT SHA512_Free(SHA512_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme SHA-1 (version 512 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Hash		: buffer contenant l'empreinte (64 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA512_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme SHA-1 (version 512 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (64 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA512_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme SHA-1 (version 512 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (64 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA512_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme SHA-1 (version 512 bits)
	 * 
	 * Buff		: buffer dont on veut effectuer l'empreinte
	 * BuffSize	: taille du buffer
	 * Key		: clef à utiliser pour protéger l'empreinte
	 * KeySize	: taille de la clef (en octets)
	 * Hash		: buffer contenant l'empreinte (64 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SHA512_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le SHA1-512 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT SHA512_StreamHash_Valid();
#endif /* #ifndef ECCTK_EVALUATION */
	
	/*!
	 * \ingroup hash_step_rmd128
	 * Context utilisé pour effectuer les opérations avec l'algorithme RIPEMD-128
	 */
	typedef struct hash_ctx RMD128_CTX;
	
	/*!
	 * \ingroup hash_step_rmd128
	 * \brief Initialisation d'un context pour l'algorithme RIPEMD-128
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RMD128_CTX * RIPEMD128_Init();
	
	/*!
	 * \ingroup hash_step_rmd128
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_Update(RMD128_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_rmd128
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme RIPEMD-128
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_Final(RMD128_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_rmd128
	 * \brief libération du context pour l'algorithme RIPEMD-128
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RIPEMD128_Free(RMD128_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme RIPEMD (version 128 bits)
	 * 
	 * File		: chemin du fichier dont on veut effectuer l'empreinte
	 * Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme RIPEMD (version 128 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup mac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant l'algorithme MAC-RIPEMD (version 128 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_FileMAC(s1byte *File, u1byte *Key, u2byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme RIPEMD (version 128 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme RIPEMD (version 128 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup mac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant l'algorithme MAC-RIPEMD (version 128 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (16 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD128_StreamMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u2byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le RIPEMD-128 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD128_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le HMAC-RIPEMD-128 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD128_StreamHashMAC_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le MAC-RIPEMD-128 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD128_StreamMAC_Valid();

#ifndef ECCTK_EVALUATION
	/*!
	 * \ingroup hash_step_rmd160
	 * Context utilisé pour effectuer les opérations avec l'algorithme RIPEMD-160
	 */
	typedef struct hash_ctx RMD160_CTX;
	
	/*!
	 * \ingroup hash_step_rmd160
	 * \brief Initialisation d'un context pour l'algorithme RIPEMD-160
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RMD160_CTX * RIPEMD160_Init();
	
	/*!
	 * \ingroup hash_step_rmd160
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_Update(RMD160_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_rmd160
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme RIPEMD-160
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_Final(RMD160_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_rmd160
	 * \brief libération du context pour l'algorithme RIPEMD-160
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RIPEMD160_Free(RMD160_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme RIPEMD (version 160 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme RIPEMD (version 160 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup mac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant l'algorithme MAC-RIPEMD (version 160 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets).
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_FileMAC(s1byte *File, u1byte *Key, u2byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme RIPEMD (version 160 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme RIPEMD (version 160 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup mac_stream
	 * \brief  effectue l'authentification d'un buffer en utilisant l'algorithme MAC-RIPEMD (version 160 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (20 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD160_StreamMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u2byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le RIPEMD-160 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD160_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le HMAC-RIPEMD-160 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD160_StreamHashMAC_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le MAC-RIPEMD-160 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD160_StreamMAC_Valid();

	/*!
	 * \ingroup hash_step_rmd256
	 * Context utilisé pour effectuer les opérations avec l'algorithme RIPEMD-256
	 */
	typedef struct hash_ctx RMD256_CTX;
	
	/*!
	 * \ingroup hash_step_rmd256
	 * \brief Initialisation d'un context pour l'algorithme RIPEMD-256
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RMD256_CTX * RIPEMD256_Init();
	
	/*!
	 * \ingroup hash_step_rmd256
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD256_Update(RMD256_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_rmd256
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme RIPEMD-256
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD256_Final(RMD256_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_rmd256
	 * \brief libération du context pour l'algorithme RIPEMD-256
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RIPEMD256_Free(RMD256_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme RIPEMD (version 256 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD256_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme RIPEMD (version 256 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD256_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme RIPEMD (version 256 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD256_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme RIPEMD (version 256 bits)
	 * 
	 * Buff		: buffer dont on veut effectuer l'empreinte
	 * BuffSize	: taille du buffer
	 * Key		: clef à utiliser pour protéger l'empreinte
	 * KeySize	: taille de la clef (en octets)
	 * Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD256_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le RIPEMD-256 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD256_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le HMAC-RIPEMD-256 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD256_StreamHashMAC_Valid();
	
	/*!
	 * \ingroup hash_step_rmd320
	 * Context utilisé pour effectuer les opérations avec l'algorithme RIPEMD-320
	 */
	typedef struct hash_ctx RMD320_CTX;
	
	/*!
	 * \ingroup hash_step_rmd320
	 * \brief Initialisation d'un context pour l'algorithme RIPEMD-320
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RMD320_CTX * RIPEMD320_Init();
	
	/*!
	 * \ingroup hash_step_rmd320
	 * \brief Mise en oeuvre des opérations de hash
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD320_Update(RMD320_CTX *ctx, u1byte *Buff, u4byte BuffSize);
	
	/*!
	 * \ingroup hash_step_rmd320
	 * \brief Finalisation du calcul de l'empreinte pour l'algorithme RIPEMD-320
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param Hash		: buffer contenant l'empreinte (32 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD320_Final(RMD320_CTX *ctx, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_step_rmd320
	 * \brief libération du context pour l'algorithme RIPEMD-320
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RIPEMD320_Free(RMD320_CTX *ctx);
	
	/*!
	 * \ingroup hash_file
	 * \brief Effectue l'empreinte d'un fichier en utilisant l'algorithme RIPEMD (version 320 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Hash		: buffer contenant l'empreinte (40 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD320_FileHash(s1byte *File, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_file
	 * \brief Effectue l'authentification d'un fichier en utilisant un MAC basé sur l'algorithme RIPEMD (version 320 bits)
	 * 
	 * \param File		: chemin du fichier dont on veut effectuer l'empreinte
	 * \param Key		: clef à utiliser pour protéger l'empreinte
	 * \param KeySize	: taille de la clef (en octets)
	 * \param Hash		: buffer contenant l'empreinte (40 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD320_FileHashMAC(s1byte *File, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_stream
	 * \brief Effectue l'empreinte d'un buffer en utilisant l'algorithme RIPEMD (version 320 bits)
	 * 
	 * \param Buff		: buffer dont on veut effectuer l'empreinte
	 * \param BuffSize	: taille du buffer
	 * \param Hash		: buffer contenant l'empreinte (40 octets pour obtenir l'empreinte complète)
	 * \param HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD320_StreamHash(u1byte *Buff, u4byte BuffSize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hmac_stream
	 * \brief Effectue l'authentification d'un buffer en utilisant un MAC basé sur l'algorithme RIPEMD (version 320 bits)
	 * 
	 * Buff		: buffer dont on veut effectuer l'empreinte
	 * BuffSize	: taille du buffer
	 * Key		: clef à utiliser pour protéger l'empreinte
	 * KeySize	: taille de la clef (en octets)
	 * Hash		: buffer contenant l'empreinte (40 octets pour obtenir l'empreinte complète)
	 * HashSize	: taille maximale du buffer contenant l'empreinte
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIPEMD320_StreamHashMAC(u1byte *Buff, u4byte BuffSize, u1byte *Key, u4byte KeySize, u1byte *Hash, u2byte HashSize);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le RIPEMD-320 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD320_StreamHash_Valid();
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet de tester le HMAC-RIPEMD-320 en comparant les résultats de la fonction
	 * sur des vecteurs de tests définis par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_HASH_VALID_SUCCESS si le test est bon, ECCTK_HASH_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIPEMD320_StreamHashMAC_Valid();
#endif /* #ifndef ECCTK_EVALUATION */
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet d'obtenir des informations sur la librairie
	 *
	 * \param Information est le buffer dans lequel sont placées les informations sur la librairie
	 * \param Size est la taille du buffer Information
	 *
	 * \remark si Size n'est pas assez grand, les informations sont tronquées
	 */
	DLL_EXPORT void EcctkHashInfo(char *Information, u2byte Size);
	
	/*!
	 * \ingroup hash_valid
	 * \brief Permet d'obtenir la taille d'une empreinte en fonction de l'algorithme
	 *
	 * \param Algorithm est l'algorithme dont on veut la taille maximale de l'empreinte
	 *
	 * \warning la taille retournée est en octets
	 *
	 * \return la taille de l'empreinte en octets, 0 si l'algorithme est inconnu
	 */
	u2byte DLL_EXPORT DigestAlgorithmSize(s2byte Algorithm);

#ifdef __cplusplus
};
#endif

#endif
