Skip to content
GitLab
Commit fdc671be authored by vagrant's avatar vagrant
Browse files

Remove PkiPort

parent 5c08a639
Show whitespace changes
Inline Side-by-side
ccsrc/Ports/LibIts_ports/AdapterControlPort.cc
View file @ fdc671be
......@@ -9,7 +9,6 @@
#include "IVIM_ports/AdapterControlPort_IVIM.partC"
#include "MapemSpatem_ports/AdapterControlPort_MapemSpatem.partC"
#include "SremSsem_ports/AdapterControlPort_SremSsem.partC"
//#include "Pki_ports/AdapterControlPort_Pki.partC"
//#include "V2G_ports/AdapterControlPort_V2G.partC"
#else //_NO_SOFTLINKS_
......@@ -20,7 +19,6 @@
#include "AdapterControlPort_MapemSpatem.partC"
#include "AdapterControlPort_SremSsem.partC"
#include "AdapterControlPort_GN.partC"
//#include "AdapterControlPort_Pki.partC"
/*
#include "AdapterControlPort_IVIM.partC"
#include "AdapterControlPort_MapemSpatem.partC"
......
ccsrc/Ports/LibIts_ports/AdapterControlPort.hh
View file @ fdc671be
......@@ -12,7 +12,6 @@
#include "IVIM_ports/AdapterControlPort_IVIM.partH"
#include "MapemSpatem_ports/AdapterControlPort_MapemSpatem.partH"
#include "SremSsem_ports/AdapterControlPort_SremSsem.partH"
//#include "Pki_ports/AdapterControlPort_Pki.partH"
//#include "V2G_ports/AdapterControlPort_V2G.partH"
#else //_NO_SOFTLINKS_
......@@ -23,7 +22,6 @@
#include "AdapterControlPort_MapemSpatem.partH"
#include "AdapterControlPort_SremSsem.partH"
#include "AdapterControlPort_GN.partH"
//#include "AdapterControlPort_Pki.partH"
/*
#include "AdapterControlPort_IVIM.partH"
#include "AdapterControlPort_MapemSpatem.partH"
......
ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPkiPort.cc deleted 100644 → 0
View file @ 5c08a639
#include <TTCN3.hh>
#include "LibItsPki_TestSystem.hh"
#include "loggers.hh"
#include "registration.hh"
#include "pki_layer.hh"
//=============================================================================
namespace LibItsPki__TestSystem {
AdapterControlPkiPort::AdapterControlPkiPort(const char *par_port_name)
: AdapterControlPkiPort_BASE(par_port_name), _params()
{
loggers::get_instance().log("AdapterControlPkiPort::AdapterControlPkiPort");
}
AdapterControlPkiPort::~AdapterControlPkiPort()
{
}
void AdapterControlPkiPort::set_parameter(const char * parameter_name, const char * parameter_value)
{
loggers::get_instance().log("AdapterControlPkiPort::set_parameter: %s=%s", parameter_name, parameter_value);
}
/*void AdapterControlPkiPort::Handle_Fd_Event(int fd, boolean is_readable,
boolean is_writable, boolean is_error) {}*/
void AdapterControlPkiPort::Handle_Fd_Event_Error(int /*fd*/)
{
}
void AdapterControlPkiPort::Handle_Fd_Event_Writable(int /*fd*/)
{
}
void AdapterControlPkiPort::Handle_Fd_Event_Readable(int /*fd*/)
{
}
/*void AdapterControlPkiPort::Handle_Timeout(double time_since_last_call) {}*/
void AdapterControlPkiPort::user_map(const char * system_port)
{
loggers::get_instance().log(">>> AdapterControlPkiPort::user_map: %s", system_port);
}
void AdapterControlPkiPort::user_unmap(const char * system_port)
{
loggers::get_instance().log(">>> AdapterControlPkiPort::user_unmap: %s", system_port);
}
void AdapterControlPkiPort::user_start()
{
}
void AdapterControlPkiPort::user_stop()
{
}
void AdapterControlPkiPort::outgoing_send(const LibItsPki__TypesAndValues::AcPkiPrimitive& send_par)
{
loggers::get_instance().log_msg(">>> AdapterControlPkiPort::outgoing_send: ", send_par);
// Register this object for AdapterControlPkiPort
pki_layer* p = registration<pki_layer>::get_instance().get_item(std::string("PKI"));
if (p != NULL) {
loggers::get_instance().log("AdapterControlPkiPort::outgoing_send: Got PKI layer %p", p);
LibItsPki__TypesAndValues::AcPkiResponse response;
response.result() = BOOLEAN(false);
if (send_par.ischosen(LibItsPki__TypesAndValues::AcPkiPrimitive::ALT_acSetSecurityData)) {
loggers::get_instance().log("AdapterControlPkiPort::outgoing_send: AcSetSecurityData");
p->set_pki_keys(send_par.acSetSecurityData());
response.result() = BOOLEAN(true);
}
// Send response
loggers::get_instance().log_msg("AdapterControlPkiPort::outgoing_send: Send response: ", response);
incoming_message(response);
} else {
loggers::get_instance().error("AdapterControlPkiPort::outgoing_send: pkiPort not registered");
}
}
} /* end of namespace */
ccsrc/Ports/LibIts_ports/Pki_ports/AdapterControlPkiPort.hh deleted 100644 → 0
View file @ 5c08a639
//=============================================================================
#include "LibItsPki_TestSystem.hh"
#include "params.hh"
namespace LibItsPki__TypesAndValues {
class AcPkiPrimitive;
}
namespace LibItsPki__TestSystem {
class AdapterControlPkiPort : public AdapterControlPkiPort_BASE {
params _params;
public:
AdapterControlPkiPort(const char *par_port_name = NULL);
~AdapterControlPkiPort();
void set_parameter(const char *parameter_name,
const char *parameter_value);
private:
/* void Handle_Fd_Event(int fd, boolean is_readable,
boolean is_writable, boolean is_error); */
void Handle_Fd_Event_Error(int fd);
void Handle_Fd_Event_Writable(int fd);
void Handle_Fd_Event_Readable(int fd);
/* void Handle_Timeout(double time_since_last_call); */
protected:
void user_map(const char *system_port);
void user_unmap(const char *system_port);
void user_start();
void user_stop();
void outgoing_send(const LibItsPki__TypesAndValues::AcPkiPrimitive& send_par);
};
} /* end of namespace */
ccsrc/Ports/LibIts_ports/Pki_ports/PkiPort.cc deleted 100644 → 0
View file @ 5c08a639
// This Test Port skeleton source file was generated by the
// TTCN-3 Compiler of the TTCN-3 Test Executor version CRL 113 200/5 R3A
// for U-ERICSSON\ethgry (ethgry@HU00078339) on Fri Aug 14 21:19:06 2015
// Copyright Ericsson Telecom AB 2000-2014
// You may modify this file. Complete the body of empty functions and
// add your member functions here.
#include "PkiPort.hh"
#include "pki_layer_factory.hh"
#include "loggers.hh"
namespace LibItsPki__TestSystem {
PkiPort::PkiPort(const char *par_port_name)
: PkiPort_BASE(par_port_name), _cfg_params(), _layer_params(), _layer(nullptr), _time_key("PkiPort::outgoing_send") {
// Nothing to do
}
PkiPort::~PkiPort()
{
loggers::get_instance().log(">>> PkiPort::~PkiPort");
if (_layer != nullptr) {
delete _layer;
}
}
void PkiPort::set_parameter(const char* parameter_name, const char* parameter_value)
{
loggers::get_instance().log("PkiPort::set_parameter: %s=%s", parameter_name, parameter_value);
_cfg_params.insert(std::pair<std::string, std::string>(std::string(parameter_name), std::string(parameter_value)));
}
/*void PkiPort::Handle_Fd_Event(int fd, boolean is_readable,
boolean is_writable, boolean is_error) {}*/
void PkiPort::Handle_Fd_Event_Error(int /*fd*/)
{
}
void PkiPort::Handle_Fd_Event_Writable(int /*fd*/)
{
}
void PkiPort::Handle_Fd_Event_Readable(int /*fd*/)
{
}
/*void PkiPort::Handle_Timeout(double time_since_last_call) {}*/
void PkiPort::user_map(const char* system_port)
{
loggers::get_instance().log(">>> PkiPort::user_map: %s", system_port);
// Build layer stack
params::iterator it = _cfg_params.find(std::string("params"));
if (it != _cfg_params.end()) {
loggers::get_instance().log("PkiPort::user_map: %s", it->second.c_str());
// Setup parameters
params::convert(_layer_params, it->second); // TODO This _layer_params seems to be useless
// Create layer
_layer = layer_stack_builder::get_instance()->create_layer_stack(it->second.c_str());
if (static_cast<pki_layer *>(_layer) == nullptr) {
loggers::get_instance().error("PkiPort::user_map: Invalid stack configuration: %s", it->second.c_str());
}
static_cast<pki_layer *>(_layer)->add_upper_port(this);
} else {
loggers::get_instance().error("PkiPort::user_map: No layers defined in configuration file");
}
}
void PkiPort::user_unmap(const char* system_port)
{
loggers::get_instance().log(">>> PkiPort::user_unmap: %s", system_port);
// Reset layers
if (_layer != nullptr) {
delete _layer;
_layer = nullptr;
}
}
void PkiPort::user_start()
{
loggers::get_instance().log(">>> PkiPort::user_start");
}
void PkiPort::user_stop()
{
loggers::get_instance().log(">>> PkiPort::user_stop");
}
void PkiPort::outgoing_send(const EtsiTs102941TypesEnrolment::InnerEcRequest& send_par)
{
loggers::get_instance().log_msg(">>> PkiPort::outgoing_send: payload=", send_par);
float duration;
loggers::get_instance().set_start_time(_time_key);
params params;
static_cast<pki_layer *>(_layer)->sendMsg(send_par, params);
loggers::get_instance().set_stop_time(_time_key, duration);
}
void PkiPort::outgoing_send(const EtsiTs102941TypesEnrolment::InnerEcResponse& send_par)
{
}
void PkiPort::outgoing_send(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& send_par) {
loggers::get_instance().log_msg(">>> PkiPort::outgoing_send: payload=", send_par);
float duration;
loggers::get_instance().set_start_time(_time_key);
params params;
static_cast<pki_layer *>(_layer)->sendMsg(send_par, params);
loggers::get_instance().set_stop_time(_time_key, duration);
}
void PkiPort::outgoing_send(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& send_par) {
}
void PkiPort::receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcRequest& p_ind, const params& p_params) {
loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
// Sanity check
if (!p_ind.is_bound()) {
return;
}
incoming_message(p_ind);
}
void PkiPort::receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcResponse& p_ind, const params& p_params) {
loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
// Sanity check
if (!p_ind.is_bound()) {
return;
}
incoming_message(p_ind);
}
void PkiPort::receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& p_ind, const params& p_params) {
loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
// Sanity check
if (!p_ind.is_bound()) {
return;
}
incoming_message(p_ind);
}
void PkiPort::receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& p_ind, const params& p_params) {
loggers::get_instance().log_msg(">>> PkiPort::receive_msg: ", p_ind);
// Sanity check
if (!p_ind.is_bound()) {
return;
}
incoming_message(p_ind);
}
} /* end of namespace */
ccsrc/Ports/LibIts_ports/Pki_ports/PkiPort.hh deleted 100644 → 0
View file @ 5c08a639
// This Test Port skeleton header file was generated by the
// TTCN-3 Compiler of the TTCN-3 Test Executor version CRL 113 200/5 R3A
// for U-ERICSSON\ethgry (ethgry@HU00078339) on Fri Aug 14 21:19:06 2015
// Copyright Ericsson Telecom AB 2000-2014
// You may modify this file. Add your attributes and prototypes of your
// member functions here.
#pragma once
#include "LibItsPki_TestSystem.hh"
#include "layer.hh"
#include "params.hh"
namespace LibItsPki__TestSystem {
class PkiPort : public PkiPort_BASE {
params _cfg_params;
params _layer_params;
layer* _layer;
std::string _time_key;
public:
PkiPort(const char *par_port_name = NULL);
~PkiPort();
void set_parameter(const char *parameter_name, const char *parameter_value);
void receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcRequest& p_ind, const params& p_params);
void receiveMsg (const EtsiTs102941TypesEnrolment::InnerEcResponse& p_ind, const params& p_params);
void receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& p_ind, const params& p_params);
void receiveMsg (const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& p_ind, const params& p_params);
private:
/* void Handle_Fd_Event(int fd, boolean is_readable,
boolean is_writable, boolean is_error); */
void Handle_Fd_Event_Error(int fd);
void Handle_Fd_Event_Writable(int fd);
void Handle_Fd_Event_Readable(int fd);
/* void Handle_Timeout(double time_since_last_call); */
protected:
void user_map(const char *system_port);
void user_unmap(const char *system_port);
void user_start();
void user_stop();
void outgoing_send(const EtsiTs102941TypesEnrolment::InnerEcRequest& send_par);
void outgoing_send(const EtsiTs102941TypesEnrolment::InnerEcResponse& send_par);
void outgoing_send(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& send_par);
void outgoing_send(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationResponse& send_par);
};
} /* end of namespace */
ccsrc/Protocols/Pki/pki_layer.cc deleted 100644 → 0
View file @ 5c08a639
#include "pki_layer_factory.hh"
#include "codec_stack_builder.hh"
#include "loggers.hh"
#include "base_time.hh"
#include "registration.hh"
#include "converter.hh"
#include "security_services.hh"
#include "pki_layer.hh"
using namespace std; // Required for isnan()
#include "LibItsPki_TypesAndValues.hh"
#include "LibItsPki_TestSystem.hh"
pki_layer::pki_layer(const std::string & p_type, const std::string & param) : t_layer<LibItsPki__TestSystem::PkiPort>(p_type), _params(), _etsi_ts102941_types_enrolment_inner_request(), _etsi_ts102941_types_enrolment_inner_response(), _etsi_ts102941_types_authorization_validation_request(), _etsi_ts102941_types_authorization_validation_response(), _codec(), _ac_set_security_data(nullptr)
{
loggers::get_instance().log(">>> pki_layer::pki_layer: %s, %s", to_string().c_str(), param.c_str());
// Setup parameters
params::convert(_params, param);
// Sanity checks
params::const_iterator it = _params.find(params::certificate);
if (it == _params.cend()) {
_params[params::certificate] = "CERT_TS_A_EA";
}
it = _params.find(params::peer_certificate);
if (it == _params.cend()) {
_params[params::peer_certificate] = "CERT_IUT_A_EA";
}
_params[params::its_aid] = "2468";
_params[params::payload_type] = "";
_params[params::signature] = "NISTP-256"; // TODO Should be removed
_params[params::encrypted_mode] = "1";
_params[params::hash] = "SHA-256"; // TODO Should be removed
// Register this object for AdapterControlPort
loggers::get_instance().log("pki_layer::pki_layer: Register %s/%p", p_type.c_str(), this);
registration<pki_layer>::get_instance().add_item(p_type, this);
}
void pki_layer::sendMsg(const EtsiTs102941TypesEnrolment::InnerEcRequest& p_inner_ec_request, params& p_param) {
loggers::get_instance().log_msg(">>> pki_layer::sendMsg: ", p_inner_ec_request);
// Sanity checks
if (_ac_set_security_data.get() == nullptr) {
loggers::get_instance().error("pki_layer::sendMsg: Security data missing");
return;
}
OCTETSTRING inner_ec_request;
_etsi_ts102941_types_enrolment_inner_request.encode(p_inner_ec_request, inner_ec_request);
// Build the EtsiTs103097Data-Signed
OCTETSTRING etsi_ts_103097_data;
if (generate_inner_ec_request_signed_for_pop(inner_ec_request, etsi_ts_103097_data, _params) == -1) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to generate InnerExRequestSignedForPop");
return;
}
// Secured the EtsiTs102941Data layer
OCTETSTRING etsi_ts_102941_data;
if (sign_and_encrypt_payload(etsi_ts_103097_data, etsi_ts_102941_data, _params) == -1) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to secure Pki message");
return;
}
loggers::get_instance().log_msg("<<< pki_layer::sendMsg: ", etsi_ts_102941_data);
send_data(etsi_ts_102941_data, _params);
}
void pki_layer::sendMsg(const EtsiTs102941TypesEnrolment::InnerEcResponse& p_inner_ec_response, params& p_param) {
loggers::get_instance().log_msg(">>> pki_layer::sendMsg: ", p_inner_ec_response);
// Create the EtsiTs102941Data layer
EtsiTs102941MessagesCa::EtsiTs102941Data etsi_ts_102941_data;
etsi_ts_102941_data.content().enrolmentResponse() = p_inner_ec_response;
loggers::get_instance().log_msg("pki_layer::sendMsg: InnerEcResponse: ", etsi_ts_102941_data);
// Encode it
OCTETSTRING etsi_ts_103097_data_enc;
_codec_etsi_ts102941_data_codec.encode(etsi_ts_102941_data, etsi_ts_103097_data_enc);
if (!etsi_ts_103097_data_enc.is_bound()) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to encode InnerEcResponse");
}
loggers::get_instance().log_msg("pki_layer::sendMsg: etsi_ts_103097_data_enc: ", etsi_ts_103097_data_enc);
// Secured the EtsiTs102941Data layer
OCTETSTRING secured_inner_ec_response;
if (sign_and_encrypt_payload(etsi_ts_103097_data_enc, secured_inner_ec_response, p_param) == 0) {
send_data(secured_inner_ec_response, _params);
}
loggers::get_instance().log_msg("<<< pki_layer::sendMsg: etsi_ts_102941_data:", secured_inner_ec_response);
send_data(secured_inner_ec_response, _params);
}
void pki_layer::sendMsg(const EtsiTs102941TypesAuthorizationValidation::AuthorizationValidationRequest& p_authorization_validation_request, params& p_param) {
loggers::get_instance().log_msg(">>> pki_layer::sendMsg: ", p_authorization_validation_request);
// Sanity checks
if (_ac_set_security_data.get() == nullptr) {
loggers::get_instance().error("pki_layer::sendMsg: Security data missing");
return;
}
// Create the EtsiTs102941Data layer
EtsiTs102941MessagesCa::EtsiTs102941Data etsi_ts_102941_data;
etsi_ts_102941_data.content().authorizationValidationRequest() = p_authorization_validation_request;
loggers::get_instance().log_msg("pki_layer::sendMsg: AuthorizationValidationRequest: ", etsi_ts_102941_data);
// Encode it
OCTETSTRING etsi_ts_103097_data_enc;
_codec_etsi_ts102941_data_codec.encode(etsi_ts_102941_data, etsi_ts_103097_data_enc);
if (!etsi_ts_103097_data_enc.is_bound()) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to encode AuthorizationValidationRequest");
}
loggers::get_instance().log_msg("pki_layer::sendMsg: etsi_ts_103097_data_enc: ", etsi_ts_103097_data_enc);
// Secured the EtsiTs102941Data layer
OCTETSTRING secured_authorization_validation_request;
if (sign_and_encrypt_payload(etsi_ts_103097_data_enc, secured_authorization_validation_request, _params) == -1) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to secure Pki message");
return;
}
loggers::get_instance().log_msg("<<< pki_layer::sendMsg: generate_authorization_validation_request: ", secured_authorization_validation_request);
send_data(secured_authorization_validation_request, _params);
}
void pki_layer::send_data(OCTETSTRING& data, params& params) {
loggers::get_instance().log_msg(">>> pki_layer::send_data: ", data);
send_to_all_layers(data, params);
}
void pki_layer::receive_data(OCTETSTRING& data, params& params)
{
loggers::get_instance().log_msg(">>> pki_layer::receive_data: ", data);
// 1. Extract EtsiTs102941Data or EtsiTs103097DataSigned
OCTETSTRING unsecured_payload;
if (decrypt_and_check_signature(data, unsecured_payload, _params) == -1) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to secure Pki message");
return;
}
loggers::get_instance().log_msg("pki_layer::receive_data: unsecured_payload=", unsecured_payload);
// Try to extract EtsiTs102941Data
EtsiTs102941MessagesCa::EtsiTs102941Data etsi_ts_102941_data;
if (_codec_etsi_ts102941_data_codec.decode(unsecured_payload, etsi_ts_102941_data) == -1) {
// Try with EtsiTs103097Data-Signed
IEEE1609dot2::Ieee1609Dot2Data etsi_ts_1609dot2_data;
if (_codec.decode(unsecured_payload, etsi_ts_1609dot2_data) == -1) {
loggers::get_instance().warning("pki_layer::sendMsg: Failed to decode unsecured payload");
return;
} else {
// Process EtsiTs103097Data-Signed
loggers::get_instance().log_msg("pki_layer::receive_data: Process ", etsi_ts_1609dot2_data);
}
} else {
// TODO Process EtsiTs102941Data
loggers::get_instance().log_msg("pki_layer::receive_data: Process ", etsi_ts_102941_data);
// Check protocol version
if (etsi_ts_102941_data.version() != 1) {
loggers::get_instance().warning("pki_layer::sendMsg: Wrong ETSI TS 102 941 protocol version, discard it!");
return;
}
if (etsi_ts_102941_data.content().ischosen(EtsiTs102941MessagesCa::EtsiTs102941DataContent::ALT_enrolmentResponse)) {
// Pass it to the ports
to_all_upper_ports(etsi_ts_102941_data.content().enrolmentResponse(), _params);
}
}
// Pass it to the ports
//to_all_upper_ports(pki_message, params);
}
void pki_layer::set_pki_keys(const LibItsPki__TypesAndValues::AcSetSecurityData& p_ac_set_security_data) {
loggers::get_instance().log_msg(">>> pki_layer::set_pki_keys: ", p_ac_set_security_data);
_ac_set_security_data.reset(new LibItsPki__TypesAndValues::AcSetSecurityData(p_ac_set_security_data));
loggers::get_instance().log_msg("pki_layer::set_pki_keys: New data", *_ac_set_security_data);
_params[params::certificate] = p_ac_set_security_data.certificateId();
_params[params::peer_certificate] = p_ac_set_security_data.peer__certificateId();
}
int pki_layer::generate_inner_ec_request_signed_for_pop(const OCTETSTRING& p_inner_ec_request, OCTETSTRING& p_etsi_ts_103097_data, params& p_params) {
loggers::get_instance().log_msg(">>> pki_layer::generate_inner_ec_request_signed_for_pop: ", p_inner_ec_request);
// Re-configure default parameters
params p(p_params);
p[params::peer_certificate] = p[params::certificate]; // ETSI TS 102 941 Clause 6.2.3.2.1 Enrolment request