Al styrken af API-interaktioner afsløres, når de bruges sammen med kode, hvilket giver mulighed for dynamisk at danne API-anmodninger og værktøjer til at analysere API-svar. Dog forbliver det stadig relativt ukendt Python Software Development Kit (herefter - Python SDK) til Check Point Management API, hvilket er en skam. Det gør livet betydeligt lettere for udviklere og entusiaster inden for automatisering. Python har vundet enorm popularitet på det seneste, så jeg besluttede mig for at fylde dette hul og give et overblik over de grundlæggende funktioner . Denne artikel vil fungere som et fremragende supplement til en anden artikel på Habr . Vi vil se på, hvordan man skriver scripts med Python SDK og dykke dybere ned i de nye funktioner i Management API i version 1.6 (som understøttes fra R80.40). Grundlæggende viden om arbejde med API'er og Python vil være nødvendig for forståelsen af artiklen.
Check Point udvikler aktivt API'er, og i øjeblikket er der kommet til verden:
- — arbejde med administrationsserveren via API (og mulighed for at udføre scripts på gateways styret af administrationsserveren)
- — arbejde med sikkerhedsgateways
- — arbejde med sandkasse i Check Points sky
- — arbejde med Identity Awareness blade på gateways
- — arbejde med SMB gateway management portal ()
- — interaktion med IoT-controllere
- — arbejde med (SD-WAN sikkerhedsløsning)
- — arbejde med
Python SDK understøtter i øjeblikket kun interaktion med Management API og Gaia API. Vi vil se på de mest vigtige klasser, metoder og variabler i dette modul.
Installation af modulet
Module cpapi installeres hurtigt og nemt fra ved hjælp af pip. En detaljeret installationsvejledning er tilgængelig i . Dette modul er tilpasset til brug med versioner af Python 2.7 og 3.7. Eksemplerne i denne artikel vil blive givet med Python 3.7. Dog kan Python SDK køres direkte fra Check Point administrationsserveren (Smart Management), men der understøttes kun version 2.7. Derfor vil der i det sidste afsnit blive givet kode til version 2.7. Umiddelbart efter installationen anbefaler jeg at se på eksempler i mapperne examples_python2 og examples_python3.
Getting Started
For us to be able to work with the components of the module cpapi, we need to import at least two necessary classes from the module: cpapi APIClient
APIClientArgs og from cpapi import APIClient, APIClientArgs
is responsible for the connection parameters to the API server, while the class
Klasse from cpapi import APIClient, APIClientArgs is responsible for interacting with the API. APIClientArgs Define connection parameters
To define various connection parameters to the API, one needs to create an instance of the class
. In principle, its parameters are predefined and when running the script on the management server, they can be omitted. from cpapi import APIClient, APIClientArgsclient_args = APIClientArgs()
However, when running on a third-party host, at least the IP address or hostname of the API server (the management server) needs to be specified. In the example below, we define the connection parameter server and assign it the IP address of the management server as a string.client_args = APIClientArgs(server='192.168.47.241')
Let's look at all the parameters and their default values that can be used when connecting to the API server:Arguments of the __init__ method of the APIClientArgs class
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
I believe that the arguments that can be used in instances of the APIClientArgs class are intuitively clear to Check Point administrators and do not require additional comments.Connecting through APIClient and the context manager
Connecting through APIClient and the context manager
Klasse APIClientArgs det er nemmest at bruge gennem kontekstmanageren. Alt, hvad der skal overføres til instansen af klassen APIClient, er de forbindelseparametre, som blev defineret i det foregående trin.
with APIClient(client_args) as client:
Kontekstmanageren vil ikke automatisk udføre login-kaldet til API-serveren, men den vil udføre logout-kaldet ved udgangen derfra. Hvis logout ikke er nødvendigt efter at have arbejdet med API-kald, skal arbejdet startes uden at bruge kontekstmanageren:
client = APIClient(client_args)Forbindelseskontrol
Det er nemmest at kontrollere, om forbindelsen fungerer med de angivne parametre ved hjælp af metoden check_fingerprint. Hvis kontrol af hash-værdien sha1 for fingerprint-certifikatet fra API-serveren ikke bestod (metoden returnerede False), skyldes det normalt problemer med forbindelsen, og vi kan stoppe programmets udførelse (eller give brugeren mulighed for at rette forbindelsesoplysningerne):
if client.check_fingerprint() is False:
print("Kunne ikke få serverens fingerprint - Tjek forbindelsen til serveren.")
exit(1)
Bemærk, at klassen APIClientArgs vil kontrollere sha1-fingerprintet for API-serverens certifikat ved hver API-kald (metoderne api_call og api_query, som vil blive omtalt lidt senere) for fejl. Hvis der opdages en fejl ved kontrol af sha1-fingerprintet for API-serverens certifikat (certifikatet er ukendt eller blevet ændret), vil metoden check_fingerprint give mulighed for at tilføje/ændre oplysninger om det lokalt på maskinen automatisk. Denne kontrol kan helt slukkes (men det anbefales kun ved kørsel af scripts på selve API-serveren, ved tilslutning til 127.0.0.1), ved at bruge argumentet APIClientArgs — unsafe_auto_accept (se nærmere om APIClientArgs tidligere i "Definerer forbindelsesparametrene").
client_args = APIClientArgs(unsafe_auto_accept=True)Login til API-serveren
Ved APIClientArgs Der er hele 3 metoder til login på API-serveren, og hver af dem gemmer værdien sid(session-id), som automatisk bruges i hver efterfølgende API-kald i headeren (navnet i headeren for denne parameter — X-chkp-sid), så det er ikke nødvendigt at behandle denne parameter yderligere.
Login-metoden
Variant med brug af brugernavn og adgangskode (i eksemplet er brugernavnet admin og adgangskoden 1q2w3e givet som positionsargumenter):
login = client.login('admin', '1q2w3e') I login-metoden er der også tilgængelige yderligere valgfri parametre, jeg angiver deres navne og standardværdier:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetode login_with_api_key
Mulighed med brug af API-nøgle (understøttes fra version R80.40 / Management API v1.6, «3TsbPJ8ZKjaJGvFyoFqHFA==» dette er værdien af API-nøglen for en af brugerne på administrationsserveren med godkendelsesmetoden API-nøgle):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') I metoden login_with_api_key er de samme valgfrie parametre tilgængelige som i metoden login.
Metode login_as_root
Mulighed for login på den lokale maskine med API-serveren:
login = client.login_as_root()For denne metode er der kun to valgfrie parametre tilgængelige:
domain=None, payload=NoneOg endelig selve API-kaldet
Vi har to muligheder for at foretage API-kald gennem metoder api_call og api_query. Lad os se nærmere på forskellen mellem dem.
api_call
Denne metode kan anvendes til alle kald. Vi skal sende den sidste del til API-kaldet og payload i anmodningens krop, hvis det er nødvendigt. Hvis payload er tom, kan den slet ikke sendes:
api_versions = client.api_call('show-api-versions') Outputtet for denne anmodning er nedenfor:
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'})Outputtet for denne anmodning er nedenfor:
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
Lad mig straks gøre det klart, at denne metode kun gælder for kald, hvor output indebærer offset. Sådan output opstår, når der er eller kan være et stort antal oplysninger. For eksempel kan dette være en anmodning om listen over alle oprettede objekter af typen host på administrationsserveren. For sådanne anmodninger returnerer API'en som standard en liste med 50 objekter (grænsen kan øges til 500 objekter i svaret). Og for at undgå at hente oplysningerne flere gange ved at ændre offset-parameteren i API-anmodningen, findes der en metode, api_query, som udfører dette arbejde automatisk. Eksempler på kald, hvor denne metode 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-kald ord i flertal, så det vil være lettere at behandle disse kald gennem api_query
show_hosts = client.api_query('show-hosts') Outputtet for denne anmodning er nedenfor:
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 af API-kaldsresultater
Efter dette kan man bruge klassens variabler og metoder APIResponse(både inde i kontekstmanageren og udenfor). Klassen APIResponse har defineret 4 metoder og 5 variabler, vi vil fokusere på de mest vigtige.
success
For at starte ville det være godt at sikre sig, at API-kaldet var succesfuldt og gav et resultat. Til dette findes metoden success:
I [49]: api_versions.success
Out[49]: True
Returnerer True, hvis API-kaldet var succesfuldt (Statuskode — 200) og False, hvis det ikke var (hvilken som helst anden statuskode). Det er praktisk at bruge lige efter API-kaldet for at vise forskellige informationer afhængigt af statuskoden.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuskode
Returnerer statuskoden efter udførelsen af API-kaldet.
I [62]: api_versions.status_code
Out[62]: 400
Mulige svarcodes: 200,400,401,403,404,409,500,501.
set_success_status
Der kan være behov for at ændre værdien af status success. Tekniskt set kan man putte hvad som helst der, endda en almindelig streng. Men et realt eksempel kan være at nulstille denne parameter til False under bestemte ledsagende betingelser. Nedenfor kan du se et eksempel, hvor der er opgaver, der udføres på serveren, men vi vil betragte denne anmodning som mislykket (sætte variablen success til False, selvom API-opkaldet var vellykket og returnerede kode 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakresponse()
Metoden response giver mulighed for at se ordbogen med svarkode (status_code) og med svartekst (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
Tillader at se kun svarteksten (body) uden unødvendige oplysninger.
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
Denne information er kun tilgængelig, når der opstod en fejl under behandlingen af API-anmodningen (svarkode ikke 200). Eksempel på output
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_name message: Unrecognized parameter [1]'
Nyttige eksempler
Nedenfor er der eksempler, der bruger API-opkald, som blev tilføjet i version Management API 1.6.
Lad os først se på arbejdet med opkaldene add-host og add-address-range. Antag, at vi skal oprette alle IP-adresser i subnettet 192.168.0.0/24, hvor den sidste oktet er 5, som objekter af typen host, mens alle andre IP-adresser skal registreres som objekter af typen adresseområde. Samtidig skal subnetadressen og broadcast-adressen undtages.
Derfor præsenteres nedenfor et script, der løser denne opgave og opretter 50 objekter af typen host og 51 objekter af typen adresseområde. At løse opgaven kræver 101 API-opkald (uden at tælle det sidste opkald publish). Vi bruger også timeit-modulet til at beregne tiden for scriptets udførelse indtil ændringerne offentliggøres.
Script med brug af 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 mit mit laboratoriumsind i mine laboratoriske miljøer varer det fra 30 til 50 sekunder afhængigt af belastningen på administrationsserveren.
Lad os nu se, hvordan vi kan løse denne opgave med et API-opkald. add-objects-batch, som blev tilføjet i version API 1.6. Dette opkald giver os mulighed for at oprette mange objekter med et enkelt API-opkald. Det kan være objekter af forskellige typer (f.eks. værter, undernet og adresseområder). Derfor kan vi løse vores opgave med et enkelt API-opkald.
Scriptet med brug af 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')
Og at køre dette script i mit laboratoriemiljø tager fra 3 til 7 sekunder afhængigt af belastningen på administrationsserveren. Således udføres et API-opkald af batch-typen, på i gennemsnit 10 gange hurtigere på 101 objekter. Forskellen vil være endnu mere imponerende med et større antal objekter.
Lad os nu se, hvordan man arbejder med set-objects-batch. Ved hjælp af dette API-opkald kan vi massivt ændre enhver parameter. Lad os indstille farven sienna for den første halvdel af adresserne fra det tidligere eksempel (op til .124 værten, samt for områderne) og tildele farven khaki til den anden halvdel af adresserne.
Ændring af farven på objekterne, der blev oprettet i det forrige eksempel
fra 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")
Du kan slette mange objekter i ét API-kald ved hjælp af delete-objects-batch. Lad os nu se på et kodeeksempel, der sletter alle værter, som blev oprettet tidligere via add-objects-batch.
Sletning af objekter ved hjælp af delete-objects-batch
fra cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5, 255, 5):
data = {"name": f'h_192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
delete_objects_batch = client.api_call("delete-objects-batch", data_for_batch)
publish = client.api_call("publish")
print(delete_objects_batch.data)
Alle funktioner, der introduceres i nye versioner af Check Point-software, får straks API-opkald. Således blev der i R80.40 tilføjet funktioner som Revert to revision og Smart Task, og der blev straks forberedt tilsvarende API-opkald. Desuden får hele funktionaliteten ved overgangen fra Legacy-konsoller til Unified Policy også API-understøttelse. For eksempel blev den længe ventede opdatering i R80.40-versionen, hvor HTTPS Inspection-politikken flyttes fra Legacy-tilstand til Unified Policy-tilstand, straks forsynet med API-opkald. Her er et eksempel på kode, der tilføjer en regel øverst i HTTPS Inspection-politikken, som udelukker inspektion af 3 kategorier (Sundhed, Finans, Offentlige tjenester), som ikke må inspiceres i henhold til lovgivningen i flere lande.
Tilføj regel til HTTPS Inspection-politik
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Juridiske Krav",
"action": "bypass",
"site-category": ["Sundhed", "Offentlige tjenester / Militær", "Finansielle Tjenester"]
}
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")
Kørsel af Python-scripts på Check Point management-serveren
Det samme gælder indeholder information om, hvordan man kører scripts i Python direkte fra management-serveren. Dette kan være praktisk, når du ikke har mulighed for at tilslutte dig API-serveren fra en anden maskine. Jeg har optaget en seks minutters video, hvor jeg gennemgår installationen af modulet cpapi og egenskaberne ved at køre Python-scripts på management-serveren. Som eksempel køres et script, der automatiserer konfigurationen af en ny gateway til en opgave som netværksrevision. Security CheckUp. Blandt de udfordringer, jeg stødte på, var der i version 2.7 af Python endnu ikke blevet tilføjet en funktion input, så for at håndtere den information, som brugeren indtaster, bruges funktionen raw_input. I øvrigt er koden den samme som ved kørsel fra andre maskiner, det er bare nemmere at bruge funktionen login_as_root, så du ikke skal angive dine egne brugernavn, adgangskode og IP-adresse på management-serveren igen.
Script til hurtig opsætning af 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 client.check_fingerprint() er False:
# print("Kunne ikke få serverens fingerprint - Tjek forbindelsen til serveren.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Login fejlede:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Indtast gateway-navnet:")
gw_ip = raw_input("Indtast gateway-IP-adressen:")
if sys.stdin.isatty():
sic = getpass.getpass("Indtast engangsadgangskoden for gatewayen (SIC): ")
else:
print("Opmærksomhed! Din adgangskode vises på skærmen!")
sic = raw_input("Indtast engangsadgangskoden for gatewayen (SIC): ")
version = raw_input("Indtast gateway-versionen (f.eks. 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("Sikker forbindelse med gatewayen er ikke etableret!")
exit(1)
elif add_gw.success:
print("Gatewayen blev tilføjet succesfuldt.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Fejl ved tilføjelse af gateway - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Netværk", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("Politikken er blevet ændret succesfuldt")
else:
print("Fejl ved ændring af politikken- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Rydningsregel", "layer" : "Netværk", "action": "Accept", "track": {"type": "Detaljeret Log", "accounting": "true"}})
if change_rule.success:
print("Rydningsreglen er blevet ændret succesfuldt")
else:
print("Fejl ved ændring af rydningsreglen- {}".format(change_rule.error_message))
# offentliggør resultatet
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Ændringerne blev offentliggjort succesfuldt.")
else:
print("Fejl ved offentliggørelse af ændringerne - {}".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("Adgangspolitikken er blevet installeret")
else:
print("Fejl ved installation af adgangspolitik - {}".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("Trusselbeskyttelsespolitikken er blevet installeret")
else:
print("Fejl ved installation af trusselbeskyttelsespolitik - {}".format(install_tp_policy.error_message))
# tilføj adgangskoder og sætninger til ordbogen
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" : "Tilføj adgangskoder og sætninger", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Linje {} i adgangskodeordbogen blev tilføjet succesfuldt".format(line_num))
else:
print("Fejl ved tilføjelse af ordbogen - {}".format(add_password_dictionary.error_message))
main() Eksempel på fil med ordliste over adgangskoder additional_pass.conf
{
"passwords" : ["malware","skadelig","inficeret","Inficeret"],
"phrases" : ["adgangskode","Adgangskode","Pas","pas","kode","nøgle","pwd","adgangskode","Adgangskode","Nøgle","nøgle","kryptering","Kryptering"]
}
Konklusion
Denne artikel behandler kun de grundlæggende funktioner. Python SDK og modulet cpapi(som du måske har gættet, er dette faktisk synonymer), og ved at undersøge koden i dette modul vil du opdage endnu flere muligheder for at arbejde med det. Det er ikke usandsynligt, at du får lyst til at supplere det med dine egne klasser, funktioner, metoder og variabler. Du kan altid dele dine resultater og gennemse andre scripts til Check Point i afsnittet i fællesskabet , som forener både produktudviklere og brugere.
God kodning, og tak fordi du læste til slut!
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