ferrijs-std 0.1.0

Node and web standard library for the ferrijs QuickJS runtime: WHATWG Streams, Events, AbortController, Buffer, crypto, fs, os, url, zlib and the capability model they enforce (partly derived from awslabs/llrt, Apache-2.0).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use std::rc::Rc;

use crate::utils::object::ObjectExt;
use rquickjs::{Class, Ctx, FromJs, Result, Value};

use super::{
    algorithm_invalid_access_error, algorithm_mismatch_error, algorithm_not_supported_error,
    crypto_key::{CryptoKey, KeyKind},
    key_algorithm::{EcAlgorithm, KeyAlgorithm, KeyDerivation},
    normalize_algorithm_name,
    util::ResultDomExt,
    EllipticCurve,
};

#[derive(Debug)]
pub enum DeriveAlgorithm {
    X25519 {
        public_key: Rc<[u8]>,
    },
    Ecdh {
        curve: EllipticCurve,
        ec_algorithm: EcAlgorithm,
        public_key: Rc<[u8]>,
    },
    Derive(KeyDerivation),
}

impl<'js> FromJs<'js> for DeriveAlgorithm {
    fn from_js(ctx: &Ctx<'js>, value: Value<'js>) -> Result<Self> {
        let obj = value.into_object_or_throw(ctx, "algorithm")?;

        let name: String = obj.get_required("name", "algorithm")?;
        let name = normalize_algorithm_name(&name);

        Ok(match name.as_str() {
            "X25519" => {
                let public_key: Class<CryptoKey> = obj.get_required("public", "algorithm")?;
                let public_key = public_key.borrow();

                public_key.check_kind(KeyKind::Public).or_throw_dom(ctx)?;

                if !matches!(public_key.algorithm, KeyAlgorithm::X25519) {
                    return algorithm_invalid_access_error(ctx, &name);
                }

                DeriveAlgorithm::X25519 {
                    public_key: public_key.handle.clone(),
                }
            },
            "ECDH" => {
                let public_key: Class<CryptoKey> = obj.get_required("public", "algorithm")?;
                let public_key = public_key.borrow();

                public_key.check_kind(KeyKind::Public).or_throw_dom(ctx)?;

                if let KeyAlgorithm::Ec {
                    curve, algorithm, ..
                } = &public_key.algorithm
                {
                    DeriveAlgorithm::Ecdh {
                        curve: *curve,
                        ec_algorithm: algorithm.clone(),
                        public_key: public_key.handle.clone(),
                    }
                } else {
                    return algorithm_mismatch_error(ctx, &name);
                }
            },
            "HKDF" => DeriveAlgorithm::Derive(KeyDerivation::for_hkdf_object(ctx, obj)?),
            "PBKDF2" => DeriveAlgorithm::Derive(KeyDerivation::for_pbkf2_object(&ctx, obj)?),
            _ => return algorithm_not_supported_error(ctx),
        })
    }
}