OAuth 2.0 & OpenID Connect SSO

OAuth 2.0 Authorization Code Flow är det rekommenderade och säkraste flödet för de flesta applikationer, inklusive webbappar och single-page applications (SPA:er). Det använder PKCE (Proof Key for Code Exchange) för publika klienter för att förhindra att auktoriseringskoder kapas.

Passar bäst för: Webbapplikationer, SPA:er, mobilappar, tredjepartsintegrationer

Använd refresh tokens för att få nya access tokens utan att användaren behöver logga in igen. Refresh tokens är giltiga i 14 dagar och kan roteras för att bibehålla säkerheten.

Passar bäst för: Långvariga sessioner, bakgrundstjänster, offline-åtkomst

OAuth 2.0 Resource Owner Password Credentials-flödet stöds för bakåtkompatibilitet med äldre integrationer. Nya integrationer bör istället använda Authorization Code Flow.

Passar bäst för: Äldre applikationer, interna verktyg (rekommenderas inte för ny utveckling)

GET /connect/authorize

Startar OAuth-auktoriseringsflödet. Omdirigerar användaren för att logga in med sin identitetsleverantör (Microsoft, Google, eller e-post/lösenord).

Query-parametrar:

• client_id (obligatorisk): Ditt applikations-ID
• redirect_uri (obligatorisk): URL att omdirigera till efter autentisering
• response_type (obligatorisk): Måste vara 'code'
• scope (obligatorisk): Mellanslagsseparerad lista av scopes (openid, email, profile, offline_access, roles)
• code_challenge (obligatorisk för SPA): PKCE code challenge
• code_challenge_method (obligatorisk tillsammans med code_challenge): 'S256'
• state (rekommenderas): Slumpmässig sträng för att förhindra CSRF-attacker
• tenant_id (valfri): Specifik tenant att autentisera mot

POST /connect/token

Byter en auktoriseringskod mot access token, ID-token, och eventuell refresh token.

Requestformat: application/x-www-form-urlencoded

Parametrar:

• grant_type (obligatorisk): 'authorization_code', 'refresh_token', eller 'password'
• code (obligatorisk för auth code flow): Auktoriseringskod från /authorize
• client_id (obligatorisk): Ditt applikations-ID
• client_secret (obligatorisk): Din applikationshemlighet (håll konfidentiell)
• redirect_uri (obligatorisk): Måste matcha /authorize-anropet
• code_verifier (obligatorisk för SPA): PKCE code verifier
• refresh_token (för refresh-flöde): Refresh token som ska bytas ut
• username & password (för password-flöde): Användaruppgifter

POST /connect/introspect

Validerar och inspekterar innehållet i en access token eller refresh token.

GET /.well-known/openid-configuration

Standard OIDC-metadata-endpoint. Returnerar discovery-information inklusive endpoints, publika nycklar, stödda scopes och grant types.

Skapa en code verifier och challenge på klientsidan:

// 1. Generate random code verifier (43-128 characters)
const codeVerifier = generateRandomString(128);

// 2. Create code challenge via SHA256 hash
const codeChallenge = await crypto.subtle.digest('SHA-256',
  new TextEncoder().encode(codeVerifier)
);

// 3. Base64-URL encode the challenge
const codeChallengeB64 = base64UrlEncode(codeChallenge);

// Store codeVerifier in sessionStorage for Step 3
sessionStorage.setItem('pkce_verifier', codeVerifier);

Skicka användaren till inloggning:

GET /connect/authorize?
  client_id={your_app_id}
  &redirect_uri=https://your-app.com/callback
  &response_type=code
  &scope=openid email profile
  &code_challenge={pkce_challenge}
  &state={random_state}

Användaren omdirigeras till sin identitetsleverantör (Microsoft, Google, eller e-post/lösenord), slutför autentiseringen och omdirigeras tillbaka till din redirect_uri med en auktoriseringskod.

Byt auktoriseringskoden från din backend:

POST /connect/token
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code
&code={auth_code}
&client_id={your_app_id}
&client_secret={your_app_secret}
&redirect_uri=https://your-app.com/callback
&code_verifier={pkce_verifier}

Vid lyckat anrop får du:

{
  "access_token": "eyJhbGciOiJSUzI1NiIs...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "DefxA1234567890...",
  "id_token": "eyJhbGciOiJSUzI1NiIs..."
}

Validera ID-tokens signatur med den publika nyckeln från /.well-known/openid-configuration, verifiera issuer- och audience-claims, och extrahera användarinformation.

ID-token (JWT) innehåller användarens identitetsinformation:

{
  "sub": "550e8400-e29b-41d4-a716-446655440000",
  "email": "user@company.com",
  "email_verified": true,
  "name": "John Doe",
  "given_name": "John",
  "family_name": "Doe",
  "tenant_id": "12345678-1234-1234-1234-123456789012",
  "iss": "https://api.advanza.ai",
  "aud": "your_app_id",
  "iat": 1234567890,
  "exp": 1234571490
}

Viktiga claims:

• sub: Unik användaridentifierare (Guid)
• email: Användarens e-postadress
• email_verified: Om e-posten är verifierad
• name, given_name, family_name: Användarens namn
• tenant_id: Användarens aktiva tenant/organisation
• iss: Token-utfärdare (alltid https://api.advanza.ai)
• aud: Avsedd mottagare (ditt applikations-ID)
• iat: Tidpunkt då token utfärdades (Unix-tidsstämpel)
• exp: Tokens utgångstid (Unix-tidsstämpel)

Access-token (JWT) innehåller auktoriseringsinformation:

{
  "sub": "550e8400-e29b-41d4-a716-446655440000",
  "email": "user@company.com",
  "name": "John Doe",
  "tenant_id": "12345678-1234-1234-1234-123456789012",
  "roles": ["Owner"],
  "scope": "openid email profile offline_access roles",
  "iss": "https://api.advanza.ai",
  "aud": "your_app_id",
  "iat": 1234567890,
  "exp": 1234571490
}

Viktiga claims:

• sub: Användar-ID
• email, name: Användarinformation
• tenant_id: Aktiv tenant (används för multi-tenancy-routning)
• roles: Användarens roller i tenanten
• scope: Beviljade scopes
• exp: Utgångstid (vanligtvis 1 timme)

Använd access token för: Inkludera i Authorization-headern (Authorization: Bearer {access_token}) när du anropar Advanzas API:er eller din backend.

Vid första inloggningen tilldelas användaren en standardtenant. Claimet tenant_id fylls i med den tenantens ID.

Användare med flera tenant-medlemskap kan byta tenant genom att skicka med önskad tenant_id -parameter till authorization-endpointen:

GET /connect/authorize?
  client_id={your_app_id}
  &redirect_uri=https://your-app.com/callback
  &response_type=code
  &scope=openid email profile
  &tenant_id=12345678-1234-1234-1234-123456789012
  &code_challenge={pkce_challenge}

Använd tenant_id -claimet för att routa anrop till rätt tenant-kontext i din backend:

// Extract tenant from token claims
const tenantId = tokenClaims.tenant_id;

// Route request to tenant context
const tenantContext = getTenantContext(tenantId);
const result = await performAction(tenantContext, action);