聊天室 https://gitter.im/panologic/community

项目1 https://github.com/tomverbeure/panologic

文件加密自释放程序，支持三端释放，仅支持Mac Windows 生成加密文件。

Code

#![feature(num_as_ne_bytes)]
#![feature(array_methods)]
#![feature(iter_advance_by)]

use std::{fs, thread, env};
use std::io::{Write, BufReader, Read, BufRead};
use std::path::{Path, PathBuf};
use std::fs::File;
use std::ptr::null;
use std::ops::Index;
use std::str::from_utf8;
use uuid::Uuid;

use std::convert::TryFrom;

fn write_bin<P: AsRef<Path>>(vb: Vec<u8>, filename: P) -> std::io::Result<()> {
    let mut f = fs::File::create(filename)?;
    f.write(&vb)?;
    f.sync_all()?;
    Ok(())
}

use std::ptr;
use std::borrow::Borrow;

unsafe fn prepend_slice<T: Copy>(vec: &mut Vec<T>, slice: &[T]) {
    let len = vec.len();
    let amt = slice.len();
    vec.reserve(amt);

    ptr::copy(vec.as_ptr(),
              vec.as_mut_ptr().offset((amt) as isize),
              len);

    ptr::copy(slice.as_ptr(),
              vec.as_mut_ptr(),
              amt);

    vec.set_len(len + amt);
}

fn to_key(slice: &[u8]) -> [u8; 8] {
    let mut vec: Vec<u8> = slice.iter().cloned().collect();
    let mut key = [0; 8];
    let diff = key.len() - vec.len();
    if diff > 0 {
        vec.append(&mut vec![0; diff]);
    }
    key.clone_from_slice(&vec);
    key
}

//F:/t/t/t/
//F:\\t\\t\\t\\

pub fn convert_path(path_str: &str) -> String {
    if cfg!(target_os = "windows") {
        String::from(path_str.replace("\\", "/"))
    } else {
        String::from(path_str)
    }
}


pub fn convert_spell() -> &'static str {
    return if cfg!(target_os = "windows") {
        "\\"
    } else {
        "/"
    };
}

pub fn _is_win_os_() -> bool {
    return convert_spell() == "\\";
}


pub fn generate_the_string(n: i32) -> String {
    let mut ans = String::new();
    if n % 2 == 0 {
        for num in (0..n - 1).rev() {
            ans.push_str("a");
        }
        ans.push_str("b");
    } else {
        for num in (0..n).rev() {
            ans.push_str("a");
        }
    }
    return ans;
}


pub fn cover_usize_to_u8s(u: usize, ad: usize) -> [u8; 10] {
    // 99 99 99 99 99 99 // 6
    let mut str_one = u.to_string();
    // let mut data = Vec::<u8>::new();
    let mut data: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
    // println!("file size start  = {:}", str_one);
    let mut str2 = String::from("");
    let mut index = 0;
    let mut insert_index = 0;

    for (i, c) in str_one.chars().enumerate() {
        index = i + 1;
        if index % ad == 0 {
            str2.push(c);
            // // println!("{:}", str2);

            unsafe {
                let mut i: i8 = str2.parse().unwrap_or(0);
                std::mem::replace(&mut data[insert_index], i as u8);
            }
            insert_index = insert_index + 1;
            str2 = String::from("");
        } else {
            str2.push(c);
            if index == str_one.len() {
                unsafe {
                    let mut i: i8 = str2.parse().unwrap_or(0);
                    std::mem::replace(&mut data[insert_index], i as u8);
                }
                insert_index = insert_index + 1;
                // // println!("{:}", str2);
            }
        }
    }

    // println!("file key = {:?}", data);
    <[u8; 10]>::try_from(data).unwrap()
}


fn get_platform(types: i8) -> &'static str {
    match types {
        1 => "task_unix",
        2 => "task.exe",
        3 => "task_linux",
        _ => ""
    }
}


fn main() {
    let args: Vec<String> = env::args().collect();
    let base = &args[0];
    if args.len() > 1 {
        let types = &args[1];
        let key = &args[2];
        let filename = &args[3];
        let savepath = &args[4];
        let to_platform: i8 = (&args[5]).parse().unwrap();
        let platform = get_platform(to_platform);
        // println!("platform ! {:?}", platform);
        // println!("encryption start !");
        let mut result = fs::read(filename).unwrap();
        // println!("需要加密的文件长度 = {:?}", result.len());
        let mut default_key = key.as_bytes();
        let mut path_str = "";
        let mut hidd_path_str = "";
        let mut path = "";
        // 找到文件名
        if filename.find(convert_spell()).is_some() {
            let sp_lit = filename.split(convert_spell()).collect::<Vec<&str>>();
            hidd_path_str = sp_lit.get(sp_lit.len() - 1).unwrap();
        } else {
            hidd_path_str = filename
        }

        extern crate des;
        let mut data = Vec::<u8>::new();
        if types == "e" {
            // 隐藏文件名
            let merge_data = hidd_path_str.as_bytes();
            // 合并 两个数据
            unsafe { prepend_slice(&mut result, &merge_data) }
            result.insert(0, merge_data.len() as u8);
            data = des::encrypt(&result, &to_key(&default_key));

            // println!("加密数据长度{:}", data.len());
            let mut path = "";
            let mut t1 = String::from(Uuid::new_v4().to_string());
            if to_platform == 2 {
                t1.push_str(".exe");
            }
            path = t1.as_str();

            let mut base_clone = base.clone();
            // platform
            if _is_win_os_() && to_platform == 1 {
                //是windows 目标是 macos
                base_clone = str::replace(&base_clone, "task.exe", "task_unix");
            }

            if _is_win_os_() && to_platform == 2 {
                // 是 windows 目标 是 windows
                base_clone = str::replace(&base_clone, "task.exe", "task.exe");
            }

            if _is_win_os_() && to_platform == 3 {
                base_clone = str::replace(&base_clone, "task.exe", "task_linux");
            }

            if !_is_win_os_() && to_platform == 3 {
                // 不是 windows 是 macos 目标 是linux
                base_clone = str::replace(&base_clone, "task_unix", "task_linux");
            }

            if !_is_win_os_() && to_platform == 2 {
                //不是windows 是 macos 目标是 windows
                base_clone = str::replace(&base_clone, "task_unix", "task.exe");
            }

            if !_is_win_os_() && to_platform == 1 {
                //不是windows 是 macos 目标是 macos
                base_clone = str::replace(&base_clone, "task_unix", "task_unix");
            }


            let mut base_file = fs::read(base_clone).unwrap();
            let de_code_index = base_file.len();
            // 将内容写进去 二进制文件 尾巴
            base_file.write(data.as_slice());
            let mut insert_index = base_file.len();

            // println!("文件起始长度{:}", insert_index);

            // 在合并文件后最后一位存储加密文件的开始坐标
            for (i, idx) in cover_usize_to_u8s(de_code_index, 2).iter().enumerate() {
                base_file.insert(insert_index + i, *idx);
            }
            // 保存文件
            // println!("文件最终长度{:}", base_file.len());
            println!("encrypt out file {:}", path.clone());
            write_bin(base_file, convert_path(savepath) + convert_spell() + path);
        }
    } else {
        use std::io;
        use std::io::prelude::*;
        println!("{}", "Please enter password");
        let mut input = String::new();
        let stdin = io::stdin();
        stdin.lock().read_line(&mut input).unwrap();
        let mut pass = input.clone();
        let mut imput_clone = input.clone();

        // println!("{:?}", imput_clone);

        let len_withoutcrlf = imput_clone.trim_right().len();
        imput_clone.truncate(len_withoutcrlf);

        pass = imput_clone;

        // println!("{:?}", pass);

        let mut result_tmp = fs::read(base).unwrap();
        let mut index_file = String::from("");
        let mut index = 11;
        for (idx, i) in (1..index).rev().enumerate() {
            let tmp_data_len = result_tmp.get(result_tmp.len() - i).unwrap();// 获取文件名长度从1开始找
            if tmp_data_len.to_string() != "0" {
                index_file.push_str(tmp_data_len.to_string().as_str());
            }
        }
        let mut start: i64 = index_file.parse().unwrap_or(0);
        let mut result = &result_tmp[start as usize..result_tmp.len() - 10 as usize];
        // println!("result tmp_data_len {:}", result_tmp.len());
        // println!("file result len = {:?}", result.len());
        // println!("file start index = {:?}", start);
        // 从自身解决数据大小 并且解密
        let mut data = des::decrypt(&result.to_vec(), &to_key(pass.as_bytes()));
        // let mut data = des::decrypt(&result.to_vec(), &to_key("123".as_bytes()));
        // println!("decrypt file ");
        let tmp_data_len = data.get(0).unwrap();// 获取文件名长度从1开始找
        let start_usize = *tmp_data_len as usize + 1;
        //  找到文件名字
        let mut path_u8_tmp = &data[1..start_usize];
        println!("File Name = {:}", String::from_utf8(path_u8_tmp.to_vec()).unwrap());
        // 找到剩下的数据
        let temp_write = &data.clone()[start_usize..data.len()];
        // 找到文件名
        let path_str = from_utf8(path_u8_tmp).unwrap();
        println!("out file  {:}", path_str);
        //
        // // println!("tmp_data_len {:?}", temp_write);
        write_bin(temp_write.to_vec(), path_str);

        return;
    }
}

公钥认证的基本思想：

对信息的加密和解密采用不同的key，这对key分别称作private key和public key，其中，public key存放在欲登录的服务器上，而private key为特定的客户机所持有。当客户机向服务器发出建立安全连接的请求时，首先发送自己的public key，如果这个public key是被服务器所允许的，服务器就发送一个经过public key加密的随机数据给客户机，这个数据只能通过private key解密，客户机将解密后的信息发还给服务器，服务器验证正确后即确认客户机是可信任的，从而建立起一条安全的信息通道。通过这种方式，客户机不需要向外发送自己的身份标志“private key”即可达到校验的目的，并且private key是不能通过public key反向推断出来的。这避免了网络窃听可能造成的密码泄露。客户机需要小心的保存自己的private key，以免被其他人窃取，一旦这样的事情发生，就需要各服务器更换受信的public key列表。

服务器使用情况

###阿里云ping

[root@iz2ze11y5fbhepqaub5q5xz ~]# ping firsh.me
PING firsh.me (27.102.129.115) 56(84) bytes of data.
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=1 ttl=46 time=33.8 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=2 ttl=46 time=33.0 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=3 ttl=46 time=33.1 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=4 ttl=46 time=32.9 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=5 ttl=46 time=33.0 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=6 ttl=46 time=33.0 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=7 ttl=46 time=33.3 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=8 ttl=46 time=32.9 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=9 ttl=46 time=33.2 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=10 ttl=46 time=33.1 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=11 ttl=46 time=33.0 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=12 ttl=46 time=32.8 ms
64 bytes from 27.102.129.115 (27.102.129.115): icmp_seq=13 ttl=46 time=32.9 ms

这应该是可以买到的 比较平民价的VPS最好的响应速度了。

购买地址 https://www.kdatacenter.com/

Trojan-Go

使用 Go 实现的完整 Trojan 代理，兼容原版 Trojan 协议及配置文件格式。安全、高效、轻巧、易用。

Trojan-Go 支持多路复用提升并发性能；使用路由模块实现国内外分流；支持 CDN 流量中转(基于 WebSocket over TLS)；支持使用 AEAD 对 Trojan 流量进行二次加密(基于 Shadowsocks AEAD)；支持可插拔的传输层插件，允许替换 TLS，使用其他加密隧道传输 Trojan 协议流量。

预编译二进制可执行文件可在 Release 页面下载。解压后即可直接运行，无其他组件依赖。

如遇到配置和使用问题、发现 bug，或是有更好的想法，欢迎加入 Telegram 交流反馈群。

简介

完整介绍和配置教程，参见 Trojan-Go 文档。

Trojan-Go 兼容原版 Trojan 的绝大多数功能，包括但不限于：

• TLS 隧道传输
• UDP 代理
• 透明代理 (NAT 模式，iptables 设置参考这里)
• 对抗 GFW 被动检测 / 主动检测的机制
• MySQL 数据持久化方案
• MySQL 用户权限认证
• 用户流量统计和配额限制

同时，Trojan-Go 还扩展实现了更多高效易用的功能特性：

• 便于快速部署的「简易模式」
• Socks5 / HTTP 代理自动适配
• 基于 TProxy 的透明代理（TCP / UDP）
• 全平台支持，无特殊依赖
• 基于多路复用（smux）降低延迟，提升并发性能
• 自定义路由模块，可实现国内外分流 / 广告屏蔽等功能
• Websocket 传输支持，以实现 CDN 流量中转（基于 WebSocket over TLS）和对抗 GFW 中间人攻击
• TLS 指纹伪造，以对抗 GFW 针对 TLS Client Hello 的特征识别
• 基于 gRPC 的 API 支持，以实现用户管理和速度限制等
• 可插拔传输层，可将 TLS 替换为其他协议或明文传输，同时有完整的 Shadowsocks 混淆插件支持
• 支持对用户更友好的 YAML 配置文件格式

图形界面客户端

Trojan-Go 服务端兼容所有原 Trojan 客户端，如 Igniter、ShadowRocket 等。以下是支持 Trojan-Go 扩展特性（Websocket / Mux 等）的客户端：

• Qv2ray：跨平台客户端，支持 Windows / macOS / Linux，使用 Trojan-Go 核心，支持所有 Trojan-Go 扩展特性。
• Igniter-Go：Android 客户端，Fork 自 Igniter，将 Igniter 核心替换为 Trojan-Go 并做了一定修改，支持所有 Trojan-Go 扩展特性。

使用方法

1. 快速启动服务端和客户端（简易模式）

   • 服务端

     sudo ./trojan-go -server -remote 127.0.0.1:80 -local 0.0.0.0:443 -key ./your_key.key -cert ./your_cert.crt -password your_password

   • 客户端

     ./trojan-go -client -remote example.com:443 -local 127.0.0.1:1080 -password your_password

2. 使用配置文件启动客户端 / 服务端 / 透明代理 / 中继（一般模式）

   ./trojan-go -config config.json

3. 使用 URL 启动客户端（格式参见文档）

   ./trojan-go -url 'trojan-go://password@cloudflare.com/?type=ws&path=%2Fpath&host=your-site.com'

4. 使用 Docker 部署

   docker run \
       --name trojan-go \
       -d \
       -v /etc/trojan-go/:/etc/trojan-go \
       --network host \
       p4gefau1t/trojan-go

   或者

   docker run \
       --name trojan-go \
       -d \
       -v /path/to/host/config:/path/in/container \
       --network host \
       p4gefau1t/trojan-go \
       /path/in/container/config.json

特性

一般情况下，Trojan-Go 和 Trojan 是互相兼容的，但一旦使用下面介绍的扩展特性（如多路复用、Websocket 等），则无法兼容。

移植性

编译得到的 Trojan-Go 单个可执行文件不依赖其他组件。同时，你可以很方便地编译（或交叉编译） Trojan-Go，然后在你的服务器、PC、树莓派，甚至路由器上部署；可以方便地使用 build tag 删减模块，以缩小可执行文件体积。

例如，交叉编译一个可在 mips 处理器、Linux 操作系统上运行的、只有客户端功能的 Trojan-Go，只需执行下面的命令，得到的可执行文件可以直接在目标平台运行：

CGO_ENABLED=0 GOOS=linux GOARCH=mips go build -tags "client" -trimpath -ldflags "-s -w -buildid="

完整的 tag 说明参见 Trojan-Go 文档。

易用

配置文件格式与原版 Trojan 兼容，但做了大幅简化，未指定的字段会被赋予默认值，由此可以更方便地部署服务端和客户端。以下是一个简单例子，完整的配置文件可以参见这里。

服务端配置文件 server.json：

{
  "run_type": "server",
  "local_addr": "0.0.0.0",
  "local_port": 443,
  "remote_addr": "127.0.0.1",
  "remote_port": 80,
  "password": ["your_awesome_password"],
  "ssl": {
    "cert": "your_cert.crt",
    "key": "your_key.key",
    "sni": "www.your-awesome-domain-name.com"
  }
}

客户端配置文件 client.json：

{
  "run_type": "client",
  "local_addr": "127.0.0.1",
  "local_port": 1080,
  "remote_addr": "www.your-awesome-domain-name.com",
  "remote_port": 443,
  "password": ["your_awesome_password"]
}

可以使用更简明易读的 YAML 语法进行配置。以下是一个客户端的例子，与上面的 client.json 等价：

客户端配置文件 client.yaml：

run-type: client
local-addr: 127.0.0.1
local-port: 1080
remote-addr: www.your-awesome-domain_name.com
remote-port: 443
password:
  - your_awesome_password

WebSocket

Trojan-Go 支持使用 TLS + Websocket 承载 Trojan 协议，使得利用 CDN 进行流量中转成为可能。

服务端和客户端配置文件中同时添加 websocket 选项即可启用 Websocket 支持，例如

"websocket": {
    "enabled": true,
    "path": "/your-websocket-path",
    "hostname": "www.your-awesome-domain-name.com"
}

完整的选项说明参见 Trojan-Go 文档。

可以省略 hostname, 但服务端和客户端的 path 必须一致。服务端开启 Websocket 支持后，可以同时支持 Websocket 和一般 Trojan 流量。未配置 Websocket 选项的客户端依然可以正常使用。

由于 Trojan 并不支持 Websocket，因此，虽然开启了 Websocket 支持的 Trojan-Go 服务端可以兼容所有客户端，但如果要使用 Websocket 承载流量，请确保双方都使用 Trojan-Go。

多路复用

在很差的网络条件下，一次 TLS 握手可能会花费很多时间。Trojan-Go 支持多路复用（基于 smux），通过一条 TLS 隧道连接承载多条 TCP 连接的方式，减少 TCP 和 TLS 握手带来的延迟，以期提升高并发情景下的性能。

启用多路复用并不能提高测速得到的链路速度，但能降低延迟、提升大量并发请求时的网络体验，例如浏览含有大量图片的网页等。

你可以通过设置客户端的 mux 选项 enabled 字段启用它：

"mux": {
    "enabled": true
}

只需开启客户端 mux 配置即可，服务端会自动检测是否启用多路复用并提供支持。完整的选项说明参见 Trojan-Go 文档。

路由模块

Trojan-Go 客户端内建一个简单实用的路由模块，以方便实现国内直连、海外代理等自定义路由功能。

路由策略有三种：

• Proxy 代理：将请求通过 TLS 隧道进行代理，由 Trojan 服务端与目的地址进行连接。
• Bypass 绕过：直接使用本地设备与目的地址进行连接。
• Block 封锁：不发送请求，直接关闭连接。

要激活路由模块，请在配置文件中添加 router 选项，并设置 enabled 字段为 true：

"router": {
    "enabled": true,
    "bypass": [
        "geoip:cn",
        "geoip:private",
        "full:localhost"
    ],
    "block": [
        "cidr:192.168.1.1/24",
    ],
    "proxy": [
        "domain:google.com",
    ],
    "default_policy": "proxy"
}

完整的选项说明参见 Trojan-Go 文档。

AEAD 加密

Trojan-Go 支持基于 Shadowsocks AEAD 对 Trojan 协议流量进行二次加密，以保证 Websocket 传输流量无法被不可信的 CDN 识别和审查：

"shadowsocks": {
    "enabled": true,
    "password": "my-password"
}

如需开启，服务端和客户端必须同时开启并保证密码一致。

传输层插件

Trojan-Go 支持可插拔的传输层插件，并支持 Shadowsocks SIP003 标准的混淆插件。下面是使用 v2ray-plugin 的一个例子：

此配置并不安全，仅作为演示

服务端配置：

"transport_plugin": {
    "enabled": true,
    "type": "shadowsocks",
    "command": "./v2ray-plugin",
    "arg": ["-server", "-host", "www.baidu.com"]
}

客户端配置：

"transport_plugin": {
    "enabled": true,
    "type": "shadowsocks",
    "command": "./v2ray-plugin",
    "arg": ["-host", "www.baidu.com"]
}

完整的选项说明参见 Trojan-Go 文档。

构建

请确保 Go 版本 >= 1.14

使用 make 进行编译：

git clone https://github.com/p4gefau1t/trojan-go.git
cd trojan-go
make
make install #安装systemd服务等，可选

或者使用 Go 自行编译：

go build -tags "full"

Go 支持通过设置环境变量进行交叉编译，例如：

编译适用于 64 位 Windows 操作系统的可执行文件：

CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -tags "full"

编译适用于 Apple Silicon 的可执行文件：

CGO_ENABLED=0 GOOS=macos GOARCH=arm64 go build -tags "full"

编译适用于 64 位 Linux 操作系统的可执行文件：

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -tags "full"

致谢

• Trojan
• V2Fly
• utls
• smux
• go-tproxy

Stargazers over time