Rust Requires Chilkat v11.0.0+

Extract TSTInfo from RFC3161 Timestamp Reply

See more HTTP Examples

Sends an RFC 3161 timestamp request to a TSA (Timestamp Authority) server and converts the timestamp reply to XML, and then extracts the TSTInfo from the XML and converts it to XML. Rust

// Note: Requires Chilkat v9.5.0.75 or greater.

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

// First sha-256 hash the data that is to be timestamped.
// In this example, the data is the string "Hello World"

let crypt = chilkat::Crypt2::new();
crypt.set_hash_algorithm("sha256");
crypt.set_encoding_mode("base64");
let base64_hash = crypt.hash_file_enc("qa_data/hamlet.xml").unwrap_or_default();

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

let request_token = chilkat::BinData::new();
let optional_policy_oid = String::new();
let add_nonce = false;
let request_tsa_cert = true;

// Create a time-stamp request token
if http.create_timestamp_request("sha256", &base64_hash, &optional_policy_oid, add_nonce, request_tsa_cert, &request_token).is_err() {
    println!("{}", http.last_error_text());
    return;
}

// Send the time-stamp request token to the TSA.
// This is the equivalent of the following CURL command:
// curl -H "Content-Type: application/timestamp-query" --data-binary '@file.tsq' http://timestamp.digicert.com > file.tsr
let tsa_url = "http://timestamp.digicert.com".to_string();
let resp = chilkat::HttpResponse::new();
if http.http_bd("POST", &tsa_url, &request_token, "application/timestamp-query", &resp).is_err() {
    println!("{}", http.last_error_text());
    return;
}

// Get the timestamp reply from the HTTP response object.
let timestamp_reply = chilkat::BinData::new();
let _ = resp.get_body_bd(&timestamp_reply);

// Convert the binary timestamp reply to XML
let asn = chilkat::Asn::new();
if asn.load_bd(&timestamp_reply).is_err() {
    println!("{}", asn.last_error_text());
    return;
}

let xml = chilkat::Xml::new();
let _ = xml.load_xml(&asn.asn_to_xml().unwrap_or_default()).is_ok();

// Extract the TSTInfo from the XML.
// The TSTInfo is this base64 encoded ASN.1 

// TSTInfo ::= SEQUENCE  {
//    version                      INTEGER  { v1(1) },
//    policy                       TSAPolicyId,
//    messageImprint               MessageImprint,
//      -- MUST have the same value as the similar field in
//      -- TimeStampReq
//    serialNumber                 INTEGER,
//     -- Time-Stamping users MUST be ready to accommodate integers
//     -- up to 160 bits.
//    genTime                      GeneralizedTime,
//    accuracy                     Accuracy                 OPTIONAL,
//    ordering                     BOOLEAN             DEFAULT FALSE,
//    nonce                        INTEGER                  OPTIONAL,
//      -- MUST be present if the similar field was present
//      -- in TimeStampReq.  In that case it MUST have the same value.
//    tsa                          [0] GeneralName          OPTIONAL,
//    extensions                   [1] IMPLICIT Extensions   OPTIONAL  }

let tst_info_base64 = xml.get_child_content("sequence[1]|contextSpecific|sequence|sequence|contextSpecific|octets").unwrap_or_default();

let bd_tst_info = chilkat::BinData::new();
let _ = bd_tst_info.append_encoded(&tst_info_base64, "base64");

let asn_tst_info = chilkat::Asn::new();
if asn_tst_info.load_bd(&bd_tst_info).is_err() {
    println!("{}", asn_tst_info.last_error_text());
    return;
}

let xml_tst_info = chilkat::Xml::new();
let _ = xml_tst_info.load_xml(&asn_tst_info.asn_to_xml().unwrap_or_default()).is_ok();
println!("{}", xml_tst_info.get_xml().unwrap_or_default());

// Here's the TSTInfo XML:

// <?xml version="1.0" encoding="utf-8"?>
// <sequence>
//     <int>01</int>
//     <oid>2.16.840.1.114412.7.1</oid>
//     <sequence>
//         <sequence>
//             <oid>2.16.840.1.101.3.4.2.1</oid>
//             <null/>
//         </sequence>
//         <octets>4sRRyWOzC7EOic4fQ9+Op1pa10DbgoBGjBvkq09LZmE=</octets>
//     </sequence>
//     <int>00AD2C86E49872597B60F87D5C54BCFFAE</int>
//     <universal tag="24" constructed="0">MjAyMzAzMTYxMTQ5NTJa</universal>
// </sequence>

//    The genTime (GeneralizedTime) is contained in the final "universal" XML element and is 
//    in base64. It is the time at which the time-stamp token has been created by
//    the TSA. After decoding from base64, it is:
// 
//    The syntax is: YYYYMMDDhhmmss[.s...]Z
//    Example: 19990609001326.34352Z

let sb_gen_time = chilkat::StringBuilder::new();
let _ = sb_gen_time.decode_and_append(&xml_tst_info.get_child_content("universal").unwrap_or_default(), "base64", "utf-8");
println!("{}", sb_gen_time.get_as_string().unwrap_or_default());

// Result:
// 20230316115718Z