/*
 * Copyright (c) 1997,2011,2013-2014 Apple Inc. All Rights Reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */


#include "comcryptPriv.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#ifdef	macintosh
#include <MacMemory.h>
#endif

/* if NULL, use our own */
comMallocExternFcn *comMallocExt = NULL;
comFreeExternFcn *comFreeExt = NULL;

#if		COM_STATS
comStats _comStats;

void resetComStats()
{
	memset(&_comStats, 0, sizeof(comStats));
}

void getComStats(comStats *stats)
{
	*stats = _comStats;
}

#else	/*COM_STATS*/

#define	incrComStat(stat, num)

#endif	/*COM_STATS*/

/*
 * Generate a symbol permutation from the key.
 */
void key_perm(
	const unsigned char *key,
	int 				keybytes,
	unsigned char 		*map,
	unsigned char 		*invmap)
{
    int i, j, tmp, sum;

    for(sum = 0, j = 0; j < keybytes; j++) {
		sum += key[j];
	}
	for(j=0; j < 256; j++) {
		map[j] = j;
	}
	for(j=0; j < 255; j++) {
		i = (key[j % keybytes] + j*sum) & 0xff;
		tmp = map[i];
		map[i] = map[j];
		map[j] = tmp;
	}
	for(j=0; j<256; j++) {
		invmap[map[j]] = j;
	}
}

int keybyte(
	const unsigned char *key,
	int 				keybytes,
	int 				index)
{
    return((int) key[index % keybytes]);
}

int keynybble(
	const unsigned char *key,
	int 				keybytes,
	int 				index)
{
	int i = index % (2*keybytes);
	int j;

    j = key[i>>1]; 		/* Which byte. */
    if(i & 1) j >>= 4; 	/* Which nybble. */
    return(j & 0xf);
}

/*
 * Hash a key array.
 */

#define HASH_SEED	3
#define HASH_REDUCE	1023

static unsigned keyHash(const unsigned char *key, unsigned keylen)
{
	unsigned x = HASH_SEED;  /* Any seed in [1,p-1].  Like SEED = 3. */
	unsigned ctr;

	for(ctr=0; ctr<keylen; ctr++) {
		x = (x * (key[ctr] + (ctr & HASH_REDUCE) + 1)) % HASH_PRIME;
	}
	return x;
}

void mallocCodeBufs(comcryptBuf *cbuf)
{
	/*
	 * calculate required buffer sizes. 
	 *
	 * Assume max required codeBuf size is the max size of ciphertext needed
	 * to decrypt one block of plaintext.
	 */
	cbuf->codeBufSize = comcryptMaxOutBufSize(NULL,
		CC_BLOCK_SIZE,
		CCOP_COMCRYPT,
		1);
	cbuf->codeBuf = (unsigned char *)ascMalloc(cbuf->codeBufSize);

	/*
	 * max size needed for level2Buf is the MaxOutBufSize of comcrypting
	 * a whole block of byte code. Note we assume that MaxOutBufSize(n) >= n.
	 */
	cbuf->level2BufSize = comcryptMaxOutBufSize(NULL,
		MAX_TOKENS,				// one byte per token
		CCOP_COMCRYPT,
		1);
	cbuf->level2Buf = (unsigned char *)ascMalloc(cbuf->level2BufSize);

	cbuf->queue = (queueElt *)ascMalloc(sizeof(queueElt) * QLEN);

	#if		QUEUE_LOOKAHEAD
	/*
	 * Might want to do this dynamically, though that requires the malloc
	 * of the lookAhead buffer to be done in initCodeBufs(), not here (at
	 * comcryptAlloc() time).
	 *
	 * FIXME : should do the malloc of lookAhead buffer lazily for
	 * non-Mac platforms.
	 */
	cbuf->lookAhead = (unsigned char *)ascMalloc(LOOKAHEAD_SIZE);
	#else	/* QUEUE_LOOKAHEAD */
	cbuf->lookAhead = NULL;
	#endif	/* QUEUE_LOOKAHEAD */

	/*
	 * This maybe should also be done dynamically, lazily...
	 */
	cbuf->sigArray = (unsigned *)ascMalloc((MAX_TOKENS + 1) * sizeof(unsigned));
}

void initCodeBufs(
	comcryptBuf *cbuf,
	const unsigned char *key,
	unsigned keyLen,
	unsigned char laEnable,
	unsigned char sigSeqEnable)
{
	unsigned ct;
	unsigned qval;
	unsigned char khash = (unsigned char)keyHash(key, keyLen);

	cbuf->nybbleDex = khash;

	if(laEnable) {
		memset(cbuf->lookAhead, 0, LOOKAHEAD_SIZE);
	}

	laprintf(("initing queue and lookahead\n"));

	for(ct=0; ct<QLEN; ct++) {
		/*
		 * New queue init 23 Dec - init from khash
		 */
		unsigned short sbyte = ct ^ khash;
		qval = (sbyte << 8) | ct;
		cbuf->queue[ct] = qval;
		if(laEnable) {
			markInQueue(cbuf, qval, 1);
		}
	}
	// note cbuf->nybbleDex = khash on return...

	cbuf->f1 = F1_DEFAULT;
	cbuf->f2 = F2_DEFAULT;
	cbuf->jmatchThresh = THRESH_2LEVEL_JMATCH_DEF;
	cbuf->minByteCode  = THRESH_2LEVEL_NUMBYTECODES_DEF;
	if(sigSeqEnable) {
		initSigSequence(cbuf, key, keyLen);
	}
}

void freeCodeBufs(comcryptBuf *cbuf)
{
	if(cbuf->queue != NULL) {
		ascFree(cbuf->queue);
	}
	if(cbuf->codeBuf != NULL) {
		ascFree(cbuf->codeBuf);
	}
	if(cbuf->level2Buf != NULL) {
		ascFree(cbuf->level2Buf);
	}
	if(cbuf->nextBuf != NULL) {
		freeCodeBufs(cbuf->nextBuf);
		ascFree(cbuf->nextBuf);
		cbuf->nextBuf = NULL;
	}
	if(cbuf->lookAhead != NULL) {
		ascFree(cbuf->lookAhead);
	}
	if(cbuf->sigArray != NULL) {
		ascFree(cbuf->sigArray);
	}
}

void serializeInt(
	unsigned i,
	unsigned char *buf)
{
	buf[0] = (unsigned char)(i >> 24);
	buf[1] = (unsigned char)(i >> 16);
	buf[2] = (unsigned char)(i >> 8);
	buf[3] = (unsigned char)(i & 0xff);
}

unsigned deserializeInt(unsigned char *buf)
{
	unsigned i;

	i  = ((unsigned)buf[0]) << 24;
	i |= ((unsigned)buf[1]) << 16;
	i |= ((unsigned)buf[2]) << 8;
	i |= buf[3];
	return i;
}

#if		COM_PARAM_ENABLE

unsigned getF1(comcryptObj cobj)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	return cpriv->cbuf.f1;
}

void setF1(comcryptObj cobj, unsigned f1)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	cpriv->cbuf.f1 = f1;
	if(cpriv->cbuf.nextBuf != NULL) {
		cpriv->cbuf.nextBuf->f1 = f1;
	}
}

unsigned getF2(comcryptObj cobj)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	return cpriv->cbuf.f2;
}

void setF2(comcryptObj cobj, unsigned f2)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	cpriv->cbuf.f2 = f2;
	if(cpriv->cbuf.nextBuf != NULL) {
		cpriv->cbuf.nextBuf->f2 = f2;
	}
}

unsigned getJmatchThresh(comcryptObj cobj)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	return cpriv->cbuf.jmatchThresh;
}

void setJmatchThresh(comcryptObj cobj, unsigned jmatchThresh)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	cpriv->cbuf.jmatchThresh = jmatchThresh;
	if(cpriv->cbuf.nextBuf != NULL) {
		cpriv->cbuf.nextBuf->jmatchThresh = jmatchThresh;
	}
}

unsigned getMinByteCode(comcryptObj cobj)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	return cpriv->cbuf.minByteCode;
}

void setMinByteCode(comcryptObj cobj, unsigned minByteCode)
{
	comcryptPriv *cpriv = (comcryptPriv *)cobj;

	cpriv->cbuf.minByteCode = minByteCode;
	if(cpriv->cbuf.nextBuf != NULL) {
		cpriv->cbuf.nextBuf->minByteCode = minByteCode;
	}
}

#endif	/*COM_PARAM_ENABLE*/


#if		COM_LA_DEBUG

/*
 * Verify integrity of lookahead w.r.t. queue.
 */
int testLookAhead(comcryptBuf *cbuf, int i1, int i2)
{
	unsigned i;

	if(!cbuf->laEnable) {
		return 0;
	}
	for(i=0; i<QLEN; i++) {
		if(!inQueue(cbuf, cbuf->queue[i])) {
			printf("aaagh, corrupted lookahead - in queue[], !inQueue()\n");
			printf("i=0x%x   i1=0x%x   i2=0x%x\n",
				i, i1, i2);
			printf("\n");
			exit(1);
		}
	}
	//return initTestLookAhead(cbuf);
	return 0;
}

int initTestLookAhead(comcryptBuf *cbuf)
{
	#if		QUEUE_LOOKAHEAD_BIT

	unsigned codeWord = 0;
	unsigned char bit;
	unsigned short byte;
	unsigned char *la = cbuf->lookAhead;

	for(byte=0; byte<LOOKAHEAD_SIZE; byte++) {
		for(bit=1; bit!=0; bit<<=1) {
			if(la[byte] & bit) {
				/*
				 * in lookahead, make sure it's in queue[]
				 */
				int i;
				int found = 0;

				for(i=0; i<QLEN; i++) {
					if(cbuf->queue[i] == codeWord) {
						found = 1;
						break;
					}
				}
				if(!found) {
					printf("***corrupted init lookahead - in l.a., "
						"not in queue[]\n");
					printf("codeWord 0x%x\n", codeWord);
					printf("\n");
					exit(1);
				}
			}
			codeWord++;
		}
	}

	#endif	/* QUEUE_LOOKAHEAD_BIT */
	return 0;
}

#endif	/* COM_LA_DEBUG */

void initSigSequence(comcryptBuf *cbuf,
	const unsigned char *key,
	unsigned keyLen)
{
    unsigned seed = IN_OFFSET;
	unsigned j;

    for(j=0; j<keyLen; j++) {
		seed += key[j];
    }
    seed %= HASH_PRIME;
    if(seed == 0) {
		seed = IN_OFFSET;
	}
	cbuf->sigArray[0] = (unsigned short)seed;
}

#if	0
/*
 * Called once per token bit, after processing the token.
 */
void nextSigWord(comcryptBuf *cbuf,
	unsigned sigDex,			// same as tokenDex
	unsigned match,
	unsigned above)				// jabove, keyabove
{
	unsigned offset;
	unsigned short *sigArray = cbuf->sigArray;

	#if		COM_DEBUG
	if(sigDex == 0) {
		printf("nextSigWord underflow\n");
		exit(1);
	}
	if(sigDex > MAX_TOKENS) {
		printf("nextSigWord overflow\n");
		exit(1);
	}
	#endif

	if(match) {
		offset = IN_OFFSET;
	}
	else {
		offset = OUT_OFFSET;
	}
#if		1
	sigArray[sigDex] = (sigArray[sigDex-1] * (above + offset)) % HASH_PRIME;
#endif
}
#endif

/*
 * Obfuscate a block of ciphertext.
 */
void sigMunge(comcryptBuf *cbuf,
	const unsigned char *tokenPtr,
	unsigned numTokens,
	unsigned char *byteCodePtr,
	unsigned char *longCodePtr)
{
	unsigned char tokenBit = 0x01;
	unsigned token;
	unsigned short sig;

	for(token=0; token<numTokens; token++) {
		sig = cbuf->sigArray[token];
		if(*tokenPtr & tokenBit) {
			/* no match - munge longCode - written MSB first */
			*longCodePtr++ ^= (unsigned char)(sig >> 8);
			*longCodePtr++ ^= (unsigned char)sig;
		}
		else {
			/* match - munge byteCode */
			*byteCodePtr++ ^= (unsigned char)sig;
		}
		tokenBit <<= 1;
		if(tokenBit == 0) {
			tokenBit = 0x01;
			tokenPtr++;
		}
	}
}


/*
 * All this can be optimized and tailored to specific platforms, of course...
 */

void *ascMalloc(unsigned size)
{
	#ifdef	macintosh

	Handle h;
	OSErr err;
	Ptr p;

	#endif	/* mac */
	
	if(comMallocExt != NULL) {
		return (comMallocExt)(size);
	}
	
	#ifdef	macintosh

	h = nil;
	err = errSecSuccess;

	h = NewHandleSys(size);		// system heap is not paged
	do{
		HLockHi(h);			// will move low in system heap
		err = MemError();
		if( err != errSecSuccess ) break;
		p = *h;
	}while(0);
	if( err != errSecSuccess ){
	    return NULL;
	}
	return p;

	#else	/* others...*/
	return malloc(size);
	#endif
}

void ascFree(void *data)
{
	#ifdef macintosh
	Handle h;
	#endif
	
	if(comFreeExt != NULL) {
		(comFreeExt)(data);
		return;
	}

	#ifdef macintosh
	if( data != nil ){
		h = RecoverHandle((Ptr) data);
		DisposeHandle(h);
	}

	#else	/* others */
	free(data);
	#endif
}