I gladly present you this jank.
You might need these to compile:
cargo add image
cargo add clap --features derive
And the jank itself:
Some Rust code
use std::path::PathBuf;
use clap::Parser;
use image::{ imageops::{self, FilterType}, ImageReader };
#[derive(Parser)]
struct Cli {
path: PathBuf,
#[arg(short = 'H', long, default_value_t = 30)]
height: u32,
#[arg(short, long, default_value_t = 0.4)]
ratio: f32,
#[arg(short, long, default_value_t, value_enum)]
filter: Filter,
}
#[derive(clap::ValueEnum, Clone, Default)]
enum Filter {
Nearest,
Triangle,
Gaussian,
CatmullRom,
#[default]
Lanczos3,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let args = Cli::parse();
let filter = match args.filter {
Filter::Nearest => { FilterType::Nearest },
Filter::Triangle => { FilterType::Triangle },
Filter::CatmullRom => { FilterType::CatmullRom },
Filter::Gaussian => { FilterType::Gaussian },
Filter::Lanczos3 => { FilterType::Lanczos3 },
};
let img = ImageReader::open(args.path)?.decode()?;
let original_ratio = img.width() as f32 / img.height() as f32;
let width = ( args.height as f32 / args.ratio ) * original_ratio;
let out = imageops::resize(&img, width as u32, args.height * 2, filter);
let mut iter = out.enumerate_rows();
while let Some((_, top)) = iter.next() {
let (_, bottom) = iter.next().unwrap();
top.zip(bottom)
.for_each(|((_, _, t), (_, _, b))| {
print!("\x1B[38;2;{};{};{};48;2;{};{};{}m\u{2584}", b[0], b[1], b[2], t[0], t[1], t[2])
});
println!("\x1B[0m");
}
Ok(())
}
BitTorrent breaks your data in blocks, each block is hashed, their sizes are known. Assuming you got your
.torrentfile from a legitimate source, it's practically impossible to receive something else, as long as your client does all the checks properly.In theory, it is possible to write malware that will collide hashes with some other content, but considering you are restricted to the size of the actual content, it's extremely unlikely that out of all the millions of
.torrents we created so far we can find even one for which it is possible.And even if you win this absolutely bizzare lottery, you'll be competing with legitimate peers for serving the blocks. If at least one block that you care about is not served by you, the recepient will just get corrupted content that won't be dangerous in any way. In other words, you need to have so much bandwidth, that you serve everything before anyone else can serve even one significant block. At which point you will probably have to spend a lot more money on that than you'll ever get from whatever malware you are trying to serve.