Fuqia e plotë e ndërveprimit me API-të zbulohet kur përdoret së bashku me kodin e programit, kur bëhet e mundur të gjenerohen në mënyrë dinamike kërkesat dhe mjetet e API për analizimin e përgjigjeve të API. Megjithatë, ajo ende mbetet e pavërejtur Kompleti i zhvillimit të softuerit Python (më tej referuar si Python SDK) për Check Point Management API, por më kot. Ai thjeshton ndjeshëm jetën e zhvilluesve dhe entuziastëve të automatizimit. Python ka fituar një popullaritet të madh kohët e fundit dhe vendosa të plotësoj boshllëkun dhe të rishikoj veçoritë kryesore. . Ky artikull shërben si një shtesë e shkëlqyer për një artikull tjetër mbi Habré . Ne do të shikojmë se si të shkruajmë skriptet duke përdorur Python SDK dhe do të hedhim një vështrim më të afërt në funksionalitetin e ri të Menaxhimit API në versionin 1.6 (mbështetur duke filluar nga R80.40). Për të kuptuar artikullin, do t'ju duhet njohuri bazë për të punuar me API dhe Python.
Check Point po zhvillon në mënyrë aktive API-në dhe për momentin janë lëshuar këto:
- — punoni me serverin e kontrollit nëpërmjet API (dhe aftësinë për të ekzekutuar skriptet në portat e kontrolluara nga serveri i kontrollit)
- — punoni me portat e sigurisë
- — duke punuar me një sandbox në renë Check Point
- — duke punuar me tehun e ndërgjegjësimit të identitetit në porta
- — punoni me portalin e menaxhimit të portës SMB ()
- — ndërveprimi me kontrollorët e IoT
- - punojnë me (Zgjidhja e sigurisë SD-WAN)
- - punojnë me
Python SDK aktualisht mbështet vetëm ndërveprimin me API të Menaxhimit dhe Gaia API. Ne do të shohim klasat, metodat dhe variablat më të rëndësishme në këtë modul.
Instalimi i modulit
Modul cpapi instalohet shpejt dhe lehtë nga me ndihmën e cicërin. Udhëzimet e hollësishme të instalimit janë në dispozicion në . Ky modul është përshtatur për të punuar me versionet 2.7 dhe 3.7 të Python. Në këtë artikull do të jepen shembuj duke përdorur Python 3.7. Sidoqoftë, Python SDK mund të ekzekutohet drejtpërdrejt nga serveri i menaxhimit të pikave të kontrollit (Menaxhimi i zgjuar), por ata mbështesin vetëm Python 2.7, kështu që seksioni i fundit do të sigurojë kodin për versionin 2.7. Menjëherë pas instalimit të modulit, unë rekomandoj të shikoni shembujt në drejtori shembuj_python2 и shembuj_python3.
Si T'ia Fillohet
Në mënyrë që ne të mund të punojmë me komponentët e modulit cpapi, duhet të importojmë nga moduli cpapi të paktën dy klasa të kërkuara:
APIClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Klasë APIClientArgs është përgjegjës për parametrat e lidhjes me serverin API dhe klasën APIClient është përgjegjës për ndërveprimin me API.
Përcaktimi i parametrave të lidhjes
Për të përcaktuar parametra të ndryshëm për t'u lidhur me API, duhet të krijoni një shembull të klasës APIClientArgs. Në parim, parametrat e tij janë të paracaktuar dhe kur ekzekutoni skriptin në serverin e kontrollit, ato nuk kanë nevojë të specifikohen.
client_args = APIClientArgs()Por kur ekzekutoni në një host të palës së tretë, duhet të specifikoni të paktën adresën IP ose emrin e hostit të serverit API (i njohur gjithashtu si serveri i menaxhimit). Në shembullin më poshtë, ne përcaktojmë parametrin e lidhjes së serverit dhe i caktojmë adresën IP të serverit të menaxhimit si një varg.
client_args = APIClientArgs(server='192.168.47.241')Le të shohim të gjithë parametrat dhe vlerat e tyre të paracaktuara që mund të përdoren kur lidheni me serverin API:
Argumentet e metodës __init__ të klasës 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 = contextUnë besoj se argumentet që mund të përdoren në instancat e klasës APIClientArgs janë intuitive për administratorët e Check Point dhe nuk kërkojnë komente shtesë.
Lidhja përmes APIClient dhe menaxherit të kontekstit
Klasë APIClient Mënyra më e përshtatshme për ta përdorur atë është përmes menaxherit të kontekstit. Gjithçka që duhet t'i kalohet një shembulli të klasës APIClient janë parametrat e lidhjes që u përcaktuan në hapin e mëparshëm.
with APIClient(client_args) as client:
Menaxheri i kontekstit nuk do të bëjë automatikisht një thirrje identifikimi në serverin API, por do të bëjë një telefonatë daljeje kur të dalë nga ai. Nëse për ndonjë arsye nuk kërkohet dalja pas përfundimit të punës me thirrjet API, duhet të filloni të punoni pa përdorur menaxherin e kontekstit:
client = APIClient(clieng_args)Testi i lidhjes
Mënyra më e lehtë për të kontrolluar nëse lidhja plotëson parametrat e specifikuar është përdorimi i metodës kontrolloni_gjurmën e gishtit. Nëse verifikimi i shumës sha1 shaXNUMX për gjurmën e gishtit të certifikatës API të serverit dështon (metoda u kthye I rremë), atëherë kjo zakonisht shkaktohet nga problemet e lidhjes dhe ne mund të ndalojmë ekzekutimin e programit (ose t'i japim përdoruesit mundësinë të korrigjojë të dhënat e lidhjes):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Ju lutemi vini re se në të ardhmen klasa APIClient do të kontrollojë çdo thirrje API (metodat api_call и api_query, do të flasim për to pak më tej) certifikata sha1 e gjurmëve të gishtave në serverin API. Por nëse, kur kontrolloni gjurmën e gishtit sha1 të certifikatës së serverit API, zbulohet një gabim (certifikata është e panjohur ose është ndryshuar), metoda kontrolloni_gjurmën e gishtit do të ofrojë mundësinë për të shtuar/ndryshuar informacionin rreth tij në makinën lokale automatikisht. Ky kontroll mund të çaktivizohet plotësisht (por kjo mund të rekomandohet vetëm nëse skriptet ekzekutohen në vetë serverin API, kur lidheni me 127.0.0.1), duke përdorur argumentin APIClientArgs - unsafe_auto_pranoj (shih më shumë rreth APIClientArgs më herët në "Përcaktimi i parametrave të lidhjes").
client_args = APIClientArgs(unsafe_auto_accept=True)Hyni në serverin API
У APIClient ka deri në 3 metoda për të hyrë në serverin API, dhe secila prej tyre e kupton kuptimin sid(sesion-id), i cili përdoret automatikisht në çdo thirrje pasuese API në kokë (emri në kokën e këtij parametri është X-chkp-sid), kështu që nuk ka nevojë të përpunohet më tej ky parametër.
mënyra e hyrjes
Opsioni duke përdorur hyrjen dhe fjalëkalimin (në shembull, emri i përdoruesit admin dhe fjalëkalimi 1q2w3e kalohen si argumente pozicionale):
login = client.login('admin', '1q2w3e') Parametra shtesë opsionalë janë gjithashtu të disponueshëm në metodën e hyrjes; këtu janë emrat e tyre dhe vlerat e paracaktuara:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetoda Login_with_api_key
Opsioni duke përdorur një çelës api (mbështetur duke filluar nga versioni i menaxhimit R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" kjo është vlera kryesore e API për një nga përdoruesit në serverin e menaxhimit me metodën e autorizimit të çelësit API):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Në metodë login_with_api_key të njëjtat parametra opsionalë janë të disponueshëm si në metodë hyrje.
metodë login_as_root
Opsioni për t'u identifikuar në një makinë lokale me një server API:
login = client.login_as_root()Ekzistojnë vetëm dy parametra opsionalë të disponueshëm për këtë metodë:
domain=None, payload=NoneDhe së fundi API e quan veten
Ne kemi dy opsione për të bërë thirrje API përmes metodave api_call и api_query. Le të kuptojmë se cili është ndryshimi midis tyre.
api_call
Kjo metodë është e zbatueshme për çdo telefonatë. Ne duhet të kalojmë pjesën e fundit për thirrjen api dhe ngarkesën në trupin e kërkesës nëse është e nevojshme. Nëse ngarkesa është bosh, atëherë ajo nuk mund të transferohet fare:
api_versions = client.api_call('show-api-versions') Prodhimi për këtë kërkesë nën prerjen:
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'})Prodhimi për këtë kërkesë nën prerjen:
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
Më lejoni të bëj një rezervë menjëherë se kjo metodë është e zbatueshme vetëm për telefonatat, prodhimi i të cilave përfshin kompensim. Një përfundim i tillë ndodh kur ai përmban ose mund të përmbajë një sasi të madhe informacioni. Për shembull, kjo mund të jetë një kërkesë për një listë të të gjitha objekteve të krijuara pritës në serverin e menaxhimit. Për kërkesa të tilla, API kthen një listë me 50 objekte si parazgjedhje (mund ta rrisni kufirin në 500 objekte në përgjigje). Dhe për të mos tërhequr informacionin disa herë duke ndryshuar parametrin e kompensimit në kërkesën API, ekziston një metodë api_query që e bën këtë punë automatikisht. Shembuj të thirrjeve ku nevojitet kjo metodë: shfaqje-sesionet, prezantuesit e shfaqjeve, rrjetet e shfaqjes, shenjat e shfaqjes, grupet e shfaqjes, intervalet e adresave të shfaqjes, portat e thjeshta të shfaqjes, grupet e shfaqjeve të thjeshta, rolet e shfaqjes së aksesit, shfaqja e klientëve të besuar, show-pako. Në fakt, ne shohim shumë fjalë në emër të këtyre thirrjeve API, kështu që këto thirrje do të jenë më të lehta për t'u trajtuar api_query
show_hosts = client.api_query('show-hosts') Prodhimi për këtë kërkesë nën prerjen:
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
})
Përpunimi i rezultateve të thirrjeve API
Pas kësaj ju mund të përdorni variablat dhe metodat e klasës APIresponse(si brenda menaxherit të kontekstit ashtu edhe jashtë). Në klasë APIresponse 4 metoda dhe 5 variabla janë të paracaktuara; ne do të ndalemi në më të rëndësishmet më në detaje.
sukses
Për të filluar, do të ishte një ide e mirë të sigurohesh që thirrja API ishte e suksesshme dhe kishte një rezultat. Ekziston një metodë për këtë sukses:
In [49]: api_versions.success
Out[49]: True
Kthen "E vërtetë" nëse thirrja API ishte e suksesshme (kodi i përgjigjes - 200) dhe "E gabuar" nëse nuk ishte e suksesshme (ndonjë kod tjetër përgjigjeje). Është i përshtatshëm për t'u përdorur menjëherë pas një thirrjeje API për të shfaqur informacione të ndryshme në varësi të kodit të përgjigjes.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) kodi i statusit
Kthen kodin e përgjigjes pasi të jetë kryer një thirrje API.
In [62]: api_versions.status_code
Out[62]: 400
Kodet e mundshme të përgjigjes: 200,400,401,403,404,409,500,501.
vendosi_statusin_sukses
Në këtë rast, mund të jetë e nevojshme të ndryshohet vlera e statusit të suksesit. Teknikisht, mund të vendosni gjithçka, madje edhe një varg të rregullt. Por një shembull i vërtetë do të ishte rivendosja e këtij parametri në False në kushte të caktuara shoqëruese. Më poshtë, kushtojini vëmendje shembullit kur ka detyra që ekzekutohen në serverin e menaxhimit, por ne do ta konsiderojmë këtë kërkesë të pasuksesshme (ne do ta vendosim variablin e suksesit në I rremë, pavarësisht se thirrja API ishte e suksesshme dhe ktheu kodin 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakpërgjigje ()
Metoda e përgjigjes ju lejon të shikoni fjalorin me kodin e përgjigjes (status_code) dhe trupin e përgjigjes (trupin).
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']}}
të dhëna
Ju lejon të shihni vetëm trupin e përgjigjes (trupit) pa informacione të panevojshme.
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']}
mesazh_gabim
Ky informacion është i disponueshëm vetëm kur ka ndodhur një gabim gjatë përpunimit të kërkesës API (kodi i përgjigjes jo 200). Shembull i prodhimit
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Shembuj të dobishëm
Më poshtë janë shembuj që përdorin thirrjet API që janë shtuar në Management API 1.6.
Së pari, le të shohim se si funksionojnë thirrjet shtoj-host и shto-adresa-varg. Le të themi se duhet të krijojmë të gjitha adresat IP të nënrrjetit 192.168.0.0/24, okteti i fundit i së cilës është 5, si objekte të tipit host, dhe të shkruajmë të gjitha adresat IP të tjera si objekte të llojit të gamës së adresave. Në këtë rast, përjashtoni adresën e nënrrjetit dhe adresën e transmetimit.
Pra, më poshtë është një skript që zgjidh këtë problem dhe krijon 50 objekte të llojit host dhe 51 objekte të llojit të gamës së adresave. Për të zgjidhur problemin, kërkohen 101 thirrje API (pa llogaritur thirrjen përfundimtare të publikimit). Gjithashtu, duke përdorur modulin timeit, ne llogarisim kohën që duhet për të ekzekutuar skriptin derisa të publikohen ndryshimet.
Skript duke përdorur add-host dhe 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')
Në mjedisin tim të laboratorit, ky skript merr nga 30 deri në 50 sekonda për t'u ekzekutuar, në varësi të ngarkesës në serverin e menaxhimit.
Tani le të shohim se si të zgjidhim të njëjtin problem duke përdorur një thirrje API shtoj-objekte-batch, mbështetja për të cilën u shtua në versionin 1.6 të API. Kjo thirrje ju lejon të krijoni shumë objekte në të njëjtën kohë në një kërkesë API. Për më tepër, këto mund të jenë objekte të llojeve të ndryshme (për shembull, hoste, nënrrjeta dhe vargjet e adresave). Kështu, detyra jonë mund të zgjidhet brenda kornizës së një thirrjeje API.
Skript duke përdorur 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')
Dhe ekzekutimi i këtij skripti në mjedisin tim laboratorik zgjat nga 3 deri në 7 sekonda, në varësi të ngarkesës në serverin e menaxhimit. Kjo do të thotë, mesatarisht, në 101 objekte API, një thirrje e tipit grupor ekzekutohet 10 herë më shpejt. Në një numër më të madh objektesh ndryshimi do të jetë edhe më mbresëlënës.
Tani le të shohim se si të punojmë me grup-objekte-batch. Duke përdorur këtë thirrje API, ne mund të ndryshojmë në masë çdo parametër. Le të vendosim gjysmën e parë të adresave nga shembulli i mëparshëm (deri në .124 hoste, dhe vargjet gjithashtu) në ngjyrën sienna dhe caktojmë ngjyrën kaki në gjysmën e dytë të adresave.
Ndryshimi i ngjyrës së objekteve të krijuara në shembullin e mëparshëm
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")
Mund të fshini shumë objekte në një thirrje API duke përdorur fshij-objektet-batch. Tani le të shohim një shembull kodi që fshin të gjithë hostet e krijuar më parë nëpërmjet shtoj-objekte-batch.
Fshirja e objekteve duke përdorur 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)
Të gjitha funksionet që shfaqen në versionet e reja të softuerit Check Point marrin menjëherë thirrje API. Kështu, në R80.40 u shfaqën "karakteristika" të tilla si Kthimi në rishikim dhe Smart Task, dhe thirrjet përkatëse API u përgatitën menjëherë për to. Për më tepër, i gjithë funksionaliteti kur kalon nga konzollat e trashëguara në modalitetin e Politikës së Bashkuar fiton gjithashtu mbështetje API. Për shembull, përditësimi i shumëpritur në versionin e softuerit R80.40 ishte zhvendosja e politikës së inspektimit HTTPS nga modaliteti i trashëgimisë në modalitetin e politikës së bashkuar dhe ky funksion mori menjëherë thirrje API. Këtu është një shembull i kodit që shton një rregull në pozicionin kryesor të politikës së Inspektimit HTTPS që përjashton 3 kategori nga inspektimi (Shëndetësia, Financa, Shërbimet Qeveritare), të cilave u ndalohet inspektimi në përputhje me ligjin në një numër vendesh.
Shtoni një rregull në politikën e inspektimit 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")
Ekzekutimi i skripteve Python në serverin e menaxhimit të Check Point
Gjithçka është e njëjtë përmban informacion se si të ekzekutohen skriptet Python direkt nga serveri i kontrollit. Kjo mund të jetë e përshtatshme kur nuk jeni në gjendje të lidheni me serverin API nga një makinë tjetër. Kam regjistruar një video gjashtë minutëshe në të cilën shikoj instalimin e modulit cpapi dhe veçoritë e ekzekutimit të skripteve Python në serverin e kontrollit. Si shembull, ekzekutohet një skript që automatizon konfigurimin e një porte të re për një detyrë të tillë si auditimi i rrjetit Kontrolli i Sigurisë. Ndër veçoritë me të cilat duhej të merresha: funksioni nuk është shfaqur ende në Python 2.7 të dhëna, kështu që për të përpunuar informacionin që fut përdoruesi, përdoret një funksion hyrje_të papërpunuara. Përndryshe, kodi është i njëjtë si për nisjen nga makinat e tjera, vetëm se është më i përshtatshëm për të përdorur funksionin login_as_root, në mënyrë që të mos specifikoni përsëri emrin tuaj të përdoruesit, fjalëkalimin dhe adresën IP të serverit të menaxhimit.
Skript për konfigurimin e shpejtë të Kontrollit të Sigurisë
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() Një skedar shembull me një fjalor fjalëkalimi shtesë_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Përfundim
Ky artikull shqyrton vetëm mundësitë themelore të punës Python SDK dhe modul cpapi(siç mund ta keni marrë me mend, këto janë në fakt sinonime), dhe duke studiuar kodin në këtë modul do të zbuloni edhe më shumë mundësi për të punuar me të. Është e mundur që ju të dëshironi ta plotësoni atë me klasat, funksionet, metodat dhe variablat tuaja. Ju gjithmonë mund të ndani punën tuaj dhe të shikoni skriptet e tjera për Check Point në seksion në komunitet , i cili bashkon zhvilluesit dhe përdoruesit e produkteve.
Gëzuar kodimin dhe faleminderit që e lexuat deri në fund!
Burimi: www.habr.com