All kraften i interaksjonen med APIet avdekkes når det brukes sammen med programmeringskode, noe som gir muligheter for å dynamisk lage API-forespørslene og verktøy for å analysere API-responsene. Imidlertid forblir det ennå lite bemerkelsesverdig Python Software Development Kit (heretter — Python SDK) for Check Point Management API, som er synd. Det forenkler livet betydelig for utviklere og automasjonsentusiaster. Python har fått enorm popularitet i det siste, og jeg bestemte meg for å fylle et gap og gi en oversikt over hovedfunksjonene . Denne artikkelen er et utmerket supplement til en annen artikkel på Habré . Vi vil se på hvordan man kan skrive skript ved hjelp av Python SDK og gå nærmere inn på den nye funksjonaliteten i Management API i versjon 1.6 (som støttes fra R80.40). Grunnleggende kunnskap om API og Python er nødvendig for å forstå artikkelen.
Check Point utvikler API aktivt, og de har nå lansert:
- — arbeid med administrasjonsserveren via API (og mulighet til å kjøre skript på gatewayene styrt av administrasjonsserveren)
- — arbeid med sikkerhetsgatewayer
- — arbeid med sandkassen i skyen til Check Point
- — arbeid med Identity Awareness-blade på gatewayene
- — arbeid med SMB-gatewayens administrasjonsportal ()
- — interaksjon med IoT-kontrollere
- — arbeid med (SD-WAN-sikkerhetsløsning)
- — arbeid med
Python SDK støtter for tiden bare interaksjon med Management API og Gaia API. Vi vil se nærmere på de viktigste klassene, metodene og variablene i denne modulen.
Installasjon av modulen
Modul cpapi installeres raskt og enkelt fra ved hjelp av pip. Det finnes en detaljert installasjonsguide i . Denne modulen er tilpasset for arbeid med Python versjoner 2.7 og 3.7. I denne artikkelen vil eksemplene bli gitt med bruk av Python 3.7. Imidlertid kan Python SDK kjøre direkte fra Check Point-administrasjonsserveren (Smart Management), men kun versjon 2.7 støttes der, derfor vil den siste delen inneholde kode for versjon 2.7. Rett etter installasjonen anbefales det å se på eksemplene i mappene examples_python2 og examples_python3.
Kom i gang
For at vi skal kunne arbejde med komponenterne i cpapi-modulet, er det nødvendigt at importere fra modulet cpapi mindst to nødvendige klasser:
APIClient og APIClientArgs
from cpapi import APIClient, APIClientArgs
Klasse APIClientArgs ansvarlig for API-serverens forbindelsesparametre, mens klassen APIClient er ansvarlig for interaktionen med API'en.
Definerer forbindelsesparametre
For at definere forskellige forbindelsesparametre til API'et, skal der oprettes en instans af klassen APIClientArgs. I princippet er dens parametre foruddefineret, og ved kørsel af scriptet på kontrolserveren kan de undlades.
client_args = APIClientArgs()Men ved kørsel på en ekstern server skal der angives mindst IP-adressen eller navnet på API-serveren (den er også kontrolserveren). I eksemplet nedenfor definerer vi forbindelsesparameteren server og tildeler den IP-adressen som streng.
client_args = APIClientArgs(server='192.168.47.241')Lad os se på alle parametre og deres standardværdier, som kan anvendes ved forbindelse til API-serveren:
Argumenter for __init__-metoden i klassen APIClientArgs
class APIClientArgs:
"""
Denne klasse giver argumenter til APIClient-konfiguration.
Alle argumenterne er konfigureret med deres standardværdier.
"""
# port er som standard sat til None, men den bliver erstattet med 443, hvis den ikke specificeres
# kontekst mulige værdier - web_api (standard) eller 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
# kontrolserverfingerprint
self.fingerprint = fingerprint
# session-id.
self.sid = sid
# kontrolserverens navn eller IP-adresse
self.server = server
# debugniveau
self.http_debug_level = http_debug_level
# et array med alle API-kald (til debugformål)
self.api_calls = api_calls if api_calls else []
# navn på debugfil. Hvis den forbliver tom, gemmes debugdata ikke på disk.
self.debug_file = debug_file
# HTTP proxyserveradresse (uden "http:\/")
self.proxy_host = proxy_host
# HTTP proxyport
self.proxy_port = proxy_port
# Kontrolserverens API-version
self.api_version = api_version
# Indikerer, at klienten ikke skal kontrollere serverens certifikat
self.unsafe = unsafe
# Indikerer, at klienten automatisk skal acceptere og gemme serverens certifikat
self.unsafe_auto_accept = unsafe_auto_accept
# Konteksten for brugen af klienten - som standard til web_api
self.context = contextJeg antager, at argumenterne, som kan anvendes i instanser af klassen APIClientArgs, er selvforklarende for Check Point-administratorer og ikke behøver yderligere kommentarer.
Vi forbinder gennem APIClient og kontekstadministratoren
Klasse APIClient Det er enklest å bruke gjennom kontekstadministratoren. Alt som trenger å bli overført til et APIClient-klasseinstans, er tilkoblingsparametrene som ble definert i forrige steg.
with APIClient(client_args) as client:
Kontekstadministratoren vil ikke automatisk utføre login-kallet mot API-serveren, men det vil utføre logout-kallet når du går ut av den. Hvis det av en eller annen grunn ikke er behov for logout etter å ha jobbet med API-kallene, må du starte arbeidet uten å bruke kontekstadministratoren:
client = APIClient(client_args)Sjekk tilkoblingen
Det er enklest å sjekke om tilkoblingen fungerer med de angitte parameterne ved hjelp av metoden check_fingerprint. Hvis sjekken av sha1-hashverdien for fingerprintet av API-serverens sertifikat feiler (metoden returnerte False), skyldes det vanligvis problemer med tilkoblingen, og vi kan stoppe programmet (eller gi brukeren muligheten til å rette tilkoblingsdataene):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Vær oppmerksom på at klassen APIClient vil sjekke sha1-fingerprintet for sertifikatet på API-serveren ved hvert API-kall (metodene api_call og api_query, som vil bli omtalt litt senere) . Hvis det oppdages en feil ved sjekking av sha1-fingerprintet for sertifikatet på API-serveren (sertifikatet er ukjent eller har blitt endret), vil metoden check_fingerprint gi muligheten til å legge til/endre informasjonen om det på den lokale maskinen automatisk. Denne sjekken kan deaktiveres helt (men dette kan bare anbefales ved kjøring av skript på selve API-serveren, når du kobler til 127.0.0.1), ved å bruke argumentet APIClientArgs — unsafe_auto_accept (se mer om APIClientArgs tidligere i "Definere tilkoblingsparametere").
client_args = APIClientArgs(unsafe_auto_accept=True)Login til API-server
Det APIClient finnes faktisk 3 metoder for innlogging på API-serveren, og hver av dem husker verdien sid(session-id), som brukes automatisk i hver påfølgende API-kall i headeren (navnet i headeren for denne parameteren — X-chkp-sid), så det er ikke behov for å håndtere denne parameteren i tillegg.
Metode for innlogging
Varianten som bruker brukernavn og passord (i eksempelet er brukernavnet admin og passordet 1q2w3e ført inn som posisjonsargumenter):
login = client.login('admin', '1q2w3e') I login-metoden er det også tilgjengelige ekstra valgfrie parametere, her er navnene og standardverdiene:
continue_last_session=False, domain=None, read_only=False, payload=NoneLogin med API-nøkkel
Alternativ med API-nøkkel (støttet fra versjon R80.40/Management API v1.6, «3TsbPJ8ZKjaJGvFyoFqHFA==» dette er API-nøkkelen for en av brukerne på administrasjonsserveren med autentiseringsmetoden API-nøkkel):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') I metoden login_with_api_key er de samme valgfrie parameterne tilgjengelige som i metoden login.
Metoden login_as_root
Alternativ for å logge inn på den lokale maskinen med API-server:
login = client.login_as_root()For denne metoden er det kun to valgfrie parametere tilgjengelige:
domain=None, payload=NoneOg til slutt selve API-kallene
Vi har to alternativer for å gjøre API-kall via metodene api_call og api_query. La oss se på hva forskjellen mellom dem er.
api_call
Denne metoden kan brukes for alle kall. Vi må sende den siste delen for API-kallet og payload i forespørselens kropp hvis nødvendig. Hvis payload er tom, kan den helt utelates:
api_versions = client.api_call('show-api-versions') Output for denne forespørselen er under:
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'})Output for denne forespørselen er under:
I [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
Jeg må spesifisere at denne metoden kun gjelder for forespørselene hvis utdata innebærer offset. Slike utdata skjer når det inneholder eller kan inneholde en stor mengde informasjon. For eksempel kan dette være en forespørsel om å liste opp alle opprettede objekter av typen vert på administrasjonsserveren. For slike forespørseler returnerer API-en som standard en liste med 50 objekter (grensen kan økes til 500 objekter i svaret). Og for å unngå å hente informasjon flere ganger ved å endre offset-parameteret i API-forespørselen, finnes det en metode api_query som utfører dette arbeidet automatisk. Eksempler på forespørseler der denne metoden er nødvendig: 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. Faktisk ser vi i navnene på disse API-kallene ord i flertall, så disse kallene vil være lettere å håndtere gjennom api_query
show_hosts = client.api_query('show-hosts') Output for denne forespørselen er under:
I [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
})
Behandling av API-kallresultater
Etter dette kan du bruke variabler og metoder i klassen APIResponse(både inne i kontekstmanageren og utenfor). Klassen har APIResponse forhåndsdefinerte 4 metoder og 5 variabler, som vi vil gå mer i dybden på de mest viktige.
success
For å begynne med, ville det vært lurt å sørge for at API-kallet ble gjennomført vellykket og returnerte et resultat. For dette finnes det en metode success:
I [49]: api_versions.success
Out[49]: True
Returnerer True hvis API-kallet var vellykket (Svarkode — 200) og False hvis ikke vellykket (hvilken som helst annen svarkode). Det er praktisk å bruke rett etter API-kallet, for å vise forskjellig informasjon avhengig av svarkode.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuskode
Returnerer svarkode etter utførelse av API-kallet.
I [62]: api_versions.status_code
Out[62]: 400
Mulige svarkoder: 200,400,401,403,404,409,500,501.
set_success_status
Det kan være nødvendig å endre verdien av statusen success. Teknisk sett kan man putte hva som helst der, til og med en vanlig streng. Men et reelt eksempel kan være å tilbakestille denne parameteren til False under visse forhold. Nedenfor ser vi et eksempel der det er oppgaver som kjører på kontrollserveren, men vi vil anse denne forespørselen som mislykket (setter variabelen success til False, selv om API-kallet var vellykket og returnerte kode 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakrespons()
Metoden respons lar deg se ordboken med statuskode (status_code) og med svaret (body).
In [94]: api_versions.respons()
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
Lar deg se bare svaret (body) uten unødvendig informasjon.
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']}
feilmelding
Denne informasjonen er tilgjengelig bare når det oppstår en feil ved behandling av API-forespørselen (statuskode ikke 200). Eksempel på utdata
In [107]: api_versions.feilmelding
Out[107]: 'kode: generic_err_invalid_parameter_navnmelding: Ukjent parameter [1]n'
Nyttige eksempler
Nedenfor er det oppført eksempler som bruker API-kall som ble lagt til i versjon Management API 1.6.
La oss først se på hvordan kallene add-host og add-address-range. Anta at vi må opprette IP-adressene i subnettet 192.168.0.0/24 som objekter av typen host, der den siste oktetten er 5, mens alle andre IP-adresser lagres som objekter av typen adresseområde. I tillegg må subnett adressen og bredde adresse ekskluderes.
Nedenfor er et skript som løser dette og oppretter 50 objekter av typen host og 51 objekter av typen adresseområde. Det kreves 101 API-kall for å fullføre oppgaven (uten å regne med den avsluttende publish-kallet). I tillegg bruker vi timeit-modulen for å beregne tiden for skriptets gjennomføring frem til endringspubliseringen.
Skriptet med bruk av add-host og 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')
I mitt laboratorium tar det fra 30 til 50 sekunder å kjøre dette skriptet, avhengig av belastningen på kontrollserveren.
Nå skal vi se hvordan denne oppgaven kan løses med en API-forespørsel. add-objects-batch, støttet siden API versjon 1.6. Denne forespørselen lar deg opprette flere objekter med én API-forespørsel. Dette kan være objekter av forskjellige typer (for eksempel verter, subnett og adresseområder). Dermed kan oppgaven vår løses innenfor ramen av én API-forespørsel.
Skriptet ved bruk av 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')
Å kjøre dette skriptet i laboratoriet mitt tar fra 3 til 7 sekunder, avhengig av belastningen på kontrollserveren. Så, i gjennomsnitt, på 101 objekter, kjører batch API-forespørselen 10 ganger raskere. Ved flere objekter vil forskjellen være enda mer imponerende.
Nå la oss se hvordan vi kan jobbe med set-objects-batch. Med denne API-forespørselen kan vi massivt endre en hvilken som helst parameter. La oss sette fargen på den første halvdelen av adressene fra forrige eksempel (opp til .124 verten, inkludert også adresserekkene) til sienna, og den andre halvdelen av adressene til khaki.
Endring av fargen på objektene opprettet i det forrige eksempelet.
fra cpapi import APIClient, APIClientArgs
klient_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")
Å fjerne flere objekter i én API-anrop kan gjøres med delete-objects-batch. Nå skal vi se på et kodeeksempel som fjerner alle verter som ble opprettet tidligere via add-objects-batch.
Fjerning av objekter ved hjelp av delete-objects-batch
fra cpapi import APIClient, APIClientArgs
klient_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
delete_objects_batch = client.api_call("delete-objects-batch", data_for_batch)
publish = client.api_call("publish")
print(delete_objects_batch.data)
Alle funksjoner som vises i nye utgivelser av Check Point-programvaren, får straks API-anrop. Så i R80.40 kom funksjoner som Revert to revision og Smart Task, og for dem ble det straks laget tilsvarende API-anrop. Videre får all funksjonalitet ved overgangen fra Legacy-konsoller til Unified Policy også støtte for API. For eksempel ble det etterlengtede oppdateringen i R80.40 versjonen flyttingen av HTTPS Inspection-policyen fra Legacy-modus til Unified Policy-modus, og denne funksjonaliteten fikk også API-anrop. Her er et eksempel på kode som legger til en regel på toppplassen for HTTPS Inspection-policyen, som unntar fra inspeksjon tre kategorier (Helse, Finans, Offentlige tjenester), som det er forbudt å inspisere i henhold til lovgivning i en rekke land.
Legg til regel i HTTPS Inspection-policyen
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")
Kjøre Python-skripter på Check Point-administrasjonsserveren
Det samme i inneholder informasjon om hvordan man kjører Python-skripter direkte fra administrasjonsserveren. Dette kan være praktisk når du ikke har mulighet til å koble til API-serveren fra en annen maskin. Jeg har laget en seks-minutters video der jeg ser på installasjonen av modulen cpapi og egenskapene ved å kjøre Python-skripter på administrasjonsserveren. Som eksempel kjøres et skript som automatiserer konfigurasjonen av en ny gateway for en oppgave som nettverksrevisjon Security CheckUp. Blant de spesifikasjonene man måtte forholde seg til: i Python 2.7 kom ikke funksjonen input, så for å håndtere informasjonen som brukeren skriver inn, brukes funksjonen raw_input. Ellers er koden den samme som for kjøring fra andre maskiner, det er bare enklere å bruke funksjonen login_as_root, slik at man slipper å oppgi sitt eget brukernavn, passord og IP-adresse til administrasjonsserveren en gang til.
Skript for rask oppsett av Security CheckUp
fra __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:
# hvis klienten sjekker fingeravtrykk er False:
# print("Kunne ikke få servert fingeravtrykk - Sjekk tilkobling til serveren.")
# exit(1)
login_res = client.login_as_root()
if login_res.success er False:
print("Innlogging mislyktes:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Skriv inn gateway-navnet:")
gw_ip = raw_input("Skriv inn gatewayens IP-adresse:")
if sys.stdin.isatty():
sic = getpass.getpass("Skriv inn engangspassord for gateway (SIC): ")
else:
print("Vær oppmerksom! Passordet ditt vil bli vist på skjermen!")
sic = raw_input("Skriv inn engangspassord for gateway (SIC): ")
version = raw_input("Skriv inn gatewayversjonen (for eksempel 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 og add_gw.data['sic-state'] != "kommuniserer":
print("Sikker tilkobling med gatewayen er ikke etablert!")
exit(1)
elif add_gw.success:
print("Gatewayen ble lagt til med suksess.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Mislyktes i å legge til gatewayen - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Nettverk", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("Policyen har blitt endret med suksess")
else:
print("Mislyktes i å endre policyen - {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Rydde regel", "layer" : "Nettverk", "action": "Godta", "track": {"type": "Detaljert logg", "accounting": "true"}})
if change_rule.success:
print("Rydde regelen har blitt endret med suksess")
else:
print("Mislyktes i å endre rydde regelen - {}".format(change_rule.error_message))
# publiser resultatet
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Endringene ble publisert med suksess.")
else:
print("Mislyktes i å publisere endringene - {}".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("Tilgangspolicyen har blitt installert")
else:
print("Mislyktes i å installere tilgangspolicy - {}".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("Trusselforebyggingspolicyen har blitt installert")
else:
print("Mislyktes i å installere trusselforebyggingspolicy - {}".format(install_tp_policy.error_message))
# legg til passord og passphrases i ordboken
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" : "Legg til passord og passphrases", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Linje {} i passordordboken ble lagt til med suksess".format(line_num))
else:
print("Mislyktes i å legge til ordboken - {}".format(add_password_dictionary.error_message))
main() Eksempel på fil med passordordbok additional_pass.conf
{
"passwords" : ["skadelig programvare","ondskapsfull","infisert","Infisert"],
"phrases" : ["passord","Passord","Pass","pass","kode","nøkkel","pwd","passord","Passord","Nøkkel","nøkkel","koding","Koding"]
}
Konklusjon
Denne artikkelen tar bare for seg de grunnleggende funksjonene. Python SDK og modulen cpapi(som du kanskje har gjettet, er disse faktisk synonymer), og ved å studere koden i denne modulen vil du oppdage enda flere muligheter i arbeidet med den. Det er ikke umulig at du ønsker å legge til dine egne klasser, funksjoner, metoder og variabler. Du kan alltid dele dine utviklinger og se på andre skript for Check Point i delen i fellesskapet , som samler både produktutviklere og brukere.
God koding, og takk for at du leste til slutten!
Kilde: habr.com
Russian
Italian
German
Polish
Estonian
Albanian
Bulgarian
Croatian
Czech
Danish
Dutch
English
French
Hungarian
Latvian
Norwegian
Portuguese
Romanian
Slovak
Slovenian
Spanish
Swedish