开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
sslimpl.h
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：44k
源码类别：

CA认证

开发平台：

WINDOWS

sslimpl.h：源码内容
  1. /*
  2.  * This file is PRIVATE to SSL and should be the first thing included by
  3.  * any SSL implementation file.
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public
  6.  * License Version 1.1 (the "License"); you may not use this file
  7.  * except in compliance with the License. You may obtain a copy of
  8.  * the License at http://www.mozilla.org/MPL/
  9.  * 
  10.  * Software distributed under the License is distributed on an "AS
  11.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  12.  * implied. See the License for the specific language governing
  13.  * rights and limitations under the License.
  14.  * 
  15.  * The Original Code is the Netscape security libraries.
  16.  * 
  17.  * The Initial Developer of the Original Code is Netscape
  18.  * Communications Corporation.  Portions created by Netscape are 
  19.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  20.  * Rights Reserved.
  21.  * 
  22.  * Contributor(s):
  23.  * 
  24.  * Alternatively, the contents of this file may be used under the
  25.  * terms of the GNU General Public License Version 2 or later (the
  26.  * "GPL"), in which case the provisions of the GPL are applicable 
  27.  * instead of those above.  If you wish to allow use of your 
  28.  * version of this file only under the terms of the GPL and not to
  29.  * allow others to use your version of this file under the MPL,
  30.  * indicate your decision by deleting the provisions above and
  31.  * replace them with the notice and other provisions required by
  32.  * the GPL.  If you do not delete the provisions above, a recipient
  33.  * may use your version of this file under either the MPL or the
  34.  * GPL.
  35.  *
  36.  * $Id: sslimpl.h,v 1.4 2000/09/12 20:15:43 jgmyers%netscape.com Exp $
  37.  */
  39. #ifndef __sslimpl_h_
  40. #define __sslimpl_h_
  42. #ifdef DEBUG
  43. #undef NDEBUG
  44. #else
  45. #undef NDEBUG
  46. #define NDEBUG
  47. #endif
  48. #include "secport.h"
  49. #include "secerr.h"
  50. #include "sslerr.h"
  51. #include "ssl3prot.h"
  52. #include "hasht.h"
  53. #include "prlock.h"
  54. #include "pkcs11t.h"
  55. #ifdef XP_UNIX
  56. #include "unistd.h"
  57. #endif
  58. #include "nssrwlk.h"
  61. #if defined(DEBUG) || defined(TRACE)
  62. #ifdef __cplusplus
  63. #define Debug 1
  64. #else
  65. extern int Debug;
  66. #endif
  67. #else
  68. #undef Debug
  69. #endif
  70. #if defined(DEBUG)
  71. #define TRACE
  72. #endif
  74. #ifdef TRACE
  75. #define SSL_TRC(a,b) if (ssl_trace >= (a)) ssl_Trace b
  76. #define PRINT_BUF(a,b) if (ssl_trace >= (a)) ssl_PrintBuf b
  77. #define DUMP_MSG(a,b) if (ssl_trace >= (a)) ssl_DumpMsg b
  78. #else
  79. #define SSL_TRC(a,b)
  80. #define PRINT_BUF(a,b)
  81. #define DUMP_MSG(a,b)
  82. #endif
  84. #ifdef DEBUG
  85. #define SSL_DBG(b) if (ssl_debug) ssl_Trace b
  86. #else
  87. #define SSL_DBG(b)
  88. #endif
  90. #if defined (DEBUG)
  91. #ifdef macintosh
  92. #include "pprthred.h"
  93. #else
  94. #include "private/pprthred.h" /* for PR_InMonitor() */
  95. #endif
  96. #define ssl_InMonitor(m) PR_InMonitor(m)
  97. #endif
  99. #define LSB(x) ((unsigned char) (x & 0xff))
  100. #define MSB(x) ((unsigned char) (((unsigned)(x)) >> 8))
  102. /************************************************************************/
  104. typedef enum { SSLAppOpRead = 0,
  105.        SSLAppOpWrite,
  106.        SSLAppOpRDWR,
  107.        SSLAppOpPost,
  108.        SSLAppOpHeader
  109. } SSLAppOperation;
  111. #define SSL_MIN_MASTER_KEY_BYTES 5
  112. #define SSL_MAX_MASTER_KEY_BYTES 64
  114. #define SSL_SESSIONID_BYTES 16
  115. #define SSL3_SESSIONID_BYTES 32
  117. #define SSL_MIN_CHALLENGE_BYTES 16
  118. #define SSL_MAX_CHALLENGE_BYTES 32
  119. #define SSL_CHALLENGE_BYTES 16
  121. #define SSL_CONNECTIONID_BYTES 16
  123. #define SSL_MIN_CYPHER_ARG_BYTES 0
  124. #define SSL_MAX_CYPHER_ARG_BYTES 32
  126. #define SSL_MAX_MAC_BYTES 16
  128. /* number of wrap mechanisms potentially used to wrap master secrets. */
  129. #define SSL_NUM_WRAP_MECHS              13
  131. /* This makes the cert cache entry exactly 4k. */
  132. #define SSL_MAX_CACHED_CERT_LEN 4060
  134. typedef struct sslBufferStr             sslBuffer;
  135. typedef struct sslConnectInfoStr        sslConnectInfo;
  136. typedef struct sslGatherStr             sslGather;
  137. typedef struct sslSecurityInfoStr       sslSecurityInfo;
  138. typedef struct sslSessionIDStr          sslSessionID;
  139. typedef struct sslSocketStr             sslSocket;
  140. typedef struct sslSocketOpsStr          sslSocketOps;
  141. typedef struct sslSocksInfoStr          sslSocksInfo;
  143. typedef struct ssl3StateStr             ssl3State;
  144. typedef struct ssl3CertNodeStr          ssl3CertNode;
  145. typedef struct ssl3BulkCipherDefStr     ssl3BulkCipherDef;
  146. typedef struct ssl3MACDefStr            ssl3MACDef;
  147. typedef struct ssl3KeyPairStr ssl3KeyPair;
  149. struct ssl3CertNodeStr {
  150.     struct ssl3CertNodeStr *next;
  151.     CERTCertificate *       cert;
  152. };
  154. typedef SECStatus (*sslHandshakeFunc)(sslSocket *ss);
  156. /* This type points to the low layer send func, 
  157. ** e.g. ssl2_SendStream or ssl3_SendPlainText.
  158. ** These functions return the same values as PR_Send, 
  159. ** i.e.  >= 0 means number of bytes sent, < 0 means error.
  160. */
  161. typedef PRInt32       (*sslSendFunc)(sslSocket *ss, const unsigned char *buf,
  162.              PRInt32 n, PRInt32 flags);
  164. typedef void          (*sslSessionIDCacheFunc)  (sslSessionID *sid);
  165. typedef void          (*sslSessionIDUncacheFunc)(sslSessionID *sid);
  166. typedef sslSessionID *(*sslSessionIDLookupFunc)(const PRIPv6Addr    *addr,
  167. unsigned char* sid,
  168. unsigned int   sidLen,
  169.                                                 CERTCertDBHandle * dbHandle);
  172. /* Socket ops */
  173. struct sslSocketOpsStr {
  174.     int         (*connect) (sslSocket *, const PRNetAddr *);
  175.     PRFileDesc *(*accept)  (sslSocket *, PRNetAddr *);
  176.     int         (*bind)    (sslSocket *, const PRNetAddr *);
  177.     int         (*listen)  (sslSocket *, int);
  178.     int         (*shutdown)(sslSocket *, int);
  179.     int         (*close)   (sslSocket *);
  181.     int         (*recv)    (sslSocket *, unsigned char *, int, int);
  183.     /* points to the higher-layer send func, e.g. ssl_SecureSend. */
  184.     int         (*send)    (sslSocket *, const unsigned char *, int, int);
  185.     int         (*read)    (sslSocket *, unsigned char *, int);
  186.     int         (*write)   (sslSocket *, const unsigned char *, int);
  188.     int         (*getpeername)(sslSocket *, PRNetAddr *);
  189.     int         (*getsockname)(sslSocket *, PRNetAddr *);
  190. };
  192. /* Flags interpreted by ssl send functions. */
  193. #define ssl_SEND_FLAG_FORCE_INTO_BUFFER 0x40000000
  194. #define ssl_SEND_FLAG_NO_BUFFER 0x20000000
  195. #define ssl_SEND_FLAG_MASK 0x7f000000
  197. /*
  198. ** A buffer object.
  199. */
  200. struct sslBufferStr {
  201.     unsigned char * buf;
  202.     unsigned int  len;
  203.     unsigned int  space;
  204. };
  206. /*
  207. ** SSL3 cipher suite policy and preference struct.
  208. */
  209. typedef struct {
  210. #ifdef AIX
  211.     unsigned int    cipher_suite : 16;
  212.     unsigned int    policy       :  8;
  213.     unsigned int    enabled      :  1;
  214.     unsigned int    isPresent    :  1;
  215. #else
  216.     ssl3CipherSuite cipher_suite;
  217.     PRUint8         policy;
  218.     unsigned char   enabled   : 1;
  219.     unsigned char   isPresent : 1;
  220. #endif
  221. } ssl3CipherSuiteCfg;
  223. #define ssl_V3_SUITES_IMPLEMENTED 13
  225. typedef struct sslOptionsStr {
  226.     unsigned int useSecurity : 1;  /*  1 */
  227.     unsigned int useSocks : 1;  /*  2 */
  228.     unsigned int requestCertificate : 1;  /*  3 */
  229.     unsigned int requireCertificate : 2;  /*  4-5 */
  230.     unsigned int handshakeAsClient : 1;  /*  6 */
  231.     unsigned int handshakeAsServer : 1;  /*  7 */
  232.     unsigned int enableSSL2 : 1;  /*  8 */
  233.     unsigned int enableSSL3 : 1;  /*  9 */
  234.     unsigned int enableTLS : 1;  /* 10 */
  235.     unsigned int noCache : 1;  /* 11 */
  236.     unsigned int fdx : 1;  /* 12 */
  237.     unsigned int v2CompatibleHello : 1;  /* 13 */
  238.     unsigned int detectRollBack   : 1;  /* 14 */
  239. } sslOptions;
  241. /*
  242. ** SSL Socket struct
  243. **
  244. ** Protection:  XXX
  245. */
  246. struct sslSocketStr {
  247.     PRFileDesc * fd;
  249.     /* Pointer to operations vector for this socket */
  250.     sslSocketOps * ops;
  252.     /* State flags */
  253.     unsigned int     useSocks : 1;
  254.     unsigned int     useSecurity : 1;
  255.     unsigned int     requestCertificate : 1;
  256.     unsigned int     requireCertificate : 2;
  258.     unsigned int     handshakeAsClient : 1;
  259.     unsigned int     handshakeAsServer : 1;
  260.     unsigned int     enableSSL2 : 1;
  261.     unsigned int     enableSSL3 : 1;
  262.     unsigned int     enableTLS : 1;
  264.     unsigned int     clientAuthRequested: 1;
  265.     unsigned int     noCache : 1;
  266.     unsigned int     fdx : 1; /* simultaneous read/write threads */
  267.     unsigned int     v2CompatibleHello : 1; /* Send v3+ client hello in v2 format */
  268.     unsigned int     detectRollBack    : 1; /* Detect rollback to SSL v3 */
  269.     unsigned int     connected : 1; /* initial handshake is complete. */
  270.     unsigned int     recvdCloseNotify : 1; /* received SSL EOF. */
  272.     /* version of the protocol to use */
  273.     SSL3ProtocolVersion version;
  274.     SSL3ProtocolVersion clientHelloVersion; /* version sent in client hello. */
  276.     /* Non-zero if socks is enabled */
  277.     sslSocksInfo *   socks;
  279.     /* Non-zero if security is enabled */
  280.     sslSecurityInfo *sec;
  282.     /* protected by firstHandshakeLock AND (in ssl3) ssl3HandshakeLock. */
  283.     const char      *url; /* ssl 2 & 3 */
  285.     /* Gather object used for gathering data */
  286.     sslGather *      gather; /*recvBufLock*/
  288.     sslHandshakeFunc handshake; /*firstHandshakeLock*/
  289.     sslHandshakeFunc nextHandshake; /*firstHandshakeLock*/
  290.     sslHandshakeFunc securityHandshake; /*firstHandshakeLock*/
  292.     sslBuffer        saveBuf; /*xmitBufLock*/
  293.     sslBuffer        pendingBuf; /*xmitBufLock*/
  295.     /* the following 3 variables are only used with socks or other proxies. */
  296.     PRIPv6Addr       peer; /* Target server IP address */
  297.     int              port; /* Target server port number. */
  298.     char *           peerID; /* String uniquely identifies target server. */
  299.     /* End of socks variables. */
  301.     ssl3State *      ssl3;
  302.     unsigned char *  cipherSpecs;
  303.     unsigned int     sizeCipherSpecs;
  304. const unsigned char *  preferredCipher;
  306.     /* Configuration state for server sockets */
  307.     CERTCertificate *     serverCert[kt_kea_size];
  308.     CERTCertificateList * serverCertChain[kt_kea_size];
  309.     SECKEYPrivateKey *    serverKey[kt_kea_size];
  310.     ssl3KeyPair *         stepDownKeyPair; /* RSA step down keys */
  312.     /* Callbacks */
  313.     SSLAuthCertificate        authCertificate;
  314.     void                     *authCertificateArg;
  315.     SSLGetClientAuthData      getClientAuthData;
  316.     void                     *getClientAuthDataArg;
  317.     SSLBadCertHandler         handleBadCert;
  318.     void                     *badCertArg;
  319.     SSLHandshakeCallback      handshakeCallback;
  320.     void                     *handshakeCallbackData;
  321.     void                     *pkcs11PinArg;
  323.     PRIntervalTime            rTimeout; /* timeout for NSPR I/O */
  324.     PRIntervalTime            wTimeout; /* timeout for NSPR I/O */
  325.     PRIntervalTime            cTimeout; /* timeout for NSPR I/O */
  327.     PRLock *      recvLock; /* lock against multiple reader threads. */
  328.     PRLock *      sendLock; /* lock against multiple sender threads. */
  330.     PRMonitor *   recvBufLock; /* locks low level recv buffers. */
  331.     PRMonitor *   xmitBufLock; /* locks low level xmit buffers. */
  333.     /* Only one thread may operate on the socket until the initial handshake
  334.     ** is complete.  This Monitor ensures that.  Since SSL2 handshake is
  335.     ** only done once, this is also effectively the SSL2 handshake lock.
  336.     */
  337.     PRMonitor *   firstHandshakeLock; 
  339.     /* This monitor protects the ssl3 handshake state machine data.
  340.     ** Only one thread (reader or writer) may be in the ssl3 handshake state
  341.     ** machine at any time.  */
  342.     PRMonitor *   ssl3HandshakeLock;
  344.     /* reader/writer lock, protects the secret data needed to encrypt and MAC
  345.     ** outgoing records, and to decrypt and MAC check incoming ciphertext 
  346.     ** records.  */
  347.     NSSRWLock *   specLock;
  349.     /* handle to perm cert db (and implicitly to the temp cert db) used 
  350.     ** with this socket. 
  351.     */
  352.     CERTCertDBHandle * dbHandle;
  354.     PRUint16 shutdownHow;  /* See ssl_SHUTDOWN defines below. */
  356.     PRUint16 allowedByPolicy;          /* copy of global policy bits. */
  357.     PRUint16 maybeAllowedByPolicy;     /* copy of global policy bits. */
  358.     PRUint16 chosenPreference;         /* SSL2 cipher preferences. */
  360.     ssl3CipherSuiteCfg cipherSuites[ssl_V3_SUITES_IMPLEMENTED];
  362. };
  364. #define SSL_LOCK_RANK_SPEC  255
  365. #define SSL_LOCK_RANK_GLOBAL  NSS_RWLOCK_RANK_NONE
  367. /* These are the valid values for shutdownHow. 
  368. ** These values are each 1 greater than the NSPR values, and the code
  369. ** depends on that relation to efficiently convert PR_SHUTDOWN values 
  370. ** into ssl_SHUTDOWN values.  These values use one bit for read, and 
  371. ** another bit for write, and can be used as bitmasks.
  372. */
  373. #define ssl_SHUTDOWN_NONE 0 /* NOT shutdown at all */
  374. #define ssl_SHUTDOWN_RCV 1 /* PR_SHUTDOWN_RCV  +1 */
  375. #define ssl_SHUTDOWN_SEND 2 /* PR_SHUTDOWN_SEND +1 */
  376. #define ssl_SHUTDOWN_BOTH 3 /* PR_SHUTDOWN_BOTH +1 */
  378. /*
  379. ** A gather object. Used to read some data until a count has been
  380. ** satisfied. Primarily for support of async sockets.
  381. ** Everything in here is protected by the recvBufLock.
  382. */
  383. struct sslGatherStr {
  384.     int           state; /* see GS_ values below. */     /* ssl 2 & 3 */
  386.     /* "buf" holds received plaintext SSL records, after decrypt and MAC check.
  387.      * SSL2: recv'd ciphertext records are put here, then decrypted in place.
  388.      * SSL3: recv'd ciphertext records are put in inbuf (see below), then 
  389.      *       decrypted into buf.
  390.      */
  391.     sslBuffer     buf; /*recvBufLock*/ /* ssl 2 & 3 */
  393.     /* number of bytes previously read into hdr or buf(ssl2) or inbuf (ssl3). 
  394.     ** (offset - writeOffset) is the number of ciphertext bytes read in but 
  395.     **     not yet deciphered.
  396.     */
  397.     unsigned int  offset;                                       /* ssl 2 & 3 */
  399.     /* number of bytes to read in next call to ssl_DefRecv (recv) */
  400.     unsigned int  remainder;                                    /* ssl 2 & 3 */
  402.     /* Number of ciphertext bytes to read in after 2-byte SSL record header. */
  403.     unsigned int  count; /* ssl2 only */
  405.     /* size of the final plaintext record. 
  406.     ** == count - (recordPadding + MAC size)
  407.     */
  408.     unsigned int  recordLen; /* ssl2 only */
  410.     /* number of bytes of padding to be removed after decrypting. */
  411.     /* This value is taken from the record's hdr[2], which means a too large
  412.      * value could crash us.
  413.      */
  414.     unsigned int  recordPadding; /* ssl2 only */
  416.     /* plaintext DATA begins this many bytes into "buf".  */
  417.     unsigned int  recordOffset; /* ssl2 only */
  419.     int           encrypted;    /* SSL2 session is now encrypted.  ssl2 only */
  421.     /* These next two values are used by SSL2 and SSL3.  
  422.     ** DoRecv uses them to extract application data.
  423.     ** The difference between writeOffset and readOffset is the amount of 
  424.     ** data available to the application.   Note that the actual offset of 
  425.     ** the data in "buf" is recordOffset (above), not readOffset.
  426.     ** In the current implementation, this is made available before the 
  427.     ** MAC is checked!!
  428.     */
  429.     unsigned int  readOffset;  /* Spot where DATA reader (e.g. application
  430.                                ** or handshake code) will read next.
  431.                                ** Always zero for SSl3 application data.
  432.        */
  433.     /* offset in buf/inbuf/hdr into which new data will be read from socket. */
  434.     unsigned int  writeOffset; 
  436.     /* Buffer for ssl3 to read (encrypted) data from the socket */
  437.     sslBuffer     inbuf; /*recvBufLock*/ /* ssl3 only */
  439.     /* The ssl[23]_GatherData functions read data into this buffer, rather
  440.     ** than into buf or inbuf, while in the GS_HEADER state.  
  441.     ** The portion of the SSL record header put here always comes off the wire 
  442.     ** as plaintext, never ciphertext.
  443.     ** For SSL2, the plaintext portion is two bytes long.  For SSl3 it is 5.
  444.     */
  445.     unsigned char hdr[5]; /* ssl 2 & 3 */
  446. };
  448. /* sslGather.state */
  449. #define GS_INIT 0
  450. #define GS_HEADER 1
  451. #define GS_MAC 2
  452. #define GS_DATA 3
  453. #define GS_PAD 4
  455. typedef SECStatus (*SSLCipher)(void *               context, 
  456.                                unsigned char *      out,
  457.        int *                outlen, 
  458.        int                  maxout, 
  459.        const unsigned char *in,
  460.        int                  inlen);
  461. typedef SECStatus (*SSLDestroy)(void *context, PRBool freeit);
  464. /*
  465.  * SSL2 buffers used in SSL3.
  466.  *     writeBuf in the SecurityInfo maintained by sslsecur.c is used
  467.  *              to hold the data just about to be passed to the kernel
  468.  *     sendBuf in the ConnectInfo maintained by sslcon.c is used
  469.  *              to hold handshake messages as they are accumulated
  470.  */
  472. /*
  473. ** This is "ci", as in "ss->sec.ci".
  474. **
  475. ** Protection:  All the variables in here are protected by 
  476. ** firstHandshakeLock AND (in ssl3) ssl3HandshakeLock 
  477. */
  478. struct sslConnectInfoStr {
  479.     /* outgoing handshakes appended to this. */
  480.     sslBuffer       sendBuf;                 /*xmitBufLock*/ /* ssl 2 & 3 */
  482.     PRIPv6Addr      peer;                                       /* ssl 2 & 3 */
  483.     unsigned short  port;                                       /* ssl 2 & 3 */
  485.     sslSessionID   *sid;                                        /* ssl 2 & 3 */
  487.     /* see CIS_HAVE defines below for the bit values in *elements. */
  488.     char            elements; /* ssl2 only */
  489.     char            requiredElements; /* ssl2 only */
  490.     char            sentElements;                               /* ssl2 only */
  492.     char            sentFinished;                               /* ssl2 only */
  494.     /* Length of server challenge.  Used by client when saving challenge */
  495.     int             serverChallengeLen;                         /* ssl2 only */
  496.     /* type of authentication requested by server */
  497.     unsigned char   authType;                                   /* ssl2 only */
  499.     /* Challenge sent by client to server in client-hello message */
  500.     /* SSL3 gets a copy of this.  See ssl3_StartHandshakeHash().  */
  501.     unsigned char   clientChallenge[SSL_MAX_CHALLENGE_BYTES];   /* ssl 2 & 3 */
  503.     /* Connection-id sent by server to client in server-hello message */
  504.     unsigned char   connectionID[SSL_CONNECTIONID_BYTES]; /* ssl2 only */
  506.     /* Challenge sent by server to client in request-certificate message */
  507.     unsigned char   serverChallenge[SSL_MAX_CHALLENGE_BYTES]; /* ssl2 only */
  509.     /* Information kept to handle a request-certificate message */
  510.     unsigned char   readKey[SSL_MAX_MASTER_KEY_BYTES]; /* ssl2 only */
  511.     unsigned char   writeKey[SSL_MAX_MASTER_KEY_BYTES]; /* ssl2 only */
  512.     unsigned        keySize; /* ssl2 only */
  513. };
  515. /* bit values for ci->elements, ci->requiredElements, sentElements. */
  516. #define CIS_HAVE_MASTER_KEY 0x01
  517. #define CIS_HAVE_CERTIFICATE 0x02
  518. #define CIS_HAVE_FINISHED 0x04
  519. #define CIS_HAVE_VERIFY 0x08
  521. /* Note: The entire content of this struct and whatever it points to gets
  522.  * blown away by SSL_ResetHandshake().  This is "sec" as in "ss->sec".
  523.  *
  524.  * Unless otherwise specified below, the contents of this struct are 
  525.  * protected by firstHandshakeLock AND (in ssl3) ssl3HandshakeLock.
  526.  */
  527. struct sslSecurityInfoStr {
  528.     sslSendFunc      send; /*xmitBufLock*/ /* ssl 2 & 3 */
  529.     int              isServer; /* Spec Lock?*/ /* ssl 2 & 3 */
  530.     sslBuffer        writeBuf; /*xmitBufLock*/ /* ssl 2 & 3 */
  532.     int              cipherType; /* ssl 2 & 3 */
  533.     int              keyBits; /* ssl 2 & 3 */
  534.     int              secretKeyBits; /* ssl 2 & 3 */
  535.     CERTCertificate *peerCert; /* ssl 2 & 3 */
  536.     SECKEYPublicKey *peerKey; /* ssl3 only */
  538.     /*
  539.     ** Procs used for SID cache (nonce) management. 
  540.     ** Different implementations exist for clients/servers 
  541.     ** The lookup proc is only used for servers.  Baloney!
  542.     */
  543.     sslSessionIDCacheFunc     cache; /* ssl 2 & 3 */
  544.     sslSessionIDUncacheFunc   uncache; /* ssl 2 & 3 */
  546.     /*
  547.     ** everything below here is for ssl2 only.
  548.     ** This stuff is equivalent to SSL3's "spec", and is protected by the 
  549.     ** same "Spec Lock" as used for SSL3's specs.
  550.     */
  551.     uint32           sendSequence; /*xmitBufLock*/ /* ssl2 only */
  552.     uint32           rcvSequence; /*recvBufLock*/ /* ssl2 only */
  554.     /* Hash information; used for one-way-hash functions (MD2, MD5, etc.) */
  555.     SECHashObject   *hash; /* Spec Lock */ /* ssl2 only */
  556.     void            *hashcx; /* Spec Lock */ /* ssl2 only */
  558.     SECItem          sendSecret; /* Spec Lock */ /* ssl2 only */
  559.     SECItem          rcvSecret; /* Spec Lock */ /* ssl2 only */
  561.     /* Session cypher contexts; one for each direction */
  562.     void            *readcx; /* Spec Lock */ /* ssl2 only */
  563.     void            *writecx; /* Spec Lock */ /* ssl2 only */
  564.     SSLCipher        enc; /* Spec Lock */ /* ssl2 only */
  565.     SSLCipher        dec; /* Spec Lock */ /* ssl2 only */
  566.     void           (*destroy)(void *, PRBool); /* Spec Lock */ /* ssl2 only */
  568.     /* Blocking information for the session cypher */
  569.     int              blockShift; /* Spec Lock */ /* ssl2 only */
  570.     int              blockSize; /* Spec Lock */ /* ssl2 only */
  572.     /* These are used during a connection handshake */
  573.     sslConnectInfo   ci; /* ssl 2 & 3 */
  575. };
  577. /*
  578. ** ssl3State and CipherSpec structs
  579. */
  581. /* The SSL bulk cipher definition */
  582. typedef enum {
  583.     cipher_null,
  584.     cipher_rc4, 
  585.     cipher_rc4_40,
  586.     cipher_rc4_56,
  587.     cipher_rc2, 
  588.     cipher_rc2_40,
  589.     cipher_des, 
  590.     cipher_3des, 
  591.     cipher_des40,
  592.     cipher_idea, 
  593.     cipher_fortezza,
  594.     cipher_missing              /* reserved for no such supported cipher */
  595. } SSL3BulkCipher;
  597. /* The specific cipher algorithm */
  599. typedef enum {
  600.     calg_null     = (int)0x80000000L, 
  601.     calg_rc4      = CKM_RC4, 
  602.     calg_rc2      = CKM_RC2_CBC,
  603.     calg_des      = CKM_DES_CBC, 
  604.     calg_3des     = CKM_DES3_CBC, 
  605.     calg_idea     = CKM_IDEA_CBC,
  606.     calg_fortezza = CKM_SKIPJACK_CBC64, 
  607.     calg_init     = (int) 0x7fffffffL
  608. } CipherAlgorithm;
  610. /* hmac added to help TLS conversion by rjr... */
  611. typedef enum {
  612.     malg_null     = (int)0x80000000L, 
  613.     malg_md5      = CKM_SSL3_MD5_MAC, 
  614.     malg_sha      = CKM_SSL3_SHA1_MAC, 
  615.     malg_md5_hmac = CKM_MD5_HMAC,
  616.     malg_sha_hmac = CKM_SHA_1_HMAC
  617. } MACAlgorithm;
  620. /* Key Exchange values moved to ssl.h */
  621. typedef SSLKEAType SSL3KEAType;
  623. typedef enum { 
  624. mac_null, 
  625. mac_md5, 
  626. mac_sha, 
  627. hmac_md5,  /* TLS HMAC version of mac_md5 */
  628. hmac_sha  /* TLS HMAC version of mac_sha */
  629. } SSL3MACAlgorithm;
  631. typedef enum { type_stream, type_block } CipherType;
  633. #define MAX_IV_LENGTH 64
  635. /*
  636.  * Do not depend upon 64 bit arithmetic in the underlying machine. 
  637.  */
  638. typedef struct {
  639.     uint32         high;
  640.     uint32         low;
  641. } SSL3SequenceNumber;
  643. typedef struct {
  644.     SSL3Opaque write_iv[MAX_IV_LENGTH];
  645.     PK11SymKey *write_key;
  646.     PK11SymKey *write_mac_key;
  647.     PK11Context *write_mac_context;
  648. } ssl3KeyMaterial;
  650. typedef struct {
  651.     SSL3Opaque        wrapped_client_write_key[12]; /* wrapped with Ks */
  652.     SSL3Opaque        wrapped_server_write_key[12]; /* wrapped with Ks */
  653.     SSL3Opaque        client_write_iv         [24];
  654.     SSL3Opaque        server_write_iv         [24];
  655.     SSL3Opaque        wrapped_master_secret   [48];
  656.     PRUint16          wrapped_master_secret_len;
  657. } ssl3SidKeys;
  659. /*
  660. ** These are the "specs" in the "ssl3" struct.
  661. ** Access to the pointers to these specs, and all the specs' contents
  662. ** (direct and indirect) is protected by the reader/writer lock ss->specLock.
  663. */
  664. typedef struct {
  665.     const ssl3BulkCipherDef *cipher_def;
  666.     const ssl3MACDef * mac_def;
  667.     int                mac_size;
  668.     SSLCipher          encode;
  669.     void *             encodeContext;
  670.     SSLCipher          decode;
  671.     void *             decodeContext;
  672.     SSLDestroy         destroy;
  673.     PK11SymKey *       master_secret;
  674.     ssl3KeyMaterial    client;
  675.     ssl3KeyMaterial    server;
  676.     SSL3SequenceNumber write_seq_num;
  677.     SSL3SequenceNumber read_seq_num;
  678.     SSL3ProtocolVersion version;
  679. } ssl3CipherSpec;
  681. typedef enum { never_cached, 
  682. in_client_cache, 
  683. in_server_cache, 
  684. invalid_cache /* no longer in any cache. */
  685. } Cached;
  687. struct sslSessionIDStr {
  688.     sslSessionID *        next;   /* chain used for client sockets, only */
  690.     CERTCertificate *     peerCert;
  691.     const char *          peerID;     /* client only */
  692.     const char *          urlSvrName; /* client only */
  694.     PRIPv6Addr            addr;
  695.     PRUint16              port;
  697.     SSL3ProtocolVersion   version;
  699.     PRUint32              time;
  700.     Cached                cached;
  701.     int                   references;
  703.     union {
  704. struct {
  705.     /* the V2 code depends upon the size of sessionID.  */
  706.     unsigned char         sessionID[SSL_SESSIONID_BYTES];
  708.     /* Stuff used to recreate key and read/write cipher objects */
  709.     SECItem               masterKey;
  710.     int                   cipherType;
  711.     SECItem               cipherArg;
  712.     int                   keyBits;
  713.     int                   secretKeyBits;
  714. } ssl2;
  715. struct {
  716.     /* values that are copied into the server's on-disk SID cache. */
  717.     uint8                 sessionIDLength;
  718.     SSL3Opaque            sessionID[SSL3_SESSIONID_BYTES];
  720.     ssl3CipherSuite       cipherSuite;
  721.     SSL3CompressionMethod compression;
  722.     PRBool                resumable;
  723.     int                   policy;
  724.     PRBool                hasFortezza;
  725.     ssl3SidKeys           keys;
  726.     CK_MECHANISM_TYPE     masterWrapMech;
  727.   /* mechanism used to wrap master secret */
  728.             SSL3KEAType           exchKeyType;
  729.   /* key type used in exchange algorithm,
  730.    * and to wrap the sym wrapping key. */
  732.     /* The following values are NOT restored from the server's on-disk
  733.      * session cache, but are restored from the client's cache.
  734.      */
  735.       PK11SymKey *      clientWriteKey;
  736.     PK11SymKey *      serverWriteKey;
  737.     PK11SymKey *      tek;
  739.     /* The following values pertain to the slot that wrapped the 
  740.     ** master secret. (used only in client)
  741.     */
  742.     SECMODModuleID    masterModuleID;
  743.     /* what module wrapped the master secret */
  744.     CK_SLOT_ID        masterSlotID;
  745.     PRUint16       masterWrapIndex;
  746. /* what's the key index for the wrapping key */
  747.     PRUint16          masterWrapSeries;
  748.                         /* keep track of the slot series, so we don't 
  749.  * accidently try to use new keys after the 
  750.  * card gets removed and replaced.*/
  752.     /* The following values pertain to the slot that did the signature
  753.     ** for client auth.   (used only in client)
  754.     */
  755.     SECMODModuleID    clAuthModuleID;
  756.     CK_SLOT_ID        clAuthSlotID;
  757.     PRUint16          clAuthSeries;
  759.             char              masterValid;
  760.     char              clAuthValid;
  762.     /* the following values are used only in the client, and only 
  763.      * with fortezza.
  764.      */
  765.     SSL3Opaque       clientWriteSave[80]; 
  766.     int              clientWriteSaveLen;  
  767. } ssl3;
  768.     } u;
  769. };
  772. typedef struct ssl3CipherSuiteDefStr {
  773.     ssl3CipherSuite          cipher_suite;
  774.     SSL3BulkCipher           bulk_cipher_alg;
  775.     SSL3MACAlgorithm         mac_alg;
  776.     SSL3KeyExchangeAlgorithm key_exchange_alg;
  777. } ssl3CipherSuiteDef;
  779. /*
  780. ** There are tables of these, all const.
  781. */
  782. typedef struct {
  783.     SSL3KeyExchangeAlgorithm kea;
  784.     SSL3KEAType              exchKeyType;
  785.     SSL3SignType             signKeyType;
  786.     PRBool                   is_limited;
  787.     int                      key_size_limit;
  788.     PRBool                   tls_keygen;
  789. } ssl3KEADef;
  791. typedef enum { kg_null, kg_strong, kg_export } SSL3KeyGenMode;
  793. /*
  794. ** There are tables of these, all const.
  795. */
  796. struct ssl3BulkCipherDefStr {
  797.     SSL3BulkCipher  cipher;
  798.     CipherAlgorithm calg;
  799.     int             key_size;
  800.     int             secret_key_size;
  801.     CipherType      type;
  802.     int             iv_size;
  803.     int             block_size;
  804.     SSL3KeyGenMode  keygen_mode;
  805. };
  807. /*
  808. ** There are tables of these, all const.
  809. */
  810. struct ssl3MACDefStr {
  811.     SSL3MACAlgorithm mac;
  812.     MACAlgorithm     malg;
  813.     int              pad_size;
  814.     int              mac_size;
  815. };
  817. typedef enum {
  818.     wait_client_hello, 
  819.     wait_client_cert, 
  820.     wait_client_key,
  821.     wait_cert_verify, 
  822.     wait_change_cipher, 
  823.     wait_finished,
  824.     wait_server_hello, 
  825.     wait_server_cert, 
  826.     wait_server_key,
  827.     wait_cert_request, 
  828.     wait_hello_done,
  829.     idle_handshake
  830. } SSL3WaitState;
  832. /*
  833. ** This is the "hs" member of the "ssl3" struct.
  834. ** This entire struct is protected by ssl3HandshakeLock
  835. */
  836. typedef struct SSL3HandshakeStateStr {
  837.     SSL3Random            server_random;
  838.     SSL3Random            client_random;
  839.     SSL3WaitState         ws;
  840.     PK11Context *         md5;            /* handshake running hashes */
  841.     PK11Context *         sha;
  842. const ssl3KEADef *        kea_def;
  843.     ssl3CipherSuite       cipher_suite;
  844. const ssl3CipherSuiteDef *suite_def;
  845.     SSL3CompressionMethod compression;
  846.     sslBuffer             msg_body;    /* protected by recvBufLock */
  847.                                /* partial handshake message from record layer */
  848.     unsigned int          header_bytes; 
  849.                                /* number of bytes consumed from handshake */
  850.                                /* message for message type and header length */
  851.     SSL3HandshakeType     msg_type;
  852.     unsigned long         msg_len;
  853.     SECItem               ca_list;     /* used only by client */
  854.     PRBool                isResuming;  /* are we resuming a session */
  855.     PRBool                rehandshake; /* immediately start another handshake 
  856.                                         * when this one finishes */
  857.     PRBool                usedStepDownKey;  /* we did a server key exchange. */
  858.     sslBuffer             msgState;    /* current state for handshake messages*/
  859.                                        /* protected by recvBufLock */
  860. } SSL3HandshakeState;
  862. struct SSL3FortezzaKEAParamsStr {
  863.     unsigned char R_s[128]; /* server's "random" public key */
  864.     PK11SymKey *  tek;
  865. };
  867. typedef struct SSL3FortezzaKEAParamsStr SSL3FortezzaKEAParams;
  869. /*
  870. ** This is the "ssl3" struct, as in "ss->ssl3".
  871. ** note:
  872. ** usually,   crSpec == cwSpec and prSpec == pwSpec.  
  873. ** Sometimes, crSpec == pwSpec and prSpec == cwSpec.
  874. ** But there are never more than 2 actual specs.  
  875. ** No spec must ever be modified if either "current" pointer points to it.
  876. */
  877. struct ssl3StateStr {
  879.     /*
  880.     ** The following Specs and Spec pointers must be protected using the 
  881.     ** Spec Lock.
  882.     */
  883.     ssl3CipherSpec *     crSpec;  /* current read spec. */
  884.     ssl3CipherSpec *     prSpec;  /* pending read spec. */
  885.     ssl3CipherSpec *     cwSpec;  /* current write spec. */
  886.     ssl3CipherSpec *     pwSpec;  /* pending write spec. */
  887.     ssl3CipherSpec       specs[2]; /* one is current, one is pending. */
  889.     SSL3HandshakeState   hs;
  891.     CERTCertificate *    clientCertificate;  /* used by client */
  892.     SECKEYPrivateKey *   clientPrivateKey;   /* used by client */
  893.     CERTCertificateList *clientCertChain;    /* used by client */
  894.     PRBool               sendEmptyCert;      /* used by client */
  896.     int                  policy;
  897. /* This says what cipher suites we can do, and should 
  898.  * be either SSL_ALLOWED or SSL_RESTRICTED 
  899.  */
  900.     PRArenaPool *        peerCertArena;  
  901.     /* These are used to keep track of the peer CA */
  902.     void *               peerCertChain;     
  903.     /* chain while we are trying to validate it.   */
  904.     CERTDistNames *      ca_list; 
  905.     /* used by server.  trusted CAs for this socket. */
  906.     SSL3FortezzaKEAParams fortezza;
  907. };
  909. typedef struct {
  910.     SSL3ContentType      type;
  911.     SSL3ProtocolVersion  version;
  912.     sslBuffer *          buf;
  913. } SSL3Ciphertext;
  915. struct ssl3KeyPairStr {
  916.     SECKEYPrivateKey *    privKey; /* RSA step down key */
  917.     SECKEYPublicKey *     pubKey; /* RSA step down key */
  918.     PRInt32               refCount; /* use PR_Atomic calls for this. */
  919. };
  921. typedef struct SSLWrappedSymWrappingKeyStr {
  922.     SSL3Opaque        wrappedSymmetricWrappingkey[512];
  923.     SSL3Opaque        wrapIV[24];
  924.     CK_MECHANISM_TYPE symWrapMechanism;  
  925.     /* unwrapped symmetric wrapping key uses this mechanism */
  926.     CK_MECHANISM_TYPE asymWrapMechanism; 
  927.     /* mechanism used to wrap the SymmetricWrappingKey using
  928.      * server's public and/or private keys. */
  929.     SSL3KEAType       exchKeyType;   /* type of keys used to wrap SymWrapKey*/
  930.     PRInt32           symWrapMechIndex;
  931.     PRUint16          wrappedSymKeyLen;
  932.     PRUint16          wrapIVLen;
  933. } SSLWrappedSymWrappingKey;
  935. /* All the global data items declared here should be protected using the 
  936. ** ssl_global_data_lock, which is a reader/writer lock.
  937. */
  938. extern NSSRWLock *             ssl_global_data_lock;
  939. extern char                    ssl_debug;
  940. extern char                    ssl_trace;
  941. extern CERTDistNames *         ssl3_server_ca_list;
  942. extern PRUint32                ssl_sid_timeout;
  943. extern PRUint32                ssl3_sid_timeout;
  944. extern PRBool                  ssl3_global_policy_some_restricted;
  946. extern const char * const      ssl_cipherName[];
  947. extern const char * const      ssl3_cipherName[];
  949. extern sslSessionIDLookupFunc  ssl_sid_lookup;
  950. extern sslSessionIDCacheFunc   ssl_sid_cache;
  951. extern sslSessionIDUncacheFunc ssl_sid_uncache;
  953. /************************************************************************/
  955. SEC_BEGIN_PROTOS
  957. /* Implementation of ops for default (non socks, non secure) case */
  958. extern int ssl_DefConnect(sslSocket *ss, const PRNetAddr *addr);
  959. extern PRFileDesc *ssl_DefAccept(sslSocket *ss, PRNetAddr *addr);
  960. extern int ssl_DefBind(sslSocket *ss, const PRNetAddr *addr);
  961. extern int ssl_DefListen(sslSocket *ss, int backlog);
  962. extern int ssl_DefShutdown(sslSocket *ss, int how);
  963. extern int ssl_DefClose(sslSocket *ss);
  964. extern int ssl_DefRecv(sslSocket *ss, unsigned char *buf, int len, int flags);
  965. extern int ssl_DefSend(sslSocket *ss, const unsigned char *buf,
  966.        int len, int flags);
  967. extern int ssl_DefRead(sslSocket *ss, unsigned char *buf, int len);
  968. extern int ssl_DefWrite(sslSocket *ss, const unsigned char *buf, int len);
  969. extern int ssl_DefGetpeername(sslSocket *ss, PRNetAddr *name);
  970. extern int ssl_DefGetsockname(sslSocket *ss, PRNetAddr *name);
  971. extern int ssl_DefGetsockopt(sslSocket *ss, PRSockOption optname,
  972.      void *optval, PRInt32 *optlen);
  973. extern int ssl_DefSetsockopt(sslSocket *ss, PRSockOption optname,
  974.      const void *optval, PRInt32 optlen);
  976. /* Implementation of ops for socks only case */
  977. extern int ssl_SocksConnect(sslSocket *ss, const PRNetAddr *addr);
  978. extern PRFileDesc *ssl_SocksAccept(sslSocket *ss, PRNetAddr *addr);
  979. extern int ssl_SocksBind(sslSocket *ss, const PRNetAddr *addr);
  980. extern int ssl_SocksListen(sslSocket *ss, int backlog);
  981. extern int ssl_SocksGetsockname(sslSocket *ss, PRNetAddr *name);
  982. extern int ssl_SocksRecv(sslSocket *ss, unsigned char *buf, int len, int flags);
  983. extern int ssl_SocksSend(sslSocket *ss, const unsigned char *buf,
  984.  int len, int flags);
  985. extern int ssl_SocksRead(sslSocket *ss, unsigned char *buf, int len);
  986. extern int ssl_SocksWrite(sslSocket *ss, const unsigned char *buf, int len);
  988. /* Implementation of ops for secure only case */
  989. extern int ssl_SecureConnect(sslSocket *ss, const PRNetAddr *addr);
  990. extern PRFileDesc *ssl_SecureAccept(sslSocket *ss, PRNetAddr *addr);
  991. extern int ssl_SecureRecv(sslSocket *ss, unsigned char *buf,
  992.   int len, int flags);
  993. extern int ssl_SecureSend(sslSocket *ss, const unsigned char *buf,
  994.   int len, int flags);
  995. extern int ssl_SecureRead(sslSocket *ss, unsigned char *buf, int len);
  996. extern int ssl_SecureWrite(sslSocket *ss, const unsigned char *buf, int len);
  997. extern int ssl_SecureShutdown(sslSocket *ss, int how);
  998. extern int ssl_SecureClose(sslSocket *ss);
  1000. /* Implementation of ops for secure socks case */
  1001. extern int ssl_SecureSocksConnect(sslSocket *ss, const PRNetAddr *addr);
  1002. extern PRFileDesc *ssl_SecureSocksAccept(sslSocket *ss, PRNetAddr *addr);
  1003. extern PRFileDesc *ssl_FindTop(sslSocket *ss);
  1005. /* Gather funcs. */
  1006. extern sslGather * ssl_NewGather(void);
  1007. extern void        ssl_DestroyGather(sslGather *gs);
  1008. extern int         ssl2_GatherData(sslSocket *ss, sslGather *gs, int flags);
  1009. extern int         ssl2_GatherRecord(sslSocket *ss, int flags);
  1010. extern SECStatus   ssl_GatherRecord1stHandshake(sslSocket *ss);
  1012. extern SECStatus   ssl2_HandleClientHelloMessage(sslSocket *ss);
  1013. extern SECStatus   ssl2_HandleServerHelloMessage(sslSocket *ss);
  1014. extern int         ssl2_StartGatherBytes(sslSocket *ss, sslGather *gs, 
  1015.                                          unsigned int count);
  1017. extern SECStatus   ssl_CreateSecurityInfo(sslSocket *ss);
  1018. extern SECStatus   ssl_CopySecurityInfo(sslSocket *ss, sslSocket *os);
  1019. extern void        ssl_DestroySecurityInfo(sslSecurityInfo *sec);
  1021. extern SECStatus   ssl_CreateSocksInfo(sslSocket *ss);
  1022. extern SECStatus   ssl_CopySocksInfo(sslSocket *ss, sslSocket *os);
  1023. extern void        ssl_DestroySocksInfo(sslSocksInfo *si);
  1025. extern sslSocket * ssl_DupSocket(sslSocket *old);
  1027. extern void        ssl_PrintBuf(sslSocket *ss, const char *msg, const void *cp, int len);
  1028. extern void        ssl_DumpMsg(sslSocket *ss, unsigned char *bp, unsigned len);
  1030. extern int         ssl_SendSavedWriteData(sslSocket *ss, sslBuffer *buf,
  1031.           sslSendFunc fp);
  1032. extern SECStatus ssl_SaveWriteData(sslSocket *ss, sslBuffer *buf, 
  1033.                                    const void* p, unsigned int l);
  1034. extern SECStatus ssl2_BeginClientHandshake(sslSocket *ss);
  1035. extern SECStatus ssl2_BeginServerHandshake(sslSocket *ss);
  1036. extern int       ssl_Do1stHandshake(sslSocket *ss);
  1038. extern SECStatus sslBuffer_Grow(sslBuffer *b, unsigned int newLen);
  1040. extern void      ssl2_UseClearSendFunc(sslSocket *ss);
  1041. extern void      ssl_ChooseSessionIDProcs(sslSecurityInfo *sec);
  1043. extern sslSessionID *ssl_LookupSID(const PRIPv6Addr *addr, PRUint16 port, 
  1044.                                    const char *peerID, const char *urlSvrName);
  1045. extern void      ssl_FreeSID(sslSessionID *sid);
  1047. extern int       ssl3_SendApplicationData(sslSocket *ss, const PRUint8 *in,
  1048.           int len, int flags);
  1050. extern PRBool    ssl_FdIsBlocking(PRFileDesc *fd);
  1052. extern PRBool    ssl_SocketIsBlocking(sslSocket *ss);
  1054. extern void      ssl_SetAlwaysBlock(sslSocket *ss);
  1056. #define SSL_LOCK_READER(ss) if (ss->recvLock) PR_Lock(ss->recvLock)
  1057. #define SSL_UNLOCK_READER(ss) if (ss->recvLock) PR_Unlock(ss->recvLock)
  1058. #define SSL_LOCK_WRITER(ss) if (ss->sendLock) PR_Lock(ss->sendLock)
  1059. #define SSL_UNLOCK_WRITER(ss) if (ss->sendLock) PR_Unlock(ss->sendLock)
  1061. #define ssl_Get1stHandshakeLock(ss)    PR_EnterMonitor((ss)->firstHandshakeLock)
  1062. #define ssl_Release1stHandshakeLock(ss) PR_ExitMonitor((ss)->firstHandshakeLock)
  1063. #define ssl_Have1stHandshakeLock(ss) PR_InMonitor(  (ss)->firstHandshakeLock)
  1065. #define ssl_GetSSL3HandshakeLock(ss) PR_EnterMonitor((ss)->ssl3HandshakeLock)
  1066. #define ssl_ReleaseSSL3HandshakeLock(ss) PR_ExitMonitor((ss)->ssl3HandshakeLock)
  1067. #define ssl_HaveSSL3HandshakeLock(ss) PR_InMonitor(   (ss)->ssl3HandshakeLock)
  1069. #define ssl_GetSpecReadLock(ss) NSSRWLock_LockRead(     (ss)->specLock)
  1070. #define ssl_ReleaseSpecReadLock(ss) NSSRWLock_UnlockRead(   (ss)->specLock)
  1072. #define ssl_GetSpecWriteLock(ss) NSSRWLock_LockWrite(  (ss)->specLock)
  1073. #define ssl_ReleaseSpecWriteLock(ss) NSSRWLock_UnlockWrite((ss)->specLock)
  1074. #define ssl_HaveSpecWriteLock(ss) NSSRWLock_HaveWriteLock((ss)->specLock)
  1076. #define ssl_GetRecvBufLock(ss) PR_EnterMonitor((ss)->recvBufLock)
  1077. #define ssl_ReleaseRecvBufLock(ss) PR_ExitMonitor( (ss)->recvBufLock)
  1078. #define ssl_HaveRecvBufLock(ss) PR_InMonitor(   (ss)->recvBufLock)
  1080. #define ssl_GetXmitBufLock(ss) PR_EnterMonitor((ss)->xmitBufLock)
  1081. #define ssl_ReleaseXmitBufLock(ss) PR_ExitMonitor( (ss)->xmitBufLock)
  1082. #define ssl_HaveXmitBufLock(ss) PR_InMonitor(   (ss)->xmitBufLock)
  1085. /* These functions are called from secnav, even though they're "private". */
  1087. extern int ssl2_SendErrorMessage(struct sslSocketStr *ss, int error);
  1088. extern int SSL_RestartHandshakeAfterServerCert(struct sslSocketStr *ss);
  1089. extern int SSL_RestartHandshakeAfterCertReq(struct sslSocketStr *ss,
  1090.     CERTCertificate *cert,
  1091.     SECKEYPrivateKey *key,
  1092.     CERTCertificateList *certChain);
  1093. extern sslSocket *ssl_FindSocket(PRFileDesc *fd);
  1094. extern void ssl_FreeSocket(struct sslSocketStr *ssl);
  1095. extern SECStatus SSL3_SendAlert(sslSocket *ss, SSL3AlertLevel level,
  1096. SSL3AlertDescription desc);
  1098. extern int ssl2_RestartHandshakeAfterCertReq(sslSocket *          ss,
  1099.      CERTCertificate *    cert, 
  1100.      SECKEYPrivateKey *   key);
  1102. extern SECStatus ssl3_RestartHandshakeAfterCertReq(sslSocket *    ss,
  1103.      CERTCertificate *    cert, 
  1104.      SECKEYPrivateKey *   key,
  1105.      CERTCertificateList *certChain);
  1107. extern int ssl2_RestartHandshakeAfterServerCert(sslSocket *ss);
  1108. extern int ssl3_RestartHandshakeAfterServerCert(sslSocket *ss);
  1110. /*
  1111.  * for dealing with SSL 3.0 clients sending SSL 2.0 format hellos
  1112.  */
  1113. extern SECStatus ssl3_HandleV2ClientHello(
  1114.     sslSocket *ss, unsigned char *buffer, int length);
  1115. extern SECStatus ssl3_StartHandshakeHash(
  1116.     sslSocket *ss, unsigned char *buf, int length);
  1118. /*
  1119.  * SSL3 specific routines
  1120.  */
  1121. SECStatus ssl3_SendClientHello(sslSocket *ss);
  1123. /*
  1124.  * input into the SSL3 machinery from the actualy network reading code
  1125.  */
  1126. SECStatus ssl3_HandleRecord(
  1127.     sslSocket *ss, SSL3Ciphertext *cipher, sslBuffer *out);
  1129. int ssl3_GatherAppDataRecord(sslSocket *ss, int flags);
  1130. int ssl3_GatherCompleteHandshake(sslSocket *ss, int flags);
  1131. /*
  1132.  * When talking to export clients or using export cipher suites, servers 
  1133.  * with public RSA keys larger than 512 bits need to use a 512-bit public
  1134.  * key, signed by the larger key.  The smaller key is a "step down" key.
  1135.  * Generate that key pair and keep it around.
  1136.  */
  1137. extern SECStatus ssl3_CreateRSAStepDownKeys(sslSocket *ss);
  1139. extern SECStatus ssl3_CipherPrefSetDefault(ssl3CipherSuite which, PRBool on);
  1140. extern SECStatus ssl3_CipherPrefGetDefault(ssl3CipherSuite which, PRBool *on);
  1141. extern SECStatus ssl2_CipherPrefSetDefault(PRInt32 which, PRBool enabled);
  1142. extern SECStatus ssl2_CipherPrefGetDefault(PRInt32 which, PRBool *enabled);
  1144. extern SECStatus ssl3_CipherPrefSet(sslSocket *ss, ssl3CipherSuite which, PRBool on);
  1145. extern SECStatus ssl3_CipherPrefGet(sslSocket *ss, ssl3CipherSuite which, PRBool *on);
  1146. extern SECStatus ssl2_CipherPrefSet(sslSocket *ss, PRInt32 which, PRBool enabled);
  1147. extern SECStatus ssl2_CipherPrefGet(sslSocket *ss, PRInt32 which, PRBool *enabled);
  1149. extern SECStatus ssl3_SetPolicy(ssl3CipherSuite which, PRInt32 policy);
  1150. extern SECStatus ssl3_GetPolicy(ssl3CipherSuite which, PRInt32 *policy);
  1151. extern SECStatus ssl2_SetPolicy(PRInt32 which, PRInt32 policy);
  1152. extern SECStatus ssl2_GetPolicy(PRInt32 which, PRInt32 *policy);
  1154. extern void      ssl2_InitSocketPolicy(sslSocket *ss);
  1155. extern void      ssl3_InitSocketPolicy(sslSocket *ss);
  1157. extern SECStatus ssl3_ConstructV2CipherSpecsHack(sslSocket *ss,
  1158.  unsigned char *cs, int *size);
  1160. extern SECStatus ssl3_RedoHandshake(sslSocket *ss, PRBool flushCache);
  1162. extern void ssl3_DestroySSL3Info(ssl3State *ssl3);
  1164. extern SECStatus ssl3_NegotiateVersion(sslSocket *ss, 
  1165.                                        SSL3ProtocolVersion peerVersion);
  1167. extern SECStatus ssl_GetPeerInfo(sslSocket *ss);
  1169. /* Construct a new NSPR socket for the app to use */
  1170. extern PRFileDesc *ssl_NewPRSocket(sslSocket *ss, PRFileDesc *fd);
  1171. extern void ssl_FreePRSocket(PRFileDesc *fd);
  1173. /* Internal config function so SSL2 can initialize the present state of 
  1174.  * various ciphers */
  1175. extern int ssl3_config_match_init(sslSocket *);
  1178. /* Create a new ref counted key pair object from two keys. */
  1179. extern ssl3KeyPair * ssl3_NewKeyPair( SECKEYPrivateKey * privKey, 
  1180.                                       SECKEYPublicKey * pubKey);
  1182. /* get a new reference (bump ref count) to an ssl3KeyPair. */
  1183. extern ssl3KeyPair * ssl3_GetKeyPairRef(ssl3KeyPair * keyPair);
  1185. /* Decrement keypair's ref count and free if zero. */
  1186. extern void ssl3_FreeKeyPair(ssl3KeyPair * keyPair);
  1188. /* calls for accessing wrapping keys across processes. */
  1189. extern PRBool
  1190. ssl_GetWrappingKey( PRInt32                   symWrapMechIndex,
  1191.                     SSL3KEAType               exchKeyType, 
  1192.     SSLWrappedSymWrappingKey *wswk);
  1194. /* The caller passes in the new value it wants
  1195.  * to set.  This code tests the wrapped sym key entry in the file on disk.  
  1196.  * If it is uninitialized, this function writes the caller's value into 
  1197.  * the disk entry, and returns false.  
  1198.  * Otherwise, it overwrites the caller's wswk with the value obtained from 
  1199.  * the disk, and returns PR_TRUE.  
  1200.  * This is all done while holding the locks/semaphores necessary to make 
  1201.  * the operation atomic.
  1202.  */
  1203. extern PRBool
  1204. ssl_SetWrappingKey(SSLWrappedSymWrappingKey *wswk);
  1206. /********************** misc calls *********************/
  1208. extern int ssl_MapLowLevelError(int hiLevelError);
  1210. extern PRUint32 ssl_Time(void);
  1212. /* emulation of NSPR routines. */
  1213. extern PRInt32 
  1214. ssl_EmulateAcceptRead( PRFileDesc *   sd, 
  1215. PRFileDesc **  nd,
  1216. PRNetAddr **   raddr, 
  1217. void *         buf, 
  1218. PRInt32        amount, 
  1219. PRIntervalTime timeout);
  1220. extern PRInt32 
  1221. ssl_EmulateTransmitFile(    PRFileDesc *        sd, 
  1222.     PRFileDesc *        fd,
  1223.     const void *        headers, 
  1224.     PRInt32             hlen, 
  1225.     PRTransmitFileFlags flags,
  1226.     PRIntervalTime      timeout);
  1227. extern PRInt32 
  1228. ssl_EmulateSendFile( PRFileDesc *        sd, 
  1229.      PRSendFileData *    sfd,
  1230.                      PRTransmitFileFlags flags, 
  1231.      PRIntervalTime      timeout);
  1233. #ifdef TRACE
  1234. #define SSL_TRACE(msg) ssl_Trace msg
  1235. #else
  1236. #define SSL_TRACE(msg)
  1237. #endif
  1239. void ssl_Trace(const char *format, ...);
  1241. SEC_END_PROTOS
  1244. #ifdef XP_UNIX
  1245. #define SSL_GETPID() getpid()
  1246. #else
  1247. #define SSL_GETPID() 0
  1248. #endif
  1250. #endif /* __sslimpl_h_ */