Visa sąveikos su API galia atsiskleidžia naudojant kartu su programos kodu, kai tampa įmanoma dinamiškai generuoti API užklausas ir API atsakymų analizės įrankius. Tačiau jis vis tiek lieka nepastebimas Python programinės įrangos kūrimo rinkinys (toliau – Python SDK), skirta Check Point Management API, bet veltui. Tai žymiai supaprastina kūrėjų ir automatikos entuziastų gyvenimą. Python pastaruoju metu įgijo milžinišką populiarumą, todėl nusprendžiau užpildyti spragą ir peržiūrėti pagrindines funkcijas. . Šis straipsnis puikiai papildo kitą straipsnį apie Habré . Pažiūrėsime, kaip rašyti scenarijus naudojant Python SDK, ir atidžiau pažvelgsime į naują valdymo API funkciją 1.6 versijoje (palaikoma nuo R80.40). Norėdami suprasti straipsnį, jums reikės pagrindinių žinių apie darbą su API ir Python.
„Check Point“ aktyviai kuria API ir šiuo metu yra išleista:
- — dirbti su valdymo serveriu per API (ir galimybę vykdyti scenarijus valdymo serverio valdomuose šliuzuose)
- — darbas su apsaugos vartais
- — darbas su smėlio dėže Check Point debesyje
- — darbas su tapatybės suvokimo peiliuku vartuose
- — dirbti su SMB vartų valdymo portalu ()
- — sąveika su daiktų interneto valdikliais
- - dirbti su (SD-WAN saugos sprendimas)
- - dirbti su
Python SDK šiuo metu palaiko tik sąveiką su valdymo API ir Gaia API. Šiame modulyje apžvelgsime svarbiausias klases, metodus ir kintamuosius.
Modulio montavimas
Modulis cpapi greitai ir lengvai įdiegiama iš per pieputis. Išsamias montavimo instrukcijas rasite . Šis modulis pritaikytas darbui su Python 2.7 ir 3.7 versijomis. Šiame straipsnyje bus pateikti pavyzdžiai naudojant Python 3.7. Tačiau Python SDK galima paleisti tiesiai iš „Check Point Management Server“ (išmaniojo valdymo), tačiau jie palaiko tik Python 2.7, todėl paskutiniame skyriuje bus pateiktas 2.7 versijos kodas. Iš karto po modulio įdiegimo rekomenduoju pažvelgti į pavyzdžius kataloguose examples_python2 и examples_python3.
Darbo pradžia
Kad galėtume dirbti su cpapi modulio komponentais, turime importuoti iš modulio cpapi bent dvi privalomos klasės:
APIClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Klasė APIClientArgs yra atsakingas už prisijungimo prie API serverio parametrus ir klasę APIClient yra atsakingas už sąveiką su API.
Ryšio parametrų nustatymas
Norėdami apibrėžti įvairius prisijungimo prie API parametrus, turite sukurti klasės egzempliorių APIClientArgs. Iš esmės jo parametrai yra iš anksto apibrėžti ir paleidžiant scenarijų valdymo serveryje, jų nurodyti nereikia.
client_args = APIClientArgs()Tačiau kai naudojate trečiosios šalies pagrindinį kompiuterį, turite nurodyti bent API serverio (taip pat žinomo kaip valdymo serverio) IP adresą arba pagrindinio kompiuterio pavadinimą. Toliau pateiktame pavyzdyje apibrėžiame serverio ryšio parametrą ir kaip eilutę priskiriame jam valdymo serverio IP adresą.
client_args = APIClientArgs(server='192.168.47.241')Pažvelkime į visus parametrus ir jų numatytąsias reikšmes, kurios gali būti naudojamos jungiantis prie API serverio:
APIClientArgs klasės metodo __init__ argumentai
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 = contextManau, kad argumentai, kuriuos galima naudoti APIClientArgs klasės atvejais, yra intuityvūs Check Point administratoriams ir nereikalauja papildomų komentarų.
Prisijungimas per APIClient ir konteksto tvarkyklę
Klasė APIClient Patogiausias būdas jį naudoti yra konteksto tvarkytuvė. Viskas, ką reikia perduoti APIClient klasės egzemplioriui, yra ryšio parametrai, kurie buvo apibrėžti ankstesniame veiksme.
with APIClient(client_args) as client:
Konteksto tvarkyklė automatiškai neskelbs prisijungimo prie API serverio, bet išeidama iš jo atliks atsijungimo skambutį. Jei dėl kokių nors priežasčių, baigus dirbti su API skambučiais atsijungti nereikia, turite pradėti dirbti nenaudodami konteksto tvarkyklės:
client = APIClient(clieng_args)Ryšio testas
Lengviausias būdas patikrinti, ar ryšys atitinka nurodytus parametrus, yra naudoti šį metodą check_fingerprint. Jei nepavyksta patikrinti serverio API sertifikato kontrolinio kodo sha1 maišos sumos (metodas grąžintas Klaidingas), tada tai dažniausiai sukelia ryšio problemos ir mes galime sustabdyti programos vykdymą (arba suteikti vartotojui galimybę pataisyti ryšio duomenis):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Atkreipkite dėmesį, kad ateityje klasė APIClient patikrins kiekvieną API iškvietimą (metodai api_call и api_query, apie juos pakalbėsime šiek tiek toliau) sha1 piršto atspaudo sertifikatas API serveryje. Bet jei tikrinant API serverio sertifikato sha1 piršto atspaudą aptinkama klaida (sertifikatas nežinomas arba buvo pakeistas), metodas check_fingerprint suteiks galimybę automatiškai pridėti/keisti informaciją apie tai vietiniame kompiuteryje. Šį patikrinimą galima visiškai išjungti (tačiau tai gali būti rekomenduojama tik tuo atveju, jei scenarijai paleidžiami pačiame API serveryje, jungiantis prie 127.0.0.1), naudojant APIClientArgs argumentą - nesaugus_auto_priimti (daugiau apie APIClientArgs skaitykite anksčiau skyriuje „Ryšio parametrų apibrėžimas“).
client_args = APIClientArgs(unsafe_auto_accept=True)Prisijunkite prie API serverio
У APIClient Yra net 3 prisijungimo prie API serverio būdai ir kiekvienas iš jų supranta prasmę sid(session-id), kuris automatiškai naudojamas kiekviename paskesniame API iškvietime antraštėje (šio parametro antraštėje esantis pavadinimas yra X-chkp-sid), todėl šio parametro toliau apdoroti nereikia.
prisijungimo būdas
Parinktis naudojant prisijungimo vardą ir slaptažodį (pavyzdyje vartotojo vardas admin ir slaptažodis 1q2w3e perduodami kaip poziciniai argumentai):
login = client.login('admin', '1q2w3e') Papildomi pasirenkami parametrai taip pat galimi prisijungimo metodu; čia yra jų pavadinimai ir numatytosios reikšmės:
continue_last_session=False, domain=None, read_only=False, payload=NonePrisijungimo_su_api_rakto metodu
Galimybė naudojant API raktą (palaikoma nuo valdymo versijos R80.40 / valdymo API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" tai yra API rakto reikšmė vienam iš valdymo serverio naudotojų su API rakto autorizacijos metodu):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Pagal metodą prisijungimo_su_api_raktu galimi tie patys pasirenkami parametrai kaip ir metode Vartotoją.
prisijungimo_kaip_root metodas
Galimybė prisijungti prie vietinio kompiuterio su API serveriu:
login = client.login_as_root()Šiam metodui galimi tik du pasirenkami parametrai:
domain=None, payload=NoneIr galiausiai API vadina save
Turime dvi galimybes atlikti API skambučius naudojant metodus api_call и api_query. Išsiaiškinkime, kuo jie skiriasi.
api_call
Šis metodas tinka bet kokiems skambučiams. Jei reikia, turime perduoti paskutinę API iškvietimo dalį ir naudingąją apkrovą. Jei naudingoji apkrova tuščia, jo iš viso negalima perkelti:
api_versions = client.api_call('show-api-versions') Šios užklausos išvestis po pjūviu:
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'})Šios užklausos išvestis po pjūviu:
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
Leiskite man iš karto padaryti išlygą, kad šis metodas taikomas tik skambučiams, kurių išvestis apima poslinkį. Tokia išvada atsiranda, kai joje yra arba gali būti daug informacijos. Pavyzdžiui, tai gali būti visų valdymo serveryje sukurtų pagrindinio kompiuterio objektų sąrašo užklausa. Tokioms užklausoms API pagal numatytuosius nustatymus pateikia 50 objektų sąrašą (atsakyme galite padidinti limitą iki 500 objektų). Ir tam, kad nebūtų traukiama informacija kelis kartus keičiant poslinkio parametrą API užklausoje, yra api_query metodas, kuris tai atlieka automatiškai. Skambučių, kai reikia šio metodo, pavyzdžiai: laidų seansai, laidų vedėjai, laidų tinklai, rodomi pakaitos simboliai, laidų grupės, rodymo adresų diapazonai, paprasti vartai, rodymo paprasti grupės, rodymo prieigos vaidmenys, patikimi klientai, šou-paketai. Tiesą sakant, šių API skambučių pavadinimuose matome daugiskaitos žodžius, todėl šiuos skambučius bus lengviau valdyti api_query
show_hosts = client.api_query('show-hosts') Šios užklausos išvestis po pjūviu:
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
})
API iškvietimų rezultatų apdorojimas
Po to galite naudoti klasės kintamuosius ir metodus APIResponse(tiek konteksto tvarkytuvėje, tiek išorėje). Klasėje APIResponse Iš anksto nustatyti 4 metodai ir 5 kintamieji, prie svarbiausių pakalbėsime plačiau.
sėkmė
Pirmiausia verta įsitikinti, kad API iškvietimas buvo sėkmingas ir davė rezultatą. Tam yra metodas sėkmė:
In [49]: api_versions.success
Out[49]: True
Grąžina True, jei API iškvietimas buvo sėkmingas (atsakymo kodas – 200), ir False, jei nepavyko (bet koks kitas atsakymo kodas). Patogu naudoti iškart po API iškvietimo, kad būtų rodoma skirtinga informacija, priklausomai nuo atsakymo kodo.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) būsenos kodas
Po API skambučio grąžina atsakymo kodą.
In [62]: api_versions.status_code
Out[62]: 400
Galimi atsakymo kodai: 200,400,401,403,404,409,500,501.
set_success_status
Tokiu atveju gali prireikti pakeisti sėkmės būsenos reikšmę. Techniškai ten galite įdėti bet ką, net įprastą eilutę. Tačiau tikras pavyzdys būtų šio parametro nustatymas iš naujo į False esant tam tikroms papildomoms sąlygoms. Toliau atkreipkite dėmesį į pavyzdį, kai valdymo serveryje vykdomos užduotys, tačiau šią užklausą laikysime nesėkminga (sėkmės kintamąjį nustatysime į Klaidingas, nepaisant to, kad API skambutis buvo sėkmingas ir grąžintas kodas 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakatsakymas ()
Atsakymo metodas leidžia peržiūrėti žodyną su atsakymo kodu (status_code) ir atsakymo tekstu (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']}}
duomenys
Leidžia matyti tik atsakymo turinį (kūną) be nereikalingos informacijos.
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
Ši informacija pasiekiama tik tada, kai apdorojant API užklausą įvyko klaida (atsakymo kodas ne 200). Išvesties pavyzdys
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Naudingi pavyzdžiai
Toliau pateikiami pavyzdžiai, kuriuose naudojami API iškvietimai, kurie buvo įtraukti į valdymo API 1.6.
Pirmiausia pažiūrėkime, kaip veikia skambučiai add-host и pridėti adresų diapazoną. Tarkime, turime sukurti visus potinklio 192.168.0.0/24 IP adresus, kurių paskutinis oktetas yra 5, kaip pagrindinio kompiuterio tipo objektus, o visus kitus IP adresus įrašyti kaip adresų diapazono tipo objektus. Tokiu atveju išskirkite potinklio adresą ir transliacijos adresą.
Taigi, žemiau yra scenarijus, kuris išsprendžia šią problemą ir sukuria 50 pagrindinio tipo objektų ir 51 adresų diapazono tipo objektą. Norint išspręsti problemą, reikalingas 101 API iškvietimas (neskaičiuojant galutinio paskelbimo skambučio). Taip pat naudodamiesi timeit moduliu apskaičiuojame laiką, kurio reikia scenarijui įvykdyti iki pakeitimų paskelbimo.
Scenarijus naudojant add-host ir 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')
Mano laboratorijos aplinkoje šis scenarijus paleidžiamas nuo 30 iki 50 sekundžių, atsižvelgiant į valdymo serverio apkrovą.
Dabar pažiūrėkime, kaip išspręsti tą pačią problemą naudojant API iškvietimą pridėti-objektai-partija, kurio palaikymas buvo pridėtas API 1.6 versijoje. Šis skambutis leidžia sukurti daug objektų vienu metu vienoje API užklausoje. Be to, tai gali būti įvairių tipų objektai (pavyzdžiui, pagrindiniai kompiuteriai, potinkliai ir adresų diapazonai). Taigi mūsų užduotis gali būti išspręsta per vieną API iškvietimą.
Scenarijus naudojant 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')
Ir šio scenarijaus paleidimas mano laboratorijos aplinkoje užtrunka nuo 3 iki 7 sekundžių, priklausomai nuo valdymo serverio apkrovos. Tai reiškia, kad vidutiniškai 101 API objekte paketinio tipo iškvietimas veikia 10 kartų greičiau. Didesniam objektų skaičiui skirtumas bus dar įspūdingesnis.
Dabar pažiūrėkime, kaip dirbti nustatyti-objektai-partija. Naudodami šį API iškvietimą galime masiškai keisti bet kurį parametrą. Pirmąją adresų pusę iš ankstesnio pavyzdžio (iki .124 pagrindinio kompiuterio ir diapazonų) nustatykime sienna spalva, o antrajai adresų pusei priskirkime chaki spalvą.
Ankstesniame pavyzdyje sukurtų objektų spalvos keitimas
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")
Galite ištrinti kelis objektus vienu API skambučiu naudodami ištrinti-objektų partiją. Dabar pažvelkime į kodo pavyzdį, kuris ištrina visus anksčiau sukurtus pagrindinius kompiuterius pridėti-objektai-partija.
Objektų ištrynimas naudojant 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)
Visos funkcijos, atsirandančios naujuose „Check Point“ programinės įrangos leidimuose, iš karto gauna API iškvietimus. Taigi R80.40 pasirodė tokios „funkcijos“ kaip Revert to revision ir Smart Task, kurioms iš karto buvo paruošti atitinkami API iškvietimai. Be to, visos funkcijos, pereinant iš senų konsolių į Unified Policy režimą, taip pat įgyja API palaikymą. Pavyzdžiui, ilgai lauktas naujinimas programinės įrangos versijoje R80.40 buvo HTTPS tikrinimo politikos perkėlimas iš Legacy režimo į Unified Policy režimą, ir ši funkcija iš karto sulaukė API skambučių. Pateikiame kodo, kuris prideda taisyklę į aukščiausią HTTPS tikrinimo politikos poziciją, pavyzdį, kuri neleidžia tikrinti 3 kategorijų (sveikatos, finansų, vyriausybinių paslaugų), kurių tikrinimas pagal įstatymą daugelyje šalių draudžiamas.
Pridėkite taisyklę prie HTTPS tikrinimo politikos
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")
„Python“ scenarijų vykdymas „Check Point“ valdymo serveryje
Viskas taip pat yra informacijos, kaip paleisti Python scenarijus tiesiai iš valdymo serverio. Tai gali būti patogu, kai negalite prisijungti prie API serverio iš kito įrenginio. Įrašiau šešių minučių vaizdo įrašą, kuriame žiūriu į modulio diegimą cpapi ir „Python“ scenarijų vykdymo valdymo serveryje funkcijos. Pavyzdžiui, paleidžiamas scenarijus, kuris automatizuoja naujo šliuzo konfigūraciją tokiai užduočiai kaip tinklo auditas. Saugos patikra. Tarp funkcijų, su kuriomis turėjau susidurti: funkcija dar nepasirodė Python 2.7 indėlis, todėl vartotojo įvestai informacijai apdoroti naudojama funkcija raw_input. Kitu atveju kodas toks pat kaip ir paleidžiant iš kitų mašinų, tik patogiau naudotis funkcija login_as_root, kad daugiau nenurodytumėte savo vartotojo vardo, slaptažodžio ir valdymo serverio IP adreso.
Scenarijus, skirtas greitai nustatyti saugos patikrą
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() Failo pavyzdys su slaptažodžių žodynu Additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
išvada
Šiame straipsnyje nagrinėjamos tik pagrindinės darbo galimybės „Python SDK“ ir modulis cpapi(kaip galėjote atspėti, tai iš tikrųjų yra sinonimai), o studijuodami kodą šiame modulyje atrasite dar daugiau galimybių dirbti su juo. Gali būti, kad norėsite jį papildyti savo klasėmis, funkcijomis, metodais ir kintamaisiais. Skiltyje visada galite bendrinti savo darbus ir peržiūrėti kitus „Check Point“ scenarijus bendruomenėje , kuri vienija ir produktų kūrėjus, ir vartotojus.
Sėkmingo kodavimo ir ačiū, kad perskaitėte iki galo!
Šaltinis: www.habr.com