/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2003,2007,2010,2011,2019  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT 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.
 *
 *  VAS_EBOOT 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 VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/cryptodisk.h>
#include <VasEBoot/types.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/dl.h>
#include <VasEBoot/err.h>
#include <VasEBoot/disk.h>
#include <VasEBoot/crypto.h>
#include <VasEBoot/partition.h>
#include <VasEBoot/i18n.h>

VAS_EBOOT_MOD_LICENSE ("GPLv3+");

#define LUKS_KEY_ENABLED  0x00AC71F3

/* On disk LUKS header */
struct VasEBoot_luks_phdr
{
  VasEBoot_uint8_t magic[6];
#define LUKS_MAGIC        "LUKS\xBA\xBE"
  VasEBoot_uint16_t version;
  char cipherName[32];
  char cipherMode[32];
  char hashSpec[32];
  VasEBoot_uint32_t payloadOffset;
  VasEBoot_uint32_t keyBytes;
  VasEBoot_uint8_t mkDigest[20];
  VasEBoot_uint8_t mkDigestSalt[32];
  VasEBoot_uint32_t mkDigestIterations;
  char uuid[40];
  struct
  {
    VasEBoot_uint32_t active;
    VasEBoot_uint32_t passwordIterations;
    VasEBoot_uint8_t passwordSalt[32];
    VasEBoot_uint32_t keyMaterialOffset;
    VasEBoot_uint32_t stripes;
  } keyblock[8];
} VAS_EBOOT_PACKED;

typedef struct VasEBoot_luks_phdr *VasEBoot_luks_phdr_t;

gcry_err_code_t AF_merge (const gcry_md_spec_t * hash, VasEBoot_uint8_t * src,
			  VasEBoot_uint8_t * dst, VasEBoot_size_t blocksize,
			  VasEBoot_size_t blocknumbers);

static VasEBoot_cryptodisk_t
luks_scan (VasEBoot_disk_t disk, VasEBoot_cryptomount_args_t cargs)
{
  VasEBoot_cryptodisk_t newdev;
  struct VasEBoot_luks_phdr header;
  char ciphername[sizeof (header.cipherName) + 1];
  char ciphermode[sizeof (header.cipherMode) + 1];
  char hashspec[sizeof (header.hashSpec) + 1];
  VasEBoot_err_t err;

  if (cargs->check_boot)
    return NULL;

  /* Read the LUKS header.  */
  err = VasEBoot_disk_read (disk, 0, 0, sizeof (header), &header);
  if (err)
    {
      if (err == VAS_EBOOT_ERR_OUT_OF_RANGE)
	VasEBoot_errno = VAS_EBOOT_ERR_NONE;
      return NULL;
    }

  /* Look for LUKS magic sequence.  */
  if (VasEBoot_memcmp (header.magic, LUKS_MAGIC, sizeof (header.magic))
      || VasEBoot_be_to_cpu16 (header.version) != 1)
    return NULL;

  if (cargs->search_uuid != NULL && VasEBoot_uuidcasecmp (cargs->search_uuid, header.uuid, sizeof (header.uuid)) != 0)
    {
      VasEBoot_dprintf ("luks", "%s != %s\n", header.uuid, cargs->search_uuid);
      return NULL;
    }

  /* Make sure that strings are null terminated.  */
  VasEBoot_memcpy (ciphername, header.cipherName, sizeof (header.cipherName));
  ciphername[sizeof (header.cipherName)] = 0;
  VasEBoot_memcpy (ciphermode, header.cipherMode, sizeof (header.cipherMode));
  ciphermode[sizeof (header.cipherMode)] = 0;
  VasEBoot_memcpy (hashspec, header.hashSpec, sizeof (header.hashSpec));
  hashspec[sizeof (header.hashSpec)] = 0;

  newdev = VasEBoot_zalloc (sizeof (struct VasEBoot_cryptodisk));
  if (!newdev)
      return NULL;
  newdev->offset_sectors = VasEBoot_be_to_cpu32 (header.payloadOffset);
  newdev->source_disk = NULL;
  newdev->log_sector_size = VAS_EBOOT_LUKS1_LOG_SECTOR_SIZE;
  newdev->total_sectors = VasEBoot_disk_native_sectors (disk) - newdev->offset_sectors;
  VasEBoot_memcpy (newdev->uuid, header.uuid, sizeof (header.uuid));
  newdev->modname = "luks";

  /* Configure the hash used for the AF splitter and HMAC.  */
  newdev->hash = VasEBoot_crypto_lookup_md_by_name (hashspec);
  if (!newdev->hash)
    {
      VasEBoot_free (newdev);
      VasEBoot_error (VAS_EBOOT_ERR_FILE_NOT_FOUND, "Couldn't load %s hash",
		  hashspec);
      return NULL;
    }

  err = VasEBoot_cryptodisk_setcipher (newdev, ciphername, ciphermode);
  if (err)
    {
      VasEBoot_free (newdev);
      return NULL;
    }

  COMPILE_TIME_ASSERT (sizeof (newdev->uuid) >= sizeof (header.uuid));
  return newdev;
}

static VasEBoot_err_t
luks_recover_key (VasEBoot_disk_t source,
		  VasEBoot_cryptodisk_t dev,
		  VasEBoot_cryptomount_args_t cargs)
{
  struct VasEBoot_luks_phdr header;
  VasEBoot_size_t keysize;
  VasEBoot_uint8_t *split_key = NULL;
  VasEBoot_uint8_t candidate_digest[sizeof (header.mkDigest)];
  unsigned i;
  VasEBoot_size_t length;
  VasEBoot_err_t err;
  VasEBoot_size_t max_stripes = 1;

  if (cargs->key_data == NULL || cargs->key_len == 0)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, "no key data");

  err = VasEBoot_disk_read (source, 0, 0, sizeof (header), &header);
  if (err)
    return err;

  VasEBoot_puts_ (N_("Attempting to decrypt master key..."));
  keysize = VasEBoot_be_to_cpu32 (header.keyBytes);
  if (keysize > VAS_EBOOT_CRYPTODISK_MAX_KEYLEN)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "key is too long");

  for (i = 0; i < ARRAY_SIZE (header.keyblock); i++)
    if (VasEBoot_be_to_cpu32 (header.keyblock[i].active) == LUKS_KEY_ENABLED
	&& VasEBoot_be_to_cpu32 (header.keyblock[i].stripes) > max_stripes)
      max_stripes = VasEBoot_be_to_cpu32 (header.keyblock[i].stripes);

  split_key = VasEBoot_calloc (keysize, max_stripes);
  if (!split_key)
    return VasEBoot_errno;

  /* Try to recover master key from each active keyslot.  */
  for (i = 0; i < ARRAY_SIZE (header.keyblock); i++)
    {
      gcry_err_code_t gcry_err;
      VasEBoot_uint8_t candidate_key[VAS_EBOOT_CRYPTODISK_MAX_KEYLEN];
      VasEBoot_uint8_t digest[VAS_EBOOT_CRYPTODISK_MAX_KEYLEN];

      /* Check if keyslot is enabled.  */
      if (VasEBoot_be_to_cpu32 (header.keyblock[i].active) != LUKS_KEY_ENABLED)
	continue;

      VasEBoot_dprintf ("luks", "Trying keyslot %d\n", i);

      /* Calculate the PBKDF2 of the user supplied passphrase.  */
      gcry_err = VasEBoot_crypto_pbkdf2 (dev->hash, cargs->key_data,
				     cargs->key_len,
				     header.keyblock[i].passwordSalt,
				     sizeof (header.keyblock[i].passwordSalt),
				     VasEBoot_be_to_cpu32 (header.keyblock[i].
						       passwordIterations),
				     digest, keysize);

      if (gcry_err)
	{
	  VasEBoot_free (split_key);
	  return VasEBoot_crypto_gcry_error (gcry_err);
	}

      VasEBoot_dprintf ("luks", "PBKDF2 done\n");

      gcry_err = VasEBoot_cryptodisk_setkey (dev, digest, keysize);
      if (gcry_err)
	{
	  VasEBoot_free (split_key);
	  return VasEBoot_crypto_gcry_error (gcry_err);
	}

      length = (keysize * VasEBoot_be_to_cpu32 (header.keyblock[i].stripes));

      /* Read and decrypt the key material from the disk.  */
      err = VasEBoot_disk_read (source,
			    VasEBoot_be_to_cpu32 (header.keyblock
					      [i].keyMaterialOffset), 0,
			    length, split_key);
      if (err)
	{
	  VasEBoot_free (split_key);
	  return err;
	}

      gcry_err = VasEBoot_cryptodisk_decrypt (dev, split_key, length, 0,
					  VAS_EBOOT_LUKS1_LOG_SECTOR_SIZE);
      if (gcry_err)
	{
	  VasEBoot_free (split_key);
	  return VasEBoot_crypto_gcry_error (gcry_err);
	}

      /* Merge the decrypted key material to get the candidate master key.  */
      gcry_err = AF_merge (dev->hash, split_key, candidate_key, keysize,
			   VasEBoot_be_to_cpu32 (header.keyblock[i].stripes));
      if (gcry_err)
	{
	  VasEBoot_free (split_key);
	  return VasEBoot_crypto_gcry_error (gcry_err);
	}

      VasEBoot_dprintf ("luks", "candidate key recovered\n");

      /* Calculate the PBKDF2 of the candidate master key.  */
      gcry_err = VasEBoot_crypto_pbkdf2 (dev->hash, candidate_key,
				     VasEBoot_be_to_cpu32 (header.keyBytes),
				     header.mkDigestSalt,
				     sizeof (header.mkDigestSalt),
				     VasEBoot_be_to_cpu32
				     (header.mkDigestIterations),
				     candidate_digest,
				     sizeof (candidate_digest));
      if (gcry_err)
	{
	  VasEBoot_free (split_key);
	  return VasEBoot_crypto_gcry_error (gcry_err);
	}

      /* Compare the calculated PBKDF2 to the digest stored
         in the header to see if it's correct.  */
      if (VasEBoot_memcmp (candidate_digest, header.mkDigest,
		       sizeof (header.mkDigest)) != 0)
	{
	  VasEBoot_dprintf ("luks", "bad digest\n");
	  continue;
	}

      /* TRANSLATORS: It's a cryptographic key slot: one element of an array
	 where each element is either empty or holds a key.  */
      VasEBoot_printf_ (N_("Slot %d opened\n"), i);

      /* Set the master key.  */
      gcry_err = VasEBoot_cryptodisk_setkey (dev, candidate_key, keysize);
      if (gcry_err)
	{
	  VasEBoot_free (split_key);
	  return VasEBoot_crypto_gcry_error (gcry_err);
	}

      VasEBoot_free (split_key);

      return VAS_EBOOT_ERR_NONE;
    }

  VasEBoot_free (split_key);
  return VAS_EBOOT_ACCESS_DENIED;
}

struct VasEBoot_cryptodisk_dev luks_crypto = {
  .scan = luks_scan,
  .recover_key = luks_recover_key
};

VAS_EBOOT_MOD_INIT (luks)
{
  COMPILE_TIME_ASSERT (sizeof (((struct VasEBoot_luks_phdr *) 0)->uuid)
		       < VAS_EBOOT_CRYPTODISK_MAX_UUID_LENGTH);
  VasEBoot_cryptodisk_dev_register (&luks_crypto);
}

VAS_EBOOT_MOD_FINI (luks)
{
  VasEBoot_cryptodisk_dev_unregister (&luks_crypto);
}