libsmack/libsmack.c

   1 /*
   2  * This file is part of libsmack
   3  *
   4  * Copyright (C) 2010, 2011 Nokia Corporation
   5  * Copyright (C) 2011, 2012, 2013 Intel Corporation
   6  * Copyright (C) 2012, 2013 Samsung Electronics Co.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * version 2.1 as published by the Free Software Foundation.
  11  *
  12  * This library is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include "sys/smack.h"
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/socket.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <unistd.h>
  33 #include <limits.h>
  34 #include <sys/xattr.h>
  35
  36 #define ACC_LEN 5
  37 #define LOAD_LEN (2 * (SMACK_LABEL_LEN + 1) + 2 * ACC_LEN + 1)
  38
  39 #define LEVEL_MAX 255
  40 #define NUM_LEN 4
  41 #define BUF_SIZE 512
  42 #define CAT_MAX_COUNT 240
  43 #define CAT_MAX_VALUE 63
  44 #define CIPSO_POS(i)   (SMACK_LABEL_LEN + 1 + NUM_LEN + NUM_LEN + i * NUM_LEN)
  45 #define CIPSO_MAX_SIZE CIPSO_POS(CAT_MAX_COUNT)
  46 #define CIPSO_NUM_LEN_STR "%-4d"
  47
  48 #define KERNEL_LONG_FORMAT "%s %s %s"
  49 #define KERNEL_SHORT_FORMAT "%-23s %-23s %5s"
  50 #define KERNEL_MODIFY_FORMAT "%s %s %s %s"
  51 #define READ_BUF_SIZE LOAD_LEN + 1
  52 #define SELF_LABEL_FILE "/proc/self/attr/current"
  53 #define ACC_CLEAR "-----"
  54
  55 extern char *smackfs_mnt;
  56
  57 struct smack_rule {
  58         char subject[SMACK_LABEL_LEN + 1];
  59         char object[SMACK_LABEL_LEN + 1];
  60         int is_modify;
  61         char access_type[ACC_LEN + 1];
  62         char allow_access_type[ACC_LEN + 1];
  63         char deny_access_type[ACC_LEN + 1];
  64         struct smack_rule *next;
  65 };
  66
  67 struct smack_accesses {
  68         struct smack_rule *first;
  69         struct smack_rule *last;
  70 };
  71
  72 struct cipso_mapping {
  73         char label[SMACK_LABEL_LEN + 1];
  74         int cats[CAT_MAX_VALUE];
  75         int ncats;
  76         int level;
  77         struct cipso_mapping *next;
  78 };
  79
  80 struct smack_cipso {
  81         struct cipso_mapping *first;
  82         struct cipso_mapping *last;
  83 };
  84
  85 static int accesses_apply(struct smack_accesses *handle, int clear);
  86 static inline void parse_access_type(const char *in, char out[ACC_LEN + 1]);
  87 static ssize_t smack_label_length(const char *label) __attribute__((unused));
  88 static inline ssize_t get_label(char *dest, const char *src);
  89
  90 int smack_accesses_new(struct smack_accesses **accesses)
  91 {
  92         struct smack_accesses *result;
  93
  94         result = calloc(sizeof(struct smack_accesses), 1);
  95         if (result == NULL)
  96                 return -1;
  97
  98         *accesses = result;
  99         return 0;
 100 }
 101
 102 void smack_accesses_free(struct smack_accesses *handle)
 103 {
 104         if (handle == NULL)
 105                 return;
 106
 107         struct smack_rule *rule = handle->first;
 108         struct smack_rule *next_rule = NULL;
 109
 110         while (rule != NULL) {
 111                 next_rule = rule->next;
 112                 free(rule);
 113                 rule = next_rule;
 114         }
 115
 116         free(handle);
 117 }
 118
 119 int smack_accesses_save(struct smack_accesses *handle, int fd)
 120 {
 121         struct smack_rule *rule = handle->first;
 122         FILE *file;
 123         int ret;
 124         int newfd;
 125
 126         newfd = dup(fd);
 127         if (newfd == -1)
 128                 return -1;
 129
 130         file = fdopen(newfd, "w");
 131         if (file == NULL) {
 132                 close(newfd);
 133                 return -1;
 134         }
 135
 136         while (rule) {
 137                 if (rule->is_modify) {
 138                         ret = fprintf(file, "%s %s %s %s\n",
 139                                       rule->subject, rule->object,
 140                                       rule->allow_access_type,
 141                                       rule->deny_access_type);
 142                 } else {
 143                         ret = fprintf(file, "%s %s %s\n",
 144                                       rule->subject, rule->object,
 145                                       rule->access_type);
 146                 }
 147
 148                 if (ret < 0) {
 149                         fclose(file);
 150                         return -1;
 151                 }
 152
 153                 rule = rule->next;
 154         }
 155
 156         fclose(file);
 157         return 0;
 158 }
 159
 160 int smack_accesses_apply(struct smack_accesses *handle)
 161 {
 162         return accesses_apply(handle, 0);
 163 }
 164
 165 int smack_accesses_clear(struct smack_accesses *handle)
 166 {
 167         return accesses_apply(handle, 1);
 168 }
 169
 170 int smack_accesses_add(struct smack_accesses *handle, const char *subject,
 171                        const char *object, const char *access_type)
 172 {
 173         struct smack_rule *rule = NULL;
 174
 175         if (smack_label_length(subject) < 0 ||
 176             smack_label_length(object) < 0)
 177                 return -1;
 178
 179         rule = calloc(sizeof(struct smack_rule), 1);
 180         if (rule == NULL)
 181                 return -1;
 182
 183         strncpy(rule->subject, subject, SMACK_LABEL_LEN);
 184         strncpy(rule->object, object, SMACK_LABEL_LEN);
 185         parse_access_type(access_type, rule->access_type);
 186
 187         if (handle->first == NULL) {
 188                 handle->first = handle->last = rule;
 189         } else {
 190                 handle->last->next = rule;
 191                 handle->last = rule;
 192         }
 193
 194         return 0;
 195 }
 196
 197 int smack_accesses_add_modify(struct smack_accesses *handle,
 198                               const char *subject,
 199                               const char *object,
 200                               const char *allow_access_type,
 201                               const char *deny_access_type)
 202 {
 203         struct smack_rule *rule = NULL;
 204
 205         if (smack_label_length(subject) < 0 ||
 206             smack_label_length(object) < 0)
 207                 return -1;
 208
 209         rule = calloc(sizeof(struct smack_rule), 1);
 210         if (rule == NULL)
 211                 return -1;
 212
 213         strncpy(rule->subject, subject, SMACK_LABEL_LEN);
 214         strncpy(rule->object, object, SMACK_LABEL_LEN);
 215         parse_access_type(allow_access_type, rule->allow_access_type);
 216         parse_access_type(deny_access_type, rule->deny_access_type);
 217         rule->is_modify = 1;
 218
 219         if (handle->first == NULL) {
 220                 handle->first = handle->last = rule;
 221         } else {
 222                 handle->last->next = rule;
 223                 handle->last = rule;
 224         }
 225
 226         return 0;
 227 }
 228
 229 int smack_accesses_add_from_file(struct smack_accesses *accesses, int fd)
 230 {
 231         FILE *file = NULL;
 232         char buf[READ_BUF_SIZE];
 233         char *ptr;
 234         const char *subject, *object, *access, *access2;
 235         int newfd;
 236         int ret;
 237
 238         newfd = dup(fd);
 239         if (newfd == -1)
 240                 return -1;
 241
 242         file = fdopen(newfd, "r");
 243         if (file == NULL) {
 244                 close(newfd);
 245                 return -1;
 246         }
 247
 248         while (fgets(buf, READ_BUF_SIZE, file) != NULL) {
 249                 if (strcmp(buf, "\n") == 0)
 250                         continue;
 251                 subject = strtok_r(buf, " \t\n", &ptr);
 252                 object = strtok_r(NULL, " \t\n", &ptr);
 253                 access = strtok_r(NULL, " \t\n", &ptr);
 254                 access2 = strtok_r(NULL, " \t\n", &ptr);
 255
 256                 if (subject == NULL || object == NULL || access == NULL ||
 257                     strtok_r(NULL, " \t\n", &ptr) != NULL) {
 258                         fclose(file);
 259                         return -1;
 260                 }
 261
 262                 if (access2 == NULL)
 263                         ret = smack_accesses_add(accesses, subject, object, access);
 264                 else
 265                         ret = smack_accesses_add_modify(accesses, subject, object, access, access2);
 266
 267                 if (ret) {
 268                         fclose(file);
 269                         return -1;
 270                 }
 271         }
 272
 273         if (ferror(file)) {
 274                 fclose(file);
 275                 return -1;
 276         }
 277
 278         fclose(file);
 279         return 0;
 280 }
 281
 282 int smack_have_access(const char *subject, const char *object,
 283                       const char *access_type)
 284 {
 285         char buf[LOAD_LEN + 1];
 286         char access_type_k[ACC_LEN + 1];
 287         int ret;
 288         int fd;
 289         int access2 = 1;
 290         char path[PATH_MAX];
 291
 292         if (!smackfs_mnt)
 293                 return -1;
 294
 295         snprintf(path, sizeof path, "%s/access2", smackfs_mnt);
 296         fd = open(path, O_RDWR);
 297         if (fd < 0) {
 298                 if (errno != ENOENT)
 299                         return -1;
 300
 301                 snprintf(path, sizeof path, "%s/access", smackfs_mnt);
 302                 fd = open(path, O_RDWR);
 303                 if (fd < 0)
 304                         return -1;
 305                 access2 = 0;
 306         }
 307
 308         parse_access_type(access_type, access_type_k);
 309
 310         if (access2)
 311                 ret = snprintf(buf, LOAD_LEN + 1, KERNEL_LONG_FORMAT,
 312                                subject, object, access_type_k);
 313         else
 314                 ret = snprintf(buf, LOAD_LEN + 1, KERNEL_SHORT_FORMAT,
 315                                subject, object, access_type_k);
 316
 317         if (ret < 0) {
 318                 close(fd);
 319                 return -1;
 320         }
 321
 322         ret = write(fd, buf, strlen(buf));
 323         if (ret < 0) {
 324                 close(fd);
 325                 return -1;
 326         }
 327
 328         ret = read(fd, buf, 1);
 329         close(fd);
 330         if (ret < 0)
 331                 return -1;
 332
 333         return buf[0] == '1';
 334 }
 335
 336 int smack_cipso_new(struct smack_cipso **cipso)
 337 {
 338         struct smack_cipso *result;
 339
 340         result = calloc(sizeof(struct smack_cipso), 1);
 341         if (result == NULL)
 342                 return -1;
 343
 344         *cipso = result;
 345         return 0;
 346 }
 347
 348 void smack_cipso_free(struct smack_cipso *cipso)
 349 {
 350         if (cipso == NULL)
 351                 return;
 352
 353         struct cipso_mapping *mapping = cipso->first;
 354         struct cipso_mapping *next_mapping = NULL;
 355
 356         while (mapping != NULL) {
 357                 next_mapping = mapping->next;
 358                 free(mapping);
 359                 mapping = next_mapping;
 360         }
 361 }
 362
 363 int smack_cipso_apply(struct smack_cipso *cipso)
 364 {
 365         struct cipso_mapping *m = NULL;
 366         char buf[CIPSO_MAX_SIZE];
 367         int fd;
 368         int i;
 369         char path[PATH_MAX];
 370         int offset=0;
 371
 372         if (!smackfs_mnt)
 373                 return -1;
 374
 375         snprintf(path, sizeof path, "%s/cipso2", smackfs_mnt);
 376         fd = open(path, O_WRONLY);
 377         if (fd < 0)
 378                 return -1;
 379
 380         memset(buf,0,CIPSO_MAX_SIZE);
 381         for (m = cipso->first; m != NULL; m = m->next) {
 382                 snprintf(buf, SMACK_LABEL_LEN + 1, "%s", m->label);
 383                 offset += strlen(buf) + 1;
 384
 385                 sprintf(&buf[offset], CIPSO_NUM_LEN_STR, m->level);
 386                 offset += NUM_LEN;
 387
 388                 sprintf(&buf[offset], CIPSO_NUM_LEN_STR, m->ncats);
 389                 offset += NUM_LEN;
 390
 391                 for (i = 0; i < m->ncats; i++){
 392                         sprintf(&buf[offset], CIPSO_NUM_LEN_STR, m->cats[i]);
 393                         offset += NUM_LEN;
 394                 }
 395
 396                 if (write(fd, buf, offset) < 0) {
 397                         close(fd);
 398                         return -1;
 399                 }
 400         }
 401
 402         close(fd);
 403         return 0;
 404 }
 405
 406 int smack_cipso_add_from_file(struct smack_cipso *cipso, int fd)
 407 {
 408         struct cipso_mapping *mapping = NULL;
 409         FILE *file = NULL;
 410         char buf[BUF_SIZE];
 411         char *label, *level, *cat, *ptr;
 412         long int val;
 413         int i;
 414         int newfd;
 415
 416         newfd = dup(fd);
 417         if (newfd == -1)
 418                 return -1;
 419
 420         file = fdopen(newfd, "r");
 421         if (file == NULL) {
 422                 close(newfd);
 423                 return -1;
 424         }
 425
 426         while (fgets(buf, BUF_SIZE, file) != NULL) {
 427                 mapping = calloc(sizeof(struct cipso_mapping), 1);
 428                 if (mapping == NULL)
 429                         goto err_out;
 430
 431                 label = strtok_r(buf, " \t\n", &ptr);
 432                 level = strtok_r(NULL, " \t\n", &ptr);
 433                 cat = strtok_r(NULL, " \t\n", &ptr);
 434                 if (smack_label_length(label) < 0 || level == NULL)
 435                         goto err_out;
 436
 437                 strncpy(mapping->label, label, SMACK_LABEL_LEN);
 438
 439                 errno = 0;
 440                 val = strtol(level, NULL, 10);
 441                 if (errno)
 442                         goto err_out;
 443
 444                 if (val < 0 || val > LEVEL_MAX)
 445                         goto err_out;
 446
 447                 mapping->level = val;
 448
 449                 for (i = 0; i < CAT_MAX_COUNT && cat != NULL; i++) {
 450                         errno = 0;
 451                         val = strtol(cat, NULL, 10);
 452                         if (errno)
 453                                 goto err_out;
 454
 455                         if (val < 0 || val > CAT_MAX_VALUE)
 456                                 goto err_out;
 457
 458                         mapping->cats[i] = val;
 459
 460                         cat = strtok_r(NULL, " \t\n", &ptr);
 461                 }
 462
 463                 mapping->ncats = i;
 464
 465                 if (cipso->first == NULL) {
 466                         cipso->first = cipso->last = mapping;
 467                 } else {
 468                         cipso->last->next = mapping;
 469                         cipso->last = mapping;
 470                 }
 471         }
 472
 473         if (ferror(file))
 474                 goto err_out;
 475
 476         fclose(file);
 477         return 0;
 478 err_out:
 479         fclose(file);
 480         free(mapping);
 481         return -1;
 482 }
 483
 484 const char *smack_smackfs_path(void)
 485 {
 486         return smackfs_mnt;
 487 }
 488
 489 ssize_t smack_new_label_from_self(char **label)
 490 {
 491         char *result;
 492         int fd;
 493         int ret;
 494
 495         result = calloc(SMACK_LABEL_LEN + 1, 1);
 496         if (result == NULL)
 497                 return -1;
 498
 499         fd = open(SELF_LABEL_FILE, O_RDONLY);
 500         if (fd < 0) {
 501                 free(result);
 502                 return -1;
 503         }
 504
 505         ret = read(fd, result, SMACK_LABEL_LEN);
 506         close(fd);
 507         if (ret < 0) {
 508                 free(result);
 509                 return -1;
 510         }
 511
 512         *label = result;
 513         return ret;
 514 }
 515
 516 ssize_t smack_new_label_from_socket(int fd, char **label)
 517 {
 518         char dummy;
 519         int ret;
 520         socklen_t length = 1;
 521         char *result;
 522
 523         ret = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, &dummy, &length);
 524         if (ret < 0 && errno != ERANGE)
 525                 return -1;
 526
 527         result = calloc(length + 1, 1);
 528         if (result == NULL)
 529                 return -1;
 530
 531         ret = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, result, &length);
 532         if (ret < 0) {
 533                 free(result);
 534                 return -1;
 535         }
 536
 537         *label = result;
 538         return length;
 539 }
 540
 541 ssize_t smack_new_label_from_path(const char *path, const char *xattr,
 542                                   int follow, char **label)
 543 {
 544         char *result;
 545         ssize_t ret = 0;
 546
 547         ret = follow ?
 548                 getxattr(path, xattr, NULL, 0) :
 549                 lgetxattr(path, xattr, NULL, 0);
 550         if (ret < 0 && errno != ERANGE)
 551                 return -1;
 552
 553         result = calloc(ret + 1, 1);
 554         if (result == NULL)
 555                 return -1;
 556
 557         ret = follow ?
 558                 getxattr(path, xattr, result, ret) :
 559                 lgetxattr(path, xattr, result, ret);
 560         if (ret < 0) {
 561                 free(result);
 562                 return -1;
 563         }
 564
 565         *label = result;
 566         return 0;
 567 }
 568
 569 int smack_set_label_for_self(const char *label)
 570 {
 571         int len;
 572         int fd;
 573         int ret;
 574
 575         len = smack_label_length(label);
 576         if (len < 0)
 577                 return -1;
 578
 579         fd = open(SELF_LABEL_FILE, O_WRONLY);
 580         if (fd < 0)
 581                 return -1;
 582
 583         ret = write(fd, label, len);
 584         close(fd);
 585
 586         return (ret < 0) ? -1 : 0;
 587 }
 588
 589 int smack_revoke_subject(const char *subject)
 590 {
 591         int ret;
 592         int fd;
 593         int len;
 594         char path[PATH_MAX];
 595
 596         len = smack_label_length(subject);
 597         if (len < 0)
 598                 return -1;
 599
 600         snprintf(path, sizeof path, "%s/revoke-subject", smackfs_mnt);
 601         fd = open(path, O_WRONLY);
 602         if (fd < 0)
 603                 return -1;
 604
 605         ret = write(fd, subject, len);
 606         close(fd);
 607
 608         return (ret < 0) ? -1 : 0;
 609 }
 610
 611 ssize_t smack_label_length(const char *label)
 612 {
 613         return get_label(NULL, label);
 614 }
 615
 616 static int accesses_apply(struct smack_accesses *handle, int clear)
 617 {
 618         char buf[LOAD_LEN + 1];
 619         struct smack_rule *rule;
 620         int ret;
 621         int fd;
 622         int load_fd;
 623         int change_fd;
 624         int load2 = 1;
 625         char path[PATH_MAX];
 626
 627         if (!smackfs_mnt)
 628                 return -1;
 629
 630         snprintf(path, sizeof path, "%s/load2", smackfs_mnt);
 631         load_fd = open(path, O_WRONLY);
 632         if (load_fd < 0) {
 633                 if (errno != ENOENT)
 634                         return -1;
 635                 /* fallback */
 636                 snprintf(path, sizeof path, "%s/load", smackfs_mnt);
 637                 load_fd = open(path, O_WRONLY);
 638                 /* Try to continue if the file doesn't exist, we might not need it. */
 639                 if (load_fd < 0 && errno != ENOENT)
 640                         return -1;
 641                 load2 = 0;
 642         }
 643
 644         snprintf(path, sizeof path, "%s/change-rule", smackfs_mnt);
 645         change_fd = open(path, O_WRONLY);
 646         /* Try to continue if the file doesn't exist, we might not need it. */
 647         if (change_fd < 0 && errno != ENOENT) {
 648                 ret = -1;
 649                 goto err_out;
 650         }
 651
 652         for (rule = handle->first; rule != NULL; rule = rule->next) {
 653                 if (rule->is_modify && !clear) {
 654                         fd = change_fd;
 655                         ret = snprintf(buf, LOAD_LEN + 1, KERNEL_MODIFY_FORMAT,
 656                                        rule->subject, rule->object,
 657                                        rule->allow_access_type,
 658                                        rule->deny_access_type);
 659                 } else {
 660                         fd = load_fd;
 661                         if (load2)
 662                                 ret = snprintf(buf, LOAD_LEN + 1, KERNEL_LONG_FORMAT,
 663                                                rule->subject, rule->object,
 664                                                clear ? ACC_CLEAR : rule->access_type);
 665                         else
 666                                 ret = snprintf(buf, LOAD_LEN + 1, KERNEL_SHORT_FORMAT,
 667                                                rule->subject, rule->object,
 668                                                clear ? ACC_CLEAR : rule->access_type);
 669                 }
 670
 671                 if (ret < 0 || fd < 0) {
 672                         ret = -1;
 673                         goto err_out;
 674                 }
 675
 676                 ret = write(fd, buf, strlen(buf));
 677                 if (ret < 0) {
 678                         ret = -1;
 679                         goto err_out;
 680                 }
 681         }
 682         ret = 0;
 683
 684 err_out:
 685         if (load_fd >= 0)
 686                 close(load_fd);
 687         if (change_fd >= 0)
 688                 close(change_fd);
 689         return ret;
 690 }
 691
 692 static inline void parse_access_type(const char *in, char out[ACC_LEN + 1])
 693 {
 694         int i;
 695
 696         for (i = 0; i < ACC_LEN; ++i)
 697                 out[i] = '-';
 698         out[ACC_LEN] = '\0';
 699
 700         for (i = 0; in[i] != '\0'; i++)
 701                 switch (in[i]) {
 702                 case 'r':
 703                 case 'R':
 704                         out[0] = 'r';
 705                         break;
 706                 case 'w':
 707                 case 'W':
 708                         out[1] = 'w';
 709                         break;
 710                 case 'x':
 711                 case 'X':
 712                         out[2] = 'x';
 713                         break;
 714                 case 'a':
 715                 case 'A':
 716                         out[3] = 'a';
 717                         break;
 718                 case 't':
 719                 case 'T':
 720                         out[4] = 't';
 721                         break;
 722                 default:
 723                         break;
 724                 }
 725 }
 726
 727 static inline ssize_t get_label(char *dest, const char *src)
 728 {
 729         int i;
 730
 731         if (!src || src[0] == '\0' || src[0] == '-')
 732                 return -1;
 733
 734         for (i = 0; i < (SMACK_LABEL_LEN + 1) && src[i]; i++) {
 735                 switch (src[i]) {
 736                 case ' ':
 737                 case '/':
 738                 case '"':
 739                 case '\\':
 740                 case '\'':
 741                         return -1;
 742                 default:
 743                         break;
 744                 }
 745
 746                 if (dest)
 747                         dest[i] = src[i];
 748         }
 749
 750         if (i < (SMACK_LABEL_LEN + 1))
 751                 dest[i] = '\0';
 752
 753         return i < (SMACK_LABEL_LEN + 1) ? i : -1;
 754 }