Module: PQCrypto::KEM

Defined in:
lib/pq_crypto/kem.rb

Defined Under Namespace

Classes: EncapsulationResult, Keypair, PublicKey, SecretKey

Constant Summary collapse

CANONICAL_ALGORITHM = 
:ml_kem_768
DETAILS = 
AlgorithmRegistry.details_for_family(:ml_kem).freeze
NATIVE_DISPATCH = 
{
  ml_kem_512: {
    keypair: :native_ml_kem_512_keypair,
    keypair_from_seed: :native_ml_kem_512_keypair_from_seed,
    encapsulate: :native_ml_kem_512_encapsulate,
    decapsulate: :native_ml_kem_512_decapsulate,
    check_public_key: :native_ml_kem_512_check_public_key,
    check_secret_key: :native_ml_kem_512_check_secret_key,
  }.freeze,
  ml_kem_768: {
    keypair: :native_ml_kem_keypair,
    keypair_from_seed: :native_ml_kem_keypair_from_seed,
    encapsulate: :native_ml_kem_encapsulate,
    decapsulate: :native_ml_kem_decapsulate,
    check_public_key: :native_ml_kem_check_public_key,
    check_secret_key: :native_ml_kem_check_secret_key,
  }.freeze,
  ml_kem_1024: {
    keypair: :native_ml_kem_1024_keypair,
    keypair_from_seed: :native_ml_kem_1024_keypair_from_seed,
    encapsulate: :native_ml_kem_1024_encapsulate,
    decapsulate: :native_ml_kem_1024_decapsulate,
    check_public_key: :native_ml_kem_1024_check_public_key,
    check_secret_key: :native_ml_kem_1024_check_secret_key,
  }.freeze,
}.freeze

Class Method Summary collapse

Class Method Details

.details(algorithm) ⇒ Object 



103
104
105
 
# File 'lib/pq_crypto/kem.rb', line 103

def details(algorithm)
  DETAILS.fetch(resolve_algorithm!(algorithm)).dup
end

.generate(algorithm = CANONICAL_ALGORITHM) ⇒ Object 



39
40
41
42
43
 
# File 'lib/pq_crypto/kem.rb', line 39

def generate(algorithm = CANONICAL_ALGORITHM)
  algorithm = resolve_algorithm!(algorithm)
  public_key, secret_key = PQCrypto.__send__(native_method_for(algorithm, :keypair))
  Keypair.new(PublicKey.new(algorithm, public_key), SecretKey.new(algorithm, secret_key))
end

.public_key_from_bytes(algorithm, bytes) ⇒ Object 



45
46
47
 
# File 'lib/pq_crypto/kem.rb', line 45

def public_key_from_bytes(algorithm, bytes)
  PublicKey.new(resolve_algorithm!(algorithm), bytes)
end

.public_key_from_pqc_container_der(der, algorithm = nil) ⇒ Object 



57
58
59
60
 
# File 'lib/pq_crypto/kem.rb', line 57

def public_key_from_pqc_container_der(der, algorithm = nil)
  resolved_algorithm, bytes = Serialization.public_key_from_pqc_container_der(algorithm, der)
  PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
end

.public_key_from_pqc_container_pem(pem, algorithm = nil) ⇒ Object 



62
63
64
65
 
# File 'lib/pq_crypto/kem.rb', line 62

def public_key_from_pqc_container_pem(pem, algorithm = nil)
  resolved_algorithm, bytes = Serialization.public_key_from_pqc_container_pem(algorithm, pem)
  PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
end

.public_key_from_spki_der(der, algorithm: nil) ⇒ Object 



91
92
93
94
95
 
# File 'lib/pq_crypto/kem.rb', line 91

def public_key_from_spki_der(der, algorithm: nil)
  resolved_algorithm, bytes = SPKI.decode_der(der)
  validate_algorithm_match!(algorithm, resolved_algorithm) if algorithm
  PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
end

.public_key_from_spki_pem(pem, algorithm: nil) ⇒ Object 



97
98
99
100
101
 
# File 'lib/pq_crypto/kem.rb', line 97

def public_key_from_spki_pem(pem, algorithm: nil)
  resolved_algorithm, bytes = SPKI.decode_pem(pem)
  validate_algorithm_match!(algorithm, resolved_algorithm) if algorithm
  PublicKey.new(resolve_algorithm!(resolved_algorithm), bytes)
end

.secret_key_from_bytes(algorithm, bytes) ⇒ Object 



49
50
51
 
# File 'lib/pq_crypto/kem.rb', line 49

def secret_key_from_bytes(algorithm, bytes)
  SecretKey.new(resolve_algorithm!(algorithm), bytes)
end

.secret_key_from_pkcs8_der(der, passphrase: nil, require_encrypted: false) ⇒ Object 



77
78
79
80
81
82
 
# File 'lib/pq_crypto/kem.rb', line 77

def secret_key_from_pkcs8_der(der, passphrase: nil, require_encrypted: false)
  require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
  secret_key_from_decoded_pkcs8(
    *PKCS8.decode_der(der, passphrase: passphrase, require_encrypted: require_encrypted)
  )
end

.secret_key_from_pkcs8_pem(pem, passphrase: nil, require_encrypted: false) ⇒ Object 



84
85
86
87
88
89
 
# File 'lib/pq_crypto/kem.rb', line 84

def secret_key_from_pkcs8_pem(pem, passphrase: nil, require_encrypted: false)
  require_encrypted = Internal.strict_boolean!(require_encrypted, name: "require_encrypted")
  secret_key_from_decoded_pkcs8(
    *PKCS8.decode_pem(pem, passphrase: passphrase, require_encrypted: require_encrypted)
  )
end

.secret_key_from_pqc_container_der(der, algorithm = nil) ⇒ Object 



67
68
69
70
 
# File 'lib/pq_crypto/kem.rb', line 67

def secret_key_from_pqc_container_der(der, algorithm = nil)
  resolved_algorithm, bytes = Serialization.secret_key_from_pqc_container_der(algorithm, der)
  SecretKey.new(resolve_algorithm!(resolved_algorithm), bytes)
end

.secret_key_from_pqc_container_pem(pem, algorithm = nil) ⇒ Object 



72
73
74
75
 
# File 'lib/pq_crypto/kem.rb', line 72

def secret_key_from_pqc_container_pem(pem, algorithm = nil)
  resolved_algorithm, bytes = Serialization.secret_key_from_pqc_container_pem(algorithm, pem)
  SecretKey.new(resolve_algorithm!(resolved_algorithm), bytes)
end

.secret_key_from_seed(algorithm, seed) ⇒ Object 



53
54
55
 
# File 'lib/pq_crypto/kem.rb', line 53

def secret_key_from_seed(algorithm, seed)
  SecretKey.from_seed(resolve_algorithm!(algorithm), seed)
end

.supported ⇒ Object 



107
108
109
 
# File 'lib/pq_crypto/kem.rb', line 107

def supported
  DETAILS.keys.dup
end