2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* A policy database (policydb) specifies the
|
|
|
|
* configuration data for the security policy.
|
|
|
|
*
|
|
|
|
* Author : Stephen Smalley, <sds@epoch.ncsc.mil>
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Updated: Trusted Computer Solutions, Inc. <dgoeddel@trustedcs.com>
|
|
|
|
*
|
|
|
|
* Support for enhanced MLS infrastructure.
|
|
|
|
*
|
|
|
|
* Updated: Frank Mayer <mayerf@tresys.com> and Karl MacMillan <kmacmillan@tresys.com>
|
|
|
|
*
|
2008-04-22 14:46:17 -07:00
|
|
|
* Added conditional policy language extensions
|
2005-04-16 15:20:36 -07:00
|
|
|
*
|
|
|
|
* Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
|
|
|
|
* Copyright (C) 2003 - 2004 Tresys Technology, LLC
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
2008-04-22 14:46:17 -07:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
2005-04-16 15:20:36 -07:00
|
|
|
* the Free Software Foundation, version 2.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _SS_POLICYDB_H_
|
|
|
|
#define _SS_POLICYDB_H_
|
|
|
|
|
2010-07-29 20:02:34 -07:00
|
|
|
#include <linux/flex_array.h>
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
#include "symtab.h"
|
|
|
|
#include "avtab.h"
|
|
|
|
#include "sidtab.h"
|
2010-02-03 08:40:20 -07:00
|
|
|
#include "ebitmap.h"
|
|
|
|
#include "mls_types.h"
|
2005-04-16 15:20:36 -07:00
|
|
|
#include "context.h"
|
|
|
|
#include "constraint.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A datum type is defined for each kind of symbol
|
|
|
|
* in the configuration data: individual permissions,
|
|
|
|
* common prefixes for access vectors, classes,
|
|
|
|
* users, roles, types, sensitivities, categories, etc.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Permission attributes */
|
|
|
|
struct perm_datum {
|
|
|
|
u32 value; /* permission bit + 1 */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Attributes of a common prefix for access vectors */
|
|
|
|
struct common_datum {
|
|
|
|
u32 value; /* internal common value */
|
|
|
|
struct symtab permissions; /* common permissions */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Class attributes */
|
|
|
|
struct class_datum {
|
|
|
|
u32 value; /* class value */
|
|
|
|
char *comkey; /* common name */
|
|
|
|
struct common_datum *comdatum; /* common datum */
|
|
|
|
struct symtab permissions; /* class-specific permission symbol table */
|
|
|
|
struct constraint_node *constraints; /* constraints on class permissions */
|
|
|
|
struct constraint_node *validatetrans; /* special transition rules */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Role attributes */
|
|
|
|
struct role_datum {
|
|
|
|
u32 value; /* internal role value */
|
2008-08-28 00:35:57 -07:00
|
|
|
u32 bounds; /* boundary of role */
|
2005-04-16 15:20:36 -07:00
|
|
|
struct ebitmap dominates; /* set of roles dominated by this role */
|
|
|
|
struct ebitmap types; /* set of authorized types for role */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct role_trans {
|
|
|
|
u32 role; /* current role */
|
|
|
|
u32 type; /* program executable type */
|
|
|
|
u32 new_role; /* new role */
|
|
|
|
struct role_trans *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct role_allow {
|
|
|
|
u32 role; /* current role */
|
|
|
|
u32 new_role; /* new role */
|
|
|
|
struct role_allow *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Type attributes */
|
|
|
|
struct type_datum {
|
|
|
|
u32 value; /* internal type value */
|
2008-08-28 00:35:57 -07:00
|
|
|
u32 bounds; /* boundary of type */
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned char primary; /* primary name? */
|
2008-08-28 00:35:57 -07:00
|
|
|
unsigned char attribute;/* attribute ?*/
|
2005-04-16 15:20:36 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* User attributes */
|
|
|
|
struct user_datum {
|
|
|
|
u32 value; /* internal user value */
|
2008-08-28 00:35:57 -07:00
|
|
|
u32 bounds; /* bounds of user */
|
2005-04-16 15:20:36 -07:00
|
|
|
struct ebitmap roles; /* set of authorized roles for user */
|
|
|
|
struct mls_range range; /* MLS range (min - max) for user */
|
|
|
|
struct mls_level dfltlevel; /* default login MLS level for user */
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* Sensitivity attributes */
|
|
|
|
struct level_datum {
|
|
|
|
struct mls_level *level; /* sensitivity and associated categories */
|
|
|
|
unsigned char isalias; /* is this sensitivity an alias for another? */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Category attributes */
|
|
|
|
struct cat_datum {
|
|
|
|
u32 value; /* internal category bit + 1 */
|
|
|
|
unsigned char isalias; /* is this category an alias for another? */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct range_trans {
|
2006-09-25 23:31:59 -07:00
|
|
|
u32 source_type;
|
|
|
|
u32 target_type;
|
|
|
|
u32 target_class;
|
2005-04-16 15:20:36 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Boolean data type */
|
|
|
|
struct cond_bool_datum {
|
|
|
|
__u32 value; /* internal type value */
|
|
|
|
int state;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cond_node;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The configuration data includes security contexts for
|
|
|
|
* initial SIDs, unlabeled file systems, TCP and UDP port numbers,
|
|
|
|
* network interfaces, and nodes. This structure stores the
|
|
|
|
* relevant data for one such entry. Entries of the same kind
|
|
|
|
* (e.g. all initial SIDs) are linked together into a list.
|
|
|
|
*/
|
|
|
|
struct ocontext {
|
|
|
|
union {
|
|
|
|
char *name; /* name of initial SID, fs, netif, fstype, path */
|
|
|
|
struct {
|
|
|
|
u8 protocol;
|
|
|
|
u16 low_port;
|
|
|
|
u16 high_port;
|
|
|
|
} port; /* TCP or UDP port information */
|
|
|
|
struct {
|
|
|
|
u32 addr;
|
|
|
|
u32 mask;
|
|
|
|
} node; /* node information */
|
|
|
|
struct {
|
|
|
|
u32 addr[4];
|
|
|
|
u32 mask[4];
|
|
|
|
} node6; /* IPv6 node information */
|
|
|
|
} u;
|
|
|
|
union {
|
|
|
|
u32 sclass; /* security class for genfs */
|
|
|
|
u32 behavior; /* labeling behavior for fs_use */
|
|
|
|
} v;
|
|
|
|
struct context context[2]; /* security context(s) */
|
|
|
|
u32 sid[2]; /* SID(s) */
|
|
|
|
struct ocontext *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct genfs {
|
|
|
|
char *fstype;
|
|
|
|
struct ocontext *head;
|
|
|
|
struct genfs *next;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* symbol table array indices */
|
|
|
|
#define SYM_COMMONS 0
|
|
|
|
#define SYM_CLASSES 1
|
|
|
|
#define SYM_ROLES 2
|
|
|
|
#define SYM_TYPES 3
|
|
|
|
#define SYM_USERS 4
|
|
|
|
#define SYM_BOOLS 5
|
|
|
|
#define SYM_LEVELS 6
|
|
|
|
#define SYM_CATS 7
|
|
|
|
#define SYM_NUM 8
|
|
|
|
|
|
|
|
/* object context array indices */
|
|
|
|
#define OCON_ISID 0 /* initial SIDs */
|
|
|
|
#define OCON_FS 1 /* unlabeled file systems */
|
|
|
|
#define OCON_PORT 2 /* TCP and UDP port numbers */
|
|
|
|
#define OCON_NETIF 3 /* network interfaces */
|
|
|
|
#define OCON_NODE 4 /* nodes */
|
|
|
|
#define OCON_FSUSE 5 /* fs_use */
|
|
|
|
#define OCON_NODE6 6 /* IPv6 nodes */
|
|
|
|
#define OCON_NUM 7
|
|
|
|
|
|
|
|
/* The policy database */
|
|
|
|
struct policydb {
|
2010-02-03 08:40:20 -07:00
|
|
|
int mls_enabled;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/* symbol tables */
|
|
|
|
struct symtab symtab[SYM_NUM];
|
|
|
|
#define p_commons symtab[SYM_COMMONS]
|
|
|
|
#define p_classes symtab[SYM_CLASSES]
|
|
|
|
#define p_roles symtab[SYM_ROLES]
|
|
|
|
#define p_types symtab[SYM_TYPES]
|
|
|
|
#define p_users symtab[SYM_USERS]
|
|
|
|
#define p_bools symtab[SYM_BOOLS]
|
|
|
|
#define p_levels symtab[SYM_LEVELS]
|
|
|
|
#define p_cats symtab[SYM_CATS]
|
|
|
|
|
|
|
|
/* symbol names indexed by (value - 1) */
|
|
|
|
char **sym_val_to_name[SYM_NUM];
|
|
|
|
#define p_common_val_to_name sym_val_to_name[SYM_COMMONS]
|
|
|
|
#define p_class_val_to_name sym_val_to_name[SYM_CLASSES]
|
|
|
|
#define p_role_val_to_name sym_val_to_name[SYM_ROLES]
|
|
|
|
#define p_type_val_to_name sym_val_to_name[SYM_TYPES]
|
|
|
|
#define p_user_val_to_name sym_val_to_name[SYM_USERS]
|
|
|
|
#define p_bool_val_to_name sym_val_to_name[SYM_BOOLS]
|
|
|
|
#define p_sens_val_to_name sym_val_to_name[SYM_LEVELS]
|
|
|
|
#define p_cat_val_to_name sym_val_to_name[SYM_CATS]
|
|
|
|
|
|
|
|
/* class, role, and user attributes indexed by (value - 1) */
|
|
|
|
struct class_datum **class_val_to_struct;
|
|
|
|
struct role_datum **role_val_to_struct;
|
|
|
|
struct user_datum **user_val_to_struct;
|
2010-11-29 13:47:09 -07:00
|
|
|
struct flex_array *type_val_to_struct_array;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* type enforcement access vectors and transitions */
|
|
|
|
struct avtab te_avtab;
|
|
|
|
|
|
|
|
/* role transitions */
|
|
|
|
struct role_trans *role_tr;
|
|
|
|
|
|
|
|
/* bools indexed by (value - 1) */
|
|
|
|
struct cond_bool_datum **bool_val_to_struct;
|
|
|
|
/* type enforcement conditional access vectors and transitions */
|
|
|
|
struct avtab te_cond_avtab;
|
|
|
|
/* linked list indexing te_cond_avtab by conditional */
|
2008-04-22 14:46:17 -07:00
|
|
|
struct cond_node *cond_list;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* role allows */
|
|
|
|
struct role_allow *role_allow;
|
|
|
|
|
|
|
|
/* security contexts of initial SIDs, unlabeled file systems,
|
|
|
|
TCP or UDP port numbers, network interfaces and nodes */
|
|
|
|
struct ocontext *ocontexts[OCON_NUM];
|
|
|
|
|
2008-04-22 14:46:17 -07:00
|
|
|
/* security contexts for files in filesystems that cannot support
|
2005-04-16 15:20:36 -07:00
|
|
|
a persistent label mapping or use another
|
|
|
|
fixed labeling behavior. */
|
2008-04-22 14:46:17 -07:00
|
|
|
struct genfs *genfs;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2010-01-07 13:55:16 -07:00
|
|
|
/* range transitions table (range_trans_key -> mls_range) */
|
|
|
|
struct hashtab *range_tr;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-09-03 15:55:16 -07:00
|
|
|
/* type -> attribute reverse mapping */
|
2010-07-29 20:02:34 -07:00
|
|
|
struct flex_array *type_attr_map_array;
|
2005-09-03 15:55:16 -07:00
|
|
|
|
2008-01-29 06:38:19 -07:00
|
|
|
struct ebitmap policycaps;
|
|
|
|
|
2008-03-30 18:17:33 -07:00
|
|
|
struct ebitmap permissive_map;
|
|
|
|
|
2010-10-13 14:50:25 -07:00
|
|
|
/* length of this policy when it was loaded */
|
|
|
|
size_t len;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned int policyvers;
|
2007-09-21 11:37:10 -07:00
|
|
|
|
|
|
|
unsigned int reject_unknown : 1;
|
|
|
|
unsigned int allow_unknown : 1;
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-09-30 10:37:50 -07:00
|
|
|
|
|
|
|
u16 process_class;
|
|
|
|
u32 process_trans_perms;
|
2005-04-16 15:20:36 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
extern void policydb_destroy(struct policydb *p);
|
|
|
|
extern int policydb_load_isids(struct policydb *p, struct sidtab *s);
|
|
|
|
extern int policydb_context_isvalid(struct policydb *p, struct context *c);
|
2007-11-07 08:08:00 -07:00
|
|
|
extern int policydb_class_isvalid(struct policydb *p, unsigned int class);
|
|
|
|
extern int policydb_type_isvalid(struct policydb *p, unsigned int type);
|
|
|
|
extern int policydb_role_isvalid(struct policydb *p, unsigned int role);
|
2005-04-16 15:20:36 -07:00
|
|
|
extern int policydb_read(struct policydb *p, void *fp);
|
2010-10-13 14:50:25 -07:00
|
|
|
extern int policydb_write(struct policydb *p, void *fp);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#define PERM_SYMTAB_SIZE 32
|
|
|
|
|
|
|
|
#define POLICYDB_CONFIG_MLS 1
|
|
|
|
|
2007-09-21 11:37:10 -07:00
|
|
|
/* the config flags related to unknown classes/perms are bits 2 and 3 */
|
|
|
|
#define REJECT_UNKNOWN 0x00000002
|
|
|
|
#define ALLOW_UNKNOWN 0x00000004
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
#define OBJECT_R "object_r"
|
|
|
|
#define OBJECT_R_VAL 1
|
|
|
|
|
|
|
|
#define POLICYDB_MAGIC SELINUX_MAGIC
|
|
|
|
#define POLICYDB_STRING "SE Linux"
|
|
|
|
|
|
|
|
struct policy_file {
|
|
|
|
char *data;
|
|
|
|
size_t len;
|
|
|
|
};
|
|
|
|
|
2010-10-13 14:50:25 -07:00
|
|
|
struct policy_data {
|
|
|
|
struct policydb *p;
|
|
|
|
void *fp;
|
|
|
|
};
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
static inline int next_entry(void *buf, struct policy_file *fp, size_t bytes)
|
|
|
|
{
|
|
|
|
if (bytes > fp->len)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memcpy(buf, fp->data, bytes);
|
|
|
|
fp->data += bytes;
|
|
|
|
fp->len -= bytes;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-13 14:50:25 -07:00
|
|
|
static inline int put_entry(void *buf, size_t bytes, int num, struct policy_file *fp)
|
|
|
|
{
|
|
|
|
size_t len = bytes * num;
|
|
|
|
|
|
|
|
memcpy(fp->data, buf, len);
|
|
|
|
fp->data += len;
|
|
|
|
fp->len -= len;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
selinux: dynamic class/perm discovery
Modify SELinux to dynamically discover class and permission values
upon policy load, based on the dynamic object class/perm discovery
logic from libselinux. A mapping is created between kernel-private
class and permission indices used outside the security server and the
policy values used within the security server.
The mappings are only applied upon kernel-internal computations;
similar mappings for the private indices of userspace object managers
is handled on a per-object manager basis by the userspace AVC. The
interfaces for compute_av and transition_sid are split for kernel
vs. userspace; the userspace functions are distinguished by a _user
suffix.
The kernel-private class indices are no longer tied to the policy
values and thus do not need to skip indices for userspace classes;
thus the kernel class index values are compressed. The flask.h
definitions were regenerated by deleting the userspace classes from
refpolicy's definitions and then regenerating the headers. Going
forward, we can just maintain the flask.h, av_permissions.h, and
classmap.h definitions separately from policy as they are no longer
tied to the policy values. The next patch introduces a utility to
automate generation of flask.h and av_permissions.h from the
classmap.h definitions.
The older kernel class and permission string tables are removed and
replaced by a single security class mapping table that is walked at
policy load to generate the mapping. The old kernel class validation
logic is completely replaced by the mapping logic.
The handle unknown logic is reworked. reject_unknown=1 is handled
when the mappings are computed at policy load time, similar to the old
handling by the class validation logic. allow_unknown=1 is handled
when computing and mapping decisions - if the permission was not able
to be mapped (i.e. undefined, mapped to zero), then it is
automatically added to the allowed vector. If the class was not able
to be mapped (i.e. undefined, mapped to zero), then all permissions
are allowed for it if allow_unknown=1.
avc_audit leverages the new security class mapping table to lookup the
class and permission names from the kernel-private indices.
The mdp program is updated to use the new table when generating the
class definitions and allow rules for a minimal boot policy for the
kernel. It should be noted that this policy will not include any
userspace classes, nor will its policy index values for the kernel
classes correspond with the ones in refpolicy (they will instead match
the kernel-private indices).
Signed-off-by: Stephen Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>
2009-09-30 10:37:50 -07:00
|
|
|
extern u16 string_to_security_class(struct policydb *p, const char *name);
|
|
|
|
extern u32 string_to_av_perm(struct policydb *p, u16 tclass, const char *name);
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
#endif /* _SS_POLICYDB_H_ */
|
|
|
|
|