Prihlásenie cez Dazr Identity: dokumentácia pre vývojárov

Štandardný OpenID Connect 1.0 s tokom autorizačného kódu a PKCE. Nie je potrebné žiadne SDK: funguje akákoľvek certifikovaná knižnica OpenID Connect aj obyčajný kód.

Ľudia už môžu vnútri Dazr Identity používať svoj účet Google alebo Microsoft, takže vaša aplikácia nepotrebuje vedľa neho samostatné tlačidlá Google a Microsoft: jedno tlačidlo namiesto troch.

Discovery a koncové body

Všetko je opísané v dokumente discovery. Nasmerujte svoju knižnicu na vydavateľa a zvyšok si nájde sama.

Registrácia aplikácie

• Aplikácie patria organizácii. Registrujú ich vlastníci a administrátori organizácie v časti Vývojári.
• Webové serverové aplikácie (dôverní klienti) dostanú tajomstvo klienta, zobrazené raz. Na tokenovom koncovom bode sa overujú cez HTTP Basic (client_secret_basic) alebo v tele formulára (client_secret_post).
• Jednostránkové a mobilné aplikácie (verejní klienti) žiadne tajomstvo nedostanú. Posielajú client_id a spoliehajú sa na PKCE.
• URI na presmerovanie sa musia presne zhodovať. Musia byť https://. Kým je aplikácia v testovaní, fungujú aj http://localhost a http://127.0.0.1 na ľubovoľnom porte.
• Adresa zásad ochrany osobných údajov, e-mail podpory a jednoriadkový účel sú povinné: ľudia ich vidia na obrazovke súhlasu.

Návody na integráciu

Každá nižšie uvedená technológia používa vlastnú štandardnú podporu OpenID Connect. Z konzoly potrebujete tri hodnoty: client ID, tajomstvo klienta (len webové serverové aplikácie) a URI na presmerovanie, ktoré ste zaregistrovali. Zvyšok pochádza z dokumentu discovery.

• Auth.js / NextAuth
• Next.js App Router
• WordPress
• Laravel
• Supabase
• Django
• Node.js (openid-client)
• Akákoľvek knižnica OpenID Connect

Auth.js / NextAuth

Auth.js (NextAuth.js v5) prijíma vlastný objekt poskytovateľa OpenID Connect. Zaregistrujte webovú serverovú aplikáciu, nastavte AUTH_SECRET, AUTH_DAZR_ID a AUTH_DAZR_SECRET a ako URI na presmerovanie použite túto URL spätného volania: 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 používa rovnaký princíp s type: "oauth" a discovery URL:

// 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

So súborom auth.ts vyššie pridajte obsluhu trasy a prihlasovacie tlačidlo, ktoré spustí serverovú akciu.

// 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>
  )
}

Tlačidlo naštýlujte podľa časti Tlačidlo. V callbackoch je Dazr sub hodnotou account.providerAccountId.

WordPress

Použite všeobecný klientsky plugin OpenID Connect, napríklad OpenID Connect Generic Client. Zaregistrujte webovú serverovú aplikáciu a vyplňte nastavenia pluginu hodnotami nižšie. Plugin na svojej stránke nastavení zobrazuje URI na presmerovanie na registráciu; predvolené je https://example.com/wp-admin/admin-ajax.php?action=openid-connect-authorize.

Názvy nastavení sa medzi pluginmi trochu líšia. Ak plugin nemá voľbu PKCE, zvoľte iný: Dazr Identity odmieta prihlásenia bez PKCE.

Laravel

Laravel Socialite nemá zabudovaný všeobecný ovládač OpenID Connect, preto pridajte malý vlastný ovládač. Posiela ľudí do Dazr s PKCE a číta používateľa z koncového bodu informácií o používateľovi. Socialite nečíta dokument discovery, preto sú koncové body vypísané. Zaregistrujte webovú serverovú aplikáciu s URI na presmerovanie 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 nemá všeobecného poskytovateľa OpenID Connect, ktorého by bolo možné nasmerovať na ľubovoľného vydavateľa: jeho poskytovatelia prihlásenia a integrácie overovania tretích strán sú pevné zoznamy. Dazr Identity preto dnes v riadiacom paneli Supabase pridať nemožno. Ak Supabase pridá všeobecnú podporu OpenID Connect, použite hodnoty z kontrolného zoznamu nižšie.

Alternatíva: prihlasujte ľudí cez Dazr Identity na vlastnom serveri (podľa niektorého z návodov na tejto stránke), ukladajte Dazr sub do svojej tabuľky používateľov a komunikujte so Supabase z tohto servera pomocou kľúča service role, s kontrolou prístupu vo vlastnom kóde. Kľúč service role nikdy neposielajte do prehliadača.

Django

Použite mozilla-django-oidc. Zaregistrujte webovú serverovú aplikáciu s URI na presmerovanie https://app.example.eu/oidc/callback/. Knižnica nečíta dokument discovery, preto sú koncové body vypísané.

# 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>

V predvolenom stave backend páruje používateľov podľa e-mailu. Ak chcete kľúčovať účty podľa sub, vytvorte podtriedu OIDCAuthenticationBackend a prepíšte filter_users_by_claims a create_user. Používajte aktuálnu verziu: staršie verzie nevedia overovať podpisy ES256.

Node.js (openid-client)

openid-client (verzia 6) číta dokument discovery a za vás kontroluje PKCE, state, nonce a ID token.

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 };
}

Akákoľvek knižnica OpenID Connect

Ak vaša technológia nie je uvedená, funguje akýkoľvek klient OpenID Connect. Skontrolujte tieto nastavenia:

• Vydavateľ https://identity.dazr.eu, discovery URL https://identity.dazr.eu/.well-known/openid-configuration.
• Typ odpovede code (tok autorizačného kódu). Žiadny implicitný ani hybridný tok.
• PKCE je povinné, s code_challenge_method=S256.
• Rozsahy: openid a len to, čo potrebujete z profile, email, address, organisations a offline_access. Vaša aplikácia musí byť registrovaná pre každý rozsah, o ktorý žiada.
• URI na presmerovanie: presne tak, ako je registrované v konzole, vrátane cesty a prípadného reťazca dopytu.
• Overenie klienta: client_secret_basic alebo client_secret_post pre webové serverové aplikácie, none pre jednostránkové a mobilné aplikácie.
• Podpis ID tokenu: ES256. Niektoré knižnice predpokladajú RS256: nastavte algoritmus na ES256.
• Ako kľúč účtu používajte sub. Je párový, pre každú organizáciu iný.
• S offline_access ukladajte po každom obnovení nový obnovovací token: rotujú.

Tok

1. Vytvorte náhodný code_verifier (43 až 128 znakov) a jeho code_challenge = base64url(SHA-256(verifier)). Vytvorte náhodné state a nonce. Všetky tri uchovávajte v relácii používateľa.
2. Presmerujte na autorizačný koncový bod s response_type=code, client_id, redirect_uri, scope (vždy vrátane openid), state, nonce, code_challenge a code_challenge_method=S256.
3. Osoba sa v prípade potreby prihlási a uvidí obrazovku súhlasu so skutočnými údajmi. Keď súhlas udelí, vráti sa na vaše URI na presmerovanie s code, state a iss. Overte, že state sa zhoduje a iss je https://identity.dazr.eu.
4. Na svojom serveri pošlite POST na tokenový koncový bod s grant_type=authorization_code, code, rovnakým redirect_uri a code_verifier.
5. Overte ID token: podpis ES256 kľúčom z JWKS (zhoda kid), iss, aud = vaše client ID, exp a váš nonce. Ako kľúč účtu používajte sub.

Parameter prompt prijíma none (odpovie hneď s login_required alebo consent_required, ak by osoba musela niečo urobiť), login (požiada osobu o nové prihlásenie) a consent (zobrazí obrazovku súhlasu, aj keď bol predtým udelený). max_age je podporované. Zapamätaný súhlas: ak osoba predtým schválila rovnaké rozsahy, vráti sa rovno do vašej aplikácie. Ak neskôr požiadate o viac, obrazovka súhlasu uvedie len to, čo je nové.

Rozsahy a claimy

Žiadajte len o to, čo potrebujete. Nič mimo tejto tabuľky neexistuje: žiadne kontakty, žiadne súbory, žiadne heslá.

Claimy sa objavujú v ID tokene pre rozsahy, ktoré osoba schválila. Koncový bod informácií o používateľovi vracia rovnakú sadu s aktuálnymi hodnotami.

Overené organizácie

Dazr overí organizáciu len vtedy, keď oficiálne zdroje preukážu dve veci: kto daná osoba je a že zastupuje túto organizáciu s jej názvom, číslom v registri a IČ DPH. Zvyčajne konateľ podpíše krátke vyhlásenie kvalifikovaným elektronickým podpisom (QES) a pridá výpis z obchodného registra, ktorý ho uvádza; s výpisom zapečateným registrom, ako je talianska visura alebo holandský výpis z KvK, je to okamžité, inak ho skontroluje Dazr. Samotný kvalifikovaný podpis nikdy organizáciu overenou neurobí. Každá organizácia v claime organisations nesie svoj aktuálny stav overenia:

Len keď je stav verified, hovorí verification.authority (a authority vo webhookoch), ako bolo preukázané spojenie medzi osobou a organizáciou:

Logická hodnota verified zostáva kvôli kompatibilite a rovná sa verification.status === 'verified'. Každá organizácia má tiež id, rovnaké, aké používajú webhooky.

Keď je stav pending alebo verified, je verification.report_url adresou jej správy o overení.

"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 a členstvo sa znovu načítavajú pri každom obnovení tokenu a požiadavke na informácie o používateľovi: po zmene roly nesie ďalšia odpoveď novú rolu a organizácia, z ktorej osoba odišla alebo bola odobratá, už nie je zahrnutá. Keď administrátor organizácie odpojí vašu aplikáciu, organizácia sa vynechá z predtým vydaných tokenov, kým ju člen pri novom prihlásení s vašou aplikáciou znovu nezdieľa. display_name a website sú null, ak ich organizácia nenastavila; name je vždy obchodné meno.

Vyžadovať overenú organizáciu

V konzole nastavte Vyžadovať overenú organizáciu na Overenie začaté alebo Overené, alebo o to požiadajte pri jednotlivej požiadavke pomocou acr_values=urn:dazr:org:verification-started alebo acr_values=urn:dazr:org:verified (platí prísnejšie z oboch). Vaša aplikácia musí tiež žiadať o rozsah organisations.

Kto nemá vyhovujúcu organizáciu, prejde tým v tom istom prihlásení: meno, organizácia (s IČ DPH overeným vo VIES) a potom overenie. Môže podpísať hneď, nechať si vyhlásenie poslať e-mailom alebo určiť niekoho iného, kto podpíše. Potom označí organizáciu na obrazovke súhlasu (označiť možno len vyhovujúce organizácie) a vráti sa na vaše URI na presmerovanie.

Ak musí podpísať ešte niekto iný, osoba sa vráti so stavom pending, aj keď ste požiadali o Overené: dostanete kód, claim uvádza pending a acr v ID tokene je urn:dazr:org:verification-started namiesto urn:dazr:org:verified. Vždy rozhodujte podľa verification.status, nikdy podľa toho, že prihlásenie prebehlo úspešne. S prompt=none dostanete interaction_required, keď požiadavka nie je splnená.

Zmeny nastavenia platia od ďalšieho prihlásenia. Už prihlásení ľudia sa neodhlásia: odpovede pri obnovení, koncový bod informácií o používateľovi a webhooky vždy nesú aktuálny stav, preto na ne pri existujúcich reláciách reagujte.

Webhooky

Pridajte v konzole URL webhooku (https). Podpisové tajomstvo uvidíte raz; môžete ho vymeniť. Dazr posiela organisation.verification.updated, keď organizácia, ktorú niektorý z vašich používateľov zdieľal s vašou aplikáciou, prejde do stavu pending, verified, failed alebo unverified. Aplikácie, ktoré nikdy nedostali organizáciu prostredníctvom súhlasu, sa o nej nikdy nedozvedia.

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 je pending, verified, failed alebo unverified. subjects sú hodnoty sub vo vašej aplikácii pri ľuďoch, ktorí s ňou túto organizáciu zdieľali. Skôr než telu požiadavky začnete dôverovať, overte podpis:

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

Odpovedzte akýmkoľvek kódom 2xx do 8 sekúnd. Inak Dazr skúsi doručenie znovu približne po 5 minútach, 30 minútach, 2, 6, 12 a 24 hodinách a potom doručenie označí ako neúspešné. Každý pokus má rovnaké ID Dazr-Delivery, takže duplikáty ignorujte. Konzola zobrazuje nedávne doručenia, vie jedno znovu odoslať a môže poslať testovaciu udalosť (webhook.test). Funguje aj dopytovanie koncového bodu informácií o používateľovi.

Správy o overení na audity

Pre každú organizáciu zdieľanú s vašou aplikáciou si môžete stiahnuť správu o tom, ako a kedy ju Dazr overil, do svojho auditného spisu. Existuje, kým je organizácia overená, a počas prebiehajúceho overenia, keď ukazuje, čo je zatiaľ hotové.

• Organizácia: názov, krajina, číslo v registri, IČ DPH a sídlo.
• Overenie: stav, metóda, oprávnenie a kedy bolo vyžiadané, podpísané a dokončené.
• Dôkazy: pri kvalifikovanom podpise alebo pečati meno podpisujúceho podľa certifikátu, vydavateľ certifikátu, sériové číslo, platnosť a odtlačok SHA-256, jeho kvalifikovaný status (vyhlásenia QC, poskytovateľ dôveryhodných služieb a služba z dôveryhodného zoznamu EÚ, s poradovým číslom a dátumom vydania zoznamu), čas podpisu a kontrola zrušenia. Pri výpise zapečatenom registrom kto ho zapečatil, kedy a čo sa zhodovalo: názov, číslo v registri, IČ DPH, konateľ. Výsledok VIES. Pri kóde cez PEC, liste alebo videohovore dátumy a kontroly, ktoré označil pracovník Dazr, zobrazený ako „Pracovník Dazr“ s interným ID.
• Pre vaše spisy: odtlačok SHA-256 každého súboru s dôkazmi, ID dokumentu, kedy bola správa vygenerovaná, a krátke vysvetlenie každej metódy a toho, čo znamená oprávnenie.

Správa nikdy neobsahuje snímky ani čísla dokladov totožnosti, jednorazové kódy, adresu PEC, e-mailové adresy ani inú adresu než sídlo.

Stiahnutie správy

Overte sa svojím client ID a tajomstvom klienta, rovnako ako pri tokenovom koncovom bode: HTTP Basic (client_secret_basic) alebo telo formulára požiadavky POST (client_secret_post). Nikdy nevkladajte tajomstvo do URL. Použite id organizácie z claimov alebo webhookov, alebo jednoducho verification.report_url, ktoré obsahujú.

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"

Stiahnuť možno len organizácie, ktoré s vašou aplikáciou prostredníctvom súhlasu zdieľal aspoň jeden z vašich používateľov. Akákoľvek iná organizácia odpovie 404, rovnako ako organizácia, ktorá neexistuje alebo nemá overenie; nesprávne tajomstvo klienta odpovie 401. Aplikácie bez tajomstva klienta nemôžu správy sťahovať. Sťahovanie má obmedzený počet požiadaviek a každé sa zobrazí v aktivite organizácie jej administrátorom, s názvom vašej aplikácie. V konzole stránka vašej aplikácie uvádza prepojené organizácie s rovnakými možnosťami stiahnutia.

Overenie podpísaného JSON

S format=jws dostanete kompaktný JWS (ES256, hlavička typ dazr-verification-report+jwt), podpísaný rovnakými kľúčmi ako ID tokeny. Jeho claimy sú iss, iat, jti (ID dokumentu), sub (id organizácie), aud (vaše client ID) a report, fakty. PDF nesie rovnaký JWS na poslednej strane a v metadátach (DazrVerificationReport), takže aj PDF možno overiť offline.

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);

Nechajte audítora overiť podpis

Pri kvalifikovanom podpise alebo pečati vracia doc=declaration podpísané vyhlásenie presne tak, ako bolo nahrané: podpísané PDF (PAdES) alebo súbor .p7m (CAdES). Audítor ho môže nezávisle overiť ukážkovým validátorom DSS Európskej komisie: nahrajte súbor, ponechajte predvolenú validačnú politiku a spustite ho. Výsledok ukáže, či je podpis kvalifikovaný (QESig, pri pečati QESeal), kto podpísal a poskytovateľa dôveryhodných služieb z dôveryhodného zoznamu EÚ. doc=extract vracia výpis z obchodného registra; výpis zapečatený registrom možno overiť rovnakým spôsobom.

Správa je dôkazom pre váš auditný spis. Regulované firmy zostávajú zodpovedné za vlastnú hĺbkovú kontrolu zákazníkov.

Dazr uchováva podpísané vyhlásenie, výpis a údaje správy, kým je organizácia overená, a 5 rokov po skončení jej overenia alebo odstránení organizácie. Vlastné kópie si uchovávajte tak dlho, ako vyžadujú vaše pravidlá.

Tokeny a ich platnosť

Podpisové kľúče sa menia. Vždy vyberajte kľúč podľa kid z JWKS a JWKS obnovte, keď uvidíte neznáme kid.

Chyby

Kým sú vaše client ID a URI na presmerovanie platné, chyby sa vracajú na vaše URI na presmerovanie ako error, error_description, state a iss: napríklad invalid_request (napríklad chýbajúce alebo plain PKCE), invalid_scope, unsupported_response_type, access_denied (osoba akciu zrušila, alebo je aplikácia v testovaní a osoba nie je členom), login_required, consent_required a interaction_required (s prompt=none, keď chýba požadovaná overená organizácia). Pri neznámom klientovi alebo neregistrovanom URI na presmerovanie zobrazí Dazr chybovú stránku a nikdy nepresmeruje. Tokenový koncový bod odpovedá chybami vo formáte JSON, napríklad invalid_client, invalid_grant a unsupported_grant_type.

Odhlásenie

Ak chcete niekoho odhlásiť, pošlite ho na koncový bod odhlásenia s id_token_hint (alebo client_id), voliteľným post_logout_redirect_uri registrovaným v nastaveniach aplikácie a state. Dazr sa opýta, či sa chce na tomto zariadení odhlásiť aj z Dazr Identity, a potom ho pošle späť. Obnovovacie tokeny, ktoré už nepotrebujete, zrušte na koncovom bode na zrušenie.

Testovanie a spustenie

Nová aplikácia je v testovaní: prihlásiť sa môžu len členovia vašej organizácie a obrazovka súhlasu to uvádza. Na spustenie nechajte svoju organizáciu overiť v Dazr Identity, pridajte URI na presmerovanie https:// a v konzole požiadajte o kontrolu na spustenie. Zmena názvu, účelu, zásad ochrany osobných údajov alebo údajov spustenej aplikácie vyžaduje novú kontrolu.

Prevod aplikácie na inú organizáciu

Aplikácia sa môže presunúť k inej organizácii registrovanej v Dazr, napríklad po predaji alebo reorganizácii. Prevod začne vlastník alebo administrátor v časti Previesť aplikáciu v nastaveniach aplikácie, v Dazr Identity alebo v portáli Sign. Vlastník alebo administrátor druhej organizácie ho do 14 dní prijme alebo odmietne. Dovtedy môže odosielateľ prevod zrušiť a nič sa nemení.

• Kto ju môže prijať. Len organizácia registrovaná v Dazr, určená svojím ID organizácie. Jej vlastníci a administrátori nájdu ID v jej právnych údajoch v Dazr Identity. Spustená aplikácia, aplikácia v kontrole, aplikácia vyžadujúca overenú organizáciu a aplikácia so zapnutým API Dazr Sign sa môžu presunúť len k overenej organizácii. Pri prijatí prevodu sa to overuje znovu.
• Nedávne prihlásenie. Začatie aj prijatie prevodu vyžadujú prihlásenie z posledných 10 minút.
• Čo sa presúva. Client ID, nastavenia, logo, URI na presmerovanie, zapnuté API a URL webhookov. Administrátor, ktorý prevod prijme, zároveň prijíma Podmienky pre vývojárov za novú organizáciu.
• Tajomstvo klienta. Webová serverová aplikácia dostane nové tajomstvo klienta, zobrazené raz administrátorovi, ktorý prevod prijme. Predchádzajúce tajomstvo funguje na tokenovom koncovom bode, koncovom bode na zrušenie a introspekciu počas prechodného obdobia zvoleného pri začatí prevodu: žiadne, 24 hodín (predvolené) alebo 7 dní. Správy o overení vyžadujú nové tajomstvo.
• Webhooky. URL zostávajú. Ich podpisové tajomstvá, pre Dazr Identity aj pre Dazr Sign, sa obnovia a zobrazia raz administrátorovi, ktorý prevod prijme. Doručenia z obdobia pred prevodom sa znovu neodosielajú.
• Ľudia a ich sub. Každá osoba si v aplikácii ponechá rovnaké sub, takže účty vo vašej aplikácii ďalej fungujú. Líši sa od jej sub v ostatných aplikáciách novej organizácie. Ľudia aplikáciu pri ďalšom prihlásení znovu schvália, pretože obrazovka súhlasu teraz uvádza novú organizáciu. Tokeny vydané pred prevodom prestanú fungovať.
• Čo zostáva predchádzajúcemu vlastníkovi. Počty prihlásení a súhlasov a doručenia webhookov z obdobia pred prevodom. Dokumenty vytvorené cez API Dazr Sign zostávajú ľuďom, ktorým patria, a nový vlastník aplikácie ich nevidí.

Tlačidlo

Použite text „Prihlásiť sa cez Dazr Identity“ a logo Dazr podľa ukážky nižšie. Veľkosť môžete zmeniť, logo, farby ani text nie. Prepojte ho s vlastnou trasou, ktorá spustí tok.

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>

Písmo Dazr. Tlačidlo používa písmo Dazr, ktoré možno voľne používať podľa SIL Open Font License. Kde písmo Dazr nie je načítané, použije sa systémové písmo. Stiahnite si písmo Dazr (ZIP so súbormi TTF a WOFF2) a hostujte ho na vlastnom webe:

/* 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; }

Minimálny príklad v Node.js

Node 18 alebo novší, bez závislostí. Webová serverová aplikácia s tajomstvom klienta; pri verejnom klientovi vynechajte hlavičku Authorization a pošlite client_id v tele.

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;
}

Limity

Autorizačný a tokenový koncový bod majú obmedzený počet požiadaviek. Ak dostanete HTTP 429, počkajte a skúste to znova; neopakujte požiadavky v rýchlej slučke.

Vaše povinnosti

Vaša organizácia je pre údaje, ktoré dostane, samostatným prevádzkovateľom. Podmienky pre vývojárov Dazr Identity stanovujú, čo s nimi smiete robiť, ako ich zabezpečiť a ako hlásiť porušenia. Otázky: hello@dazr.eu.