/src/gnutls/lib/accelerated/afalg.c

Source (jump to first uncovered line)
/*
 * Copyright (C) 2017 Stephan Mueller <smueller@chronox.de>
 *
 * Author: Stephan Mueller
 *
 * This code is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "config.h"

#include "accelerated/afalg.h"

#ifdef ENABLE_AFALG

#include "errors.h"
#include "gnutls_int.h"

#include <gnutls/crypto.h>
#include <kcapi.h>
#include <limits.h>
#include "malloca.h"

/************************ Symmetric cipher algorithms ************************/

struct kcapi_ctx {
  struct kcapi_handle *handle;
  int enc;
  uint8_t iv[MAX_CIPHER_IV_SIZE];
};

static const char *gnutls_cipher_map[] = {
  [GNUTLS_CIPHER_AES_128_CBC] = "cbc(aes)",
  [GNUTLS_CIPHER_AES_192_CBC] = "cbc(aes)",
  [GNUTLS_CIPHER_AES_256_CBC] = "cbc(aes)",
  [GNUTLS_CIPHER_3DES_CBC] = "cbc(des3_ede)",
  [GNUTLS_CIPHER_CAMELLIA_128_CBC] = "cbc(camellia)",
  [GNUTLS_CIPHER_CAMELLIA_192_CBC] = "cbc(camellia)",
  [GNUTLS_CIPHER_CAMELLIA_256_CBC] = "cbc(camellia)",
  [GNUTLS_CIPHER_SALSA20_256] = "salsa20",
  [GNUTLS_CIPHER_AES_128_XTS] = "xts(aes)",
  [GNUTLS_CIPHER_AES_256_XTS] = "xts(aes)",
};

static int afalg_cipher_init(gnutls_cipher_algorithm_t algorithm, void **_ctx,
           int enc)
{
  struct kcapi_handle *handle;
  struct kcapi_ctx *ctx;

  if (kcapi_cipher_init(&handle, gnutls_cipher_map[algorithm], 0) < 0) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  if (unlikely(kcapi_cipher_ivsize(handle) > MAX_CIPHER_IV_SIZE)) {
    gnutls_assert();
    return GNUTLS_E_INTERNAL_ERROR;
  }

  ctx = gnutls_malloc(sizeof(struct kcapi_ctx));
  if (ctx == NULL) {
    gnutls_assert();
    kcapi_cipher_destroy(handle);
    return GNUTLS_E_MEMORY_ERROR;
  }

  ctx->handle = handle;
  ctx->enc = enc;
  *_ctx = ctx;
  return 0;
}

static int afalg_cipher_setkey(void *_ctx, const void *key, size_t keysize)
{
  struct kcapi_ctx *ctx = _ctx;

  if (kcapi_cipher_setkey(ctx->handle, key, keysize) < 0) {
    gnutls_assert();
    return GNUTLS_E_ENCRYPTION_FAILED;
  }

  return 0;
}

static int afalg_cipher_setiv(void *_ctx, const void *iv, size_t iv_size)
{
  struct kcapi_ctx *ctx = _ctx;

  if (iv_size > kcapi_cipher_ivsize(ctx->handle))
    return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

  memcpy(ctx->iv, iv, iv_size);
  if (ctx->enc) {
    if (kcapi_cipher_stream_init_enc(ctx->handle, ctx->iv, NULL,
             0) < 0) {
      gnutls_assert();
      return GNUTLS_E_ENCRYPTION_FAILED;
    }
  } else {
    if (kcapi_cipher_stream_init_dec(ctx->handle, ctx->iv, NULL,
             0) < 0) {
      gnutls_assert();
      return GNUTLS_E_ENCRYPTION_FAILED;
    }
  }

  return 0;
}

static int afalg_cipher_encrypt(void *_ctx, const void *src, size_t src_size,
        void *dst, size_t dst_size)
{
  struct kcapi_ctx *ctx = _ctx;
  struct iovec iov;

  iov.iov_base = (void *)src;
  iov.iov_len = src_size;

  if (unlikely(src_size % kcapi_cipher_blocksize(ctx->handle))) {
    return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
  }

  if (kcapi_cipher_stream_update(ctx->handle, &iov, 1) < 0) {
    return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
  }

  if (unlikely(dst_size < src_size))
    return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);

  iov.iov_base = (void *)dst;
  iov.iov_len = src_size;

  if (kcapi_cipher_stream_op(ctx->handle, &iov, 1) < 0) {
    gnutls_assert();
    return GNUTLS_E_ENCRYPTION_FAILED;
  }

  return 0;
}

static int afalg_cipher_decrypt(void *_ctx, const void *src, size_t src_size,
        void *dst, size_t dst_size)
{
  struct kcapi_ctx *ctx = _ctx;
  struct iovec iov;

  iov.iov_base = (void *)src;
  iov.iov_len = src_size;

  if (unlikely(src_size % kcapi_cipher_blocksize(ctx->handle))) {
    return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
  }

  if (kcapi_cipher_stream_update(ctx->handle, &iov, 1) < 0) {
    return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
  }

  if (unlikely(dst_size < src_size))
    return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);

  iov.iov_base = (void *)dst;
  iov.iov_len = src_size;

  if (kcapi_cipher_stream_op(ctx->handle, &iov, 1) < 0) {
    gnutls_assert();
    return GNUTLS_E_ENCRYPTION_FAILED;
  }

  return 0;
}

static void afalg_cipher_deinit(void *_ctx)
{
  struct kcapi_ctx *ctx = _ctx;

  kcapi_cipher_destroy(ctx->handle);
  gnutls_free(ctx);
}

static const gnutls_crypto_cipher_st afalg_cipher_struct = {
  .init = afalg_cipher_init,
  .setkey = afalg_cipher_setkey,
  .setiv = afalg_cipher_setiv,
  .encrypt = afalg_cipher_encrypt,
  .decrypt = afalg_cipher_decrypt,
  .deinit = afalg_cipher_deinit,
};

static int afalg_cipher_register(void)
{
  unsigned int i;
  int ret = 0;

  for (i = 0;
       i < sizeof(gnutls_cipher_map) / sizeof(gnutls_cipher_map[0]);
       i++) {
    struct kcapi_handle *handle;

    if (gnutls_cipher_map[i] == 0)
      continue;

    /* Check whether cipher is available. */
    if (kcapi_cipher_init(&handle, gnutls_cipher_map[i], 0))
      continue;

    kcapi_cipher_destroy(handle);

    _gnutls_debug_log("afalg: registering: %s\n",
          gnutls_cipher_get_name(i));
    ret = gnutls_crypto_single_cipher_register(
      i, 90, &afalg_cipher_struct, 0);
    if (ret < 0) {
      gnutls_assert();
      return ret;
    }
  }

  return ret;
}

/************************ Symmetric cipher algorithms ************************/

struct kcapi_aead_ctx {
  struct kcapi_handle *handle;
  int taglen_set;
  int ccm;
};

static const char *gnutls_aead_map[] = {
  [GNUTLS_CIPHER_CAMELLIA_128_GCM] = "gcm(camellia)",
  [GNUTLS_CIPHER_CAMELLIA_256_GCM] = "gcm(camellia)",
  [GNUTLS_CIPHER_AES_128_CCM] = "ccm(aes)",
  [GNUTLS_CIPHER_AES_256_CCM] = "ccm(aes)",
  [GNUTLS_CIPHER_AES_128_GCM] = "gcm(aes)",
  [GNUTLS_CIPHER_AES_256_GCM] = "gcm(aes)",
};

static void afalg_aead_deinit(void *_ctx)
{
  struct kcapi_aead_ctx *ctx = _ctx;

  kcapi_aead_destroy(ctx->handle);
  gnutls_free(ctx);
}

static int afalg_aead_init(gnutls_cipher_algorithm_t algorithm, void **_ctx,
         int enc)
{
  struct kcapi_handle *handle;
  struct kcapi_aead_ctx *ctx;

  if (kcapi_aead_init(&handle, gnutls_aead_map[algorithm], 0) < 0) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  ctx = gnutls_malloc(sizeof(struct kcapi_aead_ctx));
  if (ctx == NULL) {
    gnutls_assert();
    kcapi_aead_destroy(handle);
    return GNUTLS_E_MEMORY_ERROR;
  }

  switch (algorithm) {
  case GNUTLS_CIPHER_AES_128_CCM:
  case GNUTLS_CIPHER_AES_256_CCM:
    ctx->ccm = 1;
    break;
  default:
    ctx->ccm = 0;
  }
  ctx->handle = handle;
  *_ctx = ctx;

  return 0;
}

static int afalg_aead_setkey(void *_ctx, const void *key, size_t keysize)
{
  struct kcapi_aead_ctx *ctx = _ctx;

  if (kcapi_aead_setkey(ctx->handle, key, keysize) < 0) {
    gnutls_assert();
    return GNUTLS_E_ENCRYPTION_FAILED;
  }

  return 0;
}

static int afalg_aead_decrypt(void *_ctx, const void *nonce, size_t nonce_size,
            const void *auth, size_t auth_size,
            size_t tag_size, const void *encr,
            size_t encr_size, void *plain, size_t plain_size)
{
  int ret = 0;
  struct kcapi_aead_ctx *ctx = _ctx;
  struct iovec iov[2];
  uint8_t *authtmp = malloca(auth_size);
  if (authtmp == NULL) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }
  if (encr_size < tag_size) {
    gnutls_assert();
    ret = GNUTLS_E_DECRYPTION_FAILED;
    goto end;
  }

  if (unlikely(plain_size < encr_size - tag_size)) {
    gnutls_assert();
    ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
    goto end;
  }

  /* Init stream once. */
  if (!ctx->taglen_set) {
    ctx->taglen_set = 1;
    if (kcapi_aead_settaglen(ctx->handle, tag_size) < 0) {
      gnutls_assert();
      ret = GNUTLS_E_DECRYPTION_FAILED;
      goto end;
    }
  }

  kcapi_aead_setassoclen(ctx->handle, auth_size);

  /* CCM nonce to IV conversion */
  if (ctx->ccm) {
    uint8_t *ccm_iv = NULL;
    uint32_t ccm_iv_len;

    if (kcapi_aead_ccm_nonce_to_iv(nonce, nonce_size, &ccm_iv,
                 &ccm_iv_len)) {
      gnutls_assert();
      ret = GNUTLS_E_DECRYPTION_FAILED;
      goto end;
    }
    if (kcapi_aead_stream_init_dec(ctx->handle, ccm_iv, NULL, 0) <
        0) {
      free(ccm_iv);
      gnutls_assert();
      ret = GNUTLS_E_DECRYPTION_FAILED;
      goto end;
    }
    free(ccm_iv);
  } else {
    if (kcapi_aead_stream_init_dec(ctx->handle, nonce, NULL, 0) <
        0) {
      gnutls_assert();
      ret = GNUTLS_E_DECRYPTION_FAILED;
      goto end;
    }
  }

  /*
   * Set AAD: IOVECs do not support const, this buffer is guaranteed to be
   * read-only
   */
  iov[0].iov_base = (void *)auth;
  iov[0].iov_len = auth_size;

  /*
   * Set CT: IOVECs do not support const, this buffer is guaranteed to be
   * read-only
   */
  iov[1].iov_base = (void *)encr;
  iov[1].iov_len = encr_size;

  if (kcapi_aead_stream_update_last(ctx->handle, iov, 2) < 0) {
    gnutls_assert();
    ret = GNUTLS_E_DECRYPTION_FAILED;
    goto end;
  }

  iov[0].iov_base = authtmp;
  iov[0].iov_len = auth_size;

  /* Set PT buffer to be filled by kernel */
  uint32_t outbuflen = kcapi_aead_outbuflen_dec(ctx->handle,
                  encr_size - tag_size,
                  auth_size, tag_size) -
           auth_size;
  iov[1].iov_base = (void *)plain;
  iov[1].iov_len = (plain_size > outbuflen) ? outbuflen : plain_size;

  if (kcapi_aead_stream_op(ctx->handle, iov, 2) < 0) {
    gnutls_assert();
    ret = GNUTLS_E_DECRYPTION_FAILED;
    goto end;
  }

end:
  freea(authtmp);
  return ret;
}

static int afalg_aead_encrypt(void *_ctx, const void *nonce, size_t nonce_size,
            const void *auth, size_t auth_size,
            size_t tag_size, const void *plain,
            size_t plain_size, void *encr, size_t encr_size)
{
  int ret = 0;
  struct kcapi_aead_ctx *ctx = _ctx;
  struct iovec iov[3];
  uint32_t iovlen = 2;
  uint8_t *authtmp = malloca(auth_size);
  if (authtmp == NULL) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  if (unlikely(encr_size - tag_size < plain_size)) {
    ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
    gnutls_assert();
    goto end;
  }

  if (nonce_size > kcapi_aead_ivsize(ctx->handle)) {
    ret = GNUTLS_E_INVALID_REQUEST;
    gnutls_assert();
    goto end;
  }

  /* Init taglen once. */
  if (!ctx->taglen_set) {
    ctx->taglen_set = 1;

    if (kcapi_aead_settaglen(ctx->handle, tag_size) < 0) {
      gnutls_assert();
      ret = GNUTLS_E_ENCRYPTION_FAILED;
      goto end;
    }
  }

  kcapi_aead_setassoclen(ctx->handle, auth_size);

  /* CCM nonce to IV conversion */
  if (ctx->ccm) {
    uint8_t *ccm_iv = NULL;
    uint32_t ccm_iv_len;

    if (kcapi_aead_ccm_nonce_to_iv(nonce, nonce_size, &ccm_iv,
                 &ccm_iv_len)) {
      gnutls_assert();
      ret = GNUTLS_E_ENCRYPTION_FAILED;
      goto end;
    }
    if (kcapi_aead_stream_init_enc(ctx->handle, ccm_iv, NULL, 0) <
        0) {
      free(ccm_iv);
      gnutls_assert();
      ret = GNUTLS_E_ENCRYPTION_FAILED;
      goto end;
    }
    free(ccm_iv);
  } else {
    if (kcapi_aead_stream_init_enc(ctx->handle, nonce, NULL, 0) <
        0) {
      gnutls_assert();
      ret = GNUTLS_E_ENCRYPTION_FAILED;
      goto end;
    }
  }

  /*
   * Set AAD: IOVECs do not support const, this buffer is guaranteed to be
   * read-only
   */
  iov[0].iov_base = (void *)auth;
  iov[0].iov_len = auth_size;

  /*
   * Set PT: IOVECs do not support const, this buffer is guaranteed to be
   * read-only
   */
  iov[1].iov_base = (void *)plain;
  iov[1].iov_len = plain_size;

  /*
   * Older kernels require tag as input. This buffer data is unused
   * which implies the encr buffer can serve as tmp space.
   */
  uint32_t inbuflen = kcapi_aead_inbuflen_enc(ctx->handle, plain_size,
                auth_size, tag_size);
  if ((auth_size + plain_size) < inbuflen) {
    iov[2].iov_base = encr;
    iov[2].iov_len = tag_size;
    iovlen = 3;
  }

  if (kcapi_aead_stream_update_last(ctx->handle, iov, iovlen) < 0) {
    gnutls_assert();
    ret = GNUTLS_E_ENCRYPTION_FAILED;
    goto end;
  }

  iov[0].iov_base = authtmp;
  iov[0].iov_len = auth_size;

  /* Set CT buffer to be filled by kernel */
  uint32_t outbuflen = kcapi_aead_outbuflen_enc(ctx->handle, plain_size,
                  auth_size, tag_size) -
           auth_size;

  iov[1].iov_base = encr;
  iov[1].iov_len = (encr_size > outbuflen) ? outbuflen : encr_size;

  if (kcapi_aead_stream_op(ctx->handle, iov, 2) < 0) {
    gnutls_assert();
    ret = GNUTLS_E_ENCRYPTION_FAILED;
    goto end;
  }

end:
  freea(authtmp);
  return ret;
}

static const gnutls_crypto_cipher_st afalg_aead_struct = {
  .init = afalg_aead_init,
  .setkey = afalg_aead_setkey,
  .aead_encrypt = afalg_aead_encrypt,
  .aead_decrypt = afalg_aead_decrypt,
  .deinit = afalg_aead_deinit,
};

static int afalg_aead_register(void)
{
  unsigned int i;
  int ret = 0;

  for (i = 0; i < sizeof(gnutls_aead_map) / sizeof(gnutls_aead_map[0]);
       i++) {
    struct kcapi_handle *handle;

    if (gnutls_aead_map[i] == 0)
      continue;

    /* Check whether cipher is available. */
    if (kcapi_aead_init(&handle, gnutls_aead_map[i], 0))
      continue;

    kcapi_aead_destroy(handle);

    _gnutls_debug_log("afalg: registering: %s\n",
          gnutls_cipher_get_name(i));
    ret = gnutls_crypto_single_cipher_register(
      i, 90, &afalg_aead_struct, 0);
    if (ret < 0) {
      gnutls_assert();
      return ret;
    }
  }

  return ret;
}

/********************** Keyed message digest algorithms **********************/

static const char *gnutls_mac_map[] = {
  [GNUTLS_MAC_SHA1] = "hmac(sha1)",
  [GNUTLS_MAC_SHA256] = "hmac(sha256)",
  [GNUTLS_MAC_SHA384] = "hmac(sha384)",
  [GNUTLS_MAC_SHA512] = "hmac(sha512)",
};

static int afalg_mac_init(gnutls_mac_algorithm_t algorithm, void **ctx)
{
  struct kcapi_handle *handle;

  if (kcapi_md_init(&handle, gnutls_mac_map[algorithm], 0) < 0) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  *ctx = handle;

  return 0;
}

static int afalg_mac_setkey(void *ctx, const void *key, size_t keysize)
{
  struct kcapi_handle *handle = ctx;

  if (kcapi_md_setkey(handle, key, keysize) < 0) {
    gnutls_assert();
    return GNUTLS_E_ENCRYPTION_FAILED;
  }

  return 0;
}

static int afalg_mac_hash(void *ctx, const void *_text, size_t textsize)
{
  struct kcapi_handle *handle = ctx;
  const uint8_t *text = _text;
  size_t offset;

  for (offset = 0; offset < textsize - textsize % INT_MAX;
       offset += INT_MAX) {
    if (kcapi_md_update(handle, text + offset, INT_MAX) < 0) {
      return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
    }
  }

  if (offset < textsize) {
    if (kcapi_md_update(handle, text + offset, textsize - offset) <
        0) {
      return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
    }
  }

  return 0;
}

static int afalg_mac_output(void *ctx, void *digest, size_t digestsize)
{
  struct kcapi_handle *handle = ctx;

  if (kcapi_md_final(handle, digest, digestsize) < 0) {
    gnutls_assert();
    return GNUTLS_E_ENCRYPTION_FAILED;
  }

  return 0;
}

static void afalg_mac_deinit(void *ctx)
{
  struct kcapi_handle *handle = ctx;

  kcapi_md_destroy(handle);
}

static int afalg_mac_fast(gnutls_mac_algorithm_t algorithm, const void *nonce,
        size_t nonce_size, const void *key, size_t keysize,
        const void *text, size_t textsize, void *digest)
{
  struct kcapi_handle *handle;
  int ret = GNUTLS_E_ENCRYPTION_FAILED;

  if (kcapi_md_init(&handle, gnutls_mac_map[algorithm], 0) < 0) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  if (kcapi_md_setkey(handle, key, keysize) < 0) {
    gnutls_assert();
    goto out;
  }

  if (textsize <= INT_MAX) {
    if (kcapi_md_digest(handle, text, textsize, digest,
            kcapi_md_digestsize(handle)) < 0) {
      gnutls_assert();
      goto out;
    }
  } else {
    ret = afalg_mac_hash(handle, text, textsize);
    if (ret < 0) {
      goto out;
    }
    if (kcapi_md_final(handle, digest,
           kcapi_md_digestsize(handle)) < 0) {
      gnutls_assert();
      return GNUTLS_E_ENCRYPTION_FAILED;
    }
  }

  ret = 0;

out:
  kcapi_md_destroy(handle);

  return ret;
}

static const gnutls_crypto_mac_st afalg_mac_struct = {
  .init = afalg_mac_init,
  .setkey = afalg_mac_setkey,
  .setnonce = NULL,
  .hash = afalg_mac_hash,
  .output = afalg_mac_output,
  .deinit = afalg_mac_deinit,
  .fast = afalg_mac_fast,
};

static int afalg_mac_register(void)
{
  unsigned int i;
  int ret = 0;

  for (i = 0; i < sizeof(gnutls_mac_map) / sizeof(gnutls_mac_map[0]);
       i++) {
    struct kcapi_handle *handle;

    if (gnutls_mac_map[i] == 0)
      continue;

    /* Check whether cipher is available. */
    if (kcapi_md_init(&handle, gnutls_mac_map[i], 0))
      continue;

    kcapi_md_destroy(handle);

    _gnutls_debug_log("afalg: registering: %s\n",
          gnutls_mac_get_name(i));
    ret = gnutls_crypto_single_mac_register(i, 90,
              &afalg_mac_struct, 0);
    if (ret < 0) {
      gnutls_assert();
      return ret;
    }
  }

  return ret;
}

/***************************** Digest algorithms *****************************/

static const char *gnutls_digest_map[] = {
  [GNUTLS_DIG_SHA1] = "sha1",
  [GNUTLS_DIG_SHA256] = "sha256",
  [GNUTLS_DIG_SHA384] = "sha384",
  [GNUTLS_DIG_SHA512] = "sha512",
};

static int afalg_digest_init(gnutls_digest_algorithm_t algorithm, void **ctx)
{
  struct kcapi_handle *handle;

  if (kcapi_md_init(&handle, gnutls_digest_map[algorithm], 0) < 0) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  *ctx = handle;

  return 0;
}

static int afalg_digest_fast(gnutls_digest_algorithm_t algorithm,
           const void *text, size_t textsize, void *digest)
{
  struct kcapi_handle *handle;
  int ret = GNUTLS_E_ENCRYPTION_FAILED;

  if (kcapi_md_init(&handle, gnutls_digest_map[algorithm], 0) < 0) {
    gnutls_assert();
    return GNUTLS_E_MEMORY_ERROR;
  }

  if (textsize <= INT_MAX) {
    if (kcapi_md_digest(handle, text, textsize, digest,
            kcapi_md_digestsize(handle)) < 0) {
      gnutls_assert();
      goto out;
    }
  } else {
    ret = afalg_mac_hash(handle, text, textsize);
    if (ret < 0) {
      goto out;
    }

    if (kcapi_md_final(handle, digest,
           kcapi_md_digestsize(handle)) < 0) {
      gnutls_assert();
      return GNUTLS_E_ENCRYPTION_FAILED;
    }
  }

  ret = 0;

out:
  kcapi_md_destroy(handle);

  return ret;
}

static const gnutls_crypto_digest_st afalg_digest_struct = {
  .init = afalg_digest_init,
  .hash = afalg_mac_hash,
  .output = afalg_mac_output,
  .deinit = afalg_mac_deinit,
  .fast = afalg_digest_fast
};

static int afalg_digest_register(void)
{
  unsigned int i;
  int ret = 0;

  for (i = 0;
       i < sizeof(gnutls_digest_map) / sizeof(gnutls_digest_map[0]);
       i++) {
    struct kcapi_handle *handle;

    if (gnutls_digest_map[i] == 0)
      continue;

    /* Check whether cipher is available. */
    if (kcapi_md_init(&handle, gnutls_digest_map[i], 0))
      continue;

    kcapi_md_destroy(handle);

    _gnutls_debug_log("afalg: registering: %s\n",
          gnutls_digest_get_name(i));
    ret = gnutls_crypto_single_digest_register(
      i, 90, &afalg_digest_struct, 0);
    if (ret < 0) {
      gnutls_assert();
      return ret;
    }
  }

  return ret;
}

int _gnutls_afalg_init(void)
{
  int ret;

  ret = afalg_cipher_register();
  if (ret)
    return ret;

  ret = afalg_aead_register();
  if (ret)
    return ret;

  ret = afalg_mac_register();
  if (ret)
    return ret;

  return afalg_digest_register();
}

void _gnutls_afalg_deinit(void)
{
  return;
}

#else /* ENABLE_AFALG */

int _gnutls_afalg_init(void)
{
  return 0;
}

void _gnutls_afalg_deinit(void)
{
  return;
}

#endif /* ENABLE_AFALG */

Coverage Report

Created: 2025-03-06 06:58

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright (C) 2017 Stephan Mueller <smueller@chronox.de>
3		*
4		* Author: Stephan Mueller
5		*
6		* This code is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU Lesser General Public License
8		* as published by the Free Software Foundation; either version 2.1 of
9		* the License, or (at your option) any later version.
10		*
11		* This library is distributed in the hope that it will be useful, but
12		* WITHOUT ANY WARRANTY; without even the implied warranty of
13		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14		* Lesser General Public License for more details.
15		*
16		* You should have received a copy of the GNU Lesser General Public License
17		* along with this program. If not, see <https://www.gnu.org/licenses/>.
18		*/
19
20		#include "config.h"
21
22		#include "accelerated/afalg.h"
23
24		#ifdef ENABLE_AFALG
25
26		#include "errors.h"
27		#include "gnutls_int.h"
28
29		#include <gnutls/crypto.h>
30		#include <kcapi.h>
31		#include <limits.h>
32		#include "malloca.h"
33
34		/********************** Symmetric cipher algorithms **********************/
35
36		struct kcapi_ctx {
37		struct kcapi_handle *handle;
38		int enc;
39		uint8_t iv[MAX_CIPHER_IV_SIZE];
40		};
41
42		static const char *gnutls_cipher_map[] = {
43		[GNUTLS_CIPHER_AES_128_CBC] = "cbc(aes)",
44		[GNUTLS_CIPHER_AES_192_CBC] = "cbc(aes)",
45		[GNUTLS_CIPHER_AES_256_CBC] = "cbc(aes)",
46		[GNUTLS_CIPHER_3DES_CBC] = "cbc(des3_ede)",
47		[GNUTLS_CIPHER_CAMELLIA_128_CBC] = "cbc(camellia)",
48		[GNUTLS_CIPHER_CAMELLIA_192_CBC] = "cbc(camellia)",
49		[GNUTLS_CIPHER_CAMELLIA_256_CBC] = "cbc(camellia)",
50		[GNUTLS_CIPHER_SALSA20_256] = "salsa20",
51		[GNUTLS_CIPHER_AES_128_XTS] = "xts(aes)",
52		[GNUTLS_CIPHER_AES_256_XTS] = "xts(aes)",
53		};
54
55		static int afalg_cipher_init(gnutls_cipher_algorithm_t algorithm, void **_ctx,
56		int enc)
57		{
58		struct kcapi_handle *handle;
59		struct kcapi_ctx *ctx;
60
61		if (kcapi_cipher_init(&handle, gnutls_cipher_map[algorithm], 0) < 0) {
62		gnutls_assert();
63		return GNUTLS_E_MEMORY_ERROR;
64		}
65
66		if (unlikely(kcapi_cipher_ivsize(handle) > MAX_CIPHER_IV_SIZE)) {
67		gnutls_assert();
68		return GNUTLS_E_INTERNAL_ERROR;
69		}
70
71		ctx = gnutls_malloc(sizeof(struct kcapi_ctx));
72		if (ctx == NULL) {
73		gnutls_assert();
74		kcapi_cipher_destroy(handle);
75		return GNUTLS_E_MEMORY_ERROR;
76		}
77
78		ctx->handle = handle;
79		ctx->enc = enc;
80		*_ctx = ctx;
81		return 0;
82		}
83
84		static int afalg_cipher_setkey(void _ctx, const void key, size_t keysize)
85		{
86		struct kcapi_ctx *ctx = _ctx;
87
88		if (kcapi_cipher_setkey(ctx->handle, key, keysize) < 0) {
89		gnutls_assert();
90		return GNUTLS_E_ENCRYPTION_FAILED;
91		}
92
93		return 0;
94		}
95
96		static int afalg_cipher_setiv(void _ctx, const void iv, size_t iv_size)
97		{
98		struct kcapi_ctx *ctx = _ctx;
99
100		if (iv_size > kcapi_cipher_ivsize(ctx->handle))
101		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
102
103		memcpy(ctx->iv, iv, iv_size);
104		if (ctx->enc) {
105		if (kcapi_cipher_stream_init_enc(ctx->handle, ctx->iv, NULL,
106		0) < 0) {
107		gnutls_assert();
108		return GNUTLS_E_ENCRYPTION_FAILED;
109		}
110		} else {
111		if (kcapi_cipher_stream_init_dec(ctx->handle, ctx->iv, NULL,
112		0) < 0) {
113		gnutls_assert();
114		return GNUTLS_E_ENCRYPTION_FAILED;
115		}
116		}
117
118		return 0;
119		}
120
121		static int afalg_cipher_encrypt(void _ctx, const void src, size_t src_size,
122		void *dst, size_t dst_size)
123		{
124		struct kcapi_ctx *ctx = _ctx;
125		struct iovec iov;
126
127		iov.iov_base = (void *)src;
128		iov.iov_len = src_size;
129
130		if (unlikely(src_size % kcapi_cipher_blocksize(ctx->handle))) {
131		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
132		}
133
134		if (kcapi_cipher_stream_update(ctx->handle, &iov, 1) < 0) {
135		return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
136		}
137
138		if (unlikely(dst_size < src_size))
139		return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
140
141		iov.iov_base = (void *)dst;
142		iov.iov_len = src_size;
143
144		if (kcapi_cipher_stream_op(ctx->handle, &iov, 1) < 0) {
145		gnutls_assert();
146		return GNUTLS_E_ENCRYPTION_FAILED;
147		}
148
149		return 0;
150		}
151
152		static int afalg_cipher_decrypt(void _ctx, const void src, size_t src_size,
153		void *dst, size_t dst_size)
154		{
155		struct kcapi_ctx *ctx = _ctx;
156		struct iovec iov;
157
158		iov.iov_base = (void *)src;
159		iov.iov_len = src_size;
160
161		if (unlikely(src_size % kcapi_cipher_blocksize(ctx->handle))) {
162		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
163		}
164
165		if (kcapi_cipher_stream_update(ctx->handle, &iov, 1) < 0) {
166		return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
167		}
168
169		if (unlikely(dst_size < src_size))
170		return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
171
172		iov.iov_base = (void *)dst;
173		iov.iov_len = src_size;
174
175		if (kcapi_cipher_stream_op(ctx->handle, &iov, 1) < 0) {
176		gnutls_assert();
177		return GNUTLS_E_ENCRYPTION_FAILED;
178		}
179
180		return 0;
181		}
182
183		static void afalg_cipher_deinit(void *_ctx)
184		{
185		struct kcapi_ctx *ctx = _ctx;
186
187		kcapi_cipher_destroy(ctx->handle);
188		gnutls_free(ctx);
189		}
190
191		static const gnutls_crypto_cipher_st afalg_cipher_struct = {
192		.init = afalg_cipher_init,
193		.setkey = afalg_cipher_setkey,
194		.setiv = afalg_cipher_setiv,
195		.encrypt = afalg_cipher_encrypt,
196		.decrypt = afalg_cipher_decrypt,
197		.deinit = afalg_cipher_deinit,
198		};
199
200		static int afalg_cipher_register(void)
201		{
202		unsigned int i;
203		int ret = 0;
204
205		for (i = 0;
206		i < sizeof(gnutls_cipher_map) / sizeof(gnutls_cipher_map[0]);
207		i++) {
208		struct kcapi_handle *handle;
209
210		if (gnutls_cipher_map[i] == 0)
211		continue;
212
213		/* Check whether cipher is available. */
214		if (kcapi_cipher_init(&handle, gnutls_cipher_map[i], 0))
215		continue;
216
217		kcapi_cipher_destroy(handle);
218
219		_gnutls_debug_log("afalg: registering: %s\n",
220		gnutls_cipher_get_name(i));
221		ret = gnutls_crypto_single_cipher_register(
222		i, 90, &afalg_cipher_struct, 0);
223		if (ret < 0) {
224		gnutls_assert();
225		return ret;
226		}
227		}
228
229		return ret;
230		}
231
232		/********************** Symmetric cipher algorithms **********************/
233
234		struct kcapi_aead_ctx {
235		struct kcapi_handle *handle;
236		int taglen_set;
237		int ccm;
238		};
239
240		static const char *gnutls_aead_map[] = {
241		[GNUTLS_CIPHER_CAMELLIA_128_GCM] = "gcm(camellia)",
242		[GNUTLS_CIPHER_CAMELLIA_256_GCM] = "gcm(camellia)",
243		[GNUTLS_CIPHER_AES_128_CCM] = "ccm(aes)",
244		[GNUTLS_CIPHER_AES_256_CCM] = "ccm(aes)",
245		[GNUTLS_CIPHER_AES_128_GCM] = "gcm(aes)",
246		[GNUTLS_CIPHER_AES_256_GCM] = "gcm(aes)",
247		};
248
249		static void afalg_aead_deinit(void *_ctx)
250		{
251		struct kcapi_aead_ctx *ctx = _ctx;
252
253		kcapi_aead_destroy(ctx->handle);
254		gnutls_free(ctx);
255		}
256
257		static int afalg_aead_init(gnutls_cipher_algorithm_t algorithm, void **_ctx,
258		int enc)
259		{
260		struct kcapi_handle *handle;
261		struct kcapi_aead_ctx *ctx;
262
263		if (kcapi_aead_init(&handle, gnutls_aead_map[algorithm], 0) < 0) {
264		gnutls_assert();
265		return GNUTLS_E_MEMORY_ERROR;
266		}
267
268		ctx = gnutls_malloc(sizeof(struct kcapi_aead_ctx));
269		if (ctx == NULL) {
270		gnutls_assert();
271		kcapi_aead_destroy(handle);
272		return GNUTLS_E_MEMORY_ERROR;
273		}
274
275		switch (algorithm) {
276		case GNUTLS_CIPHER_AES_128_CCM:
277		case GNUTLS_CIPHER_AES_256_CCM:
278		ctx->ccm = 1;
279		break;
280		default:
281		ctx->ccm = 0;
282		}
283		ctx->handle = handle;
284		*_ctx = ctx;
285
286		return 0;
287		}
288
289		static int afalg_aead_setkey(void _ctx, const void key, size_t keysize)
290		{
291		struct kcapi_aead_ctx *ctx = _ctx;
292
293		if (kcapi_aead_setkey(ctx->handle, key, keysize) < 0) {
294		gnutls_assert();
295		return GNUTLS_E_ENCRYPTION_FAILED;
296		}
297
298		return 0;
299		}
300
301		static int afalg_aead_decrypt(void _ctx, const void nonce, size_t nonce_size,
302		const void *auth, size_t auth_size,
303		size_t tag_size, const void *encr,
304		size_t encr_size, void *plain, size_t plain_size)
305		{
306		int ret = 0;
307		struct kcapi_aead_ctx *ctx = _ctx;
308		struct iovec iov[2];
309		uint8_t *authtmp = malloca(auth_size);
310		if (authtmp == NULL) {
311		gnutls_assert();
312		return GNUTLS_E_MEMORY_ERROR;
313		}
314		if (encr_size < tag_size) {
315		gnutls_assert();
316		ret = GNUTLS_E_DECRYPTION_FAILED;
317		goto end;
318		}
319
320		if (unlikely(plain_size < encr_size - tag_size)) {
321		gnutls_assert();
322		ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
323		goto end;
324		}
325
326		/* Init stream once. */
327		if (!ctx->taglen_set) {
328		ctx->taglen_set = 1;
329		if (kcapi_aead_settaglen(ctx->handle, tag_size) < 0) {
330		gnutls_assert();
331		ret = GNUTLS_E_DECRYPTION_FAILED;
332		goto end;
333		}
334		}
335
336		kcapi_aead_setassoclen(ctx->handle, auth_size);
337
338		/* CCM nonce to IV conversion */
339		if (ctx->ccm) {
340		uint8_t *ccm_iv = NULL;
341		uint32_t ccm_iv_len;
342
343		if (kcapi_aead_ccm_nonce_to_iv(nonce, nonce_size, &ccm_iv,
344		&ccm_iv_len)) {
345		gnutls_assert();
346		ret = GNUTLS_E_DECRYPTION_FAILED;
347		goto end;
348		}
349		if (kcapi_aead_stream_init_dec(ctx->handle, ccm_iv, NULL, 0) <
350		0) {
351		free(ccm_iv);
352		gnutls_assert();
353		ret = GNUTLS_E_DECRYPTION_FAILED;
354		goto end;
355		}
356		free(ccm_iv);
357		} else {
358		if (kcapi_aead_stream_init_dec(ctx->handle, nonce, NULL, 0) <
359		0) {
360		gnutls_assert();
361		ret = GNUTLS_E_DECRYPTION_FAILED;
362		goto end;
363		}
364		}
365
366		/*
367		* Set AAD: IOVECs do not support const, this buffer is guaranteed to be
368		* read-only
369		*/
370		iov[0].iov_base = (void *)auth;
371		iov[0].iov_len = auth_size;
372
373		/*
374		* Set CT: IOVECs do not support const, this buffer is guaranteed to be
375		* read-only
376		*/
377		iov[1].iov_base = (void *)encr;
378		iov[1].iov_len = encr_size;
379
380		if (kcapi_aead_stream_update_last(ctx->handle, iov, 2) < 0) {
381		gnutls_assert();
382		ret = GNUTLS_E_DECRYPTION_FAILED;
383		goto end;
384		}
385
386		iov[0].iov_base = authtmp;
387		iov[0].iov_len = auth_size;
388
389		/* Set PT buffer to be filled by kernel */
390		uint32_t outbuflen = kcapi_aead_outbuflen_dec(ctx->handle,
391		encr_size - tag_size,
392		auth_size, tag_size) -
393		auth_size;
394		iov[1].iov_base = (void *)plain;
395		iov[1].iov_len = (plain_size > outbuflen) ? outbuflen : plain_size;
396
397		if (kcapi_aead_stream_op(ctx->handle, iov, 2) < 0) {
398		gnutls_assert();
399		ret = GNUTLS_E_DECRYPTION_FAILED;
400		goto end;
401		}
402
403		end:
404		freea(authtmp);
405		return ret;
406		}
407
408		static int afalg_aead_encrypt(void _ctx, const void nonce, size_t nonce_size,
409		const void *auth, size_t auth_size,
410		size_t tag_size, const void *plain,
411		size_t plain_size, void *encr, size_t encr_size)
412		{
413		int ret = 0;
414		struct kcapi_aead_ctx *ctx = _ctx;
415		struct iovec iov[3];
416		uint32_t iovlen = 2;
417		uint8_t *authtmp = malloca(auth_size);
418		if (authtmp == NULL) {
419		gnutls_assert();
420		return GNUTLS_E_MEMORY_ERROR;
421		}
422
423		if (unlikely(encr_size - tag_size < plain_size)) {
424		ret = GNUTLS_E_SHORT_MEMORY_BUFFER;
425		gnutls_assert();
426		goto end;
427		}
428
429		if (nonce_size > kcapi_aead_ivsize(ctx->handle)) {
430		ret = GNUTLS_E_INVALID_REQUEST;
431		gnutls_assert();
432		goto end;
433		}
434
435		/* Init taglen once. */
436		if (!ctx->taglen_set) {
437		ctx->taglen_set = 1;
438
439		if (kcapi_aead_settaglen(ctx->handle, tag_size) < 0) {
440		gnutls_assert();
441		ret = GNUTLS_E_ENCRYPTION_FAILED;
442		goto end;
443		}
444		}
445
446		kcapi_aead_setassoclen(ctx->handle, auth_size);
447
448		/* CCM nonce to IV conversion */
449		if (ctx->ccm) {
450		uint8_t *ccm_iv = NULL;
451		uint32_t ccm_iv_len;
452
453		if (kcapi_aead_ccm_nonce_to_iv(nonce, nonce_size, &ccm_iv,
454		&ccm_iv_len)) {
455		gnutls_assert();
456		ret = GNUTLS_E_ENCRYPTION_FAILED;
457		goto end;
458		}
459		if (kcapi_aead_stream_init_enc(ctx->handle, ccm_iv, NULL, 0) <
460		0) {
461		free(ccm_iv);
462		gnutls_assert();
463		ret = GNUTLS_E_ENCRYPTION_FAILED;
464		goto end;
465		}
466		free(ccm_iv);
467		} else {
468		if (kcapi_aead_stream_init_enc(ctx->handle, nonce, NULL, 0) <
469		0) {
470		gnutls_assert();
471		ret = GNUTLS_E_ENCRYPTION_FAILED;
472		goto end;
473		}
474		}
475
476		/*
477		* Set AAD: IOVECs do not support const, this buffer is guaranteed to be
478		* read-only
479		*/
480		iov[0].iov_base = (void *)auth;
481		iov[0].iov_len = auth_size;
482
483		/*
484		* Set PT: IOVECs do not support const, this buffer is guaranteed to be
485		* read-only
486		*/
487		iov[1].iov_base = (void *)plain;
488		iov[1].iov_len = plain_size;
489
490		/*
491		* Older kernels require tag as input. This buffer data is unused
492		* which implies the encr buffer can serve as tmp space.
493		*/
494		uint32_t inbuflen = kcapi_aead_inbuflen_enc(ctx->handle, plain_size,
495		auth_size, tag_size);
496		if ((auth_size + plain_size) < inbuflen) {
497		iov[2].iov_base = encr;
498		iov[2].iov_len = tag_size;
499		iovlen = 3;
500		}
501
502		if (kcapi_aead_stream_update_last(ctx->handle, iov, iovlen) < 0) {
503		gnutls_assert();
504		ret = GNUTLS_E_ENCRYPTION_FAILED;
505		goto end;
506		}
507
508		iov[0].iov_base = authtmp;
509		iov[0].iov_len = auth_size;
510
511		/* Set CT buffer to be filled by kernel */
512		uint32_t outbuflen = kcapi_aead_outbuflen_enc(ctx->handle, plain_size,
513		auth_size, tag_size) -
514		auth_size;
515
516		iov[1].iov_base = encr;
517		iov[1].iov_len = (encr_size > outbuflen) ? outbuflen : encr_size;
518
519		if (kcapi_aead_stream_op(ctx->handle, iov, 2) < 0) {
520		gnutls_assert();
521		ret = GNUTLS_E_ENCRYPTION_FAILED;
522		goto end;
523		}
524
525		end:
526		freea(authtmp);
527		return ret;
528		}
529
530		static const gnutls_crypto_cipher_st afalg_aead_struct = {
531		.init = afalg_aead_init,
532		.setkey = afalg_aead_setkey,
533		.aead_encrypt = afalg_aead_encrypt,
534		.aead_decrypt = afalg_aead_decrypt,
535		.deinit = afalg_aead_deinit,
536		};
537
538		static int afalg_aead_register(void)
539		{
540		unsigned int i;
541		int ret = 0;
542
543		for (i = 0; i < sizeof(gnutls_aead_map) / sizeof(gnutls_aead_map[0]);
544		i++) {
545		struct kcapi_handle *handle;
546
547		if (gnutls_aead_map[i] == 0)
548		continue;
549
550		/* Check whether cipher is available. */
551		if (kcapi_aead_init(&handle, gnutls_aead_map[i], 0))
552		continue;
553
554		kcapi_aead_destroy(handle);
555
556		_gnutls_debug_log("afalg: registering: %s\n",
557		gnutls_cipher_get_name(i));
558		ret = gnutls_crypto_single_cipher_register(
559		i, 90, &afalg_aead_struct, 0);
560		if (ret < 0) {
561		gnutls_assert();
562		return ret;
563		}
564		}
565
566		return ret;
567		}
568
569		/******************** Keyed message digest algorithms ********************/
570
571		static const char *gnutls_mac_map[] = {
572		[GNUTLS_MAC_SHA1] = "hmac(sha1)",
573		[GNUTLS_MAC_SHA256] = "hmac(sha256)",
574		[GNUTLS_MAC_SHA384] = "hmac(sha384)",
575		[GNUTLS_MAC_SHA512] = "hmac(sha512)",
576		};
577
578		static int afalg_mac_init(gnutls_mac_algorithm_t algorithm, void **ctx)
579		{
580		struct kcapi_handle *handle;
581
582		if (kcapi_md_init(&handle, gnutls_mac_map[algorithm], 0) < 0) {
583		gnutls_assert();
584		return GNUTLS_E_MEMORY_ERROR;
585		}
586
587		*ctx = handle;
588
589		return 0;
590		}
591
592		static int afalg_mac_setkey(void ctx, const void key, size_t keysize)
593		{
594		struct kcapi_handle *handle = ctx;
595
596		if (kcapi_md_setkey(handle, key, keysize) < 0) {
597		gnutls_assert();
598		return GNUTLS_E_ENCRYPTION_FAILED;
599		}
600
601		return 0;
602		}
603
604		static int afalg_mac_hash(void ctx, const void _text, size_t textsize)
605		{
606		struct kcapi_handle *handle = ctx;
607		const uint8_t *text = _text;
608		size_t offset;
609
610		for (offset = 0; offset < textsize - textsize % INT_MAX;
611		offset += INT_MAX) {
612		if (kcapi_md_update(handle, text + offset, INT_MAX) < 0) {
613		return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
614		}
615		}
616
617		if (offset < textsize) {
618		if (kcapi_md_update(handle, text + offset, textsize - offset) <
619		0) {
620		return gnutls_assert_val(GNUTLS_E_ENCRYPTION_FAILED);
621		}
622		}
623
624		return 0;
625		}
626
627		static int afalg_mac_output(void ctx, void digest, size_t digestsize)
628		{
629		struct kcapi_handle *handle = ctx;
630
631		if (kcapi_md_final(handle, digest, digestsize) < 0) {
632		gnutls_assert();
633		return GNUTLS_E_ENCRYPTION_FAILED;
634		}
635
636		return 0;
637		}
638
639		static void afalg_mac_deinit(void *ctx)
640		{
641		struct kcapi_handle *handle = ctx;
642
643		kcapi_md_destroy(handle);
644		}
645
646		static int afalg_mac_fast(gnutls_mac_algorithm_t algorithm, const void *nonce,
647		size_t nonce_size, const void *key, size_t keysize,
648		const void text, size_t textsize, void digest)
649		{
650		struct kcapi_handle *handle;
651		int ret = GNUTLS_E_ENCRYPTION_FAILED;
652
653		if (kcapi_md_init(&handle, gnutls_mac_map[algorithm], 0) < 0) {
654		gnutls_assert();
655		return GNUTLS_E_MEMORY_ERROR;
656		}
657
658		if (kcapi_md_setkey(handle, key, keysize) < 0) {
659		gnutls_assert();
660		goto out;
661		}
662
663		if (textsize <= INT_MAX) {
664		if (kcapi_md_digest(handle, text, textsize, digest,
665		kcapi_md_digestsize(handle)) < 0) {
666		gnutls_assert();
667		goto out;
668		}
669		} else {
670		ret = afalg_mac_hash(handle, text, textsize);
671		if (ret < 0) {
672		goto out;
673		}
674		if (kcapi_md_final(handle, digest,
675		kcapi_md_digestsize(handle)) < 0) {
676		gnutls_assert();
677		return GNUTLS_E_ENCRYPTION_FAILED;
678		}
679		}
680
681		ret = 0;
682
683		out:
684		kcapi_md_destroy(handle);
685
686		return ret;
687		}
688
689		static const gnutls_crypto_mac_st afalg_mac_struct = {
690		.init = afalg_mac_init,
691		.setkey = afalg_mac_setkey,
692		.setnonce = NULL,
693		.hash = afalg_mac_hash,
694		.output = afalg_mac_output,
695		.deinit = afalg_mac_deinit,
696		.fast = afalg_mac_fast,
697		};
698
699		static int afalg_mac_register(void)
700		{
701		unsigned int i;
702		int ret = 0;
703
704		for (i = 0; i < sizeof(gnutls_mac_map) / sizeof(gnutls_mac_map[0]);
705		i++) {
706		struct kcapi_handle *handle;
707
708		if (gnutls_mac_map[i] == 0)
709		continue;
710
711		/* Check whether cipher is available. */
712		if (kcapi_md_init(&handle, gnutls_mac_map[i], 0))
713		continue;
714
715		kcapi_md_destroy(handle);
716
717		_gnutls_debug_log("afalg: registering: %s\n",
718		gnutls_mac_get_name(i));
719		ret = gnutls_crypto_single_mac_register(i, 90,
720		&afalg_mac_struct, 0);
721		if (ret < 0) {
722		gnutls_assert();
723		return ret;
724		}
725		}
726
727		return ret;
728		}
729
730		/*************************** Digest algorithms ***************************/
731
732		static const char *gnutls_digest_map[] = {
733		[GNUTLS_DIG_SHA1] = "sha1",
734		[GNUTLS_DIG_SHA256] = "sha256",
735		[GNUTLS_DIG_SHA384] = "sha384",
736		[GNUTLS_DIG_SHA512] = "sha512",
737		};
738
739		static int afalg_digest_init(gnutls_digest_algorithm_t algorithm, void **ctx)
740		{
741		struct kcapi_handle *handle;
742
743		if (kcapi_md_init(&handle, gnutls_digest_map[algorithm], 0) < 0) {
744		gnutls_assert();
745		return GNUTLS_E_MEMORY_ERROR;
746		}
747
748		*ctx = handle;
749
750		return 0;
751		}
752
753		static int afalg_digest_fast(gnutls_digest_algorithm_t algorithm,
754		const void text, size_t textsize, void digest)
755		{
756		struct kcapi_handle *handle;
757		int ret = GNUTLS_E_ENCRYPTION_FAILED;
758
759		if (kcapi_md_init(&handle, gnutls_digest_map[algorithm], 0) < 0) {
760		gnutls_assert();
761		return GNUTLS_E_MEMORY_ERROR;
762		}
763
764		if (textsize <= INT_MAX) {
765		if (kcapi_md_digest(handle, text, textsize, digest,
766		kcapi_md_digestsize(handle)) < 0) {
767		gnutls_assert();
768		goto out;
769		}
770		} else {
771		ret = afalg_mac_hash(handle, text, textsize);
772		if (ret < 0) {
773		goto out;
774		}
775
776		if (kcapi_md_final(handle, digest,
777		kcapi_md_digestsize(handle)) < 0) {
778		gnutls_assert();
779		return GNUTLS_E_ENCRYPTION_FAILED;
780		}
781		}
782
783		ret = 0;
784
785		out:
786		kcapi_md_destroy(handle);
787
788		return ret;
789		}
790
791		static const gnutls_crypto_digest_st afalg_digest_struct = {
792		.init = afalg_digest_init,
793		.hash = afalg_mac_hash,
794		.output = afalg_mac_output,
795		.deinit = afalg_mac_deinit,
796		.fast = afalg_digest_fast
797		};
798
799		static int afalg_digest_register(void)
800		{
801		unsigned int i;
802		int ret = 0;
803
804		for (i = 0;
805		i < sizeof(gnutls_digest_map) / sizeof(gnutls_digest_map[0]);
806		i++) {
807		struct kcapi_handle *handle;
808
809		if (gnutls_digest_map[i] == 0)
810		continue;
811
812		/* Check whether cipher is available. */
813		if (kcapi_md_init(&handle, gnutls_digest_map[i], 0))
814		continue;
815
816		kcapi_md_destroy(handle);
817
818		_gnutls_debug_log("afalg: registering: %s\n",
819		gnutls_digest_get_name(i));
820		ret = gnutls_crypto_single_digest_register(
821		i, 90, &afalg_digest_struct, 0);
822		if (ret < 0) {
823		gnutls_assert();
824		return ret;
825		}
826		}
827
828		return ret;
829		}
830
831		int _gnutls_afalg_init(void)
832		{
833		int ret;
834
835		ret = afalg_cipher_register();
836		if (ret)
837		return ret;
838
839		ret = afalg_aead_register();
840		if (ret)
841		return ret;
842
843		ret = afalg_mac_register();
844		if (ret)
845		return ret;
846
847		return afalg_digest_register();
848		}
849
850		void _gnutls_afalg_deinit(void)
851		{
852		return;
853		}
854
855		#else /* ENABLE_AFALG */
856
857		int _gnutls_afalg_init(void)
858	2	{
859	2	return 0;
860	2	}
861
862		void _gnutls_afalg_deinit(void)
863	0	{
864	0	return;
865	0	}
866
867		#endif /* ENABLE_AFALG */