alterwain/Frida-android-native
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

modified: src/client.rs
Some checks failed
gitea/Frida-android-native/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
Michael Wain 2024-10-13 18:53:06 +03:00
parent 7ce832a0ee
commit 1f5315b79d
1 changed files with 16 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/client.rs
View File

@ -24,16 +24,13 @@ use network_interface::NetworkInterfaceConfig;
use robusta_jni::jni::JNIEnv;
use crate::jni::FridaLib;
pub async fn client_mode(client_config: ClientConfiguration, fd: i32, /*env: &JNIEnv<'_>,*/ close_token: CancellationToken) {
let (ltx, mut lrx) = mpsc::unbounded_channel::<Vec<u8>>();
info!("Starting client log..");
ltx.send("Starting client...".as_bytes().to_vec());
pub async fn client_mode(client_config: ClientConfiguration, fd: i32, close_token: CancellationToken) {
info!("Starting client...");
let sock = UdpSocket::bind("0.0.0.0:25565").await.unwrap();
sock.connect(&client_config.server.endpoint).await.unwrap();
ltx.send(format!("FD: {:?}", &fd).as_bytes().to_vec());
ltx.send("So exhausting".as_bytes().to_vec());
info!("FD: {:?}", &fd);
let mut dev = unsafe { File::from_raw_fd(fd) };
let mut dev1 = unsafe { File::from_raw_fd(fd) };
let mut dev_reader = BufReader::new(dev);
@ -47,12 +44,11 @@ pub async fn client_mode(client_config: ClientConfiguration, fd: i32, /*env: &JN
let cipher_shared: Arc<Mutex<Option<x25519_dalek::SharedSecret>>> = Arc::new(Mutex::new(None));
let llltx = ltx.clone();
let dev_read_task = tokio::spawn(async move {
let mut buf = vec![0; 1400]; // mtu
loop {
if let Ok(n) = dev_reader.read(&mut buf).await {
llltx.send(format!("Read from tun. {:?}", hex::encode(&buf[..n])).as_bytes().to_vec());
info!("Read from tun. {:?}", hex::encode(&buf[..n]));
dx.send(buf[..n].to_vec()).unwrap();
}
}
@ -61,13 +57,12 @@ pub async fn client_mode(client_config: ClientConfiguration, fd: i32, /*env: &JN
let priv_key = BASE64_STANDARD.decode(client_config.client.private_key).unwrap();
let cipher_shared_clone = cipher_shared.clone();
let sr_ltx = ltx.clone();
let sock_read_task = tokio::spawn(async move {
let mut buf = vec![0; 4096];
loop {
if let Ok(l) = sock_rec.recv(&mut buf).await {
sr_ltx.send("Read from socket".as_bytes().to_vec());
info!("Read from socket");
let mut s_cipher = cipher_shared_clone.lock().await;
match buf.first() {
Some(h) => {
@ -92,17 +87,17 @@ pub async fn client_mode(client_config: ClientConfiguration, fd: i32, /*env: &JN
let nonce = Nonce::clone_from_slice(&wrapped_packet.nonce);
match aes.decrypt(&nonce, &wrapped_packet.data[..]) {
Ok(decrypted) => { let _ = tx.send(decrypted); },
Err(error) => { sr_ltx.send(format!("Decryption error! {:?}", error).as_bytes().to_vec()); }
Err(error) => { error!("Decryption error! {:?}", error); }
}
} else {
sr_ltx.send("There is no static_secret".as_bytes().to_vec());
warn!("There is no static_secret");
}
}, // payload
2 => { sr_ltx.send("Got keepalive packet".as_bytes().to_vec()); },
_ => { sr_ltx.send("Unexpected header value.".as_bytes().to_vec()); }
2 => { info!("Got keepalive packet"); },
_ => { error!("Unexpected header value."); }
}
},
None => { sr_ltx.send("There is no header.".as_bytes().to_vec()); }
None => { error!("There is no header."); }
}
drop(s_cipher);
}
@ -128,12 +123,12 @@ pub async fn client_mode(client_config: ClientConfiguration, fd: i32, /*env: &JN
}
rr = rx.recv() => {
if let Some(bytes) = rr {
ltx.send("Write to tun.".as_bytes().to_vec());
info!("Write to tun.");
if let Err(e) = dev_writer.write_all(&bytes).await {
ltx.send(format!("Writing error: {:?}", e).as_bytes().to_vec());
error!("Writing error: {:?}", e);
}
if let Err(e) = dev_writer.flush().await {
ltx.send(format!("Flushing error: {:?}", e).as_bytes().to_vec());
error!("Flushing error: {:?}", e);
}
}
}
@ -155,13 +150,13 @@ pub async fn client_mode(client_config: ClientConfiguration, fd: i32, /*env: &JN
if let Ok(ciphered_d) = ciphered_data {
let vpn_packet = UDPVpnPacket{ data: ciphered_d, nonce: nonce.to_vec()};
let serialized_data = vpn_packet.serialize();
ltx.send("Write to socket".as_bytes().to_vec());
info!("Write to socket");
sock_snd.send(&serialized_data).await.unwrap();
} else {
ltx.send("Socket encryption failed.".as_bytes().to_vec());
error!("Socket encryption failed.");
}
} else {
ltx.send("There is no shared_secret in main loop".as_bytes().to_vec());
error!("There is no shared_secret in main loop");
}
}
}