તમારા પોતાના API

ઍપ તમારા કોઈ API માટે ઍક્સેસ ટોકન માંગી શકે છે. તેને એક સાઇન કરેલું JWT મળે છે જેની ઑડિયન્સ એ API જ છે, બીજું કંઈ નહીં, અને તમારું API તેને Usher ને કૉલ કર્યા વિના તમારા એન્વાયર્નમેન્ટની પ્રકાશિત કી વડે તપાસે છે. એક API માટેનું ટોકન બીજા API પર કોઈ કામનું નથી.

API ને નામ આપો

Usher Console માં, એન્વાયર્નમેન્ટ ખોલો, પછી ઍપ્લિકેશન → તમારા API → API ઉમેરો. તેને એક નામ અને એક ઓળખકર્તા આપો: https:// સરનામું, જેમ કે https://api.example.com, અથવા URN, જેમ કે urn:example:api:notes. ઍપ આ ઓળખકર્તા જ માંગે છે અને ટોકનનો aud ક્લેમ પણ આ જ કહે છે (RFC 8707).

પછી API ને કૉલ કરતી ઍપને તે API આપો: દરેક ઍપ્લિકેશન પર API. ઍપ ગમે તે માંગે, તેને ફક્ત એ જ API માટે ટોકન મળે છે જે તેને આપવામાં આવ્યાં છે. API દૂર કરો એટલે તે વધુ ટોકન આપતું નથી; જે પહેલેથી અપાયાં છે તે થોડી મિનિટોમાં સમાપ્ત થાય છે.

તે માંગો

ઍપ પોતાની ઑથોરાઇઝેશન વિનંતી અને ટોકન વિનંતીઓમાં resource=<identifier> ઉમેરે છે. મોબાઇલ SDK આ તમારા માટે કરે છે:

swift

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>

kotlin

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 આ બધું કરે છે:

TypeScript

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 માં:

csharp

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"],
        };
    });

ટોકન શું કહે છે

ક્લેમ
`sub`	વ્યક્તિ. `iss` સાથે મળીને, તેમને ઓળખી રાખવાની ચાવી.
`client_id`, `azp`	જે ઍપે માંગ્યું.
`scope`	વ્યક્તિએ ઍપને શું કરવાની સંમતિ આપી.
`email`, `email_verified`	`email` સ્કોપ સાથે: વ્યક્તિનું સરનામું, અને Usher એ સાબિત કર્યું છે કે નહીં કે તે તેમનું છે.
`sid`	તેમનું સાઇન-ઇન સેશન.
`org`	`organization` સ્કોપ સાથે: તેમની સક્રિય સંસ્થા અને ભૂમિકા.

તમે પહેલેથી જાણો છો તે લોકો

જો તમારા API માં પહેલેથી જૂનાં એકાઉન્ટ હોય, તો વ્યક્તિ પહેલી વાર Usher ટોકન સાથે આવે ત્યારે તમે તેમનું એકાઉન્ટ શોધી શકો છો: તેમને email વડે શોધો, ફક્ત ત્યારે જ જ્યારે email_verified એ true હોય, અને ત્યાર પછી તેમના એકાઉન્ટ પર iss અને sub રાખો. એ પછી, તેમને iss અને sub વડે શોધો, ક્યારેય ઇમેઇલ વડે નહીં: સરનામું બીજાના હાથમાં જઈ શકે છે, સબ્જેક્ટ ક્યારેય નહીં.