Authentication

<?php

// Initializing key in some variable. You will receive this key from Eko via email
$key = "d2fe1d99-6298-4af2-8cc5-d97dcf46df30";

// Encode it using base64
$encodedKey = base64_encode($key);

// Get current timestamp in milliseconds since UNIX epoch as STRING
// Check out https://currentmillis.com to understand the timestamp format
$secret_key_timestamp = (int)(round(microtime(true) * 1000));

// Computes the signature by hashing the salt with the encoded key 
$signature = hash_hmac('SHA256', $secret_key_timestamp, $encodedKey, true);

// Encode it using base64
$secret_key = base64_encode($signature);

//Display
echo "secret-key: " . $secret_key. "\n";
echo "secret-key-timestamp: " . $secret_key_timestamp . "\n";

?>

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Date;

public class Main {
    public static final String HMAC_SHA256 = "HmacSHA256";

    public static void activateEKyc() {
        try {
            String secret_key = "";
            String secret_key_timestamp = "";
            String request_hash = "";

            // Initializing key

            
            String key = "d2fe1d99-6298-4af2-8cc5-d97dcf46df30";//uat auth key
            
            String encodedKey = Base64.getEncoder().encodeToString(key.getBytes(StandardCharsets.UTF_8));

            // Get secret_key_timestamp: current timestamp in milliseconds since UNIX epoch as STRING
            // Check out https://currentmillis.com to understand the timestamp format
            Date date = new Date();
            secret_key_timestamp = String.valueOf(date.getTime());

            // Computes the signature by hashing the salt with the encoded key
            Mac sha256_HMAC = Mac.getInstance(HMAC_SHA256);
            SecretKeySpec signature = new SecretKeySpec(encodedKey.getBytes(StandardCharsets.UTF_8), HMAC_SHA256);

            sha256_HMAC.init(signature);

            // Encode it using base64 to get secret-key
            secret_key = Base64.getEncoder().encodeToString(sha256_HMAC.doFinal(secret_key_timestamp.getBytes(StandardCharsets.UTF_8)));

            
            String utility_acc_no = "766851234";
            String amount = "100";
            String user_code = "32221002";
            String concatenatedString = secret_key_timestamp + utility_acc_no + amount+ user_code;
            byte[] hash = sha256_HMAC.doFinal(concatenatedString.getBytes(StandardCharsets.UTF_8));
            request_hash = Base64.getEncoder().encodeToString(hash);

            System.out.println("secret-key: " + secret_key);
            System.out.println("secret-key-timestamp: " + secret_key_timestamp);
            System.out.println("request_hash: " + request_hash);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        activateEKyc();
    }
}

using System;
using System.Security.Cryptography;
using System.Text;

namespace SignatureGeneration
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initializing key in some variable. You will receive this key from Eko via email
            string key = "d2fe1d99-6298-4af2-8cc5-d97dcf46df30";

            // Encode it using base64
            string encodedKey = Convert.ToBase64String(Encoding.UTF8.GetBytes(key));

            // Get current timestamp in milliseconds since UNIX epoch as STRING
            // Check out https://currentmillis.com to understand the timestamp format
            long secretKeyTimestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds();

            // Computes the signature by hashing the salt with the encoded key 
            byte[] encodedKeyBytes = Encoding.UTF8.GetBytes(encodedKey);
            byte[] timestampBytes = Encoding.UTF8.GetBytes(secretKeyTimestamp.ToString());
            byte[] signatureBytes;
            
            using (var hmac = new HMACSHA256(encodedKeyBytes))
            {
                signatureBytes = hmac.ComputeHash(timestampBytes);
            }

            // Encode it using base64
            string secretKey = Convert.ToBase64String(signatureBytes);

            // Display
            Console.WriteLine("secret-key: " + secretKey);
            Console.WriteLine("secret-key-timestamp: " + secretKeyTimestamp);
        }
    }
}

import hmac
import base64
import hashlib
import time
 
secret_key_timestamp = str(int(round(time.time() * 1000)))
key = 'd2fe1d99-6298-4af2-8cc5-d97dcf46df30'
key_bytes = key.encode('utf-8')  # Convert the key to bytes
 
message = secret_key_timestamp.encode('utf-8')
dig = hmac.new(key_bytes, message, hashlib.sha256).digest()
 
secret_key = base64.b64encode(dig).decode()
 
# Print the secret key and secret timestamp
print("Secret Key:", secret_key)
print("Secret Timestamp:", secret_key_timestamp)