security/smack/smack.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
   4  *
   5  * Author:
   6  *      Casey Schaufler <casey@schaufler-ca.com>
   7  */
   8
   9 #ifndef _SECURITY_SMACK_H
  10 #define _SECURITY_SMACK_H
  11
  12 #include <linux/capability.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/lsm_hooks.h>
  15 #include <linux/in.h>
  16 #if IS_ENABLED(CONFIG_IPV6)
  17 #include <linux/in6.h>
  18 #endif /* CONFIG_IPV6 */
  19 #include <net/netlabel.h>
  20 #include <linux/list.h>
  21 #include <linux/rculist.h>
  22 #include <linux/lsm_audit.h>
  23 #include <linux/msg.h>
  24
  25 /*
  26  * Use IPv6 port labeling if IPv6 is enabled and secmarks
  27  * are not being used.
  28  */
  29 #if IS_ENABLED(CONFIG_IPV6) && !defined(CONFIG_SECURITY_SMACK_NETFILTER)
  30 #define SMACK_IPV6_PORT_LABELING 1
  31 #endif
  32
  33 #if IS_ENABLED(CONFIG_IPV6) && defined(CONFIG_SECURITY_SMACK_NETFILTER)
  34 #define SMACK_IPV6_SECMARK_LABELING 1
  35 #endif
  36
  37 /*
  38  * Smack labels were limited to 23 characters for a long time.
  39  */
  40 #define SMK_LABELLEN    24
  41 #define SMK_LONGLABEL   256
  42
  43 /*
  44  * This is the repository for labels seen so that it is
  45  * not necessary to keep allocating tiny chuncks of memory
  46  * and so that they can be shared.
  47  *
  48  * Labels are never modified in place. Anytime a label
  49  * is imported (e.g. xattrset on a file) the list is checked
  50  * for it and it is added if it doesn't exist. The address
  51  * is passed out in either case. Entries are added, but
  52  * never deleted.
  53  *
  54  * Since labels are hanging around anyway it doesn't
  55  * hurt to maintain a secid for those awkward situations
  56  * where kernel components that ought to use LSM independent
  57  * interfaces don't. The secid should go away when all of
  58  * these components have been repaired.
  59  *
  60  * The cipso value associated with the label gets stored here, too.
  61  *
  62  * Keep the access rules for this subject label here so that
  63  * the entire set of rules does not need to be examined every
  64  * time.
  65  */
  66 struct smack_known {
  67         struct list_head                list;
  68         struct hlist_node               smk_hashed;
  69         char                            *smk_known;
  70         u32                             smk_secid;
  71         struct netlbl_lsm_secattr       smk_netlabel;   /* on wire labels */
  72         struct list_head                smk_rules;      /* access rules */
  73         struct mutex                    smk_rules_lock; /* lock for rules */
  74 };
  75
  76 /*
  77  * Maximum number of bytes for the levels in a CIPSO IP option.
  78  * Why 23? CIPSO is constrained to 30, so a 32 byte buffer is
  79  * bigger than can be used, and 24 is the next lower multiple
  80  * of 8, and there are too many issues if there isn't space set
  81  * aside for the terminating null byte.
  82  */
  83 #define SMK_CIPSOLEN    24
  84
  85 struct superblock_smack {
  86         struct smack_known      *smk_root;
  87         struct smack_known      *smk_floor;
  88         struct smack_known      *smk_hat;
  89         struct smack_known      *smk_default;
  90         int                     smk_flags;
  91 };
  92
  93 /*
  94  * Superblock flags
  95  */
  96 #define SMK_SB_INITIALIZED      0x01
  97 #define SMK_SB_UNTRUSTED        0x02
  98
  99 struct socket_smack {
 100         struct smack_known      *smk_out;       /* outbound label */
 101         struct smack_known      *smk_in;        /* inbound label */
 102         struct smack_known      *smk_packet;    /* TCP peer label */
 103         int                     smk_state;      /* netlabel socket states */
 104 };
 105 #define SMK_NETLBL_UNSET        0
 106 #define SMK_NETLBL_UNLABELED    1
 107 #define SMK_NETLBL_LABELED      2
 108 #define SMK_NETLBL_REQSKB       3
 109
 110 /*
 111  * Inode smack data
 112  */
 113 struct inode_smack {
 114         struct smack_known      *smk_inode;     /* label of the fso */
 115         struct smack_known      *smk_task;      /* label of the task */
 116         struct smack_known      *smk_mmap;      /* label of the mmap domain */
 117         int                     smk_flags;      /* smack inode flags */
 118 };
 119
 120 struct task_smack {
 121         struct smack_known      *smk_task;      /* label for access control */
 122         struct smack_known      *smk_forked;    /* label when forked */
 123         struct list_head        smk_rules;      /* per task access rules */
 124         struct mutex            smk_rules_lock; /* lock for the rules */
 125         struct list_head        smk_relabel;    /* transit allowed labels */
 126 };
 127
 128 #define SMK_INODE_INSTANT       0x01    /* inode is instantiated */
 129 #define SMK_INODE_TRANSMUTE     0x02    /* directory is transmuting */
 130 #define SMK_INODE_CHANGED       0x04    /* smack was transmuted */
 131 #define SMK_INODE_IMPURE        0x08    /* involved in an impure transaction */
 132
 133 /*
 134  * A label access rule.
 135  */
 136 struct smack_rule {
 137         struct list_head        list;
 138         struct smack_known      *smk_subject;
 139         struct smack_known      *smk_object;
 140         int                     smk_access;
 141 };
 142
 143 /*
 144  * An entry in the table identifying IPv4 hosts.
 145  */
 146 struct smk_net4addr {
 147         struct list_head        list;
 148         struct in_addr          smk_host;       /* network address */
 149         struct in_addr          smk_mask;       /* network mask */
 150         int                     smk_masks;      /* mask size */
 151         struct smack_known      *smk_label;     /* label */
 152 };
 153
 154 /*
 155  * An entry in the table identifying IPv6 hosts.
 156  */
 157 struct smk_net6addr {
 158         struct list_head        list;
 159         struct in6_addr         smk_host;       /* network address */
 160         struct in6_addr         smk_mask;       /* network mask */
 161         int                     smk_masks;      /* mask size */
 162         struct smack_known      *smk_label;     /* label */
 163 };
 164
 165 /*
 166  * An entry in the table identifying ports.
 167  */
 168 struct smk_port_label {
 169         struct list_head        list;
 170         struct sock             *smk_sock;      /* socket initialized on */
 171         unsigned short          smk_port;       /* the port number */
 172         struct smack_known      *smk_in;        /* inbound label */
 173         struct smack_known      *smk_out;       /* outgoing label */
 174         short                   smk_sock_type;  /* Socket type */
 175         short                   smk_can_reuse;
 176 };
 177
 178 struct smack_known_list_elem {
 179         struct list_head        list;
 180         struct smack_known      *smk_label;
 181 };
 182
 183 /* Super block security struct flags for mount options */
 184 #define FSDEFAULT_MNT   0x01
 185 #define FSFLOOR_MNT     0x02
 186 #define FSHAT_MNT       0x04
 187 #define FSROOT_MNT      0x08
 188 #define FSTRANS_MNT     0x10
 189
 190 #define NUM_SMK_MNT_OPTS        5
 191
 192 enum {
 193         Opt_error = -1,
 194         Opt_fsdefault = 0,
 195         Opt_fsfloor = 1,
 196         Opt_fshat = 2,
 197         Opt_fsroot = 3,
 198         Opt_fstransmute = 4,
 199 };
 200
 201 #define SMACK_DELETE_OPTION     "-DELETE"
 202 #define SMACK_CIPSO_OPTION      "-CIPSO"
 203
 204 /*
 205  * CIPSO defaults.
 206  */
 207 #define SMACK_CIPSO_DOI_DEFAULT         3       /* Historical */
 208 #define SMACK_CIPSO_DOI_INVALID         -1      /* Not a DOI */
 209 #define SMACK_CIPSO_DIRECT_DEFAULT      250     /* Arbitrary */
 210 #define SMACK_CIPSO_MAPPED_DEFAULT      251     /* Also arbitrary */
 211 #define SMACK_CIPSO_MAXLEVEL            255     /* CIPSO 2.2 standard */
 212 /*
 213  * CIPSO 2.2 standard is 239, but Smack wants to use the
 214  * categories in a structured way that limits the value to
 215  * the bits in 23 bytes, hence the unusual number.
 216  */
 217 #define SMACK_CIPSO_MAXCATNUM           184     /* 23 * 8 */
 218
 219 /*
 220  * Ptrace rules
 221  */
 222 #define SMACK_PTRACE_DEFAULT    0
 223 #define SMACK_PTRACE_EXACT      1
 224 #define SMACK_PTRACE_DRACONIAN  2
 225 #define SMACK_PTRACE_MAX        SMACK_PTRACE_DRACONIAN
 226
 227 /*
 228  * Flags for untraditional access modes.
 229  * It shouldn't be necessary to avoid conflicts with definitions
 230  * in fs.h, but do so anyway.
 231  */
 232 #define MAY_TRANSMUTE   0x00001000      /* Controls directory labeling */
 233 #define MAY_LOCK        0x00002000      /* Locks should be writes, but ... */
 234 #define MAY_BRINGUP     0x00004000      /* Report use of this rule */
 235
 236 /*
 237  * The policy for delivering signals is configurable.
 238  * It is usually "write", but can be "append".
 239  */
 240 #ifdef CONFIG_SECURITY_SMACK_APPEND_SIGNALS
 241 #define MAY_DELIVER     MAY_APPEND      /* Signal delivery requires append */
 242 #else
 243 #define MAY_DELIVER     MAY_WRITE       /* Signal delivery requires write */
 244 #endif
 245
 246 #define SMACK_BRINGUP_ALLOW             1       /* Allow bringup mode */
 247 #define SMACK_UNCONFINED_SUBJECT        2       /* Allow unconfined label */
 248 #define SMACK_UNCONFINED_OBJECT         3       /* Allow unconfined label */
 249
 250 /*
 251  * Just to make the common cases easier to deal with
 252  */
 253 #define MAY_ANYREAD     (MAY_READ | MAY_EXEC)
 254 #define MAY_READWRITE   (MAY_READ | MAY_WRITE)
 255 #define MAY_NOT         0
 256
 257 /*
 258  * Number of access types used by Smack (rwxatlb)
 259  */
 260 #define SMK_NUM_ACCESS_TYPE 7
 261
 262 /* SMACK data */
 263 struct smack_audit_data {
 264         const char *function;
 265         char *subject;
 266         char *object;
 267         char *request;
 268         int result;
 269 };
 270
 271 /*
 272  * Smack audit data; is empty if CONFIG_AUDIT not set
 273  * to save some stack
 274  */
 275 struct smk_audit_info {
 276 #ifdef CONFIG_AUDIT
 277         struct common_audit_data a;
 278         struct smack_audit_data sad;
 279 #endif
 280 };
 281
 282 /*
 283  * These functions are in smack_access.c
 284  */
 285 int smk_access_entry(char *, char *, struct list_head *);
 286 int smk_access(struct smack_known *, struct smack_known *,
 287                int, struct smk_audit_info *);
 288 int smk_tskacc(struct task_smack *, struct smack_known *,
 289                u32, struct smk_audit_info *);
 290 int smk_curacc(struct smack_known *, u32, struct smk_audit_info *);
 291 struct smack_known *smack_from_secid(const u32);
 292 char *smk_parse_smack(const char *string, int len);
 293 int smk_netlbl_mls(int, char *, struct netlbl_lsm_secattr *, int);
 294 struct smack_known *smk_import_entry(const char *, int);
 295 void smk_insert_entry(struct smack_known *skp);
 296 struct smack_known *smk_find_entry(const char *);
 297 bool smack_privileged(int cap);
 298 bool smack_privileged_cred(int cap, const struct cred *cred);
 299 void smk_destroy_label_list(struct list_head *list);
 300 int smack_populate_secattr(struct smack_known *skp);
 301
 302 /*
 303  * Shared data.
 304  */
 305 extern int smack_enabled;
 306 extern int smack_cipso_direct;
 307 extern int smack_cipso_mapped;
 308 extern struct smack_known *smack_net_ambient;
 309 extern struct smack_known *smack_syslog_label;
 310 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
 311 extern struct smack_known *smack_unconfined;
 312 #endif
 313 extern int smack_ptrace_rule;
 314 extern struct lsm_blob_sizes smack_blob_sizes;
 315
 316 extern struct smack_known smack_known_floor;
 317 extern struct smack_known smack_known_hat;
 318 extern struct smack_known smack_known_huh;
 319 extern struct smack_known smack_known_star;
 320 extern struct smack_known smack_known_web;
 321
 322 extern struct mutex     smack_known_lock;
 323 extern struct list_head smack_known_list;
 324 extern struct list_head smk_net4addr_list;
 325 extern struct list_head smk_net6addr_list;
 326
 327 extern struct mutex     smack_onlycap_lock;
 328 extern struct list_head smack_onlycap_list;
 329
 330 #define SMACK_HASH_SLOTS 16
 331 extern struct hlist_head smack_known_hash[SMACK_HASH_SLOTS];
 332 extern struct kmem_cache *smack_rule_cache;
 333
 334 static inline struct task_smack *smack_cred(const struct cred *cred)
 335 {
 336         return cred->security + smack_blob_sizes.lbs_cred;
 337 }
 338
 339 static inline struct smack_known **smack_file(const struct file *file)
 340 {
 341         return (struct smack_known **)(file->f_security +
 342                                        smack_blob_sizes.lbs_file);
 343 }
 344
 345 static inline struct inode_smack *smack_inode(const struct inode *inode)
 346 {
 347         return inode->i_security + smack_blob_sizes.lbs_inode;
 348 }
 349
 350 static inline struct smack_known **smack_msg_msg(const struct msg_msg *msg)
 351 {
 352         return msg->security + smack_blob_sizes.lbs_msg_msg;
 353 }
 354
 355 static inline struct smack_known **smack_ipc(const struct kern_ipc_perm *ipc)
 356 {
 357         return ipc->security + smack_blob_sizes.lbs_ipc;
 358 }
 359
 360 static inline struct superblock_smack *smack_superblock(
 361                                         const struct super_block *superblock)
 362 {
 363         return superblock->s_security + smack_blob_sizes.lbs_superblock;
 364 }
 365
 366 /*
 367  * Is the directory transmuting?
 368  */
 369 static inline int smk_inode_transmutable(const struct inode *isp)
 370 {
 371         struct inode_smack *sip = smack_inode(isp);
 372         return (sip->smk_flags & SMK_INODE_TRANSMUTE) != 0;
 373 }
 374
 375 /*
 376  * Present a pointer to the smack label entry in an inode blob.
 377  */
 378 static inline struct smack_known *smk_of_inode(const struct inode *isp)
 379 {
 380         struct inode_smack *sip = smack_inode(isp);
 381         return sip->smk_inode;
 382 }
 383
 384 /*
 385  * Present a pointer to the smack label entry in an task blob.
 386  */
 387 static inline struct smack_known *smk_of_task(const struct task_smack *tsp)
 388 {
 389         return tsp->smk_task;
 390 }
 391
 392 static inline struct smack_known *smk_of_task_struct_subj(
 393                                                 const struct task_struct *t)
 394 {
 395         struct smack_known *skp;
 396         const struct cred *cred;
 397
 398         rcu_read_lock();
 399
 400         cred = rcu_dereference(t->cred);
 401         skp = smk_of_task(smack_cred(cred));
 402
 403         rcu_read_unlock();
 404
 405         return skp;
 406 }
 407
 408 static inline struct smack_known *smk_of_task_struct_obj(
 409                                                 const struct task_struct *t)
 410 {
 411         struct smack_known *skp;
 412         const struct cred *cred;
 413
 414         rcu_read_lock();
 415
 416         cred = __task_cred(t);
 417         skp = smk_of_task(smack_cred(cred));
 418
 419         rcu_read_unlock();
 420
 421         return skp;
 422 }
 423
 424 /*
 425  * Present a pointer to the forked smack label entry in an task blob.
 426  */
 427 static inline struct smack_known *smk_of_forked(const struct task_smack *tsp)
 428 {
 429         return tsp->smk_forked;
 430 }
 431
 432 /*
 433  * Present a pointer to the smack label in the current task blob.
 434  */
 435 static inline struct smack_known *smk_of_current(void)
 436 {
 437         return smk_of_task(smack_cred(current_cred()));
 438 }
 439
 440 /*
 441  * logging functions
 442  */
 443 #define SMACK_AUDIT_DENIED 0x1
 444 #define SMACK_AUDIT_ACCEPT 0x2
 445 extern int log_policy;
 446
 447 void smack_log(char *subject_label, char *object_label,
 448                 int request,
 449                 int result, struct smk_audit_info *auditdata);
 450
 451 #ifdef CONFIG_AUDIT
 452
 453 /*
 454  * some inline functions to set up audit data
 455  * they do nothing if CONFIG_AUDIT is not set
 456  *
 457  */
 458 static inline void smk_ad_init(struct smk_audit_info *a, const char *func,
 459                                char type)
 460 {
 461         memset(&a->sad, 0, sizeof(a->sad));
 462         a->a.type = type;
 463         a->a.smack_audit_data = &a->sad;
 464         a->a.smack_audit_data->function = func;
 465 }
 466
 467 static inline void smk_ad_init_net(struct smk_audit_info *a, const char *func,
 468                                    char type, struct lsm_network_audit *net)
 469 {
 470         smk_ad_init(a, func, type);
 471         memset(net, 0, sizeof(*net));
 472         a->a.u.net = net;
 473 }
 474
 475 static inline void smk_ad_setfield_u_tsk(struct smk_audit_info *a,
 476                                          struct task_struct *t)
 477 {
 478         a->a.u.tsk = t;
 479 }
 480 static inline void smk_ad_setfield_u_fs_path_dentry(struct smk_audit_info *a,
 481                                                     struct dentry *d)
 482 {
 483         a->a.u.dentry = d;
 484 }
 485 static inline void smk_ad_setfield_u_fs_inode(struct smk_audit_info *a,
 486                                               struct inode *i)
 487 {
 488         a->a.u.inode = i;
 489 }
 490 static inline void smk_ad_setfield_u_fs_path(struct smk_audit_info *a,
 491                                              struct path p)
 492 {
 493         a->a.u.path = p;
 494 }
 495 static inline void smk_ad_setfield_u_net_sk(struct smk_audit_info *a,
 496                                             struct sock *sk)
 497 {
 498         a->a.u.net->sk = sk;
 499 }
 500
 501 #else /* no AUDIT */
 502
 503 static inline void smk_ad_init(struct smk_audit_info *a, const char *func,
 504                                char type)
 505 {
 506 }
 507 static inline void smk_ad_setfield_u_tsk(struct smk_audit_info *a,
 508                                          struct task_struct *t)
 509 {
 510 }
 511 static inline void smk_ad_setfield_u_fs_path_dentry(struct smk_audit_info *a,
 512                                                     struct dentry *d)
 513 {
 514 }
 515 static inline void smk_ad_setfield_u_fs_inode(struct smk_audit_info *a,
 516                                               struct inode *i)
 517 {
 518 }
 519 static inline void smk_ad_setfield_u_fs_path(struct smk_audit_info *a,
 520                                              struct path p)
 521 {
 522 }
 523 static inline void smk_ad_setfield_u_net_sk(struct smk_audit_info *a,
 524                                             struct sock *sk)
 525 {
 526 }
 527 #endif
 528
 529 #endif  /* _SECURITY_SMACK_H */