ਤੁਹਾਡੇ ਆਪਣੇ API

ਕੋਈ ਐਪ ਤੁਹਾਡੇ ਕਿਸੇ API ਲਈ ਐਕਸੈਸ ਟੋਕਨ ਮੰਗ ਸਕਦਾ ਹੈ। ਉਸਨੂੰ ਇੱਕ ਸਾਈਨ ਕੀਤਾ JWT ਮਿਲਦਾ ਹੈ ਜਿਸਦਾ ਦਰਸ਼ਕ (audience) ਉਹੀ 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 ਹਟਾਓ ਤਾਂ ਉਸ ਲਈ ਹੋਰ ਟੋਕਨ ਨਹੀਂ ਮਿਲਦੇ; ਜੋ ਪਹਿਲਾਂ ਹੀ ਜਾਰੀ ਹੋ ਚੁੱਕੇ ਹਨ, ਉਹ ਕੁਝ ਮਿੰਟਾਂ ਵਿੱਚ ਖ਼ਤਮ ਹੋ ਜਾਂਦੇ ਹਨ।

ਇਸਨੂੰ ਮੰਗੋ

ਐਪ ਆਪਣੀ ਅਧਿਕਾਰ ਬੇਨਤੀ ਅਤੇ ਆਪਣੀਆਂ ਟੋਕਨ ਬੇਨਤੀਆਂ ਵਿੱਚ 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 ਕਦੇ ਨਹੀਂ ਬਦਲਦਾ।