Self-implemented macOs tun adapter

modified:   frida_core/Cargo.toml
	modified:   frida_core/src/mac_tun.rs

frida_core/Cargo.toml

@@ -45,7 +45,7 @@ wintun = "0.5.0"
 embed-resource = "2.3"
 
 [target.'cfg(target_os="macos")'.dependencies]
-nix = "0.29.0"
+nix = { version = "0.29.0", features = ["socket"] }
 
 [target.'cfg(target_os="linux")'.dependencies]
 tokio-tun = "0.12.1"

frida_core/src/mac_tun.rs

@@ -1,7 +1,14 @@
-use std::process::Command;
+use std::os::fd::{AsRawFd, FromRawFd};
+use std::{ffi::CString, process::Command};
 use std::sync::Arc;
 use std::error::Error;
-use nix::sys::socket::socket;
+use log::info;
+use nix::errno::Errno;
+use nix::libc::{connect, sockaddr_ctl, CTLIOCGINFO};
+use nix::sys::socket::{SockaddrLike, SockaddrStorage, UnixAddr};
+use nix::{libc::{ctl_info, PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL}, sys::socket::{socket, AddressFamily, SockFlag, SockProtocol, SockType, sockaddr}};
+use tokio::fs::File;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use crate::device::AbstractDevice;
 
@@ -16,6 +23,51 @@ fn cmd(cmd: &str, args: &[&str]) {
 }
 
 pub fn create(cfg: AbstractDevice) -> (DeviceReader, DeviceWriter) {
+
+    let fd = socket(
+        AddressFamily::System, 
+            SockType::Datagram, 
+            SockFlag::empty(), 
+            Some(SockProtocol::KextControl)
+        );
+
+    if let Err(e) = fd {
+        panic!("Unable to open socket! Error: {:?}", e);
+    }
+
+    let fd = fd.unwrap();
+
+    let mut info: ctl_info = unsafe { std::mem::zeroed() };
+    let ctl_name = CString::new("com.apple.utun.control").unwrap();
+    ctl_name.as_bytes_with_nul()
+        .iter()
+        .enumerate()
+        .for_each(|(i, &c)| info.ctl_name[i] = c as i8);
+
+    if unsafe { nix::libc::ioctl(fd.as_raw_fd(), CTLIOCGINFO, &mut info) } < 0 {
+        let err = Errno::last();
+        panic!("ioctl CTLIOCGINFO failed: {}", err);
+    }
+
+    let mut sc = sockaddr_ctl {
+        sc_len: std::mem::size_of::<sockaddr_ctl>() as u8,
+        sc_family: nix::libc::AF_SYSTEM as u8,
+        ss_sysaddr: nix::libc::AF_SYS_CONTROL as u16,
+        sc_id: info.ctl_id,
+        sc_unit: 0,
+        sc_reserved: [0; 5]
+    };
+
+    let asc = &sc as *const sockaddr_ctl as *const sockaddr;
+    let f = unsafe { connect(fd.as_raw_fd(), asc, size_of::<sockaddr_ctl>() as u32 ) };
+
+    info!("utun interface created successfully {:?}", f);
+
+    let mut reader = unsafe { File::from_raw_fd(f) };
+    let mut writer = unsafe { File::from_raw_fd(f) };
+    
+    (DeviceReader {reader}, DeviceWriter {writer})
+
     /*let iface = Iface::new("utun10", Mode::Tun).unwrap();
 
     let mut address = cfg.address.unwrap().to_string();
@@ -34,21 +86,21 @@ pub fn create(cfg: AbstractDevice) -> (DeviceReader, DeviceWriter) {
 }
 
 pub struct DeviceWriter {
-    writer: Arc<Iface>
+    writer: File
 }
 
 pub struct DeviceReader {
-    reader: Arc<Iface>
+    reader: File
 }
 
 impl DeviceWriter {
-    pub async fn write(&self, buf: &Vec<u8>) -> Result<usize, Box<dyn Error>> {
-        Ok(self.writer.send(buf)?)
+    pub async fn write(&mut self, buf: &Vec<u8>) -> Result<usize, Box<dyn Error>> {
+        Ok(self.writer.write(buf).await?)
     }
 }
 
 impl DeviceReader {
-    pub async fn read(&self, buf: &mut Vec<u8>) -> Result<usize, Box<dyn Error>> {
-        Ok(self.reader.recv(buf)?)
+    pub async fn read(&mut self, buf: &mut Vec<u8>) -> Result<usize, Box<dyn Error>> {
+        Ok(self.reader.read_buf(buf).await?)
     }
 }