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

   1 #include "defs.h"
   2
   3 typedef int32_t key_serial_t;
   4
   5 #include "xlat/key_spec.h"
   6
   7 static void
   8 print_keyring_serial_number(key_serial_t id)
   9 {
  10         const char *str = xlookup(key_spec, id);
  11
  12         if (str)
  13                 tprints(str);
  14         else
  15                 tprintf("%d", id);
  16 }
  17
  18 int
  19 sys_add_key(struct tcb *tcp)
  20 {
  21         if (entering(tcp)) {
  22                 /* type */
  23                 printstr(tcp, tcp->u_arg[0], -1);
  24                 /* description */
  25                 tprints(", ");
  26                 printstr(tcp, tcp->u_arg[1], -1);
  27                 /* payload */
  28                 tprints(", ");
  29                 printstr(tcp, tcp->u_arg[2], tcp->u_arg[3]);
  30                 /* payload length */
  31                 tprintf(", %lu, ", tcp->u_arg[3]);
  32                 /* keyring serial number */
  33                 print_keyring_serial_number(tcp->u_arg[4]);
  34         }
  35         return 0;
  36 }
  37
  38 int
  39 sys_request_key(struct tcb *tcp)
  40 {
  41         if (entering(tcp)) {
  42                 /* type */
  43                 printstr(tcp, tcp->u_arg[0], -1);
  44                 /* description */
  45                 tprints(", ");
  46                 printstr(tcp, tcp->u_arg[1], -1);
  47                 /* callout_info */
  48                 tprints(", ");
  49                 printstr(tcp, tcp->u_arg[2], -1);
  50                 /* keyring serial number */
  51                 tprints(", ");
  52                 print_keyring_serial_number(tcp->u_arg[3]);
  53         }
  54         return 0;
  55 }
  56
  57 static int
  58 keyctl_get_keyring_id(struct tcb *tcp, key_serial_t id, int create)
  59 {
  60         if (entering(tcp)) {
  61                 tprints(", ");
  62                 print_keyring_serial_number(id);
  63                 tprintf(", %d", create);
  64         }
  65         return 0;
  66 }
  67
  68 static int
  69 keyctl_join_session_keyring(struct tcb *tcp, long addr)
  70 {
  71         if (entering(tcp)) {
  72                 tprints(", ");
  73                 printstr(tcp, addr, -1);
  74         }
  75         return 0;
  76 }
  77
  78 static int
  79 keyctl_update_key(struct tcb *tcp, key_serial_t id, long addr, long len)
  80 {
  81         if (entering(tcp)) {
  82                 tprints(", ");
  83                 print_keyring_serial_number(id);
  84                 tprints(", ");
  85                 printstr(tcp, addr, len);
  86                 tprintf(", %lu", len);
  87         }
  88         return 0;
  89 }
  90
  91 static int
  92 keyctl_handle_key(struct tcb *tcp, key_serial_t id)
  93 {
  94         if (entering(tcp)) {
  95                 tprints(", ");
  96                 print_keyring_serial_number(id);
  97         }
  98         return 0;
  99 }
 100
 101 static int
 102 keyctl_handle_key_key(struct tcb *tcp, key_serial_t id1, key_serial_t id2)
 103 {
 104         if (entering(tcp)) {
 105                 tprints(", ");
 106                 print_keyring_serial_number(id1);
 107                 tprints(", ");
 108                 print_keyring_serial_number(id2);
 109         }
 110         return 0;
 111 }
 112
 113 static int
 114 keyctl_read_key(struct tcb *tcp, key_serial_t id, long addr, long len)
 115 {
 116         if (entering(tcp)) {
 117                 tprints(", ");
 118                 print_keyring_serial_number(id);
 119                 tprints(", ");
 120         } else {
 121                 if (addr && syserror(tcp))
 122                         tprintf("%#lx", addr);
 123                 else {
 124                         long rval = tcp->u_rval > len ?
 125                                     len : (tcp->u_rval ? -1 : 0);
 126                         printstr(tcp, addr, rval);
 127                 }
 128                 tprintf(", %lu", len);
 129         }
 130         return 0;
 131 }
 132
 133 static int
 134 keyctl_keyring_search(struct tcb *tcp, key_serial_t id1, long addr1,
 135                       long addr2, key_serial_t id2)
 136 {
 137         if (entering(tcp)) {
 138                 tprints(", ");
 139                 print_keyring_serial_number(id1);
 140                 tprints(", ");
 141                 printstr(tcp, addr1, -1);
 142                 tprints(", ");
 143                 printstr(tcp, addr2, -1);
 144                 tprints(", ");
 145                 print_keyring_serial_number(id2);
 146         }
 147         return 0;
 148 }
 149
 150 static int
 151 keyctl_chown_key(struct tcb *tcp, key_serial_t id, int user, int group)
 152 {
 153         if (entering(tcp)) {
 154                 tprints(", ");
 155                 print_keyring_serial_number(id);
 156                 tprintf(", %d, %d", user, group);
 157         }
 158         return 0;
 159 }
 160
 161 static int
 162 keyctl_instantiate_key(struct tcb *tcp, key_serial_t id1, long addr,
 163                        long len, key_serial_t id2)
 164 {
 165         if (entering(tcp)) {
 166                 tprints(", ");
 167                 print_keyring_serial_number(id1);
 168                 tprints(", ");
 169                 printstr(tcp, addr, len);
 170                 tprintf(", %lu, ", len);
 171                 print_keyring_serial_number(id2);
 172         }
 173         return 0;
 174 }
 175
 176 static int
 177 keyctl_instantiate_key_iov(struct tcb *tcp, key_serial_t id1,
 178                            long addr, long len, key_serial_t id2)
 179 {
 180         if (entering(tcp)) {
 181                 tprints(", ");
 182                 print_keyring_serial_number(id1);
 183                 tprints(", ");
 184                 tprint_iov(tcp, len, addr, 1);
 185                 tprintf(", %lu, ", len);
 186                 print_keyring_serial_number(id2);
 187         }
 188         return 0;
 189 }
 190
 191 static int
 192 keyctl_negate_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 193                   key_serial_t id2)
 194 {
 195         if (entering(tcp)) {
 196                 tprints(", ");
 197                 print_keyring_serial_number(id1);
 198                 tprintf(", %u, ", timeout);
 199                 print_keyring_serial_number(id2);
 200         }
 201         return 0;
 202 }
 203
 204 static int
 205 keyctl_reject_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 206                   unsigned error, key_serial_t id2)
 207 {
 208         if (entering(tcp)) {
 209                 tprints(", ");
 210                 print_keyring_serial_number(id1);
 211                 tprintf(", %u, %u, ", timeout, error);
 212                 print_keyring_serial_number(id2);
 213         }
 214         return 0;
 215 }
 216
 217 static int
 218 keyctl_set_timeout(struct tcb *tcp, key_serial_t id, unsigned timeout)
 219 {
 220         if (entering(tcp)) {
 221                 tprints(", ");
 222                 print_keyring_serial_number(id);
 223                 tprintf(", %u", timeout);
 224         }
 225         return 0;
 226 }
 227
 228 static int
 229 keyctl_get_persistent(struct tcb *tcp, int uid, key_serial_t id)
 230 {
 231         if (entering(tcp)) {
 232                 tprintf(", %d, ", uid);
 233                 print_keyring_serial_number(id);
 234         }
 235         return 0;
 236 }
 237
 238 #include "xlat/key_perms.h"
 239
 240 static int
 241 keyctl_setperm_key(struct tcb *tcp, key_serial_t id, uint32_t perm)
 242 {
 243         if (entering(tcp)) {
 244                 tprints(", ");
 245                 print_keyring_serial_number(id);
 246                 tprints(", ");
 247                 printflags(key_perms, perm, "KEY_???");
 248         }
 249         return 0;
 250 }
 251
 252 #include "xlat/key_reqkeys.h"
 253
 254 static int
 255 keyctl_set_reqkey_keyring(struct tcb *tcp, int reqkey)
 256 {
 257         if (entering(tcp)) {
 258                 tprints(", ");
 259                 printxval(key_reqkeys, reqkey, "KEY_REQKEY_DEFL_???");
 260         }
 261         return 0;
 262 }
 263
 264 #include "xlat/keyctl_commands.h"
 265
 266 int
 267 sys_keyctl(struct tcb *tcp)
 268 {
 269         int cmd = tcp->u_arg[0];
 270
 271         if (entering(tcp))
 272                 printxval(keyctl_commands, cmd, "KEYCTL_???");
 273
 274         switch (cmd) {
 275         case KEYCTL_GET_KEYRING_ID:
 276                 return keyctl_get_keyring_id(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 277
 278         case KEYCTL_JOIN_SESSION_KEYRING:
 279                 return keyctl_join_session_keyring(tcp, tcp->u_arg[1]);
 280
 281         case KEYCTL_UPDATE:
 282                 return keyctl_update_key(tcp, tcp->u_arg[1],
 283                                          tcp->u_arg[2], tcp->u_arg[3]);
 284
 285         case KEYCTL_REVOKE:
 286         case KEYCTL_CLEAR:
 287         case KEYCTL_INVALIDATE:
 288         case KEYCTL_ASSUME_AUTHORITY:
 289                 return keyctl_handle_key(tcp, tcp->u_arg[1]);
 290
 291         case KEYCTL_LINK:
 292         case KEYCTL_UNLINK:
 293                 return keyctl_handle_key_key(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 294
 295         case KEYCTL_DESCRIBE:
 296         case KEYCTL_READ:
 297         case KEYCTL_GET_SECURITY:
 298                 return keyctl_read_key(tcp, tcp->u_arg[1],
 299                                        tcp->u_arg[2], tcp->u_arg[3]);
 300
 301         case KEYCTL_SEARCH:
 302                 return keyctl_keyring_search(tcp, tcp->u_arg[1], tcp->u_arg[2],
 303                                              tcp->u_arg[3], tcp->u_arg[4]);
 304
 305         case KEYCTL_CHOWN:
 306                 return keyctl_chown_key(tcp, tcp->u_arg[1],
 307                                         tcp->u_arg[2], tcp->u_arg[3]);
 308
 309         case KEYCTL_SETPERM:
 310                 return keyctl_setperm_key(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 311
 312         case KEYCTL_INSTANTIATE:
 313                 return keyctl_instantiate_key(tcp, tcp->u_arg[1], tcp->u_arg[2],
 314                                               tcp->u_arg[3], tcp->u_arg[4]);
 315
 316         case KEYCTL_NEGATE:
 317                 return keyctl_negate_key(tcp, tcp->u_arg[1],
 318                                          tcp->u_arg[2], tcp->u_arg[3]);
 319
 320         case KEYCTL_SET_REQKEY_KEYRING:
 321                 return keyctl_set_reqkey_keyring(tcp, tcp->u_arg[1]);
 322
 323         case KEYCTL_SET_TIMEOUT:
 324                 return keyctl_set_timeout(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 325
 326         case KEYCTL_SESSION_TO_PARENT:
 327                 return 0;
 328
 329         case KEYCTL_REJECT:
 330                 return keyctl_reject_key(tcp, tcp->u_arg[1], tcp->u_arg[2],
 331                                          tcp->u_arg[3], tcp->u_arg[4]);
 332
 333         case KEYCTL_INSTANTIATE_IOV:
 334                 return keyctl_instantiate_key_iov(tcp, tcp->u_arg[1],
 335                                                   tcp->u_arg[2], tcp->u_arg[3],
 336                                                   tcp->u_arg[4]);
 337
 338         case KEYCTL_GET_PERSISTENT:
 339                 return keyctl_get_persistent(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 340
 341         default:
 342                 if (entering(tcp))
 343                         tprintf(", %#lx, %#lx, %#lx, %#lx",
 344                                 tcp->u_arg[1], tcp->u_arg[2],
 345                                 tcp->u_arg[3], tcp->u_arg[4]);
 346         }
 347
 348         return 0;
 349 }