Struct CryptoGenerator 

pub struct CryptoGenerator { /* private fields */ }

Algorithm-agnostic license generator that supports multiple signature algorithms

This generator uses the pluggable cryptographic architecture to support different signature algorithms (RSA-SHA256, Ed25519, etc.).

Example

use licenz_core::generator::CryptoGenerator;
use licenz_core::crypto::algorithm_ids;
use licenz_core::keys::CryptoKeyPair;

// Generate keys
let keypair = CryptoKeyPair::generate(algorithm_ids::ED25519).unwrap();

// Create generator
let generator = CryptoGenerator::new(keypair.private_key_pem(), algorithm_ids::ED25519);

// Generate license
let license = generator.generate(license_data).unwrap();
assert_eq!(license.algorithm, "Ed25519");

Implementations

impl CryptoGenerator

pub fn new(private_key_pem: &str, algorithm_id: &str) -> Self

Create a new crypto generator with the specified algorithm

Arguments

• private_key_pem - The private key in PEM format
• algorithm_id - The algorithm to use (e.g., “RSA-SHA256”, “Ed25519”)

pub fn from_pem_file(path: &Path, algorithm_id: &str) -> Result<Self>

Create a generator from a PEM file

pub fn from_keypair(keypair: &CryptoKeyPair) -> Self

Create a generator from a CryptoKeyPair

pub fn algorithm_id(&self) -> &str

Get the algorithm ID

pub fn generate(&self, data: LicenseData) -> Result<SignedLicense>

Generate a signed license from license data

pub fn export_binary(&self, license: &SignedLicense) -> Result<Vec<u8>>

Export a signed license to binary format

pub fn export_json(&self, license: &SignedLicense) -> Result<String>

Export a signed license to JSON format

pub fn save_binary(&self, license: &SignedLicense, path: &Path) -> Result<()>

Save a license to a binary file

pub fn save_json(&self, license: &SignedLicense, path: &Path) -> Result<()>

Save a license to a JSON file

Trait Implementations

impl Debug for CryptoGenerator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.