/** @file rc4.c
 *
 *  @brief This file defines rc4 encrypt algorithm
 *
 * Copyright (C) 2014-2017, Marvell International Ltd.
 *
 * This software file (the "File") is distributed by Marvell International
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available by writing to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 */

/******************************************************
Change log:
    03/07/2014: Initial version
******************************************************/
#include "wltypes.h"
#include "rc4_rom.h"
#include "hostsa_ext_def.h"
#include "authenticator.h"

typedef struct rc4_key {
	unsigned char state[256];
	unsigned char x;
	unsigned char y;
} rc4_key;

static rc4_key rc4key;

static void swap_byte(unsigned char *a, unsigned char *b);

void
prepare_key(unsigned char *key_data_ptr, int key_data_len, rc4_key *key)
{
	unsigned char index1;
	unsigned char index2;
	unsigned char *state;
	short counter;

	state = &key->state[0];
	for (counter = 0; counter < 256; counter++) {
		state[counter] = counter;
	}
	key->x = 0;
	key->y = 0;
	index1 = 0;
	index2 = 0;
	for (counter = 0; counter < 256; counter++) {
		index2 = (key_data_ptr[index1] + state[counter] + index2) % 256;
		swap_byte(&state[counter], &state[index2]);

		index1 = (index1 + 1) % key_data_len;
	}
}

void
rc4(unsigned char *buffer_ptr, int buffer_len, int skip, rc4_key *key)
{
	unsigned char x;
	unsigned char y;
	unsigned char *state;
	unsigned char xorIndex;
	short counter;

	x = key->x;
	y = key->y;

	state = &key->state[0];

	for (counter = 0; counter < skip; counter++) {
		x = (x + 1) % 256;
		y = (state[x] + y) % 256;
		swap_byte(&state[x], &state[y]);
	}

	for (counter = 0; counter < buffer_len; counter++) {
		x = (x + 1) % 256;
		y = (state[x] + y) % 256;
		swap_byte(&state[x], &state[y]);

		xorIndex = (state[x] + state[y]) % 256;

		buffer_ptr[counter] ^= state[xorIndex];
	}
	key->x = x;
	key->y = y;
}

static void
swap_byte(unsigned char *a, unsigned char *b)
{
	unsigned char swapByte;

	swapByte = *a;
	*a = *b;
	*b = swapByte;
}

void
RC4_Encrypt(void *priv, unsigned char *Encr_Key,
	    unsigned char *IV,
	    unsigned short iv_length,
	    unsigned char *Data,
	    unsigned short data_length, unsigned short skipBytes)
{
	phostsa_private psapriv = (phostsa_private)priv;
	hostsa_util_fns *util_fns = &psapriv->util_fns;
	unsigned char key[32];

	if (iv_length + 16 > sizeof(key)) {
		return;
	}

	memcpy(util_fns, key, IV, iv_length);
	memcpy(util_fns, key + iv_length, Encr_Key, 16);

	prepare_key(key, iv_length + 16, &rc4key);
	rc4(Data, data_length, skipBytes, &rc4key);
}