SHAMAN LIBRAIRIE DE HASH SUPPORTANT SHA1 SHA256 SHA384 SHA512 MD5 BASE64

/*
ShaMan Hash Shared Library (SHA1 SHA256 SHA384 SHA512 MD5 BASE64 + random string generator )
Copyright (c) 2007 James Mrad (xtremejames183@msn.com)

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

/*********************************** API ***********************************************************************/
#ifndef __SHAMAN_H__
#define __SHAMAN_H__

#include <stdio.h> /* FILE */
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h> /* for srand */

/* local */
#include "gdefs.h"
#include "sha1.h"
#include "sha256.h"
#include "sha384.h"
#include "sha512.h"
#include "md5.h"
#include "base64.h"

/* pool memory managment */
#include "pool.h"
/* portable&&safe snprintf */
#include "snprintf.h"

#define FILE_HASH_SIZE	65635

#define MAX_HASH_BUFFER	SHA512_HASH_SIZE * 5
#define SHAMAN_OK	0
#define SHAMAN_VER	"Shaman Hash Library V2.1"

typedef enum
{
	/* supported Method */
	SHA1_HASH,
	SHA256_HASH,
	SHA384_HASH,
	SHA512_HASH,
	MD5_HASH,
	BASE64_HASH /* lol :-) */

}HASHMETH; /* Hash method */
typedef struct shaman_st
{
	uint8_t	*clear; /* clear chain */

	HASHMETH	meth;
	FILE	*fp;
	pool	p;

	uint8_t	*hash ; /* final hash chain */

	uint8_t	*version ; /* SHAMAN Version */
}SHAMAN_CTX;

/**
* Util codes
* Generate Random String 
* @param output: data will be copied to output , hide : optional 1/true if yu want to hash it using SHA1
* @return SHAMAN_OK on succes , -1 on failure
*/
int GenRandomString(uint8_t	*output,unsigned long	len);
/**
* Read a file and return it as buffer
* @param open File Pointer
* @ return a malloced buffer (must be freed) on success , -1 on failure
*/
uint8_t	*XReadFile(FILE	*fp);

#if defined _WIN32 || !defined HAVE_BZERO
/* bzero for NON POSIX */
void bzero(void *buf, size_t buf_size) ;
#endif 

/* Core Code */
/**
* Init ShaMan Context
* By default HashMethod is SHA256 */
SHAMAN_CTX	*	InitShaMan(void);
/**
* Prepare string for Hash Operation
* @param SHAMAN_CTX Not NULL , a cstr (NOT NULL)
* @return SHAMAN_OK on succes , -1 on failure
*/
int ShaManAdd(SHAMAN_CTX	*sctx,uint8_t *cstr);
/*
* Main Hash Processing
* Hash the clear buffer and copy its hex code to hash(member of CTX)
* @param CTX with clear buffer (NOT NULL)
* @return sctx->hash : the HEX Code && SHAMAN_OK on Sucess , -1 on failure
*/
int ShaManHashData(SHAMAN_CTX	*sctx);
/*
* Do File Checksum
* Hash the file named fname (must not exceed < FILE HASH_SIZE )
* @param CTX all is done done internally
* @return sctx->hash on sucess , -1 on failure
*/
int ShaManFileCheckSum(SHAMAN_CTX	*sctx,char	*fname);
/*
* Destructor OO Style
*/
int DestroyShaMan(SHAMAN_CTX	*sctx);


#endif
/******************************** TEST DE L'API ***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include "shaman.h"

int	main(int argc,char	*argv[])
{

	SHAMAN_CTX	*SCT; /* Context ShaMan */
	int res ;
	uint8_t	test[512];
	int i;
	char HAMETH[6][10] = { "SHA1","SHA256","SHA384","SHA512","MD5","BASE64" } ;
	/* Init Shaman Library*/

	SCT = InitShaMan() ;
	
	if( SCT == NULL)
	{
		puts("Cannot Load ShaMan Library");
		exit(EXIT_FAILURE);
	}
	puts(SCT->version);
	
	/* genrate a random String */
	res = GenRandomString(test,17);
	if(res != SHAMAN_OK)
	{
		puts("Cannot Generate Random String");
		exit(EXIT_FAILURE);
	}
	printf("Random String is %s\n\n",test);


	/* prepare to hash */
	ShaManAdd(SCT,test);

	/* core hash module */
	for(i = 0 ; i<= BASE64_HASH ; i++ )
	{
	SCT->meth = i ;
	res = ShaManHashData(SCT);

	if(res != SHAMAN_OK)
	{
		puts("Error While Hasing Data");
		continue ;
	}
	printf("%s Hex Code is:\n\t %s\n\n",HAMETH[i],SCT->hash);

	}

	SCT->meth = SHA1_HASH;
	ShaManFileCheckSum(SCT,"./license.txt");
	printf("License.txt Checksum(SHA1): %s\n",SCT->hash);
	SCT->meth = SHA256_HASH;
	ShaManFileCheckSum(SCT,"./license.txt");
	printf("License.txt Checksum(SHA256): %s\n",SCT->hash);
	SCT->meth = MD5_HASH;
	ShaManFileCheckSum(SCT,"./license.txt");
	printf("License.txt Checksum(MD5): %s\n",SCT->hash);


	DestroyShaMan(SCT);

	system("PAUSE");
	return 0;
}