codecrypt/src/tiger.h

/**
 * Copyright (c) 2012 Francisco Blas Izquierdo Riera (klondike)
 * The Tiger algorithm was written by Eli Biham and Ross Anderson and is
 * available on the official Tiger algorithm page.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    the algorithm authorsip notice, this list of conditions and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 * 4. If this license is not appropriate for you please write me at
 *    klondike ( a t ) klondike ( d o t ) es to negotiate another license.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **/

/**
 * These are some implementations of tiger made without looking at the original
 * reference code to ensure the resulting code can be published under a free
 * license. The paper was looked though to know how did tiger work.
 */

/** Implementation details:
 * * Here we assume char and unsigned char have size 1. If thats not the case in
 *     your compiler you may want to replace them by a type that does
 */

#ifndef TIGER_H
#define TIGER_H 1

#ifdef __cplusplus
extern "C" {
#endif

#if !defined(_MSC_VER) || (_MSC_VER >= 1600)
#include <stdint.h>
#else

typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;

#endif

#if _M_IX86_FP >= 2
#define __SSE2__
#endif

#ifdef __linux
#include <endian.h>
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define IS_LITTLE_ENDIAN
#elif  __BYTE_ORDER == __BIG_ENDIAN
#define USE_BIG_ENDIAN
#elif  __BYTE_ORDER == __PDP_ENDIAN
#error "If you feel like writting code for PDP endianess go ahead, I'm not doing that"
#else
#error "Unknown endianess"
#endif
#else
//Assume little endian if you know how to detect endianism well on other
//compilers state it.
#define IS_LITTLE_ENDIAN
#endif

#if defined(_WIN64) || defined(__x86_64__) || defined(__amd64__)
#define HASX64
#endif


/** A word in the tiger hash, 64 bits **/
typedef uint64_t t_word;

/** This one is provided as a commodity for people wanting an easy way
 * to declare result variables **/
typedef t_word t_res[3];

/** Partial calculation as used by tigerp1 and tigerp2 **/
typedef struct {
	t_res h; // Hash status
	char r[128]; // SALT
	t_word n; // Number of characters of r used
	t_word hs; // Amount of total data hashed
} t_pres;

/** This one is provided as a commodity for people wanting an easy way
 * to declare block variables **/
typedef t_word t_block[8];

/** Standard tiger calculation, put your string in str and the string
 * length on length and get the result on res **/
void tiger (const char *str, t_word length, t_res res);
/** Similar to tiger but interleaving accesses to both equally sized
 * strings to reduce overhead and pipeline stalls you get the result of
 * str1 on res1 and the one of str2 on res2 **/
void tiger_2 (const char *str1, const char *str2, t_word length,
              t_res res1, t_res res2);
#ifdef __SSE2__
/** This is equivalent to tiger_2 but uses SSE2 for the key schduling
 * making it faster **/
void tiger_sse2 (const char *str1, const char *str2, t_word length,
                 t_res res1, t_res res2);
#endif
/** This function is optimized for use on TTHs just send the two
 * concatenated hashes and you will get back the hash with a prepended
 * 0x01 **/
void tiger_49 (const char *str, t_res res);
/** This function is optimized for use on TTHs just send the 1024 sized
 * block and you will get back the hash with a prepended 0x00 **/
void tiger_1025 (const char *str, t_res res);
/** Interleaved version of tiger_49 you insert two hashes and get back
 * two results **/
void tiger_2_49 (const char *str1, const char *str2,
                 t_res res1, t_res res2);
/** Interleaved version of tiger_1025 you insert two hashes and get
 * back two results **/
void tiger_2_1025 (const char *str1, const char *str2,
                   t_res res1, t_res res2);
#ifdef __SSE2__
/** SSE2 version of tiger_49 you insert two hashes and get back two
 * results **/
void tiger_sse2_49 (const char *str1, const char *str2,
                    t_res res1, t_res res2);
/** SSE2 version of tiger_1025 you insert two hashes and get back two
 * results **/
void tiger_sse2_1025 (const char *str1, const char *str2,
                      t_res res1, t_res res2);
#endif
/** First stage of partial tiger calculation to improve password
 * security during storage **/
void tigerp1 (const char *password, t_word length, const char *salt,
              t_pres *pres);
/** Second stage of partial tiger calculation **/
void tigerp2 (const t_pres *pres, const char *salt, t_word length,
              t_res res);

#ifdef __cplusplus
}  //extern "C"
#endif

#endif