<jjwt.suite.version>0.12.3</jjwt.suite.version>

<version>3.2.2</version>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>com.fasterxml.jackson</groupId>

<artifactId>jackson-bom</artifactId>

<version>2.15.3</version>

<scope>import</scope>

<type>pom</type>

</dependency>

</dependencies>

</dependencyManagement>

<id>test-jwt-slow-multireleasejar-flaky</id>

<execution>

<!-- Verify that JWT suite 0.11.x still works -->

<id>jwt0.11.x-test</id>

<phase>integration-test</phase>

<goals>

<goal>test</goal>

</goals>

<configuration>

<classesDirectory>${project.basedir}/target/github-api-${project.version}.jar</classesDirectory>

<useSystemClassLoader>false</useSystemClassLoader>

<excludesFile>src/test/resources/slow-or-flaky-tests.txt</excludesFile>

<argLine>@{jacoco.surefire.argLine} ${surefire.argLine} -Dtest.github.connector=okhttp</argLine>

<classpathDependencyExcludes>

<classpathDependencyExclude>io.jsonwebtoken:*</classpathDependencyExclude>

</classpathDependencyExcludes>

<additionalClasspathDependencies>

<additionalClasspathDependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt-api</artifactId>

<version>0.11.5</version>

</additionalClasspathDependency>

<additionalClasspathDependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt-impl</artifactId>

<version>0.11.5</version>

</additionalClasspathDependency>

<additionalClasspathDependency>

<groupId>io.jsonwebtoken</groupId>

<artifactId>jjwt-jackson</artifactId>

<version>0.11.5</version>

</additionalClasspathDependency>

</additionalClasspathDependencies>

</configuration>

</execution>

return JwtBuilderUtil.buildJwt(issuedAt, expiration, applicationId, privateKey);

package org.kohsuke.github.extras.authorization;

import io.jsonwebtoken.JwtBuilder;

import io.jsonwebtoken.Jwts;

import io.jsonwebtoken.io.Serializer;

import io.jsonwebtoken.jackson.io.JacksonSerializer;

import io.jsonwebtoken.security.SignatureAlgorithm;

import org.kohsuke.github.GHException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.security.Key;

import java.security.PrivateKey;

import java.time.Instant;

import java.util.Date;

import java.util.logging.Logger;

final class JwtBuilderUtil {

private static final Logger LOGGER = Logger.getLogger(JwtBuilderUtil.class.getName());

private static IJwtBuilder builder;

/**

static String buildJwt(Instant issuedAt, Instant expiration, String applicationId, PrivateKey privateKey) {

if (builder == null) {

createBuilderImpl(issuedAt, expiration, applicationId, privateKey);

}

return builder.buildJwt(issuedAt, expiration, applicationId, privateKey);

}

private static void createBuilderImpl(Instant issuedAt,

Instant expiration,

String applicationId,

PrivateKey privateKey) {

// Figure out which builder to use and cache it. We don't worry about thread safety here because we're fine if

// the builder is assigned multiple times. The end result will be the same.

try {

builder = new DefaultBuilderImpl();

} catch (NoSuchMethodError | NoClassDefFoundError e) {

LOGGER.warning(

"You are using an outdated version of the io.jsonwebtoken:jjwt-* suite. v0.12.x or later is recommended.");

try {

ReflectionBuilderImpl reflectionBuider = new ReflectionBuilderImpl();

// Build a JWT to eagerly check for any reflection errors.

reflectionBuider.buildJwtWithReflection(issuedAt, expiration, applicationId, privateKey);

builder = reflectionBuider;

} catch (ReflectiveOperationException re) {

throw new GHException(

"Could not build JWT using reflection on io.jsonwebtoken:jjwt-* suite."

+ "The minimum supported version is v0.11.x, v0.12.x or later is recommended.",

re);

}

}

}

/**

interface IJwtBuilder {

/**

String buildJwt(Instant issuedAt, Instant expiration, String applicationId, PrivateKey privateKey);

}

/**

private static class DefaultBuilderImpl implements IJwtBuilder {

/**

public String buildJwt(Instant issuedAt, Instant expiration, String applicationId, PrivateKey privateKey) {

// io.jsonwebtoken.security.SignatureAlgorithm is not present in v0.11.x and below.

// Trying to call a method that uses it causes "NoClassDefFoundError" if v0.11.x is being used.

SignatureAlgorithm rs256 = Jwts.SIG.RS256;

JwtBuilder jwtBuilder = Jwts.builder();

jwtBuilder = jwtBuilder.issuedAt(Date.from(issuedAt))

.expiration(Date.from(expiration))

.issuer(applicationId)

.signWith(privateKey, rs256)

.json(new JacksonSerializer<>());

return jwtBuilder.compact();

}

}

/**

private static class ReflectionBuilderImpl implements IJwtBuilder {

private Method setIssuedAtMethod;

private Method setExpirationMethod;

private Method setIssuerMethod;

private Enum<?> rs256SignatureAlgorithm;

private Method signWithMethod;

private Method serializeToJsonMethod;

ReflectionBuilderImpl() throws ReflectiveOperationException {

JwtBuilder jwtBuilder = Jwts.builder();

Class<?> jwtReflectionClass = jwtBuilder.getClass();

setIssuedAtMethod = jwtReflectionClass.getMethod("setIssuedAt", Date.class);

setIssuerMethod = jwtReflectionClass.getMethod("setIssuer", String.class);

setExpirationMethod = jwtReflectionClass.getMethod("setExpiration", Date.class);

Class<?> signatureAlgorithmClass = Class.forName("io.jsonwebtoken.SignatureAlgorithm");

rs256SignatureAlgorithm = createEnumInstance(signatureAlgorithmClass, "RS256");

signWithMethod = jwtReflectionClass.getMethod("signWith", Key.class, signatureAlgorithmClass);

serializeToJsonMethod = jwtReflectionClass.getMethod("serializeToJsonWith", Serializer.class);

}

/**

public String buildJwt(Instant issuedAt, Instant expiration, String applicationId, PrivateKey privateKey) {

try {

return buildJwtWithReflection(issuedAt, expiration, applicationId, privateKey);

} catch (ReflectiveOperationException e) {

// This should never happen. Reflection errors should have been caught during initialization.

throw new GHException("Reflection errors during JWT creation should have been checked already.", e);

}

}

private String buildJwtWithReflection(Instant issuedAt,

Instant expiration,

String applicationId,

PrivateKey privateKey) throws IllegalAccessException, InvocationTargetException {

JwtBuilder jwtBuilder = Jwts.builder();

Object builderObj = jwtBuilder;

builderObj = setIssuedAtMethod.invoke(builderObj, Date.from(issuedAt));

builderObj = setExpirationMethod.invoke(builderObj, Date.from(expiration));

builderObj = setIssuerMethod.invoke(builderObj, applicationId);

builderObj = signWithMethod.invoke(builderObj, privateKey, rs256SignatureAlgorithm);

builderObj = serializeToJsonMethod.invoke(builderObj, new JacksonSerializer<>());

return ((JwtBuilder) builderObj).compact();

}

@SuppressWarnings("unchecked")

private static <T extends Enum<T>> T createEnumInstance(Class<?> type, String name) {

return Enum.valueOf((Class<T>) type, name);

}

}

}

**/GHPullRequestTest