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

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