Logg inn med Dazr Identity: utviklerdokumentasjon

Standard OpenID Connect 1.0 med autorisasjonskodeflyten og PKCE. Ingen SDK nødvendig: ethvert sertifisert OpenID Connect-bibliotek fungerer, og det gjør også vanlig kode.

Folk kan allerede bruke Google- eller Microsoft-kontoen sin inne i Dazr Identity, så appen din trenger ikke egne Google- og Microsoft-knapper ved siden av: én knapp i stedet for tre.

Discovery og endepunkter

Alt er beskrevet i discovery-dokumentet. Pek biblioteket ditt mot utstederen, så finner det resten.

Registrer en app

• Apper tilhører en organisasjon. Eiere og administratorer i organisasjonen registrerer dem under Utviklere.
• Apper med webserver (konfidensielle klienter) får en klienthemmelighet, som vises én gang. Autentiser mot tokenendepunktet med HTTP Basic (client_secret_basic) eller i skjemaets innhold (client_secret_post).
• Enkeltsideapper og mobilapper (offentlige klienter) får ingen hemmelighet. De sender client_id og bruker PKCE.
• Omdirigerings-URI-er må stemme nøyaktig. De må være https://. Mens appen er i testing, fungerer også http://localhost og http://127.0.0.1 på hvilken som helst port.
• En adresse til personvernerklæring, en e-post for kundestøtte og et formål på én linje er påkrevd: folk ser dem på samtykkeskjermen.

Veiledninger for integrasjon

Hver stakk nedenfor bruker sin egen standardstøtte for OpenID Connect. Du trenger tre verdier fra konsollen: klient-ID-en, klienthemmeligheten (bare apper med webserver) og omdirigerings-URI-en du registrerte. Resten kommer fra discovery-dokumentet.

• Auth.js / NextAuth
• Next.js App Router
• WordPress
• Laravel
• Supabase
• Django
• Node.js (openid-client)
• Ethvert OpenID Connect-bibliotek

Auth.js / NextAuth

Auth.js (NextAuth.js v5) tar et eget leverandørobjekt for OpenID Connect. Registrer en app med webserver, sett AUTH_SECRET, AUTH_DAZR_ID og AUTH_DAZR_SECRET, og bruk denne tilbakekallings-URL-en som omdirigerings-URI: https://app.example.eu/api/auth/callback/dazr.

// auth.ts
import NextAuth from "next-auth"

export const { handlers, auth, signIn, signOut } = NextAuth({
  providers: [
    {
      id: "dazr",
      name: "Dazr Identity",
      type: "oidc",
      issuer: "https://identity.dazr.eu",
      clientId: process.env.AUTH_DAZR_ID,
      clientSecret: process.env.AUTH_DAZR_SECRET,
      authorization: { params: { scope: "openid profile email" } },
      checks: ["pkce", "state", "nonce"],
      client: { id_token_signed_response_alg: "ES256" },
    },
  ],
})

NextAuth.js v4 bruker samme idé med type: "oauth" og discovery-URL-en:

// pages/api/auth/[...nextauth].ts (NextAuth.js v4), in providers: [ ... ]
{
  id: "dazr",
  name: "Dazr Identity",
  type: "oauth",
  wellKnown: "https://identity.dazr.eu/.well-known/openid-configuration",
  clientId: process.env.DAZR_CLIENT_ID,
  clientSecret: process.env.DAZR_CLIENT_SECRET,
  authorization: { params: { scope: "openid profile email" } },
  idToken: true,
  checks: ["pkce", "state"],
  client: { id_token_signed_response_alg: "ES256" },
  profile(profile) {
    return { id: profile.sub, name: profile.name ?? null, email: profile.email }
  },
}

Next.js App Router

Med auth.ts-filen ovenfor legger du til rutebehandleren og en innloggingsknapp som kjører en serverhandling.

// app/api/auth/[...nextauth]/route.ts
import { handlers } from "@/auth"
export const { GET, POST } = handlers

// app/page.tsx
import { auth, signIn, signOut } from "@/auth"

export default async function Page() {
  const session = await auth()
  if (session?.user) {
    return (
      <form action={async () => { "use server"; await signOut() }}>
        <p>Signed in as {session.user.email}</p>
        <button type="submit">Sign out</button>
      </form>
    )
  }
  return (
    <form action={async () => { "use server"; await signIn("dazr") }}>
      <button type="submit" className="dazr-signin">Sign in with Dazr Identity</button>
    </form>
  )
}

Gi knappen stil som vist under Knappen. I tilbakekallingene er Dazr-sub det samme som account.providerAccountId.

WordPress

Bruk et generisk klienttillegg for OpenID Connect, som OpenID Connect Generic Client. Registrer en app med webserver og fyll inn innstillingene i tillegget med verdiene nedenfor. Tillegget viser omdirigerings-URI-en som skal registreres, på innstillingssiden sin; som standard er den https://example.com/wp-admin/admin-ajax.php?action=openid-connect-authorize.

Navnene på innstillingene varierer litt mellom tillegg. Hvis et tillegg ikke har noe valg for PKCE, velg et annet: Dazr Identity avviser innlogginger uten PKCE.

Laravel

Laravel Socialite har ingen innebygd generisk driver for OpenID Connect, så legg til en liten egen driver. Den sender folk til Dazr med PKCE og leser brukeren fra endepunktet for brukerinformasjon. Socialite leser ikke discovery-dokumentet, så endepunktene er skrevet ut. Registrer en app med webserver med omdirigerings-URI-en https://app.example.eu/auth/dazr/callback.

<?php
// app/Socialite/DazrProvider.php
namespace App\Socialite;

use Laravel\Socialite\Two\AbstractProvider;
use Laravel\Socialite\Two\User;

class DazrProvider extends AbstractProvider
{
    protected $scopes = ['openid', 'profile', 'email'];
    protected $scopeSeparator = ' ';
    protected $usesPKCE = true;

    protected function getAuthUrl($state)
    {
        return $this->buildAuthUrlFromBase('https://identity.dazr.eu/oauth/authorize', $state);
    }

    protected function getTokenUrl()
    {
        return 'https://identity.dazr.eu/oauth/token';
    }

    protected function getUserByToken($token)
    {
        $response = $this->getHttpClient()->get('https://identity.dazr.eu/oauth/userinfo', [
            'headers' => ['Authorization' => 'Bearer '.$token],
        ]);

        return json_decode((string) $response->getBody(), true);
    }

    protected function mapUserToObject(array $user)
    {
        return (new User)->setRaw($user)->map([
            'id' => $user['sub'],
            'name' => $user['name'] ?? null,
            'email' => $user['email'] ?? null,
        ]);
    }
}

// config/services.php
'dazr' => [
    'client_id' => env('DAZR_CLIENT_ID'),
    'client_secret' => env('DAZR_CLIENT_SECRET'),
    'redirect' => env('DAZR_REDIRECT_URI'),
],

// app/Providers/AppServiceProvider.php, in boot()
use Laravel\Socialite\Facades\Socialite;
use App\Socialite\DazrProvider;

Socialite::extend('dazr', function ($app) {
    return Socialite::buildProvider(DazrProvider::class, config('services.dazr'));
});

// routes/web.php
Route::get('/auth/dazr', fn () => Socialite::driver('dazr')->redirect());
Route::get('/auth/dazr/callback', function () {
    $dazr = Socialite::driver('dazr')->user();
    $user = \App\Models\User::updateOrCreate(
        ['dazr_sub' => $dazr->getId()],
        ['name' => $dazr->getName() ?? $dazr->getEmail(), 'email' => $dazr->getEmail()],
    );
    Auth::login($user);
    return redirect('/');
});

Supabase

Supabase Auth har ingen generisk leverandør for OpenID Connect som du kan peke mot en hvilken som helst utsteder: innloggingsleverandørene og integrasjonene for tredjepartsautentisering er faste lister. Du kan derfor ikke legge til Dazr Identity i Supabase-dashbordet i dag. Hvis Supabase legger til generisk støtte for OpenID Connect, bruker du verdiene fra sjekklisten nedenfor.

Alternativet: logg folk inn med Dazr Identity på din egen server (med en av veiledningene på denne siden), lagre Dazr-sub i brukertabellen din, og snakk med Supabase fra den serveren med nøkkelen for tjenesterollen, med tilgangskontroll i din egen kode. Send aldri nøkkelen for tjenesterollen til en nettleser.

Django

Bruk mozilla-django-oidc. Registrer en app med webserver med omdirigerings-URI-en https://app.example.eu/oidc/callback/. Biblioteket leser ikke discovery-dokumentet, så endepunktene er skrevet ut.

# settings.py
import os

INSTALLED_APPS += ["mozilla_django_oidc"]  # after django.contrib.auth
AUTHENTICATION_BACKENDS = [
    "mozilla_django_oidc.auth.OIDCAuthenticationBackend",
    "django.contrib.auth.backends.ModelBackend",
]

OIDC_RP_CLIENT_ID = os.environ["DAZR_CLIENT_ID"]
OIDC_RP_CLIENT_SECRET = os.environ["DAZR_CLIENT_SECRET"]
OIDC_RP_SCOPES = "openid profile email"
OIDC_RP_SIGN_ALGO = "ES256"
OIDC_OP_JWKS_ENDPOINT = "https://identity.dazr.eu/oauth/jwks"
OIDC_OP_AUTHORIZATION_ENDPOINT = "https://identity.dazr.eu/oauth/authorize"
OIDC_OP_TOKEN_ENDPOINT = "https://identity.dazr.eu/oauth/token"
OIDC_OP_USER_ENDPOINT = "https://identity.dazr.eu/oauth/userinfo"
OIDC_USE_PKCE = True
OIDC_PKCE_CODE_CHALLENGE_METHOD = "S256"

LOGIN_REDIRECT_URL = "/"
LOGOUT_REDIRECT_URL = "/"

# urls.py
from django.urls import include, path
urlpatterns += [path("oidc/", include("mozilla_django_oidc.urls"))]

# template: start the sign-in
# <a href="{% url 'oidc_authentication_init' %}">Sign in with Dazr Identity</a>

Som standard matcher backend brukere etter e-post. For å bruke sub som kontonøkkel lager du en underklasse av OIDCAuthenticationBackend og overstyrer filter_users_by_claims og create_user. Bruk en nyere utgivelse: eldre utgivelser kan ikke verifisere ES256-signaturer.

Node.js (openid-client)

openid-client (versjon 6) leser discovery-dokumentet og sjekker PKCE, state, nonce og ID-tokenet for deg.

import * as client from 'openid-client';

const config = await client.discovery(
  new URL('https://identity.dazr.eu'),
  process.env.DAZR_CLIENT_ID,
  process.env.DAZR_CLIENT_SECRET, // public client: pass undefined here and client.None() as the 4th argument
);
const redirect_uri = 'https://app.example.eu/auth/dazr/callback';

// 1. Start: keep the three random values in the user's session.
export async function start(session) {
  session.verifier = client.randomPKCECodeVerifier();
  session.state = client.randomState();
  session.nonce = client.randomNonce();
  return client.buildAuthorizationUrl(config, {
    redirect_uri,
    scope: 'openid profile email',
    code_challenge: await client.calculatePKCECodeChallenge(session.verifier),
    code_challenge_method: 'S256',
    state: session.state,
    nonce: session.nonce,
  });
}

// 2. Callback: pass the full callback URL (a URL object).
export async function callback(session, currentUrl) {
  const tokens = await client.authorizationCodeGrant(config, currentUrl, {
    pkceCodeVerifier: session.verifier,
    expectedState: session.state,
    expectedNonce: session.nonce,
  });
  const claims = tokens.claims(); // sub, email, name
  return { sub: claims.sub, email: claims.email, name: claims.name };
}

Ethvert OpenID Connect-bibliotek

Hvis stakken din ikke står på listen, fungerer enhver OpenID Connect-klient. Sjekk disse innstillingene:

• Utsteder https://identity.dazr.eu, discovery-URL https://identity.dazr.eu/.well-known/openid-configuration.
• Svartype code (autorisasjonskodeflyt). Ingen implisitt eller hybrid flyt.
• PKCE er påkrevd, med code_challenge_method=S256.
• Omfang: openid pluss bare det du trenger av profile, email, address, organisations og offline_access. Appen din må være registrert for hvert omfang den ber om.
• Omdirigerings-URI: nøyaktig slik den er registrert i konsollen, inkludert stien og eventuell spørrestreng.
• Klientautentisering: client_secret_basic eller client_secret_post for apper med webserver, none for enkeltsideapper og mobilapper.
• Signatur for ID-token: ES256. Noen biblioteker antar RS256: sett algoritmen til ES256.
• Bruk sub som kontonøkkel. Den er parvis, per organisasjon.
• Med offline_access lagrer du det nye oppdateringstokenet etter hver oppdatering: de roteres.

Flyten

1. Lag en tilfeldig code_verifier (43 til 128 tegn) og tilhørende code_challenge = base64url(SHA-256(verifier)). Lag tilfeldige state og nonce. Ta vare på alle tre i brukerens økt.
2. Omdiriger til autorisasjonsendepunktet med response_type=code, client_id, redirect_uri, scope (alltid inkludert openid), state, nonce, code_challenge og code_challenge_method=S256.
3. Personen logger inn om nødvendig og ser samtykkeskjermen med de faktiske dataene. Når vedkommende tillater det, kommer personen tilbake til omdirigerings-URI-en din med code, state og iss. Sjekk at state stemmer og at iss er https://identity.dazr.eu.
4. På serveren din sender du en POST til tokenendepunktet med grant_type=authorization_code, code, samme redirect_uri og code_verifier.
5. Verifiser ID-tokenet: ES256-signatur med en nøkkel fra JWKS (match kid), iss, aud = klient-ID-en din, exp og din nonce. Bruk sub som kontonøkkel.

Parameteren prompt godtar none (svar med en gang med login_required eller consent_required hvis personen måtte ha gjort noe), login (be personen logge inn igjen) og consent (vis samtykkeskjermen selv når den er godkjent før). max_age støttes. Husket samtykke: hvis personen har godkjent de samme omfangene før, går vedkommende rett tilbake til appen din. Ber du om mer senere, viser samtykkeskjermen bare det som er nytt.

Omfang og claims

Be bare om det du trenger. Ingenting utenfor denne tabellen finnes: ingen kontakter, ingen filer, ingen passord.

Claims vises i ID-tokenet for omfangene personen godkjente. Endepunktet for brukerinformasjon returnerer det samme settet, med gjeldende verdier.

Verifiserte organisasjoner

Dazr verifiserer en organisasjon bare når offisielle kilder beviser to ting: hvem personen er, og at vedkommende representerer denne organisasjonen, med navn, registreringsnummer og mva-nummer. Vanligvis signerer daglig leder en kort erklæring med en kvalifisert elektronisk signatur (QES) og legger ved utdraget fra foretaksregisteret som oppgir vedkommende; med et utdrag forseglet av registeret, som den italienske visuraen eller et nederlandsk KvK-utdrag, går det umiddelbart, ellers gjennomgår Dazr det. En kvalifisert signatur alene gjør aldri en organisasjon verifisert. Hver organisasjon i claimen organisations har med sin gjeldende verifisering:

Bare når statusen er verified, sier verification.authority (og authority i webhooks) hvordan koblingen mellom personen og organisasjonen ble bevist:

Den boolske verdien verified beholdes for kompatibilitet og tilsvarer verification.status === 'verified'. Hver organisasjon har også en id, den samme som webhooks bruker.

Når statusen er pending eller verified, er verification.report_url adressen til verifiseringsrapporten.

"organisations": [{
  "id": "org_3k9x2m0q8w1v5t7a", "name": "Conti Logistica S.r.l.", "country": "IT",
  "register_number": "REA MI1234567", "vat": "IT12345678903", "vat_verified": true,
  "display_name": "Conti", "website": "https://conti.example",
  "verified": false, "verification": { "status": "pending", "method": "qes" }, "role": "owner"
}]

role og medlemskap leses på nytt ved hver tokenoppdatering og forespørsel om brukerinformasjon: etter en rolleendring har neste svar den nye rollen, og en organisasjon personen har gått ut av eller blitt fjernet fra, er ikke lenger med. Når en administrator i organisasjonen kobler fra appen din, utelates organisasjonen fra tokener som er utstedt tidligere, til et medlem deler den med appen din igjen ved en ny innlogging. display_name og website er null når organisasjonen ikke har angitt dem; name er alltid det juridiske navnet.

Krev en verifisert organisasjon

I konsollen setter du Krev en verifisert organisasjon til Verifisering startet eller Verifisert, eller ber om det per forespørsel med acr_values=urn:dazr:org:verification-started eller acr_values=urn:dazr:org:verified (den strengeste av de to gjelder). Appen din må også be om omfanget organisations.

Den som ikke har en organisasjon som kvalifiserer, tas gjennom det i samme innlogging: navnet sitt, organisasjonen (med mva-nummeret sjekket i VIES), deretter verifiseringen. Vedkommende kan signere med en gang, få erklæringen sendt til seg selv på e-post, eller navngi en annen som signerer. Deretter krysser vedkommende av for organisasjonen på samtykkeskjermen (bare organisasjoner som kvalifiserer, kan krysses av) og kommer tilbake til omdirigerings-URI-en din.

Hvis en annen fortsatt må signere, kommer personen tilbake med statusen pending, også når du ba om Verifisert: du mottar en kode, claimen sier pending, og acr i ID-tokenet er urn:dazr:org:verification-started i stedet for urn:dazr:org:verified. Styr alltid tilgangen etter verification.status, aldri etter at innloggingen lyktes. Med prompt=none får du interaction_required når kravet ikke er oppfylt.

Endringer i innstillingen gjelder fra neste innlogging. Folk som allerede er innlogget, logges ikke ut: svar på oppdateringer, endepunktet for brukerinformasjon og webhooks har alltid gjeldende status, så bruk dem til å reagere for eksisterende økter.

Webhooks

Legg til en webhook-URL (https) i konsollen. Du ser signeringshemmeligheten én gang; du kan rotere den. Dazr sender organisation.verification.updated når en organisasjon som en av brukerne dine har delt med appen din, blir pending, verified, failed eller unverified. Apper som aldri har mottatt en organisasjon gjennom samtykke, hører aldri om det.

POST /your/webhook
Content-Type: application/json
Dazr-Event: organisation.verification.updated
Dazr-Delivery: dlv_8Fq2…
Dazr-Signature: t=1791021600,v1=5e0c…

{ "id": "evt_…", "type": "organisation.verification.updated", "created": 1791021600,
  "data": { "organisation": { "id": "org_3k9x2m0q8w1v5t7a", "name": "Conti Logistica S.r.l.", "country": "IT" },
            "status": "verified", "method": "qes_org", "authority": "certificate", "verified_at": 1791021598,
            "report_url": "https://identity.dazr.eu/oauth/verification-report?org=org_3k9x2m0q8w1v5t7a",
            "subjects": ["Xo1c…"] } }

status er pending, verified, failed eller unverified. subjects er sub-verdiene, i appen din, for personene som delte denne organisasjonen med den. Sjekk signaturen før du stoler på innholdet:

import crypto from 'node:crypto';
// raw = the request body exactly as received (a string), header = the Dazr-Signature header
function verifyDazrSignature(raw, header, secret) {
  const m = /^t=(\d+),v1=([a-f0-9]{64})$/.exec(header || '');
  if (!m || Math.abs(Date.now() / 1000 - Number(m[1])) > 300) return false; // reject old deliveries
  const want = crypto.createHmac('sha256', secret).update(m[1] + '.' + raw).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(want), Buffer.from(m[2]));
}

Svar med en hvilken som helst 2xx innen 8 sekunder. Ellers prøver Dazr igjen etter omtrent 5 minutter, 30 minutter, 2, 6, 12 og 24 timer, og markerer deretter leveransen som mislykket. Hvert forsøk har samme Dazr-Delivery-ID, så se bort fra duplikater. Konsollen lister opp nylige leveranser, kan sende én på nytt og kan sende en testhendelse (webhook.test). Å spørre endepunktet for brukerinformasjon fungerer også.

Virksomhetsverifisering (KYB)

Virksomhetsverifisering er det høyere sikkerhetsnivået oppå organisasjonsverifisering. Den legger til hvem som eier og leder selskapet: foretaksregisteret, en ID-kontroll med selfie for representanten og for hver reell rettighetshaver, eierstrukturen og screening for sanksjoner og PEP. Organisasjonen betaler 25 € eks. mva., én gang; avbryter den før et ID-dokument er kontrollert, refunderes hele betalingen.

1. Selskapsopplysninger. Selskapsformen samt organisasjonsnummer og forretningsadresse fra organisasjonens juridiske opplysninger, bekreftet av den som starter den.
2. Betaling. 25 € eks. mva. via Mollie; fakturaen ligger på organisasjonens side.
3. ID og selfie. Representanten tar bilde av et pass, ID-kort eller en oppholdstillatelse (forside og bakside der det trengs) og to selfier, den andre med en tilfeldig dreining eller vipping av hodet. En KI-modell leser dokumentet; Dazr sjekker den maskinlesbare sonen (kontrollsiffer etter ICAO 9303), datoene og navnet; en tjeneste for ansiktssammenligning sammenligner selfien med bildet i dokumentet. En QR-kode flytter bildetakingen fra en datamaskin til en telefon.
4. Sjekk i foretaksregisteret. Navn, status og ledelse fra det offisielle registeret der det finnes på nett (Norge, Danmark, Finland, Frankrike, Nederland, Polen, Tsjekkia og Storbritannia, inkludert registeret over personer med betydelig kontroll), ellers fra en offisiell utskrift som er høyst 3 måneder gammel.
5. Hvem eier selskapet? Hver person med 25 % eller mer av aksjene eller stemmene, direkte eller via andre selskaper (med kjeden), eller med kontroll på annen måte. Oppfyller ingen dette, regnes ledelsen som reelle rettighetshavere.
6. Eierne verifiserer. Hver eier får en lenke på e-post, bekrefter den med en engangskode og tar den samme ID-kontrollen. Påminnelser sendes etter 2 og 7 dager; lenker utløper etter 14 dager.
7. Sanksjons- og PEP-kontroller. Selskapet og hver person mot EUs, FNs og OFACs sanksjonslister og for politisk eksponerte personer.
8. Beslutning. Dokumenterte risikoregler godkjenner saker uten merknader. Alt annet går til en saksbehandler hos Dazr, som kan godkjenne, avvise med en begrunnelse, be organisasjonen om mer informasjon eller kjøre en kontroll på nytt. Høyrisikosaker krever to saksbehandlere. Ingen sak avvises automatisk.

Godkjente organisasjoner screenes mot sanksjonslistene på nytt hver dag og for PEP-status jevnlig. Et nytt treff sender verifiseringen tilbake til gjennomgang, og appen din får beskjed.

Kravet kyb

Hver organisasjon i kravet organisations inneholder kyb, og verification.assurance_level oppsummerer begge nivåene: none, basic (organisasjonen verifisert) eller kyb (virksomhetsverifisering godkjent).

Etter godkjenning følger verified_claims formatet OpenID Connect for Identity Assurance:

"kyb": {
  "status": "approved",
  "report_url": "https://identity.dazr.eu/oauth/verification-report?org=org_3k9x2m0q8w1v5t7a",
  "verified_claims": {
    "verification": {
      "trust_framework": "dazr_kyb", "assurance_level": "kyb", "time": "2026-10-06T09:14:03.000Z",
      "verification_process": "kyb_7Tq2…",
      "evidence": [
        { "type": "electronic_record", "check_details": [{ "check_method": "data", "organization": "no-brreg" }] },
        { "type": "document", "check_details": [{ "check_method": "vpip" }, { "check_method": "pvr" }],
          "note": "ID document and selfie with liveness of the representative and each beneficial owner" }
      ]
    },
    "claims": {
      "legal_name": "Fjordline Logistikk AS", "country": "NO", "registration_number": "912345678",
      "beneficial_owners_verified": 2,
      "screening": { "result": "no_match_found", "pep_checked": true, "last_screened_at": "2026-10-06T03:23:00.000Z" },
      "risk_level": "low"
    }
  }
}

Kravet inneholder aldri navn, fødselsdatoer eller dokumentopplysninger om eierne. De står i revisjonsrapporten, som appen din kan hente for organisasjoner som er delt med den.

Krev virksomhetsverifisering

Sett Krev en verifisert organisasjon til Virksomhetsverifisering (KYB) i konsollen, eller be om det per forespørsel med acr_values=urn:dazr:org:kyb. Den som ikke har det ennå, starter det i samme innlogging og kan fortsette til appen din med en gang; de resterende trinnene, som eiernes ID-kontroller, skjer etterpå. ID-tokenets acr er først urn:dazr:org:kyb når en organisasjon er godkjent, så sjekk alltid kyb.status === 'approved' før du låser opp noe som krever det.

Webhooks for virksomhetsverifisering

Den samme hendelsen organisation.verification.updated sendes når statusen for virksomhetsverifiseringen endrer seg, også etter en ny screening. Dataene legger til:

"kyb": { "status": "approved", "approved_at": 1791021598, "risk_level": "low" },
"assurance_level": "kyb"

Virksomhetsverifisering på egen hånd

En organisasjon kan også starte virksomhetsverifisering fra sin side i Dazr Identity, uten at noen app ber om det. Resultatet er det samme: én verifisering per organisasjon, som hver app organisasjonen deles med, kan stole på. Bilder av ID-dokumenter og selfier slettes 30 dager etter beslutningen; resultatene og rapporten lagres i 5 år etter at verifiseringen er avsluttet, slik hvitvaskingsreglene krever.

Verifiseringsrapporter for revisjoner

For hver organisasjon som er delt med appen din, kan du hente en rapport om hvordan og når Dazr verifiserte den, til revisjonsmappen din. Den finnes mens organisasjonen er verifisert, og mens verifiseringen pågår, og viser da hva som er gjort så langt.

• Organisasjonen: navn, land, registreringsnummer, mva-nummer og forretningsadresse.
• Verifiseringen: status, metode, fullmakt, og når den ble bedt om, signert og verifisert.
• Bevisene: for en kvalifisert signatur eller et segl, signererens navn slik det står på sertifikatet, sertifikatets utsteder, serienummer, gyldighet og SHA-256-fingeravtrykk, den kvalifiserte statusen (QC-erklæringer, tillitstjenesteyter og tjeneste fra EUs tillitsliste, med listens sekvensnummer og utstedelsesdato), signeringstidspunktet og sjekken av tilbakekalling. For et registerforseglet utdrag, hvem som forseglet det, når, og hva som stemte: navn, registreringsnummer, mva-nummer, daglig leder. VIES-resultatet. For en PEC-kode, et brev eller en videosamtale, datoene og sjekkene en saksbehandler i Dazr krysset av, vist som «Saksbehandler i Dazr» med en intern ID.
• Til mappene dine: SHA-256-fingeravtrykket av hver bevisfil, en dokument-ID, når rapporten ble laget, og en kort forklaring av hver metode og av hva fullmakt betyr.

En rapport inneholder aldri bilder eller numre fra ID-dokumenter, engangskoder, PEC-adressen, e-postadresser eller andre adresser enn forretningsadressen.

Hent en rapport

Autentiser med klient-ID-en og klienthemmeligheten din, som ved tokenendepunktet: HTTP Basic (client_secret_basic), eller innholdet i en POST (client_secret_post). Legg aldri hemmeligheten i URL-en. Bruk organisasjonens id fra claims eller webhooks, eller rett og slett verification.report_url som de har med.

curl -u "$DAZR_CLIENT_ID:$DAZR_CLIENT_SECRET" -o report.pdf \
  "https://identity.dazr.eu/oauth/verification-report?org=org_3k9x2m0q8w1v5t7a&format=pdf&lang=en"

Bare organisasjoner som minst én av brukerne dine har delt med appen din gjennom samtykke, kan hentes. Alle andre organisasjoner svarer 404, det samme som en som ikke finnes eller ikke har noen verifisering; en feil klienthemmelighet svarer 401. Apper uten klienthemmelighet kan ikke hente rapporter. Nedlastinger har begrenset antall forespørsler, og hver av dem vises i organisasjonens aktivitet for administratorene, med navnet på appen din. I konsollen viser siden for appen din de tilkoblede organisasjonene med de samme nedlastingene.

Verifiser den signerte JSON-en

Med format=jws mottar du en kompakt JWS (ES256, header typ dazr-verification-report+jwt), signert med de samme nøklene som ID-tokener. Claims er iss, iat, jti (dokument-ID-en), sub (organisasjonens id), aud (klient-ID-en din) og report, faktaene. PDF-en har den samme JWS-en på siste side og i metadataene (DazrVerificationReport), så en PDF kan også kontrolleres uten nett.

import { createRemoteJWKSet, jwtVerify } from 'jose';

const jwks = createRemoteJWKSet(new URL('https://identity.dazr.eu/oauth/jwks'));
// jws = the response body of format=jws, or the text from the PDF metadata
const { payload } = await jwtVerify(jws, jwks, {
  issuer: 'https://identity.dazr.eu',
  audience: process.env.DAZR_CLIENT_ID,
  typ: 'dazr-verification-report+jwt',
});
console.log(payload.report.verification.status, payload.report.verification.authority);

La en revisor kontrollere signaturen

For en kvalifisert signatur eller et segl returnerer doc=declaration den signerte erklæringen nøyaktig slik den ble lastet opp: en signert PDF (PAdES) eller en .p7m-fil (CAdES). En revisor kan validere den uavhengig med Europakommisjonens DSS-demovalidator: last opp filen, behold standard valideringspolicy og kjør den. Resultatet viser om signaturen er kvalifisert (QESig, eller QESeal for et segl), hvem som signerte, og tillitstjenesteyteren fra EUs tillitsliste. doc=extract returnerer utdraget fra foretaksregisteret; et registerforseglet utdrag kan valideres på samme måte.

Rapporten er bevis til revisjonsmappen din. Regulerte foretak er fortsatt ansvarlige for sine egne kundetiltak.

Dazr tar vare på den signerte erklæringen, utdraget og rapportdataene mens organisasjonen er verifisert og i 5 år etter at verifiseringen avsluttes eller organisasjonen slettes. Ta vare på dine egne kopier så lenge reglene dine krever.

Tokener og levetider

Signeringsnøkler roteres. Velg alltid nøkkelen etter kid fra JWKS, og oppdater JWKS når du ser en ukjent kid.

Feil

Så lenge klient-ID-en og omdirigerings-URI-en din er gyldige, kommer feil tilbake til omdirigerings-URI-en din som error, error_description, state og iss: for eksempel invalid_request (som manglende eller plain PKCE), invalid_scope, unsupported_response_type, access_denied (personen avbrøt, eller appen er i testing og personen er ikke medlem), login_required, consent_required og interaction_required (med prompt=none, når en påkrevd verifisert organisasjon mangler). Med en ukjent klient eller en uregistrert omdirigerings-URI viser Dazr en feilside og omdirigerer aldri. Tokenendepunktet svarer med JSON-feil som invalid_client, invalid_grant og unsupported_grant_type.

Utlogging

For å logge ut noen sender du dem til utloggingsendepunktet med id_token_hint (eller client_id), en valgfri post_logout_redirect_uri registrert i appinnstillingene og state. Dazr spør om de også vil logge ut av Dazr Identity på den enheten, og sender dem så tilbake. Tilbakekall oppdateringstokener du ikke lenger trenger, ved tilbakekallingsendepunktet.

Testing og lansering

En ny app er i testing: bare medlemmer av organisasjonen din kan logge inn, og samtykkeskjermen sier det. For å lansere får du organisasjonen din verifisert i Dazr Identity, legger til en https://-omdirigerings-URI og ber om en gjennomgang for lansering i konsollen. Endrer du navnet, formålet, personvernerklæringen eller dataene til en lansert app, trengs en ny gjennomgang.

Overfør en app til en annen organisasjon

En app kan flyttes til en annen organisasjon som er registrert hos Dazr, for eksempel etter et salg eller en omorganisering. En eier eller administrator starter overføringen under Overfør app i appinnstillingene, i Dazr Identity eller i Sign-portalen. En eier eller administrator i den andre organisasjonen godtar eller avslår den innen 14 dager. Fram til da kan avsenderen avbryte, og ingenting endres.

• Hvem som kan motta den. Bare en organisasjon som er registrert hos Dazr, angitt med organisasjons-ID-en. Eierne og administratorene finner ID-en i de juridiske opplysningene i Dazr Identity. En lansert app, en app under gjennomgang, en app som krever en verifisert organisasjon og en app med Dazr Sign-API-et aktivert kan bare flyttes til en verifisert organisasjon. Dette sjekkes på nytt når overføringen godtas.
• En nylig innlogging. Å starte og godta en overføring krever en innlogging fra de siste 10 minuttene.
• Hva som flyttes. Klient-ID-en, innstillingene, logoen, omdirigerings-URI-ene, de aktiverte API-ene og webhook-URL-ene. Administratoren som godtar, godtar også utviklervilkårene for den nye organisasjonen.
• Klienthemmeligheten. En app med webserver får en ny klienthemmelighet, som vises én gang til administratoren som godtar. Den forrige hemmeligheten fortsetter å virke ved token-, tilbakekallings- og introspeksjonsendepunktene i overgangsperioden som ble valgt da overføringen startet: ingen, 24 timer (standard) eller 7 dager. Verifiseringsrapporter krever den nye hemmeligheten.
• Webhooks. URL-ene blir værende. Signeringshemmelighetene deres, for Dazr Identity og for Dazr Sign, fornyes og vises én gang til administratoren som godtar. Leveranser fra før overføringen sendes ikke på nytt.
• Folk og deres sub. Hver person beholder den samme sub i appen, så kontoene i appen din fortsetter å virke. Den er forskjellig fra deres sub i den nye organisasjonens andre apper. Folk godkjenner appen på nytt ved neste innlogging, fordi samtykkeskjermen nå viser den nye organisasjonen. Tokener som er utstedt før overføringen, slutter å virke.
• Hva som blir hos den forrige eieren. Tellinger av innlogginger og samtykker og webhook-leveranser fra før overføringen. Dokumenter som er opprettet gjennom Dazr Sign-API-et, blir hos personene som eier dem, og appens nye eier kan ikke se dem.

Knappen

Bruk ordlyden «Sign in with Dazr Identity» og Dazr-logoen som nedenfor. Du kan endre størrelsen, ikke logoen, fargene eller ordlyden. Lenk den til din egen rute som starter flyten.

Sign in with Dazr Identity

<a href="/auth/dazr" style="display:inline-flex;align-items:center;gap:10px;height:44px;padding:0 18px;border-radius:22px;background:#18203a;color:#fff;font: 600 15px/1 'Dazr', system-ui, sans-serif;text-decoration:none">
  <svg width="20" height="20" viewBox="0 0 100 100" aria-hidden="true"><path d="M50 4 89 16v31c0 25.5-16.8 42.5-39 50C27.8 89.5 11 72.5 11 47V16z" fill="#fff"/><path d="M50 15.5 79 24.5v22.8c0 19.5-12.4 32.6-29 38.7C33.4 79.9 21 66.8 21 47.3V24.5z" fill="#18203a"/><path d="M50 24 71 30.6v16.9c0 14.5-9 24.4-21 29.2-12-4.8-21-14.7-21-29.2V30.6z" fill="#fff"/></svg>
  Sign in with Dazr Identity
</a>

Dazr-skriften. Knappen bruker Dazr-skriften, som er gratis å bruke under SIL Open Font License. Der Dazr-skriften ikke er lastet inn, brukes systemskriften i stedet. Last ned Dazr-skriften (ZIP med TTF- og WOFF2-filer) for å hoste den på ditt eget nettsted:

/* woff2 files from the ZIP, copied to /fonts/ on your site */
@font-face { font-family: 'Dazr'; font-weight: 400; font-display: swap;
  src: url('/fonts/dazr-regular-latin.woff2') format('woff2'); }
@font-face { font-family: 'Dazr'; font-weight: 700; font-display: swap;
  src: url('/fonts/dazr-bold-latin.woff2') format('woff2'); }
.dazr-signin { font: 600 15px/1 'Dazr', system-ui, sans-serif; }

Et minimalt Node.js-eksempel

Node 18 eller nyere, ingen avhengigheter. En app med webserver og klienthemmelighet; for en offentlig klient fjerner du Authorization-headeren og sender client_id i innholdet.

import crypto from 'node:crypto';
const issuer = 'https://identity.dazr.eu';
const clientId = process.env.DAZR_CLIENT_ID;
const clientSecret = process.env.DAZR_CLIENT_SECRET;
const redirectUri = 'https://app.example.eu/auth/dazr/callback';
const b64url = (buf) => Buffer.from(buf).toString('base64url');

// 1. Start: keep verifier, state and nonce in the user's session.
export function start(session) {
  session.verifier = b64url(crypto.randomBytes(32));
  session.state = b64url(crypto.randomBytes(16));
  session.nonce = b64url(crypto.randomBytes(16));
  const challenge = b64url(crypto.createHash('sha256').update(session.verifier).digest());
  return issuer + '/oauth/authorize?' + new URLSearchParams({
    response_type: 'code', client_id: clientId, redirect_uri: redirectUri,
    scope: 'openid profile email', state: session.state, nonce: session.nonce,
    code_challenge: challenge, code_challenge_method: 'S256',
  });
}

// 2. Callback: check state, exchange the code, verify the ID token.
export async function callback(session, query) {
  if (query.error) throw new Error('sign-in failed: ' + query.error);
  if (query.state !== session.state || query.iss !== issuer) throw new Error('state or issuer mismatch');
  const res = await fetch(issuer + '/oauth/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
      Authorization: 'Basic ' + Buffer.from(clientId + ':' + clientSecret).toString('base64'),
    },
    body: new URLSearchParams({ grant_type: 'authorization_code', code: query.code, redirect_uri: redirectUri, code_verifier: session.verifier }),
  });
  const tokens = await res.json();
  if (!res.ok) throw new Error(tokens.error);
  const claims = await verifyIdToken(tokens.id_token, session.nonce);
  return { sub: claims.sub, email: claims.email, name: claims.name, tokens };
}

async function verifyIdToken(idToken, nonce) {
  const [h, p, s] = idToken.split('.');
  const header = JSON.parse(Buffer.from(h, 'base64url'));
  const { keys } = await (await fetch(issuer + '/oauth/jwks')).json();
  const jwk = keys.find((k) => k.kid === header.kid);
  if (!jwk || header.alg !== 'ES256') throw new Error('unknown signing key');
  const ok = crypto.verify('sha256', Buffer.from(h + '.' + p),
    { key: crypto.createPublicKey({ key: jwk, format: 'jwk' }), dsaEncoding: 'ieee-p1363' }, Buffer.from(s, 'base64url'));
  const c = JSON.parse(Buffer.from(p, 'base64url'));
  const now = Math.floor(Date.now() / 1000);
  if (!ok || c.iss !== issuer || c.aud !== clientId || c.exp < now - 30 || c.nonce !== nonce) throw new Error('invalid ID token');
  return c;
}

Grenser

Autorisasjons- og tokenendepunktene har begrenset antall forespørsler. Får du HTTP 429, vent og prøv igjen; ikke prøv på nytt i en tett løkke.

Pliktene dine

Organisasjonen din er selvstendig behandlingsansvarlig for dataene den mottar. Utviklervilkårene for Dazr Identity fastsetter hva du kan gjøre med dem, hvordan du holder dem sikre og hvordan du melder brudd. Spørsmål: hello@dazr.eu.