De folsleine krêft fan ynteraksje mei API's wurdt iepenbiere as it wurdt brûkt tegearre mei programmakoade, as it mooglik wurdt om dynamysk API-oanfragen en ark te generearjen foar it analysearjen fan API-antwurden. It bliuwt lykwols noch net te merken Python Software Development Kit (hjirnei oantsjutten as Python SDK) foar Kontrolearje Point Management API, mar om 'e nocht. It ferienfâldiget it libben fan ûntwikkelders en automatisearring signifikant. Python hat de lêste tiid enoarme populariteit opdien en ik besleat it gat te foljen en de haadfunksjes te besjen. . Dit artikel tsjinnet as in poerbêste oanfolling op in oar artikel oer Habré . Wy sille sjen nei hoe te skriuwen skripts mei help fan de Python SDK en nim in tichterby op de nije Management API funksjonaliteit yn ferzje 1.6 (stipe fanút R80.40). Om it artikel te begripen, sille jo basiskennis nedich hawwe fan wurkjen mei API's en Python.
Check Point is aktyf ûntwikkeljen fan de API en op it stuit binne de folgjende frijlitten:
- - wurkje mei de kontrôletsjinner fia API (en de mooglikheid om skripts út te fieren op poarten regele troch de kontrôletsjinner)
- - wurkje mei feiligens poarten
- - wurkje mei in sânbak yn 'e Check Point-wolk
- - wurkje mei Identity Awareness blade op poarten
- - wurkje mei it SMB gateway management portal ()
- - ynteraksje mei IoT-controllers
- - wurkje mei (SD-WAN feiligens oplossing)
- - wurkje mei
De Python SDK stipet op it stuit allinich ynteraksje mei de Management API en Gaia API. Wy sille sjen nei de wichtichste klassen, metoaden en fariabelen yn dizze module.
Module ynstallaasje
Module cpapi ynstallearret fluch en maklik út troch pip. Detaillearre ynstallaasje ynstruksjes binne beskikber yn . Dizze module is oanpast om te wurkjen mei Python-ferzjes 2.7 en 3.7. Yn dit artikel sille foarbylden wurde jûn mei Python 3.7. De Python SDK kin lykwols direkt wurde útfierd fan 'e Check Point Management Server (Smart Management), mar se stypje allinich Python 2.7, dus de lêste seksje sil koade foar ferzje 2.7 leverje. Fuort nei it ynstallearjen fan de module ried ik oan om te sjen nei de foarbylden yn 'e mappen foarbylden_python2 и foarbylden_python3.
Om te begjinnen
Om ús te kinnen wurkje mei de komponinten fan 'e cpapi-module, moatte wy ymportearje fan 'e module cpapi op syn minst twa ferplichte klassen:
APIClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Klasse APIClientArgs is ferantwurdlik foar ferbining parameters oan de API tsjinner, en de klasse APIClient is ferantwurdlik foar ynteraksje mei de API.
Bepale ferbining parameters
Om ferskate parameters te definiearjen foar ferbining mei de API, moatte jo in eksimplaar fan 'e klasse oanmeitsje APIClientArgs. Yn prinsipe binne de parameters foarôf definieare en by it útfieren fan it skript op 'e kontrôletsjinner hoege se net te spesifisearjen.
client_args = APIClientArgs()Mar as jo rinne op in host fan tredden, moatte jo op syn minst it IP-adres of hostnamme fan 'e API-tsjinner opjaan (ek wol de behearserver neamd). Yn it foarbyld hjirûnder definiearje wy de tsjinnerferbiningparameter en jouwe it it IP-adres fan 'e behearserver as in tekenrige ta.
client_args = APIClientArgs(server='192.168.47.241')Litte wy nei alle parameters en har standertwearden sjen dy't kinne wurde brûkt by it ferbinen mei de API-tsjinner:
Arguminten fan de __init__ metoade fan de APIClientArgs klasse
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 = contextIk leau dat de arguminten dy't brûkt wurde kinne yn eksimplaren fan 'e APIClientArgs-klasse yntuïtyf binne foar Check Point-behearders en hawwe gjin ekstra opmerkings nedich.
Ferbine fia APIClient en kontekstbehearder
Klasse APIClient De maklikste manier om it te brûken is fia de kontekstbehearder. Alles dat moat wurde trochjûn oan in eksimplaar fan 'e APIClient-klasse is de ferbiningsparameters dy't yn' e foarige stap definieare binne.
with APIClient(client_args) as client:
De kontekstbehearder sil net automatysk in oanmeldoprop meitsje nei de API-tsjinner, mar it sil in útlogoprop meitsje by it útgean. As om ien of oare reden útlogge net fereaske is nei it wurk mei API-oproppen, moatte jo begjinne te wurkjen sûnder de kontekstbehearder te brûken:
client = APIClient(clieng_args)Kontrolearje de ferbining
De maklikste manier om te kontrolearjen oft de ferbining foldocht oan de opjûne parameters is mei de metoade check_fingerprint. As de ferifikaasje fan 'e sha1-hash-som foar de fingerprint fan it tsjinner API-sertifikaat mislearret (de metoade weromjûn falsk), dan wurdt dit normaal feroarsake troch ferbiningsproblemen en kinne wy de útfiering fan it programma stopje (of de brûker de kâns jaan om de ferbiningsgegevens te korrigearjen):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Tink derom dat yn 'e takomst de klasse APIClient sil elke API-oprop kontrolearje (metoaden api_call и api_query, wy sille prate oer harren in bytsje fierder) sha1 fingerprint sertifikaat op de API tsjinner. Mar as, by it kontrolearjen fan de sha1 fingerprint fan it API-tsjinnersertifikaat, in flater wurdt ûntdutsen (it sertifikaat is ûnbekend of is feroare), de metoade check_fingerprint sil soargje foar de mooglikheid om te foegjen / feroarje ynformaasje oer it op de lokale masine automatysk. Dizze kontrôle kin folslein útskeakele wurde (mar dit kin allinich oanrikkemandearre wurde as skripts wurde útfierd op 'e API-tsjinner sels, by it ferbinen mei 127.0.0.1), mei it argumint APIClientArgs - unsafe_auto_accept (sjoch mear oer APIClientArgs earder yn "Definearje ferbiningsparameters").
client_args = APIClientArgs(unsafe_auto_accept=True)Oanmelde by API-tsjinner
У APIClient der binne safolle as 3 metoaden foar it oanmelden op de API tsjinner, en elk fan harren begrypt de betsjutting Sid(session-id), dy't automatysk brûkt wurdt yn elke folgjende API-oprop yn 'e koptekst (de namme yn' e koptekst fan dizze parameter is X-chkp-side), dus it is net nedich om dizze parameter fierder te ferwurkjen.
login metoade
Opsje mei oanmelding en wachtwurd (yn it foarbyld wurde de brûkersnamme admin en wachtwurd 1q2w3e trochjûn as posisjonele arguminten):
login = client.login('admin', '1q2w3e') Oanfoljende opsjonele parameters binne ek beskikber yn 'e oanmeldmetoade; hjir binne har nammen en standertwearden:
continue_last_session=False, domain=None, read_only=False, payload=NoneLogin_with_api_key metoade
Opsje mei in api-kaai (stipe fanôf behearferzje R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" dit is de API-kaaiwearde foar ien fan 'e brûkers op 'e behearserver mei de API-kaaiautorisaasjemetoade):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Yn metoade login_with_api_key deselde opsjonele parameters binne beskikber as yn 'e metoade login.
login_as_root metoade
Opsje om oan te melden by in lokale masine mei in API-tsjinner:
login = client.login_as_root()D'r binne mar twa opsjonele parameters beskikber foar dizze metoade:
domain=None, payload=NoneEn úteinlik neamt de API harsels
Wy hawwe twa opsjes om API-oproppen te meitsjen fia metoaden api_call и api_query. Litte wy útfine wat it ferskil tusken har is.
api_call
Dizze metoade is fan tapassing foar alle oproppen. Wy moatte it lêste diel trochjaan foar de api-oprop en de lading yn it fersyklichem as it nedich is. As de lading leech is, dan kin it hielendal net wurde oerdroegen:
api_versions = client.api_call('show-api-versions') Utfier foar dit fersyk ûnder de besuniging:
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'})Utfier foar dit fersyk ûnder de besuniging:
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
Lit my fuortdaliks reservearje dat dizze metoade allinich fan tapassing is foar petearen wêrfan de útfier offset omfettet. Sa'n konklúzje komt foar as it in grutte hoemannichte ynformaasje befettet of kin befetsje. Dit kin bygelyks in fersyk wêze foar in list fan alle oanmakke hostobjekten op de behearserver. Foar sokke oanfragen jout de API standert in list fan 50 objekten werom (jo kinne de limyt ferheegje nei 500 objekten yn it antwurd). En om ynformaasje net meardere kearen te lûken troch de offsetparameter yn it API-fersyk te feroarjen, is d'r in api_query-metoade dy't dit automatysk docht. Foarbylden fan oproppen wêr't dizze metoade nedich is: show-sesjes, show-hosts, show-netwurken, show-wildcards, show-groepen, show-adresberiken, show-simple-gateways, show-simple-clusters, show-tagongsrollen, show-fertroude-kliïnten, show-pakketten. Yn feite sjogge wy meartal wurden yn 'e namme fan dizze API-oproppen, sadat dizze oproppen makliker te behanneljen binne api_query
show_hosts = client.api_query('show-hosts') Utfier foar dit fersyk ûnder de besuniging:
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
})
De resultaten fan API-oproppen ferwurkje
Hjirnei kinne jo de fariabelen en metoaden fan 'e klasse brûke APIResponse(sawol binnen de kontekstbehearder as bûten). By de klasse APIResponse 4 metoaden en 5 fariabelen binne foarôf definieare; wy sille yn mear detail oer de wichtichste dûke.
sukses
Om te begjinnen, soe it in goed idee wêze om te soargjen dat de API-oprop suksesfol wie en in resultaat joech. Der is in metoade foar dit sukses:
In [49]: api_versions.success
Out[49]: True
Jout Wier as de API-oprop suksesfol wie (antwurdkoade - 200) en False as net suksesfol (elke oare antwurdkoade). It is handich om direkt nei in API-oprop te brûken om ferskate ynformaasje te werjaan ôfhinklik fan 'e antwurdkoade.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuscode
Jout de antwurdkoade werom neidat in API-oprop dien is.
In [62]: api_versions.status_code
Out[62]: 400
Mooglike antwurdkoades: 200,400,401,403,404,409,500,501.
set_success_status
Yn dit gefal kin it nedich wêze om de wearde fan 'e súksesstatus te feroarjen. Technysk kinne jo dêr alles sette, sels in gewoane snaar. Mar in echt foarbyld soe dizze parameter weromsette nei False ûnder bepaalde byhearrende betingsten. Jou hjirûnder omtinken oan it foarbyld as d'r taken rinne op 'e behearserver, mar wy sille dit fersyk as mislearre beskôgje (wy sille de súksesfariabele ynstelle op falsk, nettsjinsteande it feit dat de API-oprop suksesfol wie en koade 200 weromkaam).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakantwurd()
De antwurdmetoade lit jo it wurdboek besjen mei de antwurdkoade (status_koade) en it antwurdlichem (lichem).
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
Hjirmei kinne jo allinich it lichem fan 'e reaksje (lichem) sjen sûnder ûnnedige ynformaasje.
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']}
foutmelding
Dizze ynformaasje is allinich beskikber as in flater barde by it ferwurkjen fan it API-fersyk (antwurdkoade net 200). Foarbyld útfier
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Nuttige foarbylden
De folgjende binne foarbylden dy't de API-oproppen brûke dy't binne tafoege yn Management API 1.6.
Litte wy earst sjen hoe't petearen wurkje add-host и add-adres-berik. Litte wy sizze dat wy alle IP-adressen fan it subnet 192.168.0.0/24 moatte oanmeitsje, wêrfan it lêste oktet 5 is, as objekten fan it hosttype, en alle oare IP-adressen skriuwe as objekten fan it adresberiktype. Slút yn dit gefal it subnetadres en útstjoeradres út.
Dat, hjirûnder is in skript dat dit probleem oplost en 50 objekten fan it hosttype en 51 objekten fan it adresberiktype makket. Om it probleem op te lossen, binne 101 API-oproppen ferplicht (net telle de definitive publisearjende oprop). Ek mei de timeit-module berekkenje wy de tiid dy't it duorret om it skript út te fieren oant de wizigingen wurde publisearre.
Skript mei help fan add-host en add-adres-berik
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')
Yn myn laboratoariumomjouwing duorret dit skript tusken 30 en 50 sekonden om út te fieren, ôfhinklik fan de lading op 'e behearserver.
Litte wy no sjen hoe't jo itselde probleem oplosse kinne mei in API-oprop add-objekten-batch, stipe foar dat waard tafoege yn API ferzje 1.6. Mei dizze oprop kinne jo in protte objekten tagelyk meitsje yn ien API-fersyk. Boppedat kinne dit objekten fan ferskate soarten wêze (bygelyks hosts, subnets en adresbereiken). Sa kin ús taak oplost wurde binnen it ramt fan ien API-oprop.
Skript mei help fan 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 it útfieren fan dit skript yn myn laboratoariumomjouwing duorret fan 3 oant 7 sekonden, ôfhinklik fan de lading op 'e behearserver. Dat is, gemiddeld, op 101 API-objekten, rint in batch-type oprop 10 kear rapper. Op in grutter tal objekten sil it ferskil noch yndrukwekkender wêze.
Litte wy no sjen hoe't jo mei wurkje set-objekten-batch. Mei dizze API-oprop kinne wy elke parameter yn bulk feroarje. Litte wy de earste helte fan 'e adressen fan it foarige foarbyld (oant .124 hosts, en ek berik) ynstelle nei de kleur sienna, en de kleur kaki tawize oan 'e twadde helte fan 'e adressen.
It feroarjen fan de kleur fan de objekten makke yn it foarige foarbyld
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")
Jo kinne meardere objekten wiskje yn ien API-oprop mei wiskje-objekten-batch. Litte wy no sjen nei in koadefoarbyld dat alle earder makke hosts wisket fia add-objekten-batch.
It wiskjen fan objekten mei help fan 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 funksjes dy't ferskine yn nije releases fan Check Point-software krije fuortendaliks API-oproppen. Sa ferskynden yn R80.40 sokke "funksjes" as Werom nei revyzje en Smart Task, en korrespondearjende API-oproppen waarden fuortendaliks foar har taret. Boppedat krijt alle funksjonaliteit by it ferpleatsen fan Legacy-konsoles nei Unified Policy-modus ek API-stipe. Bygelyks, de langferwachte fernijing yn software ferzje R80.40 wie de ferhuzing fan it HTTPS Ynspeksje belied fan Legacy modus nei Unified Policy modus, en dizze funksjonaliteit fuortendaliks ûntfongen API oproppen. Hjir is in foarbyld fan koade dy't in regel tafoegje oan 'e topposysje fan it HTTPS-ynspeksjebelied dat 3-kategoryen útslút fan ynspeksje (sûnens, finânsjes, oerheidstsjinsten), dy't ferbean binne fan ynspeksje yn oerienstimming mei de wet yn in oantal lannen.
Foegje in regel ta oan it HTTPS-ynspeksjebelied
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-skripts útfiere op de Check Point-behearserver
Alles is itselde befettet ynformaasje oer hoe't jo Python-skripts direkt útfiere fan 'e kontrôletsjinner. Dit kin handich wêze as jo net kinne ferbine mei de API-tsjinner fan in oare masine. Ik haw in fideo fan seis minuten opnommen wêryn ik sjoch nei it ynstallearjen fan de module cpapi en funksjes fan it útfieren fan Python-skripts op 'e kontrôletsjinner. As foarbyld wurdt in skript útfierd dat de konfiguraasje fan in nije gateway automatisearret foar in taak lykas netwurkkontrôle Feiligens CheckUp. Under de funksjes dêr't ik mei te krijen hie: de funksje is noch net ferskynd yn Python 2.7 ynfier, dus om de ynformaasje te ferwurkjen dy't de brûker ynfiert, wurdt in funksje brûkt raw_ynput. Oars is de koade itselde as foar lansearring fan oare masines, allinich is it handiger om de funksje te brûken login_as_root, om jo eigen brûkersnamme, wachtwurd en IP-adres fan de behearserver net wer op te jaan.
Skript foar rappe opset fan 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() In foarbyldbestân mei in wachtwurdwurdboek additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
konklúzje
Dit artikel ûndersiket allinich de basismooglikheden fan wurk Python SDK en module cpapi(lykas jo miskien hawwe rieden, dit binne eins synonimen), en troch it bestudearjen fan de koade yn dizze module sille jo noch mear mooglikheden ûntdekke om dermei te wurkjen. It is mooglik dat jo it wolle oanfolje mei jo eigen klassen, funksjes, metoaden en fariabelen. Jo kinne jo wurk altyd diele en oare skripts foar Check Point besjen yn 'e seksje yn de mienskip , dy't sawol produktûntwikkelders as brûkers byinoar bringt.
Lokkige kodearring en tank foar it lêzen oant it ein!
Boarne: www.habr.com