3 This file is part of the AVR-Crypto-Lib.
4 Copyright (C) 2006-2011 Daniel Otte (daniel.otte@rub.de)
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "streamcipher_descriptor.h"
23 #include "scal-basic.h"
24 #include "nessie_common.h"
26 #include <avr/pgmspace.h>
28 static const uint8_t normal_hooks[] PROGMEM = {
29 0, 192/64, 256/64, 448/64
32 static const uint16_t long_hooks[] PROGMEM = {
33 0, 65472/64, 65536/64, 131008/64
36 static const char stream0_n[] PROGMEM = "stream[0..63]";
37 static const char stream1_n[] PROGMEM = "stream[192..255]";
38 static const char stream2_n[] PROGMEM = "stream[256..319]";
39 static const char stream3_n[] PROGMEM = "stream[448..511]";
40 static const char streamX_n[] PROGMEM = "stream[0..511]xored";
42 static const char* stream_n_str[] PROGMEM = {
50 static const char stream1_l[] PROGMEM = "stream[65472..65535]";
51 static const char stream2_l[] PROGMEM = "stream[65536..65599]";
52 static const char stream3_l[] PROGMEM = "stream[131008..131071]";
53 static const char streamX_l[] PROGMEM = "stream[0..131071]xored";
55 static const char* stream_l_str[] PROGMEM = {
63 static const uint8_t list_of_keys[][20] PROGMEM = {
64 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
65 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
66 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc,
67 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x00, 0x00, 0x00 },
68 { 0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba,
69 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0 }
72 static const uint8_t list_of_ivs[][4] PROGMEM = {
73 { 0x00, 0x00, 0x00, 0x00 },
74 { 0x01, 0x01, 0x01, 0x01 },
75 { 0x01, 0x35, 0x77, 0xaf }
79 void normal_block(scgen_ctx_t *ctx){
80 uint8_t xor_block[64];
82 PGM_VOID_P hook_ptr = normal_hooks;
83 PGM_VOID_P hook_str_ptr = stream_n_str;
87 memset(xor_block, 0, 64);
88 for(i=0; i<=448/64; ++i){
89 scal_cipher_gen_fillblock(block, 64, ctx);
90 memxor(xor_block, block, 64);
91 if(i==pgm_read_byte(hook_ptr)){
92 hook_ptr = (uint8_t*)hook_ptr + 1;
93 strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
94 hook_str_ptr = (uint8_t*)hook_str_ptr + 2;
95 nessie_print_item(str, block, 64);
98 strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
99 nessie_print_item(str, xor_block, 64);
103 void long_block(scgen_ctx_t *ctx){
104 uint8_t xor_block[64];
106 PGM_VOID_P hook_ptr = long_hooks;
107 PGM_VOID_P hook_str_ptr = stream_l_str;
111 memset(xor_block, 0, 64);
112 for(i=0; i<=131008/64; ++i){
113 scal_cipher_gen_fillblock(block, 64, ctx);
114 memxor(xor_block, block, 64);
115 if(i==pgm_read_word(hook_ptr)){
116 hook_ptr = (uint8_t*)hook_ptr + 2;
117 strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
118 hook_str_ptr = (uint8_t*)hook_str_ptr + 2;
119 nessie_print_item(str, block, 64);
125 strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
126 nessie_print_item(str, xor_block, 64);
129 void scal_nessie_stream_run(const scdesc_t *desc, uint16_t keysize_b, uint16_t ivsize_b){
130 uint8_t name_length = strlen_P((PGM_VOID_P)pgm_read_word(&(desc->name)));
131 char name[name_length+1];
132 memcpy_P(name, (PGM_VOID_P)pgm_read_word(&(desc->name)), name_length+1);
134 uint8_t key[(keysize_b+7)/8];
135 uint8_t iv[(ivsize_b+7)/8];
138 nessie_print_header(name, keysize_b, 0, 0, 0, ivsize_b?ivsize_b:((uint16_t)-1));
140 memset(iv, 0, (ivsize_b+7)/8);
141 memset(key, 0, (keysize_b+7)/8);
143 nessie_print_setheader(1);
144 for(v=0;v<keysize_b; ++v){
145 nessie_print_set_vector(1,v);
146 key[v/8] |= 0x80>>(v&7);
147 nessie_print_item("key", key, (keysize_b+7)/8);
149 nessie_print_item("IV", iv, (ivsize_b+7)/8);
151 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
154 scal_cipher_free(&ctx);
157 nessie_print_setheader(2);
159 nessie_print_set_vector(2,v);
160 memset(key, v&0xff, (keysize_b+7)/8);
161 nessie_print_item("key", key, (keysize_b+7)/8);
163 nessie_print_item("IV", iv, (ivsize_b+7)/8);
165 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
167 scal_cipher_free(&ctx);
170 nessie_print_setheader(3);
173 nessie_print_set_vector(3,v);
174 for(i=0; i<((keysize_b+7)/8); ++i){
177 nessie_print_item("key", key, (keysize_b+7)/8);
179 nessie_print_item("IV", iv, (ivsize_b+7)/8);
181 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
183 scal_cipher_free(&ctx);
186 nessie_print_setheader(4);
189 nessie_print_set_vector(4,v);
190 for(i=0; i<((keysize_b+7)/8); ++i){
191 key[i]=(i*0x53+v*5)&0xff;
193 nessie_print_item("key", key, (keysize_b+7)/8);
195 nessie_print_item("IV", iv, (ivsize_b+7)/8);
197 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
199 scal_cipher_free(&ctx);
201 if(ivsize_b==0){ /* exit if there is no IV */
202 nessie_print_footer();
206 nessie_print_setheader(5);
207 memset(key, 0, (keysize_b+7)/8);
208 for(v=0;v<ivsize_b; ++v){
209 nessie_print_set_vector(5,v);
210 iv[v/8] |= 0x80>>(v&7);
211 nessie_print_item("key", key, (keysize_b+7)/8);
212 nessie_print_item("IV", iv, (ivsize_b+7)/8);
213 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
215 scal_cipher_free(&ctx);
219 nessie_print_setheader(6);
222 nessie_print_set_vector(6,v);
223 for(i=0; i<((keysize_b+7)/8); ++i){
224 key[i]=(i*0x53+v*5)&0xff;
226 for(i=0; i<((ivsize_b+7)/8); ++i){
227 iv[i]=(i*0x67+v*9+13)&0xff;
229 nessie_print_item("key", key, (keysize_b+7)/8);
230 nessie_print_item("IV", iv, (ivsize_b+7)/8);
231 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
233 scal_cipher_free(&ctx);
236 nessie_print_setheader(7);
241 nessie_print_set_vector(7,v*3+u);
242 for(i=0; i<((keysize_b+7)/8); ++i){
243 key[i]=pgm_read_byte(list_of_keys+20*v+(i%20));
245 for(i=0; i<((ivsize_b+7)/8); ++i){
246 key[i]=pgm_read_byte(list_of_keys+4*u+(i%4));
249 nessie_print_item("key", key, (keysize_b+7)/8);
250 nessie_print_item("IV", iv, (ivsize_b+7)/8);
251 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
253 scal_cipher_free(&ctx);
255 nessie_print_footer();
258 void scal_nessie_run(const scdesc_t* desc){
259 uint16_t keysizes_count, ivsizes_count,i,j;
260 uint16_t *keysizes=NULL, *ivsizes=NULL;
261 keysizes_count = get_keysizes((PGM_VOID_P)pgm_read_word(&(desc->valid_keysize_desc)), &keysizes);
262 ivsizes_count = get_keysizes((PGM_VOID_P)pgm_read_word(&(desc->valid_ivsize_desc)), &ivsizes);
263 for(i=0; i<keysizes_count; ++i){
264 for(j=0; j<ivsizes_count; ++j){
265 scal_nessie_stream_run(desc, keysizes[i], ivsizes[j]);