2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2014-06-24 12:27:04 -06:00
|
|
|
* Copyright (C) 2003 Jana Saout <jana@saout.de>
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org>
|
2009-12-10 16:51:57 -07:00
|
|
|
* Copyright (C) 2006-2009 Red Hat, Inc. All rights reserved.
|
2013-10-28 16:21:04 -06:00
|
|
|
* Copyright (C) 2013 Milan Broz <gmazyland@gmail.com>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*/
|
|
|
|
|
2008-02-07 19:11:09 -07:00
|
|
|
#include <linux/completion.h>
|
2006-08-22 04:29:17 -06:00
|
|
|
#include <linux/err.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/crypto.h>
|
|
|
|
#include <linux/workqueue.h>
|
2015-02-13 06:25:59 -07:00
|
|
|
#include <linux/kthread.h>
|
2006-10-20 00:28:16 -06:00
|
|
|
#include <linux/backing-dev.h>
|
2011-07-26 17:09:06 -06:00
|
|
|
#include <linux/atomic.h>
|
2005-09-17 01:55:31 -06:00
|
|
|
#include <linux/scatterlist.h>
|
2015-02-13 06:27:41 -07:00
|
|
|
#include <linux/rbtree.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/page.h>
|
2006-09-02 16:56:39 -06:00
|
|
|
#include <asm/unaligned.h>
|
2011-01-13 12:59:55 -07:00
|
|
|
#include <crypto/hash.h>
|
|
|
|
#include <crypto/md5.h>
|
|
|
|
#include <crypto/algapi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-21 10:44:59 -06:00
|
|
|
#include <linux/device-mapper.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 01:27:35 -06:00
|
|
|
#define DM_MSG_PREFIX "crypt"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* context holding the current state of a multi-part conversion
|
|
|
|
*/
|
|
|
|
struct convert_context {
|
2008-02-07 19:11:09 -07:00
|
|
|
struct completion restart;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct bio *bio_in;
|
|
|
|
struct bio *bio_out;
|
2013-10-11 16:45:43 -06:00
|
|
|
struct bvec_iter iter_in;
|
|
|
|
struct bvec_iter iter_out;
|
2012-07-27 08:08:05 -06:00
|
|
|
sector_t cc_sector;
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_t cc_pending;
|
2014-02-20 16:01:01 -07:00
|
|
|
struct ablkcipher_request *req;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2008-02-07 19:10:38 -07:00
|
|
|
/*
|
|
|
|
* per bio private data
|
|
|
|
*/
|
|
|
|
struct dm_crypt_io {
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc;
|
2008-02-07 19:10:38 -07:00
|
|
|
struct bio *base_bio;
|
|
|
|
struct work_struct work;
|
|
|
|
|
|
|
|
struct convert_context ctx;
|
|
|
|
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_t io_pending;
|
2008-02-07 19:10:38 -07:00
|
|
|
int error;
|
2008-02-07 19:10:54 -07:00
|
|
|
sector_t sector;
|
2015-02-13 06:25:59 -07:00
|
|
|
|
2015-02-13 06:27:41 -07:00
|
|
|
struct rb_node rb_node;
|
2014-03-28 13:51:55 -06:00
|
|
|
} CRYPTO_MINALIGN_ATTR;
|
2008-02-07 19:10:38 -07:00
|
|
|
|
2008-02-07 19:11:04 -07:00
|
|
|
struct dm_crypt_request {
|
2009-03-16 11:44:33 -06:00
|
|
|
struct convert_context *ctx;
|
2008-02-07 19:11:04 -07:00
|
|
|
struct scatterlist sg_in;
|
|
|
|
struct scatterlist sg_out;
|
2011-01-13 12:59:54 -07:00
|
|
|
sector_t iv_sector;
|
2008-02-07 19:11:04 -07:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct crypt_config;
|
|
|
|
|
|
|
|
struct crypt_iv_operations {
|
|
|
|
int (*ctr)(struct crypt_config *cc, struct dm_target *ti,
|
2007-10-19 15:42:37 -06:00
|
|
|
const char *opts);
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*dtr)(struct crypt_config *cc);
|
2009-12-10 16:51:56 -07:00
|
|
|
int (*init)(struct crypt_config *cc);
|
2009-12-10 16:51:57 -07:00
|
|
|
int (*wipe)(struct crypt_config *cc);
|
2011-01-13 12:59:54 -07:00
|
|
|
int (*generator)(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq);
|
|
|
|
int (*post)(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq);
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2009-12-10 16:51:55 -07:00
|
|
|
struct iv_essiv_private {
|
2009-12-10 16:51:56 -07:00
|
|
|
struct crypto_hash *hash_tfm;
|
|
|
|
u8 *salt;
|
2009-12-10 16:51:55 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct iv_benbi_private {
|
|
|
|
int shift;
|
|
|
|
};
|
|
|
|
|
2011-01-13 12:59:55 -07:00
|
|
|
#define LMK_SEED_SIZE 64 /* hash + 0 */
|
|
|
|
struct iv_lmk_private {
|
|
|
|
struct crypto_shash *hash_tfm;
|
|
|
|
u8 *seed;
|
|
|
|
};
|
|
|
|
|
2013-10-28 16:21:04 -06:00
|
|
|
#define TCW_WHITENING_SIZE 16
|
|
|
|
struct iv_tcw_private {
|
|
|
|
struct crypto_shash *crc32_tfm;
|
|
|
|
u8 *iv_seed;
|
|
|
|
u8 *whitening;
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Crypt: maps a linear range of a block device
|
|
|
|
* and encrypts / decrypts at the same time.
|
|
|
|
*/
|
2015-02-13 06:27:08 -07:00
|
|
|
enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID,
|
|
|
|
DM_CRYPT_SAME_CPU, DM_CRYPT_NO_OFFLOAD };
|
2011-01-13 12:59:53 -07:00
|
|
|
|
|
|
|
/*
|
2014-02-20 16:01:01 -07:00
|
|
|
* The fields in here must be read only after initialization.
|
2011-01-13 12:59:53 -07:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
struct crypt_config {
|
|
|
|
struct dm_dev *dev;
|
|
|
|
sector_t start;
|
|
|
|
|
|
|
|
/*
|
2008-02-07 19:11:07 -07:00
|
|
|
* pool for per bio private data, crypto requests and
|
|
|
|
* encryption requeusts/buffer pages
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-02-07 19:11:07 -07:00
|
|
|
mempool_t *req_pool;
|
2005-04-16 16:20:36 -06:00
|
|
|
mempool_t *page_pool;
|
2006-10-03 02:15:40 -06:00
|
|
|
struct bio_set *bs;
|
2015-02-13 06:24:41 -07:00
|
|
|
struct mutex bio_alloc_lock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-19 15:38:58 -06:00
|
|
|
struct workqueue_struct *io_queue;
|
|
|
|
struct workqueue_struct *crypt_queue;
|
2008-03-28 15:16:07 -06:00
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
struct task_struct *write_thread;
|
|
|
|
wait_queue_head_t write_thread_wait;
|
2015-02-13 06:27:41 -07:00
|
|
|
struct rb_root write_tree;
|
2015-02-13 06:25:59 -07:00
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
char *cipher;
|
2011-01-13 12:59:52 -07:00
|
|
|
char *cipher_string;
|
2010-08-11 21:14:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct crypt_iv_operations *iv_gen_ops;
|
2006-12-05 14:41:52 -07:00
|
|
|
union {
|
2009-12-10 16:51:55 -07:00
|
|
|
struct iv_essiv_private essiv;
|
|
|
|
struct iv_benbi_private benbi;
|
2011-01-13 12:59:55 -07:00
|
|
|
struct iv_lmk_private lmk;
|
2013-10-28 16:21:04 -06:00
|
|
|
struct iv_tcw_private tcw;
|
2006-12-05 14:41:52 -07:00
|
|
|
} iv_gen_private;
|
2005-04-16 16:20:36 -06:00
|
|
|
sector_t iv_offset;
|
|
|
|
unsigned int iv_size;
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
/* ESSIV: struct crypto_cipher *essiv_tfm */
|
|
|
|
void *iv_private;
|
|
|
|
struct crypto_ablkcipher **tfms;
|
2011-01-13 12:59:54 -07:00
|
|
|
unsigned tfms_count;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2008-02-07 19:11:07 -07:00
|
|
|
/*
|
|
|
|
* Layout of each crypto request:
|
|
|
|
*
|
|
|
|
* struct ablkcipher_request
|
|
|
|
* context
|
|
|
|
* padding
|
|
|
|
* struct dm_crypt_request
|
|
|
|
* padding
|
|
|
|
* IV
|
|
|
|
*
|
|
|
|
* The padding is added so that dm_crypt_request and the IV are
|
|
|
|
* correctly aligned.
|
|
|
|
*/
|
|
|
|
unsigned int dmreq_start;
|
|
|
|
|
2014-03-28 13:51:55 -06:00
|
|
|
unsigned int per_bio_data_size;
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int key_size;
|
2013-10-28 16:21:03 -06:00
|
|
|
unsigned int key_parts; /* independent parts in key buffer */
|
|
|
|
unsigned int key_extra_size; /* additional keys length */
|
2005-04-16 16:20:36 -06:00
|
|
|
u8 key[0];
|
|
|
|
};
|
|
|
|
|
2006-10-03 02:15:40 -06:00
|
|
|
#define MIN_IOS 16
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 10:26:32 -06:00
|
|
|
static void clone_init(struct dm_crypt_io *, struct bio *);
|
2008-02-07 19:10:52 -07:00
|
|
|
static void kcryptd_queue_crypt(struct dm_crypt_io *io);
|
2011-01-13 12:59:54 -07:00
|
|
|
static u8 *iv_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq);
|
2007-05-09 03:32:52 -06:00
|
|
|
|
2011-01-13 12:59:53 -07:00
|
|
|
/*
|
|
|
|
* Use this to access cipher attributes that are the same for each CPU.
|
|
|
|
*/
|
|
|
|
static struct crypto_ablkcipher *any_tfm(struct crypt_config *cc)
|
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
return cc->tfms[0];
|
2011-01-13 12:59:53 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Different IV generation algorithms:
|
|
|
|
*
|
2006-09-02 02:17:33 -06:00
|
|
|
* plain: the initial vector is the 32-bit little-endian version of the sector
|
2007-10-19 15:10:43 -06:00
|
|
|
* number, padded with zeros if necessary.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2009-12-10 16:52:25 -07:00
|
|
|
* plain64: the initial vector is the 64-bit little-endian version of the sector
|
|
|
|
* number, padded with zeros if necessary.
|
|
|
|
*
|
2006-09-02 02:17:33 -06:00
|
|
|
* essiv: "encrypted sector|salt initial vector", the sector number is
|
|
|
|
* encrypted with the bulk cipher using a salt as key. The salt
|
|
|
|
* should be derived from the bulk cipher's key via hashing.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-09-02 16:56:39 -06:00
|
|
|
* benbi: the 64-bit "big-endian 'narrow block'-count", starting at 1
|
|
|
|
* (needed for LRW-32-AES and possible other narrow block modes)
|
|
|
|
*
|
2007-05-09 03:32:55 -06:00
|
|
|
* null: the initial vector is always zero. Provides compatibility with
|
|
|
|
* obsolete loop_fish2 devices. Do not use for new devices.
|
|
|
|
*
|
2011-01-13 12:59:55 -07:00
|
|
|
* lmk: Compatible implementation of the block chaining mode used
|
|
|
|
* by the Loop-AES block device encryption system
|
|
|
|
* designed by Jari Ruusu. See http://loop-aes.sourceforge.net/
|
|
|
|
* It operates on full 512 byte sectors and uses CBC
|
|
|
|
* with an IV derived from the sector number, the data and
|
|
|
|
* optionally extra IV seed.
|
|
|
|
* This means that after decryption the first block
|
|
|
|
* of sector must be tweaked according to decrypted data.
|
|
|
|
* Loop-AES can use three encryption schemes:
|
|
|
|
* version 1: is plain aes-cbc mode
|
|
|
|
* version 2: uses 64 multikey scheme with lmk IV generator
|
|
|
|
* version 3: the same as version 2 with additional IV seed
|
|
|
|
* (it uses 65 keys, last key is used as IV seed)
|
|
|
|
*
|
2013-10-28 16:21:04 -06:00
|
|
|
* tcw: Compatible implementation of the block chaining mode used
|
|
|
|
* by the TrueCrypt device encryption system (prior to version 4.1).
|
2015-04-05 10:03:10 -06:00
|
|
|
* For more info see: https://gitlab.com/cryptsetup/cryptsetup/wikis/TrueCryptOnDiskFormat
|
2013-10-28 16:21:04 -06:00
|
|
|
* It operates on full 512 byte sectors and uses CBC
|
|
|
|
* with an IV derived from initial key and the sector number.
|
|
|
|
* In addition, whitening value is applied on every sector, whitening
|
|
|
|
* is calculated from initial key, sector number and mixed using CRC32.
|
|
|
|
* Note that this encryption scheme is vulnerable to watermarking attacks
|
|
|
|
* and should be used for old compatible containers access only.
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* plumb: unimplemented, see:
|
|
|
|
* http://article.gmane.org/gmane.linux.kernel.device-mapper.dm-crypt/454
|
|
|
|
*/
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
memset(iv, 0, cc->iv_size);
|
2011-08-02 05:32:01 -06:00
|
|
|
*(__le32 *)iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-10 16:52:25 -07:00
|
|
|
static int crypt_iv_plain64_gen(struct crypt_config *cc, u8 *iv,
|
2011-01-13 12:59:54 -07:00
|
|
|
struct dm_crypt_request *dmreq)
|
2009-12-10 16:52:25 -07:00
|
|
|
{
|
|
|
|
memset(iv, 0, cc->iv_size);
|
2011-08-02 05:32:01 -06:00
|
|
|
*(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
|
2009-12-10 16:52:25 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:56 -07:00
|
|
|
/* Initialise ESSIV - compute salt but no local memory allocations */
|
|
|
|
static int crypt_iv_essiv_init(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
|
|
|
|
struct hash_desc desc;
|
|
|
|
struct scatterlist sg;
|
2011-01-13 12:59:53 -07:00
|
|
|
struct crypto_cipher *essiv_tfm;
|
2012-07-27 08:08:05 -06:00
|
|
|
int err;
|
2009-12-10 16:51:56 -07:00
|
|
|
|
|
|
|
sg_init_one(&sg, cc->key, cc->key_size);
|
|
|
|
desc.tfm = essiv->hash_tfm;
|
|
|
|
desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
|
|
|
|
|
|
|
|
err = crypto_hash_digest(&desc, &sg, cc->key_size, essiv->salt);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
essiv_tfm = cc->iv_private;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
err = crypto_cipher_setkey(essiv_tfm, essiv->salt,
|
|
|
|
crypto_hash_digestsize(essiv->hash_tfm));
|
|
|
|
if (err)
|
|
|
|
return err;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
|
|
|
return 0;
|
2009-12-10 16:51:56 -07:00
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:57 -07:00
|
|
|
/* Wipe salt and reset key derived from volume key */
|
|
|
|
static int crypt_iv_essiv_wipe(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
|
|
|
|
unsigned salt_size = crypto_hash_digestsize(essiv->hash_tfm);
|
2011-01-13 12:59:53 -07:00
|
|
|
struct crypto_cipher *essiv_tfm;
|
2012-07-27 08:08:05 -06:00
|
|
|
int r, err = 0;
|
2009-12-10 16:51:57 -07:00
|
|
|
|
|
|
|
memset(essiv->salt, 0, salt_size);
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
essiv_tfm = cc->iv_private;
|
|
|
|
r = crypto_cipher_setkey(essiv_tfm, essiv->salt, salt_size);
|
|
|
|
if (r)
|
|
|
|
err = r;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up per cpu cipher state */
|
|
|
|
static struct crypto_cipher *setup_essiv_cpu(struct crypt_config *cc,
|
|
|
|
struct dm_target *ti,
|
|
|
|
u8 *salt, unsigned saltsize)
|
|
|
|
{
|
|
|
|
struct crypto_cipher *essiv_tfm;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* Setup the essiv_tfm with the given salt */
|
|
|
|
essiv_tfm = crypto_alloc_cipher(cc->cipher, 0, CRYPTO_ALG_ASYNC);
|
|
|
|
if (IS_ERR(essiv_tfm)) {
|
|
|
|
ti->error = "Error allocating crypto tfm for ESSIV";
|
|
|
|
return essiv_tfm;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (crypto_cipher_blocksize(essiv_tfm) !=
|
|
|
|
crypto_ablkcipher_ivsize(any_tfm(cc))) {
|
|
|
|
ti->error = "Block size of ESSIV cipher does "
|
|
|
|
"not match IV size of block cipher";
|
|
|
|
crypto_free_cipher(essiv_tfm);
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = crypto_cipher_setkey(essiv_tfm, salt, saltsize);
|
|
|
|
if (err) {
|
|
|
|
ti->error = "Failed to set key for ESSIV cipher";
|
|
|
|
crypto_free_cipher(essiv_tfm);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
return essiv_tfm;
|
2009-12-10 16:51:57 -07:00
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:55 -07:00
|
|
|
static void crypt_iv_essiv_dtr(struct crypt_config *cc)
|
|
|
|
{
|
2011-01-13 12:59:53 -07:00
|
|
|
struct crypto_cipher *essiv_tfm;
|
2009-12-10 16:51:55 -07:00
|
|
|
struct iv_essiv_private *essiv = &cc->iv_gen_private.essiv;
|
|
|
|
|
2009-12-10 16:51:56 -07:00
|
|
|
crypto_free_hash(essiv->hash_tfm);
|
|
|
|
essiv->hash_tfm = NULL;
|
|
|
|
|
|
|
|
kzfree(essiv->salt);
|
|
|
|
essiv->salt = NULL;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
essiv_tfm = cc->iv_private;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
if (essiv_tfm)
|
|
|
|
crypto_free_cipher(essiv_tfm);
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
cc->iv_private = NULL;
|
2009-12-10 16:51:55 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
|
2007-10-19 15:42:37 -06:00
|
|
|
const char *opts)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-12-10 16:51:56 -07:00
|
|
|
struct crypto_cipher *essiv_tfm = NULL;
|
|
|
|
struct crypto_hash *hash_tfm = NULL;
|
|
|
|
u8 *salt = NULL;
|
2012-07-27 08:08:05 -06:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-10 16:51:56 -07:00
|
|
|
if (!opts) {
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Digest algorithm missing for ESSIV mode";
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:56 -07:00
|
|
|
/* Allocate hash algorithm */
|
2006-08-24 03:10:20 -06:00
|
|
|
hash_tfm = crypto_alloc_hash(opts, 0, CRYPTO_ALG_ASYNC);
|
|
|
|
if (IS_ERR(hash_tfm)) {
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Error initializing ESSIV hash";
|
2009-12-10 16:51:56 -07:00
|
|
|
err = PTR_ERR(hash_tfm);
|
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:56 -07:00
|
|
|
salt = kzalloc(crypto_hash_digestsize(hash_tfm), GFP_KERNEL);
|
2009-12-10 16:51:56 -07:00
|
|
|
if (!salt) {
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Error kmallocing salt storage in ESSIV";
|
2009-12-10 16:51:56 -07:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:56 -07:00
|
|
|
cc->iv_gen_private.essiv.salt = salt;
|
|
|
|
cc->iv_gen_private.essiv.hash_tfm = hash_tfm;
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
essiv_tfm = setup_essiv_cpu(cc, ti, salt,
|
|
|
|
crypto_hash_digestsize(hash_tfm));
|
|
|
|
if (IS_ERR(essiv_tfm)) {
|
|
|
|
crypt_iv_essiv_dtr(cc);
|
|
|
|
return PTR_ERR(essiv_tfm);
|
2011-01-13 12:59:53 -07:00
|
|
|
}
|
2012-07-27 08:08:05 -06:00
|
|
|
cc->iv_private = essiv_tfm;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2009-12-10 16:51:56 -07:00
|
|
|
|
|
|
|
bad:
|
|
|
|
if (hash_tfm && !IS_ERR(hash_tfm))
|
|
|
|
crypto_free_hash(hash_tfm);
|
2009-12-10 16:51:56 -07:00
|
|
|
kfree(salt);
|
2009-12-10 16:51:56 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypto_cipher *essiv_tfm = cc->iv_private;
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
memset(iv, 0, cc->iv_size);
|
2011-08-02 05:32:01 -06:00
|
|
|
*(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
|
2011-01-13 12:59:53 -07:00
|
|
|
crypto_cipher_encrypt_one(essiv_tfm, iv, iv);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-02 16:56:39 -06:00
|
|
|
static int crypt_iv_benbi_ctr(struct crypt_config *cc, struct dm_target *ti,
|
|
|
|
const char *opts)
|
|
|
|
{
|
2011-01-13 12:59:53 -07:00
|
|
|
unsigned bs = crypto_ablkcipher_blocksize(any_tfm(cc));
|
2006-12-08 03:37:49 -07:00
|
|
|
int log = ilog2(bs);
|
2006-09-02 16:56:39 -06:00
|
|
|
|
|
|
|
/* we need to calculate how far we must shift the sector count
|
|
|
|
* to get the cipher block count, we use this shift in _gen */
|
|
|
|
|
|
|
|
if (1 << log != bs) {
|
|
|
|
ti->error = "cypher blocksize is not a power of 2";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (log > 9) {
|
|
|
|
ti->error = "cypher blocksize is > 512";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-10 16:51:55 -07:00
|
|
|
cc->iv_gen_private.benbi.shift = 9 - log;
|
2006-09-02 16:56:39 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void crypt_iv_benbi_dtr(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
static int crypt_iv_benbi_gen(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
2006-09-02 16:56:39 -06:00
|
|
|
{
|
2006-12-05 14:41:52 -07:00
|
|
|
__be64 val;
|
|
|
|
|
2006-09-02 16:56:39 -06:00
|
|
|
memset(iv, 0, cc->iv_size - sizeof(u64)); /* rest is cleared below */
|
2006-12-05 14:41:52 -07:00
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
val = cpu_to_be64(((u64)dmreq->iv_sector << cc->iv_gen_private.benbi.shift) + 1);
|
2006-12-05 14:41:52 -07:00
|
|
|
put_unaligned(val, (__be64 *)(iv + cc->iv_size - sizeof(u64)));
|
2006-09-02 16:56:39 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
static int crypt_iv_null_gen(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
2007-05-09 03:32:55 -06:00
|
|
|
{
|
|
|
|
memset(iv, 0, cc->iv_size);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:55 -07:00
|
|
|
static void crypt_iv_lmk_dtr(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
|
|
|
|
|
|
|
|
if (lmk->hash_tfm && !IS_ERR(lmk->hash_tfm))
|
|
|
|
crypto_free_shash(lmk->hash_tfm);
|
|
|
|
lmk->hash_tfm = NULL;
|
|
|
|
|
|
|
|
kzfree(lmk->seed);
|
|
|
|
lmk->seed = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_lmk_ctr(struct crypt_config *cc, struct dm_target *ti,
|
|
|
|
const char *opts)
|
|
|
|
{
|
|
|
|
struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
|
|
|
|
|
|
|
|
lmk->hash_tfm = crypto_alloc_shash("md5", 0, 0);
|
|
|
|
if (IS_ERR(lmk->hash_tfm)) {
|
|
|
|
ti->error = "Error initializing LMK hash";
|
|
|
|
return PTR_ERR(lmk->hash_tfm);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No seed in LMK version 2 */
|
|
|
|
if (cc->key_parts == cc->tfms_count) {
|
|
|
|
lmk->seed = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
lmk->seed = kzalloc(LMK_SEED_SIZE, GFP_KERNEL);
|
|
|
|
if (!lmk->seed) {
|
|
|
|
crypt_iv_lmk_dtr(cc);
|
|
|
|
ti->error = "Error kmallocing seed storage in LMK";
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_lmk_init(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
|
|
|
|
int subkey_size = cc->key_size / cc->key_parts;
|
|
|
|
|
|
|
|
/* LMK seed is on the position of LMK_KEYS + 1 key */
|
|
|
|
if (lmk->seed)
|
|
|
|
memcpy(lmk->seed, cc->key + (cc->tfms_count * subkey_size),
|
|
|
|
crypto_shash_digestsize(lmk->hash_tfm));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_lmk_wipe(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
|
|
|
|
|
|
|
|
if (lmk->seed)
|
|
|
|
memset(lmk->seed, 0, LMK_SEED_SIZE);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_lmk_one(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq,
|
|
|
|
u8 *data)
|
|
|
|
{
|
|
|
|
struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
|
2012-07-02 05:50:54 -06:00
|
|
|
SHASH_DESC_ON_STACK(desc, lmk->hash_tfm);
|
2011-01-13 12:59:55 -07:00
|
|
|
struct md5_state md5state;
|
2013-10-28 16:21:03 -06:00
|
|
|
__le32 buf[4];
|
2011-01-13 12:59:55 -07:00
|
|
|
int i, r;
|
|
|
|
|
2012-07-02 05:50:54 -06:00
|
|
|
desc->tfm = lmk->hash_tfm;
|
|
|
|
desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
|
2011-01-13 12:59:55 -07:00
|
|
|
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_init(desc);
|
2011-01-13 12:59:55 -07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (lmk->seed) {
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_update(desc, lmk->seed, LMK_SEED_SIZE);
|
2011-01-13 12:59:55 -07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sector is always 512B, block size 16, add data of blocks 1-31 */
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_update(desc, data + 16, 16 * 31);
|
2011-01-13 12:59:55 -07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
/* Sector is cropped to 56 bits here */
|
|
|
|
buf[0] = cpu_to_le32(dmreq->iv_sector & 0xFFFFFFFF);
|
|
|
|
buf[1] = cpu_to_le32((((u64)dmreq->iv_sector >> 32) & 0x00FFFFFF) | 0x80000000);
|
|
|
|
buf[2] = cpu_to_le32(4024);
|
|
|
|
buf[3] = 0;
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_update(desc, (u8 *)buf, sizeof(buf));
|
2011-01-13 12:59:55 -07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
/* No MD5 padding here */
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_export(desc, &md5state);
|
2011-01-13 12:59:55 -07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
for (i = 0; i < MD5_HASH_WORDS; i++)
|
|
|
|
__cpu_to_le32s(&md5state.hash[i]);
|
|
|
|
memcpy(iv, &md5state.hash, cc->iv_size);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_lmk_gen(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
|
|
|
{
|
|
|
|
u8 *src;
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) {
|
2011-11-27 22:26:02 -07:00
|
|
|
src = kmap_atomic(sg_page(&dmreq->sg_in));
|
2011-01-13 12:59:55 -07:00
|
|
|
r = crypt_iv_lmk_one(cc, iv, dmreq, src + dmreq->sg_in.offset);
|
2011-11-27 22:26:02 -07:00
|
|
|
kunmap_atomic(src);
|
2011-01-13 12:59:55 -07:00
|
|
|
} else
|
|
|
|
memset(iv, 0, cc->iv_size);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_lmk_post(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
|
|
|
{
|
|
|
|
u8 *dst;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (bio_data_dir(dmreq->ctx->bio_in) == WRITE)
|
|
|
|
return 0;
|
|
|
|
|
2011-11-27 22:26:02 -07:00
|
|
|
dst = kmap_atomic(sg_page(&dmreq->sg_out));
|
2011-01-13 12:59:55 -07:00
|
|
|
r = crypt_iv_lmk_one(cc, iv, dmreq, dst + dmreq->sg_out.offset);
|
|
|
|
|
|
|
|
/* Tweak the first block of plaintext sector */
|
|
|
|
if (!r)
|
|
|
|
crypto_xor(dst + dmreq->sg_out.offset, iv, cc->iv_size);
|
|
|
|
|
2011-11-27 22:26:02 -07:00
|
|
|
kunmap_atomic(dst);
|
2011-01-13 12:59:55 -07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-10-28 16:21:04 -06:00
|
|
|
static void crypt_iv_tcw_dtr(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
|
|
|
|
|
|
|
|
kzfree(tcw->iv_seed);
|
|
|
|
tcw->iv_seed = NULL;
|
|
|
|
kzfree(tcw->whitening);
|
|
|
|
tcw->whitening = NULL;
|
|
|
|
|
|
|
|
if (tcw->crc32_tfm && !IS_ERR(tcw->crc32_tfm))
|
|
|
|
crypto_free_shash(tcw->crc32_tfm);
|
|
|
|
tcw->crc32_tfm = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_tcw_ctr(struct crypt_config *cc, struct dm_target *ti,
|
|
|
|
const char *opts)
|
|
|
|
{
|
|
|
|
struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
|
|
|
|
|
|
|
|
if (cc->key_size <= (cc->iv_size + TCW_WHITENING_SIZE)) {
|
|
|
|
ti->error = "Wrong key size for TCW";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
tcw->crc32_tfm = crypto_alloc_shash("crc32", 0, 0);
|
|
|
|
if (IS_ERR(tcw->crc32_tfm)) {
|
|
|
|
ti->error = "Error initializing CRC32 in TCW";
|
|
|
|
return PTR_ERR(tcw->crc32_tfm);
|
|
|
|
}
|
|
|
|
|
|
|
|
tcw->iv_seed = kzalloc(cc->iv_size, GFP_KERNEL);
|
|
|
|
tcw->whitening = kzalloc(TCW_WHITENING_SIZE, GFP_KERNEL);
|
|
|
|
if (!tcw->iv_seed || !tcw->whitening) {
|
|
|
|
crypt_iv_tcw_dtr(cc);
|
|
|
|
ti->error = "Error allocating seed storage in TCW";
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_tcw_init(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
|
|
|
|
int key_offset = cc->key_size - cc->iv_size - TCW_WHITENING_SIZE;
|
|
|
|
|
|
|
|
memcpy(tcw->iv_seed, &cc->key[key_offset], cc->iv_size);
|
|
|
|
memcpy(tcw->whitening, &cc->key[key_offset + cc->iv_size],
|
|
|
|
TCW_WHITENING_SIZE);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_tcw_wipe(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
|
|
|
|
|
|
|
|
memset(tcw->iv_seed, 0, cc->iv_size);
|
|
|
|
memset(tcw->whitening, 0, TCW_WHITENING_SIZE);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_tcw_whitening(struct crypt_config *cc,
|
|
|
|
struct dm_crypt_request *dmreq,
|
|
|
|
u8 *data)
|
|
|
|
{
|
|
|
|
struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
|
|
|
|
u64 sector = cpu_to_le64((u64)dmreq->iv_sector);
|
|
|
|
u8 buf[TCW_WHITENING_SIZE];
|
2012-07-02 05:50:54 -06:00
|
|
|
SHASH_DESC_ON_STACK(desc, tcw->crc32_tfm);
|
2013-10-28 16:21:04 -06:00
|
|
|
int i, r;
|
|
|
|
|
|
|
|
/* xor whitening with sector number */
|
|
|
|
memcpy(buf, tcw->whitening, TCW_WHITENING_SIZE);
|
|
|
|
crypto_xor(buf, (u8 *)§or, 8);
|
|
|
|
crypto_xor(&buf[8], (u8 *)§or, 8);
|
|
|
|
|
|
|
|
/* calculate crc32 for every 32bit part and xor it */
|
2012-07-02 05:50:54 -06:00
|
|
|
desc->tfm = tcw->crc32_tfm;
|
|
|
|
desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
|
2013-10-28 16:21:04 -06:00
|
|
|
for (i = 0; i < 4; i++) {
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_init(desc);
|
2013-10-28 16:21:04 -06:00
|
|
|
if (r)
|
|
|
|
goto out;
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_update(desc, &buf[i * 4], 4);
|
2013-10-28 16:21:04 -06:00
|
|
|
if (r)
|
|
|
|
goto out;
|
2012-07-02 05:50:54 -06:00
|
|
|
r = crypto_shash_final(desc, &buf[i * 4]);
|
2013-10-28 16:21:04 -06:00
|
|
|
if (r)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
crypto_xor(&buf[0], &buf[12], 4);
|
|
|
|
crypto_xor(&buf[4], &buf[8], 4);
|
|
|
|
|
|
|
|
/* apply whitening (8 bytes) to whole sector */
|
|
|
|
for (i = 0; i < ((1 << SECTOR_SHIFT) / 8); i++)
|
|
|
|
crypto_xor(data + i * 8, buf, 8);
|
|
|
|
out:
|
2014-11-22 01:36:04 -07:00
|
|
|
memzero_explicit(buf, sizeof(buf));
|
2013-10-28 16:21:04 -06:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_tcw_gen(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
|
|
|
{
|
|
|
|
struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
|
|
|
|
u64 sector = cpu_to_le64((u64)dmreq->iv_sector);
|
|
|
|
u8 *src;
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
/* Remove whitening from ciphertext */
|
|
|
|
if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) {
|
|
|
|
src = kmap_atomic(sg_page(&dmreq->sg_in));
|
|
|
|
r = crypt_iv_tcw_whitening(cc, dmreq, src + dmreq->sg_in.offset);
|
|
|
|
kunmap_atomic(src);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate IV */
|
|
|
|
memcpy(iv, tcw->iv_seed, cc->iv_size);
|
|
|
|
crypto_xor(iv, (u8 *)§or, 8);
|
|
|
|
if (cc->iv_size > 8)
|
|
|
|
crypto_xor(&iv[8], (u8 *)§or, cc->iv_size - 8);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_iv_tcw_post(struct crypt_config *cc, u8 *iv,
|
|
|
|
struct dm_crypt_request *dmreq)
|
|
|
|
{
|
|
|
|
u8 *dst;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (bio_data_dir(dmreq->ctx->bio_in) != WRITE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Apply whitening on ciphertext */
|
|
|
|
dst = kmap_atomic(sg_page(&dmreq->sg_out));
|
|
|
|
r = crypt_iv_tcw_whitening(cc, dmreq, dst + dmreq->sg_out.offset);
|
|
|
|
kunmap_atomic(dst);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct crypt_iv_operations crypt_iv_plain_ops = {
|
|
|
|
.generator = crypt_iv_plain_gen
|
|
|
|
};
|
|
|
|
|
2009-12-10 16:52:25 -07:00
|
|
|
static struct crypt_iv_operations crypt_iv_plain64_ops = {
|
|
|
|
.generator = crypt_iv_plain64_gen
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct crypt_iv_operations crypt_iv_essiv_ops = {
|
|
|
|
.ctr = crypt_iv_essiv_ctr,
|
|
|
|
.dtr = crypt_iv_essiv_dtr,
|
2009-12-10 16:51:56 -07:00
|
|
|
.init = crypt_iv_essiv_init,
|
2009-12-10 16:51:57 -07:00
|
|
|
.wipe = crypt_iv_essiv_wipe,
|
2005-04-16 16:20:36 -06:00
|
|
|
.generator = crypt_iv_essiv_gen
|
|
|
|
};
|
|
|
|
|
2006-09-02 16:56:39 -06:00
|
|
|
static struct crypt_iv_operations crypt_iv_benbi_ops = {
|
|
|
|
.ctr = crypt_iv_benbi_ctr,
|
|
|
|
.dtr = crypt_iv_benbi_dtr,
|
|
|
|
.generator = crypt_iv_benbi_gen
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-09 03:32:55 -06:00
|
|
|
static struct crypt_iv_operations crypt_iv_null_ops = {
|
|
|
|
.generator = crypt_iv_null_gen
|
|
|
|
};
|
|
|
|
|
2011-01-13 12:59:55 -07:00
|
|
|
static struct crypt_iv_operations crypt_iv_lmk_ops = {
|
|
|
|
.ctr = crypt_iv_lmk_ctr,
|
|
|
|
.dtr = crypt_iv_lmk_dtr,
|
|
|
|
.init = crypt_iv_lmk_init,
|
|
|
|
.wipe = crypt_iv_lmk_wipe,
|
|
|
|
.generator = crypt_iv_lmk_gen,
|
|
|
|
.post = crypt_iv_lmk_post
|
|
|
|
};
|
|
|
|
|
2013-10-28 16:21:04 -06:00
|
|
|
static struct crypt_iv_operations crypt_iv_tcw_ops = {
|
|
|
|
.ctr = crypt_iv_tcw_ctr,
|
|
|
|
.dtr = crypt_iv_tcw_dtr,
|
|
|
|
.init = crypt_iv_tcw_init,
|
|
|
|
.wipe = crypt_iv_tcw_wipe,
|
|
|
|
.generator = crypt_iv_tcw_gen,
|
|
|
|
.post = crypt_iv_tcw_post
|
|
|
|
};
|
|
|
|
|
2007-10-19 15:42:37 -06:00
|
|
|
static void crypt_convert_init(struct crypt_config *cc,
|
|
|
|
struct convert_context *ctx,
|
|
|
|
struct bio *bio_out, struct bio *bio_in,
|
2008-02-07 19:10:41 -07:00
|
|
|
sector_t sector)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ctx->bio_in = bio_in;
|
|
|
|
ctx->bio_out = bio_out;
|
2013-10-11 16:45:43 -06:00
|
|
|
if (bio_in)
|
|
|
|
ctx->iter_in = bio_in->bi_iter;
|
|
|
|
if (bio_out)
|
|
|
|
ctx->iter_out = bio_out->bi_iter;
|
2012-07-27 08:08:05 -06:00
|
|
|
ctx->cc_sector = sector + cc->iv_offset;
|
2008-02-07 19:11:09 -07:00
|
|
|
init_completion(&ctx->restart);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-16 11:44:33 -06:00
|
|
|
static struct dm_crypt_request *dmreq_of_req(struct crypt_config *cc,
|
|
|
|
struct ablkcipher_request *req)
|
|
|
|
{
|
|
|
|
return (struct dm_crypt_request *)((char *)req + cc->dmreq_start);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ablkcipher_request *req_of_dmreq(struct crypt_config *cc,
|
|
|
|
struct dm_crypt_request *dmreq)
|
|
|
|
{
|
|
|
|
return (struct ablkcipher_request *)((char *)dmreq - cc->dmreq_start);
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
static u8 *iv_of_dmreq(struct crypt_config *cc,
|
|
|
|
struct dm_crypt_request *dmreq)
|
|
|
|
{
|
|
|
|
return (u8 *)ALIGN((unsigned long)(dmreq + 1),
|
|
|
|
crypto_ablkcipher_alignmask(any_tfm(cc)) + 1);
|
|
|
|
}
|
|
|
|
|
2008-02-07 19:11:04 -07:00
|
|
|
static int crypt_convert_block(struct crypt_config *cc,
|
2008-02-07 19:11:14 -07:00
|
|
|
struct convert_context *ctx,
|
|
|
|
struct ablkcipher_request *req)
|
2008-02-07 19:11:04 -07:00
|
|
|
{
|
2013-10-11 16:45:43 -06:00
|
|
|
struct bio_vec bv_in = bio_iter_iovec(ctx->bio_in, ctx->iter_in);
|
|
|
|
struct bio_vec bv_out = bio_iter_iovec(ctx->bio_out, ctx->iter_out);
|
2008-02-07 19:11:14 -07:00
|
|
|
struct dm_crypt_request *dmreq;
|
|
|
|
u8 *iv;
|
2012-07-27 08:08:04 -06:00
|
|
|
int r;
|
2008-02-07 19:11:14 -07:00
|
|
|
|
2009-03-16 11:44:33 -06:00
|
|
|
dmreq = dmreq_of_req(cc, req);
|
2011-01-13 12:59:54 -07:00
|
|
|
iv = iv_of_dmreq(cc, dmreq);
|
2008-02-07 19:11:04 -07:00
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
dmreq->iv_sector = ctx->cc_sector;
|
2009-03-16 11:44:33 -06:00
|
|
|
dmreq->ctx = ctx;
|
2008-02-07 19:11:14 -07:00
|
|
|
sg_init_table(&dmreq->sg_in, 1);
|
2013-10-11 16:45:43 -06:00
|
|
|
sg_set_page(&dmreq->sg_in, bv_in.bv_page, 1 << SECTOR_SHIFT,
|
|
|
|
bv_in.bv_offset);
|
2008-02-07 19:11:04 -07:00
|
|
|
|
2008-02-07 19:11:14 -07:00
|
|
|
sg_init_table(&dmreq->sg_out, 1);
|
2013-10-11 16:45:43 -06:00
|
|
|
sg_set_page(&dmreq->sg_out, bv_out.bv_page, 1 << SECTOR_SHIFT,
|
|
|
|
bv_out.bv_offset);
|
2008-02-07 19:11:04 -07:00
|
|
|
|
2013-10-11 16:45:43 -06:00
|
|
|
bio_advance_iter(ctx->bio_in, &ctx->iter_in, 1 << SECTOR_SHIFT);
|
|
|
|
bio_advance_iter(ctx->bio_out, &ctx->iter_out, 1 << SECTOR_SHIFT);
|
2008-02-07 19:11:04 -07:00
|
|
|
|
2008-02-07 19:11:14 -07:00
|
|
|
if (cc->iv_gen_ops) {
|
2011-01-13 12:59:54 -07:00
|
|
|
r = cc->iv_gen_ops->generator(cc, iv, dmreq);
|
2008-02-07 19:11:14 -07:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
ablkcipher_request_set_crypt(req, &dmreq->sg_in, &dmreq->sg_out,
|
|
|
|
1 << SECTOR_SHIFT, iv);
|
|
|
|
|
|
|
|
if (bio_data_dir(ctx->bio_in) == WRITE)
|
|
|
|
r = crypto_ablkcipher_encrypt(req);
|
|
|
|
else
|
|
|
|
r = crypto_ablkcipher_decrypt(req);
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
if (!r && cc->iv_gen_ops && cc->iv_gen_ops->post)
|
|
|
|
r = cc->iv_gen_ops->post(cc, iv, dmreq);
|
|
|
|
|
2008-02-07 19:11:14 -07:00
|
|
|
return r;
|
2008-02-07 19:11:04 -07:00
|
|
|
}
|
|
|
|
|
2008-02-07 19:11:12 -07:00
|
|
|
static void kcryptd_async_done(struct crypto_async_request *async_req,
|
|
|
|
int error);
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2008-02-07 19:11:07 -07:00
|
|
|
static void crypt_alloc_req(struct crypt_config *cc,
|
|
|
|
struct convert_context *ctx)
|
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
unsigned key_index = ctx->cc_sector & (cc->tfms_count - 1);
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2014-02-20 16:01:01 -07:00
|
|
|
if (!ctx->req)
|
|
|
|
ctx->req = mempool_alloc(cc->req_pool, GFP_NOIO);
|
2011-01-13 12:59:53 -07:00
|
|
|
|
2014-02-20 16:01:01 -07:00
|
|
|
ablkcipher_request_set_tfm(ctx->req, cc->tfms[key_index]);
|
|
|
|
ablkcipher_request_set_callback(ctx->req,
|
2011-01-13 12:59:53 -07:00
|
|
|
CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,
|
2014-02-20 16:01:01 -07:00
|
|
|
kcryptd_async_done, dmreq_of_req(cc, ctx->req));
|
2008-02-07 19:11:07 -07:00
|
|
|
}
|
|
|
|
|
2014-03-28 13:51:55 -06:00
|
|
|
static void crypt_free_req(struct crypt_config *cc,
|
|
|
|
struct ablkcipher_request *req, struct bio *base_bio)
|
|
|
|
{
|
|
|
|
struct dm_crypt_io *io = dm_per_bio_data(base_bio, cc->per_bio_data_size);
|
|
|
|
|
|
|
|
if ((struct ablkcipher_request *)(io + 1) != req)
|
|
|
|
mempool_free(req, cc->req_pool);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Encrypt / decrypt data from one bio to another one (can be the same one)
|
|
|
|
*/
|
|
|
|
static int crypt_convert(struct crypt_config *cc,
|
2007-10-19 15:42:37 -06:00
|
|
|
struct convert_context *ctx)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-28 15:16:07 -06:00
|
|
|
int r;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_set(&ctx->cc_pending, 1);
|
2008-10-10 06:37:08 -06:00
|
|
|
|
2013-10-11 16:45:43 -06:00
|
|
|
while (ctx->iter_in.bi_size && ctx->iter_out.bi_size) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-07 19:11:14 -07:00
|
|
|
crypt_alloc_req(cc, ctx);
|
|
|
|
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_inc(&ctx->cc_pending);
|
2008-03-28 15:16:07 -06:00
|
|
|
|
2014-02-20 16:01:01 -07:00
|
|
|
r = crypt_convert_block(cc, ctx, ctx->req);
|
2008-02-07 19:11:14 -07:00
|
|
|
|
|
|
|
switch (r) {
|
2008-03-28 15:16:07 -06:00
|
|
|
/* async */
|
2015-04-03 10:09:46 -06:00
|
|
|
case -EINPROGRESS:
|
2008-02-07 19:11:14 -07:00
|
|
|
case -EBUSY:
|
|
|
|
wait_for_completion(&ctx->restart);
|
2013-11-14 15:32:02 -07:00
|
|
|
reinit_completion(&ctx->restart);
|
2014-02-20 16:01:01 -07:00
|
|
|
ctx->req = NULL;
|
2012-07-27 08:08:05 -06:00
|
|
|
ctx->cc_sector++;
|
2008-03-28 15:16:07 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* sync */
|
2008-02-07 19:11:14 -07:00
|
|
|
case 0:
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_dec(&ctx->cc_pending);
|
2012-07-27 08:08:05 -06:00
|
|
|
ctx->cc_sector++;
|
2008-07-02 02:34:28 -06:00
|
|
|
cond_resched();
|
2008-02-07 19:11:14 -07:00
|
|
|
continue;
|
|
|
|
|
2008-03-28 15:16:07 -06:00
|
|
|
/* error */
|
|
|
|
default:
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_dec(&ctx->cc_pending);
|
2008-03-28 15:16:07 -06:00
|
|
|
return r;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-03-28 15:16:07 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Generate a new unfragmented bio with the given size
|
|
|
|
* This should never violate the device limitations
|
2015-02-13 06:24:41 -07:00
|
|
|
*
|
|
|
|
* This function may be called concurrently. If we allocate from the mempool
|
|
|
|
* concurrently, there is a possibility of deadlock. For example, if we have
|
|
|
|
* mempool of 256 pages, two processes, each wanting 256, pages allocate from
|
|
|
|
* the mempool concurrently, it may deadlock in a situation where both processes
|
|
|
|
* have allocated 128 pages and the mempool is exhausted.
|
|
|
|
*
|
|
|
|
* In order to avoid this scenario we allocate the pages under a mutex.
|
|
|
|
*
|
|
|
|
* In order to not degrade performance with excessive locking, we try
|
|
|
|
* non-blocking allocations without a mutex first but on failure we fallback
|
|
|
|
* to blocking allocations with a mutex.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2015-02-13 06:23:52 -07:00
|
|
|
static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2006-10-03 02:15:37 -06:00
|
|
|
struct bio *clone;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
2015-02-13 06:24:41 -07:00
|
|
|
gfp_t gfp_mask = GFP_NOWAIT | __GFP_HIGHMEM;
|
|
|
|
unsigned i, len, remaining_size;
|
2007-12-13 07:16:10 -07:00
|
|
|
struct page *page;
|
2015-02-13 06:23:52 -07:00
|
|
|
struct bio_vec *bvec;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-02-13 06:24:41 -07:00
|
|
|
retry:
|
|
|
|
if (unlikely(gfp_mask & __GFP_WAIT))
|
|
|
|
mutex_lock(&cc->bio_alloc_lock);
|
|
|
|
|
2007-05-09 03:32:53 -06:00
|
|
|
clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
|
2006-10-03 02:15:37 -06:00
|
|
|
if (!clone)
|
2015-02-13 06:24:41 -07:00
|
|
|
goto return_clone;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-09 03:32:52 -06:00
|
|
|
clone_init(io, clone);
|
2006-10-03 02:15:40 -06:00
|
|
|
|
2015-02-13 06:24:41 -07:00
|
|
|
remaining_size = size;
|
|
|
|
|
2007-05-09 03:32:54 -06:00
|
|
|
for (i = 0; i < nr_iovecs; i++) {
|
2007-12-13 07:16:10 -07:00
|
|
|
page = mempool_alloc(cc->page_pool, gfp_mask);
|
2015-02-13 06:24:41 -07:00
|
|
|
if (!page) {
|
|
|
|
crypt_free_buffer_pages(cc, clone);
|
|
|
|
bio_put(clone);
|
|
|
|
gfp_mask |= __GFP_WAIT;
|
|
|
|
goto retry;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-02-13 06:24:41 -07:00
|
|
|
len = (remaining_size > PAGE_SIZE) ? PAGE_SIZE : remaining_size;
|
2007-12-13 07:16:10 -07:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
bvec = &clone->bi_io_vec[clone->bi_vcnt++];
|
|
|
|
bvec->bv_page = page;
|
|
|
|
bvec->bv_len = len;
|
|
|
|
bvec->bv_offset = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
clone->bi_iter.bi_size += len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-02-13 06:24:41 -07:00
|
|
|
remaining_size -= len;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:24:41 -07:00
|
|
|
return_clone:
|
|
|
|
if (unlikely(gfp_mask & __GFP_WAIT))
|
|
|
|
mutex_unlock(&cc->bio_alloc_lock);
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
return clone;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-16 05:48:46 -06:00
|
|
|
static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-10-16 05:48:46 -06:00
|
|
|
unsigned int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct bio_vec *bv;
|
|
|
|
|
2012-09-05 16:22:02 -06:00
|
|
|
bio_for_each_segment_all(bv, clone, i) {
|
2005-04-16 16:20:36 -06:00
|
|
|
BUG_ON(!bv->bv_page);
|
|
|
|
mempool_free(bv->bv_page, cc->page_pool);
|
|
|
|
bv->bv_page = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-28 13:51:55 -06:00
|
|
|
static void crypt_io_init(struct dm_crypt_io *io, struct crypt_config *cc,
|
|
|
|
struct bio *bio, sector_t sector)
|
2008-10-10 06:37:03 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
io->cc = cc;
|
2008-10-10 06:37:03 -06:00
|
|
|
io->base_bio = bio;
|
|
|
|
io->sector = sector;
|
|
|
|
io->error = 0;
|
2014-02-20 16:01:01 -07:00
|
|
|
io->ctx.req = NULL;
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_set(&io->io_pending, 0);
|
2008-10-10 06:37:03 -06:00
|
|
|
}
|
|
|
|
|
2008-10-10 06:37:02 -06:00
|
|
|
static void crypt_inc_pending(struct dm_crypt_io *io)
|
|
|
|
{
|
2012-07-27 08:08:04 -06:00
|
|
|
atomic_inc(&io->io_pending);
|
2008-10-10 06:37:02 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* One of the bios was finished. Check for completion of
|
|
|
|
* the whole request and correctly clean up the buffer.
|
|
|
|
*/
|
2008-02-07 19:10:43 -07:00
|
|
|
static void crypt_dec_pending(struct dm_crypt_io *io)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2009-03-16 11:44:36 -06:00
|
|
|
struct bio *base_bio = io->base_bio;
|
|
|
|
int error = io->error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-27 08:08:04 -06:00
|
|
|
if (!atomic_dec_and_test(&io->io_pending))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
2014-02-20 16:01:01 -07:00
|
|
|
if (io->ctx.req)
|
2014-03-28 13:51:55 -06:00
|
|
|
crypt_free_req(cc, io->ctx.req, base_bio);
|
2009-03-16 11:44:36 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
bio_endio(base_bio, error);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-10-19 15:38:58 -06:00
|
|
|
* kcryptd/kcryptd_io:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Needed because it would be very unwise to do decryption in an
|
2006-10-03 02:15:39 -06:00
|
|
|
* interrupt context.
|
2007-10-19 15:38:58 -06:00
|
|
|
*
|
|
|
|
* kcryptd performs the actual encryption or decryption.
|
|
|
|
*
|
|
|
|
* kcryptd_io performs the IO submission.
|
|
|
|
*
|
|
|
|
* They must be separated as otherwise the final stages could be
|
|
|
|
* starved by new requests which can block in the first stages due
|
|
|
|
* to memory allocation.
|
2011-01-13 12:59:53 -07:00
|
|
|
*
|
|
|
|
* The work is done per CPU global for all dm-crypt instances.
|
|
|
|
* They should not depend on each other and do not block.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-09-27 04:47:43 -06:00
|
|
|
static void crypt_endio(struct bio *clone, int error)
|
2006-10-03 02:15:37 -06:00
|
|
|
{
|
2007-07-12 10:26:32 -06:00
|
|
|
struct dm_crypt_io *io = clone->bi_private;
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2008-02-07 19:10:46 -07:00
|
|
|
unsigned rw = bio_data_dir(clone);
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2007-12-13 07:15:51 -07:00
|
|
|
if (unlikely(!bio_flagged(clone, BIO_UPTODATE) && !error))
|
|
|
|
error = -EIO;
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
/*
|
2007-09-27 04:47:43 -06:00
|
|
|
* free the processed pages
|
2006-10-03 02:15:37 -06:00
|
|
|
*/
|
2008-02-07 19:10:46 -07:00
|
|
|
if (rw == WRITE)
|
2007-10-16 05:48:46 -06:00
|
|
|
crypt_free_buffer_pages(cc, clone);
|
2006-10-03 02:15:37 -06:00
|
|
|
|
|
|
|
bio_put(clone);
|
|
|
|
|
2008-02-07 19:10:46 -07:00
|
|
|
if (rw == READ && !error) {
|
|
|
|
kcryptd_queue_crypt(io);
|
|
|
|
return;
|
|
|
|
}
|
2008-02-07 19:10:43 -07:00
|
|
|
|
|
|
|
if (unlikely(error))
|
|
|
|
io->error = error;
|
|
|
|
|
|
|
|
crypt_dec_pending(io);
|
2006-10-03 02:15:37 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 10:26:32 -06:00
|
|
|
static void clone_init(struct dm_crypt_io *io, struct bio *clone)
|
2006-10-03 02:15:37 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
|
|
|
clone->bi_private = io;
|
|
|
|
clone->bi_end_io = crypt_endio;
|
|
|
|
clone->bi_bdev = cc->dev->bdev;
|
|
|
|
clone->bi_rw = io->base_bio->bi_rw;
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:53 -07:00
|
|
|
static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
|
2006-10-03 02:15:37 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2006-10-03 02:15:37 -06:00
|
|
|
struct bio *clone;
|
2006-10-03 02:15:38 -06:00
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
/*
|
2015-04-09 14:53:24 -06:00
|
|
|
* We need the original biovec array in order to decrypt
|
|
|
|
* the whole bio data *afterwards* -- thanks to immutable
|
|
|
|
* biovecs we don't need to worry about the block layer
|
|
|
|
* modifying the biovec array; so leverage bio_clone_fast().
|
2006-10-03 02:15:37 -06:00
|
|
|
*/
|
2015-04-09 14:53:24 -06:00
|
|
|
clone = bio_clone_fast(io->base_bio, gfp, cc->bs);
|
2011-03-10 00:52:07 -07:00
|
|
|
if (!clone)
|
2011-01-13 12:59:53 -07:00
|
|
|
return 1;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2011-01-13 12:59:53 -07:00
|
|
|
crypt_inc_pending(io);
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
clone_init(io, clone);
|
2013-10-11 16:44:27 -06:00
|
|
|
clone->bi_iter.bi_sector = cc->start + io->sector;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2006-10-03 02:15:38 -06:00
|
|
|
generic_make_request(clone);
|
2011-01-13 12:59:53 -07:00
|
|
|
return 0;
|
2006-10-03 02:15:37 -06:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
static void kcryptd_io_read_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
|
|
|
|
|
|
|
|
crypt_inc_pending(io);
|
|
|
|
if (kcryptd_io_read(io, GFP_NOIO))
|
|
|
|
io->error = -ENOMEM;
|
|
|
|
crypt_dec_pending(io);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void kcryptd_queue_read(struct dm_crypt_io *io)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = io->cc;
|
|
|
|
|
|
|
|
INIT_WORK(&io->work, kcryptd_io_read_work);
|
|
|
|
queue_work(cc->io_queue, &io->work);
|
|
|
|
}
|
|
|
|
|
2008-02-07 19:10:49 -07:00
|
|
|
static void kcryptd_io_write(struct dm_crypt_io *io)
|
|
|
|
{
|
2008-02-07 19:11:12 -07:00
|
|
|
struct bio *clone = io->ctx.bio_out;
|
2015-02-13 06:25:59 -07:00
|
|
|
|
2008-02-07 19:11:12 -07:00
|
|
|
generic_make_request(clone);
|
2008-02-07 19:10:49 -07:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:27:41 -07:00
|
|
|
#define crypt_io_from_node(node) rb_entry((node), struct dm_crypt_io, rb_node)
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
static int dmcrypt_write(void *data)
|
2008-02-07 19:10:52 -07:00
|
|
|
{
|
2015-02-13 06:25:59 -07:00
|
|
|
struct crypt_config *cc = data;
|
2015-02-13 06:27:41 -07:00
|
|
|
struct dm_crypt_io *io;
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
while (1) {
|
2015-02-13 06:27:41 -07:00
|
|
|
struct rb_root write_tree;
|
2015-02-13 06:25:59 -07:00
|
|
|
struct blk_plug plug;
|
2008-02-07 19:10:52 -07:00
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
2008-02-07 19:10:52 -07:00
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
spin_lock_irq(&cc->write_thread_wait.lock);
|
|
|
|
continue_locked:
|
2008-02-07 19:10:52 -07:00
|
|
|
|
2015-02-13 06:27:41 -07:00
|
|
|
if (!RB_EMPTY_ROOT(&cc->write_tree))
|
2015-02-13 06:25:59 -07:00
|
|
|
goto pop_from_list;
|
|
|
|
|
|
|
|
__set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
__add_wait_queue(&cc->write_thread_wait, &wait);
|
|
|
|
|
|
|
|
spin_unlock_irq(&cc->write_thread_wait.lock);
|
|
|
|
|
|
|
|
if (unlikely(kthread_should_stop())) {
|
|
|
|
set_task_state(current, TASK_RUNNING);
|
|
|
|
remove_wait_queue(&cc->write_thread_wait, &wait);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
set_task_state(current, TASK_RUNNING);
|
|
|
|
spin_lock_irq(&cc->write_thread_wait.lock);
|
|
|
|
__remove_wait_queue(&cc->write_thread_wait, &wait);
|
|
|
|
goto continue_locked;
|
|
|
|
|
|
|
|
pop_from_list:
|
2015-02-13 06:27:41 -07:00
|
|
|
write_tree = cc->write_tree;
|
|
|
|
cc->write_tree = RB_ROOT;
|
2015-02-13 06:25:59 -07:00
|
|
|
spin_unlock_irq(&cc->write_thread_wait.lock);
|
|
|
|
|
2015-02-13 06:27:41 -07:00
|
|
|
BUG_ON(rb_parent(write_tree.rb_node));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: we cannot walk the tree here with rb_next because
|
|
|
|
* the structures may be freed when kcryptd_io_write is called.
|
|
|
|
*/
|
2015-02-13 06:25:59 -07:00
|
|
|
blk_start_plug(&plug);
|
|
|
|
do {
|
2015-02-13 06:27:41 -07:00
|
|
|
io = crypt_io_from_node(rb_first(&write_tree));
|
|
|
|
rb_erase(&io->rb_node, &write_tree);
|
2015-02-13 06:25:59 -07:00
|
|
|
kcryptd_io_write(io);
|
2015-02-13 06:27:41 -07:00
|
|
|
} while (!RB_EMPTY_ROOT(&write_tree));
|
2015-02-13 06:25:59 -07:00
|
|
|
blk_finish_plug(&plug);
|
|
|
|
}
|
|
|
|
return 0;
|
2008-02-07 19:10:52 -07:00
|
|
|
}
|
|
|
|
|
2012-03-28 11:41:22 -06:00
|
|
|
static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async)
|
2008-02-07 19:10:49 -07:00
|
|
|
{
|
2008-02-07 19:10:57 -07:00
|
|
|
struct bio *clone = io->ctx.bio_out;
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2015-02-13 06:25:59 -07:00
|
|
|
unsigned long flags;
|
2015-02-13 06:27:41 -07:00
|
|
|
sector_t sector;
|
|
|
|
struct rb_node **rbp, *parent;
|
2008-02-07 19:10:57 -07:00
|
|
|
|
2012-03-28 11:41:22 -06:00
|
|
|
if (unlikely(io->error < 0)) {
|
2008-02-07 19:10:57 -07:00
|
|
|
crypt_free_buffer_pages(cc, clone);
|
|
|
|
bio_put(clone);
|
2008-10-10 06:37:06 -06:00
|
|
|
crypt_dec_pending(io);
|
2008-02-07 19:10:57 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* crypt_convert should have filled the clone bio */
|
2013-10-11 16:45:43 -06:00
|
|
|
BUG_ON(io->ctx.iter_out.bi_size);
|
2008-02-07 19:10:57 -07:00
|
|
|
|
2013-10-11 16:44:27 -06:00
|
|
|
clone->bi_iter.bi_sector = cc->start + io->sector;
|
2008-02-07 19:11:02 -07:00
|
|
|
|
2015-02-13 06:27:08 -07:00
|
|
|
if (likely(!async) && test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags)) {
|
|
|
|
generic_make_request(clone);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
spin_lock_irqsave(&cc->write_thread_wait.lock, flags);
|
2015-02-13 06:27:41 -07:00
|
|
|
rbp = &cc->write_tree.rb_node;
|
|
|
|
parent = NULL;
|
|
|
|
sector = io->sector;
|
|
|
|
while (*rbp) {
|
|
|
|
parent = *rbp;
|
|
|
|
if (sector < crypt_io_from_node(parent)->sector)
|
|
|
|
rbp = &(*rbp)->rb_left;
|
|
|
|
else
|
|
|
|
rbp = &(*rbp)->rb_right;
|
|
|
|
}
|
|
|
|
rb_link_node(&io->rb_node, parent, rbp);
|
|
|
|
rb_insert_color(&io->rb_node, &cc->write_tree);
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
wake_up_locked(&cc->write_thread_wait);
|
|
|
|
spin_unlock_irqrestore(&cc->write_thread_wait.lock, flags);
|
2008-02-07 19:10:49 -07:00
|
|
|
}
|
|
|
|
|
2008-10-10 06:37:04 -06:00
|
|
|
static void kcryptd_crypt_write_convert(struct dm_crypt_io *io)
|
2006-10-03 02:15:37 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2006-10-03 02:15:37 -06:00
|
|
|
struct bio *clone;
|
2008-10-10 06:37:08 -06:00
|
|
|
int crypt_finished;
|
2008-10-21 10:45:00 -06:00
|
|
|
sector_t sector = io->sector;
|
2008-02-07 19:10:57 -07:00
|
|
|
int r;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2008-10-10 06:37:04 -06:00
|
|
|
/*
|
|
|
|
* Prevent io from disappearing until this function completes.
|
|
|
|
*/
|
|
|
|
crypt_inc_pending(io);
|
2008-10-21 10:45:00 -06:00
|
|
|
crypt_convert_init(cc, &io->ctx, NULL, io->base_bio, sector);
|
2008-10-10 06:37:04 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size);
|
|
|
|
if (unlikely(!clone)) {
|
|
|
|
io->error = -EIO;
|
|
|
|
goto dec;
|
|
|
|
}
|
2008-10-10 06:37:08 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
io->ctx.bio_out = clone;
|
|
|
|
io->ctx.iter_out = clone->bi_iter;
|
2008-10-21 10:45:00 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
sector += bio_sectors(clone);
|
2006-10-03 02:15:38 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
crypt_inc_pending(io);
|
|
|
|
r = crypt_convert(cc, &io->ctx);
|
|
|
|
if (r)
|
|
|
|
io->error = -EIO;
|
|
|
|
crypt_finished = atomic_dec_and_test(&io->ctx.cc_pending);
|
2008-10-10 06:37:08 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
/* Encryption was already finished, submit io now */
|
|
|
|
if (crypt_finished) {
|
|
|
|
kcryptd_crypt_write_io_submit(io, 0);
|
|
|
|
io->sector = sector;
|
2006-10-03 02:15:38 -06:00
|
|
|
}
|
2008-02-07 19:11:02 -07:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
dec:
|
2008-02-07 19:11:02 -07:00
|
|
|
crypt_dec_pending(io);
|
2008-02-07 19:10:59 -07:00
|
|
|
}
|
|
|
|
|
2012-03-28 11:41:22 -06:00
|
|
|
static void kcryptd_crypt_read_done(struct dm_crypt_io *io)
|
2008-02-07 19:10:43 -07:00
|
|
|
{
|
|
|
|
crypt_dec_pending(io);
|
|
|
|
}
|
|
|
|
|
2008-02-07 19:10:49 -07:00
|
|
|
static void kcryptd_crypt_read_convert(struct dm_crypt_io *io)
|
2006-10-03 02:15:37 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2008-02-07 19:10:43 -07:00
|
|
|
int r = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-10 06:37:02 -06:00
|
|
|
crypt_inc_pending(io);
|
2008-02-07 19:11:14 -07:00
|
|
|
|
2008-02-07 19:10:38 -07:00
|
|
|
crypt_convert_init(cc, &io->ctx, io->base_bio, io->base_bio,
|
2008-02-07 19:10:54 -07:00
|
|
|
io->sector);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-07 19:10:43 -07:00
|
|
|
r = crypt_convert(cc, &io->ctx);
|
2012-03-28 11:41:22 -06:00
|
|
|
if (r < 0)
|
|
|
|
io->error = -EIO;
|
2008-02-07 19:10:43 -07:00
|
|
|
|
2012-07-27 08:08:04 -06:00
|
|
|
if (atomic_dec_and_test(&io->ctx.cc_pending))
|
2012-03-28 11:41:22 -06:00
|
|
|
kcryptd_crypt_read_done(io);
|
2008-02-07 19:11:14 -07:00
|
|
|
|
|
|
|
crypt_dec_pending(io);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-07 19:11:12 -07:00
|
|
|
static void kcryptd_async_done(struct crypto_async_request *async_req,
|
|
|
|
int error)
|
|
|
|
{
|
2009-03-16 11:44:33 -06:00
|
|
|
struct dm_crypt_request *dmreq = async_req->data;
|
|
|
|
struct convert_context *ctx = dmreq->ctx;
|
2008-02-07 19:11:12 -07:00
|
|
|
struct dm_crypt_io *io = container_of(ctx, struct dm_crypt_io, ctx);
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2008-02-07 19:11:12 -07:00
|
|
|
|
2015-04-03 10:09:46 -06:00
|
|
|
if (error == -EINPROGRESS)
|
2008-02-07 19:11:12 -07:00
|
|
|
return;
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
if (!error && cc->iv_gen_ops && cc->iv_gen_ops->post)
|
|
|
|
error = cc->iv_gen_ops->post(cc, iv_of_dmreq(cc, dmreq), dmreq);
|
|
|
|
|
2012-03-28 11:41:22 -06:00
|
|
|
if (error < 0)
|
|
|
|
io->error = -EIO;
|
|
|
|
|
2014-03-28 13:51:55 -06:00
|
|
|
crypt_free_req(cc, req_of_dmreq(cc, dmreq), io->base_bio);
|
2008-02-07 19:11:12 -07:00
|
|
|
|
2012-07-27 08:08:04 -06:00
|
|
|
if (!atomic_dec_and_test(&ctx->cc_pending))
|
2015-04-03 10:09:46 -06:00
|
|
|
goto done;
|
2008-02-07 19:11:12 -07:00
|
|
|
|
|
|
|
if (bio_data_dir(io->base_bio) == READ)
|
2012-03-28 11:41:22 -06:00
|
|
|
kcryptd_crypt_read_done(io);
|
2008-02-07 19:11:12 -07:00
|
|
|
else
|
2012-03-28 11:41:22 -06:00
|
|
|
kcryptd_crypt_write_io_submit(io, 1);
|
2015-04-03 10:09:46 -06:00
|
|
|
done:
|
|
|
|
if (!completion_done(&ctx->restart))
|
|
|
|
complete(&ctx->restart);
|
2008-02-07 19:11:12 -07:00
|
|
|
}
|
|
|
|
|
2008-02-07 19:10:52 -07:00
|
|
|
static void kcryptd_crypt(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-12 10:26:32 -06:00
|
|
|
struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2007-10-19 15:38:58 -06:00
|
|
|
if (bio_data_dir(io->base_bio) == READ)
|
2008-02-07 19:10:52 -07:00
|
|
|
kcryptd_crypt_read_convert(io);
|
2008-02-07 19:10:49 -07:00
|
|
|
else
|
2008-02-07 19:10:52 -07:00
|
|
|
kcryptd_crypt_write_convert(io);
|
2007-10-19 15:38:58 -06:00
|
|
|
}
|
|
|
|
|
2008-02-07 19:10:52 -07:00
|
|
|
static void kcryptd_queue_crypt(struct dm_crypt_io *io)
|
2007-10-19 15:38:58 -06:00
|
|
|
{
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = io->cc;
|
2007-10-19 15:38:58 -06:00
|
|
|
|
2008-02-07 19:10:52 -07:00
|
|
|
INIT_WORK(&io->work, kcryptd_crypt);
|
|
|
|
queue_work(cc->crypt_queue, &io->work);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode key from its hex representation
|
|
|
|
*/
|
|
|
|
static int crypt_decode_key(u8 *key, char *hex, unsigned int size)
|
|
|
|
{
|
|
|
|
char buffer[3];
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
buffer[2] = '\0';
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
for (i = 0; i < size; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
buffer[0] = *hex++;
|
|
|
|
buffer[1] = *hex++;
|
|
|
|
|
2012-07-27 08:07:59 -06:00
|
|
|
if (kstrtou8(buffer, 16, &key[i]))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*hex != '\0')
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
static void crypt_free_tfms(struct crypt_config *cc)
|
2011-01-13 12:59:54 -07:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
if (!cc->tfms)
|
|
|
|
return;
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
for (i = 0; i < cc->tfms_count; i++)
|
2012-07-27 08:08:05 -06:00
|
|
|
if (cc->tfms[i] && !IS_ERR(cc->tfms[i])) {
|
|
|
|
crypto_free_ablkcipher(cc->tfms[i]);
|
|
|
|
cc->tfms[i] = NULL;
|
2011-01-13 12:59:54 -07:00
|
|
|
}
|
2012-07-27 08:08:05 -06:00
|
|
|
|
|
|
|
kfree(cc->tfms);
|
|
|
|
cc->tfms = NULL;
|
2011-01-13 12:59:54 -07:00
|
|
|
}
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
static int crypt_alloc_tfms(struct crypt_config *cc, char *ciphermode)
|
2011-01-13 12:59:54 -07:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
int err;
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
cc->tfms = kmalloc(cc->tfms_count * sizeof(struct crypto_ablkcipher *),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!cc->tfms)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-01-13 12:59:54 -07:00
|
|
|
for (i = 0; i < cc->tfms_count; i++) {
|
2012-07-27 08:08:05 -06:00
|
|
|
cc->tfms[i] = crypto_alloc_ablkcipher(ciphermode, 0, 0);
|
|
|
|
if (IS_ERR(cc->tfms[i])) {
|
|
|
|
err = PTR_ERR(cc->tfms[i]);
|
|
|
|
crypt_free_tfms(cc);
|
2011-01-13 12:59:54 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:53 -07:00
|
|
|
static int crypt_setkey_allcpus(struct crypt_config *cc)
|
|
|
|
{
|
2013-10-28 16:21:03 -06:00
|
|
|
unsigned subkey_size;
|
2012-07-27 08:08:05 -06:00
|
|
|
int err = 0, i, r;
|
|
|
|
|
2013-10-28 16:21:03 -06:00
|
|
|
/* Ignore extra keys (which are used for IV etc) */
|
|
|
|
subkey_size = (cc->key_size - cc->key_extra_size) >> ilog2(cc->tfms_count);
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
for (i = 0; i < cc->tfms_count; i++) {
|
|
|
|
r = crypto_ablkcipher_setkey(cc->tfms[i],
|
|
|
|
cc->key + (i * subkey_size),
|
|
|
|
subkey_size);
|
|
|
|
if (r)
|
|
|
|
err = r;
|
2011-01-13 12:59:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
static int crypt_set_key(struct crypt_config *cc, char *key)
|
|
|
|
{
|
2011-03-24 07:54:27 -06:00
|
|
|
int r = -EINVAL;
|
|
|
|
int key_string_len = strlen(key);
|
|
|
|
|
2011-01-13 12:59:49 -07:00
|
|
|
/* The key size may not be changed. */
|
2011-03-24 07:54:27 -06:00
|
|
|
if (cc->key_size != (key_string_len >> 1))
|
|
|
|
goto out;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2011-01-13 12:59:49 -07:00
|
|
|
/* Hyphen (which gives a key_size of zero) means there is no key. */
|
|
|
|
if (!cc->key_size && strcmp(key, "-"))
|
2011-03-24 07:54:27 -06:00
|
|
|
goto out;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
2011-01-13 12:59:49 -07:00
|
|
|
if (cc->key_size && crypt_decode_key(cc->key, key, cc->key_size) < 0)
|
2011-03-24 07:54:27 -06:00
|
|
|
goto out;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
|
|
|
set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
|
|
|
|
|
2011-03-24 07:54:27 -06:00
|
|
|
r = crypt_setkey_allcpus(cc);
|
|
|
|
|
|
|
|
out:
|
|
|
|
/* Hex key string not needed after here, so wipe it. */
|
|
|
|
memset(key, '0', key_string_len);
|
|
|
|
|
|
|
|
return r;
|
2006-10-03 02:15:37 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_wipe_key(struct crypt_config *cc)
|
|
|
|
{
|
|
|
|
clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
|
|
|
|
memset(&cc->key, 0, cc->key_size * sizeof(u8));
|
2011-01-13 12:59:53 -07:00
|
|
|
|
|
|
|
return crypt_setkey_allcpus(cc);
|
2006-10-03 02:15:37 -06:00
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
static void crypt_dtr(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
|
|
|
|
|
|
|
ti->private = NULL;
|
|
|
|
|
|
|
|
if (!cc)
|
|
|
|
return;
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
if (cc->write_thread)
|
|
|
|
kthread_stop(cc->write_thread);
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
if (cc->io_queue)
|
|
|
|
destroy_workqueue(cc->io_queue);
|
|
|
|
if (cc->crypt_queue)
|
|
|
|
destroy_workqueue(cc->crypt_queue);
|
|
|
|
|
2012-07-27 08:08:05 -06:00
|
|
|
crypt_free_tfms(cc);
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
if (cc->bs)
|
|
|
|
bioset_free(cc->bs);
|
|
|
|
|
|
|
|
if (cc->page_pool)
|
|
|
|
mempool_destroy(cc->page_pool);
|
|
|
|
if (cc->req_pool)
|
|
|
|
mempool_destroy(cc->req_pool);
|
|
|
|
|
|
|
|
if (cc->iv_gen_ops && cc->iv_gen_ops->dtr)
|
|
|
|
cc->iv_gen_ops->dtr(cc);
|
|
|
|
|
|
|
|
if (cc->dev)
|
|
|
|
dm_put_device(ti, cc->dev);
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
kzfree(cc->cipher);
|
2011-01-13 12:59:52 -07:00
|
|
|
kzfree(cc->cipher_string);
|
2010-08-11 21:14:06 -06:00
|
|
|
|
|
|
|
/* Must zero key material before freeing */
|
|
|
|
kzfree(cc);
|
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
static int crypt_ctr_cipher(struct dm_target *ti,
|
|
|
|
char *cipher_in, char *key)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-08-11 21:14:07 -06:00
|
|
|
struct crypt_config *cc = ti->private;
|
2011-01-13 12:59:54 -07:00
|
|
|
char *tmp, *cipher, *chainmode, *ivmode, *ivopts, *keycount;
|
2010-08-11 21:14:07 -06:00
|
|
|
char *cipher_api = NULL;
|
2012-07-27 08:08:05 -06:00
|
|
|
int ret = -EINVAL;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 11:41:26 -06:00
|
|
|
char dummy;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
/* Convert to crypto api definition? */
|
|
|
|
if (strchr(cipher_in, '(')) {
|
|
|
|
ti->error = "Bad cipher specification";
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-01-13 12:59:52 -07:00
|
|
|
cc->cipher_string = kstrdup(cipher_in, GFP_KERNEL);
|
|
|
|
if (!cc->cipher_string)
|
|
|
|
goto bad_mem;
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
/*
|
|
|
|
* Legacy dm-crypt cipher specification
|
2011-01-13 12:59:54 -07:00
|
|
|
* cipher[:keycount]-mode-iv:ivopts
|
2010-08-11 21:14:07 -06:00
|
|
|
*/
|
|
|
|
tmp = cipher_in;
|
2011-01-13 12:59:54 -07:00
|
|
|
keycount = strsep(&tmp, "-");
|
|
|
|
cipher = strsep(&keycount, ":");
|
|
|
|
|
|
|
|
if (!keycount)
|
|
|
|
cc->tfms_count = 1;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 11:41:26 -06:00
|
|
|
else if (sscanf(keycount, "%u%c", &cc->tfms_count, &dummy) != 1 ||
|
2011-01-13 12:59:54 -07:00
|
|
|
!is_power_of_2(cc->tfms_count)) {
|
|
|
|
ti->error = "Bad cipher key count specification";
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
cc->key_parts = cc->tfms_count;
|
2013-10-28 16:21:03 -06:00
|
|
|
cc->key_extra_size = 0;
|
2010-08-11 21:14:07 -06:00
|
|
|
|
|
|
|
cc->cipher = kstrdup(cipher, GFP_KERNEL);
|
|
|
|
if (!cc->cipher)
|
|
|
|
goto bad_mem;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
chainmode = strsep(&tmp, "-");
|
|
|
|
ivopts = strsep(&tmp, "-");
|
|
|
|
ivmode = strsep(&ivopts, ":");
|
|
|
|
|
|
|
|
if (tmp)
|
2010-08-11 21:14:07 -06:00
|
|
|
DMWARN("Ignoring unexpected additional cipher options");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-13 12:59:52 -07:00
|
|
|
/*
|
|
|
|
* For compatibility with the original dm-crypt mapping format, if
|
|
|
|
* only the cipher name is supplied, use cbc-plain.
|
|
|
|
*/
|
2010-08-11 21:14:07 -06:00
|
|
|
if (!chainmode || (!strcmp(chainmode, "plain") && !ivmode)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
chainmode = "cbc";
|
|
|
|
ivmode = "plain";
|
|
|
|
}
|
|
|
|
|
2006-08-22 04:29:17 -06:00
|
|
|
if (strcmp(chainmode, "ecb") && !ivmode) {
|
2010-08-11 21:14:07 -06:00
|
|
|
ti->error = "IV mechanism required";
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
cipher_api = kmalloc(CRYPTO_MAX_ALG_NAME, GFP_KERNEL);
|
|
|
|
if (!cipher_api)
|
|
|
|
goto bad_mem;
|
|
|
|
|
|
|
|
ret = snprintf(cipher_api, CRYPTO_MAX_ALG_NAME,
|
|
|
|
"%s(%s)", chainmode, cipher);
|
|
|
|
if (ret < 0) {
|
|
|
|
kfree(cipher_api);
|
|
|
|
goto bad_mem;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
/* Allocate cipher */
|
2012-07-27 08:08:05 -06:00
|
|
|
ret = crypt_alloc_tfms(cc, cipher_api);
|
|
|
|
if (ret < 0) {
|
|
|
|
ti->error = "Error allocating crypto tfm";
|
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
/* Initialize IV */
|
2011-01-13 12:59:53 -07:00
|
|
|
cc->iv_size = crypto_ablkcipher_ivsize(any_tfm(cc));
|
2010-08-11 21:14:07 -06:00
|
|
|
if (cc->iv_size)
|
|
|
|
/* at least a 64 bit sector number should fit in our buffer */
|
|
|
|
cc->iv_size = max(cc->iv_size,
|
|
|
|
(unsigned int)(sizeof(u64) / sizeof(u8)));
|
|
|
|
else if (ivmode) {
|
|
|
|
DMWARN("Selected cipher does not support IVs");
|
|
|
|
ivmode = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Choose ivmode, see comments at iv code. */
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ivmode == NULL)
|
|
|
|
cc->iv_gen_ops = NULL;
|
|
|
|
else if (strcmp(ivmode, "plain") == 0)
|
|
|
|
cc->iv_gen_ops = &crypt_iv_plain_ops;
|
2009-12-10 16:52:25 -07:00
|
|
|
else if (strcmp(ivmode, "plain64") == 0)
|
|
|
|
cc->iv_gen_ops = &crypt_iv_plain64_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
else if (strcmp(ivmode, "essiv") == 0)
|
|
|
|
cc->iv_gen_ops = &crypt_iv_essiv_ops;
|
2006-09-02 16:56:39 -06:00
|
|
|
else if (strcmp(ivmode, "benbi") == 0)
|
|
|
|
cc->iv_gen_ops = &crypt_iv_benbi_ops;
|
2007-05-09 03:32:55 -06:00
|
|
|
else if (strcmp(ivmode, "null") == 0)
|
|
|
|
cc->iv_gen_ops = &crypt_iv_null_ops;
|
2011-01-13 12:59:55 -07:00
|
|
|
else if (strcmp(ivmode, "lmk") == 0) {
|
|
|
|
cc->iv_gen_ops = &crypt_iv_lmk_ops;
|
2013-10-28 16:21:04 -06:00
|
|
|
/*
|
|
|
|
* Version 2 and 3 is recognised according
|
2011-01-13 12:59:55 -07:00
|
|
|
* to length of provided multi-key string.
|
|
|
|
* If present (version 3), last key is used as IV seed.
|
2013-10-28 16:21:04 -06:00
|
|
|
* All keys (including IV seed) are always the same size.
|
2011-01-13 12:59:55 -07:00
|
|
|
*/
|
2013-10-28 16:21:03 -06:00
|
|
|
if (cc->key_size % cc->key_parts) {
|
2011-01-13 12:59:55 -07:00
|
|
|
cc->key_parts++;
|
2013-10-28 16:21:03 -06:00
|
|
|
cc->key_extra_size = cc->key_size / cc->key_parts;
|
|
|
|
}
|
2013-10-28 16:21:04 -06:00
|
|
|
} else if (strcmp(ivmode, "tcw") == 0) {
|
|
|
|
cc->iv_gen_ops = &crypt_iv_tcw_ops;
|
|
|
|
cc->key_parts += 2; /* IV + whitening */
|
|
|
|
cc->key_extra_size = cc->iv_size + TCW_WHITENING_SIZE;
|
2011-01-13 12:59:55 -07:00
|
|
|
} else {
|
2010-08-11 21:14:07 -06:00
|
|
|
ret = -EINVAL;
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Invalid IV mode";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-10-28 16:21:03 -06:00
|
|
|
/* Initialize and set key */
|
|
|
|
ret = crypt_set_key(cc, key);
|
|
|
|
if (ret < 0) {
|
|
|
|
ti->error = "Error decoding and setting key";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
/* Allocate IV */
|
|
|
|
if (cc->iv_gen_ops && cc->iv_gen_ops->ctr) {
|
|
|
|
ret = cc->iv_gen_ops->ctr(cc, ti, ivopts);
|
|
|
|
if (ret < 0) {
|
|
|
|
ti->error = "Error creating IV";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
/* Initialize IV (set keys for ESSIV etc) */
|
|
|
|
if (cc->iv_gen_ops && cc->iv_gen_ops->init) {
|
|
|
|
ret = cc->iv_gen_ops->init(cc);
|
|
|
|
if (ret < 0) {
|
|
|
|
ti->error = "Error initialising IV";
|
|
|
|
goto bad;
|
|
|
|
}
|
2009-12-10 16:51:56 -07:00
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
ret = 0;
|
|
|
|
bad:
|
|
|
|
kfree(cipher_api);
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
bad_mem:
|
|
|
|
ti->error = "Cannot allocate cipher strings";
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct an encryption mapping:
|
|
|
|
* <cipher> <key> <iv_offset> <dev_path> <start>
|
|
|
|
*/
|
|
|
|
static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc;
|
2011-08-02 05:32:08 -06:00
|
|
|
unsigned int key_size, opt_params;
|
2010-08-11 21:14:07 -06:00
|
|
|
unsigned long long tmpll;
|
|
|
|
int ret;
|
dm crypt: fix access beyond the end of allocated space
The DM crypt target accesses memory beyond allocated space resulting in
a crash on 32 bit x86 systems.
This bug is very old (it dates back to 2.6.25 commit 3a7f6c990ad04 "dm
crypt: use async crypto"). However, this bug was masked by the fact
that kmalloc rounds the size up to the next power of two. This bug
wasn't exposed until 3.17-rc1 commit 298a9fa08a ("dm crypt: use per-bio
data"). By switching to using per-bio data there was no longer any
padding beyond the end of a dm-crypt allocated memory block.
To minimize allocation overhead dm-crypt puts several structures into one
block allocated with kmalloc. The block holds struct ablkcipher_request,
cipher-specific scratch pad (crypto_ablkcipher_reqsize(any_tfm(cc))),
struct dm_crypt_request and an initialization vector.
The variable dmreq_start is set to offset of struct dm_crypt_request
within this memory block. dm-crypt allocates the block with this size:
cc->dmreq_start + sizeof(struct dm_crypt_request) + cc->iv_size.
When accessing the initialization vector, dm-crypt uses the function
iv_of_dmreq, which performs this calculation: ALIGN((unsigned long)(dmreq
+ 1), crypto_ablkcipher_alignmask(any_tfm(cc)) + 1).
dm-crypt allocated "cc->iv_size" bytes beyond the end of dm_crypt_request
structure. However, when dm-crypt accesses the initialization vector, it
takes a pointer to the end of dm_crypt_request, aligns it, and then uses
it as the initialization vector. If the end of dm_crypt_request is not
aligned on a crypto_ablkcipher_alignmask(any_tfm(cc)) boundary the
alignment causes the initialization vector to point beyond the allocated
space.
Fix this bug by calculating the variable iv_size_padding and adding it
to the allocated size.
Also correct the alignment of dm_crypt_request. struct dm_crypt_request
is specific to dm-crypt (it isn't used by the crypto subsystem at all),
so it is aligned on __alignof__(struct dm_crypt_request).
Also align per_bio_data_size on ARCH_KMALLOC_MINALIGN, so that it is
aligned as if the block was allocated with kmalloc.
Reported-by: Krzysztof Kolasa <kkolasa@winsoft.pl>
Tested-by: Milan Broz <gmazyland@gmail.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
2014-08-28 09:09:31 -06:00
|
|
|
size_t iv_size_padding;
|
2011-08-02 05:32:08 -06:00
|
|
|
struct dm_arg_set as;
|
|
|
|
const char *opt_string;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 11:41:26 -06:00
|
|
|
char dummy;
|
2011-08-02 05:32:08 -06:00
|
|
|
|
|
|
|
static struct dm_arg _args[] = {
|
2015-02-13 06:27:08 -07:00
|
|
|
{0, 3, "Invalid number of feature args"},
|
2011-08-02 05:32:08 -06:00
|
|
|
};
|
2010-08-11 21:14:07 -06:00
|
|
|
|
2011-08-02 05:32:08 -06:00
|
|
|
if (argc < 5) {
|
2010-08-11 21:14:07 -06:00
|
|
|
ti->error = "Not enough arguments";
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:07 -06:00
|
|
|
key_size = strlen(argv[1]) >> 1;
|
|
|
|
|
|
|
|
cc = kzalloc(sizeof(*cc) + key_size * sizeof(u8), GFP_KERNEL);
|
|
|
|
if (!cc) {
|
|
|
|
ti->error = "Cannot allocate encryption context";
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2011-01-13 12:59:49 -07:00
|
|
|
cc->key_size = key_size;
|
2010-08-11 21:14:07 -06:00
|
|
|
|
|
|
|
ti->private = cc;
|
|
|
|
ret = crypt_ctr_cipher(ti, argv[0], argv[1]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto bad;
|
|
|
|
|
2008-02-07 19:11:07 -07:00
|
|
|
cc->dmreq_start = sizeof(struct ablkcipher_request);
|
2011-01-13 12:59:53 -07:00
|
|
|
cc->dmreq_start += crypto_ablkcipher_reqsize(any_tfm(cc));
|
dm crypt: fix access beyond the end of allocated space
The DM crypt target accesses memory beyond allocated space resulting in
a crash on 32 bit x86 systems.
This bug is very old (it dates back to 2.6.25 commit 3a7f6c990ad04 "dm
crypt: use async crypto"). However, this bug was masked by the fact
that kmalloc rounds the size up to the next power of two. This bug
wasn't exposed until 3.17-rc1 commit 298a9fa08a ("dm crypt: use per-bio
data"). By switching to using per-bio data there was no longer any
padding beyond the end of a dm-crypt allocated memory block.
To minimize allocation overhead dm-crypt puts several structures into one
block allocated with kmalloc. The block holds struct ablkcipher_request,
cipher-specific scratch pad (crypto_ablkcipher_reqsize(any_tfm(cc))),
struct dm_crypt_request and an initialization vector.
The variable dmreq_start is set to offset of struct dm_crypt_request
within this memory block. dm-crypt allocates the block with this size:
cc->dmreq_start + sizeof(struct dm_crypt_request) + cc->iv_size.
When accessing the initialization vector, dm-crypt uses the function
iv_of_dmreq, which performs this calculation: ALIGN((unsigned long)(dmreq
+ 1), crypto_ablkcipher_alignmask(any_tfm(cc)) + 1).
dm-crypt allocated "cc->iv_size" bytes beyond the end of dm_crypt_request
structure. However, when dm-crypt accesses the initialization vector, it
takes a pointer to the end of dm_crypt_request, aligns it, and then uses
it as the initialization vector. If the end of dm_crypt_request is not
aligned on a crypto_ablkcipher_alignmask(any_tfm(cc)) boundary the
alignment causes the initialization vector to point beyond the allocated
space.
Fix this bug by calculating the variable iv_size_padding and adding it
to the allocated size.
Also correct the alignment of dm_crypt_request. struct dm_crypt_request
is specific to dm-crypt (it isn't used by the crypto subsystem at all),
so it is aligned on __alignof__(struct dm_crypt_request).
Also align per_bio_data_size on ARCH_KMALLOC_MINALIGN, so that it is
aligned as if the block was allocated with kmalloc.
Reported-by: Krzysztof Kolasa <kkolasa@winsoft.pl>
Tested-by: Milan Broz <gmazyland@gmail.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
2014-08-28 09:09:31 -06:00
|
|
|
cc->dmreq_start = ALIGN(cc->dmreq_start, __alignof__(struct dm_crypt_request));
|
|
|
|
|
|
|
|
if (crypto_ablkcipher_alignmask(any_tfm(cc)) < CRYPTO_MINALIGN) {
|
|
|
|
/* Allocate the padding exactly */
|
|
|
|
iv_size_padding = -(cc->dmreq_start + sizeof(struct dm_crypt_request))
|
|
|
|
& crypto_ablkcipher_alignmask(any_tfm(cc));
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If the cipher requires greater alignment than kmalloc
|
|
|
|
* alignment, we don't know the exact position of the
|
|
|
|
* initialization vector. We must assume worst case.
|
|
|
|
*/
|
|
|
|
iv_size_padding = crypto_ablkcipher_alignmask(any_tfm(cc));
|
|
|
|
}
|
2008-02-07 19:11:07 -07:00
|
|
|
|
2015-02-13 06:25:26 -07:00
|
|
|
ret = -ENOMEM;
|
2008-02-07 19:11:07 -07:00
|
|
|
cc->req_pool = mempool_create_kmalloc_pool(MIN_IOS, cc->dmreq_start +
|
dm crypt: fix access beyond the end of allocated space
The DM crypt target accesses memory beyond allocated space resulting in
a crash on 32 bit x86 systems.
This bug is very old (it dates back to 2.6.25 commit 3a7f6c990ad04 "dm
crypt: use async crypto"). However, this bug was masked by the fact
that kmalloc rounds the size up to the next power of two. This bug
wasn't exposed until 3.17-rc1 commit 298a9fa08a ("dm crypt: use per-bio
data"). By switching to using per-bio data there was no longer any
padding beyond the end of a dm-crypt allocated memory block.
To minimize allocation overhead dm-crypt puts several structures into one
block allocated with kmalloc. The block holds struct ablkcipher_request,
cipher-specific scratch pad (crypto_ablkcipher_reqsize(any_tfm(cc))),
struct dm_crypt_request and an initialization vector.
The variable dmreq_start is set to offset of struct dm_crypt_request
within this memory block. dm-crypt allocates the block with this size:
cc->dmreq_start + sizeof(struct dm_crypt_request) + cc->iv_size.
When accessing the initialization vector, dm-crypt uses the function
iv_of_dmreq, which performs this calculation: ALIGN((unsigned long)(dmreq
+ 1), crypto_ablkcipher_alignmask(any_tfm(cc)) + 1).
dm-crypt allocated "cc->iv_size" bytes beyond the end of dm_crypt_request
structure. However, when dm-crypt accesses the initialization vector, it
takes a pointer to the end of dm_crypt_request, aligns it, and then uses
it as the initialization vector. If the end of dm_crypt_request is not
aligned on a crypto_ablkcipher_alignmask(any_tfm(cc)) boundary the
alignment causes the initialization vector to point beyond the allocated
space.
Fix this bug by calculating the variable iv_size_padding and adding it
to the allocated size.
Also correct the alignment of dm_crypt_request. struct dm_crypt_request
is specific to dm-crypt (it isn't used by the crypto subsystem at all),
so it is aligned on __alignof__(struct dm_crypt_request).
Also align per_bio_data_size on ARCH_KMALLOC_MINALIGN, so that it is
aligned as if the block was allocated with kmalloc.
Reported-by: Krzysztof Kolasa <kkolasa@winsoft.pl>
Tested-by: Milan Broz <gmazyland@gmail.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
2014-08-28 09:09:31 -06:00
|
|
|
sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size);
|
2008-02-07 19:11:07 -07:00
|
|
|
if (!cc->req_pool) {
|
|
|
|
ti->error = "Cannot allocate crypt request mempool";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2008-02-07 19:11:07 -07:00
|
|
|
}
|
|
|
|
|
2014-03-28 13:51:55 -06:00
|
|
|
cc->per_bio_data_size = ti->per_bio_data_size =
|
dm crypt: fix access beyond the end of allocated space
The DM crypt target accesses memory beyond allocated space resulting in
a crash on 32 bit x86 systems.
This bug is very old (it dates back to 2.6.25 commit 3a7f6c990ad04 "dm
crypt: use async crypto"). However, this bug was masked by the fact
that kmalloc rounds the size up to the next power of two. This bug
wasn't exposed until 3.17-rc1 commit 298a9fa08a ("dm crypt: use per-bio
data"). By switching to using per-bio data there was no longer any
padding beyond the end of a dm-crypt allocated memory block.
To minimize allocation overhead dm-crypt puts several structures into one
block allocated with kmalloc. The block holds struct ablkcipher_request,
cipher-specific scratch pad (crypto_ablkcipher_reqsize(any_tfm(cc))),
struct dm_crypt_request and an initialization vector.
The variable dmreq_start is set to offset of struct dm_crypt_request
within this memory block. dm-crypt allocates the block with this size:
cc->dmreq_start + sizeof(struct dm_crypt_request) + cc->iv_size.
When accessing the initialization vector, dm-crypt uses the function
iv_of_dmreq, which performs this calculation: ALIGN((unsigned long)(dmreq
+ 1), crypto_ablkcipher_alignmask(any_tfm(cc)) + 1).
dm-crypt allocated "cc->iv_size" bytes beyond the end of dm_crypt_request
structure. However, when dm-crypt accesses the initialization vector, it
takes a pointer to the end of dm_crypt_request, aligns it, and then uses
it as the initialization vector. If the end of dm_crypt_request is not
aligned on a crypto_ablkcipher_alignmask(any_tfm(cc)) boundary the
alignment causes the initialization vector to point beyond the allocated
space.
Fix this bug by calculating the variable iv_size_padding and adding it
to the allocated size.
Also correct the alignment of dm_crypt_request. struct dm_crypt_request
is specific to dm-crypt (it isn't used by the crypto subsystem at all),
so it is aligned on __alignof__(struct dm_crypt_request).
Also align per_bio_data_size on ARCH_KMALLOC_MINALIGN, so that it is
aligned as if the block was allocated with kmalloc.
Reported-by: Krzysztof Kolasa <kkolasa@winsoft.pl>
Tested-by: Milan Broz <gmazyland@gmail.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
2014-08-28 09:09:31 -06:00
|
|
|
ALIGN(sizeof(struct dm_crypt_io) + cc->dmreq_start +
|
|
|
|
sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size,
|
|
|
|
ARCH_KMALLOC_MINALIGN);
|
2014-03-28 13:51:55 -06:00
|
|
|
|
2015-02-13 06:23:52 -07:00
|
|
|
cc->page_pool = mempool_create_page_pool(BIO_MAX_PAGES, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!cc->page_pool) {
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Cannot allocate page mempool";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-12-10 07:35:05 -07:00
|
|
|
cc->bs = bioset_create(MIN_IOS, 0);
|
2006-10-03 02:15:40 -06:00
|
|
|
if (!cc->bs) {
|
|
|
|
ti->error = "Cannot allocate crypt bioset";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2006-10-03 02:15:40 -06:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:24:41 -07:00
|
|
|
mutex_init(&cc->bio_alloc_lock);
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
ret = -EINVAL;
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 11:41:26 -06:00
|
|
|
if (sscanf(argv[2], "%llu%c", &tmpll, &dummy) != 1) {
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Invalid iv_offset sector";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-27 02:17:48 -07:00
|
|
|
cc->iv_offset = tmpll;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
if (dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &cc->dev)) {
|
|
|
|
ti->error = "Device lookup failed";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
dm: reject trailing characters in sccanf input
Device mapper uses sscanf to convert arguments to numbers. The problem is that
the way we use it ignores additional unmatched characters in the scanned string.
For example, this `if (sscanf(string, "%d", &number) == 1)' will match a number,
but also it will match number with some garbage appended, like "123abc".
As a result, device mapper accepts garbage after some numbers. For example
the command `dmsetup create vg1-new --table "0 16384 linear 254:1bla 34816bla"'
will pass without an error.
This patch fixes all sscanf uses in device mapper. It appends "%c" with
a pointer to a dummy character variable to every sscanf statement.
The construct `if (sscanf(string, "%d%c", &number, &dummy) == 1)' succeeds
only if string is a null-terminated number (optionally preceded by some
whitespace characters). If there is some character appended after the number,
sscanf matches "%c", writes the character to the dummy variable and returns 2.
We check the return value for 1 and consequently reject numbers with some
garbage appended.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2012-03-28 11:41:26 -06:00
|
|
|
if (sscanf(argv[4], "%llu%c", &tmpll, &dummy) != 1) {
|
2006-06-26 01:27:35 -06:00
|
|
|
ti->error = "Invalid device sector";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-27 02:17:48 -07:00
|
|
|
cc->start = tmpll;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-08-02 05:32:08 -06:00
|
|
|
argv += 5;
|
|
|
|
argc -= 5;
|
|
|
|
|
|
|
|
/* Optional parameters */
|
|
|
|
if (argc) {
|
|
|
|
as.argc = argc;
|
|
|
|
as.argv = argv;
|
|
|
|
|
|
|
|
ret = dm_read_arg_group(_args, &as, &opt_params, &ti->error);
|
|
|
|
if (ret)
|
|
|
|
goto bad;
|
|
|
|
|
2015-04-16 20:00:50 -06:00
|
|
|
ret = -EINVAL;
|
2015-02-13 06:23:09 -07:00
|
|
|
while (opt_params--) {
|
|
|
|
opt_string = dm_shift_arg(&as);
|
|
|
|
if (!opt_string) {
|
|
|
|
ti->error = "Not enough feature arguments";
|
|
|
|
goto bad;
|
|
|
|
}
|
2011-08-02 05:32:08 -06:00
|
|
|
|
2015-02-13 06:23:09 -07:00
|
|
|
if (!strcasecmp(opt_string, "allow_discards"))
|
|
|
|
ti->num_discard_bios = 1;
|
|
|
|
|
|
|
|
else if (!strcasecmp(opt_string, "same_cpu_crypt"))
|
|
|
|
set_bit(DM_CRYPT_SAME_CPU, &cc->flags);
|
|
|
|
|
2015-02-13 06:27:08 -07:00
|
|
|
else if (!strcasecmp(opt_string, "submit_from_crypt_cpus"))
|
|
|
|
set_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags);
|
|
|
|
|
2015-02-13 06:23:09 -07:00
|
|
|
else {
|
|
|
|
ti->error = "Invalid feature arguments";
|
|
|
|
goto bad;
|
|
|
|
}
|
2011-08-02 05:32:08 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
ret = -ENOMEM;
|
2013-07-30 06:40:21 -06:00
|
|
|
cc->io_queue = alloc_workqueue("kcryptd_io", WQ_MEM_RECLAIM, 1);
|
2007-10-19 15:38:58 -06:00
|
|
|
if (!cc->io_queue) {
|
|
|
|
ti->error = "Couldn't create kcryptd io queue";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2007-10-19 15:38:58 -06:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:23:09 -07:00
|
|
|
if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags))
|
|
|
|
cc->crypt_queue = alloc_workqueue("kcryptd", WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM, 1);
|
|
|
|
else
|
|
|
|
cc->crypt_queue = alloc_workqueue("kcryptd", WQ_CPU_INTENSIVE | WQ_MEM_RECLAIM | WQ_UNBOUND,
|
|
|
|
num_online_cpus());
|
2007-10-19 15:38:58 -06:00
|
|
|
if (!cc->crypt_queue) {
|
2007-10-19 15:38:57 -06:00
|
|
|
ti->error = "Couldn't create kcryptd queue";
|
2010-08-11 21:14:06 -06:00
|
|
|
goto bad;
|
2007-10-19 15:38:57 -06:00
|
|
|
}
|
|
|
|
|
2015-02-13 06:25:59 -07:00
|
|
|
init_waitqueue_head(&cc->write_thread_wait);
|
2015-02-13 06:27:41 -07:00
|
|
|
cc->write_tree = RB_ROOT;
|
2015-02-13 06:25:59 -07:00
|
|
|
|
|
|
|
cc->write_thread = kthread_create(dmcrypt_write, cc, "dmcrypt_write");
|
|
|
|
if (IS_ERR(cc->write_thread)) {
|
|
|
|
ret = PTR_ERR(cc->write_thread);
|
|
|
|
cc->write_thread = NULL;
|
|
|
|
ti->error = "Couldn't spawn write thread";
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
wake_up_process(cc->write_thread);
|
|
|
|
|
2013-03-01 15:45:47 -07:00
|
|
|
ti->num_flush_bios = 1;
|
2012-07-27 08:08:08 -06:00
|
|
|
ti->discard_zeroes_data_unsupported = true;
|
2011-09-25 16:26:21 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2010-08-11 21:14:06 -06:00
|
|
|
bad:
|
|
|
|
crypt_dtr(ti);
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-12-21 13:23:41 -07:00
|
|
|
static int crypt_map(struct dm_target *ti, struct bio *bio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-12 10:26:32 -06:00
|
|
|
struct dm_crypt_io *io;
|
2012-07-27 08:08:05 -06:00
|
|
|
struct crypt_config *cc = ti->private;
|
2009-06-22 03:12:23 -06:00
|
|
|
|
2011-08-02 05:32:08 -06:00
|
|
|
/*
|
|
|
|
* If bio is REQ_FLUSH or REQ_DISCARD, just bypass crypt queues.
|
|
|
|
* - for REQ_FLUSH device-mapper core ensures that no IO is in-flight
|
|
|
|
* - for REQ_DISCARD caller must use flush if IO ordering matters
|
|
|
|
*/
|
|
|
|
if (unlikely(bio->bi_rw & (REQ_FLUSH | REQ_DISCARD))) {
|
2009-06-22 03:12:23 -06:00
|
|
|
bio->bi_bdev = cc->dev->bdev;
|
2011-08-02 05:32:08 -06:00
|
|
|
if (bio_sectors(bio))
|
2013-10-11 16:44:27 -06:00
|
|
|
bio->bi_iter.bi_sector = cc->start +
|
|
|
|
dm_target_offset(ti, bio->bi_iter.bi_sector);
|
2009-06-22 03:12:23 -06:00
|
|
|
return DM_MAPIO_REMAPPED;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-28 13:51:55 -06:00
|
|
|
io = dm_per_bio_data(bio, cc->per_bio_data_size);
|
|
|
|
crypt_io_init(io, cc, bio, dm_target_offset(ti, bio->bi_iter.bi_sector));
|
|
|
|
io->ctx.req = (struct ablkcipher_request *)(io + 1);
|
2007-10-19 15:38:58 -06:00
|
|
|
|
2011-01-13 12:59:53 -07:00
|
|
|
if (bio_data_dir(io->base_bio) == READ) {
|
|
|
|
if (kcryptd_io_read(io, GFP_NOWAIT))
|
2015-02-13 06:25:59 -07:00
|
|
|
kcryptd_queue_read(io);
|
2011-01-13 12:59:53 -07:00
|
|
|
} else
|
2007-10-19 15:38:58 -06:00
|
|
|
kcryptd_queue_crypt(io);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-08 03:41:06 -07:00
|
|
|
return DM_MAPIO_SUBMITTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-03-01 15:45:44 -07:00
|
|
|
static void crypt_status(struct dm_target *ti, status_type_t type,
|
|
|
|
unsigned status_flags, char *result, unsigned maxlen)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-08-11 21:14:07 -06:00
|
|
|
struct crypt_config *cc = ti->private;
|
2013-03-01 15:45:44 -07:00
|
|
|
unsigned i, sz = 0;
|
2015-02-13 06:23:09 -07:00
|
|
|
int num_feature_args = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case STATUSTYPE_INFO:
|
|
|
|
result[0] = '\0';
|
|
|
|
break;
|
|
|
|
|
|
|
|
case STATUSTYPE_TABLE:
|
2011-01-13 12:59:52 -07:00
|
|
|
DMEMIT("%s ", cc->cipher_string);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-03-01 15:45:44 -07:00
|
|
|
if (cc->key_size > 0)
|
|
|
|
for (i = 0; i < cc->key_size; i++)
|
|
|
|
DMEMIT("%02x", cc->key[i]);
|
|
|
|
else
|
|
|
|
DMEMIT("-");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-27 02:17:48 -07:00
|
|
|
DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
|
|
|
|
cc->dev->name, (unsigned long long)cc->start);
|
2011-08-02 05:32:08 -06:00
|
|
|
|
2015-02-13 06:23:09 -07:00
|
|
|
num_feature_args += !!ti->num_discard_bios;
|
|
|
|
num_feature_args += test_bit(DM_CRYPT_SAME_CPU, &cc->flags);
|
2015-02-13 06:27:08 -07:00
|
|
|
num_feature_args += test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags);
|
2015-02-13 06:23:09 -07:00
|
|
|
if (num_feature_args) {
|
|
|
|
DMEMIT(" %d", num_feature_args);
|
|
|
|
if (ti->num_discard_bios)
|
|
|
|
DMEMIT(" allow_discards");
|
|
|
|
if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags))
|
|
|
|
DMEMIT(" same_cpu_crypt");
|
2015-02-13 06:27:08 -07:00
|
|
|
if (test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags))
|
|
|
|
DMEMIT(" submit_from_crypt_cpus");
|
2015-02-13 06:23:09 -07:00
|
|
|
}
|
2011-08-02 05:32:08 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-03 02:15:37 -06:00
|
|
|
static void crypt_postsuspend(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
|
|
|
|
|
|
|
set_bit(DM_CRYPT_SUSPENDED, &cc->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int crypt_preresume(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
|
|
|
|
|
|
|
if (!test_bit(DM_CRYPT_KEY_VALID, &cc->flags)) {
|
|
|
|
DMERR("aborting resume - crypt key is not set.");
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void crypt_resume(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
|
|
|
|
|
|
|
clear_bit(DM_CRYPT_SUSPENDED, &cc->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Message interface
|
|
|
|
* key set <key>
|
|
|
|
* key wipe
|
|
|
|
*/
|
|
|
|
static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
2009-12-10 16:51:57 -07:00
|
|
|
int ret = -EINVAL;
|
2006-10-03 02:15:37 -06:00
|
|
|
|
|
|
|
if (argc < 2)
|
|
|
|
goto error;
|
|
|
|
|
2011-08-02 05:32:04 -06:00
|
|
|
if (!strcasecmp(argv[0], "key")) {
|
2006-10-03 02:15:37 -06:00
|
|
|
if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) {
|
|
|
|
DMWARN("not suspended during key manipulation.");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2011-08-02 05:32:04 -06:00
|
|
|
if (argc == 3 && !strcasecmp(argv[1], "set")) {
|
2009-12-10 16:51:57 -07:00
|
|
|
ret = crypt_set_key(cc, argv[2]);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (cc->iv_gen_ops && cc->iv_gen_ops->init)
|
|
|
|
ret = cc->iv_gen_ops->init(cc);
|
|
|
|
return ret;
|
|
|
|
}
|
2011-08-02 05:32:04 -06:00
|
|
|
if (argc == 2 && !strcasecmp(argv[1], "wipe")) {
|
2009-12-10 16:51:57 -07:00
|
|
|
if (cc->iv_gen_ops && cc->iv_gen_ops->wipe) {
|
|
|
|
ret = cc->iv_gen_ops->wipe(cc);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2006-10-03 02:15:37 -06:00
|
|
|
return crypt_wipe_key(cc);
|
2009-12-10 16:51:57 -07:00
|
|
|
}
|
2006-10-03 02:15:37 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
error:
|
|
|
|
DMWARN("unrecognised message received.");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-07-21 05:00:40 -06:00
|
|
|
static int crypt_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
|
|
|
|
struct bio_vec *biovec, int max_size)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
|
|
|
struct request_queue *q = bdev_get_queue(cc->dev->bdev);
|
|
|
|
|
|
|
|
if (!q->merge_bvec_fn)
|
|
|
|
return max_size;
|
|
|
|
|
|
|
|
bvm->bi_bdev = cc->dev->bdev;
|
2010-08-11 21:14:11 -06:00
|
|
|
bvm->bi_sector = cc->start + dm_target_offset(ti, bvm->bi_sector);
|
2008-07-21 05:00:40 -06:00
|
|
|
|
|
|
|
return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
|
|
|
|
}
|
|
|
|
|
2009-06-22 03:12:33 -06:00
|
|
|
static int crypt_iterate_devices(struct dm_target *ti,
|
|
|
|
iterate_devices_callout_fn fn, void *data)
|
|
|
|
{
|
|
|
|
struct crypt_config *cc = ti->private;
|
|
|
|
|
2009-07-23 13:30:42 -06:00
|
|
|
return fn(ti, cc->dev, cc->start, ti->len, data);
|
2009-06-22 03:12:33 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct target_type crypt_target = {
|
|
|
|
.name = "crypt",
|
2015-02-13 06:23:09 -07:00
|
|
|
.version = {1, 14, 0},
|
2005-04-16 16:20:36 -06:00
|
|
|
.module = THIS_MODULE,
|
|
|
|
.ctr = crypt_ctr,
|
|
|
|
.dtr = crypt_dtr,
|
|
|
|
.map = crypt_map,
|
|
|
|
.status = crypt_status,
|
2006-10-03 02:15:37 -06:00
|
|
|
.postsuspend = crypt_postsuspend,
|
|
|
|
.preresume = crypt_preresume,
|
|
|
|
.resume = crypt_resume,
|
|
|
|
.message = crypt_message,
|
2008-07-21 05:00:40 -06:00
|
|
|
.merge = crypt_merge,
|
2009-06-22 03:12:33 -06:00
|
|
|
.iterate_devices = crypt_iterate_devices,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init dm_crypt_init(void)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = dm_register_target(&crypt_target);
|
2015-02-13 06:25:26 -07:00
|
|
|
if (r < 0)
|
2006-06-26 01:27:35 -06:00
|
|
|
DMERR("register failed %d", r);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit dm_crypt_exit(void)
|
|
|
|
{
|
2009-01-05 20:04:58 -07:00
|
|
|
dm_unregister_target(&crypt_target);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(dm_crypt_init);
|
|
|
|
module_exit(dm_crypt_exit);
|
|
|
|
|
2014-06-24 12:27:04 -06:00
|
|
|
MODULE_AUTHOR("Jana Saout <jana@saout.de>");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_DESCRIPTION(DM_NAME " target for transparent encryption / decryption");
|
|
|
|
MODULE_LICENSE("GPL");
|