Zig Requires Chilkat v11.0.0+

RSA Encrypt Hash using SHA256 hash function and SHA1 mask function

See more RSA Examples

How can this Javascript be duplicated using Chilkat?

function a(e, t) {
                var r = s.pki.publicKeyFromPem(e)
                  , n = r.encrypt(t, "RSA-OAEP", {
                    md: s.md.sha256.create(),
                    mgf1: {
                        md: s.md.sha1.create()
                    }
                });
                return s.util.encode64(n)
            }

Note: The OAEP padding uses random bytes in the padding, and therefore each time encryption happens, even using the same data and key, the result will be different -- but still valid. One should not expect to get the same output.

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.

    const pubkey = try chilkat.PublicKey.init();
    defer pubkey.deinit();

    const sb_pem = try chilkat.StringBuilder.init();
    defer sb_pem.deinit();
    const b_crlf = true;
    sb_pem.appendLine("-----BEGIN PUBLIC KEY-----", b_crlf) catch {};
    sb_pem.appendLine("MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA33TqqLR3eeUmDtHS89qF", b_crlf) catch {};
    sb_pem.appendLine("3p4MP7Wfqt2Zjj3lZjLjjCGDvwr9cJNlNDiuKboODgUiT4ZdPWbOiMAfDcDzlOxA", b_crlf) catch {};
    sb_pem.appendLine("04DDnEFGAf+kDQiNSe2ZtqC7bnIc8+KSG/qOGQIVaay4Ucr6ovDkykO5Hxn7OU7s", b_crlf) catch {};
    sb_pem.appendLine("Jp9TP9H0JH8zMQA6YzijYH9LsupTerrY3U6zyihVEDXXOv08vBHk50BMFJbE9iwF", b_crlf) catch {};
    sb_pem.appendLine("wnxCsU5+UZUZYw87Uu0n4LPFS9BT8tUIvAfnRXIEWCha3KbFWmdZQZlyrFw0buUE", b_crlf) catch {};
    sb_pem.appendLine("f0YN3/Q0auBkdbDR/ES2PbgKTJdkjc/rEeM0TxvOUf7HuUNOhrtAVEN1D5uuxE1W", b_crlf) catch {};
    sb_pem.appendLine("SwIDAQAB", b_crlf) catch {};
    sb_pem.appendLine("-----END PUBLIC KEY-----", b_crlf) catch {};

    // Load the public key object from the PEM.
    pubkey.loadFromString(try sb_pem.getAsString(alloc)) catch {
        std.debug.print("{s}\n", .{try pubkey.getLastErrorText(alloc)});
        return;
    };

    const original_data = "This is the original data to be SHA-256 hashed and RSA encrypted.";

    // First we SHA-256 hash the original data to get the hash in base64 format:
    const crypt = try chilkat.Crypt2.init();
    defer crypt.deinit();
    crypt.setHashAlgorithm("SHA-256");
    crypt.setEncodingMode("base64");
    const hash_base64 = try crypt.hashStringENC(alloc, original_data);

    // Setup RSA to use OAEP padding with SHA-1 for the mask function.
    const rsa = try chilkat.Rsa.init();
    defer rsa.deinit();
    rsa.setPkcsPadding(false);
    rsa.setOaepHash("SHA256");
    rsa.usePublicKey(pubkey) catch {};
    rsa.setEncodingMode("base64");

    // We can provide a binary encoding mode, such as "base64", "hex", "base64url", etc.
    // for the Charset property.   The Charset property was previously limited to character encodings, such as
    // "utf-8", "iso-8859-1", etc.  If a binary encoding is used, then the string passed in is decoded to the binary
    // bytes as indicated.  (If an actual charset, such as "utf-8" is used, then the input string is converted to the
    // byte representation of the charset, and then encrypted.)

    // Given that a hash is composed of non-text binary bytes, we'll set the Charset property equal to "base64"
    // (because we have the base64 hash from above).
    rsa.setCharset("base64");

    // Note: The OAEP padding uses random bytes in the padding, and therefore each time encryption happens,
    // even using the same data and key, the result will be different --  but still valid.  One should not expect
    // to get the same output.
    const b_use_private_key = false;
    const encrypted_str = rsa.encryptStringENC(alloc, hash_base64, b_use_private_key) catch {
        std.debug.print("{s}\n", .{try rsa.getLastErrorText(alloc)});
        return;
    };

    std.debug.print("Base64 RSA encrypted output: {s}\n", .{encrypted_str});
}