tools/testing/selftests/kdbus/test-endpoint.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <fcntl.h>
   4 #include <stdlib.h>
   5 #include <stddef.h>
   6 #include <unistd.h>
   7 #include <stdint.h>
   8 #include <errno.h>
   9 #include <assert.h>
  10 #include <libgen.h>
  11 #include <sys/capability.h>
  12 #include <sys/wait.h>
  13 #include <stdbool.h>
  14
  15 #include "kdbus-api.h"
  16 #include "kdbus-util.h"
  17 #include "kdbus-enum.h"
  18 #include "kdbus-test.h"
  19
  20 #define KDBUS_SYSNAME_MAX_LEN                   63
  21
  22 static wur int install_name_add_match(struct kdbus_conn *conn, const char *name)
  23 {
  24         struct {
  25                 struct kdbus_cmd_match cmd;
  26                 struct {
  27                         uint64_t size;
  28                         uint64_t type;
  29                         struct kdbus_notify_name_change chg;
  30                 } item;
  31                 char name[64];
  32         } buf;
  33         int ret;
  34
  35         /* install the match rule */
  36         memset(&buf, 0, sizeof(buf));
  37         buf.item.type = KDBUS_ITEM_NAME_ADD;
  38         buf.item.chg.old_id.id = KDBUS_MATCH_ID_ANY;
  39         buf.item.chg.new_id.id = KDBUS_MATCH_ID_ANY;
  40         strncpy(buf.name, name, sizeof(buf.name) - 1);
  41         buf.item.size = sizeof(buf.item) + strlen(buf.name) + 1;
  42         buf.cmd.size = sizeof(buf.cmd) + buf.item.size;
  43
  44         ret = kdbus_cmd_match_add(conn->fd, &buf.cmd);
  45         if (ret < 0)
  46                 return ret;
  47
  48         return 0;
  49 }
  50
  51 static wur int create_endpoint(const char *buspath, uid_t uid, const char *name,
  52                            uint64_t flags)
  53 {
  54         struct {
  55                 struct kdbus_cmd cmd;
  56
  57                 /* name item */
  58                 struct {
  59                         uint64_t size;
  60                         uint64_t type;
  61                         /* max should be KDBUS_SYSNAME_MAX_LEN */
  62                         char str[128];
  63                 } name;
  64         } ep_make;
  65         int fd, ret;
  66
  67         fd = open(buspath, O_RDWR);
  68         if (fd < 0)
  69                 return fd;
  70
  71         memset(&ep_make, 0, sizeof(ep_make));
  72
  73         snprintf(ep_make.name.str,
  74                  /* Use the KDBUS_SYSNAME_MAX_LEN or sizeof(str) */
  75                  KDBUS_SYSNAME_MAX_LEN > strlen(name) ?
  76                  KDBUS_SYSNAME_MAX_LEN : sizeof(ep_make.name.str),
  77                  "%u-%s", uid, name);
  78
  79         ep_make.name.type = KDBUS_ITEM_MAKE_NAME;
  80         ep_make.name.size = KDBUS_ITEM_HEADER_SIZE +
  81                             strlen(ep_make.name.str) + 1;
  82
  83         ep_make.cmd.flags = flags;
  84         ep_make.cmd.size = sizeof(ep_make.cmd) + ep_make.name.size;
  85
  86         ret = kdbus_cmd_endpoint_make(fd, &ep_make.cmd);
  87         if (ret < 0) {
  88                 kdbus_printf("error creating endpoint: %d (%m)\n", ret);
  89                 return ret;
  90         }
  91
  92         return fd;
  93 }
  94
  95 static wur int unpriv_test_custom_ep(const char *buspath)
  96 {
  97         int ret, ep_fd1, ep_fd2;
  98         char *ep1, *ep2, *tmp1, *tmp2;
  99
 100         ASSERT_NONZERO(tmp1 = strdup(buspath));
 101         ASSERT_NONZERO(tmp2 = strdup(buspath));
 102
 103         ret = asprintf(&ep1, "%s/%u-%s", dirname(tmp1), getuid(), "apps1");
 104         ASSERT_RETURN(ret,>,0);
 105
 106         ret = asprintf(&ep2, "%s/%u-%s", dirname(tmp2), getuid(), "apps2");
 107         ASSERT_RETURN(ret,>,0);
 108
 109         free(tmp1);
 110         free(tmp2);
 111
 112         /* endpoint only accessible to current uid */
 113         ep_fd1 = create_endpoint(buspath, getuid(), "apps1", 0);
 114         ASSERT_RETURN(ep_fd1,>=,0);
 115
 116         /* endpoint world accessible */
 117         ep_fd2 = create_endpoint(buspath, getuid(), "apps2",
 118                                   KDBUS_MAKE_ACCESS_WORLD);
 119         ASSERT_RETURN(ep_fd2,>=,0);
 120
 121         RUN_UNPRIVILEGED(UNPRIV_UID, UNPRIV_UID, ({
 122                 int ep_fd;
 123                 struct kdbus_conn *ep_conn;
 124
 125                 /*
 126                  * Make sure that we are not able to create custom
 127                  * endpoints
 128                  */
 129                 ep_fd = create_endpoint(buspath, getuid(),
 130                                         "unpriv_costum_ep", 0);
 131                 ASSERT_EXIT(ep_fd,==,-EPERM);
 132
 133                 /*
 134                  * Endpoint "apps1" only accessible to same users,
 135                  * that own the endpoint. Access denied by VFS
 136                  */
 137                 ep_conn = kdbus_hello(ep1, 0, NULL, 0);
 138                 ASSERT_EXIT(errno,==,EACCES);
 139                 ASSERT_EXIT_ZERO(ep_conn);
 140
 141                 /* Endpoint "apps2" world accessible */
 142                 ASSERT_EXIT_NONZERO(ep_conn = kdbus_hello(ep2, 0, NULL, 0));
 143
 144                 kdbus_conn_free(ep_conn);
 145
 146                 exit(EXIT_SUCCESS);
 147         }),
 148         ({}));
 149
 150         CLOSE(ep_fd1);
 151         CLOSE(ep_fd2);
 152         free(ep1);
 153         free(ep2);
 154
 155         return 0;
 156 }
 157
 158 static wur int update_endpoint(int fd, const char *name)
 159 {
 160         int len = strlen(name) + 1;
 161         struct {
 162                 struct kdbus_cmd cmd;
 163
 164                 /* name item */
 165                 struct {
 166                         uint64_t size;
 167                         uint64_t type;
 168                         char str[KDBUS_ALIGN8(len)];
 169                 } name;
 170
 171                 struct {
 172                         uint64_t size;
 173                         uint64_t type;
 174                         struct kdbus_policy_access access;
 175                 } access;
 176         } ep_update;
 177         int ret;
 178
 179         memset(&ep_update, 0, sizeof(ep_update));
 180
 181         ep_update.name.size = KDBUS_ITEM_HEADER_SIZE + len;
 182         ep_update.name.type = KDBUS_ITEM_NAME;
 183         strncpy(ep_update.name.str, name, sizeof(ep_update.name.str) - 1);
 184
 185         ep_update.access.size = sizeof(ep_update.access);
 186         ep_update.access.type = KDBUS_ITEM_POLICY_ACCESS;
 187         ep_update.access.access.type = KDBUS_POLICY_ACCESS_WORLD;
 188         ep_update.access.access.access = KDBUS_POLICY_SEE;
 189
 190         ep_update.cmd.size = sizeof(ep_update);
 191
 192         ret = kdbus_cmd_endpoint_update(fd, &ep_update.cmd);
 193         if (ret < 0) {
 194                 kdbus_printf("error updating endpoint: %d (%m)\n", ret);
 195                 return ret;
 196         }
 197
 198         return 0;
 199 }
 200
 201 wur int kdbus_test_custom_endpoint(struct kdbus_test_env *env)
 202 {
 203         char *ep, *tmp;
 204         int ret, ep_fd;
 205         struct kdbus_msg *msg;
 206         struct kdbus_conn *ep_conn;
 207         struct kdbus_conn *reader;
 208         const char *name = "foo.bar.baz";
 209         const char *epname = "foo";
 210         char fake_ep[KDBUS_SYSNAME_MAX_LEN + 1] = {'\0'};
 211
 212         memset(fake_ep, 'X', sizeof(fake_ep) - 1);
 213
 214         /* Try to create a custom endpoint with a long name */
 215         ASSERT_RETURN(-ENAMETOOLONG,==,create_endpoint(env->buspath, getuid(), fake_ep, 0));
 216
 217         /* Try to create a custom endpoint with a different uid */
 218         ASSERT_RETURN(-EINVAL,==,create_endpoint(env->buspath, getuid() + 1, "foobar", 0));
 219
 220         /* create a custom endpoint, and open a connection on it */
 221         ASSERT_RETURN(0,<=,ep_fd = create_endpoint(env->buspath, getuid(), "foo", 0));
 222
 223         ASSERT_NONZERO(tmp = strdup(env->buspath));
 224         ASSERT_RETURN(0,<=,asprintf(&ep, "%s/%u-%s", dirname(tmp), getuid(), epname));
 225         free(tmp);
 226
 227         /* Register a connection that listen to broadcasts */
 228         ASSERT_NONZERO(reader = kdbus_hello(ep, 0, NULL, 0));
 229
 230         /* Register to kernel signals */
 231         ASSERT_ZERO(kdbus_add_match_id(reader, 0x1, KDBUS_ITEM_ID_ADD, KDBUS_MATCH_ID_ANY));
 232         ASSERT_ZERO(kdbus_add_match_id(reader, 0x2, KDBUS_ITEM_ID_REMOVE, KDBUS_MATCH_ID_ANY));
 233         ASSERT_ZERO(install_name_add_match(reader, name));
 234
 235         /* Monitor connections are not supported on custom endpoints */
 236         ep_conn = kdbus_hello(ep, KDBUS_HELLO_MONITOR, NULL, 0);
 237         ASSERT_RETURN(errno,==,EOPNOTSUPP);
 238         ASSERT_ZERO(ep_conn);
 239
 240         ASSERT_NONZERO(ep_conn = kdbus_hello(ep, 0, NULL, 0));
 241
 242         /* Check that the reader got the IdAdd notification */
 243         ASSERT_ZERO(kdbus_msg_recv(reader, &msg, NULL));
 244         ASSERT_RETURN(msg->items[0].type,==,(typeof(msg->items[0].type))KDBUS_ITEM_ID_ADD);
 245         ASSERT_RETURN(msg->items[0].id_change.id,==,ep_conn->id);
 246         kdbus_msg_free(msg);
 247
 248         /*
 249          * Add a name add match on the endpoint connection, acquire name from
 250          * the unfiltered connection, and make sure the filtered connection
 251          * did not get the notification on the name owner change. Also, the
 252          * endpoint connection may not be able to call conn_info, neither on
 253          * the name nor on the ID.
 254          */
 255         ASSERT_ZERO(install_name_add_match(ep_conn, name));
 256
 257         ASSERT_ZERO(kdbus_name_acquire(env->conn, name, NULL));
 258
 259         ASSERT_RETURN(ONTIZEN(0,-EAGAIN),==,kdbus_msg_recv(ep_conn, NULL, NULL));
 260         ASSERT_RETURN(ONTIZEN(0,-ESRCH),==,kdbus_conn_info(ep_conn, 0, name, 0, NULL));
 261         ASSERT_RETURN(-ESRCH,==,kdbus_conn_info(ep_conn, 0, "random.crappy.name", 0, NULL));
 262         ASSERT_RETURN(ONTIZEN(0,-ENXIO),==,kdbus_conn_info(ep_conn, env->conn->id, NULL, 0, NULL));
 263         ASSERT_RETURN(-ENXIO,==,kdbus_conn_info(ep_conn, 0x0fffffffffffffffULL, NULL, 0, NULL));
 264
 265         /* Check that the reader did not receive the name notification */
 266         ASSERT_RETURN(ONTIZEN(0,-EAGAIN),==,kdbus_msg_recv(reader, NULL, NULL));
 267
 268         /*
 269          * Release the name again, update the custom endpoint policy,
 270          * and try again. This time, the connection on the custom endpoint
 271          * should have gotten it.
 272          */
 273         ASSERT_ZERO(kdbus_name_release(env->conn, name));
 274
 275         /* Check that the reader did not receive the name notification */
 276         ASSERT_RETURN(-EAGAIN,==,kdbus_msg_recv(reader, NULL, NULL));
 277
 278         ASSERT_ZERO(update_endpoint(ep_fd, name));
 279
 280         ASSERT_ZERO(kdbus_name_acquire(env->conn, name, NULL));
 281
 282         ASSERT_ZERO(kdbus_msg_recv(ep_conn, &msg, NULL));
 283         ASSERT_RETURN(msg->items[0].type,==,(typeof(msg->items[0].type))KDBUS_ITEM_NAME_ADD);
 284         ASSERT_ZERO(msg->items[0].name_change.old_id.id);
 285         ASSERT_RETURN(msg->items[0].name_change.new_id.id,==,env->conn->id);
 286         ASSERT_ZERO(strcmp(msg->items[0].name_change.name, name));
 287         kdbus_msg_free(msg);
 288
 289         ASSERT_ZERO(kdbus_msg_recv(reader, &msg, NULL));
 290         ASSERT_ZERO(strcmp(msg->items[0].name_change.name, name));
 291
 292         kdbus_msg_free(msg);
 293
 294         ASSERT_ZERO(kdbus_conn_info(ep_conn, 0, name, 0, NULL));
 295
 296         ASSERT_ZERO(kdbus_conn_info(ep_conn, env->conn->id, NULL, 0, NULL));
 297
 298         /* If we have privileges test custom endpoints */
 299         ret = test_is_capable(CAP_SETUID, CAP_SETGID, -1);
 300         ASSERT_RETURN(ret,>=,0);
 301
 302         /*
 303          * All uids/gids are mapped and we have the necessary caps
 304          */
 305         if (ret && all_uids_gids_are_mapped())
 306                 ASSERT_ZERO(unpriv_test_custom_ep(env->buspath));
 307
 308         kdbus_conn_free(reader);
 309         kdbus_conn_free(ep_conn);
 310         CLOSE(ep_fd);
 311
 312         return TEST_OK;
 313 }