API-ների հետ փոխգործակցության ողջ ուժը բացահայտվում է, երբ օգտագործվում է ծրագրի կոդի հետ միասին, երբ հնարավոր է դառնում դինամիկ ձևավորել API հարցումներ և գործիքներ՝ API-ի պատասխանները վերլուծելու համար: Այնուամենայնիվ, դա դեռևս աննկատ է մնում Python Ծրագրային ապահովման մշակման հավաքածու (այսուհետ՝ Python SDK) համար Check Point Management API, բայց ապարդյուն։ Այն զգալիորեն հեշտացնում է մշակողների և ավտոմատացման սիրահարների կյանքը: Python-ը վերջերս հսկայական ժողովրդականություն է ձեռք բերել, և ես որոշեցի լրացնել բացը և վերանայել հիմնական հատկանիշները: . Այս հոդվածը հիանալի լրացում է Habré-ի մեկ այլ հոդվածի համար . Մենք կդիտարկենք, թե ինչպես գրել սկրիպտներ՝ օգտագործելով Python SDK-ն և ավելի մոտիկից կանդրադառնանք կառավարման նոր API գործառույթին 1.6 տարբերակում (աջակցվում է սկսած R80.40-ից): Հոդվածը հասկանալու համար ձեզ հարկավոր են API-ների և Python-ի հետ աշխատելու հիմնական գիտելիքներ:
Check Point-ը ակտիվորեն մշակում է API-ն և այս պահին թողարկվել են հետևյալը.
- — աշխատել կառավարման սերվերի հետ API-ի միջոցով (և հսկիչ սերվերի կողմից վերահսկվող դարպասների վրա սկրիպտներ գործարկելու հնարավորություն)
- — աշխատել անվտանգության դարպասների հետ
- — աշխատել ավազարկղի հետ Check Point ամպում
- — աշխատել Identity Awareness blade-ի հետ դարպասների վրա
- — աշխատել SMB gateway կառավարման պորտալի հետ ()
- — փոխազդեցություն IoT կարգավորիչների հետ
- - աշխատել հետ (SD-WAN անվտանգության լուծում)
- - աշխատել հետ
Python SDK-ն ներկայումս աջակցում է միայն կառավարման API-ի հետ փոխգործակցությանը և Gaia API. Մենք կանդրադառնանք այս մոդուլի ամենակարևոր դասերին, մեթոդներին և փոփոխականներին:
Մոդուլի տեղադրում
Մոդուլ cpapi տեղադրվում է արագ և հեշտությամբ միջոցով ծվծվալ. Տեղադրման մանրամասն հրահանգները հասանելի են . Այս մոդուլը հարմարեցված է Python 2.7 և 3.7 տարբերակների հետ աշխատելու համար: Այս հոդվածում օրինակներ կբերվեն Python 3.7-ի միջոցով: Այնուամենայնիվ, Python SDK-ն կարող է ուղղակիորեն գործարկվել Check Point Management Server-ից (Smart Management), բայց նրանք աջակցում են միայն Python 2.7-ին, ուստի վերջին բաժինը կտրամադրի կոդը 2.7 տարբերակի համար: Մոդուլը տեղադրելուց անմիջապես հետո խորհուրդ եմ տալիս դիտել դիրեկտորիաների օրինակները օրինակներ_python2 и օրինակներ_python3.
Ինչից սկսել
Որպեսզի մենք կարողանանք աշխատել cpapi մոդուլի բաղադրիչների հետ, մենք պետք է ներմուծենք մոդուլից cpapi առնվազն երկու պարտադիր դաս.
APIClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Դաս APIClientArgs պատասխանատու է API սերվերի և դասի միացման պարամետրերի համար APIClient պատասխանատու է API-ի հետ փոխգործակցության համար:
Միացման պարամետրերի որոշում
API-ին միանալու տարբեր պարամետրեր սահմանելու համար հարկավոր է դասի օրինակ ստեղծել APIClientArgs. Սկզբունքորեն, դրա պարամետրերը նախապես սահմանված են, և սկրիպտը կառավարման սերվերի վրա գործարկելիս դրանք ճշգրտման կարիք չունեն:
client_args = APIClientArgs()Բայց երբ աշխատում է երրորդ կողմի հոսթով, դուք պետք է նշեք API սերվերի առնվազն IP հասցեն կամ հոսթի անունը (հայտնի է նաև որպես կառավարման սերվեր): Ստորև բերված օրինակում մենք սահմանում ենք սերվերի միացման պարամետրը և դրան վերագրում կառավարման սերվերի IP հասցեն որպես տող:
client_args = APIClientArgs(server='192.168.47.241')Եկեք նայենք բոլոր պարամետրերին և դրանց լռելյայն արժեքներին, որոնք կարող են օգտագործվել API սերվերին միանալիս.
APIClientArgs դասի __init__ մեթոդի փաստարկները
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Կարծում եմ, որ փաստարկները, որոնք կարող են օգտագործվել APIClientArgs դասի օրինակներում, ինտուիտիվ են Check Point-ի ադմինիստրատորների համար և չեն պահանջում լրացուցիչ մեկնաբանություններ:
Միացում APIClient-ի և համատեքստի կառավարչի միջոցով
Դաս APIClient Այն օգտագործելու ամենահարմար տարբերակը համատեքստի կառավարչի միջոցով է: Այն ամենը, ինչ պետք է փոխանցվի APIClient դասի օրինակին, կապի պարամետրերն են, որոնք սահմանված էին նախորդ քայլում:
with APIClient(client_args) as client:
Համատեքստի կառավարիչը ինքնաբերաբար մուտքի զանգ չի կատարի API սերվերին, բայց դուրս գալուց դուրս կգա: Եթե API-ի զանգերի հետ աշխատանքն ավարտելուց հետո ինչ-ինչ պատճառներով դուրս գալը չի պահանջվում, դուք պետք է սկսեք աշխատել առանց համատեքստի կառավարիչ օգտագործելու.
client = APIClient(clieng_args)Միացման փորձարկում
Ստուգելու ամենահեշտ ձևը, թե արդյոք կապը համապատասխանում է նշված պարամետրերին, մեթոդի օգտագործումն է check_մատնահետք. Եթե սերվերի API վկայագրի մատնահետքի sha1 հաշ գումարի ստուգումը ձախողվի (մեթոդը վերադարձվել է Կեղծ), ապա դա սովորաբար պայմանավորված է կապի հետ կապված խնդիրներով, և մենք կարող ենք դադարեցնել ծրագրի կատարումը (կամ օգտվողին հնարավորություն տալ շտկել կապի տվյալները).
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Խնդրում ենք նկատի ունենալ, որ ապագայում դաս APIClient կստուգի յուրաքանչյուր API զանգ (մեթոդներ api_call и api_query, դրանց մասին մի փոքր ավելի կխոսենք) sha1 մատնահետքի վկայագիր API սերվերի վրա։ Բայց եթե API սերվերի վկայագրի sha1 մատնահետքը ստուգելիս սխալ է հայտնաբերվում (վկայագիրը անհայտ է կամ փոխված է), մեթոդը. check_մատնահետք հնարավորություն կտա ավտոմատ կերպով ավելացնել/փոխել դրա մասին տեղեկատվությունը տեղական մեքենայի վրա: Այս ստուգումը կարող է ամբողջությամբ անջատվել (սակայն դա կարող է առաջարկվել միայն այն դեպքում, եթե սկրիպտները գործարկվեն հենց API սերվերի վրա, երբ միանում եք 127.0.0.1-ին), օգտագործելով APIClientArgs արգումենտը. unsafe_auto_accept (Տես ավելին APIClientArgs-ի մասին ավելի վաղ «Կապի պարամետրերի սահմանում» բաժնում):
client_args = APIClientArgs(unsafe_auto_accept=True)Մուտք գործեք API սերվեր
У APIClient API սերվեր մուտք գործելու 3 եղանակ կա, և դրանցից յուրաքանչյուրը հասկանում է իմաստը Sid(sesion-id), որն ինքնաբերաբար օգտագործվում է վերնագրում API-ի յուրաքանչյուր հաջորդ կանչում (այս պարամետրի վերնագրի անվանումն է՝ X-chkp-sid), այնպես որ այս պարամետրի հետագա մշակման կարիք չկա:
մուտքի մեթոդ
Մուտք և գաղտնաբառ օգտագործող տարբերակ (օրինակ, օգտվողի անունը admin և գաղտնաբառը 1q2w3e փոխանցվում են որպես դիրքային փաստարկներ).
login = client.login('admin', '1q2w3e') Լրացուցիչ կամընտիր պարամետրերը հասանելի են նաև մուտքի մեթոդում, ահա դրանց անունները և լռելյայն արժեքները.
continue_last_session=False, domain=None, read_only=False, payload=Nonelogin_with_api_key մեթոդը
Ընտրանք՝ օգտագործելով api բանալի (աջակցվում է R80.40/Management API v1.6 կառավարման տարբերակից, "3TsbPJ8ZKjaJGvFyoFqHFA==" սա API բանալի արժեքն է կառավարման սերվերի օգտատերերից մեկի համար՝ API բանալու թույլտվության մեթոդով).
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Մեթոդի մեջ login_with_api_key նույն ընտրովի պարամետրերը հասանելի են ինչպես մեթոդում Նոր որոնում.
login_as_root մեթոդը
API սերվերով տեղական մեքենա մուտք գործելու տարբերակ.
login = client.login_as_root()Այս մեթոդի համար հասանելի է միայն երկու կամընտիր պարամետր.
domain=None, payload=NoneԵվ վերջապես API-ն իրեն անվանում է
Մեթոդների միջոցով API զանգեր կատարելու երկու տարբերակ ունենք api_call и api_query. Եկեք պարզենք, թե որն է նրանց միջև տարբերությունը:
api_call
Այս մեթոդը կիրառելի է ցանկացած զանգի համար: Անհրաժեշտության դեպքում անհրաժեշտության դեպքում մենք պետք է անցկացնենք վերջին մասը api-ի զանգի և ծանրաբեռնվածության հարցում: Եթե օգտակար բեռը դատարկ է, ապա այն ընդհանրապես չի կարող փոխանցվել.
api_versions = client.api_call('show-api-versions') Այս հարցման համար ելք՝ կտրվածքից ցածր՝
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'})Այս հարցման համար ելք՝ կտրվածքից ցածր՝
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
Թույլ տվեք անմիջապես վերապահել, որ այս մեթոդը կիրառելի է միայն այն զանգերի համար, որոնց ելքը ներառում է օֆսեթ: Նման եզրակացությունը տեղի է ունենում, երբ այն պարունակում է կամ կարող է պարունակել մեծ քանակությամբ տեղեկատվություն: Օրինակ, սա կարող է լինել կառավարման սերվերի վրա ստեղծված բոլոր հյուրընկալող օբյեկտների ցանկի հարցում: Նման հարցումների դեպքում API-ն լռելյայն վերադարձնում է 50 օբյեկտների ցանկ (պատասխանում կարող եք սահմանաչափը հասցնել 500 օբյեկտի): Եվ որպեսզի տեղեկատվությունը մի քանի անգամ չքաշվի՝ փոխելով օֆսեթ պարամետրը API հարցումում, կա api_query մեթոդ, որն ավտոմատ կերպով կատարում է այս աշխատանքը։ Զանգերի օրինակներ, որտեղ անհրաժեշտ է այս մեթոդը. շոու-սեանսներ, շոու-հաղորդավարներ, շոու-ցանցեր, շոու-վայրի քարտեր, շոու-խմբեր, ցույց-հասցե-տիրույթներ, շոու-պարզ դարպասներ, ցուցադրում-պարզ-կլաստերներ, ցուցադրում-մուտքի-դերեր, ցուցադրում-վստահելի-հաճախորդներ, շոու-փաթեթներ. Փաստորեն, այս API զանգերի անվանման մեջ մենք տեսնում ենք հոգնակի բառեր, ուստի այս զանգերը ավելի հեշտ կլինի կարգավորել: api_query
show_hosts = client.api_query('show-hosts') Այս հարցման համար ելք՝ կտրվածքից ցածր՝
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
})
API զանգերի արդյունքների մշակում
Դրանից հետո դուք կարող եք օգտագործել դասի փոփոխականները և մեթոդները APIresponse(ինչպես համատեքստի կառավարչի ներսում, այնպես էլ դրսում): Դասարանում APIresponse Նախապես սահմանված են 4 մեթոդ և 5 փոփոխական, մենք ավելի մանրամասն կանդրադառնանք ամենակարևորներին:
հաջողություն
Սկզբից լավ գաղափար կլիներ համոզվել, որ API-ի զանգը հաջող է եղել և արդյունք է տվել: Դրա համար կա մի մեթոդ հաջողություն:
In [49]: api_versions.success
Out[49]: True
Վերադարձնում է True, եթե API-ի զանգը հաջող էր (պատասխանի կոդը՝ 200) և False, եթե ոչ հաջողված (ցանկացած այլ պատասխանի կոդ): Այն հարմար է օգտագործել API-ի զանգից անմիջապես հետո՝ տարբեր տեղեկություններ ցուցադրելու համար՝ կախված պատասխանի կոդից:
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) կարգավիճակի կոդը
Վերադարձնում է պատասխանի կոդը API-ի զանգ կատարելուց հետո:
In [62]: api_versions.status_code
Out[62]: 400
Պատասխանի հնարավոր կոդերը. 200,400,401,403,404,409,500,501.
set_success_status
Այս դեպքում կարող է անհրաժեշտ լինել փոխել հաջողության կարգավիճակի արժեքը: Տեխնիկապես, դուք կարող եք այնտեղ տեղադրել ցանկացած բան, նույնիսկ սովորական լարը: Բայց իրական օրինակ կարող է լինել այս պարամետրը False-ի վերակայումը որոշակի ուղեկցող պայմաններում: Ստորև ուշադրություն դարձրեք այն օրինակին, երբ կան առաջադրանքներ, որոնք աշխատում են կառավարման սերվերի վրա, բայց մենք այս հարցումը կհամարենք անհաջող (մենք կսահմանենք հաջողության փոփոխականը. Կեղծ, չնայած այն հանգամանքին, որ API-ի զանգը հաջող էր և վերադարձրեց 200 կոդը):
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakպատասխան ()
Արձագանքման մեթոդը թույլ է տալիս բառարանը դիտել պատասխանի կոդով (status_code) և պատասխանի մարմնի (մարմին):
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']}}
տվյալներ
Թույլ է տալիս տեսնել միայն պատասխանի մարմինը (մարմինը) առանց ավելորդ տեղեկատվության:
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
Այս տեղեկատվությունը հասանելի է միայն այն դեպքում, երբ սխալ է տեղի ունեցել API հարցումը մշակելիս (պատասխանի կոդը ոչ 200): Օրինակ ելք
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Օգտակար օրինակներ
Ստորև բերված են օրինակներ, որոնք օգտագործում են API-ի կանչերը, որոնք ավելացվել են Management API 1.6-ում:
Նախ, եկեք տեսնենք, թե ինչպես են աշխատում զանգերը ավելացնել-հյուրընկալող и ավելացնել-հասցե-տիրույթ. Ենթադրենք, պետք է ստեղծենք 192.168.0.0/24 ենթացանցերի բոլոր IP հասցեները, որոնց վերջին օկտետը 5-ն է, որպես հոսթ տիպի օբյեկտներ, և բոլոր մյուս IP հասցեները գրենք որպես հասցեների տիրույթի տիպի օբյեկտներ։ Այս դեպքում բացառեք ենթացանցային հասցեն և հեռարձակման հասցեն:
Այսպիսով, ստորև ներկայացված է սկրիպտ, որը լուծում է այս խնդիրը և ստեղծում է հյուրընկալող տիպի 50 օբյեկտ և հասցեի տիրույթի տիպի 51 օբյեկտ: Խնդիրը լուծելու համար պահանջվում է 101 API զանգ (չհաշված վերջնական հրապարակման զանգը): Նաև, օգտագործելով timeit մոդուլը, մենք հաշվարկում ենք սցենարի կատարման ժամանակը, մինչև փոփոխությունները հրապարակվեն:
Սցենար՝ օգտագործելով add-host և 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')
Իմ լաբորատոր միջավայրում այս սցենարի կատարումը տևում է 30-ից 50 վայրկյան՝ կախված կառավարման սերվերի ծանրաբեռնվածությունից:
Այժմ տեսնենք, թե ինչպես կարելի է լուծել նույն խնդիրը API զանգի միջոցով ավելացնել-օբյեկտներ-խմբաքանակ, որի աջակցությունն ավելացվել է API 1.6 տարբերակում։ Այս զանգը թույլ է տալիս միանգամից բազմաթիվ օբյեկտներ ստեղծել մեկ API հարցումով: Ավելին, դրանք կարող են լինել տարբեր տեսակի օբյեկտներ (օրինակ՝ հոսթեր, ենթացանցեր և հասցեների տիրույթներ): Այսպիսով, մեր խնդիրը կարող է լուծվել մեկ API զանգի շրջանակներում։
Սցենար՝ օգտագործելով 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')
Եվ այս սկրիպտը իմ լաբորատոր միջավայրում գործարկելը տևում է 3-ից 7 վայրկյան՝ կախված կառավարման սերվերի ծանրաբեռնվածությունից: Այսինքն, միջինում 101 API օբյեկտների վրա խմբաքանակի տիպի զանգն աշխատում է 10 անգամ ավելի արագ։ Ավելի մեծ թվով օբյեկտների վրա տարբերությունն էլ ավելի տպավորիչ կլինի:
Հիմա եկեք տեսնենք, թե ինչպես աշխատել հավաքածու-օբյեկտներ-խմբաքանակ. Օգտագործելով այս API զանգը, մենք կարող ենք զանգվածաբար փոխել ցանկացած պարամետր: Եկեք նախորդ օրինակի հասցեների առաջին կեսը (մինչև .124 հոսթ, և նաև միջակայքերը) դնենք գույնի sienna-ի վրա, իսկ խակի գույնը նշանակենք հասցեների երկրորդ կեսին:
Նախորդ օրինակում ստեղծված օբյեկտների գույնի փոփոխություն
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")
Դուք կարող եք ջնջել բազմաթիվ օբյեկտներ մեկ API զանգի միջոցով՝ օգտագործելով ջնջել-օբյեկտներ-խմբաքանակ. Հիմա եկեք նայենք կոդի օրինակին, որը ջնջում է նախկինում ստեղծած բոլոր հոսթները ավելացնել-օբյեկտներ-խմբաքանակ.
Օբյեկտների ջնջում՝ օգտագործելով 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)
Բոլոր գործառույթները, որոնք հայտնվում են Check Point ծրագրաշարի նոր թողարկումներում, անմիջապես ստանում են API զանգեր: Այսպիսով, R80.40-ում հայտնվեցին այնպիսի «հատկություններ», ինչպիսիք են Վերադարձ դեպի վերանայում և Smart Task, և դրանց համար անմիջապես պատրաստվեցին համապատասխան API զանգեր։ Ավելին, բոլոր ֆունկցիոնալությունը, երբ Legacy կոնսուլներից Միասնական քաղաքականության ռեժիմին անցնելիս, նույնպես ստանում է API-ի աջակցություն: Օրինակ, R80.40 ծրագրաշարի երկար սպասված թարմացումը HTTPS-ի ստուգման քաղաքականության տեղափոխումն էր Legacy ռեժիմից միասնական քաղաքականության ռեժիմ, և այս գործառույթն անմիջապես ստացավ API զանգեր: Ահա կոդի օրինակ, որը կանոն է ավելացնում HTTPS-ի ստուգման քաղաքականության վերին դիրքին, որը բացառում է ստուգումից 3 կատեգորիա (Առողջապահություն, Ֆինանսներ, Պետական Ծառայություններ), որոնց մի շարք երկրներում օրենքով արգելված է ստուգումը:
Ավելացրեք կանոն HTTPS-ի ստուգման քաղաքականությանը
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Legal Requirements",
"action": "bypass",
"site-category": ["Health", "Government / Military", "Financial Services"]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_https_rule = client.api_call("add-https-rule", data)
publish = client.api_call("publish")
Python սկրիպտների գործարկում Check Point կառավարման սերվերի վրա
Ամեն ինչ նույնն է պարունակում է տեղեկատվություն այն մասին, թե ինչպես գործարկել Python սկրիպտները անմիջապես կառավարման սերվերից: Սա կարող է հարմար լինել, երբ այլ մեքենայից չեք կարողանում միանալ API սերվերին: Ես ձայնագրել եմ վեց րոպեանոց տեսանյութ, որում նայում եմ մոդուլի տեղադրմանը cpapi և կառավարման սերվերի վրա Python սկրիպտների գործարկման առանձնահատկությունները: Որպես օրինակ, գործարկվում է սկրիպտ, որը ավտոմատացնում է նոր դարպասի կազմաձևումը այնպիսի առաջադրանքի համար, ինչպիսին է ցանցային աուդիտը Անվտանգության ստուգում. Այն առանձնահատկությունների թվում, որոնց հետ ես ստիպված էի զբաղվել, գործառույթը դեռ չի հայտնվել Python 2.7-ում մուտք, ուստի օգտագործողի մուտքագրած տեղեկատվությունը մշակելու համար օգտագործվում է ֆունկցիա raw_input. Հակառակ դեպքում, կոդը նույնն է, ինչ այլ մեքենաներից գործարկելու համար, միայն այն ավելի հարմար է օգտագործել գործառույթը login_as_root, որպեսզի նորից չնշեք կառավարման սերվերի ձեր սեփական օգտանունը, գաղտնաբառը և IP հասցեն։
Անվտանգության ստուգման արագ տեղադրման սցենար
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() Ֆայլի օրինակ՝ գաղտնաբառի բառարան լրացուցիչ_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
Ամփոփում
Այս հոդվածը ուսումնասիրում է միայն աշխատանքի հիմնական հնարավորությունները Python SDK և մոդուլ cpapi(ինչպես կարող էիք կռահել, դրանք իրականում հոմանիշներ են), և ուսումնասիրելով այս մոդուլի կոդը՝ դուք ավելի շատ հնարավորություններ կբացահայտեք դրա հետ աշխատելու համար: Հնարավոր է, որ դուք ցանկանաք այն լրացնել ձեր սեփական դասերով, գործառույթներով, մեթոդներով և փոփոխականներով: Դուք միշտ կարող եք կիսվել ձեր աշխատանքով և դիտել «Check Point»-ի այլ սցենարներ բաժնում համայնքում , որը միավորում է ինչպես արտադրանքի մշակողներին, այնպես էլ օգտագործողներին:
Ուրախ կոդավորում և շնորհակալություն մինչև վերջ կարդալու համար:
Source: www.habr.com