[{"id":247160,"date":"2026-06-13T15:10:20","date_gmt":"2026-06-13T20:10:20","guid":{"rendered":"https:\/\/www.johndcook.com\/blog\/?p=247160"},"modified":"2026-06-13T17:11:16","modified_gmt":"2026-06-13T22:11:16","slug":"rsa-munitions-t-shirt","status":"publish","type":"post","link":"https:\/\/www.johndcook.com\/blog\/2026\/06\/13\/rsa-munitions-t-shirt\/","title":{"rendered":"RSA munitions T-shirt"},"content":{"rendered":"

Back when the US government classified strong encryption as “munitions,” RSA public key cryptography was illegal to export. In 1995, Adam Back protested this by creating a terse, obfuscated implementation of RSA in Perl code and used it as an email signature.<\/p>\n

The code was also printed on T-shirts. The shirt was classified as munitions because it contained source code for strong encryption. More on the shirt here<\/a>.<\/p>\n

\"Adam<\/p>\n

This was the code:<\/p>\n

#!\/bin\/perl -s-- -export-a-crypto-system-sig -RSA-3-lines-PERL\r\n$m=unpack(H.$w,$m.\"\\0\"x$w),$_=`echo \"16do$w 2+4Oi0$d*-^1[d2%Sa\r\n2\/d0<X+d*La1=z\\U$n%0]SX$k\"[$m*]\\EszlXx++p|dc`,s\/^.|\\W\/\/g,print\r\npack('H*',$_)while read(STDIN,$m,($w=2*$d-1+length$n&~1)\/2)\r\n<\/pre>\n
My initial intention was to unpack the code, explaining each piece in detail. I don’t have the time or patience for that, and I imagine many readers don’t either. For more of a blow-by-blow explanation, see this commentary<\/a> from 1995.<\/p>\n
dc<\/h2>\n
In the middle of the code is<\/p>\n
    echo ... | dc<\/pre>\n
This is the most dense and most important part of the code. Perl calls the dc<\/code> calculator to do the arbitrary precision arithmetic that RSA encryption requires.<\/p>\n
I’ve written about bc<\/code> several times. bc<\/code> (“basic calculator”) was a originally a more user-friendly wrapper around the reverse-Polish dc<\/code> (“desktop calculator”). dc<\/code> is still part of every Unix and Unix-like system, but I imagine bc<\/code> is far more popular.<\/p>\n
The important feature of dc<\/code> for this post is that it is stack-based, meaning that users would push data and commands on to the stack and pop results off the stack. A sequence of commands that might be understandable when interactively using dc<\/code> would look cryptic in a transcript. This is part of what makes the code so cryptic.<\/p>\n
I’ll parse just a tiny bit of the dc<\/code> code to give a flavor of what it does. The first four characters 16do<\/code> instructs dc<\/code> to push 16 on to the stack, duplicate it, and set the output radix to 16, i.e. these four characters tell dc<\/code> to work in hexadecimal.<\/p>\n
Believe it or not, the dc<\/code> code is computing<\/p>\n
m<\/em>k<\/em><\/sup> mod n<\/em><\/p>\n
using fast exponentiation<\/a>, which is the key step in the RSA algorithm.<\/p>\n
Textbook RSA<\/h2>\n
Note that Adam Back’s code is computing what we would now call textbook RSA, not RSA as it has been refined over the years and is currently implemented<\/a>.<\/p>\n
Related posts<\/h2>\n