--- /dev/null
+/* 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.
+ ***************************************************************************
+ *
+ * FeeFEED.c - generic, portable FEED encryption object, expanionless version
+ *
+ * Revision History
+ * ----------------
+ * 10/06/98 ap
+ * Changed to compile with C++.
+ * 20 Jan 1998 at Apple
+ * Mods for primeType == PT_GENERAL case.
+ * 12 Jun 1997 at Apple
+ * Was curveOrderJustify(), is lesserX1OrderJustify()
+ * 31 Mar 1997 at Apple
+ * Fixed initialRS leak
+ * 3 Mar 1997 at Apple
+ * Trimmed plainBlockSize by one byte if q mod 8 = 0
+ * 30 Jan 1997 at NeXT
+ * Created.
+ */
+
+/*
+ * FIXME - a reusable init function would be nice (i.e., free up
+ * session-dependent state and re-init it)...
+ */
+#include "ckconfig.h"
+
+#if CRYPTKIT_ASYMMETRIC_ENABLE
+
+#include "feeTypes.h"
+#include "feeFEED.h"
+#include "feeFEEDExp.h"
+#include "feePublicKey.h"
+#include "feePublicKeyPrivate.h"
+#include "elliptic.h"
+#include "falloc.h"
+#include "feeRandom.h"
+#include "ckutilities.h"
+#include "feeFunctions.h"
+#include "platform.h"
+#include "curveParams.h"
+#include "feeDebug.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+#define FEED_DEBUG 0
+#define BUFFER_DEBUG 0
+#if BUFFER_DEBUG
+#define bprintf(s) printf s
+#else
+#define bprintf(s)
+#endif
+
+/*
+ * Minimum combined size of random r and s, in bytes. For small q sizes,
+ * r and s may be even smaller, but we never truncate them to smaller than
+ * this.
+ * This must be kept in sync with constant of same name in FEED.java.
+ */
+#define RS_MIN_SIZE 16
+
+/*
+ * Private data.
+ */
+typedef struct {
+ curveParams *cp;
+
+ /*
+ * the clues are initially (r * ourPriv * theirPub(+/-)).
+ */
+ giant cluePlus;
+ giant clueMinus;
+
+ /*
+ * sPlus and sMinus are based on the random s generated at encrypt
+ * time. Values are s * x1{Plus,Minus}.
+ */
+ giant sPlus;
+ giant sMinus;
+ giant r; /* random, generated at encrypt time */
+ unsigned plainBlockSize; /* plaintext block size */
+ unsigned cipherBlockSize; /* ciphertext block size */
+ unsigned char *initialRS; /* initial random R,S as bytes */
+ unsigned initialRSSize; /* in bytes */
+ feeFEEDExp feedExp; /* for encr/decr r+s params */
+
+ /*
+ * The first few blocks of ciphertext in a stream are the 2:1-FEED
+ * encrypted r and s parameters. While decrypting, we stash incoming
+ * ciphertext in rsCtext until we get enough ciphertext to decrypt
+ * initialRS. RsBlockCount keeps a running count of the
+ * cipherBlocks received. When rsBlockCount == rsSizeCipherBlocks, we
+ * FEEDExp-decrypt rsCtext to get r and s (actually, to get
+ * initialRS; r and s are extraced later in initFromRS()).
+ *
+ * During encrypt, if rsBlockCount is zero, the first thing we send as
+ * ciphertext is the FEED-encrypted initialRS.
+ */
+ unsigned char *rsCtext; /* buffer for encrypted initialRS */
+ unsigned rsBlockCount; /* running total of incoming rs
+ * cipherblocks */
+
+ int forEncrypt; /* added for feeFEED*TextSize() */
+
+ /*
+ * These are calculated at init time - for encrypt and
+ * decrypt - as an optimization.
+ */
+ unsigned rsCtextSize; /* number of meaningful bytes in
+ * rsCtext */
+ unsigned rsSizeCipherBlocks; /* # of our cipherblocks holding
+ * rsCtext */
+
+ /*
+ * temporary variables used for encrypt/decrypt. The values in these
+ * are not needed to be kept from block to block; we just
+ * alloc them once per lifetime of a feeFEED object as an optimization.
+ */
+ giant xp; /* plaintext */
+ giant xm; /* ciphertext */
+ giant tmp1; /* scratch */
+ giant tmp2; /* scratch */
+} feedInst;
+
+/*
+ * "zero residue" indicator.
+ */
+#define RESID_ZERO 0xff
+
+/*
+ * cons up:
+ * cluePlus(0)
+ * clueMinus(0)
+ * sPlus
+ * sMinus
+ * r
+ * Assumes:
+ * cluePlus = clueMinus = ourPriv * theirPub
+ * initialRS
+ * initialRSSize
+ * cp
+ *
+ * Called at feeFEEDNewWithPubKey while encrypting, or upon decrypting
+ * first block of data.
+ */
+static feeReturn initFromRS(feedInst *finst)
+{
+ giant s;
+ unsigned rSize = finst->initialRSSize / 2;
+
+ #if FEED_DEBUG
+ if((finst->initialRS == NULL) ||
+ (finst->cp == NULL) ||
+ (finst->cluePlus == NULL) ||
+ (finst->clueMinus == NULL) ||
+ (finst->initialRSSize == 0)) {
+ dbgLog(("initFromRS: resource shortage\n"));
+ return FR_Internal;
+ }
+ #endif // FEED_DEBUG
+
+ finst->r = giant_with_data(finst->initialRS, rSize);
+ s = giant_with_data(finst->initialRS+rSize, rSize);
+
+ #if FEED_DEBUG
+ if(isZero(finst->r)) {
+ printf("initFromRS: r = 0! initialRSSize = %d; encr = %s\n",
+ finst->initialRSSize,
+ (finst->rsCtext == NULL) ? "TRUE" : "FALSE");
+ }
+ if(isZero(s)) {
+ printf("initFromRS: s = 0! initialRSSize = %d; encr = %s\n",
+ finst->initialRSSize,
+ (finst->rsCtext == NULL) ? "TRUE" : "FALSE");
+ }
+ #endif // FEE_DEBUG
+ /*
+ * Justify r and s to be in [2, minimumX1Order].
+ */
+ lesserX1OrderJustify(finst->r, finst->cp);
+ lesserX1OrderJustify(s, finst->cp);
+
+ /*
+ * sPlus = s * x1Plus
+ * sMinus = s * x1Minus
+ */
+ finst->sPlus = newGiant(finst->cp->maxDigits);
+ finst->sMinus = newGiant(finst->cp->maxDigits);
+ gtog(finst->cp->x1Plus, finst->sPlus);
+ elliptic_simple(finst->sPlus, s, finst->cp);
+ gtog(finst->cp->x1Minus, finst->sMinus);
+ elliptic_simple(finst->sMinus, s, finst->cp);
+
+ /*
+ * And finally, the initial clues. They are currently set to
+ * ourPriv * theirPub.
+ */
+ #if FEED_DEBUG
+ printf("cluePlus : "); printGiant(finst->cluePlus);
+ printf("clueMinus: "); printGiant(finst->clueMinus);
+ #endif // FEED_EEBUG
+
+ elliptic_simple(finst->cluePlus, finst->r, finst->cp);
+ elliptic_simple(finst->clueMinus, finst->r, finst->cp);
+
+ #if FEED_DEBUG
+ printf("r : "); printGiant(finst->r);
+ printf("s : "); printGiant(s);
+ printf("sPlus : "); printGiant(finst->sPlus);
+ printf("sMinus : "); printGiant(finst->sMinus);
+ printf("cluePlus : "); printGiant(finst->cluePlus);
+ printf("clueMinus: "); printGiant(finst->clueMinus);
+ #endif // FEED_DEBUG
+
+ freeGiant(s);
+ return FR_Success;
+}
+
+/*
+ * Alloc and init a feeFEED object associated with specified public and
+ * private keys.
+ */
+feeFEED feeFEEDNewWithPubKey(feePubKey myPrivKey,
+ feePubKey theirPubKey,
+ int forEncrypt, // 0 ==> decrypt 1 ==> encrypt
+ feeRandFcn randFcn, // optional
+ void *randRef)
+{
+ feedInst *finst;
+ giant privGiant;
+ key k;
+ unsigned expPlainSize;
+ unsigned expCipherSize;
+ unsigned expBlocks;
+
+ if(!curveParamsEquivalent(feePubKeyCurveParams(theirPubKey),
+ feePubKeyCurveParams(myPrivKey))) {
+ dbgLog(("feeFEEDNewWithPubKey: Incompatible Keys\n"));
+ return NULL;
+ }
+ finst = (feedInst*) fmalloc(sizeof(feedInst));
+ bzero(finst, sizeof(feedInst));
+ finst->forEncrypt = forEncrypt;
+ finst->cp = curveParamsCopy(feePubKeyCurveParams(theirPubKey));
+ finst->rsBlockCount = 0;
+ finst->xp = newGiant(finst->cp->maxDigits);
+ finst->xm = newGiant(finst->cp->maxDigits);
+ finst->tmp1 = newGiant(finst->cp->maxDigits);
+ if(forEncrypt) {
+ finst->tmp2 = newGiant(finst->cp->maxDigits);
+ }
+
+ /*
+ * cluePlus = ourPriv * theirPub+
+ * clueMinus = ourPriv * theirPub-
+ */
+ finst->cluePlus = newGiant(finst->cp->maxDigits);
+ finst->clueMinus = newGiant(finst->cp->maxDigits);
+ privGiant = feePubKeyPrivData(myPrivKey);
+ if(privGiant == NULL) {
+ dbgLog(("feeFEEDNewWithPubKey: no private key\n"));
+ goto abort;
+ }
+ k = feePubKeyPlusCurve(theirPubKey);
+ gtog(k->x, finst->cluePlus); // cluePlus = theirPub+
+ elliptic_simple(finst->cluePlus, privGiant, finst->cp);
+ k = feePubKeyMinusCurve(theirPubKey);
+ gtog(k->x, finst->clueMinus); // theirPub-
+ elliptic_simple(finst->clueMinus, privGiant, finst->cp);
+
+ /*
+ * Set up block sizes.
+ */
+ if(finst->cp->primeType == FPT_General) {
+ unsigned blen = bitlen(finst->cp->basePrime);
+
+ finst->plainBlockSize = blen / 8;
+ if((blen & 0x7) == 0) {
+ /*
+ * round down some more...
+ */
+ finst->plainBlockSize--;
+ }
+ }
+ else {
+ finst->plainBlockSize = finst->cp->q / 8;
+ if(((finst->cp->q & 0x7) == 0) && (finst->cp->k > 0)) {
+ /*
+ * Special case, with q mod 8 == 0. Here we have to
+ * trim back the plainBlockSize by one byte.
+ */
+ finst->plainBlockSize--;
+ }
+ }
+ finst->cipherBlockSize = finst->cp->minBytes + 1;
+
+ /*
+ * the size of initialRS is subject to tweaking - if we make it
+ * not a multiple of plainBlockSize, we save one FEEDExp cipherBlock
+ * in our ciphertext.
+ */
+ finst->initialRSSize = finst->plainBlockSize * 2;
+ if(finst->initialRSSize > RS_MIN_SIZE) {
+ unsigned minPlainBlocks;
+ unsigned maxSize;
+
+ /*
+ * How many plainblocks to hold RS_MIN_SIZE?
+ */
+ minPlainBlocks = (RS_MIN_SIZE + finst->plainBlockSize - 1) /
+ finst->plainBlockSize;
+
+ /*
+ * Max size = that many plainblocks, less 2 bytes (to avoid
+ * extra residue block).
+ */
+ maxSize = minPlainBlocks * finst->plainBlockSize - 2;
+
+ /*
+ * But don't bother with more than 2 plainblocks worth
+ */
+ if(finst->initialRSSize > maxSize) {
+ finst->initialRSSize = maxSize;
+ }
+ }
+ /* else leave it alone, that's small enough */
+
+ if(forEncrypt) {
+ feeRand frand = NULL;
+
+ /*
+ * Encrypt-capable FEEDExp object
+ */
+ finst->feedExp = feeFEEDExpNewWithPubKey(theirPubKey,
+ randFcn,
+ randRef);
+ if(finst->feedExp == NULL) {
+ goto abort;
+ }
+
+ /*
+ * Generate initial r and s data.
+ */
+ finst->initialRS = (unsigned char*) fmalloc(finst->initialRSSize);
+ if(randFcn != NULL) {
+ randFcn(randRef, finst->initialRS, finst->initialRSSize);
+ }
+ else {
+ frand = feeRandAlloc();
+ feeRandBytes(frand, finst->initialRS, finst->initialRSSize);
+ feeRandFree(frand);
+ }
+ if(initFromRS(finst)) {
+ goto abort;
+ }
+ }
+ else {
+ /*
+ * Decrypt-capable FEEDExp object
+ */
+ finst->feedExp = feeFEEDExpNewWithPubKey(myPrivKey,
+ randFcn,
+ randRef);
+ if(finst->feedExp == NULL) {
+ goto abort;
+ }
+
+ }
+
+ /*
+ * Figure out how many of our cipherblocks it takes to hold
+ * a FEEDExp-encrypted initialRS. If initialRSSize is an exact
+ * multiple of expPlainSize, we get an additional feedExp
+ * residue block.
+ */
+ expPlainSize = feeFEEDExpPlainBlockSize(finst->feedExp);
+ expCipherSize = feeFEEDExpCipherBlockSize(finst->feedExp);
+ expBlocks = (finst->initialRSSize + expPlainSize - 1) /
+ expPlainSize;
+ if((finst->initialRSSize % expPlainSize) == 0) {
+ expBlocks++;
+ }
+
+ /*
+ * Total meaningful bytes of encrypted initialRS
+ */
+ finst->rsCtextSize = expBlocks * expCipherSize;
+
+ /*
+ * Number of our cipherblocks it takes to hold rsCtextSize
+ */
+ finst->rsSizeCipherBlocks = (finst->rsCtextSize +
+ finst->cipherBlockSize - 1) / finst->cipherBlockSize;
+ if(!forEncrypt) {
+ finst->rsCtext = (unsigned char*) fmalloc(finst->rsSizeCipherBlocks *
+ finst->cipherBlockSize);
+ }
+
+ /*
+ * Sanity check...
+ */
+ #if FEED_DEBUG
+ {
+ unsigned fexpBlockSize = feeFEEDExpCipherBlockSize(finst->feedExp);
+
+ /*
+ * FEEDExp has one more giant in ciphertext, plaintext is
+ * same size
+ */
+ if((finst->cipherBlockSize + finst->cp->minBytes) !=
+ fexpBlockSize) {
+ dbgLog(("feeFEEDNewWithPubKey: FEEDExp CBlock Size "
+ "screwup\n"));
+ goto abort;
+ }
+ fexpBlockSize = feeFEEDExpPlainBlockSize(finst->feedExp);
+ if(fexpBlockSize != finst->plainBlockSize) {
+ dbgLog(("feeFEEDNewWithPubKey: FEEDExp PBlock Size "
+ "screwup\n"));
+ goto abort;
+ }
+ }
+ #endif // FEED_DEBUG
+
+ return finst;
+
+abort:
+ feeFEEDFree(finst);
+ return NULL;
+}
+
+void feeFEEDFree(feeFEED feed)
+{
+ feedInst *finst = (feedInst*) feed;
+
+ if(finst->cp) {
+ freeCurveParams(finst->cp);
+ }
+ if(finst->initialRS) {
+ ffree(finst->initialRS);
+ }
+ if(finst->cluePlus) {
+ freeGiant(finst->cluePlus);
+ }
+ if(finst->clueMinus) {
+ freeGiant(finst->clueMinus);
+ }
+ if(finst->sPlus) {
+ freeGiant(finst->sPlus);
+ }
+ if(finst->sMinus) {
+ freeGiant(finst->sMinus);
+ }
+ if(finst->r) {
+ freeGiant(finst->r);
+ }
+ if(finst->feedExp) {
+ feeFEEDExpFree(finst->feedExp);
+ }
+ if(finst->rsCtext) {
+ ffree(finst->rsCtext);
+ }
+ if(finst->xp) {
+ freeGiant(finst->xp);
+ }
+ if(finst->xm) {
+ freeGiant(finst->xm);
+ }
+ if(finst->tmp1) {
+ freeGiant(finst->tmp1);
+ }
+ if(finst->tmp2) {
+ freeGiant(finst->tmp2);
+ }
+ ffree(finst);
+}
+
+unsigned feeFEEDPlainBlockSize(feeFEED feed)
+{
+ feedInst *finst = (feedInst *) feed;
+
+ return finst->plainBlockSize;
+}
+
+unsigned feeFEEDCipherBlockSize(feeFEED feed)
+{
+ feedInst *finst = (feedInst *) feed;
+
+ return finst->cipherBlockSize;
+}
+
+/*
+ * Calculate size of buffer currently needed to encrypt one block of
+ * plaintext. Also used to calculate required input during decrypt
+ * to get any output.
+ */
+unsigned feeFEEDCipherBufSize(feeFEED feed,
+ int finalBlock)
+{
+ feedInst *finst = (feedInst *) feed;
+ unsigned blocks = 1; // always at least one block of ciphertext
+
+ if(finst->rsBlockCount == 0) {
+ /* haven't sent/seen encrypted RS yet */
+ blocks += finst->rsSizeCipherBlocks;
+ }
+
+ if(finalBlock) {
+ /* only needed if ptext is aligned, but tell caller to malloc */
+ blocks++;
+ }
+ bprintf(("$$$ feeFEEDCipherBufSize( %s, %s): rtn 0x%x\n",
+ finst->forEncrypt ? "encrypt" : "decrypt",
+ finalBlock ? " final" : "!final",
+ blocks * finst->cipherBlockSize));
+ return blocks * finst->cipherBlockSize;
+}
+
+/*
+ * Return the size of ciphertext currently needed to encrypt specified
+ * size of plaintext. Also can be used to calculate size of ciphertext
+ * which can be decrypted into specified size of plaintext.
+ */
+unsigned feeFEEDCipherTextSize(feeFEED feed,
+ unsigned plainTextSize,
+ int finalBlock)
+{
+ feedInst *finst = (feedInst *) feed;
+
+ /* how many blocks of plaintext? */
+ unsigned blocks = (plainTextSize + finst->plainBlockSize - 1) /
+ finst->plainBlockSize;
+
+ if(finst->forEncrypt) {
+ /* have we generated RS? */
+ if(finst->rsBlockCount == 0) {
+ /* haven't sent encrypted RS yet */
+ blocks += finst->rsSizeCipherBlocks;
+ }
+
+ /* final? residue? */
+ if(finalBlock) {
+ if((plainTextSize % finst->plainBlockSize) == 0) {
+ blocks++;
+ }
+ }
+ } /* encrypting */
+ else {
+ /*
+ * Decrypting - how much ciphertext can we decrypt safely into
+ * specified plaintext? Add in RS if we haven't seen it all
+ * yet.
+ */
+ #if BUFFER_DEBUG
+ if(finst->rsBlockCount > finst->rsSizeCipherBlocks) {
+ printf("******HEY! rsBlockCount overflow! (blockCount %d rsSize %d)\n",
+ finst->rsBlockCount, finst->rsSizeCipherBlocks);
+ }
+ #endif
+ blocks += (finst->rsSizeCipherBlocks - finst->rsBlockCount);
+ }
+ bprintf(("$$$ feeFEEDCipherTextSize(%s, %s, 0x%x): rtn 0x%x\n",
+ finst->forEncrypt ? "encrypt" : "decrypt",
+ finalBlock ? " final" : "!final",
+ plainTextSize, blocks * finst->cipherBlockSize));
+ return blocks * finst->cipherBlockSize;
+}
+
+/*
+ * Return the size of plaintext currently needed to decrypt specified size
+ * of ciphertext. Also can be used to calculate size of plaintext
+ * which can be encrypted into specified size of ciphertext.
+ */
+unsigned feeFEEDPlainTextSize(feeFEED feed,
+ unsigned cipherTextSize,
+ int finalBlock) // ignored if !forEncrypt
+{
+ feedInst *finst = (feedInst *) feed;
+
+ /* start with basic cipher block count */
+ unsigned cipherBlocks = (cipherTextSize + finst->cipherBlockSize - 1) /
+ finst->cipherBlockSize;
+
+ /* where are we in the RS stream? */
+ unsigned rsBlocksToGo = finst->rsSizeCipherBlocks - finst->rsBlockCount;
+ if(finst->forEncrypt) {
+ /*
+ * Encrypting, seeking plaintext size we can encrypt given
+ * a specified size of ciphertext.
+ */
+ if(rsBlocksToGo >= cipherBlocks) {
+ /* no room! next encrypt would overflow ctext buffer! */
+ return 0;
+ }
+ cipherBlocks -= rsBlocksToGo;
+
+ /* another constraint - residue */
+ if(finalBlock) {
+ if(cipherBlocks) {
+ /* skip if already zero... */
+ cipherBlocks--;
+ }
+ }
+ } /* encrypting */
+ else {
+ /* decrypting */
+ if(rsBlocksToGo >= cipherBlocks) {
+ /* still processing RS, no plaintext will be generated. Play it real
+ * safe and just tell caller one block. */
+ cipherBlocks = 1;
+ }
+ else {
+ /* diminish by size of RS to be gobbled with no output */
+ cipherBlocks -= rsBlocksToGo;
+ }
+ }
+ bprintf(("$$$ feeFEEDPlainTextSize( %s, %s, 0x%x): rtn 0x%x\n",
+ finst->forEncrypt ? "encrypt" : "decrypt",
+ finalBlock ? " final" : "!final",
+ cipherTextSize, cipherBlocks * finst->plainBlockSize));
+ return cipherBlocks * finst->plainBlockSize;
+}
+
+/*
+ * Bits in last byte of cipherblock
+ */
+#define CLUE_BIT 0x01 /* 1 ==> plus curve */
+#define CLUE_PLUS 0x01
+#define CLUE_MINUS 0x00
+#define PARITY_BIT 0x02 /* 1 ==> plus 's' arg to elliptic_add() */
+#define PARITY_PLUS 0x02
+#define PARITY_MINUS 0x00
+
+/*
+ * Encrypt a block or less of data. Caller malloc's cipherText.
+ * Generates up to feeFEEDCipherBufSize() bytes of ciphertext.
+ */
+feeReturn feeFEEDEncryptBlock(feeFEED feed,
+ const unsigned char *plainText,
+ unsigned plainTextLen,
+ unsigned char *cipherText,
+ unsigned *cipherTextLen, // RETURNED
+ int finalBlock)
+{
+ feedInst *finst = (feedInst *) feed;
+ unsigned ctextLen = 0;
+ feeReturn frtn = FR_Success;
+ int whichCurve;
+ giant thisClue; // not alloc'd or freed
+ giant thisS; // ditto
+ unsigned char clueByte;
+
+ if(plainTextLen > finst->plainBlockSize) {
+ return FR_IllegalArg;
+ }
+ if((plainTextLen < finst->plainBlockSize) && !finalBlock) {
+ return FR_IllegalArg;
+ }
+ if(finst->initialRS == NULL) {
+ /*
+ * Init'd for decrypt?
+ */
+ return FR_IllegalArg;
+ }
+
+ /*
+ * First block - encrypt initialRS via FEEDExp
+ */
+ if(finst->rsBlockCount == 0) {
+ unsigned char *thisCtext; // malloc's by FEEDExp
+ unsigned padLen;
+
+ if(finst->initialRS == NULL) {
+ /*
+ * init'd for decrypt or reused
+ */
+ dbgLog(("feeFEEDEncryptBlock: NULL initialRS!\n"));
+ return FR_IllegalArg;
+ }
+
+ frtn = feeFEEDExpEncrypt(finst->feedExp,
+ finst->initialRS,
+ finst->initialRSSize,
+ &thisCtext,
+ &ctextLen);
+ if(frtn) {
+ /*
+ * Should never happen...
+ */
+ dbgLog(("feeFEEDEncryptBlock: error writing encrypted"
+ " initialRS (%s)\n", feeReturnString(frtn)));
+ return FR_Internal;
+ }
+ bcopy(thisCtext, cipherText, ctextLen);
+ cipherText += ctextLen;
+ ffree(thisCtext);
+
+ finst->rsBlockCount = finst->rsSizeCipherBlocks;
+ padLen = finst->cipherBlockSize -
+ (ctextLen % finst->cipherBlockSize); // zeros to write
+
+ #if 0 /* FEED_DEBUG */
+
+ /*
+ * Hard-coded assumptions and tests about initRSSize...
+ * Currently we assume that initRSSize % expBlockSize = 0
+ */
+ if((ctextLen / finst->cipherBlockSize) != 5) {
+ dbgLog(("feeFEEDEncryptBlock: cipherblock size screwup (1)\n"));
+ return FR_Internal;
+ }
+ if(padLen != 3) {
+ dbgLog(("feeFEEDEncryptBlock: cipherblock size screwup (2)\n"));
+ return FR_Internal;
+ }
+ #endif // FEED_DEBUG
+
+ /*
+ * pad to multiple of (our) cipherblock size.
+ */
+ while(padLen) {
+ *cipherText++ = 0;
+ ctextLen++;
+ padLen--;
+ }
+ }
+
+ /*
+ * plaintext to giant xp
+ */
+ if(finalBlock) {
+ unsigned char *ptext = (unsigned char*) fmalloc(finst->plainBlockSize);
+ bzero(ptext, finst->plainBlockSize);
+ if(plainTextLen) {
+ /*
+ * skip for empty block with resid length 0
+ */
+ bcopy(plainText, ptext, plainTextLen);
+ }
+ if(plainTextLen < finst->plainBlockSize) {
+ if(plainTextLen == 0) {
+ /*
+ * Special case - resid block with no actual plaintext.
+ * Can't actually write zero here; it screws up
+ * deserializing the giant during decrypt
+ */
+ ptext[finst->plainBlockSize - 1] = RESID_ZERO;
+ bprintf(("=== FEED encrypt: RESID_ZERO\n"));
+ }
+ else {
+ ptext[finst->plainBlockSize - 1] = plainTextLen;
+ bprintf(("=== FEED encrypt: resid len 0x%x\n", plainTextLen));
+ }
+ }
+ /*
+ * else handle evenly aligned case (i.e., finalBlock true
+ * and (plainTextLen == plainBlockSize)) below...
+ */
+ deserializeGiant(ptext, finst->xp, finst->plainBlockSize);
+ ffree(ptext);
+ }
+ else {
+ deserializeGiant(plainText, finst->xp, plainTextLen);
+ }
+
+ /*
+ * encrypt xp
+ * xm = xp + clue(+/-)
+ * determine parity needed to restore xp
+ * parity = ((xm + clue(+/-) == xp) ? 1 : -1
+ * and adjust clue
+ * clue[n+1] = r * clue[n] + (s * P1)
+ */
+ whichCurve = which_curve(finst->xp, finst->cp);
+ if(whichCurve == CURVE_PLUS) {
+ thisClue = finst->cluePlus;
+ thisS = finst->sPlus;
+ clueByte = CLUE_PLUS;
+ }
+ else {
+ thisClue = finst->clueMinus;
+ thisS = finst->sMinus;
+ clueByte = CLUE_MINUS;
+ }
+ // calculate xm
+ elliptic_add(thisClue, finst->xp, finst->xm, finst->cp, SIGN_PLUS);
+ // save xm + clue in tmp1
+ elliptic_add(finst->xm, thisClue, finst->tmp1, finst->cp, SIGN_PLUS);
+ // Adjust clue
+ elliptic_simple(thisClue, finst->r, finst->cp);
+ gtog(thisClue, finst->tmp2);
+ elliptic_add(finst->tmp2, thisS, thisClue, finst->cp, SIGN_PLUS);
+
+ /*
+ * Calculate parity
+ */
+ if(gcompg(finst->tmp1, finst->xp) == 0) {
+ clueByte |= PARITY_PLUS;
+ }
+
+ /*
+ * Ciphertext = (xm, clueByte)
+ */
+ serializeGiant(finst->xm, cipherText, finst->cp->minBytes);
+ cipherText += finst->cp->minBytes;
+ ctextLen += finst->cp->minBytes;
+ *cipherText++ = clueByte;
+ ctextLen++;
+
+ #if FEED_DEBUG
+ printf("encrypt clue %d\n", clueByte);
+ printf(" xp : "); printGiant(finst->xp);
+ printf(" xm : "); printGiant(finst->xm);
+ printf(" cluePlus :"); printGiant(finst->cluePlus);
+ printf(" clueMinus :"); printGiant(finst->clueMinus);
+ #endif // FEED_DEBUG
+
+ if(finalBlock && (plainTextLen == finst->plainBlockSize)) {
+ /*
+ * Special case: finalBlock true, plainTextLen == blockSize.
+ * In this case we generate one more block of ciphertext,
+ * with a resid length of zero.
+ */
+ unsigned moreCipher; // additional cipherLen
+
+ frtn = feeFEEDEncryptBlock(feed,
+ NULL, // plainText not used
+ 0, // resid
+ cipherText, // append...
+ &moreCipher,
+ 1);
+ if(frtn == FR_Success) {
+ ctextLen += moreCipher;
+ }
+ }
+ bprintf(("=== FEED encryptBlock ptextLen 0x%x ctextLen 0x%x\n",
+ plainTextLen, ctextLen));
+
+ *cipherTextLen = ctextLen;
+ return frtn;
+}
+
+/*
+ * Decrypt (exactly) a block of data. Caller malloc's plainText. Always
+ * generates feeFEEDPlainBlockSize of plaintext, unless finalBlock is
+ * non-zero (in which case feeFEEDPlainBlockSize or less bytes of plainText are
+ * generated).
+ */
+feeReturn feeFEEDDecryptBlock(feeFEED feed,
+ const unsigned char *cipherText,
+ unsigned cipherTextLen,
+ unsigned char *plainText,
+ unsigned *plainTextLen, // RETURNED
+ int finalBlock)
+{
+ feedInst *finst = (feedInst *) feed;
+ feeReturn frtn = FR_Success;
+ unsigned char clueByte;
+ giant thisClue; // not alloc'd
+ giant thisS; // ditto
+ int parity;
+
+ if(finst->rsCtext == NULL) {
+ /*
+ * Init'd for encrypt?
+ */
+ return FR_IllegalArg;
+ }
+ if(cipherTextLen != finst->cipherBlockSize) {
+ dbgLog(("feeFEEDDecryptBlock: bad cipherTextLen\n"));
+ return FR_IllegalArg;
+ }
+ if(finst->rsBlockCount < finst->rsSizeCipherBlocks) {
+ /*
+ * Processing initialRS, FEEDExp-encrypted
+ */
+ unsigned char *rsPtr = finst->rsCtext +
+ (finst->rsBlockCount * finst->cipherBlockSize);
+ unsigned feedExpCipherSize;
+
+ if(finalBlock) {
+ dbgLog(("feeFEEDDecryptBlock: incomplete initialRS\n"));
+ return FR_BadCipherText;
+ }
+ bcopy(cipherText, rsPtr, finst->cipherBlockSize);
+ finst->rsBlockCount++;
+ if(finst->rsBlockCount < finst->rsSizeCipherBlocks) {
+ /*
+ * Not done with this yet...
+ */
+ bprintf(("=== FEED Decrypt: gobbled 0x%x bytes ctext, no ptext (1)\n",
+ cipherTextLen));
+ *plainTextLen = 0;
+ return FR_Success;
+ }
+
+ #if FEED_DEBUG
+ if((finst->rsBlockCount * finst->cipherBlockSize) <
+ finst->rsCtextSize) {
+ dbgLog(("feeFEEDDecryptBlock: rsCtextSize underflow!\n"));
+ return FR_Internal;
+ }
+ #endif // FEED_DEBUG
+
+ /*
+ * OK, we should have the FEEDExp ciphertext for initialRS
+ * in rsCtext. Note the last few bytes are extra; we don't
+ * pass them to FEEDExp.
+ */
+ feedExpCipherSize = feeFEEDCipherBlockSize(finst->feedExp);
+ frtn = feeFEEDExpDecrypt(finst->feedExp,
+ finst->rsCtext,
+ finst->rsCtextSize,
+ &finst->initialRS,
+ &finst->initialRSSize);
+ if(frtn) {
+ dbgLog(("feeFEEDDecryptBlock: error decrypting "
+ "initialRS (%s)\n", feeReturnString(frtn)));
+ return FR_BadCipherText;
+ }
+
+ /*
+ * we already know how long this should be...
+ */
+ if(finst->initialRSSize != finst->initialRSSize) {
+ dbgLog(("feeFEEDDecryptBlock: initialRS sync error\n"));
+ return FR_BadCipherText;
+ }
+
+ /*
+ * Set up clues
+ */
+ if(initFromRS(finst)) {
+ dbgLog(("feeFEEDDecryptBlock: bad initialRS\n"));
+ return FR_BadCipherText;
+ }
+ else {
+ /*
+ * Normal completion of last cipherblock containing
+ * initialRS.
+ */
+ bprintf(("=== FEED Decrypt: gobbled 0x%x bytes ctext, no ptext (2)\n",
+ cipherTextLen));
+ *plainTextLen = 0;
+ return FR_Success;
+ }
+ }
+
+ /*
+ * grab xm and clueByte from cipherText
+ */
+ deserializeGiant(cipherText, finst->xm, finst->cp->minBytes);
+ cipherText += finst->cp->minBytes;
+ clueByte = *cipherText;
+
+ if((clueByte & CLUE_BIT) == CLUE_PLUS) {
+ thisClue = finst->cluePlus;
+ thisS = finst->sPlus;
+ }
+ else {
+ thisClue = finst->clueMinus;
+ thisS = finst->sMinus;
+ }
+ if((clueByte & PARITY_BIT) == PARITY_PLUS) {
+ parity = SIGN_PLUS;
+ }
+ else {
+ parity = SIGN_MINUS;
+ }
+
+ /*
+ * recover xp
+ * xp = xm + clue(+/-) w/parity
+ * adjust clue
+ * clue[n+1] = r * clue[n] + (s * P1)
+ */
+ elliptic_add(thisClue, finst->xm, finst->xp, finst->cp, parity);
+
+ elliptic_simple(thisClue, finst->r, finst->cp);
+ gtog(thisClue, finst->tmp1);
+ elliptic_add(finst->tmp1, thisS, thisClue, finst->cp, SIGN_PLUS);
+
+ /*
+ * plaintext in xp
+ */
+ #if FEED_DEBUG
+ printf("decrypt clue %d\n", clueByte);
+ printf(" xp : "); printGiant(finst->xp);
+ printf(" xm : "); printGiant(finst->xm);
+ printf(" cluePlus :"); printGiant(finst->cluePlus);
+ printf(" clueMinus :"); printGiant(finst->clueMinus);
+ #endif // FEED_DEBUG
+
+ if(finalBlock) {
+ /*
+ * Snag data from xp in order to find out how much to move to
+ * *plainText
+ */
+ unsigned char *ptext = (unsigned char*) fmalloc(finst->plainBlockSize);
+
+ serializeGiant(finst->xp, ptext, finst->plainBlockSize);
+ *plainTextLen = ptext[finst->plainBlockSize - 1];
+ if(*plainTextLen == RESID_ZERO) {
+ bprintf(("=== FEED Decrypt: RESID_ZERO\n"));
+ *plainTextLen = 0;
+ }
+ else if(*plainTextLen > (finst->plainBlockSize - 1)) {
+ dbgLog(("feeFEEDDecryptBlock: ptext overflow!\n"));
+ bprintf(("feeFEEDDecryptBlock: ptext overflow!\n"));
+ frtn = FR_BadCipherText;
+ }
+ else {
+ bprintf(("=== FEED Decrypt: resid len 0x%x\n", *plainTextLen));
+ bcopy(ptext, plainText, *plainTextLen);
+ }
+ ffree(ptext);
+ }
+ else {
+ *plainTextLen = finst->plainBlockSize;
+ serializeGiant(finst->xp, plainText, *plainTextLen);
+ }
+ bprintf(("=== FEED decryptBlock ptextLen 0x%x ctextLen 0x%x\n",
+ *plainTextLen, cipherTextLen));
+
+ return frtn;
+}
+
+/*
+ * Convenience routines to encrypt & decrypt multi-block data.
+ */
+feeReturn feeFEEDEncrypt(feeFEED feed,
+ const unsigned char *plainText,
+ unsigned plainTextLen,
+ unsigned char **cipherText, // malloc'd and RETURNED
+ unsigned *cipherTextLen) // RETURNED
+{
+ const unsigned char *ptext; // per block
+ unsigned ptextLen; // total to go
+ unsigned thisPtextLen; // per block
+ unsigned char *ctext; // per block
+ unsigned ctextLen; // per block
+ unsigned char *ctextResult; // to return
+ unsigned ctextResultLen; // size of ctextResult
+ unsigned char *ctextPtr;
+ unsigned ctextLenTotal; // running total
+ feeReturn frtn;
+ int finalBlock;
+ unsigned numBlocks;
+ unsigned plainBlockSize;
+ #if FEE_DEBUG
+ unsigned expectedCtextSize;
+
+ expectedCtextSize = feeFEEDCipherTextSize(feed, plainTextLen, 1);
+ #endif
+
+ if(plainTextLen == 0) {
+ dbgLog(("feeFEEDDecrypt: NULL plainText\n"));
+ return FR_IllegalArg;
+ }
+
+ ptext = plainText;
+ ptextLen = plainTextLen;
+ ctext = (unsigned char*) fmalloc(feeFEEDCipherBufSize(feed, 1));
+ plainBlockSize = feeFEEDPlainBlockSize(feed);
+ numBlocks = (plainTextLen + plainBlockSize - 1)/plainBlockSize;
+
+ /*
+ * Calculate the worst-case size needed to hold all of the ciphertext
+ */
+ ctextResultLen = feeFEEDCipherTextSize(feed, plainTextLen, 1);
+ ctextResult = (unsigned char*) fmalloc(ctextResultLen);
+ ctextPtr = ctextResult;
+ ctextLenTotal = 0;
+
+ while(1) {
+ if(ptextLen <= plainBlockSize) {
+ finalBlock = 1;
+ thisPtextLen = ptextLen;
+ }
+ else {
+ finalBlock = 0;
+ thisPtextLen = plainBlockSize;
+ }
+ frtn = feeFEEDEncryptBlock(feed,
+ ptext,
+ thisPtextLen,
+ ctext,
+ &ctextLen,
+ finalBlock);
+ if(frtn) {
+ dbgLog(("feeFEEDEncrypt: encrypt error: %s\n",
+ feeReturnString(frtn)));
+ break;
+ }
+ if(ctextLen == 0) {
+ dbgLog(("feeFEEDEncrypt: null ciphertext\n"));
+ frtn = FR_Internal;
+ break;
+ }
+ bcopy(ctext, ctextPtr, ctextLen);
+ ctextLenTotal += ctextLen;
+ if(ctextLenTotal > ctextResultLen) {
+ dbgLog(("feeFEEDEncrypt: ciphertext overflow\n"));
+ frtn = FR_Internal;
+ break;
+ }
+ if(finalBlock) {
+ break;
+ }
+ ctextPtr += ctextLen;
+ ptext += thisPtextLen;
+ ptextLen -= thisPtextLen;
+ }
+
+ ffree(ctext);
+ if(frtn) {
+ ffree(ctextResult);
+ *cipherText = NULL;
+ *cipherTextLen = 0;
+ }
+ else {
+ *cipherText = ctextResult;
+ *cipherTextLen = ctextLenTotal;
+ #if FEE_DEBUG
+ if(expectedCtextSize != ctextLenTotal) {
+ printf("feeFEEDEncrypt: feeFEEDCipherTextSize error!\n");
+ printf("ptext %d exp ctext %d actual ctext %d\n",
+ plainTextLen,
+ expectedCtextSize,
+ ctextLenTotal);
+ }
+ #endif // FEE_DEBUG
+ }
+ return frtn;
+
+}
+
+feeReturn feeFEEDDecrypt(feeFEED feed,
+ const unsigned char *cipherText,
+ unsigned cipherTextLen,
+ unsigned char **plainText, // malloc'd and RETURNED
+ unsigned *plainTextLen) // RETURNED
+{
+ const unsigned char *ctext;
+ unsigned ctextLen; // total to go
+ unsigned char *ptext; // per block
+ unsigned ptextLen; // per block
+ unsigned char *ptextResult; // to return
+ unsigned char *ptextPtr;
+ unsigned ptextLenTotal; // running total
+ feeReturn frtn = FR_Success;
+ int finalBlock;
+ unsigned numBlocks;
+ unsigned plainBlockSize = feeFEEDPlainBlockSize(feed);
+ unsigned cipherBlockSize = feeFEEDCipherBlockSize(feed);
+
+ if(cipherTextLen % cipherBlockSize) {
+ dbgLog(("feeFEEDDecrypt: unaligned cipherText\n"));
+ return FR_BadCipherText;
+ }
+ if(cipherTextLen == 0) {
+ dbgLog(("feeFEEDDecrypt: NULL cipherText\n"));
+ return FR_BadCipherText;
+ }
+
+ ptext = (unsigned char*) fmalloc(plainBlockSize);
+ ctext = cipherText;
+ ctextLen = cipherTextLen;
+ numBlocks = cipherTextLen / cipherBlockSize;
+ ptextResult = (unsigned char*) fmalloc(plainBlockSize * numBlocks);
+ ptextPtr = ptextResult;
+ ptextLenTotal = 0;
+
+ while(ctextLen) {
+ if(ctextLen == cipherBlockSize) {
+ finalBlock = 1;
+ }
+ else {
+ finalBlock = 0;
+ }
+ frtn = feeFEEDDecryptBlock(feed,
+ ctext,
+ cipherBlockSize,
+ ptext,
+ &ptextLen,
+ finalBlock);
+ if(frtn) {
+ dbgLog(("feeFEEDDecryptBlock: %s\n",
+ feeReturnString(frtn)));
+ break;
+ }
+ if(ptextLen) {
+ if(ptextLen > plainBlockSize) {
+ dbgLog(("feeFEEDDecrypt: ptext overflow!\n"));
+ frtn = FR_Internal;
+ break;
+ }
+ bcopy(ptext, ptextPtr, ptextLen);
+ ptextPtr += ptextLen;
+ ptextLenTotal += ptextLen;
+ }
+ /*
+ * note ptextLen == 0 is normal termination case for
+ * plainTextLen % plainBlockSize == 0.
+ * Also expected for first 4 blocks of ciphertext;
+ * proceed (we break when ctextLen is exhausted).
+ */
+ ctext += cipherBlockSize;
+ ctextLen -= cipherBlockSize;
+ }
+
+ ffree(ptext);
+ if(frtn) {
+ ffree(ptextResult);
+ *plainText = NULL;
+ *plainTextLen = 0;
+ }
+ else {
+ *plainText = ptextResult;
+ *plainTextLen = ptextLenTotal;
+ }
+ return frtn;
+
+}
+
+#endif /* CRYPTKIT_ASYMMETRIC_ENABLE */
projects / apple / security.git / blobdiff