Add support for base64 url safe encoding

patrickfav · patrickfav · commit 344cc4a2ce7b · 2018-08-09T20:51:29.000+02:00
fix #15
diff --git a/CHANGELOG b/CHANGELOG
@@ -6,6 +6,7 @@
  * add dedicated `md5` and `sha1` transformer methods
  * add `from(Inputstream stream, int maxlength)` limiting stream reading constructor #13
  * add indexOf() with `fromIndex` parameter #14
+ * add support for base64 url safe encoding #15
 
 ## v0.6.0
 
diff --git a/src/main/java/at/favre/lib/bytes/Base64.java b/src/main/java/at/favre/lib/bytes/Base64.java
@@ -33,7 +33,21 @@ final class Base64 {
     private Base64() {
     }
 
-    public static byte[] decode(String in) {
+    private static final byte[] MAP = new byte[]{
+            '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', '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', '0', '1', '2', '3', '4',
+            '5', '6', '7', '8', '9', '+', '/'
+    };
+
+    private static final byte[] URL_MAP = new byte[]{
+            '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', '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', '0', '1', '2', '3', '4',
+            '5', '6', '7', '8', '9', '-', '_'
+    };
+
+    static byte[] decode(String in) {
         // Ignore trailing '=' padding and whitespace from the input.
         int limit = in.length();
         for (; limit > 0; limit--) {
@@ -114,19 +128,16 @@ public static byte[] decode(String in) {
         return prefix;
     }
 
-    private static final byte[] MAP = new byte[]{
-            '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', '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', '0', '1', '2', '3', '4',
-            '5', '6', '7', '8', '9', '+', '/'
-    };
+    static String encode(byte[] in) {
+        return encode(in, false, true);
+    }
 
-    public static String encode(byte[] in) {
-        return encode(in, MAP);
+    static String encode(byte[] in, boolean urlSafe, boolean usePadding) {
+        return encode(in, urlSafe ? URL_MAP : MAP, usePadding);
     }
 
-    private static String encode(byte[] in, byte[] map) {
-        int length = (in.length + 2) / 3 * 4;
+    private static String encode(byte[] in, byte[] map, boolean usePadding) {
+        int length = outLength(in.length, usePadding);
         byte[] out = new byte[length];
         int index = 0, end = in.length - in.length % 3;
         for (int i = 0; i < end; i += 3) {
@@ -139,16 +150,32 @@ private static String encode(byte[] in, byte[] map) {
             case 1:
                 out[index++] = map[(in[end] & 0xff) >> 2];
                 out[index++] = map[(in[end] & 0x03) << 4];
-                out[index++] = '=';
-                out[index++] = '=';
+                if (usePadding) {
+                    out[index++] = '=';
+                    out[index] = '=';
+                }
                 break;
             case 2:
                 out[index++] = map[(in[end] & 0xff) >> 2];
                 out[index++] = map[((in[end] & 0x03) << 4) | ((in[end + 1] & 0xff) >> 4)];
                 out[index++] = map[((in[end + 1] & 0x0f) << 2)];
-                out[index++] = '=';
+
+                if (usePadding) {
+                    out[index] = '=';
+                }
                 break;
         }
         return new String(out, StandardCharsets.US_ASCII);
     }
+
+    private static int outLength(int srclen, boolean doPadding) {
+        int len;
+        if (doPadding) {
+            len = 4 * ((srclen + 2) / 3);
+        } else {
+            int n = srclen % 3;
+            len = 4 * (srclen / 3) + (n == 0 ? 0 : n + 1);
+        }
+        return len;
+    }
 }
diff --git a/src/main/java/at/favre/lib/bytes/BinaryToTextEncoding.java b/src/main/java/at/favre/lib/bytes/BinaryToTextEncoding.java
@@ -132,9 +132,21 @@ public byte[] decode(String hexString) {
      * Simple Base64 encoder
      */
     class Base64Encoding implements EncoderDecoder {
+        private final boolean urlSafe;
+        private final boolean padding;
+
+        Base64Encoding() {
+            this(false, true);
+        }
+
+        Base64Encoding(boolean urlSafe, boolean padding) {
+            this.urlSafe = urlSafe;
+            this.padding = padding;
+        }
+
         @Override
         public String encode(byte[] array, ByteOrder byteOrder) {
-            return Base64.encode((byteOrder == ByteOrder.BIG_ENDIAN) ? array : Bytes.from(array).reverse().array());
+            return Base64.encode((byteOrder == ByteOrder.BIG_ENDIAN) ? array : Bytes.from(array).reverse().array(), urlSafe, padding);
         }
 
         @Override
diff --git a/src/main/java/at/favre/lib/bytes/Bytes.java b/src/main/java/at/favre/lib/bytes/Bytes.java
@@ -21,11 +21,7 @@
 
 package at.favre.lib.bytes;
 
-import java.io.ByteArrayInputStream;
-import java.io.DataInput;
-import java.io.File;
-import java.io.InputStream;
-import java.io.Serializable;
+import java.io.*;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -35,14 +31,7 @@
 import java.nio.charset.StandardCharsets;
 import java.security.SecureRandom;
 import java.text.Normalizer;
-import java.util.Arrays;
-import java.util.BitSet;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Objects;
-import java.util.Random;
-import java.util.UUID;
+import java.util.*;
 
 /**
  * Bytes is wrapper class for an byte-array that allows a lot of convenience operations on it:
@@ -567,7 +556,7 @@ public static Bytes parseBase36(String base36String) {
     }
 
     /**
-     * Parsing of base64 encoded byte arrays.
+     * Parsing of base64 encoded byte arrays. Supporting RFC 3548 normal and url safe encoding.
      *
      * @param base64String the encoded string
      * @return decoded instance
@@ -1482,7 +1471,20 @@ public String encodeBase36() {
      * @see <a href="https://en.wikipedia.org/wiki/Base64">Base64</a>
      */
     public String encodeBase64() {
-        return encode(new BinaryToTextEncoding.Base64Encoding());
+        return encode(new BinaryToTextEncoding.Base64Encoding(false, true));
+    }
+
+    /**
+     * Base64 representation with padding. This is the url safe variation subsitution '+' and '/' with '-' and '_'
+     * respectively. This encoding has a space efficiency of 75%.
+     * <p>
+     * Example: <code>SpT9_x6v7Q==</code>
+     *
+     * @return base64 url safe string
+     * @see <a href="https://en.wikipedia.org/wiki/Base64">Base64</a>
+     */
+    public String encodeBase64Url() {
+        return encode(new BinaryToTextEncoding.Base64Encoding(true, true));
     }
 
     /**
diff --git a/src/test/java/at/favre/lib/bytes/BinaryToTextEncodingTest.java b/src/test/java/at/favre/lib/bytes/BinaryToTextEncodingTest.java
@@ -81,12 +81,23 @@ public void encodeDecodeRadixZeros() {
 
     @Test
     public void encodeDecodeBase64() {
-        for (int i = 4; i < 32; i += 4) {
+        BinaryToTextEncoding.EncoderDecoder encoderPad = new BinaryToTextEncoding.Base64Encoding(false, true);
+        BinaryToTextEncoding.EncoderDecoder encoderUrlPad = new BinaryToTextEncoding.Base64Encoding(true, true);
+        BinaryToTextEncoding.EncoderDecoder encoderNoPad = new BinaryToTextEncoding.Base64Encoding(false, false);
+
+        for (int i = 0; i < 32; i += 4) {
             Bytes rnd = Bytes.random(i);
-            BinaryToTextEncoding.EncoderDecoder encoding = new BinaryToTextEncoding.Base64Encoding();
-            String encodedBigEndian = encoding.encode(rnd.array(), ByteOrder.BIG_ENDIAN);
-            byte[] decoded = encoding.decode(encodedBigEndian);
+            String encodedBigEndian = encoderPad.encode(rnd.array(), ByteOrder.BIG_ENDIAN);
+            byte[] decoded = encoderPad.decode(encodedBigEndian);
             assertEquals(rnd, Bytes.wrap(decoded));
+
+            String encodedBigEndianUrlPad = encoderUrlPad.encode(rnd.array(), ByteOrder.BIG_ENDIAN);
+            byte[] decodedUrlPad = encoderPad.decode(encodedBigEndianUrlPad);
+            assertEquals(rnd, Bytes.wrap(decodedUrlPad));
+
+            String encodedBigEndianNoPad = encoderNoPad.encode(rnd.array(), ByteOrder.BIG_ENDIAN);
+            byte[] decodedNoPad = encoderPad.decode(encodedBigEndianNoPad);
+            assertEquals(rnd, Bytes.wrap(decodedNoPad));
         }
     }
 
diff --git a/src/test/java/at/favre/lib/bytes/BytesParseAndEncodingTest.java b/src/test/java/at/favre/lib/bytes/BytesParseAndEncodingTest.java
@@ -31,12 +31,12 @@ public class BytesParseAndEncodingTest extends ABytesTest {
     private byte[] encodingExample;
 
     @Before
-    public void setUp() throws Exception {
+    public void setUp() {
         encodingExample = new byte[]{0x4A, (byte) 0x94, (byte) 0xFD, (byte) 0xFF, 0x1E, (byte) 0xAF, (byte) 0xED};
     }
 
     @Test
-    public void parseHex() throws Exception {
+    public void parseHex() {
         byte[] defaultArray = new byte[]{(byte) 0xA0, (byte) 0xE1};
         assertArrayEquals(defaultArray, Bytes.parseHex("0xA0E1").array());
         assertArrayEquals(defaultArray, Bytes.parseHex("A0E1").array());
@@ -45,12 +45,12 @@ public void parseHex() throws Exception {
     }
 
     @Test(expected = IllegalArgumentException.class)
-    public void parseHexInvalid() throws Exception {
+    public void parseHexInvalid() {
         Bytes.parseHex("A0E");
     }
 
     @Test
-    public void encodeHex() throws Exception {
+    public void encodeHex() {
         byte[] defaultArray = new byte[]{(byte) 0xA0, (byte) 0xE1};
         assertEquals("a0e1", Bytes.from(defaultArray).encodeHex());
         assertEquals("A0E1", Bytes.from(defaultArray).encodeHex(true));
@@ -59,58 +59,68 @@ public void encodeHex() throws Exception {
     }
 
     @Test
-    public void parseBase64() throws Exception {
+    public void parseBase64() {
         assertArrayEquals(encodingExample, Bytes.parseBase64("SpT9/x6v7Q==").array());
+        assertArrayEquals(encodingExample, Bytes.parseBase64("SpT9_x6v7Q==").array());
     }
 
     @Test(expected = IllegalArgumentException.class)
-    public void parseBase64Invalid() throws Exception {
+    public void parseBase64Invalid() {
         Bytes.parseBase64("☕");
     }
 
     @Test
-    public void encodeBase64() throws Exception {
+    public void encodeBase64() {
+        assertEquals("", Bytes.from(new byte[0]).encodeBase64());
+        assertEquals("AA==", Bytes.from(new byte[1]).encodeBase64());
         assertEquals("SpT9/x6v7Q==", Bytes.from(encodingExample).encodeBase64());
     }
 
     @Test
-    public void encodeBinary() throws Exception {
+    public void encodeBase64Url() {
+        assertEquals("", Bytes.from(new byte[0]).encodeBase64Url());
+        assertEquals("AA==", Bytes.from(new byte[1]).encodeBase64Url());
+        assertEquals("SpT9_x6v7Q==", Bytes.from(encodingExample).encodeBase64Url());
+    }
+
+    @Test
+    public void encodeBinary() {
         byte[] defaultArray = new byte[]{(byte) 0xA0, (byte) 0xE1};
         assertEquals("1010000011100001", Bytes.from(defaultArray).encodeBinary());
         assertEquals("1001010100101001111110111111111000111101010111111101101", Bytes.from(encodingExample).encodeBinary());
     }
 
     @Test
-    public void parseOctal() throws Exception {
+    public void parseOctal() {
         assertArrayEquals(encodingExample, Bytes.parseOctal("1124517677707527755").array());
     }
 
     @Test
-    public void encodeOctal() throws Exception {
+    public void encodeOctal() {
         byte[] defaultArray = new byte[]{(byte) 0xA0, (byte) 0xE1};
         assertEquals("120341", Bytes.from(defaultArray).encodeOctal());
         assertEquals("1124517677707527755", Bytes.from(encodingExample).encodeOctal());
     }
 
     @Test
-    public void parseDec() throws Exception {
+    public void parseDec() {
         assertArrayEquals(encodingExample, Bytes.parseDec("20992966904426477").array());
     }
 
     @Test
-    public void encodeDec() throws Exception {
+    public void encodeDec() {
         byte[] defaultArray = new byte[]{(byte) 0xA0, (byte) 0xE1};
         assertEquals("41185", Bytes.from(defaultArray).encodeDec());
         assertEquals("20992966904426477", Bytes.from(encodingExample).encodeDec());
     }
 
     @Test
-    public void parseBase36() throws Exception {
+    public void parseBase36() {
         assertArrayEquals(encodingExample, Bytes.parseBase36("5qpdvuwjvu5").array());
     }
 
     @Test
-    public void encodeBase36() throws Exception {
+    public void encodeBase36() {
         byte[] defaultArray = new byte[]{(byte) 0xA0, (byte) 0xE1, (byte) 0x13};
         assertEquals("69zbn", Bytes.from(defaultArray).encodeBase36());
         assertEquals("5qpdvuwjvu5", Bytes.from(encodingExample).encodeBase36());
