X-Git-Url: https://git.saurik.com/apple/security.git/blobdiff_plain/5dd5f9ec28f304ca377c42fd7f711d6cf12b90e1..5c19dc3ae3bd8e40a9c028b0deddd50ff337692c:/Security/libsecurity_cryptkit/lib/byteRep.c

diff --git a/Security/libsecurity_cryptkit/lib/byteRep.c b/Security/libsecurity_cryptkit/lib/byteRep.c
deleted file mode 100644
index f24f6d80..00000000
--- a/Security/libsecurity_cryptkit/lib/byteRep.c
+++ /dev/null
@@ -1,476 +0,0 @@
-/* Copyright (c) 1998,2011,2014 Apple Inc.  All Rights Reserved.
- *
- * NOTICE: USE OF THE MATERIALS ACCOMPANYING THIS NOTICE IS SUBJECT
- * TO THE TERMS OF THE SIGNED "FAST ELLIPTIC ENCRYPTION (FEE) REFERENCE
- * SOURCE CODE EVALUATION AGREEMENT" BETWEEN APPLE, INC. AND THE
- * ORIGINAL LICENSEE THAT OBTAINED THESE MATERIALS FROM APPLE,
- * INC.  ANY USE OF THESE MATERIALS NOT PERMITTED BY SUCH AGREEMENT WILL
- * EXPOSE YOU TO LIABILITY.
- ***************************************************************************
- *
- * byteRep.c -  FEE portable byte representation support
- *
- * Revision History
- * ----------------
- * 10/06/98		ap
- *	Changed to compile with C++.
- * 18 Apr 98 at Apple
- *	Mods for variable size giantDigit.
- * 20 Jan 98 at Apple
- *	Added curve param fields for CURVE_PARAM_VERSION 2.
- * 17 Jul 97 at Apple
- *	Added signature routines.
- *  9 Jan 97 at NeXT
- *	Split off from utilities.c
- */
-
-#include "byteRep.h"
-#include "feeTypes.h"
-#include "curveParams.h"
-#include "giantIntegers.h"
-#include "elliptic.h"
-#include "falloc.h"
-#include "ckutilities.h"
-#include "feeDebug.h"
-#include <stdlib.h>
-
-#ifndef	NULL
-#define NULL	((void *)0)
-#endif	/* NULL */
-
-/*
- * Support for portable bytestream representation of keys and signatures.
- * Platform and endianness independent; format shared with JavaFEE
- * implementation.
- */
-
-/*
- * Some handy macros.
- */
-#define ENC_BYTE(n, b, bytes)			\
-	*b++ = n;				\
-	bytes++;
-
-#define ENC_INT(n, b, bytes, i)			\
-	i = intToByteRep(n, b);			\
-	bytes += i;				\
-	b += i;
-
-#define ENC_GIANT(g, b, bytes, i)		\
-	i = giantToByteRep(g, b);		\
-	bytes += i;				\
-	b += i;
-
-#define DEC_BYTE(n, b, blen, bytes)		\
-	n = *b++;				\
-	bytes++;				\
-	blen--;
-
-#define DEC_INT(n, b, blen, bytes)		\
-	n = byteRepToInt(b);			\
-	b += sizeof(int);			\
-	bytes += sizeof(int);			\
-	blen -= gLen;
-
-#define DEC_GIANT(g, b, blen, glen, bytes, out)	\
-	g = byteRepToGiant(b, blen, &glen);	\
-	if(g == NULL) {				\
-		goto out;			\
-	}					\
-	b += glen;				\
-	bytes += glen;				\
-	blen -= gLen;
-
-
-
-
-/*
- * The routines which convert various types to byte reps return the number
- * of bytes written to the output stream.
- */
-int intToByteRep(int i, unsigned char *buf)
-{
-	*buf++ = (unsigned char)((i >> 24) & 0xff);
-	*buf++ = (unsigned char)((i >> 16) & 0xff);
-	*buf++ = (unsigned char)((i >> 8)  & 0xff);
-	*buf   = (unsigned char)(i & 0xff);
-	return 4;
-}
-
-int shortToByteRep(short s, unsigned char *buf)
-{
-	*buf++ = (unsigned char)((s >> 8)  & 0xff);
-	*buf   = (unsigned char)(s & 0xff);
-	return 2;
-}
-
-/*
- * 7 Apr 1998 : leading int is now the number of bytes in the giant's
- * giantDigits array. This value is signed.
- */
-int giantToByteRep(giant g, unsigned char *buf)
-{
-	int numBytes = g->sign * GIANT_BYTES_PER_DIGIT;
-	unsigned aNumBytes = abs(numBytes);
-
-	CKASSERT(g != NULL);
-	intToByteRep(numBytes, buf);
-	buf += sizeof(int);
-	serializeGiant(g, buf, aNumBytes);
-	return (sizeof(int) + aNumBytes);
-}
-
-int keyToByteRep(key k, unsigned char *buf)
-{
-	int numBytes = 0;
-	int i;
-
-	CKASSERT(k != NULL);
-	ENC_GIANT(k->x, buf, numBytes, i);
-
-	/* only write y for plus curve */
-	if(k->twist == CURVE_PLUS) {
-		CKASSERT(k->y != NULL);
-		ENC_GIANT(k->y, buf, numBytes, i);
-	}
-	return numBytes;
-}
-
-#define CURVE_PARAM_VERSION	3
-#define CURVE_PARAM_VERSION_MIN	3
-
-int curveParamsToByteRep(curveParams *cp, unsigned char *buf)
-{
-	int numBytes = 0;
-	int i;
-
-	CKASSERT(cp != NULL);
-	ENC_INT(CURVE_PARAM_VERSION, buf, numBytes, i);
-	ENC_INT(CURVE_PARAM_VERSION_MIN, buf, numBytes, i);
-	ENC_BYTE(cp->primeType, buf, numBytes);
-	ENC_BYTE(cp->curveType, buf, numBytes);
-	ENC_INT(cp->q, buf, numBytes, i);
-	ENC_INT(cp->k, buf, numBytes, i);
-	ENC_INT(cp->m, buf, numBytes, i);
-	ENC_INT(0, buf, numBytes, i);		// spare
-
-	ENC_GIANT(cp->a, buf, numBytes, i);
-	ENC_GIANT(cp->b, buf, numBytes, i);
-	ENC_GIANT(cp->c, buf, numBytes, i);
-	ENC_GIANT(cp->x1Plus, buf, numBytes, i);
-	ENC_GIANT(cp->x1Minus, buf, numBytes, i);
-	ENC_GIANT(cp->cOrderPlus, buf, numBytes, i);
-	ENC_GIANT(cp->cOrderMinus, buf, numBytes, i);
-	ENC_GIANT(cp->x1OrderPlus, buf, numBytes, i);
-	ENC_GIANT(cp->x1OrderMinus, buf, numBytes, i);
-	if(cp->primeType == FPT_General) {
-		ENC_GIANT(cp->basePrime, buf, numBytes, i);
-	}
-	return numBytes;
-}
-
-int sigToByteRep(int magic,
-	int version,
-	int minVersion,
-	giant g0,
-	giant g1,
-	unsigned char *buf)
-{
-	int numBytes = 0;
-	int i;
-
-	ENC_INT(magic, buf, numBytes, i);
-	ENC_INT(version, buf, numBytes, i);
-	ENC_INT(minVersion, buf, numBytes, i);
-	ENC_INT(0, buf, numBytes, i);		// spare
-	ENC_GIANT(g0, buf, numBytes, i);
-	ENC_GIANT(g1, buf, numBytes, i);
-
-	return numBytes;
-}
-
-
-/*
- * return the size of various data types' byte representations.
- */
-int lengthOfByteRepGiant(giant g)
-{
-	CKASSERT(g != NULL);
-    	return sizeof(int) + (GIANT_BYTES_PER_DIGIT * abs(g->sign));
-}
-
-int lengthOfByteRepKey(key k)
-{
-	int len = lengthOfByteRepGiant(k->x);
-
-	CKASSERT(k != NULL);
-	if(k->twist == CURVE_PLUS) {
-		CKASSERT(k->y != NULL);
-		len += lengthOfByteRepGiant(k->y);
-	}
-	return len;
-}
-
-int lengthOfByteRepCurveParams(curveParams *cp)
-{
-	int length;
-
-	CKASSERT(cp != NULL);
-	length = (6 * sizeof(int)) +		// ver, minVers, q, k, m, spare
-	        2 + 				// primeType + curveType
-		lengthOfByteRepGiant(cp->a) +
-		lengthOfByteRepGiant(cp->b) +
-		lengthOfByteRepGiant(cp->c) +
-		lengthOfByteRepGiant(cp->x1Plus) +
-		lengthOfByteRepGiant(cp->x1Minus) +
-		lengthOfByteRepGiant(cp->cOrderPlus) +
-		lengthOfByteRepGiant(cp->cOrderMinus) +
-		lengthOfByteRepGiant(cp->x1OrderPlus) +
-		lengthOfByteRepGiant(cp->x1OrderMinus);
-	if(cp->primeType == FPT_General) {
-		length += lengthOfByteRepGiant(cp->basePrime);
-	}
-	return length;
-}
-
-int lengthOfByteRepSig(giant g0,
-	giant g1)
-{
-	int length = (4 * sizeof(int)) +	// magic, version, minVersion,
-						// spare
-	    lengthOfByteRepGiant(g0) +
-	    lengthOfByteRepGiant(g1);
-	return length;
-}
-
-/*
- * Routine to cons up various types from a byte rep stream.
- */
-int byteRepToInt(const unsigned char *buf) {
-    	int result;
-
-    	result = (((int)buf[0] << 24) & 0xff000000) |
-		 (((int)buf[1] << 16) & 0x00ff0000) |
-		 (((int)buf[2] << 8) & 0xff00) |
-		 (((int)buf[3]) & 0xff);
-    	return result;
-}
-
-unsigned short byteRepToShort(const unsigned char *buf) {
-    	unsigned short result;
-
-    	result = (((unsigned short)buf[0] << 8) & 0xff00) |
-		 (((unsigned short)buf[1]) & 0xff);
-    	return result;
-}
-
-/*
- * Probably need byteRepToShortArray...
- */
-
-/*
- * byte rep stream to giant. Returns NULL on error; returns number of bytes
- * of *buf snarfed in *giantLen if successful.
- *
- * 7 Apr 1998 : leading int is now the number of bytes in the giant's
- * giantDigits array. This value is signed.
- */
-giant byteRepToGiant(const unsigned char *buf,
-	unsigned bufLen,
-	unsigned *giantLen)
-{
-	giant g;
-	int numDigits;
-	int numBytes;			// signed!
-	unsigned aNumBytes;
-
-   	if(bufLen < sizeof(int)) {
-		return (giant)NULL;
-	}
-    	numBytes = byteRepToInt(buf);
-	aNumBytes = abs(numBytes);
-	numDigits = BYTES_TO_GIANT_DIGITS(aNumBytes);
-	buf += sizeof(int);
-	bufLen -= sizeof(int);
-	if(numDigits > MAX_DIGITS) {
-		return (giant)NULL;
-	}
-
-    	if(bufLen < aNumBytes) {
-		return (giant)NULL;
-	}
-
-	/* 9 Apr 1998 - sign = 0 means no following n[] bytes in the
-	 * byteRep. We do need to alloc one digit, in this case, though...
-	 * Note that the giantstruct has one implicit digit in n[].
-	 */
-	if(aNumBytes == 0) {
-	    g = (giant)fmalloc(sizeof(giantstruct));
-	    g->capacity = 1;
-	}
-	else {
-	    g = (giant)fmalloc(sizeof(giantstruct) +
-	    	aNumBytes - GIANT_BYTES_PER_DIGIT);
-	    g->capacity = numDigits;
-	}
-	deserializeGiant(buf, g, aNumBytes);
-
-	/* deserializeGiant always cooks up positive giant; sign is
-	 * properly trimmed to handle trailing (M.S.) zeroes. */
-	if(numBytes < 0) {
-	 	g->sign = -g->sign;
-	}
-	*giantLen = sizeof(int) + aNumBytes;
-	return g;
-
-}
-
-/*
- * Convert a byte stream (and some other parameters) into a
- * keystruct.
- * Returns NULL on error; returns number of bytes of *buf snarfed in
- * *keyLen if successful.
- */
-key byteRepToKey(const unsigned char *buf,
-	unsigned bufLen,
-	int twist,
-	curveParams *cp,
-	unsigned *keyLen)	// returned
-{
-	key k;
-	giant x;
-	giant y;
-	unsigned gLen;
-	unsigned totalLen;
-
-	x = byteRepToGiant(buf, bufLen, &gLen);
-	if(x == NULL) {
-		return NULL;
-	}
-	bufLen  -= gLen;
-	buf     += gLen;
-	totalLen = gLen;
-	if(twist == CURVE_PLUS) {
-		/* this also contains y */
-		y = byteRepToGiant(buf, bufLen, &gLen);
-		if(y == NULL) {
-			freeGiant(x);
-			return NULL;
-		}
-		totalLen += gLen;
-	}
-	else {
-		/* minus curve, y is not used */
-		y = newGiant(1);
-		int_to_giant(0, y);
-	}
-	k = (key)fmalloc(sizeof(keystruct));
-	k->twist = twist;
-	k->cp = cp;
-	k->x = x;
-	k->y = y;
-	*keyLen = totalLen;
-	return k;
-}
-
-curveParams *byteRepToCurveParams(const unsigned char *buf,
-	unsigned bufLen,
-	unsigned *cpLen)
-{
-	curveParams *cp;
-	unsigned gLen = 0;
-	int version;
-	int minVersion;
-	int spare;
-	int bytes = 0;
-
-	if(bufLen < (5 * sizeof(int))) {	// ver, minVers, q, k, spare
-		return NULL;
-	}
-	cp = newCurveParams();
-
-	DEC_INT(version, buf, bufLen, bytes);
-	DEC_INT(minVersion, buf, bufLen, bytes);
-	if(minVersion > CURVE_PARAM_VERSION) {
-		/*
-		 * Can't parse this; things have changed too much between
-		 * this version of the code and the time this curveParams
-		 * was written.
-		 */
-		goto abort;
-	}
-
-	DEC_BYTE(cp->primeType, buf, bufLen, bytes);
-	DEC_BYTE(cp->curveType, buf, bufLen, bytes);
-	DEC_INT(cp->q, buf, bufLen, bytes);
-	DEC_INT(cp->k, buf, bufLen, bytes);
-	DEC_INT(cp->m, buf, bufLen, bytes);
-	DEC_INT(spare, buf, bufLen, bytes);
-
-	DEC_GIANT(cp->a, 		buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->b, 		buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->c, 		buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->x1Plus, 		buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->x1Minus, 		buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->cOrderPlus, 	buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->cOrderMinus, 	buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->x1OrderPlus, 	buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(cp->x1OrderMinus, 	buf, bufLen, gLen, bytes, abort);
-
-	/*
-	 * basePrime only present in byte rep for PT_GENERAL
-	 */
-	if(cp->primeType == FPT_General) {
-	    DEC_GIANT(cp->basePrime, buf, bufLen, gLen, bytes, abort);
-	}
-
-	/* remaining fields inferred */
-	curveParamsInferFields(cp);
-	allocRecipGiants(cp);
-
-	*cpLen = bytes;
-	return cp;
-
-abort:
-	freeCurveParams(cp);
-	return NULL;
-}
-
-/*
- * Returns 0 if bad format, e.g., if minVersion of sig is > than codeVersion.
- */
-int byteRepToSig(const unsigned char *buf,
-	unsigned bufLen,
-	int codeVersion,
-	int *sigMagic,				// RETURNED
-	int *sigVersion,			// RETURNED
-	int *sigMinVersion,			// RETURNED
-	giant *g0,					// alloc'd  & RETURNED
-	giant *g1)					// alloc'd  & RETURNED
-{
-	unsigned gLen = 0;
-	int spare;
-	int bytes = 0;
-
-	if(bufLen < (4 * sizeof(int))) {	// magic, version, minVersion,
-						// spare
-		return 0;
-	}
-	DEC_INT(*sigMagic, buf, bufLen, bytes);
-	DEC_INT(*sigVersion, buf, bufLen, bytes);
-	DEC_INT(*sigMinVersion, buf, bufLen, bytes);
-	if(*sigMinVersion > codeVersion) {
-		return 0;
-	}
-	DEC_INT(spare, buf, bufLen, bytes);
-	// deleted 2/20/01 DEC_INT(*signerLen, buf, bufLen, bytes);
-	// deleted 2/20/01 *signer = byteRepToUnichars(buf, *signerLen);
-	// deleted 2/20/01 buf += (2 * *signerLen);
-	// deleted 2/20/01 bufLen -= (2 * *signerLen);
-	DEC_GIANT(*g0, buf, bufLen, gLen, bytes, abort);
-	DEC_GIANT(*g1, buf, bufLen, gLen, bytes, abort);
-
-	return 1;
-abort:
-	return 0;
-}