sslsocket.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus library is distributed in the hope that it will be        *
 *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty   *
 *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
 *   General Public License for more details.                              *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSNSSSSLSOCKET_H
#define CONEXUSNSSSSLSOCKET_H

#include <conexus-nspr/socket.h>
#include <conexus-nspr/udp.h>
#include <conexus-nss/certificate.h>
#include <conexus-nss/privatekey.h>

namespace Conexus
{

  namespace NSS
  {
    class SSLSocket : public Conexus::NSPR::Socket
    {
      public:
        typedef ConexusPointer<SSLSocket> pointer;

      protected:
        SSLSocket( Conexus::NSPR::Socket::pointer socket, SSLSocket::pointer model = SSLSocket::pointer() );

      public:
        static pointer create( Conexus::NSPR::Socket::pointer socket, SSLSocket::pointer model = SSLSocket::pointer() );
        
        virtual ~SSLSocket() throw();

        virtual void open() throw (open_exception);

        virtual size_t input_available() throw();

        bool set_option( int32_t option, bool on=true );

        bool is_option_set( int32_t option );

        bool enable_cipher( int32_t cipher, bool enable=true );

        bool is_cipher_enabled( int32_t cipher );

        bool configure_as_server( Certificate::pointer cert, PrivateKey::pointer key, KEA kea_type );

        bool set_url( const std::string& url );

        std::string url();

        bool set_pkcs11_pin_arg( void* arg );

        void* pkcs11_pin_arg();

        bool invalidate_session();

        SECURITY_STATUS security_status();

        std::string cipher();

        int session_key_size();

        int secret_key_size();

        std::string issuer();

        std::string subject();

        // TODO return a wrapped object
        SECItem* session_id();

        bool set_peer_id( const std::string& peer_id );

        Certificate::pointer peer_certificate();
        
        bool force_handshake();

        bool rehandshake( bool flush_cache = true );

        bool reset_handshake( bool as_server = false );

        void set_authenticate_certificate_callback( sigc::slot<bool,bool,bool> slot );

        void unset_authenticate_certificate_callback();

        void set_bad_certificate_callback( sigc::slot<bool> slot );

        void unset_bad_certificate_callback();

        void set_client_authentication_callback( sigc::slot<bool,struct CERTDistNamesStr*, struct CERTCertificateStr**, struct SECKEYPrivateKeyStr**> slot );

        void set_default_client_authentication_callback(char* nickname);

        void unset_client_authentication_callback();

        sigc::signal<void> signal_handshake_complete();

      protected:

        sigc::slot<bool,bool,bool> m_authenticate_certificate_slot;

        sigc::slot<bool> m_bad_certificate_slot;

        sigc::slot<bool,struct CERTDistNamesStr*, struct CERTCertificateStr**, struct SECKEYPrivateKeyStr**> m_client_authentication_slot;

        sigc::signal<void> m_signal_handshake_complete;
        
        virtual bool on_authenticate_certificate( bool checksig, bool isServer );

        virtual bool on_bad_certificate();

        virtual bool on_client_authentication( struct CERTDistNamesStr* ca_names, struct CERTCertificateStr** ret_cert, struct SECKEYPrivateKeyStr** ret_key );

      private:
        static SECStatus SSL_AuthCertificateHook_proxy( void *arg, PRFileDesc *socket, PRBool checksig, PRBool isServer );

        static SECStatus SSL_BadCertHook_proxy( void *arg, PRFileDesc *socket );

        static void SSL_HandshakeCallback_proxy( PRFileDesc *socket, void *arg );

        static SECStatus SSL_GetClientAuthDataHook_proxy( void *arg, PRFileDesc *socket,
            struct CERTDistNamesStr *caNames,
            struct CERTCertificateStr **pRetCert,
            struct SECKEYPrivateKeyStr **pRetKey );


    };

  }

}

//         void enable_ssl( bool as_server );



#endif