🥇Teeme Check Point API kasutamise lihtsamaks Python SDK abil

Kogu API võimekus avatakse koostöös programmikoodiga, võimaldades dünaamiliselt luua API päringuid ja tööriistu API vastuste analüüsimiseks. Kuid seni on vähem märgatud Python'i tarkvaraarenduse komplekti (edaspidi — Python SDK) for Check Point Management API, mida on kahju. See muudab arendajate ja automatiseerimise entusiastide elu oluliselt lihtsamaks. Python on viimasel ajal saavutanud tohutut populaarsust ning ma otsustasin täita tühimiku ja teha ülevaate peamistest võimalustest Check Point API Python Development Kit. See artikkel on suurepärane lisa teisele artiklile Habrisse Check Point R80.10 API. Halduse CLI kaudu, skriptid ja palju muud. Me vaatame, kuidas kirjutada skripte, kasutades Python SDK-d, ja peatume lähemalt Management API uuel funktsionaalsusel versioonis 1.6 (toetatakse alates R80.40). Artikli mõistmiseks on vajalikud põhitõed API ja Python töötamise osas.

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

Check Point Management API (kehtiv versioon 1.6) — töö juhtimisserveriga läbi API (ja võimalus käitada skripte väravates, mis on juhtimisserveri all)
Check Point GAIA API (kehtiv versioon 1.4) — töös turvaväravatega
Threat Prevention API 1.0 — töös Check Point'i liivakastiga
Identity Awareness API — töös Identity Awareness blade'i turvaväravates
Security Management Portal API — töös SMB turvaväravate haldusportaaliga (Täpsemalt SMB turvaväravate kohta)
IoT API — suhtlemine IoT kontrolleritega
CloudGuard Connect API — töös CloudGuard Connect (SD-WAN security lahendus)
Dome9 API — töös Dome9

Python SDK toetab praegu ainult Management API ja Gaia API. Käsitleme selle mooduli olulisemaid klasse, meetodeid ja muutujaid.

Mooduli

Modul cpapi paigaldamine on kiire ja lihtne Check Point'i ametlikust gitHubi hoidlast kasutades pip. Üksikasjalik installatsiooni juhend on saadaval README.md. See moodul on kohandatud töötamiseks Python 2.7 ja 3.7 versioonidega. Antud artiklis on näited toodud kasutades Python 3.7. Siiski, Python SDK-d saab käivitada otse Check Point'i haldusserverilt (Smart Management), kuid seal toetatakse ainult Python 2.7 versiooni, seega viimases osas on toodud kood versioonile 2.7. Kohe pärast mooduli installimist soovitan vaadata näiteid kataloogides examples_python2 ja examples_python3.

Alustamine

Kuna meil on võimalus töötada cpapi mooduli komponentidega, tuleb importida moodulist cpapi vähemalt kaks vajalikku klassi:

APIClient ja APIClientArgs

from cpapi import APIClient, APIClientArgs

Klass APIClientArgs millel on seotud API serveriga ühenduse parameetrid, ning klass APIClient käsitleb API-ga suhtlemist.

Määra ühenduse parameetrid

Erinevate API-ga ühenduse parameetrite määramiseks tuleb luua klassi APIClientArgseksemplar. Üldiselt on selle parameetrid eelnevalt määratud ja skripti käivitamisel haldussüsteemis ei pea neid kindlasti määrama.

client_args = APIClientArgs()

Kuid kolmandal serveril käivitamisel tuleb määrata vähemalt API serveri IP-aadress või hostinimi (see on ka haldussüsteem). Allolevas näites määrame ühenduse parameetri server ja määrame sellele stringina haldussüsteemi IP-aadressi.

client_args = APIClientArgs(server='192.168.47.241')

Vaatame kõiki parameetreid ja nende vaikimisi väärtusi, mida saab API-serveriga ühendamiseks kasutada:

APIClientArgs klassi __init__ meetodi argumendid

class APIClientArgs:
    """
    See klass pakub argumente APIClient konfigureerimiseks.
    Kõik argumendid on seadistatud oma vaikeväärtustega.
    """

    # port on vaikimisi seadistatud None, kuid asendatakse 443-ga, kui ei ole määratud
    # 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
        # haldusteenuse sõrmejälg
        self.fingerprint = fingerprint
        # sessiooni-ID.
        self.sid = sid
        # haldusteenuse nimi või IP-aadress
        self.server = server
        # silumise tase
        self.http_debug_level = http_debug_level
        # massiiv, kus on kõik API-kutsed (silumise eesmärkidel)
        self.api_calls = api_calls if api_calls else []
        # silumise faili nimi. Kui see jääb tühjaks, ei salvestata silumise andmeid kettale.
        self.debug_file = debug_file
        # HTTP-proksi serveri aadress (ilma "http://")
        self.proxy_host = proxy_host
        # HTTP-proksi port
        self.proxy_port = proxy_port
        # haldusteenuse API versioon
        self.api_version = api_version
        # Näitab, et klient ei tohiks kontrollida 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

Arvan, et APIClientArgs klassi eksemplaride argumentide mõisted on Check Pointi administraatoritele loogiliselt arusaadavad ning neile ei ole lisakommentaare vajalik.

Ühendame APIClienti ja kontekstihalduriga

Klass APIClient on kõige mugavam kasutada kontekstihalduse kaudu. Kõik, mis tuleb APIClient klassi eksemplarile edastada, on ühenduse parameetrid, mis määrati eelnevas sammus.

with APIClient(client_args) as client:

Kontekstihaldur ei soorita automaatselt login kõnet API serverisse, kuid ta teeb logout kõne, kui sellest väljutakse. Kui mingil põhjusel pole API kõnede lõpetamise järgselt logout vajalik, tuleb alustada tööd ilma kontekstihaldurita:

client = APIClient(client_args)

Ühenduse kontrollimine

Kontrollida, kas ühendus antud parameetritega on lihtsaim kasutada meetodi check_fingerprint. Kui API serveri sertifikaadi fingerprinti sha1 kontrollimised ei läinud läbi (meetod tagastas False), on see tavaliselt põhjustatud ühenduse probleemidest ning me saame programmi käivitamise peatada (või anda kasutajale võimaluse andmeid parandada):

    kui client.check_fingerprint() on vale:
        print("Ei saanud serveri sõrmejälge - Kontrollige ühendust serveriga.")
        exit(1)

Pange tähele, et edaspidi klass APIClient kontrollib iga API-ülesande korral (meetodid api_call ja api_query, millest räägime hiljem) sha1 sõrmejälge API serveri sertifikaadi kohta. Kui sha1 sõrmejälje kontrollimisel tuvastatakse viga (sertifikaat on tundmatu või on muutunud), siis meetod check_fingerprint pakub võimalust lisada/muuta selle kohta teavet kohaliku masina automaatrežiimis. Selle kontrolli saab üldse välja lülitada (kuid seda soovitatakse ainult juhul, kui skripte käitatakse otse API serveris, ühendades 127.0.0.1), kasutades argumenti APIClientArgs — unsafe_auto_accept (vt APIClientArgs kohta lähemalt "Määratlege ühenduse parameetrid"-s).

client_args = APIClientArgs(unsafe_auto_accept=True)

Logi sisse API serverisse

U APIClient on kokku 3 meetodit sisse logimiseks API serverisse, ja igaühe puhul salvestatakse väärtus sid(session-id), mida kasutatakse automaatselt igas järgmises API-ühenduses päises (selle parameetri nimi päises on X-chkp-sid), nii et seda parameetrit ei pea eraldi töötlema.

Meetod login

Variant, kasutades sisselogimist ja parooli (näiteks on kasutajanimi admin ja parool 1q2w3e edastatud positsiooniliste argumentidena):

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

Metoodis login on saadaval ka täiendavad valikuvõimalused, siin on nende nimed ja vaikimisi väärtused:

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

Meetod login_with_api_key

Variant, kasutades API võtit (tugineb versioonist R80.40 / Management API v1.6, «3TsbPJ8ZKjaJGvFyoFqHFA==» see on API võti ühele kasutajale haldusserveris, kasutades autentimismeetodit API key):

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

Meetodis login_with_api_key on saadaval samad valikuvõimalused nagu meetodis login.

Meetod login_as_root

Variant sisselogimiseks lokaalsesse masinasse API serveriga:

     login = client.login_as_root()

Selle meetodi jaoks on saadaval vaid kaks valikuvõimalust:

domain=None, payload=None

Ja lõpuks, ise API kutsed

Meil on kaks varianti API kutsude tegemiseks läbi meetodite. api_call ja api_queryVaatame, milline nende vahel on erinevus.

api_call

Seda meetodit saab kasutada igasuguste kutsuste jaoks. Me peame edastama viimase osa API kutsest ja payload'i soovi korral. Kui payload on tühi, siis seda ei pea üldse edastama:

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

Käesoleva 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'})

Käesoleva päringu väljund allpool:

In [25]: show_host                                                              
Out[25]: 
APIResponse({
    "data": {
        "color": "must", 
        "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": "must",
            "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

Esmapäraselt ütlen, et see meetod kehtib ainult nende API-kutsede puhul, mille väljundis on offset (tõuke) olemas. Sellist väljundit kasutatakse, kui see sisaldab või võib sisaldada suurt hulka teavet. Näiteks võib see olla päring kõigi loodud hostide loendi saamiseks haldusserveris. Selliste päringute puhul tagastab API vaikimisi 50 objekti (selle arvu saab suurendada kuni 500 objekti). Et vältida teabe mitu korda pärimist erineva offset parameetriga API-kutses, on olemas meetod api_query, mis teeb selle töö automaatselt ära. Näited kutsetest, kus seda meetodit on vaja: 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-kutsete nimedes sõnu mitmuses, nii et neid kutseid on lihtsam töödelda läbi api_query

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

Käesoleva päringu väljund allpool:

In [21]: show_hosts                                                             
Out[21]: 
APIResponse({
    "data": [
        {
            "domain": {
                "domain-type": "domain",
                "name": "SMC kasutaja",
                "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 kasutaja",
                "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 kasutaja",
                        "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 kasutaja",
                        "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 saab kasutada klassi muutujaid ja meetodeid APIResponse(nii konteksti halduri sees kui ka väljaspool). Klassil APIResponse on määratud 4 meetodit ja 5 muutujat, millest kõige olulisematel peatume lähemalt.

success

Alustuseks oleks hea veenduda, et API kutse õnnestus ja tagastas tulemuse. Selleks on olemas meetod success:

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

Tagastab True, kui API kutse õnnestus (vastuskood — 200) ja False, kui mitte (ükskõik milline teine vastuskood). Mugav kasutada kohe pärast API kutsest, et vastavalt vastuskoodile erinevat teavet kuvada.

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

statuscode

Tagastab vastuskoodi pärast API kutsumise 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

Samuti võib olla vajalik muuta staatuse väärtust success. Tehniliselt võib sinna panna mis tahes, isegi tavalise stringi. Kuid reaalseks näiteks võib olla selle parameetri seadmine False'iks teatud kõrvaltingimustes. Allpool on näide, kus on ülesanded, mis täidetakse haldusserveris, kuid me peame seda päringut ebaõnnestunuks (seadke muutuja success False, hoolimata sellest, et API-kutse 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()

Meetod response võimaldab vaadata sõnastikku koos vastuse koodiga (status_code) ja vastuse kehaga (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

Võimaldab näha ainult vastuse keha (body) ilma liigsete detailideta.

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öötlemise käigus tekkis tõrge (vastuse kood 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 toodud näited, kus kasutatakse API päringuid, mis on lisatud juhtimise API versioonile 1.6.

Alustuseks vaatame päringute toimimist add-host ja add-address-range. Oletame, et me peame looma objektid, mille tüüp on host, kõikide IP aadresside jaoks alamsüsteemis 192.168.0.0/24, mille viimane oktet on 5, ja kõik ülejäänud IP aadressid salvestama objektidena, mille tüüp on aadressirida. Samuti tuleb välja jätta alamsüsteemi aadress ja laiendatud aadress.

Nii et allpool on esitatud skript, mis lahendab antud ülesande ja loob 50 host tüüpi objekti ja 51 aadressirea objekti. Probleemi lahendamiseks kulub 101 API päringut (ilma lõpp-päringut publish arvestamata). Samuti kasutame moodulit timeit, et arvutada skripti täitmise aega kuni muudatuste avaldamiseni.

Skript koos 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 laboratooriumis kulub selle skripti täitmiseks sõltuvalt haldusserveri koormusest 30 kuni 50 sekundit.

Nüüd vaatame, kuidas lahendada sama probleem API kutsumise abil add-objects-batch, mille tugi on lisatud API versioonis 1.6. See kutsumine võimaldab ühes API päringus luua mitmeid objekte. Need võivad olla erinevat tüüpi objektid (näiteks hostid, alamvõrgud ja aadressivahemikud). Seega saame meie ülesande lahendada ühe API kutsumise 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')

Kuid skripti täitmine minu laborikeskkonnas võtab aega 3 kuni 7 sekundit olenevalt haldusseervere koormusest. See tähendab, et keskmiselt saab 101 objekti puhul API kutsumine tüüpi 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 massiliselt muuta mis tahes parameetrit. Seadistame esimeses pooles aadresse eelmisest näitest (kuni .124 hostini, sealhulgas ka vahemike jaoks) värvi sienna ja teises pooles aadresse 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")

Eemaldada mitmed objektid ühe API kutsumisega on võimalik kasutades delete-objects-batch. Ja nüüd vaatame koodi näidet, mis eemaldab kõik varem loodud hostid add-objects-batch.

Objektide eemaldamine 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)

Check Pointi tarkvara uutes versioonides on kõik funktsioonid koheselt seotud ka API kutsungitega. Näiteks R80.40 versioonis tutvustatakse selliseid funktsioone nagu „Revert to revision” ja „Smart Task”, ning nende jaoks on kohe valmis vastavad API kutsungid. Lisaks sellele, kogu funktsionaalsus, kui toimub üleminek Legacy konsoolidest Unified Policy režiimi, saab samuti API toe. Näiteks oodatud uuendus R80.40 versioonis oli HTTPS Inspection poliitika üleminek Legacy režiimist Unified Policy režiimi, ning see funktsionaalsus sai kohe API kutsungid. Siin on koodinäide, mis lisab HTTPS Inspection poliitika tippu reegli, mis välistab kolmest kategooriast (Tervis, Rahandus, Avalikud teenused) inspektsiooni, mille inspektsioon on mitmes riigis seadusandluses keelatud.

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

Kogu sisu jääb samaks README.md sisal on teavet, kuidas käivitada skripte Pythonis otse haldusserverist. See võib olla mugav, kui teil pole võimalik ühendada API serverisse mõnest teisest masinast. Olen salvestanud kuue minuti video, milles käsitlen mooduli cpapi ja Python-skriptide käivitamise eripärasid haldusserveris. Näiteks käivitan skripti, mis automatiseerib uue lüüsikoodi seadistamist selliste ülesannete jaoks nagu võrgu auditeerimine. Security CheckUp. Eripärad, millega silmitsi seisin: Python 2.7 versioonis polnud veel funktsiooni input, seega kasutatakse kasutaja sisestatud teabe töötlemiseks funktsiooni raw_input. Muudelt masinakäivitustelt koodit erakordselt ei erine, lihtsalt on mugavam kasutada funktsiooni login_as_root, et mitte oma enda kasutajanime, paroole ja haldusserveri IP-aadressi uuesti sisestada.

Skript Security CheckUp kiireks 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("Ei saanud serveri sõrmejälge kätte - kontrollige serveriga ühendust.")
       #     exit(1)
        login_res = client.login_as_root()

        if login_res.success is False:
            print("Sisselogimine ebaõnnestus: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 ilmub ekraanile!")
            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("Turvaline ühendus väravaga ei ole loodud!")
            exit(1)
        elif add_gw.success:
            print("Värav lisati 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("Poliitika muudeti edukalt")
        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 muudeti edukalt")
        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("Muudatused avaldati edukalt.")
        else:
                print("Muudatuste 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ääsu poliitika on installitud")
        else:
                print("Juurdepääsu poliitika 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("Sissetungi tõkestamise poliitika on installitud")
        else:
            print("Sissetungi tõkestamise poliitika installimine ebaõnnestus - {}".format(install_tp_policy.error_message))
        
        # lisa paroolid ja salasõnad sõnastikku
        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 salasõnad", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
                if add_password_dictionary.success:
                    print("Parooli sõnastiku rida {} lisati edukalt".format(line_num))
                else:
                    print("Sõnastiku lisamine ebaõnnestus - {}".format(add_password_dictionary.error_message))

main()

Näidis fail sõnadega varvete jaoks additional_pass.conf
{ "passwords" : ["malware","malicious","infektoitunud","Infected"], "phrases" : ["parool","Parool","Pass","pass","kood","võti","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

Kokkuvõte

See artikkel käsitleb ainult põhivõimalusi tööks Python SDK ja mooduli cpapi(nagu te võisite arvata, need on põhimõtteliselt sünonüümid), ja uurides selle mooduli koodi avastate veelgi rohkem võimalusi selle kasutamiseks. Pole välistatud, et tekib soov täiendada seda oma klassidega, funktsioonidega, meetoditega ja muutujatega. Te võite alati jagada oma saavutusi ja vaadata teisi Check Pointi skripte jaotises CodeHub kogukonnas CheckMates, mis ühendab nii toodete arendajaid kui ka kasutajaid.

Head programmeerimist ja aitäh, et lugesite lõpuni!

Allikas: habr.com