Rust

ECDSA Sign Data and Get Raw R and S Values

See more ECC Examples

Demonstrates getting the raw R and S value of an ECDSA signature. Rust

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

// To create an ECDSA signature, the data first needs to be hashed.  Then the hash
// is signed.

let crypt = chilkat::Crypt2::new();
crypt.set_hash_algorithm("SHA256");
crypt.set_charset("utf-8");
crypt.set_encoding_mode("base64");

// Hash a string.
let hash1 = crypt.hash_string_enc("The quick brown fox jumps over the lazy dog").unwrap_or_default();
println!("hash1 = {}", hash1);

// -----------------------------------------------------------
// An ECDSA private key is used for signing.  The public key is for signature verification.
// Load our ECC private key.
// Our private key file contains this:

// 	// -----BEGIN PRIVATE KEY-----
// 	MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg3J8q/24D1sEKGdP9
// 	72MGYElLGpw/a56Y3t6pfON3uhShRANCAATlSmoizyhAwoYZAOuFBATl07/1RR54
// 	a1Dzfm16grxJe666AGKR+bSs24hk7TEpaeCTvT8YOOM3l+xKFg7zq6Q9
// 	-----END PRIVATE KEY-----

let priv_key = chilkat::PrivateKey::new();
if priv_key.load_pem_file("qa_data/ecc/secp256r1-key-pkcs8.pem").is_err() {
    println!("{}", priv_key.last_error_text());
    return;
}

// Sign the hash..
let prng = chilkat::Prng::new();
let ecdsa = chilkat::Ecc::new();
let Ok(ecdsa_sig_base64) = ecdsa.sign_hash_enc(&hash1, "base64", &priv_key, &prng) else {
    println!("{}", ecdsa.last_error_text());
    return;
};

// The ECDSA signature is ASN.1 that contains a sequence of 2 large integers (r and s)
// For example:
// SEQUENCE (2 elem)
//   INTEGER (255 bit) 792134D9B4AD82D5431ED03835A88E2596EB35E5B13054BD9B05A0069281ACC9
//   INTEGER (255 bit) 481E758CC1E3CBF825537EC3D9A2CA627E5FAD1137BBEA65DF38658DCB0A9ED5

println!("Base64 ECDSA signature = {}", ecdsa_sig_base64);

// If the raw R and S values are needed, here's how to get them:
let asn = chilkat::Asn::new();
if asn.load_encoded(&ecdsa_sig_base64, "base64").is_err() {
    println!("{}", asn.last_error_text());
    return;
}

// The R and X will be in hexidecimal in the XML.
let xml = chilkat::Xml::new();
let _ = xml.load_xml(&asn.asn_to_xml().unwrap_or_default());
println!("{}", xml.get_xml().unwrap_or_default());

// The XML looks like this:
// <sequence>
// <int>792134D9B4AD82D5431ED03835A88E2596EB35E5B13054BD9B05A0069281ACC9</int>
// <int>481E758CC1E3CBF825537EC3D9A2CA627E5FAD1137BBEA65DF38658DCB0A9ED5</int>
// </sequence>

// Copy raw R and S hex values into a Chilkat BinData object.
let bd = chilkat::BinData::new();
let r = xml.get_child_content("int[0]").unwrap_or_default();
let s = xml.get_child_content("int[1]").unwrap_or_default();
let _ = bd.append_encoded(&r, "hex");
let _ = bd.append_encoded(&s, "hex");

println!("Number of bytes in bd: {}", bd.num_bytes());