RandyMcMillan’s gists

RandyMcMillan / theodorus.rs

Last active November 7, 2025 12:20 — forked from rust-play/playground.rs

theodorus.rs

	use num_traits::Float;

	/// Calculates the lengths of the hypotenuses in the Spiral of Theodorus,
	/// which are the square roots of integers starting from sqrt(2).
	fn calculate_theodorus_hypotenuses<F: Float>(count: u32) -> Vec<F> {
	// We want roots from sqrt(2) up to sqrt(count + 1).
	// The number of triangles is 'count'.
	let mut lengths = Vec::with_capacity(count as usize);

	// The length of the first hypotenuse (the base of the spiral) is sqrt(1^2 + 1^2) = sqrt(2).

RandyMcMillan / git_vfs_v2.rs

Last active November 6, 2025 15:38 — forked from rust-play/playground.rs

git_vfs_v2.rs

	use sha2::{Digest, Sha256};
	use std::collections::{HashMap, HashSet};
	use std::fs;
	use std::io::{self, Read};
	use serde::{Serialize, Deserialize};
	use chrono::Utc;
	// APPROVED DEPENDENCY: Using data_encoding for all hex operations
	use data_encoding::HEXUPPER;

	// ====================================================================

RandyMcMillan / git_vfs.rs

Last active November 6, 2025 15:29 — forked from rust-play/playground.rs

git_vfs.rs

	use sha2::{Digest, Sha256};
	use std::collections::{HashMap, HashSet};
	use std::fs;
	use std::io::{self, Read};
	use serde::{Serialize, Deserialize};
	use chrono::Utc;
	// APPROVED DEPENDENCY: Using data_encoding for all hex operations
	use data_encoding::HEXUPPER;

	// ====================================================================

RandyMcMillan / bind_port_scan.rs

Last active November 6, 2025 13:42 — forked from rust-play/playground.rs

bind_port_scan.rs

	use std::net::{TcpListener, TcpStream, /ToSocketAddrs, /SocketAddr};
	use std::time::Duration;
	use std::thread;
	use std::io::{self, Read, Write};

	// --- Configuration ---
	const TARGET_IP: &str = "127.0.0.1"; // The IP the scanner checks
	const TIMEOUT_MS: u64 = 500; // Connection timeout in milliseconds
	// ---------------------

RandyMcMillan / env_vars.rs

Last active November 5, 2025 13:11 — forked from rust-play/playground.rs

env_vars.rs

	use std::env;

	fn env_vars() {
	// Iterate over all environment variables.
	for (key, value) in env::vars() {
	println!("{}: {}", key, value);
	}

	// You can also filter the environment variables.
	println!("\nFiltered environment variables:");

RandyMcMillan / memory_xor.rs

Last active November 4, 2025 20:44 — forked from rust-play/playground.rs

memory_xor.rs

	// Only using standard library features for this illustrative concept,
	// as the listed crates don't provide a direct, safe XOR-list implementation.

	use std::ptr;
	use std::mem;

	// --- A simplified structure for an XOR-linked list node ---
	struct Node {
	pub value: u32,
	// The "link" is the XOR of the pointers to the previous and next nodes.

RandyMcMillan / create_getter.rs

Last active October 25, 2025 12:49 — forked from rust-play/playground.rs

create_getter.rs

	// 1. Declarative Macro Definition
	// This macro takes a field identifier ($field:ident) and generates a public
	// getter method with the same name.
	macro_rules! create_getter {
	($field:ident) => {
	// The generated code:
	pub fn $field(&self) -> &str {
	// Assumes the field is a String, and returns a string slice (&str)
	&self.$field
	}

RandyMcMillan / faux_polar_ecc.rs

Last active October 24, 2025 12:37 — forked from rust-play/playground.rs

faux_polar_ecc.rs

	use std::f64::consts::PI;

	// Note: This implementation uses f64 (floating-point) for the polar coordinates (r, theta)
	// and trigonometric functions (sin, cos). This approach is for geometric demonstration // and is NOT how Elliptic Curve Cryptography (ECC) is performed, as ECC requires
	// all arithmetic to be done with integers in a finite field (modulo P).

	// The equation evaluated is:
	// r^2 * sin^2(θ) = (A_std * r^3 * cos^3(θ) + B_std * r * cos(θ) + C_std) mod P

	/// Evaluates the polar form of the Elliptic Curve equation.

RandyMcMillan / faux_ecc.rs

Last active October 24, 2025 12:28 — forked from rust-play/playground.rs

faux_ecc.rs

	// Note: In real ECC, the modulus P is a large prime (256 bits or more),
	// which requires an external crate like `num-bigint` or `crypto-bigint`.
	// This example uses u128, which is only 128 bits, for demonstration purposes.

	// We will map the general equation to the standard Weierstrass form over a finite field:
	// LHS: R * sin^2(θ) -> y_squared
	// RHS: A(r/cos(θ))^3 + B(r/cos(θ))^1 + C -> A_std * x^3 + B_std * x + C_std

	/// Evaluates the right-hand side of the Elliptic Curve equation (Weierstrass form)
	/// over a finite field, using only Rust's standard library integer types (u128).

RandyMcMillan / shot-htlc.md

Created October 22, 2025 11:33 — forked from moonsettler/shot-htlc.md

SHOT - Schnorr HTLC Obfuscation Technique

Alice and Bob reveal each other their pubkey for the session, and then both can generate the same address.

@RandyMcMillan RandyMcMillan