AI 生成程式碼中之語言特定風險

# AI 生成：經 pickle 之任意程式碼執行
import pickle
 
def load_user_preferences(data):
    return pickle.loads(data)  # 執行資料中之任意程式碼
 
# AI 生成：不安全之檔案載入
def load_model(path):
    with open(path, 'rb') as f:
        return pickle.load(f)  # 若 path 為使用者控制則危險
 
# 安全替代
import json
 
def load_user_preferences(data):
    return json.loads(data)  # 無法執行程式碼
 
# 為 ML 模型，使用 safetensors 或驗證簽章
from safetensors import safe_open
def load_model(path):
    return safe_open(path, framework="pt")

# AI 生成：經 eval 之程式碼執行
def calculate(expression):
    return eval(expression)  # 任意程式碼執行
 
def parse_config_value(value_str):
    return eval(value_str)  # 為「True」/「False」而設，執行任何事
 
# 安全替代
import ast
 
def calculate(expression):
    return ast.literal_eval(expression)  # 僅評估字面值
 
def parse_config_value(value_str):
    return {'true': True, 'false': False}.get(value_str.lower())

# AI 生成：經 shell=True 之指令注入
def ping_host(hostname):
    result = subprocess.run(
        f"ping -c 4 {hostname}",
        shell=True,  # 啟動指令注入
        capture_output=True,
        text=True
    )
    return result.stdout
 
# 安全替代
def ping_host(hostname):
    result = subprocess.run(
        ["ping", "-c", "4", hostname],  # 無 shell 解讀
        capture_output=True,
        text=True
    )
    return result.stdout

# AI 生成：經 YAML 之任意程式碼執行
import yaml
 
def load_config(path):
    with open(path) as f:
        return yaml.load(f)  # 不安全載入器，可執行程式碼
 
# 安全替代
def load_config(path):
    with open(path) as f:
        return yaml.safe_load(f)  # 僅載入基礎類型

// AI 生成：經遞迴合併之原型污染
function deepMerge(target, source) {
  for (const key in source) {
    if (typeof source[key] === 'object' && source[key] !== null) {
      if (!target[key]) target[key] = {};
      deepMerge(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  }
  return target;
}
 
// 攻擊者送出：{"__proto__": {"isAdmin": true}}
// 所有物件現具 isAdmin === true
 
// 安全替代
function deepMerge(target, source) {
  for (const key of Object.keys(source)) {  // 僅自有屬性
    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
      continue;  // 跳過危險鍵
    }
    if (typeof source[key] === 'object' && source[key] !== null) {
      if (!target[key]) target[key] = Object.create(null);
      deepMerge(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  }
  return target;
}

// AI 生成：經 eval 之程式碼執行
function processTemplate(template, data) {
  return eval('`' + template + '`');  // 具程式碼執行之範本
 
}
 
// AI 生成：經 Function 建構器之間接 eval
function createValidator(rule) {
  return new Function('value', `return ${rule}`);
}
 
// 安全替代取決於使用情境：
// - 範本字面量：使用範本化函式庫（Handlebars、具轉義之 EJS）
// - 驗證：使用 schema 驗證函式庫（Joi、Zod）

// AI 生成：易受 ReDoS 之 email 驗證
const emailRegex = /^([a-zA-Z0-9]+\.)*[a-zA-Z0-9]+@([a-zA-Z0-9]+\.)*[a-zA-Z]{2,}$/;
// 於 "aaaaaaaaaaaaaaaaaa@" + "a".repeat(100) 之災難性回溯
 
// 安全替代：使用專用驗證函式庫
const { z } = require('zod');
const emailSchema = z.string().email();

// AI 生成：為字串轉換之不必要 unsafe
fn to_string(bytes: &[u8]) -> String {
    unsafe { String::from_utf8_unchecked(bytes.to_vec()) }
    // 若 bytes 非有效 UTF-8 則未定義行為
}
 
// 安全替代
fn to_string(bytes: &[u8]) -> Result<String, std::string::FromUtf8Error> {
    String::from_utf8(bytes.to_vec())
}

// AI 生成：unsafe 指標運算
fn get_element(data: &[u32], index: usize) -> u32 {
    unsafe { *data.as_ptr().add(index) }
    // 無邊界檢查 —— 緩衝區溢位
}
 
// 安全替代
fn get_element(data: &[u32], index: usize) -> Option<u32> {
    data.get(index).copied()
}

// AI 生成：使用後釋放之潛力
fn process_data(data: Vec<u8>) -> *const u8 {
    let ptr = data.as_ptr();
    // data 於此被丟棄，ptr 為懸空
    ptr
}

// AI 生成：缺失 FFI 返回之 null 檢查
extern "C" {
    fn get_user_name() -> *const c_char;
}
 
fn user_name() -> String {
    unsafe {
        CStr::from_ptr(get_user_name())  // 若返回 null 則當機
            .to_string_lossy()
            .into_owned()
    }
}

// AI 生成：SQL 注入
func GetUser(db *sql.DB, username string) (*User, error) {
    query := fmt.Sprintf("SELECT * FROM users WHERE username = '%s'", username)
    row := db.QueryRow(query)
    // ...
}
 
// 安全替代
func GetUser(db *sql.DB, username string) (*User, error) {
    row := db.QueryRow("SELECT * FROM users WHERE username = $1", username)
    // ...
}

// AI 生成：忽略之錯誤
func writeConfig(path string, data []byte) {
    f, _ := os.Create(path)        // 錯誤被忽略
    f.Write(data)                    // 錯誤被忽略，f 可能為 nil
    f.Close()                        // 錯誤被忽略
}
 
// 安全替代
func writeConfig(path string, data []byte) error {
    f, err := os.Create(path)
    if err != nil {
        return fmt.Errorf("creating config: %w", err)
    }
    defer f.Close()
    if _, err := f.Write(data); err != nil {
        return fmt.Errorf("writing config: %w", err)
    }
    return nil
}

// AI 生成：無逾時，易受 slowloris
func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)  // 未組態逾時
}
 
// 安全替代
func main() {
    srv := &http.Server{
        Addr:         ":8080",
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }
    srv.ListenAndServe()
}