LibItsSecurity_Functions.ttcn

                return true;
            } // End of function f_getCertificateDigest
            
            function f_getCertificateFromDigest(
                                                in HashedId8 p_digest, 
                                                out EtsiTs103097Certificate p_certificate
            ) runs on ItsSecurityBaseComponent return boolean {
                var charstring v_certificate_id;
                if (not(fx_readCertificateFromDigest(p_digest, v_certificate_id))) {
                    log("f_getCertificateFromDigest: Failed to retrieve digest for ", p_digest);
                    return false;
                }
                if (not(f_readCertificate(v_certificate_id, p_certificate))) {
                    log("f_getCertificateFromDigest: Failed to retrieve digest for ", v_certificate_id);
                    return false;
                }
                return true;
            } // End of function f_getCertificateFromDigest
            
            /**
            * @desc    Read the signing private key for the specified certificate
            * @param   p_keysId            the keys identifier
            * @param   p_signingPrivateKey the signing private key
            * @return  true on success, false otherwise
            */
            function f_readSigningKey(
                                       in charstring p_keysId,
                                       out Oct32 p_signingPrivateKey
            ) runs on ItsSecurityBaseComponent return boolean {
                return fx_readSigningKey(p_keysId, p_signingPrivateKey);
            } // End of function f_readSigningKey
            
            /**
            * @desc    Read the encrypting private keys for the specified certificate
            * @param   p_keysId            the keys identifier
            * @param   p_encryptPrivateKey the encrypt private key
            * @return  true on success, false otherwise
            */
            function f_readEncryptingKey(
                                         in charstring p_keysId,
                                         out Oct32 p_encryptPrivateKey
            ) runs on ItsSecurityBaseComponent return boolean {
                return fx_readEncryptingKey(p_keysId, p_encryptPrivateKey);
            } // End of function f_readEncryptingKey
            
            function f_getCertificateValidityRestriction(
                                                         in template (value) EtsiTs103097Certificate p_cert,
                                                         out template (value) ValidityPeriod p_validityPeriod,
                                                         out template (omit) GeographicRegion p_geographicRegion
            ) return boolean {
                p_validityPeriod := valueof(p_cert.toBeSigned.validityPeriod);
                if (ispresent(p_cert.toBeSigned.region)) {
                    p_geographicRegion := valueof(p_cert.toBeSigned.region);
                } else {
                    p_geographicRegion := omit;
                }
                return true;
            } // End of function f_getCertificateValidityRestriction
            
        }// End of group certificateGetters
        
        group certificatesCaching {
            
            function f_createCertificatesCaching(
                                                 in SequenceOfCertificate p_certificates, 
                                                 out CertificatesCaching p_certificatesCaching
            ) return boolean {
                p_certificatesCaching := { };
                for (var integer v_counter := 0; v_counter < lengthof(p_certificates); v_counter := v_counter + 1) {
                    var CertificatesCachingItem v_item;
                    v_item.certificate := p_certificates[v_counter];
                    v_item.hashedId8 := f_calculateDigestSha256FromCertificate(v_item.certificate);
                    p_certificatesCaching[v_counter] := v_item;
                } // End of 'for' statement
                
                return true;
            }
            
            function f_getCertificateFromCaching(
                                                 in CertificatesCaching p_certificatesCaching, 
                                                 in HashedId8 p_hashedId8, 
                                                 out EtsiTs103097Certificate p_certificate
            ) return boolean {
                for (var integer v_counter := 0; v_counter < lengthof(p_certificatesCaching); v_counter := v_counter + 1) { 
                    if (match(p_certificatesCaching[v_counter].hashedId8, p_hashedId8) == true) {
                        p_certificate := p_certificatesCaching[v_counter].certificate;
                        return true;
                    }
                } // End of 'for' statement
                
                return false;
            }
            
            function f_getCertificatesCachingItem(
                                                  in CertificatesCaching p_certificatesCaching, 
                                                  in UInt8 p_index, 
                                                  out EtsiTs103097Certificate p_certificate
            ) return boolean {
                if (lengthof(p_certificatesCaching) < p_index) {
                    p_certificate := p_certificatesCaching[p_index].certificate;
                    return true;
                }
                
                return false;
            }
            
            function f_getCertificatesCachingItemSize(
                                                      in CertificatesCaching p_certificatesCaching
            ) return UInt8 {
                return lengthof(p_certificatesCaching);
            }
            
        }// End of group certificatesCaching
        
        
    } // End of group helpersFunctions

    group externalFunctions {
        
        group signing {
            
            /**
             * @desc    Produces a 256-bit (32-byte) hash value
             * @param   p_toBeHashedData Data to be used to calculate the hash value
             * @return  The hash value
             */
            external function fx_hashWithSha256(in octetstring p_toBeHashedData) return Oct32;
            
            /**
             * @desc    Produces a 384-bit (48-byte) hash value
             * @param   p_toBeHashedData Data to be used to calculate the hash value
             * @return  The hash value
             */
            external function fx_hashWithSha384(in octetstring p_toBeHashedData) return Oct48;
            
            external function fx_test_hmac_sha256(in octetstring p_k, in octetstring p_m) return octetstring;
            /**
             * @desc    Test function the validate AES128 CCM encryption based on IEEE Std 1609.2-20XX Annex D.6.1 AES-CCM-128
             * @return  The encrypted test
             */
            external function fx_test_encrypt_aes_128_ccm_test(in octetstring p_k, in octetstring p_n, in octetstring p_pt) return octetstring;
            
            /**
             * @desc    Test function the validate AES128 CCM decryption based on IEEE Std 1609.2-20XX Annex D.6.1 AES-CCM-128
             * @return  The decrypted test
             */
            external function fx_test_decrypt_aes_128_ccm_test(in octetstring p_k, in octetstring p_n, in octetstring p_pt) return octetstring;
            
            /**
             * @desc    Produces a Elliptic Curve Digital Encrytion Algorithm (ECIES) encryption using Nist-P256 algorithm
             * @param   p_toBeEncryptedSecuredMessage    The data to be encrypted
             * @param   p_recipientsPublicKeyX           The Recipient's public encryption key X-coordinate
             * @param   p_recipientsPublicKeyY           The Recipient's public encryption key Y-coordinate
             * @param   p_publicEphemeralKeyX            The generated ephemeral key X-coordinate
             * @param   p_publicEphemeralKeyY            The generated ephemeral key Y-coordinate
             * @param   p_encrypted_sym_key              The encrypted AES 128 CCM symmetric key
             * @param   p_authentication_vector          The tag of the AES 128 CCM symmetric key encryption
             * @param   p_nonce                          The nonce vector of the AES 128 CCM symmetric key encryption
             * @return  The encrypted message
             */
            external function fx_encryptWithEciesNistp256WithSha256(in octetstring p_toBeEncryptedSecuredMessage, in Oct32 p_recipientsPublicKeyX, in Oct32 p_recipientsPublicKeyY, out Oct32 p_publicEphemeralKeyX, out Oct32 p_publicEphemeralKeyY, out Oct16 p_encrypted_sym_key, out Oct16 p_authentication_vector, out Oct12 p_nonce) return octetstring;
            
            /**
             * @desc    Produces a Elliptic Curve Digital Encrytion Algorithm (ECIES) decryption using Nist-P256 algorithm
             * @param   p_encryptedSecuredMessage    The data to be decrypted
             * @param   p_publicEphemeralKeyX            The generated ephemeral key X-coordinate
             * @param   p_publicEphemeralKeyY            The generated ephemeral key Y-coordinate
             * @param   p_encrypted_sym_key              The encrypted AES 128 CCM symmetric key
             * @param   p_authentication_vector          The tag of the AES 128 CCM symmetric key encryption
             * @param   p_nonce                          The nonce vector of the AES 128 CCM symmetric key encryption
             * @return  The decrypted message
             */
            external function fx_decryptWithEciesNistp256WithSha256(in octetstring p_encryptedSecuredMessage, in Oct32 p_privateEncKey, in Oct32 p_publicEphemeralKeyX, in Oct32 p_publicEphemeralKeyY, in Oct16 p_encrypted_sym_key, in Oct16 p_authentication_vector, in Oct12 p_nonce) return octetstring;
            
            /**
             * @desc    Produces a Elliptic Curve Digital Encrytion Algorithm (ECIES) encryption using Brainpool-P256 algorithm
             * @param   p_toBeEncryptedSecuredMessage    The data to be encrypted
             * @param   p_recipientsPublicKeyX           The Recipient's public encryption key X-coordinate
             * @param   p_recipientsPublicKeyY           The Recipient's public encryption key Y-coordinate
             * @param   p_publicEphemeralKeyX            The generated ephemeral key X-coordinate
             * @param   p_publicEphemeralKeyY            The generated ephemeral key Y-coordinate
             * @param   p_encrypted_sym_key              The encrypted AES 128 CCM symmetric key
             * @param   p_authentication_vector          The tag of the AES 128 CCM symmetric key encryption
             * @param   p_nonce                          The nonce vector of the AES 128 CCM symmetric key encryption
             * @return  The encrypted message
             */
            external function fx_encryptWithEciesBrainpoolp256WithSha256(in octetstring p_toBeEncryptedSecuredMessage, in Oct32 p_recipientsPublicKeyX, in Oct32 p_recipientsPublicKeyY, out Oct32 p_publicEphemeralKeyX, out Oct32 p_publicEphemeralKeyY, out Oct16 p_encrypted_sym_key, out Oct16 p_authentication_vector, out Oct12 p_nonce) return octetstring;
            
            /**
             * @desc    Produces a Elliptic Curve Digital Encrytion Algorithm (ECIES) decryption using Brainpool-P256 algorithm
             * @param   p_encryptedSecuredMessage    The data to be decrypted
             * @param   p_publicEphemeralKeyX            The generated ephemeral key X-coordinate
             * @param   p_publicEphemeralKeyY            The generated ephemeral key Y-coordinate
             * @param   p_encrypted_sym_key              The encrypted AES 128 CCM symmetric key
             * @param   p_authentication_vector          The tag of the AES 128 CCM symmetric key encryption
             * @param   p_nonce                          The nonce vector of the AES 128 CCM symmetric key encryption
             * @return  The decrypted message
             */
            external function fx_decryptWithEciesBrainpoolp256WithSha256(in octetstring p_encryptedSecuredMessage, in Oct32 p_privateEncKey, in Oct32 p_publicEphemeralKeyX, in Oct32 p_publicEphemeralKeyY, in Oct16 p_encrypted_sym_key, in Oct16 p_authentication_vector, in Oct12 p_nonce) return octetstring;
            
            /**
             * @desc    Produces a Elliptic Curve Digital Signature Algorithm (ECDSA) signature
             * @param   p_toBeSignedSecuredMessage    The data to be signed
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_privateKey        The private key
             * @return  The signature value
             */
            external function fx_signWithEcdsaNistp256WithSha256(in Oct32 p_toBeSignedSecuredMessage, in HashedId8 p_certificateIssuer, in Oct32 p_privateKey) return octetstring;

            /**
             * @desc    Produces a Elliptic Curve Digital Signature Algorithm (ECDSA) signature
             * @param   p_toBeSignedSecuredMessage    The data to be signed
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_privateKey        The private key
             * @return  The signature value
             */
            external function fx_signWithEcdsaBrainpoolp256WithSha256(in Oct32 p_toBeSignedSecuredMessage, in HashedId8 p_certificateIssuer, in Oct32 p_privateKey) return octetstring;
            
            /**
             * @desc    Produces a Elliptic Curve Digital Signature Algorithm (ECDSA) signature
             * @param   p_toBeSignedSecuredMessage    The data to be signed
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_privateKey        The private key
             * @return  The signature value
             */
            external function fx_signWithEcdsaBrainpoolp384WithSha384(in Oct48 p_toBeSignedSecuredMessage, in HashedId8 p_certificateIssuer, in Oct48 p_privateKey) return octetstring;
            
            /**
             * @desc    Verify the signature of the specified data
             * @param   p_toBeVerifiedData          The data to be verified
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_signature                 The signature
             * @param   p_ecdsaNistp256PublicKeyCompressed   The compressed public key (x coordinate only)
             * @return  true on success, false otherwise
             */
            external function fx_verifyWithEcdsaNistp256WithSha256(in Oct32 p_toBeVerifiedData, in HashedId8 p_certificateIssuer, in octetstring p_signature, in Oct32 p_ecdsaNistp256PublicKeyCompressed, in integer p_compressedMode) return boolean;
            
            /**
             * @desc    Verify the signature of the specified data
             * @param   p_toBeVerifiedData          The data to be verified
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_signature                 The signature
             * @param   p_ecdsaNistp256PublicKeyX   The public key (x coordinate)
             * @param   p_ecdsaNistp256PublicKeyY   The public key (y coordinate)
             * @return  true on success, false otherwise
             */
            external function fx_verifyWithEcdsaNistp256WithSha256_1(in Oct32 p_toBeVerifiedData, in HashedId8 p_certificateIssuer, in octetstring p_signature, in Oct32 p_ecdsaNistp256PublicKeyX, in Oct32 p_ecdsaNistp256PublicKeyY) return boolean;
            
            /**
             * @desc    Verify the signature of the specified data
             * @param   p_toBeVerifiedData          The data to be verified
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_signature                 The signature
             * @param   p_ecdsaBrainpoolp256PublicKeyCompressed   The compressed public key (x coordinate only)
             * @return  true on success, false otherwise
             */
            external function fx_verifyWithEcdsaBrainpoolp256WithSha256(in Oct32 p_toBeVerifiedData, in HashedId8 p_certificateIssuer, in octetstring p_signature, in Oct32 p_ecdsaBrainpoolp256PublicKeyCompressed, in integer p_compressedMode) return boolean;
            
            /**
             * @desc    Verify the signature of the specified data
             * @param   p_toBeVerifiedData          The data to be verified
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_signature                 The signature
             * @param   p_ecdsaBrainpoolp256PublicKeyX   The public key (x coordinate)
             * @param   p_ecdsaBrainpoolp256PublicKeyY   The public key (y coordinate)
             * @return  true on success, false otherwise
             */
            external function fx_verifyWithEcdsaBrainpoolp256WithSha256_1(in Oct32 p_toBeVerifiedData, in HashedId8 p_certificateIssuer, in octetstring p_signature, in Oct32 p_ecdsaBrainpoolp256PublicKeyX, in Oct32 p_ecdsaBrainpoolp256PublicKeyY) return boolean;
            
            /**
             * @desc    Verify the signature of the specified data
             * @param   p_toBeVerifiedData          The data to be verified
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_signature                 The signature
             * @param   p_ecdsaBrainpoolp384PublicKeyCompressed   The compressed public key (x coordinate)
             * @return  true on success, false otherwise
             */
            external function fx_verifyWithEcdsaBrainpoolp384WithSha384(in Oct48 p_toBeVerifiedData, in HashedId8 p_certificateIssuer, in octetstring p_signature, in Oct48 p_ecdsaBrainpoolp384PublicKeyCompressed, in integer p_compressedMode) return boolean;
            
            /**
             * @desc    Verify the signature of the specified data
             * @param   p_toBeVerifiedData          The data to be verified
             * @param   p_certificateIssuer         The digest of the certificate issuer
             * @param   p_signature                 The signature
             * @param   p_ecdsaBrainpoolp384PublicKeyCompressed   The compressed public key (x coordinate only)
             * @return  true on success, false otherwise
             */
            external function fx_verifyWithEcdsaBrainpoolp384WithSha384_1(in Oct48 p_toBeVerifiedData, in HashedId8 p_certificateIssuer, in octetstring p_signature, in Oct48 p_ecdsaBrainpoolp384PublicKeyX, in Oct48 p_ecdsaBrainpoolp384PublicKeyY) return boolean;
            
            /**
             * @desc    Produce a new public/private key pair based on Elliptic Curve Digital Signature Algorithm (ECDSA) algorithm.
             *          This function should not be used by the ATS
             * @param   p_privateKey    The new private key value
             * @param   p_publicKeyX    The new public key value (x coordinate)
             * @param   p_publicKeyX    The new public key value (y coordinate)
             * @param   p_publicKeyCompressed The compressed public keys
             * @param   p_compressedMode The compressed mode, 0 if the latest bit of Y-coordinate is 0, 1 otherwise
             * @return  true on success, false otherwise
             */
            external function fx_generateKeyPair_nistp256(out Oct32 p_privateKey, out Oct32 p_publicKeyX, out Oct32 p_publicKeyY, out Oct32 p_publicKeyCompressed, out integer p_compressedMode) return boolean;
            
            /**
             * @desc    Produce a new public/private key pair based on Elliptic Curve Digital Signature Algorithm (ECDSA) algorithm.
             *          This function should not be used by the ATS
             * @param   p_privateKey    The new private key value
             * @param   p_publicKeyX    The new public key value (x coordinate)
             * @param   p_publicKeyX    The new public key value (y coordinate)
             * @param   p_publicKeyCompressed The compressed public keys
             * @param   p_compressedMode The compressed mode, 0 if the latest bit of Y-coordinate is 0, 1 otherwise
             * @return  true on success, false otherwise
             */
            external function fx_generateKeyPair_brainpoolp256(out Oct32 p_privateKey, out Oct32 p_publicKeyX, out Oct32 p_publicKeyY, out Oct32 p_publicKeyCompressed, out integer p_compressedMode) return boolean;
            
            /**
             * @desc    Produce a new public/private key pair based on Elliptic Curve Digital Signature Algorithm (ECDSA) algorithm.
             *          This function should not be used by the ATS
             * @param   p_privateKey    The new private key value
             * @param   p_publicKeyX    The new public key value (x coordinate)
             * @param   p_publicKeyX    The new public key value (y coordinate)
             * @param   p_publicKeyCompressed The compressed public keys
             * @param   p_compressedMode The compressed mode, 0 if the latest bit of Y-coordinate is 0, 1 otherwise
             * @return  true on success, false otherwise
             */
            external function fx_generateKeyPair_brainpoolp384(out Oct48 p_privateKey, out Oct48 p_publicKeyX, out Oct48 p_publicKeyY, out Oct48 p_publicKeyCompressed, out integer p_compressedMode) return boolean;
            
        } // End of group signing
        
        group encryption {
            
        } // End of group encryption
        
        group certificatesLoader {
            
            /**
            * @desc    Load in memory cache the certificates available in the specified directory
            * @param   p_rootDirectory Root directory to access to the certificates identified by the certificate ID
            * @param   p_configId      A configuration identifier
            * @remark  This method SHALL be call before any usage of certificates
            * @return  true on success, false otherwise
            */
            external function fx_loadCertificates(in charstring p_rootDirectory, in charstring p_configId) return boolean;
            external function fx_store_certificate(in charstring p_cert_id, in octetstring p_cert, in octetstring p_private_key, in octetstring p_public_key_x, in octetstring p_public_key_y, in octetstring p_public_key_compressed, in integer p_public_key_compressed_mode, in octetstring p_hashid8, in octetstring p_issuer, in template (omit) octetstring p_private_enc_key, in template (omit) octetstring p_public_enc_key_x, in template (omit) octetstring p_public_enc_key_y) return boolean;
            
            /**
            * @desc    Unload from memory cache the certificates
            * @return  true on success, false otherwise
            */
            external function fx_unloadCertificates() return boolean;
            
            /**
            * @desc    Read the specified certificate
            * @param   p_certificateId the certificate identifier
            * @param   p_certificate   the expected certificate
            * @return  true on success, false otherwise
            */
            external function fx_readCertificate(in charstring p_certificateId, out octetstring p_certificate) return boolean;

            /**
            * @desc    Read the specified certificate digest
            * @param   p_certificateId the certificate identifier
            * @param   p_digest   the expected certificate
            * @return  true on success, false otherwise
            */
            external function fx_readCertificateDigest(in charstring p_certificateId, out HashedId8 p_digest) return boolean;
            
            external function fx_readCertificateFromDigest(in HashedId8 p_digest, out charstring p_certificateId) return boolean;
            
            /**
            * @desc    Read the private keys for the specified certificate
            * @param   p_keysId            the keys identifier
            * @param   p_signingPrivateKey the signing private key
            * @return  true on success, false otherwise
            */

            external function fx_readSigningKey(in charstring p_keysId, out Oct32 p_signingPrivateKey) return boolean;

            /**
            * @desc    Read the private keys for the specified certificate
            * @param   p_keysId            the keys identifier
            * @param   p_encryptPrivateKey the encrypt private key
            * @return  true on success, false otherwise
            */

            external function fx_readEncryptingKey(in charstring p_keysId, out Oct32 p_encryptingPrivateKey) return boolean;

        } // End of group certificatesLoader
        
        group geodesic {
            
            /**
            * @desc    Check that given polygon doesn't have neither self-intersections nor holes.
            * @param   p_region   Polygonal Region
            * @return  true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isValidPolygonalRegion(in PolygonalRegion p_region) return boolean;
            
            /**
            * @desc Check if a polygonal region is inside another one
            * @param p_parent  The main polygonal region
            * @param p_region  The polygonal region to be included
            * @return true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isPolygonalRegionInside(in PolygonalRegion p_parent, in PolygonalRegion p_region) return boolean;
            
            /**
            * @desc Check that the location is inside a circular region
            * @param p_region      The circular region to consider
            * @param p_location    The device location
            * @return true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isLocationInsideCircularRegion(in CircularRegion p_region, in ThreeDLocation p_location) return boolean;
            
            /**
            * @desc Check that the location is inside a rectangular region
            * @param p_region      The rectangular region to consider
            * @param p_location    The device location
            * @return true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isLocationInsideRectangularRegion(in SequenceOfRectangularRegion p_region, in ThreeDLocation p_location) return boolean;
            
            /**
            * @desc Check that the location is inside a polygonal region
            * @param p_region      The polygonal region to consider
            * @param p_location    The device location
            * @return true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isLocationInsidePolygonalRegion(in PolygonalRegion p_region, in ThreeDLocation p_location) return boolean;
            
            /**
            * @desc Check if the location is inside an identified region
            * @param p_region      The identified region to consider
            * @param p_location    The device location
            * @return true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isLocationInsideIdentifiedRegion(in IdentifiedRegion p_region, in ThreeDLocation p_location) return boolean;
            
            /**
            * @desc Check if the location is inside an undefined region
            * @param p_region      The identified region to consider
            * @param p_location    The device location
            * @return true on success, false otherwise
            * @verdict Unchanged
            */
            external function fx_isLocationInsideOtherRegion(in octetstring p_region, in ThreeDLocation p_location) return boolean; 
            
            /**
             * @desc    Check that p_circular_region_1 circular region is included into p_circular_region_2 circular region
             * @param   p_circular_region_1    Circular region 1
             * @param   p_circular_region_2    Circular region 2
             *
             * @return  true on success, false otherwise
             */
            external function fx_areCirclesInside(in CircularRegion p_circular_region_1, in CircularRegion p_circular_region_2) return boolean;
            
            /**
             * @desc    Check that p_rectanglar_region_1 rectangular region is included into p_rectanglar_region_2 rectangular region
             * @param   p_rectanglar_region_1    Rectangular region 1
             * @param   p_rectanglar_region_2    Rectangular region 2
             *
             * @return  true on success, false otherwise
             */
            external function fx_areRectanglesInside(in SequenceOfRectangularRegion p_rectanglar_region_1, in SequenceOfRectangularRegion p_rectanglar_region_2) return boolean;
            
            /**
             * @desc    Check that p_polygonal_region_1 polygonal region is included into p_polygonal_region_2 polygonal region
             * @param   p_polygonal_region_1    Polygonal region 1
             * @param   p_polygonal_region_2    Polygonal region 2
             *
             * @return  true on success, false otherwise
             */
            external function fx_arePolygonsInside(in PolygonalRegion p_polygonal_region_1, in PolygonalRegion p_polygonal_region_2) return boolean;
            
            /**
            * @desc Convert a spacial coordinate from DMS to Dms
            * @param p_degrees The degrees (D)
            * @param p_minutes The minutes (M)
            * @param p_seconds The seconds (S)
            * @param p_latlon  The latitude/longitude: (N|S|E|W)
            * @return The decimal coordinate on success, 0.0, otherwise
            * @verdict Unchanged
            */
            external function fx_dms2dd(in Int p_degrees, in Int p_minutes, in float p_seconds, in Oct1 p_latlon) return float;
            
        } // End of group geodesic
        
    } // End of group externalFunctions
    
    group geometryFunctions {
        
        function f_checkRegionValidityRestiction(
                                                 in EtsiTs103097Certificate p_cert, 
                                                 in EtsiTs103097Certificate p_cert_issuer
        ) return boolean {
            var ValidityPeriod v_cert_region, v_cert_issuer_region;
            var boolean v_cert_issuer_region_result;
            
            /* FIXME To be reviewed v_cert_issuer_region_result := f_getCertificateValidityRestriction(p_cert_issuer, e_region, v_cert_issuer_region);
            if (f_getCertificateValidityRestriction(p_cert, e_region, v_cert_region) == false) {
                if (v_cert_issuer_region_result == true) {
                    if (v_cert_issuer_region.validity.region.region_type != e_none) {
                        return false;
                    }
                }
            } else if (
                        (v_cert_issuer_region_result == true) and 
                        (v_cert_issuer_region.validity.region.region_type != e_none)
            ) {
                if (v_cert_region.validity.region.region_type == e_circle) {
                    if (v_cert_issuer_region.validity.region.region_type == e_circle) {
                        // Check v_cert_region 'circle' is inside v_cert_issuer_region 'circle'
                        if (f_areCirclesInside(v_cert_region.validity.region.region.circular_region, v_cert_issuer_region.validity.region.region.circular_region) == false) {
                            log("*** " & testcasename() & ": FAIL: Issuer and issuing certificates circle area does not match ***");
                            return false;
                        }
                    }
                } else if (v_cert_region.validity.region.region_type == e_rectangle) {
                    if (v_cert_issuer_region.validity.region.region_type == e_rectangle) {
                        // Check v_cert_region 'rectangle' is inside v_cert_issuer_region 'rectangle'
                        if (f_areRectanglesInside(v_cert_region.validity.region.region.rectangular_region, v_cert_issuer_region.validity.region.region.rectangular_region) == false) {
                            log("*** " & testcasename() & ": FAIL: Issuer and issuing certificates rectangle area does not match ***");
                            return false;
                        }
                    }
                } else if (v_cert_region.validity.region.region_type == e_polygon) {
                    if (v_cert_issuer_region.validity.region.region_type == e_polygon) {
                        // Check v_cert_region 'polygon' is inside v_cert_issuer_region 'polygon'
                        if (f_arePolygonsInside(v_cert_region.validity.region.region.polygonal_region, v_cert_issuer_region.validity.region.region.polygonal_region) == false) {
                            log("*** " & testcasename() & ": FAIL: Issuer and issuing certificates polygon area does not match ***");
                            return false;
                        }
                    }
                } else if (v_cert_region.validity.region.region_type == e_id) {
                    // Check id_region
                    if (not match (v_cert_region.validity.region, mw_geographicRegion_identified(mw_identifiedRegion_iso3166_any))) { 
                        log("*** " & testcasename() & ": FAIL: Identified region is not conformed to ISO 3166-1 ***");
                        return false;
                    }
                    if (not match (v_cert_region.validity.region, mw_geographicRegion_identified(mw_identifiedRegion_un_stats_any))) {
                        log("*** " & testcasename() & ": FAIL: Identified region is not conformed to United Nations Statistics Division ***");
                        return false;
                    }
                    // Check region_dictionary
                    if (not match (v_cert_region.validity.region.region.id_region.region_dictionary, v_cert_issuer_region.validity.region.region.id_region.region_dictionary)) {
                        log("*** " & testcasename() & ": FAIL: Issuer and issuing 'region_dictionary' field does not match ***");
                        return false;
                    }
                    // Check region_identifier
                    if (not match (v_cert_region.validity.region.region.id_region.region_identifier, v_cert_issuer_region.validity.region.region.id_region.region_identifier)) {
                        log("*** " & testcasename() & ": FAIL: Issuer and issuing 'region_identifier' field does not match ***");
                        return false;
                    }
                    // Check local_region
                    if (
                        (not match (v_cert_issuer_region.validity.region.region.id_region.local_region, v_cert_region.validity.region.region.id_region.local_region)) or 
                        (not match (v_cert_issuer_region.validity.region.region.id_region.local_region, 0))
                    ) {
                        log("*** " & testcasename() & ": FAIL: Issuer and issuing 'local_region' field does not match ***");
                        return false;
                    }
                }
            }*/
            
            return true;
        } // End of function f_checkRegionValidityRestiction
        
        /**
         * @desc    Check that p_circular_region_1 circular region is included into p_circular_region_2 circular region
         * @param   p_circular_region_1    Circular region 1
         * @param   p_circular_region_2    Circular region 2
         *
         * @return  true on success, false otherwise
         */
        function f_areCirclesInside(
                                    in CircularRegion p_circular_region_1, 
                                    in CircularRegion p_circular_region_2
        ) return boolean {
            return fx_areCirclesInside(p_circular_region_1, p_circular_region_2);
        }
        
        /**
         * @desc    Check that p_rectanglar_region_1 rectangular region is included into p_rectanglar_region_2 rectangular region
         * @param   p_rectanglar_region_1    Rectangular region 1
         * @param   p_rectanglar_region_2    Rectangular region 2
         *
         * @return  true on success, false otherwise
         */
        function f_areRectanglesInside(
                                       in SequenceOfRectangularRegion p_rectanglar_region_1, 
                                       in SequenceOfRectangularRegion p_rectanglar_region_2
        ) return boolean {
            return fx_areRectanglesInside(p_rectanglar_region_1, p_rectanglar_region_2);
        }
        
        /**
         * @desc    Check that p_polygonal_region_1 polygonal region is included into p_polygonal_region_2 polygonal region
         * @param   p_polygonal_region_1    Polygonal region 1
         * @param   p_polygonal_region_2    Polygonal region 2
         *
         * @return  true on success, false otherwise
         */
        function f_arePolygonsInside(
                                     in PolygonalRegion p_polygonal_region_1, 
                                     in PolygonalRegion p_polygonal_region_2
        ) return boolean {
            return fx_arePolygonsInside(p_polygonal_region_1, p_polygonal_region_2);
        }
        
        /**
         * @desc    Check that given location is valid
         * @param   p_location    location to be checked
         * @return  true on success, false otherwise
         */
        function f_isValidTwoDLocation(
                                       in template (value) TwoDLocation p_location
        ) return boolean {
            return
//FIXME RGY Titan doesn't support dot notation after valueof at the moment
//                (valueof(p_location).longitude != c_maxLongitude + 1) and
//                (valueof(p_location).latitude != c_maxLatitude + 1);
                (valueof(p_location.longitude) != c_maxLongitude + 1) and
                (valueof(p_location.latitude) != c_maxLatitude + 1);
        } // End of function f_isValidTwoDLocation

        /**
         * @desc    Check that two given rectanlular regions are intersected
         *          Note: Regions must be normalized(northWest.latitude >= southEast.latitude)
         * @param   p_r1    Region 1
         * @param   p_r2    Region 2
         *
         * @return  true on success, false otherwise
         */
        function f_isRectangularRegionsIntersected(
                                                   in template (value) RectangularRegion p_r1,
                                                   in template (value) RectangularRegion p_r2
        ) return boolean {
            return not (
//FIXME RGY Titan doesn't support dot notation after valueof at the moment
//                valueof(p_r2).northWest.longitude > valueof(p_r1).southEast.longitude or 
//                valueof(p_r2).southEast.longitude < valueof(p_r1).northWest.longitude or 
//                valueof(p_r2).southEast.latitude  > valueof(p_r1).northWest.latitude or 
//                valueof(p_r2).northWest.latitude  < valueof(p_r1).southEast.latitude
                valueof(p_r2.northWest.longitude) > valueof(p_r1.southEast.longitude) or 
                valueof(p_r2.southEast.longitude) < valueof(p_r1.northWest.longitude) or 
                valueof(p_r2.southEast.latitude)  > valueof(p_r1.northWest.latitude) or 
                valueof(p_r2.northWest.latitude)  < valueof(p_r1.southEast.latitude)
            );
        } // End of function f_isRectangularRegionsIntersected
        
        function f_isContinuousRectangularRegions(
                                                  in template (value) SequenceOfRectangularRegion p_region
        ) return boolean {
            var integer v_i, v_j;
            var boolean v_found;
            
            for (v_i := 0; v_i < lengthof(p_region); v_i := v_i + 1) {
                var PolygonalRegion v_region_base;
                f_convertRectangularRegionIntoPolygonalRegion(valueof(p_region[v_i]), v_region_base);
                v_found := false;
                for (v_j := 0; v_j < lengthof(p_region); v_j := v_j + 1) {
                    if (v_j != v_i) {
                        var PolygonalRegion v_region;
                        f_convertRectangularRegionIntoPolygonalRegion(valueof(p_region[v_j]), v_region);
                        if (f_isPolygonalRegionInside(v_region, v_region_base) == true) {
                            v_found := true;
                        }
                    }
                } // End of 'for' statement
                if (v_found == false) {
                    return false;
                }
            } // End of 'for' statement
            
            return true;
        } // End of function f_isContinuousRectangularRegions
        
        /**
         * @desc Check if a polygonal region is inside another one
         * @param p_parent  The main polygonal region
         * @param p_region  The polygonal region to be included
         * @return true on success, false otherwise
         * @verdict Unchanged
         */
        function f_isRectangularRegionsInside(
                                              in template (value) SequenceOfRectangularRegion p_parent,
                                              in template (value) SequenceOfRectangularRegion p_region
        ) return boolean {
            var integer v_i, v_j;
            
            for (v_i := 0; v_i < lengthof(p_parent); v_i := v_i + 1) {
                var PolygonalRegion v_region_parent, v_region;
                f_convertRectangularRegionIntoPolygonalRegion(valueof(p_parent[v_i]), v_region_parent);
                for (v_j := 0; v_j < lengthof(p_parent); v_j := v_j + 1) {
                    f_convertRectangularRegionIntoPolygonalRegion(valueof(p_region[v_j]), v_region);
                    if (f_isPolygonalRegionInside(v_region, v_region_parent) == true) {
                        return true;
                    }
                } // End of 'for' statement
            } // End of 'for' statement
            
            return false;
        } // End of function f_isRectangularRegionsInside
        
        /**
         * @desc Convert a rectangular region into a polygonal region
         * @param p_region The rectangular regions to convert
         * @return 
         * @verdict 
         */
        function f_convertRectangularRegionIntoPolygonalRegion(
                                                               in template (value) RectangularRegion p_rectangular_region,
                                                               out PolygonalRegion p_region
        ) return boolean {
            
            // Convert rectangular regions to polygons and check polygons
            p_region[0] := valueof(p_rectangular_region.northWest);
            p_region[1] := { 
                valueof(p_rectangular_region.northWest.latitude) + valueof(p_rectangular_region.southEast.latitude),
                valueof(p_rectangular_region.northWest.longitude)
            };
            p_region[2] := valueof(p_rectangular_region.southEast);
            p_region[3] := { 
                valueof(p_rectangular_region.northWest.latitude),
                valueof(p_rectangular_region.northWest.longitude) + valueof(p_rectangular_region.southEast.longitude) 
            };
            log("f_convertRectangularRegionIntoPolygonalRegion: DEBUG: Northwest location is invalid in rect ", p_region);
            
            return true;
        } // End of function 
        
        /**
         * @desc    Check that given polygon doesn't have neither self-intersections nor holes.
         * @param   p_region   Polygonal Region
         * @return  true on success, false otherwise
         * @verdict Unchanged
         */
        function f_isValidPolygonalRegion(
                                          in template (value) PolygonalRegion p_region
        ) return boolean {
            // Sanity check
            if (not isbound(p_region) or (lengthof(p_region) == 0)) {
                return false;
            }
            
            return fx_isValidPolygonalRegion(valueof(p_region));
        } // End of function f_isValidPolygonalRegion
        
        /**
         * @desc Check if a polygonal region is inside another one
         * @param p_parent  The main polygonal region
         * @param p_region  The polygonal region to be included
         * @return true on success, false otherwise
         * @verdict Unchanged
         */
        function f_isPolygonalRegionInside(
                                           in template (value) PolygonalRegion p_parent,
                                           in template (value) PolygonalRegion p_region
        ) return boolean {
            // Sanity check
            if (not isbound(p_parent) or not isbound(p_region) or (lengthof(p_parent) == 0) or (lengthof(p_region) == 0)) {
                return false;
            }
            
            return fx_isPolygonalRegionInside(valueof(p_parent), valueof(p_region));
        } // End of function f_isPolygonalRegionInside
        
        /**
         * @desc
         */
        function f_isIdentifiedRegionInside(
                                            in template (value) UInt16 p_parent,
                                            in template (value) UInt16 p_region
        ) return boolean {
            return valueof(p_parent) == valueof(p_region);
        } // End of function f_isIdentifiedRegionInside
        
        /**
         * @desc Check that the location is inside a region
         * @param p_region      The region to consider
         * @param p_location    The device location
         * @return true on success, false otherwise
         * @verdict Unchanged
         */
        function f_isLocationInsideRegion(
                                          in template (value) GeographicRegion p_region,
                                          in template (value) ThreeDLocation p_location
        ) return boolean {
            var boolean v_ret := false;
            
            if (ischosen(p_region.circularRegion)) {
                v_ret := f_isLocationInsideCircularRegion(valueof(p_region.circularRegion), p_location);
            } else if (ischosen(p_region.rectangularRegion)) {
                v_ret := f_isLocationInsideRectangularRegion(valueof(p_region.rectangularRegion), p_location);
            } else if (ischosen(p_region.polygonalRegion)) {
                v_ret := f_isLocationInsidePolygonalRegion(valueof(p_region.polygonalRegion), p_location);
            } else if (ischosen(p_region.identifiedRegion)) {
                for (var integer v_i := 0; v_i < lengthof(p_region.identifiedRegion); v_i := v_i + 1) {
                    if (f_isLocationInsideIdentifiedRegion(valueof(p_region.identifiedRegion[v_i]), p_location) == true) {
                        v_ret := true;
                        break;
                    }
                } // End of 'for' statement
            }
            
            return v_ret;
        } // End of function f_isLocationInsideRegion
        
        /**
        * @desc Check that the location is inside a circular region
        * @param p_region      The circular region to consider
        * @param p_location    The device location
        * @return true on success, false otherwise
        * @verdict Unchanged
        */
        function f_isLocationInsideCircularRegion(
                                                  in template (value) CircularRegion p_region,
                                                  in template (value) ThreeDLocation p_location
        ) return boolean {
            // Sanity check
            if (not isbound(p_region) or not isbound(p_location)) {
                return false;
            }
            
            return fx_isLocationInsideCircularRegion(valueof(p_region), valueof(p_location));
        } // End of function f_isLocationInsideCircularRegion
        
        /**
        * @desc Check that the location is inside a rectangular region
        * @param p_region      The rectangular region to consider
        * @param p_location    The device location
        * @return true on success, false otherwise
        * @verdict Unchanged
        */
        function f_isLocationInsideRectangularRegion(
                                                     in template (value) SequenceOfRectangularRegion p_region,
                                                     in template (value) ThreeDLocation p_location
        ) return boolean {
            // Sanity check
            if (not isbound(p_region) or not isbound(p_location) or (lengthof(p_region) == 0)) {
                return false;
            }
//            log("f_isLocationInsideRectangularRegion: p_polygonalArea: ", p_region);
//            log("f_isLocationInsideRectangularRegion: p_location: ", p_location);
            
            return fx_isLocationInsideRectangularRegion(valueof(p_region), valueof(p_location));
        } // End of function f_isLocationInsideRectangularRegion
        
        /**
        * @desc Check that the location is inside a polygonal region
        * @param p_region      The polygonal region to consider
        * @param p_location    The device location
        * @return true on success, false otherwise
        * @verdict Unchanged
        */
        function f_isLocationInsidePolygonalRegion(
                                                   in template (value) PolygonalRegion  p_region,
                                                   in template (value) ThreeDLocation p_location
        ) return boolean {
            // Sanity check
            if (not isbound(p_region) or not isbound(p_location) or (lengthof(p_region) == 0)) {
                return false;
            }
//            log("f_isLocationInsidePolygonalRegion: p_polygonalArea: ", p_region, " - ", valueof(p_region));
//            log("f_isLocationInsidePolygonalRegion: p_location: ", p_location, " - ", valueof(p_location));
            
            return fx_isLocationInsidePolygonalRegion(valueof(p_region), valueof(p_location));
        } // End of function f_isLocationInsidePolygonalRegion
        
        /**
        * @desc Check if the location is inside an identified region
        * @param p_region      The identified region to consider
        * @param p_location    The device location
        * @return true on success, false otherwise
        * @verdict Unchanged
        */
        function f_isLocationInsideIdentifiedRegion(
                                                    in template (value) IdentifiedRegion p_region,
                                                    in template (value) ThreeDLocation p_location
        ) return boolean {
            // Sanity check
            if (not isbound(p_region) or not isbound(p_location)) {
                return false;
            }
            
            return fx_isLocationInsideIdentifiedRegion(valueof(p_region), valueof(p_location));
        } // End of function f_isLocationInsideIdentifiedRegion
        
        /**
        * @desc Check if the location is inside an undefined region
        * @param p_region      The identified region to consider
        * @param p_location    The device location
        * @return true on success, false otherwise
        * @verdict Unchanged
        */
        function f_isLocationInsideOtherRegion(
                                               in template (value) octetstring p_region,
                                               in template (value) ThreeDLocation p_location
        ) return boolean {
            // Sanity check
            if (valueof(p_region) == ''O) {
                return false;
            }
            
            return fx_isLocationInsideOtherRegion(valueof(p_region), valueof(p_location)); 
        } // End of function f_isLocationInsideOtherRegion
        
        /**
        * @desc Convert a spacial coordinate from DMS to Dms
        * @param p_degrees The degrees (D)
        * @param p_minutes The minutes (M)
        * @param p_seconds The seconds (S)
        * @param p_latlon  The latitude/longitude: (N|S|E|W)
        * @return The decimal coordinate on success, 0.0, otherwise
        * @verdict Unchanged
        */
        function f_dms2dd(
                          in integer p_degrees,
                          in integer p_minutes,
                          in float p_seconds,
                          in charstring p_latlon
        ) return float {
            var Oct1 v_latlon;
            
            // Sanity checks
            if (lengthof(p_latlon) != 1) {
                return 0.0;
            } else if ((p_latlon != "N") and (p_latlon != "S") and (p_latlon != "E") and (p_latlon != "W")) {
                return 0.0;
            }
            v_latlon := char2oct(p_latlon);
            
            return fx_dms2dd(p_degrees, p_minutes, p_seconds, v_latlon);
        } // End of function f_dms2dd
        
        /**
        * @desc Convert the latitude from float to int
        * @param p_latitude The latitude to be converted. Significand length shall be 7 digits length
        * @return The converted latitude
        * @verdict Unchanged
        */
        function f_ddlat2int(
                             in float p_latitude
        ) return SecLatitude {
            return float2int(p_latitude * 10000000.0); // Significand length shall be 7 digits length
        }
        
        /**
        * @desc Convert the longitude from float to int
        * @param p_longitude The longitude to be converted. Significand length shall be 6 digits length
        * @return The converted longitude
        * @verdict Unchanged
        */
        function f_ddlon2int(
                             in float p_longitude
        ) return SecLongitude {
            return float2int(p_longitude * 1000000.0); // Significand length shall be 6 digits length
        }
        
    } // End of group geometryFunctions
    
} // End of module LibItsSecurity_Functions