Add crypto hmac sha 256

crates/config/src/lib.rs

@@ -31,6 +31,7 @@ bitflags! {
  const JAVY_STREAM_IO = 1 << 2;
  const REDIRECT_STDOUT_TO_STDERR = 1 << 3;
  const TEXT_ENCODING = 1 << 4;
+ const CRYPTO = 1 << 5;
  }
 }
 
@@ -44,5 +45,6 @@ mod tests {
  assert!(Config::JAVY_STREAM_IO == Config::from_bits(1 << 2).unwrap());
  assert!(Config::REDIRECT_STDOUT_TO_STDERR == Config::from_bits(1 << 3).unwrap());
  assert!(Config::TEXT_ENCODING == Config::from_bits(1 << 4).unwrap());
+ assert!(Config::CRYPTO == Config::from_bits(1 << 5).unwrap());
  }
 }

crates/core/src/runtime.rs

@@ -12,7 +12,8 @@ pub(crate) fn new(shared_config: SharedConfig) -> Result<Runtime> {
  // we're disabling this temporarily. It will be enabled once we have a
  // fix forward.
  .override_json_parse_and_stringify(false)
- .javy_json(false);
+ .javy_json(false)
+ .crypto(shared_config.contains(SharedConfig::CRYPTO));
 
  Runtime::new(std::mem::take(config))
 }

crates/javy/Cargo.toml

@@ -24,6 +24,8 @@ quickcheck = "1"
 bitflags = { workspace = true }
 fastrand = "2.1.0"
 simd-json = { version = "0.13.10", optional = true, default-features = false, features = ["big-int-as-float", "serde_impl"] }
+sha2 = "0.10.8"
+hmac = "0.12.1"
 
 [dev-dependencies]
 javy-test-macros = { path = "../test-macros/" }

crates/javy/src/apis/crypto/mod.rs

@@ -0,0 +1,88 @@
+use crate::quickjs::{context::Intrinsic, qjs, Ctx, Function, Object, String as JSString, Value};
+use crate::{hold, hold_and_release, to_js_error, val_to_string, Args};
+use anyhow::{bail, Error, Result};
+
+use hmac::{Hmac, Mac};
+use sha2::Sha256;
+
+/// An implemetation of crypto APIs to optimize fuel.
+/// Currently, hmacSHA256 is the only function implemented.
+pub struct Crypto;
+
+impl Intrinsic for Crypto {
+ unsafe fn add_intrinsic(ctx: std::ptr::NonNull<qjs::JSContext>) {
+ register(Ctx::from_raw(ctx)).expect("`Crypto` APIs to succeed")
+ }
+}
+fn register(this: Ctx<'_>) -> Result<()> {
+ let globals = this.globals();
+
+ // let crypto_obj = Object::new(cx)?;
+ let crypto_obj = Object::new(this.clone())?;
+
+ crypto_obj.set(
+ "hmacSHA256",
+ Function::new(this.clone(), |this, args| {
+ let (this, args) = hold_and_release!(this, args);
+ hmac_sha256(hold!(this.clone(), args)).map_err(|e| to_js_error(this, e))
+ }),
+ )?;
+
+ globals.set("crypto", crypto_obj)?;
+
+ Ok::<_, Error>(())
+}
+/// hmac_sha256 applies the HMAC algorithm using sha256 for hashing.
+/// Arg[0] - secret
+/// Arg[1] - message
+/// returns - hex encoded string of hmac.
+fn hmac_sha256(args: Args<'_>) -> Result<Value<'_>> {
+ let (cx, args) = args.release();
+
+ if args.len() != 2 {
+ bail!("Wrong number of arguments. Expected 2. Got {}", args.len());
+ }
+
+ let js_string_secret = val_to_string(&cx, args[0].clone())?;
+ let js_string_message = val_to_string(&cx, args[1].clone())?;
+
+ /// Create alias for HMAC-SHA256
+ type HmacSha256 = Hmac<Sha256>;
+
+ let mut mac = HmacSha256::new_from_slice(js_string_secret.as_bytes())
+ .expect("HMAC can take key of any size");
+ mac.update(js_string_message.as_bytes());
+
+ let result = mac.finalize();
+ let code_bytes = result.into_bytes();
+ let code: String = format!("{code_bytes:x}");
+ let js_string = JSString::from_str(cx, &code);
+ Ok(Value::from_string(js_string?))
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::{quickjs::Value, Config, Runtime};
+ use anyhow::{Error, Result};
+
+ #[test]
+ fn test_text_encoder_decoder() -> Result<()> {
+ let mut config = Config::default();
+ config.crypto(true);
+ let runtime = Runtime::new(config)?;
+
+ runtime.context().with(|this| {
+ let result: Value<'_> = this.eval(
+ r#"
+ let expectedHex = "97d2a569059bbcd8ead4444ff99071f4c01d005bcefe0d3567e1be628e5fdcd9";
+ let result = crypto.hmacSHA256("my secret and secure key", "input message");
+ expectedHex === result;
+ "#,
+ )?;
+
+ assert!(result.as_bool().unwrap());
+ Ok::<_, Error>(())
+ })?;
+ Ok(())
+ }
+}

crates/javy/src/apis/mod.rs

@@ -57,13 +57,15 @@
 //!
 //! Disabled by default.
 pub(crate) mod console;
+pub(crate) mod crypto;
 #[cfg(feature = "json")]
 pub(crate) mod json;
 pub(crate) mod random;
 pub(crate) mod stream_io;
 pub(crate) mod text_encoding;
 
 pub(crate) use console::*;
+pub(crate) use crypto::*;
 #[cfg(feature = "json")]
 pub(crate) use json::*;
 pub(crate) use random::*;

crates/javy/src/config.rs

@@ -19,6 +19,7 @@ bitflags! {
  const OPERATORS = 1 << 12;
  const BIGNUM_EXTENSION = 1 << 13;
  const TEXT_ENCODING = 1 << 14;
+ const CRYPTO = 1 << 15;
  }
 }
 
@@ -179,6 +180,14 @@ impl Config {
  self
  }
 
+ /// Whether the `crypto` intrinsic will be available.
+ /// Enabled by default.
+ // #[cfg(feature = "crypto")]
+ pub fn crypto(&mut self, enable: bool) -> &mut Self {
+ self.intrinsics.set(JSIntrinsics::CRYPTO, enable);
+ self
+ }
+
  /// Enables whether the output of console.log will be redirected to
  /// `stderr`.
  pub fn redirect_stdout_to_stderr(&mut self, enable: bool) -> &mut Self {

crates/javy/src/runtime.rs

@@ -1,7 +1,7 @@
 // use crate::quickjs::JSContextRef;
 use super::from_js_error;
 use crate::{
- apis::{Console, NonStandardConsole, Random, StreamIO, TextEncoding},
+ apis::{Console, Crypto, NonStandardConsole, Random, StreamIO, TextEncoding},
  config::{JSIntrinsics, JavyIntrinsics},
  Config,
 };
@@ -144,6 +144,11 @@ impl Runtime {
  JavyJson::add_intrinsic(ctx.as_raw())
  }
  }
+
+ if intrinsics.contains(JSIntrinsics::CRYPTO) {
+ // #[cfg(feature = "crypto")]
+ unsafe { Crypto::add_intrinsic(ctx.as_raw()) }
+ }
  });
 
  Ok(ManuallyDrop::new(context))