Added codesign checker for macos

Author: Choochmeque

Cargo.toml

@@ -11,7 +11,8 @@ license = "MIT"
 repository = "https://github.com/Choochmeque/tauri-plugin-iap"
 
 [features]
-unstable = ["dep:swift-bridge", "dep:serde_json"]
+default = ["unstable"]
+unstable = ["dep:swift-bridge", "dep:serde_json", "dep:objc2", "dep:objc2-core-foundation", "dep:objc2-security"]
 
 [dependencies]
 tauri = { version = "2.7.0" }
@@ -21,6 +22,9 @@ thiserror = "2"
 [target.'cfg(target_os = "macos")'.dependencies]
 swift-bridge = { version = "0.1", features = ["async"], optional = true}
 serde_json = { version = "1.0", optional = true }
+objc2 = { version = "0.6", optional = true }
+objc2-core-foundation = { version = "0.3", optional = true }
+objc2-security = { version = "0.3", optional = true }
 
 [build-dependencies]
 tauri-plugin = { version = "2.3.0", features = ["build"] }

src/macos.rs

@@ -3,6 +3,46 @@ use tauri::{plugin::PluginApi, AppHandle, Runtime};
 
 use crate::models::*;
 
+mod codesign {
+    use objc2_security::{kSecCSCheckAllArchitectures, kSecCSCheckNestedCode, kSecCSStrictValidate, SecCSFlags, SecCode};
+    use std::ptr::NonNull;
+
+    /// Returns `Ok(())` if the running binary is code-signed and valid, otherwise returns an Error.
+    pub fn is_signature_valid() -> crate::Result<()> {
+        unsafe {
+            // 1) Get a handle to "self"
+            let mut self_code: *mut SecCode = std::ptr::null_mut();
+            let self_code_ptr = NonNull::<*mut SecCode>::new_unchecked(&mut self_code);
+            let status = SecCode::copy_self(SecCSFlags::empty(), self_code_ptr);
+            if status != 0 {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    format!("Failed to get code reference: OSStatus {}", status),
+                )
+                .into());
+            }
+
+            // 2) Validate the dynamic code - this checks if the signature is valid
+            let validity_flags = SecCSFlags(kSecCSCheckAllArchitectures | kSecCSCheckNestedCode | kSecCSStrictValidate);
+            let self_code_ref = self_code_ptr.as_ref().as_ref().unwrap();
+            let status = SecCode::check_validity(
+                self_code_ref,
+                validity_flags,
+                None,
+            );
+            if status != 0 {
+                return Err(std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    format!("Code signature validation failed: OSStatus {}", status),
+                )
+                .into());
+            }
+
+            Ok(())
+        }
+    }
+}
+
 #[swift_bridge::bridge]
 mod ffi {
     pub enum FFIResult {
@@ -47,6 +87,8 @@ impl<R: Runtime> Iap<R> {
     }
 
     pub fn initialize(&self) -> crate::Result<InitializeResponse> {
+        codesign::is_signature_valid()?;
+
         Self::to_result(ffi::initialize())
     }
 
@@ -55,6 +97,8 @@ impl<R: Runtime> Iap<R> {
         product_ids: Vec<String>,
         product_type: String,
     ) -> crate::Result<GetProductsResponse> {
+        codesign::is_signature_valid()?;
+
         Self::to_result(ffi::getProducts(product_ids, product_type))
     }
 
@@ -64,20 +108,26 @@ impl<R: Runtime> Iap<R> {
         product_type: String,
         offer_token: Option<String>,
     ) -> crate::Result<Purchase> {
+        codesign::is_signature_valid()?;
+
         Self::to_result(ffi::purchase(product_id, product_type, offer_token))
     }
 
     pub fn restore_purchases(
         &self,
         product_type: String,
     ) -> crate::Result<RestorePurchasesResponse> {
+        codesign::is_signature_valid()?;
+
         Self::to_result(ffi::restorePurchases(product_type))
     }
 
     pub fn acknowledge_purchase(
         &self,
         purchase_token: String,
     ) -> crate::Result<AcknowledgePurchaseResponse> {
+        codesign::is_signature_valid()?;
+
         Self::to_result(ffi::acknowledgePurchase(purchase_token))
     }
 
@@ -86,6 +136,8 @@ impl<R: Runtime> Iap<R> {
         product_id: String,
         product_type: String,
     ) -> crate::Result<ProductStatus> {
+        codesign::is_signature_valid()?;
+
         Self::to_result(ffi::getProductStatus(product_id, product_type))
     }
 }