net/netlabel/netlabel_kapi.c

   1 /*
   2  * NetLabel Kernel API
   3  *
   4  * This file defines the kernel API for the NetLabel system.  The NetLabel
   5  * system manages static and dynamic label mappings for network protocols such
   6  * as CIPSO and RIPSO.
   7  *
   8  * Author: Paul Moore <paul@paul-moore.com>
   9  *
  10  */
  11
  12 /*
  13  * (c) Copyright Hewlett-Packard Development Company, L.P., 2006, 2008
  14  *
  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.
  19  *
  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.
  24  *
  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/>.
  27  *
  28  */
  29
  30 #include <linux/init.h>
  31 #include <linux/types.h>
  32 #include <linux/slab.h>
  33 #include <linux/audit.h>
  34 #include <linux/in.h>
  35 #include <linux/in6.h>
  36 #include <net/ip.h>
  37 #include <net/ipv6.h>
  38 #include <net/netlabel.h>
  39 #include <net/cipso_ipv4.h>
  40 #include <asm/bug.h>
  41 #include <linux/atomic.h>
  42
  43 #include "netlabel_domainhash.h"
  44 #include "netlabel_unlabeled.h"
  45 #include "netlabel_cipso_v4.h"
  46 #include "netlabel_user.h"
  47 #include "netlabel_mgmt.h"
  48 #include "netlabel_addrlist.h"
  49
  50 /*
  51  * Configuration Functions
  52  */
  53
  54 /**
  55  * netlbl_cfg_map_del - Remove a NetLabel/LSM domain mapping
  56  * @domain: the domain mapping to remove
  57  * @family: address family
  58  * @addr: IP address
  59  * @mask: IP address mask
  60  * @audit_info: NetLabel audit information
  61  *
  62  * Description:
  63  * Removes a NetLabel/LSM domain mapping.  A @domain value of NULL causes the
  64  * default domain mapping to be removed.  Returns zero on success, negative
  65  * values on failure.
  66  *
  67  */
  68 int netlbl_cfg_map_del(const char *domain,
  69                        u16 family,
  70                        const void *addr,
  71                        const void *mask,
  72                        struct netlbl_audit *audit_info)
  73 {
  74         if (addr == NULL && mask == NULL) {
  75                 return netlbl_domhsh_remove(domain, audit_info);
  76         } else if (addr != NULL && mask != NULL) {
  77                 switch (family) {
  78                 case AF_INET:
  79                         return netlbl_domhsh_remove_af4(domain, addr, mask,
  80                                                         audit_info);
  81                 default:
  82                         return -EPFNOSUPPORT;
  83                 }
  84         } else
  85                 return -EINVAL;
  86 }
  87
  88 /**
  89  * netlbl_cfg_unlbl_map_add - Add a new unlabeled mapping
  90  * @domain: the domain mapping to add
  91  * @family: address family
  92  * @addr: IP address
  93  * @mask: IP address mask
  94  * @audit_info: NetLabel audit information
  95  *
  96  * Description:
  97  * Adds a new unlabeled NetLabel/LSM domain mapping.  A @domain value of NULL
  98  * causes a new default domain mapping to be added.  Returns zero on success,
  99  * negative values on failure.
 100  *
 101  */
 102 int netlbl_cfg_unlbl_map_add(const char *domain,
 103                              u16 family,
 104                              const void *addr,
 105                              const void *mask,
 106                              struct netlbl_audit *audit_info)
 107 {
 108         int ret_val = -ENOMEM;
 109         struct netlbl_dom_map *entry;
 110         struct netlbl_domaddr_map *addrmap = NULL;
 111         struct netlbl_domaddr4_map *map4 = NULL;
 112         struct netlbl_domaddr6_map *map6 = NULL;
 113
 114         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 115         if (entry == NULL)
 116                 return -ENOMEM;
 117         if (domain != NULL) {
 118                 entry->domain = kstrdup(domain, GFP_ATOMIC);
 119                 if (entry->domain == NULL)
 120                         goto cfg_unlbl_map_add_failure;
 121         }
 122
 123         if (addr == NULL && mask == NULL)
 124                 entry->def.type = NETLBL_NLTYPE_UNLABELED;
 125         else if (addr != NULL && mask != NULL) {
 126                 addrmap = kzalloc(sizeof(*addrmap), GFP_ATOMIC);
 127                 if (addrmap == NULL)
 128                         goto cfg_unlbl_map_add_failure;
 129                 INIT_LIST_HEAD(&addrmap->list4);
 130                 INIT_LIST_HEAD(&addrmap->list6);
 131
 132                 switch (family) {
 133                 case AF_INET: {
 134                         const struct in_addr *addr4 = addr;
 135                         const struct in_addr *mask4 = mask;
 136                         map4 = kzalloc(sizeof(*map4), GFP_ATOMIC);
 137                         if (map4 == NULL)
 138                                 goto cfg_unlbl_map_add_failure;
 139                         map4->def.type = NETLBL_NLTYPE_UNLABELED;
 140                         map4->list.addr = addr4->s_addr & mask4->s_addr;
 141                         map4->list.mask = mask4->s_addr;
 142                         map4->list.valid = 1;
 143                         ret_val = netlbl_af4list_add(&map4->list,
 144                                                      &addrmap->list4);
 145                         if (ret_val != 0)
 146                                 goto cfg_unlbl_map_add_failure;
 147                         break;
 148                         }
 149 #if IS_ENABLED(CONFIG_IPV6)
 150                 case AF_INET6: {
 151                         const struct in6_addr *addr6 = addr;
 152                         const struct in6_addr *mask6 = mask;
 153                         map6 = kzalloc(sizeof(*map6), GFP_ATOMIC);
 154                         if (map6 == NULL)
 155                                 goto cfg_unlbl_map_add_failure;
 156                         map6->def.type = NETLBL_NLTYPE_UNLABELED;
 157                         map6->list.addr = *addr6;
 158                         map6->list.addr.s6_addr32[0] &= mask6->s6_addr32[0];
 159                         map6->list.addr.s6_addr32[1] &= mask6->s6_addr32[1];
 160                         map6->list.addr.s6_addr32[2] &= mask6->s6_addr32[2];
 161                         map6->list.addr.s6_addr32[3] &= mask6->s6_addr32[3];
 162                         map6->list.mask = *mask6;
 163                         map6->list.valid = 1;
 164                         ret_val = netlbl_af6list_add(&map6->list,
 165                                                      &addrmap->list6);
 166                         if (ret_val != 0)
 167                                 goto cfg_unlbl_map_add_failure;
 168                         break;
 169                         }
 170 #endif /* IPv6 */
 171                 default:
 172                         goto cfg_unlbl_map_add_failure;
 173                 }
 174
 175                 entry->def.addrsel = addrmap;
 176                 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
 177         } else {
 178                 ret_val = -EINVAL;
 179                 goto cfg_unlbl_map_add_failure;
 180         }
 181
 182         ret_val = netlbl_domhsh_add(entry, audit_info);
 183         if (ret_val != 0)
 184                 goto cfg_unlbl_map_add_failure;
 185
 186         return 0;
 187
 188 cfg_unlbl_map_add_failure:
 189         kfree(entry->domain);
 190         kfree(entry);
 191         kfree(addrmap);
 192         kfree(map4);
 193         kfree(map6);
 194         return ret_val;
 195 }
 196
 197
 198 /**
 199  * netlbl_cfg_unlbl_static_add - Adds a new static label
 200  * @net: network namespace
 201  * @dev_name: interface name
 202  * @addr: IP address in network byte order (struct in[6]_addr)
 203  * @mask: address mask in network byte order (struct in[6]_addr)
 204  * @family: address family
 205  * @secid: LSM secid value for the entry
 206  * @audit_info: NetLabel audit information
 207  *
 208  * Description:
 209  * Adds a new NetLabel static label to be used when protocol provided labels
 210  * are not present on incoming traffic.  If @dev_name is NULL then the default
 211  * interface will be used.  Returns zero on success, negative values on failure.
 212  *
 213  */
 214 int netlbl_cfg_unlbl_static_add(struct net *net,
 215                                 const char *dev_name,
 216                                 const void *addr,
 217                                 const void *mask,
 218                                 u16 family,
 219                                 u32 secid,
 220                                 struct netlbl_audit *audit_info)
 221 {
 222         u32 addr_len;
 223
 224         switch (family) {
 225         case AF_INET:
 226                 addr_len = sizeof(struct in_addr);
 227                 break;
 228 #if IS_ENABLED(CONFIG_IPV6)
 229         case AF_INET6:
 230                 addr_len = sizeof(struct in6_addr);
 231                 break;
 232 #endif /* IPv6 */
 233         default:
 234                 return -EPFNOSUPPORT;
 235         }
 236
 237         return netlbl_unlhsh_add(net,
 238                                  dev_name, addr, mask, addr_len,
 239                                  secid, audit_info);
 240 }
 241
 242 /**
 243  * netlbl_cfg_unlbl_static_del - Removes an existing static label
 244  * @net: network namespace
 245  * @dev_name: interface name
 246  * @addr: IP address in network byte order (struct in[6]_addr)
 247  * @mask: address mask in network byte order (struct in[6]_addr)
 248  * @family: address family
 249  * @secid: LSM secid value for the entry
 250  * @audit_info: NetLabel audit information
 251  *
 252  * Description:
 253  * Removes an existing NetLabel static label used when protocol provided labels
 254  * are not present on incoming traffic.  If @dev_name is NULL then the default
 255  * interface will be used.  Returns zero on success, negative values on failure.
 256  *
 257  */
 258 int netlbl_cfg_unlbl_static_del(struct net *net,
 259                                 const char *dev_name,
 260                                 const void *addr,
 261                                 const void *mask,
 262                                 u16 family,
 263                                 struct netlbl_audit *audit_info)
 264 {
 265         u32 addr_len;
 266
 267         switch (family) {
 268         case AF_INET:
 269                 addr_len = sizeof(struct in_addr);
 270                 break;
 271 #if IS_ENABLED(CONFIG_IPV6)
 272         case AF_INET6:
 273                 addr_len = sizeof(struct in6_addr);
 274                 break;
 275 #endif /* IPv6 */
 276         default:
 277                 return -EPFNOSUPPORT;
 278         }
 279
 280         return netlbl_unlhsh_remove(net,
 281                                     dev_name, addr, mask, addr_len,
 282                                     audit_info);
 283 }
 284
 285 /**
 286  * netlbl_cfg_cipsov4_add - Add a new CIPSOv4 DOI definition
 287  * @doi_def: CIPSO DOI definition
 288  * @audit_info: NetLabel audit information
 289  *
 290  * Description:
 291  * Add a new CIPSO DOI definition as defined by @doi_def.  Returns zero on
 292  * success and negative values on failure.
 293  *
 294  */
 295 int netlbl_cfg_cipsov4_add(struct cipso_v4_doi *doi_def,
 296                            struct netlbl_audit *audit_info)
 297 {
 298         return cipso_v4_doi_add(doi_def, audit_info);
 299 }
 300
 301 /**
 302  * netlbl_cfg_cipsov4_del - Remove an existing CIPSOv4 DOI definition
 303  * @doi: CIPSO DOI
 304  * @audit_info: NetLabel audit information
 305  *
 306  * Description:
 307  * Remove an existing CIPSO DOI definition matching @doi.  Returns zero on
 308  * success and negative values on failure.
 309  *
 310  */
 311 void netlbl_cfg_cipsov4_del(u32 doi, struct netlbl_audit *audit_info)
 312 {
 313         cipso_v4_doi_remove(doi, audit_info);
 314 }
 315
 316 /**
 317  * netlbl_cfg_cipsov4_map_add - Add a new CIPSOv4 DOI mapping
 318  * @doi: the CIPSO DOI
 319  * @domain: the domain mapping to add
 320  * @addr: IP address
 321  * @mask: IP address mask
 322  * @audit_info: NetLabel audit information
 323  *
 324  * Description:
 325  * Add a new NetLabel/LSM domain mapping for the given CIPSO DOI to the NetLabel
 326  * subsystem.  A @domain value of NULL adds a new default domain mapping.
 327  * Returns zero on success, negative values on failure.
 328  *
 329  */
 330 int netlbl_cfg_cipsov4_map_add(u32 doi,
 331                                const char *domain,
 332                                const struct in_addr *addr,
 333                                const struct in_addr *mask,
 334                                struct netlbl_audit *audit_info)
 335 {
 336         int ret_val = -ENOMEM;
 337         struct cipso_v4_doi *doi_def;
 338         struct netlbl_dom_map *entry;
 339         struct netlbl_domaddr_map *addrmap = NULL;
 340         struct netlbl_domaddr4_map *addrinfo = NULL;
 341
 342         doi_def = cipso_v4_doi_getdef(doi);
 343         if (doi_def == NULL)
 344                 return -ENOENT;
 345
 346         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 347         if (entry == NULL)
 348                 goto out_entry;
 349         if (domain != NULL) {
 350                 entry->domain = kstrdup(domain, GFP_ATOMIC);
 351                 if (entry->domain == NULL)
 352                         goto out_domain;
 353         }
 354
 355         if (addr == NULL && mask == NULL) {
 356                 entry->def.cipso = doi_def;
 357                 entry->def.type = NETLBL_NLTYPE_CIPSOV4;
 358         } else if (addr != NULL && mask != NULL) {
 359                 addrmap = kzalloc(sizeof(*addrmap), GFP_ATOMIC);
 360                 if (addrmap == NULL)
 361                         goto out_addrmap;
 362                 INIT_LIST_HEAD(&addrmap->list4);
 363                 INIT_LIST_HEAD(&addrmap->list6);
 364
 365                 addrinfo = kzalloc(sizeof(*addrinfo), GFP_ATOMIC);
 366                 if (addrinfo == NULL)
 367                         goto out_addrinfo;
 368                 addrinfo->def.cipso = doi_def;
 369                 addrinfo->def.type = NETLBL_NLTYPE_CIPSOV4;
 370                 addrinfo->list.addr = addr->s_addr & mask->s_addr;
 371                 addrinfo->list.mask = mask->s_addr;
 372                 addrinfo->list.valid = 1;
 373                 ret_val = netlbl_af4list_add(&addrinfo->list, &addrmap->list4);
 374                 if (ret_val != 0)
 375                         goto cfg_cipsov4_map_add_failure;
 376
 377                 entry->def.addrsel = addrmap;
 378                 entry->def.type = NETLBL_NLTYPE_ADDRSELECT;
 379         } else {
 380                 ret_val = -EINVAL;
 381                 goto out_addrmap;
 382         }
 383
 384         ret_val = netlbl_domhsh_add(entry, audit_info);
 385         if (ret_val != 0)
 386                 goto cfg_cipsov4_map_add_failure;
 387
 388         return 0;
 389
 390 cfg_cipsov4_map_add_failure:
 391         kfree(addrinfo);
 392 out_addrinfo:
 393         kfree(addrmap);
 394 out_addrmap:
 395         kfree(entry->domain);
 396 out_domain:
 397         kfree(entry);
 398 out_entry:
 399         cipso_v4_doi_putdef(doi_def);
 400         return ret_val;
 401 }
 402
 403 /*
 404  * Security Attribute Functions
 405  */
 406
 407 /**
 408  * netlbl_secattr_catmap_walk - Walk a LSM secattr catmap looking for a bit
 409  * @catmap: the category bitmap
 410  * @offset: the offset to start searching at, in bits
 411  *
 412  * Description:
 413  * This function walks a LSM secattr category bitmap starting at @offset and
 414  * returns the spot of the first set bit or -ENOENT if no bits are set.
 415  *
 416  */
 417 int netlbl_secattr_catmap_walk(struct netlbl_lsm_secattr_catmap *catmap,
 418                                u32 offset)
 419 {
 420         struct netlbl_lsm_secattr_catmap *iter = catmap;
 421         u32 node_idx;
 422         u32 node_bit;
 423         NETLBL_CATMAP_MAPTYPE bitmap;
 424
 425         if (offset > iter->startbit) {
 426                 while (offset >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
 427                         iter = iter->next;
 428                         if (iter == NULL)
 429                                 return -ENOENT;
 430                 }
 431                 node_idx = (offset - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
 432                 node_bit = offset - iter->startbit -
 433                            (NETLBL_CATMAP_MAPSIZE * node_idx);
 434         } else {
 435                 node_idx = 0;
 436                 node_bit = 0;
 437         }
 438         bitmap = iter->bitmap[node_idx] >> node_bit;
 439
 440         for (;;) {
 441                 if (bitmap != 0) {
 442                         while ((bitmap & NETLBL_CATMAP_BIT) == 0) {
 443                                 bitmap >>= 1;
 444                                 node_bit++;
 445                         }
 446                         return iter->startbit +
 447                                 (NETLBL_CATMAP_MAPSIZE * node_idx) + node_bit;
 448                 }
 449                 if (++node_idx >= NETLBL_CATMAP_MAPCNT) {
 450                         if (iter->next != NULL) {
 451                                 iter = iter->next;
 452                                 node_idx = 0;
 453                         } else
 454                                 return -ENOENT;
 455                 }
 456                 bitmap = iter->bitmap[node_idx];
 457                 node_bit = 0;
 458         }
 459
 460         return -ENOENT;
 461 }
 462
 463 /**
 464  * netlbl_secattr_catmap_walk_rng - Find the end of a string of set bits
 465  * @catmap: the category bitmap
 466  * @offset: the offset to start searching at, in bits
 467  *
 468  * Description:
 469  * This function walks a LSM secattr category bitmap starting at @offset and
 470  * returns the spot of the first cleared bit or -ENOENT if the offset is past
 471  * the end of the bitmap.
 472  *
 473  */
 474 int netlbl_secattr_catmap_walk_rng(struct netlbl_lsm_secattr_catmap *catmap,
 475                                    u32 offset)
 476 {
 477         struct netlbl_lsm_secattr_catmap *iter = catmap;
 478         u32 node_idx;
 479         u32 node_bit;
 480         NETLBL_CATMAP_MAPTYPE bitmask;
 481         NETLBL_CATMAP_MAPTYPE bitmap;
 482
 483         if (offset > iter->startbit) {
 484                 while (offset >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
 485                         iter = iter->next;
 486                         if (iter == NULL)
 487                                 return -ENOENT;
 488                 }
 489                 node_idx = (offset - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
 490                 node_bit = offset - iter->startbit -
 491                            (NETLBL_CATMAP_MAPSIZE * node_idx);
 492         } else {
 493                 node_idx = 0;
 494                 node_bit = 0;
 495         }
 496         bitmask = NETLBL_CATMAP_BIT << node_bit;
 497
 498         for (;;) {
 499                 bitmap = iter->bitmap[node_idx];
 500                 while (bitmask != 0 && (bitmap & bitmask) != 0) {
 501                         bitmask <<= 1;
 502                         node_bit++;
 503                 }
 504
 505                 if (bitmask != 0)
 506                         return iter->startbit +
 507                                 (NETLBL_CATMAP_MAPSIZE * node_idx) +
 508                                 node_bit - 1;
 509                 else if (++node_idx >= NETLBL_CATMAP_MAPCNT) {
 510                         if (iter->next == NULL)
 511                                 return iter->startbit + NETLBL_CATMAP_SIZE - 1;
 512                         iter = iter->next;
 513                         node_idx = 0;
 514                 }
 515                 bitmask = NETLBL_CATMAP_BIT;
 516                 node_bit = 0;
 517         }
 518
 519         return -ENOENT;
 520 }
 521
 522 /**
 523  * netlbl_secattr_catmap_setbit - Set a bit in a LSM secattr catmap
 524  * @catmap: the category bitmap
 525  * @bit: the bit to set
 526  * @flags: memory allocation flags
 527  *
 528  * Description:
 529  * Set the bit specified by @bit in @catmap.  Returns zero on success,
 530  * negative values on failure.
 531  *
 532  */
 533 int netlbl_secattr_catmap_setbit(struct netlbl_lsm_secattr_catmap *catmap,
 534                                  u32 bit,
 535                                  gfp_t flags)
 536 {
 537         struct netlbl_lsm_secattr_catmap *iter = catmap;
 538         u32 node_bit;
 539         u32 node_idx;
 540
 541         while (iter->next != NULL &&
 542                bit >= (iter->startbit + NETLBL_CATMAP_SIZE))
 543                 iter = iter->next;
 544         if (bit >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
 545                 iter->next = netlbl_secattr_catmap_alloc(flags);
 546                 if (iter->next == NULL)
 547                         return -ENOMEM;
 548                 iter = iter->next;
 549                 iter->startbit = bit & ~(NETLBL_CATMAP_SIZE - 1);
 550         }
 551
 552         /* gcc always rounds to zero when doing integer division */
 553         node_idx = (bit - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
 554         node_bit = bit - iter->startbit - (NETLBL_CATMAP_MAPSIZE * node_idx);
 555         iter->bitmap[node_idx] |= NETLBL_CATMAP_BIT << node_bit;
 556
 557         return 0;
 558 }
 559
 560 /**
 561  * netlbl_secattr_catmap_setrng - Set a range of bits in a LSM secattr catmap
 562  * @catmap: the category bitmap
 563  * @start: the starting bit
 564  * @end: the last bit in the string
 565  * @flags: memory allocation flags
 566  *
 567  * Description:
 568  * Set a range of bits, starting at @start and ending with @end.  Returns zero
 569  * on success, negative values on failure.
 570  *
 571  */
 572 int netlbl_secattr_catmap_setrng(struct netlbl_lsm_secattr_catmap *catmap,
 573                                  u32 start,
 574                                  u32 end,
 575                                  gfp_t flags)
 576 {
 577         int ret_val = 0;
 578         struct netlbl_lsm_secattr_catmap *iter = catmap;
 579         u32 iter_max_spot;
 580         u32 spot;
 581
 582         /* XXX - This could probably be made a bit faster by combining writes
 583          * to the catmap instead of setting a single bit each time, but for
 584          * right now skipping to the start of the range in the catmap should
 585          * be a nice improvement over calling the individual setbit function
 586          * repeatedly from a loop. */
 587
 588         while (iter->next != NULL &&
 589                start >= (iter->startbit + NETLBL_CATMAP_SIZE))
 590                 iter = iter->next;
 591         iter_max_spot = iter->startbit + NETLBL_CATMAP_SIZE;
 592
 593         for (spot = start; spot <= end && ret_val == 0; spot++) {
 594                 if (spot >= iter_max_spot && iter->next != NULL) {
 595                         iter = iter->next;
 596                         iter_max_spot = iter->startbit + NETLBL_CATMAP_SIZE;
 597                 }
 598                 ret_val = netlbl_secattr_catmap_setbit(iter, spot, flags);
 599         }
 600
 601         return ret_val;
 602 }
 603
 604 /*
 605  * LSM Functions
 606  */
 607
 608 /**
 609  * netlbl_enabled - Determine if the NetLabel subsystem is enabled
 610  *
 611  * Description:
 612  * The LSM can use this function to determine if it should use NetLabel
 613  * security attributes in it's enforcement mechanism.  Currently, NetLabel is
 614  * considered to be enabled when it's configuration contains a valid setup for
 615  * at least one labeled protocol (i.e. NetLabel can understand incoming
 616  * labeled packets of at least one type); otherwise NetLabel is considered to
 617  * be disabled.
 618  *
 619  */
 620 int netlbl_enabled(void)
 621 {
 622         /* At some point we probably want to expose this mechanism to the user
 623          * as well so that admins can toggle NetLabel regardless of the
 624          * configuration */
 625         return (atomic_read(&netlabel_mgmt_protocount) > 0);
 626 }
 627
 628 /**
 629  * netlbl_sock_setattr - Label a socket using the correct protocol
 630  * @sk: the socket to label
 631  * @family: protocol family
 632  * @secattr: the security attributes
 633  *
 634  * Description:
 635  * Attach the correct label to the given socket using the security attributes
 636  * specified in @secattr.  This function requires exclusive access to @sk,
 637  * which means it either needs to be in the process of being created or locked.
 638  * Returns zero on success, -EDESTADDRREQ if the domain is configured to use
 639  * network address selectors (can't blindly label the socket), and negative
 640  * values on all other failures.
 641  *
 642  */
 643 int netlbl_sock_setattr(struct sock *sk,
 644                         u16 family,
 645                         const struct netlbl_lsm_secattr *secattr)
 646 {
 647         int ret_val;
 648         struct netlbl_dom_map *dom_entry;
 649
 650         rcu_read_lock();
 651         dom_entry = netlbl_domhsh_getentry(secattr->domain);
 652         if (dom_entry == NULL) {
 653                 ret_val = -ENOENT;
 654                 goto socket_setattr_return;
 655         }
 656         switch (family) {
 657         case AF_INET:
 658                 switch (dom_entry->def.type) {
 659                 case NETLBL_NLTYPE_ADDRSELECT:
 660                         ret_val = -EDESTADDRREQ;
 661                         break;
 662                 case NETLBL_NLTYPE_CIPSOV4:
 663                         ret_val = cipso_v4_sock_setattr(sk,
 664                                                         dom_entry->def.cipso,
 665                                                         secattr);
 666                         break;
 667                 case NETLBL_NLTYPE_UNLABELED:
 668                         ret_val = 0;
 669                         break;
 670                 default:
 671                         ret_val = -ENOENT;
 672                 }
 673                 break;
 674 #if IS_ENABLED(CONFIG_IPV6)
 675         case AF_INET6:
 676                 /* since we don't support any IPv6 labeling protocols right
 677                  * now we can optimize everything away until we do */
 678                 ret_val = 0;
 679                 break;
 680 #endif /* IPv6 */
 681         default:
 682                 ret_val = -EPROTONOSUPPORT;
 683         }
 684
 685 socket_setattr_return:
 686         rcu_read_unlock();
 687         return ret_val;
 688 }
 689
 690 /**
 691  * netlbl_sock_delattr - Delete all the NetLabel labels on a socket
 692  * @sk: the socket
 693  *
 694  * Description:
 695  * Remove all the NetLabel labeling from @sk.  The caller is responsible for
 696  * ensuring that @sk is locked.
 697  *
 698  */
 699 void netlbl_sock_delattr(struct sock *sk)
 700 {
 701         cipso_v4_sock_delattr(sk);
 702 }
 703
 704 /**
 705  * netlbl_sock_getattr - Determine the security attributes of a sock
 706  * @sk: the sock
 707  * @secattr: the security attributes
 708  *
 709  * Description:
 710  * Examines the given sock to see if any NetLabel style labeling has been
 711  * applied to the sock, if so it parses the socket label and returns the
 712  * security attributes in @secattr.  Returns zero on success, negative values
 713  * on failure.
 714  *
 715  */
 716 int netlbl_sock_getattr(struct sock *sk,
 717                         struct netlbl_lsm_secattr *secattr)
 718 {
 719         int ret_val;
 720
 721         switch (sk->sk_family) {
 722         case AF_INET:
 723                 ret_val = cipso_v4_sock_getattr(sk, secattr);
 724                 break;
 725 #if IS_ENABLED(CONFIG_IPV6)
 726         case AF_INET6:
 727                 ret_val = -ENOMSG;
 728                 break;
 729 #endif /* IPv6 */
 730         default:
 731                 ret_val = -EPROTONOSUPPORT;
 732         }
 733
 734         return ret_val;
 735 }
 736
 737 /**
 738  * netlbl_conn_setattr - Label a connected socket using the correct protocol
 739  * @sk: the socket to label
 740  * @addr: the destination address
 741  * @secattr: the security attributes
 742  *
 743  * Description:
 744  * Attach the correct label to the given connected socket using the security
 745  * attributes specified in @secattr.  The caller is responsible for ensuring
 746  * that @sk is locked.  Returns zero on success, negative values on failure.
 747  *
 748  */
 749 int netlbl_conn_setattr(struct sock *sk,
 750                         struct sockaddr *addr,
 751                         const struct netlbl_lsm_secattr *secattr)
 752 {
 753         int ret_val;
 754         struct sockaddr_in *addr4;
 755         struct netlbl_dommap_def *entry;
 756
 757         rcu_read_lock();
 758         switch (addr->sa_family) {
 759         case AF_INET:
 760                 addr4 = (struct sockaddr_in *)addr;
 761                 entry = netlbl_domhsh_getentry_af4(secattr->domain,
 762                                                    addr4->sin_addr.s_addr);
 763                 if (entry == NULL) {
 764                         ret_val = -ENOENT;
 765                         goto conn_setattr_return;
 766                 }
 767                 switch (entry->type) {
 768                 case NETLBL_NLTYPE_CIPSOV4:
 769                         ret_val = cipso_v4_sock_setattr(sk,
 770                                                         entry->cipso, secattr);
 771                         break;
 772                 case NETLBL_NLTYPE_UNLABELED:
 773                         /* just delete the protocols we support for right now
 774                          * but we could remove other protocols if needed */
 775                         cipso_v4_sock_delattr(sk);
 776                         ret_val = 0;
 777                         break;
 778                 default:
 779                         ret_val = -ENOENT;
 780                 }
 781                 break;
 782 #if IS_ENABLED(CONFIG_IPV6)
 783         case AF_INET6:
 784                 /* since we don't support any IPv6 labeling protocols right
 785                  * now we can optimize everything away until we do */
 786                 ret_val = 0;
 787                 break;
 788 #endif /* IPv6 */
 789         default:
 790                 ret_val = -EPROTONOSUPPORT;
 791         }
 792
 793 conn_setattr_return:
 794         rcu_read_unlock();
 795         return ret_val;
 796 }
 797
 798 /**
 799  * netlbl_req_setattr - Label a request socket using the correct protocol
 800  * @req: the request socket to label
 801  * @secattr: the security attributes
 802  *
 803  * Description:
 804  * Attach the correct label to the given socket using the security attributes
 805  * specified in @secattr.  Returns zero on success, negative values on failure.
 806  *
 807  */
 808 int netlbl_req_setattr(struct request_sock *req,
 809                        const struct netlbl_lsm_secattr *secattr)
 810 {
 811         int ret_val;
 812         struct netlbl_dommap_def *entry;
 813
 814         rcu_read_lock();
 815         switch (req->rsk_ops->family) {
 816         case AF_INET:
 817                 entry = netlbl_domhsh_getentry_af4(secattr->domain,
 818                                                    inet_rsk(req)->ir_rmt_addr);
 819                 if (entry == NULL) {
 820                         ret_val = -ENOENT;
 821                         goto req_setattr_return;
 822                 }
 823                 switch (entry->type) {
 824                 case NETLBL_NLTYPE_CIPSOV4:
 825                         ret_val = cipso_v4_req_setattr(req,
 826                                                        entry->cipso, secattr);
 827                         break;
 828                 case NETLBL_NLTYPE_UNLABELED:
 829                         /* just delete the protocols we support for right now
 830                          * but we could remove other protocols if needed */
 831                         cipso_v4_req_delattr(req);
 832                         ret_val = 0;
 833                         break;
 834                 default:
 835                         ret_val = -ENOENT;
 836                 }
 837                 break;
 838 #if IS_ENABLED(CONFIG_IPV6)
 839         case AF_INET6:
 840                 /* since we don't support any IPv6 labeling protocols right
 841                  * now we can optimize everything away until we do */
 842                 ret_val = 0;
 843                 break;
 844 #endif /* IPv6 */
 845         default:
 846                 ret_val = -EPROTONOSUPPORT;
 847         }
 848
 849 req_setattr_return:
 850         rcu_read_unlock();
 851         return ret_val;
 852 }
 853
 854 /**
 855 * netlbl_req_delattr - Delete all the NetLabel labels on a socket
 856 * @req: the socket
 857 *
 858 * Description:
 859 * Remove all the NetLabel labeling from @req.
 860 *
 861 */
 862 void netlbl_req_delattr(struct request_sock *req)
 863 {
 864         cipso_v4_req_delattr(req);
 865 }
 866
 867 /**
 868  * netlbl_skbuff_setattr - Label a packet using the correct protocol
 869  * @skb: the packet
 870  * @family: protocol family
 871  * @secattr: the security attributes
 872  *
 873  * Description:
 874  * Attach the correct label to the given packet using the security attributes
 875  * specified in @secattr.  Returns zero on success, negative values on failure.
 876  *
 877  */
 878 int netlbl_skbuff_setattr(struct sk_buff *skb,
 879                           u16 family,
 880                           const struct netlbl_lsm_secattr *secattr)
 881 {
 882         int ret_val;
 883         struct iphdr *hdr4;
 884         struct netlbl_dommap_def *entry;
 885
 886         rcu_read_lock();
 887         switch (family) {
 888         case AF_INET:
 889                 hdr4 = ip_hdr(skb);
 890                 entry = netlbl_domhsh_getentry_af4(secattr->domain,hdr4->daddr);
 891                 if (entry == NULL) {
 892                         ret_val = -ENOENT;
 893                         goto skbuff_setattr_return;
 894                 }
 895                 switch (entry->type) {
 896                 case NETLBL_NLTYPE_CIPSOV4:
 897                         ret_val = cipso_v4_skbuff_setattr(skb, entry->cipso,
 898                                                           secattr);
 899                         break;
 900                 case NETLBL_NLTYPE_UNLABELED:
 901                         /* just delete the protocols we support for right now
 902                          * but we could remove other protocols if needed */
 903                         ret_val = cipso_v4_skbuff_delattr(skb);
 904                         break;
 905                 default:
 906                         ret_val = -ENOENT;
 907                 }
 908                 break;
 909 #if IS_ENABLED(CONFIG_IPV6)
 910         case AF_INET6:
 911                 /* since we don't support any IPv6 labeling protocols right
 912                  * now we can optimize everything away until we do */
 913                 ret_val = 0;
 914                 break;
 915 #endif /* IPv6 */
 916         default:
 917                 ret_val = -EPROTONOSUPPORT;
 918         }
 919
 920 skbuff_setattr_return:
 921         rcu_read_unlock();
 922         return ret_val;
 923 }
 924
 925 /**
 926  * netlbl_skbuff_getattr - Determine the security attributes of a packet
 927  * @skb: the packet
 928  * @family: protocol family
 929  * @secattr: the security attributes
 930  *
 931  * Description:
 932  * Examines the given packet to see if a recognized form of packet labeling
 933  * is present, if so it parses the packet label and returns the security
 934  * attributes in @secattr.  Returns zero on success, negative values on
 935  * failure.
 936  *
 937  */
 938 int netlbl_skbuff_getattr(const struct sk_buff *skb,
 939                           u16 family,
 940                           struct netlbl_lsm_secattr *secattr)
 941 {
 942         switch (family) {
 943         case AF_INET:
 944                 if (CIPSO_V4_OPTEXIST(skb) &&
 945                     cipso_v4_skbuff_getattr(skb, secattr) == 0)
 946                         return 0;
 947                 break;
 948 #if IS_ENABLED(CONFIG_IPV6)
 949         case AF_INET6:
 950                 break;
 951 #endif /* IPv6 */
 952         }
 953
 954         return netlbl_unlabel_getattr(skb, family, secattr);
 955 }
 956
 957 /**
 958  * netlbl_skbuff_err - Handle a LSM error on a sk_buff
 959  * @skb: the packet
 960  * @error: the error code
 961  * @gateway: true if host is acting as a gateway, false otherwise
 962  *
 963  * Description:
 964  * Deal with a LSM problem when handling the packet in @skb, typically this is
 965  * a permission denied problem (-EACCES).  The correct action is determined
 966  * according to the packet's labeling protocol.
 967  *
 968  */
 969 void netlbl_skbuff_err(struct sk_buff *skb, int error, int gateway)
 970 {
 971         if (CIPSO_V4_OPTEXIST(skb))
 972                 cipso_v4_error(skb, error, gateway);
 973 }
 974
 975 /**
 976  * netlbl_cache_invalidate - Invalidate all of the NetLabel protocol caches
 977  *
 978  * Description:
 979  * For all of the NetLabel protocols that support some form of label mapping
 980  * cache, invalidate the cache.  Returns zero on success, negative values on
 981  * error.
 982  *
 983  */
 984 void netlbl_cache_invalidate(void)
 985 {
 986         cipso_v4_cache_invalidate();
 987 }
 988
 989 /**
 990  * netlbl_cache_add - Add an entry to a NetLabel protocol cache
 991  * @skb: the packet
 992  * @secattr: the packet's security attributes
 993  *
 994  * Description:
 995  * Add the LSM security attributes for the given packet to the underlying
 996  * NetLabel protocol's label mapping cache.  Returns zero on success, negative
 997  * values on error.
 998  *
 999  */
1000 int netlbl_cache_add(const struct sk_buff *skb,
1001                      const struct netlbl_lsm_secattr *secattr)
1002 {
1003         if ((secattr->flags & NETLBL_SECATTR_CACHE) == 0)
1004                 return -ENOMSG;
1005
1006         if (CIPSO_V4_OPTEXIST(skb))
1007                 return cipso_v4_cache_add(skb, secattr);
1008
1009         return -ENOMSG;
1010 }
1011
1012 /*
1013  * Protocol Engine Functions
1014  */
1015
1016 /**
1017  * netlbl_audit_start - Start an audit message
1018  * @type: audit message type
1019  * @audit_info: NetLabel audit information
1020  *
1021  * Description:
1022  * Start an audit message using the type specified in @type and fill the audit
1023  * message with some fields common to all NetLabel audit messages.  This
1024  * function should only be used by protocol engines, not LSMs.  Returns a
1025  * pointer to the audit buffer on success, NULL on failure.
1026  *
1027  */
1028 struct audit_buffer *netlbl_audit_start(int type,
1029                                         struct netlbl_audit *audit_info)
1030 {
1031         return netlbl_audit_start_common(type, audit_info);
1032 }
1033
1034 /*
1035  * Setup Functions
1036  */
1037
1038 /**
1039  * netlbl_init - Initialize NetLabel
1040  *
1041  * Description:
1042  * Perform the required NetLabel initialization before first use.
1043  *
1044  */
1045 static int __init netlbl_init(void)
1046 {
1047         int ret_val;
1048
1049         printk(KERN_INFO "NetLabel: Initializing\n");
1050         printk(KERN_INFO "NetLabel:  domain hash size = %u\n",
1051                (1 << NETLBL_DOMHSH_BITSIZE));
1052         printk(KERN_INFO "NetLabel:  protocols ="
1053                " UNLABELED"
1054                " CIPSOv4"
1055                "\n");
1056
1057         ret_val = netlbl_domhsh_init(NETLBL_DOMHSH_BITSIZE);
1058         if (ret_val != 0)
1059                 goto init_failure;
1060
1061         ret_val = netlbl_unlabel_init(NETLBL_UNLHSH_BITSIZE);
1062         if (ret_val != 0)
1063                 goto init_failure;
1064
1065         ret_val = netlbl_netlink_init();
1066         if (ret_val != 0)
1067                 goto init_failure;
1068
1069         ret_val = netlbl_unlabel_defconf();
1070         if (ret_val != 0)
1071                 goto init_failure;
1072         printk(KERN_INFO "NetLabel:  unlabeled traffic allowed by default\n");
1073
1074         return 0;
1075
1076 init_failure:
1077         panic("NetLabel: failed to initialize properly (%d)\n", ret_val);
1078 }
1079
1080 subsys_initcall(netlbl_init);