1 /*
2 * Check decoding of keyctl syscall.
3 *
4 * Copyright (c) 2016 Eugene Syromyatnikov <evgsyr@gmail.com>
5 * Copyright (c) 2016-2022 The strace developers.
6 * All rights reserved.
7 *
8 * SPDX-License-Identifier: GPL-2.0-or-later
9 */
10
11 #include "tests.h"
12 #include "scno.h"
13 #include "xmalloc.h"
14
15 #include <assert.h>
16 #include <errno.h>
17 #include <inttypes.h>
18 #include <stdarg.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <unistd.h>
23 #include <sys/uio.h>
24 #include <sys/wait.h>
25 #include <linux/keyctl.h>
26
27 #include "xlat.h"
28 #include "xlat/keyctl_caps0.h"
29 #include "xlat/keyctl_caps1.h"
30
31 static const size_t limit = 10;
32
33 static pid_t pid;
34
35 /*
36 * Well, this is true for DESCRIBE and GET_SECURITY, and false for READ and
37 * DH_COMPUTE and I see no ability to pass this information without
38 * significantly breaking interface.
39 */
40 static bool nul_terminated_buf = true;
41 static bool buf_in_arg;
42
43 /* From ioctl_dm.c */
44 #define STR32 "AbCdEfGhIjKlMnOpQrStUvWxYz012345"
45
46 #if XLAT_RAW
47 # define XARG_STR(v_) (v_), STRINGIFY(v_)
48 # define XSTR(v_, s_) STRINGIFY(v_)
49 #elif XLAT_VERBOSE
50 # define XARG_STR(v_) (v_), STRINGIFY(v_) " /* " #v_ " */"
51 # define XSTR(v_, s_) STRINGIFY(v_) " /* " s_ " */"
52 #else
53 # define XARG_STR ARG_STR
54 # define XSTR(v_, s_) s_
55 #endif
56
57 /*
58 * When this is called with positive size, the buffer provided is an "out"
59 * argument and rc contains resulting size (globally defined nul_terminated_buf
60 * controls whether it is nul-terminated or not). If size is negative,
61 * it contains "in" argument.
62 */
63 static void
64 print_quoted_string_limit(const char *str, size_t size, long rc)
65 {
66 size_t print_size = ((rc >= 0) && (size > 0)) ?
67 ((unsigned long) rc > size ? size :
68 (unsigned long) rc) : size;
69 size_t limited_size = print_size > limit ? limit : print_size;
70
71 if ((rc == -1) && !buf_in_arg) {
72 printf("%p", str);
73 return;
74 }
75
76 if (!nul_terminated_buf ||
77 (strnlen(str, limited_size) == limited_size)) {
78 print_quoted_memory(str, limited_size);
79 if (print_size > limit)
80 printf("...");
81 } else
82 print_quoted_string(str);
83 }
84
85 static void
86 print_arg(kernel_ulong_t arg, const char *str, const char *fmt, size_t size,
87 long rc)
88 {
89 if (size == (size_t) -1)
90 size = 0;
91
92 if (str) {
93 printf("%s", str);
94 } else {
95 if (size == sizeof(uint64_t))
96 printf(fmt, (uint64_t) arg);
97 else if (size == sizeof(uint32_t))
98 printf(fmt, (uint32_t) arg);
99 else
100 print_quoted_string_limit((void *) (uintptr_t) arg,
101 size, rc);
102 }
103 }
104
105 static void
106 print_flags(const struct xlat *xlat, unsigned long long flags,
107 const char *const dflt)
108 {
109 #if XLAT_RAW
110 printf("%#llx", flags);
111 #elif XLAT_VERBOSE
112 printf("%#llx /* ", flags);
113 printflags(xlat, flags, dflt);
114 printf(" */");
115 #else
116 printflags(xlat, flags, dflt);
117 #endif
118 }
119
120 /*
121 * Arguments are passed as sz, val, str, fmt. Arguments are read until 4
122 * arguments are retrieved or size of 0 is occurred.
123 *
124 * str == NULL && fmt == NULL && sz not in {4, 8} - print_quoted_string_limit is
125 * used for argument printing. If sz is negative, in argument is assumed, out
126 * otherwise.
127 */
128 static void
129 do_keyctl(kernel_ulong_t cmd, const char *cmd_str, ...)
130 {
131 kernel_ulong_t args[4] = {
132 (kernel_ulong_t) 0xdeadfee1badc0de5ULL,
133 (kernel_ulong_t) 0xdeadfee2badc0de6ULL,
134 (kernel_ulong_t) 0xdeadfee3badc0de7ULL,
135 (kernel_ulong_t) 0xdeadfee4badc0de8ULL,
136 };
137 const char *arg_str[4] = { NULL };
138 const char *arg_fmt[4] = { "%llu", "%llu", "%llu", "%llu" };
139 size_t arg_sz[4] = {
140 sizeof(kernel_ulong_t),
141 sizeof(kernel_ulong_t),
142 sizeof(kernel_ulong_t),
143 sizeof(kernel_ulong_t),
144 };
145 unsigned cnt = 0;
146
147 va_list ap;
148
149 va_start(ap, cmd_str);
150
151 do {
152 arg_sz[cnt] = va_arg(ap, size_t);
153 if (!arg_sz[cnt])
154 break;
155
156 if (arg_sz[cnt] == sizeof(uint64_t))
157 args[cnt] = va_arg(ap, uint64_t);
158 else if (arg_sz[cnt] == sizeof(uint32_t))
159 args[cnt] = va_arg(ap, uint32_t);
160 else
161 args[cnt] = (uintptr_t) va_arg(ap, void *);
162
163 arg_str[cnt] = va_arg(ap, char *);
164 arg_fmt[cnt] = va_arg(ap, char *);
165 } while (++cnt < 4);
166
167 long rc = syscall(__NR_keyctl, cmd, args[0], args[1], args[2], args[3]);
168 const char *errstr = sprintrc(rc);
169 #if XLAT_RAW
170 printf("%-5u keyctl(%#x", pid, (unsigned) cmd);
171 #elif XLAT_VERBOSE
172 printf("%-5u keyctl(%#x /* %s */", pid, (unsigned) cmd, cmd_str);
173 #else
174 printf("%-5u keyctl(%s", pid, cmd_str);
175 #endif
176 for (unsigned int i = 0; i < cnt; ++i) {
177 printf(", ");
178 print_arg(args[i], arg_str[i], arg_fmt[i], arg_sz[i], rc);
179 }
180 printf(") = %s\n", errstr);
181 }
182
183 static int ATTRIBUTE_FORMAT((__printf__, 3, 4))
184 append_str(char **buf, size_t *left, const char *fmt, ...)
185 {
186 int ret;
187 va_list ap;
188
189 va_start(ap, fmt);
190 ret = vsnprintf(*buf, *left, fmt, ap);
191 va_end(ap);
192
193 assert((ret >= 0) && ((unsigned) ret < *left));
194
195 *left -= ret;
196 *buf += ret;
197
198 return ret;
199 }
200
201 static const char *
202 kckdfp_to_str(struct keyctl_kdf_params *kdf, bool deref_hash, bool deref_oi,
203 bool print_spare, const char *hash_str, const char *oi_str)
204 {
205 static char buf[4096];
206
207 size_t left = sizeof(buf);
208 char *pos = buf;
209
210 append_str(&pos, &left, "{hashname=");
211
212 if (deref_hash && hash_str) {
213 append_str(&pos, &left, "%s", hash_str);
214 } else if (!kdf->hashname) {
215 append_str(&pos, &left, "NULL");
216 } else if (deref_hash) {
217 append_str(&pos, &left, "\"%.*s\"", (int) limit, kdf->hashname);
218
219 if (strnlen(kdf->hashname, limit + 1) > limit)
220 append_str(&pos, &left, "...");
221 } else {
222 append_str(&pos, &left, "%p", kdf->hashname);
223 }
224
225 append_str(&pos, &left, ", otherinfo=");
226
227 if (deref_oi && oi_str) {
228 append_str(&pos, &left, "%s", oi_str);
229 } else if (!kdf->otherinfo) {
230 append_str(&pos, &left, "NULL");
231 } else if (deref_oi) {
232 append_str(&pos, &left, "\"%.*s\"", (int) limit, kdf->otherinfo);
233
234 if (strnlen(kdf->otherinfo, limit + 1) > limit)
235 append_str(&pos, &left, "...");
236 } else {
237 append_str(&pos, &left, "%p", kdf->otherinfo);
238 }
239
240 append_str(&pos, &left, ", otherinfolen=%u", kdf->otherinfolen);
241
242 if (print_spare) {
243 append_str(&pos, &left, ", __spare=[");
244
245 for (size_t i = 0; i < ARRAY_SIZE(kdf->__spare); ++i) {
246 if (i)
247 append_str(&pos, &left, ", ");
248
249 append_str(&pos, &left, "%#x", kdf->__spare[i]);
250 }
251
252 append_str(&pos, &left, "]");
253 }
254
255 append_str(&pos, &left, "}");
256
257 return buf;
258 }
259
260 static const char *
261 kcpp_to_str(struct keyctl_pkey_params *params, bool out, const char *key_str,
262 bool print_spare)
263 {
264 static char buf[4096];
265
266 size_t left = sizeof(buf);
267 char *pos = buf;
268
269 append_str(&pos, &left, "{key_id=");
270
271 #if XLAT_RAW
272 append_str(&pos, &left, "%d", params->key_id);
273 #elif XLAT_VERBOSE
274 if (key_str)
275 append_str(&pos, &left, "%d /* %s */", params->key_id, key_str);
276 else
277 append_str(&pos, &left, "%d", params->key_id);
278 #else
279 if (key_str)
280 append_str(&pos, &left, "%s", key_str);
281 else
282 append_str(&pos, &left, "%d", params->key_id);
283 #endif
284
285 append_str(&pos, &left, ", in_len=%u, %s=%u",
286 params->in_len,
287 out ? "out_len" : "in2_len", params->out_len);
288
289 if (print_spare) {
290 append_str(&pos, &left, ", __spare=[");
291
292 for (size_t i = 0; i < ARRAY_SIZE(params->__spare); i++) {
293 append_str(&pos, &left, "%s%#x",
294 i ? ", " : "", params->__spare[i]);
295 }
296
297 append_str(&pos, &left, "]");
298 }
299
300 append_str(&pos, &left, "}");
301
302 return buf;
303 }
304
305 int
306 main(void)
307 {
308 pid = fork();
309 if (pid < 0)
310 perror_msg_and_fail("fork");
311 if (pid) {
312 int s;
313 pid_t rc;
314 while ((rc = waitpid(pid, &s, 0)) != pid) {
315 if (rc < 0 && errno == EINTR)
316 continue;
317 perror_msg_and_fail("waitpid: %d", pid);
318 }
319 printf("%-5u +++ exited with 0 +++\n", getpid());
320 return WIFEXITED(s) ? WEXITSTATUS(s)
321 : (WIFSIGNALED(s) ? 128 + WTERMSIG(s) : 9);
322 }
323 pid = getpid();
324
325 enum { PR_LIMIT = 10, IOV_SIZE = 11, IOV_STR_SIZE = 4096 };
326
327 static const char *kulong_fmt =
328 sizeof(kernel_ulong_t) == sizeof(uint64_t) ? "%#llx" : "%#x";
329 static const char *ksize_fmt =
330 sizeof(kernel_ulong_t) == sizeof(uint64_t) ? "%llu" : "%u";
331 static const char *ptr_fmt =
332 sizeof(void *) == sizeof(uint64_t) ? "%#llx" : "%#x";
333 static const char unterminated1[] = { '\1', '\2', '\3', '\4', '\5' };
334 static const char unterminated2[] = { '\6', '\7', '\10', '\11', '\12' };
335 static const char short_type_str[] = "shrt type";
336 static const char short_desc_str[] = "shrt desc";
337 static const char long_type_str[] = "overly long key type";
338 static const char long_desc_str[] = "overly long key description";
339 static const int32_t bogus_key1 = 0xdeadf00d;
340 static const int32_t bogus_key2 = 0x1eefdead;
341 static const kernel_ulong_t bogus_key3 =
342 (kernel_ulong_t) 0xdec0ded1dec0ded2ULL;
343 static const char *bogus_key3_str = "-557785390";
344
345 static const struct keyctl_dh_params kcdhp_data = {
346 { .private = KEY_SPEC_GROUP_KEYRING },
347 .prime = 1234567890,
348 .base = 3141592653U
349 };
350 static const char *kcdhp_str = "{private="
351 #if XLAT_RAW || XLAT_VERBOSE
352 "-6"
353 #endif
354 #if XLAT_VERBOSE
355 " /* "
356 #endif
357 #if !XLAT_RAW
358 "KEY_SPEC_GROUP_KEYRING"
359 #endif
360 #if XLAT_VERBOSE
361 " */"
362 #endif
363 ", prime=1234567890, base=-1153374643}";
364
365 /*
366 * It's bigger than current hash name size limit, but since it's
367 * implementation-dependent and totally internal, we do not rely
368 * on it much.
369 */
370 static const char long_hash_data[] = STR32 STR32 STR32 STR32 "xxx";
371 static const char short_hash_data[] = "hmac(aes)";
372 static const char otherinfo1_data[] = "\1\2 OH HAI THAR\255\0\1";
373 static const char otherinfo2_data[] = "\1\2\n\255\0\1";
374 static const struct keyctl_kdf_params kckdfp_data[] = {
375 [0] = { NULL, NULL, 0, { 0 } },
376 [1] = { NULL /* Changed to unaccessible address in copy */,
377 NULL, 0xbadc0dedU, { [7] = 0xdeadfeedU } },
378 [2] = { NULL /* long_hash_data */,
379 NULL /* Changed to unaccessible address in copy */,
380 0, { 0 } },
381 [3] = { NULL /* unterminated1 */,
382 NULL /* otherinfo_data */, 0, { 1 } },
383 [4] = { NULL /* short_hash_data */,
384 NULL /* otherinfo1_data */, sizeof(otherinfo1_data),
385 { 0, 0xfacebeef, 0, 0xba5e1ead } },
386 [5] = { NULL /* short_hash_data */,
387 NULL /* otherinfo2_data */, sizeof(otherinfo2_data),
388 { 0 } },
389 };
390
391 char *bogus_str = tail_memdup(unterminated1, sizeof(unterminated1));
392 char *bogus_desc = tail_memdup(unterminated2, sizeof(unterminated2));
393 char *short_type = tail_memdup(short_type_str, sizeof(short_type_str));
394 char *short_desc = tail_memdup(short_desc_str, sizeof(short_desc_str));
395 char *long_type = tail_memdup(long_type_str, sizeof(long_type_str));
396 char *long_desc = tail_memdup(long_desc_str, sizeof(long_desc_str));
397 char *kcdhp = tail_memdup(&kcdhp_data, sizeof(kcdhp_data));
398 char *kckdfp_long_hash = tail_memdup(long_hash_data,
399 sizeof(long_hash_data));
400 char *kckdfp_short_hash = tail_memdup(short_hash_data,
401 sizeof(short_hash_data));
402 char *kckdfp_otherinfo1 = tail_memdup(otherinfo1_data,
403 sizeof(otherinfo1_data));
404 char *kckdfp_otherinfo2 = tail_memdup(otherinfo2_data,
405 sizeof(otherinfo2_data));
406 char *kckdfp_char = tail_alloc(sizeof(kckdfp_data[0]));
407 struct iovec *key_iov = tail_alloc(sizeof(*key_iov) * IOV_SIZE);
408 char *bogus_buf1 = tail_alloc(9);
409 char *bogus_buf2 = tail_alloc(256);
410 char *key_iov_str2 = tail_alloc(4096);
411 const char *errstr;
412 ssize_t ret;
413 ssize_t kis_size = 0;
414 long rc;
415
416 key_iov[0].iov_base = short_type;
417 key_iov[0].iov_len = sizeof(short_type_str);
418 key_iov[1].iov_base = long_type;
419 key_iov[1].iov_len = sizeof(long_type_str);
420 key_iov[2].iov_base = short_desc;
421 key_iov[2].iov_len = sizeof(short_desc_str);
422 key_iov[3].iov_base = long_desc;
423 key_iov[3].iov_len = sizeof(long_desc_str);
424 key_iov[4].iov_base = bogus_str;
425 key_iov[4].iov_len = 32;
426
427 for (size_t i = 5; i < IOV_SIZE; ++i) {
428 key_iov[i].iov_base =
429 (void *) (uintptr_t) (0xfffffacefffff00dULL +
430 0x100000001ULL * i);
431 key_iov[i].iov_len = (size_t) (0xcaffeeeddefaced7ULL +
432 0x100000001ULL * i);
433 }
434
435 char *key_iov_str1 = xasprintf("[{iov_base=%p, iov_len=%zu}, "
436 "{iov_base=%p, iov_len=%zu}, "
437 "{iov_base=%p, iov_len=%zu}, "
438 "{iov_base=%p, iov_len=%zu}]",
439 key_iov[IOV_SIZE - 4].iov_base,
440 key_iov[IOV_SIZE - 4].iov_len,
441 key_iov[IOV_SIZE - 3].iov_base,
442 key_iov[IOV_SIZE - 3].iov_len,
443 key_iov[IOV_SIZE - 2].iov_base,
444 key_iov[IOV_SIZE - 2].iov_len,
445 key_iov[IOV_SIZE - 1].iov_base,
446 key_iov[IOV_SIZE - 1].iov_len);
447
448 ret = snprintf(key_iov_str2, IOV_STR_SIZE,
449 "[{iov_base=\"%s\\0\", iov_len=%zu}, "
450 "{iov_base=\"%.10s\"..., iov_len=%zu}, "
451 "{iov_base=\"%s\\0\", iov_len=%zu}, "
452 "{iov_base=\"%.10s\"..., iov_len=%zu}, ",
453 (char *) key_iov[0].iov_base, key_iov[0].iov_len,
454 (char *) key_iov[1].iov_base, key_iov[1].iov_len,
455 (char *) key_iov[2].iov_base, key_iov[2].iov_len,
456 (char *) key_iov[3].iov_base, key_iov[3].iov_len);
457
458 if ((ret < 0) || (ret >= IOV_STR_SIZE))
459 error_msg_and_fail("snprintf");
460
461 for (size_t i = 4; i < PR_LIMIT; ++i) {
462 kis_size += ret;
463
464 ret = snprintf(key_iov_str2 + kis_size, IOV_STR_SIZE - kis_size,
465 "{iov_base=%p, iov_len=%zu}, ",
466 key_iov[i].iov_base, key_iov[i].iov_len);
467
468 if ((ret < 0) || (ret >= (IOV_STR_SIZE - kis_size)))
469 error_msg_and_fail("snprintf");
470 }
471
472 kis_size += ret;
473 snprintf(key_iov_str2 + kis_size, IOV_STR_SIZE - kis_size, "...]");
474
475
476 /* Invalid command */
477 do_keyctl((kernel_ulong_t) 0xbadc0dedfacefeedULL,
478 #if XLAT_VERBOSE
479 "KEYCTL_???"
480 #else
481 "0xfacefeed"
482 # if !XLAT_RAW
483 " /* KEYCTL_??? */"
484 # endif
485 #endif
486 ,
487 sizeof(kernel_ulong_t),
488 (kernel_ulong_t) 0xdeadfee1badc0de5ULL, NULL,
489 kulong_fmt,
490 sizeof(kernel_ulong_t),
491 (kernel_ulong_t) 0xdeadfee2badc0de6ULL, NULL,
492 kulong_fmt,
493 sizeof(kernel_ulong_t),
494 (kernel_ulong_t) 0xdeadfee3badc0de7ULL, NULL,
495 kulong_fmt,
496 sizeof(kernel_ulong_t),
497 (kernel_ulong_t) 0xdeadfee4badc0de8ULL, NULL,
498 kulong_fmt);
499
500
501 /* GET_KEYRING_ID */
502 do_keyctl(ARG_STR(KEYCTL_GET_KEYRING_ID),
503 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
504 sizeof(kernel_ulong_t),
505 (kernel_ulong_t) 0xbadc0dedffffffffLLU, "-1", NULL,
506 0UL);
507 do_keyctl(ARG_STR(KEYCTL_GET_KEYRING_ID),
508 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), "%d",
509 sizeof(int), 3141592653U, NULL, "%d", NULL,
510 0UL);
511
512
513 /* KEYCTL_JOIN_SESSION_KEYRING */
514 do_keyctl(ARG_STR(KEYCTL_JOIN_SESSION_KEYRING),
515 sizeof(char *), ARG_STR(NULL), NULL,
516 0UL);
517 do_keyctl(ARG_STR(KEYCTL_JOIN_SESSION_KEYRING),
518 sizeof(char *), (char *) 0xfffffacefffffeedULL, NULL, ptr_fmt,
519 0UL);
520 do_keyctl(ARG_STR(KEYCTL_JOIN_SESSION_KEYRING),
521 sizeof(char *), bogus_str, NULL, ptr_fmt,
522 0UL);
523 do_keyctl(ARG_STR(KEYCTL_JOIN_SESSION_KEYRING),
524 sizeof(char *), ARG_STR("bogus name"), NULL,
525 0UL);
526 do_keyctl(ARG_STR(KEYCTL_JOIN_SESSION_KEYRING),
527 sizeof(char *), "very long keyring name", "\"very long \"...",
528 NULL,
529 0UL);
530
531
532 /* KEYCTL_UPDATE */
533
534 buf_in_arg = true;
535
536 do_keyctl(ARG_STR(KEYCTL_UPDATE),
537 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
538 sizeof(char *), ARG_STR(NULL), NULL,
539 sizeof(kernel_ulong_t), (kernel_ulong_t) 0, NULL, ksize_fmt,
540 0UL);
541 do_keyctl(ARG_STR(KEYCTL_UPDATE),
542 sizeof(int32_t), bogus_key1, NULL, "%d",
543 sizeof(char *), (char *) 0xfffffacefffffeedULL, NULL, ptr_fmt,
544 sizeof(kernel_ulong_t),
545 (kernel_ulong_t) 0xdeadfee4badc0de8ULL, NULL, ksize_fmt,
546 0UL);
547 do_keyctl(ARG_STR(KEYCTL_UPDATE),
548 sizeof(int32_t), bogus_key2, NULL, "%d",
549 sizeof(char *), bogus_str, NULL, ptr_fmt,
550 sizeof(kernel_ulong_t),
551 (kernel_ulong_t) 0xdeadfee4badc0de8ULL, NULL, ksize_fmt,
552 0UL);
553 do_keyctl(ARG_STR(KEYCTL_UPDATE),
554 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
555 sizeof(short_desc_str), short_desc, NULL, NULL,
556 sizeof(kernel_ulong_t),
557 (kernel_ulong_t) sizeof(short_desc_str) - 1, NULL,
558 ksize_fmt,
559 0UL);
560
561 buf_in_arg = false;
562
563
564 /* KEYCTL_REVOKE */
565 do_keyctl(ARG_STR(KEYCTL_REVOKE),
566 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
567 0UL);
568 do_keyctl(ARG_STR(KEYCTL_REVOKE),
569 sizeof(int32_t), bogus_key1, NULL, "%d",
570 0UL);
571 do_keyctl(ARG_STR(KEYCTL_REVOKE),
572 sizeof(int32_t), bogus_key2, NULL, "%d",
573 0UL);
574 do_keyctl(ARG_STR(KEYCTL_REVOKE),
575 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
576 0UL);
577
578
579 /* KEYCTL_CHOWN */
580 do_keyctl(ARG_STR(KEYCTL_CHOWN),
581 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
582 sizeof(uid_t), ARG_STR(-1), NULL,
583 sizeof(gid_t), ARG_STR(-1), NULL,
584 0UL);
585 do_keyctl(ARG_STR(KEYCTL_CHOWN),
586 sizeof(int32_t), bogus_key1, NULL, "%d",
587 sizeof(uid_t), 2718281828U, NULL, "%u",
588 sizeof(gid_t), 3141592653U, NULL, "%u",
589 0UL);
590
591
592 /* KEYCTL_SETPERM */
593 do_keyctl(ARG_STR(KEYCTL_SETPERM),
594 sizeof(int32_t), XARG_STR(KEY_SPEC_REQKEY_AUTH_KEY), NULL,
595 sizeof(uint32_t), 0xffffffffU,
596 #if XLAT_RAW || XLAT_VERBOSE
597 "0xffffffff"
598 #endif
599 #if XLAT_VERBOSE
600 " /* "
601 #endif
602 #if !XLAT_RAW
603 "KEY_POS_VIEW|KEY_POS_READ|KEY_POS_WRITE|"
604 "KEY_POS_SEARCH|KEY_POS_LINK|KEY_POS_SETATTR|"
605 "KEY_USR_VIEW|KEY_USR_READ|KEY_USR_WRITE|"
606 "KEY_USR_SEARCH|KEY_USR_LINK|KEY_USR_SETATTR|"
607 "KEY_GRP_VIEW|KEY_GRP_READ|KEY_GRP_WRITE|"
608 "KEY_GRP_SEARCH|KEY_GRP_LINK|KEY_GRP_SETATTR|"
609 "KEY_OTH_VIEW|KEY_OTH_READ|KEY_OTH_WRITE|"
610 "KEY_OTH_SEARCH|KEY_OTH_LINK|KEY_OTH_SETATTR|"
611 "0xc0c0c0c0"
612 #endif
613 #if XLAT_VERBOSE
614 " */"
615 #endif
616 , NULL,
617 0UL);
618 do_keyctl(ARG_STR(KEYCTL_SETPERM),
619 sizeof(int32_t), bogus_key1, NULL, "%d",
620 sizeof(uint32_t), 0, NULL, "%#x",
621 0UL);
622 do_keyctl(ARG_STR(KEYCTL_SETPERM),
623 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
624 sizeof(uint32_t), 0xc0c0c0c0,
625 "0xc0c0c0c0"
626 #if !XLAT_RAW
627 " /* KEY_??? */"
628 #endif
629 ,
630 NULL,
631 0UL);
632
633
634 /* KEYCTL_DESCRIBE */
635 do_keyctl(ARG_STR(KEYCTL_DESCRIBE),
636 sizeof(int32_t), bogus_key1, NULL, "%d",
637 sizeof(char *), ARG_STR(NULL), ptr_fmt,
638 sizeof(kernel_ulong_t),
639 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
640 0UL);
641 do_keyctl(ARG_STR(KEYCTL_DESCRIBE),
642 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
643 sizeof(char *), ARG_STR(NULL), ptr_fmt,
644 sizeof(kernel_ulong_t),
645 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
646 0UL);
647 do_keyctl(ARG_STR(KEYCTL_DESCRIBE),
648 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
649 (size_t) 9, (uintptr_t) bogus_buf1, NULL, NULL,
650 sizeof(kernel_ulong_t), (kernel_ulong_t) 9, NULL, ksize_fmt,
651 0UL);
652 do_keyctl(ARG_STR(KEYCTL_DESCRIBE),
653 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
654 (size_t) 256, (uintptr_t) bogus_buf2, NULL, NULL,
655 sizeof(kernel_ulong_t), (kernel_ulong_t) 256, NULL, ksize_fmt,
656 0UL);
657 do_keyctl(ARG_STR(KEYCTL_DESCRIBE),
658 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
659 (size_t) -4, (uintptr_t) bogus_buf2, NULL, NULL,
660 sizeof(kernel_ulong_t), (kernel_ulong_t) -4, NULL, ksize_fmt,
661 0UL);
662
663
664 /* KEYCTL_CLEAR */
665 do_keyctl(ARG_STR(KEYCTL_CLEAR),
666 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
667 0UL);
668 do_keyctl(ARG_STR(KEYCTL_CLEAR),
669 sizeof(int32_t), bogus_key1, NULL, "%d",
670 0UL);
671 do_keyctl(ARG_STR(KEYCTL_CLEAR),
672 sizeof(int32_t), bogus_key2, NULL, "%d",
673 0UL);
674 do_keyctl(ARG_STR(KEYCTL_CLEAR),
675 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
676 0UL);
677
678
679 /* KEYCTL_LINK */
680 do_keyctl(ARG_STR(KEYCTL_LINK),
681 sizeof(int32_t), bogus_key1, NULL, "%d",
682 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
683 0UL);
684 do_keyctl(ARG_STR(KEYCTL_LINK),
685 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
686 sizeof(int32_t), bogus_key2, NULL, "%d",
687 0UL);
688 do_keyctl(ARG_STR(KEYCTL_LINK),
689 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
690 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
691 0UL);
692
693
694 /* KEYCTL_UNLINK */
695 do_keyctl(ARG_STR(KEYCTL_UNLINK),
696 sizeof(int32_t), bogus_key1, NULL, "%d",
697 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
698 0UL);
699 do_keyctl(ARG_STR(KEYCTL_UNLINK),
700 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
701 sizeof(int32_t), bogus_key2, NULL, "%d",
702 0UL);
703 do_keyctl(ARG_STR(KEYCTL_UNLINK),
704 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
705 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
706 0UL);
707
708
709 /* KEYCTL_SEARCH */
710 buf_in_arg = true;
711
712 do_keyctl(ARG_STR(KEYCTL_SEARCH),
713 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
714 sizeof(char *), ARG_STR(NULL), NULL,
715 sizeof(char *), ARG_STR(NULL), NULL,
716 sizeof(int32_t), 0, NULL, "%d");
717 do_keyctl(ARG_STR(KEYCTL_SEARCH),
718 sizeof(int32_t), bogus_key1, NULL, "%d",
719 sizeof(char *), (char *) 0xfffffacefffffeedULL, NULL, ptr_fmt,
720 sizeof(char *), (char *) 0xfffff00dfffff157ULL, NULL, ptr_fmt,
721 sizeof(int32_t), XARG_STR(KEY_SPEC_USER_SESSION_KEYRING),
722 NULL);
723 do_keyctl(ARG_STR(KEYCTL_SEARCH),
724 sizeof(int32_t), bogus_key2, NULL, "%d",
725 sizeof(char *), bogus_str, NULL, ptr_fmt,
726 sizeof(char *), bogus_desc, NULL, ptr_fmt,
727 sizeof(int32_t), bogus_key1, NULL, "%d");
728 do_keyctl(ARG_STR(KEYCTL_SEARCH),
729 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
730 sizeof(short_type_str), short_type, NULL, NULL,
731 sizeof(short_desc_str), short_desc, NULL, NULL,
732 sizeof(int32_t), bogus_key2, NULL, "%d");
733 do_keyctl(ARG_STR(KEYCTL_SEARCH),
734 sizeof(int32_t), 0, NULL, "%d",
735 sizeof(long_type_str), long_type, NULL, NULL,
736 sizeof(long_type_str), long_desc, NULL, NULL,
737 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL);
738
739 /* KEYCTL_RESTRICT_KEYRING */
740
741 do_keyctl(ARG_STR(KEYCTL_RESTRICT_KEYRING),
742 sizeof(int32_t), XARG_STR(KEY_SPEC_REQUESTOR_KEYRING), NULL,
743 sizeof(char *), ARG_STR(NULL), NULL,
744 sizeof(char *), ARG_STR(NULL), NULL,
745 NULL);
746 do_keyctl(ARG_STR(KEYCTL_RESTRICT_KEYRING),
747 sizeof(int32_t), bogus_key1, NULL, "%d",
748 sizeof(char *), (char *) 0xfffffacefffffeedULL, NULL, ptr_fmt,
749 sizeof(char *), (char *) 0xfffff00dfffff157ULL, NULL, ptr_fmt,
750 NULL);
751 do_keyctl(ARG_STR(KEYCTL_RESTRICT_KEYRING),
752 sizeof(int32_t), bogus_key2, NULL, "%d",
753 sizeof(char *), bogus_str, NULL, ptr_fmt,
754 sizeof(char *), bogus_desc, NULL, ptr_fmt,
755 NULL);
756 do_keyctl(ARG_STR(KEYCTL_RESTRICT_KEYRING),
757 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
758 sizeof(short_type_str), short_type, NULL, NULL,
759 sizeof(short_desc_str), short_desc, NULL, NULL,
760 NULL);
761 do_keyctl(ARG_STR(KEYCTL_RESTRICT_KEYRING),
762 sizeof(int32_t), 0, NULL, "%d",
763 sizeof(long_type_str), long_type, NULL, NULL,
764 sizeof(long_type_str), long_desc, NULL, NULL,
765 NULL);
766
767 buf_in_arg = false;
768
769
770 /* KEYCTL_READ */
771 nul_terminated_buf = false;
772
773 /* Empty result is expected for these */
774 bogus_buf1[0] = '\377';
775 bogus_buf2[0] = '\377';
776
777 do_keyctl(ARG_STR(KEYCTL_READ),
778 sizeof(int32_t), bogus_key1, NULL, "%d",
779 sizeof(char *), ARG_STR(NULL), ptr_fmt,
780 sizeof(kernel_ulong_t),
781 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
782 0UL);
783 do_keyctl(ARG_STR(KEYCTL_READ),
784 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
785 sizeof(char *), ARG_STR(NULL), ptr_fmt,
786 sizeof(kernel_ulong_t),
787 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
788 0UL);
789 do_keyctl(ARG_STR(KEYCTL_READ),
790 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
791 (size_t) 9, (uintptr_t) bogus_buf1, NULL, NULL,
792 sizeof(kernel_ulong_t), (kernel_ulong_t) 9, NULL, ksize_fmt,
793 0UL);
794 do_keyctl(ARG_STR(KEYCTL_READ),
795 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
796 (size_t) 256, (uintptr_t) bogus_buf2, NULL, NULL,
797 sizeof(kernel_ulong_t), (kernel_ulong_t) 256, NULL, ksize_fmt,
798 0UL);
799 do_keyctl(ARG_STR(KEYCTL_READ),
800 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
801 (size_t) -4, (uintptr_t) bogus_buf2, NULL, NULL,
802 sizeof(kernel_ulong_t), (kernel_ulong_t) -4, NULL, ksize_fmt,
803 0UL);
804
805 nul_terminated_buf = true;
806
807 /* KEYCTL_INSTANTIATE */
808 buf_in_arg = true;
809
810 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE),
811 sizeof(int32_t), 0, NULL, "%d",
812 sizeof(char *), ARG_STR(NULL), ptr_fmt,
813 sizeof(kernel_ulong_t),
814 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
815 sizeof(int32_t), 0, NULL, "%d");
816 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE),
817 sizeof(int32_t), bogus_key1, NULL, "%d",
818 sizeof(char *), (char *) 0xfffffacefffffeedULL, NULL, ptr_fmt,
819 sizeof(kernel_ulong_t),
820 (kernel_ulong_t) 0xdeadfeedLLU, NULL, ksize_fmt,
821 sizeof(int32_t), bogus_key1, NULL, "%d");
822 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE),
823 sizeof(int32_t), bogus_key2, NULL, "%d",
824 sizeof(char *), bogus_str, NULL, ptr_fmt,
825 sizeof(kernel_ulong_t),
826 (kernel_ulong_t) 32LLU, NULL, ksize_fmt,
827 sizeof(int32_t), bogus_key2, NULL, "%d");
828 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE),
829 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
830 sizeof(short_type_str), short_desc, NULL, NULL,
831 sizeof(kernel_ulong_t),
832 (kernel_ulong_t) sizeof(short_type_str) - 1, NULL,
833 ksize_fmt,
834 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL);
835 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE),
836 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
837 sizeof(long_type_str), long_desc, NULL, NULL,
838 sizeof(kernel_ulong_t),
839 (kernel_ulong_t) sizeof(long_type_str), NULL, ksize_fmt,
840 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL);
841
842 buf_in_arg = false;
843
844
845 /* KEYCTL_NEGATE */
846 do_keyctl(ARG_STR(KEYCTL_NEGATE),
847 sizeof(int32_t), 0, NULL, "%d",
848 sizeof(uint32_t), 0, NULL, "%u",
849 sizeof(int32_t), 0, NULL, "%d",
850 0UL);
851 do_keyctl(ARG_STR(KEYCTL_NEGATE),
852 sizeof(int32_t), bogus_key1, NULL, "%d",
853 sizeof(uint32_t), 3141592653U, NULL, "%u",
854 sizeof(int32_t), bogus_key1, NULL, "%d",
855 0UL);
856 do_keyctl(ARG_STR(KEYCTL_NEGATE),
857 sizeof(int32_t), bogus_key2, NULL, "%d",
858 sizeof(kernel_ulong_t),
859 (kernel_ulong_t) 0xfeedf157badc0dedLLU, "3134983661",
860 NULL,
861 sizeof(int32_t), bogus_key2, NULL, "%d",
862 0UL);
863 do_keyctl(ARG_STR(KEYCTL_NEGATE),
864 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
865 sizeof(kernel_ulong_t),
866 (kernel_ulong_t) 0xfeedf157badc0dedLLU, "3134983661", NULL,
867 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
868 0UL);
869
870
871 /* KEYCTL_SET_REQKEY_KEYRING */
872 do_keyctl(ARG_STR(KEYCTL_SET_REQKEY_KEYRING),
873 sizeof(int32_t), XARG_STR(KEY_REQKEY_DEFL_NO_CHANGE), NULL,
874 0UL);
875 /*
876 * Keep it commented out until proper way of faking syscalls is not
877 * implemented.
878 */
879 /* do_keyctl(ARG_STR(KEYCTL_SET_REQKEY_KEYRING),
880 sizeof(int32_t),
881 XARG_STR(KEY_REQKEY_DEFL_REQUESTOR_KEYRING), NULL, 0UL); */
882 do_keyctl(ARG_STR(KEYCTL_SET_REQKEY_KEYRING),
883 sizeof(kernel_ulong_t),
884 (kernel_ulong_t) 0xfeedf157badc0dedLLU,
885 "-1159983635"
886 #if !XLAT_RAW
887 " /* KEY_REQKEY_DEFL_??? */"
888 #endif
889 , NULL, 0UL);
890
891
892 /* KEYCTL_SET_TIMEOUT */
893 do_keyctl(ARG_STR(KEYCTL_SET_TIMEOUT),
894 sizeof(int32_t), 0, NULL, "%d",
895 sizeof(uint32_t), 0, NULL, "%u",
896 0UL);
897 do_keyctl(ARG_STR(KEYCTL_SET_TIMEOUT),
898 sizeof(int32_t), bogus_key1, NULL, "%d",
899 sizeof(uint32_t), 3141592653U, NULL, "%u",
900 0UL);
901 do_keyctl(ARG_STR(KEYCTL_SET_TIMEOUT),
902 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
903 sizeof(kernel_ulong_t),
904 (kernel_ulong_t) 0xfeedf157badc0dedLLU, "3134983661",
905 NULL,
906 0UL);
907
908
909 /* KEYCTL_ASSUME_AUTHORITY */
910 do_keyctl(ARG_STR(KEYCTL_ASSUME_AUTHORITY),
911 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
912 0UL);
913 do_keyctl(ARG_STR(KEYCTL_ASSUME_AUTHORITY),
914 sizeof(int32_t), bogus_key1, NULL, "%d",
915 0UL);
916 do_keyctl(ARG_STR(KEYCTL_ASSUME_AUTHORITY),
917 sizeof(int32_t), bogus_key2, NULL, "%d",
918 0UL);
919 do_keyctl(ARG_STR(KEYCTL_ASSUME_AUTHORITY),
920 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
921 0UL);
922
923
924 /* KEYCTL_GET_SECURITY */
925 do_keyctl(ARG_STR(KEYCTL_GET_SECURITY),
926 sizeof(int32_t), bogus_key1, NULL, "%d",
927 sizeof(char *), ARG_STR(NULL), ptr_fmt,
928 sizeof(uint32_t), 0xbadc0dedU, NULL, "%u",
929 0UL);
930 do_keyctl(ARG_STR(KEYCTL_GET_SECURITY),
931 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
932 sizeof(char *), ARG_STR(NULL), ptr_fmt,
933 sizeof(kernel_ulong_t),
934 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
935 0UL);
936 do_keyctl(ARG_STR(KEYCTL_GET_SECURITY),
937 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
938 (size_t) 9, (uintptr_t) bogus_buf1, NULL, NULL,
939 sizeof(kernel_ulong_t), (kernel_ulong_t) 9, NULL, ksize_fmt,
940 0UL);
941 do_keyctl(ARG_STR(KEYCTL_GET_SECURITY),
942 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
943 (size_t) 256, (uintptr_t) bogus_buf2, NULL, NULL,
944 sizeof(kernel_ulong_t), (kernel_ulong_t) 256, NULL, ksize_fmt,
945 0UL);
946 do_keyctl(ARG_STR(KEYCTL_GET_SECURITY),
947 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), NULL,
948 (size_t) -4, (uintptr_t) bogus_buf2, NULL, NULL,
949 sizeof(kernel_ulong_t), (kernel_ulong_t) -4, NULL, ksize_fmt,
950 0UL);
951
952
953 /* KEYCTL_SESSION_TO_PARENT */
954 do_keyctl(ARG_STR(KEYCTL_SESSION_TO_PARENT), 0UL);
955
956
957 /* KEYCTL_REJECT */
958 do_keyctl(ARG_STR(KEYCTL_REJECT),
959 sizeof(int32_t), 0, NULL, "%d",
960 sizeof(uint32_t), 0, NULL, "%u",
961 sizeof(uint32_t), 0, NULL, "%u",
962 sizeof(int32_t), 0, NULL, "%d");
963 do_keyctl(ARG_STR(KEYCTL_REJECT),
964 sizeof(int32_t), bogus_key1, NULL, "%d",
965 sizeof(uint32_t), 3141592653U, NULL, "%u",
966 sizeof(uint32_t), 2718281828U, NULL, "%u",
967 sizeof(int32_t), bogus_key1, NULL, "%d");
968 do_keyctl(ARG_STR(KEYCTL_REJECT),
969 sizeof(int32_t), bogus_key2, NULL, "%d",
970 sizeof(kernel_ulong_t),
971 (kernel_ulong_t) 0xdeadca75facef157LLU, "4207866199",
972 NULL,
973 sizeof(kernel_ulong_t),
974 (kernel_ulong_t) 0xfeedf157badc0dedLLU, "3134983661",
975 NULL,
976 sizeof(int32_t), bogus_key2, NULL, "%d");
977 do_keyctl(ARG_STR(KEYCTL_REJECT),
978 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
979 sizeof(kernel_ulong_t),
980 (kernel_ulong_t) 0xfeedf157badc0dedLLU, "3134983661",
981 NULL,
982 sizeof(uint32_t), XARG_STR(ENODEV), NULL,
983 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL);
984
985
986 /* KEYCTL_INSTANTIATE_IOV */
987 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE_IOV),
988 sizeof(int32_t), 0, NULL, "%d",
989 sizeof(char *), ARG_STR(NULL), ptr_fmt,
990 sizeof(kernel_ulong_t),
991 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
992 sizeof(int32_t), 0, NULL, "%d");
993 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE_IOV),
994 sizeof(int32_t), bogus_key1, NULL, "%d",
995 sizeof(char *), (char *) 0xfffffacefffffeedULL, NULL, ptr_fmt,
996 sizeof(kernel_ulong_t), (kernel_ulong_t) 0xdeadfeedLLU, NULL,
997 ksize_fmt,
998 sizeof(int32_t), bogus_key1, NULL, "%d");
999 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE_IOV),
1000 sizeof(int32_t), bogus_key2, NULL, "%d",
1001 sizeof(char *), key_iov + IOV_SIZE, NULL, ptr_fmt,
1002 sizeof(kernel_ulong_t), (kernel_ulong_t) 32LLU, NULL,
1003 ksize_fmt,
1004 sizeof(int32_t), bogus_key2, NULL, "%d");
1005 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE_IOV),
1006 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
1007 sizeof(key_iov), key_iov + IOV_SIZE - 4, key_iov_str1, NULL,
1008 sizeof(kernel_ulong_t), (kernel_ulong_t) 4, NULL,
1009 ksize_fmt,
1010 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL);
1011 do_keyctl(ARG_STR(KEYCTL_INSTANTIATE_IOV),
1012 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
1013 sizeof(key_iov), key_iov, key_iov_str2, NULL,
1014 sizeof(kernel_ulong_t), (kernel_ulong_t) IOV_SIZE, NULL,
1015 ksize_fmt,
1016 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL);
1017
1018
1019 /* KEYCTL_INVALIDATE */
1020 do_keyctl(ARG_STR(KEYCTL_INVALIDATE),
1021 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
1022 0UL);
1023 do_keyctl(ARG_STR(KEYCTL_INVALIDATE),
1024 sizeof(int32_t), bogus_key1, NULL, "%d",
1025 0UL);
1026 do_keyctl(ARG_STR(KEYCTL_INVALIDATE),
1027 sizeof(int32_t), bogus_key2, NULL, "%d",
1028 0UL);
1029 do_keyctl(ARG_STR(KEYCTL_INVALIDATE),
1030 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
1031 0UL);
1032
1033
1034 /* KEYCTL_GET_PERSISTENT */
1035 do_keyctl(ARG_STR(KEYCTL_GET_PERSISTENT),
1036 sizeof(uid_t), ARG_STR(-1), NULL,
1037 sizeof(int32_t), XARG_STR(KEY_SPEC_GROUP_KEYRING), NULL,
1038 0UL);
1039 do_keyctl(ARG_STR(KEYCTL_GET_PERSISTENT),
1040 sizeof(uid_t), 2718281828U, NULL, "%u",
1041 sizeof(int32_t), bogus_key1, NULL, "%d",
1042 0UL);
1043 do_keyctl(ARG_STR(KEYCTL_GET_PERSISTENT),
1044 sizeof(uid_t), 2718281828U, NULL, "%u",
1045 sizeof(kernel_ulong_t), bogus_key3, bogus_key3_str, NULL,
1046 0UL);
1047
1048
1049 /* KEYCTL_DH_COMPUTE */
1050 nul_terminated_buf = false;
1051
1052 /* Empty result is expected for these */
1053 bogus_buf1[0] = '\377';
1054 bogus_buf2[0] = '\377';
1055
1056 do_keyctl(ARG_STR(KEYCTL_DH_COMPUTE),
1057 sizeof(char *), ARG_STR(NULL), ptr_fmt,
1058 sizeof(char *), ARG_STR(NULL), ptr_fmt,
1059 sizeof(kernel_ulong_t),
1060 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
1061 sizeof(char *), ARG_STR(NULL), ptr_fmt);
1062 do_keyctl(ARG_STR(KEYCTL_DH_COMPUTE),
1063 sizeof(char *), kcdhp + 1, NULL, ptr_fmt,
1064 sizeof(char *), (char *) 0xfffff157ffffdeadULL, NULL, ptr_fmt,
1065 sizeof(kernel_ulong_t),
1066 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL, ksize_fmt,
1067 sizeof(char *), ARG_STR(NULL), ptr_fmt);
1068 do_keyctl(ARG_STR(KEYCTL_DH_COMPUTE),
1069 sizeof(kcdhp), kcdhp, kcdhp_str, NULL,
1070 (size_t) 9, (uintptr_t) bogus_buf1, NULL, NULL,
1071 sizeof(kernel_ulong_t), (kernel_ulong_t) 9, NULL, ksize_fmt,
1072 sizeof(char *), ARG_STR(NULL), ptr_fmt);
1073 do_keyctl(ARG_STR(KEYCTL_DH_COMPUTE),
1074 sizeof(kcdhp), kcdhp, kcdhp_str, NULL,
1075 (size_t) 256, (uintptr_t) bogus_buf2, NULL, NULL,
1076 sizeof(kernel_ulong_t), (kernel_ulong_t) 256, NULL, ksize_fmt,
1077 sizeof(char *), ARG_STR(NULL), ptr_fmt);
1078 do_keyctl(ARG_STR(KEYCTL_DH_COMPUTE),
1079 sizeof(kcdhp), kcdhp, kcdhp_str, NULL,
1080 (size_t) -1, (uintptr_t) bogus_buf2, NULL, NULL,
1081 sizeof(kernel_ulong_t), (kernel_ulong_t) -1, NULL, ksize_fmt,
1082 sizeof(char *), kckdfp_char + 1, NULL, ptr_fmt);
1083
1084 /* KEYCTL_DH_COMPUTE + KDF */
1085
1086 for (size_t i = 0; i < ARRAY_SIZE(kckdfp_data); ++i) {
1087 struct keyctl_kdf_params *kckdfp =
1088 (struct keyctl_kdf_params *) kckdfp_char;
1089 bool deref_hash = true;
1090 bool deref_opts = true;
1091 bool print_spare = false;
1092 const char *hash_str = NULL;
1093 const char *oi_str = NULL;
1094
1095 memcpy(kckdfp, kckdfp_data + i, sizeof(kckdfp_data[i]));
1096
1097 switch (i) {
1098 case 1:
1099 deref_hash = false;
1100 print_spare = true;
1101 kckdfp->hashname =
1102 kckdfp_short_hash + sizeof(short_hash_data);
1103 break;
1104 case 2:
1105 deref_opts = false;
1106 kckdfp->hashname = kckdfp_long_hash;
1107 kckdfp->otherinfo =
1108 kckdfp_otherinfo1 + sizeof(otherinfo1_data);
1109 break;
1110 case 3:
1111 deref_opts = false;
1112 deref_hash = false;
1113 print_spare = true;
1114 kckdfp->hashname = bogus_str;
1115 kckdfp->otherinfo = kckdfp_otherinfo1;
1116 break;
1117 case 4:
1118 oi_str = "\"\\1\\2 OH HAI \"...";
1119 print_spare = true;
1120 kckdfp->hashname = kckdfp_short_hash;
1121 kckdfp->otherinfo = kckdfp_otherinfo1;
1122 break;
1123 case 5:
1124 oi_str = "\"\\1\\2\\n\\255\\0\\1\\0\"";
1125 kckdfp->hashname = kckdfp_short_hash;
1126 kckdfp->otherinfo = kckdfp_otherinfo2;
1127 break;
1128 }
1129
1130 do_keyctl(ARG_STR(KEYCTL_DH_COMPUTE),
1131 sizeof(kcdhp), kcdhp, kcdhp_str, NULL,
1132 (size_t) -1, (uintptr_t) bogus_buf2, NULL, NULL,
1133 sizeof(kernel_ulong_t), (kernel_ulong_t) -1, NULL,
1134 ksize_fmt,
1135 sizeof(kckdfp), kckdfp_char,
1136 kckdfp_to_str(kckdfp, deref_hash, deref_opts,
1137 print_spare, hash_str, oi_str),
1138 NULL);
1139 }
1140
1141 nul_terminated_buf = true;
1142
1143 /* KEYCTL_PKEY_QUERY */
1144 do_keyctl(ARG_STR(KEYCTL_PKEY_QUERY),
1145 sizeof(int32_t), bogus_key2, NULL, "%d",
1146 sizeof(kernel_ulong_t),
1147 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL,
1148 kulong_fmt,
1149 sizeof(char *), bogus_str, NULL, ptr_fmt,
1150 sizeof(char *), ARG_STR(NULL), ptr_fmt);
1151
1152 struct keyctl_pkey_query query;
1153 do_keyctl(ARG_STR(KEYCTL_PKEY_QUERY),
1154 sizeof(int32_t), XARG_STR(KEY_SPEC_THREAD_KEYRING), "%d",
1155 sizeof(kernel_ulong_t), (kernel_ulong_t) 0, NULL, kulong_fmt,
1156 sizeof(char *), "x\377\0\1", "\"x\\377\"", NULL,
1157 sizeof(&query), &query, NULL, ptr_fmt);
1158
1159 /*
1160 * KEYCTL_PKEY_ENCRYPT, KEYCTL_PKEY_DECRYPT, KEYCTL_PKEY_SIGN,
1161 * KEYCTL_PKEY_VERIFY
1162 */
1163 static const struct {
1164 int op;
1165 const char *str;
1166 bool out;
1167 } pkey_ops[] = {
1168 { ARG_STR(KEYCTL_PKEY_ENCRYPT), true },
1169 { ARG_STR(KEYCTL_PKEY_DECRYPT), true },
1170 { ARG_STR(KEYCTL_PKEY_SIGN), true },
1171 { ARG_STR(KEYCTL_PKEY_VERIFY), false },
1172 };
1173 static const char pkey_str1[] = STR32 "xxx";
1174 static const char pkey_str2[] = "\1\2HAI\255\0\1";
1175 static struct {
1176 struct keyctl_pkey_params params;
1177 const char * key_str;
1178 bool print_spare;
1179 const char *str1;
1180 const char *str2;
1181 } pkey_vecs[] = {
1182 { { KEY_SPEC_PROCESS_KEYRING, 0, { .out_len = 0 } },
1183 "KEY_SPEC_PROCESS_KEYRING", false, "\"\"", "\"\"" },
1184 { { 0, 0, { .out_len = 0 }, .__spare = { 1 } },
1185 NULL, true, "\"\"", "\"\"" },
1186 { { 0xdeadc0deU, 10, { .out_len = 10 },
1187 .__spare = { 0, 0xfacefeed } },
1188 NULL, true, "\"AbCdEfGhIj\"", NULL },
1189 { { 0xdeadc0deU, sizeof(pkey_str1),
1190 { .out_len = sizeof(pkey_str2) - 1 },
1191 .__spare = { [6] = 0xdec0ded } },
1192 NULL, true,
1193 "\"AbCdEfGhIj\"...", "\"\\1\\2HAI\\255\\0\\1\"" },
1194 };
1195
1196 char *pkey1 = tail_memdup(pkey_str1, sizeof(pkey_str1) - 1);
1197 char *pkey2 = tail_memdup(pkey_str2, sizeof(pkey_str2) - 1);
1198 struct keyctl_pkey_params *pkey_params =
1199 tail_alloc(sizeof(*pkey_params));
1200
1201 for (size_t i = 0; i < ARRAY_SIZE(pkey_ops); ++i) {
1202 do_keyctl(pkey_ops[i].op, pkey_ops[i].str,
1203 sizeof(char *), ARG_STR(NULL), ptr_fmt,
1204 sizeof(char *), ARG_STR(NULL), ptr_fmt,
1205 sizeof(char *), ARG_STR(NULL), ptr_fmt,
1206 sizeof(char *), ARG_STR(NULL), ptr_fmt);
1207
1208 do_keyctl(pkey_ops[i].op, pkey_ops[i].str,
1209 sizeof(char *), (uint32_t *) pkey_params + 1, NULL,
1210 ptr_fmt,
1211 sizeof(char *), "x\377\0\1", "\"x\\377\"", ptr_fmt,
1212 sizeof(char *), pkey1, NULL, ptr_fmt,
1213 sizeof(char *), pkey2, NULL, ptr_fmt);
1214
1215 for (size_t j = 0; j < ARRAY_SIZE(pkey_vecs); j++) {
1216 memcpy(pkey_params, &pkey_vecs[j].params,
1217 sizeof(*pkey_params));
1218 do_keyctl(pkey_ops[i].op, pkey_ops[i].str,
1219 sizeof(char *), pkey_params,
1220 kcpp_to_str(pkey_params,
1221 pkey_ops[i].out,
1222 pkey_vecs[j].key_str,
1223 pkey_vecs[j].print_spare),
1224 ptr_fmt,
1225 sizeof(char *), "", "\"\"", ptr_fmt,
1226 sizeof(char *), pkey1, pkey_vecs[j].str1,
1227 ptr_fmt,
1228 sizeof(char *), pkey2,
1229 pkey_ops[i].out ? NULL
1230 : pkey_vecs[j].str2,
1231 ptr_fmt);
1232 }
1233 }
1234
1235 /* KEYCTL_MOVE */
1236 static const struct {
1237 kernel_ulong_t key;
1238 const char *str;
1239 } move_keys[] = {
1240 { 0xbadc0ded, "-1159983635" },
1241 { XARG_STR(KEY_SPEC_THREAD_KEYRING) },
1242 };
1243 static const struct {
1244 kernel_ulong_t val;
1245 const char *str;
1246 } move_flags[] = {
1247 { (kernel_ulong_t) 0xbadc0ded00000000ULL, "0" },
1248 { 1, XSTR(0x1, "KEYCTL_MOVE_EXCL") },
1249 { (kernel_ulong_t) 0xbadc0ded00000001ULL,
1250 XSTR(0x1, "KEYCTL_MOVE_EXCL") },
1251 { (kernel_ulong_t) 0xfffffffffffffffeULL,
1252 #if !XLAT_RAW
1253 "0xfffffffe /* KEYCTL_MOVE_??? */"
1254 #else
1255 "0xfffffffe"
1256 #endif
1257 },
1258 { (kernel_ulong_t) 0xffffffffffffffffULL,
1259 XSTR(0xffffffff, "KEYCTL_MOVE_EXCL|0xfffffffe") },
1260 };
1261
1262 for (size_t i = 0;
1263 i < ARRAY_SIZE(move_keys) * ARRAY_SIZE(move_flags); ++i) {
1264 do_keyctl(ARG_STR(KEYCTL_MOVE),
1265 sizeof(kernel_ulong_t),
1266 move_keys[i % ARRAY_SIZE(move_keys)].key,
1267 move_keys[i % ARRAY_SIZE(move_keys)].str,
1268 kulong_fmt,
1269 sizeof(kernel_ulong_t),
1270 move_keys[(i + 1) % ARRAY_SIZE(move_keys)].key,
1271 move_keys[(i + 1) % ARRAY_SIZE(move_keys)].str,
1272 kulong_fmt,
1273 sizeof(kernel_ulong_t),
1274 move_keys[(i + 2) % ARRAY_SIZE(move_keys)].key,
1275 move_keys[(i + 2) % ARRAY_SIZE(move_keys)].str,
1276 kulong_fmt,
1277 sizeof(kernel_ulong_t),
1278 move_flags[i % ARRAY_SIZE(move_flags)].val,
1279 move_flags[i % ARRAY_SIZE(move_flags)].str,
1280 kulong_fmt);
1281 }
1282
1283 /* KEYCTL_CAPABILITIES */
1284 unsigned char *caps1 = tail_alloc(1);
1285 unsigned char *caps2 = tail_alloc(2);
1286 unsigned char *caps4 = tail_alloc(4);
1287
1288 do_keyctl(ARG_STR(KEYCTL_CAPABILITIES),
1289 sizeof(unsigned char *), ARG_STR(NULL), ptr_fmt,
1290 sizeof(kernel_ulong_t),
1291 (kernel_ulong_t) 0xfeedf157badc0dedLLU, NULL,
1292 ksize_fmt,
1293 0);
1294
1295 const kernel_ulong_t bad_len = (kernel_ulong_t) 0xbadc0ded00000001LLU;
1296 rc = syscall(__NR_keyctl, KEYCTL_CAPABILITIES, caps1, bad_len);
1297 errstr = sprintrc(rc);
1298 printf("%-5u keyctl(" XSTR(0x1f, "KEYCTL_CAPABILITIES") ", ", pid);
1299 if (rc >= 0) {
1300 printf("[");
1301 if (rc >= 1)
1302 print_flags(keyctl_caps0, caps1[0], "KEYCTL_CAPS0_???");
1303 printf("]");
1304 } else {
1305 printf("%p", caps1);
1306 }
1307 printf(", %llu) = %s\n", (unsigned long long) bad_len, errstr);
1308
1309 rc = syscall(__NR_keyctl, KEYCTL_CAPABILITIES, caps1, 2);
1310 errstr = sprintrc(rc);
1311 printf("%-5u keyctl(" XSTR(0x1f, "KEYCTL_CAPABILITIES") ", ", pid);
1312 if (rc >= 0) {
1313 printf("[");
1314 if (rc == 1)
1315 print_flags(keyctl_caps0, caps1[0], "KEYCTL_CAPS0_???");
1316 printf("]");
1317 } else {
1318 printf("%p", caps1);
1319 }
1320 printf(", 2) = %s\n", errstr);
1321
1322 rc = syscall(__NR_keyctl, KEYCTL_CAPABILITIES, caps2, 2);
1323 errstr = sprintrc(rc);
1324 printf("%-5u keyctl(" XSTR(0x1f, "KEYCTL_CAPABILITIES") ", ", pid);
1325 if (rc >= 0) {
1326 printf("[");
1327 if (rc >= 1)
1328 print_flags(keyctl_caps0, caps2[0], "KEYCTL_CAPS0_???");
1329 if (rc >= 2) {
1330 printf(", ");
1331 print_flags(keyctl_caps1, caps2[1], "KEYCTL_CAPS1_???");
1332 }
1333 printf("]");
1334 } else {
1335 printf("%p", caps2);
1336 }
1337 printf(", 2) = %s\n", errstr);
1338
1339 rc = syscall(__NR_keyctl, KEYCTL_CAPABILITIES, caps4, 4);
1340 errstr = sprintrc(rc);
1341 printf("%-5u keyctl(" XSTR(0x1f, "KEYCTL_CAPABILITIES") ", ", pid);
1342 if (rc >= 0) {
1343 printf("[");
1344 if (rc >= 1)
1345 print_flags(keyctl_caps0, caps4[0], "KEYCTL_CAPS0_???");
1346 if (rc >= 2) {
1347 printf(", ");
1348 print_flags(keyctl_caps1, caps4[1], "KEYCTL_CAPS1_???");
1349 }
1350 if (rc >= 3)
1351 printf(", %hhx", caps4[2]);
1352 if (rc >= 4)
1353 printf(", %hhx", caps4[3]);
1354 printf("]");
1355 } else {
1356 printf("%p", caps4);
1357 }
1358 printf(", 4) = %s\n", errstr);
1359
1360 printf("%-5u +++ exited with 0 +++\n", pid);
1361
1362 return 0;
1363 }