Vsa moč interakcije z API-jem se razkriva pri skupni uporabi s programskim kodeksom, ko se pojavijo priložnosti za dinamično oblikovanje API poizvedb in orodij za analizo API odgovorov. Vendar pa ostaja malo opaženo, Python Software Development Kit (nato — Python SDK) za Check Point Management API, kar je škoda. Znatno poenostavi življenje razvijalcem in ljubiteljem avtomatizacije. Python je v zadnjem času pridobil ogromno priljubljenost, zato sem se odločil zapolniti vrzel in predstaviti pregled osnovnih možnosti . Ta članek služi kot odličen dodatek k drugemu članku na Habrju . Proučili bomo, kako napisati skripte z uporabo Python SDK in se podrobneje osredotočili na novo funkcionalnost Management API v različici 1.6 (podprta od R80.40 naprej). Za razumevanje članka so potrebna osnovna znanja o delu z API-jem in Python-om.
Check Point aktivno razvija API, in do sedaj so nastali:
- — delo s strežnikom za upravljanje preko API (in možnost izvajanja skript na prehodih pod nadzorom strežnika za upravljanje)
- — delo z varnostnimi prehodi
- — delo s peskovnikom v oblaku Check Point
- — delo z Identity Awareness blade na prehodih
- — delo s portalom za upravljanje SMB prehodi ()
- — interakcija z IoT krmilniki
- — delo z (rešitev SD-WAN security)
- — delo z
Python SDK trenutno podpira le interakcijo s Management API in Gaia API. Proučili bomo najpomembnejše razrede, metode in spremenljivke v tem modulu.
Namestitev modula
Modul cpapi se hitro in enostavno namesti iz s pomočjo pip. Podrobna navodila za namestitev so na voljo v . Ta modul je prilagojen za delo z različicami Python 2.7 in 3.7. V tem članku bodo primeri prikazani z uporabo Python 3.7. Vendar pa lahko Python SDK teče prav z Check Point upravljalnega strežnika (Smart Management), vendar tam podpira le različico Python 2.7, zato bo v zadnjem razdelku prikazan koda za različico 2.7. Takoj po namestitvi modula priporočam, da si ogledate primere v direktorijih examples_python2 in examples_python3.
Začetek
Da bi imeli možnost delati s komponentami modula cpapi, moramo uvoziti iz modula cpapi najmanj dva potrebna razreda:
APIClient in APIClientArgs
from cpapi import APIClient, APIClientArgs
Razred APIClientArgs skrbi za parametre povezave z API strežnikom, razred APIClient skrbi za interakcijo z API-jem.
Določimo parametre povezave
Za določitev različnih parametrov povezave z API-jem je treba ustvariti instanco razreda APIClientArgs. V bistvu so njegovi parametri vnaprej določeni in jih ob zagonu skripte na upravljalskem strežniku ni treba navajati.
client_args = APIClientArgs()Pri zagonu na zunanjem gostitelju pa je treba navesti najmanj IP naslov ali ime gostitelja API strežnika (tudi upravljalski strežnik). V spodnjem primeru določamo parameter povezave server in mu dodeljujemo IP naslov upravljalskega strežnika v obliki niz.
client_args = APIClientArgs(server='192.168.47.241')Poglejmo vse parametre in njihove privzete vrednosti, ki jih lahko uporabljamo pri povezavi z API strežnikom:
Argumenti metode __init__ razreda APIClientArgs
class APIClientArgs:
"""
Ta razred zagotavlja argumente za konfiguracijo APIClient.
Vsi argumenti so konfigurirani z njihovimi privzetimi vrednostmi.
"""
# vrata so privzeto nastavljena na None, a se v primeru, da niso določena, zamenjajo z 443
# možne vrednosti konteksta - web_api (privzeto) ali 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
# prstni odtis upravljalskega strežnika
self.fingerprint = fingerprint
# identifikacija seje.
self.sid = sid
# ime upravljalskega strežnika ali IP-naslov
self.server = server
# raven odpravljanja napak
self.http_debug_level = http_debug_level
# tabela z vsemi klici API (za namene odpravljanja napak)
self.api_calls = api_calls if api_calls else []
# ime datoteke za odpravljanje napak. Če je pustimo prazno, podatki o odpravljanju napak ne bodo shranjeni na disk.
self.debug_file = debug_file
# naslov HTTP proxy strežnika (brez "http://")
self.proxy_host = proxy_host
# vrata HTTP proxy strežnika
self.proxy_port = proxy_port
# API različica upravljalskega strežnika
self.api_version = api_version
# Pokaže, da stranka ne sme preverjati potrdila strežnika
self.unsafe = unsafe
# Pokaže, da stranka samodejno sprejme in shrani potrdilo strežnika
self.unsafe_auto_accept = unsafe_auto_accept
# Kontekst uporabe stranke - privzeto na web_api
self.context = contextMenim, da so argumenti, ki jih lahko uporabimo v instancah razreda APIClientArgs, intuitivno razumljivi administratorjem Check Point in ne potrebujejo dodatnih komentarjev.
Povezujemo se preko APIClient in upravljavca konteksta
Razred APIClient najbolje je uporabiti preko upravljavca konteksta. Vse, kar je treba prenesti instanci razreda APIClient, so parametri povezave, ki so bili določeni v prejšnjem koraku.
with APIClient(client_args) as client:
Upravitelj kontekstov ne bo samodejno izvedel login klica na API strežnik, vendar bo izvedel logout klic ob izhodu. Če iz kakršnega koli razloga logout po končanju dela z API klici ni potreben, je treba začeti delo brez uporabe upravitelja kontekstov:
client = APIClient(client_args)Preverjanje povezave
Najbolje je preveriti, ali povezava deluje z zahtevanimi parametri, s pomočjo metode check_fingerprint. Če preverjanje SHA1 hash vrednosti za fingerprint certifikata API strežnika ni uspešno (metoda je vrnila False), je to običajno posledica težav s povezavo in lahko prekinemo izvajanje programa (ali damo uporabniku možnost, da popravi podatke za povezavo):
if client.check_fingerprint() is False:
print("Ni mogoče pridobiti fingerprinta strežnika - Preverite povezljivost s strežnikom.")
exit(1)
Upoštevajte, da bo razred APIClient pri vsakem klicu API preverjal (metode api_call in api_query, o katerih bomo govorili nekoliko kasneje) SHA1 fingerprint certifikata na API strežniku. Če bo med preverjanjem SHA1 fingerprint certifikata API strežnika ugotovljena napaka (certifikat je neznan ali je bil spremenjen), bo metoda check_fingerprint ponudila možnost dodati/spreminjati informacije o njem na lokalnem računalniku v samodejnem načinu. To preverjanje je mogoče popolnoma onemogočiti (kar priporočamo le v primeru izvajanja skriptov na samem API strežniku, ko se povežete z 127.0.0.1), z uporabo argumenta APIClientArgs — unsafe_auto_accept (več o APIClientArgs si lahko preberete prej v poglavju »Določanje parametrov povezave«).
client_args = APIClientArgs(unsafe_auto_accept=True)Prijava na API strežnik
Pri APIClient Obstajajo kar trije načini prijave na API strežnik, vsak od njih pa shrani vrednost sid(session-id), ki jo samodejno uporablja v vsakem naslednjem API klicu v glavi (ime v glavi tega parametra — X-chkp-sid), zato ta parameter ni treba dodatno obdelovati.
Metoda login
Možnost z uporabo uporabniškega imena in gesla (v primeru so uporabniško ime admin in geslo 1q2w3e podani kot pozicijski argumenti):
login = client.login('admin', '1q2w3e') V metodi login so na voljo tudi dodatni neobvezni parametri, tukaj so njihova imena in privzete vrednosti:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetoda login_with_api_key
Možnost z uporabo API ključa (podprto od različice upravljanja R80.40/Management API v1.6, »3TsbPJ8ZKjaJGvFyoFqHFA==« to je vrednost API ključa za enega od uporabnikov na nadzornem strežniku z metodo avtorizacije API ključa):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') V metodi login_with_api_key so na voljo enaki neobvezni parametri kot v metodi login.
Metoda login_as_root
Možnost prijave na lokalni računalnik z API strežnikom:
login = client.login_as_root()Za to metodo sta na voljo le dva neobvezna parametra:
domain=None, payload=NoneIn končno sami API klici
Imamo dve možnosti za izvajanje API klicev preko metod api_call in api_query. Poglejmo, kakšna je razlika med njima.
api_call
Ta metoda je primerna za vse klice. Potrebno je prenesti zadnji del za api klic in payload v telesu zahteve, če je to potrebno. Če je payload prazen, ga sploh ni potrebno poslati:
api_versions = client.api_call('show-api-versions') Izpis za to poizvedbo 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'})Izpis za to poizvedbo pod katom:
V [25]: prikaži_strežnik
Izhod[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
Takoj bom povedal, da je ta metoda uporabna samo za klice, katerih izhod predvideva offset (pomik). Takšen izhod nastane, kadar vsebuje ali lahko vsebuje veliko količino informacij. Na primer, to je lahko zahteva za seznam vseh ustvarjenih objektov tipa gostitelj na nadzorni strežnik. Za take zahteve API privzeto vrne seznam 50 objektov (omejitev lahko povečate na 500 objektov v odgovoru). In da ne bi večkrat poklicali informacij, sprememb za parameter offset v API zahtevi, obstaja metoda api_query, ki to delo opravi samodejno. Primeri klicev, kjer je potrebna ta metoda: 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 resnici v imenih teh API klicev vidimo besede v množini, tako da jih bo lažje obdelati prek api_query
show_hosts = client.api_query('show-hosts') Izpis za to poizvedbo 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
})
Obdelava rezultatov API klicev
Po tem lahko uporabite spremenljivke in metode razreda APIResponse(tako znotraj upravitelja konteksta kot zunaj). Razred APIResponse ima vnaprej določenih 4 metode in 5 spremenljivk, na najpomembnejših se bomo podrobneje ustavili.
success
Najprej bi bilo dobro preveriti, ali je bil API klic uspešen in je vrnil rezultat. Za to je tu metoda success:
V [49]: api_versions.success
Out[49]: True
Vrne True, če je bil API klic uspešen (statusna koda — 200) in False, če ni (katera koli druga statusna koda). Uporabno je takoj po API klicu, da odvisno od statusne kode prikaže različne informacije.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuscode
Vrne statusno kodo po izvedbi API klica.
V [62]: api_versions.status_code
Out[62]: 400
Možne statusne kode: 200,400,401,403,404,409,500,501.
set_success_status
V tem primeru je lahko potrebno spremeniti vrednost statusa success. Tehnično je mogoče vnesti karkoli, tudi navadno besedilo. A pravi primer je lahko ponastavitev te spremenljivke na False ob določenih spremljajočih pogojih. Spodaj si oglejte primer, ko obstajajo naloge, ki se izvajajo na upravljalskem strežniku, a bomo ta zahtevek šteli za neuspešnega (nastavimo spremenljivko success na False, kljub temu da je bil klic API uspešen in je vrnil kodo 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakresponse()
Metoda response omogoča vpogled v slovar s kodo odgovora (status_code) in telesom odgovora (body).
V [94]: api_versions.response()
Izhod [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
Omogoča ogled le telesa odgovora (body) brez nepotrebnih informacij.
V [93]: api_versions.data
Izhod [93]:
{'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}
error_message
Te informacije so na voljo le, ko pride do napake pri obdelavi zahtevka API (koda odgovora ne 200). Primer izhoda
V [107]: api_versions.error_message
Izhod [107]: 'code: generic_err_invalid_parameter_nname: Unrecognized parameter [1]n'
Koristni primeri
Spodaj so navedeni primeri, ki uporabljajo klice API, dodane v različico Management API 1.6.
Najprej si oglejmo delovanje klicev add-host in add-address-range. Predpostavimo, da moramo ustvariti kot objekte tipa gostitelja vse IP naslove podomrežja 192.168.0.0/24, katerih zadnji oktet je 5, vse ostale IP naslove pa zabeležiti kot objekte tipa obsega naslovov. Pri tem izključimo naslov podomrežja in širokopasovni naslov.
Torej, spodaj je prikazan skript, ki rešuje to nalogo in ustvarja 50 objektov tipa gostitelja in 51 objekt tipa obsega naslovov. Za rešitev naloge je potrebno 101 klic API (brez zadnjega klica publish). Tudi s pomočjo modula timeit merimo čas izvajanja skripta do trenutka objave sprememb.
Skript z uporabo add-host in 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 mojem laboratorijskem okolju traja izvajanje tega skripta od 30 do 50 sekund, odvisno od obremenitve na nadzornem strežniku.
Zdaj pa si poglejmo, kako rešiti isto nalogo z uporabo API klica add-objects-batch, katerega podpora je bila dodana v različici API 1.6. Ta klic omogoča, da z enim API zahtevkom ustvarimo več objektov. In ti lahko vključujejo objekte različnih tipov (na primer gostitelje, podomrežja in obsege naslovov). Tako lahko našo nalogo rešimo v okviru enega API klica.
Skripta z uporabo 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')
Izvajanje tega skripta v mojem laboratorijskem okolju traja od 3 do 7 sekund, odvisno od obremenitve na nadzornem strežniku. To pomeni, da API klic vrste batch deluje povprečno 10-krat hitreje pri 101 objektih. Pri večjem številu objektov bo razlika še bolj impresivna.
Zdaj pa si poglejmo, kako delati z set-objects-batch. S tem API klicem lahko masovno spremenimo kateri koli parameter. Nastavili bomo barvo sienna za prvo polovico naslovov iz prejšnjega primera (do .124 gostitelja, pa tudi za obsege) in barvo khaki za drugo polovico naslovov.
Sprememba barve objektov, ustvarjenih v prejšnjem primeru
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")
Množico objektov lahko izbrišete z enim API klicem z uporabo delete-objects-batch. Sedaj si poglejmo primer kode, ki izbriše vse gostitelje, ustvarjene prej preko add-objects-batch.
Izbris objektov z uporabo 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)
Vse funkcije, ki se pojavijo v novih izdajah programske opreme Check Point, takoj dobijo tudi API klice. Tako so v R80.40 nastale funkcije, kot sta Revert to revision in Smart Task, in zanje so takoj pripravili ustrezne API klice. Še več, vsa funkcionalnost pri prehodu iz Legacy konzol v način Unified Policy prav tako pridobi podporo za API. Na primer, dolgo pričakovano posodobitev v različici programske opreme R80.40 je selitev politike HTTPS Inspection iz Legacy načina v način Unified Policy, in ta funkcionalnost je takoj dobila API klice. Tukaj je primer kode, ki na vrh HTTPS Inspection politike doda pravilo, ki izključuje 3 kategorije (Zdravje, Finance, Državne storitve) iz inšpekcije, kar je v skladu z zakonodajo v nekaterih državah.
Dodaj pravilo v politiko HTTPS Inspection
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")
Zagon Python skriptov na upravljavskem strežniku Check Point
Vse v istem vsebuje informacije, kako zagnati skripte v Pythonu neposredno s upravljavskega strežnika. To je lahko koristno, ko nimate možnosti povezati se s strežnikom API z druge naprave. Posnel sem šest minut dolg video, v katerem obravnavam namestitev modula cpapi in posebnosti zagona Python skriptov na upravljavskem strežniku. Kot primer se zažene skript, ki avtomatizira konfiguracijo novega prehoda za nalogo, kot je revizija omrežja Security CheckUp. Med posebnostmi, s katerimi sem se soočil: v različici Python 2.7 še ni bila uvedena funkcija input, zato se za obdelavo informacij, ki jih vnese uporabnik, uporablja funkcija raw_input. V nasprotnem primeru je koda enaka tisti za zagon z drugih naprav, le da je bolj priročno uporabiti funkcijo login_as_root, da se ne bi večkrat morali ponovno povezovati s svojim uporabniškim imenom, geslom in IP naslovom upravljavskega strežnika.
Skript za hitro nastavitev Security CheckUp
iz __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("Ni lahko pridobite prstni odtis strežnika - Preverite povezljivost s strežnikom.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Prijava ni uspela:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Vnesite ime prehoda:")
gw_ip = raw_input("Vnesite IP naslov prehoda:")
if sys.stdin.isatty():
sic = getpass.getpass("Vnesite enkratno geslo za prehod (SIC): ")
else:
print("Pozor! Vaše geslo bo prikazano na zaslonu!")
sic = raw_input("Vnesite enkratno geslo za prehod (SIC): ")
version = raw_input("Vnesite različico prehoda (kot 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("Varnostna povezava s prehodom ni bila vzpostavljena!")
exit(1)
elif add_gw.success:
print("Prehod je bil uspešno dodan.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Dodajanje prehoda je neuspešno - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Mreža", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("Politika je bila uspešno spremenjena")
else:
print("Sprememba politike ni uspela - {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Pravila čiščenja", "layer" : "Mreža", "action": "Sprejmi", "track": {"type": "Podrobna beležka", "accounting": "true"}})
if change_rule.success:
print("Pravila čiščenja so bila uspešno spremenjena")
else:
print("Sprememba pravil čiščenja ni uspela - {}".format(change_rule.error_message))
# objavite rezultat
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Spremembe so bile uspešno objavljene.")
else:
print("Objava sprememb ni uspela - {}".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("Politika dostopa je bila nameščena")
else:
print("Namestitev politike dostopa ni uspela - {}".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("Politika preprečevanja groženj je bila nameščena")
else:
print("Namestitev politike preprečevanja groženj ni uspela - {}".format(install_tp_policy.error_message))
# dodajte gesla in gesla v slovar
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" : "Dodaj gesla in gesla", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Črta slovarja gesel {} je bila uspešno dodana".format(line_num))
else:
print("Dodajanje slovarja ni uspelo - {}".format(add_password_dictionary.error_message))
main() Primer datoteke sa rečnikom lozinki additional_pass.conf
{
"passwords" : ["malware","zlonamerne","okužene","Okužene"],
"phrases" : ["geslo","Geslo","Prehod","prehod","koda","klju" ,"pwd","geslo","Geslo","Ključ","ključ","šifra","Šifra"]
}
Zaključek
Ovaj članak razmatra samo osnovne mogućnosti rada Python SDK i modula cpapi(kao što ste mogli pretpostaviti, ovo su zapravo sinonimi), i proučavanjem koda u ovom modulu otkrićete još više mogućnosti u radu s njim. Nije isključeno da ćete želeti da ga obogatite svojim klasama, funkcijama, metodama i promenljivim. Uvek možete deliti svoje radove i pregledavati druge skripte za Check Point u odeljku u zajednici , koja okuplja i programere proizvoda i korisnike.
Prijatno kodiranje i hvala što ste pročitali do kraja!
Izvor: habr.com
