X-Git-Url: https://git.cryptolib.org/?a=blobdiff_plain;f=test_src%2Fcmacvs.c;fp=test_src%2Fcmacvs.c;h=393d2808d9934974c8a9022f0196294fa11da2ee;hb=3f2f2071c47e2e424af71cc85697f3eb26c24277;hp=0000000000000000000000000000000000000000;hpb=33a28395461ecd0c1c7820f59e180f8f2ca9216f;p=arm-crypto-lib.git
diff --git a/test_src/cmacvs.c b/test_src/cmacvs.c
new file mode 100644
index 0000000..393d280
--- /dev/null
+++ b/test_src/cmacvs.c
@@ -0,0 +1,586 @@
+/* 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 .
+*/
+/**
+ * \file cmacvs.c
+ * \author Daniel Otte
+ * \date 2010-02-02
+ * \license GPLv3 or later
+ *
+ */
+
+#include
+#include
+#include
+#include
+#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
+#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(*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(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(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(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(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");
+ }
+ }
+}