xref: /openbmc/linux/net/ipv6/calipso.c (revision ad5d07f4)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * CALIPSO - Common Architecture Label IPv6 Security Option
4  *
5  * This is an implementation of the CALIPSO protocol as specified in
6  * RFC 5570.
7  *
8  * Authors: Paul Moore <paul.moore@hp.com>
9  *          Huw Davies <huw@codeweavers.com>
10  */
11 
12 /* (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
13  * (c) Copyright Huw Davies <huw@codeweavers.com>, 2015
14  */
15 
16 #include <linux/init.h>
17 #include <linux/types.h>
18 #include <linux/rcupdate.h>
19 #include <linux/list.h>
20 #include <linux/spinlock.h>
21 #include <linux/string.h>
22 #include <linux/jhash.h>
23 #include <linux/audit.h>
24 #include <linux/slab.h>
25 #include <net/ip.h>
26 #include <net/icmp.h>
27 #include <net/tcp.h>
28 #include <net/netlabel.h>
29 #include <net/calipso.h>
30 #include <linux/atomic.h>
31 #include <linux/bug.h>
32 #include <asm/unaligned.h>
33 #include <linux/crc-ccitt.h>
34 
35 /* Maximium size of the calipso option including
36  * the two-byte TLV header.
37  */
38 #define CALIPSO_OPT_LEN_MAX (2 + 252)
39 
40 /* Size of the minimum calipso option including
41  * the two-byte TLV header.
42  */
43 #define CALIPSO_HDR_LEN (2 + 8)
44 
45 /* Maximium size of the calipso option including
46  * the two-byte TLV header and upto 3 bytes of
47  * leading pad and 7 bytes of trailing pad.
48  */
49 #define CALIPSO_OPT_LEN_MAX_WITH_PAD (3 + CALIPSO_OPT_LEN_MAX + 7)
50 
51  /* Maximium size of u32 aligned buffer required to hold calipso
52   * option.  Max of 3 initial pad bytes starting from buffer + 3.
53   * i.e. the worst case is when the previous tlv finishes on 4n + 3.
54   */
55 #define CALIPSO_MAX_BUFFER (6 + CALIPSO_OPT_LEN_MAX)
56 
57 /* List of available DOI definitions */
58 static DEFINE_SPINLOCK(calipso_doi_list_lock);
59 static LIST_HEAD(calipso_doi_list);
60 
61 /* Label mapping cache */
62 int calipso_cache_enabled = 1;
63 int calipso_cache_bucketsize = 10;
64 #define CALIPSO_CACHE_BUCKETBITS     7
65 #define CALIPSO_CACHE_BUCKETS        BIT(CALIPSO_CACHE_BUCKETBITS)
66 #define CALIPSO_CACHE_REORDERLIMIT   10
67 struct calipso_map_cache_bkt {
68 	spinlock_t lock;
69 	u32 size;
70 	struct list_head list;
71 };
72 
73 struct calipso_map_cache_entry {
74 	u32 hash;
75 	unsigned char *key;
76 	size_t key_len;
77 
78 	struct netlbl_lsm_cache *lsm_data;
79 
80 	u32 activity;
81 	struct list_head list;
82 };
83 
84 static struct calipso_map_cache_bkt *calipso_cache;
85 
86 static void calipso_cache_invalidate(void);
87 static void calipso_doi_putdef(struct calipso_doi *doi_def);
88 
89 /* Label Mapping Cache Functions
90  */
91 
92 /**
93  * calipso_cache_entry_free - Frees a cache entry
94  * @entry: the entry to free
95  *
96  * Description:
97  * This function frees the memory associated with a cache entry including the
98  * LSM cache data if there are no longer any users, i.e. reference count == 0.
99  *
100  */
calipso_cache_entry_free(struct calipso_map_cache_entry * entry)101 static void calipso_cache_entry_free(struct calipso_map_cache_entry *entry)
102 {
103 	if (entry->lsm_data)
104 		netlbl_secattr_cache_free(entry->lsm_data);
105 	kfree(entry->key);
106 	kfree(entry);
107 }
108 
109 /**
110  * calipso_map_cache_hash - Hashing function for the CALIPSO cache
111  * @key: the hash key
112  * @key_len: the length of the key in bytes
113  *
114  * Description:
115  * The CALIPSO tag hashing function.  Returns a 32-bit hash value.
116  *
117  */
calipso_map_cache_hash(const unsigned char * key,u32 key_len)118 static u32 calipso_map_cache_hash(const unsigned char *key, u32 key_len)
119 {
120 	return jhash(key, key_len, 0);
121 }
122 
123 /**
124  * calipso_cache_init - Initialize the CALIPSO cache
125  *
126  * Description:
127  * Initializes the CALIPSO label mapping cache, this function should be called
128  * before any of the other functions defined in this file.  Returns zero on
129  * success, negative values on error.
130  *
131  */
calipso_cache_init(void)132 static int __init calipso_cache_init(void)
133 {
134 	u32 iter;
135 
136 	calipso_cache = kcalloc(CALIPSO_CACHE_BUCKETS,
137 				sizeof(struct calipso_map_cache_bkt),
138 				GFP_KERNEL);
139 	if (!calipso_cache)
140 		return -ENOMEM;
141 
142 	for (iter = 0; iter < CALIPSO_CACHE_BUCKETS; iter++) {
143 		spin_lock_init(&calipso_cache[iter].lock);
144 		calipso_cache[iter].size = 0;
145 		INIT_LIST_HEAD(&calipso_cache[iter].list);
146 	}
147 
148 	return 0;
149 }
150 
151 /**
152  * calipso_cache_invalidate - Invalidates the current CALIPSO cache
153  *
154  * Description:
155  * Invalidates and frees any entries in the CALIPSO cache.  Returns zero on
156  * success and negative values on failure.
157  *
158  */
calipso_cache_invalidate(void)159 static void calipso_cache_invalidate(void)
160 {
161 	struct calipso_map_cache_entry *entry, *tmp_entry;
162 	u32 iter;
163 
164 	for (iter = 0; iter < CALIPSO_CACHE_BUCKETS; iter++) {
165 		spin_lock_bh(&calipso_cache[iter].lock);
166 		list_for_each_entry_safe(entry,
167 					 tmp_entry,
168 					 &calipso_cache[iter].list, list) {
169 			list_del(&entry->list);
170 			calipso_cache_entry_free(entry);
171 		}
172 		calipso_cache[iter].size = 0;
173 		spin_unlock_bh(&calipso_cache[iter].lock);
174 	}
175 }
176 
177 /**
178  * calipso_cache_check - Check the CALIPSO cache for a label mapping
179  * @key: the buffer to check
180  * @key_len: buffer length in bytes
181  * @secattr: the security attribute struct to use
182  *
183  * Description:
184  * This function checks the cache to see if a label mapping already exists for
185  * the given key.  If there is a match then the cache is adjusted and the
186  * @secattr struct is populated with the correct LSM security attributes.  The
187  * cache is adjusted in the following manner if the entry is not already the
188  * first in the cache bucket:
189  *
190  *  1. The cache entry's activity counter is incremented
191  *  2. The previous (higher ranking) entry's activity counter is decremented
192  *  3. If the difference between the two activity counters is geater than
193  *     CALIPSO_CACHE_REORDERLIMIT the two entries are swapped
194  *
195  * Returns zero on success, -ENOENT for a cache miss, and other negative values
196  * on error.
197  *
198  */
calipso_cache_check(const unsigned char * key,u32 key_len,struct netlbl_lsm_secattr * secattr)199 static int calipso_cache_check(const unsigned char *key,
200 			       u32 key_len,
201 			       struct netlbl_lsm_secattr *secattr)
202 {
203 	u32 bkt;
204 	struct calipso_map_cache_entry *entry;
205 	struct calipso_map_cache_entry *prev_entry = NULL;
206 	u32 hash;
207 
208 	if (!calipso_cache_enabled)
209 		return -ENOENT;
210 
211 	hash = calipso_map_cache_hash(key, key_len);
212 	bkt = hash & (CALIPSO_CACHE_BUCKETS - 1);
213 	spin_lock_bh(&calipso_cache[bkt].lock);
214 	list_for_each_entry(entry, &calipso_cache[bkt].list, list) {
215 		if (entry->hash == hash &&
216 		    entry->key_len == key_len &&
217 		    memcmp(entry->key, key, key_len) == 0) {
218 			entry->activity += 1;
219 			refcount_inc(&entry->lsm_data->refcount);
220 			secattr->cache = entry->lsm_data;
221 			secattr->flags |= NETLBL_SECATTR_CACHE;
222 			secattr->type = NETLBL_NLTYPE_CALIPSO;
223 			if (!prev_entry) {
224 				spin_unlock_bh(&calipso_cache[bkt].lock);
225 				return 0;
226 			}
227 
228 			if (prev_entry->activity > 0)
229 				prev_entry->activity -= 1;
230 			if (entry->activity > prev_entry->activity &&
231 			    entry->activity - prev_entry->activity >
232 			    CALIPSO_CACHE_REORDERLIMIT) {
233 				__list_del(entry->list.prev, entry->list.next);
234 				__list_add(&entry->list,
235 					   prev_entry->list.prev,
236 					   &prev_entry->list);
237 			}
238 
239 			spin_unlock_bh(&calipso_cache[bkt].lock);
240 			return 0;
241 		}
242 		prev_entry = entry;
243 	}
244 	spin_unlock_bh(&calipso_cache[bkt].lock);
245 
246 	return -ENOENT;
247 }
248 
249 /**
250  * calipso_cache_add - Add an entry to the CALIPSO cache
251  * @calipso_ptr: the CALIPSO option
252  * @secattr: the packet's security attributes
253  *
254  * Description:
255  * Add a new entry into the CALIPSO label mapping cache.  Add the new entry to
256  * head of the cache bucket's list, if the cache bucket is out of room remove
257  * the last entry in the list first.  It is important to note that there is
258  * currently no checking for duplicate keys.  Returns zero on success,
259  * negative values on failure.  The key stored starts at calipso_ptr + 2,
260  * i.e. the type and length bytes are not stored, this corresponds to
261  * calipso_ptr[1] bytes of data.
262  *
263  */
calipso_cache_add(const unsigned char * calipso_ptr,const struct netlbl_lsm_secattr * secattr)264 static int calipso_cache_add(const unsigned char *calipso_ptr,
265 			     const struct netlbl_lsm_secattr *secattr)
266 {
267 	int ret_val = -EPERM;
268 	u32 bkt;
269 	struct calipso_map_cache_entry *entry = NULL;
270 	struct calipso_map_cache_entry *old_entry = NULL;
271 	u32 calipso_ptr_len;
272 
273 	if (!calipso_cache_enabled || calipso_cache_bucketsize <= 0)
274 		return 0;
275 
276 	calipso_ptr_len = calipso_ptr[1];
277 
278 	entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
279 	if (!entry)
280 		return -ENOMEM;
281 	entry->key = kmemdup(calipso_ptr + 2, calipso_ptr_len, GFP_ATOMIC);
282 	if (!entry->key) {
283 		ret_val = -ENOMEM;
284 		goto cache_add_failure;
285 	}
286 	entry->key_len = calipso_ptr_len;
287 	entry->hash = calipso_map_cache_hash(calipso_ptr, calipso_ptr_len);
288 	refcount_inc(&secattr->cache->refcount);
289 	entry->lsm_data = secattr->cache;
290 
291 	bkt = entry->hash & (CALIPSO_CACHE_BUCKETS - 1);
292 	spin_lock_bh(&calipso_cache[bkt].lock);
293 	if (calipso_cache[bkt].size < calipso_cache_bucketsize) {
294 		list_add(&entry->list, &calipso_cache[bkt].list);
295 		calipso_cache[bkt].size += 1;
296 	} else {
297 		old_entry = list_entry(calipso_cache[bkt].list.prev,
298 				       struct calipso_map_cache_entry, list);
299 		list_del(&old_entry->list);
300 		list_add(&entry->list, &calipso_cache[bkt].list);
301 		calipso_cache_entry_free(old_entry);
302 	}
303 	spin_unlock_bh(&calipso_cache[bkt].lock);
304 
305 	return 0;
306 
307 cache_add_failure:
308 	if (entry)
309 		calipso_cache_entry_free(entry);
310 	return ret_val;
311 }
312 
313 /* DOI List Functions
314  */
315 
316 /**
317  * calipso_doi_search - Searches for a DOI definition
318  * @doi: the DOI to search for
319  *
320  * Description:
321  * Search the DOI definition list for a DOI definition with a DOI value that
322  * matches @doi.  The caller is responsible for calling rcu_read_[un]lock().
323  * Returns a pointer to the DOI definition on success and NULL on failure.
324  */
calipso_doi_search(u32 doi)325 static struct calipso_doi *calipso_doi_search(u32 doi)
326 {
327 	struct calipso_doi *iter;
328 
329 	list_for_each_entry_rcu(iter, &calipso_doi_list, list)
330 		if (iter->doi == doi && refcount_read(&iter->refcount))
331 			return iter;
332 	return NULL;
333 }
334 
335 /**
336  * calipso_doi_add - Add a new DOI to the CALIPSO protocol engine
337  * @doi_def: the DOI structure
338  * @audit_info: NetLabel audit information
339  *
340  * Description:
341  * The caller defines a new DOI for use by the CALIPSO engine and calls this
342  * function to add it to the list of acceptable domains.  The caller must
343  * ensure that the mapping table specified in @doi_def->map meets all of the
344  * requirements of the mapping type (see calipso.h for details).  Returns
345  * zero on success and non-zero on failure.
346  *
347  */
calipso_doi_add(struct calipso_doi * doi_def,struct netlbl_audit * audit_info)348 static int calipso_doi_add(struct calipso_doi *doi_def,
349 			   struct netlbl_audit *audit_info)
350 {
351 	int ret_val = -EINVAL;
352 	u32 doi;
353 	u32 doi_type;
354 	struct audit_buffer *audit_buf;
355 
356 	doi = doi_def->doi;
357 	doi_type = doi_def->type;
358 
359 	if (doi_def->doi == CALIPSO_DOI_UNKNOWN)
360 		goto doi_add_return;
361 
362 	refcount_set(&doi_def->refcount, 1);
363 
364 	spin_lock(&calipso_doi_list_lock);
365 	if (calipso_doi_search(doi_def->doi)) {
366 		spin_unlock(&calipso_doi_list_lock);
367 		ret_val = -EEXIST;
368 		goto doi_add_return;
369 	}
370 	list_add_tail_rcu(&doi_def->list, &calipso_doi_list);
371 	spin_unlock(&calipso_doi_list_lock);
372 	ret_val = 0;
373 
374 doi_add_return:
375 	audit_buf = netlbl_audit_start(AUDIT_MAC_CALIPSO_ADD, audit_info);
376 	if (audit_buf) {
377 		const char *type_str;
378 
379 		switch (doi_type) {
380 		case CALIPSO_MAP_PASS:
381 			type_str = "pass";
382 			break;
383 		default:
384 			type_str = "(unknown)";
385 		}
386 		audit_log_format(audit_buf,
387 				 " calipso_doi=%u calipso_type=%s res=%u",
388 				 doi, type_str, ret_val == 0 ? 1 : 0);
389 		audit_log_end(audit_buf);
390 	}
391 
392 	return ret_val;
393 }
394 
395 /**
396  * calipso_doi_free - Frees a DOI definition
397  * @doi_def: the DOI definition
398  *
399  * Description:
400  * This function frees all of the memory associated with a DOI definition.
401  *
402  */
calipso_doi_free(struct calipso_doi * doi_def)403 static void calipso_doi_free(struct calipso_doi *doi_def)
404 {
405 	kfree(doi_def);
406 }
407 
408 /**
409  * calipso_doi_free_rcu - Frees a DOI definition via the RCU pointer
410  * @entry: the entry's RCU field
411  *
412  * Description:
413  * This function is designed to be used as a callback to the call_rcu()
414  * function so that the memory allocated to the DOI definition can be released
415  * safely.
416  *
417  */
calipso_doi_free_rcu(struct rcu_head * entry)418 static void calipso_doi_free_rcu(struct rcu_head *entry)
419 {
420 	struct calipso_doi *doi_def;
421 
422 	doi_def = container_of(entry, struct calipso_doi, rcu);
423 	calipso_doi_free(doi_def);
424 }
425 
426 /**
427  * calipso_doi_remove - Remove an existing DOI from the CALIPSO protocol engine
428  * @doi: the DOI value
429  * @audit_info: NetLabel audit information
430  *
431  * Description:
432  * Removes a DOI definition from the CALIPSO engine.  The NetLabel routines will
433  * be called to release their own LSM domain mappings as well as our own
434  * domain list.  Returns zero on success and negative values on failure.
435  *
436  */
calipso_doi_remove(u32 doi,struct netlbl_audit * audit_info)437 static int calipso_doi_remove(u32 doi, struct netlbl_audit *audit_info)
438 {
439 	int ret_val;
440 	struct calipso_doi *doi_def;
441 	struct audit_buffer *audit_buf;
442 
443 	spin_lock(&calipso_doi_list_lock);
444 	doi_def = calipso_doi_search(doi);
445 	if (!doi_def) {
446 		spin_unlock(&calipso_doi_list_lock);
447 		ret_val = -ENOENT;
448 		goto doi_remove_return;
449 	}
450 	list_del_rcu(&doi_def->list);
451 	spin_unlock(&calipso_doi_list_lock);
452 
453 	calipso_doi_putdef(doi_def);
454 	ret_val = 0;
455 
456 doi_remove_return:
457 	audit_buf = netlbl_audit_start(AUDIT_MAC_CALIPSO_DEL, audit_info);
458 	if (audit_buf) {
459 		audit_log_format(audit_buf,
460 				 " calipso_doi=%u res=%u",
461 				 doi, ret_val == 0 ? 1 : 0);
462 		audit_log_end(audit_buf);
463 	}
464 
465 	return ret_val;
466 }
467 
468 /**
469  * calipso_doi_getdef - Returns a reference to a valid DOI definition
470  * @doi: the DOI value
471  *
472  * Description:
473  * Searches for a valid DOI definition and if one is found it is returned to
474  * the caller.  Otherwise NULL is returned.  The caller must ensure that
475  * calipso_doi_putdef() is called when the caller is done.
476  *
477  */
calipso_doi_getdef(u32 doi)478 static struct calipso_doi *calipso_doi_getdef(u32 doi)
479 {
480 	struct calipso_doi *doi_def;
481 
482 	rcu_read_lock();
483 	doi_def = calipso_doi_search(doi);
484 	if (!doi_def)
485 		goto doi_getdef_return;
486 	if (!refcount_inc_not_zero(&doi_def->refcount))
487 		doi_def = NULL;
488 
489 doi_getdef_return:
490 	rcu_read_unlock();
491 	return doi_def;
492 }
493 
494 /**
495  * calipso_doi_putdef - Releases a reference for the given DOI definition
496  * @doi_def: the DOI definition
497  *
498  * Description:
499  * Releases a DOI definition reference obtained from calipso_doi_getdef().
500  *
501  */
calipso_doi_putdef(struct calipso_doi * doi_def)502 static void calipso_doi_putdef(struct calipso_doi *doi_def)
503 {
504 	if (!doi_def)
505 		return;
506 
507 	if (!refcount_dec_and_test(&doi_def->refcount))
508 		return;
509 
510 	calipso_cache_invalidate();
511 	call_rcu(&doi_def->rcu, calipso_doi_free_rcu);
512 }
513 
514 /**
515  * calipso_doi_walk - Iterate through the DOI definitions
516  * @skip_cnt: skip past this number of DOI definitions, updated
517  * @callback: callback for each DOI definition
518  * @cb_arg: argument for the callback function
519  *
520  * Description:
521  * Iterate over the DOI definition list, skipping the first @skip_cnt entries.
522  * For each entry call @callback, if @callback returns a negative value stop
523  * 'walking' through the list and return.  Updates the value in @skip_cnt upon
524  * return.  Returns zero on success, negative values on failure.
525  *
526  */
calipso_doi_walk(u32 * skip_cnt,int (* callback)(struct calipso_doi * doi_def,void * arg),void * cb_arg)527 static int calipso_doi_walk(u32 *skip_cnt,
528 			    int (*callback)(struct calipso_doi *doi_def,
529 					    void *arg),
530 			    void *cb_arg)
531 {
532 	int ret_val = -ENOENT;
533 	u32 doi_cnt = 0;
534 	struct calipso_doi *iter_doi;
535 
536 	rcu_read_lock();
537 	list_for_each_entry_rcu(iter_doi, &calipso_doi_list, list)
538 		if (refcount_read(&iter_doi->refcount) > 0) {
539 			if (doi_cnt++ < *skip_cnt)
540 				continue;
541 			ret_val = callback(iter_doi, cb_arg);
542 			if (ret_val < 0) {
543 				doi_cnt--;
544 				goto doi_walk_return;
545 			}
546 		}
547 
548 doi_walk_return:
549 	rcu_read_unlock();
550 	*skip_cnt = doi_cnt;
551 	return ret_val;
552 }
553 
554 /**
555  * calipso_validate - Validate a CALIPSO option
556  * @skb: the packet
557  * @option: the start of the option
558  *
559  * Description:
560  * This routine is called to validate a CALIPSO option.
561  * If the option is valid then %true is returned, otherwise
562  * %false is returned.
563  *
564  * The caller should have already checked that the length of the
565  * option (including the TLV header) is >= 10 and that the catmap
566  * length is consistent with the option length.
567  *
568  * We leave checks on the level and categories to the socket layer.
569  */
calipso_validate(const struct sk_buff * skb,const unsigned char * option)570 bool calipso_validate(const struct sk_buff *skb, const unsigned char *option)
571 {
572 	struct calipso_doi *doi_def;
573 	bool ret_val;
574 	u16 crc, len = option[1] + 2;
575 	static const u8 zero[2];
576 
577 	/* The original CRC runs over the option including the TLV header
578 	 * with the CRC-16 field (at offset 8) zeroed out. */
579 	crc = crc_ccitt(0xffff, option, 8);
580 	crc = crc_ccitt(crc, zero, sizeof(zero));
581 	if (len > 10)
582 		crc = crc_ccitt(crc, option + 10, len - 10);
583 	crc = ~crc;
584 	if (option[8] != (crc & 0xff) || option[9] != ((crc >> 8) & 0xff))
585 		return false;
586 
587 	rcu_read_lock();
588 	doi_def = calipso_doi_search(get_unaligned_be32(option + 2));
589 	ret_val = !!doi_def;
590 	rcu_read_unlock();
591 
592 	return ret_val;
593 }
594 
595 /**
596  * calipso_map_cat_hton - Perform a category mapping from host to network
597  * @doi_def: the DOI definition
598  * @secattr: the security attributes
599  * @net_cat: the zero'd out category bitmap in network/CALIPSO format
600  * @net_cat_len: the length of the CALIPSO bitmap in bytes
601  *
602  * Description:
603  * Perform a label mapping to translate a local MLS category bitmap to the
604  * correct CALIPSO bitmap using the given DOI definition.  Returns the minimum
605  * size in bytes of the network bitmap on success, negative values otherwise.
606  *
607  */
calipso_map_cat_hton(const struct calipso_doi * doi_def,const struct netlbl_lsm_secattr * secattr,unsigned char * net_cat,u32 net_cat_len)608 static int calipso_map_cat_hton(const struct calipso_doi *doi_def,
609 				const struct netlbl_lsm_secattr *secattr,
610 				unsigned char *net_cat,
611 				u32 net_cat_len)
612 {
613 	int spot = -1;
614 	u32 net_spot_max = 0;
615 	u32 net_clen_bits = net_cat_len * 8;
616 
617 	for (;;) {
618 		spot = netlbl_catmap_walk(secattr->attr.mls.cat,
619 					  spot + 1);
620 		if (spot < 0)
621 			break;
622 		if (spot >= net_clen_bits)
623 			return -ENOSPC;
624 		netlbl_bitmap_setbit(net_cat, spot, 1);
625 
626 		if (spot > net_spot_max)
627 			net_spot_max = spot;
628 	}
629 
630 	return (net_spot_max / 32 + 1) * 4;
631 }
632 
633 /**
634  * calipso_map_cat_ntoh - Perform a category mapping from network to host
635  * @doi_def: the DOI definition
636  * @net_cat: the category bitmap in network/CALIPSO format
637  * @net_cat_len: the length of the CALIPSO bitmap in bytes
638  * @secattr: the security attributes
639  *
640  * Description:
641  * Perform a label mapping to translate a CALIPSO bitmap to the correct local
642  * MLS category bitmap using the given DOI definition.  Returns zero on
643  * success, negative values on failure.
644  *
645  */
calipso_map_cat_ntoh(const struct calipso_doi * doi_def,const unsigned char * net_cat,u32 net_cat_len,struct netlbl_lsm_secattr * secattr)646 static int calipso_map_cat_ntoh(const struct calipso_doi *doi_def,
647 				const unsigned char *net_cat,
648 				u32 net_cat_len,
649 				struct netlbl_lsm_secattr *secattr)
650 {
651 	int ret_val;
652 	int spot = -1;
653 	u32 net_clen_bits = net_cat_len * 8;
654 
655 	for (;;) {
656 		spot = netlbl_bitmap_walk(net_cat,
657 					  net_clen_bits,
658 					  spot + 1,
659 					  1);
660 		if (spot < 0) {
661 			if (spot == -2)
662 				return -EFAULT;
663 			return 0;
664 		}
665 
666 		ret_val = netlbl_catmap_setbit(&secattr->attr.mls.cat,
667 					       spot,
668 					       GFP_ATOMIC);
669 		if (ret_val != 0)
670 			return ret_val;
671 	}
672 
673 	return -EINVAL;
674 }
675 
676 /**
677  * calipso_pad_write - Writes pad bytes in TLV format
678  * @buf: the buffer
679  * @offset: offset from start of buffer to write padding
680  * @count: number of pad bytes to write
681  *
682  * Description:
683  * Write @count bytes of TLV padding into @buffer starting at offset @offset.
684  * @count should be less than 8 - see RFC 4942.
685  *
686  */
calipso_pad_write(unsigned char * buf,unsigned int offset,unsigned int count)687 static int calipso_pad_write(unsigned char *buf, unsigned int offset,
688 			     unsigned int count)
689 {
690 	if (WARN_ON_ONCE(count >= 8))
691 		return -EINVAL;
692 
693 	switch (count) {
694 	case 0:
695 		break;
696 	case 1:
697 		buf[offset] = IPV6_TLV_PAD1;
698 		break;
699 	default:
700 		buf[offset] = IPV6_TLV_PADN;
701 		buf[offset + 1] = count - 2;
702 		if (count > 2)
703 			memset(buf + offset + 2, 0, count - 2);
704 		break;
705 	}
706 	return 0;
707 }
708 
709 /**
710  * calipso_genopt - Generate a CALIPSO option
711  * @buf: the option buffer
712  * @start: offset from which to write
713  * @buf_len: the size of opt_buf
714  * @doi_def: the CALIPSO DOI to use
715  * @secattr: the security attributes
716  *
717  * Description:
718  * Generate a CALIPSO option using the DOI definition and security attributes
719  * passed to the function. This also generates upto three bytes of leading
720  * padding that ensures that the option is 4n + 2 aligned.  It returns the
721  * number of bytes written (including any initial padding).
722  */
calipso_genopt(unsigned char * buf,u32 start,u32 buf_len,const struct calipso_doi * doi_def,const struct netlbl_lsm_secattr * secattr)723 static int calipso_genopt(unsigned char *buf, u32 start, u32 buf_len,
724 			  const struct calipso_doi *doi_def,
725 			  const struct netlbl_lsm_secattr *secattr)
726 {
727 	int ret_val;
728 	u32 len, pad;
729 	u16 crc;
730 	static const unsigned char padding[4] = {2, 1, 0, 3};
731 	unsigned char *calipso;
732 
733 	/* CALIPSO has 4n + 2 alignment */
734 	pad = padding[start & 3];
735 	if (buf_len <= start + pad + CALIPSO_HDR_LEN)
736 		return -ENOSPC;
737 
738 	if ((secattr->flags & NETLBL_SECATTR_MLS_LVL) == 0)
739 		return -EPERM;
740 
741 	len = CALIPSO_HDR_LEN;
742 
743 	if (secattr->flags & NETLBL_SECATTR_MLS_CAT) {
744 		ret_val = calipso_map_cat_hton(doi_def,
745 					       secattr,
746 					       buf + start + pad + len,
747 					       buf_len - start - pad - len);
748 		if (ret_val < 0)
749 			return ret_val;
750 		len += ret_val;
751 	}
752 
753 	calipso_pad_write(buf, start, pad);
754 	calipso = buf + start + pad;
755 
756 	calipso[0] = IPV6_TLV_CALIPSO;
757 	calipso[1] = len - 2;
758 	*(__be32 *)(calipso + 2) = htonl(doi_def->doi);
759 	calipso[6] = (len - CALIPSO_HDR_LEN) / 4;
760 	calipso[7] = secattr->attr.mls.lvl;
761 	crc = ~crc_ccitt(0xffff, calipso, len);
762 	calipso[8] = crc & 0xff;
763 	calipso[9] = (crc >> 8) & 0xff;
764 	return pad + len;
765 }
766 
767 /* Hop-by-hop hdr helper functions
768  */
769 
770 /**
771  * calipso_opt_update - Replaces socket's hop options with a new set
772  * @sk: the socket
773  * @hop: new hop options
774  *
775  * Description:
776  * Replaces @sk's hop options with @hop.  @hop may be NULL to leave
777  * the socket with no hop options.
778  *
779  */
calipso_opt_update(struct sock * sk,struct ipv6_opt_hdr * hop)780 static int calipso_opt_update(struct sock *sk, struct ipv6_opt_hdr *hop)
781 {
782 	struct ipv6_txoptions *old = txopt_get(inet6_sk(sk)), *txopts;
783 
784 	txopts = ipv6_renew_options(sk, old, IPV6_HOPOPTS, hop);
785 	txopt_put(old);
786 	if (IS_ERR(txopts))
787 		return PTR_ERR(txopts);
788 
789 	txopts = ipv6_update_options(sk, txopts);
790 	if (txopts) {
791 		atomic_sub(txopts->tot_len, &sk->sk_omem_alloc);
792 		txopt_put(txopts);
793 	}
794 
795 	return 0;
796 }
797 
798 /**
799  * calipso_tlv_len - Returns the length of the TLV
800  * @opt: the option header
801  * @offset: offset of the TLV within the header
802  *
803  * Description:
804  * Returns the length of the TLV option at offset @offset within
805  * the option header @opt.  Checks that the entire TLV fits inside
806  * the option header, returns a negative value if this is not the case.
807  */
calipso_tlv_len(struct ipv6_opt_hdr * opt,unsigned int offset)808 static int calipso_tlv_len(struct ipv6_opt_hdr *opt, unsigned int offset)
809 {
810 	unsigned char *tlv = (unsigned char *)opt;
811 	unsigned int opt_len = ipv6_optlen(opt), tlv_len;
812 
813 	if (offset < sizeof(*opt) || offset >= opt_len)
814 		return -EINVAL;
815 	if (tlv[offset] == IPV6_TLV_PAD1)
816 		return 1;
817 	if (offset + 1 >= opt_len)
818 		return -EINVAL;
819 	tlv_len = tlv[offset + 1] + 2;
820 	if (offset + tlv_len > opt_len)
821 		return -EINVAL;
822 	return tlv_len;
823 }
824 
825 /**
826  * calipso_opt_find - Finds the CALIPSO option in an IPv6 hop options header
827  * @hop: the hop options header
828  * @start: on return holds the offset of any leading padding
829  * @end: on return holds the offset of the first non-pad TLV after CALIPSO
830  *
831  * Description:
832  * Finds the space occupied by a CALIPSO option (including any leading and
833  * trailing padding).
834  *
835  * If a CALIPSO option exists set @start and @end to the
836  * offsets within @hop of the start of padding before the first
837  * CALIPSO option and the end of padding after the first CALIPSO
838  * option.  In this case the function returns 0.
839  *
840  * In the absence of a CALIPSO option, @start and @end will be
841  * set to the start and end of any trailing padding in the header.
842  * This is useful when appending a new option, as the caller may want
843  * to overwrite some of this padding.  In this case the function will
844  * return -ENOENT.
845  */
calipso_opt_find(struct ipv6_opt_hdr * hop,unsigned int * start,unsigned int * end)846 static int calipso_opt_find(struct ipv6_opt_hdr *hop, unsigned int *start,
847 			    unsigned int *end)
848 {
849 	int ret_val = -ENOENT, tlv_len;
850 	unsigned int opt_len, offset, offset_s = 0, offset_e = 0;
851 	unsigned char *opt = (unsigned char *)hop;
852 
853 	opt_len = ipv6_optlen(hop);
854 	offset = sizeof(*hop);
855 
856 	while (offset < opt_len) {
857 		tlv_len = calipso_tlv_len(hop, offset);
858 		if (tlv_len < 0)
859 			return tlv_len;
860 
861 		switch (opt[offset]) {
862 		case IPV6_TLV_PAD1:
863 		case IPV6_TLV_PADN:
864 			if (offset_e)
865 				offset_e = offset;
866 			break;
867 		case IPV6_TLV_CALIPSO:
868 			ret_val = 0;
869 			offset_e = offset;
870 			break;
871 		default:
872 			if (offset_e == 0)
873 				offset_s = offset;
874 			else
875 				goto out;
876 		}
877 		offset += tlv_len;
878 	}
879 
880 out:
881 	if (offset_s)
882 		*start = offset_s + calipso_tlv_len(hop, offset_s);
883 	else
884 		*start = sizeof(*hop);
885 	if (offset_e)
886 		*end = offset_e + calipso_tlv_len(hop, offset_e);
887 	else
888 		*end = opt_len;
889 
890 	return ret_val;
891 }
892 
893 /**
894  * calipso_opt_insert - Inserts a CALIPSO option into an IPv6 hop opt hdr
895  * @hop: the original hop options header
896  * @doi_def: the CALIPSO DOI to use
897  * @secattr: the specific security attributes of the socket
898  *
899  * Description:
900  * Creates a new hop options header based on @hop with a
901  * CALIPSO option added to it.  If @hop already contains a CALIPSO
902  * option this is overwritten, otherwise the new option is appended
903  * after any existing options.  If @hop is NULL then the new header
904  * will contain just the CALIPSO option and any needed padding.
905  *
906  */
907 static struct ipv6_opt_hdr *
calipso_opt_insert(struct ipv6_opt_hdr * hop,const struct calipso_doi * doi_def,const struct netlbl_lsm_secattr * secattr)908 calipso_opt_insert(struct ipv6_opt_hdr *hop,
909 		   const struct calipso_doi *doi_def,
910 		   const struct netlbl_lsm_secattr *secattr)
911 {
912 	unsigned int start, end, buf_len, pad, hop_len;
913 	struct ipv6_opt_hdr *new;
914 	int ret_val;
915 
916 	if (hop) {
917 		hop_len = ipv6_optlen(hop);
918 		ret_val = calipso_opt_find(hop, &start, &end);
919 		if (ret_val && ret_val != -ENOENT)
920 			return ERR_PTR(ret_val);
921 	} else {
922 		hop_len = 0;
923 		start = sizeof(*hop);
924 		end = 0;
925 	}
926 
927 	buf_len = hop_len + start - end + CALIPSO_OPT_LEN_MAX_WITH_PAD;
928 	new = kzalloc(buf_len, GFP_ATOMIC);
929 	if (!new)
930 		return ERR_PTR(-ENOMEM);
931 
932 	if (start > sizeof(*hop))
933 		memcpy(new, hop, start);
934 	ret_val = calipso_genopt((unsigned char *)new, start, buf_len, doi_def,
935 				 secattr);
936 	if (ret_val < 0) {
937 		kfree(new);
938 		return ERR_PTR(ret_val);
939 	}
940 
941 	buf_len = start + ret_val;
942 	/* At this point buf_len aligns to 4n, so (buf_len & 4) pads to 8n */
943 	pad = ((buf_len & 4) + (end & 7)) & 7;
944 	calipso_pad_write((unsigned char *)new, buf_len, pad);
945 	buf_len += pad;
946 
947 	if (end != hop_len) {
948 		memcpy((char *)new + buf_len, (char *)hop + end, hop_len - end);
949 		buf_len += hop_len - end;
950 	}
951 	new->nexthdr = 0;
952 	new->hdrlen = buf_len / 8 - 1;
953 
954 	return new;
955 }
956 
957 /**
958  * calipso_opt_del - Removes the CALIPSO option from an option header
959  * @hop: the original header
960  * @new: the new header
961  *
962  * Description:
963  * Creates a new header based on @hop without any CALIPSO option.  If @hop
964  * doesn't contain a CALIPSO option it returns -ENOENT.  If @hop contains
965  * no other non-padding options, it returns zero with @new set to NULL.
966  * Otherwise it returns zero, creates a new header without the CALIPSO
967  * option (and removing as much padding as possible) and returns with
968  * @new set to that header.
969  *
970  */
calipso_opt_del(struct ipv6_opt_hdr * hop,struct ipv6_opt_hdr ** new)971 static int calipso_opt_del(struct ipv6_opt_hdr *hop,
972 			   struct ipv6_opt_hdr **new)
973 {
974 	int ret_val;
975 	unsigned int start, end, delta, pad, hop_len;
976 
977 	ret_val = calipso_opt_find(hop, &start, &end);
978 	if (ret_val)
979 		return ret_val;
980 
981 	hop_len = ipv6_optlen(hop);
982 	if (start == sizeof(*hop) && end == hop_len) {
983 		/* There's no other option in the header so return NULL */
984 		*new = NULL;
985 		return 0;
986 	}
987 
988 	delta = (end - start) & ~7;
989 	*new = kzalloc(hop_len - delta, GFP_ATOMIC);
990 	if (!*new)
991 		return -ENOMEM;
992 
993 	memcpy(*new, hop, start);
994 	(*new)->hdrlen -= delta / 8;
995 	pad = (end - start) & 7;
996 	calipso_pad_write((unsigned char *)*new, start, pad);
997 	if (end != hop_len)
998 		memcpy((char *)*new + start + pad, (char *)hop + end,
999 		       hop_len - end);
1000 
1001 	return 0;
1002 }
1003 
1004 /**
1005  * calipso_opt_getattr - Get the security attributes from a memory block
1006  * @calipso: the CALIPSO option
1007  * @secattr: the security attributes
1008  *
1009  * Description:
1010  * Inspect @calipso and return the security attributes in @secattr.
1011  * Returns zero on success and negative values on failure.
1012  *
1013  */
calipso_opt_getattr(const unsigned char * calipso,struct netlbl_lsm_secattr * secattr)1014 static int calipso_opt_getattr(const unsigned char *calipso,
1015 			       struct netlbl_lsm_secattr *secattr)
1016 {
1017 	int ret_val = -ENOMSG;
1018 	u32 doi, len = calipso[1], cat_len = calipso[6] * 4;
1019 	struct calipso_doi *doi_def;
1020 
1021 	if (cat_len + 8 > len)
1022 		return -EINVAL;
1023 
1024 	if (calipso_cache_check(calipso + 2, calipso[1], secattr) == 0)
1025 		return 0;
1026 
1027 	doi = get_unaligned_be32(calipso + 2);
1028 	rcu_read_lock();
1029 	doi_def = calipso_doi_search(doi);
1030 	if (!doi_def)
1031 		goto getattr_return;
1032 
1033 	secattr->attr.mls.lvl = calipso[7];
1034 	secattr->flags |= NETLBL_SECATTR_MLS_LVL;
1035 
1036 	if (cat_len) {
1037 		ret_val = calipso_map_cat_ntoh(doi_def,
1038 					       calipso + 10,
1039 					       cat_len,
1040 					       secattr);
1041 		if (ret_val != 0) {
1042 			netlbl_catmap_free(secattr->attr.mls.cat);
1043 			goto getattr_return;
1044 		}
1045 
1046 		if (secattr->attr.mls.cat)
1047 			secattr->flags |= NETLBL_SECATTR_MLS_CAT;
1048 	}
1049 
1050 	secattr->type = NETLBL_NLTYPE_CALIPSO;
1051 
1052 getattr_return:
1053 	rcu_read_unlock();
1054 	return ret_val;
1055 }
1056 
1057 /* sock functions.
1058  */
1059 
1060 /**
1061  * calipso_sock_getattr - Get the security attributes from a sock
1062  * @sk: the sock
1063  * @secattr: the security attributes
1064  *
1065  * Description:
1066  * Query @sk to see if there is a CALIPSO option attached to the sock and if
1067  * there is return the CALIPSO security attributes in @secattr.  This function
1068  * requires that @sk be locked, or privately held, but it does not do any
1069  * locking itself.  Returns zero on success and negative values on failure.
1070  *
1071  */
calipso_sock_getattr(struct sock * sk,struct netlbl_lsm_secattr * secattr)1072 static int calipso_sock_getattr(struct sock *sk,
1073 				struct netlbl_lsm_secattr *secattr)
1074 {
1075 	struct ipv6_opt_hdr *hop;
1076 	int opt_len, len, ret_val = -ENOMSG, offset;
1077 	unsigned char *opt;
1078 	struct ipv6_txoptions *txopts = txopt_get(inet6_sk(sk));
1079 
1080 	if (!txopts || !txopts->hopopt)
1081 		goto done;
1082 
1083 	hop = txopts->hopopt;
1084 	opt = (unsigned char *)hop;
1085 	opt_len = ipv6_optlen(hop);
1086 	offset = sizeof(*hop);
1087 	while (offset < opt_len) {
1088 		len = calipso_tlv_len(hop, offset);
1089 		if (len < 0) {
1090 			ret_val = len;
1091 			goto done;
1092 		}
1093 		switch (opt[offset]) {
1094 		case IPV6_TLV_CALIPSO:
1095 			if (len < CALIPSO_HDR_LEN)
1096 				ret_val = -EINVAL;
1097 			else
1098 				ret_val = calipso_opt_getattr(&opt[offset],
1099 							      secattr);
1100 			goto done;
1101 		default:
1102 			offset += len;
1103 			break;
1104 		}
1105 	}
1106 done:
1107 	txopt_put(txopts);
1108 	return ret_val;
1109 }
1110 
1111 /**
1112  * calipso_sock_setattr - Add a CALIPSO option to a socket
1113  * @sk: the socket
1114  * @doi_def: the CALIPSO DOI to use
1115  * @secattr: the specific security attributes of the socket
1116  *
1117  * Description:
1118  * Set the CALIPSO option on the given socket using the DOI definition and
1119  * security attributes passed to the function.  This function requires
1120  * exclusive access to @sk, which means it either needs to be in the
1121  * process of being created or locked.  Returns zero on success and negative
1122  * values on failure.
1123  *
1124  */
calipso_sock_setattr(struct sock * sk,const struct calipso_doi * doi_def,const struct netlbl_lsm_secattr * secattr)1125 static int calipso_sock_setattr(struct sock *sk,
1126 				const struct calipso_doi *doi_def,
1127 				const struct netlbl_lsm_secattr *secattr)
1128 {
1129 	int ret_val;
1130 	struct ipv6_opt_hdr *old, *new;
1131 	struct ipv6_txoptions *txopts = txopt_get(inet6_sk(sk));
1132 
1133 	old = NULL;
1134 	if (txopts)
1135 		old = txopts->hopopt;
1136 
1137 	new = calipso_opt_insert(old, doi_def, secattr);
1138 	txopt_put(txopts);
1139 	if (IS_ERR(new))
1140 		return PTR_ERR(new);
1141 
1142 	ret_val = calipso_opt_update(sk, new);
1143 
1144 	kfree(new);
1145 	return ret_val;
1146 }
1147 
1148 /**
1149  * calipso_sock_delattr - Delete the CALIPSO option from a socket
1150  * @sk: the socket
1151  *
1152  * Description:
1153  * Removes the CALIPSO option from a socket, if present.
1154  *
1155  */
calipso_sock_delattr(struct sock * sk)1156 static void calipso_sock_delattr(struct sock *sk)
1157 {
1158 	struct ipv6_opt_hdr *new_hop;
1159 	struct ipv6_txoptions *txopts = txopt_get(inet6_sk(sk));
1160 
1161 	if (!txopts || !txopts->hopopt)
1162 		goto done;
1163 
1164 	if (calipso_opt_del(txopts->hopopt, &new_hop))
1165 		goto done;
1166 
1167 	calipso_opt_update(sk, new_hop);
1168 	kfree(new_hop);
1169 
1170 done:
1171 	txopt_put(txopts);
1172 }
1173 
1174 /* request sock functions.
1175  */
1176 
1177 /**
1178  * calipso_req_setattr - Add a CALIPSO option to a connection request socket
1179  * @req: the connection request socket
1180  * @doi_def: the CALIPSO DOI to use
1181  * @secattr: the specific security attributes of the socket
1182  *
1183  * Description:
1184  * Set the CALIPSO option on the given socket using the DOI definition and
1185  * security attributes passed to the function.  Returns zero on success and
1186  * negative values on failure.
1187  *
1188  */
calipso_req_setattr(struct request_sock * req,const struct calipso_doi * doi_def,const struct netlbl_lsm_secattr * secattr)1189 static int calipso_req_setattr(struct request_sock *req,
1190 			       const struct calipso_doi *doi_def,
1191 			       const struct netlbl_lsm_secattr *secattr)
1192 {
1193 	struct ipv6_txoptions *txopts;
1194 	struct inet_request_sock *req_inet = inet_rsk(req);
1195 	struct ipv6_opt_hdr *old, *new;
1196 	struct sock *sk = sk_to_full_sk(req_to_sk(req));
1197 
1198 	if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt)
1199 		old = req_inet->ipv6_opt->hopopt;
1200 	else
1201 		old = NULL;
1202 
1203 	new = calipso_opt_insert(old, doi_def, secattr);
1204 	if (IS_ERR(new))
1205 		return PTR_ERR(new);
1206 
1207 	txopts = ipv6_renew_options(sk, req_inet->ipv6_opt, IPV6_HOPOPTS, new);
1208 
1209 	kfree(new);
1210 
1211 	if (IS_ERR(txopts))
1212 		return PTR_ERR(txopts);
1213 
1214 	txopts = xchg(&req_inet->ipv6_opt, txopts);
1215 	if (txopts) {
1216 		atomic_sub(txopts->tot_len, &sk->sk_omem_alloc);
1217 		txopt_put(txopts);
1218 	}
1219 
1220 	return 0;
1221 }
1222 
1223 /**
1224  * calipso_req_delattr - Delete the CALIPSO option from a request socket
1225  * @req: the request socket
1226  *
1227  * Description:
1228  * Removes the CALIPSO option from a request socket, if present.
1229  *
1230  */
calipso_req_delattr(struct request_sock * req)1231 static void calipso_req_delattr(struct request_sock *req)
1232 {
1233 	struct inet_request_sock *req_inet = inet_rsk(req);
1234 	struct ipv6_opt_hdr *new;
1235 	struct ipv6_txoptions *txopts;
1236 	struct sock *sk = sk_to_full_sk(req_to_sk(req));
1237 
1238 	if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt)
1239 		return;
1240 
1241 	if (calipso_opt_del(req_inet->ipv6_opt->hopopt, &new))
1242 		return; /* Nothing to do */
1243 
1244 	txopts = ipv6_renew_options(sk, req_inet->ipv6_opt, IPV6_HOPOPTS, new);
1245 
1246 	if (!IS_ERR(txopts)) {
1247 		txopts = xchg(&req_inet->ipv6_opt, txopts);
1248 		if (txopts) {
1249 			atomic_sub(txopts->tot_len, &sk->sk_omem_alloc);
1250 			txopt_put(txopts);
1251 		}
1252 	}
1253 	kfree(new);
1254 }
1255 
1256 /* skbuff functions.
1257  */
1258 
1259 /**
1260  * calipso_skbuff_optptr - Find the CALIPSO option in the packet
1261  * @skb: the packet
1262  *
1263  * Description:
1264  * Parse the packet's IP header looking for a CALIPSO option.  Returns a pointer
1265  * to the start of the CALIPSO option on success, NULL if one if not found.
1266  *
1267  */
calipso_skbuff_optptr(const struct sk_buff * skb)1268 static unsigned char *calipso_skbuff_optptr(const struct sk_buff *skb)
1269 {
1270 	const struct ipv6hdr *ip6_hdr = ipv6_hdr(skb);
1271 	int offset;
1272 
1273 	if (ip6_hdr->nexthdr != NEXTHDR_HOP)
1274 		return NULL;
1275 
1276 	offset = ipv6_find_tlv(skb, sizeof(*ip6_hdr), IPV6_TLV_CALIPSO);
1277 	if (offset >= 0)
1278 		return (unsigned char *)ip6_hdr + offset;
1279 
1280 	return NULL;
1281 }
1282 
1283 /**
1284  * calipso_skbuff_setattr - Set the CALIPSO option on a packet
1285  * @skb: the packet
1286  * @doi_def: the CALIPSO DOI to use
1287  * @secattr: the security attributes
1288  *
1289  * Description:
1290  * Set the CALIPSO option on the given packet based on the security attributes.
1291  * Returns a pointer to the IP header on success and NULL on failure.
1292  *
1293  */
calipso_skbuff_setattr(struct sk_buff * skb,const struct calipso_doi * doi_def,const struct netlbl_lsm_secattr * secattr)1294 static int calipso_skbuff_setattr(struct sk_buff *skb,
1295 				  const struct calipso_doi *doi_def,
1296 				  const struct netlbl_lsm_secattr *secattr)
1297 {
1298 	int ret_val;
1299 	struct ipv6hdr *ip6_hdr;
1300 	struct ipv6_opt_hdr *hop;
1301 	unsigned char buf[CALIPSO_MAX_BUFFER];
1302 	int len_delta, new_end, pad, payload;
1303 	unsigned int start, end;
1304 
1305 	ip6_hdr = ipv6_hdr(skb);
1306 	if (ip6_hdr->nexthdr == NEXTHDR_HOP) {
1307 		hop = (struct ipv6_opt_hdr *)(ip6_hdr + 1);
1308 		ret_val = calipso_opt_find(hop, &start, &end);
1309 		if (ret_val && ret_val != -ENOENT)
1310 			return ret_val;
1311 	} else {
1312 		start = 0;
1313 		end = 0;
1314 	}
1315 
1316 	memset(buf, 0, sizeof(buf));
1317 	ret_val = calipso_genopt(buf, start & 3, sizeof(buf), doi_def, secattr);
1318 	if (ret_val < 0)
1319 		return ret_val;
1320 
1321 	new_end = start + ret_val;
1322 	/* At this point new_end aligns to 4n, so (new_end & 4) pads to 8n */
1323 	pad = ((new_end & 4) + (end & 7)) & 7;
1324 	len_delta = new_end - (int)end + pad;
1325 	ret_val = skb_cow(skb, skb_headroom(skb) + len_delta);
1326 	if (ret_val < 0)
1327 		return ret_val;
1328 
1329 	ip6_hdr = ipv6_hdr(skb); /* Reset as skb_cow() may have moved it */
1330 
1331 	if (len_delta) {
1332 		if (len_delta > 0)
1333 			skb_push(skb, len_delta);
1334 		else
1335 			skb_pull(skb, -len_delta);
1336 		memmove((char *)ip6_hdr - len_delta, ip6_hdr,
1337 			sizeof(*ip6_hdr) + start);
1338 		skb_reset_network_header(skb);
1339 		ip6_hdr = ipv6_hdr(skb);
1340 		payload = ntohs(ip6_hdr->payload_len);
1341 		ip6_hdr->payload_len = htons(payload + len_delta);
1342 	}
1343 
1344 	hop = (struct ipv6_opt_hdr *)(ip6_hdr + 1);
1345 	if (start == 0) {
1346 		struct ipv6_opt_hdr *new_hop = (struct ipv6_opt_hdr *)buf;
1347 
1348 		new_hop->nexthdr = ip6_hdr->nexthdr;
1349 		new_hop->hdrlen = len_delta / 8 - 1;
1350 		ip6_hdr->nexthdr = NEXTHDR_HOP;
1351 	} else {
1352 		hop->hdrlen += len_delta / 8;
1353 	}
1354 	memcpy((char *)hop + start, buf + (start & 3), new_end - start);
1355 	calipso_pad_write((unsigned char *)hop, new_end, pad);
1356 
1357 	return 0;
1358 }
1359 
1360 /**
1361  * calipso_skbuff_delattr - Delete any CALIPSO options from a packet
1362  * @skb: the packet
1363  *
1364  * Description:
1365  * Removes any and all CALIPSO options from the given packet.  Returns zero on
1366  * success, negative values on failure.
1367  *
1368  */
calipso_skbuff_delattr(struct sk_buff * skb)1369 static int calipso_skbuff_delattr(struct sk_buff *skb)
1370 {
1371 	int ret_val;
1372 	struct ipv6hdr *ip6_hdr;
1373 	struct ipv6_opt_hdr *old_hop;
1374 	u32 old_hop_len, start = 0, end = 0, delta, size, pad;
1375 
1376 	if (!calipso_skbuff_optptr(skb))
1377 		return 0;
1378 
1379 	/* since we are changing the packet we should make a copy */
1380 	ret_val = skb_cow(skb, skb_headroom(skb));
1381 	if (ret_val < 0)
1382 		return ret_val;
1383 
1384 	ip6_hdr = ipv6_hdr(skb);
1385 	old_hop = (struct ipv6_opt_hdr *)(ip6_hdr + 1);
1386 	old_hop_len = ipv6_optlen(old_hop);
1387 
1388 	ret_val = calipso_opt_find(old_hop, &start, &end);
1389 	if (ret_val)
1390 		return ret_val;
1391 
1392 	if (start == sizeof(*old_hop) && end == old_hop_len) {
1393 		/* There's no other option in the header so we delete
1394 		 * the whole thing. */
1395 		delta = old_hop_len;
1396 		size = sizeof(*ip6_hdr);
1397 		ip6_hdr->nexthdr = old_hop->nexthdr;
1398 	} else {
1399 		delta = (end - start) & ~7;
1400 		if (delta)
1401 			old_hop->hdrlen -= delta / 8;
1402 		pad = (end - start) & 7;
1403 		size = sizeof(*ip6_hdr) + start + pad;
1404 		calipso_pad_write((unsigned char *)old_hop, start, pad);
1405 	}
1406 
1407 	if (delta) {
1408 		skb_pull(skb, delta);
1409 		memmove((char *)ip6_hdr + delta, ip6_hdr, size);
1410 		skb_reset_network_header(skb);
1411 	}
1412 
1413 	return 0;
1414 }
1415 
1416 static const struct netlbl_calipso_ops ops = {
1417 	.doi_add          = calipso_doi_add,
1418 	.doi_free         = calipso_doi_free,
1419 	.doi_remove       = calipso_doi_remove,
1420 	.doi_getdef       = calipso_doi_getdef,
1421 	.doi_putdef       = calipso_doi_putdef,
1422 	.doi_walk         = calipso_doi_walk,
1423 	.sock_getattr     = calipso_sock_getattr,
1424 	.sock_setattr     = calipso_sock_setattr,
1425 	.sock_delattr     = calipso_sock_delattr,
1426 	.req_setattr      = calipso_req_setattr,
1427 	.req_delattr      = calipso_req_delattr,
1428 	.opt_getattr      = calipso_opt_getattr,
1429 	.skbuff_optptr    = calipso_skbuff_optptr,
1430 	.skbuff_setattr   = calipso_skbuff_setattr,
1431 	.skbuff_delattr   = calipso_skbuff_delattr,
1432 	.cache_invalidate = calipso_cache_invalidate,
1433 	.cache_add        = calipso_cache_add
1434 };
1435 
1436 /**
1437  * calipso_init - Initialize the CALIPSO module
1438  *
1439  * Description:
1440  * Initialize the CALIPSO module and prepare it for use.  Returns zero on
1441  * success and negative values on failure.
1442  *
1443  */
calipso_init(void)1444 int __init calipso_init(void)
1445 {
1446 	int ret_val;
1447 
1448 	ret_val = calipso_cache_init();
1449 	if (!ret_val)
1450 		netlbl_calipso_ops_register(&ops);
1451 	return ret_val;
1452 }
1453 
calipso_exit(void)1454 void calipso_exit(void)
1455 {
1456 	netlbl_calipso_ops_register(NULL);
1457 	calipso_cache_invalidate();
1458 	kfree(calipso_cache);
1459 }
1460