program: add custom error codes for executable, ro writes

Author: buffalojoec

Cargo.lock

@@ -17,8 +17,11 @@ test-sbf = []
 
 [dependencies]
 bincode = "1.3.3"
+num-derive = "0.4"
+num-traits = "0.2"
 serde = { version = "1.0.193", features = ["derive"] }
 solana-program = "2.0.1"
+thiserror = "1.0.61"
 
 [dev-dependencies]
 mollusk-svm = { version = "0.0.5", features = ["fuzz"] }

program/Cargo.toml

@@ -1,8 +1,11 @@
 //! Program entrypoint.
 
 use {
-    crate::processor,
-    solana_program::{account_info::AccountInfo, entrypoint::ProgramResult, pubkey::Pubkey},
+    crate::{error::ConfigError, processor},
+    solana_program::{
+        account_info::AccountInfo, entrypoint::ProgramResult, program_error::PrintProgramError,
+        pubkey::Pubkey,
+    },
 };
 
 solana_program::entrypoint!(process_instruction);
@@ -11,5 +14,9 @@ fn process_instruction(
     accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> ProgramResult {
-    processor::process(program_id, accounts, instruction_data)
+    if let Err(error) = processor::process(program_id, accounts, instruction_data) {
+        error.print::<ConfigError>();
+        return Err(error);
+    }
+    Ok(())
 }

program/src/entrypoint.rs

@@ -0,0 +1,40 @@
+//! Program error types.
+
+use {
+    num_derive::FromPrimitive,
+    solana_program::{
+        decode_error::DecodeError,
+        msg,
+        program_error::{PrintProgramError, ProgramError},
+    },
+    thiserror::Error,
+};
+
+/// Errors that can be returned by the Config program.
+#[derive(Error, Clone, Debug, Eq, PartialEq, FromPrimitive)]
+pub enum ConfigError {
+    /// Instruction changed executable account's data.
+    #[error("Instruction changed executable account's data")]
+    ExecutableDataModified,
+    /// Instruction modified data of a read-only account.
+    #[error("Instruction modified data of a read-only account")]
+    ReadonlyDataModified,
+}
+
+impl PrintProgramError for ConfigError {
+    fn print<E>(&self) {
+        msg!(&self.to_string());
+    }
+}
+
+impl From<ConfigError> for ProgramError {
+    fn from(e: ConfigError) -> Self {
+        ProgramError::Custom(e as u32)
+    }
+}
+
+impl<T> DecodeError<T> for ConfigError {
+    fn type_of() -> &'static str {
+        "ConfigError"
+    }
+}

program/src/error.rs

@@ -2,6 +2,7 @@
 
 #[cfg(all(target_os = "solana", feature = "bpf-entrypoint"))]
 mod entrypoint;
+pub mod error;
 pub mod instruction;
 pub mod processor;
 pub mod state;

program/src/lib.rs

@@ -1,7 +1,7 @@
 //! Config program processor.
 
 use {
-    crate::state::ConfigKeys,
+    crate::{error::ConfigError, state::ConfigKeys},
     solana_program::{
         account_info::AccountInfo, entrypoint::ProgramResult, msg, program_error::ProgramError,
         pubkey::Pubkey,
@@ -160,6 +160,33 @@ pub fn process(program_id: &Pubkey, accounts: &[AccountInfo], input: &[u8]) -> P
         return Err(ProgramError::InvalidInstructionData);
     }
 
+    // [Core BPF]:
+    // When a builtin program attempts to write to an executable or read-only
+    // account, it will be immediately rejected by the `TransactionContext`.
+    // However, BPF programs do not query the `TransactionContext` for the
+    // ability to perform a write. Instead, they perform writes at-will, and
+    // the loader will inspect the serialized account memory region for any
+    // account update violations _after_ the VM has completed execution.
+    //
+    // The loader's inspection will catch any unauthorized modifications,
+    // however, when the exact same data is written to the account, thus
+    // rendering the serialized account state unchanged, the program succeeds.
+    //
+    // In order to maximize backwards compatibility between the BPF version and
+    // its original builtin, we add these checks from `TransactionContext` to
+    // the program directly, to throw even when the data being written is the
+    // same as what's currently in the account.
+    //
+    // Unfortunately, the two `InstructionError` variants thrown do not have
+    // `ProgramError` counterparts, so we mock them out with custom error
+    // codes.
+    if config_account.executable {
+        return Err(ConfigError::ExecutableDataModified.into());
+    }
+    if !config_account.is_writable {
+        return Err(ConfigError::ReadonlyDataModified.into());
+    }
+
     config_account.try_borrow_mut_data()?[..input.len()].copy_from_slice(input);
 
     Ok(())

program/src/processor.rs

@@ -5,11 +5,12 @@ use {
     mollusk_svm::{result::Check, Mollusk},
     serde::{Deserialize, Serialize},
     solana_config_program::{
+        error::ConfigError,
         instruction as config_instruction,
         state::{ConfigKeys, ConfigState},
     },
     solana_sdk::{
-        account::AccountSharedData,
+        account::{AccountSharedData, WritableAccount},
         instruction::{AccountMeta, Instruction},
         program_error::ProgramError,
         pubkey::Pubkey,
@@ -83,7 +84,7 @@ fn test_process_create_ok() {
         &[(config, config_account)],
         &[
             Check::success(),
-            Check::compute_units(612),
+            Check::compute_units(619),
             Check::account(&config)
                 .data(
                     &bincode::serialize(&(ConfigKeys { keys: vec![] }, MyConfig::default()))
@@ -111,7 +112,7 @@ fn test_process_store_ok() {
         &[(config, config_account)],
         &[
             Check::success(),
-            Check::compute_units(612),
+            Check::compute_units(619),
             Check::account(&config)
                 .data(&bincode::serialize(&(ConfigKeys { keys }, my_config)).unwrap())
                 .build(),
@@ -186,7 +187,7 @@ fn test_process_store_with_additional_signers() {
         ],
         &[
             Check::success(),
-            Check::compute_units(3_267),
+            Check::compute_units(3_274),
             Check::account(&config)
                 .data(&bincode::serialize(&(ConfigKeys { keys }, my_config)).unwrap())
                 .build(),
@@ -334,7 +335,7 @@ fn test_config_updates() {
             (signer0, AccountSharedData::default()),
             (signer1, AccountSharedData::default()),
         ],
-        &[Check::success(), Check::compute_units(3_267)],
+        &[Check::success(), Check::compute_units(3_274)],
     );
 
     // Use this for next invoke.
@@ -352,7 +353,7 @@ fn test_config_updates() {
         ],
         &[
             Check::success(),
-            Check::compute_units(3_268),
+            Check::compute_units(3_275),
             Check::account(&config)
                 .data(&bincode::serialize(&(ConfigKeys { keys }, new_config)).unwrap())
                 .build(),
@@ -465,7 +466,7 @@ fn test_config_update_contains_duplicates_fails() {
             (signer0, AccountSharedData::default()),
             (signer1, AccountSharedData::default()),
         ],
-        &[Check::success(), Check::compute_units(3_267)],
+        &[Check::success(), Check::compute_units(3_274)],
     );
 
     // Attempt update with duplicate signer inputs.
@@ -509,7 +510,7 @@ fn test_config_updates_requiring_config() {
         ],
         &[
             Check::success(),
-            Check::compute_units(3_363),
+            Check::compute_units(3_370),
             Check::account(&config)
                 .data(&bincode::serialize(&(ConfigKeys { keys: keys.clone() }, my_config)).unwrap())
                 .build(),
@@ -530,7 +531,7 @@ fn test_config_updates_requiring_config() {
         ],
         &[
             Check::success(),
-            Check::compute_units(3_363),
+            Check::compute_units(3_370),
             Check::account(&config)
                 .data(&bincode::serialize(&(ConfigKeys { keys }, new_config)).unwrap())
                 .build(),
@@ -624,7 +625,7 @@ fn test_maximum_keys_input() {
     let result = mollusk.process_and_validate_instruction(
         &instruction,
         &[(config, config_account)],
-        &[Check::success(), Check::compute_units(25_275)],
+        &[Check::success(), Check::compute_units(25_282)],
     );
 
     // Use this for next invoke.
@@ -637,7 +638,7 @@ fn test_maximum_keys_input() {
     let result = mollusk.process_and_validate_instruction(
         &instruction,
         &[(config, updated_config_account)],
-        &[Check::success(), Check::compute_units(25_275)],
+        &[Check::success(), Check::compute_units(25_282)],
     );
 
     // Use this for next invoke.
@@ -748,3 +749,58 @@ fn test_safe_deserialize_from_state() {
         &[Check::err(ProgramError::InvalidAccountData)],
     );
 }
+
+// Backwards compatibility test case.
+#[test]
+fn test_write_same_data_to_executable() {
+    let mollusk = setup();
+
+    let config = Pubkey::new_unique();
+    let keys = vec![];
+
+    // Creates a config account with `MyConfig::default()`.
+    let mut config_account = create_config_account(&mollusk, keys.clone());
+
+    // Make the config account executable.
+    config_account.set_executable(true);
+
+    // Pass the exact same data (`MyConfig::default()`) to the instruction,
+    // which we'll attempt to write into the account.
+    let instruction = config_instruction::store(&config, true, keys.clone(), &MyConfig::default());
+
+    mollusk.process_and_validate_instruction(
+        &instruction,
+        &[(config, config_account)],
+        &[Check::err(ProgramError::Custom(
+            ConfigError::ExecutableDataModified as u32,
+        ))],
+    );
+}
+
+// Backwards compatibility test case.
+#[test]
+fn test_write_same_data_to_readonly() {
+    let mollusk = setup();
+
+    let config = Pubkey::new_unique();
+    let keys = vec![];
+
+    // Creates a config account with `MyConfig::default()`.
+    let config_account = create_config_account(&mollusk, keys.clone());
+
+    // Pass the exact same data (`MyConfig::default()`) to the instruction,
+    // which we'll attempt to write into the account.
+    let mut instruction =
+        config_instruction::store(&config, true, keys.clone(), &MyConfig::default());
+
+    // Make the config account read-only.
+    instruction.accounts[0].is_writable = false;
+
+    mollusk.process_and_validate_instruction(
+        &instruction,
+        &[(config, config_account)],
+        &[Check::err(ProgramError::Custom(
+            ConfigError::ReadonlyDataModified as u32,
+        ))],
+    );
+}