פישוט ה-Check Point API עם Python SDK

העוצמה המלאה של אינטראקציה עם ממשקי API מתגלה בשימוש יחד עם קוד תוכנית, כאשר ניתן ליצור באופן דינמי בקשות API וכלים לניתוח תגובות API. עם זאת, זה עדיין לא מורגש ערכת פיתוח תוכנה של Python (להלן מכונה Python SDK) עבור API לניהול נקודות צ'ק, אך לשווא. זה מפשט משמעותית את החיים של מפתחים וחובבי אוטומציה. פייתון צברה פופולריות עצומה לאחרונה והחלטתי למלא את החסר ולסקור את המאפיינים העיקריים. ערכת פיתוח של צ'ק פוינט API Python. מאמר זה משמש כתוספת מצוינת למאמר אחר על Habré API של Check Point R80.10. ניהול באמצעות CLI, סקריפטים ועוד. נבחן כיצד לכתוב סקריפטים באמצעות Python SDK ונסתכל מקרוב על הפונקציונליות החדשה של Management API בגרסה 1.6 (נתמכת החל מ-R80.40). כדי להבין את המאמר, תזדקק לידע בסיסי בעבודה עם ממשקי API ו-Python.

צ'ק פוינט מפתחת באופן פעיל את ה-API, וכרגע שוחררו הדברים הבאים:

• ממשק API לניהול נקודות (גרסה נוכחית 1.6) - עבודה עם שרת הבקרה באמצעות API (והיכולת להפעיל סקריפטים בשערים הנשלטים על ידי שרת הבקרה)
• Check Point GAIA API (גרסה נוכחית 1.4) - עבודה עם שערי אבטחה
• API למניעת איומים 1.0 - עבודה עם ארגז חול בענן צ'ק פוינט
• API של מודעות לזהות - עבודה עם Identity Awareness Blade על שערים
• API של פורטל ניהול אבטחה - עבודה עם פורטל ניהול שער SMB (עוד על שערי SMB)
• IoT API - אינטראקציה עם בקרי IoT
• CloudGuard Connect API - לעבוד עם CloudGuard Connect (פתרון אבטחה SD-WAN)
• Dome9 API - לעבוד עם Dome9

ה-SDK של Python תומך כרגע רק באינטראקציה עם ה-API לניהול ו Gaia API. נסתכל על המחלקות, השיטות והמשתנים החשובים ביותר במודול זה.

התקנת המודול

Модуль cpapi מותקן במהירות ובקלות מ מאגר צ'ק פוינט הרשמי ב-github באמצעות פְּעִים. הוראות התקנה מפורטות זמינות ב README.md. מודול זה מותאם לעבודה עם גירסאות Python 2.7 ו-3.7. במאמר זה יינתנו דוגמאות באמצעות Python 3.7. עם זאת, ניתן להפעיל את Python SDK ישירות משרת ניהול צ'ק פוינט (Smart Management), אך הם תומכים רק ב-Python 2.7, כך שהסעיף האחרון יספק קוד לגרסה 2.7. מיד לאחר התקנת המודול, אני ממליץ להסתכל על הדוגמאות בספריות examples_python2 и examples_python3.

תחילת העבודה

על מנת שנוכל לעבוד עם הרכיבים של מודול ה-cpapi, עלינו לייבא מהמודול cpapi לפחות שני שיעורי חובה:

APIClient и APIClientArgs

from cpapi import APIClient, APIClientArgs

בכיתה APIClientArgs אחראי על פרמטרי חיבור לשרת ה-API, ולמחלקה APIClient אחראי על האינטראקציה עם ה-API.

קביעת פרמטרי חיבור

כדי להגדיר פרמטרים שונים לחיבור ל-API, עליך ליצור מופע של המחלקה APIClientArgs. באופן עקרוני, הפרמטרים שלו מוגדרים מראש וכאשר מפעילים את הסקריפט בשרת הבקרה, אין צורך לציין אותם.

client_args = APIClientArgs()

אבל כאשר פועל על מארח צד שלישי, עליך לציין לפחות את כתובת ה-IP או שם המארח של שרת ה-API (המכונה גם שרת הניהול). בדוגמה למטה, אנו מגדירים את פרמטר חיבור השרת ומקצים לו את כתובת ה-IP של שרת הניהול כמחרוזת.

client_args = APIClientArgs(server='192.168.47.241')

בואו נסתכל על כל הפרמטרים וערכי ברירת המחדל שלהם שניתן להשתמש בהם בעת חיבור לשרת ה-API:

ארגומנטים של שיטת __init__ של המחלקה APIClientArgs

class APIClientArgs:
    """
    This class provides arguments for APIClient configuration.
    All the arguments are configured with their default values.
    """

    # port is set to None by default, but it gets replaced with 443 if not specified
    # context possible values - web_api (default) or gaia_api
    def __init__(self, port=None, fingerprint=None, sid=None, server="127.0.0.1", http_debug_level=0,
                 api_calls=None, debug_file="", proxy_host=None, proxy_port=8080,
                 api_version=None, unsafe=False, unsafe_auto_accept=False, context="web_api"):
        self.port = port
        # management server fingerprint
        self.fingerprint = fingerprint
        # session-id.
        self.sid = sid
        # management server name or IP-address
        self.server = server
        # debug level
        self.http_debug_level = http_debug_level
        # an array with all the api calls (for debug purposes)
        self.api_calls = api_calls if api_calls else []
        # name of debug file. If left empty, debug data will not be saved to disk.
        self.debug_file = debug_file
        # HTTP proxy server address (without "http://")
        self.proxy_host = proxy_host
        # HTTP proxy port
        self.proxy_port = proxy_port
        # Management server's API version
        self.api_version = api_version
        # Indicates that the client should not check the server's certificate
        self.unsafe = unsafe
        # Indicates that the client should automatically accept and save the server's certificate
        self.unsafe_auto_accept = unsafe_auto_accept
        # The context of using the client - defaults to web_api
        self.context = context

אני מאמין שהארגומנטים שניתן להשתמש בהם במופעים של מחלקת APIClientArgs הם אינטואיטיביים למנהלי צ'ק פוינט ואינם דורשים הערות נוספות.

התחברות דרך APIClient ומנהל הקשר

בכיתה APIClient הדרך הנוחה ביותר להשתמש בו היא דרך מנהל ההקשרים. כל מה שצריך להעביר למופע של מחלקת APIClient הוא פרמטרי החיבור שהוגדרו בשלב הקודם.

with APIClient(client_args) as client:

מנהל ההקשר לא יבצע קריאת התחברות אוטומטית לשרת ה-API, אך הוא יבצע קריאת התנתק בעת יציאה ממנו. אם מסיבה כלשהי לא נדרשת התנתקות לאחר סיום העבודה עם קריאות API, עליך להתחיל לעבוד מבלי להשתמש במנהל ההקשרים:

client = APIClient(clieng_args)

בדיקת חיבור

הדרך הקלה ביותר לבדוק אם החיבור עומד בפרמטרים שצוינו היא באמצעות השיטה check_fingerprint. אם האימות של סכום ה-hash sha1 עבור טביעת האצבע של אישור ה-API של השרת נכשל (השיטה הוחזרה לא נכון), אז זה נגרם בדרך כלל מבעיות חיבור ואנו יכולים לעצור את הפעלת התוכנית (או לתת למשתמש את ההזדמנות לתקן את נתוני החיבור):

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

שימו לב שבעתיד השיעור APIClient יבדוק כל קריאת API (שיטות api_call и api_query, נדבר עליהם עוד קצת) sha1 אישור טביעת אצבע בשרת ה-API. אבל אם, בעת בדיקת טביעת האצבע sha1 של אישור שרת ה-API, זוהתה שגיאה (האישור אינו ידוע או שונה), השיטה check_fingerprint יספק את ההזדמנות להוסיף/לשנות מידע אודותיו במחשב המקומי באופן אוטומטי. ניתן לבטל את הסימון הזה לחלוטין (אך ניתן להמליץ ​​על כך רק אם סקריפטים מופעלים על שרת ה-API עצמו, בעת חיבור ל-127.0.0.1), באמצעות הארגומנט APIClientArgs - unsafe_auto_accept (ראה עוד על APIClientArgs קודם לכן ב"הגדרת פרמטרי חיבור").

client_args = APIClientArgs(unsafe_auto_accept=True)

כניסה לשרת API

У APIClient יש עד 3 שיטות לכניסה לשרת ה-API, וכל אחת מהן מבינה את המשמעות סיד(Session-id), המשמש אוטומטית בכל קריאת API עוקב בכותרת (השם בכותרת של פרמטר זה הוא X-chkp-sid), כך שאין צורך להמשיך לעבד את הפרמטר הזה.

שיטת הכניסה

אפשרות באמצעות כניסה וסיסמה (בדוגמה, שם המשתמש admin והסיסמה 1q2w3e מועברות כארגומנטים מיקוםיים):

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

פרמטרים אופציונליים נוספים זמינים גם בשיטת הכניסה; להלן שמותיהם וערכי ברירת המחדל שלהם:

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

שיטה login_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 והמטען בגוף הבקשה במידת הצורך. אם המטען ריק, לא ניתן לשדר אותו כלל:

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 אובייקטים בתגובה). וכדי לא למשוך את המידע מספר פעמים, שינוי פרמטר ה-offset בבקשת ה-API, יש שיטה api_query שעושה את זה בצורה אוטומטית. דוגמאות לשיחות שבהן נדרשת שיטה זו: מופעי מופעים, מארחי מופעים, רשתות מופעים, תווים כלליים למופעים, קבוצות מופעים, טווחי כתובות מופעים, שערי מופעים פשוטים, קבצי תצוגה פשוטים, הצגת גישה לתפקידים, לקוחות מהימנים, חבילות הצגה. למעשה, אנו רואים מילים ברבים בשם קריאות ה-API הללו, כך שיהיה קל יותר לטפל בהן באמצעות api_query

show_hosts = client.api_query('show-hosts') 

פלט עבור בקשה זו מתחת לגזרה:

In [21]: show_hosts                                                             
Out[21]: 
APIResponse({
    "data": [
        {
            "domain": {
                "domain-type": "domain",
                "name": "SMC User",
                "uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
            },
            "ipv4-address": "192.168.47.1",
            "name": "h_192.168.47.1",
            "type": "host",
            "uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
        },
        {
            "domain": {
                "domain-type": "domain",
                "name": "SMC User",
                "uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
            },
            "ipv4-address": "8.8.8.8",
            "name": "h_8.8.8.8",
            "type": "host",
            "uid": "c210af07-1939-49d3-a351-953a9c471d9e"
        }
    ],
    "res_obj": {
        "data": {
            "from": 1,
            "objects": [
                {
                    "domain": {
                        "domain-type": "domain",
                        "name": "SMC User",
                        "uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
                    },
                    "ipv4-address": "192.168.47.1",
                    "name": "h_192.168.47.1",
                    "type": "host",
                    "uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
                },
                {
                    "domain": {
                        "domain-type": "domain",
                        "name": "SMC User",
                        "uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
                    },
                    "ipv4-address": "8.8.8.8",
                    "name": "h_8.8.8.8",
                    "type": "host",
                    "uid": "c210af07-1939-49d3-a351-953a9c471d9e"
                }
            ],
            "to": 2,
            "total": 2
        },
        "status_code": 200
    },
    "status_code": 200,
    "success": true
})

עיבוד תוצאות קריאות API

לאחר מכן תוכל להשתמש במשתנים ובשיטות של המחלקה APIResponse(גם בתוך מנהל ההקשר וגם מחוצה לו). בכיתה APIResponse 4 שיטות ו-5 משתנים מוגדרים מראש; נתעכב על החשובים ביותר בפירוט רב יותר.

הצלחה

מלכתחילה, יהיה זה רעיון טוב לוודא שקריאת ה-API הצליחה והחזירה תוצאה. יש שיטה לזה הצלחה:

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

מחזירה True אם קריאת ה-API הצליחה (קוד תגובה - 200) ו-false אם לא הצליחה (כל קוד תגובה אחר). זה נוח לשימוש מיד לאחר קריאת API כדי להציג מידע שונה בהתאם לקוד התגובה.

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

קוד סטטוס

מחזירה את קוד התגובה לאחר ביצוע קריאת API.

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

קודי תגובה אפשריים: 200,400,401,403,404,409,500,501.

set_success_status

במקרה זה, ייתכן שיהיה צורך לשנות את הערך של סטטוס ההצלחה. מבחינה טכנית, אתה יכול לשים שם כל דבר, אפילו מחרוזת רגילה. אבל דוגמה אמיתית תהיה איפוס הפרמטר הזה ל-False בתנאים נלווים מסוימים. להלן, שימו לב לדוגמא כאשר ישנן משימות שפועלות בשרת הניהול, אך אנו נשקול את הבקשה הזו ככשלה (אנחנו נגדיר את משתנה ההצלחה ל- לא נכון, למרות שהקריאה ל-API הצליחה והחזירה קוד 200).

for task in task_result.data["tasks"]:
    if task["status"] == "failed" or task["status"] == "partially succeeded":
        task_result.set_success_status(False)
        break

תְגוּבָה()

שיטת התגובה מאפשרת להציג את המילון עם קוד התגובה (status_code) וגוף התגובה (body).

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 שנוספו ב-Management API 1.6.

Для начала рассмотрим работу вызовов add-host и add-address-range. נניח שעלינו ליצור את כל כתובות ה-IP של רשת המשנה 192.168.0.0/24, שהאוקטטה האחרונה שבהן היא 5, כאובייקטים מסוג המארח, ולכתוב את כל שאר כתובות ה-IP כאובייקטים מסוג טווח הכתובות. במקרה זה, אל תכלול את כתובת רשת המשנה ואת כתובת השידור.

אז, להלן סקריפט שפותר בעיה זו ויוצר 50 אובייקטים מסוג המארח ו-51 אובייקטים מסוג טווח הכתובות. כדי לפתור את הבעיה, נדרשות 101 קריאות API (לא סופרים את קריאת הפרסום הסופית). כמו כן, באמצעות מודול timeit, אנו מחשבים את הזמן שלוקח לביצוע הסקריפט עד לפרסום השינויים.

סקריפט באמצעות add-host ו-add-address-range

import timeit
from cpapi import APIClient, APIClientArgs

start = timeit.default_timer()

first_ip = 1
last_ip = 4

client_args = APIClientArgs(server="192.168.47.240")

with APIClient(client_args) as client: 
     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
     for ip in range(5,255,5):
         add_host = client.api_call("add-host", {"name" : f"h_192.168.0.{ip}", "ip-address": f'192.168.0.{ip}'})
     while last_ip < 255:
         add_range = client.api_call("add-address-range", {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"})
         first_ip+=5
         last_ip+=5
     stop = timeit.default_timer() 
     publish = client.api_call("publish")
     
print(f'Time to execute batch request: {stop - start} seconds')

בסביבת המעבדה שלי, הסקריפט הזה לוקח בין 30 ל-50 שניות לביצוע, תלוי בעומס על שרת הניהול.

כעת נראה כיצד ניתן לפתור את אותה בעיה באמצעות קריאת API add-objects-batch, עבורו נוספה תמיכה בגירסת API 1.6. קריאה זו מאפשרת לך ליצור אובייקטים רבים בו-זמנית בבקשת API אחת. יתרה מכך, אלה יכולים להיות אובייקטים מסוגים שונים (לדוגמה, מארחים, רשתות משנה וטווחי כתובות). כך, ניתן לפתור את המשימה שלנו במסגרת קריאת API אחת.

סקריפט באמצעות add-objects-batch

import timeit
from cpapi import APIClient, APIClientArgs

start = timeit.default_timer()

client_args = APIClientArgs(server="192.168.47.240")

objects_list_ip = []
objects_list_range = []

for ip in range(5,255,5):
    data = {"name": f'h_192.168.0.{ip}', "ip-address": f'192.168.0.{ip}'}
    objects_list_ip.append(data)
    
first_ip = 1
last_ip = 4


while last_ip < 255:
    data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"}
    objects_list_range.append(data)
    first_ip+=5
    last_ip+=5

data_for_batch = {
  "objects" : [ {
    "type" : "host",
    "list" : objects_list_ip
}, {
    "type" : "address-range",
    "list" : objects_list_range
  }]
}


with APIClient(client_args) as client: 
     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
     add_objects_batch = client.api_call("add-objects-batch", data_for_batch)
     stop = timeit.default_timer() 
     publish = client.api_call("publish")
     
print(f'Time to execute batch request: {stop - start} seconds')

והפעלת הסקריפט הזה בסביבת המעבדה שלי נמשכת בין 3 ל-7 שניות, תלוי בעומס על שרת הניהול. כלומר, בממוצע, על 101 אובייקטי API, קריאה מסוג אצווה פועלת פי 10 מהר יותר. על מספר גדול יותר של חפצים ההבדל יהיה אפילו יותר מרשים.

עכשיו בואו נראה איך לעבוד עם set-objects-batch. באמצעות קריאת API זו, אנו יכולים לשנות בכמות גדולה כל פרמטר. בואו נגדיר את החצי הראשון של הכתובות מהדוגמה הקודמת (עד .124 מארחים, וגם טווחים) לצבע sienna, ונקצה את הצבע חאקי לחצי השני של הכתובות.

שינוי צבע האובייקטים שנוצרו בדוגמה הקודמת

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

objects_list_ip_first = []
objects_list_range_first = []
objects_list_ip_second = []
objects_list_range_second = []

for ip in range(5,125,5):
    data = {"name": f'h_192.168.0.{ip}', "color": "sienna"}
    objects_list_ip_first.append(data)
    
for ip in range(125,255,5):
    data = {"name": f'h_192.168.0.{ip}', "color": "khaki"}
    objects_list_ip_second.append(data)
    
first_ip = 1
last_ip = 4
while last_ip < 125:
    data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "sienna"}
    objects_list_range_first.append(data)
    first_ip+=5
    last_ip+=5
    
while last_ip < 255:
    data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "khaki"}
    objects_list_range_second.append(data)
    first_ip+=5
    last_ip+=5

data_for_batch_first  = {
  "objects" : [ {
    "type" : "host",
    "list" : objects_list_ip_first
}, {
    "type" : "address-range",
    "list" : objects_list_range_first
  }]
}

data_for_batch_second  = {
  "objects" : [ {
    "type" : "host",
    "list" : objects_list_ip_second
}, {
    "type" : "address-range",
    "list" : objects_list_range_second
  }]
}

with APIClient(client_args) as client: 
     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') 
     set_objects_batch_first = client.api_call("set-objects-batch", data_for_batch_first)
     set_objects_batch_second = client.api_call("set-objects-batch", data_for_batch_second)
     publish = client.api_call("publish")

אתה יכול למחוק אובייקטים מרובים בקריאת API אחת באמצעות מחק-אובייקטים-אצווה. כעת נסתכל על דוגמה לקוד שמוחקת את כל המארחים שנוצרו בעבר באמצעות add-objects-batch.

מחיקת אובייקטים באמצעות delete-objects-batch

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

objects_list_ip = []
objects_list_range = []

for ip in range(5,255,5):
    data = {"name": f'h_192.168.0.{ip}'}
    objects_list_ip.append(data)

first_ip = 1
last_ip = 4
while last_ip < 255:
    data = {"name": f"r_192.168.0.{first_ip}-{last_ip}"}
    objects_list_range.append(data)
    first_ip+=5
    last_ip+=5

data_for_batch = {
  "objects" : [ {
    "type" : "host",
    "list" : objects_list_ip
}, {
    "type" : "address-range",
    "list" : objects_list_range
  }]
}

with APIClient(client_args) as client: 
     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
     delete_objects_batch = client.api_call("delete-objects-batch", data_for_batch)
     publish = client.api_call("publish")

print(delete_objects_batch.data)

כל הפונקציות המופיעות במהדורות חדשות של תוכנת צ'ק פוינט רוכשות מיד קריאות API. לפיכך, ב-R80.40 הופיעו "תכונות" כגון Revert to revision ו-Smart Task, וקריאות API מתאימות הוכנו להן מיד. יתר על כן, כל הפונקציונליות בעת מעבר מקונסולות מדור קודם למצב Unified Policy מקבלת גם תמיכת API. לדוגמה, העדכון המיוחל בגרסת התוכנה R80.40 היה המעבר של מדיניות ה-HTTPS Inspection ממצב Legacy למצב Unified Policy, ופונקציונליות זו קיבלה מיד קריאות API. הנה דוגמה לקוד שמוסיף כלל למיקום העליון של מדיניות ה-HTTPS Inspection המוציאה 3 קטגוריות מהבדיקה (בריאות, פיננסים, שירותי ממשלתיים), האסורות לבדיקה בהתאם לחוק במספר מדינות.

הוסף כלל למדיניות בדיקת HTTPS

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

data = {
  "layer" : "Default Layer",
  "position" : "top",
  "name" : "Legal Requirements",
  "action": "bypass",
  "site-category": ["Health", "Government / Military", "Financial Services"]
}

with APIClient(client_args) as client: 
     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
     add_https_rule = client.api_call("add-https-rule", data)
     publish = client.api_call("publish")

הפעלת סקריפטים של Python בשרת הניהול של צ'ק פוינט

הכל אותו דבר README.md מכיל מידע כיצד להפעיל סקריפטים של Python ישירות משרת הבקרה. זה יכול להיות נוח כאשר אינך יכול להתחבר לשרת ה-API ממחשב אחר. הקלטתי סרטון של שש דקות בו אני מסתכל על התקנת המודול cpapi ותכונות של הפעלת סקריפטים של Python בשרת הבקרה. כדוגמה, מופעל סקריפט שממכן את התצורה של שער חדש עבור משימה כמו ביקורת רשת בדיקת אבטחה. בין התכונות שהייתי צריך להתמודד איתן: הפונקציה עדיין לא הופיעה ב- 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()

קובץ לדוגמה עם מילון סיסמה additional_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

מסקנה

מאמר זה בוחן רק את האפשרויות הבסיסיות של עבודה פיתון SDK ומודול cpapi(כפי שאולי ניחשתם, אלו למעשה מילים נרדפות), ועל ידי לימוד הקוד במודול זה תגלו עוד יותר הזדמנויות לעבוד איתו. ייתכן שתרצה להשלים אותו עם מחלקות, פונקציות, שיטות ומשתנים משלך. אתה תמיד יכול לשתף את העבודה שלך ולהציג סקריפטים אחרים עבור צ'ק פוינט בקטע CodeHub בקהילה CheckMates, שמפגיש גם מפתחי מוצר וגם משתמשים.

קידוד שמח ותודה שקראתם עד הסוף!

מקור: www.habr.com