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

TOMOYO

Subversion リポジトリの参照

/[tomoyo]/trunk/2.4.x/tomoyo-tools/kernel_test/tomoyo_new_file_test.c

Diff of /trunk/2.4.x/tomoyo-tools/kernel_test/tomoyo_new_file_test.c

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

trunk/1.6.x/ccs-tools/ccstools/kernel_test/tomoyo_new_file_test.c revision 1067 by kumaneko, Sat Mar 29 03:47:21 2008 UTC trunk/1.7.x/ccs-tools/ccstools/kernel_test/ccs_new_file_test.c revision 2985 by kumaneko, Thu Sep 3 08:27:32 2009 UTC
# Line 3  Line 3 
3   *   *
4   * Testing program for fs/tomoyo_file.c   * Testing program for fs/tomoyo_file.c
5   *   *
6   * Copyright (C) 2005-2008  NTT DATA CORPORATION   * Copyright (C) 2005-2009  NTT DATA CORPORATION
7   *   *
8   * Version: 1.6.0-rc   2008/03/28   * Version: 1.7.0   2009/09/03
9   *   *
10   */   */
11  #include "include.h"  #include "include.h"
12    
 static int profile_fd = EOF;  
 static int domain_fd = EOF;  
 static int exception_fd = EOF;  
13  static const char *policy = "";  static const char *policy = "";
 static char self_domain[4096] = "";  
14    
15  static int write_policy(void) {  #if 0
16    static int write_policy(void)
17    {
18          FILE *fp;          FILE *fp;
19          char buffer[8192];          char buffer[8192];
         char *cp;  
20          int domain_found = 0;          int domain_found = 0;
21          int policy_found = 0;          int policy_found = 0;
22          memset(buffer, 0, sizeof(buffer));          memset(buffer, 0, sizeof(buffer));
23          cp = "255-MAC_FOR_FILE=disabled\n";          set_profile(0, "file::open");
         write(profile_fd, cp, strlen(cp));  
24          fp = fopen(proc_policy_domain_policy, "r");          fp = fopen(proc_policy_domain_policy, "r");
25          cp = "255-MAC_FOR_FILE=enforcing\n";          set_profile(3, "file::open");
26          write(profile_fd, cp, strlen(cp));          fprintf(domain_fp, "%s\n", policy);
         write(domain_fd, policy, strlen(policy));  
         write(domain_fd, "\n", 1);  
27          if (!fp) {          if (!fp) {
28                  printf("%s : BUG: policy read failed\n", policy);                  printf("%s : BUG: policy read failed\n", policy);
29                  return 0;                  return 0;
30          }          }
31          while (fgets(buffer, sizeof(buffer) - 1, fp)) {          while (fgets(buffer, sizeof(buffer) - 1, fp)) {
32                  cp = strchr(buffer, '\n');                  char *cp = strchr(buffer, '\n');
33                  if (cp) *cp = '\0';                  if (cp)
34                  if (!strncmp(buffer, "<kernel>", 8)) domain_found = !strcmp(self_domain, buffer);                          *cp = '\0';
35                  if (domain_found) {                  if (!strncmp(buffer, "<kernel>", 8))
36                          //printf("<%s>\n", buffer);                          domain_found = !strcmp(self_domain, buffer);
37                          if (!strcmp(buffer, policy)) {                  if (!domain_found)
38                                  policy_found = 1;                          continue;
39                                  break;                  /* printf("<%s>\n", buffer); */
40                          }                  if (!strcmp(buffer, policy)) {
41                            policy_found = 1;
42                            break;
43                  }                  }
44          }          }
45          fclose(fp);          fclose(fp);
# Line 54  static int write_policy(void) { Line 50  static int write_policy(void) {
50          errno = 0;          errno = 0;
51          return 1;          return 1;
52  }  }
53    #endif
54    
55  static void delete_policy(void) {  static void show_result(int result, char should_success)
56          write(domain_fd, "delete ", 7);  {
         write(domain_fd, policy, strlen(policy));  
         write(domain_fd, "\n", 1);  
 }  
   
 static void show_result(int result, char should_success) {  
57          int err = errno;          int err = errno;
58          printf("%s : ", policy);          printf("%s : ", policy);
59          if (should_success) {          if (should_success) {
60                  if (result != EOF) printf("OK\n");                  if (result != EOF)
61                  else printf("FAILED: %s\n", strerror(err));                          printf("OK\n");
62                    else
63                            printf("FAILED: %s\n", strerror(err));
64          } else {          } else {
65                  if (result == EOF) {                  if (result == EOF) {
66                          if (err == EPERM) printf("OK: Permission denied.\n");                          if (err == EPERM)
67                          else printf("FAILED: %s\n", strerror(err));                                  printf("OK: Permission denied.\n");
68                            else
69                                    printf("FAILED: %s\n", strerror(err));
70                  } else {                  } else {
71                          printf("BUG: didn't fail.\n");                          printf("BUG: didn't fail.\n");
72                  }                  }
73          }          }
74  }  }
75    
76  static void create2(const char *pathname) {  static void create2(const char *pathname)
77          const char *cp = "255-MAC_FOR_FILE=disabled\n";  {
78          write(profile_fd, cp, strlen(cp));          set_profile(0, "file::create");
79            set_profile(0, "file::open");
80          close(creat(pathname, 0600));          close(creat(pathname, 0600));
81          cp = "255-MAC_FOR_FILE=enforcing\n";          set_profile(3, "file::create");
82          write(profile_fd, cp, strlen(cp));          set_profile(3, "file::open");
83            errno = 0;
84  }  }
85    
86  static void mkdir2(const char *pathname) {  static void mkdir2(const char *pathname)
87          const char *cp = "255-MAC_FOR_FILE=disabled\n";  {
88          write(profile_fd, cp, strlen(cp));          set_profile(0, "file::mkdir");
89          mkdir(pathname, 0600);          mkdir(pathname, 0600);
90          cp = "255-MAC_FOR_FILE=enforcing\n";          set_profile(3, "file::mkdir");
91          write(profile_fd, cp, strlen(cp));          errno = 0;
92  }  }
93    
94  static void unlink2(const char *pathname) {  static void unlink2(const char *pathname)
95          const char *cp = "255-MAC_FOR_FILE=disabled\n";  {
96          write(profile_fd, cp, strlen(cp));          set_profile(0, "file::unlink");
97          unlink(pathname);          unlink(pathname);
98          cp = "255-MAC_FOR_FILE=enforcing\n";          set_profile(3, "file::unlink");
99          write(profile_fd, cp, strlen(cp));          errno = 0;
 }                        
   
 static void rmdir2(const char *pathname) {  
         const char *cp = "255-MAC_FOR_FILE=disabled\n";  
         write(profile_fd, cp, strlen(cp));  
         rmdir(pathname);  
         cp = "255-MAC_FOR_FILE=enforcing\n";  
         write(profile_fd, cp, strlen(cp));  
100  }  }
101    
102  static void StageFileTest(void) {  static void rmdir2(const char *pathname)
103          char *filename = "";  {
104          policy = "allow_read /proc/sys/net/ipv4/ip_local_port_range";          set_profile(0, "file::rmdir");
105          if (write_policy()) {          rmdir(pathname);
106                  static int name[] = { CTL_NET, NET_IPV4, NET_IPV4_LOCAL_PORT_RANGE };          set_profile(3, "file::rmdir");
107                  int buffer[2] = { 32768, 61000 };          errno = 0;
108                  size_t size = sizeof(buffer);  }
                 show_result(sysctl(name, 3, buffer, &size, 0, 0), 1);  
                 delete_policy();  
                 show_result(sysctl(name, 3, buffer, &size, 0, 0), 0);  
         }  
         policy = "allow_write /proc/sys/net/ipv4/ip_local_port_range";  
         if (write_policy()) {  
                 static int name[] = { CTL_NET, NET_IPV4, NET_IPV4_LOCAL_PORT_RANGE };  
                 int buffer[2] = { 32768, 61000 };  
                 size_t size = sizeof(buffer);  
                 show_result(sysctl(name, 3, 0, 0, buffer, size), 1);  
                 delete_policy();  
                 show_result(sysctl(name, 3, 0, 0, buffer, size), 0);  
         }  
         policy = "allow_read/write /proc/sys/net/ipv4/ip_local_port_range";  
         if (write_policy()) {  
                 static int name[] = { CTL_NET, NET_IPV4, NET_IPV4_LOCAL_PORT_RANGE };  
                 int buffer[2] = { 32768, 61000 };  
                 size_t size = sizeof(buffer);  
                 show_result(sysctl(name, 3, buffer, &size, buffer, size), 1);  
                 delete_policy();  
                 show_result(sysctl(name, 3, buffer, &size, buffer, size), 0);  
         }  
   
         policy = "allow_read /bin/true";  
         if (write_policy()) {  
                 show_result(uselib("/bin/true"), 1);  
                 delete_policy();  
                 show_result(uselib("/bin/true"), 0);  
         }  
   
         policy = "allow_execute /bin/true";  
         if (write_policy()) {  
                 int pipe_fd[2] = { EOF, EOF };  
                 int err = 0;  
                 fflush(stdout); fflush(stderr);  
                 pipe(pipe_fd);  
                 if (fork() == 0) {  
                         execl("/bin/true", "/bin/true", NULL);  
                         err = errno;  
                         write(pipe_fd[1], &err, sizeof(err));  
                         _exit(0);  
                 }  
                 close(pipe_fd[1]);  
                 read(pipe_fd[0], &err, sizeof(err));  
                 close(pipe_fd[0]);  
                 wait(NULL);  
                 errno = err;  
                 show_result(err ? EOF : 0, 1);  
                 delete_policy();  
                 fflush(stdout); fflush(stderr);  
                 pipe(pipe_fd);  
                 if (fork() == 0) {  
                         execl("/bin/true", "/bin/true", NULL);  
                         err = errno;  
                         write(pipe_fd[1], &err, sizeof(err));  
                         _exit(0);  
                 }  
                 close(pipe_fd[1]);  
                 read(pipe_fd[0], &err, sizeof(err));  
                 close(pipe_fd[0]);  
                 wait(NULL);  
                 errno = err;  
                 show_result(err ? EOF : 0, 0);  
         }  
   
         policy = "allow_read /dev/null";  
         if (write_policy()) {  
                 int fd = open("/dev/null", O_RDONLY);  
                 show_result(fd, 1);  
                 if (fd != EOF) close(fd);  
                 delete_policy();  
                 fd = open("/dev/null", O_RDONLY);  
                 show_result(fd, 0);  
                 if (fd != EOF) close(fd);  
         }  
   
         policy = "allow_write /dev/null";  
         if (write_policy()) {  
                 int fd = open("/dev/null", O_WRONLY);  
                 show_result(fd, 1);  
                 if (fd != EOF) close(fd);  
                 delete_policy();  
                 fd = open("/dev/null", O_WRONLY);  
                 show_result(fd, 0);  
                 if (fd != EOF) close(fd);  
         }  
109    
110          policy = "allow_read/write /dev/null";  static void mkfifo2(const char *pathname)
111          if (write_policy()) {  {
112                  int fd = open("/dev/null", O_RDWR);          set_profile(0, "file::mkfifo");
113                  show_result(fd, 1);          mkfifo(pathname, 0600);
114                  if (fd != EOF) close(fd);          set_profile(3, "file::mkfifo");
115                  delete_policy();          errno = 0;
116                  fd = open("/dev/null", O_RDWR);  }
                 show_result(fd, 0);  
                 if (fd != EOF) close(fd);  
         }  
117    
118          policy = "allow_create /tmp/open_test";  static void stage_file_test(void)
119          if (write_policy()) {  {
120                  policy = "allow_write /tmp/open_test";          static int name[] = { CTL_NET, NET_IPV4, NET_IPV4_LOCAL_PORT_RANGE };
121                  if (write_policy()) {          int buffer[2] = { 32768, 61000 };
122                          int fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0666);          size_t size = sizeof(buffer);
123                          show_result(fd, 1);          int pipe_fd[2] = { EOF, EOF };
124                          if (fd != EOF) close(fd);          int err = 0;
125                          unlink2("/tmp/open_test");          int fd;
126                          delete_policy();          char pbuffer[1024];
127                          fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0666);          struct stat sbuf;
128                          show_result(fd, 0);          struct sockaddr_un addr;
129                          if (fd != EOF) close(fd);          struct ifreq ifreq;
130                          unlink2("/tmp/open_test");          char *filename = "";
131                  }          set_profile(3, "file::execute");
132                  policy = "allow_create /tmp/open_test\n";          set_profile(3, "file::open");
133                  delete_policy();          set_profile(3, "file::create");
134          }          set_profile(3, "file::unlink");
135            set_profile(3, "file::mkdir");
136            set_profile(3, "file::rmdir");
137            set_profile(3, "file::mkfifo");
138            set_profile(3, "file::mksock");
139            set_profile(3, "file::truncate");
140            set_profile(3, "file::symlink");
141            set_profile(3, "file::rewrite");
142            set_profile(3, "file::mkblock");
143            set_profile(3, "file::mkchar");
144            set_profile(3, "file::link");
145            set_profile(3, "file::rename");
146            set_profile(3, "file::chmod");
147            set_profile(3, "file::chown");
148            set_profile(3, "file::chgrp");
149            set_profile(3, "file::ioctl");
150            set_profile(3, "file::chroot");
151            set_profile(3, "file::mount");
152            set_profile(3, "file::umount");
153            set_profile(3, "file::pivot_root");
154    
155            policy = "allow_read /proc/sys/net/ipv4/ip_local_port_range "
156                    "if task.uid=0 task.gid=0";
157            write_domain_policy(policy, 0);
158            show_result(sysctl(name, 3, buffer, &size, 0, 0), 1);
159            write_domain_policy(policy, 1);
160            show_result(sysctl(name, 3, buffer, &size, 0, 0), 0);
161    
162            policy = "allow_write /proc/sys/net/ipv4/ip_local_port_range "
163                    "if task.euid=0 0=0 1-100=10-1000";
164            write_domain_policy(policy, 0);
165            show_result(sysctl(name, 3, 0, 0, buffer, size), 1);
166            write_domain_policy(policy, 1);
167            show_result(sysctl(name, 3, 0, 0, buffer, size), 0);
168    
169            policy = "allow_read/write /proc/sys/net/ipv4/ip_local_port_range "
170                    "if 1!=10-100";
171            write_domain_policy(policy, 0);
172            show_result(sysctl(name, 3, buffer, &size, buffer, size), 1);
173            write_domain_policy(policy, 1);
174            show_result(sysctl(name, 3, buffer, &size, buffer, size), 0);
175    
176            policy = "allow_read /bin/true "
177                    "if path1.uid=0 path1.parent.uid=0 10=10-100";
178            write_domain_policy(policy, 0);
179            show_result(uselib("/bin/true"), 1);
180            write_domain_policy(policy, 1);
181            show_result(uselib("/bin/true"), 0);
182    
183            policy = "allow_execute /bin/true if task.uid!=10 path1.parent.uid=0";
184            write_domain_policy(policy, 0);
185            fflush(stdout);
186            fflush(stderr);
187            pipe(pipe_fd);
188            if (fork() == 0) {
189                    execl("/bin/true", "/bin/true", NULL);
190                    err = errno;
191                    write(pipe_fd[1], &err, sizeof(err));
192                    _exit(0);
193            }
194            close(pipe_fd[1]);
195            read(pipe_fd[0], &err, sizeof(err));
196            close(pipe_fd[0]);
197            wait(NULL);
198            errno = err;
199            show_result(err ? EOF : 0, 1);
200            write_domain_policy(policy, 1);
201            fflush(stdout);
202            fflush(stderr);
203            pipe(pipe_fd);
204            if (fork() == 0) {
205                    execl("/bin/true", "/bin/true", NULL);
206                    err = errno;
207                    write(pipe_fd[1], &err, sizeof(err));
208                    _exit(0);
209            }
210            close(pipe_fd[1]);
211            read(pipe_fd[0], &err, sizeof(err));
212            close(pipe_fd[0]);
213            wait(NULL);
214            errno = err;
215            show_result(err ? EOF : 0, 0);
216    
217            policy = "allow_read /dev/null if path1.type=char path1.dev_major=1 "
218                    "path1.dev_minor=3";
219            write_domain_policy(policy, 0);
220            fd = open("/dev/null", O_RDONLY);
221            show_result(fd, 1);
222            if (fd != EOF)
223                    close(fd);
224            write_domain_policy(policy, 1);
225            fd = open("/dev/null", O_RDONLY);
226            show_result(fd, 0);
227            if (fd != EOF)
228                    close(fd);
229    
230            policy = "allow_read /dev/null if path1.perm=0666";
231            write_domain_policy(policy, 0);
232            fd = open("/dev/null", O_RDONLY);
233            show_result(fd, 1);
234            if (fd != EOF)
235                    close(fd);
236            write_domain_policy(policy, 1);
237            fd = open("/dev/null", O_RDONLY);
238            show_result(fd, 0);
239            if (fd != EOF)
240                    close(fd);
241    
242            policy = "allow_read /dev/null if path1.perm!=0777";
243            write_domain_policy(policy, 0);
244            fd = open("/dev/null", O_RDONLY);
245            show_result(fd, 1);
246            if (fd != EOF)
247                    close(fd);
248            write_domain_policy(policy, 1);
249            fd = open("/dev/null", O_RDONLY);
250            show_result(fd, 0);
251            if (fd != EOF)
252                    close(fd);
253    
254            policy = "allow_read /dev/null if path1.perm=owner_read "
255                    "path1.perm=owner_write path1.perm!=owner_execute "
256                    "path1.perm=group_read path1.perm=group_write "
257                    "path1.perm!=group_execute path1.perm=others_read "
258                    "path1.perm=others_write path1.perm!=others_execute "
259                    "path1.perm!=setuid path1.perm!=setgid path1.perm!=sticky";
260            write_domain_policy(policy, 0);
261            fd = open("/dev/null", O_RDONLY);
262            show_result(fd, 1);
263            if (fd != EOF)
264                    close(fd);
265            write_domain_policy(policy, 1);
266            fd = open("/dev/null", O_RDONLY);
267            show_result(fd, 0);
268            if (fd != EOF)
269                    close(fd);
270    
271            set_profile(3, "file::mkfifo");
272            policy = "allow_mkfifo /tmp/mknod_fifo_test 0644 "
273                    "if path1.parent.perm=01777 path1.parent.perm=sticky "
274                    "path1.parent.uid=0 path1.parent.gid=0";
275            write_domain_policy(policy, 0);
276            filename = "/tmp/mknod_fifo_test";
277            show_result(mknod(filename, S_IFIFO | 0644, 0), 1);
278            write_domain_policy(policy, 1);
279            unlink2(filename);
280            show_result(mknod(filename, S_IFIFO | 0644, 0), 0);
281    
282          policy = "allow_write /tmp/open_test";          memset(pbuffer, 0, sizeof(pbuffer));
283          if (write_policy()) {          memset(&sbuf, 0, sizeof(sbuf));
284                  policy = "allow_create /tmp/open_test";          filename = "/dev/null";
285                  if (write_policy()) {          stat(filename, &sbuf);
286                          int fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0666);          snprintf(pbuffer, sizeof(pbuffer) - 1,
287                          show_result(fd, 1);                   "allow_write %s if path1.major=%u path1.minor=%u",
288                          if (fd != EOF) close(fd);                   filename, (unsigned int) MAJOR(sbuf.st_dev),
289                          unlink2("/tmp/open_test");                   (unsigned int) MINOR(sbuf.st_dev));
290                          delete_policy();          policy = pbuffer;
291                          fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0666);          write_domain_policy(policy, 0);
292                          show_result(fd, 0);          fd = open(filename, O_WRONLY);
293                          if (fd != EOF) close(fd);          show_result(fd, 1);
294                          unlink2("/tmp/open_test");          if (fd != EOF)
295                  }                  close(fd);
296                  policy = "allow_write /tmp/open_test\n";          write_domain_policy(policy, 1);
297                  delete_policy();          fd = open(filename, O_WRONLY);
298          }          show_result(fd, 0);
299            if (fd != EOF)
300                    close(fd);
301    
302            policy = "allow_read/write /tmp/fifo if path1.type=fifo";
303            mkfifo2("/tmp/fifo");
304            write_domain_policy(policy, 0);
305            fd = open("/tmp/fifo", O_RDWR);
306            show_result(fd, 1);
307            if (fd != EOF)
308                    close(fd);
309            write_domain_policy(policy, 1);
310            fd = open("/tmp/fifo", O_RDWR);
311            show_result(fd, 0);
312            if (fd != EOF)
313                    close(fd);
314    
315            policy = "allow_read /dev/null if path1.parent.ino=path1.parent.ino";
316            write_domain_policy(policy, 0);
317            fd = open("/dev/null", O_RDONLY);
318            show_result(fd, 1);
319            if (fd != EOF)
320                    close(fd);
321            write_domain_policy(policy, 1);
322            fd = open("/dev/null", O_RDONLY);
323            show_result(fd, 0);
324            if (fd != EOF)
325                    close(fd);
326    
327            policy = "allow_write /dev/null if path1.uid=path1.gid";
328            write_domain_policy(policy, 0);
329            fd = open("/dev/null", O_WRONLY);
330            show_result(fd, 1);
331            if (fd != EOF)
332                    close(fd);
333            write_domain_policy(policy, 1);
334            fd = open("/dev/null", O_WRONLY);
335            show_result(fd, 0);
336            if (fd != EOF)
337                    close(fd);
338    
339            policy = "allow_read/write /dev/null if task.uid=path1.parent.uid";
340            write_domain_policy(policy, 0);
341            fd = open("/dev/null", O_RDWR);
342            show_result(fd, 1);
343            if (fd != EOF)
344                    close(fd);
345            write_domain_policy(policy, 1);
346            fd = open("/dev/null", O_RDWR);
347            show_result(fd, 0);
348            if (fd != EOF)
349                    close(fd);
350    
351            policy = "allow_create /tmp/open_test 0644 "
352                    "if path1.parent.uid=task.uid";
353            write_domain_policy(policy, 0);
354            policy = "allow_write /tmp/open_test if path1.parent.uid=0";
355            write_domain_policy(policy, 0);
356            fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0644);
357            show_result(fd, 1);
358            if (fd != EOF)
359                    close(fd);
360            unlink2("/tmp/open_test");
361            write_domain_policy(policy, 1);
362            fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0644);
363            show_result(fd, 0);
364            if (fd != EOF)
365                    close(fd);
366            unlink2("/tmp/open_test");
367    
368            policy = "allow_create /tmp/open_test 0644 "
369                    "if path1.parent.uid=task.uid";
370            write_domain_policy(policy, 1);
371    
372            policy = "allow_write /tmp/open_test if task.uid=0 path1.ino!=0";
373            write_domain_policy(policy, 0);
374            policy = "allow_create /tmp/open_test 0644 if 0=0";
375            write_domain_policy(policy, 0);
376            fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0644);
377            show_result(fd, 1);
378            if (fd != EOF)
379                    close(fd);
380            unlink2("/tmp/open_test");
381            write_domain_policy(policy, 1);
382            fd = open("/tmp/open_test", O_WRONLY | O_CREAT | O_EXCL, 0644);
383            show_result(fd, 0);
384            if (fd != EOF)
385                    close(fd);
386            unlink2("/tmp/open_test");
387            policy = "allow_write /tmp/open_test if task.uid=0 path1.ino!=0";
388            write_domain_policy(policy, 1);
389    
390          filename = "/tmp/truncate_test";          filename = "/tmp/truncate_test";
391          create2(filename);          create2(filename);
392    
393          policy = "allow_truncate /tmp/truncate_test";          policy = "allow_truncate /tmp/truncate_test if task.uid=path1.uid";
394          if (write_policy()) {          write_domain_policy(policy, 0);
395                  policy = "allow_write /tmp/truncate_test";          policy = "allow_write /tmp/truncate_test if 1!=100-1000000";
396                  if (write_policy()) {          write_domain_policy(policy, 0);
397                          int fd = open(filename, O_WRONLY | O_TRUNC);          fd = open(filename, O_WRONLY | O_TRUNC);
398                          show_result(fd, 1);          show_result(fd, 1);
399                          if (fd != EOF) close(fd);          if (fd != EOF)
400                          delete_policy();                  close(fd);
401                          fd = open(filename, O_WRONLY | O_TRUNC);          write_domain_policy(policy, 1);
402                          show_result(fd, 0);          fd = open(filename, O_WRONLY | O_TRUNC);
403                          if (fd != EOF) close(fd);          show_result(fd, 0);
404                  }          if (fd != EOF)
405                  policy = "allow_truncate /tmp/truncate_test";                  close(fd);
406                  delete_policy();          policy = "allow_truncate /tmp/truncate_test "
407          }                  "if task.uid=path1.uid";
408            write_domain_policy(policy, 1);
409    
410          policy = "allow_write /tmp/truncate_test";          policy = "allow_write /tmp/truncate_test";
411          if (write_policy()) {          write_domain_policy(policy, 0);
                 policy = "allow_truncate /tmp/truncate_test";  
                 if (write_policy()) {  
                         int fd = open(filename, O_WRONLY | O_TRUNC);  
                         show_result(fd, 1);  
                         if (fd != EOF) close(fd);  
                         delete_policy();  
                         fd = open(filename, O_WRONLY | O_TRUNC);  
                         show_result(fd, 0);  
                         if (fd != EOF) close(fd);  
                 }  
                 policy = "allow_write /tmp/truncate_test\n";  
                 delete_policy();  
         }  
           
412          policy = "allow_truncate /tmp/truncate_test";          policy = "allow_truncate /tmp/truncate_test";
413          if (write_policy()) {          write_domain_policy(policy, 0);
414                  show_result(truncate(filename, 0), 1);          fd = open(filename, O_WRONLY | O_TRUNC);
415                  delete_policy();          show_result(fd, 1);
416                  show_result(truncate(filename, 0), 0);          if (fd != EOF)
417          }                  close(fd);
418            write_domain_policy(policy, 1);
419            fd = open(filename, O_WRONLY | O_TRUNC);
420            show_result(fd, 0);
421            if (fd != EOF)
422                    close(fd);
423            policy = "allow_write /tmp/truncate_test";
424            write_domain_policy(policy, 1);
425    
426          policy = "allow_truncate /tmp/truncate_test";          policy = "allow_truncate /tmp/truncate_test";
427          if (write_policy()) {          write_domain_policy(policy, 0);
428                  int fd;          show_result(truncate(filename, 0), 1);
429                  const char *cp = "255-MAC_FOR_FILE=disabled\n";          write_domain_policy(policy, 1);
430                  write(profile_fd, cp, strlen(cp));          show_result(truncate(filename, 0), 0);
431                  fd = open(filename, O_WRONLY);  
432                  cp = "255-MAC_FOR_FILE=enforcing\n";          policy = "allow_truncate /tmp/truncate_test";
433                  write(profile_fd, cp, strlen(cp));          write_domain_policy(policy, 0);
434                  show_result(ftruncate(fd, 0), 1);          set_profile(0, "file::open");
435                  delete_policy();          fd = open(filename, O_WRONLY);
436                  show_result(ftruncate(fd, 0), 0);          set_profile(3, "file::open");
437                  if (fd != EOF) close(fd);          show_result(ftruncate(fd, 0), 1);
438          }          write_domain_policy(policy, 1);
439                    show_result(ftruncate(fd, 0), 0);
440            if (fd != EOF)
441                    close(fd);
442    
443          unlink2(filename);          unlink2(filename);
           
         policy = "allow_create /tmp/mknod_reg_test";  
         if (write_policy()) {  
                 filename = "/tmp/mknod_reg_test";  
                 show_result(mknod(filename, S_IFREG, 0), 1);  
                 delete_policy();  
                 unlink2(filename);  
                 show_result(mknod(filename, S_IFREG, 0), 0);  
         }  
444    
445          policy = "allow_mkchar /tmp/mknod_chr_test";          policy = "allow_create /tmp/mknod_reg_test 0644";
446          if (write_policy()) {          write_domain_policy(policy, 0);
447                  filename = "/tmp/mknod_chr_test";          filename = "/tmp/mknod_reg_test";
448                  show_result(mknod(filename, S_IFCHR, MKDEV(1, 3)), 1);          show_result(mknod(filename, S_IFREG | 0644, 0), 1);
449                  delete_policy();          write_domain_policy(policy, 1);
450                  unlink2(filename);          unlink2(filename);
451                  show_result(mknod(filename, S_IFCHR, MKDEV(1, 3)), 0);          show_result(mknod(filename, S_IFREG | 0644, 0), 0);
         }  
452    
453          policy = "allow_mkblock /tmp/mknod_blk_test";          policy = "allow_mkchar /tmp/mknod_chr_test 0644 1 3";
454          if (write_policy()) {          write_domain_policy(policy, 0);
455                  filename = "/tmp/mknod_blk_test";          filename = "/tmp/mknod_chr_test";
456                  show_result(mknod(filename, S_IFBLK, MKDEV(1, 0)), 1);          show_result(mknod(filename, S_IFCHR | 0644, MKDEV(1, 3)), 1);
457                  delete_policy();          write_domain_policy(policy, 1);
458                  unlink2(filename);          unlink2(filename);
459                  show_result(mknod(filename, S_IFBLK, MKDEV(1, 0)), 0);          show_result(mknod(filename, S_IFCHR | 0644, MKDEV(1, 3)), 0);
         }  
460    
461          policy = "allow_mkfifo /tmp/mknod_fifo_test";          policy = "allow_mkblock /tmp/mknod_blk_test 0644 1 0";
462          if (write_policy()) {          write_domain_policy(policy, 0);
463                  filename = "/tmp/mknod_fifo_test";          filename = "/tmp/mknod_blk_test";
464                  show_result(mknod(filename, S_IFIFO, 0), 1);          show_result(mknod(filename, S_IFBLK | 0644, MKDEV(1, 0)), 1);
465                  delete_policy();          write_domain_policy(policy, 1);
466                  unlink2(filename);          unlink2(filename);
467                  show_result(mknod(filename, S_IFIFO, 0), 0);          show_result(mknod(filename, S_IFBLK | 0644, MKDEV(1, 0)), 0);
468          }  
469            policy = "allow_mkfifo /tmp/mknod_fifo_test 0644";
470            write_domain_policy(policy, 0);
471            filename = "/tmp/mknod_fifo_test";
472            show_result(mknod(filename, S_IFIFO | 0644, 0), 1);
473            write_domain_policy(policy, 1);
474            unlink2(filename);
475            show_result(mknod(filename, S_IFIFO | 0644, 0), 0);
476    
477            policy = "allow_mksock /tmp/mknod_sock_test 0644";
478            write_domain_policy(policy, 0);
479            filename = "/tmp/mknod_sock_test";
480            show_result(mknod(filename, S_IFSOCK | 0644, 0), 1);
481            write_domain_policy(policy, 1);
482            unlink2(filename);
483            show_result(mknod(filename, S_IFSOCK | 0644, 0), 0);
484    
485            policy = "allow_mkdir /tmp/mkdir_test/ 0600";
486            write_domain_policy(policy, 0);
487            filename = "/tmp/mkdir_test";
488            show_result(mkdir(filename, 0600), 1);
489            write_domain_policy(policy, 1);
490            rmdir2(filename);
491            show_result(mkdir(filename, 0600), 0);
492    
         policy = "allow_mksock /tmp/mknod_sock_test";  
         if (write_policy()) {  
                 filename = "/tmp/mknod_sock_test";  
                 show_result(mknod(filename, S_IFSOCK, 0), 1);  
                 delete_policy();  
                 unlink2(filename);  
                 show_result(mknod(filename, S_IFSOCK, 0), 0);  
         }  
           
         policy = "allow_mkdir /tmp/mkdir_test/";  
         if (write_policy()) {  
                 filename = "/tmp/mkdir_test";  
                 show_result(mkdir(filename, 0600), 1);  
                 delete_policy();  
                 rmdir2(filename);  
                 show_result(mkdir(filename, 0600), 0);  
         }  
           
493          policy = "allow_rmdir /tmp/rmdir_test/";          policy = "allow_rmdir /tmp/rmdir_test/";
494          if (write_policy()) {          write_domain_policy(policy, 0);
495                  filename = "/tmp/rmdir_test";          filename = "/tmp/rmdir_test";
496                  mkdir2(filename);          mkdir2(filename);
497                  show_result(rmdir(filename), 1);          show_result(rmdir(filename), 1);
498                  delete_policy();          write_domain_policy(policy, 1);
499                  mkdir2(filename);          mkdir2(filename);
500                  show_result(rmdir(filename), 0);          show_result(rmdir(filename), 0);
501                  rmdir2(filename);          rmdir2(filename);
502          }  
           
503          policy = "allow_unlink /tmp/unlink_test";          policy = "allow_unlink /tmp/unlink_test";
504          if (write_policy()) {          write_domain_policy(policy, 0);
505                  filename = "/tmp/unlink_test";          filename = "/tmp/unlink_test";
506                  create2(filename);          create2(filename);
507                  show_result(unlink(filename), 1);          show_result(unlink(filename), 1);
508                  delete_policy();          write_domain_policy(policy, 1);
509                  create2(filename);          create2(filename);
510                  show_result(unlink(filename), 0);          show_result(unlink(filename), 0);
511                  unlink2(filename);          unlink2(filename);
512          }  
           
513          policy = "allow_symlink /tmp/symlink_source_test";          policy = "allow_symlink /tmp/symlink_source_test";
514          if (write_policy()) {          write_domain_policy(policy, 0);
515                  filename = "/tmp/symlink_source_test";          filename = "/tmp/symlink_source_test";
516                  show_result(symlink("/tmp/symlink_dest_test", filename), 1);          show_result(symlink("/tmp/symlink_dest_test", filename), 1);
517                  delete_policy();          write_domain_policy(policy, 1);
518                  unlink2(filename);          unlink2(filename);
519                  show_result(symlink("/tmp/symlink_dest_test", filename), 0);          show_result(symlink("/tmp/symlink_dest_test", filename), 0);
520          }  
521                    policy = "allow_symlink /tmp/symlink_source_test "
522                    "if symlink.target=\"/tmp/symlink_\\*_test\"";
523            write_domain_policy(policy, 0);
524            filename = "/tmp/symlink_source_test";
525            show_result(symlink("/tmp/symlink_dest_test", filename), 1);
526            write_domain_policy(policy, 1);
527            unlink2(filename);
528            show_result(symlink("/tmp/symlink_dest_test", filename), 0);
529    
530            policy = "allow_symlink /tmp/symlink_source_test "
531                    "if task.uid=0 symlink.target=\"/tmp/symlink_\\*_test\"";
532            write_domain_policy(policy, 0);
533            filename = "/tmp/symlink_source_test";
534            show_result(symlink("/tmp/symlink_dest_test", filename), 1);
535            write_domain_policy(policy, 1);
536            unlink2(filename);
537            show_result(symlink("/tmp/symlink_dest_test", filename), 0);
538    
539            policy = "allow_symlink /tmp/symlink_source_test "
540                    "if symlink.target!=\"\\*\"";
541            write_domain_policy(policy, 0);
542            filename = "/tmp/symlink_source_test";
543            show_result(symlink("/tmp/symlink_dest_test", filename), 1);
544            write_domain_policy(policy, 1);
545            unlink2(filename);
546            show_result(symlink("/tmp/symlink_dest_test", filename), 0);
547    
548            policy = "allow_symlink /tmp/symlink_source_test "
549                    "if symlink.target!=\"/tmp/symlink_\\*_test\"";
550            write_domain_policy(policy, 0);
551            filename = "/tmp/symlink_source_test";
552            show_result(symlink("/tmp/symlink_dest_test", filename), 0);
553            write_domain_policy(policy, 1);
554            unlink2(filename);
555            show_result(symlink("/tmp/symlink_dest_test", filename), 0);
556    
557          policy = "allow_link /tmp/link_source_test /tmp/link_dest_test";          policy = "allow_link /tmp/link_source_test /tmp/link_dest_test";
558          if (write_policy()) {          write_domain_policy(policy, 0);
559                  filename = "/tmp/link_source_test";          filename = "/tmp/link_source_test";
560                  create2(filename);          create2(filename);
561                  show_result(link(filename, "/tmp/link_dest_test"), 1);          show_result(link(filename, "/tmp/link_dest_test"), 1);
562                  delete_policy();          write_domain_policy(policy, 1);
563                  unlink2("/tmp/link_dest_test");          unlink2("/tmp/link_dest_test");
564                  show_result(link(filename, "/tmp/link_dest_test"), 0);          show_result(link(filename, "/tmp/link_dest_test"), 0);
565                  unlink2(filename);          unlink2(filename);
         }  
566    
567          policy = "allow_rename /tmp/rename_source_test /tmp/rename_dest_test";          policy = "allow_rename /tmp/rename_source_test /tmp/rename_dest_test";
568          if (write_policy()) {          write_domain_policy(policy, 0);
569                  filename = "/tmp/rename_source_test";          filename = "/tmp/rename_source_test";
570                  create2(filename);          create2(filename);
571                  show_result(rename(filename, "/tmp/rename_dest_test"), 1);          show_result(rename(filename, "/tmp/rename_dest_test"), 1);
572                  delete_policy();          write_domain_policy(policy, 1);
573                  unlink2("/tmp/rename_dest_test");          unlink2("/tmp/rename_dest_test");
574                  create2(filename);          create2(filename);
575                  show_result(rename(filename, "/tmp/rename_dest_test"), 0);          show_result(rename(filename, "/tmp/rename_dest_test"), 0);
576                  unlink2(filename);          unlink2(filename);
         }  
577    
578          policy = "allow_mksock /tmp/socket_test";          policy = "allow_mksock /tmp/socket_test 0755";
579          if (write_policy()) {          write_domain_policy(policy, 0);
580                  struct sockaddr_un addr;          filename = "/tmp/socket_test";
581                  int fd;          memset(&addr, 0, sizeof(addr));
582                  filename = "/tmp/socket_test";          addr.sun_family = AF_UNIX;
583                  memset(&addr, 0, sizeof(addr));          strncpy(addr.sun_path, filename, sizeof(addr.sun_path) - 1);
584                  addr.sun_family = AF_UNIX;          fd = socket(AF_UNIX, SOCK_STREAM, 0);
585                  strncpy(addr.sun_path, filename, sizeof(addr.sun_path) - 1);          show_result(bind(fd, (struct sockaddr *) &addr, sizeof(addr)),
586                  fd = socket(AF_UNIX, SOCK_STREAM, 0);                      1);
587                  show_result(bind(fd, (struct sockaddr *) &addr, sizeof(addr)), 1);          if (fd != EOF)
588                  if (fd != EOF) close(fd);                  close(fd);
589                  delete_policy();          write_domain_policy(policy, 1);
590                  unlink2(filename);          unlink2(filename);
591                  fd = socket(AF_UNIX, SOCK_STREAM, 0);          fd = socket(AF_UNIX, SOCK_STREAM, 0);
592                  show_result(bind(fd, (struct sockaddr *) &addr, sizeof(addr)), 0);          show_result(bind(fd, (struct sockaddr *) &addr, sizeof(addr)),
593                  if (fd != EOF) close(fd);                      0);
594          }          if (fd != EOF)
595                    close(fd);
596    
597          filename = "/tmp/rewrite_test";          filename = "/tmp/rewrite_test";
598          create2(filename);          create2(filename);
599          policy = "allow_read/write /tmp/rewrite_test";          policy = "allow_read/write /tmp/rewrite_test";
600          if (write_policy()) {          write_domain_policy(policy, 0);
601                  char *cp = "deny_rewrite /tmp/rewrite_test\n";          write_exception_policy("deny_rewrite /tmp/rewrite_test", 0);
602                  write(exception_fd, cp, strlen(cp));          policy = "allow_truncate /tmp/rewrite_test";
603                  policy = "allow_truncate /tmp/rewrite_test";          write_domain_policy(policy, 0);
604                  if (write_policy()) {  
605                          int fd;          fd = open(filename, O_RDONLY);
606            show_result(fd, 1);
607                          fd = open(filename, O_RDONLY);          if (fd != EOF)
608                          show_result(fd, 1);                  close(fd);
609                          if (fd != EOF) close(fd);  
610                                    fd = open(filename, O_WRONLY | O_APPEND);
611                          fd = open(filename, O_WRONLY | O_APPEND);          show_result(fd, 1);
612                          show_result(fd, 1);          if (fd != EOF)
613                          if (fd != EOF) close(fd);                  close(fd);
614                            
615                          fd = open(filename, O_WRONLY);          fd = open(filename, O_WRONLY);
616                          show_result(fd, 0);          show_result(fd, 0);
617                          if (fd != EOF) close(fd);          if (fd != EOF)
618                                            close(fd);
619                          fd = open(filename, O_WRONLY | O_TRUNC);  
620                          show_result(fd, 0);          fd = open(filename, O_WRONLY | O_TRUNC);
621                          if (fd != EOF) close(fd);          show_result(fd, 0);
622                                    if (fd != EOF)
623                          fd = open(filename, O_WRONLY | O_TRUNC | O_APPEND);                  close(fd);
624                          show_result(fd, 0);  
625                          if (fd != EOF) close(fd);          fd = open(filename, O_WRONLY | O_TRUNC | O_APPEND);
626                                    show_result(fd, 0);
627                          show_result(truncate(filename, 0), 0);          if (fd != EOF)
628                                            close(fd);
629                          cp = "255-MAC_FOR_FILE=disabled\n";  
630                          write(profile_fd, cp, strlen(cp));          show_result(truncate(filename, 0), 0);
631                          fd = open(filename, O_WRONLY | O_APPEND);  
632                          cp = "255-MAC_FOR_FILE=enforcing\n";          set_profile(0, "file::open");
633                          write(profile_fd, cp, strlen(cp));          fd = open(filename, O_WRONLY | O_APPEND);
634                          show_result(ftruncate(fd, 0), 0);          set_profile(3, "file::open");
635                                    show_result(ftruncate(fd, 0), 0);
636                          show_result(fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_APPEND), 0);  
637                          if (fd != EOF) close(fd);          show_result(fcntl(fd, F_SETFL,
638                              fcntl(fd, F_GETFL) & ~O_APPEND), 0);
639            if (fd != EOF)
640                    close(fd);
641    
642            write_domain_policy(policy, 1);
643    
644            policy = "allow_read/write /tmp/rewrite_test";
645            write_domain_policy(policy, 1);
646            write_exception_policy("deny_rewrite /tmp/rewrite_test", 1);
647    
                         delete_policy();  
                 }  
                 policy = "allow_read/write /tmp/rewrite_test";  
                 delete_policy();  
                 cp = "delete deny_rewrite /tmp/rewrite_test\n";  
                 write(exception_fd, cp, strlen(cp));  
         }  
648          unlink2(filename);          unlink2(filename);
649    
650            policy = "allow_ioctl socket:[family=2:type=2:protocol=17] "
651                    "35122-35124 if task.uid=0";
652            write_domain_policy(policy, 0);
653            fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
654            memset(&ifreq, 0, sizeof(ifreq));
655            snprintf(ifreq.ifr_name, sizeof(ifreq.ifr_name) - 1,
656                     "lo");
657            show_result(ioctl(fd, 35123, &ifreq), 1);
658            write_domain_policy(policy, 1);
659            policy = "allow_ioctl "
660                    "socket:[family=2:type=2:protocol=17] 0-35122";
661            write_domain_policy(policy, 0);
662            show_result(ioctl(fd, 35123, &ifreq), 0);
663            write_domain_policy(policy, 1);
664            if (fd != EOF)
665                    close(fd);
666  }  }
667    
668  int main(int argc, char *argv[]) {  int main(int argc, char *argv[])
669          char *cp;  {
670          Init();          ccs_test_init();
671          profile_fd = open(proc_policy_profile, O_WRONLY);          fprintf(domain_fp, "%s /bin/true\n", self_domain);
672          domain_fd = open(proc_policy_domain_policy, O_WRONLY);          fprintf(domain_fp, "use_profile 255\n");
673          exception_fd = open(proc_policy_exception_policy, O_WRONLY);          fprintf(domain_fp, "select pid=%u\n", pid);
674          {          fprintf(profile_fp, "255-MAX_REJECT_LOG=1024\n");
675                  int self_fd = open(proc_policy_self_domain, O_RDONLY);          stage_file_test();
676                  memset(self_domain, 0, sizeof(self_domain));          fprintf(domain_fp, "use_profile 0\n");
677                  read(self_fd, self_domain, sizeof(self_domain) - 1);          clear_status();
                 close(self_fd);  
                 write(domain_fd, self_domain, strlen(self_domain));  
                 cp = " /bin/true\n";  
                 write(domain_fd, cp, strlen(cp));  
                 write(domain_fd, self_domain, strlen(self_domain));  
                 write(domain_fd, "\n", 1);  
                 cp = "use_profile 255\n";  
                 write(domain_fd, cp, strlen(cp));  
         }  
         cp = "255-MAX_REJECT_LOG=1024\n";  
         write(profile_fd, cp, strlen(cp));  
         StageFileTest();  
         cp = "use_profile 0\n";  
         write(domain_fd, cp, strlen(cp));  
         ClearStatus();  
678          return 0;          return 0;
679  }  }
Legend:
Removed from v.1067  
changed lines
  Added in v.2985
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ