2 * LUKS - Linux Unified Key Setup
4 * Copyright (C) 2004-2006, Clemens Fruhwirth <clemens@endorphin.org>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <sys/types.h>
27 #include <sys/ioctl.h>
29 #include <sys/utsname.h>
38 #define div_round_up(a,b) ({ \
39 typeof(a) __a = (a); \
40 typeof(b) __b = (b); \
41 (__a - 1) / __b + 1; \
44 static inline int round_up_modulo(int x, int m) {
45 return div_round_up(x, m) * m;
48 static const char *cleaner_name=NULL;
49 static uint64_t cleaner_size = 0;
52 static int setup_mapping(const char *cipher, const char *name,
54 const char *key, size_t keyLength,
55 unsigned int sector, size_t srcLength,
56 int mode, struct crypt_device *ctx)
58 int device_sector_size = sector_size_for_device(device);
59 struct crypt_dm_active_device dmd = {
64 .key_size = keyLength,
68 .flags = (mode == O_RDONLY) ? CRYPT_ACTIVATE_READONLY : 0
72 * we need to round this to nearest multiple of the underlying
73 * device's sector size, otherwise the mapping will be refused.
75 if(device_sector_size < 0) {
76 log_err(ctx, _("Unable to obtain sector size for %s"), device);
80 dmd.size = round_up_modulo(srcLength,device_sector_size)/SECTOR_SIZE;
81 cleaner_size = dmd.size;
83 return dm_create_device(name, "TEMP", &dmd, 0);
86 static void sigint_handler(int sig __attribute__((unused)))
92 dm_remove_device(cleaner_name, 1, cleaner_size);
94 signal(SIGINT, SIG_DFL);
95 kill(getpid(), SIGINT);
98 static const char *_error_hint(char *cipherMode, size_t keyLength)
100 const char *hint= "";
102 char c, tmp[4] = {0};
104 int i = 0, kernel_minor;
106 /* Nothing to suggest here */
107 if (uname(&uts) || strncmp(uts.release, "2.6.", 4))
110 /* Get kernel minor without suffixes */
111 while (i < 3 && (c = uts.release[i + 4]))
112 tmp[i++] = isdigit(c) ? c : '\0';
113 kernel_minor = atoi(tmp);
115 if (!strncmp(cipherMode, "xts", 3) && (keyLength != 256 && keyLength != 512))
116 hint = _("Key size in XTS mode must be 256 or 512 bits.\n");
117 else if (!strncmp(cipherMode, "xts", 3) && kernel_minor < 24)
118 hint = _("Block mode XTS is available since kernel 2.6.24.\n");
119 if (!strncmp(cipherMode, "lrw", 3) && (keyLength != 256 && keyLength != 512))
120 hint = _("Key size in LRW mode must be 256 or 512 bits.\n");
121 else if (!strncmp(cipherMode, "lrw", 3) && kernel_minor < 20)
122 hint = _("Block mode LRW is available since kernel 2.6.20.\n");
127 /* This function is not reentrant safe, as it installs a signal
128 handler and global vars for cleaning */
129 static int LUKS_endec_template(char *src, size_t srcLength,
130 struct luks_phdr *hdr,
131 char *key, size_t keyLength,
134 ssize_t (*func)(int, void *, size_t),
136 struct crypt_device *ctx)
139 char *fullpath = NULL;
140 char *dmCipherSpec = NULL;
141 const char *dmDir = dm_get_dir();
145 log_err(ctx, _("Failed to obtain device mapper directory."));
148 if(asprintf(&name,"temporary-cryptsetup-%d",getpid()) == -1 ||
149 asprintf(&fullpath,"%s/%s",dmDir,name) == -1 ||
150 asprintf(&dmCipherSpec,"%s-%s",hdr->cipherName, hdr->cipherMode) == -1) {
155 signal(SIGINT, sigint_handler);
158 r = setup_mapping(dmCipherSpec, name, device,
159 key, keyLength, sector, srcLength, mode, ctx);
161 log_err(ctx, _("Failed to setup dm-crypt key mapping for device %s.\n"
162 "Check that kernel supports %s cipher (check syslog for more info).\n%s"),
163 device, dmCipherSpec,
164 _error_hint(hdr->cipherMode, keyLength * 8));
169 devfd = open(fullpath, mode | O_DIRECT | O_SYNC); /* devfd is a global var */
171 log_err(ctx, _("Failed to open temporary keystore device.\n"));
176 r = func(devfd,src,srcLength);
178 log_err(ctx, _("Failed to access temporary keystore device.\n"));
188 dm_remove_device(cleaner_name, 1, cleaner_size);
190 signal(SIGINT, SIG_DFL);
199 int LUKS_encrypt_to_storage(char *src, size_t srcLength,
200 struct luks_phdr *hdr,
201 char *key, size_t keyLength,
204 struct crypt_device *ctx)
206 return LUKS_endec_template(src,srcLength,hdr,key,keyLength, device,
207 sector, write_blockwise, O_RDWR, ctx);
210 int LUKS_decrypt_from_storage(char *dst, size_t dstLength,
211 struct luks_phdr *hdr,
212 char *key, size_t keyLength,
215 struct crypt_device *ctx)
217 return LUKS_endec_template(dst,dstLength,hdr,key,keyLength, device,
218 sector, read_blockwise, O_RDONLY, ctx);