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 : 63597 : static __inline__ int scm_check_creds(struct ucred *creds)
46 : : {
47 : 63597 : const struct cred *cred = current_cred();
48 : 63597 : kuid_t uid = make_kuid(cred->user_ns, creds->uid);
49 : 63596 : kgid_t gid = make_kgid(cred->user_ns, creds->gid);
50 : :
51 [ + - + + ]: 63597 : if (!uid_valid(uid) || !gid_valid(gid))
52 : : return -EINVAL;
53 : :
54 [ + + + + ]: 249096 : if ((creds->pid == task_tgid_vnr(current) ||
55 [ + + ]: 121903 : ns_capable(task_active_pid_ns(current)->user_ns, CAP_SYS_ADMIN)) &&
56 [ + - + - ]: 12810 : ((uid_eq(uid, cred->uid) || uid_eq(uid, cred->euid) ||
57 [ + - + + ]: 12810 : uid_eq(uid, cred->suid)) || ns_capable(cred->user_ns, CAP_SETUID)) &&
58 [ + - + - ]: 12810 : ((gid_eq(gid, cred->gid) || gid_eq(gid, cred->egid) ||
59 [ + - ]: 12810 : gid_eq(gid, cred->sgid)) || ns_capable(cred->user_ns, CAP_SETGID))) {
60 : : return 0;
61 : : }
62 : : return -EPERM;
63 : : }
64 : :
65 : 15950 : static int scm_fp_copy(struct cmsghdr *cmsg, struct scm_fp_list **fplp)
66 : : {
67 : : int *fdp = (int*)CMSG_DATA(cmsg);
68 : 15950 : struct scm_fp_list *fpl = *fplp;
69 : : struct file **fpp;
70 : : int i, num;
71 : :
72 : 15950 : num = (cmsg->cmsg_len - sizeof(struct cmsghdr))/sizeof(int);
73 : :
74 [ + - ]: 15950 : if (num <= 0)
75 : : return 0;
76 : :
77 [ + - ]: 15950 : if (num > SCM_MAX_FD)
78 : : return -EINVAL;
79 : :
80 [ + - ]: 15950 : if (!fpl)
81 : : {
82 : : fpl = kmalloc(sizeof(struct scm_fp_list), GFP_KERNEL);
83 [ + - ]: 15950 : if (!fpl)
84 : : return -ENOMEM;
85 : 15950 : *fplp = fpl;
86 : 15950 : fpl->count = 0;
87 : 15950 : fpl->max = SCM_MAX_FD;
88 : 15950 : fpl->user = NULL;
89 : : }
90 : 15950 : fpp = &fpl->fp[fpl->count];
91 : :
92 [ + - ]: 15950 : if (fpl->count + num > fpl->max)
93 : : return -EINVAL;
94 : :
95 : : /*
96 : : * Verify the descriptors and increment the usage count.
97 : : */
98 : :
99 [ + + ]: 15950 : for (i=0; i< num; i++)
100 : : {
101 : 15950 : int fd = fdp[i];
102 : : struct file *file;
103 : :
104 [ + - + - ]: 15950 : if (fd < 0 || !(file = fget_raw(fd)))
105 : : return -EBADF;
106 : 15950 : *fpp++ = file;
107 : 15950 : fpl->count++;
108 : : }
109 : :
110 [ + - ]: 15950 : if (!fpl->user)
111 : 31900 : fpl->user = get_uid(current_user());
112 : :
113 : 15950 : return num;
114 : : }
115 : :
116 : 31072 : void __scm_destroy(struct scm_cookie *scm)
117 : : {
118 : 31072 : struct scm_fp_list *fpl = scm->fp;
119 : : int i;
120 : :
121 [ + - ]: 31072 : if (fpl) {
122 : 31073 : scm->fp = NULL;
123 [ + + ]: 62144 : for (i=fpl->count-1; i>=0; i--)
124 : 31072 : fput(fpl->fp[i]);
125 : 31072 : free_uid(fpl->user);
126 : 31072 : kfree(fpl);
127 : : }
128 : 31071 : }
129 : : EXPORT_SYMBOL(__scm_destroy);
130 : :
131 : 79547 : int __scm_send(struct socket *sock, struct msghdr *msg, struct scm_cookie *p)
132 : : {
133 : : struct cmsghdr *cmsg;
134 : : int err;
135 : :
136 [ + - + + ]: 238112 : for_each_cmsghdr(cmsg, msg) {
137 : : 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 [ + + + - ]: 79547 : if (!CMSG_OK(msg, cmsg))
148 : : goto error;
149 : :
150 [ - + ]: 79546 : if (cmsg->cmsg_level != SOL_SOCKET)
151 : 0 : continue;
152 : :
153 [ + + + ]: 79546 : switch (cmsg->cmsg_type)
154 : : {
155 : : case SCM_RIGHTS:
156 [ + - + - ]: 15950 : if (!sock->ops || sock->ops->family != PF_UNIX)
157 : : goto error;
158 : 15950 : err=scm_fp_copy(cmsg, &p->fp);
159 [ + - ]: 15950 : if (err<0)
160 : : goto error;
161 : : break;
162 : : case SCM_CREDENTIALS:
163 : : {
164 : : struct ucred creds;
165 : : kuid_t uid;
166 : : kgid_t gid;
167 [ + - ]: 63595 : if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct ucred)))
168 : : goto error;
169 : 63597 : memcpy(&creds, CMSG_DATA(cmsg), sizeof(struct ucred));
170 : 63597 : err = scm_check_creds(&creds);
171 [ + - ]: 63596 : if (err)
172 : : goto error;
173 : :
174 : 63596 : p->creds.pid = creds.pid;
175 [ - + # # ]: 63596 : if (!p->pid || pid_vnr(p->pid) != creds.pid) {
176 : : struct pid *pid;
177 : : err = -ESRCH;
178 : 63596 : pid = find_get_pid(creds.pid);
179 [ + + ]: 63597 : if (!pid)
180 : : goto error;
181 : 63066 : put_pid(p->pid);
182 : 63068 : p->pid = pid;
183 : : }
184 : :
185 : : err = -EINVAL;
186 : 63068 : uid = make_kuid(current_user_ns(), creds.uid);
187 : 63068 : gid = make_kgid(current_user_ns(), creds.gid);
188 [ + - + - ]: 63068 : if (!uid_valid(uid) || !gid_valid(gid))
189 : : goto error;
190 : :
191 : 63068 : p->creds.uid = uid;
192 : 63068 : p->creds.gid = gid;
193 : 63068 : break;
194 : : }
195 : : default:
196 : : goto error;
197 : : }
198 : : }
199 : :
200 [ + + - + ]: 79018 : if (p->fp && !p->fp->count)
201 : : {
202 : 0 : kfree(p->fp);
203 : 0 : p->fp = NULL;
204 : : }
205 : : return 0;
206 : :
207 : : error:
208 : 531 : scm_destroy(p);
209 : 529 : return err;
210 : : }
211 : : EXPORT_SYMBOL(__scm_send);
212 : :
213 : 593469 : int put_cmsg(struct msghdr * msg, int level, int type, int len, void *data)
214 : : {
215 : 593469 : struct cmsghdr __user *cm
216 : : = (__force struct cmsghdr __user *)msg->msg_control;
217 : : struct cmsghdr cmhdr;
218 : 593469 : int cmlen = CMSG_LEN(len);
219 : : int err;
220 : :
221 : : if (MSG_CMSG_COMPAT & msg->msg_flags)
222 : : return put_cmsg_compat(msg, level, type, len, data);
223 : :
224 [ + - + + ]: 593469 : 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 [ - + ]: 593469 : if (msg->msg_controllen < cmlen) {
229 : 0 : msg->msg_flags |= MSG_CTRUNC;
230 : 0 : cmlen = msg->msg_controllen;
231 : : }
232 : 593469 : cmhdr.cmsg_level = level;
233 : 593469 : cmhdr.cmsg_type = type;
234 : 593469 : cmhdr.cmsg_len = cmlen;
235 : :
236 : : err = -EFAULT;
237 [ + + ]: 593819 : if (copy_to_user(cm, &cmhdr, sizeof cmhdr))
238 : : goto out;
239 [ + + ]: 1184462 : if (copy_to_user(CMSG_DATA(cm), data, cmlen - sizeof(struct cmsghdr)))
240 : : goto out;
241 : 592077 : cmlen = CMSG_SPACE(len);
242 [ - + ]: 592077 : if (msg->msg_controllen < cmlen)
243 : 0 : cmlen = msg->msg_controllen;
244 : 592077 : msg->msg_control += cmlen;
245 : 592077 : msg->msg_controllen -= cmlen;
246 : : err = 0;
247 : : out:
248 : 592001 : 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 : : struct scm_timestamping64 tss;
255 : : 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 : : struct scm_timestamping tss;
269 : : int i;
270 : :
271 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(tss.ts); i++)
272 : 0 : tss.ts[i] = timespec64_to_timespec(tss_internal->ts[i]);
273 : :
274 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPING_OLD, sizeof(tss), &tss);
275 : 0 : }
276 : : EXPORT_SYMBOL(put_cmsg_scm_timestamping);
277 : :
278 : 15122 : void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm)
279 : : {
280 : 15122 : struct cmsghdr __user *cm
281 : : = (__force struct cmsghdr __user*)msg->msg_control;
282 : :
283 : : int fdmax = 0;
284 : 15122 : int fdnum = scm->fp->count;
285 : 15122 : struct file **fp = scm->fp->fp;
286 : : int __user *cmfptr;
287 : 15122 : int err = 0, i;
288 : :
289 : : if (MSG_CMSG_COMPAT & msg->msg_flags) {
290 : : scm_detach_fds_compat(msg, scm);
291 : 15122 : return;
292 : : }
293 : :
294 [ + - ]: 15122 : if (msg->msg_controllen > sizeof(struct cmsghdr))
295 : 30244 : fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr))
296 : 15122 : / sizeof(int));
297 : :
298 [ + + ]: 15122 : if (fdnum < fdmax)
299 : : fdmax = fdnum;
300 : :
301 [ + + ]: 45366 : for (i=0, cmfptr=(__force int __user *)CMSG_DATA(cm); i<fdmax;
302 : 15122 : i++, cmfptr++)
303 : : {
304 : : struct socket *sock;
305 : : int new_fd;
306 : 15122 : err = security_file_receive(fp[i]);
307 [ + - ]: 15122 : if (err)
308 : : break;
309 [ + + ]: 15122 : err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & msg->msg_flags
310 : : ? O_CLOEXEC : 0);
311 [ + - ]: 15122 : if (err < 0)
312 : : break;
313 : : new_fd = err;
314 : 15122 : err = put_user(new_fd, cmfptr);
315 [ - + ]: 15122 : if (err) {
316 : 0 : put_unused_fd(new_fd);
317 : 0 : break;
318 : : }
319 : : /* Bump the usage count and install the file. */
320 : 15122 : sock = sock_from_file(fp[i], &err);
321 [ + + ]: 15122 : if (sock) {
322 : 13880 : sock_update_netprioidx(&sock->sk->sk_cgrp_data);
323 : 13880 : sock_update_classid(&sock->sk->sk_cgrp_data);
324 : : }
325 : 30244 : fd_install(new_fd, get_file(fp[i]));
326 : : }
327 : :
328 [ + - ]: 15122 : if (i > 0)
329 : : {
330 : 15122 : int cmlen = CMSG_LEN(i*sizeof(int));
331 : 30244 : err = put_user(SOL_SOCKET, &cm->cmsg_level);
332 [ + - ]: 15122 : if (!err)
333 : 30244 : err = put_user(SCM_RIGHTS, &cm->cmsg_type);
334 [ + - ]: 15122 : if (!err)
335 : 30244 : err = put_user(cmlen, &cm->cmsg_len);
336 [ + - ]: 15122 : if (!err) {
337 : 15122 : cmlen = CMSG_SPACE(i*sizeof(int));
338 [ - + ]: 15122 : if (msg->msg_controllen < cmlen)
339 : 0 : cmlen = msg->msg_controllen;
340 : 15122 : msg->msg_control += cmlen;
341 : 15122 : msg->msg_controllen -= cmlen;
342 : : }
343 : : }
344 [ + - - + ]: 15122 : if (i < fdnum || (fdnum && fdmax <= 0))
345 : 0 : msg->msg_flags |= MSG_CTRUNC;
346 : :
347 : : /*
348 : : * All of the files that fit in the message have had their
349 : : * usage counts incremented, so we just free the list.
350 : : */
351 : 15122 : __scm_destroy(scm);
352 : : }
353 : : EXPORT_SYMBOL(scm_detach_fds);
354 : :
355 : 15122 : struct scm_fp_list *scm_fp_dup(struct scm_fp_list *fpl)
356 : : {
357 : : struct scm_fp_list *new_fpl;
358 : : int i;
359 : :
360 [ + - ]: 15122 : if (!fpl)
361 : : return NULL;
362 : :
363 : 15122 : new_fpl = kmemdup(fpl, offsetof(struct scm_fp_list, fp[fpl->count]),
364 : : GFP_KERNEL);
365 [ + - ]: 15122 : if (new_fpl) {
366 [ + + ]: 15122 : for (i = 0; i < fpl->count; i++)
367 : 15122 : get_file(fpl->fp[i]);
368 : 15122 : new_fpl->max = new_fpl->count;
369 : 30244 : new_fpl->user = get_uid(fpl->user);
370 : : }
371 : 15122 : return new_fpl;
372 : : }
373 : : EXPORT_SYMBOL(scm_fp_dup);
|
