exa/codecrypt
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

style modifications because of newer astyle

Browse source
This commit is contained in:
Mirek Kratochvil 2013-09-12 12:15:21 +02:00
parent 93cd8f377f
commit 54e45bd3d4
3 changed files with 169 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/ripemd128.h
View file

@ -26,21 +26,21 @@ extern "C" {
#include <stddef.h> #include <stddef.h>
#include <inttypes.h> #include <inttypes.h>
struct ampheck_ripemd128 { struct ampheck_ripemd128 {
uint32_t h[4]; uint32_t h[4];
uint8_t buffer[64]; uint8_t buffer[64];
uint64_t length; uint64_t length;
}; };
void ampheck_ripemd128_init (struct ampheck_ripemd128 *ctx); void ampheck_ripemd128_init (struct ampheck_ripemd128 *ctx);
void ampheck_ripemd128_update (struct ampheck_ripemd128 *ctx, void ampheck_ripemd128_update (struct ampheck_ripemd128 *ctx,
const uint8_t *data, const uint8_t *data,
size_t length); size_t length);
void ampheck_ripemd128_finish (const struct ampheck_ripemd128 *ctx, void ampheck_ripemd128_finish (const struct ampheck_ripemd128 *ctx,
uint8_t *digest); uint8_t *digest);
#ifdef __cplusplus #ifdef __cplusplus
} //extern "C" } //extern "C"

194
src/sha2.h
View file

@ -40,11 +40,11 @@ extern "C" {
#endif #endif
/* /*
* Import u_intXX_t size_t type definitions from system headers. You * Import u_intXX_t size_t type definitions from system headers. You
* may need to change this, or define these things yourself in this * may need to change this, or define these things yourself in this
* file. * file.
*/ */
#include <sys/types.h> #include <sys/types.h>
#ifdef SHA2_USE_INTTYPES_H #ifdef SHA2_USE_INTTYPES_H
@ -54,7 +54,7 @@ extern "C" {
#endif /* SHA2_USE_INTTYPES_H */ #endif /* SHA2_USE_INTTYPES_H */
/*** SHA-256/384/512 Various Length Definitions ***********************/ /*** SHA-256/384/512 Various Length Definitions ***********************/
#define SHA256_BLOCK_LENGTH 64 #define SHA256_BLOCK_LENGTH 64
#define SHA256_DIGEST_LENGTH 32 #define SHA256_DIGEST_LENGTH 32
#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1) #define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
@ -66,126 +66,126 @@ extern "C" {
#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1) #define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
/*** SHA-256/384/512 Context Structures *******************************/ /*** SHA-256/384/512 Context Structures *******************************/
/* NOTE: If your architecture does not define either u_intXX_t types or /* NOTE: If your architecture does not define either u_intXX_t types or
* uintXX_t (from inttypes.h), you may need to define things by hand * uintXX_t (from inttypes.h), you may need to define things by hand
* for your system: * for your system:
*/ */
#if 0 #if 0
typedef unsigned char u_int8_t; /* 1-byte (8-bits) */ typedef unsigned char u_int8_t; /* 1-byte (8-bits) */
typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */ typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */
typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */ typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */
#endif #endif
/* /*
* Most BSD systems already define u_intXX_t types, as does Linux. * Most BSD systems already define u_intXX_t types, as does Linux.
* Some systems, however, like Compaq's Tru64 Unix instead can use * Some systems, however, like Compaq's Tru64 Unix instead can use
* uintXX_t types defined by very recent ANSI C standards and included * uintXX_t types defined by very recent ANSI C standards and included
* in the file: * in the file:
* *
* #include <inttypes.h> * #include <inttypes.h>
* *
* If you choose to use <inttypes.h> then please define: * If you choose to use <inttypes.h> then please define:
* *
* #define SHA2_USE_INTTYPES_H * #define SHA2_USE_INTTYPES_H
* *
* Or on the command line during compile: * Or on the command line during compile:
* *
* cc -DSHA2_USE_INTTYPES_H ... * cc -DSHA2_USE_INTTYPES_H ...
*/ */
#ifdef SHA2_USE_INTTYPES_H #ifdef SHA2_USE_INTTYPES_H
typedef struct _SHA256_CTX { typedef struct _SHA256_CTX {
uint32_t state[8]; uint32_t state[8];
uint64_t bitcount; uint64_t bitcount;
uint8_t buffer[SHA256_BLOCK_LENGTH]; uint8_t buffer[SHA256_BLOCK_LENGTH];
} SHA256_CTX; } SHA256_CTX;
typedef struct _SHA512_CTX { typedef struct _SHA512_CTX {
uint64_t state[8]; uint64_t state[8];
uint64_t bitcount[2]; uint64_t bitcount[2];
uint8_t buffer[SHA512_BLOCK_LENGTH]; uint8_t buffer[SHA512_BLOCK_LENGTH];
} SHA512_CTX; } SHA512_CTX;
#else /* SHA2_USE_INTTYPES_H */ #else /* SHA2_USE_INTTYPES_H */
typedef struct _SHA256_CTX { typedef struct _SHA256_CTX {
u_int32_t state[8]; u_int32_t state[8];
u_int64_t bitcount; u_int64_t bitcount;
u_int8_t buffer[SHA256_BLOCK_LENGTH]; u_int8_t buffer[SHA256_BLOCK_LENGTH];
} SHA256_CTX; } SHA256_CTX;
typedef struct _SHA512_CTX { typedef struct _SHA512_CTX {
u_int64_t state[8]; u_int64_t state[8];
u_int64_t bitcount[2]; u_int64_t bitcount[2];
u_int8_t buffer[SHA512_BLOCK_LENGTH]; u_int8_t buffer[SHA512_BLOCK_LENGTH];
} SHA512_CTX; } SHA512_CTX;
#endif /* SHA2_USE_INTTYPES_H */ #endif /* SHA2_USE_INTTYPES_H */
typedef SHA512_CTX SHA384_CTX; typedef SHA512_CTX SHA384_CTX;
/*** SHA-256/384/512 Function Prototypes ******************************/ /*** SHA-256/384/512 Function Prototypes ******************************/
#ifndef NOPROTO #ifndef NOPROTO
#ifdef SHA2_USE_INTTYPES_H #ifdef SHA2_USE_INTTYPES_H
void SHA256_Init (SHA256_CTX *); void SHA256_Init (SHA256_CTX *);
void SHA256_Update (SHA256_CTX*, const uint8_t*, size_t); void SHA256_Update (SHA256_CTX*, const uint8_t*, size_t);
void SHA256_Final (uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); void SHA256_Final (uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
char* SHA256_End (SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_End (SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
char* SHA256_Data (const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_Data (const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
void SHA384_Init (SHA384_CTX*); void SHA384_Init (SHA384_CTX*);
void SHA384_Update (SHA384_CTX*, const uint8_t*, size_t); void SHA384_Update (SHA384_CTX*, const uint8_t*, size_t);
void SHA384_Final (uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*); void SHA384_Final (uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
char* SHA384_End (SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_End (SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
char* SHA384_Data (const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_Data (const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
void SHA512_Init (SHA512_CTX*); void SHA512_Init (SHA512_CTX*);
void SHA512_Update (SHA512_CTX*, const uint8_t*, size_t); void SHA512_Update (SHA512_CTX*, const uint8_t*, size_t);
void SHA512_Final (uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*); void SHA512_Final (uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
char* SHA512_End (SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_End (SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
char* SHA512_Data (const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_Data (const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#else /* SHA2_USE_INTTYPES_H */ #else /* SHA2_USE_INTTYPES_H */
void SHA256_Init (SHA256_CTX *); void SHA256_Init (SHA256_CTX *);
void SHA256_Update (SHA256_CTX*, const u_int8_t*, size_t); void SHA256_Update (SHA256_CTX*, const u_int8_t*, size_t);
void SHA256_Final (u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); void SHA256_Final (u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
char* SHA256_End (SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_End (SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
char* SHA256_Data (const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); char* SHA256_Data (const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
void SHA384_Init (SHA384_CTX*); void SHA384_Init (SHA384_CTX*);
void SHA384_Update (SHA384_CTX*, const u_int8_t*, size_t); void SHA384_Update (SHA384_CTX*, const u_int8_t*, size_t);
void SHA384_Final (u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*); void SHA384_Final (u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
char* SHA384_End (SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_End (SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
char* SHA384_Data (const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]); char* SHA384_Data (const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
void SHA512_Init (SHA512_CTX*); void SHA512_Init (SHA512_CTX*);
void SHA512_Update (SHA512_CTX*, const u_int8_t*, size_t); void SHA512_Update (SHA512_CTX*, const u_int8_t*, size_t);
void SHA512_Final (u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*); void SHA512_Final (u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
char* SHA512_End (SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_End (SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
char* SHA512_Data (const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); char* SHA512_Data (const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
#endif /* SHA2_USE_INTTYPES_H */ #endif /* SHA2_USE_INTTYPES_H */
#else /* NOPROTO */ #else /* NOPROTO */
void SHA256_Init(); void SHA256_Init();
void SHA256_Update(); void SHA256_Update();
void SHA256_Final(); void SHA256_Final();
char* SHA256_End(); char* SHA256_End();
char* SHA256_Data(); char* SHA256_Data();
void SHA384_Init(); void SHA384_Init();
void SHA384_Update(); void SHA384_Update();
void SHA384_Final(); void SHA384_Final();
char* SHA384_End(); char* SHA384_End();
char* SHA384_Data(); char* SHA384_Data();
void SHA512_Init(); void SHA512_Init();
void SHA512_Update(); void SHA512_Update();
void SHA512_Final(); void SHA512_Final();
char* SHA512_End(); char* SHA512_End();
char* SHA512_Data(); char* SHA512_Data();
#endif /* NOPROTO */ #endif /* NOPROTO */

122
src/tiger.h
View file

@ -50,10 +50,10 @@ extern "C" {
#include <stdint.h> #include <stdint.h>
#else #else
typedef __int32 int32_t; typedef __int32 int32_t;
typedef unsigned __int32 uint32_t; typedef unsigned __int32 uint32_t;
typedef __int64 int64_t; typedef __int64 int64_t;
typedef unsigned __int64 uint64_t; typedef unsigned __int64 uint64_t;
#endif #endif
@ -83,71 +83,71 @@ extern "C" {
#endif #endif
/** A word in the tiger hash, 64 bits **/ /** A word in the tiger hash, 64 bits **/
typedef uint64_t t_word; typedef uint64_t t_word;
/** This one is provided as a commodity for people wanting an easy way /** This one is provided as a commodity for people wanting an easy way
* to declare result variables **/ * to declare result variables **/
typedef t_word t_res[3]; typedef t_word t_res[3];
/** Partial calculation as used by tigerp1 and tigerp2 **/ /** Partial calculation as used by tigerp1 and tigerp2 **/
typedef struct { typedef struct {
t_res h; // Hash status t_res h; // Hash status
char r[128]; // SALT char r[128]; // SALT
t_word n; // Number of characters of r used t_word n; // Number of characters of r used
t_word hs; // Amount of total data hashed t_word hs; // Amount of total data hashed
} t_pres; } t_pres;
/** This one is provided as a commodity for people wanting an easy way /** This one is provided as a commodity for people wanting an easy way
* to declare block variables **/ * to declare block variables **/
typedef t_word t_block[8]; typedef t_word t_block[8];
/** Standard tiger calculation, put your string in str and the string /** Standard tiger calculation, put your string in str and the string
* length on length and get the result on res **/ * length on length and get the result on res **/
void tiger (const char *str, t_word length, t_res res); void tiger (const char *str, t_word length, t_res res);
/** Similar to tiger but interleaving accesses to both equally sized /** Similar to tiger but interleaving accesses to both equally sized
* strings to reduce overhead and pipeline stalls you get the result of * strings to reduce overhead and pipeline stalls you get the result of
* str1 on res1 and the one of str2 on res2 **/ * str1 on res1 and the one of str2 on res2 **/
void tiger_2 (const char *str1, const char *str2, t_word length, void tiger_2 (const char *str1, const char *str2, t_word length,
t_res res1, t_res res2); t_res res1, t_res res2);
#ifdef __SSE2__ #ifdef __SSE2__
/** This is equivalent to tiger_2 but uses SSE2 for the key schduling /** This is equivalent to tiger_2 but uses SSE2 for the key schduling
* making it faster **/ * making it faster **/
void tiger_sse2 (const char *str1, const char *str2, t_word length, void tiger_sse2 (const char *str1, const char *str2, t_word length,
t_res res1, t_res res2); t_res res1, t_res res2);
#endif #endif
/** This function is optimized for use on TTHs just send the two /** This function is optimized for use on TTHs just send the two
* concatenated hashes and you will get back the hash with a prepended * concatenated hashes and you will get back the hash with a prepended
* 0x01 **/ * 0x01 **/
void tiger_49 (const char *str, t_res res); void tiger_49 (const char *str, t_res res);
/** This function is optimized for use on TTHs just send the 1024 sized /** 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 **/ * block and you will get back the hash with a prepended 0x00 **/
void tiger_1025 (const char *str, t_res res); void tiger_1025 (const char *str, t_res res);
/** Interleaved version of tiger_49 you insert two hashes and get back /** Interleaved version of tiger_49 you insert two hashes and get back
* two results **/ * two results **/
void tiger_2_49 (const char *str1, const char *str2, void tiger_2_49 (const char *str1, const char *str2,
t_res res1, t_res res2); t_res res1, t_res res2);
/** Interleaved version of tiger_1025 you insert two hashes and get /** Interleaved version of tiger_1025 you insert two hashes and get
* back two results **/ * back two results **/
void tiger_2_1025 (const char *str1, const char *str2, void tiger_2_1025 (const char *str1, const char *str2,
t_res res1, t_res res2); t_res res1, t_res res2);
#ifdef __SSE2__ #ifdef __SSE2__
/** SSE2 version of tiger_49 you insert two hashes and get back two /** SSE2 version of tiger_49 you insert two hashes and get back two
* results **/ * results **/
void tiger_sse2_49 (const char *str1, const char *str2, void tiger_sse2_49 (const char *str1, const char *str2,
t_res res1, t_res res2); t_res res1, t_res res2);
/** SSE2 version of tiger_1025 you insert two hashes and get back two /** SSE2 version of tiger_1025 you insert two hashes and get back two
* results **/ * results **/
void tiger_sse2_1025 (const char *str1, const char *str2, void tiger_sse2_1025 (const char *str1, const char *str2,
t_res res1, t_res res2); t_res res1, t_res res2);
#endif #endif
/** First stage of partial tiger calculation to improve password /** First stage of partial tiger calculation to improve password
* security during storage **/ * security during storage **/
void tigerp1 (const char *password, t_word length, const char *salt, void tigerp1 (const char *password, t_word length, const char *salt,
t_pres *pres); t_pres *pres);
/** Second stage of partial tiger calculation **/ /** Second stage of partial tiger calculation **/
void tigerp2 (const t_pres *pres, const char *salt, t_word length, void tigerp2 (const t_pres *pres, const char *salt, t_word length,
t_res res); t_res res);
#ifdef __cplusplus #ifdef __cplusplus
} //extern "C" } //extern "C"