La plena potenco de interagado kun API-oj malkaŝiĝas kiam uzataj kune kun programkodo, kiam ekestas ŝancoj dinamike formi API-petojn kaj ilojn por analizi API-respondojn. Tamen, ĝi ankoraŭ restas malmulte rimarkata. Python Programara Evoluiga Ilaro (ĉi-poste nomata Python SDK) por API por Administrado de Kontrolpunktoj, sed vane. Ĝi multe faciligas la vivon por programistoj kaj aŭtomatigaj entuziasmuloj. Python akiris grandegan popularecon lastatempe kaj mi decidis plenigi la mankon kaj revizii la ĉefajn funkciojn Ĉi tiu artikolo servas kiel bonega komplemento al alia artikolo pri Habr. Ni konsideros kiel verki skriptojn uzante Python SDK kaj pli detale esploros la novan funkcion de Management API en versio 1.6 (subtenata ekde R80.40). Por kompreni la artikolon, vi bezonos bazan scion pri laborado kun API kaj Python.
Check Point aktive disvolvas APIojn kaj nuntempe la jenaj estas publikigitaj:
- — labori kun la administrada servilo per API (kaj la kapablo efektivigi skriptojn sur enirejoj sub la kontrolo de la administrada servilo)
- - laborante kun sekurecaj enirejoj
- — laborante kun sablokesto en la nubo Check Point
- — laborante kun Identity Awareness-klingo sur enirejoj
- — laborante kun la administrada portalo de SMB-enirejo ()
- — interagado kun IoT-regiloj
- - labori kun (SD-WAN sekureca solvo)
- - labori kun
La Python SDK nuntempe nur subtenas interagadon kun la Administra API kaj Gaia APINi traktos la plej gravajn klasojn, metodojn kaj variablojn en ĉi tiu modulo.
Instalante la modulon
Modulo cpapi Instaliĝas rapide kaj facile de kun helpo de pipDetalaj instalaĵaj instrukcioj haveblas en Ĉi tiu modulo estas adaptita por funkcii kun Python-versioj 2.7 kaj 3.7. En ĉi tiu artikolo, ekzemploj estos donitaj uzante Python 3.7. Tamen, Python SDK povas esti funkciigita rekte de la Check Point-administra servilo (Smart Management), sed nur Python 2.7 estas subtenata sur ili, do la kodo por versio 2.7 estos donita en la lasta sekcio. Tuj post instalado de la modulo, mi rekomendas rigardi la ekzemplojn en la dosierujoj. ekzemploj_python2 и ekzemploj_python3.
Kiel ekuzi
Por ke ni povu labori kun la komponantoj de la cpapi-modulo, ni bezonas importi ĝin el la modulo cpapi almenaŭ du devigaj klasoj:
API-Kliento и APIClientArgs
from cpapi import APIClient, APIClientArgs
Класс APIClientArgs respondecas pri la parametroj de konekto al la API-servilo, kaj la klaso API-Kliento Respondeca pri interagado kun la API.
Ni difinas konektajn parametrojn
Por difini diversajn konektajn parametrojn al la API, vi devas krei instancon de la klaso APIClientArgsPrincipe, ĝiaj parametroj estas antaŭdifinitaj kaj kiam la skripto estas funkciigata sur la administrada servilo, ili ne bezonas esti specifitaj.
client_args = APIClientArgs()Sed kiam vi funkcias sur triaparta gastiganto, vi devas specifi almenaŭ la IP-adreson aŭ gastigantonomon de la API-servilo (t.e., la administra servilo). En la suba ekzemplo, ni difinas la parametron "servilconnect" kaj asignas al ĝi la IP-adreson de la administra servilo kiel ĉenon.
client_args = APIClientArgs(server='192.168.47.241')Ni rigardu ĉiujn parametrojn kaj iliajn defaŭltajn valorojn, kiujn oni povas uzi dum konektado al la API-servilo:
Argumentoj de la metodo __init__ de la klaso 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 = contextMi kredas, ke la argumentoj uzeblaj en instancoj de la klaso APIClientArgs estas intuicie kompreneblaj por administrantoj de Check Point kaj ne postulas pliajn komentojn.
Konektante per APIClient kaj kunteksta administrilo
Класс API-Kliento Plej oportune estas uzi ĝin per la kunteksta administrilo. Ĉio, kion oni devas transdoni al la klaso APIClient, estas la konektaj parametroj difinitaj en la antaŭa paŝo.
with APIClient(client_args) as client:
La kunteksta administrilo ne aŭtomate faros ensalutan vokon al la API-servilo, sed ĝi faros elsalutan vokon elirante el ĝi. Se pro iu kialo elsaluto ne estas necesa post fino de laborado kun API-vokoj, vi devas komenci labori sen uzi la kuntekstan administrilon:
client = APIClient(clieng_args)Kontrolante la konekton
La plej facila maniero kontroli ĉu la konekto funkcias laŭ la specifitaj parametroj estas uzi la metodon kontroli_fingrospuronSe la haŝkontrolo de SHA1 por la fingrospuro de la atestilo de la API-servilo malsukcesis (la metodo redonis falsa), tiam ĉi tion kutime kaŭzas konektaj problemoj kaj ni povas haltigi la program-plenumon (aŭ doni al la uzanto la ŝancon korekti la konektajn datumojn):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Bonvolu noti, ke estonte la klaso API-Kliento kontrolos ĉiun API-vokon (metodojn api_voko и api_query, ni parolos pri ili iom plu) sha1 fingrospuro de la atestilo sur la API-servilo. Sed se eraro estas detektita dum kontrolado de la sha1 fingrospuro de la API-servila atestilo (la atestilo estas nekonata aŭ estis ŝanĝita), la metodo kontroli_fingrospuron provizos la eblecon aŭtomate aldoni/ŝanĝi informojn pri ĝi sur la loka maŝino. Ĉi tiu kontrolo povas esti tute malŝaltita (sed tio povas esti rekomendinda nur en kazo de funkciigo de skriptoj sur la API-servilo mem, dum konektado al 127.0.0.1), uzante la argumenton APIClientArgs - nesekura_aŭtomata_akcepto (vidu pli pri APIClientArgs pli frue en "Difinado de konektoparametroj").
client_args = APIClientArgs(unsafe_auto_accept=True)Ensaluti al API-servilo
У API-Kliento ekzistas tiom multe kiom 3 metodoj por ensaluti en la API-servilon, kaj ĉiu el ili memoras la valoron sid(sesia-identigilo), kiu estas uzata aŭtomate en ĉiu posta API-voko en la kaplinio (la nomo en la kaplinio por ĉi tiu parametro estas X-chkp-sid), do ne necesas plue prilabori ĉi tiun parametron.
Ensaluta metodo
Opcio uzanta salutnomon kaj pasvorton (en la ekzemplo, salutnomo admin kaj pasvorto 1q2w3e estas pasitaj kiel poziciaj argumentoj):
login = client.login('admin', '1q2w3e') La ensaluta metodo ankaŭ havas pliajn laŭvolajn parametrojn disponeblajn, jen iliaj nomoj kaj defaŭltaj valoroj:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetodo ensaluti_kun_api_ŝlosilo
Opcio uzanta API-ŝlosilon (subtenata ekde la administrada versio R80.40/Administrada API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" jen la API-ŝlosilvaloro por unu el la uzantoj sur la administrada servilo kun la API-ŝlosilrajtiga metodo):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') En metodo ensaluti_per_api_ŝlosilo la samaj laŭvolaj parametroj estas haveblaj kiel en la metodo Ensaluti.
metodo login_as_root
Eblo por ensaluti al loka maŝino per API-servilo:
login = client.login_as_root()Nur du laŭvolaj parametroj estas haveblaj por ĉi tiu metodo:
domain=None, payload=NoneKaj fine la API vokas sin mem
Ni havas du eblojn por fari API-alvokojn per metodoj api_voko и api_queryNi eltrovu, kia estas la diferenco inter ili.
api_voko
Ĉi tiu metodo aplikeblas por ĉiuj alvokoj. Ni bezonas pasi la lastan parton por la api-alvoko kaj la utila ŝarĝo en la korpon de la peto se necese. Se la utila ŝarĝo estas malplena, tiam ĝi povas esti tute preterlasita:
api_versions = client.api_call('show-api-versions') La eligo por ĉi tiu peto estas sub la tranĉo:
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'})La eligo por ĉi tiu peto estas sub la tranĉo:
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
Permesu al mi tuj fari rezervon, ke ĉi tiu metodo aplikeblas nur por alvokoj, kies eligo supozas ofseton. Tia eligo okazas kiam ĝi enhavas aŭ povas enhavi grandan kvanton da informoj. Ekzemple, tio povus esti peto por listo de ĉiuj kreitaj gastigant-tipaj objektoj sur la administra servilo. Por tiaj petoj, la API defaŭlte redonas liston de 50 objektoj (vi povas pliigi la limon al 500 objektoj en la respondo). Kaj por ne plurfoje tiri informojn, ŝanĝante la parametron ofseto en la API-peto, ekzistas metodo api_query, kiu faras tion aŭtomate. Ekzemploj de alvokoj kie ĉi tiu metodo estas bezonata: spektaklo-sesioj, spektaklo-gastigantoj, spektaklo-retoj, spektaklo-ĵokeroj, spektaklo-grupoj, spektaklo-adresintervaloj, spektaklo-simplaj-enirejoj, spektaklo-simplaj-aretoj, spektaklo-alirroloj, spektaklo-fidindaj-klientoj, spektaklo-pakaĵojFakte, en la nomo de ĉi tiuj API-vokoj ni vidas vortojn en pluralo, do ĉi tiuj vokoj estos pli facile pritrakteblaj per api_query
show_hosts = client.api_query('show-hosts') La eligo por ĉi tiu peto estas sub la tranĉo:
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
})
Prilaborado de API-alvokrezultoj
Post tio, vi povas uzi la variablojn kaj metodojn de la klaso. API-Respondo(kaj ene kaj ekstere de la kunteksta administrilo). La klaso API-Respondo Ekzistas 4 antaŭdifinitaj metodoj kaj 5 variabloj, ni pli detale esploros la plej gravajn.
sukceso
Unue, estus bone certigi, ke la API-voko sukcesis kaj redonis rezulton. Ekzistas metodo por tio. sukceso:
In [49]: api_versions.success
Out[49]: True
Redonas Veron se la API-voko sukcesis (Respondkodo - 200) kaj Falson se ne sukcesis (iu ajn alia respondkodo). Praktika uzo tuj post la API-voko por montri malsamajn informojn depende de la respondkodo.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuskodo
Redonas la respondkodon post plenumo de API-voko.
In [62]: api_versions.status_code
Out[62]: 400
Eblaj respondkodoj: 200,400,401,403,404,409,500,501.
agordi_sukcesan_staton
En ĉi tiu kazo, eble necesos ŝanĝi la valoron de la sukcesa stato. Teknike, vi povas meti ion ajn tien, eĉ ordinaran ĉenon. Sed reala ekzemplo estus restarigi ĉi tiun parametron al Falsa sub certaj akompanaj kondiĉoj. Sube, atentu la ekzemplon kiam estas taskoj funkciantaj sur la administra servilo, sed ni konsideros ĉi tiun peton malsukcesa (ni agordos la sukcesan variablon al falsa, malgraŭ la fakto ke la API-voko sukcesis kaj redonis kodon 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakrespondo()
La metodo "respondeco" permesas al vi rigardi vortaron kun la respondkodo (status_code) kaj la respondkorpo (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']}}
datumoj
Permesas al vi vidi nur la respondkorpon sen nenecesaj informoj.
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']}
erarmesaĝo
Ĉi tiu informo estas havebla nur kiam eraro okazis dum la prilaborado de la API-peto (respondokodo ne 200). Ekzemplo de eligo
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Utilaj ekzemploj
La jenaj ekzemploj uzas API-vokojn, kiuj estis aldonitaj en Administrada API-versio 1.6.
Ni komencu per rigardo al kiel funkcias alvokoj. aldoni-gastiganton и aldoni-adres-intervalonNi supozu, ke ni bezonas krei ĉiujn IP-adresojn de la subreto 192.168.0.0/24, kies lasta okteto estas 5, kiel objektojn de la tipo gastiganto, kaj skribi ĉiujn aliajn IP-adresojn kiel objektojn de la tipo adresintervalo. En ĉi tiu kazo, ekskludu la subretan adreson kaj la elsendan adreson.
Do, sube estas skripto kiu solvas ĉi tiun problemon kaj kreas 50 objektojn de tipo gastiganto kaj 51 objektojn de tipo adresintervalo. Solvi la problemon postulas 101 API-vokojn (ne kalkulante la finan publikigan vokon). Ankaŭ, uzante la modulon timeit, ni kalkulas la tempon necesan por efektivigi la skripton ĝis la ŝanĝoj estas publikigitaj.
Skripto uzanta add-host kaj 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')
En mia laboratoria medio, ĉi tiu skripto bezonas inter 30 kaj 50 sekundojn por efektiviĝi, depende de la ŝarĝo sur la administrada servilo.
Nun ni vidu kiel solvi la saman problemon per API-voko aldoni-objektojn-aro, subteno por kiu estis aldonita en API-versio 1.6. Ĉi tiu voko permesas al vi krei plurajn objektojn samtempe en unu API-peto. Krome, ĉi tiuj povas esti objektoj de malsamaj tipoj (ekzemple, gastigantoj, subretoj kaj adresintervaloj). Tiel, nia tasko povas esti solvita en la kadro de unu API-voko.
Skripto uzante 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')
Kaj la efektivigo de ĉi tiu skripto en mia laboratoria medio daŭras de 3 ĝis 7 sekundojn depende de la ŝarĝo sur la administrada servilo. Tio estas, averaĝe, sur 101 objektoj, la API-voko de la tipo "batch" funkcias 10 fojojn pli rapide. Sur pli granda nombro da objektoj, la diferenco estos eĉ pli impresa.
Nun ni vidu kiel labori kun aro-objektoj-aroPer ĉi tiu API-voko ni povas ŝanĝi ajnan parametron amase. Ni agordu la unuan duonon de la adresoj el la antaŭa ekzemplo (ĝis .124 gastigantoj, kaj ankaŭ intervaloj) al la koloro sienna, kaj asignu la duan duonon de la adresoj al la koloro khaki.
Ŝanĝante la koloron de objektoj kreitaj en la antaŭa ekzemplo
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")
Vi povas forigi plurajn objektojn en unu API-voko uzante forigi-objektojn-aroNun ni rigardu ekzemplon de kodo kiu forigas ĉiujn gastigantojn antaŭe kreitajn per aldoni-objektojn-aro.
Forigi objektojn per 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)
Ĉiuj funkcioj, kiuj aperas en novaj eldonoj de la programaro Check Point, tuj ricevas API-vokojn. Tiel, en R80.40 aperis tiaj "funkcioj" kiel "Revertu al revizio" kaj "Smart Task", kaj respondaj API-vokoj estis tuj pretigitaj por ili. Krome, ĉiuj funkcioj dum ŝanĝo de Heredaĵaj konzoloj al Unuigita Politikreĝimo ankaŭ ricevas API-subtenon. Ekzemple, longe atendita ĝisdatigo en la programara versio R80.40 estis la movo de la HTTPS-Inspektada politiko de Heredaĵa reĝimo al Unuigita Politikreĝimo, kaj ĉi tiu funkcio tuj ricevis API-vokojn. Jen ekzemplo de kodo, kiu aldonas regulon al la supra pozicio de la HTTPS-Inspektada politiko, kiu ekskludas 3 kategoriojn de inspektado (Sano, Financo, Registaraj Servoj), kiuj estas malpermesitaj de inspektado laŭ la leĝaro en kelkaj landoj.
Aldoni regulon al la HTTPS-inspektada politiko
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")
Funkciigi Python-skriptojn sur Check Point Management Server
Ĉio estas sama enhavas informojn pri kiel ruli Python-skriptojn rekte de la stirservilo. Ĉi tio povas esti utila kiam vi ne povas konektiĝi al la API-servilo de alia maŝino. Mi registris ses-minutan filmeton en kiu mi rigardas la instaladon de la modulo. cpapi kaj funkcioj de funkciigo de Python-skriptoj sur la administrada servilo. Ekzemple, oni funkciigas skripton, kiu aŭtomatigas la agordon de nova enirejo por tasko kiel ekzemple ret-auditado. Sekureca KontroloUnu el la trajtoj, kiujn mi devis trakti: en Python 2.7, la funkcio ankoraŭ ne aperis enigo, do la funkcio estas uzata por prilabori la informojn enigitajn de la uzanto kruda_enigoAlie, la kodo estas la sama kiel por lanĉo de aliaj maŝinoj, nur pli oportune estas uzi la funkcion ensaluti_kiel_radiko, por ne plu specifi vian propran uzantnomon, pasvorton kaj IP-adreson de la stirservilo.
Skripto por rapida agordo de Sekureca Kontrolo
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() Ekzemplo de dosiero kun pasvorta vortaro additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
konkludo
Ĉi tiu artikolo nur kovras la bazajn eblecojn de laboro Python SDK kaj modulo cpapi(kiel vi eble divenis, ĉi tiuj estas fakte sinonimoj), kaj studinte la kodon en ĉi tiu modulo, vi malkovros eĉ pli da eblecoj laborante kun ĝi. Eblas, ke vi deziros kompletigi ĝin per viaj propraj klasoj, funkcioj, metodoj kaj variabloj. Vi ĉiam povas dividi viajn evoluigojn kaj vidi aliajn skriptojn por Check Point en la sekcio en la komunumo , kiu kunigas kaj produktajn programistojn kaj uzantojn.
Feliĉan kodadon kaj dankon pro legado ĝis la fino!
fonto: www.habr.com
