From: couturier Date: Mon, 20 Jun 2022 12:28:51 +0000 (+0200) Subject: new X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/Cipher_code.git/commitdiff_plain/c99f2da0860fd162f7a1a413f4ac3ce0ebf7113f?ds=sidebyside;hp=--cc new --- c99f2da0860fd162f7a1a413f4ac3ce0ebf7113f diff --git a/Grain-128AEAD-sw-ref/Makefile b/Grain-128AEAD-sw-ref/Makefile new file mode 100644 index 0000000..eae07f0 --- /dev/null +++ b/Grain-128AEAD-sw-ref/Makefile @@ -0,0 +1,30 @@ + +CC = gcc +#CFLAGS = -std=c99 -Wall -Wextra -Wshadow -O3 #-fsanitize=address,undefined -O2 + +uname_m := $(shell uname -m) +ifeq ($(uname_m),armv7l) +CFLAGS=-O3 -march=armv7-a -mtune=cortex-a8 -mfpu=neon -ftree-vectorize -lrt `pkg-config --cflags --libs glib-2.0` +else +ifeq ($(uname_m),armv6l) +CFLAGS=-O3 -march=armv6 -mfpu=vfp -mfloat-abi=hard -lrt `pkg-config --cflags --libs glib-2.0` +else +CFLAGS=-O3 `pkg-config --cflags --libs glib-2.0` +endif +endif + + + + +all: grain128aead + +init: CFLAGS += -DINIT +init: grain128aead + +pre: CFLAGS += -DPRE +pre: grain128aead + +grain128a: grain128a.c + +clean: + rm -f grain128aead diff --git a/Grain-128AEAD-sw-ref/grain128aead.c b/Grain-128AEAD-sw-ref/grain128aead.c new file mode 100644 index 0000000..9a0734b --- /dev/null +++ b/Grain-128AEAD-sw-ref/grain128aead.c @@ -0,0 +1,360 @@ +#include +#include +#include + +#include "grain128aead.h" +#include +#include + + + + + + + +/* + * Define "PRE" to print the pre-output instead of keystream. + * Define "INIT" to also print the bits during the initialization part. + * Do this either here or during compilation with -D flag. + */ + +uint8_t grain_round; + + +double TimeStart() +{ + struct timeval tstart; + gettimeofday(&tstart,0); + return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) ); +} + +double TimeStop(double t) +{ + struct timeval tend; + + gettimeofday(&tend,0); + t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t; + return (t); +} + + +void init_grain(grain_state *grain, uint8_t *key, uint8_t *iv) +{ + // expand the packed bytes and place one bit per array cell (like a flip flop in HW) + for (int i = 0; i < 12; i++) { + for (int j = 0; j < 8; j++) { + grain->lfsr[8 * i + j] = (iv[i] & (1 << (7-j))) >> (7-j); + + } + } + + for (int i = 96; i < 127; i++) { + grain->lfsr[i] = 1; + } + + grain->lfsr[127] = 0; + + for (int i = 0; i < 16; i++) { + for (int j = 0; j < 8; j++) { + grain->nfsr[8 * i + j] = (key[i] & (1 << (7-j))) >> (7-j); + } + } + + for (int i = 0; i < 64; i++) { + grain->auth_acc[i] = 0; + grain->auth_sr[i] = 0; + } +} + +void init_data(grain_data *data, uint8_t *msg, uint32_t msg_len) +{ + // allocate enough space for message, including the padding byte, 0x80 + data->message = (uint8_t *) calloc(msg_len+8,1);//8 * STREAM_BYTES + 8, 1); + for (uint32_t i = 0; i < msg_len; i++) { + data->message[i] = msg[i]; + } + + // always pad data with the byte 0x80 + data->message[msg_len] = 1; +} + +uint8_t next_lfsr_fb(grain_state *grain) +{ + /* f(x) = 1 + x^32 + x^47 + x^58 + x^90 + x^121 + x^128 */ + return grain->lfsr[96] ^ grain->lfsr[81] ^ grain->lfsr[70] ^ grain->lfsr[38] ^ grain->lfsr[7] ^ grain->lfsr[0]; +} + +uint8_t next_nfsr_fb(grain_state *grain) +{ + return grain->nfsr[96] ^ grain->nfsr[91] ^ grain->nfsr[56] ^ grain->nfsr[26] ^ grain->nfsr[0] ^ (grain->nfsr[84] & grain->nfsr[68]) ^ + (grain->nfsr[67] & grain->nfsr[3]) ^ (grain->nfsr[65] & grain->nfsr[61]) ^ (grain->nfsr[59] & grain->nfsr[27]) ^ + (grain->nfsr[48] & grain->nfsr[40]) ^ (grain->nfsr[18] & grain->nfsr[17]) ^ (grain->nfsr[13] & grain->nfsr[11]) ^ + (grain->nfsr[82] & grain->nfsr[78] & grain->nfsr[70]) ^ (grain->nfsr[25] & grain->nfsr[24] & grain->nfsr[22]) ^ + (grain->nfsr[95] & grain->nfsr[93] & grain->nfsr[92] & grain->nfsr[88]); +} + +uint8_t next_h(grain_state *grain) +{ + // h(x) = x0x1 + x2x3 + x4x5 + x6x7 + x0x4x8 + #define x0 grain->nfsr[12] // bi+12 + #define x1 grain->lfsr[8] // si+8 + #define x2 grain->lfsr[13] // si+13 + #define x3 grain->lfsr[20] // si+20 + #define x4 grain->nfsr[95] // bi+95 + #define x5 grain->lfsr[42] // si+42 + #define x6 grain->lfsr[60] // si+60 + #define x7 grain->lfsr[79] // si+79 + #define x8 grain->lfsr[94] // si+94 + + uint8_t h_out = (x0 & x1) ^ (x2 & x3) ^ (x4 & x5) ^ (x6 & x7) ^ (x0 & x4 & x8); + return h_out; +} + +uint8_t shift(uint8_t fsr[128], uint8_t fb) +{ + uint8_t out = fsr[0]; + for (int i = 0; i < 127; i++) { + fsr[i] = fsr[i+1]; + } + fsr[127] = fb; + + return out; +} + +void auth_shift(uint8_t sr[64], uint8_t fb) +{ + for (int i = 0; i < 63; i++) { + sr[i] = sr[i+1]; + } + sr[63] = fb; +} + +void accumulate(grain_state *grain) +{ + for (int i = 0; i < 64; i++) { + grain->auth_acc[i] ^= grain->auth_sr[i]; + } +} + +uint8_t next_z(grain_state *grain, uint8_t keybit) +{ + uint8_t lfsr_fb = next_lfsr_fb(grain); + uint8_t nfsr_fb = next_nfsr_fb(grain); + uint8_t h_out = next_h(grain); + + /* y = h + s_{i+93} + sum(b_{i+j}), j \in A */ + uint8_t A[] = {2, 15, 36, 45, 64, 73, 89}; + + uint8_t nfsr_tmp = 0; + for (int i = 0; i < 7; i++) { + nfsr_tmp ^= grain->nfsr[A[i]]; + } + + uint8_t y = h_out ^ grain->lfsr[93] ^ nfsr_tmp; + + uint8_t lfsr_out; + + /* feedback y if we are in the initialization instance */ + if (grain_round == INIT) { + lfsr_out = shift(grain->lfsr, lfsr_fb ^ y); + shift(grain->nfsr, nfsr_fb ^ lfsr_out ^ y); + } else if (grain_round == FP1) { + lfsr_out = shift(grain->lfsr, lfsr_fb ^ keybit); + shift(grain->nfsr, nfsr_fb ^ lfsr_out); + } else if (grain_round == NORMAL) { + lfsr_out = shift(grain->lfsr, lfsr_fb); + shift(grain->nfsr, nfsr_fb ^ lfsr_out); + } + + return y; +} + +void print_state(grain_state *grain) +{ + printf("LFSR: "); + for (int i = 0; i < 128; i++) { + printf("%d", grain->lfsr[i]); + } + printf("\nNFSR: "); + for (int i = 0; i < 128; i++) { + printf("%d", grain->nfsr[i]); + } + printf("\n"); +} + +void print_stream(uint8_t *stream, uint8_t byte_size) +{ + for (int i = 0; i < byte_size; i++) { + uint8_t yi = 0; + for (int j = 0; j < 8; j++) { + yi = (yi << 1) ^ stream[i * 8 + j]; + } + printf("%02x", yi); + } + printf("\n"); +} + +void generate_keystream(grain_state *grain, grain_data *data, uint8_t *key) +{ + grain_round = FP1; + + uint8_t key_idx = 0; + /* inititalize the accumulator and shift reg. using the first 64 bits */ + for (int i = 0; i < 8; i++) { + for (int j = 0; j < 8; j++) { + uint8_t fp1_fb = (key[key_idx] & (1 << (7-j))) >> (7-j); + grain->auth_acc[8 * i + j] = next_z(grain, fp1_fb); + } + key_idx++; + } + + for (int i = 0; i < 8; i++) { + for (int j = 0; j < 8; j++) { + uint8_t fp1_fb = (key[key_idx] & (1 << (7-j))) >> (7-j); + grain->auth_sr[8 * i + j] = next_z(grain, fp1_fb); + } + key_idx++; + } + + grain_round = NORMAL; + + /* printf("accum init:\t"); + print_stream(grain->auth_acc, 8); + + printf("register init:\t"); + print_stream(grain->auth_sr, 8); + */ + uint8_t ks[STREAM_BYTES * 8]; // keystream array + uint16_t ks_cnt = 0; + uint8_t ms[STREAM_BYTES * 8]; // macstream array + uint16_t ms_cnt = 0; + uint8_t pre[2 * STREAM_BYTES * 8]; // pre-output + uint16_t pre_cnt = 0; + + /* generate keystream */ + for (int i = 0; i < STREAM_BYTES; i++) { + /* every second bit is used for keystream, the others for MAC */ + for (int j = 0; j < 16; j++) { + uint8_t z_next = next_z(grain, 0); + if (j % 2 == 0) { + ks[ks_cnt] = z_next; + ks_cnt++; + } else { + ms[ms_cnt] = z_next; + if (data->message[ms_cnt] == 1) { + accumulate(grain); + } + auth_shift(grain->auth_sr, z_next); + ms_cnt++; + } + pre[pre_cnt++] = z_next; // pre-output includes all bits + } + } + + /* printf("pre-output:\t"); + print_stream(pre, 2 * STREAM_BYTES); + + printf("keystream:\t"); + print_stream(ks, STREAM_BYTES); + + printf("macstream:\t"); + print_stream(ms, STREAM_BYTES); + + printf("tag:\t\t"); + print_stream(grain->auth_acc, 8); + */ +} + + +int main(int argc, char** argv) +{ + grain_state grain; + grain_data data; + + //uint8_t key[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0}; + //uint8_t iv[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x12, 0x34, 0x56, 0x78}; + + + uint8_t key[] = {0x81, 0x27, 0x73, 0x35, 0x11, 0xe9, 0x4c, 0x32, 0x9f, 0x77, 0x1f, 0xe8, 0x31, 0xec, 0x95, 0x55}; + uint8_t iv[] = {0xcc, 0xb5, 0x2f, 0xe4, 0x3e, 0x68, 0xc4, 0x5e, 0x78, 0xb1, 0x96, 0xb2}; + + //uint8_t key[16] = { 0 }; + //uint8_t iv[12] = { 0 }; + //iv[0] = 0x80; + + //uint8_t msg[0]; + //uint8_t msg[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + //uint8_t msg[8] = {1, 0, 0, 0, 0, 0, 0, 0}; + //uint8_t msg[8] = {0, 0, 0, 0, 0, 0, 0, 1}; + + int size_buf=1; + int nb_test=1; + + for(int i=1; i