🥇Lihtsustame Check Point API-d Python SDK abil

Kogu API jõud avaldub programmkoodi kooskasutamisel, kui tekivad võimalused dünaamiliselt luua API päringuid ja tööriistu API vastuste analüüsimiseks. Siiski jääb Python Software Development Kit (edasi – Python SDK) jaoks Check Point Management API, mis on kahetusväärne. See oluliselt lihtsustab arendajate ja automatiseerimisarmastajate elu. Viimasel ajal on Python saavutanud tohutut populaarsust ja otsustasin sulgeda vahe ja teha ülevaate peamistest võimalustest Check Point API Python Development Kit. See artikkel on suurepärane täienduseks teisele artiklile Habr's Check Point R80.10 API. Halduse CLI, skriptid ja muud. Me vaatame, kuidas kirjutada skripte Python SDK abil ja peatume põhjalikumalt Management API uuel funktsionaalsusel versioonis 1.6 (toetatakse alates R80.40). Artikli mõistmiseks on vajalikud põhiteadmised API ja Python'i töö kohta.

Check Point arendab aktiivselt API-d ja praeguseks on ilmunud:

Check Point Management API (praegune versioon 1.6) – töö haldusserveriga API kaudu (ja võimalus täita skripte haldusserveri all olevatesse väravatesse)
Check Point GAIA API (praegune versioon 1.4) – töö turvaväravatega
Threat Prevention API 1.0 – töö Check Point'i pilveteras kooskonnas
Identity Awareness API – töö Identity Awareness plaadi abil väravates
Security Management Portal API – töö SMB väravate haldusportaaliga (Lugemist SMB väravatest)
IoT API – suhtlemine IoT kontrolleritega
CloudGuard Connect API – töö CloudGuard Connect (SD-WAN turvalahendus)
Dome9 API – töö Dome9

Python SDK toetab praeguseks ainult Management API ja Gaia API. Vaatame kõige olulisemaid klasse, meetodeid ja muutujaid selles moodulis.

Moodi installimine

Moodul cpapi installitakse kiiresti ja lihtsalt Check Point'i ametlikust repostiitoriumist github'is kasutades pip. Üksikasjalik installatsioonijuhend on README.md. See moodul on kohandatud tööks Python versioonidega 2.7 ja 3.7. Käesolevas artiklis esitatakse näiteid kasutades Python 3.7. Siiski on Python SDK võimalik otse Check Point'i haldusserverist (Smart Management) käitada, kuid seal toetatakse vaid Python 2.7 versiooni, seega viimas sekretis on toomatud kood versioonile 2.7. Kohe pärast mooduli installimist soovitan vaadata näiteid kaustades examples_python2 ja examples_python3.

Esimene samm

Ettevalmistamiseks, et saaksime töötada cpapi mooduli komponentidega, tuleb importida moodulist cpapi kaks vajalikku klassi:

APIClient ja APIClientArgs

from cpapi import APIClient, APIClientArgs

Klass APIClientArgs vastutab API serverisse ühenduse loomise parameetrite eest, samas kui klass APIClient vastutab API-ga suhtlemise eest.

Määrame ühenduse parameetrid

Et määrata erinevaid ühenduse parameetreid API-ga, peate looma klassi APIClientArgs. Üldiselt on tema parameetrid eeldefineeritud ja skripti käivitamisel haldusserveris ei pea neid määrama.

client_args = APIClientArgs()

Kuid kolmandal hostil käivitamisel tuleb määrata vähemalt API serveri IP-aadress või hosti nimi (haldusserver). Allolevas näites määrame ühenduse parameetri server ja omistame sellele stringina haldusserveri IP-aadressi.

client_args = APIClientArgs(server='192.168.47.241')

Vaadakem kõiki parameetreid ja nende vaikimisi väärtusi, mida saab kasutada API serveriga ühenduse loomiseks:

APIClientArgs klassi __init__ meetodi argumendid

class APIClientArgs:
    """
    See klass annab argumente APIClient konfiguratsiooniks.
    Kõik argumendid on konfigureeritud oma vaikimisi väärtustega.
    """

    # port on vaikimisi määratud None-ks, kuid see asendatakse 443-ga, kui seda ei määrata
    # konteksti võimalikud väärtused - web_api (vaikimisi) või 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
        # haldusserveri sõrmejälg
        self.fingerprint = fingerprint
        # sessiooni-id.
        self.sid = sid
        # haldusserveri nimi või IP-aadress
        self.server = server
        # silumisaste
        self.http_debug_level = http_debug_level
        # massiiv kõigi API kutsungitega (silumiseks)
        self.api_calls = api_calls if api_calls else []
        # silumisdokumendi nimi. Kui see jääb tühjaks, ei salvestata silumistandmeid kettale.
        self.debug_file = debug_file
        # HTTP proxy serveri aadress (ilma "http://")
        self.proxy_host = proxy_host
        # HTTP proxy port
        self.proxy_port = proxy_port
        # Haldusserveri API versioon
        self.api_version = api_version
        # Näitab, et klient ei peaks kontrollima serveri sertifikaati
        self.unsafe = unsafe
        # Näitab, et klient peaks automaatselt aktsepteerima ja salvestama serveri sertifikaadi
        self.unsafe_auto_accept = unsafe_auto_accept
        # Kliendi kasutamise kontekst - vaikimisi web_api
        self.context = context

Eeldan, et APIClientArgs klassi eksemplaride argumendid on Check Pointi administraatoritele intuitiivselt arusaadavad ja ei vajada lisakommentaare.

Ühendume APIClienti ja konteksti halduriga

Klass APIClient Kõige mugavam on kasutada konteksti haldajat. Kõik, mis tuleb APIClient klassi eksemplarile edastada, on ühenduse parameetrid, mis määrati eelmises etapis.

with APIClient(client_args) as client:

Konteksti haldaja ei tee automaatselt API serveri sisselogimist, kuid ta teeb väljaregistreerimise väljumisel. Kui mingil põhjusel ei ole pärast API kutsete kasutamist väljaregistreerimine vajalik, tuleks alustada töötamist ilma konteksti haldajata:

client = APIClient(client_args)

Ühenduse kontrollimine

Lihtsaim viis kontrollida, kas ühendus on antud parameetrite alusel olemas, on kasutada meetodit check_fingerprint. Kui sha1 kontrollsumma API serveri fingerprint sertifikaadi jaoks ebaõnnestub (meetod tagastas Vale), siis on see tavaliselt põhjustatud ühenduse probleemidest ja me saame peatada programmi toimimise (või anda kasutajale võimaluse parandada ühendusandmeid):

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

Pange tähele, et edaspidi kontrollib klass APIClient iga API kutse puhul (meetodites api_call ja api_query, millest räägitakse pisut hiljem) sha1 fingerprint sertifikaati API serveris. Kui sha1 fingerprint API serveri sertifikaadi kontrollimisel ilmneb viga (sertifikaat on tundmatu või on muudetud), siis meetod check_fingerprint pakub võimalust lisada/muuta teavet selle kohta kohalikus masinas automaatselt. Selle kontrolli saab täielikult keelata (kuid seda soovitatakse ainult juhul, kui skripte käitatakse otse API serveris, ühendudes 127.0.0.1), kasutades APIClientArgs argumenti — unsafe_auto_accept (vt rohkem APIClientArgs kohta varem peatükis "Määrame ühenduse parameetrid").

client_args = APIClientArgs(unsafe_auto_accept=True)

Sisselogimine API serverisse

Uus APIClient on kokku 3 meetodit API serverisse sisselogimiseks ja igaüks neist salvestab väärtuse sid(sessioon-ID), mida kasutatakse automaatselt igas järgnevas API kutses päises (selle parameetri nimi päises on X-chkp-sid), nii et seda parameetrit pole vaja täiendavalt töödelda.

Sisselogimise meetod

Variant sisselogimiseks kasutades kasutajanime ja parooli (näites on kasutajanimi admin ja parool 1q2w3e antud positsiooniliste argumentidena):

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

Sisselogimise meetodil on ka täiendavad valikulised parameetrid, toon välja nende nimed ja vaikeseaded:

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

login_with_api_key meetod

API võtme kasutamise variant (toetatakse alates versioonist R80.40 / Management API v1.6, «3TsbPJ8ZKjaJGvFyoFqHFA==» see on API võtme väärtus ühe kasutaja jaoks haldusserveris, kasutades API key autoriseerimise meetodit):

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

Meetodis login_with_api_key on sama valikuline parameetrite hulk nagu meetodis login.

login_as_root meetod

API serveriga kohalikult sisselogimise variant:

     login = client.login_as_root()

Selle meetodi jaoks on saadaval vaid kaks valikulist parameetrit:

domain=None, payload=None

Ja lõpuks ise API kutsed

Meil on kaks varianti API kutsumiste tegemiseks meetodite kaudu. api_call ja api_queryUurime, mis vahel erinevus on.

api_call

See meetod sobib igasuguste kutsude tegemiseks. Me peame edastama viimase osa API kutsest ja payload'i vajadusel päringu kehas. Kui payload on tühi, siis ei ole seda üldse vaja edastada:

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

Selle päringu väljund allpool:

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

Selle päringu väljund allpool:

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

Esiteks, see meetod sobib ainult päringute jaoks, mille väljund eeldab offset'i. Selline väljund toimub juhul, kui see sisaldab või võib sisaldada suurt hulka teavet. Näiteks võib see olla päring kõigi loodud host-tüüpi objektide loendi saamiseks haldusserveris. Selliste päringute puhul tagastab API vaikimisi 50 objekti loendi (seda limiiti on võimalik suurendada kuni 500 objekti kohta vastuses). Ja et mitte teavet mitu korda küsida, muutes päringu offset parameetrit, on olemas meetod api_query, mis teeb selle töö automaatselt. Näidised väljakutsetest, kus vajalik see meetod: 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. Tegelikult näeme nende API väljakutsete nimedes mitmuse vormi sõnu, seega on neid väljakutseid lihtsam töödelda läbi api_query

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

Selle päringu väljund allpool:

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

API kutsungite tulemuste töötlemine

Pärast seda on võimalik kasutada klassi muutujaid ja meetodeid APIResponse(nii konteksti halduri sees kui väljaspool). Klassil APIResponse on määratletud 4 meetodit ja 5 muutujat, millest kõige olulisematel peatume lähemalt.

success

Esmalt oleks hea veenduda, et API kutsung läks läbi ja tagastas tulemuse. Selleks on olemas meetod success:

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

Tagastab True, kui API kutsung läks edukalt läbi (vastuskood — 200) ja False, kui mitte (igal muul vastuskoodil). Mugav kasutada kohe pärast API kutsungit, et vastuskoodi järgi erinevat teavet välja printida.

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

statuscode

Tagastab vastuskoodi pärast API kutsungi täitmist.

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

Võimalikud vastuskoodid: 200,400,401,403,404,409,500,501.

set_success_status

Samas võib olla vajalik muuta status success väärtust. Tehniliselt on sinna võimalik paigutada mida iganes, isegi tavaline string. Kuid reaalse näitena võib olla selle parameetri seadmine False'ks teatud kaasnevate tingimuste korral. Allpool on näide, kus on ülesanded, mida täidetakse juhtimisseerveris, kuid me peame seda päringut ebaõnnestunuks (seame muutuja success) Vale, vaatamata sellele, et API kutsumine oli edukas ja tagastas koodi 200).

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

response()

Metod response võimaldab vaadata vastuse sõnastikku (status_code) ja vastuse keha (body).

In [94]: api_versions.response()                                                
Out[94]: 
{'status_code': 200,
 'data': {'current-version': '1.6',
  'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}

data

Lubab näha ainult vastuse keha (body) ilma liigsest teabest.

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

See teave on saadaval ainult siis, kui API päringu töötlemisel tekkis viga (vastuskood ei 200). Näide väljundist

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

Kasulikud näited

Allpool on loetletud näited, kus kasutatakse API kutsumisi, mis on lisatud versioonile Management API 1.6.

Alustame API kutsumise töötluse uurimist add-host ja add-address-range. Oletame, et peame looma hosti tüüpi objektid kõikidele alamvõrgu 192.168.0.0/24 IP-aadressidele, mille viimane oktet on 5, ja kõik ülejäänud IP-aadressid jäävad aadressivahemiku objektideks. Samuti tuleb välistada alamvõrgu aadress ja laiaulatusliku aadress.

Nii et allpool on skript, milles lahendatakse antud ülesanne ja luuakse 50 hosti tüüpi objekti ja 51 aadressivahemiku objekti. Ülesande lahendamiseks on vajalik 101 API kutset (ilma viimase publish kutseta). Samuti mõõdame timeit mooduli abil skripti täitmise aega kuni muudatuste avaldamiseni.

Skript add-host ja add-address-range kasutamisega

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

Minu laboratoorse keskkonna jaoks kulub selle skripti täitmiseks 30 kuni 50 sekundit, sõltuvalt haldussüsteemi koormusest.

Nüüd vaatame, kuidas sama ülesannet lahendada API kõne abil add-objects-batch, mille tugi on lisatud API versioonis 1.6. See kõne võimaldab ühe API päringu abil luua korraga mitmeid objekte. Need võivad olla erinevat tüüpi objektid (näiteks hostid, alavõrgud ja aadressivahemikud). Seega saame meie ülesande lahendada ühe API kõne raames.

Skript, mis kasutab 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')

Ja selle skripti täitmine minu laboratoorse keskkonna jaoks võtab 3 kuni 7 sekundit, sõltuvalt haldussüsteemi koormusest. See tähendab, et keskmiselt toimib 101 objekti API kõne tüübiga batch 10 korda kiiremini. Suurema objekti arvu korral on erinevus veelgi muljetavaldavam.

Nüüd vaatame, kuidas töötada set-objects-batch. Selle API kõne abil saame suurte muudatuste kaudu muuta igat parameetrit. Seadistame näiteks eelmise näite esimeses pooles (hostid kuni .124, samuti vahemikud) värvi sienna ja teises pooles määrame värvi khaki.

Objektide värvi muutmine, mis loodi eelnevas näites

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

Mitme objekti kustutamine ühes API-kutses on võimalik delete-objects-batch. Vaatame nüüd koodinäidet, mis kustutab kõik varem loodud hostid add-objects-batch.

Objektide kustutamine delete-objects-batch abil

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)

Kõik funktsioonid, mis ilmuvad uusimates Check Pointi tarkvaraversioonides, saavad kohe ka API-kutsed. Näiteks R80.40 toob sellised „funktsioonid“ nagu Revert to revision ja Smart Task, ning neile on kohe valmistatud vastavad API-kutsed. Veelgi enam, kogu funktsionaalsus, mis on seotud üleminekuga Legacy konsoolidelt Unified Policy režiimile, saab samuti API toe. Näiteks oli kauaoodatud uuendus versioonis R80.40 HTTPS Inspection poliitika üleviimine Legacy režiimist Unified Policy režiimi ja see funktsionaalsus sai kohe API kutsed. Siin on koodinäide, mis lisab HTTPS Inspection poliitika kõrgeimale positsioonile reegli, mis välistab inspekteerimisest 3 kategooriat (Tervis, Finants, Riiklikud teenused), mida on mitmesuguste seaduste kohaselt keelatud inspekteerida.

Lisa reegel HTTPS Inspection poliitikasse

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

data = {
  "layer" : "Default Layer",
  "position" : "top",
  "name" : "Legal Requirements",
  "action": "bypass",
  "site-category": ["Health", "Government / Military", "Financial Services"]
}

with APIClient(client_args) as client: 
     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
     add_https_rule = client.api_call("add-https-rule", data)
     publish = client.api_call("publish")

Python skriptide käivitamine Check Pointi haldusserveris

Kõik on samas README.md sisaldab teavet, kuidas käivitada Python skripte otse haldusserverist. See võib olla mugav, kui teil pole võimalust ühendada API serveriga teiselt masinalt. Olen salvestanud kuue minuti pikkuse video, kus käsitlen mooduli cpapi ja Python skriptide käivitamise eripära haldusserveris. Näiteks käivitub skript, mis automatiseerib uue lünga seadistamist selliseks ülesandeks nagu võrgu audit Security CheckUp. Kohtasin eripära, millega pidin silmitsi seisma: versioonis Python 2.7 ei olnud veel funktsiooni input, seega kasutatakse kasutaja sisendi töötlemiseks funktsiooni raw_input. Ülejäänud osas on kood sama, nagu käivitamisel teistelt masinatelt, lihtsalt mugavam on kasutada funktsiooni login_as_root, et mitte määrata uuesti oma kasutajanime, parooli ja haldusserveri IP-aadressi.

Skript kiireks Security CheckUp seadistamiseks

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("Sisesta värava nimi:")
        gw_ip = raw_input("Sisesta värava IP-aadress:")
        if sys.stdin.isatty():
            sic = getpass.getpass("Sisesta ühekordne parool värava jaoks (SIC): ")
        else:
            print("Tähelepanu! Teie parool kuvatakse ekraanil!")
            sic = raw_input("Sisesta ühekordne parool värava jaoks (SIC): ")
        version = raw_input("Sisesta värava versioon (nt 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("Turbeline ühendus väravaga ei ole loodud!")
            exit(1)
        elif add_gw.success:
            print("Värav lisatud edukalt.")
            gw_uid = add_gw.data['uid']
            gw_name = add_gw.data['name']
        else:
            print("Värava lisamine ebaõnnestus - {}".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("Poliitikat on edukalt muudetud")
        else:
            print("Poliitika muutmine ebaõnnestus - {}".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("Cleanup reegel on edukalt muudetud")
        else:
            print("Cleanup reegli muutmine ebaõnnestus - {}".format(change_rule.error_message))

        # avalda tulemus
        publish_res = client.api_call("publish", {})
        if publish_res.success:
            print("Muutused on edukalt avaldatud.")
        else:
                print("Muutuste avaldamine ebaõnnestus - {}".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("Juurdepääsupoliitika on installitud")
        else:
                print("Juurdepääsupoliitika installimine ebaõnnestus - {}".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("Ohutõrje poliitika on installitud")
        else:
            print("Ohutõrje poliitika installimine ebaõnnestus - {}".format(install_tp_policy.error_message))
        
        # lisa paroolid ja salafraasid sõnaraamatusse
        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" : "Lisa paroolid ja salafraasid", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
                if add_password_dictionary.success:
                    print("Parooli sõnaraamatu rida {} on edukalt lisatud".format(line_num))
                else:
                    print("Sõnaraamatu lisamine ebaõnnestus - {}".format(add_password_dictionary.error_message))

main()

Näidisfail salajaste paroolide jaoks additional_pass.conf
{ "passwords" : ["pahavõtud","kahjulik","nakatunud","Nakatunud"], "phrases" : ["pahavõti","Pahavõti","Pass","pass","kood","võti","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

Kokkuvõte

See artikkel käsitleb ainult põhifunktsioone Python SDK ning moodulit cpapi(nagu võisite arvata, on need tegelikult sünonüümid), ja uurides selle mooduli koodi, avardate oma võimalusi selle kasutamisel. Pole välistatud, et soovite lisada sellele oma klasse, funktsioone, meetodeid ja muutujaid. Saate alati jagada oma töid ja vaadata teisi Check Pointi skripte jaotises CodeHub kogukonnas CheckMates, mis ühendab arendajaid ja toote kasutajaid.

Head kodeerimist ja tänan teid, et lugesite lõpuni!

Allikas: habr.com