OSX/include/security_comcryption/comcryptPriv.c

   1 /*
   2  * Copyright (c) 1997,2011,2013-2014 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24
  25 #include "comcryptPriv.h"
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #ifdef  macintosh
  30 #include <MacMemory.h>
  31 #endif
  32
  33 /* if NULL, use our own */
  34 comMallocExternFcn *comMallocExt = NULL;
  35 comFreeExternFcn *comFreeExt = NULL;
  36
  37 #if             COM_STATS
  38 comStats _comStats;
  39
  40 void resetComStats()
  41 {
  42         memset(&_comStats, 0, sizeof(comStats));
  43 }
  44
  45 void getComStats(comStats *stats)
  46 {
  47         *stats = _comStats;
  48 }
  49
  50 #else   /*COM_STATS*/
  51
  52 #define incrComStat(stat, num)
  53
  54 #endif  /*COM_STATS*/
  55
  56 /*
  57  * Generate a symbol permutation from the key.
  58  */
  59 void key_perm(
  60         const unsigned char *key,
  61         int                             keybytes,
  62         unsigned char           *map,
  63         unsigned char           *invmap)
  64 {
  65     int i, j, tmp, sum;
  66
  67     for(sum = 0, j = 0; j < keybytes; j++) {
  68                 sum += key[j];
  69         }
  70         for(j=0; j < 256; j++) {
  71                 map[j] = j;
  72         }
  73         for(j=0; j < 255; j++) {
  74                 i = (key[j % keybytes] + j*sum) & 0xff;
  75                 tmp = map[i];
  76                 map[i] = map[j];
  77                 map[j] = tmp;
  78         }
  79         for(j=0; j<256; j++) {
  80                 invmap[map[j]] = j;
  81         }
  82 }
  83
  84 int keybyte(
  85         const unsigned char *key,
  86         int                             keybytes,
  87         int                             index)
  88 {
  89     return((int) key[index % keybytes]);
  90 }
  91
  92 int keynybble(
  93         const unsigned char *key,
  94         int                             keybytes,
  95         int                             index)
  96 {
  97         int i = index % (2*keybytes);
  98         int j;
  99
 100     j = key[i>>1];              /* Which byte. */
 101     if(i & 1) j >>= 4;  /* Which nybble. */
 102     return(j & 0xf);
 103 }
 104
 105 /*
 106  * Hash a key array.
 107  */
 108
 109 #define HASH_SEED       3
 110 #define HASH_REDUCE     1023
 111
 112 static unsigned keyHash(const unsigned char *key, unsigned keylen)
 113 {
 114         unsigned x = HASH_SEED;  /* Any seed in [1,p-1].  Like SEED = 3. */
 115         unsigned ctr;
 116
 117         for(ctr=0; ctr<keylen; ctr++) {
 118                 x = (x * (key[ctr] + (ctr & HASH_REDUCE) + 1)) % HASH_PRIME;
 119         }
 120         return x;
 121 }
 122
 123 void mallocCodeBufs(comcryptBuf *cbuf)
 124 {
 125         /*
 126          * calculate required buffer sizes.
 127          *
 128          * Assume max required codeBuf size is the max size of ciphertext needed
 129          * to decrypt one block of plaintext.
 130          */
 131         cbuf->codeBufSize = comcryptMaxOutBufSize(NULL,
 132                 CC_BLOCK_SIZE,
 133                 CCOP_COMCRYPT,
 134                 1);
 135         cbuf->codeBuf = (unsigned char *)ascMalloc(cbuf->codeBufSize);
 136
 137         /*
 138          * max size needed for level2Buf is the MaxOutBufSize of comcrypting
 139          * a whole block of byte code. Note we assume that MaxOutBufSize(n) >= n.
 140          */
 141         cbuf->level2BufSize = comcryptMaxOutBufSize(NULL,
 142                 MAX_TOKENS,                             // one byte per token
 143                 CCOP_COMCRYPT,
 144                 1);
 145         cbuf->level2Buf = (unsigned char *)ascMalloc(cbuf->level2BufSize);
 146
 147         cbuf->queue = (queueElt *)ascMalloc(sizeof(queueElt) * QLEN);
 148
 149         #if             QUEUE_LOOKAHEAD
 150         /*
 151          * Might want to do this dynamically, though that requires the malloc
 152          * of the lookAhead buffer to be done in initCodeBufs(), not here (at
 153          * comcryptAlloc() time).
 154          *
 155          * FIXME : should do the malloc of lookAhead buffer lazily for
 156          * non-Mac platforms.
 157          */
 158         cbuf->lookAhead = (unsigned char *)ascMalloc(LOOKAHEAD_SIZE);
 159         #else   /* QUEUE_LOOKAHEAD */
 160         cbuf->lookAhead = NULL;
 161         #endif  /* QUEUE_LOOKAHEAD */
 162
 163         /*
 164          * This maybe should also be done dynamically, lazily...
 165          */
 166         cbuf->sigArray = (unsigned *)ascMalloc((MAX_TOKENS + 1) * sizeof(unsigned));
 167 }
 168
 169 void initCodeBufs(
 170         comcryptBuf *cbuf,
 171         const unsigned char *key,
 172         unsigned keyLen,
 173         unsigned char laEnable,
 174         unsigned char sigSeqEnable)
 175 {
 176         unsigned ct;
 177         unsigned qval;
 178         unsigned char khash = (unsigned char)keyHash(key, keyLen);
 179
 180         cbuf->nybbleDex = khash;
 181
 182         if(laEnable) {
 183                 memset(cbuf->lookAhead, 0, LOOKAHEAD_SIZE);
 184         }
 185
 186         laprintf(("initing queue and lookahead\n"));
 187
 188         for(ct=0; ct<QLEN; ct++) {
 189                 /*
 190                  * New queue init 23 Dec - init from khash
 191                  */
 192                 unsigned short sbyte = ct ^ khash;
 193                 qval = (sbyte << 8) | ct;
 194                 cbuf->queue[ct] = qval;
 195                 if(laEnable) {
 196                         markInQueue(cbuf, qval, 1);
 197                 }
 198         }
 199         // note cbuf->nybbleDex = khash on return...
 200
 201         cbuf->f1 = F1_DEFAULT;
 202         cbuf->f2 = F2_DEFAULT;
 203         cbuf->jmatchThresh = THRESH_2LEVEL_JMATCH_DEF;
 204         cbuf->minByteCode  = THRESH_2LEVEL_NUMBYTECODES_DEF;
 205         if(sigSeqEnable) {
 206                 initSigSequence(cbuf, key, keyLen);
 207         }
 208 }
 209
 210 void freeCodeBufs(comcryptBuf *cbuf)
 211 {
 212         if(cbuf->queue != NULL) {
 213                 ascFree(cbuf->queue);
 214         }
 215         if(cbuf->codeBuf != NULL) {
 216                 ascFree(cbuf->codeBuf);
 217         }
 218         if(cbuf->level2Buf != NULL) {
 219                 ascFree(cbuf->level2Buf);
 220         }
 221         if(cbuf->nextBuf != NULL) {
 222                 freeCodeBufs(cbuf->nextBuf);
 223                 ascFree(cbuf->nextBuf);
 224                 cbuf->nextBuf = NULL;
 225         }
 226         if(cbuf->lookAhead != NULL) {
 227                 ascFree(cbuf->lookAhead);
 228         }
 229         if(cbuf->sigArray != NULL) {
 230                 ascFree(cbuf->sigArray);
 231         }
 232 }
 233
 234 void serializeInt(
 235         unsigned i,
 236         unsigned char *buf)
 237 {
 238         buf[0] = (unsigned char)(i >> 24);
 239         buf[1] = (unsigned char)(i >> 16);
 240         buf[2] = (unsigned char)(i >> 8);
 241         buf[3] = (unsigned char)(i & 0xff);
 242 }
 243
 244 unsigned deserializeInt(unsigned char *buf)
 245 {
 246         unsigned i;
 247
 248         i  = ((unsigned)buf[0]) << 24;
 249         i |= ((unsigned)buf[1]) << 16;
 250         i |= ((unsigned)buf[2]) << 8;
 251         i |= buf[3];
 252         return i;
 253 }
 254
 255 #if             COM_PARAM_ENABLE
 256
 257 unsigned getF1(comcryptObj cobj)
 258 {
 259         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 260
 261         return cpriv->cbuf.f1;
 262 }
 263
 264 void setF1(comcryptObj cobj, unsigned f1)
 265 {
 266         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 267
 268         cpriv->cbuf.f1 = f1;
 269         if(cpriv->cbuf.nextBuf != NULL) {
 270                 cpriv->cbuf.nextBuf->f1 = f1;
 271         }
 272 }
 273
 274 unsigned getF2(comcryptObj cobj)
 275 {
 276         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 277
 278         return cpriv->cbuf.f2;
 279 }
 280
 281 void setF2(comcryptObj cobj, unsigned f2)
 282 {
 283         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 284
 285         cpriv->cbuf.f2 = f2;
 286         if(cpriv->cbuf.nextBuf != NULL) {
 287                 cpriv->cbuf.nextBuf->f2 = f2;
 288         }
 289 }
 290
 291 unsigned getJmatchThresh(comcryptObj cobj)
 292 {
 293         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 294
 295         return cpriv->cbuf.jmatchThresh;
 296 }
 297
 298 void setJmatchThresh(comcryptObj cobj, unsigned jmatchThresh)
 299 {
 300         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 301
 302         cpriv->cbuf.jmatchThresh = jmatchThresh;
 303         if(cpriv->cbuf.nextBuf != NULL) {
 304                 cpriv->cbuf.nextBuf->jmatchThresh = jmatchThresh;
 305         }
 306 }
 307
 308 unsigned getMinByteCode(comcryptObj cobj)
 309 {
 310         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 311
 312         return cpriv->cbuf.minByteCode;
 313 }
 314
 315 void setMinByteCode(comcryptObj cobj, unsigned minByteCode)
 316 {
 317         comcryptPriv *cpriv = (comcryptPriv *)cobj;
 318
 319         cpriv->cbuf.minByteCode = minByteCode;
 320         if(cpriv->cbuf.nextBuf != NULL) {
 321                 cpriv->cbuf.nextBuf->minByteCode = minByteCode;
 322         }
 323 }
 324
 325 #endif  /*COM_PARAM_ENABLE*/
 326
 327
 328 #if             COM_LA_DEBUG
 329
 330 /*
 331  * Verify integrity of lookahead w.r.t. queue.
 332  */
 333 int testLookAhead(comcryptBuf *cbuf, int i1, int i2)
 334 {
 335         unsigned i;
 336
 337         if(!cbuf->laEnable) {
 338                 return 0;
 339         }
 340         for(i=0; i<QLEN; i++) {
 341                 if(!inQueue(cbuf, cbuf->queue[i])) {
 342                         printf("aaagh, corrupted lookahead - in queue[], !inQueue()\n");
 343                         printf("i=0x%x   i1=0x%x   i2=0x%x\n",
 344                                 i, i1, i2);
 345                         printf("\n");
 346                         exit(1);
 347                 }
 348         }
 349         //return initTestLookAhead(cbuf);
 350         return 0;
 351 }
 352
 353 int initTestLookAhead(comcryptBuf *cbuf)
 354 {
 355         #if             QUEUE_LOOKAHEAD_BIT
 356
 357         unsigned codeWord = 0;
 358         unsigned char bit;
 359         unsigned short byte;
 360         unsigned char *la = cbuf->lookAhead;
 361
 362         for(byte=0; byte<LOOKAHEAD_SIZE; byte++) {
 363                 for(bit=1; bit!=0; bit<<=1) {
 364                         if(la[byte] & bit) {
 365                                 /*
 366                                  * in lookahead, make sure it's in queue[]
 367                                  */
 368                                 int i;
 369                                 int found = 0;
 370
 371                                 for(i=0; i<QLEN; i++) {
 372                                         if(cbuf->queue[i] == codeWord) {
 373                                                 found = 1;
 374                                                 break;
 375                                         }
 376                                 }
 377                                 if(!found) {
 378                                         printf("***corrupted init lookahead - in l.a., "
 379                                                 "not in queue[]\n");
 380                                         printf("codeWord 0x%x\n", codeWord);
 381                                         printf("\n");
 382                                         exit(1);
 383                                 }
 384                         }
 385                         codeWord++;
 386                 }
 387         }
 388
 389         #endif  /* QUEUE_LOOKAHEAD_BIT */
 390         return 0;
 391 }
 392
 393 #endif  /* COM_LA_DEBUG */
 394
 395 void initSigSequence(comcryptBuf *cbuf,
 396         const unsigned char *key,
 397         unsigned keyLen)
 398 {
 399     unsigned seed = IN_OFFSET;
 400         unsigned j;
 401
 402     for(j=0; j<keyLen; j++) {
 403                 seed += key[j];
 404     }
 405     seed %= HASH_PRIME;
 406     if(seed == 0) {
 407                 seed = IN_OFFSET;
 408         }
 409         cbuf->sigArray[0] = (unsigned short)seed;
 410 }
 411
 412 #if     0
 413 /*
 414  * Called once per token bit, after processing the token.
 415  */
 416 void nextSigWord(comcryptBuf *cbuf,
 417         unsigned sigDex,                        // same as tokenDex
 418         unsigned match,
 419         unsigned above)                         // jabove, keyabove
 420 {
 421         unsigned offset;
 422         unsigned short *sigArray = cbuf->sigArray;
 423
 424         #if             COM_DEBUG
 425         if(sigDex == 0) {
 426                 printf("nextSigWord underflow\n");
 427                 exit(1);
 428         }
 429         if(sigDex > MAX_TOKENS) {
 430                 printf("nextSigWord overflow\n");
 431                 exit(1);
 432         }
 433         #endif
 434
 435         if(match) {
 436                 offset = IN_OFFSET;
 437         }
 438         else {
 439                 offset = OUT_OFFSET;
 440         }
 441 #if             1
 442         sigArray[sigDex] = (sigArray[sigDex-1] * (above + offset)) % HASH_PRIME;
 443 #endif
 444 }
 445 #endif
 446
 447 /*
 448  * Obfuscate a block of ciphertext.
 449  */
 450 void sigMunge(comcryptBuf *cbuf,
 451         const unsigned char *tokenPtr,
 452         unsigned numTokens,
 453         unsigned char *byteCodePtr,
 454         unsigned char *longCodePtr)
 455 {
 456         unsigned char tokenBit = 0x01;
 457         unsigned token;
 458         unsigned short sig;
 459
 460         for(token=0; token<numTokens; token++) {
 461                 sig = cbuf->sigArray[token];
 462                 if(*tokenPtr & tokenBit) {
 463                         /* no match - munge longCode - written MSB first */
 464                         *longCodePtr++ ^= (unsigned char)(sig >> 8);
 465                         *longCodePtr++ ^= (unsigned char)sig;
 466                 }
 467                 else {
 468                         /* match - munge byteCode */
 469                         *byteCodePtr++ ^= (unsigned char)sig;
 470                 }
 471                 tokenBit <<= 1;
 472                 if(tokenBit == 0) {
 473                         tokenBit = 0x01;
 474                         tokenPtr++;
 475                 }
 476         }
 477 }
 478
 479
 480 /*
 481  * All this can be optimized and tailored to specific platforms, of course...
 482  */
 483
 484 void *ascMalloc(unsigned size)
 485 {
 486         #ifdef  macintosh
 487
 488         Handle h;
 489         OSErr err;
 490         Ptr p;
 491
 492         #endif  /* mac */
 493
 494         if(comMallocExt != NULL) {
 495                 return (comMallocExt)(size);
 496         }
 497
 498         #ifdef  macintosh
 499
 500         h = nil;
 501         err = errSecSuccess;
 502
 503         h = NewHandleSys(size);         // system heap is not paged
 504         do{
 505                 HLockHi(h);                     // will move low in system heap
 506                 err = MemError();
 507                 if( err != errSecSuccess ) break;
 508                 p = *h;
 509         }while(0);
 510         if( err != errSecSuccess ){
 511             return NULL;
 512         }
 513         return p;
 514
 515         #else   /* others...*/
 516         return malloc(size);
 517         #endif
 518 }
 519
 520 void ascFree(void *data)
 521 {
 522         #ifdef macintosh
 523         Handle h;
 524         #endif
 525
 526         if(comFreeExt != NULL) {
 527                 (comFreeExt)(data);
 528                 return;
 529         }
 530
 531         #ifdef macintosh
 532         if( data != nil ){
 533                 h = RecoverHandle((Ptr) data);
 534                 DisposeHandle(h);
 535         }
 536
 537         #else   /* others */
 538         free(data);
 539         #endif
 540 }