Zig Requires Chilkat v11.0.0+

PKCS11 Import a Private Key onto the HSM

See more PKCS11 Examples

Demonstrates how to import an existing RSA private key onto the smartcard/token. The imported key is a token object, meaning it stays on the HSM and exists beyond the end of the PKCS11 session. Zig

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

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

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

    // Note: Chilkat's PKCS11 implementation runs on Windows, Linux, Mac OS X, and other supported operating systems.

    const pkcs11 = try chilkat.Pkcs11.init();
    defer pkcs11.deinit();

    // Use the PKCS11 driver (.dll, .so, .dylib) for your particular HSM.
    // (The format of the path will change with the operating system.  Obviously, "C:/" is not used on non-Windows systems.
    pkcs11.setSharedLibPath("C:/Program Files (x86)/Gemalto/IDGo 800 PKCS#11/IDPrimePKCS1164.dll");

    // Establish a logged-on session.
    const pin = "0000";
    const user_type = 1;
    pkcs11.quickSession(user_type, pin) catch {
        std.debug.print("{s}\n", .{try pkcs11.getLastErrorText(alloc)});
        return;
    };

    // Let's import a certificate's private key onto the HSM.
    // First, we'll load the certificate from a .pfx (also known as .p12), which is a file format
    // that also includes the certificate's private key.
    const cert = try chilkat.Cert.init();
    defer cert.deinit();
    cert.loadPfxFile("qa_data/pfx/ehealth.fgov.be_testing.p12", "p12_password") catch {
        std.debug.print("{s}\n", .{try cert.getLastErrorText(alloc)});
        return;
    };

    // Let's get the certificate's private key.
    const priv_key = try chilkat.PrivateKey.init();
    defer priv_key.deinit();
    cert.getPrivateKey(priv_key) catch {
        std.debug.print("{s}\n", .{try cert.getLastErrorText(alloc)});
        return;
    };

    // Build a PKCS11 template to provide additional information about the key to be imported.
    const json_template = try chilkat.JsonObject.init();
    defer json_template.deinit();

    // Indicate that the key is to be stored on the token.  It is NOT a session object.
    json_template.updateBool("token", true) catch {};

    // Indicate that the key can be used for signing.
    json_template.updateBool("sign", true) catch {};

    // Provide an arbitrary ID and label (anything you want).
    // The information in the ID and/or label provides one means for finding the key in future PKCS11 sessions.
    json_template.updateString("id_hex", "010203040A0B0C0D0E0F") catch {};
    json_template.updateString("label", "ehealth private key") catch {};

    // Import the key.  The private key handle is returned on success.  Otherwise 0 is returned.
    // If our only task for now is to simply import the key, we can ignore the returned handle,
    // other than to check for success/failure.  Otherwise, the handle can be used in other PKCS11 operations.
    // This example just creates the key and does not use the returned handle.
    const key_handle = pkcs11.importPrivateKey(priv_key, json_template);
    if (key_handle == 0) {
        std.debug.print("{s}\n", .{try pkcs11.getLastErrorText(alloc)});
    } else {
        std.debug.print("key handle = {d}\n", .{key_handle});
        std.debug.print("Successfully imported a private key onto the HSM.\n", .{});
    }

    pkcs11.logout() catch {};
    pkcs11.closeSession() catch {};
}