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 - સાથે કામ કરો CloudGuard કનેક્ટ (SD-WAN સુરક્ષા ઉકેલ)
• Dome9 API - સાથે કામ કરો ડોમ9

Python SDK હાલમાં ફક્ત મેનેજમેન્ટ API અને સાથે ક્રિયાપ્રતિક્રિયાને સમર્થન આપે છે Gaia API. અમે આ મોડ્યુલમાં સૌથી મહત્વપૂર્ણ વર્ગો, પદ્ધતિઓ અને ચલોને જોઈશું.

મોડ્યુલ સ્થાપિત કરી રહ્યા છીએ

મોડ્યુલ cpapi થી ઝડપથી અને સરળતાથી ઇન્સ્ટોલ કરે છે ગીથબ પર સત્તાવાર ચેક પોઇન્ટ રીપોઝીટરી ની મદદ સાથે ફળનું નાનું બીજ. વિગતવાર સ્થાપન સૂચનાઓ ઉપલબ્ધ છે README.md. આ મોડ્યુલ Python આવૃત્તિઓ 2.7 અને 3.7 સાથે કામ કરવા માટે અનુકૂળ છે. આ લેખમાં, Python 3.7 નો ઉપયોગ કરીને ઉદાહરણો આપવામાં આવશે. જો કે, પાયથોન SDK ને ચેક પોઈન્ટ મેનેજમેન્ટ સર્વર (સ્માર્ટ મેનેજમેન્ટ) થી સીધું જ ચલાવી શકાય છે, પરંતુ તે માત્ર પાયથોન 2.7 ને સપોર્ટ કરે છે, તેથી છેલ્લો વિભાગ સંસ્કરણ 2.7 માટે કોડ પ્રદાન કરશે. મોડ્યુલ ઇન્સ્ટોલ કર્યા પછી તરત જ, હું ડિરેક્ટરીઓમાં ઉદાહરણો જોવાની ભલામણ કરું છું ઉદાહરણો_python2 и ઉદાહરણો_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 સર્વર સાથે કનેક્ટ કરતી વખતે થઈ શકે છે:

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 સર્વર પર જ સ્ક્રિપ્ટો ચલાવવામાં આવે તો જ આની ભલામણ કરી શકાય છે - અસુરક્ષિત_ઓટો_સ્વીકારો (APIClientArgs વિશે વધુ પહેલાં “ડિફાઈનિંગ કનેક્શન પેરામીટર્સ”માં જુઓ).

client_args = APIClientArgs(unsafe_auto_accept=True)

API સર્વર પર લૉગિન કરો

У APIClient API સર્વરમાં લૉગ ઇન કરવા માટે 3 જેટલી પદ્ધતિઓ છે અને તેમાંથી દરેક તેનો અર્થ સમજે છે સીડી(સત્ર-આઈડી), જે હેડરમાં દરેક અનુગામી API કૉલમાં આપમેળે વપરાય છે (આ પરિમાણના હેડરમાં નામ છે X-chkp-sid), તેથી આ પરિમાણ પર આગળ પ્રક્રિયા કરવાની જરૂર નથી.

પ્રવેશ પદ્ધતિ

લૉગિન અને પાસવર્ડનો ઉપયોગ કરવાનો વિકલ્પ (ઉદાહરણમાં, વપરાશકર્તાનામ એડમિન અને પાસવર્ડ 1q2w3e સ્થિતિની દલીલો તરીકે પસાર થાય છે):

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

લૉગિન પદ્ધતિમાં વધારાના વૈકલ્પિક પરિમાણો પણ ઉપલબ્ધ છે; અહીં તેમના નામ અને ડિફૉલ્ટ મૂલ્યો છે:

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

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 વિનંતીમાં ઑફસેટ પેરામીટર બદલીને, માહિતીને ઘણી વખત ખેંચી ન લેવા માટે, ત્યાં 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.

સેટ_સફળતા_સ્થિતિ

આ કિસ્સામાં, સફળતાની સ્થિતિનું મૂલ્ય બદલવાની જરૂર પડી શકે છે. તકનીકી રીતે, તમે ત્યાં કંઈપણ મૂકી શકો છો, એક નિયમિત સ્ટ્રિંગ પણ. પરંતુ એક વાસ્તવિક ઉદાહરણ ચોક્કસ સાથેની શરતો હેઠળ આ પરિમાણને 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

પ્રતિભાવ()

પ્રતિસાદ પદ્ધતિ તમને પ્રતિભાવ કોડ (સ્ટેટસ_કોડ) અને પ્રતિભાવ બોડી (બોડી) સાથે શબ્દકોશ જોવાની મંજૂરી આપે છે.

In [94]: api_versions.response()                                                
Out[94]: 
{'status_code': 200,
 'data': {'current-version': '1.6',
  'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}

માહિતી

તમને બિનજરૂરી માહિતી વિના માત્ર પ્રતિભાવના મુખ્ય ભાગ (શરીર) જોવાની મંજૂરી આપે છે.

In [93]: api_versions.data                                                      
Out[93]: 
{'current-version': '1.6',
 'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}

ક્ષતી સંદેશ

આ માહિતી ત્યારે જ ઉપલબ્ધ છે જ્યારે API વિનંતી (પ્રતિસાદ કોડ નથી 200). ઉદાહરણ આઉટપુટ

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

ઉપયોગી ઉદાહરણો

નીચેના ઉદાહરણો છે જે API કૉલ્સનો ઉપયોગ કરે છે જે મેનેજમેન્ટ API 1.6 માં ઉમેરવામાં આવ્યા હતા.

પ્રથમ, ચાલો જોઈએ કે કોલ્સ કેવી રીતે કાર્ય કરે છે એડ-હોસ્ટ и ઉમેરો-સરનામું-શ્રેણી. ચાલો કહીએ કે આપણે સબનેટ 192.168.0.0/24 ના બધા IP એડ્રેસ બનાવવાની જરૂર છે, જેમાંથી છેલ્લું ઓક્ટેટ 5 છે, હોસ્ટ ટાઈપના ઓબ્જેક્ટ તરીકે, અને અન્ય તમામ આઈપી એડ્રેસને એડ્રેસ રેન્જ પ્રકારના ઓબ્જેક્ટ તરીકે લખો. આ કિસ્સામાં, સબનેટ સરનામું અને બ્રોડકાસ્ટ સરનામું બાકાત રાખો.

તેથી, નીચે એક સ્ક્રિપ્ટ છે જે આ સમસ્યાનું નિરાકરણ કરે છે અને હોસ્ટ પ્રકારના 50 ઓબ્જેક્ટ અને એડ્રેસ રેન્જ પ્રકારના 51 ઓબ્જેક્ટ બનાવે છે. સમસ્યાને ઉકેલવા માટે, 101 API કૉલ્સ આવશ્યક છે (અંતિમ પબ્લિશ કૉલની ગણતરી કરતા નથી). ઉપરાંત, ટાઇમઇટ મોડ્યુલનો ઉપયોગ કરીને, અમે ફેરફારો પ્રકાશિત થાય ત્યાં સુધી સ્ક્રિપ્ટને એક્ઝિક્યુટ કરવામાં લાગતા સમયની ગણતરી કરીએ છીએ.

એડ-હોસ્ટ અને એડ-એડ્રેસ-રેન્જનો ઉપયોગ કરીને સ્ક્રિપ્ટ

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 કૉલનો ઉપયોગ કરીને, અમે કોઈપણ પરિમાણને બલ્ક બદલી શકીએ છીએ. ચાલો અગાઉના ઉદાહરણમાંથી (.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")

તમે એક 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 અને કંટ્રોલ સર્વર પર Python સ્ક્રિપ્ટ ચલાવવાની સુવિધાઓ. ઉદાહરણ તરીકે, એક સ્ક્રિપ્ટ ચલાવવામાં આવે છે જે નેટવર્ક ઓડિટીંગ જેવા કાર્ય માટે નવા ગેટવેની ગોઠવણીને સ્વચાલિત કરે છે. સુરક્ષા તપાસ. મારે જે સુવિધાઓનો સામનો કરવો પડ્યો હતો તે પૈકી: ફંક્શન હજી સુધી પાયથોન 2.7 માં દેખાયું નથી ઇનપુટ, તેથી વપરાશકર્તા જે માહિતી દાખલ કરે છે તેની પ્રક્રિયા કરવા માટે, ફંક્શનનો ઉપયોગ કરવામાં આવે છે કાચો_ઇનપુટ. નહિંતર, કોડ અન્ય મશીનોથી લોંચ કરવા માટે સમાન છે, ફક્ત તે કાર્યનો ઉપયોગ કરવા માટે વધુ અનુકૂળ છે login_as_root, જેથી તમારું પોતાનું વપરાશકર્તાનામ, પાસવર્ડ અને મેનેજમેન્ટ સર્વરનું IP સરનામું ફરીથી સ્પષ્ટ ન કરો.

સુરક્ષા ચેકઅપના ઝડપી સેટઅપ માટે સ્ક્રિપ્ટ

from __future__ import print_function
import getpass
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from cpapi import APIClient, APIClientArgs

def main():
    with APIClient() as client:
       # if client.check_fingerprint() is False:
       #     print("Could not get the server's fingerprint - Check connectivity with the server.")
       #     exit(1)
        login_res = client.login_as_root()

        if login_res.success is False:
            print("Login failed:n{}".format(login_res.error_message))
            exit(1)

        gw_name = raw_input("Enter the gateway name:")
        gw_ip = raw_input("Enter the gateway IP address:")
        if sys.stdin.isatty():
            sic = getpass.getpass("Enter one-time password for the gateway(SIC): ")
        else:
            print("Attention! Your password will be shown on the screen!")
            sic = raw_input("Enter one-time password for the gateway(SIC): ")
        version = raw_input("Enter the gateway version(like RXX.YY):")
        add_gw = client.api_call("add-simple-gateway", {'name' : gw_name, 'ipv4-address' : gw_ip, 'one-time-password' : sic, 'version': version.capitalize(), 'application-control' : 'true', 'url-filtering' : 'true', 'ips' : 'true', 'anti-bot' : 'true', 'anti-virus' : 'true', 'threat-emulation' : 'true'})
        if add_gw.success and add_gw.data['sic-state'] != "communicating":
            print("Secure connection with the gateway hasn't established!")
            exit(1)
        elif add_gw.success:
            print("The gateway was added successfully.")
            gw_uid = add_gw.data['uid']
            gw_name = add_gw.data['name']
        else:
            print("Failed to add the gateway - {}".format(add_gw.error_message))
            exit(1)

        change_policy = client.api_call("set-access-layer", {"name" : "Network", "applications-and-url-filtering": "true", "content-awareness": "true"})
        if change_policy.success:
            print("The policy has been changed successfully")
        else:
            print("Failed to change the policy- {}".format(change_policy.error_message))
        change_rule = client.api_call("set-access-rule", {"name" : "Cleanup rule", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
        if change_rule.success:
            print("The cleanup rule has been changed successfully")
        else:
            print("Failed to change the cleanup rule- {}".format(change_rule.error_message))

        # publish the result
        publish_res = client.api_call("publish", {})
        if publish_res.success:
            print("The changes were published successfully.")
        else:
                print("Failed to publish the changes - {}".format(install_tp_policy.error_message))

        install_access_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'true',  "threat-prevention" : 'false', "targets" : gw_uid})
        if install_access_policy.success:
            print("The access policy has been installed")
        else:
                print("Failed to install access policy - {}".format(install_tp_policy.error_message))

        install_tp_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'false',  "threat-prevention" : 'true', "targets" : gw_uid})
        if install_tp_policy.success:
            print("The threat prevention policy has been installed")
        else:
            print("Failed to install threat prevention policy - {}".format(install_tp_policy.error_message))
        
        # add passwords and passphrases to dictionary
        with open('additional_pass.conf') as f:
            line_num = 0
            for line in f:
                line_num += 1
                add_password_dictionary = client.api_call("run-script", {"script-name" : "Add passwords and passphrases", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
                if add_password_dictionary.success:
                    print("The password dictionary line {} was added successfully".format(line_num))
                else:
                    print("Failed to add the dictionary - {}".format(add_password_dictionary.error_message))

main()

પાસવર્ડ ડિક્શનરી વધારાની_pass.conf સાથે ઉદાહરણ ફાઇલ
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

નિષ્કર્ષ

આ લેખ કામની માત્ર મૂળભૂત શક્યતાઓની તપાસ કરે છે પાયથોન SDK અને મોડ્યુલ cpapi(જેમ તમે અનુમાન લગાવ્યું હશે, આ વાસ્તવમાં સમાનાર્થી છે), અને આ મોડ્યુલમાં કોડનો અભ્યાસ કરીને તમે તેની સાથે કામ કરવાની વધુ તકો શોધી શકશો. શક્ય છે કે તમે તેને તમારા પોતાના વર્ગો, કાર્યો, પદ્ધતિઓ અને ચલો સાથે પૂરક બનાવવા માંગો છો. તમે હંમેશા તમારું કાર્ય શેર કરી શકો છો અને વિભાગમાં ચેક પોઈન્ટ માટે અન્ય સ્ક્રિપ્ટો જોઈ શકો છો કોડહબ સમુદાયમાં ચેકમેટ્સ, જે ઉત્પાદન વિકાસકર્તાઓ અને વપરાશકર્તાઓ બંનેને એકસાથે લાવે છે.

હેપી કોડિંગ અને અંત સુધી વાંચવા બદલ આભાર!

સોર્સ: www.habr.com