security/apparmor/policy_unpack.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * AppArmor security module
   4  *
   5  * This file contains AppArmor functions for unpacking policy loaded from
   6  * userspace.
   7  *
   8  * Copyright (C) 1998-2008 Novell/SUSE
   9  * Copyright 2009-2010 Canonical Ltd.
  10  *
  11  * AppArmor uses a serialized binary format for loading policy. To find
  12  * policy format documentation see Documentation/admin-guide/LSM/apparmor.rst
  13  * All policy is validated before it is used.
  14  */
  15
  16 #include <asm/unaligned.h>
  17 #include <linux/ctype.h>
  18 #include <linux/errno.h>
  19
  20 #include "include/apparmor.h"
  21 #include "include/audit.h"
  22 #include "include/cred.h"
  23 #include "include/crypto.h"
  24 #include "include/match.h"
  25 #include "include/path.h"
  26 #include "include/policy.h"
  27 #include "include/policy_unpack.h"
  28
  29 #define K_ABI_MASK 0x3ff
  30 #define FORCE_COMPLAIN_FLAG 0x800
  31 #define VERSION_LT(X, Y) (((X) & K_ABI_MASK) < ((Y) & K_ABI_MASK))
  32 #define VERSION_GT(X, Y) (((X) & K_ABI_MASK) > ((Y) & K_ABI_MASK))
  33
  34 #define v5      5       /* base version */
  35 #define v6      6       /* per entry policydb mediation check */
  36 #define v7      7
  37 #define v8      8       /* full network masking */
  38
  39 /*
  40  * The AppArmor interface treats data as a type byte followed by the
  41  * actual data.  The interface has the notion of a a named entry
  42  * which has a name (AA_NAME typecode followed by name string) followed by
  43  * the entries typecode and data.  Named types allow for optional
  44  * elements and extensions to be added and tested for without breaking
  45  * backwards compatibility.
  46  */
  47
  48 enum aa_code {
  49         AA_U8,
  50         AA_U16,
  51         AA_U32,
  52         AA_U64,
  53         AA_NAME,                /* same as string except it is items name */
  54         AA_STRING,
  55         AA_BLOB,
  56         AA_STRUCT,
  57         AA_STRUCTEND,
  58         AA_LIST,
  59         AA_LISTEND,
  60         AA_ARRAY,
  61         AA_ARRAYEND,
  62 };
  63
  64 /*
  65  * aa_ext is the read of the buffer containing the serialized profile.  The
  66  * data is copied into a kernel buffer in apparmorfs and then handed off to
  67  * the unpack routines.
  68  */
  69 struct aa_ext {
  70         void *start;
  71         void *end;
  72         void *pos;              /* pointer to current position in the buffer */
  73         u32 version;
  74 };
  75
  76 /* audit callback for unpack fields */
  77 static void audit_cb(struct audit_buffer *ab, void *va)
  78 {
  79         struct common_audit_data *sa = va;
  80
  81         if (aad(sa)->iface.ns) {
  82                 audit_log_format(ab, " ns=");
  83                 audit_log_untrustedstring(ab, aad(sa)->iface.ns);
  84         }
  85         if (aad(sa)->name) {
  86                 audit_log_format(ab, " name=");
  87                 audit_log_untrustedstring(ab, aad(sa)->name);
  88         }
  89         if (aad(sa)->iface.pos)
  90                 audit_log_format(ab, " offset=%ld", aad(sa)->iface.pos);
  91 }
  92
  93 /**
  94  * audit_iface - do audit message for policy unpacking/load/replace/remove
  95  * @new: profile if it has been allocated (MAYBE NULL)
  96  * @ns_name: name of the ns the profile is to be loaded to (MAY BE NULL)
  97  * @name: name of the profile being manipulated (MAYBE NULL)
  98  * @info: any extra info about the failure (MAYBE NULL)
  99  * @e: buffer position info
 100  * @error: error code
 101  *
 102  * Returns: %0 or error
 103  */
 104 static int audit_iface(struct aa_profile *new, const char *ns_name,
 105                        const char *name, const char *info, struct aa_ext *e,
 106                        int error)
 107 {
 108         struct aa_profile *profile = labels_profile(aa_current_raw_label());
 109         DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_NONE, NULL);
 110         if (e)
 111                 aad(&sa)->iface.pos = e->pos - e->start;
 112         aad(&sa)->iface.ns = ns_name;
 113         if (new)
 114                 aad(&sa)->name = new->base.hname;
 115         else
 116                 aad(&sa)->name = name;
 117         aad(&sa)->info = info;
 118         aad(&sa)->error = error;
 119
 120         return aa_audit(AUDIT_APPARMOR_STATUS, profile, &sa, audit_cb);
 121 }
 122
 123 void __aa_loaddata_update(struct aa_loaddata *data, long revision)
 124 {
 125         AA_BUG(!data);
 126         AA_BUG(!data->ns);
 127         AA_BUG(!data->dents[AAFS_LOADDATA_REVISION]);
 128         AA_BUG(!mutex_is_locked(&data->ns->lock));
 129         AA_BUG(data->revision > revision);
 130
 131         data->revision = revision;
 132         d_inode(data->dents[AAFS_LOADDATA_DIR])->i_mtime =
 133                 current_time(d_inode(data->dents[AAFS_LOADDATA_DIR]));
 134         d_inode(data->dents[AAFS_LOADDATA_REVISION])->i_mtime =
 135                 current_time(d_inode(data->dents[AAFS_LOADDATA_REVISION]));
 136 }
 137
 138 bool aa_rawdata_eq(struct aa_loaddata *l, struct aa_loaddata *r)
 139 {
 140         if (l->size != r->size)
 141                 return false;
 142         if (aa_g_hash_policy && memcmp(l->hash, r->hash, aa_hash_size()) != 0)
 143                 return false;
 144         return memcmp(l->data, r->data, r->size) == 0;
 145 }
 146
 147 /*
 148  * need to take the ns mutex lock which is NOT safe most places that
 149  * put_loaddata is called, so we have to delay freeing it
 150  */
 151 static void do_loaddata_free(struct work_struct *work)
 152 {
 153         struct aa_loaddata *d = container_of(work, struct aa_loaddata, work);
 154         struct aa_ns *ns = aa_get_ns(d->ns);
 155
 156         if (ns) {
 157                 mutex_lock_nested(&ns->lock, ns->level);
 158                 __aa_fs_remove_rawdata(d);
 159                 mutex_unlock(&ns->lock);
 160                 aa_put_ns(ns);
 161         }
 162
 163         kzfree(d->hash);
 164         kzfree(d->name);
 165         kvfree(d->data);
 166         kzfree(d);
 167 }
 168
 169 void aa_loaddata_kref(struct kref *kref)
 170 {
 171         struct aa_loaddata *d = container_of(kref, struct aa_loaddata, count);
 172
 173         if (d) {
 174                 INIT_WORK(&d->work, do_loaddata_free);
 175                 schedule_work(&d->work);
 176         }
 177 }
 178
 179 struct aa_loaddata *aa_loaddata_alloc(size_t size)
 180 {
 181         struct aa_loaddata *d;
 182
 183         d = kzalloc(sizeof(*d), GFP_KERNEL);
 184         if (d == NULL)
 185                 return ERR_PTR(-ENOMEM);
 186         d->data = kvzalloc(size, GFP_KERNEL);
 187         if (!d->data) {
 188                 kfree(d);
 189                 return ERR_PTR(-ENOMEM);
 190         }
 191         kref_init(&d->count);
 192         INIT_LIST_HEAD(&d->list);
 193
 194         return d;
 195 }
 196
 197 /* test if read will be in packed data bounds */
 198 static bool inbounds(struct aa_ext *e, size_t size)
 199 {
 200         return (size <= e->end - e->pos);
 201 }
 202
 203 static void *kvmemdup(const void *src, size_t len)
 204 {
 205         void *p = kvmalloc(len, GFP_KERNEL);
 206
 207         if (p)
 208                 memcpy(p, src, len);
 209         return p;
 210 }
 211
 212 /**
 213  * aa_u16_chunck - test and do bounds checking for a u16 size based chunk
 214  * @e: serialized data read head (NOT NULL)
 215  * @chunk: start address for chunk of data (NOT NULL)
 216  *
 217  * Returns: the size of chunk found with the read head at the end of the chunk.
 218  */
 219 static size_t unpack_u16_chunk(struct aa_ext *e, char **chunk)
 220 {
 221         size_t size = 0;
 222
 223         if (!inbounds(e, sizeof(u16)))
 224                 return 0;
 225         size = le16_to_cpu(get_unaligned((__le16 *) e->pos));
 226         e->pos += sizeof(__le16);
 227         if (!inbounds(e, size))
 228                 return 0;
 229         *chunk = e->pos;
 230         e->pos += size;
 231         return size;
 232 }
 233
 234 /* unpack control byte */
 235 static bool unpack_X(struct aa_ext *e, enum aa_code code)
 236 {
 237         if (!inbounds(e, 1))
 238                 return 0;
 239         if (*(u8 *) e->pos != code)
 240                 return 0;
 241         e->pos++;
 242         return 1;
 243 }
 244
 245 /**
 246  * unpack_nameX - check is the next element is of type X with a name of @name
 247  * @e: serialized data extent information  (NOT NULL)
 248  * @code: type code
 249  * @name: name to match to the serialized element.  (MAYBE NULL)
 250  *
 251  * check that the next serialized data element is of type X and has a tag
 252  * name @name.  If @name is specified then there must be a matching
 253  * name element in the stream.  If @name is NULL any name element will be
 254  * skipped and only the typecode will be tested.
 255  *
 256  * Returns 1 on success (both type code and name tests match) and the read
 257  * head is advanced past the headers
 258  *
 259  * Returns: 0 if either match fails, the read head does not move
 260  */
 261 static bool unpack_nameX(struct aa_ext *e, enum aa_code code, const char *name)
 262 {
 263         /*
 264          * May need to reset pos if name or type doesn't match
 265          */
 266         void *pos = e->pos;
 267         /*
 268          * Check for presence of a tagname, and if present name size
 269          * AA_NAME tag value is a u16.
 270          */
 271         if (unpack_X(e, AA_NAME)) {
 272                 char *tag = NULL;
 273                 size_t size = unpack_u16_chunk(e, &tag);
 274                 /* if a name is specified it must match. otherwise skip tag */
 275                 if (name && (!size || strcmp(name, tag)))
 276                         goto fail;
 277         } else if (name) {
 278                 /* if a name is specified and there is no name tag fail */
 279                 goto fail;
 280         }
 281
 282         /* now check if type code matches */
 283         if (unpack_X(e, code))
 284                 return 1;
 285
 286 fail:
 287         e->pos = pos;
 288         return 0;
 289 }
 290
 291 static bool unpack_u8(struct aa_ext *e, u8 *data, const char *name)
 292 {
 293         if (unpack_nameX(e, AA_U8, name)) {
 294                 if (!inbounds(e, sizeof(u8)))
 295                         return 0;
 296                 if (data)
 297                         *data = get_unaligned((u8 *)e->pos);
 298                 e->pos += sizeof(u8);
 299                 return 1;
 300         }
 301         return 0;
 302 }
 303
 304 static bool unpack_u32(struct aa_ext *e, u32 *data, const char *name)
 305 {
 306         if (unpack_nameX(e, AA_U32, name)) {
 307                 if (!inbounds(e, sizeof(u32)))
 308                         return 0;
 309                 if (data)
 310                         *data = le32_to_cpu(get_unaligned((__le32 *) e->pos));
 311                 e->pos += sizeof(u32);
 312                 return 1;
 313         }
 314         return 0;
 315 }
 316
 317 static bool unpack_u64(struct aa_ext *e, u64 *data, const char *name)
 318 {
 319         if (unpack_nameX(e, AA_U64, name)) {
 320                 if (!inbounds(e, sizeof(u64)))
 321                         return 0;
 322                 if (data)
 323                         *data = le64_to_cpu(get_unaligned((__le64 *) e->pos));
 324                 e->pos += sizeof(u64);
 325                 return 1;
 326         }
 327         return 0;
 328 }
 329
 330 static size_t unpack_array(struct aa_ext *e, const char *name)
 331 {
 332         if (unpack_nameX(e, AA_ARRAY, name)) {
 333                 int size;
 334                 if (!inbounds(e, sizeof(u16)))
 335                         return 0;
 336                 size = (int)le16_to_cpu(get_unaligned((__le16 *) e->pos));
 337                 e->pos += sizeof(u16);
 338                 return size;
 339         }
 340         return 0;
 341 }
 342
 343 static size_t unpack_blob(struct aa_ext *e, char **blob, const char *name)
 344 {
 345         if (unpack_nameX(e, AA_BLOB, name)) {
 346                 u32 size;
 347                 if (!inbounds(e, sizeof(u32)))
 348                         return 0;
 349                 size = le32_to_cpu(get_unaligned((__le32 *) e->pos));
 350                 e->pos += sizeof(u32);
 351                 if (inbounds(e, (size_t) size)) {
 352                         *blob = e->pos;
 353                         e->pos += size;
 354                         return size;
 355                 }
 356         }
 357         return 0;
 358 }
 359
 360 static int unpack_str(struct aa_ext *e, const char **string, const char *name)
 361 {
 362         char *src_str;
 363         size_t size = 0;
 364         void *pos = e->pos;
 365         *string = NULL;
 366         if (unpack_nameX(e, AA_STRING, name)) {
 367                 size = unpack_u16_chunk(e, &src_str);
 368                 if (size) {
 369                         /* strings are null terminated, length is size - 1 */
 370                         if (src_str[size - 1] != 0)
 371                                 goto fail;
 372                         *string = src_str;
 373                 }
 374         }
 375         return size;
 376
 377 fail:
 378         e->pos = pos;
 379         return 0;
 380 }
 381
 382 static int unpack_strdup(struct aa_ext *e, char **string, const char *name)
 383 {
 384         const char *tmp;
 385         void *pos = e->pos;
 386         int res = unpack_str(e, &tmp, name);
 387         *string = NULL;
 388
 389         if (!res)
 390                 return 0;
 391
 392         *string = kmemdup(tmp, res, GFP_KERNEL);
 393         if (!*string) {
 394                 e->pos = pos;
 395                 return 0;
 396         }
 397
 398         return res;
 399 }
 400
 401
 402 /**
 403  * unpack_dfa - unpack a file rule dfa
 404  * @e: serialized data extent information (NOT NULL)
 405  *
 406  * returns dfa or ERR_PTR or NULL if no dfa
 407  */
 408 static struct aa_dfa *unpack_dfa(struct aa_ext *e)
 409 {
 410         char *blob = NULL;
 411         size_t size;
 412         struct aa_dfa *dfa = NULL;
 413
 414         size = unpack_blob(e, &blob, "aadfa");
 415         if (size) {
 416                 /*
 417                  * The dfa is aligned with in the blob to 8 bytes
 418                  * from the beginning of the stream.
 419                  * alignment adjust needed by dfa unpack
 420                  */
 421                 size_t sz = blob - (char *) e->start -
 422                         ((e->pos - e->start) & 7);
 423                 size_t pad = ALIGN(sz, 8) - sz;
 424                 int flags = TO_ACCEPT1_FLAG(YYTD_DATA32) |
 425                         TO_ACCEPT2_FLAG(YYTD_DATA32) | DFA_FLAG_VERIFY_STATES;
 426                 dfa = aa_dfa_unpack(blob + pad, size - pad, flags);
 427
 428                 if (IS_ERR(dfa))
 429                         return dfa;
 430
 431         }
 432
 433         return dfa;
 434 }
 435
 436 /**
 437  * unpack_trans_table - unpack a profile transition table
 438  * @e: serialized data extent information  (NOT NULL)
 439  * @profile: profile to add the accept table to (NOT NULL)
 440  *
 441  * Returns: 1 if table successfully unpacked
 442  */
 443 static bool unpack_trans_table(struct aa_ext *e, struct aa_profile *profile)
 444 {
 445         void *saved_pos = e->pos;
 446
 447         /* exec table is optional */
 448         if (unpack_nameX(e, AA_STRUCT, "xtable")) {
 449                 int i, size;
 450
 451                 size = unpack_array(e, NULL);
 452                 /* currently 4 exec bits and entries 0-3 are reserved iupcx */
 453                 if (size > 16 - 4)
 454                         goto fail;
 455                 profile->file.trans.table = kcalloc(size, sizeof(char *),
 456                                                     GFP_KERNEL);
 457                 if (!profile->file.trans.table)
 458                         goto fail;
 459
 460                 profile->file.trans.size = size;
 461                 for (i = 0; i < size; i++) {
 462                         char *str;
 463                         int c, j, pos, size2 = unpack_strdup(e, &str, NULL);
 464                         /* unpack_strdup verifies that the last character is
 465                          * null termination byte.
 466                          */
 467                         if (!size2)
 468                                 goto fail;
 469                         profile->file.trans.table[i] = str;
 470                         /* verify that name doesn't start with space */
 471                         if (isspace(*str))
 472                                 goto fail;
 473
 474                         /* count internal #  of internal \0 */
 475                         for (c = j = 0; j < size2 - 1; j++) {
 476                                 if (!str[j]) {
 477                                         pos = j;
 478                                         c++;
 479                                 }
 480                         }
 481                         if (*str == ':') {
 482                                 /* first character after : must be valid */
 483                                 if (!str[1])
 484                                         goto fail;
 485                                 /* beginning with : requires an embedded \0,
 486                                  * verify that exactly 1 internal \0 exists
 487                                  * trailing \0 already verified by unpack_strdup
 488                                  *
 489                                  * convert \0 back to : for label_parse
 490                                  */
 491                                 if (c == 1)
 492                                         str[pos] = ':';
 493                                 else if (c > 1)
 494                                         goto fail;
 495                         } else if (c)
 496                                 /* fail - all other cases with embedded \0 */
 497                                 goto fail;
 498                 }
 499                 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
 500                         goto fail;
 501                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 502                         goto fail;
 503         }
 504         return 1;
 505
 506 fail:
 507         aa_free_domain_entries(&profile->file.trans);
 508         e->pos = saved_pos;
 509         return 0;
 510 }
 511
 512 static bool unpack_xattrs(struct aa_ext *e, struct aa_profile *profile)
 513 {
 514         void *pos = e->pos;
 515
 516         if (unpack_nameX(e, AA_STRUCT, "xattrs")) {
 517                 int i, size;
 518
 519                 size = unpack_array(e, NULL);
 520                 profile->xattr_count = size;
 521                 profile->xattrs = kcalloc(size, sizeof(char *), GFP_KERNEL);
 522                 if (!profile->xattrs)
 523                         goto fail;
 524                 for (i = 0; i < size; i++) {
 525                         if (!unpack_strdup(e, &profile->xattrs[i], NULL))
 526                                 goto fail;
 527                 }
 528                 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
 529                         goto fail;
 530                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 531                         goto fail;
 532         }
 533
 534         return 1;
 535
 536 fail:
 537         e->pos = pos;
 538         return 0;
 539 }
 540
 541 static bool unpack_secmark(struct aa_ext *e, struct aa_profile *profile)
 542 {
 543         void *pos = e->pos;
 544         int i, size;
 545
 546         if (unpack_nameX(e, AA_STRUCT, "secmark")) {
 547                 size = unpack_array(e, NULL);
 548
 549                 profile->secmark = kcalloc(size, sizeof(struct aa_secmark),
 550                                            GFP_KERNEL);
 551                 if (!profile->secmark)
 552                         goto fail;
 553
 554                 profile->secmark_count = size;
 555
 556                 for (i = 0; i < size; i++) {
 557                         if (!unpack_u8(e, &profile->secmark[i].audit, NULL))
 558                                 goto fail;
 559                         if (!unpack_u8(e, &profile->secmark[i].deny, NULL))
 560                                 goto fail;
 561                         if (!unpack_strdup(e, &profile->secmark[i].label, NULL))
 562                                 goto fail;
 563                 }
 564                 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
 565                         goto fail;
 566                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 567                         goto fail;
 568         }
 569
 570         return 1;
 571
 572 fail:
 573         if (profile->secmark) {
 574                 for (i = 0; i < size; i++)
 575                         kfree(profile->secmark[i].label);
 576                 kfree(profile->secmark);
 577                 profile->secmark_count = 0;
 578                 profile->secmark = NULL;
 579         }
 580
 581         e->pos = pos;
 582         return 0;
 583 }
 584
 585 static bool unpack_rlimits(struct aa_ext *e, struct aa_profile *profile)
 586 {
 587         void *pos = e->pos;
 588
 589         /* rlimits are optional */
 590         if (unpack_nameX(e, AA_STRUCT, "rlimits")) {
 591                 int i, size;
 592                 u32 tmp = 0;
 593                 if (!unpack_u32(e, &tmp, NULL))
 594                         goto fail;
 595                 profile->rlimits.mask = tmp;
 596
 597                 size = unpack_array(e, NULL);
 598                 if (size > RLIM_NLIMITS)
 599                         goto fail;
 600                 for (i = 0; i < size; i++) {
 601                         u64 tmp2 = 0;
 602                         int a = aa_map_resource(i);
 603                         if (!unpack_u64(e, &tmp2, NULL))
 604                                 goto fail;
 605                         profile->rlimits.limits[a].rlim_max = tmp2;
 606                 }
 607                 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
 608                         goto fail;
 609                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 610                         goto fail;
 611         }
 612         return 1;
 613
 614 fail:
 615         e->pos = pos;
 616         return 0;
 617 }
 618
 619 static u32 strhash(const void *data, u32 len, u32 seed)
 620 {
 621         const char * const *key = data;
 622
 623         return jhash(*key, strlen(*key), seed);
 624 }
 625
 626 static int datacmp(struct rhashtable_compare_arg *arg, const void *obj)
 627 {
 628         const struct aa_data *data = obj;
 629         const char * const *key = arg->key;
 630
 631         return strcmp(data->key, *key);
 632 }
 633
 634 /**
 635  * unpack_profile - unpack a serialized profile
 636  * @e: serialized data extent information (NOT NULL)
 637  *
 638  * NOTE: unpack profile sets audit struct if there is a failure
 639  */
 640 static struct aa_profile *unpack_profile(struct aa_ext *e, char **ns_name)
 641 {
 642         struct aa_profile *profile = NULL;
 643         const char *tmpname, *tmpns = NULL, *name = NULL;
 644         const char *info = "failed to unpack profile";
 645         size_t ns_len;
 646         struct rhashtable_params params = { 0 };
 647         char *key = NULL;
 648         struct aa_data *data;
 649         int i, error = -EPROTO;
 650         kernel_cap_t tmpcap;
 651         u32 tmp;
 652
 653         *ns_name = NULL;
 654
 655         /* check that we have the right struct being passed */
 656         if (!unpack_nameX(e, AA_STRUCT, "profile"))
 657                 goto fail;
 658         if (!unpack_str(e, &name, NULL))
 659                 goto fail;
 660         if (*name == '\0')
 661                 goto fail;
 662
 663         tmpname = aa_splitn_fqname(name, strlen(name), &tmpns, &ns_len);
 664         if (tmpns) {
 665                 *ns_name = kstrndup(tmpns, ns_len, GFP_KERNEL);
 666                 if (!*ns_name) {
 667                         info = "out of memory";
 668                         goto fail;
 669                 }
 670                 name = tmpname;
 671         }
 672
 673         profile = aa_alloc_profile(name, NULL, GFP_KERNEL);
 674         if (!profile)
 675                 return ERR_PTR(-ENOMEM);
 676
 677         /* profile renaming is optional */
 678         (void) unpack_str(e, &profile->rename, "rename");
 679
 680         /* attachment string is optional */
 681         (void) unpack_str(e, &profile->attach, "attach");
 682
 683         /* xmatch is optional and may be NULL */
 684         profile->xmatch = unpack_dfa(e);
 685         if (IS_ERR(profile->xmatch)) {
 686                 error = PTR_ERR(profile->xmatch);
 687                 profile->xmatch = NULL;
 688                 info = "bad xmatch";
 689                 goto fail;
 690         }
 691         /* xmatch_len is not optional if xmatch is set */
 692         if (profile->xmatch) {
 693                 if (!unpack_u32(e, &tmp, NULL)) {
 694                         info = "missing xmatch len";
 695                         goto fail;
 696                 }
 697                 profile->xmatch_len = tmp;
 698         }
 699
 700         /* disconnected attachment string is optional */
 701         (void) unpack_str(e, &profile->disconnected, "disconnected");
 702
 703         /* per profile debug flags (complain, audit) */
 704         if (!unpack_nameX(e, AA_STRUCT, "flags")) {
 705                 info = "profile missing flags";
 706                 goto fail;
 707         }
 708         info = "failed to unpack profile flags";
 709         if (!unpack_u32(e, &tmp, NULL))
 710                 goto fail;
 711         if (tmp & PACKED_FLAG_HAT)
 712                 profile->label.flags |= FLAG_HAT;
 713         if (!unpack_u32(e, &tmp, NULL))
 714                 goto fail;
 715         if (tmp == PACKED_MODE_COMPLAIN || (e->version & FORCE_COMPLAIN_FLAG))
 716                 profile->mode = APPARMOR_COMPLAIN;
 717         else if (tmp == PACKED_MODE_KILL)
 718                 profile->mode = APPARMOR_KILL;
 719         else if (tmp == PACKED_MODE_UNCONFINED)
 720                 profile->mode = APPARMOR_UNCONFINED;
 721         if (!unpack_u32(e, &tmp, NULL))
 722                 goto fail;
 723         if (tmp)
 724                 profile->audit = AUDIT_ALL;
 725
 726         if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 727                 goto fail;
 728
 729         /* path_flags is optional */
 730         if (unpack_u32(e, &profile->path_flags, "path_flags"))
 731                 profile->path_flags |= profile->label.flags &
 732                         PATH_MEDIATE_DELETED;
 733         else
 734                 /* set a default value if path_flags field is not present */
 735                 profile->path_flags = PATH_MEDIATE_DELETED;
 736
 737         info = "failed to unpack profile capabilities";
 738         if (!unpack_u32(e, &(profile->caps.allow.cap[0]), NULL))
 739                 goto fail;
 740         if (!unpack_u32(e, &(profile->caps.audit.cap[0]), NULL))
 741                 goto fail;
 742         if (!unpack_u32(e, &(profile->caps.quiet.cap[0]), NULL))
 743                 goto fail;
 744         if (!unpack_u32(e, &tmpcap.cap[0], NULL))
 745                 goto fail;
 746
 747         info = "failed to unpack upper profile capabilities";
 748         if (unpack_nameX(e, AA_STRUCT, "caps64")) {
 749                 /* optional upper half of 64 bit caps */
 750                 if (!unpack_u32(e, &(profile->caps.allow.cap[1]), NULL))
 751                         goto fail;
 752                 if (!unpack_u32(e, &(profile->caps.audit.cap[1]), NULL))
 753                         goto fail;
 754                 if (!unpack_u32(e, &(profile->caps.quiet.cap[1]), NULL))
 755                         goto fail;
 756                 if (!unpack_u32(e, &(tmpcap.cap[1]), NULL))
 757                         goto fail;
 758                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 759                         goto fail;
 760         }
 761
 762         info = "failed to unpack extended profile capabilities";
 763         if (unpack_nameX(e, AA_STRUCT, "capsx")) {
 764                 /* optional extended caps mediation mask */
 765                 if (!unpack_u32(e, &(profile->caps.extended.cap[0]), NULL))
 766                         goto fail;
 767                 if (!unpack_u32(e, &(profile->caps.extended.cap[1]), NULL))
 768                         goto fail;
 769                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 770                         goto fail;
 771         }
 772
 773         if (!unpack_xattrs(e, profile)) {
 774                 info = "failed to unpack profile xattrs";
 775                 goto fail;
 776         }
 777
 778         if (!unpack_rlimits(e, profile)) {
 779                 info = "failed to unpack profile rlimits";
 780                 goto fail;
 781         }
 782
 783         if (!unpack_secmark(e, profile)) {
 784                 info = "failed to unpack profile secmark rules";
 785                 goto fail;
 786         }
 787
 788         if (unpack_nameX(e, AA_STRUCT, "policydb")) {
 789                 /* generic policy dfa - optional and may be NULL */
 790                 info = "failed to unpack policydb";
 791                 profile->policy.dfa = unpack_dfa(e);
 792                 if (IS_ERR(profile->policy.dfa)) {
 793                         error = PTR_ERR(profile->policy.dfa);
 794                         profile->policy.dfa = NULL;
 795                         goto fail;
 796                 } else if (!profile->policy.dfa) {
 797                         error = -EPROTO;
 798                         goto fail;
 799                 }
 800                 if (!unpack_u32(e, &profile->policy.start[0], "start"))
 801                         /* default start state */
 802                         profile->policy.start[0] = DFA_START;
 803                 /* setup class index */
 804                 for (i = AA_CLASS_FILE; i <= AA_CLASS_LAST; i++) {
 805                         profile->policy.start[i] =
 806                                 aa_dfa_next(profile->policy.dfa,
 807                                             profile->policy.start[0],
 808                                             i);
 809                 }
 810                 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
 811                         goto fail;
 812         } else
 813                 profile->policy.dfa = aa_get_dfa(nulldfa);
 814
 815         /* get file rules */
 816         profile->file.dfa = unpack_dfa(e);
 817         if (IS_ERR(profile->file.dfa)) {
 818                 error = PTR_ERR(profile->file.dfa);
 819                 profile->file.dfa = NULL;
 820                 info = "failed to unpack profile file rules";
 821                 goto fail;
 822         } else if (profile->file.dfa) {
 823                 if (!unpack_u32(e, &profile->file.start, "dfa_start"))
 824                         /* default start state */
 825                         profile->file.start = DFA_START;
 826         } else if (profile->policy.dfa &&
 827                    profile->policy.start[AA_CLASS_FILE]) {
 828                 profile->file.dfa = aa_get_dfa(profile->policy.dfa);
 829                 profile->file.start = profile->policy.start[AA_CLASS_FILE];
 830         } else
 831                 profile->file.dfa = aa_get_dfa(nulldfa);
 832
 833         if (!unpack_trans_table(e, profile)) {
 834                 info = "failed to unpack profile transition table";
 835                 goto fail;
 836         }
 837
 838         if (unpack_nameX(e, AA_STRUCT, "data")) {
 839                 info = "out of memory";
 840                 profile->data = kzalloc(sizeof(*profile->data), GFP_KERNEL);
 841                 if (!profile->data)
 842                         goto fail;
 843
 844                 params.nelem_hint = 3;
 845                 params.key_len = sizeof(void *);
 846                 params.key_offset = offsetof(struct aa_data, key);
 847                 params.head_offset = offsetof(struct aa_data, head);
 848                 params.hashfn = strhash;
 849                 params.obj_cmpfn = datacmp;
 850
 851                 if (rhashtable_init(profile->data, &params)) {
 852                         info = "failed to init key, value hash table";
 853                         goto fail;
 854                 }
 855
 856                 while (unpack_strdup(e, &key, NULL)) {
 857                         data = kzalloc(sizeof(*data), GFP_KERNEL);
 858                         if (!data) {
 859                                 kzfree(key);
 860                                 goto fail;
 861                         }
 862
 863                         data->key = key;
 864                         data->size = unpack_blob(e, &data->data, NULL);
 865                         data->data = kvmemdup(data->data, data->size);
 866                         if (data->size && !data->data) {
 867                                 kzfree(data->key);
 868                                 kzfree(data);
 869                                 goto fail;
 870                         }
 871
 872                         rhashtable_insert_fast(profile->data, &data->head,
 873                                                profile->data->p);
 874                 }
 875
 876                 if (!unpack_nameX(e, AA_STRUCTEND, NULL)) {
 877                         info = "failed to unpack end of key, value data table";
 878                         goto fail;
 879                 }
 880         }
 881
 882         if (!unpack_nameX(e, AA_STRUCTEND, NULL)) {
 883                 info = "failed to unpack end of profile";
 884                 goto fail;
 885         }
 886
 887         return profile;
 888
 889 fail:
 890         if (profile)
 891                 name = NULL;
 892         else if (!name)
 893                 name = "unknown";
 894         audit_iface(profile, NULL, name, info, e, error);
 895         aa_free_profile(profile);
 896
 897         return ERR_PTR(error);
 898 }
 899
 900 /**
 901  * verify_head - unpack serialized stream header
 902  * @e: serialized data read head (NOT NULL)
 903  * @required: whether the header is required or optional
 904  * @ns: Returns - namespace if one is specified else NULL (NOT NULL)
 905  *
 906  * Returns: error or 0 if header is good
 907  */
 908 static int verify_header(struct aa_ext *e, int required, const char **ns)
 909 {
 910         int error = -EPROTONOSUPPORT;
 911         const char *name = NULL;
 912         *ns = NULL;
 913
 914         /* get the interface version */
 915         if (!unpack_u32(e, &e->version, "version")) {
 916                 if (required) {
 917                         audit_iface(NULL, NULL, NULL, "invalid profile format",
 918                                     e, error);
 919                         return error;
 920                 }
 921         }
 922
 923         /* Check that the interface version is currently supported.
 924          * if not specified use previous version
 925          * Mask off everything that is not kernel abi version
 926          */
 927         if (VERSION_LT(e->version, v5) || VERSION_GT(e->version, v7)) {
 928                 audit_iface(NULL, NULL, NULL, "unsupported interface version",
 929                             e, error);
 930                 return error;
 931         }
 932
 933         /* read the namespace if present */
 934         if (unpack_str(e, &name, "namespace")) {
 935                 if (*name == '\0') {
 936                         audit_iface(NULL, NULL, NULL, "invalid namespace name",
 937                                     e, error);
 938                         return error;
 939                 }
 940                 if (*ns && strcmp(*ns, name))
 941                         audit_iface(NULL, NULL, NULL, "invalid ns change", e,
 942                                     error);
 943                 else if (!*ns)
 944                         *ns = name;
 945         }
 946
 947         return 0;
 948 }
 949
 950 static bool verify_xindex(int xindex, int table_size)
 951 {
 952         int index, xtype;
 953         xtype = xindex & AA_X_TYPE_MASK;
 954         index = xindex & AA_X_INDEX_MASK;
 955         if (xtype == AA_X_TABLE && index >= table_size)
 956                 return 0;
 957         return 1;
 958 }
 959
 960 /* verify dfa xindexes are in range of transition tables */
 961 static bool verify_dfa_xindex(struct aa_dfa *dfa, int table_size)
 962 {
 963         int i;
 964         for (i = 0; i < dfa->tables[YYTD_ID_ACCEPT]->td_lolen; i++) {
 965                 if (!verify_xindex(dfa_user_xindex(dfa, i), table_size))
 966                         return 0;
 967                 if (!verify_xindex(dfa_other_xindex(dfa, i), table_size))
 968                         return 0;
 969         }
 970         return 1;
 971 }
 972
 973 /**
 974  * verify_profile - Do post unpack analysis to verify profile consistency
 975  * @profile: profile to verify (NOT NULL)
 976  *
 977  * Returns: 0 if passes verification else error
 978  */
 979 static int verify_profile(struct aa_profile *profile)
 980 {
 981         if (profile->file.dfa &&
 982             !verify_dfa_xindex(profile->file.dfa,
 983                                profile->file.trans.size)) {
 984                 audit_iface(profile, NULL, NULL, "Invalid named transition",
 985                             NULL, -EPROTO);
 986                 return -EPROTO;
 987         }
 988
 989         return 0;
 990 }
 991
 992 void aa_load_ent_free(struct aa_load_ent *ent)
 993 {
 994         if (ent) {
 995                 aa_put_profile(ent->rename);
 996                 aa_put_profile(ent->old);
 997                 aa_put_profile(ent->new);
 998                 kfree(ent->ns_name);
 999                 kzfree(ent);
1000         }
1001 }
1002
1003 struct aa_load_ent *aa_load_ent_alloc(void)
1004 {
1005         struct aa_load_ent *ent = kzalloc(sizeof(*ent), GFP_KERNEL);
1006         if (ent)
1007                 INIT_LIST_HEAD(&ent->list);
1008         return ent;
1009 }
1010
1011 /**
1012  * aa_unpack - unpack packed binary profile(s) data loaded from user space
1013  * @udata: user data copied to kmem  (NOT NULL)
1014  * @lh: list to place unpacked profiles in a aa_repl_ws
1015  * @ns: Returns namespace profile is in if specified else NULL (NOT NULL)
1016  *
1017  * Unpack user data and return refcounted allocated profile(s) stored in
1018  * @lh in order of discovery, with the list chain stored in base.list
1019  * or error
1020  *
1021  * Returns: profile(s) on @lh else error pointer if fails to unpack
1022  */
1023 int aa_unpack(struct aa_loaddata *udata, struct list_head *lh,
1024               const char **ns)
1025 {
1026         struct aa_load_ent *tmp, *ent;
1027         struct aa_profile *profile = NULL;
1028         int error;
1029         struct aa_ext e = {
1030                 .start = udata->data,
1031                 .end = udata->data + udata->size,
1032                 .pos = udata->data,
1033         };
1034
1035         *ns = NULL;
1036         while (e.pos < e.end) {
1037                 char *ns_name = NULL;
1038                 void *start;
1039                 error = verify_header(&e, e.pos == e.start, ns);
1040                 if (error)
1041                         goto fail;
1042
1043                 start = e.pos;
1044                 profile = unpack_profile(&e, &ns_name);
1045                 if (IS_ERR(profile)) {
1046                         error = PTR_ERR(profile);
1047                         goto fail;
1048                 }
1049
1050                 error = verify_profile(profile);
1051                 if (error)
1052                         goto fail_profile;
1053
1054                 if (aa_g_hash_policy)
1055                         error = aa_calc_profile_hash(profile, e.version, start,
1056                                                      e.pos - start);
1057                 if (error)
1058                         goto fail_profile;
1059
1060                 ent = aa_load_ent_alloc();
1061                 if (!ent) {
1062                         error = -ENOMEM;
1063                         goto fail_profile;
1064                 }
1065
1066                 ent->new = profile;
1067                 ent->ns_name = ns_name;
1068                 list_add_tail(&ent->list, lh);
1069         }
1070         udata->abi = e.version & K_ABI_MASK;
1071         if (aa_g_hash_policy) {
1072                 udata->hash = aa_calc_hash(udata->data, udata->size);
1073                 if (IS_ERR(udata->hash)) {
1074                         error = PTR_ERR(udata->hash);
1075                         udata->hash = NULL;
1076                         goto fail;
1077                 }
1078         }
1079         return 0;
1080
1081 fail_profile:
1082         aa_put_profile(profile);
1083
1084 fail:
1085         list_for_each_entry_safe(ent, tmp, lh, list) {
1086                 list_del_init(&ent->list);
1087                 aa_load_ent_free(ent);
1088         }
1089
1090         return error;
1091 }