granicus.if.org Git - strace/blob - keyctl.c

   1 /*
   2  * Copyright (c) 2014-2015 Dmitry V. Levin <ldv@altlinux.org>
   3  * Copyright (c) 2014-2018 The strace developers.
   4  * All rights reserved.
   5  *
   6  * SPDX-License-Identifier: LGPL-2.1-or-later
   7  */
   8
   9 #include "defs.h"
  10
  11 #include "keyctl_kdf_params.h"
  12 #include "print_fields.h"
  13
  14 typedef int32_t key_serial_t;
  15
  16 #include "xlat/key_spec.h"
  17
  18 struct keyctl_dh_params {
  19         int32_t private;
  20         int32_t prime;
  21         int32_t base;
  22 };
  23
  24 static void
  25 print_keyring_serial_number(key_serial_t id)
  26 {
  27         printxval_d(key_spec, id, NULL);
  28 }
  29
  30 SYS_FUNC(add_key)
  31 {
  32         /* type */
  33         printstr(tcp, tcp->u_arg[0]);
  34         /* description */
  35         tprints(", ");
  36         printstr(tcp, tcp->u_arg[1]);
  37         /* payload */
  38         tprints(", ");
  39         printstrn(tcp, tcp->u_arg[2], tcp->u_arg[3]);
  40         /* payload length */
  41         tprintf(", %" PRI_klu ", ", tcp->u_arg[3]);
  42         /* keyring serial number */
  43         print_keyring_serial_number(tcp->u_arg[4]);
  44
  45         return RVAL_DECODED;
  46 }
  47
  48 SYS_FUNC(request_key)
  49 {
  50         /* type */
  51         printstr(tcp, tcp->u_arg[0]);
  52         /* description */
  53         tprints(", ");
  54         printstr(tcp, tcp->u_arg[1]);
  55         /* callout_info */
  56         tprints(", ");
  57         printstr(tcp, tcp->u_arg[2]);
  58         /* keyring serial number */
  59         tprints(", ");
  60         print_keyring_serial_number(tcp->u_arg[3]);
  61
  62         return RVAL_DECODED;
  63 }
  64
  65 static void
  66 keyctl_get_keyring_id(struct tcb *tcp, key_serial_t id, int create)
  67 {
  68         print_keyring_serial_number(id);
  69         tprintf(", %d", create);
  70 }
  71
  72 static void
  73 keyctl_update_key(struct tcb *tcp, key_serial_t id, kernel_ulong_t addr,
  74                   kernel_ulong_t len)
  75 {
  76         print_keyring_serial_number(id);
  77         tprints(", ");
  78         printstrn(tcp, addr, len);
  79         tprintf(", %llu", zero_extend_signed_to_ull(len));
  80 }
  81
  82 static void
  83 keyctl_handle_key_key(struct tcb *tcp, key_serial_t id1, key_serial_t id2)
  84 {
  85         print_keyring_serial_number(id1);
  86         tprints(", ");
  87         print_keyring_serial_number(id2);
  88 }
  89
  90 static void
  91 keyctl_read_key(struct tcb *tcp, key_serial_t id, kernel_ulong_t addr,
  92                 kernel_ulong_t len, bool has_nul)
  93 {
  94         if (entering(tcp)) {
  95                 print_keyring_serial_number(id);
  96                 tprints(", ");
  97         } else {
  98                 if (syserror(tcp))
  99                         printaddr(addr);
 100                 else {
 101                         kernel_ulong_t rval = (tcp->u_rval >= 0) &&
 102                                 ((kernel_ulong_t) tcp->u_rval > len) ? len :
 103                                 (kernel_ulong_t) tcp->u_rval;
 104                         printstr_ex(tcp, addr, rval, has_nul ?
 105                                     QUOTE_OMIT_TRAILING_0 : 0);
 106                 }
 107                 tprintf(", %llu", zero_extend_signed_to_ull(len));
 108         }
 109 }
 110
 111 static void
 112 keyctl_keyring_search(struct tcb *tcp, key_serial_t id1, kernel_ulong_t addr1,
 113                       kernel_ulong_t addr2, key_serial_t id2)
 114 {
 115         print_keyring_serial_number(id1);
 116         tprints(", ");
 117         printstr(tcp, addr1);
 118         tprints(", ");
 119         printstr(tcp, addr2);
 120         tprints(", ");
 121         print_keyring_serial_number(id2);
 122 }
 123
 124 static void
 125 keyctl_chown_key(struct tcb *tcp, key_serial_t id, unsigned user,
 126                  unsigned group)
 127 {
 128         print_keyring_serial_number(id);
 129         printuid(", ", user);
 130         printuid(", ", group);
 131 }
 132
 133 static void
 134 keyctl_instantiate_key(struct tcb *tcp, key_serial_t id1, kernel_ulong_t addr,
 135                        kernel_ulong_t len, key_serial_t id2)
 136 {
 137         print_keyring_serial_number(id1);
 138         tprints(", ");
 139         printstrn(tcp, addr, len);
 140         tprintf(", %llu, ", zero_extend_signed_to_ull(len));
 141         print_keyring_serial_number(id2);
 142 }
 143
 144 static void
 145 keyctl_instantiate_key_iov(struct tcb *tcp, key_serial_t id1,
 146                            kernel_ulong_t addr, kernel_ulong_t len,
 147                            key_serial_t id2)
 148 {
 149         print_keyring_serial_number(id1);
 150         tprints(", ");
 151         tprint_iov(tcp, len, addr, IOV_DECODE_STR);
 152         tprintf(", %llu, ", zero_extend_signed_to_ull(len));
 153         print_keyring_serial_number(id2);
 154 }
 155
 156 static void
 157 keyctl_negate_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 158                   key_serial_t id2)
 159 {
 160         print_keyring_serial_number(id1);
 161         tprintf(", %u, ", timeout);
 162         print_keyring_serial_number(id2);
 163 }
 164
 165 static void
 166 keyctl_reject_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 167                   unsigned error, key_serial_t id2)
 168 {
 169         print_keyring_serial_number(id1);
 170         tprintf(", %u, ", timeout);
 171         print_err(error, false);
 172         tprints(", ");
 173         print_keyring_serial_number(id2);
 174 }
 175
 176 static void
 177 keyctl_set_timeout(struct tcb *tcp, key_serial_t id, unsigned timeout)
 178 {
 179         print_keyring_serial_number(id);
 180         tprintf(", %u", timeout);
 181 }
 182
 183 static void
 184 keyctl_get_persistent(struct tcb *tcp, unsigned uid, key_serial_t id)
 185 {
 186         printuid("", uid);
 187         tprints(", ");
 188         print_keyring_serial_number(id);
 189 }
 190
 191 #include "xlat/key_perms.h"
 192
 193 static void
 194 keyctl_setperm_key(struct tcb *tcp, key_serial_t id, uint32_t perm)
 195 {
 196         print_keyring_serial_number(id);
 197         tprints(", ");
 198         printflags(key_perms, perm, "KEY_???");
 199 }
 200
 201 static void
 202 print_dh_params(struct tcb *tcp, kernel_ulong_t addr)
 203 {
 204         struct keyctl_dh_params params;
 205
 206         if (umove_or_printaddr(tcp, addr, &params))
 207                 return;
 208
 209         tprints("{private=");
 210         print_keyring_serial_number(params.private);
 211         tprints(", prime=");
 212         print_keyring_serial_number(params.prime);
 213         tprints(", base=");
 214         print_keyring_serial_number(params.base);
 215         tprints("}");
 216 }
 217
 218 static void
 219 keyctl_dh_compute(struct tcb *tcp, kernel_ulong_t params, kernel_ulong_t buf,
 220                   kernel_ulong_t len, kernel_ulong_t kdf_addr)
 221 {
 222         if (entering(tcp)) {
 223                 print_dh_params(tcp, params);
 224                 tprints(", ");
 225         } else {
 226                 struct strace_keyctl_kdf_params kdf;
 227
 228                 if (syserror(tcp)) {
 229                         printaddr(buf);
 230                 } else {
 231                         kernel_ulong_t rval = (tcp->u_rval >= 0) &&
 232                                 ((kernel_ulong_t) tcp->u_rval > len) ? len :
 233                                 (kernel_ulong_t) tcp->u_rval;
 234                         printstrn(tcp, buf, rval);
 235                 }
 236                 tprintf(", %llu, ", zero_extend_signed_to_ull(len));
 237
 238                 if (fetch_keyctl_kdf_params(tcp, kdf_addr, &kdf)) {
 239                         printaddr(kdf_addr);
 240                 } else {
 241                         size_t i;
 242
 243                         PRINT_FIELD_STR("{", kdf, hashname, tcp);
 244
 245                         /*
 246                          * Kernel doesn't touch otherinfo
 247                          * if otherinfolen is zero.
 248                          */
 249                         if (kdf.otherinfolen)
 250                                 PRINT_FIELD_STRN(", ", kdf, otherinfo,
 251                                                  kdf.otherinfolen, tcp);
 252                         else
 253                                 PRINT_FIELD_PTR(", ", kdf, otherinfo);
 254
 255                         PRINT_FIELD_U(", ", kdf, otherinfolen);
 256
 257                         /* Some future-proofing */
 258                         for (i = 0; i < ARRAY_SIZE(kdf.__spare); i++) {
 259                                 if (kdf.__spare[i])
 260                                         break;
 261                         }
 262
 263                         if (i < ARRAY_SIZE(kdf.__spare)) {
 264                                 tprints(", __spare=[");
 265
 266                                 for (i = 0; i < ARRAY_SIZE(kdf.__spare); i++) {
 267                                         if (i)
 268                                                 tprints(", ");
 269
 270                                         tprintf("%#x", kdf.__spare[i]);
 271                                 }
 272
 273                                 tprints("]");
 274                         }
 275
 276                         tprints("}");
 277                 }
 278         }
 279 }
 280
 281 static void
 282 keyctl_restrict_keyring(struct tcb *const tcp,
 283                         const key_serial_t id,
 284                         const kernel_ulong_t addr1,
 285                         const kernel_ulong_t addr2)
 286 {
 287         print_keyring_serial_number(id);
 288         tprints(", ");
 289         printstr(tcp, addr1);
 290         tprints(", ");
 291         printstr(tcp, addr2);
 292 }
 293
 294 #include "xlat/key_reqkeys.h"
 295 #include "xlat/keyctl_commands.h"
 296
 297 SYS_FUNC(keyctl)
 298 {
 299         int cmd = tcp->u_arg[0];
 300         kernel_ulong_t arg2 = tcp->u_arg[1];
 301         kernel_ulong_t arg3 = tcp->u_arg[2];
 302         kernel_ulong_t arg4 = tcp->u_arg[3];
 303         kernel_ulong_t arg5 = tcp->u_arg[4];
 304
 305         if (entering(tcp)) {
 306                 printxval(keyctl_commands, cmd, "KEYCTL_???");
 307
 308                 /*
 309                  * For now, KEYCTL_SESSION_TO_PARENT is the only cmd without
 310                  * arguments.
 311                  */
 312                 if (cmd != KEYCTL_SESSION_TO_PARENT)
 313                         tprints(", ");
 314         }
 315
 316         switch (cmd) {
 317         case KEYCTL_GET_KEYRING_ID:
 318                 keyctl_get_keyring_id(tcp, arg2, arg3);
 319                 break;
 320
 321         case KEYCTL_JOIN_SESSION_KEYRING:
 322                 printstr(tcp, arg2);
 323                 break;
 324
 325         case KEYCTL_UPDATE:
 326                 keyctl_update_key(tcp, arg2, arg3, arg4);
 327                 break;
 328
 329         case KEYCTL_REVOKE:
 330         case KEYCTL_CLEAR:
 331         case KEYCTL_INVALIDATE:
 332         case KEYCTL_ASSUME_AUTHORITY:
 333                 print_keyring_serial_number(arg2);
 334                 break;
 335
 336         case KEYCTL_LINK:
 337         case KEYCTL_UNLINK:
 338                 keyctl_handle_key_key(tcp, arg2, arg3);
 339                 break;
 340
 341         case KEYCTL_DESCRIBE:
 342         case KEYCTL_READ:
 343         case KEYCTL_GET_SECURITY:
 344                 keyctl_read_key(tcp, arg2, arg3, arg4, cmd != KEYCTL_READ);
 345                 return 0;
 346
 347         case KEYCTL_SEARCH:
 348                 keyctl_keyring_search(tcp, arg2, arg3, arg4, arg5);
 349                 break;
 350
 351         case KEYCTL_CHOWN:
 352                 keyctl_chown_key(tcp, arg2, arg3, arg4);
 353                 break;
 354
 355         case KEYCTL_SETPERM:
 356                 keyctl_setperm_key(tcp, arg2, arg3);
 357                 break;
 358
 359         case KEYCTL_INSTANTIATE:
 360                 keyctl_instantiate_key(tcp, arg2, arg3, arg4, arg5);
 361                 break;
 362
 363         case KEYCTL_NEGATE:
 364                 keyctl_negate_key(tcp, arg2, arg3, arg4);
 365                 break;
 366
 367         case KEYCTL_SET_REQKEY_KEYRING:
 368                 printxvals_ex((int) arg2, "KEY_REQKEY_DEFL_???",
 369                               XLAT_STYLE_FMT_D, key_reqkeys, NULL);
 370                 break;
 371
 372         case KEYCTL_SET_TIMEOUT:
 373                 keyctl_set_timeout(tcp, arg2, arg3);
 374                 break;
 375
 376         case KEYCTL_SESSION_TO_PARENT:
 377                 break;
 378
 379         case KEYCTL_REJECT:
 380                 keyctl_reject_key(tcp, arg2, arg3, arg4, arg5);
 381                 break;
 382
 383         case KEYCTL_INSTANTIATE_IOV:
 384                 keyctl_instantiate_key_iov(tcp, arg2, arg3, arg4, arg5);
 385                 break;
 386
 387         case KEYCTL_GET_PERSISTENT:
 388                 keyctl_get_persistent(tcp, arg2, arg3);
 389                 break;
 390
 391         case KEYCTL_DH_COMPUTE:
 392                 keyctl_dh_compute(tcp, arg2, arg3, arg4, arg5);
 393                 return 0;
 394
 395         case KEYCTL_RESTRICT_KEYRING:
 396                 keyctl_restrict_keyring(tcp, arg2, arg3, arg4);
 397                 break;
 398
 399         default:
 400                 tprintf("%#" PRI_klx ", %#" PRI_klx
 401                         ", %#" PRI_klx ", %#" PRI_klx,
 402                         arg2, arg3, arg4, arg5);
 403                 break;
 404         }
 405
 406         return RVAL_DECODED;
 407 }