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

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

trunk/1.6.x/ccs-patch/fs/tomoyo_network.c revision 1135 by kumaneko, Thu Apr 24 07:34:11 2008 UTC branches/ccs-patch/fs/tomoyo_network.c revision 2727 by kumaneko, Fri Jul 3 14:06:48 2009 UTC
# Line 3  Line 3 
3   *   *
4   * Implementation of the Domain-Based Mandatory Access Control.   * Implementation of the Domain-Based Mandatory Access Control.
5   *   *
6   * Copyright (C) 2005-2008  NTT DATA CORPORATION   * Copyright (C) 2005-2009  NTT DATA CORPORATION
7   *   *
8   * Version: 1.6.1-rc   2008/04/24   * Version: 1.7.0-pre   2009/07/03
9   *   *
10   * 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.
11   * See README.ccs for ChangeLog.   * See README.ccs for ChangeLog.
# Line 14  Line 14 
14    
15  #include <linux/ccs_common.h>  #include <linux/ccs_common.h>
16  #include <linux/tomoyo.h>  #include <linux/tomoyo.h>
17    #include <linux/tomoyo_socket.h>
18  #include <linux/realpath.h>  #include <linux/realpath.h>
19  #include <linux/net.h>  #include <linux/net.h>
20  #include <linux/inet.h>  #include <linux/inet.h>
21  #include <linux/in.h>  #include <linux/in.h>
22  #include <linux/in6.h>  #include <linux/in6.h>
23    #include <net/ip.h>
24    #include <net/ipv6.h>
25    #include <net/udp.h>
26    
27    /* Index numbers for Network Controls. */
28    enum ccs_network_acl_index {
29            NETWORK_ACL_UDP_BIND,
30            NETWORK_ACL_UDP_CONNECT,
31            NETWORK_ACL_TCP_BIND,
32            NETWORK_ACL_TCP_LISTEN,
33            NETWORK_ACL_TCP_CONNECT,
34            NETWORK_ACL_TCP_ACCEPT,
35            NETWORK_ACL_RAW_BIND,
36            NETWORK_ACL_RAW_CONNECT
37    };
38    
39  /**  /**
40   * audit_network_log - Audit network log.   * ccs_audit_network_log - Audit network log.
41   *   *
42   * @is_ipv6:    True if @address is an IPv6 address.   * @r:          Pointer to "struct ccs_request_info".
43   * @operation:  The name of operation.   * @operation:  The name of operation.
44   * @address:    An IPv4 or IPv6 address.   * @address:    An IPv4 or IPv6 address.
45   * @port:       Port number.   * @port:       Port number.
46   * @is_granted: True if this is a granted log.   * @is_granted: True if this is a granted log.
  * @profile:    Profile number used.  
  * @mode:       Access control mode used.  
47   *   *
48   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
49   */   */
50  static int audit_network_log(const bool is_ipv6, const char *operation,  static int ccs_audit_network_log(struct ccs_request_info *r,
51                               const char *address, const u16 port,                                   const char *operation, const char *address,
52                               const bool is_granted,                                   const u16 port, const bool is_granted)
                              const u8 profile, const u8 mode)  
53  {  {
54          char *buf;          return ccs_write_audit_log(is_granted, r, KEYWORD_ALLOW_NETWORK
55          int len = 256;                                     "%s %s %u\n", operation, address, port);
         int len2;  
         if (ccs_can_save_audit_log(is_granted) < 0)  
                 return -ENOMEM;  
         buf = ccs_init_audit_log(&len, profile, mode, NULL);  
         if (!buf)  
                 return -ENOMEM;  
         len2 = strlen(buf);  
         snprintf(buf + len2, len - len2 - 1, KEYWORD_ALLOW_NETWORK "%s %s %u\n",  
                  operation, address, port);  
         return ccs_write_audit_log(buf, is_granted);  
56  }  }
57    
58    /* The list for "struct ccs_address_group_entry". */
59    LIST_HEAD(ccs_address_group_list);
60    
61  /**  /**
62   * save_ipv6_address - Keep the given IPv6 address on the RAM.   * ccs_get_address_group - Allocate memory for "struct ccs_address_group_entry".
63   *   *
64   * @addr: Pointer to "struct in6_addr".   * @group_name: The name of address group.
  *  
  * Returns pointer to "struct in6_addr" on success, NULL otherwise.  
65   *   *
66   * The RAM is shared, so NEVER try to modify or kfree() the returned address.   * Returns pointer to "struct ccs_address_group_entry" on success,
67     * NULL otherwise.
68   */   */
69  static const struct in6_addr *save_ipv6_address(const struct in6_addr *addr)  static struct ccs_address_group_entry *ccs_get_address_group(const char *
70                                                                 group_name)
71  {  {
72          static const u8 block_size = 16;          struct ccs_address_group_entry *entry = NULL;
73          struct addr_list {          struct ccs_address_group_entry *group;
74                  struct in6_addr addr[block_size];          const struct ccs_path_info *saved_group_name;
75                  struct list1_head list;          int error = -ENOMEM;
76                  u32 in_use_count;          if (!ccs_is_correct_path(group_name, 0, 0, 0) ||
77          };              !group_name[0])
         static LIST1_HEAD(address_list);  
         struct addr_list *ptr;  
         static DEFINE_MUTEX(lock);  
         u8 i = block_size;  
         if (!addr)  
78                  return NULL;                  return NULL;
79          mutex_lock(&lock);          saved_group_name = ccs_get_name(group_name);
80          list1_for_each_entry(ptr, &address_list, list) {          if (!saved_group_name)
81                  for (i = 0; i < ptr->in_use_count; i++) {                  return NULL;
82                          if (!memcmp(&ptr->addr[i], addr, sizeof(*addr)))          entry = kzalloc(sizeof(*entry), GFP_KERNEL);
83                                  goto ok;          mutex_lock(&ccs_policy_lock);
84                  }          list_for_each_entry_rcu(group, &ccs_address_group_list, list) {
85                  if (i < block_size)                  if (saved_group_name != group->group_name)
86                          break;                          continue;
87          }                  atomic_inc(&group->users);
88          if (i == block_size) {                  error = 0;
89                  ptr = ccs_alloc_element(sizeof(*ptr));                  break;
                 if (!ptr)  
                         goto ok;  
                 list1_add_tail_mb(&ptr->list, &address_list);  
                 i = 0;  
90          }          }
91          ptr->addr[ptr->in_use_count++] = *addr;          if (error && ccs_memory_ok(entry, sizeof(*entry))) {
92   ok:                  INIT_LIST_HEAD(&entry->address_group_member_list);
93          mutex_unlock(&lock);                  entry->group_name = saved_group_name;
94          return ptr ? &ptr->addr[i] : NULL;                  saved_group_name = NULL;
95                    atomic_set(&entry->users, 1);
96                    list_add_tail_rcu(&entry->list, &ccs_address_group_list);
97                    group = entry;
98                    entry = NULL;
99                    error = 0;
100            }
101            mutex_unlock(&ccs_policy_lock);
102            ccs_put_name(saved_group_name);
103            kfree(entry);
104            return !error ? group : NULL;
105  }  }
106    
 /* The list for "struct address_group_entry". */  
 static LIST1_HEAD(address_group_list);  
   
107  /**  /**
108   * update_address_group_entry - Update "struct address_group_entry" list.   * ccs_update_address_group_entry - Update "struct ccs_address_group_entry" list.
109   *   *
110   * @group_name:  The name of address group.   * @group_name:  The name of address group.
111   * @is_ipv6:     True if @min_address and @max_address are IPv6 addresses.   * @is_ipv6:     True if @min_address and @max_address are IPv6 addresses.
# Line 111  static LIST1_HEAD(address_group_list); Line 115  static LIST1_HEAD(address_group_list);
115   *   *
116   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
117   */   */
118  static int update_address_group_entry(const char *group_name,  static int ccs_update_address_group_entry(const char *group_name,
119                                        const bool is_ipv6,                                            const bool is_ipv6,
120                                        const u16 *min_address,                                            const u16 *min_address,
121                                        const u16 *max_address,                                            const u16 *max_address,
122                                        const bool is_delete)                                            const bool is_delete)
123  {  {
124          static DEFINE_MUTEX(lock);          struct ccs_address_group_entry *group;
125          struct address_group_entry *new_group;          struct ccs_address_group_member *entry = NULL;
126          struct address_group_entry *group;          struct ccs_address_group_member *member;
         struct address_group_member *new_member;  
         struct address_group_member *member;  
         const struct path_info *saved_group_name;  
127          const struct in6_addr *saved_min_address = NULL;          const struct in6_addr *saved_min_address = NULL;
128          const struct in6_addr *saved_max_address = NULL;          const struct in6_addr *saved_max_address = NULL;
129          int error = -ENOMEM;          int error = is_delete ? -ENOENT : -ENOMEM;
130          bool found = false;          const u32 min_ipv4_address = ntohl(*(u32 *) min_address);
131          if (!ccs_is_correct_path(group_name, 0, 0, 0, __func__) ||          const u32 max_ipv4_address = ntohl(*(u32 *) max_address);
132              !group_name[0])          group = ccs_get_address_group(group_name);
133                  return -EINVAL;          if (!group)
         saved_group_name = ccs_save_name(group_name);  
         if (!saved_group_name)  
                 return -ENOMEM;  
         if (!is_ipv6)  
                 goto not_ipv6;  
         saved_min_address  
                 = save_ipv6_address((struct in6_addr *) min_address);  
         saved_max_address  
                 = save_ipv6_address((struct in6_addr *) max_address);  
         if (!saved_min_address || !saved_max_address)  
134                  return -ENOMEM;                  return -ENOMEM;
135   not_ipv6:          if (is_ipv6) {
136          mutex_lock(&lock);                  saved_min_address
137          list1_for_each_entry(group, &address_group_list, list) {                          = ccs_get_ipv6_address((struct in6_addr *)
138                  if (saved_group_name != group->group_name)                                                 min_address);
139                          continue;                  saved_max_address
140                  list1_for_each_entry(member, &group->address_group_member_list,                          = ccs_get_ipv6_address((struct in6_addr *)
141                                       list) {                                                 max_address);
142                          if (member->is_ipv6 != is_ipv6)                  if (!saved_min_address || !saved_max_address)
                                 continue;  
                         if (is_ipv6) {  
                                 if (member->min.ipv6 != saved_min_address ||  
                                     member->max.ipv6 != saved_max_address)  
                                         continue;  
                         } else {  
                                 if (member->min.ipv4 != *(u32 *) min_address ||  
                                     member->max.ipv4 != *(u32 *) max_address)  
                                         continue;  
                         }  
                         member->is_deleted = is_delete;  
                         error = 0;  
143                          goto out;                          goto out;
144            }
145            if (!is_delete)
146                    entry = kzalloc(sizeof(*entry), GFP_KERNEL);
147            mutex_lock(&ccs_policy_lock);
148            list_for_each_entry_rcu(member, &group->address_group_member_list,
149                                    list) {
150                    if (member->is_ipv6 != is_ipv6)
151                            continue;
152                    if (is_ipv6) {
153                            if (member->min.ipv6 != saved_min_address ||
154                                member->max.ipv6 != saved_max_address)
155                                    continue;
156                    } else {
157                            if (member->min.ipv4 != min_ipv4_address ||
158                                member->max.ipv4 != max_ipv4_address)
159                                    continue;
160                  }                  }
161                  found = true;                  member->is_deleted = is_delete;
162                    error = 0;
163                  break;                  break;
164          }          }
165          if (is_delete) {          if (!is_delete && error && ccs_memory_ok(entry, sizeof(*entry))) {
166                  error = -ENOENT;                  entry->is_ipv6 = is_ipv6;
167                  goto out;                  if (is_ipv6) {
168          }                          entry->min.ipv6 = saved_min_address;
169          if (!found) {                          saved_min_address = NULL;
170                  new_group = ccs_alloc_element(sizeof(*new_group));                          entry->max.ipv6 = saved_max_address;
171                  if (!new_group)                          saved_max_address = NULL;
172                          goto out;                  } else {
173                  INIT_LIST1_HEAD(&new_group->address_group_member_list);                          entry->min.ipv4 = min_ipv4_address;
174                  new_group->group_name = saved_group_name;                          entry->max.ipv4 = max_ipv4_address;
175                  list1_add_tail_mb(&new_group->list, &address_group_list);                  }
176                  group = new_group;                  list_add_tail_rcu(&entry->list,
177          }                                    &group->address_group_member_list);
178          new_member = ccs_alloc_element(sizeof(*new_member));                  entry = NULL;
179          if (!new_member)                  error = 0;
                 goto out;  
         new_member->is_ipv6 = is_ipv6;  
         if (is_ipv6) {  
                 new_member->min.ipv6 = saved_min_address;  
                 new_member->max.ipv6 = saved_max_address;  
         } else {  
                 new_member->min.ipv4 = *(u32 *) min_address;  
                 new_member->max.ipv4 = *(u32 *) max_address;  
180          }          }
181          list1_add_tail_mb(&new_member->list, &group->address_group_member_list);          mutex_unlock(&ccs_policy_lock);
         error = 0;  
182   out:   out:
183          mutex_unlock(&lock);          ccs_put_ipv6_address(saved_min_address);
184          ccs_update_counter(CCS_UPDATES_COUNTER_EXCEPTION_POLICY);          ccs_put_ipv6_address(saved_max_address);
185            ccs_put_address_group(group);
186          return error;          return error;
187  }  }
188    
189  /**  /**
190   * ccs_write_address_group_policy - Write "struct address_group_entry" list.   * ccs_parse_ip_address - Parse an IP address.
191   *   *
192   * @data:      String to parse.   * @address: String to parse.
193   * @is_delete: True if it is a delete request.   * @min:     Pointer to store min address.
194     * @max:     Pointer to store max address.
195   *   *
196   * Returns 0 on success, negative value otherwise.   * Returns 2 if @address is an IPv6, 1 if @address is an IPv4, 0 otherwise.
197   */   */
198  int ccs_write_address_group_policy(char *data, const bool is_delete)  static int ccs_parse_ip_address(char *address, u16 *min, u16 *max)
199  {  {
200          u8 count;          int count = sscanf(address, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx"
201          bool is_ipv6;                             "-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",
202          u16 min_address[8];                             &min[0], &min[1], &min[2], &min[3],
203          u16 max_address[8];                             &min[4], &min[5], &min[6], &min[7],
204          char *cp = strchr(data, ' ');                             &max[0], &max[1], &max[2], &max[3],
205          if (!cp)                             &max[4], &max[5], &max[6], &max[7]);
                 return -EINVAL;  
         *cp++ = '\0';  
         count = sscanf(cp, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx"  
                        "-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",  
                        &min_address[0], &min_address[1],  
                        &min_address[2], &min_address[3],  
                        &min_address[4], &min_address[5],  
                        &min_address[6], &min_address[7],  
                        &max_address[0], &max_address[1],  
                        &max_address[2], &max_address[3],  
                        &max_address[4], &max_address[5],  
                        &max_address[6], &max_address[7]);  
206          if (count == 8 || count == 16) {          if (count == 8 || count == 16) {
207                  u8 i;                  u8 i;
208                    if (count == 8)
209                            memmove(max, min, sizeof(u16) * 8);
210                  for (i = 0; i < 8; i++) {                  for (i = 0; i < 8; i++) {
211                          min_address[i] = htons(min_address[i]);                          min[i] = htons(min[i]);
212                          max_address[i] = htons(max_address[i]);                          max[i] = htons(max[i]);
213                  }                  }
214                  if (count == 8)                  return 2;
                         memmove(max_address, min_address, sizeof(min_address));  
                 is_ipv6 = true;  
                 goto ok;  
215          }          }
216          count = sscanf(cp, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",          count = sscanf(address, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",
217                         &min_address[0], &min_address[1],                         &min[0], &min[1], &min[2], &min[3],
218                         &min_address[2], &min_address[3],                         &max[0], &max[1], &max[2], &max[3]);
                        &max_address[0], &max_address[1],  
                        &max_address[2], &max_address[3]);  
219          if (count == 4 || count == 8) {          if (count == 4 || count == 8) {
220                  u32 ip = ((((u8) min_address[0]) << 24)                  u32 ip = htonl((((u8) min[0]) << 24) + (((u8) min[1]) << 16)
221                            + (((u8) min_address[1]) << 16)                                 + (((u8) min[2]) << 8) + (u8) min[3]);
222                            + (((u8) min_address[2]) << 8)                  memmove(min, &ip, sizeof(ip));
                           + (u8) min_address[3]);  
                 *(u32 *) min_address = ip;  
223                  if (count == 8)                  if (count == 8)
224                          ip = ((((u8) max_address[0]) << 24)                          ip = htonl((((u8) max[0]) << 24) + (((u8) max[1]) << 16)
225                                + (((u8) max_address[1]) << 16)                                     + (((u8) max[2]) << 8) + (u8) max[3]);
226                                + (((u8) max_address[2]) << 8)                  memmove(max, &ip, sizeof(ip));
227                                + (u8) max_address[3]);                  return 1;
                 *(u32 *) max_address = ip;  
                 is_ipv6 = false;  
                 goto ok;  
228          }          }
229          return -EINVAL;          return 0;
  ok:  
         return update_address_group_entry(data, is_ipv6,  
                                           min_address, max_address, is_delete);  
230  }  }
231    
232  /**  /**
233   * find_or_assign_new_address_group - Create address group.   * ccs_write_address_group_policy - Write "struct ccs_address_group_entry" list.
234   *   *
235   * @group_name: The name of address group.   * @data:      String to parse.
236     * @is_delete: True if it is a delete request.
237   *   *
238   * Returns pointer to "struct address_group_entry" on success, NULL otherwise.   * Returns 0 on success, negative value otherwise.
239   */   */
240  static struct address_group_entry *  int ccs_write_address_group_policy(char *data, const bool is_delete)
 find_or_assign_new_address_group(const char *group_name)  
241  {  {
242          u8 i;          bool is_ipv6;
243          struct address_group_entry *group;          u16 min_address[8];
244          for (i = 0; i <= 1; i++) {          u16 max_address[8];
245                  list1_for_each_entry(group, &address_group_list, list) {          char *cp = strchr(data, ' ');
246                          if (!strcmp(group_name, group->group_name->name))          if (!cp)
247                                  return group;                  return -EINVAL;
248                  }          *cp++ = '\0';
249                  if (!i) {          switch (ccs_parse_ip_address(cp, min_address, max_address)) {
250                          const u16 dummy[2] = { 0, 0 };          case 2:
251                          update_address_group_entry(group_name, false,                  is_ipv6 = true;
252                                                     dummy, dummy, false);                  break;
253                          update_address_group_entry(group_name, false,          case 1:
254                                                     dummy, dummy, true);                  is_ipv6 = false;
255                  }                  break;
256            default:
257                    return -EINVAL;
258          }          }
259          return NULL;          return ccs_update_address_group_entry(data, is_ipv6, min_address,
260                                                  max_address, is_delete);
261  }  }
262    
263  /**  /**
264   * address_matches_to_group - Check whether the given address matches members of the given address group.   * ccs_address_matches_group - Check whether the given address matches members of the given address group.
265   *   *
266   * @is_ipv6: True if @address is an IPv6 address.   * @is_ipv6: True if @address is an IPv6 address.
267   * @address: An IPv4 or IPv6 address.   * @address: An IPv4 or IPv6 address.
268   * @group:   Pointer to "struct address_group_entry".   * @group:   Pointer to "struct ccs_address_group_entry".
269   *   *
270   * Returns true if @address matches addresses in @group group, false otherwise.   * Returns true if @address matches addresses in @group group, false otherwise.
271     *
272     * Caller holds srcu_read_lock(&ccs_ss).
273   */   */
274  static bool address_matches_to_group(const bool is_ipv6, const u32 *address,  static bool ccs_address_matches_group(const bool is_ipv6, const u32 *address,
275                                       const struct address_group_entry *group)                                        const struct ccs_address_group_entry *
276                                          group)
277  {  {
278          struct address_group_member *member;          struct ccs_address_group_member *member;
279          const u32 ip = ntohl(*address);          const u32 ip = ntohl(*address);
280          list1_for_each_entry(member, &group->address_group_member_list, list) {          bool matched = false;
281            list_for_each_entry_rcu(member, &group->address_group_member_list,
282                                    list) {
283                  if (member->is_deleted)                  if (member->is_deleted)
284                          continue;                          continue;
285                  if (member->is_ipv6) {                  if (member->is_ipv6) {
286                          if (is_ipv6 &&                          if (is_ipv6 &&
287                              memcmp(member->min.ipv6, address, 16) <= 0 &&                              memcmp(member->min.ipv6, address, 16) <= 0 &&
288                              memcmp(address, member->max.ipv6, 16) <= 0)                              memcmp(address, member->max.ipv6, 16) <= 0) {
289                                  return true;                                  matched = true;
290                                    break;
291                            }
292                  } else {                  } else {
293                          if (!is_ipv6 &&                          if (!is_ipv6 &&
294                              member->min.ipv4 <= ip && ip <= member->max.ipv4)                              member->min.ipv4 <= ip && ip <= member->max.ipv4) {
295                                  return true;                                  matched = true;
296                                    break;
297                            }
298                  }                  }
299          }          }
300          return false;          return matched;
301  }  }
302    
303  /**  /**
304   * ccs_read_address_group_policy - Read "struct address_group_entry" list.   * ccs_read_address_group_policy - Read "struct ccs_address_group_entry" list.
305   *   *
306   * @head: Pointer to "struct ccs_io_buffer".   * @head: Pointer to "struct ccs_io_buffer".
307   *   *
308   * Returns true on success, false otherwise.   * Returns true on success, false otherwise.
309     *
310     * Caller holds srcu_read_lock(&ccs_ss).
311   */   */
312  bool ccs_read_address_group_policy(struct ccs_io_buffer *head)  bool ccs_read_address_group_policy(struct ccs_io_buffer *head)
313  {  {
314          struct list1_head *gpos;          struct list_head *gpos;
315          struct list1_head *mpos;          struct list_head *mpos;
316          list1_for_each_cookie(gpos, head->read_var1, &address_group_list) {          bool done = true;
317                  struct address_group_entry *group;          list_for_each_cookie(gpos, head->read_var1, &ccs_address_group_list) {
318                  group = list1_entry(gpos, struct address_group_entry, list);                  struct ccs_address_group_entry *group;
319                  list1_for_each_cookie(mpos, head->read_var2,                  group = list_entry(gpos, struct ccs_address_group_entry, list);
320                                        &group->address_group_member_list) {                  list_for_each_cookie(mpos, head->read_var2,
321                                         &group->address_group_member_list) {
322                          char buf[128];                          char buf[128];
323                          struct address_group_member *member;                          struct ccs_address_group_member *member;
324                          member = list1_entry(mpos, struct address_group_member,                          member = list_entry(mpos,
325                                                 struct ccs_address_group_member,
326                                               list);                                               list);
327                          if (member->is_deleted)                          if (member->is_deleted)
328                                  continue;                                  continue;
# Line 352  bool ccs_read_address_group_policy(struc Line 334  bool ccs_read_address_group_policy(struc
334                                  ccs_print_ipv6(buf, sizeof(buf), min_address);                                  ccs_print_ipv6(buf, sizeof(buf), min_address);
335                                  if (min_address != max_address) {                                  if (min_address != max_address) {
336                                          int len;                                          int len;
337                                          char *cp = strchr(buf, '\0');                                          char *cp = buf + strlen(buf);
338                                          *cp++ = '-';                                          *cp++ = '-';
339                                          len = strlen(buf);                                          len = strlen(buf);
340                                          ccs_print_ipv6(cp, sizeof(buf) - len,                                          ccs_print_ipv6(cp, sizeof(buf) - len,
# Line 372  bool ccs_read_address_group_policy(struc Line 354  bool ccs_read_address_group_policy(struc
354                                                   HIPQUAD(max_address));                                                   HIPQUAD(max_address));
355                                  }                                  }
356                          }                          }
357                          if (!ccs_io_printf(head, KEYWORD_ADDRESS_GROUP                          done = ccs_io_printf(head, KEYWORD_ADDRESS_GROUP
358                                             "%s %s\n", group->group_name->name,                                               "%s %s\n", group->group_name->name,
359                                             buf))                                               buf);
360                                  goto out;                          if (!done)
361                                    break;
362                  }                  }
363                    if (!done)
364                            break;
365          }          }
366          return true;          return done;
  out:  
         return false;  
367  }  }
368    
369  #if !defined(NIP6)  #if !defined(NIP6)
# Line 447  const char *ccs_net2keyword(const u8 ope Line 430  const char *ccs_net2keyword(const u8 ope
430  }  }
431    
432  /**  /**
433   * update_network_entry - Update "struct ip_network_acl_record" list.   * ccs_update_network_entry - Update "struct ccs_ip_network_acl_record" list.
434   *   *
435   * @operation:   Type of operation.   * @operation:   Type of operation.
436   * @record_type: Type of address.   * @record_type: Type of address.
437   * @group:       Pointer to "struct address_group_entry". May be NULL.   * @group:       Name of group. May be NULL.
438   * @min_address: Start of IPv4 or IPv6 address range.   * @min_address: Start of IPv4 or IPv6 address range.
439   * @max_address: End of IPv4 or IPv6 address range.   * @max_address: End of IPv4 or IPv6 address range.
440   * @min_port:    Start of port number range.   * @min_port:    Start of port number range.
441   * @max_port:    End of port number range.   * @max_port:    End of port number range.
442   * @domain:      Pointer to "struct domain_info".   * @domain:      Pointer to "struct ccs_domain_info".
443   * @condition:   Pointer to "struct condition_list". May be NULL.   * @condition:   Pointer to "struct ccs_condition". May be NULL.
444   * @is_delete:   True if it is a delete request.   * @is_delete:   True if it is a delete request.
445   *   *
446   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
447   */   */
448  static int update_network_entry(const u8 operation, const u8 record_type,  static int ccs_update_network_entry(const u8 operation, const u8 record_type,
449                                  const struct address_group_entry *group,                                      const char *group_name,
450                                  const u32 *min_address, const u32 *max_address,                                      const u32 *min_address,
451                                  const u16 min_port, const u16 max_port,                                      const u32 *max_address,
452                                  struct domain_info *domain,                                      const u16 min_port, const u16 max_port,
453                                  const struct condition_list *condition,                                      struct ccs_domain_info *domain,
454                                  const bool is_delete)                                      struct ccs_condition *condition,
455                                        const bool is_delete)
456  {  {
457          struct acl_info *ptr;          struct ccs_ip_network_acl_record *entry = NULL;
458          struct ip_network_acl_record *acl;          struct ccs_acl_info *ptr;
459          int error = -ENOMEM;          int error = is_delete ? -ENOENT : -ENOMEM;
460          /* using host byte order to allow u32 comparison than memcmp().*/          /* using host byte order to allow u32 comparison than memcmp().*/
461          const u32 min_ip = ntohl(*min_address);          const u32 min_ip = ntohl(*min_address);
462          const u32 max_ip = ntohl(*max_address);          const u32 max_ip = ntohl(*max_address);
463          const struct in6_addr *saved_min_address = NULL;          const struct in6_addr *saved_min_address = NULL;
464          const struct in6_addr *saved_max_address = NULL;          const struct in6_addr *saved_max_address = NULL;
465            struct ccs_address_group_entry *group = NULL;
466          if (!domain)          if (!domain)
467                  return -EINVAL;                  return -EINVAL;
468          if (record_type != IP_RECORD_TYPE_IPv6)          if (group_name) {
469                  goto not_ipv6;                  group = ccs_get_address_group(group_name);
470          saved_min_address = save_ipv6_address((struct in6_addr *) min_address);                  if (!group)
471          saved_max_address = save_ipv6_address((struct in6_addr *) max_address);                          return -ENOMEM;
472          if (!saved_min_address || !saved_max_address)          } else if (record_type == IP_RECORD_TYPE_IPv6) {
473                  return -ENOMEM;                  saved_min_address = ccs_get_ipv6_address((struct in6_addr *)
474   not_ipv6:                                                           min_address);
475          mutex_lock(&domain_acl_lock);                  saved_max_address = ccs_get_ipv6_address((struct in6_addr *)
476                                                             max_address);
477                    if (!saved_min_address || !saved_max_address)
478                            goto out;
479            }
480          if (is_delete)          if (is_delete)
481                  goto delete;                  goto delete;
482          list1_for_each_entry(ptr, &domain->acl_info_list, list) {          entry = kzalloc(sizeof(*entry), GFP_KERNEL);
483            mutex_lock(&ccs_policy_lock);
484            list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
485                    struct ccs_ip_network_acl_record *acl;
486                  if (ccs_acl_type1(ptr) != TYPE_IP_NETWORK_ACL)                  if (ccs_acl_type1(ptr) != TYPE_IP_NETWORK_ACL)
487                          continue;                          continue;
488                  if (ccs_get_condition_part(ptr) != condition)                  if (ptr->cond != condition)
489                          continue;                          continue;
490                  acl = container_of(ptr, struct ip_network_acl_record, head);                  acl = container_of(ptr, struct ccs_ip_network_acl_record, head);
491                  if (acl->operation_type != operation ||                  if (acl->operation_type != operation ||
492                      acl->record_type != record_type ||                      acl->record_type != record_type ||
493                      acl->min_port != min_port || max_port != acl->max_port)                      acl->min_port != min_port || max_port != acl->max_port)
# Line 513  static int update_network_entry(const u8 Line 505  static int update_network_entry(const u8
505                                  continue;                                  continue;
506                  }                  }
507                  error = ccs_add_domain_acl(NULL, ptr);                  error = ccs_add_domain_acl(NULL, ptr);
508                  goto out;                  break;
509          }          }
510          /* Not found. Append it to the tail. */          if (error && ccs_memory_ok(entry, sizeof(*entry))) {
511          acl = ccs_alloc_acl_element(TYPE_IP_NETWORK_ACL, condition);                  entry->head.type = TYPE_IP_NETWORK_ACL;
512          if (!acl)                  entry->head.cond = condition;
513                  goto out;                  entry->operation_type = operation;
514          acl->operation_type = operation;                  entry->record_type = record_type;
515          acl->record_type = record_type;                  if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {
516          if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {                          entry->u.group = group;
517                  acl->u.group = group;                          group = NULL;
518          } else if (record_type == IP_RECORD_TYPE_IPv4) {                  } else if (record_type == IP_RECORD_TYPE_IPv4) {
519                  acl->u.ipv4.min = min_ip;                          entry->u.ipv4.min = min_ip;
520                  acl->u.ipv4.max = max_ip;                          entry->u.ipv4.max = max_ip;
521          } else {                  } else {
522                  acl->u.ipv6.min = saved_min_address;                          entry->u.ipv6.min = saved_min_address;
523                  acl->u.ipv6.max = saved_max_address;                          saved_min_address = NULL;
524          }                          entry->u.ipv6.max = saved_max_address;
525          acl->min_port = min_port;                          saved_max_address = NULL;
526          acl->max_port = max_port;                  }
527          error = ccs_add_domain_acl(domain, &acl->head);                  entry->min_port = min_port;
528                    entry->max_port = max_port;
529                    error = ccs_add_domain_acl(domain, &entry->head);
530                    entry = NULL;
531            }
532            mutex_unlock(&ccs_policy_lock);
533          goto out;          goto out;
534   delete:   delete:
535          error = -ENOENT;          mutex_lock(&ccs_policy_lock);
536          list1_for_each_entry(ptr, &domain->acl_info_list, list) {          list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
537                    struct ccs_ip_network_acl_record *acl;
538                  if (ccs_acl_type2(ptr) != TYPE_IP_NETWORK_ACL)                  if (ccs_acl_type2(ptr) != TYPE_IP_NETWORK_ACL)
539                          continue;                          continue;
540                  if (ccs_get_condition_part(ptr) != condition)                  if (ptr->cond != condition)
541                          continue;                          continue;
542                  acl = container_of(ptr, struct ip_network_acl_record, head);                  acl = container_of(ptr, struct ccs_ip_network_acl_record, head);
543                  if (acl->operation_type != operation ||                  if (acl->operation_type != operation ||
544                      acl->record_type != record_type ||                      acl->record_type != record_type ||
545                      acl->min_port != min_port || max_port != acl->max_port)                      acl->min_port != min_port || max_port != acl->max_port)
# Line 561  static int update_network_entry(const u8 Line 559  static int update_network_entry(const u8
559                  error = ccs_del_domain_acl(ptr);                  error = ccs_del_domain_acl(ptr);
560                  break;                  break;
561          }          }
562            mutex_unlock(&ccs_policy_lock);
563   out:   out:
564          mutex_unlock(&domain_acl_lock);          ccs_put_ipv6_address(saved_min_address);
565            ccs_put_ipv6_address(saved_max_address);
566            ccs_put_address_group(group);
567            kfree(entry);
568          return error;          return error;
569  }  }
570    
571  /**  /**
572   * check_network_entry - Check permission for network operation.   * ccs_check_network_entry2 - Check permission for network operation.
573   *   *
574   * @is_ipv6:   True if @address is an IPv6 address.   * @is_ipv6:   True if @address is an IPv6 address.
575   * @operation: Type of operation.   * @operation: Type of operation.
# Line 575  static int update_network_entry(const u8 Line 577  static int update_network_entry(const u8
577   * @port:      Port number.   * @port:      Port number.
578   *   *
579   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
580     *
581     * Caller holds srcu_read_lock(&ccs_ss).
582   */   */
583  static int check_network_entry(const bool is_ipv6, const u8 operation,  static int ccs_check_network_entry2(const bool is_ipv6, const u8 operation,
584                                 const u32 *address, const u16 port)                                      const u32 *address, const u16 port)
585  {  {
586          struct domain_info * const domain = current->domain_info;          struct ccs_request_info r;
587          struct acl_info *ptr;          struct ccs_acl_info *ptr;
588          const char *keyword = ccs_net2keyword(operation);          const char *keyword = ccs_net2keyword(operation);
589          const u8 profile = current->domain_info->profile;          bool is_enforce;
         const u8 mode = ccs_check_flags(CCS_TOMOYO_MAC_FOR_NETWORK);  
         const bool is_enforce = (mode == 3);  
590          /* using host byte order to allow u32 comparison than memcmp().*/          /* using host byte order to allow u32 comparison than memcmp().*/
591          const u32 ip = ntohl(*address);          const u32 ip = ntohl(*address);
592          bool found = false;          bool found = false;
593          char buf[64];          char buf[64];
594          if (!mode)          if (!ccs_can_sleep())
595                  return 0;                  return 0;
596          list1_for_each_entry(ptr, &domain->acl_info_list, list) {          ccs_init_request_info(&r, NULL, CCS_MAC_FOR_NETWORK);
597                  struct ip_network_acl_record *acl;          is_enforce = (r.mode == 3);
598            if (!r.mode)
599                    return 0;
600     retry:
601            list_for_each_entry_rcu(ptr, &r.domain->acl_info_list, list) {
602                    struct ccs_ip_network_acl_record *acl;
603                  if (ccs_acl_type2(ptr) != TYPE_IP_NETWORK_ACL)                  if (ccs_acl_type2(ptr) != TYPE_IP_NETWORK_ACL)
604                          continue;                          continue;
605                  acl = container_of(ptr, struct ip_network_acl_record, head);                  acl = container_of(ptr, struct ccs_ip_network_acl_record, head);
606                  if (acl->operation_type != operation || port < acl->min_port ||                  if (acl->operation_type != operation || port < acl->min_port ||
607                      acl->max_port < port || !ccs_check_condition(ptr, NULL))                      acl->max_port < port || !ccs_check_condition(&r, ptr))
608                          continue;                          continue;
609                  if (acl->record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {                  if (acl->record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {
610                          if (!address_matches_to_group(is_ipv6, address,                          if (!ccs_address_matches_group(is_ipv6, address,
611                                                        acl->u.group))                                                         acl->u.group))
612                                  continue;                                  continue;
613                  } else if (acl->record_type == IP_RECORD_TYPE_IPv4) {                  } else if (acl->record_type == IP_RECORD_TYPE_IPv4) {
614                          if (is_ipv6 ||                          if (is_ipv6 ||
# Line 613  static int check_network_entry(const boo Line 620  static int check_network_entry(const boo
620                              memcmp(address, acl->u.ipv6.max, 16) > 0)                              memcmp(address, acl->u.ipv6.max, 16) > 0)
621                                  continue;                                  continue;
622                  }                  }
623                  ccs_update_condition(ptr);                  r.cond = ptr->cond;
624                  found = true;                  found = true;
625                  break;                  break;
626          }          }
# Line 623  static int check_network_entry(const boo Line 630  static int check_network_entry(const boo
630                                 (const struct in6_addr *) address);                                 (const struct in6_addr *) address);
631          else          else
632                  snprintf(buf, sizeof(buf) - 1, "%u.%u.%u.%u", HIPQUAD(ip));                  snprintf(buf, sizeof(buf) - 1, "%u.%u.%u.%u", HIPQUAD(ip));
633          audit_network_log(is_ipv6, keyword, buf, port, found, profile, mode);          ccs_audit_network_log(&r, keyword, buf, port, found);
634          if (found)          if (found)
635                  return 0;                  return 0;
636          if (ccs_verbose_mode())          if (ccs_verbose_mode(r.domain))
637                  printk(KERN_WARNING "TOMOYO-%s: %s to %s %u denied for %s\n",                  printk(KERN_WARNING "TOMOYO-%s: %s to %s %u denied for %s\n",
638                         ccs_get_msg(is_enforce), keyword, buf, port,                         ccs_get_msg(is_enforce), keyword, buf, port,
639                         ccs_get_last_name(domain));                         ccs_get_last_name(r.domain));
640          if (is_enforce)          if (is_enforce) {
641                  return ccs_check_supervisor("%s\n" KEYWORD_ALLOW_NETWORK "%s "                  int err = ccs_check_supervisor(&r, KEYWORD_ALLOW_NETWORK
642                                              "%s %u\n", domain->domainname->name,                                                 "%s %s %u\n", keyword, buf,
643                                              keyword, buf, port);                                                 port);
644          if (mode == 1 && ccs_check_domain_quota(domain))                  if (err == 1)
645                  update_network_entry(operation, is_ipv6 ?                          goto retry;
646                                       IP_RECORD_TYPE_IPv6 : IP_RECORD_TYPE_IPv4,                  return err;
647                                       NULL, address, address, port, port, domain,          }
648                                       NULL, 0);          if (r.mode == 1 && ccs_domain_quota_ok(r.domain)) {
649                    struct ccs_condition *cond = ccs_handler_cond();
650                    ccs_update_network_entry(operation, is_ipv6 ?
651                                             IP_RECORD_TYPE_IPv6 :
652                                             IP_RECORD_TYPE_IPv4,
653                                             NULL, address, address, port, port,
654                                             r.domain, cond, false);
655                    ccs_put_condition(cond);
656            }
657          return 0;          return 0;
658  }  }
659    
660  /**  /**
661   * ccs_write_network_policy - Write "struct ip_network_acl_record" list.   * ccs_check_network_entry - Check permission for network operation.
662     *
663     * @is_ipv6:   True if @address is an IPv6 address.
664     * @operation: Type of operation.
665     * @address:   An IPv4 or IPv6 address.
666     * @port:      Port number.
667     *
668     * Returns 0 on success, negative value otherwise.
669     */
670    static int ccs_check_network_entry(const bool is_ipv6, const u8 operation,
671                                       const u32 *address, const u16 port)
672    {
673            const int idx = srcu_read_lock(&ccs_ss);
674            const int error = ccs_check_network_entry2(is_ipv6, operation,
675                                                       address, port);
676            srcu_read_unlock(&ccs_ss, idx);
677            return error;
678    }
679    
680    /**
681     * ccs_write_network_policy - Write "struct ccs_ip_network_acl_record" list.
682   *   *
683   * @data:      String to parse.   * @data:      String to parse.
684   * @domain:    Pointer to "struct domain_info".   * @domain:    Pointer to "struct ccs_domain_info".
685   * @condition: Pointer to "struct condition_list". May be NULL.   * @condition: Pointer to "struct ccs_condition". May be NULL.
686   * @is_delete: True if it is a delete request.   * @is_delete: True if it is a delete request.
687   *   *
688   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
689   */   */
690  int ccs_write_network_policy(char *data, struct domain_info *domain,  int ccs_write_network_policy(char *data, struct ccs_domain_info *domain,
691                               const struct condition_list *condition,                               struct ccs_condition *condition,
692                               const bool is_delete)                               const bool is_delete)
693  {  {
694          u8 sock_type;          u8 sock_type;
# Line 661  int ccs_write_network_policy(char *data, Line 696  int ccs_write_network_policy(char *data,
696          u8 record_type;          u8 record_type;
697          u16 min_address[8];          u16 min_address[8];
698          u16 max_address[8];          u16 max_address[8];
699          struct address_group_entry *group = NULL;          const char *group_name = NULL;
700          u16 min_port;          u16 min_port;
701          u16 max_port;          u16 max_port;
702          u8 count;          u8 count;
# Line 714  int ccs_write_network_policy(char *data, Line 749  int ccs_write_network_policy(char *data,
749          if (!cp1)          if (!cp1)
750                  goto out;                  goto out;
751          *cp1++ = '\0';          *cp1++ = '\0';
752          count = sscanf(cp2, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx"          switch (ccs_parse_ip_address(cp2, min_address, max_address)) {
753                         "-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",          case 2:
                        &min_address[0], &min_address[1],  
                        &min_address[2], &min_address[3],  
                        &min_address[4], &min_address[5],  
                        &min_address[6], &min_address[7],  
                        &max_address[0], &max_address[1],  
                        &max_address[2], &max_address[3],  
                        &max_address[4], &max_address[5],  
                        &max_address[6], &max_address[7]);  
         if (count == 8 || count == 16) {  
                 u8 i;  
                 for (i = 0; i < 8; i++) {  
                         min_address[i] = htons(min_address[i]);  
                         max_address[i] = htons(max_address[i]);  
                 }  
                 if (count == 8)  
                         memmove(max_address, min_address, sizeof(min_address));  
754                  record_type = IP_RECORD_TYPE_IPv6;                  record_type = IP_RECORD_TYPE_IPv6;
755                  goto ok;                  break;
756          }          case 1:
         count = sscanf(cp2, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",  
                        &min_address[0], &min_address[1],  
                        &min_address[2], &min_address[3],  
                        &max_address[0], &max_address[1],  
                        &max_address[2], &max_address[3]);  
         if (count == 4 || count == 8) {  
                 u32 ip = htonl((((u8) min_address[0]) << 24)  
                                + (((u8) min_address[1]) << 16)  
                                + (((u8) min_address[2]) << 8)  
                                + (u8) min_address[3]);  
                 *(u32 *) min_address = ip;  
                 if (count == 8)  
                         ip = htonl((((u8) max_address[0]) << 24)  
                                    + (((u8) max_address[1]) << 16)  
                                    + (((u8) max_address[2]) << 8)  
                                    + (u8) max_address[3]);  
                 *(u32 *) max_address = ip;  
757                  record_type = IP_RECORD_TYPE_IPv4;                  record_type = IP_RECORD_TYPE_IPv4;
758                  goto ok;                  break;
759          }          default:
760          if (*cp2 == '@') {                  if (*cp2 != '@')
761                  group = find_or_assign_new_address_group(cp2 + 1);                          goto out;
762                  if (!group)                  group_name = cp2 + 1;
                         return -ENOMEM;  
763                  record_type = IP_RECORD_TYPE_ADDRESS_GROUP;                  record_type = IP_RECORD_TYPE_ADDRESS_GROUP;
764                  goto ok;                  break;
765          }          }
  out:  
         return -EINVAL;  
  ok:  
766          if (strchr(cp1, ' '))          if (strchr(cp1, ' '))
767                  goto out;                  goto out;
768          count = sscanf(cp1, "%hu-%hu", &min_port, &max_port);          count = sscanf(cp1, "%hu-%hu", &min_port, &max_port);
# Line 772  int ccs_write_network_policy(char *data, Line 770  int ccs_write_network_policy(char *data,
770                  goto out;                  goto out;
771          if (count == 1)          if (count == 1)
772                  max_port = min_port;                  max_port = min_port;
773          return update_network_entry(operation, record_type, group,          return ccs_update_network_entry(operation, record_type, group_name,
774                                      (u32 *) min_address, (u32 *) max_address,                                          (u32 *) min_address,
775                                      min_port, max_port, domain, condition,                                          (u32 *) max_address,
776                                      is_delete);                                          min_port, max_port, domain, condition,
777                                            is_delete);
778     out:
779            return -EINVAL;
780  }  }
781    
782  /**  /**
# Line 787  int ccs_write_network_policy(char *data, Line 788  int ccs_write_network_policy(char *data,
788   *   *
789   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
790   */   */
791  int ccs_check_network_listen_acl(const _Bool is_ipv6, const u8 *address,  static inline int ccs_check_network_listen_acl(const bool is_ipv6,
792                                   const u16 port)                                                 const u8 *address,
793                                                   const u16 port)
794  {  {
795          return check_network_entry(is_ipv6, NETWORK_ACL_TCP_LISTEN,          return ccs_check_network_entry(is_ipv6, NETWORK_ACL_TCP_LISTEN,
796                                     (const u32 *) address, ntohs(port));                                         (const u32 *) address, ntohs(port));
797  }  }
798    
799  /**  /**
# Line 804  int ccs_check_network_listen_acl(const _ Line 806  int ccs_check_network_listen_acl(const _
806   *   *
807   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
808   */   */
809  int ccs_check_network_connect_acl(const _Bool is_ipv6, const int sock_type,  static inline int ccs_check_network_connect_acl(const bool is_ipv6,
810                                    const u8 *address, const u16 port)                                                  const int sock_type,
811                                                    const u8 *address,
812                                                    const u16 port)
813  {  {
814          u8 operation;          u8 operation;
815          switch (sock_type) {          switch (sock_type) {
# Line 818  int ccs_check_network_connect_acl(const Line 822  int ccs_check_network_connect_acl(const
822          default:          default:
823                  operation = NETWORK_ACL_RAW_CONNECT;                  operation = NETWORK_ACL_RAW_CONNECT;
824          }          }
825          return check_network_entry(is_ipv6, operation, (const u32 *) address,          return ccs_check_network_entry(is_ipv6, operation,
826                                     ntohs(port));                                         (const u32 *) address, ntohs(port));
827  }  }
828    
829  /**  /**
# Line 832  int ccs_check_network_connect_acl(const Line 836  int ccs_check_network_connect_acl(const
836   *   *
837   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
838   */   */
839  int ccs_check_network_bind_acl(const _Bool is_ipv6, const int sock_type,  static int ccs_check_network_bind_acl(const bool is_ipv6, const int sock_type,
840                                 const u8 *address, const u16 port)                                        const u8 *address, const u16 port)
841  {  {
842          u8 operation;          u8 operation;
843          switch (sock_type) {          switch (sock_type) {
# Line 846  int ccs_check_network_bind_acl(const _Bo Line 850  int ccs_check_network_bind_acl(const _Bo
850          default:          default:
851                  operation = NETWORK_ACL_RAW_BIND;                  operation = NETWORK_ACL_RAW_BIND;
852          }          }
853          return check_network_entry(is_ipv6, operation, (const u32 *) address,          return ccs_check_network_entry(is_ipv6, operation,
854                                     ntohs(port));                                         (const u32 *) address, ntohs(port));
855  }  }
856    
857  /**  /**
# Line 859  int ccs_check_network_bind_acl(const _Bo Line 863  int ccs_check_network_bind_acl(const _Bo
863   *   *
864   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
865   */   */
866  int ccs_check_network_accept_acl(const _Bool is_ipv6, const u8 *address,  static inline int ccs_check_network_accept_acl(const bool is_ipv6,
867                                   const u16 port)                                                 const u8 *address,
868                                                   const u16 port)
869  {  {
870          int retval;          int retval;
871          current->tomoyo_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;          current->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
872          retval = check_network_entry(is_ipv6, NETWORK_ACL_TCP_ACCEPT,          retval = ccs_check_network_entry(is_ipv6, NETWORK_ACL_TCP_ACCEPT,
873                                       (const u32 *) address, ntohs(port));                                           (const u32 *) address, ntohs(port));
874          current->tomoyo_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;          current->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
875          return retval;          return retval;
876  }  }
877    
# Line 880  int ccs_check_network_accept_acl(const _ Line 885  int ccs_check_network_accept_acl(const _
885   *   *
886   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
887   */   */
888  int ccs_check_network_sendmsg_acl(const _Bool is_ipv6, const int sock_type,  static inline int ccs_check_network_sendmsg_acl(const bool is_ipv6,
889                                    const u8 *address, const u16 port)                                                  const int sock_type,
890                                                    const u8 *address,
891                                                    const u16 port)
892  {  {
893          u8 operation;          u8 operation;
894          if (sock_type == SOCK_DGRAM)          if (sock_type == SOCK_DGRAM)
895                  operation = NETWORK_ACL_UDP_CONNECT;                  operation = NETWORK_ACL_UDP_CONNECT;
896          else          else
897                  operation = NETWORK_ACL_RAW_CONNECT;                  operation = NETWORK_ACL_RAW_CONNECT;
898          return check_network_entry(is_ipv6, operation, (const u32 *) address,          return ccs_check_network_entry(is_ipv6, operation,
899                                     ntohs(port));                                         (const u32 *) address, ntohs(port));
900  }  }
901    
902  /**  /**
# Line 902  int ccs_check_network_sendmsg_acl(const Line 909  int ccs_check_network_sendmsg_acl(const
909   *   *
910   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
911   */   */
912  int ccs_check_network_recvmsg_acl(const _Bool is_ipv6, const int sock_type,  static inline int ccs_check_network_recvmsg_acl(const bool is_ipv6,
913                                    const u8 *address, const u16 port)                                                  const int sock_type,
914                                                    const u8 *address,
915                                                    const u16 port)
916  {  {
917          int retval;          int retval;
918          const u8 operation          const u8 operation
919                  = (sock_type == SOCK_DGRAM) ?                  = (sock_type == SOCK_DGRAM) ?
920                  NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT;                  NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT;
921          current->tomoyo_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;          current->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
922          retval = check_network_entry(is_ipv6, operation, (const u32 *) address,          retval = ccs_check_network_entry(is_ipv6, operation,
923                                       ntohs(port));                                           (const u32 *) address, ntohs(port));
924          current->tomoyo_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;          current->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
925          return retval;          return retval;
926  }  }
927    
928    #define MAX_SOCK_ADDR 128 /* net/socket.c */
929    
930    /* Check permission for creating a socket. */
931    int ccs_socket_create_permission(int family, int type, int protocol)
932    {
933            int error = 0;
934            /* Nothing to do if I am a kernel service. */
935            if (segment_eq(get_fs(), KERNEL_DS))
936                    return 0;
937            if (family == PF_PACKET && !ccs_capable(CCS_USE_PACKET_SOCKET))
938                    return -EPERM;
939            if (family == PF_ROUTE && !ccs_capable(CCS_USE_ROUTE_SOCKET))
940                    return -EPERM;
941            if (family != PF_INET && family != PF_INET6)
942                    return 0;
943            switch (type) {
944            case SOCK_STREAM:
945                    if (!ccs_capable(CCS_INET_STREAM_SOCKET_CREATE))
946                            error = -EPERM;
947                    break;
948            case SOCK_DGRAM:
949                    if (!ccs_capable(CCS_USE_INET_DGRAM_SOCKET))
950                            error = -EPERM;
951                    break;
952            case SOCK_RAW:
953                    if (!ccs_capable(CCS_USE_INET_RAW_SOCKET))
954                            error = -EPERM;
955                    break;
956            }
957            return error;
958    }
959    
960    /* Check permission for listening a TCP socket. */
961    int ccs_socket_listen_permission(struct socket *sock)
962    {
963            int error = 0;
964            char addr[MAX_SOCK_ADDR];
965            int addr_len;
966            /* Nothing to do if I am a kernel service. */
967            if (segment_eq(get_fs(), KERNEL_DS))
968                    return 0;
969            if (sock->type != SOCK_STREAM)
970                    return 0;
971            switch (sock->sk->sk_family) {
972            case PF_INET:
973            case PF_INET6:
974                    break;
975            default:
976                    return 0;
977            }
978            if (!ccs_capable(CCS_INET_STREAM_SOCKET_LISTEN))
979                    return -EPERM;
980            if (sock->ops->getname(sock, (struct sockaddr *) addr, &addr_len, 0))
981                    return -EPERM;
982            switch (((struct sockaddr *) addr)->sa_family) {
983                    struct sockaddr_in6 *addr6;
984                    struct sockaddr_in *addr4;
985            case AF_INET6:
986                    addr6 = (struct sockaddr_in6 *) addr;
987                    error = ccs_check_network_listen_acl(true,
988                                                         addr6->sin6_addr.s6_addr,
989                                                         addr6->sin6_port);
990                    break;
991            case AF_INET:
992                    addr4 = (struct sockaddr_in *) addr;
993                    error = ccs_check_network_listen_acl(false,
994                                                         (u8 *) &addr4->sin_addr,
995                                                         addr4->sin_port);
996                    break;
997            }
998            return error;
999    }
1000    
1001    /* Check permission for setting the remote IP address/port pair of a socket. */
1002    int ccs_socket_connect_permission(struct socket *sock, struct sockaddr *addr,
1003                                      int addr_len)
1004    {
1005            int error = 0;
1006            const unsigned int type = sock->type;
1007            /* Nothing to do if I am a kernel service. */
1008            if (segment_eq(get_fs(), KERNEL_DS))
1009                    return 0;
1010            switch (type) {
1011            case SOCK_STREAM:
1012            case SOCK_DGRAM:
1013            case SOCK_RAW:
1014                    break;
1015            default:
1016                    return 0;
1017            }
1018            switch (addr->sa_family) {
1019                    struct sockaddr_in6 *addr6;
1020                    struct sockaddr_in *addr4;
1021                    u16 port;
1022            case AF_INET6:
1023                    if (addr_len < SIN6_LEN_RFC2133)
1024                            break;
1025                    addr6 = (struct sockaddr_in6 *) addr;
1026                    if (type != SOCK_RAW)
1027                            port = addr6->sin6_port;
1028                    else
1029                            port = htons(sock->sk->sk_protocol);
1030                    error = ccs_check_network_connect_acl(true, type,
1031                                                          addr6->sin6_addr.s6_addr,
1032                                                          port);
1033                    break;
1034            case AF_INET:
1035                    if (addr_len < sizeof(struct sockaddr_in))
1036                            break;
1037                    addr4 = (struct sockaddr_in *) addr;
1038                    if (type != SOCK_RAW)
1039                            port = addr4->sin_port;
1040                    else
1041                            port = htons(sock->sk->sk_protocol);
1042                    error = ccs_check_network_connect_acl(false, type,
1043                                                          (u8 *) &addr4->sin_addr,
1044                                                          port);
1045                    break;
1046            }
1047            if (type != SOCK_STREAM)
1048                    return error;
1049            switch (sock->sk->sk_family) {
1050            case PF_INET:
1051            case PF_INET6:
1052                    if (!ccs_capable(CCS_INET_STREAM_SOCKET_CONNECT))
1053                            error = -EPERM;
1054                    break;
1055            }
1056            return error;
1057    }
1058    
1059    /* Check permission for setting the local IP address/port pair of a socket. */
1060    int ccs_socket_bind_permission(struct socket *sock, struct sockaddr *addr,
1061                                   int addr_len)
1062    {
1063            int error = 0;
1064            const unsigned int type = sock->type;
1065            /* Nothing to do if I am a kernel service. */
1066            if (segment_eq(get_fs(), KERNEL_DS))
1067                    return 0;
1068            switch (type) {
1069            case SOCK_STREAM:
1070            case SOCK_DGRAM:
1071            case SOCK_RAW:
1072                    break;
1073            default:
1074                    return 0;
1075            }
1076            switch (addr->sa_family) {
1077                    struct sockaddr_in6 *addr6;
1078                    struct sockaddr_in *addr4;
1079                    u16 port;
1080            case AF_INET6:
1081                    if (addr_len < SIN6_LEN_RFC2133)
1082                            break;
1083                    addr6 = (struct sockaddr_in6 *) addr;
1084                    if (type != SOCK_RAW)
1085                            port = addr6->sin6_port;
1086                    else
1087                            port = htons(sock->sk->sk_protocol);
1088                    error = ccs_check_network_bind_acl(true, type,
1089                                                       addr6->sin6_addr.s6_addr,
1090                                                       port);
1091                    break;
1092            case AF_INET:
1093                    if (addr_len < sizeof(struct sockaddr_in))
1094                            break;
1095                    addr4 = (struct sockaddr_in *) addr;
1096                    if (type != SOCK_RAW)
1097                            port = addr4->sin_port;
1098                    else
1099                            port = htons(sock->sk->sk_protocol);
1100                    error = ccs_check_network_bind_acl(false, type,
1101                                                       (u8 *) &addr4->sin_addr,
1102                                                       port);
1103                    break;
1104            }
1105            return error;
1106    }
1107    
1108    /*
1109     * Check permission for accepting a TCP socket.
1110     *
1111     * Currently, the LSM hook for this purpose is not provided.
1112     */
1113    int ccs_socket_accept_permission(struct socket *sock, struct sockaddr *addr)
1114    {
1115            int error = 0;
1116            int addr_len;
1117            /* Nothing to do if I am a kernel service. */
1118            if (segment_eq(get_fs(), KERNEL_DS))
1119                    return 0;
1120            switch (sock->sk->sk_family) {
1121            case PF_INET:
1122            case PF_INET6:
1123                    break;
1124            default:
1125                    return 0;
1126            }
1127            error = sock->ops->getname(sock, addr, &addr_len, 2);
1128            if (error)
1129                    return error;
1130            switch (addr->sa_family) {
1131                    struct sockaddr_in6 *addr6;
1132                    struct sockaddr_in *addr4;
1133            case AF_INET6:
1134                    addr6 = (struct sockaddr_in6 *) addr;
1135                    error = ccs_check_network_accept_acl(true,
1136                                                         addr6->sin6_addr.s6_addr,
1137                                                         addr6->sin6_port);
1138                    break;
1139            case AF_INET:
1140                    addr4 = (struct sockaddr_in *) addr;
1141                    error = ccs_check_network_accept_acl(false,
1142                                                         (u8 *) &addr4->sin_addr,
1143                                                         addr4->sin_port);
1144                    break;
1145            }
1146            return error;
1147    }
1148    
1149    /* Check permission for sending a datagram via a UDP or RAW socket. */
1150    int ccs_socket_sendmsg_permission(struct socket *sock, struct sockaddr *addr,
1151                                      int addr_len)
1152    {
1153            int error = 0;
1154            const int type = sock->type;
1155            /* Nothing to do if I am a kernel service. */
1156            if (segment_eq(get_fs(), KERNEL_DS))
1157                    return 0;
1158            if (!addr || (type != SOCK_DGRAM && type != SOCK_RAW))
1159                    return 0;
1160            switch (addr->sa_family) {
1161                    struct sockaddr_in6 *addr6;
1162                    struct sockaddr_in *addr4;
1163                    u16 port;
1164            case AF_INET6:
1165                    if (addr_len < SIN6_LEN_RFC2133)
1166                            break;
1167                    addr6 = (struct sockaddr_in6 *) addr;
1168                    if (type == SOCK_DGRAM)
1169                            port = addr6->sin6_port;
1170                    else
1171                            port = htons(sock->sk->sk_protocol);
1172                    error = ccs_check_network_sendmsg_acl(true, type,
1173                                                          addr6->sin6_addr.s6_addr,
1174                                                          port);
1175                    break;
1176            case AF_INET:
1177                    if (addr_len < sizeof(struct sockaddr_in))
1178                            break;
1179                    addr4 = (struct sockaddr_in *) addr;
1180                    if (type == SOCK_DGRAM)
1181                            port = addr4->sin_port;
1182                    else
1183                            port = htons(sock->sk->sk_protocol);
1184                    error = ccs_check_network_sendmsg_acl(false, type,
1185                                                          (u8 *) &addr4->sin_addr,
1186                                                          port);
1187                    break;
1188            }
1189            return error;
1190    }
1191    
1192    #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
1193    #if !defined(RHEL_MAJOR) || RHEL_MAJOR != 5
1194    
1195    static inline struct iphdr *ip_hdr(const struct sk_buff *skb)
1196    {
1197            return skb->nh.iph;
1198    }
1199    
1200    static inline struct udphdr *udp_hdr(const struct sk_buff *skb)
1201    {
1202            return skb->h.uh;
1203    }
1204    
1205    static inline struct ipv6hdr *ipv6_hdr(const struct sk_buff *skb)
1206    {
1207            return skb->nh.ipv6h;
1208    }
1209    
1210    #endif
1211    #endif
1212    
1213    #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)
1214    static void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
1215                                  unsigned int flags)
1216    {
1217            /* Clear queue. */
1218            if (flags & MSG_PEEK) {
1219                    int clear = 0;
1220                    spin_lock_irq(&sk->sk_receive_queue.lock);
1221                    if (skb == skb_peek(&sk->sk_receive_queue)) {
1222                            __skb_unlink(skb, &sk->sk_receive_queue);
1223                            clear = 1;
1224                    }
1225                    spin_unlock_irq(&sk->sk_receive_queue.lock);
1226                    if (clear)
1227                            kfree_skb(skb);
1228            }
1229            skb_free_datagram(sk, skb);
1230    }
1231    #elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
1232    static void skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
1233                                  unsigned int flags)
1234    {
1235            /* Clear queue. */
1236            if (flags & MSG_PEEK) {
1237                    int clear = 0;
1238                    spin_lock_bh(&sk->sk_receive_queue.lock);
1239                    if (skb == skb_peek(&sk->sk_receive_queue)) {
1240                            __skb_unlink(skb, &sk->sk_receive_queue);
1241                            clear = 1;
1242                    }
1243                    spin_unlock_bh(&sk->sk_receive_queue.lock);
1244                    if (clear)
1245                            kfree_skb(skb);
1246            }
1247            skb_free_datagram(sk, skb);
1248    }
1249    #endif
1250    
1251    /*
1252     * Check permission for receiving a datagram via a UDP or RAW socket.
1253     *
1254     * Currently, the LSM hook for this purpose is not provided.
1255     */
1256    int ccs_socket_recvmsg_permission(struct sock *sk, struct sk_buff *skb,
1257                                      const unsigned int flags)
1258    {
1259            int error = 0;
1260            const unsigned int type = sk->sk_type;
1261            if (type != SOCK_DGRAM && type != SOCK_RAW)
1262                    return 0;
1263            /* Nothing to do if I am a kernel service. */
1264            if (segment_eq(get_fs(), KERNEL_DS))
1265                    return 0;
1266    
1267            switch (sk->sk_family) {
1268                    struct in6_addr sin6;
1269                    struct in_addr sin4;
1270                    u16 port;
1271            case PF_INET6:
1272                    if (type == SOCK_DGRAM) { /* UDP IPv6 */
1273                            if (skb->protocol == htons(ETH_P_IP)) {
1274                                    ipv6_addr_set(&sin6, 0, 0, htonl(0xffff),
1275                                                  ip_hdr(skb)->saddr);
1276                            } else {
1277                                    ipv6_addr_copy(&sin6, &ipv6_hdr(skb)->saddr);
1278                            }
1279                            port = udp_hdr(skb)->source;
1280                    } else { /* RAW IPv6 */
1281                            ipv6_addr_copy(&sin6, &ipv6_hdr(skb)->saddr);
1282                            port = htons(sk->sk_protocol);
1283                    }
1284                    error = ccs_check_network_recvmsg_acl(true, type,
1285                                                          (u8 *) &sin6, port);
1286                    break;
1287            case PF_INET:
1288                    if (type == SOCK_DGRAM) { /* UDP IPv4 */
1289                            sin4.s_addr = ip_hdr(skb)->saddr;
1290                            port = udp_hdr(skb)->source;
1291                    } else { /* RAW IPv4 */
1292                            sin4.s_addr = ip_hdr(skb)->saddr;
1293                            port = htons(sk->sk_protocol);
1294                    }
1295                    error = ccs_check_network_recvmsg_acl(false, type,
1296                                                          (u8 *) &sin4, port);
1297                    break;
1298            }
1299            if (!error)
1300                    return 0;
1301            /*
1302             * Remove from queue if MSG_PEEK is used so that
1303             * the head message from unwanted source in receive queue will not
1304             * prevent the caller from picking up next message from wanted source
1305             * when the caller is using MSG_PEEK flag for picking up.
1306             */
1307    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
1308            if (type == SOCK_DGRAM)
1309                    lock_sock(sk);
1310    #endif
1311            skb_kill_datagram(sk, skb, flags);
1312    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
1313            if (type == SOCK_DGRAM)
1314                    release_sock(sk);
1315    #endif
1316            /* Hope less harmful than -EPERM. */
1317            return -ENOMEM;
1318    }
1319    EXPORT_SYMBOL(ccs_socket_recvmsg_permission);
Legend:
Removed from v.1135  
changed lines
  Added in v.2727
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ