2019-03-03 09:12:36 -08:00
|
|
|
use crate::native_loader;
|
2019-04-02 07:36:10 -07:00
|
|
|
use crate::system_instruction_processor;
|
2019-05-30 21:31:35 -07:00
|
|
|
use serde::{Deserialize, Serialize};
|
2019-06-27 14:25:10 -07:00
|
|
|
use solana_sdk::account::{
|
|
|
|
create_keyed_credit_only_accounts, Account, KeyedAccount, LamportCredit,
|
|
|
|
};
|
2019-04-02 15:02:57 -07:00
|
|
|
use solana_sdk::instruction::{CompiledInstruction, InstructionError};
|
2019-04-23 17:25:03 -07:00
|
|
|
use solana_sdk::instruction_processor_utils;
|
2019-07-16 09:45:32 -07:00
|
|
|
use solana_sdk::loader_instruction::LoaderInstruction;
|
2019-03-29 09:05:06 -07:00
|
|
|
use solana_sdk::message::Message;
|
2019-02-18 22:26:22 -08:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
|
|
|
use solana_sdk::system_program;
|
2019-03-29 09:05:06 -07:00
|
|
|
use solana_sdk::transaction::TransactionError;
|
2019-04-23 17:25:03 -07:00
|
|
|
use std::collections::HashMap;
|
2019-07-16 09:45:32 -07:00
|
|
|
use std::io::Write;
|
2019-04-23 17:25:03 -07:00
|
|
|
use std::sync::RwLock;
|
|
|
|
|
|
|
|
#[cfg(unix)]
|
|
|
|
use libloading::os::unix::*;
|
|
|
|
#[cfg(windows)]
|
|
|
|
use libloading::os::windows::*;
|
2019-03-13 10:55:43 -07:00
|
|
|
|
2019-02-18 22:26:22 -08:00
|
|
|
/// Return true if the slice has any duplicate elements
|
|
|
|
pub fn has_duplicates<T: PartialEq>(xs: &[T]) -> bool {
|
|
|
|
// Note: This is an O(n^2) algorithm, but requires no heap allocations. The benchmark
|
2019-04-02 08:35:38 -07:00
|
|
|
// `bench_has_duplicates` in benches/message_processor.rs shows that this implementation is
|
2019-02-18 22:26:22 -08:00
|
|
|
// ~50 times faster than using HashSet for very short slices.
|
|
|
|
for i in 1..xs.len() {
|
|
|
|
if xs[i..].contains(&xs[i - 1]) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Get mut references to a subset of elements.
|
2019-03-19 17:52:02 -07:00
|
|
|
fn get_subset_unchecked_mut<'a, T>(
|
2019-03-14 14:32:12 -07:00
|
|
|
xs: &'a mut [T],
|
|
|
|
indexes: &[u8],
|
|
|
|
) -> Result<Vec<&'a mut T>, InstructionError> {
|
2019-02-18 22:26:22 -08:00
|
|
|
// Since the compiler doesn't know the indexes are unique, dereferencing
|
|
|
|
// multiple mut elements is assumed to be unsafe. If, however, all
|
|
|
|
// indexes are unique, it's perfectly safe. The returned elements will share
|
|
|
|
// the liftime of the input slice.
|
|
|
|
|
2019-03-14 14:32:12 -07:00
|
|
|
// Make certain there are no duplicate indexes. If there are, return an error
|
|
|
|
// because we can't return multiple mut references to the same element.
|
2019-02-18 22:26:22 -08:00
|
|
|
if has_duplicates(indexes) {
|
2019-03-14 14:32:12 -07:00
|
|
|
return Err(InstructionError::DuplicateAccountIndex);
|
2019-02-18 22:26:22 -08:00
|
|
|
}
|
|
|
|
|
2019-03-14 14:32:12 -07:00
|
|
|
Ok(indexes
|
2019-02-18 22:26:22 -08:00
|
|
|
.iter()
|
|
|
|
.map(|i| {
|
|
|
|
let ptr = &mut xs[*i as usize] as *mut T;
|
|
|
|
unsafe { &mut *ptr }
|
|
|
|
})
|
2019-03-14 14:32:12 -07:00
|
|
|
.collect())
|
2019-02-18 22:26:22 -08:00
|
|
|
}
|
|
|
|
|
2019-03-15 19:48:11 -07:00
|
|
|
fn verify_instruction(
|
2019-06-10 19:50:02 -07:00
|
|
|
is_debitable: bool,
|
2019-03-15 19:48:11 -07:00
|
|
|
program_id: &Pubkey,
|
2019-08-26 11:04:20 -07:00
|
|
|
pre: &Account,
|
|
|
|
post: &Account,
|
2019-03-15 19:48:11 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
|
|
|
// Verify the transaction
|
|
|
|
|
2019-07-29 15:29:20 -07:00
|
|
|
// Make sure that program_id is still the same or this was just assigned by the system program,
|
2019-10-16 10:47:45 -07:00
|
|
|
// but even the system program can't touch a credit-only account.
|
2019-08-26 11:04:20 -07:00
|
|
|
if pre.owner != post.owner && (!is_debitable || !system_program::check_id(&program_id)) {
|
2019-03-15 19:48:11 -07:00
|
|
|
return Err(InstructionError::ModifiedProgramId);
|
|
|
|
}
|
2019-10-19 18:23:27 -07:00
|
|
|
// An account not assigned to the program cannot have its balance decrease.
|
2019-08-26 11:04:20 -07:00
|
|
|
if *program_id != post.owner && pre.lamports > post.lamports {
|
2019-03-15 19:48:11 -07:00
|
|
|
return Err(InstructionError::ExternalAccountLamportSpend);
|
|
|
|
}
|
2019-10-16 10:47:45 -07:00
|
|
|
// The balance of credit-only accounts may only increase.
|
2019-08-26 11:04:20 -07:00
|
|
|
if !is_debitable && pre.lamports > post.lamports {
|
2019-06-10 19:50:02 -07:00
|
|
|
return Err(InstructionError::CreditOnlyLamportSpend);
|
|
|
|
}
|
2019-10-16 10:47:45 -07:00
|
|
|
// Only system accounts can change the size of the data.
|
|
|
|
if !system_program::check_id(&program_id) && pre.data.len() != post.data.len() {
|
|
|
|
return Err(InstructionError::AccountDataSizeChanged);
|
|
|
|
}
|
2019-03-15 19:48:11 -07:00
|
|
|
// For accounts unassigned to the program, the data may not change.
|
2019-08-26 11:04:20 -07:00
|
|
|
if *program_id != post.owner && !system_program::check_id(&program_id) && pre.data != post.data
|
2019-03-15 19:48:11 -07:00
|
|
|
{
|
|
|
|
return Err(InstructionError::ExternalAccountDataModified);
|
2019-02-18 22:26:22 -08:00
|
|
|
}
|
2019-06-10 19:50:02 -07:00
|
|
|
// Credit-only account data may not change.
|
2019-08-26 11:04:20 -07:00
|
|
|
if !is_debitable && pre.data != post.data {
|
2019-06-10 19:50:02 -07:00
|
|
|
return Err(InstructionError::CreditOnlyDataModified);
|
|
|
|
}
|
2019-07-29 15:29:20 -07:00
|
|
|
// executable is one-way (false->true) and
|
2019-10-16 10:47:45 -07:00
|
|
|
// only system or the account owner may modify.
|
2019-08-26 11:04:20 -07:00
|
|
|
if pre.executable != post.executable
|
2019-07-29 15:29:20 -07:00
|
|
|
&& (!is_debitable
|
2019-08-26 11:04:20 -07:00
|
|
|
|| pre.executable
|
|
|
|
|| *program_id != post.owner && !system_program::check_id(&program_id))
|
2019-07-29 15:29:20 -07:00
|
|
|
{
|
|
|
|
return Err(InstructionError::ExecutableModified);
|
|
|
|
}
|
2019-10-16 10:47:45 -07:00
|
|
|
// No one modifies rent_epoch (yet).
|
2019-08-26 11:04:20 -07:00
|
|
|
if pre.rent_epoch != post.rent_epoch {
|
|
|
|
return Err(InstructionError::RentEpochModified);
|
|
|
|
}
|
|
|
|
|
2019-02-18 22:26:22 -08:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2019-07-16 09:45:32 -07:00
|
|
|
/// Return instruction data to pass to process_instruction().
|
|
|
|
/// When a loader is detected, the instruction data is wrapped with a LoaderInstruction
|
|
|
|
/// to signal to the loader that the instruction data should be used as arguments when
|
|
|
|
/// invoking a "main()" function.
|
|
|
|
fn get_loader_instruction_data<'a>(
|
|
|
|
loaders: &[(Pubkey, Account)],
|
|
|
|
ix_data: &'a [u8],
|
|
|
|
loader_ix_data: &'a mut Vec<u8>,
|
|
|
|
) -> &'a [u8] {
|
|
|
|
if loaders.len() > 1 {
|
|
|
|
let ix = LoaderInstruction::InvokeMain {
|
|
|
|
data: ix_data.to_vec(),
|
|
|
|
};
|
|
|
|
let ix_data = bincode::serialize(&ix).unwrap();
|
|
|
|
loader_ix_data.write_all(&ix_data).unwrap();
|
|
|
|
loader_ix_data
|
|
|
|
} else {
|
|
|
|
ix_data
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-16 16:20:09 -07:00
|
|
|
pub type ProcessInstruction =
|
2019-05-31 15:29:21 -07:00
|
|
|
fn(&Pubkey, &mut [KeyedAccount], &[u8]) -> Result<(), InstructionError>;
|
2019-03-15 19:48:11 -07:00
|
|
|
|
2019-04-23 17:25:03 -07:00
|
|
|
pub type SymbolCache = RwLock<HashMap<Vec<u8>, Symbol<instruction_processor_utils::Entrypoint>>>;
|
|
|
|
|
2019-05-30 21:31:35 -07:00
|
|
|
#[derive(Serialize, Deserialize)]
|
2019-04-02 08:35:38 -07:00
|
|
|
pub struct MessageProcessor {
|
2019-05-30 21:31:35 -07:00
|
|
|
#[serde(skip)]
|
2019-03-16 16:20:09 -07:00
|
|
|
instruction_processors: Vec<(Pubkey, ProcessInstruction)>,
|
2019-05-30 21:31:35 -07:00
|
|
|
#[serde(skip)]
|
2019-04-23 17:25:03 -07:00
|
|
|
symbol_cache: SymbolCache,
|
2019-03-15 19:48:11 -07:00
|
|
|
}
|
|
|
|
|
2019-04-02 08:35:38 -07:00
|
|
|
impl Default for MessageProcessor {
|
2019-03-15 19:48:11 -07:00
|
|
|
fn default() -> Self {
|
2019-04-02 07:36:10 -07:00
|
|
|
let instruction_processors: Vec<(Pubkey, ProcessInstruction)> = vec![(
|
|
|
|
system_program::id(),
|
|
|
|
system_instruction_processor::process_instruction,
|
|
|
|
)];
|
2019-03-16 16:20:09 -07:00
|
|
|
|
|
|
|
Self {
|
|
|
|
instruction_processors,
|
2019-04-23 17:25:03 -07:00
|
|
|
symbol_cache: RwLock::new(HashMap::new()),
|
2019-03-16 16:20:09 -07:00
|
|
|
}
|
2019-03-15 19:48:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-02 08:35:38 -07:00
|
|
|
impl MessageProcessor {
|
2019-07-31 14:28:14 -07:00
|
|
|
/// Add a static entrypoint to intercept instructions before the dynamic loader.
|
2019-03-16 16:20:09 -07:00
|
|
|
pub fn add_instruction_processor(
|
|
|
|
&mut self,
|
|
|
|
program_id: Pubkey,
|
|
|
|
process_instruction: ProcessInstruction,
|
|
|
|
) {
|
|
|
|
self.instruction_processors
|
|
|
|
.push((program_id, process_instruction));
|
2019-03-07 12:42:01 -08:00
|
|
|
}
|
2019-03-15 19:48:11 -07:00
|
|
|
|
|
|
|
/// Process an instruction
|
|
|
|
/// This method calls the instruction's program entrypoint method
|
|
|
|
fn process_instruction(
|
|
|
|
&self,
|
2019-03-29 09:05:06 -07:00
|
|
|
message: &Message,
|
2019-04-02 15:02:57 -07:00
|
|
|
instruction: &CompiledInstruction,
|
2019-03-15 19:48:11 -07:00
|
|
|
executable_accounts: &mut [(Pubkey, Account)],
|
|
|
|
program_accounts: &mut [&mut Account],
|
2019-03-18 09:05:03 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2019-05-22 15:23:16 -07:00
|
|
|
let program_id = instruction.program_id(&message.account_keys);
|
2019-03-15 19:48:11 -07:00
|
|
|
|
2019-07-16 09:45:32 -07:00
|
|
|
let mut loader_ix_data = vec![];
|
|
|
|
let ix_data = get_loader_instruction_data(
|
|
|
|
executable_accounts,
|
|
|
|
&instruction.data,
|
|
|
|
&mut loader_ix_data,
|
|
|
|
);
|
|
|
|
|
2019-06-27 14:25:10 -07:00
|
|
|
let mut keyed_accounts = create_keyed_credit_only_accounts(executable_accounts);
|
2019-04-02 15:02:57 -07:00
|
|
|
let mut keyed_accounts2: Vec<_> = instruction
|
2019-03-07 09:35:28 -08:00
|
|
|
.accounts
|
|
|
|
.iter()
|
|
|
|
.map(|&index| {
|
|
|
|
let index = index as usize;
|
2019-03-29 09:05:06 -07:00
|
|
|
let key = &message.account_keys[index];
|
2019-06-27 14:25:10 -07:00
|
|
|
let is_debitable = message.is_debitable(index);
|
|
|
|
(
|
|
|
|
key,
|
|
|
|
index < message.header.num_required_signatures as usize,
|
|
|
|
is_debitable,
|
|
|
|
)
|
2019-03-07 09:35:28 -08:00
|
|
|
})
|
2019-03-15 19:48:11 -07:00
|
|
|
.zip(program_accounts.iter_mut())
|
2019-06-27 14:25:10 -07:00
|
|
|
.map(|((key, is_signer, is_debitable), account)| {
|
|
|
|
if is_debitable {
|
|
|
|
KeyedAccount::new(key, is_signer, account)
|
|
|
|
} else {
|
|
|
|
KeyedAccount::new_credit_only(key, is_signer, account)
|
|
|
|
}
|
|
|
|
})
|
2019-03-07 09:35:28 -08:00
|
|
|
.collect();
|
2019-03-15 19:48:11 -07:00
|
|
|
keyed_accounts.append(&mut keyed_accounts2);
|
|
|
|
|
2019-07-16 09:45:32 -07:00
|
|
|
assert!(
|
|
|
|
keyed_accounts[0].account.executable,
|
|
|
|
"loader not executable"
|
|
|
|
);
|
|
|
|
|
2019-09-24 04:09:53 -07:00
|
|
|
let loader_id = keyed_accounts[0].unsigned_key();
|
|
|
|
for (id, process_instruction) in &self.instruction_processors {
|
|
|
|
if id == loader_id {
|
|
|
|
return process_instruction(&program_id, &mut keyed_accounts[1..], &ix_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-16 09:45:32 -07:00
|
|
|
native_loader::invoke_entrypoint(
|
2019-03-15 19:48:11 -07:00
|
|
|
&program_id,
|
|
|
|
&mut keyed_accounts,
|
2019-07-16 09:45:32 -07:00
|
|
|
ix_data,
|
2019-04-23 17:25:03 -07:00
|
|
|
&self.symbol_cache,
|
2019-03-15 19:48:11 -07:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Execute an instruction
|
|
|
|
/// This method calls the instruction's program entrypoint method and verifies that the result of
|
|
|
|
/// the call does not violate the bank's accounting rules.
|
|
|
|
/// The accounts are committed back to the bank only if this function returns Ok(_).
|
|
|
|
fn execute_instruction(
|
|
|
|
&self,
|
2019-03-29 09:05:06 -07:00
|
|
|
message: &Message,
|
2019-04-02 15:02:57 -07:00
|
|
|
instruction: &CompiledInstruction,
|
2019-03-15 19:48:11 -07:00
|
|
|
executable_accounts: &mut [(Pubkey, Account)],
|
|
|
|
program_accounts: &mut [&mut Account],
|
2019-06-10 19:50:02 -07:00
|
|
|
credits: &mut [&mut LamportCredit],
|
2019-03-15 19:48:11 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2019-05-22 15:23:16 -07:00
|
|
|
let program_id = instruction.program_id(&message.account_keys);
|
2019-06-27 14:25:10 -07:00
|
|
|
assert_eq!(instruction.accounts.len(), program_accounts.len());
|
2019-03-15 19:48:11 -07:00
|
|
|
// TODO: the runtime should be checking read/write access to memory
|
2019-10-16 10:47:45 -07:00
|
|
|
// we are trusting the hard-coded programs not to clobber
|
2019-06-22 17:18:35 -07:00
|
|
|
let pre_total: u128 = program_accounts
|
|
|
|
.iter()
|
|
|
|
.map(|a| u128::from(a.lamports))
|
|
|
|
.sum();
|
2019-08-26 11:04:20 -07:00
|
|
|
#[allow(clippy::map_clone)]
|
|
|
|
let pre_accounts: Vec<_> = program_accounts
|
2019-03-15 19:48:11 -07:00
|
|
|
.iter_mut()
|
2019-08-26 11:04:20 -07:00
|
|
|
.map(|account| account.clone()) // cloned() doesn't work on & &
|
2019-03-15 19:48:11 -07:00
|
|
|
.collect();
|
|
|
|
|
2019-05-31 15:29:21 -07:00
|
|
|
self.process_instruction(message, instruction, executable_accounts, program_accounts)?;
|
2019-03-15 19:48:11 -07:00
|
|
|
// Verify the instruction
|
2019-08-26 11:04:20 -07:00
|
|
|
for (pre_account, (i, post_account, is_debitable)) in
|
|
|
|
pre_accounts
|
|
|
|
.iter()
|
|
|
|
.zip(program_accounts.iter().enumerate().map(|(i, account)| {
|
|
|
|
(
|
|
|
|
i,
|
|
|
|
account,
|
|
|
|
message.is_debitable(instruction.accounts[i] as usize),
|
|
|
|
)
|
|
|
|
}))
|
|
|
|
{
|
|
|
|
verify_instruction(is_debitable, &program_id, pre_account, post_account)?;
|
2019-06-10 19:50:02 -07:00
|
|
|
if !is_debitable {
|
2019-08-26 11:04:20 -07:00
|
|
|
*credits[i] += post_account.lamports - pre_account.lamports;
|
2019-06-10 19:50:02 -07:00
|
|
|
}
|
2019-03-15 19:48:11 -07:00
|
|
|
}
|
|
|
|
// The total sum of all the lamports in all the accounts cannot change.
|
2019-06-22 17:18:35 -07:00
|
|
|
let post_total: u128 = program_accounts
|
|
|
|
.iter()
|
|
|
|
.map(|a| u128::from(a.lamports))
|
|
|
|
.sum();
|
2019-08-26 11:04:20 -07:00
|
|
|
|
2019-03-15 19:48:11 -07:00
|
|
|
if pre_total != post_total {
|
|
|
|
return Err(InstructionError::UnbalancedInstruction);
|
|
|
|
}
|
|
|
|
Ok(())
|
2019-03-07 09:35:28 -08:00
|
|
|
}
|
|
|
|
|
2019-03-29 09:05:06 -07:00
|
|
|
/// Process a message.
|
|
|
|
/// This method calls each instruction in the message over the set of loaded Accounts
|
2019-03-15 19:48:11 -07:00
|
|
|
/// The accounts are committed back to the bank only if every instruction succeeds
|
2019-03-29 09:05:06 -07:00
|
|
|
pub fn process_message(
|
2019-03-15 19:48:11 -07:00
|
|
|
&self,
|
2019-03-29 09:05:06 -07:00
|
|
|
message: &Message,
|
2019-03-15 19:48:11 -07:00
|
|
|
loaders: &mut [Vec<(Pubkey, Account)>],
|
2019-03-29 09:05:06 -07:00
|
|
|
accounts: &mut [Account],
|
2019-06-10 19:50:02 -07:00
|
|
|
credits: &mut [LamportCredit],
|
2019-03-15 19:48:11 -07:00
|
|
|
) -> Result<(), TransactionError> {
|
2019-03-29 09:05:06 -07:00
|
|
|
for (instruction_index, instruction) in message.instructions.iter().enumerate() {
|
2019-05-23 15:19:53 -07:00
|
|
|
let executable_index = message
|
2019-07-01 17:34:22 -07:00
|
|
|
.program_position(instruction.program_id_index as usize)
|
2019-05-23 15:19:53 -07:00
|
|
|
.ok_or(TransactionError::InvalidAccountIndex)?;
|
|
|
|
let executable_accounts = &mut loaders[executable_index];
|
2019-03-29 09:05:06 -07:00
|
|
|
let mut program_accounts = get_subset_unchecked_mut(accounts, &instruction.accounts)
|
2019-03-15 19:48:11 -07:00
|
|
|
.map_err(|err| TransactionError::InstructionError(instruction_index as u8, err))?;
|
2019-05-23 15:19:53 -07:00
|
|
|
// TODO: `get_subset_unchecked_mut` panics on an index out of bounds if an executable
|
|
|
|
// account is also included as a regular account for an instruction, because the
|
|
|
|
// executable account is not passed in as part of the accounts slice
|
2019-06-10 19:50:02 -07:00
|
|
|
let mut instruction_credits = get_subset_unchecked_mut(credits, &instruction.accounts)
|
|
|
|
.map_err(|err| TransactionError::InstructionError(instruction_index as u8, err))?;
|
2019-03-15 19:48:11 -07:00
|
|
|
self.execute_instruction(
|
2019-03-29 09:05:06 -07:00
|
|
|
message,
|
2019-04-02 15:02:57 -07:00
|
|
|
instruction,
|
2019-03-15 19:48:11 -07:00
|
|
|
executable_accounts,
|
|
|
|
&mut program_accounts,
|
2019-06-10 19:50:02 -07:00
|
|
|
&mut instruction_credits,
|
2019-03-15 19:48:11 -07:00
|
|
|
)
|
|
|
|
.map_err(|err| TransactionError::InstructionError(instruction_index as u8, err))?;
|
2019-03-11 15:35:25 -07:00
|
|
|
}
|
2019-03-15 19:48:11 -07:00
|
|
|
Ok(())
|
|
|
|
}
|
2019-03-11 15:35:25 -07:00
|
|
|
}
|
|
|
|
|
2019-02-18 22:26:22 -08:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-06-10 19:50:02 -07:00
|
|
|
use solana_sdk::instruction::{AccountMeta, Instruction, InstructionError};
|
|
|
|
use solana_sdk::message::Message;
|
2019-09-24 04:09:53 -07:00
|
|
|
use solana_sdk::native_loader::create_loadable_account;
|
2019-02-18 22:26:22 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_has_duplicates() {
|
|
|
|
assert!(!has_duplicates(&[1, 2]));
|
|
|
|
assert!(has_duplicates(&[1, 2, 1]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-19 17:52:02 -07:00
|
|
|
fn test_get_subset_unchecked_mut() {
|
2019-02-18 22:26:22 -08:00
|
|
|
assert_eq!(
|
2019-03-19 17:52:02 -07:00
|
|
|
get_subset_unchecked_mut(&mut [7, 8], &[0]).unwrap(),
|
|
|
|
vec![&mut 7]
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
get_subset_unchecked_mut(&mut [7, 8], &[0, 1]).unwrap(),
|
2019-02-18 22:26:22 -08:00
|
|
|
vec![&mut 7, &mut 8]
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-03-19 17:52:02 -07:00
|
|
|
fn test_get_subset_unchecked_mut_duplicate_index() {
|
|
|
|
// This panics, because it assumes duplicate detection is done elsewhere.
|
2019-03-14 14:32:12 -07:00
|
|
|
assert_eq!(
|
2019-03-19 17:52:02 -07:00
|
|
|
get_subset_unchecked_mut(&mut [7, 8], &[0, 0]).unwrap_err(),
|
2019-03-14 14:32:12 -07:00
|
|
|
InstructionError::DuplicateAccountIndex
|
|
|
|
);
|
2019-02-18 22:26:22 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[should_panic]
|
2019-03-19 17:52:02 -07:00
|
|
|
fn test_get_subset_unchecked_mut_out_of_bounds() {
|
2019-02-18 22:26:22 -08:00
|
|
|
// This panics, because it assumes bounds validation is done elsewhere.
|
2019-03-19 17:52:02 -07:00
|
|
|
get_subset_unchecked_mut(&mut [7, 8], &[2]).unwrap();
|
2019-02-18 22:26:22 -08:00
|
|
|
}
|
2019-02-22 12:08:54 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_verify_instruction_change_program_id() {
|
2019-03-13 10:46:49 -07:00
|
|
|
fn change_program_id(
|
|
|
|
ix: &Pubkey,
|
|
|
|
pre: &Pubkey,
|
|
|
|
post: &Pubkey,
|
2019-07-29 15:29:20 -07:00
|
|
|
is_debitable: bool,
|
2019-03-13 10:46:49 -07:00
|
|
|
) -> Result<(), InstructionError> {
|
2019-07-29 15:29:20 -07:00
|
|
|
verify_instruction(
|
|
|
|
is_debitable,
|
|
|
|
&ix,
|
2019-08-26 11:04:20 -07:00
|
|
|
&Account::new(0, 0, pre),
|
2019-07-29 15:29:20 -07:00
|
|
|
&Account::new(0, 0, post),
|
|
|
|
)
|
2019-02-22 12:08:54 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
let system_program_id = system_program::id();
|
2019-03-30 20:37:33 -07:00
|
|
|
let alice_program_id = Pubkey::new_rand();
|
|
|
|
let mallory_program_id = Pubkey::new_rand();
|
2019-02-22 12:08:54 -08:00
|
|
|
|
|
|
|
assert_eq!(
|
2019-07-29 15:29:20 -07:00
|
|
|
change_program_id(
|
|
|
|
&system_program_id,
|
|
|
|
&system_program_id,
|
|
|
|
&alice_program_id,
|
|
|
|
true
|
|
|
|
),
|
2019-02-22 12:08:54 -08:00
|
|
|
Ok(()),
|
|
|
|
"system program should be able to change the account owner"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
2019-07-29 15:29:20 -07:00
|
|
|
change_program_id(&system_program_id, &system_program_id, &alice_program_id, false),
|
|
|
|
Err(InstructionError::ModifiedProgramId),
|
|
|
|
"system program should not be able to change the account owner of a credit only account"
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
change_program_id(
|
|
|
|
&mallory_program_id,
|
|
|
|
&system_program_id,
|
|
|
|
&alice_program_id,
|
|
|
|
true
|
|
|
|
),
|
2019-03-13 10:46:49 -07:00
|
|
|
Err(InstructionError::ModifiedProgramId),
|
2019-02-22 12:08:54 -08:00
|
|
|
"malicious Mallory should not be able to change the account owner"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2019-07-29 15:29:20 -07:00
|
|
|
fn test_verify_instruction_change_executable() {
|
|
|
|
let alice_program_id = Pubkey::new_rand();
|
|
|
|
let change_executable = |program_id: &Pubkey,
|
|
|
|
is_debitable: bool,
|
|
|
|
pre_executable: bool,
|
|
|
|
post_executable: bool|
|
|
|
|
-> Result<(), InstructionError> {
|
2019-08-26 11:04:20 -07:00
|
|
|
let pre = Account {
|
|
|
|
owner: alice_program_id,
|
|
|
|
executable: pre_executable,
|
|
|
|
..Account::default()
|
|
|
|
};
|
|
|
|
|
|
|
|
let post = Account {
|
|
|
|
owner: alice_program_id,
|
|
|
|
executable: post_executable,
|
|
|
|
..Account::default()
|
|
|
|
};
|
|
|
|
verify_instruction(is_debitable, &program_id, &pre, &post)
|
2019-07-29 15:29:20 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
let mallory_program_id = Pubkey::new_rand();
|
|
|
|
let system_program_id = system_program::id();
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
change_executable(&system_program_id, true, false, true),
|
|
|
|
Ok(()),
|
|
|
|
"system program should be able to change executable"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
change_executable(&alice_program_id, true, false, true),
|
|
|
|
Ok(()),
|
|
|
|
"alice program should be able to change executable"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
change_executable(&system_program_id, false, false, true),
|
|
|
|
Err(InstructionError::ExecutableModified),
|
|
|
|
"system program can't modify executable of credit-only accounts"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
change_executable(&system_program_id, true, true, false),
|
|
|
|
Err(InstructionError::ExecutableModified),
|
|
|
|
"system program can't reverse executable"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
change_executable(&mallory_program_id, true, false, true),
|
|
|
|
Err(InstructionError::ExecutableModified),
|
|
|
|
"malicious Mallory should not be able to change the account executable"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_verify_instruction_change_data() {
|
|
|
|
let alice_program_id = Pubkey::new_rand();
|
|
|
|
|
|
|
|
let change_data =
|
|
|
|
|program_id: &Pubkey, is_debitable: bool| -> Result<(), InstructionError> {
|
2019-10-16 10:47:45 -07:00
|
|
|
let pre = Account::new_data(0, &[0], &alice_program_id).unwrap();
|
2019-08-26 11:04:20 -07:00
|
|
|
let post = Account::new_data(0, &[42], &alice_program_id).unwrap();
|
|
|
|
verify_instruction(is_debitable, &program_id, &pre, &post)
|
2019-07-29 15:29:20 -07:00
|
|
|
};
|
2019-02-22 12:08:54 -08:00
|
|
|
|
|
|
|
let system_program_id = system_program::id();
|
2019-03-30 20:37:33 -07:00
|
|
|
let mallory_program_id = Pubkey::new_rand();
|
2019-02-22 12:08:54 -08:00
|
|
|
|
|
|
|
assert_eq!(
|
2019-06-10 19:50:02 -07:00
|
|
|
change_data(&system_program_id, true),
|
2019-02-22 12:08:54 -08:00
|
|
|
Ok(()),
|
2019-03-14 09:48:27 -07:00
|
|
|
"system program should be able to change the data"
|
2019-02-22 12:08:54 -08:00
|
|
|
);
|
2019-07-29 15:29:20 -07:00
|
|
|
assert_eq!(
|
|
|
|
change_data(&alice_program_id, true),
|
|
|
|
Ok(()),
|
|
|
|
"alice program should be able to change the data"
|
|
|
|
);
|
2019-02-22 12:08:54 -08:00
|
|
|
assert_eq!(
|
2019-06-10 19:50:02 -07:00
|
|
|
change_data(&mallory_program_id, true),
|
2019-03-14 09:48:27 -07:00
|
|
|
Err(InstructionError::ExternalAccountDataModified),
|
|
|
|
"malicious Mallory should not be able to change the account data"
|
2019-02-22 12:08:54 -08:00
|
|
|
);
|
2019-06-10 19:50:02 -07:00
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
change_data(&system_program_id, false),
|
|
|
|
Err(InstructionError::CreditOnlyDataModified),
|
|
|
|
"system program should not be able to change the data if credit-only"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-08-26 11:04:20 -07:00
|
|
|
#[test]
|
|
|
|
fn test_verify_instruction_rent_epoch() {
|
|
|
|
let alice_program_id = Pubkey::new_rand();
|
|
|
|
let pre = Account::new(0, 0, &alice_program_id);
|
|
|
|
let mut post = Account::new(0, 0, &alice_program_id);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
verify_instruction(false, &system_program::id(), &pre, &post),
|
|
|
|
Ok(()),
|
|
|
|
"nothing changed!"
|
|
|
|
);
|
|
|
|
|
|
|
|
post.rent_epoch += 1;
|
|
|
|
assert_eq!(
|
|
|
|
verify_instruction(false, &system_program::id(), &pre, &post),
|
|
|
|
Err(InstructionError::RentEpochModified),
|
|
|
|
"no one touches rent_epoch"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-06-10 19:50:02 -07:00
|
|
|
#[test]
|
|
|
|
fn test_verify_instruction_credit_only() {
|
|
|
|
let alice_program_id = Pubkey::new_rand();
|
2019-08-26 11:04:20 -07:00
|
|
|
let pre = Account::new(42, 0, &alice_program_id);
|
|
|
|
let post = Account::new(0, 0, &alice_program_id);
|
2019-06-10 19:50:02 -07:00
|
|
|
assert_eq!(
|
2019-08-26 11:04:20 -07:00
|
|
|
verify_instruction(false, &system_program::id(), &pre, &post),
|
2019-06-10 19:50:02 -07:00
|
|
|
Err(InstructionError::ExternalAccountLamportSpend),
|
|
|
|
"debit should fail, even if system program"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
2019-08-26 11:04:20 -07:00
|
|
|
verify_instruction(false, &alice_program_id, &pre, &post,),
|
2019-06-10 19:50:02 -07:00
|
|
|
Err(InstructionError::CreditOnlyLamportSpend),
|
|
|
|
"debit should fail, even if owning program"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-10-16 10:47:45 -07:00
|
|
|
#[test]
|
|
|
|
fn test_verify_instruction_data_size_changed() {
|
|
|
|
let alice_program_id = Pubkey::new_rand();
|
|
|
|
let pre = Account::new_data(42, &[42], &alice_program_id).unwrap();
|
|
|
|
let post = Account::new_data(42, &[42, 42], &alice_program_id).unwrap();
|
|
|
|
assert_eq!(
|
|
|
|
verify_instruction(true, &system_program::id(), &pre, &post),
|
|
|
|
Ok(()),
|
|
|
|
"system program should be able to change account data size"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
verify_instruction(true, &alice_program_id, &pre, &post),
|
|
|
|
Err(InstructionError::AccountDataSizeChanged),
|
|
|
|
"non-system programs cannot change their data size"
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-06-10 19:50:02 -07:00
|
|
|
#[test]
|
|
|
|
fn test_process_message_credit_only_handling() {
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
|
|
enum MockSystemInstruction {
|
|
|
|
Correct { lamports: u64 },
|
|
|
|
AttemptDebit { lamports: u64 },
|
|
|
|
Misbehave { lamports: u64 },
|
|
|
|
}
|
|
|
|
|
|
|
|
fn mock_system_process_instruction(
|
|
|
|
_program_id: &Pubkey,
|
|
|
|
keyed_accounts: &mut [KeyedAccount],
|
|
|
|
data: &[u8],
|
|
|
|
) -> Result<(), InstructionError> {
|
|
|
|
if let Ok(instruction) = bincode::deserialize(data) {
|
|
|
|
match instruction {
|
|
|
|
MockSystemInstruction::Correct { lamports } => {
|
|
|
|
keyed_accounts[0].account.lamports -= lamports;
|
|
|
|
keyed_accounts[1].account.lamports += lamports;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
MockSystemInstruction::AttemptDebit { lamports } => {
|
|
|
|
keyed_accounts[0].account.lamports += lamports;
|
|
|
|
keyed_accounts[1].account.lamports -= lamports;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
// Credit a credit-only account for more lamports than debited
|
|
|
|
MockSystemInstruction::Misbehave { lamports } => {
|
|
|
|
keyed_accounts[0].account.lamports -= lamports;
|
|
|
|
keyed_accounts[1].account.lamports = 2 * lamports;
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Err(InstructionError::InvalidInstructionData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let mock_system_program_id = Pubkey::new(&[2u8; 32]);
|
|
|
|
let mut message_processor = MessageProcessor::default();
|
|
|
|
message_processor
|
|
|
|
.add_instruction_processor(mock_system_program_id, mock_system_process_instruction);
|
|
|
|
|
|
|
|
let mut accounts: Vec<Account> = Vec::new();
|
|
|
|
let account = Account::new(100, 1, &mock_system_program_id);
|
|
|
|
accounts.push(account);
|
|
|
|
let account = Account::new(0, 1, &mock_system_program_id);
|
|
|
|
accounts.push(account);
|
|
|
|
|
|
|
|
let mut loaders: Vec<Vec<(Pubkey, Account)>> = Vec::new();
|
|
|
|
let account = create_loadable_account("mock_system_program");
|
2019-09-24 04:09:53 -07:00
|
|
|
loaders.push(vec![(mock_system_program_id, account)]);
|
2019-06-10 19:50:02 -07:00
|
|
|
|
|
|
|
let from_pubkey = Pubkey::new_rand();
|
|
|
|
let to_pubkey = Pubkey::new_rand();
|
|
|
|
let account_metas = vec![
|
|
|
|
AccountMeta::new(from_pubkey, true),
|
|
|
|
AccountMeta::new_credit_only(to_pubkey, false),
|
|
|
|
];
|
|
|
|
let message = Message::new(vec![Instruction::new(
|
|
|
|
mock_system_program_id,
|
|
|
|
&MockSystemInstruction::Correct { lamports: 50 },
|
|
|
|
account_metas.clone(),
|
|
|
|
)]);
|
|
|
|
let mut deltas = vec![0, 0];
|
|
|
|
|
|
|
|
let result =
|
|
|
|
message_processor.process_message(&message, &mut loaders, &mut accounts, &mut deltas);
|
|
|
|
assert_eq!(result, Ok(()));
|
|
|
|
assert_eq!(accounts[0].lamports, 50);
|
|
|
|
assert_eq!(accounts[1].lamports, 50);
|
|
|
|
assert_eq!(deltas, vec![0, 50]);
|
|
|
|
|
|
|
|
let message = Message::new(vec![Instruction::new(
|
|
|
|
mock_system_program_id,
|
|
|
|
&MockSystemInstruction::AttemptDebit { lamports: 50 },
|
|
|
|
account_metas.clone(),
|
|
|
|
)]);
|
|
|
|
let mut deltas = vec![0, 0];
|
|
|
|
|
|
|
|
let result =
|
|
|
|
message_processor.process_message(&message, &mut loaders, &mut accounts, &mut deltas);
|
|
|
|
assert_eq!(
|
|
|
|
result,
|
|
|
|
Err(TransactionError::InstructionError(
|
|
|
|
0,
|
|
|
|
InstructionError::CreditOnlyLamportSpend
|
|
|
|
))
|
|
|
|
);
|
|
|
|
|
|
|
|
let message = Message::new(vec![Instruction::new(
|
|
|
|
mock_system_program_id,
|
|
|
|
&MockSystemInstruction::Misbehave { lamports: 50 },
|
|
|
|
account_metas,
|
|
|
|
)]);
|
|
|
|
let mut deltas = vec![0, 0];
|
|
|
|
|
|
|
|
let result =
|
|
|
|
message_processor.process_message(&message, &mut loaders, &mut accounts, &mut deltas);
|
|
|
|
assert_eq!(
|
|
|
|
result,
|
|
|
|
Err(TransactionError::InstructionError(
|
|
|
|
0,
|
|
|
|
InstructionError::UnbalancedInstruction
|
|
|
|
))
|
|
|
|
);
|
2019-02-22 12:08:54 -08:00
|
|
|
}
|
2019-07-16 09:45:32 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_get_loader_instruction_data() {
|
|
|
|
// First ensure the ix_data is unaffected if not invoking via a loader.
|
|
|
|
let ix_data = [1];
|
|
|
|
let mut loader_ix_data = vec![];
|
|
|
|
|
|
|
|
let native_pubkey = Pubkey::new_rand();
|
|
|
|
let native_loader = (native_pubkey, Account::new(0, 0, &native_pubkey));
|
|
|
|
assert_eq!(
|
|
|
|
get_loader_instruction_data(&[native_loader.clone()], &ix_data, &mut loader_ix_data),
|
|
|
|
&ix_data
|
|
|
|
);
|
|
|
|
|
|
|
|
// Now ensure the ix_data is wrapped when there's a loader present.
|
|
|
|
let acme_pubkey = Pubkey::new_rand();
|
|
|
|
let acme_loader = (acme_pubkey, Account::new(0, 0, &native_pubkey));
|
|
|
|
let expected_ix = LoaderInstruction::InvokeMain {
|
|
|
|
data: ix_data.to_vec(),
|
|
|
|
};
|
|
|
|
let expected_ix_data = bincode::serialize(&expected_ix).unwrap();
|
|
|
|
assert_eq!(
|
|
|
|
get_loader_instruction_data(
|
|
|
|
&[native_loader.clone(), acme_loader.clone()],
|
|
|
|
&ix_data,
|
|
|
|
&mut loader_ix_data
|
|
|
|
),
|
|
|
|
&expected_ix_data[..]
|
|
|
|
);
|
|
|
|
|
|
|
|
// Note there was an allocation in the input vector.
|
|
|
|
assert_eq!(loader_ix_data, expected_ix_data);
|
|
|
|
}
|
2019-02-18 22:26:22 -08:00
|
|
|
}
|