security/selinux/include/security.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Security server interface.
   4  *
   5  * Author : Stephen Smalley, <sds@tycho.nsa.gov>
   6  *
   7  */
   8
   9 #ifndef _SELINUX_SECURITY_H_
  10 #define _SELINUX_SECURITY_H_
  11
  12 #include <linux/compiler.h>
  13 #include <linux/dcache.h>
  14 #include <linux/magic.h>
  15 #include <linux/types.h>
  16 #include <linux/rcupdate.h>
  17 #include <linux/refcount.h>
  18 #include <linux/workqueue.h>
  19 #include <linux/delay.h>
  20 #include <linux/printk.h>
  21 #include "flask.h"
  22 #include "policycap.h"
  23
  24 #define SECSID_NULL                     0x00000000 /* unspecified SID */
  25 #define SECSID_WILD                     0xffffffff /* wildcard SID */
  26 #define SECCLASS_NULL                   0x0000 /* no class */
  27
  28 /* Identify specific policy version changes */
  29 #define POLICYDB_VERSION_BASE           15
  30 #define POLICYDB_VERSION_BOOL           16
  31 #define POLICYDB_VERSION_IPV6           17
  32 #define POLICYDB_VERSION_NLCLASS        18
  33 #define POLICYDB_VERSION_VALIDATETRANS  19
  34 #define POLICYDB_VERSION_MLS            19
  35 #define POLICYDB_VERSION_AVTAB          20
  36 #define POLICYDB_VERSION_RANGETRANS     21
  37 #define POLICYDB_VERSION_POLCAP         22
  38 #define POLICYDB_VERSION_PERMISSIVE     23
  39 #define POLICYDB_VERSION_BOUNDARY       24
  40 #define POLICYDB_VERSION_FILENAME_TRANS 25
  41 #define POLICYDB_VERSION_ROLETRANS      26
  42 #define POLICYDB_VERSION_NEW_OBJECT_DEFAULTS    27
  43 #define POLICYDB_VERSION_DEFAULT_TYPE   28
  44 #define POLICYDB_VERSION_CONSTRAINT_NAMES       29
  45 #define POLICYDB_VERSION_XPERMS_IOCTL   30
  46 #define POLICYDB_VERSION_INFINIBAND             31
  47 #define POLICYDB_VERSION_GLBLUB         32
  48 #define POLICYDB_VERSION_COMP_FTRANS    33 /* compressed filename transitions */
  49
  50 /* Range of policy versions we understand*/
  51 #define POLICYDB_VERSION_MIN   POLICYDB_VERSION_BASE
  52 #define POLICYDB_VERSION_MAX   POLICYDB_VERSION_COMP_FTRANS
  53
  54 /* Mask for just the mount related flags */
  55 #define SE_MNTMASK      0x0f
  56 /* Super block security struct flags for mount options */
  57 /* BE CAREFUL, these need to be the low order bits for selinux_get_mnt_opts */
  58 #define CONTEXT_MNT     0x01
  59 #define FSCONTEXT_MNT   0x02
  60 #define ROOTCONTEXT_MNT 0x04
  61 #define DEFCONTEXT_MNT  0x08
  62 #define SBLABEL_MNT     0x10
  63 /* Non-mount related flags */
  64 #define SE_SBINITIALIZED        0x0100
  65 #define SE_SBPROC               0x0200
  66 #define SE_SBGENFS              0x0400
  67 #define SE_SBGENFS_XATTR        0x0800
  68
  69 #define CONTEXT_STR     "context"
  70 #define FSCONTEXT_STR   "fscontext"
  71 #define ROOTCONTEXT_STR "rootcontext"
  72 #define DEFCONTEXT_STR  "defcontext"
  73 #define SECLABEL_STR "seclabel"
  74
  75 struct netlbl_lsm_secattr;
  76
  77 extern int selinux_enabled_boot;
  78
  79 /*
  80  * type_datum properties
  81  * available at the kernel policy version >= POLICYDB_VERSION_BOUNDARY
  82  */
  83 #define TYPEDATUM_PROPERTY_PRIMARY      0x0001
  84 #define TYPEDATUM_PROPERTY_ATTRIBUTE    0x0002
  85
  86 /* limitation of boundary depth  */
  87 #define POLICYDB_BOUNDS_MAXDEPTH        4
  88
  89 struct selinux_avc;
  90 struct selinux_policy;
  91
  92 struct selinux_state {
  93 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
  94         bool disabled;
  95 #endif
  96 #ifdef CONFIG_SECURITY_SELINUX_DEVELOP
  97         bool enforcing;
  98 #endif
  99         bool checkreqprot;
 100         bool initialized;
 101         bool policycap[__POLICYDB_CAP_MAX];
 102
 103         struct page *status_page;
 104         struct mutex status_lock;
 105
 106         struct selinux_avc *avc;
 107         struct selinux_policy __rcu *policy;
 108         struct mutex policy_mutex;
 109 } __randomize_layout;
 110
 111 void selinux_avc_init(struct selinux_avc **avc);
 112
 113 extern struct selinux_state selinux_state;
 114
 115 static inline bool selinux_initialized(const struct selinux_state *state)
 116 {
 117         /* do a synchronized load to avoid race conditions */
 118         return smp_load_acquire(&state->initialized);
 119 }
 120
 121 static inline void selinux_mark_initialized(struct selinux_state *state)
 122 {
 123         /* do a synchronized write to avoid race conditions */
 124         smp_store_release(&state->initialized, true);
 125 }
 126
 127 #ifdef CONFIG_SECURITY_SELINUX_DEVELOP
 128 static inline bool enforcing_enabled(struct selinux_state *state)
 129 {
 130         return READ_ONCE(state->enforcing);
 131 }
 132
 133 static inline void enforcing_set(struct selinux_state *state, bool value)
 134 {
 135         WRITE_ONCE(state->enforcing, value);
 136 }
 137 #else
 138 static inline bool enforcing_enabled(struct selinux_state *state)
 139 {
 140         return true;
 141 }
 142
 143 static inline void enforcing_set(struct selinux_state *state, bool value)
 144 {
 145 }
 146 #endif
 147
 148 static inline bool checkreqprot_get(const struct selinux_state *state)
 149 {
 150         return READ_ONCE(state->checkreqprot);
 151 }
 152
 153 static inline void checkreqprot_set(struct selinux_state *state, bool value)
 154 {
 155         if (value)
 156                 pr_err("SELinux: https://github.com/SELinuxProject/selinux-kernel/wiki/DEPRECATE-checkreqprot\n");
 157         WRITE_ONCE(state->checkreqprot, value);
 158 }
 159
 160 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
 161 static inline bool selinux_disabled(struct selinux_state *state)
 162 {
 163         return READ_ONCE(state->disabled);
 164 }
 165
 166 static inline void selinux_mark_disabled(struct selinux_state *state)
 167 {
 168         WRITE_ONCE(state->disabled, true);
 169 }
 170 #else
 171 static inline bool selinux_disabled(struct selinux_state *state)
 172 {
 173         return false;
 174 }
 175 #endif
 176
 177 static inline bool selinux_policycap_netpeer(void)
 178 {
 179         struct selinux_state *state = &selinux_state;
 180
 181         return READ_ONCE(state->policycap[POLICYDB_CAP_NETPEER]);
 182 }
 183
 184 static inline bool selinux_policycap_openperm(void)
 185 {
 186         struct selinux_state *state = &selinux_state;
 187
 188         return READ_ONCE(state->policycap[POLICYDB_CAP_OPENPERM]);
 189 }
 190
 191 static inline bool selinux_policycap_extsockclass(void)
 192 {
 193         struct selinux_state *state = &selinux_state;
 194
 195         return READ_ONCE(state->policycap[POLICYDB_CAP_EXTSOCKCLASS]);
 196 }
 197
 198 static inline bool selinux_policycap_alwaysnetwork(void)
 199 {
 200         struct selinux_state *state = &selinux_state;
 201
 202         return READ_ONCE(state->policycap[POLICYDB_CAP_ALWAYSNETWORK]);
 203 }
 204
 205 static inline bool selinux_policycap_cgroupseclabel(void)
 206 {
 207         struct selinux_state *state = &selinux_state;
 208
 209         return READ_ONCE(state->policycap[POLICYDB_CAP_CGROUPSECLABEL]);
 210 }
 211
 212 static inline bool selinux_policycap_nnp_nosuid_transition(void)
 213 {
 214         struct selinux_state *state = &selinux_state;
 215
 216         return READ_ONCE(state->policycap[POLICYDB_CAP_NNP_NOSUID_TRANSITION]);
 217 }
 218
 219 static inline bool selinux_policycap_genfs_seclabel_symlinks(void)
 220 {
 221         struct selinux_state *state = &selinux_state;
 222
 223         return READ_ONCE(state->policycap[POLICYDB_CAP_GENFS_SECLABEL_SYMLINKS]);
 224 }
 225
 226 static inline bool selinux_policycap_ioctl_skip_cloexec(void)
 227 {
 228         struct selinux_state *state = &selinux_state;
 229
 230         return READ_ONCE(state->policycap[POLICYDB_CAP_IOCTL_SKIP_CLOEXEC]);
 231 }
 232
 233 struct selinux_policy_convert_data;
 234
 235 struct selinux_load_state {
 236         struct selinux_policy *policy;
 237         struct selinux_policy_convert_data *convert_data;
 238 };
 239
 240 int security_mls_enabled(struct selinux_state *state);
 241 int security_load_policy(struct selinux_state *state,
 242                          void *data, size_t len,
 243                          struct selinux_load_state *load_state);
 244 void selinux_policy_commit(struct selinux_state *state,
 245                            struct selinux_load_state *load_state);
 246 void selinux_policy_cancel(struct selinux_state *state,
 247                            struct selinux_load_state *load_state);
 248 int security_read_policy(struct selinux_state *state,
 249                          void **data, size_t *len);
 250 int security_read_state_kernel(struct selinux_state *state,
 251                                void **data, size_t *len);
 252 int security_policycap_supported(struct selinux_state *state,
 253                                  unsigned int req_cap);
 254
 255 #define SEL_VEC_MAX 32
 256 struct av_decision {
 257         u32 allowed;
 258         u32 auditallow;
 259         u32 auditdeny;
 260         u32 seqno;
 261         u32 flags;
 262 };
 263
 264 #define XPERMS_ALLOWED 1
 265 #define XPERMS_AUDITALLOW 2
 266 #define XPERMS_DONTAUDIT 4
 267
 268 #define security_xperm_set(perms, x) ((perms)[(x) >> 5] |= 1 << ((x) & 0x1f))
 269 #define security_xperm_test(perms, x) (1 & ((perms)[(x) >> 5] >> ((x) & 0x1f)))
 270 struct extended_perms_data {
 271         u32 p[8];
 272 };
 273
 274 struct extended_perms_decision {
 275         u8 used;
 276         u8 driver;
 277         struct extended_perms_data *allowed;
 278         struct extended_perms_data *auditallow;
 279         struct extended_perms_data *dontaudit;
 280 };
 281
 282 struct extended_perms {
 283         u16 len;        /* length associated decision chain */
 284         struct extended_perms_data drivers; /* flag drivers that are used */
 285 };
 286
 287 /* definitions of av_decision.flags */
 288 #define AVD_FLAGS_PERMISSIVE    0x0001
 289
 290 void security_compute_av(struct selinux_state *state,
 291                          u32 ssid, u32 tsid,
 292                          u16 tclass, struct av_decision *avd,
 293                          struct extended_perms *xperms);
 294
 295 void security_compute_xperms_decision(struct selinux_state *state,
 296                                       u32 ssid, u32 tsid, u16 tclass,
 297                                       u8 driver,
 298                                       struct extended_perms_decision *xpermd);
 299
 300 void security_compute_av_user(struct selinux_state *state,
 301                               u32 ssid, u32 tsid,
 302                               u16 tclass, struct av_decision *avd);
 303
 304 int security_transition_sid(struct selinux_state *state,
 305                             u32 ssid, u32 tsid, u16 tclass,
 306                             const struct qstr *qstr, u32 *out_sid);
 307
 308 int security_transition_sid_user(struct selinux_state *state,
 309                                  u32 ssid, u32 tsid, u16 tclass,
 310                                  const char *objname, u32 *out_sid);
 311
 312 int security_member_sid(struct selinux_state *state, u32 ssid, u32 tsid,
 313                         u16 tclass, u32 *out_sid);
 314
 315 int security_change_sid(struct selinux_state *state, u32 ssid, u32 tsid,
 316                         u16 tclass, u32 *out_sid);
 317
 318 int security_sid_to_context(struct selinux_state *state, u32 sid,
 319                             char **scontext, u32 *scontext_len);
 320
 321 int security_sid_to_context_force(struct selinux_state *state,
 322                                   u32 sid, char **scontext, u32 *scontext_len);
 323
 324 int security_sid_to_context_inval(struct selinux_state *state,
 325                                   u32 sid, char **scontext, u32 *scontext_len);
 326
 327 int security_context_to_sid(struct selinux_state *state,
 328                             const char *scontext, u32 scontext_len,
 329                             u32 *out_sid, gfp_t gfp);
 330
 331 int security_context_str_to_sid(struct selinux_state *state,
 332                                 const char *scontext, u32 *out_sid, gfp_t gfp);
 333
 334 int security_context_to_sid_default(struct selinux_state *state,
 335                                     const char *scontext, u32 scontext_len,
 336                                     u32 *out_sid, u32 def_sid, gfp_t gfp_flags);
 337
 338 int security_context_to_sid_force(struct selinux_state *state,
 339                                   const char *scontext, u32 scontext_len,
 340                                   u32 *sid);
 341
 342 int security_get_user_sids(struct selinux_state *state,
 343                            u32 callsid, char *username,
 344                            u32 **sids, u32 *nel);
 345
 346 int security_port_sid(struct selinux_state *state,
 347                       u8 protocol, u16 port, u32 *out_sid);
 348
 349 int security_ib_pkey_sid(struct selinux_state *state,
 350                          u64 subnet_prefix, u16 pkey_num, u32 *out_sid);
 351
 352 int security_ib_endport_sid(struct selinux_state *state,
 353                             const char *dev_name, u8 port_num, u32 *out_sid);
 354
 355 int security_netif_sid(struct selinux_state *state,
 356                        char *name, u32 *if_sid);
 357
 358 int security_node_sid(struct selinux_state *state,
 359                       u16 domain, void *addr, u32 addrlen,
 360                       u32 *out_sid);
 361
 362 int security_validate_transition(struct selinux_state *state,
 363                                  u32 oldsid, u32 newsid, u32 tasksid,
 364                                  u16 tclass);
 365
 366 int security_validate_transition_user(struct selinux_state *state,
 367                                       u32 oldsid, u32 newsid, u32 tasksid,
 368                                       u16 tclass);
 369
 370 int security_bounded_transition(struct selinux_state *state,
 371                                 u32 oldsid, u32 newsid);
 372
 373 int security_sid_mls_copy(struct selinux_state *state,
 374                           u32 sid, u32 mls_sid, u32 *new_sid);
 375
 376 int security_net_peersid_resolve(struct selinux_state *state,
 377                                  u32 nlbl_sid, u32 nlbl_type,
 378                                  u32 xfrm_sid,
 379                                  u32 *peer_sid);
 380
 381 int security_get_classes(struct selinux_policy *policy,
 382                          char ***classes, int *nclasses);
 383 int security_get_permissions(struct selinux_policy *policy,
 384                              char *class, char ***perms, int *nperms);
 385 int security_get_reject_unknown(struct selinux_state *state);
 386 int security_get_allow_unknown(struct selinux_state *state);
 387
 388 #define SECURITY_FS_USE_XATTR           1 /* use xattr */
 389 #define SECURITY_FS_USE_TRANS           2 /* use transition SIDs, e.g. devpts/tmpfs */
 390 #define SECURITY_FS_USE_TASK            3 /* use task SIDs, e.g. pipefs/sockfs */
 391 #define SECURITY_FS_USE_GENFS           4 /* use the genfs support */
 392 #define SECURITY_FS_USE_NONE            5 /* no labeling support */
 393 #define SECURITY_FS_USE_MNTPOINT        6 /* use mountpoint labeling */
 394 #define SECURITY_FS_USE_NATIVE          7 /* use native label support */
 395 #define SECURITY_FS_USE_MAX             7 /* Highest SECURITY_FS_USE_XXX */
 396
 397 int security_fs_use(struct selinux_state *state, struct super_block *sb);
 398
 399 int security_genfs_sid(struct selinux_state *state,
 400                        const char *fstype, const char *path, u16 sclass,
 401                        u32 *sid);
 402
 403 int selinux_policy_genfs_sid(struct selinux_policy *policy,
 404                        const char *fstype, const char *path, u16 sclass,
 405                        u32 *sid);
 406
 407 #ifdef CONFIG_NETLABEL
 408 int security_netlbl_secattr_to_sid(struct selinux_state *state,
 409                                    struct netlbl_lsm_secattr *secattr,
 410                                    u32 *sid);
 411
 412 int security_netlbl_sid_to_secattr(struct selinux_state *state,
 413                                    u32 sid,
 414                                    struct netlbl_lsm_secattr *secattr);
 415 #else
 416 static inline int security_netlbl_secattr_to_sid(struct selinux_state *state,
 417                                             struct netlbl_lsm_secattr *secattr,
 418                                             u32 *sid)
 419 {
 420         return -EIDRM;
 421 }
 422
 423 static inline int security_netlbl_sid_to_secattr(struct selinux_state *state,
 424                                          u32 sid,
 425                                          struct netlbl_lsm_secattr *secattr)
 426 {
 427         return -ENOENT;
 428 }
 429 #endif /* CONFIG_NETLABEL */
 430
 431 const char *security_get_initial_sid_context(u32 sid);
 432
 433 /*
 434  * status notifier using mmap interface
 435  */
 436 extern struct page *selinux_kernel_status_page(struct selinux_state *state);
 437
 438 #define SELINUX_KERNEL_STATUS_VERSION   1
 439 struct selinux_kernel_status {
 440         u32     version;        /* version number of the structure */
 441         u32     sequence;       /* sequence number of seqlock logic */
 442         u32     enforcing;      /* current setting of enforcing mode */
 443         u32     policyload;     /* times of policy reloaded */
 444         u32     deny_unknown;   /* current setting of deny_unknown */
 445         /*
 446          * The version > 0 supports above members.
 447          */
 448 } __packed;
 449
 450 extern void selinux_status_update_setenforce(struct selinux_state *state,
 451                                              int enforcing);
 452 extern void selinux_status_update_policyload(struct selinux_state *state,
 453                                              int seqno);
 454 extern void selinux_complete_init(void);
 455 extern int selinux_disable(struct selinux_state *state);
 456 extern void exit_sel_fs(void);
 457 extern struct path selinux_null;
 458 extern void selnl_notify_setenforce(int val);
 459 extern void selnl_notify_policyload(u32 seqno);
 460 extern int selinux_nlmsg_lookup(u16 sclass, u16 nlmsg_type, u32 *perm);
 461
 462 extern void avtab_cache_init(void);
 463 extern void ebitmap_cache_init(void);
 464 extern void hashtab_cache_init(void);
 465 extern int security_sidtab_hash_stats(struct selinux_state *state, char *page);
 466
 467 #endif /* _SELINUX_SECURITY_H_ */