Information about Uuencode

Uuencoding is a form of binary-to-text encoding that originated in the Unix program uuencode, for encoding binary data for transmission over the uucp mail system. The name "uuencoding" is derived from "Unix-to-Unix encoding". Since uucp converted characters between various computer's character sets, uuencode was used to convert the data to fairly common characters that were unlikely to be "translated" and thereby destroy the file. The program uudecode reverses the effect of uuencode, recreating the original binary file exactly. uuencode/decode became popular for sending binary files by e-mail and posting to usenet newsgroups, etc. It has now been largely replaced by MIME and yEnc.

The encoding process

Uuencode pre-dates base64 coding, but the POSIX version of uuencode has the option of producing and decoding data in base64 format, beginning with the line begin-base64 <mode> <file> and ending with the line

The remainder of this article describes the original "historic" uuencode.

Uuencoded data starts with a line of the form: begin <mode> <file> Where <mode> is the file's read/write/execute permissions as three octal digits, and <file> is the name to be used when recreating the binary data.

Uuencoding repeatedly takes in a group of three bytes, adding trailing zeros if there are fewer than three bytes left. These 24 bits are split into four groups of six which are treated as numbers between 0 and 63. Decimal 32 is added to each number and they are output as ASCII characters which will lie in the range 32 (space) to 32+63 = 95 (underscore). ASCII characters greater than 95 may also be used; however, only the six right-most bits are relevant.

Each group of sixty output characters (corresponding to 45 input bytes) is output as a separate line preceded by an encoded character giving the number of encoded bytes on that line. For all lines except the last, this will be the character 'M' (ASCII code 77 = 32+45). If the input is not evenly divisible by 45, the last line will contain the remaining N output characters, preceded by the character whose code is 32 + the number of remaining input bytes. Finally, a line containing just a single space (or grave character) is output, followed by one line containing the string "end".

Sometimes each data line has extra dummy characters (often the grave accent) added to avoid problems with mailers that strip trailing spaces. These characters are ignored by uudecode. The grave accent (ASCII 96) can also be used in place of a space character. When stripped of their high bits they both decode to 000000.

Despite using this limited range of characters, there are still some problems encountered when uuencoded data passes through certain old computers. The worst offenders are computers using non-ASCII character sets such as EBCDIC. To solve this problem, the Xxencode format was created as a more robust version of the encoding, which used only alphanumeric characters and the plus and minus symbols. This is also solved by the new Base64 format supported by uuencode.

uuencode historical algorithm

The standard output is a text file (encoded in the character set of the current locale) that begins with the line: begin <mode> <decode_pathname> and ends with the line: end where <mode> is the file's read/write/execute permissions as three octal digits, and <decode_pathname> is the name to be used when recreating the binary data. In both cases, the lines have no preceding or trailing <blank>s.

The algorithm that is used for lines in between begin and end takes three octets as input and writes four characters of output by splitting the input at six-bit intervals into four octets, containing data in the lower six bits only. These octets are converted to characters by adding a value of 0x20 to each octet, so that each octet is in the range [0x20,0x5f], and then it shall be assumed to represent a printable character in the ISO/IEC 646:1991 standard encoded character set. It is then translated into the corresponding character codes for the codeset in use in the current locale. (For example, the octet 0x41, representing 'A' , would be translated to 'A' in the current codeset, such as 0xc1 if it were EBCDIC.)

Where the bits of two octets are combined, the least significant bits of the first octet are shifted left and combined with the most significant bits of the second octet shifted right. Thus the three octets A, B, C are converted into the four octets:

0x20 + (( A >> 2 ) & 0x3F) 0x20 + (((A << 4) | ((B >> 4) & 0xF)) & 0x3F) 0x20 + (((B << 2) | ((C >> 6) & 0x3)) & 0x3F) 0x20 + (( C ) & 0x3F)

These octets then are translated into the local character set.

Each encoded line contains a length character, equal to the number of characters to be decoded plus 0x20 translated to the local character set as described above, followed by the encoded characters. The maximum number of octets to be encoded on each line shall be 45.

Sample uuencoding

The table shows the uuencoding of the three ASCII encoded characters Cat into its uuencoded representation 0V%T:

Original characters	C								a								t
Original ASCII, decimal	67								97								116
ASCII, binary	0	1	0	0	0	0	1	1	0	1	1	0	0	0	0	1	0	1	1	1	0	1	0	0
New decimal values	16						54						5						52
+32	48						86						37						84
Uuencoded characters	0						V						%						T

If the complete uuencoded output of the three ASCII characters Cat might appear as the following begin 644 cat.txt

1. 0V%T

` end

Uuencode table

The following table represents the subset of ASCII characters used by UUEncode and the 6-bit binary string they represent.

Printable Representation	ASCII Decimal	Binary Representation		Printable Representation	ASCII Decimal	Binary Representation
(space)	32	000 000		@	64	100 000
!	33	000 001		A	65	100 001
"	34	000 010		B	66	100 010
#	35	000 011		C	67	100 011
$	36	000 100		D	68	100 100
%	37	000 101		E	69	100 101
&	38	000 110		F	70	100 110
'	39	000 111		G	71	100 111
(	40	001 000		H	72	101 000
)	41	001 001		I	73	101 001
*	42	001 010		J	74	101 010
+	43	001 011		K	75	101 011
,	44	001 100		L	76	101 100
-	45	001 101		M	77	101 101
.	46	001 110		N	78	101 110
/	47	001 111		O	79	101 111
0	48	010 000		P	80	110 000
1	49	010 001		Q	81	110 001
2	50	010 010		R	82	110 010
3	51	010 011		S	83	110 011
4	52	010 100		T	84	110 100
5	53	010 101		U	85	110 101
6	54	010 110		V	86	110 110
7	55	010 111		W	87	110 111
8	56	011 000		X	88	111 000
9	57	011 001		Y	89	111 001
:	58	011 010		Z	90	111 010
;	59	011 011		[	91	111 011
<	60	011 100		align="center"	92	111 100
=	61	011 101		]	93	111 101
>	62	011 110		^	94	111 110
?	63	011 111		_	95	111 111
				`	96	(1) 000 000

Decoding

You can decode the values by using the following schedule:

>
Read 4 bytes: b0, b1, b2, b3 
            a = (((b0 - 0x20) & 0x3F) << 2 & 0xFC) | (((b1 - 0x20) & 0x3F) >> 4 & 0x03);            
            b = (((b1 - 0x20) & 0x3F) << 4 & 0xF0) | (((b2 - 0x20) & 0x3F) >> 2 & 0x0F);            
            c = (((b2 - 0x20) & 0x3F) << 6 & 0xC0) |  ((b3 - 0x20) & 0x3F);            
Write a,b,c

Note: For Java, you need to use '>>>' (unsigned right-shift operator) instead of '>>'

Trivia

Microsoft's E-mail-program Outlook Express once contained a flaw that it also accepts "begin ..." as start of UUEncoded attachments (i.e., not requiring octal encoded UNIX-style permissions). Especially in Usenet, where MIME is seldom used and plain text is preferred, some people would embed begin, space, space in their messages in order to maliciously hide the rest of the message from Outlook Express users (e.g., they configure their news-client to quote starting with the line "begin quote from xxx")[1].

See also

• Base64
• BinHex
• MIME
• XXEncode
• YEnc

References

This article was originally based on material from the Free On-line Dictionary of Computing, which is licensed under the GFDL.

• IEEE Std 1003.1 uuencode man page

External links

• GNU sharutils - The Free Software Foundation's sharutils bundle includes uuencode, uudecode, and others.
• UUDeview - open-source program to encode/decode Base64, BinHex, uuencode, xxencode, etc. for Unix/Windows/DOS
• UUENCODE-UUDECODE - open-source program to encode/decode created by Clem "Grandad" Dye