ItsPkiItss_TestCases.ttcn

        v_ea.start(f_TC_SECPKI_ITSS_ENR_07_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);
      } // End of TC_SECPKI_ITSS_ENR_07_BV

      group f_SECPKI_ITSS_ENR_07_BV {

        function f_TC_SECPKI_ITSS_ENR_07_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          
          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);
          
          // Test adapter configuration
          
          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          
          // Test Body
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request)
            {
              var Ieee1609Dot2Data v_decrypted_message;
              var InnerEcRequest   v_inner_ec_request;
              var InnerEcResponse  v_inner_ec_response;
              var Ieee1609Dot2Data v_response_message;
              var EtsiTs102941Data v_pki_request;
              var Oct16 v_request_hash, v_aes_enc_key;
              var PublicVerificationKey v_canonical_key;
              tc_ac.stop;

              if( not f_read_ec_request_from_iut_itss(v_request.request.body.binary_body.ieee1609dot2_data,
                                                       v_request_hash, v_aes_enc_key,
                                                       v_decrypted_message,
                                                       v_pki_request,
                                                      v_inner_ec_request)) {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // send any response to prevent enrolment repetition
              // negative is simpler
              if( not f_http_build_error_ec_response ( unknownits,v_request_hash,
                                                          vc_eaPrivateKey, vc_eaWholeHash, v_aes_enc_key,
                                                          v_response_message) )
              {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't build enrolment response ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }
              f_http_send(v_headers, m_http_response(
                                                      m_http_response_ok(
                                                              m_http_message_body_binary(
                                                                      m_binary_body_ieee1609dot2_data(v_response_message)
                                                              ), v_headers)));

              if (not isvalue(v_inner_ec_request)) {
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              if (ispresent(v_inner_ec_request.requestedSubjectAttributes.certIssuePermissions)) {
                log("*** " & testcasename() & ": FAIL: InnerEcRequest shall not contain certIssuePermissions attribute ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // Set verdict
              log("*** " & testcasename() & ": PASS: InnerEcRequest received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
          
          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_07_BV_pki

      } // End of group f_SECPKI_ITSS_ENR_07_BV

      /**
       * @desc In the headerInfo of the tbsData of the InnerECRequestSignedForPOP all other components 
       *       of the component tbsdata.headerInfo except generationTime and psid are not used and absent. 
       *       The psid shall be set to "secured certificate request" as assigned in ETSI TS 102 965 and 
       *       the generationTime shall be present.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is requested to send an EnrolmentRequestMessage
       *         }
       *         then {
       *             the IUT sends an EtsiTs103097Data-Encrypted
       *                 containing an encrypted EtsiTs103097Data-Signed
       *                     containing EtsiTs103097Data
       *                         containing InnerECRequestSignedForPOP
       *                             containing tbsData
       *                                 containing headerInfo
       *                                     containing psid
       *                                         indicating AID_CERT_REQ
       *                                     and containing generationTime
       *                                     and not containing any other component of tbsdata.headerInfo
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v1.2.1 SECPKI_ITSS_ENR_08_BV
       * @reference ETSI TS 102 941, clause 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_08_BV_1() runs on ItsMtc system ItsPkiItssSystem {
        f_TC_SECPKI_ITSS_ENR_08_BV_mtc(c_stInitial);
      } // End of TC_SECPKI_ITSS_ENR_08_BV_1
      testcase TC_SECPKI_ITSS_ENR_08_BV_2() runs on ItsMtc system ItsPkiItssSystem {
        f_TC_SECPKI_ITSS_ENR_08_BV_mtc(c_stEnrolled);
      } // End of TC_SECPKI_ITSS_ENR_08_BV_2

      group f_SECPKI_ITSS_ENR_08_BV {

        function f_TC_SECPKI_ITSS_ENR_08_BV_mtc(in charstring p_itss_state) runs on ItsMtc system ItsPkiItssSystem {
          // Local variables
          var ItsPkiItss v_itss;
          var ItsPkiHttp v_ea;

          // Test control
          if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT) {
            log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT required for executing the TC ***");
            setverdict(inconc);
            stop;
          }

          // Test component configuration
          f_cfMtcUp01(v_itss, v_ea);

          // Start components
          if(p_itss_state == c_stEnrolled) {
            v_itss.start(f_TC_SECPKI_ITSS_ENR_03_BV_itss());
          } else {
            v_itss.start(f_TC_SECPKI_ITSS_ENR_01_BV_itss());
          }
          v_ea.start(f_TC_SECPKI_ITSS_ENR_08_BV_pki(p_itss_state));

          // Synchronization
          f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

          // Cleanup
          f_cfMtcDown01(v_itss, v_ea);
        } // End of TC_SECPKI_ITSS_ENR_08_BV

        function f_TC_SECPKI_ITSS_ENR_08_BV_pki(
                                                in charstring p_itss_state
                                                ) runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          
          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);
          
          // Test adapter configuration
          
          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);

          if (p_itss_state == c_stEnrolled) {
            var InnerEcRequest v_inner_ec_request;
            var InnerEcResponse v_inner_ec_response;
            if(not f_await_ec_request_send_response( v_inner_ec_request, v_inner_ec_response, v_request)){
              log("*** " & testcasename() & ": INFO: First InnerEcRequest error ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
            }
            log("*** " & testcasename() & ": INFO: First InnerEcRequest received ***");
          }
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          
          // Test Body
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request) {
              var Oct16 v_request_hash;
              var Oct16 v_aes_enc_key;
              var Ieee1609Dot2Data v_decrypted_message;
              var InnerEcRequest v_inner_ec_request;
              var InnerEcResponse v_inner_ec_response;
              var Ieee1609Dot2Data v_response_message;
              var EtsiTs102941Data v_pki_request;
              tc_ac.stop;

              f_read_ec_request_from_iut_itss(v_request.request.body.binary_body.ieee1609dot2_data,
                                                      v_request_hash, v_aes_enc_key,
                                                      v_decrypted_message,
                                                      v_pki_request,
                                                      v_inner_ec_request);

              if (not(isvalue(v_pki_request))) {
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // send any response to prevent enrolment repetition
              // negative is simpler
              if( not f_http_build_error_ec_response ( unknownits,v_request_hash,
                                                  vc_eaPrivateKey, vc_eaWholeHash, v_aes_enc_key,
                                                  v_response_message) )
              {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't build enrolment response ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }
              f_http_send(v_headers, m_http_response(
                                                      m_http_response_ok(
                                                              m_http_message_body_binary(
                                                                      m_binary_body_ieee1609dot2_data(v_response_message)
                                                              ), v_headers)));

              if( not ischosen(v_pki_request.content.enrolmentRequest)) {
                log("*** " & testcasename() & ": FAIL: Not an enrolment request ***");
                log("*** " & testcasename() & ":       EtsiTs102941Data.content=", v_pki_request.content);
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              if (not(match(v_pki_request.content.enrolmentRequest,
                            mw_etsiTs103097Data_signed(
                                                       mw_signedData(
                                                                     -,
                                                                     mw_toBeSignedData(
                                                                                       -,
                                                                                       mw_headerInfo_inner_pki_request
                  )))))) {
                log("*** " & testcasename() & ": FAIL: Wrong InnerECRequestSignedForPOP headers ***");
                log("*** " & testcasename() & ":       ", 
                      match( v_pki_request.content.enrolmentRequest, 
                             m_etsiTs103097Data_signed(mw_signedData( -,mw_toBeSignedData(-,mw_headerInfo_inner_pki_request())))));
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // Set verdict
              log("*** " & testcasename() & ": PASS: EC Request received with proper InnerECRequestSignedForPOP headers ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
          
          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_08_BV_pki

      } // End of group f_SECPKI_ITSS_ENR_08


      /**
       * @desc In the headerInfo of the tbsData of the outer EtsiTs102941Data-Signed all other components 
       *       of the component tbsdata.headerInfo except generationTime and psid are not used and absent. 
       *       The psid shall be set to "secured certificate request" as assigned in ETSI TS 102 965 and 
       *       the generationTime shall be present.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is requested to send an EnrolmentRequestMessage
       *         }
       *         then {
       *             the IUT sends an EtsiTs103097Data-Encrypted
       *                 containing an encrypted EtsiTs103097Data-Signed
       *                     containing EtsiTs103097Data
       *                         containing InnerECRequestSignedForPOP
       *                             containing tbsData
       *                                 containing headerInfo
       *                                     containing psid
       *                                         indicating AID_CERT_REQ
       *                                     and containing generationTime
       *                                     and not containing any other component of tbsdata.headerInfo
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v1.2.1 SECPKI_ITSS_ENR_09_BV
       * @reference ETSI TS 102 941, clause 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_09_BV_1() runs on ItsMtc system ItsPkiItssSystem {
        f_TC_SECPKI_ITSS_ENR_09_BV_mtc(c_stInitial);
      } // End of TC_SECPKI_ITSS_ENR_09_BV_1
      testcase TC_SECPKI_ITSS_ENR_09_BV_2() runs on ItsMtc system ItsPkiItssSystem {
        f_TC_SECPKI_ITSS_ENR_09_BV_mtc(c_stEnrolled);
      } // End of TC_SECPKI_ITSS_ENR_09_BV_2

      group f_TC_SECPKI_ITSS_ENR_09_BV {

        function f_TC_SECPKI_ITSS_ENR_09_BV_mtc(in charstring p_itss_state) runs on ItsMtc system ItsPkiItssSystem {
          // Local variables
          var ItsPkiItss v_itss;
          var ItsPkiHttp v_ea;

          // Test control
          if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT) {
            log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT required for executing the TC ***");
            setverdict(inconc);
            stop;
          }

          // Test component configuration
          f_cfMtcUp01(v_itss, v_ea);

          // Start components
          if(p_itss_state == c_stEnrolled) {
            v_itss.start(f_TC_SECPKI_ITSS_ENR_03_BV_itss());
          } else {
            v_itss.start(f_TC_SECPKI_ITSS_ENR_01_BV_itss());
          }
          v_ea.start(f_TC_SECPKI_ITSS_ENR_09_BV_pki(p_itss_state));

          // Synchronization
          f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

          // Cleanup
          f_cfMtcDown01(v_itss, v_ea);
        } // End of f_TC_SECPKI_ITSS_ENR_09_BV_mtc

        function f_TC_SECPKI_ITSS_ENR_09_BV_pki(
                                                in charstring p_itss_state
                                                ) runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          
          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);
          
          // Test adapter configuration
          
          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);          
          
          if (p_itss_state == c_stEnrolled) {
            var InnerEcRequest v_inner_ec_request;
            var InnerEcResponse v_inner_ec_response;
            if (not(f_await_ec_request_send_response( v_inner_ec_request, v_inner_ec_response, v_request))) {
              log("*** " & testcasename() & ": INFO: First InnerEcRequest error ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
            }
            log("*** " & testcasename() & ": INFO: First InnerEcRequest received ***");
          }
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          
          // Test Body
          tc_ac.start;          
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request) {
              var Ieee1609Dot2Data v_decrypted_message;
              var InnerEcRequest   v_inner_ec_request;
              var InnerEcResponse  v_inner_ec_response;
              var Ieee1609Dot2Data v_response_message;
              var EtsiTs102941Data v_pki_request;
              var Oct16 v_request_hash, v_aes_enc_key;
              var PublicVerificationKey v_canonical_key;

              tc_ac.stop;

              if (not(f_read_ec_request_from_iut_itss(v_request.request.body.binary_body.ieee1609dot2_data,
                                                      v_request_hash, v_aes_enc_key,
                                                      v_decrypted_message,
                                                      v_pki_request,
                                                      v_inner_ec_request))) {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // send error response to prevent enrolment repetition
              if( not f_http_build_error_ec_response ( unknownits,v_request_hash,
                                                  vc_eaPrivateKey, vc_eaWholeHash, v_aes_enc_key,
                                                  v_response_message) )
              {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't build enrolment response ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }
              f_http_send(v_headers, m_http_response(
                                                      m_http_response_ok(
                                                              m_http_message_body_binary(
                                                                      m_binary_body_ieee1609dot2_data(v_response_message)
                                                              ), v_headers)));

              // check signed message structure
              if ( not ( match( v_decrypted_message,
                            mw_etsiTs103097Data_signed(
                                                       mw_signedData(
                                                                     -,
                                                                     mw_toBeSignedData(
                                                                                       -,
                                                                                       mw_headerInfo_outer_pki_request
                          
              )))))) {
                log("*** " & testcasename() & ": FAIL: Invalid outer signed structure in EC request ***");
                log("*** " & testcasename() & ":       ",
                  match(v_decrypted_message,m_etsiTs103097Data_signed(mw_signedData(-,mw_toBeSignedData(-,mw_headerInfo_outer_pki_request()))))
                );
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // Set verdict
              log("*** " & testcasename() & ": PASS: EC request contains valid outer signed structure ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
      
          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_09_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_09_BV

      /**
       * @desc The EtsiTs103097Data-Encrypted containing the correctly encrypted ciphertext and a recipients 
       *       component containing one instance of RecipientInfo of choice certRecipInfo containing the 
       *       hashedId8 of the EA certificate in recipientId and the encrypted data encryption key in encKey. 
       *       The data encryption key is encrypted using the public key found in the EA certificate referenced 
       *       in the recipientId.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is requested to send an EnrolmentRequestMessage
       *         }
       *         then {
       *             the IUT sends an EtsiTs103097Data-Encrypted
       *                 containing recipients
       *                     containing exactly one instance of RecipientInfo of choice certRecipInfo
       *                         containing recipientId
       *                             indicating the hashedId8
       *                                 referencing to the EA certificate
       *                                     containing encryptionKey (KEY)
       *                      and containing encKey
       *                          being a symmetric key (SYMKEY) encrypted using the key KEY
       *                  containing ciphertext
       *                      which is encrypted using the symmetric key SYMKEY contained in encKey
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v1.2.1 SECPKI_ITSS_ENR_10_BV
       * @reference ETSI TS 102 941, clause 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_10_BV_1() runs on ItsMtc system ItsPkiItssSystem {
        f_TC_SECPKI_ITSS_ENR_10_BV_mtc(c_stInitial);
      } // End of TC_SECPKI_ITSS_ENR_10_BV_1
      testcase TC_SECPKI_ITSS_ENR_10_BV_2() runs on ItsMtc system ItsPkiItssSystem {
        f_TC_SECPKI_ITSS_ENR_10_BV_mtc(c_stEnrolled);
      } // End of TC_SECPKI_ITSS_ENR_10_BV_2

      group f_TC_SECPKI_ITSS_ENR_10_BV {

        function f_TC_SECPKI_ITSS_ENR_10_BV_mtc(in charstring p_itss_state) runs on ItsMtc system ItsPkiItssSystem {
          // Local variables
          var ItsPkiItss v_itss;
          var ItsPkiHttp v_ea;

          // Test control
          if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT) {
            log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT required for executing the TC ***");
            setverdict(inconc);
            stop;
          }

          // Test component configuration
          f_cfMtcUp01(v_itss, v_ea);

          // Start components
          if(p_itss_state == c_stEnrolled) {
            v_itss.start(f_TC_SECPKI_ITSS_ENR_03_BV_itss());
          } else {
            v_itss.start(f_TC_SECPKI_ITSS_ENR_01_BV_itss());
          }
          v_ea.start(f_TC_SECPKI_ITSS_ENR_10_BV_pki(p_itss_state));

          // Synchronization
          f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

          // Cleanup
          f_cfMtcDown01(v_itss, v_ea);
        } // End of f_TC_SECPKI_ITSS_ENR_10_BV_mtc

        function f_TC_SECPKI_ITSS_ENR_10_BV_pki(
                                                in charstring p_itss_state
                                                ) runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          
          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);
          
          // Test adapter configuration
          
          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);          
          
          if (p_itss_state == c_stEnrolled) {
            var InnerEcRequest v_inner_ec_request;
            var InnerEcResponse v_inner_ec_response;
            if (not(f_await_ec_request_send_response( v_inner_ec_request, v_inner_ec_response, v_request))) {
              log("*** " & testcasename() & ": INFO: First InnerEcRequest error ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
            }
            log("*** " & testcasename() & ": INFO: First InnerEcRequest received ***");
          }
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          
          // Test Body
          tc_ac.start;          
          alt {
            [] a_await_ec_http_request_from_iut(  
                                                mw_http_request(
                                                                mw_http_request_post(
                                                                                      PICS_HTTP_POST_URI_EC,
                                                                                      -,
                                                                                      mw_http_message_body_binary(
                                                                                                                  mw_binary_body_ieee1609dot2_data(
                                                                                                                                                   mw_enrolmentRequestMessage(
                                                                                                                                                                              mw_encryptedData(
                                                                                                                                                                                               { mw_recipientInfo_certRecipInfo(
                                                                                                                                                                                                                                mw_pKRecipientInfo(vc_eaHashedId8)
                                                                                                                                                                                                                                )
                                                                                                                                                                                               }
                                                )))))),
                                                v_request) {
              var Ieee1609Dot2Data v_decrypted_message;
              var InnerEcRequest   v_inner_ec_request;
              var InnerEcResponse  v_inner_ec_response;
              var Ieee1609Dot2Data v_response_message;
              var EtsiTs102941Data v_pki_request;
              var Oct16 v_request_hash, v_aes_enc_key;
              var PublicVerificationKey v_canonical_key;
              tc_ac.stop;

              log("*** " & testcasename() & ": PASS: EC request sent to proper EA recipient ***");

              if (not(f_read_ec_request_from_iut_itss(v_request.request.body.binary_body.ieee1609dot2_data,
                                                      v_request_hash, v_aes_enc_key,
                                                      v_decrypted_message,
                                                      v_pki_request,
                                                      v_inner_ec_request))) {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // send any response to prevent enrolment repetition
              // negative is just simpler
              if( not f_http_build_error_ec_response ( unknownits,v_request_hash,
                                                          vc_eaPrivateKey, vc_eaWholeHash, v_aes_enc_key,
                                                          v_response_message) )
              {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't build enrolment response ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }
              f_http_send(v_headers, m_http_response(
                                                      m_http_response_ok(
                                                              m_http_message_body_binary(
                                                                      m_binary_body_ieee1609dot2_data(v_response_message)
                                                              ), v_headers)));

              // Set verdict
              log("*** " & testcasename() & ": PASS: EC request can be decrypted ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request) {
              f_send_500_Internal_Error(v_headers); // we don't care about response
              log("*** " & testcasename() & ": FAIL: EC request sent to wrong recipient ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
      
          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_10_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_10_BV

      /**
       * @desc In the inner signed data structure (InnerECRequestSignedForPOP), the signature is computed 
       *       on InnerECRequest with the private key corresponding to the new verificationKey to prove 
       *       possession of the generated verification key pair.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is requested to send an EnrolmentRequestMessage
       *         }
       *         then {
       *             the IUT sends an EtsiTs103097Data-Encrypted
       *                 containing an encrypted EtsiTs103097Data-Signed
       *                     containing EtsiTs103097Data
       *                         containing InnerECRequestSignedForPOP
       *                             containing tbsData
       *                                 containing InnerEcRequest
       *                                     containing verificationKey (VKEY)
       *                              containing signature
       *                                  computed on InnerECRequest
       *                                      using the private key corresponding to VKEY
       *                                          contained in InnerECRequest
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v2.0.1 SECPKI_ITSS_ENR_11_BV
       * @reference ETSI TS 102 941, clause 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_11_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start components
        v_itss.start(f_TC_SECPKI_ITSS_ENR_01_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_11_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);
      } // End of TC_SECPKI_ITSS_ENR_11_BV
      
      group f_TC_SECPKI_ITSS_ENR_11_BV {
        function f_TC_SECPKI_ITSS_ENR_11_BV_pki ( ) runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          
          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);
          
          // Test adapter configuration
          
          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);          
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          
          // Test Body
          tc_ac.start;          
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request)
            {
              var Ieee1609Dot2Data v_decrypted_message;
              var InnerEcRequest   v_inner_ec_request;
              var InnerEcResponse  v_inner_ec_response;
              var Ieee1609Dot2Data v_response_message;
              var EtsiTs102941Data v_pki_request;
              var Oct16 v_request_hash, v_aes_enc_key;
              var PublicVerificationKey v_canonical_key;
              tc_ac.stop;

              if (not f_read_ec_request_from_iut_itss(v_request.request.body.binary_body.ieee1609dot2_data,
                                                      v_request_hash, v_aes_enc_key,
                                                      v_decrypted_message,
                                                      v_pki_request,
                                                      v_inner_ec_request))
              {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // send any response to prevent enrolment repetition
              // negative is easier
              if( not f_http_build_error_ec_response ( unknownits,v_request_hash,
                                                  vc_eaPrivateKey, vc_eaWholeHash, v_aes_enc_key,
                                                  v_response_message) ) {
                f_send_500_Internal_Error(v_headers);
                log("*** " & testcasename() & ": FAIL: Can't build enrolment response ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }
              f_http_send(v_headers, m_http_response(
                                                      m_http_response_ok(
                                                              m_http_message_body_binary(
                                                                      m_binary_body_ieee1609dot2_data(v_response_message)
                                                              ), v_headers)));


              if (not isbound(v_inner_ec_request))
              {
                log("*** " & testcasename() & ": FAIL: Can't parse enrolment request***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              if (not f_verifyEcdsa(bit2oct(encvalue(v_pki_request.content.enrolmentRequest.content.signedData.tbsData)),
                                    int2oct(0, 32),
                                    v_pki_request.content.enrolmentRequest.content.signedData.signature_,
                                    v_inner_ec_request.publicKeys.verificationKey))
              {
                log("*** " & testcasename() & ": FAIL: EC request signature verification failed ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
              }

              // Set verdict
              log("*** " & testcasename() & ": PASS: PoP signature verified correctly ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }

            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
      
          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_11_BV_pki
      } // End of group g_TC_SECPKI_ITSS_ENR_11_BV

      /**
       * @desc Check that signing of Enrolment HttpRequest message is permitted by the EC certificate.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT and PICS_SECPKI_REENROLMENT 
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is in enrolled state
       *             the IUT is requested to send an EnrolmentRequestMessage
       *         }
       *         then {
       *             the IUT sends an EtsiTs103097Data-Encrypted
       *                 containing an encrypted EtsiTs103097Data-Signed
       *                     containing signer
       *                         containing digest
       *                             indicating HashedId8 of the EC certificate
       *                                 containing appPermissions
       *                                     containing an item of type PsidSsp
       *                                         containing psid
       *                                             indicating AID_CERT_REQ
       *                                         and containing ssp
       *                                             containing opaque[0] (version) 
       *                                                 indicating 1
       *                                             containing opaque[1] (value) 
       *                                                 indicating "Enrolment Request" (bit 1) set to 1
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v2.0.1 SECPKI_ITSS_ENR_12_BV
       * @reference ETSI TS 102 941, clause 6.1.3, 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_12_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT or not PICS_SECPKI_REENROLMENT ) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT and PICS_SECPKI_REENROLMENT required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start components
        v_itss.start(f_TC_SECPKI_ITSS_ENR_03_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_03_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);
      } // End of TC_SECPKI_ITSS_ENR_12_BV

    } // End of group itss_enrolment_request

    // ETSI TS 103 525-2 V2.0.2 (2023-07) Clause 5.2.2.2  Enrollment response handling
    group itss_enrolment_response {

      /**
       * @desc If an enrolment request fails, the IUT returns to the state 'initialized'.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is requested to send an EnrolmentRequestMessage
       *             and the EnrolmentResponseMessage is received
       *                 containing a responseCode different than 0
       *         }
       *         then {
       *             the IUT returns to the "initialized" state
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v2.0.1 SECPKI_ITSS_ENR_RECV_01_BV
       * @reference ETSI TS 102 941, clause 6.1.3, 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_RECV_01_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start components
        v_itss.start(f_TC_SECPKI_ITSS_ENR_RECV_01_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_RECV_01_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);

      } // End of TC_SECPKI_ITSS_ENR_RECV_01_BV

      group f_TC_SECPKI_ITSS_ENR_RECV_01_BV {

        function f_TC_SECPKI_ITSS_ENR_RECV_01_BV_itss() runs on ItsPkiItss system ItsPkiItssSystem {
          // Local variables
          var HashedId8               v_certificate_digest;
          var EtsiTs103097Certificate v_certificate;
          var boolean                 v_iut_state_ok := false;

          // Test component configuration
          f_cfUp_itss(); // No IT certificate selected

          // Test adapter configuration

          // Preamble
          // Initial state: No CAM shall be emitted
          geoNetworkingPort.clear;
          tc_noac.start;
          alt {
            [] geoNetworkingPort.receive {
              log("No CA message expected");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
            }
            [] tc_noac.timeout {
              f_sendUtTriggerEnrolmentRequestPrimitive();
              log("*** " & testcasename() & "_itss: : INFO: No CA message received ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            }
          } // End of 'alt' statement

          // Test Body
          tc_ac.start; // TDOD To refined, use altstep
          alt {
            [] utPort.receive(UtPkiTriggerInd: { state := 0 }) {
              tc_ac.stop;
              v_iut_state_ok := true;
              log("*** " & testcasename() & "_itss: INFO: IUT is in initialized state ***");
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & "_itss: DBG: IUT state update not recieved ***");
              //f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
          tc_noac.start;
          alt {
            [] geoNetworkingPort.receive {
              log("No CA message expected");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
            }
            [] tc_noac.timeout {
              if (v_iut_state_ok == true) {
                log("*** " & testcasename() & "_itss: : PASS: Enrolment trigger processed succesfully ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
              } else {
                log("Did not receive IUT state update");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
              }
            }
          } // End of 'alt' statement

          // Postamble
          f_cfDown_itss();
        } // End of function f_TC_SECPKI_ITSS_ENR_RECV_01_BV_itss

        function f_TC_SECPKI_ITSS_ENR_RECV_01_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers     v_headers;
          var HttpMessage v_request;

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(
                                                mw_http_request(
                                                                mw_http_request_post(
                                                                                     PICS_HTTP_POST_URI_EC,
                                                                                     -,
                                                                                     mw_http_message_body_binary(
                                                                                                                 mw_binary_body_ieee1609dot2_data(
                                                                                                                                                  mw_enrolmentRequestMessage(
                                                                                                                                                                            mw_encryptedData(
                                                                                                                                                                                             { *, mw_recipientInfo_certRecipInfo(mw_pKRecipientInfo(vc_eaHashedId8)), * },
                                                                                                                                                                                             mw_symmetricCiphertext_aes128ccm
                                                                                                                                                                                             )))))),
                                                v_request
                                                ) {
              var HttpMessage v_response;
              var integer v_result;
              var InnerEcRequest v_inner_ec_request;
              var InnerEcResponse v_inner_ec_response;

              tc_ac.stop;

              // Verify IUT response
              f_verify_http_ec_request_from_iut_itss(v_request.request, v_headers, v_inner_ec_request, v_inner_ec_response, v_response, v_result, -, -, cantparse);
              // Send response forcing error code
              if (isvalue(v_response)) {
                httpPort.send(v_response);
              }
              // Set verdict
              if (v_result == 0) {
                log("*** " & testcasename() & ": INFO: InnerEcRequest received ***");
                f_selfOrClientSyncAndVerdict(c_prDone, e_success);
              } else {
                log("*** " & testcasename() & ": FAIL: Failed to verify EA an EnrolmentRequestMessage ***");
                f_selfOrClientSyncAndVerdict(c_prDone, e_error);
              }
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
            }
          } // End of 'alt' statement

          // Test Body
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);

          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_RECV_01_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_RECV_01_BV

      /**
       * @desc The IUT is capable of parsing and handling of positive EnrolmentResponse messages 
       *       containing the requested EC. In case of a successful enrolment, the IUT switches 
       *       to the state 'enrolled'.
       * <pre>
       * Pics Selection: PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is requested to send an initial EnrolmentRequestMessage
       *             and when the IUT receives a subsequent EnrolmentResponseMessage as an answer of the EA
       *                 containing a responseCode
       *                     indicating 0
       *                 and containing an enrolment certificate
       *         }