Java Glossary : armouring

Java definitions: 0-9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

You are here : home : Java Glossary : A words : armouring.

armouring

Converting binary data into printable gibberish so that data transport systems will not corrupt it. You see it used often in certificates, email, and HTTP communications.

There are many data transport systems that either ignore, act on or otherwise meddle with control characters embedded in the data. They may trim trailing blanks, change line end characters, convert tabs to spaces etc. etc. Any of these actions would totally corrupt binary data. To pass binary data through such a meddlesome channel, e.g. the email system, it must first be armoured, converted to use only safe printable characters that will not be meddled with, e.g. a-z A-Z 0-9 and the vanilla punctuation.

MIME email and email attachments have a configurable encoding scheme, controlled via the Transfer-Content-Encoding mime header, often base64 or Quoted-Printable.

Unfortunately this bulks the message up by 30 to 300% depending on the technique you use. The other end has to recognise the armouring technique and do the reverse to get he binary back.

When 8-bit data are encoded in printable characters, the more printable characters used in the representation, generally the more efficient the protocol. However, the more characters used, the greater the odds one of the characters used will be interfered with by your communication channel.

Armouring Schemes

Unfortunately, there are a plethora of techniques. It is not always obvious just from looking which was used to encode the data:

base64: common in certificates, passwords, email, email attachments, cookies and HTTP POSTs. Used to armour bytes or anything that can be converted to bytes, e.g. via serialized ObjectStreams.
```
// Base64 armouring
// source available at http://mindprod.com/products.html#BASE64
import com.mindprod.base64.Base64;
...
// sample byte array to encode
byte[] toSend = { (byte)0xfc, (byte)0x0f, (byte)0xc0 };

// create encoder object
Base64 base64 = new Base64();
base64.setLineLength( 72 );  // default

// encoding a byte[]
String send = base64.encoder( toSend );

// decoding a byte[]
byte[] reconstituted = base64.decoder( sent );
```
Base64 uses an small cast of characters to convert 8-bit data into printable characters: a to z, A to Z, 0 to 9, + / and =. You might do this to convert any binary data to printable. This makes base64 suitable for encoding binary data as SQL strings, that will work no matter what the encoding. Unfortunately + / and = all have special meaning in URLs. See Base64 for free Java source code. Every three characters in the original fluff up to four characters in the encoded form. This 33% increase in size occurs independent of what characters appear in your data. At the receiving end you convert the printable characters back to the 8-bit data.
url-encoded: mime type x-www-form-urlencoded which is handled by java.net.URLEncoder.encode/decode. This is only intended for String data with a few awkward characters in it, typically for CGI GET and POST HTTP requests.
```
// URL-Encoder armouring
import java.net.URLEncoder;
import java.net.URLDecoder;
...
String toSend = "The \"quick\" brown\nfox.";

// encoding a String
String send = URLEncoder( toSend, "UTF-8" );

// decoding the String
String reconstituted = URLDecoder( sent, "UTF-8" );
```
You see this used to encode URLs in messages sent by a browser to a server. java.net.URLEncoder uses the following set of characters to convert 8-bit data into printable characters :a to z, A to Z, 0 to 9, -, ., *, and _. It works like this:
- The alphanumeric characters a to z, A to Z, 0 to 9 remain the same.
- The special characters ., -, *, and _ remain the same.
- The space character is converted into a plus sign +.
- All other 16-bit characters are unsafe and are first converted into one or more bytes using some encoding scheme. Then each byte is represented by the 3-character string %FF, where FF is the two-digit hexadecimal representation of the byte.
In the best case, your message is the same size as the original. In a pathological case, your message can balloon up to three times the original size.

base64u: A variant of Base64 that avoids the + / and = characters that have special meaning in URLs, GET and POST. You can treat its output either as not needing URLEncoding, or as already URLEncoded. Used to armour bytes or anything that can be converted to bytes, e.g. via serialized ObjectStreams.

// Base64u armouring
// source available at http://mindprod.com/products.html#BASE64
import com.mindprod.base64.Base64u;
...
// sample byte array to encode
byte[] toSend = { (byte)0xfc, (byte)0x0f, (byte)0xc0 };

// create encoder object
Base64u base64u = new Base64u();
base64u.setLineLength( 72 );  // default

// encoding a byte[]
String send = base64u.encoder( toSend );

// decoding a byte[]
byte[] reconstituted = base64u.decoder( sent );

the Wrapper which optionally handles serialising/reconstituting, compression/decompression, signing/verifying, heavy duty encryption/decryption and Base64u armouring/dearmouring.

// Wrapper serialiazation, compression and base64u armouring.
// source code available at http://mindprod.com/products.html#WRAPPER
import com.mindprod.wrapper.Wrap;
import com.mindprod.wrapper.UnWrap;
...
Wrap w = new Wrap();
Anything original message = new Anything();

// you can send any Serializable object, including Strings and raw byte arrays.
String transport = w.wrap( originalMessage );

// transport String is sent to another machine... and then

Unwrap u = new Unwrap();
Anything reconstitutedMessage = (Anything)u.unwrap( transport );

Use it when you want to include arbitrary Java Objects in your CGI GETS and POSTS.

Quoted-Printable (RFC 2045) used in newsgroup messages and email. Quoted-Printable (RFC 2045) uses the following set of characters to convert 8-bit data into printable characters : space, a to z, A to Z, 0 to 9, !- <, >- ~, =. It converts unsafe characters into =FF where FF is the hex equivalent. In the best case, your message is the same size as the original. In a pathological case, your message can balloon up to three times the original size.
hexadecimal: two characters per byte 0..F. The result is always exactly double the size of the original. This is the easiest schemes to write code for.
binhex: a hex variant used on the MacIntosh.
UUEncode: similar to Base64 in that they both use 64 ASCII characters to represent 6 bits in the printable representation, but they are not compatible. Base 64 uses upper case, lower case, digits and only three punctuation symbols. UUEncode uses 28 punctuation symbols because it uses only upper case letters. Also, the uuencode command has a structure to its output, with a header containing a file name and permissions, line-length encoding characters, and a footer, none of which are part of Base64.
CMP Encode: dates back to 1985. Very efficient for text that is mostly printable already. CMP Encode uses the full 95 ASCII printable characters excluding space. Printable characters it leaves as is. It encodes control characters with a lead ^, e.g. code 3 becomes ^C. High bit chars are encoded with a lead `. It has a simple compression scheme for repeating character strings. In the best case, your message can be even smaller than the original. In a pathological case, your message can balloon up to twice the original size. Unfortunately, Java code for this algorithm is not currently available. Pascal source and executable is available. This algorithm is not a recognised official MIME encoding.
CMP Encrypt: dates back to 1985. Also encrypted with a theoretically uncrackable one-time pad. Pascal source and executable is available.

Base64 ¤ encipher ¤ encode ¤ encoding ¤ encrypt ¤ MIME ¤ printable ¤ the Wrapper

home	Canadian Mind Products
	mindprod.com IP:[24.87.56.253]
	Your IP:[80.134.30.163]
	You are visitor number 567.
	Please send errors, omissions and suggestions
	to improve this page to Roedy Green.
	You can get a fresh copy of this page from:	or possibly from your local J: drive mirror:
	http://mindprod.com/jgloss/armouring.html	J:\mindprod\jgloss\armouring.html