Kuasa penuh interaksi dengan API didedahkan apabila digunakan bersama-sama dengan kod program, apabila ia menjadi mungkin untuk menjana permintaan dan alat API secara dinamik untuk menganalisis respons API. Walau bagaimanapun, ia masih tidak dapat disedari Kit Pembangunan Perisian Python (selepas ini dirujuk sebagai Python SDK) untuk API Pengurusan Titik Semak, tetapi sia-sia. Ia memudahkan kehidupan pembangun dan peminat automasi dengan ketara. Python telah mendapat populariti yang besar sejak kebelakangan ini dan saya memutuskan untuk mengisi jurang dan menyemak ciri utama. . Artikel ini berfungsi sebagai tambahan yang sangat baik kepada artikel lain tentang HabrΓ© . Kami akan melihat cara menulis skrip menggunakan Python SDK dan melihat dengan lebih dekat kefungsian API Pengurusan baharu dalam versi 1.6 (disokong bermula dari R80.40). Untuk memahami artikel, anda memerlukan pengetahuan asas untuk bekerja dengan API dan Python.
Check Point sedang giat membangunkan API dan pada masa ini perkara berikut telah dikeluarkan:
- β bekerja dengan pelayan kawalan melalui API (dan keupayaan untuk melaksanakan skrip pada get laluan yang dikawal oleh pelayan kawalan)
- β bekerja dengan pintu masuk keselamatan
- β bekerja dengan kotak pasir dalam awan Check Point
- β bekerja dengan bilah Kesedaran Identiti pada pintu masuk
- β bekerja dengan portal pengurusan gerbang SMB ()
- β interaksi dengan pengawal IoT
- - bekerja dengan (penyelesaian keselamatan SD-WAN)
- - bekerja dengan
SDK Python pada masa ini hanya menyokong interaksi dengan API Pengurusan dan API Gaia. Kami akan melihat kelas, kaedah dan pembolehubah yang paling penting dalam modul ini.
Memasang modul
Modul cpapi memasang dengan cepat dan mudah daripada melalui pip. Arahan pemasangan terperinci tersedia dalam . Modul ini disesuaikan untuk berfungsi dengan Python versi 2.7 dan 3.7. Dalam artikel ini, contoh akan diberikan menggunakan Python 3.7. Walau bagaimanapun, SDK Python boleh dijalankan terus dari Pelayan Pengurusan Titik Semak (Pengurusan Pintar), tetapi mereka hanya menyokong Python 2.7, jadi bahagian terakhir akan menyediakan kod untuk versi 2.7. Sejurus selepas memasang modul, saya mengesyorkan melihat contoh dalam direktori examples_python2 ΠΈ examples_python3.
Bermula
Untuk membolehkan kami bekerja dengan komponen modul cpapi, kami perlu mengimport daripada modul tersebut cpapi sekurang-kurangnya dua kelas yang diperlukan:
APIClient ΠΈ APIClientArgs
from cpapi import APIClient, APIClientArgs
Kelas APIClientArgs bertanggungjawab untuk parameter sambungan ke pelayan API, dan kelas APIClient bertanggungjawab untuk interaksi dengan API.
Menentukan parameter sambungan
Untuk mentakrifkan pelbagai parameter untuk menyambung ke API, anda perlu membuat contoh kelas APIClientArgs. Pada dasarnya, parameternya dipratakrifkan dan apabila menjalankan skrip pada pelayan kawalan, ia tidak perlu dinyatakan.
client_args = APIClientArgs()Tetapi apabila berjalan pada hos pihak ketiga, anda perlu menentukan sekurang-kurangnya alamat IP atau nama hos pelayan API (juga dikenali sebagai pelayan pengurusan). Dalam contoh di bawah, kami mentakrifkan parameter sambungan pelayan dan memberikannya alamat IP pelayan pengurusan sebagai rentetan.
client_args = APIClientArgs(server='192.168.47.241')Mari lihat semua parameter dan nilai lalainya yang boleh digunakan semasa menyambung ke pelayan API:
Argumen kaedah __init__ kelas 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 = contextSaya percaya bahawa hujah yang boleh digunakan dalam contoh kelas APIClientArgs adalah intuitif kepada pentadbir Check Point dan tidak memerlukan ulasan tambahan.
Menyambung melalui APIClient dan pengurus konteks
Kelas APIClient Cara paling mudah untuk menggunakannya ialah melalui pengurus konteks. Semua yang perlu dihantar kepada contoh kelas APIClient ialah parameter sambungan yang ditakrifkan dalam langkah sebelumnya.
with APIClient(client_args) as client:
Pengurus konteks tidak akan membuat panggilan log masuk ke pelayan API secara automatik, tetapi ia akan membuat panggilan log keluar apabila keluar darinya. Jika atas sebab tertentu log keluar tidak diperlukan selepas selesai bekerja dengan panggilan API, anda perlu mula bekerja tanpa menggunakan pengurus konteks:
client = APIClient(clieng_args)Ujian sambungan
Cara paling mudah untuk menyemak sama ada sambungan memenuhi parameter yang ditentukan ialah menggunakan kaedah semak_cap jari. Jika pengesahan jumlah cincang sha1 untuk cap jari sijil API pelayan gagal (kaedah dikembalikan Palsu), maka ini biasanya disebabkan oleh masalah sambungan dan kami boleh menghentikan pelaksanaan program (atau memberi pengguna peluang untuk membetulkan data sambungan):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
Sila ambil perhatian bahawa pada masa hadapan kelas APIClient akan menyemak setiap panggilan API (methods api_call ΠΈ api_query, kita akan membincangkannya sedikit lagi) sijil cap jari sha1 pada pelayan API. Tetapi jika, apabila menyemak cap jari sha1 sijil pelayan API, ralat dikesan (sijil tidak diketahui atau telah ditukar), kaedahnya semak_cap jari akan memberi peluang untuk menambah/menukar maklumat mengenainya pada mesin tempatan secara automatik. Semakan ini boleh dilumpuhkan sepenuhnya (tetapi ini hanya boleh disyorkan jika skrip dijalankan pada pelayan API itu sendiri, apabila menyambung ke 127.0.0.1), menggunakan argumen APIClientArgs - tidak selamat_auto_terima (lihat lebih lanjut mengenai APIClientArgs lebih awal dalam "Menentukan parameter sambungan").
client_args = APIClientArgs(unsafe_auto_accept=True)Log masuk ke pelayan API
Π£ APIClient terdapat sebanyak 3 kaedah untuk log masuk ke pelayan API, dan setiap satunya memahami maksudnya sid(session-id), yang digunakan secara automatik dalam setiap panggilan API berikutnya dalam pengepala (nama dalam pengepala parameter ini ialah X-chkp-sid), jadi tidak perlu lagi memproses parameter ini.
kaedah log masuk
Pilihan menggunakan log masuk dan kata laluan (dalam contoh, nama pengguna admin dan kata laluan 1q2w3e diluluskan sebagai hujah kedudukan):
login = client.login('admin', '1q2w3e') Parameter pilihan tambahan juga tersedia dalam kaedah log masuk; berikut ialah nama dan nilai lalainya:
continue_last_session=False, domain=None, read_only=False, payload=NoneKaedah log masuk_dengan_kunci_api
Pilihan menggunakan kunci api (disokong bermula daripada versi pengurusan R80.40/API Pengurusan v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" ini ialah nilai kunci API untuk salah seorang pengguna pada pelayan pengurusan dengan kaedah kebenaran kunci API):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') Dalam kaedah log masuk_dengan_kunci_api parameter pilihan yang sama tersedia seperti dalam kaedah log masuk.
kaedah login_as_root
Pilihan untuk log masuk ke mesin tempatan dengan pelayan API:
login = client.login_as_root()Terdapat hanya dua parameter pilihan yang tersedia untuk kaedah ini:
domain=None, payload=NoneDan akhirnya API memanggil diri mereka sendiri
Kami mempunyai dua pilihan untuk membuat panggilan API melalui kaedah api_call ΠΈ api_query. Mari kita fikirkan apa perbezaan antara mereka.
api_call
Kaedah ini boleh digunakan untuk sebarang panggilan. Kita perlu melepasi bahagian terakhir untuk panggilan api dan muatan dalam badan permintaan jika perlu. Jika muatan kosong, maka ia tidak boleh dipindahkan sama sekali:
api_versions = client.api_call('show-api-versions') Output untuk permintaan ini di bawah potongan:
In [23]: api_versions
Out[23]:
APIResponse({
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"res_obj": {
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"status_code": 200
},
"status_code": 200,
"success": true
})
show_host = client.api_call('show-host', {'name' : 'h_8.8.8.8'})Output untuk permintaan ini di bawah potongan:
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
Izinkan saya membuat tempahan dengan segera bahawa kaedah ini hanya terpakai untuk panggilan yang outputnya melibatkan offset. Inferens sedemikian berlaku apabila ia mengandungi atau mungkin mengandungi sejumlah besar maklumat. Sebagai contoh, ini boleh menjadi permintaan untuk senarai semua objek hos yang dibuat pada pelayan pengurusan. Untuk permintaan sedemikian, API mengembalikan senarai 50 objek secara lalai (anda boleh meningkatkan had kepada 500 objek dalam respons). Dan untuk tidak menarik maklumat beberapa kali, menukar parameter offset dalam permintaan API, terdapat kaedah api_query yang melakukan kerja ini secara automatik. Contoh panggilan yang memerlukan kaedah ini: sesi rancangan, hos rancangan, rangkaian rancangan, show-wildcards, show-group, show-address-ranges, show-simple-gateways, show-simple-clusters, show-access-roles, show-trusted-clients, pakej persembahan. Malah, kami melihat perkataan jamak dalam nama panggilan API ini, jadi panggilan ini akan lebih mudah dikendalikan api_query
show_hosts = client.api_query('show-hosts') Output untuk permintaan ini di bawah potongan:
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
})
Memproses hasil panggilan API
Selepas ini anda boleh menggunakan pembolehubah dan kaedah kelas APIResponse(kedua-duanya di dalam pengurus konteks dan di luar). Di kelas APIResponse 4 kaedah dan 5 pembolehubah telah dipratentukan; kita akan membincangkan yang paling penting dengan lebih terperinci.
kejayaan
Sebagai permulaan, adalah idea yang baik untuk memastikan bahawa panggilan API berjaya dan mengembalikan hasil. Terdapat kaedah untuk ini kejayaan:
In [49]: api_versions.success
Out[49]: True
Mengembalikan Benar jika panggilan API berjaya (kod respons - 200) dan Salah jika tidak berjaya (sebarang kod respons lain). Ia mudah digunakan selepas panggilan API untuk memaparkan maklumat yang berbeza bergantung pada kod respons.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) kod status
Mengembalikan kod respons selepas panggilan API dibuat.
In [62]: api_versions.status_code
Out[62]: 400
Kod respons yang mungkin: 200,400,401,403,404,409,500,501.
set_success_status
Dalam kes ini, nilai status kejayaan mungkin perlu diubah. Secara teknikal, anda boleh meletakkan apa sahaja di sana, walaupun rentetan biasa. Tetapi contoh sebenar ialah menetapkan semula parameter ini kepada False di bawah syarat tertentu yang disertakan. Di bawah, perhatikan contoh apabila terdapat tugas yang dijalankan pada pelayan pengurusan, tetapi kami akan menganggap permintaan ini tidak berjaya (kami akan menetapkan pembolehubah kejayaan kepada Palsu, walaupun pada hakikatnya panggilan API berjaya dan mengembalikan kod 200).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakrespons()
Kaedah respons membolehkan anda melihat kamus dengan kod respons (status_code) dan badan respons (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
Membolehkan anda melihat hanya badan tindak balas (badan) tanpa maklumat yang tidak diperlukan.
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
Maklumat ini tersedia hanya apabila ralat berlaku semasa memproses permintaan API (kod respons tiada 200). Contoh output
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
Contoh yang berguna
Berikut ialah contoh yang menggunakan panggilan API yang telah ditambahkan dalam API Pengurusan 1.6.
Mula-mula, mari kita lihat cara panggilan berfungsi tambah hos ΠΈ tambah-alamat-julat. Katakan kita perlu mencipta semua alamat IP subnet 192.168.0.0/24, oktet terakhir ialah 5, sebagai objek jenis hos, dan tulis semua alamat IP lain sebagai objek jenis julat alamat. Dalam kes ini, kecualikan alamat subnet dan alamat siaran.
Jadi, di bawah ialah skrip yang menyelesaikan masalah ini dan mencipta 50 objek jenis hos dan 51 objek jenis julat alamat. Untuk menyelesaikan masalah, 101 panggilan API diperlukan (tidak mengira panggilan penerbitan terakhir). Selain itu, menggunakan modul timeit, kami mengira masa yang diperlukan untuk melaksanakan skrip sehingga perubahan diterbitkan.
Skrip menggunakan add-host dan 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')
Dalam persekitaran makmal saya, skrip ini mengambil masa antara 30 dan 50 saat untuk dilaksanakan, bergantung pada beban pada pelayan pengurusan.
Sekarang mari lihat cara menyelesaikan masalah yang sama menggunakan panggilan API tambah-objek-batch, sokongan yang telah ditambahkan dalam API versi 1.6. Panggilan ini membolehkan anda mencipta banyak objek sekaligus dalam satu permintaan API. Selain itu, ini boleh menjadi objek daripada jenis yang berbeza (contohnya, hos, subnet dan julat alamat). Oleh itu, tugas kami boleh diselesaikan dalam rangka kerja satu panggilan API.
Skrip menggunakan 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')
Dan menjalankan skrip ini dalam persekitaran makmal saya mengambil masa dari 3 hingga 7 saat, bergantung pada beban pada pelayan pengurusan. Iaitu, secara purata, pada 101 objek API, panggilan jenis kelompok berjalan 10 kali lebih pantas. Pada bilangan objek yang lebih besar perbezaannya akan menjadi lebih mengagumkan.
Sekarang mari kita lihat cara bekerja dengannya set-objek-batch. Menggunakan panggilan API ini, kami boleh menukar mana-mana parameter secara pukal. Mari kita tetapkan separuh pertama alamat daripada contoh sebelumnya (sehingga .124 hos, dan julat juga) kepada warna sienna, dan tetapkan warna khaki pada separuh kedua alamat.
Menukar warna objek yang dibuat dalam contoh sebelumnya
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")
Anda boleh memadamkan berbilang objek dalam satu panggilan API menggunakan delete-objects-batch. Sekarang mari kita lihat contoh kod yang memadamkan semua hos yang dibuat sebelum ini melalui tambah-objek-batch.
Memadam objek menggunakan 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)
Semua fungsi yang muncul dalam keluaran baharu perisian Check Point serta-merta memperoleh panggilan API. Oleh itu, dalam R80.40 "ciri" seperti Kembali ke semakan dan Tugas Pintar muncul, dan panggilan API yang sepadan segera disediakan untuknya. Selain itu, semua kefungsian apabila beralih daripada konsol Legacy ke mod Dasar Disatukan juga memperoleh sokongan API. Sebagai contoh, kemas kini yang telah lama ditunggu-tunggu dalam versi perisian R80.40 ialah pemindahan dasar Pemeriksaan HTTPS daripada mod Warisan kepada mod Dasar Bersatu, dan fungsi ini menerima panggilan API dengan serta-merta. Berikut ialah contoh kod yang menambahkan peraturan pada kedudukan teratas dasar Pemeriksaan HTTPS yang mengecualikan 3 kategori daripada pemeriksaan (Kesihatan, Kewangan, Perkhidmatan Kerajaan), yang dilarang daripada pemeriksaan mengikut undang-undang di beberapa negara.
Tambahkan peraturan pada dasar Pemeriksaan 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")
Menjalankan skrip Python pada pelayan pengurusan Check Point
Semuanya sama mengandungi maklumat tentang cara menjalankan skrip Python terus daripada pelayan kawalan. Ini boleh menjadi mudah apabila anda tidak dapat menyambung ke pelayan API daripada mesin lain. Saya merakam video enam minit di mana saya melihat pemasangan modul cpapi dan ciri menjalankan skrip Python pada pelayan kawalan. Sebagai contoh, skrip dijalankan yang mengautomasikan konfigurasi get laluan baharu untuk tugas seperti pengauditan rangkaian Pemeriksaan Keselamatan. Antara ciri-ciri yang perlu saya tangani: fungsi tersebut masih belum muncul dalam Python 2.7 input, jadi untuk memproses maklumat yang dimasukkan pengguna, fungsi digunakan input_raw. Jika tidak, kodnya adalah sama seperti untuk melancarkan daripada mesin lain, cuma ia lebih mudah untuk menggunakan fungsi tersebut login_as_root, supaya tidak menyatakan nama pengguna, kata laluan dan alamat IP pelayan pengurusan anda sekali lagi.
Skrip untuk persediaan pantas Pemeriksaan Keselamatan
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() Contoh fail dengan kamus kata laluan additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","ΠΏΠ°ΡΠΎΠ»Ρ","ΠΠ°ΡΠΎΠ»Ρ","ΠΠ»ΡΡ","ΠΊΠ»ΡΡ","ΡΠΈΡΡ","Π¨ΠΈΡΡ"]
}
Kesimpulan
Artikel ini hanya mengkaji kemungkinan asas kerja SDK Python dan modul cpapi(seperti yang anda duga, ini sebenarnya sinonim), dan dengan mempelajari kod dalam modul ini anda akan menemui lebih banyak peluang untuk bekerja dengannya. Ada kemungkinan anda ingin menambahnya dengan kelas, fungsi, kaedah dan pembolehubah anda sendiri. Anda sentiasa boleh berkongsi kerja anda dan melihat skrip lain untuk Check Point dalam bahagian tersebut dalam komuniti , yang menyatukan kedua-dua pembangun produk dan pengguna.
Selamat mengekod dan terima kasih kerana membaca hingga habis!
Sumber: www.habr.com