bertos/sec/cipher/blowfish_test.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos 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 2 of the License, or
   9  * (at your option) any later version.
  10  *
  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.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2006 Develer S.r.l. (http://www.develer.com/)
  30  *
  31  * -->
  32  *
  33  * \brief Blowfish testsuite
  34  * \author Giovanni Bajo <rasky@develer.com>
  35  *
  36  */
  37
  38 #include "blowfish.h"
  39 #include <cpu/byteorder.h>
  40 #include <string.h>
  41
  42 /*
  43  *  Author     :  Randy L. Milbert
  44  *  E-mail     :  rmilbert@mit.edu
  45  *  Date       :  18 Jun 97
  46  *  Description:  Eric Young's test vectors for Blowfish.
  47  */
  48
  49 #define NUM_VARIABLE_KEY_TESTS  34
  50 #define NUM_SET_KEY_TESTS                       24
  51
  52 /* plaintext bytes -- left halves */
  53 static const uint32_t plaintext_l[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
  54    0x00000000l, 0xFFFFFFFFl, 0x10000000l, 0x11111111l, 0x11111111l,
  55    0x01234567l, 0x00000000l, 0x01234567l, 0x01A1D6D0l, 0x5CD54CA8l,
  56    0x0248D438l, 0x51454B58l, 0x42FD4430l, 0x059B5E08l, 0x0756D8E0l,
  57    0x762514B8l, 0x3BDD1190l, 0x26955F68l, 0x164D5E40l, 0x6B056E18l,
  58    0x004BD6EFl, 0x480D3900l, 0x437540C8l, 0x072D43A0l, 0x02FE5577l,
  59    0x1D9D5C50l, 0x30553228l, 0x01234567l, 0x01234567l, 0x01234567l,
  60    0xFFFFFFFFl, 0x00000000l, 0x00000000l, 0xFFFFFFFFl, 0xFEDCBA98l,
  61    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  62    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  63    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  64    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  65    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l };
  66
  67 /* plaintext bytes -- right halves */
  68 static const uint32_t plaintext_r[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
  69    0x00000000l, 0xFFFFFFFFl, 0x00000001l, 0x11111111l, 0x11111111l,
  70    0x89ABCDEFl, 0x00000000l, 0x89ABCDEFl, 0x39776742l, 0x3DEF57DAl,
  71    0x06F67172l, 0x2DDF440Al, 0x59577FA2l, 0x51CF143Al, 0x774761D2l,
  72    0x29BF486Al, 0x49372802l, 0x35AF609Al, 0x4F275232l, 0x759F5CCAl,
  73    0x09176062l, 0x6EE762F2l, 0x698F3CFAl, 0x77075292l, 0x8117F12Al,
  74    0x18F728C2l, 0x6D6F295Al, 0x89ABCDEFl, 0x89ABCDEFl, 0x89ABCDEFl,
  75    0xFFFFFFFFl, 0x00000000l, 0x00000000l, 0xFFFFFFFFl, 0x76543210l,
  76    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  77    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  78    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  79    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  80    0x76543210l, 0x76543210l, 0x76543210l };
  81
  82 /* key bytes for variable key tests */
  83 static const uint8_t variable_key[NUM_VARIABLE_KEY_TESTS][8] = {
  84    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  85    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
  86    { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  87    { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
  88    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  89    { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
  90    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  91    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
  92    { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
  93    { 0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E },
  94    { 0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86 },
  95    { 0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E },
  96    { 0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6 },
  97    { 0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE },
  98    { 0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6 },
  99    { 0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE },
 100    { 0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16 },
 101    { 0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F },
 102    { 0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46 },
 103    { 0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E },
 104    { 0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76 },
 105    { 0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07 },
 106    { 0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F },
 107    { 0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7 },
 108    { 0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF },
 109    { 0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6 },
 110    { 0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF },
 111    { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
 112    { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
 113    { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
 114    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 115    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
 116    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
 117    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }};
 118
 119 /* key bytes for set key tests */
 120 static const uint8_t set_key[24] = {
 121    0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 122    0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
 123    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
 124
 125 /* ciphertext bytes -- left halves */
 126 static const uint32_t ciphertext_l[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
 127    0x4EF99745l, 0x51866FD5l, 0x7D856F9Al, 0x2466DD87l, 0x61F9C380l,
 128    0x7D0CC630l, 0x4EF99745l, 0x0ACEAB0Fl, 0x59C68245l, 0xB1B8CC0Bl,
 129    0x1730E577l, 0xA25E7856l, 0x353882B1l, 0x48F4D088l, 0x432193B7l,
 130    0x13F04154l, 0x2EEDDA93l, 0xD887E039l, 0x5F99D04Fl, 0x4A057A3Bl,
 131    0x452031C1l, 0x7555AE39l, 0x53C55F9Cl, 0x7A8E7BFAl, 0xCF9C5D7Al,
 132    0xD1ABB290l, 0x55CB3774l, 0xFA34EC48l, 0xA7907951l, 0xC39E072Dl,
 133    0x014933E0l, 0xF21E9A77l, 0x24594688l, 0x6B5C5A9Cl, 0xF9AD597Cl,
 134    0xE91D21C1l, 0xE9C2B70Al, 0xBE1E6394l, 0xB39E4448l, 0x9457AA83l,
 135    0x8BB77032l, 0xE87A244El, 0x15750E7Al, 0x122BA70Bl, 0x3A833C9Al,
 136    0x9409DA87l, 0x884F8062l, 0x1F85031Cl, 0x79D9373Al, 0x93142887l,
 137    0x03429E83l, 0xA4299E27l, 0xAFD5AED1l, 0x10851C0El, 0xE6F51ED7l,
 138    0x64A6E14Al, 0x80C7D7D4l, 0x05044B62l };
 139
 140 /* ciphertext bytes -- right halves */
 141 static const uint32_t ciphertext_r[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
 142    0x6198DD78l, 0xB85ECB8Al, 0x613063F2l, 0x8B963C9Dl, 0x2281B096l,
 143    0xAFDA1EC7l, 0x6198DD78l, 0xC6A0A28Dl, 0xEB05282Bl, 0x250F09A0l,
 144    0x8BEA1DA4l, 0xCF2651EBl, 0x09CE8F1Al, 0x4C379918l, 0x8951FC98l,
 145    0xD69D1AE5l, 0xFFD39C79l, 0x3C2DA6E3l, 0x5B163969l, 0x24D3977Bl,
 146    0xE4FADA8El, 0xF59B87BDl, 0xB49FC019l, 0x937E89A3l, 0x4986ADB5l,
 147    0x658BC778l, 0xD13EF201l, 0x47B268B2l, 0x08EA3CAEl, 0x9FAC631Dl,
 148    0xCDAFF6E4l, 0xB71C49BCl, 0x5754369Al, 0x5D9E0A5Al, 0x49DB005El,
 149    0xD961A6D6l, 0x1BC65CF3l, 0x08640F05l, 0x1BDB1E6El, 0xB1928C0Dl,
 150    0xF960629Dl, 0x2CC85E82l, 0x4F4EC577l, 0x3AB64AE0l, 0xFFC537F6l,
 151    0xA90F6BF2l, 0x5060B8B4l, 0x19E11968l, 0x714CA34Fl, 0xEE3BE15Cl,
 152    0x8CE2D14Bl, 0x469FF67Bl, 0xC1BC96A8l, 0x3858DA9Fl, 0x9B9DB21Fl,
 153    0xFD36B46Fl, 0x5A5479ADl, 0xFA52D080l };
 154
 155
 156
 157 int blowfish_testSetup(void)
 158 {
 159         kdbg_init();
 160         return 0;
 161 }
 162
 163 int blowfish_testTearDown(void)
 164 {
 165         return 0;
 166 }
 167
 168 int blowfish_testRun(void)
 169 {
 170         // NOTE: we use a static variable here to avoid stack overflows due to the huge
 171         // context structure of blowfish.
 172         static BlowfishContext ctx;
 173         blowfish_init(&ctx);
 174         BlockCipher *c = &ctx.c;
 175
 176         for (int i=0; i<NUM_VARIABLE_KEY_TESTS; ++i)
 177         {
 178                 uint32_t data[2] = { cpu_to_be32(plaintext_l[i]), cpu_to_be32(plaintext_r[i]) };
 179
 180                 cipher_set_vkey(c, variable_key[i], 8);
 181
 182                 cipher_ecb_encrypt(c, data);
 183                 ASSERT(data[0] == cpu_to_be32(ciphertext_l[i]));
 184                 ASSERT(data[1] == cpu_to_be32(ciphertext_r[i]));
 185
 186                 cipher_ecb_decrypt(c, data);
 187                 ASSERT(data[0] == cpu_to_be32(plaintext_l[i]));
 188                 ASSERT(data[1] == cpu_to_be32(plaintext_r[i]));
 189         }
 190
 191         for (int j=0; j<NUM_SET_KEY_TESTS; ++j)
 192         {
 193                 int i = j + NUM_VARIABLE_KEY_TESTS;
 194                 uint32_t data[2] = { cpu_to_be32(plaintext_l[i]), cpu_to_be32(plaintext_r[i]) };
 195
 196                 cipher_set_vkey(c, &set_key[0], j+1);
 197
 198                 cipher_ecb_encrypt(c, data);
 199                 ASSERT(data[0] == cpu_to_be32(ciphertext_l[i]));
 200                 ASSERT(data[1] == cpu_to_be32(ciphertext_r[i]));
 201
 202                 cipher_ecb_decrypt(c, data);
 203                 ASSERT(data[0] == cpu_to_be32(plaintext_l[i]));
 204                 ASSERT(data[1] == cpu_to_be32(plaintext_r[i]));
 205         }
 206
 207         uint8_t data[8];
 208         memset(data, 0, 8);
 209         cipher_set_vkey(c, "0123456789", 10);
 210         for (int i=0;i<1000;++i) cipher_ecb_encrypt(c, data);
 211         for (int i=0;i<1000;++i) cipher_ecb_decrypt(c, data);
 212         ASSERT(memcmp(data, "\x00\x00\x00\x00\x00\x00\x00\x00", 8) == 0);
 213
 214         return 0;
 215 }
 216
 217 TEST_MAIN(blowfish);