1 /* 2 * LUKS - Linux Unified Key Setup 3 * 4 * Copyright (C) 2004-2006, Clemens Fruhwirth <clemens@endorphin.org> 5 * 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. 9 * 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. 14 * 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 18 */ 19 20 #include <string.h> 21 #include <stdio.h> 22 #include <stdlib.h> 23 #include <ctype.h> 24 #include <inttypes.h> 25 #include <sys/types.h> 26 #include <sys/stat.h> 27 #include <sys/ioctl.h> 28 #include <sys/mman.h> 29 #include <sys/utsname.h> 30 #include <fcntl.h> 31 #include <unistd.h> 32 #include <errno.h> 33 #include <signal.h> 34 35 #include "luks.h" 36 //#include "../lib/libcryptsetup.h" 37 #include "../lib/internal.h" 38 //#include "../lib/blockdev.h" 39 40 #define div_round_up(a,b) ({ \ 41 typeof(a) __a = (a); \ 42 typeof(b) __b = (b); \ 43 (__a - 1) / __b + 1; \ 44 }) 45 46 static inline int round_up_modulo(int x, int m) { 47 return div_round_up(x, m) * m; 48 } 49 50 static const char *cleaner_name=NULL; 51 static uint64_t cleaner_size = 0; 52 static int devfd=-1; 53 54 static int setup_mapping(const char *cipher, const char *name, 55 const char *device, unsigned int payloadOffset, 56 const char *key, size_t keyLength, 57 unsigned int sector, size_t srcLength, 58 int mode, struct crypt_device *ctx) 59 { 60 int device_sector_size = sector_size_for_device(device); 61 uint64_t size; 62 63 /* 64 * we need to round this to nearest multiple of the underlying 65 * device's sector size, otherwise the mapping will be refused. 66 */ 67 if(device_sector_size < 0) { 68 log_err(ctx, _("Unable to obtain sector size for %s"), device); 69 return -EINVAL; 70 } 71 size = round_up_modulo(srcLength,device_sector_size)/SECTOR_SIZE; 72 cleaner_size = size; 73 74 return dm_create_device(name, device, cipher, "TEMP", NULL, size, 0, sector, 75 keyLength, key, (mode == O_RDONLY), 0); 76 } 77 78 static void sigint_handler(int sig) 79 { 80 if(devfd >= 0) 81 close(devfd); 82 devfd = -1; 83 if(cleaner_name) 84 dm_remove_device(cleaner_name, 1, cleaner_size); 85 86 signal(SIGINT, SIG_DFL); 87 kill(getpid(), SIGINT); 88 } 89 90 static char *_error_hint(char *cipherName, char *cipherMode, size_t keyLength) 91 { 92 char *hint = ""; 93 #ifdef __linux__ 94 char c, tmp[4] = {0}; 95 struct utsname uts; 96 int i = 0, kernel_minor; 97 98 /* Nothing to suggest here */ 99 if (uname(&uts) || strncmp(uts.release, "2.6.", 4)) 100 return hint; 101 102 /* Get kernel minor without suffixes */ 103 while (i < 3 && (c = uts.release[i + 4])) 104 tmp[i++] = isdigit(c) ? c : '\0'; 105 kernel_minor = atoi(tmp); 106 107 if (!strncmp(cipherMode, "xts", 3) && (keyLength != 256 && keyLength != 512)) 108 hint = _("Key size in XTS mode must be 256 or 512 bits.\n"); 109 else if (!strncmp(cipherMode, "xts", 3) && kernel_minor < 24) 110 hint = _("Block mode XTS is available since kernel 2.6.24.\n"); 111 if (!strncmp(cipherMode, "lrw", 3) && (keyLength != 256 && keyLength != 512)) 112 hint = _("Key size in LRW mode must be 256 or 512 bits.\n"); 113 else if (!strncmp(cipherMode, "lrw", 3) && kernel_minor < 20) 114 hint = _("Block mode LRW is available since kernel 2.6.20.\n"); 115 #endif 116 return hint; 117 } 118 119 /* This function is not reentrant safe, as it installs a signal 120 handler and global vars for cleaning */ 121 static int LUKS_endec_template(char *src, size_t srcLength, 122 struct luks_phdr *hdr, 123 char *key, size_t keyLength, 124 const char *device, 125 unsigned int sector, 126 ssize_t (*func)(int, void *, size_t), 127 int mode, 128 struct crypt_device *ctx) 129 { 130 char *name = NULL; 131 char *fullpath = NULL; 132 char *dmCipherSpec = NULL; 133 const char *dmDir = dm_get_dir(); 134 int r = -1; 135 136 if(dmDir == NULL) { 137 log_err(ctx, _("Failed to obtain device mapper directory.")); 138 return -1; 139 } 140 if(asprintf(&name,"temporary-cryptsetup-%d",getpid()) == -1 || 141 asprintf(&fullpath,"%s/%s",dmDir,name) == -1 || 142 asprintf(&dmCipherSpec,"%s-%s",hdr->cipherName, hdr->cipherMode) == -1) { 143 r = -ENOMEM; 144 goto out1; 145 } 146 147 signal(SIGINT, sigint_handler); 148 cleaner_name = name; 149 150 r = setup_mapping(dmCipherSpec, name, device, hdr->payloadOffset, 151 key, keyLength, sector, srcLength, mode, ctx); 152 if(r < 0) { 153 log_err(ctx, _("Failed to setup dm-crypt key mapping for device %s.\n" 154 "Check that kernel supports %s cipher (check syslog for more info).\n%s"), 155 device, dmCipherSpec, 156 _error_hint(hdr->cipherName, hdr->cipherMode, keyLength * 8)); 157 r = -EIO; 158 goto out1; 159 } 160 161 devfd = open(fullpath, mode | O_DIRECT | O_SYNC); /* devfd is a global var */ 162 if(devfd == -1) { 163 log_err(ctx, _("Failed to open temporary keystore device.\n")); 164 r = -EIO; 165 goto out2; 166 } 167 168 r = func(devfd,src,srcLength); 169 if(r < 0) { 170 log_err(ctx, _("Failed to access temporary keystore device.\n")); 171 r = -EIO; 172 goto out3; 173 } 174 175 r = 0; 176 out3: 177 close(devfd); 178 devfd = -1; 179 out2: 180 dm_remove_device(cleaner_name, 1, cleaner_size); 181 out1: 182 signal(SIGINT, SIG_DFL); 183 cleaner_name = NULL; 184 cleaner_size = 0; 185 free(dmCipherSpec); 186 free(fullpath); 187 free(name); 188 return r; 189 } 190 191 int LUKS_encrypt_to_storage(char *src, size_t srcLength, 192 struct luks_phdr *hdr, 193 char *key, size_t keyLength, 194 const char *device, 195 unsigned int sector, 196 struct crypt_device *ctx) 197 { 198 return LUKS_endec_template(src,srcLength,hdr,key,keyLength, device, sector, 199 (ssize_t (*)(int, void *, size_t)) write_blockwise, 200 O_RDWR, ctx); 201 } 202 203 int LUKS_decrypt_from_storage(char *dst, size_t dstLength, 204 struct luks_phdr *hdr, 205 char *key, size_t keyLength, 206 const char *device, 207 unsigned int sector, 208 struct crypt_device *ctx) 209 { 210 return LUKS_endec_template(dst,dstLength,hdr,key,keyLength, device, 211 sector, read_blockwise, O_RDONLY, ctx); 212 } 213