Ponto de verificação API R80.10. Controle via CLI, scripts e muito mais

Tenho certeza de que todos que já trabalharam com Check Point, houve uma reclamação sobre impossibilidade de editar a configuração na linha de comando. Isto é especialmente estranho para quem já trabalhou com Cisco ASA, onde absolutamente tudo pode ser configurado na CLI. Com a Check Point é o contrário - todas as configurações de segurança foram realizadas exclusivamente a partir da interface gráfica. No entanto, algumas coisas são completamente inconvenientes de serem feitas através da GUI (mesmo uma tão conveniente quanto a do Check Point). Por exemplo, a tarefa de adicionar 100 novos hosts ou redes torna-se um procedimento longo e tedioso. Para cada objeto você terá que clicar várias vezes com o mouse e inserir o endereço IP. O mesmo se aplica à criação de um grupo de sites ou à ativação/desativação em massa de assinaturas IPS. Neste caso, existe uma grande probabilidade de cometer um erro.

Um “milagre” aconteceu há relativamente pouco tempo. Com o lançamento da nova versão Gaia R80 a oportunidade foi anunciada Uso de API, o que abre amplas oportunidades para automatizar configurações, administração, monitoramento, etc. Agora você pode:

• criar objetos;
• adicionar ou editar listas de acesso;
• ativar/desativar lâminas;
• configurar interfaces de rede;
• instalar políticas;
• И многое другое.

Para ser sincero, não entendo como essa notícia passou por Habr. Neste artigo descreveremos brevemente como usar a API e forneceremos vários exemplos práticos. Configurações do CheckPoint usando scripts.

Gostaria de fazer uma reserva desde já que a API é utilizada apenas para o servidor de Gerenciamento. Aqueles. Ainda é impossível gerenciar gateways sem um servidor de gerenciamento.

Quem pode usar esta API em princípio?

1. Administradores de sistema que desejam simplificar ou automatizar tarefas rotineiras de configuração do Check Point;
2. Empresas que pretendam integrar a Check Point com outras soluções (sistemas de virtualização, sistemas de tickets, sistemas de gestão de configuração, etc.);
3. Integradores de sistemas que desejam padronizar configurações ou criar produtos adicionais relacionados à Check Point.

Esquema típico

Então, vamos imaginar um esquema típico com Check Point:

Como de costume, temos um gateway (SG), servidor de gerenciamento (SMS) e console de administração (SmartConsole). Nesse caso, o processo normal de configuração do gateway é assim:

Aqueles. Primeiro você precisa executar no computador do administrador SmartConsole, com o qual nos conectamos ao servidor de gerenciamento (SMS). As configurações de segurança são feitas no SMS e só então aplicadas (política de instalação) para o gateway (SG).

Quando se utiliza o API de gerenciamento, podemos basicamente pular o primeiro ponto (iniciar o SmartConsole) e usar Comandos de API diretamente para o servidor de gerenciamento (SMS).

Maneiras de usar a API

Existem quatro maneiras principais de editar a configuração usando a API:

1) Usando o utilitário mgmt_cli

Exemplo - # mgmt_cli adiciona nome do host host1 endereço IP 192.168.2.100
Este comando é executado a partir da linha de comando do Management Server (SMS). Acho que a sintaxe do comando é clara - host1 é criado com o endereço 192.168.2.100.

2) Insira comandos API via clish (no modo especialista)

Basicamente, tudo que você precisa fazer é fazer login na linha de comando (login do gerente) na conta usada ao conectar via SmartConsole (ou conta root). Então você pode entrar Comandos de API (neste caso não há necessidade de usar o utilitário antes de cada comando mgmt_cli). Você pode criar completo Scripts BASH. Um exemplo de script criado pelo host:

script bash

#!/bin/bash

main() {
    clear

    #LOGIN (don't ask for username and password, user is already logged in to Management server as 'root' user)
    mgmt_cli login --root true > id_add_host.txt
    on_error_print_and_exit "Error: Failed to login, check that the server is up and running (run 'api status')"

    #READ HOST NAME
    printf "Enter host name:n"
    read -e host_name
    on_empty_input_print_and_exit "$host_name" "Error: The host's name cannot be empty."

    #READ IP ADDRESS
    printf "nEnter host IP address:n"
    read -e ip
    on_empty_input_print_and_exit "$ip" "Error: The host's IP address cannot be empty."

    #CREATE HOST
    printf "Creating new host: $host_name with IP address: $ipn"
    new_host_response=$(mgmt_cli add host name $host_name ip-address $ip -s id_add_host.txt 2> /dev/null)
    on_error_print_and_exit "Error: Failed to create host object. n$new_host_response"

    #PUBLISH THE CHANGES
    printf "nPublishing the changesn"
    mgmt_cli publish --root true -s id_add_host.txt &> /dev/null
    on_error_print_and_exit "Error: Failed to publish the changes."

    #LOGOUT
    logout
	
	printf "Done.n"
}

logout(){
	mgmt_cli logout --root true -s id_add_host.txt &> /dev/null
}

on_error_print_and_exit(){
    if [ $? -ne 0 ]; then
        handle_error "$1" 
	fi
}

handle_error(){
    printf "n$1n" #print error message
    mgmt_cli discard --root true -s id_add_host.txt &> /dev/null
    logout
    exit 1
}

on_empty_input_print_and_exit(){
	if [ -z "$1" ]; then
		printf "$2n" #print error message
		logout
		exit 0
	fi
}

# Script starts here. Call function "main".
main

Se você estiver interessado, pode assistir ao vídeo correspondente:

3) Via SmartConsole abrindo a janela CLI

Tudo que você precisa fazer é abrir a janela CLI direto de SmartConsole, conforme mostrado na imagem abaixo.

Nesta janela, você pode começar imediatamente a inserir comandos de API.

4) Serviços da Web. Usar solicitação de postagem HTTPS (API REST)

Na nossa opinião, este é um dos métodos mais promissores, porque permite que você “construa” aplicativos inteiros com base em gerenciamento de servidor de gerenciamento (desculpe pela tautologia). A seguir veremos esse método com um pouco mais de detalhes.

Para resumir:

1. API + cli mais adequado para pessoas acostumadas com a Cisco;
2. API + shell para aplicação de scripts e execução de tarefas rotineiras;
3. API REST para automação.

Habilitando a API

Por padrão, a API está habilitada em servidores de gerenciamento com mais de 4 GB de RAM e configurações autônomas com mais de 8 GB de RAM. Você pode verificar o status usando o comando: status da API

Se descobrir que a API está desabilitada, é muito fácil habilitá-la via SmartConsole: Gerenciar e configurações > Blades > API de gerenciamento > Configurações avançadas

Em seguida, publique (Publique) muda e execute o comando reinicialização da API.

Solicitações da Web + Python

Para executar comandos de API, você pode usar solicitações da Web usando Python e bibliotecas pedidos, json. Em geral, a estrutura de uma solicitação web consiste em três partes:

1)Endereço

(https://<managemenet server>:<port>/web_api/<command>) 

2) Cabeçalhos HTTP

content-Type: application/json
x-chkp-sid: <session ID token as returned by the login command>

3) Solicitar carga útil

Texto em formato JSON contendo os diferentes parâmetros

Exemplo para chamar vários comandos:

def api_call(ip_addr, port, command, json_payload, sid):
    url = 'https://' + ip_addr + ':' + str(port) + '/web_api/' + command
    if sid == “”:
        request_headers = {'Content-Type' : 'application/json'}
    else:
        request_headers = {'Content-Type' : 'application/json', 'X-chkp-sid' : sid}
    r = requests.post(url,data=json.dumps(json_payload), headers=request_headers,verify=False)
    return r.json()                                        
'xxx.xxx.xxx.xxx' -> Ip address GAIA

Aqui estão algumas tarefas típicas que você encontra com mais frequência ao administrar o Check Point.

1) Exemplo de funções de autorização e logout:

Escrita

    payload = {‘user’: ‘your_user’, ‘password’ : ‘your_password’}
    response = api_call('xxx.xxx.xxx.xxx', 443, 'login',payload, '')
    return response["sid"]

    response = api_call('xxx.xxx.xxx.xxx', 443,'logout', {} ,sid)
    return response["message"]

2) Ligando os blades e configurando a rede:

Escrita

new_gateway_data = {'name':'CPGleb','anti-bot':True,'anti-virus' : True,'application-control':True,'ips':True,'url-filtering':True,'interfaces':
                    [{'name':"eth0",'topology':'external','ipv4-address': 'xxx.xxx.xxx.xxx',"ipv4-network-mask": "255.255.255.0"},
                     {'name':"eth1",'topology':'internal','ipv4-address': 'xxx.xxx.xxx.xxx',"ipv4-network-mask": "255.255.255.0"}]}
new_gateway_result = api_call('xxx.xxx.xxx.xxx', 443,'set-simple-gateway', new_gateway_data ,sid)
print(json.dumps(new_gateway_result))

3) Alteração das regras do firewall:

Escrita

new_access_data={'name':'Cleanup rule','layer':'Network','action':'Accept'}
new_access_result = api_call('xxx.xxx.xxx.xxx', 443,'set-access-rule', new_access_data ,sid)
print(json.dumps(new_access_result))

4) Adicionando camada de aplicativo:

Escrita

add_access_layer_application={ 'name' : 'application123',"applications-and-url-filtering" : True,"firewall" : False}
add_access_layer_application_result = api_call('xxx.xxx.xxx.xxx', 443,'add-access-layer', add_access_layer_application ,sid)
print(json.dumps(add_access_layer_application_result))

set_package_layer={"name" : "Standard","access":True,"access-layers" : {"add" : [ { "name" : "application123","position" :2}]} ,"installation-targets" : "CPGleb"}
set_package_layer_result = api_call('xxx.xxx.xxx.xxx', 443,'set-package', set_package_layer ,sid)
print(json.dumps(set_package_layer_result))

5) Publique e defina a política, verifique a execução do comando (task-id):

Escrita

publish_result = api_call('xxx.xxx.xxx.xxx', 443,"publish", {},sid)
print("publish result: " + json.dumps(publish_result))
new_policy = {'policy-package':'Standard','access':True,'targets':['CPGleb']}
new_policy_result = api_call('xxx.xxx.xxx.xxx', 443,'install-policy', new_policy ,sid)
print(json.dumps(new_policy_result)

task_id=(json.dumps(new_policy_result ["task-id"]))
len_str=len(task_id)
task_id=task_id[1:(len_str-1)]
show_task_id ={'task-id':(task_id)}
show_task=api_call('xxx.xxx.xxx.xxx',443,'show-task',show_task_id,sid)
print(json.dumps(show_task))

6) Adicionar anfitrião:

Escrita

new_host_data = {'name':'JohnDoePc', 'ip-address': '192.168.0.10'}
new_host_result = api_call('xxx.xxx.xxx.xxx', 443,'add-host', new_host_data ,sid)
print(json.dumps(new_host_result))

7) Adicione um campo Prevenção contra ameaças:

Escrita

set_package_layer={'name':'Standard','threat-prevention' :True,'installation-targets':'CPGleb'}
set_package_layer_result = api_call('xxx.xxx.xxx.xxx', 443,'set-package',set_package_layer,sid)
print(json.dumps(set_package_layer_result))

8) Veja a lista de sessões

Escrita

new_session_data = {'limit':'50', 'offset':'0','details-level' : 'standard'}
new_session_result = api_call('xxx.xxx.xxx.xxx', 443,'show-sessions', new_session_data ,sid)
print(json.dumps(new_session_result))

9) Crie um novo perfil:

Escrita

add_threat_profile={'name':'Apeiron', "active-protections-performance-impact" : "low","active-protections-severity" : "low or above","confidence-level-medium" : "prevent",
  "confidence-level-high" : "prevent", "threat-emulation" : True,"anti-virus" : True,"anti-bot" : True,"ips" : True,
  "ips-settings" : { "newly-updated-protections" : "staging","exclude-protection-with-performance-impact" : True,"exclude-protection-with-performance-impact-mode" : "High or lower"},
  "overrides" : [ {"protection" : "3Com Network Supervisor Directory Traversal","capture-packets" : True,"action" : "Prevent","track" : "Log"},
                  {"protection" : "7-Zip ARJ Archive Handling Buffer Overflow", "capture-packets" : True,"action" : "Prevent","track" : "Log"} ]}
add_threat_profile_result=api_call('xxx.xxx.xxx.xxx',443,'add-threat-profile',add_threat_profile,sid)
print(json.dumps(add_threat_profile_result))  

10) Altere a ação para a assinatura IPS:

Escrita

set_threat_protection={
  "name" : "3Com Network Supervisor Directory Traversal",
  "overrides" : [{ "profile" : "Apeiron","action" : "Detect","track" : "Log","capture-packets" : True},
    { "profile" : "Apeiron", "action" : "Detect", "track" : "Log", "capture-packets" : False} ]}
set_threat_protection_result=api_call('xxx.xxx.xxx.xxx',443,'set-threat-protection',set_threat_protection,sid)
print(json.dumps(set_threat_protection_result))

11) Adicione seu serviço:

Escrita

add_service_udp={    "name" : "Dota2_udp", "port" : '27000-27030',
"keep-connections-open-after-policy-installation" : False,
"session-timeout" : 0, "match-for-any" : True,
"sync-connections-on-cluster" : True,
"aggressive-aging" : {"enable" : True, "timeout" : 360,"use-default-timeout" : False  },
"accept-replies" : False}
add_service_udp_results=api_call('xxx.xxx.xxx.xxx',443,"add-service-udp",add_service_udp,sid)
print(json.dumps(add_service_udp_results))

12) Adicione uma categoria, site ou grupo:

Escrita

add_application_site_category={  "name" : "Valve","description" : "Valve Games"}
add_application_site_category_results=api_call('xxx.xxx.xxx.xxx',443,"add-application-site-category",add_application_site_category,sid)
print(json.dumps(add_application_site_category_results))

add_application_site={    "name" : "Dota2", "primary-category" : "Valve",  "description" : "Dotka",
  "url-list" : [ "www.dota2.ru" ], "urls-defined-as-regular-expression" : False}
add_application_site_results=api_call('xxx.xxx.xxx.xxx',443,"add-application-site " , 
add_application_site , sid)
print(json.dumps(add_application_site_results))

add_application_site_group={"name" : "Games","members" : [ "Dota2"]}
add_application_site_group_results=api_call('xxx.xxx.xxx.xxx',443,"add-application-site-group",add_application_site_group,sid)
print(json.dumps(add_application_site_group_results))

Além disso, com a ajuda API da web você pode adicionar e remover redes, hosts, funções de acesso, etc. As lâminas podem ser personalizadas Antivírus, Antibot, IPS, VPN. É ainda possível instalar licenças usando o comando script de execução. Todos os comandos da API Check Point podem ser encontrados aqui aqui.

API Check Point + Carteiro

Também conveniente de usar API da Web do ponto de verificação em conjunção com Postman. Postman possui versões desktop para Windows, Linux e MacOS. Além disso, existe um plugin para Google Chrome. Isso é o que usaremos. Primeiro você precisa encontrar o Postman na Google Chrome Store e instalar:

Usando este utilitário, poderemos gerar solicitações da Web para a API Check Point. Para não lembrar de todos os comandos da API, é possível importar as chamadas coleções (templates), que já contêm todos os comandos necessários:

é você vai encontrar coleção para R80.10. Após a importação, os modelos de comandos da API estarão disponíveis para nós:

Na minha opinião, isso é muito conveniente. Você pode começar a desenvolver aplicativos rapidamente usando a API Check Point.

Ponto de verificação + Ansible

Gostaria também de salientar que existe Ansible módulo para API CheckPoint. O módulo permite gerenciar configurações, mas não é tão conveniente para resolver problemas exóticos. Escrever scripts em qualquer linguagem de programação oferece soluções mais flexíveis e convenientes.

Jogar aviator online grátis: hack aviator funciona

É aqui que provavelmente terminaremos nossa breve revisão da API Check Point. Na minha opinião, esse recurso era muito esperado e necessário. O surgimento da API abre oportunidades muito amplas para administradores de sistemas e integradores de sistemas que trabalham com produtos Check Point. Orquestração, automação, feedback SIEM... tudo é possível agora.

PS Mais artigos sobre Check Point como sempre você pode encontrá-lo em nosso blog Habr ou no blog em On-line.

PSS Para questões técnicas relacionadas à configuração do Check Point, você pode aqui

Apenas usuários registrados podem participar da pesquisa. Entrarpor favor

Você está planejando usar a API?

• 70,6%sim12

• 23,5%No4

• 5,9%Já estou usando1

17 usuários votaram. 3 usuários se abstiveram.

Fonte: habr.com