TypeScript skaitmeniniai parašai: išsamus autentifikavimo tipo saugos vadovas

Mūsų itin susietoje pasaulinėje ekonomikoje skaitmeninis pasitikėjimas yra didžiausia valiuta. Nuo finansinių operacijų iki saugių ryšių ir teisiškai įpareigojančių susitarimų, patikrinamo, apsaugoto nuo klastojimo skaitmeninio tapatumo poreikis niekada nebuvo toks svarbus. Šio skaitmeninio pasitikėjimo pagrindas yra skaitmeninis parašas – kriptografinis stebuklas, užtikrinantis autentifikavimą, vientisumą ir neginčijamumą. Tačiau įgyvendinti šiuos sudėtingus kriptografinius primityvus yra pavojinga. Viena netinkamai įdėta kintamoji, neteisingas duomenų tipas arba subtili loginė klaida gali tyliai pakenkti visam saugumo modeliui ir sukelti katastrofiškų pažeidžiamumų.

Kūrėjams, dirbantiems JavaScript ekosistemoje, šis iššūkis yra dar didesnis. Kalbos dinamiškas, laisvo tipo pobūdis suteikia neįtikėtino lankstumo, tačiau atveria duris klaidų klasei, kuri ypač pavojinga saugumo kontekste. Kai perduodate slaptus kriptografinius raktus ar duomenų buferius, paprastas tipo prievartavimas gali lemti saugų ar nenaudingą parašą. Čia TypeScript iškyla ne tik kaip patogumas kūrėjams, bet ir kaip esminė saugumo priemonė.

Šiame išsamiame vadove nagrinėjama Autentifikavimo tipo saugos koncepcija. Mes išnagrinėsime, kaip TypeScript statinio tipo sistema gali būti naudojama skaitmeninio parašo diegimams sustiprinti, paverčiant jūsų kodą iš galimų vykdymo metu klaidų minų lauko į kompiliavimo metu saugumo garantijų bastioną. Mes pereisime nuo pagrindinių sąvokų prie praktinių, realaus pasaulio kodo pavyzdžių, demonstruojančių, kaip sukurti patikimesnes, prižiūrimos ir akivaizdžiai saugesnes autentifikavimo sistemas pasaulinei auditorijai.

Pagrindai: greitas skaitmeninių parašų priminimas

Prieš gilindamiesi į TypeScript vaidmenį, susitarkime dėl aiškaus, bendro supratimo, kas yra skaitmeninis parašas ir kaip jis veikia. Tai daugiau nei tik ranka rašyto parašo nuskaitytas vaizdas; tai galingas kriptografinis mechanizmas, pastatytas ant trijų pagrindinių ramsčių.

1 ramstis: maišos funkcijos duomenų vientisumui

Įsivaizduokite, kad turite dokumentą. Norėdami užtikrinti, kad niekas nepakeis nė vienos raidės jums nežinant, paleiskite jį per maišos funkcijos algoritmą (pvz., SHA-256). Šis algoritmas sukuria unikalią, fiksuoto dydžio simbolių eilutę, vadinamą maišos kodu arba pranešimo santrauka. Tai vienpusis procesas; negalite atgauti originalaus dokumento iš maišos kodo. Svarbiausia, kad jei pasikeis bent vienas originalaus dokumento bitas, gautas maišos kodas bus visiškai kitoks. Tai užtikrina duomenų vientisumą.

2 ramstis: asimetrinis šifravimas autentifikavimui ir neginčijamumui

Čia vyksta magija. Asimetrinis šifravimas, dar žinomas kaip viešojo rakto kriptografija, apima matematiškai susietų raktų porą kiekvienam vartotojui:

• Privatus raktas: savininkas jį laiko visiškai paslaptyje. Jis naudojamas pasirašymui.
• Viešasis raktas: laisvai dalijamasi su pasauliu. Jis naudojamas patikrinimui.

Viskas, kas užšifruota privačiu raktu, gali būti iššifruota tik atitinkamu viešuoju raktu. Šis ryšys yra pasitikėjimo pagrindas.

Pasirašymo ir patikrinimo procesas

Apjunkime visa tai į paprastą darbo eigą:

1. Pasirašymas:
   • Alicija nori nusiųsti pasirašytą sutartį Bobui.
   • Pirmiausia ji sukuria sutarties dokumento maišos kodą.
   • Tada ji naudoja savo privatų raktą, kad užšifruotų šį maišos kodą. Šis užšifruotas maišos kodas yra skaitmeninis parašas.
   • Alicija siunčia originalų sutarties dokumentą kartu su savo skaitmeniniu parašu Bobui.
2. Patikrinimas:
   • Bobas gauna sutartį ir parašą.
   • Jis paima gautą sutarties dokumentą ir apskaičiuoja jo maišos kodą naudodamas tą patį maišos funkcijos algoritmą, kurį naudojo Alicija.
   • Tada jis naudoja Alicijos viešąjį raktą (kurį gali gauti iš patikimo šaltinio), kad iššifruotų jos atsiųstą parašą. Tai atskleidžia jos apskaičiuotą originalų maišos kodą.
   • Bobas palygina du maišos kodus: tą, kurį apskaičiavo pats, ir tą, kurį iššifravo iš parašo.

Jei maišos kodai sutampa, Bobas gali būti tikras dėl trijų dalykų:

• Autentifikavimas: tik Alicija, privataus rakto savininkė, galėjo sukurti parašą, kurį galėtų iššifruoti jos viešasis raktas.
• Vientisumas: dokumentas nebuvo pakeistas gabenant, nes jo apskaičiuotas maišos kodas atitinka tą, kuris yra iš parašo.
• Neginčijamumas: Alicija negali vėliau paneigti pasirašiusi dokumentą, nes tik ji turi privatų raktą, reikalingą parašui sukurti.

JavaScript iššūkis: kur slepiasi su tipais susiję pažeidžiamumai

Idealiame pasaulyje aukščiau aprašytas procesas yra nepriekaištingas. Realiame programinės įrangos kūrimo pasaulyje, ypač naudojant paprastą JavaScript, subtilios klaidos gali sukurti didžiules saugumo spragas.

Apsvarstykite tipinę kripto bibliotekos funkciją Node.js:

// Hipotetinė paprasta JavaScript pasirašymo funkcija
function createSignature(data, privateKey, algorithm) {
const sign = crypto.createSign(algorithm);
sign.update(data);
sign.end();
const signature = sign.sign(privateKey, 'base64');
return signature;
}

Tai atrodo pakankamai paprasta, bet kas gali nutikti ne taip?

• Neteisingas duomenų tipas `data`: Metodas `sign.update()` dažnai tikisi `string` arba `Buffer`. Jei kūrėjas netyčia perduoda skaičių (`12345`) arba objektą (`{ id: 12345 }`), JavaScript gali netiesiogiai konvertuoti jį į eilutę (`"12345"` arba `"[object Object]"`). Parašas bus sugeneruotas be klaidos, bet jis bus skirtas neteisingiems pagrindiniams duomenims. Tada patikrinimas nepavyks, todėl atsiras erzinančių ir sunkiai diagnozuojamų klaidų.
• Netinkamai tvarkomi raktų formatai: Metodas `sign.sign()` yra išrankus `privateKey` formatui. Tai gali būti eilutė PEM formatu, `KeyObject` arba `Buffer`. Neteisingo formato siuntimas gali sukelti vykdymo metu gedimą arba, dar blogiau, tylų gedimą, kai sukuriamas negaliojantis parašas.
• `null` arba `undefined` reikšmės: Kas nutiks, jei `privateKey` yra `undefined` dėl nesėkmingos duomenų bazės paieškos? Programa sugrius vykdymo metu, potencialiai atskleisdama vidinę sistemos būseną arba sukurdama paslaugos trikdymo pažeidžiamumą.
• Algoritmo neatitikimas: Jei pasirašymo funkcija naudoja `'sha256'`, bet tikrintojas tikisi parašo, sugeneruoto su `'sha512'`, patikrinimas visada nepavyks. Be tipo sistemos vykdymo, tai priklauso tik nuo kūrėjo disciplinos ir dokumentacijos.

Tai nėra tik programavimo klaidos; tai yra saugumo trūkumai. Neteisingai sugeneruotas parašas gali lemti galiojančių operacijų atmetimą arba, sudėtingesniais atvejais, atverti atakos vektorius parašo manipuliavimui.

TypeScript į pagalbą: autentifikavimo tipo saugos įgyvendinimas

TypeScript suteikia įrankius, leidžiančius pašalinti šias visų klasių klaidas, kol kodas dar nėra vykdomas. Sukurdami tvirtą duomenų struktūrų ir funkcijų sutartį, mes perkeliame klaidų aptikimą iš vykdymo į kompiliavimo laiką.

1 žingsnis: pagrindinių kriptografinių tipų apibrėžimas

Pirmas žingsnis yra modeliuoti mūsų kriptografinius primityvus su aiškiais tipais. Vietoj to, kad perduotume bendrines `string` arba `any`, mes apibrėžiame tikslias sąsajas arba tipo slapyvardžius.

Galinga technika čia yra prekės ženklo tipų (arba nominalaus tipų nustatymo) naudojimas. Tai leidžia mums sukurti skirtingus tipus, kurie yra struktūriškai identiški `string`, bet nėra sukeičiami, o tai puikiai tinka raktams ir parašams.

// types.ts
export type Brand = K & { __brand: T };
// Raktų nereikėtų traktuoti kaip bendrinių eilučių
export type PrivateKey = Brand;
export type PublicKey = Brand;
// Parašas taip pat yra specifinis eilutės tipas (pvz., base64)
export type Signature = Brand;
// Apibrėžkite leidžiamų algoritmų rinkinį, kad išvengtumėte rašybos klaidų ir netinkamo naudojimo
export enum SignatureAlgorithm {
RS256 = 'RSA-SHA256',
ES256 = 'ECDSA-SHA256',
// Čia pridėkite kitus palaikomus algoritmus
}
// Apibrėžkite pagrindinę sąsają bet kokiems duomenims, kuriuos norime pasirašyti
export interface Signable {
// Galime užtikrinti, kad bet koks pasirašomasis turinys būtų serializuojamas
// Paprastumo dėlei čia leisime bet kokį objektą, bet gamyboje
// galite įgyvendinti struktūrą, pvz., { [key: string]: string | number | boolean; }
[key: string]: any;
}

Su šiais tipais kompiliatorius dabar išmes klaidą, jei bandysite naudoti `PublicKey`, kai tikimasi `PrivateKey`. Negalite tiesiog perduoti jokios atsitiktinės eilutės; ji turi būti aiškiai konvertuota į prekės ženklo tipą, signalizuojant aiškų ketinimą.

2 žingsnis: tipo saugos pasirašymo ir patikrinimo funkcijų kūrimas

Dabar perrašykime savo funkcijas naudodami šiuos stiprius tipus. Šiame pavyzdyje naudosime Node.js įmontuotą `crypto` modulį.

// crypto.service.ts
import * as crypto from 'crypto';
import { PrivateKey, PublicKey, Signature, SignatureAlgorithm, Signable } from './types';
export class DigitalSignatureService {
public sign(
payload: T,
privateKey: PrivateKey,
algorithm: SignatureAlgorithm
): Signature {
// Siekiant nuoseklumo, mes visada eilutėmis paverčiame turinį deterministiškai.
// Rūšiavimo raktai užtikrina, kad {a:1, b:2} ir {b:2, a:1} sukuria tą patį maišos kodą.
const stringifiedPayload = JSON.stringify(payload, Object.keys(payload).sort());
const signer = crypto.createSign(algorithm); signer.update(stringifiedPayload); signer.end();
const signature = signer.sign(privateKey, 'base64');
return signature as Signature;
}
public verify(
payload: T,
signature: Signature,
publicKey: PublicKey,
algorithm: SignatureAlgorithm
): boolean {
const stringifiedPayload = JSON.stringify(payload, Object.keys(payload).sort());
const verifier = crypto.createVerify(algorithm); verifier.update(stringifiedPayload); verifier.end();
return verifier.verify(publicKey, signature, 'base64');
}
}

Pažvelkite į funkcijos parašų skirtumą:

• `sign(payload: T, privateKey: PrivateKey, ...)`: Dabar neįmanoma netyčia perduoti viešojo rakto ar bendrinės eilutės kaip `privateKey`. Turinys yra apribotas sąsaja `Signable`, o mes naudojame generics (``), kad išsaugotume specifinį turinio tipą.
• `verify(..., signature: Signature, publicKey: PublicKey, ...)`: Argumentai yra aiškiai apibrėžti. Negalite sumaišyti parašo ir viešojo rakto.
• `algorithm: SignatureAlgorithm`: Naudodami enum, mes užkertame kelią rašybos klaidoms (`'RSA-SHA256'` vs `'RSA-sha256'`) ir apribojame kūrėjams iš anksto patvirtintų saugių algoritmų sąrašą, užkertant kelią kriptografijos žeminimo atakoms kompiliavimo metu.

3 žingsnis: praktinis pavyzdys su JSON žiniatinklio žetonais (JWT)

Skaitmeniniai parašai yra JSON žiniatinklio parašų (JWS) pagrindas, kurie dažnai naudojami JSON žiniatinklio žetonams (JWT) kurti. Pritaikykime savo tipo saugos modelius šiam visur esančiam autentifikavimo mechanizmui.

Pirmiausia apibrėžiame griežtą tipą mūsų JWT turiniui. Vietoj bendrinio objekto mes nurodome kiekvieną numatomą pretenziją ir jos tipą.

// types.ts (išplėstas)
export interface UserTokenPayload extends Signable {
iss: string; // Leidėjas sub: string; // Subjektas (pvz., vartotojo ID) aud: string; // Auditorija exp: number; // Galiojimo laikas (Unix laiko žyma) iat: number; // Išduotas (Unix laiko žyma) jti: string; // JWT ID roles: string[]; // Pasirinktinė pretenzija }

Dabar mūsų žetonų generavimo ir patvirtinimo paslauga gali būti griežtai susieta su šiuo konkrečiu turiniu.

// auth.service.ts
import { DigitalSignatureService } from './crypto.service';
import { PrivateKey, PublicKey, SignatureAlgorithm, UserTokenPayload } from './types';
class AuthService {
private signatureService = new DigitalSignatureService();
private privateKey: PrivateKey; // Įkeltas saugiai private publicKey: PublicKey; // Viešai prieinamas
constructor(pk: PrivateKey, pub: PublicKey) {
this.privateKey = pk;
this.publicKey = pub;
}
// Funkcija dabar skirta tik vartotojo žetonų kūrimui public generateUserToken(userId: string, roles: string[]): string {
const now = Math.floor(Date.now() / 1000); const payload: UserTokenPayload = {
iss: 'https://api.my-global-app.com',
aud: 'my-global-app-clients', sub: userId, roles: roles, iat: now,
exp: now + (60 * 15), // 15 minučių galiojimas jti: crypto.randomBytes(16).toString('hex'),
};
// JWS standartas naudoja base64url kodavimą, o ne tik base64 const header = { alg: 'RS256', typ: 'JWT' }; // Algoritmas turi atitikti rakto tipą const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64url'); const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64url');
// Mūsų tipo sistema nesupranta JWS struktūros, todėl turime ją sukurti. // Tikras diegimas naudotų biblioteką, bet parodykime principą. // Pastaba: parašas turi būti ant eilutės 'encodedHeader.encodedPayload'. // Paprastumo dėlei naudosime turinio objektą tiesiogiai naudodami mūsų paslaugą. const signature = this.signatureService.sign(
payload,
this.privateKey,
SignatureAlgorithm.RS256 );
// Tinkama JWT biblioteka tvarkytų parašo base64url konvertavimą. // Tai supaprastintas pavyzdys, skirtas parodyti tipo saugą ant turinio. return `${encodedHeader}.${encodedPayload}.${signature}`; }
public validateAndDecodeToken(token: string): UserTokenPayload | null {
// Realiame pranešime naudotumėte tokią biblioteką kaip 'jose' arba 'jsonwebtoken', // kuri tvarkytų analizavimą ir patikrinimą. const [header, payload, signature] = token.split('.');
if (!header || !payload || !signature) {
return null; // Neteisingas formatas }
try {
const decodedPayload: unknown = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
// Dabar naudojame tipo apsaugą, kad patvirtintume iškoduotą objektą if (!this.isUserTokenPayload(decodedPayload)) { console.error('Iškoduotas turinys neatitinka numatomos struktūros.'); return null; }
// Dabar galime saugiai naudoti decodedPayload kaip UserTokenPayload const isValid = this.signatureService.verify(
decodedPayload,
signature as Signature, // Čia turime konvertuoti iš eilutės this.publicKey,
SignatureAlgorithm.RS256 );
if (!isValid) { console.error('Parašo patikrinimas nepavyko.'); return null; }
if (decodedPayload.exp * 1000 < Date.now()) { console.error('Žetono galiojimo laikas baigėsi.'); return null; } return decodedPayload;
} catch (error) { console.error('Klaida tikrinant žetoną:', error); return null; } } // Tai yra esminė tipo apsaugos funkcija private isUserTokenPayload(payload: unknown): payload is UserTokenPayload { if (typeof payload !== 'object' || payload === null) return false; const p = payload as { [key: string]: unknown }; return ( typeof p.iss === 'string' && typeof p.sub === 'string' && typeof p.aud === 'string' && typeof p.exp === 'number' && typeof p.iat === 'number' && typeof p.jti === 'string' && Array.isArray(p.roles) && p.roles.every(r => typeof r === 'string') ); } }

Tipo apsauga `isUserTokenPayload` yra tiltas tarp netipuoto, nepatikimo išorinio pasaulio (gaunamos žetono eilutės) ir mūsų saugios, tipuotos vidinės sistemos. Kai ši funkcija grąžina `true`, TypeScript žino, kad kintamasis `decodedPayload` atitinka sąsają `UserTokenPayload`, leidžiančią saugiai pasiekti tokias savybes kaip `decodedPayload.sub` ir `decodedPayload.exp` be jokių `any` konvertavimų ar baimės dėl `undefined` klaidų.

Architektūriniai modeliai keičiamo dydžio tipo saugiam autentifikavimui

Tipo saugos taikymas nėra tik atskiros funkcijos; tai yra visos sistemos, kurioje saugumo sutartys įgyvendinamos kompiliatoriaus, kūrimas. Štai keletas architektūrinių modelių, kurie išplečia šias privilegijas.

Tipo saugykla

Daugelyje sistemų kriptografinius raktus valdo raktų valdymo paslauga (KMS) arba saugomi saugiame saugykloje. Kai gaunate raktą, turėtumėte užtikrinti, kad jis būtų grąžintas su teisingu tipu.

Vietoj tokios funkcijos kaip `getKey(keyId: string): Promise`, sukurkite paslaugą, kuri grąžina griežtai tipuotus raktus.

// key.repository.ts
import { PublicKey, PrivateKey } from './types';
interface KeyRepository {
getPublicKey(keyId: string): Promise;
getPrivateKey(keyId: string): Promise;
}
// Pavyzdinis įgyvendinimas (pvz., gavimas iš AWS KMS arba Azure Key Vault) class KmsRepository implements KeyRepository {
public async getPublicKey(keyId: string): Promise {
// ... logika, skirta paskambinti KMS ir gauti viešojo rakto eilutę ... const keyFromKms: string | undefined = await someKmsSdk.getPublic(keyId); if (!keyFromKms) return null; return keyFromKms as PublicKey; // Konvertuoti į mūsų firminį tipą }
public async getPrivateKey(keyId: string): Promise {
// ... logika, skirta paskambinti KMS, kad būtų galima naudoti privatų raktą pasirašymui ... // Daugelyje KMS sistemų niekada negaunate paties privataus rakto, perduodate duomenis, kad juos pasirašytumėte. // Šis modelis vis dar taikomas grąžinamam parašui. return '... saugiai gautas raktas ...' as PrivateKey; } }

Abstraktuojant raktų gavimą už šios sąsajos, likusiai jūsų programos daliai nereikia jaudintis dėl eilutės tipo KMS API pobūdžio. Ji gali pasikliauti gavusi `PublicKey` arba `PrivateKey`, užtikrinant, kad tipo sauga tekėtų per visą jūsų autentifikavimo krūvą.

Teiginių funkcijos įvesties patvirtinimui

Tipo apsaugos yra puikios, bet kartais norite išmesti klaidą iš karto, jei patvirtinimas nepavyksta. TypeScript raktinis žodis `asserts` puikiai tinka tam.

// Mūsų tipo apsaugos modifikacija
function assertIsUserTokenPayload(payload: unknown): asserts payload is UserTokenPayload {
if (!isUserTokenPayload(payload)) {
throw new Error('Neteisinga žetono turinio struktūra.');
} }

Dabar savo patvirtinimo logikoje galite tai padaryti:

const decodedPayload: unknown = JSON.parse(...);
assertIsUserTokenPayload(decodedPayload);
// Nuo šiol TypeScript ŽINO, kad decodedPayload yra UserTokenPayload tipo
console.log(decodedPayload.sub); // Tai dabar yra 100% tipo sauga

Šis modelis sukuria švaresnį, lengviau įskaitomą patvirtinimo kodą, atskiriant patvirtinimo logiką nuo verslo logikos, kuri seka toliau.

Pasaulinės pasekmės ir žmogaus faktorius

Saugios sistemos kūrimas yra pasaulinis iššūkis, apimantis daugiau nei tik kodą. Tai apima žmones, procesus ir bendradarbiavimą per sienas ir laiko juostas. Autentifikavimo tipo sauga suteikia didelių privilegijų šiame pasauliniame kontekste.

• Tarnauja kaip gyva dokumentacija: Paskirstytos komandos atveju gerai tipuotas kodo bazė yra tikslios, nedviprasmiškos dokumentacijos forma. Naujas kūrėjas kitoje šalyje gali iš karto suprasti autentifikavimo sistemos duomenų struktūras ir sutartis tiesiog perskaitęs tipo apibrėžimus. Tai sumažina nesusipratimus ir pagreitina integravimą.
• Supaprastina saugumo auditus: Kai saugumo auditoriai peržiūri jūsų kodą, tipo saugus diegimas padaro sistemos ketinimą visiškai aiškų. Lengviau patikrinti, ar teisingi raktai naudojami teisingoms operacijoms ir ar duomenų struktūros tvarkomos nuosekliai. Tai gali būti labai svarbu norint pasiekti atitiktį tarptautiniams standartams, tokiems kaip SOC 2 arba GDPR.
• Pagerina sąveiką: Nors TypeScript suteikia kompiliavimo metu garantijas, jis nekeičia duomenų formato viela. JWT, sugeneruotas tipo saugaus TypeScript backend, vis dar yra standartinis JWT, kurį gali naudoti mobilusis klientas, parašytas Swift arba partnerių paslauga, parašyta Go. Tipo sauga yra kūrimo metu apsauga, užtikrinanti, kad teisingai įgyvendinate pasaulinį standartą.
• Sumažina pažinimo apkrovą: Kriptografija yra sunki. Kūrėjams nereikėtų laikyti visos sistemos duomenų srauto ir tipo taisyklių savo galvose. Perduodami šią atsakomybę TypeScript kompiliatoriui, kūrėjai gali sutelkti dėmesį į aukštesnio lygio saugumo logiką, pvz., užtikrinti teisingus galiojimo patikrinimus ir tvirtą klaidų tvarkymą, o ne jaudintis dėl `TypeError: cannot read property 'sign' of undefined`.

Išvada: Pasitikėjimo kūrimas su tipais

Skaitmeniniai parašai yra šiuolaikinio skaitmeninio saugumo kertinis akmuo, tačiau jų įgyvendinimas dinamiškai tipuotomis kalbomis, tokiomis kaip JavaScript, yra subtilus procesas, kuriame mažiausia klaida gali turėti rimtų pasekmių. Pasinaudodami TypeScript, mes ne tik pridedame tipų; mes iš esmės keičiame savo požiūrį į saugaus kodo rašymą.

Autentifikavimo tipo sauga, pasiekta naudojant aiškius tipus, firminius primityvus, tipo apsaugas ir apgalvotą architektūrą, suteikia galingą saugos tinklą kompiliavimo metu. Tai leidžia mums sukurti sistemas, kurios yra ne tik patikimesnės ir mažiau linkusios į įprastus pažeidžiamumus, bet ir labiau suprantamos, prižiūrimos ir audituojamos pasaulinėms komandoms.

Galiausiai, saugaus kodo rašymas yra apie sudėtingumo valdymą ir neapibrėžtumo mažinimą. TypeScript suteikia mums galingą įrankių rinkinį, leidžiantį tai padaryti, leidžiantį mums kurti skaitmeninį pasitikėjimą, nuo kurio priklauso mūsų tarpusavyje susijęs pasaulis, po vieną tipo saugos funkciją vienu metu.