2019-05-24 16:21:42 -07:00
|
|
|
pub mod alloc;
|
|
|
|
pub mod allocator_bump;
|
2018-10-16 16:33:31 -07:00
|
|
|
pub mod bpf_verifier;
|
2020-08-11 16:11:52 -07:00
|
|
|
pub mod deprecated;
|
|
|
|
pub mod serialization;
|
2020-04-30 01:43:11 -07:00
|
|
|
pub mod syscalls;
|
2018-10-16 16:33:31 -07:00
|
|
|
|
2020-08-11 16:11:52 -07:00
|
|
|
use crate::{
|
|
|
|
bpf_verifier::VerifierError,
|
|
|
|
serialization::{deserialize_parameters, serialize_parameters},
|
|
|
|
syscalls::SyscallError,
|
|
|
|
};
|
2020-02-14 13:59:03 -08:00
|
|
|
use num_derive::{FromPrimitive, ToPrimitive};
|
2020-03-26 14:00:26 -07:00
|
|
|
use solana_rbpf::{
|
2020-09-14 17:42:37 -07:00
|
|
|
error::{EbpfError, UserDefinedError},
|
2020-03-26 14:00:26 -07:00
|
|
|
memory_region::MemoryRegion,
|
2020-10-09 13:07:09 -07:00
|
|
|
vm::{Config, EbpfVm, Executable, InstructionMeter},
|
2020-03-26 14:00:26 -07:00
|
|
|
};
|
2020-09-29 14:36:30 -07:00
|
|
|
use solana_runtime::{
|
2020-10-09 10:33:12 -07:00
|
|
|
feature_set::compute_budget_balancing,
|
2020-09-29 14:36:30 -07:00
|
|
|
process_instruction::{ComputeMeter, Executor, InvokeContext},
|
|
|
|
};
|
2020-01-02 18:18:56 -08:00
|
|
|
use solana_sdk::{
|
2020-06-17 10:39:14 -07:00
|
|
|
account::{is_executable, next_keyed_account, KeyedAccount},
|
2020-08-11 16:11:52 -07:00
|
|
|
bpf_loader, bpf_loader_deprecated,
|
2020-06-17 10:39:14 -07:00
|
|
|
decode_error::DecodeError,
|
2020-01-31 10:58:07 -08:00
|
|
|
entrypoint::SUCCESS,
|
2020-01-02 18:18:56 -08:00
|
|
|
instruction::InstructionError,
|
|
|
|
loader_instruction::LoaderInstruction,
|
2020-06-17 10:39:14 -07:00
|
|
|
program_utils::limited_deserialize,
|
2020-01-02 18:18:56 -08:00
|
|
|
pubkey::Pubkey,
|
|
|
|
};
|
2020-09-14 17:42:37 -07:00
|
|
|
use std::{cell::RefCell, rc::Rc, sync::Arc};
|
2020-02-14 13:59:03 -08:00
|
|
|
use thiserror::Error;
|
2019-05-24 16:21:42 -07:00
|
|
|
|
2020-08-14 12:32:45 -07:00
|
|
|
solana_sdk::declare_builtin!(
|
2019-12-03 17:55:18 -08:00
|
|
|
solana_sdk::bpf_loader::ID,
|
2019-11-20 16:32:19 -08:00
|
|
|
solana_bpf_loader_program,
|
2020-08-14 12:32:45 -07:00
|
|
|
solana_bpf_loader_program::process_instruction
|
2019-11-20 16:32:19 -08:00
|
|
|
);
|
|
|
|
|
2020-09-14 17:42:37 -07:00
|
|
|
/// Errors returned by the BPFLoader if the VM fails to run the program
|
2020-02-14 13:59:03 -08:00
|
|
|
#[derive(Error, Debug, Clone, PartialEq, FromPrimitive, ToPrimitive)]
|
|
|
|
pub enum BPFLoaderError {
|
2020-03-26 14:00:26 -07:00
|
|
|
#[error("failed to create virtual machine")]
|
|
|
|
VirtualMachineCreationFailed = 0x0b9f_0001,
|
|
|
|
#[error("virtual machine failed to run the program to completion")]
|
|
|
|
VirtualMachineFailedToRunProgram = 0x0b9f_0002,
|
2020-02-14 13:59:03 -08:00
|
|
|
}
|
|
|
|
impl<E> DecodeError<E> for BPFLoaderError {
|
|
|
|
fn type_of() -> &'static str {
|
|
|
|
"BPFLoaderError"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-14 17:42:37 -07:00
|
|
|
/// Errors returned by functions the BPF Loader registers with the VM
|
2020-08-26 14:48:51 -07:00
|
|
|
#[derive(Debug, Error, PartialEq)]
|
2020-03-26 14:00:26 -07:00
|
|
|
pub enum BPFError {
|
|
|
|
#[error("{0}")]
|
|
|
|
VerifierError(#[from] VerifierError),
|
|
|
|
#[error("{0}")]
|
2020-04-30 01:43:11 -07:00
|
|
|
SyscallError(#[from] SyscallError),
|
2020-03-26 14:00:26 -07:00
|
|
|
}
|
|
|
|
impl UserDefinedError for BPFError {}
|
|
|
|
|
2020-09-14 17:42:37 -07:00
|
|
|
/// Point all log messages to the log collector
|
2020-06-13 13:20:08 -07:00
|
|
|
macro_rules! log{
|
|
|
|
($logger:ident, $message:expr) => {
|
|
|
|
if let Ok(mut logger) = $logger.try_borrow_mut() {
|
|
|
|
if logger.log_enabled() {
|
|
|
|
logger.log($message);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
($logger:ident, $fmt:expr, $($arg:tt)*) => {
|
|
|
|
if let Ok(mut logger) = $logger.try_borrow_mut() {
|
2020-09-14 17:42:37 -07:00
|
|
|
if logger.log_enabled() {
|
|
|
|
logger.log(&format!($fmt, $($arg)*));
|
|
|
|
}
|
2020-06-13 13:20:08 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-09-29 14:36:30 -07:00
|
|
|
fn map_ebpf_error(
|
|
|
|
invoke_context: &mut dyn InvokeContext,
|
|
|
|
e: EbpfError<BPFError>,
|
|
|
|
) -> InstructionError {
|
|
|
|
let logger = invoke_context.get_logger();
|
|
|
|
log!(logger, "{}", e);
|
|
|
|
InstructionError::InvalidAccountData
|
|
|
|
}
|
|
|
|
|
2020-09-14 17:42:37 -07:00
|
|
|
pub fn create_and_cache_executor(
|
|
|
|
program: &KeyedAccount,
|
|
|
|
invoke_context: &mut dyn InvokeContext,
|
|
|
|
) -> Result<Arc<BPFExecutor>, InstructionError> {
|
2020-09-29 14:36:30 -07:00
|
|
|
let executable = EbpfVm::create_executable_from_elf(&program.try_account_ref()?.data, None)
|
|
|
|
.map_err(|e| map_ebpf_error(invoke_context, e))?;
|
|
|
|
let (_, elf_bytes) = executable
|
|
|
|
.get_text_bytes()
|
|
|
|
.map_err(|e| map_ebpf_error(invoke_context, e))?;
|
|
|
|
bpf_verifier::check(
|
|
|
|
elf_bytes,
|
2020-10-09 10:33:12 -07:00
|
|
|
!invoke_context.is_feature_active(&compute_budget_balancing::id()),
|
2020-09-14 17:42:37 -07:00
|
|
|
)
|
2020-09-29 14:36:30 -07:00
|
|
|
.map_err(|e| map_ebpf_error(invoke_context, EbpfError::UserError(e)))?;
|
2020-09-14 17:42:37 -07:00
|
|
|
let executor = Arc::new(BPFExecutor { executable });
|
|
|
|
invoke_context.add_executor(program.unsigned_key(), executor.clone());
|
|
|
|
Ok(executor)
|
2020-08-21 15:31:19 -07:00
|
|
|
}
|
2020-09-14 17:42:37 -07:00
|
|
|
|
|
|
|
/// Create the BPF virtual machine
|
|
|
|
pub fn create_vm<'a>(
|
|
|
|
loader_id: &'a Pubkey,
|
|
|
|
executable: &'a dyn Executable<BPFError>,
|
|
|
|
parameter_accounts: &'a [KeyedAccount<'a>],
|
|
|
|
invoke_context: &'a mut dyn InvokeContext,
|
|
|
|
) -> Result<(EbpfVm<'a, BPFError>, MemoryRegion), EbpfError<BPFError>> {
|
2020-10-09 13:07:09 -07:00
|
|
|
let compute_budget = invoke_context.get_compute_budget();
|
|
|
|
let mut vm = EbpfVm::new(
|
|
|
|
executable,
|
|
|
|
Config {
|
|
|
|
max_call_depth: compute_budget.max_call_depth,
|
|
|
|
stack_frame_size: compute_budget.stack_frame_size,
|
|
|
|
},
|
|
|
|
)?;
|
2020-09-14 17:42:37 -07:00
|
|
|
let heap_region =
|
|
|
|
syscalls::register_syscalls(loader_id, &mut vm, parameter_accounts, invoke_context)?;
|
|
|
|
Ok((vm, heap_region))
|
2020-08-21 15:31:19 -07:00
|
|
|
}
|
|
|
|
|
2019-06-12 08:49:59 -07:00
|
|
|
pub fn process_instruction(
|
2018-11-17 17:02:14 -08:00
|
|
|
program_id: &Pubkey,
|
2020-01-22 17:54:06 -08:00
|
|
|
keyed_accounts: &[KeyedAccount],
|
2020-01-10 13:20:15 -08:00
|
|
|
instruction_data: &[u8],
|
2020-04-28 14:33:56 -07:00
|
|
|
invoke_context: &mut dyn InvokeContext,
|
2019-03-18 09:05:03 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2020-08-11 16:11:52 -07:00
|
|
|
debug_assert!(bpf_loader::check_id(program_id) || bpf_loader_deprecated::check_id(program_id));
|
2020-03-05 10:57:35 -08:00
|
|
|
|
2020-06-13 13:20:08 -07:00
|
|
|
let logger = invoke_context.get_logger();
|
|
|
|
|
2020-01-10 13:20:15 -08:00
|
|
|
if keyed_accounts.is_empty() {
|
2020-06-13 13:20:08 -07:00
|
|
|
log!(logger, "No account keys");
|
2020-01-10 13:20:15 -08:00
|
|
|
return Err(InstructionError::NotEnoughAccountKeys);
|
|
|
|
}
|
2020-09-14 17:42:37 -07:00
|
|
|
let program = &keyed_accounts[0];
|
2020-01-10 13:20:15 -08:00
|
|
|
|
2020-01-22 09:11:56 -08:00
|
|
|
if is_executable(keyed_accounts)? {
|
2020-09-14 17:42:37 -07:00
|
|
|
let executor = match invoke_context.get_executor(program.unsigned_key()) {
|
|
|
|
Some(executor) => executor,
|
|
|
|
None => create_and_cache_executor(program, invoke_context)?,
|
|
|
|
};
|
|
|
|
executor.execute(program_id, keyed_accounts, instruction_data, invoke_context)?
|
|
|
|
} else if !keyed_accounts.is_empty() {
|
|
|
|
match limited_deserialize(instruction_data)? {
|
|
|
|
LoaderInstruction::Write { offset, bytes } => {
|
|
|
|
if program.signer_key().is_none() {
|
|
|
|
log!(logger, "key[0] did not sign the transaction");
|
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
|
|
|
}
|
|
|
|
let offset = offset as usize;
|
|
|
|
let len = bytes.len();
|
|
|
|
if program.data_len()? < offset + len {
|
|
|
|
log!(
|
|
|
|
logger,
|
|
|
|
"Write overflow: {} < {}",
|
|
|
|
program.data_len()?,
|
|
|
|
offset + len
|
|
|
|
);
|
|
|
|
return Err(InstructionError::AccountDataTooSmall);
|
|
|
|
}
|
|
|
|
program.try_account_ref_mut()?.data[offset..offset + len].copy_from_slice(&bytes);
|
|
|
|
}
|
|
|
|
LoaderInstruction::Finalize => {
|
|
|
|
if program.signer_key().is_none() {
|
|
|
|
log!(logger, "key[0] did not sign the transaction");
|
|
|
|
return Err(InstructionError::MissingRequiredSignature);
|
|
|
|
}
|
|
|
|
|
|
|
|
let _ = create_and_cache_executor(program, invoke_context)?;
|
|
|
|
program.try_account_ref_mut()?.executable = true;
|
|
|
|
log!(
|
|
|
|
logger,
|
|
|
|
"Finalized account {:?}",
|
|
|
|
program.signer_key().unwrap()
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Passed to the VM to enforce the compute budget
|
|
|
|
struct ThisInstructionMeter {
|
|
|
|
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
|
|
|
}
|
2020-10-15 15:55:37 -07:00
|
|
|
impl ThisInstructionMeter {
|
|
|
|
fn new(compute_meter: Rc<RefCell<dyn ComputeMeter>>) -> Self {
|
|
|
|
Self { compute_meter }
|
|
|
|
}
|
|
|
|
}
|
2020-09-14 17:42:37 -07:00
|
|
|
impl InstructionMeter for ThisInstructionMeter {
|
|
|
|
fn consume(&mut self, amount: u64) {
|
|
|
|
// 1 to 1 instruction to compute unit mapping
|
|
|
|
// ignore error, Ebpf will bail if exceeded
|
|
|
|
let _ = self.compute_meter.borrow_mut().consume(amount);
|
|
|
|
}
|
|
|
|
fn get_remaining(&self) -> u64 {
|
|
|
|
self.compute_meter.borrow().get_remaining()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// BPF Loader's Executor implementation
|
|
|
|
pub struct BPFExecutor {
|
|
|
|
executable: Box<dyn Executable<BPFError>>,
|
|
|
|
}
|
|
|
|
impl Executor for BPFExecutor {
|
|
|
|
fn execute(
|
|
|
|
&self,
|
|
|
|
program_id: &Pubkey,
|
|
|
|
keyed_accounts: &[KeyedAccount],
|
|
|
|
instruction_data: &[u8],
|
|
|
|
invoke_context: &mut dyn InvokeContext,
|
|
|
|
) -> Result<(), InstructionError> {
|
|
|
|
let logger = invoke_context.get_logger();
|
|
|
|
|
2020-01-22 17:54:06 -08:00
|
|
|
let mut keyed_accounts_iter = keyed_accounts.iter();
|
2020-01-10 13:20:15 -08:00
|
|
|
let program = next_keyed_account(&mut keyed_accounts_iter)?;
|
2020-03-17 12:06:15 -07:00
|
|
|
|
2020-01-22 17:54:06 -08:00
|
|
|
let parameter_accounts = keyed_accounts_iter.as_slice();
|
2020-03-05 10:57:35 -08:00
|
|
|
let parameter_bytes = serialize_parameters(
|
2020-08-11 16:11:52 -07:00
|
|
|
program_id,
|
2020-03-05 10:57:35 -08:00
|
|
|
program.unsigned_key(),
|
|
|
|
parameter_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
)?;
|
2020-03-17 12:06:15 -07:00
|
|
|
{
|
2020-08-21 15:31:19 -07:00
|
|
|
let compute_meter = invoke_context.get_compute_meter();
|
2020-08-24 13:21:34 -07:00
|
|
|
let (mut vm, heap_region) = match create_vm(
|
|
|
|
program_id,
|
2020-09-14 17:42:37 -07:00
|
|
|
self.executable.as_ref(),
|
2020-08-24 13:21:34 -07:00
|
|
|
¶meter_accounts,
|
|
|
|
invoke_context,
|
|
|
|
) {
|
|
|
|
Ok(info) => info,
|
|
|
|
Err(e) => {
|
|
|
|
log!(logger, "Failed to create BPF VM: {}", e);
|
|
|
|
return Err(BPFLoaderError::VirtualMachineCreationFailed.into());
|
|
|
|
}
|
|
|
|
};
|
2020-03-17 12:06:15 -07:00
|
|
|
|
2020-06-13 13:20:08 -07:00
|
|
|
log!(logger, "Call BPF program {}", program.unsigned_key());
|
2020-10-15 15:55:37 -07:00
|
|
|
let instruction_meter = ThisInstructionMeter::new(compute_meter.clone());
|
|
|
|
let before = compute_meter.borrow().get_remaining();
|
|
|
|
let result = vm.execute_program_metered(
|
2020-08-21 15:31:19 -07:00
|
|
|
parameter_bytes.as_slice(),
|
|
|
|
&[],
|
|
|
|
&[heap_region],
|
|
|
|
instruction_meter,
|
2020-10-15 15:55:37 -07:00
|
|
|
);
|
|
|
|
let after = compute_meter.borrow().get_remaining();
|
|
|
|
log!(
|
|
|
|
logger,
|
|
|
|
"BPF program consumed {} of {} units",
|
|
|
|
before - after,
|
|
|
|
before
|
|
|
|
);
|
|
|
|
match result {
|
2020-03-17 12:06:15 -07:00
|
|
|
Ok(status) => {
|
|
|
|
if status != SUCCESS {
|
|
|
|
let error: InstructionError = status.into();
|
2020-06-13 13:20:08 -07:00
|
|
|
log!(
|
|
|
|
logger,
|
|
|
|
"BPF program {} failed: {}",
|
|
|
|
program.unsigned_key(),
|
|
|
|
error
|
|
|
|
);
|
2020-03-17 12:06:15 -07:00
|
|
|
return Err(error);
|
|
|
|
}
|
|
|
|
}
|
2020-03-26 14:00:26 -07:00
|
|
|
Err(error) => {
|
2020-06-13 13:20:08 -07:00
|
|
|
log!(
|
|
|
|
logger,
|
|
|
|
"BPF program {} failed: {}",
|
|
|
|
program.unsigned_key(),
|
|
|
|
error
|
|
|
|
);
|
2020-03-26 14:00:26 -07:00
|
|
|
return match error {
|
2020-04-30 01:43:11 -07:00
|
|
|
EbpfError::UserError(BPFError::SyscallError(
|
|
|
|
SyscallError::InstructionError(error),
|
2020-03-26 14:00:26 -07:00
|
|
|
)) => Err(error),
|
|
|
|
_ => Err(BPFLoaderError::VirtualMachineFailedToRunProgram.into()),
|
|
|
|
};
|
2020-01-10 13:20:15 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-08-11 16:11:52 -07:00
|
|
|
deserialize_parameters(program_id, parameter_accounts, ¶meter_bytes)?;
|
2020-06-13 13:20:08 -07:00
|
|
|
log!(logger, "BPF program {} success", program.unsigned_key());
|
2020-09-14 17:42:37 -07:00
|
|
|
Ok(())
|
2018-10-16 09:43:49 -07:00
|
|
|
}
|
|
|
|
}
|
2018-10-31 10:59:56 -07:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2020-05-08 12:37:04 -07:00
|
|
|
use rand::Rng;
|
2020-09-29 01:36:46 -07:00
|
|
|
use solana_runtime::{
|
2020-09-29 14:36:30 -07:00
|
|
|
feature_set::FeatureSet,
|
2020-09-29 01:36:46 -07:00
|
|
|
message_processor::{Executors, ThisInvokeContext},
|
|
|
|
process_instruction::{ComputeBudget, Logger, ProcessInstruction},
|
|
|
|
};
|
2020-04-28 14:33:56 -07:00
|
|
|
use solana_sdk::{
|
2020-09-29 01:36:46 -07:00
|
|
|
account::Account, instruction::CompiledInstruction, instruction::Instruction,
|
|
|
|
message::Message, rent::Rent,
|
2020-04-28 14:33:56 -07:00
|
|
|
};
|
2020-05-08 12:37:04 -07:00
|
|
|
use std::{cell::RefCell, fs::File, io::Read, ops::Range, rc::Rc};
|
2020-04-28 14:33:56 -07:00
|
|
|
|
2020-08-21 15:31:19 -07:00
|
|
|
#[derive(Debug, Default, Clone)]
|
|
|
|
pub struct MockComputeMeter {
|
|
|
|
pub remaining: u64,
|
|
|
|
}
|
|
|
|
impl ComputeMeter for MockComputeMeter {
|
|
|
|
fn consume(&mut self, amount: u64) -> Result<(), InstructionError> {
|
2020-09-25 11:08:10 -07:00
|
|
|
let exceeded = self.remaining < amount;
|
2020-08-21 15:31:19 -07:00
|
|
|
self.remaining = self.remaining.saturating_sub(amount);
|
2020-09-25 11:08:10 -07:00
|
|
|
if exceeded {
|
2020-08-21 15:31:19 -07:00
|
|
|
return Err(InstructionError::ComputationalBudgetExceeded);
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
fn get_remaining(&self) -> u64 {
|
|
|
|
self.remaining
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#[derive(Debug, Default, Clone)]
|
|
|
|
pub struct MockLogger {
|
|
|
|
pub log: Rc<RefCell<Vec<String>>>,
|
|
|
|
}
|
|
|
|
impl Logger for MockLogger {
|
|
|
|
fn log_enabled(&self) -> bool {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
fn log(&mut self, message: &str) {
|
|
|
|
self.log.borrow_mut().push(message.to_string());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#[derive(Debug)]
|
2020-05-08 12:24:36 -07:00
|
|
|
pub struct MockInvokeContext {
|
2020-08-21 15:31:19 -07:00
|
|
|
pub key: Pubkey,
|
|
|
|
pub logger: MockLogger,
|
2020-09-29 14:36:30 -07:00
|
|
|
pub compute_budget: ComputeBudget,
|
2020-08-21 15:31:19 -07:00
|
|
|
pub compute_meter: MockComputeMeter,
|
|
|
|
}
|
|
|
|
impl Default for MockInvokeContext {
|
|
|
|
fn default() -> Self {
|
|
|
|
MockInvokeContext {
|
|
|
|
key: Pubkey::default(),
|
|
|
|
logger: MockLogger::default(),
|
2020-09-29 14:36:30 -07:00
|
|
|
compute_budget: ComputeBudget::default(),
|
2020-08-21 15:31:19 -07:00
|
|
|
compute_meter: MockComputeMeter {
|
|
|
|
remaining: std::u64::MAX,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
2020-05-08 12:24:36 -07:00
|
|
|
}
|
2020-04-28 14:33:56 -07:00
|
|
|
impl InvokeContext for MockInvokeContext {
|
|
|
|
fn push(&mut self, _key: &Pubkey) -> Result<(), InstructionError> {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
fn pop(&mut self) {}
|
|
|
|
fn verify_and_update(
|
|
|
|
&mut self,
|
|
|
|
_message: &Message,
|
|
|
|
_instruction: &CompiledInstruction,
|
|
|
|
_accounts: &[Rc<RefCell<Account>>],
|
|
|
|
) -> Result<(), InstructionError> {
|
|
|
|
Ok(())
|
|
|
|
}
|
2020-05-08 12:24:36 -07:00
|
|
|
fn get_caller(&self) -> Result<&Pubkey, InstructionError> {
|
|
|
|
Ok(&self.key)
|
|
|
|
}
|
2020-06-03 12:48:19 -07:00
|
|
|
fn get_programs(&self) -> &[(Pubkey, ProcessInstruction)] {
|
|
|
|
&[]
|
|
|
|
}
|
2020-06-13 13:20:08 -07:00
|
|
|
fn get_logger(&self) -> Rc<RefCell<dyn Logger>> {
|
2020-08-21 15:31:19 -07:00
|
|
|
Rc::new(RefCell::new(self.logger.clone()))
|
2020-06-13 13:20:08 -07:00
|
|
|
}
|
2020-09-29 14:36:30 -07:00
|
|
|
fn get_compute_budget(&self) -> &ComputeBudget {
|
|
|
|
&self.compute_budget
|
2020-08-26 14:48:51 -07:00
|
|
|
}
|
2020-08-21 15:31:19 -07:00
|
|
|
fn get_compute_meter(&self) -> Rc<RefCell<dyn ComputeMeter>> {
|
|
|
|
Rc::new(RefCell::new(self.compute_meter.clone()))
|
|
|
|
}
|
2020-09-14 17:42:37 -07:00
|
|
|
fn add_executor(&mut self, _pubkey: &Pubkey, _executor: Arc<dyn Executor>) {}
|
|
|
|
fn get_executor(&mut self, _pubkey: &Pubkey) -> Option<Arc<dyn Executor>> {
|
|
|
|
None
|
|
|
|
}
|
2020-09-24 07:36:22 -07:00
|
|
|
fn record_instruction(&self, _instruction: &Instruction) {}
|
2020-09-29 14:36:30 -07:00
|
|
|
fn is_feature_active(&self, _feature_id: &Pubkey) -> bool {
|
|
|
|
true
|
|
|
|
}
|
2020-06-13 13:20:08 -07:00
|
|
|
}
|
2020-08-21 15:31:19 -07:00
|
|
|
|
|
|
|
struct TestInstructionMeter {
|
|
|
|
remaining: u64,
|
2020-06-13 13:20:08 -07:00
|
|
|
}
|
2020-08-21 15:31:19 -07:00
|
|
|
impl InstructionMeter for TestInstructionMeter {
|
|
|
|
fn consume(&mut self, amount: u64) {
|
|
|
|
self.remaining = self.remaining.saturating_sub(amount);
|
2020-06-06 10:18:28 -07:00
|
|
|
}
|
2020-08-21 15:31:19 -07:00
|
|
|
fn get_remaining(&self) -> u64 {
|
|
|
|
self.remaining
|
2020-06-06 10:18:28 -07:00
|
|
|
}
|
2020-04-28 14:33:56 -07:00
|
|
|
}
|
2018-11-06 14:28:46 -08:00
|
|
|
|
2018-10-31 10:59:56 -07:00
|
|
|
#[test]
|
2020-03-26 14:00:26 -07:00
|
|
|
#[should_panic(expected = "ExceededMaxInstructions(10)")]
|
2019-11-08 09:19:19 -08:00
|
|
|
fn test_bpf_loader_non_terminating_program() {
|
2018-10-31 10:59:56 -07:00
|
|
|
#[rustfmt::skip]
|
2019-11-08 09:19:19 -08:00
|
|
|
let program = &[
|
2019-02-22 16:27:19 -08:00
|
|
|
0x07, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // r6 + 1
|
|
|
|
0x05, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, // goto -2
|
2018-10-31 10:59:56 -07:00
|
|
|
0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // exit
|
|
|
|
];
|
|
|
|
let input = &mut [0x00];
|
2018-11-06 14:28:46 -08:00
|
|
|
|
2020-09-29 14:36:30 -07:00
|
|
|
let executable = EbpfVm::create_executable_from_text_bytes(program, None).unwrap();
|
2020-10-09 13:07:09 -07:00
|
|
|
let mut vm = EbpfVm::<BPFError>::new(executable.as_ref(), Config::default()).unwrap();
|
2020-08-21 15:31:19 -07:00
|
|
|
let instruction_meter = TestInstructionMeter { remaining: 10 };
|
|
|
|
vm.execute_program_metered(input, &[], &[], instruction_meter)
|
|
|
|
.unwrap();
|
2018-10-31 10:59:56 -07:00
|
|
|
}
|
2019-11-08 09:19:19 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_write() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
2020-01-22 17:54:06 -08:00
|
|
|
let program_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
let keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
2020-01-10 13:20:15 -08:00
|
|
|
let instruction_data = bincode::serialize(&LoaderInstruction::Write {
|
2019-11-08 09:19:19 -08:00
|
|
|
offset: 3,
|
|
|
|
bytes: vec![1, 2, 3],
|
|
|
|
})
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
// Case: Empty keyed accounts
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::NotEnoughAccountKeys),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
2020-05-15 09:35:43 -07:00
|
|
|
&[],
|
2020-04-28 14:33:56 -07:00
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Not signed
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::MissingRequiredSignature),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Write bytes to an offset
|
2020-07-10 13:02:55 -07:00
|
|
|
#[allow(unused_mut)]
|
2020-01-22 17:54:06 -08:00
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, true, &program_account)];
|
2020-01-22 09:11:56 -08:00
|
|
|
keyed_accounts[0].account.borrow_mut().data = vec![0; 6];
|
2019-11-08 09:19:19 -08:00
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
2020-01-22 09:11:56 -08:00
|
|
|
assert_eq!(
|
|
|
|
vec![0, 0, 0, 1, 2, 3],
|
|
|
|
keyed_accounts[0].account.borrow().data
|
|
|
|
);
|
2019-11-08 09:19:19 -08:00
|
|
|
|
|
|
|
// Case: Overflow
|
2020-07-10 13:02:55 -07:00
|
|
|
#[allow(unused_mut)]
|
2020-01-22 17:54:06 -08:00
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, true, &program_account)];
|
2020-01-22 09:11:56 -08:00
|
|
|
keyed_accounts[0].account.borrow_mut().data = vec![0; 5];
|
2019-11-08 09:19:19 -08:00
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::AccountDataTooSmall),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_finalize() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
2020-08-11 16:11:52 -07:00
|
|
|
let mut file = File::open("test_elfs/noop_aligned.so").expect("file open failed");
|
2019-12-04 12:03:29 -08:00
|
|
|
let mut elf = Vec::new();
|
2020-03-31 10:07:38 -07:00
|
|
|
let rent = Rent::default();
|
2019-12-04 12:03:29 -08:00
|
|
|
file.read_to_end(&mut elf).unwrap();
|
2020-01-22 17:54:06 -08:00
|
|
|
let program_account = Account::new_ref(rent.minimum_balance(elf.len()), 0, &program_id);
|
2020-01-22 09:11:56 -08:00
|
|
|
program_account.borrow_mut().data = elf;
|
2020-03-31 10:07:38 -07:00
|
|
|
let keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
2020-01-10 13:20:15 -08:00
|
|
|
let instruction_data = bincode::serialize(&LoaderInstruction::Finalize).unwrap();
|
2019-11-08 09:19:19 -08:00
|
|
|
|
|
|
|
// Case: Empty keyed accounts
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::NotEnoughAccountKeys),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
2020-05-15 09:35:43 -07:00
|
|
|
&[],
|
2020-04-28 14:33:56 -07:00
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Not signed
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::MissingRequiredSignature),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Finalize
|
2020-03-31 10:07:38 -07:00
|
|
|
let keyed_accounts = vec![KeyedAccount::new(&program_key, true, &program_account)];
|
2019-11-08 09:19:19 -08:00
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
2020-01-22 09:11:56 -08:00
|
|
|
assert!(keyed_accounts[0].account.borrow().executable);
|
|
|
|
|
|
|
|
program_account.borrow_mut().executable = false; // Un-finalize the account
|
2019-12-04 12:03:29 -08:00
|
|
|
|
|
|
|
// Case: Finalize
|
2020-01-22 09:11:56 -08:00
|
|
|
program_account.borrow_mut().data[0] = 0; // bad elf
|
2020-03-31 10:07:38 -07:00
|
|
|
let keyed_accounts = vec![KeyedAccount::new(&program_key, true, &program_account)];
|
2019-12-04 12:03:29 -08:00
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::InvalidAccountData),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&instruction_data,
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2019-12-04 12:03:29 -08:00
|
|
|
);
|
2019-11-08 09:19:19 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_invoke_main() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
|
|
|
|
// Create program account
|
2020-08-11 16:11:52 -07:00
|
|
|
let mut file = File::open("test_elfs/noop_aligned.so").expect("file open failed");
|
2019-11-08 09:19:19 -08:00
|
|
|
let mut elf = Vec::new();
|
|
|
|
file.read_to_end(&mut elf).unwrap();
|
2020-01-22 17:54:06 -08:00
|
|
|
let program_account = Account::new_ref(1, 0, &program_id);
|
2020-01-22 09:11:56 -08:00
|
|
|
program_account.borrow_mut().data = elf;
|
|
|
|
program_account.borrow_mut().executable = true;
|
2019-11-08 09:19:19 -08:00
|
|
|
|
2020-01-22 17:54:06 -08:00
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
2019-11-08 09:19:19 -08:00
|
|
|
|
2020-09-14 17:42:37 -07:00
|
|
|
let mut invoke_context = MockInvokeContext::default();
|
|
|
|
|
2019-11-08 09:19:19 -08:00
|
|
|
// Case: Empty keyed accounts
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::NotEnoughAccountKeys),
|
2020-09-14 17:42:37 -07:00
|
|
|
process_instruction(&bpf_loader::id(), &[], &[], &mut invoke_context)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Only a program account
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-09-14 17:42:37 -07:00
|
|
|
process_instruction(&bpf_loader::id(), &keyed_accounts, &[], &mut invoke_context)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
// Case: Account not executable
|
2020-01-22 09:11:56 -08:00
|
|
|
keyed_accounts[0].account.borrow_mut().executable = false;
|
2019-11-08 09:19:19 -08:00
|
|
|
assert_eq!(
|
2020-01-10 13:20:15 -08:00
|
|
|
Err(InstructionError::InvalidInstructionData),
|
2020-09-14 17:42:37 -07:00
|
|
|
process_instruction(&bpf_loader::id(), &keyed_accounts, &[], &mut invoke_context)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
2020-01-22 09:11:56 -08:00
|
|
|
keyed_accounts[0].account.borrow_mut().executable = true;
|
2019-11-08 09:19:19 -08:00
|
|
|
|
|
|
|
// Case: With program and parameter account
|
2020-01-22 17:54:06 -08:00
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&program_key, false, ¶meter_account));
|
2019-11-08 09:19:19 -08:00
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-09-14 17:42:37 -07:00
|
|
|
process_instruction(&bpf_loader::id(), &keyed_accounts, &[], &mut invoke_context)
|
2019-11-08 09:19:19 -08:00
|
|
|
);
|
2020-01-22 09:11:56 -08:00
|
|
|
|
2020-08-26 14:48:51 -07:00
|
|
|
// Case: limited budget
|
|
|
|
let program_id = Pubkey::default();
|
|
|
|
let mut invoke_context = ThisInvokeContext::new(
|
|
|
|
&program_id,
|
|
|
|
Rent::default(),
|
|
|
|
vec![],
|
|
|
|
vec![],
|
|
|
|
None,
|
|
|
|
ComputeBudget {
|
|
|
|
max_units: 1,
|
|
|
|
log_units: 100,
|
|
|
|
log_64_units: 100,
|
|
|
|
create_program_address_units: 1500,
|
|
|
|
invoke_units: 1000,
|
|
|
|
max_invoke_depth: 2,
|
2020-09-29 23:29:20 -07:00
|
|
|
sha256_base_cost: 85,
|
|
|
|
sha256_byte_cost: 1,
|
2020-10-09 13:07:09 -07:00
|
|
|
max_call_depth: 20,
|
|
|
|
stack_frame_size: 4096,
|
2020-10-15 09:11:54 -07:00
|
|
|
log_pubkey_units: 100,
|
2020-08-26 14:48:51 -07:00
|
|
|
},
|
2020-09-14 17:42:37 -07:00
|
|
|
Rc::new(RefCell::new(Executors::default())),
|
2020-09-24 07:36:22 -07:00
|
|
|
None,
|
2020-09-29 14:36:30 -07:00
|
|
|
Arc::new(FeatureSet::default()),
|
2020-08-26 14:48:51 -07:00
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
Err(InstructionError::Custom(194969602)),
|
|
|
|
process_instruction(&bpf_loader::id(), &keyed_accounts, &[], &mut invoke_context)
|
|
|
|
);
|
|
|
|
|
2020-01-22 09:11:56 -08:00
|
|
|
// Case: With duplicate accounts
|
|
|
|
let duplicate_key = Pubkey::new_rand();
|
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
2020-02-11 10:03:28 -08:00
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
2020-01-22 09:11:56 -08:00
|
|
|
keyed_accounts.push(KeyedAccount::new(&duplicate_key, false, ¶meter_account));
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&duplicate_key, false, ¶meter_account));
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
2020-04-28 14:33:56 -07:00
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
2020-05-15 09:35:43 -07:00
|
|
|
&[],
|
2020-04-28 14:33:56 -07:00
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
2020-01-22 09:11:56 -08:00
|
|
|
);
|
2019-11-08 09:19:19 -08:00
|
|
|
}
|
2020-05-08 12:37:04 -07:00
|
|
|
|
2020-08-11 16:11:52 -07:00
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_serialize_unaligned() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
|
|
|
|
// Create program account
|
|
|
|
let mut file = File::open("test_elfs/noop_unaligned.so").expect("file open failed");
|
|
|
|
let mut elf = Vec::new();
|
|
|
|
file.read_to_end(&mut elf).unwrap();
|
|
|
|
let program_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
program_account.borrow_mut().data = elf;
|
|
|
|
program_account.borrow_mut().executable = true;
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
|
|
|
|
|
|
|
// Case: With program and parameter account
|
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&program_key, false, ¶meter_account));
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
|
|
|
process_instruction(
|
|
|
|
&bpf_loader_deprecated::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&[],
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
// Case: With duplicate accounts
|
|
|
|
let duplicate_key = Pubkey::new_rand();
|
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&duplicate_key, false, ¶meter_account));
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&duplicate_key, false, ¶meter_account));
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
|
|
|
process_instruction(
|
|
|
|
&bpf_loader_deprecated::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&[],
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bpf_loader_serialize_aligned() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
|
|
|
|
// Create program account
|
|
|
|
let mut file = File::open("test_elfs/noop_aligned.so").expect("file open failed");
|
|
|
|
let mut elf = Vec::new();
|
|
|
|
file.read_to_end(&mut elf).unwrap();
|
|
|
|
let program_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
program_account.borrow_mut().data = elf;
|
|
|
|
program_account.borrow_mut().executable = true;
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
|
|
|
|
|
|
|
// Case: With program and parameter account
|
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&program_key, false, ¶meter_account));
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&[],
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
// Case: With duplicate accounts
|
|
|
|
let duplicate_key = Pubkey::new_rand();
|
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
let mut keyed_accounts = vec![KeyedAccount::new(&program_key, false, &program_account)];
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&duplicate_key, false, ¶meter_account));
|
|
|
|
keyed_accounts.push(KeyedAccount::new(&duplicate_key, false, ¶meter_account));
|
|
|
|
assert_eq!(
|
|
|
|
Ok(()),
|
|
|
|
process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
|
|
|
&[],
|
|
|
|
&mut MockInvokeContext::default()
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-05-08 12:37:04 -07:00
|
|
|
/// fuzzing utility function
|
|
|
|
fn fuzz<F>(
|
|
|
|
bytes: &[u8],
|
|
|
|
outer_iters: usize,
|
|
|
|
inner_iters: usize,
|
|
|
|
offset: Range<usize>,
|
|
|
|
value: Range<u8>,
|
|
|
|
work: F,
|
|
|
|
) where
|
|
|
|
F: Fn(&mut [u8]),
|
|
|
|
{
|
|
|
|
let mut rng = rand::thread_rng();
|
|
|
|
for _ in 0..outer_iters {
|
|
|
|
let mut mangled_bytes = bytes.to_vec();
|
|
|
|
for _ in 0..inner_iters {
|
|
|
|
let offset = rng.gen_range(offset.start, offset.end);
|
|
|
|
let value = rng.gen_range(value.start, value.end);
|
|
|
|
mangled_bytes[offset] = value;
|
|
|
|
work(&mut mangled_bytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[ignore]
|
|
|
|
fn test_fuzz() {
|
|
|
|
let program_id = Pubkey::new_rand();
|
|
|
|
let program_key = Pubkey::new_rand();
|
|
|
|
|
|
|
|
// Create program account
|
2020-08-11 16:11:52 -07:00
|
|
|
let mut file = File::open("test_elfs/noop_aligned.so").expect("file open failed");
|
2020-05-08 12:37:04 -07:00
|
|
|
let mut elf = Vec::new();
|
|
|
|
file.read_to_end(&mut elf).unwrap();
|
|
|
|
|
2020-06-13 13:20:08 -07:00
|
|
|
// Mangle the whole file
|
2020-05-08 12:37:04 -07:00
|
|
|
fuzz(
|
|
|
|
&elf,
|
|
|
|
1_000_000_000,
|
|
|
|
100,
|
|
|
|
0..elf.len(),
|
|
|
|
0..255,
|
|
|
|
|bytes: &mut [u8]| {
|
|
|
|
let program_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
program_account.borrow_mut().data = bytes.to_vec();
|
|
|
|
program_account.borrow_mut().executable = true;
|
|
|
|
|
|
|
|
let parameter_account = Account::new_ref(1, 0, &program_id);
|
|
|
|
let keyed_accounts = vec![
|
|
|
|
KeyedAccount::new(&program_key, false, &program_account),
|
|
|
|
KeyedAccount::new(&program_key, false, ¶meter_account),
|
|
|
|
];
|
|
|
|
|
|
|
|
let _result = process_instruction(
|
|
|
|
&bpf_loader::id(),
|
|
|
|
&keyed_accounts,
|
2020-05-15 09:35:43 -07:00
|
|
|
&[],
|
2020-05-08 12:37:04 -07:00
|
|
|
&mut MockInvokeContext::default(),
|
|
|
|
);
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
2018-10-31 10:59:56 -07:00
|
|
|
}
|