Examples

using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.OpenSsl;

// Make sure to include the BEGIN/END headers AND the newlines
var privateKeyText = "-----BEGIN EC PRIVATE KEY-----\nXXXXX-----\nEND EC PRIVATE KEY-----";

// Simple POCO object to represent a transfer
InternalTransfer internalTransfer = new()
{
    FromAccount = "1234",
    ToAccount = "4321",
    Amount = 300,
    Description = "Test transfer"
};
var nonce = Guid.NewGuid().ToString();
var date = DateTime.UtcNow.ToString("R");
var body = JsonConvert.SerializeObject(internalTransfer, new JsonSerializerSettings()
{
    ContractResolver = new DefaultContractResolver()
    {
        NamingStrategy = new SnakeCaseNamingStrategy()
    }
});
var rawSignature= body + date + nonce;

var pemKeyPair = (AsymmetricCipherKeyPair)new PemReader(new StringReader(privateKeyText)).ReadObject();
ISigner? signer = SignerUtilities.GetSigner("SHA256withECDSA");
var ecPrivKey = (ECPrivateKeyParameters)pemKeyPair.Private;
signer.Init(true, ecPrivKey);
signer.BlockUpdate(Encoding.UTF8.GetBytes(rawSignature), 0, rawSignature.Length);
var signature = Convert.ToBase64String(signer.GenerateSignature());

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api-sandbox.utb.com/api/v1/transfer/internal");
request.Headers.Add("Accept", "application/json");
request.Headers.Add("X-UTB-Subscription-Key", "SUBSCRIPTION_KEY");
request.Headers.Add("X-UTB-Signature", signature);
request.Headers.Add("X-UTB-Signature-Nonce", nonce);
request.Headers.Add("Date", date);
request.Headers.Add("X-UTB-Signature-Version", "v1");
request.Content = new StringContent(body, null, "application/json");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

import ecdsa
from ecdsa.util import sigencode_der
from hashlib import sha256
import base64
import uuid
import locale, datetime
import http.client
import hashlib
import json

# Make sure to include the BEGIN/END headers AND the newlines
private_key = "-----BEGIN EC PRIVATE KEY-----\nXXXXX\n-----END EC PRIVATE KEY-----"

internal_transfer = {
  "from_account": "1234",
  "to_account": "4321",
  "amount": 300,
  "description": "Test transfer"
}
body = json.dumps(internal_transfer)
nonce = str(uuid.uuid4())
date = datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
rawsignature = body + date + nonce

sk = ecdsa.SigningKey.from_pem(private_key)
signed_message = sk.sign(rawsignature.encode(encoding='utf-8'), hashfunc = hashlib.sha256, sigencode=sigencode_der)
signature = base64.b64encode(signed_message)

conn = http.client.HTTPSConnection("api-sandbox.utb.com")
headers = {
  'Accept': 'application/json',
  'Content-Type': 'application/json',
  'X-UTB-Subscription-Key': "SUBSCRIPTION_KEY",
  'X-UTB-Signature': signature,
  'X-UTB-Signature-Nonce': nonce,
  'Date': date,
  'X-UTB-Signature-Version': "v1"
}
conn.request("POST", "/api/v1/transfer/internal", body, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.squareup.okhttp.*;
import org.bouncycastle.openssl.PEMKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
import java.io.IOException;
import java.io.StringReader;
import java.math.BigDecimal;
import java.security.*;
import java.security.interfaces.ECPrivateKey;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeyException, SignatureException {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        // Make sure to include the BEGIN/END headers AND the newlines
        String privatekey = "-----BEGIN EC PRIVATE KEY-----\nXXXXX\n-----END EC PRIVATE KEY-----";
        PEMParser parser = new PEMParser(new StringReader(privatekey));
        KeyPair keyPair = new JcaPEMKeyConverter().setProvider("BC").getKeyPair((PEMKeyPair) parser.readObject());
        ECPrivateKey key = (ECPrivateKey) keyPair.getPrivate();
        Signature signer = Signature.getInstance("SHA256withECDSA");
        signer.initSign(key);

        SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));

        // Simple POJO object to represent a transfer
        InternalTransfer internalTransfer = new InternalTransfer();
        internalTransfer.setFromAccount("1234");
        internalTransfer.setToAccount("4321");
        internalTransfer.setAmount(new BigDecimal(300));
        internalTransfer.setDescription("Test transfer");

        Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();
        String body = gson.toJson(internalTransfer);
        String date = dateFormat.format(Calendar.getInstance().getTime());
        String nonce = UUID.randomUUID().toString();
        String rawSignature = body + date + nonce;

        signer.update(rawSignature.getBytes("UTF8"));

        String signature = Base64.getEncoder().encodeToString(signer.sign());

        MediaType mediaType = MediaType.parse("application/json");
        RequestBody requestBody = RequestBody.create(mediaType, body);

        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://api-sandbox.utb.com/api/v1/transfer/internal")
                .method("POST", requestBody)
                .addHeader("Accept", "application/json")
                .addHeader("X-UTB-Subscription-Key", "SUBSCRIPTION_KEY")
                .addHeader("X-UTB-Signature", signature)
                .addHeader("X-UTB-Signature-Nonce", nonce)
                .addHeader("Date", date)
                .addHeader("X-UTB-Signature-Version", "v1")
                .build();
        Response response = client.newCall(request).execute();
        System.out.println(response.body().string());
    }
}

let request = require('request')
let rs = require('jsrsasign')
let uuid = require('uuid');

// Make sure to include the BEGIN/END headers AND the newlines
let privateKey = "-----BEGIN EC PRIVATE KEY-----\nXXXXX\n-----END EC PRIVATE KEY-----"

let body = JSON.stringify({
    "from_account": "1234",
    "to_account": "4321",
    "amount": 300,
    "description": "Test transfer"
})
let date = new Date().toUTCString();
let nonce = uuid.v4();
let rawSignature = body + date + nonce;

let sign = new rs.KJUR.crypto.Signature({"alg": "SHA256withECDSA"})
sign.init(privateKey)
let signature = Buffer.from(sign.signString(rawSignature), 'hex').toString('base64')
console.log(signature)

let options = {
    'method': 'POST',
    'url': 'https://api-sandbox.utb.com/api/v1/transfer/internal',
    'headers': {
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'X-UTB-Subscription-Key': "SUBSCRIPTION_KEY",
        'X-UTB-Signature': signature,
        'X-UTB-Signature-Nonce': nonce,
        'Date': date,
        'X-UTB-Signature-Version': "v1"
    },
    body: body
};
request(options, function (error, response) {
    if (error) throw new Error(error);
    console.log(response.body);
});