update to c2pa-rs main API

Author: gpeacock

Cargo.toml

@@ -13,7 +13,7 @@ crate-type = ["cdylib"]
 v1 = ["c2pa/file_io"]
 
 [dependencies]
-c2pa = {git = "https://github.com/contentauth/c2pa-rs.git", branch = "gpeacock/manifest_store_builder", features = ["openssl", "openssl_sign"]}
+c2pa = {git = "https://github.com/contentauth/c2pa-rs.git", branch = "main", features = ["unstable_api", "openssl", "openssl_sign"]}
 pem = "3.0.3"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_derive = "1.0"

src/c2pa.udl

@@ -3,6 +3,8 @@ namespace c2pa {
   string version();
   string sdk_version();
  /// [Throws=Error]
+ /// CallbackSigner create_signer(SignerCallback callback, SigningAlg alg, bytes certs, string? ta_url);
+ /// [Throws=Error]
  /// string read_file([ByRef] string path, string? data_dir);
  /// [Throws=Error]
  /// string read_ingredient_file([ByRef] string path, [ByRef] string data_dir);
@@ -22,7 +24,6 @@ interface Error {
   Manifest(string reason);
   ManifestNotFound(string reason);
   NotSupported(string reason);
-  FileNotFound(string reason);
   Other(string reason);
   RemoteManifest(string reason);
   ResourceNotFound(string reason);
@@ -62,27 +63,13 @@ interface Reader {
   constructor();
 
   [Throws=Error]
-  string read([ByRef] string format, [ByRef] Stream reader);
+  string from_stream([ByRef] string format, [ByRef] Stream reader);
 
   [Throws=Error]
   string json();
 
   [Throws=Error]
-  u64 resource([ByRef] string uri, [ByRef] Stream stream);
-};
-
-///dictionary SignerInfo {
-///  string alg;
-///  sequence<u8> sign_cert;
-///  sequence<u8> private_key;
-///  string? ta_url;
-///};
-
-dictionary SignerConfig {
-  SigningAlg alg;
-  bytes certs;
-  string? time_authority_url = null;
-  boolean use_ocsp = false;
+  u64 resource_to_stream([ByRef] string uri, [ByRef] Stream stream);
 };
 
 callback interface SignerCallback {
@@ -91,7 +78,7 @@ callback interface SignerCallback {
 };
 
 interface CallbackSigner {
-  constructor(SignerCallback callback,  SignerConfig config);
+  constructor(SignerCallback callback, SigningAlg alg, bytes certs, string? ta_url);
 };
 
 interface Builder {
@@ -106,6 +93,12 @@ interface Builder {
   [Throws=Error]
   void add_ingredient([ByRef] string ingredient_json, [ByRef] string format, [ByRef] Stream stream );
 
+  [Throws=Error]
+  void to_archive([ByRef] Stream stream );
+
+  [Throws=Error]
+  void from_archive([ByRef] Stream stream );
+
   [Throws=Error]
   bytes sign([ByRef] string format, [ByRef] Stream input, [ByRef] Stream output ,[ByRef] CallbackSigner signer);
 };

src/callback_signer.rs

@@ -10,80 +10,47 @@
 // specific language governing permissions and limitations under
 // each license.
 
-use c2pa::{Signer, SigningAlg};
+use c2pa::SigningAlg;
 
 use crate::Result;
 
-
 /// Defines the callback interface for a signer
 pub trait SignerCallback: Send + Sync {
-    /// Read a stream of bytes from the stream
+    /// Sign the given bytes and return the signature
     fn sign(&self, bytes: Vec<u8>) -> Result<Vec<u8>>;
 }
 
-/// Configuration for a Signer
-#[repr(C)]
-pub struct SignerConfig {
-    /// Returns the algorithm of the Signer.
-    pub alg: c2pa::SigningAlg,
-
-    /// Returns the certificates as a Vec containing a Vec of DER bytes for each certificate.
-    pub certs: Vec<u8>,
-
-    /// URL for time authority to time stamp the signature
-    pub time_authority_url: Option<String>,
-
-    /// Try to fetch OCSP response for the signing cert if available
-    pub use_ocsp: bool,
-}
-
-/// Callback signer that uses a callback to sign data
+/// This is a wrapper around the CallbackSigner for Python
+///
+/// Uniffi callbacks are only supported as a method in a structure, so this is a workaround
 pub struct CallbackSigner {
-    callback: Box<dyn SignerCallback>,
-    alg: SigningAlg,
-    sign_certs: Vec<u8>,
-    ta_url: Option<String>,
+    signer: c2pa::CallbackSigner,
 }
 
 impl CallbackSigner {
     pub fn new(
         callback: Box<dyn SignerCallback>,
-        config: SignerConfig,
-        // alg: SigningAlg,
-        // sign_certs: Vec<u8>,
-        // ta_url: Option<String>,
+        alg: SigningAlg,
+        certs: Vec<u8>,
+        ta_url: Option<String>,
     ) -> Self {
-        Self {
-            callback,
-            alg: config.alg,
-            sign_certs: config.certs,
-            ta_url: config.time_authority_url,
+        
+        // When this closure is called it will call the sign method on the python callback
+        let python_signer = move |_context: *const (), data: &[u8]| {
+            callback
+                .sign(data.to_vec())
+                .map_err(|e| c2pa::Error::BadParam(e.to_string()))
+        };
+
+        let mut signer = c2pa::CallbackSigner::new(python_signer, alg, certs);
+        if let Some(url) = ta_url {
+            signer = signer.set_tsa_url(url);
         }
-    }
-}
-
-impl Signer for CallbackSigner {
-    fn sign(&self, data: &[u8]) -> c2pa::Result<Vec<u8>> {
-        self.callback
-            .sign(data.to_vec())
-            .map_err(|e| c2pa::Error::BadParam(e.to_string()))
-    }
-
-    fn alg(&self) -> SigningAlg {
-        self.alg
-    }
-
-    fn certs(&self) -> c2pa::Result<Vec<Vec<u8>>> {
-        let mut pems =
-            pem::parse_many(&self.sign_certs).map_err(|e| c2pa::Error::OtherError(Box::new(e)))?;
-        Ok(pems.drain(..).map(|p| p.into_contents()).collect())
-    }
-
-    fn reserve_size(&self) -> usize {
-        20000
+        Self { signer }
     }
 
-    fn time_authority_url(&self) -> Option<String> {
-        self.ta_url.clone()
+    /// The python Builder wrapper sign function calls this
+    pub fn signer(&self) -> &c2pa::CallbackSigner {
+        &self.signer
     }
 }

src/error.rs

@@ -9,7 +9,7 @@ pub enum Error {
     #[error("AssertionNotFound {reason}")]
     AssertionNotFound { reason: String },
     #[error("Decoding {reason}")]
-    Decoding{ reason: String },
+    Decoding { reason: String },
     #[error("Encoding {reason}")]
     Encoding { reason: String },
     #[error("FileNotFound{reason}")]
@@ -45,10 +45,12 @@ impl Error {
         use c2pa::Error::*;
         let err_str = err.to_string();
         match err {
-            c2pa::Error::AssertionMissing { url } => Self::AssertionNotFound{ reason: "".to_string()},
+            c2pa::Error::AssertionMissing { url } => Self::AssertionNotFound {
+                reason: "".to_string(),
+            },
             AssertionInvalidRedaction
             | AssertionRedactionNotFound
-            | AssertionUnsupportedVersion => Self::Assertion{ reason: err_str},
+            | AssertionUnsupportedVersion => Self::Assertion { reason: err_str },
             ClaimAlreadySigned
             | ClaimUnsigned
             | ClaimMissingSignatureBox
@@ -59,11 +61,11 @@ impl Error {
             | ClaimSelfRedact
             | ClaimDisallowedRedaction
             | UpdateManifestInvalid
-            | TooManyManifestStores => Self::Manifest{ reason: err_str},
-            ClaimMissing { label } => Self::ManifestNotFound{ reason: err_str},
-            AssertionDecoding(_) | ClaimDecoding => Self::Decoding{ reason: err_str},
-            AssertionEncoding | XmlWriteError | ClaimEncoding => Self::Encoding{ reason: err_str},
-            InvalidCoseSignature { coset_error } => Self::Signature{ reason: err_str},
+            | TooManyManifestStores => Self::Manifest { reason: err_str },
+            ClaimMissing { label } => Self::ManifestNotFound { reason: err_str },
+            AssertionDecoding(_) | ClaimDecoding => Self::Decoding { reason: err_str },
+            AssertionEncoding | XmlWriteError | ClaimEncoding => Self::Encoding { reason: err_str },
+            InvalidCoseSignature { coset_error } => Self::Signature { reason: err_str },
             CoseSignatureAlgorithmNotSupported
             | CoseMissingKey
             | CoseX5ChainMissing
@@ -78,19 +80,25 @@ impl Error {
             | CoseTimeStampGeneration
             | CoseTimeStampAuthority
             | CoseSigboxTooSmall
-            | InvalidEcdsaSignature => Self::Signature{ reason: err_str},
-            RemoteManifestFetch(_) | RemoteManifestUrl(_) => Self::RemoteManifest{ reason: err_str},
-            JumbfNotFound => Self::ManifestNotFound{ reason: err_str},
-            BadParam(_) | MissingFeature(_) => Self::Other{ reason: err_str},
-            IoError(_) => Self::Io{ reason: err_str},
-            JsonError(e) => Self::Json{ reason: err_str},
-            NotFound | ResourceNotFound(_) | MissingDataBox => Self::ResourceNotFound{ reason: err_str},
-            FileNotFound(_) => Self::FileNotFound{ reason: err_str},
-            UnsupportedType => Self::NotSupported{ reason: err_str},
-            ClaimVerification(_) | InvalidClaim(_) | JumbfParseError(_) => Self::Verify{ reason: err_str},
+            | InvalidEcdsaSignature => Self::Signature { reason: err_str },
+            RemoteManifestFetch(_) | RemoteManifestUrl(_) => {
+                Self::RemoteManifest { reason: err_str }
+            }
+            JumbfNotFound => Self::ManifestNotFound { reason: err_str },
+            BadParam(_) | MissingFeature(_) => Self::Other { reason: err_str },
+            IoError(_) => Self::Io { reason: err_str },
+            JsonError(e) => Self::Json { reason: err_str },
+            NotFound | ResourceNotFound(_) | MissingDataBox => {
+                Self::ResourceNotFound { reason: err_str }
+            }
+            FileNotFound(_) => Self::FileNotFound { reason: err_str },
+            UnsupportedType => Self::NotSupported { reason: err_str },
+            ClaimVerification(_) | InvalidClaim(_) | JumbfParseError(_) => {
+                Self::Verify { reason: err_str }
+            }
             #[cfg(feature = "add_thumbnails")]
             ImageError => Self::ImageError(err_str),
-            _ => Self::Other{ reason: err_str},
+            _ => Self::Other { reason: err_str },
         }
     }
 }
@@ -111,7 +119,8 @@ impl From<c2pa::Error> for Error {
 
 impl From<std::io::Error> for Error {
     fn from(err: std::io::Error) -> Self {
-        Self::Io { reason: err.to_string()}
+        Self::Io {
+            reason: err.to_string(),
+        }
     }
 }
-