CertiK协助修复Solana大整数模幂运算中的DOS漏洞

[1u8; len] for the base and exponent Use a prime or an RSA modulus for each bit-sizes.

计算时间（ns） = bits^2CU = 计算时间 / 33 ns

CU = 4,194,304 / 33 ≈ 127,100

CU = 52,000,000 / 33 ≈ 1,575,757

let params = &translate_slice::<BigModExpParams>(            memory_mapping,            params,            1,            invoke_context.get_check_aligned(),            invoke_context.get_check_size(),        )?        .get(0)        .ok_or(SyscallError::InvalidLength)?;        if params.base_len > 512 || params.exponent_len > 512 ||params.modulus_len > 512 {            return Err(Box::new(SyscallError::InvalidLength));        }let input_len: u64 = std::cmp::max(params.base_len, params.exponent_len);let input_len: u64 = std::cmp::max(input_len, params.modulus_len);

let budget = invoke_context.get_compute_budget();        consume_compute_meter(            invoke_context,            budget.syscall_base_cost.saturating_add(                input_len                    .saturating_mul(input_len)                    .checked_div(budget.big_modular_exponentiation_cost)                    .unwrap_or(u64::MAX),            ),        )?;

CU = bytes^2 / big_modular_exponentiation_cost (33)

CU = bits^2 / 33

CU = (bytes * 8) ^2 / big_modular_exponentiation_cost

CU = 4096 ^ 2 / 33 ~= 508,400

200_000 / 8043 ≈ 2424 * 37 ms ≈ 890 ms

 pub const NUM_THREADS: u32 = 6;    const NUM_VOTE_PROCESSING_THREADS: u32 = 2;    const MIN_THREADS_BANKING: u32 = 1;    const MIN_TOTAL_THREADS: u32 = NUM_VOTE_PROCESSING_THREADS +MIN_THREADS_BANKING;    ...    pub fn num_threads() -> u32 {            cmp::max(                env::var("Solana_BANKING_THREADS")                    .map(|x| x.parse().unwrap_or(NUM_THREADS))                    .unwrap_or(NUM_THREADS),                MIN_TOTAL_THREADS,            )         }

 Builder::new()            .name(format!("solBanknStgTx{id:02}"))            .spawn(move || {                Self::process_loop(                    &mut packet_receiver,                    &decision_maker,                    &mut forwarder,                    &consumer,                    id,                    unprocessed_transaction_storage,                )            })            .unwrap()

 loop {            if !unprocessed_transaction_storage.is_empty()                || last_metrics_update.elapsed() >= SLOT_BOUNDARY_CHECK_PERIOD            {                let (_, process_buffered_packets_time) = measure!(                    Self::process_buffered_packets(                        decision_maker,                        forwarder,                        consumer,                        &mut unprocessed_transaction_storage,                        &banking_stage_stats,                        &mut slot_metrics_tracker,                        &mut tracer_packet_stats,                    ),                    "process_buffered_packets",                );                slot_metrics_tracker                    .increment_process_buffered_packets_us(process_buffered_packets_time.as_us());                last_metrics_update = Instant::now();            }

            tracer_packet_stats.report(1000);

            match packet_receiver.receive_and_buffer_packets(                &mut unprocessed_transaction_storage,                &mut banking_stage_stats,                &mut tracer_packet_stats,                &mut slot_metrics_tracker,            ) {                Ok(()) | Err(RecvTimeoutError::Timeout) => (),                Err(RecvTimeoutError::Disconnected) => break,            }            banking_stage_stats.report(1000);        }

let (load_and_execute_transactions_output, load_execute_us) = measure_us!(bank            .load_and_execute_transactions(                batch,                MAX_PROCESSING_AGE,                &mut execute_and_commit_timings.execute_timings,                TransactionProcessingConfig {                    account_overrides: None,                    log_messages_bytes_limit: self.log_messages_bytes_limit,                    limit_to_load_programs: true,                    recording_config: ExecutionRecordingConfig::new_single_setting(                        transaction_status_sender_enabled                    ),                }            ));        execute_and_commit_timings.load_execute_us = load_execute_us;        .......        .......        let (record_transactions_summary, record_us) = measure_us!(self            .transaction_recorder            .record_transactions(bank.slot(), executed_transactions));        execute_and_commit_timings.record_us = record_us;        .......        ......        let (commit_time_us, commit_transaction_statuses) = if executed_transactions_count != 0 {            self.committer.commit_transactions(                batch,                &mut loaded_transactions,                execution_results,                last_blockhash,                lamports_per_signature,                starting_transaction_index,                bank,                &mut pre_balance_info,                &mut execute_and_commit_timings,                signature_count,                executed_transactions_count,                executed_non_vote_transactions_count,                executed_with_successful_result_count,            )        } else {            (                0,

                vec![CommitTransactionDetails::NotCommitted; execution_results.len()],            )        };

if bank_slot != working_bank.bank.slot() {                return Err(PohRecorderError::MaxHeightReached);            }

fn process_packets<F>(        &mut self,        bank: &Bank,        banking_stage_stats: &BankingStageStats,        slot_metrics_tracker: &mut LeaderSlotMetricsTracker,        mut processing_function: F,    ) -> bool    where        F: FnMut(            &Vec<Arc<ImmutableDeserializedPacket>>,            &mut ConsumeScannerPayload,        ) -> Option<Vec<usize>>,    {        let mut retryable_packets = self.take_priority_queue();        let original_capacity = retryable_packets.capacity();        let mut new_retryable_packets = MinMaxHeap::with_capacity(original_capacity);        let all_packets_to_process = retryable_packets.drain_desc().collect_vec();        ..............                ..........                while let Some((packets_to_process, payload)) = scanner.iterate() {            let packets_to_process = packets_to_process                .iter()                .map(|p| (*p).clone())                .collect_vec();            let retryable_packets = if let Some(retryable_transaction_indexes) =                processing_function(&packets_to_process, payload)            {                Self::collect_retained_packets(                    payload.message_hash_to_transaction,                    &packets_to_process,                    &retryable_transaction_indexes,                )            } else {                packets_to_process            };

            new_retryable_packets.extend(retryable_packets);        }        .......      }