add baseline v2 api support

Author: gpeacock

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "rust-analyzer.linkedProjects": [
+        "./Cargo.toml"
+    ],
+    "rust-analyzer.showUnlinkedFileNotification": false
+}

Cargo.toml

@@ -10,8 +10,9 @@ name = "c2pa"
 crate-type = ["cdylib"]
 
 [dependencies]
-c2pa-c = { git = "https://github.com/contentauth/c2pa-c.git", branch = "main" }
-serde = { version = "1.0", features = ["derive"] }
+c2pa = {path="../c2pa-rs/sdk", features = ["file_io", "openssl_sign"]}
+pem = "3.0.3"
+serde = { version = "1.0.197", features = ["derive"] }
 serde_derive = "1.0"
 serde_json = "1.0"
 thiserror = "1.0.49"

src/c2pa.udl

@@ -11,23 +11,64 @@ namespace c2pa {
 };
 
 [Error]
-enum Error {
-  "Assertion",
-  "AssertionNotFound",
-  "Decoding",
-  "Encoding",
-  "FileNotFound",
-  "Io",
-  "Json",
-  "Manifest",
-  "ManifestNotFound",
-  "NotSupported",
-  "Other",
-  "NullParameter",
-  "RemoteManifest",
-  "ResourceNotFound",
-  "Signature",
-  "Verify"
+interface Error {
+  Assertion(string reason);
+  AssertionNotFound(string reason);
+  Decoding(string reason);
+  Encoding(string reason);
+  FileNotFound(string reason);
+  Io(string reason);
+  Json(string reason);
+  Manifest(string reason);
+  ManifestNotFound(string reason);
+  NotSupported(string reason);
+  FileNotFound(string reason);
+  Other(string reason);
+  RemoteManifest(string reason);
+  ResourceNotFound(string reason);
+  RwLock();
+  Signature(string reason);
+  Verify(string reason);
+};
+
+enum SigningAlg {
+  "Es256",
+  "Es384",
+  "Es512",
+  "Ps256",
+  "Ps384",
+  "Ps512",
+  "Ed25519"
+};
+
+enum SeekMode {
+  "Start",
+  "End",
+  "Current"
+};
+
+callback interface Stream {
+  [Throws=Error]
+  bytes read_stream(u64 length);
+
+  [Throws=Error]
+  u64 seek_stream(i64 pos, SeekMode mode);
+
+  [Throws=Error]
+  u64 write_stream(bytes data);
+};
+
+interface Reader {
+  constructor();
+
+  [Throws=Error]
+  string read([ByRef] string format, [ByRef] Stream reader);
+
+  [Throws=Error]
+  string json();
+
+  [Throws=Error]
+  u64 resource([ByRef] string uri, [ByRef] Stream stream);
 };
 
 dictionary SignerInfo {
@@ -37,3 +78,31 @@ dictionary SignerInfo {
   string? ta_url;
 };
 
+dictionary SignerConfig {
+  SigningAlg alg;
+  bytes certs;
+  string? time_authority_url = null;
+  boolean use_ocsp = false;
+};
+
+callback interface SignerCallback {
+  [Throws=Error]
+  bytes sign(bytes data);
+};
+
+interface CallbackSigner {
+  constructor(SignerCallback callback,  SignerConfig config);
+};
+
+interface Builder {
+  constructor();
+  
+  [Throws=Error]
+  void with_json([ByRef] string json);
+
+  [Throws=Error]
+  void add_resource([ByRef] string uri, [ByRef] Stream stream );
+
+  [Throws=Error]
+  bytes sign([ByRef] string format, [ByRef] Stream input, [ByRef] Stream output ,[ByRef] CallbackSigner signer);
+};

src/error.rs

@@ -0,0 +1,117 @@
+use thiserror::Error;
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Error, Debug)]
+/// Defines all possible errors that can occur in this library
+pub enum Error {
+    #[error("Assertion {reason}")]
+    Assertion { reason: String },
+    #[error("AssertionNotFound {reason}")]
+    AssertionNotFound { reason: String },
+    #[error("Decoding {reason}")]
+    Decoding{ reason: String },
+    #[error("Encoding {reason}")]
+    Encoding { reason: String },
+    #[error("FileNotFound{reason}")]
+    FileNotFound { reason: String },
+    #[error("Io {reason}")]
+    Io { reason: String },
+    #[error("Json {reason}")]
+    Json { reason: String },
+    #[error("Manifest {reason}")]
+    Manifest { reason: String },
+    #[error("ManifestNotFound {reason}")]
+    ManifestNotFound { reason: String },
+    #[error("NotSupported {reason}")]
+    NotSupported { reason: String },
+    #[error("Other {reason}")]
+    Other { reason: String },
+    #[error("Remote {reason}")]
+    RemoteManifest { reason: String },
+    #[error("ResourceNotFound {reason}")]
+    ResourceNotFound { reason: String },
+    #[error("RwLock")]
+    RwLock,
+    #[error("Signature {reason}")]
+    Signature { reason: String },
+    #[error("Verify{reason}")]
+    Verify { reason: String },
+}
+
+impl Error {
+    // Convert c2pa errors to published API errors
+    #[allow(unused_variables)]
+    pub(crate) fn from_c2pa_error(err: c2pa::Error) -> Self {
+        use c2pa::Error::*;
+        let err_str = err.to_string();
+        match err {
+            c2pa::Error::AssertionMissing { url } => Self::AssertionNotFound{ reason: "".to_string()},
+            AssertionInvalidRedaction
+            | AssertionRedactionNotFound
+            | AssertionUnsupportedVersion => Self::Assertion{ reason: err_str},
+            ClaimAlreadySigned
+            | ClaimUnsigned
+            | ClaimMissingSignatureBox
+            | ClaimMissingIdentity
+            | ClaimVersion
+            | ClaimInvalidContent
+            | ClaimMissingHardBinding
+            | 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},
+            CoseSignatureAlgorithmNotSupported
+            | CoseMissingKey
+            | CoseX5ChainMissing
+            | CoseInvalidCert
+            | CoseSignature
+            | CoseVerifier
+            | CoseCertExpiration
+            | CoseCertRevoked
+            | CoseInvalidTimeStamp
+            | CoseTimeStampValidity
+            | CoseTimeStampMismatch
+            | 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},
+            #[cfg(feature = "add_thumbnails")]
+            ImageError => Self::ImageError(err_str),
+            _ => Self::Other{ reason: err_str},
+        }
+    }
+}
+
+impl From<uniffi::UnexpectedUniFFICallbackError> for Error {
+    fn from(err: uniffi::UnexpectedUniFFICallbackError) -> Self {
+        Self::Other {
+            reason: err.reason.clone(),
+        }
+    }
+}
+
+impl From<c2pa::Error> for Error {
+    fn from(err: c2pa::Error) -> Self {
+        Self::from_c2pa_error(err)
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Self::Io { reason: err.to_string()}
+    }
+}
+

src/json_api.rs

@@ -0,0 +1,126 @@
+// Copyright 2023 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 c2pa::{Ingredient, Manifest, ManifestStore};
+
+use crate::{Error, Result, SignerInfo};
+
+/// Returns the version of the C2PA library
+pub fn sdk_version() -> String {
+    format!(
+        "{}/{} {}/{}",
+        env!("CARGO_PKG_NAME"),
+        env!("CARGO_PKG_VERSION"),
+        c2pa::NAME,
+        c2pa::VERSION
+    )
+}
+
+/// Returns ManifestStore JSON string from a file path.
+///
+/// If data_dir is provided, any thumbnail or c2pa data will be written to that folder.
+/// Any Validation errors will be reported in the validation_status field.
+///
+pub fn read_file(path: &str, data_dir: Option<String>) -> Result<String> {
+    Ok(match data_dir {
+        Some(dir) => ManifestStore::from_file_with_resources(path, &dir),
+        None => ManifestStore::from_file(path),
+    }
+    .map_err(Error::from_c2pa_error)?
+    .to_string())
+}
+
+/// Returns an Ingredient JSON string from a file path.
+///
+/// Any thumbnail or c2pa data will be written to data_dir if provided
+pub fn read_ingredient_file(path: &str, data_dir: &str) -> Result<String> {
+    Ok(Ingredient::from_file_with_folder(path, data_dir)
+        .map_err(Error::from_c2pa_error)?
+        .to_string())
+}
+
+/// Adds a manifest to the source file and writes the result to the destination file.
+/// Also returns the binary manifest data for optional cloud storage
+/// A manifest definition must be supplied
+/// Signer information must also be supplied
+///
+/// Any file paths in the manifest will be read relative to the source file
+pub fn sign_file(
+    source: &str,
+    dest: &str,
+    manifest_json: &str,
+    signer_info: &SignerInfo,
+    data_dir: Option<String>,
+) -> Result<Vec<u8>> {
+    let mut manifest = Manifest::from_json(manifest_json).map_err(Error::from_c2pa_error)?;
+
+    // if data_dir is provided, set the base path for the manifest
+    if let Some(path) = data_dir {
+        manifest
+            .with_base_path(path)
+            .map_err(Error::from_c2pa_error)?;
+    }
+
+    // If the source file has a manifest store, and no parent is specified, treat the source's manifest store as the parent.
+    if manifest.parent().is_none() {
+        let source_ingredient = Ingredient::from_file(source).map_err(Error::from_c2pa_error)?;
+        if source_ingredient.manifest_data().is_some() {
+            manifest
+                .set_parent(source_ingredient)
+                .map_err(Error::from_c2pa_error)?;
+        }
+    }
+
+    let signer = signer_info.signer()?;
+    manifest
+        .embed(&source, &dest, &*signer)
+        .map_err(Error::from_c2pa_error)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{fs::remove_dir_all, path::PathBuf};
+
+    /// returns a path to a file in the fixtures folder
+    pub fn test_path(path: &str) -> String {
+        let base = env!("CARGO_MANIFEST_DIR");
+        format!("{}/{}", base, path)
+    }
+
+    #[test]
+    fn test_verify_from_file_no_base() {
+        let path = test_path("tests/fixtures/C.jpg");
+        let result = read_file(&path, None);
+        assert!(result.is_ok());
+        let json_report = result.unwrap();
+        println!("{}", json_report);
+        assert!(json_report.contains("C.jpg"));
+        assert!(!json_report.contains("validation_status"));
+    }
+
+    #[test]
+    fn test_read_from_file_with_base() {
+        let path = test_path("tests/fixtures/C.jpg");
+        let data_dir = "target/data_dir";
+        if PathBuf::from(data_dir).exists() {
+            remove_dir_all(data_dir).unwrap();
+        }
+        let result = read_file(&path, Some(data_dir.to_owned()));
+        assert!(result.is_ok());
+        let json_report = result.unwrap();
+        println!("{}", json_report);
+        assert!(json_report.contains("C.jpg"));
+        assert!(PathBuf::from(data_dir).exists());
+        assert!(json_report.contains("thumbnail"));
+    }
+}