Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
c3ef1500 | 2 | /* |
0f2a55d5 | 3 | * security/tomoyo/securityfs_if.c |
c3ef1500 | 4 | * |
0f2a55d5 | 5 | * Copyright (C) 2005-2011 NTT DATA CORPORATION |
c3ef1500 TH |
6 | */ |
7 | ||
8 | #include <linux/security.h> | |
9 | #include "common.h" | |
10 | ||
731d37aa TH |
11 | /** |
12 | * tomoyo_check_task_acl - Check permission for task operation. | |
13 | * | |
14 | * @r: Pointer to "struct tomoyo_request_info". | |
15 | * @ptr: Pointer to "struct tomoyo_acl_info". | |
16 | * | |
17 | * Returns true if granted, false otherwise. | |
18 | */ | |
19 | static bool tomoyo_check_task_acl(struct tomoyo_request_info *r, | |
20 | const struct tomoyo_acl_info *ptr) | |
21 | { | |
22 | const struct tomoyo_task_acl *acl = container_of(ptr, typeof(*acl), | |
23 | head); | |
cdcf6723 | 24 | |
731d37aa TH |
25 | return !tomoyo_pathcmp(r->param.task.domainname, acl->domainname); |
26 | } | |
27 | ||
28 | /** | |
29 | * tomoyo_write_self - write() for /sys/kernel/security/tomoyo/self_domain interface. | |
30 | * | |
31 | * @file: Pointer to "struct file". | |
32 | * @buf: Domainname to transit to. | |
33 | * @count: Size of @buf. | |
34 | * @ppos: Unused. | |
35 | * | |
36 | * Returns @count on success, negative value otherwise. | |
37 | * | |
38 | * If domain transition was permitted but the domain transition failed, this | |
39 | * function returns error rather than terminating current thread with SIGKILL. | |
40 | */ | |
41 | static ssize_t tomoyo_write_self(struct file *file, const char __user *buf, | |
42 | size_t count, loff_t *ppos) | |
43 | { | |
44 | char *data; | |
45 | int error; | |
cdcf6723 | 46 | |
731d37aa TH |
47 | if (!count || count >= TOMOYO_EXEC_TMPSIZE - 10) |
48 | return -ENOMEM; | |
16e5c1fc AV |
49 | data = memdup_user_nul(buf, count); |
50 | if (IS_ERR(data)) | |
51 | return PTR_ERR(data); | |
731d37aa TH |
52 | tomoyo_normalize_line(data); |
53 | if (tomoyo_correct_domain(data)) { | |
54 | const int idx = tomoyo_read_lock(); | |
55 | struct tomoyo_path_info name; | |
56 | struct tomoyo_request_info r; | |
cdcf6723 | 57 | |
731d37aa TH |
58 | name.name = data; |
59 | tomoyo_fill_path_info(&name); | |
60 | /* Check "task manual_domain_transition" permission. */ | |
61 | tomoyo_init_request_info(&r, NULL, TOMOYO_MAC_FILE_EXECUTE); | |
62 | r.param_type = TOMOYO_TYPE_MANUAL_TASK_ACL; | |
63 | r.param.task.domainname = &name; | |
64 | tomoyo_check_acl(&r, tomoyo_check_task_acl); | |
65 | if (!r.granted) | |
66 | error = -EPERM; | |
67 | else { | |
68 | struct tomoyo_domain_info *new_domain = | |
69 | tomoyo_assign_domain(data, true); | |
70 | if (!new_domain) { | |
71 | error = -ENOENT; | |
72 | } else { | |
8c6cb983 TH |
73 | struct tomoyo_task *s = tomoyo_task(current); |
74 | struct tomoyo_domain_info *old_domain = | |
75 | s->domain_info; | |
43fc4609 | 76 | |
8c6cb983 TH |
77 | s->domain_info = new_domain; |
78 | atomic_inc(&new_domain->users); | |
79 | atomic_dec(&old_domain->users); | |
80 | error = 0; | |
731d37aa TH |
81 | } |
82 | } | |
83 | tomoyo_read_unlock(idx); | |
84 | } else | |
85 | error = -EINVAL; | |
731d37aa TH |
86 | kfree(data); |
87 | return error ? error : count; | |
88 | } | |
89 | ||
90 | /** | |
91 | * tomoyo_read_self - read() for /sys/kernel/security/tomoyo/self_domain interface. | |
92 | * | |
93 | * @file: Pointer to "struct file". | |
94 | * @buf: Domainname which current thread belongs to. | |
95 | * @count: Size of @buf. | |
96 | * @ppos: Bytes read by now. | |
97 | * | |
98 | * Returns read size on success, negative value otherwise. | |
99 | */ | |
100 | static ssize_t tomoyo_read_self(struct file *file, char __user *buf, | |
101 | size_t count, loff_t *ppos) | |
102 | { | |
103 | const char *domain = tomoyo_domain()->domainname->name; | |
104 | loff_t len = strlen(domain); | |
105 | loff_t pos = *ppos; | |
cdcf6723 | 106 | |
731d37aa TH |
107 | if (pos >= len || !count) |
108 | return 0; | |
109 | len -= pos; | |
110 | if (count < len) | |
111 | len = count; | |
112 | if (copy_to_user(buf, domain + pos, len)) | |
113 | return -EFAULT; | |
114 | *ppos += len; | |
115 | return len; | |
116 | } | |
117 | ||
118 | /* Operations for /sys/kernel/security/tomoyo/self_domain interface. */ | |
119 | static const struct file_operations tomoyo_self_operations = { | |
120 | .write = tomoyo_write_self, | |
121 | .read = tomoyo_read_self, | |
122 | }; | |
123 | ||
c3ef1500 TH |
124 | /** |
125 | * tomoyo_open - open() for /sys/kernel/security/tomoyo/ interface. | |
126 | * | |
127 | * @inode: Pointer to "struct inode". | |
128 | * @file: Pointer to "struct file". | |
129 | * | |
130 | * Returns 0 on success, negative value otherwise. | |
131 | */ | |
132 | static int tomoyo_open(struct inode *inode, struct file *file) | |
133 | { | |
496ad9aa | 134 | const int key = ((u8 *) file_inode(file)->i_private) |
c3ef1500 TH |
135 | - ((u8 *) NULL); |
136 | return tomoyo_open_control(key, file); | |
137 | } | |
138 | ||
139 | /** | |
140 | * tomoyo_release - close() for /sys/kernel/security/tomoyo/ interface. | |
141 | * | |
c3ef1500 TH |
142 | * @file: Pointer to "struct file". |
143 | * | |
c3ef1500 TH |
144 | */ |
145 | static int tomoyo_release(struct inode *inode, struct file *file) | |
146 | { | |
e53cfda5 AV |
147 | tomoyo_close_control(file->private_data); |
148 | return 0; | |
c3ef1500 TH |
149 | } |
150 | ||
0849e3ba | 151 | /** |
b5bc60b4 | 152 | * tomoyo_poll - poll() for /sys/kernel/security/tomoyo/ interface. |
0849e3ba TH |
153 | * |
154 | * @file: Pointer to "struct file". | |
6041e834 | 155 | * @wait: Pointer to "poll_table". Maybe NULL. |
0849e3ba | 156 | * |
a9a08845 LT |
157 | * Returns EPOLLIN | EPOLLRDNORM | EPOLLOUT | EPOLLWRNORM if ready to read/write, |
158 | * EPOLLOUT | EPOLLWRNORM otherwise. | |
0849e3ba | 159 | */ |
c0d4be28 | 160 | static __poll_t tomoyo_poll(struct file *file, poll_table *wait) |
0849e3ba TH |
161 | { |
162 | return tomoyo_poll_control(file, wait); | |
163 | } | |
164 | ||
c3ef1500 TH |
165 | /** |
166 | * tomoyo_read - read() for /sys/kernel/security/tomoyo/ interface. | |
167 | * | |
168 | * @file: Pointer to "struct file". | |
169 | * @buf: Pointer to buffer. | |
170 | * @count: Size of @buf. | |
171 | * @ppos: Unused. | |
172 | * | |
173 | * Returns bytes read on success, negative value otherwise. | |
174 | */ | |
175 | static ssize_t tomoyo_read(struct file *file, char __user *buf, size_t count, | |
176 | loff_t *ppos) | |
177 | { | |
0df7e8b8 | 178 | return tomoyo_read_control(file->private_data, buf, count); |
c3ef1500 TH |
179 | } |
180 | ||
181 | /** | |
182 | * tomoyo_write - write() for /sys/kernel/security/tomoyo/ interface. | |
183 | * | |
184 | * @file: Pointer to "struct file". | |
185 | * @buf: Pointer to buffer. | |
186 | * @count: Size of @buf. | |
187 | * @ppos: Unused. | |
188 | * | |
189 | * Returns @count on success, negative value otherwise. | |
190 | */ | |
191 | static ssize_t tomoyo_write(struct file *file, const char __user *buf, | |
192 | size_t count, loff_t *ppos) | |
193 | { | |
0df7e8b8 | 194 | return tomoyo_write_control(file->private_data, buf, count); |
c3ef1500 TH |
195 | } |
196 | ||
197 | /* | |
198 | * tomoyo_operations is a "struct file_operations" which is used for handling | |
199 | * /sys/kernel/security/tomoyo/ interface. | |
200 | * | |
201 | * Some files under /sys/kernel/security/tomoyo/ directory accept open(O_RDWR). | |
202 | * See tomoyo_io_buffer for internals. | |
203 | */ | |
204 | static const struct file_operations tomoyo_operations = { | |
205 | .open = tomoyo_open, | |
206 | .release = tomoyo_release, | |
0849e3ba | 207 | .poll = tomoyo_poll, |
c3ef1500 TH |
208 | .read = tomoyo_read, |
209 | .write = tomoyo_write, | |
7e2deb7c | 210 | .llseek = noop_llseek, |
c3ef1500 TH |
211 | }; |
212 | ||
213 | /** | |
214 | * tomoyo_create_entry - Create interface files under /sys/kernel/security/tomoyo/ directory. | |
215 | * | |
216 | * @name: The name of the interface file. | |
217 | * @mode: The permission of the interface file. | |
218 | * @parent: The parent directory. | |
219 | * @key: Type of interface. | |
220 | * | |
221 | * Returns nothing. | |
222 | */ | |
52ef0c04 | 223 | static void __init tomoyo_create_entry(const char *name, const umode_t mode, |
c3ef1500 TH |
224 | struct dentry *parent, const u8 key) |
225 | { | |
226 | securityfs_create_file(name, mode, parent, ((u8 *) NULL) + key, | |
227 | &tomoyo_operations); | |
228 | } | |
229 | ||
230 | /** | |
231 | * tomoyo_initerface_init - Initialize /sys/kernel/security/tomoyo/ interface. | |
232 | * | |
233 | * Returns 0. | |
234 | */ | |
235 | static int __init tomoyo_initerface_init(void) | |
236 | { | |
43fc4609 | 237 | struct tomoyo_domain_info *domain; |
c3ef1500 TH |
238 | struct dentry *tomoyo_dir; |
239 | ||
43fc4609 CS |
240 | if (!tomoyo_enabled) |
241 | return 0; | |
242 | domain = tomoyo_domain(); | |
c3ef1500 | 243 | /* Don't create securityfs entries unless registered. */ |
43fc4609 | 244 | if (domain != &tomoyo_kernel_domain) |
c3ef1500 TH |
245 | return 0; |
246 | ||
247 | tomoyo_dir = securityfs_create_dir("tomoyo", NULL); | |
248 | tomoyo_create_entry("query", 0600, tomoyo_dir, | |
249 | TOMOYO_QUERY); | |
250 | tomoyo_create_entry("domain_policy", 0600, tomoyo_dir, | |
251 | TOMOYO_DOMAINPOLICY); | |
252 | tomoyo_create_entry("exception_policy", 0600, tomoyo_dir, | |
253 | TOMOYO_EXCEPTIONPOLICY); | |
eadd99cc TH |
254 | tomoyo_create_entry("audit", 0400, tomoyo_dir, |
255 | TOMOYO_AUDIT); | |
c3ef1500 TH |
256 | tomoyo_create_entry(".process_status", 0600, tomoyo_dir, |
257 | TOMOYO_PROCESS_STATUS); | |
b22b8b9f TH |
258 | tomoyo_create_entry("stat", 0644, tomoyo_dir, |
259 | TOMOYO_STAT); | |
c3ef1500 TH |
260 | tomoyo_create_entry("profile", 0600, tomoyo_dir, |
261 | TOMOYO_PROFILE); | |
262 | tomoyo_create_entry("manager", 0600, tomoyo_dir, | |
263 | TOMOYO_MANAGER); | |
264 | tomoyo_create_entry("version", 0400, tomoyo_dir, | |
265 | TOMOYO_VERSION); | |
731d37aa TH |
266 | securityfs_create_file("self_domain", 0666, tomoyo_dir, NULL, |
267 | &tomoyo_self_operations); | |
778c4a4d | 268 | tomoyo_load_builtin_policy(); |
c3ef1500 TH |
269 | return 0; |
270 | } | |
271 | ||
272 | fs_initcall(tomoyo_initerface_init); |