From 34679b90dcdcc3c9834e4a510e6fc3ebb77b2246 Mon Sep 17 00:00:00 2001 From: Sergej Schumilo Date: Sun, 14 Nov 2021 21:59:03 +0100 Subject: [PATCH] Initial Release of Nyx Co-authored-by: Cornelius Aschermann --- README.md | 21 ++ acat/.gitignore | 4 + acat/Cargo.toml | 12 + acat/src/main.rs | 149 +++++++++++ config/.gitignore | 4 + config/Cargo.toml | 12 + config/src/config.rs | 192 ++++++++++++++ config/src/lib.rs | 7 + config/src/loader.rs | 59 +++++ fuzz_runner/.gitignore | 3 + fuzz_runner/Cargo.toml | 28 ++ fuzz_runner/src/exitreason.rs | 46 ++++ fuzz_runner/src/forksrv/error.rs | 66 +++++ fuzz_runner/src/forksrv/mod.rs | 246 ++++++++++++++++++ fuzz_runner/src/forksrv/newtypes.rs | 37 +++ fuzz_runner/src/lib.rs | 226 ++++++++++++++++ fuzz_runner/src/nyx/aux_buffer.rs | 215 ++++++++++++++++ fuzz_runner/src/nyx/ijon_data.rs | 29 +++ fuzz_runner/src/nyx/mem_barrier.rs | 33 +++ fuzz_runner/src/nyx/mod.rs | 129 ++++++++++ fuzz_runner/src/nyx/params.rs | 266 +++++++++++++++++++ fuzz_runner/src/nyx/qemu_process.rs | 387 ++++++++++++++++++++++++++++ fuzz_runner/src/nyx/tests/tests.rs | 13 + libnyx/.gitignore | 4 + libnyx/Cargo.toml | 16 ++ libnyx/build.rs | 29 +++ libnyx/cbindgen.toml | 14 + libnyx/src/lib.rs | 212 +++++++++++++++ libnyx/test.c | 100 +++++++ libnyx/test.sh | 1 + logo.png | Bin 0 -> 253147 bytes 31 files changed, 2560 insertions(+) create mode 100644 README.md create mode 100644 acat/.gitignore create mode 100644 acat/Cargo.toml create mode 100644 acat/src/main.rs create mode 100644 config/.gitignore create mode 100644 config/Cargo.toml create mode 100644 config/src/config.rs create mode 100644 config/src/lib.rs create mode 100644 config/src/loader.rs create mode 100644 fuzz_runner/.gitignore create mode 100644 fuzz_runner/Cargo.toml create mode 100644 fuzz_runner/src/exitreason.rs create mode 100644 fuzz_runner/src/forksrv/error.rs create mode 100644 fuzz_runner/src/forksrv/mod.rs create mode 100644 fuzz_runner/src/forksrv/newtypes.rs create mode 100644 fuzz_runner/src/lib.rs create mode 100644 fuzz_runner/src/nyx/aux_buffer.rs create mode 100644 fuzz_runner/src/nyx/ijon_data.rs create mode 100644 fuzz_runner/src/nyx/mem_barrier.rs create mode 100644 fuzz_runner/src/nyx/mod.rs create mode 100644 fuzz_runner/src/nyx/params.rs create mode 100644 fuzz_runner/src/nyx/qemu_process.rs create mode 100644 fuzz_runner/src/nyx/tests/tests.rs create mode 100644 libnyx/.gitignore create mode 100644 libnyx/Cargo.toml create mode 100644 libnyx/build.rs create mode 100644 libnyx/cbindgen.toml create mode 100644 libnyx/src/lib.rs create mode 100644 libnyx/test.c create mode 100644 libnyx/test.sh create mode 100644 logo.png diff --git a/README.md b/README.md new file mode 100644 index 0000000..eaa93df --- /dev/null +++ b/README.md @@ -0,0 +1,21 @@ +# libnyx + +

+ +

+ +libnyx is a library that allows you to simply build hypervisor based snapshot fuzzers. Using libnyx, managing multiple vms and snapshots as well as the communication with the code running in the VM becomes a matter of a handful of lines of code. At the moment, libnyx can be used via a simple C interface or from a rust library. + +## Bug Reports and Contributions + +If you found and fixed a bug on your own: We are very open to patches, please create a pull request! + +### License + +This library is provided under **AGPL license**. + +**Free Software Hell Yeah!** + +Proudly provided by: +* [Sergej Schumilo](http://schumilo.de) - sergej@schumilo.de / [@ms_s3c](https://twitter.com/ms_s3c) +* [Cornelius Aschermann](https://hexgolems.com) - cornelius@hexgolems.com / [@is_eqv](https://twitter.com/is_eqv) diff --git a/acat/.gitignore b/acat/.gitignore new file mode 100644 index 0000000..543a865 --- /dev/null +++ b/acat/.gitignore @@ -0,0 +1,4 @@ +debug/ +target/ + +Cargo.lock diff --git a/acat/Cargo.toml b/acat/Cargo.toml new file mode 100644 index 0000000..89bf817 --- /dev/null +++ b/acat/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "acat" +version = "0.1.0" +authors = ["Sergej Schumilo "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +fuzz_runner={path="../fuzz_runner"} +colored = "2.0.0" +clap="2.33.0" diff --git a/acat/src/main.rs b/acat/src/main.rs new file mode 100644 index 0000000..c2b387d --- /dev/null +++ b/acat/src/main.rs @@ -0,0 +1,149 @@ +use fuzz_runner::nyx::aux_buffer; + +use clap::{App, Arg, AppSettings}; + +use std::fs::{OpenOptions}; +use std::str; + +extern crate colored; +use colored::*; + + +fn print_aux_buffer(aux_buffer: &aux_buffer::AuxBuffer, target_file: &String, show_header: bool, show_cap: bool, show_config: bool, show_result: bool, show_misc: bool, colored_output: bool){ + println!("\n{} {} {}", "**************", target_file.green().bold(), "**************"); + + + + colored::control::set_override(colored_output); + + + if show_header{ + println!("\n{} {}", "=>", "HEADER".blue().bold()); + print!("{}", format!("{:#?}", aux_buffer.header).yellow()); + } + + if show_cap{ + println!("\n{} {}", "=>", "CAP".blue().bold()); + print!("{}", format!("{:#?}", aux_buffer.cap).yellow()); + } + + if show_config{ + println!("\n{} {}", "=>", "CONFIG".blue().bold()); + print!("{}", format!("{:#?}", aux_buffer.config).yellow()); + } + + if show_result{ + println!("\n{} {}", "=>", "RESULT".blue().bold()); + print!("{}", format!("{:#?}", aux_buffer.result).yellow()); + } + + if show_misc{ + if aux_buffer.misc.len != 0 { + println!("\n{} {}", "=>", "MISC".blue().bold()); + let len = aux_buffer.misc.len; + println!("{}", str::from_utf8(&aux_buffer.misc.data[0..len as usize]).unwrap().red()); + } + } +} + +fn main() { + + let matches = App::new("acat") + .about("Fancy tool to debug aux buffers!") + .arg( + Arg::with_name("target_file") + .short("f") + .long("target_file") + .value_name("TARGET") + .takes_value(true) + .help("specifies target file (aux buffer)"), + ) + .arg( + Arg::with_name("show_header") + .long("show_header") + .value_name("SHOW_HEADER") + .required(false) + .takes_value(false) + .help("show header section"), + ) + .arg( + Arg::with_name("show_cap") + .long("show_cap") + .value_name("SHOW_CAP") + .required(false) + .takes_value(false) + .help("show capabilities section"), + ) + .arg( + Arg::with_name("show_config") + .long("show_config") + .value_name("SHOW_CONFIG") + .required(false) + .takes_value(false) + .help("show config section"), + ) + .arg( + Arg::with_name("ignore_result") + .long("ignore_result") + .value_name("IGNORE_RESULT") + .required(false) + .takes_value(false) + .help("dont't show result section"), + ) + .arg( + Arg::with_name("show_misc") + .long("show_misc") + .value_name("SHOW_MISC") + .required(false) + .takes_value(false) + .help("show misc section"), + ) + .arg( + Arg::with_name("show_all") + .short("a") + .long("show_all") + .value_name("SHOW_ALL") + .required(false) + .takes_value(false) + .help("show all sections"), + ) + .arg( + Arg::with_name("disable_color") + .short("c") + .long("disable_color") + .value_name("SHOW_ALL") + .required(false) + .takes_value(false) + .help("show all sections"), + ) + .setting(AppSettings::ArgRequiredElseHelp) + .get_matches(); + + + let show_header: bool = matches.is_present("show_header"); + let show_cap: bool = matches.is_present("show_cap"); + let show_config: bool = matches.is_present("show_config"); + let show_result: bool = !matches.is_present("ignore_result"); + let show_misc: bool = matches.is_present("show_misc"); + let colered_output: bool = !matches.is_present("disable_color"); + + + + let aux_buffer_file = matches.value_of("target_file").expect("file not found"); + let aux_shm_f = OpenOptions::new() + .write(false) + .read(true) + .open(aux_buffer_file) + .expect("couldn't open aux buffer file"); + let aux_buffer = aux_buffer::AuxBuffer::new_readonly(aux_shm_f, true); + + aux_buffer.validate_header(); + + if matches.is_present("show_all"){ + print_aux_buffer(&aux_buffer, &aux_buffer_file.to_string(), true, true, true, true, true, colered_output); + } + else{ + print_aux_buffer(&aux_buffer, &aux_buffer_file.to_string(), show_header, show_cap, show_config, show_result, show_misc, colered_output); + } + +} diff --git a/config/.gitignore b/config/.gitignore new file mode 100644 index 0000000..543a865 --- /dev/null +++ b/config/.gitignore @@ -0,0 +1,4 @@ +debug/ +target/ + +Cargo.lock diff --git a/config/Cargo.toml b/config/Cargo.toml new file mode 100644 index 0000000..1ab9280 --- /dev/null +++ b/config/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "config" +version = "0.1.0" +authors = ["coco "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +serde ="1.0.104" +serde_derive ="1.0.104" +ron="0.6.2" \ No newline at end of file diff --git a/config/src/config.rs b/config/src/config.rs new file mode 100644 index 0000000..604b181 --- /dev/null +++ b/config/src/config.rs @@ -0,0 +1,192 @@ +use std::time::Duration; +use serde_derive::Serialize; +use serde_derive::Deserialize; +use std::fs::File; +use std::path::{Path}; +use crate::loader::*; + +fn into_absolute_path(path_to_sharedir: &str, path_to_file: String) -> String { + let path_to_default_config = Path::new(&path_to_file); + + if path_to_default_config.is_relative(){ + let path = &format!("{}/{}", path_to_sharedir, path_to_file); + let absolute_path = Path::new(&path); + return absolute_path.canonicalize().unwrap().to_str().unwrap().to_string(); + } + else{ + return path_to_default_config.to_str().unwrap().to_string(); + } +} + +#[derive(Clone)] +pub struct QemuKernelConfig { + pub qemu_binary: String, + pub kernel: String, + pub ramfs: String, + pub debug: bool, +} + +impl QemuKernelConfig{ + pub fn new_from_loader(default_config_folder: &str, default: QemuKernelConfigLoader, config: QemuKernelConfigLoader) -> Self { + let mut qemu_binary = config.qemu_binary.or(default.qemu_binary).expect("no qemu_binary specified"); + let mut kernel = config.kernel.or(default.kernel).expect("no kernel specified"); + let mut ramfs = config.ramfs.or(default.ramfs).expect("no ramfs specified"); + + qemu_binary = into_absolute_path(default_config_folder, qemu_binary); + kernel = into_absolute_path(default_config_folder, kernel); + ramfs = into_absolute_path(default_config_folder, ramfs); + + Self{ + qemu_binary: qemu_binary, + kernel: kernel, + ramfs: ramfs, + debug: config.debug.or(default.debug).expect("no debug specified"), + } + } +} + +#[derive(Clone, Serialize, Deserialize)] +pub enum SnapshotPath { + Reuse(String), + Create(String), + DefaultPath, +} + +#[derive(Clone)] +pub struct QemuSnapshotConfig { + pub qemu_binary: String, + pub hda: String, + pub presnapshot: String, + pub snapshot_path: SnapshotPath, + pub debug: bool, +} + +impl QemuSnapshotConfig{ + pub fn new_from_loader(default_config_folder: &str, default: QemuSnapshotConfigLoader, config: QemuSnapshotConfigLoader) -> Self { + + let mut qemu_binary = config.qemu_binary.or(default.qemu_binary).expect("no qemu_binary specified"); + let mut hda = config.hda.or(default.hda).expect("no hda specified"); + let mut presnapshot = config.presnapshot.or(default.presnapshot).expect("no presnapshot specified"); + qemu_binary = into_absolute_path(default_config_folder, qemu_binary); + hda = into_absolute_path(default_config_folder, hda); + presnapshot = into_absolute_path(default_config_folder, presnapshot); + + Self{ + qemu_binary: qemu_binary, + hda: hda, + presnapshot: presnapshot, + snapshot_path: config.snapshot_path.or(default.snapshot_path).expect("no snapshot_path specified"), + debug: config.debug.or(default.debug).expect("no debug specified"), + } + } +} + +#[derive(Clone)] +pub enum FuzzRunnerConfig { + QemuKernel(QemuKernelConfig), + QemuSnapshot(QemuSnapshotConfig), +} + +impl FuzzRunnerConfig{ + pub fn new_from_loader(default_config_folder: &str, default: FuzzRunnerConfigLoader, config: FuzzRunnerConfigLoader) -> Self { + match (default, config){ + (FuzzRunnerConfigLoader::QemuKernel(d), + FuzzRunnerConfigLoader::QemuKernel(c)) => { Self::QemuKernel(QemuKernelConfig::new_from_loader(default_config_folder, d, c))}, + (FuzzRunnerConfigLoader::QemuSnapshot(d), + FuzzRunnerConfigLoader::QemuSnapshot(c)) => { Self::QemuSnapshot(QemuSnapshotConfig::new_from_loader(default_config_folder, d, c))}, + _ => panic!("conflicting FuzzRunner configs"), + } + } +} + +#[derive(Copy, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum SnapshotPlacement { + None, + Balanced, + Aggressive, +} + +impl std::str::FromStr for SnapshotPlacement { + type Err = ron::Error; + fn from_str(s: &str) -> Result { + ron::de::from_str(s) + } +} + +#[derive(Clone)] +pub struct FuzzerConfig { + pub spec_path: String, + pub workdir_path: String, + pub bitmap_size: usize, + pub mem_limit: usize, + pub time_limit: Duration, + pub target_binary: Option, + pub threads: usize, + pub thread_id: usize, + pub cpu_pin_start_at: usize, + pub seed_path: Option, + pub dict: Vec>, + pub snapshot_placement: SnapshotPlacement, + pub dump_python_code_for_inputs: Option, + pub exit_after_first_crash: bool +} +impl FuzzerConfig{ + pub fn new_from_loader(sharedir: &str, default: FuzzerConfigLoader, config: FuzzerConfigLoader) -> Self { + + let seed_path = config.seed_path.or(default.seed_path).unwrap(); + let seed_path_value = if seed_path.is_empty() { + None + } + else{ + Some(into_absolute_path(&sharedir, seed_path)) + }; + + Self{ + spec_path: format!("{}/spec.msgp",sharedir), + workdir_path: config.workdir_path.or(default.workdir_path).expect("no workdir_path specified"), + bitmap_size: config.bitmap_size.or(default.bitmap_size).expect("no bitmap_size specified"), + mem_limit: config.mem_limit.or(default.mem_limit).expect("no mem_limit specified"), + time_limit: config.time_limit.or(default.time_limit).expect("no time_limit specified"), + target_binary: config.target_binary.or(default.target_binary), + threads: config.threads.or(default.threads).expect("no threads specified"), + thread_id: config.thread_id.or(default.thread_id).expect("no thread_id specified"), + cpu_pin_start_at: config.cpu_pin_start_at.or(default.cpu_pin_start_at).expect("no cpu_pin_start_at specified"), + seed_path: seed_path_value, + dict: config.dict.or(default.dict).expect("no dict specified"), + snapshot_placement: config.snapshot_placement.or(default.snapshot_placement).expect("no snapshot_placement specified"), + dump_python_code_for_inputs: config.dump_python_code_for_inputs.or(default.dump_python_code_for_inputs), + exit_after_first_crash: config.exit_after_first_crash.unwrap_or(default.exit_after_first_crash.unwrap_or(false)), + } + } +} + +#[derive(Clone)] +pub struct Config { + pub runner: FuzzRunnerConfig, + pub fuzz: FuzzerConfig, +} + +impl Config{ + pub fn new_from_loader(sharedir: &str, default_config_folder: &str, default: ConfigLoader, config: ConfigLoader) -> Self{ + Self{ + runner: FuzzRunnerConfig::new_from_loader(&default_config_folder, default.runner, config.runner), + fuzz: FuzzerConfig::new_from_loader(&sharedir, default.fuzz, config.fuzz), + } + } + + pub fn new_from_sharedir(sharedir: &str) -> Self { + let path_to_config = format!("{}/config.ron", sharedir); + let cfg_file = File::open(&path_to_config).expect("could not open config file"); + let mut cfg: ConfigLoader = ron::de::from_reader(cfg_file).unwrap(); + + let default_path = into_absolute_path(sharedir, cfg.include_default_config_path.unwrap()); + let default_config_folder = Path::new(&default_path).parent().unwrap().to_str().unwrap(); + cfg.include_default_config_path = Some(default_path.clone()); + + let default_file = File::open(cfg.include_default_config_path.as_ref().expect("no default config given")).expect("could not open config file"); + let default: ConfigLoader = ron::de::from_reader(default_file).unwrap(); + + Self::new_from_loader(&sharedir, &default_config_folder, default, cfg) + } +} diff --git a/config/src/lib.rs b/config/src/lib.rs new file mode 100644 index 0000000..225983a --- /dev/null +++ b/config/src/lib.rs @@ -0,0 +1,7 @@ +extern crate serde; +extern crate serde_derive; +extern crate ron; + +mod loader; +mod config; +pub use config::*; \ No newline at end of file diff --git a/config/src/loader.rs b/config/src/loader.rs new file mode 100644 index 0000000..115577d --- /dev/null +++ b/config/src/loader.rs @@ -0,0 +1,59 @@ +use crate::config::*; +use serde_derive::Serialize; +use serde_derive::Deserialize; +use std::time::Duration; + +#[derive(Clone, Serialize, Deserialize)] +pub struct QemuKernelConfigLoader { + pub qemu_binary: Option, + pub kernel: Option, + pub ramfs: Option, + pub debug: Option, +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct QemuSnapshotConfigLoader { + pub qemu_binary: Option, + pub hda: Option, + pub presnapshot: Option, + pub snapshot_path: Option, + pub debug: Option, +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct ForkServerConfigLoader { + pub args: Option>, + pub hide_output: Option, + pub input_size: Option, + pub env: Option>, +} + +#[derive(Clone, Serialize, Deserialize)] +pub enum FuzzRunnerConfigLoader { + QemuKernel(QemuKernelConfigLoader), + QemuSnapshot(QemuSnapshotConfigLoader), +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct FuzzerConfigLoader { + pub workdir_path: Option, + pub bitmap_size: Option, + pub mem_limit: Option, + pub time_limit: Option, + pub target_binary: Option, + pub threads: Option, + pub thread_id: Option, + pub cpu_pin_start_at: Option, + pub seed_path: Option, + pub dict: Option>>, + pub snapshot_placement: Option, + pub dump_python_code_for_inputs: Option, + pub exit_after_first_crash: Option, +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct ConfigLoader { + pub include_default_config_path: Option, + pub runner: FuzzRunnerConfigLoader, + pub fuzz: FuzzerConfigLoader, +} diff --git a/fuzz_runner/.gitignore b/fuzz_runner/.gitignore new file mode 100644 index 0000000..5f111e7 --- /dev/null +++ b/fuzz_runner/.gitignore @@ -0,0 +1,3 @@ +target/ +debug/ +Cargo.lock diff --git a/fuzz_runner/Cargo.toml b/fuzz_runner/Cargo.toml new file mode 100644 index 0000000..ed384cd --- /dev/null +++ b/fuzz_runner/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "fuzz_runner" +version = "0.1.0" +authors = ["coco "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +nix = "0.17.0" +time = "0.2.9" +subprocess = "0.2.4" +regex = "1.3.6" +lazy_static = "1.4.0" +libc = "0.2.68" +quick-error = "*" +tempfile = "3.1.0" +rand = "0.7.3" +serde_derive = "1.0" +serde = "1.0" +byteorder = "*" +snafu = "0.6.3" +timeout-readwrite = "0.3.1" +glob="0.3.0" +hex="0.4.2" +config={path="../config"} +colored = "2.0.0" +derivative = "2.1.1" diff --git a/fuzz_runner/src/exitreason.rs b/fuzz_runner/src/exitreason.rs new file mode 100644 index 0000000..2447fb7 --- /dev/null +++ b/fuzz_runner/src/exitreason.rs @@ -0,0 +1,46 @@ +use nix::sys::wait::WaitStatus; + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum ExitReason { + Normal(i32), + Timeout, + Signaled(i32), + Crash(Vec), + Asan, + Stopped(i32), + FuzzerError, + InvalidWriteToPayload(Vec), +} + +impl ExitReason { + pub fn from_wait_status(status: WaitStatus) -> ExitReason { + return match status { + WaitStatus::Exited(_, return_value) => ExitReason::Normal(return_value), + WaitStatus::Signaled(_, signal, _) => ExitReason::Signaled(signal as i32), + WaitStatus::Stopped(_, signal) => ExitReason::Stopped(signal as i32), + _ => panic!("Unknown WaitStatus: {:?}", status), + }; + } + + pub fn is_normal(&self) -> bool{ + use ExitReason::*; + match self { + Normal(_) => return true, + _ => return false, + } + } + + pub fn name(&self) -> &str{ + use ExitReason::*; + match self { + Normal(_) => return "normal", + Timeout => return "timeout", + Signaled(_) => return "signal", + Crash(_) => return "crash", + Asan => return "asan", + Stopped(_) => return "stop", + InvalidWriteToPayload(_) => return "invalid_write_to_payload_buffer", + FuzzerError => unreachable!(), + } + } +} diff --git a/fuzz_runner/src/forksrv/error.rs b/fuzz_runner/src/forksrv/error.rs new file mode 100644 index 0000000..c939e0a --- /dev/null +++ b/fuzz_runner/src/forksrv/error.rs @@ -0,0 +1,66 @@ +use nix; +use std; + +quick_error! { + #[derive(Debug, Clone)] + pub enum SpawnError { + Fork(err: nix::Error) { + from() + description("execve failed") + display("execve error: {}", err) + cause(err) + } + Path(desc: String){ + description("Invalid Path") + display("Problem with binary path: {}", desc) + } + + Exec(desc: String){ + description("Execution Failed") + display("Execution failed: {}", desc) + } + + FFINull(err: std::ffi::NulError) { + from() + description("argument/path contained Null byte") + display("Null error: {}", err) + cause(err) + } + DevNull(desc: String){ + description("failed to open /dev/null") + display("failed to open /dev/null: {}", desc) + } + } +} + +pub fn path_err(desc: &str) -> Result { + return Err(SpawnError::Path(desc.into())); +} + +quick_error! { + #[derive(Debug)] + pub enum SubprocessError { + Spawn(err: SpawnError) { + from() + description("spawning failed") + display("spawning failed: {}", err) + cause(err) + } + Unspecific(desc: String){ + description("Subprocess Failed") + display("Subprocess failed: {}", desc) + } + Io(err: std::io::Error){ + from() + cause(err) + } + Unix(err: nix::Error){ + from() + cause(err) + } + } +} + +pub fn descr_err(desc: &str) -> Result { + return Err(SubprocessError::Unspecific(desc.into())); +} diff --git a/fuzz_runner/src/forksrv/mod.rs b/fuzz_runner/src/forksrv/mod.rs new file mode 100644 index 0000000..2a20772 --- /dev/null +++ b/fuzz_runner/src/forksrv/mod.rs @@ -0,0 +1,246 @@ +/* +pub mod newtypes; + +use nix::fcntl; +use nix::libc::{ + __errno_location, shmat, shmctl, shmget, strerror, IPC_CREAT, IPC_EXCL, IPC_PRIVATE, IPC_RMID, +}; +use nix::sys::signal::{self, Signal}; +use nix::sys::stat; +use nix::sys::wait::WaitStatus; +use nix::unistd; +use nix::unistd::Pid; +use nix::unistd::{fork, ForkResult}; +use std::ffi::{CStr, CString}; +use std::os::unix::io::AsRawFd; +use std::os::unix::io::RawFd; + +use std::io::BufReader; +use std::ptr; + +use timeout_readwrite::TimeoutReader; + +use byteorder::{LittleEndian, ReadBytesExt}; +use std::fs::File; +use std::os::unix::io::FromRawFd; + +use crate::exitreason::ExitReason; +use newtypes::*; +use snafu::ResultExt; + +extern crate config; +use crate::config::{ForkServerConfig, FuzzerConfig}; + +pub struct ForkServer { + inp_file: File, + ctl_in: File, + shared_data: *mut [u8], + input_data: Vec, + input_size: usize, + st_out: std::io::BufReader>, +} + +impl ForkServer { + pub fn new(cfg: &ForkServerConfig, fuzz_cfg: &FuzzerConfig) -> Self { + let inp_file = tempfile::NamedTempFile::new().expect("couldn't create temp file"); + let (inp_file, in_path) = inp_file + .keep() + .expect("couldn't persists temp file for input"); + let inp_file_path = in_path + .to_str() + .expect("temp path should be unicode!") + .to_string(); + let args = cfg + .args + .iter() + .map(|s| { + if s == "@@" { + inp_file_path.clone() + } else { + s.to_string() + } + }) + .collect::>(); + let (ctl_out, ctl_in) = nix::unistd::pipe().expect("failed to create ctl_pipe"); + let (st_out, st_in) = nix::unistd::pipe().expect("failed to create st_pipe"); + let (shm_file, shared_data) = ForkServer::create_shm(fuzz_cfg.bitmap_size); + + match fork().expect("couldn't fork") { + // Parent returns + ForkResult::Parent { child: _, .. } => { + unistd::close(ctl_out).expect("coulnd't close ctl_out"); + unistd::close(st_in).expect("coulnd't close st_out"); + let mut st_out = BufReader::new(TimeoutReader::new( + unsafe { File::from_raw_fd(st_out) }, + fuzz_cfg.time_limit, + )); + st_out + .read_u32::() + .expect("couldn't read child hello"); + return Self { + inp_file: inp_file, + ctl_in: unsafe { File::from_raw_fd(ctl_in) }, + shared_data: shared_data, + st_out, + input_data: vec![0; cfg.input_size], + input_size: 0, + }; + } + //Child does complex stuff + ForkResult::Child => { + let forkserver_fd = 198; // from AFL config.h + unistd::dup2(ctl_out, forkserver_fd as RawFd) + .expect("couldn't dup2 ctl_our to FROKSRV_FD"); + unistd::dup2(st_in, (forkserver_fd + 1) as RawFd) + .expect("couldn't dup2 ctl_our to FROKSRV_FD+1"); + + unistd::dup2(inp_file.as_raw_fd(), 0).expect("couldn't dup2 input file to stdin"); + unistd::close(inp_file.as_raw_fd()).expect("couldn't close input file"); + + unistd::close(ctl_in).expect("couldn't close ctl_in"); + unistd::close(ctl_out).expect("couldn't close ctl_out"); + unistd::close(st_in).expect("couldn't close ctl_out"); + unistd::close(st_out).expect("couldn't close ctl_out"); + + let path = CString::new(fuzz_cfg.target_binary.as_ref().expect("forkserver requires target path").to_string()) + .expect("binary path must not contain zero"); + let args = args + .into_iter() + .map(|s| CString::new(s).expect("args must not contain zero")) + .collect::>(); + + let shm_id = CString::new(format!("__AFL_SHM_ID={}", shm_file)).unwrap(); + + //Asan options: set asan SIG to 223 and disable leak detection + let asan_settings = + CString::new("ASAN_OPTIONS=exitcode=223,abort_on_erro=true,detect_leaks=0") + .expect("RAND_2089158993"); + + let mut env = vec![shm_id, asan_settings]; + env.extend( + cfg.env + .iter() + .map(|str| CString::new(str.to_string()).unwrap()), + ); + + if cfg.hide_output { + let null = fcntl::open("/dev/null", fcntl::OFlag::O_RDWR, stat::Mode::empty()) + .expect("couldn't open /dev/null"); + unistd::dup2(null, 1 as RawFd).expect("couldn't dup2 /dev/null to stdout"); + unistd::dup2(null, 2 as RawFd).expect("couldn't dup2 /dev/null to stderr"); + unistd::close(null).expect("couldn't close /dev/null"); + } + + let arg_ref = &args.iter().map(|x| x.as_c_str()).collect::>()[..]; + let env_ref = &env.iter().map(|x| x.as_c_str()).collect::>()[..]; + + println!("EXECVE {:?} {:?} {:?}", fuzz_cfg.target_binary, arg_ref, env_ref); + unistd::execve(&path, arg_ref, env_ref).expect("couldn't execve target"); + unreachable!(); + } + } + } + + pub fn run_data(&mut self, data: &[u8]) -> Result { + self.input_data[0..data.len()].copy_from_slice(data); + self.input_size = data.len(); + return self.run(); + } + + pub fn run(&mut self) -> Result { + for i in self.get_bitmap_mut().iter_mut() { + *i = 0; + } + unistd::ftruncate(self.inp_file.as_raw_fd(), 0).context(QemuRunNix { + task: "Couldn't truncate inp_file", + })?; + unistd::lseek(self.inp_file.as_raw_fd(), 0, unistd::Whence::SeekSet).context( + QemuRunNix { + task: "Couldn't seek inp_file", + }, + )?; + unistd::write( + self.inp_file.as_raw_fd(), + &self.input_data[0..self.input_size], + ) + .context(QemuRunNix { + task: "Couldn't write data to inp_file", + })?; + unistd::lseek(self.inp_file.as_raw_fd(), 0, unistd::Whence::SeekSet).context( + QemuRunNix { + task: "Couldn't seek inp_file", + }, + )?; + + unistd::write(self.ctl_in.as_raw_fd(), &[0, 0, 0, 0]).context(QemuRunNix { + task: "Couldn't send start command", + })?; + + let pid = Pid::from_raw(self.st_out.read_i32::().context(QemuRunIO { + task: "Couldn't read target pid", + })?); + + if let Ok(status) = self.st_out.read_i32::() { + return Ok(ExitReason::from_wait_status( + WaitStatus::from_raw(pid, status).expect("402104968"), + )); + } + signal::kill(pid, Signal::SIGKILL).context(QemuRunNix { + task: "Couldn't kill timed out process", + })?; + self.st_out.read_u32::().context(QemuRunIO { + task: "couldn't read timeout exitcode", + })?; + return Ok(ExitReason::Timeout); + } + + pub fn get_bitmap_mut(&mut self) -> &mut [u8] { + unsafe { return &mut *self.shared_data } + } + pub fn get_bitmap(&self) -> &[u8] { + unsafe { return &*self.shared_data } + } + + pub fn get_input_mut(&mut self) -> &mut [u8] { + return &mut self.input_data[..]; + } + + pub fn get_input(&self) -> &[u8] { + return &self.input_data[..]; + } + + pub fn set_input_size(&mut self, size: usize) { + assert!(size <= self.input_data.len()); + self.input_size = size; + } + + fn create_shm(bitmap_size: usize) -> (i32, *mut [u8]) { + unsafe { + let shm_id = shmget(IPC_PRIVATE, bitmap_size, IPC_CREAT | IPC_EXCL | 0o600); + if shm_id < 0 { + panic!( + "shm_id {:?}", + CString::from_raw(strerror(*__errno_location())) + ); + } + + let trace_bits = shmat(shm_id, ptr::null(), 0); + if (trace_bits as isize) < 0 { + panic!( + "shmat {:?}", + CString::from_raw(strerror(*__errno_location())) + ); + } + + let res = shmctl(shm_id, IPC_RMID, 0 as *mut nix::libc::shmid_ds); + if res < 0 { + panic!( + "shmclt {:?}", + CString::from_raw(strerror(*__errno_location())) + ); + } + return (shm_id, trace_bits as *mut [u8; 1 << 16]); + } + } +} +*/ \ No newline at end of file diff --git a/fuzz_runner/src/forksrv/newtypes.rs b/fuzz_runner/src/forksrv/newtypes.rs new file mode 100644 index 0000000..edea5c2 --- /dev/null +++ b/fuzz_runner/src/forksrv/newtypes.rs @@ -0,0 +1,37 @@ +use snafu::{Backtrace, Snafu}; + +use std::path::PathBuf; + +#[derive(Debug, Snafu)] +#[snafu(visibility = "pub")] +pub enum SubprocessError { + #[snafu(display("Could not handle qemu trace file to {} {}", path.display(), source))] + ReadQemuTrace { + path: PathBuf, + source: std::io::Error, + }, + + #[snafu(display("Could not parse integer in {} {}", line, source))] + ParseIntQemuTrace { + line: String, + source: std::num::ParseIntError, + }, + + #[snafu(display("Could not parse line {}", line))] + ParseLineQemuTrace { line: String, backtrace: Backtrace }, + + #[snafu(display("Qemu did not produce any output"))] + NoQemuOutput { backtrace: Backtrace }, + + #[snafu(display("Could not communicate with QemuForkServer {} {} ", task, source))] + QemuRunNix { task: String, source: nix::Error }, + + #[snafu(display("Could not communicate with QemuForkServer {} {} ", task, source))] + QemuRunIO { + task: String, + source: std::io::Error, + }, + + #[snafu(display("Could not disassemble {}", task))] + DisassemblyError { task: String, backtrace: Backtrace }, +} diff --git a/fuzz_runner/src/lib.rs b/fuzz_runner/src/lib.rs new file mode 100644 index 0000000..181792c --- /dev/null +++ b/fuzz_runner/src/lib.rs @@ -0,0 +1,226 @@ +extern crate byteorder; +extern crate glob; +extern crate nix; +extern crate serde_derive; +extern crate snafu; +extern crate tempfile; +extern crate timeout_readwrite; +extern crate config; +#[macro_use] extern crate lazy_static; +extern crate regex; +extern crate hex; + + +pub mod exitreason; +pub use exitreason::ExitReason; + +pub mod forksrv; +//pub use forksrv::ForkServer; + +pub mod nyx; +pub use nyx::QemuProcess; + +use std::error::Error; + + +#[derive(Debug,Clone,Eq,PartialEq,Hash)] +pub struct TestInfo { + pub ops_used: u32, + pub exitreason: ExitReason +} + +#[derive(Debug,Clone,Eq,PartialEq,Hash)] +pub enum RedqueenBPType{ + Str, + Cmp, + Sub, +} + +impl RedqueenBPType{ + pub fn new(data:&str) -> Self { + match data { + "STR" => return Self::Str, + "CMP" => return Self::Cmp, + "SUB" => return Self::Sub, + _ => panic!("unknown reqdueen bp type {}",data), + } + } +} + +#[derive(Debug,Clone,Eq,PartialEq,Hash)] +pub struct RedqueenEvent{ + pub addr: u64, + pub bp_type: RedqueenBPType, + pub lhs: Vec, + pub rhs: Vec, + pub imm: bool, +} + +impl RedqueenEvent{ + pub fn new(line: &str) -> Self{ + lazy_static! { + static ref RE : regex::Regex = regex::Regex::new(r"([0-9a-fA-F]+)\s+(CMP|SUB|STR)\s+(\d+)\s+([0-9a-fA-F]+)-([0-9a-fA-F]+)(\sIMM)?").unwrap(); + } + if let Some(mat) = RE.captures(line){ + let addr_s = mat.get(1).unwrap().as_str(); + let type_s = mat.get(2).unwrap().as_str(); + //let bits_s =mat.get(3); + let lhs = mat.get(4).unwrap().as_str(); + let rhs = mat.get(5).unwrap().as_str(); + let imm = mat.get(6).map(|_x| true).unwrap_or(false); + return Self{addr: u64::from_str_radix(addr_s, 16).unwrap(), bp_type: RedqueenBPType::new(type_s), lhs: hex::decode(lhs).unwrap(), rhs: hex::decode(rhs).unwrap(), imm}; + } + panic!("couldn't parse redqueen line {}",line); + } +} + +#[derive(Debug,Clone,Eq,PartialEq,Hash)] +pub struct RedqueenInfo {pub bps: Vec} + +pub struct CFGInfo {} + +pub trait FuzzRunner { + fn run_test(&mut self) -> Result>; + fn run_redqueen(&mut self) -> Result>; + fn run_cfg(&mut self) -> Result>; + + fn run_create_snapshot(&mut self) -> bool; + fn delete_snapshot(&mut self) -> Result<(), Box>; + + fn shutdown(&mut self) -> Result<(), Box>; + + fn input_buffer(&mut self) -> &mut [u8]; + fn bitmap_buffer(&self) -> &[u8]; + fn ijon_max_buffer(&self) -> &[u64]; + fn set_input_size(&mut self, size: usize); + + fn parse_redqueen_data(&self, data: &str) -> RedqueenInfo{ + let bps = data.lines().map(|line| RedqueenEvent::new(line)).collect::>(); + return RedqueenInfo{bps} + } + fn parse_redqueen_file(&self, path: &str) -> RedqueenInfo{ + self.parse_redqueen_data(&std::fs::read_to_string(path).unwrap()) + } +} + +/* +impl FuzzRunner for ForkServer { + fn run_test(&mut self) -> Result> { + self.run().unwrap(); + + return Ok(TestInfo {ops_used: 0, exitreason: ExitReason::FuzzerError}); //TODO fix this! + } + + fn run_redqueen(&mut self) -> Result> { + unreachable!(); + //return Ok(parse_redqueen_file()); + } + + fn run_cfg(&mut self) -> Result> { + unreachable!() + //return Ok(CFGInfo {}); + } + fn run_create_snapshot(&mut self) -> bool{ + unreachable!(); + } + fn delete_snapshot(&mut self) -> Result<(), Box>{ + unreachable!(); + } + + fn shutdown(self) -> Result<(), Box> { + return Ok(()); + } + fn input_buffer(&mut self) -> &mut [u8] { + self.get_input_mut() + } + fn bitmap_buffer(&self) -> &[u8] { + self.get_bitmap() + } + fn ijon_max_buffer(&self) -> &[u64] { + unreachable!(); + } + fn set_input_size(&mut self, size: usize) { + ForkServer::set_input_size(self, size) + } +} +*/ +impl FuzzRunner for QemuProcess { + fn run_test(&mut self) -> Result> { + self.send_payload(); + let ops_used = self.feedback_data.shared.interpreter.executed_opcode_num; + if self.aux.result.crash_found != 0 { + return Ok(TestInfo {ops_used, exitreason: ExitReason::Crash(self.aux.misc.as_slice().to_vec())}); + } + if self.aux.result.payload_write_attempt_found != 0{ + return Ok(TestInfo {ops_used, exitreason: ExitReason::InvalidWriteToPayload(self.aux.misc.as_slice().to_vec())}); + } + if self.aux.result.timeout_found != 0 { + return Ok(TestInfo {ops_used, exitreason: ExitReason::Timeout}); + } + if self.aux.result.asan_found != 0 { + return Ok(TestInfo {ops_used, exitreason: ExitReason::Asan}); + } + if self.aux.result.success != 0{ + return Ok(TestInfo {ops_used, exitreason: ExitReason::Normal(0)}); + } + println!("unknown exeuction result!!"); + return Ok(TestInfo {ops_used, exitreason: ExitReason::FuzzerError}); + } + + fn run_create_snapshot(&mut self) -> bool{ + assert_eq!(self.aux.result.tmp_snapshot_created,0); + self.send_payload(); + return self.aux.result.tmp_snapshot_created == 1; + } + + fn delete_snapshot(&mut self) -> Result<(), Box>{ + if self.aux.result.tmp_snapshot_created != 0 { + self.aux.config.changed = 1; + self.aux.config.discard_tmp_snapshot = 1; + self.send_payload(); + if self.aux.result.tmp_snapshot_created != 0 { + println!("AUX BUFFER {:#?}",self.aux); + } + assert_eq!( self.aux.result.tmp_snapshot_created, 0); + } + return Ok(()); + } + + + fn run_redqueen(&mut self) -> Result> { + self.aux.config.changed = 1; + self.aux.config.redqueen_mode=1; + self.send_payload(); + self.aux.config.changed = 1; + self.aux.config.redqueen_mode=0; + let rq_file = format!("{}/redqueen_workdir_{}/redqueen_results.txt",self.params.workdir,self.params.qemu_id); + return Ok(self.parse_redqueen_file(&rq_file)); + } + + fn run_cfg(&mut self) -> Result> { + //println!("TRACE!!!!"); + self.aux.config.trace_mode=1; + self.aux.config.changed = 1; + self.send_payload(); + self.aux.config.changed = 1; + self.aux.config.trace_mode=0; + return Ok(CFGInfo {}); + } + + fn shutdown(&mut self) -> Result<(), Box> { + self.shutdown(); + return Ok(()); + } + fn input_buffer(&mut self) -> &mut [u8] { + &mut self.payload[..] + } + fn bitmap_buffer(&self) -> &[u8] { + self.bitmap + } + fn ijon_max_buffer(&self) -> &[u64] { + &self.feedback_data.shared.ijon.max_data + } + fn set_input_size(&mut self, _size: usize) { + //self.payload[4..].copy_from_slice(&(size as u32).to_le_bytes()); + } +} diff --git a/fuzz_runner/src/nyx/aux_buffer.rs b/fuzz_runner/src/nyx/aux_buffer.rs new file mode 100644 index 0000000..4443e2d --- /dev/null +++ b/fuzz_runner/src/nyx/aux_buffer.rs @@ -0,0 +1,215 @@ + +use core::ffi::c_void; +use nix::sys::mman::*; +use std::fs::File; +use std::os::unix::io::IntoRawFd; +use std::fmt; +//use std::sync::atomic::compiler_fence; +//use std::sync::atomic::Ordering; + +use crate::nyx::mem_barrier::mem_barrier; + + +use derivative::Derivative; + + + +const AUX_BUFFER_SIZE: usize = 4096; + +const AUX_MAGIC: u64 = 0x54502d554d4551_u64; +const QEMU_PT_VERSION: u16 = 1; /* let's start at 1 for the initial version using the aux buffer */ + +const HEADER_SIZE: usize = 128; +const CAP_SIZE: usize = 256; +const CONFIG_SIZE: usize = 512; +const STATE_SIZE: usize = 512; +//const MISC_SIZE: usize = 4096 - (HEADER_SIZE + CAP_SIZE + CONFIG_SIZE + STATE_SIZE); + +const HEADER_OFFSET: usize = 0; +const CAP_OFFSET: usize = HEADER_OFFSET + HEADER_SIZE; +const CONFIG_OFFSET: usize = CAP_OFFSET + CAP_SIZE; +const STATE_OFFSET: usize = CONFIG_OFFSET + CONFIG_SIZE; +const MISC_OFFSET: usize = STATE_OFFSET + STATE_SIZE; +const MISC_SIZE: usize = AUX_BUFFER_SIZE - MISC_OFFSET; + +#[derive(Debug)] +pub struct AuxBuffer { + pub header: &'static mut auxilary_buffer_header_s, + pub cap: &'static mut auxilary_buffer_cap_s, + pub config: &'static mut auxilary_buffer_config_s, + pub result: &'static mut auxilary_buffer_result_s, + pub misc: &'static mut auxilary_buffer_misc_s, +} + +impl AuxBuffer { + + pub fn new_readonly(file: File, read_only: bool) -> Self { + + let mut prot = ProtFlags::PROT_READ; + if !read_only{ + prot |= ProtFlags::PROT_WRITE; + } + + let flags = MapFlags::MAP_SHARED; + unsafe { + let ptr = mmap(0 as *mut c_void, 0x1000, prot, flags, file.into_raw_fd(), 0).unwrap(); + let header = (ptr.add(HEADER_OFFSET) as *mut auxilary_buffer_header_s) + .as_mut() + .unwrap(); + let cap = (ptr.add(CAP_OFFSET) as *mut auxilary_buffer_cap_s) + .as_mut() + .unwrap(); + let config = (ptr.add(CONFIG_OFFSET) as *mut auxilary_buffer_config_s) + .as_mut() + .unwrap(); + let result = (ptr.add(STATE_OFFSET) as *mut auxilary_buffer_result_s) + .as_mut() + .unwrap(); + let misc = (ptr.add(MISC_OFFSET) as *mut auxilary_buffer_misc_s) + .as_mut() + .unwrap(); + return Self { + header, + cap, + config, + result, + misc, + }; + } + } + + pub fn new(file: File) -> Self { + return AuxBuffer::new_readonly(file, false); + } + + pub fn validate_header(&self) { + mem_barrier(); + let mgc = self.header.magic; + assert_eq!(mgc, AUX_MAGIC); + let version = self.header.version; + assert_eq!(version, QEMU_PT_VERSION); + let hash = self.header.hash; + assert_eq!(hash, 81); + } +} +#[derive(Debug, Copy, Clone)] +#[repr(C, packed(1))] +pub struct auxilary_buffer_header_s { + pub magic: u64, /* 0x54502d554d4551 */ + pub version: u16, + pub hash: u16, +} +#[derive(Debug, Copy, Clone)] +#[repr(C, packed(1))] +pub struct auxilary_buffer_cap_s { + pub redqueen: u8, + pub agent_timeout_detection: u8, /* agent implements own timeout detection; host timeout detection is still in used, but treshold is increased by x2; */ + pub agent_trace_bitmap: u8, /* agent implements own tracing mechanism; PT tracing is disabled */ + pub agent_ijon_trace_bitmap: u8, /* agent uses the ijon shm buffer */ +} +#[derive(Debug, Copy, Clone)] +#[repr(C, packed(1))] +pub struct auxilary_buffer_config_s { + pub changed: u8, /* set this byte to kick in a rescan of this buffer */ + + pub timeout_sec: u8, + pub timeout_usec: u32, + + /* trigger to enable / disable different QEMU-PT modes */ + pub redqueen_mode: u8, + pub trace_mode: u8, + pub reload_mode: u8, + pub verbose_level: u8, + pub page_dump_mode: u8, + pub page_addr: u64, + /* 0 -> disabled + 1 -> decoding + 2 -> decoding + full disassembling + */ + //uint8_t pt_processing_mode; + pub protect_payload_buffer: u8, + /* snapshot extension */ + pub discard_tmp_snapshot: u8, +} + +#[derive(Derivative)] +#[derivative(Debug)] +#[derive(Copy, Clone)] +#[repr(C, packed(1))] +pub struct auxilary_buffer_result_s { + /* 0 -> booting, + 1 -> loader level 1, + 2 -> loader level 2, + 3 -> ready to fuzz + */ + pub state: u8, + /* snapshot extension */ + pub tmp_snapshot_created: u8, + + #[derivative(Debug="ignore")] + pub padding_1: u8, + #[derivative(Debug="ignore")] + pub padding_2: u8, + + pub bb_coverage: u32, + + #[derivative(Debug="ignore")] + pub padding_3: u8, + #[derivative(Debug="ignore")] + pub padding_4: u8, + + pub hprintf: u8, + pub exec_done: u8, + pub crash_found: u8, + pub asan_found: u8, + pub timeout_found: u8, + pub reloaded: u8, + pub pt_overflow: u8, + + + pub runtime_sec: u8, + + pub page_not_found: u8, + pub success: u8, + pub runtime_usec: u32, + pub page_not_found_addr: u64, + pub dirty_pages: u32, + pub pt_trace_size: u32, + pub payload_write_attempt_found: u8, + +} + +#[repr(C, packed(1))] +pub struct auxilary_buffer_misc_s { + pub len: u16, + pub data: [u8;MISC_SIZE-2], +} + +fn inspect_bytes(bs: &[u8]) -> String { + use std::ascii::escape_default; + use std::str; + + let mut visible = String::new(); + for &b in bs { + let part: Vec = escape_default(b).collect(); + visible.push_str(str::from_utf8(&part).unwrap()); + } + visible +} +impl auxilary_buffer_misc_s{ + pub fn as_slice(&self) -> &[u8]{ + assert!(self.len as usize <= self.data.len()); + return &self.data[0..self.len as usize]; + } + pub fn as_string(&self) -> String{ + inspect_bytes(self.as_slice()) + } +} + +impl fmt::Debug for auxilary_buffer_misc_s { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("auxilary_buffer_misc_s") + .field("data", &inspect_bytes(self.as_slice())) + .finish() + } +} \ No newline at end of file diff --git a/fuzz_runner/src/nyx/ijon_data.rs b/fuzz_runner/src/nyx/ijon_data.rs new file mode 100644 index 0000000..1a4490f --- /dev/null +++ b/fuzz_runner/src/nyx/ijon_data.rs @@ -0,0 +1,29 @@ +#[derive(Debug, Copy, Clone)] +#[repr(C, packed(1))] +pub struct InterpreterData{ + pub executed_opcode_num: u32 +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct IjonData { + pub max_data: [u64;256], +} + +#[derive(Copy, Clone)] +#[repr(C, packed(1))] +pub struct SharedFeedbackData{ + pub interpreter: InterpreterData, + pad: [u8; 0x1000/2-std::mem::size_of::()], + pub ijon: IjonData, +} + +pub struct FeedbackBuffer { + pub shared: &'static mut SharedFeedbackData, +} + +impl FeedbackBuffer{ + pub fn new(shared: &'static mut SharedFeedbackData) -> Self{ + Self{shared} + } +} \ No newline at end of file diff --git a/fuzz_runner/src/nyx/mem_barrier.rs b/fuzz_runner/src/nyx/mem_barrier.rs new file mode 100644 index 0000000..8c93fd1 --- /dev/null +++ b/fuzz_runner/src/nyx/mem_barrier.rs @@ -0,0 +1,33 @@ +use std::sync::atomic::compiler_fence; +use std::sync::atomic::Ordering; + +// we expect this to be a nop. +// but in some extreme cases, this +/* +use std::sync::atomic::compiler_fence; +use std::sync::atomic::Ordering; + +fn barrier() { +compiler_fence(Ordering::SeqCst); +} + +pub fn read2(data: &mut u32) -> u32{ + let a = *data; + barrier(); + let b = *data; + return a.wrapping_add(b); +} +*/ + +//compiles to +/* + mov eax, dword ptr [rdi] + add eax, dword ptr [rdi] + ret +*/ +//while the second access gets optimized out without the barrier. +//To ensure that reads/writes to the shared memory buffer actually are executed, we use mem_barrier to lightweight synchronize the values. + +pub fn mem_barrier() { + compiler_fence(Ordering::SeqCst); +} diff --git a/fuzz_runner/src/nyx/mod.rs b/fuzz_runner/src/nyx/mod.rs new file mode 100644 index 0000000..f452769 --- /dev/null +++ b/fuzz_runner/src/nyx/mod.rs @@ -0,0 +1,129 @@ +pub mod aux_buffer; +pub mod ijon_data; +pub mod mem_barrier; +pub mod params; +pub mod qemu_process; + +pub use qemu_process::QemuProcess; + +use std::fs; +use std::path::PathBuf; + +extern crate config; +use crate::config::{QemuKernelConfig, QemuSnapshotConfig, FuzzerConfig, SnapshotPath}; + +fn into_absolute_path(sharedir: &str) -> String{ + + let srcdir = PathBuf::from(&sharedir); + + if srcdir.is_relative(){ + return fs::canonicalize(&srcdir).unwrap().to_str().unwrap().to_string(); + } + else{ + return sharedir.to_string(); + } +} + +pub fn qemu_process_new_from_kernel(sharedir: String, cfg: &QemuKernelConfig, fuzz_cfg: &FuzzerConfig) -> qemu_process::QemuProcess { + let params = params::KernelVmParams { + qemu_binary: cfg.qemu_binary.to_string(), + kernel: cfg.kernel.to_string(), + sharedir: into_absolute_path(&sharedir), + ramfs: cfg.ramfs.to_string(), + ram_size: fuzz_cfg.mem_limit, + bitmap_size: fuzz_cfg.bitmap_size, + debug: cfg.debug, + dump_python_code_for_inputs: match fuzz_cfg.dump_python_code_for_inputs{ + None => false, + Some(x) => x, + } + }; + let qemu_id = fuzz_cfg.thread_id; + let qemu_params = params::QemuParams::new_from_kernel(&fuzz_cfg.workdir_path, qemu_id, ¶ms, fuzz_cfg.threads > 1); + + /* + if qemu_id == 0{ + qemu_process::QemuProcess::prepare_workdir(&fuzz_cfg.workdir_path, fuzz_cfg.seed_pattern.clone()); + } + */ + return qemu_process::QemuProcess::new(qemu_params); +} + +pub fn qemu_process_new_from_snapshot(sharedir: String, cfg: &QemuSnapshotConfig, fuzz_cfg: &FuzzerConfig) -> qemu_process::QemuProcess { + + let snapshot_path = match &cfg.snapshot_path{ + SnapshotPath::Create(_x) => panic!(), + SnapshotPath::Reuse(x) => SnapshotPath::Reuse(x.to_string()), + SnapshotPath::DefaultPath => { + if fuzz_cfg.thread_id == 0 { + SnapshotPath::Create(format!("{}/snapshot/",fuzz_cfg.workdir_path)) + } else { + SnapshotPath::Reuse(format!("{}/snapshot/",fuzz_cfg.workdir_path)) + } + } + }; + + let params = params::SnapshotVmParams { + qemu_binary: cfg.qemu_binary.to_string(), + hda: cfg.hda.to_string(), + sharedir: into_absolute_path(&sharedir), + presnapshot: cfg.presnapshot.to_string(), + ram_size: fuzz_cfg.mem_limit, + bitmap_size: fuzz_cfg.bitmap_size, + debug: cfg.debug, + snapshot_path, + dump_python_code_for_inputs: match fuzz_cfg.dump_python_code_for_inputs{ + None => false, + Some(x) => x, + } + }; + let qemu_id = fuzz_cfg.thread_id; + let qemu_params = params::QemuParams::new_from_snapshot(&fuzz_cfg.workdir_path, qemu_id, fuzz_cfg.cpu_pin_start_at, ¶ms, fuzz_cfg.threads > 1); + + /* + if qemu_id == 0{ + println!("------> WIPING EVERYTHING"); + qemu_process::QemuProcess::prepare_workdir(&fuzz_cfg.workdir_path, fuzz_cfg.seed_pattern.clone()); + println!("------> WIPING EVERYTHING DONE"); + } + */ + + return qemu_process::QemuProcess::new(qemu_params); +} + + +#[cfg(test)] +mod tests { + //use crate::aux_buffer::*; + use super::params::*; + use super::qemu_process::*; + //use std::{thread, time}; + + #[test] + fn it_works() { + let workdir = "/tmp/workdir_test"; + let params = KernelVmParams { + qemu_binary: "/home/kafl/NEW2/QEMU-PT_4.2.0/x86_64-softmmu/qemu-system-x86_64" + .to_string(), + kernel: "/home/kafl/Target-Components/linux_initramfs/bzImage-linux-4.15-rc7" + .to_string(), + ramfs: "/home/kafl/Target-Components/linux_initramfs/init.cpio.gz".to_string(), + sharedir: "foo! invalid".to_string(), + ram_size: 1000, + bitmap_size: 0x1 << 16, + debug: false, + dump_python_code_for_inputs: false, + }; + let qemu_id = 1; + let qemu_params = QemuParams::new_from_kernel(workdir, qemu_id, ¶ms); + + QemuProcess::prepare_workdir(&workdir, None); + + let mut qemu_process = QemuProcess::new(qemu_params); + + for _i in 0..100 { + qemu_process.send_payload(); + } + println!("test done"); + } +} diff --git a/fuzz_runner/src/nyx/params.rs b/fuzz_runner/src/nyx/params.rs new file mode 100644 index 0000000..8c5f3f4 --- /dev/null +++ b/fuzz_runner/src/nyx/params.rs @@ -0,0 +1,266 @@ +use std::path::Path; +use crate::config::SnapshotPath; + +pub struct KernelVmParams { + pub qemu_binary: String, + pub kernel: String, + pub sharedir: String, + pub ramfs: String, + pub ram_size: usize, + pub bitmap_size: usize, + pub debug: bool, + + pub dump_python_code_for_inputs: bool, +} + +pub struct SnapshotVmParams{ + pub qemu_binary: String, + pub hda: String, + pub sharedir: String, + pub presnapshot: String, + pub snapshot_path: SnapshotPath, + pub ram_size: usize, + pub bitmap_size: usize, + pub debug: bool, + + pub dump_python_code_for_inputs: bool, +} + +pub struct QemuParams { + pub cmd: Vec, + pub qemu_aux_buffer_filename: String, + pub control_filename: String, + pub bitmap_filename: String, + pub payload_filename: String, + pub binary_filename: String, + pub workdir: String, + pub qemu_id: usize, + pub bitmap_size: usize, + pub payload_size: usize, + + pub dump_python_code_for_inputs: bool, +} + +impl QemuParams { + pub fn new_from_snapshot(workdir: &str, qemu_id: usize, cpu: usize, params: &SnapshotVmParams, create_snapshot_file: bool) -> QemuParams{ + + assert!(!(!create_snapshot_file && qemu_id == 1)); + let project_name = Path::new(workdir) + .file_name() + .expect("Couldn't get project name from workdir!") + .to_str() + .expect("invalid chars in workdir path") + .to_string(); + + let qemu_aux_buffer_filename = format!("{}/aux_buffer_{}", workdir, qemu_id); + let payload_filename = format!("/dev/shm/kafl_{}_qemu_payload_{}", project_name, qemu_id); + //let tracedump_filename = format!("/dev/shm/kafl_{}_pt_trace_dump_{}", project_name, qemu_id); + let binary_filename = format!("{}/program", workdir); + let bitmap_filename = format!("/dev/shm/kafl_{}_bitmap_{}", project_name, qemu_id); + let control_filename = format!("{}/interface_{}", workdir, qemu_id); + + let mut cmd = vec![]; + cmd.push(params.qemu_binary.to_string()); + + cmd.push("-drive".to_string()); + cmd.push(format!("file={},format=raw,index=0,media=disk", params.hda.to_string())); + + if !params.debug { + cmd.push("-display".to_string()); + cmd.push("none".to_string()); + } else { + cmd.push("-vnc".to_string()); + cmd.push(format!(":{}",qemu_id+cpu)); + } + + cmd.push("-serial".to_string()); + if params.debug { + cmd.push("mon:stdio".to_string()); + } else { + cmd.push("stdio".to_string()); + } + + cmd.push("-enable-kvm".to_string()); + + cmd.push("-net".to_string()); + cmd.push("none".to_string()); + + cmd.push("-k".to_string()); + cmd.push("de".to_string()); + + cmd.push("-m".to_string()); + cmd.push(params.ram_size.to_string()); + + cmd.push("-chardev".to_string()); + cmd.push(format!( + "socket,server,path={},id=kafl_interface", + control_filename + )); + + // -fast_vm_reload path=/tmp/fuzz_workdir/snapshot/,load=off,pre_path=/home/kafl/ubuntu_snapshot + + cmd.push("-device".to_string()); + let mut nyx_ops = format!("kafl,chardev=kafl_interface"); + nyx_ops += &format!(",bitmap_size={}", params.bitmap_size+0x1000); + nyx_ops += &format!(",worker_id={}", qemu_id); + nyx_ops += &format!(",workdir={}", workdir); + nyx_ops += &format!(",sharedir={}", params.sharedir); + //nyx_ops += &format!(",ip0_a=0x1000,ip0_b=0x7ffffffff000"); + //nyx_ops += &format!(",ip0_a=ffff800000000000,ip0_b=ffffffffffffffff"); + + cmd.push(nyx_ops); + + cmd.push("-machine".to_string()); + cmd.push("kAFL64-v1".to_string()); + + cmd.push("-cpu".to_string()); + cmd.push("kAFL64-Hypervisor-v1".to_string()); + //cmd.push("kvm64-v1,".to_string()); + + match ¶ms.snapshot_path { + SnapshotPath::Create(path) => { + if create_snapshot_file { + cmd.push("-fast_vm_reload".to_string()); + cmd.push(format!("path={},load=off,pre_path={}", path,params.presnapshot)); + } + else{ + cmd.push("-fast_vm_reload".to_string()); + cmd.push(format!("path={},load=off,pre_path={},skip_serialization=on", path,params.presnapshot)); + } + }, + SnapshotPath::Reuse(path) => { + cmd.push("-fast_vm_reload".to_string()); + cmd.push(format!("path={},load=on", path)); + } + SnapshotPath::DefaultPath => panic!(), + } + + /* + bin = read_binary_file("/tmp/zsh_fuzz") + assert(len(bin)<= (128 << 20)) + atomic_write(binary_filename, bin) + */ + return QemuParams { + cmd, + qemu_aux_buffer_filename, + control_filename, + bitmap_filename, + payload_filename, + binary_filename, + workdir: workdir.to_string(), + qemu_id, + bitmap_size: params.bitmap_size, + payload_size: (1 << 16), + dump_python_code_for_inputs: params.dump_python_code_for_inputs, + }; + } + + pub fn new_from_kernel(workdir: &str, qemu_id: usize, params: &KernelVmParams, create_snapshot_file: bool) -> QemuParams { + //prepare_working_dir(workdir) + + assert!(!(!create_snapshot_file && qemu_id == 1)); + let project_name = Path::new(workdir) + .file_name() + .expect("Couldn't get project name from workdir!") + .to_str() + .expect("invalid chars in workdir path") + .to_string(); + + let qemu_aux_buffer_filename = format!("{}/aux_buffer_{}", workdir, qemu_id); + let payload_filename = format!("/dev/shm/kafl_{}_qemu_payload_{}", project_name, qemu_id); + //let tracedump_filename = format!("/dev/shm/kafl_{}_pt_trace_dump_{}", project_name, qemu_id); + let binary_filename = format!("{}/program", workdir); + let bitmap_filename = format!("/dev/shm/kafl_{}_bitmap_{}", project_name, qemu_id); + let control_filename = format!("{}/interface_{}", workdir, qemu_id); + + let mut cmd = vec![]; + cmd.push(params.qemu_binary.to_string()); + cmd.push("-kernel".to_string()); + cmd.push(params.kernel.to_string()); + + cmd.push("-initrd".to_string()); + cmd.push(params.ramfs.to_string()); + + cmd.push("-append".to_string()); + cmd.push("nokaslr oops=panic nopti ignore_rlimit_data".to_string()); + + if !params.debug { + cmd.push("-display".to_string()); + cmd.push("none".to_string()); + } + + cmd.push("-serial".to_string()); + if params.debug { + cmd.push("mon:stdio".to_string()); + } else { + cmd.push("none".to_string()); + } + + cmd.push("-enable-kvm".to_string()); + + cmd.push("-net".to_string()); + cmd.push("none".to_string()); + + cmd.push("-k".to_string()); + cmd.push("de".to_string()); + + cmd.push("-m".to_string()); + cmd.push(params.ram_size.to_string()); + + //cmd.push//("-cdrom".to_string()); + //cmd.push("/home/kafl/rust_dev/nyx/syzkaller_spec/cd.iso".to_string()); + + cmd.push("-chardev".to_string()); + cmd.push(format!( + "socket,server,path={},id=kafl_interface", + control_filename + )); + + cmd.push("-device".to_string()); + let mut nyx_ops = format!("kafl,chardev=kafl_interface"); + nyx_ops += &format!(",bitmap_size={}", params.bitmap_size+0x1000); /* + ijon page */ + nyx_ops += &format!(",worker_id={}", qemu_id); + nyx_ops += &format!(",workdir={}", workdir); + nyx_ops += &format!(",sharedir={}", params.sharedir); + + //nyx_ops += &format!(",ip0_a=0x1000,ip0_b=0x7ffffffff000"); + //nyx_ops += &format!(",ip0_a=ffff800000000000,ip0_b=ffffffffffffffff"); + + cmd.push(nyx_ops); + + cmd.push("-machine".to_string()); + cmd.push("kAFL64-v1".to_string()); + + cmd.push("-cpu".to_string()); + cmd.push("kAFL64-Hypervisor-v1,+vmx".to_string()); + //cmd.push("kvm64-v1,+vmx".to_string()); + + if create_snapshot_file { + cmd.push("-fast_vm_reload".to_string()); + if qemu_id == 0{ + cmd.push(format!("path={}/snapshot/,load=off", workdir)); + } else { + cmd.push(format!("path={}/snapshot/,load=on", workdir)); + } + } + + /* + bin = read_binary_file("/tmp/zsh_fuzz") + assert(len(bin)<= (128 << 20)) + atomic_write(binary_filename, bin) + */ + return QemuParams { + cmd, + qemu_aux_buffer_filename, + control_filename, + bitmap_filename, + payload_filename, + binary_filename, + workdir: workdir.to_string(), + qemu_id, + bitmap_size: params.bitmap_size, + payload_size: (128 << 10), + dump_python_code_for_inputs: params.dump_python_code_for_inputs, + }; + } +} diff --git a/fuzz_runner/src/nyx/qemu_process.rs b/fuzz_runner/src/nyx/qemu_process.rs new file mode 100644 index 0000000..2fd7e63 --- /dev/null +++ b/fuzz_runner/src/nyx/qemu_process.rs @@ -0,0 +1,387 @@ +use core::ffi::c_void; +use nix::sys::mman::*; +use std::fs; +use std::fs::{File, OpenOptions}; +use std::io::prelude::*; +use std::os::unix::fs::symlink; +use std::os::unix::io::IntoRawFd; +use std::os::unix::net::UnixStream; +use std::path::Path; +use std::process::Child; +use std::process::Command; +use std::{thread, time}; + +use std::str; + +extern crate colored; // not needed in Rust 2018 + +use colored::*; + + +use crate::nyx::aux_buffer::AuxBuffer; +use crate::nyx::ijon_data::{SharedFeedbackData, FeedbackBuffer}; +use crate::nyx::mem_barrier::mem_barrier; +use crate::nyx::params::QemuParams; + +pub struct QemuProcess { + pub process: Child, + pub aux: AuxBuffer, + pub feedback_data: FeedbackBuffer, + pub ctrl: UnixStream, + pub bitmap: &'static mut [u8], + pub payload: &'static mut [u8], + pub params: QemuParams, + hprintf_log: File, +} + +fn execute_qemu(ctrl: &mut UnixStream) { + ctrl.write_all(&[120_u8]).unwrap(); +} + +fn wait_qemu(ctrl: &mut UnixStream) { + let mut buf = [0]; + ctrl.read_exact(&mut buf).unwrap(); +} + +fn run_qemu(ctrl: &mut UnixStream) { + execute_qemu(ctrl); + wait_qemu(ctrl); +} + +fn make_shared_data(file: File, size: usize) -> &'static mut [u8] { + let prot = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE; + let flags = MapFlags::MAP_SHARED; + unsafe { + let ptr = mmap(0 as *mut c_void, size, prot, flags, file.into_raw_fd(), 0).unwrap(); + + let data = std::slice::from_raw_parts_mut(ptr as *mut u8, size); + return data; + } +} + +fn make_shared_ijon_data(file: File, size: usize) -> FeedbackBuffer { + let prot = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE; + let flags = MapFlags::MAP_SHARED; + unsafe { + let ptr = mmap(std::ptr::null_mut::(), 0x1000, prot, flags, file.into_raw_fd(), size as i64).unwrap(); + FeedbackBuffer::new((ptr as *mut SharedFeedbackData).as_mut().unwrap()) + } +} + +impl QemuProcess { + pub fn new(params: QemuParams) -> QemuProcess { + Self::prepare_redqueen_workdir(¶ms.workdir, params.qemu_id); + + if params.qemu_id == 0{ + println!("[!] libnyx: spawning qemu with:\n {}", params.cmd.join(" ")); + } + + let bitmap_shm_f = OpenOptions::new() + .create(true) + .read(true) + .write(true) + .open(¶ms.bitmap_filename) + .expect("couldn't open bitmap file"); + let mut payload_shm_f = OpenOptions::new() + .create(true) + .read(true) + .write(true) + .open(¶ms.payload_filename) + .expect("couldn't open payload file"); + + symlink( + ¶ms.bitmap_filename, + format!("{}/bitmap_{}", params.workdir, params.qemu_id), + ) + .unwrap(); + symlink( + ¶ms.payload_filename, + format!("{}/payload_{}", params.workdir, params.qemu_id), + ) + .unwrap(); + //println!("======================================SET NOT_INIT!!!!"); + payload_shm_f.write_all(b"not_init").unwrap(); + bitmap_shm_f.set_len(params.bitmap_size as u64).unwrap(); + payload_shm_f.set_len(params.payload_size as u64 + 0x1000).unwrap(); + + let bitmap_shared = make_shared_data(bitmap_shm_f, params.bitmap_size); + let payload_shared = make_shared_data(payload_shm_f, params.payload_size); + + + let bitmap_shm_f = OpenOptions::new() + .create(true) + .read(true) + .write(true) + .open(¶ms.bitmap_filename) + .expect("couldn't open bitmap file"); + + let ijon_shared = make_shared_ijon_data(bitmap_shm_f, params.bitmap_size); + + + thread::sleep(time::Duration::from_secs(1)); + + thread::sleep(time::Duration::from_millis(200*params.qemu_id as u64)); + + + let child = if params.dump_python_code_for_inputs{ + Command::new(¶ms.cmd[0]) + .args(¶ms.cmd[1..]) + .env("DUMP_PAYLOAD_MODE", "TRUE") + .spawn() + .expect("failed to execute process") + } + else{ + Command::new(¶ms.cmd[0]) + .args(¶ms.cmd[1..]) + .spawn() + .expect("failed to execute process") + }; + + + thread::sleep(time::Duration::from_secs(1)); + + thread::sleep(time::Duration::from_millis(200*params.qemu_id as u64)); + + //println!("CONNECT TO {}", params.control_filename); + + //control.settimeout(None) maybe needed? + //control.setblocking(1) + + let mut control = loop { + match UnixStream::connect(¶ms.control_filename) { + Ok(stream) => break stream, + _ => { + //println!("TRY..."); /* broken af */ + thread::sleep(time::Duration::from_millis(1)) + }, + } + }; + + // dry_run + //println!("TRHEAD {} run QEMU initial",params.qemu_id); + run_qemu(&mut control); + + let aux_shm_f = OpenOptions::new() + .read(true) + .write(true) + .open(¶ms.qemu_aux_buffer_filename) + .expect("couldn't open aux buffer file"); + aux_shm_f.set_len(0x1000).unwrap(); + + let aux_shm_f = OpenOptions::new() + .write(true) + .read(true) + .open(¶ms.qemu_aux_buffer_filename) + .expect("couldn't open aux buffer file"); + let mut aux_buffer = AuxBuffer::new(aux_shm_f); + + aux_buffer.validate_header(); + aux_buffer.config.protect_payload_buffer = 1; + + loop { + if aux_buffer.result.hprintf == 1 { + let len = aux_buffer.misc.len; + print!("{}", String::from_utf8_lossy(&aux_buffer.misc.data[0..len as usize]).yellow()); + } + else{ + //println!("QEMU NOT READY"); + } + + if aux_buffer.result.state == 3 { + break; + } + //println!("QEMU NOT READY"); + //println!("TRHEAD {} run QEMU NOT READY",params.qemu_id); + run_qemu(&mut control); + } + //println!("QEMU READY"); + println!("[!] libnyx: qemu #{} is ready:", params.qemu_id); + + aux_buffer.config.reload_mode = 1; + aux_buffer.config.timeout_sec = 0; + aux_buffer.config.timeout_usec = 500_000; + aux_buffer.config.changed = 1; + + //run_qemu(&mut control); + //run_qemu(&mut control); + + let mut option = OpenOptions::new(); + option.read(true); + option.write(true); + option.create(true); + let hprintf_log = option.open(format!("{}/hprintf_log_{}", params.workdir, params.qemu_id)).unwrap(); + + return QemuProcess { + process: child, + aux: aux_buffer, + feedback_data: ijon_shared, + ctrl: control, + bitmap: bitmap_shared, + payload: payload_shared, + params, + hprintf_log, + }; + } + + + pub fn send_payload(&mut self) { + let mut old_address: u64 = 0; + //use rand::Rng; + //println!("RUN INPUT"); + //std::thread::sleep(std::time::Duration::from_secs(1)); + //let time = std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH).unwrap().as_nanos(); + //self.hprintf_log.write_all(&format!("===({})===\n", time).as_bytes()).unwrap(); + loop { + mem_barrier(); + run_qemu(&mut self.ctrl); + mem_barrier(); + + if self.aux.result.hprintf != 0 { + self.hprintf_log.write_all(&format!("{}\n", self.aux.misc.as_string()).as_bytes()).unwrap(); + //println!("HPRINTF {}", self.aux.misc.as_string()); + let len = self.aux.misc.len; + + + + print!("{}", String::from_utf8_lossy(&self.aux.misc.data[0..len as usize]).yellow()); + //print!("{}", "".clear()); + println!("TEST\n"); + + continue; + } + //println!("pt trace size {:x} bytes",self.aux.result.pt_trace_size); + //println!("{:} dirty pages",self.aux.result.dirty_pages); + //println!("interpreter ran {} ops",self.feedback_data.shared.interpreter.executed_opcode_num); + //let max_v = 0; + //let max_i = 0; + //for (i,v) in self.feedback_data.shared.ijon.max_data.iter().enumerate(){ + // if *v > max_v{ + // max_v=*v; + // max_i=i; + // + // } + //} + //println!("found IJON MAX: {}\t{:x}",max_i,max_v); + + if self.aux.result.success != 0 || self.aux.result.crash_found != 0 || self.aux.result.asan_found != 0 || self.aux.result.payload_write_attempt_found != 0 { + break; + } + + if self.aux.result.page_not_found != 0 { + let v = self.aux.result.page_not_found_addr; + println!("PAGE NOT FOUND -> {:x}\n", v); + if old_address == self.aux.result.page_not_found_addr { + break; + } + old_address = self.aux.result.page_not_found_addr; + self.aux.config.page_addr = self.aux.result.page_not_found_addr; + self.aux.config.page_dump_mode = 1; + self.aux.config.changed = 1; + } + //else { + // break; + //} + + } + //std::thread::sleep(std::time::Duration::from_secs(1)); + //if self.aux.result.tmp_snapshot_created != 0 { + // //println!("created snapshot!!!!!!\n"); + //} + } + + pub fn set_timeout(&mut self, timeout: std::time::Duration){ + self.aux.config.timeout_sec = timeout.as_secs() as u8; + self.aux.config.timeout_usec = timeout.subsec_micros(); + self.aux.config.changed = 1; + } + + pub fn wait(&mut self) { + self.process.wait().unwrap(); + } + + pub fn shutdown(&mut self) { + println!("Let's kill QEMU!"); + self.process.kill().unwrap(); + self.wait(); + } + + pub fn prepare_workdir(workdir: &str, seed_path: Option) { + Self::clear_workdir(workdir); + let folders = vec![ + "/corpus/normal", + "/metadata", + "/corpus/crash", + "/corpus/kasan", + "/corpus/timeout", + "/bitmaps", + "/imports", + "/seeds", + "/snapshot", + "/forced_imports", + ]; + + for folder in folders.iter() { + fs::create_dir_all(format!("{}/{}", workdir, folder)) + .expect("couldn't initialize workdir"); + } + OpenOptions::new() + .create(true) + .write(true) + .open(format!("{}/filter", workdir)) + .unwrap(); + OpenOptions::new() + .create(true) + .write(true) + .open(format!("{}/page_cache.lock", workdir)) + .unwrap(); + OpenOptions::new() + .create(true) + .write(true) + .open(format!("{}/page_cache.dump", workdir)) + .unwrap(); + OpenOptions::new() + .create(true) + .write(true) + .open(format!("{}/page_cache.addr", workdir)) + .unwrap(); + + OpenOptions::new().create(true).write(true).open(format!("{}/program", workdir)).unwrap(); + + //println!("IMPORT STUFF FOR {:?}", seed_path); + if let Some(path) = seed_path { + let pattern = format!("{}/*", path); + //println!("IMPORT STUFF FOR {}", pattern); + for (i,p) in glob::glob(&pattern).expect("couldn't glob seed pattern??").enumerate() + { + let src = p.unwrap_or_else(|e| panic!("invalid seed path found {:?}",e)); + //println!("import {} to {}/seeds/seed_{}",src.to_string_lossy(), workdir,i); + let dst = format!("{}/seeds/seed_{}.bin",workdir, i); + fs::copy(&src, &dst).unwrap_or_else(|e| panic!("couldn't copy seed {} to {} {:?}",src.to_string_lossy(),dst,e)); + } + } + } + + fn prepare_redqueen_workdir(workdir: &str, qemu_id: usize) { + //println!("== preparing RQ folder: {}", qemu_id); + fs::create_dir_all(format!("{}/redqueen_workdir_{}", workdir, qemu_id)) + .expect("couldn't initialize workdir"); + //println!("== preparing RQ folder: {} DONE", qemu_id); + + } + + fn clear_workdir(workdir: &str) { + let _ = fs::remove_dir_all(workdir); + + let project_name = Path::new(workdir) + .file_name() + .expect("Couldn't get project name from workdir!") + .to_str() + .expect("invalid chars in workdir path") + .to_string(); + + for p in glob::glob(&format!("/dev/shm/kafl_{}_*", project_name)).expect("couldn't glob??") + { + fs::remove_file(p.expect("invalid path found")).unwrap(); + } + } +} diff --git a/fuzz_runner/src/nyx/tests/tests.rs b/fuzz_runner/src/nyx/tests/tests.rs new file mode 100644 index 0000000..17d0c4f --- /dev/null +++ b/fuzz_runner/src/nyx/tests/tests.rs @@ -0,0 +1,13 @@ +// Check hprintf works +// Check bitmap writes work +// Check input data works +// Check crash detection works +// Check timeouts work +// Check snapshot reset memory®ixters works +// Check snapshot reset timer works +// Check snapshot restet hdd works +// Check incremental snapshots work + + +// Check that all small edit distancem utations are performed in reasonable time +// Check that length extension is performed in reasonable time \ No newline at end of file diff --git a/libnyx/.gitignore b/libnyx/.gitignore new file mode 100644 index 0000000..f985e56 --- /dev/null +++ b/libnyx/.gitignore @@ -0,0 +1,4 @@ +/target +Cargo.lock +app +libnyx.h diff --git a/libnyx/Cargo.toml b/libnyx/Cargo.toml new file mode 100644 index 0000000..f88cb9d --- /dev/null +++ b/libnyx/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "libnyx" +version = "0.1.0" +edition = "2018" + +[lib] +name = "libnyx" +crate-type = ["staticlib"] + +[build-dependencies] +cbindgen = "0.19" + +[dependencies] +config={path="../config"} +fuzz_runner={path="../fuzz_runner"} +libc = "0.2" \ No newline at end of file diff --git a/libnyx/build.rs b/libnyx/build.rs new file mode 100644 index 0000000..173cb88 --- /dev/null +++ b/libnyx/build.rs @@ -0,0 +1,29 @@ +use std::env; +use std::path::PathBuf; + + + +fn main() { + println!("build.rs"); + let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR") + .expect("CARGO_MANIFEST_DIR env var is not defined")); + println!("CARGO_MANIFEST_DIR: {:?}", crate_dir); + + let out_dir = PathBuf::from(env::var("OUT_DIR") + .expect("OUT_DIR env var is not defined")); + println!("OUT_DIR: {:?}", out_dir); + + let config = cbindgen::Config::from_file("cbindgen.toml") + .expect("Unable to find cbindgen.toml configuration file"); + + // OUT_DIR doesn't appear to be configurable, so prolly not a good destination + // cargo +nightly build --out-dir `pwd` -Z unstable-options + // added question to this issue: https://github.com/rust-lang/cargo/issues/6790 + // for now, CARGO_MANIFEST_DIR (crate_dir) seems reasonable + + + cbindgen::generate_with_config(&crate_dir, config) + .unwrap() + .write_to_file(crate_dir.join("libnyx.h")); + +} diff --git a/libnyx/cbindgen.toml b/libnyx/cbindgen.toml new file mode 100644 index 0000000..785c30e --- /dev/null +++ b/libnyx/cbindgen.toml @@ -0,0 +1,14 @@ + +header = "/* This is a very basic example header file */" +include_guard = "libnyx_h" +autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */" +language = "C" +sys_includes = ["stdint.h", "stdbool.h"] +no_includes = true +usize_is_size_t = true + + +[export.rename] +"str" = "char" +"QemuProcess" = "void" + diff --git a/libnyx/src/lib.rs b/libnyx/src/lib.rs new file mode 100644 index 0000000..57fa7b9 --- /dev/null +++ b/libnyx/src/lib.rs @@ -0,0 +1,212 @@ +extern crate libc; + +use config::{Config, FuzzRunnerConfig}; + +use fuzz_runner::nyx::qemu_process_new_from_kernel; +use fuzz_runner::nyx::qemu_process_new_from_snapshot; +use fuzz_runner::nyx::qemu_process::QemuProcess; + +use libc::c_char; +use std::ffi::CStr; + +#[repr(C)] +pub enum NyxReturnValue { + Normal, + Crash, + Asan, + Timout, + InvalidWriteToPayload, + Error +} + +#[no_mangle] +pub extern "C" fn nyx_new(sharedir: *const c_char, workdir: *const c_char, worker_id: u32, create_snapshot: bool) -> * mut QemuProcess { + let sharedir_c_str = unsafe { + assert!(!sharedir.is_null()); + CStr::from_ptr(sharedir) + }; + + let workdir_c_str = unsafe { + assert!(!workdir.is_null()); + CStr::from_ptr(workdir) + }; + + + let sharedir_r_str = sharedir_c_str.to_str().unwrap(); + let workdir_r_str = workdir_c_str.to_str().unwrap(); + + println!("r_str: {}", sharedir_r_str); + let cfg: Config = Config::new_from_sharedir(&sharedir_r_str); + println!("config {}", cfg.fuzz.bitmap_size); + + + + let mut config = cfg.fuzz; + let runner_cfg = cfg.runner; + + + /* todo: add sanity check */ + config.cpu_pin_start_at = worker_id as usize; + + config.thread_id = worker_id as usize; + config.threads = if create_snapshot { 2 as usize } else { 1 as usize }; + + + config.workdir_path = format!("{}", workdir_r_str); + + let sdir = sharedir_r_str.clone(); + + if worker_id == 0 { + QemuProcess::prepare_workdir(&config.workdir_path, config.seed_path.clone()); + } + + match runner_cfg.clone() { + FuzzRunnerConfig::QemuSnapshot(cfg) => { + let runner = qemu_process_new_from_snapshot(sdir.to_string(), &cfg, &config); + return Box::into_raw(Box::new(runner)); + } + FuzzRunnerConfig::QemuKernel(cfg) => { + let runner = qemu_process_new_from_kernel(sdir.to_string(), &cfg, &config); + return Box::into_raw(Box::new(runner)); + } + } +} + +#[no_mangle] +pub extern "C" fn nyx_get_aux_buffer(qemu_process: * mut QemuProcess) -> *mut u8 { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + //return (*qemu_process).aux.get_raw_ptr(); + //return &((*qemu_process).aux.header).as_mut_ptr(); + return std::ptr::addr_of!((*qemu_process).aux.header.magic) as *mut u8; + } +} + +#[no_mangle] +pub extern "C" fn nyx_get_payload_buffer(qemu_process: * mut QemuProcess) -> *mut u8 { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + return (*qemu_process).payload.as_mut_ptr(); + } +} + +#[no_mangle] +pub extern "C" fn nyx_get_bitmap_buffer(qemu_process: * mut QemuProcess) -> *mut u8 { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + return (*qemu_process).bitmap.as_mut_ptr(); + } +} + +#[no_mangle] +pub extern "C" fn nyx_shutdown(qemu_process: * mut QemuProcess) { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + (*qemu_process).shutdown(); + } +} + +#[no_mangle] +pub extern "C" fn nyx_option_set_reload_mode(qemu_process: * mut QemuProcess, enable: bool) { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + (*qemu_process).aux.config.reload_mode = if enable {1} else {0}; + } +} + +#[no_mangle] +pub extern "C" fn nyx_option_set_timeout(qemu_process: * mut QemuProcess, timeout_sec: u8, timeout_usec: u32) { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + (*qemu_process).aux.config.timeout_sec = timeout_sec; + (*qemu_process).aux.config.timeout_usec = timeout_usec; + } +} + +#[no_mangle] +pub extern "C" fn nyx_option_apply(qemu_process: * mut QemuProcess) { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + (*qemu_process).aux.config.changed = 1; + } +} + +#[no_mangle] +pub extern "C" fn nyx_exec(qemu_process: * mut QemuProcess) -> NyxReturnValue { + + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + (*qemu_process).send_payload(); + + if (*qemu_process).aux.result.crash_found != 0 { + return NyxReturnValue::Crash; + } + if (*qemu_process).aux.result.asan_found != 0 { + return NyxReturnValue::Asan; + } + if (*qemu_process).aux.result.timeout_found != 0 { + return NyxReturnValue::Timout; + } + if (*qemu_process).aux.result.payload_write_attempt_found != 0 { + return NyxReturnValue::InvalidWriteToPayload; + } + if (*qemu_process).aux.result.success != 0 { + return NyxReturnValue::Normal; + } + println!("unknown exeuction result!!"); + return NyxReturnValue::Error; + } +} + +#[no_mangle] +pub extern "C" fn nyx_set_afl_input(qemu_process: * mut QemuProcess, buffer: *mut u8, size: u32) { + + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + assert!((buffer as usize) % std::mem::align_of::() == 0); + + std::ptr::copy(&size, (*qemu_process).payload.as_mut_ptr() as *mut u32, 1 as usize); + std::ptr::copy(buffer, (*qemu_process).payload[std::mem::size_of::()..].as_mut_ptr(), std::cmp::min(size as usize, 0x10000)); + } +} + + +#[no_mangle] +pub extern "C" fn nyx_print_aux_buffer(qemu_process: * mut QemuProcess) { + unsafe{ + assert!(!qemu_process.is_null()); + assert!((qemu_process as usize) % std::mem::align_of::() == 0); + + print!("{}", format!("{:#?}", (*qemu_process).aux.result)); + if (*qemu_process).aux.result.crash_found != 0 || (*qemu_process).aux.result.asan_found != 0 || (*qemu_process).aux.result.hprintf != 0 { + println!("{}", std::str::from_utf8(&(*qemu_process).aux.misc.data).unwrap()); + } + } +} + + + + +#[cfg(test)] +mod tests { + #[test] + fn it_works() { + } +} diff --git a/libnyx/test.c b/libnyx/test.c new file mode 100644 index 0000000..ab3b048 --- /dev/null +++ b/libnyx/test.c @@ -0,0 +1,100 @@ + +#include +#include "libnyx.h" + +#include +#include + +#ifndef HEXDUMP_COLS +#define HEXDUMP_COLS 16 +#endif + +void hexdump(void *mem, unsigned int len) +{ + unsigned int i, j; + + for(i = 0; i < len + ((len % HEXDUMP_COLS) ? (HEXDUMP_COLS - len % HEXDUMP_COLS) : 0); i++) + { + /* print offset */ + if(i % HEXDUMP_COLS == 0) + { + printf("0x%06x: ", i); + } + + /* print hex data */ + if(i < len) + { + printf("%02x ", 0xFF & ((char*)mem)[i]); + } + else /* end of block, just aligning for ASCII dump */ + { + printf(" "); + } + + /* print ASCII dump */ + if(i % HEXDUMP_COLS == (HEXDUMP_COLS - 1)) + { + for(j = i - (HEXDUMP_COLS - 1); j <= i; j++) + { + if(j >= len) /* end of block, not really printing */ + { + putchar(' '); + } + else if(isprint(((char*)mem)[j])) /* printable char */ + { + putchar(0xFF & ((char*)mem)[j]); + } + else /* other char */ + { + putchar('.'); + } + } + putchar('\n'); + } + } +} + + +int main(int argc, char** argv){ + printf("YO\n"); + + + void* aux_buffer; + + void* ptr = nyx_new("/tmp/nyx_bash/"); + + printf("QEMU Rust Object Pointer: %p\n", ptr); + + void* aux = nyx_get_aux_buffer(ptr); + + printf("QEMU Rust Aux Pointer: %p\n", aux); + + hexdump(aux, 16); + + void* payload = nyx_get_payload_buffer(ptr); + + nyx_set_afl_input(ptr, "HALLO", 5); + + + printf("QEMU Rust Payload Pointer: %p\n", payload); + + nyx_option_set_reload_mode(ptr, true); + nyx_option_apply(ptr); + + hexdump(payload, 16); + + printf("About to run init\n"); + printf("INIT -> %d\n", nyx_exec(ptr)); + printf("Init done\n"); + + + for(int i = 0; i < 32; i++){ + nyx_set_afl_input(ptr, "HALLO", 5); + printf("nyx_exec -> %d\n", nyx_exec(ptr)); + //nyx_print_aux_buffer(ptr); + } + + nyx_shutdown(ptr); + + +} diff --git a/libnyx/test.sh b/libnyx/test.sh new file mode 100644 index 0000000..dde33d5 --- /dev/null +++ b/libnyx/test.sh @@ -0,0 +1 @@ +cargo build && gcc test.c target/debug/liblibnyx.a -o app -pthread -ldl -lrt && ./app diff --git a/logo.png b/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..2643cb58d27407370105b4e758a84538e1ae7f09 GIT binary patch literal 253147 zcmeFXby!@@vNyVB1_pv_a0>~+2MG{-fCLHdA;=)XHMlba2_(UT2X_zdHUvxX;2KD9 zcb8n=ckg}nKIfkAxqse&zSV2Zs_CjHs{8Qfh?)}%5bNAe7`o~+%+SA<5-o(|>nNiKzk&%y^?~Vh`0RIaG z1~MT3q9G)AJYX@<_OBY;bCTC{0RSrDza9|Fqp+mARybH|y>xx4tR!OQXwPl(+R@aU z+tc3ZFBBl=DRM{Jo4cAYdfMALxQKX)KlochKYwYU0V|;KKY5CI8a%%-qGy+1km~+R=gWFTEzFj&82v4<7tg(0^V3sHdy7 z#lK5(aQSDm?ivXDiv#23=7IfhFmq4q{{!qV&i@g1XQTgW)_*I^)5Pf?pudgrk2;F| zRRfWi8s;vJc5Z*QMS@rG3D4aHH~zod_YbV9v$gr1h5mv4r~H5B{ZDzl z|Btf%lm9=l|AuNiSi4H_{j<3Lk^LX2zYHbvw}a|Ev$i*PaQUl+LQe(7VE-%Ue?`9h zH&TH2uE>8Q|AX@%$UFOs$T*w-H6XMc9qlCk-{V6J_CIC*2VD8inO~c@nmjXcHJ9My z;p64vy}S9fc!fls2;bctJiH=*bDoMJMJ`EWydSs#sBQ*(T(y|U8~YT76=b-_b)N*eZVzuUg%+k}e{S69uxT zxMcEpXgx-o&xhBUfN{WJfJ~G7&f!_Pi>1`L%9nzo*Y0tOO}^G^gQ;t@VKKEC*X=pJ z|1=HSITM+4Rpsr!%*;^e_i)J8z)~;0QEq-~IuDECTG+BYzAphbFPDW*%7b6NNwxl% zccFuYIT+Yt^hreHR4;po&SUP!iBIdi@a>Suu3Gp_Mc%Aq+f9kW?FiR?r=_dE&$ne= z<8;Hz7}lu2(>@8SQ(n##BXN4=@@=82U(s!$SeXk0$KhDZ7L|&eEpauS<+I|ix*4G$ z?|X=kPoAhV{+*27)EDtkH(62=z)}|KW>EA9dRG5nP_$u4bgxhEub&=c@5nZRDH=$!NG5J0c+`t^AzpaaA&q6DzKZdcUa_1B!XyJ|iIBFIe zy0Y5x+MTY-4^T}z8Dv^ecE_K|aZ02-#MZI>&#)lFU5-Cwkzk(v8uiEtBACC~G z#ad~6|HXWQvM3Z{spui1NIgo@8Tgj%AKhKv&*tQr)f#-k zzJ?2HE}s|_LtKF$?^rI68MwE?dj%THiYs^J&SZ_kP^m4H?~L%ilB!ZxY4SkZ!^}F#5IY?pZb!rG+J2WwjL_mDZ)p zl_HYb64)7(-6vMebi<+>>Bl{#j{L3+YPkv)&h{448%p)(Cx$PtkA^HA`tH{~iY26d z8r6UcbEODAY!AXp@^HC!tO+5YJDi-U{@#1*NJ;dmBZQFRY^hjKhlGQcAk{Fs;$t|C zkj~gm!xOm$8|khf_A@j;N`%tZ9?5 z4OvASKhArVAIZ#k)3s>HR(#(_=UU~j^L$^ls?XNQ_l_`fYc;>Eo$47OtF4!g(0ciZ zY~9mPv20?}#kECy+B~XPqD;Gg~FgaD;ZjY@i;eA|Crr-9{=6YdR-g$ef;&-b^ z4Rfkpw5ZNa{HDL^+g3P z!hl6ugRk!>jI7KP87bd##h3A5IjOktLi>$x1mY&R&|&1}l(k01#2?+m@5z;k)P;7Z z=3bbtHH<97cqq&@ZeC=;BPqIHG~T$D6^DaEG5w6D#1qy}KJ9yqddPiH6VJK&?ZKEY zMmt?1bn760;%^MgNO(y2UJt9BO9osES?t3&0DC^PEGDgYB&&1*a+2Wl038oS6pd$O zSUvV+Pb9<8T%(%MiTsOUHX8$2CfJQqx#<_1h;)44Wp9hxId& zvk2}s?lbe^>dFd|o(L*ZlWnk45GB;?J~&&=f+R;3`9M(UGr{PC_rge5osi$~&%}KR zRFI<52raoG-@3evV#L|gIJelfLxI~pgOe4Bc-4M1=ck;HY*cg|0MV1{Q0~{X&K>C?C)Fz_m)sp=2zWUkZb<8YJHIrGc}wGa>+C5latYh zT!@9rE)94o!TF?G`{ahEBdxG0+adx&#)T-mBI9vXQ`dc^-`0A^1|7-Tzs?~z*QdvJ z0BTQWzQ=^e@FI!@v{nOku;7!nMWYIa7t8e2B0W7lSF0kWEw%=w-C`yxHCr<^F|8_R zqipGRuVdZPYn=8TtJDXlJs--k3~Dc&+@iUz(x=B^755&~pnNOxIf}Ypif*5RZi`3B z4c!JsWJuI>Pm~swrC90pn)^l6@FEh3dl+T(v)!+JD`?5Q`k^aBVzWDat~+C)URuwe ze!T6nP^`%12w#}*;wv-k(BxHLOi|CcekW-u6wU2>tG-BP6z}3E$8pl+6}?yRsbWro zW5K+t&b@z(D$kqZkGk1`HH!8bT}kl-T6?uvXYak%;|z&S~pX#NMoOtc}&cTWsZfK zcxWfZxhR#(^KN#QbJ3?y*K>`?=P(jzdSxbhwceiIOW=_F;(tv=&my_&oa=N??3K!I z&#wlT7*9x^v*Uxk@kSrA#z8^dj}vM@B%fD-Ri=aq;GF`!0MtsmKZU3U(_9&(?2h0J zdUDiGNuHfa5U%27oz)gFA=9kwd=zJWi`_j+K!>nC@<7 zBa33?;`$v3uEr@iP>FEUf$96NleV|9_ILvsQQ)4y9M*dbAuV|1RWmj~Yi@WqNO8*z zHqAV7#rKI_@S;)SSiT$?fWKG-xfKAEKh-PL)O=3({fI6-w%Vc4R{j+hi|B}V?2HV~ z%O~{*-OJ0b5%!+->dXU`nX-b*)PN5{Fh?x^FlMlKwB{AU-ljJ_qOrX_c(9OjYc$DR z^EO9SN5af+-O`Urs9!JHS#ZHMoY#QxK59$(RN3+u{WsNjS3krjf^YaYexBfIl9Kw3 zJb;hN+Jo`mjvO33IH7)%orjF zMh67voD-}cm4#pKg>RYlY=de`qE_P~HJT4UO|&ehCB;g-e;rXx zP#-uc5xKqtZ1m&f)hmohjj)Y?c?@(B zZ}}RL-#Fx9T%WTSjNEeQI%w+2rK62lhj>Z(Th}iQ0tRbJUn{j&!`>Jc>(Yfm6LyC3 zrE$!@l4Duv;vm1`q0#T}Rfs9!mwIupGV)b=4#-*gMxE|1n*+P9&$Tn~r2*^YjA0!l6#S zJ7DC6l1#$;Fat*bj^;?3XmMP$!=j{&B=9mLh4;mh+sm1S$u$cL3o8n%D-qk$RglvV zxW7K>sf6p+i^QC=GFUz$7j^L5P?)fis{UkDVu1499xn6IwapelDBx*7uZP6Xk6UZ}>>x@cw|UW_WEFhlA+KYOwDnYIT!N>&gy$`rTdtc4+5 zlFW-C+()(|li{9%qi4T(^uxpWkAMC!p4Tyrnxsk=l}|dTT4BXJcp~p~zR3jYe%{LN zLT2B(K4&UTd~`5KP0^G8MBTWMmFJJ5Y2oezLrZNnq|i~|LcY<+ttq@MA&2nC?~~U< zJt)WG;(}A_9%I^s-{w=F@b@`LS~sJ%^a3B>*uR`uLoQy65b+zk#8QIe4j7z-+aq`m&_uMZ!ct+zI6E`@ zV4RWI4lxl^k!7=-?3{h@{iuR|yx3GMj}H9p0w}|X@4Q@D;|m6fUd$^kXpVFinkox^ z@yIziPiZtomF%hEFyRySfIk*1YhXWn@1Tx^r7k+i-s=LNVvSZtzNv!-o#4?lESK$b z#?~*-H$ly!Ty;#TBOaCO#exs@wojnFf{)n`zBYu(ChJ$tid864qgt9Ij&nuAx+1w< zlqDl={BBCBr!kgkCL98^bn*-)t#?w*!Y(NQE$$v)k6xvTbjcS>QwEg{ab3DRmWAS{ zTVwB9S0v24fdTm+6m3E7+m3Zhd8%>%Wyl&> zC_d@%w?{@SD>Oh(r$%uzuu819hN6Czei4(H3rMUQTFntE#5ytZ6M$xfBhzYLE!Wh- zPnZ@`iz>!@E4_`uuapN=nPP98PKxMDUy`Y1V-^TKyx>nDXPev-o^&=~;6f@-D#(aK z4)2E>=$q}3WoP&rvzDmbn2KT>ESrfdsncj!e(?9G3Nwp4{*)(t-uUU4E;n z^;?>sP*Jld26=|>YDK*35|4)2VrfODzqci=a8k@?7_Uk~Ra!9i=lhF12@vbOxY#sJ z&h^#x2`@fYc=rsI@B-A5G7`;N{uGDRc<8scPOGkX)=}K7+0T&{fc{f_L{_W*NRPdw z*@j`}j4mQRjB1fjehCMz>!n6i}Y*tn)0nz%s5wFlFRQ@;; zzZLL7;-2{B&t=T@e@?yV5CC;iBiGBG)1B)rcko*sY!zgKb&DAHv39frb-So>k z+$hniOh2I*Qz7jUZYWV; zys^e)n$|V=J_DY&tcma3g6iuB@&^a|lLTi)J~8~6zF6yad4Zm7xqkQ}7J(JKLYsBZ zC+0*rxkL%OMFdP&H&>og_7wG%$RNmCsg6#Q1X#5n;-r8vw?*A?ZZs#4qQK2CiYxKL zV^Q+OkdilcwUO6?s+Qxw8W3-%YbrPU(^Ox)OD)ngV%tRco_34BBqY?QQ``qX%^tBF zr|a8gC0u+fWDca`M-h@pe6nP*Zj)rjXB=wwmk0=_=I4R+Eu>=I=)o6k#(^Qcx!SF* zR$$qQ@YN~9rZPX#9vusCjOiZE2Bi8)V*bE2UP!Gi6uOUYeEA0rRU?i}6nGmM*P790 ziv55&sz*!-Ij*g-mFfZ-BBNaAjpt*HJ1QX`&aXprgrG8wl-cVJWm_CHM4sI3NCCf- zoP{0L_NYKmJqBxBCwR4&lk~$#NstmKJ=su*52Hlds)`X+#zh_Y4MRz3>ZuO(lmS`w zc9g^s4`ibEU9SbW9wq2Q`OOkO#NVB+K7yHoHD2e-sl|OZu3Op^kSk73f~k@K_HNH% zRyXFxVSTn|V83!{w2I-Ja#hpR16xB8`yg-`QZuY7Ntk_aG|^ zf$PKTlsNa|;vb9xe)w?>C!iQx`E4q8uT^0CyPRxB2gX>bqpwQtXSobQCu(M6dwXmA z8LA(_$aeSD7uLzn;j?z5DhTIBx6E9azDb&-mAbPO$4zMh?25!C^O051&T%2g-Tvf* zTdd0_W+3P~Zf*Jrq1dx|_{5ApxHleDy?NJB>*}`4R$?;)ELYr=kOgnV!d$dWs%@Y_Up*XCKe*BCA@X*JYZM|@a~o$KzzC! zCv-Y?Be?rIRDX#=o!Y^hRewC{T*Ew+ZcRl!d*1T!T4xM8EPM>psHyX768H?t*r@@X zKFO?=PfS^SCv5hS-Qhm^%zU-VS83y+8VoS%2OX{QFjB+z`J=)v62DfjlT_EdcHR$@ zGR9UD9fq1^kOc$5-xDG0qrs1(1Tziqe4a=`$hf8mkjeo}aM|Buz*(k!aQ3VV^~CZYknFr}0&|=c3eZFla~6Yqm0E_p_o=r| z_V6OFAFF@*i?Rcdd4ZpHKI%lB;M@*QJ! z*6|_?>8KYkwAJ&)u%=49o?!&AGE?GyP`IiH#3dc3RLcxn!9^axI}!p3Qf##J#Vti@ z+A%1ze7K|vmXe|>^?4{;2`4|jlA?Ym#)rv6(+@hQ*&C6LxpPxn;4=@DJ(LO_`qhov z{+w{$Pe^l^I|;v&s36i|;*x!*Z$;CXC9t+169d-!L1j4J9r+SN81&H?r+SRYf-$lm zX^HV(Bx>!k3fV1q{uOAo&N8eR+tofkn*?FZp?o{7;I^#JycjxRagsTgig5BVr34u= z-z{)qAHb)dJQetJ+KZ9knQ%w-NcD@>e)A={nTq}9=3`T+*2W@v^c@0qbFas70f_@+dyX9`$ZvIhY9Uqlj^2;B#gY*Wxjetf! zJg!hR`s(Y^s)aR7vE!?4^X`~%cClT>9|RUp!~}^Bt@n);a-wyc5+Q`Q0+-d+L2oU( zkd{2*sD4Zo@37%Vs*HX#i3}q@;CHQwru9Tenm3come``3d6>1Oe?)%hH()G9UKSac zKwtB*+Ct~ll354sdBKMiQ6G@35bET$o`{2-5_W?&qa*#)E{cpVCFE)}EZjmOn^$TR znYSXGer$QDPHa!a>bn^uiQ*Op6A#w=vOJ!auYCgNIxe1mc)dyrt9I8~L= z9eH;Dfe=zpc%n>bAEtF}JNel=eSTGJy@{!Dsh{GJAJ2EKOF**G?{Jj9UUZ~6s=R<1 zh#=d=tap*oIrZbo_X&{@J}37Zvv`aq{CFj19LZ_t2k_)sQ-mRrtr&-!gw3`N8Y*g$ zJ*P@4oISP9MJoL?J?qr%w+M46kyPPXOi=If=u-lcR+PZuAIK*c>$!ZUXzw=UM;v=ajU(@1&`tHrV z^%P78eI=%5X5!$@o!EI!ia7A|;dc4p&$vXZKMu&SF{I{Wz1gXHd6 zHiZRDa!LJ_iT9wrolECcnE^+|Q0v#4>H*ZjsyT8yM8*g@H>Wgr*WC^0O zsIfQus4%yPG`PQMQoeeH-w&!P3ZcYOjDw}~5c1sn9Xex5U4oyNIbZ3`#y&=md?nqs z@@PD{!x*&K&*pQ_eBe2C_qQ}-^PaHA_cLG_NeK=}%y7oMDVV{$+HqzhK@I z9dllArw5Yi{Skj%7Y(JIYI(C0PmdN-2dNzP{@K&H2o|t4lrp`ltil?49Ae1q=BU+_ zQa(054k^Ht?ckGEdL41Yd8oNhI-DX-cy<5b5nOd9r+1ocy;;DbF88yxJm{xl=tY0i z71_%CVmHA$397ApPqS@))YeEq(h$2XfUHDnh5;1hwCW;%sZHKiZdDmuk!+ayn2h6X zhtjUxHt6n$RT>3SgyHJR;z@aY=zJ6RqS@8x2QKIoOnHtng_4Na$CYBHExG4p8LsLK zL)Zlj1fd_*G0ug=&qJxO@q!TM8$Bd-^*hvus@nz~U!MQ*9C&#e2C9HUDVa-=iP$Mv z2jbRO%6O^5gz+_CPVE7g2SjTZO!82=!+}IB17S4LDyo8j8693;I-X>LK|%@$j8+g~ zZm(3R<&U)Gl`JzGgJJAHVzD z8nJGbLCDF9_;g%4w}4>2n|O1P2#I_~h@F3M42o$@IHZy4jm&WT>BR$Z zmP2URm!db{vB!x(u6Y8Q+#3?vE1jNJYm#z?Yrj_3JU=*%d8M?xh=x z>BnKM9`2U8-n2{U&SO^3NCxA!uryxfAL8Vor56`$gXrn2uIJxh7+I@ow{=sX+f0Il zPYS;P{!AH&R?D<&yXp>~01|<=gw2Mi_#O30gc&~-#CM!m4s^-n7zU3$K45%&NkAg; z83|>>2C49H1CmDOFOS66HMwFd55Rt6GvlLQm|QWUHrKIyg$+alTfZ32h4LsWAs71q zBl|sV}8cc;5j*apEyc84>VIL__9U9fTao&y*k`(kWyf`TM0&WZ8 zAl#JN9D+KnC#QYMb}u#8wr2RyVmc{@VK=T9fi+AjidEAJq@($oZ%}@R(DT4IW0y*n zNQC_P{WWO4)+>tpG_EhsO6x^+?voO2dC6}onI^ztapK>erz-8|0LiFkz{t4lNmy-9H6SdfLNr zYh2e4UtpS*BbFf(TeT%BJHM6XOUf?Q@+&pQsiKMzPYZu_ucJ1TMd(!$%tZDs7&JE- zE5yUn1bHyrZK0Jmmd)KW)@b@eX>aVEc7_b04-1!A8|gS-`gElkBzC+)8$|3o8KdyA zWq}=JKNKZ})Ye7*Vc? zlj|^nJTLmMrUxINBnWMwp6J0u+cwuknow=Or?A-NOXB z?|)j;ds`r@sxD`KBa@r4o69fK?qQo3W3_UT$6b>f-#f?BWDJXEfumI!h`SG8WU@LpmFd#Zbuv*A z9W{r=eN3;$xTU700y#VzFr`Pjbo)S=B6`G0gORx3@X&K(9Ykn$k`-*7A$|;HO7J*V z07?f|iVVkGy!Uj>^wCGWYxlB7M1}GT+yS^T#xl>#32aZUbA&$(J)jHIK+zVIoVQ|OBl(L#oFU6FyYQ5;87NY%-kj>k< zzLi86GM)Fi;kRM~;c5Bj$OuP-+;6$Le1~RP*P5^aJsb4_)iP?-OB=i9jv0~XOC5Q8 zdCHBJ8oxfnh2t?>-&-2xM!FG~Ms> z=5z(6z_`pDnvci2Eg4Z-+T<+gqDNN6!g-;*53wv%zXEf&vMH5Sz`Prt9X(Q6sMG{M2KfJ*@0zZ0pA zz4MT~)RRkOxR~#KCc#wFO20!ISSf*SaxWIgIA1KhYwdgqk&7t#q{xGn%S6J6pm%?e z-7jgv08z@?VI8WN!0Zfb3}YMpZA~k;8wjK^cxAvujT)3{7zX&gd;%~L&}|N251Yig zpM)x6#jTAIkM8=GRc>xC_UX`56l;2?slgp%T}$k6I4wHTc83}aA}$`xH&G1vx87jd^;R2eWoJAr%>xjzAvfyG`r6=dM;CD}L z8P}0j9hbXR%;Np4n5?6^%IERcOUIG-;Ss)@FU1yQ)V3k;m3(!W8Qgv;j%WiuSHwV5VTI`?VlSOV~io(#~a$VraGY?~t z!kyT^5@!=T{nUk{%Pe`J8Og**!H+yo`S?cC67B|ogX@#w$LO}_p^lu)m7q#PF(^GsQThcXfG=x7RD#a9&42$ zi54v#PwWgX?t$n~J{YkMiQx?T!!Vo+&BOAfXSh1 zBgsNgW+uhDg484?3cCFOo8T_oW-!-C3qJ_R|H*zH11fI~ z%B&z~TtfykO;HzGf>_eYG_N!kLcP?89*jb#&Sf)+ovbhp-81nMw-d4MMrso=R1%bB zQk!j^L914f`~~Bu^K6}C{uG<)W@M^vEgM<6fMrM|y*;hCcZvUY=fUN@tOsdN-&FdiXwA~9mTyF>d>yy2 zd#!0^mTc$k9XyY%KmDX1xU{AWN|Mf5Yjg;9|6(bJ2tXu(oNfR~`Z%wE?8xdg!s9bi z{5nYn+I2@lJiJwzAjpnM;QYEl)BUEC{m-Y3HMaV_j&tR$4JNO}-$dSY!=+7mp$76# zOY^Imd*_hsANdl?u7-(M_FGseWODM2r=Ig8!lg6K;ey@}_(%ZU8;=?|^lc>vT;XK(}t>ZM2@W(<{Vh8hzy{H8w^0{Kl4)lyvo5e)Hza92WcdLD-k0%Hj%QRl_2G z5#1cWOMSY;$*5|EzGlsLf80!eS_>eUHu`E1et6gBM~{PPvYN_l6=@h((Z#o3L3%Bh zM=VvoLW|jar)bz#^J#$zICahvbjc2pU8xl3KdI8-QM^HOnfQdnld+rsJe>Yv*0ZU) zpxB(V_CB(pRkhd!88e%sVl?02f>OP`YBu ze9#b|4HoTU+*vl&dXPH2#oo(|?0s~b^-b`^a|#Cs=Rt!?bH$@dMObR9-E1yD&19s! z^XVVOeqdRxlpd|JPL3Q%`v`OA#9beUX;x={V|K`21;zb6;?)$Nq!$2({ zNwc@tR`K+Mq zK3QMvi@qCMnQmPx3Cakc6K%~h&x^jtj{aRIF|*tauG9{^;Mm*@N^4_mr9&7$a2F+9 zAB$_9kO(CPL`V(FgjEj%7J|$GR$pL%r zPv!U<9erGct%8t38$Tf}aB=xR1spmp!NPL{0!`*N+tP@xwj%cdSo z5te89VALszy^~sp`uA49^CnXIwaqJ?Z7$*e`{TNnB0B%0E|WjszZSe+8v*-A)JF)Q0(Fi4gp?3VB z5VFpLh4kkkd~zWY{rK(cBw}Q8m)~2r;!raT&&5x&fHE?kkbvN`EF%MhP;f@GX@=c> zW8B|*GXNKjT|~s{toS;G5AJrbyr@VRyq#z}%il6TP2=Ql4HZXUT=)=>?>WpvH?t%B zo5|%Q>2t4>x_!GQ$|SCyO10P(@0IyWxbAg_PeT#9W__ct4EkUn(j{h+VDi^bPeHe1 zLr{M-Mb(qr*Yf8BEbO*($$o(<3gB+4Jf@Dh1J zOG~6DkI#0t7<@JhQ9bFtHj8WzFD*|cC(q_^VaF|=>uQiZq{+rhJj_m%{m<$`uY-6l z{se~>Pm9?{`j*^H$DcMhxSMEMejOG@yKPOOzVm}AFL3ja4Zm)b-hnGxWZ`b}VL5LyiRx_L2pDr0uIX-$+BfM zB=eE(KY9`(^#)&^gK@ZL){O2vG~`qRem z`i{O`o$l3`c9`K@3r~3^CNijoBRih}C}PGTOIsC`?_<1&4Uc%Sz>XZF4uhyM$Os=P zun9II!wN%DMdhdl4AaR*H9x_6!F=8)b{B^M7J`TuX(pCU!@ir~b#jg+mw&Mk{Fbcj zPvj;!_+=U?oX9&W{Tid66U`@0Un;QJEQ|DmcB-x4Zfkj(#2pNLpXH?KEEv*j zXC}Z3ecLA|tSzLv4b&t=-o*F76phtS0`rAAng_?db=U4N|-p@^ljbEG~QT&?hfu zfH>m!i88hq4Ua)B4}A}bkG&3b+Yxy1Nw!6bDHnSUK~8E0N8cs=1-+v<(Le6Xw|kOL zT$jJ84>*3Nl%NRCH)CT(ul40WFjQI4Z(M0V22m z@EqutRz%B9g928%0M?bIs#dU{gdN1FmEV+FOq1vd#=cRLzZ{{vVeV4$^Okw0n*EBE6 zhfuT)BuNqgUGK{dV2tTyVBiLo=Gf)ZH>>a9?w8sL`owwtqFx`3^v#>s?yrcP^wK(m zTz@*A^~(@AGJ#@m`v2sFUN;8-0m4^qI*|3tMnT*)&J_Vxmajni0p`9wgLpD8aCoTu zR?=md9||we;-ik}&g_t*#v=S{dJ@Dy;J+n$R^nwm)FE>?W*OniDT7mDlHWpu@Sk7a zGCJCfsmq{?qB0rn4j*93SvKa|XGEOh1ML^BNft;szFb8 z6G${u#r{`Lnz2KvB+RTx^!J!FVr&agwPu$MDA9*kdTwOfg}Vy4!WA}Rqb7~K+q2R8 zoQT8`)_INE^A(9F#$2sAb4gzr>N}h_@x3syoV>!)@LAc8za;O9WO%dkI&As^^V-hG zhQMD*!($YDYpRf*<8B5xd2~-K40nq;d-3^5-Y8d6)broXiJ48!hUEUR4O0ZE;ZlP) z?Zc+e1Zr`vO@Zc|AwT0YOBKuT?hjU8P>ffK$#+b^xon={3Asu3mn9E^g> z$bQV;j$^L@Ma2NZ` z@Bj{|Rlr{hmJLlGaDGeK?$4Ip*@c#X z0hgh+VUPDKo;c-83W>L0Tye@bw0uUp@k>jelK*rc4JUQ>mpwdr z3RJSrhEDfxJP|9by)?3JP`T)h{@Z!An7}KKhbw+wvADUs|-PoaUKaVY;~=*v1TueXFr%uO)w@ad0$v3@0d- zl0=KeL-v!479f%pwwInChllv_1!Z3WG#nxDy|KrCfS7ab!6e03py_kEXUqInAGb_iFtarc$v2R-m9D&xUXyObNJgIh!f;kh6>re33P@~GnnA;m$0$_tI zg|I^K;&|kN#nl>n9$khDX)?J|pyN{LZW2~bzzO~d_|*7*xjzo$>$8VP$WrP=85(rG zX${&J^tS%K;TlFj&2&X*o2clGbg3!{sTxzyN49->m7azi^zWS;592);-tB>l=1gi` z;|n+gQcdxy|GO%D=mSMXm(7HMyDTd=$Ks=^Mv^THX9IC;fg+nvN`W>@FwSCvX8PE5|D*ji%mEU33h+ZZ7X35+ z@SyjruqrjE?HTc_iHLNuAD+L^?YBKWX|&g~j=nDQb$cz2=Up8kZfzS+BiZ2COQ(_Z zzDMW!3)gu|u%^q+Lat<33JbRs={N;K71U;l^8ybQ4_uCe7)4pFEP%^6B?#CDzTgY$ zB?toBz{Se=Kw*)*?FIZiMkp($kagI4cAq!s_tbZ_9KJ&`&=H_!pBC6hw zCn3mq44U%v*A2vpi1yb70fT!9S@~Ljdce;W{n~S}qqP-rOjA~qahJ{ag|Go`eQ_mt zS?e367YR(5+obxzXKqGwBc|;Prm>RwB^(8+Oed3PL2vb2veUtr<#qM;bDG5$_TKh} zl4wFtv3tD#Ity?(sk|A9h8g#C?>QZko|Ag&AlWt+0MVlB!m1UY7kYh!1(WI6SP%V~RV3>s7Lmjh}@t2QaTchn^LCT=HMFq8ZQ$b&`Fzoxr)zy-yMv{#56gnKQO; z$LZ?#+Oa~~t`>uA-!}^#Kg@Ku&Stwip+$#-og)jI74#d$7gGA^yoA40H@E-sL-Chp zuusB*+IvT(*HB<0gBW-%)1upE`wn?_ov(UKs#atkRQt9ZGQ$U26zlLjB3@KkevEWS zUty^c*h}d%27nVGI^Es_a82{yIKO!c;=n&RGcKO$V_2@f8a<@4A`WhfvyEXA#+H>` zeAt#}5C&90CMw$1rgSrO0jAw|Y@son#Te)R4^8LcPxTl7@z1^XUfDuf6@|#=Udbpz z(z33|$Os|C9jMGuvNEm^3L%7ydxh*SDl)IV$2G6(uAlGk_xSw_pL0Ivyx*_a>-{`6 z?W1qjRls|jmojTXXaDwU^~dTy&VhcncrWa?@fG(YM}w&C_hk(?UypF3Vv7 z8Tn4PTe{SFt}nAZ2-v@^BK7mHnk?emd8QQ>z3#)BFH(0P6MJVLPPpqcuQ@>1kb4XD zdNWqMQcNu$WPs#9$*5^)9q+Ew+OpiID-<~N+d!fA0&90&LaHWrAQ@{QmyBqVnkuyP z*Gq5o^IH}sxL&S+P}-%q;XB?idpeMhL8J7#V*4{tQlCG%IG zjlf4p1Sns!IAR4K9h8gM@}6l1L~!wj5UcxFSK9FEjNf^lJywy2hB5Kk^cLUR1Z74g zX#gh9zFo5Uz|~zYE$BFc7FG+g?>Opz%4>VNgxg%Wsma*|tT&WShDDm{q-TNyBO&#- zXnIOgEfhs>^6IF_yu_8AhS(+H_M?%igY{B?PN;(7M-HrJZA}gN4ea;c9v1Fu&aikg z4DQ8yIY)M3m9q^{k`kmu5I_kST%UhE#F8(}j~Qn?eoK4fFZ(xp6TN)V0{FV^-O5c6 zPtEr>t56m&VkFy)2W+MGqDfvM$mP5`DRPH`rapnH-#&g$VeH_8vyNo~m}2eIUby}Z zrhgDQ;Rm7A_&uLz`$I4zYwNPR%TrA~4ACYh_tJJD!-Xq!0Mo;J0q$KB3aVuSh*&?d z$Qc%CcND%qv4UL%i4yXn>$rnNKru*^I+F{yNU$mmBxHrfq5*qGe#V6%&Y6{*`I%4W{%trXbd@ zoPmd;7u(5p74_=)%a~mczP%Qkzk(i}Bgh4_*SC;gxTd(qy0tGLw;?4ZM>|__$^IkFS(i-5&qxnCaNzPx|4R>UN2R zciuMJ;z!<=vNBSWUH?fZ%@o<$aOQk44gB2IrZ%DyvD*>KP)EZ$;%SHD$`OlY>s@&W zv1zwpsR;Qbx%8xrCMG-UDyD+&#}hBkRJKHXAB>KEZ98wTVJ0aBnu7gdPO0a5 zrNSg81EtT1&lIvg^JZAF$}l$NwZ%V(aWaX}4*xc=mUAIJ2Yg6UBHh7tar~NHO}@yL zM*nr$c+SJ7sAc3Z!-ynge|X~uk4HufWDOxTXleryE~_DizdLSuE)@r1+pVPo$?jP{HbrF(MaY%>648HyL*sbyB!JRME&eYeVMd$u6qJIN9H(c)4INY5*Dfx z%>*J1{F25$2=fr}dsqhVt?$da-n5K872`S|AQh)enI` zURzl<2q<)&7C+rM-({5oSxpMa(?U!>^tz?5T4dQ!*p=MqTI3>mx9`klr{=|iC2tt@ zb1G!#^S#&fe-|}h!>S(2yr~>xU>|_0@P*1_=hzvMCtRvsKGsCwcj!e_I-3|Od{C$= zL=Eh~9|jp_cmSvdJ*XMC&cALR*jq|j;Q6O`B}~cy@W2RpMZ93;%#A_bo!6waC=buDnc4c@3?MCN`Cz!{o!g@M@O6iqr<@-#Z00hOsOq2_dpx`XP;?aExmwV^ z=^dlNGd3jF{Eld3IivVo$fI$flRNX3pY%Kb)Q>GcSvk+86*|vKo1JRA;@#izVc_L+ zZPu-mn%C7etfslinN^}g|Cc+sbaL!d$pVjOfyIWD*X^fY&O4)f8(ZVZ$Z6sOdIcr$!uEoW?o{A$OOiq>2!c zO=Bd`^Qs9wnhe2w%|lNfU_d-(;5_o>#=_j3qLzSek&0Q(N`!2owk_=$%%@U!nmDG6 zeB6$Xpa=+`vrg8Sco661@oBNLaqU9Lp5l{kzX(#@)}nHghDS+L{+A2^W+na-r^MOC zh5{t>abi&KJLe@vn_lfEIrn6}<5Dt>2QhO$_su4p!sZQo%u|Mo#ltMSXGb7#I+?p= z-q%n2n|r9)XG)R@7R>hH^kDjrd=1=v6;Q+|j z0gcGJk{KLJO2QI5WzzogzXIend{L^Pcc%I%jt&kCu&5o}@h8JQW1iUD1lvFl2SP#9 zzgM-qPh}eI@{FpD<7yJn;~u%}%S~A~Bl`Q$nxND1zbiL0I&j}<`6uBq<_q5tJ}(Y> zgba*qcEpb|{!k5Da0!k;>!{NqF|f z;HPbAe_eyZHWJ$x_uMZ&r2}&1%2eoK<1+Izd@%7lE@C!8{QhwL*>nP1N1TCz-_y_B@3lR*osuuTZrb1J8Nk0JET|Z7>ye9quN;^?onq6qq?(zzpp@X$s4<%-` zIebl>6rfQ8LMDi#6j>FK&C&U;jnauw1B2Y@%mcj;h@xLg@$*<-GePEf*PPbPS$D!)Y1VlNh9m!V#2k;a zr8n=mes&W~LjrVG%0owp!1c9^3^)Vqk}L3NJp(3+p%~c4f2-x$DNi|WWWEsLw|-Bu z=S%q((Eu=CAG&qQWLuSA@~OGg|d(>$p>3W@aH>~ zQV*6{uOuAP<|KIi?#MprdOzK3m?v-N|Rq{jt9?-nvpeNX7ufqMDAWU zEp@No9`l&0!Re!W-l4|2YS|MqH*$i8h!6L7`-+k7UE-D-p;PP0?fW;q>^UXNRk#Sg z1bL7u^H0{9I;nfCv20Z+L#O94XJ4A2n#X8;Cv|ACDpP2u*ljGa-)89wGuDM=<`WwO zBwD8A3dfb(Ylc1_RJS!nRWj?p9bu3zy5eb7^ z9H2i8kLHBZ%Dz+`m@`Q0Lh>tvY0YOACWR#^iG1f!Qs?gzosdhUWoFu35@tMzSikK^ zUQn|l;`+Pqd67=r{AM`Z8p-zS_Y3P(oLns3xy8`Lq4DIYxMsO&SzqdeX>Abk7gK_3 z-nQM)a?s_&DDKLwJU_zkte{9$J&s>5x~39hxW$j!dB2k}MBZiMR}Vw!ETQ!INTO2z z%tti{XYDVSkO{8s+AP{X#AE&eXu3bD z948eb$3rV6lHeglh)>jY8xr~1Pr)^WEO+46UNAc?x)7ZiHACszmbi#=R0FqOrzb|U z?O<^nt=p++D&;4H+M%GV^=m8q>yC1la$9=Br64~_9J(7%d4&$rbO`ai#1rncf26zn zS>HTHoh87_ZGS|mqsN=`$M8v4UXJJc z8LSFY5?|<>ImtB~?{|u-pdaGPSDVvoimIj-VpvvcEO;@1DpOuq)l12N;ira`d{8xM z7Q<=bpP4h0V{DQg8togk=a!5uI3K>yHD^-Z4|bStEijH}{yjDFsn8aLILHo`m3J1p zo?crJI;*sL=iX|kr647sc;LyraQg?`ho@d}h<&KL-CPOQV7w#7;EMf()JFu?$q?>Y z%JX*E>CN#?JC>uxq3w@|KNPzS4@nx(j75K(Z}uc-ML*5$hWl1j68k~E>85k{nq(1A zKwQ8lJ^DjdPvHhdDJ(>b)H5wLLS)!|z04!ALhlOSwkLa_Df`7Inv9Iu0~`_b`{HIB zM|b+4>RX(WB;m$;_~Tv*S0y!o7@q;lX#bjXYqgb=(2~cmV{>}7pgC#LHi|iT&~GZsabKAizyyX zYYQAur{bveQO>H&XRm~#wb^<#QPl&?eJp8fN)n7l{lH89S4l#KywP_*aAD;Kop=ac zAEU~z^*)G`T|zy+pkQnP{&yvWSG`n1+keX~%7YeOkZsoW<5VflNq7tWyx%bLHZu}I zl_Zy8ar>emZ7=_^V;?V5ZH_bu=|>;T2C}T)x5x}2uakk+v7=9#J?I_qlfOjJ52wG% z1kF!)Kp()|Tm3!CU~nGCAR|44vp7i^9UT_LY84MxN%?Or+0TbG{cQ5JaIBqypSHe@_IoHFd}yn}`Zw-dALn7J~#sC7Upjn6!ae zsUN0$V;@fd^`%{Z>BzYLc8{c}IQkTRx9!VI4ODX4^m(8I2smJWX#y zYpiB(ZlqI4ZRa|&!;aKId{jLFXv-Kylw~CWl^rnsBtLws|h~x(w&;`kAhb=4U%{Fw<|{zmkYRc2ExaFyRjcp$1Z>$GvtM? zJtpREPj9md`X;^b(j8@yJlxE#M3NSo@U%VC|8Cc0R}=pH@zpE<6 zXy-huaq1$;xlEtY$p5MVh$b76Ph#>v{TtZ8L+S&i;d3m!x9bynb90~Hpv`FB-;WDE zuitd)KFKew#vJ|91KmD>j&vLU8KHfrRcmn-_e#RpUuvB5Xy7+;bNm-KLaqnqY$c&J z(UKe|yBZP+;g3i;bhVZ`ZrdO26xladL%kbHKD7-8oPh?J>%=_1s@7eQXCa@;#Yj+V z5n`*7k#^@3T{L~4iboP+gbR0JMyz&sFXT?(>&hh|h=~f4E^^Cv>znU35w=l%+EHvX3Co0V>U4BX$xBXWH^fU8aG8(`t`$ENip}t~^ z@B3K+$mS7qRWeGI*@f5EqZnvLJqXh^%J)@N%<)%e>$n3hrM*wh1Ql`37&P-3-M(h6rF`{~l5@n0{|-vW1pRpPOf&E2J$i z4EEi^Llmo7urJp6P|7SuxxLBk)vidgU%}lZyr#B^J<-(hh z8=JDz&wLe0H~i7AU0!3|X0Hcx>H@Bl*;f@OT5V|;YJ!z-weG?j$_AD7)_U&k?jA`e|&Bc)RYO|&QO7l$xBgS*u0&NbLKO#NnBVmvgb@d*iUbV@d#a)<7< z9L+r>CKIREPox|t;-F0OBP+<>hV}#owe5wV)+uK{A62GMhS1Nc>q)SxfI{f^e%4GO z6uuZ?VPJLPJR1MVxDMBV<;3zji{#)JHCU_wmV>ieR;tcK9c9YDxasQ=bM!`_5=%$!IYFYf55fE$zDERKeXz2 zQ&3*wnonw*dlAAAC_1I}c4{h^tfRWfN$~(5{kA#)dq-llNj)Px=36HTF3P(5y22~S z5T!W;Le-r?pD@R=KoQxU+oPd@yU`$4aq5bl4ilx>tfj*$Ue=nv#ej#AtE~{bQQ=ad z{sWC)_qU52Oza$wF8(71EH#}qWdOpi4R=bh5rnPEK5jj5XLaJ2!DbxE^06!` z9ks+r1t5v9{T>mK^fUHP8vfvl*7*#-!q;zV-i(-O**2i8O+3+m(B~zj#Tud14~j@o zG-rMd;$2~wt_4jSxa5zrho%Ba(Z5~5{Z`P&!1GEjPghB(BK8KT`(b~yhR|DW)W@jz zqnVK=)0*w#1#zOdeo#N8Pup5P^6=KLgD)*_^b9OW4t@O@jV(zvuWw8WO6Bq02!o2dWHpYisKNWGCmW?^|-a7WK>=}c0 zT@}y!<#>$%arA9lbx?b)eTDs97HaEFN&6}1nr{Q~tfm{Zbu@Bv3Xao%f#a3Dw0XuP zc>Wbv1q`vQn@m|^!H1MqUQ%>2@qCD}K`nDDGN;gnSj{-F91Q0j4M4y*4b~q@&SAZY z2Pm{h;APOo9F{T1K?$Y@70$)r+QVx+fAqLcBFXaN>~BWrKxbLMWDz|d?$E(gRd0uDL4%$BpcBl)_465v;~s@`E#$4-3J{qd|1Djo2Tl;Up(#2>Dvn;dotw;8Px!R{f>(GAC~h zNGr7Uz~DsPvaA74<1T;|rPq`Od01QlyHxshqlUP(D+@g7d!^9_LH|T_vN)R zv{Bxwb*Ht#wqe1j3$EG0W_Ex~yC_}8|3(-1zn{2$(9HDXSUXP>XJW6|grkO-2uft8 z>ni!|D}lQLb&$)?eJ69MBA!mP_zjO4<;PMp9<4uq<6VwxB6+kbR!h zdl!(A2Hy~ufSD$QQ>;7P!@v~`H5%}p!TH^^15`y{#$diE5+F|(Jn7q1a(D19P^MfWQK+ZE4#v(MQ5TX>z{e3tdl8GJ1W(fR*b zfPZ%PLDAncPn@wm5~F`5=?QH^dea5$-r{vKaR1>KfiH5M)2iutv2HK{DMHw0q11a6 zI?nLiQL3$Ep$p7B7)U3wg$55#$1VDOr?#4?d5f84%#mbT3J<$lahDMB)1y)a$Hp+! ziClK++yp{OcmE*!56?^>mt_{%nwkJ2BtnhnmW^-u{Zc2l)-TUqp>ILx%L$U9o;Z~t z=k75`e(pr``sDNz=J7zkH>RSLE7z2VUUKV;@54&%yFw@=WeD;+m{z2g_d>lv_)0#;3nH`&>w) z=shKa-tKq0c{4rRa!!^Nh`9rfWScQL0il)kr~fcav+5NVzXNFnegfwtp#%=zqduBc zCaS>>Y8Y)D4D6qIo1Yme{~jd*kw#%Ec>RB?F!(6yIh(T%s9I03FO#ZX@@U+|^3{UG z!2($2up}zOKV3lH+4Rgo7f!C2DfdHX`S$`_Oi^a=eK~ndNe0fJRm z>sieSevMJ3?cjTdXr;_^=e>K=dtYR>Lr;isPF0U(*1{*8GVd9uiO!TfLgD=IHaX!Q zK4~azQ1719CSV6bJeYIdP&dWeb;)9zaQzI7-0xr2q0SI20IHi<3NyAAq|{dTF73uk z2(Vcpfks_1J3l1Bdj*szj7o66(PZ_RUqJe-(%)*rMDVArM_G=`wr%JM+~L+#pL_Vp z?w%PgfDfls4!;2CPW($O7;>Fd^;#Y_Of=*W4Xog84&$5`T< zuo1VP1ErpFJc&67QFAu$TKi)OKum591s$0mO+p((mErBbRfD?s9oyXW3;Oo1GzrMd}O!e zaRF((Eu-86iGsZC0&-eB7<~ez7@qrWcWqf&^L6fM{zfgOWka10jgOYl z)MFM{gt#u(;oo)Re&Est6RaiT#N4;ALC@A##zsx^St~LC;UqAs?jLE088}X{ihMc9 zebNwTMvb2`;4MGPY5@fhm3+>Apr{kHRID9fakkUsD&t~GIyRfhGAC0ph|v5VwIJX> z(t5SCBLNvMWOO&II3yN-IoHMMF>ViVhCv=(HLdv8_SfW`a1-eOpr1P+?(}*+-1Bh4 zbW}$EIq@-=j{*HYA|s9Bm2x=Y!|EI?mxeKB-nYRNP~t$W)AaYZ^I^=0wNqG@H2RxJ z2<=GW($P@~-Alm!)6eBX(uPF*ZzR_mjlQEve@t7m_nXykbG*33+Hy8}DIt(YPTos`c-Vm6X{DQ~r1lQ9PYQrYlb{ zKwj}=dpzpoY(BgLSt2L~j6T7PS9ETu39I?*B%;35EVDp@=!b=LSaB$LJ~QLj;n3(x zA96MK#I>=PI<6Detbi%|^CY6i7D#8pm!V9YyQ&O2@*qTjJjv)ZL&Szi>8|;Ezz>`m zB~;E@dKt7)zR=E^aE8?a^hulLtM&r{T%r4yzaU2oKz;26_mjHuVMb^nDGQ~$_|@K6u}>Zk5kSO2!8vws>~3(`?%Nzg~9ri*4!BbhDjqxj;=XH zYlq31TRfG7H87*F9}3)|eccQBL+$MwN^bcxN;|14R$so@Jzcz2E@{^qqjsB?RNva! zGGF26CjRt+zL3^c9{8o^L7|n6?6CTVlDx5H$q3J64V3B~j6_4w%=OJ_VqQoi{s>EU zK%(C%tlsxM#Vg{ifJKsr=+15MUYx=pa-gE}8o4I=+*?guU$%kmFOzO}Tl;yHiUbEO zU!dvRumITcINlvkZ6fsU?pMMD+ACNHcykA zs4pIzhH-2&i#B5rlmRm>u#+vn<^Jh>JrBL!urhNCsO-R}lEC$LOZXQ-NP##dB=WPa zj+G#uUvx;RM#j|tNcXwA_snFBueom)6X`(>^KY8aFE2;Q! zIl;S{Eb23ZlYn=u9NHi&+&{y|IVZ!|-YhXRS1^}G`>D(b3t+Rj^4FGMuys!`h)5I( zsxTYMgCQ}hK(XUsuzPU{8FN%u=}S53H;h4AdR3i0r_<(P{ z&X1#~_8b!XtmwD{$5>EG2mOy4EegHdLiEUttv z>vnOQv7I*aJPy-+^z%Mh{zg##`_$TEV~m(v@V@JZw`uB0md#~9UgVw4R8&JmZ@5D- zLV7Qq40kVI6)j*IIAS2!OGu~lX8E6ccP;>Y`3GCq=d-6TJ{5FXM_h=xT7B<=&BLKn zW-mC3)|lzmr&oU~-f{fKb3oG=7MWH4vRB!;8By4aR@b5I$hauNe5haqHWQW(s@Zkl zGi8{OLqa9lU~7nR>($Y^fMifpnjF;w)q0WXT|GvRT(^%?XYcty%hr|GO~$673h%Nz2UR#i7p&W0PZnezgu+du}CC!o8|KHH(GIdaemL31ej zXPmO$DQs);>B8DOVYJPYn(zA_580In@=l>qe+OlvZjRPm8{fZiCu3mzFONG)Dwk)M zVP?VxGy5>`XdOilVi5WlMNzp9qA^ocvB|dN95CX`yj&=#B@?i81%DND!|-DzPJCRf z8ovs#pMb4wKJvdx{wA(0p`}GYQkx+Eo-b=|xpd9egqZP*8MhoyNYVUhOPaJtPJRTt z2dqcIx_XaDdzpTTe=2Z##2j+JFlNDkb`RawS{d?tBN}^SYZOl}+X_KY+iS#c4}300 z0c7%t8zn_*!H10Rn_9Fvbp7Y`Vn~t1CQZx^*OJJEr8@FCHNb10tWA9Ju4K(5^U)IG##hgV7R%?~m)e6j3h8i~0}PW#8=#{L5xw<+gPPhf2>X zPo!v#DK~2ariLs>Wdq}#ynohjzhQG80&zzkB)LilT7hUM8E~~`vOjnEWsoO>U02d$ zrbWJA8Wz~%C^nJ#xq+7OKm?A|aWJ}Ee{0DgXss$pI4d_-$J@*T^=9@R?WCW81}7l{wfNPw0}B zBZN>rI|lmDQXezcu2+*3htV0d^JT9C^4PjnSvtOA(Z2B6mA*E3?Y`B+h}WQ$7P>AG zk2!=;SJ93~SR)>;y=+DOt*n6?2c%+j1e``Aww?fu;uX~!JvE4i-lV`xp8YF53xD2` zXA8rpG+U{@vb0KpuW42Vp%7c;8c7AtyP^&F;~ADm&q_6lhry zOaApF(#SGu_jVZ7+iCtw^W1Je6Iy@8HtWBk=VjVPl2y}*!@lK1-&5|-BXIt82Ky`V z#e zKU6I^U)2LHhQJ71NohRNH)Uz#7RZ;267U3e1Afik4d)`ccKw5RUX!@xrZ`)znvtCJ z9*qKEB}t7o_}&xw`&7|=TX&l9UP1Bw#@ycg+t1@K-+Y(6m{}i0M_`d{zDv<)P#%r(pb;7g|Cu*EiVMt;B=)<>skR)a)i2c3=X7&^5PN(4 z&ZsQQiLG*|Civj8-^v~^py&xO>ied3U3|dv55I^?M=lM-7P6x}wbDcTzRt;WOzLr^ z2gDF~AAEs+lAvH53jAPXC!-4XJBl0SPuumF8oAg}l|3Juh;^w2#or^G*y+LL4Q;n} zA`|au2KFBhe-0aM=&Se5CSmEg=`djY)?X66zooK>cvTw9!Di+c6%-+D{JsGE{rjaA z+UEClyOH3(FE_q?`QqIcRWN+&8nlRw`C90{n9c_y=}1QY;R*BIX)3Z6qvr7>jM(~2 zVOB0HwLd#6@K=s*;8K5O22V3`CuSPC>!N-nsLlAI=%z6$235e+YXqD@STGXS8QFW! zfS_VLb0v<~z*|v&1a&qfu131zg}}^ymaOJqHlo%F=&drZTW)Az@khs>njI%aV8h1ZyM!Gxe_Cbp9(q z@Fd?0L&MSdzGP#X(UXfNe&{H>0S%VmIDe9#Y7(}$4D4NGp3yw)*Wv7qa+wXZ6hcH~2Tk%Ud&dis`L z4q8dEba2XmlLFBX2LB9tem=pgZjx>`a>v^%Gjm-P1EL>x=N*ddguLehMj!Y9o3m5Z zEdHDEg1pD)-{;Go_%j=VHyRxH^YJgq_hBk$p&B5Ak5%eGhxf`=M(MKi7KhVdhjCwK z!@7+B`@HWJrWjV=XZRj--C;!yH?nq(hm83<_AClty2fOpMIS1h?=X-gML*o*>xRw3 z8^3|P!{d&{-xGF}xpv#VSazZZqtgt+rG7(rT!@qUMSg1Tb!OlNK9n0K>R6UB%IcWm zVD=3r7BI)J7m{}(UMC1$d_v>vmP!hf#VYIF{;X`}a`5Tm#VuX@QT?yn;+w8M0sB*Q zTfasG$VZeo73!Vc?pZzB`u8hD%O6wUgpMF%9Bl)sCM!GH0p_sB&{&CcX;7uFD+35%M59+eNLa|x__*WY8Kal zo53!x2dA%63Zu?a;=)-P#raT%Foow-2{YJaON3_!b$+r_ck~$Rpd^`Y z4?B3M_*|e_eL3xn2YpRb!0&sVFXO4O(Biq<#s0FE^rHEsixKO6unRu*n;LUVq}*|c zpbX-`oOY*)YdYC@vneZQ19H4r*`HgP9tm4KU_aXZWyBqTCoPSh-Y)&Bt&9KR0W}NX zEvk@%Kds4wGuPMV$z6Zg>x6WTY~q$eu5QP0if;U@qREliKQ?^cdAs-dBAoNvv=O?u zWy7ueu&V^Wy40$nJkASxVGT05X6EzUmqsZ*9rEwtX|~iNMx_=_vgf?`K@gXSlO^IK zeM2lLi9hTq=q6>m_L2!_Rw!RJFlKs7Z|!-Nepiv6kwjb^f9{=>=Q@0HShM@G!>Q*? zSZux@F80X`OWR91l=wpYru7O+?%lx~H$6yRNY*!c`m=4n=2!gW{_4j&V*#Cz6Sw5%z#>rXo(?LCYdbo=hW_cc-K22rLWtNgO|{Up zvnu+*XB)5zC${KDM$wIeA#d8{cIwg`K06rF6U%vD;q-Uyl$}&9+n2~{x z4}J@&GdwlU9sk-AzBgdJ^=Ub8{dcP3wQnxwdPm(dmfnF9*RU^k=AVnTJI9P5>&{*c z#yN%rPx#ino)nUSGdvcSl^QayY#!d<;851s9vuGqq-DNRGQaI9 z^ZDn1E8_(;SnfFl7+>qYK6=;T+UI0&d}FbpM-H3d8oe9eaO*s?7c!=x=O*vB|&1i zP~OYms=3Y`g@X3qI0B*QX9b|^S5S7ql0pFABMCGlzh%mYuU{T$1FXDzqSFh(tgj;V zYUSH*3!>td#~R|kihxv}aQjuLlsrWD3*#m~UV1$FgXh~hHt5BL$}3e9Pntx}dh_L7 z7`t13|4p`@%ZtC~3#5F1l4@A@8iUt&*GE%3SgIk4IaunoH4v%Bt{RDxIUN0TZSM@0 z=X^x2g=Oxz%XnQa;-*|sZ`+e8Dw7Bo1)XNW67p) zvZ;sF+tOsbMIEa@>p%F?yvM0i?U1A#_rSaBF*n{|j%{UtNBt$9J`n2P%A3k%4OD7% zqNIB1708DcRslAgGCR``*HugJQP%o zY^2$hGy+;hH|3d{&ZmN%FUxtB&@KJ0ftuYuslK~uOcO713@*B-+@GVZHvYbLw))S= z_+JU`9|o!57g;Oc@h+^W8w-%!m&0~B$yJ`U$`f~!L_R1XKC6X5c#%&|OAQj-e^8?K zdoUo-V5Y(gSabuDw@DW0{ShN&5F4gXqsSk2eTK!s`@LW$@Tp&V zDuN{Q@>2JYr5ZTkI5oT)htmGo1wvgL`A4xNodsP%#E4Iy;p7n!`S&6;J&mq;pQ zc`~j`!Z9U1nmn9idr@_+{uz%o1wZ@?oOktbv_Er}wjATp)D-aA#t|7mM@DX<4Yrf? zcVlS|d5$$qI8-?$P3Ndu!K1O$jPclh+M)K}R0R37ldg|oU8V$gJhCNY}bHg=An_c zR~JwyC-=R=%r^7%hU#c$K^6AIN5anT*$n|nSI5sTR1S|U6{HKDmg|(1&B=Xv5o*Ht zV(c8=kMDmklvA~9P5U2%{MZnz=AXW^GQ68Cnr)Y9Bv)SxZ2V{*c=}pEBy>LBS>S>1vULf!9`#r? z=!f9%_&|YEj>sSG1D`9bfM;o^JFhrKtNv{irj9rwe-8wMoH~hgty?sM(B1Gb!?`P8 z-wr^xJ)mWxmjAeZmTnIzGi4jz>)E6nW@I~s#A`>?%P_WfvEQvS!UH@r5|d8S+3hwPQ+pST>ovlj!LC6XGQ||r=LU1 zCx|8xK2QW%N04tu?hvr%QYdKs@F8W{uDDB__cKRP^rf?J9D?mpkRd{#QE@N4uy9#HyqIZ0;5hQgjiA5)>7Yf7PJfkJz=h0p(gbrL#PN=L0Rf)4Rw>=6QV@N% z80O?Z+ktlsSj-euyjx7WBxt;S+au=-qrpoyfuB2#$IA6SOq~jOGF8tG%0@c1C=YOY z>#fvwDc6~hmg@kcI@w?3xwJZzFh0nQ%%oqn}wY35z>R<)^a zHF*Ev#$!o*##Ft*V>UKU--OK!c0f?>ip#n_pY++tPy6@IYM;2H6ot~+G=@CZmDs1b zX8h9Jw!1e;;HukZt%K7;+_-CxQOS|lS@R$t^FSty7VPYx;4K>pw)OkImJIm2g<$39 z8&mGL|DN9M@|R`X(@k}qyIJOGP`lVabK+~VG;yx%xX-5Fn> z49jp>OFulzZ+{@ASSeRmMaI|A+RID&?7!CdFdrK*#19jDkR)~;YFFa@O)~4>O6#>* zWyG35`UmR{6F0sB+gb7sOWJ9zW%5&`Q72R~*{tV_*3CL+BblqnomD9v-<`oWqro5@ z${suiNMaKyGK(z!mhnb<)8HOJP)rgrtCH?yTakTHl?ZrtCNuqi79h8it*Ry0^;GwP zccY&R(ODR1xbaOgX`y%*E=fqQ_BiwanNXU}v3eTK`<&>R9_;%)D$H4xD0u z_Tm_niSRnfin( zb)o5UcH|@GX{_`C2aNtIwdg{{+2aS=sx(^d?a3x?NdN0sWy%*L0c*#QYp8MbNkBW~ zuo7`vKXLY9`0IsxYoq9^>HR-Ut#sXbx(p~G39q$0f2;&y>s4e9al#@ z^*MwXS4wed~C5wan@HEOHbct*=5;Lj7%}52)XgT=h#Mpi;-!fjDorTyb~AH zrE^a+x$!uBe`jQ=qobqy^Yyx{R^YOav~_|4JG;u$FLra%pPQs9iLB0d&pGzof?;~- z75_uiS$IYD#an!4=PU#p>QW`;!?(Sw_X5ReX zTkjv3S?jEG?>*?d z#MeJL#9C6|iF__vwCBOfx!ONk+u@Md?>}3LO8;AtDQ!uA=f7!S6B$?w=3Z=U5;+#Jn{k0$djJaxkp;gZr)Bv>pkXnI&|(Mj$-w# zu#VLnaO?K~b<=pi2zV`A7B86@pv4Z0{^{TE{5K-W|C^FmT{ha;f$Il`MQ{LHi#*<304CXA~sZd z{b0rqD}Ei(I3{DgThEbD{8S^ZPG2rhAESSam1c(lO zG0yFG_LJ?DUKTt|CvNyPRA^A(`Qubi_U~c#6s=xXNo+Hy7vfrA1?k<7fVQni;K+~A zvZ&_4W^s$8?=mJsFfZ0Bq6S%=1fB6U-zPquw5kCO+GxBGssXS(`aHLeP!cpJij{e5 zEc$(^0GQHvhj@)wlUE}RdmixNLNj+}b3K|Ozx4-4#+E%-X6FkN6EnQ%7-6VzXx!vD z^6at-K$e2+2|9K1!?=?;2Ui+nJUA5Z;k@W_9SYebBPkbK}*=|Br;07#LOfIs5i%B zk=f&VU%Sj~!!h<^f&lah{zja9Qxw`#+}-evddqTQrszt5dYH}Tx zU9$V$3xD;Xeb+8m%-;@RQh|e$v$nleJr*MviJm`Z$ZEr+)LW>o#nTXF58tm;fok0M zrEvco)R*DcE2Y>q!q zX5bZlYc;2X*Ps3DxoN=tP9)J3GSta{Y?hCJU7B@|{2p1vI5F_0{&cSe1z@_k2pYdY zOd?2wx+wICs2Ihx|C`-tJlVCSxX0~TX5j=n*Eo8Q{?6pZsQ1?uVa~n8Nocvg<+_&m zrtxT(`^MkhU2v~0Ynxok0$s-apI{m{XPv~ z6mQuRt;mg_HEz>jfCySHh&O9NtKZcali*tPpUv0D!QvWf+5n$|mE)SFLq?8cv>AsB zl&v&SgMp2YYv!Q?M%N)5G^+GXmP4|LptBy+4O&as-cM^RxC2cfAWnuU<8ycKBZhEGLjHm=GVa*Fx% z!dUYrtiBVu`ZMx*7ZP!b`e_^MHOV^w<9Do?QirblOX(!>y)L}L8jEhs5j#7@;pL2S zpbDp(9I4eg0UM@AKeq#R9a}ybE&H0ojHZCv*I!3ySla114L{b+Eb5qZZ()KqJ3!ra-y)qcPy>p3BU2uc>R^k z43EHcQ>uIJ^6#Vt)moC!q=eA2{)dswZ7h)XUdzr^x|`$uY+z&7vQvgLJ5RW04a)zt+3e2;?$b8rU<5FCwe zAd^dlmhnY0T?zK|gGGX?Llo~Kiwwwm65|z7D)^prK80?oF()TixYB?qh~*OnV^|=i zpXKQSW|faxrlSY`*INP}o{033zl*=W@KxfKUN0nmk^7a|QU`nx?RF}UDEXkXj50yoXSZ4~1Ymz(2+>PjU@7(OOZ+`Gu4xZDm zNO-;idesV-%ZLL5oQ7Db`=+F3jBfoC1}Xn{LyO>mq&H86Xk$l($;COZYOkM#4B}Gy z9;epG69m5w3^-k$?UCy_*>BHs5G8PS_wGFH5~>X*y&S4%I9|X@%Qgp0{caPOAn^RR z;vEIsFFP?C!=QZ;$N1Hb=!c)M${&tBAk4>OL_Ei1YkK(TFkd*yb~QLJ+`Dsn%(o&EG8wO=LpSkZVUCA}>! zS@j?MGEzRE@p||)%M+>GNpd%2!y;TYh?ZD>`j# zvqPl7Gf5R|bnX7h5NSWSpTOJc%Kf*tqMKP^^szVSE$7qxJhEnLfjy#A@f(XL0ygyv z`mDRgWJIsFZCAXk&~faKIdZjyv$W@l$}3bV(U8O(hm)pb9_`K;#nMnbx6t z^Se2qHJTuU`>xohPm$>d-#Cv&*8+9B3X3PIIa`PN-4HHdNSM>wgH3XS_~-`>LWQ8c zOW#L#YalAi<t(euq@@Kw=4|bh1d?B;deHr2{bha{ zeg`m@8Xt|B80u@(|MYG{wbkB&TXku);TlFI8w%;g?do?61HY9Hel<9wpGO?Pj>ZQn zmfnWAlFvvZ%KeR_p;8t(?+=hap=AvcPy3LMgyItlwygc?0v!DiX1e*NAF>x!duy+jA^bZOr4Esv~8y9;$g zlNt!TngmF#hn`_%6yFUU@-a2(k@Hx(&zA6Tva4(71WUXYf|+J{B5?F872+qM+CALN z%pmIQ{@&RuprbZbYVd>Eltl!`gV&;(h^yIq zapa667?ucOPh`GOkxf?YYjW^3E_ZA={u7EJ2VGI#o%XBc1)K&i7V!o zFGC(s(M#Tk`5K%;0d$_A}7)i)I1;15?`W0~3>vqF#}Nv2=hBVQ%}@n)7| zNtnB!(#r^wa+5!gb*Art5FAn{t(9T4Bvp*_&UtnO|?wvs^?OvTeFXPYpdgUpA=u$Gq;-G^-w zy%TU1c|21J=}uF?cPHI>_olg*S89JG)`M<52`T z$N$D+9O1ZaZ_J7JNBJ|$ENgU_mDB6nTtqMBfvJ79gOgTRs_yDp&v_h#dpMu9MsRP=kQRc-#T%5mdb;{}z@?4F03>!z z_x)q_f}hA6P{tM=74az+Nx`FktIf)iF*|F;9^y&#DhME8x`^(Piq4;@V!1;B4i0-V zk!WIY#dlD1#tWX{!Aimk0_5xVzJ-}A9o?S{bTQgjhW&nBF=%9P`_F7b)ELyO+;Q1j zNM&x4Mx|-*E#Z`wP`@*d0f8)f$E~jQtCk&2x_ld1v+Q8&@smT8-HC2bMvOJp|5J}) zK?76r+CGfWAemNe!qu<_>*N?dY*E6%?E4bbQ}P6AS-dXdk6F+h<%s0jYQL9_PY?() z_2*j1dI$#TlimbDD@j(HLT^c(0%NF0+k*$;dj(6rlNKa7s6P0hso=LP-0zK=@s_DD z8vW}XwEio$K;?J^mC#dWR}t*G-SRZ?un(O-uw)rf48aRK>JQJpHDM4%6Jafu>d}QB zH}pxvZvt$yc+GiPhlpP#64mo82oK+kR*oi2;-}Lgu*5%j|B)>qOc{G0ZE-#jbdgoVrQ9Zxg{TY1i}Ydx1&sXiN&pvPHvQ#7HsI)gX(0KNUKgtt z{8o(701=`6L7iXA-47u-F7Ea%HrGp=zfmjddzE?JXzqHP+I7!>sZ+kj0GqVF{yspe zfc}`eZ<$$2de;>9m~~$O#MZPK4OM zfygNVh_3l5jSGaoIX#ag@?LwI@Lx%UuFSm4GCdfQPQ2c9K|Vz-_CcKyfj5`}IIS!1 zC#UG2o~X8lwb-*A6~nLHQ(hG+qYpC>8{x>kY{R|>_Wypvd5a4O{mnjArF(%M)^3B( z4BB>6Kw?&a!qn+fux#q#ULms1yqE_eI&xS2hCR+YA<#|K*7gT9) zzUK!z2k(|VYA)&-M@_54+`@lo<^SsvkytUZt$8E##uHg z*qwW8p1)0OqelZ&&SBnOs9weaj2WJ$vG%qW5F+Z7@jX9iBG2<$Tlg1IGAm`@%AGU- z=vhVk+NMpnC&K2XW{41?3KKE=gz(Q7psP?-BgFA9FP|HE$1|0W47~GNGgalOz%U$X-2S z&3}n*{pklRMn#{~(raScpC0^t9!! zlmuN+b~@{AV7#J@AuZb(+<+1PB?9YPE~DDVTKeCa^eXa()h+|~F>UA3q1Vj<#%=`u zE683?mOJB?-~dkfg+iI}Q#7_bt&~0@dM0UWmz)A_K3N3H60c6blk< zGWNo!|4r5VCh-c+(3_b#VCi~CAHdc9gN|X+@o005(hNi-DhG#QnerSZd7n5 zb^P*Qxw2yAk^{9K1ShzAKAxwgQK{?B{-lp50knH<6|ry=8pF9B3rGORDnl9RP-u#D zNVDvZ0Q2+{83Yr^=p*+FO8a*a>+QWyaQ(?iBgulAy-OKH3bg}?S}tSgU@QCy124z^ zdT6M&r{XhNl2iu+bHQ|Rr4knx2ByUxec2fDsp@LC^X%!KZRVhznea{j`*#9Qy}y#P z=e#*Z>4=KT?Y~3zBTEo(#|Z_;mqrJFI~0!ME0-XeAuw4D_wG@Q?&>y@Q$#zJMdiPs zvlV~;C67)wS@fsdMy^U?pu%XrvplM!F4@+_XR|X|MQk%idSNs=pbolvUTleQ=04X* zOdY^pZ)G9mZ^KGvluwonquJvUi9aOp3tTw-!pV>x^X-^q4g?7=4fr$-V6kbBEzTR7G(mc)U9_?O9})xK5Y7vAI#mxV=!Yj{Ol70#%5FkI^0|A(-{GrsnQ<( z7Di6J1@WzRe5P=Iwgh<`&ReLNg5x=Q82jL@pWM^+XdR!hpmnoT!w5)!n7)Dhs7BXi zf?ZF$TF^B$2yZ^eT`g!ZGoSNs2t}b4eDnLb6o>{Ma$9A&2gBok&n;(@!Vas zW}cTgn8$qduxCxdPeBANBsbhi*M!?hf35bg=dS8%uhYe&tD=nL)Nwh8C}0R7g8jAi z@!^5Wh@UZvGE=_Gq(Tv${Rhf~wUa=oqUanQ&Numm`M%}mw{Vrrx%W5B_gjp;lK&h? zwMziY_RlGVqrdQLF@g5qnX-}SVyLN9oE|Bl6My*h`4}_H$pyThTw_q&?&3qpt>n$c z#1MU!Xpe7+P5gOOqXfrY9b`_#u6D=!5rneX5UNWy%>PK@n zx@VZG8BLKI5A;W9cYVAo9jBD0clqN#i5M|JpH@~lWj&OqKf8uJR!UhZ10_S}i;^wf zHZ1oUr#JA727^ysEdBc#>kr|#t4nU(a|Ykk{#o?@f8R$}2J`)3-D7pF|_-c$W|Pc9^1bcLJSURdJ6HUf6ho`BN1W-Y1}v zQ)Zdjf-e>g`8)^Q#f@c>okG4}M(Ul-4lVAfJbzi-yTfG|�OrEox1wt$_QH<~yAt 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 O0fTt@ETPUbBK?0Tdn~5_ literal 0 HcmV?d00001