Rust Requires Chilkat v11.0.0+

ING Open Banking OAuth2 Client Credentials

See more OAuth2 Examples

Demonstrates how to get an access token for the ING Open Banking APIs using client credentials. Rust

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

let cert = chilkat::Cert::new();
if cert.load_from_file("qa_data/certs_and_keys/ING/example_client_tls.cer").is_err() {
    println!("{}", cert.last_error_text());
    return;
}

let bd_priv_key = chilkat::BinData::new();
if bd_priv_key.load_file("qa_data/certs_and_keys/ING/example_client_tls.key").is_err() {
    println!("Failed to load example_client_tls.key");
    return;
}

// The OAuth 2.0 client_id for these certificates is e77d776b-90af-4684-bebc-521e5b2614dd. 
// Please note down this client_id since you will need it in the next steps to call the API.

let priv_key = chilkat::PrivateKey::new();
if priv_key.load_any_format(&bd_priv_key, "").is_err() {
    println!("{}", priv_key.last_error_text());
    return;
}

// Associate the private key with the certificate.
if cert.set_private_key(&priv_key).is_err() {
    println!("{}", cert.last_error_text());
    return;
}

let http = chilkat::Http::new();

if http.set_ssl_client_cert(&cert).is_err() {
    println!("{}", http.last_error_text());
    return;
}

// Calculate the Digest and add the "Digest" header.  Do the equivalent of this:
// payload="grant_type=client_credentials"
// payloadDigest=`echo -n "$payload" | openssl dgst -binary -sha256 | openssl base64`
// digest=SHA-256=$payloadDigest
let crypt = chilkat::Crypt2::new();
crypt.set_hash_algorithm("SHA256");
crypt.set_encoding_mode("base64");
let payload = "grant_type=client_credentials".to_string();
let payload_digest = crypt.hash_string_enc(&payload).unwrap_or_default();

// Calculate the current date/time and add the Date header.  
// reqDate=$(LC_TIME=en_US.UTF-8 date -u "+%a, %d %b %Y %H:%M:%S GMT")  
let dt = chilkat::DateTime::new();
let _ = dt.set_from_current_system_time();
// The desire date/time format is the "RFC822" format.
http.set_request_header("Date", &dt.get_as_rfc822(false).unwrap_or_default());

// Calculate signature for signing your request
// Duplicate the following code:

// 	httpMethod="post"
// 	reqPath="/oauth2/token"
// 	signingString="(request-target): $httpMethod $reqPath
// 	date: $reqDate
// 	digest: $digest"
// 	signature=`printf "$signingString" | openssl dgst -sha256 -sign "${certPath}example_client_signing.key" -passin "pass:changeit" | openssl base64 -A`

let http_method = "POST".to_string();
let req_path = "/oauth2/token".to_string();

let sb_string_to_sign = chilkat::StringBuilder::new();
let _ = sb_string_to_sign.append("(request-target): ");
let _ = sb_string_to_sign.append(&http_method);
let _ = sb_string_to_sign.to_lowercase();
let _ = sb_string_to_sign.append(" ");
let _ = sb_string_to_sign.append_line(&req_path, false);

let _ = sb_string_to_sign.append("date: ");
let _ = sb_string_to_sign.append_line(&dt.get_as_rfc822(false).unwrap_or_default(), false);

let _ = sb_string_to_sign.append("digest: SHA-256=");
let _ = sb_string_to_sign.append(&payload_digest);

let signing_priv_key = chilkat::PrivateKey::new();
if signing_priv_key.load_pem_file("qa_data/certs_and_keys/ING/example_client_signing.key").is_err() {
    println!("{}", signing_priv_key.last_error_text());
    return;
}

let rsa = chilkat::Rsa::new();
if rsa.use_private_key(&signing_priv_key).is_err() {
    println!("{}", rsa.last_error_text());
    return;
}

rsa.set_encoding_mode("base64");
let b64_signature = rsa.sign_string_enc(&sb_string_to_sign.get_as_string().unwrap_or_default(), "SHA256").unwrap_or_default();

let sb_auth_hdr_val = chilkat::StringBuilder::new();
let _ = sb_auth_hdr_val.append("Signature keyId=\"e77d776b-90af-4684-bebc-521e5b2614dd\",");
let _ = sb_auth_hdr_val.append("algorithm=\"rsa-sha256\",");
let _ = sb_auth_hdr_val.append("headers=\"(request-target) date digest\",");
let _ = sb_auth_hdr_val.append("signature=\"");
let _ = sb_auth_hdr_val.append(&b64_signature);
let _ = sb_auth_hdr_val.append("\"");

let sb_digest_hdr_val = chilkat::StringBuilder::new();
let _ = sb_digest_hdr_val.append("SHA-256=");
let _ = sb_digest_hdr_val.append(&payload_digest);

// Do the following CURL statement:

// 	curl -i -X POST "${httpHost}${reqPath}" \
// 	-H 'Accept: application/json' \
// 	-H 'Content-Type: application/x-www-form-urlencoded' \
// 	-H "Digest: ${digest}" \
// 	-H "Date: ${reqDate}" \
// 	-H "authorization: Signature keyId=\"$keyId\",algorithm=\"rsa-sha256\",headers=\"(request-target) date digest\",signature=\"$signature\"" \
// 	-d "${payload}" \
// 	--cert "${certPath}tlsCert.crt" \
// 	--key "${certPath}tlsCert.key"

let req = chilkat::HttpRequest::new();
req.add_param("grant_type", "client_credentials");
req.add_header("Accept", "application/json");
req.add_header("Date", &dt.get_as_rfc822(false).unwrap_or_default());
req.add_header("Digest", &sb_digest_hdr_val.get_as_string().unwrap_or_default());
req.add_header("Authorization", &sb_auth_hdr_val.get_as_string().unwrap_or_default());

req.set_http_verb("POST");
req.set_content_type("application/x-www-form-urlencoded");

let resp = chilkat::HttpResponse::new();
if http.http_req("https://api.sandbox.ing.com/oauth2/token", &req, &resp).is_err() {
    println!("{}", http.last_error_text());
    return;
}

// If successful, the status code = 200
println!("Response Status Code: {}", resp.status_code());
println!("{}", resp.body_str());

let json = chilkat::JsonObject::new();
let _ = json.load(&resp.body_str());

json.set_emit_compact(false);
println!("{}", json.emit().unwrap_or_default());

// A successful response contains an access token such as:
// {
//   "access_token": "eyJhbGc ... bxI_SoPOBH9xmoM",
//   "expires_in": 905,
//   "scope": "payment-requests:view payment-requests:create payment-requests:close greetings:view virtual-ledger-accounts:fund-reservation:create virtual-ledger-accounts:fund-reservation:delete virtual-ledger-accounts:balance:view",
//   "token_type": "Bearer",
//   "keys": [
//     {
//       "kty": "RSA",
//       "n": "3l3rdz4...04VPkdV",
//       "e": "AQAB",
//       "use": "sig",
//       "alg": "RS256",
//       "x5t": "3c396700fc8cd709cf9cb5452a22bcde76985851"
//     }
//   ],
//   "client_id": "e77d776b-90af-4684-bebc-521e5b2614dd"
// }

// Use this online tool to generate parsing code from sample JSON: 
// Generate Parsing Code from JSON

let access_token = json.string_of("access_token").unwrap_or_default();
let expires_in = json.int_of("expires_in");
let scope = json.string_of("scope").unwrap_or_default();
let token_type = json.string_of("token_type").unwrap_or_default();
let client_id = json.string_of("client_id").unwrap_or_default();
let mut i = 0;
let count_i = json.size_of_array("keys");
while i < count_i {
    json.set_i(i);
    let _ = json.string_of("keys[i].kty").unwrap_or_default();
    let _ = json.string_of("keys[i].n").unwrap_or_default();
    let _ = json.string_of("keys[i].e").unwrap_or_default();
    let _ = json.string_of("keys[i].use").unwrap_or_default();
    let _ = json.string_of("keys[i].alg").unwrap_or_default();
    let _ = json.string_of("keys[i].x5t").unwrap_or_default();
    i = i + 1;
}

// This example will save the JSON containing the access key to a file so that
// a subsequent example can load it and then use the access key for a request, such as to create a payment request.
let _ = json.write_file("qa_data/tokens/ing_access_token.json");