Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /* scm.c - Socket level control messages processing.
3 : : *
4 : : * Author: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
5 : : * Alignment and value checking mods by Craig Metz
6 : : */
7 : :
8 : : #include <linux/module.h>
9 : : #include <linux/signal.h>
10 : : #include <linux/capability.h>
11 : : #include <linux/errno.h>
12 : : #include <linux/sched.h>
13 : : #include <linux/sched/user.h>
14 : : #include <linux/mm.h>
15 : : #include <linux/kernel.h>
16 : : #include <linux/stat.h>
17 : : #include <linux/socket.h>
18 : : #include <linux/file.h>
19 : : #include <linux/fcntl.h>
20 : : #include <linux/net.h>
21 : : #include <linux/interrupt.h>
22 : : #include <linux/netdevice.h>
23 : : #include <linux/security.h>
24 : : #include <linux/pid_namespace.h>
25 : : #include <linux/pid.h>
26 : : #include <linux/nsproxy.h>
27 : : #include <linux/slab.h>
28 : : #include <linux/errqueue.h>
29 : :
30 : : #include <linux/uaccess.h>
31 : :
32 : : #include <net/protocol.h>
33 : : #include <linux/skbuff.h>
34 : : #include <net/sock.h>
35 : : #include <net/compat.h>
36 : : #include <net/scm.h>
37 : : #include <net/cls_cgroup.h>
38 : :
39 : :
40 : : /*
41 : : * Only allow a user to send credentials, that they could set with
42 : : * setu(g)id.
43 : : */
44 : :
45 : 1301 : static __inline__ int scm_check_creds(struct ucred *creds)
46 : : {
47 [ + - ]: 1301 : const struct cred *cred = current_cred();
48 [ + - ]: 1301 : kuid_t uid = make_kuid(cred->user_ns, creds->uid);
49 [ + - ]: 1301 : kgid_t gid = make_kgid(cred->user_ns, creds->gid);
50 : :
51 [ + - + - ]: 1301 : if (!uid_valid(uid) || !gid_valid(gid))
52 : : return -EINVAL;
53 : :
54 [ + + + - ]: 2516 : if ((creds->pid == task_tgid_vnr(current) ||
55 [ - + ]: 2516 : ns_capable(task_active_pid_ns(current)->user_ns, CAP_SYS_ADMIN)) &&
56 [ # # # # ]: 0 : ((uid_eq(uid, cred->uid) || uid_eq(uid, cred->euid) ||
57 [ - - - + ]: 1301 : uid_eq(uid, cred->suid)) || ns_capable(cred->user_ns, CAP_SETUID)) &&
58 [ # # # # ]: 0 : ((gid_eq(gid, cred->gid) || gid_eq(gid, cred->egid) ||
59 [ # # ]: 0 : gid_eq(gid, cred->sgid)) || ns_capable(cred->user_ns, CAP_SETGID))) {
60 : 1301 : return 0;
61 : : }
62 : : return -EPERM;
63 : : }
64 : :
65 : 338 : static int scm_fp_copy(struct cmsghdr *cmsg, struct scm_fp_list **fplp)
66 : : {
67 : 338 : int *fdp = (int*)CMSG_DATA(cmsg);
68 : 338 : struct scm_fp_list *fpl = *fplp;
69 : 338 : struct file **fpp;
70 : 338 : int i, num;
71 : :
72 : 338 : num = (cmsg->cmsg_len - sizeof(struct cmsghdr))/sizeof(int);
73 : :
74 [ + - ]: 338 : if (num <= 0)
75 : : return 0;
76 : :
77 [ + - ]: 338 : if (num > SCM_MAX_FD)
78 : : return -EINVAL;
79 : :
80 [ + - ]: 338 : if (!fpl)
81 : : {
82 : 338 : fpl = kmalloc(sizeof(struct scm_fp_list), GFP_KERNEL);
83 [ + - ]: 338 : if (!fpl)
84 : : return -ENOMEM;
85 : 338 : *fplp = fpl;
86 : 338 : fpl->count = 0;
87 : 338 : fpl->max = SCM_MAX_FD;
88 : 338 : fpl->user = NULL;
89 : : }
90 : 338 : fpp = &fpl->fp[fpl->count];
91 : :
92 [ + - ]: 338 : if (fpl->count + num > fpl->max)
93 : : return -EINVAL;
94 : :
95 : : /*
96 : : * Verify the descriptors and increment the usage count.
97 : : */
98 : :
99 [ + + ]: 676 : for (i=0; i< num; i++)
100 : : {
101 : 338 : int fd = fdp[i];
102 : 338 : struct file *file;
103 : :
104 [ + - - + ]: 338 : if (fd < 0 || !(file = fget_raw(fd)))
105 : 0 : return -EBADF;
106 : 338 : *fpp++ = file;
107 : 338 : fpl->count++;
108 : : }
109 : :
110 [ + - ]: 338 : if (!fpl->user)
111 : 338 : fpl->user = get_uid(current_user());
112 : :
113 : : return num;
114 : : }
115 : :
116 : 676 : void __scm_destroy(struct scm_cookie *scm)
117 : : {
118 : 676 : struct scm_fp_list *fpl = scm->fp;
119 : 676 : int i;
120 : :
121 [ + - ]: 676 : if (fpl) {
122 : 676 : scm->fp = NULL;
123 [ + + ]: 1352 : for (i=fpl->count-1; i>=0; i--)
124 : 676 : fput(fpl->fp[i]);
125 : 676 : free_uid(fpl->user);
126 : 676 : kfree(fpl);
127 : : }
128 : 676 : }
129 : : EXPORT_SYMBOL(__scm_destroy);
130 : :
131 : 1639 : int __scm_send(struct socket *sock, struct msghdr *msg, struct scm_cookie *p)
132 : : {
133 : 1639 : struct cmsghdr *cmsg;
134 : 1639 : int err;
135 : :
136 [ + - - + : 4831 : for_each_cmsghdr(cmsg, msg) {
+ - ]
137 : 1639 : err = -EINVAL;
138 : :
139 : : /* Verify that cmsg_len is at least sizeof(struct cmsghdr) */
140 : : /* The first check was omitted in <= 2.2.5. The reasoning was
141 : : that parser checks cmsg_len in any case, so that
142 : : additional check would be work duplication.
143 : : But if cmsg_level is not SOL_SOCKET, we do not check
144 : : for too short ancillary data object at all! Oops.
145 : : OK, let's add it...
146 : : */
147 [ + - - + ]: 1639 : if (!CMSG_OK(msg, cmsg))
148 : 0 : goto error;
149 : :
150 [ - + ]: 1639 : if (cmsg->cmsg_level != SOL_SOCKET)
151 : 0 : continue;
152 : :
153 [ + + - ]: 1639 : switch (cmsg->cmsg_type)
154 : : {
155 : 338 : case SCM_RIGHTS:
156 [ + - - + ]: 338 : if (!sock->ops || sock->ops->family != PF_UNIX)
157 : 0 : goto error;
158 : 338 : err=scm_fp_copy(cmsg, &p->fp);
159 [ - + ]: 338 : if (err<0)
160 : 0 : goto error;
161 : : break;
162 : 1301 : case SCM_CREDENTIALS:
163 : : {
164 : 1301 : struct ucred creds;
165 : 1301 : kuid_t uid;
166 : 1301 : kgid_t gid;
167 [ - + ]: 1301 : if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct ucred)))
168 : 86 : goto error;
169 : 1301 : memcpy(&creds, CMSG_DATA(cmsg), sizeof(struct ucred));
170 : 1301 : err = scm_check_creds(&creds);
171 [ - + ]: 1301 : if (err)
172 : 0 : goto error;
173 : :
174 : 1301 : p->creds.pid = creds.pid;
175 [ - + - - ]: 1301 : if (!p->pid || pid_vnr(p->pid) != creds.pid) {
176 : 1301 : struct pid *pid;
177 : 1301 : err = -ESRCH;
178 : 1301 : pid = find_get_pid(creds.pid);
179 [ + + ]: 1301 : if (!pid)
180 : 86 : goto error;
181 : 1215 : put_pid(p->pid);
182 : 1215 : p->pid = pid;
183 : : }
184 : :
185 : 1215 : err = -EINVAL;
186 [ + - ]: 1215 : uid = make_kuid(current_user_ns(), creds.uid);
187 [ + - ]: 1215 : gid = make_kgid(current_user_ns(), creds.gid);
188 [ + - - + ]: 1215 : if (!uid_valid(uid) || !gid_valid(gid))
189 : 0 : goto error;
190 : :
191 : 1215 : p->creds.uid = uid;
192 : 1215 : p->creds.gid = gid;
193 : 1215 : break;
194 : : }
195 : 0 : default:
196 : 0 : goto error;
197 : : }
198 : : }
199 : :
200 [ + + - + ]: 1553 : if (p->fp && !p->fp->count)
201 : : {
202 : 0 : kfree(p->fp);
203 : 0 : p->fp = NULL;
204 : : }
205 : : return 0;
206 : :
207 : 86 : error:
208 : 86 : scm_destroy(p);
209 : 86 : return err;
210 : : }
211 : : EXPORT_SYMBOL(__scm_send);
212 : :
213 : 29151 : int put_cmsg(struct msghdr * msg, int level, int type, int len, void *data)
214 : : {
215 : 29151 : struct cmsghdr __user *cm
216 : : = (__force struct cmsghdr __user *)msg->msg_control;
217 : 29151 : struct cmsghdr cmhdr;
218 : 29151 : int cmlen = CMSG_LEN(len);
219 : 29151 : int err;
220 : :
221 [ - + ]: 29151 : if (MSG_CMSG_COMPAT & msg->msg_flags)
222 : 0 : return put_cmsg_compat(msg, level, type, len, data);
223 : :
224 [ + - - + ]: 29151 : if (cm==NULL || msg->msg_controllen < sizeof(*cm)) {
225 : 0 : msg->msg_flags |= MSG_CTRUNC;
226 : 0 : return 0; /* XXX: return error? check spec. */
227 : : }
228 [ - + ]: 29151 : if (msg->msg_controllen < cmlen) {
229 : 0 : msg->msg_flags |= MSG_CTRUNC;
230 : 0 : cmlen = msg->msg_controllen;
231 : : }
232 : 29151 : cmhdr.cmsg_level = level;
233 : 29151 : cmhdr.cmsg_type = type;
234 : 29151 : cmhdr.cmsg_len = cmlen;
235 : :
236 : 29151 : err = -EFAULT;
237 [ - + ]: 29151 : if (copy_to_user(cm, &cmhdr, sizeof cmhdr))
238 : 0 : goto out;
239 [ - + - + ]: 58302 : if (copy_to_user(CMSG_DATA(cm), data, cmlen - sizeof(struct cmsghdr)))
240 : 0 : goto out;
241 : 29151 : cmlen = CMSG_SPACE(len);
242 [ - + ]: 29151 : if (msg->msg_controllen < cmlen)
243 : 0 : cmlen = msg->msg_controllen;
244 : 29151 : msg->msg_control += cmlen;
245 : 29151 : msg->msg_controllen -= cmlen;
246 : 29151 : err = 0;
247 : : out:
248 : : return err;
249 : : }
250 : : EXPORT_SYMBOL(put_cmsg);
251 : :
252 : 0 : void put_cmsg_scm_timestamping64(struct msghdr *msg, struct scm_timestamping_internal *tss_internal)
253 : : {
254 : 0 : struct scm_timestamping64 tss;
255 : 0 : int i;
256 : :
257 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(tss.ts); i++) {
258 : 0 : tss.ts[i].tv_sec = tss_internal->ts[i].tv_sec;
259 : 0 : tss.ts[i].tv_nsec = tss_internal->ts[i].tv_nsec;
260 : : }
261 : :
262 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_NEW, sizeof(tss), &tss);
263 : 0 : }
264 : : EXPORT_SYMBOL(put_cmsg_scm_timestamping64);
265 : :
266 : 0 : void put_cmsg_scm_timestamping(struct msghdr *msg, struct scm_timestamping_internal *tss_internal)
267 : : {
268 : 0 : struct scm_timestamping tss;
269 : 0 : int i;
270 : :
271 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(tss.ts); i++) {
272 : 0 : tss.ts[i].tv_sec = tss_internal->ts[i].tv_sec;
273 : 0 : tss.ts[i].tv_nsec = tss_internal->ts[i].tv_nsec;
274 : : }
275 : :
276 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_OLD, sizeof(tss), &tss);
277 : 0 : }
278 : : EXPORT_SYMBOL(put_cmsg_scm_timestamping);
279 : :
280 : 338 : void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm)
281 : : {
282 : 338 : struct cmsghdr __user *cm
283 : : = (__force struct cmsghdr __user*)msg->msg_control;
284 : :
285 : 338 : int fdmax = 0;
286 : 338 : int fdnum = scm->fp->count;
287 : 338 : struct file **fp = scm->fp->fp;
288 : 338 : int __user *cmfptr;
289 : 338 : int err = 0, i;
290 : :
291 [ - + ]: 338 : if (MSG_CMSG_COMPAT & msg->msg_flags) {
292 : 0 : scm_detach_fds_compat(msg, scm);
293 : 0 : return;
294 : : }
295 : :
296 [ + - ]: 338 : if (msg->msg_controllen > sizeof(struct cmsghdr))
297 : 338 : fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr))
298 : 338 : / sizeof(int));
299 : :
300 : 338 : if (fdnum < fdmax)
301 : : fdmax = fdnum;
302 : :
303 [ + + ]: 676 : for (i=0, cmfptr=(__force int __user *)CMSG_DATA(cm); i<fdmax;
304 : 338 : i++, cmfptr++)
305 : : {
306 : 338 : struct socket *sock;
307 : 338 : int new_fd;
308 : 338 : err = security_file_receive(fp[i]);
309 [ + - ]: 338 : if (err)
310 : : break;
311 : 676 : err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & msg->msg_flags
312 : 338 : ? O_CLOEXEC : 0);
313 [ + - ]: 338 : if (err < 0)
314 : : break;
315 : 338 : new_fd = err;
316 : 338 : err = put_user(new_fd, cmfptr);
317 [ - + ]: 338 : if (err) {
318 : 0 : put_unused_fd(new_fd);
319 : 0 : break;
320 : : }
321 : : /* Bump the usage count and install the file. */
322 : 338 : sock = sock_from_file(fp[i], &err);
323 : 338 : if (sock) {
324 : : sock_update_netprioidx(&sock->sk->sk_cgrp_data);
325 : : sock_update_classid(&sock->sk->sk_cgrp_data);
326 : : }
327 : 338 : fd_install(new_fd, get_file(fp[i]));
328 : : }
329 : :
330 [ + - ]: 338 : if (i > 0)
331 : : {
332 : 338 : int cmlen = CMSG_LEN(i*sizeof(int));
333 : 338 : err = put_user(SOL_SOCKET, &cm->cmsg_level);
334 [ + - ]: 338 : if (!err)
335 : 338 : err = put_user(SCM_RIGHTS, &cm->cmsg_type);
336 [ + - ]: 338 : if (!err)
337 : 338 : err = put_user(cmlen, &cm->cmsg_len);
338 [ + - ]: 338 : if (!err) {
339 : 338 : cmlen = CMSG_SPACE(i*sizeof(int));
340 [ - + ]: 338 : if (msg->msg_controllen < cmlen)
341 : 0 : cmlen = msg->msg_controllen;
342 : 338 : msg->msg_control += cmlen;
343 : 338 : msg->msg_controllen -= cmlen;
344 : : }
345 : : }
346 [ + - - + ]: 338 : if (i < fdnum || (fdnum && fdmax <= 0))
347 : 0 : msg->msg_flags |= MSG_CTRUNC;
348 : :
349 : : /*
350 : : * All of the files that fit in the message have had their
351 : : * usage counts incremented, so we just free the list.
352 : : */
353 : 338 : __scm_destroy(scm);
354 : : }
355 : : EXPORT_SYMBOL(scm_detach_fds);
356 : :
357 : 338 : struct scm_fp_list *scm_fp_dup(struct scm_fp_list *fpl)
358 : : {
359 : 338 : struct scm_fp_list *new_fpl;
360 : 338 : int i;
361 : :
362 [ + - ]: 338 : if (!fpl)
363 : : return NULL;
364 : :
365 : 338 : new_fpl = kmemdup(fpl, offsetof(struct scm_fp_list, fp[fpl->count]),
366 : : GFP_KERNEL);
367 [ + - ]: 338 : if (new_fpl) {
368 [ + + ]: 676 : for (i = 0; i < fpl->count; i++)
369 : 338 : get_file(fpl->fp[i]);
370 : 338 : new_fpl->max = new_fpl->count;
371 : 338 : new_fpl->user = get_uid(fpl->user);
372 : : }
373 : : return new_fpl;
374 : : }
375 : : EXPORT_SYMBOL(scm_fp_dup);
|
