diff -r 000000000000 -r af10295192d8 networksecurity/tls/protocol/tlsconnection.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networksecurity/tls/protocol/tlsconnection.h Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,291 @@ +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// SSL3.0 and TLS1.0 Connection header file. +// Describes a secure (SSL3.0/TLS1.0) connection. +// +// + +/** + @file +*/ + +#ifndef _TLSCONNECTION_H_ +#define _TLSCONNECTION_H_ + +#include +#include +#include +#include +#include +#include +#include "LOGFILE.H" + +//Tls protocol Panics +enum TTlsPanic +{ + ETlsPanicClientHelloMsgNotSent = 0, + ETlsPanicHandshakeMsgAlreadyExists, + ETlsPanicChangeCipherMsgNotReceived, + ETlsPanicServerHelloMsgNotReceived, + ETlsPanicNullHandshakeMsg, + ETlsPanicNullServerCertificate, + ETlsPanicInvalidProcessState, + ETlsPanicInvalidTlsSession, + ETlsPanicNullTlsSession, + ETlsPanicTlsProviderNotReady, + ETlsPanicNoCA, + ETlsPanicNoDataToProcess, + ETlsPanicNoUserData, + ETlsPanicUserDataAlreadySet, + ETlsPanicNullPointerToHandshakeHeaderBuffer, + ETlsPanicNullPointerToHandshakeRecordParser, + ETlsPanicAppDataResumeButNotStarted, + ETlsPanicHelloRequestRecWhileInAppData, + ETlsPanicSignatureAlreadyExists, + ETlsPanicNullStateMachineHistory, + ETlsPanicNullStateMachine, + ETlsPanicInvalidStateMachine, + ETlsPanicStateMachineAlreadyExists, + ETlsPanicStateMachineStopped, + ETlsPanicInvalidStatus, + ETlsPanicAlertReceived, + ETlsPanicAlreadyActive, +}; + +// Declaration for global panic function for Tls protocol +GLREF_C void TlsPanic(TTlsPanic aPanic); + +// Constant values +const TInt KProtocolDescMinSize = 8; //< Minimum size of the descriptor for the Protocol name + +/* +In RFC2716 (PPP EAP TLS Authentication Protocol) section 3.5, label is defined as "client EAP encryption" + +In draft-josefsson-pppext-eap-tls-eap-02 (Protected EAP Protocol (PEAP)) section 2.8, label is +defined as "client PEAP encryption". However, most of radius servers use "client EAP encryption" +as the constant keying string. + +In draft-ietf-pppext-eap-ttls-04 EAP Tunneled TLS Authentication Protocol (TTLS) section 7, +label is defined as "ttls keying material". + +Following max size is sufficient to all those cases. +*/ +const TInt KKeyingLabelMaxSize = 100; + +// TlsConnection supported protocols +_LIT( KProtocolVerSSL30, "SSL3.0" ); //< SSL 3.0 Protocol +_LIT( KProtocolVerTLS10, "TLS1.0" ); //< TLS 1.0 Protocol + + +// Forward Declarations +class CRecordParser; +class CRecordComposer; +class CSendAlert; +class CHandshake; +class CSendAppData; +class CRecvAppData; + +class CTlsConnection : public CActive, public MSecureSocket, public MStateMachineNotify +/** + * A secure (SSL v3.0 or TLS vl.0) connection. + * Implements the MSecureSocket interface used by the SECURESOCKET.DLL to talk to + * the protocol implementation. Note that it only implements Client-mode support + * for the SSL v3.0 and TLS v1.0 protocols. + * Server-mode operation is NOT supported. + */ +{ +public: + IMPORT_C static MSecureSocket* NewL(RSocket& aSocket, const TDesC& aProtocol); + IMPORT_C static MSecureSocket* NewL(MGenericSecureSocket& aSocket, const TDesC& aProtocol); + + IMPORT_C static void UnloadDll(TAny* /*aPtr*/); + + ~CTlsConnection(); + + // MSecureSocket interface + virtual TInt AvailableCipherSuites(TDes8& aCiphers); + virtual void CancelAll(); + virtual void CancelHandshake(); + virtual void CancelRecv(); + virtual void CancelSend(); + virtual const CX509Certificate* ClientCert(); + virtual TClientCertMode ClientCertMode(); + virtual void Close(); + virtual TInt CurrentCipherSuite(TDes8& aCipherSuite); + virtual TDialogMode DialogMode(); + virtual void FlushSessionCache(); + virtual TInt GetOpt(TUint aOptionName,TUint aOptionLevel,TDes8& aOption); + virtual TInt GetOpt(TUint aOptionName,TUint aOptionLevel,TInt& aOption); + virtual TInt Protocol(TDes& aProtocol); + virtual void Recv(TDes8& aDesc, TRequestStatus & aStatus); + virtual void RecvOneOrMore(TDes8& aDesc, TRequestStatus& aStatus, TSockXfrLength& aLen); + virtual void RenegotiateHandshake(TRequestStatus& aStatus); + virtual void Send(const TDesC8& aDesc, TRequestStatus& aStatus); + virtual void Send(const TDesC8& aDesc, TRequestStatus& aStatus, TSockXfrLength& aLen); + virtual const CX509Certificate* ServerCert(); + virtual TInt SetAvailableCipherSuites(const TDesC8& aCiphers); + virtual TInt SetClientCert(const CX509Certificate& aCert); + virtual TInt SetClientCertMode(const TClientCertMode aClientCertMode); + virtual TInt SetDialogMode(const TDialogMode aDialogMode); + virtual TInt SetOpt(TUint aOptionName,TUint aOptionLevel, const TDesC8& aOption=KNullDesC8()); + virtual TInt SetOpt(TUint aOptionName,TUint aOptionLevel,TInt aOption); + virtual TInt SetProtocol(const TDesC& aProtocol); + virtual TInt SetServerCert(const CX509Certificate& aCert); + virtual void StartClientHandshake(TRequestStatus& aStatus); + virtual void StartServerHandshake(TRequestStatus& aStatus); + + // MStateMachineNotify interface + virtual TBool OnCompletion(CStateMachine* aStateMachine); + + // Internal functions (these 2 functions are only used by this class) + void StartRenegotiation( TRequestStatus* aStatus ); + void StartClientHandshakeStateMachine( TRequestStatus* aStatus ); + + void ResetCryptoAttributes(); + + //helper getter + CTLSProvider& TlsProvider(); + CTLSSession*& TlsSession(); + CRecordParser& RecordParser() const; + CRecordComposer& RecordComposer() const; + CSendAppData* SendAppData() const; + TBool SessionReUse() const; + void GetServerAddrInfo( TTLSServerAddr& serverInfo ); + + // Retrieve or confirm the Connection states + TBool IsHandshaking() const; + TBool IsReNegotiating() const; + TBool IsInDataMode() const; + TBool IsIdle() const; + + // Methods from CActive + void RunL(); + void DoCancel(); + +protected: + CTlsConnection(); + void ConstructL(RSocket& aSocket, const TDesC& aProtocol); + void ConstructL(MGenericSecureSocket& aSocket, const TDesC& aProtocol); + void DeleteStateMachines(); + void CancelAll(TInt aError); + TBool SendData(const TDesC8& aDesc, TRequestStatus& aStatus); + TBool RecvData(TDes8& aDesc, TRequestStatus& aStatus); + + TInt GetKeyingMaterial(TDes8& aKeyingMaterial); + +protected: + CTLSProvider* iTlsProvider; //< TLS Provider interface + CTLSSession* iTlsSession; //< TLS Session interface + CRecordParser* iRecordParser; //< Record parser object + CRecordComposer* iRecordComposer; //< Record composer object + CHandshake* iHandshake; //< Handshake negotiation state machine + CSendAppData* iSendAppData; //< Application data transmission state machine + CRecvAppData* iRecvAppData; //< Application data reception state machine + TDialogMode iDialogMode; //< Dialog settings + + //to keep the certificates given to client so that the client doesn't have to delete them + //=> compatible behaviour with the old tls + CX509Certificate* iClientCert; + CX509Certificate* iServerCert; + + CGenericSecureSocket* iGenericSocket; +}; + + +// Inline functions + +/** + * Returns a pointer to an Application data tx. state machine. + */ +inline CSendAppData* CTlsConnection::SendAppData() const +{ + LOG(Log::Printf(_L("CTlsConnection::CSendAppData()"));) + return iSendAppData; +} + +/** + * Returns a reference to a TlsProvider object. + */ +inline CTLSProvider& CTlsConnection::TlsProvider() +{ + LOG(Log::Printf(_L("CTlsConnection::TlsProvider()"));) + return *iTlsProvider; +} + +/** + * Returns a reference to a TlsSession object. + */ +inline CTLSSession*& CTlsConnection::TlsSession() +{ + LOG(Log::Printf(_L("CTlsConnection::TlsSession()"));) + return iTlsSession; +} + +/** + * Returns a reference to a Record parser object. + */ +inline CRecordParser& CTlsConnection::RecordParser() const +{ + LOG(Log::Printf(_L("CTlsConnection::RecordParser()"));) + return *iRecordParser; +} + +/** + * Returns a reference to a Record composer object. + */ +inline CRecordComposer& CTlsConnection::RecordComposer() const +{ + LOG(Log::Printf(_L("CTlsConnection::RecordComposer()"));) + return *iRecordComposer; +} + +/** + * Returns a Boolean value that indicates whether a connection is + * handshaking. + */ +inline TBool CTlsConnection::IsHandshaking() const +{ + LOG(Log::Printf(_L("CTlsConnection::IsHandshaking()"));) + return iHandshake && !IsInDataMode(); +} + +/** + * Returns a Boolean value that indicates whether a connection is + * renegotiating a handshake. + */ +inline TBool CTlsConnection::IsReNegotiating() const +{ + LOG(Log::Printf(_L("CTlsConnection::IsReNegotiating()"));) + return iHandshake && IsInDataMode(); +} + +/** + * Returns a Boolean value that indicates whether a connection is + * in data mode (transmission or reception). + */ +inline TBool CTlsConnection::IsInDataMode() const +{ + LOG(Log::Printf(_L("CTlsConnection::IsInDataMode()"));) + return iSendAppData != 0; // iSendAppData and iRecvAppData always go together; +} + +inline TBool CTlsConnection::SessionReUse() const +{ + LOG(Log::Printf(_L("CTlsConnection::SessionReUse()"));) + return ETrue; //used to return a value set in the FlushSessionChance + //don't think this is a good idea PS +} + +#endif +