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

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.5.x/ccs-patch/fs/tomoyo_network.c revision 808 by kumaneko, Mon Dec 17 04:06:21 2007 UTC branches/ccs-patch/security/ccsecurity/network.c revision 3825 by kumaneko, Sun Jul 18 06:37:11 2010 UTC
# Line 1  Line 1 
1  /*  /*
2   * fs/tomoyo_network.c   * security/ccsecurity/network.c
3   *   *
4   * Implementation of the Domain-Based Mandatory Access Control.   * Copyright (C) 2005-2010  NTT DATA CORPORATION
5   *   *
6   * Copyright (C) 2005-2007  NTT DATA CORPORATION   * Version: 1.7.2+   2010/06/04
  *  
  * Version: 1.5.3-pre   2007/12/17  
7   *   *
8   * This file is applicable to both 2.4.30 and 2.6.11 and later.   * This file is applicable to both 2.4.30 and 2.6.11 and later.
9   * See README.ccs for ChangeLog.   * See README.ccs for ChangeLog.
10   *   *
11   */   */
 /***** TOMOYO Linux start. *****/  
12    
13  #include <linux/ccs_common.h>  #include <linux/net.h>
14  #include <linux/tomoyo.h>  #include <linux/inet.h>
15  #include <linux/realpath.h>  #include <linux/in.h>
16    #include <linux/in6.h>
17  #include <net/ip.h>  #include <net/ip.h>
18    #include <net/ipv6.h>
19    #include <net/udp.h>
20    #include "internal.h"
21    
22    const char *ccs_net_keyword[CCS_MAX_NETWORK_OPERATION] = {
23            [CCS_NETWORK_UDP_BIND] = "UDP bind",
24            [CCS_NETWORK_UDP_CONNECT] = "UDP connect",
25            [CCS_NETWORK_TCP_BIND] = "TCP bind",
26            [CCS_NETWORK_TCP_LISTEN] = "TCP listen",
27            [CCS_NETWORK_TCP_CONNECT] = "TCP connect",
28            [CCS_NETWORK_TCP_ACCEPT] = "TCP accept",
29            [CCS_NETWORK_RAW_BIND] = "RAW bind",
30            [CCS_NETWORK_RAW_CONNECT] = "RAW connect"
31    };
32    
33  /*************************  VARIABLES  *************************/  /**
34     * ccs_audit_network_log - Audit network log.
35  extern struct mutex domain_acl_lock;   *
36     * @r: Pointer to "struct ccs_request_info".
37  /*************************  AUDIT FUNCTIONS  *************************/   *
38     * Returns 0 on success, negative value otherwise.
39     */
40    static int ccs_audit_network_log(struct ccs_request_info *r)
41    {
42            char buf[128];
43            const char *operation = ccs_net_keyword[r->param.network.operation];
44            const u32 *address = r->param.network.address;
45            const u16 port = r->param.network.port;
46            if (r->param.network.is_ipv6)
47                    ccs_print_ipv6(buf, sizeof(buf), (const struct in6_addr *)
48                                   address, (const struct in6_addr *) address);
49            else
50                    ccs_print_ipv4(buf, sizeof(buf), r->param.network.ip,
51                                   r->param.network.ip);
52            ccs_write_log(r, "network %s %s %u\n", operation, buf, port);
53            if (r->granted)
54                    return 0;
55            ccs_warn_log(r, "network %s %s %u", operation, buf, port);
56            return ccs_supervisor(r, "network %s %s %u\n", operation, buf, port);
57    }
58    
59  static int AuditNetworkLog(const bool is_ipv6, const char *operation, const u32 *address, const u16 port, const bool is_granted)  /**
60     * ccs_parse_ip_address - Parse an IP address.
61     *
62     * @address: String to parse.
63     * @min:     Pointer to store min address.
64     * @max:     Pointer to store max address.
65     *
66     * Returns CCS_IP_ADDRESS_TYPE_IPv6 if @address is an IPv6,
67     * CCS_IP_ADDRESS_TYPE_IPv4 if @address is an IPv4,
68     * CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP otherwise.
69     */
70    int ccs_parse_ip_address(char *address, u16 *min, u16 *max)
71  {  {
72          char *buf;          int count = sscanf(address, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx"
73          int len = 256;                             "-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",
74          if (CanSaveAuditLog(is_granted) < 0) return -ENOMEM;                             &min[0], &min[1], &min[2], &min[3],
75          if ((buf = InitAuditLog(&len)) == NULL) return -ENOMEM;                             &min[4], &min[5], &min[6], &min[7],
76          snprintf(buf + strlen(buf), len - strlen(buf) - 1, KEYWORD_ALLOW_NETWORK "%s ", operation);                             &max[0], &max[1], &max[2], &max[3],
77          if (is_ipv6) {                             &max[4], &max[5], &max[6], &max[7]);
78                  print_ipv6(buf + strlen(buf), len - strlen(buf), (const struct in6_addr *) address);          if (count == 8 || count == 16) {
79          } else {                  u8 i;
80                  u32 ip = *address;                  if (count == 8)
81                  snprintf(buf + strlen(buf), len - strlen(buf) - 1, "%u.%u.%u.%u", NIPQUAD(ip));                          memmove(max, min, sizeof(u16) * 8);
82                    for (i = 0; i < 8; i++) {
83                            min[i] = htons(min[i]);
84                            max[i] = htons(max[i]);
85                    }
86                    return CCS_IP_ADDRESS_TYPE_IPv6;
87            }
88            count = sscanf(address, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",
89                           &min[0], &min[1], &min[2], &min[3],
90                           &max[0], &max[1], &max[2], &max[3]);
91            if (count == 4 || count == 8) {
92                    u32 ip = htonl((((u8) min[0]) << 24) + (((u8) min[1]) << 16)
93                                   + (((u8) min[2]) << 8) + (u8) min[3]);
94                    memmove(min, &ip, sizeof(ip));
95                    if (count == 8)
96                            ip = htonl((((u8) max[0]) << 24)
97                                       + (((u8) max[1]) << 16)
98                                       + (((u8) max[2]) << 8) + (u8) max[3]);
99                    memmove(max, &ip, sizeof(ip));
100                    return CCS_IP_ADDRESS_TYPE_IPv4;
101          }          }
102          snprintf(buf + strlen(buf), len - strlen(buf) - 1, " %u\n", port);          return CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP;
         return WriteAuditLog(buf, is_granted);  
103  }  }
104    
105  /*************************  UTILITY FUNCTIONS  *************************/  /**
106     * ccs_print_ipv4 - Print an IPv4 address.
107     *
108     * @buffer:     Buffer to write to.
109     * @buffer_len: Size of @buffer.
110     * @min_ip:     Min address in host byte order.
111     * @max_ip:     Max address in host byte order.
112     *
113     * Returns nothing.
114     */
115    void ccs_print_ipv4(char *buffer, const int buffer_len,
116                        const u32 min_ip, const u32 max_ip)
117    {
118            memset(buffer, 0, buffer_len);
119            snprintf(buffer, buffer_len - 1, "%u.%u.%u.%u%c%u.%u.%u.%u",
120                     HIPQUAD(min_ip), min_ip == max_ip ? '\0' : '-',
121                     HIPQUAD(max_ip));
122    }
123    
124    #if !defined(NIP6)
125    #define NIP6(addr)                                                      \
126            ntohs((addr).s6_addr16[0]), ntohs((addr).s6_addr16[1]),         \
127                    ntohs((addr).s6_addr16[2]), ntohs((addr).s6_addr16[3]), \
128                    ntohs((addr).s6_addr16[4]), ntohs((addr).s6_addr16[5]), \
129                    ntohs((addr).s6_addr16[6]), ntohs((addr).s6_addr16[7])
130    #endif
131    
132  /* Keep the given IPv6 address on the RAM. The RAM is shared, so NEVER try to modify or kfree() the returned address. */  /**
133  static const struct in6_addr *SaveIPv6Address(const struct in6_addr *addr)   * ccs_print_ipv6 - Print an IPv6 address.
134     *
135     * @buffer:     Buffer to write to.
136     * @buffer_len: Size of @buffer.
137     * @min_ip:     Pointer to "struct in6_addr".
138     * @max_ip:     Pointer to "struct in6_addr".
139     *
140     * Returns nothing.
141     */
142    void ccs_print_ipv6(char *buffer, const int buffer_len,
143                        const struct in6_addr *min_ip,
144                        const struct in6_addr *max_ip)
145  {  {
146          static const int block_size = 16;          memset(buffer, 0, buffer_len);
147          struct addr_list {          snprintf(buffer, buffer_len - 1,
148                  struct in6_addr addr[block_size];                   "%x:%x:%x:%x:%x:%x:%x:%x%c%x:%x:%x:%x:%x:%x:%x:%x",
149                  struct list1_head list;                   NIP6(*min_ip), min_ip == max_ip ? '\0' : '-',
150                  u32 in_use_count;                   NIP6(*max_ip));
151          };  }
152          static LIST1_HEAD(address_list);  
153          struct addr_list *ptr;  static bool ccs_check_network_acl(const struct ccs_request_info *r,
154          static DEFINE_MUTEX(lock);                                    const struct ccs_acl_info *ptr)
155          int i = block_size;  {
156          if (!addr) return NULL;          const struct ccs_ip_network_acl *acl =
157          mutex_lock(&lock);                  container_of(ptr, typeof(*acl), head);
158          list1_for_each_entry(ptr, &address_list, list) {          bool ret;
159                  for (i = 0; i < ptr->in_use_count; i++) {          if (!(acl->perm & (1 << r->param.network.operation)) ||
160                          if (memcmp(&ptr->addr[i], addr, sizeof(*addr)) == 0) goto ok;              !ccs_compare_number_union(r->param.network.port, &acl->port))
161                  }                  return false;
162                  if (i < block_size) break;          switch (acl->address_type) {
163          }          case CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP:
164          if (i == block_size) {                  ret = ccs_address_matches_group(r->param.network.is_ipv6,
165                  ptr = alloc_element(sizeof(*ptr));                                                  r->param.network.address,
166                  if (!ptr) goto ok;                                                  acl->address.group);
167                  list1_add_tail_mb(&ptr->list, &address_list);                  break;
168                  i = 0;          case CCS_IP_ADDRESS_TYPE_IPv4:
169          }                  ret = !r->param.network.is_ipv6 &&
170          ptr->addr[ptr->in_use_count++] = *addr;                          acl->address.ipv4.min <= r->param.network.ip &&
171  ok:                          r->param.network.ip <= acl->address.ipv4.max;
172          mutex_unlock(&lock);                  break;
173          return ptr ? &ptr->addr[i] : NULL;          default:
174  }                  ret = r->param.network.is_ipv6 &&
175                            memcmp(acl->address.ipv6.min, r->param.network.address,
176  /*************************  ADDRESS GROUP HANDLER  *************************/                                 16) <= 0 &&
177                            memcmp(r->param.network.address, acl->address.ipv6.max,
178  static LIST1_HEAD(address_group_list);                                 16) <= 0;
   
 static int AddAddressGroupEntry(const char *group_name, const bool is_ipv6, const u16 *min_address, const u16 *max_address, const bool is_delete)  
 {  
         static DEFINE_MUTEX(lock);  
         struct address_group_entry *new_group, *group;  
         struct address_group_member *new_member, *member;  
         const struct path_info *saved_group_name;  
         const struct in6_addr *saved_min_address = NULL, *saved_max_address = NULL;  
         int error = -ENOMEM;  
         bool found = 0;  
         if (!IsCorrectPath(group_name, 0, 0, 0, __FUNCTION__) || !group_name[0]) return -EINVAL;  
         if ((saved_group_name = SaveName(group_name)) == NULL) return -ENOMEM;  
         if (is_ipv6) {  
                 if ((saved_min_address = SaveIPv6Address((struct in6_addr *) min_address)) == NULL  
                     || (saved_max_address = SaveIPv6Address((struct in6_addr *) max_address)) == NULL) return -ENOMEM;  
         }  
         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;  
                         goto out;  
                 }  
                 found = 1;  
179                  break;                  break;
180          }          }
181          if (is_delete) {          return ret;
                 error = -ENOENT;  
                 goto out;  
         }  
         if (!found) {  
                 if ((new_group = alloc_element(sizeof(*new_group))) == NULL) goto out;  
                 INIT_LIST1_HEAD(&new_group->address_group_member_list);  
                 new_group->group_name = saved_group_name;  
                 list1_add_tail_mb(&new_group->list, &address_group_list);  
                 group = new_group;  
         }  
         if ((new_member = alloc_element(sizeof(*new_member))) == NULL) 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;  
         }  
         list1_add_tail_mb(&new_member->list, &group->address_group_member_list);  
         error = 0;  
  out:  
         mutex_unlock(&lock);  
         return error;  
182  }  }
183    
184  int AddAddressGroupPolicy(char *data, const bool is_delete)  /**
185     * ccs_network_entry - Check permission for network operation.
186     *
187     * @is_ipv6:   True if @address is an IPv6 address.
188     * @operation: Type of operation.
189     * @address:   An IPv4 or IPv6 address in network byte order.
190     * @port:      Port number in network byte order.
191     *
192     * Returns 0 on success, negative value otherwise.
193     */
194    static int ccs_network_entry(const bool is_ipv6, const u8 operation,
195                                 const u32 *address, const u16 port)
196  {  {
197          int count, is_ipv6;          const int idx = ccs_read_lock();
198          u16 min_address[8], max_address[8];          struct ccs_request_info r;
199          char *cp = strchr(data, ' ');          int error = 0;
200          if (!cp) return -EINVAL;          if (ccs_init_request_info(&r, CCS_MAC_NETWORK_UDP_BIND + operation)
201          *cp++ = '\0';              != CCS_CONFIG_DISABLED) {
202          if ((count = sscanf(cp, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",                  r.param_type = CCS_TYPE_IP_NETWORK_ACL;
203                              &min_address[0], &min_address[1], &min_address[2], &min_address[3],                  r.param.network.operation = operation;
204                              &min_address[4], &min_address[5], &min_address[6], &min_address[7],                  r.param.network.is_ipv6 = is_ipv6;
205                              &max_address[0], &max_address[1], &max_address[2], &max_address[3],                  r.param.network.address = address;
206                              &max_address[4], &max_address[5], &max_address[6], &max_address[7])) == 8 || count == 16) {                  r.param.network.port = ntohs(port);
207                  int i;                  /* use host byte order to allow u32 comparison than memcmp().*/
208                  for (i = 0; i < 8; i++) {                  r.param.network.ip = ntohl(*address);
209                          min_address[i] = htons(min_address[i]);                  do {
210                          max_address[i] = htons(max_address[i]);                          ccs_check_acl(&r, ccs_check_network_acl);
211                  }                          error = ccs_audit_network_log(&r);
212                  if (count == 8) memmove(max_address, min_address, sizeof(min_address));                  } while (error == CCS_RETRY_REQUEST);
                 is_ipv6 = 1;  
         } else if ((count = sscanf(cp, "%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])) == 4 || count == 8) {  
                 u32 ip = ((((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 = ((((u8) max_address[0]) << 24) + (((u8) max_address[1]) << 16) + (((u8) max_address[2]) << 8) + (u8) max_address[3]);  
                 * (u32 *) max_address = ip;  
                 is_ipv6 = 0;  
         } else {  
                 return -EINVAL;  
213          }          }
214          return AddAddressGroupEntry(data, is_ipv6, min_address, max_address, is_delete);          ccs_read_unlock(idx);
215            return error;
216  }  }
217    
218  static struct address_group_entry *FindOrAssignNewAddressGroup(const char *group_name)  static bool ccs_same_ip_network_acl(const struct ccs_acl_info *a,
219                                        const struct ccs_acl_info *b)
220  {  {
221          int i;          const struct ccs_ip_network_acl *p1 = container_of(a, typeof(*p1),
222          struct address_group_entry *group;                                                             head);
223          for (i = 0; i <= 1; i++) {          const struct ccs_ip_network_acl *p2 = container_of(b, typeof(*p2),
224                  list1_for_each_entry(group, &address_group_list, list) {                                                             head);
225                          if (strcmp(group_name, group->group_name->name) == 0) return group;          return ccs_same_acl_head(&p1->head, &p2->head)
226                  }                  && p1->address_type == p2->address_type &&
227                  if (i == 0) {                  p1->address.ipv4.min == p2->address.ipv4.min &&
228                          const u16 dummy[2] = { 0, 0 };                  p1->address.ipv6.min == p2->address.ipv6.min &&
229                          AddAddressGroupEntry(group_name, 0, dummy, dummy, 0);                  p1->address.ipv4.max == p2->address.ipv4.max &&
230                          AddAddressGroupEntry(group_name, 0, dummy, dummy, 1);                  p1->address.ipv6.max == p2->address.ipv6.max &&
231                  }                  p1->address.group == p2->address.group &&
232          }                  ccs_same_number_union(&p1->port, &p2->port);
233          return NULL;  }
234    
235    static bool ccs_merge_ip_network_acl(struct ccs_acl_info *a,
236                                         struct ccs_acl_info *b,
237                                         const bool is_delete)
238    {
239            u8 * const a_perm = &container_of(a, struct ccs_ip_network_acl, head)
240                    ->perm;
241            u8 perm = *a_perm;
242            const u8 b_perm = container_of(b, struct ccs_ip_network_acl, head)
243                    ->perm;
244            if (is_delete)
245                    perm &= ~b_perm;
246            else
247                    perm |= b_perm;
248            *a_perm = perm;
249            return !perm;
250  }  }
251    
252  static int AddressMatchesToGroup(const bool is_ipv6, const u32 *address, const struct address_group_entry *group)  /**
253     * ccs_write_network - Write "struct ccs_ip_network_acl" list.
254     *
255     * @data:      String to parse.
256     * @domain:    Pointer to "struct ccs_domain_info".
257     * @condition: Pointer to "struct ccs_condition". Maybe NULL.
258     * @is_delete: True if it is a delete request.
259     *
260     * Returns 0 on success, negative value otherwise.
261     */
262    int ccs_write_network(char *data, struct ccs_domain_info *domain,
263                          struct ccs_condition *condition, const bool is_delete)
264  {  {
265          struct address_group_member *member;          struct ccs_ip_network_acl e = {
266          const u32 ip = ntohl(*address);                  .head.type = CCS_TYPE_IP_NETWORK_ACL,
267          list1_for_each_entry(member, &group->address_group_member_list, list) {                  .head.cond = condition,
268                  if (member->is_deleted) continue;          };
269                  if (member->is_ipv6) {          u16 min_address[8];
270                          if (is_ipv6 && memcmp(member->min.ipv6, address, 16) <= 0 && memcmp(address, member->max.ipv6, 16) <= 0) return 1;          u16 max_address[8];
271                  } else {          int error = is_delete ? -ENOENT : -ENOMEM;
272                          if (!is_ipv6 && member->min.ipv4 <= ip && ip <= member->max.ipv4) return 1;          u8 sock_type;
273            u8 operation;
274            char *w[4];
275            if (!ccs_tokenize(data, w, sizeof(w)) || !w[3][0])
276                    return -EINVAL;
277            if (!strcmp(w[0], "TCP"))
278                    sock_type = SOCK_STREAM;
279            else if (!strcmp(w[0], "UDP"))
280                    sock_type = SOCK_DGRAM;
281            else if (!strcmp(w[0], "RAW"))
282                    sock_type = SOCK_RAW;
283            else
284                    return -EINVAL;
285            if (!strcmp(w[1], "bind"))
286                    switch (sock_type) {
287                    case SOCK_STREAM:
288                            operation = CCS_NETWORK_TCP_BIND;
289                            break;
290                    case SOCK_DGRAM:
291                            operation = CCS_NETWORK_UDP_BIND;
292                            break;
293                    default:
294                            operation = CCS_NETWORK_RAW_BIND;
295                            break;
296                    }
297            else if (!strcmp(w[1], "connect"))
298                    switch (sock_type) {
299                    case SOCK_STREAM:
300                            operation = CCS_NETWORK_TCP_CONNECT;
301                            break;
302                    case SOCK_DGRAM:
303                            operation = CCS_NETWORK_UDP_CONNECT;
304                            break;
305                    default:
306                            operation = CCS_NETWORK_RAW_CONNECT;
307                            break;
308                  }                  }
309            else if (sock_type == SOCK_STREAM && !strcmp(w[1], "listen"))
310                    operation = CCS_NETWORK_TCP_LISTEN;
311            else if (sock_type == SOCK_STREAM && !strcmp(w[1], "accept"))
312                    operation = CCS_NETWORK_TCP_ACCEPT;
313            else
314                    return -EINVAL;
315            e.perm = 1 << operation;                        
316            switch (ccs_parse_ip_address(w[2], min_address, max_address)) {
317            case CCS_IP_ADDRESS_TYPE_IPv6:
318                    e.address_type = CCS_IP_ADDRESS_TYPE_IPv6;
319                    e.address.ipv6.min = ccs_get_ipv6_address((struct in6_addr *)
320                                                              min_address);
321                    e.address.ipv6.max = ccs_get_ipv6_address((struct in6_addr *)
322                                                              max_address);
323                    if (!e.address.ipv6.min || !e.address.ipv6.max)
324                            goto out;
325                    break;
326            case CCS_IP_ADDRESS_TYPE_IPv4:
327                    e.address_type = CCS_IP_ADDRESS_TYPE_IPv4;
328                    /* use host byte order to allow u32 comparison.*/
329                    e.address.ipv4.min = ntohl(*(u32 *) min_address);
330                    e.address.ipv4.max = ntohl(*(u32 *) max_address);
331                    break;
332            default:
333                    if (w[2][0] != '@')
334                            return -EINVAL;
335                    e.address_type = CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP;
336                    e.address.group = ccs_get_group(w[2] + 1, CCS_ADDRESS_GROUP);
337                    if (!e.address.group)
338                            return -ENOMEM;
339                    break;
340            }
341            if (!ccs_parse_number_union(w[3], &e.port))
342                    goto out;
343            error = ccs_update_domain(&e.head, sizeof(e), is_delete, domain,
344                                      ccs_same_ip_network_acl,
345                                      ccs_merge_ip_network_acl);
346     out:
347            if (e.address_type == CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP)
348                    ccs_put_group(e.address.group);
349            else if (e.address_type == CCS_IP_ADDRESS_TYPE_IPv6) {
350                    ccs_put_ipv6_address(e.address.ipv6.min);
351                    ccs_put_ipv6_address(e.address.ipv6.max);
352          }          }
353          return 0;          ccs_put_number_union(&e.port);
354            return error;
355  }  }
356    
357  int ReadAddressGroupPolicy(struct io_buffer *head)  #ifndef CONFIG_NET
358    
359    void __init ccs_network_init(void)
360  {  {
         struct list1_head *gpos;  
         struct list1_head *mpos;  
         list1_for_each_cookie(gpos, head->read_var1, &address_group_list) {  
                 struct address_group_entry *group;  
                 group = list1_entry(gpos, struct address_group_entry, list);  
                 list1_for_each_cookie(mpos, head->read_var2, &group->address_group_member_list) {  
                         char buf[128];  
                         struct address_group_member *member;  
                         member = list1_entry(mpos, struct address_group_member, list);  
                         if (member->is_deleted) continue;  
                         if (member->is_ipv6) {  
                                 const struct in6_addr *min_address = member->min.ipv6, *max_address = member->max.ipv6;  
                                 print_ipv6(buf, sizeof(buf), min_address);  
                                 if (min_address != max_address) {  
                                         char *cp = strchr(buf, '\0');  
                                         *cp++ = '-';  
                                         print_ipv6(cp, sizeof(buf) - strlen(buf), max_address);  
                                 }  
                         } else {  
                                 const u32 min_address = member->min.ipv4, max_address = member->max.ipv4;  
                                 memset(buf, 0, sizeof(buf));  
                                 snprintf(buf, sizeof(buf) - 1, "%u.%u.%u.%u", HIPQUAD(min_address));  
                                 if (min_address != max_address) {  
                                         const int len = strlen(buf);  
                                         snprintf(buf + len, sizeof(buf) - 1 - len, "-%u.%u.%u.%u", HIPQUAD(max_address));  
                                 }  
                         }  
                         if (io_printf(head, KEYWORD_ADDRESS_GROUP "%s %s\n", group->group_name->name, buf)) return -ENOMEM;  
                 }  
         }  
         return 0;  
361  }  }
362    
363  /*************************  NETWORK NETWORK ACL HANDLER  *************************/  #else
364    
365  #if !defined(NIP6)  #define MAX_SOCK_ADDR 128 /* net/socket.c */
 #define NIP6(addr) \  
         ntohs((addr).s6_addr16[0]), \  
         ntohs((addr).s6_addr16[1]), \  
         ntohs((addr).s6_addr16[2]), \  
         ntohs((addr).s6_addr16[3]), \  
         ntohs((addr).s6_addr16[4]), \  
         ntohs((addr).s6_addr16[5]), \  
         ntohs((addr).s6_addr16[6]), \  
         ntohs((addr).s6_addr16[7])  
 #endif  
366    
367  char *print_ipv6(char *buffer, const int buffer_len, const struct in6_addr *ip)  /* Check permission for creating a socket. */
368    static int __ccs_socket_create_permission(int family, int type, int protocol)
369  {  {
370          memset(buffer, 0, buffer_len);          int error = 0;
371          snprintf(buffer, buffer_len - 1, "%x:%x:%x:%x:%x:%x:%x:%x", NIP6(*ip));          /* Nothing to do if I am a kernel service. */
372          return buffer;          if (segment_eq(get_fs(), KERNEL_DS))
373                    return 0;
374            if (family == PF_PACKET && !ccs_capable(CCS_USE_PACKET_SOCKET))
375                    return -EPERM;
376            if (family == PF_ROUTE && !ccs_capable(CCS_USE_ROUTE_SOCKET))
377                    return -EPERM;
378            if (family != PF_INET && family != PF_INET6)
379                    return 0;
380            switch (type) {
381            case SOCK_STREAM:
382                    if (!ccs_capable(CCS_INET_STREAM_SOCKET_CREATE))
383                            error = -EPERM;
384                    break;
385            case SOCK_DGRAM:
386                    if (!ccs_capable(CCS_USE_INET_DGRAM_SOCKET))
387                            error = -EPERM;
388                    break;
389            case SOCK_RAW:
390                    if (!ccs_capable(CCS_USE_INET_RAW_SOCKET))
391                            error = -EPERM;
392                    break;
393            }
394            return error;
395  }  }
396    
397  const char *network2keyword(const unsigned int operation)  /* Check permission for listening a TCP socket. */
398    static int __ccs_socket_listen_permission(struct socket *sock)
399  {  {
400          const char *keyword = "unknown";          int error = 0;
401          switch (operation) {          char addr[MAX_SOCK_ADDR];
402          case NETWORK_ACL_UDP_BIND:          int addr_len;
403                  keyword = "UDP bind";          u32 *address;
404                  break;          u16 port;
405          case NETWORK_ACL_UDP_CONNECT:          bool is_ipv6;
406                  keyword = "UDP connect";          /* Nothing to do if I am a kernel service. */
407                  break;          if (segment_eq(get_fs(), KERNEL_DS))
408          case NETWORK_ACL_TCP_BIND:                  return 0;
409                  keyword = "TCP bind";          if (sock->type != SOCK_STREAM)
410                  break;                  return 0;
411          case NETWORK_ACL_TCP_LISTEN:          switch (sock->sk->sk_family) {
412                  keyword = "TCP listen";          case PF_INET:
413                  break;          case PF_INET6:
414          case NETWORK_ACL_TCP_CONNECT:                  break;
415                  keyword = "TCP connect";          default:
416                  break;                  return 0;
         case NETWORK_ACL_TCP_ACCEPT:  
                 keyword = "TCP accept";  
                 break;  
         case NETWORK_ACL_RAW_BIND:  
                 keyword = "RAW bind";  
                 break;  
         case NETWORK_ACL_RAW_CONNECT:  
                 keyword = "RAW connect";  
                 break;  
         }  
         return keyword;  
 }  
   
 static int AddNetworkEntry(const u8 operation, const u8 record_type, const struct address_group_entry *group, const u32 *min_address, const u32 *max_address, const u16 min_port, const u16 max_port, struct domain_info *domain, const struct condition_list *condition, const bool is_delete)  
 {  
         struct acl_info *ptr;  
         struct ip_network_acl_record *acl;  
         int error = -ENOMEM;  
         const u32 min_ip = ntohl(*min_address), max_ip = ntohl(*max_address); /* using host byte order to allow u32 comparison than memcmp().*/  
         const struct in6_addr *saved_min_address = NULL, *saved_max_address = NULL;  
         if (!domain) return -EINVAL;  
         if (record_type == IP_RECORD_TYPE_IPv6) {  
                 if ((saved_min_address = SaveIPv6Address((struct in6_addr *) min_address)) == NULL  
                     || (saved_max_address = SaveIPv6Address((struct in6_addr *) max_address)) == NULL) return -ENOMEM;  
         }  
         mutex_lock(&domain_acl_lock);  
         if (!is_delete) {  
                 list1_for_each_entry(ptr, &domain->acl_info_list, list) {  
                         acl = container_of(ptr, struct ip_network_acl_record, head);  
                         if (ptr->type == TYPE_IP_NETWORK_ACL && acl->operation_type == operation && acl->record_type == record_type && ptr->cond == condition && acl->min_port == min_port && max_port == acl->max_port) {  
                                 if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {  
                                         if (acl->u.group == group) {  
                                                 ptr->is_deleted = 0;  
                                                 /* Found. Nothing to do. */  
                                                 error = 0;  
                                                 goto out;  
                                         }  
                                 } else if (record_type == IP_RECORD_TYPE_IPv4) {  
                                         if (acl->u.ipv4.min == min_ip && max_ip == acl->u.ipv4.max) {  
                                                 ptr->is_deleted = 0;  
                                                 /* Found. Nothing to do. */  
                                                 error = 0;  
                                                 goto out;  
                                         }  
                                 } else if (record_type == IP_RECORD_TYPE_IPv6) {  
                                         if (acl->u.ipv6.min == saved_min_address && saved_max_address == acl->u.ipv6.max) {  
                                                 ptr->is_deleted = 0;  
                                                 /* Found. Nothing to do. */  
                                                 error = 0;  
                                                 goto out;  
                                         }  
                                 }  
                         }  
                 }  
                 /* Not found. Append it to the tail. */  
                 if ((acl = alloc_element(sizeof(*acl))) == NULL) goto out;  
                 acl->head.type = TYPE_IP_NETWORK_ACL;  
                 acl->operation_type = operation;  
                 acl->record_type = record_type;  
                 acl->head.cond = condition;  
                 if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {  
                         acl->u.group = group;  
                 } else if (record_type == IP_RECORD_TYPE_IPv4) {  
                         acl->u.ipv4.min = min_ip;  
                         acl->u.ipv4.max = max_ip;  
                 } else {  
                         acl->u.ipv6.min = saved_min_address;  
                         acl->u.ipv6.max = saved_max_address;  
                 }  
                 acl->min_port = min_port;  
                 acl->max_port = max_port;  
                 error = AddDomainACL(domain, &acl->head);  
         } else {  
                 error = -ENOENT;  
                 list1_for_each_entry(ptr, &domain->acl_info_list, list) {  
                         acl = container_of(ptr, struct ip_network_acl_record, head);  
                         if (ptr->type != TYPE_IP_NETWORK_ACL || ptr->is_deleted || acl->operation_type != operation || acl->record_type != record_type || ptr->cond != condition || acl->min_port != min_port || acl->max_port != max_port) continue;  
                         if (record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {  
                                 if (acl->u.group != group) continue;  
                         } else if (record_type == IP_RECORD_TYPE_IPv4) {  
                                 if (acl->u.ipv4.min != min_ip || max_ip != acl->u.ipv4.max) continue;  
                         } else if (record_type == IP_RECORD_TYPE_IPv6) {  
                                 if (acl->u.ipv6.min != saved_min_address || saved_max_address != acl->u.ipv6.max) continue;  
                         }  
                         error = DelDomainACL(ptr);  
                         break;  
                 }  
417          }          }
418   out: ;          if (!ccs_capable(CCS_INET_STREAM_SOCKET_LISTEN))
419          mutex_unlock(&domain_acl_lock);                  return -EPERM;
420            if (sock->ops->getname(sock, (struct sockaddr *) addr, &addr_len, 0))
421                    return -EPERM;
422            switch (((struct sockaddr *) addr)->sa_family) {
423            case AF_INET6:
424                    is_ipv6 = true;
425                    address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr
426                            .s6_addr;
427                    port = ((struct sockaddr_in6 *) addr)->sin6_port;
428                    break;
429            case AF_INET:
430                    is_ipv6 = false;
431                    address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;
432                    port = ((struct sockaddr_in *) addr)->sin_port;
433                    break;
434            default:
435                    goto skip;
436            }
437            error = ccs_network_entry(is_ipv6, CCS_NETWORK_TCP_LISTEN, address,
438                                      port);
439     skip:
440          return error;          return error;
441  }  }
442    
443  static int CheckNetworkEntry(const bool is_ipv6, const int operation, const u32 *address, const u16 port)  /* Check permission for setting the remote IP address/port pair of a socket. */
444  {  static int __ccs_socket_connect_permission(struct socket *sock,
445          struct domain_info * const domain = current->domain_info;                                             struct sockaddr *addr, int addr_len)
446          struct acl_info *ptr;  {
447          const char *keyword = network2keyword(operation);          int error = 0;
448          const bool is_enforce = CheckCCSEnforce(CCS_TOMOYO_MAC_FOR_NETWORK);          const unsigned int type = sock->type;
449          const u32 ip = ntohl(*address); /* using host byte order to allow u32 comparison than memcmp().*/          u32 *address;
450          bool found = 0;          u16 port;
451          if (!CheckCCSFlags(CCS_TOMOYO_MAC_FOR_NETWORK)) return 0;          u8 operation;
452          list1_for_each_entry(ptr, &domain->acl_info_list, list) {          bool is_ipv6;
453                  struct ip_network_acl_record *acl;          /* Nothing to do if I am a kernel service. */
454                  acl = container_of(ptr, struct ip_network_acl_record, head);          if (segment_eq(get_fs(), KERNEL_DS))
455                  if (ptr->type != TYPE_IP_NETWORK_ACL || ptr->is_deleted || acl->operation_type != operation || port < acl->min_port || acl->max_port < port || CheckCondition(ptr->cond, NULL)) continue;                  return 0;
456                  if (acl->record_type == IP_RECORD_TYPE_ADDRESS_GROUP) {          switch (type) {
457                          if (!AddressMatchesToGroup(is_ipv6, address, acl->u.group)) continue;          case SOCK_STREAM:
458                  } else if (acl->record_type == IP_RECORD_TYPE_IPv4) {                  operation = CCS_NETWORK_TCP_CONNECT;
459                          if (is_ipv6 || ip < acl->u.ipv4.min || acl->u.ipv4.max < ip) continue;                  break;
460                  } else {          case SOCK_DGRAM:
461                          if (!is_ipv6 || memcmp(acl->u.ipv6.min, address, 16) > 0 || memcmp(address, acl->u.ipv6.max, 16) > 0) continue;                  operation = CCS_NETWORK_UDP_CONNECT;
                 }  
                 found = 1;  
462                  break;                  break;
463                                    case SOCK_RAW:
464                    operation = CCS_NETWORK_RAW_CONNECT;
465                    break;
466            default:
467                    return 0;
468          }          }
469          AuditNetworkLog(is_ipv6, keyword, address, port, found);          switch (addr->sa_family) {
470          if (found) return 0;          case AF_INET6:
471          if (TomoyoVerboseMode()) {                  if (addr_len < SIN6_LEN_RFC2133)
472                  if (is_ipv6) {                          goto skip;
473                          char buf[64];                  is_ipv6 = true;
474                          print_ipv6(buf, sizeof(buf), (const struct in6_addr *) address);                  address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr
475                          printk("TOMOYO-%s: %s to %s %u denied for %s\n", GetMSG(is_enforce), keyword, buf, port, GetLastName(domain));                          .s6_addr;
476                  } else {                  port = ((struct sockaddr_in6 *) addr)->sin6_port;
477                          printk("TOMOYO-%s: %s to %u.%u.%u.%u %u denied for %s\n", GetMSG(is_enforce), keyword, HIPQUAD(ip), port, GetLastName(domain));                  break;
478                  }          case AF_INET:
479                    if (addr_len < sizeof(struct sockaddr_in))
480                            goto skip;
481                    is_ipv6 = false;
482                    address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;
483                    port = ((struct sockaddr_in *) addr)->sin_port;
484                    break;
485            default:
486                    goto skip;
487          }          }
488          AuditNetworkLog(is_ipv6, keyword, address, port, 0);          if (type == SOCK_RAW)
489          if (is_enforce) {                  port = htons(sock->sk->sk_protocol);
490                  if (is_ipv6) {          error = ccs_network_entry(is_ipv6, operation, address, port);
491                          char buf[64];   skip:
492                          print_ipv6(buf, sizeof(buf), (const struct in6_addr *) address);          if (type != SOCK_STREAM)
493                          return CheckSupervisor("%s\n" KEYWORD_ALLOW_NETWORK "%s %s %u\n", domain->domainname->name, keyword, buf, port);                  return error;
494                  }          switch (sock->sk->sk_family) {
495                  return CheckSupervisor("%s\n" KEYWORD_ALLOW_NETWORK "%s %u.%u.%u.%u %u\n", domain->domainname->name, keyword, HIPQUAD(ip), port);          case PF_INET:
496            case PF_INET6:
497                    if (!ccs_capable(CCS_INET_STREAM_SOCKET_CONNECT))
498                            error = -EPERM;
499                    break;
500          }          }
501          if (CheckCCSAccept(CCS_TOMOYO_MAC_FOR_NETWORK, domain)) AddNetworkEntry(operation, is_ipv6 ? IP_RECORD_TYPE_IPv6 : IP_RECORD_TYPE_IPv4, NULL, address, address, port, port, domain, NULL, 0);          return error;
         return 0;  
502  }  }
503    
504  int AddNetworkPolicy(char *data, struct domain_info *domain, const struct condition_list *condition, const bool is_delete)  /* Check permission for setting the local IP address/port pair of a socket. */
505  {  static int __ccs_socket_bind_permission(struct socket *sock,
506          u8 sock_type, operation, record_type;                                          struct sockaddr *addr, int addr_len)
507          u16 min_address[8], max_address[8];  {
508          struct address_group_entry *group = NULL;          int error = 0;
509          u16 min_port, max_port;          const unsigned int type = sock->type;
510          int count;          const u32 *address;
511          char *cp1 = NULL, *cp2 = NULL;          u16 port;
512          if ((cp1 = strchr(data, ' ')) == NULL) goto out; cp1++;          u8 operation;
513          if (strncmp(data, "TCP ", 4) == 0) sock_type = SOCK_STREAM;          bool is_ipv6;
514          else if (strncmp(data, "UDP ", 4) == 0) sock_type = SOCK_DGRAM;          /* Nothing to do if I am a kernel service. */
515          else if (strncmp(data, "RAW ", 4) == 0) sock_type = SOCK_RAW;          if (segment_eq(get_fs(), KERNEL_DS))
516          else goto out;                  return 0;
517          if ((cp2 = strchr(cp1, ' ')) == NULL) goto out; cp2++;          switch (type) {
518          if (strncmp(cp1, "bind ", 5) == 0) {          case SOCK_STREAM:
519                  operation = (sock_type == SOCK_STREAM) ? NETWORK_ACL_TCP_BIND : (sock_type == SOCK_DGRAM) ? NETWORK_ACL_UDP_BIND : NETWORK_ACL_RAW_BIND;                  operation = CCS_NETWORK_TCP_BIND;
520          } else if (strncmp(cp1, "connect ", 8) == 0) {                  break;
521                  operation = (sock_type == SOCK_STREAM) ? NETWORK_ACL_TCP_CONNECT : (sock_type == SOCK_DGRAM) ? NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT;          case SOCK_DGRAM:
522          } else if (sock_type == SOCK_STREAM && strncmp(cp1, "listen ", 7) == 0) {                  operation = CCS_NETWORK_UDP_BIND;
523                  operation = NETWORK_ACL_TCP_LISTEN;                  break;
524          } else if (sock_type == SOCK_STREAM && strncmp(cp1, "accept ", 7) == 0) {          case SOCK_RAW:
525                  operation = NETWORK_ACL_TCP_ACCEPT;                  operation = CCS_NETWORK_RAW_BIND;
526          } else {                  break;
527                  goto out;          default:
528                    return 0;
529          }          }
530          if ((cp1 = strchr(cp2, ' ')) == NULL) goto out; *cp1++ = '\0';          switch (addr->sa_family) {
531          if ((count = sscanf(cp2, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx-%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",          case AF_INET6:
532                              &min_address[0], &min_address[1], &min_address[2], &min_address[3],                  if (addr_len < SIN6_LEN_RFC2133)
533                              &min_address[4], &min_address[5], &min_address[6], &min_address[7],                          goto skip;
534                              &max_address[0], &max_address[1], &max_address[2], &max_address[3],                  is_ipv6 = true;
535                              &max_address[4], &max_address[5], &max_address[6], &max_address[7])) == 8 || count == 16) {                  address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr
536                  int i;                          .s6_addr;
537                  for (i = 0; i < 8; i++) {                  port = ((struct sockaddr_in6 *) addr)->sin6_port;
538                          min_address[i] = htons(min_address[i]);                  break;
539                          max_address[i] = htons(max_address[i]);          case AF_INET:
540                  }                  if (addr_len < sizeof(struct sockaddr_in))
541                  if (count == 8) memmove(max_address, min_address, sizeof(min_address));                          goto skip;
542                  record_type = IP_RECORD_TYPE_IPv6;                  is_ipv6 = false;
543          } else if ((count = sscanf(cp2, "%hu.%hu.%hu.%hu-%hu.%hu.%hu.%hu",                  address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;
544                                     &min_address[0], &min_address[1], &min_address[2], &min_address[3],                  port = ((struct sockaddr_in *) addr)->sin_port;
545                                     &max_address[0], &max_address[1], &max_address[2], &max_address[3])) == 4 || count == 8) {                  break;
546                  u32 ip = htonl((((u8) min_address[0]) << 24) + (((u8) min_address[1]) << 16) + (((u8) min_address[2]) << 8) + (u8) min_address[3]);          default:
547                  * (u32 *) min_address = ip;                  goto skip;
548                  if (count == 8) ip = htonl((((u8) max_address[0]) << 24) + (((u8) max_address[1]) << 16) + (((u8) max_address[2]) << 8) + (u8) max_address[3]);          }
549                  * (u32 *) max_address = ip;          if (type == SOCK_RAW)
550                  record_type = IP_RECORD_TYPE_IPv4;                  port = htons(sock->sk->sk_protocol);
551          } else if (*cp2 == '@') {          error = ccs_network_entry(is_ipv6, operation, address, port);
552                  if ((group = FindOrAssignNewAddressGroup(cp2 + 1)) == NULL) return -ENOMEM;   skip:
553                  record_type = IP_RECORD_TYPE_ADDRESS_GROUP;          return error;
554          } else {  }
555                  goto out;  
556    /* Check permission for accepting a TCP socket. */
557    static int __ccs_socket_post_accept_permission(struct socket *sock,
558                                                   struct socket *newsock)
559    {
560            struct sockaddr_storage addr;
561            struct task_struct * const task = current;
562            int error = 0;
563            int addr_len;
564            u32 *address;
565            u16 port;
566            bool is_ipv6;
567            /* Nothing to do if I am a kernel service. */
568            if (segment_eq(get_fs(), KERNEL_DS))
569                    return 0;
570            switch (newsock->sk->sk_family) {
571            case PF_INET:
572            case PF_INET6:
573                    break;
574            default:
575                    return 0;
576          }          }
577          if (strchr(cp1, ' ')) goto out;          error = newsock->ops->getname(newsock, (struct sockaddr *) &addr,
578          if ((count = sscanf(cp1, "%hu-%hu", &min_port, &max_port)) == 1 || count == 2) {                                        &addr_len, 2);
579                  if (count == 1) max_port = min_port;          if (error)
580                  return AddNetworkEntry(operation, record_type, group, (u32 *) min_address, (u32 *) max_address, min_port, max_port, domain, condition, is_delete);                  return error;
581            switch (((struct sockaddr *) &addr)->sa_family) {
582            case AF_INET6:
583                    is_ipv6 = true;
584                    address = (u32 *) ((struct sockaddr_in6 *) &addr)->sin6_addr
585                            .s6_addr;
586                    port = ((struct sockaddr_in6 *) &addr)->sin6_port;
587                    break;
588            case AF_INET:
589                    is_ipv6 = false;
590                    address = (u32 *) &((struct sockaddr_in *) &addr)->sin_addr;
591                    port = ((struct sockaddr_in *) &addr)->sin_port;
592                    break;
593            default:
594                    goto skip;
595          }          }
596   out: ;          task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
597          return -EINVAL;          error = ccs_network_entry(is_ipv6, CCS_NETWORK_TCP_ACCEPT, address,
598                                      port);
599            task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
600     skip:
601            return error;
602  }  }
603    
604  int CheckNetworkListenACL(const _Bool is_ipv6, const u8 *address, const u16 port)  /* Check permission for sending a datagram via a UDP or RAW socket. */
605  {  static int __ccs_socket_sendmsg_permission(struct socket *sock,
606          return CheckNetworkEntry(is_ipv6, NETWORK_ACL_TCP_LISTEN, (const u32 *) address, ntohs(port));                                             struct msghdr *msg, int size)
607    {
608            struct sockaddr *addr = (struct sockaddr *) msg->msg_name;
609            const int addr_len = msg->msg_namelen;
610            int error = 0;
611            const int type = sock->type;
612            u32 *address;
613            u16 port;
614            bool is_ipv6;
615            u8 operation;
616            if (!addr)
617                    return 0;
618            /* Nothing to do if I am a kernel service. */
619            if (segment_eq(get_fs(), KERNEL_DS))
620                    return 0;
621            switch (type) {
622            case SOCK_DGRAM:
623                    operation = CCS_NETWORK_UDP_CONNECT;
624                    break;
625            case SOCK_RAW:
626                    operation = CCS_NETWORK_RAW_CONNECT;
627                    break;
628            default:
629                    return 0;
630            }
631            switch (addr->sa_family) {
632            case AF_INET6:
633                    if (addr_len < SIN6_LEN_RFC2133)
634                            goto skip;
635                    is_ipv6 = true;
636                    address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr
637                            .s6_addr;
638                    port = ((struct sockaddr_in6 *) addr)->sin6_port;
639                    break;
640            case AF_INET:
641                    if (addr_len < sizeof(struct sockaddr_in))
642                            goto skip;
643                    is_ipv6 = false;
644                    address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;
645                    port = ((struct sockaddr_in *) addr)->sin_port;
646                    break;
647            default:
648                    goto skip;
649            }
650            if (type == SOCK_RAW)
651                    port = htons(sock->sk->sk_protocol);
652            error = ccs_network_entry(is_ipv6, operation, address, port);
653     skip:
654            return error;
655  }  }
656    
657  int CheckNetworkConnectACL(const _Bool is_ipv6, const int sock_type, const u8 *address, const u16 port)  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
658    #if !defined(RHEL_MAJOR) || RHEL_MAJOR != 5
659    #if !defined(AX_MAJOR) || AX_MAJOR != 3 || !defined(AX_MINOR) || AX_MINOR < 2
660    
661    static inline struct iphdr *ip_hdr(const struct sk_buff *skb)
662  {  {
663          return CheckNetworkEntry(is_ipv6, sock_type == SOCK_STREAM ? NETWORK_ACL_TCP_CONNECT : (sock_type == SOCK_DGRAM ? NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT), (const u32 *) address, ntohs(port));          return skb->nh.iph;
664  }  }
665    
666  int CheckNetworkBindACL(const _Bool is_ipv6, const int sock_type, const u8 *address, const u16 port)  static inline struct udphdr *udp_hdr(const struct sk_buff *skb)
667  {  {
668          return CheckNetworkEntry(is_ipv6, sock_type == SOCK_STREAM ? NETWORK_ACL_TCP_BIND : (sock_type == SOCK_DGRAM ? NETWORK_ACL_UDP_BIND : NETWORK_ACL_RAW_BIND), (const u32 *) address, ntohs(port));          return skb->h.uh;
669  }  }
670    
671  int CheckNetworkAcceptACL(const _Bool is_ipv6, const u8 *address, const u16 port)  static inline struct ipv6hdr *ipv6_hdr(const struct sk_buff *skb)
672  {  {
673          int retval;          return skb->nh.ipv6h;
         current->tomoyo_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         retval = CheckNetworkEntry(is_ipv6, NETWORK_ACL_TCP_ACCEPT, (const u32 *) address, ntohs(port));  
         current->tomoyo_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         return retval;  
674  }  }
675    
676  int CheckNetworkSendMsgACL(const _Bool is_ipv6, const int sock_type, const u8 *address, const u16 port)  #endif
677  {  #endif
678          return CheckNetworkEntry(is_ipv6, sock_type == SOCK_DGRAM ? NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT, (const u32 *) address, ntohs(port));  #endif
679    
680    /* Check permission for receiving a datagram via a UDP or RAW socket. */
681    static int __ccs_socket_post_recvmsg_permission(struct sock *sk,
682                                                    struct sk_buff *skb)
683    {
684            struct task_struct * const task = current;
685            int error = 0;
686            const unsigned int type = sk->sk_type;
687            u16 port;
688            bool is_ipv6;
689            u8 operation;
690            union {
691                    struct in6_addr sin6;
692                    struct in_addr sin4;
693            } address;
694            switch (type) {
695            case SOCK_DGRAM:
696                    operation = CCS_NETWORK_UDP_CONNECT;
697                    break;
698            case SOCK_RAW:
699                    operation = CCS_NETWORK_RAW_CONNECT;
700                    break;
701            default:
702                    return 0;
703            }
704            /* Nothing to do if I am a kernel service. */
705            if (segment_eq(get_fs(), KERNEL_DS))
706                    return 0;
707            switch (sk->sk_family) {
708            case PF_INET6:
709                    is_ipv6 = true;
710                    if (type == SOCK_DGRAM && skb->protocol == htons(ETH_P_IP))
711                            ipv6_addr_set(&address.sin6, 0, 0, htonl(0xffff),
712                                          ip_hdr(skb)->saddr);
713                    else
714                            ipv6_addr_copy(&address.sin6, &ipv6_hdr(skb)->saddr);
715                    break;
716            case PF_INET:
717                    is_ipv6 = false;
718                    address.sin4.s_addr = ip_hdr(skb)->saddr;
719                    break;
720            default:
721                    goto skip;
722            }
723            if (type == SOCK_DGRAM)
724                    port = udp_hdr(skb)->source;
725            else
726                    port = htons(sk->sk_protocol);
727            task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
728            error = ccs_network_entry(is_ipv6, operation, (u32 *) &address, port);
729            task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
730     skip:
731            return error;
732  }  }
733    
734  int CheckNetworkRecvMsgACL(const _Bool is_ipv6, const int sock_type, const u8 *address, const u16 port)  void __init ccs_network_init(void)
735  {  {
736          int retval;          ccsecurity_ops.socket_create_permission =
737          current->tomoyo_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;                  __ccs_socket_create_permission;
738          retval = CheckNetworkEntry(is_ipv6, sock_type == SOCK_DGRAM ? NETWORK_ACL_UDP_CONNECT : NETWORK_ACL_RAW_CONNECT, (const u32 *) address, ntohs(port));          ccsecurity_ops.socket_listen_permission =
739          current->tomoyo_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;                  __ccs_socket_listen_permission;
740          return retval;          ccsecurity_ops.socket_connect_permission =
741                    __ccs_socket_connect_permission;
742            ccsecurity_ops.socket_bind_permission = __ccs_socket_bind_permission;
743            ccsecurity_ops.socket_post_accept_permission =
744                    __ccs_socket_post_accept_permission;
745            ccsecurity_ops.socket_sendmsg_permission =
746                    __ccs_socket_sendmsg_permission;
747            ccsecurity_ops.socket_post_recvmsg_permission =
748                    __ccs_socket_post_recvmsg_permission;
749  }  }
750    
751  /***** TOMOYO Linux end. *****/  #endif
Legend:
Removed from v.808  
changed lines
  Added in v.3825
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ