@comate/zulu 1.2.1-beta.1 → 1.3.0

package/comate-engine/assets/skills/code-security-comate/references/vul_repair_sensitive.md

@@ -0,0 +1,219 @@
+# 敏感信息硬编码漏洞修复流程
+
+修复漏洞分为以下三个步骤：
+1. 读取漏洞报告
+2. 修复硬编码漏洞
+3. 引入SDK（如果需要）
+
+## 读取漏洞报告
+
+基于凭证配置网页回传的数据获取漏洞报告，示例如下：
+```json
+{
+  "scanChatID": "从 credential_poll 返回的 chatUUID",
+  "repo": {
+    "language": "java",
+    "framework": "springboot"
+  },
+  "deployment": {
+    "platform": 2,
+    "platformName": "ipipe"
+  },
+  "files": [
+    {
+      "name": "src/main/resources/application.properties",
+      "hash": "文件SHA256",
+      "vulList": [
+        {
+          "ruleID": "codescan_generic_password-config_sensitive",
+          "line": 35,
+          "hash": "漏洞hash",
+          "extra": {
+            "secret": {
+              "credentialName": "KL_SPRING_DATASOURCE_PASSWORD",
+              "start": {"col": 28, "line": 35},
+              "end": {"col": 43, "line": 35}
+            }
+          }
+        }
+      ]
+    }
+  ],
+  "trigger": 1,
+  "type": 4
+}
+```
+各字段说明如下：
+* repo：代码库信息
+    * language：代码语言
+    * framework：代码框架
+* deployment：部署信息
+    * platform：部署平台，1 表示 cnap，2 表示 ipipe，3 表示 opera，4 表示 datamanage
+    * platformName：部署平台名称（如 ipipe、cnap、opera、datamanage）
+    * credential_id：凭证 ID（platform 为 4 时使用，用于引入 keyless-sdk）
+* files：文件信息
+    * name：漏洞文件的相对路径
+    * vulList：漏洞列表
+        * extra.secret.start：敏感信息的开始位置（行、列）
+        * extra.secret.end：敏感信息的结束位置（行、列）
+        * extra.secret.credentialName：建议使用的环境变量名称
+
+## 修复漏洞
+硬编码漏洞修复的本质就是改变原来在代码中的硬编码敏感信息写法，改为从环境变量中读取敏感信息。修复时遍历漏洞报告中的所有文件和漏洞，逐个修复，按以下流程进行处理。
+
+### 代码文件
+如果漏洞文件是代码文件，比如 java、go、php、py 等，则根据各语言的写法生成读取环境变量的代码，并替换掉原来的硬编码敏感信息，注意有以下几点要求：
+1. 与环境变量读取无关的其他代码和字符不要做任何改动
+2. 如果漏洞行是被引号包裹的纯字符串，输出时保留其结构不变，仍然可以直接执行字符串操作，但要避免空字符串的拼接
+3. 不要给出环境变量默认值
+4. 如果代码开头存在空格、tab等缩进，保留原始代码的缩进，不要清除两端的空白字符
+5. 如果是 python 语言，使用 os.environ 的方式获取环境变量，而不是 os.getenv
+6. 如果是 go 语言，不能在 const 中读取环境变量，在 const 下方重新定义读取代码，并删除 const 的硬编码的值
+7. 如果是 java 语言，且 platform 为 4 时，则采用 System.getProperty 的语法读取变量
+8. 如果原文件中缺失读取环境变量所需的第三方库，则自动引入，比如 python 的 os 库，go 的 os 库等
+
+### 配置文件
+如果漏洞文件是配置文件，比如 yml、properties、ini 等，则结合语言和框架共同决定如何修改代码，修改原则如下：
+1. 如果语言为 go，框架为 gdp，toml 后缀的文件直接使用特定的占位符替换敏感信息，占位符的环境变量名称根据 credential_name 命名，示例如下：
+```toml
+// 修复前
+password=123123123
+// 修复后
+password=${env.KL_PASSWORD}
+```
+2. 除第一种情况之外，其他语言、框架、配置文件类型，使用常规的环境变量占位符替换敏感信息，占位符的环境变量名称根据 credential_name 命名。
+```toml
+// 修复前
+password=123123123
+// 修复后
+password=${KL_PASSWORD}
+```
+
+漏洞报告可能涉及多个文件，修复时按文件进行聚合，优先将一个文件中的漏洞全部修复完成再修复其他漏洞。
+
+## 引入SDK
+从第一个漏洞报告读取数据，如果 platform 为 4 时需要引入 keyless-sdk 并添加初始化代码。通过该 sdk 将凭证注入到环境变量中，然后其他位置的代码才能读取到环境变量。注意，只有平台为 4 时才需要引入 sdk，其他平台不需要。不同语言 sdk 及初始化代码添加方式如下。
+
+#### java 语言
+pom.xml 文件中添加 keyless-sdk 依赖，其中的注释需要保留。
+```xml
+<!-- keyless-sdk dependency -->
+<dependency>
+    <groupId>com.baidu.xbu-data</groupId>
+    <artifactId>keyless-sdk</artifactId>
+    <version>1.0.2</version>
+</dependency>
+```
+项目启动的函数中添加以下初始化代码，注意其中的 credentialID 需要与漏洞报告中的 credential_id 保持一致。
+```java
+import com.baidu.keyless.KeylessClient;
+
+public class KeylessAppCredentialDemo {
+    public static void main(String[] args) {
+        // 初始化 keyless-sdk 开始
+        // step1: 设置 credentialID 构建 client，详情可参考 https://ku.baidu-int.com/d/BRnvQROwD8akQY
+        String credentialID = "appDemo_prod";
+        KeylessClient keylessClient = KeylessClient.builder()
+            .credentialId(credentialID)
+            .build();
+        // step2: 获取凭证信息并注入到系统环境变量中
+        try {
+            keylessClient.load();
+        } catch (Exception e) {
+            System.out.println("load keyless client error: " + e.getMessage());
+        }
+        // 初始化 keyless-sdk 结束
+        // 以下为其他原始代码
+        ... ...
+    }
+}
+```
+
+#### go 语言
+go.mod 文件中添加 keyless-sdk 依赖，其中的注释需要保留。
+```mod
+require (
+    icode.baidu.com/baidu/xbu-data/things-go keyless-sdk-2.2.0 // keyless-sdk dependency
+)
+```
+项目启动的函数中添加以下初始化代码，注意其中的 CredentialID 需要与漏洞报告中的 credential_id 保持一致。
+```go
+package main
+
+import (
+    "icode.baidu.com/baidu/xbu-data/things-go/pkg/keyless"
+)
+
+func main() {
+    // 初始化 keyless-sdk 开始
+    // step1: 设置 CredentialID 构建 client，详情可参考 https://ku.baidu-int.com/d/G_QqzMQrQR9_K_
+    req := &keyless.GetCredentialReq{
+        CredentialID: "appDemo_prod", // 凭证标识
+    }
+    // step2: 获取凭证信息并注入到系统环境变量中
+    client := keyless.NewClient(req)
+    err := client.Load()
+    if err != nil {
+        fmt.Println(err.Error())
+        return
+    }
+    // 初始化 keyless-sdk 结束
+    // 以下为其他原始代码
+        ... ...
+}
+```
+
+#### python 语言
+requirements.txt 文件中添加 keyless-sdk 依赖，其中的注释需要保留。
+```txt
+// keyless-sdk dependency
+credential-vault-sdk>=0.1.12（Python3 版本添加此依赖）
+credential-vault-sdk-py2>=0.1.9（Python2 版本添加此依赖）
+```
+初始化代码如下，注意
+* 其中的 credential_id 需要与漏洞报告中的 credential_id 保持一致；
+* 如果是完整的服务或项目，初始化代码要添加在项目启动的函数中；
+* 如果是独立的 Python 脚本文件，每个独立的文件都要添加 keyless-sdk 依赖和初始化代码。
+```python
+from credential_vault_sdk.keyless_client import KeylessClient
+
+def main():
+    # 初始化 keyless-sdk 开始
+    # step1: 设置 credential_id 构建 client，详情可参考 https://ku.baidu-int.com/d/HWaSIaQSThk88b
+    client = KeylessClient(credential_id="appDemo_prod")
+    # step2: 获取凭证信息并注入到系统环境变量中
+    client.load()
+    # 初始化 keyless-sdk 结束
+    # 以下为其他原始代码
+    ... ...
+```
+
+#### C++ 语言
+在文件开始引入头文件和命名空间，其中的注释需要保留：
+```C++
+// keyless-sdk dependency
+#include "keyless/keyless_client.h"
+
+using namespace baidu::credentialvault::cppsdk;
+```
+
+项目启动的函数中添加以下初始化代码，注意其中的 credentialID 需要与漏洞报告中的 credential_id 保持一致。
+```C++
+#include "keyless/keyless_client.h"
+
+using namespace baidu::credentialvault::cppsdk;
+
+int main(int argc, char *argv[]) {
+    // 初始化 keyless-sdk 开始
+    // step1: 设置 credential_id 构建 client，详情可参考 https://ku.baidu-int.com/d/x5s_A3YHll0PvR
+    KeylessClient client = KeylessClient("appDemo_prod");
+    // step2: 获取凭证信息并注入到系统环境变量中
+    KeylessStatus load_result = client.load();
+    if (!load_result.ok()) {
+        return 0;
+    }
+    // 初始化 keyless-sdk 结束
+    // 以下为其他原始代码
+    ... ...
+}
+```

package/comate-engine/assets/skills/code-security-comate/scripts/credential_hosting.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+凭证托管工具 - 将凭证托管到第三方平台（iPipe/CNAP/datamanage）。
+
+用法:
+    python3 credential_hosting.py --poll-result <poll_result.json路径> --username <用户名>
+
+    也可手动指定各参数（不推荐，仅向后兼容）:
+    python3 credential_hosting.py --chat-id <chatID> --platform <platformName> --username <用户名> --credentials '<JSON>'
+
+使用 --poll-result 时，自动从 credential_poll.py 的输出文件中提取 chatUUID、deployment.platformName、data.credentials。
+"""
+
+import argparse
+import json
+import logging
+import sys
+
+import http_client  # noqa: F401 (triggers shared logging config)
+import utils
+
+logger = logging.getLogger("credential_hosting")
+
+
+def hosting_credentials(chat_id, platform, credentials, username, user_id):
+    """将凭证托管到指定平台。"""
+    url = "{}/api/v1/deployments/{}/credentials".format(utils.HOST, platform)
+    payload = {
+        "configs": credentials,
+        "scanChatID": chat_id,
+    }
+
+    logger.info("credential_hosting: chat_id=%s, platform=%s, credentials_count=%d",
+                chat_id, platform, len(credentials))
+    print("正在托管凭证到 {} 平台...".format(platform), file=sys.stderr)
+    return http_client.post(
+        url,
+        headers=utils.build_headers(username, user_id, chat_id),
+        json_body=payload,
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="凭证托管工具")
+    parser.add_argument("--poll-result", default=None, help="credential_poll.py 输出的结果文件路径，自动提取所需参数")
+    parser.add_argument("--chat-id", default=None, help="scanChatID（使用 --poll-result 时可省略）")
+    parser.add_argument("--platform", default=None, help="托管平台名称（使用 --poll-result 时可省略）")
+    parser.add_argument("--username", required=True, help="Comate 用户名")
+    parser.add_argument("--credentials", default=None, help="凭证配置 JSON（使用 --poll-result 时可省略）")
+    args = parser.parse_args()
+
+    user_id = utils.make_user_id(args.username)
+
+    chat_id = args.chat_id
+    platform = args.platform
+    credentials = None
+
+    if args.poll_result:
+        # 从 poll_result 文件提取所有参数
+        try:
+            with open(args.poll_result, "r", encoding="utf-8") as f:
+                poll_data = json.load(f)
+        except Exception as e:
+            print("错误: 读取 poll-result 失败 {}: {}".format(args.poll_result, e), file=sys.stderr)
+            sys.exit(1)
+
+        chat_id = chat_id or poll_data.get("chatUUID", "")
+        data = poll_data.get("data", {})
+        platform = platform or data.get("deployment", {}).get("platformName", "")
+        credentials = data.get("credentials")
+    elif args.credentials:
+        try:
+            credentials = json.loads(args.credentials)
+        except json.JSONDecodeError as e:
+            print("错误: 凭证 JSON 解析失败: {}".format(e), file=sys.stderr)
+            sys.exit(1)
+
+    if not chat_id or not platform or credentials is None:
+        print("错误: 缺少必要参数。使用 --poll-result 或同时提供 --chat-id、--platform、--credentials", file=sys.stderr)
+        sys.exit(1)
+
+    result = hosting_credentials(chat_id, platform, credentials, args.username, user_id)
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/comate-engine/assets/skills/code-security-comate/scripts/credential_poll.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+凭证配置轮询工具 - 通过 WebSocket 监听凭证托管助手网页的配置结果。
+
+用法:
+    python3 credential_poll.py --chat-id <chatID> --username <用户名>
+
+流程:
+    1. 连接 WebSocket 端点
+    2. 等待用户在网页完成凭证配置并点击「生成代码」
+    3. 收到 msgType=repair 消息后输出配置数据
+
+注意: 使用 Python 标准库实现 WebSocket 客户端，无需第三方依赖。
+"""
+
+import argparse
+import base64
+import json
+import logging
+import os
+import socket
+import struct
+import sys
+import time
+
+try:
+    import ssl
+    _SSL_AVAILABLE = True
+except ImportError:
+    _SSL_AVAILABLE = False
+
+# 触发共享日志配置
+import http_client  # noqa: F401
+import utils
+
+logger = logging.getLogger("credential_poll")
+
+WS_TIMEOUT = 30 * 60  # 30 分钟超时
+RECV_TIMEOUT = 5  # 每次 recv 超时秒数
+MAX_RECONNECT = 10
+RECONNECT_BASE_INTERVAL = 1  # 秒
+
+# WebSocket opcodes
+OP_TEXT = 0x1
+OP_CLOSE = 0x8
+OP_PING = 0x9
+OP_PONG = 0xA
+
+
+def _generate_ws_key():
+    """生成随机的 Sec-WebSocket-Key。"""
+    return base64.b64encode(os.urandom(16)).decode("ascii")
+
+
+def _ws_connect(host, port, path, headers, use_ssl=True, timeout=10):
+    """
+    建立 WebSocket 连接，返回 socket 对象。
+    执行 HTTP Upgrade 握手，验证 101 响应。
+    """
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.settimeout(timeout)
+
+    if use_ssl:
+        if not _SSL_AVAILABLE:
+            raise RuntimeError(
+                "WebSocket 需要 SSL 但 ssl 模块不可用。"
+                "请安装 libssl1.1 或重新编译 Python 以支持 ssl。"
+            )
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        sock = ctx.wrap_socket(sock, server_hostname=host)
+
+    sock.connect((host, port))
+
+    # 构造握手请求
+    ws_key = _generate_ws_key()
+    lines = [
+        "GET {} HTTP/1.1".format(path),
+        "Host: {}".format(host),
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Version: 13",
+        "Sec-WebSocket-Key: {}".format(ws_key),
+    ]
+    for k, v in headers.items():
+        lines.append("{}: {}".format(k, v))
+    lines.append("")
+    lines.append("")
+
+    request = "\r\n".join(lines)
+    sock.sendall(request.encode("utf-8"))
+
+    # 读取响应头
+    response = b""
+    while b"\r\n\r\n" not in response:
+        chunk = sock.recv(4096)
+        if not chunk:
+            raise ConnectionError("连接在握手期间被关闭")
+        response += chunk
+
+    header_end = response.index(b"\r\n\r\n")
+    header_part = response[:header_end].decode("utf-8")
+    status_line = header_part.split("\r\n")[0]
+
+    # 验证 101 状态码
+    parts = status_line.split(" ", 2)
+    status_code = int(parts[1])
+    if status_code != 101:
+        # 尝试读取 body 获取错误信息
+        body_part = response[header_end + 4:]
+        error_msg = body_part.decode("utf-8", errors="replace") if body_part else ""
+        raise ConnectionError("WebSocket 握手失败: HTTP {} - {}".format(status_code, error_msg))
+
+    return sock
+
+
+def _ws_recv_frame(sock):
+    """
+    接收一个 WebSocket 帧，返回 (opcode, payload_bytes)。
+    """
+    def _recv_exact(n):
+        data = b""
+        while len(data) < n:
+            chunk = sock.recv(n - len(data))
+            if not chunk:
+                raise ConnectionError("连接被关闭")
+            data += chunk
+        return data
+
+    # 读取 2 字节头
+    head = _recv_exact(2)
+    opcode = head[0] & 0x0F
+    masked = (head[1] & 0x80) != 0
+    payload_len = head[1] & 0x7F
+
+    # 扩展长度
+    if payload_len == 126:
+        payload_len = struct.unpack("!H", _recv_exact(2))[0]
+    elif payload_len == 127:
+        payload_len = struct.unpack("!Q", _recv_exact(8))[0]
+
+    # mask (服务端发给客户端通常不 mask，但保留处理)
+    mask_key = None
+    if masked:
+        mask_key = _recv_exact(4)
+
+    # payload
+    payload = _recv_exact(payload_len)
+
+    if mask_key:
+        payload = bytes(b ^ mask_key[i % 4] for i, b in enumerate(payload))
+
+    return opcode, payload
+
+
+def _ws_send_frame(sock, opcode, payload=b""):
+    """
+    发送一个 WebSocket 帧（客户端发送需要 mask）。
+    """
+    mask_key = os.urandom(4)
+    masked_payload = bytes(b ^ mask_key[i % 4] for i, b in enumerate(payload))
+
+    frame = bytearray()
+    frame.append(0x80 | opcode)  # FIN + opcode
+
+    length = len(payload)
+    if length < 126:
+        frame.append(0x80 | length)  # MASK bit + length
+    elif length < 65536:
+        frame.append(0x80 | 126)
+        frame.extend(struct.pack("!H", length))
+    else:
+        frame.append(0x80 | 127)
+        frame.extend(struct.pack("!Q", length))
+
+    frame.extend(mask_key)
+    frame.extend(masked_payload)
+
+    sock.sendall(bytes(frame))
+
+
+def _ws_send_pong(sock, payload=b""):
+    """回复 pong 帧。"""
+    _ws_send_frame(sock, OP_PONG, payload)
+
+
+def _ws_send_close(sock, code=1000, reason=""):
+    """发送 close 帧。"""
+    payload = struct.pack("!H", code) + reason.encode("utf-8")
+    _ws_send_frame(sock, OP_CLOSE, payload)
+
+
+def _parse_ws_url(url):
+    """解析 wss://host/path，返回 (host, port, path, use_ssl)。"""
+    if url.startswith("wss://"):
+        use_ssl = True
+        default_port = 443
+        rest = url[6:]
+    elif url.startswith("ws://"):
+        use_ssl = False
+        default_port = 80
+        rest = url[5:]
+    else:
+        raise ValueError("不支持的 URL scheme: {}".format(url))
+
+    if "/" in rest:
+        host_port, path = rest.split("/", 1)
+        path = "/" + path
+    else:
+        host_port = rest
+        path = "/"
+
+    if ":" in host_port:
+        host, port_str = host_port.split(":", 1)
+        port = int(port_str)
+    else:
+        host = host_port
+        port = default_port
+
+    return host, port, path, use_ssl
+
+
+def poll_credential_config(chat_id, user_id):
+    """通过 WebSocket 监听凭证配置，返回配置数据 dict 或 None。"""
+    url = "{}/api/v1/ws/credential/events".format(utils.WS_HOST)
+    host, port, path, use_ssl = _parse_ws_url(url)
+    logger.info("credential_poll start: chat_id=%s", chat_id)
+
+    ws_headers = {
+        "SAST-Chat-ID": chat_id,
+        "Comate-User-Id": user_id,
+    }
+
+    reconnect_attempts = 0
+    start_time = time.time()
+
+    while time.time() - start_time < WS_TIMEOUT:
+        sock = None
+        try:
+            sock = _ws_connect(host, port, path, ws_headers, use_ssl, timeout=RECV_TIMEOUT)
+            print("WebSocket 已连接，等待凭证配置...", file=sys.stderr)
+            reconnect_attempts = 0  # 连接成功，重置重连计数
+
+            while time.time() - start_time < WS_TIMEOUT:
+                try:
+                    opcode, payload = _ws_recv_frame(sock)
+
+                    if opcode == OP_TEXT:
+                        msg = payload.decode("utf-8")
+                        if not msg:
+                            continue
+                        data = json.loads(msg)
+                        msg_type = data.get("msgType", "")
+
+                        if msg_type == "repair":
+                            print("收到凭证配置数据", file=sys.stderr)
+                            logger.info("credential_poll received repair data")
+                            try:
+                                _ws_send_close(sock)
+                            except Exception:
+                                pass
+                            return data
+                        elif msg_type == "openFile":
+                            continue
+
+                    elif opcode == OP_PING:
+                        _ws_send_pong(sock, payload)
+
+                    elif opcode == OP_CLOSE:
+                        print("服务端关闭连接，尝试重连...", file=sys.stderr)
+                        break
+
+                except socket.timeout:
+                    # recv 超时，继续等待
+                    continue
+                except (ConnectionError, OSError):
+                    print("WebSocket 连接断开，尝试重连...", file=sys.stderr)
+                    break
+                except ValueError as e:
+                    print("JSON 解析失败: {}".format(e), file=sys.stderr)
+                    continue
+
+        except ConnectionError as e:
+            err_msg = str(e)
+            print("WebSocket 连接失败: {}".format(err_msg), file=sys.stderr)
+            # 400004 表示会话不存在（用户还未打开网页），继续重试等待用户打开
+            # 其他业务错误直接退出
+            if "400004" in err_msg:
+                print("会话不存在，等待用户打开凭证托管网页...", file=sys.stderr)
+            elif "HTTP 200" in err_msg or "400" in err_msg:
+                print("服务端拒绝连接，请检查 chatID 是否有效", file=sys.stderr)
+                return None
+
+        except Exception as e:
+            print("WebSocket 连接失败: {}".format(e), file=sys.stderr)
+
+        finally:
+            if sock:
+                try:
+                    sock.close()
+                except Exception:
+                    pass
+
+        # 重连逻辑：指数退避
+        reconnect_attempts += 1
+        if reconnect_attempts > MAX_RECONNECT:
+            print("达到最大重连次数，退出", file=sys.stderr)
+            return None
+
+        delay = RECONNECT_BASE_INTERVAL * (2 ** (reconnect_attempts - 1))
+        print("{}秒后重连 (第{}/{})次...".format(delay, reconnect_attempts, MAX_RECONNECT), file=sys.stderr)
+        time.sleep(delay)
+
+    print("超时，未收到凭证配置", file=sys.stderr)
+    logger.warning("credential_poll timeout: chat_id=%s", chat_id)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser(description="凭证配置轮询工具")
+    parser.add_argument("--chat-id", required=True, help="scanChatID，用于关联扫描会话")
+    parser.add_argument("--username", required=True, help="Comate 用户名")
+    parser.add_argument("--output", default=None, help="将结果保存到指定文件路径（同时仍输出到标准输出）")
+    args = parser.parse_args()
+
+    user_id = utils.make_user_id(args.username)
+
+    result = poll_credential_config(args.chat_id, user_id)
+    if result:
+        output_json = json.dumps(result, ensure_ascii=False, indent=2)
+        print(output_json)
+        if args.output:
+            output_dir = os.path.dirname(os.path.abspath(args.output))
+            os.makedirs(output_dir, exist_ok=True)
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(output_json)
+            print("已保存: {}".format(args.output), file=sys.stderr)
+    else:
+        print(json.dumps({"error": "未收到凭证配置数据"}, ensure_ascii=False))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()