/* RC4 Keystream Output implemented by Karl-Uwe Frank */

#include <stdlib.h>
#include <stdio.h> 
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <math.h>


#define swap(X,Y) { uint8_t T = X; X = Y; Y = T; }



//-----------------------------------------
// 
// rm -f rc4_keystream && gcc -O3 -std=c99 rc4_keystream.c -o rc4_keystream
// 
// Usage:
// ./rc4_keystream key out_size-in-64bit > rc4_keystream_out.bin
//
//
//-----------------------------------------
//
//  Official Test Vector - Key 0102030405  | https://tools.ietf.org/html/rfc6229
//
// ./rc4_keystream 0102030405 128 | xxd -g 1
// 
// 0000000: b2 39 63 05 f0 3d c0 27 cc c3 52 4a 0a 11 18 a8  .9c..=.'..RJ....
// 0000010: 69 82 94 4f 18 fc 82 d5 89 c4 03 a4 7a 0d 09 19  i..O........z...
// 0000020: b6 8f 78 c2 8d 15 d8 22 23 4c 6c b8 c5 f6 c4 ac  ..x...."#Ll.....
// 0000030: b0 b9 96 a4 13 fe da 54 28 b0 78 86 b2 a0 85 12  .......T(.x.....
// 0000040: 56 a0 85 25 07 80 58 d0 73 35 4a 84 76 ff e7 72  V..%..X.s5J.v..r
// 0000050: 61 e4 f3 71 0f 03 0b 0c 14 89 69 4b b9 89 28 17  a..q......iK..(.
// 0000060: 65 92 a5 e2 2f 3e 85 11 35 dc 1e 6a b1 24 2b 8c  e.../>..5..j.$+.
// 0000070: 27 75 04 30 e3 1c 13 5d c8 39 98 de 2d 93 0f 3e  'u.0...].9..-..>
//-----------------------------------------
//
// echo -en 'rc4' | md5sum
//
// ./rc4_keystream 374315ed9864f687d6d5144167944eb8 | xxd -g 1
// 
// 0000000: a1 d2 ab dc 62 7d 2d aa b6 6c 85 7f 10 2d 75 24  ....b}-..l...-u$
// 0000010: 5c 1f 0f fd 0f 83 9b af a3 9a 70 2a 5c 6f 3d 38  \.........p*\o=8
// 0000020: 99 b1 81 eb df 1a 4f 1c 3a 9e e0 97 28 93 ca db  ......O.:...(...
// 0000030: a1 03 60 47 be 7b a3 80 9e df 26 7a 8d a0 4f 4c  ..`G.{....&z..OL
// 0000040: 78 b6 fe 33 5a d8 a0 2a fc 14 33 6f 26 5b 61 e2  x..3Z..*..3o&[a.
// 0000050: e1 fd f9 ae f9 4f 8b 04 5b 3c 44 bd 03 37 40 63  .....O..[<D..7@c
// 0000060: 48 e5 e5 bd c0 a2 6c ef ad 29 8f da a7 96 90 06  H.....l..)......
// 0000070: 60 f8 ce 0c 4c b1 9a 2a 8c 7a d8 73 34 9b c7 f6  `...L..*.z.s4...
// 

/*
//---------------------------------------

 	http://www.iacr.org/workshops/fse2009/slides/2302_1015_Matsui.pdf


 	[24-byte Colliding Key Pair]
 	K1 = 00 42 CE D3 DF DD B6 9D 41 3D BD 3A B1 16 5A 33 ED A2 CD 1F E2 8C 01 76
 	K2 = 00 42 CE D3 DF DD B6 9D 41 3D BD 3A B1 16 5A 33 ED A2 CD 1F E2 8C 01 77 

 ./rc4_keystream 0042CED3DFDDB69D413DBD3AB1165A33EDA2CD1FE28C0176 128 | xxd -g 1

 ./rc4_keystream 0042CED3DFDDB69D413DBD3AB1165A33EDA2CD1FE28C0177 128 | xxd -g 1

//---------------------------------------

 	[43-byte Colliding Key Pair]
 	K1 = 00 6d 41 8b 95 46 07 a4 87 8d 69 d7 bc bc c4 70 4a 3b ed 94 34 50 04 68 4d 4f 2e 30 c1 6e 20 a8 bf 80 b6 ae df ae 43 56 0a 80 e7
 	K2 = 00 6d 41 8b 95 46 07 a4 87 8d 69 d7 bc bc c4 70 4a 3b ed 94 34 50 04 68 4d 4f 2e 30 c1 6e 20 a8 bf 80 b6 ae df ae 43 56 0a 80 e8

 ./rc4_keystream 006d418b954607a4878d69d7bcbcc4704a3bed94345004684d4f2e30c16e20a8bf80b6aedfae43560a80e7 128 | xxd -g 1

 ./rc4_keystream 006d418b954607a4878d69d7bcbcc4704a3bed94345004684d4f2e30c16e20a8bf80b6aedfae43560a80e8 128 | xxd -g 1

*/
//---------------------------------------


//-----------------------------------------
// Main 
//
int main (int argc, char *argv[]) 
{ 
  // initialisation
  char* PrgName;

	uint8_t  a, b, j, k, t, out_8bit;
	uint8_t SBox[256];
	uint64_t output_size, i;

	// Check if a Seed is passed through
 	if (argc < 3) {
 		fprintf(stderr,"\nUasge: key as hex formated string without leading 0x");
 		fprintf(stderr,"\n       and size of output as byte value >0 and max. 64bit\n");
 		fprintf(stderr,"\nExample: ");
 		fprintf(stderr,"\n./rc4_keystream 374315ed9864f687d6d5144167944eb8 1048576 > rc4_keystream_out.bin\n\n");
 		return 1;
 	}	
		
 	output_size = (int)strtoul(argv[2], NULL, 0);
 	
 	if (output_size == 0) {
		fprintf(stderr,"\nError: size of output must be byte value >0 and max. 64bit\n\n");
	 	exit(1);
	}

	// We have a key
	uint8_t key[256];
	uint8_t keyLen;
	uint8_t hexKey[256];
	uint8_t hex[3]; 

	// Make sure the arrays get initialised properly
	// and wipe out anything which might be there
	memset(key,    0, 256);
	memset(hexKey, 0, 256);
	memset(hex,    0, 3);

	// Rebuild key[] from KeyHash
	strcpy(hexKey, argv[1]);
	keyLen = strlen(hexKey);
	hexKey[keyLen] = 0;

	keyLen = keyLen/2;
	for (uint8_t i=0; i<keyLen; i++) {
		strncpy(hex, hexKey +(i*2), 2);
		key[i] = strtol(hex, NULL, 16);
	}


	/*
	fprintf(stderr, "========= Start Values (rc4 8-bit) ============\n\n");
	fprintf(stderr, "                 key = %s\n\n", argv[1]); 
	fprintf(stderr, "              keyLen = %d\n\n", keyLen); 
	fprintf(stderr, "  Output size (byte) = %s\n\n", argv[2]); 
	fprintf(stderr, "===================================================\n\n");
	*/

  //-----------------------------------------
  // Initialisation of rc4
  //
  // perform the Key Schedule
  for (int i=0; i<256; i++) {
    SBox[i] = i;
  }

	k=0; j=0;
	
	for (int i=0; i<256; i++) {
		k = (i % keyLen);
		j = (j + SBox[i] + key[k]);
		swap(SBox[i], SBox[j]);
	}
		
	a=0; b=0;

  fflush(stdout);

	// Output the keystream
  for (uint64_t i=0; i<output_size; i++) {
		a = a + 1;
		b = b + SBox[a];
	
		swap(SBox[a], SBox[b]);
	
		t = (SBox[a] + SBox[b]);

		out_8bit = SBox[t];
    
    // write keystream to stdout
    fwrite(&out_8bit, sizeof(out_8bit), 1, stdout);
	}

  fflush(stdout);

  return 0;
}