Frida-android-native/src/main.rs

#![cfg(target_os = "android")]

/*use jni::{
    objects::{JClass, JString},
    sys::{jboolean, jchar, jint, jstring},
    JNIEnv,
};
use std::{error::Error, fs, net::Ipv4Addr, str};
use clap::{App, Arg, ArgMatches};
use env_logger::Builder;
use log::{error, LevelFilter};
use crate::config::{ ServerConfiguration, ClientConfiguration, ObfsProtocol, ServerPeer };
use fast32::base32::RFC4648;
use crossbeam_channel::unbounded;*/

use ::jni::objects::GlobalRef;
use ::jni::JavaVM;
use robusta_jni::bridge;
use std::sync::OnceLock;
use robusta_jni::jni::JNIEnv;
use std::fs::File;
use std::io::Write;

mod config;
mod client;
mod udp;
mod mobile;

static TUN_QUIT: std::sync::Mutex<Option<tokio_util::sync::CancellationToken>> = std::sync::Mutex::new(None);
static LOG_FILE: std::sync::Mutex<Option<File>> = std::sync::Mutex::new(None);

pub fn log2java(text: String) {
    if let Ok(mut l) = LOG_FILE.lock() {
        if let Some(mut ff) = l.take() {
            ff.write_all(text.as_bytes());
            ff.write_all(b"\n");
            ff.flush();
            //jni::FridaLib::traceFromNative(l.unwrap(), text);
        }
    }
}

#[bridge]
mod jni {
    use android_logger::Config;
    use jni::objects::{GlobalRef, JObject, JValue, JString};
    use jni::sys::{jboolean, jchar, jint, jstring};
    use log::{info, trace};
    use robusta_jni::convert::{IntoJavaValue, Signature, TryFromJavaValue, TryIntoJavaValue};
    use robusta_jni::jni::errors::Result as JniResult;
    use robusta_jni::jni::objects::AutoLocal;
    use robusta_jni::jni::JNIEnv;
    use crate::mobile;
    use crate::{TUN_QUIT, LOG_FILE};
    use std::fs::File;

    #[derive(Signature, TryIntoJavaValue, IntoJavaValue, TryFromJavaValue)]
    #[package(com.alterdekim.frida)]
    pub struct FridaLib<'env: 'borrow, 'borrow> {
        #[instance]
        raw: AutoLocal<'env, 'borrow>,
    }

    impl<'env: 'borrow, 'borrow> FridaLib<'env, 'borrow> {
        pub extern "jni" fn start(self, env: &JNIEnv, config_b32: String,
            tun_fd: i32,
            close_fd_on_drop: bool,
            temp_file: String) -> JniResult<i32> {
            
            let close_token = tokio_util::sync::CancellationToken::new();
            if let Ok(mut l) = TUN_QUIT.lock() {
                if l.is_some() {
                    return Ok(-1);
                }
                *l = Some(close_token.clone());
            } else {
                return Ok(-2);
            }

            if let Ok(mut l) = LOG_FILE.lock() {
                if !l.is_some() {
                    *l = Some(File::options()
                    .read(false)
                    .write(true)
                    .open(&temp_file).unwrap());
                }
                
            }

            let main_loop = async move {
                /*if let Err(err) =  {
                    FridaLib::traceFromNative(env, format!("main loop error: {}", err));
                    return Err(err);
                }*/
                mobile::mobile_run(config_b32, close_fd_on_drop, tun_fd, /*env,*/ close_token).await;
            };
        
            let exit_code = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
                Err(_e) => -3,
                Ok(rt) => { rt.spawn(main_loop); -4 } //block_on
            };
        
            Ok(exit_code)
            
            //FridaLib::traceFromNative(env, "Hello world".to_string());

            //Ok(mobile::mobile_run(config_b32, close_fd_on_drop, tun_fd, env))
        }

        pub extern "jni" fn stop(self, env: &JNIEnv) -> JniResult<i32> {
            if let Ok(mut l) = TUN_QUIT.lock() {
                if let Some(close_token) = l.take() {
                    close_token.cancel();
                    return Ok(0);
                }
            }
            Ok(-1)
        }

        pub extern "java" fn traceFromNative(
            env: &JNIEnv,
            text: String,
        ) -> JniResult<()> {

        }
    }
}