/* -----------------------------------------------------------------------
 *
 * 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_CIPHER_H_
#define _ECCTK_CIPHER_H_

/*! \file ecctk-cipher.h
 *
 * Ce fichier contiend les références des fonctions disponibles
 * pour la mise en oeuvre des algorithmes de chiffrement symétriques.
 *
 * \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.
 */

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

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme RC2 pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_RC2		0x01

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme RC4 pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_RC4		0x02

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme BLOWFISH pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_BLOWFISH	0x03

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme DES pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_DES		0x04

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme 3DES-EDE à 2 clefs pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_3DES_EDE_2 0x05

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme 3DES-EDE à 3 clefs pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_3DES_EDE_3 0x0b

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme CAST128 pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_CAST128	0x06

#ifndef ECCTK_EVALUATION
/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme RIJNDAEL pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_RIJNDAEL	0x07

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme TWOFISH pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_TWOFISH	0x08

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme MARS pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_MARS		0x09

/*!
 * \ingroup cipher_algo
 *
 * Utilisation de l'algorithme SERPENT pour le chiffrement symétrique
 */
#define ECCTK_CIPHER_ALGO_SERPENT	0x0a

#endif

/*!
 * \ingroup cipher_mode
 *
 * Utilisation du mode Electronic CodeBook
 */
#define ECCTK_CIPHER_MODE_ECB		0x01

/*!
 * \ingroup cipher_mode
 *
 * Utilisation du mode Cipher Block Chaining
 */
#define ECCTK_CIPHER_MODE_CBC		0x02

/*!
 * \ingroup cipher_mode
 *
 * Utilisation du mode Cipher FeedBack
 */
#define ECCTK_CIPHER_MODE_CFB		0x03

/*!
 * \ingroup cipher_mode
 *
 * Utilisation du mode Output FeedBack
 */
#define ECCTK_CIPHER_MODE_OFB		0x04

/*!
 * \ingroup cipher_mode
 *
 * Utilisation du mode Counter
 */
#define ECCTK_CIPHER_MODE_CTR		0x05

/*!
 * \ingroup cipher_mode
 *
 * Définition d'un mode spécial pour la gestion du RC4
 */
#define ECCTK_CIPHER_MODE_RC4		0x06

/*!
 * \ingroup cipher_mode
 *
 * Opération de chiffrement
 */
#define ECCTK_CIPHER_ENCRYPT		0x01

/*!
 * \ingroup cipher_mode
 *
 * Opération de déchiffrement
 */
#define ECCTK_CIPHER_DECRYPT		0x02


/*!
 * \ingroup cipher_error
 *
 * Aucune erreur
 */
#define ECCTK_CIPHER_NO_ERROR			  0

/*!
 * \ingroup cipher_error
 *
 * Erreur sur le vecteur d'initialisation
 */
#define ECCTK_CIPHER_IV_ERROR			 -1

/*!
 * \ingroup cipher_error
 *
 * Opération inconnue
 */
#define ECCTK_CIPHER_OPERATION_ERROR	 -2

/*!
 * \ingroup cipher_error
 *
 * Mode inconnu
 */
#define ECCTK_CIPHER_MODE_ERROR			 -3

/*!
 * \ingroup cipher_error
 *
 * Impossible d'ouvrir le fichier
 */
#define ECCTK_CIPHER_FILE_OPEN_ERROR	 -4

/*!
 * \ingroup cipher_error
 *
 * Impossible de lire le fichier
 */
#define ECCTK_CIPHER_FILE_READ_ERROR	 -5

/*!
 * \ingroup cipher_error
 *
 * Impossible d'écrire dans le fichier
 */
#define ECCTK_CIPHER_FILE_WRITE_ERROR	 -6

/*!
 * \ingroup cipher_error
 *
 * Nombre de clefs incorrect
 */
#define ECCTK_CIPHER_NBKEY_ERROR		 -7

/*!
 * \ingroup cipher_error
 *
 * Erreur durant l'initialisation
 */
#define ECCTK_CIPHER_INIT_ERROR			 -8

/*!
 * \ingroup cipher_error
 *
 * Erreur durant l'update
 */
#define ECCTK_CIPHER_UPDATE_ERROR		 -9

/*!
 * \ingroup cipher_error
 *
 * Erreur durant la finalisation
 */
#define ECCTK_CIPHER_FINAL_ERROR		-10

/*!
 * \ingroup cipher_error
 *
 * Erreur durant la vérification du déchiffrement (ECB,CBC)
 */
#define ECCTK_CIPHER_DECRYPT_FAILED		-11

/*!
 * \ingroup cipher_error
 *
 * Impossible de se déplacer dans le fichier
 */
#define ECCTK_CIPHER_FILE_FSEEK_ERROR	-12

/*!
 * \ingroup cipher_error
 *
 * Le buffer de sortie est trop petit
 */
#define ECCTK_CIPHER_OUT_TOO_SMALL		-13

/*!
 * \ingroup cipher_error
 *
 * Le buffer de sortie est NULL
 */
#define ECCTK_CIPHER_OUT_BUFFER_NULL	-14

/*!
 * \ingroup cipher_error
 *
 * Algorithme inconnu
 */
#define ECCTK_CIPHER_ALGO_ERROR			-15

/*!
 * \ingroup cipher_error
 *
 * Un ou plusieurs arguments sont NULL
 */
#define ECCTK_CIPHER_NULL_ARGS			-16

/*!
 * \ingroup cipher_error
 *
 * Erreur interne
 */
#define	ECCTK_CIPHER_INTERNAL_ERROR		-17

/*!
 * \ingroup cipher_valid
 *
 * Succès de la fonction de validation
 */
#define ECCTK_CIPHER_VALID_SUCCESS		1

/*!
 * \ingroup cipher_valid
 *
 * Echec de la fonction de validation
 */
#define ECCTK_CIPHER_VALID_FAILED		0

#ifdef __cplusplus
extern "C" {
#endif

	/*!
	 * \ingroup cipher_step_bf
	 * Context utilisé pour effectuer les opérations avec l'algorithme BLOWFISH
	 */
	typedef struct cipher_ctx BLOWFISH_CTX;
	
	/*!
	 * \ingroup cipher_step_bf
	 * \brief Initialisation d'un context pour l'algorithme BLOWFISH
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 56 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT BLOWFISH_CTX * BLOWFISH_Init(u1byte Op, u1byte OpMode, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_bf
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme BLOWFISH
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 8) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT BLOWFISH_Update(BLOWFISH_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_bf
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme BLOWFISH
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT BLOWFISH_Final(BLOWFISH_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_bf
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme BLOWFISH
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT BLOWFISH_Free(BLOWFISH_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme BLOWFISH
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 56 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT BLOWFISH_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme BLOWFISH
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 56 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT BLOWFISH_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme BLOWFISH
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 56 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+8 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT BLOWFISH_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
												u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme BLOWFISH
	 * 
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT BLOWFISH_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
												u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme BLOWFISH sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT BLOWFISH_Valid();
	
	/*!
	 * \ingroup cipher_step_cast128
	 * Context utilisé pour effectuer les opérations avec l'algorithme CAST-128
	 */
	typedef struct cipher_ctx CAST128_CTX;
	
	/*!
	 * \ingroup cipher_step_cast128
	 * \brief Initialisation d'un context pour l'algorithme CAST-128
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT CAST128_CTX * CAST128_Init(u1byte Op, u1byte OpMode, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_cast128
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme CAST-128
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 8) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT CAST128_Update(CAST128_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_cast128
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme CAST-128
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT CAST128_Final(CAST128_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_cast128
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme CAST-128
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT CAST128_Free(CAST128_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme CAST-128
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT CAST128_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme CAST-128
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT CAST128_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme CAST-128
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+8 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT CAST128_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme CAST-128
	 *
	* \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 16 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT CAST128_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
												u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme CAST-128 sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT CAST128_Valid();
	
	/*!
	 * \ingroup cipher_step_des
	 * Context utilisé pour effectuer les opérations avec l'algorithme DES
	 */
	typedef struct cipher_ctx DES_CTX;
	
	/*!
	 * \ingroup cipher_step_des
	 * \brief Initialisation d'un context pour l'algorithme DES
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param NbKey		: nombre de clefs, 1 ==> DES, 2 ==> 3DES (mode EDE à 2 clefs), , 3 ==> 3DES (mode EDE à 3 clefs).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \warning si le vecteur d'initialisation n'est pas NULL, sa taille doit-être de 8 octets.
	 * \warning la taille du buffer contenant la clef doit-être :
	 *   -  8 octets pour le DES
	 *   - 16 octets pour le 3DES-EDE2
	 *   - 24 octets pour le 3DES-EDE3
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT DES_CTX * DES_Init(u2byte Op, u2byte OpMode, u2byte NbKey, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_des
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme DES
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 8) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT DES_Update(DES_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_des
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme DES
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT DES_Final(DES_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_des
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme DES
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT DES_Free(DES_CTX *ctx);
	
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme DES
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param NbKey		: nombre de clefs, 1 ==> DES, 2 ==> 3DES (mode EDE à 2 clefs), , 3 ==> 3DES (mode EDE à 3 clefs).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \warning si le vecteur d'initialisation n'est pas NULL, sa taille doit-être de 8 octets.
	 * \warning la taille du buffer contenant la clef doit-être :
	 *   -  8 octets pour le DES
	 *   - 16 octets pour le 3DES-EDE2
	 *   - 24 octets pour le 3DES-EDE3
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT DES_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize,
										u2byte NbKey, u2byte OpMode);
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme DES
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param NbKey		: nombre de clefs, 1 ==> DES, 2 ==> 3DES (mode EDE à 2 clefs), , 3 ==> 3DES (mode EDE à 3 clefs).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT DES_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
										u1byte *IV, u2byte IVsize, u2byte NbKey, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme DES
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param NbKey			: nombre de clefs, 1 ==> DES, 2 ==> 3DES (mode EDE à 2 clefs), , 3 ==> 3DES (mode EDE à 3 clefs).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+8 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT DES_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
										u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte NbKey, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme DES
	 *
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param NbKey			: nombre de clefs, 1 ==> DES, 2 ==> 3DES (mode EDE à 2 clefs), , 3 ==> 3DES (mode EDE à 3 clefs).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT DES_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
										u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte NbKey, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme DES sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT DES_Valid();
	
	
	/*!
	 * \ingroup cipher_step_rc2
	 * Context utilisé pour effectuer les opérations avec l'algorithme RC2
	 */
	typedef struct cipher_ctx RC2_CTX;
	
	/*!
	 * \ingroup cipher_step_rc2
	 * \brief Initialisation d'un context pour l'algorithme RC2
	 *
	 * \param Op		  : précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	  : mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param RealKeySize : taille effective (en bits) de la clef de chiffrement. Par defaut la valeur est de 1024 bits
	 * \param Key		  : buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	  : taille de la clef (en octets).
	 * \param IV		  : buffer contenant le vecteur d'initialisation.
	 * \param IVsize	  : taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 128 octets, les octets supplémentaires sont ignorés
	 * \remark la taille effective de la clef est de 1024 bits
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RC2_CTX * RC2_Init(u2byte Op, u2byte OpMode, u2byte RealKeySize, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_rc2
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme RC2
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 8) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT RC2_Update(RC2_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_rc2
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme RC2
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT RC2_Final(RC2_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_rc2
	 *
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme RC2
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RC2_Free(RC2_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme RC2
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 128 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RC2_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme RC2
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 128 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RC2_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
										u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme RC2
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 128 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+8 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RC2_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
										u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme RC2
	 * 
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est supérieure à 128 octets, les octets supplémentaires sont ignorés
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RC2_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
										u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme RC2 sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RC2_Valid();
	
	
	/*!
	 * \ingroup cipher_step_rc4
	 * Context utilisé pour effectuer les opérations avec l'algorithme RC4
	 */
	typedef struct cipher_ctx RC4_CTX;
	
	/*!
	 * \ingroup cipher_step_rc4
	 * \brief Initialisation d'un context pour l'algorithme RC4
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 256 octets, les octets supplémentaires sont ignorés
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RC4_CTX * RC4_Init(u2byte Op, u1byte *Key, u2byte Keysize);
	
	/*!
	 * \ingroup cipher_step_rc4
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme RC4
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 8) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT RC4_Update(RC4_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_rc4
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme RC4
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT RC4_Final(RC4_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_rc4
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme RC4
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RC4_Free(RC4_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme RC4
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 256 octets, les octets supplémentaires sont ignorés
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RC4_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme RC4
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 256 octets, les octets supplémentaires sont ignorés
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RC4_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme RC4
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 256 octets, les octets supplémentaires sont ignorés
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RC4_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
										u1byte *Key, u2byte Keysize);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme RC4
	 *
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 *
	 * \remark si la taille de la clef est supérieure à 256 octets, les octets supplémentaires sont ignorés
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RC4_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
										u1byte *Key, u2byte Keysize);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme RC4 sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RC4_Valid();
	
	
	#ifndef ECCTK_EVALUATION
	/*!
	 * \ingroup cipher_step_aes
	 * Context utilisé pour effectuer les opérations avec l'algorithme RIJNDAEL (AES)
	 */
	typedef struct cipher_ctx RIJNDAEL_CTX;
	
	/*!
	 * \ingroup cipher_step_aes
	 * \brief Initialisation d'un context pour l'algorithme RIJNDAEL
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT RIJNDAEL_CTX * RIJNDAEL_Init(u1byte Op, u1byte OpMode, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_aes
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme RIJNDAEL
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 16) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT RIJNDAEL_Update(RIJNDAEL_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_aes
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme RIJNDAEL
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT RIJNDAEL_Final(RIJNDAEL_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_aes
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme RIJNDAEL
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT RIJNDAEL_Free(RIJNDAEL_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme RIJNDAEL
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT RIJNDAEL_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme RIJNDAEL
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RIJNDAEL_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme RIJNDAEL
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+16 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RIJNDAEL_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
												u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme RIJNDAEL
	 * 
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT RIJNDAEL_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
												u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme RIJNDAEL sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT RIJNDAEL_Valid();
	
	
	/*!
	 * \ingroup cipher_step_serpent
	 * Context utilisé pour effectuer les opérations avec l'algorithme SERPENT
	 */
	typedef struct cipher_ctx SERPENT_CTX;
	
	/*!
	 * \ingroup cipher_step_serpent
	 * \brief Initialisation d'un context pour l'algorithme SERPENT
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT SERPENT_CTX * SERPENT_Init(u1byte Op, u1byte OpMode, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_serpent
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme SERPENT
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 16) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT SERPENT_Update(SERPENT_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_serpent
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme SERPENT
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT SERPENT_Final(SERPENT_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_serpent
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme SERPENT
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT SERPENT_Free(SERPENT_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme SERPENT
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT SERPENT_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme SERPENT
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT SERPENT_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme SERPENT
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+16 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT SERPENT_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme SERPENT
	 * 
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT SERPENT_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme SERPENT sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT SERPENT_Valid();
	
	
	/*!
	 * \ingroup cipher_step_twofish
	 * Context utilisé pour effectuer les opérations avec l'algorithme TWOFISH
	 */
	typedef struct cipher_ctx TWOFISH_CTX;
	
	/*!
	 * \ingroup cipher_step_twofish
	 * \brief Initialisation d'un context pour l'algorithme TWOFISH
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT TWOFISH_CTX * TWOFISH_Init(u1byte Op, u1byte OpMode, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_twofish
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme TWOFISH
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 16) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT TWOFISH_Update(TWOFISH_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_twofish
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme TWOFISH
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT TWOFISH_Final(TWOFISH_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_twofish
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme TWOFISH
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT TWOFISH_Free(TWOFISH_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme TWOFISH
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT TWOFISH_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme TWOFISH
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT TWOFISH_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme TWOFISH
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+16 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT TWOFISH_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme TWOFISH
	 * 
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - comprise entre 17 et 23 octets, un padding de 0 est ajouté pour atteidre la taille de 24 octets
	 *   - comprise entre 25 et 31 octets, un padding de 0 est ajouté pour atteidre la taille de 32 octets
	 *   - supérieur à 32 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT TWOFISH_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme TWOFISH sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT TWOFISH_Valid();
	
	
	/*!
	 * \ingroup cipher_step_mars
	 * Context utilisé pour effectuer les opérations avec l'algorithme MARS
	 */
	typedef struct cipher_ctx MARS_CTX;
	
	/*!
	 * \ingroup cipher_step_mars
	 * \brief Initialisation d'un context pour l'algorithme MARS
	 *
	 * \param Op		: précise si on chiffre ou si on déchiffre (ECCTK_CIPHER_ENCRYPT ou ECCTK_CIPHER_DECRYPT).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 * \param Key		: buffer contenant la clef de chiffrement/déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - supérieur à 56 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return un context initialisé, ou NULL en cas d'erreur.
	 */
	DLL_EXPORT MARS_CTX * MARS_Init(u1byte Op, u1byte OpMode, u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize);
	
	/*!
	 * \ingroup cipher_step_mars
	 * \brief Mise en oeuvre des opérations de chiffrement/déchiffrement pour l'algorithme MARS
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferIn	: buffer à chiffré/déchiffré.
	 * \param BufferOut	: buffer de sortie contenant le buffer déchiffré/chiffré.
	 * \param Size		: taille du buffer à chiffré/déchiffré.
	 *
	 * \remark la taille minimale du buffer de sortie doit être de (Size + 16) octets.
	 *
	 * \return le nombre d'octets chiffrés/déchiffrés ou un code d'erreur.
	 */
	s4byte DLL_EXPORT MARS_Update(MARS_CTX *ctx, u1byte *BufferIn, u1byte *BufferOut, u4byte Size);
	
	/*!
	 * \ingroup cipher_step_mars
	 * \brief Finalisation du chiffrement/déchiffrement (ajout, retrait du padding éventuel) pour l'algorithme MARS
	 *
	 * \param ctx		: un context précédemment initialisé.
	 * \param BufferOut	: buffer de sortie conenant le buffer déchiffré/chiffré.
	 *
	 * \warning il faut directement passer le buffer provenant de la fonction Update.
	 *
	 * \return la taille exacte du buffer chiffré/déchiffré ou un code d'erreur.
	 */
	s4byte DLL_EXPORT MARS_Final(MARS_CTX *ctx, u1byte *BufferOut);
	
	/*!
	 * \ingroup cipher_step_mars
	 * \brief Effacement de la clef de chiffrement/déchiffrement, libération du context pour l'algorithme MARS
	 *
	 * \param ctx : un context précédemment initialisé.
	 */
	void DLL_EXPORT MARS_Free(MARS_CTX *ctx);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Déchiffrement d'un fichier en utilisant l'algorithme MARS
	 *
	 * \param InFile	: chemin/nom du fichier à déchiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de déchiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de déchiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - supérieur à 56 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction
	 */
	s2byte DLL_EXPORT MARS_FileDecrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
											u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_file
	 * \brief Chiffrement d'un fichier en utilisant l'algorithme MARS
	 *
	 * \param InFile	: chemin/nom du fichier à chiffrer.
	 * \param OutFile	: chemin/nom du fichier de sortie.
	 * \param Key		: buffer contenant la clef de chiffrement.
	 * \param Keysize	: taille de la clef (en octets).
	 * \param IV		: buffer contenant le vecteur d'initialisation.
	 * \param IVsize	: taille du vecteur d'initialisation (en octets).
	 * \param OpMode	: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - supérieur à 56 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT MARS_FileEncrypt(s1byte *InFile, s1byte *OutFile, u1byte *Key, u2byte Keysize,
										u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Chiffrement d'un buffer mémoire en utilisant l'algorithme MARS
	 *
	 * \param BufferIn		: buffer à chiffrer.
	 * \param BufferInSize	: taille du buffer à chiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de chiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - supérieur à 56 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize+16 pour les modes ECB & CBC.
	 *	- BufferOutSize >= BufferInSize pour les modes CFB & OFB.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT MARS_StreamEncrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_stream
	 * \brief Déchiffrement d'un buffer mémoire en utilisant l'algorithme MARS
	 * 
	 * \param BufferIn		: buffer à déchiffrer.
	 * \param BufferInSize	: taille du buffer à déchiffrer.
	 * \param BufferOut		: buffer de sortie.
	 * \param BufferOutSize	: pointeur sur la taille du buffer de sortie.
	 * \param Key			: buffer contenant la clef de déchiffrement.
	 * \param Keysize		: taille de la clef (en octets).
	 * \param IV			: buffer contenant le vecteur d'initialisation.
	 * \param IVsize		: taille du vecteur d'initialisation (en octets).
	 * \param OpMode		: mode de chiffrement (ECCTK_CIPHER_MODE_...).
	 *
	 * \remark si la taille de la clef est :
	 *   - inférieur à 16 octets, un padding de 0 est ajouté pour atteidre la taille de 16 octets
	 *   - supérieur à 56 octets, les octets supplémentaires sont ignorés
	 *
	 * \remark le vecteur d'initialisation peut-être NULL si on utilise le mode ECCTK_CIPHER_MODE_ECB.
	 * \remark le buffer de sortie peut-être NULL.
	 * \remark la taille du buffer de sortie est toujours mise à jour avec la la taille exacte du buffer de sortie,
	 * ou nécessaire si ce dernier est NULL.
	 *
	 * \warning Il faut respecter :
	 *	- BufferOutSize >= BufferInSize pour tous les modes.
	 *
	 * \return code d'erreur de la fonction.
	 */
	s2byte DLL_EXPORT MARS_StreamDecrypt(u1byte *BufferIn, s4byte BufferInSize, u1byte *BufferOut, s4byte *BufferOutSize,
											u1byte *Key, u2byte Keysize, u1byte *IV, u2byte IVsize, u2byte OpMode);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Validation de l'algorithme MARS sur des vecteurs de tests définis
	 * par le ou les concepteurs de l'algorithme.
	 *
	 * \return ECCTK_CIPHER_VALID_SUCCESS si le test est bon, ECCTK_CIPHER_VALID_FAILED sinon
	 */
	s2byte DLL_EXPORT MARS_Valid();
	
	#endif /* ECCTK_EVALUATION */
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Permet de connaître la taille "normale" du vecteur d'initialisation pour un algorithme donné
	 *
	 * \param Algorithm est l'algorithme dont on veut la taille de l'iv
	 *
	 * \warning la taille est retournée en octets
	 *
	 * \return la taille de l'iv en octets
	 */
	u2byte DLL_EXPORT CipherAlgorithmIVSize(s2byte Algorithm);
	
	/*!
	 * \ingroup cipher_valid
	 * \brief Permet de connaître la taille maximale d'une clef pour un algorithme donné
	 *
	 * \param Algorithm est l'algorithme dont on veut la taille maximale de la clef
	 *
	 * \warning la taille est retournée en octets
	 *
	 * \return la taille maximale de la clef en octets, 
	 */
	u2byte DLL_EXPORT CipherAlgorithmKeySize(s2byte Algorithm);
	
	/*!
	 * \ingroup cipher_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 EcctkCipherInfo(char *Information, u2byte Size);

#ifdef __cplusplus
};
#endif

#endif
