// Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <assert.h>
#include <string.h>

#include "internal.h"


using namespace bssl;

static_assert(16 % sizeof(size_t) == 0, "block cannot be divided into size_t");

void bssl::CRYPTO_cfb128_encrypt(const uint8_t *in, uint8_t *out, size_t len,
                                 const AES_KEY *key, uint8_t ivec[16],
                                 unsigned *num, int enc, block128_f block) {
  assert(in && out && key && ivec && num);

  unsigned n = *num;

  if (enc) {
    while (n && len) {
      *(out++) = ivec[n] ^= *(in++);
      --len;
      n = (n + 1) % 16;
    }
    while (len >= 16) {
      (*block)(ivec, ivec, key);
      for (; n < 16; n += sizeof(crypto_word_t)) {
        crypto_word_t tmp =
            CRYPTO_load_word_le(ivec + n) ^ CRYPTO_load_word_le(in + n);
        CRYPTO_store_word_le(ivec + n, tmp);
        CRYPTO_store_word_le(out + n, tmp);
      }
      len -= 16;
      out += 16;
      in += 16;
      n = 0;
    }
    if (len) {
      (*block)(ivec, ivec, key);
      while (len--) {
        out[n] = ivec[n] ^= in[n];
        ++n;
      }
    }
    *num = n;
    return;
  } else {
    while (n && len) {
      uint8_t c;
      *(out++) = ivec[n] ^ (c = *(in++));
      ivec[n] = c;
      --len;
      n = (n + 1) % 16;
    }
    while (len >= 16) {
      (*block)(ivec, ivec, key);
      for (; n < 16; n += sizeof(crypto_word_t)) {
        crypto_word_t t = CRYPTO_load_word_le(in + n);
        CRYPTO_store_word_le(out + n, CRYPTO_load_word_le(ivec + n) ^ t);
        CRYPTO_store_word_le(ivec + n, t);
      }
      len -= 16;
      out += 16;
      in += 16;
      n = 0;
    }
    if (len) {
      (*block)(ivec, ivec, key);
      while (len--) {
        uint8_t c;
        out[n] = ivec[n] ^ (c = in[n]);
        ivec[n] = c;
        ++n;
      }
    }
    *num = n;
    return;
  }
}


/* This expects a single block of size nbits for both in and out. Note that
   it corrupts any extra bits in the last byte of out */
static void cfbr_encrypt_block(const uint8_t *in, uint8_t *out, unsigned nbits,
                               const AES_KEY *key, uint8_t ivec[16], int enc,
                               block128_f block) {
  int n, rem, num;
  uint8_t ovec[16 * 2 + 1]; /* +1 because we dererefence (but don't use) one
                               byte off the end */

  if (nbits <= 0 || nbits > 128) {
    return;
  }

  // fill in the first half of the new IV with the current IV
  OPENSSL_memcpy(ovec, ivec, 16);
  // construct the new IV
  (*block)(ivec, ivec, key);
  num = (nbits + 7) / 8;
  if (enc) {
    // encrypt the input
    for (n = 0; n < num; ++n) {
      out[n] = (ovec[16 + n] = in[n] ^ ivec[n]);
    }
  } else {
    // decrypt the input
    for (n = 0; n < num; ++n) {
      out[n] = (ovec[16 + n] = in[n]) ^ ivec[n];
    }
  }
  // shift ovec left...
  rem = nbits % 8;
  num = nbits / 8;
  if (rem == 0) {
    OPENSSL_memcpy(ivec, ovec + num, 16);
  } else {
    for (n = 0; n < 16; ++n) {
      ivec[n] = ovec[n + num] << rem | ovec[n + num + 1] >> (8 - rem);
    }
  }

  // it is not necessary to cleanse ovec, since the IV is not secret
}

// N.B. This expects the input to be packed, MS bit first
void bssl::CRYPTO_cfb128_1_encrypt(const uint8_t *in, uint8_t *out, size_t bits,
                                   const AES_KEY *key, uint8_t ivec[16],
                                   unsigned *num, int enc, block128_f block) {
  size_t n;
  uint8_t c[1], d[1];

  assert(in && out && key && ivec && num);
  assert(*num == 0);

  for (n = 0; n < bits; ++n) {
    c[0] = (in[n / 8] & (1 << (7 - n % 8))) ? 0x80 : 0;
    cfbr_encrypt_block(c, d, 1, key, ivec, enc, block);
    out[n / 8] = (out[n / 8] & ~(1 << (unsigned int)(7 - n % 8))) |
                 ((d[0] & 0x80) >> (unsigned int)(n % 8));
  }
}

void bssl::CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out,
                                   size_t length, const AES_KEY *key,
                                   unsigned char ivec[16], unsigned *num,
                                   int enc, block128_f block) {
  size_t n;

  assert(in && out && key && ivec && num);
  assert(*num == 0);

  for (n = 0; n < length; ++n) {
    cfbr_encrypt_block(&in[n], &out[n], 8, key, ivec, enc, block);
  }
}