Commit 05c07ab5 authored by Yann Garcia's avatar Yann Garcia
Browse files

Validate TC_SECPKI_EA_BFK_AUTH_01_BV

parent 9b48588f

ccsrc/EncDec/LibItsPki_Encdec.cc

+28 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
#include "etsi_ts102941_types_enrolment_inner_response.hh"

#include "ieee_1609dot2_base_types_public_encryption_key.hh"

#include "ieee_1609dot2_base_types_public_verification_key.hh"

#include "etsi_ts102941_types_ra_ee_cert_info.hh"



#include "etsi_ts102941_trust_lists_ctl_format.hh"
@@ -260,6 +261,33 @@ namespace LibItsPki__EncdecDeclarations { 
    return 0;

  }



  BITSTRING fx__enc__RaEeCertInfo(Ieee1609Dot2Dot1EeRaInterface::RaEeCertInfo const &p_ra_ee_cert_info) {

    loggers::get_instance().log_msg(">>> fx__enc__RaEeCertInfo: ", p_ra_ee_cert_info);



    etsi_ts102941_types_ra_ee_cert_info codec;

    OCTETSTRING                                           os;

    if (codec.encode(p_ra_ee_cert_info, os) == -1) {

      loggers::get_instance().warning("fx__enc__RaEeCertInfo: -1 result code was returned");

      return int2bit(0, 1);

    }



    return oct2bit(os);

  }



  INTEGER fx__dec__RaEeCertInfo(BITSTRING &b, Ieee1609Dot2Dot1EeRaInterface::RaEeCertInfo &p_ra_ee_cert_info) {

    loggers::get_instance().log_msg(">>> fx__dec__RaEeCertInfo: ", b);



    etsi_ts102941_types_ra_ee_cert_info codec;

    OCTETSTRING                                           is = bit2oct(b);

    if (codec.decode(is, p_ra_ee_cert_info) == -1) {

      loggers::get_instance().warning("fx__dec__RaEeCertInfo: -1 result code was returned");

      return -1;

    }



    loggers::get_instance().log_msg("<<< fx__dec__RaEeCertInfo: ", p_ra_ee_cert_info);

    return 0;

  }



  BITSTRING fx__enc__PublicKeys(EtsiTs102941BaseTypes::PublicKeys const &p_public_keys) {

    loggers::get_instance().log_msg(">>> fx__enc__PublicKeys: ", p_public_keys);

ccsrc/Externals/LibItsSecurity_externals.cc

+30 −10
Original line number Diff line number Diff line
@@ -2228,25 +2228,45 @@ namespace LibItsSecurity__Functions { 


  FLOAT fx__int2ddlon(const INTEGER &p__longitude) { return (float)((float)p__longitude / 1000000.0); }



  BOOLEAN fx__generate__bkf__signing__expension__keys(const INTEGER& p__i, const INTEGER& p__j, const BOOLEAN& p_debug, OCTETSTRING& p__expension__key) {

    loggers::get_instance().log_msg(">>> fx__generate__bkf__signing__expension__keys: p__i: ", p__i);

    loggers::get_instance().log_msg(">>> fx__generate__bkf__signing__expension__keys: p__j: ", p__j);

  BOOLEAN fx__generate__bkf__signing__key__expension(const INTEGER& p__i, const INTEGER& p__j, const BOOLEAN& p_debug, OCTETSTRING& p__kS) {

    loggers::get_instance().log_msg(">>> fx__generate__bkf__signing__key__expension: p__i: ", p__i);

    loggers::get_instance().log_msg(">>> fx__generate__bkf__signing__key__expension: p__j: ", p__j);



    if (security_services_its::get_instance().generate_bkf_signing_expension_keys(p__i, p__j, p_debug, p__expension__key) == -1) {

    if (security_services_its::get_instance().generate_bkf_signing_key_expension(p__i, p__j, p_debug, p__kS) == -1) {

      return FALSE;

    }

    loggers::get_instance().log_msg("<<< fx__generate__bkf__signing__expension__keys: p__expension__key: ", p__expension__key);

    loggers::get_instance().log_msg("<<< fx__generate__bkf__signing__key__expension: p__kS: ", p__kS);

    return TRUE;

  }



  BOOLEAN fx__generate__bkf__enc__expension__keys(const INTEGER& p__i, const INTEGER& p__j, const BOOLEAN& p_debug, OCTETSTRING& p__expension__key) {

    loggers::get_instance().log_msg(">>> fx__generate__bkf__enc__expension__keys: p__i: ", p__i);

    loggers::get_instance().log_msg(">>> fx__generate__bkf__enc__expension__keys: p__j: ", p__j);

  BOOLEAN fx__create__bkf__signing__expension__keys(const OCTETSTRING& p__kS, const BOOLEAN& p_debug, OCTETSTRING& p__expension__key) {

    loggers::get_instance().log_msg(">>> fx__create__bkf__signing__expension__keys: p__i: ", p__kS);



    if (security_services_its::get_instance().generate_bkf_enc_expension_keys(p__i, p__j, p_debug, p__expension__key) == -1) {

    if (security_services_its::get_instance().create_bkf_signing_expension_keys(p__kS, p_debug, p__expension__key) == -1) {

      return FALSE;

    }

    loggers::get_instance().log_msg("<<< fx__generate__bkf__enc__expension__keys: p__expension__key: ", p__expension__key);

    loggers::get_instance().log_msg("<<< fx__create__bkf__signing__expension__keys: p__expension__key: ", p__expension__key);

    return TRUE;

  }



  BOOLEAN fx__generate__bkf__enc__key__expension(const INTEGER& p__i, const INTEGER& p__j, const BOOLEAN& p_debug, OCTETSTRING& p__kE) {

    loggers::get_instance().log_msg(">>> fx__generate__bkf__enc__key__expension: p__i: ", p__i);

    loggers::get_instance().log_msg(">>> fx__generate__bkf__enc__key__expension: p__j: ", p__j);



    if (security_services_its::get_instance().generate_bkf_enc_key_expension(p__i, p__j, p_debug, p__kE) == -1) {

      return FALSE;

    }

    loggers::get_instance().log_msg("<<< fx__generate__bkf__enc__key__expension: p__kE: ", p__kE);

    return TRUE;

  }



  BOOLEAN fx__create__bkf__enc__expension__keys(const OCTETSTRING& p__kE, const BOOLEAN& p_debug, OCTETSTRING& p__expension__key) {

    loggers::get_instance().log_msg(">>> fx__create__bkf__enc__expension__keys: p__i: ", p__kE);



    if (security_services_its::get_instance().create_bkf_enc_expension_keys(p__kE, p_debug, p__expension__key) == -1) {

      return FALSE;

    }

    loggers::get_instance().log_msg("<<< fx__create__bkf__enc__expension__keys: p__expension__key: ", p__expension__key);

    return TRUE;

  }

ccsrc/Protocols/Security/etsi_ts102941_data_codec.cc

+19 −0
Original line number Diff line number Diff line
@@ -22,6 +22,25 @@ int etsi_ts102941_data_codec::decode(const OCTETSTRING &p_data, EtsiTs102941Mess 
  //  _params = params;

  p_etsi_ts_102941_data.decode(*p_etsi_ts_102941_data.get_descriptor(), decoding_buffer, TTCN_EncDec::CT_OER);



  /**

   * FIXME FSCOM Bug in TITAN TTCN-3 and ASN.1 Compiler for the TTCN-3 Test Executor, version 9.0.0

   */

  if (p_etsi_ts_102941_data.content().ischosen(EtsiTs102941MessagesCa::EtsiTs102941DataContent::ALT_enrolmentResponse)) {

    if (p_etsi_ts_102941_data.content().enrolmentResponse().certificate().ispresent()) {

      Ieee1609Dot2::CertificateBase* cert = static_cast<Ieee1609Dot2::CertificateBase*>(p_etsi_ts_102941_data.content().enrolmentResponse().certificate().get_opt_value());

      cert->toBeSigned().appExtensions().set_to_omit();

      cert->toBeSigned().certIssueExtensions().set_to_omit();

      cert->toBeSigned().certRequestExtension().set_to_omit();

    }

  } else if (p_etsi_ts_102941_data.content().ischosen(EtsiTs102941MessagesCa::EtsiTs102941DataContent::ALT_butterflyAuthorizationRequest)) {

    p_etsi_ts_102941_data.content().butterflyAuthorizationRequest().tbsCert().appExtensions().set_to_omit();

    p_etsi_ts_102941_data.content().butterflyAuthorizationRequest().tbsCert().certIssueExtensions().set_to_omit();

    p_etsi_ts_102941_data.content().butterflyAuthorizationRequest().tbsCert().certRequestExtension().set_to_omit();

  }

  /**

   * 

   */



  loggers::get_instance().log_msg("<<< etsi_ts102941_data_codec::decode: ", (const Base_Type &)p_etsi_ts_102941_data);

  return 0;

}

ccsrc/Protocols/Security/module.mk

+1 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ sources += http_etsi_ieee1609dot2_codec.cc \ 
           etsi_ts102941_types_authorization_shared_at_request.cc \

           etsi_ts102941_types_authorization_validation_request.cc \

           etsi_ts102941_types_authorization_validation_response.cc \

           etsi_ts102941_types_ra_ee_cert_info.cc \

           etsi_ts102941_types_enrolment_inner_request.cc \

           etsi_ts102941_types_enrolment_inner_response.cc \

ccsrc/Protocols/Security/security_ecc.cc

+104 −61
Original line number Diff line number Diff line
@@ -1208,119 +1208,162 @@ int security_ecc::compute_digest_sm3(const OCTETSTRING &p_data, const OCTETSTRIN 
  return 0;

}



int security_ecc::generate_bkf_signing_expension_keys(const encryption_algotithm p_enc_algorithm, const INTEGER& p_i, const INTEGER& p_j, const BOOLEAN& p_debug, OCTETSTRING& p_expension_key) {

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_signing_expension_keys: ", p_i);

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_signing_expension_keys: ", p_j);

int security_ecc::generate_bkf_signing_key_expension(const encryption_algotithm p_enc_algorithm, const INTEGER& p_i, const INTEGER& p_j, const BOOLEAN& p_debug, OCTETSTRING& p_kS) {

  loggers::get_instance().log(">>> security_ecc::generate_bkf_signing_key_expension: p_enc_algorithm=%d", p_enc_algorithm);

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_signing_key_expension: p_i=", p_i);

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_signing_key_expension: p_j=", p_j);

  

  size_t aes_len;

  size_t aes_key_len;

  if (p_enc_algorithm == encryption_algotithm::aes_128_ecb) {

    aes_len = 16;

    aes_key_len = 16;

  } else {

    loggers::get_instance().warning("security_ecc::generate_bkf_signing_expension_keys: Wrong algorithm: %d", p_enc_algorithm);

    loggers::get_instance().warning("security_ecc::generate_bkf_signing_key_expension: Wrong algorithm: %d", p_enc_algorithm);

    return -1;

  }

  loggers::get_instance().log("security_ecc::generate_bkf_signing_key_expension: aes_key_len=%ld", aes_key_len);



  // Calculate kS = 0^32 || i || j || 0^32

  BIGNUM* x_cert = BN_new(); // kS = (i * 4294967296 + j) * 4294967296;

  BN_zero(x_cert);

  int res = ::BN_add_word(x_cert, p_i);

  res = ::BN_mul_word(x_cert, 4294967296);

  res = ::BN_add_word(x_cert, p_j);

  res = ::BN_mul_word(x_cert, 4294967296);

  unsigned char kS[aes_len];

  ::BN_bn2binpad(x_cert, kS, aes_len);

  loggers::get_instance().log_to_hexa("security_ecc::generate_bkf_signing_expension_keys: kS: ", kS, aes_len);

  // Calculate p_kS = 0^32 || i || j || 0^32

  BIGNUM* x_cert = BN_new();

  ::BN_zero_ex(x_cert);

  ::BN_add_word(x_cert, p_i.get_long_long_val()); // p_kS = (i * 4294967296 + j) * 4294967296;

  ::BN_mul_word(x_cert, 4294967296);

  ::BN_add_word(x_cert, p_j.get_long_long_val());

  ::BN_mul_word(x_cert, 4294967296);

  unsigned char kS[aes_key_len];

  ::BN_bn2binpad(x_cert, kS, aes_key_len);

  loggers::get_instance().log_to_hexa("security_ecc::generate_bkf_signing_key_expension: kS: ", kS, aes_key_len);

  p_kS = OCTETSTRING(aes_key_len, kS);

  

  unsigned char* random_signing_aes_enc_key = (unsigned char*)OPENSSL_malloc(aes_len);

  ::BN_free(x_cert);



  loggers::get_instance().log_msg("<<< security_ecc::generate_bkf_signing_key_expension: p_kS: ", p_kS);

  return 0;

}



int security_ecc::create_bkf_signing_expension_keys(const encryption_algotithm p_enc_algorithm, const OCTETSTRING& p_kS, const BOOLEAN& p_debug, OCTETSTRING& p_expension_key) {

  loggers::get_instance().log(">>> security_ecc::create_bkf_signing_expension_keys: p_enc_algorithm=%d", p_enc_algorithm);

  loggers::get_instance().log_msg(">>> security_ecc::create_bkf_signing_expension_keys: p_kS=", p_kS);



  size_t aes_key_len;

  if (p_enc_algorithm == encryption_algotithm::aes_128_ecb) {

    aes_key_len = 16;

  } else {

    loggers::get_instance().warning("security_ecc::create_bkf_signing_expension_keys: Wrong algorithm: %d", p_enc_algorithm);

    return -1;

  }

  loggers::get_instance().log("security_ecc::create_bkf_signing_expension_keys: aes_key_len=%ld", aes_key_len);



  unsigned char* random_signing_aes_enc_key = (unsigned char*)OPENSSL_malloc(aes_key_len);

  if (p_debug == true) {

    const unsigned char random_signing_aes_enc_key_test[aes_len] = { 0x12, 0x1D, 0x14, 0x21, 0x67, 0x15, 0xE1, 0x1D, 0x2D, 0x37, 0x87, 0x43, 0x4A, 0x67, 0x3B, 0x1B }; // FIXME Random

    memcpy((void*)random_signing_aes_enc_key, (const void*)random_signing_aes_enc_key_test, aes_len);

    const unsigned char random_signing_aes_enc_key_test[aes_key_len] = { 0x12, 0x1D, 0x14, 0x21, 0x67, 0x15, 0xE1, 0x1D, 0x2D, 0x37, 0x87, 0x43, 0x4A, 0x67, 0x3B, 0x1B }; // FIXME Random

    memcpy((void*)random_signing_aes_enc_key, (const void*)random_signing_aes_enc_key_test, aes_key_len);

  } else {

    if (::RAND_bytes(random_signing_aes_enc_key, sizeof(random_signing_aes_enc_key)) == -1) {

      OPENSSL_free(random_signing_aes_enc_key);

      loggers::get_instance().error("security_ecc::generate_bkf_signing_expension_keys: RAND_bytes failure");

      loggers::get_instance().error("security_ecc::create_bkf_signing_expension_keys: RAND_bytes failure");

      return -1;

    }

  }

  loggers::get_instance().log_to_hexa("security_ecc::generate_bkf_signing_expension_keys: random_signing_aes_enc_key: ", random_signing_aes_enc_key, aes_len);

  loggers::get_instance().log_to_hexa("security_ecc::create_bkf_signing_expension_keys: random_signing_aes_enc_key: ", random_signing_aes_enc_key, aes_key_len);



  unsigned char* bin_signing_expension_key;

  res = bkf_expension_function(

  int res = bkf_expension_function(

                                   p_enc_algorithm,

                                   random_signing_aes_enc_key,

                                kS, // P1609.2.1/D7, January 2022 Clause 9.3.3 Caterpillar key pair generation - kS

                                aes_len,

                                   static_cast<const unsigned char*>(p_kS), // P1609.2.1/D7, January 2022 Clause 9.3.3 Caterpillar key pair generation - p_kS

                                   aes_key_len,

                                   &bin_signing_expension_key

                                   );

  if (res == -1) {

    OPENSSL_free(random_signing_aes_enc_key);

    loggers::get_instance().error("security_ecc::generate_bkf_signing_expension_keys: bkf_expension_function failure");

    loggers::get_instance().error("security_ecc::create_bkf_signing_expension_keys: bkf_expension_function failure");

    return -1;

  }

  p_expension_key = OCTETSTRING(res, bin_signing_expension_key);

  OPENSSL_free(random_signing_aes_enc_key);

  OPENSSL_free(bin_signing_expension_key);



  loggers::get_instance().log_msg("<<< security_ecc::generate_bkf_signing_expension_keys: p_expension_key: ", p_expension_key);

  loggers::get_instance().log_msg("<<< security_ecc::create_bkf_signing_expension_keys: p_expension_key: ", p_expension_key);

  return 0;

}



int security_ecc::generate_bkf_enc_expension_keys(const encryption_algotithm p_enc_algorithm, const INTEGER& p_i, const INTEGER& p_j, const BOOLEAN& p_debug, OCTETSTRING& p_expension_key) {

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_enc_expension_keys: ", p_i);

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_enc_expension_keys: ", p_j);

int security_ecc::generate_bkf_enc_key_expension(const encryption_algotithm p_enc_algorithm, const INTEGER& p_i, const INTEGER& p_j, const BOOLEAN& p_debug, OCTETSTRING& p_kE) {

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_enc_key_expension: ", p_i);

  loggers::get_instance().log_msg(">>> security_ecc::generate_bkf_enc_key_expension: ", p_j);

  

  size_t aes_len;

  size_t aes_key_len;

  if (p_enc_algorithm == encryption_algotithm::aes_128_ecb) {

    aes_len = 16;

    aes_key_len = 16;

  } else {

    loggers::get_instance().warning("security_ecc::generate_bkf_enc_expension_keys: Wrong algorithm: %d", p_enc_algorithm);

    loggers::get_instance().warning("security_ecc::generate_bkf_enc_key_expension: Wrong algorithm: %d", p_enc_algorithm);

    return -1;

  }

  loggers::get_instance().log("security_ecc::generate_bkf_enc_key_expension: aes_key_len=%d", aes_key_len);



  // Calculate kE = (1^32 || i || j || 0^32)

  BIGNUM* x_enc = BN_new(); // kE = (((4294967296 - 1) * 4294967296 + i) * 4294967296 + j) * 4294967296;

  // Calculate p_kE = (1^32 || i || j || 0^32)

  BIGNUM* x_enc = BN_new(); // p_kE = (((4294967296 - 1) * 4294967296 + i) * 4294967296 + j) * 4294967296;

  BN_zero(x_enc);

  int res = ::BN_add_word(x_enc, 4294967296 - 1);

  res = ::BN_mul_word(x_enc, 4294967296);

  res = ::BN_add_word(x_enc, p_i);

  res = ::BN_mul_word(x_enc, 4294967296);

  res = ::BN_add_word(x_enc, p_j);

  res = ::BN_mul_word(x_enc, 4294967296);

  ::BN_add_word(x_enc, 4294967296 - 1);

  ::BN_mul_word(x_enc, 4294967296);

  ::BN_add_word(x_enc, p_i.get_long_long_val());

  ::BN_mul_word(x_enc, 4294967296);

  ::BN_add_word(x_enc, p_j.get_long_long_val());

  ::BN_mul_word(x_enc, 4294967296);

  unsigned char kE[16];

  ::BN_bn2binpad(x_enc, kE, 16);

  loggers::get_instance().log_to_hexa("security_ecc::generate_bkf_enc_expension_keys: kE: ", kE, 16);

  ::BN_bn2binpad(x_enc, kE, aes_key_len);

  loggers::get_instance().log_to_hexa("security_ecc::generate_bkf_enc_key_expension: kE: ", kE, aes_key_len);

  p_kE = OCTETSTRING(aes_key_len, kE);



  ::BN_free(x_enc);



  loggers::get_instance().log_msg("<<< security_ecc::generate_bkf_enc_key_expension: p_kE: ", p_kE);

  return 0;

}



int security_ecc::create_bkf_enc_expension_keys(const encryption_algotithm p_enc_algorithm, const OCTETSTRING& p_kE, const BOOLEAN& p_debug, OCTETSTRING& p_expension_key) {

  loggers::get_instance().log(">>> security_ecc::create_bkf_enc_expension_keys: p_enc_algorithm=%d", p_enc_algorithm);

  loggers::get_instance().log_msg(">>> security_ecc::create_bkf_enc_expension_keys: p_kE=", p_kE);



  size_t aes_key_len;

  if (p_enc_algorithm == encryption_algotithm::aes_128_ecb) {

    aes_key_len = 16;

  } else {

    loggers::get_instance().warning("security_ecc::create_bkf_enc_expension_keys: Wrong algorithm: %d", p_enc_algorithm);

    return -1;

  }

  loggers::get_instance().log("security_ecc::create_bkf_enc_expension_keys: aes_key_len=%d", aes_key_len);



  unsigned char* random_encryption_aes_enc_key = (unsigned char*)OPENSSL_malloc(aes_len);

  unsigned char* random_encryption_aes_enc_key = (unsigned char*)OPENSSL_malloc(aes_key_len);

  if (p_debug == true) {

    const unsigned char random_encryption_aes_enc_key_test[aes_len] = { 0x6B, 0x71, 0xA7, 0xEB, 0x57, 0x55, 0xF1, 0x6E, 0x89, 0x98, 0x1D, 0x21, 0x89, 0xA6, 0xDA, 0xEA }; // FIXME Random

    memcpy((void*)random_encryption_aes_enc_key, (const void*)random_encryption_aes_enc_key_test, aes_len);

    const unsigned char random_encryption_aes_enc_key_test[aes_key_len] = { 0x6B, 0x71, 0xA7, 0xEB, 0x57, 0x55, 0xF1, 0x6E, 0x89, 0x98, 0x1D, 0x21, 0x89, 0xA6, 0xDA, 0xEA }; // FIXME Random

    memcpy((void*)random_encryption_aes_enc_key, (const void*)random_encryption_aes_enc_key_test, aes_key_len);

  } else {

    if (::RAND_bytes(random_encryption_aes_enc_key, sizeof(random_encryption_aes_enc_key)) == -1) {

      OPENSSL_free(random_encryption_aes_enc_key);

      loggers::get_instance().error("security_ecc::generate_bkf_enc_expension_keys: RAND_bytes failure");

      loggers::get_instance().error("security_ecc::create_bkf_enc_expension_keys: RAND_bytes failure");

      return -1;

    }

  }

  loggers::get_instance().log_to_hexa("security_ecc::generate_bkf_enc_expension_keys: random_encryption_aes_enc_key: ", random_encryption_aes_enc_key, aes_len);

  loggers::get_instance().log_to_hexa("security_ecc::create_bkf_enc_expension_keys: random_encryption_aes_enc_key: ", random_encryption_aes_enc_key, aes_key_len);



  unsigned char* bin_enc_expension_key;

  res = bkf_expension_function(

  int res = bkf_expension_function(

                                   p_enc_algorithm,

                                   random_encryption_aes_enc_key,

                                kE, // P1609.2.1/D7, January 2022 Clause 9.3.3 Caterpillar key pair generation - kS

                                aes_len,

                                   static_cast<const unsigned char*>(p_kE), // P1609.2.1/D7, January 2022 Clause 9.3.3 Caterpillar key pair generation - p_kE

                                   aes_key_len,

                                   &bin_enc_expension_key

                                   );

  if (res == -1) {

    OPENSSL_free(random_encryption_aes_enc_key);

    loggers::get_instance().error("security_ecc::generate_bkf_enc_expension_keys: bkf_expension_function failure");

    loggers::get_instance().error("security_ecc::create_bkf_enc_expension_keys: bkf_expension_function failure");

    return -1;

  }

  p_expension_key = OCTETSTRING(res, bin_enc_expension_key);

  OPENSSL_free(random_encryption_aes_enc_key);

  OPENSSL_free(bin_enc_expension_key);



  loggers::get_instance().log_msg("<<< security_ecc::generate_bkf_enc_expension_keys: p_expension_key: ", p_expension_key);

  loggers::get_instance().log_msg("<<< security_ecc::create_bkf_enc_expension_keys: p_expension_key: ", p_expension_key);

  return 0;

}