2 * CIPSO - Commercial IP Security Option
4 * This is an implementation of the CIPSO 2.2 protocol as specified in
5 * draft-ietf-cipso-ipsecurity-01.txt with additional tag types as found in
6 * FIPS-188, copies of both documents can be found in the Documentation
7 * directory. While CIPSO never became a full IETF RFC standard many vendors
8 * have chosen to adopt the protocol and over the years it has become a
9 * de-facto standard for labeled networking.
11 * Author: Paul Moore <paul.moore@hp.com>
16 * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2 of the License, or
21 * (at your option) any later version.
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
26 * the GNU General Public License for more details.
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 #include <linux/init.h>
35 #include <linux/types.h>
36 #include <linux/rcupdate.h>
37 #include <linux/list.h>
38 #include <linux/spinlock.h>
39 #include <linux/string.h>
40 #include <linux/jhash.h>
44 #include <net/netlabel.h>
45 #include <net/cipso_ipv4.h>
46 #include <asm/atomic.h>
49 struct cipso_v4_domhsh_entry {
52 struct list_head list;
56 /* List of available DOI definitions */
57 /* XXX - Updates should be minimal so having a single lock for the
58 * cipso_v4_doi_list and the cipso_v4_doi_list->dom_list should be
60 /* XXX - This currently assumes a minimal number of different DOIs in use,
61 * if in practice there are a lot of different DOIs this list should
62 * probably be turned into a hash table or something similar so we
63 * can do quick lookups. */
64 static DEFINE_SPINLOCK(cipso_v4_doi_list_lock);
65 static struct list_head cipso_v4_doi_list = LIST_HEAD_INIT(cipso_v4_doi_list);
67 /* Label mapping cache */
68 int cipso_v4_cache_enabled = 1;
69 int cipso_v4_cache_bucketsize = 10;
70 #define CIPSO_V4_CACHE_BUCKETBITS 7
71 #define CIPSO_V4_CACHE_BUCKETS (1 << CIPSO_V4_CACHE_BUCKETBITS)
72 #define CIPSO_V4_CACHE_REORDERLIMIT 10
73 struct cipso_v4_map_cache_bkt {
76 struct list_head list;
78 struct cipso_v4_map_cache_entry {
83 struct netlbl_lsm_cache *lsm_data;
86 struct list_head list;
88 static struct cipso_v4_map_cache_bkt *cipso_v4_cache = NULL;
90 /* Restricted bitmap (tag #1) flags */
91 int cipso_v4_rbm_optfmt = 0;
92 int cipso_v4_rbm_strictvalid = 1;
99 * cipso_v4_bitmap_walk - Walk a bitmap looking for a bit
100 * @bitmap: the bitmap
101 * @bitmap_len: length in bits
102 * @offset: starting offset
103 * @state: if non-zero, look for a set (1) bit else look for a cleared (0) bit
106 * Starting at @offset, walk the bitmap from left to right until either the
107 * desired bit is found or we reach the end. Return the bit offset, -1 if
108 * not found, or -2 if error.
110 static int cipso_v4_bitmap_walk(const unsigned char *bitmap,
117 unsigned char bitmask;
120 /* gcc always rounds to zero when doing integer division */
121 byte_offset = offset / 8;
122 byte = bitmap[byte_offset];
124 bitmask = 0x80 >> (offset % 8);
126 while (bit_spot < bitmap_len) {
127 if ((state && (byte & bitmask) == bitmask) ||
128 (state == 0 && (byte & bitmask) == 0))
134 byte = bitmap[++byte_offset];
143 * cipso_v4_bitmap_setbit - Sets a single bit in a bitmap
144 * @bitmap: the bitmap
146 * @state: if non-zero, set the bit (1) else clear the bit (0)
149 * Set a single bit in the bitmask. Returns zero on success, negative values
152 static void cipso_v4_bitmap_setbit(unsigned char *bitmap,
159 /* gcc always rounds to zero when doing integer division */
161 bitmask = 0x80 >> (bit % 8);
163 bitmap[byte_spot] |= bitmask;
165 bitmap[byte_spot] &= ~bitmask;
169 * cipso_v4_doi_domhsh_free - Frees a domain list entry
170 * @entry: the entry's RCU field
173 * This function is designed to be used as a callback to the call_rcu()
174 * function so that the memory allocated to a domain list entry can be released
178 static void cipso_v4_doi_domhsh_free(struct rcu_head *entry)
180 struct cipso_v4_domhsh_entry *ptr;
182 ptr = container_of(entry, struct cipso_v4_domhsh_entry, rcu);
188 * cipso_v4_cache_entry_free - Frees a cache entry
189 * @entry: the entry to free
192 * This function frees the memory associated with a cache entry including the
193 * LSM cache data if there are no longer any users, i.e. reference count == 0.
196 static void cipso_v4_cache_entry_free(struct cipso_v4_map_cache_entry *entry)
199 netlbl_secattr_cache_free(entry->lsm_data);
205 * cipso_v4_map_cache_hash - Hashing function for the CIPSO cache
207 * @key_len: the length of the key in bytes
210 * The CIPSO tag hashing function. Returns a 32-bit hash value.
213 static u32 cipso_v4_map_cache_hash(const unsigned char *key, u32 key_len)
215 return jhash(key, key_len, 0);
219 * Label Mapping Cache Functions
223 * cipso_v4_cache_init - Initialize the CIPSO cache
226 * Initializes the CIPSO label mapping cache, this function should be called
227 * before any of the other functions defined in this file. Returns zero on
228 * success, negative values on error.
231 static int cipso_v4_cache_init(void)
235 cipso_v4_cache = kcalloc(CIPSO_V4_CACHE_BUCKETS,
236 sizeof(struct cipso_v4_map_cache_bkt),
238 if (cipso_v4_cache == NULL)
241 for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {
242 spin_lock_init(&cipso_v4_cache[iter].lock);
243 cipso_v4_cache[iter].size = 0;
244 INIT_LIST_HEAD(&cipso_v4_cache[iter].list);
251 * cipso_v4_cache_invalidate - Invalidates the current CIPSO cache
254 * Invalidates and frees any entries in the CIPSO cache. Returns zero on
255 * success and negative values on failure.
258 void cipso_v4_cache_invalidate(void)
260 struct cipso_v4_map_cache_entry *entry, *tmp_entry;
263 for (iter = 0; iter < CIPSO_V4_CACHE_BUCKETS; iter++) {
264 spin_lock_bh(&cipso_v4_cache[iter].lock);
265 list_for_each_entry_safe(entry,
267 &cipso_v4_cache[iter].list, list) {
268 list_del(&entry->list);
269 cipso_v4_cache_entry_free(entry);
271 cipso_v4_cache[iter].size = 0;
272 spin_unlock_bh(&cipso_v4_cache[iter].lock);
279 * cipso_v4_cache_check - Check the CIPSO cache for a label mapping
280 * @key: the buffer to check
281 * @key_len: buffer length in bytes
282 * @secattr: the security attribute struct to use
285 * This function checks the cache to see if a label mapping already exists for
286 * the given key. If there is a match then the cache is adjusted and the
287 * @secattr struct is populated with the correct LSM security attributes. The
288 * cache is adjusted in the following manner if the entry is not already the
289 * first in the cache bucket:
291 * 1. The cache entry's activity counter is incremented
292 * 2. The previous (higher ranking) entry's activity counter is decremented
293 * 3. If the difference between the two activity counters is geater than
294 * CIPSO_V4_CACHE_REORDERLIMIT the two entries are swapped
296 * Returns zero on success, -ENOENT for a cache miss, and other negative values
300 static int cipso_v4_cache_check(const unsigned char *key,
302 struct netlbl_lsm_secattr *secattr)
305 struct cipso_v4_map_cache_entry *entry;
306 struct cipso_v4_map_cache_entry *prev_entry = NULL;
309 if (!cipso_v4_cache_enabled)
312 hash = cipso_v4_map_cache_hash(key, key_len);
313 bkt = hash & (CIPSO_V4_CACHE_BUCKETBITS - 1);
314 spin_lock_bh(&cipso_v4_cache[bkt].lock);
315 list_for_each_entry(entry, &cipso_v4_cache[bkt].list, list) {
316 if (entry->hash == hash &&
317 entry->key_len == key_len &&
318 memcmp(entry->key, key, key_len) == 0) {
319 entry->activity += 1;
320 atomic_inc(&entry->lsm_data->refcount);
321 secattr->cache = entry->lsm_data;
322 if (prev_entry == NULL) {
323 spin_unlock_bh(&cipso_v4_cache[bkt].lock);
327 if (prev_entry->activity > 0)
328 prev_entry->activity -= 1;
329 if (entry->activity > prev_entry->activity &&
330 entry->activity - prev_entry->activity >
331 CIPSO_V4_CACHE_REORDERLIMIT) {
332 __list_del(entry->list.prev, entry->list.next);
333 __list_add(&entry->list,
334 prev_entry->list.prev,
338 spin_unlock_bh(&cipso_v4_cache[bkt].lock);
343 spin_unlock_bh(&cipso_v4_cache[bkt].lock);
349 * cipso_v4_cache_add - Add an entry to the CIPSO cache
351 * @secattr: the packet's security attributes
354 * Add a new entry into the CIPSO label mapping cache. Add the new entry to
355 * head of the cache bucket's list, if the cache bucket is out of room remove
356 * the last entry in the list first. It is important to note that there is
357 * currently no checking for duplicate keys. Returns zero on success,
358 * negative values on failure.
361 int cipso_v4_cache_add(const struct sk_buff *skb,
362 const struct netlbl_lsm_secattr *secattr)
364 int ret_val = -EPERM;
366 struct cipso_v4_map_cache_entry *entry = NULL;
367 struct cipso_v4_map_cache_entry *old_entry = NULL;
368 unsigned char *cipso_ptr;
371 if (!cipso_v4_cache_enabled || cipso_v4_cache_bucketsize <= 0)
374 cipso_ptr = CIPSO_V4_OPTPTR(skb);
375 cipso_ptr_len = cipso_ptr[1];
377 entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
380 entry->key = kmalloc(cipso_ptr_len, GFP_ATOMIC);
381 if (entry->key == NULL) {
383 goto cache_add_failure;
385 memcpy(entry->key, cipso_ptr, cipso_ptr_len);
386 entry->key_len = cipso_ptr_len;
387 entry->hash = cipso_v4_map_cache_hash(cipso_ptr, cipso_ptr_len);
388 atomic_inc(&secattr->cache->refcount);
389 entry->lsm_data = secattr->cache;
391 bkt = entry->hash & (CIPSO_V4_CACHE_BUCKETBITS - 1);
392 spin_lock_bh(&cipso_v4_cache[bkt].lock);
393 if (cipso_v4_cache[bkt].size < cipso_v4_cache_bucketsize) {
394 list_add(&entry->list, &cipso_v4_cache[bkt].list);
395 cipso_v4_cache[bkt].size += 1;
397 old_entry = list_entry(cipso_v4_cache[bkt].list.prev,
398 struct cipso_v4_map_cache_entry, list);
399 list_del(&old_entry->list);
400 list_add(&entry->list, &cipso_v4_cache[bkt].list);
401 cipso_v4_cache_entry_free(old_entry);
403 spin_unlock_bh(&cipso_v4_cache[bkt].lock);
409 cipso_v4_cache_entry_free(entry);
418 * cipso_v4_doi_search - Searches for a DOI definition
419 * @doi: the DOI to search for
422 * Search the DOI definition list for a DOI definition with a DOI value that
423 * matches @doi. The caller is responsibile for calling rcu_read_[un]lock().
424 * Returns a pointer to the DOI definition on success and NULL on failure.
426 static struct cipso_v4_doi *cipso_v4_doi_search(u32 doi)
428 struct cipso_v4_doi *iter;
430 list_for_each_entry_rcu(iter, &cipso_v4_doi_list, list)
431 if (iter->doi == doi && iter->valid)
437 * cipso_v4_doi_add - Add a new DOI to the CIPSO protocol engine
438 * @doi_def: the DOI structure
441 * The caller defines a new DOI for use by the CIPSO engine and calls this
442 * function to add it to the list of acceptable domains. The caller must
443 * ensure that the mapping table specified in @doi_def->map meets all of the
444 * requirements of the mapping type (see cipso_ipv4.h for details). Returns
445 * zero on success and non-zero on failure.
448 int cipso_v4_doi_add(struct cipso_v4_doi *doi_def)
450 if (doi_def == NULL || doi_def->doi == CIPSO_V4_DOI_UNKNOWN)
454 INIT_RCU_HEAD(&doi_def->rcu);
455 INIT_LIST_HEAD(&doi_def->dom_list);
458 if (cipso_v4_doi_search(doi_def->doi) != NULL)
459 goto doi_add_failure_rlock;
460 spin_lock(&cipso_v4_doi_list_lock);
461 if (cipso_v4_doi_search(doi_def->doi) != NULL)
462 goto doi_add_failure_slock;
463 list_add_tail_rcu(&doi_def->list, &cipso_v4_doi_list);
464 spin_unlock(&cipso_v4_doi_list_lock);
469 doi_add_failure_slock:
470 spin_unlock(&cipso_v4_doi_list_lock);
471 doi_add_failure_rlock:
477 * cipso_v4_doi_remove - Remove an existing DOI from the CIPSO protocol engine
478 * @doi: the DOI value
479 * @audit_secid: the LSM secid to use in the audit message
480 * @callback: the DOI cleanup/free callback
483 * Removes a DOI definition from the CIPSO engine, @callback is called to
484 * free any memory. The NetLabel routines will be called to release their own
485 * LSM domain mappings as well as our own domain list. Returns zero on
486 * success and negative values on failure.
489 int cipso_v4_doi_remove(u32 doi,
490 struct netlbl_audit *audit_info,
491 void (*callback) (struct rcu_head * head))
493 struct cipso_v4_doi *doi_def;
494 struct cipso_v4_domhsh_entry *dom_iter;
497 if (cipso_v4_doi_search(doi) != NULL) {
498 spin_lock(&cipso_v4_doi_list_lock);
499 doi_def = cipso_v4_doi_search(doi);
500 if (doi_def == NULL) {
501 spin_unlock(&cipso_v4_doi_list_lock);
506 list_del_rcu(&doi_def->list);
507 spin_unlock(&cipso_v4_doi_list_lock);
508 list_for_each_entry_rcu(dom_iter, &doi_def->dom_list, list)
510 netlbl_domhsh_remove(dom_iter->domain,
512 cipso_v4_cache_invalidate();
515 call_rcu(&doi_def->rcu, callback);
524 * cipso_v4_doi_getdef - Returns a pointer to a valid DOI definition
525 * @doi: the DOI value
528 * Searches for a valid DOI definition and if one is found it is returned to
529 * the caller. Otherwise NULL is returned. The caller must ensure that
530 * rcu_read_lock() is held while accessing the returned definition.
533 struct cipso_v4_doi *cipso_v4_doi_getdef(u32 doi)
535 return cipso_v4_doi_search(doi);
539 * cipso_v4_doi_walk - Iterate through the DOI definitions
540 * @skip_cnt: skip past this number of DOI definitions, updated
541 * @callback: callback for each DOI definition
542 * @cb_arg: argument for the callback function
545 * Iterate over the DOI definition list, skipping the first @skip_cnt entries.
546 * For each entry call @callback, if @callback returns a negative value stop
547 * 'walking' through the list and return. Updates the value in @skip_cnt upon
548 * return. Returns zero on success, negative values on failure.
551 int cipso_v4_doi_walk(u32 *skip_cnt,
552 int (*callback) (struct cipso_v4_doi *doi_def, void *arg),
555 int ret_val = -ENOENT;
557 struct cipso_v4_doi *iter_doi;
560 list_for_each_entry_rcu(iter_doi, &cipso_v4_doi_list, list)
561 if (iter_doi->valid) {
562 if (doi_cnt++ < *skip_cnt)
564 ret_val = callback(iter_doi, cb_arg);
567 goto doi_walk_return;
578 * cipso_v4_doi_domhsh_add - Adds a domain entry to a DOI definition
579 * @doi_def: the DOI definition
580 * @domain: the domain to add
583 * Adds the @domain to the the DOI specified by @doi_def, this function
584 * should only be called by external functions (i.e. NetLabel). This function
585 * does allocate memory. Returns zero on success, negative values on failure.
588 int cipso_v4_doi_domhsh_add(struct cipso_v4_doi *doi_def, const char *domain)
590 struct cipso_v4_domhsh_entry *iter;
591 struct cipso_v4_domhsh_entry *new_dom;
593 new_dom = kzalloc(sizeof(*new_dom), GFP_KERNEL);
597 new_dom->domain = kstrdup(domain, GFP_KERNEL);
598 if (new_dom->domain == NULL) {
604 INIT_RCU_HEAD(&new_dom->rcu);
607 spin_lock(&cipso_v4_doi_list_lock);
608 list_for_each_entry_rcu(iter, &doi_def->dom_list, list)
610 ((domain != NULL && iter->domain != NULL &&
611 strcmp(iter->domain, domain) == 0) ||
612 (domain == NULL && iter->domain == NULL))) {
613 spin_unlock(&cipso_v4_doi_list_lock);
615 kfree(new_dom->domain);
619 list_add_tail_rcu(&new_dom->list, &doi_def->dom_list);
620 spin_unlock(&cipso_v4_doi_list_lock);
627 * cipso_v4_doi_domhsh_remove - Removes a domain entry from a DOI definition
628 * @doi_def: the DOI definition
629 * @domain: the domain to remove
632 * Removes the @domain from the DOI specified by @doi_def, this function
633 * should only be called by external functions (i.e. NetLabel). Returns zero
634 * on success and negative values on error.
637 int cipso_v4_doi_domhsh_remove(struct cipso_v4_doi *doi_def,
640 struct cipso_v4_domhsh_entry *iter;
643 spin_lock(&cipso_v4_doi_list_lock);
644 list_for_each_entry_rcu(iter, &doi_def->dom_list, list)
646 ((domain != NULL && iter->domain != NULL &&
647 strcmp(iter->domain, domain) == 0) ||
648 (domain == NULL && iter->domain == NULL))) {
650 list_del_rcu(&iter->list);
651 spin_unlock(&cipso_v4_doi_list_lock);
653 call_rcu(&iter->rcu, cipso_v4_doi_domhsh_free);
657 spin_unlock(&cipso_v4_doi_list_lock);
664 * Label Mapping Functions
668 * cipso_v4_map_lvl_valid - Checks to see if the given level is understood
669 * @doi_def: the DOI definition
670 * @level: the level to check
673 * Checks the given level against the given DOI definition and returns a
674 * negative value if the level does not have a valid mapping and a zero value
675 * if the level is defined by the DOI.
678 static int cipso_v4_map_lvl_valid(const struct cipso_v4_doi *doi_def, u8 level)
680 switch (doi_def->type) {
681 case CIPSO_V4_MAP_PASS:
683 case CIPSO_V4_MAP_STD:
684 if (doi_def->map.std->lvl.cipso[level] < CIPSO_V4_INV_LVL)
693 * cipso_v4_map_lvl_hton - Perform a level mapping from the host to the network
694 * @doi_def: the DOI definition
695 * @host_lvl: the host MLS level
696 * @net_lvl: the network/CIPSO MLS level
699 * Perform a label mapping to translate a local MLS level to the correct
700 * CIPSO level using the given DOI definition. Returns zero on success,
701 * negative values otherwise.
704 static int cipso_v4_map_lvl_hton(const struct cipso_v4_doi *doi_def,
708 switch (doi_def->type) {
709 case CIPSO_V4_MAP_PASS:
712 case CIPSO_V4_MAP_STD:
713 if (host_lvl < doi_def->map.std->lvl.local_size) {
714 *net_lvl = doi_def->map.std->lvl.local[host_lvl];
724 * cipso_v4_map_lvl_ntoh - Perform a level mapping from the network to the host
725 * @doi_def: the DOI definition
726 * @net_lvl: the network/CIPSO MLS level
727 * @host_lvl: the host MLS level
730 * Perform a label mapping to translate a CIPSO level to the correct local MLS
731 * level using the given DOI definition. Returns zero on success, negative
735 static int cipso_v4_map_lvl_ntoh(const struct cipso_v4_doi *doi_def,
739 struct cipso_v4_std_map_tbl *map_tbl;
741 switch (doi_def->type) {
742 case CIPSO_V4_MAP_PASS:
745 case CIPSO_V4_MAP_STD:
746 map_tbl = doi_def->map.std;
747 if (net_lvl < map_tbl->lvl.cipso_size &&
748 map_tbl->lvl.cipso[net_lvl] < CIPSO_V4_INV_LVL) {
749 *host_lvl = doi_def->map.std->lvl.cipso[net_lvl];
759 * cipso_v4_map_cat_rbm_valid - Checks to see if the category bitmap is valid
760 * @doi_def: the DOI definition
761 * @bitmap: category bitmap
762 * @bitmap_len: bitmap length in bytes
765 * Checks the given category bitmap against the given DOI definition and
766 * returns a negative value if any of the categories in the bitmap do not have
767 * a valid mapping and a zero value if all of the categories are valid.
770 static int cipso_v4_map_cat_rbm_valid(const struct cipso_v4_doi *doi_def,
771 const unsigned char *bitmap,
775 u32 bitmap_len_bits = bitmap_len * 8;
776 u32 cipso_cat_size = doi_def->map.std->cat.cipso_size;
777 u32 *cipso_array = doi_def->map.std->cat.cipso;
779 switch (doi_def->type) {
780 case CIPSO_V4_MAP_PASS:
782 case CIPSO_V4_MAP_STD:
784 cat = cipso_v4_bitmap_walk(bitmap,
790 if (cat >= cipso_cat_size ||
791 cipso_array[cat] >= CIPSO_V4_INV_CAT)
804 * cipso_v4_map_cat_rbm_hton - Perform a category mapping from host to network
805 * @doi_def: the DOI definition
806 * @host_cat: the category bitmap in host format
807 * @host_cat_len: the length of the host's category bitmap in bytes
808 * @net_cat: the zero'd out category bitmap in network/CIPSO format
809 * @net_cat_len: the length of the CIPSO bitmap in bytes
812 * Perform a label mapping to translate a local MLS category bitmap to the
813 * correct CIPSO bitmap using the given DOI definition. Returns the minimum
814 * size in bytes of the network bitmap on success, negative values otherwise.
817 static int cipso_v4_map_cat_rbm_hton(const struct cipso_v4_doi *doi_def,
818 const unsigned char *host_cat,
820 unsigned char *net_cat,
825 u32 net_spot_max = 0;
826 u32 host_clen_bits = host_cat_len * 8;
827 u32 net_clen_bits = net_cat_len * 8;
828 u32 host_cat_size = doi_def->map.std->cat.local_size;
829 u32 *host_cat_array = doi_def->map.std->cat.local;
831 switch (doi_def->type) {
832 case CIPSO_V4_MAP_PASS:
833 net_spot_max = host_cat_len - 1;
834 while (net_spot_max > 0 && host_cat[net_spot_max] == 0)
836 if (net_spot_max > net_cat_len)
838 memcpy(net_cat, host_cat, net_spot_max);
840 case CIPSO_V4_MAP_STD:
842 host_spot = cipso_v4_bitmap_walk(host_cat,
848 if (host_spot >= host_cat_size)
851 net_spot = host_cat_array[host_spot];
852 if (net_spot >= net_clen_bits)
854 cipso_v4_bitmap_setbit(net_cat, net_spot, 1);
856 if (net_spot > net_spot_max)
857 net_spot_max = net_spot;
863 if (++net_spot_max % 8)
864 return net_spot_max / 8 + 1;
865 return net_spot_max / 8;
872 * cipso_v4_map_cat_rbm_ntoh - Perform a category mapping from network to host
873 * @doi_def: the DOI definition
874 * @net_cat: the category bitmap in network/CIPSO format
875 * @net_cat_len: the length of the CIPSO bitmap in bytes
876 * @host_cat: the zero'd out category bitmap in host format
877 * @host_cat_len: the length of the host's category bitmap in bytes
880 * Perform a label mapping to translate a CIPSO bitmap to the correct local
881 * MLS category bitmap using the given DOI definition. Returns the minimum
882 * size in bytes of the host bitmap on success, negative values otherwise.
885 static int cipso_v4_map_cat_rbm_ntoh(const struct cipso_v4_doi *doi_def,
886 const unsigned char *net_cat,
888 unsigned char *host_cat,
892 u32 host_spot_max = 0;
894 u32 net_clen_bits = net_cat_len * 8;
895 u32 host_clen_bits = host_cat_len * 8;
896 u32 net_cat_size = doi_def->map.std->cat.cipso_size;
897 u32 *net_cat_array = doi_def->map.std->cat.cipso;
899 switch (doi_def->type) {
900 case CIPSO_V4_MAP_PASS:
901 if (net_cat_len > host_cat_len)
903 memcpy(host_cat, net_cat, net_cat_len);
905 case CIPSO_V4_MAP_STD:
907 net_spot = cipso_v4_bitmap_walk(net_cat,
913 if (net_spot >= net_cat_size ||
914 net_cat_array[net_spot] >= CIPSO_V4_INV_CAT)
917 host_spot = net_cat_array[net_spot];
918 if (host_spot >= host_clen_bits)
920 cipso_v4_bitmap_setbit(host_cat, host_spot, 1);
922 if (host_spot > host_spot_max)
923 host_spot_max = host_spot;
929 if (++host_spot_max % 8)
930 return host_spot_max / 8 + 1;
931 return host_spot_max / 8;
938 * Protocol Handling Functions
941 #define CIPSO_V4_HDR_LEN 6
944 * cipso_v4_gentag_hdr - Generate a CIPSO option header
945 * @doi_def: the DOI definition
946 * @len: the total tag length in bytes
947 * @buf: the CIPSO option buffer
950 * Write a CIPSO header into the beginning of @buffer. Return zero on success,
951 * negative values on failure.
954 static int cipso_v4_gentag_hdr(const struct cipso_v4_doi *doi_def,
958 if (CIPSO_V4_HDR_LEN + len > 40)
961 buf[0] = IPOPT_CIPSO;
962 buf[1] = CIPSO_V4_HDR_LEN + len;
963 *(u32 *)&buf[2] = htonl(doi_def->doi);
968 #define CIPSO_V4_TAG1_CAT_LEN 30
971 * cipso_v4_gentag_rbm - Generate a CIPSO restricted bitmap tag (type #1)
972 * @doi_def: the DOI definition
973 * @secattr: the security attributes
974 * @buffer: the option buffer
975 * @buffer_len: length of buffer in bytes
978 * Generate a CIPSO option using the restricted bitmap tag, tag type #1. The
979 * actual buffer length may be larger than the indicated size due to
980 * translation between host and network category bitmaps. Returns zero on
981 * success, negative values on failure.
984 static int cipso_v4_gentag_rbm(const struct cipso_v4_doi *doi_def,
985 const struct netlbl_lsm_secattr *secattr,
986 unsigned char **buffer,
989 int ret_val = -EPERM;
990 unsigned char *buf = NULL;
994 if (secattr->mls_cat) {
995 buf = kzalloc(CIPSO_V4_HDR_LEN + 4 + CIPSO_V4_TAG1_CAT_LEN,
1000 ret_val = cipso_v4_map_cat_rbm_hton(doi_def,
1002 secattr->mls_cat_len,
1003 &buf[CIPSO_V4_HDR_LEN + 4],
1004 CIPSO_V4_TAG1_CAT_LEN);
1006 goto gentag_failure;
1008 /* This will send packets using the "optimized" format when
1009 * possibile as specified in section 3.4.2.6 of the
1011 if (cipso_v4_rbm_optfmt && (ret_val > 0 && ret_val < 10))
1014 buf_len = 4 + ret_val;
1016 buf = kzalloc(CIPSO_V4_HDR_LEN + 4, GFP_ATOMIC);
1022 ret_val = cipso_v4_map_lvl_hton(doi_def, secattr->mls_lvl, &level);
1024 goto gentag_failure;
1026 ret_val = cipso_v4_gentag_hdr(doi_def, buf_len, buf);
1028 goto gentag_failure;
1030 buf[CIPSO_V4_HDR_LEN] = 0x01;
1031 buf[CIPSO_V4_HDR_LEN + 1] = buf_len;
1032 buf[CIPSO_V4_HDR_LEN + 3] = level;
1035 *buffer_len = CIPSO_V4_HDR_LEN + buf_len;
1045 * cipso_v4_parsetag_rbm - Parse a CIPSO restricted bitmap tag
1046 * @doi_def: the DOI definition
1047 * @tag: the CIPSO tag
1048 * @secattr: the security attributes
1051 * Parse a CIPSO restricted bitmap tag (tag type #1) and return the security
1052 * attributes in @secattr. Return zero on success, negatives values on
1056 static int cipso_v4_parsetag_rbm(const struct cipso_v4_doi *doi_def,
1057 const unsigned char *tag,
1058 struct netlbl_lsm_secattr *secattr)
1061 u8 tag_len = tag[1];
1064 ret_val = cipso_v4_map_lvl_ntoh(doi_def, tag[3], &level);
1067 secattr->mls_lvl = level;
1068 secattr->mls_lvl_vld = 1;
1071 switch (doi_def->type) {
1072 case CIPSO_V4_MAP_PASS:
1073 secattr->mls_cat_len = tag_len - 4;
1075 case CIPSO_V4_MAP_STD:
1076 secattr->mls_cat_len =
1077 doi_def->map.std->cat.local_size;
1080 secattr->mls_cat = kzalloc(secattr->mls_cat_len, GFP_ATOMIC);
1081 if (secattr->mls_cat == NULL)
1084 ret_val = cipso_v4_map_cat_rbm_ntoh(doi_def,
1088 secattr->mls_cat_len);
1090 kfree(secattr->mls_cat);
1093 secattr->mls_cat_len = ret_val;
1100 * cipso_v4_validate - Validate a CIPSO option
1101 * @option: the start of the option, on error it is set to point to the error
1104 * This routine is called to validate a CIPSO option, it checks all of the
1105 * fields to ensure that they are at least valid, see the draft snippet below
1106 * for details. If the option is valid then a zero value is returned and
1107 * the value of @option is unchanged. If the option is invalid then a
1108 * non-zero value is returned and @option is adjusted to point to the
1109 * offending portion of the option. From the IETF draft ...
1111 * "If any field within the CIPSO options, such as the DOI identifier, is not
1112 * recognized the IP datagram is discarded and an ICMP 'parameter problem'
1113 * (type 12) is generated and returned. The ICMP code field is set to 'bad
1114 * parameter' (code 0) and the pointer is set to the start of the CIPSO field
1115 * that is unrecognized."
1118 int cipso_v4_validate(unsigned char **option)
1120 unsigned char *opt = *option;
1122 unsigned char opt_iter;
1123 unsigned char err_offset = 0;
1126 struct cipso_v4_doi *doi_def = NULL;
1129 /* caller already checks for length values that are too large */
1133 goto validate_return;
1137 doi_def = cipso_v4_doi_getdef(ntohl(*((u32 *)&opt[2])));
1138 if (doi_def == NULL) {
1140 goto validate_return_locked;
1144 tag = opt + opt_iter;
1145 while (opt_iter < opt_len) {
1146 for (tag_iter = 0; doi_def->tags[tag_iter] != tag[0];)
1147 if (doi_def->tags[tag_iter] == CIPSO_V4_TAG_INVALID ||
1148 ++tag_iter == CIPSO_V4_TAG_MAXCNT) {
1149 err_offset = opt_iter;
1150 goto validate_return_locked;
1154 if (tag_len > (opt_len - opt_iter)) {
1155 err_offset = opt_iter + 1;
1156 goto validate_return_locked;
1160 case CIPSO_V4_TAG_RBITMAP:
1162 err_offset = opt_iter + 1;
1163 goto validate_return_locked;
1166 /* We are already going to do all the verification
1167 * necessary at the socket layer so from our point of
1168 * view it is safe to turn these checks off (and less
1169 * work), however, the CIPSO draft says we should do
1170 * all the CIPSO validations here but it doesn't
1171 * really specify _exactly_ what we need to validate
1172 * ... so, just make it a sysctl tunable. */
1173 if (cipso_v4_rbm_strictvalid) {
1174 if (cipso_v4_map_lvl_valid(doi_def,
1176 err_offset = opt_iter + 3;
1177 goto validate_return_locked;
1180 cipso_v4_map_cat_rbm_valid(doi_def,
1183 err_offset = opt_iter + 4;
1184 goto validate_return_locked;
1189 err_offset = opt_iter;
1190 goto validate_return_locked;
1194 opt_iter += tag_len;
1197 validate_return_locked:
1200 *option = opt + err_offset;
1205 * cipso_v4_error - Send the correct reponse for a bad packet
1207 * @error: the error code
1208 * @gateway: CIPSO gateway flag
1211 * Based on the error code given in @error, send an ICMP error message back to
1212 * the originating host. From the IETF draft ...
1214 * "If the contents of the CIPSO [option] are valid but the security label is
1215 * outside of the configured host or port label range, the datagram is
1216 * discarded and an ICMP 'destination unreachable' (type 3) is generated and
1217 * returned. The code field of the ICMP is set to 'communication with
1218 * destination network administratively prohibited' (code 9) or to
1219 * 'communication with destination host administratively prohibited'
1220 * (code 10). The value of the code is dependent on whether the originator
1221 * of the ICMP message is acting as a CIPSO host or a CIPSO gateway. The
1222 * recipient of the ICMP message MUST be able to handle either value. The
1223 * same procedure is performed if a CIPSO [option] can not be added to an
1224 * IP packet because it is too large to fit in the IP options area."
1226 * "If the error is triggered by receipt of an ICMP message, the message is
1227 * discarded and no response is permitted (consistent with general ICMP
1228 * processing rules)."
1231 void cipso_v4_error(struct sk_buff *skb, int error, u32 gateway)
1233 if (skb->nh.iph->protocol == IPPROTO_ICMP || error != -EACCES)
1237 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_ANO, 0);
1239 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_ANO, 0);
1243 * cipso_v4_socket_setattr - Add a CIPSO option to a socket
1245 * @doi_def: the CIPSO DOI to use
1246 * @secattr: the specific security attributes of the socket
1249 * Set the CIPSO option on the given socket using the DOI definition and
1250 * security attributes passed to the function. This function requires
1251 * exclusive access to @sock->sk, which means it either needs to be in the
1252 * process of being created or locked via lock_sock(sock->sk). Returns zero on
1253 * success and negative values on failure.
1256 int cipso_v4_socket_setattr(const struct socket *sock,
1257 const struct cipso_v4_doi *doi_def,
1258 const struct netlbl_lsm_secattr *secattr)
1260 int ret_val = -EPERM;
1262 unsigned char *buf = NULL;
1265 struct ip_options *opt = NULL;
1267 struct inet_sock *sk_inet;
1268 struct inet_connection_sock *sk_conn;
1270 /* In the case of sock_create_lite(), the sock->sk field is not
1271 * defined yet but it is not a problem as the only users of these
1272 * "lite" PF_INET sockets are functions which do an accept() call
1273 * afterwards so we will label the socket as part of the accept(). */
1278 /* XXX - This code assumes only one tag per CIPSO option which isn't
1279 * really a good assumption to make but since we only support the MAC
1280 * tags right now it is a safe assumption. */
1283 switch (doi_def->tags[iter]) {
1284 case CIPSO_V4_TAG_RBITMAP:
1285 ret_val = cipso_v4_gentag_rbm(doi_def,
1292 goto socket_setattr_failure;
1296 } while (ret_val != 0 &&
1297 iter < CIPSO_V4_TAG_MAXCNT &&
1298 doi_def->tags[iter] != CIPSO_V4_TAG_INVALID);
1300 goto socket_setattr_failure;
1302 /* We can't use ip_options_get() directly because it makes a call to
1303 * ip_options_get_alloc() which allocates memory with GFP_KERNEL and
1304 * we can't block here. */
1305 opt_len = (buf_len + 3) & ~3;
1306 opt = kzalloc(sizeof(*opt) + opt_len, GFP_ATOMIC);
1309 goto socket_setattr_failure;
1311 memcpy(opt->__data, buf, buf_len);
1312 opt->optlen = opt_len;
1316 ret_val = ip_options_compile(opt, NULL);
1318 goto socket_setattr_failure;
1320 sk_inet = inet_sk(sk);
1321 if (sk_inet->is_icsk) {
1322 sk_conn = inet_csk(sk);
1324 sk_conn->icsk_ext_hdr_len -= sk_inet->opt->optlen;
1325 sk_conn->icsk_ext_hdr_len += opt->optlen;
1326 sk_conn->icsk_sync_mss(sk, sk_conn->icsk_pmtu_cookie);
1328 opt = xchg(&sk_inet->opt, opt);
1333 socket_setattr_failure:
1340 * cipso_v4_sock_getattr - Get the security attributes from a sock
1342 * @secattr: the security attributes
1345 * Query @sk to see if there is a CIPSO option attached to the sock and if
1346 * there is return the CIPSO security attributes in @secattr. This function
1347 * requires that @sk be locked, or privately held, but it does not do any
1348 * locking itself. Returns zero on success and negative values on failure.
1351 int cipso_v4_sock_getattr(struct sock *sk, struct netlbl_lsm_secattr *secattr)
1353 int ret_val = -ENOMSG;
1354 struct inet_sock *sk_inet;
1355 unsigned char *cipso_ptr;
1357 struct cipso_v4_doi *doi_def;
1359 sk_inet = inet_sk(sk);
1360 if (sk_inet->opt == NULL || sk_inet->opt->cipso == 0)
1362 cipso_ptr = sk_inet->opt->__data + sk_inet->opt->cipso -
1363 sizeof(struct iphdr);
1364 ret_val = cipso_v4_cache_check(cipso_ptr, cipso_ptr[1], secattr);
1368 doi = ntohl(*(u32 *)&cipso_ptr[2]);
1370 doi_def = cipso_v4_doi_getdef(doi);
1371 if (doi_def == NULL) {
1375 switch (cipso_ptr[6]) {
1376 case CIPSO_V4_TAG_RBITMAP:
1377 ret_val = cipso_v4_parsetag_rbm(doi_def,
1388 * cipso_v4_socket_getattr - Get the security attributes from a socket
1390 * @secattr: the security attributes
1393 * Query @sock to see if there is a CIPSO option attached to the socket and if
1394 * there is return the CIPSO security attributes in @secattr. Returns zero on
1395 * success and negative values on failure.
1398 int cipso_v4_socket_getattr(const struct socket *sock,
1399 struct netlbl_lsm_secattr *secattr)
1403 lock_sock(sock->sk);
1404 ret_val = cipso_v4_sock_getattr(sock->sk, secattr);
1405 release_sock(sock->sk);
1411 * cipso_v4_skbuff_getattr - Get the security attributes from the CIPSO option
1413 * @secattr: the security attributes
1416 * Parse the given packet's CIPSO option and return the security attributes.
1417 * Returns zero on success and negative values on failure.
1420 int cipso_v4_skbuff_getattr(const struct sk_buff *skb,
1421 struct netlbl_lsm_secattr *secattr)
1423 int ret_val = -ENOMSG;
1424 unsigned char *cipso_ptr;
1426 struct cipso_v4_doi *doi_def;
1428 if (!CIPSO_V4_OPTEXIST(skb))
1430 cipso_ptr = CIPSO_V4_OPTPTR(skb);
1431 if (cipso_v4_cache_check(cipso_ptr, cipso_ptr[1], secattr) == 0)
1434 doi = ntohl(*(u32 *)&cipso_ptr[2]);
1436 doi_def = cipso_v4_doi_getdef(doi);
1437 if (doi_def == NULL)
1438 goto skbuff_getattr_return;
1439 switch (cipso_ptr[6]) {
1440 case CIPSO_V4_TAG_RBITMAP:
1441 ret_val = cipso_v4_parsetag_rbm(doi_def,
1447 skbuff_getattr_return:
1457 * cipso_v4_init - Initialize the CIPSO module
1460 * Initialize the CIPSO module and prepare it for use. Returns zero on success
1461 * and negative values on failure.
1464 static int __init cipso_v4_init(void)
1468 ret_val = cipso_v4_cache_init();
1470 panic("Failed to initialize the CIPSO/IPv4 cache (%d)\n",
1476 subsys_initcall(cipso_v4_init);