All the power of API interaction is revealed when used in conjunction with programming code, allowing for dynamic API requests and tools for analyzing API responses. However, it still remains somewhat unnoticed Python Software Development Kit (hereinafter referred to as Python SDK) for Check Point Management API, which is a pity. It significantly simplifies life for developers and automation enthusiasts. Python has gained immense popularity recently, and I decided to fill in the gap and make an overview of the main features . This article serves as a great supplement to another article on Habr . We will consider how to write scripts using the Python SDK and focus more on the new features of the Management API in version 1.6 (supported starting from R80.40). Basic knowledge of API and Python is required to understand the article.
Check Point actively develops its API, and currently, we have seen the emergence of:
- â working with the management server through the API (and the ability to execute scripts on gateways managed by the management server)
- â working with security gateways
- â working with the sandbox in the Check Point cloud
- â working with the Identity Awareness blade on gateways
- â working with the SMB gateway management portal ()
- â interaction with IoT controllers
- â working with (SD-WAN security solution)
- â working with
The Python SDK currently supports interaction only with the Management API and Gaia API. We will look at the most important classes, methods, and variables in this module.
Installing the module
Modul cpapi is quick and easy to install from med hjÀlp av pip. A detailed installation guide is available in . This module is adapted to work with Python versions 2.7 and 3.7. In this article, examples will be provided using Python 3.7. However, the Python SDK can be run directly from the Check Point management server (Smart Management), but it only supports version 2.7, so the last section will include code for version 2.7. Immediately after installing the module, I recommend looking at the examples in the directories examples_python2 och examples_python3.
Komma igÄng
To be able to work with the components of the cpapi module, we need to import from the module cpapi minst tvÄ nödvÀndiga klasser:
APIClient och APIClientArgs
frÄn cpapi importera APIClient, APIClientArgs
Klassen APIClientArgs ansvarar för anslutningsparametrarna till API-servern, och klassen APIClient ansvarar för interaktionen med API:n.
Definiera anslutningsparametrar
För att definiera olika anslutningsparametrar till API:t mÄste du skapa en instans av klassen APIClientArgs. I princip Àr dess parametrar förutbestÀmda och vid körning av skriptet pÄ administrationsservern behöver de inte anges.
client_args = APIClientArgs()Men vid körning pÄ en tredje parts vÀrd mÄste du ange minst IP-adressen eller vÀrdnamnet för API-servern (administrationsservern). I exemplet nedan definierar vi anslutningsparametern server och tilldelar den som en strÀng IP-adressen till administrationsservern.
client_args = APIClientArgs(server='192.168.47.241')LÄt oss titta pÄ alla parametrar och deras standardvÀrden som kan anvÀndas vid anslutning till API-servern:
Argumenten för __init__-metoden i klassen APIClientArgs
class APIClientArgs:
"""
Denna klass tillhandahÄller argument för APIClient-konfiguration.
Alla argument Àr konfigurerade med sina standardvÀrden.
"""
# port sÀtts till None som standard, men det ersÀtts med 443 om det inte anges
# möjliga vÀrden för kontext - 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
# fingerprint för administrationsservern
self.fingerprint = fingerprint
# sessions-id.
self.sid = sid
# namn eller IP-adress för administrationsservern
self.server = server
# debug-nivÄ
self.http_debug_level = http_debug_level
# en array med alla API-anrop (för debug-ÀndamÄl)
self.api_calls = api_calls om api_calls annars []
# namn pÄ debuggfil. Om den lÀmnas tom, sparas inte debugdata pÄ disk.
self.debug_file = debug_file
# HTTP-proxyserverns adress (utan "http://")
self.proxy_host = proxy_host
# HTTP-proxyport
self.proxy_port = proxy_port
# API-version för administrationsservern
self.api_version = api_version
# Indikerar att klienten inte ska kontrollera serverns certifikat
self.unsafe = unsafe
# Indikerar att klienten automatiskt ska acceptera och spara serverns certifikat
self.unsafe_auto_accept = unsafe_auto_accept
# Kontexten för anvÀndning av klienten - standard Àr web_api
self.context = contextJag tror att de argument som kan anvÀndas i instanser av klassen APIClientArgs Àr intuitivt tydliga för Check Point-administratörer och inte behöver nÄgra ytterligare kommentarer.
Anslut genom APIClient och kontextförvaltaren
Klassen APIClient Àr lÀttast att anvÀnda genom kontextförvaltaren. Allt som behövs Àr att överföra instansen av klassen APIClient de anslutningsparametrar som definierades i föregÄende steg.
med APIClient(client_args) som klient:
Kontextförvaltaren kommer inte automatiskt att göra ett login-anrop till API-servern, men den kommer att göra ett logout-anrop nÀr du loggar ut frÄn den. Om logout inte behövs efter att du har arbetat med API-anrop, behöver du börja arbetet utan att anvÀnda kontextförvaltaren:
client = APIClient(client_args)Kontroll av anslutning
Det enklaste sÀttet att kontrollera om anslutningen fungerar enligt angivna parametrar Àr att anvÀnda metoden check_fingerprint. Om kontrollen av sha1-hashvÀrdet för fingerprint-certifikatet pÄ API-servern inte lyckas (metoden returnerade Falskt), beror det vanligtvis pÄ anslutningsproblem, och vi kan stoppa programkörningen (eller ge anvÀndaren möjlighet att rÀtta anslutningsuppgifterna):
if client.check_fingerprint() is False:
print("Kunde inte hÀmta serverns fingerprint - Kontrollera anslutningen till servern.")
exit(1)
TĂ€nk pĂ„ att klassen APIClient kommer att kontrollera sha1-fingerprint-certifikatet pĂ„ API-servern vid varje API-anrop (metoderna api_call och api_query, som behandlas lĂ€ngre fram) för fingerprintet. Om ett fel upptĂ€cks vid kontrollen av sha1-fingerprint-certifikatet pĂ„ API-servern (certifikatet Ă€r okĂ€nt eller har Ă€ndrats), kommer metoden check_fingerprint att ge möjlighet att lĂ€gga till/Ă€ndra information om det pĂ„ den lokala maskinen automatiskt. Denna kontroll kan helt stĂ€ngas av (men detta rekommenderas endast om skripten körs pĂ„ sjĂ€lva API-servern, vid anslutning till 127.0.0.1) med hjĂ€lp av argumentet APIClientArgs â unsafe_auto_accept (mer information om APIClientArgs finns tidigare i "Definiera anslutningsparametrar").
client_args = APIClientArgs(unsafe_auto_accept=True)Login till API-server
Hos APIClient det finns hela 3 metoder för inloggning pĂ„ API-server, och var och en sparar vĂ€rdet sid(session-id), som anvĂ€nds automatiskt i varje efterföljande API-anrop i huvudrubriken (namnet i rubriken för denna parameter â X-chkp-sid), sĂ„ det Ă€r inte nödvĂ€ndigt att hantera denna parameter separat.
Metod login
Alternativet med anvÀndarnamn och lösenord (i exemplet Àr anvÀndarnamnet admin och lösenordet 1q2w3e angivet som positionella argument):
login = client.login('admin', '1q2w3e') Vid login-metoden finns ocksÄ ytterligare valfria parametrar, jag anger deras namn och standardvÀrden:
continue_last_session=False, domain=None, read_only=False, payload=NoneMetod login_with_api_key
Alternativet med anvÀndning av api-nyckel (stöds frÄn och med version R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" detta Àr API-nyckelvÀrdet för en av anvÀndarna pÄ administrationsservern med API-nyckel autentiseringsmetod):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') I metoden login_with_api_key finns samma valfria parametrar som i metoden login.
Metoden login_as_root
Alternativ för att logga in pÄ den lokala maskinen med API-servern:
login = client.login_as_root()För denna metod finns det endast tvÄ valfria parametrar:
domain=None, payload=NoneOch slutligen sjÀlva API-anropen
Vi har tvÄ alternativ för att göra API-anrop via metoder api_call och api_query. LÄt oss titta nÀrmare pÄ skillnaden mellan dem.
api_call
Denna metod kan tillÀmpas pÄ vilket anrop som helst. Vi mÄste skicka den sista delen för api-anropet och payload i begÀrans kropp vid behov. Om payload Àr tomt kan det helt enkelt utelÀmnas:
api_versions = client.api_call('show-api-versions') Utdata för denna begÀran under kat:
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'})Utdata för denna begÀran under kat:
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
Jag vill omedelbart klargöra att denna metod endast Àr tillÀmplig för anrop vars utdata förvÀntar sig offset (förskjutning). SÄdan utdata sker nÀr den innehÄller eller kan innehÄlla en stor mÀngd information. Till exempel kan detta vara en begÀran om att lista alla skapade objekt av typen vÀrd pÄ administrationsservern. För sÄdana förfrÄgningar returnerar API:t som standard en lista med 50 objekt (grÀnsen kan ökas till 500 objekt i svaret). För att inte behöva hÀmta information flera gÄnger genom att Àndra offset-parametern i API-förfrÄgan finns det en metod api_query som automatiskt utför detta arbete. Exempel pÄ anrop dÀr denna metod behövs: 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. I sjÀlva verket ser vi ord i plural i namnen pÄ dessa API-anrop, sÄ det blir lÀttare att hantera dessa anrop genom api_query
show_hosts = client.api_query('show-hosts') Utdata för denna begÀran under kat:
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
})
Bearbetning av API-anropets resultat
Efter detta kan du anvÀnda variabler och metoder i klassen APIResponse(bÄde inuti kontextförvaltaren och utanför). Klassen APIResponse har 4 förutbestÀmda metoder och 5 variabler, vi kommer att stanna vid de mest viktiga.
success
För att börja skulle det vara bra att sÀkerstÀlla att API-anropet gick igenom framgÄngsrikt och returnerade ett resultat. För detta finns det en metod success:
I [49]: api_versions.success
Out[49]: True
Returnerar True om API-anropet lyckades (statuskod 200) och False om det misslyckades (vilken annan statuskod som helst). LÀtt att anvÀnda direkt efter API-anropet för att visa olika information beroende pÄ statuskod.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuskod
Returnerar statuskoden efter utförande av API-anropet.
I [62]: api_versions.status_code
Out[62]: 400
Möjliga statuskoder: 200,400,401,403,404,409,500,501.
set_success_status
Det kan vara nödvÀndigt att Àndra vÀrdet för success-status. Tekniskt kan vad som helst placeras dÀr, till och med en vanlig strÀng. Men ett verkligt exempel kan vara att ÄterstÀlla denna parameter till False under vissa omstÀndigheter. Observera nedan ett exempel dÀr det finns uppgifter som utförs pÄ hanteringsservern, men vi kommer att betrakta denna begÀran som misslyckad (vi sÀtter variabeln success till Falskt, trots att API-anropet var framgÄngsrikt och ÄtervÀnde kod 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 gör det möjligt att se en ordbok med svarskoden (status_code) och svarets kropp (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
Möjliggör att endast se svarets kropp (body) utan överflödig information.
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
Denna information Àr endast tillgÀnglig nÀr ett fel har intrÀffat under behandlingen av API-anropet (svarskod inte 200). Exempel pÄ utdata
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Nyttiga exempel
Nedan listas exempel dÀr API-anrop har anvÀnts, vilka har lagts till i version Management API 1.6.
LÄt oss först övervÀga hur anropen fungerar add-host och add-address-range. Anta att vi behöver skapa IP-adresser av typen host för alla IP-adresser i subnettet 192.168.0.0/24, dÀr den sista oktetten Àr 5, och alla övriga IP-adresser skall skrivas som objekt av typen adressering. Vidare sÀtts subnettets och broadcast-adressen som undantag.
SÄ, nedan presenteras ett skript som löser denna uppgift och skapar 50 objekt av typen host och 51 objekt av typen adressering. För att lösa uppgiften krÀvs 101 API-anrop (exklusive det avslutande anropet publicera). Dessutom anvÀnder vi modulen timeit för att berÀkna tidsÄtgÄngen för skriptet fram till publiceringen av Àndringarna.
Skriptet med anvÀndning av add-host och 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 min laboratoriemiljö tar det mellan 30 och 50 sekunder att köra detta skript beroende pÄ belastningen pÄ styrservern.
LÄt oss nu se hur vi kan lösa samma uppgift med hjÀlp av API-anrop add-objects-batch, vilket stöddes i API-version 1.6. Detta anrop gör det möjligt att skapa flera objekt med ett enda API-anrop. Detta kan vara objekt av olika typer (t.ex. vÀrdar, subnÀt och adressintervall). PÄ sÄ sÀtt kan vÄr uppgift lösas inom ett enda API-anrop.
Skript som anvÀnder 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')
Och att köra detta skript i min laboratoriemiljö tar mellan 3 och 7 sekunder beroende pÄ belastningen pÄ styrservern. Det betyder att ett API-anrop av typen batch, i genomsnitt, körs 10 gÄnger snabbare med 101 objekt. Vid fler objekt blir skillnaden Ànnu mer imponerande.
LÄt oss nu titta pÄ hur vi arbetar med set-objects-batch. Med hjÀlp av detta API-anrop kan vi massÀndra vilken parameter som helst. LÄt oss stÀlla in den första halvan av adresserna frÄn det föregÄende exemplet (upp till .124 för vÀrden, samt för intervallen) till fÀrgen sienna, medan den andra halvan av adresserna fÄr fÀrgen khaki.
Ăndring av fĂ€rgen pĂ„ objekten som skapades i det föregĂ„ende exemplet
frÄn cpapi importera 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 = []
för ip i range(5,125,5):
data = {"name": f'h_192.168.0.{ip}', "color": "sienna"}
objects_list_ip_first.append(data)
för ip i 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
}]
}
med APIClient(client_args) som klient:
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")
För att ta bort flera objekt i en API-anrop kan man anvÀnda delete-objects-batch. Nu ska vi titta pÄ ett kodexempel som tar bort alla vÀrdar som skapades tidigare genom add-objects-batch.
Borttagning av objekt med hjÀlp av delete-objects-batch
frÄn cpapi importera APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
för ip i 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
}]
}
med APIClient(client_args) som klient:
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)
Alla funktioner som dyker upp i nya versioner av Check Point-programvaran fÄr snart ocksÄ API-anrop. I R80.40 infördes funktioner som Revert to revision och Smart Task, vars motsvarande API-anrop bereddes direkt. Dessutom fÄr all funktionalitet som övergÄr frÄn Legacy-konsoler till lÀget Unified Policy ocksÄ stöd för API. Till exempel blev det efterlÀngtade uppdateringen i version R80.40 flytten av HTTPS Inspection-policyn frÄn Legacy-lÀget till Unified Policy-lÀget, och denna funktionalitet fick omedelbart API-anrop. HÀr Àr ett kodexempel som lÀgger till en regel i topplÀget för HTTPS Inspection-policyn, som undantar tre kategorier (HÀlsa, Finans, Statliga tjÀnster) som inte fÄr inspekteras enligt lagstiftningen i flera lÀnder.
LĂ€gg till en regel i HTTPS Inspection-policyn
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")
Kör Python-skript pÄ Check Point managementserver
Samma sak gÀller innehÄller information om hur man kör Python-skript direkt frÄn managementservern. Det kan vara anvÀndbart nÀr du inte har möjlighet att ansluta till API-servern frÄn en annan maskin. Jag har spelat in en sex minuter lÄng video dÀr jag gÄr igenom installationen av modulen cpapi och detaljerna kring att köra Python-skript pÄ managementservern. Som exempel körs ett skript som automatiserar konfigurationen av en ny gateway för uppgifter som nÀtverksrevision. Security CheckUp. Bland de utmaningar jag stötte pÄ: i version Python 2.7 fanns Ànnu inte funktionen input, sÄ för att hantera information som anvÀndaren matar in anvÀnds funktionen raw_input. I övrigt Àr koden densamma som för körning frÄn andra maskiner, det Àr bara bekvÀmare att anvÀnda funktionen login_as_root, sÄ man slipper ange sitt eget anvÀndarnamn, lösenord och IP-adress till managementservern igen.
Skript för snabb instÀllning av Security CheckUp
frÄn __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:
# om client.check_fingerprint() Àr False:
# print("Kunde inte hÀmta serverns fingeravtryck - Kontrollera anslutningen till servern.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Inloggning misslyckades:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Ange gatewaynamnet:")
gw_ip = raw_input("Ange gatewayns IP-adress:")
if sys.stdin.isatty():
sic = getpass.getpass("Ange engÄngslösenord för gatewayn (SIC): ")
else:
print("Observera! Ditt lösenord kommer att visas pÄ skÀrmen!")
sic = raw_input("Ange engÄngslösenord för gatewayn (SIC): ")
version = raw_input("Ange gatewayns version (som 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'] != "kommunicerar":
print("SĂ€ker anslutning med gatewayn har inte etablerats!")
exit(1)
elif add_gw.success:
print("Gatewayn lades till framgÄngsrikt.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Misslyckades med att lÀgga till gatewayn - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "NĂ€tverk", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("Policyn har Àndrats framgÄngsrikt")
else:
print("Misslyckades med att Àndra policyn- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Rensningsregel", "layer" : "NĂ€tverk", "action": "Acceptera", "track": {"type": "Detaljerad logg", "accounting": "true"}})
if change_rule.success:
print("Rensningsregeln har Àndrats framgÄngsrikt")
else:
print("Misslyckades med att Àndra rensningsregeln- {}".format(change_rule.error_message))
# publicera resultatet
publish_res = client.api_call("publish", {})
if publish_res.success:
print("Ăndringarna publicerades framgĂ„ngsrikt.")
else:
print("Misslyckades med att publicera Àndringarna - {}".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("Ă
tkomstpolicyn har installerats")
else:
print("Misslyckades med att installera Ă„tkomstpolicyn - {}".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("Hotförebyggande policyn har installerats")
else:
print("Misslyckades med att installera hotförebyggande policyn - {}".format(install_tp_policy.error_message))
# lÀgg till lösenord och fraser till 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" : "LÀgg till lösenord och fraser", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("Raden {} i lösenordsordboken lades till framgÄngsrikt".format(line_num))
else:
print("Misslyckades med att lÀgga till ordboken - {}".format(add_password_dictionary.error_message))
main() Exempelfil med lösenordsordlista additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","lösenord","Lösenord","Nyckel","nyckel","kryptering","Kryptering"]
}
Slutsats
Denna artikel behandlar endast de grundlÀggande funktionerna för arbete Python SDK och modulen cpapi(som du kanske har gissat Àr detta i praktiken synonymer), och genom att studera koden i denna modul kommer du att upptÀcka Ànnu fler möjligheter till arbete med den. Det Àr inte osannolikt att du fÄr en önskan att komplettera den med dina egna klasser, funktioner, metoder och variabler. Du kan alltid dela dina resultat och se andra skript för Check Point i avsnittet i gemenskapen , som förenar bÄde produktutvecklare och anvÀndare.
Trevlig kodning och tack för att du lÀste hela vÀgen till slut!
KĂ€lla: habr.com
