587 lines
13 KiB
C
587 lines
13 KiB
C
/* cmacvs.c */
|
|
/*
|
|
This file is part of the ARM-Crypto-Lib.
|
|
Copyright (C) 2006-2010 Daniel Otte (daniel.otte@rub.de)
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
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 cmacvs.c
|
|
* \author Daniel Otte
|
|
* \date 2010-02-02
|
|
* \license GPLv3 or later
|
|
*
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include "blockcipher_descriptor.h"
|
|
#include "bcal-basic.h"
|
|
#include "bcal-cmac.h"
|
|
#include "cmacvs.h"
|
|
#include "string-extras.h"
|
|
#include "cli.h"
|
|
|
|
|
|
#ifdef DEBUG
|
|
# undef DEBUG
|
|
#endif
|
|
|
|
#define DEBUG 0
|
|
|
|
#if DEBUG
|
|
# include "config.h"
|
|
# include <util/delay.h>
|
|
#endif
|
|
|
|
bcdesc_t* cmacvs_algo=NULL;
|
|
bcdesc_t** cmacvs_algolist=NULL;
|
|
|
|
void cmacvs_listalgos(void){
|
|
char option = 'a';
|
|
|
|
bcdesc_t* t;
|
|
uint8_t i=0;
|
|
cli_putstr("\r\nthe following algorithms are available:\r\n");
|
|
while(option<='z' && (t=(bcdesc_t*)(cmacvs_algolist[i]))){
|
|
cli_putc('\t');
|
|
cli_putc((t==cmacvs_algo)?'*':' ');
|
|
cli_putc(option++);
|
|
cli_putstr(":\t");
|
|
cli_putstr(t->name);
|
|
cli_putstr("\r\n");
|
|
i++;
|
|
}
|
|
}
|
|
|
|
void cmacvs_setalgo(char* param){
|
|
param = strstrip(param);
|
|
if(param[1]=='\0'){ /* single letter specified */
|
|
uint8_t i,option = param[0]-'a';
|
|
|
|
if(!cmacvs_algolist){
|
|
cli_putstr("\r\nERROR: cmacvs_algolist not set!");
|
|
return;
|
|
}
|
|
for(i=0; i<=option; ++i){
|
|
if((cmacvs_algolist[i])==NULL){
|
|
cli_putstr("\r\nERROR: invalid selection!");
|
|
return;
|
|
}
|
|
}
|
|
cmacvs_algo=(bcdesc_t*)(cmacvs_algolist[option]);
|
|
} else { /* name specifyed */
|
|
bcdesc_t* t=NULL;
|
|
uint8_t i=0;
|
|
while((t=(bcdesc_t*)(cmacvs_algolist[i])) &&
|
|
strcasecmp(param, t->name))
|
|
++i;
|
|
if(t){
|
|
cmacvs_algo=t;
|
|
}else{
|
|
cli_putstr("\r\nERROR: could not find \"");
|
|
cli_putstr(param);
|
|
cli_putstr("\"!");
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
uint16_t buffer_idx;
|
|
uint16_t buffersize_B;
|
|
uint32_t blocks;
|
|
bcal_cmac_ctx_t ctx;
|
|
uint8_t* buffer;
|
|
uint8_t in_byte;
|
|
} cmacvs_ctx_t;
|
|
|
|
static cmacvs_ctx_t cmacvs_ctx;
|
|
|
|
uint8_t buffer_add(char c){
|
|
uint8_t v,t;
|
|
if(cmacvs_ctx.buffer_idx==cmacvs_ctx.buffersize_B){
|
|
bcal_cmac_nextBlock(&(cmacvs_ctx.ctx), cmacvs_ctx.buffer);
|
|
++cmacvs_ctx.blocks;
|
|
cmacvs_ctx.buffer_idx=0;
|
|
cmacvs_ctx.in_byte=0;
|
|
cli_putc('.');
|
|
memset(cmacvs_ctx.buffer, 0, cmacvs_ctx.buffersize_B);
|
|
}
|
|
if(c>='0' && c<='9'){
|
|
v=c-'0';
|
|
}else{
|
|
c &= (uint8_t)~('a' ^ 'A');
|
|
if(c>='A' && c<='F'){
|
|
v=c-'A'+10;
|
|
}else{
|
|
return 1;
|
|
}
|
|
}
|
|
t=cmacvs_ctx.buffer[cmacvs_ctx.buffer_idx];
|
|
if(cmacvs_ctx.in_byte){
|
|
t |= v;
|
|
cmacvs_ctx.buffer[cmacvs_ctx.buffer_idx]=t;
|
|
cmacvs_ctx.buffer_idx++;
|
|
cmacvs_ctx.in_byte = 0;
|
|
}else{
|
|
t |= v<<4;
|
|
cmacvs_ctx.buffer[cmacvs_ctx.buffer_idx]=t;
|
|
cmacvs_ctx.in_byte = 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t getValue(char* key){
|
|
uint32_t val=0;
|
|
char instr[21];
|
|
char* str2;
|
|
for(;;){
|
|
memset(instr, 0, 21);
|
|
cli_getsn(instr, 20);
|
|
str2 = strstrip(instr);
|
|
if(!strncasecmp(str2, key, strlen(key))){
|
|
while(*str2 && *str2!='=')
|
|
str2++;
|
|
if(*str2=='='){
|
|
do{
|
|
str2++;
|
|
}while(*str2 && !isdigit((uint8_t)(*str2)));
|
|
val=(uint32_t)strtoul(str2, NULL, 10);
|
|
return val;
|
|
}
|
|
} else {
|
|
if(!strncasecmp(str2, "EXIT", 4)){
|
|
cli_putstr("\r\n got exit ...");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
uint8_t getKey(void* key_buffer, uint8_t klen_B){
|
|
char c;
|
|
uint8_t v,i=0;
|
|
memset(key_buffer, 0x00, klen_B);
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while((c|('a'^'A'))!='k');
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while((c|('a'^'A'))!='e');
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while((c|('a'^'A'))!='y');
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while(c!='=');
|
|
klen_B *= 2;
|
|
while(klen_B){
|
|
v = 0x10;
|
|
c = cli_getc_cecho();
|
|
if(c>='0' && c<='9'){
|
|
v = c-'0';
|
|
}else{
|
|
c |= 'A'^'a';
|
|
if(c>='a' && c<='f'){
|
|
v= c-'a'+10;
|
|
}
|
|
}
|
|
if(v<0x10){
|
|
if((i&1)==0){
|
|
v<<=4;
|
|
}
|
|
((uint8_t*)key_buffer)[i/2] |= v;
|
|
++i;
|
|
--klen_B;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8_t getMac(void* mac_buffer, uint8_t mlen_B){
|
|
char c;
|
|
uint8_t v,i=0;
|
|
memset(mac_buffer, 0x00, mlen_B);
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while((c|('a'^'A'))!='m');
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while((c|('a'^'A'))!='a');
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while((c|('a'^'A'))!='c');
|
|
do{
|
|
c = cli_getc_cecho();
|
|
}while(c!='=');
|
|
mlen_B *= 2;
|
|
while(mlen_B){
|
|
v = 0x10;
|
|
c = cli_getc_cecho();
|
|
if(c>='0' && c<='9'){
|
|
v = c-'0';
|
|
}else{
|
|
c |= 'A'^'a';
|
|
if(c>='a' && c<='f'){
|
|
v= c-'a'+10;
|
|
}
|
|
}
|
|
if(v<0x10){
|
|
if((i&1)==0){
|
|
v<<=4;
|
|
}
|
|
((uint8_t*)mac_buffer)[i/2] |= v;
|
|
++i;
|
|
--mlen_B;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void cmacvs_test1(void){ /* Gen tests */
|
|
int32_t klen, mlen, tlen;
|
|
int32_t expect_input=0;
|
|
|
|
if(!cmacvs_algo){
|
|
cli_putstr("\r\nERROR: select algorithm first!");
|
|
return;
|
|
}
|
|
char c;
|
|
cmacvs_ctx.buffersize_B=(cmacvs_algo->blocksize_b)/8;
|
|
uint8_t tag[cmacvs_ctx.buffersize_B];
|
|
uint8_t buffer[cmacvs_ctx.buffersize_B+5];
|
|
cmacvs_ctx.buffer = buffer;
|
|
cli_putstr("\r\nbuffer_size = 0x");
|
|
cli_hexdump_rev(&(cmacvs_ctx.buffersize_B), 2);
|
|
cli_putstr(" bytes");
|
|
for(;;){
|
|
cmacvs_ctx.blocks = 0;
|
|
memset(buffer, 0, cmacvs_ctx.buffersize_B);
|
|
klen = getValue("Klen");
|
|
if(klen<0){
|
|
return;
|
|
}
|
|
mlen = getValue("Mlen");
|
|
if(mlen<0){
|
|
return;
|
|
}
|
|
tlen = getValue("Tlen");
|
|
if(tlen<0){
|
|
return;
|
|
}
|
|
uint8_t key_buffer[klen];
|
|
#if DEBUG
|
|
cli_putstr("\r\nKLen == ");
|
|
cli_hexdump_rev(&klen, 4);
|
|
cli_putstr("\r\nMLen == ");
|
|
cli_hexdump_rev(&mlen, 4);
|
|
cli_putstr("\r\nTLen == ");
|
|
cli_hexdump_rev(&tlen, 4);
|
|
#endif
|
|
getKey(key_buffer, klen);
|
|
if(mlen==0){
|
|
expect_input=2;
|
|
}else{
|
|
expect_input=mlen*2;
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\nexpected_input == ");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
if(expect_input==0)
|
|
cli_putstr("\r\nexpected_input == 0 !!!");
|
|
#endif
|
|
uint8_t ret;
|
|
#if DEBUG
|
|
cli_putstr("\r\n CMAC init");
|
|
cli_putstr("\r\n (2) expected_input == ");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
#endif
|
|
ret = bcal_cmac_init(cmacvs_algo, key_buffer, klen*8, &(cmacvs_ctx.ctx));
|
|
if(ret){
|
|
cli_putstr("\r\n bcal_cmac_init returned with: ");
|
|
cli_hexdump(&ret, 1);
|
|
return;
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\n (3) expected_input == ");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
cli_putstr("\r\n");
|
|
#endif
|
|
while((c=cli_getc_cecho())!='M' && c!='m'){
|
|
if(!isspace((uint8_t)c)){
|
|
cli_putstr("\r\nERROR: wrong input (1) [0x");
|
|
cli_hexdump(&c, 1);
|
|
cli_putstr("]!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
}
|
|
if((c=cli_getc_cecho())!='s' && c!='S'){
|
|
cli_putstr("\r\nERROR: wrong input (2)!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
if((c=cli_getc_cecho())!='g' && c!='G'){
|
|
cli_putstr("\r\nERROR: wrong input (3)!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
while((c=cli_getc_cecho())!='='){
|
|
if(!isspace((uint8_t)c)){
|
|
cli_putstr("\r\nERROR: wrong input (4)!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\nparsing started");
|
|
#endif
|
|
cmacvs_ctx.buffer_idx = 0;
|
|
cmacvs_ctx.in_byte = 0;
|
|
cmacvs_ctx.blocks = 0;
|
|
while(expect_input>0){
|
|
c=cli_getc_cecho();
|
|
#if DEBUG
|
|
cli_putstr("\r\n\t(");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
cli_putstr(") ");
|
|
_delay_ms(500);
|
|
#endif
|
|
if(buffer_add(c)==0){
|
|
--expect_input;
|
|
}else{
|
|
if(!isblank((uint16_t)c)){
|
|
cli_putstr("\r\nERROR: wrong input (5) (");
|
|
cli_putc(c);
|
|
cli_putstr(")!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\nBuffer-A:");
|
|
cli_hexdump_block(buffer, cmacvs_ctx.buffersize_B, 5, 8);
|
|
|
|
cli_putstr("\r\n starting finalisation");
|
|
cli_putstr("\r\n\tblocks == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.blocks),4);
|
|
cli_putstr("\r\n\tbuffer_idx == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.buffer_idx),2);
|
|
cli_putstr("\r\n\tin_byte == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.in_byte),1);
|
|
// _delay_ms(500);
|
|
|
|
cli_putstr("\r\n starting last block");
|
|
cli_putstr("\r\n\tlength == ");
|
|
cli_hexdump_rev(&mlen,4);
|
|
cli_putstr("\r\n\tbuffersize_B == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.buffersize_B),2);
|
|
uint16_t temp=(mlen-cmacvs_ctx.blocks*cmacvs_ctx.buffersize_B)*8;
|
|
cli_putstr("\r\n\t (temp) == ");
|
|
cli_hexdump_rev(&temp,2);
|
|
// _delay_ms(500);
|
|
#endif
|
|
uint16_t temp=(mlen-cmacvs_ctx.blocks*cmacvs_ctx.buffersize_B)*8;
|
|
bcal_cmac_lastBlock( &(cmacvs_ctx.ctx), buffer, /* be aware of freaking compilers!!! */
|
|
// length-(cmacvs_ctx.blocks)*((cmacvs_ctx.buffersize_B)*8));
|
|
temp );
|
|
#if DEBUG
|
|
cli_putstr("\r\n starting ctx2cmac");
|
|
_delay_ms(500);
|
|
#endif
|
|
bcal_cmac_ctx2mac(tag, tlen*8, &(cmacvs_ctx.ctx));
|
|
#if DEBUG
|
|
cli_putstr("\r\n starting cmac free");
|
|
#endif
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
cli_putstr("\r\n Mac = ");
|
|
cli_hexdump(tag, tlen);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
void cmacvs_test2(void){ /* Ver tests */
|
|
int32_t klen, mlen, tlen;
|
|
int32_t expect_input=0;
|
|
|
|
if(!cmacvs_algo){
|
|
cli_putstr("\r\nERROR: select algorithm first!");
|
|
return;
|
|
}
|
|
char c;
|
|
cmacvs_ctx.buffersize_B=(cmacvs_algo->blocksize_b)/8;
|
|
uint8_t tag[cmacvs_ctx.buffersize_B];
|
|
uint8_t tag_ref[cmacvs_ctx.buffersize_B];
|
|
uint8_t buffer[cmacvs_ctx.buffersize_B+5];
|
|
cmacvs_ctx.buffer = buffer;
|
|
cli_putstr("\r\nbuffer_size = 0x");
|
|
cli_hexdump_rev(&(cmacvs_ctx.buffersize_B), 2);
|
|
cli_putstr(" bytes");
|
|
for(;;){
|
|
cmacvs_ctx.blocks = 0;
|
|
memset(buffer, 0, cmacvs_ctx.buffersize_B);
|
|
klen = getValue("Klen");
|
|
if(klen<0){
|
|
return;
|
|
}
|
|
mlen = getValue("Mlen");
|
|
if(mlen<0){
|
|
return;
|
|
}
|
|
tlen = getValue("Tlen");
|
|
if(tlen<0){
|
|
return;
|
|
}
|
|
uint8_t key_buffer[klen];
|
|
#if DEBUG
|
|
cli_putstr("\r\nKLen == ");
|
|
cli_hexdump_rev(&klen, 4);
|
|
cli_putstr("\r\nMLen == ");
|
|
cli_hexdump_rev(&mlen, 4);
|
|
cli_putstr("\r\nTLen == ");
|
|
cli_hexdump_rev(&tlen, 4);
|
|
#endif
|
|
getKey(key_buffer, klen);
|
|
if(mlen==0){
|
|
expect_input=2;
|
|
}else{
|
|
expect_input=mlen*2;
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\nexpected_input == ");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
if(expect_input==0)
|
|
cli_putstr("\r\nexpected_input == 0 !!!");
|
|
#endif
|
|
uint8_t ret;
|
|
#if DEBUG
|
|
cli_putstr("\r\n CMAC init");
|
|
cli_putstr("\r\n (2) expected_input == ");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
#endif
|
|
ret = bcal_cmac_init(cmacvs_algo, key_buffer, klen*8, &(cmacvs_ctx.ctx));
|
|
if(ret){
|
|
cli_putstr("\r\n bcal_cmac_init returned with: ");
|
|
cli_hexdump(&ret, 1);
|
|
return;
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\n (3) expected_input == ");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
cli_putstr("\r\n");
|
|
#endif
|
|
while((c=cli_getc_cecho())!='M' && c!='m'){
|
|
if(!isspace((uint8_t)c)){
|
|
cli_putstr("\r\nERROR: wrong input (1) [0x");
|
|
cli_hexdump(&c, 1);
|
|
cli_putstr("]!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
}
|
|
if((c=cli_getc_cecho())!='s' && c!='S'){
|
|
cli_putstr("\r\nERROR: wrong input (2)!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
if((c=cli_getc_cecho())!='g' && c!='G'){
|
|
cli_putstr("\r\nERROR: wrong input (3)!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
while((c=cli_getc_cecho())!='='){
|
|
if(!isspace((uint8_t)c)){
|
|
cli_putstr("\r\nERROR: wrong input (4)!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\nparsing started");
|
|
#endif
|
|
cmacvs_ctx.buffer_idx = 0;
|
|
cmacvs_ctx.in_byte = 0;
|
|
cmacvs_ctx.blocks = 0;
|
|
while(expect_input>0){
|
|
c=cli_getc_cecho();
|
|
#if DEBUG
|
|
cli_putstr("\r\n\t(");
|
|
cli_hexdump_rev(&expect_input, 4);
|
|
cli_putstr(") ");
|
|
_delay_ms(500);
|
|
#endif
|
|
if(buffer_add(c)==0){
|
|
--expect_input;
|
|
}else{
|
|
if(!isblank((uint16_t)c)){
|
|
cli_putstr("\r\nERROR: wrong input (5) (");
|
|
cli_putc(c);
|
|
cli_putstr(")!\r\n");
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#if DEBUG
|
|
cli_putstr("\r\nBuffer-A:");
|
|
cli_hexdump_block(buffer, cmacvs_ctx.buffersize_B, 5, 8);
|
|
|
|
cli_putstr("\r\n starting finalisation");
|
|
cli_putstr("\r\n\tblocks == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.blocks),4);
|
|
cli_putstr("\r\n\tbuffer_idx == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.buffer_idx),2);
|
|
cli_putstr("\r\n\tin_byte == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.in_byte),1);
|
|
// _delay_ms(500);
|
|
|
|
cli_putstr("\r\n starting last block");
|
|
cli_putstr("\r\n\tlength == ");
|
|
cli_hexdump_rev(&mlen,4);
|
|
cli_putstr("\r\n\tbuffersize_B == ");
|
|
cli_hexdump_rev(&(cmacvs_ctx.buffersize_B),2);
|
|
uint16_t temp=(mlen-cmacvs_ctx.blocks*cmacvs_ctx.buffersize_B)*8;
|
|
cli_putstr("\r\n\t (temp) == ");
|
|
cli_hexdump_rev(&temp,2);
|
|
// _delay_ms(500);
|
|
#endif
|
|
uint16_t temp=(mlen-cmacvs_ctx.blocks*cmacvs_ctx.buffersize_B)*8;
|
|
bcal_cmac_lastBlock( &(cmacvs_ctx.ctx), buffer, /* be aware of freaking compilers!!! */
|
|
// length-(cmacvs_ctx.blocks)*((cmacvs_ctx.buffersize_B)*8));
|
|
temp );
|
|
#if DEBUG
|
|
cli_putstr("\r\n starting ctx2cmac");
|
|
_delay_ms(500);
|
|
#endif
|
|
bcal_cmac_ctx2mac(tag, tlen*8, &(cmacvs_ctx.ctx));
|
|
#if DEBUG
|
|
cli_putstr("\r\n starting cmac free");
|
|
#endif
|
|
bcal_cmac_free(&(cmacvs_ctx.ctx));
|
|
cli_putstr("\r\n Mac = ");
|
|
cli_hexdump(tag, tlen);
|
|
getMac(tag_ref, tlen);
|
|
if(memcmp(tag, tag_ref, tlen)){
|
|
cli_putstr("\r\n Result = F");
|
|
}else{
|
|
cli_putstr("\r\n Result = P");
|
|
}
|
|
}
|
|
}
|