libsecurity_sd_cspdl/lib/SDContext.h

   1 /*
   2  * Copyright (c) 2004 Apple Computer, 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 //
  26 // SDContext.h - Security Server contexts
  27 //
  28 #ifndef _H_SD_CONTEXT
  29 #define _H_SD_CONTEXT
  30
  31 #include <security_cdsa_plugin/CSPsession.h>
  32 #include <securityd_client/ssclient.h>
  33 #include <security_cdsa_utilities/digestobject.h>
  34 #include <security_cdsa_client/cspclient.h>
  35
  36 //
  37 // Parent class for all CSPContexts implemented in this CSP.  Currently the
  38 // only thing we add is a reference to our creator's session.
  39 //
  40 class SDCSPSession;
  41 class SDKey;
  42
  43 class SDContext : public CSPFullPluginSession::CSPContext
  44 {
  45 public:
  46         SDContext(SDCSPSession &session);
  47         ~SDContext() { clearOutBuf(); }
  48         virtual void init(const Context &context, bool encoding);
  49
  50 protected:
  51         SecurityServer::ClientSession &clientSession();
  52         SDCSPSession &mSession;
  53
  54         // mOutBuf provides a holding tank for implied final() operations
  55         // resulting from an outputSize(true, 0). This form of outputSize()
  56         // is understood to only occur just prior to the final() call. To avoid
  57         // an extra RPC (just to perform the outputSize(), most subclasses of
  58         // SDContext actually perform the final() operation at this time,
  59         // storing the result in mOutBuf. At final(), mOutBuf() is just copied
  60         // to the caller's supplied output buffer.
  61         CssmData mOutBuf;
  62
  63         // We remember a pointer to the passed in context and assume it will
  64         // remain a valid from init(), update() all the way though the call to
  65         // final().
  66         const Context *mContext;
  67
  68         void clearOutBuf();
  69         void copyOutBuf(CssmData &out);
  70 };
  71
  72 // context for signature (sign and verify)
  73 class SDSignatureContext : public SDContext
  74 {
  75 public:
  76         SDSignatureContext(SDCSPSession &session);
  77         ~SDSignatureContext();
  78         virtual void init(const Context &context, bool signing);
  79         virtual void update(const CssmData &data);
  80         virtual size_t outputSize(bool final, size_t inSize);
  81
  82         /* sign */
  83         void sign(CssmData &sig);
  84         virtual void final(CssmData &out);
  85
  86         /* verify */
  87         virtual void final(const CssmData &in);
  88
  89         /* for raw sign/verify - optionally called after init */
  90         virtual void setDigestAlgorithm(CSSM_ALGORITHMS digestAlg);
  91
  92 private:
  93         /* stash the context's key for final sign/verify */
  94         SecurityServer::KeyHandle mKeyHandle;
  95
  96         /* alg-dependent, calculated at init time */
  97         CSSM_ALGORITHMS mSigAlg;                // raw signature alg
  98         CSSM_ALGORITHMS mDigestAlg;             // digest
  99         CSSM_ALGORITHMS mOrigAlg;               // caller's context alg
 100
 101         /* exactly one of these is used to collect updates */
 102         NullDigest                      *mNullDigest;
 103         CssmClient::Digest      *mDigest;
 104 };
 105
 106 // Context for GenerateRandom operations
 107 class SDRandomContext : public SDContext
 108 {
 109 public:
 110         SDRandomContext(SDCSPSession &session);
 111         virtual void init(const Context &context, bool);
 112         virtual size_t outputSize(bool final, size_t inSize);
 113         virtual void final(CssmData &out);
 114
 115 private:
 116         uint32 mOutSize;                // spec'd in context at init() time
 117 };
 118
 119 // Context for Encrypt and Decrypt operations
 120 class SDCryptContext : public SDContext
 121 {
 122 public:
 123         SDCryptContext(SDCSPSession &session);
 124         ~SDCryptContext();
 125         virtual void init(const Context &context, bool encoding);
 126         virtual size_t inputSize(size_t outSize);
 127         virtual size_t outputSize(bool final, size_t inSize);
 128         virtual void minimumProgress(size_t &in, size_t &out);
 129         virtual void update(void *inp, size_t &inSize, void *outp,
 130                                                 size_t &outSize);
 131         virtual void final(CssmData &out);
 132
 133 private:
 134         SecurityServer::KeyHandle mKeyHandle;
 135         NullDigest mNullDigest;                                         // accumulator
 136 };
 137
 138 // Digest, using raw CSP
 139 class SDDigestContext : public SDContext
 140 {
 141 public:
 142         SDDigestContext(SDCSPSession &session);
 143         ~SDDigestContext();
 144         virtual void init(const Context &context, bool);
 145         virtual void update(const CssmData &data);
 146         virtual void final(CssmData &out);
 147         virtual size_t outputSize(bool final, size_t inSize);
 148
 149 private:
 150         CssmClient::Digest *mDigest;
 151 };
 152
 153 // common class for MAC generate, verify
 154 class SDMACContext : public SDContext
 155 {
 156 public:
 157         SDMACContext(SDCSPSession &session);
 158         virtual void init(const Context &context, bool);
 159         virtual void update(const CssmData &data);
 160         virtual size_t outputSize(bool final, size_t inSize);
 161
 162         /* sign */
 163         void genMac(CssmData &mac);
 164         virtual void final(CssmData &out);
 165         /* verify */
 166         virtual void final(const CssmData &in);
 167
 168 private:
 169         SecurityServer::KeyHandle mKeyHandle;
 170         NullDigest mNullDigest;                                 // accumulator
 171 };
 172
 173
 174 #endif // _H_SD_CONTEXT