neocrypt.c

/* ========================================================================== *\
||				   NeoCrypt				      ||
||                                 Neo_Chen                                   ||
\* ========================================================================== */

/* ========================================================================== *\
||   This is free and unencumbered software released into the public domain.  ||
||									      ||
||   Anyone is free to copy, modify, publish, use, compile, sell, or	      ||
||   distribute this software, either in source code form or as a compiled    ||
||   binary, for any purpose, commercial or non-commercial, and by any	      ||
||   means.								      ||
||									      ||
||   In jurisdictions that recognize copyright laws, the author or authors    ||
||   of this software dedicate any and all copyright interest in the	      ||
||   software to the public domain. We make this dedication for the benefit   ||
||   of the public at large and to the detriment of our heirs and	      ||
||   successors. We intend this dedication to be an overt act of	      ||
||   relinquishment in perpetuity of all present and future rights to this    ||
||   software under copyright law.					      ||
||									      ||
||   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	      ||
||   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF       ||
||   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   ||
||   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR        ||
||   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,    ||
||   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR    ||
||   OTHER DEALINGS IN THE SOFTWARE.					      ||
||									      ||
||   For more information, please refer to <http://unlicense.org/>            ||
\* ========================================================================== */

/* Use POSIX C Source */
#ifndef _POSIX_C_SOURCE
#  define _POSIX_C_SOURCE 1
#endif

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <getopt.h>

/* Check if inline is supported */
#if INLINE && __GNUC_STDC_INLINE__
#  define _INLINE inline static
#else
#  define _INLINE
#endif

#ifdef EXPECT_MACRO
#  define likely(x)	__builtin_expect(!!(x), 1)
#  define unlikely(x)	__builtin_expect(!!(x), 0)
#else
#  define likely(x)	(x)
#  define unlikely(x)	(x)
#endif

typedef uint32_t crc32_t;

#define KEYSIZE	256
FILE *pwfile;
uint8_t key[KEYSIZE];
size_t keylength=0;

/* RC4 variables */
uint8_t rc4_sbox[256];
uint8_t rc4_i=0, rc4_j=0;

/* algorithm selection */
static void (*blkenc)(uint8_t *in, uint8_t *out, size_t bs);
enum algo
{
	RC4,
	CRC32
} algo;

/* Bulk IO */
uint8_t * restrict inbuf;
uint8_t * restrict outbuf;
size_t bufnbyte=0;
size_t bufsize=(1<<18);

/* Main I/O */
FILE * restrict in;
FILE * restrict out;
char infile[PATH_MAX];
char outfile[PATH_MAX];

uint8_t status=0;
#define ST_KEY_MASK	0x1
#define ST_KEY		(status & ST_KEY_MASK)

uint8_t verbose=0;

void panic(char *msg)
{
	fputs(msg, stderr);
	putc('\n', stderr);
	exit(1);
}

void info(char *fmt, ...)
{
	va_list args;
	va_start (args, fmt);
	if(verbose > 0)
	{
		vfprintf(stderr, fmt, args);
	}
	va_end(args);
}

void *allocate(size_t size)
{
	void *ptr = malloc(size);
	if(ptr == NULL)
		panic("Memory allocate error");
	memset(ptr, 0, size);
	return ptr;
}

_INLINE void swap(uint8_t * restrict a, uint8_t * restrict b)
{
	uint8_t temp=0;
	temp = *a;
	*a = *b;
	*b = temp;
}

/* RC4 core routine */
static void rc4_ksa(uint8_t *s, uint8_t *key, size_t len)
{
	unsigned int ksa_i=0, ksa_j=0;

	for(ksa_i=0; ksa_i < (1<<8); ++ksa_i)
		s[ksa_i]=ksa_i;
	for(ksa_i=0; ksa_i < (1<<8); ++ksa_i)
	{
		ksa_j = (ksa_j + s[ksa_i] + key[ksa_i % len]) & 0xFF;
		swap(s + ksa_i, s + ksa_j);
	}
}

_INLINE uint8_t rc4_prga(uint8_t * restrict s)
{
	rc4_j += s[++rc4_i];
	swap(s + rc4_i, s + rc4_j);
	return s[(uint8_t)(s[rc4_i] + s[rc4_j])];
}

static void rc4_blkenc(uint8_t * restrict in, uint8_t * restrict out, size_t bs)
{
	size_t i=0;
	for(i=0; likely(i < bs); i++)
		out[i] = in[i] ^ rc4_prga(rc4_sbox);
}

/* CRC32 routine generated by pycrc */

/* CRC32 table */
static const crc32_t crc32_table[256] = {
	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
	0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
	0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
	0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
	0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
	0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
	0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
	0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
	0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
	0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
	0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
	0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
	0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
	0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
	0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
	0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
	0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
	0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
	0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
	0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

crc32_t crc32_init(void)
{
	return 0xffffffff;
}

crc32_t crc32_end(crc32_t crc)
{
	return crc ^ 0xffffffff;
}

_INLINE crc32_t crc32_update(crc32_t crc, const uint8_t *data, size_t len)
{
	uint8_t index=0;
	size_t i=0;

	for(i = 0; likely(i < len); i++)
	{
		index = crc ^ *data;
		crc = crc32_table[index] ^ (crc >> 8);
		data++;
	}
	return crc;
}

size_t readbyte(uint8_t *dst, size_t limit, FILE *fd)
{
	size_t size=0;
	int input=0;
	while((size < limit) && ((input = getc(fd)) != EOF))
	{
		dst[size++] = input;
	}
	return size;
}

void parsearg(int argc, char **argv)
{
	int opt;
	while((opt = getopt(argc, argv, "ha:i:o:k:p:b:v")) != -1)
	{
		switch(opt)
		{
			case 'a':	/* Algorithm */
				if(strcmp(optarg, "rc4") == 0)
					algo = RC4;
				else if(strcmp(optarg, "crc32") == 0)
					algo = CRC32;
				else
					panic("Invalid Algortihm Name");
				break;
			case 'i':	/* Input */
				if(strcmp(optarg, "-"))
				{
					/* if not "-" */
					if((in = fopen(optarg, "rb")) == NULL)
					{
						perror(optarg);
						exit(8);
					}
				}
				else
					in=stdin;	/* stdin */
				strncpy(infile, optarg, PATH_MAX - 1);
				break;
			case 'o':	/* Output */
				if(strcmp(optarg, "-"))
				{
					/* if not "-" */
					if((out = fopen(optarg, "wb+")) == NULL)
					{
						perror(optarg);
						exit(8);
					}
				}
				else
					out=stdout;	/* stdout */
				strncpy(outfile, optarg, PATH_MAX - 1);
				break;
			case 'k':	/* Key from argument */
				strncpy((char*)key, optarg, KEYSIZE - 1);
				keylength = strlen((char*)key);
				status |= ST_KEY_MASK;
				break;
			case 'p':	/* Key from fd */
				if(strcmp(optarg, "-"))
				{
					if((pwfile = fopen(optarg, "r")) == NULL)
					{
						perror(optarg);
						exit(8);
					}
					keylength = readbyte(key, KEYSIZE, pwfile);
				}
				else
				{
					pwfile=stdin;
					if(in == stdin)	/* fd == stdin */
						panic("in == pwfile == stdin");

					/* Prompt */
					fputs("PASSWORD=", stderr);
					keylength = readbyte(key, KEYSIZE, stdin);
				}
				status |= ST_KEY_MASK;
				break;
			case 'b':	/* Buffer size in KiB */
				bufsize = 0;
				sscanf(optarg, "%zu", &bufsize);
				if(bufsize == 0)
					panic("Buffer size == 0");
				else
					bufsize <<= 10;
				break;
			case 'v':
				verbose++;
				break;
			default:
			case 'h': /* Help */
				fprintf(stderr, "Usage: %s [-a algo] [-h] [-i infile] [-o outfile] [-k key] [-p keyfile] [-b bufsize]\n", argv[0]);
				exit(0);
				break;
		}
	}
}

int main(int argc, char **argv)
{
	info("RC4 & CRC32 Calculation Utility\n");

	/* Initialize Defaults */
	in  = stdin;
	out = stdout;
	algo = RC4;
	crc32_t crc=0;

	parsearg(argc, argv);
	info("bufsize = %zuK\n", bufsize >> 10);

	if(!ST_KEY && algo == RC4)
		panic("No key is given");

	switch(algo)
	{
		case RC4:
			blkenc = rc4_blkenc;
			rc4_ksa(rc4_sbox, key, keylength);
			break;
		case CRC32:
			crc = crc32_init();
			break;
		default:
			panic("Invalid Algorithm");
	}

	info("Init Done\n");

	inbuf = allocate(bufsize);
	outbuf = allocate(bufsize);

	info("Entering Bulk-Operation Loop\n");
	switch(algo)
	{
		case CRC32:
			while(likely((bufnbyte = fread(inbuf, 1, bufsize, in)) != 0))
				crc = crc32_update(crc, inbuf, bufnbyte);

			crc = crc32_end(crc);
			fprintf(stdout, "CRC32 = 0x%08X\n", crc);
			break;
		case RC4:
		default:
			while(likely((bufnbyte = fread(inbuf, 1, bufsize, in)) != 0))
			{
				blkenc(inbuf, outbuf, bufnbyte);
				if(unlikely(fwrite(outbuf, 1, bufnbyte, out) != bufnbyte))
						break;
			}
			break;
	}

	if(ferror(in))
		perror(infile);
	if(ferror(out))
		perror(outfile);

	/* Final clean-up */
	info("Clean-up\n");
	fclose(in);
	fclose(out);
	free(inbuf);
	free(outbuf);
	return 0;
}