titanization.patch

+             */
+            testcase TC_SEC_ITSS_RCV_DENM_04_10_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_digest(
+                                vc_atCertificate.signer_info.signerInfo.digest
+                        )),
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_generation_time_with_standard_deviation(
+                            m_time64WithStandardDeviation(
+                                1000 * f_getCurrentTime(),
+                                255
+                            )
+                        ),
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM
+                    }, 
+                    e_certificate_digest_with_sha256,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_04_10_BO
+            
+            /**
+             * @desc    Check that IUT discards the Secured DENM containing the header fields of type 'expiry_time'
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *          and containing header_fields[1].type
+             *              indicating 'generation_time'
+             *              and containing time
+             *                  indicating CURRENT_TIME
+             *          and containing header_fields[2]
+             *              containing type
+             *                  indicating 'expiration'
+             *              and containing expiry_time 
+             *                  indicating CURRENT_TIME + 1 h 
+             *          and containing header_fields[3].type
+             *                  indicating 'generation_location'
+             *          and containing header_fields[4].type
+             *              containing its_aid
+             *          and not containing other header fields
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_04_11_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_04_11_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_digest(
+                                vc_atCertificate.signer_info.signerInfo.digest
+                        )),
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_expiry_time(
+                            1000 * (3600 + f_getCurrentTime()) // In us
+                        ),
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM
+                    }, 
+                    e_certificate_digest_with_sha256,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_04_11_BO
+            
+            /**
+             * @desc    Check that IUT accepts the Secured DENM containing additional non-standard HeaderField
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *          and containing header_fields[1].type
+             *              indicating 'generation_time'
+             *          and containing header_fields[3].type
+             *              containing its_aid
+             *          and containing header_fields[4]
+             *              containing type
+             *                  indicating non-standard header field type (200)
+             *              and containing other_header
+             *                  indicating non-empty data
+             *          and not containing other header fields
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_04_12_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_04_12_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_digest(
+                                vc_atCertificate.signer_info.signerInfo.digest
+                        )),
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM,
+                        m_header_field_unspecify
+                    }, 
+                    e_certificate_digest_with_sha256,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_04_12_BO
+            
+            /**
+             * @desc    Check that IUT discards the Secured CAM containing the header field 'encryption_parameter and recipient_info'
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *          and containing header_fields[1].type
+             *              indicating 'generation_time'
+             *          and containing header_fields[3].type
+             *              containing its_aid
+             *          and containing header_fields[4]
+             *              containing type
+             *                  indicating 'encryption_parameters'
+             *              and containing enc_params
+             *                  containing symm_algorithm
+             *                      indicating 'aes_128_ccm'
+             *                  and containing nonce
+             *              and containing header_fields[4]
+             *                  containing type
+             *                      indicating 'recipient_info'
+             *                  and containing recipients
+             *                      containing recipients[0]
+             *                          containing cert_id
+             *                              referencing to CERT_IUT_A_AT
+             *                          and containing pk_encryption
+             *                              indicating 'ecies_nistp256'
+             *                          and containing enc_key
+             *          and not containing other header fields
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_04_13_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_04_13_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                var Certificate v_iutATCertificate;
+                var SubjectAttribute v_encryption_key;
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                if (
+                    (f_readCertificate(cc_iutCert_A, v_iutATCertificate) == false) or 
+                    (f_getCertificateSubjectAttribute(v_iutATCertificate, e_encryption_key, v_encryption_key) == false)
+                ) {
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout); // Set verdict to inconc
+                } else {
+                    v_securedGnPdu := f_prepareSecuredDenm(
+                        cc_taCert_A, 
+                        {
+                            m_header_field_signer_info(
+                                m_signerInfo_digest(
+                                    vc_atCertificate.signer_info.signerInfo.digest
+                            )),
+                            m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                            m_header_field_generation_location(
+                                valueof(m_threeDLocation(
+                                    v_longPosVectorNodeB.latitude,
+                                    v_longPosVectorNodeB.longitude,
+                                    '0000'O
+                                ))
+                            ),
+                            m_header_field_its_aid_DENM,
+                            m_header_field_enc_params(                                  // containing header_fields[3].type.enc_params
+                                m_encryptionParameters_aes_128_ccm(                     //      indicating 'aes_128_ccm'
+                                    PX_ENCRYPTIONPARAMETERS_AES_128_CCM_NONCE           // and containing nonce
+                                )
+                            ),
+                            m_header_field_multiple_recipients(                         // containing header_fields[4].type
+                                {                                                       //     indicating 'encryption_parameters'
+                                    m_recipientInfo_ecies_enc_key(
+                                        v_iutATCertificate.signer_info.signerInfo.digest,
+                                        e_ecies_nistp256,                               // containing symm_algorithm
+                                                                                        //     indicating 'aes_128_ccm'
+                                        m_eciesEncryptedKey_aesccm(
+                                            v_encryption_key.attribute.rv,
+                                            '00000000000000000000000000000000'O, // FIXME Where to find these values
+                                            '00000000000000000000000000000000'O
+                                        )
+                                    )
+                                }
+                            )
+                        }, 
+                        e_certificate_digest_with_sha256,
+                        false
+                    ); 
+                    f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                    
+                    f_sleep(PX_TNOAC);
+                    v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                    for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                        // Empty on purpose 
+                    } // End of 'for' statement
+                    if (i < lengthof(vc_utInds)) {
+                        log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    else {
+                        log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_04_13_BO
+            
+            /**
+             * @desc    Check that IUT discards the Secured DENM containing the header fields of type 'request_unrecognized_certificate'
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *          and containing header_fields[1].type
+             *              indicating 'generation_time'
+             *              and containing generation_time
+             *                  indicating CURRENT_TIME
+             *          and containing header_fields[2].type
+             *             indicating 'request_unrecognized_certificate'
+             *             and containing digests[0]
+             *                 indicating the digest of X_IUT_AT_CERT
+             *          and containing header_fields[3].type
+             *              indicating 'generation_location'
+             *          and containing header_fields[4].type
+             *              indicating 'its_aid'
+             *          and not containing other header fields
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_04_14_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_04_14_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                var Certificate v_iutATCertificate;
+                var SignerInfo v_signerInfo;
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                if (
+                    (f_readCertificate(cc_iutCert_A, v_iutATCertificate) == false) or 
+                    (f_getCertificateSignerInfo(v_iutATCertificate, v_signerInfo) == false)
+                ) {
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout); // Set verdict to inconc
+                } else {
+                    v_securedGnPdu := f_prepareSecuredDenm(
+                        cc_taCert_A, 
+                        {
+                            m_header_field_signer_info(
+                                m_signerInfo_digest(
+                                    vc_atCertificate.signer_info.signerInfo.digest
+                            )),
+                            m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                            m_header_field_unrecognised_certificate(
+                                f_HashedId3FromHashedId8(
+                                   f_calculateDigestFromCertificate(
+                                       v_signerInfo.signerInfo.certificate
+                                   )
+                                )
+                            ),
+                            m_header_field_generation_location(
+                                valueof(m_threeDLocation(
+                                    v_longPosVectorNodeB.latitude,
+                                    v_longPosVectorNodeB.longitude,
+                                    '0000'O
+                                ))
+                            ),
+                            m_header_field_its_aid_DENM
+                        }, 
+                        e_certificate_digest_with_sha256,
+                        false
+                    ); 
+                    f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                    
+                    f_sleep(PX_TNOAC);
+                    v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                    for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                        // Empty on purpose 
+                    } // End of 'for' statement
+                    if (i < lengthof(vc_utInds)) {
+                        log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    else {
+                        log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_04_14_BO
+            
+            /**
+             * @desc    Check that IUT discards a Secured DENM if the header_fields contains a signer of type 'self'
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *                  containing signer.type
+             *                      indicating 'self'
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_05_01_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_05_01_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_self
+                        ), 
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM
+                    }, 
+                    e_self,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_05_01_BO
+            
+            /**
+             * @desc    Check that IUT discards a Secured DENM if the header_fields contains a signer of type 'certificate_digest_with_other_algorithm'
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *                  containing signer.type
+             *                      indicating 'certificate_digest_with_other_algorithm'
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_05_02_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_05_02_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_other_certificates(
+                                m_certificateWithAlgo_ecdsa(
+                                    PX_OTHER_CERT_DIGEST
+                        ))), 
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM
+                    }, 
+                    e_certificate_digest_with_other_algorithm,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_05_02_BO
+            
+            /**
+             * @desc    Check that IUT discards a Secured DENM if the header_fields contains a signer of type certificate_chain
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *                  containing signer.type
+             *                      indicating 'certificate_digest_with_other_algorithm'
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_05_03_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_05_03_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_certificates(
+                                { vc_aaCertificate, vc_atCertificate }
+                        )), 
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM
+                    }, 
+                    e_certificate_chain,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_05_03_BO
+            
+            /**
+             * @desc    Check that IUT discards a secured DENM if the header_fields contains a signer info of unknown or reserved type
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields[0].type
+             *              indicating 'signer_info'
+             *                  containing signer.type
+             *                      indicating X_UNKNOWN_SIGNERINFO_TYPE
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_05_04_BO
+             * @reference    ETSI TS 103 097 [1], clause 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_05_04_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert_A, 
+                    {
+                        m_header_field_signer_info(
+                            m_signerInfo_unknown(
+                                'CAFFEEDECA'O
+                        )), 
+                        m_header_field_generation_time(1000 * f_getCurrentTime()), // In us
+                        m_header_field_generation_location(
+                            valueof(m_threeDLocation(
+                                v_longPosVectorNodeB.latitude,
+                                v_longPosVectorNodeB.longitude,
+                                '0000'O
+                            ))
+                        ),
+                        m_header_field_its_aid_DENM
+                    }, 
+                    e_unknown,
+                    false
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_05_04_BO
+            
+            /**
+             * @desc    Check that IUT discards a Secured DENM containing generation_time before the certificate validity period
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A) 
+             *          containing header_fields['signer_info'].signer 
+             *              containing certificate (CERT_TS_MSG_06_01_BO_AT)
+             *                  containing validity_restrictions['time_start_and_end']
+             *                      containing start_validity
+             *                          indicating START_VALIDITY_AT
+             *                      and containing end_validity
+             *                          indicating END_VALIDITY_AT
+             *          and containing header_fields ['generation_time']
+             *              containing generation_time
+             *                  indicating GEN_TIME < START_VALIDITY_AT
+             *  } then { 
+             *      the IUT discards the message 
+             *  } 
+             * } 
+             * </pre>
+             *
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_RCV_DENM_06_01_BO
+             * @reference    ETSI TS 103 097 [1], clauses 5.4 and 7.2
+             */
+            testcase TC_SEC_ITSS_RCV_DENM_06_01_BO() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var integer i;
+                var GeoNetworkingPdu v_securedGnPdu;
+                var GnRawPayload v_sentRawPayload;
+                var LongPosVector v_longPosVectorNodeB := f_getPosition(c_compNodeB); // Use NodeB
+                var ValidityRestriction v_timeValidity;
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                f_getCertificateValidityRestriction(vc_atCertificate, e_time_start_and_end, v_timeValidity);
+                v_securedGnPdu := f_prepareSecuredDenm(
+                    cc_taCert0601_BO, 
+                    {
+                        m_header_field_generation_time(
+                            (v_timeValidity.validity.time_start_and_end.start_validity - 3600) * 1000
+                        ) // In us
+                    }, 
+                    e_certificate
+                ); 
+                f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(v_securedGnPdu));
+                
+                f_sleep(PX_TNOAC);
+                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
+                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
+                    // Empty on purpose 
+                } // End of 'for' statement
+                if (i < lengthof(vc_utInds)) {
+                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                else {
+                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_RCV_DENM_06_01_BO
+            
+            /**
+             * @desc    Check that IUT discards a Secured DENM containing generation_time before the certificate validity period
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with { 
+             *  the IUT being in the 'authorized' state 
+             *  and the IUT current time is inside the time validity period of CERT_TS_A_AT
+             * } 
+             * ensure that { 
+             *  when { 
+             *      the IUT is receiving a SecuredMessage (MSG_SEC_RCV_DENM_A)