ctf-pwn 0.3.8

Pwn utilities for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

# ctf-pwn

[![crate](https://img.shields.io/crates/v/ctf-pwn.svg)](https://crates.io/crates/ctf-pwn)

Pwn utilities for Rust.

## Features


### Pipe

* [x] Converting TCP Stream or Process to Pipe
* [x] Conditional reading
* [x] Bridging pipe to stdout/stdin
* [x] Payload crafter
* [x] Ansi event support for ncurses like shells

### Shell

* [ ] Intel x86
* [ ] Amd x64
* [ ] Arm
* [ ] Risc-V

### Binary Parsing

* [x] Elf
* [ ] PE

## Examples


### Connecting to tcp stream

```rs
let mut pipe = TcpPipe::connect("127.0.0.1:1337").await?;
```

### Spawning new process

```rs
let mut pipe = ProcessPipe::from_app("ls").await?;

let mut pipe = ProcessPipe::from_app_args("ls", ["-l", "-a"]).await?;
```

### Generic loading

```rs
let mut pipe = Pipe::new(stdin(), stdout());
```

### Reading examples

```rs
let data: Vec<u8> = pipe.recv().await?;
let data: Vec<u8> = pipe.recv_until("Name:", false).await?;
let data: Vec<u8> = pipe.recv_until([0x01, 0x02, 0x03], false).await?;
let data: String = pipe.recv_line_utf8().await?;
let data: AsciiString = pipe.recv_line_ascii().await?;
```

### Regex

```rs
let data = pipe.recv_until(r"(Ok)|(Error)", true).await?;
let flag = pipe.recv_regex_utf8(r"HTB\{[^\}]+\}").await?;
```

### Interactive shell

```rs
pipe.interactive_shell().await?;
```

### Ncurses support


#### Sending ansi commands

```rs
pipe.write_ansi_command(ansi::Down).await?;
pipe.write_ansi_command(ansi::Right).await?;
pipe.write_ansi_command(ansi::Enter).await?;
```

#### Ansi event based interactive shell

```rs
pipe.interactive_ansi().await?;
```


### Payload

```rs
let payload = Payload::builder()
    .recv_until("> ", false)
    .push("1")
    .push("\n")
    .send()
    .recv_until("Insert card's serial number: ", false)
    .push_line("%4919x%7$hn")
    .send()
    .recv_regex_utf8(r"HTB\{[^\}]+\}")
    .build();

let flag = pipe.payload(payload).await?;
println!("{flag}");
```

### Elf

```rust
let elf = Elf::parse("app_path").await?;
let got: &HashMap<String, u64> = elf.got();
let plt: &HashMap<String, u64> = elf.plt();
let symbols: &HashMap<String, Symbol> = elf.symbols();
let dynamic_symbols: &HashMap<String, Symbol> = elf.dynamic_symbols();
```