SecureTransport/privateInc/sslContext.h

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /*
  20         File:           sslContext.h
  21
  22         Contains:       Private SSL typedefs: SSLContext and its components
  23
  24         Written by:     Doug Mitchell
  25
  26         Copyright: (c) 1999 by Apple Computer, Inc., all rights reserved.
  27
  28 */
  29
  30 #ifndef _SSLCONTEXT_H_
  31 #define _SSLCONTEXT_H_ 1
  32
  33 #include <Security/SecureTransport.h>
  34 #include "sslBuildFlags.h"
  35 #include <Security/cssmtype.h>
  36
  37 #include "sslPriv.h"
  38 #include "tls_ssl.h"
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 typedef struct
  45 {   SSLReadFunc         read;
  46     SSLWriteFunc        write;
  47     SSLConnectionRef    ioRef;
  48 } IOContext;
  49
  50 /*
  51  * An element in a certificate chain.
  52  */
  53 typedef struct SSLCertificate
  54 {
  55         struct SSLCertificate   *next;
  56     SSLBuffer               derCert;
  57 } SSLCertificate;
  58
  59 #include "cryptType.h"
  60
  61 /*
  62  * An SSLContext contains four of these - one for each of {read,write} and for
  63  * {current, pending}.
  64  */
  65 struct CipherContext
  66 {
  67
  68         const HashHmacReference         *macRef;                        /* HMAC (TLS) or digest (SSL) */
  69     const SSLSymmetricCipher    *symCipher;
  70
  71         /* this is a context which is reused once per record */
  72     HashHmacContext                             macCtx;
  73
  74     /*
  75      * symKey is obtained from the CSP at cspHand. Normally this
  76      * cspHand is the same as ctx->cspHand; some day they might differ.
  77      * Code which deals with this struct doesn't ever have to
  78      * attach or detach from cspHand - that's taken care of at the
  79      * SSLContext level.
  80      */
  81     CSSM_KEY_PTR                                symKey;
  82     CSSM_CSP_HANDLE                             cspHand;
  83     CSSM_CC_HANDLE                              ccHand;
  84
  85         /* needed in CDSASymmInit */
  86         uint8                                           encrypting;
  87
  88     sslUint64                           sequenceNum;
  89     uint8                               ready;
  90
  91         /* in SSL2 mode, the macSecret is the same size as the
  92          * cipher key - which is 24 bytes in the 3DES case. */
  93         uint8                                           macSecret[MAX_SYMKEY_SIZE];
  94 };
  95 /* typedef in cryptType.h */
  96
  97 #include "sslHandshake.h"
  98
  99 typedef struct WaitingRecord
 100 {   struct WaitingRecord    *next;
 101     SSLBuffer                           data;
 102     uint32                  sent;
 103 } WaitingRecord;
 104
 105 typedef struct DNListElem
 106 {   struct DNListElem   *next;
 107     SSLBuffer               derDN;
 108 } DNListElem;
 109
 110 struct SSLContext
 111 {
 112     IOContext           ioCtx;
 113
 114         /*
 115          * Prior to successful protocol negotiation, negProtocolVersion
 116          * is SSL_Version_Undetermined. Subsequent to successful
 117          * negotiation, negProtocolVersion contains the actual over-the-wire
 118          * protocol value.
 119          *
 120          * The Boolean versionEnable flags are set by
 121          * SSLSetProtocolVersionEnabled or SSLSetProtocolVersion and
 122          * remain invariant once negotiation has started. If there
 123          * were a large number of these and/or we were adding new
 124          * protocol versions on a regular basis, we'd probably want
 125          * to implement these as a word of flags. For now, in the
 126          * real world, this is the most straightfoprward implementation.
 127          */
 128     SSLProtocolVersion  negProtocolVersion;     /* negotiated */
 129     SSLProtocolVersion  clientReqProtocol;      /* requested by client in hello msg */
 130         Boolean                         versionSsl2Enable;
 131         Boolean                         versionSsl3Enable;
 132         Boolean                         versionTls1Enable;
 133     SSLProtocolSide     protocolSide;
 134
 135     const struct _SslTlsCallouts *sslTslCalls; /* selects between SSLv3 and TLSv1 */
 136
 137     /* crypto state in CDSA-centric terms */
 138
 139     SecKeyRef                   signingPrivKeyRef;      /* our private signing key */
 140     CSSM_KEY_PTR                signingPubKey;          /* our public signing key */
 141
 142     SecKeyRef                   encryptPrivKeyRef;      /* our private encrypt key, for
 143                                                                          * server-initiated key exchange */
 144     CSSM_KEY_PTR                encryptPubKey;  /* public version of above */
 145
 146     CSSM_KEY_PTR                peerPubKey;
 147     CSSM_CSP_HANDLE             peerPubKeyCsp;  /* may not be needed, we figure this
 148                                                                          * one out by trial&error, right? */
 149
 150         /*
 151          * Various cert chains.
 152          * For all three, the root is the first in the chain.
 153          */
 154     SSLCertificate      *localCert;
 155     SSLCertificate              *encryptCert;
 156     SSLCertificate      *peerCert;
 157
 158         /* peer certs as SecTrustRef */
 159         SecTrustRef                     peerSecTrust;
 160
 161     /*
 162      * trusted root certs; specific to this implementation, we'll store
 163      * them conveniently...these will be used as AnchorCerts in a TP
 164      * call.
 165      */
 166     uint32                              numTrustedCerts;
 167     CSSM_DATA_PTR               trustedCerts;
 168
 169     /* for symmetric cipher and RNG */
 170     CSSM_CSP_HANDLE             cspHand;
 171
 172     /* session-wide handles for Apple TP, CL */
 173     CSSM_TP_HANDLE              tpHand;
 174     CSSM_CL_HANDLE              clHand;
 175
 176         #if             APPLE_DH
 177         SSLBuffer                       dhParamsPrime;
 178         SSLBuffer                       dhParamsGenerator;
 179         SSLBuffer                       dhParamsEncoded;        /* prime + generator */
 180     SSLBuffer                   dhPeerPublic;
 181     SSLBuffer                   dhExchangePublic;
 182         CSSM_KEY_PTR            dhPrivate;
 183         #endif  /* APPLE_DH */
 184
 185         Boolean                         allowExpiredCerts;
 186         Boolean                         allowExpiredRoots;
 187         Boolean                         enableCertVerify;
 188
 189     SSLBuffer               sessionID;
 190
 191     SSLBuffer                   peerID;
 192     SSLBuffer                   resumableSession;
 193
 194         char                            *peerDomainName;
 195         UInt32                          peerDomainNameLen;
 196
 197     CipherContext       readCipher;
 198     CipherContext       writeCipher;
 199     CipherContext       readPending;
 200     CipherContext       writePending;
 201
 202     uint16              selectedCipher;                 /* currently selected */
 203     const SSLCipherSpec *selectedCipherSpec;    /* ditto */
 204     SSLCipherSpec               *validCipherSpecs;              /* context's valid specs */
 205     unsigned                    numValidCipherSpecs;    /* size of validCipherSpecs */
 206     SSLHandshakeState   state;
 207
 208         /* server-side only */
 209     SSLAuthenticate             clientAuth;                             /* kNeverAuthenticate, etc. */
 210     Boolean                             tryClientAuth;
 211
 212         /* client and server */
 213         SSLClientCertificateState       clientCertState;
 214
 215     DNListElem          *acceptableDNList;
 216
 217     int                 certRequested;
 218     int                 certSent;
 219     int                 certReceived;
 220     int                 x509Requested;
 221
 222     uint8               clientRandom[SSL_CLIENT_SRVR_RAND_SIZE];
 223     uint8               serverRandom[SSL_CLIENT_SRVR_RAND_SIZE];
 224     SSLBuffer                   preMasterSecret;
 225     uint8               masterSecret[SSL_MASTER_SECRET_SIZE];
 226
 227         /* running digests of all handshake messages */
 228     SSLBuffer                   shaState, md5State;
 229
 230     SSLBuffer               fragmentedMessageCache;
 231
 232     unsigned            ssl2ChallengeLength;
 233     unsigned                    ssl2ConnectionIDLength;
 234     unsigned            sessionMatch;
 235
 236         /* Record layer fields */
 237     SSLBuffer                   partialReadBuffer;
 238     uint32              amountRead;
 239
 240         /* Transport layer fields */
 241     WaitingRecord       *recordWriteQueue;
 242     SSLBuffer                   receivedDataBuffer;
 243     uint32              receivedDataPos;
 244
 245     Boolean                             allowAnyRoot;           // don't require known roots
 246         Boolean                         sentFatalAlert;         // this session terminated by fatal alert
 247         Boolean                         rsaBlindingEnable;
 248 };
 249
 250 #ifdef __cplusplus
 251 }
 252 #endif
 253
 254 #endif /* _SSLCONTEXT_H_ */