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);
122 strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
123 nessie_print_item(str, xor_block, 64);
126 void scal_nessie_stream_run(const scdesc_t *desc, uint16_t keysize_b, uint16_t ivsize_b){
127 uint8_t name_length = strlen_P((PGM_VOID_P)pgm_read_word(&(desc->name)));
128 char name[name_length+1];
129 memcpy_P(name, (PGM_VOID_P)pgm_read_word(&(desc->name)), name_length+1);
131 uint8_t key[(keysize_b+7)/8];
132 uint8_t iv[(ivsize_b+7)/8];
135 nessie_print_header(name, keysize_b, 0, 0, 0, ivsize_b?ivsize_b:((uint16_t)-1));
137 memset(iv, 0, (ivsize_b+7)/8);
138 memset(key, 0, (keysize_b+7)/8);
140 nessie_print_setheader(1);
141 for(v=0;v<keysize_b; ++v){
142 nessie_print_set_vector(1,v);
143 key[v/8] |= 0x80>>(v&7);
144 nessie_print_item("key", key, (keysize_b+7)/8);
146 nessie_print_item("IV", iv, (ivsize_b+7)/8);
148 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
151 scal_cipher_free(&ctx);
154 nessie_print_setheader(2);
156 nessie_print_set_vector(2,v);
157 memset(key, v&0xff, (keysize_b+7)/8);
158 nessie_print_item("key", key, (keysize_b+7)/8);
160 nessie_print_item("IV", iv, (ivsize_b+7)/8);
162 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
164 scal_cipher_free(&ctx);
167 nessie_print_setheader(3);
170 nessie_print_set_vector(3,v);
171 for(i=0; i<((keysize_b+7)/8); ++i){
174 nessie_print_item("key", key, (keysize_b+7)/8);
176 nessie_print_item("IV", iv, (ivsize_b+7)/8);
178 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
180 scal_cipher_free(&ctx);
183 nessie_print_setheader(4);
186 nessie_print_set_vector(4,v);
187 for(i=0; i<((keysize_b+7)/8); ++i){
188 key[i]=(i*0x53+v*5)&0xff;
190 nessie_print_item("key", key, (keysize_b+7)/8);
192 nessie_print_item("IV", iv, (ivsize_b+7)/8);
194 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
196 scal_cipher_free(&ctx);
198 if(ivsize_b==0){ /* exit if there is no IV */
199 nessie_print_footer();
203 nessie_print_setheader(5);
204 memset(key, 0, (keysize_b+7)/8);
205 for(v=0;v<ivsize_b; ++v){
206 nessie_print_set_vector(5,v);
207 iv[v/8] |= 0x80>>(v&7);
208 nessie_print_item("key", key, (keysize_b+7)/8);
209 nessie_print_item("IV", iv, (ivsize_b+7)/8);
210 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
212 scal_cipher_free(&ctx);
216 nessie_print_setheader(6);
219 nessie_print_set_vector(6,v);
220 for(i=0; i<((keysize_b+7)/8); ++i){
221 key[i]=(i*0x53+v*5)&0xff;
223 for(i=0; i<((ivsize_b+7)/8); ++i){
224 iv[i]=(i*0x67+v*9+13)&0xff;
226 nessie_print_item("key", key, (keysize_b+7)/8);
227 nessie_print_item("IV", iv, (ivsize_b+7)/8);
228 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
230 scal_cipher_free(&ctx);
233 nessie_print_setheader(7);
238 nessie_print_set_vector(7,v*3+u);
239 for(i=0; i<((keysize_b+7)/8); ++i){
240 key[i]=pgm_read_byte(list_of_keys+20*v+(i%20));
242 for(i=0; i<((ivsize_b+7)/8); ++i){
243 key[i]=pgm_read_byte(list_of_keys+4*u+(i%4));
246 nessie_print_item("key", key, (keysize_b+7)/8);
247 nessie_print_item("IV", iv, (ivsize_b+7)/8);
248 scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
250 scal_cipher_free(&ctx);
252 nessie_print_footer();
255 void scal_nessie_run(const scdesc_t* desc){
256 uint16_t keysizes_count, ivsizes_count,i,j;
257 uint16_t *keysizes=NULL, *ivsizes=NULL;
258 keysizes_count = get_keysizes((PGM_VOID_P)pgm_read_word(&(desc->valid_keysize_desc)), &keysizes);
259 ivsizes_count = get_keysizes((PGM_VOID_P)pgm_read_word(&(desc->valid_ivsize_desc)), &ivsizes);
260 for(i=0; i<keysizes_count; ++i){
261 for(j=0; j<ivsizes_count; ++j){
262 scal_nessie_stream_run(desc, keysizes[i], ivsizes[j]);