Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <fcntl.h>
5 : : #include <inttypes.h>
6 : : #include <limits.h>
7 : : #include <poll.h>
8 : : #include <signal.h>
9 : : #include <stdbool.h>
10 : : #include <stddef.h>
11 : : #include <stdint.h>
12 : : #include <stdio.h>
13 : : #include <stdlib.h>
14 : : #include <string.h>
15 : : #include <sys/inotify.h>
16 : : #include <sys/signalfd.h>
17 : : #include <sys/socket.h>
18 : : #include <sys/stat.h>
19 : : #include <sys/time.h>
20 : : #include <sys/uio.h>
21 : : #include <sys/un.h>
22 : : #include <termios.h>
23 : : #include <unistd.h>
24 : :
25 : : #include "alloc-util.h"
26 : : #include "ask-password-api.h"
27 : : #include "fd-util.h"
28 : : #include "fileio.h"
29 : : #include "format-util.h"
30 : : #include "fs-util.h"
31 : : #include "io-util.h"
32 : : #include "log.h"
33 : : #include "macro.h"
34 : : #include "memory-util.h"
35 : : #include "missing.h"
36 : : #include "mkdir.h"
37 : : #include "process-util.h"
38 : : #include "random-util.h"
39 : : #include "signal-util.h"
40 : : #include "socket-util.h"
41 : : #include "string-util.h"
42 : : #include "strv.h"
43 : : #include "terminal-util.h"
44 : : #include "time-util.h"
45 : : #include "tmpfile-util.h"
46 : : #include "umask-util.h"
47 : : #include "utf8.h"
48 : :
49 : : #define KEYRING_TIMEOUT_USEC ((5 * USEC_PER_MINUTE) / 2)
50 : :
51 : 0 : static int lookup_key(const char *keyname, key_serial_t *ret) {
52 : : key_serial_t serial;
53 : :
54 [ # # ]: 0 : assert(keyname);
55 [ # # ]: 0 : assert(ret);
56 : :
57 : 0 : serial = request_key("user", keyname, NULL, 0);
58 [ # # ]: 0 : if (serial == -1)
59 : 0 : return negative_errno();
60 : :
61 : 0 : *ret = serial;
62 : 0 : return 0;
63 : : }
64 : :
65 : 0 : static int retrieve_key(key_serial_t serial, char ***ret) {
66 : 0 : size_t nfinal, m = 100;
67 : : char **l;
68 : 0 : _cleanup_(erase_and_freep) char *pfinal = NULL;
69 : :
70 [ # # ]: 0 : assert(ret);
71 : :
72 : 0 : for (;;) {
73 [ # # # ]: 0 : _cleanup_(erase_and_freep) char *p = NULL;
74 : : long n;
75 : :
76 : 0 : p = new(char, m);
77 [ # # ]: 0 : if (!p)
78 : 0 : return -ENOMEM;
79 : :
80 : 0 : n = keyctl(KEYCTL_READ, (unsigned long) serial, (unsigned long) p, (unsigned long) m, 0);
81 [ # # ]: 0 : if (n < 0)
82 : 0 : return -errno;
83 [ # # ]: 0 : if ((size_t) n < m) {
84 : 0 : nfinal = (size_t) n;
85 : 0 : pfinal = TAKE_PTR(p);
86 : 0 : break;
87 : : }
88 : :
89 [ # # ]: 0 : if (m > LONG_MAX / 2) /* overflow check */
90 : 0 : return -ENOMEM;
91 : 0 : m *= 2;
92 : : }
93 : :
94 : 0 : l = strv_parse_nulstr(pfinal, nfinal);
95 [ # # ]: 0 : if (!l)
96 : 0 : return -ENOMEM;
97 : :
98 : 0 : *ret = l;
99 : 0 : return 0;
100 : : }
101 : :
102 : 0 : static int add_to_keyring(const char *keyname, AskPasswordFlags flags, char **passwords) {
103 : 0 : _cleanup_strv_free_erase_ char **l = NULL;
104 : 0 : _cleanup_(erase_and_freep) char *p = NULL;
105 : : key_serial_t serial;
106 : : size_t n;
107 : : int r;
108 : :
109 [ # # ]: 0 : assert(keyname);
110 [ # # ]: 0 : assert(passwords);
111 : :
112 [ # # ]: 0 : if (!(flags & ASK_PASSWORD_PUSH_CACHE))
113 : 0 : return 0;
114 : :
115 : 0 : r = lookup_key(keyname, &serial);
116 [ # # ]: 0 : if (r >= 0) {
117 : 0 : r = retrieve_key(serial, &l);
118 [ # # ]: 0 : if (r < 0)
119 : 0 : return r;
120 [ # # ]: 0 : } else if (r != -ENOKEY)
121 : 0 : return r;
122 : :
123 : 0 : r = strv_extend_strv(&l, passwords, true);
124 [ # # ]: 0 : if (r <= 0)
125 : 0 : return r;
126 : :
127 : 0 : r = strv_make_nulstr(l, &p, &n);
128 [ # # ]: 0 : if (r < 0)
129 : 0 : return r;
130 : :
131 : 0 : serial = add_key("user", keyname, p, n, KEY_SPEC_USER_KEYRING);
132 [ # # ]: 0 : if (serial == -1)
133 : 0 : return -errno;
134 : :
135 [ # # ]: 0 : if (keyctl(KEYCTL_SET_TIMEOUT,
136 : : (unsigned long) serial,
137 : 0 : (unsigned long) DIV_ROUND_UP(KEYRING_TIMEOUT_USEC, USEC_PER_SEC), 0, 0) < 0)
138 [ # # ]: 0 : log_debug_errno(errno, "Failed to adjust timeout: %m");
139 : :
140 : : /* Tell everyone to check the keyring */
141 : 0 : (void) touch("/run/systemd/ask-password");
142 : :
143 [ # # ]: 0 : log_debug("Added key to keyring as %" PRIi32 ".", serial);
144 : :
145 : 0 : return 1;
146 : : }
147 : :
148 : 0 : static int add_to_keyring_and_log(const char *keyname, AskPasswordFlags flags, char **passwords) {
149 : : int r;
150 : :
151 [ # # ]: 0 : assert(keyname);
152 [ # # ]: 0 : assert(passwords);
153 : :
154 : 0 : r = add_to_keyring(keyname, flags, passwords);
155 [ # # ]: 0 : if (r < 0)
156 [ # # ]: 0 : return log_debug_errno(r, "Failed to add password to keyring: %m");
157 : :
158 : 0 : return 0;
159 : : }
160 : :
161 : 0 : static int ask_password_keyring(const char *keyname, AskPasswordFlags flags, char ***ret) {
162 : :
163 : : key_serial_t serial;
164 : : int r;
165 : :
166 [ # # ]: 0 : assert(keyname);
167 [ # # ]: 0 : assert(ret);
168 : :
169 [ # # ]: 0 : if (!(flags & ASK_PASSWORD_ACCEPT_CACHED))
170 : 0 : return -EUNATCH;
171 : :
172 : 0 : r = lookup_key(keyname, &serial);
173 [ # # ]: 0 : if (r == -ENOSYS) /* when retrieving the distinction doesn't matter */
174 : 0 : return -ENOKEY;
175 [ # # ]: 0 : if (r < 0)
176 : 0 : return r;
177 : :
178 : 0 : return retrieve_key(serial, ret);
179 : : }
180 : :
181 : 0 : static int backspace_chars(int ttyfd, size_t p) {
182 [ # # ]: 0 : if (ttyfd < 0)
183 : 0 : return 0;
184 : :
185 : 0 : _cleanup_free_ char *buf = malloc_multiply(3, p);
186 [ # # ]: 0 : if (!buf)
187 : 0 : return log_oom();
188 : :
189 [ # # ]: 0 : for (size_t i = 0; i < p; i++)
190 : 0 : memcpy(buf + 3 * i, "\b \b", 3);
191 : :
192 : 0 : return loop_write(ttyfd, buf, 3*p, false);
193 : : }
194 : :
195 : 0 : static int backspace_string(int ttyfd, const char *str) {
196 [ # # ]: 0 : assert(str);
197 : :
198 : : /* Backspaces through enough characters to entirely undo printing of the specified string. */
199 : :
200 [ # # ]: 0 : if (ttyfd < 0)
201 : 0 : return 0;
202 : :
203 : 0 : size_t m = utf8_n_codepoints(str);
204 [ # # ]: 0 : if (m == (size_t) -1)
205 : 0 : m = strlen(str); /* Not a valid UTF-8 string? If so, let's backspace the number of bytes
206 : : * output. Most likely this happened because we are not in an UTF-8 locale,
207 : : * and in that case that is the correct thing to do. And even if it's not,
208 : : * terminals tend to stop backspacing at the leftmost column, hence
209 : : * backspacing too much should be mostly OK. */
210 : :
211 : 0 : return backspace_chars(ttyfd, m);
212 : : }
213 : :
214 : 0 : int ask_password_tty(
215 : : int ttyfd,
216 : : const char *message,
217 : : const char *keyname,
218 : : usec_t until,
219 : : AskPasswordFlags flags,
220 : : const char *flag_file,
221 : : char ***ret) {
222 : :
223 : : enum {
224 : : POLL_TTY,
225 : : POLL_INOTIFY,
226 : : _POLL_MAX,
227 : : };
228 : :
229 : 0 : bool reset_tty = false, dirty = false, use_color = false;
230 : 0 : _cleanup_close_ int cttyfd = -1, notify = -1;
231 : : struct termios old_termios, new_termios;
232 : 0 : char passphrase[LINE_MAX + 1] = {}, *x;
233 : 0 : _cleanup_strv_free_erase_ char **l = NULL;
234 : : struct pollfd pollfd[_POLL_MAX];
235 : 0 : size_t p = 0, codepoint = 0;
236 : : int r;
237 : :
238 [ # # ]: 0 : assert(ret);
239 : :
240 [ # # ]: 0 : if (flags & ASK_PASSWORD_NO_TTY)
241 : 0 : return -EUNATCH;
242 : :
243 [ # # ]: 0 : if (!message)
244 : 0 : message = "Password:";
245 : :
246 [ # # # # : 0 : if (flag_file || ((flags & ASK_PASSWORD_ACCEPT_CACHED) && keyname)) {
# # ]
247 : 0 : notify = inotify_init1(IN_CLOEXEC|IN_NONBLOCK);
248 [ # # ]: 0 : if (notify < 0)
249 : 0 : return -errno;
250 : : }
251 [ # # ]: 0 : if (flag_file) {
252 [ # # ]: 0 : if (inotify_add_watch(notify, flag_file, IN_ATTRIB /* for the link count */) < 0)
253 : 0 : return -errno;
254 : : }
255 [ # # # # ]: 0 : if ((flags & ASK_PASSWORD_ACCEPT_CACHED) && keyname) {
256 : 0 : r = ask_password_keyring(keyname, flags, ret);
257 [ # # ]: 0 : if (r >= 0)
258 : 0 : return 0;
259 [ # # ]: 0 : else if (r != -ENOKEY)
260 : 0 : return r;
261 : :
262 [ # # ]: 0 : if (inotify_add_watch(notify, "/run/systemd/ask-password", IN_ATTRIB /* for mtime */) < 0)
263 : 0 : return -errno;
264 : : }
265 : :
266 : : /* If the caller didn't specify a TTY, then use the controlling tty, if we can. */
267 [ # # ]: 0 : if (ttyfd < 0)
268 : 0 : ttyfd = cttyfd = open("/dev/tty", O_RDWR|O_NOCTTY|O_CLOEXEC);
269 : :
270 [ # # ]: 0 : if (ttyfd >= 0) {
271 [ # # ]: 0 : if (tcgetattr(ttyfd, &old_termios) < 0)
272 : 0 : return -errno;
273 : :
274 [ # # ]: 0 : if (flags & ASK_PASSWORD_CONSOLE_COLOR)
275 : 0 : use_color = dev_console_colors_enabled();
276 : : else
277 : 0 : use_color = colors_enabled();
278 : :
279 [ # # ]: 0 : if (use_color)
280 : 0 : (void) loop_write(ttyfd, ANSI_HIGHLIGHT, STRLEN(ANSI_HIGHLIGHT), false);
281 : :
282 : 0 : (void) loop_write(ttyfd, message, strlen(message), false);
283 : 0 : (void) loop_write(ttyfd, " ", 1, false);
284 : :
285 [ # # ]: 0 : if (use_color)
286 : 0 : (void) loop_write(ttyfd, ANSI_NORMAL, STRLEN(ANSI_NORMAL), false);
287 : :
288 : 0 : new_termios = old_termios;
289 : 0 : new_termios.c_lflag &= ~(ICANON|ECHO);
290 : 0 : new_termios.c_cc[VMIN] = 1;
291 : 0 : new_termios.c_cc[VTIME] = 0;
292 : :
293 [ # # ]: 0 : if (tcsetattr(ttyfd, TCSADRAIN, &new_termios) < 0) {
294 : 0 : r = -errno;
295 : 0 : goto finish;
296 : : }
297 : :
298 : 0 : reset_tty = true;
299 : : }
300 : :
301 : 0 : pollfd[POLL_TTY] = (struct pollfd) {
302 : 0 : .fd = ttyfd >= 0 ? ttyfd : STDIN_FILENO,
303 : : .events = POLLIN,
304 : : };
305 : 0 : pollfd[POLL_INOTIFY] = (struct pollfd) {
306 : : .fd = notify,
307 : : .events = POLLIN,
308 : : };
309 : :
310 : 0 : for (;;) {
311 [ # # # # ]: 0 : _cleanup_(erase_char) char c;
312 : 0 : int sleep_for = -1, k;
313 : : ssize_t n;
314 : :
315 [ # # ]: 0 : if (until > 0) {
316 : : usec_t y;
317 : :
318 : 0 : y = now(CLOCK_MONOTONIC);
319 : :
320 [ # # ]: 0 : if (y > until) {
321 : 0 : r = -ETIME;
322 : 0 : goto finish;
323 : : }
324 : :
325 : 0 : sleep_for = (int) DIV_ROUND_UP(until - y, USEC_PER_MSEC);
326 : : }
327 : :
328 [ # # ]: 0 : if (flag_file)
329 [ # # ]: 0 : if (access(flag_file, F_OK) < 0) {
330 : 0 : r = -errno;
331 : 0 : goto finish;
332 : : }
333 : :
334 [ # # ]: 0 : k = poll(pollfd, notify >= 0 ? 2 : 1, sleep_for);
335 [ # # ]: 0 : if (k < 0) {
336 [ # # ]: 0 : if (errno == EINTR)
337 : 0 : continue;
338 : :
339 : 0 : r = -errno;
340 : 0 : goto finish;
341 [ # # ]: 0 : } else if (k == 0) {
342 : 0 : r = -ETIME;
343 : 0 : goto finish;
344 : : }
345 : :
346 [ # # # # : 0 : if (notify >= 0 && pollfd[POLL_INOTIFY].revents != 0 && keyname) {
# # ]
347 : 0 : (void) flush_fd(notify);
348 : :
349 : 0 : r = ask_password_keyring(keyname, flags, ret);
350 [ # # ]: 0 : if (r >= 0) {
351 : 0 : r = 0;
352 : 0 : goto finish;
353 [ # # ]: 0 : } else if (r != -ENOKEY)
354 : 0 : goto finish;
355 : : }
356 : :
357 [ # # ]: 0 : if (pollfd[POLL_TTY].revents == 0)
358 : 0 : continue;
359 : :
360 : 0 : n = read(ttyfd >= 0 ? ttyfd : STDIN_FILENO, &c, 1);
361 [ # # ]: 0 : if (n < 0) {
362 [ # # # # ]: 0 : if (IN_SET(errno, EINTR, EAGAIN))
363 : 0 : continue;
364 : :
365 : 0 : r = -errno;
366 : 0 : goto finish;
367 : :
368 : : }
369 : :
370 : : /* We treat EOF, newline and NUL byte all as valid end markers */
371 [ # # # # : 0 : if (n == 0 || c == '\n' || c == 0)
# # ]
372 : : break;
373 : :
374 [ # # ]: 0 : if (c == 21) { /* C-u */
375 : :
376 [ # # ]: 0 : if (!(flags & ASK_PASSWORD_SILENT))
377 : 0 : (void) backspace_string(ttyfd, passphrase);
378 : :
379 : 0 : explicit_bzero_safe(passphrase, sizeof(passphrase));
380 : 0 : p = codepoint = 0;
381 : :
382 [ # # # # ]: 0 : } else if (IN_SET(c, '\b', 127)) {
383 : :
384 [ # # ]: 0 : if (p > 0) {
385 : : size_t q;
386 : :
387 [ # # ]: 0 : if (!(flags & ASK_PASSWORD_SILENT))
388 : 0 : (void) backspace_chars(ttyfd, 1);
389 : :
390 : : /* Remove a full UTF-8 codepoint from the end. For that, figure out where the
391 : : * last one begins */
392 : 0 : q = 0;
393 : 0 : for (;;) {
394 : : size_t z;
395 : :
396 : 0 : z = utf8_encoded_valid_unichar(passphrase + q, (size_t) -1);
397 [ # # ]: 0 : if (z == 0) {
398 : 0 : q = (size_t) -1; /* Invalid UTF8! */
399 : 0 : break;
400 : : }
401 : :
402 [ # # ]: 0 : if (q + z >= p) /* This one brings us over the edge */
403 : 0 : break;
404 : :
405 : 0 : q += z;
406 : : }
407 : :
408 [ # # ]: 0 : p = codepoint = q == (size_t) -1 ? p - 1 : q;
409 : 0 : explicit_bzero_safe(passphrase + p, sizeof(passphrase) - p);
410 : :
411 [ # # # # ]: 0 : } else if (!dirty && !(flags & ASK_PASSWORD_SILENT)) {
412 : :
413 : 0 : flags |= ASK_PASSWORD_SILENT;
414 : :
415 : : /* There are two ways to enter silent mode. Either by pressing backspace as
416 : : * first key (and only as first key), or ... */
417 : :
418 [ # # ]: 0 : if (ttyfd >= 0)
419 : 0 : (void) loop_write(ttyfd, "(no echo) ", 10, false);
420 : :
421 [ # # ]: 0 : } else if (ttyfd >= 0)
422 : 0 : (void) loop_write(ttyfd, "\a", 1, false);
423 : :
424 [ # # # # ]: 0 : } else if (c == '\t' && !(flags & ASK_PASSWORD_SILENT)) {
425 : :
426 : 0 : (void) backspace_string(ttyfd, passphrase);
427 : 0 : flags |= ASK_PASSWORD_SILENT;
428 : :
429 : : /* ... or by pressing TAB at any time. */
430 : :
431 [ # # ]: 0 : if (ttyfd >= 0)
432 : 0 : (void) loop_write(ttyfd, "(no echo) ", 10, false);
433 : :
434 [ # # ]: 0 : } else if (p >= sizeof(passphrase)-1) {
435 : :
436 : : /* Reached the size limit */
437 [ # # ]: 0 : if (ttyfd >= 0)
438 : 0 : (void) loop_write(ttyfd, "\a", 1, false);
439 : :
440 : : } else {
441 : 0 : passphrase[p++] = c;
442 : :
443 [ # # # # ]: 0 : if (!(flags & ASK_PASSWORD_SILENT) && ttyfd >= 0) {
444 : : /* Check if we got a complete UTF-8 character now. If so, let's output one '*'. */
445 : 0 : n = utf8_encoded_valid_unichar(passphrase + codepoint, (size_t) -1);
446 [ # # ]: 0 : if (n >= 0) {
447 [ # # ]: 0 : if (flags & ASK_PASSWORD_ECHO)
448 : 0 : (void) loop_write(ttyfd, passphrase + codepoint, n, false);
449 : : else
450 : 0 : (void) loop_write(ttyfd, "*", 1, false);
451 : 0 : codepoint = p;
452 : : }
453 : : }
454 : :
455 : 0 : dirty = true;
456 : : }
457 : : }
458 : :
459 : 0 : x = strndup(passphrase, p);
460 : 0 : explicit_bzero_safe(passphrase, sizeof(passphrase));
461 [ # # ]: 0 : if (!x) {
462 : 0 : r = -ENOMEM;
463 : 0 : goto finish;
464 : : }
465 : :
466 : 0 : r = strv_consume(&l, x);
467 [ # # ]: 0 : if (r < 0)
468 : 0 : goto finish;
469 : :
470 [ # # ]: 0 : if (keyname)
471 : 0 : (void) add_to_keyring_and_log(keyname, flags, l);
472 : :
473 : 0 : *ret = TAKE_PTR(l);
474 : 0 : r = 0;
475 : :
476 : 0 : finish:
477 [ # # # # ]: 0 : if (ttyfd >= 0 && reset_tty) {
478 : 0 : (void) loop_write(ttyfd, "\n", 1, false);
479 : 0 : (void) tcsetattr(ttyfd, TCSADRAIN, &old_termios);
480 : : }
481 : :
482 : 0 : return r;
483 : : }
484 : :
485 : 0 : static int create_socket(char **ret) {
486 : 0 : _cleanup_free_ char *path = NULL;
487 : 0 : union sockaddr_union sa = {};
488 : 0 : _cleanup_close_ int fd = -1;
489 : : int salen, r;
490 : :
491 [ # # ]: 0 : assert(ret);
492 : :
493 : 0 : fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
494 [ # # ]: 0 : if (fd < 0)
495 : 0 : return -errno;
496 : :
497 [ # # ]: 0 : if (asprintf(&path, "/run/systemd/ask-password/sck.%" PRIx64, random_u64()) < 0)
498 : 0 : return -ENOMEM;
499 : :
500 : 0 : salen = sockaddr_un_set_path(&sa.un, path);
501 [ # # ]: 0 : if (salen < 0)
502 : 0 : return salen;
503 : :
504 [ # # # # ]: 0 : RUN_WITH_UMASK(0177) {
505 [ # # ]: 0 : if (bind(fd, &sa.sa, salen) < 0)
506 : 0 : return -errno;
507 : : }
508 : :
509 : 0 : r = setsockopt_int(fd, SOL_SOCKET, SO_PASSCRED, true);
510 [ # # ]: 0 : if (r < 0)
511 : 0 : return r;
512 : :
513 : 0 : *ret = TAKE_PTR(path);
514 : 0 : return TAKE_FD(fd);
515 : : }
516 : :
517 : 0 : int ask_password_agent(
518 : : const char *message,
519 : : const char *icon,
520 : : const char *id,
521 : : const char *keyname,
522 : : usec_t until,
523 : : AskPasswordFlags flags,
524 : : char ***ret) {
525 : :
526 : : enum {
527 : : FD_SOCKET,
528 : : FD_SIGNAL,
529 : : FD_INOTIFY,
530 : : _FD_MAX
531 : : };
532 : :
533 : 0 : _cleanup_close_ int socket_fd = -1, signal_fd = -1, notify = -1, fd = -1;
534 : 0 : char temp[] = "/run/systemd/ask-password/tmp.XXXXXX";
535 : 0 : char final[sizeof(temp)] = "";
536 : 0 : _cleanup_free_ char *socket_name = NULL;
537 : 0 : _cleanup_strv_free_erase_ char **l = NULL;
538 : 0 : _cleanup_fclose_ FILE *f = NULL;
539 : : struct pollfd pollfd[_FD_MAX];
540 : : sigset_t mask, oldmask;
541 : : int r;
542 : :
543 [ # # ]: 0 : assert(ret);
544 : :
545 [ # # ]: 0 : if (flags & ASK_PASSWORD_NO_AGENT)
546 : 0 : return -EUNATCH;
547 : :
548 [ # # ]: 0 : assert_se(sigemptyset(&mask) >= 0);
549 [ # # ]: 0 : assert_se(sigset_add_many(&mask, SIGINT, SIGTERM, -1) >= 0);
550 [ # # ]: 0 : assert_se(sigprocmask(SIG_BLOCK, &mask, &oldmask) >= 0);
551 : :
552 : 0 : (void) mkdir_p_label("/run/systemd/ask-password", 0755);
553 : :
554 [ # # # # ]: 0 : if ((flags & ASK_PASSWORD_ACCEPT_CACHED) && keyname) {
555 : 0 : r = ask_password_keyring(keyname, flags, ret);
556 [ # # ]: 0 : if (r >= 0) {
557 : 0 : r = 0;
558 : 0 : goto finish;
559 [ # # ]: 0 : } else if (r != -ENOKEY)
560 : 0 : goto finish;
561 : :
562 : 0 : notify = inotify_init1(IN_CLOEXEC | IN_NONBLOCK);
563 [ # # ]: 0 : if (notify < 0) {
564 : 0 : r = -errno;
565 : 0 : goto finish;
566 : : }
567 [ # # ]: 0 : if (inotify_add_watch(notify, "/run/systemd/ask-password", IN_ATTRIB /* for mtime */) < 0) {
568 : 0 : r = -errno;
569 : 0 : goto finish;
570 : : }
571 : : }
572 : :
573 : 0 : fd = mkostemp_safe(temp);
574 [ # # ]: 0 : if (fd < 0) {
575 : 0 : r = fd;
576 : 0 : goto finish;
577 : : }
578 : :
579 : 0 : (void) fchmod(fd, 0644);
580 : :
581 : 0 : f = fdopen(fd, "w");
582 [ # # ]: 0 : if (!f) {
583 : 0 : r = -errno;
584 : 0 : goto finish;
585 : : }
586 : :
587 : 0 : fd = -1;
588 : :
589 : 0 : signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
590 [ # # ]: 0 : if (signal_fd < 0) {
591 : 0 : r = -errno;
592 : 0 : goto finish;
593 : : }
594 : :
595 : 0 : socket_fd = create_socket(&socket_name);
596 [ # # ]: 0 : if (socket_fd < 0) {
597 : 0 : r = socket_fd;
598 : 0 : goto finish;
599 : : }
600 : :
601 : 0 : fprintf(f,
602 : : "[Ask]\n"
603 : : "PID="PID_FMT"\n"
604 : : "Socket=%s\n"
605 : : "AcceptCached=%i\n"
606 : : "Echo=%i\n"
607 : : "NotAfter="USEC_FMT"\n",
608 : : getpid_cached(),
609 : : socket_name,
610 : 0 : (flags & ASK_PASSWORD_ACCEPT_CACHED) ? 1 : 0,
611 : 0 : (flags & ASK_PASSWORD_ECHO) ? 1 : 0,
612 : : until);
613 : :
614 [ # # ]: 0 : if (message)
615 : 0 : fprintf(f, "Message=%s\n", message);
616 : :
617 [ # # ]: 0 : if (icon)
618 : 0 : fprintf(f, "Icon=%s\n", icon);
619 : :
620 [ # # ]: 0 : if (id)
621 : 0 : fprintf(f, "Id=%s\n", id);
622 : :
623 : 0 : r = fflush_and_check(f);
624 [ # # ]: 0 : if (r < 0)
625 : 0 : goto finish;
626 : :
627 : 0 : memcpy(final, temp, sizeof(temp));
628 : :
629 : 0 : final[sizeof(final)-11] = 'a';
630 : 0 : final[sizeof(final)-10] = 's';
631 : 0 : final[sizeof(final)-9] = 'k';
632 : :
633 [ # # ]: 0 : if (rename(temp, final) < 0) {
634 : 0 : r = -errno;
635 : 0 : goto finish;
636 : : }
637 : :
638 [ # # ]: 0 : zero(pollfd);
639 : 0 : pollfd[FD_SOCKET].fd = socket_fd;
640 : 0 : pollfd[FD_SOCKET].events = POLLIN;
641 : 0 : pollfd[FD_SIGNAL].fd = signal_fd;
642 : 0 : pollfd[FD_SIGNAL].events = POLLIN;
643 : 0 : pollfd[FD_INOTIFY].fd = notify;
644 : 0 : pollfd[FD_INOTIFY].events = POLLIN;
645 : :
646 : 0 : for (;;) {
647 : : char passphrase[LINE_MAX+1];
648 : : struct msghdr msghdr;
649 : : struct iovec iovec;
650 : : struct ucred *ucred;
651 : : union {
652 : : struct cmsghdr cmsghdr;
653 : : uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
654 : : } control;
655 : : ssize_t n;
656 : : int k;
657 : : usec_t t;
658 : :
659 : 0 : t = now(CLOCK_MONOTONIC);
660 : :
661 [ # # # # ]: 0 : if (until > 0 && until <= t) {
662 : 0 : r = -ETIME;
663 : 0 : goto finish;
664 : : }
665 : :
666 [ # # # # ]: 0 : k = poll(pollfd, notify >= 0 ? _FD_MAX : _FD_MAX - 1, until > 0 ? (int) ((until-t)/USEC_PER_MSEC) : -1);
667 [ # # ]: 0 : if (k < 0) {
668 [ # # ]: 0 : if (errno == EINTR)
669 : 0 : continue;
670 : :
671 : 0 : r = -errno;
672 : 0 : goto finish;
673 : : }
674 : :
675 [ # # ]: 0 : if (k <= 0) {
676 : 0 : r = -ETIME;
677 : 0 : goto finish;
678 : : }
679 : :
680 [ # # ]: 0 : if (pollfd[FD_SIGNAL].revents & POLLIN) {
681 : 0 : r = -EINTR;
682 : 0 : goto finish;
683 : : }
684 : :
685 [ # # # # ]: 0 : if (notify >= 0 && pollfd[FD_INOTIFY].revents != 0) {
686 : 0 : (void) flush_fd(notify);
687 : :
688 : 0 : r = ask_password_keyring(keyname, flags, ret);
689 [ # # ]: 0 : if (r >= 0) {
690 : 0 : r = 0;
691 : 0 : goto finish;
692 [ # # ]: 0 : } else if (r != -ENOKEY)
693 : 0 : goto finish;
694 : : }
695 : :
696 [ # # ]: 0 : if (pollfd[FD_SOCKET].revents == 0)
697 : 0 : continue;
698 : :
699 [ # # ]: 0 : if (pollfd[FD_SOCKET].revents != POLLIN) {
700 : 0 : r = -EIO;
701 : 0 : goto finish;
702 : : }
703 : :
704 : 0 : iovec = IOVEC_MAKE(passphrase, sizeof(passphrase));
705 : :
706 [ # # ]: 0 : zero(control);
707 [ # # ]: 0 : zero(msghdr);
708 : 0 : msghdr.msg_iov = &iovec;
709 : 0 : msghdr.msg_iovlen = 1;
710 : 0 : msghdr.msg_control = &control;
711 : 0 : msghdr.msg_controllen = sizeof(control);
712 : :
713 : 0 : n = recvmsg(socket_fd, &msghdr, 0);
714 [ # # ]: 0 : if (n < 0) {
715 [ # # # # ]: 0 : if (IN_SET(errno, EAGAIN, EINTR))
716 : 0 : continue;
717 : :
718 : 0 : r = -errno;
719 : 0 : goto finish;
720 : : }
721 : :
722 : 0 : cmsg_close_all(&msghdr);
723 : :
724 [ # # ]: 0 : if (n <= 0) {
725 [ # # ]: 0 : log_debug("Message too short");
726 : 0 : continue;
727 : : }
728 : :
729 [ # # ]: 0 : if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
730 [ # # ]: 0 : control.cmsghdr.cmsg_level != SOL_SOCKET ||
731 [ # # ]: 0 : control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
732 [ # # ]: 0 : control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
733 [ # # ]: 0 : log_debug("Received message without credentials. Ignoring.");
734 : 0 : continue;
735 : : }
736 : :
737 : 0 : ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
738 [ # # ]: 0 : if (ucred->uid != 0) {
739 [ # # ]: 0 : log_debug("Got request from unprivileged user. Ignoring.");
740 : 0 : continue;
741 : : }
742 : :
743 [ # # ]: 0 : if (passphrase[0] == '+') {
744 : : /* An empty message refers to the empty password */
745 [ # # ]: 0 : if (n == 1)
746 : 0 : l = strv_new("");
747 : : else
748 : 0 : l = strv_parse_nulstr(passphrase+1, n-1);
749 : 0 : explicit_bzero_safe(passphrase, n);
750 [ # # ]: 0 : if (!l) {
751 : 0 : r = -ENOMEM;
752 : 0 : goto finish;
753 : : }
754 : :
755 [ # # ]: 0 : if (strv_isempty(l)) {
756 : 0 : l = strv_free(l);
757 [ # # ]: 0 : log_debug("Invalid packet");
758 : 0 : continue;
759 : : }
760 : :
761 : 0 : break;
762 : : }
763 : :
764 [ # # ]: 0 : if (passphrase[0] == '-') {
765 : 0 : r = -ECANCELED;
766 : 0 : goto finish;
767 : : }
768 : :
769 [ # # ]: 0 : log_debug("Invalid packet");
770 : : }
771 : :
772 [ # # ]: 0 : if (keyname)
773 : 0 : (void) add_to_keyring_and_log(keyname, flags, l);
774 : :
775 : 0 : *ret = TAKE_PTR(l);
776 : 0 : r = 0;
777 : :
778 : 0 : finish:
779 [ # # ]: 0 : if (socket_name)
780 : 0 : (void) unlink(socket_name);
781 : :
782 : 0 : (void) unlink(temp);
783 : :
784 [ # # ]: 0 : if (final[0])
785 : 0 : (void) unlink(final);
786 : :
787 [ # # ]: 0 : assert_se(sigprocmask(SIG_SETMASK, &oldmask, NULL) == 0);
788 : 0 : return r;
789 : : }
790 : :
791 : 0 : int ask_password_auto(
792 : : const char *message,
793 : : const char *icon,
794 : : const char *id,
795 : : const char *keyname,
796 : : usec_t until,
797 : : AskPasswordFlags flags,
798 : : char ***ret) {
799 : :
800 : : int r;
801 : :
802 [ # # ]: 0 : assert(ret);
803 : :
804 [ # # # # ]: 0 : if ((flags & ASK_PASSWORD_ACCEPT_CACHED) &&
805 : 0 : keyname &&
806 [ # # # # ]: 0 : ((flags & ASK_PASSWORD_NO_TTY) || !isatty(STDIN_FILENO)) &&
807 [ # # ]: 0 : (flags & ASK_PASSWORD_NO_AGENT)) {
808 : 0 : r = ask_password_keyring(keyname, flags, ret);
809 [ # # ]: 0 : if (r != -ENOKEY)
810 : 0 : return r;
811 : : }
812 : :
813 [ # # # # ]: 0 : if (!(flags & ASK_PASSWORD_NO_TTY) && isatty(STDIN_FILENO))
814 : 0 : return ask_password_tty(-1, message, keyname, until, flags, NULL, ret);
815 : :
816 [ # # ]: 0 : if (!(flags & ASK_PASSWORD_NO_AGENT))
817 : 0 : return ask_password_agent(message, icon, id, keyname, until, flags, ret);
818 : :
819 : 0 : return -EUNATCH;
820 : : }
|
