gf128mul.h File Reference

#include <stdlib.h>
#include <string.h>
#include "mode_hdr.h"

Go to the source code of this file.

Defines

#define TABLES_8K
#define GF_BYTE_LEN   16
#define VERSION_1
#define MSK_80   (0x80 * (unit_cast(BFR_UNIT,-1) / 0xff))
#define MSK_F0   (0xf0 * (unit_cast(BFR_UNIT,-1) / 0xff))
#define mul_x(r, x)
#define mul_x4(x)
#define mul_x8(x)
#define tab64k(x)   ((gf_t64k)x)
#define xor_64k(i, a, t, r)   xor_block_aligned(r, tab64k(t)[i][a[i]])
#define gf_mul_64k(a, t, r)
#define tab8k(x)   ((gf_t8k)x)
#define xor_8k(i, a, t, r)
#define gf_mul_8k(a, t, r)
#define tab4k(x)   ((gf_t4k)x)
#define xor_4k(i, a, t, r)   mul_x8(r); xor_block_aligned(r, tab4k(t)[a[i]])
#define gf_mul_4k(a, t, r)
#define tab256(t)   ((gf_t256)t)
#define xor_256(i, a, t, r)
#define gf_mul_256(a, t, r)

Typedefs

typedef uint_32t(* gf_t64k )[256][GF_BYTE_LEN >> 2]
typedef uint_32t(* gf_t8k )[16][GF_BYTE_LEN >> 2]
typedef uint_32t(* gf_t4k )[GF_BYTE_LEN >> 2]
typedef uint_32t(* gf_t256 )[GF_BYTE_LEN >> 2]

Functions

void gf_mul (void *a, const void *b)
void init_64k_table (unsigned char g[], void *t)
void init_8k_table (unsigned char g[], void *t)
void init_4k_table (unsigned char g[], void *t)
void init_256_table (unsigned char g[], void *t)

Variables

const unsigned short gf_tab [256]

Define Documentation

#define GF_BYTE_LEN   16

Definition at line 104 of file gf128mul.h.

#define gf_mul_256 ( a,
t,
 ) 
Value:
do { int i = 15;                \
    move_block_aligned(r,tab256(t)[a[15] & 15]); mul_x4(r); \
    xor_block_aligned(r, tab256(t)[a[15] >> 4]);            \
    while(i--)                                              \
    {   xor_256(i, a, t, r);                                \
    }                                                       \
    move_block_aligned(a, r);                               \
} while(0)

Definition at line 935 of file gf128mul.h.

#define gf_mul_4k ( a,
t,
 ) 
Value:
do { int i = 15; \
    move_block_aligned(r,tab4k(t)[a[15]]);  \
    while(i--)                              \
    {   xor_4k(i, a, t, r);                 \
    }                                       \
    move_block_aligned(a, r);               \
} while(0)

Definition at line 846 of file gf128mul.h.

#define gf_mul_64k ( a,
t,
 ) 
Value:
do {                \
    move_block_aligned(r, tab64k(t)[0][a[0]]);  \
    xor_64k( 1, a, t, r);                       \
    xor_64k( 2, a, t, r); xor_64k( 3, a, t, r); \
    xor_64k( 4, a, t, r); xor_64k( 5, a, t, r); \
    xor_64k( 6, a, t, r); xor_64k( 7, a, t, r); \
    xor_64k( 8, a, t, r); xor_64k( 9, a, t, r); \
    xor_64k(10, a, t, r); xor_64k(11, a, t, r); \
    xor_64k(12, a, t, r); xor_64k(13, a, t, r); \
    xor_64k(14, a, t, r); xor_64k(15, a, t, r); \
    move_block_aligned(a, r);                   \
} while(0)

Definition at line 672 of file gf128mul.h.

#define gf_mul_8k ( a,
t,
 ) 
Value:
do { int i;              \
    memcpy(r, tab8k(t)[0][a[0] & 15], GF_BYTE_LEN); \
    xor_block_aligned(r, tab8k(t)[1][a[0] >> 4]);   \
    for(i = 1; i < GF_BYTE_LEN; ++i)                \
    {   xor_8k(i, a, t, r);                         \
    }                                               \
    memcpy(a, r, GF_BYTE_LEN);                      \
} while(0)

Definition at line 765 of file gf128mul.h.

#define MSK_80   (0x80 * (unit_cast(BFR_UNIT,-1) / 0xff))

Definition at line 157 of file gf128mul.h.

#define MSK_F0   (0xf0 * (unit_cast(BFR_UNIT,-1) / 0xff))

Definition at line 158 of file gf128mul.h.

#define mul_x ( r,
 ) 
Value:
do { uint_8t _tt = ui8_ptr(x)[15] & 1;          \
        ui8_ptr(r)[15] = (ui8_ptr(x)[15] >> 1) | (ui8_ptr(x)[14] << 7); \
        ui8_ptr(r)[14] = (ui8_ptr(x)[14] >> 1) | (ui8_ptr(x)[13] << 7); \
        ui8_ptr(r)[13] = (ui8_ptr(x)[13] >> 1) | (ui8_ptr(x)[12] << 7); \
        ui8_ptr(r)[12] = (ui8_ptr(x)[12] >> 1) | (ui8_ptr(x)[11] << 7); \
        ui8_ptr(r)[11] = (ui8_ptr(x)[11] >> 1) | (ui8_ptr(x)[10] << 7); \
        ui8_ptr(r)[10] = (ui8_ptr(x)[10] >> 1) | (ui8_ptr(x)[ 9] << 7); \
        ui8_ptr(r)[ 9] = (ui8_ptr(x)[ 9] >> 1) | (ui8_ptr(x)[ 8] << 7); \
        ui8_ptr(r)[ 8] = (ui8_ptr(x)[ 8] >> 1) | (ui8_ptr(x)[ 7] << 7); \
        ui8_ptr(r)[ 7] = (ui8_ptr(x)[ 7] >> 1) | (ui8_ptr(x)[ 6] << 7); \
        ui8_ptr(r)[ 6] = (ui8_ptr(x)[ 6] >> 1) | (ui8_ptr(x)[ 5] << 7); \
        ui8_ptr(r)[ 5] = (ui8_ptr(x)[ 5] >> 1) | (ui8_ptr(x)[ 4] << 7); \
        ui8_ptr(r)[ 4] = (ui8_ptr(x)[ 4] >> 1) | (ui8_ptr(x)[ 3] << 7); \
        ui8_ptr(r)[ 3] = (ui8_ptr(x)[ 3] >> 1) | (ui8_ptr(x)[ 2] << 7); \
        ui8_ptr(r)[ 2] = (ui8_ptr(x)[ 2] >> 1) | (ui8_ptr(x)[ 1] << 7); \
        ui8_ptr(r)[ 1] = (ui8_ptr(x)[ 1] >> 1) | (ui8_ptr(x)[ 0] << 7); \
        ui8_ptr(r)[ 0] = (ui8_ptr(x)[ 0] >> 1) ^ (_tt ? 0xe1 : 0x00);   \
    } while(0)

Definition at line 374 of file gf128mul.h.

#define mul_x4 (  ) 
Value:
do { uint_16t _tt = gf_tab[(ui8_ptr(x)[15] << 4) & 0xff];         \
        ui8_ptr(x)[15] =  (ui8_ptr(x)[15] >> 4) | (ui8_ptr(x)[14] << 4);                \
        ui8_ptr(x)[14] =  (ui8_ptr(x)[14] >> 4) | (ui8_ptr(x)[13] << 4);                \
        ui8_ptr(x)[13] =  (ui8_ptr(x)[13] >> 4) | (ui8_ptr(x)[12] << 4);                \
        ui8_ptr(x)[12] =  (ui8_ptr(x)[12] >> 4) | (ui8_ptr(x)[11] << 4);                \
        ui8_ptr(x)[11] =  (ui8_ptr(x)[11] >> 4) | (ui8_ptr(x)[10] << 4);                \
        ui8_ptr(x)[10] =  (ui8_ptr(x)[10] >> 4) | (ui8_ptr(x)[ 9] << 4);                \
        ui8_ptr(x)[ 9] =  (ui8_ptr(x)[ 9] >> 4) | (ui8_ptr(x)[ 8] << 4);                \
        ui8_ptr(x)[ 8] =  (ui8_ptr(x)[ 8] >> 4) | (ui8_ptr(x)[ 7] << 4);                \
        ui8_ptr(x)[ 7] =  (ui8_ptr(x)[ 7] >> 4) | (ui8_ptr(x)[ 6] << 4);                \
        ui8_ptr(x)[ 6] =  (ui8_ptr(x)[ 6] >> 4) | (ui8_ptr(x)[ 5] << 4);                \
        ui8_ptr(x)[ 5] =  (ui8_ptr(x)[ 5] >> 4) | (ui8_ptr(x)[ 4] << 4);                \
        ui8_ptr(x)[ 4] =  (ui8_ptr(x)[ 4] >> 4) | (ui8_ptr(x)[ 3] << 4);                \
        ui8_ptr(x)[ 3] =  (ui8_ptr(x)[ 3] >> 4) | (ui8_ptr(x)[ 2] << 4);                \
        ui8_ptr(x)[ 2] =  (ui8_ptr(x)[ 2] >> 4) | (ui8_ptr(x)[ 1] << 4);                \
        ui8_ptr(x)[ 1] = ((ui8_ptr(x)[ 1] >> 4) | (ui8_ptr(x)[ 0] << 4)) ^ (_tt >> 8);  \
        ui8_ptr(x)[ 0] =  (ui8_ptr(x)[ 0] >> 4) ^ (_tt & 0xff);                         \
    } while(0)

Definition at line 393 of file gf128mul.h.

#define mul_x8 (  ) 
Value:
do { uint_16t _tt = gf_tab[ui8_ptr(x)[15]];   \
        memmove(ui8_ptr(x) + 1, ui8_ptr(x), 15);                    \
        ui8_ptr(x)[1] ^= (_tt >> 8);                                \
        ui8_ptr(x)[0] = (_tt & 0xff);                               \
    } while(0)

Definition at line 412 of file gf128mul.h.

#define tab256 (  )     ((gf_t256)t)

Definition at line 879 of file gf128mul.h.

#define tab4k (  )     ((gf_t4k)x)

Definition at line 798 of file gf128mul.h.

#define tab64k (  )     ((gf_t64k)x)

Definition at line 636 of file gf128mul.h.

#define tab8k (  )     ((gf_t8k)x)

Definition at line 712 of file gf128mul.h.

#define TABLES_8K

Definition at line 52 of file gf128mul.h.

#define VERSION_1

Definition at line 155 of file gf128mul.h.

#define xor_256 ( i,
a,
t,
 ) 
Value:
mul_x4(r); xor_block_aligned(r, tab256(t)[a[i] & 15]);  \
    mul_x4(r); xor_block_aligned(r, tab256(t)[a[i] >> 4])

Definition at line 880 of file gf128mul.h.

#define xor_4k ( i,
a,
t,
 )     mul_x8(r); xor_block_aligned(r, tab4k(t)[a[i]])

Definition at line 799 of file gf128mul.h.

#define xor_64k ( i,
a,
t,
 )     xor_block_aligned(r, tab64k(t)[i][a[i]])

Definition at line 637 of file gf128mul.h.

#define xor_8k ( i,
a,
t,
 ) 
Value:
xor_block_aligned(r, tab8k(t)[i + i][a[i] & 15]); \
    xor_block_aligned(r, tab8k(t)[i + i + 1][a[i] >> 4])

Definition at line 713 of file gf128mul.h.


Typedef Documentation

typedef uint_32t(* gf_t256)[GF_BYTE_LEN >> 2]

Definition at line 878 of file gf128mul.h.

typedef uint_32t(* gf_t4k)[GF_BYTE_LEN >> 2]

Definition at line 797 of file gf128mul.h.

typedef uint_32t(* gf_t64k)[256][GF_BYTE_LEN >> 2]

Definition at line 635 of file gf128mul.h.

typedef uint_32t(* gf_t8k)[16][GF_BYTE_LEN >> 2]

Definition at line 711 of file gf128mul.h.


Function Documentation

void gf_mul ( void *  a,
const void *  b 
)
void init_256_table ( unsigned char  g[],
void *  t 
)
void init_4k_table ( unsigned char  g[],
void *  t 
)
void init_64k_table ( unsigned char  g[],
void *  t 
)
void init_8k_table ( unsigned char  g[],
void *  t 
)

Variable Documentation

const unsigned short gf_tab[256]
Generated on Sun Nov 21 13:21:00 2010 for DTN Reference Implementation by  doxygen 1.6.3