Python SDK सह चेक पॉइंट API सरलीकृत करणे

API सह परस्परसंवादाची संपूर्ण शक्ती प्रोग्राम कोडसह एकत्रितपणे वापरली जाते तेव्हा प्रकट होते, जेव्हा API प्रतिसादांचे विश्लेषण करण्यासाठी API विनंत्या आणि साधने गतिशीलपणे व्युत्पन्न करणे शक्य होते. मात्र, तरीही ते लक्षात येत नाही पायथन सॉफ्टवेअर डेव्हलपमेंट किट (यापुढे Python SDK म्हणून संदर्भित) साठी पॉइंट मॅनेजमेंट API तपासा, पण व्यर्थ. हे विकासक आणि ऑटोमेशन उत्साही लोकांचे जीवन लक्षणीयरीत्या सुलभ करते. पायथनने अलीकडे प्रचंड लोकप्रियता मिळवली आहे आणि मी अंतर भरून मुख्य वैशिष्ट्यांचे पुनरावलोकन करण्याचा निर्णय घेतला. पॉइंट API पायथन डेव्हलपमेंट किट तपासा. हा लेख हाब्रेवरील दुसर्‍या लेखात उत्कृष्ट जोड म्हणून काम करतो पॉइंट R80.10 API तपासा. CLI, स्क्रिप्ट आणि बरेच काही द्वारे व्यवस्थापन. आम्ही Python SDK वापरून स्क्रिप्ट कसे लिहायचे ते पाहू आणि आवृत्ती 1.6 (R80.40 पासून समर्थित) मधील नवीन व्यवस्थापन API कार्यक्षमतेकडे जवळून पाहू. लेख समजून घेण्यासाठी, तुम्हाला APIs आणि Python सह काम करण्याचे मूलभूत ज्ञान आवश्यक असेल.

चेक पॉइंट सक्रियपणे API विकसित करत आहे आणि याक्षणी खालील रिलीझ केले गेले आहेत:

• पॉइंट मॅनेजमेंट API तपासा (वर्तमान आवृत्ती 1.6) — API द्वारे कंट्रोल सर्व्हरसह कार्य करा (आणि कंट्रोल सर्व्हरद्वारे नियंत्रित गेटवेवर स्क्रिप्ट कार्यान्वित करण्याची क्षमता)
• चेक पॉइंट GAIA API (वर्तमान आवृत्ती 1.4) - सुरक्षा गेटवेसह कार्य करा
• धोका प्रतिबंधक API 1.0 — चेक पॉइंट क्लाउडमध्ये सँडबॉक्ससह कार्य करणे
• ओळख जागरूकता API — गेटवेवर आयडेंटिटी अवेअरनेस ब्लेडसह काम करणे
• सुरक्षा व्यवस्थापन पोर्टल API - SMB गेटवे व्यवस्थापन पोर्टलसह कार्य करा (SMB गेटवे बद्दल अधिक)
• IoT API - IoT नियंत्रकांशी संवाद
• CloudGuard Connect API - च्या सोबत काम करतो क्लाउडगार्ड कनेक्ट (SD-WAN सुरक्षा उपाय)
• Dome9 API - च्या सोबत काम करतो घुमट ३९

Python SDK सध्या फक्त मॅनेजमेंट API आणि परस्परसंवादाला समर्थन देते Gaia API. आपण या मॉड्यूलमधील सर्वात महत्वाचे वर्ग, पद्धती आणि चल पाहू.

मॉड्यूल स्थापित करत आहे

मॉड्यूल cpapi पासून जलद आणि सहज स्थापित होते गिथबवर अधिकृत चेक पॉइंट रेपॉजिटरी मदतीने वाळीत टाकणे. मध्ये तपशीलवार स्थापना सूचना उपलब्ध आहेत README.md. हे मॉड्यूल पायथन आवृत्त्या 2.7 आणि 3.7 सह कार्य करण्यासाठी अनुकूल केले आहे. या लेखात, पायथन 3.7 वापरून उदाहरणे दिली जातील. तथापि, पायथन SDK चेक पॉइंट मॅनेजमेंट सर्व्हर (स्मार्ट मॅनेजमेंट) वरून थेट चालविला जाऊ शकतो, परंतु ते केवळ पायथन 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()

परंतु तृतीय-पक्ष होस्टवर चालत असताना, तुम्हाला 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 वर्गाच्या उदाहरणांमध्ये वापरले जाऊ शकणारे युक्तिवाद चेक पॉइंट प्रशासकांसाठी अंतर्ज्ञानी आहेत आणि त्यांना अतिरिक्त टिप्पण्यांची आवश्यकता नाही.

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, आम्ही त्यांच्याबद्दल थोडे पुढे बोलू) API सर्व्हरवर sha1 फिंगरप्रिंट प्रमाणपत्र. परंतु, API सर्व्हर प्रमाणपत्राचे sha1 फिंगरप्रिंट तपासताना, त्रुटी आढळल्यास (प्रमाणपत्र अज्ञात आहे किंवा बदलले गेले आहे), पद्धत तपासा_फिंगरप्रिंट स्थानिक मशीनवर आपोआप माहिती जोडण्याची/बदलण्याची संधी प्रदान करेल. ही तपासणी पूर्णपणे अक्षम केली जाऊ शकते (परंतु APIClientArgs युक्तिवाद वापरून, 127.0.0.1 शी कनेक्ट करताना, API सर्व्हरवर स्क्रिप्ट चालवल्या गेल्या असतील तरच याची शिफारस केली जाऊ शकते - unsafe_auto_accept ("कनेक्शन पॅरामीटर्स परिभाषित करणे" मध्ये APIClientArgs बद्दल अधिक पहा).

client_args = APIClientArgs(unsafe_auto_accept=True)

API सर्व्हरवर लॉग इन करा

У APIClient API सर्व्हरवर लॉग इन करण्यासाठी तब्बल 3 पद्धती आहेत आणि त्या प्रत्येकाचा अर्थ समजतो sid(सत्र-आयडी), जे शीर्षलेखातील प्रत्येक त्यानंतरच्या API कॉलमध्ये स्वयंचलितपणे वापरले जाते (या पॅरामीटरच्या शीर्षलेखातील नाव आहे X-chkp-sid), त्यामुळे या पॅरामीटरवर पुढील प्रक्रिया करण्याची आवश्यकता नाही.

लॉगिन पद्धत

लॉगिन आणि पासवर्ड वापरण्याचा पर्याय (उदाहरणार्थ, वापरकर्तानाव प्रशासक आणि संकेतशब्द 1q2w3e स्थानात्मक युक्तिवाद म्हणून पास केले जातात):

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

लॉगिन पद्धतीमध्ये अतिरिक्त पर्यायी मापदंड देखील उपलब्ध आहेत; येथे त्यांची नावे आणि डीफॉल्ट मूल्ये आहेत:

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

लॉगिन_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_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_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 कॉलच्या परिणामांवर प्रक्रिया करत आहे

यानंतर तुम्ही क्लासचे व्हेरिएबल्स आणि पद्धती वापरू शकता API प्रतिसाद(संदर्भ व्यवस्थापकाच्या आत आणि बाहेर दोन्ही). वर्गात API प्रतिसाद 4 पद्धती आणि 5 व्हेरिएबल्स पूर्वनिर्धारित आहेत; आम्ही सर्वात महत्वाच्या गोष्टींवर अधिक तपशीलवार विचार करू.

यश

सुरुवातीला, API कॉल यशस्वी झाला आणि परिणाम परत आला याची खात्री करणे चांगली कल्पना असेल. यासाठी एक पद्धत आहे यश:

In [49]: api_versions.success                                                   
Out[49]: True

API कॉल यशस्वी झाल्यास सत्य (प्रतिसाद कोड - 200) आणि यशस्वी न झाल्यास असत्य (इतर कोणताही प्रतिसाद कोड) परत करतो. प्रतिसाद कोडवर अवलंबून भिन्न माहिती प्रदर्शित करण्यासाठी 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

या प्रकरणात, यशाच्या स्थितीचे मूल्य बदलणे आवश्यक असू शकते. तांत्रिकदृष्ट्या, तुम्ही तेथे काहीही ठेवू शकता, अगदी नियमित स्ट्रिंग देखील. परंतु एक वास्तविक उदाहरण हे पॅरामीटर काही विशिष्ट परिस्थितींमध्ये असत्य वर रीसेट करणे आहे. खाली, व्यवस्थापन सर्व्हरवर कार्य चालू असताना उदाहरणाकडे लक्ष द्या, परंतु आम्ही ही विनंती अयशस्वी मानू (आम्ही यश व्हेरिएबल सेट करू खोटे, 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 1.6 मध्ये जोडलेले API कॉल वापरणारी उदाहरणे खालील आहेत.

प्रथम, कॉल कसे कार्य करतात ते पाहू ऍड-होस्ट и जोडा-पत्ता-श्रेणी. समजा की आपल्याला सबनेट 192.168.0.0/24 चे सर्व IP पत्ते तयार करावे लागतील, ज्यातील शेवटचा ऑक्टेट 5 आहे, होस्ट प्रकाराचे ऑब्जेक्ट म्हणून, आणि इतर सर्व IP पत्ते अॅड्रेस रेंज प्रकाराचे ऑब्जेक्ट म्हणून लिहा. या प्रकरणात, सबनेट पत्ता आणि प्रसारण पत्ता वगळा.

तर, खाली एक स्क्रिप्ट आहे जी या समस्येचे निराकरण करते आणि होस्ट प्रकाराचे 50 ऑब्जेक्ट्स आणि अॅड्रेस रेंज प्रकाराचे 51 ऑब्जेक्ट्स तयार करते. समस्येचे निराकरण करण्यासाठी, 101 API कॉल आवश्यक आहेत (अंतिम प्रकाशन कॉल मोजत नाही). तसेच, timeit मॉड्यूल वापरून, बदल प्रकाशित होईपर्यंत स्क्रिप्ट कार्यान्वित करण्यासाठी लागणारा वेळ आम्ही मोजतो.

ऍड-होस्ट आणि ऍड-पत्ता-श्रेणी वापरून स्क्रिप्ट

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 कॉलच्या चौकटीत सोडवले जाऊ शकते.

अॅड-ऑब्जेक्ट्स-बॅच वापरून स्क्रिप्ट

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 कॉलचा वापर करून, आम्ही कोणतेही पॅरामीटर मोठ्या प्रमाणात बदलू शकतो. आधीच्या उदाहरणावरून पत्त्यांचा पहिला अर्धा भाग (.१२४ होस्ट्सपर्यंत आणि रेंजही) कलर सिएना वर सेट करू आणि पत्त्यांच्या दुसऱ्या अर्ध्या भागाला रंग खाकी देऊ.

मागील उदाहरणामध्ये तयार केलेल्या वस्तूंचा रंग बदलणे

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 कॉलमध्‍ये एकाधिक ऑब्जेक्ट हटवू शकता डिलीट-ऑब्जेक्ट्स-बॅच. आता कोडचे उदाहरण पाहू जे पूर्वी तयार केलेले सर्व होस्ट हटवते अॅड-ऑब्जेक्ट्स-बॅच.

डिलीट-ऑब्जेक्ट्स-बॅच वापरून ऑब्जेक्ट्स हटवणे

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)

चेक पॉइंट सॉफ्टवेअरच्या नवीन रिलीझमध्ये दिसणारी सर्व फंक्शन्स ताबडतोब API कॉल प्राप्त करतात. अशा प्रकारे, R80.40 मध्ये रिव्हर्ट टू रिव्हिजन आणि स्मार्ट टास्क सारखी “वैशिष्ट्ये” दिसू लागली आणि त्यांच्यासाठी संबंधित API कॉल त्वरित तयार केले गेले. शिवाय, लेगसी कन्सोलवरून युनिफाइड पॉलिसी मोडमध्ये जाताना सर्व कार्यक्षमता देखील API समर्थन प्राप्त करते. उदाहरणार्थ, सॉफ्टवेअर आवृत्ती R80.40 मधील दीर्घ-प्रतीक्षित अपडेट म्हणजे HTTPS तपासणी धोरणाची लेगसी मोडमधून युनिफाइड पॉलिसी मोडमध्ये हलवणे आणि या कार्यक्षमतेला त्वरित 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")

चेक पॉइंट व्यवस्थापन सर्व्हरवर पायथन स्क्रिप्ट चालवणे

सर्व काही तसेच आहे README.md नियंत्रण सर्व्हरवरून पायथन स्क्रिप्ट्स कसे चालवायचे याबद्दल माहिती समाविष्टीत आहे. जेव्हा तुम्ही दुसर्‍या मशीनवरून API सर्व्हरशी कनेक्ट करू शकत नसाल तेव्हा हे सोयीचे असू शकते. मी सहा मिनिटांचा व्हिडिओ रेकॉर्ड केला आहे ज्यामध्ये मी मॉड्यूल स्थापित करताना पाहतो cpapi आणि कंट्रोल सर्व्हरवर पायथन स्क्रिप्ट चालवण्याची वैशिष्ट्ये. उदाहरण म्हणून, एक स्क्रिप्ट चालवली जाते जी नेटवर्क ऑडिटिंगसारख्या कार्यासाठी नवीन गेटवेचे कॉन्फिगरेशन स्वयंचलित करते सुरक्षा तपासणी. मला ज्या वैशिष्ट्यांचा सामना करावा लागला त्यापैकी: फंक्शन अद्याप पायथन 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","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

निष्कर्ष

हा लेख कामाच्या केवळ मूलभूत शक्यतांचा अभ्यास करतो पायथन एसडीके आणि मॉड्यूल cpapi(तुम्ही अंदाज लावला असेल, हे प्रत्यक्षात समानार्थी शब्द आहेत), आणि या मॉड्यूलमधील कोडचा अभ्यास करून तुम्हाला त्यासोबत काम करण्याच्या आणखी संधी सापडतील. हे शक्य आहे की तुम्हाला ते तुमच्या स्वतःच्या वर्ग, कार्ये, पद्धती आणि चलांसह पूरक करायचे असेल. तुम्ही तुमचे काम नेहमी शेअर करू शकता आणि विभागातील चेक पॉइंटसाठी इतर स्क्रिप्ट पाहू शकता कोडहब समाजात चेकमेट्स, जे उत्पादन विकासक आणि वापरकर्ते दोघांना एकत्र आणते.

आनंदी कोडिंग आणि शेवटपर्यंत वाचल्याबद्दल धन्यवाद!

स्त्रोत: www.habr.com