lib/crypto/aes_ccm_128_test.c

   1 /*
   2    AES-CCM-128 tests
   3
   4    Copyright (C) Stefan Metzmacher 2015
   5
   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.
  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, see <http://www.gnu.org/licenses/>.
  18 */
  19 #include "replace.h"
  20 #include "../lib/util/samba_util.h"
  21 #include "../lib/crypto/crypto.h"
  22 #include "../lib/crypto/aes_test.h"
  23
  24 #ifndef AES_CCM_128_ONLY_TESTVECTORS
  25 struct torture_context;
  26 bool torture_local_crypto_aes_ccm_128(struct torture_context *torture);
  27
  28 /*
  29  This uses our own test values as we rely on a 11 byte nonce
  30  and the values from rfc rfc3610 use 13 byte nonce.
  31 */
  32 bool torture_local_crypto_aes_ccm_128(struct torture_context *tctx)
  33 {
  34         bool ret = true;
  35         uint32_t i;
  36         struct aes_mode_testvector testarray[] = {
  37 #endif /* AES_CCM_128_ONLY_TESTVECTORS */
  38 #define AES_CCM_128_TESTVECTOR(_k, _n, _a, _p, _c, _t) \
  39         AES_MODE_TESTVECTOR(aes_ccm_128, _k, _n, _a, _p, _c, _t)
  40
  41         AES_CCM_128_TESTVECTOR(
  42                 /* K */
  43                 "8BF9FBC2B8149484FF11AB1F3A544FF6",
  44                 /* N */
  45                 "010000000000000077F7A8",
  46                 /* A */
  47                 "010000000000000077F7A80000000000"
  48                 "A8000000000001004100002C00980000",
  49                 /* P */
  50                 "FE534D4240000100000000000B00811F"
  51                 "00000000000000000600000000000000"
  52                 "00000000010000004100002C00980000"
  53                 "00000000000000000000000000000000"
  54                 "3900000094010600FFFFFFFFFFFFFFFF"
  55                 "FFFFFFFFFFFFFFFF7800000030000000"
  56                 "000000007800000000000000FFFF0000"
  57                 "0100000000000000"
  58                 "03005C003100370032002E0033003100"
  59                 "2E0039002E003100380033005C006E00"
  60                 "650074006C006F0067006F006E000000",
  61                 /* C */
  62                 "25985364BF9AF90EB0B9C8FB55B7C446"
  63                 "780F310F1EC4677726BFBF34E38E6408"
  64                 "057EE228814F11CBAAB794A79F7A1F78"
  65                 "2DE73B7477985360A02D35A7A347ABF7"
  66                 "9F18DD8687767423BB08F18642B6EFEE"
  67                 "8B1543D83091AF5952F58BB4BD89FF6B"
  68                 "0206E7170481C7BC61F06653D0CF10F7"
  69                 "C78380389382C276"
  70                 "7B8BF34D687A5C3D4F783F926F7755C0"
  71                 "2D44C30848C69CFDD8E54395F1881611"
  72                 "E5502285870A7179068923105190C837",
  73                 /* T */
  74                 "3C11F652F8EA5600C8607D2E0FEAFD42"
  75         ),
  76         AES_CCM_128_TESTVECTOR(
  77                 /* K */
  78                 "f9fdca4ac64fe7f014de0f43039c7571",
  79                 /* N */
  80                 "5a8aa485c316e947125478",
  81                 /* A */
  82                 "3796cf51b8726652a4204733b8fbb047"
  83                 "cf00fb91a9837e22ec22b1a268f88e2c",
  84                 /* P */
  85                 "a265480ca88d5f536db0dc6abc40faf0"
  86                 "d05be7a9669777682345647586786983",
  87                 /* C */
  88                 "65F8D8422006FB77FB7CCEFDFFF93729"
  89                 "B3EFCB06A0FAF3A2ABAB485723373F53",
  90                 /* T */
  91                 "2C62BD82AD231887A7B326E1E045BC91"
  92         ),
  93         AES_CCM_128_TESTVECTOR(
  94                 /* K */
  95                 "197afb02ffbd8f699dacae87094d5243",
  96                 /* N */
  97                 "5a8aa485c316e947125478",
  98                 /* A */
  99                 "",
 100                 /* P */
 101                 "3796cf51b8726652a4204733b8fbb047"
 102                 "cf00fb91a9837e22",
 103                 /* C */
 104                 "CA53910394115C5DAB5D7250F04D6A27"
 105                 "2BCFA4329528F3AC",
 106                 /* T */
 107                 "38E3A318F9BA88D4DD2FAF3521820001"
 108         ),
 109         AES_CCM_128_TESTVECTOR(
 110                 /* K */
 111                 "90929a4b0ac65b350ad1591611fe4829",
 112                 /* N */
 113                 "5a8aa485c316e9403aff85",
 114                 /* A */
 115                 "",
 116                 /* P */
 117                 "a16a2e741f1cd9717285b6d882c1fc53"
 118                 "655e9773761ad697",
 119                 /* C */
 120                 "ACA5E98D2784D131AE76E3C8BF9C3988"
 121                 "35C0206C71893F26",
 122                 /* T */
 123                 "AE67C0EA38C5383BFDC7967F4E9D1678"
 124         ),
 125         AES_CCM_128_TESTVECTOR(
 126                 /* K */
 127                 "f9fdca4ac64fe7f014de0f43039c7571",
 128                 /* N */
 129                 "5a8aa485c316e947125478",
 130                 /* A */
 131                 "3796cf51b8726652a4204733b8fbb047"
 132                 "cf00fb91a9837e22ec22b1a268f88e2c",
 133                 /* P */
 134                 "a265480ca88d5f536db0dc6abc40faf0"
 135                 "d05be7a966977768",
 136                 /* C */
 137                 "65F8D8422006FB77FB7CCEFDFFF93729"
 138                 "B3EFCB06A0FAF3A2",
 139                 /* T */
 140                 "03C6E244586AFAB9B60D9F6DBDF7EB1A"
 141         ),
 142         AES_CCM_128_TESTVECTOR(
 143                 /* K */
 144                 "26511fb51fcfa75cb4b44da75a6e5a0e",
 145                 /* N */
 146                 "5a8aa485c316e9403aff85",
 147                 /* A */
 148                 "a16a2e741f1cd9717285b6d882c1fc53"
 149                 "655e9773761ad697a7ee6410184c7982",
 150                 /* P */
 151                 "8739b4bea1a099fe547499cbc6d1b13d"
 152                 "849b8084c9b6acc5",
 153                 /* C */
 154                 "D31F9FC23674D5272125375E0A2F5365"
 155                 "41B1FAF1DD68C819",
 156                 /* T */
 157                 "4F315233A76C4DD99972561C5158AB3B"
 158         ),
 159         AES_CCM_128_TESTVECTOR(
 160                 /* K */
 161                 "f9fdca4ac64fe7f014de0f43039c7571",
 162                 /* N */
 163                 "5a8aa485c316e947125478",
 164                 /* A */
 165                 "3796cf51b8726652a4204733b8fbb047"
 166                 "cf00fb91a9837e22ec22b1a268",
 167                 /* P */
 168                 "a265480ca88d5f536db0dc6abc40faf0"
 169                 "d05be7a9669777682376345745",
 170                 /* C */
 171                 "65F8D8422006FB77FB7CCEFDFFF93729"
 172                 "B3EFCB06A0FAF3A2AB981875E0",
 173                 /* T */
 174                 "EA93AAEDA607226E9E79D2EE5C4B62F8"
 175         ),
 176         AES_CCM_128_TESTVECTOR(
 177                 /* K */
 178                 "26511fb51fcfa75cb4b44da75a6e5a0e",
 179                 /* N */
 180                 "5a8aa485c316e9403aff85",
 181                 /* A */
 182                 "a16a2e741f1cd9717285b6d882c1fc53"
 183                 "65",
 184                 /* P */
 185                 "8739b4bea1a099fe547499cbc6d1b13d"
 186                 "84",
 187                 /* C */
 188                 "D31F9FC23674D5272125375E0A2F5365"
 189                 "41",
 190                 /* T */
 191                 "036F58DA2372B29BD0E01C58A0E7F9EE"
 192         ),
 193         AES_CCM_128_TESTVECTOR(
 194                 /* K */
 195                 "00000000000000000000000000000000",
 196                 /* N */
 197                 "0000000000000000000000",
 198                 /* A */
 199                 "",
 200                 /* P */
 201                 "00",
 202                 /* C */
 203                 "2E",
 204                 /* T */
 205                 "61787D2C432A58293B73D01154E61B6B"
 206         ),
 207         AES_CCM_128_TESTVECTOR(
 208                 /* K */
 209                 "00000000000000000000000000000000",
 210                 /* N */
 211                 "0000000000000000000000",
 212                 /* A */
 213                 "00",
 214                 /* P */
 215                 "00",
 216                 /* C */
 217                 "2E",
 218                 /* T */
 219                 "E4284A0E813F0FFA146CF59F9ADAFBD7"
 220         ),
 221 #ifndef AES_CCM_128_ONLY_TESTVECTORS
 222         };
 223
 224         for (i=0; i < ARRAY_SIZE(testarray); i++) {
 225                 struct aes_ccm_128_context ctx;
 226                 uint8_t T[AES_BLOCK_SIZE];
 227                 DATA_BLOB _T = data_blob_const(T, sizeof(T));
 228                 DATA_BLOB C;
 229                 int e;
 230
 231                 C = data_blob_dup_talloc(tctx, testarray[i].P);
 232
 233                 aes_ccm_128_init(&ctx, testarray[i].K.data, testarray[i].N.data,
 234                                  testarray[i].A.length, testarray[i].P.length);
 235                 aes_ccm_128_update(&ctx,
 236                                    testarray[i].A.data,
 237                                    testarray[i].A.length);
 238                 aes_ccm_128_update(&ctx, C.data, C.length);
 239                 aes_ccm_128_crypt(&ctx, C.data, C.length);
 240                 aes_ccm_128_digest(&ctx, T);
 241
 242                 e = memcmp(testarray[i].T.data, T, sizeof(T));
 243                 if (e != 0) {
 244                         aes_mode_testvector_debug(&testarray[i], NULL, &C, &_T);
 245                         ret = false;
 246                         goto fail;
 247                 }
 248
 249                 e = memcmp(testarray[i].C.data, C.data, C.length);
 250                 if (e != 0) {
 251                         aes_mode_testvector_debug(&testarray[i], NULL, &C, &_T);
 252                         ret = false;
 253                         goto fail;
 254                 }
 255         }
 256
 257         for (i=0; i < ARRAY_SIZE(testarray); i++) {
 258                 struct aes_ccm_128_context ctx;
 259                 uint8_t T[AES_BLOCK_SIZE];
 260                 DATA_BLOB _T = data_blob_const(T, sizeof(T));
 261                 DATA_BLOB C;
 262                 int e;
 263                 size_t j;
 264
 265                 C = data_blob_dup_talloc(tctx, testarray[i].P);
 266
 267                 aes_ccm_128_init(&ctx, testarray[i].K.data, testarray[i].N.data,
 268                                  testarray[i].A.length, testarray[i].P.length);
 269                 for (j=0; j < testarray[i].A.length; j++) {
 270                         aes_ccm_128_update(&ctx, NULL, 0);
 271                         aes_ccm_128_update(&ctx, &testarray[i].A.data[j], 1);
 272                         aes_ccm_128_update(&ctx, NULL, 0);
 273                 }
 274                 for (j=0; j < C.length; j++) {
 275                         aes_ccm_128_crypt(&ctx, NULL, 0);
 276                         aes_ccm_128_update(&ctx, NULL, 0);
 277                         aes_ccm_128_update(&ctx, &C.data[j], 1);
 278                         aes_ccm_128_crypt(&ctx, &C.data[j], 1);
 279                         aes_ccm_128_crypt(&ctx, NULL, 0);
 280                         aes_ccm_128_update(&ctx, NULL, 0);
 281                 }
 282                 aes_ccm_128_digest(&ctx, T);
 283
 284                 e = memcmp(testarray[i].T.data, T, sizeof(T));
 285                 if (e != 0) {
 286                         aes_mode_testvector_debug(&testarray[i], NULL, &C, &_T);
 287                         ret = false;
 288                         goto fail;
 289                 }
 290
 291                 e = memcmp(testarray[i].C.data, C.data, C.length);
 292                 if (e != 0) {
 293                         aes_mode_testvector_debug(&testarray[i], NULL, &C, &_T);
 294                         ret = false;
 295                         goto fail;
 296                 }
 297         }
 298
 299         for (i=0; i < ARRAY_SIZE(testarray); i++) {
 300                 struct aes_ccm_128_context ctx;
 301                 uint8_t T[AES_BLOCK_SIZE];
 302                 DATA_BLOB _T = data_blob_const(T, sizeof(T));
 303                 DATA_BLOB P;
 304                 int e;
 305                 size_t j;
 306
 307                 P = data_blob_dup_talloc(tctx, testarray[i].C);
 308
 309                 aes_ccm_128_init(&ctx, testarray[i].K.data, testarray[i].N.data,
 310                                  testarray[i].A.length, testarray[i].P.length);
 311                 for (j=0; j < testarray[i].A.length; j++) {
 312                         aes_ccm_128_update(&ctx, NULL, 0);
 313                         aes_ccm_128_update(&ctx, &testarray[i].A.data[j], 1);
 314                         aes_ccm_128_update(&ctx, NULL, 0);
 315                 }
 316                 for (j=0; j < P.length; j++) {
 317                         aes_ccm_128_crypt(&ctx, NULL, 0);
 318                         aes_ccm_128_update(&ctx, NULL, 0);
 319                         aes_ccm_128_crypt(&ctx, &P.data[j], 1);
 320                         aes_ccm_128_update(&ctx, &P.data[j], 1);
 321                         aes_ccm_128_crypt(&ctx, NULL, 0);
 322                         aes_ccm_128_update(&ctx, NULL, 0);
 323                 }
 324                 aes_ccm_128_digest(&ctx, T);
 325
 326                 e = memcmp(testarray[i].T.data, T, sizeof(T));
 327                 if (e != 0) {
 328                         aes_mode_testvector_debug(&testarray[i], &P, NULL, &_T);
 329                         ret = false;
 330                         goto fail;
 331                 }
 332
 333                 e = memcmp(testarray[i].P.data, P.data, P.length);
 334                 if (e != 0) {
 335                         aes_mode_testvector_debug(&testarray[i], &P, NULL, &_T);
 336                         ret = false;
 337                         goto fail;
 338                 }
 339         }
 340
 341         for (i=0; i < ARRAY_SIZE(testarray); i++) {
 342                 struct aes_ccm_128_context ctx;
 343                 uint8_t T[AES_BLOCK_SIZE];
 344                 DATA_BLOB _T = data_blob_const(T, sizeof(T));
 345                 DATA_BLOB P;
 346                 int e;
 347
 348                 P = data_blob_dup_talloc(tctx, testarray[i].C);
 349
 350                 aes_ccm_128_init(&ctx, testarray[i].K.data, testarray[i].N.data,
 351                                  testarray[i].A.length, testarray[i].P.length);
 352                 aes_ccm_128_update(&ctx, testarray[i].A.data, testarray[i].A.length);
 353                 aes_ccm_128_crypt(&ctx, P.data, P.length);
 354                 aes_ccm_128_update(&ctx, P.data, P.length);
 355                 aes_ccm_128_digest(&ctx, T);
 356
 357                 e = memcmp(testarray[i].T.data, T, sizeof(T));
 358                 if (e != 0) {
 359                         aes_mode_testvector_debug(&testarray[i], &P, NULL, &_T);
 360                         ret = false;
 361                         goto fail;
 362                 }
 363
 364                 e = memcmp(testarray[i].P.data, P.data, P.length);
 365                 if (e != 0) {
 366                         aes_mode_testvector_debug(&testarray[i], &P, NULL, &_T);
 367                         ret = false;
 368                         goto fail;
 369                 }
 370         }
 371
 372  fail:
 373         return ret;
 374 }
 375
 376 #endif /* AES_CCM_128_ONLY_TESTVECTORS */