Authentication

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
import os

def generate_rsa_keypair(company):
    rsa_private_key = rsa.generate_private_key(
        public_exponent=65537, key_size=2048, backend=default_backend()
    )
    private_key_pem = rsa_private_key.private_bytes(
        serialization.Encoding.PEM,
        serialization.PrivateFormat.PKCS8,
        serialization.NoEncryption()
    )
    with open(os.path.join("keys", company + ".private.pem"), "wb") as f:
        f.write(private_key_pem)

    public_key_pem = rsa_private_key.public_key().public_bytes(
        serialization.Encoding.PEM,
        serialization.PublicFormat.SubjectPublicKeyInfo
    )
    with open(os.path.join("keys", company + ".public.pem"), "wb") as f:
        f.write(public_key_pem)

generate_rsa_keypair("ZTEST")

const { generateKeyPairSync } = require('crypto');
const fs = require('fs');
const path = require('path');

function generateRsaKeypair(company) {
    const { privateKey, publicKey } = generateKeyPairSync('rsa', {
        modulusLength: 2048,
        publicKeyEncoding: { type: 'spki', format: 'pem' },
        privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
    });

    fs.writeFileSync(path.join('keys', `${company}.private.pem`), privateKey);
    fs.writeFileSync(path.join('keys', `${company}.public.pem`), publicKey);
}

generateRsaKeypair('ZTEST');

import java.security.*;
import java.io.*;
import java.util.Base64;

public class GenerateRsaKeypair {
    public static void generateRsaKeypair(String company) throws Exception {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();

        byte[] privateBytes = keyPair.getPrivate().getEncoded();
        String privateKey = "-----BEGIN PRIVATE KEY-----\n"
            + Base64.getMimeEncoder(64, new byte[]{'\n'}).encodeToString(privateBytes)
            + "\n-----END PRIVATE KEY-----\n";
        try (FileWriter fw = new FileWriter("keys/" + company + ".private.pem")) {
            fw.write(privateKey);
        }

        byte[] publicBytes = keyPair.getPublic().getEncoded();
        String publicKey = "-----BEGIN PUBLIC KEY-----\n"
            + Base64.getMimeEncoder(64, new byte[]{'\n'}).encodeToString(publicBytes)
            + "\n-----END PUBLIC KEY-----\n";
        try (FileWriter fw = new FileWriter("keys/" + company + ".public.pem")) {
            fw.write(publicKey);
        }
    }

    public static void main(String[] args) throws Exception {
        generateRsaKeypair("ZTEST");
    }
}

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/pem"
    "os"
    "path/filepath"
)

func generateRsaKeypair(company string) error {
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        return err
    }

    privateFile, err := os.Create(filepath.Join("keys", company+".private.pem"))
    if err != nil {
        return err
    }
    defer privateFile.Close()
    pem.Encode(privateFile, &pem.Block{
        Type:  "PRIVATE KEY",
        Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
    })

    publicFile, err := os.Create(filepath.Join("keys", company+".public.pem"))
    if err != nil {
        return err
    }
    defer publicFile.Close()
    pubBytes, _ := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
    pem.Encode(publicFile, &pem.Block{
        Type:  "PUBLIC KEY",
        Bytes: pubBytes,
    })

    return nil
}

func main() {
    generateRsaKeypair("ZTEST")
}

mkdir -p keys
openssl genrsa -out keys/ZTEST.private.pem 2048
openssl rsa -in keys/ZTEST.private.pem -pubout -out keys/ZTEST.public.pem