Den fulla kraften i interaktion med API:er avslöjas när den används tillsammans med programkod, när det blir möjligt att dynamiskt generera API-förfrågningar och verktyg för att analysera API-svar. Det är dock fortfarande omärkligt Python Software Development Kit (hädanefter kallad Python SDK) för Check Point Management API, men förgäves. Det förenklar avsevärt livet för utvecklare och automationsentusiaster. Python har vunnit enorm popularitet på sistone och jag bestämde mig för att fylla tomrummet och se över huvudfunktionerna. . Den här artikeln fungerar som ett utmärkt tillägg till en annan artikel om Habré . Vi ska titta på hur man skriver skript med Python SDK och titta närmare på den nya Management API-funktionaliteten i version 1.6 (stödd från R80.40). För att förstå artikeln behöver du grundläggande kunskaper om att arbeta med API:er och Python.
Check Point utvecklar aktivt API:n och för tillfället har följande släppts:
- — arbeta med kontrollservern via API (och möjligheten att köra skript på gateways som kontrolleras av kontrollservern)
- — arbeta med säkerhetsgateways
- — arbetar med en sandlåda i Check Point-molnet
- — arbeta med Identity Awareness Blade på gateways
- — arbeta med SMB-gatewayhanteringsportalen ()
- — interaktion med IoT-kontroller
- - arbeta med (SD-WAN säkerhetslösning)
- - arbeta med
Python SDK stöder för närvarande endast interaktion med Management API och Gaia API. Vi kommer att titta på de viktigaste klasserna, metoderna och variablerna i denna modul.
Installation av modulen
Modul cpapi installeras snabbt och enkelt från via pip. Detaljerade installationsanvisningar finns i . Denna modul är anpassad för att fungera med Python-versionerna 2.7 och 3.7. I den här artikeln kommer exempel att ges med Python 3.7. Python SDK kan dock köras direkt från Check Point Management Server (Smart Management), men de stöder bara Python 2.7, så det sista avsnittet kommer att tillhandahålla kod för version 2.7. Direkt efter installation av modulen rekommenderar jag att du tittar på exemplen i katalogerna exempel_python2 и exempel_python3.
Komma igång
För att vi ska kunna arbeta med komponenterna i cpapi-modulen behöver vi importera från modulen cpapi minst två obligatoriska klasser:
APIClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Klass APIClientArgs är ansvarig för anslutningsparametrar till API-servern och klassen APIClient är ansvarig för interaktion med API.
Fastställande av anslutningsparametrar
För att definiera olika parametrar för att ansluta till API:t måste du skapa en instans av klassen APIClientArgs. I princip är dess parametrar fördefinierade och när skriptet körs på kontrollservern behöver de inte specificeras.
client_args = APIClientArgs()Men när du kör på en tredjepartsvärd måste du ange åtminstone IP-adressen eller värdnamnet för API-servern (även känd som hanteringsservern). I exemplet nedan definierar vi serveranslutningsparametern och tilldelar den hanteringsserverns IP-adress som en sträng.
client_args = APIClientArgs(server='192.168.47.241')Låt oss titta på alla parametrar och deras standardvärden som kan användas när du ansluter till API-servern:
Argument för metoden __init__ för klassen APIClientArgs
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 = contextJag tror att argumenten som kan användas i instanser av APIClientArgs-klassen är intuitiva för Check Point-administratörer och inte kräver ytterligare kommentarer.
Ansluter via APIClient och kontexthanterare
Klass APIClient Det bekvämaste sättet att använda det är genom kontexthanteraren. Allt som behöver skickas till en instans av APIClient-klassen är anslutningsparametrarna som definierades i föregående steg.
with APIClient(client_args) as client:
Kontexthanteraren kommer inte automatiskt att göra ett inloggningsanrop till API-servern, men det kommer att göra ett utloggningsanrop när den avslutas. Om det av någon anledning inte krävs utloggning efter att ha arbetat klart med API-anrop, måste du börja arbeta utan att använda kontexthanteraren:
client = APIClient(clieng_args)Anslutningstest
Det enklaste sättet att kontrollera om anslutningen uppfyller de angivna parametrarna är att använda metoden check_fingerprint. Om verifieringen av sha1-hashsumman för fingeravtrycket för serverns API-certifikat misslyckas (metoden returneras Falsk), då orsakas detta vanligtvis av anslutningsproblem och vi kan stoppa exekveringen av programmet (eller ge användaren möjlighet att korrigera anslutningsdata):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Observera att i framtiden klassen APIClient kommer att kontrollera varje API-anrop (metoder api_call и api_query, vi kommer att prata om dem lite längre) sha1 fingeravtryckscertifikat på API-servern. Men om, när man kontrollerar sha1-fingeravtrycket för API-servercertifikatet, ett fel upptäcks (certifikatet är okänt eller har ändrats), metoden check_fingerprint ger möjlighet att lägga till/ändra information om det på den lokala maskinen automatiskt. Denna kontroll kan inaktiveras helt (men detta kan endast rekommenderas om skript körs på själva API-servern, när du ansluter till 127.0.0.1), med APIClientArgs-argumentet - unsafe_auto_accept (se mer om APIClientArgs tidigare i "Definiera anslutningsparametrar").
client_args = APIClientArgs(unsafe_auto_accept=True)Logga in på API-server
У APIClient det finns så många som 3 metoder för att logga in på API-servern, och var och en av dem förstår innebörden sid(session-id), som används automatiskt i varje efterföljande API-anrop i rubriken (namnet i rubriken för denna parameter är X-chkp-sida), så det finns inget behov av att ytterligare bearbeta denna parameter.
inloggningsmetod
Alternativ med inloggning och lösenord (i exemplet skickas användarnamnet admin och lösenordet 1q2w3e som positionsargument):
login = client.login('admin', '1q2w3e') Ytterligare valfria parametrar är också tillgängliga i inloggningsmetoden; här är deras namn och standardvärden:
continue_last_session=False, domain=None, read_only=False, payload=NoneLogin_with_api_key metod
Alternativ med en api-nyckel (stöds från hanteringsversion R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" detta är API-nyckelvärdet för en av användarna på hanteringsservern med API-nyckelbehörighetsmetoden):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') I metod login_with_api_key samma valfria parametrar är tillgängliga som i metoden logga in.
login_as_root-metoden
Möjlighet att logga in på en lokal maskin med en API-server:
login = client.login_as_root()Det finns bara två valfria parametrar tillgängliga för denna metod:
domain=None, payload=NoneOch slutligen kallar API:et sig själva
Vi har två alternativ för att göra API-anrop genom metoder api_call и api_query. Låt oss ta reda på vad skillnaden är mellan dem.
api_call
Denna metod är tillämplig för alla samtal. Vi måste skicka den sista delen för api-anropet och nyttolasten i förfrågan om det behövs. Om nyttolasten är tom kan den inte överföras alls:
api_versions = client.api_call('show-api-versions') Utdata för denna begäran under snittet:
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 snittet:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"res_obj": {
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"status_code": 200
},
"status_code": 200,
"success": true
})
api_query
Låt mig omedelbart göra en reservation för att denna metod endast är tillämplig för samtal vars utdata involverar offset. En sådan slutledning uppstår när den innehåller eller kan innehålla en stor mängd information. Detta kan till exempel vara en begäran om en lista över alla skapade värdobjekt på hanteringsservern. För sådana förfrågningar returnerar API:et en lista med 50 objekt som standard (du kan öka gränsen till 500 objekt i svaret). Och för att inte dra informationen flera gånger, ändra offset-parametern i API-begäran, finns det en api_query-metod som gör detta automatiskt. Exempel på samtal där denna metod behövs: show-sessioner, show-värdar, show-nätverk, show-wildcards, show-grupper, show-adressintervall, show-enkla-gateways, show-enkla-kluster, show-access-roller, show-trusted-clients, show-paket. Faktum är att vi ser pluralord i namnet på dessa API-anrop, så dessa anrop blir lättare att hantera genom api_query
show_hosts = client.api_query('show-hosts') Utdata för denna begäran under snittet:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"res_obj": {
"data": {
"from": 1,
"objects": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"to": 2,
"total": 2
},
"status_code": 200
},
"status_code": 200,
"success": true
})
Bearbetar resultaten av API-anrop
Efter detta kan du använda klassens variabler och metoder APIResponse(både inom sammanhangshanteraren och utanför). På klassen APIResponse 4 metoder och 5 variabler är fördefinierade; vi kommer att uppehålla oss vid de viktigaste i mer detalj.
framgång
Till att börja med skulle det vara en bra idé att se till att API-anropet lyckades och gav ett resultat. Det finns en metod för detta framgång:
In [49]: api_versions.success
Out[49]: True
Returnerar True om API-anropet lyckades (svarskod - 200) och False om inte lyckades (någon annan svarskod). Det är bekvämt att använda direkt efter ett API-anrop för att visa olika information beroende på svarskoden.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) statuskod
Returnerar svarskoden efter att ett API-anrop har gjorts.
In [62]: api_versions.status_code
Out[62]: 400
Möjliga svarskoder: 200,400,401,403,404,409,500,501.
set_success_status
I det här fallet kan det vara nödvändigt att ändra värdet på framgångsstatusen. Tekniskt sett kan du lägga vad som helst där, till och med ett vanligt snöre. Men ett verkligt exempel skulle vara att återställa denna parameter till False under vissa medföljande förhållanden. Nedan, var uppmärksam på exemplet när det finns uppgifter som körs på hanteringsservern, men vi kommer att betrakta denna begäran som misslyckad (vi kommer att ställa in framgångsvariabeln till Falsk, trots att API-anropet lyckades och returnerade kod 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breaksvar()
Svarsmetoden låter dig se ordboken med svarskoden (status_kod) och svarstexten (kropp).
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']}}
datum
Tillåter dig att bara se brödtexten i svaret (kroppen) utan onö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']}
felmeddelande
Denna information är endast tillgänglig när ett fel uppstod under bearbetningen av API-begäran (svarskod ingen 200). Exempel utgång
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Användbara exempel
Följande är exempel som använder API-anrop som lades till i Management API 1.6.
Låt oss först titta på hur samtal fungerar add-host и add-adress-intervall. Låt oss säga att vi måste skapa alla IP-adresser för subnätet 192.168.0.0/24, vars sista oktetten är 5, som objekt av värdtypen, och skriva alla andra IP-adresser som objekt av adressintervallstypen. I det här fallet, exkludera subnätadressen och broadcastadressen.
Så nedan är ett skript som löser detta problem och skapar 50 objekt av värdtypen och 51 objekt av adressintervallstypen. För att lösa problemet krävs 101 API-anrop (det slutliga publiceringsanropet räknas inte med). Med timeit-modulen beräknar vi också hur lång tid det tar att köra skriptet tills ändringarna publiceras.
Skript med 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 labbmiljö tar det här skriptet mellan 30 och 50 sekunder att köra, beroende på belastningen på hanteringsservern.
Låt oss nu se hur man löser samma problem med ett API-anrop add-objects-batch, stöd för vilket lades till i API-version 1.6. Detta anrop låter dig skapa många objekt samtidigt i en API-förfrågan. Dessutom kan dessa vara objekt av olika typer (till exempel värdar, subnät och adressintervall). Därmed kan vår uppgift lösas inom ramen för ett API-anrop.
Skript med 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 det här skriptet i min labbmiljö tar från 3 till 7 sekunder, beroende på belastningen på hanteringsservern. Det vill säga, i genomsnitt, på 101 API-objekt, kör ett anrop av batchtyp 10 gånger snabbare. På ett större antal objekt blir skillnaden ännu mer imponerande.
Låt oss nu se hur man arbetar med set-objekt-batch. Genom att använda detta API-anrop kan vi ändra vilken parameter som helst. Låt oss ställa in den första hälften av adresserna från föregående exempel (upp till .124 värdar, och intervall också) till färgen sienna, och tilldela färgen khaki till den andra hälften av adresserna.
Ändra färgen på objekten som skapades i föregående exempel
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")
Du kan ta bort flera objekt i ett API-anrop med hjälp av ta bort-objekt-batch. Låt oss nu titta på ett kodexempel som tar bort alla värdar som skapats tidigare via add-objects-batch.
Ta bort objekt med delete-objects-batch
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)
Alla funktioner som visas i nya versioner av Check Point-mjukvaran får omedelbart API-anrop. I R80.40 dök alltså upp sådana "funktioner" som Återgå till revision och Smart Task, och motsvarande API-anrop förbereddes omedelbart för dem. Dessutom får all funktionalitet när man flyttar från äldre konsoler till Unified Policy-läge också API-stöd. Till exempel var den efterlängtade uppdateringen i mjukvaruversion R80.40 flyttningen av HTTPS-inspektionspolicyn från Legacy-läge till Unified Policy-läge, och denna funktion fick omedelbart API-anrop. Här är ett exempel på kod som lägger till en regel till toppositionen i HTTPS-inspektionspolicyn som utesluter 3 kategorier från inspektion (hälsa, ekonomi, statliga tjänster), som är förbjudna från inspektion i enlighet med lagen i ett antal länder.
Lägg till en regel i HTTPS-inspektionspolicyn
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-hanteringsservern
Allting är det samma innehåller information om hur man kör Python-skript direkt från kontrollservern. Detta kan vara praktiskt när du inte kan ansluta till API-servern från en annan maskin. Jag spelade in en sex minuters video där jag tittar på hur jag installerar modulen cpapi och funktioner för att köra Python-skript på kontrollservern. Som ett exempel körs ett skript som automatiserar konfigurationen av en ny gateway för en uppgift som nätverksrevision Säkerhetskontroll. Bland funktionerna som jag var tvungen att ta itu med: funktionen har ännu inte dykt upp i Python 2.7 ingång, så för att bearbeta informationen som användaren anger används en funktion rå_ingång. Annars är koden densamma som för att starta från andra maskiner, bara det är bekvämare att använda funktionen login_as_root, för att inte ange ditt eget användarnamn, lösenord och IP-adress för hanteringsservern igen.
Skript för snabb installation av säkerhetskontroll
from __future__ import print_function
import getpass
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from cpapi import APIClient, APIClientArgs
def main():
with APIClient() as client:
# if client.check_fingerprint() is False:
# print("Could not get the server's fingerprint - Check connectivity with the server.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Login failed:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Enter the gateway name:")
gw_ip = raw_input("Enter the gateway IP address:")
if sys.stdin.isatty():
sic = getpass.getpass("Enter one-time password for the gateway(SIC): ")
else:
print("Attention! Your password will be shown on the screen!")
sic = raw_input("Enter one-time password for the gateway(SIC): ")
version = raw_input("Enter the gateway version(like 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("Secure connection with the gateway hasn't established!")
exit(1)
elif add_gw.success:
print("The gateway was added successfully.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Failed to add the gateway - {}".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("The policy has been changed successfully")
else:
print("Failed to change the policy- {}".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("The cleanup rule has been changed successfully")
else:
print("Failed to change the cleanup rule- {}".format(change_rule.error_message))
# publish the result
publish_res = client.api_call("publish", {})
if publish_res.success:
print("The changes were published successfully.")
else:
print("Failed to publish the changes - {}".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("The access policy has been installed")
else:
print("Failed to install access policy - {}".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("The threat prevention policy has been installed")
else:
print("Failed to install threat prevention policy - {}".format(install_tp_policy.error_message))
# add passwords and passphrases to dictionary
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" : "Add passwords and passphrases", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("The password dictionary line {} was added successfully".format(line_num))
else:
print("Failed to add the dictionary - {}".format(add_password_dictionary.error_message))
main() En exempelfil med en lösenordslexikon additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Slutsats
Den här artikeln undersöker endast de grundläggande möjligheterna med arbete Python SDK och modul cpapi(som du kanske har gissat är dessa faktiskt synonymer), och genom att studera koden i denna modul kommer du att upptäcka ännu fler möjligheter att arbeta med den. Det är möjligt att du vill komplettera den med dina egna klasser, funktioner, metoder och variabler. Du kan alltid dela ditt arbete och se andra skript för Check Point i avsnittet i samhället , som samlar både produktutvecklare och användare.
Lycka till med kodningen och tack för att du läste till slutet!
Källa: will.com