hardliner66/uaf - Change 2GEILJZTYWEJEMN4PWFQYLQXZZ44BVCJFM5XW35EUGS3GQZB3CPQC

first working prototype

Created by hardliner66 on February 19, 2024

2GEILJZTYWEJEMN4PWFQYLQXZZ44BVCJFM5XW35EUGS3GQZB3CPQC

Dependencies

In channels

main

Change contents

Insertion in src/main.rs at line 5 [3.49]
[3.150]
[3.150]
```
use std::time::Duration;
```
Replacement in src/main.rs at line 11 [3.49]
B:BD[3.269] → [2.0:50]
```
use tokio::process::{Child, ChildStdin, Command};
```
[3.269]
[3.345]
```
use tokio::process::Command;
```
Insertion in src/main.rs at line 13 [3.49]
[3.363]
[3.363]
```
use tokio::sync::mpsc::UnboundedSender;
```
Deletion in src/main.rs at line 21 [3.49]
B:BD[3.518] → [3.518:536]
B:BD[3.536] → [2.96:119]
∅:D[2.119] → [3.554:570]
B:BD[3.554] → [3.554:570]
B:BD[3.570] → [2.120:183]
∅:D[2.183] → [3.628:634]
B:BD[3.628] → [3.628:634]
```
}
struct Actor {
    stdin: ChildStdin,
}
impl Actor {
    fn new(stdin: ChildStdin) -> Self {
        Self { stdin }
    }
```

Replacement in src/main.rs at line 24 [3.49]

B:BD[3.665] → [3.665:773]

B:BD[3.773] → [2.184:287]

    static ref ACTORS: Arc<Mutex<HashMap<Uuid, Arc<Mutex<Actor>>>>> = Arc::new(Mutex::new(HashMap::new()));
    static ref SPAWN_REQUESTS: Arc<Mutex<Vec<(Uuid, SpawnActor)>>> = Arc::new(Mutex::new(Vec::new()));

[3.665]

[3.773]

    static ref ACTORS: Arc<Mutex<HashMap<Uuid, UnboundedSender<Message>>>> = Arc::new(Mutex::new(HashMap::new()));

Replacement in src/main.rs at line 27 [3.49]

B:BD[3.776] → [2.288:369]

∅:D[2.369] → [3.844:932]

B:BD[3.844] → [3.844:932]

async fn spawn_actor(executable: PathBuf, block: bool) -> anyhow::Result<Uuid> {
    if !executable.is_file() {
        bail!("{} is not a file", executable.display());

[3.776]

[3.932]

async fn spawn_actor(
    spawn_actor: SpawnActor,
    block: bool,
    tx: UnboundedSender<(Uuid, SpawnActor)>,
) -> anyhow::Result<Uuid> {
    if !spawn_actor.executable.is_file() {
        bail!("{} is not a file", spawn_actor.executable.display());

Replacement in src/main.rs at line 36 [3.49]

B:BD[3.939] → [3.939:1042]

    if !executable.executable() {
        bail!("{} is not an executable file", executable.display());

[3.939]

[3.1042]

    if !spawn_actor.executable.executable() {
        bail!(
            "{} is not an executable file",
            spawn_actor.executable.display()
        );

Replacement in src/main.rs at line 43 [3.49]

B:BD[3.1049] → [3.1049:1094]

    let mut child = Command::new(executable)

[3.1049]

[3.1094]

    let mut child = Command::new(spawn_actor.executable)
        .args(spawn_actor.args)

Replacement in src/main.rs at line 63 [3.49]

B:BD[2.723] → [2.723:953]

                        let mut other = other.lock().await;
                        let message = serde_json::to_string(&message).unwrap();
                        if let Err(e) = other.stdin.write_all(message.as_bytes()).await {

[2.723]

[2.953]

                        if let Err(e) = other.send(message) {

Replacement in src/main.rs at line 68 [3.49]

B:BD[2.1135] → [2.1135:1267]

                    let mut spawn_requests = SPAWN_REQUESTS.lock().await;
                    spawn_requests.push((uuid, message));

[2.1135]

[2.1267]

                    tx.send((uuid, message)).unwrap();

Replacement in src/main.rs at line 102 [3.49]

B:BD[2.2062] → [2.2062:2425]

        let init_message = Message {
            to: uuid,
            from: None,
            payload: serde_json::json!({
                "id": uuid,
            }),
        };
        let msg = serde_json::to_string(&init_message)?;
        stdin
            .write_all(msg.as_bytes())
            .await
            .expect("Failed to write to child stdin");

[2.2062]

[2.2425]

        spawn(async move {
            let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<Message>();
            spawn(async move {
                while let Some(message) = rx.recv().await {
                    let msg = serde_json::to_string(&message).unwrap();
                    stdin
                        .write_all(format!("{msg}\n").as_bytes())
                        .await
                        .expect("Failed to write to child stdin");
                    stdin.flush().await.expect("Failed to flush child stdin");
                }
            });
            let init_message = Message {
                to: uuid,
                from: None,
                payload: serde_json::json!({
                    "id": uuid,
                }),
            };
            tx.send(init_message)
                .expect("Failed to write to child stdin");

Replacement in src/main.rs at line 125 [3.49]

B:BD[2.2426] → [2.2426:2542]

        let mut actors = ACTORS.lock().await;
        actors.insert(uuid, Arc::new(Mutex::new(Actor::new(stdin))));

[2.2426]

[3.2619]

            let mut actors = ACTORS.lock().await;
            actors.insert(uuid, tx);
        });

Replacement in src/main.rs at line 141 [3.49]

B:BD[3.2852] → [2.2594:3470]

    spawn(async {
        let mut spawn_requests = SPAWN_REQUESTS.lock().await;
        loop {
            if let Some((uuid, request)) = spawn_requests.pop() {
                let new_uid = spawn_actor(request.executable, false).await.unwrap();
                let message = Message {
                    from: None,
                    to: uuid,
                    payload: serde_json::json!({
                        "type": "spawned",
                        "status": "ok",
                        "id": new_uid,
                    }),
                };
                let actors = ACTORS.lock().await;
                let mut actor = actors.get(&uuid).unwrap().lock().await;
                actor
                    .stdin
                    .write_all(serde_json::to_string(&message).unwrap().as_bytes())
                    .await
                    .unwrap();

[3.2852]

[2.3470]

    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<(Uuid, SpawnActor)>();
    {
        let tx = tx.clone();
        spawn(async move {
            loop {
                if let Some((uuid, request)) = rx.recv().await {
                    match spawn_actor(request, false, tx.clone()).await {
                        Ok(new_uid) => {
                            let message = Message {
                                from: None,
                                to: uuid,
                                payload: serde_json::json!({
                                    "type": "spawned",
                                    "status": "ok",
                                    "id": new_uid,
                                }),
                            };
                            let actors = ACTORS.lock().await;
                            let actor = actors.get(&uuid).unwrap();
                            actor.send(message).unwrap();
                        }
                        Err(e) => {
                            let message = Message {
                                from: None,
                                to: uuid,
                                payload: serde_json::json!({
                                    "type": "spawned",
                                    "status": "error",
                                    "error": format!("{e}"),
                                }),
                            };
                            let actors = ACTORS.lock().await;
                            let actor = actors.get(&uuid).unwrap();
                            actor.send(message).unwrap();
                        }
                    }
                }
                tokio::time::sleep(Duration::from_millis(500)).await;

Replacement in src/main.rs at line 181 [3.49]
B:BD[2.3484] → [2.3484:3502]
```
        }
    });
```
[2.3484]
[3.2892]
```
        });
    }
```

Replacement in src/main.rs at line 184 [3.49]

B:BD[3.2893] → [2.3503:3549]

    _ = spawn_actor(executable, true).await?;

[3.2893]

[2.3549]

    _ = spawn_actor(
        SpawnActor {
            executable,
            args: Vec::new(),
        },
        true,
        tx.clone(),
    )
    .await?;

Insertion in src/lib.rs at line 12 [3.2938]

[3.3167]


//'{"type": "message", "to": "73f31d83-a71e-4e32-a74a-263d3139f54d", "payload": {}}'

Insertion in src/lib.rs at line 19 [3.2938]
[2.3763]
[3.3279]
```
    #[serde(default)]
    pub args: Vec<String>,
```
Deletion in src/bin/test-actor.rs at line 1 [2.3861]
B:BD[2.3861] → [2.3862:3893]
```
use std::io::{self, BufRead};
```

Replacement in src/bin/test-actor.rs at line 2 [2.3861]

B:BD[2.3917] → [2.3917:3979]

use tokio::io::AsyncWriteExt;
use uaf::{LogMessage, Message};

[2.3917]

[2.3979]

use serde::Serialize;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use uaf::{LogMessage, Message, SpawnActor};

Replacement in src/bin/test-actor.rs at line 17 [2.3861]
B:BD[2.4266] → [2.4266:4303]
```
fn send_message(message: &Message) {
```
[2.4266]
[2.4303]
```
fn send_message<T: Serialize>(message: &T) {
```

Replacement in src/bin/test-actor.rs at line 24 [2.3861]

B:BD[2.4434] → [2.4434:4532]

    let stdin = io::stdin();
    let mut reader = stdin.lock();
    let mut line = String::new();

[2.4434]

[2.4532]

    let stdin = tokio::io::stdin();
    let stdin_reader = BufReader::new(stdin);
    let mut lines = stdin_reader.lines();

Replacement in src/bin/test-actor.rs at line 29 [2.3861]

B:BD[2.4556] → [2.4556:4608]

    while let Ok(_) = reader.read_line(&mut line) {

[2.4556]

[2.4608]

    while let Some(line) = lines.next_line().await.unwrap() {

Insertion in src/bin/test-actor.rs at line 34 [2.3861]

[2.4835]


        if count == 5 {
            send_message(&SpawnActor {
                executable: std::path::PathBuf::from("/usr/bin/cat"),
                args: vec!["-h".to_string()],
            });
        }

Insertion in src/bin/test-actor.rs at line 43 [2.3861]

[2.4836]

        if count == 8 {
            return;
        }

File addition: LOG.TXT (----------)

[4.1]

0{"type":"Message","from":null,"to":"35c87090-2182-4d5a-9a64-6cd105722066","payload":{"id":"35c87090-2182-4d5a-9a64-6cd105722066"}}
{"type":"Message","from":null,"to":"35c87090-2182-4d5a-9a64-6cd105722066","payload":{"id":"35c87090-2182-4d5a-9a64-6cd105722066"}}
{"type":"Message","from":"35c87090-2182-4d5a-9a64-6cd105722066","to":"35c87090-2182-4d5a-9a64-6cd105722066","payload":{"status":"ok","count":1}}