titanization.patch

+            
+            /**
+             * @desc        Check that the secured message contains of type signed, signed_external or signed_and_encrypted 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_ITS_AID_OTHER_PROFILE
+             * Config Id: CF01
+             * Initial conditions:
+             * with {
+             *     the IUT being in the 'authorized' state
+             * }
+             * Expected results:
+             * ensure that {
+             *     when {
+             *         the IUT is requested to send a Beacon
+             *     } then {
+             *         the IUT sends a SecuredMessage {
+             *             containing payload_fields
+             *                 containing exactly one element of type Payload
+             *                     containing type
+             *                         indicating 'signed' or 'signed_external' or 'signed_and_encrypted'
+             * }
+             * </pre>
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_GENMSG_06_01_BV
+             * @reference    ETSI TS 103 097 [1], clause 7.3
+             */
+            testcase TC_SEC_ITSS_SND_GENMSG_06_01_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                // Local variables
+                var LongPosVector v_longPosVectorIut;
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY) or not(PICS_ITS_AID_OTHER_PROFILE)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_ITS_AID_OTHER_PROFILE' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                v_longPosVectorIut := f_getPosition(c_compIut);
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_acTriggerEvent(m_startPassBeaconing(m_beaconHeader(v_longPosVectorIut).beaconHeader)); // Authorize the TA to forward the received beacons
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                tc_ac.start;
+                alt {
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage_Others(
+                                    ?, 
+                                    mw_payload(
+                                        e_signed
+                                    ) 
+                                ),
+                                mw_geoNwBeaconPacket(
+                                    ?
+                    )))) { 
+                        log("*** " & testcasename() & ": PASS: Beacon payload is 'signed'");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage_Others(
+                                    ?, 
+                                    mw_payload(
+                                        e_signed_external
+                                    ) 
+                                ),
+                                mw_geoNwBeaconPacket(
+                                    ?
+                    )))) { 
+                        log("*** " & testcasename() & ": PASS: Beacon payload is 'e_signed_external'");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage_Others(
+                                    ?, 
+                                    mw_payload(
+                                        e_signed_and_encrypted
+                                    ) 
+                                ),
+                                mw_geoNwBeaconPacket(
+                                    ?
+                    )))) { 
+                        log("*** " & testcasename() & ": PASS: Beacon payload is 'e_signed_and_encrypted'");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage_Others(
+                                    ?, 
+                                    mw_payload
+                                ),
+                                mw_geoNwBeaconPacket(
+                                    ?
+                    )))) { 
+                        log("*** " & testcasename() & ": FAIL: Beacon payload is not signed, signed_external or signed_and_encrypted");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    [] tc_ac.timeout {
+                        log("*** " & testcasename() & ": INCONC: Expected Message not received ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
+                    }
+                } // End of 'alt' statement
+                
+                // Postamble
+                f_acTriggerEvent(m_stopPassBeaconing);
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_SND_GENMSG_06_01_BV
+            
+            /**
+             * @desc   Check that the secured GN Message contains only one TrailerField of type signature ;
+             *         Check that the signature contained in the SecuredMessage is calculated over the right fields by 
+             *         cryptographically verifying the signature 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_ITS_AID_OTHER_PROFILE
+             * Config Id: CF01
+             * Initial conditions:
+             * with {
+             *   the IUT being in the 'authorized' state
+             * }
+             * ensure that {
+             *   when {
+             *     the IUT is requested to send Beacon
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields ['signer_info']
+             *             containing signer
+             *                 containing type
+             *                     indicating 'certificate'
+             *             and containing certificate
+             *                 indicating CERT
+             *         and containing trailer_fields['signature']
+             *             containing signature
+             *                 verifiable using CERT.subject_attributes['verification_key'] 
+             *   }
+             * }
+             * </pre>
+             * @see          ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_GENMSG_07_01_BV
+             * @reference    ETSI TS 103 097 [1], clause 7.3
+             */
+            testcase TC_SEC_ITSS_SND_GENMSG_07_01_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                
+                //  Local variables
+                var LongPosVector v_longPosVectorIut;
+                var GeoNetworkingInd v_geoNwInd;
+                var SignerInfo v_signerInfo;
+                
+                // Test adapter configuration
+                if (not(PICS_GN_SECURITY) or not(PICS_ITS_AID_OTHER_PROFILE)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_ITS_AID_OTHER_PROFILE' required for executing the TC ***");
+                    stop;
+                }
+                
+                // Test component configuration
+                f_cf01Up();
+                v_longPosVectorIut := f_getPosition(c_compIut);
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_acTriggerEvent(m_startPassBeaconing(m_beaconHeader(v_longPosVectorIut).beaconHeader)); // Authorize the TA to forward the received beacons
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                    
+                // Test Body
+                tc_ac.start;
+                alt {
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage_Others(
+                                    mw_header_field_signer_info_certificate
+                    )))) -> value v_geoNwInd { 
+                        tc_ac.stop;
+                        log("*** " & testcasename() & ": INFO: Beacon message with certificate received ***");
+                        f_getMsgSignerInfo(v_geoNwInd.msgIn.gnPacket.securedMsg, v_signerInfo);
+                        
+                        if (f_verifyGnSecuredMessageSignatureWithCertificate(v_geoNwInd.msgIn.gnPacket.securedMsg, v_signerInfo.signerInfo.certificate) == false) {
+                            log("*** " & testcasename() & ": FAIL: Beacon received with invalide signature");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                    }
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage_Others
+                    ))) { 
+                        tc_ac.stop;
+                        log("*** " & testcasename() & ": FAIL: Beacon message without certificate received");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    [] tc_ac.timeout {
+                        log("*** " & testcasename() & ": INCONC: Expected GN Message not received");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
+                    }
+                } // End of 'alt' statement
+                log("*** " & testcasename() & ": PASS: GN Message received with correct signature");
+                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                
+                // Postamble
+                f_acTriggerEvent(m_stopPassBeaconing);
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_SND_DENM_07_01_BV
+            
+        } // End of group sendOtherProfile
+        
+        /**
+         * @desc Sending behaviour test cases for certificates profile
+         * @see ETSI TS 103 096-2 V1.2.2 (2016-01) Clause 5.2.7 Profiles for certificates
+         */
+        group sendCertificatesProfile {
+            
+            /**
+             * @desc    Check that AT certificate has version 2
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with {
+             *   the IUT being in the 'authorized' state
+             *   the IUT being requested to include certificate in the next CAM
+             * }
+             * Expected Behaviour:
+             * ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating certificate
+             *             containing certificate
+             *                 containing version
+             *                     indicating '2'
+             *   }
+             * }
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_01_01_BV
+             * @reference   ETSI TS 103 097 [1], clauses 6.1 and 7.4.1
+             */
+            testcase TC_SEC_ITSS_SND_CERT_01_01_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                // Local variables
+                
+                // Test control
+                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
+                tc_ac.start;
+                alt {
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage(
+                                    superset(
+                                        mw_header_field_signer_info_certificate(
+                                            mw_certificate(
+                    ))))))) {
+                        tc_ac.stop;
+                        log("*** " & testcasename() & ": PASS: AT Certificate version set to " & int2char(c_certificate_version) & " ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage(
+                                    superset(
+                                        mw_header_field_signer_info_certificate(
+                                            ?
+                    )))))) {
+                        tc_ac.stop;
+                        log("*** " & testcasename() & ": FAIL: AT Certificate version mismatch ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    [] tc_ac.timeout {
+                        log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
+                    }
+                } // End of 'alt' statement
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+            } // End of testcase TC_SEC_ITSS_SND_CERT_01_01_BV
+            
+            /**
+             * @desc    Check that AA certificate has version 2
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with {
+             *   the IUT being in the 'authorized' state
+             *      the IUT being requested to include certificate chain in the next CAM
+             * }
+             * Expected Behaviour:
+             * ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate_chain'
+             *             and containing certificates
+             *                 indicating length > 0
+             *                 and containing certificates[n] (0..N)
+             *                     containing version
+             *                         indicating '2'
+             *   }
+             * }
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_01_02_BV
+             * @reference   ETSI TS 103 097 [1], clauses 6.1 and 7.4.1
+             */
+            testcase TC_SEC_ITSS_SND_CERT_01_02_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                // Local variables
+                var SecuredMessage v_recv;
+                var Certificate v_cert;
+                var SignerInfo v_si;
+                var HashedId8 v_digest;
+                
+                // Test control
+                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();
+                
+                // Wait for the message with the certificate to retrieve the AA digest.
+                // Ask for the chain, containing AT and AA certificate
+                // Check AA Certificate
+                log("*** " & testcasename() & ": INFO: Wait for certificate and ask for certificate chain  ***");
+                tc_ac.start;
+                f_askForCertificateChain(f_generateDefaultCam());
+                tc_ac.stop;
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test Body
+                tc_ac.start;
+                alt {
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage(
+                                    superset(
+                                        mw_header_field_signer_info_certificate_chain(
+                                            superset(
+                                                mw_aa_certificate
+                    ))))))) {
+                        tc_ac.stop;
+                        log("*** " & testcasename() & ": PASS: AA certificate version set to " & int2char(c_certificate_version) & " ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                    }
+                    [] geoNetworkingPort.receive(
+                        mw_geoNwInd(
+                            mw_geoNwSecPdu(
+                                mdw_securedMessage(
+                                    superset(
+                                        mw_header_field_signer_info_certificate_chain
+                    ))))) {
+                        tc_ac.stop;
+                        log("*** " & testcasename() & ": FAIL: AA certificate version mismatch or no AA cert received***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    [] tc_ac.timeout {
+                        log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
+                    }
+                } // End of 'alt' statement
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+                
+            } // End of testcase TC_SEC_ITSS_SND_CERT_01_02_BV
+            
+            /**
+             * @desc    Check that the references in the certificate chain are valid
+             *          Check that signer_info type of all certificates in the chain are 'certificate_digest_with_sha256', 
+             *          'certificate_digest_with_other_algorithm' or 'self'
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY
+             * Config Id: CF01
+             * Initial conditions:
+             * with {
+             *   the IUT being in the 'authorized' state
+             *   the IUT being requested to include certificate chain in the next CAM
+             * } ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate_chain'
+             *             and containing certificates
+             *                 indicating length > 0
+             *             and containing certificates[0]
+             *                 containing signer_info
+             *                     containing type
+             *                         indicating 'certificate_digest_with_sha256'
+             *                         or indicating 'certificate_digest_with_other_algorythm'
+             *                     and containing digest
+             *                         referenced to the trusted certificate
+             *                 or containing signer_info
+             *                     containing type
+             *                         indicating 'self'
+             *             and containing certificates[n] (1..N)
+             *                 containing signer_info
+             *                     containing type
+             *                         indicating 'certificate_digest_with_sha256'
+             *                         or indicating 'certificate_digest_with_other_algorythm'
+             *                     and containing digest
+             *                         referenced to the certificates[n-1]
+             * }
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_02_01_BV
+             * @reference   ETSI TS 103 097 [1], clause 4.2.10, 6.1 and 7.4.1
+             */
+            testcase TC_SEC_ITSS_SND_CERT_02_01_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                // Local declarations
+                var CertificateChain v_chain;
+                var SignerInfo v_si;
+                var HashedId8 v_digest;
+                
+                // Test control
+                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);
+                
+                log("*** " & testcasename() & ": INFO: Request and waiting for the message containing certificate chain  ***");
+                tc_ac.start;
+                if (not f_askAndWaitForCertificateChain(v_chain, f_generateDefaultCam())) {
+                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
+                }
+                tc_ac.stop;
+                
+                // Test Body
+                for (var integer v_counter := lengthof(v_chain) - 1; v_counter > 1; v_counter := v_counter - 1) { // Loop on []N-1..1]
+                    if (not f_getCertificateSignerInfo(v_chain[v_counter], v_si)) {
+                        log("*** " & testcasename() & ": FAIL: Certificate[ " & int2str(v_counter) & "] doesn't contain signer info ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                    if (v_si.type_ != e_certificate_digest_with_sha256) {
+                    	if (v_si.type_ != e_certificate_digest_with_other_algorithm or PICS_PLUGTEST_VERSION) {
+                        	log("*** " & testcasename() & ": FAIL: Certificate is not signed with digest ***");
+	                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    	}
+                    }
+                    // signer_info.type indicates 'certificate_digest_with_sha256' or 'certificate_digest_with_other_algorythm'
+                    
+                    v_digest := f_calculateDigestFromCertificate(v_chain[v_counter - 1]);
+                    if (not match (v_si.signerInfo.digest, v_digest)) {
+                        log("*** " & testcasename() & ": FAIL: Certificate chain is not valid ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                    }
+                } // End of 'for' statement
+                // Process certificate[0]
+                if (not f_getCertificateSignerInfo(v_chain[0], v_si)) {
+                    log("*** " & testcasename() & ": FAIL: Certificate[0] doesn't contain signer info ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                // Process certificate[0]
+                if (v_si.type_ != e_certificate_digest_with_sha256) {
+                    log("*** " & testcasename() & ": FAIL: Certificate[0] is not signed with digest ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                }
+                // signer_info.type indicates 'certificate_digest_with_sha256' only
+                log("*** " & testcasename() & ": PASS: Certificate chain is well signed ***");
+                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+                
+            } // End of testcase TC_SEC_ITSS_SND_CERT_02_01_BV
+            
+            /**
+             * @desc Check that the rectangular region validity restriction of the message signing certificate 
+             *       contains not more than six valid rectangles; 
+             *       Check that the rectangular region validity restriction of the message signing certificate is 
+             *       continuous and does not contain any holes 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_RECTANGULAR_REGION
+             * Config Id: CF01
+             * with {
+             *   the IUT being in the 'authorized' state
+             *   the IUT being requested to include certificate in the next CAM
+             * } ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate'
+             *             containing certificate
+             *                 containing validity_restrictions['region']
+             *                     containing region_type
+             *                         indicating 'rectangle'
+             *                     and containing rectangular_region
+             *                         indicating length <= 6
+             *                         and containing elements of type RectangularRegion
+             *                             indicating continuous region without holes
+             *                             and containing northwest and southeast
+             *                                 indicating northwest is on the north from southeast
+             *   }
+             * }
+             * @remark Certificate: cc_taCert_C
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_04_01_BV
+             * @reference   ETSI TS 103 097 [1], clauses 4.2.20 and 4.2.23
+             */
+            testcase TC_SEC_ITSS_SND_CERT_04_01_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                // Local variables
+                var Certificate         v_cert;
+                var ValidityRestriction v_vr;
+                var integer             v_counter;
+                
+                // Test control
+                if (not(PICS_GN_SECURITY) or not(PICS_CERTIFICATE_SELECTION) or not(PICS_USE_RECTANGULAR_REGION)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_RECTANGULAR_REGION' required for executing the TC ***");
+                    stop;
+                }
+                    
+                // Test component configuration
+                vc_hashedId8ToBeUsed := cc_iutCert_C;
+                f_cf01Up();
+                    
+                // Test adapter configuration
+                    
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test body
+                tc_ac.start;
+                if (not f_waitForCertificate(v_cert)) {
+                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
+                }
+                tc_ac.stop;
+                if (f_getCertificateValidityRestriction(v_cert, e_region, v_vr)) {
+                    if (v_vr.validity.region.region_type == e_rectangle) {
+                        var RectangularRegions v_rects := v_vr.validity.region.region.rectangular_region;
+                        if (lengthof(v_rects) > 6) {
+                            log("*** " & testcasename() & ": FAIL: Rectangular regions count is greather than 6 ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        for (v_counter := 0; v_counter<lengthof(v_rects); v_counter := v_counter + 1) {
+                            var RectangularRegion v_rect := v_rects[v_counter];
+                            if (true != f_isValidTwoDLocation(v_rect.northwest)) {
+                                log("*** " & testcasename() & ": FAIL: Northwest location is invalid in rect " & int2str(v_counter) & " ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                            if (true != f_isValidTwoDLocation(v_rect.southeast)) {
+                                log("*** " & testcasename() & ": FAIL: Southeast location is invalid in rect " & int2str(v_counter) & " ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                            // Check normality of the rectangle
+                            if (v_rect.northwest.latitude < v_rect.southeast.latitude) {
+                                log("*** " & testcasename() & ": FAIL: Rectangular region " & int2str(v_counter) & " is not normalized ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                        } // End of 'for' statement
+                        
+                        // Check for continuous rectangles
+                        if (lengthof(v_rects) > 1) { 
+                            if (true !=  f_isContinuousRectangularRegions(v_rects)) { // FIXME Not implemented
+                                log("*** " & testcasename() & ": FAIL: Rectangular regions are not connected all together ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            } else {
+                                log("*** " & testcasename() & ": PASS: Certificate has a valid rectangular region restrictions ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                            }
+                        }
+                    } else {
+                        log("*** " & testcasename() & ": INCONC: Certificate has other region type ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout); // to be inconc
+                    }
+                } else {
+                    log("*** " & testcasename() & ": PASS: Certificate doesn't have any location restrictions ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+                
+            } // End of testcase TC_SEC_ITSS_SND_CERT_04_01_BV
+            
+            /**
+             * @desc Check that the rectangular region validity restriction of all certificates contains not more than 
+             *       six valid rectangles; 
+             *       Check that the rectangular region validity restriction of the AT certificate is continuous and 
+             *       does not contain any holes 
+             *       Check that the rectangular certificate validity region of the subordinate certificate is well formed and 
+             *       inside the validity region of the issuing certificate 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_RECTANGULAR_REGION
+             * Config Id: CF01
+             * with {
+             *     the IUT being in the 'authorized' state
+             *     the IUT being requested to include certificate chain in the next CAM
+             * } ensure that {
+             *   when {
+             *     the IUT is requested to send a CAM
+             * } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate_chain'
+             *             containing certificates
+             *                indicating length N > 0
+             *                and containing certificates [n] 0..n
+             *                    containing validity_restrictions['region']
+             *                        containing region_type
+             *                            indicating 'rectangle'
+             *                        and containing rectangular_region
+             *                            indicating length <= 6
+             *                            and containing elements of type RectangularRegion
+             *                                containing northwest and southeast
+             *                                    indicating northwest  on the north from southeast
+             *                                and indicating continuous region without holes
+             *    }
+             * }
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_04_02_BV
+             * @reference   ETSI TS 103 097 [1], clauses 4.2.20 and 4.2.23
+             */
+            testcase TC_SEC_ITSS_SND_CERT_04_02_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                // Local variables
+                var CertificateChain    v_chain;
+                var ValidityRestriction v_vr := valueof(m_validity_restriction_unknown), v_vri := valueof(m_validity_restriction_unknown);  // current and issuing cert validity restrictions
+                var boolean             f_vr := false, f_vri := false;
+                
+                // Test control
+                if (not(PICS_GN_SECURITY) or not(PICS_CERTIFICATE_SELECTION) or not(PICS_USE_RECTANGULAR_REGION)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_RECTANGULAR_REGION' required for executing the TC ***");
+                    stop;
+                }
+                    
+                // Test component configuration
+                vc_hashedId8ToBeUsed := cc_iutCert_C;
+                f_cf01Up();
+                    
+                // Test adapter configuration
+                    
+                // Preamble
+                f_prNeighbour();
+                log("*** " & testcasename() & ": INFO: Request and waiting for the message containing certificate chain  ***");
+                tc_ac.start;
+                if (not f_askAndWaitForCertificateChain(v_chain, f_generateDefaultCam())) {
+                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
+                } else {
+                    f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                }
+                
+                // Test Body
+                tc_ac.stop;
+                for (var integer v_counter := 0; v_counter < lengthof(v_chain); v_counter := v_counter + 1) {
+                    v_vri := v_vr;
+                    f_vri := f_vr;
+                    f_vr := f_getCertificateValidityRestriction(v_chain[v_counter], e_region, v_vr);
+                    log("v_chain[v_counter]=", v_chain[v_counter]);
+                    if (f_vr) {
+                        var RectangularRegions v_rects;
+                        if (v_vr.validity.region.region_type != e_rectangle) {
+                            log("*** " & testcasename() & ": INCONC: Certificate validity restriction region is not rectangular ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        v_rects := v_vr.validity.region.region.rectangular_region;
+                        log("v_rects=", v_rects);
+                        if (lengthof(v_rects) > 6) {
+                            log("*** " & testcasename() & ": FAIL: Rectangular regions count is greather than 6 ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        for (var integer j:=0; j<lengthof(v_rects); j:=j + 1) {
+                            var RectangularRegion v_rect := v_rects[j];
+                            if (true != f_isValidTwoDLocation(v_rect.northwest)) {
+                                log("*** " & testcasename() & ": FAIL: Northwest location is invalid in rect " & int2str(v_counter) & " ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                            if (true != f_isValidTwoDLocation(v_rect.southeast)) {
+                                log("*** " & testcasename() & ": FAIL: Southeast location is invalid in rect " & int2str(v_counter) & " ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                            // Check normality of the rectangle
+                            if (v_rect.northwest.latitude < v_rect.southeast.latitude) {
+                                log("*** " & testcasename() & ": FAIL: Rectangle " & int2str(v_counter) & " is not normalized ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                        }
+                        if (f_vri) {
+                            // current restrictions must be inside of the parent one
+                            if (not f_isRectangularRegionsInside(v_vri.validity.region.region.rectangular_region, v_rects)) {
+                                log("*** " & testcasename() & ": FAIL: Certificate validity restriction region is not inside the issuing one ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                        }
+                    } else {
+                        // Region validity restriction is not exist
+                        if (f_vri) {
+                            log("*** " & testcasename() & ": FAIL: Certificate validity restriction region must be set if thi restriction exists in the issuing certificate ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                    }
+                } // End of 'for' statement
+                // FIXME Check holes
+                log("*** " & testcasename() & ": PASS: All certificates has a valid rectangular region restrictions ***");
+                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+                
+            } // End of testcase TC_SEC_ITSS_SND_CERT_04_02_BV
+            
+            /**
+             * @desc Check that the polygonal certificate validity region contains at least three and no more than 12 points
+             *       Check that the polygonal certificate validity region does not contain intersections and holes 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_POLYGONAL_REGION
+             * Config Id: CF01
+             * with {
+             *   the IUT being in the 'authorized' state
+             *   the IUT being requested to include certificate in the next CAM
+             * } ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate'
+             *             containing certificate
+             *                 containing validity_restrictions['region']
+             *                 and containing region_type
+             *                     indicating 'polygon'
+             *                 and containing polygonal_region 
+             *                     indicating length >=3 and <=12
+             *                     and indicating continuous region without holes and intersections
+             *   }
+             * }
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_05_01_BV
+             * @reference   ETSI TS 103 097 [1], clause 4.2.24
+             */
+            testcase TC_SEC_ITSS_SND_CERT_05_01_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                var Certificate         v_cert;
+                var ValidityRestriction v_vr;
+                var integer             v_counter;
+                
+                // Test control
+                if (not(PICS_GN_SECURITY) or not(PICS_CERTIFICATE_SELECTION) or not(PICS_USE_POLYGONAL_REGION)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_POLYGONAL_REGION' required for executing the TC ***");
+                    stop;
+                }
+                    
+                // Test component configuration
+                vc_hashedId8ToBeUsed := cc_iutCert_D;
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                
+                // Test body
+                tc_ac.start;
+                if (not f_waitForCertificate(v_cert)) {
+                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
+                }
+                tc_ac.stop;
+                if (f_getCertificateValidityRestriction(v_cert, e_region, v_vr)) { 
+                    if (v_vr.validity.region.region_type == e_polygon) {
+                        var PolygonalRegion v_pr := v_vr.validity.region.region.polygonal_region;
+                        var integer v_length := lengthof(v_pr);
+                        if (v_length < 3) {
+                            log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too small ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        if (v_length > 12) {
+                            log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too big ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        if (true != f_isValidPolygonalRegion(v_pr)) {
+                            log("*** " & testcasename() & ": FAIL: Polygonal region is not valid (self-intersected) ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        log("*** " & testcasename() & ": PASS: Certificate has a valid rectangular region restrictions ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                        // FIXME Check holes
+                    } else {
+                        log("*** " & testcasename() & ": INCONC: Certificate has other region type ***");
+                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout); // to be inconc
+                    }
+                } else {
+                    log("*** " & testcasename() & ": PASS: Certificate doesn't have any location restrictions ***");
+                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                }
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+                
+            } // End of testcase TC_SEC_ITSS_SND_CERT_05_01_BV
+            
+            /**
+             * @desc Check that the polygonal certificate validity region is inside the validity region of the issuing certificate
+             *       Check that the issuing polygonal certificate validity region contains at least three and no more than 12 points 
+             *       Check that the issuing polygonal certificate validity region does not contain intersections and holes 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_POLYGONAL_REGION
+             * Config Id: CF01
+             * with {
+             *   the IUT being in the 'authorized' state
+             *   the IUT being requested to include certificate chain in the next CAM
+             * } ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate_chain'
+             *             and containing certificates
+             *                 indicating length > 0
+             *             and containing certificates [n] (0..n)
+             *                 containing validity_restrictions['region']
+             *                     containing region_type
+             *                         indicating 'polygon'
+             *                     and containing polygonal_region
+             *                         indicating length >=3 and <=12
+             *                         and indicating continuous region without holes and intersections
+             *   }
+             * }
+             * </pre>
+             * @see         ETSI TS 103 096-2 v1.3.2 TP_SEC_ITSS_SND_CERT_05_02_BV
+             * @reference   ETSI TS 103 097 [1], clause 4.2.24
+             */
+            testcase TC_SEC_ITSS_SND_CERT_05_02_BV() runs on ItsGeoNetworking system ItsSecSystem {
+                // Local declarations
+                var CertificateChain    v_chain;
+                var ValidityRestriction v_vr := valueof(m_validity_restriction_unknown), v_vri := valueof(m_validity_restriction_unknown);  // current and issuing cert validity restrictions
+                var boolean f_vr := false, f_vri := false;
+                
+                // Test control
+                if (not(PICS_GN_SECURITY) or not(PICS_CERTIFICATE_SELECTION) or not(PICS_USE_POLYGONAL_REGION)) {
+                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_POLYGONAL_REGION' required for executing the TC ***");
+                    stop;
+                }
+                    
+                // Test component configuration
+                vc_hashedId8ToBeUsed := cc_iutCert_D;
+                f_cf01Up();
+                
+                // Test adapter configuration
+                
+                // Preamble
+                f_prNeighbour();
+                log("*** " & testcasename() & ": INFO: Request and waiting for the message containing certificate chain  ***");
+                tc_ac.start;
+                if (not f_askAndWaitForCertificateChain(v_chain, f_generateDefaultCam())) {
+                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
+                    f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
+                } else {
+                    f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
+                }
+                
+                // Test Body
+                f_vr := false;
+                tc_ac.stop;
+                for (var integer v_counter := 0; v_counter < lengthof(v_chain); v_counter := v_counter + 1) {
+                    v_vri := v_vr;
+                    f_vri := f_vr;
+                    f_vr := f_getCertificateValidityRestriction(v_chain[v_counter], e_region, v_vr);
+                    if (f_vr) {
+                        var PolygonalRegion v_pr;
+                        var integer v_length;
+                        
+                        if (v_vr.validity.region.region_type != e_polygon) {
+                            log("*** " & testcasename() & ": INCONC: Certificate validity restriction region is not polygonal ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        
+                        v_pr := v_vr.validity.region.region.polygonal_region;
+                        v_length := lengthof(v_pr);
+                        
+                        if (v_length < 3) {
+                            log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too small in cert " & int2str(v_counter) & " ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        
+                        if (v_length > 12) {
+                            log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too big  in cert " & int2str(v_counter) & "***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        
+                        if (true != f_isValidPolygonalRegion(v_pr)) {
+                            log("*** " & testcasename() & ": FAIL: Polygonal region is not valid (self-intersected) in cert " & int2str(v_counter) & " ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                        
+                        if (f_vri) {
+                            // current restrictions must be inside of the parent one
+                            if (true != f_isPolygonalRegionInside(v_vri.validity.region.region.polygonal_region, v_pr)) {
+                                log("*** " & testcasename() & ": FAIL: Certificate validity restriction region in cert " & int2str(v_counter) & " is not inside the issuing one ***");
+                                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                            }
+                            // FIXME Check holes
+                        }
+                    } else {
+                        // Region validity restriction is not exist
+                        if (f_vri) {
+                            log("*** " & testcasename() & ": FAIL: Certificate validity restriction region must be set in the certificate "  & int2str(v_counter) &
+                                                                  "because this restriction exists in the issuing certificate ***");
+                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
+                        }
+                    }
+                } // End of 'for' statement
+                log("*** " & testcasename() & ": PASS: All certificates has a valid polygonal region restrictions ***");
+                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
+                
+                // Postamble
+                f_poNeighbour();
+                f_cf01Down();
+                
+            } // End of testcase TC_SEC_ITSS_SND_CERT_05_02_BV
+            
+            /**
+             * @desc Check that the identified certificate validity region contains values that correspond to numeric country codes 
+             *       as defined in ISO 3166-1 or defined by United Nations Statistics Division 
+             * <pre>
+             * Pics Selection: PICS_GN_SECURITY and PICS_CERTIFICATE_SELECTION and PICS_USE_IDENTIFIED_REGION
+             * Config Id: CF01
+             * with {
+             *   the IUT being in the 'authorized' state
+             *   the IUT being requested to include certificate in the next CAM
+             * } ensure that {
+             *    when {
+             *     the IUT is requested to send a CAM
+             *   } then {
+             *     the IUT sends a SecuredMessage
+             *         containing header_fields['signer_info'].signer
+             *             containing type
+             *                 indicating 'certificate'
+             *             and containing certificate 
+             *                 containing validity_restrictions['region']
+             *                     containing region
+             *                         containing region_type
+             *                             indicating 'id'
+             *                         and containing id_region
+             *                             containing region_dictionary
+             *                                 indicating 'iso_3166_1' (0)