Source: codecZ85.js

  1. /**
  2.  * @fileOverview    Z85 codec implementation.
  3.  * @summary         Z85 encoding is the "string-safe" ZeroMQ variant of Base85 
  4.  *                  encoding. The character set avoids the single and double
  5.  *                  quotes and the backslash, making the encoded string
  6.  *                  safe to embed in command-line interpreters.
  7.  *                  Base85 uses 5 characters to encode 4 bytes of data,
  8.  *                  making the encoded size 1/4 larger than the original;
  9.  *                  this also makes it more efficient than uuencode or Base64,
  10.  *                  which uses 4 characters to encode 3 bytes of data, making
  11.  *                  the encoded size 1/3 larger than the original.
  12.  *
  13.  * @author          Manjul Apratim
  14.  */
  16. /**
  17.  * Z85 encoding/decoding
  18.  * http://rfc.zeromq.org/spec:32/Z85/
  19.  * @namespace
  20.  */
  21. sjcl.codec.z85 = {
  22.   /** The Z85 alphabet.
  23.    * @private
  24.    */
  25.   _chars: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#",
  27.   /** The decoder map (maps base 85 to base 256).
  28.    * @private
  29.    */
  30.   _byteMap: [
  31.     0x00, 0x44, 0x00, 0x54, 0x53, 0x52, 0x48, 0x00, 
  32.     0x4B, 0x4C, 0x46, 0x41, 0x00, 0x3F, 0x3E, 0x45, 
  33.     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
  34.     0x08, 0x09, 0x40, 0x00, 0x49, 0x42, 0x4A, 0x47, 
  35.     0x51, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 
  36.     0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 
  37.     0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 
  38.     0x3B, 0x3C, 0x3D, 0x4D, 0x00, 0x4E, 0x43, 0x00, 
  39.     0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 
  40.     0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 
  41.     0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 
  42.     0x21, 0x22, 0x23, 0x4F, 0x00, 0x50, 0x00, 0x00
  43.   ],
  45.   /**
  46.    * @summary Method to convert a bitArray to a Z85-encoded string.
  47.    *          The bits represented by the array MUST be multiples of 4 bytes.
  48.    * @param   {bitArray} arr - The input bitArray.
  49.    * @return  {string} The Z85-encoded string.
  50.    */
  51.   fromBits: function (arr) {
  52.     // Sanity checks
  53.     if (!arr) {
  54.       return null;
  55.     }
  56.     // Check we have multiples of 4 bytes (32 bits)
  57.     if (0 !== sjcl.bitArray.bitLength(arr) % 32) {
  58.       throw new sjcl.exception.invalid("Invalid bitArray length!");
  59.     }
  61.     var out = "", c = sjcl.codec.z85._chars;
  63.     // Convert sequences of 4 bytes (each word) to 5 characters.
  64.     for (var i = 0; i < arr.length; ++i) {
  65.       // Each element in the bitArray is a 32-bit (4-byte) word.
  66.       var word = arr[i];
  67.       var value = 0;
  68.       for (var j = 0; j < 4; ++j) {
  69.         // Extract each successive byte from the word from the left.
  70.         var byteChunk = (word >>> 8*(4 - j - 1)) & 0xFF;
  71.         // Accumulate in base-256
  72.         value = value*256 + byteChunk;
  73.       }
  74.       var divisor = 85*85*85*85;
  75.       while (divisor) {
  76.         out += c.charAt(Math.floor(value/divisor) % 85);
  77.         divisor = Math.floor(divisor/85);
  78.       }
  79.     }
  81.     // Sanity check - each 4-bytes (1 word) should yield 5 characters.
  82.     var encodedSize = arr.length*5;
  83.     if (out.length !== encodedSize) {
  84.       throw new sjcl.exception.invalid("Bad Z85 conversion!");
  85.     }
  86.     return out;
  87.   },
  89.   /**
  90.    * @summary Method to convert a Z85-encoded string to a bitArray.
  91.    *          The length of the string MUST be a multiple of 5
  92.    *          (else it is not a valid Z85 string).
  93.    * @param   {string} str - A valid Z85-encoded string.
  94.    * @return  {bitArray} The decoded data represented as a bitArray.
  95.    */
  96.   toBits: function(str) {
  97.     // Sanity check
  98.     if (!str) {
  99.         return [];
  100.     }
  101.     // Accept only strings bounded to 5 bytes
  102.     if (0 !== str.length % 5) {
  103.       throw new sjcl.exception.invalid("Invalid Z85 string!");
  104.     }
  106.     var out = [], value = 0, byteMap = sjcl.codec.z85._byteMap;
  107.     var word = 0, wordSize = 0;
  108.     for (var i = 0; i < str.length;) {
  109.       // Accumulate value in base 85.
  110.       value = value * 85 + byteMap[str[i++].charCodeAt(0) - 32]; 
  111.       if (0 === i % 5) {
  112.         // Output value in base-256
  113.         var divisor = 256*256*256;
  114.         while (divisor) {
  115.           // The following is equivalent to a left shift by 8 bits
  116.           // followed by OR-ing; however, left shift may cause sign problems
  117.           // due to 2's complement interpretation,
  118.           // and we're operating on unsigned values.
  119.           word = (word * Math.pow(2, 8)) + (Math.floor(value/divisor) % 256);
  120.           ++wordSize;
  121.           // If 4 bytes have been acumulated, push the word into the bitArray.
  122.           if (4 === wordSize) {
  123.             out.push(word);
  124.             word = 0, wordSize = 0;
  125.           }
  126.           divisor = Math.floor(divisor/256);
  127.         }
  128.         value = 0;
  129.       }
  130.     }
  132.     return out;
  133.   }
  134. }