O poder total da interacción coas API revélase cando se usa xunto co código do programa, cando se fai posible xerar de forma dinámica solicitudes de API e ferramentas para analizar as respostas das API. Non obstante, aínda segue imperceptible Kit de desenvolvemento de software Python (en diante denominado SDK de Python) para API de xestión de puntos de verificación, pero en balde. Simplifica significativamente a vida dos desenvolvedores e dos entusiastas da automatización. Python gañou unha enorme popularidade ultimamente e decidín cubrir o oco e revisar as principais características. . Este artigo serve de excelente complemento a outro sobre Habré . Analizaremos como escribir scripts usando o SDK de Python e analizaremos a nova funcionalidade da API de xestión na versión 1.6 (admitida a partir de R80.40). Para comprender o artigo, necesitarás coñecementos básicos sobre o traballo con API e Python.
Check Point está a desenvolver activamente a API e polo momento lanzáronse os seguintes:
- — traballar co servidor de control a través da API (e a capacidade de executar scripts en pasarelas controladas polo servidor de control)
- - traballar con pasarelas de seguridade
- — traballar cun sandbox na nube Check Point
- — traballar con Identity Awareness blade en pasarelas
- — traballar co portal de xestión da pasarela SMB ()
- — interacción con controladores IoT
- - traballar con (Solución de seguridade SD-WAN)
- - traballar con
Actualmente, o SDK de Python só admite a interacción coa API de xestión e Gaia API. Observaremos as clases, métodos e variables máis importantes deste módulo.
Instalación do módulo
Módulo cpapi instálase de xeito rápido e sinxelo desde coa axuda PIP. As instrucións de instalación detalladas están dispoñibles en . Este módulo está adaptado para traballar coas versións 2.7 e 3.7 de Python. Neste artigo, daranse exemplos usando Python 3.7. Non obstante, o SDK de Python pódese executar directamente desde o servidor de xestión de Check Point (Xestión intelixente), pero só admiten Python 2.7, polo que a última sección proporcionará código para a versión 2.7. Inmediatamente despois de instalar o módulo, recomendo mirar os exemplos dos directorios exemplos_python2 и exemplos_python3.
introdución
Para que poidamos traballar cos compoñentes do módulo cpapi, necesitamos importar desde o módulo cpapi polo menos dúas clases obrigatorias:
Cliente APIC и APIClientArgs
from cpapi import APIClient, APIClientArgs
Clase APIClientArgs é responsable dos parámetros de conexión ao servidor API e á clase Cliente APIC é responsable da interacción coa API.
Determinación dos parámetros de conexión
Para definir varios parámetros para conectarse á API, cómpre crear unha instancia da clase APIClientArgs. En principio, os seus parámetros están predefinidos e ao executar o script no servidor de control non é necesario especificalos.
client_args = APIClientArgs()Pero cando se executa nun servidor de terceiros, cómpre especificar polo menos o enderezo IP ou o nome de host do servidor API (tamén coñecido como servidor de xestión). No seguinte exemplo, definimos o parámetro de conexión do servidor e asignámoslle o enderezo IP do servidor de xestión como unha cadea.
client_args = APIClientArgs(server='192.168.47.241')Vexamos todos os parámetros e os seus valores predeterminados que se poden usar ao conectarse ao servidor API:
Argumentos do método __init__ da clase APIClientArgs
class APIClientArgs:
"""
This class provides arguments for APIClient configuration.
All the arguments are configured with their default values.
"""
# port is set to None by default, but it gets replaced with 443 if not specified
# context possible values - web_api (default) or gaia_api
def __init__(self, port=None, fingerprint=None, sid=None, server="127.0.0.1", http_debug_level=0,
api_calls=None, debug_file="", proxy_host=None, proxy_port=8080,
api_version=None, unsafe=False, unsafe_auto_accept=False, context="web_api"):
self.port = port
# management server fingerprint
self.fingerprint = fingerprint
# session-id.
self.sid = sid
# management server name or IP-address
self.server = server
# debug level
self.http_debug_level = http_debug_level
# an array with all the api calls (for debug purposes)
self.api_calls = api_calls if api_calls else []
# name of debug file. If left empty, debug data will not be saved to disk.
self.debug_file = debug_file
# HTTP proxy server address (without "http://")
self.proxy_host = proxy_host
# HTTP proxy port
self.proxy_port = proxy_port
# Management server's API version
self.api_version = api_version
# Indicates that the client should not check the server's certificate
self.unsafe = unsafe
# Indicates that the client should automatically accept and save the server's certificate
self.unsafe_auto_accept = unsafe_auto_accept
# The context of using the client - defaults to web_api
self.context = contextCreo que os argumentos que se poden usar en instancias da clase APIClientArgs son intuitivos para os administradores de Check Point e non requiren comentarios adicionais.
Conexión mediante APIClient e xestor de contexto
Clase Cliente APIC O xeito máis cómodo de usalo é a través do xestor de contexto. Todo o que hai que pasar a unha instancia da clase APIClient son os parámetros de conexión que se definiron no paso anterior.
with APIClient(client_args) as client:
O xestor de contexto non fará automaticamente unha chamada de inicio de sesión ao servidor da API, pero fará unha chamada de saída ao saír del. Se por algún motivo non é necesario saír despois de rematar de traballar coas chamadas API, debes comezar a traballar sen usar o xestor de contexto:
client = APIClient(clieng_args)Proba de conexión
A forma máis sinxela de comprobar se a conexión cumpre os parámetros especificados é usar o método comprobar_pegada dixital. Se falla a verificación da suma hash sha1 para a impresión dixital do certificado da API do servidor (o método devolto Falso), entón isto adoita ser causado por problemas de conexión e podemos deter a execución do programa (ou darlle ao usuario a oportunidade de corrixir os datos de conexión):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Teña en conta que no futuro a clase Cliente APIC comprobará cada chamada de API (métodos api_call и api_query, falaremos deles un pouco máis adiante) sha1 certificado de impresión dixital no servidor API. Pero se, ao comprobar a impresión dixital sha1 do certificado do servidor API, se detecta un erro (o certificado é descoñecido ou foi modificado), o método comprobar_pegada dixital ofrecerá a oportunidade de engadir/cambiar información sobre ela na máquina local automaticamente. Esta comprobación pódese desactivar por completo (pero só se pode recomendar se os scripts se executan no propio servidor API, ao conectarse a 127.0.0.1), usando o argumento APIClientArgs - unsafe_auto_accept (consulte máis información sobre APIClientArgs anteriormente en "Definición de parámetros de conexión").
client_args = APIClientArgs(unsafe_auto_accept=True)Inicie sesión no servidor API
У Cliente APIC hai ata 3 métodos para iniciar sesión no servidor API, e cada un deles comprende o significado Sid(id da sesión), que se usa automaticamente en cada chamada de API posterior na cabeceira (o nome da cabeceira deste parámetro é X-chkp-sid), polo que non é necesario seguir procesando este parámetro.
método de inicio de sesión
Opción que usa o inicio de sesión e o contrasinal (no exemplo, o nome de usuario admin e o contrasinal 1q2w3e pasan como argumentos posicionais):
login = client.login('admin', '1q2w3e') Tamén están dispoñibles parámetros opcionais adicionais no método de inicio de sesión; aquí están os seus nomes e valores predeterminados:
continue_last_session=False, domain=None, read_only=False, payload=NoneMétodo login_with_api_key
Opción mediante unha clave API (admitida a partir da versión de xestión R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" este é o valor da clave API para un dos usuarios do servidor de xestión co método de autorización da clave API):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') No método login_with_api_key están dispoñibles os mesmos parámetros opcionais que no método Iniciar sesión.
método login_as_root
Opción para iniciar sesión nunha máquina local cun servidor API:
login = client.login_as_root()Só hai dous parámetros opcionais dispoñibles para este método:
domain=None, payload=NoneE finalmente a API chámase a si mesma
Temos dúas opcións para facer chamadas á API mediante métodos api_call и api_query. Imos descubrir cal é a diferenza entre eles.
api_call
Este método é aplicable a calquera chamada. Necesitamos pasar a última parte para a chamada da API e a carga útil no corpo da solicitude se é necesario. Se a carga útil está baleira, non se pode transmitir en absoluto:
api_versions = client.api_call('show-api-versions') Saída desta solicitude debaixo do corte:
In [23]: api_versions
Out[23]:
APIResponse({
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"res_obj": {
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"status_code": 200
},
"status_code": 200,
"success": true
})
show_host = client.api_call('show-host', {'name' : 'h_8.8.8.8'})Saída desta solicitude debaixo do corte:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"res_obj": {
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"status_code": 200
},
"status_code": 200,
"success": true
})
api_query
Permítanme facer unha reserva de inmediato de que este método só é aplicable para as chamadas cuxa saída implica compensación. Tal inferencia prodúcese cando contén ou pode conter unha gran cantidade de información. Por exemplo, pode tratarse dunha solicitude dunha lista de todos os obxectos de host creados no servidor de xestión. Para tales solicitudes, a API devolve unha lista de 50 obxectos por defecto (pode aumentar o límite a 500 obxectos na resposta). E para non tirar a información varias veces, cambiando o parámetro de compensación na solicitude da API, hai un método api_query que fai este traballo automaticamente. Exemplos de chamadas onde se necesita este método: show-sessions, show-hosts, show-networks, show-widcards, show-groups, show-address-ranges, show-simple-gateways, show-simple-clusters, show-access-roles, show-trusted-clients, paquetes de exhibición. De feito, vemos palabras en plural no nome destas chamadas API, polo que estas chamadas serán máis fáciles de manexar api_query
show_hosts = client.api_query('show-hosts') Saída desta solicitude debaixo do corte:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"res_obj": {
"data": {
"from": 1,
"objects": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"to": 2,
"total": 2
},
"status_code": 200
},
"status_code": 200,
"success": true
})
Procesando os resultados das chamadas API
Despois diso podes usar as variables e métodos da clase APIResposta(tanto dentro do xestor de contexto como fóra). Na clase APIResposta Están predefinidos 4 métodos e 5 variables; deterémonos nos máis importantes con máis detalle.
éxito
Para comezar, sería unha boa idea asegurarse de que a chamada API foi exitosa e devolveu un resultado. Hai un método para iso éxito:
In [49]: api_versions.success
Out[49]: True
Devolve True se a chamada á API foi exitosa (código de resposta - 200) e False se non se realizou (calquera outro código de resposta). É conveniente usar inmediatamente despois dunha chamada API para mostrar información diferente dependendo do código de resposta.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) código de estado
Devolve o código de resposta despois de realizar unha chamada á API.
In [62]: api_versions.status_code
Out[62]: 400
Códigos de resposta posibles: 200,400,401,403,404,409,500,501.
set_success_status
Neste caso, pode ser necesario cambiar o valor do estado de éxito. Tecnicamente, podes poñer calquera cousa alí, incluso unha corda normal. Pero un exemplo real sería restablecer este parámetro a Falso en determinadas condicións. A continuación, preste atención ao exemplo cando hai tarefas en execución no servidor de xestión, pero consideraremos que esta solicitude non foi exitosa (fixaremos a variable de éxito en Falso, a pesar de que a chamada á API foi exitosa e devolveu o código 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakresposta ()
O método de resposta permítelle ver o dicionario co código de resposta (status_code) e o corpo da resposta (body).
In [94]: api_versions.response()
Out[94]:
{'status_code': 200,
'data': {'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}
datos
Permítelle ver só o corpo da resposta (corpo) sen información innecesaria.
In [93]: api_versions.data
Out[93]:
{'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}
mensaxe_de_erro
Esta información só está dispoñible cando se produciu un erro ao procesar a solicitude da API (código de resposta non 200). Exemplo de saída
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Exemplos útiles
Os seguintes son exemplos que usan as chamadas API que se engadiron na API de xestión 1.6.
En primeiro lugar, vexamos como funcionan as chamadas engadir-host и Engadir intervalo de enderezos. Digamos que necesitamos crear todos os enderezos IP da subrede 192.168.0.0/24, cuxo último octeto é 5, como obxectos do tipo de host, e escribir todos os demais enderezos IP como obxectos do tipo de intervalo de enderezos. Neste caso, excluír o enderezo da subrede e o enderezo de difusión.
Polo tanto, a continuación móstrase un script que resolve este problema e crea 50 obxectos do tipo host e 51 obxectos do tipo intervalo de enderezos. Para resolver o problema, son necesarias 101 chamadas API (sen contar a chamada de publicación final). Ademais, mediante o módulo timeit, calculamos o tempo que tarda en executar o script ata que se publiquen os cambios.
Script usando add-host e add-address-range
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
first_ip = 1
last_ip = 4
client_args = APIClientArgs(server="192.168.47.240")
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
for ip in range(5,255,5):
add_host = client.api_call("add-host", {"name" : f"h_192.168.0.{ip}", "ip-address": f'192.168.0.{ip}'})
while last_ip < 255:
add_range = client.api_call("add-address-range", {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"})
first_ip+=5
last_ip+=5
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
No meu entorno de laboratorio, este script tarda entre 30 e 50 segundos en executarse, dependendo da carga do servidor de xestión.
Agora imos ver como resolver o mesmo problema usando unha chamada API engadir-obxectos-lote, soporte para o cal se engadiu na versión 1.6 da API. Esta chamada permítelle crear moitos obxectos á vez nunha solicitude de API. Ademais, estes poden ser obxectos de diferentes tipos (por exemplo, hosts, subredes e intervalos de enderezos). Así, a nosa tarefa pódese resolver no marco dunha chamada API.
Script usando add-objects-batch
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}', "ip-address": f'192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_objects_batch = client.api_call("add-objects-batch", data_for_batch)
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
E executar este script no meu entorno de laboratorio leva de 3 a 7 segundos, dependendo da carga do servidor de xestión. É dicir, de media, en 101 obxectos API, unha chamada de tipo lote execútase 10 veces máis rápido. Nun maior número de obxectos a diferenza será aínda máis impresionante.
Agora imos ver como traballar conxunto-obxectos-lote. Usando esta chamada á API, podemos cambiar de forma masiva calquera parámetro. Imos establecer a primeira metade dos enderezos do exemplo anterior (ata .124 anfitrións, e tamén intervalos) na cor sienna e asignar a cor caqui á segunda metade dos enderezos.
Cambiando a cor dos obxectos creados no exemplo anterior
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip_first = []
objects_list_range_first = []
objects_list_ip_second = []
objects_list_range_second = []
for ip in range(5,125,5):
data = {"name": f'h_192.168.0.{ip}', "color": "sienna"}
objects_list_ip_first.append(data)
for ip in range(125,255,5):
data = {"name": f'h_192.168.0.{ip}', "color": "khaki"}
objects_list_ip_second.append(data)
first_ip = 1
last_ip = 4
while last_ip < 125:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "sienna"}
objects_list_range_first.append(data)
first_ip+=5
last_ip+=5
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "khaki"}
objects_list_range_second.append(data)
first_ip+=5
last_ip+=5
data_for_batch_first = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip_first
}, {
"type" : "address-range",
"list" : objects_list_range_first
}]
}
data_for_batch_second = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip_second
}, {
"type" : "address-range",
"list" : objects_list_range_second
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
set_objects_batch_first = client.api_call("set-objects-batch", data_for_batch_first)
set_objects_batch_second = client.api_call("set-objects-batch", data_for_batch_second)
publish = client.api_call("publish")
Podes eliminar varios obxectos nunha chamada API usando eliminar-obxectos-lote. Agora vexamos un exemplo de código que elimina todos os hosts creados anteriormente mediante engadir-obxectos-lote.
Eliminando obxectos usando delete-objects-batch
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
delete_objects_batch = client.api_call("delete-objects-batch", data_for_batch)
publish = client.api_call("publish")
print(delete_objects_batch.data)
Todas as funcións que aparecen nas novas versións do software Check Point adquiren inmediatamente chamadas de API. Así, en R80.40 apareceron "funcións" como Revertir a revisión e Smart Task, e as chamadas API correspondentes preparáronse inmediatamente para elas. Ademais, todas as funcionalidades ao pasar das consolas antigas ao modo Política unificada tamén adquiren compatibilidade con API. Por exemplo, a tan esperada actualización da versión de software R80.40 foi o cambio da política de inspección HTTPS do modo Legacy ao modo de Política unificada, e esta funcionalidade recibiu inmediatamente chamadas de API. Aquí tes un exemplo de código que engade unha regra á posición superior da política de inspección HTTPS que exclúe 3 categorías da inspección (Saúde, Finanzas, Servizos gobernamentais), que están prohibidas de conformidade coa lei en varios países.
Engade unha regra á política de inspección HTTPS
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Legal Requirements",
"action": "bypass",
"site-category": ["Health", "Government / Military", "Financial Services"]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_https_rule = client.api_call("add-https-rule", data)
publish = client.api_call("publish")
Execución de scripts de Python no servidor de xestión de Check Point
Todo é igual contén información sobre como executar scripts de Python directamente desde o servidor de control. Isto pode ser conveniente cando non podes conectarte ao servidor da API desde outra máquina. Gravei un vídeo de seis minutos no que miro a instalación do módulo cpapi e características de execución de scripts de Python no servidor de control. Por exemplo, execútase un script que automatiza a configuración dunha nova pasarela para unha tarefa como a auditoría de rede. Comprobación de seguridade. Entre as características que tiven que tratar: a función aínda non apareceu en Python 2.7 entrada, polo que para procesar a información que introduce o usuario utilízase unha función entrada_en bruto. Se non, o código é o mesmo que para o lanzamento doutras máquinas, só que é máis cómodo usar a función login_as_root, para non volver a especificar o seu propio nome de usuario, contrasinal e enderezo IP do servidor de xestión.
Script para a configuración rápida de Security CheckUp
from __future__ import print_function
import getpass
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from cpapi import APIClient, APIClientArgs
def main():
with APIClient() as client:
# if client.check_fingerprint() is False:
# print("Could not get the server's fingerprint - Check connectivity with the server.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Login failed:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Enter the gateway name:")
gw_ip = raw_input("Enter the gateway IP address:")
if sys.stdin.isatty():
sic = getpass.getpass("Enter one-time password for the gateway(SIC): ")
else:
print("Attention! Your password will be shown on the screen!")
sic = raw_input("Enter one-time password for the gateway(SIC): ")
version = raw_input("Enter the gateway version(like RXX.YY):")
add_gw = client.api_call("add-simple-gateway", {'name' : gw_name, 'ipv4-address' : gw_ip, 'one-time-password' : sic, 'version': version.capitalize(), 'application-control' : 'true', 'url-filtering' : 'true', 'ips' : 'true', 'anti-bot' : 'true', 'anti-virus' : 'true', 'threat-emulation' : 'true'})
if add_gw.success and add_gw.data['sic-state'] != "communicating":
print("Secure connection with the gateway hasn't established!")
exit(1)
elif add_gw.success:
print("The gateway was added successfully.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Failed to add the gateway - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Network", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("The policy has been changed successfully")
else:
print("Failed to change the policy- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Cleanup rule", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
if change_rule.success:
print("The cleanup rule has been changed successfully")
else:
print("Failed to change the cleanup rule- {}".format(change_rule.error_message))
# publish the result
publish_res = client.api_call("publish", {})
if publish_res.success:
print("The changes were published successfully.")
else:
print("Failed to publish the changes - {}".format(install_tp_policy.error_message))
install_access_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'true', "threat-prevention" : 'false', "targets" : gw_uid})
if install_access_policy.success:
print("The access policy has been installed")
else:
print("Failed to install access policy - {}".format(install_tp_policy.error_message))
install_tp_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'false', "threat-prevention" : 'true', "targets" : gw_uid})
if install_tp_policy.success:
print("The threat prevention policy has been installed")
else:
print("Failed to install threat prevention policy - {}".format(install_tp_policy.error_message))
# add passwords and passphrases to dictionary
with open('additional_pass.conf') as f:
line_num = 0
for line in f:
line_num += 1
add_password_dictionary = client.api_call("run-script", {"script-name" : "Add passwords and passphrases", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("The password dictionary line {} was added successfully".format(line_num))
else:
print("Failed to add the dictionary - {}".format(add_password_dictionary.error_message))
main() Un ficheiro de exemplo cun dicionario de contrasinais additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Conclusión
Este artigo examina só as posibilidades básicas de traballo SDK de Python e módulo cpapi(como poderías adiviñar, estes son en realidade sinónimos), e ao estudar o código deste módulo descubrirás aínda máis posibilidades de traballar con el. É posible que queira complementalo coas súas propias clases, funcións, métodos e variables. Sempre podes compartir o teu traballo e ver outros guións para Check Point na sección na comunidade , que reúne tanto a desenvolvedores de produtos como usuarios.
Feliz codificación e grazas por ler ata o final!
Fonte: www.habr.com