オープンソース・ソフトウェアの開発とダウンロード

TOMOYO

Subversion リポジトリの参照

/[tomoyo]/trunk/1.8.x/ccs-patch/security/ccsecurity/network.c

Diff of /trunk/1.8.x/ccs-patch/security/ccsecurity/network.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/ccs-patch/fs/ccsecurity/network.c revision 2853 by kumaneko, Wed Aug 5 11:43:05 2009 UTC trunk/1.8.x/ccs-patch/security/ccsecurity/network.c revision 3949 by kumaneko, Sun Sep 5 11:50:03 2010 UTC
# Line 1  Line 1 
1  /*  /*
2   * fs/ccsecurity/network.c   * security/ccsecurity/network.c
3   *   *
4   * Copyright (C) 2005-2009  NTT DATA CORPORATION   * Copyright (C) 2005-2010  NTT DATA CORPORATION
5   *   *
6   * Version: 1.7.0-pre   2009/07/03   * Version: 1.8.0-pre   2010/09/01
7   *   *
8   * This file is applicable to both 2.4.30 and 2.6.11 and later.   * This file is applicable to both 2.4.30 and 2.6.11 and later.
9   * See README.ccs for ChangeLog.   * See README.ccs for ChangeLog.
# Line 14  Line 14 
14  #include <linux/inet.h>  #include <linux/inet.h>
15  #include <linux/in.h>  #include <linux/in.h>
16  #include <linux/in6.h>  #include <linux/in6.h>
17    #include <linux/un.h>
18    #include <net/sock.h>
19    #include <net/af_unix.h>
20  #include <net/ip.h>  #include <net/ip.h>
21  #include <net/ipv6.h>  #include <net/ipv6.h>
22  #include <net/udp.h>  #include <net/udp.h>
23  #include "ccs_common.h"  #include "internal.h"
24  #include <linux/ccsecurity.h>  
25  #include <linux/ccsecurity_socket.h>  struct ccs_inet_addr_info {
26            u16 port;           /* In network byte order. */
27  /* Index numbers for Network Controls. */          const u32 *address; /* In network byte order. */
28  enum ccs_network_acl_index {          bool is_ipv6;
         NETWORK_ACL_UDP_BIND,  
         NETWORK_ACL_UDP_CONNECT,  
         NETWORK_ACL_TCP_BIND,  
         NETWORK_ACL_TCP_LISTEN,  
         NETWORK_ACL_TCP_CONNECT,  
         NETWORK_ACL_TCP_ACCEPT,  
         NETWORK_ACL_RAW_BIND,  
         NETWORK_ACL_RAW_CONNECT  
29  };  };
30    
31  /**  struct ccs_unix_addr_info {
32   * ccs_audit_network_log - Audit network log.          u8 *addr;
33   *          unsigned int addr_len;
34   * @r:          Pointer to "struct ccs_request_info".  };
  * @operation:  The name of operation.  
  * @address:    An IPv4 or IPv6 address.  
  * @port:       Port number.  
  * @is_granted: True if this is a granted log.  
  *  
  * Returns 0 on success, negative value otherwise.  
  */  
 static int ccs_audit_network_log(struct ccs_request_info *r,  
                                  const char *operation, const char *address,  
                                  const u16 port, const bool is_granted)  
 {  
         if (!is_granted && ccs_verbose_mode(r->domain))  
                 printk(KERN_WARNING "TOMOYO-%s: %s to %s %u denied for %s\n",  
                        ccs_get_msg(r->mode == 3), operation, address, port,  
                        ccs_get_last_name(r->domain));  
         return ccs_write_audit_log(is_granted, r, KEYWORD_ALLOW_NETWORK  
                                    "%s %s %u\n", operation, address, port);  
 }  
35    
36  /* The list for "struct ccs_address_group_entry". */  struct ccs_addr_info {
37  LIST_HEAD(ccs_address_group_list);          u8 protocol;
38            u8 operation;
39            struct ccs_inet_addr_info inet;
40            struct ccs_unix_addr_info unix0;
41    };
42    
43    const char *ccs_proto_keyword[CCS_SOCK_MAX] = {
44            [SOCK_STREAM]    = "stream",
45            [SOCK_DGRAM]     = "dgram",
46            [SOCK_RAW]       = "raw",
47            [SOCK_SEQPACKET] = "seqpacket",
48    };
49    
50    const char *ccs_socket_keyword[CCS_MAX_NETWORK_OPERATION] = {
51            [CCS_NETWORK_BIND]    = "bind",
52            [CCS_NETWORK_LISTEN]  = "listen",
53            [CCS_NETWORK_CONNECT] = "connect",
54            [CCS_NETWORK_ACCEPT]  = "accept",
55            [CCS_NETWORK_SEND]    = "send",
56            [CCS_NETWORK_RECV]    = "recv",
57    };
58    
59    static int ccs_audit_net_log(struct ccs_request_info *r, const char *family,
60                                 const u8 proto, const u8 ope, const char *address)
61    {
62            const char *protocol = ccs_proto_keyword[proto];
63            const char *operation = ccs_socket_keyword[ope];
64            ccs_write_log(r, "network %s %s %s %s\n", family,
65                          protocol, operation, address);
66            if (r->granted)
67                    return 0;
68            ccs_warn_log(r, "network %s %s %s %s", family, protocol, operation,
69                         address);
70            return ccs_supervisor(r, "network %s %s %s %s\n", family, protocol,
71                                  operation, address);
72    }
73    
74  /**  /**
75   * ccs_get_address_group - Allocate memory for "struct ccs_address_group_entry".   * ccs_audit_inet_log - Audit INET network log.
76   *   *
77   * @group_name: The name of address group.   * @r: Pointer to "struct ccs_request_info".
78   *   *
79   * Returns pointer to "struct ccs_address_group_entry" on success,   * Returns 0 on success, negative value otherwise.
  * NULL otherwise.  
80   */   */
81  static struct ccs_address_group_entry *ccs_get_address_group(const char *  static int ccs_audit_inet_log(struct ccs_request_info *r)
                                                              group_name)  
82  {  {
83          struct ccs_address_group_entry *entry = NULL;          char buf[128];
84          struct ccs_address_group_entry *group;          int len;
85          const struct ccs_path_info *saved_group_name;          const u32 *address = r->param.inet_network.address;
86          int error = -ENOMEM;          if (r->param.inet_network.is_ipv6)
87          if (!ccs_is_correct_path(group_name, 0, 0, 0) ||                  ccs_print_ipv6(buf, sizeof(buf), (const struct in6_addr *)
88              !group_name[0])                                 address, (const struct in6_addr *) address);
89                  return NULL;          else
90          saved_group_name = ccs_get_name(group_name);                  ccs_print_ipv4(buf, sizeof(buf), r->param.inet_network.ip,
91          if (!saved_group_name)                                 r->param.inet_network.ip);
92                  return NULL;          len = strlen(buf);
93          entry = kzalloc(sizeof(*entry), GFP_KERNEL);          snprintf(buf + len, sizeof(buf) - len, " %u",
94          mutex_lock(&ccs_policy_lock);                   r->param.inet_network.port);
95          list_for_each_entry_rcu(group, &ccs_address_group_list, list) {          return ccs_audit_net_log(r, "inet", r->param.inet_network.protocol,
96                  if (saved_group_name != group->group_name)                                   r->param.inet_network.operation, buf);
                         continue;  
                 atomic_inc(&group->users);  
                 error = 0;  
                 break;  
         }  
         if (error && ccs_memory_ok(entry, sizeof(*entry))) {  
                 INIT_LIST_HEAD(&entry->address_group_member_list);  
                 entry->group_name = saved_group_name;  
                 saved_group_name = NULL;  
                 atomic_set(&entry->users, 1);  
                 list_add_tail_rcu(&entry->list, &ccs_address_group_list);  
                 group = entry;  
                 entry = NULL;  
                 error = 0;  
         }  
         mutex_unlock(&ccs_policy_lock);  
         ccs_put_name(saved_group_name);  
         kfree(entry);  
         return !error ? group : NULL;  
97  }  }
98    
99  /**  /**
100   * ccs_update_address_group_entry - Update "struct ccs_address_group_entry" list.   * ccs_audit_unix_log - Audit UNIX network log.
101   *   *
102   * @group_name:  The name of address group.   * @r: Pointer to "struct ccs_request_info".
  * @is_ipv6:     True if @min_address and @max_address are IPv6 addresses.  
  * @min_address: Start of IPv4 or IPv6 address range.  
  * @max_address: End of IPv4 or IPv6 address range.  
  * @is_delete:   True if it is a delete request.  
103   *   *
104   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
105   */   */
106  static int ccs_update_address_group_entry(const char *group_name,  static int ccs_audit_unix_log(struct ccs_request_info *r)
107                                            const bool is_ipv6,  {
108                                            const u16 *min_address,          return ccs_audit_net_log(r, "unix", r->param.unix_network.protocol,
109                                            const u16 *max_address,                                   r->param.unix_network.operation,
110                                            const bool is_delete)                                   r->param.unix_network.address->name);
 {  
         struct ccs_address_group_entry *group;  
         struct ccs_address_group_member *entry = NULL;  
         struct ccs_address_group_member *member;  
         const struct in6_addr *saved_min_address = NULL;  
         const struct in6_addr *saved_max_address = NULL;  
         int error = is_delete ? -ENOENT : -ENOMEM;  
         const u32 min_ipv4_address = ntohl(*(u32 *) min_address);  
         const u32 max_ipv4_address = ntohl(*(u32 *) max_address);  
         group = ccs_get_address_group(group_name);  
         if (!group)  
                 return -ENOMEM;  
         if (is_ipv6) {  
                 saved_min_address  
                         = ccs_get_ipv6_address((struct in6_addr *)  
                                                min_address);  
                 saved_max_address  
                         = ccs_get_ipv6_address((struct in6_addr *)  
                                                max_address);  
                 if (!saved_min_address || !saved_max_address)  
                         goto out;  
         }  
         if (!is_delete)  
                 entry = kzalloc(sizeof(*entry), GFP_KERNEL);  
         mutex_lock(&ccs_policy_lock);  
         list_for_each_entry_rcu(member, &group->address_group_member_list,  
                                 list) {  
                 if (member->is_ipv6 != is_ipv6)  
                         continue;  
                 if (is_ipv6) {  
                         if (member->min.ipv6 != saved_min_address ||  
                             member->max.ipv6 != saved_max_address)  
                                 continue;  
                 } else {  
                         if (member->min.ipv4 != min_ipv4_address ||  
                             member->max.ipv4 != max_ipv4_address)  
                                 continue;  
                 }  
                 member->is_deleted = is_delete;  
                 error = 0;  
                 break;  
         }  
         if (!is_delete && error && ccs_memory_ok(entry, sizeof(*entry))) {  
                 entry->is_ipv6 = is_ipv6;  
                 if (is_ipv6) {  
                         entry->min.ipv6 = saved_min_address;  
                         saved_min_address = NULL;  
                         entry->max.ipv6 = saved_max_address;  
                         saved_max_address = NULL;  
                 } else {  
                         entry->min.ipv4 = min_ipv4_address;  
                         entry->max.ipv4 = max_ipv4_address;  
                 }  
                 list_add_tail_rcu(&entry->list,  
                                   &group->address_group_member_list);  
                 entry = NULL;  
                 error = 0;  
         }  
         mutex_unlock(&ccs_policy_lock);  
  out:  
         ccs_put_ipv6_address(saved_min_address);  
         ccs_put_ipv6_address(saved_max_address);  
         ccs_put_address_group(group);  
         return error;  
111  }  }
112    
113  /**  /**
# Line 194  static int ccs_update_address_group_entr Line 117  static int ccs_update_address_group_entr
117   * @min:     Pointer to store min address.   * @min:     Pointer to store min address.
118   * @max:     Pointer to store max address.   * @max:     Pointer to store max address.
119   *   *
120   * Returns 2 if @address is an IPv6, 1 if @address is an IPv4, 0 otherwise.   * Returns CCS_IP_ADDRESS_TYPE_IPv6 if @address is an IPv6,
121     * CCS_IP_ADDRESS_TYPE_IPv4 if @address is an IPv4,
122     * CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP otherwise.
123   */   */
124  static int ccs_parse_ip_address(char *address, u16 *min, u16 *max)  int ccs_parse_ip_address(char *address, u16 *min, u16 *max)
125  {  {
126          int count = sscanf(address, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx"          int count = sscanf(address, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx"
127                             "-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",                             "-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",
# Line 212  static int ccs_parse_ip_address(char *ad Line 137  static int ccs_parse_ip_address(char *ad
137                          min[i] = htons(min[i]);                          min[i] = htons(min[i]);
138                          max[i] = htons(max[i]);                          max[i] = htons(max[i]);
139                  }                  }
140                  return 2;                  return CCS_IP_ADDRESS_TYPE_IPv6;
141          }          }
142          count = sscanf(address, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",          count = sscanf(address, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",
143                         &min[0], &min[1], &min[2], &min[3],                         &min[0], &min[1], &min[2], &min[3],
# Line 222  static int ccs_parse_ip_address(char *ad Line 147  static int ccs_parse_ip_address(char *ad
147                                 + (((u8) min[2]) << 8) + (u8) min[3]);                                 + (((u8) min[2]) << 8) + (u8) min[3]);
148                  memmove(min, &ip, sizeof(ip));                  memmove(min, &ip, sizeof(ip));
149                  if (count == 8)                  if (count == 8)
150                          ip = htonl((((u8) max[0]) << 24) + (((u8) max[1]) << 16)                          ip = htonl((((u8) max[0]) << 24)
151                                       + (((u8) max[1]) << 16)
152                                     + (((u8) max[2]) << 8) + (u8) max[3]);                                     + (((u8) max[2]) << 8) + (u8) max[3]);
153                  memmove(max, &ip, sizeof(ip));                  memmove(max, &ip, sizeof(ip));
154                  return 1;                  return CCS_IP_ADDRESS_TYPE_IPv4;
         }  
         return 0;  
 }  
   
 /**  
  * ccs_write_address_group_policy - Write "struct ccs_address_group_entry" list.  
  *  
  * @data:      String to parse.  
  * @is_delete: True if it is a delete request.  
  *  
  * Returns 0 on success, negative value otherwise.  
  */  
 int ccs_write_address_group_policy(char *data, const bool is_delete)  
 {  
         char *w[2];  
         bool is_ipv6;  
         u16 min_address[8];  
         u16 max_address[8];  
         if (!ccs_tokenize(data, w, sizeof(w)) || !w[1][0])  
                 return -EINVAL;  
         switch (ccs_parse_ip_address(w[1], min_address, max_address)) {  
         case 2:  
                 is_ipv6 = true;  
                 break;  
         case 1:  
                 is_ipv6 = false;  
                 break;  
         default:  
                 return -EINVAL;  
155          }          }
156          return ccs_update_address_group_entry(w[0], is_ipv6, min_address,          return CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP;
                                               max_address, is_delete);  
157  }  }
158    
159  /**  /**
160   * ccs_address_matches_group - Check whether the given address matches members of the given address group.   * ccs_print_ipv4 - Print an IPv4 address.
161   *   *
162   * @is_ipv6: True if @address is an IPv6 address.   * @buffer:     Buffer to write to.
163   * @address: An IPv4 or IPv6 address.   * @buffer_len: Size of @buffer.
164   * @group:   Pointer to "struct ccs_address_group_entry".   * @min_ip:     Min address in host byte order.
165   *   * @max_ip:     Max address in host byte order.
  * Returns true if @address matches addresses in @group group, false otherwise.  
  *  
  * Caller holds ccs_read_lock().  
  */  
 static bool ccs_address_matches_group(const bool is_ipv6, const u32 *address,  
                                       const struct ccs_address_group_entry *  
                                       group)  
 {  
         struct ccs_address_group_member *member;  
         const u32 ip = ntohl(*address);  
         bool matched = false;  
         ccs_check_read_lock();  
         list_for_each_entry_rcu(member, &group->address_group_member_list,  
                                 list) {  
                 if (member->is_deleted)  
                         continue;  
                 if (member->is_ipv6) {  
                         if (is_ipv6 &&  
                             memcmp(member->min.ipv6, address, 16) <= 0 &&  
                             memcmp(address, member->max.ipv6, 16) <= 0) {  
                                 matched = true;  
                                 break;  
                         }  
                 } else {  
                         if (!is_ipv6 &&  
                             member->min.ipv4 <= ip && ip <= member->max.ipv4) {  
                                 matched = true;  
                                 break;  
                         }  
                 }  
         }  
         return matched;  
 }  
   
 /**  
  * ccs_read_address_group_policy - Read "struct ccs_address_group_entry" list.  
  *  
  * @head: Pointer to "struct ccs_io_buffer".  
  *  
  * Returns true on success, false otherwise.  
166   *   *
167   * Caller holds ccs_read_lock().   * Returns nothing.
168   */   */
169  bool ccs_read_address_group_policy(struct ccs_io_buffer *head)  void ccs_print_ipv4(char *buffer, const int buffer_len,
170                        const u32 min_ip, const u32 max_ip)
171  {  {
172          struct list_head *gpos;          memset(buffer, 0, buffer_len);
173          struct list_head *mpos;          snprintf(buffer, buffer_len - 1, "%u.%u.%u.%u%c%u.%u.%u.%u",
174          bool done = true;                   HIPQUAD(min_ip), min_ip == max_ip ? '\0' : '-',
175          ccs_check_read_lock();                   HIPQUAD(max_ip));
         list_for_each_cookie(gpos, head->read_var1, &ccs_address_group_list) {  
                 struct ccs_address_group_entry *group;  
                 group = list_entry(gpos, struct ccs_address_group_entry, list);  
                 list_for_each_cookie(mpos, head->read_var2,  
                                      &group->address_group_member_list) {  
                         char buf[128];  
                         struct ccs_address_group_member *member;  
                         member = list_entry(mpos,  
                                              struct ccs_address_group_member,  
                                              list);  
                         if (member->is_deleted)  
                                 continue;  
                         if (member->is_ipv6) {  
                                 const struct in6_addr *min_address  
                                         = member->min.ipv6;  
                                 const struct in6_addr *max_address  
                                         = member->max.ipv6;  
                                 ccs_print_ipv6(buf, sizeof(buf), min_address);  
                                 if (min_address != max_address) {  
                                         int len;  
                                         char *cp = buf + strlen(buf);  
                                         *cp++ = '-';  
                                         len = strlen(buf);  
                                         ccs_print_ipv6(cp, sizeof(buf) - len,  
                                                        max_address);  
                                 }  
                         } else {  
                                 const u32 min_address = member->min.ipv4;  
                                 const u32 max_address = member->max.ipv4;  
                                 memset(buf, 0, sizeof(buf));  
                                 snprintf(buf, sizeof(buf) - 1, "%u.%u.%u.%u",  
                                          HIPQUAD(min_address));  
                                 if (min_address != max_address) {  
                                         const int len = strlen(buf);  
                                         snprintf(buf + len,  
                                                  sizeof(buf) - 1 - len,  
                                                  "-%u.%u.%u.%u",  
                                                  HIPQUAD(max_address));  
                                 }  
                         }  
                         done = ccs_io_printf(head, KEYWORD_ADDRESS_GROUP  
                                              "%s %s\n", group->group_name->name,  
                                              buf);  
                         if (!done)  
                                 break;  
                 }  
                 if (!done)  
                         break;  
         }  
         return done;  
176  }  }
177    
178  #if !defined(NIP6)  #if !defined(NIP6)
179  #define NIP6(addr)      \  #define NIP6(addr)                                                      \
180          ntohs((addr).s6_addr16[0]), ntohs((addr).s6_addr16[1]), \          ntohs((addr).s6_addr16[0]), ntohs((addr).s6_addr16[1]),         \
181          ntohs((addr).s6_addr16[2]), ntohs((addr).s6_addr16[3]), \                  ntohs((addr).s6_addr16[2]), ntohs((addr).s6_addr16[3]), \
182          ntohs((addr).s6_addr16[4]), ntohs((addr).s6_addr16[5]), \                  ntohs((addr).s6_addr16[4]), ntohs((addr).s6_addr16[5]), \
183          ntohs((addr).s6_addr16[6]), ntohs((addr).s6_addr16[7])                  ntohs((addr).s6_addr16[6]), ntohs((addr).s6_addr16[7])
184  #endif  #endif
185    
186  /**  /**
# Line 381  bool ccs_read_address_group_policy(struc Line 188  bool ccs_read_address_group_policy(struc
188   *   *
189   * @buffer:     Buffer to write to.   * @buffer:     Buffer to write to.
190   * @buffer_len: Size of @buffer.   * @buffer_len: Size of @buffer.
191   * @ip:         Pointer to "struct in6_addr".   * @min_ip:     Pointer to "struct in6_addr".
192     * @max_ip:     Pointer to "struct in6_addr".
193   *   *
194   * Returns nothing.   * Returns nothing.
195   */   */
196  void ccs_print_ipv6(char *buffer, const int buffer_len,  void ccs_print_ipv6(char *buffer, const int buffer_len,
197                      const struct in6_addr *ip)                      const struct in6_addr *min_ip,
198                        const struct in6_addr *max_ip)
199  {  {
200          memset(buffer, 0, buffer_len);          memset(buffer, 0, buffer_len);
201          snprintf(buffer, buffer_len - 1, "%x:%x:%x:%x:%x:%x:%x:%x", NIP6(*ip));          snprintf(buffer, buffer_len - 1,
202  }                   "%x:%x:%x:%x:%x:%x:%x:%x%c%x:%x:%x:%x:%x:%x:%x:%x",
203                     NIP6(*min_ip), min_ip == max_ip ? '\0' : '-',
204  /**                   NIP6(*max_ip));
205   * ccs_net2keyword - Convert network operation index to network operation name.  }
206   *  
207   * @operation: Type of operation.  static bool ccs_check_inet_acl(struct ccs_request_info *r,
208   *                                 const struct ccs_acl_info *ptr)
209   * Returns the name of operation.  {
210   */          const struct ccs_inet_acl *acl = container_of(ptr, typeof(*acl), head);
211  const char *ccs_net2keyword(const u8 operation)          bool ret;
212  {          if (!(acl->perm & (1 << r->param.inet_network.operation)) ||
213          const char *keyword = "unknown";              !ccs_compare_number_union(r->param.inet_network.port, &acl->port))
214          switch (operation) {                  return false;
215          case NETWORK_ACL_UDP_BIND:          switch (acl->address_type) {
216                  keyword = "UDP bind";          case CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP:
217                  break;                  ret = ccs_address_matches_group(r->param.inet_network.is_ipv6,
218          case NETWORK_ACL_UDP_CONNECT:                                                  r->param.inet_network.address,
219                  keyword = "UDP connect";                                                  acl->address.group);
220                  break;                  break;
221          case NETWORK_ACL_TCP_BIND:          case CCS_IP_ADDRESS_TYPE_IPv4:
222                  keyword = "TCP bind";                  ret = !r->param.inet_network.is_ipv6 &&
223                  break;                          acl->address.ipv4.min <= r->param.inet_network.ip &&
224          case NETWORK_ACL_TCP_LISTEN:                          r->param.inet_network.ip <= acl->address.ipv4.max;
                 keyword = "TCP listen";  
                 break;  
         case NETWORK_ACL_TCP_CONNECT:  
                 keyword = "TCP connect";  
                 break;  
         case NETWORK_ACL_TCP_ACCEPT:  
                 keyword = "TCP accept";  
225                  break;                  break;
226          case NETWORK_ACL_RAW_BIND:          default:
227                  keyword = "RAW bind";                  ret = r->param.inet_network.is_ipv6 &&
228                  break;                          memcmp(acl->address.ipv6.min,
229          case NETWORK_ACL_RAW_CONNECT:                                 r->param.inet_network.address, 16) <= 0 &&
230                  keyword = "RAW connect";                          memcmp(r->param.inet_network.address,
231                  break;                                 acl->address.ipv6.max, 16) <= 0;
232          }                  break;
233          return keyword;          }
234  }          return ret;
235    }
236    
237    static bool ccs_check_unix_acl(struct ccs_request_info *r,
238                                   const struct ccs_acl_info *ptr)
239    {
240            const struct ccs_unix_acl *acl = container_of(ptr, typeof(*acl), head);
241            return (acl->perm & (1 << r->param.unix_network.operation)) &&
242                    ccs_compare_name_union(r->param.unix_network.address,
243                                           &acl->name);
244    }
245    
246    static const u8
247    ccs_inet2mac[CCS_SOCK_MAX][CCS_MAX_NETWORK_OPERATION] = {
248            [SOCK_STREAM] = {
249                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_INET_STREAM_BIND,
250                    [CCS_NETWORK_LISTEN]  = CCS_MAC_NETWORK_INET_STREAM_LISTEN,
251                    [CCS_NETWORK_CONNECT] = CCS_MAC_NETWORK_INET_STREAM_CONNECT,
252                    [CCS_NETWORK_ACCEPT]  = CCS_MAC_NETWORK_INET_STREAM_ACCEPT,
253            },
254            [SOCK_DGRAM] = {
255                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_INET_DGRAM_BIND,
256                    [CCS_NETWORK_SEND]    = CCS_MAC_NETWORK_INET_DGRAM_SEND,
257                    [CCS_NETWORK_RECV]    = CCS_MAC_NETWORK_INET_DGRAM_RECV,
258            },
259            [SOCK_RAW]    = {
260                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_INET_RAW_BIND,
261                    [CCS_NETWORK_SEND]    = CCS_MAC_NETWORK_INET_RAW_SEND,
262                    [CCS_NETWORK_RECV]    = CCS_MAC_NETWORK_INET_RAW_RECV,
263            },
264    };
265    
266  /**  static const u8
267   * ccs_update_network_entry - Update "struct ccs_ip_network_acl_record" list.  ccs_unix2mac[CCS_SOCK_MAX][CCS_MAX_NETWORK_OPERATION] = {
268   *          [SOCK_STREAM] = {
269   * @operation:   Type of operation.                  [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_UNIX_STREAM_BIND,
270   * @record_type: Type of address.                  [CCS_NETWORK_LISTEN]  = CCS_MAC_NETWORK_UNIX_STREAM_LISTEN,
271   * @group:       Name of group. May be NULL.                  [CCS_NETWORK_CONNECT] = CCS_MAC_NETWORK_UNIX_STREAM_CONNECT,
272   * @min_address: Start of IPv4 or IPv6 address range.                  [CCS_NETWORK_ACCEPT]  = CCS_MAC_NETWORK_UNIX_STREAM_ACCEPT,
273   * @max_address: End of IPv4 or IPv6 address range.          },
274   * @min_port:    Start of port number range.          [SOCK_DGRAM] = {
275   * @max_port:    End of port number range.                  [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_UNIX_DGRAM_BIND,
276   * @domain:      Pointer to "struct ccs_domain_info".                  [CCS_NETWORK_SEND]    = CCS_MAC_NETWORK_UNIX_DGRAM_SEND,
277   * @condition:   Pointer to "struct ccs_condition". May be NULL.                  [CCS_NETWORK_RECV]    = CCS_MAC_NETWORK_UNIX_DGRAM_RECV,
278   * @is_delete:   True if it is a delete request.          },
279   *          [SOCK_SEQPACKET] = {
280   * Returns 0 on success, negative value otherwise.                  [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_UNIX_SEQPACKET_BIND,
281   */                  [CCS_NETWORK_LISTEN]  = CCS_MAC_NETWORK_UNIX_SEQPACKET_LISTEN,
282  static int ccs_update_network_entry(const u8 operation, const u8 record_type,                  [CCS_NETWORK_CONNECT] = CCS_MAC_NETWORK_UNIX_SEQPACKET_CONNECT,
283                                      const char *group_name,                  [CCS_NETWORK_ACCEPT]  = CCS_MAC_NETWORK_UNIX_SEQPACKET_ACCEPT,
284                                      const u32 *min_address,          },
285                                      const u32 *max_address,  };
                                     const u16 min_port, const u16 max_port,  
                                     struct ccs_domain_info *domain,  
                                     struct ccs_condition *condition,  
                                     const bool is_delete)  
 {  
         struct ccs_ip_network_acl_record *entry = NULL;  
         struct ccs_acl_info *ptr;  
         int error = is_delete ? -ENOENT : -ENOMEM;  
         /* using host byte order to allow u32 comparison than memcmp().*/  
         const u32 min_ip = ntohl(*min_address);  
         const u32 max_ip = ntohl(*max_address);  
         const struct in6_addr *saved_min_address = NULL;  
         const struct in6_addr *saved_max_address = NULL;  
         struct ccs_address_group_entry *group = NULL;  
         if (!domain)  
                 return -EINVAL;  
         if (group_name) {  
                 group = ccs_get_address_group(group_name);  
                 if (!group)  
                         return -ENOMEM;  
         } else if (record_type == IP_RECORD_TYPE_IPv6) {  
                 saved_min_address = ccs_get_ipv6_address((struct in6_addr *)  
                                                          min_address);  
                 saved_max_address = ccs_get_ipv6_address((struct in6_addr *)  
                                                          max_address);  
                 if (!saved_min_address || !saved_max_address)  
                         goto out;  
         }  
         if (is_delete)  
                 goto delete;  
         entry = kzalloc(sizeof(*entry), GFP_KERNEL);  
         mutex_lock(&ccs_policy_lock);  
         list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {  
                 struct ccs_ip_network_acl_record *acl;  
                 if (ccs_acl_type1(ptr) != TYPE_IP_NETWORK_ACL)  
                         continue;  
                 if (ptr->cond != condition)  
                         continue;  
                 acl = container_of(ptr, struct ccs_ip_network_acl_record, head);  
                 if (acl->operation_type != operation ||  
                     acl->record_type != record_type ||  
                     acl->min_port != min_port || max_port != acl->max_port)  
                         continue;  
                 if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {  
                         if (acl->u.group != group)  
                                 continue;  
                 } else if (record_type == IP_RECORD_TYPE_IPv4) {  
                         if (acl->u.ipv4.min != min_ip ||  
                             max_ip != acl->u.ipv4.max)  
                                 continue;  
                 } else if (record_type == IP_RECORD_TYPE_IPv6) {  
                         if (acl->u.ipv6.min != saved_min_address ||  
                             saved_max_address != acl->u.ipv6.max)  
                                 continue;  
                 }  
                 error = ccs_add_domain_acl(NULL, ptr);  
                 break;  
         }  
         if (error && ccs_memory_ok(entry, sizeof(*entry))) {  
                 entry->head.type = TYPE_IP_NETWORK_ACL;  
                 entry->head.cond = condition;  
                 entry->operation_type = operation;  
                 entry->record_type = record_type;  
                 if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {  
                         entry->u.group = group;  
                         group = NULL;  
                 } else if (record_type == IP_RECORD_TYPE_IPv4) {  
                         entry->u.ipv4.min = min_ip;  
                         entry->u.ipv4.max = max_ip;  
                 } else {  
                         entry->u.ipv6.min = saved_min_address;  
                         saved_min_address = NULL;  
                         entry->u.ipv6.max = saved_max_address;  
                         saved_max_address = NULL;  
                 }  
                 entry->min_port = min_port;  
                 entry->max_port = max_port;  
                 error = ccs_add_domain_acl(domain, &entry->head);  
                 entry = NULL;  
         }  
         mutex_unlock(&ccs_policy_lock);  
         goto out;  
  delete:  
         mutex_lock(&ccs_policy_lock);  
         list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {  
                 struct ccs_ip_network_acl_record *acl;  
                 if (ccs_acl_type2(ptr) != TYPE_IP_NETWORK_ACL)  
                         continue;  
                 if (ptr->cond != condition)  
                         continue;  
                 acl = container_of(ptr, struct ccs_ip_network_acl_record, head);  
                 if (acl->operation_type != operation ||  
                     acl->record_type != record_type ||  
                     acl->min_port != min_port || max_port != acl->max_port)  
                         continue;  
                 if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {  
                         if (acl->u.group != group)  
                                 continue;  
                 } else if (record_type == IP_RECORD_TYPE_IPv4) {  
                         if (acl->u.ipv4.min != min_ip ||  
                             max_ip != acl->u.ipv4.max)  
                                 continue;  
                 } else if (record_type == IP_RECORD_TYPE_IPv6) {  
                         if (acl->u.ipv6.min != saved_min_address ||  
                             saved_max_address != acl->u.ipv6.max)  
                                 continue;  
                 }  
                 error = ccs_del_domain_acl(ptr);  
                 break;  
         }  
         mutex_unlock(&ccs_policy_lock);  
  out:  
         ccs_put_ipv6_address(saved_min_address);  
         ccs_put_ipv6_address(saved_max_address);  
         ccs_put_address_group(group);  
         kfree(entry);  
         return error;  
 }  
286    
287  /**  static bool ccs_same_inet_acl(const struct ccs_acl_info *a,
288   * ccs_check_network_entry2 - Check permission for network operation.                                        const struct ccs_acl_info *b)
  *  
  * @is_ipv6:   True if @address is an IPv6 address.  
  * @operation: Type of operation.  
  * @address:   An IPv4 or IPv6 address.  
  * @port:      Port number.  
  *  
  * Returns 0 on success, negative value otherwise.  
  *  
  * Caller holds ccs_read_lock().  
  */  
 static int ccs_check_network_entry2(const bool is_ipv6, const u8 operation,  
                                     const u32 *address, const u16 port)  
289  {  {
290          struct ccs_request_info r;          const struct ccs_inet_acl *p1 = container_of(a, typeof(*p1), head);
291          struct ccs_acl_info *ptr;          const struct ccs_inet_acl *p2 = container_of(b, typeof(*p2), head);
292          const char *keyword = ccs_net2keyword(operation);          return p1->protocol == p2->protocol &&
293          bool is_enforce;                  p1->address_type == p2->address_type &&
294          /* using host byte order to allow u32 comparison than memcmp().*/                  p1->address.ipv4.min == p2->address.ipv4.min &&
295          const u32 ip = ntohl(*address);                  p1->address.ipv6.min == p2->address.ipv6.min &&
296          bool found = false;                  p1->address.ipv4.max == p2->address.ipv4.max &&
297          char buf[64];                  p1->address.ipv6.max == p2->address.ipv6.max &&
298          ccs_check_read_lock();                  p1->address.group == p2->address.group &&
299          if (!ccs_can_sleep())                  ccs_same_number_union(&p1->port, &p2->port);
300                  return 0;  }
301          ccs_init_request_info(&r, NULL, CCS_MAC_FOR_NETWORK);  
302          is_enforce = (r.mode == 3);  static bool ccs_same_unix_acl(const struct ccs_acl_info *a,
303          if (!r.mode)                                        const struct ccs_acl_info *b)
304                  return 0;  {
305   retry:          const struct ccs_unix_acl *p1 = container_of(a, typeof(*p1), head);
306          list_for_each_entry_rcu(ptr, &r.domain->acl_info_list, list) {          const struct ccs_unix_acl *p2 = container_of(b, typeof(*p2), head);
307                  struct ccs_ip_network_acl_record *acl;          return p1->protocol == p2->protocol &&
308                  if (ccs_acl_type2(ptr) != TYPE_IP_NETWORK_ACL)                  ccs_same_name_union(&p1->name, &p2->name);
309                          continue;  }
310                  acl = container_of(ptr, struct ccs_ip_network_acl_record, head);  
311                  if (acl->operation_type != operation || port < acl->min_port ||  static bool ccs_merge_inet_acl(struct ccs_acl_info *a, struct ccs_acl_info *b,
312                      acl->max_port < port || !ccs_check_condition(&r, ptr))                                 const bool is_delete)
313                          continue;  {
314                  if (acl->record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {          u8 * const a_perm = &container_of(a, struct ccs_inet_acl, head)->perm;
315                          if (!ccs_address_matches_group(is_ipv6, address,          u8 perm = *a_perm;
316                                                         acl->u.group))          const u8 b_perm = container_of(b, struct ccs_inet_acl, head)->perm;
317                                  continue;          if (is_delete)
318                  } else if (acl->record_type == IP_RECORD_TYPE_IPv4) {                  perm &= ~b_perm;
                         if (is_ipv6 ||  
                             ip < acl->u.ipv4.min || acl->u.ipv4.max < ip)  
                                 continue;  
                 } else {  
                         if (!is_ipv6 ||  
                             memcmp(acl->u.ipv6.min, address, 16) > 0 ||  
                             memcmp(address, acl->u.ipv6.max, 16) > 0)  
                                 continue;  
                 }  
                 r.cond = ptr->cond;  
                 found = true;  
                 break;  
         }  
         memset(buf, 0, sizeof(buf));  
         if (is_ipv6)  
                 ccs_print_ipv6(buf, sizeof(buf),  
                                (const struct in6_addr *) address);  
319          else          else
320                  snprintf(buf, sizeof(buf) - 1, "%u.%u.%u.%u", HIPQUAD(ip));                  perm |= b_perm;
321          ccs_audit_network_log(&r, keyword, buf, port, found);          *a_perm = perm;
322          if (found)          return !perm;
                 return 0;  
         if (is_enforce) {  
                 int err = ccs_check_supervisor(&r, KEYWORD_ALLOW_NETWORK  
                                                "%s %s %u\n", keyword, buf,  
                                                port);  
                 if (err == 1)  
                         goto retry;  
                 return err;  
         } else if (ccs_domain_quota_ok(&r)) {  
                 struct ccs_condition *cond = ccs_handler_cond();  
                 ccs_update_network_entry(operation, is_ipv6 ?  
                                          IP_RECORD_TYPE_IPv6 :  
                                          IP_RECORD_TYPE_IPv4,  
                                          NULL, address, address, port, port,  
                                          r.domain, cond, false);  
                 ccs_put_condition(cond);  
         }  
         return 0;  
323  }  }
324    
325  /**  static bool ccs_merge_unix_acl(struct ccs_acl_info *a, struct ccs_acl_info *b,
326   * ccs_check_network_entry - Check permission for network operation.                                 const bool is_delete)
  *  
  * @is_ipv6:   True if @address is an IPv6 address.  
  * @operation: Type of operation.  
  * @address:   An IPv4 or IPv6 address.  
  * @port:      Port number.  
  *  
  * Returns 0 on success, negative value otherwise.  
  */  
 static int ccs_check_network_entry(const bool is_ipv6, const u8 operation,  
                                    const u32 *address, const u16 port)  
327  {  {
328          const int idx = ccs_read_lock();          u8 * const a_perm = &container_of(a, struct ccs_unix_acl, head)->perm;
329          const int error = ccs_check_network_entry2(is_ipv6, operation,          u8 perm = *a_perm;
330                                                     address, port);          const u8 b_perm = container_of(b, struct ccs_unix_acl, head)->perm;
331          ccs_read_unlock(idx);          if (is_delete)
332          return error;                  perm &= ~b_perm;
333            else
334                    perm |= b_perm;
335            *a_perm = perm;
336            return !perm;
337  }  }
338    
339  /**  /**
340   * ccs_write_network_policy - Write "struct ccs_ip_network_acl_record" list.   * ccs_write_inet_network - Write "struct ccs_inet_acl" list.
341   *   *
342   * @data:      String to parse.   * @data:  String to parse.
343   * @domain:    Pointer to "struct ccs_domain_info".   * @param: Pointer to "struct ccs_acl_param".
  * @condition: Pointer to "struct ccs_condition". May be NULL.  
  * @is_delete: True if it is a delete request.  
344   *   *
345   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
346   */   */
347  int ccs_write_network_policy(char *data, struct ccs_domain_info *domain,  int ccs_write_inet_network(char *data, struct ccs_acl_param *param)
                              struct ccs_condition *condition,  
                              const bool is_delete)  
348  {  {
349          char *w[4];          struct ccs_inet_acl e = { .head.type = CCS_TYPE_INET_ACL };
         u8 sock_type;  
         u8 operation;  
         u8 record_type;  
350          u16 min_address[8];          u16 min_address[8];
351          u16 max_address[8];          u16 max_address[8];
352          const char *group_name = NULL;          int error = -EINVAL;
353          u16 min_port;          u8 type;
354          u16 max_port;          if (!ccs_tokenize(data, param->w, sizeof(param->w)) || !param->w[3][0])
355          u8 count;                  return -EINVAL;
356          if (!ccs_tokenize(data, w, sizeof(w)) || !w[3][0])          for (e.protocol = 0; e.protocol < CCS_SOCK_MAX; e.protocol++)
357                  return -EINVAL;                  if (!strcmp(param->w[0], ccs_proto_keyword[e.protocol]))
         if (!strcmp(w[0], "TCP"))  
                 sock_type = SOCK_STREAM;  
         else if (!strcmp(w[0], "UDP"))  
                 sock_type = SOCK_DGRAM;  
         else if (!strcmp(w[0], "RAW"))  
                 sock_type = SOCK_RAW;  
         else  
                 goto out;  
         if (!strcmp(w[1], "bind"))  
                 switch (sock_type) {  
                 case SOCK_STREAM:  
                         operation = NETWORK_ACL_TCP_BIND;  
                         break;  
                 case SOCK_DGRAM:  
                         operation = NETWORK_ACL_UDP_BIND;  
                         break;  
                 default:  
                         operation = NETWORK_ACL_RAW_BIND;  
                 }  
         else if (!strcmp(w[1], "connect"))  
                 switch (sock_type) {  
                 case SOCK_STREAM:  
                         operation = NETWORK_ACL_TCP_CONNECT;  
                         break;  
                 case SOCK_DGRAM:  
                         operation = NETWORK_ACL_UDP_CONNECT;  
358                          break;                          break;
359                  default:          for (type = 0; type < CCS_MAX_NETWORK_OPERATION; type++)
360                          operation = NETWORK_ACL_RAW_CONNECT;                  if (ccs_permstr(param->w[1], ccs_socket_keyword[type]))
361                  }                          e.perm |= 1 << type;
362          else if (sock_type == SOCK_STREAM && !strcmp(w[1], "listen"))          if (e.protocol == CCS_SOCK_MAX || !e.perm)
363                  operation = NETWORK_ACL_TCP_LISTEN;                  return -EINVAL;
364          else if (sock_type == SOCK_STREAM && !strcmp(w[1], "accept"))          switch (ccs_parse_ip_address(param->w[2], min_address, max_address)) {
365                  operation = NETWORK_ACL_TCP_ACCEPT;          case CCS_IP_ADDRESS_TYPE_IPv6:
366          else                  e.address_type = CCS_IP_ADDRESS_TYPE_IPv6;
367                  goto out;                  e.address.ipv6.min = ccs_get_ipv6_address((struct in6_addr *)
368          switch (ccs_parse_ip_address(w[2], min_address, max_address)) {                                                              min_address);
369          case 2:                  e.address.ipv6.max = ccs_get_ipv6_address((struct in6_addr *)
370                  record_type = IP_RECORD_TYPE_IPv6;                                                              max_address);
371                    if (!e.address.ipv6.min || !e.address.ipv6.max)
372                            goto out;
373                  break;                  break;
374          case 1:          case CCS_IP_ADDRESS_TYPE_IPv4:
375                  record_type = IP_RECORD_TYPE_IPv4;                  e.address_type = CCS_IP_ADDRESS_TYPE_IPv4;
376                    /* use host byte order to allow u32 comparison.*/
377                    e.address.ipv4.min = ntohl(*(u32 *) min_address);
378                    e.address.ipv4.max = ntohl(*(u32 *) max_address);
379                  break;                  break;
380          default:          default:
381                  if (w[2][0] != '@')                  if (param->w[2][0] != '@')
382                          goto out;                          return -EINVAL;
383                  group_name = w[2] + 1;                  e.address_type = CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP;
384                  record_type = IP_RECORD_TYPE_ADDRESS_GROUP;                  e.address.group = ccs_get_group(param->w[2] + 1,
385                                                    CCS_ADDRESS_GROUP);
386                    if (!e.address.group)
387                            return -ENOMEM;
388                  break;                  break;
389          }          }
390          count = sscanf(w[3], "%hu-%hu", &min_port, &max_port);          if (!ccs_parse_number_union(param->w[3], &e.port))
         if (count != 1 && count != 2)  
391                  goto out;                  goto out;
392          if (count == 1)          error = ccs_update_domain(&e.head, sizeof(e), param, ccs_same_inet_acl,
393                  max_port = min_port;                                    ccs_merge_inet_acl);
         return ccs_update_network_entry(operation, record_type, group_name,  
                                         (u32 *) min_address,  
                                         (u32 *) max_address,  
                                         min_port, max_port, domain, condition,  
                                         is_delete);  
394   out:   out:
395          return -EINVAL;          if (e.address_type == CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP)
396                    ccs_put_group(e.address.group);
397            else if (e.address_type == CCS_IP_ADDRESS_TYPE_IPv6) {
398                    ccs_put_ipv6_address(e.address.ipv6.min);
399                    ccs_put_ipv6_address(e.address.ipv6.max);
400            }
401            ccs_put_number_union(&e.port);
402            return error;
403  }  }
404    
405  /**  /**
406   * ccs_check_network_listen_acl - Check permission for listen() operation.   * ccs_write_unix_network - Write "struct ccs_unix_acl" list.
407   *   *
408   * @is_ipv6: True if @address is an IPv6 address.   * @data:  String to parse.
409   * @address: An IPv4 or IPv6 address.   * @param: Pointer to "struct ccs_acl_param".
  * @port:    Port number.  
410   *   *
411   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
412   */   */
413  static inline int ccs_check_network_listen_acl(const bool is_ipv6,  int ccs_write_unix_network(char *data, struct ccs_acl_param *param)
414                                                 const u8 *address,  {
415                                                 const u16 port)          struct ccs_unix_acl e = { .head.type = CCS_TYPE_UNIX_ACL };
416            int error;
417            u8 type;
418            if (!ccs_tokenize(data, param->w, sizeof(param->w)) || !param->w[2][0])
419                    return -EINVAL;
420            for (e.protocol = 0; e.protocol < CCS_SOCK_MAX; e.protocol++)
421                    if (!strcmp(param->w[0], ccs_proto_keyword[e.protocol]))
422                            break;
423            for (type = 0; type < CCS_MAX_NETWORK_OPERATION; type++)
424                    if (ccs_permstr(param->w[1], ccs_socket_keyword[type]))
425                            e.perm |= 1 << type;
426            if (e.protocol == CCS_SOCK_MAX || !e.perm)
427                    return -EINVAL;
428            if (!ccs_parse_name_union(param->w[2], &e.name))
429                    return -EINVAL;
430            error = ccs_update_domain(&e.head, sizeof(e), param, ccs_same_unix_acl,
431                                      ccs_merge_unix_acl);
432            ccs_put_name_union(&e.name);
433            return error;
434    }
435    
436    #ifndef CONFIG_NET
437    
438    void __init ccs_network_init(void)
439  {  {
440          return ccs_check_network_entry(is_ipv6, NETWORK_ACL_TCP_LISTEN,          u8 i;
441                                         (const u32 *) address, ntohs(port));          for (i = 0; i < CCS_SOCK_MAX; i++)
442                    if (!ccs_proto_keyword[i])
443                            ccs_proto_keyword[i] = "unknown";
444  }  }
445    
446    #else
447    
448  /**  /**
449   * ccs_check_network_connect_acl - Check permission for connect() operation.   * ccs_inet_entry - Check permission for INET network operation.
450   *   *
451   * @is_ipv6:   True if @address is an IPv6 address.   * @address: Pointer to "struct ccs_addr_info".
  * @sock_type: Type of socket. (TCP or UDP or RAW)  
  * @address:   An IPv4 or IPv6 address.  
  * @port:      Port number.  
452   *   *
453   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
454   */   */
455  static inline int ccs_check_network_connect_acl(const bool is_ipv6,  static int ccs_inet_entry(const struct ccs_addr_info *address)
                                                 const int sock_type,  
                                                 const u8 *address,  
                                                 const u16 port)  
456  {  {
457          u8 operation;          const int idx = ccs_read_lock();
458          switch (sock_type) {          struct ccs_request_info r;
459          case SOCK_STREAM:          int error = 0;
460                  operation = NETWORK_ACL_TCP_CONNECT;          const u8 type = ccs_inet2mac[address->protocol][address->operation];
461                  break;          if (type && ccs_init_request_info(&r, type) != CCS_CONFIG_DISABLED) {
462          case SOCK_DGRAM:                  struct task_struct * const task = current;
463                  operation = NETWORK_ACL_UDP_CONNECT;                  const bool no_sleep = address->operation == CCS_NETWORK_ACCEPT
464                  break;                          || address->operation == CCS_NETWORK_RECV;
465          default:                  r.param_type = CCS_TYPE_INET_ACL;
466                  operation = NETWORK_ACL_RAW_CONNECT;                  r.param.inet_network.protocol = address->protocol;
467                    r.param.inet_network.operation = address->operation;
468                    r.param.inet_network.is_ipv6 = address->inet.is_ipv6;
469                    r.param.inet_network.address = address->inet.address;
470                    r.param.inet_network.port = ntohs(address->inet.port);
471                    /* use host byte order to allow u32 comparison than memcmp().*/
472                    r.param.inet_network.ip = ntohl(*address->inet.address);
473                    if (no_sleep)
474                            task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
475                    do {
476                            ccs_check_acl(&r, ccs_check_inet_acl);
477                            error = ccs_audit_inet_log(&r);
478                    } while (error == CCS_RETRY_REQUEST);
479                    if (no_sleep)
480                            task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
481          }          }
482          return ccs_check_network_entry(is_ipv6, operation,          ccs_read_unlock(idx);
483                                         (const u32 *) address, ntohs(port));          return error;
484  }  }
485    
486  /**  static int ccs_check_inet_address(const struct sockaddr *addr,
487   * ccs_check_network_bind_acl - Check permission for bind() operation.                                    const unsigned int addr_len, const u16 port,
488   *                                    struct ccs_addr_info *address)
  * @is_ipv6:   True if @address is an IPv6 address.  
  * @sock_type: Type of socket. (TCP or UDP or RAW)  
  * @address:   An IPv4 or IPv6 address.  
  * @port:      Port number.  
  *  
  * Returns 0 on success, negative value otherwise.  
  */  
 static int ccs_check_network_bind_acl(const bool is_ipv6, const int sock_type,  
                                       const u8 *address, const u16 port)  
489  {  {
490          u8 operation;          struct ccs_inet_addr_info *i = &address->inet;
491          switch (sock_type) {          switch (addr->sa_family) {
492          case SOCK_STREAM:          case AF_INET6:
493                  operation = NETWORK_ACL_TCP_BIND;                  if (addr_len < SIN6_LEN_RFC2133)
494                            goto skip;
495                    i->is_ipv6 = true;
496                    i->address = (u32 *)
497                            ((struct sockaddr_in6 *) addr)->sin6_addr.s6_addr;
498                    i->port = ((struct sockaddr_in6 *) addr)->sin6_port;
499                  break;                  break;
500          case SOCK_DGRAM:          case AF_INET:
501                  operation = NETWORK_ACL_UDP_BIND;                  if (addr_len < sizeof(struct sockaddr_in))
502                            goto skip;
503                    i->is_ipv6 = false;
504                    i->address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;
505                    i->port = ((struct sockaddr_in *) addr)->sin_port;
506                  break;                  break;
507          default:          default:
508                  operation = NETWORK_ACL_RAW_BIND;                  goto skip;
509          }          }
510          return ccs_check_network_entry(is_ipv6, operation,          if (address->protocol == SOCK_RAW)
511                                         (const u32 *) address, ntohs(port));                  i->port = htons(port);
512  }          return ccs_inet_entry(address);
513     skip:
514  /**          return 0;
  * ccs_check_network_accept_acl - Check permission for accept() operation.  
  *  
  * @is_ipv6: True if @address is an IPv6 address.  
  * @address: An IPv4 or IPv6 address.  
  * @port:    Port number.  
  *  
  * Returns 0 on success, negative value otherwise.  
  */  
 static inline int ccs_check_network_accept_acl(const bool is_ipv6,  
                                                const u8 *address,  
                                                const u16 port)  
 {  
         int retval;  
         current->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         retval = ccs_check_network_entry(is_ipv6, NETWORK_ACL_TCP_ACCEPT,  
                                          (const u32 *) address, ntohs(port));  
         current->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         return retval;  
515  }  }
516    
517  /**  /**
518   * ccs_check_network_sendmsg_acl - Check permission for sendmsg() operation.   * ccs_unix_entry - Check permission for UNIX network operation.
519   *   *
520   * @is_ipv6:   True if @address is an IPv6 address.   * @address: Pointer to "struct ccs_addr_info".
  * @sock_type: Type of socket. (UDP or RAW)  
  * @address:   An IPv4 or IPv6 address.  
  * @port:      Port number.  
521   *   *
522   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
523   */   */
524  static inline int ccs_check_network_sendmsg_acl(const bool is_ipv6,  static int ccs_unix_entry(const struct ccs_addr_info *address)
                                                 const int sock_type,  
                                                 const u8 *address,  
                                                 const u16 port)  
525  {  {
526          u8 operation;          const int idx = ccs_read_lock();
527          if (sock_type == SOCK_DGRAM)          struct ccs_request_info r;
528                  operation = NETWORK_ACL_UDP_CONNECT;          int error = 0;
529          else          const u8 type = ccs_unix2mac[address->protocol][address->operation];
530                  operation = NETWORK_ACL_RAW_CONNECT;          if (type && ccs_init_request_info(&r, type) != CCS_CONFIG_DISABLED) {
531          return ccs_check_network_entry(is_ipv6, operation,                  char *buf;
532                                         (const u32 *) address, ntohs(port));                  if (address->unix0.addr_len <= sizeof(sa_family_t))
533                            buf = ccs_encode2("anonymous", 9);                      
534                    else if (address->unix0.addr[0])
535                            buf = ccs_encode(address->unix0.addr);
536                    else
537                            buf = ccs_encode2(address->unix0.addr,
538                                              address->unix0.addr_len
539                                              - sizeof(sa_family_t));
540                    if (buf) {
541                            struct task_struct * const task = current;
542                            const bool no_sleep =
543                                    address->operation == CCS_NETWORK_ACCEPT ||
544                                    address->operation == CCS_NETWORK_RECV;
545                            struct ccs_path_info addr;
546                            addr.name = buf;
547                            ccs_fill_path_info(&addr);
548                            r.param_type = CCS_TYPE_UNIX_ACL;
549                            r.param.unix_network.protocol = address->protocol;
550                            r.param.unix_network.operation = address->operation;
551                            r.param.unix_network.address = &addr;
552                            if (no_sleep)
553                                    task->ccs_flags |=
554                                            CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
555                    
556                            do {
557                                    ccs_check_acl(&r, ccs_check_unix_acl);
558                                    error = ccs_audit_unix_log(&r);
559                            } while (error == CCS_RETRY_REQUEST);
560                            if (no_sleep)
561                                    task->ccs_flags &=
562                                            ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
563                            kfree(buf);
564                    } else
565                            error = -ENOMEM;
566            }
567            ccs_read_unlock(idx);
568            return error;
569  }  }
570    
571  /**  static int ccs_check_unix_address(struct sockaddr *addr,
572   * ccs_check_network_recvmsg_acl - Check permission for recvmsg() operation.                                    const unsigned int addr_len,
573   *                                    struct ccs_addr_info *address)
574   * @is_ipv6:   True if @address is an IPv6 address.  {
575   * @sock_type: Type of socket. (UDP or RAW)          struct ccs_unix_addr_info *u = &address->unix0;
576   * @address:   An IPv4 or IPv6 address.          if (addr->sa_family != AF_UNIX)
577   * @port:      Port number.                  return 0;
578   *          u->addr = ((struct sockaddr_un *) addr)->sun_path;
579   * Returns 0 on success, negative value otherwise.          u->addr_len = addr_len;
580   */          /*
581  static inline int ccs_check_network_recvmsg_acl(const bool is_ipv6,           * Terminate pathname with '\0' like unix_mkname() does.
582                                                  const int sock_type,           * This is needed because pathname was copied by move_addr_to_kernel()
583                                                  const u8 *address,           * but not yet terminated by unix_mkname().
584                                                  const u16 port)           */
585  {          if (u->addr[0] && addr_len > sizeof(short) &&
586          int retval;              addr_len <= sizeof(struct sockaddr_un))
587          const u8 operation                  ((char *) u->addr)[addr_len] = '\0';
588                  = (sock_type == SOCK_DGRAM) ?          return ccs_unix_entry(address);
                 NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT;  
         current->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         retval = ccs_check_network_entry(is_ipv6, operation,  
                                          (const u32 *) address, ntohs(port));  
         current->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         return retval;  
589  }  }
590    
591  #define MAX_SOCK_ADDR 128 /* net/socket.c */  static bool ccs_kernel_service(void)
   
 /* Check permission for creating a socket. */  
 int ccs_socket_create_permission(int family, int type, int protocol)  
592  {  {
         int error = 0;  
593          /* Nothing to do if I am a kernel service. */          /* Nothing to do if I am a kernel service. */
594          if (segment_eq(get_fs(), KERNEL_DS))          return segment_eq(get_fs(), KERNEL_DS);
                 return 0;  
         if (family == PF_PACKET && !ccs_capable(CCS_USE_PACKET_SOCKET))  
                 return -EPERM;  
         if (family == PF_ROUTE && !ccs_capable(CCS_USE_ROUTE_SOCKET))  
                 return -EPERM;  
         if (family != PF_INET && family != PF_INET6)  
                 return 0;  
         switch (type) {  
         case SOCK_STREAM:  
                 if (!ccs_capable(CCS_INET_STREAM_SOCKET_CREATE))  
                         error = -EPERM;  
                 break;  
         case SOCK_DGRAM:  
                 if (!ccs_capable(CCS_USE_INET_DGRAM_SOCKET))  
                         error = -EPERM;  
                 break;  
         case SOCK_RAW:  
                 if (!ccs_capable(CCS_USE_INET_RAW_SOCKET))  
                         error = -EPERM;  
                 break;  
         }  
         return error;  
595  }  }
596    
597  /* Check permission for listening a TCP socket. */  static u8 ccs_sock_family(struct sock *sk)
 int ccs_socket_listen_permission(struct socket *sock)  
598  {  {
599          int error = 0;          u8 family;
600          char addr[MAX_SOCK_ADDR];          if (ccs_kernel_service())
         int addr_len;  
         /* Nothing to do if I am a kernel service. */  
         if (segment_eq(get_fs(), KERNEL_DS))  
                 return 0;  
         if (sock->type != SOCK_STREAM)  
601                  return 0;                  return 0;
602          switch (sock->sk->sk_family) {          family = sk->sk_family;
603            switch (family) {
604          case PF_INET:          case PF_INET:
605          case PF_INET6:          case PF_INET6:
606                  break;          case PF_UNIX:
607                    return family;
608          default:          default:
609                  return 0;                  return 0;
610          }          }
611          if (!ccs_capable(CCS_INET_STREAM_SOCKET_LISTEN))  }
612    
613    /* Check permission for creating a socket. */
614    static int __ccs_socket_create_permission(int family, int type, int protocol)
615    {
616            if (ccs_kernel_service())
617                    return 0;
618            if (family == PF_PACKET && !ccs_capable(CCS_USE_PACKET_SOCKET))
619                  return -EPERM;                  return -EPERM;
620          if (sock->ops->getname(sock, (struct sockaddr *) addr, &addr_len, 0))          if (family == PF_ROUTE && !ccs_capable(CCS_USE_ROUTE_SOCKET))
621                  return -EPERM;                  return -EPERM;
622          switch (((struct sockaddr *) addr)->sa_family) {          return 0;
                 struct sockaddr_in6 *addr6;  
                 struct sockaddr_in *addr4;  
         case AF_INET6:  
                 addr6 = (struct sockaddr_in6 *) addr;  
                 error = ccs_check_network_listen_acl(true,  
                                                      addr6->sin6_addr.s6_addr,  
                                                      addr6->sin6_port);  
                 break;  
         case AF_INET:  
                 addr4 = (struct sockaddr_in *) addr;  
                 error = ccs_check_network_listen_acl(false,  
                                                      (u8 *) &addr4->sin_addr,  
                                                      addr4->sin_port);  
                 break;  
         }  
         return error;  
623  }  }
624    
625  /* Check permission for setting the remote IP address/port pair of a socket. */  /* Check permission for listening a socket. */
626  int ccs_socket_connect_permission(struct socket *sock, struct sockaddr *addr,  static int __ccs_socket_listen_permission(struct socket *sock)
                                   int addr_len)  
627  {  {
628          int error = 0;          struct ccs_addr_info address;
629            const u8 family = ccs_sock_family(sock->sk);
630          const unsigned int type = sock->type;          const unsigned int type = sock->type;
631          /* Nothing to do if I am a kernel service. */          struct sockaddr_storage addr;
632          if (segment_eq(get_fs(), KERNEL_DS))          int addr_len;
633            if (!family || (type != SOCK_STREAM && type != SOCK_SEQPACKET))
634                  return 0;                  return 0;
635            {
636                    const int error = sock->ops->getname(sock, (struct sockaddr *)
637                                                         &addr, &addr_len, 0);
638                    if (error)
639                            return error;
640            }
641            address.protocol = type;
642            address.operation = CCS_NETWORK_LISTEN;
643            if (family == PF_UNIX)
644                    return ccs_check_unix_address((struct sockaddr *) &addr,
645                                                  addr_len, &address);
646            return ccs_check_inet_address((struct sockaddr *) &addr, addr_len, 0,
647                                          &address);
648    }
649    
650    /* Check permission for setting the remote address of a socket. */
651    static int __ccs_socket_connect_permission(struct socket *sock,
652                                               struct sockaddr *addr, int addr_len)
653    {
654            struct ccs_addr_info address;
655            const u8 family = ccs_sock_family(sock->sk);
656            const unsigned int type = sock->type;
657            if (!family)
658                    return 0;
659            address.protocol = type;
660          switch (type) {          switch (type) {
         case SOCK_STREAM:  
661          case SOCK_DGRAM:          case SOCK_DGRAM:
662          case SOCK_RAW:          case SOCK_RAW:
663                    address.operation = CCS_NETWORK_SEND;
664                    break;
665            case SOCK_STREAM:
666            case SOCK_SEQPACKET:
667                    address.operation = CCS_NETWORK_CONNECT;
668                  break;                  break;
669          default:          default:
670                  return 0;                  return 0;
671          }          }
672          switch (addr->sa_family) {          if (family == PF_UNIX)
673                  struct sockaddr_in6 *addr6;                  return ccs_check_unix_address(addr, addr_len, &address);
674                  struct sockaddr_in *addr4;          return ccs_check_inet_address(addr, addr_len, sock->sk->sk_protocol,
675                  u16 port;                                        &address);
         case AF_INET6:  
                 if (addr_len < SIN6_LEN_RFC2133)  
                         break;  
                 addr6 = (struct sockaddr_in6 *) addr;  
                 if (type != SOCK_RAW)  
                         port = addr6->sin6_port;  
                 else  
                         port = htons(sock->sk->sk_protocol);  
                 error = ccs_check_network_connect_acl(true, type,  
                                                       addr6->sin6_addr.s6_addr,  
                                                       port);  
                 break;  
         case AF_INET:  
                 if (addr_len < sizeof(struct sockaddr_in))  
                         break;  
                 addr4 = (struct sockaddr_in *) addr;  
                 if (type != SOCK_RAW)  
                         port = addr4->sin_port;  
                 else  
                         port = htons(sock->sk->sk_protocol);  
                 error = ccs_check_network_connect_acl(false, type,  
                                                       (u8 *) &addr4->sin_addr,  
                                                       port);  
                 break;  
         }  
         if (type != SOCK_STREAM)  
                 return error;  
         switch (sock->sk->sk_family) {  
         case PF_INET:  
         case PF_INET6:  
                 if (!ccs_capable(CCS_INET_STREAM_SOCKET_CONNECT))  
                         error = -EPERM;  
                 break;  
         }  
         return error;  
676  }  }
677    
678  /* Check permission for setting the local IP address/port pair of a socket. */  /* Check permission for setting the local address of a socket. */
679  int ccs_socket_bind_permission(struct socket *sock, struct sockaddr *addr,  static int __ccs_socket_bind_permission(struct socket *sock,
680                                 int addr_len)                                          struct sockaddr *addr, int addr_len)
681  {  {
682          int error = 0;          struct ccs_addr_info address;
683            const u8 family = ccs_sock_family(sock->sk);
684          const unsigned int type = sock->type;          const unsigned int type = sock->type;
685          /* Nothing to do if I am a kernel service. */          if (!family)
         if (segment_eq(get_fs(), KERNEL_DS))  
686                  return 0;                  return 0;
687          switch (type) {          switch (type) {
688          case SOCK_STREAM:          case SOCK_STREAM:
689          case SOCK_DGRAM:          case SOCK_DGRAM:
690          case SOCK_RAW:          case SOCK_RAW:
691            case SOCK_SEQPACKET:
692                    address.protocol = type;
693                    address.operation = CCS_NETWORK_BIND;
694                  break;                  break;
695          default:          default:
696                  return 0;                  return 0;
697          }          }
698          switch (addr->sa_family) {          if (family == PF_UNIX)
699                  struct sockaddr_in6 *addr6;                  return ccs_check_unix_address(addr, addr_len, &address);
700                  struct sockaddr_in *addr4;          return ccs_check_inet_address(addr, addr_len, sock->sk->sk_protocol,
701                  u16 port;                                        &address);
         case AF_INET6:  
                 if (addr_len < SIN6_LEN_RFC2133)  
                         break;  
                 addr6 = (struct sockaddr_in6 *) addr;  
                 if (type != SOCK_RAW)  
                         port = addr6->sin6_port;  
                 else  
                         port = htons(sock->sk->sk_protocol);  
                 error = ccs_check_network_bind_acl(true, type,  
                                                    addr6->sin6_addr.s6_addr,  
                                                    port);  
                 break;  
         case AF_INET:  
                 if (addr_len < sizeof(struct sockaddr_in))  
                         break;  
                 addr4 = (struct sockaddr_in *) addr;  
                 if (type != SOCK_RAW)  
                         port = addr4->sin_port;  
                 else  
                         port = htons(sock->sk->sk_protocol);  
                 error = ccs_check_network_bind_acl(false, type,  
                                                    (u8 *) &addr4->sin_addr,  
                                                    port);  
                 break;  
         }  
         return error;  
702  }  }
703    
704  /*  /* Check permission for sending a datagram. */
705   * Check permission for accepting a TCP socket.  static int __ccs_socket_sendmsg_permission(struct socket *sock,
706   *                                             struct msghdr *msg, int size)
  * Currently, the LSM hook for this purpose is not provided.  
  */  
 int ccs_socket_accept_permission(struct socket *sock, struct sockaddr *addr)  
707  {  {
708          int error = 0;          struct ccs_addr_info address;
709          int addr_len;          const u8 family = ccs_sock_family(sock->sk);
710          /* Nothing to do if I am a kernel service. */          const unsigned int type = sock->type;
711          if (segment_eq(get_fs(), KERNEL_DS))          if (!msg->msg_name || !family ||
712                  return 0;              (type != SOCK_DGRAM && type != SOCK_RAW))
         switch (sock->sk->sk_family) {  
         case PF_INET:  
         case PF_INET6:  
                 break;  
         default:  
713                  return 0;                  return 0;
714          }          address.protocol = type;
715          error = sock->ops->getname(sock, addr, &addr_len, 2);          address.operation = CCS_NETWORK_SEND;
716          if (error)          if (family == PF_UNIX)
717                  return error;                  return ccs_check_unix_address((struct sockaddr *)
718          switch (addr->sa_family) {                                                msg->msg_name, msg->msg_namelen,
719                  struct sockaddr_in6 *addr6;                                                &address);
720                  struct sockaddr_in *addr4;          return ccs_check_inet_address((struct sockaddr *) msg->msg_name,
721          case AF_INET6:                                        msg->msg_namelen, sock->sk->sk_protocol,
722                  addr6 = (struct sockaddr_in6 *) addr;                                        &address);
723                  error = ccs_check_network_accept_acl(true,  }
724                                                       addr6->sin6_addr.s6_addr,  
725                                                       addr6->sin6_port);  /* Check permission for accepting a socket. */
726                  break;  static int __ccs_socket_post_accept_permission(struct socket *sock,
727          case AF_INET:                                                 struct socket *newsock)
                 addr4 = (struct sockaddr_in *) addr;  
                 error = ccs_check_network_accept_acl(false,  
                                                      (u8 *) &addr4->sin_addr,  
                                                      addr4->sin_port);  
                 break;  
         }  
         return error;  
 }  
   
 /* Check permission for sending a datagram via a UDP or RAW socket. */  
 int ccs_socket_sendmsg_permission(struct socket *sock, struct sockaddr *addr,  
                                   int addr_len)  
728  {  {
729          int error = 0;          struct ccs_addr_info address;
730          const int type = sock->type;          const u8 family = ccs_sock_family(sock->sk);
731          /* Nothing to do if I am a kernel service. */          const unsigned int type = sock->type;
732          if (segment_eq(get_fs(), KERNEL_DS))          struct sockaddr_storage addr;
733                  return 0;          int addr_len;
734          if (!addr || (type != SOCK_DGRAM && type != SOCK_RAW))          if (!family || (type != SOCK_STREAM && type != SOCK_SEQPACKET))
735                  return 0;                  return 0;
736          switch (addr->sa_family) {          {
737                  struct sockaddr_in6 *addr6;                  const int error = newsock->ops->getname(newsock,
738                  struct sockaddr_in *addr4;                                                          (struct sockaddr *)
739                  u16 port;                                                          &addr, &addr_len, 2);
740          case AF_INET6:                  if (error)
741                  if (addr_len < SIN6_LEN_RFC2133)                          return error;
742                          break;          }
743                  addr6 = (struct sockaddr_in6 *) addr;          address.protocol = type;
744                  if (type == SOCK_DGRAM)          address.operation = CCS_NETWORK_ACCEPT;
745                          port = addr6->sin6_port;          if (family == PF_UNIX)
746                  else                  return ccs_check_unix_address((struct sockaddr *) &addr,
747                          port = htons(sock->sk->sk_protocol);                                                addr_len, &address);
748                  error = ccs_check_network_sendmsg_acl(true, type,          return ccs_check_inet_address((struct sockaddr *) &addr, addr_len, 0,
749                                                        addr6->sin6_addr.s6_addr,                                        &address);
                                                       port);  
                 break;  
         case AF_INET:  
                 if (addr_len < sizeof(struct sockaddr_in))  
                         break;  
                 addr4 = (struct sockaddr_in *) addr;  
                 if (type == SOCK_DGRAM)  
                         port = addr4->sin_port;  
                 else  
                         port = htons(sock->sk->sk_protocol);  
                 error = ccs_check_network_sendmsg_acl(false, type,  
                                                       (u8 *) &addr4->sin_addr,  
                                                       port);  
                 break;  
         }  
         return error;  
750  }  }
751    
752  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
753  #if !defined(RHEL_MAJOR) || RHEL_MAJOR != 5  #if !defined(RHEL_MAJOR) || RHEL_MAJOR != 5
754    #if !defined(AX_MAJOR) || AX_MAJOR != 3 || !defined(AX_MINOR) || AX_MINOR < 2
755    
756  static inline struct iphdr *ip_hdr(const struct sk_buff *skb)  static inline struct iphdr *ip_hdr(const struct sk_buff *skb)
757  {  {
# Line 1195  static inline struct ipv6hdr *ipv6_hdr(c Line 770  static inline struct ipv6hdr *ipv6_hdr(c
770    
771  #endif  #endif
772  #endif  #endif
   
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)  
 static void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,  
                               unsigned int flags)  
 {  
         /* Clear queue. */  
         if (flags & MSG_PEEK) {  
                 int clear = 0;  
                 spin_lock_irq(&sk->sk_receive_queue.lock);  
                 if (skb == skb_peek(&sk->sk_receive_queue)) {  
                         __skb_unlink(skb, &sk->sk_receive_queue);  
                         clear = 1;  
                 }  
                 spin_unlock_irq(&sk->sk_receive_queue.lock);  
                 if (clear)  
                         kfree_skb(skb);  
         }  
         skb_free_datagram(sk, skb);  
 }  
 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)  
 static void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,  
                               unsigned int flags)  
 {  
         /* Clear queue. */  
         if (flags & MSG_PEEK) {  
                 int clear = 0;  
                 spin_lock_bh(&sk->sk_receive_queue.lock);  
                 if (skb == skb_peek(&sk->sk_receive_queue)) {  
                         __skb_unlink(skb, &sk->sk_receive_queue);  
                         clear = 1;  
                 }  
                 spin_unlock_bh(&sk->sk_receive_queue.lock);  
                 if (clear)  
                         kfree_skb(skb);  
         }  
         skb_free_datagram(sk, skb);  
 }  
773  #endif  #endif
774    
775  /*  /* Check permission for receiving a datagram. */
776   * Check permission for receiving a datagram via a UDP or RAW socket.  static int __ccs_socket_post_recvmsg_permission(struct sock *sk,
777   *                                                  struct sk_buff *skb)
  * Currently, the LSM hook for this purpose is not provided.  
  */  
 int ccs_socket_recvmsg_permission(struct sock *sk, struct sk_buff *skb,  
                                   const unsigned int flags)  
778  {  {
779          int error = 0;          struct ccs_addr_info address;
780            const u8 family = ccs_sock_family(sk);
781          const unsigned int type = sk->sk_type;          const unsigned int type = sk->sk_type;
782          if (type != SOCK_DGRAM && type != SOCK_RAW)          struct sockaddr_storage addr;
783            if (!family)
784                  return 0;                  return 0;
785          /* Nothing to do if I am a kernel service. */          switch (type) {
786          if (segment_eq(get_fs(), KERNEL_DS))          case SOCK_DGRAM:
787            case SOCK_RAW:
788                    address.protocol = type;
789                    break;
790            default:
791                  return 0;                  return 0;
792            }
793          switch (sk->sk_family) {          address.operation = CCS_NETWORK_RECV;
794                  struct in6_addr sin6;          switch (family) {
                 struct in_addr sin4;  
                 u16 port;  
795          case PF_INET6:          case PF_INET6:
796                  if (type == SOCK_DGRAM) { /* UDP IPv6 */                  {
797                          if (skb->protocol == htons(ETH_P_IP)) {                          struct in6_addr *sin6 = (struct in6_addr *) &addr;
798                                  ipv6_addr_set(&sin6, 0, 0, htonl(0xffff),                          address.inet.is_ipv6 = true;
799                            if (type == SOCK_DGRAM &&
800                                skb->protocol == htons(ETH_P_IP))
801                                    ipv6_addr_set(sin6, 0, 0, htonl(0xffff),
802                                                ip_hdr(skb)->saddr);                                                ip_hdr(skb)->saddr);
803                          } else {                          else
804                                  ipv6_addr_copy(&sin6, &ipv6_hdr(skb)->saddr);                                  ipv6_addr_copy(sin6, &ipv6_hdr(skb)->saddr);
805                          }                          break;
                         port = udp_hdr(skb)->source;  
                 } else { /* RAW IPv6 */  
                         ipv6_addr_copy(&sin6, &ipv6_hdr(skb)->saddr);  
                         port = htons(sk->sk_protocol);  
806                  }                  }
                 error = ccs_check_network_recvmsg_acl(true, type,  
                                                       (u8 *) &sin6, port);  
                 break;  
807          case PF_INET:          case PF_INET:
808                  if (type == SOCK_DGRAM) { /* UDP IPv4 */                  {
809                          sin4.s_addr = ip_hdr(skb)->saddr;                          struct in_addr *sin4 = (struct in_addr *) &addr;
810                          port = udp_hdr(skb)->source;                          address.inet.is_ipv6 = false;
811                  } else { /* RAW IPv4 */                          sin4->s_addr = ip_hdr(skb)->saddr;
812                          sin4.s_addr = ip_hdr(skb)->saddr;                          break;
                         port = htons(sk->sk_protocol);  
813                  }                  }
814                  error = ccs_check_network_recvmsg_acl(false, type,          default: /* == PF_UNIX */
815                                                        (u8 *) &sin4, port);                  {
816                  break;  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
817          }                          struct unix_address *u = unix_sk(skb->sk)->addr;
818          if (!error)  #else
819                  return 0;                          struct unix_address *u = skb->sk->protinfo.af_unix.addr;
         /*  
          * Remove from queue if MSG_PEEK is used so that  
          * the head message from unwanted source in receive queue will not  
          * prevent the caller from picking up next message from wanted source  
          * when the caller is using MSG_PEEK flag for picking up.  
          */  
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)  
         if (type == SOCK_DGRAM)  
                 lock_sock(sk);  
820  #endif  #endif
821          skb_kill_datagram(sk, skb, flags);                          unsigned int addr_len;
822  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)                          if (!u)
823                                    return 0;
824                            addr_len = u->len;
825                            if (addr_len >= sizeof(addr))
826                                    return 0;
827                            memcpy(&addr, u->name, addr_len);
828                            return ccs_check_unix_address((struct sockaddr *) &addr,
829                                                          addr_len, &address);
830                    }
831            }
832            address.inet.address = (u32 *) &addr;
833          if (type == SOCK_DGRAM)          if (type == SOCK_DGRAM)
834                  release_sock(sk);                  address.inet.port = udp_hdr(skb)->source;
835  #endif          else
836          /* Hope less harmful than -EPERM. */                  address.inet.port = htons(sk->sk_protocol);
837          return -ENOMEM;          return ccs_inet_entry(&address);
838  }  }
839  EXPORT_SYMBOL(ccs_socket_recvmsg_permission);  
840    void __init ccs_network_init(void)
841    {
842            u8 i;
843            for (i = 0; i < CCS_SOCK_MAX; i++)
844                    if (!ccs_proto_keyword[i])
845                            ccs_proto_keyword[i] = "unknown";
846            ccsecurity_ops.socket_create_permission =
847                    __ccs_socket_create_permission;
848            ccsecurity_ops.socket_listen_permission =
849                    __ccs_socket_listen_permission;
850            ccsecurity_ops.socket_connect_permission =
851                    __ccs_socket_connect_permission;
852            ccsecurity_ops.socket_bind_permission = __ccs_socket_bind_permission;
853            ccsecurity_ops.socket_post_accept_permission =
854                    __ccs_socket_post_accept_permission;
855            ccsecurity_ops.socket_sendmsg_permission =
856                    __ccs_socket_sendmsg_permission;
857            ccsecurity_ops.socket_post_recvmsg_permission =
858                    __ccs_socket_post_recvmsg_permission;
859    }
860    
861    #endif
Legend:
Removed from v.2853  
changed lines
  Added in v.3949
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ