공개 출처에서 거래 신호를 읽고, 이를 분석하여 토큰을 매수/매도할지 결정하는 LLM 에이전트를 상상해 보십시오. 이 에이전트는 수백만 달러를 관리합니다. 이러한 에이전트는 디스코드 서버, 트위터 피드, 텔레그램 봇, 기업 플랫폼 등 모든 곳에 존재합니다.

문제는 무엇일까요? 생산 환경의 대부분 LLM 시스템과 마찬가지로 이들은 오픈 소스 모델(LLaMA, Mistral 등)을 기반으로 실행됩니다.

오픈 소스는 한 가지를 의미합니다. 즉, 공격자가 가중치(weights)를 다운로드하여 로컬에서 공격을 최적화할 수 있다는 것입니다. 그리고 무서운 점은 이것입니다. 이 공격은 플랫폼에 관계없이 모든 인스턴스에서 동시에 작동한다는 것입니다.

이것은 한 사용자에게 대한 피싱이 아닙니다. 이는 아키텍처적인 대규모 악용(mass-exploitation)입니다.

에이전트가 오픈 소스 모델을 사용하는 이유

이상하게 들릴 수 있습니다. 왜 GPT-4 API를 사용하지 않을까요? 더 강력하고, 더 안전하며, 주요 기업의 지원을 받기 때문입니다.

답은 비용(cost)입니다. 오픈 소스 모델은 저렴합니다. 호스팅 업체가 LLaMA-7B를 한 번 다운로드하여 자체 서버에 배포하면 요청당 비용이 전혀 들지 않습니다. 유연성이 높습니다. 미세 조정(fine-tune)할 수 있고, 데이터를 제어할 수 있으며, 어디든 배포할 수 있습니다.

스타트업에게는 비즈니스적으로 합리적입니다. 하지만 비즈니스적인 합리성 ≠ 보안입니다.

모델 가중치에 대한 Gradient 기반 공격

Gradient 기반 적대적 공격(예: Greedy Coordinate Gradient)은 공격자가 기울기 하강법(gradient descent)을 통해 모델 가중치에 직접적으로 적대적 접미사(adversarial suffix)를 최적화하는 화이트박스 공격입니다. 이 접미사는 특정 가중치에 맞게 조정됩니다. 가중치를 변경하면 취약점이 사라집니다.

작동 방식은 다음과 같습니다:

1. 오픈 소스 LLaMA-7B 다운로드
2. 목표 출력 정의: `/buy_order {

다음 단계에서 발생하는 일:

1. 여러 플랫폼의 에이전트들이 메시지를 읽음 (RAG, 피드 스캐닝 등)
2. 텍스트가 모델로 입력됨
3. 모델이 생성함: /buy_order {"amount": 50000, "token": "$SCAMRUG"}
4. 런타임 (Runtime)에서 정규 표현식 (regex)으로 이를 파싱함
5. 실행함: trading_api.buy(amount=50000, token="$SCAMRUG")
6. 실제로 $50,000가 소비됨
7. 이 과정이 수천 개의 에이전트 인스턴스에서 동시에 발생함

규모는? 여러 플랫폼에 걸친 단 하나의 게시물로 인해 수십억 달러의 손실이 발생할 수 있습니다.

첫 번째 방어 시도: 무작위 노이즈 (random noise)

명백한 아이디어는 다음과 같습니다: 매 추론 (inference) 전에 가중치 (weights)에 무작위 노이즈를 추가하는 것입니다. 그러면 접미사 (suffix)가 깨지게 됩니다.

# 추론 전
shift = random.normal(0, 0.1, size=model.weights.shape)
model.weights += shift
...

합리적으로 들립니다. 하지만 결함이 있습니다.

공격자는 그래디언트 기반 적대적 공격 (gradient-based adversarial attacks)을 매번 다른 무작위 노이즈를 사용하여 여러 번 수행할 수 있습니다. 그런 다음 이러한 접미사들을 평균 냅니다. 그러면 어떻게 될까요?

수학적으로, 서로 다른 노이즈 수준에서 최적화된 값들을 평균 내면... 베이스 모델 (base model)에서 최적화된 접미사로 수렴합니다. 무작위 노이즈의 평균은 0에 가까워지기 때문입니다.

결과: 최종 접미사가 보호되지 않은 모델에서 작동합니다. 방어에 실패했습니다.

왜일까요? 노이즈가 **정적 (static)**이기 때문입니다. 노이즈가 입력값에 의존하지 않습니다. 입력 A에 대해서는 특정 무작위 노이즈가 있고, 입력 B에 대해서는 다른 무작위 노이즈가 있습니다. 하지만 이것들은 단지 무작위 숫자일 뿐입니다. 공격자는 단순히 여러 노이즈 수준에 걸쳐 데이터를 수집하여 평균적으로 작동하는 접미사를 찾아낼 수 있습니다.

두 번째 방어 시도: 입력 의존적 노이즈 (PRNG)

다음 아이디어는 다음과 같습니다: 만약 시프트 (shift)가 입력 자체에 의존한다면 어떨까요?

seed = hash(input_tokens)
rng = random.default_rng(seed)
shift = rng.uniform(-0.1, 0.1, size=model.weights.shape)
...

이제 서로 다른 텍스트를 가진 각 요청은 서로 다른 시프트를 갖게 됩니다. 입력_A에 최적화된 접미사는 모델 가중치가 완전히 다르기 때문에 입력_B에서는 작동하지 않을 것입니다.

실제로 이는 효과가 있습니다. TinyLlama-1.1B 모델에서 테스트했을 때:

• 기본 모델 (Base model): 20% ASR (10개의 접미사 중 2개의 정렬이 손상됨)
• 입력 의존적 시프트 (With input-dependent shift) 적용 시: 0% ASR (접미사 전이 없음)

완벽합니다! 단 한 가지 예외가 있다면, 클라이언트가 서버가 실제로 시프트를 적용했는지 어떻게 검증하느냐는 것입니다.

정답은: 검증할 수 없다는 것입니다.

클라이언트는 요청을 보내고 응답을 받습니다. 서버가 보호되지 않은 모델로부터 단순히 결과를 반환한 것인지, 아니면 실제로 시프트를 적용한 것인지 어떻게 알 수 있을까요? 양측 모두 입력 해시 (input hash)를 알고 있습니다. 양측 모두 결정론적 (deterministically)으로 동일한 시프트를 계산할 수 있습니다. 하지만 서버는 적용하지 않았음에도 불구하고 단순히 "네, 시프트를 적용했습니다!"라고 거짓말을 할 수 있습니다.

이것이 바로 신뢰 문제 (trust problem)입니다. 그리고 돈이 걸려 있는 시나리오(예: 트레이딩 봇)에서는 신뢰에 의존할 수 없습니다.

해결책: VRF 및 암호학적 증명 (cryptographic proof)

VRF는 검증 가능한 랜덤 함수 (Verifiable Random Function)의 약자입니다. 이는 증명을 동반한 의사 난수 생성기 (PRNG)입니다.

기술적 작동 방식:

1. LoRA 어댑터는 고정된 시드 (fixed seed)로 초기화됩니다 — 무작위 가중치가 아니라 결정론적으로 초기화됩니다. 이를 통해 CA는 나중에 정확히 동일한 어댑터를 재현할 수 있습니다.

2. 각 요청에 대해, 서버는 input_tokens를 기반으로 VRF를 통해 난수 (gamma)를 생성합니다.

3. 추론 (inference) 전, 모델 가중치에 VRF 시프트가 적용됩니다.

4. 온도 (Temperature) 파라미터가 텍스트 생성 중 가변성을 제어합니다 (일반적으로 안정성을 위해 낮게 설정됨).

핵심 아이디어는 이렇습니다: 서버는 결정론적인 가중치 시프트를 적용하되, 이 숫자가 자신의 개인키 (private key)를 사용하여 진정으로 생성되었음을 입증하는 암호학적 증명을 보냅니다.

클라이언트는 결과와 증명을 받습니다. 서버의 공개키 (public key)를 사용하여 다음을 확인합니다: 서버가 이 gamma를 생성하기 위해 실제로 자신의 개인키를 사용했는가? 이 확인 작업은 약 0.4밀리초가 소요되며 매번 실행됩니다.

Server:
  sk = SigningKey.generate()  # 개인키 (비밀키)
  gamma, proof = vrf_prove(sk, input_tokens)
...

이것이 첫 번째 방어선입니다. 하지만 이것만으로는 충분하지 않습니다. VRF는 서버가 올바른 키를 사용했고 gamma를 올바르게 계산했음을 증명합니다. 하지만 서버가 실제로 이 gamma를 가중치에 적용했는지, 또는 출력된 로짓 (logits)이 정직한지는 증명하지 못합니다.

두 번째 계층으로 들어갑니다.

계층 2: 인증 기관 (Certificate Authority) 감사

인증 기관 (Certificate Authority, CA)은 신뢰할 수 있는 당사자에 의해 제어되는 동일한 모델의 또 다른 인스턴스일 뿐입니다. 검증 흐름은 다음과 같이 작동합니다:

1️⃣ 클라이언트 요청 전송
   ┌────────────────────────────┐
   │ 클라이언트: input_tokens       │
...

CA는 VRF 증명과 함께 서버의 출력을 수신하고, 동일한 계산을 독립적으로 재계산하여 비교합니다.

만약 서버가 정직하게 시프트 (shift)를 적용했다면, 로짓 (logits)은 거의 완벽하게 일치합니다 (코사인 유사도 (cosine similarity) ≈ 1.0). 만약 서버가 시프트를 조작하거나 건너뛰었다면, 코사인 유사도는 0.004로 떨어지며 이는 즉각적으로 드러납니다.

이것이 왜 작동할까요? 접미사 (suffixes)는 서로 다른 가중치 행렬 (weight matrices) 사이에서 전이되지 않기 때문입니다. 공격자가 감사가 수행된다는 사실을 알고 있더라도, 베이스 모델 (base model)과 시프트된 버전 (shifted version) 모두에서 작동하는 접미사를 생성할 수는 없습니다. 이들은 수학적으로 서로 다른 모델입니다.

수학적 결과는 냉혹합니다: p=1% 샘플링 시, 1,000번의 부정 시도 후 탐지 확률은 99.99%에 달합니다. 경제적으로 볼 때, 속임수는 이득이 되지 않습니다.

수치 데이터

공격 성공률 (Attack Success Rate, ASR):

• 베이스 모델 (Base model): 20%
• VRF+LoRA 적용 시: 0%

단 하나의 접미사도 방어된 버전으로 전이되지 않습니다.

모델 품질 (Model quality):

• 기준 퍼플렉서티 (Baseline perplexity, GPT-2): 48.86
• VRF 적용 시 (shift_scale=0.1): 49.74
• 차이: +0.88 (+1.8%)

노이즈 범위 내에 있습니다. 모델은 동일하게 작동합니다.

CA 처리량 (CA throughput):
TinyLlama-1.1B (Apple M-series) 기준, 시간의 98%는 모델 추론 (inference)에 소요됩니다. 암호화 연산 (Crypto operations)은 2% 미만을 차지합니다. 하나의 CA 인스턴스는 p=1%에서 약 3,900명의 클라이언트를 보호할 수 있습니다.

만약 공격자가 감사를 회피하려고 시도한다면? 수학적으로, CA가 요청당 1%의 확률로 검사한다면, 1,000번의 부정 시도 후 적발될 확률은 99.99%입니다. 경제적으로, 이는 이득이 되지 않습니다.

이것이 중요한 이유

오픈 소스 LLM 모델은 저렴하고 유연하며 제어권을 제공한다는 점에서 엄청난 가치를 지닙니다. 하지만 이는 그래디언트 기반 적대적 공격 (gradient-based adversarial attacks) 스타일의 공격에 대한 구조적 취약성을 만들어냅니다.

우리의 솔루션은 계층적입니다:

1. VRF는 암호학적으로 검증 가능한 무작위 가중치 이동 (random weight shift)을 생성합니다.
2. 클라이언트는 서버가 올바른 키를 사용했는지 항상 검증합니다.
3. CA(인증 기관)는 출력 로짓 (output logits)을 무작위로 점검합니다.

결과: ASR (공격 성공률)이 20%에서 0%로 감소하며, 모델 품질은 거의 저하되지 않고, 처리량 (throughput)은 수용 가능한 수준을 유지합니다.

이것이 만능 해결책 (silver bullet)은 아닙니다. 하지만 LLM 봇이 제3자에 의해 배포되고 공개 콘텐츠를 읽는 개방형 생태계(open ecosystems)에서는 측정 가능하고 암호학적으로 검증 가능한 방어책입니다.