നിങ്ങളുടെ സ്വന്തം API-കൾ

ഒരു ആപ്പിന് നിങ്ങളുടെ API-കളിൽ ഒന്നിനായി ആക്സസ് ടോക്കൺ ചോദിക്കാം. ഓഡിയൻസ് ആ API മാത്രമായ, സൈൻ ചെയ്ത ഒരു JWT അതിന് ലഭിക്കുന്നു; Usher-നെ വിളിക്കാതെ, നിങ്ങളുടെ എൻവയോൺമെന്റ് പ്രസിദ്ധീകരിച്ച കീകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ API അത് പരിശോധിക്കുന്നു. ഒരു API-ക്കുള്ള ടോക്കൺ മറ്റൊന്നിൽ ഉപയോഗശൂന്യമാണ്.

API-ക്ക് പേര് നൽകുക

Usher Console-ൽ എൻവയോൺമെന്റ് തുറക്കുക, തുടർന്ന് ആപ്ലിക്കേഷനുകൾ → നിങ്ങളുടെ API-കൾ → ഒരു API ചേർക്കുക. അതിന് ഒരു പേരും ഐഡന്റിഫയറും നൽകുക: https://api.example.com പോലെ ഒരു https:// വിലാസം, അല്ലെങ്കിൽ urn:example:api:notes പോലെ ഒരു URN. ആപ്പ് ചോദിക്കുന്നതും ടോക്കണിന്റെ aud ക്ലെയിം പറയുന്നതും ഈ ഐഡന്റിഫയറാണ് (RFC 8707).

തുടർന്ന് അതിനെ വിളിക്കുന്ന ആപ്പുകൾക്ക് API നൽകുക: ഓരോ ആപ്ലിക്കേഷനിലെയും API-കൾ. എന്ത് ചോദിച്ചാലും, ഒരു ആപ്പിന് അതിന് നൽകിയിട്ടുള്ള API-കൾക്ക് മാത്രമേ ടോക്കണുകൾ ലഭിക്കൂ. ഒരു API നീക്കം ചെയ്താൽ അത് പിന്നെ ടോക്കണുകൾ നൽകില്ല; ഇതിനകം പുറത്തുള്ളവ മിനിറ്റുകൾക്കുള്ളിൽ കാലഹരണപ്പെടും.

അത് ചോദിക്കുക

ആപ്പ് അതിന്റെ ഓതറൈസേഷൻ അഭ്യർത്ഥനയിലും ടോക്കൺ അഭ്യർത്ഥനകളിലും resource=<identifier> ചേർക്കുന്നു. മൊബൈൽ SDK-കൾ ഇത് നിങ്ങൾക്കായി ചെയ്യും:

let usher = UsherClient(configuration: .init(
    issuer: URL(string: "https://login.example.com")!,
    clientID: "…",
    redirectURI: URL(string: "com.example.notes:/oauth/callback")!,
    resources: ["urn:example:api:notes"]))

var request = URLRequest(url: URL(string: "https://api.example.com/notes")!)
try await usher.authorize(&request)   // Authorization: Bearer <a JWT for the Notes API>

val usher = Usher.client(context, UsherConfiguration(
    issuer = "https://login.example.com",
    clientId = "…",
    redirectUri = "com.example.notes:/oauth/callback",
    resources = listOf("urn:example:api:notes")))

നിങ്ങളുടെ രണ്ട് API-കളെ വിളിക്കുന്ന ഒരു ആപ്പിന് രണ്ടും ഒരേസമയം ചോദിക്കാം; അപ്പോൾ ടോക്കണിന്റെ ഓഡിയൻസിൽ രണ്ടും ഉണ്ടാകും.

നിങ്ങളുടെ API-യിൽ അത് പരിശോധിക്കുക

ഓരോ അഭ്യർത്ഥനയുടെയും ടോക്കണിലെ എന്തെങ്കിലും വിശ്വസിക്കുന്നതിന് മുമ്പ് അത് പരിശോധിക്കുക:

• സിഗ്നേച്ചർ, നിങ്ങളുടെ എൻവയോൺമെന്റിന്റെ ഡിസ്കവറി ഡോക്യുമെന്റിലെ jwks_uri-ലുള്ള കീകളുമായി ഒത്തുനോക്കി. അൽഗോരിതം കീയിൽ നിന്ന് എടുക്കുക, ഒരിക്കലും ടോക്കണിന്റെ ഹെഡറിൽ നിന്നല്ല.
• iss കൃത്യമായും നിങ്ങളുടെ എൻവയോൺമെന്റിന്റെ ഇഷ്യൂവർ ആണ്. അത് നിങ്ങളുടെ കോൺഫിഗറേഷനിൽ സ്ഥിരപ്പെടുത്തുക; ഒരിക്കലും ടോക്കണിൽ നിന്ന് വായിക്കരുത്.
• aud നിങ്ങളുടെ API-യുടെ ഐഡന്റിഫയർ ഉൾക്കൊള്ളുന്നു. (openid സ്കോപ്പ് ഉണ്ടെങ്കിൽ അതിൽ നിങ്ങളുടെ എൻവയോൺമെന്റിന്റെ userinfo വിലാസവും ഉണ്ടാകും.)
• ഹെഡറിലെ typ at+jwt ആണ്, അതിനാൽ ഒരു ID ടോക്കൺ ആക്സസ് ടോക്കണായി കടത്തിവിടാനാവില്ല.
• exp കഴിഞ്ഞിട്ടില്ല. ആക്സസ് ടോക്കണുകൾ 10 മിനിറ്റ് നിലനിൽക്കും; SDK-കൾ അവ നിങ്ങൾക്കായി പുതുക്കുന്നു.

Node.js-ൽ, @usher/node ഇതെല്ലാം ചെയ്യുന്നു:

import { createVerifier } from '@usher/node'

const usher = await createVerifier({
  issuer: 'https://login.example.com',
  audience: 'urn:example:api:notes',
})

const claims = await usher.accessToken(bearerToken) // throws if any check fails

ASP.NET Core-ൽ:

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(o =>
    {
        o.Authority = "https://login.example.com"; // discovery and keys come from here
        o.MapInboundClaims = false;
        o.TokenValidationParameters = new()
        {
            ValidIssuer = "https://login.example.com",
            ValidAudience = "urn:example:api:notes",
            ValidTypes = ["at+jwt"],
        };
    });

ടോക്കൺ എന്ത് പറയുന്നു

നിങ്ങൾക്ക് ഇതിനകം അറിയാവുന്ന ആളുകൾ

നിങ്ങളുടെ API-ക്ക് മുമ്പേ അക്കൗണ്ടുകളുണ്ടെങ്കിൽ, ഒരാൾ Usher ടോക്കണുമായി ആദ്യമായി എത്തുമ്പോൾ അവരുടെ അക്കൗണ്ട് കണ്ടെത്താം: email ഉപയോഗിച്ച് തിരയുക, email_verified true ആണെങ്കിൽ മാത്രം, അപ്പോൾ മുതൽ iss-ഉം sub-ഉം അവരുടെ അക്കൗണ്ടിൽ സൂക്ഷിക്കുക. അതിനുശേഷം, iss-ഉം sub-ഉം ഉപയോഗിച്ച് അവരെ കണ്ടെത്തുക, ഒരിക്കലും ഇമെയിൽ ഉപയോഗിച്ചല്ല: ഒരു വിലാസം കൈമാറപ്പെടാം, ഒരു സബ്ജക്റ്റ് ഒരിക്കലും മാറില്ല.