Merge pull request #101 from karthik2804/crypto/digest

add sha256 and sha512 digests

Author: karthik2804

Cargo.lock

@@ -22,3 +22,4 @@ serde = "1.0.137"
 serde_bytes = "0.11"
 serde_derive = "1.0.137"
 send_wrapper = "0.6.0"
+sha2 = "0.10.6"

crates/spin-js-engine/Cargo.toml

@@ -1,14 +1,19 @@
+require('fast-text-encoding')
+
+let encoder = new TextEncoder()
+
 /** @internal */
 declare var _random: {
     math_rand: () => number
     get_rand: () => number
+    get_hash: (algorithm: string, content: ArrayBuffer) => ArrayBuffer
 }
 
 /** @internal */
 export const crypto = {
     getRandomValues: function <T extends ArrayBufferView | null>(array: T) {
         if (array) {
-            if(array.byteLength > 65536) {
+            if (array.byteLength > 65536) {
                 throw "QuotaExceededError"
             }
             const bytes = Buffer.from(array.buffer)
@@ -17,5 +22,41 @@ export const crypto = {
             }
         }
         return array
+    },
+    subtle: {
+        digest: function (algorithm: string, content: ArrayBuffer) {
+            if (algorithm == "SHA-256") {
+                return Promise.resolve(_random.get_hash("sha256", content))
+            } else if (algorithm == "SHA-512") {
+                return Promise.resolve(_random.get_hash("sha512", content))
+            } else {
+                throw new Error("SHA-256 and SHA-512 are the only supported algorithms");
+            }
+        }
+    },
+    createHash: function (algorithm: string) {
+        let data = new Uint8Array()
+        return {
+            update(content: string | Uint8Array, inputEncoding: string = "string") {
+                if (inputEncoding == "string") {
+                    // @ts-ignore
+                    content = encoder.encode(content)
+                }
+                let  mergedArray = new Uint8Array(data.length + content.length);
+                mergedArray.set(data);
+                // @ts-ignore
+                mergedArray.set(content, data.length);
+                data = mergedArray
+            },
+            digest() {
+                if (algorithm == "sha256") {
+                    return _random.get_hash("sha256", data.buffer)
+                } else if (algorithm == "sha512") {
+                    return _random.get_hash("sha512", data.buffer)
+                } else
+                    throw new Error("sha256 and sha512 are the only supported algorithms");
+            }
+        }
     }
+
 }

crates/spin-js-engine/src/js_sdk/modules/crypto.ts

@@ -9,6 +9,7 @@ use {
     send_wrapper::SendWrapper,
     serde::{Deserialize, Serialize},
     serde_bytes::ByteBuf,
+    sha2::Digest,
     spin_sdk::{
         config,
         http::{Request, Response},
@@ -256,6 +257,30 @@ fn get_rand(context: &Context, _this: &Value, _args: &[Value]) -> Result<Value>
     context.value_from_u32(thread_rng().gen_range(0..=255))
 }
 
+fn get_hash(context: &Context, _this: &Value, args: &[Value]) -> Result<Value> {
+    match args {
+        [algorithm, content] => {
+            let algorithm = &deserialize_helper(algorithm)?;
+            let content_deserializer = &mut Deserializer::from(content.clone());
+            let content = ByteBuf::deserialize(content_deserializer)?;
+            if algorithm == "sha256" {
+                let hashvalue = sha2::Sha256::digest(content);
+                let mut serializer = Serializer::from_context(context)?;
+                hashvalue.serialize(&mut serializer)?;
+                Ok(serializer.value)
+            } else if algorithm == "sha512" {
+                let hashvalue = sha2::Sha512::digest(content);
+                let mut serializer = Serializer::from_context(context)?;
+                hashvalue.serialize(&mut serializer)?;
+                Ok(serializer.value)
+            } else {
+                bail!("Invalid algorithm, only sha256 and sha512 are supported")
+            }
+        }
+        _ => bail!("invalid"),
+    }
+}
+
 fn math_rand(context: &Context, _this: &Value, _args: &[Value]) -> Result<Value> {
     context.value_from_f64(thread_rng().gen_range(0.0_f64..1.0))
 }
@@ -462,6 +487,7 @@ fn do_init() -> Result<()> {
     let _random = context.object_value()?;
     _random.set_property("math_rand", context.wrap_callback(math_rand)?)?;
     _random.set_property("get_rand", context.wrap_callback(get_rand)?)?;
+    _random.set_property("get_hash", context.wrap_callback(get_hash)?)?;
 
     global.set_property("_random", _random)?;
     global.set_property("spinSdk", spin_sdk)?;

crates/spin-js-engine/src/lib.rs

@@ -37,8 +37,16 @@ declare global {
         toString(): string
         values(): string[]
     }
+    interface Hash {
+        update(content: string | Uint8Array, inputEncoding?: string): void
+        digest(): ArrayBuffer
+    }
     const crypto:  {
         getRandomValues<T extends ArrayBufferView | null>(array: T): T
+        subtle: {
+            digest(algorithm: string, content: ArrayBuffer): Promise<ArrayBuffer>
+        }
+        createHash(algorithm: string): Hash
     }
 }