Die gesamte Kraft der Interaktion mit der API entfaltet sich in Verbindung mit Programmcode, wenn die Möglichkeit besteht, API-Anfragen dynamisch zu erstellen und Tools zur Analyse von API-Antworten zu nutzen. Bislang bleibt jedoch wenig wahrgenommen, Python Software Development Kit (im Folgenden – Python SDK) für Check Point Management API, und das zu Unrecht. Es erleichtert das Leben von Entwicklern und Automatisierungsbegeisterten erheblich. Python hat in letzter Zeit enorme Popularität erlangt, und ich habe beschlossen, die Lücke zu schließen und eine Übersicht über die wichtigsten Funktionen zu geben. . Dieser Artikel dient als hervorragende Ergänzung zu einem anderen Artikel auf Habré, . Wir werden uns ansehen, wie man Skripte mit dem Python SDK schreibt und dabei genauer auf die neuen Funktionen des Management API in Version 1.6 (unterstützt ab R80.40) eingehen. Für das Verständnis des Artikels sind grundlegende Kenntnisse über die Arbeit mit APIs und Python erforderlich.
Check Point entwickelt die API aktiv weiter, und momentan sind folgende erschienen:
- — Arbeiten mit dem Management-Server über die API (und die Möglichkeit, Skripte auf Gateways, die vom Management-Server verwaltet werden, auszuführen)
- — Arbeiten mit Sicherheits-Gateways
- — Arbeiten mit der Cloud-Sandbox von Check Point
- — Arbeiten mit dem Identity Awareness Blade an Gateways
- — Arbeiten mit dem SMB-Gateway-Management-Portal ()
- — Interaktion mit IoT-Controllern
- — Arbeiten mit (SD-WAN-Sicherheitslösung)
- — Arbeiten mit
Das Python SDK unterstützt derzeit nur die Interaktion mit dem Management API und Gaia API. Wir werden die wichtigsten Klassen, Methoden und Variablen in diesem Modul betrachten.
Installation des Moduls
Modul cpapi wird schnell und einfach aus mit Hilfe von pip. Eine ausführliche Installationsanleitung finden Sie in . Dieses Modul ist für die Verwendung mit den Versionen Python 2.7 und 3.7 angepasst. In diesem Artikel werden Beispiele mit Python 3.7 präsentiert. Das Python SDK kann jedoch direkt von der Check Point-Verwaltung (Smart Management) ausgeführt werden, wo nur die Version Python 2.7 unterstützt wird; daher wird im letzten Abschnitt der Code für die Version 2.7 angegeben. Unmittelbar nach der Installation des Moduls empfehle ich, sich die Beispiele in den Verzeichnissen anzusehen examples_python2 und examples_python3.
Erste Schritte
Um mit den Komponenten des Moduls cpapi arbeiten zu können, müssen wir aus dem Modul importieren cpapi mindestens zwei notwendige Klassen:
APIClient und APIClientArgs
from cpapi import APIClient, APIClientArgs
Klasse APIClientArgs verantwortlich für die Verbindungsparameter zum API-Server, während die Klasse APIClient für die Interaktion mit dem API zuständig ist.
Definieren der Verbindungsparameter
Um verschiedene Verbindungsparameter zum API zu definieren, muss eine Instanz der Klasse APIClientArgserstellt werden. Im Grunde sind seine Parameter vordefiniert und beim Ausführen des Skripts auf dem Verwaltungsserver müssen sie nicht angegeben werden.
client_args = APIClientArgs()Aber beim Ausführen auf einem externen Host muss mindestens die IP-Adresse oder der Hostname des API-Servers (auch Verwaltungsserver genannt) angegeben werden. Im folgenden Beispiel definieren wir den Verbindungsparameter server und weisen ihm die IP-Adresse des Verwaltungsservers als Zeichenfolge zu.
client_args = APIClientArgs(server='192.168.47.241')Lassen Sie uns alle Parameter und ihre Standardwerte ansehen, die beim Verbinden mit dem API-Server verwendet werden können:
Arguments des __init__-Methoden der Klasse APIClientArgs
class APIClientArgs:
"""
Diese Klasse stellt Argumente für die APIClient-Konfiguration zur Verfügung.
Alle Argumente sind mit ihren Standardwerten konfiguriert.
"""
# Der Port ist standardmäßig auf None gesetzt, wird aber auf 443 ersetzt, wenn er nicht angegeben ist.
# Mögliche Werte für den Kontext - web_api (Standard) oder 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
# Fingerabdruck des Verwaltungsservers
self.fingerprint = fingerprint
# Sitzungs-ID.
self.sid = sid
# Name oder IP-Adresse des Verwaltungsservers
self.server = server
# Debuggeniveau
self.http_debug_level = http_debug_level
# Ein Array mit allen API-Aufrufen (zu Debugging-Zwecken)
self.api_calls = api_calls if api_calls else []
# Name der Debug-Datei. Wenn leer gelassen, werden Debug-Daten nicht auf der Festplatte gespeichert.
self.debug_file = debug_file
# HTTP-Proxyserveradresse (ohne "http://")
self.proxy_host = proxy_host
# HTTP-Proxyport
self.proxy_port = proxy_port
# API-Version des Verwaltungsservers
self.api_version = api_version
# Gibt an, dass der Client nicht das Zertifikat des Servers überprüfen sollte
self.unsafe = unsafe
# Gibt an, dass der Client das Zertifikat des Servers automatisch akzeptieren und speichern sollte
self.unsafe_auto_accept = unsafe_auto_accept
# Der Kontext der Nutzung des Clients - standardmäßig web_api
self.context = contextIch nehme an, dass die Argumente, die in Instanzen der Klasse APIClientArgs verwendet werden, für die Administratoren von Check Point intuitiv verständlich sind und keiner zusätzlichen Erläuterung bedürfen.
Wir verbinden uns über APIClient und den Kontextmanager
Klasse APIClient am besten über den Kontextmanager. Alles, was an die Instanz der Klasse APIClient übergeben werden muss, sind die Verbindungsparameter, die im vorherigen Schritt festgelegt wurden.
with APIClient(client_args) as client:
Der Kontextmanager führt nicht automatisch einen Login-Aufruf an den API-Server durch, aber er führt einen Logout-Aufruf beim Verlassen aus. Wenn aus irgendeinem Grund der Logout nach der Arbeit mit den API-Aufrufen nicht erforderlich ist, sollte die Arbeit ohne Verwendung des Kontextmanagers begonnen werden:
client = APIClient(client_args)Verbindung überprüfen
Die einfachste Möglichkeit, zu überprüfen, ob die Verbindung mit den angegebenen Parametern funktioniert, erfolgt über die Methode check_fingerprint. Wenn die SHA1-Prüfziffer für das Fingerprint-Zertifikat des API-Servers nicht bestanden hat (die Methode hat zurückgegeben False), liegt dies normalerweise an Verbindungsproblemen, und wir können die Ausführung des Programms stoppen (oder dem Benutzer die Möglichkeit geben, die Verbindungsdaten zu korrigieren):
if client.check_fingerprint() is False:
print("Konnte den Fingerabdruck des Servers nicht abrufen - Überprüfen Sie die Konnektivität mit dem Server.")
exit(1)
Bitte beachten Sie, dass die Klasse APIClient bei jedem API-Aufruf (Methoden api_call und api_query, darauf wird später näher eingegangen) den sha1-Fingerabdruck des Zertifikats auf dem API-Server überprüfen wird. Sollte bei der Überprüfung des sha1-Fingerabdrucks des API-Serverzertifikats ein Fehler festgestellt werden (Zertifikat unbekannt oder geändert), ermöglicht die Methode check_fingerprint die Möglichkeit, Informationen über das Zertifikat auf der lokalen Maschine automatisch hinzuzufügen/zu ändern. Diese Überprüfung kann vollständig deaktiviert werden (aber dies kann nur empfohlen werden, wenn Skripte auf dem API-Server selbst ausgeführt werden, wenn Sie sich mit 127.0.0.1 verbinden), indem Sie das Argument APIClientArgs— unsafe_auto_accept verwenden (siehe vorhergehenden Abschnitt „Parameter für die Verbindung definieren“).
client_args = APIClientArgs(unsafe_auto_accept=True)Anmeldung beim API-Server
U APIClient es gibt insgesamt 3 Methoden zur Anmeldung beim API-Server, und jede von ihnen speichert den Wert sid(Sitzungs-ID), der automatisch in jedem nachfolgenden API-Aufruf im Header verwendet wird (der Name dieses Parameters im Header ist— X-chkp-sid), sodass dieser Parameter nicht zusätzlich verarbeitet werden muss.
Die Login-Methode
Option zur Verwendung von Login und Passwort (im Beispiel wurden der Benutzername admin und das Passwort 1q2w3e als Positionsargumente übergeben):
login = client.login('admin', '1q2w3e') Im Login-Methode sind auch zusätzliche optionale Parameter verfügbar, ich führe ihre Namen und Standardwerte auf:
continue_last_session=False, domain=None, read_only=False, payload=NoneMethode login_with_api_key
Option zur Verwendung eines API-Schlüssels (unterstützt ab Version R80.40/Management API v1.6, „3TsbPJ8ZKjaJGvFyoFqHFA==“ dies ist der Wert des API-Schlüssels für einen der Benutzer auf dem Management-Server mit der Authentifizierungsmethode API-Schlüssel):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') In der Methode login_with_api_key sind dieselben optionalen Parameter verfügbar wie in der Methode anmelden.
Methode login_as_root
Option des Logins auf den lokalen Rechner mit API-Server:
login = client.login_as_root()Für diese Methode sind nur zwei optionale Parameter verfügbar:
domain=None, payload=NoneUnd schließlich die API-Aufrufe
Wir haben zwei Optionen, API-Aufrufe über Methoden zu machen. api_call und api_queryLassen Sie uns herausfinden, worin der Unterschied zwischen ihnen besteht.
api_call
Diese Methode kann für alle Aufrufe verwendet werden. Wir müssen den letzten Teil für den API-Aufruf und die Nutzlast im Anforderungstext bei Bedarf übergeben. Wenn die Nutzlast leer ist, muss sie nicht übergeben werden:
api_versions = client.api_call('show-api-versions') Die Ausgabe für diese Anfrage finden Sie unter dem folgenden Abschnitt:
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'})Die Ausgabe für diese Anfrage finden Sie unter dem folgenden Abschnitt:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "schwarz",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC Benutzer",
"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": "schwarz",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC Benutzer",
"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
Zunächst möchte ich klarstellen, dass diese Methode nur für Aufrufe anwendbar ist, deren Ausgabe einen Offset (Verschiebung) erfordert. Eine solche Ausgabe erfolgt, wenn sie eine große Menge an Informationen enthält oder enthalten kann. Ein Beispiel dafür könnte eine Anfrage nach einer Liste aller auf dem Verwaltungsserver erstellten Hostobjekte sein. Für solche Anfragen gibt die API standardmäßig eine Liste von 50 Objekten zurück (der Limi kann auf bis zu 500 Objekte erhöht werden). Um die Informationen nicht mehrfach abzurufen, indem der Offset-Parameter in der API-Abfrage geändert wird, gibt es die Methode api_query, die diese Arbeit automatisch erledigt. Beispiele für Aufrufe, bei denen diese Methode benötigt wird: 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. Tatsächlich sehen wir im Namen dieser API-Aufrufe Worte in der Mehrzahl, sodass diese Aufrufe einfacher über api_query
show_hosts = client.api_query('show-hosts') Die Ausgabe für diese Anfrage finden Sie unter dem folgenden Abschnitt:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC Benutzer",
"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 Benutzer",
"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 Benutzer",
"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 Benutzer",
"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
})
Verarbeitung der Ergebnisse von API-Aufrufen
Danach können die Variablen und Methoden der Klasse verwendet werden APIResponse(sowohl innerhalb des Kontextmanagers als auch außerhalb). Die Klasse APIResponse verfügt über 4 Methoden und 5 Variablen, auf die wichtigsten werden wir näher eingehen.
Erfolg
Zunächst wäre es gut, sicherzustellen, dass der API-Aufruf erfolgreich war und ein Ergebnis zurückgegeben hat. Dafür gibt es die Methode Erfolg:
In [49]: api_versions.success
Out[49]: True
Gibt True zurück, wenn der API-Aufruf erfolgreich war (Antwortcode — 200) und False, wenn er nicht erfolgreich war (irgendein anderer Antwortcode). Es ist bequem, dies direkt nach einem API-Aufruf zu verwenden, um je nach Antwortcode verschiedene Informationen auszugeben.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) Antwortcode
Gibt den Antwortcode nach der Ausführung des API-Aufrufs zurück.
In [62]: api_versions.status_code
Out[62]: 400
Mögliche Antwortcodes: 200,400,401,403,404,409,500,501.
set_success_status
Es kann erforderlich sein, den Statuswert 'success' zu ändern. Technisch gesehen kann dort alles hineingestellt werden, sogar eine gewöhnliche Zeichenfolge. Ein reales Beispiel könnte sein, diesen Parameter auf 'False' zurückzusetzen, wenn bestimmte begleitende Bedingungen erfüllt sind. Beachten Sie unten ein Beispiel, bei dem Aufgaben auf dem Management-Server ausgeführt werden, wir jedoch diesen Auftrag als gescheitert betrachten (wir setzen die Variable 'success' auf False, obwohl der API-Aufruf erfolgreich war und den Code 200 zurückgab).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakresponse()
Die Methode response ermöglicht es, das Dictionary mit dem Statuscode (status_code) und dem Antworttext (body) anzuzeigen.
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
Es zeigt nur den Antworttext (body) ohne überflüssige Informationen.
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
Diese Informationen sind nur verfügbar, wenn bei der Verarbeitung der API-Anfrage ein Fehler aufgetreten ist (Statuscode nicht 200). Beispielausgabe
In [107]: api_versions.error_message \nOut[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Nützliche Beispiele
Im Folgenden sind Beispiele aufgeführt, die API-Aufrufe verwenden, die in die Version Management API 1.6 aufgenommen wurden.
Zunächst betrachten wir die Funktionsweise der Aufrufe add-host und add-address-range. Angenommen, wir müssen alle IP-Adressen im Subnetz 192.168.0.0/24, deren letzter Oktett 5 ist, als Host-Objekte erstellen, während alle anderen IP-Adressen als Adressbereich-Objekte aufgezeichnet werden. Dabei sollten das Subnetz und die Broadcast-Adresse ausgeschlossen werden.
Unten finden Sie das Skript, das diese Aufgabe löst und 50 Host-Objekte sowie 51 Adressbereich-Objekte erstellt. Für die Lösung der Aufgabe sind 101 API-Aufrufe erforderlich (ohne den abschließenden Aufruf publish). Außerdem berechnen wir mit dem Modul timeit die Zeit zur Ausführung des Skripts bis zur Veröffentlichung der Änderungen.
Skript mit Verwendung von add-host und 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')
In meiner Laborumgebung benötigt das Ausführen dieses Skripts je nach Last auf dem Verwaltungsserver zwischen 30 und 50 Sekunden.
Schauen wir uns nun an, wie dieselbe Aufgabe mit einem API-Aufruf gelöst werden kann add-objects-batch, dessen Unterstützung in Version 1.6 der API hinzugefügt wurde. Dieser Aufruf ermöglicht es, in einem API-Anruf eine Vielzahl von Objekten gleichzeitig zu erstellen. Dabei kann es sich um Objekte verschiedener Typen handeln (zum Beispiel Hosts, Subnetze und Adressbereiche). So kann unsere Aufgabe im Rahmen eines einzigen API-Aufrufs erledigt werden.
Skript unter Verwendung von 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')
Die Ausführung dieses Skripts in meiner Laborumgebung dauert abhängig von der Last auf dem Verwaltungserver zwischen 3 und 7 Sekunden. Durchschnittlich wird bei 101 Objekten der API-Aufruf vom Typ Batch zehnmal schneller ausgeführt. Bei einer größeren Anzahl von Objekten wird der Unterschied noch beeindruckender sein.
Jetzt schauen wir uns an, wie man mit set-objects-batch. Mit diesem API-Aufruf können wir jeden Parameter in großen Mengen ändern. Lassen Sie uns die erste Hälfte der Adressen aus dem vorherigen Beispiel (bis zur .124 der Hosts, einschließlich der Bereiche) in sienna und der zweiten Hälfte der Adressen die Farbe khaki zuweisen.
Änderung der Farbe von Objekten, die im vorherigen Beispiel erstellt wurden
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")
Um mehrere Objekte in einem API-Aufruf zu löschen, verwenden Sie delete-objects-batch. Schauen wir uns nun ein Beispiel für Code an, der alle zuvor über add-objects-batch.
das Löschen von Objekten mit delete-objects-batch entfernt.
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 Funktionen, die in neuen Check Point Software-Releases erscheinen, sind sofort auch über API-Aufrufe verfügbar. In R80.40 wurden zum Beispiel Funktionen wie "Revert to revision" und "Smart Task" eingeführt, für die sofort die entsprechenden API-Aufrufe vorbereitet wurden. Darüber hinaus erhält die gesamte Funktionalität beim Übergang von Legacy-Konsole in den Unified Policy-Modus ebenfalls API-Unterstützung. Ein lang erwartetes Update in der Softwareversion R80.40 war der Übergang der HTTPS Inspection-Richtlinie aus dem Legacy-Modus in den Unified Policy-Modus, und diese Funktionalität erhielt sofort API-Aufrufe. Hier ist ein Beispielcode, der in der oberen Position der HTTPS Inspection-Richtlinie eine Regel hinzufügt, die drei Kategorien (Gesundheit, Finanzen, Staatliche Dienste) von der Inspektion ausschließt, deren Inspektion gemäß der Gesetzgebung in mehreren Ländern verboten ist.
Regel zur HTTPS Inspection hinzufügen
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Rechtliche Anforderungen",
"action": "bypass",
"site-category": ["Gesundheit", "Regierung / Militär", "Finanzdienstleistungen"]
}
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")
Ausführen von Python-Skripten auf dem Check Point Management-Server
Alles beim Alten Hier finden Sie Informationen dazu, wie Sie Skripte in Python direkt vom Verwaltungsserver ausführen können. Dies kann praktisch sein, wenn Sie keine Möglichkeit haben, sich mit dem API-Server von einem anderen Computer aus zu verbinden. Ich habe ein sechsminütiges Video aufgenommen, in dem ich die Installation des Moduls bespreche. cpapi und die Besonderheiten der Ausführung von Python-Skripten auf dem Verwaltungsserver. Als Beispiel wird ein Skript ausgeführt, das die Konfiguration eines neuen Gateways für Aufgaben wie die Netzwerküberprüfung automatisiert. Security CheckUp. Zu den Besonderheiten, mit denen ich konfrontiert wurde, gehört, dass in Python 2.7 die Funktion noch nicht verfügbar ist. input, daher wird zur Verarbeitung der Informationen, die der Benutzer eingibt, die Funktion raw_input. Ansonsten ist der Code derselbe wie bei der Ausführung von anderen Maschinen, es ist nur bequemer, die Funktion login_as_root, zu verwenden, um nicht erneut Benutzernamen, Passwort und die IP-Adresse des Verwaltungsservers angeben zu müssen.
Skript zur schnellen Einrichtung von 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:
# wenn client.check_fingerprint() False zurückgibt:
# print("Konnte den Fingerabdruck des Servers nicht abrufen - Überprüfen Sie die Konnektivität mit dem Server.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Anmeldung fehlgeschlagen:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Geben Sie den Namen des Gateways ein:")
gw_ip = raw_input("Geben Sie die IP-Adresse des Gateways ein:")
if sys.stdin.isatty():
sic = getpass.getpass("Geben Sie das Einmalpasswort für das Gateway (SIC) ein:")
else:
print("Achtung! Ihr Passwort wird auf dem Bildschirm angezeigt!")
sic = raw_input("Geben Sie das Einmalpasswort für das Gateway (SIC) ein:")
version = raw_input("Geben Sie die Gateway-Version ein (zum Beispiel 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("Sichere Verbindung mit dem Gateway wurde nicht hergestellt!")
exit(1)
elif add_gw.success:
print("Das Gateway wurde erfolgreich hinzugefügt.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Fehler beim Hinzufügen des Gateways - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Netzwerk", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("Die Richtlinie wurde erfolgreich geändert")
else:
print("Fehler beim Ändern der Richtlinie - {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Bereinigung Regel", "layer" : "Netzwerk", "action": "Akzeptieren", "track": {"type": "Detailliertes Protokoll", "accounting": "true"}})
if change_rule.success:
print("Die Bereinigungsregel wurde erfolgreich geändert")
else:
print("Fehler beim Ändern der Bereinigungsregel - {}".format(change_rule.error_message))
# die Ergebnisse veröffentlichen
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Die Änderungen wurden erfolgreich veröffentlicht.")
else:
print("Fehler beim Veröffentlichen der Änderungen - {}".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("Die Zugriffsrichtlinie wurde installiert")
else:
print("Fehler beim Installieren der Zugriffsrichtlinie - {}".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("Die Richtlinie zur Bedrohungsvorbeugung wurde installiert")
else:
print("Fehler beim Installieren der Richtlinie zur Bedrohungsvorbeugung - {}".format(install_tp_policy.error_message))
# Passwörter und Passphrasen zum Wörterbuch hinzufügen
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" : "Passwörter und Passphrasen hinzufügen", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Die Zeile {} im Passwortwörterbuch wurde erfolgreich hinzugefügt".format(line_num))
else:
print("Fehler beim Hinzufügen des Wörterbuchs - {}".format(add_password_dictionary.error_message))
main() Beispiel einer Datei mit dem Passwortwörterbuch additional_pass.conf
{
"passwords" : ["Malware","bösartig","infiziert","Infiziert"],
"phrases" : ["Passwort","Passwort","Pass","pass","codigo","Schlüssel","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Fazit
Dieser Artikel behandelt nur die grundlegenden Funktionen. Python SDK und das Modul cpapi(wie Sie vielleicht erraten haben, sind dies tatsächlich Synonyme), und wenn Sie den Code in diesem Modul studieren, werden Sie noch mehr Möglichkeiten entdecken, mit ihm zu arbeiten. Es ist nicht auszuschließen, dass Sie den Drang verspüren, es mit eigenen Klassen, Funktionen, Methoden und Variablen zu ergänzen. Sie können Ihre Entwicklungen immer teilen und andere Skripte für Check Point im Bereich in der Gemeinschaft , die sowohl Produktentwickler als auch Benutzer vereint.
Viel Spaß beim Programmieren und danke, dass Sie bis zum Ende gelesen haben!
Quelle: habr.com
