diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/libimcv/Makefile.am | 8 | ||||
-rw-r--r-- | src/libimcv/plugins/imc_hcd/Makefile.am | 16 | ||||
-rw-r--r-- | src/libimcv/plugins/imc_hcd/imc_hcd.c | 714 | ||||
-rw-r--r-- | src/libimcv/plugins/imc_hcd/imc_hcd_state.c | 176 | ||||
-rw-r--r-- | src/libimcv/plugins/imc_hcd/imc_hcd_state.h | 50 | ||||
-rw-r--r-- | src/libimcv/plugins/imv_hcd/Makefile.am | 18 | ||||
-rw-r--r-- | src/libimcv/plugins/imv_hcd/imv_hcd.c | 24 | ||||
-rw-r--r-- | src/libimcv/plugins/imv_hcd/imv_hcd_agent.c | 566 | ||||
-rw-r--r-- | src/libimcv/plugins/imv_hcd/imv_hcd_agent.h | 36 | ||||
-rw-r--r-- | src/libimcv/plugins/imv_hcd/imv_hcd_state.c | 264 | ||||
-rw-r--r-- | src/libimcv/plugins/imv_hcd/imv_hcd_state.h | 77 |
11 files changed, 1949 insertions, 0 deletions
diff --git a/src/libimcv/Makefile.am b/src/libimcv/Makefile.am index 593611dd8..6923aac0d 100644 --- a/src/libimcv/Makefile.am +++ b/src/libimcv/Makefile.am @@ -175,6 +175,14 @@ if USE_IMV_SWID SUBDIRS += plugins/imv_swid endif +if USE_IMC_HCD + SUBDIRS += plugins/imc_hcd +endif + +if USE_IMV_HCD + SUBDIRS += plugins/imv_hcd +endif + TESTS = imcv_tests check_PROGRAMS = $(TESTS) diff --git a/src/libimcv/plugins/imc_hcd/Makefile.am b/src/libimcv/plugins/imc_hcd/Makefile.am new file mode 100644 index 000000000..db25a57de --- /dev/null +++ b/src/libimcv/plugins/imc_hcd/Makefile.am @@ -0,0 +1,16 @@ +AM_CPPFLAGS = \ + -I$(top_srcdir)/src/libstrongswan \ + -I$(top_srcdir)/src/libtncif \ + -I$(top_srcdir)/src/libimcv + +AM_CFLAGS = \ + $(PLUGIN_CFLAGS) + +imcv_LTLIBRARIES = imc-hcd.la + +imc_hcd_la_LIBADD = $(top_builddir)/src/libimcv/libimcv.la \ + $(top_builddir)/src/libstrongswan/libstrongswan.la + +imc_hcd_la_SOURCES = imc_hcd.c imc_hcd_state.h imc_hcd_state.c + +imc_hcd_la_LDFLAGS = -module -avoid-version -no-undefined diff --git a/src/libimcv/plugins/imc_hcd/imc_hcd.c b/src/libimcv/plugins/imc_hcd/imc_hcd.c new file mode 100644 index 000000000..35badebbe --- /dev/null +++ b/src/libimcv/plugins/imc_hcd/imc_hcd.c @@ -0,0 +1,714 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +#include "imc_hcd_state.h" + +#include <imc/imc_agent.h> +#include <imc/imc_msg.h> +#include <generic/generic_attr_bool.h> +#include <generic/generic_attr_chunk.h> +#include <generic/generic_attr_string.h> +#include <ietf/ietf_attr.h> +#include <ietf/ietf_attr_attr_request.h> +#include <pwg/pwg_attr.h> +#include <pwg/pwg_attr_vendor_smi_code.h> + +#include <tncif_pa_subtypes.h> + +#include <pen/pen.h> +#include <utils/debug.h> + +/* IMC definitions */ + +static const char imc_name[] = "HCD"; + +static pen_type_t msg_types[] = { + { PEN_PWG, PA_SUBTYPE_PWG_HCD } +}; + +static imc_agent_t *imc_hcd; + +typedef struct quadruple_t quadruple_t; + +struct quadruple_t { + char *section; + pwg_attr_t name_attr; + pwg_attr_t patches_attr; + pwg_attr_t string_version_attr; + pwg_attr_t version_attr; +}; + +static quadruple_t quadruples[] = { + { "firmware", + PWG_HCD_FIRMWARE_NAME, PWG_HCD_FIRMWARE_PATCHES, + PWG_HCD_FIRMWARE_STRING_VERSION, PWG_HCD_FIRMWARE_VERSION }, + { "resident_application", + PWG_HCD_RESIDENT_APP_NAME, PWG_HCD_RESIDENT_APP_PATCHES, + PWG_HCD_RESIDENT_APP_STRING_VERSION, PWG_HCD_RESIDENT_APP_VERSION }, + { "user_application", + PWG_HCD_USER_APP_NAME, PWG_HCD_USER_APP_PATCHES, + PWG_HCD_USER_APP_STRING_VERSION, PWG_HCD_USER_APP_VERSION } +}; + +/** + * see section 3.8.1 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_Initialize(TNC_IMCID imc_id, + TNC_Version min_version, + TNC_Version max_version, + TNC_Version *actual_version) +{ + if (imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has already been initialized", imc_name); + return TNC_RESULT_ALREADY_INITIALIZED; + } + imc_hcd = imc_agent_create(imc_name, msg_types, countof(msg_types), + imc_id, actual_version); + if (!imc_hcd) + { + return TNC_RESULT_FATAL; + } + + if (min_version > TNC_IFIMC_VERSION_1 || max_version < TNC_IFIMC_VERSION_1) + { + DBG1(DBG_IMC, "no common IF-IMC version"); + return TNC_RESULT_NO_COMMON_VERSION; + } + return TNC_RESULT_SUCCESS; +} + +/** + * see section 3.8.2 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_NotifyConnectionChange(TNC_IMCID imc_id, + TNC_ConnectionID connection_id, TNC_ConnectionState new_state) +{ + imc_state_t *state; + + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + switch (new_state) + { + case TNC_CONNECTION_STATE_CREATE: + state = imc_hcd_state_create(connection_id); + return imc_hcd->create_state(imc_hcd, state); + case TNC_CONNECTION_STATE_HANDSHAKE: + if (imc_hcd->change_state(imc_hcd, connection_id, new_state, + &state) != TNC_RESULT_SUCCESS) + { + return TNC_RESULT_FATAL; + } + state->set_result(state, imc_id, + TNC_IMV_EVALUATION_RESULT_DONT_KNOW); + return TNC_RESULT_SUCCESS; + case TNC_CONNECTION_STATE_DELETE: + return imc_hcd->delete_state(imc_hcd, connection_id); + default: + return imc_hcd->change_state(imc_hcd, connection_id, + new_state, NULL); + } +} + +/** + * Add AttributesNaturalLanguage attribute to send queue + */ +static void add_attrs_natural_lang(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + char *string; + + string = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.attributes_natural_language", "en", + lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_ATTRS_NATURAL_LANG, + string); + attr = generic_attr_string_create(chunk_from_str(string), + pen_type_create(PEN_PWG, PWG_HCD_ATTRS_NATURAL_LANG)); + msg->add_attribute(msg, attr); +} + +/** + * Add DefaultPasswordEnabled attribute to send queue + */ +static void add_default_pwd_enabled(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + bool status; + + status = lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.default_password_enabled", FALSE, + lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_DEFAULT_PWD_ENABLED, + status ? "yes" : "no"); + attr = generic_attr_bool_create(status, + pen_type_create(PEN_PWG, PWG_HCD_DEFAULT_PWD_ENABLED)); + msg->add_attribute(msg, attr); +} + +/** + * Add ForwardingEnabled attribute to send queue + */ +static void add_forwarding_enabled(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + bool status; + + status = lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.forwarding_enabled", FALSE, lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_FORWARDING_ENABLED, + status ? "yes" : "no"); + attr = generic_attr_bool_create(status, + pen_type_create(PEN_PWG, PWG_HCD_FORWARDING_ENABLED)); + msg->add_attribute(msg, attr); +} + +/** + * Add MachineTypeModel attribute to send queue + */ +static void add_machine_type_model(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + char *string; + + string = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.machine_type_model", "", lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_MACHINE_TYPE_MODEL, + string); + attr = generic_attr_string_create(chunk_from_str(string), + pen_type_create(PEN_PWG, PWG_HCD_MACHINE_TYPE_MODEL)); + msg->add_attribute(msg, attr); +} + +/** + * Add PSTNFaxEnabled attribute to send queue + */ +static void add_pstn_fax_enabled(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + bool status; + + status = lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.pstn_fax_enabled", FALSE, lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_PSTN_FAX_ENABLED, + status ? "yes" : "no"); + attr = generic_attr_bool_create(status, + pen_type_create(PEN_PWG, PWG_HCD_PSTN_FAX_ENABLED)); + msg->add_attribute(msg, attr); +} + +/** + * Add TimeSource attribute to send queue + */ +static void add_time_source(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + char *string; + + string = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.time_source", "", lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_TIME_SOURCE, + string); + attr = generic_attr_string_create(chunk_from_str(string), + pen_type_create(PEN_PWG, PWG_HCD_TIME_SOURCE)); + msg->add_attribute(msg, attr); +} + +/** + * Add UserApplicationEnabled attribute to send queue + */ +static void add_user_app_enabled(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + bool status; + + status = lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.user_application_enabled", FALSE, + lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_USER_APP_ENABLED, + status ? "yes" : "no"); + attr = generic_attr_bool_create(status, + pen_type_create(PEN_PWG, PWG_HCD_USER_APP_ENABLED)); + msg->add_attribute(msg, attr); +} + +/** + * Add UserApplicationPersistenceEnabled attribute to send queue + */ +static void add_user_app_persist_enabled(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + bool status; + + status = lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.user_application_persistenc.enabled", + FALSE, lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_USER_APP_PERSIST_ENABLED, + status ? "yes" : "no"); + attr = generic_attr_bool_create(status, + pen_type_create(PEN_PWG, PWG_HCD_USER_APP_PERSIST_ENABLED)); + msg->add_attribute(msg, attr); +} + +/** + * Add VendorName attribute to send queue + */ +static void add_vendor_name(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + char *string; + + string = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.vendor_name", "", lib->ns); + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, PWG_HCD_VENDOR_NAME, + string); + attr = generic_attr_string_create(chunk_from_str(string), + pen_type_create(PEN_PWG, PWG_HCD_VENDOR_NAME)); + msg->add_attribute(msg, attr); +} + +/** + * Add VendorSMICode attribute to send queue + */ +static void add_vendor_smi_code(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + int smi_code; + + smi_code = lib->settings->get_int(lib->settings, + "%s.plugins.imc-hcd.vendor_smi_code", 0, lib->ns); + DBG2(DBG_IMC, "%N: 0x%06x (%d)", pwg_attr_names, PWG_HCD_VENDOR_SMI_CODE, + smi_code, smi_code); + attr = pwg_attr_vendor_smi_code_create(smi_code); + msg->add_attribute(msg, attr); +} + +/** + * Add CertificationState attribute to send queue + */ +static void add_certification_state(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + char *hex_string; + chunk_t blob; + + hex_string = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.certification_state", NULL, lib->ns); + if (hex_string) + { + blob = chunk_from_hex(chunk_from_str(hex_string), NULL); + + DBG2(DBG_IMC, "%N: %B", pwg_attr_names, PWG_HCD_CERTIFICATION_STATE, + &blob); + attr = generic_attr_chunk_create(blob, + pen_type_create(PEN_PWG, PWG_HCD_CERTIFICATION_STATE)); + msg->add_attribute(msg, attr); + chunk_free(&blob); + } +} + +/** + * Add CertificationState attribute to send queue + */ +static void add_configuration_state(imc_msg_t *msg) +{ + pa_tnc_attr_t *attr; + char *hex_string; + chunk_t blob; + + hex_string = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.configuration_state", NULL, lib->ns); + if (hex_string) + { + blob = chunk_from_hex(chunk_from_str(hex_string), NULL); + + DBG2(DBG_IMC, "%N: %B", pwg_attr_names, PWG_HCD_CONFIGURATION_STATE, + &blob); + attr = generic_attr_chunk_create(blob, + pen_type_create(PEN_PWG, PWG_HCD_CONFIGURATION_STATE)); + msg->add_attribute(msg, attr); + chunk_free(&blob); + } +} + +/** + * Add Correlated Attributes to send queue + */ +static void add_quadruple(imc_msg_t *msg, quadruple_t *quad) +{ + pa_tnc_attr_t *attr; + const size_t version_len = 16; + char version[version_len]; + char hex_version_default[] = "00000000000000000000000000000000"; + char *app, *name, *patches, *pos, *string_version, *hex_version; + chunk_t num_version; + enumerator_t *enumerator; + + enumerator = lib->settings->create_section_enumerator(lib->settings, + "%s.plugins.imc-hcd.%s", lib->ns, quad->section); + while (enumerator->enumerate(enumerator, &app)) + { + name = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.%s.%s.name", "", + lib->ns, quad->section, app); + patches = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.%s.%s.patches", "", + lib->ns, quad->section, app); + string_version = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.%s.%s.string_version", "", + lib->ns, quad->section, app); + hex_version = lib->settings->get_str(lib->settings, + "%s.plugins.imc-hcd.%s.%s.version", hex_version_default, + lib->ns, quad->section, app); + + /* replace \n escape character by CRLF */ + pos = patches; + while (TRUE) + { + pos = strchr(pos, '\\'); + if (pos == NULL) + { + break; + } + if (pos[1] == 'n') + { + pos[0] = '\r'; + pos[1] = '\n'; + pos++; + } + pos++; + } + + /* convert hex string into binary chunk */ + if (strlen(hex_version) > 2 * version_len) + { + hex_version = hex_version_default; + } + num_version = chunk_from_hex(chunk_from_str(hex_version), version); + + DBG2(DBG_IMC, "--- %s ---", app); + + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, quad->name_attr, name); + attr = generic_attr_string_create(chunk_from_str(name), + pen_type_create(PEN_PWG, quad->name_attr)); + msg->add_attribute(msg, attr); + + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, quad->patches_attr, patches); + attr = generic_attr_string_create(chunk_from_str(patches), + pen_type_create(PEN_PWG, quad->patches_attr)); + msg->add_attribute(msg, attr); + + DBG2(DBG_IMC, "%N: %s", pwg_attr_names, quad->string_version_attr, + string_version); + attr = generic_attr_string_create(chunk_from_str(string_version), + pen_type_create(PEN_PWG, quad->string_version_attr)); + msg->add_attribute(msg, attr); + + DBG2(DBG_IMC, "%N: %#B", pwg_attr_names, quad->version_attr, &num_version); + attr = generic_attr_chunk_create(num_version, + pen_type_create(PEN_PWG, quad->version_attr)); + msg->add_attribute(msg, attr); + } + enumerator->destroy(enumerator); +} + +/** + * see section 3.8.3 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_BeginHandshake(TNC_IMCID imc_id, + TNC_ConnectionID connection_id) +{ + imc_state_t *state; + imc_msg_t *out_msg; + TNC_Result result = TNC_RESULT_SUCCESS; + int i; + + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + if (!imc_hcd->get_state(imc_hcd, connection_id, &state)) + { + return TNC_RESULT_FATAL; + } + out_msg = imc_msg_create(imc_hcd, state, connection_id, imc_id, + TNC_IMVID_ANY, msg_types[0]); + + /* mandatory attributes that are always sent without request */ + add_attrs_natural_lang(out_msg); + add_default_pwd_enabled(out_msg); + add_forwarding_enabled(out_msg); + add_machine_type_model(out_msg); + add_pstn_fax_enabled(out_msg); + add_time_source(out_msg); + add_vendor_name(out_msg); + add_vendor_smi_code(out_msg); + add_user_app_enabled(out_msg); + add_user_app_persist_enabled(out_msg); + + if (lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.push_info", FALSE, lib->ns)) + { + /* correlated attributes */ + for (i = 0; i < countof(quadruples); i++) + { + add_quadruple(out_msg, &quadruples[i]); + } + } + + /* send PA-TNC message with the excl flag not set */ + result = out_msg->send(out_msg, FALSE); + out_msg->destroy(out_msg); + + return result; +} + +static TNC_Result receive_message(imc_state_t *state, imc_msg_t *in_msg) +{ + imc_msg_t *out_msg; + enumerator_t *enumerator; + pa_tnc_attr_t *attr; + pen_type_t type; + TNC_Result result; + bool fatal_error = FALSE, pushed_info; + + /* generate an outgoing PA-TNC message - we might need it */ + out_msg = imc_msg_create_as_reply(in_msg); + + /* parse received PA-TNC message and handle local and remote errors */ + result = in_msg->receive(in_msg, out_msg, &fatal_error); + if (result != TNC_RESULT_SUCCESS) + { + out_msg->destroy(out_msg); + return result; + } + pushed_info = lib->settings->get_bool(lib->settings, + "%s.plugins.imc-hcd.push_info", FALSE, lib->ns); + + /* analyze PA-TNC attributes */ + enumerator = in_msg->create_attribute_enumerator(in_msg); + while (enumerator->enumerate(enumerator, &attr)) + { + type = attr->get_type(attr); + + if (type.vendor_id == PEN_IETF) + { + if (type.type == IETF_ATTR_ATTRIBUTE_REQUEST) + { + ietf_attr_attr_request_t *attr_cast; + pen_type_t *entry; + enumerator_t *e; + + attr_cast = (ietf_attr_attr_request_t*)attr; + + e = attr_cast->create_enumerator(attr_cast); + while (e->enumerate(e, &entry)) + { + if (entry->vendor_id == PEN_PWG) + { + switch (entry->type) + { + case PWG_HCD_ATTRS_NATURAL_LANG: + add_attrs_natural_lang(out_msg); + break; + case PWG_HCD_DEFAULT_PWD_ENABLED: + add_default_pwd_enabled(out_msg); + break; + case PWG_HCD_FORWARDING_ENABLED: + add_forwarding_enabled(out_msg); + break; + case PWG_HCD_MACHINE_TYPE_MODEL: + add_machine_type_model(out_msg); + break; + case PWG_HCD_PSTN_FAX_ENABLED: + add_pstn_fax_enabled(out_msg); + break; + case PWG_HCD_TIME_SOURCE: + add_time_source(out_msg); + break; + case PWG_HCD_USER_APP_ENABLED: + add_user_app_enabled(out_msg); + break; + case PWG_HCD_USER_APP_PERSIST_ENABLED: + add_user_app_persist_enabled(out_msg); + break; + case PWG_HCD_VENDOR_NAME: + add_vendor_name(out_msg); + break; + case PWG_HCD_VENDOR_SMI_CODE: + add_vendor_smi_code(out_msg); + break; + case PWG_HCD_CERTIFICATION_STATE: + add_certification_state(out_msg); + break; + case PWG_HCD_CONFIGURATION_STATE: + add_configuration_state(out_msg); + break; + default: + if (pushed_info) + { + continue; + } + } + + /* if not pushed, deliver on request */ + switch (entry->type) + { + case PWG_HCD_FIRMWARE_NAME: + add_quadruple(out_msg, &quadruples[0]); + break; + case PWG_HCD_RESIDENT_APP_NAME: + add_quadruple(out_msg, &quadruples[1]); + break; + case PWG_HCD_USER_APP_NAME: + add_quadruple(out_msg, &quadruples[2]); + break; + default: + break; + } + } + } + e->destroy(e); + } + } + } + enumerator->destroy(enumerator); + + if (fatal_error) + { + result = TNC_RESULT_FATAL; + } + else + { + /* send PA-TNC message with the EXCL flag set */ + result = out_msg->send(out_msg, TRUE); + } + out_msg->destroy(out_msg); + + return result; +} + +/** + * see section 3.8.4 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_ReceiveMessage(TNC_IMCID imc_id, + TNC_ConnectionID connection_id, + TNC_BufferReference msg, + TNC_UInt32 msg_len, + TNC_MessageType msg_type) +{ + imc_state_t *state; + imc_msg_t *in_msg; + TNC_Result result; + + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + if (!imc_hcd->get_state(imc_hcd, connection_id, &state)) + { + return TNC_RESULT_FATAL; + } + in_msg = imc_msg_create_from_data(imc_hcd, state, connection_id, msg_type, + chunk_create(msg, msg_len)); + result = receive_message(state, in_msg); + in_msg->destroy(in_msg); + + return result; +} + +/** + * see section 3.8.6 of TCG TNC IF-IMV Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_ReceiveMessageLong(TNC_IMCID imc_id, + TNC_ConnectionID connection_id, + TNC_UInt32 msg_flags, + TNC_BufferReference msg, + TNC_UInt32 msg_len, + TNC_VendorID msg_vid, + TNC_MessageSubtype msg_subtype, + TNC_UInt32 src_imv_id, + TNC_UInt32 dst_imc_id) +{ + imc_state_t *state; + imc_msg_t *in_msg; + TNC_Result result; + + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + if (!imc_hcd->get_state(imc_hcd, connection_id, &state)) + { + return TNC_RESULT_FATAL; + } + in_msg = imc_msg_create_from_long_data(imc_hcd, state, connection_id, + src_imv_id, dst_imc_id,msg_vid, msg_subtype, + chunk_create(msg, msg_len)); + result =receive_message(state, in_msg); + in_msg->destroy(in_msg); + + return result; +} + +/** + * see section 3.8.7 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_BatchEnding(TNC_IMCID imc_id, + TNC_ConnectionID connection_id) +{ + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + return TNC_RESULT_SUCCESS; +} + +/** + * see section 3.8.8 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_Terminate(TNC_IMCID imc_id) +{ + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + imc_hcd->destroy(imc_hcd); + imc_hcd = NULL; + + return TNC_RESULT_SUCCESS; +} + +/** + * see section 4.2.8.1 of TCG TNC IF-IMC Specification 1.3 + */ +TNC_Result TNC_IMC_API TNC_IMC_ProvideBindFunction(TNC_IMCID imc_id, + TNC_TNCC_BindFunctionPointer bind_function) +{ + if (!imc_hcd) + { + DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name); + return TNC_RESULT_NOT_INITIALIZED; + } + return imc_hcd->bind_functions(imc_hcd, bind_function); +} diff --git a/src/libimcv/plugins/imc_hcd/imc_hcd_state.c b/src/libimcv/plugins/imc_hcd/imc_hcd_state.c new file mode 100644 index 000000000..ce93d7ef7 --- /dev/null +++ b/src/libimcv/plugins/imc_hcd/imc_hcd_state.c @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +#include "imc_hcd_state.h" + +#include <tncif_names.h> + +#include <utils/debug.h> + +typedef struct private_imc_hcd_state_t private_imc_hcd_state_t; + +/** + * Private data of an imc_hcd_state_t object. + */ +struct private_imc_hcd_state_t { + + /** + * Public members of imc_hcd_state_t + */ + imc_hcd_state_t public; + + /** + * TNCCS connection ID + */ + TNC_ConnectionID connection_id; + + /** + * TNCCS connection state + */ + TNC_ConnectionState state; + + /** + * Assessment/Evaluation Result + */ + TNC_IMV_Evaluation_Result result; + + /** + * Does the TNCCS connection support long message types? + */ + bool has_long; + + /** + * Does the TNCCS connection support exclusive delivery? + */ + bool has_excl; + + /** + * Maximum PA-TNC message size for this TNCCS connection + */ + u_int32_t max_msg_len; + + /** + * PA-TNC attribute segmentation contracts associated with TNCCS connection + */ + seg_contract_manager_t *contracts; +}; + +METHOD(imc_state_t, get_connection_id, TNC_ConnectionID, + private_imc_hcd_state_t *this) +{ + return this->connection_id; +} + +METHOD(imc_state_t, has_long, bool, + private_imc_hcd_state_t *this) +{ + return this->has_long; +} + +METHOD(imc_state_t, has_excl, bool, + private_imc_hcd_state_t *this) +{ + return this->has_excl; +} + +METHOD(imc_state_t, set_flags, void, + private_imc_hcd_state_t *this, bool has_long, bool has_excl) +{ + this->has_long = has_long; + this->has_excl = has_excl; +} + +METHOD(imc_state_t, set_max_msg_len, void, + private_imc_hcd_state_t *this, u_int32_t max_msg_len) +{ + this->max_msg_len = max_msg_len; +} + +METHOD(imc_state_t, get_max_msg_len, u_int32_t, + private_imc_hcd_state_t *this) +{ + return this->max_msg_len; +} + +METHOD(imc_state_t, get_contracts, seg_contract_manager_t*, + private_imc_hcd_state_t *this) +{ + return this->contracts; +} + +METHOD(imc_state_t, change_state, void, + private_imc_hcd_state_t *this, TNC_ConnectionState new_state) +{ + this->state = new_state; +} + +METHOD(imc_state_t, set_result, void, + private_imc_hcd_state_t *this, TNC_IMCID id, + TNC_IMV_Evaluation_Result result) +{ + this->result = result; +} + +METHOD(imc_state_t, get_result, bool, + private_imc_hcd_state_t *this, TNC_IMCID id, + TNC_IMV_Evaluation_Result *result) +{ + if (result) + { + *result = this->result; + } + return this->result != TNC_IMV_EVALUATION_RESULT_DONT_KNOW; +} + +METHOD(imc_state_t, destroy, void, + private_imc_hcd_state_t *this) +{ + this->contracts->destroy(this->contracts); + free(this); +} + +/** + * Described in header. + */ +imc_state_t *imc_hcd_state_create(TNC_ConnectionID connection_id) +{ + private_imc_hcd_state_t *this; + + INIT(this, + .public = { + .interface = { + .get_connection_id = _get_connection_id, + .has_long = _has_long, + .has_excl = _has_excl, + .set_flags = _set_flags, + .set_max_msg_len = _set_max_msg_len, + .get_max_msg_len = _get_max_msg_len, + .get_contracts = _get_contracts, + .change_state = _change_state, + .set_result = _set_result, + .get_result = _get_result, + .destroy = _destroy, + }, + }, + .state = TNC_CONNECTION_STATE_CREATE, + .result = TNC_IMV_EVALUATION_RESULT_DONT_KNOW, + .connection_id = connection_id, + .contracts = seg_contract_manager_create(), + ); + + return &this->public.interface; +} + + diff --git a/src/libimcv/plugins/imc_hcd/imc_hcd_state.h b/src/libimcv/plugins/imc_hcd/imc_hcd_state.h new file mode 100644 index 000000000..dbd5ddb4f --- /dev/null +++ b/src/libimcv/plugins/imc_hcd/imc_hcd_state.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +/** + * @defgroup imc_hcd imc_hcd + * @ingroup libimcv_plugins + * + * @defgroup imc_hcd_state_t imc_hcd_state + * @{ @ingroup imc_hcd + */ + +#ifndef IMC_HCD_STATE_H_ +#define IMC_HCD_STATE_H_ + +#include <imc/imc_state.h> +#include <library.h> + +typedef struct imc_hcd_state_t imc_hcd_state_t; + +/** + * Internal state of an imc_hcd_t connection instance + */ +struct imc_hcd_state_t { + + /** + * imc_state_t interface + */ + imc_state_t interface; +}; + +/** + * Create an imc_hcd_state_t instance + * + * @param id connection ID + */ +imc_state_t* imc_hcd_state_create(TNC_ConnectionID id); + +#endif /** IMC_HCD_STATE_H_ @}*/ diff --git a/src/libimcv/plugins/imv_hcd/Makefile.am b/src/libimcv/plugins/imv_hcd/Makefile.am new file mode 100644 index 000000000..28926d45e --- /dev/null +++ b/src/libimcv/plugins/imv_hcd/Makefile.am @@ -0,0 +1,18 @@ +AM_CPPFLAGS = \ + -I$(top_srcdir)/src/libstrongswan \ + -I$(top_srcdir)/src/libtncif \ + -I$(top_srcdir)/src/libimcv + +AM_CFLAGS = \ + $(PLUGIN_CFLAGS) + +imcv_LTLIBRARIES = imv-hcd.la + +imv_hcd_la_LIBADD = $(top_builddir)/src/libimcv/libimcv.la \ + $(top_builddir)/src/libstrongswan/libstrongswan.la + +imv_hcd_la_SOURCES = \ + imv_hcd.c imv_hcd_state.h imv_hcd_state.c \ + imv_hcd_agent.h imv_hcd_agent.c + +imv_hcd_la_LDFLAGS = -module -avoid-version -no-undefined diff --git a/src/libimcv/plugins/imv_hcd/imv_hcd.c b/src/libimcv/plugins/imv_hcd/imv_hcd.c new file mode 100644 index 000000000..f32095217 --- /dev/null +++ b/src/libimcv/plugins/imv_hcd/imv_hcd.c @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +#include "imv_hcd_agent.h" + +static const char imv_name[] = "HCD"; +static const imv_agent_create_t imv_agent_create = imv_hcd_agent_create; + +/* include generic TGC TNC IF-IMV API code below */ + +#include <imv/imv_if.h> + diff --git a/src/libimcv/plugins/imv_hcd/imv_hcd_agent.c b/src/libimcv/plugins/imv_hcd/imv_hcd_agent.c new file mode 100644 index 000000000..7143f2414 --- /dev/null +++ b/src/libimcv/plugins/imv_hcd/imv_hcd_agent.c @@ -0,0 +1,566 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +#define _GNU_SOURCE +#include <stdio.h> + +#include "imv_hcd_agent.h" +#include "imv_hcd_state.h" + +#include <imcv.h> +#include <imv/imv_agent.h> +#include <imv/imv_msg.h> +#include <generic/generic_attr_bool.h> +#include <generic/generic_attr_chunk.h> +#include <generic/generic_attr_string.h> +#include <ietf/ietf_attr.h> +#include <ietf/ietf_attr_attr_request.h> +#include <pwg/pwg_attr.h> +#include <pwg/pwg_attr_vendor_smi_code.h> +#include "tcg/seg/tcg_seg_attr_max_size.h" +#include "tcg/seg/tcg_seg_attr_seg_env.h" + +#include <tncif_names.h> +#include <tncif_pa_subtypes.h> + +#include <pen/pen.h> +#include <utils/debug.h> + +#define HCD_MAX_ATTR_SIZE 10000000 + +typedef struct private_imv_hcd_agent_t private_imv_hcd_agent_t; +typedef enum imv_hcd_attr_t imv_hcd_attr_t; + +/* Subscribed PA-TNC message subtypes */ +static pen_type_t msg_types[] = { + { PEN_PWG, PA_SUBTYPE_PWG_HCD } +}; + +/** + * Flag set when corresponding attribute has been received + */ +enum imv_hcd_attr_t { + IMV_HCD_ATTR_NONE = 0, + IMV_HCD_ATTR_NATURAL_LANG = (1<<0), + IMV_HCD_ATTR_DEFAULT_PWD_ENABLED = (1<<1), + IMV_HCD_ATTR_FIREWALL_SETTING = (1<<2), + IMV_HCD_ATTR_FIRMWARE_NAME = (1<<3), + IMV_HCD_ATTR_FORWARDING_ENABLED = (1<<4), + IMV_HCD_ATTR_MACHINE_TYPE_MODEL = (1<<5), + IMV_HCD_ATTR_PSTN_FAX_ENABLED = (1<<6), + IMV_HCD_ATTR_RESIDENT_APP_NAME = (1<<7), + IMV_HCD_ATTR_TIME_SOURCE = (1<<8), + IMV_HCD_ATTR_USER_APP_ENABLED = (1<<9), + IMV_HCD_ATTR_USER_APP_PERSIST_ENABLED = (1<<10), + IMV_HCD_ATTR_USER_APP_NAME = (1<<11), + IMV_HCD_ATTR_VENDOR_NAME = (1<<12), + IMV_HCD_ATTR_VENDOR_SMI_CODE = (1<<13), + IMV_HCD_ATTR_MUST = (1<<14)-1 +}; + +static imv_hcd_attr_t attr_type_to_flag(pwg_attr_t attr_type) +{ + switch (attr_type) + { + case PWG_HCD_ATTRS_NATURAL_LANG: + return IMV_HCD_ATTR_NATURAL_LANG; + case PWG_HCD_DEFAULT_PWD_ENABLED: + return IMV_HCD_ATTR_DEFAULT_PWD_ENABLED; + case PWG_HCD_FIREWALL_SETTING: + return IMV_HCD_ATTR_FIREWALL_SETTING; + case PWG_HCD_FIRMWARE_NAME: + return IMV_HCD_ATTR_FIRMWARE_NAME; + case PWG_HCD_FORWARDING_ENABLED: + return IMV_HCD_ATTR_FORWARDING_ENABLED; + case PWG_HCD_MACHINE_TYPE_MODEL: + return IMV_HCD_ATTR_MACHINE_TYPE_MODEL; + case PWG_HCD_PSTN_FAX_ENABLED: + return IMV_HCD_ATTR_PSTN_FAX_ENABLED; + case PWG_HCD_RESIDENT_APP_NAME: + return IMV_HCD_ATTR_RESIDENT_APP_NAME; + case PWG_HCD_TIME_SOURCE: + return IMV_HCD_ATTR_TIME_SOURCE; + case PWG_HCD_USER_APP_ENABLED: + return IMV_HCD_ATTR_USER_APP_ENABLED; + case PWG_HCD_USER_APP_PERSIST_ENABLED: + return IMV_HCD_ATTR_USER_APP_PERSIST_ENABLED; + case PWG_HCD_USER_APP_NAME: + return IMV_HCD_ATTR_USER_APP_NAME; + case PWG_HCD_VENDOR_NAME: + return IMV_HCD_ATTR_VENDOR_NAME; + case PWG_HCD_VENDOR_SMI_CODE: + return IMV_HCD_ATTR_VENDOR_SMI_CODE; + default: + return IMV_HCD_ATTR_NONE; + } +} + +/** + * Private data of an imv_hcd_agent_t object. + */ +struct private_imv_hcd_agent_t { + + /** + * Public members of imv_hcd_agent_t + */ + imv_agent_if_t public; + + /** + * IMV agent responsible for generic functions + */ + imv_agent_t *agent; + +}; + +METHOD(imv_agent_if_t, bind_functions, TNC_Result, + private_imv_hcd_agent_t *this, TNC_TNCS_BindFunctionPointer bind_function) +{ + return this->agent->bind_functions(this->agent, bind_function); +} + +METHOD(imv_agent_if_t, notify_connection_change, TNC_Result, + private_imv_hcd_agent_t *this, TNC_ConnectionID id, + TNC_ConnectionState new_state) +{ + TNC_IMV_Action_Recommendation rec; + imv_state_t *state; + imv_session_t *session; + + switch (new_state) + { + case TNC_CONNECTION_STATE_CREATE: + state = imv_hcd_state_create(id); + return this->agent->create_state(this->agent, state); + case TNC_CONNECTION_STATE_DELETE: + return this->agent->delete_state(this->agent, id); + case TNC_CONNECTION_STATE_ACCESS_ALLOWED: + case TNC_CONNECTION_STATE_ACCESS_ISOLATED: + case TNC_CONNECTION_STATE_ACCESS_NONE: + if (this->agent->get_state(this->agent, id, &state) && imcv_db) + { + session = state->get_session(state); + + if (session->get_policy_started(session)) + { + switch (new_state) + { + case TNC_CONNECTION_STATE_ACCESS_ALLOWED: + rec = TNC_IMV_ACTION_RECOMMENDATION_ALLOW; + break; + case TNC_CONNECTION_STATE_ACCESS_ISOLATED: + rec = TNC_IMV_ACTION_RECOMMENDATION_ISOLATE; + break; + case TNC_CONNECTION_STATE_ACCESS_NONE: + default: + rec = TNC_IMV_ACTION_RECOMMENDATION_NO_ACCESS; + } + imcv_db->add_recommendation(imcv_db, session, rec); + if (!imcv_db->policy_script(imcv_db, session, FALSE)) + { + DBG1(DBG_IMV, "error in policy script stop"); + } + } + } + /* fall through to default state */ + default: + return this->agent->change_state(this->agent, id, new_state, NULL); + } +} + +/** + * Process a received message + */ +static TNC_Result receive_msg(private_imv_hcd_agent_t *this, imv_state_t *state, + imv_msg_t *in_msg) +{ + imv_msg_t *out_msg; + imv_hcd_state_t *hcd_state; + pa_tnc_attr_t *attr; + pen_type_t type; + TNC_Result result; + bool fatal_error = FALSE, assessment = FALSE; + enumerator_t *enumerator; + + hcd_state = (imv_hcd_state_t*)state; + + /* generate an outgoing PA-TNC message - we might need it */ + out_msg = imv_msg_create_as_reply(in_msg); + + /* parse received PA-TNC message and handle local and remote errors */ + result = in_msg->receive(in_msg,out_msg, &fatal_error); + if (result != TNC_RESULT_SUCCESS) + { + out_msg->destroy(out_msg); + return result; + } + + /* analyze PA-TNC attributes */ + enumerator = in_msg->create_attribute_enumerator(in_msg); + while (enumerator->enumerate(enumerator, &attr)) + { + type = attr->get_type(attr); + + if (type.vendor_id == PEN_PWG) + { + state->set_action_flags(state, attr_type_to_flag(type.type)); + + switch (type.type) + { + case PWG_HCD_ATTRS_NATURAL_LANG: + case PWG_HCD_MACHINE_TYPE_MODEL: + case PWG_HCD_VENDOR_NAME: + case PWG_HCD_TIME_SOURCE: + case PWG_HCD_FIRMWARE_NAME: + case PWG_HCD_FIRMWARE_PATCHES: + case PWG_HCD_FIRMWARE_STRING_VERSION: + case PWG_HCD_RESIDENT_APP_NAME: + case PWG_HCD_RESIDENT_APP_PATCHES: + case PWG_HCD_RESIDENT_APP_STRING_VERSION: + case PWG_HCD_USER_APP_NAME: + case PWG_HCD_USER_APP_PATCHES: + case PWG_HCD_USER_APP_STRING_VERSION: + { + chunk_t value; + + value = attr->get_value(attr); + DBG2(DBG_IMV, "%N: %.*s", pwg_attr_names, type.type, + value.len, value.ptr); + break; + } + case PWG_HCD_FIRMWARE_VERSION: + case PWG_HCD_RESIDENT_APP_VERSION: + case PWG_HCD_USER_APP_VERSION: + { + chunk_t value; + + value = attr->get_value(attr); + DBG2(DBG_IMV, "%N: %#B", pwg_attr_names, type.type, &value); + break; + } + case PWG_HCD_CERTIFICATION_STATE: + case PWG_HCD_CONFIGURATION_STATE: + { + chunk_t value; + + value = attr->get_value(attr); + DBG2(DBG_IMV, "%N: %B", pwg_attr_names, type.type, &value); + break; + } + case PWG_HCD_DEFAULT_PWD_ENABLED: + case PWG_HCD_FORWARDING_ENABLED: + case PWG_HCD_PSTN_FAX_ENABLED: + case PWG_HCD_USER_APP_ENABLED: + case PWG_HCD_USER_APP_PERSIST_ENABLED: + { + generic_attr_bool_t *attr_cast; + bool status; + + attr_cast = (generic_attr_bool_t*)attr; + status = attr_cast->get_status(attr_cast); + DBG2(DBG_IMV, "%N: %s", pwg_attr_names, type.type, + status ? "yes" : "no"); + + if (type.type == PWG_HCD_USER_APP_ENABLED && !status) + { + /* do not request user applications */ + state->set_action_flags(state, + IMV_HCD_ATTR_USER_APP_NAME); + } + break; + } + case PWG_HCD_VENDOR_SMI_CODE: + { + pwg_attr_vendor_smi_code_t *attr_cast; + uint32_t smi_code; + + attr_cast = (pwg_attr_vendor_smi_code_t*)attr; + smi_code = attr_cast->get_vendor_smi_code(attr_cast); + DBG2(DBG_IMV, "%N: 0x%06x (%u)", pwg_attr_names, type.type, + smi_code, smi_code); + break; + } + default: + break; + } + } + } + enumerator->destroy(enumerator); + + if (fatal_error) + { + state->set_recommendation(state, + TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION, + TNC_IMV_EVALUATION_RESULT_ERROR); + assessment = TRUE; + } + + if (assessment) + { + hcd_state->set_handshake_state(hcd_state, IMV_HCD_STATE_END); + result = out_msg->send_assessment(out_msg); + if (result == TNC_RESULT_SUCCESS) + { + result = this->agent->provide_recommendation(this->agent, state); + } + } + else + { + /* send PA-TNC message with the EXCL flag set */ + result = out_msg->send(out_msg, TRUE); + } + out_msg->destroy(out_msg); + + return result; +} + +METHOD(imv_agent_if_t, receive_message, TNC_Result, + private_imv_hcd_agent_t *this, TNC_ConnectionID id, + TNC_MessageType msg_type, chunk_t msg) +{ + imv_state_t *state; + imv_msg_t *in_msg; + TNC_Result result; + + if (!this->agent->get_state(this->agent, id, &state)) + { + return TNC_RESULT_FATAL; + } + in_msg = imv_msg_create_from_data(this->agent, state, id, msg_type, msg); + result = receive_msg(this, state, in_msg); + in_msg->destroy(in_msg); + + return result; +} + +METHOD(imv_agent_if_t, receive_message_long, TNC_Result, + private_imv_hcd_agent_t *this, TNC_ConnectionID id, + TNC_UInt32 src_imc_id, TNC_UInt32 dst_imv_id, + TNC_VendorID msg_vid, TNC_MessageSubtype msg_subtype, chunk_t msg) +{ + imv_state_t *state; + imv_msg_t *in_msg; + TNC_Result result; + + if (!this->agent->get_state(this->agent, id, &state)) + { + return TNC_RESULT_FATAL; + } + in_msg = imv_msg_create_from_long_data(this->agent, state, id, + src_imc_id, dst_imv_id, msg_vid, msg_subtype, msg); + result = receive_msg(this, state, in_msg); + in_msg->destroy(in_msg); + + return result; + +} + +/** + * Build an IETF Attribute Request attribute for missing attributes + */ +static pa_tnc_attr_t* build_attr_request(uint32_t received) +{ + pa_tnc_attr_t *attr; + ietf_attr_attr_request_t *attr_cast; + + attr = ietf_attr_attr_request_create(PEN_RESERVED, 0); + attr_cast = (ietf_attr_attr_request_t*)attr; + + if (!(received & IMV_HCD_ATTR_NATURAL_LANG)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_ATTRS_NATURAL_LANG); + } + if (!(received & IMV_HCD_ATTR_DEFAULT_PWD_ENABLED)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_DEFAULT_PWD_ENABLED); + } + if (!(received & IMV_HCD_ATTR_FIREWALL_SETTING)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_FIREWALL_SETTING); + } + if (!(received & IMV_HCD_ATTR_FIRMWARE_NAME)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_FIRMWARE_NAME); + } + if (!(received & IMV_HCD_ATTR_FORWARDING_ENABLED)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_FORWARDING_ENABLED); + } + if (!(received & IMV_HCD_ATTR_MACHINE_TYPE_MODEL)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_MACHINE_TYPE_MODEL); + } + if (!(received & IMV_HCD_ATTR_PSTN_FAX_ENABLED)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_PSTN_FAX_ENABLED); + } + if (!(received & IMV_HCD_ATTR_RESIDENT_APP_NAME)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_RESIDENT_APP_NAME); + } + if (!(received & IMV_HCD_ATTR_TIME_SOURCE)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_TIME_SOURCE); + } + if (!(received & IMV_HCD_ATTR_USER_APP_ENABLED)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_USER_APP_ENABLED); + } + if (!(received & IMV_HCD_ATTR_USER_APP_PERSIST_ENABLED)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_USER_APP_PERSIST_ENABLED); + } + if (!(received & IMV_HCD_ATTR_USER_APP_NAME)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_USER_APP_NAME); + } + if (!(received & IMV_HCD_ATTR_VENDOR_NAME)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_VENDOR_NAME); + } + if (!(received & IMV_HCD_ATTR_VENDOR_SMI_CODE)) + { + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_VENDOR_SMI_CODE); + } + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_CERTIFICATION_STATE); + attr_cast->add(attr_cast, PEN_PWG, PWG_HCD_CONFIGURATION_STATE); + + return attr; +} + +METHOD(imv_agent_if_t, batch_ending, TNC_Result, + private_imv_hcd_agent_t *this, TNC_ConnectionID id) +{ + imv_msg_t *out_msg; + imv_state_t *state; + imv_hcd_state_t *hcd_state; + imv_hcd_handshake_state_t handshake_state; + pa_tnc_attr_t *attr; + TNC_IMVID imv_id; + TNC_Result result = TNC_RESULT_SUCCESS; + uint32_t received; + + if (!this->agent->get_state(this->agent, id, &state)) + { + return TNC_RESULT_FATAL; + } + hcd_state = (imv_hcd_state_t*)state; + handshake_state = hcd_state->get_handshake_state(hcd_state); + received = state->get_action_flags(state); + imv_id = this->agent->get_id(this->agent); + + if (handshake_state == IMV_HCD_STATE_END) + { + return TNC_RESULT_SUCCESS; + } + + /* create an empty out message - we might need it */ + out_msg = imv_msg_create(this->agent, state, id, imv_id, TNC_IMCID_ANY, + msg_types[0]); + + if (handshake_state == IMV_HCD_STATE_INIT) + { + size_t max_attr_size = HCD_MAX_ATTR_SIZE; + size_t max_seg_size; + seg_contract_t *contract; + seg_contract_manager_t *contracts; + char buf[BUF_LEN]; + + /* Determine maximum PA-TNC attribute segment size */ + max_seg_size = state->get_max_msg_len(state) + - PA_TNC_HEADER_SIZE + - PA_TNC_ATTR_HEADER_SIZE + - TCG_SEG_ATTR_SEG_ENV_HEADER + - PA_TNC_ATTR_HEADER_SIZE + - TCG_SEG_ATTR_MAX_SIZE_SIZE; + + /* Announce support of PA-TNC segmentation to IMC */ + contract = seg_contract_create(msg_types[0], max_attr_size, + max_seg_size, TRUE, imv_id, FALSE); + contract->get_info_string(contract, buf, BUF_LEN, TRUE); + DBG2(DBG_IMV, "%s", buf); + contracts = state->get_contracts(state); + contracts->add_contract(contracts, contract); + attr = tcg_seg_attr_max_size_create(max_attr_size, max_seg_size, TRUE); + out_msg->add_attribute(out_msg, attr); + + if ((received & IMV_HCD_ATTR_MUST) != IMV_HCD_ATTR_MUST) + { + /* create attribute request for missing mandatory attributes */ + out_msg->add_attribute(out_msg, build_attr_request(received)); + } + hcd_state->set_handshake_state(hcd_state, IMV_HCD_STATE_ATTR_REQ); + } + + /* send non-empty PA-TNC message with excl flag not set */ + if (out_msg->get_attribute_count(out_msg)) + { + result = out_msg->send(out_msg, FALSE); + } + out_msg->destroy(out_msg); + + return result; +} + +METHOD(imv_agent_if_t, solicit_recommendation, TNC_Result, + private_imv_hcd_agent_t *this, TNC_ConnectionID id) +{ + imv_state_t *state; + + if (!this->agent->get_state(this->agent, id, &state)) + { + return TNC_RESULT_FATAL; + } + return this->agent->provide_recommendation(this->agent, state); +} + +METHOD(imv_agent_if_t, destroy, void, + private_imv_hcd_agent_t *this) +{ + DESTROY_IF(this->agent); + free(this); +} + +/** + * Described in header. + */ +imv_agent_if_t *imv_hcd_agent_create(const char *name, TNC_IMVID id, + TNC_Version *actual_version) +{ + private_imv_hcd_agent_t *this; + imv_agent_t *agent; + + agent = imv_agent_create(name, msg_types, countof(msg_types), id, + actual_version); + if (!agent) + { + return NULL; + } + + INIT(this, + .public = { + .bind_functions = _bind_functions, + .notify_connection_change = _notify_connection_change, + .receive_message = _receive_message, + .receive_message_long = _receive_message_long, + .batch_ending = _batch_ending, + .solicit_recommendation = _solicit_recommendation, + .destroy = _destroy, + }, + .agent = agent, + ); + + return &this->public; +} + diff --git a/src/libimcv/plugins/imv_hcd/imv_hcd_agent.h b/src/libimcv/plugins/imv_hcd/imv_hcd_agent.h new file mode 100644 index 000000000..d4e2e3f0e --- /dev/null +++ b/src/libimcv/plugins/imv_hcd/imv_hcd_agent.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +/** + * @defgroup imv_hcd_agent_t imv_hcd_agent + * @{ @ingroup imv_hcd + */ + +#ifndef IMV_HCD_AGENT_H_ +#define IMV_HCD_AGENT_H_ + +#include <imv/imv_agent_if.h> + +/** + * Creates a HCD IMV agent + * + * @param name Name of the IMV + * @param id ID of the IMV + * @param actual_version TNC IF-IMV version + */ +imv_agent_if_t* imv_hcd_agent_create(const char* name, TNC_IMVID id, + TNC_Version *actual_version); + +#endif /** IMV_HCD_AGENT_H_ @}*/ diff --git a/src/libimcv/plugins/imv_hcd/imv_hcd_state.c b/src/libimcv/plugins/imv_hcd/imv_hcd_state.c new file mode 100644 index 000000000..69cb3753e --- /dev/null +++ b/src/libimcv/plugins/imv_hcd/imv_hcd_state.c @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +#include "imv_hcd_state.h" + +#include <tncif_policy.h> + +#include <utils/debug.h> + +typedef struct private_imv_hcd_state_t private_imv_hcd_state_t; + +/** + * Private data of an imv_hcd_state_t object. + */ +struct private_imv_hcd_state_t { + + /** + * Public members of imv_hcd_state_t + */ + imv_hcd_state_t public; + + /** + * TNCCS connection ID + */ + TNC_ConnectionID connection_id; + + /** + * TNCCS connection state + */ + TNC_ConnectionState state; + + /** + * Does the TNCCS connection support long message types? + */ + bool has_long; + + /** + * Does the TNCCS connection support exclusive delivery? + */ + bool has_excl; + + /** + * Maximum PA-TNC message size for this TNCCS connection + */ + uint32_t max_msg_len; + + /** + * Flags set for completed actions + */ + uint32_t action_flags; + + /** + * IMV database session associated with TNCCS connection + */ + imv_session_t *session; + + /** + * PA-TNC attribute segmentation contracts associated with TNCCS connection + */ + seg_contract_manager_t *contracts; + + /** + * IMV action recommendation + */ + TNC_IMV_Action_Recommendation rec; + + /** + * IMV evaluation result + */ + TNC_IMV_Evaluation_Result eval; + + /** + * IMV OS handshake state + */ + imv_hcd_handshake_state_t handshake_state; + +}; + +METHOD(imv_state_t, get_connection_id, TNC_ConnectionID, + private_imv_hcd_state_t *this) +{ + return this->connection_id; +} + +METHOD(imv_state_t, has_long, bool, + private_imv_hcd_state_t *this) +{ + return this->has_long; +} + +METHOD(imv_state_t, has_excl, bool, + private_imv_hcd_state_t *this) +{ + return this->has_excl; +} + +METHOD(imv_state_t, set_flags, void, + private_imv_hcd_state_t *this, bool has_long, bool has_excl) +{ + this->has_long = has_long; + this->has_excl = has_excl; +} + +METHOD(imv_state_t, set_max_msg_len, void, + private_imv_hcd_state_t *this, uint32_t max_msg_len) +{ + this->max_msg_len = max_msg_len; +} + +METHOD(imv_state_t, get_max_msg_len, uint32_t, + private_imv_hcd_state_t *this) +{ + return this->max_msg_len; +} + +METHOD(imv_state_t, set_action_flags, void, + private_imv_hcd_state_t *this, uint32_t flags) +{ + this->action_flags |= flags; +} + +METHOD(imv_state_t, get_action_flags, uint32_t, + private_imv_hcd_state_t *this) +{ + return this->action_flags; +} + +METHOD(imv_state_t, set_session, void, + private_imv_hcd_state_t *this, imv_session_t *session) +{ + this->session = session; +} + +METHOD(imv_state_t, get_session, imv_session_t*, + private_imv_hcd_state_t *this) +{ + return this->session; +} + +METHOD(imv_state_t, get_contracts, seg_contract_manager_t*, + private_imv_hcd_state_t *this) +{ + return this->contracts; +} + +METHOD(imv_state_t, get_recommendation, void, + private_imv_hcd_state_t *this, TNC_IMV_Action_Recommendation *rec, + TNC_IMV_Evaluation_Result *eval) +{ + *rec = this->rec; + *eval = this->eval; +} + +METHOD(imv_state_t, set_recommendation, void, + private_imv_hcd_state_t *this, TNC_IMV_Action_Recommendation rec, + TNC_IMV_Evaluation_Result eval) +{ + this->rec = rec; + this->eval = eval; +} + +METHOD(imv_state_t, update_recommendation, void, + private_imv_hcd_state_t *this, TNC_IMV_Action_Recommendation rec, + TNC_IMV_Evaluation_Result eval) +{ + this->rec = tncif_policy_update_recommendation(this->rec, rec); + this->eval = tncif_policy_update_evaluation(this->eval, eval); +} + +METHOD(imv_state_t, change_state, void, + private_imv_hcd_state_t *this, TNC_ConnectionState new_state) +{ + this->state = new_state; +} + +METHOD(imv_state_t, get_reason_string, bool, + private_imv_hcd_state_t *this, enumerator_t *language_enumerator, + chunk_t *reason_string, char **reason_language) +{ + return FALSE; +} + +METHOD(imv_state_t, get_remediation_instructions, bool, + private_imv_hcd_state_t *this, enumerator_t *language_enumerator, + chunk_t *string, char **lang_code, char **uri) +{ + return FALSE; +} + +METHOD(imv_state_t, destroy, void, + private_imv_hcd_state_t *this) +{ + DESTROY_IF(this->session); + this->contracts->destroy(this->contracts); + free(this); +} + +METHOD(imv_hcd_state_t, set_handshake_state, void, + private_imv_hcd_state_t *this, imv_hcd_handshake_state_t new_state) +{ + this->handshake_state = new_state; +} + +METHOD(imv_hcd_state_t, get_handshake_state, imv_hcd_handshake_state_t, + private_imv_hcd_state_t *this) +{ + return this->handshake_state; +} + +/** + * Described in header. + */ +imv_state_t *imv_hcd_state_create(TNC_ConnectionID connection_id) +{ + private_imv_hcd_state_t *this; + + INIT(this, + .public = { + .interface = { + .get_connection_id = _get_connection_id, + .has_long = _has_long, + .has_excl = _has_excl, + .set_flags = _set_flags, + .set_max_msg_len = _set_max_msg_len, + .get_max_msg_len = _get_max_msg_len, + .set_action_flags = _set_action_flags, + .get_action_flags = _get_action_flags, + .set_session = _set_session, + .get_session = _get_session, + .get_contracts = _get_contracts, + .change_state = _change_state, + .get_recommendation = _get_recommendation, + .set_recommendation = _set_recommendation, + .update_recommendation = _update_recommendation, + .get_reason_string = _get_reason_string, + .get_remediation_instructions = _get_remediation_instructions, + .destroy = _destroy, + }, + .set_handshake_state = _set_handshake_state, + .get_handshake_state = _get_handshake_state, + }, + .state = TNC_CONNECTION_STATE_CREATE, + .rec = TNC_IMV_ACTION_RECOMMENDATION_NO_RECOMMENDATION, + .eval = TNC_IMV_EVALUATION_RESULT_DONT_KNOW, + .connection_id = connection_id, + .contracts = seg_contract_manager_create(), + ); + + return &this->public.interface; +} + + diff --git a/src/libimcv/plugins/imv_hcd/imv_hcd_state.h b/src/libimcv/plugins/imv_hcd/imv_hcd_state.h new file mode 100644 index 000000000..2b1c02c23 --- /dev/null +++ b/src/libimcv/plugins/imv_hcd/imv_hcd_state.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2015 Andreas Steffen + * HSR Hochschule fuer Technik Rapperswil + * + * 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. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * 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. + */ + +/** + * @defgroup imv_hcd imv_hcd + * @ingroup libimcv_plugins + * + * @defgroup imv_hcd_state_t imv_hcd_state + * @{ @ingroup imv_hcd + */ + +#ifndef IMV_HCD_STATE_H_ +#define IMV_HCD_STATE_H_ + +#include <imv/imv_state.h> +#include <library.h> + +typedef struct imv_hcd_state_t imv_hcd_state_t; +typedef enum imv_hcd_handshake_state_t imv_hcd_handshake_state_t; +typedef enum os_settings_t os_settings_t; + +/** + * IMV OS Handshake States (state machine) + */ +enum imv_hcd_handshake_state_t { + IMV_HCD_STATE_INIT, + IMV_HCD_STATE_ATTR_REQ, + IMV_HCD_STATE_END +}; + +/** + * Internal state of an imv_hcd_t connection instance + */ +struct imv_hcd_state_t { + + /** + * imv_state_t interface + */ + imv_state_t interface; + + /** + * Set state of the handshake + * + * @param new_state the handshake state of IMV + */ + void (*set_handshake_state)(imv_hcd_state_t *this, + imv_hcd_handshake_state_t new_state); + + /** + * Get state of the handshake + * + * @return the handshake state of IMV + */ + imv_hcd_handshake_state_t (*get_handshake_state)(imv_hcd_state_t *this); + +}; + +/** + * Create an imv_hcd_state_t instance + * + * @param id connection ID + */ +imv_state_t* imv_hcd_state_create(TNC_ConnectionID id); + +#endif /** IMV_HCD_STATE_H_ @}*/ |