ScribeJava est une bibliothèque client OAuth légère, thread-safe et modulaire. Elle est conçue pour les développeurs qui exigent un contrôle total, une sécurité maximale et zéro dépendance inutile.

1. Pourquoi ScribeJava
2. Architecture Modulaire
3. Démarrage Rapide
4. Integration OIDC Enterprise
5. Installation
6. Compatibilite et Android
7. Documentation & Exemples

ScribeJava est le choix idéal pour les projets qui refusent l'opacité des frameworks "tout-en-un".

ScribeJava est conçu comme un écosystème de composants indépendants :

graph TD
    subgraph Core
        C[scribejava-core]
    end
    subgraph Extensions
        C --> O[scribejava-oidc]
        C --> A[scribejava-apis]
        C --> I[scribejava-integration-helpers]
    end
    subgraph Transport
        C --> H1[scribejava-httpclient-okhttp]
        C --> H2[scribejava-httpclient-armeria]
    end

ScribeJava repose sur trois piliers fondamentaux :

1. L'API (DefaultApi20, DefaultApi10a) : Définit les points de terminaison (URLs) et les verbes HTTP du fournisseur (ex: GitHub, Google).

2. Le Service (OAuth20Service) : Gère la logique d'exécution des requêtes, la signature et l'échange de jetons.

3. Le Grant (OAuth20Grant) : Définit la stratégie d'obtention du jeton (Code, Mot de passe, Device Flow, Client Credentials).

Utilisé pour les applications web et mobiles. PKCE (RFC 7636) est fortement recommandé pour sécuriser l'échange de code.

Fonctionnement du PKCE :

• Génération : ScribeJava crée un code_verifier (secret cryptographique) et calcule son code_challenge (SHA-256).

• Autorisation : Le challenge est envoyé au serveur dans l'URL initiale.

• Échange : Le verifier secret est envoyé lors de la demande de jeton pour prouver l'identité du client.

// Configuration
OAuth20Service service = new ServiceBuilder(clientId)
    .apiSecret(clientSecret)
    .callback("https://mon-app.com/callback")
    .build(GitHubApi.instance());

// Génération de l'URL d'autorisation
PKCE pkce = PKCEService.defaultInstance().generatePKCE();
String authUrl = service.createAuthorizationUrlBuilder()
    .pkce(pkce)
    .build();

// Échange du code contre un jeton
AuthorizationCodeGrant grant = new AuthorizationCodeGrant(code);
grant.setPkceCodeVerifier(pkce.getCodeVerifier());
OAuth2AccessToken token = service.getAccessToken(grant);

Utilisez notre coordinateur spécialisé ou l'API native pour une autonomie totale (Zero-Dependency).

Vous n'avez plus besoin de configurer les URLs d'API manuellement. Fournissez uniquement l'URL de l'émetteur (Issuer) :

// Configure tout automatiquement à partir de /.well-known/openid-configuration
OidcServiceBuilder builder = new OidcServiceBuilder(clientId)
    .apiSecret(clientSecret)
    .baseOnDiscovery("https://accounts.google.com", httpClient, userAgent);

OAuth20Service service = builder.build(new DefaultOidcApi20());
String authUrl = service.getAuthorizationUrl(); // L'URL est découverte dynamiquement !

// 1. Découverte dynamique des endpoints et des clés (Natif)
OidcDiscoveryService discovery = new OidcDiscoveryService(issuer, httpClient, userAgent);
OidcProviderMetadata metadata = discovery.getProviderMetadata();
Map<String, OidcKey> keys = discovery.getJwks(metadata.getJwksUri());

// 2. Initialisation du Validateur (Natif ScribeJava)
IdTokenValidator validator = new IdTokenValidator(metadata.getIssuer(), clientId, "RS256", keys);

// 3. Orchestration via Coordinateur (Helpers)
OidcAuthFlowCoordinator<String> coordinator = new OidcAuthFlowCoordinator<>(oidcService, repository);
OidcAuthResult result = coordinator.finishAuthorization(userId, code, state, sessionContext);

Pour les applications réelles, ScribeJava propose le module scribejava-integration-helpers qui orchestre tout le cycle de vie.

Le développeur ne gère plus les refresh_token. ScribeJava le fait silencieusement.

AuthorizedClientService<String> client = new AuthorizedClientService<>(service, renewer);

// Exécute la requête : rafraîchit le jeton automatiquement s'il est expiré (Thread-safe)
Response resp = client.execute(userId, new OAuthRequest(Verb.GET, "https://api.example.com/me"));

Branchez vos logs (ELK/Grafana) pour surveiller la santé de vos connexions.

service.setListener(new AuthEventListener<String>() {
    @Override
    public void onCsrfDetected(String key, String got, String expected) {
        logger.error("ALERTE SÉCURITÉ : Tentative CSRF sur l'utilisateur " + key);
    }
    // ... onTokenRefreshed, onRefreshFailed
});

ScribeJava est distribué via GitHub Releases.

💡 Note actuelle : v9.2.3

Installez le JAR téléchargé localement ou utilisez votre dépôt privé :

<dependency>
    <groupId>com.github.scribejava</groupId>
    <artifactId>scribejava-core</artifactId>
    <version>9.2.3</version>
</dependency>
<dependency>
    <groupId>com.github.scribejava</groupId>
    <artifactId>scribejava-oidc</artifactId>
    <version>9.2.3</version>
</dependency>
<!-- Hautement recommandé : Pour l'automatisation et l'OIDC Enterprise -->
<dependency>
    <groupId>com.github.scribejava</groupId>
    <artifactId>scribejava-integration-helpers</artifactId>
    <version>9.2.3</version>
</dependency>

• Java : Compatible de Java 8 à Java 25.
• Android : Support complet (API 21+).

• 🚀 Démarrage Rapide (Quick Start) - Exemples complets pour CLI (OAuth2, OIDC, M2M).

• ⚡ Guide de Migration - Passer de la v8 à la v9.

• ⚙️ Guide ScribeJava Core - Moteur OAuth, requêtes, résilience et diagnostic.

• 🛡️ Sécurité Avancée (DPoP/PAR) - RFC 9449 et 9126.

• 🔐 Guide des Fonctionnalités OIDC - Discovery, JWT natif et Logout.

• 📖 Guide d'Intégration Helpers - Orchestration, Auto-refresh et multi-tenant.

• 📖 Catalogue des Fonctionnalités - Liste exhaustive par module.

• 🛠️ Documentation CI/CD - Architecture du pipeline qualité.

• 🚑 Guide de Dépannage - Solutions aux erreurs courantes.

• 📖 Modules : Core | OIDC | Integration Helpers

• 🎯 Exemples :

  • OpenID Connect avec Découverte Dynamique
  • OIDC Enterprise avec Auto-Refresh

• Consulter la Javadoc en ligne

⭐ Soutenez-nous ! Mettez une étoile sur le projet pour nous aider à grandir.