ssi-security-commons 0.16.17 → 0.16.19

package/fesm2022/ssi-security-commons.mjs

@@ -10,7 +10,7 @@ import { MatButtonModule } from '@angular/material/button';
 import * as i1$1 from '@angular/common/http';
 import { HttpHeaders, HttpResponse, HttpErrorResponse } from '@angular/common/http';
 import { map, catchError, switchMap, filter, take } from 'rxjs/operators';
-import { BehaviorSubject, throwError } from 'rxjs';
+import { BehaviorSubject, throwError, map as map$1 } from 'rxjs';
 import * as i2$2 from '@angular/router';
 
 class SsiSecurityCommonsService {
@@ -289,6 +289,11 @@ class SessionService {
             data = window.localStorage.getItem(u);
             token = window.localStorage.getItem(t);
             refreshToken = window.localStorage.getItem(r);
+            if (data && token && refreshToken) {
+                data = this.cryptoService.decrypt(data);
+                token = this.cryptoService.decrypt(token);
+                refreshToken = this.cryptoService.decrypt(refreshToken);
+            }
         }
         else {
             data = window.localStorage.getItem(USERDATA);
@@ -935,6 +940,249 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImpor
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i2$2.Router }, { type: CryptoService }, { type: JwtService }, { type: SessionService }]; } });
 
+/* eslint-disable max-lines-per-function */
+/* eslint-disable prefer-const */
+class WebAuthnService {
+    constructor(sessionService, http, snackBar, environment) {
+        this.sessionService = sessionService;
+        this.http = http;
+        this.snackBar = snackBar;
+        this.webAuthnAvailable = !!navigator.credentials && !!navigator.credentials.create;
+        this.environment = environment;
+    }
+    webAuthnSignup(user) {
+        console.log('[webAuthnSignup]');
+        const publicKeyCredentialCreationOptions = {
+            challenge: this.getChallenge(),
+            rp: {
+                name: 'WebAuthn',
+            },
+            user: {
+                id: Uint8Array.from(user.id, c => c.charCodeAt(0)),
+                name: user.email,
+                displayName: user.email,
+            },
+            pubKeyCredParams: [{ alg: -7, type: 'public-key' }],
+            authenticatorSelection: {
+                authenticatorAttachment: 'platform',
+            },
+            timeout: 60000,
+            attestation: 'direct'
+        };
+        return navigator.credentials.create({
+            publicKey: publicKeyCredentialCreationOptions,
+        });
+    }
+    webAuthnSignin(user) {
+        console.log(user);
+        /* {
+            "id": "b18ee077-f896-44f4-a2d4-3ac831eb1c90",
+            "email": "test.user@email.com",
+            "password": "",
+            "credentials": [
+                [
+                    {
+                        "id": {},
+                        "type": "public-key"
+                    }
+                ]
+            ]
+        } */
+        let publicKeyCredentials = {
+            challenge: this.getChallenge(),
+            allowCredentials: user.credentials[0]
+        };
+        return navigator.credentials.get({ publicKey: publicKeyCredentials });
+    }
+    getChallenge() {
+        return Uint8Array.from('jEfcn1CsGFxBiXYtJMSGDycPqPoyFJ3Z', c => c.charCodeAt(0));
+    }
+    register(user, newCredentialInfo) {
+        const promise = new Promise((resolve, reject) => {
+            let enc = new TextDecoder('utf-8');
+            let clientDataJSON = enc.decode(newCredentialInfo.response.clientDataJSON);
+            console.log(clientDataJSON);
+            let clientData = JSON.parse(clientDataJSON);
+            console.log(clientData);
+            const publicKey = this.arrayBufferToBase64Url(newCredentialInfo.rawId);
+            let idList = [{
+                    // id: newCredentialInfo.rawId,
+                    id: publicKey,
+                    type: 'public-key'
+                }];
+            user.credentials.push(idList);
+            console.log(user);
+            this.addAttributeUser(user.id, 'webauthn_key', publicKey).subscribe({
+                next: (res) => {
+                    console.log(res);
+                    resolve(res);
+                },
+                error: (err) => {
+                    console.error(err);
+                    reject(err);
+                }
+            });
+        });
+        return promise;
+    }
+    base64UrlToArrayBuffer(base64UrlString) {
+        const base64String = base64UrlString.replace(/-/g, '+').replace(/_/g, '/');
+        const paddedBase64String = base64String.padEnd(Math.ceil(base64String.length / 4) * 4, '=');
+        const uint8Array = new Uint8Array(atob(paddedBase64String)
+            .split('')
+            .map((char) => char.charCodeAt(0)));
+        return uint8Array.buffer;
+    }
+    arrayBufferToBase64Url(arrayBuffer) {
+        const uint8Array = new Uint8Array(arrayBuffer);
+        let base64String = btoa(String.fromCharCode.apply(null, Array.from(uint8Array)));
+        base64String = base64String.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+        return base64String;
+    }
+    signUp() {
+        const promise = new Promise((resolve, reject) => {
+            if (this.webAuthnAvailable) {
+                const userData = this.sessionService.getUserdata();
+                if (userData) {
+                    let user = {
+                        id: userData?.userId,
+                        email: userData?.email,
+                        credentials: []
+                    };
+                    this.webAuthnSignup(user)
+                        .then((credential) => {
+                        console.log('credentials.create RESPONSE', credential);
+                        this.register(user, credential).then((res) => {
+                            console.log(res);
+                            this.showSnackBar(this.getMessage('signUpOk'), ['snack-success']);
+                            resolve(this.getMessage('signUpOk'));
+                        }).catch((err) => {
+                            console.error(err);
+                            this.showSnackBar(this.getMessage('signUpNok'), ['snack-error']);
+                            reject(this.getMessage('signUpNok'));
+                        });
+                    }).catch((error) => {
+                        console.error('credentials.create ERROR', error);
+                        this.showSnackBar(this.getMessage('signUpNok'), ['snack-error']);
+                        reject(this.getMessage('signUpNok'));
+                    });
+                }
+            }
+            else {
+                this.showSnackBar(this.getMessage('browserNok'), ['snack-error']);
+                reject(this.getMessage('browserNok'));
+            }
+        });
+        return promise;
+    }
+    signIn() {
+        const promise = new Promise((resolve, reject) => {
+            if (this.webAuthnAvailable) {
+                const userData = this.sessionService.getUserdata();
+                if (userData) {
+                    let user = {
+                        id: userData?.userId,
+                        email: userData?.email,
+                        credentials: [{}]
+                    };
+                    this.getAttributeUser(user.id, 'webauthn_key').subscribe({
+                        next: (res) => {
+                            console.log(res);
+                            if (res.data && res.data.webauthn_key && res.data.webauthn_key.length > 0) {
+                                const cred = {
+                                    id: this.base64UrlToArrayBuffer(res.data.webauthn_key[0]),
+                                    type: 'public-key'
+                                };
+                                user.credentials.splice(0, 1);
+                                user.credentials.push([cred]);
+                                this.webAuthnSignin(user).then((response) => {
+                                    console.log('SUCCESSFULLY GOT AN ASSERTION!', response);
+                                    resolve('ok');
+                                })
+                                    .catch((error) => {
+                                    console.error('FAIL', error);
+                                    this.showSnackBar(this.getMessage('invalidCredentials'), ['snack-error']);
+                                    reject(this.getMessage('invalidCredentials'));
+                                });
+                            }
+                            else {
+                                this.showSnackBar(this.getMessage('noCredentials'), ['snack-error']);
+                                reject(this.getMessage('noCredentials'));
+                            }
+                        },
+                        error: (err) => {
+                            console.error(err);
+                            this.showSnackBar(this.getMessage('errorRetrievingCredentials'), ['snack-error']);
+                            reject(this.getMessage('errorRetrievingCredentials'));
+                        }
+                    });
+                }
+            }
+            else {
+                this.showSnackBar(this.getMessage('browserNok'), ['snack-error']);
+                reject(this.getMessage('browserNok'));
+            }
+        });
+        return promise;
+    }
+    addAttributeUser(userId, code, value) {
+        return this.http.post(this.environment.endPoint + `/user/attribute/value/${userId}/${code}/${value}`, {})
+            .pipe(map$1(res => res));
+    }
+    getAttributeUser(userId, code) {
+        return this.http.get(this.environment.endPoint + `/user/attribute/value/${userId}/${code}`)
+            .pipe(map$1(res => res));
+    }
+    showSnackBar(message, panelClass = []) {
+        console.log(message);
+        setTimeout(() => {
+            this.snackBar.open(message, undefined, {
+                duration: 5000,
+                panelClass,
+                verticalPosition: 'top'
+            });
+        });
+    }
+    getMessage(code) {
+        let msg = '';
+        const lang = window.localStorage.getItem('LANG');
+        const messagesEn = {
+            signUpOk: 'Credentials registered successfully',
+            signUpNok: 'A problem occurred while registering credentials',
+            browserNok: 'The browser does not support this functionality',
+            noCredentials: 'The user has no stored credentials',
+            invalidCredentials: 'The credentials are invalid',
+            errorRetrievingCredentials: 'There was a problem retrieving credentials',
+        };
+        const messagesEs = {
+            signUpOk: 'Credenciales registradas exitosamente',
+            signUpNok: 'Se produjo un problema al registrar las credenciales',
+            browserNok: 'El navegador no soporta esta funcionalidad',
+            noCredentials: 'El usuario no tiene credenciales almacenadas',
+            invalidCredentials: 'Las credenciales no son válidas',
+            errorRetrievingCredentials: 'Se produjo un problema al recuperar las credenciales',
+        };
+        if (lang && lang === 'en') {
+            msg = messagesEn[code];
+        }
+        else {
+            msg = messagesEs[code];
+        }
+        return msg;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: WebAuthnService, deps: [{ token: SessionService }, { token: i1$1.HttpClient }, { token: i2$1.MatSnackBar }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: WebAuthnService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: WebAuthnService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: SessionService }, { type: i1$1.HttpClient }, { type: i2$1.MatSnackBar }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+
 /*
  * Public API Surface of ssi-security-commons
  */
@@ -943,5 +1191,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AuthInterceptor, CryptoService, JwtService, LANG, MessagesService, REFRESH_TOKEN, ResponseInterceptor, SessionService, SsiSecurityCommonsComponent, SsiSecurityCommonsModule, SsiSecurityCommonsService, TOKEN, USERDATA };
+export { AuthInterceptor, CryptoService, JwtService, LANG, MessagesService, REFRESH_TOKEN, ResponseInterceptor, SessionService, SsiSecurityCommonsComponent, SsiSecurityCommonsModule, SsiSecurityCommonsService, TOKEN, USERDATA, WebAuthnService };
 //# sourceMappingURL=ssi-security-commons.mjs.map