Support specifying the Cryptography Provider by name and instance

lib/src/main/java/com/auth0/jwt/JWTCreator.java

@@ -3,13 +3,19 @@
 import com.auth0.jwt.algorithms.Algorithm;
 import com.auth0.jwt.exceptions.JWTCreationException;
 import com.auth0.jwt.exceptions.SignatureGenerationException;
-import com.auth0.jwt.impl.*;
+import com.auth0.jwt.impl.HeaderClaimsHolder;
+import com.auth0.jwt.impl.HeaderSerializer;
+import com.auth0.jwt.impl.PayloadClaimsHolder;
+import com.auth0.jwt.impl.PayloadSerializer;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 
 import java.nio.charset.StandardCharsets;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.Security;
 import java.time.Instant;
 import java.util.*;
 import java.util.Map.Entry;
@@ -23,10 +29,6 @@
 @SuppressWarnings("WeakerAccess")
 public final class JWTCreator {
 
-    private final Algorithm algorithm;
-    private final String headerJson;
-    private final String payloadJson;
-
     private static final ObjectMapper mapper;
     private static final SimpleModule module;
 
@@ -39,6 +41,10 @@ public final class JWTCreator {
         mapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true);
     }
 
+    private final Algorithm algorithm;
+    private final String headerJson;
+    private final String payloadJson;
+
     private JWTCreator(Algorithm algorithm, Map<String, Object> headerClaims, Map<String, Object> payloadClaims)
             throws JWTCreationException {
         this.algorithm = algorithm;
@@ -60,6 +66,19 @@ static JWTCreator.Builder init() {
         return new Builder();
     }
 
+    private String sign(Provider cryptoProvider) throws SignatureGenerationException {
+        String header = Base64.getUrlEncoder().withoutPadding()
+                .encodeToString(headerJson.getBytes(StandardCharsets.UTF_8));
+        String payload = Base64.getUrlEncoder().withoutPadding()
+                .encodeToString(payloadJson.getBytes(StandardCharsets.UTF_8));
+
+        byte[] signatureBytes = algorithm.sign(header.getBytes(StandardCharsets.UTF_8),
+                payload.getBytes(StandardCharsets.UTF_8), cryptoProvider);
+        String signature = Base64.getUrlEncoder().withoutPadding().encodeToString((signatureBytes));
+
+        return String.format("%s.%s.%s", header, payload, signature);
+    }
+
     /**
      * The Builder class holds the Claims that defines the JWT to be created.
      */
@@ -72,6 +91,55 @@ public static class Builder {
             this.headerClaims = new HashMap<>();
         }
 
+        private static boolean validateClaim(Map<?, ?> map) {
+            // do not accept null values in maps
+            for (Entry<?, ?> entry : map.entrySet()) {
+                Object value = entry.getValue();
+                if (!isSupportedType(value)) {
+                    return false;
+                }
+
+                if (entry.getKey() == null || !(entry.getKey() instanceof String)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private static boolean validateClaim(List<?> list) {
+            // accept null values in list
+            for (Object object : list) {
+                if (!isSupportedType(object)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private static boolean isSupportedType(Object value) {
+            if (value instanceof List) {
+                return validateClaim((List<?>) value);
+            } else if (value instanceof Map) {
+                return validateClaim((Map<?, ?>) value);
+            } else {
+                return isBasicType(value);
+            }
+        }
+
+        private static boolean isBasicType(Object value) {
+            if (value == null) {
+                return true;
+            } else {
+                Class<?> c = value.getClass();
+
+                if (c.isArray()) {
+                    return c == Integer[].class || c == Long[].class || c == String[].class;
+                }
+                return c == String.class || c == Integer.class || c == Long.class || c == Double.class
+                        || c == Date.class || c == Instant.class || c == Boolean.class;
+            }
+        }
+
         /**
          * Add specific Claims to set as the Header.
          * If provided map is null then nothing is changed
@@ -481,65 +549,58 @@ private boolean validatePayload(Map<String, ?> payload) {
             return true;
         }
 
-        private static boolean validateClaim(Map<?, ?> map) {
-            // do not accept null values in maps
-            for (Entry<?, ?> entry : map.entrySet()) {
-                Object value = entry.getValue();
-                if (!isSupportedType(value)) {
-                    return false;
-                }
+        /**
+         * Creates a new JWT and signs is with the given algorithm.
+         *
+         * @param algorithm used to sign the JWT
+         * @return a new JWT token
+         * @throws IllegalArgumentException if the provided algorithm is null.
+         * @throws JWTCreationException     if the claims could not be converted to a valid JSON
+         *                                  or there was a problem with the signing key.
+         */
+        public String sign(Algorithm algorithm) throws IllegalArgumentException, JWTCreationException {
 
-                if (entry.getKey() == null || !(entry.getKey() instanceof String)) {
-                    return false;
-                }
-            }
-            return true;
+            return this.sign(algorithm, (Provider) null);
         }
 
-        private static boolean validateClaim(List<?> list) {
-            // accept null values in list
-            for (Object object : list) {
-                if (!isSupportedType(object)) {
-                    return false;
-                }
+        /**
+         * Creates a new JWT and signs is with the given algorithm.
+         *
+         * @param algorithm    used to sign the JWT
+         * @param providerName the provider to use for crypto operations
+         * @return a new JWT token
+         * @throws IllegalArgumentException if the provided algorithm is null.
+         * @throws JWTCreationException     if the claims could not be converted to a valid JSON
+         *                                  or there was a problem with the signing key.
+         * @throws NoSuchProviderException  if a provider with providerName name cannot be found with
+         *                                  {@link Security#getProvider(String)}
+         */
+        public String sign(Algorithm algorithm, String providerName)
+                throws IllegalArgumentException, JWTCreationException, NoSuchProviderException {
+            if (providerName == null) {
+                throw new IllegalArgumentException("providerName cannot be null");
             }
-            return true;
-        }
 
-        private static boolean isSupportedType(Object value) {
-            if (value instanceof List) {
-                return validateClaim((List<?>) value);
-            } else if (value instanceof Map) {
-                return validateClaim((Map<?, ?>) value);
-            } else {
-                return isBasicType(value);
+            Provider provider = Security.getProvider(providerName);
+            if (provider == null) {
+                throw new NoSuchProviderException(String.format("No provider named [%s] installed", providerName));
             }
-        }
-
-        private static boolean isBasicType(Object value) {
-            if (value == null) {
-                return true;
-            } else {
-                Class<?> c = value.getClass();
 
-                if (c.isArray()) {
-                    return c == Integer[].class || c == Long[].class || c == String[].class;
-                }
-                return c == String.class || c == Integer.class || c == Long.class || c == Double.class
-                        || c == Date.class || c == Instant.class || c == Boolean.class;
-            }
+            return new JWTCreator(algorithm, headerClaims, payloadClaims).sign(provider);
         }
 
         /**
          * Creates a new JWT and signs is with the given algorithm.
          *
-         * @param algorithm used to sign the JWT
+         * @param algorithm      used to sign the JWT
+         * @param cryptoProvider the provider to use for crypto operations
          * @return a new JWT token
          * @throws IllegalArgumentException if the provided algorithm is null.
          * @throws JWTCreationException     if the claims could not be converted to a valid JSON
          *                                  or there was a problem with the signing key.
          */
-        public String sign(Algorithm algorithm) throws IllegalArgumentException, JWTCreationException {
+        public String sign(Algorithm algorithm, Provider cryptoProvider)
+                throws IllegalArgumentException, JWTCreationException {
             if (algorithm == null) {
                 throw new IllegalArgumentException("The Algorithm cannot be null.");
             }
@@ -551,7 +612,7 @@ public String sign(Algorithm algorithm) throws IllegalArgumentException, JWTCrea
             if (signingKeyId != null) {
                 withKeyId(signingKeyId);
             }
-            return new JWTCreator(algorithm, headerClaims, payloadClaims).sign();
+            return new JWTCreator(algorithm, headerClaims, payloadClaims).sign(cryptoProvider);
         }
 
         private void assertNonNull(String name) {
@@ -563,18 +624,6 @@ private void assertNonNull(String name) {
         private void addClaim(String name, Object value) {
             payloadClaims.put(name, value);
         }
-    }
 
-    private String sign() throws SignatureGenerationException {
-        String header = Base64.getUrlEncoder().withoutPadding()
-                .encodeToString(headerJson.getBytes(StandardCharsets.UTF_8));
-        String payload = Base64.getUrlEncoder().withoutPadding()
-                .encodeToString(payloadJson.getBytes(StandardCharsets.UTF_8));
-
-        byte[] signatureBytes = algorithm.sign(header.getBytes(StandardCharsets.UTF_8),
-                payload.getBytes(StandardCharsets.UTF_8));
-        String signature = Base64.getUrlEncoder().withoutPadding().encodeToString((signatureBytes));
-
-        return String.format("%s.%s.%s", header, payload, signature);
     }
 }