/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]. */

#include <openssl/cast.h>
#include <openssl/cipher.h>
#include <openssl/obj.h>

#if defined(OPENSSL_WINDOWS)
OPENSSL_MSVC_PRAGMA(warning(push, 3))
#include <intrin.h>
OPENSSL_MSVC_PRAGMA(warning(pop))
#endif

#include "../../crypto/fipsmodule/cipher/internal.h"
#include "../../crypto/internal.h"
#include "internal.h"
#include "../macros.h"


void CAST_ecb_encrypt(const uint8_t *in, uint8_t *out, const CAST_KEY *ks,
                      int enc) {
  uint32_t d[2];

  n2l(in, d[0]);
  n2l(in, d[1]);
  if (enc) {
    CAST_encrypt(d, ks);
  } else {
    CAST_decrypt(d, ks);
  }
  l2n(d[0], out);
  l2n(d[1], out);
}

#define E_CAST(n, key, L, R, OP1, OP2, OP3)                                    \
  {                                                                            \
    uint32_t a, b, c, d;                                                       \
    t = (key[n * 2] OP1 R) & 0xffffffff;                                       \
    t = CRYPTO_rotl_u32(t, (key[n * 2 + 1]));                                  \
    a = CAST_S_table0[(t >> 8) & 0xff];                                        \
    b = CAST_S_table1[(t)&0xff];                                               \
    c = CAST_S_table2[(t >> 24) & 0xff];                                       \
    d = CAST_S_table3[(t >> 16) & 0xff];                                       \
    L ^= (((((a OP2 b)&0xffffffffL)OP3 c) & 0xffffffffL) OP1 d) & 0xffffffffL; \
  }

void CAST_encrypt(uint32_t *data, const CAST_KEY *key) {
  uint32_t l, r, t;
  const uint32_t *k;

  k = &key->data[0];
  l = data[0];
  r = data[1];

  E_CAST(0, k, l, r, +, ^, -);
  E_CAST(1, k, r, l, ^, -, +);
  E_CAST(2, k, l, r, -, +, ^);
  E_CAST(3, k, r, l, +, ^, -);
  E_CAST(4, k, l, r, ^, -, +);
  E_CAST(5, k, r, l, -, +, ^);
  E_CAST(6, k, l, r, +, ^, -);
  E_CAST(7, k, r, l, ^, -, +);
  E_CAST(8, k, l, r, -, +, ^);
  E_CAST(9, k, r, l, +, ^, -);
  E_CAST(10, k, l, r, ^, -, +);
  E_CAST(11, k, r, l, -, +, ^);

  if (!key->short_key) {
    E_CAST(12, k, l, r, +, ^, -);
    E_CAST(13, k, r, l, ^, -, +);
    E_CAST(14, k, l, r, -, +, ^);
    E_CAST(15, k, r, l, +, ^, -);
  }

  data[1] = l & 0xffffffffL;
  data[0] = r & 0xffffffffL;
}

void CAST_decrypt(uint32_t *data, const CAST_KEY *key) {
  uint32_t l, r, t;
  const uint32_t *k;

  k = &key->data[0];
  l = data[0];
  r = data[1];

  if (!key->short_key) {
    E_CAST(15, k, l, r, +, ^, -);
    E_CAST(14, k, r, l, -, +, ^);
    E_CAST(13, k, l, r, ^, -, +);
    E_CAST(12, k, r, l, +, ^, -);
  }

  E_CAST(11, k, l, r, -, +, ^);
  E_CAST(10, k, r, l, ^, -, +);
  E_CAST(9, k, l, r, +, ^, -);
  E_CAST(8, k, r, l, -, +, ^);
  E_CAST(7, k, l, r, ^, -, +);
  E_CAST(6, k, r, l, +, ^, -);
  E_CAST(5, k, l, r, -, +, ^);
  E_CAST(4, k, r, l, ^, -, +);
  E_CAST(3, k, l, r, +, ^, -);
  E_CAST(2, k, r, l, -, +, ^);
  E_CAST(1, k, l, r, ^, -, +);
  E_CAST(0, k, r, l, +, ^, -);

  data[1] = l & 0xffffffffL;
  data[0] = r & 0xffffffffL;
}

void CAST_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t length,
                      const CAST_KEY *ks, uint8_t *iv, int enc) {
  uint32_t tin0, tin1;
  uint32_t tout0, tout1, xor0, xor1;
  size_t l = length;
  uint32_t tin[2];

  if (enc) {
    n2l(iv, tout0);
    n2l(iv, tout1);
    iv -= 8;
    while (l >= 8) {
      n2l(in, tin0);
      n2l(in, tin1);
      tin0 ^= tout0;
      tin1 ^= tout1;
      tin[0] = tin0;
      tin[1] = tin1;
      CAST_encrypt(tin, ks);
      tout0 = tin[0];
      tout1 = tin[1];
      l2n(tout0, out);
      l2n(tout1, out);
      l -= 8;
    }
    if (l != 0) {
      n2ln(in, tin0, tin1, l);
      tin0 ^= tout0;
      tin1 ^= tout1;
      tin[0] = tin0;
      tin[1] = tin1;
      CAST_encrypt(tin, ks);
      tout0 = tin[0];
      tout1 = tin[1];
      l2n(tout0, out);
      l2n(tout1, out);
    }
    l2n(tout0, iv);
    l2n(tout1, iv);
  } else {
    n2l(iv, xor0);
    n2l(iv, xor1);
    iv -= 8;
    while (l >= 8) {
      n2l(in, tin0);
      n2l(in, tin1);
      tin[0] = tin0;
      tin[1] = tin1;
      CAST_decrypt(tin, ks);
      tout0 = tin[0] ^ xor0;
      tout1 = tin[1] ^ xor1;
      l2n(tout0, out);
      l2n(tout1, out);
      xor0 = tin0;
      xor1 = tin1;
      l -= 8;
    }
    if (l != 0) {
      n2l(in, tin0);
      n2l(in, tin1);
      tin[0] = tin0;
      tin[1] = tin1;
      CAST_decrypt(tin, ks);
      tout0 = tin[0] ^ xor0;
      tout1 = tin[1] ^ xor1;
      l2nn(tout0, tout1, out, l);
      xor0 = tin0;
      xor1 = tin1;
    }
    l2n(xor0, iv);
    l2n(xor1, iv);
  }
  tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
  tin[0] = tin[1] = 0;
}

#define CAST_exp(l, A, a, n)   \
  A[n / 4] = l;                \
  a[n + 3] = (l)&0xff;         \
  a[n + 2] = (l >> 8) & 0xff;  \
  a[n + 1] = (l >> 16) & 0xff; \
  a[n + 0] = (l >> 24) & 0xff;
#define S4 CAST_S_table4
#define S5 CAST_S_table5
#define S6 CAST_S_table6
#define S7 CAST_S_table7

void CAST_set_key(CAST_KEY *key, size_t len, const uint8_t *data) {
  uint32_t x[16];
  uint32_t z[16];
  uint32_t k[32];
  uint32_t X[4], Z[4];
  uint32_t l, *K;
  size_t i;

  for (i = 0; i < 16; i++) {
    x[i] = 0;
  }

  if (len > 16) {
    len = 16;
  }

  for (i = 0; i < len; i++) {
    x[i] = data[i];
  }

  if (len <= 10) {
    key->short_key = 1;
  } else {
    key->short_key = 0;
  }

  K = &k[0];
  X[0] = ((x[0] << 24) | (x[1] << 16) | (x[2] << 8) | x[3]) & 0xffffffffL;
  X[1] = ((x[4] << 24) | (x[5] << 16) | (x[6] << 8) | x[7]) & 0xffffffffL;
  X[2] = ((x[8] << 24) | (x[9] << 16) | (x[10] << 8) | x[11]) & 0xffffffffL;
  X[3] = ((x[12] << 24) | (x[13] << 16) | (x[14] << 8) | x[15]) & 0xffffffffL;

  for (;;) {
    l = X[0] ^ S4[x[13]] ^ S5[x[15]] ^ S6[x[12]] ^ S7[x[14]] ^ S6[x[8]];
    CAST_exp(l, Z, z, 0);
    l = X[2] ^ S4[z[0]] ^ S5[z[2]] ^ S6[z[1]] ^ S7[z[3]] ^ S7[x[10]];
    CAST_exp(l, Z, z, 4);
    l = X[3] ^ S4[z[7]] ^ S5[z[6]] ^ S6[z[5]] ^ S7[z[4]] ^ S4[x[9]];
    CAST_exp(l, Z, z, 8);
    l = X[1] ^ S4[z[10]] ^ S5[z[9]] ^ S6[z[11]] ^ S7[z[8]] ^ S5[x[11]];
    CAST_exp(l, Z, z, 12);

    K[0] = S4[z[8]] ^ S5[z[9]] ^ S6[z[7]] ^ S7[z[6]] ^ S4[z[2]];
    K[1] = S4[z[10]] ^ S5[z[11]] ^ S6[z[5]] ^ S7[z[4]] ^ S5[z[6]];
    K[2] = S4[z[12]] ^ S5[z[13]] ^ S6[z[3]] ^ S7[z[2]] ^ S6[z[9]];
    K[3] = S4[z[14]] ^ S5[z[15]] ^ S6[z[1]] ^ S7[z[0]] ^ S7[z[12]];

    l = Z[2] ^ S4[z[5]] ^ S5[z[7]] ^ S6[z[4]] ^ S7[z[6]] ^ S6[z[0]];
    CAST_exp(l, X, x, 0);
    l = Z[0] ^ S4[x[0]] ^ S5[x[2]] ^ S6[x[1]] ^ S7[x[3]] ^ S7[z[2]];
    CAST_exp(l, X, x, 4);
    l = Z[1] ^ S4[x[7]] ^ S5[x[6]] ^ S6[x[5]] ^ S7[x[4]] ^ S4[z[1]];
    CAST_exp(l, X, x, 8);
    l = Z[3] ^ S4[x[10]] ^ S5[x[9]] ^ S6[x[11]] ^ S7[x[8]] ^ S5[z[3]];
    CAST_exp(l, X, x, 12);

    K[4] = S4[x[3]] ^ S5[x[2]] ^ S6[x[12]] ^ S7[x[13]] ^ S4[x[8]];
    K[5] = S4[x[1]] ^ S5[x[0]] ^ S6[x[14]] ^ S7[x[15]] ^ S5[x[13]];
    K[6] = S4[x[7]] ^ S5[x[6]] ^ S6[x[8]] ^ S7[x[9]] ^ S6[x[3]];
    K[7] = S4[x[5]] ^ S5[x[4]] ^ S6[x[10]] ^ S7[x[11]] ^ S7[x[7]];

    l = X[0] ^ S4[x[13]] ^ S5[x[15]] ^ S6[x[12]] ^ S7[x[14]] ^ S6[x[8]];
    CAST_exp(l, Z, z, 0);
    l = X[2] ^ S4[z[0]] ^ S5[z[2]] ^ S6[z[1]] ^ S7[z[3]] ^ S7[x[10]];
    CAST_exp(l, Z, z, 4);
    l = X[3] ^ S4[z[7]] ^ S5[z[6]] ^ S6[z[5]] ^ S7[z[4]] ^ S4[x[9]];
    CAST_exp(l, Z, z, 8);
    l = X[1] ^ S4[z[10]] ^ S5[z[9]] ^ S6[z[11]] ^ S7[z[8]] ^ S5[x[11]];
    CAST_exp(l, Z, z, 12);

    K[8] = S4[z[3]] ^ S5[z[2]] ^ S6[z[12]] ^ S7[z[13]] ^ S4[z[9]];
    K[9] = S4[z[1]] ^ S5[z[0]] ^ S6[z[14]] ^ S7[z[15]] ^ S5[z[12]];
    K[10] = S4[z[7]] ^ S5[z[6]] ^ S6[z[8]] ^ S7[z[9]] ^ S6[z[2]];
    K[11] = S4[z[5]] ^ S5[z[4]] ^ S6[z[10]] ^ S7[z[11]] ^ S7[z[6]];

    l = Z[2] ^ S4[z[5]] ^ S5[z[7]] ^ S6[z[4]] ^ S7[z[6]] ^ S6[z[0]];
    CAST_exp(l, X, x, 0);
    l = Z[0] ^ S4[x[0]] ^ S5[x[2]] ^ S6[x[1]] ^ S7[x[3]] ^ S7[z[2]];
    CAST_exp(l, X, x, 4);
    l = Z[1] ^ S4[x[7]] ^ S5[x[6]] ^ S6[x[5]] ^ S7[x[4]] ^ S4[z[1]];
    CAST_exp(l, X, x, 8);
    l = Z[3] ^ S4[x[10]] ^ S5[x[9]] ^ S6[x[11]] ^ S7[x[8]] ^ S5[z[3]];
    CAST_exp(l, X, x, 12);

    K[12] = S4[x[8]] ^ S5[x[9]] ^ S6[x[7]] ^ S7[x[6]] ^ S4[x[3]];
    K[13] = S4[x[10]] ^ S5[x[11]] ^ S6[x[5]] ^ S7[x[4]] ^ S5[x[7]];
    K[14] = S4[x[12]] ^ S5[x[13]] ^ S6[x[3]] ^ S7[x[2]] ^ S6[x[8]];
    K[15] = S4[x[14]] ^ S5[x[15]] ^ S6[x[1]] ^ S7[x[0]] ^ S7[x[13]];
    if (K != k) {
      break;
    }
    K += 16;
  }

  for (i = 0; i < 16; i++) {
    key->data[i * 2] = k[i];
    key->data[i * 2 + 1] = ((k[i + 16]) + 16) & 0x1f;
  }
}

// The input and output encrypted as though 64bit cfb mode is being used. The
// extra state information to record how much of the 64bit block we have used
// is contained in *num.
void CAST_cfb64_encrypt(const uint8_t *in, uint8_t *out, size_t length,
                        const CAST_KEY *schedule, uint8_t *ivec, int *num,
                        int enc) {
  uint32_t v0, v1, t;
  int n = *num;
  size_t l = length;
  uint32_t ti[2];
  uint8_t *iv, c, cc;

  iv = ivec;
  if (enc) {
    while (l--) {
      if (n == 0) {
        n2l(iv, v0);
        ti[0] = v0;
        n2l(iv, v1);
        ti[1] = v1;
        CAST_encrypt((uint32_t *)ti, schedule);
        iv = ivec;
        t = ti[0];
        l2n(t, iv);
        t = ti[1];
        l2n(t, iv);
        iv = ivec;
      }
      c = *(in++) ^ iv[n];
      *(out++) = c;
      iv[n] = c;
      n = (n + 1) & 0x07;
    }
  } else {
    while (l--) {
      if (n == 0) {
        n2l(iv, v0);
        ti[0] = v0;
        n2l(iv, v1);
        ti[1] = v1;
        CAST_encrypt((uint32_t *)ti, schedule);
        iv = ivec;
        t = ti[0];
        l2n(t, iv);
        t = ti[1];
        l2n(t, iv);
        iv = ivec;
      }
      cc = *(in++);
      c = iv[n];
      iv[n] = cc;
      *(out++) = c ^ cc;
      n = (n + 1) & 0x07;
    }
  }
  v0 = v1 = ti[0] = ti[1] = t = c = cc = 0;
  *num = n;
}

static int cast_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
                         const uint8_t *iv, int enc) {
  CAST_KEY *cast_key = ctx->cipher_data;
  CAST_set_key(cast_key, ctx->key_len, key);
  return 1;
}

static int cast_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
                           size_t len) {
  CAST_KEY *cast_key = ctx->cipher_data;

  while (len >= CAST_BLOCK) {
    CAST_ecb_encrypt(in, out, cast_key, ctx->encrypt);
    in += CAST_BLOCK;
    out += CAST_BLOCK;
    len -= CAST_BLOCK;
  }
  assert(len == 0);

  return 1;
}

static int cast_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
                           size_t len) {
  CAST_KEY *cast_key = ctx->cipher_data;
  CAST_cbc_encrypt(in, out, len, cast_key, ctx->iv, ctx->encrypt);
  return 1;
}

static const EVP_CIPHER cast5_ecb = {
    .nid = NID_cast5_ecb,
    .block_size = CAST_BLOCK,
    .key_len = CAST_KEY_LENGTH,
    .iv_len = CAST_BLOCK,
    .ctx_size = sizeof(CAST_KEY),
    .flags = EVP_CIPH_ECB_MODE | EVP_CIPH_VARIABLE_LENGTH,
    .init = cast_init_key,
    .cipher = cast_ecb_cipher,
};

static const EVP_CIPHER cast5_cbc = {
    .nid = NID_cast5_cbc,
    .block_size = CAST_BLOCK,
    .key_len = CAST_KEY_LENGTH,
    .iv_len = CAST_BLOCK,
    .ctx_size = sizeof(CAST_KEY),
    .flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH,
    .init = cast_init_key,
    .cipher = cast_cbc_cipher,
};

const EVP_CIPHER *EVP_cast5_ecb(void) { return &cast5_ecb; }

const EVP_CIPHER *EVP_cast5_cbc(void) { return &cast5_cbc; }
