eap_tls_fsm.hxx

/* BEGIN_COPYRIGHT                                                        */
/*                                                                        */
/* Open Diameter: Open-source software for the Diameter and               */
/*                Diameter related protocols                              */
/*                                                                        */
/* Copyright (C) 2002-2004 Open Diameter Project                          */
/*                                                                        */
/* This program is free software; you can redistribute it and/or modify   */
/* it under the terms of the GNU General Public License as published by   */
/* the Free Software Foundation; either version 2 of the License, or      */
/* (at your option) any later version.                                    */
/*                                                                        */          
/* This program 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 program; if not, write to the Free Software            */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307    */
/* USA.                                                                   */
/*                                                                        */
/* In addition, when you copy and redistribute some or the entire part of */
/* the source code of this software with or without modification, you     */
/* MUST include this copyright notice in each copy.                       */
/*                                                                        */
/* If you make any changes that are appeared to be useful, please send    */
/* sources that include the changed part to                               */
/* diameter-developers@lists.sourceforge.net so that we can reflect your  */
/* changes to one unified version of this software.                       */
/*                                                                        */
/* END_COPYRIGHT                                                          */
/***************************************************************************
                          eap_tls_fsm.hxx  -  description
                             -------------------
    begin                : jue mar 18 2004
    copyright            : (C) 2004 by 
    email                : 
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef  __EAP_TLS_FSM_HXX__
#define  __EAP_TLS_FSM_HXX__


#include <ace/Reactor.h>
#include <stdio.h>
#include "eap_tls.hxx"
#include "eap_fsm.hxx"
#include "eap_peerfsm.hxx"
#include "eap_authfsm.hxx"
#include "eap_method_registrar.hxx"
#include "eap_tls_session.hxx"
#include "eap_tls_parser.hxx"
#include "eap_tls_mng.hxx"

class EapPeerTlsStateMachine
  :  public EapMethodStateMachine,
     public EapStateMachine<EapPeerTlsStateMachine>
{
  friend class EapMethodStateMachineCreator<EapPeerTlsStateMachine>;
  friend class EapPeerTlsStateTable_S;
public:

  void Start() throw(AAA_Error)
  {
    std::string cliente("cliente");
    std::string clt_key("./tests/tls_config/peer/clt-key.pem");
    std::string clt_cert("./tests/tls_config/peer/clt-cert.pem");
    std::string random_peer("./tests/tls_config/auth/random");
    std::string ca_path_peer("./tests/tls_config/peer");
    std::string ca_cert_peer("./tests/tls_config/peer/ca-cert.pem");
    std::string dh_peer("./tests/tls_config/auth/dh");
    EAPTLS_config *config_peer= new EAPTLS_config(cliente,
                                       clt_key,
                                       clt_cert,
                                       random_peer,
                                       ca_path_peer,
                                       ca_cert_peer,
                                       dh_peer,
                              (ACE_INT32)0,
                              (ACE_INT32)1,
                              (ACE_INT32)512,
                              (ACE_INT32)512,
                              (ACE_INT32)1,
                              (ACE_INT32)1,
                                         false,
                              (ACE_INT32)600);

   

    ctx_peer=tls_mng_peer.init_tls_ctx(*config_peer);
    tls_conf_ctx_peer = new EAPTLS_tls_t(config_peer,ctx_peer);
    EapStateMachine<EapPeerTlsStateMachine>::Start();
  }

  inline void Notify(AAA_Event ev)
  {
    EapStateMachine<EapPeerTlsStateMachine>::Notify(ev);
  }

  virtual std::string& InputIdentity()=0;

  EAPTLS_session_t_peer* get_tls_session() {return ssn;};
  EAPTLS_tls_mng_peer& get_mng_peer(){return tls_mng_peer;};
  void set_tls_session(EAPTLS_session_t_peer *ssn)
  {
        if (this->ssn != NULL) delete this->ssn;this->ssn = ssn;
  }
  /*AAAMessageBlock *get_master_key()
  {
    TLS_data *data = ssn->get_tls_data();
    ACE_UINT32 msk_length = (ACE_UINT32)(data->session->master_key_length); //Recover master key length
    AAAMessageBlock *msk = AAAMessageBlock::Acquire(msk_length);
    msk->copy((const char *)data->session->master_key,msk_length);
    return msk;
  }*/

  EAPTLS_tls_t * get_ctx_peer() {return tls_conf_ctx_peer;};

protected:
  EAPTLS_config *config_peer;
  EAPTLS_tls_mng_peer tls_mng_peer;
  TLS_context *ctx_peer;
  EAPTLS_tls_t  *tls_conf_ctx_peer;
  
  EapPeerTlsStateMachine(EapSwitchStateMachine &s);
  ~EapPeerTlsStateMachine() {};
  EAPTLS_session_t_peer *ssn;
  std::string history;
};

class EapAuthTlsStateMachine
  :  public EapMethodStateMachine,
     public EapStateMachine<EapAuthTlsStateMachine>
{
  friend class EapMethodStateMachineCreator<EapAuthTlsStateMachine>;
  friend class EapAuthTlsStateTable_S;
public:

  void Start() throw(AAA_Error)
  {
    std::string servidor("servidor");
    std::string srv_key("./tests/tls_config/auth/srv-key.pem");
    std::string srv_cert("./tests/tls_config/auth/srv-cert.pem");
    std::string random("./tests/tls_config/auth/random");
    std::string ca_path("./tests/tls_config/auth");
    std::string ca_cert("./tests/tls_config/auth/ca-cert.pem");
    std::string dh("./tests/tls_config/auth/dh");
    int s_server_session_id_context=0xFFFFF;

   EAPTLS_config *config_auth=new EAPTLS_config(servidor,
                                       srv_key,
                                       srv_cert,
                                       random,
                                       ca_path,
                                       ca_cert,
                                       dh,
                              (ACE_INT32)0,
                              (ACE_INT32)1,
                              (ACE_INT32)512,
                              (ACE_INT32)512,
                              (ACE_INT32)1,
                              (ACE_INT32)1,                                       
                                         false,
                              (ACE_INT32)500);    //Fragment size.
    ctx_auth=tls_mng_auth.init_tls_ctx(*config_auth,s_server_session_id_context);
    tls_conf_ctx_auth = new EAPTLS_tls_t(config_auth,ctx_auth);
    

    EapStateMachine<EapAuthTlsStateMachine>::Start();
  }

  inline void Notify(AAA_Event ev)
  {
    EapStateMachine<EapAuthTlsStateMachine>::Notify(ev);
  }
  EAPTLS_session_t_auth* get_tls_session() {return ssn;};
  EAPTLS_tls_mng_auth& get_mng_auth(){return tls_mng_auth;};
  void set_tls_session(EAPTLS_session_t_auth *ssn) {if (this->ssn != NULL) delete this->ssn;this->ssn = ssn;};
  /*AAAMessageBlock *get_master_key()
  {
    TLS_data *data = ssn->get_tls_data();
    ACE_UINT32 msk_length = (ACE_UINT32)(data->session->master_key_length); //Recover master key length
    AAAMessageBlock *msk = AAAMessageBlock::Acquire((char *)data->session->master_key,msk_length);
    return msk;
  }*/

  EAPTLS_tls_t * get_ctx_auth(){ return tls_conf_ctx_auth;}
  
  std::string& History() { return history; }
protected:

  EAPTLS_config *config_auth;
  EAPTLS_tls_mng_auth tls_mng_auth;
  TLS_context *ctx_auth;
  EAPTLS_tls_t  *tls_conf_ctx_auth;

  EapAuthTlsStateMachine(EapSwitchStateMachine &s);
  ~EapAuthTlsStateMachine() {}
  EAPTLS_session_t_auth *ssn;
  std::string history;
};
#endif

---