Esta página foi traduzida pela API Cloud Translation.

Encaminhador de Operações de segurança do Google para Linux

Neste documento, descrevemos como instalar e configurar o encaminhador no Linux. Para instalar o encaminhador no Windows, consulte Encaminhamento do Windows.

O encaminhador é usado para enviar registros do ambiente do cliente para a equipe de operações de segurança do Google instância. Isso é usado quando os clientes querem enviar os registros diretamente para o Google Security Operations e não quiser usar os buckets na nuvem para ingerir dados ou os logtype não tem ingestão nativa por API de terceiros. O encaminhador pode ser usada como uma solução pronta para implantação, em vez de incorporar manualmente o API de ingestão.

É possível instalar o encaminhador em várias distribuições do Linux, como Debian, Ubuntu, Red Hat e Suse. O Google Cloud fornece o software usando uma contêiner do Docker. É possível executar e gerenciar o contêiner do Docker em uma máquina física ou virtual com Linux.

Requisitos do sistema

Confira a seguir recomendações gerais. Para recomendações específicas entre em contato com o suporte de Operações de segurança do Google.

RAM: 1 GB para cada tipo de dados coletados (coletor) aceito pelas Operações de Segurança do Google para ingestão. Por exemplo, se você especificou quatro coletores diferentes, precisa de 4 GB de RAM para coletar os dados dos quatro coletores.
CPU: duas CPUs são suficientes para lidar com menos de 10.000 eventos por segundo (EPS) (total para todos os tipos de dados). Se você espera encaminhar mais de 10.000 EPS, provisione de 4 a 6 CPUs.
Disco: 100 MB de espaço em disco são suficientes, independente da quantidade de dados Os encaminhadores das Operações de segurança do Google lidam com essa situação. Se você precisar armazenar em buffer as mensagens do backlog no disco e não na memória, consulte Armazenamento em buffer de disco. As Operações de segurança do Google e encaminhadores buffers para a memória por padrão.

Intervalos de endereços IP do Google

Talvez seja necessário abrir o intervalo de endereços IP ao definir uma configuração de Encaminhador, por exemplo, ao definir a configuração do seu firewall. O Google não pode fornecer uma lista específica de endereços IP. No entanto, você pode conseguir intervalos de endereços IP do Google.

Verificar a configuração do firewall

Todos os firewalls ou proxies autenticados entre o contêiner de encaminhador do Google Security Operations e a Internet exigem regras para abrir o acesso aos seguintes hosts:

Tipo de conexão	Destino	Port
TCP	malachiteingestion-pa.googleapis.com	443
TCP	asia-northeast1-malachiteingestion-pa.googleapis.com	443
TCP	asia-south1-malachiteingestion-pa.googleapis.com	443
TCP	asia-southeast1-malachiteingestion-pa.googleapis.com	443
TCP	australia-southeast1-malachiteingestion-pa.googleapis.com	443
TCP	europe-malachiteingestion-pa.googleapis.com	443
TCP	europe-west2-malachiteingestion-pa.googleapis.com	443
TCP	europe-west3-malachiteingestion-pa.googleapis.com	443
TCP	europe-west6-malachiteingestion-pa.googleapis.com	443
TCP	europe-west12-malachiteingestion-pa.googleapis.com	443
TCP	me-central1-malachiteingestion-pa.googleapis.com	443
TCP	me-central2-malachiteingestion-pa.googleapis.com	443
TCP	me-west1-malachiteingestion-pa.googleapis.com	443
TCP	northamerica-northeast2-malachiteingestion-pa.googleapis.com	443
TCP	accounts.google.com	443
TCP	gcr.io	443
TCP	oauth2.googleapis.com	443
TCP	storage.googleapis.com	443

Personalizar os arquivos de configuração

O Google Cloud personaliza os arquivos de configuração para a instância do encaminhador com metadados específicos, como mostrado na seção de saída. É possível fazer o download do arquivo de configuração de acordo com seus requisitos e inclua informações sobre os tipos de registro a serem ingeridos nos coletores nesta seção. Para mais informações sobre as definições de configuração, consulte a Referência das definições de configuração.

Configurar o encaminhador do Linux

Para configurar o encaminhador do Linux usando a UI, consulte Gerenciar configurações do encaminhador usando a interface do Google SecOps.

Para configurar o encaminhador do Linux manualmente, faça o seguinte:

Faça uma cópia do modelo de arquivo de configuração fornecido com o software.
Fazer o download do arquivo de configuração pela UI.
Salve os dois arquivos no mesmo diretório usando a seguinte convenção de nomenclatura:

FORWARDER_NAME.conf: use esse arquivo para definir o de configurações relacionadas à ingestão de registros.

FORWARDER_NAME_auth.conf: use esse arquivo para definir a credenciais de autorização.
Modifique os arquivos para incluir a configuração da sua instância de encaminhador. Use os exemplos fornecidos neste documento como referência.
Verifique se existe uma entrada para cada entrada na FORWARDER_NAME_auth.conf, mesmo que a entrada não tenha os detalhes de autenticação correspondentes. Isso é necessário para mapear os dados corretamente.

Todas as alterações feitas no arquivo de configuração serão aplicadas automaticamente pelo encaminhador em até cinco minutos.

Exemplo de configuração

O exemplo de código a seguir mostra o formato dos arquivos de configuração para um encaminhador. Para detalhes sobre as configurações de cada tipo de ingestão mecanismo, como Splunk ou Syslog, consulte Coletar dados.

Arquivo FORWARDER_NAME.conf

output:
  url: malachiteingestion-pa.googleapis.com:443
  identity:
    identity:
    collector_id: COLLECTOR_ID \
    customer_id: CUSTOMER_ID \

collectors:
  - syslog:
      common:
        enabled: true
        data_type: "WINDOWS_DHCP"
        data_hint:
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      tcp_address: 0.0.0.0:10514
      udp_address: 0.0.0.0:10514
      connection_timeout_sec: 60
      tcp_buffer_size: 524288
  - syslog:
      common:
        enabled: true
        data_type: "WINDOWS_DNS"
        data_hint:
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      tcp_address: 0.0.0.0:10515
      connection_timeout_sec: 60
      tcp_buffer_size: 524288

O arquivo FORWARDER_NAME_auth.conf

output:
  identity:
    secret_key: |
      {
        "type": "service_account",
        "project_id": "PROJECT_ID" \,
        "private_key_id": "PRIVATE_KEY_ID" \,
        "private_key": "-----BEGIN PRIVATE KEY-----\\"PRIVATE_KEY" \n-----END PRIVATE KEY-----\n",
        "client_email": "CLIENT_EMAIL" \,
        "client_id": "CLIENT_ID" \,
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/example-account-1%40example-account.iam.gserviceaccount.com"
      }

collectors:
  - syslog:
  - syslog:
      certificate: "../forwarder/inputs/testdata/localhost.pem"
      certificate_key: "../forwarder/inputs/testdata/localhost.key"

Esse sistema de dois arquivos permite armazenar credenciais de autenticação em um para reforçar a segurança. Você pode armazenar o arquivo FORWARDER_NAME.conf em um arquivo repositório de controle de versões ou qualquer sistema aberto de gerenciamento de configuração. É possível armazenar FORWARDER_NAME_auth.conf diretamente na máquina física ou virtual que executa o encaminhador.

Exemplo de configuração (arquivo único)

output:
  url: malachiteingestion-pa.googleapis.com:443
  identity:
    identity:
    collector_id: "COLLECTOR_ID" \
    customer_id: "CUSTOMER_ID" \
    secret_key: |
      {
        "type": "service_account",
        "project_id": "PROJECT_ID" \,
        "private_key_id": "PRIVATE_KEY_ID" \,
        "private_key": "-----BEGIN PRIVATE KEY-----\ "PRIVATE_KEY" \n-----END PRIVATE KEY-----\n",
        "client_email": "CLIENT_EMAIL" \,
        "client_id": "CLIENT_ID" \,
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/malachite-test-1%40malachite-test.iam.gserviceaccount.com"
      }

collectors:
  - syslog:
      common:
        enabled: true
        data_type: "WINDOWS_DHCP"
        data_hint:
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      tcp_address: 0.0.0.0:10514
      udp_address: 0.0.0.0:10514
      connection_timeout_sec: 60
      tcp_buffer_size: 524288
  - syslog:
      common:
        enabled: true
        data_type: "WINDOWS_DNS"
        data_hint:
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      tcp_address: 0.0.0.0:10515
      connection_timeout_sec: 60
      certificate: "../forwarder/inputs/testdata/localhost.pem"
      certificate_key: "../forwarder/inputs/testdata/localhost.key"
      tcp_buffer_size: 524288

Se você estiver usando um único arquivo de configuração e quiser mover para o arquivo de dois faça o seguinte:

Crie uma cópia da configuração atual.
Salve um arquivo como FORWARDER_NAME.conf e exclua as credenciais de autorização dele.
Salve o outro arquivo como FORWARDER_NAME_auth.conf e exclua todos os dados não autorizados. Use os exemplos de arquivos de configuração fornecidos neste guia como referência.
Siga a convenção de nomenclatura e outras diretrizes mencionadas na seção Personalizar os arquivos de configuração.

Instalar o Docker

A instalação do Docker depende do ambiente do host. É possível instalar o Docker em diferentes sistemas operacionais de host. O Google Cloud oferece uma documentação limitada para ajudar você a instalar o Docker em várias das distribuições mais conhecidas do Linux. No entanto, o Docker tem código aberto e toda a documentação necessária já está disponível. Para instruções sobre a instalação do Docker, consulte a Documentação do Docker.

Depois que o Docker for instalado no sistema, o processo de instalação do encaminhador do Google Security Operations será semelhante a qualquer tipo de distribuição Linux.

Para verificar se o Docker está instalado corretamente no sistema, execute o seguinte comando (privilégios elevados):

   docker ps

A resposta a seguir indica que o Docker foi instalado corretamente:

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

Comandos úteis do Docker

Colete informações adicionais sobre a instalação do Docker usando o seguinte comando:
```
docker info
```
O serviço Docker pode ser desativado por padrão. Para verificar se ela está desativada, execute o seguinte comando:
```
systemctl is-enabled docker
```

Para ativar o serviço do Docker e iniciá-lo imediatamente, execute um dos comandos a seguir: comandos:

sudo systemctl enable --now docker

sudo systemctl enable /usr/lib/systemd/system/docker.service

Saída:

Created symlink /etc/systemd/system/multi-user.target.wants/docker.service → /lib/systemd/system/docker.service

Ao iniciar um encaminhador, execute o seguinte comando para configurá-lo para reiniciar automaticamente:
```
sudo docker run --restart=always `IMAGE_NAME`
```
IMAGE_NAME é o nome da imagem do encaminhador.

Para verificar o status e os detalhes do serviço do Docker, execute o seguinte comando:

sudo systemctl status docker

Saída:

● docker.service - Docker Application Container Engine
    Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
    Active: active (running) since Sat 2020-07-18 11:14:05 UTC; 15s ago
TriggeredBy: ● docker.socket
      Docs: https://docs.docker.com
  Main PID: 263 (dockerd)
      Tasks: 20
    Memory: 100.4M
    CGroup: /system.slice/docker.service
            └─263 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Jul 18 11:14:05 swarm-kraken dockerd[263]: time="2020-07-18T11:14:05.713787002Z" level=info msg="API listen on /run/docker.sock"
Jul 18 11:14:05 swarm-kraken systemd[1]: Started Docker Application Container Engine

Em caso de problemas com o Docker, a equipe de suporte de Operações de Segurança do Google pode solicitar desse comando para ajudar e depurar o problema.

Instalar o encaminhador no Linux

Nesta seção, descrevemos como instalar o Encaminhador de operações de segurança do Google usando um contêiner do Docker em um sistema Linux.

Etapa 1. Fazer o download, transferir e instalar os arquivos de configuração do encaminhador

O Google Security Operations fornece arquivos de configuração de encaminhadores específicos para seu sistema operacional (Linux ou Windows). Você pode fazer o download do arquivo de configuração conforme seus requisitos. Depois de concluir as etapas a seguir, transfira os arquivos de configuração do laptop para o diretório /opt/chronicle/config de encaminhamento, que fica no diretório inicial do usuário.

Conecte-se ao host do encaminhador do Linux pelo terminal.

Crie um novo usuário no host do encaminhador do Linux.

  adduser USERNAME
  passwd USERNAME
  usermod -aG wheel USERNAME

Altere o diretório para o diretório inicial do novo usuário que executa o Docker contêiner.
Crie um diretório para armazenar os arquivos de configuração do encaminhador do Google Security Operations:
```
  mkdir /opt/chronicle/config
```
Observação :o nome do diretório, config, é um exemplo. É possível especificar para este diretório. No entanto, use o mesmo diretório ao executar o comando docker run.
Mude o diretório.
```
  cd /opt/chronicle/config
```
Depois de transferir os arquivos, verifique se os arquivos de configuração estão localizados no diretório /opt/chronicle/config:
```
  ls -l
```

Etapa 2. Execute o encaminhador no contêiner do Docker

Use os procedimentos a seguir para iniciar o encaminhador das Operações de segurança do Google pela primeira vez, bem como atualizar para a versão mais recente do Contêiner das Operações de segurança do Google:

As opções --log-opt estão disponíveis desde o Docker 1,13. Essas opções limitam o tamanho dos arquivos de registro do contêiner e para uso, desde que sua versão do Docker seja compatível.

Se você estiver fazendo upgrade, comece limpando todas as execuções anteriores do Docker. Na exemplo a seguir, o nome do contêiner do Docker é cfps. Obter a imagem mais recente do Docker no Google Cloud com o docker pull, como mostrado abaixo.
```
docker stop cfps
```
```
docker rm cfps
```

Consiga a imagem mais recente do Docker no Google Cloud:

docker pull gcr.io/chronicle-container/cf_production_stable

Inicie o encaminhador das Operações de segurança do Google no contêiner do Docker:

docker run \
--detach \
--name cfps \
--restart=always \
--log-opt max-size=100m \
--log-opt max-file=10 \
--net=host \
-v /opt/chronicle/config:/opt/chronicle/external \
gcr.io/chronicle-container/cf_production_stable

Ver registros do encaminhador

Para visualizar os registros de encaminhador das Operações de segurança do Google, execute o seguinte comando:

  sudo docker logs cfps

Para ver o caminho do arquivo em que os registros são armazenados, execute o seguinte comando:

docker inspect --format='{{.LogPath}}' CONTAINER_NAME

Para visualizar os registros em execução em tempo real, execute o seguinte comando:

  sudo docker logs cfps -f

Para armazenar os registros em um arquivo, execute o seguinte comando:

  sudo docker logs cfps &> logs.txt

Desinstalar o encaminhador

Os comandos do Docker a seguir ajudam a interromper e desinstalar ou remover o encaminhador do Google Security Operations.

Para interromper ou desinstalar o contêiner do encaminhador:

    docker stop cfps

Para remover o contêiner do encaminhador:

    docker rm cfps

Atualizar o encaminhador

O encaminhador de Operações de segurança do Google tem duas partes e é atualizado da seguinte forma:

Pacote de encaminhador: é atualizado automaticamente e não é necessário reiniciar.
Imagem Docker do encaminhador: é atualizada manualmente após interromper o encaminhador existente e iniciar uma nova instância como conforme descrito na Etapa 2.

Coletar dados

As seções a seguir ajudam você a configurar o encaminhador do Google Security Operations para ingerir diferentes tipos de dados, que são: encaminhados à instância de Operações de segurança do Google.

Coletar dados do Splunk

É possível configurar o encaminhador de Operações de segurança do Google para encaminhar seus dados do Splunk para as Operações de segurança do Google. O Google Cloud configura o encaminhador das Operações de segurança do Google com as seguintes informações para encaminhar seus dados do Splunk:

URL para a API REST do Splunk (por exemplo, https://10.0.113.15:8089).
Consultas Splunk para gerar dados para cada um dos tipos de dados necessários (por exemplo, index=dns).

FORWARDER_NAME.conf
output:
collectors:
  - splunk:
      common:
        enabled: true
        data_type: WINDOWS_DNS
        data_hint: "#fields ts      uid     id.orig_h       id.orig_p       id.resp_h         id.resp_p       proto   trans_id        query   qclass  qclass_name"
        batch_n_seconds: 10
        batch_n_bytes: 819200
      url: https://127.0.0.1:8089
      is_ignore_cert: true
      minimum_window_size: 10s
      maximum_window_size: 30s
      query_string: search index=* sourcetype=dns
      query_mode: realtime

Disponibilize as credenciais da sua conta do Splunk para as Operações de segurança do Google encaminhador. Para fazer isso, crie um arquivo creds.txt.

Para usar um arquivo creds.txt:

Crie um arquivo local para suas credenciais do Splunk e nomeie-o como creds.txt.

Observação: verifique se as credenciais estão armazenadas com segurança. Não encaminhe suas credenciais do Splunk para o Google Cloud.
Insira seu nome de usuário na primeira linha e a senha na segunda linha:
```
cat creds.txt

myusername
mypassword
```
Usar o encaminhador de Operações de Segurança do Google para acessar um Splunk instância, copie o arquivo creds.txt para o diretório de configuração (o mesmo em que os arquivos de configuração residem). Exemplo:
```
cp creds.txt /opt/chronicle/config/creds.txt
```
Verifique se o arquivo creds.txt está no local correto:
```
ls /opt/chronicle/config
```

Coletar dados de syslog

O encaminhador de Operações de segurança do Google pode funcionar como um servidor Syslog. É possível configurar qualquer appliance ou servidor que oferece suporte ao envio de dados de syslog por uma conexão TCP ou UDP para encaminhar os dados ao encaminhador de Operações de Segurança do Google. Você pode controlar os dados exatos que o appliance ou o servidor envia para o Encaminhador de Operações de Segurança do Google. O encaminhador de Operações de Segurança do Google pode encaminhar os dados para as Operações de segurança do Google.

O arquivo de configuração FORWARDER_NAME.conf (fornecido pelo Google Cloud) especifica quais portas monitorar para cada tipo de encaminhados (por exemplo, porta 10514). Por padrão, as Operações de segurança do Google o encaminhador aceita conexões TCP e UDP.

Configurar rsyslog

Para configurar o rsyslog, especifique um destino para cada porta (por exemplo, cada tipo de dados). Consulte a documentação do sistema para saber a sintaxe correta. A Exemplos abaixo ilustram a configuração de destino "rsyslog":

Tráfego de registro TCP: dns.* @@192.168.0.12:10514
Tráfego de registro UDP: dns.* @192.168.0.12:10514

Ativar TLS para configurações syslog

É possível ativar o TLS para a conexão Syslog com as Operações de segurança do Google encaminhador. No arquivo de configuração do encaminhador do Google Security Operations (FORWARDER_NAME.conf), especifique seu próprio local gerado pelo Google, como mostrado no exemplo a seguir:

certificado	"/opt/chronicle/external/certs/client_generated_cert.pem"
certificate_key	"/opt/chronicle/external/certs/client_generated_cert.key"

Com base no exemplo mostrado, modifique o encaminhador do Google Security Operations arquivo de configuração (FORWARDER_NAME.conf) da seguinte forma:

  collectors:
- syslog:
    common:
      enabled: true
      data_type: WINDOWS_DNS
      data_hint:
      batch_n_seconds: 10
      batch_n_bytes: 1048576
    tcp_address: 0.0.0.0:10515
    tcp_buffer_size: 65536
    connection_timeout_sec: 60
    certificate: "/opt/chronicle/external/certs/client_generated_cert.pem"
    certificate_key: "/opt/chronicle/external/certs/client_generated_cert.key"
    minimum_tls_version: "TLSv1_3"

Alguns pontos importantes a serem observados:

É possível configurar o tamanho do buffer TCP. O tamanho padrão do buffer TCP 64 KB.
O valor padrão e recomendado de Connection_timeout é 60 segundos. A conexão TCP é encerrada se ficar inativa por um período especificado.
A versão de TLS mínima é comparada com a versão do TLS do solicitação de entrada. A versão TLS da solicitação de entrada deve ser superior a a versão mínima do TLS. A versão de TLS mínima deve ser um dos seguintes valores: TLSv1_0, TLSv1_1, TLSv1_2, TLSv1_3.

É possível criar um diretório "certs" no diretório de configuração e armazenar os arquivos de certificado.

Coletar dados de arquivos

Um coletor de arquivos é projetado para buscar os registros de um arquivo. O arquivo deve ser vinculado ao contêiner do Docker.

Use este método se você quiser fazer o upload manual dos registros de um único arquivo de registros. Isso pode ser usada para preencher os registros de um determinado arquivo de registro.

Inicie o encaminhador do Google Security Operations pelo contêiner do Docker:

  docker run \
    --detach \
    --name cfps \
    --log-opt max-size=100m \
    --log-opt max-file=10 \
    --net=host \
    -v /opt/chronicle/config:/opt/chronicle/external \
    -v /var/log/crowdstrike/falconhostclient:/opt/chronicle/edr \
     gcr.io/chronicle-container/cf_production_stable

Esse comando docker run é fundamental para mapear o volume de carga para o contêiner.

Com base neste exemplo, modifique o encaminhador do Google Security Operations (arquivo FORWARDER_NAME.conf) da seguinte maneira. O arquivo sample.txt precisa estar no /var/log/crowdstrike/falconhostclient.

 collectors:
  - file:
       common:
         enabled: true
         data_type: CS_EDR
         data_hint:
         batch_n_seconds: 10
         batch_n_bytes: 1048576
       file_path: /opt/chronicle/edr/sample.txt
       filter:

Configurações de sinalização

skip_seek_to_end (bool): essa flag é definida como false por padrão, e o arquivo entrada envia apenas novas linhas de registro como entrada. Definir como true faz com que todos linhas de registro anteriores sejam enviadas novamente durante as reinicializações do encaminhador. Isso faz com que o registro duplicação. Definir essa flag como true é útil em determinados específicas (por exemplo, durante interrupções), porque reiniciar o encaminhador envia o que estão faltando novamente.

poll (bool): o coletor de arquivos usa a biblioteca Tail para verificar se há mudanças no no sistema de arquivos. Ao definir essa flag como true, a biblioteca Tail usa a pesquisa em vez do método de notificação padrão.

Coletar dados de pacotes

O encaminhador de Operações de segurança do Google pode capturar pacotes diretamente de uma rede interface usando o libcap no Linux. Para mais informações sobre o libcap, consulte libcap - página de manual do Linux (em inglês).

Os pacotes são capturados e enviados para as Operações de segurança do Google em vez das entradas de registro. A captura de pacotes é gerenciada em um . Para ativar a captura de pacotes no seu sistema, entre em contato com Suporte das Operações de segurança do Google.

O Google Cloud configura o encaminhador das Operações de segurança do Google com a Berkeley Expressão do filtro de pacotes (BPF, na sigla em inglês) usada na captura de pacotes (por exemplo, porta 53) e não localhost). Para mais informações, consulte Filtros de pacote Berkeley (em inglês).

Coletar dados do tópico Kafka

É possível ingerir dados dos tópicos do Kafka da mesma forma que faz com o syslog. A os grupos de consumidores são aproveitados para permitir que você implante até três encaminhadores e extrair dados do mesmo tópico Kafka. Para mais informações, consulte Kafka (em inglês).

Para mais informações sobre grupos de consumidores do Kafka, consulte: https://docs.confluent.io/platform/current/clients/consumer.html

Exemplo de configuração: entrada do Kafka

A configuração do encaminhador a seguir mostra como configurar o encaminhador para ingerir dados dos tópicos do Kafka.

Arquivo FORWARDER_NAME.conf

collectors:
- kafka:
      common:
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: NIX_SYSTEM
        enabled: true
      topic: example-topic
      group_id: chronicle-forwarder
      timeout: 60s
      brokers: ["broker-1:9092", "broker-2:9093"]
      tls:
        insecureSkipVerify: true
        certificate: "/path/to/cert.pem"
        certificate_key: "/path/to/cert.key"
- syslog:
      common:
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: WINEVTLOG
        enabled: true
      tcp_address: 0.0.0.0:30001
      connection_timeout_sec: 60

O arquivo FORWARDER_NAME_auth.conf

collectors:
- kafka:
      username: user
      password: password
- syslog:

Coletar dados do WebProxy

O encaminhador de Operações de segurança do Google pode capturar dados do WebProxy diretamente de uma rede interface usando o libcap no Linux. Para saber mais sobre o libcap, consulte libcap - página de manual do Linux (em inglês). Para ativar a captura de dados do WebProxy para seu sistema, entre em contato com Suporte das Operações de segurança do Google.

Modificar a configuração do encaminhador do Google Security Operations (arquivo FORWARDER_NAME.conf) da seguinte forma:

- webproxy:
      common:
        enabled : true
        data_type: <Your LogType>
        batch_n_seconds: 10
        batch_n_bytes: 1048576
      interface: any
      bpf: tcp and dst port 80

Personalizar configurações

A tabela a seguir lista parâmetros importantes usados no arquivo de configuração do encaminhador.

Parâmetro	Descrição
data_type	O tipo de dados de registro que o coletor pode coletar e processar.
metadados	Metadados, que substituem os metadados globais.
max_file_buffer_bytes	Número máximo de bytes que podem ser acumulados no disco ou no buffer do arquivo. O valor padrão é `1073741824`, que é 1 GB.
max_memory_buffer_bytes	Número máximo de bytes que podem ser acumulados no buffer de memória. A o valor padrão é `1073741824`, que é 1 GB.
write_to_disk_dir_path	O caminho a ser usado para o arquivo ou buffer de disco.
write_to_disk_buffer_enabled	Se `true`, o buffer de disco será usado em vez do buffer de memória. O valor padrão é `false`.
batch_n_bytes	Número máximo de bytes que podem ser acumulados pelo coletor após em que os dados são reunidos em lote. O valor padrão é `1048576`, que é 1 MB.
batch_n_seconds	O número de segundos após os quais os dados coletados pelo coletor são agrupados. O valor padrão é de 11 segundos.
data_hint	Formato de dados que o coletor pode receber (geralmente o cabeçalho do arquivo de registros que descreve o formato).

Para uma lista extensa dos parâmetros usados no arquivo de configuração, consulte Campos de configuração do encaminhador e Campos de configuração do coletor.

Ativar a compactação de dados

A compactação de registros reduz o consumo de largura de banda da rede ao transferir registros Operações de segurança do Google. No entanto, a compactação pode causar um aumento no uso da CPU. A compensação entre o uso de CPU e a largura de banda depende de muitos fatores, incluindo o tipo de dados de registro, a compressibilidade desses dados, a disponibilidade de recursos no host executando o encaminhador e a necessidade de reduzir a consumo de largura de banda.

Por exemplo, os registros baseados em texto são bem comprimidos e podem fornecer uma largura de banda substancial com baixo uso de CPU. No entanto, os payloads criptografados dos pacotes brutos são bem compactadas e aumentam o uso da CPU.

A compactação de registros fica desativada por padrão. Ativar a compactação de registros pode reduzir o consumo de largura de banda. No entanto, ativar a compactação de registros aumentar o uso da CPU. Saiba o que fazer.

Para ativar a compactação de registro, defina o campo compression como true no arquivo de configuração do encaminhador das Operações de segurança do Google como como mostrado no exemplo a seguir:

Arquivo FORWARDER_NAME.conf

output:
  compression: true
    url: malachiteingestion-pa.googleapis.com:443
    identity:
      identity:
      collector_id: 10479925-878c-11e7-9421-10604b7cb5c1
      customer_id: ebdc4bb9-878b-11e7-8455-10604b7cb5c1
...

O arquivo FORWARDER_NAME_auth.conf

output:
  identity:
    secret_key: |
    {
     "type": "service_account",
...
    }

Configurar o armazenamento em buffer de disco

O armazenamento em buffer de disco permite armazenar em buffer as mensagens acumuladas no disco, memória. As mensagens em backlog podem ser armazenadas caso o encaminhador falhe ou o host subjacente falha. Ativar o armazenamento em buffer de disco pode afetar desempenho.

Se o armazenamento em buffer do disco estiver desativado, o encaminhador usará 1 GB de memória (RAM) para cada tipo de registro (por exemplo, por conector). Especifique o valor de max_memory_buffer_bytes parâmetro de configuração. A memória máxima permitida é de 4 GB.

É possível configurar o armazenamento em buffer automático na memória para usar um buffer compartilhado dinamicamente entre coletores, que lida melhor com picos de tráfego. Para ativar o recurso buffer compartilhado, adicione o seguinte na configuração do encaminhador:

auto_buffer:
  enabled: true
  target_memory_utilization: 80

Se o armazenamento em buffer automático de disco estiver ativado, target_memory_utilization não está definido, ele usa um valor padrão de 70.

Se você estiver executando o encaminhador usando o Docker, o Google recomenda montar um separado do volume de configuração para fins de isolamento. Além disso, cada entrada precisa ser isolada com o próprio diretório ou volume para evitar conflitos de segurança.

Exemplo de configuração: armazenamento em buffer de disco

A configuração a seguir inclui a sintaxe para ativar o armazenamento em buffer do disco:

collectors:
- syslog:
    common:
      write_to_disk_buffer_enabled: true
      # /buffers/NIX_SYSTEM is part of the external mounted volume for the
forwarder
      write_to_disk_dir_path: /buffers/NIX_SYSTEM
      max_file_buffer_bytes: 1073741824
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60

Definir filtros de expressão regular

Os filtros de expressão regular permitem filtrar registros com base na expressão regular e faz correspondências com registros brutos.

Os filtros empregam a sintaxe RE2 descrita aqui: https://github.com/google/re2/wiki/Syntax

Os filtros precisam incluir uma expressão regular e, opcionalmente, definir um comportamento quando há uma correspondência. O comportamento padrão em uma correspondência é bloquear (você pode o configure explicitamente como um bloco).

Como alternativa, especifique filtros com o comportamento allow. Se você especificar qualquer filtro allow, o encaminhador bloqueia quaisquer registros que não correspondam a pelo menos um Filtro allow.

É possível definir um número arbitrário de filtros. Os filtros de bloqueio precedência sobre filtros allow.

Quando os filtros são definidos, é necessário atribuir um nome a eles. Os nomes dos ativos os filtros serão informados às Operações de segurança do Google por meio das métricas de integridade do encaminhador. Filtros definidos na raiz da configuração são mesclados com filtros definidos no no nível do coletor. Os filtros no nível do coletor têm precedência nos casos nomes conflitantes. Se nenhum filtro for definido na raiz ou no coletor o comportamento é permitir todos.

Exemplo de configuração: filtros de expressão regular

Na configuração do encaminhador a seguir, o WINEVTLOG registra que não correspondem ao filtro raiz (allow_filter) estão bloqueados. Considerando os parâmetros o filtro permitirá apenas registros com prioridades entre 0 e 99. No entanto, todos os registros NIX_SYSTEM que contêm "foo" ou "bar" estão bloqueados, apesar da allow_filter. Isso ocorre porque os filtros usam um OR lógico. Todos registros são processados até que um filtro seja acionado.

regex_filters:
  allow_filter:
    regexp: ^<[1-9][0-9]?$>.*$
    behavior_on_match: allow
collectors:
- syslog:
    common:
      regex_filters:
        block_filter_1:
          regexp: ^.*foo.*$
          behavior_on_match: block
        block_filter_2:
          regexp: ^.*bar.*$
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60

Configurar rótulos arbitrários

Os identificadores são usados para anexar metadados arbitrários a registros usando pares de chave-valor. Os rótulos podem ser configurados para todo um encaminhador ou dentro de um coletor específico de um encaminhador. Se ambos forem fornecidos, os rótulos serão mesclados com o que têm precedência sobre as chaves do encaminhador se as chaves se sobrepuserem.

Exemplo de configuração: rótulos arbitrários

Na seguinte configuração do encaminhador, o valor 'foo=bar' e 'meow=mix' chave e pares de valores estão anexados a logs WINEVTLOG e a tag 'foo=baz' e "miau=mix" pares de chave-valor são anexados aos registros NIX_SYSTEM.

metadata:
  labels:
    foo: bar
    meow: mix
collectors:
syslog:
    common:
      metadata:
        labels:
          foo: baz
          meow: mix
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60

Configurar namespaces

Use rótulos de namespace para identificar registros de segmentos de rede distintos e e eliminar o conflito de endereços IP sobrepostos. É possível configurar um rótulo de namespace encaminhador inteiro ou dentro de um coletor específico dele. Se ambos forem incluído, o namespace do coletor específico tem precedência.

Qualquer namespace configurado para o encaminhador aparece com os recursos associados no a interface do usuário das Operações de segurança do Google. Também é possível pesquisar namespaces usando o Recurso de pesquisa das Operações de segurança do Google.

Para informações sobre como visualizar namespaces na interface do usuário das Operações de segurança do Google, clique aqui.

Exemplo de configuração: namespaces

Na configuração do encaminhador a seguir, os registros WINEVTLOG são anexados ao namespace FORWARDER e registros NIX_SYSTEM são anexada ao namespace CORPORATE.

metadata:
  namespace: FORWARDER
collectors:
- syslog:
      common:
        metadata:
          namespace: CORPORATE
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: NIX_SYSTEM
        enabled: true
      tcp_address: 0.0.0.0:30000
      connection_timeout_sec: 60
- syslog:
      common:
        batch_n_bytes: 1048576
        batch_n_seconds: 10
        data_hint: null
        data_type: WINEVTLOG
        enabled: true
      tcp_address: 0.0.0.0:30001
      connection_timeout_sec: 60

Configurar opções de balanceamento de carga e alta disponibilidade

O encaminhador das Operações de segurança do Google para Linux pode ser implantado em um ambiente em que um balanceador de carga de camada 4 é instalado entre a origem e o encaminhador de dados instâncias. Assim, um cliente pode distribuir a coleta de registros vários encaminhadores ou enviar registros para outro em caso de falha. Isso esse recurso só é compatível com o tipo de coleção "syslog".

O encaminhador do Linux inclui um servidor HTTP integrado que responde à do balanceador de carga. O servidor HTTP também ajuda a garantir que os registros sejam não sejam perdidos durante a inicialização ou desligamento de um encaminhador.

Configurar o servidor HTTP, o balanceamento de carga e as opções de alta disponibilidade na seção server do arquivo de configuração do encaminhador. Essas opções oferecem suporte à definição de durações de tempo limite e códigos de status retornados em resposta a verificações de integridade recebidas no programador de contêiner e baseadas em orquestração bem como de balanceadores de carga tradicionais.

Use os caminhos de URL abaixo para verificações de integridade, prontidão e atividade. Os valores <host:port> são definidos na configuração do encaminhador.

http://<host:port>/meta/available: verificações de atividade do contêiner programadores ou orquestradores.
http://<host:port>/meta/ready: verificações de prontidão e carga tradicional e verificações de integridade do balanceador.

A configuração do encaminhador a seguir é um exemplo para balanceamento de carga e disponibilidade:

collectors:
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: NIX_SYSTEM
      enabled: true
    tcp_address: 0.0.0.0:30000
    connection_timeout_sec: 60
- syslog:
    common:
      batch_n_bytes: 1048576
      batch_n_seconds: 10
      data_hint: null
      data_type: WINEVTLOG
      enabled: true
    tcp_address: 0.0.0.0:30001
    connection_timeout_sec: 60
server:
  graceful_timeout: 15s
  drain_timeout: 10s
  http:
    port: 8080
    host: 0.0.0.0
    read_timeout: 3s
    read_header_timeout: 3s
    write_timeout: 3s
    idle_timeout: 3s
    routes:
    - meta:
        available_status: 204
        ready_status: 204
        unready_status: 503

Caminho de configuração	Descrição
servidor : Graceful_timeout	O tempo que o encaminhador retorna uma verificação de prontidão/integridade ruim e ainda aceita novas conexões. Também é hora de esperar recebendo um sinal para parar e começar o encerramento no próprio servidor. Isso dá ao balanceador de carga tempo para remover o encaminhador. do pool.
servidor : run_timeout	A quantidade de tempo que o encaminhador espera conexões ativas para fechar por conta própria antes de ser fechado pelo servidor.
servidor : http : porta	O número da porta que o servidor HTTP detecta para verificações de integridade da de carga HTTP(S) externo global. O valor precisa estar entre 1024 e 65535.
servidor : http : host	O endereço IP ou nome do host que pode ser convertido em endereços IP, que o deve detectar. Se estiver vazio, o valor padrão será o sistema local (0.0.0.0).
servidor : http : read_timeout	Usado para ajustar o servidor HTTP. Normalmente, não precisa ser alterado de a configuração padrão. A quantidade máxima de tempo permitida para ler todo o o cabeçalho e o corpo da solicitação. É possível definir read_timeout e read_header_timeout.
servidor : http : read_header_timeout	Usado para ajustar o servidor HTTP. Normalmente, não precisa ser alterado de a configuração padrão. A quantidade máxima de tempo permitida para ler a solicitação e cabeçalhos de cache válidos. O prazo de leitura da conexão é redefinido após a leitura do cabeçalho.
servidor : http : write_timeout	Usado para ajustar o servidor HTTP. Normalmente, não precisa ser alterado de a configuração padrão. O tempo máximo permitido para enviar uma resposta. Ele é redefinido quando um novo cabeçalho de solicitação é lido.
servidor : http : sleep_timeout	Usado para ajustar o servidor HTTP. Normalmente, não precisa ser alterado de a configuração padrão. O tempo máximo de espera pela próxima quando conexões inativas estão ativadas. Se missing_timeout for zero, o o valor de read_timeout é usado. Se ambos forem zero, o "read_header_timeout" será usados.
routes : meta : Ready_status	O código de status que o encaminhador retorna quando está pronto para aceitar o tráfego em uma das seguintes situações: A verificação de prontidão é recebida de um programador de contêiner ou e orquestrador. A verificação de integridade é recebida de um balanceador de carga tradicional.
routes : meta : familiesy_status	O código de status que o encaminhador retorna quando não está pronto para aceitar do tráfego de entrada.
routes : meta : available_status	O código de status que o encaminhador retorna quando uma verificação de atividade é recebida e o encaminhador está disponível. Os programadores ou orquestradores de contêiner costumam enviar verificações de atividade.

Perguntas frequentes

Como atualizo meu encaminhador?

O encaminhador do Linux é constantemente atualizado por um script de shell no Docker imagem. Para atualizar a imagem do Docker, execute o encaminhador.

O que é um contêiner do Docker?

Os contêineres do Docker são como máquinas virtuais que fornecem segurança, isolamento e gerenciamento de recursos.
as máquinas virtuais têm um espaço privilegiado (kernel do Linux) e uma espaço do usuário (tudo com o qual você interage: libc, python, ls, tcpdump etc.).
Contêineres: têm apenas um espaço de usuário, ou seja, tudo com que você interage: libc, python, ls, tcpdump e assim por diante) e depender do espaço de privilégios do host.

Por que distribuir o encaminhador das Operações de segurança do Google usando um contêiner?

Melhor segurança por meio do isolamento:
- O ambiente e os requisitos do cliente não afetam as Operações de segurança do Google encaminhador.
- O ambiente e os requisitos do encaminhador das Operações de segurança do Google não afetam com o cliente.
- O mecanismo de distribuição do contêiner já existe e pode ser particular e separados para o Google Cloud e os clientes. https://cloud.google.com/container-registry/

Você precisa aprender os comandos avançados do Docker?

O encaminhador de Operações de segurança do Google usa um único contêiner, então não é necessário aprender sobre Swarm, orquestração ou outros recursos avançados do Docker conceitos ou comandos.