使用 Python SDK 简化 Check Point API

当与程序代码一起使用时，当可以动态生成 API 请求和用于分析 API 响应的工具时，与 API 交互的全部威力就会显现出来。 然而，仍然难以察觉 Python 软件开发工具包 （以下简称Python SDK） 检查点管理API，但徒劳无功。 它极大地简化了开发人员和自动化爱好者的生活。 Python 最近获得了巨大的流行，我决定填补这一空白并回顾其主要功能。 Check Point API Python 开发套件。 本文是对哈布雷另一篇文章的精彩补充 检查点 R80.10 API。 通过 CLI、脚本等进行管理。 我们将了解如何使用 Python SDK 编写脚本，并仔细研究版本 1.6 中的新管理 API 功能（从 R80.40 开始支持）。 要理解本文，您需要使用 API 和 Python 的基础知识。

Check Point 正在积极开发 API，目前已发布以下内容：

• Check Point 管理 API（当前版本 1.6） — 通过 API 与控制服务器合作（以及在控制服务器控制的网关上执行脚本的能力）
• 检查点 GAIA API（当前版本 1.4） — 与安全网关合作
• 威胁防御API 1.0 — 使用 Check Point 云中的沙箱
• 身份识别API — 在网关上使用身份识别刀片
• 安全管理门户API — 使用 SMB 网关管理门户（有关 SMB 网关的更多信息)
• 物联网应用程序接口 — 与物联网控制器交互
• 云卫士连接API - 与 云卫士连接 （SD-WAN安全解决方案）
• Dome9 API - 与 Dome9

Python SDK目前仅支持与管理API交互 盖亚API。 我们将了解本模块中最重要的类、方法和变量。

安装模块

模 CPAPI 快速、轻松地安装 github 上的官方 Check Point 存储库 通过 点子。 详细的安装说明可参见 README.md。 该模块适用于 Python 2.7 和 3.7 版本。 在本文中，将使用 Python 3.7 给出示例。 但是，Python SDK 可以直接从 Check Point 管理服务器（智能管理）运行，但它们仅支持 Python 2.7，因此最后一节将提供 2.7 版本的代码。 安装模块后，我建议立即查看目录中的示例 示例_python2 и 示例_python3.

入门

为了让我们能够使用 cpapi 模块的组件，我们需要从模块导入 CPAPI 至少两个必修课程：

API客户端 и API客户端参数

from cpapi import APIClient, APIClientArgs

类 API客户端参数 负责API服务器的连接参数，以及类 API客户端 负责与API交互。

确定连接参数

要定义连接API的各种参数，您需要创建该类的实例 API客户端参数。 原则上，其参数是预定义的，在控制服务器上运行脚本时不需要指定它们。

client_args = APIClientArgs()

但在第三方主机上运行时，您至少需要指定API服务器（也称为管理服务器）的IP地址或主机名。 在下面的示例中，我们定义服务器连接参数，并将管理服务器的 IP 地址作为字符串分配给它。

client_args = APIClientArgs(server='192.168.47.241')

我们来看看连接API服务器时可以使用的所有参数及其默认值：

APIClientArgs 类的 __init__ 方法的参数

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

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

我相信可以在 APIClientArgs 类的实例中使用的参数对于 Check Point 管理员来说是直观的，不需要额外的注释。

通过 APIClient 和上下文管理器连接

类 API客户端 使用它最方便的方法是通过上下文管理器。 需要传递给 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)

请注意，今后的课程 API客户端 将检查每个 API 调用（方法 api_调用 и api查询，我们将进一步讨论它们）API 服务器上的 sha1 指纹证书。 但是，如果在检查 API 服务器证书的 sha1 指纹时检测到错误（证书未知或已更改），则该方法 检查指纹 将提供在本地计算机上自动添加/更改有关它的信息的机会。 可以使用 APIClientArgs 参数完全禁用此检查（但只有在连接到 127.0.0.1 时在 API 服务器本身上运行脚本时才建议这样做） - 不安全自动接受 （请参阅前面“定义连接参数”中有关 APIClientArgs 的更多信息）。

client_args = APIClientArgs(unsafe_auto_accept=True)

登录API服务器

У API客户端 登录API服务器的方法多达3种，每种方法都明白其含义 SID(session-id)，在 header 中后续每次 API 调用时都会自动使用该参数（该参数的 header 中的名称为 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/管理 API v1.6 开始支持， “3TsbPJ8ZKjaJGvFyoFqHFA==” 这是管理服务器上使用 API 密钥授权方法的用户之一的 API 密钥值）：

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

在方法中 使用 api 密钥登录 与方法中相同的可选参数可用 登录.

登录为根方法

使用 API 服务器登录本地计算机的选项：

     login = client.login_as_root()

此方法只有两个可选参数可用：

domain=None, payload=None

最后API调用自己

我们有两种选择通过方法进行 API 调用 api_调用 и api查询。 让我们弄清楚它们之间有什么区别。

api_调用

此方法适用于任何调用。 如有必要，我们需要在请求正文中传递 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查询

我马上预约一下，这个方法只适用于输出涉及偏移量的调用。 当包含或可能包含大量信息时，就会发生这种推断。 例如，这可能是对管理服务器上所有创建的主机对象的列表的请求。 对于此类请求，API 默认返回 50 个对象的列表（您可以在响应中将限制增加到 500 个对象）。 为了不通过改变 API 请求中的 offset 参数来多次拉取信息，有一个 api_query 方法可以自动完成这项工作。 需要此方法的调用示例： 显示会话、显示主机、显示网络、显示通配符、显示组、显示地址范围、显示简单网关、显示简单集群、显示访问角色、显示受信任客户端、显示包。 事实上，我们在这些 API 调用的名称中看到复数单词，因此这些调用将更容易通过 api查询

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），则返回 True；如果不成功（任何其他响应代码），则返回 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。 下面，请注意管理服务器上有任务正在运行时的示例，但我们会认为此请求不成功（我们将 success 变量设置为 假，尽管 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']}}

data

允许您只看到响应的正文（body），而没有不必要的信息。

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'

有用的例子

以下是使用 Management API 1.6 中添加的 API 调用的示例。

首先，我们来看看调用是如何工作的 添加主机 и 添加地址范围。 假设我们需要创建子网 192.168.0.0/24 的所有 IP 地址（最后一个八位字节为 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 调用解决同样的问题 批量添加对象，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 倍。 对于更多数量的物体，差异会更加令人印象深刻。

现在让我们看看如何使用 设置对象批次。 使用此 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 调用中删除多个对象 批量删除对象。 现在让我们看一个代码示例，该示例删除之前通过以下方式创建的所有主机 批量添加对象.

使用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中就出现了Revert to revision、Smart Task这样的“功能”，并立即为它们准备了相应的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")

在 Check Point 管理服务器上运行 Python 脚本

一切都一样 README.md 包含有关如何直接从控制服务器运行 Python 脚本的信息。 当您无法从另一台计算机连接到 API 服务器时，这会很方便。 我录制了一个六分钟的视频，在其中查看如何安装模块 CPAPI 以及在控制服务器上运行Python脚本的功能。 例如，运行一个脚本，自动为网络审核等任务配置新网关 安全检查。 我必须处理的功能包括：该功能尚未出现在 Python 2.7 中 输入，因此为了处理用户输入的信息，使用了一个函数 原始输入。 其他方面与其他机器启动代码相同，只是使用功能更方便 以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","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

结论

本文仅考察工作的基本可能性 开发工具包 和模块 CPAPI（正如您可能已经猜到的，这些实际上是同义词），通过研究本模块中的代码，您将发现更多使用它的机会。 您可能想用自己的类、函数、方法和变量来补充它。 您可以随时在 参考资料 部分分享您的作品并查看 Check Point 的其他脚本 代码中心 在社区中 将军，它将产品开发人员和用户聚集在一起。

祝您编码愉快，感谢您阅读到最后！

来源： habr.com