/**
 *  @author   ETSI / STF481
 *  @version  $URL$
 *            $Id$
 *  @desc     Module containing functions for Security Protocol
 *
 */
module LibItsSecurity_Functions {
    
    // Libcommon
    
//    import from LibCommon_BasicTypesAndValues all;
//    import from LibCommon_DataStrings all;
//    import from LibCommon_VerdictControl {type FncRetCode;}
//    import from LibCommon_Sync all;
//    import from LibCommon_Time all;

    // LibIts
//    import from LibItsCommon_Functions all;
//    import from LibItsCommon_TestSystem all;
//    import from LibItsCommon_TypesAndValues all;
    import from LibItsGeoNetworking_TypesAndValues all;
    import from LibItsSecurity_TypesAndValues all;
//    import from LibItsGeoNetworking_TestSystem all;
//    import from LibItsGeoNetworking_Templates all;
//    import from LibItsGeoNetworking_Functions all;
    
    group helpersFunctions {
        
        /**
         * @desc    Produces a 256-bit (32-byte) hash value
         * @param   TODO
         * @return  TODO
         */
        function f_hashWithSha256(in octetstring p_toBeHashedData) {
            
        }
        
        /**
         * @desc    Produces a Elliptic Curve Digital Signature Algorithm (ECDSA) signaturee
         * @param   TODO
         * @return  TODO
         */
        function f_signWithEcdsaNistp256WithSha256() {
            
        }
        
        /**
         * @desc    Verify the signature of the specified data
         * @param   TODO
         * @return  true on success, false otherwise
         */
        function f_verifyWithEcdsaNistp256WithSha256() return boolean {
            return false;
        }
        
        /**
         * @desc    Produce a new public/private key pair based on Elliptic Curve Digital Signature Algorithm (ECDSA) algorithm
         * @param   TODO
         * @return  true on success, false otherwise
         */
        function f_generateKeyPair() return boolean {
            return false;
        }
        
        /**
         * @desc    Calculate digest over the certificate
         * @param   cert The certificate
         * @return  the digest
         */
        function f_calculateDigest(in Certificate cert) return HashedId8 {
            return '0000000000000000'O;
        }
        
        group messageGetters {
    
            /**
             * @desc    return SecuredMessage field of GeoNetworking packet 
             * @param   p_msg GeoNetworking packet
             * @return  the SecuredMessage if any
             */
            function f_getSecuredMessage(in GeoNetworkingPdu p_msg)
            return SecuredMessage {
                return p_msg.gnPacket.securedMsg;
            }
            
            /**
             * @desc    return SecuredMessage header field of given type or null if none 
             * @param   p_msg the SecuredMessage
             * @param   p_type header field type
             * @return  HeaderField of given type if any or null
             */
            function f_getMsgHeaderField(in SecuredMessage p_msg, in HeaderFieldType p_type)
            return HeaderField {
                var HeaderField v_return := null;
                var integer v_length  := lengthof(p_msg.header_fields);
                var integer v_i;
                
                for(v_i := 0; v_i < v_length; v_i := v_i + 1){
                    if(p_msg.header_fields[v_i].type_ == p_type){
                        v_return := p_msg.header_fields[v_i]; 
                        break;
                    }
                }
                
                return v_return;
            }
            
            /**
             * @desc    return SignerInfo SecuredMessage field
             */
            function f_getMsgSignerInfo(in SecuredMessage p_msg) return SignerInfo {
                var HeaderField v_hf := f_getMsgHeaderField(p_msg, e_signer_info);
                
                if(isbound(v_hf)){
                    return v_hf.headerField.signer;
                }
                
                return null;
            }
            
        }// End of group messageGetters
        
        group certificateGetters {
            function f_getCertificateValidityRestriction(in Certificate p_cert, in ValidityRestrictionType p_type)
            return ValidityRestriction {
                var ValidityRestriction v_return := null;
                var integer v_length  := lengthof(p_cert.validity_restrictions);
                var integer v_index;
                for( v_index := 0; v_index < v_length; v_index := v_index + 1 ) {
                    if( p_cert.validity_restrictions[v_index].type_ == p_type ) {
                        v_return := p_cert.validity_restrictions[v_index];
                        break;
                    }
                }
                return v_return;
            }
            
        }// End of group certificateGetters
    
    } // End of group helpersFunctions

    group externalFunctions {
        
        /**
         * @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 octetstring;
        
        /**
         * @desc    Produces a Elliptic Curve Digital Signature Algorithm (ECDSA) signaturee
         * @param   p_toBeSignedData    The data to be signed
         * @param   p_privateKey        The private key
         * @return  The signature value
         */
        external function fx_signWithEcdsaNistp256WithSha256(in octetstring p_toBeSignedData, in octetstring/*UInt64*/ p_privateKey) return octetstring;
        
        /**
         * @desc    Verify the signature of the specified data
         * @param   p_toBeVerifiedData          The data to be verified
         * @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(in octetstring p_toBeVerifiedData, in octetstring p_signature, in octetstring p_ecdsaNistp256PublicKeyX, in octetstring p_ecdsaNistp256PublicKeyY) return boolean;
        
        /**
         * @desc    Produce a new public/private key pair based on Elliptic Curve Digital Signature Algorithm (ECDSA) algorithm
         * @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)
         * @return  true on success, false otherwise
         */
        external function fx_generateKeyPair(out octetstring/*UInt64*/ p_privateKey, out octetstring p_publicKeyX, out octetstring p_publicKeyY) return boolean;
        
    } // End of group externalFunctions
    
} // End of module LibItsSecurity_Functions