Die gesamte Kraft der Interaktion mit der API entfaltet sich in Kombination mit Programmiersprachen, wenn sich die Möglichkeit ergibt, API-Anfragen dynamisch zu erstellen und Werkzeuge zur Analyse von API-Antworten zur Verfügung zu haben. Allerdings bleibt es bisher weitgehend unbemerkt. Python Software Development Kit (weiterhin — Python SDK) für Check Point Management API, was schade ist. Es vereinfacht das Leben von Entwicklern und Automatisierungsbegeisterten erheblich. Python hat in letzter Zeit große Popularität erlangt, und ich habe entschieden, die Lücke zu schließen und die grundlegenden Möglichkeiten zu überprüfen. . Dieser Artikel dient als hervorragende Ergänzung zu einem anderen Artikel auf Habré. . Wir werden uns anschauen, wie man Skripte mit Hilfe des Python SDK schreibt und näher auf die neuen Funktionen der 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 API und Python erforderlich.
Check Point entwickelt die API aktiv weiter, und bisher sind folgende erschienen:
- — Interaktion mit dem Management-Server über die API (und die Möglichkeit, Skripte auf Gateways zu erstellen, die vom Management-Server verwaltet werden)
- — Interaktion mit Sicherheits-Gateways
- — Arbeiten mit der Sandbox in der Cloud von Check Point
- — Arbeiten mit der Identity Awareness Blade auf Gateways
- — Arbeiten mit dem Management-Portal für SMB-Gateways ()
- — Interaktion mit IoT-Controllern
- — Arbeiten mit (eine SD-WAN Sicherheitslösung)
- — Arbeiten mit
Das Python SDK unterstützt derzeit nur die Interaktion mit der Management API und Gaia API. Wir werden die wichtigsten Klassen, Methoden und Variablen in diesem Modul betrachten.
Die Installation des Moduls
Modul cpapi geht schnell und einfach über mit pip. Eine ausführliche Anleitung zur Installation findet sich in . Dieses Modul ist für die Verwendung mit den Versionen Python 2.7 und 3.7 angepasst. In diesem Artikel werden die Beispiele mit Python 3.7 gegeben. Allerdings kann das Python SDK direkt vom Check Point Management-Server (Smart Management) ausgeführt werden, wo jedoch nur Python 2.7 unterstützt wird, deshalb wird im letzten Abschnitt der Code für Version 2.7 bereitgestellt. 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 cpapi-Moduls arbeiten zu können, müssen wir sie aus dem Modul importieren. cpapi mindestens zwei erforderliche Klassen:
APIClient und APIClientArgs
from cpapi import APIClient, APIClientArgs
Klasse APIClientArgs verantwortlich für die Verbindungsparameter zum API-Server, während die Klasse APIClient die Interaktion mit der API steuert.
Definieren der Verbindungsparameter
Um verschiedene Verbindungsparameter zur API festzulegen, muss eine Instanz der Klasse APIClientArgserzeugt werden. Prinzipiell sind seine Parameter vordefiniert und bei der Ausführung des Skripts auf dem Verwaltungsserver müssen sie nicht angegeben werden.
client_args = APIClientArgs()Aber beim Ausführen auf einem fremden Host müssen 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 als String die IP-Adresse des Verwaltungsservers zu.
client_args = APIClientArgs(server='192.168.47.241')Lassen Sie uns alle Parameter und ihre Standardwerte betrachten, die beim Anschluss an den API-Server verwendet werden können:
Argumente der __init__ Methode der Klasse APIClientArgs
class APIClientArgs:
"""
Diese Klasse bietet Argumente für die Konfiguration von APIClient.
Alle Argumente sind mit ihren Standardwerten konfiguriert.
"""
# Der Port ist standardmäßig auf None gesetzt, wird aber durch 443 ersetzt, wenn nicht angegeben
# 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
# Session-ID.
self.sid = sid
# Name oder IP-Adresse des Verwaltungsservers
self.server = server
# Debug-Level
self.http_debug_level = http_debug_level
# ein Array mit allen API-Aufrufen (zu Debug-Zwecken)
self.api_calls = api_calls if api_calls else []
# Name der Debug-Datei. Wenn leer gelassen, werden die Debug-Daten nicht auf dem Disk gespeichert.
self.debug_file = debug_file
# HTTP-Proxy-Serveradresse (ohne "http://")
self.proxy_host = proxy_host
# HTTP-Proxy-Port
self.proxy_port = proxy_port
# API-Version des Verwaltungsservers
self.api_version = api_version
# Gibt an, dass der Client das Zertifikat des Servers nicht überprüfen soll
self.unsafe = unsafe
# Gibt an, dass der Client das Zertifikat des Servers automatisch akzeptieren und speichern soll
self.unsafe_auto_accept = unsafe_auto_accept
# Der Kontext der Verwendung des Clients - standardmäßig auf web_api eingestellt
self.context = contextIch nehme an, dass die Argumente, die in Instanzen der Klasse APIClientArgs verwendet werden können, für die Administratoren von Check Point intuitiv verständlich sind und keine zusätzlichen Kommentare benötigen.
Verbindung über APIClient und Context-Manager
Klasse APIClient ist am bequemsten über den Context-Manager zu verwenden. 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 Kontext-Manager wird den Login-Aufruf an den API-Server nicht automatisch ausführen, aber er wird beim Abmelden den Logout-Aufruf ausführen. Wenn aus bestimmten Gründen der Logout nach der Arbeit mit den API-Aufrufen nicht erforderlich ist, sollte die Arbeit ohne Verwendung des Kontextmanagers begonnen werden:
client = APIClient(clieng_args)Verbindung überprüfen
Es ist am einfachsten, die Verbindung anhand der angegebenen Parameter mit der Methode zu überprüfen check_fingerprint. Wenn die SHA1-Hash-Prüfung für das Fingerabdruck-Zertifikat des API-Servers nicht bestanden hat (die Methode hat zurückgegeben Falsch), liegt das normalerweise an Problemen mit der Verbindung, und wir können die Ausführung des Programms stoppen (oder dem Benutzer ermöglichen, die Verbindungsdaten zu korrigieren):
if client.check_fingerprint() is False:
print("Konnte den Fingerabdruck des Servers nicht abrufen - Überprüfen Sie die Konnektivität zum Server.")
exit(1)
Beachten Sie, dass die Klasse APIClient bei jedem API-Aufruf (Methoden api_call und api_query, auf die wir gleich zu sprechen kommen) 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), bietet die Methode check_fingerprint die Möglichkeit, Informationen darüber automatisch auf der lokalen Maschine hinzuzufügen/zu ändern. Diese Überprüfung kann vollständig deaktiviert werden (aber das kann nur empfohlen werden, wenn Skripte auf dem API-Server selbst ausgeführt werden, bei einer Verbindung zu 127.0.0.1), indem das Argument APIClientArgs verwendet wird — unsafe_auto_accept (siehe Details zu APIClientArgs zuvor in "Verbindungseinstellungen definieren").
client_args = APIClientArgs(unsafe_auto_accept=True)Login am API-Server
Der APIClient es gibt insgesamt 3 Methoden für den Login am API-Server, und jede von ihnen merkt sich den Wert sid(Session-ID), der automatisch bei jedem nachfolgenden API-Aufruf im Header verwendet wird (der Name in diesem Header für diesen Parameter ist X-chkp-sid), sodass keine zusätzliche Verarbeitung dieses Parameters erforderlich ist.
Methode login
Option mit Login und Passwort (im Beispiel wurden Benutzername admin und Passwort 1q2w3e als positionale Argumente übergeben):
login = client.login('admin', '1q2w3e') In der Methode login sind auch zusätzliche optionale Parameter verfügbar; hier sind ihre Namen und Standardwerte:
continue_last_session=False, domain=None, read_only=False, payload=NoneMethode login_with_api_key
Option mit Verwendung des API-Schlüssels (unterstützt ab Version R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" dies ist der API-Schlüssel für einen der Benutzer auf dem Verwaltungsserver mit der Authentifizierungsmethode API-Schlüssel:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') In der Methode login_with_api_key sind die gleichen optionalen Parameter wie in der Methode verfügbar login.
Die Methode login_as_root
Variante des Logins auf die lokale Maschine mit dem API-Server:
login = client.login_as_root()Für diese Methode sind insgesamt zwei optionale Parameter verfügbar:
domain=None, payload=NoneUnd schließlich die API-Aufrufe selbst
Wir haben zwei Möglichkeiten, API-Aufrufe über Methoden zu machen api_call und api_query. Lassen Sie uns klären, worin der Unterschied zwischen ihnen besteht.
api_call
Diese Methode ist für alle Aufrufe anwendbar. Wir müssen den letzten Teil für den API-Aufruf und payload im Body der Anfrage nach Bedarf übermitteln. Wenn der payload leer ist, kann er ganz weggelassen werden:
api_versions = client.api_call('show-api-versions') Ausgabe für diese Anfrage unter dem Spoiler:
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'})Ausgabe für diese Anfrage unter dem Spoiler:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "schwarz",
"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": "schwarz",
"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
Ich möchte gleich klarstellen, dass dieses Verfahren nur für Aufrufe anwendbar ist, deren Ausgabe einen Offset (Verschiebung) beinhaltet. Eine solche Ausgabe erfolgt, wenn sie eine große Menge an Informationen enthält oder enthalten könnte. Zum Beispiel kann das eine Anfrage nach einer Liste aller erstellten Objekte vom Typ Host auf dem Verwaltungsserver sein. Bei solchen Abfragen gibt die API standardmäßig eine Liste von 50 Objekten zurück (der Limit kann auf 500 Objekte in der Antwort erhöht werden). Um nicht mehrmals Informationen abzurufen und den Offset-Wert in der API-Anfrage zu ändern, gibt es die Methode api_query, die diese Aufgabe automatisch erledigt. Beispiele für Aufrufe, bei denen diese Methode erforderlich ist: 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 Wörter im Plural, sodass diese Aufrufe einfacher verarbeitet werden können über api_query
show_hosts = client.api_query('show-hosts') Ausgabe für diese Anfrage unter dem Spoiler:
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
Nach diesem Schritt können die Variablen und Methoden der Klasse verwendet werden APIResponse(sowohl innerhalb des Kontextmanagers als auch außerhalb). Die Klasse APIResponse hat 4 vordefinierte Methoden und 5 Variablen, auf die wichtigsten werden wir näher eingehen.
success
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 success:
In [49]: api_versions.success
Out[49]: True
Gibt True zurück, wenn der API-Aufruf erfolgreich war (Antwortcode — 200) und False, wenn nicht (jeder andere Antwortcode). Praktisch zur sofortigen Verwendung nach dem API-Aufruf, um je nach Antwortcode unterschiedliche Informationen auszugeben.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuscode
Gibt den Antwortcode nach der Durchfü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 notwendig sein, den Status success zu ändern. Technisch gesehen kann dort alles hineingesetzt werden, sogar ein einfacher String. Ein konkretes Beispiel könnte sein, diesen Parameter auf False zurückzusetzen, wenn bestimmte Begleitbedingungen erfüllt sind. Achten Sie im Folgenden auf ein Beispiel, bei dem es Aufgaben gibt, die auf dem Verwaltungsserver ausgeführt werden, wir jedoch diese Anfrage als erfolglos betrachten (wir setzen die Variable success auf Falsch, 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 Wörterbuch mit dem Antwortcode (status_code) und dem Antworttext (body) zu sehen.
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
Erlaubt es, nur den Antworttext (body) ohne unnötige Informationen zu sehen.
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 beim Bearbeiten der API-Anfrage ein Fehler aufgetreten ist (Antwortcode nicht 200). Beispielausgabe
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Nützliche Beispiele
Im Folgenden finden Sie Beispiele, in denen API-Aufrufe verwendet werden, die in der Version Management API 1.6 hinzugefügt wurden.
Lassen Sie uns zunächst die Funktionsweise der Aufrufe add-host und add-address-range. Angenommen, wir müssen alle IP-Adressen des Subnetzes 192.168.0.0/24 als Hostobjekte erstellen, deren letzter Oktett 5 ist, während alle anderen IP-Adressen als Adressbereichsobjekte aufgezeichnet werden. Dabei sollen das Subnetz und die Broadcast-Adresse ausgeschlossen werden.
Unten finden Sie ein Skript, das diese Aufgabe löst und 50 Hostobjekte und 51 Adressbereichsobjekte erstellt. Für diese Aufgabe sind 101 API-Aufrufe erforderlich (ohne den abschließenden Aufruf publish). Mit dem Modul timeit berechnen wir auch die Zeit für die 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'Zeit für die Ausführung der Batch-Anfrage: {stop - start} Sekunden')
In meiner Laborumgebung dauert die Ausführung dieses Skripts zwischen 30 und 50 Sekunden, abhängig von der Auslastung des Verwaltungsservers.
Sehen wir uns nun an, wie dieses Problem mit einem API-Aufruf gelöst werden kann add-objects-batch, dessen Unterstützung in der API-Version 1.6 hinzugefügt wurde. Dieser Aufruf ermöglicht es, in einem einzigen API-Request eine Vielzahl von Objekten zu erstellen. Dabei können es Objekte verschiedener Typen sein (zum Beispiel Hosts, Subnetze und Adressbereiche). So kann unsere Aufgabe im Rahmen eines einzigen API-Aufrufs gelöst werden.
Skript mit 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'Zeit für die Ausführung der Batch-Anfrage: {stop - start} Sekunden')
Die Ausführung dieses Skripts benötigt in meiner Laborumgebung zwischen 3 und 7 Sekunden, abhängig von der Belastung des Verwaltungsservers. Das bedeutet, dass der API-Aufruf vom Typ Batch im Durchschnitt bei 101 Objekten zehnmal schneller arbeitet. Bei einer größeren Anzahl von Objekten wird der Unterschied noch beeindruckender sein.
Sehen wir uns nun an, wie man mit set-objects-batch. Mit diesem API-Aufruf können wir massenhaft einen beliebigen Parameter ändern. Lassen Sie uns die erste Hälfte der Adressen aus dem vorherigen Beispiel (bis zur .124 des Hosts und auch für die Bereiche) in der Farbe sienna festlegen, während wir der zweiten Hälfte der Adressen die Farbe khaki zuweisen.
Änderung der Farbe der im vorherigen Beispiel erstellten Objekte
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")
Eine Vielzahl von Objekten kann in einem API-Aufruf mittels delete-objects-batch. Lassen Sie uns nun ein Beispiel ansehen, das alle zuvor über add-objects-batch.
Objekte mit Hilfe von delete-objects-batch löschen
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 Software-Releases von Check Point erscheinen, erhalten sofort API-Aufrufe. So wurden in R80.40 Features wie "Revert to revision" und "Smart Task" eingeführt, und für sie wurden umgehend entsprechende API-Aufrufe vorbereitet. Darüber hinaus erhält die gesamte Funktionalität beim Wechsel von Legacy-Konsolen in den Unified Policy-Modus ebenfalls API-Unterstützung. Beispielsweise war das lang erwartete Update in der Softwareversion R80.40 der Umzug der HTTPS-Inspektionsrichtlinie vom Legacy-Modus in den Unified Policy-Modus, und diese Funktionalität erhielt sofort API-Aufrufe. Hier ist ein Beispielcode, der in der obersten Position der HTTPS-Inspektionsrichtlinie eine Regel hinzufügt, die drei Kategorien (Gesundheit, Finanzen, staatliche Dienstleistungen) von der Inspektion ausschließt, deren Inspektion laut Gesetzgebung in mehreren Ländern verboten ist.
Regel zur HTTPS-Inspektion 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-Verwaltungsserver
Das Gleiche gilt für enthält Informationen darüber, wie man Skripte in Python direkt vom Verwaltungsserver ausführt. Dies kann praktisch sein, wenn Sie nicht in der Lage sind, sich von einem anderen Computer mit dem API-Server zu verbinden. Ich habe ein sechsminütiges Video aufgenommen, in dem ich die Installation des Moduls behandle. cpapi und die Besonderheiten beim Ausführen 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. Sicherheitsüberprüfung. Zu den Herausforderungen, mit denen ich konfrontiert war: In der Version Python 2.7 gab es die Funktion input, daher wird zur Verarbeitung von Benutzereingaben die Funktion raw_input. Ansonsten ist der Code derselbe wie beim Ausführen von anderen Maschinen, nur praktischer, da die Funktion login_as_root, verwendet wird, um nicht erneut den eigenen Benutzernamen, das Passwort und die IP-Adresse des Verwaltungsservers anzugeben.
Skript zur schnellen Konfiguration der Sicherheitsüberprüfung
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("Konnte den Fingerabdruck des Servers nicht abrufen - Überprüfen Sie die Konnektivität zum 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 einmalige Passwort für das Gateway (SIC) ein: ")
else:
print("Achtung! Ihr Passwort wird auf dem Bildschirm angezeigt!")
sic = raw_input("Geben Sie das einmalige Passwort für das Gateway (SIC) ein:")
version = raw_input("Geben Sie die Gateway-Version ein (z.B. 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 zum 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" : "Network", "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" : "Cleanup rule", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
if change_rule.success:
print("Die Bereinigungsvorschrift wurde erfolgreich geändert")
else:
print("Fehler beim Ändern der Bereinigungsvorschrift- {}".format(change_rule.error_message))
# 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 Bedrohungsverhinderung wurde installiert")
else:
print("Fehler beim Installieren der Richtlinie zur Bedrohungsverhinderung - {}".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 {} des Passwortwörterbuchs 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
{
"passwörter" : ["malware","bösartig","infiziert","Infiziert"],
"sätze" : ["passwort","Passwort","Pass","pass","codigo","key","pwd","пароль","Пароль","Kлюч","ключ","шифр","Шифр"]
}
Fazit
Dieser Artikel behandelt nur die grundlegenden Funktionen der Arbeit Python SDK und des Moduls cpapi(wie Sie wahrscheinlich 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 ausgeschlossen, dass Sie den Wunsch entwickeln, es mit Ihren eigenen Klassen, Funktionen, Methoden und Variablen zu ergänzen. Sie können immer Ihre Entwicklungen teilen und andere Skripte für Check Point im Abschnitt in der Gemeinschaft , die sowohl Entwickler von Produkten als auch Benutzer vereint.
Viel Spaß beim Programmieren und danke, dass Sie bis zum Ende gelesen haben!
Quelle: habr.com
