/*

  silcacc_cipher.c

  Author: Pekka Riikonen <priikone@silcnet.org>

  Copyright (C) 2008 Pekka Riikonen

  This program 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; version 2 of the License.

  This program 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.

*/

#include "silccrypto.h"

/************************** Types and definitions ***************************/

SILC_CIPHER_API_SET_KEY(acc_cipher);
SILC_CIPHER_API_SET_IV(acc_cipher);
SILC_CIPHER_API_ENCRYPT(acc_cipher);
SILC_CIPHER_API_DECRYPT(acc_cipher);
SILC_CIPHER_API_INIT(acc_cipher);
SILC_CIPHER_API_UNINIT(acc_cipher);

/* Accelerated cipher */
typedef struct SilcAcceleratorCipherStruct {
  SilcCipher cipher;		/* Associated cipher */
  SilcCipher acc_cipher;	/* Accelerator cipher */
} *SilcAcceleratorCipher;

/************************** Accelerator Cipher API **************************/

/* The Cipher API for the accelerated cipher is simply a wrapper.  It
   calls the SILC Cipher API for the accelerator cipher. */

const SilcCipherObject silc_acc_ciph =
{
  "silc_acc_cipher",
  "silc_acc_cipher",

  silc_acc_cipher_set_key,
  silc_acc_cipher_set_iv,
  silc_acc_cipher_encrypt,
  silc_acc_cipher_decrypt,
  silc_acc_cipher_init,
  silc_acc_cipher_uninit,

  0, 0, 0, 0
};

SILC_CIPHER_API_SET_KEY(acc_cipher)
{
  SilcAcceleratorCipher c = context;

  /* Set key for the associated cipher too */
  silc_cipher_set_key(c->cipher, key, keylen, encryption);

  /* Set key for accelerator */
  return silc_cipher_set_key(c->acc_cipher, key, keylen, encryption);
}

SILC_CIPHER_API_SET_IV(acc_cipher)
{
  SilcAcceleratorCipher c = context;

  /* Set IV for the associated cipher too */
  silc_cipher_set_iv(c->cipher, iv);

  /* Set IV for accelerator */
  silc_cipher_set_iv(c->acc_cipher, iv);
}

SILC_CIPHER_API_ENCRYPT(acc_cipher)
{
  SilcAcceleratorCipher c = context;
  return silc_cipher_encrypt(c->acc_cipher, src, dst, len, iv);
}

SILC_CIPHER_API_DECRYPT(acc_cipher)
{
  SilcAcceleratorCipher c = context;
  return silc_cipher_decrypt(c->acc_cipher, src, dst, len, iv);
}

SILC_CIPHER_API_INIT(acc_cipher)
{
  /* This operation is never called */
  return NULL;
}

SILC_CIPHER_API_UNINIT(acc_cipher)
{
  SilcAcceleratorCipher c = context;
  SilcCipherObject *acc_ops = c->acc_cipher->cipher;

  /* Free the accelerator cipher and its operations we allocated earlier. */
  silc_cipher_free(c->acc_cipher);
  silc_free(acc_ops);

  /* Free our operations too */
  silc_free(ops);
}

/*************************** SILC Accelerator API ***************************/

/* Accelerate cipher */

SilcCipher silc_acc_cipher(SilcAccelerator acc, SilcCipher cipher)
{
  SilcCipher c;
  SilcAcceleratorCipher acc_cipher;
  const SilcCipherObject *alg;
  int i;

  if (!acc || !cipher)
    return NULL;

  SILC_LOG_DEBUG(("Accelerate cipher %p with accelerator %s",
		  cipher, acc->name));

  if (!acc->cipher) {
    SILC_LOG_ERROR(("Accelerator '%s' does not support cipher acceleration ",
		    acc->name));
    return NULL;
  }

  if (silc_acc_get_cipher(NULL, cipher)) {
    SILC_LOG_DEBUG(("Cipher %p is already accelerated", cipher));
    return NULL;
  }

  /* Check that accelerator supports this cipher algorithm */
  alg = cipher->cipher;
  for (i = 0; acc->cipher[i].alg_name; i++) {
    if ((!strcmp(acc->cipher[i].alg_name, alg->alg_name) ||
	 !strcmp(acc->cipher[i].alg_name, "any")) &&
	(acc->cipher[i].mode == alg->mode ||
	 acc->cipher[i].mode == 0) &&
	(acc->cipher[i].key_len == alg->key_len ||
	 acc->cipher[i].key_len == 0)) {
      alg = NULL;
      break;
    }
  }
  if (alg) {
    SILC_LOG_DEBUG(("Accelerator %s does not support %s (mode %d) "
		    "acceleration", acc->name, alg->name, alg->mode));
    return NULL;
  }

  /* Allocate cipher context for the SILC Cipher API */
  c = silc_calloc(1, sizeof(*c));
  if (!c)
    return NULL;

  /* Allocate cipher operations */
  c->cipher = silc_calloc(1, sizeof(SilcCipherObject));
  if (!c->cipher) {
    silc_free(c);
    return NULL;
  }
  *c->cipher = silc_acc_ciph;

  /* Allocate cipher context */
  c->context = acc_cipher = silc_calloc(1, sizeof(*acc_cipher));
  if (!acc_cipher) {
    silc_free(c->cipher);
    silc_free(c);
    return NULL;
  }
  acc_cipher->cipher = cipher;

  /* Allocate the actual algorithm accelerator. */
  acc_cipher->acc_cipher = silc_calloc(1, sizeof(*acc_cipher->acc_cipher));
  if (!acc_cipher->acc_cipher) {
    silc_free(c->cipher);
    silc_free(c);
    silc_free(acc_cipher);
  }

  /* Initialize the algorithm accelerator */
  acc_cipher->acc_cipher->context =
    acc->cipher[i].init((struct SilcCipherObjectStruct *)&acc->cipher[i]);
  if (!acc_cipher->acc_cipher->context) {
    silc_free(c->cipher);
    silc_free(c);
    silc_free(acc_cipher->acc_cipher);
    silc_free(acc_cipher);
    return NULL;
  }

  /* Allocate algorithm accelerator operations */
  acc_cipher->acc_cipher->cipher = silc_calloc(1, sizeof(SilcCipherObject));
  if (!acc_cipher->acc_cipher->cipher) {
    silc_free(c->cipher);
    silc_free(c);
    silc_free(acc_cipher->acc_cipher->context);
    silc_free(acc_cipher->acc_cipher);
    silc_free(acc_cipher);
    return NULL;
  }

  /* Set algorithm accelerator operations.  They are copied from the
     accelerator, but algorithm specific things come from associated
     cipher.  This way accelerators get the associated cipher details. */
  *acc_cipher->acc_cipher->cipher = acc->cipher[i];
  acc_cipher->acc_cipher->cipher->alg_name =
    (char *)silc_cipher_get_alg_name(cipher);
  acc_cipher->acc_cipher->cipher->key_len = silc_cipher_get_key_len(cipher);
  acc_cipher->acc_cipher->cipher->block_len =
    silc_cipher_get_block_len(cipher);
  acc_cipher->acc_cipher->cipher->iv_len = silc_cipher_get_iv_len(cipher);

  /* Set for the accelerator cipher too */
  c->cipher->key_len = silc_cipher_get_key_len(cipher);
  c->cipher->block_len = silc_cipher_get_block_len(cipher);
  c->cipher->iv_len = silc_cipher_get_iv_len(cipher);

  /* Start the accelerator.  The accelerator is started by setting key
     with NULL key. */
  if (!silc_cipher_set_key(acc_cipher->acc_cipher, NULL, 0, FALSE)) {
    SilcCipherObject *ops = acc_cipher->acc_cipher->cipher;
    silc_cipher_free(acc_cipher->acc_cipher);
    silc_free(ops);
    silc_free(c->cipher);
    silc_free(c);
    return NULL;
  }

  SILC_LOG_DEBUG(("New accelerated cipher %p", c));

  return c;
}

/* Return underlaying cipher from accelerated cipher. */

SilcCipher silc_acc_get_cipher(SilcAccelerator acc, SilcCipher cipher)
{
  SilcAcceleratorCipher acc_cipher;

  if (!cipher || cipher->cipher != &silc_acc_ciph)
    return NULL;

  acc_cipher = cipher->context;

  return acc_cipher->cipher;
}