Iniziare con l'API

require 'uri'

require 'net/http'

require 'openssl'

require 'time'




PUBLIC_KEY = 'XXXXXXX'

SECRET_KEY = 'XXXXXXX'

API_URL = 'https://api.regiondo.com/v1/...'




def get_query_string(url)

  uri = URI(url)

  uri.query

end




def get_auth_header(url)

  query_string = get_query_string(url) || ''

  timestamp = (Time.now.to_f * 1000).to_i

  request_data = "#{timestamp}#{PUBLIC_KEY}#{query_string}"

  hmac_digest = OpenSSL::HMAC.hexdigest('sha256', SECRET_KEY, request_data)

  { timestamp: timestamp, hmac: hmac_digest }

end




auth_data = get_auth_header(API_URL)




uri = URI(API_URL)

http = Net::HTTP.new(uri.host, uri.port)

http.use_ssl = true




request = Net::HTTP::Get.new(uri)

request['X-API-HASH'] = auth_data[:hmac]

request['X-API-TIME'] = auth_data[:timestamp].to_s

request['X-API-ID'] = PUBLIC_KEY




response = http.request(request)

puts response.body

using System;

using System.Net.Http;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;




class Program

{

    const string PUBLIC_KEY = "XXXXXXX";

    const string SECRET_KEY = "XXXXXXX";

    const string API_URL = "https://api.regiondo.com/v1/...";




    static string GetQueryString(string url)

    {

        var uri = new Uri(url);

        return uri.Query;

    }




    static (long timestamp, string hmac) GetAuthHeader(string url)

    {

        var queryString = GetQueryString(url);

        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        var requestData = $"{timestamp}{PUBLIC_KEY}{queryString}";

        using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(SECRET_KEY)))

        {

            var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(requestData));

            var hmacDigest = BitConverter.ToString(hash).Replace("-", "").ToLower();

            return (timestamp, hmacDigest);

        }

    }




    static async Task Main(string[] args)

    {

        var (timestamp, hmac) = GetAuthHeader(API_URL);




        using (var client = new HttpClient())

        {

            client.DefaultRequestHeaders.Add("X-API-HASH", hmac);

            client.DefaultRequestHeaders.Add("X-API-TIME", timestamp.ToString());

            client.DefaultRequestHeaders.Add("X-API-ID", PUBLIC_KEY);




            var response = await client.GetAsync(API_URL);

            var responseBody = await response.Content.ReadAsStringAsync();

            Console.WriteLine(responseBody);

        }

    }

}

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import java.net.HttpURLConnection;

import java.net.URL;

import java.nio.charset.StandardCharsets;

import java.security.MessageDigest;




public class Main {

    private static final String PUBLIC_KEY = "XXXXXXX";

    private static final String SECRET_KEY = "XXXXXXX";

    private static final String API_URL = "https://api.regiondo.com/v1/...";




    private static String getQueryString(String url) throws Exception {

        URL uri = new URL(url);

        return uri.getQuery();

    }




    private static String getAuthHeader(String url) throws Exception {

        String queryString = getQueryString(url);

        long timestamp = System.currentTimeMillis();

        String requestData = timestamp + PUBLIC_KEY + (queryString != null ? queryString : "");

        

        Mac sha256Hmac = Mac.getInstance("HmacSHA256");

        SecretKeySpec secretKey = new SecretKeySpec(SECRET_KEY.getBytes(StandardCharsets.UTF_8), "HmacSHA256");

        sha256Hmac.init(secretKey);

        

        byte[] hashBytes = sha256Hmac.doFinal(requestData.getBytes(StandardCharsets.UTF_8));

        StringBuilder hash = new StringBuilder();

        for (byte b : hashBytes) {

            hash.append(String.format("%02x", b));

        }

        

        return String.format("%d|%s", timestamp, hash.toString());

    }




    public static void main(String[] args) throws Exception {

        String[] authData = getAuthHeader(API_URL).split("\\|");

        long timestamp = Long.parseLong(authData[0]);

        String hmac = authData[1];




        URL url = new URL(API_URL);

        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        conn.setRequestMethod("GET");

        conn.setRequestProperty("X-API-HASH", hmac);

        conn.setRequestProperty("X-API-TIME", Long.toString(timestamp));

        conn.setRequestProperty("X-API-ID", PUBLIC_KEY);




        int responseCode = conn.getResponseCode();

        System.out.println("Response Code: " + responseCode);




        BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));

        String inputLine;

        StringBuffer response = new StringBuffer();




        while ((inputLine = in.readLine()) != null) {

            response.append(inputLine);

        }

        in.close();

        System.out.println(response.toString());

    }

}

package main




import (

    "crypto/hmac"

    "crypto/sha256"

    "encoding/hex"

    "fmt"

    "net/http"

    "net/url"

    "time"

)




const (

    PublicKey = "XXXXXXX"

    SecretKey = "XXXXXXX"

    ApiURL    = "https://api.regiondo.com/v1/..."

)




func getQueryString(rawUrl string) string {

    parsedUrl, _ := url.Parse(rawUrl)

    return parsedUrl.RawQuery

}




func getAuthHeader(requestUrl string) (string, string) {

    queryString := getQueryString(requestUrl)

    timestamp := time.Now().UnixNano() / int64(time.Millisecond)

    requestData := fmt.Sprintf("%d%s%s", timestamp, PublicKey, queryString)

    

    h := hmac.New(sha256.New, []byte(SecretKey))

    h.Write([]byte(requestData))

    hmacDigest := hex.EncodeToString(h.Sum(nil))

    

    return fmt.Sprintf("%d", timestamp), hmacDigest

}




func main() {

    timestamp, hmacDigest := getAuthHeader(ApiURL)  

   client := &http.Client{}

    req, _ := http.NewRequest("GET", ApiURL, nil)

    req.Header.Add("X-API-HASH", hmacDigest)

     req.Header.Add("X-API-TIME", timestamp)

    req.Header.Add("X-API-ID", PublicKey)

    

    resp, err := client.Do(req)

    if err != nil {

        fmt.Println("Error:", err)

        return

    }

    defer resp.Body.Close()

    

    fmt.Println("Response Status:", resp.Status)

}