Plná síla interakce s API se projeví při použití společně s programovým kódem, kdy je možné dynamicky generovat API požadavky a nástroje pro analýzu odpovědí API. Stále však zůstává nepostřehnutelný Python Software Development Kit (dále jen Python SDK) pro Check Point Management API, ale marně. Výrazně zjednodušuje život vývojářům a nadšencům do automatizace. Python si v poslední době získal obrovskou popularitu a rozhodl jsem se vyplnit mezeru a přezkoumat hlavní funkce. . Tento článek slouží jako vynikající doplněk k dalšímu článku o Habrém . Podíváme se na to, jak psát skripty pomocí Python SDK, a blíže se podíváme na novou funkci Management API ve verzi 1.6 (podporovaná od R80.40). K pochopení článku budete potřebovat základní znalosti práce s API a Pythonem.
Check Point aktivně vyvíjí API a v tuto chvíli byly vydány následující:
- — práce s řídicím serverem přes API (a schopnost spouštět skripty na branách řízených řídicím serverem)
- — práce s bezpečnostními bránami
- — práce s sandboxem v cloudu Check Point
- — práce s nástrojem Identity Awareness na branách
- — pracovat s portálem pro správu brány SMB ()
- — interakce s ovladači internetu věcí
- - pracovat s (bezpečnostní řešení SD-WAN)
- - pracovat s
Python SDK aktuálně podporuje pouze interakci s Management API a Gaia API. V tomto modulu se podíváme na nejdůležitější třídy, metody a proměnné.
Instalace modulu
Modul cpapi instaluje se rychle a snadno z přes jádro. Podrobné pokyny k instalaci jsou k dispozici v . Tento modul je přizpůsoben pro práci s Pythonem verze 2.7 a 3.7. V tomto článku budou uvedeny příklady pomocí Pythonu 3.7. Python SDK však lze spustit přímo z Check Point Management Server (Smart Management), ale podporují pouze Python 2.7, takže poslední část bude obsahovat kód pro verzi 2.7. Ihned po instalaci modulu doporučuji podívat se na příklady v adresářích example_python2 и example_python3.
Začínáme
Abychom mohli pracovat s komponentami modulu cpapi, musíme z modulu importovat cpapi alespoň dvě povinné třídy:
APIClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Třída APIClientArgs je zodpovědný za parametry připojení k serveru API a třídě APIClient je zodpovědný za interakci s API.
Určení parametrů připojení
Chcete-li definovat různé parametry pro připojení k rozhraní API, musíte vytvořit instanci třídy APIClientArgs. Jeho parametry jsou v zásadě předdefinované a při spuštění skriptu na řídicím serveru je není nutné zadávat.
client_args = APIClientArgs()Pokud však běží na hostiteli třetí strany, musíte zadat alespoň IP adresu nebo název hostitele serveru API (známého také jako server pro správu). V níže uvedeném příkladu definujeme parametr připojení k serveru a přiřadíme mu IP adresu management serveru jako řetězec.
client_args = APIClientArgs(server='192.168.47.241')Podívejme se na všechny parametry a jejich výchozí hodnoty, které lze použít při připojení k serveru API:
Argumenty metody __init__ třídy 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 = contextVěřím, že argumenty, které lze použít v instancích třídy APIClientArgs, jsou pro správce Check Pointu intuitivní a nevyžadují další komentáře.
Připojení přes APIClient a kontextový manažer
Třída APIClient Nejpohodlnější způsob použití je prostřednictvím správce kontextu. Vše, co je třeba předat instanci třídy APIClient, jsou parametry připojení, které byly definovány v předchozím kroku.
with APIClient(client_args) as client:
Správce kontextu automaticky nezavolá přihlášení k serveru API, ale při jeho ukončení provede odhlášení. Pokud z nějakého důvodu není po dokončení práce s voláním API vyžadováno odhlášení, musíte začít pracovat bez použití správce kontextu:
client = APIClient(clieng_args)Kontrola připojení
Nejjednodušší způsob, jak zkontrolovat, zda připojení splňuje zadané parametry, je pomocí metody check_fingerprint. Pokud se ověření součtu hash sha1 pro otisk certifikátu API serveru nezdaří (vrácená metoda Falešný), pak je to obvykle způsobeno problémy s připojením a můžeme zastavit provádění programu (nebo dát uživateli příležitost opravit údaje o připojení):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Upozorňujeme, že v budoucnu tř APIClient zkontroluje každé volání API (metody api_call и api_query, budeme o nich mluvit trochu dále) certifikát otisku prstu sha1 na serveru API. Pokud se však při kontrole otisku sha1 certifikátu serveru API zjistí chyba (certifikát je neznámý nebo byl změněn), metoda check_fingerprint poskytne možnost automaticky přidat/změnit informace o něm na místním počítači. Tuto kontrolu lze zcela zakázat (ale lze to doporučit pouze v případě, že jsou skripty spouštěny na samotném serveru API při připojování k 127.0.0.1), pomocí argumentu APIClientArgs - unsafe_auto_accept (více o APIClientArgs viz dříve v části „Definování parametrů připojení“).
client_args = APIClientArgs(unsafe_auto_accept=True)Přihlaste se k serveru API
У APIClient existují až 3 způsoby přihlášení k serveru API a každý z nich chápe význam sid(session-id), který se automaticky použije v každém následujícím volání API v hlavičce (název v hlavičce tohoto parametru je X-chkp-sid), takže není potřeba tento parametr dále zpracovávat.
způsob přihlášení
Možnost pomocí přihlašovacího jména a hesla (v příkladu jsou uživatelské jméno admin a heslo 1q2w3e předány jako poziční argumenty):
login = client.login('admin', '1q2w3e') V metodě přihlášení jsou k dispozici také další volitelné parametry, zde jsou jejich názvy a výchozí hodnoty:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetoda Login_with_api_key
Možnost použití klíče API (podporováno od verze pro správu R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" toto je hodnota klíče API pro jednoho z uživatelů na serveru pro správu s metodou autorizace klíče API):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') V metodě login_with_api_key jsou k dispozici stejné volitelné parametry jako v metodě přihlásit se.
metoda login_as_root
Možnost přihlášení k místnímu počítači pomocí serveru API:
login = client.login_as_root()Pro tuto metodu jsou k dispozici pouze dva volitelné parametry:
domain=None, payload=NoneA nakonec API volá sama sebe
Máme dvě možnosti, jak provádět volání API prostřednictvím metod api_call и api_query. Pojďme zjistit, jaký je mezi nimi rozdíl.
api_call
Tato metoda je použitelná pro všechna volání. V těle požadavku musíme v případě potřeby předat poslední část pro volání api a užitečné zatížení. Pokud je užitečné zatížení prázdné, nelze jej vůbec přenést:
api_versions = client.api_call('show-api-versions') Výstup pro tento požadavek pod řezem:
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'})Výstup pro tento požadavek pod řezem:
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
Okamžitě mi dovolte učinit rezervaci, že tato metoda je použitelná pouze pro volání, jejichž výstup zahrnuje offset. K takovému závěru dochází, když obsahuje nebo může obsahovat velké množství informací. Může to být například požadavek na seznam všech vytvořených hostitelských objektů na serveru pro správu. Pro takové požadavky rozhraní API ve výchozím nastavení vrací seznam 50 objektů (limit můžete v odpovědi zvýšit na 500 objektů). A aby se informace nevytahovaly několikrát při změně parametru offset v požadavku API, existuje metoda api_query, která to dělá automaticky. Příklady volání, kde je tato metoda potřebná: show-session, show-hostitelé, show-networks, show-widcards, show-groups, show-address-ranges, show-simple-gateways, show-simple-clusters, show-access-role, show-důvěryhodní-klienti, výstavní balíčky. Ve skutečnosti vidíme v názvech těchto volání API slova v množném čísle, takže tato volání bude snazší zvládnout api_query
show_hosts = client.api_query('show-hosts') Výstup pro tento požadavek pod řezem:
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
})
Zpracování výsledků volání API
Poté můžete použít proměnné a metody třídy APIResponse(jak uvnitř kontextového manažera, tak mimo něj). Ve třídě APIResponse Předdefinovány jsou 4 metody a 5 proměnných, u těch nejdůležitějších se zastavíme podrobněji.
úspěch
Pro začátek by bylo dobré se ujistit, že volání API bylo úspěšné a vrátilo výsledek. Existuje na to metoda úspěch:
In [49]: api_versions.success
Out[49]: True
Vrátí True, pokud bylo volání API úspěšné (kód odezvy - 200) a False, pokud nebylo úspěšné (jakýkoli jiný kód odezvy). Je vhodné použít ihned po volání API k zobrazení různých informací v závislosti na kódu odpovědi.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) stavový kód
Vrátí kód odpovědi po provedení volání API.
In [62]: api_versions.status_code
Out[62]: 400
Možné kódy odpovědí: 200,400,401,403,404,409,500,501.
set_success_status
V tomto případě může být nutné změnit hodnotu stavu úspěchu. Technicky tam můžete dát cokoliv, i obyčejný provázek. Ale skutečným příkladem by bylo resetování tohoto parametru na False za určitých doprovodných podmínek. Níže věnujte pozornost příkladu, kdy na serveru pro správu běží úlohy, ale tento požadavek budeme považovat za neúspěšný (proměnnou úspěchu nastavíme na Falešný, navzdory skutečnosti, že volání API bylo úspěšné a vrátilo kód 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakOdezva()
Metoda odezvy umožňuje zobrazit slovník s kódem odezvy (kód_stavu) a tělem odpovědi (tělo).
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']}}
datum
Umožňuje zobrazit pouze tělo odpovědi (tělo) bez zbytečných informací.
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']}
chybové hlášení
Tyto informace jsou dostupné pouze v případě, že při zpracování požadavku API došlo k chybě (kód odpovědi ne 200). Příklad výstupu
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Užitečné příklady
Následují příklady, které používají volání API, která byla přidána v Management API 1.6.
Nejprve se podívejme, jak fungují hovory přidat hostitele и add-address-range. Řekněme, že potřebujeme vytvořit všechny IP adresy podsítě 192.168.0.0/24, jejíž poslední oktet je 5, jako objekty typu hostitel a všechny ostatní IP adresy zapsat jako objekty typu rozsahu adres. V tomto případě vylučte adresu podsítě a adresu vysílání.
Níže je tedy skript, který řeší tento problém a vytváří 50 objektů typu hostitel a 51 objektů typu rozsah adres. K vyřešení problému je potřeba 101 volání API (nepočítaje poslední volání publikování). Pomocí modulu timeit také vypočítáme čas potřebný k provedení skriptu, než budou změny publikovány.
Skript pomocí add-host a 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')
V mém laboratorním prostředí trvá spuštění tohoto skriptu 30 až 50 sekund v závislosti na zatížení serveru pro správu.
Nyní se podívejme, jak vyřešit stejný problém pomocí volání API přidat-objekty-dávka, jehož podpora byla přidána ve verzi API 1.6. Toto volání vám umožňuje vytvořit mnoho objektů najednou v jednom požadavku API. Navíc to mohou být objekty různých typů (například hostitelé, podsítě a rozsahy adres). Náš úkol tak lze vyřešit v rámci jednoho volání API.
Skript pomocí 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')
A spuštění tohoto skriptu v mém laboratorním prostředí trvá 3 až 7 sekund, v závislosti na zatížení serveru pro správu. To znamená, že v průměru na 101 objektech API běží volání dávkového typu 10krát rychleji. Na větším počtu objektů bude rozdíl ještě působivější.
Nyní se podívejme, jak s ním pracovat set-objects-batch. Pomocí tohoto volání API můžeme hromadně změnit libovolný parametr. Nastavme první polovinu adres z předchozího příkladu (až do 124 hostitelů a také rozsahy) na barvu sienna a přiřaďme barvu khaki druhé polovině adres.
Změna barvy objektů vytvořených v předchozím příkladu
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")
Pomocí jednoho volání API můžete odstranit více objektů smazat-objekty-dávka. Nyní se podívejme na příklad kódu, který odstraní všechny hostitele vytvořené dříve prostřednictvím přidat-objekty-dávka.
Mazání objektů pomocí 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)
Všechny funkce, které se objevují v nových verzích softwaru Check Point, okamžitě získávají volání API. V R80.40 se tedy objevily takové „funkce“ jako Revert to revision a Smart Task a pro ně byla okamžitě připravena odpovídající API volání. Navíc všechny funkce při přechodu ze starších konzolí do režimu Unified Policy také získávají podporu API. Například dlouho očekávanou aktualizací ve verzi softwaru R80.40 byl přesun zásady kontroly HTTPS z režimu Legacy do režimu Unified Policy a tato funkce okamžitě přijala volání API. Zde je příklad kódu, který přidává na nejvyšší pozici zásady kontroly HTTPS pravidlo, které vylučuje z kontroly 3 kategorie (Zdraví, Finance, Státní služby), které jsou v souladu se zákonem v řadě zemí zakázány.
Přidejte pravidlo do zásad kontroly 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")
Spouštění skriptů Python na serveru pro správu Check Point
Všechno je stejné obsahuje informace o tom, jak spouštět skripty Pythonu přímo z řídicího serveru. To může být výhodné, když se nemůžete připojit k serveru API z jiného počítače. Natočil jsem šestiminutové video, ve kterém se dívám na instalaci modulu cpapi a funkce spouštění skriptů Python na řídicím serveru. Jako příklad je spuštěn skript, který automatizuje konfiguraci nové brány pro úlohu, jako je audit sítě Kontrola zabezpečení. Mezi funkcemi, se kterými jsem se musel vypořádat: funkce se ještě neobjevila v Pythonu 2.7 vstup, takže ke zpracování informací, které uživatel zadá, se používá funkce Hrubý vstup. Jinak je kód stejný jako pro spouštění z jiných strojů, jen je pohodlnější používat funkci login_as_root, abyste znovu neuváděli své vlastní uživatelské jméno, heslo a IP adresu serveru pro správu.
Skript pro rychlé nastavení 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() Příklad souboru se slovníkem hesel Additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Závěr
Tento článek zkoumá pouze základní možnosti práce Python SDK a modul cpapi(jak asi tušíte, jsou to vlastně synonyma) a studiem kódu v tomto modulu objevíte ještě další možnosti práce s ním. Je možné, že jej budete chtít doplnit o vlastní třídy, funkce, metody a proměnné. Vždy můžete sdílet svou práci a zobrazit další skripty pro Check Point v sekci v komunitě , která sdružuje jak produktové vývojáře, tak uživatele.
Hodně štěstí při kódování a díky za přečtení až do konce!
Zdroj: www.habr.com