com.google.api.client.googleapis.auth.oauth2.GooglePublicKeysManager Java Examples

static FirebaseTokenVerifierImpl createIdTokenVerifier(FirebaseApp app, Clock clock) {
  String projectId = ImplFirebaseTrampolines.getProjectId(app);
  checkState(!Strings.isNullOrEmpty(projectId),
      "Must initialize FirebaseApp with a project ID to call verifyIdToken()");
  IdTokenVerifier idTokenVerifier = newIdTokenVerifier(
      clock, ID_TOKEN_ISSUER_PREFIX, projectId);
  GooglePublicKeysManager publicKeysManager = newPublicKeysManager(
      app.getOptions(), clock, ID_TOKEN_CERT_URL);
  return FirebaseTokenVerifierImpl.builder()
      .setShortName("ID token")
      .setMethod("verifyIdToken()")
      .setDocUrl("https://firebase.google.com/docs/auth/admin/verify-id-tokens")
      .setJsonFactory(app.getOptions().getJsonFactory())
      .setPublicKeysManager(publicKeysManager)
      .setIdTokenVerifier(idTokenVerifier)
      .build();
}
 

static FirebaseTokenVerifierImpl createSessionCookieVerifier(FirebaseApp app, Clock clock) {
  String projectId = ImplFirebaseTrampolines.getProjectId(app);
  checkState(!Strings.isNullOrEmpty(projectId),
      "Must initialize FirebaseApp with a project ID to call verifySessionCookie()");
  IdTokenVerifier idTokenVerifier = newIdTokenVerifier(
      clock, SESSION_COOKIE_ISSUER_PREFIX, projectId);
  GooglePublicKeysManager publicKeysManager = newPublicKeysManager(
      app.getOptions(), clock, SESSION_COOKIE_CERT_URL);
  return FirebaseTokenVerifierImpl.builder()
      .setJsonFactory(app.getOptions().getJsonFactory())
      .setPublicKeysManager(publicKeysManager)
      .setIdTokenVerifier(idTokenVerifier)
      .setShortName("session cookie")
      .setMethod("verifySessionCookie()")
      .setDocUrl("https://firebase.google.com/docs/auth/admin/manage-cookies")
      .build();
}
 

@Test
public void verifyTokenCertificateError() {
  MockHttpTransport failingTransport = new MockHttpTransport() {
    @Override
    public LowLevelHttpRequest buildRequest(String method, String url) throws IOException {
      throw new IOException("Expected error");
    }
  };
  GooglePublicKeysManager publicKeysManager = newPublicKeysManager(failingTransport);
  FirebaseTokenVerifier idTokenVerifier = newTestTokenVerifier(publicKeysManager);
  String token = tokenFactory.createToken();

  try {
    idTokenVerifier.verifyToken(token);
    Assert.fail("No exception thrown");
  } catch (FirebaseAuthException expected) {
    assertTrue(expected.getCause() instanceof IOException);
    assertEquals("Expected error", expected.getCause().getMessage());
  }
}
 

private static GooglePublicKeysManager newPublicKeysManager(
    FirebaseOptions options, Clock clock, String certUrl) {
  return new GooglePublicKeysManager.Builder(
      options.getHttpTransport(), UNQUOTED_CTRL_CHAR_JSON_FACTORY)
      .setClock(clock)
      .setPublicCertsEncodedUrl(certUrl)
      .build();
}
 

@Before
public void setUp() throws Exception {
  ServiceAccount serviceAccount = ServiceAccount.EDITOR;
  GooglePublicKeysManager publicKeysManager = newPublicKeysManager(serviceAccount.getCert());
  this.tokenVerifier = newTestTokenVerifier(publicKeysManager);
  this.tokenFactory = new TestTokenFactory(serviceAccount.getPrivateKey(), TEST_TOKEN_ISSUER);
}
 

@Test
public void testVerifyTokenIncorrectCert() throws Exception {
  String token = tokenFactory.createToken();
  GooglePublicKeysManager publicKeysManager = newPublicKeysManager(
      ServiceAccount.NONE.getCert());
  FirebaseTokenVerifier tokenVerifier = newTestTokenVerifier(publicKeysManager);

  thrown.expectMessage("Failed to verify the signature of Firebase test token. "
      + "See https://test.doc.url for details on how to retrieve a test token.");
  tokenVerifier.verifyToken(token);
}
 

private GooglePublicKeysManager newPublicKeysManager(String certificate) {
  String serviceAccountCertificates =
      String.format("{\"%s\" : \"%s\"}", TestTokenFactory.PRIVATE_KEY_ID, certificate);
  HttpTransport transport = new MockHttpTransport.Builder()
      .setLowLevelHttpResponse(
          new MockLowLevelHttpResponse().setContent(serviceAccountCertificates))
      .build();
  return newPublicKeysManager(transport);
}
 

private GooglePublicKeysManager newPublicKeysManager(HttpTransport transport) {
  return new GooglePublicKeysManager.Builder(
      transport, FirebaseTokenUtils.UNQUOTED_CTRL_CHAR_JSON_FACTORY)
      .setClock(TestTokenFactory.CLOCK)
      .setPublicCertsEncodedUrl("https://test.cert.url")
      .build();
}
 

private FirebaseTokenVerifier newTestTokenVerifier(GooglePublicKeysManager publicKeysManager) {
  return FirebaseTokenVerifierImpl.builder()
      .setShortName("test token")
      .setMethod("verifyTestToken()")
      .setDocUrl("https://test.doc.url")
      .setJsonFactory(TestTokenFactory.JSON_FACTORY)
      .setPublicKeysManager(publicKeysManager)
      .setIdTokenVerifier(newIdTokenVerifier())
      .build();
}
 

@Before
public void setUp() throws Exception {
  final var keyGen = KeyPairGenerator.getInstance("RSA");
  keyGen.initialize(571);
  KeyPair pair = keyGen.generateKeyPair();
  privateKey = pair.getPrivate();

  final var keysManager = new GooglePublicKeysManager(Utils.getDefaultTransport(), Utils.getDefaultJsonFactory());
  stubPublicKey(keysManager, pair.getPublic());

  verifier = new GoogleIdTokenVerifier(keysManager);
}
 

public EndpointsPeerAuthenticator() {
  Client client = Client.getInstance();
  GooglePublicKeysManager keyManager = new GooglePublicKeysManager.Builder(
      client.getHttpTransport(), client.getJsonFactory()).setPublicCertsEncodedUrl(
      PUBLIC_CERT_URL).build();
  GoogleIdTokenVerifier verifier =
      new GoogleIdTokenVerifier.Builder(keyManager).setIssuer(ISSUER).build();
  jwtAuthenticator = new GoogleJwtAuthenticator(verifier);
}
 

GooglePublicKeysManager getPublicKeysManager() {
  return publicKeysManager;
}
 

Builder setPublicKeysManager(GooglePublicKeysManager publicKeysManager) {
  this.publicKeysManager = publicKeysManager;
  return this;
}
 

private void verifyPublicKeysManager(GooglePublicKeysManager publicKeysManager, String certUrl) {
  assertNotNull(publicKeysManager);
  assertEquals(certUrl, publicKeysManager.getPublicCertsEncodedUrl());
  assertSame(CLOCK, publicKeysManager.getClock());
  assertTrue(publicKeysManager.getJsonFactory() instanceof GsonFactory);
}
 

private void stubPublicKey(GooglePublicKeysManager keysManager, PublicKey publicKey)
    throws NoSuchFieldException, IllegalAccessException {
  // Reflection is used because final methods make it impossible to mock
  setField(keysManager, "publicKeys", List.of(publicKey));
  setField(keysManager, "expirationTimeMilliseconds", Long.MAX_VALUE);
}
 

private void setField(GooglePublicKeysManager keysManager, String name, Object value)
    throws NoSuchFieldException, IllegalAccessException {
  final var field = GooglePublicKeysManager.class.getDeclaredField(name);
  field.setAccessible(true);
  field.set(keysManager, value);
}