Celá sila interakcie s API sa prejavuje pri spolupráci s programovým kódom, keď vznikajú možnosti dynamicky vytvárať API požiadavky a nástroje na analýzu odpovedí API. Avšak, doteraz zostáva málo viditeľný Python Software Development Kit (ďalej len Python SDK) pre Check Point Management API, čo je škoda. Výrazne uľahčuje život vývojárom a nadšencom automatizácie. Python sa v poslednej dobe teší obrovskej popularite a rozhodol som sa zaplniť medzeru a vykonať prehľad hlavných možností . Tento článok slúži ako vynikajúce doplnenie iného článku na Habr . My sa pozrieme, ako napísať skripty s využitím Python SDK a podrobnejšie sa zastavíme na novej funkcionalite Management API vo verzii 1.6 (podporovanej od R80.40). Na pochopenie článku budú potrebné základné znalosti o práci s API a Python.
Check Point aktívne rozvíja API a v súčasnosti sa objavili:
- — práca so serverom správy cez API (a možnosť vykonávať skripty na bránach riadených serverom správy)
- — práca so zabezpečovacími bránami
- — práca s pieskoviskom v cloude Check Point
- — práca s blade Identity Awareness na bránach
- — práca s portálom správy SMB brán ()
- — interakcia s IoT kontrolérmi
- — práca s (riešenie SD-WAN security)
- — práca s
Python SDK v súčasnosti podporuje interakciu iba s Management API a Gaia API. My sa pozrieme na najdôležitejšie triedy, metódy a premenné v tomto module.
Inštalácia modulu
Modul cpapi sa inštaluje rýchlo a jednoducho z s pomocou pip. Podrobný návod na inštaláciu je v . Tento modul je prispôsobený pre prácu s verziami Python 2.7 a 3.7. V tomto článku budú príklady uvedené s použitím Python 3.7. Avšak, Python SDK je možné spustiť priamo zo servera správy Check Point (Smart Management), ale na nich je podporovaná iba verzia Python 2.7, a preto v poslednej časti bude uvedený kód pre verziu 2.7. Ihneď po inštalácii modulu odporúčam pozrieť sa na príklady v adresároch examples_python2 a examples_python3.
Začiatok práce
Aby sme mali možnosť pracovať s komponentmi modulu cpapi, je potrebné importovať z modulu cpapi aspoň dve potrebné triedy:
APIClient a APIClientArgs
from cpapi import APIClient, APIClientArgs
Trieda APIClientArgs zodpovedá za parametre pripojenia k API serveru, zatiaľ čo trieda APIClient zodpovedá za interakciu s API.
Definujeme parametre pripojenia
Aby sme určili rôzne parametre pripojenia k API, musíme vytvoriť inštanciu triedy APIClientArgs. V zásade sú jej parametre preddefinované a pri spustení skriptu na správcovskom serveri ich nie je potrebné uvádzať.
client_args = APIClientArgs()Ale pri spustení na externom hostiteľovi je potrebné uviesť aspoň IP adresu alebo názov hostiteľa API servera (teda správcovského servera). V nasledujúcom príklade definujeme parameter pripojenia server a priradíme mu ako reťazec IP adresu správcovského servera.
client_args = APIClientArgs(server='192.168.47.241')Pozrime sa na všetky parametre a ich predvolené hodnoty, ktoré môžeme použiť pri pripojení k API serveru:
Argumenty metódy __init__ triedy APIClientArgs
class APIClientArgs:
"""
Táto trieda poskytuje argumenty pre konfiguráciu APIClient.
Všetky argumenty sú nastavené na svoje predvolené hodnoty.
"""
# port je predvolene nastavený na None, ale nahrádza sa hodnotou 443, ak nie je špecifikovaný
# možné hodnoty kontextu - web_api (predvolené) alebo 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
# otlačok správcovského servera
self.fingerprint = fingerprint
# session-id.
self.sid = sid
# názov alebo IP adresa správcovského servera
self.server = server
# úroveň ladenia
self.http_debug_level = http_debug_level
# pole so všetkými API volaniami (na účely ladenia)
self.api_calls = api_calls if api_calls else []
# názov súboru s ladením. Ak je ponechaný prázdny, ladené dáta nebudú uložené na disku.
self.debug_file = debug_file
# adresa HTTP proxy servera (bez "http://")
self.proxy_host = proxy_host
# port HTTP proxy
self.proxy_port = proxy_port
# verzia API správcovského servera
self.api_version = api_version
# Indikuje, že klient by nemal overovať certifikát servera
self.unsafe = unsafe
# Indikuje, že klient by mal automaticky akceptovať a uložiť certifikát servera
self.unsafe_auto_accept = unsafe_auto_accept
# Kontext používania klienta - predvolene web_api
self.context = contextPredpokladám, že argumenty, ktoré môžu byť použité v inštanciách triedy APIClientArgs, sú intuitívne jasné administrátorom Check Point a nie sú potrebné ďalšie komentáre.
Pripojíme sa cez APIClient a správcu kontextu
Trieda APIClient najpraktickejšie je ich používať prostredníctvom správcu kontextu. Všetko, čo musíme odovzdať inštancii triedy APIClient, sú parametre pripojenia, ktoré sme definovali v predchádzajúcom kroku.
with APIClient(client_args) as client:
Správca kontextu automaticky nevykoná login volanie na API server, ale vykoná logout volanie pri odhlásení. Ak z akýchkoľvek dôvodov nie je potrebné logout po skončení práce s API, treba začať prácu bez použitia správcu kontextu:
client = APIClient(clieng_args)Kontrola pripojenia
Najjednoduchšie overíte, či pripojenie funguje podľa zadaných parametrov, pomocou metódy check_fingerprint. Ak kontrola hash sumy sha1 pre fingerprint certifikátu API servera neuspeje (metóda vrátila False), zvyčajne to spôsobuje problémy s pripojením a môžeme zastaviť vykonávanie programu (alebo dať používateľovi možnosť opraviť údaje na pripojenie):
if client.check_fingerprint() is False:
print("Nemohli sme získať fingerprint servera - Skontrolujte pripojenie so serverom.")
exit(1)
Majte na pamäti, že trieda APIClient bude kontrolovať pri každom volaní API (metódy api_call a api_query, o ktorých bude reč ďalej) sha1 fingerprint certifikátu na API serveri. A ak pri kontrole sha1 fingerprint certifikátu API servera dôjde k chybe (certifikát je neznámy alebo bol zmenený), metóda check_fingerprint poskytne možnosť pridať/zmeniť informácie o ňom na lokálnom počítači automaticky. Túto kontrolu je možné úplne vypnúť (ale to sa odporúča len pri spustení skriptov na samotnom API serveri, pri pripojení k 127.0.0.1) s použitím argumentu APIClientArgs - unsafe_auto_accept (pozri podrobnejšie o APIClientArgs skôr v „Definovanie parametrov pripojenia“).
client_args = APIClientArgs(unsafe_auto_accept=True)Prihlásenie na API server
U APIClient existujú celkom 3 metódy prihlásenia na API server, a každá z nich uchováva hodnotu sid(session-id), ktorá sa automaticky používa pri každom nasledujúcom volaní API v hlavičke (názov v hlavičke pre tento parameter - X-chkp-sid), takže nie je potrebné tento parameter dodatočne spracovávať.
Metóda login
Varianta s použitím prihlasovacieho mena a hesla (v príklade sú užívateľské meno admin a heslo 1q2w3e zadané ako pozičné argumenty):
login = client.login('admin', '1q2w3e') V metóde login sú tiež k dispozícii ďalšie voliteľné parametre, uvádzam ich názvy a predvolené hodnoty:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetóda login_with_api_key
Varianta s použitím api kľúča (podporovaná od verzie R80.40 / Management API v1.6, „3TsbPJ8ZKjaJGvFyoFqHFA==“ toto je hodnota API kľúča pre jedného z používateľov na správcovskom serveri s metódou autorizácie API kľúča:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') V metóde login_with_api_key sú dostupné rovnaké voliteľné parametre ako v metóde login.
Metóda login_as_root
Variant prihlásenia na lokálny stroj s API serverom:
login = client.login_as_root()Pre túto metódu sú k dispozícii iba dva voliteľné parametre:
domain=None, payload=NoneA nakoniec samotné API volania
Máme dva spôsoby, ako vykonávať API volania cez metódy api_call a api_query. Poďme sa pozrieť na to, v čom je medzi nimi rozdiel.
api_call
Táto metóda je použitelná pre akékoľvek volania. Musíme odovzdať poslednú časť pre api volanie a payload v tele požiadavky, ak je to potrebné. Ak je payload prázdny, nemusí sa vôbec odovzdávať:
api_versions = client.api_call('show-api-versions') Výstup pre túto žiadosť pod katom:
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 pre túto žiadosť pod katom:
Vo [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "čierna",
"comments": "",
"domain": {
"domain-type": "doména",
"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": "odomknuté",
"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": "čierna",
"comments": "",
"domain": {
"domain-type": "doména",
"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": "odomknuté",
"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
Hneď na začiatku musím poznamenať, že táto metóda je použitelná iba na výzvy, ktorých výstup predpokladá offset (posun). Takýto výstup sa generuje, ak obsahuje alebo môže obsahovať veľké množstvo informácií. Napríklad, to môže byť požiadavka na zoznam všetkých vytvorených objektov typu host na správcovskom serveri. Pre takéto požiadavky API vracia zoznam 50 objektov predvolene (je možné zvýšiť limit na 500 objektov v odpovedi). A aby sme nemali potrebu získavať informácie viackrát, meniac parameter offset v API požiadavke, existuje metóda api_query, ktorá túto prácu vykonáva automaticky. Príklady výziev, kde je táto metóda potrebná: show-sessions, show-hosts, show-networks, show-wildcards, show-groups, show-address-ranges, show-simple-gateways, show-simple-clusters, show-access-roles, show-trusted-clients, show-packages. V skutočnosti v názvoch týchto API výziev vidíme slová v množnom čísle, takže tieto výzvy bude jednoduchšie spracovávať cez api_query
show_hosts = client.api_query('show-hosts') Výstup pre túto žiadosť pod katom:
V [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
})
Spracovanie výsledkov API volaní
Po tomto môžete používať premenné a metódy triedy APIResponse(ako vo vnútri správcovského kontextu, tak aj vonku). Trieda APIResponse má preddefinovaných 4 metódy a 5 premenných, na najdôležitejších sa zastavíme podrobnejšie.
success
Najprv by bolo dobré uistiť sa, že API volanie prebehlo úspešne a vrátilo výsledok. Na to existuje metóda success:
V [49]: api_versions.success
Out[49]: True
Vracia True, ak API volanie prebehlo úspešne (kód odpovede — 200) a False, ak nie (akýkoľvek iný kód odpovede). Je pohodlné ho používať hneď po API volaní, aby sa na základe kódu odpovede zobrazili rôzne informácie.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuscode
Vracia kód odpovede po vykonaní API volania.
V [62]: api_versions.status_code
Out[62]: 400
Možné kódy odpovedí: 200,400,401,403,404,409,500,501.
set_success_status
Môže sa vyskytnúť potreba zmeniť hodnotu stavu success. Technicky tam možno vložiť čokoľvek, dokonca aj obyčajný reťazec. Ale skutočným príkladom môže byť nastavenie tejto hodnoty na False za určitých sprievodných podmienok. Nižšie je uvedený príklad, keď existujú úlohy vykonávané na správcovskom serveri, ale považujeme tento dopyt za neúspešný (nastavíme premennú success na False, aj keď bol API dopyt úspešný a vrátil 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)
breakresponse()
Metóda response umožňuje zobraziť slovník s kódom odpovede (status_code) a s telom odpovede (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']}}
data
Umožňuje zobraziť iba telo odpovede (body) bez zbytočných informácií.
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']}
error_message
Tieto informácie sú k dispozícii len vtedy, ak sa pri spracovaní API dopytu vyskytla chyba (kód odpovede nie 200). Ukážka výstupu
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Užitočné príklady
Nižšie sú uvedené príklady, v ktorých sa používajú API dopyty, ktoré boli pridané do verzie Management API 1.6.
Najskôr sa pozrime na prácu s dopytmi add-host a add-address-range. Predpokladajme, že potrebujeme vytvoriť ako objekty typu host všetky IP adresy subnetu 192.168.0.0/24, ktorých posledný oktet je 5, a všetky ostatné IP adresy zapísať ako objekty typu rozsah adries. Pri tom vylúčime adresu subnetu a vysielaciu adresu.
Takže níže je uvedený skript, ktorý rieši túto úlohu a vytvára 50 objektov typu host a 51 objekt typu rozsah adries. Na vyriešenie úlohy je potrebných 101 API dopytov (nepočítajúc konečný dopyt publish). Takisto pomocou modulu timeit meriame čas potrebný na vykonanie skriptu pred publikovaním zmien.
Skript s použitím 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 mojej laboratórnej prostredí trvá vykonanie tohto skriptu medzi 30 a 50 sekundami v závislosti od záťaže na riadiacom serveri.
A teraz sa pozrime, ako túto úlohu vyriešiť pomocou API volania add-objects-batch, ktorého podpora bola pridaná vo verzii API 1.6. Toto volanie umožňuje vytvoriť množstvo objektov naraz jedným API požiadavkom. Môžu to byť rôzne typy objektov (napríklad hostitelia, podsiete a rozsahy adries). Týmto spôsobom môžeme svoju úlohu vyriešiť v rámci jedného API volania.
Skript s využitím 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 vykonanie tohto skriptu v mojej laboratórnej prostredí trvá medzi 3 a 7 sekundami, v závislosti od záťaže na riadiacom serveri. To znamená, že pri 101 objektoch sa API volanie typu batch vykonáva v priemere 10-krát rýchlejšie. Pri väčšom počte objektov bude rozdiel ešte pôsobivejší.
Teraz sa pozrime, ako pracovať s set-objects-batch. S pomocou tohto API volania môžeme hromadne zmeniť akýkoľvek parameter. Nastavme prvej polovici adries z predchádzajúceho príkladu (do .124 hostiteľa, vrátane rozsahov) farbu sienna, a druhej polovici adries pridelíme farbu khaki.
Zmena farby objektov vytvorených v predchádzajúcom príklade
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")
Odstránenie viacerých objektov v jednom API volaní je možné pomocou delete-objects-batch. A teraz sa pozrime na príklad kódu, ktorý odstraňuje všetky hosty vytvorené skôr cez add-objects-batch.
Odstránenie objektov pomocou 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šetky funkcie, ktoré sa objavujú v nových vydaniach softvéru Check Point, prichádzajú aj s API volaniami. V R80.40 sa objavili funkcie ako "Revert to revision" a "Smart Task", pre ktoré boli okamžite pripravené príslušné API volania. Navyše, celý funkčný mechanizmus pri prechode z Legacy konzol do režimu Unified Policy tiež získava podporu API. Napríklad dlho očakávanou aktualizáciou vo verzii softvéru R80.40 bolo presunutie politiky HTTPS Inspekcia z Legacy režimu do režimu Unified Policy, a táto funkcia sa ihneď dočkala API volaní. Tu je príklad kódu, ktorý pridáva do najvyššej pozície pravidlo politiky HTTPS Inspekcie, ktoré vylučuje z inspekcie tri kategórie (Zdravie, Financie, Verejné služby), ktoré je zakázané inšpektovať v súlade so zákonodarstvom v niektorých krajinách.
Pridať pravidlo do politiky HTTPS Inspekcia
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Právne požiadavky",
"action": "bypass",
"site-category": ["Zdravie", "Verejná správa / Vojenské", "Finančné služby"]
}
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")
Spustenie Python skriptov na správcovskom serveri Check Point
Všetko v tom istom obsahuje informácie o tom, ako spúšťať skripty v Pythone priamo zo správcovského servera. Môže to byť užitočné, keď nemáte možnosť pripojiť sa k API serveru z iného počítača. Nahrával som šesťminútové video, v ktorom sa zaoberám inštaláciou modulu cpapi a osobitostiami spustenia Python skriptov na správcovskom serveri. Ako príklad sa spúšťa skript, ktorý automatizuje konfiguráciu nového brány pre úlohu, ako je audit siete Security CheckUp. Z osobitostí, s ktorými som sa stretol: vo verzii Python 2.7 ešte neexistuje funkcia input, preto na spracovanie informácií, ktoré zadáva používateľ, sa používa funkcia raw_input. V ostatnom je kód rovnaký ako pre spustenie z iných strojov, ibaže je pohodlnejšie používať funkciu login_as_root, aby ste znova neuvádzali svoje vlastné používateľské meno, heslo a IP adresu správcovského servera.
Skript pre rýchlu konfiguráciu Security CheckUp
z __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:
# ak klient.check_fingerprint() je False:
# print("Nepodarilo sa získať odtlačok servera - Skontrolujte konektivitu so serverom.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Prihlásenie zlyhalo:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Zadajte názov brány:")
gw_ip = raw_input("Zadajte IP adresu brány:")
if sys.stdin.isatty():
sic = getpass.getpass("Zadajte jednorazové heslo pre bránu (SIC): ")
else:
print("Pozor! Vaše heslo bude zobrazené na obrazovke!")
sic = raw_input("Zadajte jednorazové heslo pre bránu (SIC): ")
version = raw_input("Zadajte verziu brány (napr. 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("Bezpečné pripojenie s bránou nebolo nadviazané!")
exit(1)
elif add_gw.success:
print("Brána bola úspešne pridaná.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Nepodarilo sa pridať bránu - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Sieť", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("Politika bola úspešne zmenená")
else:
print("Nepodarilo sa zmeniť politiku - {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Úpravná pravidlo", "layer" : "Sieť", "action": "Accept", "track": {"type": "Podrobný záznam", "accounting": "true"}})
if change_rule.success:
print("Úpravné pravidlo bolo úspešne zmenené")
else:
print("Nepodarilo sa zmeniť úpravné pravidlo - {}".format(change_rule.error_message))
# publikovať výsledok
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Zmeny boli úspešne publikované.")
else:
print("Nepodarilo sa publikovať zmeny - {}".format(install_tp_policy.error_message))
install_access_policy = client.api_call("install-policy", {"policy-package" : "Štandard", "access" : 'true', "threat-prevention" : 'false', "targets" : gw_uid})
if install_access_policy.success:
print("Prístupová politika bola nainštalovaná")
else:
print("Nepodarilo sa nainštalovať prístupovú politiku - {}".format(install_tp_policy.error_message))
install_tp_policy = client.api_call("install-policy", {"policy-package" : "Štandard", "access" : 'false', "threat-prevention" : 'true', "targets" : gw_uid})
if install_tp_policy.success:
print("Politika prevencie hrozieb bola nainštalovaná")
else:
print("Nepodarilo sa nainštalovať politiku prevencie hrozieb - {}".format(install_tp_policy.error_message))
# pridať heslá a frázy do slovníka
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" : "Pridajte heslá a frázy", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Riadok slovníka hesiel {} bol úspešne pridaný".format(line_num))
else:
print("Nepodarilo sa pridať slovník - {}".format(add_password_dictionary.error_message))
main() Ukážkový súbor so slovníkom hesiel additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","heslo","Heslo","Kľúč","kľúč","šifrovanie","Šifrovanie"]
}
Záver
Tento článok sa zaoberá len základnými možnosťami práce Python SDK a modulu cpapi(ako ste si mohli domyslieť, to sú vlastne synonymá), a skúmaním kódu v tomto module objavíte ešte viac možností v práci s ním. Nie je vylúčené, že sa u vás objaví túžba doplniť ho svojimi triedami, funkciami, metódami a premennými. Vždy sa môžete podeliť o svoje výtvory a prezerať si iné skripty pre Check Point v sekcii v komunite , ktorá spája i vývojárov produktov a používateľov.
Príjemné kódovanie a ďakujeme, že ste dočítali až do konca!
Zdroj: habr.com
