Zig 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. Zig

const std = @import("std");
const chilkat = @import("chilkat");

pub fn main(init: std.process.Init) !void {
    const alloc = init.arena.allocator();

    // 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"

    const crypt = try chilkat.Crypt2.init();
    defer crypt.deinit();
    crypt.setHashAlgorithm("sha256");
    crypt.setEncodingMode("base64");
    const base64_hash = try crypt.hashFileENC(alloc, "qa_data/hamlet.xml");

    const http = try chilkat.Http.init();
    defer http.deinit();

    const request_token = try chilkat.BinData.init();
    defer request_token.deinit();
    const optional_policy_oid = "";
    const add_nonce = false;
    const request_tsa_cert = true;

    // Create a time-stamp request token
    http.createTimestampRequest("sha256", base64_hash, optional_policy_oid, add_nonce, request_tsa_cert, request_token) catch {
        std.debug.print("{s}\n", .{try http.getLastErrorText(alloc)});
        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
    const tsa_url = "http://timestamp.digicert.com";
    const resp = try chilkat.HttpResponse.init();
    defer resp.deinit();
    http.httpBd("POST", tsa_url, request_token, "application/timestamp-query", resp) catch {
        std.debug.print("{s}\n", .{try http.getLastErrorText(alloc)});
        return;
    };

    // Get the timestamp reply from the HTTP response object.
    const timestamp_reply = try chilkat.BinData.init();
    defer timestamp_reply.deinit();
    resp.getBodyBd(timestamp_reply) catch {};

    // Convert the binary timestamp reply to XML
    const asn = try chilkat.Asn.init();
    defer asn.deinit();
    asn.loadBd(timestamp_reply) catch {
        std.debug.print("{s}\n", .{try asn.getLastErrorText(alloc)});
        return;
    };

    const xml = try chilkat.Xml.init();
    defer xml.deinit();
    try xml.loadXml(try asn.asnToXml(alloc));

    // 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  }

    const tst_info_base64 = try xml.getChildContent(alloc, "sequence[1]|contextSpecific|sequence|sequence|contextSpecific|octets");

    const bd_tst_info = try chilkat.BinData.init();
    defer bd_tst_info.deinit();
    bd_tst_info.appendEncoded(tst_info_base64, "base64") catch {};

    const asn_tst_info = try chilkat.Asn.init();
    defer asn_tst_info.deinit();
    asn_tst_info.loadBd(bd_tst_info) catch {
        std.debug.print("{s}\n", .{try asn_tst_info.getLastErrorText(alloc)});
        return;
    };

    const xml_tst_info = try chilkat.Xml.init();
    defer xml_tst_info.deinit();
    try xml_tst_info.loadXml(try asn_tst_info.asnToXml(alloc));
    std.debug.print("{s}\n", .{try xml_tst_info.getXml(alloc)});

    // 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

    const sb_gen_time = try chilkat.StringBuilder.init();
    defer sb_gen_time.deinit();
    sb_gen_time.decodeAndAppend(try xml_tst_info.getChildContent(alloc, "universal"), "base64", "utf-8") catch {};
    std.debug.print("{s}\n", .{try sb_gen_time.getAsString(alloc)});

    // Result:
    // 20230316115718Z
}