sunrpc/auth_gss/gss_krb5_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2022 Oracle and/or its affiliates.
   4  *
   5  * KUnit test of SunRPC's GSS Kerberos mechanism. Subsystem
   6  * name is "rpcsec_gss_krb5".
   7  */
   8
   9 #include <kunit/test.h>
  10 #include <kunit/visibility.h>
  11
  12 #include <linux/kernel.h>
  13 #include <crypto/hash.h>
  14
  15 #include <linux/sunrpc/xdr.h>
  16 #include <linux/sunrpc/gss_krb5.h>
  17
  18 #include "gss_krb5_internal.h"
  19
  20 MODULE_IMPORT_NS(EXPORTED_FOR_KUNIT_TESTING);
  21
  22 struct gss_krb5_test_param {
  23         const char                      *desc;
  24         u32                             enctype;
  25         u32                             nfold;
  26         u32                             constant;
  27         const struct xdr_netobj         *base_key;
  28         const struct xdr_netobj         *Ke;
  29         const struct xdr_netobj         *usage;
  30         const struct xdr_netobj         *plaintext;
  31         const struct xdr_netobj         *confounder;
  32         const struct xdr_netobj         *expected_result;
  33         const struct xdr_netobj         *expected_hmac;
  34         const struct xdr_netobj         *next_iv;
  35 };
  36
  37 static inline void gss_krb5_get_desc(const struct gss_krb5_test_param *param,
  38                                      char *desc)
  39 {
  40         strscpy(desc, param->desc, KUNIT_PARAM_DESC_SIZE);
  41 }
  42
  43 static void kdf_case(struct kunit *test)
  44 {
  45         const struct gss_krb5_test_param *param = test->param_value;
  46         const struct gss_krb5_enctype *gk5e;
  47         struct xdr_netobj derivedkey;
  48         int err;
  49
  50         /* Arrange */
  51         gk5e = gss_krb5_lookup_enctype(param->enctype);
  52         if (!gk5e)
  53                 kunit_skip(test, "Encryption type is not available");
  54
  55         derivedkey.data = kunit_kzalloc(test, param->expected_result->len,
  56                                         GFP_KERNEL);
  57         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, derivedkey.data);
  58         derivedkey.len = param->expected_result->len;
  59
  60         /* Act */
  61         err = gk5e->derive_key(gk5e, param->base_key, &derivedkey,
  62                                param->usage, GFP_KERNEL);
  63         KUNIT_ASSERT_EQ(test, err, 0);
  64
  65         /* Assert */
  66         KUNIT_EXPECT_EQ_MSG(test,
  67                             memcmp(param->expected_result->data,
  68                                    derivedkey.data, derivedkey.len), 0,
  69                             "key mismatch");
  70 }
  71
  72 static void checksum_case(struct kunit *test)
  73 {
  74         const struct gss_krb5_test_param *param = test->param_value;
  75         struct xdr_buf buf = {
  76                 .head[0].iov_len        = param->plaintext->len,
  77                 .len                    = param->plaintext->len,
  78         };
  79         const struct gss_krb5_enctype *gk5e;
  80         struct xdr_netobj Kc, checksum;
  81         struct crypto_ahash *tfm;
  82         int err;
  83
  84         /* Arrange */
  85         gk5e = gss_krb5_lookup_enctype(param->enctype);
  86         if (!gk5e)
  87                 kunit_skip(test, "Encryption type is not available");
  88
  89         Kc.len = gk5e->Kc_length;
  90         Kc.data = kunit_kzalloc(test, Kc.len, GFP_KERNEL);
  91         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, Kc.data);
  92         err = gk5e->derive_key(gk5e, param->base_key, &Kc,
  93                                param->usage, GFP_KERNEL);
  94         KUNIT_ASSERT_EQ(test, err, 0);
  95
  96         tfm = crypto_alloc_ahash(gk5e->cksum_name, 0, CRYPTO_ALG_ASYNC);
  97         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tfm);
  98         err = crypto_ahash_setkey(tfm, Kc.data, Kc.len);
  99         KUNIT_ASSERT_EQ(test, err, 0);
 100
 101         buf.head[0].iov_base = kunit_kzalloc(test, buf.head[0].iov_len, GFP_KERNEL);
 102         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf.head[0].iov_base);
 103         memcpy(buf.head[0].iov_base, param->plaintext->data, buf.head[0].iov_len);
 104
 105         checksum.len = gk5e->cksumlength;
 106         checksum.data = kunit_kzalloc(test, checksum.len, GFP_KERNEL);
 107         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, checksum.data);
 108
 109         /* Act */
 110         err = gss_krb5_checksum(tfm, NULL, 0, &buf, 0, &checksum);
 111         KUNIT_ASSERT_EQ(test, err, 0);
 112
 113         /* Assert */
 114         KUNIT_EXPECT_EQ_MSG(test,
 115                             memcmp(param->expected_result->data,
 116                                    checksum.data, checksum.len), 0,
 117                             "checksum mismatch");
 118
 119         crypto_free_ahash(tfm);
 120 }
 121
 122 #define DEFINE_HEX_XDR_NETOBJ(name, hex_array...)               \
 123         static const u8 name ## _data[] = { hex_array };        \
 124         static const struct xdr_netobj name = {                 \
 125                 .data   = (u8 *)name##_data,                    \
 126                 .len    = sizeof(name##_data),                  \
 127         }
 128
 129 #define DEFINE_STR_XDR_NETOBJ(name, string)                     \
 130         static const u8 name ## _str[] = string;                \
 131         static const struct xdr_netobj name = {                 \
 132                 .data   = (u8 *)name##_str,                     \
 133                 .len    = sizeof(name##_str) - 1,               \
 134         }
 135
 136 /*
 137  * RFC 3961 Appendix A.1.  n-fold
 138  *
 139  * The n-fold function is defined in section 5.1 of RFC 3961.
 140  *
 141  * This test material is copyright (C) The Internet Society (2005).
 142  */
 143
 144 DEFINE_HEX_XDR_NETOBJ(nfold_test1_plaintext,
 145                       0x30, 0x31, 0x32, 0x33, 0x34, 0x35
 146 );
 147 DEFINE_HEX_XDR_NETOBJ(nfold_test1_expected_result,
 148                       0xbe, 0x07, 0x26, 0x31, 0x27, 0x6b, 0x19, 0x55
 149 );
 150
 151 DEFINE_HEX_XDR_NETOBJ(nfold_test2_plaintext,
 152                       0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64
 153 );
 154 DEFINE_HEX_XDR_NETOBJ(nfold_test2_expected_result,
 155                       0x78, 0xa0, 0x7b, 0x6c, 0xaf, 0x85, 0xfa
 156 );
 157
 158 DEFINE_HEX_XDR_NETOBJ(nfold_test3_plaintext,
 159                       0x52, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x43, 0x6f,
 160                       0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2c,
 161                       0x20, 0x61, 0x6e, 0x64, 0x20, 0x52, 0x75, 0x6e,
 162                       0x6e, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x64,
 163                       0x65
 164 );
 165 DEFINE_HEX_XDR_NETOBJ(nfold_test3_expected_result,
 166                       0xbb, 0x6e, 0xd3, 0x08, 0x70, 0xb7, 0xf0, 0xe0
 167 );
 168
 169 DEFINE_HEX_XDR_NETOBJ(nfold_test4_plaintext,
 170                       0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64
 171 );
 172 DEFINE_HEX_XDR_NETOBJ(nfold_test4_expected_result,
 173                       0x59, 0xe4, 0xa8, 0xca, 0x7c, 0x03, 0x85, 0xc3,
 174                       0xc3, 0x7b, 0x3f, 0x6d, 0x20, 0x00, 0x24, 0x7c,
 175                       0xb6, 0xe6, 0xbd, 0x5b, 0x3e
 176 );
 177
 178 DEFINE_HEX_XDR_NETOBJ(nfold_test5_plaintext,
 179                       0x4d, 0x41, 0x53, 0x53, 0x41, 0x43, 0x48, 0x56,
 180                       0x53, 0x45, 0x54, 0x54, 0x53, 0x20, 0x49, 0x4e,
 181                       0x53, 0x54, 0x49, 0x54, 0x56, 0x54, 0x45, 0x20,
 182                       0x4f, 0x46, 0x20, 0x54, 0x45, 0x43, 0x48, 0x4e,
 183                       0x4f, 0x4c, 0x4f, 0x47, 0x59
 184 );
 185 DEFINE_HEX_XDR_NETOBJ(nfold_test5_expected_result,
 186                       0xdb, 0x3b, 0x0d, 0x8f, 0x0b, 0x06, 0x1e, 0x60,
 187                       0x32, 0x82, 0xb3, 0x08, 0xa5, 0x08, 0x41, 0x22,
 188                       0x9a, 0xd7, 0x98, 0xfa, 0xb9, 0x54, 0x0c, 0x1b
 189 );
 190
 191 DEFINE_HEX_XDR_NETOBJ(nfold_test6_plaintext,
 192                       0x51
 193 );
 194 DEFINE_HEX_XDR_NETOBJ(nfold_test6_expected_result,
 195                       0x51, 0x8a, 0x54, 0xa2, 0x15, 0xa8, 0x45, 0x2a,
 196                       0x51, 0x8a, 0x54, 0xa2, 0x15, 0xa8, 0x45, 0x2a,
 197                       0x51, 0x8a, 0x54, 0xa2, 0x15
 198 );
 199
 200 DEFINE_HEX_XDR_NETOBJ(nfold_test7_plaintext,
 201                       0x62, 0x61
 202 );
 203 DEFINE_HEX_XDR_NETOBJ(nfold_test7_expected_result,
 204                       0xfb, 0x25, 0xd5, 0x31, 0xae, 0x89, 0x74, 0x49,
 205                       0x9f, 0x52, 0xfd, 0x92, 0xea, 0x98, 0x57, 0xc4,
 206                       0xba, 0x24, 0xcf, 0x29, 0x7e
 207 );
 208
 209 DEFINE_HEX_XDR_NETOBJ(nfold_test_kerberos,
 210                       0x6b, 0x65, 0x72, 0x62, 0x65, 0x72, 0x6f, 0x73
 211 );
 212 DEFINE_HEX_XDR_NETOBJ(nfold_test8_expected_result,
 213                       0x6b, 0x65, 0x72, 0x62, 0x65, 0x72, 0x6f, 0x73
 214 );
 215 DEFINE_HEX_XDR_NETOBJ(nfold_test9_expected_result,
 216                       0x6b, 0x65, 0x72, 0x62, 0x65, 0x72, 0x6f, 0x73,
 217                       0x7b, 0x9b, 0x5b, 0x2b, 0x93, 0x13, 0x2b, 0x93
 218 );
 219 DEFINE_HEX_XDR_NETOBJ(nfold_test10_expected_result,
 220                       0x83, 0x72, 0xc2, 0x36, 0x34, 0x4e, 0x5f, 0x15,
 221                       0x50, 0xcd, 0x07, 0x47, 0xe1, 0x5d, 0x62, 0xca,
 222                       0x7a, 0x5a, 0x3b, 0xce, 0xa4
 223 );
 224 DEFINE_HEX_XDR_NETOBJ(nfold_test11_expected_result,
 225                       0x6b, 0x65, 0x72, 0x62, 0x65, 0x72, 0x6f, 0x73,
 226                       0x7b, 0x9b, 0x5b, 0x2b, 0x93, 0x13, 0x2b, 0x93,
 227                       0x5c, 0x9b, 0xdc, 0xda, 0xd9, 0x5c, 0x98, 0x99,
 228                       0xc4, 0xca, 0xe4, 0xde, 0xe6, 0xd6, 0xca, 0xe4
 229 );
 230
 231 static const struct gss_krb5_test_param rfc3961_nfold_test_params[] = {
 232         {
 233                 .desc                   = "64-fold(\"012345\")",
 234                 .nfold                  = 64,
 235                 .plaintext              = &nfold_test1_plaintext,
 236                 .expected_result        = &nfold_test1_expected_result,
 237         },
 238         {
 239                 .desc                   = "56-fold(\"password\")",
 240                 .nfold                  = 56,
 241                 .plaintext              = &nfold_test2_plaintext,
 242                 .expected_result        = &nfold_test2_expected_result,
 243         },
 244         {
 245                 .desc                   = "64-fold(\"Rough Consensus, and Running Code\")",
 246                 .nfold                  = 64,
 247                 .plaintext              = &nfold_test3_plaintext,
 248                 .expected_result        = &nfold_test3_expected_result,
 249         },
 250         {
 251                 .desc                   = "168-fold(\"password\")",
 252                 .nfold                  = 168,
 253                 .plaintext              = &nfold_test4_plaintext,
 254                 .expected_result        = &nfold_test4_expected_result,
 255         },
 256         {
 257                 .desc                   = "192-fold(\"MASSACHVSETTS INSTITVTE OF TECHNOLOGY\")",
 258                 .nfold                  = 192,
 259                 .plaintext              = &nfold_test5_plaintext,
 260                 .expected_result        = &nfold_test5_expected_result,
 261         },
 262         {
 263                 .desc                   = "168-fold(\"Q\")",
 264                 .nfold                  = 168,
 265                 .plaintext              = &nfold_test6_plaintext,
 266                 .expected_result        = &nfold_test6_expected_result,
 267         },
 268         {
 269                 .desc                   = "168-fold(\"ba\")",
 270                 .nfold                  = 168,
 271                 .plaintext              = &nfold_test7_plaintext,
 272                 .expected_result        = &nfold_test7_expected_result,
 273         },
 274         {
 275                 .desc                   = "64-fold(\"kerberos\")",
 276                 .nfold                  = 64,
 277                 .plaintext              = &nfold_test_kerberos,
 278                 .expected_result        = &nfold_test8_expected_result,
 279         },
 280         {
 281                 .desc                   = "128-fold(\"kerberos\")",
 282                 .nfold                  = 128,
 283                 .plaintext              = &nfold_test_kerberos,
 284                 .expected_result        = &nfold_test9_expected_result,
 285         },
 286         {
 287                 .desc                   = "168-fold(\"kerberos\")",
 288                 .nfold                  = 168,
 289                 .plaintext              = &nfold_test_kerberos,
 290                 .expected_result        = &nfold_test10_expected_result,
 291         },
 292         {
 293                 .desc                   = "256-fold(\"kerberos\")",
 294                 .nfold                  = 256,
 295                 .plaintext              = &nfold_test_kerberos,
 296                 .expected_result        = &nfold_test11_expected_result,
 297         },
 298 };
 299
 300 /* Creates the function rfc3961_nfold_gen_params */
 301 KUNIT_ARRAY_PARAM(rfc3961_nfold, rfc3961_nfold_test_params, gss_krb5_get_desc);
 302
 303 static void rfc3961_nfold_case(struct kunit *test)
 304 {
 305         const struct gss_krb5_test_param *param = test->param_value;
 306         u8 *result;
 307
 308         /* Arrange */
 309         result = kunit_kzalloc(test, 4096, GFP_KERNEL);
 310         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, result);
 311
 312         /* Act */
 313         krb5_nfold(param->plaintext->len * 8, param->plaintext->data,
 314                    param->expected_result->len * 8, result);
 315
 316         /* Assert */
 317         KUNIT_EXPECT_EQ_MSG(test,
 318                             memcmp(param->expected_result->data,
 319                                    result, param->expected_result->len), 0,
 320                             "result mismatch");
 321 }
 322
 323 static struct kunit_case rfc3961_test_cases[] = {
 324         {
 325                 .name                   = "RFC 3961 n-fold",
 326                 .run_case               = rfc3961_nfold_case,
 327                 .generate_params        = rfc3961_nfold_gen_params,
 328         },
 329         {}
 330 };
 331
 332 static struct kunit_suite rfc3961_suite = {
 333         .name                   = "RFC 3961 tests",
 334         .test_cases             = rfc3961_test_cases,
 335 };
 336
 337 /*
 338  * From RFC 3962 Appendix B:   Sample Test Vectors
 339  *
 340  * Some test vectors for CBC with ciphertext stealing, using an
 341  * initial vector of all-zero.
 342  *
 343  * This test material is copyright (C) The Internet Society (2005).
 344  */
 345
 346 DEFINE_HEX_XDR_NETOBJ(rfc3962_encryption_key,
 347                       0x63, 0x68, 0x69, 0x63, 0x6b, 0x65, 0x6e, 0x20,
 348                       0x74, 0x65, 0x72, 0x69, 0x79, 0x61, 0x6b, 0x69
 349 );
 350
 351 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test1_plaintext,
 352                       0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20,
 353                       0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65,
 354                       0x20
 355 );
 356 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test1_expected_result,
 357                       0xc6, 0x35, 0x35, 0x68, 0xf2, 0xbf, 0x8c, 0xb4,
 358                       0xd8, 0xa5, 0x80, 0x36, 0x2d, 0xa7, 0xff, 0x7f,
 359                       0x97
 360 );
 361 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test1_next_iv,
 362                       0xc6, 0x35, 0x35, 0x68, 0xf2, 0xbf, 0x8c, 0xb4,
 363                       0xd8, 0xa5, 0x80, 0x36, 0x2d, 0xa7, 0xff, 0x7f
 364 );
 365
 366 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test2_plaintext,
 367                       0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20,
 368                       0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65,
 369                       0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c,
 370                       0x20, 0x47, 0x61, 0x75, 0x27, 0x73, 0x20
 371 );
 372 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test2_expected_result,
 373                       0xfc, 0x00, 0x78, 0x3e, 0x0e, 0xfd, 0xb2, 0xc1,
 374                       0xd4, 0x45, 0xd4, 0xc8, 0xef, 0xf7, 0xed, 0x22,
 375                       0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
 376                       0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5
 377 );
 378 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test2_next_iv,
 379                       0xfc, 0x00, 0x78, 0x3e, 0x0e, 0xfd, 0xb2, 0xc1,
 380                       0xd4, 0x45, 0xd4, 0xc8, 0xef, 0xf7, 0xed, 0x22
 381 );
 382
 383 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test3_plaintext,
 384                       0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20,
 385                       0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65,
 386                       0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c,
 387                       0x20, 0x47, 0x61, 0x75, 0x27, 0x73, 0x20, 0x43
 388 );
 389 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test3_expected_result,
 390                       0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
 391                       0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8,
 392                       0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
 393                       0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84
 394 );
 395 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test3_next_iv,
 396                       0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
 397                       0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8
 398 );
 399
 400 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test4_plaintext,
 401                       0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20,
 402                       0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65,
 403                       0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c,
 404                       0x20, 0x47, 0x61, 0x75, 0x27, 0x73, 0x20, 0x43,
 405                       0x68, 0x69, 0x63, 0x6b, 0x65, 0x6e, 0x2c, 0x20,
 406                       0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x2c
 407 );
 408 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test4_expected_result,
 409                       0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
 410                       0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
 411                       0xb3, 0xff, 0xfd, 0x94, 0x0c, 0x16, 0xa1, 0x8c,
 412                       0x1b, 0x55, 0x49, 0xd2, 0xf8, 0x38, 0x02, 0x9e,
 413                       0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
 414                       0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5
 415 );
 416 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test4_next_iv,
 417                       0xb3, 0xff, 0xfd, 0x94, 0x0c, 0x16, 0xa1, 0x8c,
 418                       0x1b, 0x55, 0x49, 0xd2, 0xf8, 0x38, 0x02, 0x9e
 419 );
 420
 421 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test5_plaintext,
 422                       0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20,
 423                       0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65,
 424                       0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c,
 425                       0x20, 0x47, 0x61, 0x75, 0x27, 0x73, 0x20, 0x43,
 426                       0x68, 0x69, 0x63, 0x6b, 0x65, 0x6e, 0x2c, 0x20,
 427                       0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x2c, 0x20
 428 );
 429 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test5_expected_result,
 430                       0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
 431                       0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
 432                       0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
 433                       0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8,
 434                       0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
 435                       0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8
 436 );
 437 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test5_next_iv,
 438                       0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
 439                       0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8
 440 );
 441
 442 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test6_plaintext,
 443                       0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20,
 444                       0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68, 0x65,
 445                       0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c,
 446                       0x20, 0x47, 0x61, 0x75, 0x27, 0x73, 0x20, 0x43,
 447                       0x68, 0x69, 0x63, 0x6b, 0x65, 0x6e, 0x2c, 0x20,
 448                       0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x2c, 0x20,
 449                       0x61, 0x6e, 0x64, 0x20, 0x77, 0x6f, 0x6e, 0x74,
 450                       0x6f, 0x6e, 0x20, 0x73, 0x6f, 0x75, 0x70, 0x2e
 451 );
 452 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test6_expected_result,
 453                       0x97, 0x68, 0x72, 0x68, 0xd6, 0xec, 0xcc, 0xc0,
 454                       0xc0, 0x7b, 0x25, 0xe2, 0x5e, 0xcf, 0xe5, 0x84,
 455                       0x39, 0x31, 0x25, 0x23, 0xa7, 0x86, 0x62, 0xd5,
 456                       0xbe, 0x7f, 0xcb, 0xcc, 0x98, 0xeb, 0xf5, 0xa8,
 457                       0x48, 0x07, 0xef, 0xe8, 0x36, 0xee, 0x89, 0xa5,
 458                       0x26, 0x73, 0x0d, 0xbc, 0x2f, 0x7b, 0xc8, 0x40,
 459                       0x9d, 0xad, 0x8b, 0xbb, 0x96, 0xc4, 0xcd, 0xc0,
 460                       0x3b, 0xc1, 0x03, 0xe1, 0xa1, 0x94, 0xbb, 0xd8
 461 );
 462 DEFINE_HEX_XDR_NETOBJ(rfc3962_enc_test6_next_iv,
 463                       0x48, 0x07, 0xef, 0xe8, 0x36, 0xee, 0x89, 0xa5,
 464                       0x26, 0x73, 0x0d, 0xbc, 0x2f, 0x7b, 0xc8, 0x40
 465 );
 466
 467 static const struct gss_krb5_test_param rfc3962_encrypt_test_params[] = {
 468         {
 469                 .desc                   = "Encrypt with aes128-cts-hmac-sha1-96 case 1",
 470                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
 471                 .Ke                     = &rfc3962_encryption_key,
 472                 .plaintext              = &rfc3962_enc_test1_plaintext,
 473                 .expected_result        = &rfc3962_enc_test1_expected_result,
 474                 .next_iv                = &rfc3962_enc_test1_next_iv,
 475         },
 476         {
 477                 .desc                   = "Encrypt with aes128-cts-hmac-sha1-96 case 2",
 478                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
 479                 .Ke                     = &rfc3962_encryption_key,
 480                 .plaintext              = &rfc3962_enc_test2_plaintext,
 481                 .expected_result        = &rfc3962_enc_test2_expected_result,
 482                 .next_iv                = &rfc3962_enc_test2_next_iv,
 483         },
 484         {
 485                 .desc                   = "Encrypt with aes128-cts-hmac-sha1-96 case 3",
 486                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
 487                 .Ke                     = &rfc3962_encryption_key,
 488                 .plaintext              = &rfc3962_enc_test3_plaintext,
 489                 .expected_result        = &rfc3962_enc_test3_expected_result,
 490                 .next_iv                = &rfc3962_enc_test3_next_iv,
 491         },
 492         {
 493                 .desc                   = "Encrypt with aes128-cts-hmac-sha1-96 case 4",
 494                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
 495                 .Ke                     = &rfc3962_encryption_key,
 496                 .plaintext              = &rfc3962_enc_test4_plaintext,
 497                 .expected_result        = &rfc3962_enc_test4_expected_result,
 498                 .next_iv                = &rfc3962_enc_test4_next_iv,
 499         },
 500         {
 501                 .desc                   = "Encrypt with aes128-cts-hmac-sha1-96 case 5",
 502                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
 503                 .Ke                     = &rfc3962_encryption_key,
 504                 .plaintext              = &rfc3962_enc_test5_plaintext,
 505                 .expected_result        = &rfc3962_enc_test5_expected_result,
 506                 .next_iv                = &rfc3962_enc_test5_next_iv,
 507         },
 508         {
 509                 .desc                   = "Encrypt with aes128-cts-hmac-sha1-96 case 6",
 510                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
 511                 .Ke                     = &rfc3962_encryption_key,
 512                 .plaintext              = &rfc3962_enc_test6_plaintext,
 513                 .expected_result        = &rfc3962_enc_test6_expected_result,
 514                 .next_iv                = &rfc3962_enc_test6_next_iv,
 515         },
 516 };
 517
 518 /* Creates the function rfc3962_encrypt_gen_params */
 519 KUNIT_ARRAY_PARAM(rfc3962_encrypt, rfc3962_encrypt_test_params,
 520                   gss_krb5_get_desc);
 521
 522 /*
 523  * This tests the implementation of the encryption part of the mechanism.
 524  * It does not apply a confounder or test the result of HMAC over the
 525  * plaintext.
 526  */
 527 static void rfc3962_encrypt_case(struct kunit *test)
 528 {
 529         const struct gss_krb5_test_param *param = test->param_value;
 530         struct crypto_sync_skcipher *cts_tfm, *cbc_tfm;
 531         const struct gss_krb5_enctype *gk5e;
 532         struct xdr_buf buf;
 533         void *iv, *text;
 534         u32 err;
 535
 536         /* Arrange */
 537         gk5e = gss_krb5_lookup_enctype(param->enctype);
 538         if (!gk5e)
 539                 kunit_skip(test, "Encryption type is not available");
 540
 541         cbc_tfm = crypto_alloc_sync_skcipher(gk5e->aux_cipher, 0, 0);
 542         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cbc_tfm);
 543         err = crypto_sync_skcipher_setkey(cbc_tfm, param->Ke->data, param->Ke->len);
 544         KUNIT_ASSERT_EQ(test, err, 0);
 545
 546         cts_tfm = crypto_alloc_sync_skcipher(gk5e->encrypt_name, 0, 0);
 547         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cts_tfm);
 548         err = crypto_sync_skcipher_setkey(cts_tfm, param->Ke->data, param->Ke->len);
 549         KUNIT_ASSERT_EQ(test, err, 0);
 550
 551         iv = kunit_kzalloc(test, crypto_sync_skcipher_ivsize(cts_tfm), GFP_KERNEL);
 552         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, iv);
 553
 554         text = kunit_kzalloc(test, param->plaintext->len, GFP_KERNEL);
 555         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, text);
 556
 557         memcpy(text, param->plaintext->data, param->plaintext->len);
 558         memset(&buf, 0, sizeof(buf));
 559         buf.head[0].iov_base = text;
 560         buf.head[0].iov_len = param->plaintext->len;
 561         buf.len = buf.head[0].iov_len;
 562
 563         /* Act */
 564         err = krb5_cbc_cts_encrypt(cts_tfm, cbc_tfm, 0, &buf, NULL,
 565                                    iv, crypto_sync_skcipher_ivsize(cts_tfm));
 566         KUNIT_ASSERT_EQ(test, err, 0);
 567
 568         /* Assert */
 569         KUNIT_EXPECT_EQ_MSG(test,
 570                             param->expected_result->len, buf.len,
 571                             "ciphertext length mismatch");
 572         KUNIT_EXPECT_EQ_MSG(test,
 573                             memcmp(param->expected_result->data,
 574                                    text, param->expected_result->len), 0,
 575                             "ciphertext mismatch");
 576         KUNIT_EXPECT_EQ_MSG(test,
 577                             memcmp(param->next_iv->data, iv,
 578                                    param->next_iv->len), 0,
 579                             "IV mismatch");
 580
 581         crypto_free_sync_skcipher(cts_tfm);
 582         crypto_free_sync_skcipher(cbc_tfm);
 583 }
 584
 585 static struct kunit_case rfc3962_test_cases[] = {
 586         {
 587                 .name                   = "RFC 3962 encryption",
 588                 .run_case               = rfc3962_encrypt_case,
 589                 .generate_params        = rfc3962_encrypt_gen_params,
 590         },
 591         {}
 592 };
 593
 594 static struct kunit_suite rfc3962_suite = {
 595         .name                   = "RFC 3962 suite",
 596         .test_cases             = rfc3962_test_cases,
 597 };
 598
 599 /*
 600  * From RFC 6803 Section 10.  Test vectors
 601  *
 602  * Sample results for key derivation
 603  *
 604  * Copyright (c) 2012 IETF Trust and the persons identified as the
 605  * document authors.  All rights reserved.
 606  */
 607
 608 DEFINE_HEX_XDR_NETOBJ(camellia128_cts_cmac_basekey,
 609                       0x57, 0xd0, 0x29, 0x72, 0x98, 0xff, 0xd9, 0xd3,
 610                       0x5d, 0xe5, 0xa4, 0x7f, 0xb4, 0xbd, 0xe2, 0x4b
 611 );
 612 DEFINE_HEX_XDR_NETOBJ(camellia128_cts_cmac_Kc,
 613                       0xd1, 0x55, 0x77, 0x5a, 0x20, 0x9d, 0x05, 0xf0,
 614                       0x2b, 0x38, 0xd4, 0x2a, 0x38, 0x9e, 0x5a, 0x56
 615 );
 616 DEFINE_HEX_XDR_NETOBJ(camellia128_cts_cmac_Ke,
 617                       0x64, 0xdf, 0x83, 0xf8, 0x5a, 0x53, 0x2f, 0x17,
 618                       0x57, 0x7d, 0x8c, 0x37, 0x03, 0x57, 0x96, 0xab
 619 );
 620 DEFINE_HEX_XDR_NETOBJ(camellia128_cts_cmac_Ki,
 621                       0x3e, 0x4f, 0xbd, 0xf3, 0x0f, 0xb8, 0x25, 0x9c,
 622                       0x42, 0x5c, 0xb6, 0xc9, 0x6f, 0x1f, 0x46, 0x35
 623 );
 624
 625 DEFINE_HEX_XDR_NETOBJ(camellia256_cts_cmac_basekey,
 626                       0xb9, 0xd6, 0x82, 0x8b, 0x20, 0x56, 0xb7, 0xbe,
 627                       0x65, 0x6d, 0x88, 0xa1, 0x23, 0xb1, 0xfa, 0xc6,
 628                       0x82, 0x14, 0xac, 0x2b, 0x72, 0x7e, 0xcf, 0x5f,
 629                       0x69, 0xaf, 0xe0, 0xc4, 0xdf, 0x2a, 0x6d, 0x2c
 630 );
 631 DEFINE_HEX_XDR_NETOBJ(camellia256_cts_cmac_Kc,
 632                       0xe4, 0x67, 0xf9, 0xa9, 0x55, 0x2b, 0xc7, 0xd3,
 633                       0x15, 0x5a, 0x62, 0x20, 0xaf, 0x9c, 0x19, 0x22,
 634                       0x0e, 0xee, 0xd4, 0xff, 0x78, 0xb0, 0xd1, 0xe6,
 635                       0xa1, 0x54, 0x49, 0x91, 0x46, 0x1a, 0x9e, 0x50
 636 );
 637 DEFINE_HEX_XDR_NETOBJ(camellia256_cts_cmac_Ke,
 638                       0x41, 0x2a, 0xef, 0xc3, 0x62, 0xa7, 0x28, 0x5f,
 639                       0xc3, 0x96, 0x6c, 0x6a, 0x51, 0x81, 0xe7, 0x60,
 640                       0x5a, 0xe6, 0x75, 0x23, 0x5b, 0x6d, 0x54, 0x9f,
 641                       0xbf, 0xc9, 0xab, 0x66, 0x30, 0xa4, 0xc6, 0x04
 642 );
 643 DEFINE_HEX_XDR_NETOBJ(camellia256_cts_cmac_Ki,
 644                       0xfa, 0x62, 0x4f, 0xa0, 0xe5, 0x23, 0x99, 0x3f,
 645                       0xa3, 0x88, 0xae, 0xfd, 0xc6, 0x7e, 0x67, 0xeb,
 646                       0xcd, 0x8c, 0x08, 0xe8, 0xa0, 0x24, 0x6b, 0x1d,
 647                       0x73, 0xb0, 0xd1, 0xdd, 0x9f, 0xc5, 0x82, 0xb0
 648 );
 649
 650 DEFINE_HEX_XDR_NETOBJ(usage_checksum,
 651                       0x00, 0x00, 0x00, 0x02, KEY_USAGE_SEED_CHECKSUM
 652 );
 653 DEFINE_HEX_XDR_NETOBJ(usage_encryption,
 654                       0x00, 0x00, 0x00, 0x02, KEY_USAGE_SEED_ENCRYPTION
 655 );
 656 DEFINE_HEX_XDR_NETOBJ(usage_integrity,
 657                       0x00, 0x00, 0x00, 0x02, KEY_USAGE_SEED_INTEGRITY
 658 );
 659
 660 static const struct gss_krb5_test_param rfc6803_kdf_test_params[] = {
 661         {
 662                 .desc                   = "Derive Kc subkey for camellia128-cts-cmac",
 663                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
 664                 .base_key               = &camellia128_cts_cmac_basekey,
 665                 .usage                  = &usage_checksum,
 666                 .expected_result        = &camellia128_cts_cmac_Kc,
 667         },
 668         {
 669                 .desc                   = "Derive Ke subkey for camellia128-cts-cmac",
 670                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
 671                 .base_key               = &camellia128_cts_cmac_basekey,
 672                 .usage                  = &usage_encryption,
 673                 .expected_result        = &camellia128_cts_cmac_Ke,
 674         },
 675         {
 676                 .desc                   = "Derive Ki subkey for camellia128-cts-cmac",
 677                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
 678                 .base_key               = &camellia128_cts_cmac_basekey,
 679                 .usage                  = &usage_integrity,
 680                 .expected_result        = &camellia128_cts_cmac_Ki,
 681         },
 682         {
 683                 .desc                   = "Derive Kc subkey for camellia256-cts-cmac",
 684                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
 685                 .base_key               = &camellia256_cts_cmac_basekey,
 686                 .usage                  = &usage_checksum,
 687                 .expected_result        = &camellia256_cts_cmac_Kc,
 688         },
 689         {
 690                 .desc                   = "Derive Ke subkey for camellia256-cts-cmac",
 691                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
 692                 .base_key               = &camellia256_cts_cmac_basekey,
 693                 .usage                  = &usage_encryption,
 694                 .expected_result        = &camellia256_cts_cmac_Ke,
 695         },
 696         {
 697                 .desc                   = "Derive Ki subkey for camellia256-cts-cmac",
 698                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
 699                 .base_key               = &camellia256_cts_cmac_basekey,
 700                 .usage                  = &usage_integrity,
 701                 .expected_result        = &camellia256_cts_cmac_Ki,
 702         },
 703 };
 704
 705 /* Creates the function rfc6803_kdf_gen_params */
 706 KUNIT_ARRAY_PARAM(rfc6803_kdf, rfc6803_kdf_test_params, gss_krb5_get_desc);
 707
 708 /*
 709  * From RFC 6803 Section 10.  Test vectors
 710  *
 711  * Sample checksums.
 712  *
 713  * Copyright (c) 2012 IETF Trust and the persons identified as the
 714  * document authors.  All rights reserved.
 715  *
 716  * XXX: These tests are likely to fail on EBCDIC or Unicode platforms.
 717  */
 718 DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test1_plaintext,
 719                       "abcdefghijk");
 720 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test1_basekey,
 721                       0x1d, 0xc4, 0x6a, 0x8d, 0x76, 0x3f, 0x4f, 0x93,
 722                       0x74, 0x2b, 0xcb, 0xa3, 0x38, 0x75, 0x76, 0xc3
 723 );
 724 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test1_usage,
 725                       0x00, 0x00, 0x00, 0x07, KEY_USAGE_SEED_CHECKSUM
 726 );
 727 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test1_expected_result,
 728                       0x11, 0x78, 0xe6, 0xc5, 0xc4, 0x7a, 0x8c, 0x1a,
 729                       0xe0, 0xc4, 0xb9, 0xc7, 0xd4, 0xeb, 0x7b, 0x6b
 730 );
 731
 732 DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test2_plaintext,
 733                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 734 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test2_basekey,
 735                       0x50, 0x27, 0xbc, 0x23, 0x1d, 0x0f, 0x3a, 0x9d,
 736                       0x23, 0x33, 0x3f, 0x1c, 0xa6, 0xfd, 0xbe, 0x7c
 737 );
 738 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test2_usage,
 739                       0x00, 0x00, 0x00, 0x08, KEY_USAGE_SEED_CHECKSUM
 740 );
 741 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test2_expected_result,
 742                       0xd1, 0xb3, 0x4f, 0x70, 0x04, 0xa7, 0x31, 0xf2,
 743                       0x3a, 0x0c, 0x00, 0xbf, 0x6c, 0x3f, 0x75, 0x3a
 744 );
 745
 746 DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test3_plaintext,
 747                       "123456789");
 748 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test3_basekey,
 749                       0xb6, 0x1c, 0x86, 0xcc, 0x4e, 0x5d, 0x27, 0x57,
 750                       0x54, 0x5a, 0xd4, 0x23, 0x39, 0x9f, 0xb7, 0x03,
 751                       0x1e, 0xca, 0xb9, 0x13, 0xcb, 0xb9, 0x00, 0xbd,
 752                       0x7a, 0x3c, 0x6d, 0xd8, 0xbf, 0x92, 0x01, 0x5b
 753 );
 754 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test3_usage,
 755                       0x00, 0x00, 0x00, 0x09, KEY_USAGE_SEED_CHECKSUM
 756 );
 757 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test3_expected_result,
 758                       0x87, 0xa1, 0x2c, 0xfd, 0x2b, 0x96, 0x21, 0x48,
 759                       0x10, 0xf0, 0x1c, 0x82, 0x6e, 0x77, 0x44, 0xb1
 760 );
 761
 762 DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test4_plaintext,
 763                       "!@#$%^&*()!@#$%^&*()!@#$%^&*()");
 764 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test4_basekey,
 765                       0x32, 0x16, 0x4c, 0x5b, 0x43, 0x4d, 0x1d, 0x15,
 766                       0x38, 0xe4, 0xcf, 0xd9, 0xbe, 0x80, 0x40, 0xfe,
 767                       0x8c, 0x4a, 0xc7, 0xac, 0xc4, 0xb9, 0x3d, 0x33,
 768                       0x14, 0xd2, 0x13, 0x36, 0x68, 0x14, 0x7a, 0x05
 769 );
 770 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test4_usage,
 771                       0x00, 0x00, 0x00, 0x0a, KEY_USAGE_SEED_CHECKSUM
 772 );
 773 DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test4_expected_result,
 774                       0x3f, 0xa0, 0xb4, 0x23, 0x55, 0xe5, 0x2b, 0x18,
 775                       0x91, 0x87, 0x29, 0x4a, 0xa2, 0x52, 0xab, 0x64
 776 );
 777
 778 static const struct gss_krb5_test_param rfc6803_checksum_test_params[] = {
 779         {
 780                 .desc                   = "camellia128-cts-cmac checksum test 1",
 781                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
 782                 .base_key               = &rfc6803_checksum_test1_basekey,
 783                 .usage                  = &rfc6803_checksum_test1_usage,
 784                 .plaintext              = &rfc6803_checksum_test1_plaintext,
 785                 .expected_result        = &rfc6803_checksum_test1_expected_result,
 786         },
 787         {
 788                 .desc                   = "camellia128-cts-cmac checksum test 2",
 789                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
 790                 .base_key               = &rfc6803_checksum_test2_basekey,
 791                 .usage                  = &rfc6803_checksum_test2_usage,
 792                 .plaintext              = &rfc6803_checksum_test2_plaintext,
 793                 .expected_result        = &rfc6803_checksum_test2_expected_result,
 794         },
 795         {
 796                 .desc                   = "camellia256-cts-cmac checksum test 3",
 797                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
 798                 .base_key               = &rfc6803_checksum_test3_basekey,
 799                 .usage                  = &rfc6803_checksum_test3_usage,
 800                 .plaintext              = &rfc6803_checksum_test3_plaintext,
 801                 .expected_result        = &rfc6803_checksum_test3_expected_result,
 802         },
 803         {
 804                 .desc                   = "camellia256-cts-cmac checksum test 4",
 805                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
 806                 .base_key               = &rfc6803_checksum_test4_basekey,
 807                 .usage                  = &rfc6803_checksum_test4_usage,
 808                 .plaintext              = &rfc6803_checksum_test4_plaintext,
 809                 .expected_result        = &rfc6803_checksum_test4_expected_result,
 810         },
 811 };
 812
 813 /* Creates the function rfc6803_checksum_gen_params */
 814 KUNIT_ARRAY_PARAM(rfc6803_checksum, rfc6803_checksum_test_params,
 815                   gss_krb5_get_desc);
 816
 817 /*
 818  * From RFC 6803 Section 10.  Test vectors
 819  *
 820  * Sample encryptions (all using the default cipher state)
 821  *
 822  * Copyright (c) 2012 IETF Trust and the persons identified as the
 823  * document authors.  All rights reserved.
 824  *
 825  * Key usage values are from errata 4326 against RFC 6803.
 826  */
 827
 828 static const struct xdr_netobj rfc6803_enc_empty_plaintext = {
 829         .len    = 0,
 830 };
 831
 832 DEFINE_STR_XDR_NETOBJ(rfc6803_enc_1byte_plaintext, "1");
 833 DEFINE_STR_XDR_NETOBJ(rfc6803_enc_9byte_plaintext, "9 bytesss");
 834 DEFINE_STR_XDR_NETOBJ(rfc6803_enc_13byte_plaintext, "13 bytes byte");
 835 DEFINE_STR_XDR_NETOBJ(rfc6803_enc_30byte_plaintext,
 836                       "30 bytes bytes bytes bytes byt"
 837 );
 838
 839 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test1_confounder,
 840                       0xb6, 0x98, 0x22, 0xa1, 0x9a, 0x6b, 0x09, 0xc0,
 841                       0xeb, 0xc8, 0x55, 0x7d, 0x1f, 0x1b, 0x6c, 0x0a
 842 );
 843 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test1_basekey,
 844                       0x1d, 0xc4, 0x6a, 0x8d, 0x76, 0x3f, 0x4f, 0x93,
 845                       0x74, 0x2b, 0xcb, 0xa3, 0x38, 0x75, 0x76, 0xc3
 846 );
 847 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test1_expected_result,
 848                       0xc4, 0x66, 0xf1, 0x87, 0x10, 0x69, 0x92, 0x1e,
 849                       0xdb, 0x7c, 0x6f, 0xde, 0x24, 0x4a, 0x52, 0xdb,
 850                       0x0b, 0xa1, 0x0e, 0xdc, 0x19, 0x7b, 0xdb, 0x80,
 851                       0x06, 0x65, 0x8c, 0xa3, 0xcc, 0xce, 0x6e, 0xb8
 852 );
 853
 854 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test2_confounder,
 855                       0x6f, 0x2f, 0xc3, 0xc2, 0xa1, 0x66, 0xfd, 0x88,
 856                       0x98, 0x96, 0x7a, 0x83, 0xde, 0x95, 0x96, 0xd9
 857 );
 858 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test2_basekey,
 859                       0x50, 0x27, 0xbc, 0x23, 0x1d, 0x0f, 0x3a, 0x9d,
 860                       0x23, 0x33, 0x3f, 0x1c, 0xa6, 0xfd, 0xbe, 0x7c
 861 );
 862 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test2_expected_result,
 863                       0x84, 0x2d, 0x21, 0xfd, 0x95, 0x03, 0x11, 0xc0,
 864                       0xdd, 0x46, 0x4a, 0x3f, 0x4b, 0xe8, 0xd6, 0xda,
 865                       0x88, 0xa5, 0x6d, 0x55, 0x9c, 0x9b, 0x47, 0xd3,
 866                       0xf9, 0xa8, 0x50, 0x67, 0xaf, 0x66, 0x15, 0x59,
 867                       0xb8
 868 );
 869
 870 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test3_confounder,
 871                       0xa5, 0xb4, 0xa7, 0x1e, 0x07, 0x7a, 0xee, 0xf9,
 872                       0x3c, 0x87, 0x63, 0xc1, 0x8f, 0xdb, 0x1f, 0x10
 873 );
 874 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test3_basekey,
 875                       0xa1, 0xbb, 0x61, 0xe8, 0x05, 0xf9, 0xba, 0x6d,
 876                       0xde, 0x8f, 0xdb, 0xdd, 0xc0, 0x5c, 0xde, 0xa0
 877 );
 878 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test3_expected_result,
 879                       0x61, 0x9f, 0xf0, 0x72, 0xe3, 0x62, 0x86, 0xff,
 880                       0x0a, 0x28, 0xde, 0xb3, 0xa3, 0x52, 0xec, 0x0d,
 881                       0x0e, 0xdf, 0x5c, 0x51, 0x60, 0xd6, 0x63, 0xc9,
 882                       0x01, 0x75, 0x8c, 0xcf, 0x9d, 0x1e, 0xd3, 0x3d,
 883                       0x71, 0xdb, 0x8f, 0x23, 0xaa, 0xbf, 0x83, 0x48,
 884                       0xa0
 885 );
 886
 887 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test4_confounder,
 888                       0x19, 0xfe, 0xe4, 0x0d, 0x81, 0x0c, 0x52, 0x4b,
 889                       0x5b, 0x22, 0xf0, 0x18, 0x74, 0xc6, 0x93, 0xda
 890 );
 891 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test4_basekey,
 892                       0x2c, 0xa2, 0x7a, 0x5f, 0xaf, 0x55, 0x32, 0x24,
 893                       0x45, 0x06, 0x43, 0x4e, 0x1c, 0xef, 0x66, 0x76
 894 );
 895 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test4_expected_result,
 896                       0xb8, 0xec, 0xa3, 0x16, 0x7a, 0xe6, 0x31, 0x55,
 897                       0x12, 0xe5, 0x9f, 0x98, 0xa7, 0xc5, 0x00, 0x20,
 898                       0x5e, 0x5f, 0x63, 0xff, 0x3b, 0xb3, 0x89, 0xaf,
 899                       0x1c, 0x41, 0xa2, 0x1d, 0x64, 0x0d, 0x86, 0x15,
 900                       0xc9, 0xed, 0x3f, 0xbe, 0xb0, 0x5a, 0xb6, 0xac,
 901                       0xb6, 0x76, 0x89, 0xb5, 0xea
 902 );
 903
 904 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test5_confounder,
 905                       0xca, 0x7a, 0x7a, 0xb4, 0xbe, 0x19, 0x2d, 0xab,
 906                       0xd6, 0x03, 0x50, 0x6d, 0xb1, 0x9c, 0x39, 0xe2
 907 );
 908 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test5_basekey,
 909                       0x78, 0x24, 0xf8, 0xc1, 0x6f, 0x83, 0xff, 0x35,
 910                       0x4c, 0x6b, 0xf7, 0x51, 0x5b, 0x97, 0x3f, 0x43
 911 );
 912 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test5_expected_result,
 913                       0xa2, 0x6a, 0x39, 0x05, 0xa4, 0xff, 0xd5, 0x81,
 914                       0x6b, 0x7b, 0x1e, 0x27, 0x38, 0x0d, 0x08, 0x09,
 915                       0x0c, 0x8e, 0xc1, 0xf3, 0x04, 0x49, 0x6e, 0x1a,
 916                       0xbd, 0xcd, 0x2b, 0xdc, 0xd1, 0xdf, 0xfc, 0x66,
 917                       0x09, 0x89, 0xe1, 0x17, 0xa7, 0x13, 0xdd, 0xbb,
 918                       0x57, 0xa4, 0x14, 0x6c, 0x15, 0x87, 0xcb, 0xa4,
 919                       0x35, 0x66, 0x65, 0x59, 0x1d, 0x22, 0x40, 0x28,
 920                       0x2f, 0x58, 0x42, 0xb1, 0x05, 0xa5
 921 );
 922
 923 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test6_confounder,
 924                       0x3c, 0xbb, 0xd2, 0xb4, 0x59, 0x17, 0x94, 0x10,
 925                       0x67, 0xf9, 0x65, 0x99, 0xbb, 0x98, 0x92, 0x6c
 926 );
 927 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test6_basekey,
 928                       0xb6, 0x1c, 0x86, 0xcc, 0x4e, 0x5d, 0x27, 0x57,
 929                       0x54, 0x5a, 0xd4, 0x23, 0x39, 0x9f, 0xb7, 0x03,
 930                       0x1e, 0xca, 0xb9, 0x13, 0xcb, 0xb9, 0x00, 0xbd,
 931                       0x7a, 0x3c, 0x6d, 0xd8, 0xbf, 0x92, 0x01, 0x5b
 932 );
 933 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test6_expected_result,
 934                       0x03, 0x88, 0x6d, 0x03, 0x31, 0x0b, 0x47, 0xa6,
 935                       0xd8, 0xf0, 0x6d, 0x7b, 0x94, 0xd1, 0xdd, 0x83,
 936                       0x7e, 0xcc, 0xe3, 0x15, 0xef, 0x65, 0x2a, 0xff,
 937                       0x62, 0x08, 0x59, 0xd9, 0x4a, 0x25, 0x92, 0x66
 938 );
 939
 940 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test7_confounder,
 941                       0xde, 0xf4, 0x87, 0xfc, 0xeb, 0xe6, 0xde, 0x63,
 942                       0x46, 0xd4, 0xda, 0x45, 0x21, 0xbb, 0xa2, 0xd2
 943 );
 944 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test7_basekey,
 945                       0x1b, 0x97, 0xfe, 0x0a, 0x19, 0x0e, 0x20, 0x21,
 946                       0xeb, 0x30, 0x75, 0x3e, 0x1b, 0x6e, 0x1e, 0x77,
 947                       0xb0, 0x75, 0x4b, 0x1d, 0x68, 0x46, 0x10, 0x35,
 948                       0x58, 0x64, 0x10, 0x49, 0x63, 0x46, 0x38, 0x33
 949 );
 950 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test7_expected_result,
 951                       0x2c, 0x9c, 0x15, 0x70, 0x13, 0x3c, 0x99, 0xbf,
 952                       0x6a, 0x34, 0xbc, 0x1b, 0x02, 0x12, 0x00, 0x2f,
 953                       0xd1, 0x94, 0x33, 0x87, 0x49, 0xdb, 0x41, 0x35,
 954                       0x49, 0x7a, 0x34, 0x7c, 0xfc, 0xd9, 0xd1, 0x8a,
 955                       0x12
 956 );
 957
 958 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test8_confounder,
 959                       0xad, 0x4f, 0xf9, 0x04, 0xd3, 0x4e, 0x55, 0x53,
 960                       0x84, 0xb1, 0x41, 0x00, 0xfc, 0x46, 0x5f, 0x88
 961 );
 962 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test8_basekey,
 963                       0x32, 0x16, 0x4c, 0x5b, 0x43, 0x4d, 0x1d, 0x15,
 964                       0x38, 0xe4, 0xcf, 0xd9, 0xbe, 0x80, 0x40, 0xfe,
 965                       0x8c, 0x4a, 0xc7, 0xac, 0xc4, 0xb9, 0x3d, 0x33,
 966                       0x14, 0xd2, 0x13, 0x36, 0x68, 0x14, 0x7a, 0x05
 967 );
 968 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test8_expected_result,
 969                       0x9c, 0x6d, 0xe7, 0x5f, 0x81, 0x2d, 0xe7, 0xed,
 970                       0x0d, 0x28, 0xb2, 0x96, 0x35, 0x57, 0xa1, 0x15,
 971                       0x64, 0x09, 0x98, 0x27, 0x5b, 0x0a, 0xf5, 0x15,
 972                       0x27, 0x09, 0x91, 0x3f, 0xf5, 0x2a, 0x2a, 0x9c,
 973                       0x8e, 0x63, 0xb8, 0x72, 0xf9, 0x2e, 0x64, 0xc8,
 974                       0x39
 975 );
 976
 977 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test9_confounder,
 978                       0xcf, 0x9b, 0xca, 0x6d, 0xf1, 0x14, 0x4e, 0x0c,
 979                       0x0a, 0xf9, 0xb8, 0xf3, 0x4c, 0x90, 0xd5, 0x14
 980 );
 981 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test9_basekey,
 982                       0xb0, 0x38, 0xb1, 0x32, 0xcd, 0x8e, 0x06, 0x61,
 983                       0x22, 0x67, 0xfa, 0xb7, 0x17, 0x00, 0x66, 0xd8,
 984                       0x8a, 0xec, 0xcb, 0xa0, 0xb7, 0x44, 0xbf, 0xc6,
 985                       0x0d, 0xc8, 0x9b, 0xca, 0x18, 0x2d, 0x07, 0x15
 986 );
 987 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test9_expected_result,
 988                       0xee, 0xec, 0x85, 0xa9, 0x81, 0x3c, 0xdc, 0x53,
 989                       0x67, 0x72, 0xab, 0x9b, 0x42, 0xde, 0xfc, 0x57,
 990                       0x06, 0xf7, 0x26, 0xe9, 0x75, 0xdd, 0xe0, 0x5a,
 991                       0x87, 0xeb, 0x54, 0x06, 0xea, 0x32, 0x4c, 0xa1,
 992                       0x85, 0xc9, 0x98, 0x6b, 0x42, 0xaa, 0xbe, 0x79,
 993                       0x4b, 0x84, 0x82, 0x1b, 0xee
 994 );
 995
 996 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test10_confounder,
 997                       0x64, 0x4d, 0xef, 0x38, 0xda, 0x35, 0x00, 0x72,
 998                       0x75, 0x87, 0x8d, 0x21, 0x68, 0x55, 0xe2, 0x28
 999 );
1000 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test10_basekey,
1001                       0xcc, 0xfc, 0xd3, 0x49, 0xbf, 0x4c, 0x66, 0x77,
1002                       0xe8, 0x6e, 0x4b, 0x02, 0xb8, 0xea, 0xb9, 0x24,
1003                       0xa5, 0x46, 0xac, 0x73, 0x1c, 0xf9, 0xbf, 0x69,
1004                       0x89, 0xb9, 0x96, 0xe7, 0xd6, 0xbf, 0xbb, 0xa7
1005 );
1006 DEFINE_HEX_XDR_NETOBJ(rfc6803_enc_test10_expected_result,
1007                       0x0e, 0x44, 0x68, 0x09, 0x85, 0x85, 0x5f, 0x2d,
1008                       0x1f, 0x18, 0x12, 0x52, 0x9c, 0xa8, 0x3b, 0xfd,
1009                       0x8e, 0x34, 0x9d, 0xe6, 0xfd, 0x9a, 0xda, 0x0b,
1010                       0xaa, 0xa0, 0x48, 0xd6, 0x8e, 0x26, 0x5f, 0xeb,
1011                       0xf3, 0x4a, 0xd1, 0x25, 0x5a, 0x34, 0x49, 0x99,
1012                       0xad, 0x37, 0x14, 0x68, 0x87, 0xa6, 0xc6, 0x84,
1013                       0x57, 0x31, 0xac, 0x7f, 0x46, 0x37, 0x6a, 0x05,
1014                       0x04, 0xcd, 0x06, 0x57, 0x14, 0x74
1015 );
1016
1017 static const struct gss_krb5_test_param rfc6803_encrypt_test_params[] = {
1018         {
1019                 .desc                   = "Encrypt empty plaintext with camellia128-cts-cmac",
1020                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
1021                 .constant               = 0,
1022                 .base_key               = &rfc6803_enc_test1_basekey,
1023                 .plaintext              = &rfc6803_enc_empty_plaintext,
1024                 .confounder             = &rfc6803_enc_test1_confounder,
1025                 .expected_result        = &rfc6803_enc_test1_expected_result,
1026         },
1027         {
1028                 .desc                   = "Encrypt 1 byte with camellia128-cts-cmac",
1029                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
1030                 .constant               = 1,
1031                 .base_key               = &rfc6803_enc_test2_basekey,
1032                 .plaintext              = &rfc6803_enc_1byte_plaintext,
1033                 .confounder             = &rfc6803_enc_test2_confounder,
1034                 .expected_result        = &rfc6803_enc_test2_expected_result,
1035         },
1036         {
1037                 .desc                   = "Encrypt 9 bytes with camellia128-cts-cmac",
1038                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
1039                 .constant               = 2,
1040                 .base_key               = &rfc6803_enc_test3_basekey,
1041                 .plaintext              = &rfc6803_enc_9byte_plaintext,
1042                 .confounder             = &rfc6803_enc_test3_confounder,
1043                 .expected_result        = &rfc6803_enc_test3_expected_result,
1044         },
1045         {
1046                 .desc                   = "Encrypt 13 bytes with camellia128-cts-cmac",
1047                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
1048                 .constant               = 3,
1049                 .base_key               = &rfc6803_enc_test4_basekey,
1050                 .plaintext              = &rfc6803_enc_13byte_plaintext,
1051                 .confounder             = &rfc6803_enc_test4_confounder,
1052                 .expected_result        = &rfc6803_enc_test4_expected_result,
1053         },
1054         {
1055                 .desc                   = "Encrypt 30 bytes with camellia128-cts-cmac",
1056                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
1057                 .constant               = 4,
1058                 .base_key               = &rfc6803_enc_test5_basekey,
1059                 .plaintext              = &rfc6803_enc_30byte_plaintext,
1060                 .confounder             = &rfc6803_enc_test5_confounder,
1061                 .expected_result        = &rfc6803_enc_test5_expected_result,
1062         },
1063         {
1064                 .desc                   = "Encrypt empty plaintext with camellia256-cts-cmac",
1065                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
1066                 .constant               = 0,
1067                 .base_key               = &rfc6803_enc_test6_basekey,
1068                 .plaintext              = &rfc6803_enc_empty_plaintext,
1069                 .confounder             = &rfc6803_enc_test6_confounder,
1070                 .expected_result        = &rfc6803_enc_test6_expected_result,
1071         },
1072         {
1073                 .desc                   = "Encrypt 1 byte with camellia256-cts-cmac",
1074                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
1075                 .constant               = 1,
1076                 .base_key               = &rfc6803_enc_test7_basekey,
1077                 .plaintext              = &rfc6803_enc_1byte_plaintext,
1078                 .confounder             = &rfc6803_enc_test7_confounder,
1079                 .expected_result        = &rfc6803_enc_test7_expected_result,
1080         },
1081         {
1082                 .desc                   = "Encrypt 9 bytes with camellia256-cts-cmac",
1083                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
1084                 .constant               = 2,
1085                 .base_key               = &rfc6803_enc_test8_basekey,
1086                 .plaintext              = &rfc6803_enc_9byte_plaintext,
1087                 .confounder             = &rfc6803_enc_test8_confounder,
1088                 .expected_result        = &rfc6803_enc_test8_expected_result,
1089         },
1090         {
1091                 .desc                   = "Encrypt 13 bytes with camellia256-cts-cmac",
1092                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
1093                 .constant               = 3,
1094                 .base_key               = &rfc6803_enc_test9_basekey,
1095                 .plaintext              = &rfc6803_enc_13byte_plaintext,
1096                 .confounder             = &rfc6803_enc_test9_confounder,
1097                 .expected_result        = &rfc6803_enc_test9_expected_result,
1098         },
1099         {
1100                 .desc                   = "Encrypt 30 bytes with camellia256-cts-cmac",
1101                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
1102                 .constant               = 4,
1103                 .base_key               = &rfc6803_enc_test10_basekey,
1104                 .plaintext              = &rfc6803_enc_30byte_plaintext,
1105                 .confounder             = &rfc6803_enc_test10_confounder,
1106                 .expected_result        = &rfc6803_enc_test10_expected_result,
1107         },
1108 };
1109
1110 /* Creates the function rfc6803_encrypt_gen_params */
1111 KUNIT_ARRAY_PARAM(rfc6803_encrypt, rfc6803_encrypt_test_params,
1112                   gss_krb5_get_desc);
1113
1114 static void rfc6803_encrypt_case(struct kunit *test)
1115 {
1116         const struct gss_krb5_test_param *param = test->param_value;
1117         struct crypto_sync_skcipher *cts_tfm, *cbc_tfm;
1118         const struct gss_krb5_enctype *gk5e;
1119         struct xdr_netobj Ke, Ki, checksum;
1120         u8 usage_data[GSS_KRB5_K5CLENGTH];
1121         struct xdr_netobj usage = {
1122                 .data = usage_data,
1123                 .len = sizeof(usage_data),
1124         };
1125         struct crypto_ahash *ahash_tfm;
1126         unsigned int blocksize;
1127         struct xdr_buf buf;
1128         void *text;
1129         size_t len;
1130         u32 err;
1131
1132         /* Arrange */
1133         gk5e = gss_krb5_lookup_enctype(param->enctype);
1134         if (!gk5e)
1135                 kunit_skip(test, "Encryption type is not available");
1136
1137         memset(usage_data, 0, sizeof(usage_data));
1138         usage.data[3] = param->constant;
1139
1140         Ke.len = gk5e->Ke_length;
1141         Ke.data = kunit_kzalloc(test, Ke.len, GFP_KERNEL);
1142         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, Ke.data);
1143         usage.data[4] = KEY_USAGE_SEED_ENCRYPTION;
1144         err = gk5e->derive_key(gk5e, param->base_key, &Ke, &usage, GFP_KERNEL);
1145         KUNIT_ASSERT_EQ(test, err, 0);
1146
1147         cbc_tfm = crypto_alloc_sync_skcipher(gk5e->aux_cipher, 0, 0);
1148         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cbc_tfm);
1149         err = crypto_sync_skcipher_setkey(cbc_tfm, Ke.data, Ke.len);
1150         KUNIT_ASSERT_EQ(test, err, 0);
1151
1152         cts_tfm = crypto_alloc_sync_skcipher(gk5e->encrypt_name, 0, 0);
1153         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cts_tfm);
1154         err = crypto_sync_skcipher_setkey(cts_tfm, Ke.data, Ke.len);
1155         KUNIT_ASSERT_EQ(test, err, 0);
1156         blocksize = crypto_sync_skcipher_blocksize(cts_tfm);
1157
1158         len = param->confounder->len + param->plaintext->len + blocksize;
1159         text = kunit_kzalloc(test, len, GFP_KERNEL);
1160         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, text);
1161         memcpy(text, param->confounder->data, param->confounder->len);
1162         memcpy(text + param->confounder->len, param->plaintext->data,
1163                param->plaintext->len);
1164
1165         memset(&buf, 0, sizeof(buf));
1166         buf.head[0].iov_base = text;
1167         buf.head[0].iov_len = param->confounder->len + param->plaintext->len;
1168         buf.len = buf.head[0].iov_len;
1169
1170         checksum.len = gk5e->cksumlength;
1171         checksum.data = kunit_kzalloc(test, checksum.len, GFP_KERNEL);
1172         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, checksum.data);
1173
1174         Ki.len = gk5e->Ki_length;
1175         Ki.data = kunit_kzalloc(test, Ki.len, GFP_KERNEL);
1176         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, Ki.data);
1177         usage.data[4] = KEY_USAGE_SEED_INTEGRITY;
1178         err = gk5e->derive_key(gk5e, param->base_key, &Ki,
1179                                &usage, GFP_KERNEL);
1180         KUNIT_ASSERT_EQ(test, err, 0);
1181         ahash_tfm = crypto_alloc_ahash(gk5e->cksum_name, 0, CRYPTO_ALG_ASYNC);
1182         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ahash_tfm);
1183         err = crypto_ahash_setkey(ahash_tfm, Ki.data, Ki.len);
1184         KUNIT_ASSERT_EQ(test, err, 0);
1185
1186         /* Act */
1187         err = gss_krb5_checksum(ahash_tfm, NULL, 0, &buf, 0, &checksum);
1188         KUNIT_ASSERT_EQ(test, err, 0);
1189
1190         err = krb5_cbc_cts_encrypt(cts_tfm, cbc_tfm, 0, &buf, NULL, NULL, 0);
1191         KUNIT_ASSERT_EQ(test, err, 0);
1192
1193         /* Assert */
1194         KUNIT_EXPECT_EQ_MSG(test, param->expected_result->len,
1195                             buf.len + checksum.len,
1196                             "ciphertext length mismatch");
1197         KUNIT_EXPECT_EQ_MSG(test,
1198                             memcmp(param->expected_result->data,
1199                                    buf.head[0].iov_base, buf.len), 0,
1200                             "encrypted result mismatch");
1201         KUNIT_EXPECT_EQ_MSG(test,
1202                             memcmp(param->expected_result->data +
1203                                    (param->expected_result->len - checksum.len),
1204                                    checksum.data, checksum.len), 0,
1205                             "HMAC mismatch");
1206
1207         crypto_free_ahash(ahash_tfm);
1208         crypto_free_sync_skcipher(cts_tfm);
1209         crypto_free_sync_skcipher(cbc_tfm);
1210 }
1211
1212 static struct kunit_case rfc6803_test_cases[] = {
1213         {
1214                 .name                   = "RFC 6803 key derivation",
1215                 .run_case               = kdf_case,
1216                 .generate_params        = rfc6803_kdf_gen_params,
1217         },
1218         {
1219                 .name                   = "RFC 6803 checksum",
1220                 .run_case               = checksum_case,
1221                 .generate_params        = rfc6803_checksum_gen_params,
1222         },
1223         {
1224                 .name                   = "RFC 6803 encryption",
1225                 .run_case               = rfc6803_encrypt_case,
1226                 .generate_params        = rfc6803_encrypt_gen_params,
1227         },
1228         {}
1229 };
1230
1231 static struct kunit_suite rfc6803_suite = {
1232         .name                   = "RFC 6803 suite",
1233         .test_cases             = rfc6803_test_cases,
1234 };
1235
1236 /*
1237  * From RFC 8009 Appendix A.  Test Vectors
1238  *
1239  * Sample results for SHA-2 enctype key derivation
1240  *
1241  * This test material is copyright (c) 2016 IETF Trust and the
1242  * persons identified as the document authors.  All rights reserved.
1243  */
1244
1245 DEFINE_HEX_XDR_NETOBJ(aes128_cts_hmac_sha256_128_basekey,
1246                       0x37, 0x05, 0xd9, 0x60, 0x80, 0xc1, 0x77, 0x28,
1247                       0xa0, 0xe8, 0x00, 0xea, 0xb6, 0xe0, 0xd2, 0x3c
1248 );
1249 DEFINE_HEX_XDR_NETOBJ(aes128_cts_hmac_sha256_128_Kc,
1250                       0xb3, 0x1a, 0x01, 0x8a, 0x48, 0xf5, 0x47, 0x76,
1251                       0xf4, 0x03, 0xe9, 0xa3, 0x96, 0x32, 0x5d, 0xc3
1252 );
1253 DEFINE_HEX_XDR_NETOBJ(aes128_cts_hmac_sha256_128_Ke,
1254                       0x9b, 0x19, 0x7d, 0xd1, 0xe8, 0xc5, 0x60, 0x9d,
1255                       0x6e, 0x67, 0xc3, 0xe3, 0x7c, 0x62, 0xc7, 0x2e
1256 );
1257 DEFINE_HEX_XDR_NETOBJ(aes128_cts_hmac_sha256_128_Ki,
1258                       0x9f, 0xda, 0x0e, 0x56, 0xab, 0x2d, 0x85, 0xe1,
1259                       0x56, 0x9a, 0x68, 0x86, 0x96, 0xc2, 0x6a, 0x6c
1260 );
1261
1262 DEFINE_HEX_XDR_NETOBJ(aes256_cts_hmac_sha384_192_basekey,
1263                       0x6d, 0x40, 0x4d, 0x37, 0xfa, 0xf7, 0x9f, 0x9d,
1264                       0xf0, 0xd3, 0x35, 0x68, 0xd3, 0x20, 0x66, 0x98,
1265                       0x00, 0xeb, 0x48, 0x36, 0x47, 0x2e, 0xa8, 0xa0,
1266                       0x26, 0xd1, 0x6b, 0x71, 0x82, 0x46, 0x0c, 0x52
1267 );
1268 DEFINE_HEX_XDR_NETOBJ(aes256_cts_hmac_sha384_192_Kc,
1269                       0xef, 0x57, 0x18, 0xbe, 0x86, 0xcc, 0x84, 0x96,
1270                       0x3d, 0x8b, 0xbb, 0x50, 0x31, 0xe9, 0xf5, 0xc4,
1271                       0xba, 0x41, 0xf2, 0x8f, 0xaf, 0x69, 0xe7, 0x3d
1272 );
1273 DEFINE_HEX_XDR_NETOBJ(aes256_cts_hmac_sha384_192_Ke,
1274                       0x56, 0xab, 0x22, 0xbe, 0xe6, 0x3d, 0x82, 0xd7,
1275                       0xbc, 0x52, 0x27, 0xf6, 0x77, 0x3f, 0x8e, 0xa7,
1276                       0xa5, 0xeb, 0x1c, 0x82, 0x51, 0x60, 0xc3, 0x83,
1277                       0x12, 0x98, 0x0c, 0x44, 0x2e, 0x5c, 0x7e, 0x49
1278 );
1279 DEFINE_HEX_XDR_NETOBJ(aes256_cts_hmac_sha384_192_Ki,
1280                       0x69, 0xb1, 0x65, 0x14, 0xe3, 0xcd, 0x8e, 0x56,
1281                       0xb8, 0x20, 0x10, 0xd5, 0xc7, 0x30, 0x12, 0xb6,
1282                       0x22, 0xc4, 0xd0, 0x0f, 0xfc, 0x23, 0xed, 0x1f
1283 );
1284
1285 static const struct gss_krb5_test_param rfc8009_kdf_test_params[] = {
1286         {
1287                 .desc                   = "Derive Kc subkey for aes128-cts-hmac-sha256-128",
1288                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1289                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1290                 .usage                  = &usage_checksum,
1291                 .expected_result        = &aes128_cts_hmac_sha256_128_Kc,
1292         },
1293         {
1294                 .desc                   = "Derive Ke subkey for aes128-cts-hmac-sha256-128",
1295                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1296                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1297                 .usage                  = &usage_encryption,
1298                 .expected_result        = &aes128_cts_hmac_sha256_128_Ke,
1299         },
1300         {
1301                 .desc                   = "Derive Ki subkey for aes128-cts-hmac-sha256-128",
1302                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1303                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1304                 .usage                  = &usage_integrity,
1305                 .expected_result        = &aes128_cts_hmac_sha256_128_Ki,
1306         },
1307         {
1308                 .desc                   = "Derive Kc subkey for aes256-cts-hmac-sha384-192",
1309                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1310                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1311                 .usage                  = &usage_checksum,
1312                 .expected_result        = &aes256_cts_hmac_sha384_192_Kc,
1313         },
1314         {
1315                 .desc                   = "Derive Ke subkey for aes256-cts-hmac-sha384-192",
1316                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1317                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1318                 .usage                  = &usage_encryption,
1319                 .expected_result        = &aes256_cts_hmac_sha384_192_Ke,
1320         },
1321         {
1322                 .desc                   = "Derive Ki subkey for aes256-cts-hmac-sha384-192",
1323                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1324                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1325                 .usage                  = &usage_integrity,
1326                 .expected_result        = &aes256_cts_hmac_sha384_192_Ki,
1327         },
1328 };
1329
1330 /* Creates the function rfc8009_kdf_gen_params */
1331 KUNIT_ARRAY_PARAM(rfc8009_kdf, rfc8009_kdf_test_params, gss_krb5_get_desc);
1332
1333 /*
1334  * From RFC 8009 Appendix A.  Test Vectors
1335  *
1336  * These sample checksums use the above sample key derivation results,
1337  * including use of the same base-key and key usage values.
1338  *
1339  * This test material is copyright (c) 2016 IETF Trust and the
1340  * persons identified as the document authors.  All rights reserved.
1341  */
1342
1343 DEFINE_HEX_XDR_NETOBJ(rfc8009_checksum_plaintext,
1344                       0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1345                       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1346                       0x10, 0x11, 0x12, 0x13, 0x14
1347 );
1348 DEFINE_HEX_XDR_NETOBJ(rfc8009_checksum_test1_expected_result,
1349                       0xd7, 0x83, 0x67, 0x18, 0x66, 0x43, 0xd6, 0x7b,
1350                       0x41, 0x1c, 0xba, 0x91, 0x39, 0xfc, 0x1d, 0xee
1351 );
1352 DEFINE_HEX_XDR_NETOBJ(rfc8009_checksum_test2_expected_result,
1353                       0x45, 0xee, 0x79, 0x15, 0x67, 0xee, 0xfc, 0xa3,
1354                       0x7f, 0x4a, 0xc1, 0xe0, 0x22, 0x2d, 0xe8, 0x0d,
1355                       0x43, 0xc3, 0xbf, 0xa0, 0x66, 0x99, 0x67, 0x2a
1356 );
1357
1358 static const struct gss_krb5_test_param rfc8009_checksum_test_params[] = {
1359         {
1360                 .desc                   = "Checksum with aes128-cts-hmac-sha256-128",
1361                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1362                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1363                 .usage                  = &usage_checksum,
1364                 .plaintext              = &rfc8009_checksum_plaintext,
1365                 .expected_result        = &rfc8009_checksum_test1_expected_result,
1366         },
1367         {
1368                 .desc                   = "Checksum with aes256-cts-hmac-sha384-192",
1369                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1370                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1371                 .usage                  = &usage_checksum,
1372                 .plaintext              = &rfc8009_checksum_plaintext,
1373                 .expected_result        = &rfc8009_checksum_test2_expected_result,
1374         },
1375 };
1376
1377 /* Creates the function rfc8009_checksum_gen_params */
1378 KUNIT_ARRAY_PARAM(rfc8009_checksum, rfc8009_checksum_test_params,
1379                   gss_krb5_get_desc);
1380
1381 /*
1382  * From RFC 8009 Appendix A.  Test Vectors
1383  *
1384  * Sample encryptions (all using the default cipher state):
1385  * --------------------------------------------------------
1386  *
1387  * These sample encryptions use the above sample key derivation results,
1388  * including use of the same base-key and key usage values.
1389  *
1390  * This test material is copyright (c) 2016 IETF Trust and the
1391  * persons identified as the document authors.  All rights reserved.
1392  */
1393
1394 static const struct xdr_netobj rfc8009_enc_empty_plaintext = {
1395         .len    = 0,
1396 };
1397 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_short_plaintext,
1398                       0x00, 0x01, 0x02, 0x03, 0x04, 0x05
1399 );
1400 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_block_plaintext,
1401                       0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1402                       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
1403 );
1404 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_long_plaintext,
1405                       0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1406                       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
1407                       0x10, 0x11, 0x12, 0x13, 0x14
1408 );
1409
1410 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test1_confounder,
1411                       0x7e, 0x58, 0x95, 0xea, 0xf2, 0x67, 0x24, 0x35,
1412                       0xba, 0xd8, 0x17, 0xf5, 0x45, 0xa3, 0x71, 0x48
1413 );
1414 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test1_expected_result,
1415                       0xef, 0x85, 0xfb, 0x89, 0x0b, 0xb8, 0x47, 0x2f,
1416                       0x4d, 0xab, 0x20, 0x39, 0x4d, 0xca, 0x78, 0x1d
1417 );
1418 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test1_expected_hmac,
1419                       0xad, 0x87, 0x7e, 0xda, 0x39, 0xd5, 0x0c, 0x87,
1420                       0x0c, 0x0d, 0x5a, 0x0a, 0x8e, 0x48, 0xc7, 0x18
1421 );
1422
1423 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test2_confounder,
1424                       0x7b, 0xca, 0x28, 0x5e, 0x2f, 0xd4, 0x13, 0x0f,
1425                       0xb5, 0x5b, 0x1a, 0x5c, 0x83, 0xbc, 0x5b, 0x24
1426 );
1427 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test2_expected_result,
1428                       0x84, 0xd7, 0xf3, 0x07, 0x54, 0xed, 0x98, 0x7b,
1429                       0xab, 0x0b, 0xf3, 0x50, 0x6b, 0xeb, 0x09, 0xcf,
1430                       0xb5, 0x54, 0x02, 0xce, 0xf7, 0xe6
1431 );
1432 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test2_expected_hmac,
1433                       0x87, 0x7c, 0xe9, 0x9e, 0x24, 0x7e, 0x52, 0xd1,
1434                       0x6e, 0xd4, 0x42, 0x1d, 0xfd, 0xf8, 0x97, 0x6c
1435 );
1436
1437 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test3_confounder,
1438                       0x56, 0xab, 0x21, 0x71, 0x3f, 0xf6, 0x2c, 0x0a,
1439                       0x14, 0x57, 0x20, 0x0f, 0x6f, 0xa9, 0x94, 0x8f
1440 );
1441 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test3_expected_result,
1442                       0x35, 0x17, 0xd6, 0x40, 0xf5, 0x0d, 0xdc, 0x8a,
1443                       0xd3, 0x62, 0x87, 0x22, 0xb3, 0x56, 0x9d, 0x2a,
1444                       0xe0, 0x74, 0x93, 0xfa, 0x82, 0x63, 0x25, 0x40,
1445                       0x80, 0xea, 0x65, 0xc1, 0x00, 0x8e, 0x8f, 0xc2
1446 );
1447 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test3_expected_hmac,
1448                       0x95, 0xfb, 0x48, 0x52, 0xe7, 0xd8, 0x3e, 0x1e,
1449                       0x7c, 0x48, 0xc3, 0x7e, 0xeb, 0xe6, 0xb0, 0xd3
1450 );
1451
1452 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test4_confounder,
1453                       0xa7, 0xa4, 0xe2, 0x9a, 0x47, 0x28, 0xce, 0x10,
1454                       0x66, 0x4f, 0xb6, 0x4e, 0x49, 0xad, 0x3f, 0xac
1455 );
1456 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test4_expected_result,
1457                       0x72, 0x0f, 0x73, 0xb1, 0x8d, 0x98, 0x59, 0xcd,
1458                       0x6c, 0xcb, 0x43, 0x46, 0x11, 0x5c, 0xd3, 0x36,
1459                       0xc7, 0x0f, 0x58, 0xed, 0xc0, 0xc4, 0x43, 0x7c,
1460                       0x55, 0x73, 0x54, 0x4c, 0x31, 0xc8, 0x13, 0xbc,
1461                       0xe1, 0xe6, 0xd0, 0x72, 0xc1
1462 );
1463 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test4_expected_hmac,
1464                       0x86, 0xb3, 0x9a, 0x41, 0x3c, 0x2f, 0x92, 0xca,
1465                       0x9b, 0x83, 0x34, 0xa2, 0x87, 0xff, 0xcb, 0xfc
1466 );
1467
1468 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test5_confounder,
1469                       0xf7, 0x64, 0xe9, 0xfa, 0x15, 0xc2, 0x76, 0x47,
1470                       0x8b, 0x2c, 0x7d, 0x0c, 0x4e, 0x5f, 0x58, 0xe4
1471 );
1472 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test5_expected_result,
1473                       0x41, 0xf5, 0x3f, 0xa5, 0xbf, 0xe7, 0x02, 0x6d,
1474                       0x91, 0xfa, 0xf9, 0xbe, 0x95, 0x91, 0x95, 0xa0
1475 );
1476 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test5_expected_hmac,
1477                       0x58, 0x70, 0x72, 0x73, 0xa9, 0x6a, 0x40, 0xf0,
1478                       0xa0, 0x19, 0x60, 0x62, 0x1a, 0xc6, 0x12, 0x74,
1479                       0x8b, 0x9b, 0xbf, 0xbe, 0x7e, 0xb4, 0xce, 0x3c
1480 );
1481
1482 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test6_confounder,
1483                       0xb8, 0x0d, 0x32, 0x51, 0xc1, 0xf6, 0x47, 0x14,
1484                       0x94, 0x25, 0x6f, 0xfe, 0x71, 0x2d, 0x0b, 0x9a
1485 );
1486 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test6_expected_result,
1487                       0x4e, 0xd7, 0xb3, 0x7c, 0x2b, 0xca, 0xc8, 0xf7,
1488                       0x4f, 0x23, 0xc1, 0xcf, 0x07, 0xe6, 0x2b, 0xc7,
1489                       0xb7, 0x5f, 0xb3, 0xf6, 0x37, 0xb9
1490 );
1491 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test6_expected_hmac,
1492                       0xf5, 0x59, 0xc7, 0xf6, 0x64, 0xf6, 0x9e, 0xab,
1493                       0x7b, 0x60, 0x92, 0x23, 0x75, 0x26, 0xea, 0x0d,
1494                       0x1f, 0x61, 0xcb, 0x20, 0xd6, 0x9d, 0x10, 0xf2
1495 );
1496
1497 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test7_confounder,
1498                       0x53, 0xbf, 0x8a, 0x0d, 0x10, 0x52, 0x65, 0xd4,
1499                       0xe2, 0x76, 0x42, 0x86, 0x24, 0xce, 0x5e, 0x63
1500 );
1501 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test7_expected_result,
1502                       0xbc, 0x47, 0xff, 0xec, 0x79, 0x98, 0xeb, 0x91,
1503                       0xe8, 0x11, 0x5c, 0xf8, 0xd1, 0x9d, 0xac, 0x4b,
1504                       0xbb, 0xe2, 0xe1, 0x63, 0xe8, 0x7d, 0xd3, 0x7f,
1505                       0x49, 0xbe, 0xca, 0x92, 0x02, 0x77, 0x64, 0xf6
1506 );
1507 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test7_expected_hmac,
1508                       0x8c, 0xf5, 0x1f, 0x14, 0xd7, 0x98, 0xc2, 0x27,
1509                       0x3f, 0x35, 0xdf, 0x57, 0x4d, 0x1f, 0x93, 0x2e,
1510                       0x40, 0xc4, 0xff, 0x25, 0x5b, 0x36, 0xa2, 0x66
1511 );
1512
1513 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test8_confounder,
1514                       0x76, 0x3e, 0x65, 0x36, 0x7e, 0x86, 0x4f, 0x02,
1515                       0xf5, 0x51, 0x53, 0xc7, 0xe3, 0xb5, 0x8a, 0xf1
1516 );
1517 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test8_expected_result,
1518                       0x40, 0x01, 0x3e, 0x2d, 0xf5, 0x8e, 0x87, 0x51,
1519                       0x95, 0x7d, 0x28, 0x78, 0xbc, 0xd2, 0xd6, 0xfe,
1520                       0x10, 0x1c, 0xcf, 0xd5, 0x56, 0xcb, 0x1e, 0xae,
1521                       0x79, 0xdb, 0x3c, 0x3e, 0xe8, 0x64, 0x29, 0xf2,
1522                       0xb2, 0xa6, 0x02, 0xac, 0x86
1523 );
1524 DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_test8_expected_hmac,
1525                       0xfe, 0xf6, 0xec, 0xb6, 0x47, 0xd6, 0x29, 0x5f,
1526                       0xae, 0x07, 0x7a, 0x1f, 0xeb, 0x51, 0x75, 0x08,
1527                       0xd2, 0xc1, 0x6b, 0x41, 0x92, 0xe0, 0x1f, 0x62
1528 );
1529
1530 static const struct gss_krb5_test_param rfc8009_encrypt_test_params[] = {
1531         {
1532                 .desc                   = "Encrypt empty plaintext with aes128-cts-hmac-sha256-128",
1533                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1534                 .plaintext              = &rfc8009_enc_empty_plaintext,
1535                 .confounder             = &rfc8009_enc_test1_confounder,
1536                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1537                 .expected_result        = &rfc8009_enc_test1_expected_result,
1538                 .expected_hmac          = &rfc8009_enc_test1_expected_hmac,
1539         },
1540         {
1541                 .desc                   = "Encrypt short plaintext with aes128-cts-hmac-sha256-128",
1542                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1543                 .plaintext              = &rfc8009_enc_short_plaintext,
1544                 .confounder             = &rfc8009_enc_test2_confounder,
1545                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1546                 .expected_result        = &rfc8009_enc_test2_expected_result,
1547                 .expected_hmac          = &rfc8009_enc_test2_expected_hmac,
1548         },
1549         {
1550                 .desc                   = "Encrypt block plaintext with aes128-cts-hmac-sha256-128",
1551                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1552                 .plaintext              = &rfc8009_enc_block_plaintext,
1553                 .confounder             = &rfc8009_enc_test3_confounder,
1554                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1555                 .expected_result        = &rfc8009_enc_test3_expected_result,
1556                 .expected_hmac          = &rfc8009_enc_test3_expected_hmac,
1557         },
1558         {
1559                 .desc                   = "Encrypt long plaintext with aes128-cts-hmac-sha256-128",
1560                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1561                 .plaintext              = &rfc8009_enc_long_plaintext,
1562                 .confounder             = &rfc8009_enc_test4_confounder,
1563                 .base_key               = &aes128_cts_hmac_sha256_128_basekey,
1564                 .expected_result        = &rfc8009_enc_test4_expected_result,
1565                 .expected_hmac          = &rfc8009_enc_test4_expected_hmac,
1566         },
1567         {
1568                 .desc                   = "Encrypt empty plaintext with aes256-cts-hmac-sha384-192",
1569                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1570                 .plaintext              = &rfc8009_enc_empty_plaintext,
1571                 .confounder             = &rfc8009_enc_test5_confounder,
1572                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1573                 .expected_result        = &rfc8009_enc_test5_expected_result,
1574                 .expected_hmac          = &rfc8009_enc_test5_expected_hmac,
1575         },
1576         {
1577                 .desc                   = "Encrypt short plaintext with aes256-cts-hmac-sha384-192",
1578                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1579                 .plaintext              = &rfc8009_enc_short_plaintext,
1580                 .confounder             = &rfc8009_enc_test6_confounder,
1581                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1582                 .expected_result        = &rfc8009_enc_test6_expected_result,
1583                 .expected_hmac          = &rfc8009_enc_test6_expected_hmac,
1584         },
1585         {
1586                 .desc                   = "Encrypt block plaintext with aes256-cts-hmac-sha384-192",
1587                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1588                 .plaintext              = &rfc8009_enc_block_plaintext,
1589                 .confounder             = &rfc8009_enc_test7_confounder,
1590                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1591                 .expected_result        = &rfc8009_enc_test7_expected_result,
1592                 .expected_hmac          = &rfc8009_enc_test7_expected_hmac,
1593         },
1594         {
1595                 .desc                   = "Encrypt long plaintext with aes256-cts-hmac-sha384-192",
1596                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1597                 .plaintext              = &rfc8009_enc_long_plaintext,
1598                 .confounder             = &rfc8009_enc_test8_confounder,
1599                 .base_key               = &aes256_cts_hmac_sha384_192_basekey,
1600                 .expected_result        = &rfc8009_enc_test8_expected_result,
1601                 .expected_hmac          = &rfc8009_enc_test8_expected_hmac,
1602         },
1603 };
1604
1605 /* Creates the function rfc8009_encrypt_gen_params */
1606 KUNIT_ARRAY_PARAM(rfc8009_encrypt, rfc8009_encrypt_test_params,
1607                   gss_krb5_get_desc);
1608
1609 static void rfc8009_encrypt_case(struct kunit *test)
1610 {
1611         const struct gss_krb5_test_param *param = test->param_value;
1612         struct crypto_sync_skcipher *cts_tfm, *cbc_tfm;
1613         const struct gss_krb5_enctype *gk5e;
1614         struct xdr_netobj Ke, Ki, checksum;
1615         u8 usage_data[GSS_KRB5_K5CLENGTH];
1616         struct xdr_netobj usage = {
1617                 .data = usage_data,
1618                 .len = sizeof(usage_data),
1619         };
1620         struct crypto_ahash *ahash_tfm;
1621         struct xdr_buf buf;
1622         void *text;
1623         size_t len;
1624         u32 err;
1625
1626         /* Arrange */
1627         gk5e = gss_krb5_lookup_enctype(param->enctype);
1628         if (!gk5e)
1629                 kunit_skip(test, "Encryption type is not available");
1630
1631         *(__be32 *)usage.data = cpu_to_be32(2);
1632
1633         Ke.len = gk5e->Ke_length;
1634         Ke.data = kunit_kzalloc(test, Ke.len, GFP_KERNEL);
1635         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, Ke.data);
1636         usage.data[4] = KEY_USAGE_SEED_ENCRYPTION;
1637         err = gk5e->derive_key(gk5e, param->base_key, &Ke,
1638                                &usage, GFP_KERNEL);
1639         KUNIT_ASSERT_EQ(test, err, 0);
1640
1641         cbc_tfm = crypto_alloc_sync_skcipher(gk5e->aux_cipher, 0, 0);
1642         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cbc_tfm);
1643         err = crypto_sync_skcipher_setkey(cbc_tfm, Ke.data, Ke.len);
1644         KUNIT_ASSERT_EQ(test, err, 0);
1645
1646         cts_tfm = crypto_alloc_sync_skcipher(gk5e->encrypt_name, 0, 0);
1647         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cts_tfm);
1648         err = crypto_sync_skcipher_setkey(cts_tfm, Ke.data, Ke.len);
1649         KUNIT_ASSERT_EQ(test, err, 0);
1650
1651         len = param->confounder->len + param->plaintext->len;
1652         text = kunit_kzalloc(test, len, GFP_KERNEL);
1653         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, text);
1654         memcpy(text, param->confounder->data, param->confounder->len);
1655         memcpy(text + param->confounder->len, param->plaintext->data,
1656                param->plaintext->len);
1657
1658         memset(&buf, 0, sizeof(buf));
1659         buf.head[0].iov_base = text;
1660         buf.head[0].iov_len = param->confounder->len + param->plaintext->len;
1661         buf.len = buf.head[0].iov_len;
1662
1663         checksum.len = gk5e->cksumlength;
1664         checksum.data = kunit_kzalloc(test, checksum.len, GFP_KERNEL);
1665         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, checksum.data);
1666
1667         Ki.len = gk5e->Ki_length;
1668         Ki.data = kunit_kzalloc(test, Ki.len, GFP_KERNEL);
1669         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, Ki.data);
1670         usage.data[4] = KEY_USAGE_SEED_INTEGRITY;
1671         err = gk5e->derive_key(gk5e, param->base_key, &Ki,
1672                                &usage, GFP_KERNEL);
1673         KUNIT_ASSERT_EQ(test, err, 0);
1674
1675         ahash_tfm = crypto_alloc_ahash(gk5e->cksum_name, 0, CRYPTO_ALG_ASYNC);
1676         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ahash_tfm);
1677         err = crypto_ahash_setkey(ahash_tfm, Ki.data, Ki.len);
1678         KUNIT_ASSERT_EQ(test, err, 0);
1679
1680         /* Act */
1681         err = krb5_cbc_cts_encrypt(cts_tfm, cbc_tfm, 0, &buf, NULL, NULL, 0);
1682         KUNIT_ASSERT_EQ(test, err, 0);
1683         err = krb5_etm_checksum(cts_tfm, ahash_tfm, &buf, 0, &checksum);
1684         KUNIT_ASSERT_EQ(test, err, 0);
1685
1686         /* Assert */
1687         KUNIT_EXPECT_EQ_MSG(test,
1688                             param->expected_result->len, buf.len,
1689                             "ciphertext length mismatch");
1690         KUNIT_EXPECT_EQ_MSG(test,
1691                             memcmp(param->expected_result->data,
1692                                    buf.head[0].iov_base,
1693                                    param->expected_result->len), 0,
1694                             "ciphertext mismatch");
1695         KUNIT_EXPECT_EQ_MSG(test, memcmp(param->expected_hmac->data,
1696                                          checksum.data,
1697                                          checksum.len), 0,
1698                             "HMAC mismatch");
1699
1700         crypto_free_ahash(ahash_tfm);
1701         crypto_free_sync_skcipher(cts_tfm);
1702         crypto_free_sync_skcipher(cbc_tfm);
1703 }
1704
1705 static struct kunit_case rfc8009_test_cases[] = {
1706         {
1707                 .name                   = "RFC 8009 key derivation",
1708                 .run_case               = kdf_case,
1709                 .generate_params        = rfc8009_kdf_gen_params,
1710         },
1711         {
1712                 .name                   = "RFC 8009 checksum",
1713                 .run_case               = checksum_case,
1714                 .generate_params        = rfc8009_checksum_gen_params,
1715         },
1716         {
1717                 .name                   = "RFC 8009 encryption",
1718                 .run_case               = rfc8009_encrypt_case,
1719                 .generate_params        = rfc8009_encrypt_gen_params,
1720         },
1721         {}
1722 };
1723
1724 static struct kunit_suite rfc8009_suite = {
1725         .name                   = "RFC 8009 suite",
1726         .test_cases             = rfc8009_test_cases,
1727 };
1728
1729 /*
1730  * Encryption self-tests
1731  */
1732
1733 DEFINE_STR_XDR_NETOBJ(encrypt_selftest_plaintext,
1734                       "This is the plaintext for the encryption self-test.");
1735
1736 static const struct gss_krb5_test_param encrypt_selftest_params[] = {
1737         {
1738                 .desc                   = "aes128-cts-hmac-sha1-96 encryption self-test",
1739                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA1_96,
1740                 .Ke                     = &rfc3962_encryption_key,
1741                 .plaintext              = &encrypt_selftest_plaintext,
1742         },
1743         {
1744                 .desc                   = "aes256-cts-hmac-sha1-96 encryption self-test",
1745                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA1_96,
1746                 .Ke                     = &rfc3962_encryption_key,
1747                 .plaintext              = &encrypt_selftest_plaintext,
1748         },
1749         {
1750                 .desc                   = "camellia128-cts-cmac encryption self-test",
1751                 .enctype                = ENCTYPE_CAMELLIA128_CTS_CMAC,
1752                 .Ke                     = &camellia128_cts_cmac_Ke,
1753                 .plaintext              = &encrypt_selftest_plaintext,
1754         },
1755         {
1756                 .desc                   = "camellia256-cts-cmac encryption self-test",
1757                 .enctype                = ENCTYPE_CAMELLIA256_CTS_CMAC,
1758                 .Ke                     = &camellia256_cts_cmac_Ke,
1759                 .plaintext              = &encrypt_selftest_plaintext,
1760         },
1761         {
1762                 .desc                   = "aes128-cts-hmac-sha256-128 encryption self-test",
1763                 .enctype                = ENCTYPE_AES128_CTS_HMAC_SHA256_128,
1764                 .Ke                     = &aes128_cts_hmac_sha256_128_Ke,
1765                 .plaintext              = &encrypt_selftest_plaintext,
1766         },
1767         {
1768                 .desc                   = "aes256-cts-hmac-sha384-192 encryption self-test",
1769                 .enctype                = ENCTYPE_AES256_CTS_HMAC_SHA384_192,
1770                 .Ke                     = &aes256_cts_hmac_sha384_192_Ke,
1771                 .plaintext              = &encrypt_selftest_plaintext,
1772         },
1773 };
1774
1775 /* Creates the function encrypt_selftest_gen_params */
1776 KUNIT_ARRAY_PARAM(encrypt_selftest, encrypt_selftest_params,
1777                   gss_krb5_get_desc);
1778
1779 /*
1780  * Encrypt and decrypt plaintext, and ensure the input plaintext
1781  * matches the output plaintext. A confounder is not added in this
1782  * case.
1783  */
1784 static void encrypt_selftest_case(struct kunit *test)
1785 {
1786         const struct gss_krb5_test_param *param = test->param_value;
1787         struct crypto_sync_skcipher *cts_tfm, *cbc_tfm;
1788         const struct gss_krb5_enctype *gk5e;
1789         struct xdr_buf buf;
1790         void *text;
1791         int err;
1792
1793         /* Arrange */
1794         gk5e = gss_krb5_lookup_enctype(param->enctype);
1795         if (!gk5e)
1796                 kunit_skip(test, "Encryption type is not available");
1797
1798         cbc_tfm = crypto_alloc_sync_skcipher(gk5e->aux_cipher, 0, 0);
1799         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cbc_tfm);
1800         err = crypto_sync_skcipher_setkey(cbc_tfm, param->Ke->data, param->Ke->len);
1801         KUNIT_ASSERT_EQ(test, err, 0);
1802
1803         cts_tfm = crypto_alloc_sync_skcipher(gk5e->encrypt_name, 0, 0);
1804         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cts_tfm);
1805         err = crypto_sync_skcipher_setkey(cts_tfm, param->Ke->data, param->Ke->len);
1806         KUNIT_ASSERT_EQ(test, err, 0);
1807
1808         text = kunit_kzalloc(test, roundup(param->plaintext->len,
1809                                            crypto_sync_skcipher_blocksize(cbc_tfm)),
1810                              GFP_KERNEL);
1811         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, text);
1812
1813         memcpy(text, param->plaintext->data, param->plaintext->len);
1814         memset(&buf, 0, sizeof(buf));
1815         buf.head[0].iov_base = text;
1816         buf.head[0].iov_len = param->plaintext->len;
1817         buf.len = buf.head[0].iov_len;
1818
1819         /* Act */
1820         err = krb5_cbc_cts_encrypt(cts_tfm, cbc_tfm, 0, &buf, NULL, NULL, 0);
1821         KUNIT_ASSERT_EQ(test, err, 0);
1822         err = krb5_cbc_cts_decrypt(cts_tfm, cbc_tfm, 0, &buf);
1823         KUNIT_ASSERT_EQ(test, err, 0);
1824
1825         /* Assert */
1826         KUNIT_EXPECT_EQ_MSG(test,
1827                             param->plaintext->len, buf.len,
1828                             "length mismatch");
1829         KUNIT_EXPECT_EQ_MSG(test,
1830                             memcmp(param->plaintext->data,
1831                                    buf.head[0].iov_base, buf.len), 0,
1832                             "plaintext mismatch");
1833
1834         crypto_free_sync_skcipher(cts_tfm);
1835         crypto_free_sync_skcipher(cbc_tfm);
1836 }
1837
1838 static struct kunit_case encryption_test_cases[] = {
1839         {
1840                 .name                   = "Encryption self-tests",
1841                 .run_case               = encrypt_selftest_case,
1842                 .generate_params        = encrypt_selftest_gen_params,
1843         },
1844         {}
1845 };
1846
1847 static struct kunit_suite encryption_test_suite = {
1848         .name                   = "Encryption test suite",
1849         .test_cases             = encryption_test_cases,
1850 };
1851
1852 kunit_test_suites(&rfc3961_suite,
1853                   &rfc3962_suite,
1854                   &rfc6803_suite,
1855                   &rfc8009_suite,
1856                   &encryption_test_suite);
1857
1858 MODULE_DESCRIPTION("Test RPCSEC GSS Kerberos 5 functions");
1859 MODULE_LICENSE("GPL");