However, a non-trivial number of JJWT users were confused by the method signature and attempted to
- * use raw password strings as the key argument - for example {@code signWith(HS256, myPassword)} - which is
+ * use raw password strings as the key argument - for example {@code with(HS256, myPassword)} - which is
* almost always incorrect for cryptographic hashes and can produce erroneous or insecure results.
*
* {
JwtBuilder signWith(SignatureAlgorithm alg, Key key) throws InvalidKeyException;
/**
+ * Deprecation Notice
+ * This has been deprecated since JJWT_RELEASE_VERSION. Use
+ * {@link #signWith(Key, io.jsonwebtoken.security.SignatureAlgorithm)} instead.. Standard JWA algorithms
+ * are represented as instances of this new interface in the {@link io.jsonwebtoken.security.SignatureAlgorithms}
+ * enum class.
+ *
* Signs the constructed JWT with the specified key using the specified algorithm, producing a JWS.
*
* It is typically recommended to call the {@link #signWith(Key)} instead for simplicity.
@@ -465,9 +497,29 @@ public interface JwtBuilder extends ClaimsMutator {
* the specified algorithm.
* @see #signWith(Key)
* @since 0.10.0
+ * @deprecated since JJWT_RELEASE_VERSION to use a more the more flexible {@link io.jsonwebtoken.security.SignatureAlgorithm}.
*/
+ @Deprecated
JwtBuilder signWith(Key key, SignatureAlgorithm alg) throws InvalidKeyException;
+ /**
+ * Signs the constructed JWT with the specified key using the specified algorithm, producing a JWS.
+ *
+ * It is typically recommended to call the {@link #signWith(Key)} instead for simplicity.
+ * However, this method can be useful if the recommended algorithm heuristics do not meet your needs or if
+ * you want explicit control over the signature algorithm used with the specified key.
+ *
+ * @param key the signing key to use to digitally sign the JWT.
+ * @param alg the JWS algorithm to use with the key to digitally sign the JWT, thereby producing a JWS.
+ * @return the builder for method chaining.
+ * @throws InvalidKeyException if the Key is insufficient or explicitly disallowed by the JWT specification for
+ * the specified algorithm.
+ * @see #signWith(Key)
+ * @see SignatureAlgorithms#forSigningKey(Key)
+ * @since JJWT_RELEASE_VERSION
+ */
+ JwtBuilder signWith(Key key, io.jsonwebtoken.security.SignatureAlgorithm alg) throws InvalidKeyException;
+
/**
* Compresses the JWT body using the specified {@link CompressionCodec}.
*
@@ -477,7 +529,7 @@ public interface JwtBuilder extends ClaimsMutator {
*
* Compatibility Warning
*
- * The JWT family of specifications defines compression only for JWE (Json Web Encryption)
+ *
The JWT family of specifications defines compression only for JWE (JSON Web Encryption)
* tokens. Even so, JJWT will also support compression for JWS tokens as well if you choose to use it.
* However, be aware that if you use compression when creating a JWS token, other libraries may not be able to
* parse that JWS token. When using compression for JWS tokens, be sure that all parties accessing the
diff --git a/api/src/main/java/io/jsonwebtoken/JwtParserBuilder.java b/api/src/main/java/io/jsonwebtoken/JwtParserBuilder.java
index 2e8dd8794..0e9d85ae9 100644
--- a/api/src/main/java/io/jsonwebtoken/JwtParserBuilder.java
+++ b/api/src/main/java/io/jsonwebtoken/JwtParserBuilder.java
@@ -19,6 +19,8 @@
import io.jsonwebtoken.io.Deserializer;
import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
import java.util.Date;
import java.util.Map;
@@ -35,6 +37,17 @@
*/
public interface JwtParserBuilder {
+ /**
+ * Sets the JCA Provider to use during cryptographic signature and decryption operations, or {@code null} if the
+ * JCA subsystem preferred provider should be used.
+ *
+ * @param provider the JCA Provider to use during cryptographic signature and decryption operations, or {@code null}
+ * if the JCA subsystem preferred provider should be used.
+ * @return the builder for method chaining.
+ * @since JJWT_RELEASE_VERSION
+ */
+ JwtParserBuilder setProvider(Provider provider);
+
/**
* Ensures that the specified {@code jti} exists in the parsed JWT. If missing or if the parsed
* value does not equal the specified value, an exception will be thrown indicating that the
diff --git a/api/src/main/java/io/jsonwebtoken/Jwts.java b/api/src/main/java/io/jsonwebtoken/Jwts.java
index 80de65a44..d9f62db44 100644
--- a/api/src/main/java/io/jsonwebtoken/Jwts.java
+++ b/api/src/main/java/io/jsonwebtoken/Jwts.java
@@ -76,6 +76,30 @@ public static JwsHeader jwsHeader(Map header) {
return Classes.newInstance("io.jsonwebtoken.impl.DefaultJwsHeader", MAP_ARG, header);
}
+ /**
+ * Returns a new {@link JweHeader} instance suitable for encrypted JWTs (aka 'JWE's).
+ *
+ * @return a new {@link JweHeader} instance suitable for encrypted JWTs (aka 'JWE's).
+ * @see JwtBuilder#setHeader(Header)
+ * @since JJWT_RELEASE_VERSION
+ */
+ public static JweHeader jweHeader() {
+ return Classes.newInstance("io.jsonwebtoken.impl.DefaultJweHeader");
+ }
+
+ /**
+ * Returns a new {@link JweHeader} instance suitable for encrypted JWTs (aka 'JWE's), populated with the
+ * specified name/value pairs.
+ *
+ * @return a new {@link JweHeader} instance suitable for encrypted JWTs (aka 'JWE's), populated with the
+ * specified name/value pairs.
+ * @see JwtBuilder#setHeader(Header)
+ * @since JJWT_RELEASE_VERSION
+ */
+ public static JweHeader jweHeader(Map header) {
+ return Classes.newInstance("io.jsonwebtoken.impl.DefaultJweHeader", MAP_ARG, header);
+ }
+
/**
* Returns a new {@link Claims} instance to be used as a JWT body.
*
diff --git a/api/src/main/java/io/jsonwebtoken/Named.java b/api/src/main/java/io/jsonwebtoken/Named.java
new file mode 100644
index 000000000..0bd6064ce
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/Named.java
@@ -0,0 +1,14 @@
+package io.jsonwebtoken;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface Named {
+
+ /**
+ * Returns the string name of the associated object.
+ *
+ * @return the string name of the associated object.
+ */
+ String getName();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/RequiredTypeException.java b/api/src/main/java/io/jsonwebtoken/RequiredTypeException.java
index eeb60d308..44124615d 100644
--- a/api/src/main/java/io/jsonwebtoken/RequiredTypeException.java
+++ b/api/src/main/java/io/jsonwebtoken/RequiredTypeException.java
@@ -16,12 +16,13 @@
package io.jsonwebtoken;
/**
- * Exception thrown when {@link Claims#get(String, Class)} is called and the value does not match the type of the
- * {@code Class} argument.
+ * Exception thrown when attempting to obtain a value from a JWT or JWK and the existing value does not match the
+ * expected type.
*
* @since 0.6
*/
public class RequiredTypeException extends JwtException {
+
public RequiredTypeException(String message) {
super(message);
}
diff --git a/api/src/main/java/io/jsonwebtoken/SignatureAlgorithm.java b/api/src/main/java/io/jsonwebtoken/SignatureAlgorithm.java
index 9f646502d..1bdafddaf 100644
--- a/api/src/main/java/io/jsonwebtoken/SignatureAlgorithm.java
+++ b/api/src/main/java/io/jsonwebtoken/SignatureAlgorithm.java
@@ -34,7 +34,9 @@
* JSON Web Algorithms specification.
*
* @since 0.1
+ * @deprecated since JJWT_RELEASE_VERSION; use {@link io.jsonwebtoken.security.SignatureAlgorithms} instead.
*/
+@Deprecated
public enum SignatureAlgorithm {
/**
diff --git a/api/src/main/java/io/jsonwebtoken/SignatureException.java b/api/src/main/java/io/jsonwebtoken/SignatureException.java
index e98b4c722..12a2e92d7 100644
--- a/api/src/main/java/io/jsonwebtoken/SignatureException.java
+++ b/api/src/main/java/io/jsonwebtoken/SignatureException.java
@@ -15,7 +15,7 @@
*/
package io.jsonwebtoken;
-import io.jsonwebtoken.security.SecurityException;
+import io.jsonwebtoken.security.CryptoException;
/**
* Exception indicating that either calculating a signature or verifying an existing signature of a JWT failed.
@@ -24,7 +24,7 @@
* @deprecated in favor of {@link io.jsonwebtoken.security.SecurityException}; this class will be removed before 1.0
*/
@Deprecated
-public class SignatureException extends SecurityException {
+public class SignatureException extends CryptoException {
public SignatureException(String message) {
super(message);
diff --git a/api/src/main/java/io/jsonwebtoken/lang/Assert.java b/api/src/main/java/io/jsonwebtoken/lang/Assert.java
index 7c9e7c367..ab6dd2fd4 100644
--- a/api/src/main/java/io/jsonwebtoken/lang/Assert.java
+++ b/api/src/main/java/io/jsonwebtoken/lang/Assert.java
@@ -77,10 +77,11 @@ public static void isNull(Object object) {
* @param message the exception message to use if the assertion fails
* @throws IllegalArgumentException if the object is null
*/
- public static void notNull(Object object, String message) {
+ public static T notNull(T object, String message) {
if (object == null) {
throw new IllegalArgumentException(message);
}
+ return object;
}
/**
@@ -196,10 +197,11 @@ public static void notEmpty(Object[] array) {
notEmpty(array, "[Assertion failed] - this array must not be empty: it must contain at least 1 element");
}
- public static void notEmpty(byte[] array, String msg) {
+ public static byte[] notEmpty(byte[] array, String msg) {
if (Objects.isEmpty(array)) {
throw new IllegalArgumentException(msg);
}
+ return array;
}
/**
diff --git a/api/src/main/java/io/jsonwebtoken/lang/Collections.java b/api/src/main/java/io/jsonwebtoken/lang/Collections.java
index d775a002a..167f23f2b 100644
--- a/api/src/main/java/io/jsonwebtoken/lang/Collections.java
+++ b/api/src/main/java/io/jsonwebtoken/lang/Collections.java
@@ -28,6 +28,17 @@ public final class Collections {
private Collections(){} //prevent instantiation
+ public static List emptyList() {
+ return java.util.Collections.emptyList();
+ }
+
+ public static List of(T... elements) {
+ if (elements == null || elements.length == 0) {
+ return java.util.Collections.emptyList();
+ }
+ return java.util.Collections.unmodifiableList(Arrays.asList(elements));
+ }
+
/**
* Return true if the supplied Collection is null
* or empty. Otherwise, return false.
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadDecryptionRequest.java b/api/src/main/java/io/jsonwebtoken/security/AeadDecryptionRequest.java
new file mode 100644
index 000000000..4f9fa8261
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadDecryptionRequest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadDecryptionRequest extends AeadRequest, AuthenticationTagSource {
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadEncryptionAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/AeadEncryptionAlgorithm.java
new file mode 100644
index 000000000..f903377f1
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadEncryptionAlgorithm.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadEncryptionAlgorithm, ERes extends AeadEncryptionResult, DReq extends AeadDecryptionRequest> extends EncryptionAlgorithm {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadEncryptionResult.java b/api/src/main/java/io/jsonwebtoken/security/AeadEncryptionResult.java
new file mode 100644
index 000000000..292810620
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadEncryptionResult.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadEncryptionResult extends EncryptionResult, AuthenticationTagSource {
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadIvEncryptionResult.java b/api/src/main/java/io/jsonwebtoken/security/AeadIvEncryptionResult.java
new file mode 100644
index 000000000..8524f1d57
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadIvEncryptionResult.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadIvEncryptionResult extends IvEncryptionResult, AeadEncryptionResult {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadIvRequest.java b/api/src/main/java/io/jsonwebtoken/security/AeadIvRequest.java
new file mode 100644
index 000000000..05159ef23
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadIvRequest.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadIvRequest extends IvRequest, AeadDecryptionRequest {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadRequest.java b/api/src/main/java/io/jsonwebtoken/security/AeadRequest.java
new file mode 100644
index 000000000..8112813fe
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadRequest.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadRequest extends CryptoRequest, AssociatedDataSource {
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AeadSymmetricEncryptionAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/AeadSymmetricEncryptionAlgorithm.java
new file mode 100644
index 000000000..4e74987f7
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AeadSymmetricEncryptionAlgorithm.java
@@ -0,0 +1,11 @@
+package io.jsonwebtoken.security;
+
+import javax.crypto.SecretKey;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AeadSymmetricEncryptionAlgorithm extends
+ SymmetricEncryptionAlgorithm, AeadIvEncryptionResult, AeadIvRequest>,
+ AeadEncryptionAlgorithm, AeadIvEncryptionResult, AeadIvRequest> {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AssociatedDataSource.java b/api/src/main/java/io/jsonwebtoken/security/AssociatedDataSource.java
new file mode 100644
index 000000000..0acd5555d
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AssociatedDataSource.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AssociatedDataSource {
+
+ byte[] getAssociatedData();
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AsymmetricKeyAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/AsymmetricKeyAlgorithm.java
new file mode 100644
index 000000000..84624225f
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AsymmetricKeyAlgorithm.java
@@ -0,0 +1,16 @@
+package io.jsonwebtoken.security;
+
+import java.security.KeyPair;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AsymmetricKeyAlgorithm {
+
+ /**
+ * Generates a new secure-random key pair with a key length suitable for this Algorithm.
+ *
+ * @return a new secure-random key pair with a key length suitable for this Algorithm.
+ */
+ KeyPair generateKeyPair();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AsymmetricKeySignatureAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/AsymmetricKeySignatureAlgorithm.java
new file mode 100644
index 000000000..93279d698
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AsymmetricKeySignatureAlgorithm.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AsymmetricKeySignatureAlgorithm extends SignatureAlgorithm, AsymmetricKeyAlgorithm {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/AuthenticationTagSource.java b/api/src/main/java/io/jsonwebtoken/security/AuthenticationTagSource.java
new file mode 100644
index 000000000..b7e1f55ec
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/AuthenticationTagSource.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface AuthenticationTagSource {
+
+ byte[] getAuthenticationTag();
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/CryptoException.java b/api/src/main/java/io/jsonwebtoken/security/CryptoException.java
new file mode 100644
index 000000000..6d3b26fb3
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/CryptoException.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class CryptoException extends SecurityException {
+
+ public CryptoException(String message) {
+ super(message);
+ }
+
+ public CryptoException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/CryptoMessage.java b/api/src/main/java/io/jsonwebtoken/security/CryptoMessage.java
new file mode 100644
index 000000000..9d904c471
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/CryptoMessage.java
@@ -0,0 +1,10 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface CryptoMessage {
+
+ T getData(); //plaintext, ciphertext, or Key for key wrap algorithms
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/CryptoRequest.java b/api/src/main/java/io/jsonwebtoken/security/CryptoRequest.java
new file mode 100644
index 000000000..489dfe01b
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/CryptoRequest.java
@@ -0,0 +1,36 @@
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface CryptoRequest extends CryptoMessage {
+
+ /**
+ * Returns the JCA provider that should be used for cryptographic operations during the request or
+ * {@code null} if the JCA subsystem preferred provider should be used.
+ *
+ * @return the JCA provider that should be used for cryptographic operations during the request or
+ * {@code null} if the JCA subsystem preferred provider should be used.
+ */
+ Provider getProvider();
+
+ /**
+ * Returns the {@code SecureRandom} to use when performing cryptographic operations during the request, or
+ * {@code null} if a default {@link SecureRandom} should be used.
+ *
+ * @return the {@code SecureRandom} to use when performing cryptographic operations during the request, or
+ * {@code null} if a default {@link SecureRandom} should be used.
+ */
+ SecureRandom getSecureRandom();
+
+ /**
+ * Returns the key to use for signing, wrapping, encryption or decryption depending on the type of request.
+ *
+ * @return the key to use for signing, wrapping, encryption or decryption depending on the type of request.
+ */
+ K getKey();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/CurveId.java b/api/src/main/java/io/jsonwebtoken/security/CurveId.java
new file mode 100644
index 000000000..415783359
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/CurveId.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface CurveId {
+
+ String toString();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/CurveIds.java b/api/src/main/java/io/jsonwebtoken/security/CurveIds.java
new file mode 100644
index 000000000..fffefe506
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/CurveIds.java
@@ -0,0 +1,44 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Maps;
+import io.jsonwebtoken.lang.Strings;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class CurveIds {
+
+ public static final CurveId P256 = new DefaultCurveId("P-256");
+ public static final CurveId P384 = new DefaultCurveId("P-384");
+ public static final CurveId P521 = new DefaultCurveId("P-521"); // yes, this is supposed to be 521 and not 512
+
+ private static final Map STANDARD_IDS = Collections.unmodifiableMap(Maps
+ .of(P256.toString(), P256)
+ .and(P384.toString(), P384)
+ .and(P521.toString(), P521)
+ .build());
+
+ private static final Set STANDARD_IDS_SET =
+ Collections.unmodifiableSet(new LinkedHashSet<>(STANDARD_IDS.values()));
+
+ public static Set values() {
+ return STANDARD_IDS_SET;
+ }
+
+ public static boolean isStandard(CurveId curveId) {
+ return curveId != null && STANDARD_IDS.containsKey(curveId.toString());
+ }
+
+ public static CurveId forValue(String value) {
+ value = Strings.clean(value);
+ Assert.hasText(value, "value argument cannot be null or empty.");
+ CurveId std = STANDARD_IDS.get(value);
+ return std != null ? std : new DefaultCurveId(value);
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/DecryptionKeyResolver.java b/api/src/main/java/io/jsonwebtoken/security/DecryptionKeyResolver.java
new file mode 100644
index 000000000..9e2cbce78
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/DecryptionKeyResolver.java
@@ -0,0 +1,19 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.JweHeader;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface DecryptionKeyResolver {
+
+ /**
+ * Returns the decryption key that should be used to decrypt a corresponding JWE's Ciphertext (payload).
+ *
+ * @param header the JWE header to inspect to determine which decryption key should be used
+ * @return the decryption key that should be used to decrypt a corresponding JWE's Ciphertext (payload).
+ */
+ Key resolveDecryptionKey(JweHeader header);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/DefaultCurveId.java b/api/src/main/java/io/jsonwebtoken/security/DefaultCurveId.java
new file mode 100644
index 000000000..479f768fb
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/DefaultCurveId.java
@@ -0,0 +1,33 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Strings;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+final class DefaultCurveId implements CurveId {
+
+ private final String id;
+
+ DefaultCurveId(String id) {
+ id = Strings.clean(id);
+ Assert.hasText(id, "id argument cannot be null or empty.");
+ this.id = id;
+ }
+
+ @Override
+ public int hashCode() {
+ return id.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return obj == this || (obj instanceof CurveId && obj.toString().equals(this.id));
+ }
+
+ @Override
+ public String toString() {
+ return id;
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EcJwk.java b/api/src/main/java/io/jsonwebtoken/security/EcJwk.java
new file mode 100644
index 000000000..eba5b1045
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EcJwk.java
@@ -0,0 +1,13 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EcJwk extends Jwk, EcJwkMutator {
+
+ CurveId getCurveId();
+
+ String getX();
+
+ String getY();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EcJwkBuilder.java b/api/src/main/java/io/jsonwebtoken/security/EcJwkBuilder.java
new file mode 100644
index 000000000..c0ae666f8
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EcJwkBuilder.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EcJwkBuilder extends JwkBuilder, EcJwkMutator {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EcJwkBuilderFactory.java b/api/src/main/java/io/jsonwebtoken/security/EcJwkBuilderFactory.java
new file mode 100644
index 000000000..f6666e02f
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EcJwkBuilderFactory.java
@@ -0,0 +1,11 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EcJwkBuilderFactory {
+
+ PublicEcJwkBuilder publicKey();
+
+ PrivateEcJwkBuilder privateKey();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EcJwkMutator.java b/api/src/main/java/io/jsonwebtoken/security/EcJwkMutator.java
new file mode 100644
index 000000000..fad155ad9
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EcJwkMutator.java
@@ -0,0 +1,13 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EcJwkMutator extends JwkMutator {
+
+ T setCurveId(CurveId curveId);
+
+ T setX(String x);
+
+ T setY(String y);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithm.java
new file mode 100644
index 000000000..a3ba789c2
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithm.java
@@ -0,0 +1,15 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.Named;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EncryptionAlgorithm, ERes extends EncryptionResult, DReq extends CryptoRequest> extends Named {
+
+ ERes encrypt(EReq request) throws CryptoException, KeyException;
+
+ byte[] decrypt(DReq request) throws CryptoException, KeyException;
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithmLocator.java b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithmLocator.java
new file mode 100644
index 000000000..ec44fd8b9
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithmLocator.java
@@ -0,0 +1,11 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.JweHeader;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EncryptionAlgorithmLocator {
+
+ EncryptionAlgorithm getEncryptionAlgorithm(JweHeader jweHeader);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithmName.java b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithmName.java
new file mode 100644
index 000000000..9b482d3bf
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithmName.java
@@ -0,0 +1,75 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public enum EncryptionAlgorithmName {
+
+ A128CBC_HS256("A128CBC-HS256", "AES_128_CBC_HMAC_SHA_256 authenticated encryption algorithm, as defined in https://tools.ietf.org/html/rfc7518#section-5.2.3", "AES/CBC/PKCS5Padding"),
+ A192CBC_HS384("A192CBC-HS384", "AES_192_CBC_HMAC_SHA_384 authenticated encryption algorithm, as defined in https://tools.ietf.org/html/rfc7518#section-5.2.4", "AES/CBC/PKCS5Padding"),
+ A256CBC_HS512("A256CBC-HS512", "AES_256_CBC_HMAC_SHA_512 authenticated encryption algorithm, as defined in https://tools.ietf.org/html/rfc7518#section-5.2.5", "AES/CBC/PKCS5Padding"),
+ A128GCM("A128GCM", "AES GCM using 128-bit key", "AES/GCM/NoPadding"),
+ A192GCM("A192GCM", "AES GCM using 192-bit key", "AES/GCM/NoPadding"),
+ A256GCM("A256GCM", "AES GCM using 256-bit key", "AES/GCM/NoPadding");
+
+ private final String name;
+ private final String description;
+ private final String jcaName;
+
+ EncryptionAlgorithmName(String name, String description, String jcaName) {
+ this.name = name;
+ this.description = description;
+ this.jcaName = jcaName;
+ }
+
+ /**
+ * Returns the JWA algorithm name constant.
+ *
+ * @return the JWA algorithm name constant.
+ */
+ public String getValue() {
+ return name;
+ }
+
+ /**
+ * Returns the JWA algorithm description.
+ *
+ * @return the JWA algorithm description.
+ */
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ * Returns the name of the JCA algorithm used to encrypt or decrypt JWE content.
+ *
+ * @return the name of the JCA algorithm used to encrypt or decrypt JWE content.
+ */
+ public String getJcaName() {
+ return jcaName;
+ }
+
+ /**
+ * Returns the corresponding {@code EncryptionAlgorithmName} enum instance based on a
+ * case-insensitive name comparison of the specified JWE enc value.
+ *
+ * @param name the case-insensitive JWE enc header value.
+ * @return Returns the corresponding {@code EncryptionAlgorithmName} enum instance based on a
+ * case-insensitive name comparison of the specified JWE enc value.
+ * @throws IllegalArgumentException if the specified value does not match any JWE {@code EncryptionAlgorithmName} value.
+ */
+ public static EncryptionAlgorithmName forName(String name) throws IllegalArgumentException {
+ for (EncryptionAlgorithmName enc : values()) {
+ if (enc.getValue().equalsIgnoreCase(name)) {
+ return enc;
+ }
+ }
+
+ throw new IllegalArgumentException("Unsupported JWE Content Encryption Algorithm name: " + name);
+ }
+
+ @Override
+ public String toString() {
+ return name;
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithms.java b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithms.java
new file mode 100644
index 000000000..dbaeecb58
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EncryptionAlgorithms.java
@@ -0,0 +1,105 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Classes;
+import io.jsonwebtoken.lang.Maps;
+import io.jsonwebtoken.lang.Strings;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public final class EncryptionAlgorithms {
+
+ //prevent instantiation
+ private EncryptionAlgorithms() {
+ }
+
+ private static final Class MAC_CLASS = Classes.forName("io.jsonwebtoken.impl.security.MacSignatureAlgorithm");
+ private static final String HMAC = "io.jsonwebtoken.impl.security.HmacAesEncryptionAlgorithm";
+ private static final Class[] HMAC_ARGS = new Class[]{String.class, MAC_CLASS};
+
+ private static final String GCM = "io.jsonwebtoken.impl.security.GcmAesEncryptionAlgorithm";
+ private static final Class[] GCM_ARGS = new Class[]{String.class, int.class};
+
+ private static AeadSymmetricEncryptionAlgorithm hmac(int keyLength) {
+ int digestLength = keyLength * 2;
+ String name = "A" + keyLength + "CBC-HS" + digestLength;
+ SignatureAlgorithm macSigAlg = Classes.newInstance(SignatureAlgorithms.HMAC, SignatureAlgorithms.HMAC_ARGS, name, "HmacSHA" + digestLength, keyLength);
+ return Classes.newInstance(HMAC, HMAC_ARGS, name, macSigAlg);
+ }
+
+ private static AeadSymmetricEncryptionAlgorithm gcm(int keyLength) {
+ String name = "A" + keyLength + "GCM";
+ return Classes.newInstance(GCM, GCM_ARGS, name, keyLength);
+ }
+
+ /**
+ * AES_128_CBC_HMAC_SHA_256 authenticated encryption algorithm, as defined by
+ * RFC 7518, Section 5.2.3. This algorithm
+ * requires a 256 bit (32 byte) key.
+ */
+ public static final AeadSymmetricEncryptionAlgorithm A128CBC_HS256 = hmac(128);
+
+ /**
+ * AES_192_CBC_HMAC_SHA_384 authenticated encryption algorithm, as defined by
+ * RFC 7518, Section 5.2.4. This algorithm
+ * requires a 384 bit (48 byte) key.
+ */
+ public static final AeadSymmetricEncryptionAlgorithm A192CBC_HS384 = hmac(192);
+
+ /**
+ * AES_256_CBC_HMAC_SHA_512 authenticated encryption algorithm, as defined by
+ * RFC 7518, Section 5.2.5. This algorithm
+ * requires a 512 bit (64 byte) key.
+ */
+ public static final AeadSymmetricEncryptionAlgorithm A256CBC_HS512 = hmac(256);
+
+ /**
+ * "AES GCM using 128-bit key" as defined by
+ * RFC 7518, Section 5.3. This algorithm requires
+ * a 128 bit (16 byte) key.
+ */
+ public static final AeadSymmetricEncryptionAlgorithm A128GCM = gcm(128);
+
+ /**
+ * "AES GCM using 192-bit key" as defined by
+ * RFC 7518, Section 5.3. This algorithm requires
+ * a 192 bit (24 byte) key.
+ */
+ public static final AeadSymmetricEncryptionAlgorithm A192GCM = gcm(192);
+
+ /**
+ * "AES GCM using 256-bit key" as defined by
+ * RFC 7518, Section 5.3. This algorithm requires
+ * a 256 bit (32 byte) key.
+ */
+ public static final AeadSymmetricEncryptionAlgorithm A256GCM = gcm(256);
+
+ private static final Map SYMMETRIC_VALUES_BY_NAME = Collections.unmodifiableMap(Maps
+ .of(A128CBC_HS256.getName(), A128CBC_HS256)
+ .and(A192CBC_HS384.getName(), A192CBC_HS384)
+ .and(A256CBC_HS512.getName(), A256CBC_HS512)
+ .and(A128GCM.getName(), A128GCM)
+ .and(A192GCM.getName(), A192GCM)
+ .and(A256GCM.getName(), A256GCM)
+ .build());
+
+ public static EncryptionAlgorithm forName(String name) {
+ Assert.hasText(name, "name cannot be null or empty.");
+ EncryptionAlgorithm alg = SYMMETRIC_VALUES_BY_NAME.get(name.toUpperCase());
+ if (alg == null) {
+ String msg = "'" + name + "' is not a JWE specification standard name. The standard names are: " +
+ Strings.collectionToCommaDelimitedString(SYMMETRIC_VALUES_BY_NAME.keySet());
+ throw new IllegalArgumentException(msg);
+ }
+ return alg;
+ }
+
+ public static Collection symmetric() {
+ return SYMMETRIC_VALUES_BY_NAME.values();
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/EncryptionResult.java b/api/src/main/java/io/jsonwebtoken/security/EncryptionResult.java
new file mode 100644
index 000000000..62b76f6ca
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/EncryptionResult.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface EncryptionResult {
+
+ byte[] getCiphertext();
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/InitializationVectorSource.java b/api/src/main/java/io/jsonwebtoken/security/InitializationVectorSource.java
new file mode 100644
index 000000000..47f1032ed
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/InitializationVectorSource.java
@@ -0,0 +1,16 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface InitializationVectorSource {
+
+ /**
+ * Returns the secure-random initialization vector used during encryption that must be presented in order
+ * to decrypt.
+ *
+ * @return the secure-random initialization vector used during encryption that must be presented in order
+ * to decrypt.
+ */
+ byte[] getInitializationVector();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/InvalidKeyException.java b/api/src/main/java/io/jsonwebtoken/security/InvalidKeyException.java
index 2e3b84b8a..5d6b4183d 100644
--- a/api/src/main/java/io/jsonwebtoken/security/InvalidKeyException.java
+++ b/api/src/main/java/io/jsonwebtoken/security/InvalidKeyException.java
@@ -23,4 +23,8 @@ public class InvalidKeyException extends KeyException {
public InvalidKeyException(String message) {
super(message);
}
+
+ public InvalidKeyException(String msg, Exception cause) {
+ super(msg, cause);
+ }
}
diff --git a/api/src/main/java/io/jsonwebtoken/security/IvEncryptionResult.java b/api/src/main/java/io/jsonwebtoken/security/IvEncryptionResult.java
new file mode 100644
index 000000000..ac75f30fb
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/IvEncryptionResult.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface IvEncryptionResult extends EncryptionResult, InitializationVectorSource {
+
+ byte[] compact();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/IvRequest.java b/api/src/main/java/io/jsonwebtoken/security/IvRequest.java
new file mode 100644
index 000000000..e4dfbbcc1
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/IvRequest.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface IvRequest extends CryptoRequest, InitializationVectorSource {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/Jwk.java b/api/src/main/java/io/jsonwebtoken/security/Jwk.java
new file mode 100644
index 000000000..f527978cf
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/Jwk.java
@@ -0,0 +1,30 @@
+package io.jsonwebtoken.security;
+
+import java.net.URI;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface Jwk extends Map, JwkMutator {
+
+ String getType();
+
+ String getUse();
+
+ Set getOperations();
+
+ String getAlgorithm();
+
+ String getId();
+
+ URI getX509Url();
+
+ List getX509CertficateChain();
+
+ String getX509CertificateSha1Thumbprint();
+
+ String getX509CertificateSha256Thumbprint();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/JwkBuilder.java b/api/src/main/java/io/jsonwebtoken/security/JwkBuilder.java
new file mode 100644
index 000000000..c5b09062f
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/JwkBuilder.java
@@ -0,0 +1,10 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface JwkBuilder extends JwkMutator {
+
+ K build();
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/JwkBuilderFactory.java b/api/src/main/java/io/jsonwebtoken/security/JwkBuilderFactory.java
new file mode 100644
index 000000000..406408dff
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/JwkBuilderFactory.java
@@ -0,0 +1,12 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface JwkBuilderFactory {
+
+ EcJwkBuilderFactory ellipticCurve();
+
+ SymmetricJwkBuilder symmetric();
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/JwkMutator.java b/api/src/main/java/io/jsonwebtoken/security/JwkMutator.java
new file mode 100644
index 000000000..ba8ab1cc1
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/JwkMutator.java
@@ -0,0 +1,27 @@
+package io.jsonwebtoken.security;
+
+import java.net.URI;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface JwkMutator {
+
+ T setUse(String use);
+
+ T setOperations(Set ops);
+
+ T setAlgorithm(String alg);
+
+ T setId(String id);
+
+ T setX509Url(URI uri);
+
+ T setX509CertificateChain(List chain);
+
+ T setX509CertificateSha1Thumbprint(String thumbprint);
+
+ T setX509CertificateSha256Thumbprint(String thumbprint);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfo.java b/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfo.java
new file mode 100644
index 000000000..55eb75030
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfo.java
@@ -0,0 +1,16 @@
+package io.jsonwebtoken.security;
+
+import java.util.Map;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface JwkRsaPrimeInfo extends Map, JwkRsaPrimeInfoMutator {
+
+ String getPrime();
+
+ String getCrtExponent();
+
+ String getCrtCoefficient();
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfoBuilder.java b/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfoBuilder.java
new file mode 100644
index 000000000..4307aa57d
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfoBuilder.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface JwkRsaPrimeInfoBuilder extends JwkRsaPrimeInfoMutator {
+
+ JwkRsaPrimeInfo build();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfoMutator.java b/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfoMutator.java
new file mode 100644
index 000000000..36a956122
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/JwkRsaPrimeInfoMutator.java
@@ -0,0 +1,13 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface JwkRsaPrimeInfoMutator {
+
+ T setPrime(String r);
+
+ T setCrtExponent(String d);
+
+ T setCrtCoefficient(String t);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/Jwks.java b/api/src/main/java/io/jsonwebtoken/security/Jwks.java
new file mode 100644
index 000000000..08cf45bf3
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/Jwks.java
@@ -0,0 +1,14 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.lang.Classes;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class Jwks {
+
+ public static T builder() {
+ return Classes.newInstance("io.jsonwebtoken.impl.security.DefaultJwkBuilderFactory");
+ }
+
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/KeyException.java b/api/src/main/java/io/jsonwebtoken/security/KeyException.java
index 0db219245..da44f9ad8 100644
--- a/api/src/main/java/io/jsonwebtoken/security/KeyException.java
+++ b/api/src/main/java/io/jsonwebtoken/security/KeyException.java
@@ -23,4 +23,8 @@ public class KeyException extends SecurityException {
public KeyException(String message) {
super(message);
}
+
+ public KeyException(String msg, Exception cause) {
+ super(msg, cause);
+ }
}
diff --git a/api/src/main/java/io/jsonwebtoken/security/KeyManagementAlgorithmName.java b/api/src/main/java/io/jsonwebtoken/security/KeyManagementAlgorithmName.java
new file mode 100644
index 000000000..bb1b169b3
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/KeyManagementAlgorithmName.java
@@ -0,0 +1,106 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.lang.Collections;
+
+import java.util.List;
+
+/**
+ * Type-safe representation of standard JWE encryption key management algorithm names as defined in the
+ * JSON Web Algorithms specification.
+ *
+ * @since JJWT_RELEASE_VERSION
+ */
+public enum KeyManagementAlgorithmName {
+
+ RSA1_5("RSA1_5", "RSAES-PKCS1-v1_5", Collections.emptyList(), "RSA/ECB/PKCS1Padding"),
+ RSA_OAEP("RSA-OAEP", "RSAES OAEP using default parameters", Collections.emptyList(), "RSA/ECB/OAEPWithSHA-1AndMGF1Padding"),
+ RSA_OAEP_256("RSA-OAEP-256", "RSAES OAEP using SHA-256 and MGF1 with SHA-256", Collections.emptyList(), "RSA/ECB/OAEPWithSHA-256AndMGF1Padding & MGF1ParameterSpec.SHA256"),
+ A128KW("A128KW", "AES Key Wrap with default initial value using 128-bit key", Collections.emptyList(), "AESWrap"),
+ A192KW("A192KW", "AES Key Wrap with default initial value using 192-bit key", Collections.emptyList(), "AESWrap"),
+ A256KW("A256KW", "AES Key Wrap with default initial value using 256-bit key", Collections.emptyList(), "AESWrap"),
+ dir("dir", "Direct use of a shared symmetric key as the CEK", Collections.emptyList(), "RSA/ECB/OAEPWithSHA-1AndMGF1Padding"),
+ ECDH_ES("ECDH-ES", "Elliptic Curve Diffie-Hellman Ephemeral Static key agreement using Concat KDF", Collections.of("epk", "apu", "apv"), "ECDH"),
+ ECDH_ES_A128KW("ECDH-ES+A128KW", "ECDH-ES using Concat KDF and CEK wrapped with \"A128KW\"", Collections.of("epk", "apu", "apv"), "ECDH???"),
+ ECDH_ES_A192KW("ECDH-ES+A192KW", "ECDH-ES using Concat KDF and CEK wrapped with \"A192KW\"", Collections.of("epk", "apu", "apv"), "ECDH???"),
+ ECDH_ES_A256KW("ECDH-ES+A256KW", "ECDH-ES using Concat KDF and CEK wrapped with \"A256KW\"", Collections.of("epk", "apu", "apv"), "ECDH???"),
+ A128GCMKW("A128GCMKW", "Key wrapping with AES GCM using 128-bit key", Collections.of("iv", "tag"), "???"),
+ A192GCMKW("A192GCMKW", "Key wrapping with AES GCM using 192-bit key", Collections.of("iv", "tag"), "???"),
+ A256GCMKW("A256GCMKW", "Key wrapping with AES GCM using 256-bit key", Collections.of("iv", "tag"), "???"),
+ PBES2_HS256_A128KW("PBES2-HS256+A128KW", "PBES2 with HMAC SHA-256 and \"A128KW\" wrapping", Collections.of("p2s", "p2c"), "???"),
+ PBES2_HS384_A192KW("PBES2-HS384+A192KW", "PBES2 with HMAC SHA-384 and \"A192KW\" wrapping", Collections.of("p2s", "p2c"), "???"),
+ PBES2_HS512_A256KW("PBES2-HS512+A256KW", "PBES2 with HMAC SHA-512 and \"A256KW\" wrapping", Collections.of("p2s", "p2c"), "???");
+
+ private final String value;
+ private final String description;
+ private final List moreHeaderParams;
+ private final String jcaName;
+
+ KeyManagementAlgorithmName(String value, String description, List moreHeaderParams, String jcaName) {
+ this.value = value;
+ this.description = description;
+ this.moreHeaderParams = moreHeaderParams;
+ this.jcaName = jcaName;
+ }
+
+ /**
+ * Returns the JWA algorithm name constant.
+ *
+ * @return the JWA algorithm name constant.
+ */
+ public String getValue() {
+ return value;
+ }
+
+ /**
+ * Returns the JWA algorithm description.
+ *
+ * @return the JWA algorithm description.
+ */
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ * Returns a list of header parameters that must exist in the JWE header when evaluating the key management
+ * algorithm. The list will be empty for algorithms that do not require additional header parameters.
+ *
+ * @return a list of header parameters that must exist in the JWE header when evaluating the key management
+ * algorithm.
+ */
+ public List getMoreHeaderParams() {
+ return moreHeaderParams;
+ }
+
+ /**
+ * Returns the name of the JCA algorithm used to create or validate the Content Encryption Key (CEK).
+ *
+ * @return the name of the JCA algorithm used to create or validate the Content Encryption Key (CEK).
+ */
+ public String getJcaName() {
+ return jcaName;
+ }
+
+ /**
+ * Returns the corresponding {@code KeyManagementAlgorithmName} enum instance based on a
+ * case-insensitive name comparison of the specified JWE alg value.
+ *
+ * @param name the case-insensitive JWE alg header value.
+ * @return Returns the corresponding {@code KeyManagementAlgorithmName} enum instance based on a
+ * case-insensitive name comparison of the specified JWE alg value.
+ * @throws IllegalArgumentException if the specified value does not match any JWE {@code KeyManagementAlgorithmName} value.
+ */
+ public static KeyManagementAlgorithmName forName(String name) throws IllegalArgumentException {
+ for (KeyManagementAlgorithmName alg : values()) {
+ if (alg.getValue().equalsIgnoreCase(name)) {
+ return alg;
+ }
+ }
+
+ throw new IllegalArgumentException("Unsupported JWE Key Management Algorithm name: " + name);
+ }
+
+ @Override
+ public String toString() {
+ return value;
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/KeyManagementModeName.java b/api/src/main/java/io/jsonwebtoken/security/KeyManagementModeName.java
new file mode 100644
index 000000000..4f4968c0f
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/KeyManagementModeName.java
@@ -0,0 +1,42 @@
+package io.jsonwebtoken.security;
+
+/**
+ * An enum representing the {@code Key Management Mode} names defined in
+ * RFC 7516, Section 2.
+ *
+ * @since JJWT_RELEASE_VERSION
+ */
+public enum KeyManagementModeName {
+
+ KEY_ENCRYPTION("Key Encryption",
+ "The CEK value is encrypted to the intended recipient using an asymmetric encryption algorithm"),
+
+ KEY_WRAPPING("Key Wrapping",
+ "The CEK value is encrypted to the intended recipient using a symmetric key wrapping algorithm."),
+
+ DIRECT_KEY_AGREEMENT("Direct Key Agreement",
+ "A key agreement algorithm is used to agree upon the CEK value."),
+
+ KEY_AGREEMENT_WITH_KEY_WRAPPING("Key Agreement with Key Wrapping",
+ "A key agreement algorithm is used to agree upon a symmetric key used to encrypt the CEK value to the " +
+ "intended recipient using a symmetric key wrapping algorithm."),
+
+ DIRECT_ENCRYPTION("Direct Encryption",
+ "The CEK value used is the secret symmetric key value shared between the parties.");
+
+ private final String name;
+ private final String desc;
+
+ KeyManagementModeName(String name, String desc) {
+ this.name = name;
+ this.desc = desc;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getDescription() {
+ return desc;
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/Keys.java b/api/src/main/java/io/jsonwebtoken/security/Keys.java
index cb4784248..088be5e9b 100644
--- a/api/src/main/java/io/jsonwebtoken/security/Keys.java
+++ b/api/src/main/java/io/jsonwebtoken/security/Keys.java
@@ -15,16 +15,11 @@
*/
package io.jsonwebtoken.security;
-import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.lang.Assert;
-import io.jsonwebtoken.lang.Classes;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.KeyPair;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
/**
* Utility class for securely generating {@link SecretKey}s and {@link KeyPair}s.
@@ -33,36 +28,10 @@
*/
public final class Keys {
- private static final String MAC = "io.jsonwebtoken.impl.crypto.MacProvider";
- private static final String RSA = "io.jsonwebtoken.impl.crypto.RsaProvider";
- private static final String EC = "io.jsonwebtoken.impl.crypto.EllipticCurveProvider";
-
- private static final Class[] SIG_ARG_TYPES = new Class[]{SignatureAlgorithm.class};
-
- //purposefully ordered higher to lower:
- private static final List PREFERRED_HMAC_ALGS = Collections.unmodifiableList(Arrays.asList(
- SignatureAlgorithm.HS512, SignatureAlgorithm.HS384, SignatureAlgorithm.HS256));
-
//prevent instantiation
private Keys() {
}
- /*
- public static final int bitLength(Key key) throws IllegalArgumentException {
- Assert.notNull(key, "Key cannot be null.");
- if (key instanceof SecretKey) {
- byte[] encoded = key.getEncoded();
- return Arrays.length(encoded) * 8;
- } else if (key instanceof RSAKey) {
- return ((RSAKey)key).getModulus().bitLength();
- } else if (key instanceof ECKey) {
- return ((ECKey)key).getParams().getOrder().bitLength();
- }
-
- throw new IllegalArgumentException("Unsupported key type: " + key.getClass().getName());
- }
- */
-
/**
* Creates a new SecretKey instance for use with HMAC-SHA algorithms based on the specified key byte array.
*
@@ -80,23 +49,37 @@ public static SecretKey hmacShaKeyFor(byte[] bytes) throws WeakKeyException {
int bitLength = bytes.length * 8;
- for (SignatureAlgorithm alg : PREFERRED_HMAC_ALGS) {
- if (bitLength >= alg.getMinKeyLength()) {
- return new SecretKeySpec(bytes, alg.getJcaName());
- }
+ //Purposefully ordered higher to lower to ensure the strongest key possible can be generated.
+ if (bitLength >= 512) {
+ return new SecretKeySpec(bytes, "HmacSHA512");
+ } else if (bitLength >= 384) {
+ return new SecretKeySpec(bytes, "HmacSHA384");
+ } else if (bitLength >= 256) {
+ return new SecretKeySpec(bytes, "HmacSHA256");
}
String msg = "The specified key byte array is " + bitLength + " bits which " +
"is not secure enough for any JWT HMAC-SHA algorithm. The JWT " +
"JWA Specification (RFC 7518, Section 3.2) states that keys used with HMAC-SHA algorithms MUST have a " +
"size >= 256 bits (the key size must be greater than or equal to the hash " +
- "output size). Consider using the " + Keys.class.getName() + "#secretKeyFor(SignatureAlgorithm) method " +
- "to create a key guaranteed to be secure enough for your preferred HMAC-SHA algorithm. See " +
- "https://tools.ietf.org/html/rfc7518#section-3.2 for more information.";
+ "output size). Consider using the SignatureAlgorithms.HS256.generateKey() method (or HS384.generateKey() " +
+ "or HS512.generateKey()) to create a key guaranteed to be secure enough for your preferred HMAC-SHA " +
+ "algorithm. See https://tools.ietf.org/html/rfc7518#section-3.2 for more information.";
throw new WeakKeyException(msg);
}
/**
+ * Deprecation Notice
+ * As of JJWT JJWT_RELEASE_VERSION, symmetric (secret) key algorithm instances can generate a key of suitable
+ * length for that specific algorithm by calling their {@code generateKey()} method directly. For example:
+ *
+ * {@link SignatureAlgorithms#HS256}.generateKey();
+ * {@link SignatureAlgorithms#HS384}.generateKey();
+ * {@link SignatureAlgorithms#HS512}.generateKey();
+ *
+ *
* Returns a new {@link SecretKey} with a key length suitable for use with the specified {@link SignatureAlgorithm}.
*
*
JWA Specification (RFC 7518), Section 3.2
@@ -124,23 +107,36 @@ public static SecretKey hmacShaKeyFor(byte[] bytes) throws WeakKeyException {
*
* @param alg the {@code SignatureAlgorithm} to inspect to determine which key length to use.
* @return a new {@link SecretKey} instance suitable for use with the specified {@link SignatureAlgorithm}.
- * @throws IllegalArgumentException for any input value other than {@link SignatureAlgorithm#HS256},
- * {@link SignatureAlgorithm#HS384}, or {@link SignatureAlgorithm#HS512}
+ * @throws IllegalArgumentException for any input value other than {@link io.jsonwebtoken.SignatureAlgorithm#HS256},
+ * {@link io.jsonwebtoken.SignatureAlgorithm#HS384}, or {@link io.jsonwebtoken.SignatureAlgorithm#HS512}
+ * @deprecated since JJWT_RELEASE_VERSION. Use your preferred {@link SymmetricKeySignatureAlgorithm} instance's
+ * {@link SymmetricKeySignatureAlgorithm#generateKey() generateKey()} method directly.
*/
- public static SecretKey secretKeyFor(SignatureAlgorithm alg) throws IllegalArgumentException {
+ @Deprecated
+ public static SecretKey secretKeyFor(io.jsonwebtoken.SignatureAlgorithm alg) throws IllegalArgumentException {
Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
- switch (alg) {
- case HS256:
- case HS384:
- case HS512:
- return Classes.invokeStatic(MAC, "generateKey", SIG_ARG_TYPES, alg);
- default:
- String msg = "The " + alg.name() + " algorithm does not support shared secret keys.";
- throw new IllegalArgumentException(msg);
+ SignatureAlgorithm salg = SignatureAlgorithms.forName(alg.name());
+ if (!(salg instanceof SymmetricKeySignatureAlgorithm)) {
+ String msg = "The " + alg.name() + " algorithm does not support shared secret keys.";
+ throw new IllegalArgumentException(msg);
}
+ return ((SymmetricKeySignatureAlgorithm) salg).generateKey();
}
/**
+ *
Deprecation Notice
+ * As of JJWT JJWT_RELEASE_VERSION, asymmetric key algorithm instances can generate KeyPairs of suitable strength
+ * for that specific algorithm by calling their {@code generateKeyPair()} method directly. For example:
+ *
+ * {@link SignatureAlgorithms#RS256}.generateKeyPair();
+ * {@link SignatureAlgorithms#RS384}.generateKeyPair();
+ * {@link SignatureAlgorithms#RS256}.generateKeyPair();
+ * ... etc ...
+ * {@link SignatureAlgorithms#ES512}.generateKeyPair();
+ *
+ *
* Returns a new {@link KeyPair} suitable for use with the specified asymmetric algorithm.
*
*
If the {@code alg} argument is an RSA algorithm, a KeyPair is generated based on the following:
@@ -199,7 +195,7 @@ public static SecretKey secretKeyFor(SignatureAlgorithm alg) throws IllegalArgum
*
*
* | EC512 |
- * 512 bits |
+ * 521 bits |
* {@code P-521} |
* {@code secp521r1} |
*
@@ -208,24 +204,17 @@ public static SecretKey secretKeyFor(SignatureAlgorithm alg) throws IllegalArgum
* @param alg the {@code SignatureAlgorithm} to inspect to determine which asymmetric algorithm to use.
* @return a new {@link KeyPair} suitable for use with the specified asymmetric algorithm.
* @throws IllegalArgumentException if {@code alg} is not an asymmetric algorithm
+ * @deprecated since JJWT_RELEASE_VERSION. Use your preferred {@link AsymmetricKeySignatureAlgorithm} instance's
+ * {@link AsymmetricKeySignatureAlgorithm#generateKeyPair() generateKeyPair()} method directly.
*/
- public static KeyPair keyPairFor(SignatureAlgorithm alg) throws IllegalArgumentException {
+ @Deprecated
+ public static KeyPair keyPairFor(io.jsonwebtoken.SignatureAlgorithm alg) throws IllegalArgumentException {
Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
- switch (alg) {
- case RS256:
- case PS256:
- case RS384:
- case PS384:
- case RS512:
- case PS512:
- return Classes.invokeStatic(RSA, "generateKeyPair", SIG_ARG_TYPES, alg);
- case ES256:
- case ES384:
- case ES512:
- return Classes.invokeStatic(EC, "generateKeyPair", SIG_ARG_TYPES, alg);
- default:
- String msg = "The " + alg.name() + " algorithm does not support Key Pairs.";
- throw new IllegalArgumentException(msg);
+ SignatureAlgorithm salg = SignatureAlgorithms.forName(alg.name());
+ if (!(salg instanceof AsymmetricKeySignatureAlgorithm)) {
+ String msg = "The " + alg.name() + " algorithm does not support Key Pairs.";
+ throw new IllegalArgumentException(msg);
}
+ return ((AsymmetricKeySignatureAlgorithm) salg).generateKeyPair();
}
}
diff --git a/api/src/main/java/io/jsonwebtoken/security/MalformedKeyException.java b/api/src/main/java/io/jsonwebtoken/security/MalformedKeyException.java
new file mode 100644
index 000000000..a89bbc3df
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/MalformedKeyException.java
@@ -0,0 +1,15 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class MalformedKeyException extends InvalidKeyException {
+
+ public MalformedKeyException(String message) {
+ super(message);
+ }
+
+ public MalformedKeyException(String msg, Exception cause) {
+ super(msg, cause);
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwk.java b/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwk.java
new file mode 100644
index 000000000..2130d45d0
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwk.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PrivateEcJwk extends EcJwk, PrivateEcJwkMutator {
+
+ String getD();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwkBuilder.java b/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwkBuilder.java
new file mode 100644
index 000000000..543e785db
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwkBuilder.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PrivateEcJwkBuilder extends EcJwkBuilder {
+
+ PrivateEcJwkBuilder setD(String d);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwkMutator.java b/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwkMutator.java
new file mode 100644
index 000000000..f6e5f8a23
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PrivateEcJwkMutator.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PrivateEcJwkMutator extends EcJwkMutator {
+
+ T setD(String d);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PrivateRsaJwk.java b/api/src/main/java/io/jsonwebtoken/security/PrivateRsaJwk.java
new file mode 100644
index 000000000..28976a93c
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PrivateRsaJwk.java
@@ -0,0 +1,23 @@
+package io.jsonwebtoken.security;
+
+import java.util.List;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PrivateRsaJwk extends RsaJwk, PrivateRsaJwkMutator {
+
+ String getD();
+
+ String getP();
+
+ String getQ();
+
+ String getDP();
+
+ String getDQ();
+
+ String getQI();
+
+ List getOtherPrimesInfo();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PrivateRsaJwkMutator.java b/api/src/main/java/io/jsonwebtoken/security/PrivateRsaJwkMutator.java
new file mode 100644
index 000000000..6ffb3edc6
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PrivateRsaJwkMutator.java
@@ -0,0 +1,23 @@
+package io.jsonwebtoken.security;
+
+import java.util.List;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PrivateRsaJwkMutator extends RsaJwkMutator {
+
+ T setD(String d);
+
+ T setP(String p);
+
+ T setQ(String q);
+
+ T setDP(String dp);
+
+ T setDQ(String dq);
+
+ T setQI(String qi);
+
+ T setOtherPrimesInfo(List infos);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PublicEcJwk.java b/api/src/main/java/io/jsonwebtoken/security/PublicEcJwk.java
new file mode 100644
index 000000000..be532e268
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PublicEcJwk.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PublicEcJwk extends EcJwk {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PublicEcJwkBuilder.java b/api/src/main/java/io/jsonwebtoken/security/PublicEcJwkBuilder.java
new file mode 100644
index 000000000..ed893ed35
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PublicEcJwkBuilder.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PublicEcJwkBuilder extends EcJwkBuilder {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/PublicRsaJwk.java b/api/src/main/java/io/jsonwebtoken/security/PublicRsaJwk.java
new file mode 100644
index 000000000..99e121368
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/PublicRsaJwk.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface PublicRsaJwk extends RsaJwk {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/RsaJwk.java b/api/src/main/java/io/jsonwebtoken/security/RsaJwk.java
new file mode 100644
index 000000000..0a5c2393a
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/RsaJwk.java
@@ -0,0 +1,11 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface RsaJwk extends Jwk, RsaJwkMutator {
+
+ String getModulus();
+
+ String getExponent();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/RsaJwkMutator.java b/api/src/main/java/io/jsonwebtoken/security/RsaJwkMutator.java
new file mode 100644
index 000000000..0df8a74da
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/RsaJwkMutator.java
@@ -0,0 +1,11 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface RsaJwkMutator extends JwkMutator {
+
+ T setModulus(String n);
+
+ T setExponent(String e);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SignatureAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/SignatureAlgorithm.java
new file mode 100644
index 000000000..095fe5047
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SignatureAlgorithm.java
@@ -0,0 +1,15 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.Named;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SignatureAlgorithm extends Named {
+
+ byte[] sign(CryptoRequest request) throws SignatureException, KeyException;
+
+ boolean verify(VerifySignatureRequest request) throws SignatureException, KeyException;
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SignatureAlgorithms.java b/api/src/main/java/io/jsonwebtoken/security/SignatureAlgorithms.java
new file mode 100644
index 000000000..deac14210
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SignatureAlgorithms.java
@@ -0,0 +1,223 @@
+package io.jsonwebtoken.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Classes;
+
+import javax.crypto.SecretKey;
+import java.security.Key;
+import java.security.PrivateKey;
+import java.security.interfaces.ECKey;
+import java.security.interfaces.RSAKey;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public final class SignatureAlgorithms {
+
+ // Prevent instantiation
+ private SignatureAlgorithms() {
+ }
+
+ static final String HMAC = "io.jsonwebtoken.impl.security.MacSignatureAlgorithm";
+ static final Class[] HMAC_ARGS = new Class[]{String.class, String.class, int.class};
+
+ private static final String RSA = "io.jsonwebtoken.impl.security.RsaSignatureAlgorithm";
+ private static final Class[] RSA_ARGS = new Class[]{String.class, String.class, int.class};
+ private static final Class[] PSS_ARGS = new Class[]{String.class, String.class, int.class, int.class};
+
+ private static final String EC = "io.jsonwebtoken.impl.security.EllipticCurveSignatureAlgorithm";
+ private static final Class[] EC_ARGS = new Class[]{String.class, String.class, String.class, int.class, int.class};
+
+ private static SymmetricKeySignatureAlgorithm hmacSha(int minKeyLength) {
+ return Classes.newInstance(HMAC, HMAC_ARGS, "HS" + minKeyLength, "HmacSHA" + minKeyLength, minKeyLength);
+ }
+
+ private static AsymmetricKeySignatureAlgorithm rsa(int digestLength, int preferredKeyLength) {
+ return Classes.newInstance(RSA, RSA_ARGS, "RS" + digestLength, "SHA" + digestLength + "withRSA", preferredKeyLength);
+ }
+
+ private static AsymmetricKeySignatureAlgorithm pss(int digestLength, int preferredKeyLength) {
+ return Classes.newInstance(RSA, PSS_ARGS, "PS" + digestLength, "RSASSA-PSS", preferredKeyLength, digestLength);
+ }
+
+ private static AsymmetricKeySignatureAlgorithm ec(int keySize, int signatureLength) {
+ int shaSize = keySize == 521 ? 512 : keySize;
+ return Classes.newInstance(EC, EC_ARGS, "ES" + shaSize, "SHA" + shaSize + "withECDSA", "secp" + keySize + "r1", keySize, signatureLength);
+ }
+
+ public static final SignatureAlgorithm NONE = Classes.newInstance("io.jsonwebtoken.impl.security.NoneSignatureAlgorithm");
+ public static final SymmetricKeySignatureAlgorithm HS256 = hmacSha(256);
+ public static final SymmetricKeySignatureAlgorithm HS384 = hmacSha(384);
+ public static final SymmetricKeySignatureAlgorithm HS512 = hmacSha(512);
+ public static final AsymmetricKeySignatureAlgorithm RS256 = rsa(256, 2048);
+ public static final AsymmetricKeySignatureAlgorithm RS384 = rsa(384, 3072);
+ public static final AsymmetricKeySignatureAlgorithm RS512 = rsa(512, 4096);
+ public static final AsymmetricKeySignatureAlgorithm PS256 = pss(256, 2048);
+ public static final AsymmetricKeySignatureAlgorithm PS384 = pss(384, 3072);
+ public static final AsymmetricKeySignatureAlgorithm PS512 = pss(512, 4096);
+ public static final AsymmetricKeySignatureAlgorithm ES256 = ec(256, 64);
+ public static final AsymmetricKeySignatureAlgorithm ES384 = ec(384, 96);
+ public static final AsymmetricKeySignatureAlgorithm ES512 = ec(521, 132);
+
+ private static Map toMap(SignatureAlgorithm... algs) {
+ Map m = new LinkedHashMap<>();
+ for (SignatureAlgorithm alg : algs) {
+ m.put(alg.getName(), alg);
+ }
+ return Collections.unmodifiableMap(m);
+ }
+
+ private static final Map STANDARD_ALGORITHMS = toMap(
+ NONE, HS256, HS384, HS512, RS256, RS384, RS512, PS256, PS384, PS512, ES256, ES384, ES512
+ );
+
+ public static Collection values() {
+ return STANDARD_ALGORITHMS.values();
+ }
+
+ /**
+ * Looks up and returns the corresponding JWA standard {@code SignatureAlgorithm} instance based on a
+ * case-insensitive name comparison.
+ *
+ * @param name The case-insensitive name of the JWA standard {@code SignatureAlgorithm} instance to return
+ * @return the corresponding JWA standard {@code SignatureAlgorithm} enum instance based on a
+ * case-insensitive name comparison.
+ * @throws SignatureException if the specified value does not match any JWA standard {@code SignatureAlgorithm}
+ * name.
+ */
+ public static SignatureAlgorithm forName(String name) {
+ Assert.notNull(name, "name argument cannot be null.");
+ //try constant time lookup first. This will satisfy 99% of invocations:
+ SignatureAlgorithm alg = STANDARD_ALGORITHMS.get(name);
+ if (alg != null) {
+ return alg;
+ }
+ //fall back to case-insensitive lookup:
+ for (SignatureAlgorithm salg : STANDARD_ALGORITHMS.values()) {
+ if (name.equalsIgnoreCase(salg.getName())) {
+ return salg;
+ }
+ }
+ // still no result - error:
+ throw new SignatureException("Unsupported signature algorithm '" + name + "'");
+ }
+
+ /**
+ * Returns the recommended signature algorithm to be used with the specified key according to the following
+ * heuristics:
+ *
+ *
+ * Key Signature Algorithm
+ *
+ *
+ * | If the Key is a: |
+ * And: |
+ * With a key size of: |
+ * The returned SignatureAlgorithm will be: |
+ *
+ *
+ *
+ *
+ * | {@link SecretKey} |
+ * {@link Key#getAlgorithm() getAlgorithm()}.equals("HmacSHA256")1 |
+ * 256 <= size <= 383 2 |
+ * {@link SignatureAlgorithms#HS256 HS256} |
+ *
+ *
+ * | {@link SecretKey} |
+ * {@link Key#getAlgorithm() getAlgorithm()}.equals("HmacSHA384")1 |
+ * 384 <= size <= 511 |
+ * {@link SignatureAlgorithms#HS384 HS384} |
+ *
+ *
+ * | {@link SecretKey} |
+ * {@link Key#getAlgorithm() getAlgorithm()}.equals("HmacSHA512")1 |
+ * 512 <= size |
+ * {@link SignatureAlgorithms#HS512 HS512} |
+ *
+ *
+ * | {@link ECKey} |
+ * instanceof {@link PrivateKey} |
+ * 256 <= size <= 383 3 |
+ * {@link SignatureAlgorithms#ES256 ES256} |
+ *
+ *
+ * | {@link ECKey} |
+ * instanceof {@link PrivateKey} |
+ * 384 <= size <= 520 4 |
+ * {@link SignatureAlgorithms#ES384 ES384} |
+ *
+ *
+ * | {@link ECKey} |
+ * instanceof {@link PrivateKey} |
+ * 521 <= size 4 |
+ * {@link SignatureAlgorithms#ES512 ES512} |
+ *
+ *
+ * | {@link RSAKey} |
+ * instanceof {@link PrivateKey} |
+ * 2048 <= size <= 3071 5,6 |
+ * {@link SignatureAlgorithms#RS256 RS256} |
+ *
+ *
+ * | {@link RSAKey} |
+ * instanceof {@link PrivateKey} |
+ * 3072 <= size <= 4095 6 |
+ * {@link SignatureAlgorithms#RS384 RS384} |
+ *
+ *
+ * | {@link RSAKey} |
+ * instanceof {@link PrivateKey} |
+ * 4096 <= size 5 |
+ * {@link SignatureAlgorithms#RS512 RS512} |
+ *
+ *
+ *
+ * Notes:
+ *
+ * - {@code SecretKey} instances must have an {@link Key#getAlgorithm() algorithm} name equal
+ * to {@code HmacSHA256}, {@code HmacSHA384} or {@code HmacSHA512}. If not, the key bytes might not be
+ * suitable for HMAC signatures will be rejected with a {@link InvalidKeyException}.
+ * - The JWT JWA Specification (RFC 7518,
+ * Section 3.2) mandates that HMAC-SHA-* signing keys MUST be 256 bits or greater.
+ * {@code SecretKey}s with key lengths less than 256 bits will be rejected with an
+ * {@link WeakKeyException}.
+ * - The JWT JWA Specification (RFC 7518,
+ * Section 3.4) mandates that ECDSA signing key lengths MUST be 256 bits or greater.
+ * {@code ECKey}s with key lengths less than 256 bits will be rejected with a
+ * {@link WeakKeyException}.
+ * - The ECDSA {@code P-521} curve does indeed use keys of 521 bits, not 512 as might be expected. ECDSA
+ * keys of 384 < size <= 520 are suitable for ES384, while ES512 requires keys >= 521 bits. The '512' part of the
+ * ES512 name reflects the usage of the SHA-512 algorithm, not the ECDSA key length. ES512 with ECDSA keys less
+ * than 521 bits will be rejected with a {@link WeakKeyException}.
+ * - The JWT JWA Specification (RFC 7518,
+ * Section 3.3) mandates that RSA signing key lengths MUST be 2048 bits or greater.
+ * {@code RSAKey}s with key lengths less than 2048 bits will be rejected with a
+ * {@link WeakKeyException}.
+ * - Technically any RSA key of length >= 2048 bits may be used with the {@link #RS256}, {@link #RS384}, and
+ * {@link #RS512} algorithms, so we assume an RSA signature algorithm based on the key length to
+ * parallel similar decisions in the JWT specification for HMAC and ECDSA signature algorithms.
+ * This is not required - just a convenience.
+ *
+ * This implementation does not return the {@link #PS256}, {@link #PS256}, {@link #PS256} RSA variants for any
+ * specified {@link RSAKey} because the the {@link #RS256}, {@link #RS384}, and {@link #RS512} algorithms are
+ * available in the JDK by default while the {@code PS}* variants require either JDK 11 or an additional JCA
+ * Provider (like BouncyCastle).
+ * Finally, this method will throw an {@link InvalidKeyException} for any key that does not match the
+ * heuristics and requirements documented above, since that inevitably means the Key is either insufficient or
+ * explicitly disallowed by the JWT specification.
+ *
+ * @param key the key to inspect
+ * @return the recommended signature algorithm to be used with the specified key
+ * @throws InvalidKeyException for any key that does not match the heuristics and requirements documented above,
+ * since that inevitably means the Key is either insufficient or explicitly disallowed by the JWT specification.
+ */
+ public static SignatureAlgorithm forSigningKey(Key key) {
+ io.jsonwebtoken.SignatureAlgorithm alg = io.jsonwebtoken.SignatureAlgorithm.forSigningKey(key);
+ return forName(alg.getValue());
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SignatureException.java b/api/src/main/java/io/jsonwebtoken/security/SignatureException.java
index 7cddb2cac..93253a01b 100644
--- a/api/src/main/java/io/jsonwebtoken/security/SignatureException.java
+++ b/api/src/main/java/io/jsonwebtoken/security/SignatureException.java
@@ -18,6 +18,7 @@
/**
* @since 0.10.0
*/
+@SuppressWarnings("deprecation")
public class SignatureException extends io.jsonwebtoken.SignatureException {
public SignatureException(String message) {
diff --git a/api/src/main/java/io/jsonwebtoken/security/SymmetricEncryptionAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/SymmetricEncryptionAlgorithm.java
new file mode 100644
index 000000000..a140da83c
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SymmetricEncryptionAlgorithm.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+import javax.crypto.SecretKey;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SymmetricEncryptionAlgorithm, ERes extends IvEncryptionResult, DReq extends IvRequest> extends EncryptionAlgorithm, SymmetricKeyAlgorithm {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SymmetricJwk.java b/api/src/main/java/io/jsonwebtoken/security/SymmetricJwk.java
new file mode 100644
index 000000000..6b81fcde1
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SymmetricJwk.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SymmetricJwk extends Jwk, SymmetricJwkMutator {
+
+ String getK();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SymmetricJwkBuilder.java b/api/src/main/java/io/jsonwebtoken/security/SymmetricJwkBuilder.java
new file mode 100644
index 000000000..af63d4238
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SymmetricJwkBuilder.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SymmetricJwkBuilder extends JwkBuilder, SymmetricJwkMutator {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SymmetricJwkMutator.java b/api/src/main/java/io/jsonwebtoken/security/SymmetricJwkMutator.java
new file mode 100644
index 000000000..0ab48505e
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SymmetricJwkMutator.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SymmetricJwkMutator extends JwkMutator {
+
+ T setK(String k);
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SymmetricKeyAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/SymmetricKeyAlgorithm.java
new file mode 100644
index 000000000..fb074973f
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SymmetricKeyAlgorithm.java
@@ -0,0 +1,16 @@
+package io.jsonwebtoken.security;
+
+import javax.crypto.SecretKey;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SymmetricKeyAlgorithm {
+
+ /**
+ * Creates and returns a new secure-random key with a length sufficient to be used by this Algorithm.
+ *
+ * @return a new secure-random key with a length sufficient to be used by this Algorithm.
+ */
+ SecretKey generateKey();
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/SymmetricKeySignatureAlgorithm.java b/api/src/main/java/io/jsonwebtoken/security/SymmetricKeySignatureAlgorithm.java
new file mode 100644
index 000000000..451b6c645
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/SymmetricKeySignatureAlgorithm.java
@@ -0,0 +1,7 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface SymmetricKeySignatureAlgorithm extends SignatureAlgorithm, SymmetricKeyAlgorithm {
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/UnsupportedKeyException.java b/api/src/main/java/io/jsonwebtoken/security/UnsupportedKeyException.java
new file mode 100644
index 000000000..890dec20a
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/UnsupportedKeyException.java
@@ -0,0 +1,15 @@
+package io.jsonwebtoken.security;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class UnsupportedKeyException extends KeyException {
+
+ public UnsupportedKeyException(String message) {
+ super(message);
+ }
+
+ public UnsupportedKeyException(String msg, Exception cause) {
+ super(msg, cause);
+ }
+}
diff --git a/api/src/main/java/io/jsonwebtoken/security/VerifySignatureRequest.java b/api/src/main/java/io/jsonwebtoken/security/VerifySignatureRequest.java
new file mode 100644
index 000000000..b71a6c1d7
--- /dev/null
+++ b/api/src/main/java/io/jsonwebtoken/security/VerifySignatureRequest.java
@@ -0,0 +1,11 @@
+package io.jsonwebtoken.security;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public interface VerifySignatureRequest extends CryptoRequest {
+
+ byte[] getSignature();
+}
diff --git a/api/src/test/groovy/io/jsonwebtoken/EncryptionAlgorithmNameTest.groovy b/api/src/test/groovy/io/jsonwebtoken/EncryptionAlgorithmNameTest.groovy
new file mode 100644
index 000000000..26fd5d0b3
--- /dev/null
+++ b/api/src/test/groovy/io/jsonwebtoken/EncryptionAlgorithmNameTest.groovy
@@ -0,0 +1,61 @@
+package io.jsonwebtoken
+
+import io.jsonwebtoken.security.EncryptionAlgorithmName
+import org.junit.Test
+import static org.junit.Assert.*
+
+class EncryptionAlgorithmNameTest {
+
+ @Test
+ void testGetValue() {
+ assertEquals 'A128CBC-HS256', EncryptionAlgorithmName.A128CBC_HS256.getValue()
+ assertEquals 'A192CBC-HS384', EncryptionAlgorithmName.A192CBC_HS384.getValue()
+ assertEquals 'A256CBC-HS512', EncryptionAlgorithmName.A256CBC_HS512.getValue()
+ assertEquals 'A128GCM', EncryptionAlgorithmName.A128GCM.getValue()
+ assertEquals 'A192GCM', EncryptionAlgorithmName.A192GCM.getValue()
+ assertEquals 'A256GCM', EncryptionAlgorithmName.A256GCM.getValue()
+ }
+
+ @Test
+ void testGetDescription() {
+ assertEquals 'AES_128_CBC_HMAC_SHA_256 authenticated encryption algorithm, as defined in https://tools.ietf.org/html/rfc7518#section-5.2.3', EncryptionAlgorithmName.A128CBC_HS256.getDescription()
+ assertEquals 'AES_192_CBC_HMAC_SHA_384 authenticated encryption algorithm, as defined in https://tools.ietf.org/html/rfc7518#section-5.2.4', EncryptionAlgorithmName.A192CBC_HS384.getDescription()
+ assertEquals 'AES_256_CBC_HMAC_SHA_512 authenticated encryption algorithm, as defined in https://tools.ietf.org/html/rfc7518#section-5.2.5', EncryptionAlgorithmName.A256CBC_HS512.getDescription()
+ assertEquals 'AES GCM using 128-bit key', EncryptionAlgorithmName.A128GCM.getDescription()
+ assertEquals 'AES GCM using 192-bit key', EncryptionAlgorithmName.A192GCM.getDescription()
+ assertEquals 'AES GCM using 256-bit key', EncryptionAlgorithmName.A256GCM.getDescription()
+ }
+
+ @Test
+ void testGetJcaName() {
+ for( def name : EncryptionAlgorithmName.values() ) {
+ if (name.getValue().contains("GCM")) {
+ assertEquals 'AES/GCM/NoPadding', name.getJcaName()
+ } else {
+ assertEquals 'AES/CBC/PKCS5Padding', name.getJcaName()
+ }
+ }
+ }
+
+ @Test
+ void testToString() {
+ for( def name : EncryptionAlgorithmName.values() ) {
+ assertEquals name.toString(), name.getValue()
+ }
+ }
+
+ @Test
+ void testForName() {
+ def name = EncryptionAlgorithmName.forName('A128GCM')
+ assertSame name, EncryptionAlgorithmName.A128GCM
+ }
+
+ @Test
+ void testForNameFailure() {
+ try {
+ EncryptionAlgorithmName.forName('foo')
+ fail()
+ } catch (IllegalArgumentException expected) {
+ }
+ }
+}
diff --git a/api/src/test/groovy/io/jsonwebtoken/lang/ArraysTest.groovy b/api/src/test/groovy/io/jsonwebtoken/lang/ArraysTest.groovy
new file mode 100644
index 000000000..2702003e6
--- /dev/null
+++ b/api/src/test/groovy/io/jsonwebtoken/lang/ArraysTest.groovy
@@ -0,0 +1,45 @@
+package io.jsonwebtoken.lang
+
+import org.junit.Test
+
+import java.nio.charset.StandardCharsets
+
+import static org.junit.Assert.*
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+class ArraysTest {
+
+ @Test
+ void testCleanWithNull() {
+ assertNull Arrays.clean(null)
+ }
+
+ @Test
+ void testCleanWithEmpty() {
+ assertNull Arrays.clean(new byte[0])
+ }
+
+ @Test
+ void testCleanWithElements() {
+ byte[] bytes = "hello".getBytes(StandardCharsets.UTF_8)
+ assertSame bytes, Arrays.clean(bytes)
+ }
+
+ @Test
+ void testByteArrayLengthWithNull() {
+ assertEquals 0, Arrays.length(null)
+ }
+
+ @Test
+ void testByteArrayLengthWithEmpty() {
+ assertEquals 0, Arrays.length(new byte[0])
+ }
+
+ @Test
+ void testByteArrayLengthWithElements() {
+ byte[] bytes = "hello".getBytes(StandardCharsets.UTF_8)
+ assertEquals 5, Arrays.length(bytes)
+ }
+}
diff --git a/api/src/test/groovy/io/jsonwebtoken/security/CurveIdsTest.groovy b/api/src/test/groovy/io/jsonwebtoken/security/CurveIdsTest.groovy
new file mode 100644
index 000000000..7a1af2dd7
--- /dev/null
+++ b/api/src/test/groovy/io/jsonwebtoken/security/CurveIdsTest.groovy
@@ -0,0 +1,24 @@
+package io.jsonwebtoken.security
+
+import org.junit.Test
+import static org.junit.Assert.*
+
+class CurveIdsTest {
+
+ @Test(expected=IllegalArgumentException)
+ void testNullId() {
+ CurveIds.forValue(null)
+ }
+
+ @Test(expected=IllegalArgumentException)
+ void testEmptyId() {
+ CurveIds.forValue(' ')
+ }
+
+ @Test
+ void testNonStandardId() {
+ CurveId id = CurveIds.forValue("NonStandard")
+ assertNotNull id
+ assertEquals 'NonStandard', id.toString()
+ }
+}
diff --git a/api/src/test/groovy/io/jsonwebtoken/security/KeyManagementAlgorithmNameTest.groovy b/api/src/test/groovy/io/jsonwebtoken/security/KeyManagementAlgorithmNameTest.groovy
new file mode 100644
index 000000000..3a4366b7f
--- /dev/null
+++ b/api/src/test/groovy/io/jsonwebtoken/security/KeyManagementAlgorithmNameTest.groovy
@@ -0,0 +1,54 @@
+package io.jsonwebtoken.security
+
+import org.junit.Test
+import static org.junit.Assert.*
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+class KeyManagementAlgorithmNameTest {
+
+ @Test
+ void testToString() {
+ for( def name : KeyManagementAlgorithmName.values()) {
+ assertEquals name.value, name.toString()
+ }
+ }
+
+ @Test
+ void testGetDescription() {
+ for( def name : KeyManagementAlgorithmName.values()) {
+ assertNotNull name.getDescription() //TODO improve this for actual value testing
+ }
+ }
+
+ @Test
+ void testGetMoreHeaderParams() {
+ for( def name : KeyManagementAlgorithmName.values()) {
+ assertNotNull name.getMoreHeaderParams() //TODO improve this for actual value testing
+ }
+ }
+
+ @Test
+ void testGetJcaName() {
+ for( def name : KeyManagementAlgorithmName.values()) {
+ assertNotNull name.getJcaName() //TODO improve this for actual value testing
+ }
+ }
+
+ @Test
+ void testForName() {
+ def name = KeyManagementAlgorithmName.forName('A128KW')
+ assertSame name, KeyManagementAlgorithmName.A128KW
+ }
+
+ @Test
+ void testForNameFailure() {
+ try {
+ KeyManagementAlgorithmName.forName('foo')
+ fail()
+ } catch (IllegalArgumentException expected) {
+ }
+ }
+}
+
diff --git a/api/src/test/groovy/io/jsonwebtoken/security/KeyManagementModeNameTest.groovy b/api/src/test/groovy/io/jsonwebtoken/security/KeyManagementModeNameTest.groovy
new file mode 100644
index 000000000..900894dca
--- /dev/null
+++ b/api/src/test/groovy/io/jsonwebtoken/security/KeyManagementModeNameTest.groovy
@@ -0,0 +1,19 @@
+package io.jsonwebtoken.security
+
+import org.junit.Test
+import static org.junit.Assert.*
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+class KeyManagementModeNameTest {
+
+ @Test
+ void test() {
+ //todo, write a real test:
+ for(KeyManagementModeName modeName : KeyManagementModeName.values()) {
+ assertNotNull modeName.getName()
+ assertNotNull modeName.getDescription()
+ }
+ }
+}
diff --git a/api/src/test/groovy/io/jsonwebtoken/security/KeysTest.groovy b/api/src/test/groovy/io/jsonwebtoken/security/KeysTest.groovy
index 7635491cc..8fa9148f3 100644
--- a/api/src/test/groovy/io/jsonwebtoken/security/KeysTest.groovy
+++ b/api/src/test/groovy/io/jsonwebtoken/security/KeysTest.groovy
@@ -16,18 +16,19 @@
package io.jsonwebtoken.security
import io.jsonwebtoken.SignatureAlgorithm
-import io.jsonwebtoken.lang.Classes
import org.junit.Test
import org.junit.runner.RunWith
import org.powermock.core.classloader.annotations.PrepareForTest
+import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor
import org.powermock.modules.junit4.PowerMockRunner
import javax.crypto.SecretKey
+import javax.crypto.spec.SecretKeySpec
import java.security.KeyPair
+import java.security.SecureRandom
import static org.easymock.EasyMock.eq
import static org.easymock.EasyMock.expect
-import static org.easymock.EasyMock.same
import static org.junit.Assert.*
import static org.powermock.api.easymock.PowerMock.*
@@ -37,9 +38,18 @@ import static org.powermock.api.easymock.PowerMock.*
* The actual implementation assertions are done in KeysImplTest in the impl module.
*/
@RunWith(PowerMockRunner)
-@PrepareForTest([Classes, Keys])
+@PrepareForTest([SignatureAlgorithms, Keys])
+@SuppressStaticInitializationFor("io.jsonwebtoken.security.SignatureAlgorithms")
class KeysTest {
+ private static final Random RANDOM = new SecureRandom()
+
+ static byte[] bytes(int sizeInBits) {
+ byte[] bytes = new byte[sizeInBits / Byte.SIZE]
+ RANDOM.nextBytes(bytes)
+ return bytes
+ }
+
@Test
void testPrivateCtor() { //for code coverage only
new Keys()
@@ -65,14 +75,35 @@ class KeysTest {
"is not secure enough for any JWT HMAC-SHA algorithm. The JWT " +
"JWA Specification (RFC 7518, Section 3.2) states that keys used with HMAC-SHA algorithms MUST have a " +
"size >= 256 bits (the key size must be greater than or equal to the hash " +
- "output size). Consider using the " + Keys.class.getName() + "#secretKeyFor(SignatureAlgorithm) method " +
- "to create a key guaranteed to be secure enough for your preferred HMAC-SHA algorithm. See " +
+ "output size). Consider using the SignatureAlgorithms.HS256.generateKey() method (or " +
+ "HS384.generateKey() or HS512.generateKey()) to create a key guaranteed to be secure enough " +
+ "for your preferred HMAC-SHA algorithm. See " +
"https://tools.ietf.org/html/rfc7518#section-3.2 for more information." as String, expected.message
}
}
+ @Test
+ void testHmacShaWithValidSizes() {
+ for (int i : [256, 384, 512]) {
+ byte[] bytes = bytes(i)
+ def key = Keys.hmacShaKeyFor(bytes)
+ assertTrue key instanceof SecretKeySpec
+ assertEquals "HmacSHA$i" as String, key.getAlgorithm()
+ assertTrue Arrays.equals(bytes, key.getEncoded())
+ }
+ }
+
+ @Test
+ void testHmacShaLargerThan512() {
+ def key = Keys.hmacShaKeyFor(bytes(520))
+ assertTrue key instanceof SecretKeySpec
+ assertEquals 'HmacSHA512', key.getAlgorithm()
+ assertTrue key.getEncoded().length * Byte.SIZE >= 512
+ }
+
@Test
void testSecretKeyFor() {
+ mockStatic(SignatureAlgorithms)
for (SignatureAlgorithm alg : SignatureAlgorithm.values()) {
@@ -80,61 +111,66 @@ class KeysTest {
if (name.startsWith('H')) {
- mockStatic(Classes)
-
def key = createMock(SecretKey)
- expect(Classes.invokeStatic(eq(Keys.MAC), eq("generateKey"), same(Keys.SIG_ARG_TYPES), same(alg))).andReturn(key)
+ def salg = createMock(SymmetricKeySignatureAlgorithm)
- replay Classes, key
+ expect(SignatureAlgorithms.forName(eq(name))).andReturn(salg)
+ expect(salg.generateKey()).andReturn(key)
+ replay SignatureAlgorithms, salg, key
assertSame key, Keys.secretKeyFor(alg)
- verify Classes, key
-
- reset Classes, key
+ verify SignatureAlgorithms, salg, key
+ reset SignatureAlgorithms, salg, key
} else {
+ def salg = name == 'NONE' ? createMock(io.jsonwebtoken.security.SignatureAlgorithm) : createMock(AsymmetricKeySignatureAlgorithm)
+ expect(SignatureAlgorithms.forName(eq(name))).andReturn(salg)
+ replay SignatureAlgorithms, salg
try {
Keys.secretKeyFor(alg)
fail()
} catch (IllegalArgumentException expected) {
assertEquals "The $name algorithm does not support shared secret keys." as String, expected.message
}
-
+ verify SignatureAlgorithms, salg
+ reset SignatureAlgorithms, salg
}
}
-
}
@Test
void testKeyPairFor() {
+ mockStatic SignatureAlgorithms
for (SignatureAlgorithm alg : SignatureAlgorithm.values()) {
String name = alg.name()
if (name.equals('NONE') || name.startsWith('H')) {
+ def salg = name == 'NONE' ? createMock(io.jsonwebtoken.security.SignatureAlgorithm) : createMock(SymmetricKeySignatureAlgorithm)
+ expect(SignatureAlgorithms.forName(eq(name))).andReturn(salg)
+ replay SignatureAlgorithms, salg
try {
Keys.keyPairFor(alg)
fail()
} catch (IllegalArgumentException expected) {
assertEquals "The $name algorithm does not support Key Pairs." as String, expected.message
}
+ verify SignatureAlgorithms, salg
+ reset SignatureAlgorithms, salg
} else {
- String fqcn = name.startsWith('E') ? Keys.EC : Keys.RSA
-
- mockStatic Classes
-
def pair = createMock(KeyPair)
- expect(Classes.invokeStatic(eq(fqcn), eq("generateKeyPair"), same(Keys.SIG_ARG_TYPES), same(alg))).andReturn(pair)
+ def salg = createMock(AsymmetricKeySignatureAlgorithm)
- replay Classes, pair
+ expect(SignatureAlgorithms.forName(eq(name))).andReturn(salg)
+ expect(salg.generateKeyPair()).andReturn(pair)
+ replay SignatureAlgorithms, pair, salg
assertSame pair, Keys.keyPairFor(alg)
- verify Classes, pair
-
- reset Classes, pair
+ verify SignatureAlgorithms, pair, salg
+ reset SignatureAlgorithms, pair, salg
}
}
}
diff --git a/api/src/test/groovy/io/jsonwebtoken/security/UnsupportedKeyExceptionTest.groovy b/api/src/test/groovy/io/jsonwebtoken/security/UnsupportedKeyExceptionTest.groovy
new file mode 100644
index 000000000..1738defb9
--- /dev/null
+++ b/api/src/test/groovy/io/jsonwebtoken/security/UnsupportedKeyExceptionTest.groovy
@@ -0,0 +1,17 @@
+package io.jsonwebtoken.security
+
+import org.junit.Test
+
+import static org.junit.Assert.*
+
+class UnsupportedKeyExceptionTest {
+
+ @Test
+ void testCauseWithMessage() {
+ def cause = new IllegalStateException()
+ def msg = 'foo'
+ def ex = new UnsupportedKeyException(msg, cause)
+ assertEquals msg, ex.getMessage()
+ assertSame cause, ex.getCause()
+ }
+}
diff --git a/extensions/gson/pom.xml b/extensions/gson/pom.xml
index 6b6985e83..ed554b0e0 100644
--- a/extensions/gson/pom.xml
+++ b/extensions/gson/pom.xml
@@ -21,7 +21,7 @@
io.jsonwebtoken
jjwt-root
- 0.11.3-SNAPSHOT
+ 0.12.0-SNAPSHOT
../../pom.xml
@@ -44,4 +44,13 @@
+
+
+
+ com.github.siom79.japicmp
+ japicmp-maven-plugin
+
+
+
+
\ No newline at end of file
diff --git a/extensions/gson/src/test/groovy/io/jsonwebtoken/gson/io/GsonDeserializerTest.groovy b/extensions/gson/src/test/groovy/io/jsonwebtoken/gson/io/GsonDeserializerTest.groovy
index ae1223965..581de42ca 100644
--- a/extensions/gson/src/test/groovy/io/jsonwebtoken/gson/io/GsonDeserializerTest.groovy
+++ b/extensions/gson/src/test/groovy/io/jsonwebtoken/gson/io/GsonDeserializerTest.groovy
@@ -21,6 +21,9 @@ import io.jsonwebtoken.io.Deserializer
import io.jsonwebtoken.lang.Strings
import org.junit.Test
+import java.text.DecimalFormat
+import java.text.NumberFormat
+
import static org.easymock.EasyMock.*
import static org.junit.Assert.*
import static org.hamcrest.CoreMatchers.instanceOf
diff --git a/extensions/jackson/pom.xml b/extensions/jackson/pom.xml
index 79b0959ab..ae26aec49 100644
--- a/extensions/jackson/pom.xml
+++ b/extensions/jackson/pom.xml
@@ -21,7 +21,7 @@
io.jsonwebtoken
jjwt-root
- 0.11.3-SNAPSHOT
+ 0.12.0-SNAPSHOT
../../pom.xml
@@ -66,14 +66,6 @@
com.github.siom79.japicmp
japicmp-maven-plugin
-
-
-
-
- ${project.build.directory}/${project.artifactId}-${project.version}-deprecated.${project.packaging}
-
-
-
diff --git a/extensions/jackson/src/main/java/io/jsonwebtoken/jackson/io/JacksonDeserializer.java b/extensions/jackson/src/main/java/io/jsonwebtoken/jackson/io/JacksonDeserializer.java
index a9ea111ea..c208ed7eb 100644
--- a/extensions/jackson/src/main/java/io/jsonwebtoken/jackson/io/JacksonDeserializer.java
+++ b/extensions/jackson/src/main/java/io/jsonwebtoken/jackson/io/JacksonDeserializer.java
@@ -37,7 +37,6 @@ public class JacksonDeserializer implements Deserializer {
private final Class returnType;
private final ObjectMapper objectMapper;
- @SuppressWarnings("unused") //used via reflection by RuntimeClasspathDeserializerLocator
public JacksonDeserializer() {
this(JacksonSerializer.DEFAULT_OBJECT_MAPPER);
}
diff --git a/extensions/orgjson/pom.xml b/extensions/orgjson/pom.xml
index f0ea88409..afe5b6bfb 100644
--- a/extensions/orgjson/pom.xml
+++ b/extensions/orgjson/pom.xml
@@ -21,7 +21,7 @@
io.jsonwebtoken
jjwt-root
- 0.11.3-SNAPSHOT
+ 0.12.0-SNAPSHOT
../../pom.xml
@@ -66,14 +66,6 @@
com.github.siom79.japicmp
japicmp-maven-plugin
-
-
-
-
- ${project.build.directory}/${project.artifactId}-${project.version}-deprecated.${project.packaging}
-
-
-
diff --git a/extensions/pom.xml b/extensions/pom.xml
index ee13b0f20..9259cd713 100644
--- a/extensions/pom.xml
+++ b/extensions/pom.xml
@@ -21,7 +21,7 @@
io.jsonwebtoken
jjwt-root
- 0.11.3-SNAPSHOT
+ 0.12.0-SNAPSHOT
../pom.xml
diff --git a/impl/pom.xml b/impl/pom.xml
index b1aaf92e1..ef51219f2 100644
--- a/impl/pom.xml
+++ b/impl/pom.xml
@@ -21,7 +21,7 @@
io.jsonwebtoken
jjwt-root
- 0.11.3-SNAPSHOT
+ 0.12.0-SNAPSHOT
../pom.xml
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultHeader.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultHeader.java
index 3560afc4a..7dba1763d 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/DefaultHeader.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultHeader.java
@@ -53,14 +53,26 @@ public T setContentType(String cty) {
return (T)this;
}
+ @Override
+ public String getAlgorithm() {
+ return getString(ALGORITHM);
+ }
+
+ @Override
+ public T setAlgorithm(String alg) {
+ setValue(ALGORITHM, alg);
+ return (T)this;
+ }
+
@SuppressWarnings("deprecation")
@Override
public String getCompressionAlgorithm() {
- String alg = getString(COMPRESSION_ALGORITHM);
- if (!Strings.hasText(alg)) {
- alg = getString(DEPRECATED_COMPRESSION_ALGORITHM);
+ String s = getString(COMPRESSION_ALGORITHM);
+ if (!Strings.hasText(s)) {
+ //backwards compatibility TODO: remove when releasing 1.0
+ s = getString(DEPRECATED_COMPRESSION_ALGORITHM);
}
- return alg;
+ return s;
}
@Override
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJweHeader.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJweHeader.java
new file mode 100644
index 000000000..db69ab44b
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJweHeader.java
@@ -0,0 +1,30 @@
+package io.jsonwebtoken.impl;
+
+import io.jsonwebtoken.JweHeader;
+
+import java.util.Map;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DefaultJweHeader extends DefaultHeader implements JweHeader {
+
+ public DefaultJweHeader() {
+ super();
+ }
+
+ public DefaultJweHeader(Map map) {
+ super(map);
+ }
+
+ @Override
+ public String getEncryptionAlgorithm() {
+ return getString(ENCRYPTION_ALGORITHM);
+ }
+
+ @Override
+ public JweHeader setEncryptionAlgorithm(String enc) {
+ setValue(ENCRYPTION_ALGORITHM, enc);
+ return this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwsHeader.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwsHeader.java
index cb747e3dd..bb23dff15 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwsHeader.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwsHeader.java
@@ -19,7 +19,7 @@
import java.util.Map;
-public class DefaultJwsHeader extends DefaultHeader implements JwsHeader {
+public class DefaultJwsHeader extends DefaultHeader implements JwsHeader {
public DefaultJwsHeader() {
super();
@@ -29,17 +29,6 @@ public DefaultJwsHeader(Map map) {
super(map);
}
- @Override
- public String getAlgorithm() {
- return getString(ALGORITHM);
- }
-
- @Override
- public JwsHeader setAlgorithm(String alg) {
- setValue(ALGORITHM, alg);
- return this;
- }
-
@Override
public String getKeyId() {
return getString(KEY_ID);
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtBuilder.java
index 2c7ab1177..78421cfc5 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtBuilder.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtBuilder.java
@@ -21,10 +21,8 @@
import io.jsonwebtoken.JwsHeader;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.JwtParser;
-import io.jsonwebtoken.SignatureAlgorithm;
-import io.jsonwebtoken.impl.crypto.DefaultJwtSigner;
-import io.jsonwebtoken.impl.crypto.JwtSigner;
import io.jsonwebtoken.impl.lang.LegacyServices;
+import io.jsonwebtoken.impl.security.DefaultCryptoRequest;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.io.Encoder;
import io.jsonwebtoken.io.Encoders;
@@ -33,31 +31,55 @@
import io.jsonwebtoken.lang.Assert;
import io.jsonwebtoken.lang.Collections;
import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.CryptoRequest;
import io.jsonwebtoken.security.InvalidKeyException;
+import io.jsonwebtoken.security.SignatureAlgorithm;
+import io.jsonwebtoken.security.SignatureAlgorithms;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
import java.util.Date;
import java.util.Map;
public class DefaultJwtBuilder implements JwtBuilder {
+ private static final byte[] TEST_MESSAGE_BYTES = "Test message".getBytes(StandardCharsets.UTF_8);
+
+ private Provider provider;
+ private SecureRandom secureRandom;
+
private Header header;
private Claims claims;
private String payload;
- private SignatureAlgorithm algorithm;
+ private SignatureAlgorithm algorithm = SignatureAlgorithms.NONE;
+
private Key key;
- private Serializer> serializer;
+ private Serializer> serializer;
private Encoder base64UrlEncoder = Encoders.BASE64URL;
private CompressionCodec compressionCodec;
@Override
- public JwtBuilder serializeToJsonWith(Serializer> serializer) {
+ public JwtBuilder setProvider(Provider provider) {
+ this.provider = provider;
+ return this;
+ }
+
+ @Override
+ public JwtBuilder setSecureRandom(SecureRandom secureRandom) {
+ this.secureRandom = secureRandom;
+ return this;
+ }
+
+ @Override
+ public JwtBuilder serializeToJsonWith(Serializer> serializer) {
Assert.notNull(serializer, "Serializer cannot be null.");
this.serializer = serializer;
return this;
@@ -111,7 +133,7 @@ public JwtBuilder setHeaderParam(String name, Object value) {
@Override
public JwtBuilder signWith(Key key) throws InvalidKeyException {
Assert.notNull(key, "Key argument cannot be null.");
- SignatureAlgorithm alg = SignatureAlgorithm.forSigningKey(key);
+ SignatureAlgorithm alg = SignatureAlgorithms.forSigningKey(key);
return signWith(key, alg);
}
@@ -119,14 +141,19 @@ public JwtBuilder signWith(Key key) throws InvalidKeyException {
public JwtBuilder signWith(Key key, SignatureAlgorithm alg) throws InvalidKeyException {
Assert.notNull(key, "Key argument cannot be null.");
Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
- alg.assertValidSigningKey(key); //since 0.10.0 for https://github.com/jwtk/jjwt/issues/334
this.algorithm = alg;
this.key = key;
return this;
}
@Override
- public JwtBuilder signWith(SignatureAlgorithm alg, byte[] secretKeyBytes) throws InvalidKeyException {
+ public JwtBuilder signWith(Key key, io.jsonwebtoken.SignatureAlgorithm alg) throws InvalidKeyException {
+ Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
+ return signWith(key, SignatureAlgorithms.forName(alg.getValue()));
+ }
+
+ @Override
+ public JwtBuilder signWith(io.jsonwebtoken.SignatureAlgorithm alg, byte[] secretKeyBytes) throws InvalidKeyException {
Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
Assert.notEmpty(secretKeyBytes, "secret key byte array cannot be null or empty.");
Assert.isTrue(alg.isHmac(), "Key bytes may only be specified for HMAC signatures. If using RSA or Elliptic Curve, use the signWith(SignatureAlgorithm, Key) method instead.");
@@ -135,7 +162,7 @@ public JwtBuilder signWith(SignatureAlgorithm alg, byte[] secretKeyBytes) throws
}
@Override
- public JwtBuilder signWith(SignatureAlgorithm alg, String base64EncodedSecretKey) throws InvalidKeyException {
+ public JwtBuilder signWith(io.jsonwebtoken.SignatureAlgorithm alg, String base64EncodedSecretKey) throws InvalidKeyException {
Assert.hasText(base64EncodedSecretKey, "base64-encoded secret key cannot be null or empty.");
Assert.isTrue(alg.isHmac(), "Base64-encoded key bytes may only be specified for HMAC signatures. If using RSA or Elliptic Curve, use the signWith(SignatureAlgorithm, Key) method instead.");
byte[] bytes = Decoders.BASE64.decode(base64EncodedSecretKey);
@@ -143,7 +170,7 @@ public JwtBuilder signWith(SignatureAlgorithm alg, String base64EncodedSecretKey
}
@Override
- public JwtBuilder signWith(SignatureAlgorithm alg, Key key) {
+ public JwtBuilder signWith(io.jsonwebtoken.SignatureAlgorithm alg, Key key) {
return signWith(key, alg);
}
@@ -315,21 +342,11 @@ public String compact() {
jwsHeader = (JwsHeader) header;
} else {
//noinspection unchecked
- jwsHeader = new DefaultJwsHeader(header);
- }
-
- if (key != null) {
- jwsHeader.setAlgorithm(algorithm.getValue());
- } else {
- //no signature - plaintext JWT:
- jwsHeader.setAlgorithm(SignatureAlgorithm.NONE.getValue());
- }
-
- if (compressionCodec != null) {
- jwsHeader.setCompressionAlgorithm(compressionCodec.getAlgorithmName());
+ header = jwsHeader = new DefaultJwsHeader(header);
}
- String base64UrlEncodedHeader = base64UrlEncode(jwsHeader, "Unable to serialize header to json.");
+ Assert.state(algorithm != null, "algorithm instance should never be null."); // invariant
+ jwsHeader.setAlgorithm(algorithm.getName());
byte[] bytes;
try {
@@ -339,19 +356,20 @@ public String compact() {
}
if (compressionCodec != null) {
+ header.setCompressionAlgorithm(compressionCodec.getAlgorithmName());
bytes = compressionCodec.compress(bytes);
}
+ String base64UrlEncodedHeader = base64UrlEncode(jwsHeader, "Unable to serialize header to json.");
String base64UrlEncodedBody = base64UrlEncoder.encode(bytes);
String jwt = base64UrlEncodedHeader + JwtParser.SEPARATOR_CHAR + base64UrlEncodedBody;
if (key != null) { //jwt must be signed:
-
- JwtSigner signer = createSigner(algorithm, key);
-
- String base64UrlSignature = signer.sign(jwt);
-
+ byte[] data = jwt.getBytes(StandardCharsets.US_ASCII);
+ CryptoRequest request = new DefaultCryptoRequest<>(data, key, provider, secureRandom);
+ byte[] signature = algorithm.sign(request);
+ String base64UrlSignature = base64UrlEncoder.encode(signature);
jwt += JwtParser.SEPARATOR_CHAR + base64UrlSignature;
} else {
// no signature (plaintext), but must terminate w/ a period, see
@@ -362,17 +380,10 @@ public String compact() {
return jwt;
}
- /*
- * @since 0.5 mostly to allow testing overrides
- */
- protected JwtSigner createSigner(SignatureAlgorithm alg, Key key) {
- return new DefaultJwtSigner(alg, key, base64UrlEncoder);
- }
-
@Deprecated // remove before 1.0 - call the serializer and base64UrlEncoder directly
protected String base64UrlEncode(Object o, String errMsg) {
Assert.isInstanceOf(Map.class, o, "object argument must be a map.");
- Map m = (Map)o;
+ Map m = (Map) o;
byte[] bytes;
try {
bytes = toJson(m);
@@ -387,7 +398,7 @@ protected String base64UrlEncode(Object o, String errMsg) {
@Deprecated //remove before 1.0 - call the serializer directly
protected byte[] toJson(Object object) throws SerializationException {
Assert.isInstanceOf(Map.class, object, "object argument must be a map.");
- Map m = (Map)object;
+ Map m = (Map) object;
return serializer.serialize(m);
}
}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParser.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParser.java
index 591433f3c..a31588e41 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParser.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParser.java
@@ -33,26 +33,35 @@
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.MissingClaimException;
import io.jsonwebtoken.PrematureJwtException;
-import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.SigningKeyResolver;
import io.jsonwebtoken.UnsupportedJwtException;
import io.jsonwebtoken.impl.compression.DefaultCompressionCodecResolver;
-import io.jsonwebtoken.impl.crypto.DefaultJwtSignatureValidator;
-import io.jsonwebtoken.impl.crypto.JwtSignatureValidator;
+import io.jsonwebtoken.impl.crypto.DefaultSignatureValidatorFactory;
+import io.jsonwebtoken.impl.crypto.SignatureValidator;
+import io.jsonwebtoken.impl.crypto.SignatureValidatorFactory;
import io.jsonwebtoken.impl.lang.LegacyServices;
+import io.jsonwebtoken.impl.security.DefaultVerifySignatureRequest;
import io.jsonwebtoken.io.Decoder;
import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.io.DecodingException;
+import io.jsonwebtoken.io.DeserializationException;
import io.jsonwebtoken.io.Deserializer;
import io.jsonwebtoken.lang.Assert;
import io.jsonwebtoken.lang.DateFormats;
import io.jsonwebtoken.lang.Objects;
import io.jsonwebtoken.lang.Strings;
import io.jsonwebtoken.security.InvalidKeyException;
+import io.jsonwebtoken.security.SignatureAlgorithm;
+import io.jsonwebtoken.security.SignatureAlgorithms;
import io.jsonwebtoken.security.SignatureException;
+import io.jsonwebtoken.security.SymmetricKeySignatureAlgorithm;
+import io.jsonwebtoken.security.VerifySignatureRequest;
import io.jsonwebtoken.security.WeakKeyException;
import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
import java.security.Key;
+import java.security.Provider;
import java.util.Date;
import java.util.Map;
@@ -61,7 +70,11 @@ public class DefaultJwtParser implements JwtParser {
private static final int MILLISECONDS_PER_SECOND = 1000;
+ private static final JwtTokenizer jwtTokenizer = new JwtTokenizer();
+
// TODO: make the folling fields final for v1.0
+ private Provider provider;
+
private byte[] keyBytes;
private Key key;
@@ -82,12 +95,15 @@ public class DefaultJwtParser implements JwtParser {
/**
* TODO: remove this constructor before 1.0
+ *
* @deprecated for backward compatibility only, see other constructors.
*/
@Deprecated
- public DefaultJwtParser() { }
+ public DefaultJwtParser() {
+ }
- DefaultJwtParser(SigningKeyResolver signingKeyResolver,
+ DefaultJwtParser(Provider provider,
+ SigningKeyResolver signingKeyResolver,
Key key,
byte[] keyBytes,
Clock clock,
@@ -96,6 +112,7 @@ public DefaultJwtParser() { }
Decoder base64UrlDecoder,
Deserializer> deserializer,
CompressionCodecResolver compressionCodecResolver) {
+ this.provider = provider;
this.signingKeyResolver = signingKeyResolver;
this.key = key;
this.keyBytes = keyBytes;
@@ -244,6 +261,16 @@ public boolean isSigned(String jwt) {
return false;
}
+ /* ========================================================================
+
+ JWE PARSING LOGIC TEMPORARILY DISABLED
+ Until we find out a cleaner design (delegation, separation of concerns, etc)
+
+ private static void malformed(String type, String part) {
+ String msg = "Required " + type + " " + part + " is missing.";
+ throw new MalformedJwtException(msg);
+ }
+
@Override
public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException, SignatureException {
@@ -257,14 +284,16 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
Assert.hasText(jwt, "JWT String argument cannot be null or empty.");
- if ("..".equals(jwt)) {
- String msg = "JWT string '..' is missing a header.";
- throw new MalformedJwtException(msg);
- }
+ //parse the constituent parts of the compact string:
+ String base64UrlEncodedHeader = null; //JWS or JWE
+
+ String base64UrlEncodedCek = null; //JWE only
+ String base64UrlEncodedPayload = null; //JWS or JWE
- String base64UrlEncodedHeader = null;
- String base64UrlEncodedPayload = null;
- String base64UrlEncodedDigest = null;
+ String base64UrlEncodedIv = null; //JWE only
+
+ String base64UrlEncodedTag = null; //JWE only
+ String base64UrlEncodedDigest = null; //JWS only
int delimiterCount = 0;
@@ -272,15 +301,31 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
for (char c : jwt.toCharArray()) {
+ if (Character.isWhitespace(c)) {
+ String msg = "Compact JWT strings cannot contain whitespace.";
+ throw new MalformedJwtException(msg);
+ }
+
if (c == SEPARATOR_CHAR) {
CharSequence tokenSeq = Strings.clean(sb);
String token = tokenSeq != null ? tokenSeq.toString() : null;
- if (delimiterCount == 0) {
- base64UrlEncodedHeader = token;
- } else if (delimiterCount == 1) {
- base64UrlEncodedPayload = token;
+ switch (delimiterCount) {
+ case 0:
+ base64UrlEncodedHeader = token;
+ break;
+ case 1:
+ //we'll figure out if we have a compact JWE or JWS after finishing inspecting the char array:
+ base64UrlEncodedCek = token;
+ base64UrlEncodedPayload = token;
+ break;
+ case 2:
+ base64UrlEncodedIv = token;
+ break;
+ case 3:
+ base64UrlEncodedPayload = token; //ciphertext
+ break;
}
delimiterCount++;
@@ -290,27 +335,255 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
}
}
- if (delimiterCount != 2) {
- String msg = "JWT strings must contain exactly 2 period characters. Found: " + delimiterCount;
+ boolean jwe;
+ if (delimiterCount == 2) { // JWT or JWS
+ //noinspection ConstantConditions
+ jwe = false;
+ } else if (delimiterCount == 4) { // JWE
+ jwe = true;
+ } else {
+ String msg = "Invalid compact JWT string. JWSs must have exactly 2 period characters, " +
+ "JWEs must have exactly 4. Found: " + delimiterCount + ".";
throw new MalformedJwtException(msg);
}
+
+ String type = jwe ? "JWE" : "JWS";
+
if (sb.length() > 0) {
- base64UrlEncodedDigest = sb.toString();
+ String value = sb.toString();
+ if (jwe) {
+ base64UrlEncodedTag = value;
+ } else {
+ base64UrlEncodedDigest = value;
+ }
+ }
+
+ if (base64UrlEncodedHeader == null) {
+ malformed(type, "Protected Header");
}
+ if (base64UrlEncodedPayload == null) {
+ malformed(type, jwe ? "Ciphertext" : "Payload");
+ }
+
+ if (jwe) {
+ if (base64UrlEncodedIv == null) {
+ malformed(type, "Initialization Vector");
+ }
+ if (base64UrlEncodedTag == null) {
+ malformed(type, "Authentication Tag");
+ }
+ }
+
+ // =============== Header =================
+ Header header;
+
+ CompressionCodec compressionCodec;
+
+ byte[] bytes = base64UrlDecode(base64UrlEncodedHeader);
+ String origValue = new String(bytes, Strings.UTF_8);
+ Map m = (Map) readValue(origValue);
+
+ if (base64UrlEncodedDigest != null) {
+ header = new DefaultJwsHeader(m);
+ } else if (jwe) {
+ header = new DefaultJweHeader(m);
+ } else {
+ header = new DefaultHeader(m);
+ }
+
+ compressionCodec = compressionCodecResolver.resolveCompressionCodec(header);
+
+ // =============== Body =================
+ bytes = base64UrlDecoder.decode(base64UrlEncodedPayload);
+ if (compressionCodec != null) {
+ bytes = compressionCodec.decompress(bytes);
+ }
+ String payload = new String(bytes, Strings.UTF_8);
+
+ Claims claims = null;
+
+ if (payload.charAt(0) == '{' && payload.charAt(payload.length() - 1) == '}') { //likely to be json, parse it:
+ Map claimsMap = (Map) readValue(payload);
+ claims = new DefaultClaims(claimsMap);
+ }
+
+ // =============== Signature =================
+ if (base64UrlEncodedDigest != null) { //it is signed - validate the signature
+
+ JwsHeader jwsHeader = (JwsHeader) header;
+
+ SignatureAlgorithm algorithm = null;
+
+ String alg = jwsHeader.getAlgorithm();
+ if (Strings.hasText(alg)) {
+ algorithm = SignatureAlgorithm.forName(alg);
+ }
+
+ if (algorithm == null || algorithm == SignatureAlgorithm.NONE) {
+ //it is plaintext, but it has a signature. This is invalid:
+ String msg = "JWT string has a digest/signature, but the header does not reference a valid signature " +
+ "algorithm.";
+ throw new MalformedJwtException(msg);
+ }
+
+ if (key != null && keyBytes != null) {
+ throw new IllegalStateException("A key object and key bytes cannot both be specified. Choose either.");
+ } else if ((key != null || keyBytes != null) && signingKeyResolver != null) {
+ String object = key != null ? "a key object" : "key bytes";
+ throw new IllegalStateException("A signing key resolver and " + object + " cannot both be specified. Choose either.");
+ }
+
+ //digitally signed, let's assert the signature:
+ Key key = this.key;
+
+ if (key == null) { //fall back to keyBytes
+
+ byte[] keyBytes = this.keyBytes;
+
+ if (Objects.isEmpty(keyBytes) && signingKeyResolver != null) { //use the signingKeyResolver
+ if (claims != null) {
+ key = signingKeyResolver.resolveSigningKey(jwsHeader, claims);
+ } else {
+ key = signingKeyResolver.resolveSigningKey(jwsHeader, payload);
+ }
+ }
+
+ if (!Objects.isEmpty(keyBytes)) {
+
+ Assert.isTrue(algorithm.isHmac(),
+ "Key bytes can only be specified for HMAC signatures. Please specify a PublicKey or PrivateKey instance.");
+
+ key = new SecretKeySpec(keyBytes, algorithm.getJcaName());
+ }
+ }
+
+ Assert.notNull(key, "A signing key must be specified if the specified JWT is digitally signed.");
+
+ //re-create the jwt part without the signature. This is what needs to be signed for verification:
+ String jwtWithoutSignature = base64UrlEncodedHeader + SEPARATOR_CHAR + base64UrlEncodedPayload;
+
+ JwtSignatureValidator validator;
+ try {
+ algorithm.assertValidVerificationKey(key); //since 0.10.0: https://github.com/jwtk/jjwt/issues/334
+ validator = createSignatureValidator(algorithm, key);
+ } catch (WeakKeyException e) {
+ throw e;
+ } catch (InvalidKeyException | IllegalArgumentException e) {
+ String algName = algorithm.getValue();
+ String msg = "The parsed JWT indicates it was signed with the " + algName + " signature " +
+ "algorithm, but the specified signing key of type " + key.getClass().getName() +
+ " may not be used to validate " + algName + " signatures. Because the specified " +
+ "signing key reflects a specific and expected algorithm, and the JWT does not reflect " +
+ "this algorithm, it is likely that the JWT was not expected and therefore should not be " +
+ "trusted. Another possibility is that the parser was configured with the incorrect " +
+ "signing key, but this cannot be assumed for security reasons.";
+ throw new UnsupportedJwtException(msg, e);
+ }
+
+ if (!validator.isValid(jwtWithoutSignature, base64UrlEncodedDigest)) {
+ String msg = "JWT signature does not match locally computed signature. JWT validity cannot be " +
+ "asserted and should not be trusted.";
+ throw new SignatureException(msg);
+ }
+ }
+
+ final boolean allowSkew = this.allowedClockSkewMillis > 0;
+
+ //since 0.3:
+ if (claims != null) {
+
+ final Date now = this.clock.now();
+ long nowTime = now.getTime();
+
+ //https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-30#section-4.1.4
+ //token MUST NOT be accepted on or after any specified exp time:
+ Date exp = claims.getExpiration();
+ if (exp != null) {
+
+ long maxTime = nowTime - this.allowedClockSkewMillis;
+ Date max = allowSkew ? new Date(maxTime) : now;
+ if (max.after(exp)) {
+ String expVal = DateFormats.formatIso8601(exp, false);
+ String nowVal = DateFormats.formatIso8601(now, false);
+
+ long differenceMillis = maxTime - exp.getTime();
+
+ String msg = "JWT expired at " + expVal + ". Current time: " + nowVal + ", a difference of " +
+ differenceMillis + " milliseconds. Allowed clock skew: " +
+ this.allowedClockSkewMillis + " milliseconds.";
+ throw new ExpiredJwtException(header, claims, msg);
+ }
+ }
+
+ //https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-30#section-4.1.5
+ //token MUST NOT be accepted before any specified nbf time:
+ Date nbf = claims.getNotBefore();
+ if (nbf != null) {
+
+ long minTime = nowTime + this.allowedClockSkewMillis;
+ Date min = allowSkew ? new Date(minTime) : now;
+ if (min.before(nbf)) {
+ String nbfVal = DateFormats.formatIso8601(nbf, false);
+ String nowVal = DateFormats.formatIso8601(now, false);
+
+ long differenceMillis = nbf.getTime() - minTime;
+
+ String msg = "JWT must not be accepted before " + nbfVal + ". Current time: " + nowVal +
+ ", a difference of " +
+ differenceMillis + " milliseconds. Allowed clock skew: " +
+ this.allowedClockSkewMillis + " milliseconds.";
+ throw new PrematureJwtException(header, claims, msg);
+ }
+ }
+
+ validateExpectedClaims(header, claims);
+ }
+
+ Object body = claims != null ? claims : payload;
+
+ if (base64UrlEncodedDigest != null) {
+ return new DefaultJws<>((JwsHeader) header, body, base64UrlEncodedDigest);
+ } else {
+ return new DefaultJwt<>(header, body);
+ }
+ }
+
+ ======================================================================== */
+
+ @Override
+ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException, SignatureException {
+
+ // TODO, this logic is only need for a now deprecated code path
+ // remove this block in v1.0 (the equivalent is already in DefaultJwtParserBuilder)
+ if (this.deserializer == null) {
+ // try to find one based on the services available
+ // TODO: This util class will throw a UnavailableImplementationException here to retain behavior of previous version, remove in v1.0
+ this.deserializer = LegacyServices.loadFirst(Deserializer.class);
+ }
+
+ Assert.hasText(jwt, "JWT String argument cannot be null or empty.");
+
+ if ("..".equals(jwt)) {
+ String msg = "JWT string '..' is missing a header.";
+ throw new MalformedJwtException(msg);
+ }
+
+ TokenizedJwt tokenized = jwtTokenizer.tokenize(jwt);
// =============== Header =================
Header header = null;
CompressionCodec compressionCodec = null;
- if (base64UrlEncodedHeader != null) {
- byte[] bytes = base64UrlDecoder.decode(base64UrlEncodedHeader);
+ if (tokenized.getProtected() != null) {
+
+ byte[] bytes = base64UrlDecode(tokenized.getProtected());
String origValue = new String(bytes, Strings.UTF_8);
Map m = (Map) readValue(origValue);
- if (base64UrlEncodedDigest != null) {
- header = new DefaultJwsHeader(m);
+ if (tokenized.getDigest() != null) {
+ header = tokenized instanceof TokenizedJwe ? new DefaultJweHeader(m) : new DefaultJwsHeader(m);
} else {
header = new DefaultHeader(m);
}
@@ -320,8 +593,8 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
// =============== Body =================
String payload = ""; // https://github.com/jwtk/jjwt/pull/540
- if (base64UrlEncodedPayload != null) {
- byte[] bytes = base64UrlDecoder.decode(base64UrlEncodedPayload);
+ if (tokenized.getBody() != null) {
+ byte[] bytes = base64UrlDecode(tokenized.getBody());
if (compressionCodec != null) {
bytes = compressionCodec.decompress(bytes);
}
@@ -336,7 +609,7 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
}
// =============== Signature =================
- if (base64UrlEncodedDigest != null) { //it is signed - validate the signature
+ if (tokenized.getDigest() != null) { //it is signed - validate the signature
JwsHeader jwsHeader = (JwsHeader) header;
@@ -345,11 +618,11 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
if (header != null) {
String alg = jwsHeader.getAlgorithm();
if (Strings.hasText(alg)) {
- algorithm = SignatureAlgorithm.forName(alg);
+ algorithm = SignatureAlgorithms.forName(alg);
}
}
- if (algorithm == null || algorithm == SignatureAlgorithm.NONE) {
+ if (algorithm == null || algorithm == SignatureAlgorithms.NONE) {
//it is plaintext, but it has a signature. This is invalid:
String msg = "JWT string has a digest/signature, but the header does not reference a valid signature " +
"algorithm.";
@@ -379,30 +652,38 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
}
if (!Objects.isEmpty(keyBytes)) {
-
- Assert.isTrue(algorithm.isHmac(),
- "Key bytes can only be specified for HMAC signatures. Please specify a PublicKey or PrivateKey instance.");
-
- key = new SecretKeySpec(keyBytes, algorithm.getJcaName());
+ Assert.isTrue(algorithm instanceof SymmetricKeySignatureAlgorithm,
+ "Key bytes can only be specified for symmetric key signatures. Please specify a PublicKey or PrivateKey instance.");
+ key = new SecretKeySpec(keyBytes, ((SymmetricKeySignatureAlgorithm) algorithm).generateKey().getAlgorithm());
}
}
Assert.notNull(key, "A signing key must be specified if the specified JWT is digitally signed.");
//re-create the jwt part without the signature. This is what needs to be signed for verification:
- String jwtWithoutSignature = base64UrlEncodedHeader + SEPARATOR_CHAR;
- if (base64UrlEncodedPayload != null) {
- jwtWithoutSignature += base64UrlEncodedPayload;
+ String jwtWithoutSignature = tokenized.getProtected() + SEPARATOR_CHAR;
+ if (tokenized.getBody() != null) {
+ jwtWithoutSignature += tokenized.getBody();
}
- JwtSignatureValidator validator;
+ byte[] data = jwtWithoutSignature.getBytes(StandardCharsets.US_ASCII);
+ byte[] signature = base64UrlDecode(tokenized.getDigest());
+
try {
- algorithm.assertValidVerificationKey(key); //since 0.10.0: https://github.com/jwtk/jjwt/issues/334
- validator = createSignatureValidator(algorithm, key);
+ VerifySignatureRequest request =
+ new DefaultVerifySignatureRequest(data, key, this.provider, null, signature);
+
+ //SignatureValidator validator = DefaultSignatureValidatorFactory.INSTANCE.createSignatureValidator(io.jsonwebtoken.SignatureAlgorithm.forName(algorithm.getName()), key);
+ // if (!validator.isValid(data, signature)) {
+ if (!algorithm.verify(request)) {
+ String msg = "JWT signature does not match locally computed signature. JWT validity cannot be " +
+ "asserted and should not be trusted.";
+ throw new SignatureException(msg);
+ }
} catch (WeakKeyException e) {
throw e;
} catch (InvalidKeyException | IllegalArgumentException e) {
- String algName = algorithm.getValue();
+ String algName = algorithm.getName();
String msg = "The parsed JWT indicates it was signed with the " + algName + " signature " +
"algorithm, but the specified signing key of type " + key.getClass().getName() +
" may not be used to validate " + algName + " signatures. Because the specified " +
@@ -412,12 +693,6 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
"signing key, but this cannot be assumed for security reasons.";
throw new UnsupportedJwtException(msg, e);
}
-
- if (!validator.isValid(jwtWithoutSignature, base64UrlEncodedDigest)) {
- String msg = "JWT signature does not match locally computed signature. JWT validity cannot be " +
- "asserted and should not be trusted.";
- throw new SignatureException(msg);
- }
}
final boolean allowSkew = this.allowedClockSkewMillis > 0;
@@ -474,8 +749,8 @@ public Jwt parse(String jwt) throws ExpiredJwtException, MalformedJwtException,
Object body = claims != null ? claims : payload;
- if (base64UrlEncodedDigest != null) {
- return new DefaultJws<>((JwsHeader) header, body, base64UrlEncodedDigest);
+ if (tokenized.getDigest() != null) {
+ return new DefaultJws<>((JwsHeader) header, body, tokenized.getDigest());
} else {
return new DefaultJwt<>(header, body);
}
@@ -533,13 +808,6 @@ private void validateExpectedClaims(Header header, Claims claims) {
}
}
- /*
- * @since 0.5 mostly to allow testing overrides
- */
- protected JwtSignatureValidator createSignatureValidator(SignatureAlgorithm alg, Key key) {
- return new DefaultJwtSignatureValidator(alg, key, base64UrlDecoder);
- }
-
@Override
public T parse(String compact, JwtHandler handler)
throws ExpiredJwtException, MalformedJwtException, SignatureException {
@@ -614,6 +882,15 @@ public Jws onClaimsJws(Jws jws) {
});
}
+ protected byte[] base64UrlDecode(String base64UrlEncoded) {
+ try {
+ return base64UrlDecoder.decode(base64UrlEncoded);
+ } catch (DecodingException e) {
+ String msg = "Invalid Base64Url string: " + base64UrlEncoded;
+ throw new MalformedJwtException(msg, e);
+ }
+ }
+
@SuppressWarnings("unchecked")
protected Map readValue(String val) {
byte[] bytes = val.getBytes(Strings.UTF_8);
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParserBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParserBuilder.java
index 3b299ebfb..d86f9ec12 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParserBuilder.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultJwtParserBuilder.java
@@ -22,13 +22,14 @@
import io.jsonwebtoken.JwtParserBuilder;
import io.jsonwebtoken.SigningKeyResolver;
import io.jsonwebtoken.impl.compression.DefaultCompressionCodecResolver;
+import io.jsonwebtoken.impl.lang.Services;
import io.jsonwebtoken.io.Decoder;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.io.Deserializer;
import io.jsonwebtoken.lang.Assert;
-import io.jsonwebtoken.impl.lang.Services;
import java.security.Key;
+import java.security.Provider;
import java.util.Date;
import java.util.Map;
@@ -49,6 +50,8 @@ public class DefaultJwtParserBuilder implements JwtParserBuilder {
static final String MAX_CLOCK_SKEW_ILLEGAL_MSG = "Illegal allowedClockSkewMillis value: multiplying this " +
"value by 1000 to obtain the number of milliseconds would cause a numeric overflow.";
+ private Provider provider;
+
private byte[] keyBytes;
private Key key;
@@ -67,6 +70,11 @@ public class DefaultJwtParserBuilder implements JwtParserBuilder {
private long allowedClockSkewMillis = 0;
+ @Override
+ public JwtParserBuilder setProvider(Provider provider) {
+ this.provider = provider;
+ return this;
+ }
@Override
public JwtParserBuilder deserializeJsonWith(Deserializer> deserializer) {
@@ -197,7 +205,8 @@ public JwtParser build() {
}
return new ImmutableJwtParser(
- new DefaultJwtParser(signingKeyResolver,
+ new DefaultJwtParser(provider,
+ signingKeyResolver,
key,
keyBytes,
clock,
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultTokenizedJwe.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultTokenizedJwe.java
new file mode 100644
index 000000000..68724dc2a
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultTokenizedJwe.java
@@ -0,0 +1,23 @@
+package io.jsonwebtoken.impl;
+
+class DefaultTokenizedJwe extends DefaultTokenizedJwt implements TokenizedJwe {
+
+ private final String encryptedKey;
+ private final String iv;
+
+ DefaultTokenizedJwe(String protectedHeader, String body, String digest, String encryptedKey, String iv) {
+ super(protectedHeader, body, digest);
+ this.encryptedKey = encryptedKey;
+ this.iv = iv;
+ }
+
+ @Override
+ public String getEncryptedKey() {
+ return this.encryptedKey;
+ }
+
+ @Override
+ public String getIv() {
+ return this.iv;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DefaultTokenizedJwt.java b/impl/src/main/java/io/jsonwebtoken/impl/DefaultTokenizedJwt.java
new file mode 100644
index 000000000..cf7d1ae52
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DefaultTokenizedJwt.java
@@ -0,0 +1,29 @@
+package io.jsonwebtoken.impl;
+
+class DefaultTokenizedJwt implements TokenizedJwt {
+
+ private final String protectedHeader;
+ private final String body;
+ private final String digest;
+
+ DefaultTokenizedJwt(String protectedHeader, String body, String digest) {
+ this.protectedHeader = protectedHeader;
+ this.body = body;
+ this.digest = digest;
+ }
+
+ @Override
+ public String getProtected() {
+ return this.protectedHeader;
+ }
+
+ @Override
+ public String getBody() {
+ return this.body;
+ }
+
+ @Override
+ public String getDigest() {
+ return this.digest;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/DispatchingParser.java b/impl/src/main/java/io/jsonwebtoken/impl/DispatchingParser.java
new file mode 100644
index 000000000..99b465b63
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/DispatchingParser.java
@@ -0,0 +1,145 @@
+package io.jsonwebtoken.impl;
+
+import io.jsonwebtoken.lang.Assert;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DispatchingParser {
+
+ static final char DELIMITER = '.';
+
+ /*
+
+ public void parse(String compactJwe) {
+
+ //parse the constituent parts of the compact JWE:
+
+ String base64UrlEncodedHeader = null; //JWT, JWS or JWE
+
+ String base64UrlEncodedCek = null; //JWE only
+ String base64UrlEncodedPayload = null; //JWT or JWS
+
+ String base64UrlEncodedIv = null; //JWE only
+ String base64UrlEncodedCiphertext = null; //JWE only
+
+ String base64UrlEncodedTag = null; //JWE only
+ String base64UrlencodedDigest = null; //JWS only
+
+ StringBuilder sb = new StringBuilder();
+
+ char[] chars = compactJwe.toCharArray();
+
+ int tokenIndex = 0;
+
+ for (char c : chars) {
+
+ Assert.isTrue(!Character.isWhitespace(c), "Compact JWT strings cannot contain whitespace.");
+
+ if (c == DELIMITER) {
+
+ String value = sb.length() > 0 ? sb.toString() : null;
+
+ switch (tokenIndex) {
+ case 0:
+ base64UrlEncodedHeader = value;
+ break;
+ case 1:
+ //we'll figure out if we have a compact JWE or JWS after finishing inspecting the char array:
+ base64UrlEncodedCek = value;
+ base64UrlEncodedPayload = value;
+ case 2:
+ base64UrlEncodedIv = value;
+ break;
+ case 3:
+ base64UrlEncodedCiphertext = value;
+ break;
+ }
+
+ sb = new StringBuilder();
+ tokenIndex++;
+ } else {
+ sb.append(c);
+ }
+ }
+
+ boolean jwe = false;
+ if (tokenIndex == 2) { // JWT or JWS
+ jwe = false;
+ } else if (tokenIndex == 4) { // JWE
+ jwe = true;
+ } else {
+ String msg = "Invalid compact JWT string - invalid number of period character delimiters: " + tokenIndex +
+ ". JWTs and JWSs must have exactly 2 periods, JWEs must have exactly 4 periods.";
+ throw new IllegalArgumentException(msg);
+ }
+
+ if (sb.length() > 0) {
+ String value = sb.toString();
+ if (jwe) {
+ base64UrlEncodedTag = value;
+ } else {
+ base64UrlencodedDigest = value;
+ }
+ }
+
+ throw new UnsupportedOperationException("Not yet implemented.");
+
+ /*
+
+
+ base64UrlEncodedTag = sb.toString();
+
+ Assert.notNull(base64UrlEncodedHeader, "Invalid compact JWE: base64Url JWE Protected Header is missing.");
+ Assert.notNull(base64UrlEncodedIv, "Invalid compact JWE: base64Url JWE Initialization Vector is missing.");
+ Assert.notNull(base64UrlEncodedCiphertext, "Invalid compact JWE: base64Url JWE Ciphertext is missing.");
+ Assert.notNull(base64UrlEncodedTag, "Invalid compact JWE: base64Url JWE Authentication Tag is missing.");
+
+ //find which encryption key was used so we can decrypt:
+ final byte[] headerBytes = base64UrlDecode(base64UrlEncodedHeader);
+ final DefaultHeaders headers = serializationCodec.deserialize(headerBytes, DefaultHeaders.class);
+
+ SecretKey secretKey = secretKeyResolver.getSecretKey(headers);
+ if (secretKey == null) {
+ String msg = "SecretKeyResolver did not return a secret key for headers " + headers +
+ ". This is required for message decryption.";
+ throw new CryptoException(msg);
+ }
+
+ byte[] aad = base64UrlEncodedHeader.getBytes(StandardCharsets.US_ASCII);
+ byte[] iv = base64UrlDecode(base64UrlEncodedIv);
+ byte[] ciphertext = base64UrlDecode(base64UrlEncodedCiphertext);
+ byte[] tag = base64UrlDecode(base64UrlEncodedTag);
+
+ DecryptionRequest dreq = DecryptionRequests.builder()
+ .setKey(secretKey.getEncoded())
+ .setAdditionalAuthenticatedData(aad)
+ .setInitializationVector(iv)
+ .setCiphertext(ciphertext)
+ .setAuthenticationTag(tag)
+ .build();
+
+ byte[] plaintext = encryptionService.decrypt(dreq);
+
+ CompressionAlgorithm calg = headers.getCompressionAlgorithm();
+ if (calg != null) {
+ plaintext = calg.getCodec().decompress(plaintext);
+ }
+
+ Object body = null;
+
+ val = headers.get(JAVA_TYPE_HEADER_NAME);
+ if (val != null) {
+ String jtyp = val.toString();
+ if (jtyp != null) {
+ Class bodyType = ClassUtils.forName(jtyp);
+ body = serializationCodec.deserialize(plaintext, bodyType);
+ }
+ }
+
+ message.getHeaders().putAll(headers);
+ message.setBody(body);
+
+ }
+ */
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/JwtMap.java b/impl/src/main/java/io/jsonwebtoken/impl/JwtMap.java
index 0f410dd2c..92c2c6891 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/JwtMap.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/JwtMap.java
@@ -16,7 +16,11 @@
package io.jsonwebtoken.impl;
import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Collections;
import io.jsonwebtoken.lang.DateFormats;
+import io.jsonwebtoken.lang.Strings;
+
+import java.lang.reflect.Array;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Collection;
@@ -100,8 +104,16 @@ protected static Date toSpecDate(Object v, String name) {
return toDate(v, name);
}
+ protected static boolean isReduceableToNull(Object v) {
+ return v == null ||
+ (v instanceof String && !Strings.hasText((String)v)) ||
+ (v instanceof Collection && Collections.isEmpty((Collection) v)) ||
+ (v instanceof Map && Collections.isEmpty((Map)v)) ||
+ (v.getClass().isArray() && Array.getLength(v) == 0);
+ }
+
protected void setValue(String name, Object v) {
- if (v == null) {
+ if (isReduceableToNull(v)) {
map.remove(name);
} else {
map.put(name, v);
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/JwtTokenizer.java b/impl/src/main/java/io/jsonwebtoken/impl/JwtTokenizer.java
new file mode 100644
index 000000000..30910a0da
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/JwtTokenizer.java
@@ -0,0 +1,77 @@
+package io.jsonwebtoken.impl;
+
+import io.jsonwebtoken.MalformedJwtException;
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Strings;
+
+public class JwtTokenizer {
+
+ static final char DELIMITER = '.';
+
+ private static final String DELIM_ERR_MSG_PREFIX = "Invalid compact JWT string: Compact JWSs must contain " +
+ "exactly 2 period characters, and compact JWEs must contain exactly 4. Found: ";
+
+ @SuppressWarnings("unchecked")
+ public T tokenize(String jwt) {
+
+ Assert.hasText(jwt, "Argument cannot be null or empty.");
+
+ String protectedHeader = null; //Both JWS and JWE
+ String body = null; //JWS Payload or JWE Ciphertext
+ String digest = null; //JWS Signature or JWE AAD Tag
+ String encryptedKey = null; //JWE only
+ String iv = null; //JWE only
+
+ int delimiterCount = 0;
+
+ StringBuilder sb = new StringBuilder(128);
+
+ for (char c : jwt.toCharArray()) {
+
+ Assert.isTrue(!Character.isWhitespace(c), "Compact JWT strings may not contain whitespace.");
+
+ if (c == DELIMITER) {
+
+ CharSequence tokenSeq = Strings.clean(sb);
+ String token = tokenSeq != null ? tokenSeq.toString() : null;
+
+ switch (delimiterCount) {
+ case 0:
+ protectedHeader = token;
+ break;
+ case 1:
+ body = token; //for JWS
+ encryptedKey = token; //for JWE
+ break;
+ case 2:
+ body = null; //clear out value set for JWS
+ iv = token;
+ break;
+ case 3:
+ body = token;
+ break;
+ }
+
+ sb.setLength(0);
+ delimiterCount++;
+ } else {
+ sb.append(c);
+ }
+ }
+
+ if (delimiterCount != 2 && delimiterCount != 4) {
+ String msg = DELIM_ERR_MSG_PREFIX + delimiterCount;
+ throw new MalformedJwtException(msg);
+ }
+
+ if (sb.length() > 0) {
+ digest = Strings.clean(sb.toString());
+ }
+
+ if (delimiterCount == 2) {
+ return (T) new DefaultTokenizedJwt(protectedHeader, body, digest);
+ }
+
+ return (T) new DefaultTokenizedJwe(protectedHeader, body, digest, encryptedKey, iv);
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwe.java b/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwe.java
new file mode 100644
index 000000000..6e790ac10
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwe.java
@@ -0,0 +1,8 @@
+package io.jsonwebtoken.impl;
+
+public interface TokenizedJwe extends TokenizedJwt {
+
+ String getEncryptedKey();
+
+ String getIv();
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwt.java b/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwt.java
new file mode 100644
index 000000000..3db2dbe2e
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwt.java
@@ -0,0 +1,20 @@
+package io.jsonwebtoken.impl;
+
+public interface TokenizedJwt {
+
+ /**
+ * Protected header.
+ * @return protected header.
+ */
+ String getProtected();
+
+ /**
+ * Payload for JWS, Ciphertext for JWE
+ */
+ String getBody();
+
+ /**
+ * Signature for JWS, AAD Tag for JWE.
+ */
+ String getDigest();
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwtBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwtBuilder.java
new file mode 100644
index 000000000..cd4ad5edd
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/TokenizedJwtBuilder.java
@@ -0,0 +1,9 @@
+package io.jsonwebtoken.impl;
+
+public interface TokenizedJwtBuilder {
+
+ TokenizedJwtBuilder append(String token);
+
+ T build();
+
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveProvider.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveProvider.java
index 6296289fb..0f6f4d46f 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveProvider.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveProvider.java
@@ -17,6 +17,8 @@
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.impl.security.EllipticCurveSignatureAlgorithm;
+import io.jsonwebtoken.impl.security.Randoms;
import io.jsonwebtoken.lang.Assert;
import io.jsonwebtoken.lang.Strings;
@@ -68,19 +70,19 @@ public static KeyPair generateKeyPair() {
/**
* Generates a new secure-random key pair of sufficient strength for the specified Elliptic Curve {@link
* SignatureAlgorithm} (must be one of {@code ES256}, {@code ES384} or {@code ES512}) using JJWT's default {@link
- * SignatureProvider#DEFAULT_SECURE_RANDOM SecureRandom instance}. This is a convenience method that immediately
+ * Randoms#secureRandom() SecureRandom instance}. This is a convenience method that immediately
* delegates to {@link #generateKeyPair(SignatureAlgorithm, SecureRandom)}.
*
* @param alg the algorithm indicating strength, must be one of {@code ES256}, {@code ES384} or {@code ES512}
* @return a new secure-randomly generated key pair of sufficient strength for the specified {@link
* SignatureAlgorithm} (must be one of {@code ES256}, {@code ES384} or {@code ES512}) using JJWT's default {@link
- * SignatureProvider#DEFAULT_SECURE_RANDOM SecureRandom instance}.
+ * Randoms#secureRandom() SecureRandom instance}.
* @see #generateKeyPair()
* @see #generateKeyPair(SignatureAlgorithm, SecureRandom)
* @see #generateKeyPair(String, String, SignatureAlgorithm, SecureRandom)
*/
public static KeyPair generateKeyPair(SignatureAlgorithm alg) {
- return generateKeyPair(alg, DEFAULT_SECURE_RANDOM);
+ return generateKeyPair(alg, Randoms.secureRandom());
}
/**
@@ -169,7 +171,6 @@ public static int getSignatureByteArrayLength(final SignatureAlgorithm alg)
}
}
-
/**
* Transcodes the JCA ASN.1/DER-encoded signature into the concatenated
* R + S format expected by ECDSA JWS.
@@ -178,52 +179,11 @@ public static int getSignatureByteArrayLength(final SignatureAlgorithm alg)
* @param outputLength The expected length of the ECDSA JWS signature.
* @return The ECDSA JWS encoded signature.
* @throws JwtException If the ASN.1/DER signature format is invalid.
+ * @deprecated since JJWT_RELEASE_VERSION. Use {@code ElliptiCurveSignatureAlgorithm.transcodeSignatureToConcat} instead.
*/
+ @Deprecated
public static byte[] transcodeSignatureToConcat(final byte[] derSignature, int outputLength) throws JwtException {
-
- if (derSignature.length < 8 || derSignature[0] != 48) {
- throw new JwtException("Invalid ECDSA signature format");
- }
-
- int offset;
- if (derSignature[1] > 0) {
- offset = 2;
- } else if (derSignature[1] == (byte) 0x81) {
- offset = 3;
- } else {
- throw new JwtException("Invalid ECDSA signature format");
- }
-
- byte rLength = derSignature[offset + 1];
-
- int i = rLength;
- while ((i > 0) && (derSignature[(offset + 2 + rLength) - i] == 0)) {
- i--;
- }
-
- byte sLength = derSignature[offset + 2 + rLength + 1];
-
- int j = sLength;
- while ((j > 0) && (derSignature[(offset + 2 + rLength + 2 + sLength) - j] == 0)) {
- j--;
- }
-
- int rawLen = Math.max(i, j);
- rawLen = Math.max(rawLen, outputLength / 2);
-
- if ((derSignature[offset - 1] & 0xff) != derSignature.length - offset
- || (derSignature[offset - 1] & 0xff) != 2 + rLength + 2 + sLength
- || derSignature[offset] != 2
- || derSignature[offset + 2 + rLength] != 2) {
- throw new JwtException("Invalid ECDSA signature format");
- }
-
- final byte[] concatSignature = new byte[2 * rawLen];
-
- System.arraycopy(derSignature, (offset + 2 + rLength) - i, concatSignature, rawLen - i, i);
- System.arraycopy(derSignature, (offset + 2 + rLength + 2 + sLength) - j, concatSignature, 2 * rawLen - j, j);
-
- return concatSignature;
+ return EllipticCurveSignatureAlgorithm.transcodeSignatureToConcat(derSignature, outputLength);
}
@@ -236,68 +196,10 @@ public static byte[] transcodeSignatureToConcat(final byte[] derSignature, int o
* {@code null}.
* @return The ASN.1/DER encoded signature.
* @throws JwtException If the ECDSA JWS signature format is invalid.
+ * @deprecated since JJWT_RELEASE_VERSION. Use {@link EllipticCurveSignatureAlgorithm#transcodeSignatureToDER(byte[])} instead.
*/
+ @Deprecated
public static byte[] transcodeSignatureToDER(byte[] jwsSignature) throws JwtException {
-
- int rawLen = jwsSignature.length / 2;
-
- int i = rawLen;
-
- while ((i > 0) && (jwsSignature[rawLen - i] == 0)) {
- i--;
- }
-
- int j = i;
-
- if (jwsSignature[rawLen - i] < 0) {
- j += 1;
- }
-
- int k = rawLen;
-
- while ((k > 0) && (jwsSignature[2 * rawLen - k] == 0)) {
- k--;
- }
-
- int l = k;
-
- if (jwsSignature[2 * rawLen - k] < 0) {
- l += 1;
- }
-
- int len = 2 + j + 2 + l;
-
- if (len > 255) {
- throw new JwtException("Invalid ECDSA signature format");
- }
-
- int offset;
-
- final byte derSignature[];
-
- if (len < 128) {
- derSignature = new byte[2 + 2 + j + 2 + l];
- offset = 1;
- } else {
- derSignature = new byte[3 + 2 + j + 2 + l];
- derSignature[1] = (byte) 0x81;
- offset = 2;
- }
-
- derSignature[0] = 48;
- derSignature[offset++] = (byte) len;
- derSignature[offset++] = 2;
- derSignature[offset++] = (byte) j;
-
- System.arraycopy(jwsSignature, rawLen - i, derSignature, (offset + j) - i, i);
-
- offset += j;
-
- derSignature[offset++] = 2;
- derSignature[offset++] = (byte) l;
-
- System.arraycopy(jwsSignature, 2 * rawLen - k, derSignature, (offset + l) - k, k);
-
- return derSignature;
+ return EllipticCurveSignatureAlgorithm.transcodeSignatureToDER(jwsSignature);
}
}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSignatureValidator.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSignatureValidator.java
index 3fc1fd9a7..9f8729daa 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSignatureValidator.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSignatureValidator.java
@@ -16,6 +16,7 @@
package io.jsonwebtoken.impl.crypto;
import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.impl.security.EllipticCurveSignatureAlgorithm;
import io.jsonwebtoken.lang.Assert;
import io.jsonwebtoken.security.SignatureException;
@@ -48,7 +49,7 @@ public boolean isValid(byte[] data, byte[] signature) {
* and backwards compatibility will possibly be removed in a future version of this library.
*
* **/
- byte[] derSignature = expectedSize != signature.length && signature[0] == 0x30 ? signature : EllipticCurveProvider.transcodeSignatureToDER(signature);
+ byte[] derSignature = expectedSize != signature.length && signature[0] == 0x30 ? signature : EllipticCurveSignatureAlgorithm.transcodeSignatureToDER(signature);
return doVerify(sig, publicKey, data, derSignature);
} catch (Exception e) {
String msg = "Unable to verify Elliptic Curve signature using configured ECPublicKey. " + e.getMessage();
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSigner.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSigner.java
index 9aeb1e8b3..3d0922fd4 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSigner.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/EllipticCurveSigner.java
@@ -17,6 +17,7 @@
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.impl.security.EllipticCurveSignatureAlgorithm;
import io.jsonwebtoken.security.SignatureException;
import java.security.InvalidKeyException;
@@ -54,6 +55,6 @@ protected byte[] doSign(byte[] data) throws InvalidKeyException, java.security.S
Signature sig = createSignatureInstance();
sig.initSign(privateKey);
sig.update(data);
- return transcodeSignatureToConcat(sig.sign(), getSignatureByteArrayLength(alg));
+ return EllipticCurveSignatureAlgorithm.transcodeSignatureToConcat(sig.sign(), getSignatureByteArrayLength(alg));
}
}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/MacProvider.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/MacProvider.java
index b0117411c..e577b6262 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/MacProvider.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/MacProvider.java
@@ -16,6 +16,7 @@
package io.jsonwebtoken.impl.crypto;
import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.impl.security.Randoms;
import io.jsonwebtoken.lang.Assert;
import javax.crypto.KeyGenerator;
@@ -48,19 +49,19 @@ public static SecretKey generateKey() {
/**
* Generates a new secure-random secret key of a length suitable for creating and verifying HMAC signatures
* according to the specified {@code SignatureAlgorithm} using JJWT's default {@link
- * SignatureProvider#DEFAULT_SECURE_RANDOM SecureRandom instance}. This is a convenience method that immediately
+ * Randoms#secureRandom() SecureRandom instance}. This is a convenience method that immediately
* delegates to {@link #generateKey(SignatureAlgorithm, SecureRandom)}.
*
* @param alg the desired signature algorithm
* @return a new secure-random secret key of a length suitable for creating and verifying HMAC signatures according
- * to the specified {@code SignatureAlgorithm} using JJWT's default {@link SignatureProvider#DEFAULT_SECURE_RANDOM
- * SecureRandom instance}.
+ * to the specified {@code SignatureAlgorithm} using JJWT's default {@link
+ * Randoms#secureRandom() SecureRandom instance}.
* @see #generateKey()
* @see #generateKey(SignatureAlgorithm, SecureRandom)
* @since 0.5
*/
public static SecretKey generateKey(SignatureAlgorithm alg) {
- return generateKey(alg, DEFAULT_SECURE_RANDOM);
+ return generateKey(alg, Randoms.secureRandom());
}
/**
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaProvider.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaProvider.java
index bce2b1c7a..11a91102e 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaProvider.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaProvider.java
@@ -16,6 +16,7 @@
package io.jsonwebtoken.impl.crypto;
import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.impl.security.Randoms;
import io.jsonwebtoken.lang.Assert;
import io.jsonwebtoken.lang.RuntimeEnvironment;
import io.jsonwebtoken.security.SignatureException;
@@ -105,7 +106,7 @@ public static KeyPair generateKeyPair() {
/**
* Generates a new RSA secure-randomly key pair of the specified size using JJWT's default {@link
- * SignatureProvider#DEFAULT_SECURE_RANDOM SecureRandom instance}. This is a convenience method that immediately
+ * Randoms#secureRandom() SecureRandom instance}. This is a convenience method that immediately
* delegates to {@link #generateKeyPair(int, SecureRandom)}.
*
* @param keySizeInBits the key size in bits (NOT bytes).
@@ -116,12 +117,12 @@ public static KeyPair generateKeyPair() {
* @since 0.5
*/
public static KeyPair generateKeyPair(int keySizeInBits) {
- return generateKeyPair(keySizeInBits, DEFAULT_SECURE_RANDOM);
+ return generateKeyPair(keySizeInBits, Randoms.secureRandom());
}
/**
* Generates a new RSA secure-randomly key pair suitable for the specified SignatureAlgorithm using JJWT's
- * default {@link SignatureProvider#DEFAULT_SECURE_RANDOM SecureRandom instance}. This is a convenience method
+ * default {@link Randoms#secureRandom() SecureRandom instance}. This is a convenience method
* that immediately delegates to {@link #generateKeyPair(int)} based on the relevant key size for the specified
* algorithm.
*
@@ -146,7 +147,7 @@ public static KeyPair generateKeyPair(SignatureAlgorithm alg) {
keySizeInBits = 3072;
break;
}
- return generateKeyPair(keySizeInBits, DEFAULT_SECURE_RANDOM);
+ return generateKeyPair(keySizeInBits, Randoms.secureRandom());
}
/**
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaSignatureValidator.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaSignatureValidator.java
index ba36be1be..0b4cfd024 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaSignatureValidator.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/RsaSignatureValidator.java
@@ -33,16 +33,19 @@ public class RsaSignatureValidator extends RsaProvider implements SignatureValid
public RsaSignatureValidator(SignatureAlgorithm alg, Key key) {
super(alg, key);
- Assert.isTrue(key instanceof RSAPrivateKey || key instanceof RSAPublicKey,
- "RSA Signature validation requires either a RSAPublicKey or RSAPrivateKey instance.");
+ Assert.isTrue(isRsaKey(key), "RSA Signature validation requires either a RSAPublicKey or RSAPrivateKey instance.");
this.SIGNER = key instanceof RSAPrivateKey ? new RsaSigner(alg, key) : null;
}
+ protected static boolean isRsaKey(Key key) {
+ return key instanceof RSAPrivateKey || key instanceof RSAPublicKey;
+ }
+
@Override
public boolean isValid(byte[] data, byte[] signature) {
if (key instanceof PublicKey) {
- Signature sig = createSignatureInstance();
PublicKey publicKey = (PublicKey) key;
+ Signature sig = createSignatureInstance();
try {
return doVerify(sig, publicKey, data, signature);
} catch (Exception e) {
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/crypto/SignatureProvider.java b/impl/src/main/java/io/jsonwebtoken/impl/crypto/SignatureProvider.java
index 7419a478b..8665565fb 100644
--- a/impl/src/main/java/io/jsonwebtoken/impl/crypto/SignatureProvider.java
+++ b/impl/src/main/java/io/jsonwebtoken/impl/crypto/SignatureProvider.java
@@ -16,6 +16,7 @@
package io.jsonwebtoken.impl.crypto;
import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.impl.security.Randoms;
import io.jsonwebtoken.lang.Assert;
import io.jsonwebtoken.lang.RuntimeEnvironment;
import io.jsonwebtoken.security.SignatureException;
@@ -28,24 +29,10 @@
abstract class SignatureProvider {
/**
- * JJWT's default SecureRandom number generator. This RNG is initialized using the JVM default as follows:
- *
- *
- * static {
- * DEFAULT_SECURE_RANDOM = new SecureRandom();
- * DEFAULT_SECURE_RANDOM.nextBytes(new byte[64]);
- * }
- *
- *
- * nextBytes is called to force the RNG to initialize itself if not already initialized. The
- * byte array is not used and discarded immediately for garbage collection.
+ * @deprecated use {@link Randoms#secureRandom() Randoms.secureRandom()} instead.
*/
- public static final SecureRandom DEFAULT_SECURE_RANDOM;
-
- static {
- DEFAULT_SECURE_RANDOM = new SecureRandom();
- DEFAULT_SECURE_RANDOM.nextBytes(new byte[64]);
- }
+ @Deprecated //TODO: remove for 1.0
+ public static final SecureRandom DEFAULT_SECURE_RANDOM = Randoms.secureRandom();
protected final SignatureAlgorithm alg;
protected final Key key;
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractAeadAesEncryptionAlgorithm.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractAeadAesEncryptionAlgorithm.java
new file mode 100644
index 000000000..7760420c0
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractAeadAesEncryptionAlgorithm.java
@@ -0,0 +1,112 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Arrays;
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.AeadIvRequest;
+import io.jsonwebtoken.security.AeadIvEncryptionResult;
+import io.jsonwebtoken.security.AeadRequest;
+import io.jsonwebtoken.security.AeadSymmetricEncryptionAlgorithm;
+import io.jsonwebtoken.security.AssociatedDataSource;
+import io.jsonwebtoken.security.CryptoException;
+import io.jsonwebtoken.security.CryptoRequest;
+import io.jsonwebtoken.security.InitializationVectorSource;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import java.security.SecureRandom;
+
+import static io.jsonwebtoken.lang.Arrays.*;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+abstract class AbstractAeadAesEncryptionAlgorithm
+ extends AbstractEncryptionAlgorithm, AeadIvEncryptionResult, AeadIvRequest>
+ implements AeadSymmetricEncryptionAlgorithm {
+
+ protected static final int AES_BLOCK_SIZE_BYTES = 16;
+ protected static final int AES_BLOCK_SIZE_BITS = AES_BLOCK_SIZE_BYTES * Byte.SIZE;
+ public static final String INVALID_GENERATED_IV_LENGTH =
+ "generatedIvLengthInBits must be a positive number <= " + AES_BLOCK_SIZE_BITS;
+
+ protected static final String DECRYPT_NO_IV = "This EncryptionAlgorithm implementation rejects decryption " +
+ "requests that do not include initialization vectors. AES ciphertext without an IV is weak and should " +
+ "never be used.";
+
+ private final int generatedIvByteLength;
+ private final int requiredKeyByteLength;
+ private final int requiredKeyBitLength;
+
+ public AbstractAeadAesEncryptionAlgorithm(String name, String transformationString, int generatedIvLengthInBits, int requiredKeySizeInBits) {
+
+ super(name, transformationString);
+
+ Assert.isTrue(generatedIvLengthInBits > 0 && generatedIvLengthInBits <= AES_BLOCK_SIZE_BITS, INVALID_GENERATED_IV_LENGTH);
+ Assert.isTrue((generatedIvLengthInBits % Byte.SIZE) == 0, "generatedIvLengthInBits must be evenly divisible by 8.");
+ this.generatedIvByteLength = generatedIvLengthInBits / Byte.SIZE;
+
+ Assert.isTrue(requiredKeySizeInBits > 0, "requiredKeyLengthInBits must be greater than zero.");
+ Assert.isTrue((requiredKeySizeInBits % Byte.SIZE) == 0, "requiredKeyLengthInBits must be evenly divisible by 8.");
+ this.requiredKeyBitLength = requiredKeySizeInBits;
+ this.requiredKeyByteLength = requiredKeySizeInBits / Byte.SIZE;
+ }
+
+ public int getRequiredKeyByteLength() {
+ return this.requiredKeyByteLength;
+ }
+
+ @Override
+ public SecretKey generateKey() {
+ try {
+ return doGenerateKey();
+ } catch (Exception e) {
+ throw new CryptoException("Unable to generate a new " + getName() + " SecretKey: " + e.getMessage(), e);
+ }
+ }
+
+ protected SecretKey doGenerateKey() throws Exception {
+ KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
+ keyGenerator.init(this.requiredKeyBitLength);
+ return keyGenerator.generateKey();
+ }
+
+ byte[] ensureInitializationVector(AeadRequest request) {
+ byte[] iv = null;
+ if (request instanceof InitializationVectorSource) {
+ iv = Arrays.clean(((InitializationVectorSource)request).getInitializationVector());
+ }
+ if (Arrays.length(iv) == 0) {
+ iv = new byte[this.generatedIvByteLength];
+ SecureRandom random = ensureSecureRandom(request);
+ random.nextBytes(iv);
+ }
+ return iv;
+ }
+
+ SecretKey assertKey(CryptoRequest request) {
+ SecretKey key = request.getKey();
+ return assertKeyLength(key);
+ }
+
+ SecretKey assertKeyLength(SecretKey key) {
+ int length = length(key.getEncoded());
+ if (length != requiredKeyByteLength) {
+ throw new CryptoException("The " + getName() + " algorithm requires that keys have a key length of " +
+ "(preferably secure-random) " + requiredKeyBitLength + " bits (" +
+ requiredKeyByteLength + " bytes). The provided key has a length of " + length * Byte.SIZE
+ + " bits (" + length + " bytes).");
+ }
+ return key;
+ }
+
+ byte[] assertDecryptionIv(InitializationVectorSource src) throws IllegalArgumentException {
+ byte[] iv = src.getInitializationVector();
+ Assert.notEmpty(iv, DECRYPT_NO_IV);
+ return iv;
+ }
+
+ byte[] getAAD(AssociatedDataSource src) {
+ byte[] aad = src.getAssociatedData();
+ return io.jsonwebtoken.lang.Arrays.clean(aad);
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwk.java
new file mode 100644
index 000000000..ade7425a7
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwk.java
@@ -0,0 +1,65 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.CurveId;
+import io.jsonwebtoken.security.CurveIds;
+import io.jsonwebtoken.security.EcJwk;
+import io.jsonwebtoken.security.MalformedKeyException;
+
+@SuppressWarnings("unchecked")
+class AbstractEcJwk extends AbstractJwk implements EcJwk {
+
+ static final String TYPE_VALUE = "EC";
+ static final String CURVE_ID = "crv";
+ static final String X = "x";
+ static final String Y = "y";
+
+ AbstractEcJwk() {
+ super(TYPE_VALUE);
+ }
+
+ @Override
+ public CurveId getCurveId() {
+ Object val = get(CURVE_ID);
+ if (val == null) {
+ return null;
+ }
+ if (val instanceof CurveId) {
+ return (CurveId) val;
+ }
+ if (val instanceof String) {
+ CurveId id = CurveIds.forValue((String) val);
+ setCurveId(id); //replace string with type safe value
+ return id;
+ }
+ throw new MalformedKeyException("EC JWK 'crv' value must be an CurveId or a String. Value has type: " +
+ val.getClass().getName());
+ }
+
+ @Override
+ public T setCurveId(CurveId curveId) {
+ return setRequiredValue(CURVE_ID, curveId, "curve id");
+ }
+
+ @Override
+ public String getX() {
+ return getString(X);
+ }
+
+ @Override
+ public T setX(String x) {
+ return setRequiredValue(X, x, "x coordinate");
+ }
+
+ @Override
+ public String getY() {
+ return getString(Y);
+ }
+
+ @Override
+ public T setY(String y) {
+ y = Strings.clean(y);
+ setValue(Y, y);
+ return (T) this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwkBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwkBuilder.java
new file mode 100644
index 000000000..e7588022e
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwkBuilder.java
@@ -0,0 +1,31 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.CurveId;
+import io.jsonwebtoken.security.EcJwk;
+import io.jsonwebtoken.security.EcJwkBuilder;
+
+@SuppressWarnings("unchecked")
+abstract class AbstractEcJwkBuilder extends AbstractJwkBuilder implements EcJwkBuilder {
+
+ AbstractEcJwkBuilder(JwkValidator validator) {
+ super(validator);
+ }
+
+ @Override
+ public T setCurveId(CurveId curveId) {
+ this.jwk.setCurveId(curveId);
+ return (T) this;
+ }
+
+ @Override
+ public T setX(String x) {
+ this.jwk.setX(x);
+ return (T) this;
+ }
+
+ @Override
+ public T setY(String y) {
+ this.jwk.setY(y);
+ return (T) this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwkValidator.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwkValidator.java
new file mode 100644
index 000000000..eeabbcdc1
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEcJwkValidator.java
@@ -0,0 +1,39 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.CurveId;
+import io.jsonwebtoken.security.CurveIds;
+import io.jsonwebtoken.security.EcJwk;
+import io.jsonwebtoken.security.KeyException;
+
+abstract class AbstractEcJwkValidator extends AbstractJwkValidator {
+
+ AbstractEcJwkValidator() {
+ super(AbstractEcJwk.TYPE_VALUE);
+ }
+
+ @Override
+ final void validateJwk(T jwk) throws KeyException {
+
+ CurveId curveId = jwk.getCurveId();
+ if (curveId == null) { // https://tools.ietf.org/html/rfc7518#section-6.2.1
+ malformed("EC JWK curve id ('crv' property) must be specified.");
+ }
+
+ String x = jwk.getX();
+ if (!Strings.hasText(x)) { // https://tools.ietf.org/html/rfc7518#section-6.2.1
+ malformed("EC JWK x coordinate ('x' property) must be specified.");
+ }
+
+ // https://tools.ietf.org/html/rfc7518#section-6.2.1 (last sentence):
+ if (CurveIds.isStandard(curveId) && !Strings.hasText(jwk.getY())) {
+ malformed(curveId + " EC JWK y coordinate ('y' property) must be specified.");
+ }
+
+ //TODO: RFC length validation for x and y values
+
+ validateEcJwk(jwk);
+ }
+
+ abstract void validateEcJwk(T jwk);
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEncryptionAlgorithm.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEncryptionAlgorithm.java
new file mode 100644
index 000000000..b2f3cd0fa
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractEncryptionAlgorithm.java
@@ -0,0 +1,48 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.CryptoException;
+import io.jsonwebtoken.security.CryptoRequest;
+import io.jsonwebtoken.security.EncryptionAlgorithm;
+import io.jsonwebtoken.security.EncryptionResult;
+
+import java.security.Key;
+
+abstract class AbstractEncryptionAlgorithm,
+ ERes extends EncryptionResult, DReq extends CryptoRequest>
+ extends CipherAlgorithm implements EncryptionAlgorithm {
+
+ AbstractEncryptionAlgorithm(String name, String transformationString) {
+ super(name, transformationString);
+ }
+
+ @Override
+ public ERes encrypt(EReq req) throws CryptoException {
+ try {
+ Assert.notNull(req, "Encryption request cannot be null.");
+ return doEncrypt(req);
+ } catch (CryptoException ce) {
+ throw ce; //propagate
+ } catch (Exception e) {
+ String msg = "Unable to perform " + getName() + " encryption: " + e.getMessage();
+ throw new CryptoException(msg, e);
+ }
+ }
+
+ protected abstract ERes doEncrypt(EReq req) throws Exception;
+
+ @Override
+ public byte[] decrypt(DReq req) throws CryptoException {
+ try {
+ Assert.notNull(req, "Decryption request cannot be null.");
+ return doDecrypt(req);
+ } catch (CryptoException ce) {
+ throw ce; //propagate
+ } catch (Exception e) {
+ String msg = "Unable to perform " + getName() + " decryption: " + e.getMessage();
+ throw new CryptoException(msg, e);
+ }
+ }
+
+ protected abstract byte[] doDecrypt(DReq req) throws Exception;
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwk.java
new file mode 100644
index 000000000..309f6ef18
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwk.java
@@ -0,0 +1,191 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.impl.JwtMap;
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Collections;
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.Jwk;
+import io.jsonwebtoken.security.MalformedKeyException;
+
+import java.lang.reflect.Array;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+@SuppressWarnings("unchecked")
+abstract class AbstractJwk extends JwtMap implements Jwk {
+
+ static final String TYPE = "kty";
+ static final String USE = "use";
+ static final String OPERATIONS = "key_ops";
+ static final String ALGORITHM = "alg";
+ static final String ID = "kid";
+ static final String X509_URL = "x5u";
+ static final String X509_CERT_CHAIN = "x5c";
+ static final String X509_SHA1_THUMBPRINT = "x5t";
+ static final String X509_SHA256_THUMBPRINT = "x5t#S256";
+
+ AbstractJwk(String type) {
+ type = Strings.clean(type);
+ Assert.notNull(type, "JWK type cannot be null or empty.");
+ put(TYPE, type);
+ }
+
+ T setRequiredValue(String key, Object value, String name) {
+ boolean reduceable = value != null && isReduceableToNull(value);
+ if (reduceable) {
+ value = null;
+ }
+ if (value == null) {
+ String msg = getType() + " JWK " + name + " ('" + key + "' property) cannot be null";
+ if (reduceable) {
+ msg += " or empty";
+ }
+ msg += ".";
+ throw new IllegalArgumentException(msg);
+ }
+ setValue(key, value);
+ return (T) this;
+ }
+
+ protected List getList(String name) {
+ Object value = get(name);
+ if (value == null) {
+ return null;
+ }
+ List list = new ArrayList<>();
+ if (value instanceof Collection) {
+ Collection c = (Collection)value;
+ for (Object o : c) {
+ list.add(o == null ? null : String.valueOf(o));
+ }
+ } else if (value.getClass().isArray()) {
+ int length = Array.getLength(value);
+ for (int i = 0; i < length; i ++) {
+ Object o = Array.get(value, i);
+ list.add(o == null ? null : String.valueOf(o));
+ }
+ }
+ return list;
+ }
+
+ @Override
+ public String getType() {
+ return getString(TYPE);
+ }
+
+ @Override
+ public String getUse() {
+ return getString(USE);
+ }
+
+ @Override
+ public T setUse(String use) {
+ setValue(USE, Strings.clean(use));
+ return (T)this;
+ }
+
+ @Override
+ public Set getOperations() {
+ Object val = get(OPERATIONS);
+ if (val instanceof Set) {
+ return (Set)val;
+ }
+ List list = getList(OPERATIONS);
+ return val == null ? null : new LinkedHashSet<>(list);
+ }
+
+ @Override
+ public T setOperations(Set ops) {
+ Set operations = Collections.isEmpty(ops) ? null : new LinkedHashSet<>(ops);
+ setValue(OPERATIONS, operations);
+ return (T)this;
+ }
+
+ @Override
+ public String getAlgorithm() {
+ return getString(ALGORITHM);
+ }
+
+ @Override
+ public T setAlgorithm(String alg) {
+ setValue(ALGORITHM, Strings.clean(alg));
+ return (T)this;
+ }
+
+ @Override
+ public String getId() {
+ return getString(ID);
+ }
+
+ @Override
+ public T setId(String id) {
+ setValue(ID, Strings.clean(id));
+ return (T)this;
+ }
+
+ @Override
+ public URI getX509Url() {
+ Object val = get(X509_URL);
+ if (val == null) {
+ return null;
+ }
+ if (val instanceof URI) {
+ return (URI)val;
+ }
+ String sval = String.valueOf(val);
+ URI uri;
+ try {
+ uri = new URI(sval);
+ setValue(X509_URL, uri); //replace with constructed instance
+ } catch (URISyntaxException e) {
+ String msg = getType() + " JWK x5u value cannot be converted to a URI instance: " + sval;
+ throw new MalformedKeyException(msg, e);
+ }
+ return uri;
+ }
+
+ @Override
+ public T setX509Url(URI url) {
+ setValue(X509_URL, url);
+ return (T)this;
+ }
+
+ @Override
+ public List getX509CertficateChain() {
+ return getList(X509_CERT_CHAIN);
+ }
+
+ @Override
+ public T setX509CertificateChain(List chain) {
+ chain = Collections.isEmpty(chain) ? null : new ArrayList<>(new LinkedHashSet<>(chain)); //guarantee no duplicate elements
+ setValue(X509_CERT_CHAIN, chain);
+ return (T)this;
+ }
+
+ @Override
+ public String getX509CertificateSha1Thumbprint() {
+ return getString(X509_SHA1_THUMBPRINT);
+ }
+
+ @Override
+ public T setX509CertificateSha1Thumbprint(String thumbprint) {
+ setValue(X509_SHA1_THUMBPRINT, Strings.clean(thumbprint));
+ return (T)this;
+ }
+
+ @Override
+ public String getX509CertificateSha256Thumbprint() {
+ return getString(X509_SHA256_THUMBPRINT);
+ }
+
+ @Override
+ public T setX509CertificateSha256Thumbprint(String thumbprint) {
+ setValue(X509_SHA256_THUMBPRINT, Strings.clean(thumbprint));
+ return (T)this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkBuilder.java
new file mode 100644
index 000000000..548b2b6b3
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkBuilder.java
@@ -0,0 +1,79 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.Jwk;
+import io.jsonwebtoken.security.JwkBuilder;
+
+import java.net.URI;
+import java.util.List;
+import java.util.Set;
+
+@SuppressWarnings("unchecked")
+abstract class AbstractJwkBuilder implements JwkBuilder {
+
+ protected final K jwk;
+
+ private final JwkValidator validator;
+
+ AbstractJwkBuilder(JwkValidator validator) {
+ Assert.notNull(validator, "validator cannot be null.");
+ this.validator = validator;
+ this.jwk = newJwk();
+ Assert.notNull(this.jwk, "newJwk implementation cannot return a null instance.");
+ }
+
+ abstract K newJwk();
+
+ public final K build() {
+ validator.validate(this.jwk);
+ return jwk;
+ }
+
+ @Override
+ public T setUse(String use) {
+ this.jwk.setUse(use);
+ return (T)this;
+ }
+
+ @Override
+ public T setOperations(Set ops) {
+ this.jwk.setOperations(ops);
+ return (T)this;
+ }
+
+ @Override
+ public T setAlgorithm(String alg) {
+ this.jwk.setAlgorithm(alg);
+ return (T)this;
+ }
+
+ @Override
+ public T setId(String id) {
+ this.jwk.setId(id);
+ return (T)this;
+ }
+
+ @Override
+ public T setX509Url(URI url) {
+ this.jwk.setX509Url(url);
+ return (T)this;
+ }
+
+ @Override
+ public T setX509CertificateChain(List chain) {
+ this.jwk.setX509CertificateChain(chain);
+ return (T)this;
+ }
+
+ @Override
+ public T setX509CertificateSha1Thumbprint(String thumbprint) {
+ this.jwk.setX509CertificateSha1Thumbprint(thumbprint);
+ return (T)this;
+ }
+
+ @Override
+ public T setX509CertificateSha256Thumbprint(String thumbprint) {
+ this.jwk.setX509CertificateSha256Thumbprint(thumbprint);
+ return (T)this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkConverter.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkConverter.java
new file mode 100644
index 000000000..fd8fc71f0
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkConverter.java
@@ -0,0 +1,86 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.InvalidKeyException;
+import io.jsonwebtoken.security.KeyException;
+import io.jsonwebtoken.security.MalformedKeyException;
+
+import java.math.BigInteger;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.util.Map;
+
+abstract class AbstractJwkConverter implements JwkConverter {
+
+ private static Map assertNotEmpty(Map m) {
+ if (m == null || m.isEmpty()) {
+ throw new InvalidKeyException("JWK map cannot be null or empty.");
+ }
+ return m;
+ }
+
+ static void malformed(String msg) {
+ throw new MalformedKeyException(msg);
+ }
+
+ static String getRequiredString(Map m, String name) {
+ assertNotEmpty(m);
+ Object value = m.get(name);
+ if (value == null) {
+ malformed("JWK is missing required case-sensitive '" + name + "' member.");
+ }
+ String s = String.valueOf(value);
+ if (!Strings.hasText(s)) {
+ malformed("JWK '" + name + "' member cannot be null or empty.");
+ }
+ return s;
+ }
+
+ static BigInteger getRequiredBigInt(Map m, String name) {
+ String s = getRequiredString(m, name);
+ try {
+ byte[] bytes = Decoders.BASE64URL.decode(s);
+ return new BigInteger(bytes);
+ } catch (Exception e) {
+ String msg = "Unable to decode JWK member '" + name + "' to integer from value: " + s;
+ throw new MalformedKeyException(msg, e);
+ }
+ }
+
+ // Copied from Apache Commons Codec 1.14:
+ // https://github.com/apache/commons-codec/blob/af7b94750e2178b8437d9812b28e36ac87a455f2/src/main/java/org/apache/commons/codec/binary/Base64.java#L746-L775
+ static byte[] toUnsignedBytes(BigInteger bigInt) {
+ int bitlen = bigInt.bitLength();
+ // round bitlen
+ bitlen = ((bitlen + 7) >> 3) << 3;
+ final byte[] bigBytes = bigInt.toByteArray();
+
+ if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1) == (bitlen / 8))) {
+ return bigBytes;
+ }
+ // set up params for copying everything but sign bit
+ int startSrc = 0;
+ int len = bigBytes.length;
+
+ // if bigInt is exactly byte-aligned, just skip signbit in copy
+ if ((bigInt.bitLength() % 8) == 0) {
+ startSrc = 1;
+ len--;
+ }
+ final int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
+ final byte[] resizedBytes = new byte[bitlen / 8];
+ System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
+ return resizedBytes;
+ }
+
+ KeyFactory getKeyFactory(String alg) {
+ try {
+ return KeyFactory.getInstance(alg);
+ } catch (NoSuchAlgorithmException e) {
+ String msg = "Unable to obtain JCA KeyFactory instance for algorithm: " + alg;
+ throw new KeyException(msg, e);
+ }
+ }
+
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkValidator.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkValidator.java
new file mode 100644
index 000000000..e004ddf42
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractJwkValidator.java
@@ -0,0 +1,40 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.Jwk;
+import io.jsonwebtoken.security.KeyException;
+import io.jsonwebtoken.security.MalformedKeyException;
+
+abstract class AbstractJwkValidator implements JwkValidator {
+
+ private final String TYPE_VALUE;
+
+ AbstractJwkValidator(String kty) {
+ kty = Strings.clean(kty);
+ Assert.notNull(kty);
+ this.TYPE_VALUE = kty;
+ }
+
+ static void malformed(String msg) throws MalformedKeyException {
+ throw new MalformedKeyException(msg);
+ }
+
+ @Override
+ public final void validate(T jwk) throws KeyException {
+
+ String type = jwk.getType();
+ if (!Strings.hasText(type)) {
+ malformed("JWKs must have a key type ('kty') property value.");
+ }
+
+ if (!TYPE_VALUE.equals(type)) {
+ malformed("JWK does not have expected key type ('kty') value of '" +
+ TYPE_VALUE + "'. Value found: " + type);
+ }
+
+ validateJwk(jwk);
+ }
+
+ abstract void validateJwk(T jwk) throws KeyException;
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractRsaJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractRsaJwk.java
new file mode 100644
index 000000000..960d13b0c
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractRsaJwk.java
@@ -0,0 +1,35 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.RsaJwk;
+
+@SuppressWarnings("unchecked")
+public class AbstractRsaJwk extends AbstractJwk implements RsaJwk {
+
+ static final String TYPE_VALUE = "RSA";
+ static final String MODULUS = "n";
+ static final String EXPONENT = "e";
+
+ AbstractRsaJwk() {
+ super(TYPE_VALUE);
+ }
+
+ @Override
+ public String getModulus() {
+ return getString(MODULUS);
+ }
+
+ @Override
+ public T setModulus(String value) {
+ return setRequiredValue(MODULUS, value, "modulus");
+ }
+
+ @Override
+ public String getExponent() {
+ return getString(EXPONENT);
+ }
+
+ @Override
+ public T setExponent(String value) {
+ return setRequiredValue(EXPONENT, value, "exponent");
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractRsaJwkValidator.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractRsaJwkValidator.java
new file mode 100644
index 000000000..f438a1804
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractRsaJwkValidator.java
@@ -0,0 +1,16 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.KeyException;
+import io.jsonwebtoken.security.RsaJwk;
+
+public class AbstractRsaJwkValidator extends AbstractJwkValidator {
+
+ AbstractRsaJwkValidator() {
+ super(AbstractRsaJwk.TYPE_VALUE);
+ }
+
+ @Override
+ void validateJwk(T jwk) throws KeyException {
+
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractSignatureAlgorithm.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractSignatureAlgorithm.java
new file mode 100644
index 000000000..398089dfb
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractSignatureAlgorithm.java
@@ -0,0 +1,128 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.RuntimeEnvironment;
+import io.jsonwebtoken.security.CryptoRequest;
+import io.jsonwebtoken.security.KeyException;
+import io.jsonwebtoken.security.SignatureAlgorithm;
+import io.jsonwebtoken.security.SignatureException;
+import io.jsonwebtoken.security.VerifySignatureRequest;
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.Key;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+import java.security.Signature;
+import java.security.spec.AlgorithmParameterSpec;
+
+abstract class AbstractSignatureAlgorithm extends CryptoAlgorithm implements SignatureAlgorithm {
+
+ AbstractSignatureAlgorithm(String name, String jcaName) {
+ super(name, jcaName);
+ }
+
+ //visible for testing
+ protected boolean isBouncyCastleAvailable() {
+ return RuntimeEnvironment.BOUNCY_CASTLE_AVAILABLE;
+ }
+
+ protected Signature createSignatureInstance(Provider provider, AlgorithmParameterSpec spec) {
+
+ Signature sig;
+ try {
+ sig = getSignatureInstance(provider);
+ } catch (NoSuchAlgorithmException e) {
+
+ String msg = "JWT signature algorithm '" + getName() + "' uses the JCA algorithm '" + getJcaName() +
+ "', which is not ";
+
+ if (provider != null) {
+ msg += "supported by the specified JCA Provider {" + provider + "}. Try ";
+ } else {
+ msg += "available in the current JVM. Try ";
+ }
+
+ if (!isBouncyCastleAvailable()) {
+ msg += "including BouncyCastle in the runtime classpath, or ";
+ }
+
+ msg += "explicitly supplying a JCA Provider that supports the JCA algorithm name '" + getJcaName() +
+ "'. Cause: " + e.getMessage();
+
+ throw new SignatureException(msg, e);
+ }
+
+ if (spec != null) {
+ try {
+ setParameter(sig, spec);
+ } catch (InvalidAlgorithmParameterException e) {
+ String msg = "Unsupported " + getJcaName() + " parameter {" + spec + "}: " + e.getMessage();
+ throw new SignatureException(msg, e);
+ }
+ }
+
+ return sig;
+ }
+
+ //for testing overrides
+ protected Signature getSignatureInstance(Provider provider) throws NoSuchAlgorithmException {
+ final String jcaName = getJcaName();
+ return provider != null ?
+ Signature.getInstance(jcaName, provider) :
+ Signature.getInstance(jcaName);
+ }
+
+ //for testing overrides
+ protected void setParameter(Signature sig, AlgorithmParameterSpec spec) throws InvalidAlgorithmParameterException {
+ sig.setParameter(spec);
+ }
+
+ protected static String keyType(boolean signing) {
+ return signing ? "signing" : "verification";
+ }
+
+ protected abstract void validateKey(Key key, boolean signing);
+
+ @Override
+ public byte[] sign(CryptoRequest request) throws SignatureException, KeyException {
+ final Key key = Assert.notNull(request.getKey(), "Signature request key cannot be null.");
+ Assert.notEmpty(request.getData(), "Signature request data byte array cannot be null or empty.");
+ try {
+ validateKey(key, true);
+ return doSign(request);
+ } catch (SignatureException | KeyException e) {
+ throw e; //propagate
+ } catch (Exception e) {
+ String msg = "Unable to compute " + getName() + " signature with JCA algorithm '" + getJcaName() + "' " +
+ "using key {" + key + "}: " + e.getMessage();
+ throw new SignatureException(msg, e);
+ }
+ }
+
+ protected abstract byte[] doSign(CryptoRequest request) throws Exception;
+
+ @Override
+ public boolean verify(VerifySignatureRequest request) throws SignatureException, KeyException {
+ final Key key = Assert.notNull(request.getKey(), "Signature verification key cannot be null.");
+ Assert.notEmpty(request.getData(), "Signature verification data byte array cannot be null or empty.");
+ Assert.notEmpty(request.getSignature(), "Signature byte array cannot be null or empty.");
+ try {
+ validateKey(key, false);
+ return doVerify(request);
+ } catch (SignatureException | KeyException e) {
+ throw e; //propagate
+ } catch (Exception e) {
+ String msg = "Unable to verify " + getName() + " signature with JCA algorithm '" + getJcaName() + "' " +
+ "using key {" + key + "}: " + e.getMessage();
+ throw new SignatureException(msg, e);
+ }
+ }
+
+ protected boolean doVerify(VerifySignatureRequest request) throws Exception {
+ byte[] providedSignature = request.getSignature();
+ Assert.notEmpty(providedSignature, "Request signature byte array cannot be null or empty.");
+ byte[] computedSignature = sign(request);
+ return MessageDigest.isEqual(providedSignature, computedSignature);
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractTypedJwkConverter.java b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractTypedJwkConverter.java
new file mode 100644
index 000000000..b52258c50
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/AbstractTypedJwkConverter.java
@@ -0,0 +1,33 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+
+import java.security.KeyFactory;
+import java.util.HashMap;
+import java.util.Map;
+
+abstract class AbstractTypedJwkConverter extends AbstractJwkConverter implements TypedJwkConverter {
+
+ private final String keyType;
+
+ AbstractTypedJwkConverter(String keyType) {
+ Assert.hasText(keyType, "keyType argument cannot be null or empty.");
+ this.keyType = keyType;
+ }
+
+ @Override
+ public String getKeyType() {
+ return this.keyType;
+ }
+
+ KeyFactory getKeyFactory() {
+ return getKeyFactory(getKeyType());
+ }
+
+ Map newJwkMap() {
+ Map m = new HashMap<>();
+ m.put("kty", getKeyType());
+ return m;
+ }
+
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/CipherAlgorithm.java b/impl/src/main/java/io/jsonwebtoken/impl/security/CipherAlgorithm.java
new file mode 100644
index 000000000..0276097ae
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/CipherAlgorithm.java
@@ -0,0 +1,19 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.CryptoRequest;
+
+abstract class CipherAlgorithm extends CryptoAlgorithm {
+
+ private final String transformation;
+
+ CipherAlgorithm(String name, String transformation) {
+ super(name, transformation);
+ Assert.hasText(transformation, "Transformation string cannot be null or empty.");
+ this.transformation = transformation;
+ }
+
+ CipherTemplate newCipherTemplate(CryptoRequest request) {
+ return new CipherTemplate(this.transformation, request != null ? request.getProvider() : null);
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/CipherCallback.java b/impl/src/main/java/io/jsonwebtoken/impl/security/CipherCallback.java
new file mode 100644
index 000000000..575d1318f
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/CipherCallback.java
@@ -0,0 +1,8 @@
+package io.jsonwebtoken.impl.security;
+
+import javax.crypto.Cipher;
+
+public interface CipherCallback {
+
+ T doWithCipher(Cipher cipher) throws Exception;
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/CipherTemplate.java b/impl/src/main/java/io/jsonwebtoken/impl/security/CipherTemplate.java
new file mode 100644
index 000000000..f1757fe87
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/CipherTemplate.java
@@ -0,0 +1,54 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.CryptoException;
+
+import javax.crypto.Cipher;
+import javax.crypto.NoSuchPaddingException;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+
+class CipherTemplate {
+
+ private final Provider provider;
+
+ private final String transformation;
+
+ CipherTemplate(String transformation, Provider provider) {
+ Assert.hasText(transformation, "Transformation string cannot be null or empty.");
+ this.transformation = transformation;
+ this.provider = provider;
+ }
+
+ //for testing visibility
+ Cipher getCipherInstance(String transformation, Provider provider)
+ throws NoSuchPaddingException, NoSuchAlgorithmException {
+ return provider != null ?
+ Cipher.getInstance(transformation, provider) :
+ Cipher.getInstance(transformation);
+ }
+
+ private Cipher newCipher() throws CryptoException {
+ try {
+ return getCipherInstance(transformation, provider);
+ } catch (Exception e) {
+ String msg = "Unable to obtain cipher from ";
+ if (provider != null) {
+ msg += "specified Provider {" + provider + "} ";
+ } else {
+ msg += "default JCA Provider ";
+ }
+ msg += "for transformation '" + transformation + "': " + e.getMessage();
+ throw new CryptoException(msg, e);
+ }
+ }
+
+ T execute(CipherCallback callback) throws CryptoException {
+ Cipher cipher = newCipher();
+ try {
+ return callback.doWithCipher(cipher);
+ } catch (Exception e) {
+ throw new CryptoException("Cipher callback execution failed: " + e.getMessage(), e);
+ }
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/CryptoAlgorithm.java b/impl/src/main/java/io/jsonwebtoken/impl/security/CryptoAlgorithm.java
new file mode 100644
index 000000000..8afc6776b
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/CryptoAlgorithm.java
@@ -0,0 +1,35 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.Named;
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.CryptoRequest;
+
+import java.security.SecureRandom;
+
+abstract class CryptoAlgorithm implements Named {
+
+ private final String name;
+
+ private final String jcaName;
+
+ CryptoAlgorithm(String name, String jcaName) {
+ Assert.hasText(name, "name cannot be null or empty.");
+ this.name = name;
+ Assert.hasText(jcaName, "jcaName cannot be null or empty.");
+ this.jcaName = jcaName;
+ }
+
+ @Override
+ public String getName() {
+ return this.name;
+ }
+
+ String getJcaName() {
+ return this.jcaName;
+ }
+
+ SecureRandom ensureSecureRandom(CryptoRequest request) {
+ SecureRandom random = request.getSecureRandom();
+ return random != null ? random : Randoms.secureRandom();
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAeadIvEncryptionResult.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAeadIvEncryptionResult.java
new file mode 100644
index 000000000..434bee5c6
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAeadIvEncryptionResult.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.AeadIvEncryptionResult;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+class DefaultAeadIvEncryptionResult extends DefaultIvEncryptionResult implements AeadIvEncryptionResult {
+
+ private final byte[] tag;
+
+ DefaultAeadIvEncryptionResult(byte[] ciphertext, byte[] iv, byte[] tag) {
+ super(ciphertext, iv);
+ this.tag = Assert.notEmpty(tag, "authentication tag cannot be null or empty.");
+ }
+
+ @Override
+ public byte[] getAuthenticationTag() {
+ return this.tag;
+ }
+
+ @Override
+ public byte[] compact() {
+ byte[] output = new byte[iv.length + ciphertext.length + tag.length];
+ System.arraycopy(iv, 0, output, 0, iv.length); // iv first
+ System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); // then ciphertext
+ System.arraycopy(tag, 0, output, iv.length + ciphertext.length, tag.length); // finally tag
+ return output;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAeadIvRequest.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAeadIvRequest.java
new file mode 100644
index 000000000..0ecc0d885
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAeadIvRequest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.AeadIvRequest;
+
+import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DefaultAeadIvRequest extends DefaultIvDecryptionRequest
+ implements AeadIvRequest {
+
+ private final byte[] aad;
+
+ private final byte[] tag;
+
+ public DefaultAeadIvRequest(T data, K key, Provider provider, SecureRandom secureRandom, byte[] iv, byte[] aad, byte[] tag) {
+ super(data, key, provider, secureRandom, iv);
+ this.aad = aad;
+ this.tag = Assert.notEmpty(tag, "Authentication tag cannot be null or empty.");
+ }
+
+ @Override
+ public byte[] getAssociatedData() {
+ return this.aad;
+ }
+
+ @Override
+ public byte[] getAuthenticationTag() {
+ return this.tag;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAesEncryptionRequest.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAesEncryptionRequest.java
new file mode 100644
index 000000000..f6927653a
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultAesEncryptionRequest.java
@@ -0,0 +1,26 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.AeadRequest;
+
+import javax.crypto.SecretKey;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+public class DefaultAesEncryptionRequest extends DefaultCryptoRequest implements AeadRequest {
+
+ private final byte[] aad;
+
+ public DefaultAesEncryptionRequest(T data, SecretKey key, Provider provider, SecureRandom secureRandom, byte[] aad) {
+ super(data, key, provider, secureRandom);
+ this.aad = aad;
+ }
+
+ public DefaultAesEncryptionRequest(T data, SecretKey key, byte[] aad) {
+ this(data, key, null, null, aad);
+ }
+
+ @Override
+ public byte[] getAssociatedData() {
+ return this.aad;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultCryptoMessage.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultCryptoMessage.java
new file mode 100644
index 000000000..0adfa0383
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultCryptoMessage.java
@@ -0,0 +1,24 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.CryptoMessage;
+
+import java.security.Key;
+import java.security.Provider;
+
+class DefaultCryptoMessage implements CryptoMessage {
+
+ private final T data;
+
+ DefaultCryptoMessage(T data) {
+ this.data = Assert.notNull(data, "data cannot be null.");
+ if (data instanceof byte[] && ((byte[]) data).length == 0) {
+ throw new IllegalArgumentException("data byte array cannot be empty.");
+ }
+ }
+
+ @Override
+ public T getData() {
+ return data;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultCryptoRequest.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultCryptoRequest.java
new file mode 100644
index 000000000..de0cbf763
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultCryptoRequest.java
@@ -0,0 +1,37 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.CryptoRequest;
+
+import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+public class DefaultCryptoRequest extends DefaultCryptoMessage implements CryptoRequest {
+
+ private final Provider provider;
+ private final SecureRandom secureRandom;
+ private final K key;
+
+ public DefaultCryptoRequest(T data, K key, Provider provider, SecureRandom secureRandom) {
+ super(data);
+ this.key = Assert.notNull(key, "key cannot be null.");
+ this.provider = provider;
+ this.secureRandom = secureRandom;
+ }
+
+ @Override
+ public K getKey() {
+ return this.key;
+ }
+
+ @Override
+ public Provider getProvider() {
+ return this.provider;
+ }
+
+ @Override
+ public SecureRandom getSecureRandom() {
+ return this.secureRandom;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEcJwkBuilderFactory.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEcJwkBuilderFactory.java
new file mode 100644
index 000000000..ca3c544e4
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEcJwkBuilderFactory.java
@@ -0,0 +1,18 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.EcJwkBuilderFactory;
+import io.jsonwebtoken.security.PrivateEcJwkBuilder;
+import io.jsonwebtoken.security.PublicEcJwkBuilder;
+
+final class DefaultEcJwkBuilderFactory implements EcJwkBuilderFactory {
+
+ @Override
+ public PublicEcJwkBuilder publicKey() {
+ return new DefaultPublicEcJwkBuilder();
+ }
+
+ @Override
+ public PrivateEcJwkBuilder privateKey() {
+ return new DefaultPrivateEcJwkBuilder();
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionAlgorithmLocator.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionAlgorithmLocator.java
new file mode 100644
index 000000000..9c8668c25
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionAlgorithmLocator.java
@@ -0,0 +1,40 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.JweHeader;
+import io.jsonwebtoken.MalformedJwtException;
+import io.jsonwebtoken.UnsupportedJwtException;
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.EncryptionAlgorithm;
+import io.jsonwebtoken.security.EncryptionAlgorithmLocator;
+import io.jsonwebtoken.security.EncryptionAlgorithms;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DefaultEncryptionAlgorithmLocator implements EncryptionAlgorithmLocator {
+
+ @Override
+ public EncryptionAlgorithm getEncryptionAlgorithm(JweHeader jweHeader) {
+
+ String enc = Strings.clean(jweHeader.getEncryptionAlgorithm());
+ //TODO: this check needs to be in the parser, to be enforced regardless of the locator implementation
+ if (enc == null) {
+ String msg = "JWE header does not contain an 'enc' header parameter. This header parameter is mandatory " +
+ "per the JWE Specification, Section 4.1.2. See " +
+ "https://tools.ietf.org/html/rfc7516#section-4.1.2 for more information.";
+ throw new MalformedJwtException(msg);
+ }
+
+ try {
+ return EncryptionAlgorithms.forName(enc); //TODO: change to findByName and let the parser throw on null return. See below:
+ } catch (IllegalArgumentException e) {
+ //TODO: move this check to the parser - needs to be enforced if the locator returns null or throws a non-JWT exception
+ //couldn't find one:
+ String msg = "JWE 'enc' header parameter value of '" + enc + "' does not match a JWE standard algorithm " +
+ "identifier. If '" + enc + "' represents a custom algorithm, the JwtParser must be configured with " +
+ "a custom EncryptionAlgorithmLocator instance that knows how to return a compatible " +
+ "EncryptionAlgorithm instance. Otherwise, this JWE is invalid and may not be used safely.";
+ throw new UnsupportedJwtException(msg, e);
+ }
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionRequest.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionRequest.java
new file mode 100644
index 000000000..c897fb259
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionRequest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.AeadRequest;
+import io.jsonwebtoken.security.AssociatedDataSource;
+import io.jsonwebtoken.security.InitializationVectorSource;
+
+import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DefaultEncryptionRequest extends DefaultCryptoRequest implements AeadRequest, InitializationVectorSource {
+
+ private final byte[] iv;
+
+ private final byte[] aad;
+
+ public DefaultEncryptionRequest(T data, K key, Provider provider, SecureRandom secureRandom, byte[] iv, byte[] aad) {
+ super(data, key, provider, secureRandom);
+ this.iv = iv;
+ this.aad = aad;
+ }
+
+ @Override
+ public byte[] getAssociatedData() {
+ return this.aad;
+ }
+
+ @Override
+ public byte[] getInitializationVector() {
+ return this.iv;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionResult.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionResult.java
new file mode 100644
index 000000000..8910b85a1
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultEncryptionResult.java
@@ -0,0 +1,18 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.EncryptionResult;
+
+class DefaultEncryptionResult implements EncryptionResult {
+
+ protected final byte[] ciphertext;
+
+ DefaultEncryptionResult(byte[] ciphertext) {
+ this.ciphertext = Assert.notEmpty(ciphertext, "ciphertext cannot be null or empty.");
+ }
+
+ @Override
+ public byte[] getCiphertext() {
+ return this.ciphertext;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultIvDecryptionRequest.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultIvDecryptionRequest.java
new file mode 100644
index 000000000..d230c7c49
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultIvDecryptionRequest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.InitializationVectorSource;
+
+import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DefaultIvDecryptionRequest extends DefaultCryptoRequest implements InitializationVectorSource {
+
+ private final byte[] iv;
+
+ public DefaultIvDecryptionRequest(T data, K key, Provider provider, SecureRandom secureRandom, byte[] iv) {
+ super(data, key, provider, secureRandom);
+ this.iv = Assert.notEmpty(iv, "Initialization Vector cannot be null or empty.");
+ }
+
+ @Override
+ public byte[] getInitializationVector() {
+ return this.iv;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultIvEncryptionResult.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultIvEncryptionResult.java
new file mode 100644
index 000000000..b8b190305
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultIvEncryptionResult.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 jsonwebtoken.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.IvEncryptionResult;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+class DefaultIvEncryptionResult extends DefaultEncryptionResult implements IvEncryptionResult {
+
+ protected final byte[] iv;
+
+ DefaultIvEncryptionResult(byte[] ciphertext, byte[] iv) {
+ super(ciphertext);
+ this.iv = Assert.notEmpty(iv, "initialization vector cannot be null or empty.");
+ }
+
+ @Override
+ public byte[] getInitializationVector() {
+ return this.iv;
+ }
+
+ @Override
+ public byte[] compact() {
+ byte[] output = new byte[iv.length + ciphertext.length];
+ System.arraycopy(iv, 0, output, 0, iv.length); // iv first
+ System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); // then ciphertext
+ return output;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJweFactory.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJweFactory.java
new file mode 100644
index 000000000..052ad7719
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJweFactory.java
@@ -0,0 +1,123 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.impl.lang.Services;
+import io.jsonwebtoken.io.Decoder;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.io.Deserializer;
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.EncryptionAlgorithm;
+import io.jsonwebtoken.security.EncryptionAlgorithms;
+
+import java.util.Map;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DefaultJweFactory {
+
+ private final Decoder base64UrlDecoder;
+
+ private final Deserializer> deserializer;
+
+ private final EncryptionAlgorithm encryptionAlgorithm;
+
+ private static Deserializer> loadDeserializer() {
+ Deserializer deserializer = Services.loadFirst(Deserializer.class);
+ //noinspection unchecked
+ return (Deserializer>) deserializer;
+ }
+
+ public DefaultJweFactory() {
+ this(Decoders.BASE64URL, loadDeserializer(), EncryptionAlgorithms.A256GCM);
+ }
+
+ public DefaultJweFactory(Decoder base64UrlDecoder,
+ Deserializer> deserializer,
+ EncryptionAlgorithm encryptionAlgorithm) {
+ this.base64UrlDecoder = Assert.notNull(base64UrlDecoder, "Base64Url TextCodec cannot be null.");
+ this.deserializer = Assert.notNull(deserializer, "Deserializer cannot be null.");
+ this.encryptionAlgorithm = Assert.notNull(encryptionAlgorithm, "EncryptionAlgorithm cannot be null.");
+ }
+
+ /*
+
+ public Jwe createJwe(String base64UrlProtectedHeader, String base64UrlEncryptedKey, String base64UrlIv,
+ String base64UrlCiphertext, String base64UrlAuthenticationTag) {
+
+ // ====================================================================
+ // https://tools.ietf.org/html/rfc7516#section-5.2 #2
+ // ====================================================================
+
+ final byte[] headerBytes = base64UrlDecode(base64UrlProtectedHeader, "Protected Header");
+
+ // encrypted key can be null with Direct Key or Direct Key Agreement
+ // https://tools.ietf.org/html/rfc7516#section-5.2
+ // so we use a 'null safe' variant:
+ final byte[] encryptedKeyBytes = nullSafeBase64UrlDecode(base64UrlEncryptedKey, "Encrypted Key");
+
+ final byte[] iv = base64UrlDecode(base64UrlIv, "Initialization Vector");
+
+ final byte[] ciphertext = base64UrlDecode(base64UrlCiphertext, "Ciphertext");
+
+ final byte[] authcTag = base64UrlDecode(base64UrlAuthenticationTag, "Authentication Tag");
+
+ // ====================================================================
+ // https://tools.ietf.org/html/rfc7516#section-5.2 #3
+ // ====================================================================
+
+ Map protectedHeader;
+ try {
+ protectedHeader = parseJson(headerBytes);
+ } catch (Exception e) {
+ String msg = "JWE Protected Header must be a valid JSON object.";
+ throw new IllegalArgumentException(msg, e);
+ }
+ Assert.notEmpty(protectedHeader, "JWE Protected Header cannot be a null or empty JSON object.");
+
+ DefaultJweHeader header = new DefaultJweHeader(protectedHeader);
+
+ // ====================================================================
+ // https://tools.ietf.org/html/rfc7516#section-5.2 #4
+ // ====================================================================
+
+ // we currently don't support JSON serialization (just compact), so we can skip #4
+
+ // ====================================================================
+ // https://tools.ietf.org/html/rfc7516#section-5.2 #11 and #12
+ // ====================================================================
+
+
+ throw new UnsupportedOperationException("Not yet finished.");
+
+ }
+
+ protected byte[] nullSafeBase64UrlDecode(String base64UrlEncoded, String jweName) {
+ if (base64UrlEncoded == null) {
+ return null;
+ }
+ return base64UrlDecode(base64UrlEncoded, jweName);
+ }
+
+ protected byte[] base64UrlDecode(String base64UrlEncoded, String jweName) {
+
+ if (base64UrlEncoded == null) {
+ String msg = "Invalid compact JWE: base64url JWE " + jweName + " is missing.";
+ throw new IllegalArgumentException(msg);
+ }
+
+ try {
+ return base64UrlDecoder.decode(base64UrlEncoded);
+ } catch (Exception e) {
+ String msg = "Invalid compact JWE: JWE " + jweName +
+ " fragment is invalid and cannot be Base64Url-decoded: " + base64UrlEncoded;
+ throw new IllegalArgumentException(msg, e);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ protected Map parseJson(byte[] json) {
+ return deserializer.deserialize(json);
+ }
+
+ */
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJwkBuilderFactory.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJwkBuilderFactory.java
new file mode 100644
index 000000000..2a55f6062
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJwkBuilderFactory.java
@@ -0,0 +1,18 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.EcJwkBuilderFactory;
+import io.jsonwebtoken.security.JwkBuilderFactory;
+import io.jsonwebtoken.security.SymmetricJwkBuilder;
+
+public final class DefaultJwkBuilderFactory implements JwkBuilderFactory {
+
+ @Override
+ public EcJwkBuilderFactory ellipticCurve() {
+ return new DefaultEcJwkBuilderFactory();
+ }
+
+ @Override
+ public SymmetricJwkBuilder symmetric() {
+ return new DefaultSymmetricJwkBuilder();
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJwkConverter.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJwkConverter.java
new file mode 100644
index 000000000..52e963ec6
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultJwkConverter.java
@@ -0,0 +1,58 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Collections;
+import io.jsonwebtoken.security.UnsupportedKeyException;
+
+import java.security.Key;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class DefaultJwkConverter extends AbstractJwkConverter {
+
+ private final Map converters = new HashMap<>();
+
+ public DefaultJwkConverter() {
+ this(Collections.of(
+ new SymmetricJwkConverter(),
+ new EcJwkConverter(),
+ new RsaJwkConverter()));
+ }
+
+ public DefaultJwkConverter(List converters) {
+ Assert.notEmpty(converters, "Converters cannot be null or empty.");
+ for(TypedJwkConverter converter : converters) {
+ this.converters.put(converter.getKeyType(), converter);
+ }
+ }
+
+ private JwkConverter getConverter(String kty) {
+ JwkConverter converter = converters.get(kty);
+ if (converter == null) {
+ String msg = "Unrecognized JWK kty (key type) value: " + kty;
+ throw new UnsupportedKeyException(msg);
+ }
+ return converter;
+ }
+
+ @Override
+ public Key toKey(Map jwk) {
+ String type = getRequiredString(jwk, "kty");
+ JwkConverter converter = getConverter(type);
+ return converter.toKey(jwk);
+ }
+
+ @Override
+ public Map toJwk(Key key) {
+ Assert.notNull(key, "Key argument cannot be null.");
+ for(TypedJwkConverter converter : converters.values()) {
+ if (converter.supports(key)) {
+ return converter.toJwk(key);
+ }
+ }
+
+ String msg = "Unable to determine JWK converter for key of type " + key.getClass();
+ throw new UnsupportedKeyException(msg);
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateEcJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateEcJwk.java
new file mode 100644
index 000000000..66650e8f4
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateEcJwk.java
@@ -0,0 +1,18 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.PrivateEcJwk;
+
+class DefaultPrivateEcJwk extends AbstractEcJwk implements PrivateEcJwk {
+
+ static final String D = "d";
+
+ @Override
+ public String getD() {
+ return getString(D);
+ }
+
+ @Override
+ public PrivateEcJwk setD(String d) {
+ return setRequiredValue(D, d, "private key");
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateEcJwkBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateEcJwkBuilder.java
new file mode 100644
index 000000000..33d3ad98f
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateEcJwkBuilder.java
@@ -0,0 +1,24 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.PrivateEcJwk;
+import io.jsonwebtoken.security.PrivateEcJwkBuilder;
+
+class DefaultPrivateEcJwkBuilder extends AbstractEcJwkBuilder implements PrivateEcJwkBuilder {
+
+ private static final JwkValidator VALIDATOR = new PrivateEcJwkValidator();
+
+ DefaultPrivateEcJwkBuilder() {
+ super(VALIDATOR);
+ }
+
+ @Override
+ PrivateEcJwk newJwk() {
+ return new DefaultPrivateEcJwk();
+ }
+
+ @Override
+ public PrivateEcJwkBuilder setD(String d) {
+ this.jwk.setD(d);
+ return this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateRsaJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateRsaJwk.java
new file mode 100644
index 000000000..f945f7c07
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPrivateRsaJwk.java
@@ -0,0 +1,87 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.JwkRsaPrimeInfo;
+import io.jsonwebtoken.security.PrivateRsaJwk;
+
+import java.util.List;
+
+public class DefaultPrivateRsaJwk extends AbstractRsaJwk implements PrivateRsaJwk {
+
+ static String PRIVATE_EXPONENT = "d";
+ static String FIRST_PRIME = "p";
+ static String SECOND_PRIME = "q";
+ static String FIRST_CRT_EXPONENT = "dp";
+ static String SECOND_CRT_EXPONENT = "dq";
+ static String FIRST_CRT_COEFFICIENT = "qi";
+ static String OTHER_PRIMES_INFO = "oth";
+
+ @Override
+ public String getD() {
+ return getString(PRIVATE_EXPONENT);
+ }
+
+ @Override
+ public PrivateRsaJwk setD(String d) {
+ return setRequiredValue(PRIVATE_EXPONENT, d, "private exponent");
+ }
+
+ @Override
+ public String getP() {
+ return getString(FIRST_PRIME);
+ }
+
+ @Override
+ public PrivateRsaJwk setP(String p) {
+ return setRequiredValue(FIRST_PRIME, p, "first prime factor");
+ }
+
+ @Override
+ public String getQ() {
+ return getString(SECOND_PRIME);
+ }
+
+ @Override
+ public PrivateRsaJwk setQ(String q) {
+ return setRequiredValue(FIRST_PRIME, q, "second prime factor");
+ }
+
+ @Override
+ public String getDP() {
+ return getString(FIRST_CRT_EXPONENT);
+ }
+
+ @Override
+ public PrivateRsaJwk setDP(String dp) {
+ return setRequiredValue(FIRST_CRT_EXPONENT, dp, "first crt exponent");
+ }
+
+ @Override
+ public String getDQ() {
+ return getString(SECOND_CRT_EXPONENT);
+ }
+
+ @Override
+ public PrivateRsaJwk setDQ(String dq) {
+ return setRequiredValue(SECOND_CRT_EXPONENT, dq, "second crt exponent");
+ }
+
+ @Override
+ public String getQI() {
+ return getString(FIRST_CRT_COEFFICIENT);
+ }
+
+ @Override
+ public PrivateRsaJwk setQI(String qi) {
+ return setRequiredValue(FIRST_CRT_COEFFICIENT, qi, "first crt coefficient");
+ }
+
+ @Override
+ public List getOtherPrimesInfo() {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ @Override
+ public PrivateRsaJwk setOtherPrimesInfo(List infos) {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPublicEcJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPublicEcJwk.java
new file mode 100644
index 000000000..bdc6c1854
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPublicEcJwk.java
@@ -0,0 +1,6 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.PublicEcJwk;
+
+class DefaultPublicEcJwk extends AbstractEcJwk implements PublicEcJwk {
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPublicEcJwkBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPublicEcJwkBuilder.java
new file mode 100644
index 000000000..99ec5bdbc
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultPublicEcJwkBuilder.java
@@ -0,0 +1,23 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.PublicEcJwk;
+import io.jsonwebtoken.security.PublicEcJwkBuilder;
+
+class DefaultPublicEcJwkBuilder extends AbstractEcJwkBuilder implements PublicEcJwkBuilder {
+
+ private static final JwkValidator VALIDATOR = new AbstractEcJwkValidator() {
+ @Override
+ protected void validateEcJwk(PublicEcJwk jwk) {
+ //nothing additional to do
+ }
+ };
+
+ DefaultPublicEcJwkBuilder() {
+ super(VALIDATOR);
+ }
+
+ @Override
+ PublicEcJwk newJwk() {
+ return new DefaultPublicEcJwk();
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultSymmetricJwk.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultSymmetricJwk.java
new file mode 100644
index 000000000..cd4d6d598
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultSymmetricJwk.java
@@ -0,0 +1,28 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.lang.Strings;
+import io.jsonwebtoken.security.SymmetricJwk;
+
+final class DefaultSymmetricJwk extends AbstractJwk implements SymmetricJwk {
+
+ static final String TYPE_VALUE = "oct";
+ static final String K = "k";
+
+ DefaultSymmetricJwk() {
+ super(TYPE_VALUE);
+ }
+
+ @Override
+ public String getK() {
+ return getString(K);
+ }
+
+ @Override
+ public SymmetricJwk setK(String k) {
+ k = Strings.clean(k);
+ Assert.notNull(k, "SymmetricJwk 'k' property cannot be null or empty.");
+ setValue(K, k);
+ return this;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultSymmetricJwkBuilder.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultSymmetricJwkBuilder.java
new file mode 100644
index 000000000..eed168c92
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultSymmetricJwkBuilder.java
@@ -0,0 +1,24 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.security.SymmetricJwk;
+import io.jsonwebtoken.security.SymmetricJwkBuilder;
+
+final class DefaultSymmetricJwkBuilder extends AbstractJwkBuilder implements SymmetricJwkBuilder {
+
+ private static final JwkValidator VALIDATOR = new SymmetricJwkValidator();
+
+ DefaultSymmetricJwkBuilder() {
+ super(VALIDATOR);
+ }
+
+ @Override
+ public SymmetricJwkBuilder setK(String k) {
+ this.jwk.setK(k);
+ return this;
+ }
+
+ @Override
+ SymmetricJwk newJwk() {
+ return new DefaultSymmetricJwk();
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultVerifySignatureRequest.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultVerifySignatureRequest.java
new file mode 100644
index 000000000..5ede1eef9
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DefaultVerifySignatureRequest.java
@@ -0,0 +1,23 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.VerifySignatureRequest;
+
+import java.security.Key;
+import java.security.Provider;
+import java.security.SecureRandom;
+
+public class DefaultVerifySignatureRequest extends DefaultCryptoRequest implements VerifySignatureRequest {
+
+ private final byte[] signature;
+
+ public DefaultVerifySignatureRequest(byte[] data, Key key, Provider provider, SecureRandom secureRandom, byte[] signature) {
+ super(data, key, provider, secureRandom);
+ this.signature = Assert.notEmpty(signature, "Signature byte array cannot be null or empty.");
+ }
+
+ @Override
+ public byte[] getSignature() {
+ return this.signature;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DirectEncryptionMode.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DirectEncryptionMode.java
new file mode 100644
index 000000000..70c5c75f1
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DirectEncryptionMode.java
@@ -0,0 +1,22 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.lang.Assert;
+
+import javax.crypto.SecretKey;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DirectEncryptionMode implements KeyManagementMode {
+
+ private final SecretKey key;
+
+ DirectEncryptionMode(SecretKey key) {
+ this.key = Assert.notNull(key, "SecretKey argument cannot be null.");
+ }
+
+ @Override
+ public SecretKey getKey(GetKeyRequest ignored) {
+ return this.key;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DirectKeyAgreementMode.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DirectKeyAgreementMode.java
new file mode 100644
index 000000000..e6e40363d
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DirectKeyAgreementMode.java
@@ -0,0 +1,14 @@
+package io.jsonwebtoken.impl.security;
+
+import javax.crypto.SecretKey;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DirectKeyAgreementMode implements KeyManagementMode {
+
+ @Override
+ public SecretKey getKey(GetKeyRequest request) {
+ throw new UnsupportedOperationException("Not Yet Implemented");
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/DisabledDecryptionKeyResolver.java b/impl/src/main/java/io/jsonwebtoken/impl/security/DisabledDecryptionKeyResolver.java
new file mode 100644
index 000000000..e7f4962a3
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/DisabledDecryptionKeyResolver.java
@@ -0,0 +1,22 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.JweHeader;
+import io.jsonwebtoken.security.DecryptionKeyResolver;
+
+import java.security.Key;
+
+/**
+ * @since JJWT_RELEASE_VERSION
+ */
+public class DisabledDecryptionKeyResolver implements DecryptionKeyResolver {
+
+ /**
+ * Singleton instance that may be used if direct instantiation is not desired.
+ */
+ public static final DisabledDecryptionKeyResolver INSTANCE = new DisabledDecryptionKeyResolver();
+
+ @Override
+ public Key resolveDecryptionKey(JweHeader header) {
+ return null;
+ }
+}
diff --git a/impl/src/main/java/io/jsonwebtoken/impl/security/EcJwkConverter.java b/impl/src/main/java/io/jsonwebtoken/impl/security/EcJwkConverter.java
new file mode 100644
index 000000000..529da692b
--- /dev/null
+++ b/impl/src/main/java/io/jsonwebtoken/impl/security/EcJwkConverter.java
@@ -0,0 +1,177 @@
+package io.jsonwebtoken.impl.security;
+
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.io.Encoders;
+import io.jsonwebtoken.lang.Assert;
+import io.jsonwebtoken.security.Jwks;
+import io.jsonwebtoken.security.KeyException;
+import io.jsonwebtoken.security.PublicEcJwkBuilder;
+import io.jsonwebtoken.security.UnsupportedKeyException;
+
+import java.math.BigInteger;
+import java.security.AlgorithmParameters;
+import java.security.Key;
+import java.security.KeyFactory;
+import java.security.interfaces.ECPrivateKey;
+import java.security.interfaces.ECPublicKey;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.ECParameterSpec;
+import java.security.spec.ECPoint;
+import java.security.spec.ECPrivateKeySpec;
+import java.security.spec.ECPublicKeySpec;
+import java.util.HashMap;
+import java.util.Map;
+
+public class EcJwkConverter extends AbstractTypedJwkConverter {
+
+ private static final Map EC_CURVE_NAMES_BY_JWA_ID = createEcCurveNameMap();
+
+ private static Map createEcCurveNameMap() {
+ Map m = new HashMap<>();
+ m.put("P-256", "secp256r1");
+ m.put("P-384", "secp384r1");
+ m.put("P-521", "secp521r1");
+ return m;
+ }
+
+ private static ECParameterSpec getStandardNameSpec(String stdName) throws KeyException {
+ try {
+ AlgorithmParameters parameters = AlgorithmParameters.getInstance("EC");
+ parameters.init(new ECGenParameterSpec(stdName));
+ return parameters.getParameterSpec(ECParameterSpec.class);
+ } catch (Exception e) {
+ String msg = "Unable to obtain JVM ECParameterSpec for JWA curve ID '" + stdName + "'.";
+ throw new KeyException(msg, e);
+ }
+ }
+
+ private static ECParameterSpec getCurveIdSpec(String curveId) {
+ String stdName = EC_CURVE_NAMES_BY_JWA_ID.get(curveId);
+ if (stdName == null) {
+ String msg = "Unrecognized JWA curve id '" + curveId + "'";
+ throw new UnsupportedKeyException(msg);
+ }
+ return getStandardNameSpec(stdName);
+ }
+
+ /**
+ * https://tools.ietf.org/html/rfc7518#section-6.2.1.2 indicates that this algorithm logic is defined in
+ * http://www.secg.org/sec1-v2.pdf Section 2.3.5.
+ * @param fieldSize EC field size
+ * @param coordinate EC point coordinate (e.g. x or y)
+ * @return A base64Url-encoded String representing the EC field per the RFC format
+ */
+ // Algorithm defined in http://www.secg.org/sec1-v2.pdf Section 2.3.5
+ static String encodeCoordinate(int fieldSize, BigInteger coordinate) {
+ byte[] bytes = toUnsignedBytes(coordinate);
+ int mlen = (int)Math.ceil(fieldSize / 8d);
+ if (mlen > bytes.length) {
+ byte[] m = new byte[mlen];
+ System.arraycopy(bytes, 0, m, mlen - bytes.length, bytes.length);
+ bytes = m;
+ }
+ return Encoders.BASE64URL.encode(bytes);
+ }
+
+ EcJwkConverter() {
+ super("EC");
+ }
+
+ @Override
+ public boolean supports(Key key) {
+ return key instanceof ECPrivateKey || key instanceof ECPublicKey;
+ }
+
+ @Override
+ public Key toKey(Map jwk) {
+ Assert.notNull(jwk, "JWK map argument cannot be null.");
+ if (jwk.containsKey("d")) {
+ return toPrivateKey(jwk);
+ }
+ return toPublicKey(jwk);
+ }
+
+ @Override
+ public Map toJwk(Key key) {
+ if (key instanceof ECPrivateKey) {
+ return toPrivateJwk((ECPrivateKey)key);
+ }
+ Assert.isInstanceOf(ECPublicKey.class, key, "Key argument must be an ECPublicKey or ECPrivateKey instance.");
+ return toPublicJwk((ECPublicKey)key);
+ }
+
+ private ECPublicKey toPublicKey(Map jwk) {
+ String curveId = getRequiredString(jwk, "crv");
+ BigInteger x = getRequiredBigInt(jwk, "x");
+ BigInteger y = getRequiredBigInt(jwk, "y");
+
+ ECParameterSpec spec = getCurveIdSpec(curveId);
+ ECPoint point = new ECPoint(x, y);
+ ECPublicKeySpec pubSpec = new ECPublicKeySpec(point, spec);
+
+ try {
+ KeyFactory kf = getKeyFactory();
+ return (ECPublicKey)kf.generatePublic(pubSpec);
+ } catch (Exception e) {
+ String msg = "Unable to obtain ECPublicKey for curve '" + curveId + "'.";
+ throw new KeyException(msg, e);
+ }
+ }
+
+ public ECPrivateKey toPrivateKey(Map jwk) {
+ String curveId = getRequiredString(jwk, "crv");
+ BigInteger d = getRequiredBigInt(jwk, "d");
+
+ // We don't actually need these two values for JVM lookup, but the
+ // [JWA spec](https://tools.ietf.org/html/rfc7518#section-6.2.2)
+ // requires them to be present and valid for the private key as well, so we assert that here:
+ getRequiredBigInt(jwk, "x");
+ getRequiredBigInt(jwk, "y");
+
+ ECParameterSpec spec = getCurveIdSpec(curveId);
+ ECPrivateKeySpec privateSpec = new ECPrivateKeySpec(d, spec);
+
+ try {
+ KeyFactory kf = getKeyFactory();
+ return (ECPrivateKey)kf.generatePrivate(privateSpec);
+ } catch (Exception e) {
+ String msg = "Unable to obtain ECPrivateKey from specified jwk for curve '" + curveId + "'.";
+ throw new KeyException(msg, e);
+ }
+ }
+
+ public Map toPublicJwk(ECPublicKey key) {
+
+ PublicEcJwkBuilder builder = Jwks.builder().ellipticCurve().publicKey();
+
+ Map