Baixa uma lista de dominios e testa no ooniprobe

ooniprobe_anatel.sh

#!/bin/bash

# URL base para download do ooniprobe
BASE_URL="https://github.com/ooni/probe-cli/releases/download"

# Nome do arquivo de domínios
ARQUIVO="dominios.txt"
ARQUIVO_TEMP="dominios_temp.txt"
ARQUIVO_DIFF="dominios_diff.txt"

# URL do arquivo do compilado dos (supostos) dominios bloqueados por ordem judicial
URL_ARQUIVO="https://gist.githubusercontent.com/3esmit/a2d1b83863c5b47afbc05f1797ebf245/raw/dominios.txt"

# Arquivo para armazenar o ETag localmente
ETAG_FILE=".etag"

# Nome do arquivo de configuração
CONFIG_FILE="$HOME/.ooniprobe/config.json"

# Diretório para o binário do ooniprobe
LOCAL_BIN="$HOME/.local/bin"

# Função para verificar diferenças no Gist
verificar_diff_gist() {
  echo "Baixando o arquivo do Gist..."
  curl -s -o "$ARQUIVO_TEMP" "$URL_ARQUIVO"
  if [ $? -ne 0 ]; then
    echo "Erro ao baixar o arquivo do Gist."
    exit 1
  fi

  echo "Gerando lista de diferenças entre o arquivo do Gist e o arquivo local..."
  
  # Garantir que ambos os arquivos existam e estejam ordenados antes da comparação
  sort -u "$ARQUIVO_TEMP" -o "$ARQUIVO_TEMP"
  if [ -f "$ARQUIVO" ]; then
    sort -u "$ARQUIVO" -o "$ARQUIVO"
  else
    echo "Arquivo local não encontrado. Considerando todas as entradas do Gist como novas."
    mv "$ARQUIVO_TEMP" "$ARQUIVO_DIFF"
    return
  fi

  # Gerar o arquivo com os domínios presentes no Gist, mas ausentes no arquivo local
  comm -23 "$ARQUIVO_TEMP" "$ARQUIVO" > "$ARQUIVO_DIFF"

  echo "Arquivo temporário com diferenças gerado: $ARQUIVO_DIFF"
}

# Função para detectar arquitetura
detectar_arquitetura() {
  local uname_out="$(uname -s)"
  local arch="$(uname -m)"

  case "${uname_out}" in
    Linux*)
      case "${arch}" in
        x86_64) echo "ooniprobe-linux-amd64" ;;
        i386|i686) echo "ooniprobe-linux-386" ;;
        armv6l) echo "ooniprobe-linux-armv6" ;;
        armv7l) echo "ooniprobe-linux-armv7" ;;
        aarch64) echo "ooniprobe-linux-arm64" ;;
        *) echo "unsupported" ;;
      esac
      ;;
    Darwin*)
      case "${arch}" in
        x86_64) echo "ooniprobe-darwin-amd64" ;;
        arm64) echo "ooniprobe-darwin-arm64" ;;
        *) echo "unsupported" ;;
      esac
      ;;
    *) echo "unsupported" ;;
  esac
}

# Verificar a última versão disponível no GitHub
verificar_ultima_versao() {
  curl -s "https://api.github.com/repos/ooni/probe-cli/releases/latest" | \
    grep '"tag_name":' | \
    sed -E 's/.*"([^"]+)".*/\1/'
}

baixar_ooniprobe() {
  # Detectar arquitetura do sistema
  BINARIO=$(detectar_arquitetura)

  if [ "$BINARIO" == "unsupported" ]; then
    echo "Arquitetura não suportada!"
    exit 1
  fi

  # Nome do binário local
  OONIPROBE_BIN="$LOCAL_BIN/ooniprobe"

  # Detectar a última versão disponível
  echo "Verificando a última versão do ooniprobe..."
  ULTIMA_VERSAO=$(verificar_ultima_versao)
  if [ -z "$ULTIMA_VERSAO" ]; then
    echo "Não foi possível obter a última versão do ooniprobe."
    exit 1
  fi

  # URL do binário para a última versão
  OONIPROBE_URL="$BASE_URL/$ULTIMA_VERSAO/$BINARIO"
  # Verificar se o binário já está na última versão
  if [ -f "$OONIPROBE_BIN" ]; then
    echo "Verificando a versão atual do ooniprobe..."
    VERSAO_ATUAL=$("$OONIPROBE_BIN" --version 2>&1 | awk '{print $NF}' | tr -d 'v')
    if [ "$VERSAO_ATUAL" == "${ULTIMA_VERSAO#v}" ]; then
      echo "Você já possui a última versão do ooniprobe ($VERSAO_ATUAL)."
    else
      echo "O ooniprobe está desatualizado: $VERSAO_ATUAL."
      echo "Uma nova versão do ooniprobe está disponível: $ULTIMA_VERSAO."
      echo "Baixando a nova versão..."
      curl -L -o "$OONIPROBE_BIN" "$OONIPROBE_URL"
      chmod +x "$OONIPROBE_BIN"
      echo "Nova versão do ooniprobe baixada e configurada."
    fi
  else
    echo "Baixando o ooniprobe para arquitetura: $BINARIO"
    curl -L -o "$OONIPROBE_BIN" "$OONIPROBE_URL"
    if [ $? -ne 0 ]; then
      echo "Erro ao baixar o ooniprobe. Verifique sua conexão e tente novamente."
      exit 1
    fi
    chmod +x "$OONIPROBE_BIN"
    echo "ooniprobe baixado e configurado como executável."
fi
}


# Criar ~/.local/bin se necessário e verificar $PATH
configurar_local_bin() {
  if [ ! -d "$LOCAL_BIN" ]; then
    echo "Criando diretório $LOCAL_BIN..."
    mkdir -p "$LOCAL_BIN"
  fi

  if [[ ":$PATH:" != *":$LOCAL_BIN:"* ]]; then
    echo "Adicionando $LOCAL_BIN ao PATH..."
    SHELL_CONFIG_FILE="$HOME/.bashrc"
    if [ -n "$ZSH_VERSION" ]; then
      SHELL_CONFIG_FILE="$HOME/.zshrc"
    fi
    echo "export PATH=\$PATH:$LOCAL_BIN" >> "$SHELL_CONFIG_FILE"
    export PATH="$PATH:$LOCAL_BIN"
    echo "O diretório $LOCAL_BIN foi adicionado ao PATH. Reinicie o shell para ativar permanentemente."
  fi
}

# Criar arquivo de configuração padrão, somente se não existir
criar_configuracao() {
  if [ ! -d "$(dirname "$CONFIG_FILE")" ]; then
    mkdir -p "$(dirname "$CONFIG_FILE")"
  fi

  if [ ! -f "$CONFIG_FILE" ]; then
    echo "Criando arquivo de configuração padrão para ooniprobe..."
    cat <<EOF > "$CONFIG_FILE"
{
    "_": "",
    "_version": 1,
    "_informed_consent": true,
    "sharing": {
      "upload_results": true
    },
    "nettests": {
      "websites_url_limit": 0,
      "websites_enabled_category_codes": null,
      "websites_max_runtime": 0
    },
    "advanced": {
      "send_crash_reports": true
    }
}
EOF
    echo "Arquivo de configuração criado em '$CONFIG_FILE'."
  else
    echo "Arquivo de configuração já existe em '$CONFIG_FILE'. Nenhuma alteração foi feita."
  fi
}

# Verificar se o arquivo no Gist foi alterado
verificar_alteracoes_gist() {
  echo "Verificando alterações no arquivo do Gist..."
  
  # Obter o ETag remoto
  local etag_remote=$(curl -sI "$URL_ARQUIVO" | grep -i ETag | awk '{print $2}' | tr -d '"')
  
  # Se não houver ETag remoto, considere erro na verificação
  if [ -z "$etag_remote" ]; then
    echo "Erro: Não foi possível obter o ETag remoto."
    exit 1
  fi

  # Ler o ETag local, se existir
  local etag_local=""
  if [ -f "$ETAG_FILE" ]; then
    etag_local=$(cat "$ETAG_FILE")
  fi

  # Comparar os ETags
  if [ "$etag_remote" != "$etag_local" ]; then
    echo "Alterações detectadas no arquivo. Baixando novo arquivo..."
    curl -s -o "$ARQUIVO" "$URL_ARQUIVO"
    if [ $? -eq 0 ]; then
      echo "$etag_remote" > "$ETAG_FILE"
      echo "Novo arquivo baixado e salvo como '$ARQUIVO'."
    else
      echo "Erro ao baixar o arquivo atualizado do Gist."
      exit 1
    fi
  else
    echo "Nenhuma alteração detectada no arquivo do Gist."
  fi
}

# Executar testes de websites
testar_websites() {
  local input_file=$1
  echo "Executando teste de websites com o arquivo: $input_file"
  "$OONIPROBE_BIN" run websites --input-file "$input_file"
  if [ $? -ne 0 ]; then
    echo "Erro ao executar testes de websites."
    exit 1
  fi
}


executar() {
  # Executar lógica para flags
  if [ "$FLAG_DIFF_ONLY" == "1" ]; then
    verificar_diff_gist
    testar_websites "$ARQUIVO_DIFF"
    mv "$ARQUIVO_TEMP" "$ARQUIVO" 
    exit 0
  fi

  # Verificar alterações no arquivo do Gist e baixá-lo se necessário
  verificar_alteracoes_gist

  if [ "$FLAG_WEBSITES_ONLY" == "1" ]; then
    testar_websites "$ARQUIVO"
    exit 0
  fi

  # Executar testes rápidos
  echo "Executando testes rápidos..."
  "$OONIPROBE_BIN" run ndt
  "$OONIPROBE_BIN" run dash
  "$OONIPROBE_BIN" run dnscheck

  # Testar domínios do arquivo baixado
  echo "Executando testes de conectividade com os domínios fornecidos no arquivo..."
  testar_websites "$ARQUIVO"

  # Testar os sites padrão do ooniprobe
  echo "Executando testes de conectividade com os sites padrão do ooniprobe..."
  "$OONIPROBE_BIN" run websites 

  echo "Todos os testes foram concluídos."
}

# Exibir ajuda
exibir_ajuda() {
  echo "Uso: $0 [opções]"
  echo ""
  echo "Opções:"
  echo "  --diff-only          Gera um arquivo temporário com os domínios que estão no Gist mas não no arquivo local e executa os testes."
  echo "  --websites-only      Executa apenas o teste de websites usando o arquivo local ou o arquivo temporário gerado pelo --diff-only."
  echo "  --help               Exibe esta mensagem de ajuda."
  exit 0
}

# Processar flags
processar_flags() {
  for arg in "$@"; do
    case "$arg" in
      --diff-only)
        FLAG_DIFF_ONLY=1
        ;;
      --websites-only)
        FLAG_WEBSITES_ONLY=1
        ;;
      --help)
        exibir_ajuda
        ;;
      *)
        echo "Opção inválida: $arg"
        exibir_ajuda
        ;;
    esac
  done
}


# Lógica principal
processar_flags "$@"

# Configurar ~/.local/bin e verificar PATH
configurar_local_bin

baixar_ooniprobe

# Criar configuração padrão, somente se necessário
criar_configuracao

executar