/*
 *  VasEBoot  --  GRand Unified Bootloader
 *  Copyright (C) 2003,2007,2010,2011  Free Software Foundation, Inc.
 *
 *  VasEBoot is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VasEBoot is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VasEBoot.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/cryptodisk.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/dl.h>
#include <VasEBoot/extcmd.h>
#include <VasEBoot/i18n.h>
#include <VasEBoot/fs.h>
#include <VasEBoot/file.h>
#include <VasEBoot/procfs.h>
#include <VasEBoot/partition.h>

#ifdef VasEBoot_UTIL
#include <VasEBoot/emu/hostdisk.h>
#endif

VasEBoot_MOD_LICENSE ("GPLv3+");

VasEBoot_cryptodisk_dev_t VasEBoot_cryptodisk_list;

static const struct VasEBoot_arg_option options[] =
  {
    {"uuid", 'u', 0, N_("Mount by UUID."), 0, 0},
    /* TRANSLATORS: It's still restricted to cryptodisks only.  */
    {"all", 'a', 0, N_("Mount all."), 0, 0},
    {"boot", 'b', 0, N_("Mount all volumes with `boot' flag set."), 0, 0},
    {0, 0, 0, 0, 0, 0}
  };

/* Our irreducible polynom is x^128+x^7+x^2+x+1. Lowest byte of it is:  */
#define GF_POLYNOM 0x87
static inline int GF_PER_SECTOR (const struct VasEBoot_cryptodisk *dev)
{
  return 1U << (dev->log_sector_size - VasEBoot_CRYPTODISK_GF_LOG_BYTES);
}

static VasEBoot_cryptodisk_t cryptodisk_list = NULL;
static VasEBoot_uint8_t last_cryptodisk_id = 0;

static void
gf_mul_x (VasEBoot_uint8_t *g)
{
  int over = 0, over2 = 0;
  unsigned j;

  for (j = 0; j < VasEBoot_CRYPTODISK_GF_BYTES; j++)
    {
      over2 = !!(g[j] & 0x80);
      g[j] <<= 1;
      g[j] |= over;
      over = over2;
    }
  if (over)
    g[0] ^= GF_POLYNOM;
}


static void
gf_mul_x_be (VasEBoot_uint8_t *g)
{
  int over = 0, over2 = 0;
  int j;

  for (j = (int) VasEBoot_CRYPTODISK_GF_BYTES - 1; j >= 0; j--)
    {
      over2 = !!(g[j] & 0x80);
      g[j] <<= 1;
      g[j] |= over;
      over = over2;
    }
  if (over)
    g[VasEBoot_CRYPTODISK_GF_BYTES - 1] ^= GF_POLYNOM;
}

static void
gf_mul_be (VasEBoot_uint8_t *o, const VasEBoot_uint8_t *a, const VasEBoot_uint8_t *b)
{
  unsigned i;
  VasEBoot_uint8_t t[VasEBoot_CRYPTODISK_GF_BYTES];
  VasEBoot_memset (o, 0, VasEBoot_CRYPTODISK_GF_BYTES);
  VasEBoot_memcpy (t, b, VasEBoot_CRYPTODISK_GF_BYTES);
  for (i = 0; i < VasEBoot_CRYPTODISK_GF_SIZE; i++)
    {
      if (((a[VasEBoot_CRYPTODISK_GF_BYTES - i / VasEBoot_CHAR_BIT - 1] >> (i % VasEBoot_CHAR_BIT))) & 1)
	VasEBoot_crypto_xor (o, o, t, VasEBoot_CRYPTODISK_GF_BYTES);
      gf_mul_x_be (t);
    }
}

static gcry_err_code_t
VasEBoot_crypto_pcbc_decrypt (VasEBoot_crypto_cipher_handle_t cipher,
			 void *out, void *in, VasEBoot_size_t size,
			 void *iv)
{
  VasEBoot_uint8_t *inptr, *outptr, *end;
  VasEBoot_uint8_t ivt[VasEBoot_CRYPTO_MAX_CIPHER_BLOCKSIZE];
  VasEBoot_size_t blocksize;
  if (!cipher->cipher->decrypt)
    return GPG_ERR_NOT_SUPPORTED;
  blocksize = cipher->cipher->blocksize;
  if (blocksize == 0 || (((blocksize - 1) & blocksize) != 0)
      || ((size & (blocksize - 1)) != 0))
    return GPG_ERR_INV_ARG;
  if (blocksize > VasEBoot_CRYPTO_MAX_CIPHER_BLOCKSIZE)
    return GPG_ERR_INV_ARG;
  end = (VasEBoot_uint8_t *) in + size;
  for (inptr = in, outptr = out; inptr < end;
       inptr += blocksize, outptr += blocksize)
    {
      VasEBoot_memcpy (ivt, inptr, blocksize);
      cipher->cipher->decrypt (cipher->ctx, outptr, inptr);
      VasEBoot_crypto_xor (outptr, outptr, iv, blocksize);
      VasEBoot_crypto_xor (iv, ivt, outptr, blocksize);
    }
  return GPG_ERR_NO_ERROR;
}

static gcry_err_code_t
VasEBoot_crypto_pcbc_encrypt (VasEBoot_crypto_cipher_handle_t cipher,
			  void *out, void *in, VasEBoot_size_t size,
			  void *iv)
{
  VasEBoot_uint8_t *inptr, *outptr, *end;
  VasEBoot_uint8_t ivt[VasEBoot_CRYPTO_MAX_CIPHER_BLOCKSIZE];
  VasEBoot_size_t blocksize;
  if (!cipher->cipher->encrypt)
    return GPG_ERR_NOT_SUPPORTED;
  blocksize = cipher->cipher->blocksize;
  if (blocksize > VasEBoot_CRYPTO_MAX_CIPHER_BLOCKSIZE)
    return GPG_ERR_INV_ARG;
  if (blocksize == 0 || (((blocksize - 1) & blocksize) != 0)
      || ((size & (blocksize - 1)) != 0))
    return GPG_ERR_INV_ARG;
  end = (VasEBoot_uint8_t *) in + size;
  for (inptr = in, outptr = out; inptr < end;
       inptr += blocksize, outptr += blocksize)
    {
      VasEBoot_memcpy (ivt, inptr, blocksize);
      VasEBoot_crypto_xor (outptr, outptr, iv, blocksize);
      cipher->cipher->encrypt (cipher->ctx, outptr, inptr);
      VasEBoot_crypto_xor (iv, ivt, outptr, blocksize);
    }
  return GPG_ERR_NO_ERROR;
}

struct lrw_sector
{
  VasEBoot_uint8_t low[VasEBoot_CRYPTODISK_GF_BYTES];
  VasEBoot_uint8_t high[VasEBoot_CRYPTODISK_GF_BYTES];
  VasEBoot_uint8_t low_byte, low_byte_c;
};

static void
generate_lrw_sector (struct lrw_sector *sec,
		     const struct VasEBoot_cryptodisk *dev,
		     const VasEBoot_uint8_t *iv)
{
  VasEBoot_uint8_t idx[VasEBoot_CRYPTODISK_GF_BYTES];
  VasEBoot_uint16_t c;
  int j;
  VasEBoot_memcpy (idx, iv, VasEBoot_CRYPTODISK_GF_BYTES);
  sec->low_byte = (idx[VasEBoot_CRYPTODISK_GF_BYTES - 1]
		   & (GF_PER_SECTOR (dev) - 1));
  sec->low_byte_c = (((GF_PER_SECTOR (dev) - 1) & ~sec->low_byte) + 1);
  idx[VasEBoot_CRYPTODISK_GF_BYTES - 1] &= ~(GF_PER_SECTOR (dev) - 1);
  gf_mul_be (sec->low, dev->lrw_key, idx);
  if (!sec->low_byte)
    return;

  c = idx[VasEBoot_CRYPTODISK_GF_BYTES - 1] + GF_PER_SECTOR (dev);
  if (c & 0x100)
    {
      for (j = VasEBoot_CRYPTODISK_GF_BYTES - 2; j >= 0; j--)
	{
	  idx[j]++;
	  if (idx[j] != 0)
	    break;
	}
    }
  idx[VasEBoot_CRYPTODISK_GF_BYTES - 1] = c;
  gf_mul_be (sec->high, dev->lrw_key, idx);
}

static void __attribute__ ((unused))
lrw_xor (const struct lrw_sector *sec,
	 const struct VasEBoot_cryptodisk *dev,
	 VasEBoot_uint8_t *b)
{
  unsigned i;

  for (i = 0; i < sec->low_byte_c * VasEBoot_CRYPTODISK_GF_BYTES;
       i += VasEBoot_CRYPTODISK_GF_BYTES)
    VasEBoot_crypto_xor (b + i, b + i, sec->low, VasEBoot_CRYPTODISK_GF_BYTES);
  VasEBoot_crypto_xor (b, b, dev->lrw_precalc + VasEBoot_CRYPTODISK_GF_BYTES * sec->low_byte,
		   sec->low_byte_c * VasEBoot_CRYPTODISK_GF_BYTES);
  if (!sec->low_byte)
    return;

  for (i = sec->low_byte_c * VasEBoot_CRYPTODISK_GF_BYTES;
       i < (1U << dev->log_sector_size); i += VasEBoot_CRYPTODISK_GF_BYTES)
    VasEBoot_crypto_xor (b + i, b + i, sec->high, VasEBoot_CRYPTODISK_GF_BYTES);
  VasEBoot_crypto_xor (b + sec->low_byte_c * VasEBoot_CRYPTODISK_GF_BYTES,
		   b + sec->low_byte_c * VasEBoot_CRYPTODISK_GF_BYTES,
		   dev->lrw_precalc, sec->low_byte * VasEBoot_CRYPTODISK_GF_BYTES);
}

static gcry_err_code_t
VasEBoot_cryptodisk_endecrypt (struct VasEBoot_cryptodisk *dev,
			   VasEBoot_uint8_t * data, VasEBoot_size_t len,
			   VasEBoot_disk_addr_t sector, int do_encrypt)
{
  VasEBoot_size_t i;
  gcry_err_code_t err;

  if (dev->cipher->cipher->blocksize > VasEBoot_CRYPTO_MAX_CIPHER_BLOCKSIZE)
    return GPG_ERR_INV_ARG;

  /* The only mode without IV.  */
  if (dev->mode == VasEBoot_CRYPTODISK_MODE_ECB && !dev->rekey)
    return (do_encrypt ? VasEBoot_crypto_ecb_encrypt (dev->cipher, data, data, len)
	    : VasEBoot_crypto_ecb_decrypt (dev->cipher, data, data, len));

  for (i = 0; i < len; i += (1U << dev->log_sector_size))
    {
      VasEBoot_size_t sz = ((dev->cipher->cipher->blocksize
			 + sizeof (VasEBoot_uint32_t) - 1)
			/ sizeof (VasEBoot_uint32_t));
      VasEBoot_uint32_t iv[(VasEBoot_CRYPTO_MAX_CIPHER_BLOCKSIZE + 3) / 4];

      if (dev->rekey)
	{
	  VasEBoot_uint64_t zone = sector >> dev->rekey_shift;
	  if (zone != dev->last_rekey)
	    {
	      err = dev->rekey (dev, zone);
	      if (err)
		return err;
	      dev->last_rekey = zone;
	    }
	}

      VasEBoot_memset (iv, 0, sizeof (iv));
      switch (dev->mode_iv)
	{
	case VasEBoot_CRYPTODISK_MODE_IV_NULL:
	  break;
	case VasEBoot_CRYPTODISK_MODE_IV_BYTECOUNT64_HASH:
	  {
	    VasEBoot_uint64_t tmp;
	    void *ctx;

	    ctx = VasEBoot_zalloc (dev->iv_hash->contextsize);
	    if (!ctx)
	      return GPG_ERR_OUT_OF_MEMORY;

	    tmp = VasEBoot_cpu_to_le64 (sector << dev->log_sector_size);
	    dev->iv_hash->init (ctx);
	    dev->iv_hash->write (ctx, dev->iv_prefix, dev->iv_prefix_len);
	    dev->iv_hash->write (ctx, &tmp, sizeof (tmp));
	    dev->iv_hash->final (ctx);

	    VasEBoot_memcpy (iv, dev->iv_hash->read (ctx), sizeof (iv));
	    VasEBoot_free (ctx);
	  }
	  break;
	case VasEBoot_CRYPTODISK_MODE_IV_PLAIN64:
	  iv[1] = VasEBoot_cpu_to_le32 (sector >> 32);
	  /* FALLTHROUGH */
	case VasEBoot_CRYPTODISK_MODE_IV_PLAIN:
	  iv[0] = VasEBoot_cpu_to_le32 (sector & 0xFFFFFFFF);
	  break;
	case VasEBoot_CRYPTODISK_MODE_IV_BYTECOUNT64:
	  iv[1] = VasEBoot_cpu_to_le32 (sector >> (32 - dev->log_sector_size));
	  iv[0] = VasEBoot_cpu_to_le32 ((sector << dev->log_sector_size)
				    & 0xFFFFFFFF);
	  break;
	case VasEBoot_CRYPTODISK_MODE_IV_BENBI:
	  {
	    VasEBoot_uint64_t num = (sector << dev->benbi_log) + 1;
	    iv[sz - 2] = VasEBoot_cpu_to_be32 (num >> 32);
	    iv[sz - 1] = VasEBoot_cpu_to_be32 (num & 0xFFFFFFFF);
	  }
	  break;
	case VasEBoot_CRYPTODISK_MODE_IV_ESSIV:
	  iv[0] = VasEBoot_cpu_to_le32 (sector & 0xFFFFFFFF);
	  err = VasEBoot_crypto_ecb_encrypt (dev->essiv_cipher, iv, iv,
					 dev->cipher->cipher->blocksize);
	  if (err)
	    return err;
	}

      switch (dev->mode)
	{
	case VasEBoot_CRYPTODISK_MODE_CBC:
	  if (do_encrypt)
	    err = VasEBoot_crypto_cbc_encrypt (dev->cipher, data + i, data + i,
					   (1U << dev->log_sector_size), iv);
	  else
	    err = VasEBoot_crypto_cbc_decrypt (dev->cipher, data + i, data + i,
					   (1U << dev->log_sector_size), iv);
	  if (err)
	    return err;
	  break;

	case VasEBoot_CRYPTODISK_MODE_PCBC:
	  if (do_encrypt)
	    err = VasEBoot_crypto_pcbc_encrypt (dev->cipher, data + i, data + i,
					    (1U << dev->log_sector_size), iv);
	  else
	    err = VasEBoot_crypto_pcbc_decrypt (dev->cipher, data + i, data + i,
					    (1U << dev->log_sector_size), iv);
	  if (err)
	    return err;
	  break;
	case VasEBoot_CRYPTODISK_MODE_XTS:
	  {
	    unsigned j;
	    err = VasEBoot_crypto_ecb_encrypt (dev->secondary_cipher, iv, iv,
					   dev->cipher->cipher->blocksize);
	    if (err)
	      return err;
	    
	    for (j = 0; j < (1U << dev->log_sector_size);
		 j += dev->cipher->cipher->blocksize)
	      {
		VasEBoot_crypto_xor (data + i + j, data + i + j, iv,
				 dev->cipher->cipher->blocksize);
		if (do_encrypt)
		  err = VasEBoot_crypto_ecb_encrypt (dev->cipher, data + i + j, 
						 data + i + j,
						 dev->cipher->cipher->blocksize);
		else
		  err = VasEBoot_crypto_ecb_decrypt (dev->cipher, data + i + j, 
						 data + i + j,
						 dev->cipher->cipher->blocksize);
		if (err)
		  return err;
		VasEBoot_crypto_xor (data + i + j, data + i + j, iv,
				 dev->cipher->cipher->blocksize);
		gf_mul_x ((VasEBoot_uint8_t *) iv);
	      }
	  }
	  break;
	case VasEBoot_CRYPTODISK_MODE_LRW:
	  {
	    struct lrw_sector sec;

	    generate_lrw_sector (&sec, dev, (VasEBoot_uint8_t *) iv);
	    lrw_xor (&sec, dev, data + i);

	    if (do_encrypt)
	      err = VasEBoot_crypto_ecb_encrypt (dev->cipher, data + i, 
					     data + i,
					     (1U << dev->log_sector_size));
	    else
	      err = VasEBoot_crypto_ecb_decrypt (dev->cipher, data + i, 
					     data + i,
					     (1U << dev->log_sector_size));
	    if (err)
	      return err;
	    lrw_xor (&sec, dev, data + i);
	  }
	  break;
	case VasEBoot_CRYPTODISK_MODE_ECB:
	  if (do_encrypt)
	    err = VasEBoot_crypto_ecb_encrypt (dev->cipher, data + i, data + i,
					   (1U << dev->log_sector_size));
	  else
	    err = VasEBoot_crypto_ecb_decrypt (dev->cipher, data + i, data + i,
					   (1U << dev->log_sector_size));
	  if (err)
	    return err;
	  break;
	default:
	  return GPG_ERR_NOT_IMPLEMENTED;
	}
      sector++;
    }
  return GPG_ERR_NO_ERROR;
}

gcry_err_code_t
VasEBoot_cryptodisk_decrypt (struct VasEBoot_cryptodisk *dev,
			 VasEBoot_uint8_t * data, VasEBoot_size_t len,
			 VasEBoot_disk_addr_t sector)
{
  return VasEBoot_cryptodisk_endecrypt (dev, data, len, sector, 0);
}

gcry_err_code_t
VasEBoot_cryptodisk_setkey (VasEBoot_cryptodisk_t dev, VasEBoot_uint8_t *key, VasEBoot_size_t keysize)
{
  gcry_err_code_t err;
  int real_keysize;

  real_keysize = keysize;
  if (dev->mode == VasEBoot_CRYPTODISK_MODE_XTS)
    real_keysize /= 2;
  if (dev->mode == VasEBoot_CRYPTODISK_MODE_LRW)
    real_keysize -= dev->cipher->cipher->blocksize;
	
  /* Set the PBKDF2 output as the cipher key.  */
  err = VasEBoot_crypto_cipher_set_key (dev->cipher, key, real_keysize);
  if (err)
    return err;
  VasEBoot_memcpy (dev->key, key, keysize);
  dev->keysize = keysize;

  /* Configure ESSIV if necessary.  */
  if (dev->mode_iv == VasEBoot_CRYPTODISK_MODE_IV_ESSIV)
    {
      VasEBoot_size_t essiv_keysize = dev->essiv_hash->mdlen;
      VasEBoot_uint8_t hashed_key[VasEBoot_CRYPTO_MAX_MDLEN];
      if (essiv_keysize > VasEBoot_CRYPTO_MAX_MDLEN)
	return GPG_ERR_INV_ARG;

      VasEBoot_crypto_hash (dev->essiv_hash, hashed_key, key, keysize);
      err = VasEBoot_crypto_cipher_set_key (dev->essiv_cipher,
					hashed_key, essiv_keysize);
      if (err)
	return err;
    }
  if (dev->mode == VasEBoot_CRYPTODISK_MODE_XTS)
    {
      err = VasEBoot_crypto_cipher_set_key (dev->secondary_cipher,
					key + real_keysize,
					keysize / 2);
      if (err)
	return err;
    }

  if (dev->mode == VasEBoot_CRYPTODISK_MODE_LRW)
    {
      unsigned i;
      VasEBoot_uint8_t idx[VasEBoot_CRYPTODISK_GF_BYTES];

      VasEBoot_free (dev->lrw_precalc);
      VasEBoot_memcpy (dev->lrw_key, key + real_keysize,
		   dev->cipher->cipher->blocksize);
      dev->lrw_precalc = VasEBoot_malloc ((1U << dev->log_sector_size));
      if (!dev->lrw_precalc)
	return GPG_ERR_OUT_OF_MEMORY;
      VasEBoot_memset (idx, 0, VasEBoot_CRYPTODISK_GF_BYTES);
      for (i = 0; i < (1U << dev->log_sector_size);
	   i += VasEBoot_CRYPTODISK_GF_BYTES)
	{
	  idx[VasEBoot_CRYPTODISK_GF_BYTES - 1] = i / VasEBoot_CRYPTODISK_GF_BYTES;
	  gf_mul_be (dev->lrw_precalc + i, idx, dev->lrw_key);
	}
    }
  return GPG_ERR_NO_ERROR;
}

static int
VasEBoot_cryptodisk_iterate (VasEBoot_disk_dev_iterate_hook_t hook, void *hook_data,
			 VasEBoot_disk_pull_t pull)
{
  VasEBoot_cryptodisk_t i;

  if (pull != VasEBoot_DISK_PULL_NONE)
    return 0;

  for (i = cryptodisk_list; i != NULL; i = i->next)
    {
      char buf[30];
      VasEBoot_snprintf (buf, sizeof (buf), "crypto%lu", i->id);
      if (hook (buf, hook_data))
	return 1;
    }

  return VasEBoot_ERR_NONE;
}

static VasEBoot_err_t
VasEBoot_cryptodisk_open (const char *name, VasEBoot_disk_t disk)
{
  VasEBoot_cryptodisk_t dev;

  if (VasEBoot_memcmp (name, "crypto", sizeof ("crypto") - 1) != 0)
    return VasEBoot_error (VasEBoot_ERR_UNKNOWN_DEVICE, "No such device");

  if (VasEBoot_memcmp (name, "cryptouuid/", sizeof ("cryptouuid/") - 1) == 0)
    {
      for (dev = cryptodisk_list; dev != NULL; dev = dev->next)
	if (VasEBoot_strcasecmp (name + sizeof ("cryptouuid/") - 1, dev->uuid) == 0)
	  break;
    }
  else
    {
      unsigned long id = VasEBoot_strtoul (name + sizeof ("crypto") - 1, 0, 0);
      if (VasEBoot_errno)
	return VasEBoot_error (VasEBoot_ERR_UNKNOWN_DEVICE, "No such device");
      /* Search for requested device in the list of CRYPTODISK devices.  */
      for (dev = cryptodisk_list; dev != NULL; dev = dev->next)
	if (dev->id == id)
	  break;
    }
  if (!dev)
    return VasEBoot_error (VasEBoot_ERR_UNKNOWN_DEVICE, "No such device");

  disk->log_sector_size = dev->log_sector_size;

#ifdef VasEBoot_UTIL
  if (dev->cheat)
    {
      if (!VasEBoot_UTIL_FD_IS_VALID (dev->cheat_fd))
	dev->cheat_fd = VasEBoot_util_fd_open (dev->cheat, VasEBoot_UTIL_FD_O_RDONLY);
      if (!VasEBoot_UTIL_FD_IS_VALID (dev->cheat_fd))
	return VasEBoot_error (VasEBoot_ERR_IO, N_("cannot open `%s': %s"),
			   dev->cheat, VasEBoot_util_fd_strerror ());
    }
#endif

  if (!dev->source_disk)
    {
      VasEBoot_dprintf ("cryptodisk", "Opening device %s\n", name);
      /* Try to open the source disk and populate the requested disk.  */
      dev->source_disk = VasEBoot_disk_open (dev->source);
      if (!dev->source_disk)
	return VasEBoot_errno;
    }

  disk->data = dev;
  disk->total_sectors = dev->total_length;
  disk->max_agglomerate = VasEBoot_DISK_MAX_MAX_AGGLOMERATE;
  disk->id = dev->id;
  dev->ref++;
  return VasEBoot_ERR_NONE;
}

static void
VasEBoot_cryptodisk_close (VasEBoot_disk_t disk)
{
  VasEBoot_cryptodisk_t dev = (VasEBoot_cryptodisk_t) disk->data;
  VasEBoot_dprintf ("cryptodisk", "Closing disk\n");

  dev->ref--;

  if (dev->ref != 0)
    return;
#ifdef VasEBoot_UTIL
  if (dev->cheat)
    {
      VasEBoot_util_fd_close (dev->cheat_fd);
      dev->cheat_fd = VasEBoot_UTIL_FD_INVALID;
    }
#endif
  VasEBoot_disk_close (dev->source_disk);
  dev->source_disk = NULL;
}

static VasEBoot_err_t
VasEBoot_cryptodisk_read (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		      VasEBoot_size_t size, char *buf)
{
  VasEBoot_cryptodisk_t dev = (VasEBoot_cryptodisk_t) disk->data;
  VasEBoot_err_t err;
  gcry_err_code_t gcry_err;

#ifdef VasEBoot_UTIL
  if (dev->cheat)
    {
      int r;
      r = VasEBoot_util_fd_seek (dev->cheat_fd, sector << disk->log_sector_size);
      if (r)
	return VasEBoot_error (VasEBoot_ERR_BAD_DEVICE, N_("cannot seek `%s': %s"),
			   dev->cheat, VasEBoot_util_fd_strerror ());
      if (VasEBoot_util_fd_read (dev->cheat_fd, buf, size << disk->log_sector_size)
	  != (ssize_t) (size << disk->log_sector_size))
	return VasEBoot_error (VasEBoot_ERR_READ_ERROR, N_("cannot read `%s': %s"),
			   dev->cheat, VasEBoot_util_fd_strerror ());
      return VasEBoot_ERR_NONE;
    }
#endif

  VasEBoot_dprintf ("cryptodisk",
		"Reading %" PRIuVasEBoot_SIZE " sectors from sector 0x%"
		PRIxVasEBoot_UINT64_T " with offset of %" PRIuVasEBoot_UINT64_T "\n",
		size, sector, dev->offset);

  err = VasEBoot_disk_read (dev->source_disk,
			(sector << (disk->log_sector_size
				   - VasEBoot_DISK_SECTOR_BITS)) + dev->offset, 0,
			size << disk->log_sector_size, buf);
  if (err)
    {
      VasEBoot_dprintf ("cryptodisk", "VasEBoot_disk_read failed with error %d\n", err);
      return err;
    }
  gcry_err = VasEBoot_cryptodisk_endecrypt (dev, (VasEBoot_uint8_t *) buf,
					size << disk->log_sector_size,
					sector, 0);
  return VasEBoot_crypto_gcry_error (gcry_err);
}

static VasEBoot_err_t
VasEBoot_cryptodisk_write (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		       VasEBoot_size_t size, const char *buf)
{
  VasEBoot_cryptodisk_t dev = (VasEBoot_cryptodisk_t) disk->data;
  gcry_err_code_t gcry_err;
  char *tmp;
  VasEBoot_err_t err;

#ifdef VasEBoot_UTIL
  if (dev->cheat)
    {
      int r;
      r = VasEBoot_util_fd_seek (dev->cheat_fd, sector << disk->log_sector_size);
      if (r)
	return VasEBoot_error (VasEBoot_ERR_BAD_DEVICE, N_("cannot seek `%s': %s"),
			   dev->cheat, VasEBoot_util_fd_strerror ());
      if (VasEBoot_util_fd_write (dev->cheat_fd, buf, size << disk->log_sector_size)
	  != (ssize_t) (size << disk->log_sector_size))
	return VasEBoot_error (VasEBoot_ERR_READ_ERROR, N_("cannot read `%s': %s"),
			   dev->cheat, VasEBoot_util_fd_strerror ());
      return VasEBoot_ERR_NONE;
    }
#endif

  tmp = VasEBoot_malloc (size << disk->log_sector_size);
  if (!tmp)
    return VasEBoot_errno;
  VasEBoot_memcpy (tmp, buf, size << disk->log_sector_size);

  VasEBoot_dprintf ("cryptodisk",
		"Writing %" PRIuVasEBoot_SIZE " sectors to sector 0x%"
		PRIxVasEBoot_UINT64_T " with offset of %" PRIuVasEBoot_UINT64_T "\n",
		size, sector, dev->offset);

  gcry_err = VasEBoot_cryptodisk_endecrypt (dev, (VasEBoot_uint8_t *) tmp,
					size << disk->log_sector_size,
					sector, 1);
  if (gcry_err)
    {
      VasEBoot_free (tmp);
      return VasEBoot_crypto_gcry_error (gcry_err);
    }

  /* Since ->write was called so disk.mod is loaded but be paranoid  */
  
  if (VasEBoot_disk_write_weak)
    err = VasEBoot_disk_write_weak (dev->source_disk,
				(sector << (disk->log_sector_size
					    - VasEBoot_DISK_SECTOR_BITS))
				+ dev->offset,
				0, size << disk->log_sector_size, tmp);
  else
    err = VasEBoot_error (VasEBoot_ERR_BUG, "disk.mod not loaded");
  VasEBoot_free (tmp);
  return err;
}

#ifdef VasEBoot_UTIL
static VasEBoot_disk_memberlist_t
VasEBoot_cryptodisk_memberlist (VasEBoot_disk_t disk)
{
  VasEBoot_cryptodisk_t dev = (VasEBoot_cryptodisk_t) disk->data;
  VasEBoot_disk_memberlist_t list = NULL;

  list = VasEBoot_malloc (sizeof (*list));
  if (list)
    {
      list->disk = dev->source_disk;
      list->next = NULL;
    }

  return list;
}
#endif

static void
cryptodisk_cleanup (void)
{
#if 0
  VasEBoot_cryptodisk_t dev = cryptodisk_list;
  VasEBoot_cryptodisk_t tmp;

  while (dev != NULL)
    {
      VasEBoot_free (dev->source);
      VasEBoot_free (dev->cipher);
      VasEBoot_free (dev->secondary_cipher);
      VasEBoot_free (dev->essiv_cipher);
      tmp = dev->next;
      VasEBoot_free (dev);
      dev = tmp;
    }
#endif
}

VasEBoot_err_t
VasEBoot_cryptodisk_insert (VasEBoot_cryptodisk_t newdev, const char *name,
			VasEBoot_disk_t source)
{
  newdev->source = VasEBoot_strdup (name);
  if (!newdev->source)
    {
      VasEBoot_free (newdev);
      return VasEBoot_errno;
    }

  newdev->id = last_cryptodisk_id++;
  newdev->source_id = source->id;
  newdev->source_dev_id = source->dev->id;
  newdev->partition_start = VasEBoot_partition_get_start (source->partition);
  newdev->next = cryptodisk_list;
  cryptodisk_list = newdev;

  return VasEBoot_ERR_NONE;
}

VasEBoot_cryptodisk_t
VasEBoot_cryptodisk_get_by_uuid (const char *uuid)
{
  VasEBoot_cryptodisk_t dev;
  for (dev = cryptodisk_list; dev != NULL; dev = dev->next)
    if (VasEBoot_strcasecmp (dev->uuid, uuid) == 0)
      return dev;
  return NULL;
}

VasEBoot_cryptodisk_t
VasEBoot_cryptodisk_get_by_source_disk (VasEBoot_disk_t disk)
{
  VasEBoot_cryptodisk_t dev;
  for (dev = cryptodisk_list; dev != NULL; dev = dev->next)
    if (dev->source_id == disk->id && dev->source_dev_id == disk->dev->id)
      if ((disk->partition && VasEBoot_partition_get_start (disk->partition) == dev->partition_start) ||
          (!disk->partition && dev->partition_start == 0))
        return dev;
  return NULL;
}

#ifdef VasEBoot_UTIL
VasEBoot_err_t
VasEBoot_cryptodisk_cheat_insert (VasEBoot_cryptodisk_t newdev, const char *name,
			      VasEBoot_disk_t source, const char *cheat)
{
  newdev->cheat = VasEBoot_strdup (cheat);
  newdev->source = VasEBoot_strdup (name);
  if (!newdev->source || !newdev->cheat)
    {
      VasEBoot_free (newdev->source);
      VasEBoot_free (newdev->cheat);
      return VasEBoot_errno;
    }

  newdev->cheat_fd = VasEBoot_UTIL_FD_INVALID;
  newdev->source_id = source->id;
  newdev->source_dev_id = source->dev->id;
  newdev->partition_start = VasEBoot_partition_get_start (source->partition);
  newdev->id = last_cryptodisk_id++;
  newdev->next = cryptodisk_list;
  cryptodisk_list = newdev;

  return VasEBoot_ERR_NONE;
}

void
VasEBoot_util_cryptodisk_get_abstraction (VasEBoot_disk_t disk,
				      void (*cb) (const char *val, void *data),
				      void *data)
{
  VasEBoot_cryptodisk_t dev = (VasEBoot_cryptodisk_t) disk->data;

  cb ("cryptodisk", data);
  cb (dev->modname, data);

  if (dev->cipher)
    cb (dev->cipher->cipher->modname, data);
  if (dev->secondary_cipher)
    cb (dev->secondary_cipher->cipher->modname, data);
  if (dev->essiv_cipher)
    cb (dev->essiv_cipher->cipher->modname, data);
  if (dev->hash)
    cb (dev->hash->modname, data);
  if (dev->essiv_hash)
    cb (dev->essiv_hash->modname, data);
  if (dev->iv_hash)
    cb (dev->iv_hash->modname, data);
}

const char *
VasEBoot_util_cryptodisk_get_uuid (VasEBoot_disk_t disk)
{
  VasEBoot_cryptodisk_t dev = (VasEBoot_cryptodisk_t) disk->data;
  return dev->uuid;
}

#endif

static int check_boot, have_it;
static char *search_uuid;

static void
cryptodisk_close (VasEBoot_cryptodisk_t dev)
{
  VasEBoot_crypto_cipher_close (dev->cipher);
  VasEBoot_crypto_cipher_close (dev->secondary_cipher);
  VasEBoot_crypto_cipher_close (dev->essiv_cipher);
  VasEBoot_free (dev);
}

static VasEBoot_err_t
VasEBoot_cryptodisk_scan_device_real (const char *name, VasEBoot_disk_t source)
{
  VasEBoot_err_t err;
  VasEBoot_cryptodisk_t dev;
  VasEBoot_cryptodisk_dev_t cr;

  dev = VasEBoot_cryptodisk_get_by_source_disk (source);

  if (dev)
    return VasEBoot_ERR_NONE;

  FOR_CRYPTODISK_DEVS (cr)
  {
    dev = cr->scan (source, search_uuid, check_boot);
    if (VasEBoot_errno)
      return VasEBoot_errno;
    if (!dev)
      continue;
    
    err = cr->recover_key (source, dev);
    if (err)
    {
      cryptodisk_close (dev);
      return err;
    }

    VasEBoot_cryptodisk_insert (dev, name, source);

    have_it = 1;

    return VasEBoot_ERR_NONE;
  }
  return VasEBoot_ERR_NONE;
}

#ifdef VasEBoot_UTIL
#include <VasEBoot/util/misc.h>
VasEBoot_err_t
VasEBoot_cryptodisk_cheat_mount (const char *sourcedev, const char *cheat)
{
  VasEBoot_err_t err;
  VasEBoot_cryptodisk_t dev;
  VasEBoot_cryptodisk_dev_t cr;
  VasEBoot_disk_t source;

  /* Try to open disk.  */
  source = VasEBoot_disk_open (sourcedev);
  if (!source)
    return VasEBoot_errno;

  dev = VasEBoot_cryptodisk_get_by_source_disk (source);

  if (dev)
    {
      VasEBoot_disk_close (source);	
      return VasEBoot_ERR_NONE;
    }

  FOR_CRYPTODISK_DEVS (cr)
  {
    dev = cr->scan (source, search_uuid, check_boot);
    if (VasEBoot_errno)
      return VasEBoot_errno;
    if (!dev)
      continue;

    VasEBoot_util_info ("cheatmounted %s (%s) at %s", sourcedev, dev->modname,
		    cheat);
    err = VasEBoot_cryptodisk_cheat_insert (dev, sourcedev, source, cheat);
    VasEBoot_disk_close (source);
    if (err)
      VasEBoot_free (dev);

    return VasEBoot_ERR_NONE;
  }

  VasEBoot_disk_close (source);

  return VasEBoot_ERR_NONE;
}
#endif

static int
VasEBoot_cryptodisk_scan_device (const char *name,
			     void *data __attribute__ ((unused)))
{
  VasEBoot_err_t err;
  VasEBoot_disk_t source;

  /* Try to open disk.  */
  source = VasEBoot_disk_open (name);
  if (!source)
    {
      VasEBoot_print_error ();
      return 0;
    }

  err = VasEBoot_cryptodisk_scan_device_real (name, source);

  VasEBoot_disk_close (source);
  
  if (err)
    VasEBoot_print_error ();
  return have_it && search_uuid ? 1 : 0;
}

static VasEBoot_err_t
VasEBoot_cmd_cryptomount (VasEBoot_extcmd_context_t ctxt, int argc, char **args)
{
  struct VasEBoot_arg_list *state = ctxt->state;

  if (argc < 1 && !state[1].set && !state[2].set)
    return VasEBoot_error (VasEBoot_ERR_BAD_ARGUMENT, "device name required");

  have_it = 0;
  if (state[0].set)
    {
      VasEBoot_cryptodisk_t dev;

      dev = VasEBoot_cryptodisk_get_by_uuid (args[0]);
      if (dev)
	{
	  VasEBoot_dprintf ("cryptodisk",
			"already mounted as crypto%lu\n", dev->id);
	  return VasEBoot_ERR_NONE;
	}

      check_boot = state[2].set;
      search_uuid = args[0];
      VasEBoot_device_iterate (&VasEBoot_cryptodisk_scan_device, NULL);
      search_uuid = NULL;

      if (!have_it)
	return VasEBoot_error (VasEBoot_ERR_BAD_ARGUMENT, "no such cryptodisk found");
      return VasEBoot_ERR_NONE;
    }
  else if (state[1].set || (argc == 0 && state[2].set))
    {
      search_uuid = NULL;
      check_boot = state[2].set;
      VasEBoot_device_iterate (&VasEBoot_cryptodisk_scan_device, NULL);
      search_uuid = NULL;
      return VasEBoot_ERR_NONE;
    }
  else
    {
      VasEBoot_err_t err;
      VasEBoot_disk_t disk;
      VasEBoot_cryptodisk_t dev;
      char *diskname;
      char *disklast = NULL;
      VasEBoot_size_t len;

      search_uuid = NULL;
      check_boot = state[2].set;
      diskname = args[0];
      len = VasEBoot_strlen (diskname);
      if (len && diskname[0] == '(' && diskname[len - 1] == ')')
	{
	  disklast = &diskname[len - 1];
	  *disklast = '\0';
	  diskname++;
	}

      disk = VasEBoot_disk_open (diskname);
      if (!disk)
	{
	  if (disklast)
	    *disklast = ')';
	  return VasEBoot_errno;
	}

      dev = VasEBoot_cryptodisk_get_by_source_disk (disk);
      if (dev)
	{
	  VasEBoot_dprintf ("cryptodisk", "already mounted as crypto%lu\n", dev->id);
	  VasEBoot_disk_close (disk);
	  if (disklast)
	    *disklast = ')';
	  return VasEBoot_ERR_NONE;
	}

      err = VasEBoot_cryptodisk_scan_device_real (diskname, disk);

      VasEBoot_disk_close (disk);
      if (disklast)
	*disklast = ')';

      return err;
    }
}

static struct VasEBoot_disk_dev VasEBoot_cryptodisk_dev = {
  .name = "cryptodisk",
  .id = VasEBoot_DISK_DEVICE_CRYPTODISK_ID,
  .iterate = VasEBoot_cryptodisk_iterate,
  .open = VasEBoot_cryptodisk_open,
  .close = VasEBoot_cryptodisk_close,
  .read = VasEBoot_cryptodisk_read,
  .write = VasEBoot_cryptodisk_write,
#ifdef VasEBoot_UTIL
  .memberlist = VasEBoot_cryptodisk_memberlist,
#endif
  .next = 0
};

static char
hex (VasEBoot_uint8_t val)
{
  if (val < 10)
    return '0' + val;
  return 'a' + val - 10;
}

/* Open a file named NAME and initialize FILE.  */
static char *
luks_script_get (VasEBoot_size_t *sz)
{
  VasEBoot_cryptodisk_t i;
  VasEBoot_size_t size = 0;
  char *ptr, *ret;

  *sz = 0;

  for (i = cryptodisk_list; i != NULL; i = i->next)
    if (VasEBoot_strcmp (i->modname, "luks") == 0)
      {
	size += sizeof ("luks_mount ");
	size += VasEBoot_strlen (i->uuid);
	size += VasEBoot_strlen (i->cipher->cipher->name);
	size += 54;
	if (i->essiv_hash)
	  size += VasEBoot_strlen (i->essiv_hash->name);
	size += i->keysize * 2;
      }

  ret = VasEBoot_malloc (size + 1);
  if (!ret)
    return 0;

  ptr = ret;

  for (i = cryptodisk_list; i != NULL; i = i->next)
    if (VasEBoot_strcmp (i->modname, "luks") == 0)
      {
	unsigned j;
	const char *iptr;
	ptr = VasEBoot_stpcpy (ptr, "luks_mount ");
	ptr = VasEBoot_stpcpy (ptr, i->uuid);
	*ptr++ = ' ';
	VasEBoot_snprintf (ptr, 21, "%" PRIuVasEBoot_UINT64_T " ", i->offset);
	while (*ptr)
	  ptr++;
	for (iptr = i->cipher->cipher->name; *iptr; iptr++)
	  *ptr++ = VasEBoot_tolower (*iptr);
	switch (i->mode)
	  {
	  case VasEBoot_CRYPTODISK_MODE_ECB:
	    ptr = VasEBoot_stpcpy (ptr, "-ecb"); 
	    break;
	  case VasEBoot_CRYPTODISK_MODE_CBC:
	    ptr = VasEBoot_stpcpy (ptr, "-cbc");
	    break;
	  case VasEBoot_CRYPTODISK_MODE_PCBC:
	    ptr = VasEBoot_stpcpy (ptr, "-pcbc");
	    break;
	  case VasEBoot_CRYPTODISK_MODE_XTS:
	    ptr = VasEBoot_stpcpy (ptr, "-xts");
	    break;
	  case VasEBoot_CRYPTODISK_MODE_LRW:
	    ptr = VasEBoot_stpcpy (ptr, "-lrw");
	    break;
	  }

	switch (i->mode_iv)
	  {
	  case VasEBoot_CRYPTODISK_MODE_IV_NULL:
	    ptr = VasEBoot_stpcpy (ptr, "-null"); 
	    break;
	  case VasEBoot_CRYPTODISK_MODE_IV_PLAIN:
	    ptr = VasEBoot_stpcpy (ptr, "-plain"); 
	    break;
	  case VasEBoot_CRYPTODISK_MODE_IV_PLAIN64:
	    ptr = VasEBoot_stpcpy (ptr, "-plain64"); 
	    break;
	  case VasEBoot_CRYPTODISK_MODE_IV_BENBI:
	    ptr = VasEBoot_stpcpy (ptr, "-benbi"); 
	    break;
	  case VasEBoot_CRYPTODISK_MODE_IV_ESSIV:
	    ptr = VasEBoot_stpcpy (ptr, "-essiv:"); 
	    ptr = VasEBoot_stpcpy (ptr, i->essiv_hash->name);
	    break;
	  case VasEBoot_CRYPTODISK_MODE_IV_BYTECOUNT64:
	  case VasEBoot_CRYPTODISK_MODE_IV_BYTECOUNT64_HASH:
	    break;
	  }
	*ptr++ = ' ';
	for (j = 0; j < i->keysize; j++)
	  {
	    *ptr++ = hex (i->key[j] >> 4);
	    *ptr++ = hex (i->key[j] & 0xf);
	  }
	*ptr++ = '\n';
      }
  *ptr = '\0';
  *sz = ptr - ret;
  return ret;
}

struct VasEBoot_procfs_entry luks_script =
{
  .name = "luks_script",
  .get_contents = luks_script_get
};

static VasEBoot_extcmd_t cmd;

VasEBoot_MOD_INIT (cryptodisk)
{
  VasEBoot_disk_dev_register (&VasEBoot_cryptodisk_dev);
  cmd = VasEBoot_register_extcmd ("cryptomount", VasEBoot_cmd_cryptomount, 0,
			      N_("SOURCE|-u UUID|-a|-b"),
			      N_("Mount a crypto device."), options);
  VasEBoot_procfs_register ("luks_script", &luks_script);
}

VasEBoot_MOD_FINI (cryptodisk)
{
  VasEBoot_disk_dev_unregister (&VasEBoot_cryptodisk_dev);
  cryptodisk_cleanup ();
  VasEBoot_procfs_unregister (&luks_script);
}