E gjitha fuqia e ndërveprimit me API zbulohet kur përdoret në bashkëpunim me kodin programues, kur krijohen mundësi për të formuar dinamikisht kërkesat API dhe mjetet për analizimin e përgjigjeve API. Megjithatë, ende mbetet pak i njohur Python Software Development Kit ((python — SDK) për Check Point Management API, që është një humbje. Ai e thjeshton ndjeshëm jetën e zhvilluesve dhe entuziastëve të automatizimit. Python ka fituar një popullaritet të madh vitet e fundit dhe unë vendosa të plotësoj boshllëkun dhe të bëj një përmbledhje të mundësive kryesore . Ky artikull shërben si një plotësim i shkëlqyer për një artikull tjetër në Habrë . Ne do të shqyrtojmë se si të shkruajmë skriptet duke përdorur Python SDK dhe do të ndalemi më në detaje në funksionalitetin e ri të Management API në versionin 1.6 (i mbështetur që nga R80.40). Për të kuptuar artikullin, nevojiten njohuri bazike mbi punën me API dhe Python.
Check Point aktivisht zhvillon API dhe deri më tani janë krijuar:
- — puna me serverin e menaxhimit përmes API (dhe mundësia për të ekzekutuar skripte në portat që menaxhohen nga serveri i menaxhimit)
- — punë me portat e sigurisë
- — punimi me sandëçin në re Check Point
- — punimi me blade të Identity Awareness në kaluesit
- — punimi me portalin e menaxhimit të kaluesve SMB ()
- — ndërveprimi me kontrollorët e IoT
- — punimi me (zgjidhja e sigurisë SD-WAN)
- — punimi me
Python SDK aktualisht mbështet vetëm ndërveprimin me Management API dhe Gaia API. Ne do të shqyrtojmë klasat, metodat dhe variablat më të rëndësishme në këtë modul.
Instalimi i modulit
Moduli cpapi instalohet shpejt dhe lehtë nga me anë të pip. Udhëzimi i detajuar për instalimin është në . Ky modul është i adaptuar për të punuar me versionet Python 2.7 dhe 3.7. Në këtë artikull, shembujt do të jepen duke përdorur Python 3.7. Megjithatë, Python SDK mund të ekzekutohet drejtpërdrejt nga serveri i menaxhimit të Check Point (Smart Management), por atje mbështetet vetëm versioni Python 2.7, prandaj në seksionin e fundit do të jepet kodi për versionin 2.7. Menjëherë pas instalimit të modulit, rekomandoj të shikoni shembujt në direktorët examples_python2 dhe examples_python3.
Fillimi i punës
Për të pasur mundësinë të punojmë me komponentet e modulit cpapi, duhet të importojmë nga moduli cpapi të paktën dy klasa të nevojshme:
APIClient dhe APIClientArgs
nga cpapi importo APIClient, APIClientArgs
Klasa APIClientArgs përgjigjet për parametrat e lidhjes me serverin API, ndërsa klasa APIClient përgjigjet për ndërveprimin me API.
Përcaktojmë parametrat e lidhjes
Për të përcaktuar parametra të ndryshëm lidhjeje me API, duhet të krijoni një instancë të klasës APIClientArgs. Në parim, parametrat e saj janë të paracaktuar dhe gjatë ekzekutimit të skriptit në serverin e menaxhimit, nuk është e nevojshme të specifikohen.
client_args = APIClientArgs()Por gjatë ekzekutimit në një host të jashtëm, duhet të specifikoni të paktën adresën IP ose emrin e hostit të serverit API (i njëjti është serveri i menaxhimit). Në shembullin më poshtë, ne përcaktojmë parametrin e lidhjes server dhe i atribuoni atij si një varg adresën IP të serverit të menaxhimit.
client_args = APIClientArgs(server='192.168.47.241')Le ta shohim të gjitha parametrat dhe vlerat e tyre të paracaktuara që mund të përdoren gjatë lidhjes me serverin API:
Argumentet e metodës __init__ të klasës APIClientArgs
class APIClientArgs:
"""
Kjo klasë ofron argumente për konfigurimin e APIClient.
Të gjitha argumentet janë konfiguruar me vlerat e tyre të paracaktuara.
"""
# porta është e vendosur në None si parazgjedhje, por zëvendësohet me 443 nëse nuk është specifikuar
# vlerat e mundshme për kontekst - web_api (parazgjedhja) ose 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
# menaxhimi server evidencë
self.fingerprint = fingerprint
# sesioni-id.
self.sid = sid
# emri ose adresa IP e serverit të menaxhimit
self.server = server
# niveli i debug
self.http_debug_level = http_debug_level
# një array me të gjitha thirrjet API (për qëllime debug)
self.api_calls = api_calls if api_calls else []
# emri i skedës së debug. Nëse lëshohet bosh, të dhënat e debug nuk do të ruhen në disk.
self.debug_file = debug_file
# adresa e serverit të proxy HTTP (pa "http://")
self.proxy_host = proxy_host
# porta e proxy HTTP
self.proxy_port = proxy_port
# versioni i API të serverit të menaxhimit
self.api_version = api_version
# Tregon se klienti nuk duhet të kontrollojë certifikatën e serverit
self.unsafe = unsafe
# Tregon se klienti duhet automatikisht të pranojë dhe të ruajë certifikatën e serverit
self.unsafe_auto_accept = unsafe_auto_accept
# Konteksti i përdorimit të klientit - parazgjedhja është web_api
self.context = contextMendoj se argumentet që mund të përdoren në instancat e klasës APIClientArgs, janë intuitivisht të qarta për administratorët e Check Point dhe nuk kanë nevojë për komente të mëtejshme.
Lidheni përmes APIClient dhe menaxherit të kontekstit
Klasa APIClient është më e lehtë të përdoret përmes menaxherit të kontekstit. Gjithçka që duhet t'i kalosh instancës së klasës APIClient janë parametrat e lidhjes të caktuar në hapin e mëparshëm.
with APIClient(client_args) as client:
Menaxheri i kontekstit nuk do të kryejë automatikisht thirrjen login në serverin API, megjithatë, ai do të kryejë thirrjen logout kur të dilni prej tij. Nëse për ndonjë arsye thirrja logout në fund të punës me thirrjet API nuk është e nevojshme, duhet të filloni punën pa përdorur menaxherin e kontekstit:
client = APIClient(client_args)Kontrolli i lidhjes
Të kontrollosh nëse lidhja kalon përmes parametrave të caktuar është më e lehtë me metodën check_fingerprint. Nëse verifikimi i hash-it sha1 për fingerprint-in e certifikatës së serverit API nuk kalon (metoda ktheu False), atëherë zakonisht kjo shkaktohet nga problemi me lidhjen dhe ne mund të ndalim ekzekutimin e programit (ose t'i japim përdoruesit mundësinë të rregullojë të dhënat për lidhjen):
nëse client.check_fingerprint() është False:
print("Nuk mund të marrësh gjurmën e serverit - Kontakto me serverin.")
exit(1)
Kujdesi, klasë APIClient do të verifikojë në çdo thirrje API (metodat api_call dhe api_query, për të cilat do të flasim më vonë) gjurmën sha1 të certifikatës në serverin API. Nëse gjatë verifikimit të gjurmës sha1 të certifikatës së serverit API zbulohet një gabim (certifikata e panjohur ose e modifikuar), metoda check_fingerprint do të ofrojë mundësinë për të shtuar/modifikuar informacionin në lidhje me të në makinën lokale në mënyrë automatike. Këtë verifikim mund ta rrethosh krejtësisht (por rekomandohet vetëm në rastin e ekzekutimit të skripteve në vetë serverin API, kur lidhet me 127.0.0.1), duke përdorur argumentin APIClientArgs — unsafe_auto_accept (shiko më shumë për APIClientArgs më herët në "Përcaktimi i parametrave të lidhjes").
client_args = APIClientArgs(unsafe_auto_accept=True)Hyrja në serverin API
Tek APIClient ka 3 metoda për hyrje në serverin API, dhe secila prej tyre ruan vlerën sid(id e sesionit), e cila përdoret automatikisht në çdo thirrje të mëtejshme API në header (emri në header për këtë parametër — X-chkp-sid), kështu që nuk është e nevojshme të përpunosh sërish këtë parametër.
Metoda e hyrjes
Opcioni me përdorimin e emrit të përdoruesit dhe fjalëkalimit (në shembuj emri i përdoruesit admin dhe fjalëkalimi 1q2w3e janë dërguar si argumente pozita):
login = client.login('admin', '1q2w3e') Në metodën login janë gjithashtu të disponueshme disa parametra të tjerë opsionalë, këtu janë emrat e tyre dhe vlerat standarde:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetoda login_with_api_key
Opcioni me përdorimin e çelësit API (mbështetet që nga versioni i menaxhimit R80.40/Management API v1.6, «3TsbPJ8ZKjaJGvFyoFqHFA==» ky është vlera e çelësit API për një nga përdoruesit në serverin e menaxhimit me metodën e autorizimit API key):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Në metodën login_with_api_key janë të disponueshme të njëjtat parametra opsionalë si në metodën login.
Metoda login_as_root
Opcioni i login-it në makinën lokale me serverin API:
login = client.login_as_root()Për këtë metodë janë vetëm dy parametra opsionalë:
domain=None, payload=NoneDhe përfundimisht vetë thirrjet API
Kemi dy opsione për të bërë thirrje API përmes metodave api_call dhe api_query. Le të shqyrtojmë se çfarë ndryshimi ka midis tyre.
api_call
Ky metodë është e aplikueshme për çdo thirrje. Na duhet të dërgojmë pjesën e fundit për thirrjen API dhe payload-in në trupin e kërkesës kur është e nevojshme. Nëse payload është i zbrazët, atëherë nuk është e nevojshme ta dërgojmë fare:
api_versions = client.api_call('show-api-versions') Shfaqja për këtë kërkesë është më poshtë:
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'})Shfaqja për këtë kërkesë është më poshtë:
Në [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "e zezë",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "Përdoruesi SMC",
"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": "i çelur",
"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": "e zezë",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "Përdoruesi SMC",
"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": "i çelur",
"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
Së pari, dua të sqaroj se ky metod është i aplikueshëm vetëm për thirrje, ku rezultati parashikon offset (shkallim). Ky rezultat ndodh kur përmban ose mund të përmbajë një sasi të madhe informacioni. Për shembull, kjo mund të jetë një kërkesë për listën e të gjitha objekteve të krijuara të tipit host në serverin e menaxhimit. Për këto kërkesa, API-ja kthen një listë prej 50 objekteve si parazgjedhje (mund të rritet kufiri deri në 500 objekte në përgjigje). Dhe për të mos u përfshirë në marrjen e informacionit disa herë duke ndryshuar parametrin offset në kërkesën API, ekziston metoda api_query, e cila e bën këtë punë automatikisht. Shembujt e thirrjeve ku nevojitet ky metod: 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. Në fakt, në emrin e këtyre thirrjeve API shohim fjalë në shumës, kështu që këto thirrje do të jenë më të lehta për t'u përpunuar përmes api_query
show_hosts = client.api_query('show-hosts') Shfaqja për këtë kërkesë është më poshtë:
Në [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, mund të përdoren variablat dhe metodat e klasës APIResponse(si brenda menaxherit të kontekstit, ashtu edhe jashtë). Klasa APIResponse ka 4 metoda të paracaktuara dhe 5 variabla, për të cilët do të ndaleshim më në hollësi.
sukses
Për fillim, do të ishte mirë të sigurohemi që thirrja API ka përfunduar me sukses dhe ka kthyer rezultat. Për këtë ka një metodë sukses:
In [49]: api_versions.success
Out[49]: True
Kthen True nëse thirrja API ka përfunduar me sukses (Kodi i përgjigjes — 200) dhe False nëse nuk ka përfunduar me sukses (çdo kod tjetër përgjigjeje). E dobishme për t'u përdorur menjëherë pas thirrjes API, për të treguar informacione të ndryshme në varësi të kodit të përgjigjes.
if api_ver.sukses:
print(api_versions.data)
else:
print(api_versions.err_message) kodstatusi
Kthen kodin e përgjigjes pas përfundimit të thirrjes API.
In [62]: api_versions.status_code
Out[62]: 400
Kodin e mundshëm të përgjigjeve: 200,400,401,403,404,409,500,501.
set_sukses_status
Kjo mund të kërkojë ndërrimin e vlerës së statusit success. Teknikisht, mund të vendoset çdo gjë aty, madje edhe një varg i zakonshëm. Por një shembull i vërtetë mund të jetë rregullimi i këtij parametri në False nën kushte të caktuara. Më poshtë, vini re një shembull kur ka detyra që ekzekutohen në serverin e menaxhimit, por do ta konsiderojmë këtë kërkesë si të dështuar (do ta vendosim variablin success në False, megjithëse thirrja API ishte e suksesshme dhe ktheu kodin 200).
për detyrën në task_result.data["tasks"]:
nëse detyra["status"] == "dështoi" ose detyra["status"] == "partsialisht e suksesshme":
task_result.set_success_status(False)
breakresponse()
Metoda response lejon që të shikoni një fjalor me kodin e përgjigjes (status_code) dhe trupin e përgjigjes (body).
Në [94]: api_versions.response()
Dalja[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
Lejon të shikoni vetëm trupin e përgjigjes (body) pa informacion të tepruar.
Në [93]: api_versions.data
Dalja[93]:
{'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}
error_message
Kjo informacion është e disponueshme vetëm kur gjatë përpunimit të kërkesës API ndodhi një gabim (kode përgjigjeje nuk 200). Shembulli i daljes
Në [107]: api_versions.error_message
Dalja[107]: 'kod: generic_err_invalid_parameter_nënmesazh: Parametri [1] nuk njihetn'
Shembuj të dobishëm
Më poshtë janë listuar shembuj, ku përdoren thirrje API që janë shtuar në versionin Management API 1.6.
Së pari, le të shqyrtojmë funksionimin e thirrjeve add-host dhe add-address-range. Le të supozojmë se na nevojitet të krijojmë si objekte të tipit host të gjitha adresat IP të nënpunësit 192.168.0.0/24, ku okteti i fundit është 5, dhe të gjitha adresat IP të tjera t'i shkruajmë si objekte të tipit diapazon adresash. Në këtë rast, adresa e nënpunësit dhe adresa e transmetimit nuk përfshihen.
Pra, më poshtë është një skenar ku zgjidhet ky problem dhe krijohen 50 objekte të tipit host dhe 51 objekt të tipit diapazon adresash. Zgjidhja e problemit kërkon 101 thirrje API (pa llogaritur thirrjen përfundimtare publish). Gjithashtu me modulin timeit llogarisim kohën për ekzekutimin e skenarit deri në momentin e publikimit të ndryshimeve.
Skenari me përdorimin e 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ë ambientin tim laboratorik, për ekzekutimin e këtij skripti, nevojiten nga 30 deri në 50 sekonda në varësi të ngarkesës në serverin e menaxhimit.
Tani le të shohim si ta zgjidhim të njëjtën detyrë duke përdorur thirrjen API add-objects-batch, mbështetje për të cilin është shtuar në versionin API 1.6. Kjo thirrje lejon që me një kërkesë API të krijoni një shumëllojshmëri objektesh menjëherë. Ndërsa këto mund të jenë objekte të ndryshme (p.sh. host, subnet dhe diapazone adresash). Në këtë mënyrë, detyra jonë mund të zgjidhet brenda një thirrje API.
Skripti me përdorimin e 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')
Koha zgjidhni këtë skript në ambientin tim të laboratorit, zgjat nga 3 deri në 7 sekonda, në varësi të ngarkesës së serverit të menaxhimit. Pra, mesatarisht, për 101 objekte, thirrja API e tipit batch, ekzekutohet 10 herë më shpejt. Me një numër më të madh objektesh, diferenca do të jetë akoma më shokuese.
Tani le të shohim se si të punojmë me set-objects-batch. Me ndihmën e këtij thirrjeje API, ne mund të ndryshojmë në masë çdo parametr. Le të caktojmë ngjyrën sienna për gjysmën e parë të adresave nga shembulli i kaluar (deri te .124 e hostit, përfshirë dhe intervalet) dhe ngjyrën khaki për 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")
Kështu që mund të fshini një grup objekte në një thirrje API duke përdorur delete-objects-batch. Tani le të shikojmë një shembull kodi që fshin të gjitha hostet e krijuar më herët përmes add-objects-batch.
Fshirja e objekteve duke përdorur delete-objects-batch
nga cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
për ip në 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
}]
}
me APIClient(client_args) si klient:
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ë lëshimet e reja të softuerit Check Point, menjëherë marrin edhe thirrjet API. Kështu, në R80.40 u shfaqën disa "veçori" si Revert to revision dhe Smart Task, dhe për to u përgatitën menjëherë thirrjet përkatëse API. Më tepër, gjithë funksionaliteti gjatë kalimit nga konsolat Legacy në mënyrën Unified Policy gjithashtu merr mbështetje API. Për shembull, një përmirësim i shumëpritur në versionin e softuerit R80.40 ishte kalimi i politikës HTTPS Inspection nga mënyra Legacy në mënyrën Unified Policy, dhe ky funksionalitet menjëherë mori thirrjet API. Ja një shembull i kodit që shton në pozitat e sipërme të politikës HTTPS Inspection një rregull që përjashton nga inspektimi 3 kategori (Shëndetësia, Financa, Shërbimet Qeveritare), të cilat ndalohen të inspektohen sipas legjislacionit në disa vende.
Shto një rregull në politiken e HTTPS Inspection
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Kërkesat Ligjore",
"action": "bypass",
"site-category": ["Shëndet", "Qeveri / Ushtarak", "Shërbime Financiare"]
}
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")
Shkarkimi i skripteve Python në serverin e menaxhimit Check Point
E njëjta gjë informacioni mbi mënyrën e të ekzekutuarit skripte në Python direkt nga serveri menaxher. Kjo mund të jetë e dobishme kur nuk keni mundësi të lidhni me serverin API nga një makin tjetër. Kam regjistruar një video prej gjashtë minutash ku shqyrtoj instalimin e modulit cpapi dhe veçoritë e ekzekutimit të skripteve Python në serverin menaxher. Si një shembull, ekzekutohet një skript që automatizon konfigurimin e një gateway të ri për një detyrë si auditimi i rrjetit Kontrolli i Sigurisë. Një nga veçoritë me të cilat u përballëm ishte se në versionin Python 2.7 nuk kishte kaluar funksioni input, prandaj për trajtimin e informacionit që jep përdoruesi, përdoret funksioni raw_input. Për sa i përket pjesës tjetër, kodi është i njëjtë si për ekzekutimin nga makinat e tjera, vetëm se është më e lehtë të përdoret funksioni login_as_root, në mënyrë që të mos i shkruani përsëri emrin tuaj të përdoruesit, fjalëkalimin dhe adresën IP të serverit menaxher.
Skripti për konfigurimin e shpejtë të Kontrollit të Sigurisë
nga __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():
me klientin APIClient() si client:
# nese client.check_fingerprint() eshte False:
# print("Nuk mund te marrim gjurmën e serverit - Kontrolloni lidhjen me serverin.")
# exit(1)
login_res = client.login_as_root()
nese login_res.success eshte False:
print("Dështimi i aksesit:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Shkruani emrin e gateway-it:")
gw_ip = raw_input("Shkruani adresën IP të gateway-it:")
nese sys.stdin.isatty():
sic = getpass.getpass("Shkruani fjalëkalimin njëherësh për gateway-in (SIC): ")
else:
print("Këshillë! Fjalëkalimi juaj do të shfaqet në ekran!")
sic = raw_input("Shkruani fjalëkalimin njëherësh për gateway-in (SIC): ")
version = raw_input("Shkruani versionin e gateway-it (si 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'})
nese add_gw.success dhe add_gw.data['sic-state'] != "communicating":
print("Lidhja e sigurt me gateway-in nuk është vendosur!")
exit(1)
elif add_gw.success:
print("Gateway-i u shtua me sukses.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Dështimi për të shtuar gateway-in - {}".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"})
nese change_policy.success:
print("Politika është ndryshuar me sukses")
else:
print("Dështimi për të ndryshuar politikën- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Rregulli i pastrimit", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
nese change_rule.success:
print("Rregulli i pastrimit është ndryshuar me sukses")
else:
print("Dështimi për të ndryshuar rregullin e pastrimit- {}".format(change_rule.error_message))
# publikoni rezultatin
publish_res = client.api_call("publish", {})
nese publish_res.success:
print("Ndryshimet janë publikuar me sukses.")
else:
print("Dështimi për të publikuar ndryshimet - {}".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})
nese install_access_policy.success:
print("Politika e aksesit është instaluar")
else:
print("Dështimi për të instaluar politikën e aksesit - {}".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})
nese install_tp_policy.success:
print("Politika e parandalimit të kërcënimeve është instaluar")
else:
print("Dështimi për të instaluar politikën e parandalimit të kërcënimeve - {}".format(install_tp_policy.error_message))
# shtoni fjalëkalimet dhe fjalëkalimet në fjalor
me hap 'additional_pass.conf' si f:
line_num = 0
për linjë në f:
line_num += 1
add_password_dictionary = client.api_call("run-script", {"script-name" : "Shto fjalëkalimet dhe fjalëkalimet", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(linjen), "targets" : gw_name})
nese add_password_dictionary.success:
print("Linja e fjalëkalimit në fjalor {} u shtua me sukses".format(line_num))
else:
print("Dështimi për të shtuar fjalorin - {}".format(add_password_dictionary.error_message))
main() Shembuj skedari me fjalorin e fjalëkalimeve additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","fjalëkalim","Fjalëkalim","Çelës","çelës","shifrë","Shifrë"]
}
Përfundimi
Ky artikull shqyrton vetëm mundësitë bazë të punës Python SDK dhe modulit cpapi(siç mund ta keni kuptuar, këto janë në fakt sinonime), dhe duke studiuar kodin në këtë modul do të hapni përpara jush më shumë mundësi në punën me të. Nuk është e pamundur që të dëshironit të shtoni klasat, funksionet, metodat dhe variablat tuaja. Gjithmonë mund të ndani punimet tuaja dhe të shikoni skriptet e tjera për Check Point në seksionin në komunitetin , i cili bashkon zhvilluesit e produkteve dhe përdoruesit.
Kënaquni me kodimin dhe faleminderit që e lexuat deri në fund!
Burimi: habr.com
