Kogu API võimekus avatakse koostöös programmikoodiga, võimaldades dünaamiliselt luua API päringuid ja tööriistu API vastuste analüüsimiseks. Kuid seni on vähem märgatud Python'i tarkvaraarenduse komplekti (edaspidi — Python SDK) for Check Point Management API, mida on kahju. See muudab arendajate ja automatiseerimise entusiastide elu oluliselt lihtsamaks. Python on viimasel ajal saavutanud tohutut populaarsust ning ma otsustasin täita tühimiku ja teha ülevaate peamistest võimalustest . See artikkel on suurepärane lisa teisele artiklile Habrisse . Me vaatame, kuidas kirjutada skripte, kasutades Python SDK-d, ja peatume lähemalt Management API uuel funktsionaalsusel versioonis 1.6 (toetatakse alates R80.40). Artikli mõistmiseks on vajalikud põhitõed API ja Python töötamise osas.
Check Point arendab aktiivselt API-d ja hetkel on ilmunud:
- — töö juhtimisserveriga läbi API (ja võimalus käitada skripte väravates, mis on juhtimisserveri all)
- — töös turvaväravatega
- — töös Check Point'i liivakastiga
- — töös Identity Awareness blade'i turvaväravates
- — töös SMB turvaväravate haldusportaaliga ()
- — suhtlemine IoT kontrolleritega
- — töös (SD-WAN security lahendus)
- — töös
Python SDK toetab praegu ainult Management API ja Gaia API. Käsitleme selle mooduli olulisemaid klasse, meetodeid ja muutujaid.
Mooduli
Modul cpapi paigaldamine on kiire ja lihtne kasutades pip. Üksikasjalik installatsiooni juhend on saadaval . See moodul on kohandatud töötamiseks Python 2.7 ja 3.7 versioonidega. Antud artiklis on näited toodud kasutades Python 3.7. Siiski, Python SDK-d saab käivitada otse Check Point'i haldusserverilt (Smart Management), kuid seal toetatakse ainult Python 2.7 versiooni, seega viimases osas on toodud kood versioonile 2.7. Kohe pärast mooduli installimist soovitan vaadata näiteid kataloogides examples_python2 ja examples_python3.
Alustamine
Kuna meil on võimalus töötada cpapi mooduli komponentidega, tuleb importida moodulist cpapi vähemalt kaks vajalikku klassi:
APIClient ja APIClientArgs
from cpapi import APIClient, APIClientArgs
Klass APIClientArgs millel on seotud API serveriga ühenduse parameetrid, ning klass APIClient käsitleb API-ga suhtlemist.
Määra ühenduse parameetrid
Erinevate API-ga ühenduse parameetrite määramiseks tuleb luua klassi APIClientArgseksemplar. Üldiselt on selle parameetrid eelnevalt määratud ja skripti käivitamisel haldussüsteemis ei pea neid kindlasti määrama.
client_args = APIClientArgs()Kuid kolmandal serveril käivitamisel tuleb määrata vähemalt API serveri IP-aadress või hostinimi (see on ka haldussüsteem). Allolevas näites määrame ühenduse parameetri server ja määrame sellele stringina haldussüsteemi IP-aadressi.
client_args = APIClientArgs(server='192.168.47.241')Vaatame kõiki parameetreid ja nende vaikimisi väärtusi, mida saab API-serveriga ühendamiseks kasutada:
APIClientArgs klassi __init__ meetodi argumendid
class APIClientArgs:
"""
See klass pakub argumente APIClient konfigureerimiseks.
Kõik argumendid on seadistatud oma vaikeväärtustega.
"""
# port on vaikimisi seadistatud None, kuid asendatakse 443-ga, kui ei ole määratud
# konteksti võimalikud väärtused - web_api (vaikimisi) või 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
# haldusteenuse sõrmejälg
self.fingerprint = fingerprint
# sessiooni-ID.
self.sid = sid
# haldusteenuse nimi või IP-aadress
self.server = server
# silumise tase
self.http_debug_level = http_debug_level
# massiiv, kus on kõik API-kutsed (silumise eesmärkidel)
self.api_calls = api_calls if api_calls else []
# silumise faili nimi. Kui see jääb tühjaks, ei salvestata silumise andmeid kettale.
self.debug_file = debug_file
# HTTP-proksi serveri aadress (ilma "http://")
self.proxy_host = proxy_host
# HTTP-proksi port
self.proxy_port = proxy_port
# haldusteenuse API versioon
self.api_version = api_version
# Näitab, et klient ei tohiks kontrollida serveri sertifikaati
self.unsafe = unsafe
# Näitab, et klient peaks automaatselt aktsepteerima ja salvestama serveri sertifikaadi
self.unsafe_auto_accept = unsafe_auto_accept
# Kliendi kasutamise kontekst - vaikimisi web_api
self.context = contextArvan, et APIClientArgs klassi eksemplaride argumentide mõisted on Check Pointi administraatoritele loogiliselt arusaadavad ning neile ei ole lisakommentaare vajalik.
Ühendame APIClienti ja kontekstihalduriga
Klass APIClient on kõige mugavam kasutada kontekstihalduse kaudu. Kõik, mis tuleb APIClient klassi eksemplarile edastada, on ühenduse parameetrid, mis määrati eelnevas sammus.
with APIClient(client_args) as client:
Kontekstihaldur ei soorita automaatselt login kõnet API serverisse, kuid ta teeb logout kõne, kui sellest väljutakse. Kui mingil põhjusel pole API kõnede lõpetamise järgselt logout vajalik, tuleb alustada tööd ilma kontekstihaldurita:
client = APIClient(client_args)Ühenduse kontrollimine
Kontrollida, kas ühendus antud parameetritega on lihtsaim kasutada meetodi check_fingerprint. Kui API serveri sertifikaadi fingerprinti sha1 kontrollimised ei läinud läbi (meetod tagastas False), on see tavaliselt põhjustatud ühenduse probleemidest ning me saame programmi käivitamise peatada (või anda kasutajale võimaluse andmeid parandada):
kui client.check_fingerprint() on vale:
print("Ei saanud serveri sõrmejälge - Kontrollige ühendust serveriga.")
exit(1)
Pange tähele, et edaspidi klass APIClient kontrollib iga API-ülesande korral (meetodid api_call ja api_query, millest räägime hiljem) sha1 sõrmejälge API serveri sertifikaadi kohta. Kui sha1 sõrmejälje kontrollimisel tuvastatakse viga (sertifikaat on tundmatu või on muutunud), siis meetod check_fingerprint pakub võimalust lisada/muuta selle kohta teavet kohaliku masina automaatrežiimis. Selle kontrolli saab üldse välja lülitada (kuid seda soovitatakse ainult juhul, kui skripte käitatakse otse API serveris, ühendades 127.0.0.1), kasutades argumenti APIClientArgs — unsafe_auto_accept (vt APIClientArgs kohta lähemalt "Määratlege ühenduse parameetrid"-s).
client_args = APIClientArgs(unsafe_auto_accept=True)Logi sisse API serverisse
U APIClient on kokku 3 meetodit sisse logimiseks API serverisse, ja igaühe puhul salvestatakse väärtus sid(session-id), mida kasutatakse automaatselt igas järgmises API-ühenduses päises (selle parameetri nimi päises on X-chkp-sid), nii et seda parameetrit ei pea eraldi töötlema.
Meetod login
Variant, kasutades sisselogimist ja parooli (näiteks on kasutajanimi admin ja parool 1q2w3e edastatud positsiooniliste argumentidena):
login = client.login('admin', '1q2w3e') Metoodis login on saadaval ka täiendavad valikuvõimalused, siin on nende nimed ja vaikimisi väärtused:
continue_last_session=False, domain=None, read_only=False, payload=NoneMeetod login_with_api_key
Variant, kasutades API võtit (tugineb versioonist R80.40 / Management API v1.6, «3TsbPJ8ZKjaJGvFyoFqHFA==» see on API võti ühele kasutajale haldusserveris, kasutades autentimismeetodit API key):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Meetodis login_with_api_key on saadaval samad valikuvõimalused nagu meetodis login.
Meetod login_as_root
Variant sisselogimiseks lokaalsesse masinasse API serveriga:
login = client.login_as_root()Selle meetodi jaoks on saadaval vaid kaks valikuvõimalust:
domain=None, payload=NoneJa lõpuks, ise API kutsed
Meil on kaks varianti API kutsude tegemiseks läbi meetodite. api_call ja api_queryVaatame, milline nende vahel on erinevus.
api_call
Seda meetodit saab kasutada igasuguste kutsuste jaoks. Me peame edastama viimase osa API kutsest ja payload'i soovi korral. Kui payload on tühi, siis seda ei pea üldse edastama:
api_versions = client.api_call('show-api-versions') Käesoleva päringu väljund allpool:
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'})Käesoleva päringu väljund allpool:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "must",
"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": "must",
"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
Esmapäraselt ütlen, et see meetod kehtib ainult nende API-kutsede puhul, mille väljundis on offset (tõuke) olemas. Sellist väljundit kasutatakse, kui see sisaldab või võib sisaldada suurt hulka teavet. Näiteks võib see olla päring kõigi loodud hostide loendi saamiseks haldusserveris. Selliste päringute puhul tagastab API vaikimisi 50 objekti (selle arvu saab suurendada kuni 500 objekti). Et vältida teabe mitu korda pärimist erineva offset parameetriga API-kutses, on olemas meetod api_query, mis teeb selle töö automaatselt ära. Näited kutsetest, kus seda meetodit on vaja: 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. Tegelikult näeme nende API-kutsete nimedes sõnu mitmuses, nii et neid kutseid on lihtsam töödelda läbi api_query
show_hosts = client.api_query('show-hosts') Käesoleva päringu väljund allpool:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC kasutaja",
"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 kasutaja",
"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 kasutaja",
"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 kasutaja",
"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 kutsungite tulemuste töötlemine
Pärast seda saab kasutada klassi muutujaid ja meetodeid APIResponse(nii konteksti halduri sees kui ka väljaspool). Klassil APIResponse on määratud 4 meetodit ja 5 muutujat, millest kõige olulisematel peatume lähemalt.
success
Alustuseks oleks hea veenduda, et API kutse õnnestus ja tagastas tulemuse. Selleks on olemas meetod success:
In [49]: api_versions.success
Out[49]: True
Tagastab True, kui API kutse õnnestus (vastuskood — 200) ja False, kui mitte (ükskõik milline teine vastuskood). Mugav kasutada kohe pärast API kutsest, et vastavalt vastuskoodile erinevat teavet kuvada.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuscode
Tagastab vastuskoodi pärast API kutsumise täitmist.
In [62]: api_versions.status_code
Out[62]: 400
Võimalikud vastuskoodid: 200,400,401,403,404,409,500,501.
set_success_status
Samuti võib olla vajalik muuta staatuse väärtust success. Tehniliselt võib sinna panna mis tahes, isegi tavalise stringi. Kuid reaalseks näiteks võib olla selle parameetri seadmine False'iks teatud kõrvaltingimustes. Allpool on näide, kus on ülesanded, mis täidetakse haldusserveris, kuid me peame seda päringut ebaõnnestunuks (seadke muutuja success False, hoolimata sellest, et API-kutse oli edukas ja tagastas koodi 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakresponse()
Meetod response võimaldab vaadata sõnastikku koos vastuse koodiga (status_code) ja vastuse kehaga (body).
In [94]: api_versions.response()
Out[94]:
{'status_code': 200,
'data': {'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}
data
Võimaldab näha ainult vastuse keha (body) ilma liigsete detailideta.
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
See teave on saadaval ainult siis, kui API päringu töötlemise käigus tekkis tõrge (vastuse kood ei 200). Näide väljundist
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Kasulikud näited
Allpool on toodud näited, kus kasutatakse API päringuid, mis on lisatud juhtimise API versioonile 1.6.
Alustuseks vaatame päringute toimimist add-host ja add-address-range. Oletame, et me peame looma objektid, mille tüüp on host, kõikide IP aadresside jaoks alamsüsteemis 192.168.0.0/24, mille viimane oktet on 5, ja kõik ülejäänud IP aadressid salvestama objektidena, mille tüüp on aadressirida. Samuti tuleb välja jätta alamsüsteemi aadress ja laiendatud aadress.
Nii et allpool on esitatud skript, mis lahendab antud ülesande ja loob 50 host tüüpi objekti ja 51 aadressirea objekti. Probleemi lahendamiseks kulub 101 API päringut (ilma lõpp-päringut publish arvestamata). Samuti kasutame moodulit timeit, et arvutada skripti täitmise aega kuni muudatuste avaldamiseni.
Skript koos add-host ja add-address-range kasutamisega
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')
Minu laboratooriumis kulub selle skripti täitmiseks sõltuvalt haldusserveri koormusest 30 kuni 50 sekundit.
Nüüd vaatame, kuidas lahendada sama probleem API kutsumise abil add-objects-batch, mille tugi on lisatud API versioonis 1.6. See kutsumine võimaldab ühes API päringus luua mitmeid objekte. Need võivad olla erinevat tüüpi objektid (näiteks hostid, alamvõrgud ja aadressivahemikud). Seega saame meie ülesande lahendada ühe API kutsumise raames.
Skript, mis kasutab 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')
Kuid skripti täitmine minu laborikeskkonnas võtab aega 3 kuni 7 sekundit olenevalt haldusseervere koormusest. See tähendab, et keskmiselt saab 101 objekti puhul API kutsumine tüüpi batch 10 korda kiiremini. Suurema objekti arvu korral on erinevus veelgi muljetavaldavam.
Nüüd vaatame, kuidas töötada set-objects-batch. Selle API-kõne abil saame massiliselt muuta mis tahes parameetrit. Seadistame esimeses pooles aadresse eelmisest näitest (kuni .124 hostini, sealhulgas ka vahemike jaoks) värvi sienna ja teises pooles aadresse määrame värvi khaki.
Objektide värvi muutmine, mis loodi eelnevas näites
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")
Eemaldada mitmed objektid ühe API kutsumisega on võimalik kasutades delete-objects-batch. Ja nüüd vaatame koodi näidet, mis eemaldab kõik varem loodud hostid add-objects-batch.
Objektide eemaldamine delete-objects-batch abil
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)
Check Pointi tarkvara uutes versioonides on kõik funktsioonid koheselt seotud ka API kutsungitega. Näiteks R80.40 versioonis tutvustatakse selliseid funktsioone nagu „Revert to revision” ja „Smart Task”, ning nende jaoks on kohe valmis vastavad API kutsungid. Lisaks sellele, kogu funktsionaalsus, kui toimub üleminek Legacy konsoolidest Unified Policy režiimi, saab samuti API toe. Näiteks oodatud uuendus R80.40 versioonis oli HTTPS Inspection poliitika üleminek Legacy režiimist Unified Policy režiimi, ning see funktsionaalsus sai kohe API kutsungid. Siin on koodinäide, mis lisab HTTPS Inspection poliitika tippu reegli, mis välistab kolmest kategooriast (Tervis, Rahandus, Avalikud teenused) inspektsiooni, mille inspektsioon on mitmes riigis seadusandluses keelatud.
Lisa reegel HTTPS Inspection poliitikasse
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 skriptide käivitamine Check Pointi haldusserveris
Kogu sisu jääb samaks sisal on teavet, kuidas käivitada skripte Pythonis otse haldusserverist. See võib olla mugav, kui teil pole võimalik ühendada API serverisse mõnest teisest masinast. Olen salvestanud kuue minuti video, milles käsitlen mooduli cpapi ja Python-skriptide käivitamise eripärasid haldusserveris. Näiteks käivitan skripti, mis automatiseerib uue lüüsikoodi seadistamist selliste ülesannete jaoks nagu võrgu auditeerimine. Security CheckUp. Eripärad, millega silmitsi seisin: Python 2.7 versioonis polnud veel funktsiooni input, seega kasutatakse kasutaja sisestatud teabe töötlemiseks funktsiooni raw_input. Muudelt masinakäivitustelt koodit erakordselt ei erine, lihtsalt on mugavam kasutada funktsiooni login_as_root, et mitte oma enda kasutajanime, paroole ja haldusserveri IP-aadressi uuesti sisestada.
Skript Security CheckUp kiireks seadistamiseks.
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("Ei saanud serveri sõrmejälge kätte - kontrollige serveriga ühendust.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Sisselogimine ebaõnnestus:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Sisesta värava nimi:")
gw_ip = raw_input("Sisesta värava IP-aadress:")
if sys.stdin.isatty():
sic = getpass.getpass("Sisesta ühekordne parool värava jaoks (SIC): ")
else:
print("Tähelepanu! Teie parool ilmub ekraanile!")
sic = raw_input("Sisesta ühekordne parool värava jaoks (SIC): ")
version = raw_input("Sisesta värava versioon (nt 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("Turvaline ühendus väravaga ei ole loodud!")
exit(1)
elif add_gw.success:
print("Värav lisati edukalt.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Värava lisamine ebaõnnestus - {}".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("Poliitika muudeti edukalt")
else:
print("Poliitika muutmine ebaõnnestus - {}".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("Cleanup reegel muudeti edukalt")
else:
print("Cleanup reegli muutmine ebaõnnestus - {}".format(change_rule.error_message))
# avalda tulemus
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Muudatused avaldati edukalt.")
else:
print("Muudatuste avaldamine ebaõnnestus - {}".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("Juurdepääsu poliitika on installitud")
else:
print("Juurdepääsu poliitika installimine ebaõnnestus - {}".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("Sissetungi tõkestamise poliitika on installitud")
else:
print("Sissetungi tõkestamise poliitika installimine ebaõnnestus - {}".format(install_tp_policy.error_message))
# lisa paroolid ja salasõnad sõnastikku
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" : "Lisa paroolid ja salasõnad", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Parooli sõnastiku rida {} lisati edukalt".format(line_num))
else:
print("Sõnastiku lisamine ebaõnnestus - {}".format(add_password_dictionary.error_message))
main() Näidis fail sõnadega varvete jaoks additional_pass.conf
{
"passwords" : ["malware","malicious","infektoitunud","Infected"],
"phrases" : ["parool","Parool","Pass","pass","kood","võti","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Kokkuvõte
See artikkel käsitleb ainult põhivõimalusi tööks Python SDK ja mooduli cpapi(nagu te võisite arvata, need on põhimõtteliselt sünonüümid), ja uurides selle mooduli koodi avastate veelgi rohkem võimalusi selle kasutamiseks. Pole välistatud, et tekib soov täiendada seda oma klassidega, funktsioonidega, meetoditega ja muutujatega. Te võite alati jagada oma saavutusi ja vaadata teisi Check Pointi skripte jaotises kogukonnas , mis ühendab nii toodete arendajaid kui ka kasutajaid.
Head programmeerimist ja aitäh, et lugesite lõpuni!
Allikas: habr.com
