---
title: "Kobako：從預設開放到拒絕，便利與安全性的挑戰"
date: 2026-11-18T00:00:00+08:00
publishDate: 2026-11-18T00:00:00+08:00
lastmod: 2026-11-16T21:43:57+08:00
tags: ["LLM","AI","經驗","Ruby","WebAssembly","Gem","mruby","Rust"]
series: "kobako"
toc: true
cover: "https://blog.aotoki.me/posts/2026/11/18/kobako-from-default-allow-to-deny/cover_hu_c57a47befc618b56.webp"
permalink: "https://blog.aotoki.me/posts/2026/11/18/kobako-from-default-allow-to-deny/"
language: "zh-tw"
---

Kobako 在設計階段就把宿主（Host）和客體（Guest）可以輕鬆溝通當目標，這也是[繫結服務（Bind）](https://blog.aotoki.me/posts/2026/11/11/kobako-why-sandbox-has-no-time/)機制會被設計出來的理由。

為了讓使用者可以非常輕鬆的使用，基本上只要呼叫 `Sandbox#bind` 時提供任意物件，就可以在客體呼叫這個物件的方法，卻帶來了極大的風險，最後只能選擇改變設計。

## 逃脫

大多數的安全問題都是由「邊界」設計不完整引起，最近台灣不少資安事件，也都是先從脆弱的點被攻破後，還能繼續移動到其他地方才讓嚴重性上升。

Kobako 的客體本身就是「可以跑任意程式碼」的地方，也就是弱點，而「繫結機制」剛好又能從客體穿透到宿主，滿足移動的條件，那麼就構成了一條攻擊路徑。

正常狀況下，幾乎不會想到這樣的路徑，但我們把普通物件繫結後，因為 Ruby 的語言特性，讓漏洞就這樣曝露出來。

```ruby
class UserRepository
  def initialize(tenant:) = @tenant = tenant
  def find(email:) = "found #{email}"
end

sandbox.bind("UserRepository", UserRepository.new(tenant: "acme"))

sandbox.eval(<<~RUBY)
  UserRepository.send(:eval, "1 + 1")
RUBY
```

我們預期使用者只會使用 `UserRepository.find(...)` 的方式呼叫，但沒想到使用者用了 `UserRepository.send(:eval, "1 + 1")` 這樣的寫法，在這個階段 Kobako 因為不清楚使用者實際是什麼物件，所以會利用 `public_send` 來協助轉送。

```ruby
def dispatch(target, method, *args)
  target.public_send(method, *args)
end
```

就結果而言，`UserRepository.send(...)` 被翻譯為 `target.public_send(:send, :eval, "1 + 1")` 這樣的形式。

雖然用了 `#public_send` 但是 `#send` 還是被允許透過 `#public_send` 呼叫，原本不能呼叫的私有方法 `#eval` 就順利被釋放出來，變成可以利用的位置。

那麼，有了 `#eval` 能做的事情幾乎就是原本 CRuby 可以做的事情，風險就被升高到非常多。

## 防禦

防禦方總是比較困難的地方在於，如果使用者有正當的理由不該阻止，但當被惡意使用者利用時，到底要有多少限制才不會讓使用者覺得不方便呢？

首先，針對 `#send` 的問題，理論上所有物件都是透過「繼承」拿到這個特性，所以在初期的版本中，採用了列舉帶有高風險能力的物件，拒絕透過繼承使用這些能力。

```ruby
BLOCKED = [BasicObject, Kernel, Object, Module, Class]

def dispatch(target, method, *args)
  owner = target.public_method(method).owner
  raise NoMethodError, "#{method} is not a Service method" if BLOCKED.include?(owner)
  
  target.public_send(method, *args)
end
```

在這個狀況下，原本 `#send` 方法可以被利用，但因為它屬於 `BLOCKED` 定義的方法，就會變成 `NoMethodError` 而無法使用，看起來就足以解決這個缺陷。

然而，這還存在更多邊界問題，在後續的安全性回報中，又看到了這樣的利用方式。

```ruby
class Store
  def initialize = @io = File.open("/etc/hostname")
  def backend_type = @io.class
end

sandbox.bind("App::Store", Store.new)

sandbox.eval(<<~RUBY)
  klass = App::Store.backend_type
  klass.read("/etc/hostname")
RUBY
```

或者像這樣的利用方式

```ruby
class UserRepositoryDecorator < SimpleDelegator; end

sandbox.bind("UserRepository", UserRepositoryDecorator.new(UserRepository.new(tenant: "acme")))

sandbox.eval(<<~RUBY)
  UserRepository.method_missing(:eval, "1 + 1")
RUBY
```

第一種是因為 `#backend_type` 回傳 `Class` 類型物件後，被 Handle 機制包裝，這樣只需要猜到外部是一個 `File` 類別物件，就能用 `#read` 逃脫讀取系統檔案。

第二種則是 `SimpleDelegator` 自訂了 `#method_missing` 的能力還能呼叫 `BLOCKED` 範圍內的類別，反而再次逃離原本 `BLOCKED` 的範圍，即使原本設計了 `#respond_to_guest?` 讓使用者可以控制安全的操作，但因為方便通常不會設定，反而讓各種可被利用的選項持續出現。

為了避免這類問題再次發生，現在預設會把所有宿主的物件包裝，並且仔細檢查每一條呼叫路徑再放行，等於在沒有定義 `#respond_to_guest?` 的時候，由 Kobako 先幫所有人定義了預設的版本。

```ruby
def exposed_methods(target)
  case target
  when Module, Delegator then []
  else target.class.public_instance_methods(false)
  end
end

def dispatch(target, method, *args)
  allowed =
    if target.respond_to?(:respond_to_guest?, true)
      target.__send__(:respond_to_guest?, method)
    else
      exposed_methods(target).include?(method)
    end
  raise NoMethodError, "#{method} is not exposed to the guest" unless allowed

  target.public_send(method, *args)
end
```

調整後的處理，會先確認是否有定義 `#respond_to_guest?` 來決定是否放行，如果沒有則使用一個通用的方式檢查

- 排除已知的系統物件
- 只列出物件自己的公開方法，私有和繼承的都不開放

這樣一來，除非物件自己定義了會呼叫繼承來的 `#send` 的方法，不然很難再被利用這些能力，雖然使用上需要自己重新定義像是 `#each` 之類的方法，但透過這種預設拒絕的機制，才把這類型的安全問題完整防堵。

## 取捨

預設開放的設計讓繫結物件很輕鬆，但這邊在加強安全的同時，運作上會「稍微慢一點」以及使用上會變得比較不方便。

像是用來模擬 Cloudflare Workers 的範例中，原本可以直接把 `Rack::Request` 繫結，但因為這個關係，我們需要改寫成這樣。

```ruby
class GuestRequest < Rack::Request
  private

  def respond_to_guest?(name) = %i[request_method path params].include?(name)
end
```

現在必須明確地把 `respond_to_guest?` 寫下才能使用，但順帶的也將像是 `#env` 這類方法阻隔起來，宿主的資訊反而不會洩漏，使用者也比較能清楚自己在做什麼。

即使刻意放寬，Kobako 現有的機制也可以很好的阻止。

```ruby
class Profile
  def initialize = @secret = "TOPSECRET"

  private

  def respond_to_guest?(_name) = true
end

sandbox.bind("Profile", Profile.new)

sandbox.eval(<<~RUBY)
  Profile.pretty_print_instance_variables
RUBY
```

上面的例子是宿主安裝了 PrettyPrint 套件，所以會帶入像是 `#pretty_print_instance_variables` 的方法可以把 `@secret` 印出來，此時就會因為前面 `BLOCKED` 演變而來的檢查，只要是透過繼承拿到的能力就先拒絕，`#respond_to_guest?` 只能縮小範圍而不能重新開放，就能避免錯誤的把 `@secret` 印出來。

整體來說，原本為了極致的開發體驗讓安全性問題變得嚴重，最終只能讓使用者多一點不方便和額外處理，換來可以安心使用的設計。
