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

   1 /*
   2  * Copyright (c) 2014-2015 Dmitry V. Levin <ldv@altlinux.org>
   3  * Copyright (c) 2014-2017 The strace developers.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "defs.h"
  30
  31 #include "keyctl_kdf_params.h"
  32 #include "print_fields.h"
  33
  34 typedef int32_t key_serial_t;
  35
  36 #include "xlat/key_spec.h"
  37
  38 struct keyctl_dh_params {
  39         int32_t private;
  40         int32_t prime;
  41         int32_t base;
  42 };
  43
  44 static void
  45 print_keyring_serial_number(key_serial_t id)
  46 {
  47         printxval_d(key_spec, id, NULL);
  48 }
  49
  50 SYS_FUNC(add_key)
  51 {
  52         /* type */
  53         printstr(tcp, tcp->u_arg[0]);
  54         /* description */
  55         tprints(", ");
  56         printstr(tcp, tcp->u_arg[1]);
  57         /* payload */
  58         tprints(", ");
  59         printstrn(tcp, tcp->u_arg[2], tcp->u_arg[3]);
  60         /* payload length */
  61         tprintf(", %" PRI_klu ", ", tcp->u_arg[3]);
  62         /* keyring serial number */
  63         print_keyring_serial_number(tcp->u_arg[4]);
  64
  65         return RVAL_DECODED;
  66 }
  67
  68 SYS_FUNC(request_key)
  69 {
  70         /* type */
  71         printstr(tcp, tcp->u_arg[0]);
  72         /* description */
  73         tprints(", ");
  74         printstr(tcp, tcp->u_arg[1]);
  75         /* callout_info */
  76         tprints(", ");
  77         printstr(tcp, tcp->u_arg[2]);
  78         /* keyring serial number */
  79         tprints(", ");
  80         print_keyring_serial_number(tcp->u_arg[3]);
  81
  82         return RVAL_DECODED;
  83 }
  84
  85 static void
  86 keyctl_get_keyring_id(struct tcb *tcp, key_serial_t id, int create)
  87 {
  88         print_keyring_serial_number(id);
  89         tprintf(", %d", create);
  90 }
  91
  92 static void
  93 keyctl_update_key(struct tcb *tcp, key_serial_t id, kernel_ulong_t addr,
  94                   kernel_ulong_t len)
  95 {
  96         print_keyring_serial_number(id);
  97         tprints(", ");
  98         printstrn(tcp, addr, len);
  99         tprintf(", %llu", zero_extend_signed_to_ull(len));
 100 }
 101
 102 static void
 103 keyctl_handle_key_key(struct tcb *tcp, key_serial_t id1, key_serial_t id2)
 104 {
 105         print_keyring_serial_number(id1);
 106         tprints(", ");
 107         print_keyring_serial_number(id2);
 108 }
 109
 110 static void
 111 keyctl_read_key(struct tcb *tcp, key_serial_t id, kernel_ulong_t addr,
 112                 kernel_ulong_t len, bool has_nul)
 113 {
 114         if (entering(tcp)) {
 115                 print_keyring_serial_number(id);
 116                 tprints(", ");
 117         } else {
 118                 if (syserror(tcp))
 119                         printaddr(addr);
 120                 else {
 121                         kernel_ulong_t rval = (tcp->u_rval >= 0) &&
 122                                 ((kernel_ulong_t) tcp->u_rval > len) ? len :
 123                                 (kernel_ulong_t) tcp->u_rval;
 124                         printstr_ex(tcp, addr, rval, has_nul ?
 125                                     QUOTE_OMIT_TRAILING_0 : 0);
 126                 }
 127                 tprintf(", %llu", zero_extend_signed_to_ull(len));
 128         }
 129 }
 130
 131 static void
 132 keyctl_keyring_search(struct tcb *tcp, key_serial_t id1, kernel_ulong_t addr1,
 133                       kernel_ulong_t addr2, key_serial_t id2)
 134 {
 135         print_keyring_serial_number(id1);
 136         tprints(", ");
 137         printstr(tcp, addr1);
 138         tprints(", ");
 139         printstr(tcp, addr2);
 140         tprints(", ");
 141         print_keyring_serial_number(id2);
 142 }
 143
 144 static void
 145 keyctl_chown_key(struct tcb *tcp, key_serial_t id, unsigned user,
 146                  unsigned group)
 147 {
 148         print_keyring_serial_number(id);
 149         printuid(", ", user);
 150         printuid(", ", group);
 151 }
 152
 153 static void
 154 keyctl_instantiate_key(struct tcb *tcp, key_serial_t id1, kernel_ulong_t addr,
 155                        kernel_ulong_t len, key_serial_t id2)
 156 {
 157         print_keyring_serial_number(id1);
 158         tprints(", ");
 159         printstrn(tcp, addr, len);
 160         tprintf(", %llu, ", zero_extend_signed_to_ull(len));
 161         print_keyring_serial_number(id2);
 162 }
 163
 164 static void
 165 keyctl_instantiate_key_iov(struct tcb *tcp, key_serial_t id1,
 166                            kernel_ulong_t addr, kernel_ulong_t len,
 167                            key_serial_t id2)
 168 {
 169         print_keyring_serial_number(id1);
 170         tprints(", ");
 171         tprint_iov(tcp, len, addr, IOV_DECODE_STR);
 172         tprintf(", %llu, ", zero_extend_signed_to_ull(len));
 173         print_keyring_serial_number(id2);
 174 }
 175
 176 static void
 177 keyctl_negate_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 178                   key_serial_t id2)
 179 {
 180         print_keyring_serial_number(id1);
 181         tprintf(", %u, ", timeout);
 182         print_keyring_serial_number(id2);
 183 }
 184
 185 static void
 186 keyctl_reject_key(struct tcb *tcp, key_serial_t id1, unsigned timeout,
 187                   unsigned error, key_serial_t id2)
 188 {
 189         const char *err_str = err_name(error);
 190
 191         print_keyring_serial_number(id1);
 192         tprintf(", %u, ", timeout);
 193
 194         if (err_str)
 195                 tprintf("%s, ", err_str);
 196         else
 197                 tprintf("%u, ", error);
 198
 199         print_keyring_serial_number(id2);
 200 }
 201
 202 static void
 203 keyctl_set_timeout(struct tcb *tcp, key_serial_t id, unsigned timeout)
 204 {
 205         print_keyring_serial_number(id);
 206         tprintf(", %u", timeout);
 207 }
 208
 209 static void
 210 keyctl_get_persistent(struct tcb *tcp, unsigned uid, key_serial_t id)
 211 {
 212         printuid("", uid);
 213         tprints(", ");
 214         print_keyring_serial_number(id);
 215 }
 216
 217 #include "xlat/key_perms.h"
 218
 219 static void
 220 keyctl_setperm_key(struct tcb *tcp, key_serial_t id, uint32_t perm)
 221 {
 222         print_keyring_serial_number(id);
 223         tprints(", ");
 224         printflags(key_perms, perm, "KEY_???");
 225 }
 226
 227 static void
 228 print_dh_params(struct tcb *tcp, kernel_ulong_t addr)
 229 {
 230         struct keyctl_dh_params params;
 231
 232         if (umove_or_printaddr(tcp, addr, &params))
 233                 return;
 234
 235         tprints("{private=");
 236         print_keyring_serial_number(params.private);
 237         tprints(", prime=");
 238         print_keyring_serial_number(params.prime);
 239         tprints(", base=");
 240         print_keyring_serial_number(params.base);
 241         tprints("}");
 242 }
 243
 244 static void
 245 keyctl_dh_compute(struct tcb *tcp, kernel_ulong_t params, kernel_ulong_t buf,
 246                   kernel_ulong_t len, kernel_ulong_t kdf_addr)
 247 {
 248         if (entering(tcp)) {
 249                 print_dh_params(tcp, params);
 250                 tprints(", ");
 251         } else {
 252                 struct strace_keyctl_kdf_params kdf;
 253
 254                 if (syserror(tcp)) {
 255                         printaddr(buf);
 256                 } else {
 257                         kernel_ulong_t rval = (tcp->u_rval >= 0) &&
 258                                 ((kernel_ulong_t) tcp->u_rval > len) ? len :
 259                                 (kernel_ulong_t) tcp->u_rval;
 260                         printstrn(tcp, buf, rval);
 261                 }
 262                 tprintf(", %llu, ", zero_extend_signed_to_ull(len));
 263
 264                 if (fetch_keyctl_kdf_params(tcp, kdf_addr, &kdf)) {
 265                         printaddr(kdf_addr);
 266                 } else {
 267                         size_t i;
 268
 269                         PRINT_FIELD_STR("{", kdf, hashname, tcp);
 270
 271                         /*
 272                          * Kernel doesn't touch otherinfo
 273                          * if otherinfolen is zero.
 274                          */
 275                         if (kdf.otherinfolen)
 276                                 PRINT_FIELD_STRN(", ", kdf, otherinfo,
 277                                                  kdf.otherinfolen, tcp);
 278                         else
 279                                 PRINT_FIELD_PTR(", ", kdf, otherinfo);
 280
 281                         PRINT_FIELD_U(", ", kdf, otherinfolen);
 282
 283                         /* Some future-proofing */
 284                         for (i = 0; i < ARRAY_SIZE(kdf.__spare); i++) {
 285                                 if (kdf.__spare[i])
 286                                         break;
 287                         }
 288
 289                         if (i < ARRAY_SIZE(kdf.__spare)) {
 290                                 tprints(", __spare=[");
 291
 292                                 for (i = 0; i < ARRAY_SIZE(kdf.__spare); i++) {
 293                                         if (i)
 294                                                 tprints(", ");
 295
 296                                         tprintf("%#x", kdf.__spare[i]);
 297                                 }
 298
 299                                 tprints("]");
 300                         }
 301
 302                         tprints("}");
 303                 }
 304         }
 305 }
 306
 307 static void
 308 keyctl_restrict_keyring(struct tcb *const tcp,
 309                         const key_serial_t id,
 310                         const kernel_ulong_t addr1,
 311                         const kernel_ulong_t addr2)
 312 {
 313         print_keyring_serial_number(id);
 314         tprints(", ");
 315         printstr(tcp, addr1);
 316         tprints(", ");
 317         printstr(tcp, addr2);
 318 }
 319
 320 #include "xlat/key_reqkeys.h"
 321 #include "xlat/keyctl_commands.h"
 322
 323 SYS_FUNC(keyctl)
 324 {
 325         int cmd = tcp->u_arg[0];
 326         kernel_ulong_t arg2 = tcp->u_arg[1];
 327         kernel_ulong_t arg3 = tcp->u_arg[2];
 328         kernel_ulong_t arg4 = tcp->u_arg[3];
 329         kernel_ulong_t arg5 = tcp->u_arg[4];
 330
 331         if (entering(tcp)) {
 332                 printxval(keyctl_commands, cmd, "KEYCTL_???");
 333
 334                 /*
 335                  * For now, KEYCTL_SESSION_TO_PARENT is the only cmd without
 336                  * arguments.
 337                  */
 338                 if (cmd != KEYCTL_SESSION_TO_PARENT)
 339                         tprints(", ");
 340         }
 341
 342         switch (cmd) {
 343         case KEYCTL_GET_KEYRING_ID:
 344                 keyctl_get_keyring_id(tcp, arg2, arg3);
 345                 break;
 346
 347         case KEYCTL_JOIN_SESSION_KEYRING:
 348                 printstr(tcp, arg2);
 349                 break;
 350
 351         case KEYCTL_UPDATE:
 352                 keyctl_update_key(tcp, arg2, arg3, arg4);
 353                 break;
 354
 355         case KEYCTL_REVOKE:
 356         case KEYCTL_CLEAR:
 357         case KEYCTL_INVALIDATE:
 358         case KEYCTL_ASSUME_AUTHORITY:
 359                 print_keyring_serial_number(arg2);
 360                 break;
 361
 362         case KEYCTL_LINK:
 363         case KEYCTL_UNLINK:
 364                 keyctl_handle_key_key(tcp, arg2, arg3);
 365                 break;
 366
 367         case KEYCTL_DESCRIBE:
 368         case KEYCTL_READ:
 369         case KEYCTL_GET_SECURITY:
 370                 keyctl_read_key(tcp, arg2, arg3, arg4, cmd != KEYCTL_READ);
 371                 return 0;
 372
 373         case KEYCTL_SEARCH:
 374                 keyctl_keyring_search(tcp, arg2, arg3, arg4, arg5);
 375                 break;
 376
 377         case KEYCTL_CHOWN:
 378                 keyctl_chown_key(tcp, arg2, arg3, arg4);
 379                 break;
 380
 381         case KEYCTL_SETPERM:
 382                 keyctl_setperm_key(tcp, arg2, arg3);
 383                 break;
 384
 385         case KEYCTL_INSTANTIATE:
 386                 keyctl_instantiate_key(tcp, arg2, arg3, arg4, arg5);
 387                 break;
 388
 389         case KEYCTL_NEGATE:
 390                 keyctl_negate_key(tcp, arg2, arg3, arg4);
 391                 break;
 392
 393         case KEYCTL_SET_REQKEY_KEYRING:
 394                 printxval(key_reqkeys, arg2, "KEY_REQKEY_DEFL_???");
 395                 break;
 396
 397         case KEYCTL_SET_TIMEOUT:
 398                 keyctl_set_timeout(tcp, arg2, arg3);
 399                 break;
 400
 401         case KEYCTL_SESSION_TO_PARENT:
 402                 break;
 403
 404         case KEYCTL_REJECT:
 405                 keyctl_reject_key(tcp, arg2, arg3, arg4, arg5);
 406                 break;
 407
 408         case KEYCTL_INSTANTIATE_IOV:
 409                 keyctl_instantiate_key_iov(tcp, arg2, arg3, arg4, arg5);
 410                 break;
 411
 412         case KEYCTL_GET_PERSISTENT:
 413                 keyctl_get_persistent(tcp, arg2, arg3);
 414                 break;
 415
 416         case KEYCTL_DH_COMPUTE:
 417                 keyctl_dh_compute(tcp, arg2, arg3, arg4, arg5);
 418                 return 0;
 419
 420         case KEYCTL_RESTRICT_KEYRING:
 421                 keyctl_restrict_keyring(tcp, arg2, arg3, arg4);
 422                 break;
 423
 424         default:
 425                 tprintf("%#" PRI_klx ", %#" PRI_klx
 426                         ", %#" PRI_klx ", %#" PRI_klx,
 427                         arg2, arg3, arg4, arg5);
 428                 break;
 429         }
 430
 431         return RVAL_DECODED;
 432 }