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 20MODULE_IMPORT_NS(EXPORTED_FOR_KUNIT_TESTING); 21 22struct 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 37static 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 43static 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 72static 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 144DEFINE_HEX_XDR_NETOBJ(nfold_test1_plaintext, 145 0x30, 0x31, 0x32, 0x33, 0x34, 0x35 146); 147DEFINE_HEX_XDR_NETOBJ(nfold_test1_expected_result, 148 0xbe, 0x07, 0x26, 0x31, 0x27, 0x6b, 0x19, 0x55 149); 150 151DEFINE_HEX_XDR_NETOBJ(nfold_test2_plaintext, 152 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64 153); 154DEFINE_HEX_XDR_NETOBJ(nfold_test2_expected_result, 155 0x78, 0xa0, 0x7b, 0x6c, 0xaf, 0x85, 0xfa 156); 157 158DEFINE_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); 165DEFINE_HEX_XDR_NETOBJ(nfold_test3_expected_result, 166 0xbb, 0x6e, 0xd3, 0x08, 0x70, 0xb7, 0xf0, 0xe0 167); 168 169DEFINE_HEX_XDR_NETOBJ(nfold_test4_plaintext, 170 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64 171); 172DEFINE_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 178DEFINE_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); 185DEFINE_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 191DEFINE_HEX_XDR_NETOBJ(nfold_test6_plaintext, 192 0x51 193); 194DEFINE_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 200DEFINE_HEX_XDR_NETOBJ(nfold_test7_plaintext, 201 0x62, 0x61 202); 203DEFINE_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 209DEFINE_HEX_XDR_NETOBJ(nfold_test_kerberos, 210 0x6b, 0x65, 0x72, 0x62, 0x65, 0x72, 0x6f, 0x73 211); 212DEFINE_HEX_XDR_NETOBJ(nfold_test8_expected_result, 213 0x6b, 0x65, 0x72, 0x62, 0x65, 0x72, 0x6f, 0x73 214); 215DEFINE_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); 219DEFINE_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); 224DEFINE_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 231static 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 */ 301KUNIT_ARRAY_PARAM(rfc3961_nfold, rfc3961_nfold_test_params, gss_krb5_get_desc); 302 303static 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 323static 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 332static 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 346DEFINE_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 351DEFINE_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); 356DEFINE_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); 361DEFINE_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 366DEFINE_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); 372DEFINE_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); 378DEFINE_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 383DEFINE_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); 389DEFINE_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); 395DEFINE_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 400DEFINE_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); 408DEFINE_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); 416DEFINE_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 421DEFINE_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); 429DEFINE_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); 437DEFINE_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 442DEFINE_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); 452DEFINE_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); 462DEFINE_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 467static 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 */ 519KUNIT_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 */ 527static 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 585static 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 594static 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 608DEFINE_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); 612DEFINE_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); 616DEFINE_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); 620DEFINE_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 625DEFINE_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); 631DEFINE_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); 637DEFINE_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); 643DEFINE_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 650DEFINE_HEX_XDR_NETOBJ(usage_checksum, 651 0x00, 0x00, 0x00, 0x02, KEY_USAGE_SEED_CHECKSUM 652); 653DEFINE_HEX_XDR_NETOBJ(usage_encryption, 654 0x00, 0x00, 0x00, 0x02, KEY_USAGE_SEED_ENCRYPTION 655); 656DEFINE_HEX_XDR_NETOBJ(usage_integrity, 657 0x00, 0x00, 0x00, 0x02, KEY_USAGE_SEED_INTEGRITY 658); 659 660static 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 */ 706KUNIT_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 */ 718DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test1_plaintext, 719 "abcdefghijk"); 720DEFINE_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); 724DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test1_usage, 725 0x00, 0x00, 0x00, 0x07, KEY_USAGE_SEED_CHECKSUM 726); 727DEFINE_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 732DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test2_plaintext, 733 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); 734DEFINE_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); 738DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test2_usage, 739 0x00, 0x00, 0x00, 0x08, KEY_USAGE_SEED_CHECKSUM 740); 741DEFINE_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 746DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test3_plaintext, 747 "123456789"); 748DEFINE_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); 754DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test3_usage, 755 0x00, 0x00, 0x00, 0x09, KEY_USAGE_SEED_CHECKSUM 756); 757DEFINE_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 762DEFINE_STR_XDR_NETOBJ(rfc6803_checksum_test4_plaintext, 763 "!@#$%^&*()!@#$%^&*()!@#$%^&*()"); 764DEFINE_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); 770DEFINE_HEX_XDR_NETOBJ(rfc6803_checksum_test4_usage, 771 0x00, 0x00, 0x00, 0x0a, KEY_USAGE_SEED_CHECKSUM 772); 773DEFINE_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 778static 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 */ 814KUNIT_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 828static const struct xdr_netobj rfc6803_enc_empty_plaintext = { 829 .len = 0, 830}; 831 832DEFINE_STR_XDR_NETOBJ(rfc6803_enc_1byte_plaintext, "1"); 833DEFINE_STR_XDR_NETOBJ(rfc6803_enc_9byte_plaintext, "9 bytesss"); 834DEFINE_STR_XDR_NETOBJ(rfc6803_enc_13byte_plaintext, "13 bytes byte"); 835DEFINE_STR_XDR_NETOBJ(rfc6803_enc_30byte_plaintext, 836 "30 bytes bytes bytes bytes byt" 837); 838 839DEFINE_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); 843DEFINE_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); 847DEFINE_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 854DEFINE_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); 858DEFINE_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); 862DEFINE_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 870DEFINE_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); 874DEFINE_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); 878DEFINE_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 887DEFINE_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); 891DEFINE_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); 895DEFINE_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 904DEFINE_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); 908DEFINE_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); 912DEFINE_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 923DEFINE_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); 927DEFINE_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); 933DEFINE_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 940DEFINE_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); 944DEFINE_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); 950DEFINE_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 958DEFINE_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); 962DEFINE_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); 968DEFINE_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 977DEFINE_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); 981DEFINE_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); 987DEFINE_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 996DEFINE_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); 1000DEFINE_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); 1006DEFINE_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 1017static 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 */ 1111KUNIT_ARRAY_PARAM(rfc6803_encrypt, rfc6803_encrypt_test_params, 1112 gss_krb5_get_desc); 1113 1114static 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 1212static 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 1231static 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 1245DEFINE_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); 1249DEFINE_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); 1253DEFINE_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); 1257DEFINE_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 1262DEFINE_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); 1268DEFINE_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); 1273DEFINE_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); 1279DEFINE_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 1285static 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 */ 1331KUNIT_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 1343DEFINE_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); 1348DEFINE_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); 1352DEFINE_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 1358static 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 */ 1378KUNIT_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 1394static const struct xdr_netobj rfc8009_enc_empty_plaintext = { 1395 .len = 0, 1396}; 1397DEFINE_HEX_XDR_NETOBJ(rfc8009_enc_short_plaintext, 1398 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 1399); 1400DEFINE_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); 1404DEFINE_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 1410DEFINE_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); 1414DEFINE_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); 1418DEFINE_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 1423DEFINE_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); 1427DEFINE_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); 1432DEFINE_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 1437DEFINE_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); 1441DEFINE_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); 1447DEFINE_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 1452DEFINE_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); 1456DEFINE_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); 1463DEFINE_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 1468DEFINE_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); 1472DEFINE_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); 1476DEFINE_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 1482DEFINE_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); 1486DEFINE_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); 1491DEFINE_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 1497DEFINE_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); 1501DEFINE_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); 1507DEFINE_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 1513DEFINE_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); 1517DEFINE_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); 1524DEFINE_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 1530static 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 */ 1606KUNIT_ARRAY_PARAM(rfc8009_encrypt, rfc8009_encrypt_test_params, 1607 gss_krb5_get_desc); 1608 1609static 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 1705static 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 1724static 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 1733DEFINE_STR_XDR_NETOBJ(encrypt_selftest_plaintext, 1734 "This is the plaintext for the encryption self-test."); 1735 1736static 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 */ 1776KUNIT_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 */ 1784static 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 1838static 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 1847static struct kunit_suite encryption_test_suite = { 1848 .name = "Encryption test suite", 1849 .test_cases = encryption_test_cases, 1850}; 1851 1852kunit_test_suites(&rfc3961_suite, 1853 &rfc3962_suite, 1854 &rfc6803_suite, 1855 &rfc8009_suite, 1856 &encryption_test_suite); 1857 1858MODULE_DESCRIPTION("Test RPCSEC GSS Kerberos 5 functions"); 1859MODULE_LICENSE("GPL"); 1860