76 lines
3.3 KiB
Text
76 lines
3.3 KiB
Text
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.
|
|
|
|
When compiling the following define flags can be added to enable some features:
|
|
* USE_BIG_ENDIAN compile for big endian machines
|
|
* FORCE_ALIGNMENT force 8-byte alignment of inoput data on little endian code to
|
|
prevent issues caused by unaligned acceses.
|
|
Please bear in mind that currently we expect properly aligned output buffers
|
|
for result output and that t_res type takes care of that.
|
|
|
|
The code should detect automatically when a x64 processor and when SSE2 is used
|
|
from the compiler predefined macros. When using MSVC please read
|
|
http://msdn.microsoft.com/en-us/library/7t5yh4fd.aspx to know how to enable
|
|
SSE2 support. In other compilers you may needed to set the __SSE2__ and HASX64
|
|
macros by hand.
|
|
|
|
The API offered currently is the following:
|
|
/** 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;
|
|
|
|
/** 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);
|
|
|
|
/** 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);
|
|
|
|
/** 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);
|
|
|
|
/** 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
|
|
);
|
|
|
|
/** 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);
|