crypto_symmetric.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2013 GNUnet e.V.

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet 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
     Affero General Public License for more details.

     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */

#include "platform.h"
#include "gnunet_crypto_lib.h"
#include <gcrypt.h>

#define LOG(kind, ...) GNUNET_log_from(kind, "util-crypto-symmetric", __VA_ARGS__)

void
GNUNET_CRYPTO_symmetric_create_session_key(struct GNUNET_CRYPTO_SymmetricSessionKey *key)
{
  gcry_randomize(key->aes_key,
                 GNUNET_CRYPTO_AES_KEY_LENGTH,
                 GCRY_STRONG_RANDOM);
  gcry_randomize(key->twofish_key,
                 GNUNET_CRYPTO_AES_KEY_LENGTH,
                 GCRY_STRONG_RANDOM);
}


static int
setup_cipher_aes(gcry_cipher_hd_t *handle,
                 const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
                 const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
{
  int rc;

  GNUNET_assert(0 ==
                gcry_cipher_open(handle, GCRY_CIPHER_AES256,
                                 GCRY_CIPHER_MODE_CFB, 0));
  rc = gcry_cipher_setkey(*handle,
                          sessionkey->aes_key,
                          sizeof(sessionkey->aes_key));
  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
  rc = gcry_cipher_setiv(*handle,
                         iv->aes_iv,
                         sizeof(iv->aes_iv));
  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
  return GNUNET_OK;
}


static int
setup_cipher_twofish(gcry_cipher_hd_t *handle,
                     const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
                     const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
{
  int rc;

  GNUNET_assert(0 ==
                gcry_cipher_open(handle, GCRY_CIPHER_TWOFISH,
                                 GCRY_CIPHER_MODE_CFB, 0));
  rc = gcry_cipher_setkey(*handle,
                          sessionkey->twofish_key,
                          sizeof(sessionkey->twofish_key));
  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
  rc = gcry_cipher_setiv(*handle,
                         iv->twofish_iv,
                         sizeof(iv->twofish_iv));
  GNUNET_assert((0 == rc) || ((char)rc == GPG_ERR_WEAK_KEY));
  return GNUNET_OK;
}


ssize_t
GNUNET_CRYPTO_symmetric_encrypt(const void *block,
                                size_t size,
                                const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
                                const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
                                void *result)
{
  gcry_cipher_hd_t handle;
  char tmp[size];

  if (GNUNET_OK != setup_cipher_aes(&handle, sessionkey, iv))
    return -1;
  GNUNET_assert(0 == gcry_cipher_encrypt(handle, tmp, size, block, size));
  gcry_cipher_close(handle);
  if (GNUNET_OK != setup_cipher_twofish(&handle, sessionkey, iv))
    return -1;
  GNUNET_assert(0 == gcry_cipher_encrypt(handle, result, size, tmp, size));
  gcry_cipher_close(handle);
  memset(tmp, 0, sizeof(tmp));
  return size;
}


ssize_t
GNUNET_CRYPTO_symmetric_decrypt(const void *block,
                                size_t size,
                                const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey,
                                const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
                                void *result)
{
  gcry_cipher_hd_t handle;
  char tmp[size];

  if (GNUNET_OK != setup_cipher_twofish(&handle, sessionkey, iv))
    return -1;
  GNUNET_assert(0 == gcry_cipher_decrypt(handle, tmp, size, block, size));
  gcry_cipher_close(handle);
  if (GNUNET_OK != setup_cipher_aes(&handle, sessionkey, iv))
    return -1;
  GNUNET_assert(0 == gcry_cipher_decrypt(handle, result, size, tmp, size));
  gcry_cipher_close(handle);
  memset(tmp, 0, sizeof(tmp));
  return size;
}


void
GNUNET_CRYPTO_symmetric_derive_iv(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
                                  const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
                                  const void *salt,
                                  size_t salt_len,
                                  ...)
{
  va_list argp;

  va_start(argp, salt_len);
  GNUNET_CRYPTO_symmetric_derive_iv_v(iv, skey, salt, salt_len, argp);
  va_end(argp);
}


void
GNUNET_CRYPTO_symmetric_derive_iv_v(struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
                                    const struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
                                    const void *salt,
                                    size_t salt_len,
                                    va_list argp)
{
  char aes_salt[salt_len + 4];
  char twofish_salt[salt_len + 4];

  GNUNET_memcpy(aes_salt, salt, salt_len);
  GNUNET_memcpy(&aes_salt[salt_len], "AES!", 4);
  GNUNET_memcpy(twofish_salt, salt, salt_len);
  GNUNET_memcpy(&twofish_salt[salt_len], "FISH", 4);
  GNUNET_CRYPTO_kdf_v(iv->aes_iv,
                      sizeof(iv->aes_iv),
                      aes_salt,
                      salt_len + 4,
                      skey->aes_key,
                      sizeof(skey->aes_key),
                      argp);
  GNUNET_CRYPTO_kdf_v(iv->twofish_iv,
                      sizeof(iv->twofish_iv),
                      twofish_salt,
                      salt_len + 4,
                      skey->twofish_key,
                      sizeof(skey->twofish_key),
                      argp);
}

/* end of crypto_symmetric.c */