ເຮັດໃຫ້ງ່າຍຂອງ Check Point API ກັບ Python SDK

ພະລັງງານອັນເຕັມທີ່ຂອງປະຕິສໍາພັນກັບ APIs ໄດ້ຖືກເປີດເຜີຍເມື່ອນໍາໃຊ້ຮ່ວມກັນກັບລະຫັດໂຄງການ, ເມື່ອມັນເປັນໄປໄດ້ທີ່ຈະສ້າງການຮ້ອງຂໍ API ແລະເຄື່ອງມືໃນການວິເຄາະການຕອບສະຫນອງ API. ຢ່າງໃດກໍຕາມ, ມັນຍັງຄົງ unnoticeable ຊຸດພັດທະນາຊອບແວ Python (ຕໍ່ໄປນີ້ເອີ້ນວ່າ Python SDK) ສໍາລັບ Check Point Management API, ແຕ່ໃນ vain. ມັນເຮັດໃຫ້ຊີວິດຂອງນັກພັດທະນາ ແລະຜູ້ທີ່ມັກໃຊ້ລະບົບອັດຕະໂນມັດໄດ້ງ່າຍຂຶ້ນ. Python ໄດ້ຮັບຄວາມນິຍົມຢ່າງຫຼວງຫຼາຍໃນບໍ່ດົນມານີ້ແລະຂ້າພະເຈົ້າໄດ້ຕັດສິນໃຈຕື່ມຊ່ອງຫວ່າງແລະທົບທວນລັກສະນະຕົ້ນຕໍ. Check Point API ຊຸດພັດທະນາ Python. ບົດ​ຄວາມ​ນີ້​ເປັນ​ການ​ເພີ່ມ​ເຕີມ​ທີ່​ດີ​ເລີດ​ກັບ​ບົດ​ຄວາມ​ອື່ນ​ກ່ຽວ​ກັບ Habré​ ກວດເບິ່ງຈຸດ R80.10 API. ການຄຸ້ມຄອງຜ່ານ CLI, scripts ແລະອື່ນໆ. ພວກເຮົາຈະເບິ່ງວິທີການຂຽນສະຄິບໂດຍໃຊ້ Python SDK ແລະເບິ່ງທີ່ໃກ້ຊິດຢູ່ໃນຫນ້າທີ່ໃຫມ່ຂອງ Management API ໃນຮຸ່ນ 1.6 (ສະຫນັບສະຫນູນເລີ່ມຕົ້ນຈາກ R80.40). ເພື່ອເຂົ້າໃຈບົດຄວາມ, ທ່ານຈະຕ້ອງມີຄວາມຮູ້ພື້ນຖານຂອງການເຮັດວຽກກັບ APIs ແລະ Python.

Check Point ກໍາລັງພັດທະນາ API ຢ່າງຈິງຈັງ ແລະໃນຂະນະນີ້ສິ່ງຕໍ່ໄປນີ້ໄດ້ຖືກປ່ອຍອອກມາແລ້ວ:

• Check Point Management API (ເວີຊັນປັດຈຸບັນ 1.6) — ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ​ເຄື່ອງ​ແມ່​ຂ່າຍ​ຂອງ​ການ​ຄວບ​ຄຸມ​ໂດຍ​ຜ່ານ API (ແລະ​ຄວາມ​ສາ​ມາດ​ໃນ​ການ​ປະ​ຕິ​ບັດ​ສະ​ຄິບ​ກ່ຽວ​ກັບ​ການ​ປະ​ຕູ​ທີ່​ຄວບ​ຄຸມ​ໂດຍ​ເຄື່ອງ​ແມ່​ຂ່າຍ​ການ​ຄວບ​ຄຸມ​)
• Check Point GAIA API (ເວີຊັນປັດຈຸບັນ 1.4) — ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ​ປະ​ຕູ​ຄວາມ​ປອດ​ໄພ​
• API ປ້ອງກັນໄພຂົ່ມຂູ່ 1.0 — ເຮັດວຽກກັບ sandbox ໃນ Check Point cloud
• API ການຮັບຮູ້ຕົວຕົນ — ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ​ແຜ່ນ​ໃບ​ຄ້າຍ​ຄື​ການ​ປູກ​ຈິດ​ສໍາ​ນຶກ​ກ່ຽວ​ກັບ​ການ​ປະ​ຕູ​
• API ການຄຸ້ມຄອງຄວາມປອດໄພ Portal — ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ SMB ປະ​ຕູ​ຄຸ້ມ​ຄອງ​ປະ​ຕູ (ເພີ່ມເຕີມກ່ຽວກັບ SMB gateways)
• IoT API - ການໂຕ້ຕອບກັບຕົວຄວບຄຸມ IoT
• CloudGuard Connect API - ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ CloudGuard ເຊື່ອມຕໍ່ (ການແກ້ໄຂຄວາມປອດໄພ SD-WAN)
• Dome9 API - ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ Dome9

Python SDK ປະຈຸບັນພຽງແຕ່ສະຫນັບສະຫນູນການໂຕ້ຕອບກັບ API ການຈັດການແລະ Gaia API. ພວກເຮົາຈະເບິ່ງຫ້ອງຮຽນ, ວິທີການແລະຕົວແປທີ່ສໍາຄັນທີ່ສຸດໃນໂມດູນນີ້.

ການຕິດຕັ້ງໂມດູນ

ໂມດູນ cpapi ການ​ຕິດ​ຕັ້ງ​ຢ່າງ​ວ່ອງ​ໄວ​ແລະ​ໄດ້​ຢ່າງ​ງ່າຍ​ດາຍ​ຈາກ​ ພື້ນທີ່ເກັບຂໍ້ມູນ Check Point ຢ່າງເປັນທາງການໃນ github ໂດຍການຊ່ວຍເຫຼືອ pip. ຄໍາແນະນໍາການຕິດຕັ້ງລາຍລະອຽດແມ່ນມີຢູ່ໃນ README.md. ໂມດູນນີ້ຖືກດັດແປງເພື່ອເຮັດວຽກກັບ Python ຮຸ່ນ 2.7 ແລະ 3.7. ໃນບົດຄວາມນີ້, ຈະຍົກຕົວຢ່າງໂດຍໃຊ້ Python 3.7. ຢ່າງໃດກໍ່ຕາມ, Python SDK ສາມາດດໍາເນີນການໄດ້ໂດຍກົງຈາກ Check Point Management Server (Smart Management), ແຕ່ພວກເຂົາພຽງແຕ່ສະຫນັບສະຫນູນ Python 2.7, ດັ່ງນັ້ນພາກສຸດທ້າຍຈະໃຫ້ລະຫັດສໍາລັບຮຸ່ນ 2.7. ທັນທີຫຼັງຈາກການຕິດຕັ້ງໂມດູນ, ຂ້າພະເຈົ້າແນະນໍາໃຫ້ເບິ່ງຕົວຢ່າງໃນໄດເລກະທໍລີ example_python2 и example_python3.

ການເລີ່ມຕົ້ນ

ເພື່ອໃຫ້ພວກເຮົາສາມາດເຮັດວຽກກັບອົງປະກອບຂອງໂມດູນ 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:

ອາກິວເມັນຂອງວິທີການ __init__ ຂອງຫ້ອງຮຽນ 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 = context

ຂ້າພະເຈົ້າເຊື່ອວ່າການໂຕ້ຖຽງທີ່ສາມາດນໍາໃຊ້ໄດ້ໃນຕົວຢ່າງຂອງຫ້ອງຮຽນ APIClientArgs ແມ່ນ intuitive ກັບຜູ້ບໍລິຫານ Check Point ແລະບໍ່ຈໍາເປັນຕ້ອງມີຄໍາເຫັນເພີ່ມເຕີມ.

ການເຊື່ອມຕໍ່ຜ່ານ APIClient ແລະຜູ້ຈັດການບໍລິບົດ

Класс APIClient ວິທີທີ່ສະດວກທີ່ສຸດທີ່ຈະໃຊ້ມັນແມ່ນຜ່ານຕົວຈັດການສະພາບການ. ທັງຫມົດທີ່ຕ້ອງໄດ້ຮັບການສົ່ງກັບຕົວຢ່າງຂອງຊັ້ນ APIClient ແມ່ນຕົວກໍານົດການເຊື່ອມຕໍ່ທີ່ຖືກກໍານົດໄວ້ໃນຂັ້ນຕອນທີ່ຜ່ານມາ.

with APIClient(client_args) as client:

ຜູ້ຈັດການບໍລິບົດຈະບໍ່ເຮັດການໂທເຂົ້າລະບົບໄປຫາເຊີບເວີ API ໂດຍອັດຕະໂນມັດ, ແຕ່ມັນຈະໂທອອກເມື່ອອອກຈາກມັນ. ຖ້າສໍາລັບເຫດຜົນບາງຢ່າງທີ່ບໍ່ຈໍາເປັນຕ້ອງອອກຈາກລະບົບຫຼັງຈາກສໍາເລັດການເຮັດວຽກກັບການໂທ API, ທ່ານຈໍາເປັນຕ້ອງເລີ່ມເຮັດວຽກໂດຍບໍ່ຕ້ອງໃຊ້ຕົວຈັດການສະພາບການ:

client = APIClient(clieng_args)

ການທົດສອບການເຊື່ອມຕໍ່

ວິທີທີ່ງ່າຍທີ່ສຸດທີ່ຈະກວດເບິ່ງວ່າການເຊື່ອມຕໍ່ກົງກັບຕົວກໍານົດການທີ່ກໍານົດໄວ້ແມ່ນໃຊ້ວິທີການ check_fingerprint. ຖ້າການກວດສອບຜົນລວມຂອງ sha1 hash ສໍາລັບລາຍນິ້ວມືຂອງໃບຢັ້ງຢືນ API ຂອງເຄື່ອງແມ່ຂ່າຍລົ້ມເຫລວ (ວິທີການສົ່ງຄືນ ທີ່ບໍ່ຖືກຕ້ອງ), ຫຼັງຈາກນັ້ນ, ນີ້ມັກຈະເກີດຈາກບັນຫາການເຊື່ອມຕໍ່ແລະພວກເຮົາສາມາດຢຸດເຊົາການດໍາເນີນໂຄງການ (ຫຼືໃຫ້ຜູ້ໃຊ້ໂອກາດທີ່ຈະແກ້ໄຂຂໍ້ມູນການເຊື່ອມຕໍ່):

    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 fingerprint ໃນເຄື່ອງແມ່ຂ່າຍ API. ແຕ່ຖ້າ, ເມື່ອກວດເບິ່ງລາຍນິ້ວມື sha1 ຂອງໃບຢັ້ງຢືນເຊີບເວີ API, ກວດພົບຂໍ້ຜິດພາດ (ໃບຢັ້ງຢືນບໍ່ຮູ້ຈັກຫຼືມີການປ່ຽນແປງ), ວິທີການ. check_fingerprint ຈະໃຫ້ໂອກາດທີ່ຈະເພີ່ມ / ປ່ຽນແປງຂໍ້ມູນກ່ຽວກັບມັນຢູ່ໃນເຄື່ອງທ້ອງຖິ່ນໂດຍອັດຕະໂນມັດ. ການກວດສອບນີ້ສາມາດຖືກປິດການໃຊ້ງານຢ່າງສົມບູນ (ແຕ່ນີ້ສາມາດແນະນໍາພຽງແຕ່ຖ້າສະຄິບຖືກດໍາເນີນການຢູ່ໃນເຄື່ອງແມ່ຂ່າຍ API ຕົວມັນເອງ, ເມື່ອເຊື່ອມຕໍ່ກັບ 127.0.0.1), ໂດຍໃຊ້ການໂຕ້ຖຽງ APIClientArgs - unsafe_auto_ຍອມຮັບ (ເບິ່ງເພີ່ມເຕີມກ່ຽວກັບ APIClientArgs ກ່ອນຫນ້ານີ້ໃນ "ການກໍານົດຕົວກໍານົດການເຊື່ອມຕໍ່").

client_args = APIClientArgs(unsafe_auto_accept=True)

ເຂົ້າສູ່ລະບົບ API server

У APIClient ມີຫຼາຍເຖິງ 3 ວິທີການສໍາລັບການເຂົ້າສູ່ລະບົບ API server, ແລະແຕ່ລະຄົນເຂົ້າໃຈຄວາມຫມາຍ sid(session-id), ເຊິ່ງຖືກນໍາໃຊ້ໂດຍອັດຕະໂນມັດໃນແຕ່ລະການໂທ API ຕໍ່ໄປໃນ header (ຊື່ໃນ header ຂອງພາລາມິເຕີນີ້ແມ່ນ. X-chkp-sid), ດັ່ງນັ້ນບໍ່ຈໍາເປັນຕ້ອງດໍາເນີນການເພີ່ມເຕີມພາລາມິເຕີນີ້.

ວິທີການເຂົ້າສູ່ລະບົບ

ທາງ​ເລືອກ​ການ​ນໍາ​ໃຊ້​ການ​ເຂົ້າ​ສູ່​ລະ​ບົບ​ແລະ​ລະ​ຫັດ​ຜ່ານ (ໃນ​ຕົວ​ຢ່າງ​, ຊື່​ຜູ້​ບໍ​ລິ​ຫານ​ແລະ​ລະ​ຫັດ​ຜ່ານ 1q2w3e ຖືກ​ຜ່ານ​ເປັນ​ການ​ໂຕ້​ຖຽງ​ຕໍາ​ແຫນ່ງ​)​:

     login = client.login('admin', '1q2w3e')  

ຕົວກໍານົດການທາງເລືອກເພີ່ມເຕີມແມ່ນມີຢູ່ໃນວິທີການເຂົ້າສູ່ລະບົບ, ນີ້ແມ່ນຊື່ແລະຄ່າເລີ່ມຕົ້ນຂອງພວກມັນ:

continue_last_session=False, domain=None, read_only=False, payload=None

ວິທີການເຂົ້າສູ່ລະບົບ_with_api_key

ທາງເລືອກທີ່ໃຊ້ api key (ຮອງຮັບຕັ້ງແຕ່ເວີຊັນການຈັດການ R80.40/Management API v1.6, "3TsbPJ8ZKjaJGvFyoFqHFA==" ນີ້ແມ່ນຄ່າຫຼັກ API ສໍາລັບຫນຶ່ງໃນຜູ້ໃຊ້ໃນເຊີບເວີການຈັດການດ້ວຍວິທີການອະນຸຍາດຫຼັກ API):

     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') 

ໃນ​ວິ​ທີ​ການ​ login_with_api_key ຕົວກໍານົດການທາງເລືອກດຽວກັນແມ່ນມີຢູ່ໃນວິທີການ ເຂົ້າ​ສູ່​ລະ​ບົບ.

ວິທີການເຂົ້າສູ່ລະບົບ_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 ທີ່ເຮັດວຽກນີ້ໂດຍອັດຕະໂນມັດ. ຕົວຢ່າງຂອງການໂທທີ່ວິທີການນີ້ຕ້ອງການ: show-sessions, show-hosts, show-networks, show-wildcards, show-group, show-address-ranges, show-simple-gateways, show-simple-clusters, show-access-roles, show-trusted-client, ຊຸດສະແດງ. ໃນຄວາມເປັນຈິງ, ພວກເຮົາເຫັນຄໍາຫຼາຍໃນຊື່ຂອງການໂທ 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.

ທໍາອິດ, ໃຫ້ເບິ່ງວິທີການໂທເຮັດວຽກ add-host и add-address-range. ສົມມຸດວ່າພວກເຮົາຈໍາເປັນຕ້ອງສ້າງທີ່ຢູ່ IP ທັງຫມົດຂອງເຄືອຂ່າຍຍ່ອຍ 192.168.0.0/24, octet ສຸດທ້າຍແມ່ນ 5, ເປັນວັດຖຸຂອງປະເພດເຈົ້າພາບ, ແລະຂຽນທີ່ຢູ່ IP ອື່ນໆທັງຫມົດເປັນວັດຖຸຂອງປະເພດຊ່ວງທີ່ຢູ່. ໃນກໍລະນີນີ້, ຍົກເວັ້ນທີ່ຢູ່ subnet ແລະທີ່ຢູ່ອອກອາກາດ.

ດັ່ງນັ້ນ, ຂ້າງລຸ່ມນີ້ແມ່ນສະຄິບທີ່ແກ້ໄຂບັນຫານີ້ແລະສ້າງ 50 ວັດຖຸຂອງປະເພດເຈົ້າພາບແລະ 51 ວັດຖຸຂອງປະເພດທີ່ຢູ່. ເພື່ອແກ້ໄຂບັນຫາ, 101 ການໂທ API ແມ່ນຕ້ອງການ (ບໍ່ນັບການໂທອອກສຸດທ້າຍ). ນອກຈາກນັ້ນ, ການນໍາໃຊ້ໂມດູນ timeit, ພວກເຮົາຄິດໄລ່ເວລາທີ່ມັນໃຊ້ເວລາເພື່ອປະຕິບັດ script ຈົນກ່ວາການປ່ຽນແປງຈະຖືກເຜີຍແຜ່.

ສະຄຣິບໂດຍໃຊ້ 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')

ໃນສະພາບແວດລ້ອມຫ້ອງທົດລອງຂອງຂ້ອຍ, script ນີ້ໃຊ້ເວລາລະຫວ່າງ 30 ຫາ 50 ວິນາທີເພື່ອປະຕິບັດ, ຂຶ້ນກັບການໂຫຼດໃນເຄື່ອງແມ່ຂ່າຍການຈັດການ.

ຕອນນີ້ໃຫ້ເບິ່ງວິທີການແກ້ໄຂບັນຫາດຽວກັນໂດຍໃຊ້ການໂທ API add-objects-batch, ສະຫນັບສະຫນູນທີ່ໄດ້ຖືກເພີ່ມເຂົ້າໃນ API ຮຸ່ນ 1.6. ການໂທນີ້ອະນຸຍາດໃຫ້ທ່ານສ້າງວັດຖຸຈໍານວນຫຼາຍໃນເວລາດຽວກັນໃນຫນຶ່ງຄໍາຮ້ອງຂໍ API. ຍິ່ງໄປກວ່ານັ້ນ, ເຫຼົ່ານີ້ສາມາດເປັນວັດຖຸຂອງປະເພດຕ່າງໆ (ຕົວຢ່າງ, hosts, subnets ແລະໄລຍະທີ່ຢູ່). ດັ່ງນັ້ນ, ວຽກງານຂອງພວກເຮົາສາມາດແກ້ໄຂໄດ້ພາຍໃນກອບຂອງການໂທ 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, ການໂທປະເພດ batch ແລ່ນໄວກວ່າ 10 ເທົ່າ. ໃນຈໍານວນຂະຫນາດໃຫຍ່ຂອງວັດຖຸ, ຄວາມແຕກຕ່າງຈະປະທັບໃຈຫຼາຍ.

ໃນປັດຈຸບັນໃຫ້ເຮົາເບິ່ງວິທີການເຮັດວຽກຮ່ວມກັບ set-objects-batch. ການນໍາໃຊ້ການໂທ API ນີ້, ພວກເຮົາສາມາດປ່ຽນພາລາມິເຕີເປັນຈໍານວນຫຼວງຫຼາຍ. ໃຫ້ກໍານົດເຄິ່ງທໍາອິດຂອງທີ່ຢູ່ຈາກຕົວຢ່າງກ່ອນຫນ້າ (ເຖິງ .124 hosts, ແລະ ranges ເກີນໄປ) ໄປຫາ color sienna, ແລະກໍາຫນົດສີ khaki ກັບເຄິ່ງທີສອງຂອງທີ່ຢູ່.

ການປ່ຽນສີຂອງວັດຖຸທີ່ສ້າງຂຶ້ນໃນຕົວຢ່າງທີ່ຜ່ານມາ

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 consoles ກັບຮູບແບບນະໂຍບາຍ Unified ຍັງໄດ້ຮັບການສະຫນັບສະຫນູນ 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

ທຸກສິ່ງທຸກຢ່າງແມ່ນຄືກັນ README.md ມີຂໍ້ມູນກ່ຽວກັບວິທີແລ່ນສະຄຣິບ Python ໂດຍກົງຈາກເຊີບເວີຄວບຄຸມ. ນີ້ສາມາດສະດວກໃນເວລາທີ່ທ່ານບໍ່ສາມາດເຊື່ອມຕໍ່ກັບເຄື່ອງແມ່ຂ່າຍຂອງ API ຈາກເຄື່ອງອື່ນ. ຂ້າພະເຈົ້າໄດ້ບັນທຶກວິດີໂອຫົກນາທີທີ່ຂ້າພະເຈົ້າເບິ່ງຢູ່ໃນການຕິດຕັ້ງໂມດູນ cpapi ແລະຄຸນສົມບັດຂອງການໃຊ້ສະຄຣິບ Python ໃນເຊີບເວີຄວບຄຸມ. ຕົວຢ່າງເຊັ່ນ, script ແມ່ນດໍາເນີນການທີ່ອັດຕະໂນມັດການຕັ້ງຄ່າປະຕູໃຫມ່ສໍາລັບວຽກງານເຊັ່ນ: ການກວດສອບເຄືອຂ່າຍ. ກວດກາຄວາມປອດໄພ. ໃນບັນດາຄຸນສົມບັດທີ່ຂ້ອຍຕ້ອງຈັດການກັບ: ຟັງຊັນຍັງບໍ່ທັນປາກົດຢູ່ໃນ Python 2.7 ການປ້ອນຂໍ້ມູນ, ດັ່ງນັ້ນເພື່ອປະມວນຜົນຂໍ້ມູນທີ່ຜູ້ໃຊ້ເຂົ້າມາ, ຫນ້າທີ່ຖືກນໍາໃຊ້ raw_input. ຖ້າບໍ່ດັ່ງນັ້ນ, ລະຫັດແມ່ນຄືກັນກັບການເປີດຕົວຈາກເຄື່ອງອື່ນໆ, ພຽງແຕ່ມັນສະດວກກວ່າທີ່ຈະໃຊ້ຟັງຊັນ login_as_root, ເພື່ອບໍ່ໃຫ້ລະບຸຊື່ຜູ້ໃຊ້ຂອງຕົນເອງ, ລະຫັດຜ່ານແລະທີ່ຢູ່ IP ຂອງເຄື່ອງແມ່ຂ່າຍການຈັດການອີກເທື່ອຫນຶ່ງ.

Script ສໍາລັບການຕິດຕັ້ງໄວຂອງ Security CheckUp

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()

ໄຟລ໌ຕົວຢ່າງທີ່ມີວັດຈະນານຸກົມລະຫັດຜ່ານ additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}

ສະຫລຸບ

ບົດຄວາມນີ້ຈະພິຈາລະນາພຽງແຕ່ຄວາມເປັນໄປໄດ້ພື້ນຖານຂອງການເຮັດວຽກ Python SDK ແລະໂມດູນ cpapi(ຕາມທີ່ທ່ານອາດຈະໄດ້ຄາດເດົາ, ເຫຼົ່ານີ້ແມ່ນຄໍາສັບຄ້າຍຄືກັນ), ແລະໂດຍການສຶກສາລະຫັດໃນໂມດູນນີ້, ທ່ານຈະຄົ້ນພົບໂອກາດຫຼາຍສໍາລັບການເຮັດວຽກກັບມັນ. ມັນເປັນໄປໄດ້ວ່າທ່ານຈະຕ້ອງການເສີມມັນດ້ວຍຫ້ອງຮຽນ, ຫນ້າທີ່, ວິທີການແລະຕົວແປຂອງທ່ານເອງ. ທ່ານສາມາດແບ່ງປັນວຽກງານຂອງທ່ານແລະເບິ່ງສະຄິບອື່ນສໍາລັບ Check Point ໃນສ່ວນ CodeHub ຢູ່ໃນຊຸມຊົນ CheckMates, ເຊິ່ງນໍາເອົາທັງຜູ້ພັດທະນາຜະລິດຕະພັນແລະຜູ້ໃຊ້ຮ່ວມກັນ.

ຍິນດີ coding ແລະຂໍຂອບໃຈສໍາລັບການອ່ານຈົນຈົບ!

ແຫຼ່ງຂໍ້ມູນ: www.habr.com