chore: Move WASM WindowOrWorker util into c2pa-crypto (#690)

internal/crypto/Cargo.toml

@@ -83,6 +83,7 @@ web-time = "1.1"
 
 [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
 getrandom = { version = "0.2.7", features = ["js"] }
+js-sys = "0.3.58"
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wasm-bindgen-test = "0.3.31"

internal/crypto/src/tests/webcrypto/mod.rs

@@ -12,3 +12,4 @@
 // each license.
 
 mod validators;
+mod window_or_worker;

internal/crypto/src/tests/webcrypto/window_or_worker.rs

@@ -0,0 +1,21 @@
+// Copyright 2024 Adobe. All rights reserved.
+// This file is licensed to you under the Apache License,
+// Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
+// or the MIT license (http://opensource.org/licenses/MIT),
+// at your option.
+
+// Unless required by applicable law or agreed to in writing,
+// this software is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR REPRESENTATIONS OF ANY KIND, either express or
+// implied. See the LICENSE-MIT and LICENSE-APACHE files for the
+// specific language governing permissions and limitations under
+// each license.
+
+use wasm_bindgen_test::wasm_bindgen_test;
+
+use crate::webcrypto::WindowOrWorker;
+
+#[wasm_bindgen_test]
+fn has_crypto_library() {
+    WindowOrWorker::new().unwrap().crypto().unwrap();
+}

internal/crypto/src/webcrypto/mod.rs

@@ -20,3 +20,6 @@
 //! [`SubtleCrypto`]: https://rustwasm.github.io/wasm-bindgen/api/web_sys/struct.SubtleCrypto.html
 
 pub mod validators;
+
+mod window_or_worker;
+pub use window_or_worker::{WasmCryptoError, WindowOrWorker};

sdk/src/wasm/context.rs → internal/crypto/src/webcrypto/window_or_worker.rs

@@ -11,24 +11,28 @@
 // specific language governing permissions and limitations under
 // each license.
 
+#![allow(missing_docs)]
+
+use thiserror::Error;
 use wasm_bindgen::{prelude::*, JsCast, JsValue};
 use web_sys::{Crypto, SubtleCrypto, Window, WorkerGlobalScope};
 
-use crate::{Error, Result};
-
-// Adapted from gloo's implementation, since there doesn't seem to be a great way to do context checking using
-// wasm-bindgen/web-sys without using something like `js_sys::eval`. References:
-// - Issue: https://github.com/rustwasm/wasm-bindgen/issues/1046
-// - Issue: https://github.com/rustwasm/wasm-bindgen/issues/2148#issuecomment-638606446
-// - Code reference: https://git.io/J9crn
-
+/// Adapted from gloo's implementation, since there doesn't seem to be a great
+/// way to do context checking using `wasm-bindgen/web-sys` without using
+/// something like `js_sys::eval`.
+///
+/// References:
+///
+/// - Issue: https://github.com/rustwasm/wasm-bindgen/issues/1046
+/// - Issue: https://github.com/rustwasm/wasm-bindgen/issues/2148#issuecomment-638606446
+/// - Code reference: https://git.io/J9crn
 pub enum WindowOrWorker {
     Window(Window),
     Worker(WorkerGlobalScope),
 }
 
 impl WindowOrWorker {
-    pub fn new() -> Result<Self> {
+    pub fn new() -> Result<Self, WasmCryptoError> {
         #[wasm_bindgen]
         extern "C" {
             type Global;
@@ -47,21 +51,31 @@ impl WindowOrWorker {
         } else if !global.worker().is_undefined() {
             Ok(Self::Worker(global.unchecked_into()))
         } else {
-            Err(Error::WasmInvalidContext)
+            Err(WasmCryptoError::UnknownContext)
         }
     }
 
-    pub fn crypto(&self) -> Result<Crypto> {
+    pub fn crypto(&self) -> Result<Crypto, WasmCryptoError> {
         match self {
             Self::Window(window) => window.crypto(),
             Self::Worker(worker) => worker.crypto(),
         }
-        .map_err(|_err| Error::WasmNoCrypto)
+        .map_err(|_err| WasmCryptoError::NoCryptoAvailable)
     }
 
-    pub fn subtle_crypto(&self) -> Result<SubtleCrypto> {
-        let crypto = self.crypto()?;
-
-        Ok(crypto.subtle())
+    pub fn subtle_crypto(&self) -> Result<SubtleCrypto, WasmCryptoError> {
+        Ok(self.crypto()?.subtle())
     }
 }
+
+/// Error returned when cryptography libraries are unavailable.
+#[derive(Debug, Error, Eq, PartialEq)]
+pub enum WasmCryptoError {
+    /// Unknown context.
+    #[error("could not find window or worker in global environment")]
+    UnknownContext,
+
+    /// Crypto library unavailable.
+    #[error("window or worker's .crypto() method failed")]
+    NoCryptoAvailable,
+}

sdk/src/error.rs

@@ -314,3 +314,13 @@ impl From<c2pa_crypto::openssl::OpenSslMutexUnavailable> for Error {
         Self::OpenSslMutexError
     }
 }
+
+#[cfg(target_arch = "wasm32")]
+impl From<c2pa_crypto::webcrypto::WasmCryptoError> for Error {
+    fn from(err: c2pa_crypto::webcrypto::WasmCryptoError) -> Self {
+        match err {
+            c2pa_crypto::webcrypto::WasmCryptoError::UnknownContext => Self::WasmInvalidContext,
+            c2pa_crypto::webcrypto::WasmCryptoError::NoCryptoAvailable => Self::WasmNoCrypto,
+        }
+    }
+}

sdk/src/utils/test.rs

@@ -496,11 +496,10 @@ impl crate::signer::AsyncSigner for WebCryptoSigner {
     }
 
     async fn sign(&self, claim_bytes: Vec<u8>) -> crate::error::Result<Vec<u8>> {
+        use c2pa_crypto::webcrypto::WindowOrWorker;
         use js_sys::{Array, Object, Reflect, Uint8Array};
         use wasm_bindgen_futures::JsFuture;
         use web_sys::CryptoKey;
-
-        use crate::wasm::context::WindowOrWorker;
         let context = WindowOrWorker::new().unwrap();
         let crypto = context.subtle_crypto().unwrap();
 

sdk/src/wasm/mod.rs

@@ -11,8 +11,6 @@
 // specific language governing permissions and limitations under
 // each license.
 
-#[cfg(target_arch = "wasm32")]
-pub(crate) mod context;
 #[cfg(target_arch = "wasm32")]
 pub(crate) mod rsa_wasm_signer;
 #[cfg(target_arch = "wasm32")]

sdk/src/wasm/util.rs

@@ -1,6 +1,7 @@
+use c2pa_crypto::webcrypto::WindowOrWorker;
 use web_sys::Crypto;
 
-use crate::{wasm::context::WindowOrWorker, Error, Result};
+use crate::{Error, Result};
 
 pub fn get_random_values(len: usize) -> Result<Vec<u8>> {
     let context = WindowOrWorker::new();

sdk/src/wasm/webcrypto_validator.rs

@@ -13,15 +13,15 @@
 
 use std::convert::TryFrom;
 
-use c2pa_crypto::SigningAlg;
+use c2pa_crypto::{webcrypto::WindowOrWorker, SigningAlg};
 use js_sys::{Array, ArrayBuffer, Object, Reflect, Uint8Array};
 use spki::SubjectPublicKeyInfoRef;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{CryptoKey, SubtleCrypto};
 use x509_parser::der_parser::ber::{parse_ber_sequence, BerObject};
 
-use crate::{wasm::context::WindowOrWorker, Error, Result};
+use crate::{Error, Result};
 
 pub struct EcKeyImportParams {
     name: String,