API-แแแแแ แฃแ แแแแ แแฅแแแแแแแก แกแ แฃแแ แซแแแ แแแแแแแแ แแ แแแ แแแแก แแแแแแ แแ แแแ แแแแแงแแแแแแกแแก, แ แแแแกแแช แจแแกแแซแแแแแแ แแแฎแแแแ API แแแแฎแแแแแแแก แแ แแแกแขแ แฃแแแแขแแแแก แแแแแแแฃแ แแ แแแแแ แแ แแแ API แแแกแฃแฎแแแแก แแแแแแแแกแแแแก. แแฃแแชแ แแก แแแแแช แจแแฃแแฉแแแแแแ แ แฉแแแ Python แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแแแแ แแแแก แแแแ แแแ (แจแแแแแแแจแ Python SDK) for Check Point Management API, แแแแ แแ แแแแแ. แแก แแแแจแแแแแแแแแ แแแแ แขแแแแแก แแแแแแแแแ แแแแกแ แแ แแแขแแแแขแแแแชแแแก แแแงแแแ แฃแแแ แชแฎแแแ แแแแก. แแ แแแแ แแ แแก แแแแแแแ แฃแแแ แแแแแ แ แแแแฃแแแ แแแ แแแแแแแ แแ แแแแแแฌแงแแแขแ แจแแแแแกแ แฎแแ แแแแ แแ แแแแแแแฎแแแ แซแแ แแแแแ แแแฎแแกแแแแแแแแแ. . แแก แกแขแแขแแ แแแกแแฎแฃแ แแแ แฐแแแ แแแ แแแแแ แแ แแ แกแขแแขแแแก แจแแกแแแแจแแแ แแแแแขแแแแก . แฉแแแ แแแแแแฎแแแแแ, แแฃ แ แแแแ แฃแแแ แแแแฌแแ แแ แกแแ แแแขแแแ Python SDK-แแก แแแแแงแแแแแแ แแ แฃแคแ แ แแฎแแแก แแแแแแแแ แแแ แแแแแฏแแแแขแแก API-แก แแฎแแ แคแฃแแฅแชแแแแแแแแแก 1.6 แแแ แกแแแจแ (แแฎแแ แแแญแแ แแแแ R80.40-แแแ แแแฌแงแแแฃแแ). แกแขแแขแแแก แแแกแแแแแแ แแแแญแแ แแแแแ API-แแแแแ แแ แแแแแแแแ แแฃแจแแแแแก แกแแแแแแกแ แชแแแแ.
Check Point แแฅแขแแฃแ แแ แแแแแแ แแแก API-แก แแ แแ แแ แแแกแแแแก แแแแแแแแ แจแแแแแแ:
- โ แกแแแแแขแ แแแ แกแแ แแแ แแแ แแฃแจแแแแ API-แแก แกแแจแฃแแแแแแ (แแ แกแแ แแแขแแแแก แจแแกแ แฃแแแแแก แจแแกแแซแแแแแแแ แกแแแแแขแ แแแ แกแแ แแแ แแก แแแแ แแแแขแ แแแแ แแแแ แแแ แแแญแแแแแ)
- โ แฃแกแแคแ แแฎแแแแแก แแแ แแแญแแแแแแ แแฃแจแแแแ
- โ แฅแแแจแแก แงแฃแแแแ แแฃแจแแแแ Check Point แฆแ แฃแแแแจแ
- โ แแฃแจแแแแ Identity Awareness blade-แแแ แแแ แแแญแแแแแ
- โ แแแฃแจแแแแ SMB แแแ แแแญแแก แแแ แแแแก แแแ แขแแแแแ ()
- โ แแแขแแ แแฅแชแแ IoT แแแแขแ แแแแ แแแแแ
- - แแฃแจแแแแ (SD-WAN แฃแกแแคแ แแฎแแแแแก แแแแแฌแงแแแขแ)
- - แแฃแจแแแแ
Python SDK แแแแแแแ แแฎแแ แก แฃแญแแ แก แแฎแแแแ แแแ แแแแก API-แกแแแ แฃแ แแแแ แแฅแแแแแแแก แแ Gaia API. แฉแแแ แแแแแแฎแแแแแ แแ แแแแฃแแจแ แงแแแแแแ แแแแจแแแแแแแแ แแแแกแแแก, แแแแแแแแก แแ แชแแแแแแแก.
แแแแฃแแแก แแแงแแแแแ
แแแแฃแแ cpapi แแแกแขแแแแชแแ แกแฌแ แแคแแ แแ แแแ แขแแแแ แแแ via pip. แแแกแขแแแแชแแแก แแแขแแแฃแ แ แแแกแขแ แฃแฅแชแแแแ แฎแแแแแกแแฌแแแแแแ . แแก แแแแฃแแ แแแแแขแแ แแแฃแแแ แแแแแแแก 2.7 แแ 3.7 แแแ แกแแแแแแ แแฃแจแแแแแกแแแแก. แแ แกแขแแขแแแจแ แแแชแแแฃแแแ แแแแแแแแแแ Python 3.7-แแก แแแแแงแแแแแแ. แแฃแแชแ, Python SDK-แแก แแแจแแแแ แจแแกแแซแแแแแแแ แฃแจแฃแแแแ Check Point Management Server-แแแแ (Smart Management), แแแแ แแ แแกแแแ แแฎแแ แก แฃแญแแ แแ แแฎแแแแ Python 2.7-แก, แแแแขแแ แแแแ แแแแงแแคแแแแแแจแ แแแชแแแฃแแแ แแแแ 2.7 แแแ แกแแแกแแแแก. แแแแฃแแแก แแแงแแแแแแกแแแแแแ, แแแ แฉแแแ, แแแแแฎแแแแ แแแแแแแแแแก แแแ แแฅแขแแ แแแจแ แแแแแแแแแแ_แแแแแแ2 ะธ แแแแแแแแแแ_แแแแแแ3.
แแแชแแแแแแ
แแแแกแแแแแก, แ แแ แจแแแแแซแแแก cpapi แแแแฃแแแก แแแแแแแแแขแแแแแ แแฃแจแแแแ, แกแแญแแ แแ แแแแฃแแแแแ แแแแแ แขแ cpapi ะบะฐะบ ะผะธะฝะธะผัะผ ะดะฒะฐ ะฝะตะพะฑั ะพะดะธะผัั ะบะปะฐััะฐ:
APIClient ะธ APIClientArgs
from cpapi import APIClient, APIClientArgs
แแแแกแ APIClientArgs แแแกแฃแฎแแกแแแแแแแแ API แกแแ แแแ แแแ แแ แแแแกแแแ แแแแแแจแแ แแแแก แแแ แแแแขแ แแแแ APIClient แแแกแฃแฎแแกแแแแแแแแ API-แกแแแ แฃแ แแแแ แแฅแแแแแแแกแแแแก.
แแแแจแแ แแก แแแ แแแแขแ แแแแก แแแแกแแแฆแแ แ
API-แกแแแ แแแกแแแแแจแแ แแแแแ แกแฎแแแแแกแฎแแ แแแ แแแแขแ แแก แแแกแแแแแแแ, แแฅแแแ แฃแแแ แจแแฅแแแแ แแแแกแแก แแแแแแแแแ แ APIClientArgs. แแ แแแชแแแจแ, แแแกแ แแแ แแแแขแ แแแ แฌแแแแกแฌแแ แแ แแก แแแแกแแแฆแแ แฃแแ แแ แกแแแแแขแ แแแ แกแแ แแแ แแ แกแแ แแแขแแก แแแจแแแแแกแแก แแแแ แแแแแแแ แแขแแแ แแ แแ แแก แกแแญแแ แ.
client_args = APIClientArgs()แแแแ แแ แแแกแแแ แแฎแแ แแก แฐแแกแขแแ แแฃแจแแแแแกแแก, แแฅแแแ แฃแแแ แแแฃแแแแแ แแแแแแฃแ IP แแแกแแแแ แแ แแ แฐแแกแขแแก แกแแฎแแแ API แกแแ แแแ แแก (แแกแแแ แชแแแแแแ แ แแแแ แช แแแ แแแแก แกแแ แแแ แ). แฅแแแแแ แแแงแแแแแ แแแแแแแแจแ แฉแแแ แแแแแกแแแฆแแ แแแ แกแแ แแแ แแก แแแแจแแ แแก แแแ แแแแขแ แก แแ แแแแแญแแแ แแแก แแแ แแแแก แกแแ แแแ แแก 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)แแแแจแแ แแก แจแแแแฌแแแแ
แฃแแแ แขแแแแกแ แแแ แแแแก แจแแกแแแแฌแแแแแแ, แจแแแกแแแแแแแ แแฃ แแ แ แแแแจแแ แ แแแแแแแแฃแ แแแ แแแแขแ แแแก, แแ แแก แแแแแแแก แแแแแงแแแแแ แจแแแแฌแแแแ_แแแแแก แแแแแแญแแ. แแฃ แกแแ แแแ แแก 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 แแแแแก แแแแแแญแแแก แจแแแแฌแแแแแกแแก แแแแแแแแแแ แจแแชแแแแ (แกแแ แแแคแแแแขแ แฃแชแแแแแ แแ แจแแชแแแแแแ), แแแแแแ แจแแแแฌแแแแ_แแแแแก แแแแแแญแแ แกแแจแฃแแแแแแก แแแแชแแแ แแแขแแแแขแฃแ แแ แแแแแแขแแ/แจแแชแแแแแ แแแคแแ แแแชแแ แแแแแแแแ แแ แแแแฅแแแแแ. แแ แจแแแแฌแแแแแก แกแ แฃแแ แแแแแ แแแ แจแแกแแซแแแแแแแ (แแแแ แแ แแก แจแแแซแแแแ แแงแแก แ แแแแแแแแแแฃแแ แแฎแแแแ แแ แจแแแแฎแแแแแจแ, แแฃ แกแแ แแแขแแแ แแแจแแแแฃแแแ แแแแแ API แกแแ แแแ แแ, 127.0.0.1-แแแ แแแแแแจแแ แแแแกแแก), APIClientArgs แแ แแฃแแแแขแแก แแแแแงแแแแแแ - unsafe_auto_accept (แแฎแแแแ แแแขแ APIClientArgs-แแก แจแแกแแฎแแ แแแ แ โแแแแจแแ แแก แแแ แแแแขแ แแแแก แแแแกแแแฆแแ แแจแโ).
client_args = APIClientArgs(unsafe_auto_accept=True)แจแแแแ API แกแแ แแแ แแ
ะฃ APIClient แแ แกแแแแแก API แกแแ แแแ แแ แจแแกแแแแก 3 แแแแแแ แแ แแแแแแฃแ แแแแแแแก แแกแแแก แแแแจแแแแแแแ แกแแ(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 ะฒัะทะพะฒะฐ ะธ payload ะฒ ัะตะปะต ะทะฐะฟัะพัะฐ ะฟัะธ ะฝะตะพะฑั ะพะดะธะผะพััะธ. ะัะปะธ payload ะฟัััะพะน, ัะพ ะตะณะพ ะผะพะถะฝะพ ะฝะต ะฟะตัะตะดะฐะฒะฐัั ะฒะพะฒัะต:
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.
แแแแงแแแแ_แฌแแ แแแขแแแแก_แกแขแแขแฃแกแ
แแ แจแแแแฎแแแแแจแ แจแแแซแแแแ แกแแญแแ แ แแแฎแแแก แฌแแ แแแขแแแแก แกแขแแขแฃแกแแก แแแแจแแแแแแแแก แจแแชแแแ. แขแแฅแแแแฃแ แแ, แแฅแแแ แจแแแแซแแแแ แแแแแแแแกแแ แงแแแแแคแแ แ, แแฃแแแแช แฉแแแฃแแแแ แแแ แกแขแ แแฅแแแ. แแแแ แแ แ แแแแฃแ แ แแแแแแแแ แแฅแแแแ แแ แแแ แแแแขแ แแก 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']}
แจแแชแแแแแก_แแแกแแฏแ
แแก แแแคแแ แแแชแแ แฎแแแแแกแแฌแแแแแแ แแฎแแแแ แแแจแแ, แ แแแแกแแช แแแฎแแ แจแแชแแแแ API แแแแฎแแแแแก แแแแฃแจแแแแแแกแแก (แแแกแฃแฎแแก แแแแ แแ แแ แแก 200). แแแแแแแแ แแแแแแแแแแ
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
แกแแกแแ แแแแแ แแแแแแแแแแ
แฅแแแแแ แแแชแแแฃแแแ แแแแแแแแแแ, แ แแแแแแแช แแงแแแแแแ API แแแ แแแก, แ แแแแแแแช แแแแแขแแแฃแแแ แแแ แแแแก 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 แแแ แแก แแแแแงแแแแแแ add-objects-batch, แ แแแแแก แแฎแแ แแแญแแ แ แแแแแขแแแฃแแแ 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. แแฎแแ แแแแแ แจแแแฎแแแแ แแแแแก แแแแแแแแก, แ แแแแแแช แฌแแจแแแก แแแ แ แจแแฅแแแแ แงแแแแ แฐแแกแขแก add-objects-batch.
แแแแแฅแขแแแแก แฌแแจแแ 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-แจแ แแแแแฉแแแ แแกแแแ โแคแฃแแฅแชแแแแโ, แ แแแแ แแชแแ Revert to revision แแ 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")
แแแแแแแก แกแแ แแแขแแแแก แแแจแแแแ Check Point แแแ แแแแก แกแแ แแแ แแ
แงแแแแแคแแ แ แแแแแแ แจแแแชแแแก แแแคแแ แแแชแแแก แแแแก แจแแกแแฎแแ, แแฃ แ แแแแ แฃแแแ แแแฃแจแแแ แแแแแแแก แกแแ แแแขแแแ แแแ แแแแแ แกแแแแแขแ แแแ แกแแ แแแ แแแแ. แแก แจแแแซแแแแ แแงแแก แแแกแแฎแแ แฎแแแแแ, แ แแแแกแแช แแฅแแแ แแ แจแแแแซแแแแ แแแฃแแแแจแแ แแแ API แกแแ แแแ แก แกแฎแแ แแแแ แแขแแแแ. แแ แฉแแแฌแแ แ แแฅแแกแฌแฃแแแแแ แแแแแ, แ แแแแแจแแช แแฃแงแฃแ แแ แแแแฃแแแก แแแงแแแแแแก cpapi แแ แกแแแแแขแ แแแ แกแแ แแแ แแ แแแแแแแก แกแแ แแแขแแแแก แแแจแแแแแก แคแฃแแฅแชแแแแ. แแแแแแแแแ, แแแจแแแแฃแแแ แกแแ แแแขแ, แ แแแแแแช แแแขแแแแขแแแแ แแแก แแฎแแแ แแแ แแแญแแก แแแแคแแแฃแ แแชแแแก แแกแแแ แแแแชแแแแกแแแแก, แ แแแแ แแชแแ แฅแกแแแแก แแฃแแแขแ แฃแกแแคแ แแฎแแแแแก แจแแแแฌแแแแ. แแแฎแแกแแแแแแแแแก แจแแ แแก, แ แแแแแแแแแช แแแแแแแแแแ แแแแแฌแแ: แคแฃแแฅแชแแ แฏแแ แแ แแแแแฉแแแแแ Python 2.7-แจแ แจแแขแแแแก, แแแแขแแ แแแแฎแแแ แแแแแก แแแแ แจแแงแแแแแแ แแแคแแ แแแชแแแก แแแกแแแฃแจแแแแแแแ แแแแแแงแแแแแ แคแฃแแฅแชแแ แแแแแแฃแแ_แจแแงแแแแ. แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ, แแแแ แแแแแแ, แ แแช แกแฎแแ แแแแฅแแแแแแแแ แแแจแแแแแกแแแแก, แแฎแแแแ แคแฃแแฅแชแแแก แแแแแงแแแแแ แฃแคแ แ แแแกแแฎแแ แฎแแแแแแ 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","ะฟะฐัะพะปั","ะะฐัะพะปั","ะะปัั","ะบะปัั","ัะธัั","ะจะธัั"]
}
แแแกแแแแ
แแก แกแขแแขแแ แแแแแฎแแแแแก แแฎแแแแ แแฃแจแแแแแก แซแแ แแแแ แจแแกแแซแแแแแแแแแก แแแแแแ SDK แแ แแแแฃแแ cpapi(แ แแแแ แช แแแแแ แแแฎแแแแ, แแก แกแแแแแแแแแแจแ แกแแแแแแแแแแ) แแ แแ แแแแฃแแแก แแแแแก แจแแกแฌแแแแแ แแฅแแแ แแฆแแแแฉแแแ แแแแแ แฃแคแ แ แแแข แจแแกแแซแแแแแแแแแก แแแกแแแ แแฃแจแแแแแกแแแแก. แแ แแ แแก แแแแแ แแชแฎแฃแแ, แ แแ แแแแแแแแ แแแกแ แแแแแขแแแ แแฅแแแแ แกแแแฃแแแ แ แแแแกแแแแ, แคแฃแแฅแชแแแแแ, แแแแแแแแแแ แแ แชแแแแแแแแ. แแฅแแแ แงแแแแแแแแก แจแแแแซแแแแ แแแแแแแ แแ แแฅแแแแ แแแแฃแจแแแแ แ แแ แแแฎแแ แกแฎแแ แกแแ แแแขแแแ Check Point-แแกแแแแก แแแแงแแคแแแแแแจแ แกแแแแแแแแแแแจแ , แ แแแแแแช แแแ แแแแแแแก แ แแแแ แช แแ แแแฃแฅแขแแก แจแแแฅแแแแแแแก, แแกแแแ แแแแฎแแแ แแแแแแก.
แแแแแแแ แ แแแแแ แแแ แแ แแแแแแแ แแแแแแแ แฌแแแแแฎแแแกแแแแก!
แฌแงแแ แ: www.habr.com