1 /*- 2 * Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #ifdef _KERNEL 32 #include <sys/kernel.h> 33 #include <sys/malloc.h> 34 #include <sys/sysctl.h> 35 #include <sys/systm.h> 36 #endif /* _KERNEL */ 37 #include <sys/queue.h> 38 #include <sys/tree.h> 39 40 #include <geom/geom.h> 41 42 #include <geom/eli/g_eli.h> 43 44 #ifdef _KERNEL 45 MALLOC_DECLARE(M_ELI); 46 47 SYSCTL_DECL(_kern_geom_eli); 48 /* 49 * The default limit (8192 keys) will allow to cache all keys for 4TB 50 * provider with 512 bytes sectors and will take around 1MB of memory. 51 */ 52 static u_int g_eli_key_cache_limit = 8192; 53 SYSCTL_UINT(_kern_geom_eli, OID_AUTO, key_cache_limit, CTLFLAG_RDTUN, 54 &g_eli_key_cache_limit, 0, "Maximum number of encryption keys to cache"); 55 static uint64_t g_eli_key_cache_hits; 56 SYSCTL_UQUAD(_kern_geom_eli, OID_AUTO, key_cache_hits, CTLFLAG_RW, 57 &g_eli_key_cache_hits, 0, "Key cache hits"); 58 static uint64_t g_eli_key_cache_misses; 59 SYSCTL_UQUAD(_kern_geom_eli, OID_AUTO, key_cache_misses, CTLFLAG_RW, 60 &g_eli_key_cache_misses, 0, "Key cache misses"); 61 62 #endif /* _KERNEL */ 63 64 static int 65 g_eli_key_cmp(const struct g_eli_key *a, const struct g_eli_key *b) 66 { 67 68 if (a->gek_keyno > b->gek_keyno) 69 return (1); 70 else if (a->gek_keyno < b->gek_keyno) 71 return (-1); 72 return (0); 73 } 74 75 void 76 g_eli_key_fill(struct g_eli_softc *sc, struct g_eli_key *key, uint64_t keyno) 77 { 78 const uint8_t *ekey; 79 struct { 80 char magic[4]; 81 uint8_t keyno[8]; 82 } __packed hmacdata; 83 84 if ((sc->sc_flags & G_ELI_FLAG_ENC_IVKEY) != 0) 85 ekey = sc->sc_mkey; 86 else 87 ekey = sc->sc_ekey; 88 89 bcopy("ekey", hmacdata.magic, 4); 90 le64enc(hmacdata.keyno, keyno); 91 g_eli_crypto_hmac(ekey, G_ELI_MAXKEYLEN, (uint8_t *)&hmacdata, 92 sizeof(hmacdata), key->gek_key, 0); 93 key->gek_keyno = keyno; 94 key->gek_count = 0; 95 key->gek_magic = G_ELI_KEY_MAGIC; 96 } 97 98 #ifdef _KERNEL 99 RB_PROTOTYPE(g_eli_key_tree, g_eli_key, gek_link, g_eli_key_cmp); 100 RB_GENERATE(g_eli_key_tree, g_eli_key, gek_link, g_eli_key_cmp); 101 102 static struct g_eli_key * 103 g_eli_key_allocate(struct g_eli_softc *sc, uint64_t keyno) 104 { 105 struct g_eli_key *key, *ekey, keysearch; 106 107 mtx_assert(&sc->sc_ekeys_lock, MA_OWNED); 108 mtx_unlock(&sc->sc_ekeys_lock); 109 110 key = malloc(sizeof(*key), M_ELI, M_WAITOK); 111 g_eli_key_fill(sc, key, keyno); 112 113 mtx_lock(&sc->sc_ekeys_lock); 114 /* 115 * Recheck if the key wasn't added while we weren't holding the lock. 116 */ 117 keysearch.gek_keyno = keyno; 118 ekey = RB_FIND(g_eli_key_tree, &sc->sc_ekeys_tree, &keysearch); 119 if (ekey != NULL) { 120 bzero(key, sizeof(*key)); 121 free(key, M_ELI); 122 key = ekey; 123 TAILQ_REMOVE(&sc->sc_ekeys_queue, key, gek_next); 124 } else { 125 RB_INSERT(g_eli_key_tree, &sc->sc_ekeys_tree, key); 126 sc->sc_ekeys_allocated++; 127 } 128 TAILQ_INSERT_TAIL(&sc->sc_ekeys_queue, key, gek_next); 129 130 return (key); 131 } 132 133 static struct g_eli_key * 134 g_eli_key_find_last(struct g_eli_softc *sc) 135 { 136 struct g_eli_key *key; 137 138 mtx_assert(&sc->sc_ekeys_lock, MA_OWNED); 139 140 TAILQ_FOREACH(key, &sc->sc_ekeys_queue, gek_next) { 141 if (key->gek_count == 0) 142 break; 143 } 144 145 return (key); 146 } 147 148 static void 149 g_eli_key_replace(struct g_eli_softc *sc, struct g_eli_key *key, uint64_t keyno) 150 { 151 152 mtx_assert(&sc->sc_ekeys_lock, MA_OWNED); 153 KASSERT(key->gek_magic == G_ELI_KEY_MAGIC, ("Invalid magic.")); 154 155 RB_REMOVE(g_eli_key_tree, &sc->sc_ekeys_tree, key); 156 TAILQ_REMOVE(&sc->sc_ekeys_queue, key, gek_next); 157 158 KASSERT(key->gek_count == 0, ("gek_count=%d", key->gek_count)); 159 160 g_eli_key_fill(sc, key, keyno); 161 162 RB_INSERT(g_eli_key_tree, &sc->sc_ekeys_tree, key); 163 TAILQ_INSERT_TAIL(&sc->sc_ekeys_queue, key, gek_next); 164 } 165 166 static void 167 g_eli_key_remove(struct g_eli_softc *sc, struct g_eli_key *key) 168 { 169 170 mtx_assert(&sc->sc_ekeys_lock, MA_OWNED); 171 KASSERT(key->gek_magic == G_ELI_KEY_MAGIC, ("Invalid magic.")); 172 KASSERT(key->gek_count == 0, ("gek_count=%d", key->gek_count)); 173 174 RB_REMOVE(g_eli_key_tree, &sc->sc_ekeys_tree, key); 175 TAILQ_REMOVE(&sc->sc_ekeys_queue, key, gek_next); 176 sc->sc_ekeys_allocated--; 177 bzero(key, sizeof(*key)); 178 free(key, M_ELI); 179 } 180 181 void 182 g_eli_key_init(struct g_eli_softc *sc) 183 { 184 uint8_t *mkey; 185 186 mtx_lock(&sc->sc_ekeys_lock); 187 188 mkey = sc->sc_mkey + sizeof(sc->sc_ivkey); 189 if ((sc->sc_flags & G_ELI_FLAG_AUTH) == 0) 190 bcopy(mkey, sc->sc_ekey, G_ELI_DATAKEYLEN); 191 else { 192 /* 193 * The encryption key is: ekey = HMAC_SHA512(Data-Key, 0x10) 194 */ 195 g_eli_crypto_hmac(mkey, G_ELI_MAXKEYLEN, "\x10", 1, 196 sc->sc_ekey, 0); 197 } 198 199 if ((sc->sc_flags & G_ELI_FLAG_SINGLE_KEY) != 0) { 200 sc->sc_ekeys_total = 1; 201 sc->sc_ekeys_allocated = 0; 202 } else { 203 off_t mediasize; 204 size_t blocksize; 205 206 if ((sc->sc_flags & G_ELI_FLAG_AUTH) != 0) { 207 struct g_provider *pp; 208 209 pp = LIST_FIRST(&sc->sc_geom->consumer)->provider; 210 mediasize = pp->mediasize; 211 blocksize = pp->sectorsize; 212 } else { 213 mediasize = sc->sc_mediasize; 214 blocksize = sc->sc_sectorsize; 215 } 216 sc->sc_ekeys_total = 217 ((mediasize - 1) >> G_ELI_KEY_SHIFT) / blocksize + 1; 218 sc->sc_ekeys_allocated = 0; 219 TAILQ_INIT(&sc->sc_ekeys_queue); 220 RB_INIT(&sc->sc_ekeys_tree); 221 if (sc->sc_ekeys_total <= g_eli_key_cache_limit) { 222 uint64_t keyno; 223 224 for (keyno = 0; keyno < sc->sc_ekeys_total; keyno++) 225 (void)g_eli_key_allocate(sc, keyno); 226 KASSERT(sc->sc_ekeys_total == sc->sc_ekeys_allocated, 227 ("sc_ekeys_total=%ju != sc_ekeys_allocated=%ju", 228 (uintmax_t)sc->sc_ekeys_total, 229 (uintmax_t)sc->sc_ekeys_allocated)); 230 } 231 } 232 233 mtx_unlock(&sc->sc_ekeys_lock); 234 } 235 236 void 237 g_eli_key_destroy(struct g_eli_softc *sc) 238 { 239 240 mtx_lock(&sc->sc_ekeys_lock); 241 if ((sc->sc_flags & G_ELI_FLAG_SINGLE_KEY) != 0) { 242 bzero(sc->sc_ekey, sizeof(sc->sc_ekey)); 243 } else { 244 struct g_eli_key *key; 245 246 while ((key = TAILQ_FIRST(&sc->sc_ekeys_queue)) != NULL) 247 g_eli_key_remove(sc, key); 248 TAILQ_INIT(&sc->sc_ekeys_queue); 249 RB_INIT(&sc->sc_ekeys_tree); 250 } 251 mtx_unlock(&sc->sc_ekeys_lock); 252 } 253 254 /* 255 * Select encryption key. If G_ELI_FLAG_SINGLE_KEY is present we only have one 256 * key available for all the data. If the flag is not present select the key 257 * based on data offset. 258 */ 259 uint8_t * 260 g_eli_key_hold(struct g_eli_softc *sc, off_t offset, size_t blocksize) 261 { 262 struct g_eli_key *key, keysearch; 263 uint64_t keyno; 264 265 if ((sc->sc_flags & G_ELI_FLAG_SINGLE_KEY) != 0) 266 return (sc->sc_ekey); 267 268 /* We switch key every 2^G_ELI_KEY_SHIFT blocks. */ 269 keyno = (offset >> G_ELI_KEY_SHIFT) / blocksize; 270 271 KASSERT(keyno < sc->sc_ekeys_total, 272 ("%s: keyno=%ju >= sc_ekeys_total=%ju", 273 __func__, (uintmax_t)keyno, (uintmax_t)sc->sc_ekeys_total)); 274 275 keysearch.gek_keyno = keyno; 276 277 if (sc->sc_ekeys_total == sc->sc_ekeys_allocated) { 278 /* We have all the keys, so avoid some overhead. */ 279 key = RB_FIND(g_eli_key_tree, &sc->sc_ekeys_tree, &keysearch); 280 KASSERT(key != NULL, ("No key %ju found.", (uintmax_t)keyno)); 281 KASSERT(key->gek_magic == G_ELI_KEY_MAGIC, 282 ("Invalid key magic.")); 283 return (key->gek_key); 284 } 285 286 mtx_lock(&sc->sc_ekeys_lock); 287 key = RB_FIND(g_eli_key_tree, &sc->sc_ekeys_tree, &keysearch); 288 if (key != NULL) { 289 g_eli_key_cache_hits++; 290 TAILQ_REMOVE(&sc->sc_ekeys_queue, key, gek_next); 291 TAILQ_INSERT_TAIL(&sc->sc_ekeys_queue, key, gek_next); 292 } else { 293 /* 294 * No key in cache, find the least recently unreferenced key 295 * or allocate one if we haven't reached our limit yet. 296 */ 297 if (sc->sc_ekeys_allocated < g_eli_key_cache_limit) { 298 key = g_eli_key_allocate(sc, keyno); 299 } else { 300 g_eli_key_cache_misses++; 301 key = g_eli_key_find_last(sc); 302 if (key != NULL) { 303 g_eli_key_replace(sc, key, keyno); 304 } else { 305 /* All keys are referenced? Allocate one. */ 306 key = g_eli_key_allocate(sc, keyno); 307 } 308 } 309 } 310 key->gek_count++; 311 mtx_unlock(&sc->sc_ekeys_lock); 312 313 KASSERT(key->gek_magic == G_ELI_KEY_MAGIC, ("Invalid key magic.")); 314 315 return (key->gek_key); 316 } 317 318 void 319 g_eli_key_drop(struct g_eli_softc *sc, uint8_t *rawkey) 320 { 321 struct g_eli_key *key = (struct g_eli_key *)rawkey; 322 323 if ((sc->sc_flags & G_ELI_FLAG_SINGLE_KEY) != 0) 324 return; 325 326 KASSERT(key->gek_magic == G_ELI_KEY_MAGIC, ("Invalid key magic.")); 327 328 if (sc->sc_ekeys_total == sc->sc_ekeys_allocated) 329 return; 330 331 mtx_lock(&sc->sc_ekeys_lock); 332 KASSERT(key->gek_count > 0, ("key->gek_count=%d", key->gek_count)); 333 key->gek_count--; 334 while (sc->sc_ekeys_allocated > g_eli_key_cache_limit) { 335 key = g_eli_key_find_last(sc); 336 if (key == NULL) 337 break; 338 g_eli_key_remove(sc, key); 339 } 340 mtx_unlock(&sc->sc_ekeys_lock); 341 } 342 #endif /* _KERNEL */ 343