Merge "Merge branch 'upstream' into tizen" into tizen
[platform/upstream/cryptsetup.git] / lib / utils.c
1 /*
2  * utils - miscellaneous device utilities for cryptsetup
3  *
4  * Copyright (C) 2004 Jana Saout <jana@saout.de>
5  * Copyright (C) 2004-2007 Clemens Fruhwirth <clemens@endorphin.org>
6  * Copyright (C) 2009-2021 Red Hat, Inc. All rights reserved.
7  * Copyright (C) 2009-2021 Milan Broz
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22  */
23
24 #include <stdio.h>
25 #include <errno.h>
26 #include <sys/mman.h>
27 #include <sys/resource.h>
28 #include <sys/stat.h>
29 #include <sys/utsname.h>
30
31 #include "internal.h"
32
33 size_t crypt_getpagesize(void)
34 {
35         long r = sysconf(_SC_PAGESIZE);
36         return r <= 0 ? DEFAULT_MEM_ALIGNMENT : (size_t)r;
37 }
38
39 unsigned crypt_cpusonline(void)
40 {
41         long r = sysconf(_SC_NPROCESSORS_ONLN);
42         return r < 0 ? 1 : r;
43 }
44
45 uint64_t crypt_getphysmemory_kb(void)
46 {
47         long pagesize, phys_pages;
48         uint64_t phys_memory_kb;
49
50         pagesize = sysconf(_SC_PAGESIZE);
51         phys_pages = sysconf(_SC_PHYS_PAGES);
52
53         if (pagesize < 0 || phys_pages < 0)
54                 return 0;
55
56         phys_memory_kb = pagesize / 1024;
57         phys_memory_kb *= phys_pages;
58
59         return phys_memory_kb;
60 }
61
62 /* MEMLOCK */
63 #define DEFAULT_PROCESS_PRIORITY -18
64
65 static int _priority;
66 static int _memlock_count = 0;
67
68 // return 1 if memory is locked
69 int crypt_memlock_inc(struct crypt_device *ctx)
70 {
71         if (!_memlock_count++) {
72                 log_dbg(ctx, "Locking memory.");
73                 if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
74                         log_dbg(ctx, "Cannot lock memory with mlockall.");
75                         _memlock_count--;
76                         return 0;
77                 }
78                 errno = 0;
79                 if (((_priority = getpriority(PRIO_PROCESS, 0)) == -1) && errno)
80                         log_err(ctx, _("Cannot get process priority."));
81                 else
82                         if (setpriority(PRIO_PROCESS, 0, DEFAULT_PROCESS_PRIORITY))
83                                 log_dbg(ctx, "setpriority %d failed: %s",
84                                         DEFAULT_PROCESS_PRIORITY, strerror(errno));
85         }
86         return _memlock_count ? 1 : 0;
87 }
88
89 int crypt_memlock_dec(struct crypt_device *ctx)
90 {
91         if (_memlock_count && (!--_memlock_count)) {
92                 log_dbg(ctx, "Unlocking memory.");
93                 if (munlockall() == -1)
94                         log_err(ctx, _("Cannot unlock memory."));
95                 if (setpriority(PRIO_PROCESS, 0, _priority))
96                         log_dbg(ctx, "setpriority %d failed: %s", _priority, strerror(errno));
97         }
98         return _memlock_count ? 1 : 0;
99 }
100
101 /* Keyfile processing */
102
103 /*
104  * A simple call to lseek(3) might not be possible for some inputs (e.g.
105  * reading from a pipe), so this function instead reads of up to BUFSIZ bytes
106  * at a time until the specified number of bytes. It returns -1 on read error
107  * or when it reaches EOF before the requested number of bytes have been
108  * discarded.
109  */
110 static int keyfile_seek(int fd, uint64_t bytes)
111 {
112         char tmp[BUFSIZ];
113         size_t next_read;
114         ssize_t bytes_r;
115         off64_t r;
116
117         r = lseek64(fd, bytes, SEEK_CUR);
118         if (r > 0)
119                 return 0;
120         if (r < 0 && errno != ESPIPE)
121                 return -1;
122
123         while (bytes > 0) {
124                 /* figure out how much to read */
125                 next_read = bytes > sizeof(tmp) ? sizeof(tmp) : (size_t)bytes;
126
127                 bytes_r = read(fd, tmp, next_read);
128                 if (bytes_r < 0) {
129                         if (errno == EINTR)
130                                 continue;
131
132                         crypt_safe_memzero(tmp, sizeof(tmp));
133                         /* read error */
134                         return -1;
135                 }
136
137                 if (bytes_r == 0)
138                         /* EOF */
139                         break;
140
141                 bytes -= bytes_r;
142         }
143
144         crypt_safe_memzero(tmp, sizeof(tmp));
145         return bytes == 0 ? 0 : -1;
146 }
147
148 int crypt_keyfile_device_read(struct crypt_device *cd,  const char *keyfile,
149                               char **key, size_t *key_size_read,
150                               uint64_t keyfile_offset, size_t key_size,
151                               uint32_t flags)
152 {
153         int fd, regular_file, char_to_read = 0, char_read = 0, unlimited_read = 0;
154         int r = -EINVAL, newline;
155         char *pass = NULL;
156         size_t buflen, i;
157         uint64_t file_read_size;
158         struct stat st;
159
160         if (!key || !key_size_read)
161                 return -EINVAL;
162
163         *key = NULL;
164         *key_size_read = 0;
165
166         fd = keyfile ? open(keyfile, O_RDONLY) : STDIN_FILENO;
167         if (fd < 0) {
168                 log_err(cd, _("Failed to open key file."));
169                 return -EINVAL;
170         }
171
172         if (isatty(fd)) {
173                 log_err(cd, _("Cannot read keyfile from a terminal."));
174                 r = -EINVAL;
175                 goto out_err;
176         }
177
178         /* If not requested otherwise, we limit input to prevent memory exhaustion */
179         if (key_size == 0) {
180                 key_size = DEFAULT_KEYFILE_SIZE_MAXKB * 1024 + 1;
181                 unlimited_read = 1;
182                 /* use 4k for buffer (page divisor but avoid huge pages) */
183                 buflen = 4096 - sizeof(size_t); // sizeof(struct safe_allocation);
184         } else
185                 buflen = key_size;
186
187         regular_file = 0;
188         if (keyfile) {
189                 if (stat(keyfile, &st) < 0) {
190                         log_err(cd, _("Failed to stat key file."));
191                         goto out_err;
192                 }
193                 if (S_ISREG(st.st_mode)) {
194                         regular_file = 1;
195                         file_read_size = (uint64_t)st.st_size;
196
197                         if (keyfile_offset > file_read_size) {
198                                 log_err(cd, _("Cannot seek to requested keyfile offset."));
199                                 goto out_err;
200                         }
201                         file_read_size -= keyfile_offset;
202
203                         /* known keyfile size, alloc it in one step */
204                         if (file_read_size >= (uint64_t)key_size)
205                                 buflen = key_size;
206                         else if (file_read_size)
207                                 buflen = file_read_size;
208                 }
209         }
210
211         pass = crypt_safe_alloc(buflen);
212         if (!pass) {
213                 log_err(cd, _("Out of memory while reading passphrase."));
214                 goto out_err;
215         }
216
217         /* Discard keyfile_offset bytes on input */
218         if (keyfile_offset && keyfile_seek(fd, keyfile_offset) < 0) {
219                 log_err(cd, _("Cannot seek to requested keyfile offset."));
220                 goto out_err;
221         }
222
223         for (i = 0, newline = 0; i < key_size; i += char_read) {
224                 if (i == buflen) {
225                         buflen += 4096;
226                         pass = crypt_safe_realloc(pass, buflen);
227                         if (!pass) {
228                                 log_err(cd, _("Out of memory while reading passphrase."));
229                                 r = -ENOMEM;
230                                 goto out_err;
231                         }
232                 }
233
234                 if (flags & CRYPT_KEYFILE_STOP_EOL) {
235                         /* If we should stop on newline, we must read the input
236                          * one character at the time. Otherwise we might end up
237                          * having read some bytes after the newline, which we
238                          * promised not to do.
239                          */
240                         char_to_read = 1;
241                 } else {
242                         /* char_to_read = min(key_size - i, buflen - i) */
243                         char_to_read = key_size < buflen ?
244                                 key_size - i : buflen - i;
245                 }
246                 char_read = read_buffer(fd, &pass[i], char_to_read);
247                 if (char_read < 0) {
248                         log_err(cd, _("Error reading passphrase."));
249                         r = -EPIPE;
250                         goto out_err;
251                 }
252
253                 if (char_read == 0)
254                         break;
255                 /* Stop on newline only if not requested read from keyfile */
256                 if ((flags & CRYPT_KEYFILE_STOP_EOL) && pass[i] == '\n') {
257                         newline = 1;
258                         pass[i] = '\0';
259                         break;
260                 }
261         }
262
263         /* Fail if piped input dies reading nothing */
264         if (!i && !regular_file && !newline) {
265                 log_err(cd, _("Nothing to read on input."));
266                 r = -EPIPE;
267                 goto out_err;
268         }
269
270         /* Fail if we exceeded internal default (no specified size) */
271         if (unlimited_read && i == key_size) {
272                 log_err(cd, _("Maximum keyfile size exceeded."));
273                 goto out_err;
274         }
275
276         if (!unlimited_read && i != key_size) {
277                 log_err(cd, _("Cannot read requested amount of data."));
278                 goto out_err;
279         }
280
281         *key = pass;
282         *key_size_read = i;
283         r = 0;
284 out_err:
285         if (fd != STDIN_FILENO)
286                 close(fd);
287
288         if (r)
289                 crypt_safe_free(pass);
290         return r;
291 }
292
293 int crypt_keyfile_read(struct crypt_device *cd,  const char *keyfile,
294                        char **key, size_t *key_size_read,
295                        size_t keyfile_offset, size_t keyfile_size_max,
296                        uint32_t flags)
297 {
298         return crypt_keyfile_device_read(cd, keyfile, key, key_size_read,
299                                          keyfile_offset, keyfile_size_max, flags);
300 }
301
302 int kernel_version(uint64_t *kversion)
303 {
304         struct utsname uts;
305         uint16_t maj, min, patch, rel;
306         int r = -EINVAL;
307
308         if (uname(&uts) < 0)
309                 return r;
310
311         if (sscanf(uts.release, "%" SCNu16  ".%" SCNu16 ".%" SCNu16 "-%" SCNu16,
312                    &maj, &min, &patch, &rel) == 4)
313                 r = 0;
314         else if (sscanf(uts.release,  "%" SCNu16 ".%" SCNu16 ".%" SCNu16,
315                         &maj, &min, &patch) == 3) {
316                 rel = 0;
317                 r = 0;
318         }
319
320         if (!r)
321                 *kversion = version(maj, min, patch, rel);
322
323         return r;
324 }
325
326 bool crypt_string_in(const char *str, char **list, size_t list_size)
327 {
328         size_t i;
329
330         for (i = 0; *list && i < list_size; i++, list++)
331                 if (!strcmp(str, *list))
332                         return true;
333
334         return false;
335 }
336
337 /* compare two strings (allows NULL values) */
338 int crypt_strcmp(const char *a, const char *b)
339 {
340         if (!a && !b)
341                 return 0;
342         else if (!a || !b)
343                 return 1;
344         return strcmp(a, b);
345 }