Die volle krag van interaksie met API's word aan die lig gebring wanneer dit saam met programkode gebruik word, wanneer dit moontlik word om API-versoeke en gereedskap vir die ontleding van API-reaksies dinamies te genereer. Dit bly egter steeds onopvallend Python sagteware-ontwikkelingskit (hierna verwys as Python SDK) vir Check Point Management API, maar tevergeefs. Dit vergemaklik die lewe van ontwikkelaars en outomatisering-entoesiaste aansienlik. Python het die afgelope tyd enorme gewildheid verwerf en ek het besluit om die gaping te vul en die hoofkenmerke te hersien. . Hierdie artikel dien as 'n uitstekende toevoeging tot 'n ander artikel oor Habré . Ons sal kyk hoe om skrifte met die Python SDK te skryf en die nuwe Management API-funksionaliteit in weergawe 1.6 van nader te bekyk (ondersteun vanaf R80.40). Om die artikel te verstaan, sal jy basiese kennis nodig hê om met API's en Python te werk.
Check Point is aktief besig om die API te ontwikkel en op die oomblik is die volgende vrygestel:
- - werk met die beheerbediener via API (en die vermoë om skrifte uit te voer op poorte wat deur die beheerbediener beheer word)
- — werk met sekuriteitspoorte
- — werk met 'n sandbox in die Check Point-wolk
- — werk met Identity Awareness blade op poorte
- — werk met die SMB-poortbestuursportaal ()
- - interaksie met IoT-beheerders
- - werk met (SD-WAN sekuriteit oplossing)
- - werk met
Die Python SDK ondersteun tans net interaksie met die Management API en Gaia API. Ons gaan kyk na die belangrikste klasse, metodes en veranderlikes in hierdie module.
Die installering van die module
Module cpapi installeer vinnig en maklik vanaf met die hulp pit. Gedetailleerde installasie-instruksies is beskikbaar in . Hierdie module is aangepas om met Python-weergawes 2.7 en 3.7 te werk. In hierdie artikel sal voorbeelde gegee word met Python 3.7. Die Python SDK kan egter direk vanaf die Check Point Management Server (Smart Management) uitgevoer word, maar hulle ondersteun slegs Python 2.7, so die laaste afdeling sal kode vir weergawe 2.7 verskaf. Onmiddellik na die installering van die module, beveel ek aan om na die voorbeelde in die gidse te kyk voorbeelde_python2 и voorbeelde_python3.
Aan die slag
Om met die komponente van die cpapi-module te kan werk, moet ons vanaf die module invoer cpapi ten minste twee vereiste klasse:
API-kliënt и APIClientArgs
from cpapi import APIClient, APIClientArgs
Klas APIClientArgs is verantwoordelik vir verbindingsparameters na die API-bediener en die klas API-kliënt is verantwoordelik vir interaksie met die API.
Bepaling van verbindingsparameters
Om verskeie parameters te definieer om aan die API te koppel, moet jy 'n instansie van die klas skep APIClientArgs. In beginsel is sy parameters vooraf gedefinieer en wanneer die skrip op die beheerbediener uitgevoer word, hoef dit nie gespesifiseer te word nie.
client_args = APIClientArgs()Maar wanneer jy op 'n derdeparty-gasheer loop, moet jy ten minste die IP-adres of gasheernaam van die API-bediener (ook bekend as die bestuursbediener) spesifiseer. In die voorbeeld hieronder definieer ons die bedienerverbindingsparameter en ken dit die IP-adres van die bestuursbediener as 'n string toe.
client_args = APIClientArgs(server='192.168.47.241')Kom ons kyk na al die parameters en hul verstekwaardes wat gebruik kan word wanneer u aan die API-bediener koppel:
Argumente van die __init__ metode van die APIClientArgs klas
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 = contextEk glo dat die argumente wat in gevalle van die APIClientArgs-klas gebruik kan word, intuïtief is vir Check Point-administrateurs en nie bykomende kommentaar benodig nie.
Koppel via APIClient en konteksbestuurder
Klas API-kliënt Die gerieflikste manier om dit te gebruik, is deur die konteksbestuurder. Al wat na 'n instansie van die APIClient-klas oorgedra moet word, is die verbindingsparameters wat in die vorige stap gedefinieer is.
with APIClient(client_args) as client:
Die konteksbestuurder sal nie outomaties 'n aanmeldoproep na die API-bediener maak nie, maar dit sal 'n uittekenoproep maak wanneer dit verlaat word. As om een of ander rede nie afmeld nodig is nadat jy klaar met API-oproepe gewerk het nie, moet jy begin werk sonder om die konteksbestuurder te gebruik:
client = APIClient(clieng_args)Kontroleer die verbinding
Die maklikste manier om te kyk of die verbinding aan die gespesifiseerde parameters voldoen, is om die metode te gebruik check_vingerafdruk. As die verifikasie van die sha1-hash-som vir die vingerafdruk van die bediener-API-sertifikaat misluk (die metode het teruggekeer Vals), dan word dit gewoonlik veroorsaak deur verbindingsprobleme en ons kan die uitvoering van die program stop (of die gebruiker die geleentheid gee om die verbindingsdata reg te stel):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Neem asseblief kennis dat die klas in die toekoms API-kliënt sal elke API-oproep (metodes api_oproep и api_navraag, ons sal 'n bietjie verder daaroor praat) sha1 vingerafdruksertifikaat op die API-bediener. Maar as, wanneer die sha1-vingerafdruk van die API-bedienersertifikaat nagegaan word, 'n fout bespeur word (die sertifikaat is onbekend of is verander), die metode check_vingerafdruk sal die geleentheid bied om inligting daaroor op die plaaslike masjien outomaties by te voeg/te verander. Hierdie kontrole kan heeltemal gedeaktiveer word (maar dit kan slegs aanbeveel word as skrifte op die API-bediener self uitgevoer word, wanneer dit aan 127.0.0.1 gekoppel word), met behulp van die APIClientArgs-argument - onveilig_outo_aanvaar (sien meer oor APIClientArgs vroeër in "Definieer verbindingsparameters").
client_args = APIClientArgs(unsafe_auto_accept=True)Meld aan by API-bediener
У API-kliënt daar is soveel as 3 metodes om by die API-bediener aan te meld, en elkeen van hulle verstaan die betekenis sid(sessie-ID), wat outomaties gebruik word in elke daaropvolgende API-oproep in die kopskrif (die naam in die kop van hierdie parameter is X-chkp-kant), so dit is nie nodig om hierdie parameter verder te verwerk nie.
aanmeldmetode
Opsie deur login en wagwoord te gebruik (in die voorbeeld word die gebruikersnaam admin en wagwoord 1q2w3e as posisionele argumente deurgegee):
login = client.login('admin', '1q2w3e') Bykomende opsionele parameters is ook beskikbaar in die aanmeldmetode; hier is hul name en verstekwaardes:
continue_last_session=False, domain=None, read_only=False, payload=NoneLogin_with_api_key metode
Opsie met behulp van 'n API-sleutel (ondersteun vanaf bestuurweergawe R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" dit is die API-sleutelwaarde vir een van die gebruikers op die bestuursbediener met die API-sleutelmagtigingsmetode):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') In metode login_with_api_key dieselfde opsionele parameters is beskikbaar as in die metode teken asseblief aan.
login_as_root metode
Opsie om aan te meld by 'n plaaslike masjien met 'n API-bediener:
login = client.login_as_root()Daar is slegs twee opsionele parameters beskikbaar vir hierdie metode:
domain=None, payload=NoneEn uiteindelik noem die API hulself
Ons het twee opsies om API-oproepe deur metodes te maak api_oproep и api_navraag. Kom ons vind uit wat die verskil tussen hulle is.
api_oproep
Hierdie metode is van toepassing op enige oproepe. Ons moet die laaste deel vir die api-oproep en loonvrag in die versoekliggaam slaag indien nodig. As loonvrag leeg is, kan dit glad nie versend word nie:
api_versions = client.api_call('show-api-versions') Uitset vir hierdie versoek onder die snit:
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'})Uitset vir hierdie versoek onder die snit:
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_navraag
Laat ek dadelik 'n bespreking maak dat hierdie metode slegs van toepassing is op oproepe waarvan die uitset offset behels. So 'n afleiding vind plaas wanneer dit 'n groot hoeveelheid inligting bevat of kan bevat. Dit kan byvoorbeeld 'n versoek wees vir 'n lys van alle geskepte gasheervoorwerpe op die bestuurbediener. Vir sulke versoeke gee die API by verstek 'n lys van 50 voorwerpe terug (jy kan die limiet tot 500 voorwerpe in die antwoord verhoog). En om nie die inligting verskeie kere te trek nie, deur die offset-parameter in die API-versoek te verander, is daar 'n api_query-metode wat dit outomaties doen. Voorbeelde van oproepe waar hierdie metode benodig word: show-sessies, show-gashere, show-netwerke, show-wildcards, show-groepe, show-adresreekse, show-eenvoudige-poorte, show-eenvoudige-klusters, wys-toegang-rolle, wys-vertroude-kliënte, vertoon-pakkette. Trouens, ons sien meervoudswoorde in die naam van hierdie API-oproepe, so hierdie oproepe sal makliker wees om deur te hanteer api_navraag
show_hosts = client.api_query('show-hosts') Uitset vir hierdie versoek onder die snit:
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
})
Verwerking van die resultate van API-oproepe
Hierna kan jy die veranderlikes en metodes van die klas gebruik API-reaksie(beide binne die konteksbestuurder en buite). By die klas API-reaksie 4 metodes en 5 veranderlikes is vooraf gedefinieer; ons sal in meer besonderhede stilstaan by die belangrikstes.
sukses
Om mee te begin, sal dit 'n goeie idee wees om seker te maak dat die API-oproep suksesvol was en 'n resultaat opgelewer het. Daar is 'n metode hiervoor sukses:
In [49]: api_versions.success
Out[49]: True
Wys Waar as die API-oproep suksesvol was (antwoordkode - 200) en Vals indien nie suksesvol nie (enige ander antwoordkode). Dit is gerieflik om onmiddellik na 'n API-oproep te gebruik om verskillende inligting te vertoon, afhangende van die antwoordkode.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuskode
Wys die reaksiekode nadat 'n API-oproep gemaak is.
In [62]: api_versions.status_code
Out[62]: 400
Moontlike reaksiekodes: 200,400,401,403,404,409,500,501.
stel_suksesstatus
In hierdie geval kan dit nodig wees om die waarde van die suksesstatus te verander. Tegnies kan jy enigiets daar plaas, selfs 'n gewone tou. Maar 'n werklike voorbeeld sou wees om hierdie parameter terug te stel na Onwaar onder sekere gepaardgaande toestande. Gee hieronder aandag aan die voorbeeld wanneer daar take op die bestuurbediener loop, maar ons sal hierdie versoek as onsuksesvol beskou (ons sal die suksesveranderlike stel op Vals, ten spyte van die feit dat die API-oproep suksesvol was en kode 200 teruggestuur het).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakreaksie()
Die reaksiemetode laat jou toe om die woordeboek met die antwoordkode (status_kode) en die antwoordliggaam (liggaam) te bekyk.
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
Laat jou toe om slegs die liggaam van die reaksie (liggaam) te sien sonder onnodige inligting.
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']}
foutboodskap
Hierdie inligting is slegs beskikbaar wanneer 'n fout voorgekom het tydens die verwerking van die API-versoek (antwoordkode geen 200). Voorbeeld uitset
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Nuttige voorbeelde
Die volgende is voorbeelde wat die API-oproepe gebruik wat in Management API 1.6 bygevoeg is.
Kom ons kyk eers na hoe oproepe werk add-gasheer и byvoeg-adres-reeks. Kom ons sê ons moet alle IP-adresse van die subnet 192.168.0.0/24, waarvan die laaste oktet 5 is, as voorwerpe van die gasheertipe skep, en alle ander IP-adresse as voorwerpe van die adresreekstipe skryf. In hierdie geval, sluit die subnetadres en uitsaaiadres uit.
So, hieronder is 'n skrif wat hierdie probleem oplos en skep 50 voorwerpe van die gasheertipe en 51 voorwerpe van die adresreekstipe. Om die probleem op te los, word 101 API-oproepe vereis (nie die finale publiseeroproep ingereken nie). Ook, deur die timeit-module te gebruik, bereken ons die tyd wat dit neem om die skrif uit te voer totdat die veranderinge gepubliseer word.
Skrip met add-host en add-adresreeks
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')
In my laboratoriumomgewing neem hierdie skrip tussen 30 en 50 sekondes om uit te voer, afhangende van die las op die bestuurbediener.
Kom ons kyk nou hoe om dieselfde probleem op te los met 'n API-oproep voeg-voorwerpe-batch by, ondersteuning waarvoor bygevoeg is in API weergawe 1.6. Hierdie oproep laat jou toe om baie voorwerpe gelyktydig in een API-versoek te skep. Boonop kan dit voorwerpe van verskillende tipes wees (byvoorbeeld gashere, subnette en adresreekse). Ons taak kan dus binne die raamwerk van een API-oproep opgelos word.
Skrip met 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')
En om hierdie skrip in my laboratoriumomgewing te laat loop, neem van 3 tot 7 sekondes, afhangend van die las op die bestuursbediener. Dit wil sê, gemiddeld op 101 API-voorwerpe loop 'n bondeltipe oproep 10 keer vinniger. Op 'n groter aantal voorwerpe sal die verskil selfs meer indrukwekkend wees.
Kom ons kyk nou hoe om mee te werk stel-voorwerpe-batch. Deur hierdie API-oproep te gebruik, kan ons enige parameter grootmaat verander. Kom ons stel die eerste helfte van die adresse van die vorige voorbeeld (tot .124 gashere, en reekse ook) op die kleur sienna, en ken die kleur kakie toe aan die tweede helfte van die adresse.
Verander die kleur van die voorwerpe wat in die vorige voorbeeld geskep is
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")
Jy kan veelvuldige voorwerpe in een API-oproep uitvee met behulp van delete-objects-batch. Kom ons kyk nou na 'n kodevoorbeeld wat alle gashere wat voorheen geskep is, uitvee voeg-voorwerpe-batch by.
Vee voorwerpe uit met 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)
Alle funksies wat in nuwe vrystellings van Check Point-sagteware verskyn, verkry onmiddellik API-oproepe. So, in R80.40 het sulke "kenmerke" soos Terug na hersiening en Slimtaak verskyn, en ooreenstemmende API-oproepe is dadelik daarvoor voorberei. Boonop kry alle funksionaliteit by die oorskakeling van Oud-konsoles na Unified Policy-modus ook API-ondersteuning. Byvoorbeeld, die langverwagte opdatering in sagtewareweergawe R80.40 was die skuif van die HTTPS-inspeksiebeleid van Legacy-modus na Unified Policy-modus, en hierdie funksionaliteit het onmiddellik API-oproepe ontvang. Hier is 'n voorbeeld van kode wat 'n reël by die topposisie van die HTTPS-inspeksiebeleid voeg wat 3 kategorieë van inspeksie uitsluit (Gesondheid, Finansies, Staatsdienste), wat ooreenkomstig die wet in 'n aantal lande verbied word om te inspeksie.
Voeg 'n reël by die HTTPS-inspeksiebeleid
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")
Begin Python-skrifte op die Check Point-bestuurbediener
Alles is dieselfde bevat inligting oor hoe om Python-skrifte direk vanaf die beheerbediener uit te voer. Dit kan gerieflik wees wanneer u nie vanaf 'n ander masjien aan die API-bediener kan koppel nie. Ek het 'n video van ses minute opgeneem waarin ek kyk na die installering van die module cpapi en kenmerke om Python-skrifte op die beheerbediener te laat loop. As 'n voorbeeld word 'n skrip uitgevoer wat die konfigurasie van 'n nuwe poort vir 'n taak soos netwerkouditering outomatiseer Sekuriteitskontrole. Onder die kenmerke waarmee ek te doen gehad het: die funksie het nog nie in Python 2.7 verskyn nie insette, dus om die inligting wat die gebruiker invoer te verwerk, word 'n funksie gebruik rou_invoer. Andersins is die kode dieselfde as om vanaf ander masjiene te begin, net dit is geriefliker om die funksie te gebruik login_as_root, om nie weer jou eie gebruikersnaam, wagwoord en IP-adres van die bestuursbediener te spesifiseer nie.
Skrip vir vinnige opstel van Security CheckUp
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() 'n Voorbeeldlêer met 'n wagwoordwoordeboek additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Gevolgtrekking
Hierdie artikel ondersoek slegs die basiese moontlikhede van werk Python SDK en module cpapi(soos jy dalk geraai het, is dit eintlik sinonieme), en deur die kode in hierdie module te bestudeer sal jy nog meer geleenthede ontdek om daarmee te werk. Dit is moontlik dat jy dit sal wil aanvul met jou eie klasse, funksies, metodes en veranderlikes. Jy kan altyd jou werk deel en ander skrifte vir Check Point in die afdeling bekyk in die gemeenskap , wat beide produkontwikkelaars en gebruikers bymekaarbring.
Gelukkige kodering en dankie dat jy tot die einde gelees het!
Bron: will.com