2 * NetLabel Management Support
4 * This file defines the management functions for the NetLabel system. The
5 * NetLabel system manages static and dynamic label mappings for network
6 * protocols such as CIPSO and RIPSO.
8 * Author: Paul Moore <paul@paul-moore.com>
13 * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
23 * the GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see <http://www.gnu.org/licenses/>.
30 #include <linux/types.h>
31 #include <linux/socket.h>
32 #include <linux/string.h>
33 #include <linux/skbuff.h>
35 #include <linux/in6.h>
36 #include <linux/slab.h>
38 #include <net/netlink.h>
39 #include <net/genetlink.h>
42 #include <net/netlabel.h>
43 #include <net/cipso_ipv4.h>
44 #include <linux/atomic.h>
46 #include "netlabel_domainhash.h"
47 #include "netlabel_user.h"
48 #include "netlabel_mgmt.h"
50 /* NetLabel configured protocol counter */
51 atomic_t netlabel_mgmt_protocount = ATOMIC_INIT(0);
53 /* Argument struct for netlbl_domhsh_walk() */
54 struct netlbl_domhsh_walk_arg {
55 struct netlink_callback *nl_cb;
60 /* NetLabel Generic NETLINK CIPSOv4 family */
61 static struct genl_family netlbl_mgmt_gnl_family = {
62 .id = GENL_ID_GENERATE,
64 .name = NETLBL_NLTYPE_MGMT_NAME,
65 .version = NETLBL_PROTO_VERSION,
66 .maxattr = NLBL_MGMT_A_MAX,
69 /* NetLabel Netlink attribute policy */
70 static const struct nla_policy netlbl_mgmt_genl_policy[NLBL_MGMT_A_MAX + 1] = {
71 [NLBL_MGMT_A_DOMAIN] = { .type = NLA_NUL_STRING },
72 [NLBL_MGMT_A_PROTOCOL] = { .type = NLA_U32 },
73 [NLBL_MGMT_A_VERSION] = { .type = NLA_U32 },
74 [NLBL_MGMT_A_CV4DOI] = { .type = NLA_U32 },
82 * netlbl_mgmt_add - Handle an ADD message
83 * @info: the Generic NETLINK info block
84 * @audit_info: NetLabel audit information
87 * Helper function for the ADD and ADDDEF messages to add the domain mappings
88 * from the message to the hash table. See netlabel.h for a description of the
89 * message format. Returns zero on success, negative values on failure.
92 static int netlbl_mgmt_add_common(struct genl_info *info,
93 struct netlbl_audit *audit_info)
96 int ret_val = -EINVAL;
97 struct netlbl_domaddr_map *addrmap = NULL;
98 struct cipso_v4_doi *cipsov4 = NULL;
100 struct netlbl_dom_map *entry = kzalloc(sizeof(*entry), GFP_KERNEL);
104 entry->def.type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
105 if (info->attrs[NLBL_MGMT_A_DOMAIN]) {
106 size_t tmp_size = nla_len(info->attrs[NLBL_MGMT_A_DOMAIN]);
107 entry->domain = kmalloc(tmp_size, GFP_KERNEL);
108 if (entry->domain == NULL) {
112 nla_strlcpy(entry->domain,
113 info->attrs[NLBL_MGMT_A_DOMAIN], tmp_size);
116 /* NOTE: internally we allow/use a entry->def.type value of
117 * NETLBL_NLTYPE_ADDRSELECT but we don't currently allow users
118 * to pass that as a protocol value because we need to know the
121 switch (entry->def.type) {
122 case NETLBL_NLTYPE_UNLABELED:
124 case NETLBL_NLTYPE_CIPSOV4:
125 if (!info->attrs[NLBL_MGMT_A_CV4DOI])
126 goto add_free_domain;
128 tmp_val = nla_get_u32(info->attrs[NLBL_MGMT_A_CV4DOI]);
129 cipsov4 = cipso_v4_doi_getdef(tmp_val);
131 goto add_free_domain;
132 entry->def.cipso = cipsov4;
135 goto add_free_domain;
138 if (info->attrs[NLBL_MGMT_A_IPV4ADDR]) {
139 struct in_addr *addr;
140 struct in_addr *mask;
141 struct netlbl_domaddr4_map *map;
143 addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
144 if (addrmap == NULL) {
146 goto add_doi_put_def;
148 INIT_LIST_HEAD(&addrmap->list4);
149 INIT_LIST_HEAD(&addrmap->list6);
151 if (nla_len(info->attrs[NLBL_MGMT_A_IPV4ADDR]) !=
152 sizeof(struct in_addr)) {
154 goto add_free_addrmap;
156 if (nla_len(info->attrs[NLBL_MGMT_A_IPV4MASK]) !=
157 sizeof(struct in_addr)) {
159 goto add_free_addrmap;
161 addr = nla_data(info->attrs[NLBL_MGMT_A_IPV4ADDR]);
162 mask = nla_data(info->attrs[NLBL_MGMT_A_IPV4MASK]);
164 map = kzalloc(sizeof(*map), GFP_KERNEL);
167 goto add_free_addrmap;
170 map->list.addr = addr->s_addr & mask->s_addr;
171 map->list.mask = mask->s_addr;
173 map->def.type = entry->def.type;
175 map->def.cipso = cipsov4;
177 ret_val = netlbl_af4list_add(&map->list, &addrmap->list4);
181 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
182 entry->def.addrsel = addrmap;
183 #if IS_ENABLED(CONFIG_IPV6)
184 } else if (info->attrs[NLBL_MGMT_A_IPV6ADDR]) {
185 struct in6_addr *addr;
186 struct in6_addr *mask;
187 struct netlbl_domaddr6_map *map;
189 addrmap = kzalloc(sizeof(*addrmap), GFP_KERNEL);
190 if (addrmap == NULL) {
192 goto add_doi_put_def;
194 INIT_LIST_HEAD(&addrmap->list4);
195 INIT_LIST_HEAD(&addrmap->list6);
197 if (nla_len(info->attrs[NLBL_MGMT_A_IPV6ADDR]) !=
198 sizeof(struct in6_addr)) {
200 goto add_free_addrmap;
202 if (nla_len(info->attrs[NLBL_MGMT_A_IPV6MASK]) !=
203 sizeof(struct in6_addr)) {
205 goto add_free_addrmap;
207 addr = nla_data(info->attrs[NLBL_MGMT_A_IPV6ADDR]);
208 mask = nla_data(info->attrs[NLBL_MGMT_A_IPV6MASK]);
210 map = kzalloc(sizeof(*map), GFP_KERNEL);
213 goto add_free_addrmap;
216 map->list.addr = *addr;
217 map->list.addr.s6_addr32[0] &= mask->s6_addr32[0];
218 map->list.addr.s6_addr32[1] &= mask->s6_addr32[1];
219 map->list.addr.s6_addr32[2] &= mask->s6_addr32[2];
220 map->list.addr.s6_addr32[3] &= mask->s6_addr32[3];
221 map->list.mask = *mask;
223 map->def.type = entry->def.type;
225 ret_val = netlbl_af6list_add(&map->list, &addrmap->list6);
229 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
230 entry->def.addrsel = addrmap;
234 ret_val = netlbl_domhsh_add(entry, audit_info);
245 cipso_v4_doi_putdef(cipsov4);
247 kfree(entry->domain);
254 * netlbl_mgmt_listentry - List a NetLabel/LSM domain map entry
255 * @skb: the NETLINK buffer
256 * @entry: the map entry
259 * This function is a helper function used by the LISTALL and LISTDEF command
260 * handlers. The caller is responsible for ensuring that the RCU read lock
261 * is held. Returns zero on success, negative values on failure.
264 static int netlbl_mgmt_listentry(struct sk_buff *skb,
265 struct netlbl_dom_map *entry)
268 struct nlattr *nla_a;
269 struct nlattr *nla_b;
270 struct netlbl_af4list *iter4;
271 #if IS_ENABLED(CONFIG_IPV6)
272 struct netlbl_af6list *iter6;
275 if (entry->domain != NULL) {
276 ret_val = nla_put_string(skb,
277 NLBL_MGMT_A_DOMAIN, entry->domain);
282 switch (entry->def.type) {
283 case NETLBL_NLTYPE_ADDRSELECT:
284 nla_a = nla_nest_start(skb, NLBL_MGMT_A_SELECTORLIST);
288 netlbl_af4list_foreach_rcu(iter4, &entry->def.addrsel->list4) {
289 struct netlbl_domaddr4_map *map4;
290 struct in_addr addr_struct;
292 nla_b = nla_nest_start(skb, NLBL_MGMT_A_ADDRSELECTOR);
296 addr_struct.s_addr = iter4->addr;
297 ret_val = nla_put_in_addr(skb, NLBL_MGMT_A_IPV4ADDR,
301 addr_struct.s_addr = iter4->mask;
302 ret_val = nla_put_in_addr(skb, NLBL_MGMT_A_IPV4MASK,
306 map4 = netlbl_domhsh_addr4_entry(iter4);
307 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
311 switch (map4->def.type) {
312 case NETLBL_NLTYPE_CIPSOV4:
313 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CV4DOI,
314 map4->def.cipso->doi);
320 nla_nest_end(skb, nla_b);
322 #if IS_ENABLED(CONFIG_IPV6)
323 netlbl_af6list_foreach_rcu(iter6, &entry->def.addrsel->list6) {
324 struct netlbl_domaddr6_map *map6;
326 nla_b = nla_nest_start(skb, NLBL_MGMT_A_ADDRSELECTOR);
330 ret_val = nla_put_in6_addr(skb, NLBL_MGMT_A_IPV6ADDR,
334 ret_val = nla_put_in6_addr(skb, NLBL_MGMT_A_IPV6MASK,
338 map6 = netlbl_domhsh_addr6_entry(iter6);
339 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL,
344 nla_nest_end(skb, nla_b);
348 nla_nest_end(skb, nla_a);
350 case NETLBL_NLTYPE_UNLABELED:
351 ret_val = nla_put_u32(skb,NLBL_MGMT_A_PROTOCOL,entry->def.type);
353 case NETLBL_NLTYPE_CIPSOV4:
354 ret_val = nla_put_u32(skb,NLBL_MGMT_A_PROTOCOL,entry->def.type);
357 ret_val = nla_put_u32(skb, NLBL_MGMT_A_CV4DOI,
358 entry->def.cipso->doi);
366 * NetLabel Command Handlers
370 * netlbl_mgmt_add - Handle an ADD message
371 * @skb: the NETLINK buffer
372 * @info: the Generic NETLINK info block
375 * Process a user generated ADD message and add the domains from the message
376 * to the hash table. See netlabel.h for a description of the message format.
377 * Returns zero on success, negative values on failure.
380 static int netlbl_mgmt_add(struct sk_buff *skb, struct genl_info *info)
382 struct netlbl_audit audit_info;
384 if ((!info->attrs[NLBL_MGMT_A_DOMAIN]) ||
385 (!info->attrs[NLBL_MGMT_A_PROTOCOL]) ||
386 (info->attrs[NLBL_MGMT_A_IPV4ADDR] &&
387 info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
388 (info->attrs[NLBL_MGMT_A_IPV4MASK] &&
389 info->attrs[NLBL_MGMT_A_IPV6MASK]) ||
390 ((info->attrs[NLBL_MGMT_A_IPV4ADDR] != NULL) ^
391 (info->attrs[NLBL_MGMT_A_IPV4MASK] != NULL)) ||
392 ((info->attrs[NLBL_MGMT_A_IPV6ADDR] != NULL) ^
393 (info->attrs[NLBL_MGMT_A_IPV6MASK] != NULL)))
396 netlbl_netlink_auditinfo(skb, &audit_info);
398 return netlbl_mgmt_add_common(info, &audit_info);
402 * netlbl_mgmt_remove - Handle a REMOVE message
403 * @skb: the NETLINK buffer
404 * @info: the Generic NETLINK info block
407 * Process a user generated REMOVE message and remove the specified domain
408 * mappings. Returns zero on success, negative values on failure.
411 static int netlbl_mgmt_remove(struct sk_buff *skb, struct genl_info *info)
414 struct netlbl_audit audit_info;
416 if (!info->attrs[NLBL_MGMT_A_DOMAIN])
419 netlbl_netlink_auditinfo(skb, &audit_info);
421 domain = nla_data(info->attrs[NLBL_MGMT_A_DOMAIN]);
422 return netlbl_domhsh_remove(domain, &audit_info);
426 * netlbl_mgmt_listall_cb - netlbl_domhsh_walk() callback for LISTALL
427 * @entry: the domain mapping hash table entry
428 * @arg: the netlbl_domhsh_walk_arg structure
431 * This function is designed to be used as a callback to the
432 * netlbl_domhsh_walk() function for use in generating a response for a LISTALL
433 * message. Returns the size of the message on success, negative values on
437 static int netlbl_mgmt_listall_cb(struct netlbl_dom_map *entry, void *arg)
439 int ret_val = -ENOMEM;
440 struct netlbl_domhsh_walk_arg *cb_arg = arg;
443 data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).portid,
444 cb_arg->seq, &netlbl_mgmt_gnl_family,
445 NLM_F_MULTI, NLBL_MGMT_C_LISTALL);
447 goto listall_cb_failure;
449 ret_val = netlbl_mgmt_listentry(cb_arg->skb, entry);
451 goto listall_cb_failure;
454 genlmsg_end(cb_arg->skb, data);
458 genlmsg_cancel(cb_arg->skb, data);
463 * netlbl_mgmt_listall - Handle a LISTALL message
464 * @skb: the NETLINK buffer
465 * @cb: the NETLINK callback
468 * Process a user generated LISTALL message and dumps the domain hash table in
469 * a form suitable for use in a kernel generated LISTALL message. Returns zero
470 * on success, negative values on failure.
473 static int netlbl_mgmt_listall(struct sk_buff *skb,
474 struct netlink_callback *cb)
476 struct netlbl_domhsh_walk_arg cb_arg;
477 u32 skip_bkt = cb->args[0];
478 u32 skip_chain = cb->args[1];
482 cb_arg.seq = cb->nlh->nlmsg_seq;
484 netlbl_domhsh_walk(&skip_bkt,
486 netlbl_mgmt_listall_cb,
489 cb->args[0] = skip_bkt;
490 cb->args[1] = skip_chain;
495 * netlbl_mgmt_adddef - Handle an ADDDEF message
496 * @skb: the NETLINK buffer
497 * @info: the Generic NETLINK info block
500 * Process a user generated ADDDEF message and respond accordingly. Returns
501 * zero on success, negative values on failure.
504 static int netlbl_mgmt_adddef(struct sk_buff *skb, struct genl_info *info)
506 struct netlbl_audit audit_info;
508 if ((!info->attrs[NLBL_MGMT_A_PROTOCOL]) ||
509 (info->attrs[NLBL_MGMT_A_IPV4ADDR] &&
510 info->attrs[NLBL_MGMT_A_IPV6ADDR]) ||
511 (info->attrs[NLBL_MGMT_A_IPV4MASK] &&
512 info->attrs[NLBL_MGMT_A_IPV6MASK]) ||
513 ((info->attrs[NLBL_MGMT_A_IPV4ADDR] != NULL) ^
514 (info->attrs[NLBL_MGMT_A_IPV4MASK] != NULL)) ||
515 ((info->attrs[NLBL_MGMT_A_IPV6ADDR] != NULL) ^
516 (info->attrs[NLBL_MGMT_A_IPV6MASK] != NULL)))
519 netlbl_netlink_auditinfo(skb, &audit_info);
521 return netlbl_mgmt_add_common(info, &audit_info);
525 * netlbl_mgmt_removedef - Handle a REMOVEDEF message
526 * @skb: the NETLINK buffer
527 * @info: the Generic NETLINK info block
530 * Process a user generated REMOVEDEF message and remove the default domain
531 * mapping. Returns zero on success, negative values on failure.
534 static int netlbl_mgmt_removedef(struct sk_buff *skb, struct genl_info *info)
536 struct netlbl_audit audit_info;
538 netlbl_netlink_auditinfo(skb, &audit_info);
540 return netlbl_domhsh_remove_default(&audit_info);
544 * netlbl_mgmt_listdef - Handle a LISTDEF message
545 * @skb: the NETLINK buffer
546 * @info: the Generic NETLINK info block
549 * Process a user generated LISTDEF message and dumps the default domain
550 * mapping in a form suitable for use in a kernel generated LISTDEF message.
551 * Returns zero on success, negative values on failure.
554 static int netlbl_mgmt_listdef(struct sk_buff *skb, struct genl_info *info)
556 int ret_val = -ENOMEM;
557 struct sk_buff *ans_skb = NULL;
559 struct netlbl_dom_map *entry;
561 ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
564 data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
565 0, NLBL_MGMT_C_LISTDEF);
567 goto listdef_failure;
570 entry = netlbl_domhsh_getentry(NULL);
573 goto listdef_failure_lock;
575 ret_val = netlbl_mgmt_listentry(ans_skb, entry);
578 goto listdef_failure;
580 genlmsg_end(ans_skb, data);
581 return genlmsg_reply(ans_skb, info);
583 listdef_failure_lock:
591 * netlbl_mgmt_protocols_cb - Write an individual PROTOCOL message response
592 * @skb: the skb to write to
593 * @cb: the NETLINK callback
594 * @protocol: the NetLabel protocol to use in the message
597 * This function is to be used in conjunction with netlbl_mgmt_protocols() to
598 * answer a application's PROTOCOLS message. Returns the size of the message
599 * on success, negative values on failure.
602 static int netlbl_mgmt_protocols_cb(struct sk_buff *skb,
603 struct netlink_callback *cb,
606 int ret_val = -ENOMEM;
609 data = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
610 &netlbl_mgmt_gnl_family, NLM_F_MULTI,
611 NLBL_MGMT_C_PROTOCOLS);
613 goto protocols_cb_failure;
615 ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, protocol);
617 goto protocols_cb_failure;
619 genlmsg_end(skb, data);
622 protocols_cb_failure:
623 genlmsg_cancel(skb, data);
628 * netlbl_mgmt_protocols - Handle a PROTOCOLS message
629 * @skb: the NETLINK buffer
630 * @cb: the NETLINK callback
633 * Process a user generated PROTOCOLS message and respond accordingly.
636 static int netlbl_mgmt_protocols(struct sk_buff *skb,
637 struct netlink_callback *cb)
639 u32 protos_sent = cb->args[0];
641 if (protos_sent == 0) {
642 if (netlbl_mgmt_protocols_cb(skb,
644 NETLBL_NLTYPE_UNLABELED) < 0)
645 goto protocols_return;
648 if (protos_sent == 1) {
649 if (netlbl_mgmt_protocols_cb(skb,
651 NETLBL_NLTYPE_CIPSOV4) < 0)
652 goto protocols_return;
657 cb->args[0] = protos_sent;
662 * netlbl_mgmt_version - Handle a VERSION message
663 * @skb: the NETLINK buffer
664 * @info: the Generic NETLINK info block
667 * Process a user generated VERSION message and respond accordingly. Returns
668 * zero on success, negative values on failure.
671 static int netlbl_mgmt_version(struct sk_buff *skb, struct genl_info *info)
673 int ret_val = -ENOMEM;
674 struct sk_buff *ans_skb = NULL;
677 ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
680 data = genlmsg_put_reply(ans_skb, info, &netlbl_mgmt_gnl_family,
681 0, NLBL_MGMT_C_VERSION);
683 goto version_failure;
685 ret_val = nla_put_u32(ans_skb,
687 NETLBL_PROTO_VERSION);
689 goto version_failure;
691 genlmsg_end(ans_skb, data);
692 return genlmsg_reply(ans_skb, info);
701 * NetLabel Generic NETLINK Command Definitions
704 static const struct genl_ops netlbl_mgmt_genl_ops[] = {
706 .cmd = NLBL_MGMT_C_ADD,
707 .flags = GENL_ADMIN_PERM,
708 .policy = netlbl_mgmt_genl_policy,
709 .doit = netlbl_mgmt_add,
713 .cmd = NLBL_MGMT_C_REMOVE,
714 .flags = GENL_ADMIN_PERM,
715 .policy = netlbl_mgmt_genl_policy,
716 .doit = netlbl_mgmt_remove,
720 .cmd = NLBL_MGMT_C_LISTALL,
722 .policy = netlbl_mgmt_genl_policy,
724 .dumpit = netlbl_mgmt_listall,
727 .cmd = NLBL_MGMT_C_ADDDEF,
728 .flags = GENL_ADMIN_PERM,
729 .policy = netlbl_mgmt_genl_policy,
730 .doit = netlbl_mgmt_adddef,
734 .cmd = NLBL_MGMT_C_REMOVEDEF,
735 .flags = GENL_ADMIN_PERM,
736 .policy = netlbl_mgmt_genl_policy,
737 .doit = netlbl_mgmt_removedef,
741 .cmd = NLBL_MGMT_C_LISTDEF,
743 .policy = netlbl_mgmt_genl_policy,
744 .doit = netlbl_mgmt_listdef,
748 .cmd = NLBL_MGMT_C_PROTOCOLS,
750 .policy = netlbl_mgmt_genl_policy,
752 .dumpit = netlbl_mgmt_protocols,
755 .cmd = NLBL_MGMT_C_VERSION,
757 .policy = netlbl_mgmt_genl_policy,
758 .doit = netlbl_mgmt_version,
764 * NetLabel Generic NETLINK Protocol Functions
768 * netlbl_mgmt_genl_init - Register the NetLabel management component
771 * Register the NetLabel management component with the Generic NETLINK
772 * mechanism. Returns zero on success, negative values on failure.
775 int __init netlbl_mgmt_genl_init(void)
777 return genl_register_family_with_ops(&netlbl_mgmt_gnl_family,
778 netlbl_mgmt_genl_ops);