1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * KUnit tests for AppArmor's policy unpack. 4 */ 5 6 #include <kunit/test.h> 7 8 #include "include/policy.h" 9 #include "include/policy_unpack.h" 10 11 #define TEST_STRING_NAME "TEST_STRING" 12 #define TEST_STRING_DATA "testing" 13 #define TEST_STRING_BUF_OFFSET \ 14 (3 + strlen(TEST_STRING_NAME) + 1) 15 16 #define TEST_U32_NAME "U32_TEST" 17 #define TEST_U32_DATA ((u32)0x01020304) 18 #define TEST_NAMED_U32_BUF_OFFSET \ 19 (TEST_STRING_BUF_OFFSET + 3 + strlen(TEST_STRING_DATA) + 1) 20 #define TEST_U32_BUF_OFFSET \ 21 (TEST_NAMED_U32_BUF_OFFSET + 3 + strlen(TEST_U32_NAME) + 1) 22 23 #define TEST_U16_OFFSET (TEST_U32_BUF_OFFSET + 3) 24 #define TEST_U16_DATA ((u16)(TEST_U32_DATA >> 16)) 25 26 #define TEST_U64_NAME "U64_TEST" 27 #define TEST_U64_DATA ((u64)0x0102030405060708) 28 #define TEST_NAMED_U64_BUF_OFFSET (TEST_U32_BUF_OFFSET + sizeof(u32) + 1) 29 #define TEST_U64_BUF_OFFSET \ 30 (TEST_NAMED_U64_BUF_OFFSET + 3 + strlen(TEST_U64_NAME) + 1) 31 32 #define TEST_BLOB_NAME "BLOB_TEST" 33 #define TEST_BLOB_DATA "\xde\xad\x00\xbe\xef" 34 #define TEST_BLOB_DATA_SIZE (ARRAY_SIZE(TEST_BLOB_DATA)) 35 #define TEST_NAMED_BLOB_BUF_OFFSET (TEST_U64_BUF_OFFSET + sizeof(u64) + 1) 36 #define TEST_BLOB_BUF_OFFSET \ 37 (TEST_NAMED_BLOB_BUF_OFFSET + 3 + strlen(TEST_BLOB_NAME) + 1) 38 39 #define TEST_ARRAY_NAME "ARRAY_TEST" 40 #define TEST_ARRAY_SIZE 16 41 #define TEST_NAMED_ARRAY_BUF_OFFSET \ 42 (TEST_BLOB_BUF_OFFSET + 5 + TEST_BLOB_DATA_SIZE) 43 #define TEST_ARRAY_BUF_OFFSET \ 44 (TEST_NAMED_ARRAY_BUF_OFFSET + 3 + strlen(TEST_ARRAY_NAME) + 1) 45 46 struct policy_unpack_fixture { 47 struct aa_ext *e; 48 size_t e_size; 49 }; 50 51 struct aa_ext *build_aa_ext_struct(struct policy_unpack_fixture *puf, 52 struct kunit *test, size_t buf_size) 53 { 54 char *buf; 55 struct aa_ext *e; 56 57 buf = kunit_kzalloc(test, buf_size, GFP_USER); 58 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, buf); 59 60 e = kunit_kmalloc(test, sizeof(*e), GFP_USER); 61 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, e); 62 63 e->start = buf; 64 e->end = e->start + buf_size; 65 e->pos = e->start; 66 67 *buf = AA_NAME; 68 *(buf + 1) = strlen(TEST_STRING_NAME) + 1; 69 strcpy(buf + 3, TEST_STRING_NAME); 70 71 buf = e->start + TEST_STRING_BUF_OFFSET; 72 *buf = AA_STRING; 73 *(buf + 1) = strlen(TEST_STRING_DATA) + 1; 74 strcpy(buf + 3, TEST_STRING_DATA); 75 76 buf = e->start + TEST_NAMED_U32_BUF_OFFSET; 77 *buf = AA_NAME; 78 *(buf + 1) = strlen(TEST_U32_NAME) + 1; 79 strcpy(buf + 3, TEST_U32_NAME); 80 *(buf + 3 + strlen(TEST_U32_NAME) + 1) = AA_U32; 81 *((u32 *)(buf + 3 + strlen(TEST_U32_NAME) + 2)) = TEST_U32_DATA; 82 83 buf = e->start + TEST_NAMED_U64_BUF_OFFSET; 84 *buf = AA_NAME; 85 *(buf + 1) = strlen(TEST_U64_NAME) + 1; 86 strcpy(buf + 3, TEST_U64_NAME); 87 *(buf + 3 + strlen(TEST_U64_NAME) + 1) = AA_U64; 88 *((u64 *)(buf + 3 + strlen(TEST_U64_NAME) + 2)) = TEST_U64_DATA; 89 90 buf = e->start + TEST_NAMED_BLOB_BUF_OFFSET; 91 *buf = AA_NAME; 92 *(buf + 1) = strlen(TEST_BLOB_NAME) + 1; 93 strcpy(buf + 3, TEST_BLOB_NAME); 94 *(buf + 3 + strlen(TEST_BLOB_NAME) + 1) = AA_BLOB; 95 *(buf + 3 + strlen(TEST_BLOB_NAME) + 2) = TEST_BLOB_DATA_SIZE; 96 memcpy(buf + 3 + strlen(TEST_BLOB_NAME) + 6, 97 TEST_BLOB_DATA, TEST_BLOB_DATA_SIZE); 98 99 buf = e->start + TEST_NAMED_ARRAY_BUF_OFFSET; 100 *buf = AA_NAME; 101 *(buf + 1) = strlen(TEST_ARRAY_NAME) + 1; 102 strcpy(buf + 3, TEST_ARRAY_NAME); 103 *(buf + 3 + strlen(TEST_ARRAY_NAME) + 1) = AA_ARRAY; 104 *((u16 *)(buf + 3 + strlen(TEST_ARRAY_NAME) + 2)) = TEST_ARRAY_SIZE; 105 106 return e; 107 } 108 109 static int policy_unpack_test_init(struct kunit *test) 110 { 111 size_t e_size = TEST_ARRAY_BUF_OFFSET + sizeof(u16) + 1; 112 struct policy_unpack_fixture *puf; 113 114 puf = kunit_kmalloc(test, sizeof(*puf), GFP_USER); 115 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, puf); 116 117 puf->e_size = e_size; 118 puf->e = build_aa_ext_struct(puf, test, e_size); 119 120 test->priv = puf; 121 return 0; 122 } 123 124 static void policy_unpack_test_inbounds_when_inbounds(struct kunit *test) 125 { 126 struct policy_unpack_fixture *puf = test->priv; 127 128 KUNIT_EXPECT_TRUE(test, inbounds(puf->e, 0)); 129 KUNIT_EXPECT_TRUE(test, inbounds(puf->e, puf->e_size / 2)); 130 KUNIT_EXPECT_TRUE(test, inbounds(puf->e, puf->e_size)); 131 } 132 133 static void policy_unpack_test_inbounds_when_out_of_bounds(struct kunit *test) 134 { 135 struct policy_unpack_fixture *puf = test->priv; 136 137 KUNIT_EXPECT_FALSE(test, inbounds(puf->e, puf->e_size + 1)); 138 } 139 140 static void policy_unpack_test_unpack_array_with_null_name(struct kunit *test) 141 { 142 struct policy_unpack_fixture *puf = test->priv; 143 u16 array_size; 144 145 puf->e->pos += TEST_ARRAY_BUF_OFFSET; 146 147 array_size = unpack_array(puf->e, NULL); 148 149 KUNIT_EXPECT_EQ(test, array_size, (u16)TEST_ARRAY_SIZE); 150 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 151 puf->e->start + TEST_ARRAY_BUF_OFFSET + sizeof(u16) + 1); 152 } 153 154 static void policy_unpack_test_unpack_array_with_name(struct kunit *test) 155 { 156 struct policy_unpack_fixture *puf = test->priv; 157 const char name[] = TEST_ARRAY_NAME; 158 u16 array_size; 159 160 puf->e->pos += TEST_NAMED_ARRAY_BUF_OFFSET; 161 162 array_size = unpack_array(puf->e, name); 163 164 KUNIT_EXPECT_EQ(test, array_size, (u16)TEST_ARRAY_SIZE); 165 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 166 puf->e->start + TEST_ARRAY_BUF_OFFSET + sizeof(u16) + 1); 167 } 168 169 static void policy_unpack_test_unpack_array_out_of_bounds(struct kunit *test) 170 { 171 struct policy_unpack_fixture *puf = test->priv; 172 const char name[] = TEST_ARRAY_NAME; 173 u16 array_size; 174 175 puf->e->pos += TEST_NAMED_ARRAY_BUF_OFFSET; 176 puf->e->end = puf->e->start + TEST_ARRAY_BUF_OFFSET + sizeof(u16); 177 178 array_size = unpack_array(puf->e, name); 179 180 KUNIT_EXPECT_EQ(test, array_size, (u16)0); 181 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 182 puf->e->start + TEST_NAMED_ARRAY_BUF_OFFSET); 183 } 184 185 static void policy_unpack_test_unpack_blob_with_null_name(struct kunit *test) 186 { 187 struct policy_unpack_fixture *puf = test->priv; 188 char *blob = NULL; 189 size_t size; 190 191 puf->e->pos += TEST_BLOB_BUF_OFFSET; 192 size = unpack_blob(puf->e, &blob, NULL); 193 194 KUNIT_ASSERT_EQ(test, size, TEST_BLOB_DATA_SIZE); 195 KUNIT_EXPECT_TRUE(test, 196 memcmp(blob, TEST_BLOB_DATA, TEST_BLOB_DATA_SIZE) == 0); 197 } 198 199 static void policy_unpack_test_unpack_blob_with_name(struct kunit *test) 200 { 201 struct policy_unpack_fixture *puf = test->priv; 202 char *blob = NULL; 203 size_t size; 204 205 puf->e->pos += TEST_NAMED_BLOB_BUF_OFFSET; 206 size = unpack_blob(puf->e, &blob, TEST_BLOB_NAME); 207 208 KUNIT_ASSERT_EQ(test, size, TEST_BLOB_DATA_SIZE); 209 KUNIT_EXPECT_TRUE(test, 210 memcmp(blob, TEST_BLOB_DATA, TEST_BLOB_DATA_SIZE) == 0); 211 } 212 213 static void policy_unpack_test_unpack_blob_out_of_bounds(struct kunit *test) 214 { 215 struct policy_unpack_fixture *puf = test->priv; 216 char *blob = NULL; 217 void *start; 218 int size; 219 220 puf->e->pos += TEST_NAMED_BLOB_BUF_OFFSET; 221 start = puf->e->pos; 222 puf->e->end = puf->e->start + TEST_BLOB_BUF_OFFSET 223 + TEST_BLOB_DATA_SIZE - 1; 224 225 size = unpack_blob(puf->e, &blob, TEST_BLOB_NAME); 226 227 KUNIT_EXPECT_EQ(test, size, 0); 228 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, start); 229 } 230 231 static void policy_unpack_test_unpack_str_with_null_name(struct kunit *test) 232 { 233 struct policy_unpack_fixture *puf = test->priv; 234 const char *string = NULL; 235 size_t size; 236 237 puf->e->pos += TEST_STRING_BUF_OFFSET; 238 size = unpack_str(puf->e, &string, NULL); 239 240 KUNIT_EXPECT_EQ(test, size, strlen(TEST_STRING_DATA) + 1); 241 KUNIT_EXPECT_STREQ(test, string, TEST_STRING_DATA); 242 } 243 244 static void policy_unpack_test_unpack_str_with_name(struct kunit *test) 245 { 246 struct policy_unpack_fixture *puf = test->priv; 247 const char *string = NULL; 248 size_t size; 249 250 size = unpack_str(puf->e, &string, TEST_STRING_NAME); 251 252 KUNIT_EXPECT_EQ(test, size, strlen(TEST_STRING_DATA) + 1); 253 KUNIT_EXPECT_STREQ(test, string, TEST_STRING_DATA); 254 } 255 256 static void policy_unpack_test_unpack_str_out_of_bounds(struct kunit *test) 257 { 258 struct policy_unpack_fixture *puf = test->priv; 259 const char *string = NULL; 260 void *start = puf->e->pos; 261 int size; 262 263 puf->e->end = puf->e->pos + TEST_STRING_BUF_OFFSET 264 + strlen(TEST_STRING_DATA) - 1; 265 266 size = unpack_str(puf->e, &string, TEST_STRING_NAME); 267 268 KUNIT_EXPECT_EQ(test, size, 0); 269 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, start); 270 } 271 272 static void policy_unpack_test_unpack_strdup_with_null_name(struct kunit *test) 273 { 274 struct policy_unpack_fixture *puf = test->priv; 275 char *string = NULL; 276 size_t size; 277 278 puf->e->pos += TEST_STRING_BUF_OFFSET; 279 size = unpack_strdup(puf->e, &string, NULL); 280 281 KUNIT_EXPECT_EQ(test, size, strlen(TEST_STRING_DATA) + 1); 282 KUNIT_EXPECT_FALSE(test, 283 ((uintptr_t)puf->e->start <= (uintptr_t)string) 284 && ((uintptr_t)string <= (uintptr_t)puf->e->end)); 285 KUNIT_EXPECT_STREQ(test, string, TEST_STRING_DATA); 286 } 287 288 static void policy_unpack_test_unpack_strdup_with_name(struct kunit *test) 289 { 290 struct policy_unpack_fixture *puf = test->priv; 291 char *string = NULL; 292 size_t size; 293 294 size = unpack_strdup(puf->e, &string, TEST_STRING_NAME); 295 296 KUNIT_EXPECT_EQ(test, size, strlen(TEST_STRING_DATA) + 1); 297 KUNIT_EXPECT_FALSE(test, 298 ((uintptr_t)puf->e->start <= (uintptr_t)string) 299 && ((uintptr_t)string <= (uintptr_t)puf->e->end)); 300 KUNIT_EXPECT_STREQ(test, string, TEST_STRING_DATA); 301 } 302 303 static void policy_unpack_test_unpack_strdup_out_of_bounds(struct kunit *test) 304 { 305 struct policy_unpack_fixture *puf = test->priv; 306 void *start = puf->e->pos; 307 char *string = NULL; 308 int size; 309 310 puf->e->end = puf->e->pos + TEST_STRING_BUF_OFFSET 311 + strlen(TEST_STRING_DATA) - 1; 312 313 size = unpack_strdup(puf->e, &string, TEST_STRING_NAME); 314 315 KUNIT_EXPECT_EQ(test, size, 0); 316 KUNIT_EXPECT_PTR_EQ(test, string, (char *)NULL); 317 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, start); 318 } 319 320 static void policy_unpack_test_unpack_nameX_with_null_name(struct kunit *test) 321 { 322 struct policy_unpack_fixture *puf = test->priv; 323 bool success; 324 325 puf->e->pos += TEST_U32_BUF_OFFSET; 326 327 success = unpack_nameX(puf->e, AA_U32, NULL); 328 329 KUNIT_EXPECT_TRUE(test, success); 330 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 331 puf->e->start + TEST_U32_BUF_OFFSET + 1); 332 } 333 334 static void policy_unpack_test_unpack_nameX_with_wrong_code(struct kunit *test) 335 { 336 struct policy_unpack_fixture *puf = test->priv; 337 bool success; 338 339 puf->e->pos += TEST_U32_BUF_OFFSET; 340 341 success = unpack_nameX(puf->e, AA_BLOB, NULL); 342 343 KUNIT_EXPECT_FALSE(test, success); 344 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 345 puf->e->start + TEST_U32_BUF_OFFSET); 346 } 347 348 static void policy_unpack_test_unpack_nameX_with_name(struct kunit *test) 349 { 350 struct policy_unpack_fixture *puf = test->priv; 351 const char name[] = TEST_U32_NAME; 352 bool success; 353 354 puf->e->pos += TEST_NAMED_U32_BUF_OFFSET; 355 356 success = unpack_nameX(puf->e, AA_U32, name); 357 358 KUNIT_EXPECT_TRUE(test, success); 359 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 360 puf->e->start + TEST_U32_BUF_OFFSET + 1); 361 } 362 363 static void policy_unpack_test_unpack_nameX_with_wrong_name(struct kunit *test) 364 { 365 struct policy_unpack_fixture *puf = test->priv; 366 static const char name[] = "12345678"; 367 bool success; 368 369 puf->e->pos += TEST_NAMED_U32_BUF_OFFSET; 370 371 success = unpack_nameX(puf->e, AA_U32, name); 372 373 KUNIT_EXPECT_FALSE(test, success); 374 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 375 puf->e->start + TEST_NAMED_U32_BUF_OFFSET); 376 } 377 378 static void policy_unpack_test_unpack_u16_chunk_basic(struct kunit *test) 379 { 380 struct policy_unpack_fixture *puf = test->priv; 381 char *chunk = NULL; 382 size_t size; 383 384 puf->e->pos += TEST_U16_OFFSET; 385 /* 386 * WARNING: For unit testing purposes, we're pushing puf->e->end past 387 * the end of the allocated memory. Doing anything other than comparing 388 * memory addresses is dangerous. 389 */ 390 puf->e->end += TEST_U16_DATA; 391 392 size = unpack_u16_chunk(puf->e, &chunk); 393 394 KUNIT_EXPECT_PTR_EQ(test, (void *)chunk, 395 puf->e->start + TEST_U16_OFFSET + 2); 396 KUNIT_EXPECT_EQ(test, size, (size_t)TEST_U16_DATA); 397 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, (void *)(chunk + TEST_U16_DATA)); 398 } 399 400 static void policy_unpack_test_unpack_u16_chunk_out_of_bounds_1( 401 struct kunit *test) 402 { 403 struct policy_unpack_fixture *puf = test->priv; 404 char *chunk = NULL; 405 size_t size; 406 407 puf->e->pos = puf->e->end - 1; 408 409 size = unpack_u16_chunk(puf->e, &chunk); 410 411 KUNIT_EXPECT_EQ(test, size, (size_t)0); 412 KUNIT_EXPECT_PTR_EQ(test, chunk, (char *)NULL); 413 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, puf->e->end - 1); 414 } 415 416 static void policy_unpack_test_unpack_u16_chunk_out_of_bounds_2( 417 struct kunit *test) 418 { 419 struct policy_unpack_fixture *puf = test->priv; 420 char *chunk = NULL; 421 size_t size; 422 423 puf->e->pos += TEST_U16_OFFSET; 424 /* 425 * WARNING: For unit testing purposes, we're pushing puf->e->end past 426 * the end of the allocated memory. Doing anything other than comparing 427 * memory addresses is dangerous. 428 */ 429 puf->e->end = puf->e->pos + TEST_U16_DATA - 1; 430 431 size = unpack_u16_chunk(puf->e, &chunk); 432 433 KUNIT_EXPECT_EQ(test, size, (size_t)0); 434 KUNIT_EXPECT_PTR_EQ(test, chunk, (char *)NULL); 435 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, puf->e->start + TEST_U16_OFFSET); 436 } 437 438 static void policy_unpack_test_unpack_u32_with_null_name(struct kunit *test) 439 { 440 struct policy_unpack_fixture *puf = test->priv; 441 bool success; 442 u32 data; 443 444 puf->e->pos += TEST_U32_BUF_OFFSET; 445 446 success = unpack_u32(puf->e, &data, NULL); 447 448 KUNIT_EXPECT_TRUE(test, success); 449 KUNIT_EXPECT_EQ(test, data, TEST_U32_DATA); 450 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 451 puf->e->start + TEST_U32_BUF_OFFSET + sizeof(u32) + 1); 452 } 453 454 static void policy_unpack_test_unpack_u32_with_name(struct kunit *test) 455 { 456 struct policy_unpack_fixture *puf = test->priv; 457 const char name[] = TEST_U32_NAME; 458 bool success; 459 u32 data; 460 461 puf->e->pos += TEST_NAMED_U32_BUF_OFFSET; 462 463 success = unpack_u32(puf->e, &data, name); 464 465 KUNIT_EXPECT_TRUE(test, success); 466 KUNIT_EXPECT_EQ(test, data, TEST_U32_DATA); 467 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 468 puf->e->start + TEST_U32_BUF_OFFSET + sizeof(u32) + 1); 469 } 470 471 static void policy_unpack_test_unpack_u32_out_of_bounds(struct kunit *test) 472 { 473 struct policy_unpack_fixture *puf = test->priv; 474 const char name[] = TEST_U32_NAME; 475 bool success; 476 u32 data; 477 478 puf->e->pos += TEST_NAMED_U32_BUF_OFFSET; 479 puf->e->end = puf->e->start + TEST_U32_BUF_OFFSET + sizeof(u32); 480 481 success = unpack_u32(puf->e, &data, name); 482 483 KUNIT_EXPECT_FALSE(test, success); 484 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 485 puf->e->start + TEST_NAMED_U32_BUF_OFFSET); 486 } 487 488 static void policy_unpack_test_unpack_u64_with_null_name(struct kunit *test) 489 { 490 struct policy_unpack_fixture *puf = test->priv; 491 bool success; 492 u64 data; 493 494 puf->e->pos += TEST_U64_BUF_OFFSET; 495 496 success = unpack_u64(puf->e, &data, NULL); 497 498 KUNIT_EXPECT_TRUE(test, success); 499 KUNIT_EXPECT_EQ(test, data, TEST_U64_DATA); 500 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 501 puf->e->start + TEST_U64_BUF_OFFSET + sizeof(u64) + 1); 502 } 503 504 static void policy_unpack_test_unpack_u64_with_name(struct kunit *test) 505 { 506 struct policy_unpack_fixture *puf = test->priv; 507 const char name[] = TEST_U64_NAME; 508 bool success; 509 u64 data; 510 511 puf->e->pos += TEST_NAMED_U64_BUF_OFFSET; 512 513 success = unpack_u64(puf->e, &data, name); 514 515 KUNIT_EXPECT_TRUE(test, success); 516 KUNIT_EXPECT_EQ(test, data, TEST_U64_DATA); 517 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 518 puf->e->start + TEST_U64_BUF_OFFSET + sizeof(u64) + 1); 519 } 520 521 static void policy_unpack_test_unpack_u64_out_of_bounds(struct kunit *test) 522 { 523 struct policy_unpack_fixture *puf = test->priv; 524 const char name[] = TEST_U64_NAME; 525 bool success; 526 u64 data; 527 528 puf->e->pos += TEST_NAMED_U64_BUF_OFFSET; 529 puf->e->end = puf->e->start + TEST_U64_BUF_OFFSET + sizeof(u64); 530 531 success = unpack_u64(puf->e, &data, name); 532 533 KUNIT_EXPECT_FALSE(test, success); 534 KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, 535 puf->e->start + TEST_NAMED_U64_BUF_OFFSET); 536 } 537 538 static void policy_unpack_test_unpack_X_code_match(struct kunit *test) 539 { 540 struct policy_unpack_fixture *puf = test->priv; 541 bool success = unpack_X(puf->e, AA_NAME); 542 543 KUNIT_EXPECT_TRUE(test, success); 544 KUNIT_EXPECT_TRUE(test, puf->e->pos == puf->e->start + 1); 545 } 546 547 static void policy_unpack_test_unpack_X_code_mismatch(struct kunit *test) 548 { 549 struct policy_unpack_fixture *puf = test->priv; 550 bool success = unpack_X(puf->e, AA_STRING); 551 552 KUNIT_EXPECT_FALSE(test, success); 553 KUNIT_EXPECT_TRUE(test, puf->e->pos == puf->e->start); 554 } 555 556 static void policy_unpack_test_unpack_X_out_of_bounds(struct kunit *test) 557 { 558 struct policy_unpack_fixture *puf = test->priv; 559 bool success; 560 561 puf->e->pos = puf->e->end; 562 success = unpack_X(puf->e, AA_NAME); 563 564 KUNIT_EXPECT_FALSE(test, success); 565 } 566 567 static struct kunit_case apparmor_policy_unpack_test_cases[] = { 568 KUNIT_CASE(policy_unpack_test_inbounds_when_inbounds), 569 KUNIT_CASE(policy_unpack_test_inbounds_when_out_of_bounds), 570 KUNIT_CASE(policy_unpack_test_unpack_array_with_null_name), 571 KUNIT_CASE(policy_unpack_test_unpack_array_with_name), 572 KUNIT_CASE(policy_unpack_test_unpack_array_out_of_bounds), 573 KUNIT_CASE(policy_unpack_test_unpack_blob_with_null_name), 574 KUNIT_CASE(policy_unpack_test_unpack_blob_with_name), 575 KUNIT_CASE(policy_unpack_test_unpack_blob_out_of_bounds), 576 KUNIT_CASE(policy_unpack_test_unpack_nameX_with_null_name), 577 KUNIT_CASE(policy_unpack_test_unpack_nameX_with_wrong_code), 578 KUNIT_CASE(policy_unpack_test_unpack_nameX_with_name), 579 KUNIT_CASE(policy_unpack_test_unpack_nameX_with_wrong_name), 580 KUNIT_CASE(policy_unpack_test_unpack_str_with_null_name), 581 KUNIT_CASE(policy_unpack_test_unpack_str_with_name), 582 KUNIT_CASE(policy_unpack_test_unpack_str_out_of_bounds), 583 KUNIT_CASE(policy_unpack_test_unpack_strdup_with_null_name), 584 KUNIT_CASE(policy_unpack_test_unpack_strdup_with_name), 585 KUNIT_CASE(policy_unpack_test_unpack_strdup_out_of_bounds), 586 KUNIT_CASE(policy_unpack_test_unpack_u16_chunk_basic), 587 KUNIT_CASE(policy_unpack_test_unpack_u16_chunk_out_of_bounds_1), 588 KUNIT_CASE(policy_unpack_test_unpack_u16_chunk_out_of_bounds_2), 589 KUNIT_CASE(policy_unpack_test_unpack_u32_with_null_name), 590 KUNIT_CASE(policy_unpack_test_unpack_u32_with_name), 591 KUNIT_CASE(policy_unpack_test_unpack_u32_out_of_bounds), 592 KUNIT_CASE(policy_unpack_test_unpack_u64_with_null_name), 593 KUNIT_CASE(policy_unpack_test_unpack_u64_with_name), 594 KUNIT_CASE(policy_unpack_test_unpack_u64_out_of_bounds), 595 KUNIT_CASE(policy_unpack_test_unpack_X_code_match), 596 KUNIT_CASE(policy_unpack_test_unpack_X_code_mismatch), 597 KUNIT_CASE(policy_unpack_test_unpack_X_out_of_bounds), 598 {}, 599 }; 600 601 static struct kunit_suite apparmor_policy_unpack_test_module = { 602 .name = "apparmor_policy_unpack", 603 .init = policy_unpack_test_init, 604 .test_cases = apparmor_policy_unpack_test_cases, 605 }; 606 607 kunit_test_suite(apparmor_policy_unpack_test_module); 608