Perturb.org - Scott's Geek Stuff

Perl: ULID generation

Sun, 26 Apr 2026 18:58:48 -0700

ULID's are an interesting way to generate globally unique identifiers. Here is a quickie Perl implementation to generate ULIDs. This implementation does not include the intra-millisecond monotonic increment however. If that feature is important to you consider checking out a more full-featured implementation like ULID::Tiny.

for (1 .. 5) {
		    say(ulid());
		}

sub ulid {
		    my $ts    = $_[0] || time() * 1000;
		    my $bytes = substr(pack("Q>", $ts), 2, 6);
		
		    # Append 10 random bytes
		    for (0 .. 9) { $bytes .= chr(int(rand(256))); }
		
		    # base32 encoding
		    my $bits  = unpack("B*", $bytes);
		    my $pad   = (5 - (length($bits) % 5)) % 5;
		    $bits    .= '0' x $pad;
		
		    # Chars to use for base32
		    my @CROCKFORD_CHARS = split //, '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
		
		    my $result  = '';
		    for (my $i = 0; $i < length($bits); $i += 5) {
		        my $chunk = substr($bits, $i, 5);
		        my $index = 0;
		        for my $bit (split //, $chunk) {
		            $index = ($index << 1) | $bit;
		        }
		
		        $result .= $CROCKFORD_CHARS[$index];
		    }
		
		    return $result;
		}

See also: UUIDv7

Perl: Using Inline::C to embed C functions in your Perl scripts

Thu, 23 Apr 2026 14:34:43 -0700

Perl allows "inline" code written in other languages. This is useful because you can have native C functions interact with your Perl code. By placing your C code in the __DATA__ section of your Perl script you get clean separation between the two languages.

Note: Inline::C does not understand uint64_t in function definitions, so anything that interacts with Perl needs to use UV instead. Internally C functions can use and interact with uint64_t variables just fine.

use strict;
		use warnings;
		use v5.16;
		use Inline 'C';
		
		##############################################
		
		seed_splitmix64(time());
		
		for (1 .. 5) {
		    say splitmix64();
		}
		
		##############################################
		
		__DATA__
		__C__
		
		uint64_t x = 123456789;
		
		void seed_splitmix64(UV seed) {
		    x = seed;
		}
		
		UV splitmix64() {
		    uint64_t z = (x += 0x9e3779b97f4a7c15);
		    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
		    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
		
		    return z ^ (z >> 31);
		}

This will compile the C code into a shared object in the _Inline directory in whichever directory you instantiated your Perl script. Code is only compiled once (and where there are changes), so your script performance will be very high.

Comparison of markup languages

Thu, 09 Apr 2026 10:58:41 -0700

I've been investigating JSON vs YAML vs TOML for various applications. After testing many variations I ended up writing a simple tool to compare all three live.

Linux: SFTP and SCP friendly login banners

Thu, 26 Mar 2026 14:07:00 -0700

To display a message when a user logs into your server, add the following to ~/.bashrc:

# If it's an interactive terminal show the banner
		if [[ $- == *i* ]]; then
		    echo "Welcome to the monitoring server"
		    echo "Configuration is stored in /etc/myapp"
		fi

This runs only for interactive sessions. Non-interactive connections such as SFTP and SCP remain unaffected, which prevents automated processes from breaking.

See also: The text_color project.

YAML is growing on me

Wed, 25 Mar 2026 10:04:29 -0700

The more I learn about YAML, the more I like it. JSON is great as a machine readable format, but it sucks at being human readable. Want to add an element, better make sure you have all the commas and curly braces in the exact right place or the whole thing will be unusable. YAML on the other hand is designed to be human readable and modifiable. It's a very simple key/value system using indentation to represent layers.

PHP has a PECL module with good YAML support. There are also pure PHP versions if you're unable to install PECL modules. Symfony provides one, and so does Spyc. I prefer the latter because it's a single file and very easy to install.

On the Perl side there is YAML::XS, YAML::PP, and many others.

Parsing YAML is very easy in just about every language I can find. If you have a complex data structure that you need humans to interact with use YAML please.

Here is a great breakdown of when to use YAML vs JSON:

Use Case	Recommended	Why
API request/response	JSON	Universal support, strict parsing
Configuration files	YAML	Comments, readability
Browser/JavaScript	JSON	Native parsing
Kubernetes/Docker	YAML	Industry standard
Data interchange	JSON	Unambiguous, fast
Human-edited files	YAML	Less punctuation

YAML spec differences.

C: Fill an array of unsigned integers with random data using getentropy()

Sun, 11 Jan 2026 12:32:42 -0800

Often I need to generate random unsigned integers for seeding PRNGs. The best way is using the getentropy() system function to read OS level randomness into your array.

#include <sys/random.h>
		
		// Read from system random to fill up data structure
		int8_t fill_urandom(void *buf, size_t bytes) {
		    int8_t ok = getentropy(buf, bytes);
		
		    return (ok == 0);
		}

Declare your array of integers, and then pass it as a pointer to this function to fill with random bytes from your OS. This will get you a bunch of random integers you can use for seeding PRNGs.

uint64_t seed[4];
		fill_urandom(seed, sizeof(seed));

Books of 2026

Thu, 01 Jan 2026 10:50:29 -0800

List of books I read in 2026. Also see the list of 2025. The date indicated denotes the date I started reading the book.

2026-01-01 - White Fang by Jack London - 180 pages
2026-01-03 - Hollow Man by John Dickson Carr - 213 pages
2026-01-06 - The Three-body Problem by Cixin Liu - 400 pages
2026-01-12 - Star Wars: Revelation by Karen Traviss - 410 pages
2026-01-19 - Pale Blue Dot by Carl Sagan - 342 pages
2026-01-25 - Dungeon Crawler Carl by Matt Dinniman - 450 pages
2026-02-01 - Project Hail Mary by Andy Weir - 478 pages
2026-02-09 - The Dark Forest by Cixin Liu - 512 pages
2026-02-18 - The Hike by Drew Magary - 278 pages
2026-02-22 - Fletch by Gregory Mcdonald - 249 pages
2026-02-26 - Zen And The Art Of Motorcycle Maintenance by Robert M. Pirsig - 540 pages
2026-03-06 - Aliens: The Female War by Steve Perry - 258 pages
2026-03-11 - The Crystal Cave by Mary Stewart - 522 pages
2026-03-20 - Nexus by Yuval Noah Harari - 420 pages
2026-03-26 - Star Wars: Onslaught by Michael A. Stackpole - 292 pages
2026-03-31 - Death's End by Cixin Liu - 590 pages
2026-04-09 - The Call Of The Wild by Jack London - 160 pages
2026-04-11 - Dragons Of Autumn Twilight by Margaret Weis - 444 pages
2026-04-19 - Wayne Of Gotham by Tracy Hickman - 296 pages
2026-04-23 - Unwept by Tracy Hickman - 268 pages
2026-04-27 - Star Wars: Ruin by Michael A. Stackpole - 292 pages
2026-05-02 - Eragon by Christopher Paolini - 503 pages

2026-xx-xx - Dragons Of A Fallen Sun by Margaret Weis - 627 pages
2026-xx-xx - Dragons Of A Lost Star by Margaret Weis - 550 pages
2026-xx-xx - Dragons Of A Vanished Moon by Margaret Weis - 629 pages

2026-xx-xx - Eldest by Christopher Paolini - 679 pages
2026-xx-xx - Brisingr by Christopher Paolini - 763 pages
2026-xx-xx - Inheritance by Christopher Paolini - 849 pages

How far does Gandalf fall when fighting the Balrog in Khazad Dum?

Wed, 24 Dec 2025 21:16:09 -0800

In the extended edition of Fellowship of the Ring Gandalf fights the Balrog and then falls for about 70 seconds.

It takes about 12 seconds to reach terminal velocity: 0.5 * g * t^2 = 0.5 * 9.81 * 12^2 ~ 706m

The remaining 58 seconds Gandalf is at terminal velocity (not speeding up) of 53m/s which is v * t = 53 * 58 ~ 3074m. For a total of 3780 meters, or about 2.35 miles.

Pretty impressive free-fall considering they were ALREADY under ground.

Perl: biski64 and sfc64 PRNG

Tue, 23 Dec 2025 10:08:47 -0800

Biski64 is a new PRNG there is extremely fast and also very simple. This one was pretty simple so I ported it to Perl in biski64.pl.

SFC64 is also largely considered on of the better PRNGs so I ported it also in sfc64.pl.

PRNG: PCG64 in Perl

Fri, 12 Dec 2025 18:33:07 -0800

I found a PCG64 implementation that I was able to borrow and convert to pure Perl:

# PCG64 RXS-M-XS "simple" variant
		#my $seeds = [12, 34];
		#my $rand  = pcg64_perl($seeds);
		sub pcg64_perl {
		    my $seeds = $_[0];
		    my $ret   = (($seeds->[0] >> (($seeds->[0] >> 59) + 5)) ^ $seeds->[0]);
		
		    use integer;
		    $ret *= 12605985483714917081;
		    $seeds->[0] = $seeds->[0] * 6364136223846793005 + $seeds->[1];
		    no integer;
		
		    $ret = ($ret >> 43) ^ $ret;
		
		    return $ret;
		}

Update: Bonus points because it's really fast:

*               Rate xosh256**  biski64     sfc64     PCG32 Splitmix64     PCG64
		xosh256**  1589825/s        --     -26%      -48%      -52%       -58%      -65%
		biski64    2145923/s       35%       --      -30%      -35%       -43%      -53%
		sfc64      3058104/s       92%      43%        --       -8%       -19%      -33%
		PCG32      3311258/s      108%      54%        8%        --       -13%      -28%
		Splitmix64 3787879/s      138%      77%       24%       14%         --      -17%
		PCG64      4587156/s      189%     114%       50%       39%        21%        --

PHP: Serve large audio/video files outside of the webroot

Tue, 02 Dec 2025 11:57:04 -0800

I have some large audio files that I need to serve via HTTPs. They need to be protected by my PHP login system so they cannot live inside of the webroot. Fortunately there is a nifty Apache module named X-sendfile, that lets you serve files outside of the webroot.

Credential checking is done in PHP, and then you set a special HTTP header that Apache watches for. When Apaches sees the X-Sendfile header it serves the file directly. This gets you all the advantages of a full-blown HTTP server handling your files, but the convenience and simplicity of PHP for handling authentication.

if ($authorized) {
		    $mime_type = mime_from_filename($filepath);
		
		    header("Content-Type: $mime_type");
		    header("X-Sendfile: $filepath");
		    exit;
		}

See also: Get mime type for file

PHP: Get the mime type for a file

Mon, 01 Dec 2025 19:48:54 -0800

If you need to get the mime type for a file in PHP you can use this function which wrappers the finfo_open() function.

function mime_from_filename($filename) {
		    $finfo = finfo_open(FILEINFO_MIME_TYPE);
		    $mime  = finfo_file($finfo, $filename);
		    finfo_close($finfo);
		
		    return $mine;
		}

Note: This function requires the file to exist on the disk.

Perl: Get terminal width

Wed, 19 Nov 2025 14:41:22 -0800

If you need a fast and simple way to get the terminal width in Perl core use Term::ReadKey. This is almost certainly faster and better than shelling out to tput cols.

sub get_terminal_width {
		    my @x      = Term::ReadKey::GetTerminalSize();
		    my $width  = $x[0] || 0;
		
		    return $width;
		}

NIST Password Recommedations for 2025

Tue, 04 Nov 2025 14:44:15 -0800

Current NIST Password Requirements for 2025 (SP800-63b).

What’s gone:

❌ Required uppercase, numbers, and symbols
❌ Mandatory password resets every 90 days
❌ Arbitrary complexity policies

What’s required now:

✅ Minimum 8-character passwords (15+ for privileged accounts)
✅ Password screening against compromised credential databases
✅ Support for passwordless authentication and passkeys

Minimum Password Length Requirements

Password length serves as the cornerstone of NIST's updated authentication framework. While the baseline requirement mandates a minimum of 8 characters, security research reveals that passwords under 8 characters can be cracked within hours using modern computing power.

StrongDM has a good summary.

Two more PRNGs implemented in Perl

Wed, 29 Oct 2025 09:41:54 -0700

In my ongoing quest to implement PRNGs in pure Perl I'm adding the Marsaglia multiply-with-carry family to my collection. These were a little difficult because the math is all done in 128bits which requires a special emulation layer in Perl. The Perl version is much slower than the C version, but that's to be expected without native 128bit variable types.

I also implemented squares64 PRNG which was a little more straight forward. I learned that bitwise shifts are normally unsigned, but if we're in a use integer block bitwise shifts change to signed. This is not what we want so I ended doing a lot of use integer followed almost immediately by a no integer to make sure we're doing the math in the correct mode.