ക്വിക്ക്സ്റ്റാർട്ട്: ഏത് OIDC ലൈബ്രറിയും

Usher ഒരു സ്റ്റാൻഡേർഡ് OpenID Connect പ്രൊവൈഡറാണ്. നിങ്ങളുടെ ഭാഷയ്ക്ക് സർട്ടിഫൈ ചെയ്ത ഒരു OIDC ക്ലയന്റ് ഉണ്ടെങ്കിൽ, വേണ്ടതെല്ലാം നിങ്ങളുടെ പക്കൽ ഇതിനകമുണ്ട്: അതിനെ നിങ്ങളുടെ എൻവയോൺമെന്റിന്റെ ഡിസ്കവറി ഡോക്യുമെന്റിലേക്ക് ചൂണ്ടി, PKCE-യോടുകൂടിയ ഓതറൈസേഷൻ കോഡ് ഫ്ലോ ഉപയോഗിക്കുക.

ക്രമീകരണങ്ങൾ

ക്രമീകരണം	മൂല്യം
ഇഷ്യൂവർ	`https://<handle>.usherid.com`
ഡിസ്കവറി URL	`https://<handle>.usherid.com/.well-known/openid-configuration`
ഫ്ലോ	ഓതറൈസേഷൻ കോഡ് (`response_type=code`)
PKCE	നിർബന്ധം, `code_challenge_method=S256`
സ്കോപ്പുകൾ	`openid profile email offline_access`
ക്ലയന്റ് ഓതന്റിക്കേഷൻ	`token_endpoint_auth_methods_supported`-ൽ പട്ടികപ്പെടുത്തിയതുപോലെ

നിങ്ങളുടെ എൻവയോൺമെന്റിന്റെ ഹാൻഡിൽ Usher Console-ൽ, അതിന്റെ ഇഷ്യൂവറിന് അരികിലുണ്ട്. ഡെവലപ്മെന്റ് എൻവയോൺമെന്റുകൾക്ക് wise-otter-42 പോലെ ഒരു ക്രമരഹിത ഹാൻഡിൽ ലഭിക്കും; പ്രൊഡക്ഷൻ എൻവയോൺമെന്റുകൾക്ക് നിങ്ങൾ തിരഞ്ഞെടുത്ത ഹാൻഡിൽ ഉണ്ടാകും. ഒരു പ്രൊഡക്ഷൻ എൻവയോൺമെന്റിന് പകരം login.acme.com പോലെ നിങ്ങളുടെ സ്വന്തം ഡൊമെയ്‌നിൽ ആകാം: ഒരു CNAME റെക്കോർഡ് ഉപയോഗിച്ച് ഡൊമെയ്ൻ Usher-ലേക്ക് ചൂണ്ടിക്കഴിഞ്ഞാൽ, അതായിരിക്കും അതിന്റെ ഇഷ്യൂവർ.

ഡിസ്കവറി ഡോക്യുമെന്റ് വായിക്കുക

നിങ്ങളുടെ ക്ലയന്റിന് വേണ്ട എല്ലാ എൻഡ്‌പോയിന്റുകളും കീകളും ഇവിടെ പട്ടികപ്പെടുത്തിയിട്ടുണ്ട്. URL-കൾ കോഡിലേക്ക് പകർത്തുന്നതിന് പകരം നിങ്ങളുടെ ലൈബ്രറി അത് വായിക്കട്ടെ.

ടെർമിനൽ

curl -s https://acme.usherid.com/.well-known/openid-configuration | jq

മറുപടി (ചുരുക്കിയത്)

{
  "issuer": "https://acme.usherid.com",
  "authorization_endpoint": "https://acme.usherid.com/api/auth/oauth2/authorize",
  "token_endpoint": "https://acme.usherid.com/api/auth/oauth2/token",
  "userinfo_endpoint": "https://acme.usherid.com/api/auth/oauth2/userinfo",
  "jwks_uri": "https://acme.usherid.com/api/auth/jwks",
  "introspection_endpoint": "https://acme.usherid.com/api/auth/oauth2/introspect",
  "revocation_endpoint": "https://acme.usherid.com/api/auth/oauth2/revoke",
  "end_session_endpoint": "https://acme.usherid.com/api/auth/oauth2/end-session",
  "scopes_supported": ["openid", "profile", "email", "offline_access"],
  "response_types_supported": ["code"],
  "grant_types_supported": ["authorization_code", "refresh_token", "client_credentials"],
  "code_challenge_methods_supported": ["S256"]
}

ഫ്ലോ

ആളെ ഓതറൈസേഷൻ എൻഡ്‌പോയിന്റിലേക്ക് അയയ്ക്കുക

ഒരു ക്രമരഹിത PKCE വെരിഫയർ ഉണ്ടാക്കി, ഒരു ക്രമരഹിത state-നൊപ്പം, ഈ ബ്രൗസറിന്റെ സെഷന് മാത്രം എത്താവുന്നിടത്ത് സൂക്ഷിക്കുക (കുറഞ്ഞ ആയുസ്സുള്ള ഒരു httpOnly കുക്കി നന്നായി പ്രവർത്തിക്കും). തുടർന്ന് response_type=code, നിങ്ങളുടെ client_id, redirect_uri, മുകളിലെ സ്കോപ്പുകൾ, state, നിങ്ങളുടെ വെരിഫയറിന്റെ S256 code_challenge എന്നിവയോടെ റീഡയറക്ട് ചെയ്യുക.

അവർ സൈൻ ഇൻ ചെയ്യട്ടെ

ഇവിടെ നിന്ന് ലോബി ഏറ്റെടുക്കുന്നു: അത് നിങ്ങളുടെ ആപ്പിന്റെ പേര് പറയുന്നു, നിങ്ങളുടെ എൻവയോൺമെന്റ് അനുവദിക്കുന്ന സൈൻ ഇൻ രീതികൾ നൽകുന്നു, ആദ്യ തവണ സമ്മതം ചോദിക്കുന്നു.

കോൾബാക്ക് പരിശോധിക്കുക

Usher code, state എന്നിവയോടെ നിങ്ങളുടെ redirect_uri-ലേക്ക് റീഡയറക്ട് ചെയ്യുന്നു. നിങ്ങൾ സൂക്ഷിച്ചതുമായി state പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ മറുപടി നിരസിക്കുക. കോഡ് ഒറ്റത്തവണ ഉപയോഗത്തിനുള്ളതാണ്, അഞ്ച് മിനിറ്റ് നിലനിൽക്കും.

കോഡിന് പകരം ടോക്കണുകൾ വാങ്ങുക

നിങ്ങളുടെ സെർവറിൽ നിന്ന്, കോഡും PKCE വെരിഫയറും ടോക്കൺ എൻഡ്‌പോയിന്റിലേക്ക് പോസ്റ്റ് ചെയ്യുക:

ടോക്കൺ അഭ്യർത്ഥന

curl -s -X POST https://acme.usherid.com/api/auth/oauth2/token \
-u "$CLIENT_ID:$CLIENT_SECRET" \
-d grant_type=authorization_code \
-d code="$CODE" \
-d redirect_uri=https://app.acme.example/callback \
-d code_verifier="$CODE_VERIFIER"

ID ടോക്കൺ സാധൂകരിക്കുക

jwks_uri-ലെ കീകളുമായി അതിന്റെ സിഗ്നേച്ചർ പരിശോധിക്കുക, iss നിങ്ങളുടെ ഇഷ്യൂവറാണെന്നും aud നിങ്ങളുടെ ക്ലയന്റ് ID ആണെന്നും exp ഭാവിയിലാണെന്നും ഉറപ്പാക്കുക. നിങ്ങളുടെ ലൈബ്രറി ഇത് നിങ്ങൾക്കായി ചെയ്യുന്നു; അത് ഓഫാക്കിയിട്ടില്ലെന്ന് ഉറപ്പാക്കുക.

Node.js-ൽ

openid-client സാധൂകരണം ഉൾപ്പെടെ മുകളിലുള്ളതെല്ലാം ചെയ്യുന്നു:

openid-client

import * as client from 'openid-client'

// discovery: every endpoint and key comes from the issuer
const config = await client.discovery(
  new URL('https://acme.usherid.com'),
  process.env.USHER_CLIENT_ID!,
  process.env.USHER_CLIENT_SECRET!,
)

// 1. send them to the Lobby, with PKCE (S256) and a state to check later
const codeVerifier = client.randomPKCECodeVerifier()
const state = client.randomState()
const url = client.buildAuthorizationUrl(config, {
  redirect_uri: 'https://app.acme.example/callback',
  scope: 'openid profile email offline_access',
  code_challenge: await client.calculatePKCECodeChallenge(codeVerifier),
  code_challenge_method: 'S256',
  state,
})
// keep codeVerifier and state in a short-lived httpOnly cookie, then redirect to url

// 2. back at /callback: swap the code for tokens
const tokens = await client.authorizationCodeGrant(config, new URL(request.url), {
  pkceCodeVerifier: codeVerifier,
  expectedState: state,
})
const { sub, email, name } = tokens.claims()!

മറ്റ് ഭാഷകളിൽ

വ്യാപകമായി ഉപയോഗിക്കുന്ന ഈ ലൈബ്രറികളെല്ലാം സ്റ്റാൻഡേർഡ് OpenID Connect സംസാരിക്കുന്നു, Usher-ന് മാത്രമുള്ള ഒന്നുമില്ലാതെ Usher-നൊപ്പം പ്രവർത്തിക്കുന്നു:

ഭാഷ	ലൈബ്രറി
Python	Authlib
Go	`coreos/go-oidc`, `golang.org/x/oauth2`-നൊപ്പം
Java	Spring Security OAuth 2.0 Client
.NET	`Microsoft.AspNetCore.Authentication.OpenIdConnect`
Ruby	`omniauth_openid_connect`
PHP	`jumbojett/openid-connect-php`

സൈൻ ഇൻ ചെയ്‌ത നിലയിൽ തുടരൽ

offline_access സ്കോപ്പ് ഉണ്ടെങ്കിൽ, ടോക്കൺ മറുപടിയിൽ ഒരു റിഫ്രഷ് ടോക്കൺ ഉൾപ്പെടും. പഴയ ആക്സസ് ടോക്കൺ കാലഹരണപ്പെടുമ്പോൾ പുതിയത് നേടാൻ grant_type=refresh_token ഉപയോഗിച്ച് അത് ഉപയോഗിക്കുക. റിഫ്രഷ് ടോക്കണുകൾ റൊട്ടേറ്റ് ചെയ്യുന്നു: ഓരോ ഉപയോഗവും പുതിയൊരെണ്ണം നൽകുന്നു, പഴയത് പ്രവർത്തിക്കാതാകുന്നു.

സൈൻ ഔട്ട് ചെയ്യൽ

ആദ്യം നിങ്ങളുടെ സ്വന്തം സെഷൻ മായ്ക്കുക, തുടർന്ന് post_logout_redirect_uri (ഉണ്ടെങ്കിൽ id_token_hint-ഉം) സഹിതം end_session_endpoint-ലേക്ക് റീഡയറക്ട് ചെയ്യുക, അങ്ങനെ ലോബിയും ആളെ മറക്കും.