libsepol: refactor ebitmap conversion in link.c
PATCH v3 1/8 libsepol: refactor ebitmap conversion in link.c
Refactor the ebitmap conversions in link.c into its own function.
Do not log an OOM message twice on type_set_or_convert() failure.
Drop the now unused state parameter from type_set_or_convert() and type_set_convert().
--- libsepol/src/link.c | 140 +++++++++++++++----------------------------- 1 file changed, 47 insertions(+), 93 deletions(-)
libsepol/src/link.c +47 -93
@@ -958,26 +958,28 @@ static int alias_copy_callback(hashtab_key_t key, hashtab_datum_t datum,/*********** callbacks that fix bitmaps ***********/ -static int type_set_convert (type_set_t * types,type_set_t * dst, -policy_module_t * mod,link_state_t * state - __attribute__ ((unused))) +static int ebitmap_convert (const ebitmap_t *src,ebitmap_t *dst,const uint32_t *map) { -unsigned int i; -ebitmap_node_t *tnode; -ebitmap_for_each_positive_bit (&types->types, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&dst->types, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } - } -ebitmap_for_each_positive_bit (&types->negset, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&dst->negset, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } +unsigned int bit; +ebitmap_node_t *node; +ebitmap_for_each_positive_bit (src, node, bit) { +assert (map[bit]); +if (ebitmap_set_bit (dst, map[bit] -1 ,1 )) +return -1 ; } + +return 0 ; +} + +static int type_set_convert (const type_set_t * types,type_set_t * dst, +const policy_module_t * mod) +{ +if (ebitmap_convert (&types->types, &dst->types, mod->map[SYM_TYPES ])) + goto cleanup; + +if (ebitmap_convert (&types->negset, &dst->negset, mod->map[SYM_TYPES ])) + goto cleanup; + dst->flags = types->flags;return 0 ;
@@ -988,13 +990,13 @@ static int type_set_convert(type_set_t * types, type_set_t * dst,/* OR 2 typemaps together and at the same time map the src types to * the correct values in the dst typeset. */ -static int type_set_or_convert (type_set_t * types,type_set_t * dst, -policy_module_t * mod,link_state_t * state) +static int type_set_or_convert (const type_set_t * types,type_set_t * dst, +const policy_module_t * mod) {type_set_t ts_tmp;type_set_init (&ts_tmp); -if (type_set_convert (types, &ts_tmp, mod, state) ==-1 ) { +if (type_set_convert (types, &ts_tmp, mod) ==-1 ) { goto cleanup; }if (type_set_or_eq (dst, &ts_tmp)) {
@@ -1004,7 +1006,6 @@ static int type_set_or_convert(type_set_t * types, type_set_t * dst,return 0 ; cleanup: -ERR (state->handle,"Out of memory!" );type_set_destroy (&ts_tmp);return -1 ; }
@@ -1012,18 +1013,11 @@ static int type_set_or_convert(type_set_t * types, type_set_t * dst,static int role_set_or_convert (role_set_t * roles,role_set_t * dst,policy_module_t * mod,link_state_t * state) { -unsigned int i;ebitmap_t tmp; -ebitmap_node_t *rnode;ebitmap_init (&tmp); -ebitmap_for_each_positive_bit (&roles->roles, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&roles->roles, &tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dst->roles, &tmp)) { goto cleanup; }
@@ -1088,13 +1082,11 @@ static int mls_range_convert(mls_semantic_range_t * src, mls_semantic_range_t *static int role_fix_callback (hashtab_key_t key,hashtab_datum_t datum,void *data) { -unsigned int i;char *id = key;role_datum_t *role, *dest_role =NULL ;link_state_t *state = (link_state_t *) data;ebitmap_t e_tmp;policy_module_t *mod = state->cur; -ebitmap_node_t *rnode;hashtab_t role_tab; role = (role_datum_t *) datum;
@@ -1111,30 +1103,20 @@ static int role_fix_callback(hashtab_key_t key, hashtab_datum_t datum, }ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&role->dominates, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&role->dominates, &e_tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dest_role->dominates, &e_tmp)) { goto cleanup; } -if (type_set_or_convert (&role->types, &dest_role->types, mod, state)) { +if (type_set_or_convert (&role->types, &dest_role->types, mod)) { goto cleanup; }ebitmap_destroy (&e_tmp);if (role->flavor ==ROLE_ATTRIB ) {ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&role->roles, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&role->roles, &e_tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dest_role->roles, &e_tmp)) { goto cleanup; }
@@ -1152,13 +1134,11 @@ static int role_fix_callback(hashtab_key_t key, hashtab_datum_t datum,static int type_fix_callback (hashtab_key_t key,hashtab_datum_t datum,void *data) { -unsigned int i;char *id = key;type_datum_t *type, *new_type =NULL ;link_state_t *state = (link_state_t *) data;ebitmap_t e_tmp;policy_module_t *mod = state->cur; -ebitmap_node_t *tnode;symtab_t *typetab; type = (type_datum_t *) datum;
@@ -1181,13 +1161,8 @@ static int type_fix_callback(hashtab_key_t key, hashtab_datum_t datum, }ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&type->types, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&type->types, &e_tmp, mod->map[SYM_TYPES ])) + goto cleanup;if (ebitmap_union (&new_type->types, &e_tmp)) { goto cleanup; }
@@ -1269,9 +1244,8 @@ static int copy_avrule_list(avrule_t * list, avrule_t ** dst, new_rule->specified = cur->specified; new_rule->flags = cur->flags;if (type_set_convert - (&cur->stypes, &new_rule->stypes, module, state) ==-1 - ||type_set_convert (&cur->ttypes, &new_rule->ttypes, module, - state) ==-1 ) { + (&cur->stypes, &new_rule->stypes, module) ==-1 + ||type_set_convert (&cur->ttypes, &new_rule->ttypes, module) ==-1 ) { goto cleanup; }
@@ -1355,8 +1329,6 @@ static int copy_role_trans_list(role_trans_rule_t * list, policy_module_t * module, link_state_t * state) {role_trans_rule_t *cur, *new_rule =NULL , *tail; -unsigned int i; -ebitmap_node_t *cnode; cur = list; tail = *dst;
@@ -1374,19 +1346,12 @@ static int copy_role_trans_list(role_trans_rule_t * list,if (role_set_or_convert (&cur->roles, &new_rule->roles, module, state) ||type_set_or_convert (&cur->types, &new_rule->types, - module, state)) { + module)) { goto cleanup; } -ebitmap_for_each_positive_bit (&cur->classes, cnode, i) { -assert (module->map[SYM_CLASSES ][i]); -if (ebitmap_set_bit (&new_rule->classes, - module-> - map[SYM_CLASSES ][i] -1 , -1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&cur->classes, &new_rule->classes, module->map[SYM_CLASSES ])) + goto cleanup; new_rule->new_role = module->map[SYM_ROLES ][cur->new_role -1 ];
@@ -1476,8 +1441,8 @@ static int copy_filename_trans_list(filename_trans_rule_t * list,if (!new_rule->name) goto err; -if (type_set_or_convert (&cur->stypes, &new_rule->stypes, module, state) || -type_set_or_convert (&cur->ttypes, &new_rule->ttypes, module, state)) +if (type_set_or_convert (&cur->stypes, &new_rule->stypes, module) || +type_set_or_convert (&cur->ttypes, &new_rule->ttypes, module)) goto err; new_rule->tclass = module->map[SYM_CLASSES ][cur->tclass -1 ];
@@ -1497,8 +1462,6 @@ static int copy_range_trans_list(range_trans_rule_t * rules, policy_module_t * mod, link_state_t * state) {range_trans_rule_t *rule, *new_rule =NULL ; -unsigned int i; -ebitmap_node_t *cnode;for (rule = rules; rule; rule = rule->next) { new_rule =
@@ -1512,21 +1475,15 @@ static int copy_range_trans_list(range_trans_rule_t * rules, *dst = new_rule;if (type_set_convert (&rule->stypes, &new_rule->stypes, - mod, state)) + mod)) goto cleanup;if (type_set_convert (&rule->ttypes, &new_rule->ttypes, - mod, state)) + mod)) goto cleanup; -ebitmap_for_each_positive_bit (&rule->tclasses, cnode, i) { -assert (mod->map[SYM_CLASSES ][i]); -if (ebitmap_set_bit - (&new_rule->tclasses, - mod->map[SYM_CLASSES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&rule->tclasses, &new_rule->tclasses, mod->map[SYM_CLASSES ])) + goto cleanup;if (mls_range_convert (&rule->trange, &new_rule->trange, mod, state)) goto cleanup;
@@ -1688,15 +1645,12 @@ static int copy_scope_index(scope_index_t * src, scope_index_t * dest, } dest->class_perms_len = largest_mapped_class_value;for (i =0 ; i < src->class_perms_len; i++) { -ebitmap_t *srcmap = src->class_perms_map + i; +const ebitmap_t *srcmap = src->class_perms_map + i;ebitmap_t *destmap = dest->class_perms_map + module->map[SYM_CLASSES ][i] -1 ; -ebitmap_for_each_positive_bit (srcmap, node, j) { -if (ebitmap_set_bit (destmap, module->perm_map[i][j] -1 , -1 )) { - goto cleanup; - } - } + +if (ebitmap_convert (srcmap, destmap, module->perm_map[i])) + goto cleanup; }return 0 ;
Signature · 1 line
2.36.1
PATCH v3 2/8 libsepol: add ebitmap iterator wrapper with startnode
Similar like ebitmap_for_each_bit() iterates over all bits of an ebitmap add ebitmap_for_each_bit_starting() iterating over all bits starting from a specific node and bit, which can be from an outer iteration.
---
v2:
* use _after suffix
* reorder parameters
--- libsepol/include/sepol/policydb/ebitmap.h | 7 +++++++ 1 file changed, 7 insertions(+)
libsepol/include/sepol/policydb/ebitmap.h +7 -0
@@ -80,6 +80,13 @@ static inline int ebitmap_node_get_bit(const ebitmap_node_t * n, unsigned int bi#define ebitmap_for_each_positive_bit (e, n, bit) \ ebitmap_for_each_bit(e, n, bit) if (ebitmap_node_get_bit(n, bit)) \ +#define ebitmap_for_each_bit_after (e, n, bit, startnode, startbit) \ + n = startnode; \ + for (bit = ebitmap_next(&n, startbit); bit < ebitmap_length(e); bit = ebitmap_next(&n, bit)) \ + +#define ebitmap_for_each_positive_bit_after (e, n, bit, startnode, startbit) \ + ebitmap_for_each_bit_after(e, n, bit, startnode, startbit) if (ebitmap_node_get_bit(n, bit)) \ +extern int ebitmap_cmp (const ebitmap_t * e1,const ebitmap_t * e2);extern int ebitmap_or (ebitmap_t * dst,const ebitmap_t * e1,const ebitmap_t * e2);extern int ebitmap_union (ebitmap_t * dst,const ebitmap_t * e1);
Signature · 1 line
2.36.1
Re: [PATCH v3 2/8] libsepol: add ebitmap iterator wrapper with startnode
Quoted 19 lines · Christian Göttsche
Similar like
ebitmap_for_each_bit()iterates over all bits of an ebitmap addebitmap_for_each_bit_starting()iterating over all bits starting from a specific node and bit, which can be from an outer iteration.Signed-off-by Christian Göttsche <[email protected]>---
v2:
* use_aftersuffix
* reorder parameters--- libsepol/include/sepol/policydb/ebitmap.h | 7 +++++++ 1 file changed, 7 insertions(+)libsepol/include/sepol/policydb/ebitmap.h +0
-0
libsepol/include/sepol/policydb/ebitmap.h static inline int ebitmap_node_get_bit(const ebitmap_node_t * n, unsigned int bi · line 86
Quoted 7 lines
libsepol/include/sepol/policydb/ebitmap.h +4
-0@@ -80,6 +80,13 @@ static inline int ebitmap_node_get_bit(const ebitmap_node_t * n, unsigned int bi#define ebitmap_for_each_positive_bit (e, n, bit) \ ebitmap_for_each_bit(e, n, bit) if (ebitmap_node_get_bit(n, bit)) \ +#define ebitmap_for_each_bit_after (e, n, bit, startnode, startbit) \ + n = startnode; \ + for (bit = ebitmap_next(&n, startbit); bit < ebitmap_length(e); bit = ebitmap_next(&n, bit)) \ +
It would be better to only use one statement:
for (n = startnode, bit = ebitmap_next(&n, startbit); ...
Thanks,
Jim
Quoted 9 lines
libsepol/include/sepol/policydb/ebitmap.h +3
-1+#define ebitmap_for_each_positive_bit_after (e, n, bit, startnode, startbit) \ + ebitmap_for_each_bit_after(e, n, bit, startnode, startbit) if (ebitmap_node_get_bit(n, bit)) \ +extern int ebitmap_cmp (const ebitmap_t * e1,const ebitmap_t * e2);extern int ebitmap_or (ebitmap_t * dst,const ebitmap_t * e1,const ebitmap_t * e2);extern int ebitmap_union (ebitmap_t * dst,const ebitmap_t * e1); --2.36.1
PATCH v3 3/8 libsepol: add compile-time constraint for mutual exclusive attributes
In reply to Christian GöttscheAdd a new compile-time constraint, similar to neverallow, which enables to specify two or more type attributes to be mutual exclusive. This means no type can be associated with more than one of them.
The constraints are stored as a linked-list in the policy for modular policies, by a new modular policy version, and are discarded in kernel policies, not needing any kernel support.
Some Reference Policy examples:
unpriv_userdomain, admindomain:
<no violations>
client_packet_type, server_packet_type:
<no violations>
auth_file_type, non_auth_file_type:
<no violations>
pseudofs, xattrfs, noxattrfs:
<no violations>
reserved_port_type, unreserved_port_type:
<no violations>
security_file_type, non_security_file_type:
libsepol.check_segregate_attributes: Segregate Attributes violation, type dnssec_t associated with attributes security_file_type and non_security_file_type
ibendport_type, packet_type, sysctl_type, device_node, ibpkey_type, sysfs_types, domain, boolean_type, netif_type, file_type, node_type, proc_type, port_type:
libsepol.check_segregate_attributes: Segregate Attributes violation, type sysctl_fs_t associated with attributes sysctl_type and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type sysctl_t associated with attributes sysctl_type and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type virt_content_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type initrc_devpts_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type qemu_image_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type user_devpts_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type cardmgr_dev_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type bootloader_tmp_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type xen_image_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type svirt_prot_exec_image_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type xen_devpts_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type svirt_image_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type virt_image_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type container_file_t associated with attributes device_node and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type cpu_online_t associated with attributes sysfs_types and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type sysfs_t associated with attributes sysfs_types and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type dockerc_t associated with attributes domain and file_type libsepol.check_segregate_attributes: Segregate Attributes violation, type proc_t associated with attributes file_type and proc_type libsepol.check_segregate_attributes: Segregate Attributes violation, type proc_xen_t associated with attributes file_type and proc_type
libsepol.check_assertions: 20 Segregate Attributes failures occurred
---
v3:
- drop source location information:
this information was already lost for binary modular policies and CIL policies; also typeattribute statements have none and the few segregate_attributes statements can be easily grepped
- misc renaming
v2:
rebase onto _after suffix change
--- libsepol/include/sepol/policydb/policydb.h | 15 ++++- libsepol/src/assertion.c | 57 +++++++++++++--- libsepol/src/expand.c | 45 ++++++++++++- libsepol/src/kernel_to_conf.c | 38 ++++++++++- libsepol/src/link.c | 44 +++++++++++++ libsepol/src/policydb.c | 76 ++++++++++++++++++++++ libsepol/src/policydb_validate.c | 29 +++++++++ libsepol/src/write.c | 34 +++++++++- 8 files changed, 325 insertions(+), 13 deletions(-)
libsepol/include/sepol/policydb/policydb.h +14 -1
@@ -192,6 +192,12 @@ typedef struct type_datum {uint32_t bounds;/* bounds type, if exist */ } type_datum_t; +/* Mutual exclusive attributes */ +typedef struct segregate_attributes_rule { +ebitmap_t attrs;/* mutual exclusive attributes */ +struct segregate_attributes_rule *next; +}segregate_attributes_rule_t ; +/* * Properties of type_datum * available on the policy version >= (MOD_)POLICYDB_VERSION_BOUNDARY
@@ -605,6 +611,10 @@ typedef struct policydb {bitmaps. Someday the 0 bit may be used for global permissive */ ebitmap_t permissive_map; +/* mutual exclusive attributes (not preserved in kernel policy). +stored as linked list */ +segregate_attributes_rule_t *segregate_attributes; +unsigned policyvers;unsigned handle_unknown;
@@ -696,6 +706,8 @@ extern void level_datum_init(level_datum_t * x);extern void level_datum_destroy (level_datum_t * x);extern void cat_datum_init (cat_datum_t * x);extern void cat_datum_destroy (cat_datum_t * x); +extern void segregate_attributes_rule_init (segregate_attributes_rule_t * x); +extern void segregate_attributes_rule_destroy (segregate_attributes_rule_t * x);extern int check_assertion (policydb_t *p,avrule_t *avrule);extern int check_assertions (sepol_handle_t * handle,policydb_t * p,avrule_t * avrules);
@@ -783,9 +795,10 @@ extern int policydb_set_target_platform(policydb_t *p, int platform);#define MOD_POLICYDB_VERSION_INFINIBAND 19#define MOD_POLICYDB_VERSION_GLBLUB 20#define MOD_POLICYDB_VERSION_SELF_TYPETRANS 21 +#define MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES 22#define MOD_POLICYDB_VERSION_MIN MOD_POLICYDB_VERSION_BASE -#define MOD_POLICYDB_VERSION_MAX MOD_POLICYDB_VERSION_SELF_TYPETRANS +#define MOD_POLICYDB_VERSION_MAX MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES#define POLICYDB_CONFIG_MLS 1
libsepol/src/assertion.c +49 -8
80 lines not on this page · raw message
libsepol/src/expand.c +44 -1
63 lines not on this page · raw message
libsepol/src/kernel_to_conf.c +37 -1
@@ -1839,6 +1839,33 @@ exit:return rc; } +static int write_segregate_attributes_to_conf (FILE *out,const struct policydb *pdb) +{ +const segregate_attributes_rule_t *sattr; + +for (sattr = pdb->segregate_attributes; sattr; sattr = sattr->next) { +struct ebitmap_node *node; +unsigned int bit; +int first =1 ; + +sepol_printf (out,"segregate_attributes " ); + +ebitmap_for_each_positive_bit (&sattr->attrs, node, bit) { +if (first) { + first =0 ; + }else { +sepol_printf (out,", " ); + } + +sepol_printf (out,"%s" , pdb->p_type_val_to_name[bit -1 ]); + } + +sepol_printf (out,";\n" ); + } + +return 0 ; +} +struct map_filename_trans_args {struct policydb *pdb;struct strs *strs;
@@ -3200,7 +3227,16 @@ int sepol_kernel_policydb_to_conf(FILE *out, struct policydb *pdb)if (rc !=0 ) { goto exit; } -write_filename_trans_rules_to_conf (out, pdb); + + rc =write_segregate_attributes_to_conf (out, pdb); +if (rc !=0 ) { + goto exit; + } + + rc =write_filename_trans_rules_to_conf (out, pdb); +if (rc !=0 ) { + goto exit; + }if (pdb->mls) { rc =write_range_trans_rules_to_conf (out, pdb);
libsepol/src/link.c +44 -0
56 lines not on this page · raw message
libsepol/src/policydb.c +76 -0
118 lines not on this page · raw message
libsepol/src/policydb_validate.c +29 -0
@@ -1270,6 +1270,32 @@ bad:return -1 ; } +static int validate_segregate_attributes (sepol_handle_t *handle,policydb_t *p,validate_t flavors[]) +{ +segregate_attributes_rule_t *sattr; +ebitmap_node_t *node; +unsigned int i; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +if (ebitmap_cardinality (&sattr->attrs) <2 ) + goto bad; + +if (validate_ebitmap (&sattr->attrs, &flavors[SYM_TYPES ])) + goto bad; + +ebitmap_for_each_positive_bit (&sattr->attrs, node, i) { +if (p->type_val_to_struct[i]->flavor !=TYPE_ATTRIB ) + goto bad; + } + } + +return 0 ; + +bad: +ERR (handle,"Invalid segregate attributes definition" ); +return -1 ; +} +static int validate_properties (sepol_handle_t *handle,policydb_t *p) {switch (p->policy_type) {
@@ -1376,6 +1402,9 @@ int validate_policydb(sepol_handle_t *handle, policydb_t *p)if (validate_permissives (handle, p, flavors)) goto bad; +if (validate_segregate_attributes (handle, p, flavors)) + goto bad; +validate_array_destroy (flavors);return 0 ;
libsepol/src/write.c +32 -2
@@ -58,9 +58,9 @@ struct policy_data {static int avrule_write_list (policydb_t *p,avrule_t * avrules,struct policy_file *fp); -static int ebitmap_write (ebitmap_t * e,struct policy_file *fp) +static int ebitmap_write (const ebitmap_t * e,struct policy_file *fp) { -ebitmap_node_t *n; +const ebitmap_node_t *n;uint32_t buf[32 ], bit, count;uint64_t map;size_t items;
@@ -2191,6 +2191,30 @@ static int role_attr_uncount(hashtab_key_t key __attribute__ ((unused)),return 0 ; } +static int segregate_attributes_write (const policydb_t *p,struct policy_file *fp) +{ +const segregate_attributes_rule_t *sattr; +size_t items; +uint32_t buf, count =0 ; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +if (__builtin_add_overflow (count,1 , &count)) +return POLICYDB_ERROR ; + } + + buf =cpu_to_le32 (count); + items =put_entry (&buf,sizeof (uint32_t ),1 , fp); +if (items !=1 ) +return POLICYDB_ERROR ; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +if (ebitmap_write (&sattr->attrs, fp)) +return POLICYDB_ERROR ; + } + +return POLICYDB_SUCCESS ; +} +/* * Write the configuration data in a policy database * structure to a policy database binary representation
@@ -2413,5 +2437,11 @@ int policydb_write(policydb_t * p, struct policy_file *fp) } } +if (p->policyvers >=MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES && + p->policy_type !=POLICY_KERN ) { +if (segregate_attributes_write (p, fp)) +return POLICYDB_ERROR ; + } +return POLICYDB_SUCCESS ; }
Signature · 1 line
2.36.1
Re: [PATCH v3 3/8] libsepol: add compile-time constraint for mutual exclusive attributes
Quoted 64 lines · Christian Göttsche
Add a new compile-time constraint, similar to neverallow, which enables to specify two or more type attributes to be mutual exclusive. This means no type can be associated with more than one of them.
The constraints are stored as a linked-list in the policy for modular policies, by a new modular policy version, and are discarded in kernel policies, not needing any kernel support.
Some Reference Policy examples:
unpriv_userdomain, admindomain:<no violations>
client_packet_type,server_packet_type:<no violations>
auth_file_type,non_auth_file_type:<no violations>
pseudofs, xattrfs, noxattrfs:
<no violations>
reserved_port_type,unreserved_port_type:<no violations>
security_file_type,non_security_file_type:libsepol.check_segregate_attributes: Segregate Attributes violation, type
dnssec_tassociated with attributessecurity_file_typeandnon_security_file_type
ibendport_type,packet_type,sysctl_type,device_node,ibpkey_type,sysfs_types, domain,boolean_type,netif_type,file_type,node_type,proc_type,port_type:libsepol.check_segregate_attributes: Segregate Attributes violation, type
sysctl_fs_tassociated with attributessysctl_typeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typesysctl_tassociated with attributessysctl_typeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typevirt_content_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typeinitrc_devpts_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typeqemu_image_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typeuser_devpts_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typecardmgr_dev_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typebootloader_tmp_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typexen_image_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typesvirt_prot_exec_image_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typexen_devpts_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typesvirt_image_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typevirt_image_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typecontainer_file_tassociated with attributesdevice_nodeandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typecpu_online_tassociated with attributessysfs_typesandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typesysfs_tassociated with attributessysfs_typesandfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typedockerc_tassociated with attributes domain andfile_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typeproc_tassociated with attributesfile_typeandproc_typelibsepol.check_segregate_attributes: Segregate Attributes violation, typeproc_xen_tassociated with attributesfile_typeandproc_typelibsepol.check_assertions: 20 Segregate Attributes failures occurred
Signed-off-by Christian Göttsche <[email protected]>
Quoted 9 lines
---
v3:
- drop source location information:
this information was already lost for binary modular policies and CIL policies; also typeattribute statements have none and the fewsegregate_attributesstatements can be easily grepped
- misc renaming
v2:
rebase onto_aftersuffix change
I am not completely sold on this for a couple of reasons.
1) Neverallow rules express actual security goals.
2) Should we really keep adding more to the modular policy and policy.conf languages?
3) This can already be tested in CIL (but not as cleanly) (typeattribute disjoint_types)
(typeattributeset disjoint_types (and attr1 attr2)) (allow disjoint_types self (process (transition))) (neverallow disjoint_types self (process (transition)))
I would prefer "disjoint" to "segegrate" as well.
Thanks,
Jim
Quoted 574 lines
--- libsepol/include/sepol/policydb/policydb.h | 15 ++++- libsepol/src/assertion.c | 57 +++++++++++++--- libsepol/src/expand.c | 45 ++++++++++++- libsepol/src/kernel_to_conf.c | 38 ++++++++++- libsepol/src/link.c | 44 +++++++++++++ libsepol/src/policydb.c | 76 ++++++++++++++++++++++ libsepol/src/policydb_validate.c | 29 +++++++++ libsepol/src/write.c | 34 +++++++++- 8 files changed, 325 insertions(+), 13 deletions(-)libsepol/include/sepol/policydb/policydb.h +14
-1@@ -192,6 +192,12 @@ typedef struct type_datum {uint32_t bounds;/* bounds type, if exist */ } type_datum_t; +/* Mutual exclusive attributes */ +typedef struct segregate_attributes_rule { +ebitmap_t attrs;/* mutual exclusive attributes */ +struct segregate_attributes_rule *next; +}segregate_attributes_rule_t ; +/* * Properties of type_datum * available on the policy version >= (MOD_)POLICYDB_VERSION_BOUNDARY @@ -605,6 +611,10 @@ typedef struct policydb {bitmaps. Someday the 0 bit may be used for global permissive */ ebitmap_t permissive_map; +/* mutual exclusive attributes (not preserved in kernel policy). +stored as linked list */ +segregate_attributes_rule_t *segregate_attributes; +unsigned policyvers;unsigned handle_unknown;@@ -696,6 +706,8 @@ extern void level_datum_init(level_datum_t * x);extern void level_datum_destroy (level_datum_t * x);extern void cat_datum_init (cat_datum_t * x);extern void cat_datum_destroy (cat_datum_t * x); +extern void segregate_attributes_rule_init (segregate_attributes_rule_t * x); +extern void segregate_attributes_rule_destroy (segregate_attributes_rule_t * x);extern int check_assertion (policydb_t *p,avrule_t *avrule);extern int check_assertions (sepol_handle_t * handle,policydb_t * p,avrule_t * avrules);@@ -783,9 +795,10 @@ extern int policydb_set_target_platform(policydb_t *p, int platform);#define MOD_POLICYDB_VERSION_INFINIBAND 19#define MOD_POLICYDB_VERSION_GLBLUB 20#define MOD_POLICYDB_VERSION_SELF_TYPETRANS 21 +#define MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES 22#define MOD_POLICYDB_VERSION_MIN MOD_POLICYDB_VERSION_BASE -#define MOD_POLICYDB_VERSION_MAX MOD_POLICYDB_VERSION_SELF_TYPETRANS +#define MOD_POLICYDB_VERSION_MAX MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES#define POLICYDB_CONFIG_MLS 1libsepol/src/assertion.c +49
-8@@ -36,7 +36,7 @@ struct avtab_match_args {unsigned long errors; }; -static const char *policy_name (policydb_t *p) { +static const char *policy_name (const policydb_t *p) {const char *policy_file ="policy.conf" ;if (p->name) { policy_file = p->name;@@ -535,6 +535,44 @@ int check_assertion(policydb_t *p, avrule_t *avrule)return rc; } +static int check_segregate_attributes (sepol_handle_t *handle,const policydb_t *p) +{ +const segregate_attributes_rule_t *sattr; +int errors =0 , rc; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +ebitmap_node_t *first_node; +unsigned int first_bit; + +ebitmap_for_each_positive_bit (&sattr->attrs, first_node, first_bit) { +ebitmap_node_t *second_node; +unsigned int second_bit; + +ebitmap_for_each_positive_bit_after (&sattr->attrs, second_node, second_bit, first_node, first_bit) { +ebitmap_t attr_union; +ebitmap_node_t *type_node; +unsigned int type_bit; + + rc =ebitmap_and (&attr_union, &p->attr_type_map[first_bit], &p->attr_type_map[second_bit]); +if (rc <0 ) +return rc; + +ebitmap_for_each_positive_bit (&attr_union, type_node, type_bit) { +ERR (handle,"Segregate Attributes violation, type %s associated with attributes %s and %s" , + p->p_type_val_to_name[type_bit], + p->p_type_val_to_name[first_bit], + p->p_type_val_to_name[second_bit]); + errors++; + } + +ebitmap_destroy (&attr_union); + } + } + } + +return errors; +} +int check_assertions (sepol_handle_t * handle,policydb_t * p,avrule_t * avrules) {@@ -542,13 +580,6 @@ int check_assertions(sepol_handle_t * handle, policydb_t * p,avrule_t *a;unsigned long errors =0 ; -if (!avrules) { -/* Since assertions are stored in avrules, if it is NULL -there won't be any to check. This also prevents an invalid -free if the avtabs are never initialized */ -return 0 ; - } -for (a = avrules; a !=NULL ; a = a->next) {if (!(a->specified & (AVRULE_NEVERALLOW |AVRULE_XPERMS_NEVERALLOW )))continue ;@@ -570,5 +601,15 @@ int check_assertions(sepol_handle_t * handle, policydb_t * p,if (errors)ERR (handle,"%lu neverallow failures occurred" , errors); + rc =check_segregate_attributes (handle, p); +if (rc <0 ) { +ERR (handle,"Error occurred while checking Segregate Attributes" ); +return -1 ; + } +if (rc) { +ERR (handle,"%d Segregate Attributes failures occurred" , rc); + errors += rc; + } +return errors ?-1 :0 ; }libsepol/src/expand.c +44
-1@@ -56,7 +56,7 @@ static void expand_state_init(expand_state_t * state)memset (state,0 ,sizeof (expand_state_t)); } -static int map_ebitmap (ebitmap_t * src,ebitmap_t * dst,uint32_t * map) +static int map_ebitmap (const ebitmap_t * src,ebitmap_t * dst,const uint32_t * map) {unsigned int i;ebitmap_node_t *tnode;@@ -2341,6 +2341,45 @@ static int genfs_copy(expand_state_t * state)return 0 ; } +static int segregate_attributes_copy (expand_state_t *state) +{ +const segregate_attributes_rule_t *old; +segregate_attributes_rule_t *list =NULL ; + +for (old = state->base->segregate_attributes; old; old = old->next) { +segregate_attributes_rule_t *new; + + new =malloc (sizeof (segregate_attributes_rule_t)); +if (!new) { +ERR (state->handle,"Out of memory!" ); +return -1 ; + } + +segregate_attributes_rule_init (new); + +if (map_ebitmap (&old->attrs, &new->attrs, state->typemap)) { +ERR (state->handle,"out of memory" ); +ebitmap_destroy (&new->attrs); +free (new); +return -1 ; + } + +if (list) + list->next = new; +else { +if (state->out->segregate_attributes) { +segregate_attributes_rule_t *s; +for (s = state->out->segregate_attributes; s->next; s = s->next) {} + s->next = new; + }else + state->out->segregate_attributes = new; + } + list = new; + } + +return 0 ; +} +static int type_attr_map (hashtab_key_t key __attribute__ ((unused)),hashtab_datum_t datum,void *ptr)@@ -3173,6 +3212,10 @@ int expand_module(sepol_handle_t * handle,if (genfs_copy (&state)) goto cleanup; +/* copy segregate attributes */ +if (segregate_attributes_copy (&state)) + goto cleanup; +/* Build the type<->attribute maps and remove attributes. */ state.out->attr_type_map =calloc (state.out->p_types.nprim,sizeof (ebitmap_t));libsepol/src/kernel_to_conf.c +37
-1@@ -1839,6 +1839,33 @@ exit:return rc; } +static int write_segregate_attributes_to_conf (FILE *out,const struct policydb *pdb) +{ +const segregate_attributes_rule_t *sattr; + +for (sattr = pdb->segregate_attributes; sattr; sattr = sattr->next) { +struct ebitmap_node *node; +unsigned int bit; +int first =1 ; + +sepol_printf (out,"segregate_attributes " ); + +ebitmap_for_each_positive_bit (&sattr->attrs, node, bit) { +if (first) { + first =0 ; + }else { +sepol_printf (out,", " ); + } + +sepol_printf (out,"%s" , pdb->p_type_val_to_name[bit -1 ]); + } + +sepol_printf (out,";\n" ); + } + +return 0 ; +} +struct map_filename_trans_args {struct policydb *pdb;struct strs *strs;@@ -3200,7 +3227,16 @@ int sepol_kernel_policydb_to_conf(FILE *out, struct policydb *pdb)if (rc !=0 ) { goto exit; } -write_filename_trans_rules_to_conf (out, pdb); + + rc =write_segregate_attributes_to_conf (out, pdb); +if (rc !=0 ) { + goto exit; + } + + rc =write_filename_trans_rules_to_conf (out, pdb); +if (rc !=0 ) { + goto exit; + }if (pdb->mls) { rc =write_range_trans_rules_to_conf (out, pdb);libsepol/src/link.c +44
-0@@ -1857,6 +1857,45 @@ static int scope_copy_callback(hashtab_key_t key, hashtab_datum_t datum,return -1 ; } +static int copy_segregate_attributes (link_state_t * state,const policy_module_t *module) +{ +const segregate_attributes_rule_t *src_sattr; +segregate_attributes_rule_t *list =NULL ; + +for (src_sattr = module->policy->segregate_attributes; src_sattr; src_sattr = src_sattr->next) { +segregate_attributes_rule_t *new_sattr; + + new_sattr =malloc (sizeof (segregate_attributes_rule_t)); +if (!new_sattr) { +ERR (state->handle,"Out of memory!" ); +return -1 ; + } + +segregate_attributes_rule_init (new_sattr); + +if (ebitmap_convert (&src_sattr->attrs, &new_sattr->attrs, module->map[SYM_TYPES ])) { +ebitmap_destroy (&new_sattr->attrs); +free (new_sattr); +ERR (state->handle,"Out of memory!" ); +return -1 ; + } + +if (list) + list->next = new_sattr; +else { +if (state->base->segregate_attributes) { +segregate_attributes_rule_t *s; +for (s = state->base->segregate_attributes; s->next; s = s->next) {} + s->next = new_sattr; + }else + state->base->segregate_attributes = new_sattr; + } + list = new_sattr; + } + +return 0 ; +} +/* Copy a module over to a base, remapping all values within. After * all identifiers and rules are done, copy the scoping information. * This is when it checks for duplicate declarations. */ @@ -1891,6 +1930,11 @@ static int copy_module(link_state_t * state, policy_module_t * module) } } + ret =copy_segregate_attributes (state, module); +if (ret) { +return ret; + } +return 0 ; }libsepol/src/policydb.c +76
-0@@ -334,6 +334,13 @@ static const struct policydb_compat_info policydb_compat[] = { .ocon_num = OCON_IBENDPORT + 1, .target_platform = SEPOL_TARGET_SELINUX, }, + { + .type = POLICY_BASE, + .version = MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES, + .sym_num = SYM_NUM, + .ocon_num = OCON_IBENDPORT + 1, + .target_platform = SEPOL_TARGET_SELINUX, + }, { .type = POLICY_MOD, .version = MOD_POLICYDB_VERSION_BASE,@@ -460,6 +467,13 @@ static const struct policydb_compat_info policydb_compat[] = { .ocon_num = 0, .target_platform = SEPOL_TARGET_SELINUX, }, + { + .type = POLICY_MOD, + .version = MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES, + .sym_num = SYM_NUM, + .ocon_num = 0, + .target_platform = SEPOL_TARGET_SELINUX, + }, };#if 0 @@ -760,6 +774,20 @@ void avrule_list_destroy(avrule_t * x) } } +void segregate_attributes_rule_init (segregate_attributes_rule_t * x) +{ +ebitmap_init (&x->attrs); + x->next =NULL ; +} + + +void segregate_attributes_rule_destroy (segregate_attributes_rule_t * x) +{ +if (!x) +return ; +ebitmap_destroy (&x->attrs); +} +/* * Initialize the role table by implicitly adding role 'object_r'. If * the policy is a module, set object_r's scope to be SCOPE_REQ, @@ -1492,6 +1520,7 @@ void policydb_destroy(policydb_t * p)unsigned int i;role_allow_t *ra, *lra =NULL ;role_trans_t *tr, *ltr =NULL ; +segregate_attributes_rule_t *sattr, *sattr_next;if (!p)return ;@@ -1585,6 +1614,12 @@ void policydb_destroy(policydb_t * p)free (p->attr_type_map); } +for (sattr = p->segregate_attributes; sattr; sattr = sattr_next) { + sattr_next = sattr->next; +segregate_attributes_rule_destroy (sattr); +free (sattr); + } +return ; }@@ -4174,6 +4209,41 @@ static int scope_read(policydb_t * p, int symnum, struct policy_file *fp)return -1 ; } +static int segregate_attributes_read (policydb_t * p,struct policy_file *fp) +{ +segregate_attributes_rule_t *list =NULL ; +uint32_t buf, nel, i; +int rc; + + rc =next_entry (&buf, fp,sizeof (uint32_t )); +if (rc <0 ) +return -1 ; + nel =le32_to_cpu (buf); +for (i =0 ; i < nel; i++) { +segregate_attributes_rule_t *sattr; + + sattr =malloc (sizeof (segregate_attributes_rule_t)); +if (!sattr) +return -1 ; + +segregate_attributes_rule_init (sattr); + +if (ebitmap_read (&sattr->attrs, fp) <0 ) { +ebitmap_destroy (&sattr->attrs); +free (sattr); +return -1 ; + } + +if (list) + list->next = sattr; +else + p->segregate_attributes = sattr; + list = sattr; + } + +return 0 ; +} +static sepol_security_class_t policydb_string_to_security_class (struct policydb *policydb,const char *class_name)@@ -4570,6 +4640,12 @@ int policydb_read(policydb_t * p, struct policy_file *fp, unsigned verbose) } } +if (p->policyvers >=MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES && + p->policy_type !=POLICY_KERN ) { +if (segregate_attributes_read (p, fp)) +return POLICYDB_ERROR ; + } +if (validate_policydb (fp->handle, p)) goto bad;libsepol/src/policydb_validate.c +29
-0@@ -1270,6 +1270,32 @@ bad:return -1 ; } +static int validate_segregate_attributes (sepol_handle_t *handle,policydb_t *p,validate_t flavors[]) +{ +segregate_attributes_rule_t *sattr; +ebitmap_node_t *node; +unsigned int i; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +if (ebitmap_cardinality (&sattr->attrs) <2 ) + goto bad; + +if (validate_ebitmap (&sattr->attrs, &flavors[SYM_TYPES ])) + goto bad; + +ebitmap_for_each_positive_bit (&sattr->attrs, node, i) { +if (p->type_val_to_struct[i]->flavor !=TYPE_ATTRIB ) + goto bad; + } + } + +return 0 ; + +bad: +ERR (handle,"Invalid segregate attributes definition" ); +return -1 ; +} +static int validate_properties (sepol_handle_t *handle,policydb_t *p) {switch (p->policy_type) {@@ -1376,6 +1402,9 @@ int validate_policydb(sepol_handle_t *handle, policydb_t *p)if (validate_permissives (handle, p, flavors)) goto bad; +if (validate_segregate_attributes (handle, p, flavors)) + goto bad; +validate_array_destroy (flavors);return 0 ;libsepol/src/write.c +32
-3@@ -58,9 +58,9 @@ struct policy_data {static int avrule_write_list (policydb_t *p,avrule_t * avrules,struct policy_file *fp); -static int ebitmap_write (ebitmap_t * e,struct policy_file *fp) +static int ebitmap_write (const ebitmap_t * e,struct policy_file *fp) { -ebitmap_node_t *n; +const ebitmap_node_t *n;uint32_t buf[32 ], bit, count;uint64_t map;size_t items;@@ -2191,6 +2191,30 @@ static int role_attr_uncount(hashtab_key_t key __attribute__ ((unused)),return 0 ; } +static int segregate_attributes_write (const policydb_t *p,struct policy_file *fp) +{ +const segregate_attributes_rule_t *sattr; +size_t items; +uint32_t buf, count =0 ; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +if (__builtin_add_overflow (count,1 , &count)) +return POLICYDB_ERROR ; + } + + buf =cpu_to_le32 (count); + items =put_entry (&buf,sizeof (uint32_t ),1 , fp); +if (items !=1 ) +return POLICYDB_ERROR ; + +for (sattr = p->segregate_attributes; sattr; sattr = sattr->next) { +if (ebitmap_write (&sattr->attrs, fp)) +return POLICYDB_ERROR ; + } + +return POLICYDB_SUCCESS ; +} +/* * Write the configuration data in a policy database * structure to a policy database binary representation @@ -2413,5 +2437,11 @@ int policydb_write(policydb_t * p, struct policy_file *fp) } } +if (p->policyvers >=MOD_POLICYDB_VERSION_SEGREGATE_ATTRIBUTES && + p->policy_type !=POLICY_KERN ) { +if (segregate_attributes_write (p, fp)) +return POLICYDB_ERROR ; + } +return POLICYDB_SUCCESS ; } --2.36.1
PATCH v3 4/8 checkpolicy: add front-end support for segregate attributes
In reply to Christian GöttscheSupport specifying segregate attributes.
The following two blocks are equivalent:
segregate_attributes attr1, attr2, attr3;
segregate_attributes attr1, attr2;
segregate_attributes attr1, attr3;
segregate_attributes attr2, attr3;--- checkpolicy/policy_define.c | 66 +++++++++++++++++++++++++++++++++++++ checkpolicy/policy_define.h | 1 + checkpolicy/policy_parse.y | 5 +++ checkpolicy/policy_scan.l | 2 ++ 4 files changed, 74 insertions(+)
checkpolicy/policy_define.c +66 -0
@@ -1220,6 +1220,72 @@ exit:return rc; } +int define_segregate_attributes (void ) +{ +char *id =NULL ; +segregate_attributes_rule_t *sattr =NULL ; +int rc =-1 ; + +if (pass ==1 ) { +while ((id =queue_remove (id_queue))) +free (id); +return 0 ; + } + + sattr =malloc (sizeof (segregate_attributes_rule_t)); +if (!sattr) { +yyerror ("Out of memory!" ); + goto exit; + } + +ebitmap_init (&sattr->attrs); + +while ((id =queue_remove (id_queue))) { +const type_datum_t *attr; + +if (!is_id_in_scope (SYM_TYPES , id)) { +yyerror2 ("attribute %s is not within scope" , id); + goto exit; + } + + attr =hashtab_search (policydbp->p_types.table, id); +if (!attr) { +yyerror2 ("attribute %s is not declared" , id); + goto exit; + } + +if (attr->flavor !=TYPE_ATTRIB ) { +yyerror2 ("%s is a type, not an attribute" , id); + goto exit; + } + +if (ebitmap_get_bit (&sattr->attrs, attr->s.value -1 )) { +yyerror2 ("attribute %s used multiple times" , id); + goto exit; + } + +if (ebitmap_set_bit (&sattr->attrs, attr->s.value -1 , TRUE)) { +yyerror ("Out of memory!" ); + goto exit; + } + +free (id); + } + + sattr->next = policydbp->segregate_attributes; + policydbp->segregate_attributes = sattr; + + sattr =NULL ; + rc =0 ; +exit: +if (sattr) { +ebitmap_destroy (&sattr->attrs); +free (sattr); + } +free (id); +return rc; +} +static int add_aliases_to_type (type_datum_t * type) {char *id;
checkpolicy/policy_define.h +1 -0
@@ -68,6 +68,7 @@ int define_type(int alias);int define_user (void );int define_validatetrans (constraint_expr_t *expr);int expand_attrib (void ); +int define_segregate_attributes (void );int insert_id (const char *id,int push);int insert_separator (int push);role_datum_t *define_role_dom (role_datum_t *r);
checkpolicy/policy_parse.y +5 -0
@@ -104,6 +104,7 @@ typedef int (* require_func_t)(int pass); %token ALIAS %token ATTRIBUTE %token EXPANDATTRIBUTE +%token SEGREGATEATTRIBUTES %token BOOL %token TUNABLE %token IF
@@ -320,6 +321,7 @@ rbac_decl : attribute_role_def ; te_decl : attribute_def | expandattribute_def + | segregateattributes_def | type_def | typealias_def | typeattribute_def
@@ -337,6 +339,9 @@ attribute_def : ATTRIBUTE identifier ';' expandattribute_def : EXPANDATTRIBUTE names bool_val ';' { if (expand_attrib()) return -1;} ; +segregateattributes_def : SEGREGATEATTRIBUTES identifier ',' id_comma_list ';' + { if (define_segregate_attributes()) return -1;} + ; type_def : TYPE identifier alias_def opt_attr_list ';' {if (define_type(1)) return -1;} | TYPE identifier opt_attr_list ';'
checkpolicy/policy_scan.l +2 -0
@@ -123,6 +123,8 @@ ATTRIBUTE | attribute { return(ATTRIBUTE); } EXPANDATTRIBUTE | expandattribute { return(EXPANDATTRIBUTE); } +SEGREGATE_ATTRIBUTES | +segregate_attributes { return(SEGREGATEATTRIBUTES); } TYPE_TRANSITION | type_transition { return(TYPE_TRANSITION); } TYPE_MEMBER |
Signature · 1 line
2.36.1
Re: [PATCH v3 4/8] checkpolicy: add front-end support for segregate attributes
Quoted 56 lines · Christian Göttsche
Support specifying segregate attributes.
The following two blocks are equivalent:
segregate_attributes attr1, attr2, attr3; segregate_attributes attr1, attr2; segregate_attributes attr1, attr3; segregate_attributes attr2, attr3;Signed-off-by Christian Göttsche <[email protected]>--- checkpolicy/policy_define.c | 66 +++++++++++++++++++++++++++++++++++++ checkpolicy/policy_define.h | 1 + checkpolicy/policy_parse.y | 5 +++ checkpolicy/policy_scan.l | 2 ++ 4 files changed, 74 insertions(+)checkpolicy/policy_define.c +29
-0@@ -1220,6 +1220,72 @@ exit:return rc; } +int define_segregate_attributes (void ) +{ +char *id =NULL ; +segregate_attributes_rule_t *sattr =NULL ; +int rc =-1 ; + +if (pass ==1 ) { +while ((id =queue_remove (id_queue))) +free (id); +return 0 ; + } + + sattr =malloc (sizeof (segregate_attributes_rule_t)); +if (!sattr) { +yyerror ("Out of memory!" ); + goto exit; + } + +ebitmap_init (&sattr->attrs); + +while ((id =queue_remove (id_queue))) { +const type_datum_t *attr; + +if (!is_id_in_scope (SYM_TYPES , id)) { +yyerror2 ("attribute %s is not within scope" , id); + goto exit; + } + + attr =hashtab_search (policydbp->p_types.table, id);
checkpolicy/policy_define.c exit: · line 1261
Quoted 10 lines
checkpolicy/policy_define.c +10
-0+if (!attr) { +yyerror2 ("attribute %s is not declared" , id); + goto exit; + } + +if (attr->flavor !=TYPE_ATTRIB ) { +yyerror2 ("%s is a type, not an attribute" , id); + goto exit; + } +
It seems like it would be useful to check a type, so an error would be given if the type is associated with the attribute.
Quoted 63 lines
checkpolicy/policy_define.c +27
-0+if (ebitmap_get_bit (&sattr->attrs, attr->s.value -1 )) { +yyerror2 ("attribute %s used multiple times" , id); + goto exit; + } + +if (ebitmap_set_bit (&sattr->attrs, attr->s.value -1 , TRUE)) { +yyerror ("Out of memory!" ); + goto exit; + } + +free (id); + } + + sattr->next = policydbp->segregate_attributes; + policydbp->segregate_attributes = sattr; + + sattr =NULL ; + rc =0 ; +exit: +if (sattr) { +ebitmap_destroy (&sattr->attrs); +free (sattr); + } +free (id); +return rc; +} +static int add_aliases_to_type (type_datum_t * type) {char *id;checkpolicy/policy_define.h +1
-0@@ -68,6 +68,7 @@ int define_type(int alias);int define_user (void );int define_validatetrans (constraint_expr_t *expr);int expand_attrib (void ); +int define_segregate_attributes (void );int insert_id (const char *id,int push);int insert_separator (int push);role_datum_t *define_role_dom (role_datum_t *r);checkpolicy/policy_parse.y +2
-0@@ -104,6 +104,7 @@ typedef int (* require_func_t)(int pass); %token ALIAS %token ATTRIBUTE %token EXPANDATTRIBUTE +%token SEGREGATEATTRIBUTES %token BOOL %token TUNABLE %token IF@@ -320,6 +321,7 @@ rbac_decl : attribute_role_def ; te_decl : attribute_def | expandattribute_def + | segregateattributes_def | type_def | typealias_def | typeattribute_def
checkpolicy/policy_parse.y attribute_def : ATTRIBUTE identifier ';' · line 344
Quoted 6 lines
checkpolicy/policy_parse.y +3
-0@@ -337,6 +339,9 @@ attribute_def : ATTRIBUTE identifier ';' expandattribute_def : EXPANDATTRIBUTE names bool_val ';' { if (expand_attrib()) return -1;} ; +segregateattributes_def : SEGREGATEATTRIBUTES identifier ',' id_comma_list ';' + { if (define_segregate_attributes()) return -1;} +
I don't see the need for comparing more than two at a time.
Something like:disjoint_types attr1 attr2;
Thanks,
Jim
;
Quoted 19 lines
checkpolicy/policy_parse.y +0
-0type_def : TYPE identifier alias_def opt_attr_list ';' {if (define_type(1)) return -1;} | TYPE identifier opt_attr_list ';'checkpolicy/policy_scan.l +2
-1@@ -123,6 +123,8 @@ ATTRIBUTE | attribute { return(ATTRIBUTE); } EXPANDATTRIBUTE | expandattribute { return(EXPANDATTRIBUTE); } +SEGREGATE_ATTRIBUTES | +segregate_attributes { return(SEGREGATEATTRIBUTES); } TYPE_TRANSITION | type_transition { return(TYPE_TRANSITION); } TYPE_MEMBER | --2.36.1
Re: [PATCH v3 4/8] checkpolicy: add front-end support for segregate attributes
Quoted 64 lines · James Carter
Quoted 61 lines · Christian Göttsche
Support specifying segregate attributes.
The following two blocks are equivalent:
segregate_attributes attr1, attr2, attr3; segregate_attributes attr1, attr2; segregate_attributes attr1, attr3; segregate_attributes attr2, attr3;Signed-off-by Christian Göttsche <[email protected]>--- checkpolicy/policy_define.c | 66 +++++++++++++++++++++++++++++++++++++ checkpolicy/policy_define.h | 1 + checkpolicy/policy_parse.y | 5 +++ checkpolicy/policy_scan.l | 2 ++ 4 files changed, 74 insertions(+)checkpolicy/policy_define.c +34
-0@@ -1220,6 +1220,72 @@ exit:return rc; } +int define_segregate_attributes (void ) +{ +char *id =NULL ; +segregate_attributes_rule_t *sattr =NULL ; +int rc =-1 ; + +if (pass ==1 ) { +while ((id =queue_remove (id_queue))) +free (id); +return 0 ; + } + + sattr =malloc (sizeof (segregate_attributes_rule_t)); +if (!sattr) { +yyerror ("Out of memory!" ); + goto exit; + } + +ebitmap_init (&sattr->attrs); + +while ((id =queue_remove (id_queue))) { +const type_datum_t *attr; + +if (!is_id_in_scope (SYM_TYPES , id)) { +yyerror2 ("attribute %s is not within scope" , id); + goto exit; + } + + attr =hashtab_search (policydbp->p_types.table, id); +if (!attr) { +yyerror2 ("attribute %s is not declared" , id); + goto exit; + } +
Quoted 9 lines
checkpolicy/policy_define.c exit: · line 1261
Quoted 5 lines
checkpolicy/policy_define.c +5
-0+if (attr->flavor !=TYPE_ATTRIB ) { +yyerror2 ("%s is a type, not an attribute" , id); + goto exit; + } +It seems like it would be useful to check a type, so an error would be given if the type is associated with the attribute.
I am not exactly sure what you mean.
Do you like to have a policy statement like
nevertypeattribute TYPE ATTRIBUTE;
that checks at compile time a type is not associated with an attribute?
Quoted 72 lines
Quoted 63 lines
checkpolicy/policy_define.c +27
-0+if (ebitmap_get_bit (&sattr->attrs, attr->s.value -1 )) { +yyerror2 ("attribute %s used multiple times" , id); + goto exit; + } + +if (ebitmap_set_bit (&sattr->attrs, attr->s.value -1 , TRUE)) { +yyerror ("Out of memory!" ); + goto exit; + } + +free (id); + } + + sattr->next = policydbp->segregate_attributes; + policydbp->segregate_attributes = sattr; + + sattr =NULL ; + rc =0 ; +exit: +if (sattr) { +ebitmap_destroy (&sattr->attrs); +free (sattr); + } +free (id); +return rc; +} +static int add_aliases_to_type (type_datum_t * type) {char *id;checkpolicy/policy_define.h +1
-0@@ -68,6 +68,7 @@ int define_type(int alias);int define_user (void );int define_validatetrans (constraint_expr_t *expr);int expand_attrib (void ); +int define_segregate_attributes (void );int insert_id (const char *id,int push);int insert_separator (int push);role_datum_t *define_role_dom (role_datum_t *r);checkpolicy/policy_parse.y +2
-0@@ -104,6 +104,7 @@ typedef int (* require_func_t)(int pass); %token ALIAS %token ATTRIBUTE %token EXPANDATTRIBUTE +%token SEGREGATEATTRIBUTES %token BOOL %token TUNABLE %token IF@@ -320,6 +321,7 @@ rbac_decl : attribute_role_def ; te_decl : attribute_def | expandattribute_def + | segregateattributes_def | type_def | typealias_def | typeattribute_defcheckpolicy/policy_parse.y attribute_def : ATTRIBUTE identifier ';' · line 344
Quoted 6 lines
checkpolicy/policy_parse.y +3
-0@@ -337,6 +339,9 @@ attribute_def : ATTRIBUTE identifier ';' expandattribute_def : EXPANDATTRIBUTE names bool_val ';' { if (expand_attrib()) return -1;} ; +segregateattributes_def : SEGREGATEATTRIBUTES identifier ',' id_comma_list ';' + { if (define_segregate_attributes()) return -1;} +I don't see the need for comparing more than two at a time.
Quoted 2 lines
Something like:
disjoint_typesattr1 attr2;
That would lead to quadratic growth of statements, for example in the Reference Policy example of
ibendport_type, packet_type, sysctl_type, device_node,ibpkey_type, sysfs_types, domain, boolean_type, netif_type, file_type, node_type, proc_type, port_type
Also one could see supporting more than two attributes as syntactic sugar, which the traditional language already supports, e.g.
allow { TYPE1 TYPE2 } { TYPE3 TYPE4 } : { CLASS1 CLASS2 } perm_list;Quoted 24 lines
Thanks,
Jim;Quoted 19 lines
checkpolicy/policy_parse.y +0
-0type_def : TYPE identifier alias_def opt_attr_list ';' {if (define_type(1)) return -1;} | TYPE identifier opt_attr_list ';'checkpolicy/policy_scan.l +2
-1@@ -123,6 +123,8 @@ ATTRIBUTE | attribute { return(ATTRIBUTE); } EXPANDATTRIBUTE | expandattribute { return(EXPANDATTRIBUTE); } +SEGREGATE_ATTRIBUTES | +segregate_attributes { return(SEGREGATEATTRIBUTES); } TYPE_TRANSITION | type_transition { return(TYPE_TRANSITION); } TYPE_MEMBER | --2.36.1
Re: [PATCH v3 4/8] checkpolicy: add front-end support for segregate attributes
Quoted 161 lines · Christian Göttsche
Quoted 64 lines · James Carter
Quoted 61 lines · Christian Göttsche
Support specifying segregate attributes.
The following two blocks are equivalent:
segregate_attributes attr1, attr2, attr3; segregate_attributes attr1, attr2; segregate_attributes attr1, attr3; segregate_attributes attr2, attr3;Signed-off-by Christian Göttsche <[email protected]>--- checkpolicy/policy_define.c | 66 +++++++++++++++++++++++++++++++++++++ checkpolicy/policy_define.h | 1 + checkpolicy/policy_parse.y | 5 +++ checkpolicy/policy_scan.l | 2 ++ 4 files changed, 74 insertions(+)checkpolicy/policy_define.c +34
-0@@ -1220,6 +1220,72 @@ exit:return rc; } +int define_segregate_attributes (void ) +{ +char *id =NULL ; +segregate_attributes_rule_t *sattr =NULL ; +int rc =-1 ; + +if (pass ==1 ) { +while ((id =queue_remove (id_queue))) +free (id); +return 0 ; + } + + sattr =malloc (sizeof (segregate_attributes_rule_t)); +if (!sattr) { +yyerror ("Out of memory!" ); + goto exit; + } + +ebitmap_init (&sattr->attrs); + +while ((id =queue_remove (id_queue))) { +const type_datum_t *attr; + +if (!is_id_in_scope (SYM_TYPES , id)) { +yyerror2 ("attribute %s is not within scope" , id); + goto exit; + } + + attr =hashtab_search (policydbp->p_types.table, id); +if (!attr) { +yyerror2 ("attribute %s is not declared" , id); + goto exit; + } +Quoted 9 lines
checkpolicy/policy_define.c exit: · line 1261
Quoted 5 lines
checkpolicy/policy_define.c +5
-0+if (attr->flavor !=TYPE_ATTRIB ) { +yyerror2 ("%s is a type, not an attribute" , id); + goto exit; + } +It seems like it would be useful to check a type, so an error would be given if the type is associated with the attribute.
I am not exactly sure what you mean.
Do you like to have a policy statement likenevertypeattribute TYPE ATTRIBUTE;that checks at compile time a type is not associated with an attribute?
Quoted 72 lines
Quoted 63 lines
checkpolicy/policy_define.c +27
-0+if (ebitmap_get_bit (&sattr->attrs, attr->s.value -1 )) { +yyerror2 ("attribute %s used multiple times" , id); + goto exit; + } + +if (ebitmap_set_bit (&sattr->attrs, attr->s.value -1 , TRUE)) { +yyerror ("Out of memory!" ); + goto exit; + } + +free (id); + } + + sattr->next = policydbp->segregate_attributes; + policydbp->segregate_attributes = sattr; + + sattr =NULL ; + rc =0 ; +exit: +if (sattr) { +ebitmap_destroy (&sattr->attrs); +free (sattr); + } +free (id); +return rc; +} +static int add_aliases_to_type (type_datum_t * type) {char *id;checkpolicy/policy_define.h +1
-0@@ -68,6 +68,7 @@ int define_type(int alias);int define_user (void );int define_validatetrans (constraint_expr_t *expr);int expand_attrib (void ); +int define_segregate_attributes (void );int insert_id (const char *id,int push);int insert_separator (int push);role_datum_t *define_role_dom (role_datum_t *r);checkpolicy/policy_parse.y +2
-0@@ -104,6 +104,7 @@ typedef int (* require_func_t)(int pass); %token ALIAS %token ATTRIBUTE %token EXPANDATTRIBUTE +%token SEGREGATEATTRIBUTES %token BOOL %token TUNABLE %token IF@@ -320,6 +321,7 @@ rbac_decl : attribute_role_def ; te_decl : attribute_def | expandattribute_def + | segregateattributes_def | type_def | typealias_def | typeattribute_defcheckpolicy/policy_parse.y attribute_def : ATTRIBUTE identifier ';' · line 344
Quoted 6 lines
checkpolicy/policy_parse.y +3
-0@@ -337,6 +339,9 @@ attribute_def : ATTRIBUTE identifier ';' expandattribute_def : EXPANDATTRIBUTE names bool_val ';' { if (expand_attrib()) return -1;} ; +segregateattributes_def : SEGREGATEATTRIBUTES identifier ',' id_comma_list ';' + { if (define_segregate_attributes()) return -1;} +I don't see the need for comparing more than two at a time.
Quoted 2 lines
Something like:
disjoint_typesattr1 attr2;That would lead to quadratic growth of statements, for example in the Reference Policy example of
Quoted 9 lines
ibendport_type,packet_type,sysctl_type,device_node,ibpkey_type,sysfs_types, domain,boolean_type,netif_type,file_type,node_type,proc_type,port_typeAlso one could see supporting more than two attributes as syntactic sugar, which the traditional language already supports, e.g.
allow { TYPE1 TYPE2 } { TYPE3 TYPE4 } : { CLASS1 CLASS2 } perm_list;
The case above would be a pain to do and making it a list would be better. I guess using a list is not that big of a deal.
The problem with checking that attributes are disjoint is that it does not tell me *why* they should be disjoint.
It would be better to use more neverallow rules because they express the goals of the security policy.
If a neverallow rule cannot be written to say why two attributes should be disjoint, then either the policy is not fine-grained enough for it to matter or there is a problem with the policy.
Jim
Quoted 24 lines
Quoted 24 lines
Thanks,
Jim;Quoted 19 lines
checkpolicy/policy_parse.y +0
-0type_def : TYPE identifier alias_def opt_attr_list ';' {if (define_type(1)) return -1;} | TYPE identifier opt_attr_list ';'checkpolicy/policy_scan.l +2
-1@@ -123,6 +123,8 @@ ATTRIBUTE | attribute { return(ATTRIBUTE); } EXPANDATTRIBUTE | expandattribute { return(EXPANDATTRIBUTE); } +SEGREGATE_ATTRIBUTES | +segregate_attributes { return(SEGREGATEATTRIBUTES); } TYPE_TRANSITION | type_transition { return(TYPE_TRANSITION); } TYPE_MEMBER | --2.36.1
PATCH v3 5/8 libsepol/tests: add test for segregate attributes
In reply to Christian Göttsche--- libsepol/tests/libsepol-tests.c | 2 + .../tests/policies/test-sattrs/single.conf | 87 ++++++++ .../policies/test-sattrs/split_base.conf | 53 +++++ .../policies/test-sattrs/split_module1.conf | 9 + .../policies/test-sattrs/split_module2.conf | 9 + .../policies/test-sattrs/split_module3.conf | 9 + libsepol/tests/test-segregateattributes.c | 197 ++++++++++++++++++ libsepol/tests/test-segregateattributes.h | 10 + 8 files changed, 376 insertions(+) create mode 100644 libsepol/tests/policies/test-sattrs/single.conf create mode 100644 libsepol/tests/policies/test-sattrs/split_base.conf create mode 100644 libsepol/tests/policies/test-sattrs/split_module1.conf create mode 100644 libsepol/tests/policies/test-sattrs/split_module2.conf create mode 100644 libsepol/tests/policies/test-sattrs/split_module3.conf create mode 100644 libsepol/tests/test-segregateattributes.c create mode 100644 libsepol/tests/test-segregateattributes.h
libsepol/tests/libsepol-tests.c +2 -0
@@ -23,6 +23,7 @@#include "test-expander.h" #include "test-deps.h" #include "test-downgrade.h" +#include "test-segregateattributes.h" #include <CUnit/Basic.h> #include <CUnit/Console.h>
@@ -69,6 +70,7 @@ static bool do_tests(int interactive, int verbose)DECLARE_SUITE (expander);DECLARE_SUITE (deps);DECLARE_SUITE (downgrade); +DECLARE_SUITE (sattrs);if (verbose)CU_basic_set_mode (CU_BRM_VERBOSE );
libsepol/tests/policies/test-sattrs/single.conf new file +87 -0
87 lines not on this page · raw message
libsepol/tests/policies/test-sattrs/split_base.conf new file +53 -0
53 lines not on this page · raw message
libsepol/tests/policies/test-sattrs/split_module1.conf new file +9 -0
@@ -0,0 +1,9 @@ +module sattrs_test_1 1.0; + +require { + type test_type_t; +} + +attribute attr1; + +typeattribute test_type_t attr1;
libsepol/tests/policies/test-sattrs/split_module2.conf new file +9 -0
@@ -0,0 +1,9 @@ +module sattrs_test_2 1.0; + +require { + type test_type_t; +} + +attribute attr2; + +typeattribute test_type_t attr2;
libsepol/tests/policies/test-sattrs/split_module3.conf new file +9 -0
@@ -0,0 +1,9 @@ +module sattrs_test_3 1.0; + +require { + attribute attr1, attr2; +} + +type test_type_t; + +segregate_attributes attr1, attr2;
libsepol/tests/test-segregateattributes.c new file +197 -0
197 lines not on this page · raw message
libsepol/tests/test-segregateattributes.h new file +10 -0
@@ -0,0 +1,10 @@ +#ifndef TEST_SEGREGATEATTRIBUTES_H__ +#define TEST_SEGREGATEATTRIBUTES_H__ + +#include <CUnit/Basic.h> + +int sattrs_test_init (void ); +int sattrs_test_cleanup (void ); +int sattrs_add_tests (CU_pSuite suite); + +#endif /* TEST_SEGREGATEATTRIBUTES_H__ */
Signature · 1 line
2.36.1
PATCH v3 6/8 libsepol/cil: add support for segregate attributes
In reply to Christian GöttscheSupport the compile time constraint with the following syntax:
(segregateattributes (attr1 attr2 [...]))
and reports like:
...
Qualifying Names
Compile post process
Building policy binary
Checking Neverallows
Checking Segregate Attributes
Segregate Attributes violation, type test_type associated with attributes attr1 attr2 Checking User Bounds
Checking Role Bounds
Checking Type Bounds
Failed to generate binary
Failed to build policydb
--- libsepol/cil/src/cil.c | 17 +++++++ libsepol/cil/src/cil_binary.c | 75 ++++++++++++++++++++++++++++++ libsepol/cil/src/cil_build_ast.c | 58 +++++++++++++++++++++++ libsepol/cil/src/cil_build_ast.h | 2 + libsepol/cil/src/cil_copy_ast.c | 18 +++++++ libsepol/cil/src/cil_flavor.h | 1 + libsepol/cil/src/cil_internal.h | 8 ++++ libsepol/cil/src/cil_policy.c | 26 +++++++++++ libsepol/cil/src/cil_reset_ast.c | 8 ++++ libsepol/cil/src/cil_resolve_ast.c | 38 +++++++++++++++ libsepol/cil/src/cil_resolve_ast.h | 1 + libsepol/cil/src/cil_write_ast.c | 11 +++++ libsepol/src/kernel_to_cil.c | 32 +++++++++++++ secilc/docs/README.md | 1 + secilc/docs/cil_type_statements.md | 50 ++++++++++++++++++++ 15 files changed, 346 insertions(+)
libsepol/cil/src/cil.c +17 -0
@@ -225,6 +225,7 @@ char *CIL_KEY_SRC_CIL;char *CIL_KEY_SRC_HLL_LMS ;char *CIL_KEY_SRC_HLL_LMX ;char *CIL_KEY_SRC_HLL_LME ; +char *CIL_KEY_SEGREGATEATTRIBUTES ;static void cil_init_keys (void ) {
@@ -394,6 +395,7 @@ static void cil_init_keys(void)CIL_KEY_SRC_HLL_LMS =cil_strpool_add ("lms" );CIL_KEY_SRC_HLL_LMX =cil_strpool_add ("lmx" );CIL_KEY_SRC_HLL_LME =cil_strpool_add ("lme" ); +CIL_KEY_SEGREGATEATTRIBUTES =cil_strpool_add ("segregateattributes" ); }void cil_db_init (struct cil_db **db)
@@ -426,6 +428,7 @@ void cil_db_init(struct cil_db **db)cil_list_init (&(*db)->userprefixes,CIL_LIST_ITEM );cil_list_init (&(*db)->selinuxusers,CIL_LIST_ITEM );cil_list_init (&(*db)->names,CIL_LIST_ITEM ); +cil_list_init (&(*db)->segregateattributes,CIL_LIST_ITEM );cil_type_init (&(*db)->selftype); (*db)->selftype->datum.name =CIL_KEY_SELF ;
@@ -481,6 +484,7 @@ void cil_db_destroy(struct cil_db **db)cil_list_destroy (&(*db)->userprefixes,CIL_FALSE );cil_list_destroy (&(*db)->selinuxusers,CIL_FALSE );cil_list_destroy (&(*db)->names,CIL_TRUE ); +cil_list_destroy (&(*db)->segregateattributes,CIL_FALSE );cil_destroy_type ((*db)->selftype);
@@ -1005,6 +1009,9 @@ void cil_destroy_data(void **data, enum cil_flavor flavor)case CIL_SRC_INFO :cil_destroy_src_info (*data);break ; +case CIL_SEGREGATEATTRIBUTES : +cil_destroy_segregateattributes (*data); +break ;case CIL_OP :case CIL_CONS_OPERAND :break ;
@@ -1413,6 +1420,8 @@ const char * cil_node_to_string(struct cil_tree_node *node)return CIL_KEY_CONS_H1 ;case CIL_CONS_H2 :return CIL_KEY_CONS_H2 ; +case CIL_SEGREGATEATTRIBUTES : +return CIL_KEY_SEGREGATEATTRIBUTES ;default :break ;
@@ -2904,3 +2913,11 @@ void cil_src_info_init(struct cil_src_info **info) (*info)->hll_line =0 ; (*info)->path =NULL ; } + +void cil_segregateattributes_init (struct cil_segregateattributes **sattrs) +{ + *sattrs =cil_malloc (sizeof (**sattrs)); + + (*sattrs)->str_expr =NULL ; + (*sattrs)->datum_expr =NULL ; +}
libsepol/cil/src/cil_binary.c +75 -0
99 lines not on this page · raw message
libsepol/cil/src/cil_build_ast.c +58 -0
70 lines not on this page · raw message
libsepol/cil/src/cil_build_ast.h +2 -0
@@ -225,6 +225,8 @@ int cil_gen_defaultrange(struct cil_tree_node *parse_current, struct cil_tree_novoid cil_destroy_defaultrange (struct cil_defaultrange *def);int cil_gen_src_info (struct cil_tree_node *parse_current,struct cil_tree_node *ast_node);void cil_destroy_src_info (struct cil_src_info *info); +int cil_gen_segregateattributes (struct cil_db *db,struct cil_tree_node *parse_current,struct cil_tree_node *ast_node); +void cil_destroy_segregateattributes (struct cil_segregateattributes *sattrs);int cil_fill_cats (struct cil_tree_node *curr,struct cil_cats **cats);void cil_destroy_cats (struct cil_cats *cats);
libsepol/cil/src/cil_copy_ast.c +18 -0
@@ -1697,6 +1697,21 @@ static int cil_copy_src_info(__attribute__((unused)) struct cil_db *db, void *dareturn SEPOL_OK ; } +static int cil_copy_segregateattributes (__attribute__((unused))struct cil_db *db,void *data,void **copy, __attribute__((unused))symtab_t *symtab) +{ +struct cil_segregateattributes *orig = data; +struct cil_segregateattributes *new =NULL ; + +cil_segregateattributes_init (&new); + +cil_copy_expr (db, orig->str_expr, &new->str_expr); +cil_copy_expr (db, orig->datum_expr, &new->datum_expr); + + *copy = new; + +return SEPOL_OK ; +} +static int __cil_copy_node_helper (struct cil_tree_node *orig,uint32_t *finished,void *extra_args) {int rc =SEPOL_ERR ;
@@ -1990,6 +2005,9 @@ static int __cil_copy_node_helper(struct cil_tree_node *orig, uint32_t *finishedcase CIL_SRC_INFO : copy_func = &cil_copy_src_info;break ; +case CIL_SEGREGATEATTRIBUTES : + copy_func = &cil_copy_segregateattributes; +break ;default : goto exit; }
libsepol/cil/src/cil_flavor.h +1 -0
@@ -115,6 +115,7 @@ enum cil_flavor {CIL_SRC_INFO ,CIL_IBPKEYCON ,CIL_IBENDPORTCON , + CIL_SEGREGATEATTRIBUTES,/* * boolean constraint set catset
libsepol/cil/src/cil_internal.h +8 -0
@@ -242,6 +242,7 @@ extern char *CIL_KEY_SRC_CIL;extern char *CIL_KEY_SRC_HLL_LMS ;extern char *CIL_KEY_SRC_HLL_LMX ;extern char *CIL_KEY_SRC_HLL_LME ; +extern char *CIL_KEY_SEGREGATEATTRIBUTES ;/* Symbol Table Array Indices
@@ -309,6 +310,7 @@ struct cil_db {struct cil_list *userprefixes;struct cil_list *selinuxusers;struct cil_list *names; +struct cil_list *segregateattributes;int num_types_and_attrs;int num_classes;int num_cats;
@@ -975,6 +977,11 @@ struct cil_src_info {char *path; }; +struct cil_segregateattributes { +struct cil_list *str_expr; +struct cil_list *datum_expr; +}; +void cil_db_init (struct cil_db **db);void cil_db_destroy (struct cil_db **db);
@@ -1085,5 +1092,6 @@ void cil_mls_init(struct cil_mls **mls);void cil_src_info_init (struct cil_src_info **info);void cil_userattribute_init (struct cil_userattribute **attribute);void cil_userattributeset_init (struct cil_userattributeset **attrset); +void cil_segregateattributes_init (struct cil_segregateattributes **sattrs);#endif
libsepol/cil/src/cil_policy.c +26 -0
@@ -69,6 +69,7 @@ enum cil_statement_list {CIL_LIST_USER ,CIL_LIST_CONSTRAINT ,CIL_LIST_VALIDATETRANS , +CIL_LIST_SEGREGATEATTRIBUTES , CIL_LIST_NUM_LISTS };
@@ -168,6 +169,9 @@ static int __cil_gather_statements_helper(struct cil_tree_node *node, uint32_t *case CIL_VALIDATETRANS : kind =CIL_LIST_VALIDATETRANS ;break ; +case CIL_SEGREGATEATTRIBUTES : + kind =CIL_LIST_SEGREGATEATTRIBUTES ; +break ;default :break ; }
@@ -1911,6 +1915,27 @@ static void cil_devicetreecons_to_policy(FILE *out, struct cil_sort *devicetreec } } +static void cil_segregateattributes_to_policy (FILE *out,struct cil_list *sattrs_list) +{ +struct cil_list_item *curr_sattrs, *curr_attr; +struct cil_segregateattributes *sattrs; +int first =1 ; + +cil_list_for_each (curr_sattrs, sattrs_list) { + sattrs = curr_sattrs->data; +fprintf (out,"segregate_attriutes " ); +cil_list_for_each (curr_attr, sattrs->datum_expr) { +if (!first) { + first =0 ; + }else { +fprintf (out,", " ); + } +fprintf (out,"%s" ,DATUM (curr_attr->data)->fqn); + } +fprintf (out,";\n" ); + } +} +void cil_gen_policy (FILE *out,struct cil_db *db) {unsigned i;
@@ -1956,6 +1981,7 @@ void cil_gen_policy(FILE *out, struct cil_db *db)cil_typebounds_to_policy (out, lists[CIL_LIST_TYPE ]);cil_typeattributes_to_policy (out, lists[CIL_LIST_TYPE ], lists[CIL_LIST_TYPEATTRIBUTE ]);cil_te_rules_to_policy (out, head, db->mls); +cil_segregateattributes_to_policy (out, db->segregateattributes);cil_roles_to_policy (out, lists[CIL_LIST_ROLE ]);cil_role_types_to_policy (out, lists[CIL_LIST_ROLE ], lists[CIL_LIST_TYPE ]);
libsepol/cil/src/cil_reset_ast.c +8 -0
@@ -475,6 +475,11 @@ static void cil_reset_booleanif(struct cil_booleanif *bif)cil_list_destroy (&bif->datum_expr,CIL_FALSE ); } +static void cil_reset_segregateattributes (struct cil_segregateattributes *sattrs) +{ +cil_list_destroy (&sattrs->datum_expr,CIL_FALSE ); +} +static int __cil_reset_node (struct cil_tree_node *node, __attribute__((unused))uint32_t *finished, __attribute__((unused))void *extra_args) {switch (node->flavor) {
@@ -630,6 +635,9 @@ static int __cil_reset_node(struct cil_tree_node *node, __attribute__((unused))case CIL_BOOLEANIF :cil_reset_booleanif (node->data);break ; +case CIL_SEGREGATEATTRIBUTES : +cil_reset_segregateattributes (node->data); +break ;case CIL_TUNABLEIF :case CIL_CALL :break ;/* Not effected by optional block disabling */
libsepol/cil/src/cil_resolve_ast.c +38 -0
@@ -3265,6 +3265,7 @@ int cil_resolve_expr(enum cil_flavor expr_type, struct cil_list *str_expr, struc sym_index =CIL_SYM_TUNABLES ;break ;case CIL_TYPE : +case CIL_TYPEATTRIBUTE : sym_index =CIL_SYM_TYPES ;break ;case CIL_ROLE :
@@ -3312,6 +3313,13 @@ int cil_resolve_expr(enum cil_flavor expr_type, struct cil_list *str_expr, struc }else {if (sym_index ==CIL_SYM_TYPES && (expr_type ==CIL_CONSTRAIN || expr_type ==CIL_VALIDATETRANS )) {cil_type_used (res_datum,CIL_ATTR_CONSTRAINT ); + }else if (expr_type ==CIL_SEGREGATEATTRIBUTES ) { +if (FLAVOR (res_datum) !=CIL_TYPEATTRIBUTE ) { +cil_tree_log (parent,CIL_ERR ,"Type or type alias not supported in segregate attributes declaration" ); + rc =SEPOL_ERR ; + goto exit; + } +cil_type_used (res_datum,CIL_ATTR_NEVERALLOW ); }cil_list_append (*datum_expr,CIL_DATUM , res_datum); }
@@ -3508,6 +3516,33 @@ exit:return rc; } +int cil_resolve_segregateattributes (struct cil_tree_node *current,void *extra_args) +{ +struct cil_segregateattributes *sattrs = current->data; +struct cil_list_item *first, *second; +int rc; + + rc =cil_resolve_expr (CIL_SEGREGATEATTRIBUTES , sattrs->str_expr, &sattrs->datum_expr, current, extra_args); +if (rc !=SEPOL_OK ) { + goto exit; + } + +cil_list_for_each (first, sattrs->datum_expr) { +for (second = first->next; second; second = second->next) { +if (first->data == second->data) { +cil_tree_log (current,CIL_ERR ,"Repeated attribute in segregate attributes declaration" ); + rc =SEPOL_ERR ; + goto exit; + } + } + } + +return SEPOL_OK ; + +exit: +return rc; +} +/* * Degenerate inheritance leads to exponential growth of the policy * It can take many forms, but here is one example.
@@ -3888,6 +3923,9 @@ static int __cil_resolve_ast_node(struct cil_tree_node *node, void *extra_args)case CIL_USERATTRIBUTESET : rc =cil_resolve_userattributeset (node, args);break ; +case CIL_SEGREGATEATTRIBUTES : + rc =cil_resolve_segregateattributes (node, args); +break ;default :break ; }
libsepol/cil/src/cil_resolve_ast.h +1 -0
@@ -96,6 +96,7 @@ int cil_resolve_expr(enum cil_flavor expr_type, struct cil_list *str_expr, strucint cil_resolve_boolif (struct cil_tree_node *current,void *extra_args);int cil_evaluate_expr (struct cil_list *datum_expr,uint16_t *result);int cil_resolve_tunif (struct cil_tree_node *current,void *extra_args); +int cil_resolve_segregateattributes (struct cil_tree_node *current,void *extra_args);int cil_resolve_ast (struct cil_db *db,struct cil_tree_node *current);int cil_resolve_name (struct cil_tree_node *ast_node,char *name,enum cil_sym_index sym_index,void *extra_args,struct cil_symtab_datum **datum);
libsepol/cil/src/cil_write_ast.c +11 -0
@@ -1474,7 +1474,18 @@ void cil_write_ast_node(FILE *out, struct cil_tree_node *node)fprintf (out,"(ipaddr %s %s)\n" ,datum_to_str (&ipaddr->datum), buf);break ; } +case CIL_SEGREGATEATTRIBUTES : { +struct cil_segregateattributes *sattrs = node->data; +fprintf (out,"(segregateattributes " ); +if (sattrs->datum_expr) +write_expr (out, sattrs->datum_expr); +else +write_expr (out, sattrs->str_expr); +fprintf (out,")\n" ); +break ; + }default : +cil_log (CIL_ERR ,"Unsupported flavor: %d\n" , node->flavor);fprintf (out,"(<?RULE:%s>)\n" ,cil_node_to_string (node));break ; }
libsepol/src/kernel_to_cil.c +32 -0
@@ -1906,6 +1906,33 @@ static int map_filename_trans_to_str(hashtab_key_t key, void *data, void *arg)return 0 ; } +static int write_segregate_attributes_to_cil (FILE *out,const struct policydb *pdb) +{ +const segregate_attributes_rule_t *sattr; + +for (sattr = pdb->segregate_attributes; sattr; sattr = sattr->next) { +struct ebitmap_node *node; +unsigned int bit; +int first =1 ; + +sepol_printf (out,"(segregateattributes (" ); + +ebitmap_for_each_positive_bit (&sattr->attrs, node, bit) { +if (first) { + first =0 ; + }else { +sepol_printf (out," " ); + } + +sepol_printf (out,"%s" , pdb->p_type_val_to_name[bit -1 ]); + } + +sepol_printf (out,"))\n" ); + } + +return 0 ; +} +static int write_filename_trans_rules_to_cil (FILE *out,struct policydb *pdb) {struct map_filename_trans_args args;
@@ -3329,6 +3356,11 @@ int sepol_kernel_policydb_to_cil(FILE *out, struct policydb *pdb) goto exit; } + rc =write_segregate_attributes_to_cil (out, pdb); +if (rc !=0 ) { + goto exit; + } + rc =write_filename_trans_rules_to_cil (out, pdb);if (rc !=0 ) { goto exit;
secilc/docs/README.md +1 -0
@@ -132,6 +132,7 @@ CIL (Common Intermediate Language) * [typemember](cil_type_statements.md#typemember) * [typetransition](cil_type_statements.md#typetransition) * [typepermissive](cil_type_statements.md#typepermissive) + * [segregateattributes](cil_type_statements.md#segregateattributes) * [User Statements](cil_user_statements.md#user-statements) * [user](cil_user_statements.md#user)
secilc/docs/cil_type_statements.md +50 -0
53 lines not on this page · raw message
Signature · 1 line
2.36.1
Re: [PATCH v3 6/8] libsepol/cil: add support for segregate attributes
Quoted 4 lines · Christian Göttsche
Support the compile time constraint with the following syntax:
(segregateattributes (attr1 attr2 [...]))
Not a list. The vast majority of the cases are going to be that a type can be either one or another.
(typesdisjoint attr1 attr2)
Keep it simple.
Quoted 175 lines
and reports like:
...
Qualifying Names
Compile post process
Building policy binary
Checking Neverallows
Checking Segregate Attributes
Segregate Attributes violation, typetest_typeassociated with attributes attr1 attr2 Checking User Bounds
Checking Role Bounds
Checking Type Bounds
Failed to generate binary
Failed to build policydbSigned-off-by Christian Göttsche <[email protected]>--- libsepol/cil/src/cil.c | 17 +++++++ libsepol/cil/src/cil_binary.c | 75 ++++++++++++++++++++++++++++++ libsepol/cil/src/cil_build_ast.c | 58 +++++++++++++++++++++++ libsepol/cil/src/cil_build_ast.h | 2 + libsepol/cil/src/cil_copy_ast.c | 18 +++++++ libsepol/cil/src/cil_flavor.h | 1 + libsepol/cil/src/cil_internal.h | 8 ++++ libsepol/cil/src/cil_policy.c | 26 +++++++++++ libsepol/cil/src/cil_reset_ast.c | 8 ++++ libsepol/cil/src/cil_resolve_ast.c | 38 +++++++++++++++ libsepol/cil/src/cil_resolve_ast.h | 1 + libsepol/cil/src/cil_write_ast.c | 11 +++++ libsepol/src/kernel_to_cil.c | 32 +++++++++++++ secilc/docs/README.md | 1 + secilc/docs/cil_type_statements.md | 50 ++++++++++++++++++++ 15 files changed, 346 insertions(+)libsepol/cil/src/cil.c +17
-0@@ -225,6 +225,7 @@ char *CIL_KEY_SRC_CIL;char *CIL_KEY_SRC_HLL_LMS ;char *CIL_KEY_SRC_HLL_LMX ;char *CIL_KEY_SRC_HLL_LME ; +char *CIL_KEY_SEGREGATEATTRIBUTES ;static void cil_init_keys (void ) {@@ -394,6 +395,7 @@ static void cil_init_keys(void)CIL_KEY_SRC_HLL_LMS =cil_strpool_add ("lms" );CIL_KEY_SRC_HLL_LMX =cil_strpool_add ("lmx" );CIL_KEY_SRC_HLL_LME =cil_strpool_add ("lme" ); +CIL_KEY_SEGREGATEATTRIBUTES =cil_strpool_add ("segregateattributes" ); }void cil_db_init (struct cil_db **db)@@ -426,6 +428,7 @@ void cil_db_init(struct cil_db **db)cil_list_init (&(*db)->userprefixes,CIL_LIST_ITEM );cil_list_init (&(*db)->selinuxusers,CIL_LIST_ITEM );cil_list_init (&(*db)->names,CIL_LIST_ITEM ); +cil_list_init (&(*db)->segregateattributes,CIL_LIST_ITEM );cil_type_init (&(*db)->selftype); (*db)->selftype->datum.name =CIL_KEY_SELF ;@@ -481,6 +484,7 @@ void cil_db_destroy(struct cil_db **db)cil_list_destroy (&(*db)->userprefixes,CIL_FALSE );cil_list_destroy (&(*db)->selinuxusers,CIL_FALSE );cil_list_destroy (&(*db)->names,CIL_TRUE ); +cil_list_destroy (&(*db)->segregateattributes,CIL_FALSE );cil_destroy_type ((*db)->selftype);@@ -1005,6 +1009,9 @@ void cil_destroy_data(void **data, enum cil_flavor flavor)case CIL_SRC_INFO :cil_destroy_src_info (*data);break ; +case CIL_SEGREGATEATTRIBUTES : +cil_destroy_segregateattributes (*data); +break ;case CIL_OP :case CIL_CONS_OPERAND :break ;@@ -1413,6 +1420,8 @@ const char * cil_node_to_string(struct cil_tree_node *node)return CIL_KEY_CONS_H1 ;case CIL_CONS_H2 :return CIL_KEY_CONS_H2 ; +case CIL_SEGREGATEATTRIBUTES : +return CIL_KEY_SEGREGATEATTRIBUTES ;default :break ;@@ -2904,3 +2913,11 @@ void cil_src_info_init(struct cil_src_info **info) (*info)->hll_line =0 ; (*info)->path =NULL ; } + +void cil_segregateattributes_init (struct cil_segregateattributes **sattrs) +{ + *sattrs =cil_malloc (sizeof (**sattrs)); + + (*sattrs)->str_expr =NULL ; + (*sattrs)->datum_expr =NULL ; +}libsepol/cil/src/cil_binary.c +51
-0@@ -3818,6 +3818,38 @@ exit:return SEPOL_ERR ; } +static int cil_segregateattributes_to_policydb (policydb_t *pdb,const struct cil_segregateattributes *sattrs) +{ +segregate_attributes_rule_t *sattr; +struct cil_list_item *curr; +type_datum_t *sepol_type; +int rc =SEPOL_ERR ; + + sattr =cil_malloc (sizeof (segregate_attributes_rule_t)); +ebitmap_init (&sattr->attrs); + +cil_list_for_each (curr, sattrs->datum_expr) { + rc =__cil_get_sepol_type_datum (pdb,DATUM (curr->data), &sepol_type); +if (rc !=SEPOL_OK ) goto exit; + +if (ebitmap_set_bit (&sattr->attrs, sepol_type->s.value -1 ,1 )) { + goto exit; + } + } + + sattr->next = pdb->segregate_attributes; + pdb->segregate_attributes = sattr; + +return SEPOL_OK ; + +exit: +if (sattr) { +ebitmap_destroy (&sattr->attrs); +free (sattr); + } +return rc; +} +static int __cil_node_to_policydb (struct cil_tree_node *node,void *extra_args) {int rc =SEPOL_OK ;@@ -3960,6 +3992,9 @@ static int __cil_node_to_policydb(struct cil_tree_node *node, void *extra_args)case CIL_DEFAULTRANGE : rc =cil_defaultrange_to_policydb (pdb, node->data);break ; +case CIL_SEGREGATEATTRIBUTES : + rc =cil_segregateattributes_to_policydb (pdb, node->data); +break ;default :break ; }@@ -4890,6 +4925,42 @@ exit:return rc; } +static int cil_check_segregateattributes (const policydb_t *pdb,int *violation) +{ +const segregate_attributes_rule_t *sattr; + +for (sattr = pdb->segregate_attributes; sattr; sattr = sattr->next) { +ebitmap_node_t *first_node; +unsigned int first_bit; + +ebitmap_for_each_positive_bit (&sattr->attrs, first_node, first_bit) { +ebitmap_node_t *second_node; +unsigned int second_bit; + +ebitmap_for_each_positive_bit_after (&sattr->attrs, second_node, second_bit, first_node, first_bit) { +ebitmap_t attr_union; +ebitmap_node_t *type_node; +unsigned int type_bit;
libsepol/cil/src/cil_binary.c exit: · line 4953
Quoted 10 lines
libsepol/cil/src/cil_binary.c +10
-0+ +if (ebitmap_and (&attr_union, &pdb->attr_type_map[first_bit], &pdb->attr_type_map[second_bit])) +return SEPOL_ERR ; + +ebitmap_for_each_positive_bit (&attr_union, type_node, type_bit) { +cil_log (CIL_ERR ,"Segregate Attributes violation, type %s associated with attributes %s and %s\n" , + pdb->p_type_val_to_name[type_bit], + pdb->p_type_val_to_name[first_bit], + pdb->p_type_val_to_name[second_bit]); + *violation =CIL_TRUE ;
It needs to report the file and linenumber of the violation. This is the case for checkpolicy as well. There is a reason that we carry that information for neverallow rules.
Thanks,
Jim
Quoted 512 lines
libsepol/cil/src/cil_binary.c +14
-0+ } + +ebitmap_destroy (&attr_union); + } + } + } + +return SEPOL_OK ; +} +static struct cil_list *cil_classperms_from_sepol (policydb_t *pdb,uint16_t class,uint32_t data,struct cil_class *class_value_to_cil[],struct cil_perm **perm_value_to_cil[]) {struct cil_classperms *cp;@@ -5160,6 +5231,10 @@ int cil_binary_create_allocated_pdb(const struct cil_db *db, sepol_policydb_t *p rc =cil_check_neverallows (db, pdb, neverallows, &violation);if (rc !=SEPOL_OK ) goto exit; +cil_log (CIL_INFO ,"Checking Segregate Attributes\n" ); + rc =cil_check_segregateattributes (pdb, &violation); +if (rc !=SEPOL_OK ) goto exit; +cil_log (CIL_INFO ,"Checking User Bounds\n" ); rc =bounds_check_users (NULL , pdb);if (rc) {libsepol/cil/src/cil_build_ast.c +58
-0@@ -6164,6 +6164,62 @@ void cil_destroy_src_info(struct cil_src_info *info)free (info); } +int cil_gen_segregateattributes (struct cil_db *db,struct cil_tree_node *parse_current,struct cil_tree_node *ast_node) +{ +enum cil_syntax syntax[] = { +CIL_SYN_STRING , +CIL_SYN_LIST , +CIL_SYN_END + }; +size_t syntax_len =sizeof (syntax)/sizeof (*syntax); +struct cil_segregateattributes *sattrs =NULL ; +int rc =SEPOL_ERR ; + +if (db ==NULL || parse_current ==NULL || ast_node ==NULL ) { + goto exit; + } + + rc =__cil_verify_syntax (parse_current, syntax, syntax_len); +if (rc !=SEPOL_OK ) { + goto exit; + } + +cil_segregateattributes_init (&sattrs); + + rc =cil_gen_expr (parse_current->next,CIL_TYPEATTRIBUTE , &sattrs->str_expr); +if (rc !=SEPOL_OK ) { + goto exit; + } + +/* require at least two attributes */ +if (sattrs->str_expr->head == sattrs->str_expr->tail) { + rc =SEPOL_ERR ; + goto exit; + } + + ast_node->data = sattrs; + ast_node->flavor =CIL_SEGREGATEATTRIBUTES ; + +return SEPOL_OK ; + +exit: +cil_tree_log (parse_current,CIL_ERR ,"Bad segregate attributes declaration" ); +cil_destroy_segregateattributes (sattrs); +return rc; +} + +void cil_destroy_segregateattributes (struct cil_segregateattributes *sattrs) +{ +if (sattrs ==NULL ) { +return ; + } + +cil_list_destroy (&sattrs->str_expr,CIL_TRUE ); +cil_list_destroy (&sattrs->datum_expr,CIL_FALSE ); + +free (sattrs); +} +static int check_for_illegal_statement (struct cil_tree_node *parse_current,struct cil_args_build *args) {if (args->tunif !=NULL ) {@@ -6455,6 +6511,8 @@ static struct cil_tree_node * parse_statement(struct cil_db *db, struct cil_tree rc =cil_gen_mls (parse_current, new_ast_node); }else if (parse_current->data ==CIL_KEY_SRC_INFO ) { rc =cil_gen_src_info (parse_current, new_ast_node); + }else if (parse_current->data ==CIL_KEY_SEGREGATEATTRIBUTES ) { + rc =cil_gen_segregateattributes (db, parse_current, new_ast_node); }else {cil_log (CIL_ERR ,"Error: Unknown keyword %s\n" , (char *)parse_current->data); rc =SEPOL_ERR ;libsepol/cil/src/cil_build_ast.h +2
-0@@ -225,6 +225,8 @@ int cil_gen_defaultrange(struct cil_tree_node *parse_current, struct cil_tree_novoid cil_destroy_defaultrange (struct cil_defaultrange *def);int cil_gen_src_info (struct cil_tree_node *parse_current,struct cil_tree_node *ast_node);void cil_destroy_src_info (struct cil_src_info *info); +int cil_gen_segregateattributes (struct cil_db *db,struct cil_tree_node *parse_current,struct cil_tree_node *ast_node); +void cil_destroy_segregateattributes (struct cil_segregateattributes *sattrs);int cil_fill_cats (struct cil_tree_node *curr,struct cil_cats **cats);void cil_destroy_cats (struct cil_cats *cats);libsepol/cil/src/cil_copy_ast.c +18
-0@@ -1697,6 +1697,21 @@ static int cil_copy_src_info(__attribute__((unused)) struct cil_db *db, void *dareturn SEPOL_OK ; } +static int cil_copy_segregateattributes (__attribute__((unused))struct cil_db *db,void *data,void **copy, __attribute__((unused))symtab_t *symtab) +{ +struct cil_segregateattributes *orig = data; +struct cil_segregateattributes *new =NULL ; + +cil_segregateattributes_init (&new); + +cil_copy_expr (db, orig->str_expr, &new->str_expr); +cil_copy_expr (db, orig->datum_expr, &new->datum_expr); + + *copy = new; + +return SEPOL_OK ; +} +static int __cil_copy_node_helper (struct cil_tree_node *orig,uint32_t *finished,void *extra_args) {int rc =SEPOL_ERR ;@@ -1990,6 +2005,9 @@ static int __cil_copy_node_helper(struct cil_tree_node *orig, uint32_t *finishedcase CIL_SRC_INFO : copy_func = &cil_copy_src_info;break ; +case CIL_SEGREGATEATTRIBUTES : + copy_func = &cil_copy_segregateattributes; +break ;default : goto exit; }libsepol/cil/src/cil_flavor.h +1
-0@@ -115,6 +115,7 @@ enum cil_flavor {CIL_SRC_INFO ,CIL_IBPKEYCON ,CIL_IBENDPORTCON , + CIL_SEGREGATEATTRIBUTES,/* * boolean constraint set catset libsepol/cil/src/cil_internal.h +8
-0@@ -242,6 +242,7 @@ extern char *CIL_KEY_SRC_CIL;extern char *CIL_KEY_SRC_HLL_LMS ;extern char *CIL_KEY_SRC_HLL_LMX ;extern char *CIL_KEY_SRC_HLL_LME ; +extern char *CIL_KEY_SEGREGATEATTRIBUTES ;/* Symbol Table Array Indices @@ -309,6 +310,7 @@ struct cil_db {struct cil_list *userprefixes;struct cil_list *selinuxusers;struct cil_list *names; +struct cil_list *segregateattributes;int num_types_and_attrs;int num_classes;int num_cats;@@ -975,6 +977,11 @@ struct cil_src_info {char *path; }; +struct cil_segregateattributes { +struct cil_list *str_expr; +struct cil_list *datum_expr; +}; +void cil_db_init (struct cil_db **db);void cil_db_destroy (struct cil_db **db);@@ -1085,5 +1092,6 @@ void cil_mls_init(struct cil_mls **mls);void cil_src_info_init (struct cil_src_info **info);void cil_userattribute_init (struct cil_userattribute **attribute);void cil_userattributeset_init (struct cil_userattributeset **attrset); +void cil_segregateattributes_init (struct cil_segregateattributes **sattrs);#endif libsepol/cil/src/cil_policy.c +26
-0@@ -69,6 +69,7 @@ enum cil_statement_list {CIL_LIST_USER ,CIL_LIST_CONSTRAINT ,CIL_LIST_VALIDATETRANS , +CIL_LIST_SEGREGATEATTRIBUTES , CIL_LIST_NUM_LISTS };@@ -168,6 +169,9 @@ static int __cil_gather_statements_helper(struct cil_tree_node *node, uint32_t *case CIL_VALIDATETRANS : kind =CIL_LIST_VALIDATETRANS ;break ; +case CIL_SEGREGATEATTRIBUTES : + kind =CIL_LIST_SEGREGATEATTRIBUTES ; +break ;default :break ; }@@ -1911,6 +1915,27 @@ static void cil_devicetreecons_to_policy(FILE *out, struct cil_sort *devicetreec } } +static void cil_segregateattributes_to_policy (FILE *out,struct cil_list *sattrs_list) +{ +struct cil_list_item *curr_sattrs, *curr_attr; +struct cil_segregateattributes *sattrs; +int first =1 ; + +cil_list_for_each (curr_sattrs, sattrs_list) { + sattrs = curr_sattrs->data; +fprintf (out,"segregate_attriutes " ); +cil_list_for_each (curr_attr, sattrs->datum_expr) { +if (!first) { + first =0 ; + }else { +fprintf (out,", " ); + } +fprintf (out,"%s" ,DATUM (curr_attr->data)->fqn); + } +fprintf (out,";\n" ); + } +} +void cil_gen_policy (FILE *out,struct cil_db *db) {unsigned i;@@ -1956,6 +1981,7 @@ void cil_gen_policy(FILE *out, struct cil_db *db)cil_typebounds_to_policy (out, lists[CIL_LIST_TYPE ]);cil_typeattributes_to_policy (out, lists[CIL_LIST_TYPE ], lists[CIL_LIST_TYPEATTRIBUTE ]);cil_te_rules_to_policy (out, head, db->mls); +cil_segregateattributes_to_policy (out, db->segregateattributes);cil_roles_to_policy (out, lists[CIL_LIST_ROLE ]);cil_role_types_to_policy (out, lists[CIL_LIST_ROLE ], lists[CIL_LIST_TYPE ]);libsepol/cil/src/cil_reset_ast.c +8
-0@@ -475,6 +475,11 @@ static void cil_reset_booleanif(struct cil_booleanif *bif)cil_list_destroy (&bif->datum_expr,CIL_FALSE ); } +static void cil_reset_segregateattributes (struct cil_segregateattributes *sattrs) +{ +cil_list_destroy (&sattrs->datum_expr,CIL_FALSE ); +} +static int __cil_reset_node (struct cil_tree_node *node, __attribute__((unused))uint32_t *finished, __attribute__((unused))void *extra_args) {switch (node->flavor) {@@ -630,6 +635,9 @@ static int __cil_reset_node(struct cil_tree_node *node, __attribute__((unused))case CIL_BOOLEANIF :cil_reset_booleanif (node->data);break ; +case CIL_SEGREGATEATTRIBUTES : +cil_reset_segregateattributes (node->data); +break ;case CIL_TUNABLEIF :case CIL_CALL :break ;/* Not effected by optional block disabling */ libsepol/cil/src/cil_resolve_ast.c +38
-0@@ -3265,6 +3265,7 @@ int cil_resolve_expr(enum cil_flavor expr_type, struct cil_list *str_expr, struc sym_index =CIL_SYM_TUNABLES ;break ;case CIL_TYPE : +case CIL_TYPEATTRIBUTE : sym_index =CIL_SYM_TYPES ;break ;case CIL_ROLE :@@ -3312,6 +3313,13 @@ int cil_resolve_expr(enum cil_flavor expr_type, struct cil_list *str_expr, struc }else {if (sym_index ==CIL_SYM_TYPES && (expr_type ==CIL_CONSTRAIN || expr_type ==CIL_VALIDATETRANS )) {cil_type_used (res_datum,CIL_ATTR_CONSTRAINT ); + }else if (expr_type ==CIL_SEGREGATEATTRIBUTES ) { +if (FLAVOR (res_datum) !=CIL_TYPEATTRIBUTE ) { +cil_tree_log (parent,CIL_ERR ,"Type or type alias not supported in segregate attributes declaration" ); + rc =SEPOL_ERR ; + goto exit; + } +cil_type_used (res_datum,CIL_ATTR_NEVERALLOW ); }cil_list_append (*datum_expr,CIL_DATUM , res_datum); }@@ -3508,6 +3516,33 @@ exit:return rc; } +int cil_resolve_segregateattributes (struct cil_tree_node *current,void *extra_args) +{ +struct cil_segregateattributes *sattrs = current->data; +struct cil_list_item *first, *second; +int rc; + + rc =cil_resolve_expr (CIL_SEGREGATEATTRIBUTES , sattrs->str_expr, &sattrs->datum_expr, current, extra_args); +if (rc !=SEPOL_OK ) { + goto exit; + } + +cil_list_for_each (first, sattrs->datum_expr) { +for (second = first->next; second; second = second->next) { +if (first->data == second->data) { +cil_tree_log (current,CIL_ERR ,"Repeated attribute in segregate attributes declaration" ); + rc =SEPOL_ERR ; + goto exit; + } + } + } + +return SEPOL_OK ; + +exit: +return rc; +} +/* * Degenerate inheritance leads to exponential growth of the policy * It can take many forms, but here is one example. @@ -3888,6 +3923,9 @@ static int __cil_resolve_ast_node(struct cil_tree_node *node, void *extra_args)case CIL_USERATTRIBUTESET : rc =cil_resolve_userattributeset (node, args);break ; +case CIL_SEGREGATEATTRIBUTES : + rc =cil_resolve_segregateattributes (node, args); +break ;default :break ; }libsepol/cil/src/cil_resolve_ast.h +1
-0@@ -96,6 +96,7 @@ int cil_resolve_expr(enum cil_flavor expr_type, struct cil_list *str_expr, strucint cil_resolve_boolif (struct cil_tree_node *current,void *extra_args);int cil_evaluate_expr (struct cil_list *datum_expr,uint16_t *result);int cil_resolve_tunif (struct cil_tree_node *current,void *extra_args); +int cil_resolve_segregateattributes (struct cil_tree_node *current,void *extra_args);int cil_resolve_ast (struct cil_db *db,struct cil_tree_node *current);int cil_resolve_name (struct cil_tree_node *ast_node,char *name,enum cil_sym_index sym_index,void *extra_args,struct cil_symtab_datum **datum);libsepol/cil/src/cil_write_ast.c +11
-0@@ -1474,7 +1474,18 @@ void cil_write_ast_node(FILE *out, struct cil_tree_node *node)fprintf (out,"(ipaddr %s %s)\n" ,datum_to_str (&ipaddr->datum), buf);break ; } +case CIL_SEGREGATEATTRIBUTES : { +struct cil_segregateattributes *sattrs = node->data; +fprintf (out,"(segregateattributes " ); +if (sattrs->datum_expr) +write_expr (out, sattrs->datum_expr); +else +write_expr (out, sattrs->str_expr); +fprintf (out,")\n" ); +break ; + }default : +cil_log (CIL_ERR ,"Unsupported flavor: %d\n" , node->flavor);fprintf (out,"(<?RULE:%s>)\n" ,cil_node_to_string (node));break ; }libsepol/src/kernel_to_cil.c +32
-0@@ -1906,6 +1906,33 @@ static int map_filename_trans_to_str(hashtab_key_t key, void *data, void *arg)return 0 ; } +static int write_segregate_attributes_to_cil (FILE *out,const struct policydb *pdb) +{ +const segregate_attributes_rule_t *sattr; + +for (sattr = pdb->segregate_attributes; sattr; sattr = sattr->next) { +struct ebitmap_node *node; +unsigned int bit; +int first =1 ; + +sepol_printf (out,"(segregateattributes (" ); + +ebitmap_for_each_positive_bit (&sattr->attrs, node, bit) { +if (first) { + first =0 ; + }else { +sepol_printf (out," " ); + } + +sepol_printf (out,"%s" , pdb->p_type_val_to_name[bit -1 ]); + } + +sepol_printf (out,"))\n" ); + } + +return 0 ; +} +static int write_filename_trans_rules_to_cil (FILE *out,struct policydb *pdb) {struct map_filename_trans_args args;@@ -3329,6 +3356,11 @@ int sepol_kernel_policydb_to_cil(FILE *out, struct policydb *pdb) goto exit; } + rc =write_segregate_attributes_to_cil (out, pdb); +if (rc !=0 ) { + goto exit; + } + rc =write_filename_trans_rules_to_cil (out, pdb);if (rc !=0 ) { goto exit;secilc/docs/README.md +1
-0@@ -132,6 +132,7 @@ CIL (Common Intermediate Language) * [typemember](cil_type_statements.md#typemember) * [typetransition](cil_type_statements.md#typetransition) * [typepermissive](cil_type_statements.md#typepermissive) + * [segregateattributes](cil_type_statements.md#segregateattributes) * [User Statements](cil_user_statements.md#user-statements) * [user](cil_user_statements.md#user)secilc/docs/cil_type_statements.md +50
-1@@ -601,3 +601,53 @@ This example will allow SELinux to run the `healthd.process` domain in permissiv (allow ...) ) ``` + +segregateattributes +------------------- + +Libsepol and secilc version 3.5 introduced the segregateattributes statement +to mark two or more type attributes mutual exclusive. This is a compiler +enforced action that will stop compilation until the offending associations +are modified. + +Note that these constraints can be over-ridden by the CIL compiler command +line parameter `-N` or `--disable-neverallow` flags. + +**Statement definition:** + +```secil + (segregateattributes (typeattribute_id typeattribute_id...)) +``` + +**Where:** + +<table> +<colgroup> +<col width="27%" /> +<col width="72%" /> +</colgroup> +<tbody> +<tr class="odd"> +<td align="left"><p><code>segregateattributes</code></p></td> +<td align="left"><p>The <code>segregateattributes</code> keyword.</p></td> +</tr> +<tr class="even"> +<td align="left"><p><code>typeattribute_id</code></p></td> +<td align="left"><p>At least two previously declared <code>typeattribute</code> identifier.</p> +<p>Note that the same <code>typeattribute</code> identifier must not be repeated.</p></td> +</tr> +</tbody> +</table> + +**Example:** + +This example will not compile as `type_1` is associated with type attributes `attr_1` and `attr_2`: + +```secil + (type type_1) + (typeattribute attr_1) + (typeattribute attr_2) + (typeattributeset attr_1 (type_1)) + (typeattributeset attr_2 (type_1)) + (segregateattributes (attr_1 attr_2)) +``` --2.36.1
PATCH v3 7/8 secilc: run tests against development version of libsepol
In reply to Christian GöttscheSince secilc is dynamically linked against libsepol do not run tests against the system version of libsepol to support new features currently in development.
--- secilc/Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
secilc/Makefile +2 -2
@@ -34,8 +34,8 @@ $(SECILC): $(SECILC_OBJS) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LDLIBS) test: $(SECILC) - ./$(SECILC) test/policy.cil - ./$(SECILC) -c $(POL_VERS) -O -M 1 -f /dev/null -o opt-actual.bin test/opt-input.cil + env LD_LIBRARY_PATH="$(DESTDIR)/lib:$(DESTDIR)/usr/lib" ./$(SECILC) test/policy.cil + env LD_LIBRARY_PATH="$(DESTDIR)/lib:$(DESTDIR)/usr/lib" ./$(SECILC) -c $(POL_VERS) -O -M 1 -f /dev/null -o opt-actual.bin test/opt-input.cil $(CHECKPOLICY) -b -C -M -o opt-actual.cil opt-actual.bin >/dev/null $(DIFF) test/opt-expected.cil opt-actual.cil
Signature · 1 line
2.36.1
Re: [PATCH v3 7/8] secilc: run tests against development version of libsepol
Quoted 15 lines · Christian Göttsche
Since secilc is dynamically linked against libsepol do not run tests against the system version of libsepol to support new features currently in development.
Signed-off-by Christian Göttsche <[email protected]>--- secilc/Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)secilc/Makefile +0
-0
secilc/Makefile $(SECILC): $(SECILC_OBJS) · line 41
Quoted 10 lines
secilc/Makefile +2
-2@@ -34,8 +34,8 @@ $(SECILC): $(SECILC_OBJS) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LDLIBS) test: $(SECILC) - ./$(SECILC) test/policy.cil - ./$(SECILC) -c $(POL_VERS) -O -M 1 -f /dev/null -o opt-actual.bin test/opt-input.cil + env LD_LIBRARY_PATH="$(DESTDIR)/lib:$(DESTDIR)/usr/lib" ./$(SECILC) test/policy.cil + env LD_LIBRARY_PATH="$(DESTDIR)/lib:$(DESTDIR)/usr/lib" ./$(SECILC) -c $(POL_VERS) -O -M 1 -f /dev/null -o opt-actual.bin test/opt-input.cil $(CHECKPOLICY) -b -C -M -o opt-actual.cil opt-actual.bin >/dev/null $(DIFF) test/opt-expected.cil opt-actual.cil
This assumes that LIBDIR and SHLIBDIR were not used.
The README.md file says to use the following for tests:
DESTDIR=~/obj ./scripts/env_use_destdir make test
and that works for secilc as well.
Jim
Quoted 3 lines
--
2.36.1
PATCH v3 8/8 secilc: include segregate attributes in tests
In reply to Christian Göttsche--- secilc/test/policy.cil | 3 +++ 1 file changed, 3 insertions(+)
secilc/test/policy.cil +3 -0
@@ -118,13 +118,16 @@ (typeattribute foo_type) (typeattribute bar_type) (typeattribute baz_type) + (typeattribute bad_type) (typeattribute not_bad_type) (typeattributeset exec_type (or bin_t kernel_t)) (typeattributeset foo_type (and exec_type kernel_t)) (typeattributeset bar_type (xor exec_type foo_type)) (typeattributeset baz_type (not bin_t)) (typeattributeset baz_type (and exec_type (and bar_type bin_t))) + (typeattributeset bad_type (bad_t)) (typeattributeset not_bad_type (not bad_t)) + (segregateattributes (bad_type not_bad_type)) (typealias sbin_t) (typealiasactual sbin_t bin_t) (typepermissive device_t)
Signature · 1 line
2.36.1
Quoted 9 lines · Christian Göttsche
Refactor the ebitmap conversions in
link.cinto its own function.Do not log an OOM message twice on
type_set_or_convert()failure.Drop the now unused state parameter from
type_set_or_convert()andtype_set_convert().Signed-off-by Christian Göttsche <[email protected]>
Quoted 294 lines
--- libsepol/src/link.c | 140 +++++++++++++++----------------------------- 1 file changed, 47 insertions(+), 93 deletions(-)libsepol/src/link.c +47
-94@@ -958,26 +958,28 @@ static int alias_copy_callback(hashtab_key_t key, hashtab_datum_t datum,/*********** callbacks that fix bitmaps ***********/ -static int type_set_convert (type_set_t * types,type_set_t * dst, -policy_module_t * mod,link_state_t * state - __attribute__ ((unused))) +static int ebitmap_convert (const ebitmap_t *src,ebitmap_t *dst,const uint32_t *map) { -unsigned int i; -ebitmap_node_t *tnode; -ebitmap_for_each_positive_bit (&types->types, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&dst->types, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } - } -ebitmap_for_each_positive_bit (&types->negset, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&dst->negset, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } +unsigned int bit; +ebitmap_node_t *node; +ebitmap_for_each_positive_bit (src, node, bit) { +assert (map[bit]); +if (ebitmap_set_bit (dst, map[bit] -1 ,1 )) +return -1 ; } + +return 0 ; +} + +static int type_set_convert (const type_set_t * types,type_set_t * dst, +const policy_module_t * mod) +{ +if (ebitmap_convert (&types->types, &dst->types, mod->map[SYM_TYPES ])) + goto cleanup; + +if (ebitmap_convert (&types->negset, &dst->negset, mod->map[SYM_TYPES ])) + goto cleanup; + dst->flags = types->flags;return 0 ;@@ -988,13 +990,13 @@ static int type_set_convert(type_set_t * types, type_set_t * dst,/* OR 2 typemaps together and at the same time map the src types to * the correct values in the dst typeset. */ -static int type_set_or_convert (type_set_t * types,type_set_t * dst, -policy_module_t * mod,link_state_t * state) +static int type_set_or_convert (const type_set_t * types,type_set_t * dst, +const policy_module_t * mod) {type_set_t ts_tmp;type_set_init (&ts_tmp); -if (type_set_convert (types, &ts_tmp, mod, state) ==-1 ) { +if (type_set_convert (types, &ts_tmp, mod) ==-1 ) { goto cleanup; }if (type_set_or_eq (dst, &ts_tmp)) {@@ -1004,7 +1006,6 @@ static int type_set_or_convert(type_set_t * types, type_set_t * dst,return 0 ; cleanup: -ERR (state->handle,"Out of memory!" );type_set_destroy (&ts_tmp);return -1 ; }@@ -1012,18 +1013,11 @@ static int type_set_or_convert(type_set_t * types, type_set_t * dst,static int role_set_or_convert (role_set_t * roles,role_set_t * dst,policy_module_t * mod,link_state_t * state) { -unsigned int i;ebitmap_t tmp; -ebitmap_node_t *rnode;ebitmap_init (&tmp); -ebitmap_for_each_positive_bit (&roles->roles, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&roles->roles, &tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dst->roles, &tmp)) { goto cleanup; }@@ -1088,13 +1082,11 @@ static int mls_range_convert(mls_semantic_range_t * src, mls_semantic_range_t *static int role_fix_callback (hashtab_key_t key,hashtab_datum_t datum,void *data) { -unsigned int i;char *id = key;role_datum_t *role, *dest_role =NULL ;link_state_t *state = (link_state_t *) data;ebitmap_t e_tmp;policy_module_t *mod = state->cur; -ebitmap_node_t *rnode;hashtab_t role_tab; role = (role_datum_t *) datum;@@ -1111,30 +1103,20 @@ static int role_fix_callback(hashtab_key_t key, hashtab_datum_t datum, }ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&role->dominates, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&role->dominates, &e_tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dest_role->dominates, &e_tmp)) { goto cleanup; } -if (type_set_or_convert (&role->types, &dest_role->types, mod, state)) { +if (type_set_or_convert (&role->types, &dest_role->types, mod)) { goto cleanup; }ebitmap_destroy (&e_tmp);if (role->flavor ==ROLE_ATTRIB ) {ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&role->roles, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&role->roles, &e_tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dest_role->roles, &e_tmp)) { goto cleanup; }@@ -1152,13 +1134,11 @@ static int role_fix_callback(hashtab_key_t key, hashtab_datum_t datum,static int type_fix_callback (hashtab_key_t key,hashtab_datum_t datum,void *data) { -unsigned int i;char *id = key;type_datum_t *type, *new_type =NULL ;link_state_t *state = (link_state_t *) data;ebitmap_t e_tmp;policy_module_t *mod = state->cur; -ebitmap_node_t *tnode;symtab_t *typetab; type = (type_datum_t *) datum;@@ -1181,13 +1161,8 @@ static int type_fix_callback(hashtab_key_t key, hashtab_datum_t datum, }ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&type->types, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&type->types, &e_tmp, mod->map[SYM_TYPES ])) + goto cleanup;if (ebitmap_union (&new_type->types, &e_tmp)) { goto cleanup; }@@ -1269,9 +1244,8 @@ static int copy_avrule_list(avrule_t * list, avrule_t ** dst, new_rule->specified = cur->specified; new_rule->flags = cur->flags;if (type_set_convert - (&cur->stypes, &new_rule->stypes, module, state) ==-1 - ||type_set_convert (&cur->ttypes, &new_rule->ttypes, module, - state) ==-1 ) { + (&cur->stypes, &new_rule->stypes, module) ==-1 + ||type_set_convert (&cur->ttypes, &new_rule->ttypes, module) ==-1 ) { goto cleanup; }@@ -1355,8 +1329,6 @@ static int copy_role_trans_list(role_trans_rule_t * list, policy_module_t * module, link_state_t * state) {role_trans_rule_t *cur, *new_rule =NULL , *tail; -unsigned int i; -ebitmap_node_t *cnode; cur = list; tail = *dst;@@ -1374,19 +1346,12 @@ static int copy_role_trans_list(role_trans_rule_t * list,if (role_set_or_convert (&cur->roles, &new_rule->roles, module, state) ||type_set_or_convert (&cur->types, &new_rule->types, - module, state)) { + module)) { goto cleanup; } -ebitmap_for_each_positive_bit (&cur->classes, cnode, i) { -assert (module->map[SYM_CLASSES ][i]); -if (ebitmap_set_bit (&new_rule->classes, - module-> - map[SYM_CLASSES ][i] -1 , -1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&cur->classes, &new_rule->classes, module->map[SYM_CLASSES ])) + goto cleanup; new_rule->new_role = module->map[SYM_ROLES ][cur->new_role -1 ];@@ -1476,8 +1441,8 @@ static int copy_filename_trans_list(filename_trans_rule_t * list,if (!new_rule->name) goto err; -if (type_set_or_convert (&cur->stypes, &new_rule->stypes, module, state) || -type_set_or_convert (&cur->ttypes, &new_rule->ttypes, module, state)) +if (type_set_or_convert (&cur->stypes, &new_rule->stypes, module) || +type_set_or_convert (&cur->ttypes, &new_rule->ttypes, module)) goto err; new_rule->tclass = module->map[SYM_CLASSES ][cur->tclass -1 ];@@ -1497,8 +1462,6 @@ static int copy_range_trans_list(range_trans_rule_t * rules, policy_module_t * mod, link_state_t * state) {range_trans_rule_t *rule, *new_rule =NULL ; -unsigned int i; -ebitmap_node_t *cnode;for (rule = rules; rule; rule = rule->next) { new_rule =@@ -1512,21 +1475,15 @@ static int copy_range_trans_list(range_trans_rule_t * rules, *dst = new_rule;if (type_set_convert (&rule->stypes, &new_rule->stypes, - mod, state)) + mod)) goto cleanup;if (type_set_convert (&rule->ttypes, &new_rule->ttypes, - mod, state)) + mod)) goto cleanup; -ebitmap_for_each_positive_bit (&rule->tclasses, cnode, i) { -assert (mod->map[SYM_CLASSES ][i]); -if (ebitmap_set_bit - (&new_rule->tclasses, - mod->map[SYM_CLASSES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&rule->tclasses, &new_rule->tclasses, mod->map[SYM_CLASSES ])) + goto cleanup;if (mls_range_convert (&rule->trange, &new_rule->trange, mod, state)) goto cleanup;@@ -1688,15 +1645,12 @@ static int copy_scope_index(scope_index_t * src, scope_index_t * dest, } dest->class_perms_len = largest_mapped_class_value;for (i =0 ; i < src->class_perms_len; i++) { -ebitmap_t *srcmap = src->class_perms_map + i; +const ebitmap_t *srcmap = src->class_perms_map + i;ebitmap_t *destmap = dest->class_perms_map + module->map[SYM_CLASSES ][i] -1 ; -ebitmap_for_each_positive_bit (srcmap, node, j) { -if (ebitmap_set_bit (destmap, module->perm_map[i][j] -1 , -1 )) { - goto cleanup; - } - } + +if (ebitmap_convert (srcmap, destmap, module->perm_map[i])) + goto cleanup; }return 0 ; --2.36.1
Quoted 6 lines · James Carter
Quoted 3 lines · Christian Göttsche
Refactor the ebitmap conversions in
link.cinto its own function.
Quoted 9 lines
Quoted 6 lines
Do not log an OOM message twice on
type_set_or_convert()failure.Drop the now unused state parameter from
type_set_or_convert()andtype_set_convert().Signed-off-by Christian Göttsche <[email protected]>Acked-by James Carter <[email protected]>
I applied this patch, but none of the others from this series. This patch really fit better with the other ebitmap work that was being merged anyway.
Thanks,
Jim
Quoted 294 lines
Quoted 294 lines
--- libsepol/src/link.c | 140 +++++++++++++++----------------------------- 1 file changed, 47 insertions(+), 93 deletions(-)libsepol/src/link.c +47
-94@@ -958,26 +958,28 @@ static int alias_copy_callback(hashtab_key_t key, hashtab_datum_t datum,/*********** callbacks that fix bitmaps ***********/ -static int type_set_convert (type_set_t * types,type_set_t * dst, -policy_module_t * mod,link_state_t * state - __attribute__ ((unused))) +static int ebitmap_convert (const ebitmap_t *src,ebitmap_t *dst,const uint32_t *map) { -unsigned int i; -ebitmap_node_t *tnode; -ebitmap_for_each_positive_bit (&types->types, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&dst->types, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } - } -ebitmap_for_each_positive_bit (&types->negset, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&dst->negset, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } +unsigned int bit; +ebitmap_node_t *node; +ebitmap_for_each_positive_bit (src, node, bit) { +assert (map[bit]); +if (ebitmap_set_bit (dst, map[bit] -1 ,1 )) +return -1 ; } + +return 0 ; +} + +static int type_set_convert (const type_set_t * types,type_set_t * dst, +const policy_module_t * mod) +{ +if (ebitmap_convert (&types->types, &dst->types, mod->map[SYM_TYPES ])) + goto cleanup; + +if (ebitmap_convert (&types->negset, &dst->negset, mod->map[SYM_TYPES ])) + goto cleanup; + dst->flags = types->flags;return 0 ;@@ -988,13 +990,13 @@ static int type_set_convert(type_set_t * types, type_set_t * dst,/* OR 2 typemaps together and at the same time map the src types to * the correct values in the dst typeset. */ -static int type_set_or_convert (type_set_t * types,type_set_t * dst, -policy_module_t * mod,link_state_t * state) +static int type_set_or_convert (const type_set_t * types,type_set_t * dst, +const policy_module_t * mod) {type_set_t ts_tmp;type_set_init (&ts_tmp); -if (type_set_convert (types, &ts_tmp, mod, state) ==-1 ) { +if (type_set_convert (types, &ts_tmp, mod) ==-1 ) { goto cleanup; }if (type_set_or_eq (dst, &ts_tmp)) {@@ -1004,7 +1006,6 @@ static int type_set_or_convert(type_set_t * types, type_set_t * dst,return 0 ; cleanup: -ERR (state->handle,"Out of memory!" );type_set_destroy (&ts_tmp);return -1 ; }@@ -1012,18 +1013,11 @@ static int type_set_or_convert(type_set_t * types, type_set_t * dst,static int role_set_or_convert (role_set_t * roles,role_set_t * dst,policy_module_t * mod,link_state_t * state) { -unsigned int i;ebitmap_t tmp; -ebitmap_node_t *rnode;ebitmap_init (&tmp); -ebitmap_for_each_positive_bit (&roles->roles, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&roles->roles, &tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dst->roles, &tmp)) { goto cleanup; }@@ -1088,13 +1082,11 @@ static int mls_range_convert(mls_semantic_range_t * src, mls_semantic_range_t *static int role_fix_callback (hashtab_key_t key,hashtab_datum_t datum,void *data) { -unsigned int i;char *id = key;role_datum_t *role, *dest_role =NULL ;link_state_t *state = (link_state_t *) data;ebitmap_t e_tmp;policy_module_t *mod = state->cur; -ebitmap_node_t *rnode;hashtab_t role_tab; role = (role_datum_t *) datum;@@ -1111,30 +1103,20 @@ static int role_fix_callback(hashtab_key_t key, hashtab_datum_t datum, }ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&role->dominates, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&role->dominates, &e_tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dest_role->dominates, &e_tmp)) { goto cleanup; } -if (type_set_or_convert (&role->types, &dest_role->types, mod, state)) { +if (type_set_or_convert (&role->types, &dest_role->types, mod)) { goto cleanup; }ebitmap_destroy (&e_tmp);if (role->flavor ==ROLE_ATTRIB ) {ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&role->roles, rnode, i) { -assert (mod->map[SYM_ROLES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_ROLES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&role->roles, &e_tmp, mod->map[SYM_ROLES ])) + goto cleanup;if (ebitmap_union (&dest_role->roles, &e_tmp)) { goto cleanup; }@@ -1152,13 +1134,11 @@ static int role_fix_callback(hashtab_key_t key, hashtab_datum_t datum,static int type_fix_callback (hashtab_key_t key,hashtab_datum_t datum,void *data) { -unsigned int i;char *id = key;type_datum_t *type, *new_type =NULL ;link_state_t *state = (link_state_t *) data;ebitmap_t e_tmp;policy_module_t *mod = state->cur; -ebitmap_node_t *tnode;symtab_t *typetab; type = (type_datum_t *) datum;@@ -1181,13 +1161,8 @@ static int type_fix_callback(hashtab_key_t key, hashtab_datum_t datum, }ebitmap_init (&e_tmp); -ebitmap_for_each_positive_bit (&type->types, tnode, i) { -assert (mod->map[SYM_TYPES ][i]); -if (ebitmap_set_bit - (&e_tmp, mod->map[SYM_TYPES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&type->types, &e_tmp, mod->map[SYM_TYPES ])) + goto cleanup;if (ebitmap_union (&new_type->types, &e_tmp)) { goto cleanup; }@@ -1269,9 +1244,8 @@ static int copy_avrule_list(avrule_t * list, avrule_t ** dst, new_rule->specified = cur->specified; new_rule->flags = cur->flags;if (type_set_convert - (&cur->stypes, &new_rule->stypes, module, state) ==-1 - ||type_set_convert (&cur->ttypes, &new_rule->ttypes, module, - state) ==-1 ) { + (&cur->stypes, &new_rule->stypes, module) ==-1 + ||type_set_convert (&cur->ttypes, &new_rule->ttypes, module) ==-1 ) { goto cleanup; }@@ -1355,8 +1329,6 @@ static int copy_role_trans_list(role_trans_rule_t * list, policy_module_t * module, link_state_t * state) {role_trans_rule_t *cur, *new_rule =NULL , *tail; -unsigned int i; -ebitmap_node_t *cnode; cur = list; tail = *dst;@@ -1374,19 +1346,12 @@ static int copy_role_trans_list(role_trans_rule_t * list,if (role_set_or_convert (&cur->roles, &new_rule->roles, module, state) ||type_set_or_convert (&cur->types, &new_rule->types, - module, state)) { + module)) { goto cleanup; } -ebitmap_for_each_positive_bit (&cur->classes, cnode, i) { -assert (module->map[SYM_CLASSES ][i]); -if (ebitmap_set_bit (&new_rule->classes, - module-> - map[SYM_CLASSES ][i] -1 , -1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&cur->classes, &new_rule->classes, module->map[SYM_CLASSES ])) + goto cleanup; new_rule->new_role = module->map[SYM_ROLES ][cur->new_role -1 ];@@ -1476,8 +1441,8 @@ static int copy_filename_trans_list(filename_trans_rule_t * list,if (!new_rule->name) goto err; -if (type_set_or_convert (&cur->stypes, &new_rule->stypes, module, state) || -type_set_or_convert (&cur->ttypes, &new_rule->ttypes, module, state)) +if (type_set_or_convert (&cur->stypes, &new_rule->stypes, module) || +type_set_or_convert (&cur->ttypes, &new_rule->ttypes, module)) goto err; new_rule->tclass = module->map[SYM_CLASSES ][cur->tclass -1 ];@@ -1497,8 +1462,6 @@ static int copy_range_trans_list(range_trans_rule_t * rules, policy_module_t * mod, link_state_t * state) {range_trans_rule_t *rule, *new_rule =NULL ; -unsigned int i; -ebitmap_node_t *cnode;for (rule = rules; rule; rule = rule->next) { new_rule =@@ -1512,21 +1475,15 @@ static int copy_range_trans_list(range_trans_rule_t * rules, *dst = new_rule;if (type_set_convert (&rule->stypes, &new_rule->stypes, - mod, state)) + mod)) goto cleanup;if (type_set_convert (&rule->ttypes, &new_rule->ttypes, - mod, state)) + mod)) goto cleanup; -ebitmap_for_each_positive_bit (&rule->tclasses, cnode, i) { -assert (mod->map[SYM_CLASSES ][i]); -if (ebitmap_set_bit - (&new_rule->tclasses, - mod->map[SYM_CLASSES ][i] -1 ,1 )) { - goto cleanup; - } - } +if (ebitmap_convert (&rule->tclasses, &new_rule->tclasses, mod->map[SYM_CLASSES ])) + goto cleanup;if (mls_range_convert (&rule->trange, &new_rule->trange, mod, state)) goto cleanup;@@ -1688,15 +1645,12 @@ static int copy_scope_index(scope_index_t * src, scope_index_t * dest, } dest->class_perms_len = largest_mapped_class_value;for (i =0 ; i < src->class_perms_len; i++) { -ebitmap_t *srcmap = src->class_perms_map + i; +const ebitmap_t *srcmap = src->class_perms_map + i;ebitmap_t *destmap = dest->class_perms_map + module->map[SYM_CLASSES ][i] -1 ; -ebitmap_for_each_positive_bit (srcmap, node, j) { -if (ebitmap_set_bit (destmap, module->perm_map[i][j] -1 , -1 )) { - goto cleanup; - } - } + +if (ebitmap_convert (srcmap, destmap, module->perm_map[i])) + goto cleanup; }return 0 ; --2.36.1