Encryption Key Generation Code Examples

<?php
// AES-256 Encryption Key Generation
$aes_key = random_bytes(32); // 256 bits
$aes_key_hex = bin2hex($aes_key);
echo "AES-256 Key (Hex): " . $aes_key_hex . "\n";

// AES-128 Encryption Key
$aes_128_key = bin2hex(random_bytes(16)); // 128 bits
echo "AES-128 Key (Hex): " . $aes_128_key . "\n";

// RSA Key Pair Generation (2048-bit)
$config = [
    "private_key_bits" => 2048,
    "private_key_type" => OPENSSL_KEYTYPE_RSA,
];

$res = openssl_pkey_new($config);
openssl_pkey_export($res, $private_key);
$public_key = openssl_pkey_get_details($res)["key"];

echo "Private Key:\n" . $private_key . "\n";
echo "Public Key:\n" . $public_key . "\n";

// Base64 encode for storage
$encoded_key = base64_encode($aes_key);
echo "AES Key (Base64): " . $encoded_key;

// Node.js - AES & RSA Key Generation
const crypto = require('crypto');

// AES-256 Key Generation
const aesKey = crypto.randomBytes(32); // 256 bits
const aesKeyHex = aesKey.toString('hex');
console.log('AES-256 Key (Hex):', aesKeyHex);

// AES-128 Key
const aes128Key = crypto.randomBytes(16).toString('hex');
console.log('AES-128 Key (Hex):', aes128Key);

// RSA Key Pair Generation (2048-bit)
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem'
  }
});

console.log('Private Key:\n', privateKey);
console.log('Public Key:\n', publicKey);

// Base64 encoding for storage
const aesKeyBase64 = aesKey.toString('base64');
console.log('AES Key (Base64):', aesKeyBase64);

// Web Crypto API (Browser)
// async function generateWebCryptoKey() {
//   const key = await crypto.subtle.generateKey(
//     { name: 'AES-GCM', length: 256 },
//     true,
//     ['encrypt', 'decrypt']
//   );
//   return key;
// }

# Install: pip install cryptography
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
from cryptography.fernet import Fernet
import secrets

# Fernet key: 32 bytes = 16-byte HMAC-SHA256 key + 16-byte AES-128-CBC key
fernet_key = Fernet.generate_key()
print(f"Fernet Key (Base64): {fernet_key.decode()}")

# Raw AES-256 Key (32 bytes)
aes_256_key = secrets.token_bytes(32)
aes_256_hex = aes_256_key.hex()
print(f"AES-256 Key (Hex): {aes_256_hex}")

# AES-128 Key (16 bytes)
aes_128_key = secrets.token_hex(16)  # Returns hex string
print(f"AES-128 Key (Hex): {aes_128_key}")

# RSA Key Pair Generation (2048-bit)
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)

# Export private key
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)

# Export public key
public_key = private_key.public_key()
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

print(f"Private Key:\n{private_pem.decode()}")
print(f"Public Key:\n{public_pem.decode()}")

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.security.*;
import java.util.Base64;

public class EncryptionKeyGenerator {
    public static void main(String[] args) throws Exception {
        // AES-256 Key Generation
        KeyGenerator aesKeyGen = KeyGenerator.getInstance("AES");
        aesKeyGen.init(256, new SecureRandom());
        SecretKey aesKey = aesKeyGen.generateKey();

        byte[] aesKeyBytes = aesKey.getEncoded();
        String aesKeyHex = bytesToHex(aesKeyBytes);
        String aesKeyBase64 = Base64.getEncoder().encodeToString(aesKeyBytes);

        System.out.println("AES-256 Key (Hex): " + aesKeyHex);
        System.out.println("AES-256 Key (Base64): " + aesKeyBase64);

        // AES-128 Key
        aesKeyGen.init(128);
        SecretKey aes128Key = aesKeyGen.generateKey();
        System.out.println("AES-128 Key (Hex): " + bytesToHex(aes128Key.getEncoded()));

        // RSA Key Pair Generation (2048-bit)
        KeyPairGenerator rsaKeyGen = KeyPairGenerator.getInstance("RSA");
        rsaKeyGen.initialize(2048, new SecureRandom());
        KeyPair keyPair = rsaKeyGen.generateKeyPair();

        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();

        System.out.println("Private Key (Base64): " +
            Base64.getEncoder().encodeToString(privateKey.getEncoded()));
        System.out.println("Public Key (Base64): " +
            Base64.getEncoder().encodeToString(publicKey.getEncoded()));
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder hex = new StringBuilder();
        for (byte b : bytes) {
            hex.append(String.format("%02x", b));
        }
        return hex.toString();
    }
}

using System;
using System.Security.Cryptography;
using System.Text;

class EncryptionKeyGenerator
{
    static void Main()
    {
        // AES-256 Key Generation
        using (Aes aes = Aes.Create())
        {
            aes.KeySize = 256;
            aes.GenerateKey();

            string aesKeyHex = BitConverter.ToString(aes.Key).Replace("-", "");
            string aesKeyBase64 = Convert.ToBase64String(aes.Key);

            Console.WriteLine($"AES-256 Key (Hex): {aesKeyHex}");
            Console.WriteLine($"AES-256 Key (Base64): {aesKeyBase64}");
        }

        // AES-128 Key (manual, with RandomNumberGenerator)
        byte[] aes128Key = new byte[16]; // 128 bits
        RandomNumberGenerator.Fill(aes128Key);
        Console.WriteLine($"AES-128 Key (Hex): {BitConverter.ToString(aes128Key).Replace("-", "")}");

        // RSA Key Pair Generation (2048-bit)
        using (RSA rsa = RSA.Create(2048))
        {
            // Export private key
            string privateKeyXml = rsa.ToXmlString(true);
            byte[] privateKeyBytes = rsa.ExportPkcs8PrivateKey();
            string privateKeyBase64 = Convert.ToBase64String(privateKeyBytes);

            // Export public key
            string publicKeyXml = rsa.ToXmlString(false);
            byte[] publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
            string publicKeyBase64 = Convert.ToBase64String(publicKeyBytes);

            Console.WriteLine($"Private Key (Base64): {privateKeyBase64}");
            Console.WriteLine($"Public Key (Base64): {publicKeyBase64}");
        }
    }
}

#include <iostream>
#include <cryptopp/cryptlib.h>
#include <cryptopp/rijndael.h>
#include <cryptopp/modes.h>
#include <cryptopp/files.h>
#include <cryptopp/osrng.h>
#include <cryptopp/rsa.h>
#include <cryptopp/hex.h>
#include <cryptopp/base64.h>

using namespace CryptoPP;

int main() {
    AutoSeededRandomPool rng;

    // AES-256 Key Generation
    byte aes256Key[AES::MAX_KEYLENGTH]; // 32 bytes
    rng.GenerateBlock(aes256Key, sizeof(aes256Key));

    std::string aes256Hex;
    HexEncoder hexEncoder(new StringSink(aes256Hex));
    hexEncoder.Put(aes256Key, sizeof(aes256Key));
    hexEncoder.MessageEnd();

    std::cout << "AES-256 Key (Hex): " << aes256Hex << std::endl;

    // AES-128 Key
    byte aes128Key[16];
    rng.GenerateBlock(aes128Key, 16);

    std::string aes128Hex;
    StringSource(aes128Key, 16, true, new HexEncoder(new StringSink(aes128Hex)));
    std::cout << "AES-128 Key (Hex): " << aes128Hex << std::endl;

    // RSA Key Pair Generation (2048-bit)
    RSA::PrivateKey privateKey;
    privateKey.GenerateRandomWithKeySize(rng, 2048);

    RSA::PublicKey publicKey(privateKey);

    // Export private key (DER format)
    std::string privateKeyDer;
    StringSink privKeySink(privateKeyDer);
    privateKey.DEREncode(privKeySink);
    privKeySink.MessageEnd();

    std::string privateKeyBase64;
    StringSource(privateKeyDer, true,
        new Base64Encoder(new StringSink(privateKeyBase64), false));

    std::cout << "Private Key (Base64): " << privateKeyBase64 << std::endl;

    return 0;
}

require 'openssl'
require 'securerandom'
require 'base64'

# AES-256 Key Generation
aes_256_key = SecureRandom.random_bytes(32) # 256 bits
aes_256_hex = aes_256_key.unpack1('H*')
aes_256_base64 = Base64.strict_encode64(aes_256_key)

puts "AES-256 Key (Hex): #{aes_256_hex}"
puts "AES-256 Key (Base64): #{aes_256_base64}"

# AES-128 Key
aes_128_key = SecureRandom.hex(16) # Returns hex string (16 bytes)
puts "AES-128 Key (Hex): #{aes_128_key}"

# RSA Key Pair Generation (2048-bit)
rsa_key = OpenSSL::PKey::RSA.new(2048)

private_key_pem = rsa_key.to_pem
public_key_pem = rsa_key.public_key.to_pem

puts "Private Key:\n#{private_key_pem}"
puts "Public Key:\n#{public_key_pem}"

# Export in DER format (binary)
private_key_der = rsa_key.to_der
public_key_der = rsa_key.public_key.to_der

private_key_base64 = Base64.strict_encode64(private_key_der)
puts "Private Key (Base64): #{private_key_base64}"

# Password-protected private key
encrypted_key = rsa_key.private_to_pem(OpenSSL::Cipher.new('AES-256-CBC'), 'password')
puts "Encrypted Private Key:\n#{encrypted_key}"

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/hex"
    "encoding/pem"
    "fmt"
    "log"
)

func main() {
    // AES-256 Key Generation
    aes256Key := make([]byte, 32) // 256 bits
    if _, err := rand.Read(aes256Key); err != nil {
        log.Fatal(err)
    }

    aes256Hex := hex.EncodeToString(aes256Key)
    aes256Base64 := base64.StdEncoding.EncodeToString(aes256Key)

    fmt.Println("AES-256 Key (Hex):", aes256Hex)
    fmt.Println("AES-256 Key (Base64):", aes256Base64)

    // AES-128 Key
    aes128Key := make([]byte, 16)
    rand.Read(aes128Key)
    fmt.Println("AES-128 Key (Hex):", hex.EncodeToString(aes128Key))

    // RSA Key Pair Generation (2048-bit)
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        log.Fatal(err)
    }

    // Export private key (PKCS8 format)
    privateKeyBytes, err := x509.MarshalPKCS8PrivateKey(privateKey)
    if err != nil {
        log.Fatal(err)
    }

    privateKeyPem := pem.EncodeToMemory(&pem.Block{
        Type:  "PRIVATE KEY",
        Bytes: privateKeyBytes,
    })

    // Export public key
    publicKeyBytes, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
    if err != nil {
        log.Fatal(err)
    }

    publicKeyPem := pem.EncodeToMemory(&pem.Block{
        Type:  "PUBLIC KEY",
        Bytes: publicKeyBytes,
    })

    fmt.Println("Private Key:\n", string(privateKeyPem))
    fmt.Println("Public Key:\n", string(publicKeyPem))
}