pssl.h

Go to the documentation of this file.

/*
 * pssl.h
 *
 * Secure Sockets Layer channel interface class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-2002 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 20385 $
 * $Author: rjongbloed $
 * $Date: 2008-06-04 10:40:38 +0000 (Wed, 04 Jun 2008) $
 */

#ifndef _PSSL_H
#define _PSSL_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib/sockets.h>


struct ssl_st;
struct ssl_ctx_st;
struct x509_st;
struct evp_pkey_st;
struct dh_st;

enum PSSLFileTypes {
  PSSLFileTypePEM,
  PSSLFileTypeASN1,
  PSSLFileTypeDEFAULT
};


class PSSLPrivateKey : public PObject
{
  PCLASSINFO(PSSLPrivateKey, PObject);
  public:
    PSSLPrivateKey();

    PSSLPrivateKey(
      unsigned modulus,   
      void (*callback)(int,int,void *) = NULL,  
      void *cb_arg = NULL                       
    );

    PSSLPrivateKey(
      const PFilePath & keyFile,  
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );

    PSSLPrivateKey(
      const BYTE * keyData,   
      PINDEX keySize          
    );

    PSSLPrivateKey(
      const PBYTEArray & keyData  
    );

    PSSLPrivateKey(
      const PSSLPrivateKey & privKey
    );

    PSSLPrivateKey & operator=(
      const PSSLPrivateKey & privKay
    );

    ~PSSLPrivateKey();

    operator evp_pkey_st *() const { return key; }

    PBoolean Create(
      unsigned modulus,   
      void (*callback)(int,int,void *) = NULL,  
      void *cb_arg = NULL                       
    );

    PBYTEArray GetData() const;

    PString AsString() const;

    PBoolean Load(
      const PFilePath & keyFile,  
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );

    PBoolean Save(
      const PFilePath & keyFile,  
      PBoolean append = PFalse,        
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );


  protected:
    evp_pkey_st * key;
};


class PSSLCertificate : public PObject
{
  PCLASSINFO(PSSLCertificate, PObject);
  public:
    PSSLCertificate();

    PSSLCertificate(
      const PFilePath & certFile, 
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );

    PSSLCertificate(
      const BYTE * certData,  
      PINDEX certSize        
    );

    PSSLCertificate(
      const PBYTEArray & certData  
    );

    PSSLCertificate(
      const PString & certString  
    );

    PSSLCertificate(
      const PSSLCertificate & cert
    );

    PSSLCertificate & operator=(
      const PSSLCertificate & cert
    );

    ~PSSLCertificate();

    operator x509_st *() const { return certificate; }

    PBoolean CreateRoot(
      const PString & subject,    
      const PSSLPrivateKey & key  
    );

    PBYTEArray GetData() const;

    PString AsString() const;

    PBoolean Load(
      const PFilePath & certFile, 
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );

    PBoolean Save(
      const PFilePath & keyFile,  
      PBoolean append = PFalse,        
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );


  protected:
    x509_st * certificate;
};


class PSSLDiffieHellman : public PObject
{
  PCLASSINFO(PSSLDiffieHellman, PObject);
  public:
    PSSLDiffieHellman();

    PSSLDiffieHellman(
      const PFilePath & dhFile, 
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );

    PSSLDiffieHellman(
      const BYTE * pData, 
      PINDEX pSize,       
      const BYTE * gData, 
      PINDEX gSize        
    );

    PSSLDiffieHellman(
      const PSSLDiffieHellman & dh
    );

    PSSLDiffieHellman & operator=(
      const PSSLDiffieHellman & dh
    );

    ~PSSLDiffieHellman();

    operator dh_st *() const { return dh; }

    PBoolean Load(
      const PFilePath & dhFile, 
      PSSLFileTypes fileType = PSSLFileTypeDEFAULT  
    );

  protected:
    dh_st * dh;
};


class PSSLContext {
  public:
    enum Method {
      SSLv23,
      SSLv2,
      SSLv3,
      TLSv1
    };

    PSSLContext(
      const void * sessionId = NULL,  
      PINDEX idSize = 0               
    );
    PSSLContext(
      Method method,                  
      const void * sessionId = NULL,  
      PINDEX idSize = 0               
    );

    ~PSSLContext();

    operator ssl_ctx_st *() const { return context; }

    PBoolean SetCAPath(
      const PDirectory & caPath   
    );

    PBoolean SetCAFile(
      const PFilePath & caFile    
    );

    PBoolean UseCertificate(
      const PSSLCertificate & certificate
    );

    PBoolean UsePrivateKey(
      const PSSLPrivateKey & key
    );

    PBoolean UseDiffieHellman(
      const PSSLDiffieHellman & dh
    );

    PBoolean SetCipherList(
      const PString & ciphers   
    );

  protected:
    void Construct(Method method, const void * sessionId, PINDEX idSize);
    ssl_ctx_st * context;
};


class PSSLChannel : public PIndirectChannel
{
  PCLASSINFO(PSSLChannel, PIndirectChannel)
  public:
    PSSLChannel(
      PSSLContext * context = NULL,   
      PBoolean autoDeleteContext = PFalse  
    );
    PSSLChannel(
      PSSLContext & context           
    );

    ~PSSLChannel();

    // Overrides from PChannel
    virtual PBoolean Read(void * buf, PINDEX len);
    virtual PBoolean Write(const void * buf, PINDEX len);
    virtual PBoolean Close();
    virtual PBoolean Shutdown(ShutdownValue) { return PTrue; }
    virtual PString GetErrorText(ErrorGroup group = NumErrorGroups) const;
    virtual PBoolean ConvertOSError(int error, ErrorGroup group = LastGeneralError);

    // New functions
    PBoolean Accept();

    PBoolean Accept(
      PChannel & channel  
    );

    PBoolean Accept(
      PChannel * channel,     
      PBoolean autoDelete = PTrue  
    );


    PBoolean Connect();

    PBoolean Connect(
      PChannel & channel  
    );

    PBoolean Connect(
      PChannel * channel,     
      PBoolean autoDelete = PTrue  
    );

    PBoolean UseCertificate(
      const PSSLCertificate & certificate
    );

    PBoolean UsePrivateKey(
      const PSSLPrivateKey & key
    );

    enum VerifyMode {
      VerifyNone,
      VerifyPeer,
      VerifyPeerMandatory,
    };

    void SetVerifyMode(
      VerifyMode mode
    );

    PSSLContext * GetContext() const { return context; }

    virtual PBoolean RawSSLRead(void * buf, PINDEX & len);

  protected:
    virtual PBoolean OnOpen();

  protected:
    PSSLContext * context;
    PBoolean          autoDeleteContext;
    ssl_st      * ssl;
};

#endif // _PSSL_H

---