]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
2106ccd9 TH |
2 | /* |
3 | * security/tomoyo/mount.c | |
4 | * | |
0f2a55d5 | 5 | * Copyright (C) 2005-2011 NTT DATA CORPORATION |
2106ccd9 TH |
6 | */ |
7 | ||
8 | #include <linux/slab.h> | |
e262e32d | 9 | #include <uapi/linux/mount.h> |
2106ccd9 TH |
10 | #include "common.h" |
11 | ||
b5bc60b4 TH |
12 | /* String table for special mount operations. */ |
13 | static const char * const tomoyo_mounts[TOMOYO_MAX_SPECIAL_MOUNT] = { | |
14 | [TOMOYO_MOUNT_BIND] = "--bind", | |
15 | [TOMOYO_MOUNT_MOVE] = "--move", | |
16 | [TOMOYO_MOUNT_REMOUNT] = "--remount", | |
17 | [TOMOYO_MOUNT_MAKE_UNBINDABLE] = "--make-unbindable", | |
18 | [TOMOYO_MOUNT_MAKE_PRIVATE] = "--make-private", | |
19 | [TOMOYO_MOUNT_MAKE_SLAVE] = "--make-slave", | |
20 | [TOMOYO_MOUNT_MAKE_SHARED] = "--make-shared", | |
21 | }; | |
2106ccd9 | 22 | |
99a85259 TH |
23 | /** |
24 | * tomoyo_audit_mount_log - Audit mount log. | |
25 | * | |
26 | * @r: Pointer to "struct tomoyo_request_info". | |
27 | * | |
28 | * Returns 0 on success, negative value otherwise. | |
29 | */ | |
30 | static int tomoyo_audit_mount_log(struct tomoyo_request_info *r) | |
31 | { | |
eadd99cc | 32 | return tomoyo_supervisor(r, "file mount %s %s %s 0x%lX\n", |
7c75964f | 33 | r->param.mount.dev->name, |
eadd99cc TH |
34 | r->param.mount.dir->name, |
35 | r->param.mount.type->name, | |
36 | r->param.mount.flags); | |
99a85259 TH |
37 | } |
38 | ||
0df7e8b8 TH |
39 | /** |
40 | * tomoyo_check_mount_acl - Check permission for path path path number operation. | |
41 | * | |
42 | * @r: Pointer to "struct tomoyo_request_info". | |
43 | * @ptr: Pointer to "struct tomoyo_acl_info". | |
44 | * | |
45 | * Returns true if granted, false otherwise. | |
46 | */ | |
484ca79c | 47 | static bool tomoyo_check_mount_acl(struct tomoyo_request_info *r, |
99a85259 TH |
48 | const struct tomoyo_acl_info *ptr) |
49 | { | |
50 | const struct tomoyo_mount_acl *acl = | |
51 | container_of(ptr, typeof(*acl), head); | |
cdcf6723 | 52 | |
0df7e8b8 TH |
53 | return tomoyo_compare_number_union(r->param.mount.flags, |
54 | &acl->flags) && | |
55 | tomoyo_compare_name_union(r->param.mount.type, | |
56 | &acl->fs_type) && | |
57 | tomoyo_compare_name_union(r->param.mount.dir, | |
58 | &acl->dir_name) && | |
99a85259 | 59 | (!r->param.mount.need_dev || |
0df7e8b8 TH |
60 | tomoyo_compare_name_union(r->param.mount.dev, |
61 | &acl->dev_name)); | |
99a85259 TH |
62 | } |
63 | ||
2106ccd9 | 64 | /** |
d795ef9e | 65 | * tomoyo_mount_acl - Check permission for mount() operation. |
2106ccd9 TH |
66 | * |
67 | * @r: Pointer to "struct tomoyo_request_info". | |
0f2a55d5 | 68 | * @dev_name: Name of device file. Maybe NULL. |
2106ccd9 TH |
69 | * @dir: Pointer to "struct path". |
70 | * @type: Name of filesystem type. | |
71 | * @flags: Mount options. | |
72 | * | |
73 | * Returns 0 on success, negative value otherwise. | |
74 | * | |
75 | * Caller holds tomoyo_read_lock(). | |
76 | */ | |
808d4e3c AV |
77 | static int tomoyo_mount_acl(struct tomoyo_request_info *r, |
78 | const char *dev_name, | |
e6641edd | 79 | const struct path *dir, const char *type, |
b5bc60b4 | 80 | unsigned long flags) |
2106ccd9 | 81 | { |
97fb35e4 | 82 | struct tomoyo_obj_info obj = { }; |
2106ccd9 | 83 | struct path path; |
2106ccd9 TH |
84 | struct file_system_type *fstype = NULL; |
85 | const char *requested_type = NULL; | |
86 | const char *requested_dir_name = NULL; | |
87 | const char *requested_dev_name = NULL; | |
88 | struct tomoyo_path_info rtype; | |
89 | struct tomoyo_path_info rdev; | |
90 | struct tomoyo_path_info rdir; | |
91 | int need_dev = 0; | |
92 | int error = -ENOMEM; | |
cdcf6723 | 93 | |
97fb35e4 | 94 | r->obj = &obj; |
2106ccd9 TH |
95 | |
96 | /* Get fstype. */ | |
c8c57e84 | 97 | requested_type = tomoyo_encode(type); |
2106ccd9 TH |
98 | if (!requested_type) |
99 | goto out; | |
100 | rtype.name = requested_type; | |
101 | tomoyo_fill_path_info(&rtype); | |
102 | ||
103 | /* Get mount point. */ | |
97fb35e4 | 104 | obj.path2 = *dir; |
2106ccd9 TH |
105 | requested_dir_name = tomoyo_realpath_from_path(dir); |
106 | if (!requested_dir_name) { | |
107 | error = -ENOMEM; | |
108 | goto out; | |
109 | } | |
110 | rdir.name = requested_dir_name; | |
111 | tomoyo_fill_path_info(&rdir); | |
112 | ||
113 | /* Compare fs name. */ | |
b5bc60b4 | 114 | if (type == tomoyo_mounts[TOMOYO_MOUNT_REMOUNT]) { |
2106ccd9 | 115 | /* dev_name is ignored. */ |
b5bc60b4 TH |
116 | } else if (type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE] || |
117 | type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE] || | |
118 | type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE] || | |
119 | type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED]) { | |
2106ccd9 | 120 | /* dev_name is ignored. */ |
b5bc60b4 TH |
121 | } else if (type == tomoyo_mounts[TOMOYO_MOUNT_BIND] || |
122 | type == tomoyo_mounts[TOMOYO_MOUNT_MOVE]) { | |
2106ccd9 TH |
123 | need_dev = -1; /* dev_name is a directory */ |
124 | } else { | |
125 | fstype = get_fs_type(type); | |
126 | if (!fstype) { | |
127 | error = -ENODEV; | |
128 | goto out; | |
129 | } | |
130 | if (fstype->fs_flags & FS_REQUIRES_DEV) | |
131 | /* dev_name is a block device file. */ | |
132 | need_dev = 1; | |
133 | } | |
134 | if (need_dev) { | |
135 | /* Get mount point or device file. */ | |
4e78c724 | 136 | if (!dev_name || kern_path(dev_name, LOOKUP_FOLLOW, &path)) { |
2106ccd9 TH |
137 | error = -ENOENT; |
138 | goto out; | |
139 | } | |
97fb35e4 | 140 | obj.path1 = path; |
2106ccd9 TH |
141 | requested_dev_name = tomoyo_realpath_from_path(&path); |
142 | if (!requested_dev_name) { | |
143 | error = -ENOENT; | |
144 | goto out; | |
145 | } | |
146 | } else { | |
147 | /* Map dev_name to "<NULL>" if no dev_name given. */ | |
148 | if (!dev_name) | |
149 | dev_name = "<NULL>"; | |
c8c57e84 | 150 | requested_dev_name = tomoyo_encode(dev_name); |
2106ccd9 TH |
151 | if (!requested_dev_name) { |
152 | error = -ENOMEM; | |
153 | goto out; | |
154 | } | |
155 | } | |
156 | rdev.name = requested_dev_name; | |
157 | tomoyo_fill_path_info(&rdev); | |
cf6e9a64 TH |
158 | r->param_type = TOMOYO_TYPE_MOUNT_ACL; |
159 | r->param.mount.need_dev = need_dev; | |
160 | r->param.mount.dev = &rdev; | |
161 | r->param.mount.dir = &rdir; | |
162 | r->param.mount.type = &rtype; | |
163 | r->param.mount.flags = flags; | |
99a85259 TH |
164 | do { |
165 | tomoyo_check_acl(r, tomoyo_check_mount_acl); | |
166 | error = tomoyo_audit_mount_log(r); | |
167 | } while (error == TOMOYO_RETRY_REQUEST); | |
2106ccd9 TH |
168 | out: |
169 | kfree(requested_dev_name); | |
170 | kfree(requested_dir_name); | |
171 | if (fstype) | |
172 | put_filesystem(fstype); | |
173 | kfree(requested_type); | |
97fb35e4 TH |
174 | /* Drop refcount obtained by kern_path(). */ |
175 | if (obj.path1.dentry) | |
176 | path_put(&obj.path1); | |
2106ccd9 TH |
177 | return error; |
178 | } | |
179 | ||
2106ccd9 TH |
180 | /** |
181 | * tomoyo_mount_permission - Check permission for mount() operation. | |
182 | * | |
0f2a55d5 | 183 | * @dev_name: Name of device file. Maybe NULL. |
2106ccd9 | 184 | * @path: Pointer to "struct path". |
0f2a55d5 | 185 | * @type: Name of filesystem type. Maybe NULL. |
2106ccd9 | 186 | * @flags: Mount options. |
0f2a55d5 | 187 | * @data_page: Optional data. Maybe NULL. |
2106ccd9 TH |
188 | * |
189 | * Returns 0 on success, negative value otherwise. | |
190 | */ | |
e6641edd | 191 | int tomoyo_mount_permission(const char *dev_name, const struct path *path, |
b5bc60b4 TH |
192 | const char *type, unsigned long flags, |
193 | void *data_page) | |
2106ccd9 TH |
194 | { |
195 | struct tomoyo_request_info r; | |
196 | int error; | |
197 | int idx; | |
198 | ||
57c2590f TH |
199 | if (tomoyo_init_request_info(&r, NULL, TOMOYO_MAC_FILE_MOUNT) |
200 | == TOMOYO_CONFIG_DISABLED) | |
2106ccd9 | 201 | return 0; |
d795ef9e TH |
202 | if ((flags & MS_MGC_MSK) == MS_MGC_VAL) |
203 | flags &= ~MS_MGC_MSK; | |
204 | if (flags & MS_REMOUNT) { | |
b5bc60b4 | 205 | type = tomoyo_mounts[TOMOYO_MOUNT_REMOUNT]; |
d795ef9e | 206 | flags &= ~MS_REMOUNT; |
df91e494 | 207 | } else if (flags & MS_BIND) { |
b5bc60b4 | 208 | type = tomoyo_mounts[TOMOYO_MOUNT_BIND]; |
d795ef9e | 209 | flags &= ~MS_BIND; |
df91e494 TH |
210 | } else if (flags & MS_SHARED) { |
211 | if (flags & (MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE)) | |
212 | return -EINVAL; | |
213 | type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED]; | |
214 | flags &= ~MS_SHARED; | |
215 | } else if (flags & MS_PRIVATE) { | |
216 | if (flags & (MS_SHARED | MS_SLAVE | MS_UNBINDABLE)) | |
217 | return -EINVAL; | |
b5bc60b4 | 218 | type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE]; |
d795ef9e | 219 | flags &= ~MS_PRIVATE; |
df91e494 TH |
220 | } else if (flags & MS_SLAVE) { |
221 | if (flags & (MS_SHARED | MS_PRIVATE | MS_UNBINDABLE)) | |
222 | return -EINVAL; | |
b5bc60b4 | 223 | type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE]; |
d795ef9e | 224 | flags &= ~MS_SLAVE; |
df91e494 TH |
225 | } else if (flags & MS_UNBINDABLE) { |
226 | if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE)) | |
227 | return -EINVAL; | |
228 | type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE]; | |
229 | flags &= ~MS_UNBINDABLE; | |
230 | } else if (flags & MS_MOVE) { | |
231 | type = tomoyo_mounts[TOMOYO_MOUNT_MOVE]; | |
232 | flags &= ~MS_MOVE; | |
d795ef9e | 233 | } |
2106ccd9 TH |
234 | if (!type) |
235 | type = "<NULL>"; | |
236 | idx = tomoyo_read_lock(); | |
237 | error = tomoyo_mount_acl(&r, dev_name, path, type, flags); | |
238 | tomoyo_read_unlock(idx); | |
239 | return error; | |
240 | } |