// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * utils - miscellaneous device utilities for cryptsetup

 *

 * Copyright (C) 2004 Jana Saout <jana@saout.de>

 * Copyright (C) 2004-2007 Clemens Fruhwirth <clemens@endorphin.org>

 * Copyright (C) 2009-2026 Red Hat, Inc. All rights reserved.

 * Copyright (C) 2009-2026 Milan Broz

 */

#include <stdio.h>

#include <errno.h>

#include <sys/mman.h>

#include <sys/resource.h>

#include <sys/stat.h>

#include <sys/utsname.h>

#include "internal.h"

#include "utils_storage_wrappers.h"

#define MAX_CAPI_LEN_STR "143" /* for sscanf of crypto API string + 16  + \0 */

size_t crypt_getpagesize(void)

{

  long r = sysconf(_SC_PAGESIZE);

  return r <= 0 ? DEFAULT_MEM_ALIGNMENT : (size_t)r;

}

unsigned crypt_cpusonline(void)

{

  long r = sysconf(_SC_NPROCESSORS_ONLN);

  return r < 0 ? 1 : r;

}

uint64_t crypt_getphysmemory_kb(void)

{

  long pagesize, phys_pages;

  uint64_t phys_memory_kb, page_size_kb;

  pagesize = sysconf(_SC_PAGESIZE);

  phys_pages = sysconf(_SC_PHYS_PAGES);

  if (pagesize <= 0 || phys_pages <= 0)

    return 0;

  page_size_kb = pagesize / 1024;

  phys_memory_kb = page_size_kb * phys_pages;

  /* sanity check for overflow */

  if (phys_memory_kb / phys_pages != page_size_kb)

    return 0;

  /* coverity[return_overflow:FALSE] */

  return phys_memory_kb;

}

uint64_t crypt_getphysmemoryfree_kb(void)

{

  long pagesize, phys_pages;

  uint64_t phys_memoryfree_kb, page_size_kb;

  pagesize = sysconf(_SC_PAGESIZE);

  phys_pages = sysconf(_SC_AVPHYS_PAGES);

  if (pagesize <= 0 || phys_pages <= 0)

    return 0;

  page_size_kb = pagesize / 1024;

  phys_memoryfree_kb = page_size_kb * phys_pages;

  /* sanity check for overflow */

  if (phys_memoryfree_kb / phys_pages != page_size_kb)

    return 0;

  /* coverity[return_overflow:FALSE] */

  return phys_memoryfree_kb;

}

bool crypt_swapavailable(void)

{

  int fd;

  ssize_t size;

  char buf[4096], *p;

  uint64_t total;

  if ((fd = open("/proc/meminfo", O_RDONLY)) < 0)

    return true;

  size = read(fd, buf, sizeof(buf));

  close(fd);

  if (size < 1)

    return true;

  if (size < (ssize_t)sizeof(buf))

    buf[size] = 0;

  else

    buf[sizeof(buf) - 1] = 0;

  p = strstr(buf, "SwapTotal:");

  if (!p)

    return true;

  if (sscanf(p, "SwapTotal: %" PRIu64 " kB", &total) != 1)

    return true;

  return total > 0;

}

void crypt_process_priority(struct crypt_device *cd, int *priority, bool raise)

{

  int _priority, new_priority;

  if (raise) {

    _priority = getpriority(PRIO_PROCESS, 0);

    if (_priority < 0)

      _priority = 0;

    if (priority)

      *priority = _priority;

    /*

     * Do not bother checking CAP_SYS_NICE as device activation

     * requires CAP_SYSADMIN later anyway.

     */

    if (getuid() || geteuid())

      new_priority = 0;

    else

      new_priority = -18;

    if (setpriority(PRIO_PROCESS, 0, new_priority))

      log_dbg(cd, "Cannot raise process priority.");

  } else {

    _priority = priority ? *priority : 0;

    if (setpriority(PRIO_PROCESS, 0, _priority))

      log_dbg(cd, "Cannot reset process priority.");

  }

}

/* Keyfile processing */

/*

 * A simple call to lseek(3) might not be possible for some inputs (e.g.

 * reading from a pipe), so this function instead reads of up to BUFSIZ bytes

 * at a time until the specified number of bytes. It returns -1 on read error

 * or when it reaches EOF before the requested number of bytes have been

 * discarded.

 */

static int keyfile_seek(int fd, uint64_t bytes)

{

  char tmp[BUFSIZ];

  size_t next_read;

  ssize_t bytes_r;

  off_t r;

  r = lseek(fd, bytes, SEEK_CUR);

  if (r > 0)

    return 0;

  if (r < 0 && errno != ESPIPE)

    return -1;

  while (bytes > 0) {

    /* figure out how much to read */

    next_read = bytes > sizeof(tmp) ? sizeof(tmp) : (size_t)bytes;

    bytes_r = read(fd, tmp, next_read);

    if (bytes_r < 0) {

      if (errno == EINTR)

        continue;

      crypt_safe_memzero(tmp, sizeof(tmp));

      /* read error */

      return -1;

    }

    if (bytes_r == 0)

      /* EOF */

      break;

    bytes -= bytes_r;

  }

  crypt_safe_memzero(tmp, sizeof(tmp));

  return bytes == 0 ? 0 : -1;

}

int crypt_keyfile_device_read(struct crypt_device *cd,  const char *keyfile,

            char **key, size_t *key_size_read,

            uint64_t keyfile_offset, size_t key_size,

            uint32_t flags)

{

  int fd, regular_file, char_to_read = 0, char_read = 0, unlimited_read = 0;

  int r = -EINVAL, newline;

  char *pass = NULL;

  size_t buflen, i;

  uint64_t file_read_size;

  struct stat st;

  bool close_fd = false;

  if (!key || !key_size_read)

    return -EINVAL;

  *key = NULL;

  *key_size_read = 0;

  if (keyfile) {

    fd = open(keyfile, O_RDONLY);

    if (fd < 0) {

      log_err(cd, _("Failed to open key file."));

      return -EINVAL;

    }

    close_fd = true;

  } else

    fd = STDIN_FILENO;

  if (isatty(fd)) {

    log_err(cd, _("Cannot read keyfile from a terminal."));

    goto out;

  }

  /* If not requested otherwise, we limit input to prevent memory exhaustion */

  if (key_size == 0) {

    key_size = DEFAULT_KEYFILE_SIZE_MAXKB * 1024 + 1;

    unlimited_read = 1;

    /* use 4k for buffer (page divisor but avoid huge pages) */

    buflen = 4096 - 16; /* sizeof(struct safe_allocation); */

  } else

    buflen = key_size;

  regular_file = 0;

  if (keyfile) {

    if (stat(keyfile, &st) < 0) {

      log_err(cd, _("Failed to stat key file."));

      goto out;

    }

    if (S_ISREG(st.st_mode)) {

      regular_file = 1;

      file_read_size = (uint64_t)st.st_size;

      if (keyfile_offset > file_read_size) {

        log_err(cd, _("Cannot seek to requested keyfile offset."));

        goto out;

      }

      file_read_size -= keyfile_offset;

      /* known keyfile size, alloc it in one step */

      if (file_read_size >= (uint64_t)key_size)

        buflen = key_size;

      else if (file_read_size)

        buflen = file_read_size;

    }

  }

  pass = crypt_safe_alloc(buflen);

  if (!pass) {

    log_err(cd, _("Out of memory while reading passphrase."));

    goto out;

  }

  /* Discard keyfile_offset bytes on input */

  if (keyfile_offset && keyfile_seek(fd, keyfile_offset) < 0) {

    log_err(cd, _("Cannot seek to requested keyfile offset."));

    goto out;

  }

  for (i = 0, newline = 0; i < key_size; i += char_read) {

    if (i == buflen) {

      buflen += 4096;

      pass = crypt_safe_realloc(pass, buflen);

      if (!pass) {

        log_err(cd, _("Out of memory while reading passphrase."));

        r = -ENOMEM;

        goto out;

      }

    }

    if (flags & CRYPT_KEYFILE_STOP_EOL) {

      /* If we should stop on newline, we must read the input

       * one character at the time. Otherwise we might end up

       * having read some bytes after the newline, which we

       * promised not to do.

       */

      char_to_read = 1;

    } else {

      /* char_to_read = min(key_size - i, buflen - i) */

      char_to_read = key_size < buflen ?

        key_size - i : buflen - i;

    }

    char_read = read_buffer(fd, &pass[i], char_to_read);

    if (char_read < 0) {

      log_err(cd, _("Error reading passphrase."));

      r = -EPIPE;

      goto out;

    }

    if (char_read == 0)

      break;

    /* Stop on newline only if not requested read from keyfile */

    if ((flags & CRYPT_KEYFILE_STOP_EOL) && pass[i] == '\n') {

      newline = 1;

      pass[i] = '\0';

      break;

    }

  }

  /* Fail if piped input dies reading nothing */

  if (!i && !regular_file && !newline) {

    log_err(cd, _("Nothing to read on input."));

    r = -EPIPE;

    goto out;

  }

  /* Fail if we exceeded internal default (no specified size) */

  if (unlimited_read && i == key_size) {

    log_err(cd, _("Maximum keyfile size exceeded."));

    goto out;

  }

  if (!unlimited_read && i != key_size) {

    log_err(cd, _("Cannot read requested amount of data."));

    goto out;

  }

  *key = pass;

  *key_size_read = i;

  r = 0;

out:

  if (close_fd)

    close(fd);

  if (r)

    crypt_safe_free(pass);

  return r;

}

int crypt_keyfile_read(struct crypt_device *cd,  const char *keyfile,

           char **key, size_t *key_size_read,

           size_t keyfile_offset, size_t keyfile_size_max,

           uint32_t flags)

{

  return crypt_keyfile_device_read(cd, keyfile, key, key_size_read,

           keyfile_offset, keyfile_size_max, flags);

}

int kernel_version(uint64_t *kversion)

{

  struct utsname uts;

  uint16_t maj, min, patch, rel;

  int r = -EINVAL;

  if (uname(&uts) < 0)

    return r;

  if (sscanf(uts.release, "%" SCNu16  ".%" SCNu16 ".%" SCNu16 "-%" SCNu16,

       &maj, &min, &patch, &rel) == 4)

    r = 0;

  else if (sscanf(uts.release,  "%" SCNu16 ".%" SCNu16 ".%" SCNu16,

      &maj, &min, &patch) == 3) {

    rel = 0;

    r = 0;

  }

  if (!r)

    *kversion = compact_version(maj, min, patch, rel);

  return r;

}

bool crypt_string_in(const char *str, char **list, size_t list_size)

{

  size_t i;

  for (i = 0; *list && i < list_size; i++, list++)

    if (!strcmp(str, *list))

      return true;

  return false;

}

/* compare two strings (allows NULL values) */

int crypt_strcmp(const char *a, const char *b)

{

  if (!a && !b)

    return 0;

  else if (!a || !b)

    return 1;

  return strcmp(a, b);

}

int crypt_check_cipher(struct crypt_device *cd,

           size_t keylength,

           const char *cipher,

           const char *cipher_mode)

{

  int r;

  char cipher_spec[2*MAX_CAPI_ONE_LEN], buf[SECTOR_SIZE], *empty_key;

  struct crypt_storage *s = NULL;

  struct volume_key *empty_vk = NULL;

  struct crypt_storage_wrapper *csw = NULL;

  log_dbg(cd, "Checking if cipher %s-%s is usable (storage wrapper).", cipher, cipher_mode);

  empty_key = malloc(keylength);

  if (!empty_key)

    return -ENOMEM;

  /* No need to get KEY quality random but it must avoid known weak keys. */

  r = crypt_random_get(cd, empty_key, keylength, CRYPT_RND_NORMAL);

  if (r < 0)

    goto out;

  r = crypt_storage_init(&s, SECTOR_SIZE, cipher, cipher_mode, empty_key, keylength, false);

  if (!r) {

    memset(buf, 0, sizeof(buf));

    r = crypt_storage_decrypt(s, 0, sizeof(buf), buf);

  }

  /* dm-crypt backend requires root access */

  if (!r || (getuid() || geteuid()))

    goto out;

  if (*cipher_mode != '\0')

    r = snprintf(cipher_spec, sizeof(cipher_spec), "%s-%s", cipher, cipher_mode);

  else

    r = snprintf(cipher_spec, sizeof(cipher_spec), "%s", cipher);

  if (r < 0 || (size_t)r >= sizeof(cipher_spec)) {

    r = -EINVAL;

    goto out;

  }

  empty_vk = crypt_alloc_volume_key(keylength, empty_key);

  if (!empty_vk) {

    r = -ENOMEM;

    goto out;

  }

  r = crypt_storage_wrapper_init(cd, &csw, crypt_metadata_device(cd), 0, 0, SECTOR_SIZE,

               cipher_spec, empty_vk, CSW_DMCRYPT_ONLY | CSW_OPEN_READONLY);

  if (r)

    goto out;

  memset(buf, 0, sizeof(buf));

  r = crypt_storage_wrapper_read_decrypt(csw, 0, &buf, sizeof(buf));

  crypt_safe_memzero(buf, sizeof(buf));

  if (r < 0 || (size_t)r != sizeof(buf))

    r = -EIO;

  else

    r = 0;

out:

  crypt_storage_destroy(s);

  free(empty_key);

  crypt_storage_wrapper_destroy(csw);

  crypt_free_volume_key(empty_vk);

  return r;

}

int crypt_capi_to_cipher(char **org_c, char **org_i, const char *c_dm, const char *i_dm)

{

  char cipher[MAX_CAPI_ONE_LEN], mode[MAX_CAPI_ONE_LEN], iv[MAX_CAPI_ONE_LEN],

       auth[MAX_CAPI_ONE_LEN], tmp[MAX_CAPI_LEN], dmcrypt_tmp[MAX_CAPI_LEN*2],

       capi[MAX_CAPI_LEN+1];

  size_t len;

  int i;

  if (!c_dm)

    return -EINVAL;

  /* legacy mode */

  if (strncmp(c_dm, "capi:", 5)) {

    if (!(*org_c = strdup(c_dm)))

      return -ENOMEM;

    if (i_dm) {

      if (!(*org_i = strdup(i_dm))) {

        free(*org_c);

        *org_c = NULL;

        return -ENOMEM;

      }

    } else

      *org_i = NULL;

    return 0;

  }

  /* modes with capi: prefix */

  i = sscanf(c_dm, "capi:%" MAX_CAPI_LEN_STR "[^-]-%" MAX_CAPI_ONE_LEN_STR "s", tmp, iv);

  if (i != 2)

    return -EINVAL;

  /* non-cryptsetup compatible mode (generic driver with dash?) */

  if (strrchr(iv, ')')) {

    if (i_dm)

      return -EINVAL;

    if (!(*org_c = strdup(c_dm)))

      return -ENOMEM;

    return 0;

  }

  len = strlen(tmp);

  if (len < 2)

    return -EINVAL;

  if (tmp[len-1] == ')')

    tmp[len-1] = '\0';

  if (sscanf(tmp, "rfc4309(%" MAX_CAPI_LEN_STR "s", capi) == 1) {

    if (!(*org_i = strdup("aead")))

      return -ENOMEM;

  } else if (sscanf(tmp, "rfc7539(%" MAX_CAPI_LEN_STR "[^,],%" MAX_CAPI_ONE_LEN_STR "s", capi, auth) == 2) {

    if (!(*org_i = strdup(auth)))

      return -ENOMEM;

  } else if (sscanf(tmp, "authenc(%" MAX_CAPI_ONE_LEN_STR "[^,],%" MAX_CAPI_LEN_STR "s", auth, capi) == 2) {

    if (!(*org_i = strdup(auth)))

      return -ENOMEM;

  } else {

    if (i_dm) {

      if (!(*org_i = strdup(i_dm)))

        return -ENOMEM;

    } else

      *org_i = NULL;

    memset(capi, 0, sizeof(capi));

    strncpy(capi, tmp, sizeof(capi)-1);

  }

  i = sscanf(capi, "%" MAX_CAPI_ONE_LEN_STR "[^(](%" MAX_CAPI_ONE_LEN_STR "[^)])", mode, cipher);

  if (i == 2)

    i = snprintf(dmcrypt_tmp, sizeof(dmcrypt_tmp), "%s-%s-%s", cipher, mode, iv);

  else

    i = snprintf(dmcrypt_tmp, sizeof(dmcrypt_tmp), "%s-%s", capi, iv);

  if (i < 0 || (size_t)i >= sizeof(dmcrypt_tmp)) {

    free(*org_i);

    *org_i = NULL;

    return -EINVAL;

  }

  if (!(*org_c = strdup(dmcrypt_tmp))) {

    free(*org_i);

    *org_i = NULL;

    return -ENOMEM;

  }

  return 0;

}