1 files changed, 27 insertions, 18 deletions

diff --git a/ext/crypto/shared.rs b/ext/crypto/shared.rs
index 4ecb35dc2..109f51fa1 100644
--- a/ext/crypto/shared.rs
+++ b/ext/crypto/shared.rs
@@ -5,7 +5,8 @@ use std::borrow::Cow;
 use deno_core::error::custom_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::ZeroCopyBuf;
+use deno_core::JsBuffer;
+use deno_core::ToJsBuffer;
 use elliptic_curve::sec1::ToEncodedPoint;
 use rsa::pkcs1::DecodeRsaPrivateKey;
 use rsa::pkcs1::EncodeRsaPublicKey;
@@ -46,19 +47,27 @@ pub enum EcNamedCurve {
   P521,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Deserialize)]
 #[serde(rename_all = "lowercase", tag = "type", content = "data")]
-pub enum RawKeyData {
-  Secret(ZeroCopyBuf),
-  Private(ZeroCopyBuf),
-  Public(ZeroCopyBuf),
+pub enum V8RawKeyData {
+  Secret(JsBuffer),
+  Private(JsBuffer),
+  Public(JsBuffer),
 }
 
-impl RawKeyData {
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase", tag = "type", content = "data")]
+pub enum RustRawKeyData {
+  Secret(ToJsBuffer),
+  Private(ToJsBuffer),
+  Public(ToJsBuffer),
+}
+
+impl V8RawKeyData {
   pub fn as_rsa_public_key(&self) -> Result<Cow<'_, [u8]>, AnyError> {
     match self {
-      RawKeyData::Public(data) => Ok(Cow::Borrowed(data)),
-      RawKeyData::Private(data) => {
+      V8RawKeyData::Public(data) => Ok(Cow::Borrowed(data)),
+      V8RawKeyData::Private(data) => {
         let private_key = RsaPrivateKey::from_pkcs1_der(data)
           .map_err(|_| type_error("expected valid private key"))?;
 
@@ -75,55 +84,55 @@ impl RawKeyData {
 
   pub fn as_rsa_private_key(&self) -> Result<&[u8], AnyError> {
     match self {
-      RawKeyData::Private(data) => Ok(data),
+      V8RawKeyData::Private(data) => Ok(data),
       _ => Err(type_error("expected private key")),
     }
   }
 
   pub fn as_secret_key(&self) -> Result<&[u8], AnyError> {
     match self {
-      RawKeyData::Secret(data) => Ok(data),
+      V8RawKeyData::Secret(data) => Ok(data),
       _ => Err(type_error("expected secret key")),
     }
   }
 
   pub fn as_ec_public_key_p256(&self) -> Result<p256::EncodedPoint, AnyError> {
     match self {
-      RawKeyData::Public(data) => {
+      V8RawKeyData::Public(data) => {
         // public_key is a serialized EncodedPoint
         p256::EncodedPoint::from_bytes(data)
           .map_err(|_| type_error("expected valid public EC key"))
       }
-      RawKeyData::Private(data) => {
+      V8RawKeyData::Private(data) => {
         let signing_key = p256::SecretKey::from_pkcs8_der(data)
           .map_err(|_| type_error("expected valid private EC key"))?;
         Ok(signing_key.public_key().to_encoded_point(false))
       }
       // Should never reach here.
-      RawKeyData::Secret(_) => unreachable!(),
+      V8RawKeyData::Secret(_) => unreachable!(),
     }
   }
 
   pub fn as_ec_public_key_p384(&self) -> Result<p384::EncodedPoint, AnyError> {
     match self {
-      RawKeyData::Public(data) => {
+      V8RawKeyData::Public(data) => {
         // public_key is a serialized EncodedPoint
         p384::EncodedPoint::from_bytes(data)
           .map_err(|_| type_error("expected valid public EC key"))
       }
-      RawKeyData::Private(data) => {
+      V8RawKeyData::Private(data) => {
         let signing_key = p384::SecretKey::from_pkcs8_der(data)
           .map_err(|_| type_error("expected valid private EC key"))?;
         Ok(signing_key.public_key().to_encoded_point(false))
       }
       // Should never reach here.
-      RawKeyData::Secret(_) => unreachable!(),
+      V8RawKeyData::Secret(_) => unreachable!(),
     }
   }
 
   pub fn as_ec_private_key(&self) -> Result<&[u8], AnyError> {
     match self {
-      RawKeyData::Private(data) => Ok(data),
+      V8RawKeyData::Private(data) => Ok(data),
       _ => Err(type_error("expected private key")),
     }
   }