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 SYS_FUNC(add_key)
  19 {
  20         /* type */
  21         printstr(tcp, tcp->u_arg[0], -1);
  22         /* description */
  23         tprints(", ");
  24         printstr(tcp, tcp->u_arg[1], -1);
  25         /* payload */
  26         tprints(", ");
  27         printstr(tcp, tcp->u_arg[2], tcp->u_arg[3]);
  28         /* payload length */
  29         tprintf(", %lu, ", tcp->u_arg[3]);
  30         /* keyring serial number */
  31         print_keyring_serial_number(tcp->u_arg[4]);
  32
  33         return RVAL_DECODED;
  34 }
  35
  36 SYS_FUNC(request_key)
  37 {
  38         /* type */
  39         printstr(tcp, tcp->u_arg[0], -1);
  40         /* description */
  41         tprints(", ");
  42         printstr(tcp, tcp->u_arg[1], -1);
  43         /* callout_info */
  44         tprints(", ");
  45         printstr(tcp, tcp->u_arg[2], -1);
  46         /* keyring serial number */
  47         tprints(", ");
  48         print_keyring_serial_number(tcp->u_arg[3]);
  49
  50         return RVAL_DECODED;
  51 }
  52
  53 static void
  54 keyctl_get_keyring_id(struct tcb *tcp, key_serial_t id, int create)
  55 {
  56         print_keyring_serial_number(id);
  57         tprintf(", %d", create);
  58 }
  59
  60 static void
  61 keyctl_update_key(struct tcb *tcp, key_serial_t id, long addr, long len)
  62 {
  63         print_keyring_serial_number(id);
  64         tprints(", ");
  65         printstr(tcp, addr, len);
  66         tprintf(", %lu", len);
  67 }
  68
  69 static void
  70 keyctl_handle_key_key(struct tcb *tcp, key_serial_t id1, key_serial_t id2)
  71 {
  72         print_keyring_serial_number(id1);
  73         tprints(", ");
  74         print_keyring_serial_number(id2);
  75 }
  76
  77 static void
  78 keyctl_read_key(struct tcb *tcp, key_serial_t id, long addr, long len)
  79 {
  80         if (entering(tcp)) {
  81                 print_keyring_serial_number(id);
  82                 tprints(", ");
  83         } else {
  84                 if (syserror(tcp))
  85                         printaddr(addr);
  86                 else {
  87                         long rval = tcp->u_rval > len ?
  88                                     len : (tcp->u_rval ? -1 : 0);
  89                         printstr(tcp, addr, rval);
  90                 }
  91                 tprintf(", %lu", len);
  92         }
  93 }
  94
  95 static void
  96 keyctl_keyring_search(struct tcb *tcp, key_serial_t id1, long addr1,
  97                       long addr2, key_serial_t id2)
  98 {
  99         print_keyring_serial_number(id1);
 100         tprints(", ");
 101         printstr(tcp, addr1, -1);
 102         tprints(", ");
 103         printstr(tcp, addr2, -1);
 104         tprints(", ");
 105         print_keyring_serial_number(id2);
 106 }
 107
 108 static void
 109 keyctl_chown_key(struct tcb *tcp, key_serial_t id, int user, int group)
 110 {
 111         print_keyring_serial_number(id);
 112         tprintf(", %d, %d", user, group);
 113 }
 114
 115 static void
 116 keyctl_instantiate_key(struct tcb *tcp, key_serial_t id1, long addr,
 117                        long len, key_serial_t id2)
 118 {
 119         print_keyring_serial_number(id1);
 120         tprints(", ");
 121         printstr(tcp, addr, len);
 122         tprintf(", %lu, ", len);
 123         print_keyring_serial_number(id2);
 124 }
 125
 126 static void
 127 keyctl_instantiate_key_iov(struct tcb *tcp, key_serial_t id1,
 128                            long addr, long len, key_serial_t id2)
 129 {
 130         print_keyring_serial_number(id1);
 131         tprints(", ");
 132         tprint_iov(tcp, len, addr, 1);
 133         tprintf(", %lu, ", len);
 134         print_keyring_serial_number(id2);
 135 }
 136
 137 static void
 138 keyctl_negate_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 139                   key_serial_t id2)
 140 {
 141         print_keyring_serial_number(id1);
 142         tprintf(", %u, ", timeout);
 143         print_keyring_serial_number(id2);
 144 }
 145
 146 static void
 147 keyctl_reject_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 148                   unsigned error, key_serial_t id2)
 149 {
 150         print_keyring_serial_number(id1);
 151         tprintf(", %u, %u, ", timeout, error);
 152         print_keyring_serial_number(id2);
 153 }
 154
 155 static void
 156 keyctl_set_timeout(struct tcb *tcp, key_serial_t id, unsigned timeout)
 157 {
 158         print_keyring_serial_number(id);
 159         tprintf(", %u", timeout);
 160 }
 161
 162 static void
 163 keyctl_get_persistent(struct tcb *tcp, int uid, key_serial_t id)
 164 {
 165         tprintf("%d, ", uid);
 166         print_keyring_serial_number(id);
 167 }
 168
 169 #include "xlat/key_perms.h"
 170
 171 static void
 172 keyctl_setperm_key(struct tcb *tcp, key_serial_t id, uint32_t perm)
 173 {
 174         print_keyring_serial_number(id);
 175         tprints(", ");
 176         printflags(key_perms, perm, "KEY_???");
 177 }
 178
 179 #include "xlat/key_reqkeys.h"
 180 #include "xlat/keyctl_commands.h"
 181
 182 SYS_FUNC(keyctl)
 183 {
 184         int cmd = tcp->u_arg[0];
 185
 186         if (entering(tcp)) {
 187                 printxval(keyctl_commands, cmd, "KEYCTL_???");
 188                 tprints(", ");
 189         }
 190
 191         switch (cmd) {
 192         case KEYCTL_GET_KEYRING_ID:
 193                 keyctl_get_keyring_id(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 194                 break;
 195
 196         case KEYCTL_JOIN_SESSION_KEYRING:
 197                 printstr(tcp, tcp->u_arg[1], -1);
 198                 break;
 199
 200         case KEYCTL_UPDATE:
 201                 keyctl_update_key(tcp, tcp->u_arg[1],
 202                                   tcp->u_arg[2], tcp->u_arg[3]);
 203                 break;
 204
 205         case KEYCTL_REVOKE:
 206         case KEYCTL_CLEAR:
 207         case KEYCTL_INVALIDATE:
 208         case KEYCTL_ASSUME_AUTHORITY:
 209                 print_keyring_serial_number(tcp->u_arg[1]);
 210                 break;
 211
 212         case KEYCTL_LINK:
 213         case KEYCTL_UNLINK:
 214                 keyctl_handle_key_key(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 215                 break;
 216
 217         case KEYCTL_DESCRIBE:
 218         case KEYCTL_READ:
 219         case KEYCTL_GET_SECURITY:
 220                 keyctl_read_key(tcp, tcp->u_arg[1],
 221                                 tcp->u_arg[2], tcp->u_arg[3]);
 222                 return 0;
 223
 224         case KEYCTL_SEARCH:
 225                 keyctl_keyring_search(tcp, tcp->u_arg[1], tcp->u_arg[2],
 226                                       tcp->u_arg[3], tcp->u_arg[4]);
 227                 break;
 228
 229         case KEYCTL_CHOWN:
 230                 keyctl_chown_key(tcp, tcp->u_arg[1],
 231                                  tcp->u_arg[2], tcp->u_arg[3]);
 232                 break;
 233
 234         case KEYCTL_SETPERM:
 235                 keyctl_setperm_key(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 236                 break;
 237
 238         case KEYCTL_INSTANTIATE:
 239                 keyctl_instantiate_key(tcp, tcp->u_arg[1], tcp->u_arg[2],
 240                                        tcp->u_arg[3], tcp->u_arg[4]);
 241                 break;
 242
 243         case KEYCTL_NEGATE:
 244                 keyctl_negate_key(tcp, tcp->u_arg[1],
 245                                   tcp->u_arg[2], tcp->u_arg[3]);
 246                 break;
 247
 248         case KEYCTL_SET_REQKEY_KEYRING:
 249                 printxval(key_reqkeys, tcp->u_arg[1], "KEY_REQKEY_DEFL_???");
 250                 break;
 251
 252         case KEYCTL_SET_TIMEOUT:
 253                 keyctl_set_timeout(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 254                 break;
 255
 256         case KEYCTL_SESSION_TO_PARENT:
 257                 break;
 258
 259         case KEYCTL_REJECT:
 260                 keyctl_reject_key(tcp, tcp->u_arg[1], tcp->u_arg[2],
 261                                   tcp->u_arg[3], tcp->u_arg[4]);
 262                 break;
 263
 264         case KEYCTL_INSTANTIATE_IOV:
 265                 keyctl_instantiate_key_iov(tcp, tcp->u_arg[1],
 266                                            tcp->u_arg[2], tcp->u_arg[3],
 267                                            tcp->u_arg[4]);
 268                 break;
 269
 270         case KEYCTL_GET_PERSISTENT:
 271                 keyctl_get_persistent(tcp, tcp->u_arg[1], tcp->u_arg[2]);
 272                 break;
 273
 274         default:
 275                 tprintf("%#lx, %#lx, %#lx, %#lx",
 276                         tcp->u_arg[1], tcp->u_arg[2],
 277                         tcp->u_arg[3], tcp->u_arg[4]);
 278                 break;
 279         }
 280
 281         return RVAL_DECODED;
 282 }