OSX/libsecurity_apple_csp/lib/ascContext.cpp

   1 /*
   2  * Copyright (c) 2001,2011-2012,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 #ifdef  ASC_CSP_ENABLE
  26
  27 #include "ascContext.h"
  28 #include "ascFactory.h"
  29 #include <security_utilities/debugging.h>
  30 #include <security_utilities/logging.h>
  31 #include <Security/cssmapple.h>
  32
  33 #define abprintf(args...)       secinfo("ascBuf", ## args)              /* buffer sizes */
  34 #define aioprintf(args...)      secinfo("ascIo", ## args)               /* all I/O */
  35
  36 static Allocator *ascAllocator;
  37
  38 /*
  39  * Comcryption-style memory allocator callbacks
  40  */
  41 static void *ccMalloc(unsigned size)
  42 {
  43         return ascAllocator->malloc(size);
  44 }
  45 static void ccFree(void *data)
  46 {
  47         ascAllocator->free(data);
  48 }
  49
  50 /* Given a ComCryption error, throw appropriate CssmError */
  51 static void throwComcrypt(
  52         comcryptReturn  crtn,
  53         const char              *op)            /* optional */
  54 {
  55         CSSM_RETURN cerr = CSSM_OK;
  56         const char *errStr = "Bad Error String";
  57
  58         switch(crtn) {
  59                 case CCR_SUCCESS:
  60                         errStr = "CCR_SUCCESS";
  61                         break;
  62                 case CCR_OUTBUFFER_TOO_SMALL:
  63                         errStr = "CCR_OUTBUFFER_TOO_SMALL";
  64                         cerr = CSSMERR_CSP_OUTPUT_LENGTH_ERROR;
  65                         break;
  66                 case CCR_MEMORY_ERROR:
  67                         errStr = "CCR_MEMORY_ERROR";
  68                         cerr = CSSMERR_CSP_MEMORY_ERROR;
  69                         break;
  70                 case CCR_WRONG_VERSION:
  71                         errStr = "CCR_WRONG_VERSION";
  72                         cerr = CSSMERR_CSP_INVALID_DATA;
  73                         break;
  74                 case CCR_BAD_CIPHERTEXT:
  75                         errStr = "CCR_BAD_CIPHERTEXT";
  76                         cerr = CSSMERR_CSP_INVALID_DATA;
  77                         break;
  78                 case CCR_INTERNAL:
  79                 default:
  80                         errStr = "CCR_INTERNAL";
  81                         cerr = CSSMERR_CSP_INTERNAL_ERROR;
  82                         break;
  83         }
  84         if(op) {
  85                 Security::Syslog::error("Apple CSP %s: %s", op, errStr);
  86         }
  87         if(cerr) {
  88                 CssmError::throwMe(cerr);
  89         }
  90 }
  91
  92 /*
  93  * Algorithm factory.
  94  */
  95
  96 AscAlgFactory::AscAlgFactory(
  97         Allocator *normAlloc,
  98         Allocator *privAlloc)
  99 {
 100         /* once-per-address-space init */
 101         ascAllocator = privAlloc;
 102         comMallocRegister(ccMalloc, ccFree);
 103 }
 104
 105 bool AscAlgFactory::setup(
 106         AppleCSPSession &session,
 107         CSPFullPluginSession::CSPContext * &cspCtx,
 108         const Context &context)
 109 {
 110         if(context.algorithm() != CSSM_ALGID_ASC) {
 111                 return false;
 112         }
 113         if(cspCtx != NULL) {
 114                 /* reusing one of ours; OK */
 115                 return true;
 116         }
 117         switch(context.type()) {
 118                 case CSSM_ALGCLASS_KEYGEN:
 119                         cspCtx = new AppleSymmKeyGenerator(session,
 120                                 8,
 121                                 COMCRYPT_MAX_KEYLENGTH * 8,
 122                                 true);                                  // must be byte size
 123                         return true;
 124                 case CSSM_ALGCLASS_SYMMETRIC:
 125                         cspCtx = new ASCContext(session);
 126                         return true;
 127                 default:
 128                         break;
 129         }
 130         /* not ours */
 131         return false;
 132 }
 133
 134 ASCContext::~ASCContext()
 135 {
 136         if(mCcObj != NULL) {
 137                 comcryptObjFree(mCcObj);
 138         }
 139 }
 140
 141 /*
 142  * Standard CSPContext init, called from CSPFullPluginSession::init().
 143  * Reusable, e.g., query followed by en/decrypt.
 144  */
 145 void ASCContext::init(
 146         const Context &context,
 147         bool encrypting)
 148 {
 149         CSSM_SIZE               keyLen;
 150         uint8                   *keyData        = NULL;
 151         comcryptReturn  crtn;
 152
 153         /* obtain key from context */
 154         symmetricKeyBits(context, session(), CSSM_ALGID_ASC,
 155                 encrypting ? CSSM_KEYUSE_ENCRYPT : CSSM_KEYUSE_DECRYPT,
 156                 keyData, keyLen);
 157         if((keyLen < 1) || (keyLen > COMCRYPT_MAX_KEYLENGTH)) {
 158                 CssmError::throwMe(CSSMERR_CSP_INVALID_ATTR_KEY);
 159         }
 160         mDecryptBufValid = false;
 161
 162         /* optional optimization attribute */
 163         comcryptOptimize optimize = CCO_DEFAULT;
 164         uint32 opt = context.getInt(CSSM_ATTRIBUTE_ASC_OPTIMIZATION);
 165         switch(opt) {
 166                 case CSSM_ASC_OPTIMIZE_DEFAULT:
 167                         optimize = CCO_DEFAULT;
 168                         break;
 169                 case CSSM_ASC_OPTIMIZE_SIZE:
 170                         optimize = CCO_SIZE;
 171                         break;
 172                 case CSSM_ASC_OPTIMIZE_SECURITY:
 173                         optimize = CCO_SECURITY;
 174                         break;
 175                 case CSSM_ASC_OPTIMIZE_TIME:
 176                         optimize = CCO_TIME;
 177                         break;
 178                 case CSSM_ASC_OPTIMIZE_TIME_SIZE:
 179                         optimize = CCO_TIME_SIZE;
 180                         break;
 181                 case CSSM_ASC_OPTIMIZE_ASCII:
 182                         optimize = CCO_ASCII;
 183                         break;
 184                 default:
 185                         CssmError::throwMe(CSSMERR_CSP_INVALID_ATTR_ALG_PARAMS);
 186         }
 187
 188         /* All other context attributes ignored */
 189         /* init the low-level state */
 190         if(mCcObj == NULL) {
 191                 /* note we allow for context reuse */
 192                 mCcObj = comcryptAlloc();
 193                 if(mCcObj == NULL) {
 194                         CssmError::throwMe(CSSMERR_CSP_MEMORY_ERROR);
 195                 }
 196         }
 197
 198         crtn = comcryptInit(mCcObj, keyData, (unsigned)keyLen, optimize);
 199         if(crtn) {
 200                 throwComcrypt(crtn, "comcryptInit");
 201         }
 202 }
 203
 204 /*
 205  * All of these functions are called by CSPFullPluginSession.
 206  */
 207 void ASCContext::update(
 208         void                    *inp,
 209         size_t                  &inSize,                        // in/out
 210         void                    *outp,
 211         size_t                  &outSize)                       // in/out
 212 {
 213         comcryptReturn crtn;
 214         unsigned outLen;
 215         unsigned char *inText  = (unsigned char *)inp;
 216         unsigned char *outText = (unsigned char *)outp;
 217
 218         if(encoding()) {
 219                 outLen = (unsigned)outSize;
 220                 crtn = comcryptData(mCcObj,
 221                         inText,
 222                         (unsigned)inSize,
 223                         outText,
 224                         &outLen,
 225                         CCE_MORE_TO_COME);              // not used on encrypt
 226                 if(crtn) {
 227                         throwComcrypt(crtn, "comcryptData");
 228                 }
 229         }
 230         else {
 231                 /*
 232                  * Deal with 1-byte buffer hack. First decrypt the existing buffer...
 233                  */
 234                 if(inSize == 0) {
 235                         CssmError::throwMe(CSSMERR_CSP_INPUT_LENGTH_ERROR);
 236                 }
 237                 unsigned thisOutLen;
 238                 unsigned partialOutLen = 0;
 239                 if(mDecryptBufValid) {
 240                         thisOutLen = (unsigned)outSize;
 241                         crtn = deComcryptData(mCcObj,
 242                                 &mDecryptBuf,
 243                                 1,
 244                                 outText,
 245                                 &thisOutLen,
 246                                 CCE_MORE_TO_COME);
 247                         mDecryptBufValid = false;
 248                         if(crtn) {
 249                                 throwComcrypt(crtn, "deComcryptData (1)");
 250                         }
 251                         partialOutLen = thisOutLen;
 252                         outText      += thisOutLen;
 253                 }
 254
 255                 /*
 256                  * Now decrypt remaining, less one byte (which is stored in the
 257                  * buffer).
 258                  */
 259                 thisOutLen = (unsigned)(outSize - partialOutLen);
 260                 crtn = deComcryptData(mCcObj,
 261                         inText,
 262                         (unsigned)(inSize - 1),
 263                         outText,
 264                         &thisOutLen,
 265                         CCE_MORE_TO_COME);
 266                 if(crtn) {
 267                         throwComcrypt(crtn, "deComcryptData (2)");
 268                 }
 269                 outLen = partialOutLen + thisOutLen;
 270                 mDecryptBuf = inText[inSize - 1];
 271                 mDecryptBufValid = true;
 272         }
 273         outSize = outLen;
 274         aioprintf("=== ASC::update encrypt %d   inSize %ld  outSize %ld",
 275                 encoding() ? 1 : 0, inSize, outSize);
 276 }
 277
 278 void ASCContext::final(
 279         CssmData                &out)
 280 {
 281         if(encoding()) {
 282                 out.length(0);
 283         }
 284         else {
 285                 /* decrypt buffer hack */
 286                 if(!mDecryptBufValid) {
 287                         CssmError::throwMe(CSSMERR_CSP_INPUT_LENGTH_ERROR);
 288                 }
 289                 comcryptReturn crtn;
 290                 unsigned outLen = (unsigned)out.Length;
 291                 crtn = deComcryptData(mCcObj,
 292                         &mDecryptBuf,
 293                         1,
 294                         (unsigned char *)out.Data,
 295                         &outLen,
 296                         CCE_END_OF_STREAM);
 297                 mDecryptBufValid = false;
 298                 if(crtn) {
 299                         throwComcrypt(crtn, "deComcryptData (3)");
 300                 }
 301                 out.length(outLen);
 302         }
 303         aioprintf("=== ASC::final  encrypt %d   outSize %ld",
 304                 encoding() ? 1 : 0, out.Length);
 305 }
 306
 307 size_t ASCContext::inputSize(
 308         size_t                  outSize)                        // input for given output size
 309 {
 310         size_t rtn = comcryptMaxInBufSize(mCcObj,
 311                 (unsigned)outSize,
 312                 encoding() ? CCOP_COMCRYPT : CCOP_DECOMCRYPT);
 313         abprintf("--- ASCContext::inputSize  inSize %ld outSize %ld",
 314                 rtn, outSize);
 315         return rtn;
 316 }
 317
 318 /*
 319  * ComCryption's buffer size calculation really does not lend itself to the
 320  * requirements here. For example, there is no guarantee that
 321  * inputSize(outputSize(x)) == x. We're just going to fudge it and make
 322  * apps (or CSPFullPluginSession) alloc plenty more than they need.
 323  */
 324 #define ASC_OUTSIZE_FUDGE                       1
 325 #define ASC_OUTSIZE_FUDGE_FACTOR        1.2
 326
 327 size_t ASCContext::outputSize(
 328         bool                    final,
 329         size_t                  inSize)                         // output for given input size
 330 {
 331         unsigned effectiveInSize = (unsigned)inSize;
 332         size_t rtn;
 333         if(encoding()) {
 334                 rtn = comcryptMaxOutBufSize(mCcObj,
 335                         effectiveInSize,
 336                         CCOP_COMCRYPT,
 337                         final);
 338                 #if ASC_OUTSIZE_FUDGE
 339                 float newOutSize = rtn;
 340                 newOutSize *= ASC_OUTSIZE_FUDGE_FACTOR;
 341                 rtn = static_cast<size_t>(newOutSize);
 342                 #endif  /* ASC_OUTSIZE_FUDGE */
 343         }
 344         else {
 345                 if(final) {
 346                         if(mDecryptBufValid) {
 347                                 effectiveInSize++;
 348                         }
 349                 }
 350                 else if(inSize && !mDecryptBufValid) {
 351                         /* not final and nothing buffered yet - lop off one */
 352                         effectiveInSize--;
 353                 }
 354                 rtn = comcryptMaxOutBufSize(mCcObj,
 355                         effectiveInSize,
 356                         CCOP_DECOMCRYPT,
 357                         final);
 358         }
 359         abprintf("--- ASCContext::outputSize inSize %ld outSize %ld final %d ",
 360                 inSize, rtn, final);
 361         return rtn;
 362 }
 363
 364 void ASCContext::minimumProgress(
 365         size_t                  &in,
 366         size_t                  &out)                           // minimum progress chunks
 367 {
 368         if(encoding()) {
 369                 in  = 1;
 370                 out = comcryptMaxOutBufSize(mCcObj,
 371                         1,
 372                         CCOP_COMCRYPT,
 373                         0);
 374         }
 375         else {
 376                 if(mDecryptBufValid) {
 377                         /* use "everything" */
 378                         in = 1;
 379                 }
 380                 else {
 381                         in = 0;
 382                 }
 383                 out = comcryptMaxOutBufSize(mCcObj,
 384                         (unsigned)in,
 385                         CCOP_DECOMCRYPT,
 386                         0);
 387         }
 388         abprintf("--- ASCContext::minProgres in %ld out %ld", in, out);
 389 }
 390
 391 #endif  /* ASC_CSP_ENABLE */