along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
- * File: A5_1.h
- * Author: Daniel Otte
- * Date: 24.06.2006
+ * File: A5_1.h
+ * Author: Daniel Otte
+ * Date: 24.06.2006
* License: GPL
* Description: Implementation of the A5/1 stream cipher algorithm, as used in GSM.
* ! Warning, this is weak crypto !
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
-ALIASES =
+ALIASES = "license=\par License:\n" "email=\par E-Mail:\n"
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = NO
BUILTIN_STL_SUPPORT = NO
RECURSIVE = NO
EXCLUDE =
EXCLUDE_SYMLINKS = NO
-EXCLUDE_PATTERNS =
+EXCLUDE_PATTERNS = main-*
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
CLASS_DIAGRAMS = NO
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
-CLASS_GRAPH = YES
+CLASS_GRAPH = NO
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
-CALL_GRAPH = YES
+CALL_GRAPH = NO
CALLER_GRAPH = NO
-GRAPHICAL_HIERARCHY = YES
+GRAPHICAL_HIERARCHY = NO
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
xclean: clean
rm -rf $(DEP_DIR)*.d
-flash:
- $(ERASECMD)
- $(FLASHCMD)
+docu:
+ doxygen
+
%.lst: %.elf
$(OBJDUMP) -h -S $< > $@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+
/*
* File: arcfour-asm.S
* Author: Daniel Otte
* length is length of key in bytes!
*/
-void arcfour_init(arcfour_ctx_t *c, uint8_t *key, uint8_t length){
+void arcfour_init(arcfour_ctx_t *ctx, void *key, uint8_t length_B){
uint8_t t;
unsigned x,y=0;
for(x=0; x<= 255; ++x)
- c->s[x]=x;
+ ctx->s[x]=x;
for(x=0; x<= 255; ++x){
- y += c->s[x] + key[x % length];
+ y += ctx->s[x] + ((uint8_t*)key)[x % length_B];
y &= 0xff;
- t = c->s[y];
- c->s[y] = c->s[x];
- c->s[x] = t;
- };
-
- c->i = c->j = 0;
+ t = ctx->s[y];
+ ctx->s[y] = ctx->s[x];
+ ctx->s[x] = t;
+ }
+ ctx->i = ctx->j = 0;
}
-uint8_t arcfour_gen(arcfour_ctx_t *c){
+uint8_t arcfour_gen(arcfour_ctx_t *ctx){
uint8_t t;
- c->i++;
- c->j += c->s[c->i];
- t = c->s[c->j];
- c->s[c->j] = c->s[c->i];
- c->s[c->i] = t;
- return c->s[(c->s[c->j] + c->s[c->i]) & 0xff];
+ ctx->i++;
+ ctx->j += ctx->s[ctx->i];
+ t = ctx->s[ctx->j];
+ ctx->s[ctx->j] = ctx->s[ctx->i];
+ ctx->s[ctx->i] = t;
+ return ctx->s[(ctx->s[ctx->j] + ctx->s[ctx->i]) & 0xff];
}
* File: arcfour.h
* Author: Daniel Otte
* Date: 2006-06-07
- * License: GPL
+ * License: GPLv3+
* Description: Implementation of the ARCFOUR (RC4 compatible) stream cipher algorithm.
*/
-/*
+
+/**
* \file arcfour.h
* \author Daniel Otte
* \date 2006-06-07
- * \par License
- * GPL
- * \brief Implementation of the ARCFOUR (RC4 compatible) stream cipher algorithm.
+ * \license GPLv3+
+ * \brief Implementation of the ARCFOUR (RC4 compatible) stream cipher algorithm.
+ *
+ * This header file defines the interface of the ARCFOUR cipher implementation.
+ *
+ * This implementation aims to be compatible with the ARCFOUR description
+ * availabe at
+ * http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt
*/
#include <stdint.h>
-typedef struct {
+/** \typedef arcfour_ctx_t
+ * \brief type for arcfour context
+ *
+ * A variable of this type may contain a complete ARCFOUR context.
+ * The context is used to store the state of the cipher and gets
+ * created by the arcfour_init(arcfour_ctx_t *c, uint8_t *key, uint8_t length_B)
+ * function. The context is of the fixed size of 258 bytes
+ */
+
+/** \struct arcfour_ctx_st
+ * \brief base for ::arcfour_ctx_t
+ *
+ * The struct holds the two indices and the S-Box
+ */
+typedef struct arcfour_ctx_st {
uint8_t i,j;
uint8_t s[256];
} arcfour_ctx_t;
+/** \fn void arcfour_init(arcfour_ctx_t *ctx, void *key, uint8_t length_B)
+ * \brief setup a context with a key
+ *
+ * This function sets up a ::arcfour_ctx_t context using
+ * the supplied key of the given length.
+ * \param ctx pointer to the context
+ * \param key pointer to the key
+ * \param length_B length of the key in bytes (between 1 and 255)
+ */
+
+void arcfour_init(arcfour_ctx_t *ctx, void *key, uint8_t length_B);
-void arcfour_init(arcfour_ctx_t *c, uint8_t *key, uint8_t length);
-uint8_t arcfour_gen(arcfour_ctx_t *c);
+/** \fn uint8_t arcfour_gen(arcfour_ctx_t *ctx)
+ * \brief generates a byte of keystream
+ *
+ * This function generates the next byte of keystream
+ * from the supplied ::arcfour_ctx_t context which is updated acordingly
+ *
+ * \param ctx pointer to the context
+ * \return byte of keystream
+ */
+
+uint8_t arcfour_gen(arcfour_ctx_t *ctx);
#endif
-/**
- * \brief sets up round keys (context) for cast5 en/decryption.
- * @param s Pointer to cast5 context.
- * @param key Pointer to binary key.
- * @param keylength length of keydata in bits.
- */
-void cast5_init(uint8_t* key, uint8_t keylength_b, cast5_ctx_t* s){
+
+void cast5_init(void* key, uint8_t keylength_b, cast5_ctx_t* s){
/* we migth return if the key is valid and if setup was sucessfull */
uint32_t x[4], z[4];
#define BPX ((uint8_t*)&(x[0]))
/*************************************************************************/
-/**
- * \brief encrypts a datablock with cast5
- * @param block Pointer to datablock
- * @param s Pointer to cast5 roundkeys (context)
- */
-void cast5_enc(void* block, cast5_ctx_t *s){
+void cast5_enc(void* block, const cast5_ctx_t *s){
uint32_t l,r, x, y;
uint8_t i;
cast5_f_t* f[]={cast5_f1,cast5_f2,cast5_f3};
/*************************************************************************/
-/**
- * \brief decrypts a datablock with cast5
- * @param block Pointer to datablock
- * @param s Pointer to cast5 roundkeys (context)
- */
-void cast5_dec(void* block, cast5_ctx_t *s){
+void cast5_dec(void* block, const cast5_ctx_t *s){
uint32_t l,r, x, y;
int8_t i, rounds;
cast5_f_t* f[]={cast5_f1,cast5_f2,cast5_f3};
* Description: Implementation of the CAST5 (aka CAST-128) cipher algorithm as described in RFC 2144
*
*/
+
+/**
+ * \file cast5.h
+ * \author Daniel Otte
+ * \date 2006-07-26
+ * \license GPL
+ * \brief Implementation of the CAST5 (aka CAST-128) cipher algorithm as described in RFC 2144
+ *
+ */
+
#ifndef CAST5_H_
#define CAST5_H_
#endif
#endif
-
+/** \typedef cast5_ctx_t
+ * \brief CAST-5 context
+ *
+ * A variable of this type may hold a keyschedule for the CAST-5 cipher.
+ * This context is regulary generated by the
+ * cast5_init(uint8_t* key, uint8_t keylength_b, cast5_ctx_t* s) funtion.
+ */
typedef struct cast5_ctx_st{
uint32_t mask[16];
uint8_t rotl[8]; /* 4 bit from every rotation key is stored here */
bool shortkey;
} cast5_ctx_t;
-void cast5_init(uint8_t* key, uint8_t keylength_b, cast5_ctx_t* s);
-void cast5_enc(void* block, cast5_ctx_t *s);
-void cast5_dec(void* block, cast5_ctx_t *s);
+
+/** \fn void cast5_init(void* key, uint8_t keylength_b, cast5_ctx_t* s);
+ * \brief generate keyschedule/contex for CAST-5
+ *
+ * This function generates the keyschedule from the supplied key for the
+ * CAST-5 cipher and stores it in a supplied ::cast5_ctx_t context.
+ * \param key pointer to the key
+ * \param keylength_b length of the key in bits (maximum 128 bits)
+ * \param s pointer to the context
+ */
+void cast5_init(void* key, uint8_t keylength_b, cast5_ctx_t* s);
+
+/** \fn void cast5_enc(void* block, const cast5_ctx_t *s);
+ * \brief encrypt a block with the CAST-5 algorithm
+ *
+ * This function encrypts a block of 64 bits (8 bytes) with the CAST-5 algorithm.
+ * It uses a keyschedule as generated by the
+ * cast5_init(void* key, uint8_t keylength_b, cast5_ctx_t* s) function.
+ * \param block pointer to the block which gets encrypted
+ * \param s pointer to the keyschedule/context
+ */
+void cast5_enc(void* block, const cast5_ctx_t *s);
+
+/** \fn void cast5_dec(void* block, const cast5_ctx_t *s);
+ * \brief decrypt a block with the CAST-5 algorithm
+ *
+ * This function decrypts a block of 64 bits (8 bytes) with the CAST-5 algorithm.
+ * It uses a keyschedule as generated by the
+ * cast5_init(void* key, uint8_t keylength_b, cast5_ctx_t* s) function.
+ * \param block pointer to the block which gets decrypted
+ * \param s pointer to the keyschedule/context
+ */
+void cast5_dec(void* block, const cast5_ctx_t *s);
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
- * \file des.c
- * \author Daniel Otte
- * \email daniel.otte@rub.de
- * \date 2007-06-16
- * \brief DES and EDE-DES implementation
- * \par License
- * GPLv3 or later
+ * \file des.c
+ * \author Daniel Otte
+ * \email daniel.otte@rub.de
+ * \date 2007-06-16
+ * \brief DES and EDE-DES implementation
+ * \license GPLv3 or later
*
*/
#include "config.h"
#include "debug.h"
#include "uart.h"
+#include <stdint.h>
#include <string.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#define ROTTABLE_INV 0x3F7E
/******************************************************************************/
-void permute(prog_uint8_t *ptable, uint8_t *in, uint8_t *out){
+void permute(prog_uint8_t *ptable, const uint8_t *in, uint8_t *out){
uint8_t ib, ob; /* in-bytes and out-bytes */
uint8_t byte, bit; /* counter for bit and byte */
ib = pgm_read_byte(&(ptable[0]));
/******************************************************************************/
-void des_enc(uint8_t* out, uint8_t* in, uint8_t* key){
+void des_enc(void* out, const void* in, const void* key){
#define R *((uint32_t*)&(data[4]))
#define L *((uint32_t*)&(data[0]))
uint8_t data[8],kr[6],k[7];
uint8_t i;
- permute((prog_uint8_t*)ip_permtab, in, data);
- permute((prog_uint8_t*)pc1_permtab, key, k);
+ permute((prog_uint8_t*)ip_permtab, (uint8_t*)in, data);
+ permute((prog_uint8_t*)pc1_permtab, (uint8_t*)key, k);
for(i=0; i<8; ++i){
shiftkey(k);
if(ROTTABLE&((1<<((i<<1)+0))) )
L ^= R;
R ^= L;
- permute((prog_uint8_t*)inv_ip_permtab, data, out);
+ permute((prog_uint8_t*)inv_ip_permtab, data, (uint8_t*)out);
}
/******************************************************************************/
-void des_dec(uint8_t* out, uint8_t* in, uint8_t* key){
+void des_dec(void* out, const void* in, const uint8_t* key){
#define R *((uint32_t*)&(data[4]))
#define L *((uint32_t*)&(data[0]))
uint8_t data[8],kr[6],k[7];
int8_t i;
- permute((prog_uint8_t*)ip_permtab, in, data);
- permute((prog_uint8_t*)pc1_permtab, key, k);
+ permute((prog_uint8_t*)ip_permtab, (uint8_t*)in, data);
+ permute((prog_uint8_t*)pc1_permtab, (uint8_t*)key, k);
for(i=7; i>=0; --i){
permute((prog_uint8_t*)pc2_permtab, k, kr);
L ^= R;
R ^= L;
- permute((prog_uint8_t*)inv_ip_permtab, data, out);
+ permute((prog_uint8_t*)inv_ip_permtab, data, (uint8_t*)out);
}
/******************************************************************************/
-void tdes_enc(uint8_t* out, uint8_t* in, uint8_t* key){
- des_enc(out, in, key + 0);
- des_dec(out, out, key + 8);
- des_enc(out, out, key +16);
+void tdes_enc(void* out, void* in, const void* key){
+ des_enc(out, in, (uint8_t*)key + 0);
+ des_dec(out, out, (uint8_t*)key + 8);
+ des_enc(out, out, (uint8_t*)key +16);
}
/******************************************************************************/
-void tdes_dec(uint8_t* out, uint8_t* in, uint8_t* key){
- des_dec(out, in, key + 0);
- des_enc(out, out, key + 8);
- des_dec(out, out, key +16);
+void tdes_dec(void* out, void* in, const uint8_t* key){
+ des_dec(out, in, (uint8_t*)key + 0);
+ des_enc(out, out, (uint8_t*)key + 8);
+ des_dec(out, out, (uint8_t*)key +16);
}
/******************************************************************************/
* \author Daniel Otte
* \date 2007-06-16
* \brief des and tdes declarations
- * \par License
- * GPL
+ * \license GPLv3 or later
*
*/
#ifndef DES_H_
#define DES_H_
-#include <stdint.h>
/* the FIPS 46-3 (1999-10-25) name for triple DES is triple data encryption algorithm so TDEA.
* Also we only implement the three key mode */
+
+/** \def tdea_enc
+ * \brief defining an alias for void tdes_enc(void* out, const void* in, const void* key)
+ */
+
+/** \def tdea_dec
+ * \brief defining an alias for void tdes_dec(void* out, const void* in, const void* key)
+ */
+
#define tdea_enc tdes_enc
#define tdea_dec tdes_dec
-void des_enc(uint8_t* out, uint8_t* in, uint8_t* key);
-void des_dec(uint8_t* out, uint8_t* in, uint8_t* key);
-void tdes_enc(uint8_t* out, uint8_t* in, uint8_t* key);
-void tdes_dec(uint8_t* out, uint8_t* in, uint8_t* key);
+/** \fn void des_enc(void* out, const void* in, const void* key)
+ * \brief encrypt a block with DES
+ *
+ * This function encrypts a block of 64 bits (8 bytes) with the DES algorithm.
+ * Key expansion is done automatically. The key is 64 bits long, but note that
+ * only 56 bits are used (the LSB of each byte is droped). The input and output
+ * blocks may overlap.
+ *
+ * \param out pointer to the block (64 bit = 8 byte) where the ciphertext is written to
+ * \param in pointer to the block (64 bit = 8 byte) where the plaintext is read from
+ * \param key pointer to the key (64 bit = 8 byte)
+ */
+void des_enc(void* out, const void* in, const void* key);
+
+/** \fn void des_dec(void* out, const void* in, const void* key)
+ * \brief decrypt a block with DES
+ *
+ * This function decrypts a block of 64 bits (8 bytes) with the DES algorithm.
+ * Key expansion is done automatically. The key is 64 bits long, but note that
+ * only 56 bits are used (the LSB of each byte is droped). The input and output
+ * blocks may overlap.
+ *
+ * \param out pointer to the block (64 bit = 8 byte) where the plaintext is written to
+ * \param in pointer to the block (64 bit = 8 byte) where the ciphertext is read from
+ * \param key pointer to the key (64 bit = 8 byte)
+ */
+void des_dec(void* out, const void* in, const void* key);
+
+/** \fn void tdes_enc(void* out, const void* in, const void* key)
+ * \brief encrypt a block with Tripple-DES
+ *
+ * This function encrypts a block of 64 bits (8 bytes) with the Tripple-DES (EDE)
+ * algorithm. Key expansion is done automatically. The key is 192 bits long, but
+ * note that only 178 bits are used (the LSB of each byte is droped). The input
+ * and output blocks may overlap.
+ *
+ * \param out pointer to the block (64 bit = 8 byte) where the ciphertext is written to
+ * \param in pointer to the block (64 bit = 8 byte) where the plaintext is read from
+ * \param key pointer to the key (192 bit = 24 byte)
+ */
+void tdes_enc(void* out, const void* in, const void* key);
+
+/** \fn void tdes_dec(void* out, const void* in, const void* key)
+ * \brief decrypt a block with Tripple-DES
+ *
+ * This function decrypts a block of 64 bits (8 bytes) with the Tripple-DES (EDE)
+ * algorithm. Key expansion is done automatically. The key is 192 bits long, but
+ * note that only 178 bits are used (the LSB of each byte is droped). The input
+ * and output blocks may overlap.
+ *
+ * \param out pointer to the block (64 bit = 8 byte) where the plaintext is written to
+ * \param in pointer to the block (64 bit = 8 byte) where the ciphertext is read from
+ * \param key pointer to the key (192 bit = 24 byte)
+ */
+ void tdes_dec(void* out, const void* in, const void* key);
#endif /*DES_H_*/
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
- * \file entropium.c
- * \author Daniel Otte
- * \email daniel.otte@rub.de
- * \date 2006-05-17
- * \par License:
- * GPLv3 or later
+ * \file entropium.c
+ * \author Daniel Otte
+ * \email daniel.otte@rub.de
+ * \date 2006-05-17
+ * \license GPLv3 or later
* \brief This file contains an implementaition of a pseudo-random-number generator.
*
* Extension 1:
* rndCore is expanded to 512 bits for more security.
*
- * \verbatim
- * ################################################################################################
- * # #
- * # +---------------------------+ #
- * # | | +---+ #
- * # V | | | #
- * # (concat) | | V #
- * +---------------+ # o---------o (xor)+---------+ o---------o | o----o o---------o # +--------------+
- * | entropy Block | -----> | sha-256 | --(offset)-< | rndCore | ---> | sha-256 | --+--+-| +1 |---> | sha-256 | -----> | random Block |
- * +---------------+ # o---------o (xor)+---------+ o---------o | o----o o---------o # +--------------+
- * # (xor) (xor) | #
- * # ^ ^ | #
- * # \ / | #
- * # (offset)---------------------+ #
- * # #
- * ################################################################################################
- * \endverbatim
- */
-
- /* \verbatim
- * ################################################################################################
- * # #
- * # +---------------------------+ #
- * # | | +---+ #
- * # V | | | #
- * # (concat) | | V #
- * +---------------+ # o---------o (xor)+---------+ o---------o | o----o o---------o # +--------------+
- * | entropy Block | -----> | sha-256 | --(offset)-< | rndCore | ---> | sha-256 | --+--+-| +1 |---> | sha-256 | -----> | random Block |
- * +---------------+ # o---------o (xor)+---------+ o---------o | o----o o---------o # +--------------+
- * # (xor) (xor) | #
- * # ^ ^ | #
- * # \ / | #
- * # (offset)---------------------+ #
- * # #
- * ################################################################################################
- * \endverbatim
+ \verbatim
+ ################################################################################################
+ # #
+ # +---------------------------+ #
+ # | | #
+ # V | #
+ # (concat) | #
+ +---------------+ # o---------o (xor)+---------+ o---------o o----o o---------o # +--------------+
+ | entropy Block | -----> | sha-256 | --(offset)-< | rndCore | ---> | sha-256 | --+----| +1 |---> | sha-256 | -----> | random Block |
+ +---------------+ # o---------o (xor)+---------+ o---------o | o----o o---------o # +--------------+
+ # (xor) (xor) | #
+ # ^ ^ | #
+ # \ / | #
+ # (offset)---------------------+ #
+ # #
+ ################################################################################################
+ \endverbatim
*/
#include <stdint.h>
/*************************************************************************/
-/**
- * \brief This function adds entropy to the central entropy pool
- *
- * @param length This ist the length of the random data in BITS.
- * @param data This is the random data which should be added to the entropy pool
-*/
/* idea is: hash the message and add it via xor to rndCore
*
* length in bits
}
/*************************************************************************/
-/**
- * \brief This function fills a given buffer with 32 random bytes
- * @param b Pointer to buffer wich is to fill
- */
+
void entropium_getRandomBlock(void *b){
sha256_ctx_t s;
uint8_t offset=8;
}
/*************************************************************************/
-
-/**
- * \brief This function simply returns a random byte
- * @return a random byte
- */
+
uint8_t entropium_getRandomByte(void){
static uint8_t block[32];
static uint8_t i=32;
return block[i++];
}
-/*************************************************************************/
-
-/**
- * \brief This function fills the given bock with length random bytes
- * @return a random byte
- */
-
void entropium_fillBlockRandom(void* block, unsigned length_B){
while(length_B>ENTROPIUM_RANDOMBLOCK_SIZE){
entropium_getRandomBlock(block);
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+
/**
* File: entropium.h
* Author: Daniel Otte
* Description: This file contains the declarations for the pseudo-random-number generator.
**/
+/**
+ * \file entropium.h
+ * \author Daniel Otte
+ * \date 23.07.2006
+ * \license GPLv3 or later
+ * \brief This file contains the declarations for the pseudo-random-number generator.
+ **/
+
+
#ifndef ENTROPIUM_H_
#define ENTROPIUM_H_
*/
#define ENTROPIUM_RANDOMBLOCK_SIZE 32 /* bytes */
+/** \fn void entropium_addEntropy(unsigned length_b, const void* data)
+ * \brief add entropy to the prng
+ *
+ * This function adds data to the internal entropy pool
+ * \param length_b length of the data block in bits
+ * \param data pointer to the data
+ */
void entropium_addEntropy(unsigned length_b, const void* data);
+
+/** \fn void entropium_getRandomBlock(void* b)
+ * \brief generate a fixed size block of random data
+ *
+ * This function writes 32 bytes of random extracted from the entropy pool
+ * in the supplied buffer.
+ * \param b buffer where the random data gets written
+ */
void entropium_getRandomBlock(void* b);
-/* this does some simple buffering */
+
+/** \fn uint8_t entropium_getRandomByte(void)
+ * \brief get a single byte of random data
+ *
+ * This function utilizes a internal buffer which gets automatically filled
+ * again.
+ * \return a byte of random data
+ */
uint8_t entropium_getRandomByte(void);
+/** \fn void entropium_fillBlockRandom(void* block, unsigned length_B)
+ * \brief get a block of random data
+ *
+ * This function writes random data extracted from the entropy pool in the
+ * supplied buffer. It shares a internal buffer with the
+ * entropium_getRandomByte() function.
+ * \param block pointer to the buffer where the random data goes
+ * \param length_B number of bytes to be written to the buffer
+ */
void entropium_fillBlockRandom(void* block, unsigned length_B);
#endif /*PRNG_H_*/
char* cipher_name = "Shabea";
/*****************************************************************************
- * additional validation-functions *
+ * additional validation-functions *
*****************************************************************************/
-void shabea_genctx_dummy(uint8_t* key, uint16_t keysize, void* ctx){
- memcpy(ctx, key, keysize);
+void shabea_genctx_dummy(uint8_t* key, uint16_t keysize_b, void* ctx){
+ memcpy(ctx, key, (keysize_b+7)/8);
}
void shabea_enc_dummy(void* buffer, void* ctx){
--- /dev/null
+/** \mainpage Documentation for microcrypt-lib
+ \section Algorithms Available algorithms
+ \subsection Stream-ciphers Stream ciphers
+ A stream cipher generates a keystream which is normaly XORed with the
+ plaintext to produce the the ciphertext. Stream ciphers therfore have a
+ state which is automaticaly updated to produce the next element of the
+ keystream. Most Streamciphers produce a fixed length of keytream per
+ iteration which may be a byte, a bit or any other data unit.
+
+ Implemented stream ciphers:
+ - A5/1 (A5_1.h)
+ - ARCFOUR (RC4 compatible) (arcfour.h)
+ - Grain (grain.h)
+ - Trivium (trivium.h)
+
+ \subsection Block-ciphers Block ciphers
+ Block cipher encrypt/decrypt fixed length blocks (mostly 64 bits or 128 bits)
+ with a key. Most block ciphers iterate a round function which uses a so-called
+ round key. The round keys are generated on the fly or with a special init
+ function (this is cipher specific). Round keys are stored in a context which
+ is not modifyed by the encryption or decryption function. Also the same
+ context can be used for encryption and decryption and depends only on the key
+ and its length.
+
+ Implemented block ciphers:
+ - Camellia (camellia.h)
+ - CAST5 (a.k.a CAST-128) (cast5.h)
+ - CAST6 (a.k.a CAST-256) (cast6.h)
+ - DES & Tripple-DES (EDE) (des.h)
+ - Noekeon (noekeon.h)
+ - RC5 (rc5.h)
+ - RC6 (rc6.h)
+ - SEED (seed.h)
+ - Serpent (serpent.h)
+ - Shabea (shabea.h)
+ - SHACAL-1 (encryption only) (shacal1_enc.h)
+ - SHACAL-2 (encryption only) (shacal2_enc.h)
+ - Skipjack (skipjack.h)
+ - XTEA (xtea.h)
+
+ \subsection Hashes Hashes
+ A Hash function produces a fixed length output (called hash value or message
+ digest) from a variable length message input.
+
+ Implemented hash functions:
+ - MD5 (md5.h)
+ - SHA-1 (sha1.h)
+ - SHA-256 (sha256.h)
+
+ \subsection MACs Message-Authentification-Codes (MACs)
+ - HMAC-SHA-1 (hmac-sha1.h)
+ - HMAC-SHA-256 (hmac-sha256.h)
+
+ \subsection PRNGs Pseudo-Random-Number-Generators (PRNGs)
+ - Entropium (entropium.h)
+
+*/
\ No newline at end of file
projects / avr-crypto-lib.git / commitdiff