policy_unpack_test.c 18 KB

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