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

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

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

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

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

התקנת המודול

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

תחילת העבודה

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

לקוח API и APIClientArgs

from cpapi import APIClient, APIClientArgs

בכיתה APIClientArgs אחראי על פרמטרי החיבור לשרת ה-API ועל המחלקה לקוח API אחראי על האינטראקציה עם ה-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 מובנים באופן אינטואיטיבי למנהלי Check Point ואינם דורשים הערות נוספות.

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

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

with APIClient(client_args) as client:

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

client = APIClient(clieng_args)

בדיקת חיבור

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

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

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

client_args = APIClientArgs(unsafe_auto_accept=True)

התחברות לשרת ה-API

У לקוח API ישנן עד 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==') 

בשיטה כניסה_עם_מפתח_API אותם פרמטרים אופציונליים זמינים כמו בשיטה התחבר.

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

לאחר מכן, ניתן להשתמש במשתנים ובמתודות של המחלקה. תגובת APISponse(בתוך ומחוץ למנהל ההקשר). המחלקה תגובת APISponse ישנן 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.

סט_מצב_הצלחה

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

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

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

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

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

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

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

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

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

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

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

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

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

objects_list_ip = []
objects_list_range = []

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

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

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

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

print(delete_objects_batch.data)

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

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

from cpapi import APIClient, APIClientArgs

client_args = APIClientArgs(server="192.168.47.240")

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

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

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

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

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

מקור: www.habr.com