Une connexion qui ne demande rien à personne.

vérifié @droplet/id · navigateur · aucune dépendance · source

import { DropletId, boutonDropletId } from '@droplet/id';

const did = new DropletId({
  clientId: 'mon-site',
  redirectUri: location.origin + '/',
  portees: ['openid', 'profile'],   // 'profile' : le pseudo, si la personne accepte
});

if (did.estUnRetour()) {
  const { sub, pseudo } = await did.terminerConnexion();   // ID token vérifié
} else {
  document.body.append(boutonDropletId({ onClick: () => did.connecter() }));
}

vérifié @droplet/id-react · utilisé par la démo Kola Café · source

import { DropletIdProvider, DropletIdButton, useDropletId } from '@droplet/id-react';

<DropletIdProvider clientId="mon-site" redirectUri={location.origin + '/'} portees={['openid', 'profile']}>
  <App />
</DropletIdProvider>

function App() {
  const { utilisateur, chargement, erreur, deconnecter } = useDropletId();
  if (!utilisateur) return <DropletIdButton variante="sombre" />;
  return <p>Bonjour {utilisateur.pseudo ?? 'vous'}</p>;
}

vérifié @droplet/id-node · par-dessus openid-client · utilisé par la démo Librairie Baobab · source

import express from 'express';
import { DropletIdServeur } from '@droplet/id-node';

const did = await DropletIdServeur.creer({
  clientId: 'mon-site',
  redirectUri: 'https://mon-site.cm/connexion/retour',
});

const app = express();
// GET /connexion et GET /connexion/retour, prêts :
app.use(did.routesExpress({
  secret: process.env.SECRET,                  // 32 caractères ou plus
  ouvrirSession: (req, res, { sub, pseudo }) => { /* votre session */ },
}));

vérifié droplet-id · une seule dépendance (cryptography) · Flask inclus · source

from droplet_id import DropletId

did = DropletId("mon-site", "https://mon-site.cm/connexion/retour")
url, attente = did.commencer()          # gardez `attente` en session, puis redirigez vers url
session = did.terminer(url_de_retour, attente)
session["sub"]

# Avec Flask, en une ligne :
from droplet_id.flask import blueprint
app.register_blueprint(blueprint(client_id="mon-site", redirect_uri="https://mon-site.cm/connexion/retour"))

vérifié dropletmesh/droplet-id · sans dépendance, même sur un hébergement mutualisé · PHP 8.1+ · source

<?php
require 'DropletId.php';
session_start();
$did = new DropletMesh\DropletId('mon-site', 'https://mon-site.cm/connexion/retour');

// connexion.php
[$url, $_SESSION['droplet_id_attente']] = $did->commencer();
header("Location: $url");

// retour.php
$session = $did->terminer($urlComplete, $_SESSION['droplet_id_attente'] ?? null);
$_SESSION['utilisateur'] = $session['sub'];

vérifié par-dessus coreos/go-oidc et x/oauth2 · source

did, err := dropletid.Nouveau(ctx, dropletid.Options{
    ClientID:    "mon-site",
    RedirectURI: "https://mon-site.cm/connexion/retour",
})
url, attente := did.Commencer()                       // gardez `attente` en session
session, err := did.Terminer(ctx, r.URL.Query(), attente)
session.Sub

compilé et testé droplet_id · par-dessus flutter_appauth · bouton officiel inclus · source

final did = DropletId(clientId: 'mon-app', redirectUri: 'cm.monapp:/connexion');

DropletIdBouton(onPressed: () async {
  final session = await did.connecter();   // onglet sécurisé, jamais une WebView
  print(session.sub);
});

// android/app/build.gradle :
// manifestPlaceholders += [appAuthRedirectScheme: 'cm.monapp']

compilé et testé app.dropletmesh.id · par-dessus AppAuth-Android · bouton Compose inclus · source

val did = DropletId(context, clientId = "mon-app", redirectUri = Uri.parse("cm.monapp:/connexion"))

val lanceur = rememberLauncherForActivityResult(StartActivityForResult()) { r ->
    scope.launch { val session = did.terminer(r.data!!); /* session.sub */ }
}
DropletIdBouton(onClick = { scope.launch { lanceur.launch(did.intentionDeConnexion()) } })

guide Droplet ID suit OpenID Connect : la bibliothèque standard de votre langage suffit. Réglages communs : émetteur https://id.dropletmesh.app, flux authorization_code, PKCE S256, portées openid (+ profile), client public sans secret.

Java — Spring Security (application.yml)

spring.security.oauth2.client:
  registration.droplet:
    client-id: mon-site
    client-authentication-method: none
    authorization-grant-type: authorization_code
    redirect-uri: "{baseUrl}/login/oauth2/code/droplet"
    scope: openid
  provider.droplet:
    issuer-uri: https://id.dropletmesh.app

C# — ASP.NET Core

builder.Services.AddAuthentication(o => { o.DefaultScheme = "Cookies"; o.DefaultChallengeScheme = "droplet"; })
  .AddCookie("Cookies")
  .AddOpenIdConnect("droplet", o => {
      o.Authority = "https://id.dropletmesh.app";
      o.ClientId = "mon-site";
      o.ResponseType = "code";
      o.UsePkce = true;
      o.Scope.Clear(); o.Scope.Add("openid");
  });

Ruby — OmniAuth

use OmniAuth::Builder do
  provider :openid_connect,
    issuer: "https://id.dropletmesh.app", discovery: true,
    pkce: true, scope: [:openid], response_type: :code,
    client_options: { identifier: "mon-site", redirect_uri: "https://mon-site.cm/auth/openid_connect/callback" }
end

Swift — AppAuth-iOS

OIDAuthorizationService.discoverConfiguration(forIssuer: URL(string: "https://id.dropletmesh.app")!) { conf, _ in
  let req = OIDAuthorizationRequest(configuration: conf!, clientId: "mon-app", scopes: [OIDScopeOpenID],
                                    redirectURL: URL(string: "cm.monapp:/connexion")!, responseType: OIDResponseTypeCode,
                                    additionalParameters: nil)
  session = OIDAuthState.authState(byPresenting: req, presenting: self) { etat, _ in /* etat?.lastTokenResponse?.idToken */ }
}

Ces quatre guides utilisent les bibliothèques officielles de chaque langage ; ils n’ont pas encore d’essai automatique contre le service.