ngs - v1.0.5

njs/crypto

Types

CryptoKey

</> 
pub type CryptoKey

CryptoKeyPair

</> 
pub type CryptoKeyPair

DecryptAlgorithm

</> 
pub type DecryptAlgorithm =
  EncryptAlgorithm

EncryptAlgorithm

</> 
pub type EncryptAlgorithm {
  RsaOaep(name: String)
  AesCtr(name: String, counter: buffer.ArrayBuffer, length: Int)
  AesCbc(name: String, iv: buffer.ArrayBuffer)
  AesGcm(
    name: String,
    iv: buffer.ArrayBuffer,
    additional_data: buffer.ArrayBuffer,
    tag_length: Int,
  )
}

Constructors

Hash

</> 
pub type Hash

Hmac

</> 
pub type Hmac

KeyAlgorithm

</> 
pub type KeyAlgorithm {
  RsaOaepKey(name: String, hash: String)
  HMACKey(name: String, hash: String, length: Int)
  AesKey(name: String)
}

Constructors 

  • RsaOaepKey(name: String, hash: String)

    RSA-OAEP

  • HMACKey(name: String, hash: String, length: Int)

    HMAC

  • AesKey(name: String)

    AES-CTR AES-CBC ASE-GCM

KeyData

</> 
pub type KeyData {
  KeyData(d: json.Json)
  KeyArrayData(d: buffer.ArrayBuffer)
}

Constructors

Values

create_hash

</> 
pub fn create_hash(algorithm a: String) -> Hash

create_hmac

</> 
pub fn create_hmac(algorithm a: String, secret k: String) -> Hmac

decrypt

</> 
pub fn decrypt(
  algorithm a: EncryptAlgorithm,
  key k: CryptoKey,
  ciphertext d: buffer.ArrayBuffer,
) -> promise.Promise(buffer.ArrayBuffer)

derive_bits

</> 
pub fn derive_bits(
  algorithm a: a,
  base_key k: CryptoKey,
  length l: Int,
) -> promise.Promise(buffer.ArrayBuffer)

derive_key

</> 
pub fn derive_key(
  algorithm a: a,
  base_key k: CryptoKey,
  derived_key_algorithm dka: KeyAlgorithm,
  extractable e: Bool,
  key_usages ku: array.Array(String),
) -> promise.Promise(CryptoKey)

digest

</> 
pub fn digest(
  algorithm a: String,
  data d: buffer.ArrayBuffer,
) -> promise.Promise(buffer.ArrayBuffer)

encrypt

</> 
pub fn encrypt(
  algorithm a: EncryptAlgorithm,
  key k: CryptoKey,
  plaintext d: buffer.ArrayBuffer,
) -> promise.Promise(buffer.ArrayBuffer)

export_key

</> 
pub fn export_key(
  format f: String,
  key k: CryptoKey,
) -> promise.Promise(KeyData)

generate_key

</> 
pub fn generate_key(
  algorithm a: KeyAlgorithm,
  extractable e: Bool,
  usages ku: array.Array(String),
) -> promise.Promise(CryptoKeyPair)

get_random_values

</> 
pub fn get_random_values(
  typedarray a: buffer.TypedArray,
) -> buffer.TypedArray

hash_copy

</> 
pub fn hash_copy(hash h: Hash) -> Hash

hash_digest

</> 
pub fn hash_digest(
  hash h: Hash,
  encoding e: buffer.Encoding,
) -> String

hash_update

</> 
pub fn hash_update(hash h: Hash, data d: buffer.Buffer) -> Hash

hmac_digest

</> 
pub fn hmac_digest(
  hmac h: Hmac,
  encoding e: buffer.Encoding,
) -> String

hmac_update

</> 
pub fn hmac_update(hmac h: Hmac, data d: buffer.Buffer) -> Hmac

import_key

</> 
pub fn import_key(
  format f: String,
  key k: buffer.ArrayBuffer,
  algorithm a: KeyAlgorithm,
  extractable e: Bool,
  usages ku: array.Array(String),
) -> promise.Promise(CryptoKey)

sign

</> 
pub fn sign(
  algorithm a: a,
  key k: CryptoKey,
  data d: buffer.ArrayBuffer,
) -> promise.Promise(buffer.ArrayBuffer)

verify

</> 
pub fn verify(
  algorithm a: a,
  key k: CryptoKey,
  signature s: buffer.ArrayBuffer,
  data d: buffer.ArrayBuffer,
) -> promise.Promise(Bool)
✨ Search Document