पायथन एसडीके के साथ चेक प्वाइंट एपीआई को सरल बनाना

प्रोग्राम कोड के साथ उपयोग करने पर एपीआई के साथ इंटरैक्शन की पूरी शक्ति का पता चलता है, जब एपीआई प्रतिक्रियाओं का विश्लेषण करने के लिए एपीआई अनुरोधों और उपकरणों को गतिशील रूप से उत्पन्न करना संभव हो जाता है। हालाँकि, यह अभी भी ध्यान देने योग्य नहीं है पायथन सॉफ्टवेयर डेवलपमेंट किट (इसके बाद इसे पायथन एसडीके के रूप में संदर्भित किया जाएगा)। चेक प्वाइंट प्रबंधन एपीआई, परन्तु सफलता नहीं मिली। यह डेवलपर्स और स्वचालन उत्साही लोगों के जीवन को काफी सरल बनाता है। पायथन ने हाल ही में काफी लोकप्रियता हासिल की है और मैंने इस अंतर को भरने और मुख्य विशेषताओं की समीक्षा करने का फैसला किया है। चेक प्वाइंट एपीआई पायथन डेवलपमेंट किट. यह लेख हैब्रे पर एक अन्य लेख के लिए एक उत्कृष्ट अतिरिक्त के रूप में कार्य करता है प्वाइंट R80.10 एपीआई जांचें। सीएलआई, स्क्रिप्ट और बहुत कुछ के माध्यम से प्रबंधन. हम देखेंगे कि पायथन एसडीके का उपयोग करके स्क्रिप्ट कैसे लिखें और संस्करण 1.6 (आर80.40 से समर्थित) में नई प्रबंधन एपीआई कार्यक्षमता पर करीब से नज़र डालें। लेख को समझने के लिए, आपको एपीआई और पायथन के साथ काम करने के बुनियादी ज्ञान की आवश्यकता होगी।

चेक प्वाइंट सक्रिय रूप से एपीआई विकसित कर रहा है और फिलहाल निम्नलिखित जारी किए गए हैं:

• चेक प्वाइंट प्रबंधन एपीआई (वर्तमान संस्करण 1.6) - एपीआई के माध्यम से नियंत्रण सर्वर के साथ काम करें (और नियंत्रण सर्वर द्वारा नियंत्रित गेटवे पर स्क्रिप्ट निष्पादित करने की क्षमता)
• चेक प्वाइंट जीएआईए एपीआई (वर्तमान संस्करण 1.4) - सुरक्षा गेटवे के साथ काम करें
• खतरा निवारण एपीआई 1.0 - चेक प्वाइंट क्लाउड में सैंडबॉक्स के साथ काम करना
• पहचान जागरूकता एपीआई - गेटवे पर आइडेंटिटी अवेयरनेस ब्लेड के साथ काम करना
• सुरक्षा प्रबंधन पोर्टल एपीआई — एसएमबी गेटवे प्रबंधन पोर्टल के साथ काम करें (एसएमबी गेटवे के बारे में अधिक जानकारी)
• आईओटी एपीआई - IoT नियंत्रकों के साथ सहभागिता
• क्लाउडगार्ड कनेक्ट एपीआई - के साथ काम क्लाउडगार्ड कनेक्ट (एसडी-डब्ल्यूएएन सुरक्षा समाधान)
• डोम9 एपीआई - के साथ काम डोमे9

पायथन एसडीके वर्तमान में केवल प्रबंधन एपीआई के साथ इंटरैक्शन का समर्थन करता है गैया एपीआई. हम इस मॉड्यूल में सबसे महत्वपूर्ण वर्गों, विधियों और चरों को देखेंगे।

मॉड्यूल स्थापना

मॉड्यूल cpapi से जल्दी और आसानी से इंस्टॉल हो जाता है जीथब पर आधिकारिक चेक प्वाइंट रिपॉजिटरी के माध्यम से रंज. विस्तृत स्थापना निर्देश यहां उपलब्ध हैं README.md. यह मॉड्यूल पायथन संस्करण 2.7 और 3.7 के साथ काम करने के लिए अनुकूलित है। इस आलेख में, Python 3.7 का उपयोग करके उदाहरण दिए जाएंगे। हालाँकि, Python SDK को सीधे चेक प्वाइंट मैनेजमेंट सर्वर (स्मार्ट मैनेजमेंट) से चलाया जा सकता है, लेकिन वे केवल Python 2.7 का समर्थन करते हैं, इसलिए अंतिम अनुभाग संस्करण 2.7 के लिए कोड प्रदान करेगा। मॉड्यूल स्थापित करने के तुरंत बाद, मैं निर्देशिकाओं में उदाहरण देखने की सलाह देता हूं उदाहरण_पायथन2 и उदाहरण_पायथन3.

प्रारंभ करना

सीपीएपीआई मॉड्यूल के घटकों के साथ काम करने में सक्षम होने के लिए, हमें मॉड्यूल से आयात करने की आवश्यकता है cpapi कम से कम दो आवश्यक वर्ग:

एपीआईक्लाइंट и APIClientArgs

from cpapi import APIClient, APIClientArgs

वर्ग APIClientArgs एपीआई सर्वर और क्लास से कनेक्शन पैरामीटर के लिए जिम्मेदार है एपीआईक्लाइंट एपीआई के साथ इंटरेक्शन के लिए जिम्मेदार है।

कनेक्शन पैरामीटर का निर्धारण

एपीआई से कनेक्ट करने के लिए विभिन्न मापदंडों को परिभाषित करने के लिए, आपको क्लास का एक उदाहरण बनाना होगा APIClientArgs. सिद्धांत रूप में, इसके पैरामीटर पूर्वनिर्धारित होते हैं और नियंत्रण सर्वर पर स्क्रिप्ट चलाते समय, उन्हें निर्दिष्ट करने की आवश्यकता नहीं होती है।

client_args = APIClientArgs()

लेकिन तृतीय-पक्ष होस्ट पर चलते समय, आपको एपीआई सर्वर (जिसे प्रबंधन सर्वर भी कहा जाता है) का कम से कम आईपी पता या होस्ट नाम निर्दिष्ट करना होगा। नीचे दिए गए उदाहरण में, हम सर्वर कनेक्शन पैरामीटर को परिभाषित करते हैं और इसे एक स्ट्रिंग के रूप में प्रबंधन सर्वर का आईपी पता निर्दिष्ट करते हैं।

client_args = APIClientArgs(server='192.168.47.241')

आइए उन सभी मापदंडों और उनके डिफ़ॉल्ट मानों को देखें जिनका उपयोग एपीआई सर्वर से कनेक्ट करते समय किया जा सकता है:

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 वर्ग के उदाहरणों में जिन तर्कों का उपयोग किया जा सकता है, वे चेक प्वाइंट प्रशासकों के लिए सहज हैं और उन्हें अतिरिक्त टिप्पणियों की आवश्यकता नहीं है।

एपीआईक्लाइंट और संदर्भ प्रबंधक के माध्यम से कनेक्ट हो रहा है

वर्ग एपीआईक्लाइंट इसका उपयोग करने का सबसे सुविधाजनक तरीका संदर्भ प्रबंधक है। एपीआईक्लाइंट क्लास के एक उदाहरण में पास किए जाने वाले सभी कनेक्शन पैरामीटर हैं जो पिछले चरण में परिभाषित किए गए थे।

with APIClient(client_args) as client:

संदर्भ प्रबंधक स्वचालित रूप से एपीआई सर्वर पर लॉगिन कॉल नहीं करेगा, लेकिन इससे बाहर निकलने पर यह लॉगआउट कॉल करेगा। यदि किसी कारण से एपीआई कॉल के साथ काम खत्म करने के बाद लॉगआउट की आवश्यकता नहीं है, तो आपको संदर्भ प्रबंधक का उपयोग किए बिना काम शुरू करना होगा:

client = APIClient(clieng_args)

कनेक्शन परीक्षण

यह जांचने का सबसे आसान तरीका कि कनेक्शन निर्दिष्ट मापदंडों को पूरा करता है या नहीं, विधि का उपयोग करना है check_fingerprint. यदि सर्वर एपीआई प्रमाणपत्र के फिंगरप्रिंट के लिए sha1 हैश राशि का सत्यापन विफल हो जाता है (विधि वापस आ जाती है झूठा), तो यह आमतौर पर कनेक्शन समस्याओं के कारण होता है और हम प्रोग्राम के निष्पादन को रोक सकते हैं (या उपयोगकर्ता को कनेक्शन डेटा को सही करने का अवसर दे सकते हैं):

    if client.check_fingerprint() is False:
        print("Could not get the server's fingerprint - Check connectivity with the server.")
        exit(1)

कृपया ध्यान दें कि भविष्य में कक्षा एपीआईक्लाइंट प्रत्येक एपीआई कॉल की जांच करेगा (तरीके एपीआई_कॉल и api_query, हम उनके बारे में थोड़ा आगे बात करेंगे) एपीआई सर्वर पर sha1 फिंगरप्रिंट प्रमाणपत्र। लेकिन अगर, एपीआई सर्वर प्रमाणपत्र के sha1 फ़िंगरप्रिंट की जाँच करते समय, एक त्रुटि का पता चलता है (प्रमाणपत्र अज्ञात है या बदल दिया गया है), तो विधि check_fingerprint स्थानीय मशीन पर स्वचालित रूप से इसके बारे में जानकारी जोड़ने/बदलने का अवसर प्रदान करेगा। APIClientArgs तर्क का उपयोग करके इस चेक को पूरी तरह से अक्षम किया जा सकता है (लेकिन इसकी अनुशंसा केवल तभी की जा सकती है जब 127.0.0.1 से कनेक्ट होने पर स्क्रिप्ट एपीआई सर्वर पर ही चलती है) - असुरक्षित_ऑटो_स्वीकार (पहले "कनेक्शन पैरामीटर परिभाषित करना" में APIClientArgs के बारे में और अधिक देखें)।

client_args = APIClientArgs(unsafe_auto_accept=True)

एपीआई सर्वर में लॉग इन करें

У एपीआईक्लाइंट एपीआई सर्वर में लॉग इन करने के लिए कम से कम 3 तरीके हैं, और उनमें से प्रत्येक का अर्थ समझता है सिड(सत्र-आईडी), जो हेडर में प्रत्येक बाद के एपीआई कॉल में स्वचालित रूप से उपयोग किया जाता है (इस पैरामीटर के हेडर में नाम है एक्स-सीएचकेपी-सिड), इसलिए इस पैरामीटर को आगे संसाधित करने की कोई आवश्यकता नहीं है।

लॉगिन विधि

लॉगिन और पासवर्ड का उपयोग करने का विकल्प (उदाहरण में, उपयोगकर्ता नाम व्यवस्थापक और पासवर्ड 1q2w3e को स्थितिगत तर्क के रूप में पारित किया गया है):

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

अतिरिक्त वैकल्पिक पैरामीटर भी लॉगिन विधि में उपलब्ध हैं; यहां उनके नाम और डिफ़ॉल्ट मान हैं:

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

विधि लॉगिन_विथ_एपीआई_की

एपीआई कुंजी का उपयोग करने का विकल्प (प्रबंधन संस्करण R80.40/प्रबंधन एपीआई v1.6 से शुरू होकर समर्थित, "3TsbPJ8ZKjaJGvFyoFqHFA==" यह एपीआई कुंजी प्राधिकरण विधि के साथ प्रबंधन सर्वर पर उपयोगकर्ताओं में से एक के लिए एपीआई कुंजी मान है):

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

विधि में लॉगिन_विथ_एपीआई_की विधि के समान ही वैकल्पिक पैरामीटर उपलब्ध हैं लॉग इन.

लॉगिन_अस_रूट विधि

एपीआई सर्वर के साथ स्थानीय मशीन में लॉगिन करने का विकल्प:

     login = client.login_as_root()

इस विधि के लिए केवल दो वैकल्पिक पैरामीटर उपलब्ध हैं:

domain=None, payload=None

और अंत में एपीआई खुद को कॉल करता है

विधियों के माध्यम से एपीआई कॉल करने के लिए हमारे पास दो विकल्प हैं एपीआई_कॉल и api_query. आइए जानें कि इनमें क्या अंतर है।

एपीआई_कॉल

यह विधि किसी भी कॉल के लिए लागू है. यदि आवश्यक हो तो हमें अनुरोध निकाय में एपीआई कॉल और पेलोड के लिए अंतिम भाग को पास करना होगा। यदि पेलोड खाली है, तो इसे बिल्कुल भी स्थानांतरित नहीं किया जा सकता है:

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

मैं तुरंत एक आरक्षण कर दूं कि यह विधि केवल उन कॉलों के लिए लागू है जिनके आउटपुट में ऑफसेट शामिल है। ऐसा अनुमान तब होता है जब इसमें बड़ी मात्रा में जानकारी होती है या हो सकती है। उदाहरण के लिए, यह प्रबंधन सर्वर पर सभी निर्मित होस्ट ऑब्जेक्ट की सूची के लिए अनुरोध हो सकता है। ऐसे अनुरोधों के लिए, एपीआई डिफ़ॉल्ट रूप से 50 ऑब्जेक्ट की एक सूची लौटाता है (आप प्रतिक्रिया में सीमा को 500 ऑब्जेक्ट तक बढ़ा सकते हैं)। और जानकारी को कई बार न खींचने के लिए, एपीआई अनुरोध में ऑफसेट पैरामीटर को बदलते हुए, एक एपीआई_क्वेरी विधि है जो यह काम स्वचालित रूप से करती है। कॉल के उदाहरण जहां इस पद्धति की आवश्यकता है: शो-सत्र, शो-होस्ट, शो-नेटवर्क, शो-वाइल्डकार्ड, शो-समूह, शो-एड्रेस-रेंज, शो-सिंपल-गेटवे, शो-सिंपल-क्लस्टर, शो-एक्सेस-भूमिकाएं, शो-विश्वसनीय-ग्राहक, शो-पैकेज. वास्तव में, हम इन एपीआई कॉलों के नाम में बहुवचन शब्द देखते हैं, इसलिए इन कॉलों को संभालना आसान होगा 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
})

एपीआई कॉल के परिणामों को संसाधित करना

इसके बाद आप क्लास के वेरिएबल्स और तरीकों का उपयोग कर सकते हैं APIResponse(संदर्भ प्रबंधक के अंदर और बाहर दोनों)। कक्षा में APIResponse 4 विधियाँ और 5 चर पूर्वनिर्धारित हैं; हम सबसे महत्वपूर्ण पर अधिक विस्तार से ध्यान देंगे।

सफलता

आरंभ करने के लिए, यह सुनिश्चित करना एक अच्छा विचार होगा कि एपीआई कॉल सफल रही और परिणाम लौटा। इसके लिए एक विधि है सफलता:

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

यदि एपीआई कॉल सफल रही (प्रतिक्रिया कोड - 200) तो सही है और यदि सफल नहीं है तो गलत है (कोई अन्य प्रतिक्रिया कोड)। प्रतिक्रिया कोड के आधार पर विभिन्न जानकारी प्रदर्शित करने के लिए एपीआई कॉल के तुरंत बाद इसका उपयोग करना सुविधाजनक है।

if api_ver.success: 
    print(api_versions.data) 
else: 
    print(api_versions.err_message) 

स्थिति का कोड

एपीआई कॉल किए जाने के बाद प्रतिक्रिया कोड लौटाता है।

In [62]: api_versions.status_code                                               
Out[62]: 400

संभावित प्रतिक्रिया कोड: 200,400,401,403,404,409,500,501.

सेट_सफलता_स्थिति

इस मामले में, सफलता की स्थिति का मान बदलना आवश्यक हो सकता है। तकनीकी रूप से, आप वहां कुछ भी डाल सकते हैं, यहां तक ​​कि एक नियमित स्ट्रिंग भी। लेकिन एक वास्तविक उदाहरण कुछ निश्चित शर्तों के तहत इस पैरामीटर को गलत पर रीसेट करना होगा। नीचे, उदाहरण पर ध्यान दें जब प्रबंधन सर्वर पर कार्य चल रहे हों, लेकिन हम इस अनुरोध को असफल मानेंगे (हम सफलता चर को यहां सेट करेंगे) झूठा, इस तथ्य के बावजूद कि एपीआई कॉल सफल रही और कोड 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']}

त्रुटि संदेश

यह जानकारी केवल तभी उपलब्ध होती है जब एपीआई अनुरोध (प्रतिक्रिया कोड) को संसाधित करते समय कोई त्रुटि उत्पन्न होती है नहीं 200). उदाहरण आउटपुट

In [107]: api_versions.error_message                                            
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'

उपयोगी उदाहरण

निम्नलिखित उदाहरण हैं जो प्रबंधन एपीआई 1.6 में जोड़े गए एपीआई कॉल का उपयोग करते हैं।

सबसे पहले, आइए देखें कि कॉल कैसे काम करती हैं ऐड-होस्ट и ऐड-एड्रेस-रेंज. मान लीजिए कि हमें सबनेट 192.168.0.0/24 के सभी आईपी पते बनाने की जरूरत है, जिसका अंतिम ऑक्टेट 5 है, होस्ट प्रकार की वस्तुओं के रूप में, और अन्य सभी आईपी पते को एड्रेस रेंज प्रकार की वस्तुओं के रूप में लिखना है। इस स्थिति में, सबनेट पता और प्रसारण पता छोड़ दें।

तो, नीचे एक स्क्रिप्ट है जो इस समस्या को हल करती है और होस्ट प्रकार की 50 ऑब्जेक्ट और एड्रेस रेंज प्रकार की 51 ऑब्जेक्ट बनाती है। समस्या को हल करने के लिए, 101 एपीआई कॉल की आवश्यकता है (अंतिम प्रकाशन कॉल की गिनती नहीं)। साथ ही, टाइमइट मॉड्यूल का उपयोग करके, हम परिवर्तन प्रकाशित होने तक स्क्रिप्ट को निष्पादित करने में लगने वाले समय की गणना करते हैं।

ऐड-होस्ट और ऐड-एड्रेस-रेंज का उपयोग कर स्क्रिप्ट

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 सेकंड का समय लगता है।

अब आइए देखें कि एपीआई कॉल का उपयोग करके उसी समस्या को कैसे हल किया जाए ऐड-ऑब्जेक्ट्स-बैच, जिसके लिए समर्थन एपीआई संस्करण 1.6 में जोड़ा गया था। यह कॉल आपको एक एपीआई अनुरोध में एक साथ कई ऑब्जेक्ट बनाने की अनुमति देता है। इसके अलावा, ये विभिन्न प्रकार की वस्तुएं हो सकती हैं (उदाहरण के लिए, होस्ट, सबनेट और एड्रेस रेंज)। इस प्रकार, हमारा कार्य एक एपीआई कॉल के ढांचे के भीतर हल किया जा सकता है।

ऐड-ऑब्जेक्ट्स-बैच का उपयोग कर स्क्रिप्ट

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 एपीआई ऑब्जेक्ट पर एक बैच टाइप कॉल 10 गुना तेजी से चलती है। बड़ी संख्या में वस्तुओं पर अंतर और भी अधिक प्रभावशाली होगा।

अब देखते हैं कैसे काम करना है सेट-ऑब्जेक्ट्स-बैच. इस एपीआई कॉल का उपयोग करके, हम किसी भी पैरामीटर को बड़े पैमाने पर बदल सकते हैं। आइए पिछले उदाहरण के पतों के पहले आधे भाग (.124 होस्ट तक, और रेंज भी) को सिएना रंग पर सेट करें, और पतों के दूसरे भाग को खाकी रंग निर्दिष्ट करें।

पिछले उदाहरण में बनाई गई वस्तुओं का रंग बदलना

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

आप इसका उपयोग करके एक एपीआई कॉल में एकाधिक ऑब्जेक्ट हटा सकते हैं डिलीट-ऑब्जेक्ट्स-बैच. अब आइए एक कोड उदाहरण देखें जो पहले बनाए गए सभी होस्ट को हटा देता है ऐड-ऑब्जेक्ट्स-बैच.

डिलीट-ऑब्जेक्ट्स-बैच का उपयोग करके ऑब्जेक्ट्स को हटाना

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)

चेक प्वाइंट सॉफ्टवेयर के नए रिलीज में दिखाई देने वाले सभी फ़ंक्शन तुरंत एपीआई कॉल प्राप्त करते हैं। इस प्रकार, R80.40 में रिवर्ट टू रिवीजन और स्मार्ट टास्क जैसी "सुविधाएँ" दिखाई दीं, और संबंधित एपीआई कॉल तुरंत उनके लिए तैयार की गईं। इसके अलावा, लीगेसी कंसोल से यूनिफाइड पॉलिसी मोड में जाने पर सभी कार्यक्षमताएं एपीआई समर्थन भी प्राप्त कर लेती हैं। उदाहरण के लिए, सॉफ्टवेयर संस्करण R80.40 में लंबे समय से प्रतीक्षित अपडेट HTTPS निरीक्षण नीति को लीगेसी मोड से यूनिफाइड पॉलिसी मोड में स्थानांतरित करना था, और इस कार्यक्षमता को तुरंत एपीआई कॉल प्राप्त हुई। यहां कोड का एक उदाहरण दिया गया है जो 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 इसमें नियंत्रण सर्वर से सीधे पायथन स्क्रिप्ट चलाने के तरीके के बारे में जानकारी शामिल है। यह तब सुविधाजनक हो सकता है जब आप किसी अन्य मशीन से एपीआई सर्वर से कनेक्ट करने में असमर्थ हों। मैंने छह मिनट का एक वीडियो रिकॉर्ड किया जिसमें मैं मॉड्यूल को स्थापित करते हुए देख रहा हूं cpapi और नियंत्रण सर्वर पर पायथन स्क्रिप्ट चलाने की विशेषताएं। उदाहरण के तौर पर, एक स्क्रिप्ट चलाई जाती है जो नेटवर्क ऑडिटिंग जैसे कार्य के लिए नए गेटवे के कॉन्फ़िगरेशन को स्वचालित करती है सुरक्षा जांच. जिन सुविधाओं से मुझे निपटना पड़ा उनमें से: फ़ंक्शन अभी तक पायथन 2.7 में दिखाई नहीं दिया है निवेश, इसलिए उपयोगकर्ता द्वारा दर्ज की गई जानकारी को संसाधित करने के लिए, एक फ़ंक्शन का उपयोग किया जाता है कच्चे इनपुट. अन्यथा, कोड अन्य मशीनों से लॉन्च करने के समान ही है, केवल फ़ंक्शन का उपयोग करना अधिक सुविधाजनक है लॉगिन_अस_रूट, ताकि प्रबंधन सर्वर का अपना स्वयं का उपयोगकर्ता नाम, पासवर्ड और आईपी पता दोबारा निर्दिष्ट न करें।

सुरक्षा जांच के त्वरित सेटअप के लिए स्क्रिप्ट

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

पासवर्ड डिक्शनरी एडिशनल_पास.कॉन्फ़ के साथ एक उदाहरण फ़ाइल
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

निष्कर्ष

यह आलेख केवल कार्य की बुनियादी संभावनाओं की जांच करता है पायथन एसडीके और मॉड्यूल cpapi(जैसा कि आपने अनुमान लगाया होगा, ये वास्तव में समानार्थक शब्द हैं), और इस मॉड्यूल में कोड का अध्ययन करके आप इसके साथ काम करने के और भी अधिक अवसर खोजेंगे। यह संभव है कि आप इसे अपनी कक्षाओं, कार्यों, विधियों और चर के साथ पूरक करना चाहेंगे। आप हमेशा अपना काम साझा कर सकते हैं और अनुभाग में चेक प्वाइंट के लिए अन्य स्क्रिप्ट देख सकते हैं कोडहब समुदाय में चेकमेट्स, जो उत्पाद डेवलपर्स और उपयोगकर्ताओं दोनों को एक साथ लाता है।

हैप्पी कोडिंग और अंत तक पढ़ने के लिए धन्यवाद!

स्रोत: www.habr.com