ProHoster > Blog > Administratioun > Vereinfachung vun der Check Point API mat der Python SDK

Vereinfachung vun der Check Point API mat der Python SDK

Vereinfachung vun der Check Point API mat der Python SDKDĂ©i voll Kraaft vun der Interaktioun mat APIen gĂ«tt opgedeckt wann se zesumme mam Programmcode benotzt ginn, wann et mĂ©iglech gĂ«tt dynamesch API Ufroen an Tools ze generĂ©ieren fir API Äntwerten ze analysĂ©ieren. Et bleift awer nach Ă«mmer onmerkbar Python Software EntwĂ©cklung Kit (nodrĂ©iglech als Python SDK bezeechent) fir Check Point Management API, awer Ă«msoss. Et vereinfacht d'Liewen vun EntwĂ©ckler an Automatisatiounsbegeeschterten wesentlech. Python huet zĂ«nter kuerzem enorm PopularitĂ©it gewonnen an ech hu beschloss d'LĂŒck ze fĂ«llen an d'Haaptfeatures ze iwwerprĂ©iwen. Check Point API Python EntwĂ©cklung Kit. DĂ«sen Artikel dĂ©ngt als exzellent ErgĂ€nzung zu engem aneren Artikel iwwer HabrĂ© Check Point R80.10 API. Gestioun iwwer CLI, Scripten a mĂ©i. Mir kucken wĂ©i Dir Scripte schreift mat der Python SDK a kucke mĂ©i no op dĂ©i nei Management API FunktionalitĂ©it an der Versioun 1.6 (Ă«nnerstĂ«tzt ab R80.40). Fir den Artikel ze verstoen, braucht Dir Basiskenntnisser fir mat APIen a Python ze schaffen.

Check Point ass aktiv d'API entwéckelt an am Moment sinn déi folgend verëffentlecht ginn:

De Python SDK ënnerstëtzt de Moment nëmmen Interaktioun mat der Management API an Gaia API. Mir kucken op déi wichtegst Klassen, Methoden a Variabelen an dësem Modul.

Vereinfachung vun der Check Point API mat der Python SDK

Installatioun vum Modul

Modul cpapi installĂ©iert sĂ©ier an einfach aus offiziell Check Point Repository op github mat der HĂ«llef vun Pip. DetaillĂ©iert Installatiounsinstruktiounen sinn verfĂŒgbar an VIRLIESEN.md. DĂ«se Modul ass ugepasst fir mat Python Versiounen 2.7 an 3.7 ze schaffen. An dĂ«sem Artikel ginn Beispiller mat Python 3.7. WĂ©i och Ă«mmer, de Python SDK kann direkt vum Check Point Management Server (Smart Management) lafen, awer si Ă«nnerstĂ«tzen nĂ«mmen Python 2.7, sou datt de leschte Sektioun Code fir Versioun 2.7 gĂ«tt. Direkt no der Installatioun vum Modul, ech recommandĂ©ieren d'Beispiller an de Verzeichnisser ze kucken Beispiller_python2 Đž Beispiller_python3.

Schrëtt;

Fir datt mir fÀeg sinn mat de Komponenten vum cpapi Modul ze schaffen, musse mir aus dem Modul importéieren cpapi op d'mannst zwee erfuerderlech Klassen:

APIClient Đž APIClientArgs

from cpapi import APIClient, APIClientArgs

Klass APIClientArgs ass verantwortlech fir Verbindungsparameter zum API Server, an der Klass APIClient ass verantwortlech fir d'Interaktioun mat der API.

Bestëmmung vun Verbindung Parameteren

Fir verschidde Parameteren ze definéieren fir mat der API ze verbannen, musst Dir eng Instanz vun der Klass erstellen APIClientArgs. Prinzipiell sinn seng Parameteren virdefinéiert a wann Dir de Skript um Kontrollserver leeft, brauche se net spezifizéiert ze ginn.

client_args = APIClientArgs()

Awer wann Dir op engem Drëtt-Partei-Host leeft, musst Dir op d'mannst d'IP Adress oder den Hostnumm vum API Server spezifizéieren (och bekannt als de Managementserver). Am Beispill hei ënnen definéiere mir de Serververbindungsparameter an ginn et d'IP Adress vum Managementserver als String.

client_args = APIClientArgs(server='192.168.47.241')

Loosst eis all d'Parameteren an hir StandardwÀerter kucken, déi benotzt kënne ginn wann Dir mam API Server verbënnt:

Argumenter vun der __init__ Method vun der APIClientArgs Klass

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 = context

Ech gleewen datt d'Argumenter, déi an Instanzen vun der APIClientArgs Klass benotzt kënne ginn, intuitiv fir Check Point Administrateuren sinn a keng zousÀtzlech Kommentarer erfuerderen.

Verbindung iwwer APIClient a Kontextmanager

Klass APIClient De bequemste Wee fir et ze benotzen ass duerch de Kontextmanager. Alles wat un eng Instanz vun der APIClient Klass weidergeleet muss ginn ass d'Verbindungsparameter déi am virege Schrëtt definéiert goufen.

with APIClient(client_args) as client:

De Kontextmanager wÀert net automatesch e Login-Uruff un den API-Server maachen, awer e mécht e Logout-Uruff wann se erausgeet. Wann aus iergendengem Grond de Logout net erfuerderlech ass nodeems Dir mat API-Uriff geschafft hutt, musst Dir ufÀnken ze schaffen ouni de Kontextmanager ze benotzen:

client = APIClient(clieng_args)

Iwwerpréift d'Verbindung

Deen einfachste Wee fir ze kontrolléieren ob d'Verbindung de spezifizéierte Parameteren entsprécht ass d'Methode check_fingerprint. Wann d'Verifizéierung vun der sha1 Hash Zomm fir de Fangerofdrock vum Server API Zertifikat feelt (d'Methode ass zréck falsch), da gëtt dëst normalerweis duerch Verbindungsproblemer verursaacht a mir kënnen d'Ausféierung vum Programm stoppen (oder dem Benotzer d'Méiglechkeet ginn d'Verbindungsdaten ze korrigéieren):

    if client.check_fingerprint() is False:
        print("Could not get the server's fingerprint - Check connectivity with the server.")
        exit(1)

Maacht weg datt an Zukunft d'Klass APIClient wÀert all API Uruff (Methoden api_call О api_query, Mir schwÀtzen iwwer hinnen e bësse méi wÀit) sha1 Fangerofdrock Zertifikat op der API Server. Awer wann, wann Dir de sha1 Fangerofdrock vum API Server Zertifikat iwwerpréift, e Feeler festgestallt gëtt (den Zertifika ass onbekannt oder gouf geÀnnert), d'Method check_fingerprint gëtt d'Méiglechkeet fir eng Foto / Ànneren Informatiounen doriwwer op der lokal Maschinn automatesch. Dëse Scheck kann komplett ausgeschalt ginn (awer dëst kann nëmme recommandéiert ginn wann Skripte um API Server selwer lafen, wann Dir mat 127.0.0.1 verbënnt), mam APIClientArgs Argument - onsécher_auto_akzeptéieren (kuckt méi iwwer APIClientArgs fréier am "Verbindungsparameter definéieren").

client_args = APIClientArgs(unsafe_auto_accept=True)

Login op API Server

У APIClient et gi sou vill wéi 3 Methoden fir an den API Server aloggen, a jidderee vun hinnen versteet d'Bedeitung sid(Session-ID), déi automatesch an all spéider API Uruff am Header benotzt gëtt (den Numm am Header vun dësem Parameter ass X-chkp-sid), also ass et net néideg dëse Parameter weider ze veraarbecht.

Login Method

Optioun mat Login a Passwuert (am Beispill ginn de Benotzernumm Admin a Passwuert 1q2w3e als positional Argumenter iwwerginn):

     login = client.login('admin', '1q2w3e')

ZousĂ€tzlech optional Parameteren sinn och verfĂŒgbar an der Loginmethod hei sinn hir Nimm an StandardwĂ€erter:

continue_last_session=False, domain=None, read_only=False, payload=None

Login_with_api_key Method

Optioun mat engem API Schlëssel (ënnerstëtzt vun der Gestioun Versioun R80.40 / Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" Dëst ass den API SchlësselwÀert fir ee vun de Benotzer um Managementserver mat der API Schlëssel Autorisatiounsmethod):

     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')

An der Method login_with_api_key déi selwecht fakultativ Parameteren sinn disponibel wéi an der Method Aloggen.

Login_as_root Method

Optioun fir op eng lokal Maschinn mat engem API Server ze loggen:

     login = client.login_as_root()

Et ginn nĂ«mmen zwee fakultativ Parameteren fir dĂ«s Method verfĂŒgbar:

domain=None, payload=None

A schliisslech rifft d'API sech

Mir hunn zwou MĂ©iglechkeeten fir API Uriff duerch Methoden ze maachen api_call Đž api_query. Loosst eis erausfannen wat den Ënnerscheed tĂ«scht hinnen ass.

api_call

Dës Method ass applicabel fir all Uruff. Mir mussen de leschten Deel fir den API Uruff an Notzlaascht am Ufro Kierper passéieren wann néideg. Wann Notzlaascht eidel ass, da kann et guer net iwwerdroe ginn:

api_versions = client.api_call('show-api-versions')

Ausgang fir dës Ufro ënner dem Schnëtt:

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'})

Ausgang fir dës Ufro ënner dem Schnëtt:

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

Loosst mech direkt reservĂ©ieren datt dĂ«s Method nĂ«mme fir Uruff applicabel ass, deenen hir Ausgang Offset implizĂ©iert. Sou eng Inferenz geschitt wann et eng grouss QuantitĂ©it un Informatioun enthĂ€lt oder kann enthalen. Zum Beispill kann dĂ«st eng Ufro fir eng LĂ«scht vun all erstallt Hostobjekter um Managementserver sinn. Fir esou Ufroe gĂ«tt d'API eng LĂ«scht vun 50 Objeten als Standard zrĂ©ck (Dir kĂ«nnt d'Limite op 500 Objeten an der Äntwert erhĂ©ijen). A fir d'Informatioun net e puer Mol ze zĂ©ien, den Offsetparameter an der API Ufro z'Ă€nneren, gĂ«tt et eng api_query Method dĂ©i dĂ«st automatesch funktionnĂ©iert. Beispiller vun Uruff wou dĂ«s Method gebraucht gĂ«tt: Show-Sessiounen, Show-Hosten, Show-Netzwierker, Show-Wildcards, Show-Gruppen, Show-Adress-Gamme, Show-Simple-Gateways, Show-Simple-Clusters, Show-Access-Rollen, Show-Vertrauens-Clienten, weisen-Packagen. TatsĂ€chlech gesi mir Plural Wierder am Numm vun dĂ«sen API Uriff, sou datt dĂ«s Uriff mĂ©i einfach sinn ze handhaben duerch api_query

show_hosts = client.api_query('show-hosts')

Ausgang fir dës Ufro ënner dem Schnëtt:

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
})

Veraarbechtung vun de Resultater vun API Uriff

Duerno kënnt Dir d'Variabelen a Methode vun der Klass benotzen APIResponse(souwuel am Kontext Manager an ausserhalb). An der Klass APIResponse 4 Methoden a 5 Variablen si virdefinéiert, mir wÀerte méi detailléiert op déi wichtegst ophalen.

Vereinfachung vun der Check Point API mat der Python SDK

SuccĂšs

Fir unzefÀnken, wier et eng gutt Iddi fir sécher ze stellen datt den API Uruff erfollegrÀich war an e Resultat zréckginn. Et gëtt eng Method fir dëst SuccÚs:

In [49]: api_versions.success                                                   
Out[49]: True

Gitt True zrĂ©ck wann den API Uruff erfollegrĂ€ich war (Äntwert Code - 200) a False wann net erfollegrĂ€ich (all aner Äntwert Code). Et ass bequem direkt no engem API Uruff ze benotzen fir verschidden Informatioun ofhĂ€ngeg vum Äntwertcode ze weisen.

if api_ver.success: 
    print(api_versions.data) 
else: 
    print(api_versions.err_message)

statuscode

Gitt den Äntwertcode zrĂ©ck nodeems en API Uruff gemaach gouf.

In [62]: api_versions.status_code                                               
Out[62]: 400

MĂ©iglech Äntwert Coden: 200,400,401,403,404,409,500,501.

set_success_status

An dësem Fall kann et néideg sinn de WÀert vum Erfollegsstatus z'Ànneren. Technesch kënnt Dir alles do setzen, och e regelméisseg String. Awer e richtegt Beispill wier dëse Parameter op False zréckgesat ënner bestëmmte begleedende Bedéngungen. Hei ënnen oppassen op d'Beispill wann et Aufgaben um Managementserver lafen, awer mir wÀerten dës Ufro als net erfollegrÀich betruechten (mir setzen d'Erfollegsvariabel op falsch, trotz der Tatsaach datt den API Uruff erfollegrÀich war an de Code 200 zréckginn).

for task in task_result.data["tasks"]:
    if task["status"] == "failed" or task["status"] == "partially succeeded":
        task_result.set_success_status(False)
        break

Äntwert ()

D'Äntwertmethod erlaabt Iech d'Wörterbuch mam Äntwertcode (status_code) an dem Äntwertkierper (Kierper) ze gesinn.

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']}}

Donnéeën

Erlaabt Iech nĂ«mmen de Kierper vun der Äntwert (Kierper) ouni onnĂ©ideg Informatioun ze gesinn.

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

DĂ«s Informatioun ass nĂ«mme verfĂŒgbar wann e Feeler geschitt ass beim Veraarbechtung vun der API Ufro (Äntwert Code Net 200). Beispill Ausgang

In [107]: api_versions.error_message                                            
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'

NĂ«tzlech Beispiller

DĂ©i folgend sinn Beispiller dĂ©i d'API Uruff benotzen dĂ©i am Management API 1.6 bĂ€igefĂŒĂŒgt goufen.

Als éischt kucke mer wéi d'Uriff funktionnéieren add-Host О add-address-range. Loosst eis soen datt mir all IP Adressen vum Subnet 192.168.0.0/24 erstellen, dee leschte Oktett ass 5, als Objete vum Hosttyp, an all aner IP Adressen als Objete vum Adressbereichtyp schreiwen. An dësem Fall, ausgeschloss d'Subnet Adress an d'Emissiounsadress.

Also, hei Ă«nnen ass e Skript deen dĂ«se Problem lĂ©ist an 50 Objete vum Hosttyp an 51 Objete vum Adressbereichtyp erstellt. Fir de Problem ze lĂ©isen, sinn 101 API Uriff erfuerderlech (net zielt de finalen VerĂ«ffentlechungsruff). Och mam timeit Modul berechene mir d'ZĂ€it dĂ©i et brauch fir de Skript auszefĂ©ieren bis d'Ännerunge publizĂ©iert ginn.

Skript mat Add-Host an 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')

A mengem Labo-Ëmfeld dauert dĂ«st Skript tĂ«scht 30 an 50 Sekonnen fir auszefĂ©ieren, ofhĂ€ngeg vun der Belaaschtung vum Managementserver.

Loosst eis elo kucken wĂ©i een dee selwechte Problem mat engem API Uruff lĂ©ist add-objects-batch, ËnnerstĂ«tzung fir dĂ©i an der API Versioun 1.6 bĂ€igefĂŒĂŒgt gouf. DĂ«sen Uruff erlaabt Iech vill Objeten glĂ€ichzĂ€iteg an enger API Ufro ze kreĂ©ieren. Ausserdeem kĂ«nnen dĂ«s Objete vu verschiddenen Aarte sinn (zum Beispill Hosten, Ënnernetzer an Adressbereich). Sou kann eis Aufgab am Kader vun engem API Uruff gelĂ©ist ginn.

Skript mat 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')

A laafen dĂ«sem Skript a mengem Labo Ëmfeld dauert aus 3 ze 7 Sekonnen, jee no der Laascht op der Gestioun Server. Dat ass, am DuerchschnĂ«tt, op 101 API Objekter, leeft e Batch Typ Uruff 10 Mol mĂ©i sĂ©ier. Op enger mĂ©i grousser Zuel vun Objeten wĂ€ert den Ënnerscheed nach mĂ©i beandrockend sinn.

Loosst eis elo kucken wéi een mat schafft Set-Objete-Batch. Mat dësem API Uruff kënne mir all Parameter bulk Ànneren. Loosst eis déi éischt Halschent vun den Adressen aus dem fréiere Beispill (bis zu .124 Hosten, a BerÀicher och) op d'Faarf Sienna setzen, an d'Faarf khaki op déi zweet Halschent vun den Adressen zouginn.

Ännert d'Faarf vun den Objeten, dĂ©i am virege Beispill erstallt goufen

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")

Dir kënnt e puer Objeten an engem API Uruff lÀschen lÀschen-Objete-Batch. Loosst eis elo e Code Beispill kucken dat all Hosten lÀscht déi virdru geschaf goufen add-objects-batch.

D'Objete lÀschen andeems Dir delete-objects-batch benotzt

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)

All Funktiounen, dĂ©i an nei VerĂ«ffentlechunge vun der Check Point Software erschĂ©ngen, krĂ©ien direkt API Uriff. Also, an R80.40 sou "Features" wĂ©i Revert to revision an Smart Task erschĂ©ngen, an entspriechend API-Uriff goufen direkt fir si virbereet. Ausserdeem kritt all FunktionalitĂ©it beim PlĂ«nneren vun Legacy Konsolen op Unified Policy Modus och API ËnnerstĂ«tzung. Zum Beispill war de laang erwaarde Update an der Softwareversioun R80.40 d'Bewegung vun der HTTPS Inspektiounspolitik vum Legacy Modus op Unified Policy Modus, an dĂ«s FunktionalitĂ©it krut direkt API Uriff. Hei ass e Beispill vu Code, deen eng Regel op d'Toppositioun vun der HTTPS Inspektiounspolitik bĂ€idrĂ©it, dĂ©i 3 Kategorien vun der Inspektioun ausschlĂ©isst (Gesondheet, Finanzen, Regierungsservicer), dĂ©i vun der Inspektioun am Aklang mat de Gesetzer vun enger Zuel vu LĂ€nner verbueden sinn.

FĂŒĂŒgt eng Regel un der HTTPS Inspektiounspolitik

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")

Lafen Python Scripten op der Check Point Gestioun Server

Alles ass d'selwecht VIRLIESEN.md enthĂ€lt Informatiounen iwwer wĂ©i Python Scripten direkt vum Kontrollserver lafen. DĂ«st kann praktesch sinn wann Dir net fĂ€eg sidd mam API Server vun enger anerer Maschinn ze verbannen. Ech hunn e sechs Minutte Video opgeholl, an deem ech de Modul installĂ©iere kucken cpapi an Fonctiounen vun Lafen Python Scripten op der Kontroll Server. Als Beispill gĂ«tt e Skript ausgefĂŒhrt deen d'Konfiguratioun vun engem neie Paart fir eng Aufgab wĂ©i Netzwierkaudit automatisĂ©iert SĂ©cherheet CheckUp. Ënnert de Fonctiounen dĂ©i ech hu misse kĂ«mmeren: d'Funktioun ass nach net am Python 2.7 opgetaucht Input ginn, also fir d'Informatioun ze veraarbecht, dĂ©i de Benotzer agitt, gĂ«tt eng Funktioun benotzt raw_input. Soss ass de Code d'selwecht wĂ©i fir d'Start vun anere Maschinnen, nĂ«mmen et ass mĂ©i praktesch d'Funktioun ze benotzen login_as_root, fir Ären eegene Benotzernumm, Passwuert an IP Adress vum Managementserver net erĂ«m ze spezifizĂ©ieren.

Spillt Video

Skript fir séier Konfiguratioun vu SécherheetscheckUp

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()

E Beispill Fichier mat engem Passwuert Wierderbuch additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","ĐżĐ°Ń€ĐŸĐ»ŃŒ","ĐŸĐ°Ń€ĐŸĐ»ŃŒ","Ключ","Đșлюч","шофр","йофр"]
}

Konklusioun

DĂ«sen Artikel Ă«nnersicht nĂ«mmen d'BasismĂ©iglechkeeten vun der Aarbecht Python SDK an Modul cpapi(wĂ©i Dir vlĂ€icht scho scho scho scho scho geduecht hutt, dat sinn eigentlech Synonyme), an andeems Dir de Code an dĂ«sem Modul studĂ©iert, entdeckt Dir nach mĂ©i MĂ©iglechkeete fir domat ze schaffen. Et ass mĂ©iglech datt Dir et wĂ«llt ergĂ€nzen mat Ären eegene Klassen, Funktiounen, Methoden a Variablen. Dir kĂ«nnt Ă«mmer Är Aarbecht deelen an aner Skripte fir Check Point an der Rubrik kucken CodeHub an der Gemeng CheckMates, dĂ©i souwuel ProduktentwĂ©ckler a Benotzer zesummebrĂ©ngen.

Glécklech Kodéierung a Merci fir d'Liesen bis zum Schluss!

Source: will.com

Kaaft zouverlĂ€sseg Hosting fir Site mat DDoS Schutz, VPS VDS Server đŸ”„ Kaaft zouverlĂ©issegt WebsĂ€ithosting mat DDoS-Schutz, VPS VDS Server | ProHoster