ଆପଣଙ୍କ ନିଜ 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 କାଢ଼ିଦେଲେ ଏହା ଆଉ ଟୋକେନ ଦିଏ ନାହିଁ; ପୂର୍ବରୁ ଦିଆଯାଇଥିବାଗୁଡ଼ିକ କିଛି ମିନିଟ ଭିତରେ ଶେଷ ହୋଇଯାଏ।

ଏହା ମାଗନ୍ତୁ

ଆପଟି ନିଜ authorization ଅନୁରୋଧ ଓ ଟୋକେନ ଅନୁରୋଧରେ 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 ଦ୍ୱାରା ଖୋଜନ୍ତୁ, କେବେ ଇମେଲ ଦ୍ୱାରା ନୁହେଁ: ଏକ ଠିକଣା ହାତ ବଦଳାଇପାରେ, ଏକ subject କେବେ ବଦଳେ ନାହିଁ।