Merge pull request #157 from simon04/base64

martijndwars · web-flow · commit 3796a43f5248 · 2021-02-07T22:20:33.000+01:00
Migrate to java.util.Base64
diff --git a/src/main/java/nl/martijndwars/webpush/AbstractPushService.java b/src/main/java/nl/martijndwars/webpush/AbstractPushService.java
@@ -19,6 +19,7 @@
 import java.security.PublicKey;
 import java.security.SecureRandom;
 import java.security.spec.InvalidKeySpecException;
+import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -164,8 +165,8 @@ protected final HttpRequest prepareRequest(Notification notification, Encoding e
                 headers.put("Content-Encoding", "aes128gcm");
             } else if (encoding == Encoding.AESGCM) {
                 headers.put("Content-Encoding", "aesgcm");
-                headers.put("Encryption", "salt=" + Base64Encoder.encodeUrlWithoutPadding(salt));
-                headers.put("Crypto-Key", "dh=" + Base64Encoder.encodeUrl(dh));
+                headers.put("Encryption", "salt=" + Base64.getUrlEncoder().withoutPadding().encodeToString(salt));
+                headers.put("Crypto-Key", "dh=" + Base64.getUrlEncoder().encodeToString(dh));
             }
 
             body = encrypted.getCiphertext();
@@ -201,15 +202,15 @@ protected final HttpRequest prepareRequest(Notification notification, Encoding e
             byte[] pk = Utils.encode((ECPublicKey) getPublicKey());
 
             if (encoding == Encoding.AES128GCM) {
-                headers.put("Authorization", "vapid t=" + jws.getCompactSerialization() + ", k=" + Base64Encoder.encodeUrlWithoutPadding(pk));
+                headers.put("Authorization", "vapid t=" + jws.getCompactSerialization() + ", k=" + Base64.getUrlEncoder().withoutPadding().encodeToString(pk));
             } else if (encoding == Encoding.AESGCM) {
                 headers.put("Authorization", "WebPush " + jws.getCompactSerialization());
             }
 
             if (headers.containsKey("Crypto-Key")) {
-                headers.put("Crypto-Key", headers.get("Crypto-Key") + ";p256ecdsa=" + Base64Encoder.encodeUrlWithoutPadding(pk));
+                headers.put("Crypto-Key", headers.get("Crypto-Key") + ";p256ecdsa=" + Base64.getUrlEncoder().encodeToString(pk));
             } else {
-                headers.put("Crypto-Key", "p256ecdsa=" + Base64Encoder.encodeUrl(pk));
+                headers.put("Crypto-Key", "p256ecdsa=" + Base64.getUrlEncoder().encodeToString(pk));
             }
         } else if (notification.isFcm() && getGcmApiKey() != null) {
             headers.put("Authorization", "key=" + getGcmApiKey());
diff --git a/src/main/java/nl/martijndwars/webpush/Base64Encoder.java b/src/main/java/nl/martijndwars/webpush/Base64Encoder.java
diff --git a/src/main/java/nl/martijndwars/webpush/HttpEce.java b/src/main/java/nl/martijndwars/webpush/HttpEce.java
@@ -12,6 +12,7 @@
 import java.nio.ByteBuffer;
 import java.security.*;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -437,7 +438,7 @@ private static byte[] intToBytes(int number) {
      */
     private static byte[] log(String info, byte[] array) {
         if ("1".equals(System.getenv("ECE_KEYLOG"))) {
-            System.out.println(info + " [" + array.length + "]: " + Base64Encoder.encodeUrlWithoutPadding(array));
+            System.out.println(info + " [" + array.length + "]: " + Base64.getUrlEncoder().withoutPadding().encodeToString(array));
         }
 
         return array;
diff --git a/src/main/java/nl/martijndwars/webpush/Notification.java b/src/main/java/nl/martijndwars/webpush/Notification.java
@@ -8,6 +8,7 @@
 import java.security.NoSuchProviderException;
 import java.security.PublicKey;
 import java.security.spec.InvalidKeySpecException;
+import java.util.Base64;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
@@ -71,23 +72,23 @@ public Notification(String endpoint, PublicKey userPublicKey, byte[] userAuth, b
     }
 
     public Notification(String endpoint, String userPublicKey, String userAuth, byte[] payload, int ttl)  throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
-        this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload, ttl);
+        this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload, ttl);
     }
 
     public Notification(String endpoint, PublicKey userPublicKey, byte[] userAuth, byte[] payload) {
         this(endpoint, userPublicKey, userAuth, payload, DEFAULT_TTL);
     }
 
     public Notification(String endpoint, String userPublicKey, String userAuth, byte[] payload) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
-        this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload);
+        this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload);
     }
 
     public Notification(String endpoint, String userPublicKey, String userAuth, String payload) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
-        this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload.getBytes(UTF_8));
+        this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload.getBytes(UTF_8));
     }
 
 	public Notification(String endpoint, String userPublicKey, String userAuth, String payload, Urgency urgency) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
-		this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload.getBytes(UTF_8));
+		this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload.getBytes(UTF_8));
 		this.urgency = urgency;
 	}
 
@@ -200,7 +201,7 @@ public NotificationBuilder userPublicKey(byte[] publicKey) throws NoSuchAlgorith
         }
 
         public NotificationBuilder userAuth(String userAuth) {
-            this.userAuth = Base64Encoder.decode(userAuth);
+            this.userAuth = Base64.getUrlDecoder().decode(userAuth);
             return this;
         }
 
diff --git a/src/main/java/nl/martijndwars/webpush/Utils.java b/src/main/java/nl/martijndwars/webpush/Utils.java
@@ -15,6 +15,7 @@
 import java.nio.ByteBuffer;
 import java.security.*;
 import java.security.spec.InvalidKeySpecException;
+import java.util.Base64;
 
 import static org.bouncycastle.jce.provider.BouncyCastleProvider.PROVIDER_NAME;
 
@@ -45,7 +46,7 @@ public static byte[] encode(ECPrivateKey privateKey) {
      * @param encodedPublicKey
      */
     public static PublicKey loadPublicKey(String encodedPublicKey) throws NoSuchProviderException, NoSuchAlgorithmException, InvalidKeySpecException {
-        byte[] decodedPublicKey = Base64Encoder.decode(encodedPublicKey);
+        byte[] decodedPublicKey = Base64.getUrlDecoder().decode(encodedPublicKey);
         return loadPublicKey(decodedPublicKey);
     }
 
@@ -74,7 +75,7 @@ public static PublicKey loadPublicKey(byte[] decodedPublicKey) throws NoSuchProv
      * @throws InvalidKeySpecException
      */
     public static PrivateKey loadPrivateKey(String encodedPrivateKey) throws NoSuchProviderException, NoSuchAlgorithmException, InvalidKeySpecException {
-        byte[] decodedPrivateKey = Base64Encoder.decode(encodedPrivateKey);
+        byte[] decodedPrivateKey = Base64.getUrlDecoder().decode(encodedPrivateKey);
         return loadPrivateKey(decodedPrivateKey);
     }
 
diff --git a/src/main/java/nl/martijndwars/webpush/cli/handlers/GenerateKeyHandler.java b/src/main/java/nl/martijndwars/webpush/cli/handlers/GenerateKeyHandler.java
@@ -1,6 +1,5 @@
 package nl.martijndwars.webpush.cli.handlers;
 
-import nl.martijndwars.webpush.Base64Encoder;
 import nl.martijndwars.webpush.Utils;
 import nl.martijndwars.webpush.cli.commands.GenerateKeyCommand;
 import org.bouncycastle.jce.ECNamedCurveTable;
@@ -15,6 +14,7 @@
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.security.*;
+import java.util.Base64;
 
 import static nl.martijndwars.webpush.Utils.ALGORITHM;
 import static nl.martijndwars.webpush.Utils.CURVE;
@@ -42,10 +42,10 @@ public void run() throws InvalidAlgorithmParameterException, NoSuchAlgorithmExce
         }
 
         System.out.println("PublicKey:");
-        System.out.println(Base64Encoder.encodeUrl(encodedPublicKey));
+        System.out.println(Base64.getUrlEncoder().encodeToString(encodedPublicKey));
 
         System.out.println("PrivateKey:");
-        System.out.println(Base64Encoder.encodeUrl(encodedPrivateKey));
+        System.out.println(Base64.getUrlEncoder().encodeToString(encodedPrivateKey));
     }
 
     /**
diff --git a/src/test/java/nl/martijndwars/webpush/Base64EncoderTest.java b/src/test/java/nl/martijndwars/webpush/Base64EncoderTest.java
diff --git a/src/test/java/nl/martijndwars/webpush/HttpEceTest.java b/src/test/java/nl/martijndwars/webpush/HttpEceTest.java
@@ -7,9 +7,9 @@
 import org.junit.jupiter.api.Test;
 
 import java.security.*;
+import java.util.Base64;
 import java.util.HashMap;
 
-import static nl.martijndwars.webpush.Base64Encoder.decode;
 import static nl.martijndwars.webpush.Encoding.AES128GCM;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
@@ -19,6 +19,10 @@ public static void addSecurityProvider() {
         Security.addProvider(new BouncyCastleProvider());
     }
 
+    private byte[] decode(String s) {
+        return Base64.getUrlDecoder().decode(s);
+    }
+
     @Test
     public void testZeroSaltAndKey() throws GeneralSecurityException {
         HttpEce httpEce = new HttpEce();
diff --git a/src/test/java/nl/martijndwars/webpush/selenium/SeleniumTests.java b/src/test/java/nl/martijndwars/webpush/selenium/SeleniumTests.java
@@ -1,13 +1,13 @@
 package nl.martijndwars.webpush.selenium;
 
-import nl.martijndwars.webpush.Base64Encoder;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.TestFactory;
 
 import java.io.IOException;
 import java.security.Security;
+import java.util.Base64;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.DynamicTest.dynamicTest;
@@ -58,8 +58,8 @@ public Stream<DynamicTest> dynamicTests() throws IOException {
      * @return
      */
     protected Stream<Configuration> getConfigurations() {
-        String PUBLIC_KEY_NO_PADDING = Base64Encoder.encodeWithoutPadding(
-                Base64Encoder.decode(PUBLIC_KEY)
+        String PUBLIC_KEY_NO_PADDING = Base64.getUrlEncoder().withoutPadding().encodeToString(
+                Base64.getUrlDecoder().decode(PUBLIC_KEY)
         );
 
         return Stream.of(

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`import java.security.NoSuchProviderException;`
`9`	`9`	`import java.security.PublicKey;`
`10`	`10`	`import java.security.spec.InvalidKeySpecException;`
	`11`	`+import java.util.Base64;`
`11`	`12`
`12`	`13`	`import static java.nio.charset.StandardCharsets.UTF_8;`
`13`	`14`
`@@ -71,23 +72,23 @@ public Notification(String endpoint, PublicKey userPublicKey, byte[] userAuth, b`
`71`	`72`	`}`
`72`	`73`
`73`	`74`	`public Notification(String endpoint, String userPublicKey, String userAuth, byte[] payload, int ttl) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {`
`74`		`- this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload, ttl);`
	`75`	`+ this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload, ttl);`
`75`	`76`	`}`
`76`	`77`
`77`	`78`	`public Notification(String endpoint, PublicKey userPublicKey, byte[] userAuth, byte[] payload) {`
`78`	`79`	`this(endpoint, userPublicKey, userAuth, payload, DEFAULT_TTL);`
`79`	`80`	`}`
`80`	`81`
`81`	`82`	`public Notification(String endpoint, String userPublicKey, String userAuth, byte[] payload) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {`
`82`		`- this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload);`
	`83`	`+ this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload);`
`83`	`84`	`}`
`84`	`85`
`85`	`86`	`public Notification(String endpoint, String userPublicKey, String userAuth, String payload) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {`
`86`		`- this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload.getBytes(UTF_8));`
	`87`	`+ this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload.getBytes(UTF_8));`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`public Notification(String endpoint, String userPublicKey, String userAuth, String payload, Urgency urgency) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {`
`90`		`- this(endpoint, Utils.loadPublicKey(userPublicKey), Base64Encoder.decode(userAuth), payload.getBytes(UTF_8));`
	`91`	`+ this(endpoint, Utils.loadPublicKey(userPublicKey), Base64.getUrlDecoder().decode(userAuth), payload.getBytes(UTF_8));`
`91`	`92`	`this.urgency = urgency;`
`92`	`93`	`}`
`93`	`94`
`@@ -200,7 +201,7 @@ public NotificationBuilder userPublicKey(byte[] publicKey) throws NoSuchAlgorith`
`200`	`201`	`}`
`201`	`202`
`202`	`203`	`public NotificationBuilder userAuth(String userAuth) {`
`203`		`- this.userAuth = Base64Encoder.decode(userAuth);`
	`204`	`+ this.userAuth = Base64.getUrlDecoder().decode(userAuth);`
`204`	`205`	`return this;`
`205`	`206`	`}`
`206`	`207`