L’autenticazione a due o più fattori (conosciuta anche come strong authentication) è oggi uno dei sistemi di protezione più sicuri che abbiamo a disposizione per proteggere i nostri account.

In questo post scoprirai come attivare un metodo di autenticazione a due fattori in una applicazione sviluppata con Oracle APEX.

Se anche tu sviluppi applicazioni con Oracle APEX, ti consiglio di leggerlo attentamente perché mai come oggi è diventato importante sviluppare applicazioni web sicure.

Autenticazione a due Fattori e Verifica in due Passaggi: sono la stessa cosa?

Ti chiedo scusa.

Non sono stato del tutto sincero con te.

Ti ho detto che avremmo costruito un metodo di autenticazione a due fattori in Oracle APEX ma non è esattamente corretto.

Cosa voglio dire?

Mi spiego subito.

L’autenticazione a due fattori (2FA oppure TFA) è un metodo di autenticazione sicura per sistemi e piattaforme informatiche che consiste nell’utilizzo di due metodi di autenticazione invece che uno.

Uno schema di autenticazione classico prevede che per accedere ad un servizio o applicazione web ti venga richiesto di inserire la username e la password.

Uno schema di autenticazione a due fattori aggiunge un livello di sicurezza in più perché combina l’utilizzo di due fattori di categorie diverse.

Questi fattori possono essere di generalmente di tre tipologie:

• Una cosa che sai, ad esempio una password
• Una cosa che hai, ad esempio uno smartcard o un altro dispositivo per l’autenticazione
• Una cosa che sei, ad esempio l’impronta digitale o un altro dato biometrico

Spero di non averti incasinato.

Facciamo un esempio.

Un processo di autenticazione a due fattori è lo sblocco del telefono subito dopo l’accensione, in cui l’utente:

• Inserisce il PIN (qualcosa che sai)
• Fa una scansione della propria impronta digitale (qualcosa che sei)

In questo modo, il sistema è protetto da due livelli di sicurezza invece di uno e si riduce il rischio di accessi non autorizzati.

La verifica in due passaggi (2SV) è simile al concetto di cui stiamo parlando, ma può utilizzare due fattori simili, appartenenti alla stessa categoria.

Ad esempio, la maggior parte degli account e delle applicazioni richiede una verifica in due passaggi che comprende l’inserimento di una password e, durante il secondo passaggio, di un ulteriore codice di sicurezza.

Questo codice può essere un dato alfanumerico inviato per SMS, email o app (ad esempio Google Authenticator) o un codice QR.

Spesso i codici hanno una scadenza, il che significa che il secondo passaggio della verifica deve essere completato entro un breve periodo di tempo dal primo.

Oggi impareremo a creare in Oracle APEX un meccanismo di verifica in due passaggi basato sull’utilizzo di una Time-based One-Time Password (tra poco vedremo di cosa si tratta).

Anche se nel corso dell’articolo parlerò di autenticazione a due fattori è bene che ti sia chiara la differenza tra i due meccanismi.

One-Time Password: cosa sono le Password OTP e TOTP?

Una One-Time Password (OTP) è un tipo di password che, come suggerisce il nome, può essere usata solo una volta.

È un modo sicuro per fornire l’accesso a un’applicazione o eseguire una transazione una sola volta.

Un esempio?

Le transazioni bancarie, come l’autorizzazione di un bonifico o un acquisto on-line, spesso fanno utilizzo dell’OTP.

Poichè la password perde la sua validità dopo che è stata utilizzata e non può essere riutilizzata, questo meccanismo fornisce una protezione più avanzata rispetto alle password statiche, che rimangono le stesse per più sessioni di accesso.

La cosa importante da ricordare è che le password vengono generate attraverso algoritmi di casualità ed è quindi difficile (se non impossibile) da prevedere.

Il fatto poi che le password OTP siano utilizzabili solo una volta fanno si che questo meccanismo sia discretamente robusto.

Come fa l’utente a sapere ogni volta quale password usare? Generalmente si utilizzano SMS o e-mail.

Una Time-based One-Time Password (TOTP) è una evoluzione, per così dire, dell’OTP ed infatti ne riprende i concetti ma si differenzia dal fatto che la password ha una valenza anche temporale.

La password non viene inviata via mail o SMS ma viene calcolata direttamente dallo smartphone (talvolta anche da un token) che l’utente deve avere necessariamente con sé a portata di mano.

Altro aspetto da tenere a mente è che tutto funziona se il server e il dispositivo sono temporalmente sincronizzati ovvero devono generare ogni 60 secondi la stessa password a partire da una chiave segreta condivisa.

Verifica in due Passaggi in Oracle APEX

Oracle APEX mette a disposizione diversi metodi di autenticazione.

Oltre ad metodo di autenticazione base, puoi usare il social login oppure crearne di totalmente personalizzati.

Purtroppo Oracle APEX non mette a disposizione oggi meccanismi di T2A o 2SV out-of-the-box, per questo motivo dovremo necessariamente costruire un meccanismo di autenticazione custom.

Per realizzare questo tutorial mi sono basato sull’utilissimo lavoro che ha fatto fuzziebrain e che è stato documentato in questo articolo.

Installa il package PL-SQL oos_utils

Prima di tutto dobbiamo installare il package oos_utils che puoi recuperare da questo link.

Per installare il package ho deciso di usare la funzionalità SQL Scripts di Oracle APEX.

• Accedi ad Oracle APEX e vai in SQL Workshop > SQL Scripts

• Clicca Upload

• Seleziona il file oos_utils_install che dovresti trovare nella cartella oos-utils-master/install

• Dai un nome allo Script e premi Upload

• Premi Run

• Premi Run Now per lanciare lo script SQL e verifica che venga eseguito senza errori.

Installa l’applicazione Two-Factor Authentication Demo

Installiamo gli oggetti che ci permetteranno di attivare l’autenticazione a due fattori in Oracle APEX.

Come accennavo prima, partiremo da una applicazione demo realizzata da fuzziebrain.

Puoi scaricare l’applicazione e tutti gli oggetti che servono per farla funzionare dal relativo progetto GitHub.

• Accedi ad Oracle APEX e vai in SQL Workshop > SQL Scripts
• Carica ed esegui i seguenti scripts:
  • create_tfa_user.sql: crea una tabella che utilizzeremo per attivare uno schema di autenticazione custom.
  • pkg_tfa_apex.pks e pkg_tfa_apex.pkb: package PL-SQL che utilizzeremo per attivare l’autenticazione a due fattori.

Ora possiamo importare in l’applicazione Two-Factor Authentication Demo Application.

• Accedi all’APP Builder e clicca Import

• Seleziona il file di installazione dell’applicazione che viene fornito e premi Next per avviare il wizard.
• Premi Install Application per completare la procedura.

Avviamo subito l’applicazione per capire come funziona.

• Questa è la pagina iniziale. La prima cosa da fare è registrare gli utenti, quindi clicca sul bottone Register

• Viene avviata una form che useremo per registrare gli utenti dell’applicazione.
• Inserisci un nuovo utente specificando username e password.
• Premi Register per completare la procedura.

Ora attiveremo l’autenticazione a due fattori per l’utente demo che abbiamo appena creato.

• Clicca su My Account.

• Dovresti vedere la classica Login Page di Oracle APEX.
• Inserisci le credenziali dell’utente demo.

• Attiva l’autenticazione a due fattori e clicca Save Changes

L’applicazione mostra un QR Code che dovrai inquadrare usando una qualsiasi app di autenticazione come, ad esempio, Google Authenticator.

• Avvia l’applicazione Google Authenticator dal tuo smartphone e clicca Aggiungi Account
• Seleziona l’opzione Altro Account ed inquadra il QR Code generato da Oracle APEX per aggiungere il nuovo account
• Inserisci nel campo Verification Code il codice per la password che viene generato sul tuo smartphone premi Verify

• Dovresti ricevere questo messaggio di conferma

Bene, hai attivato l’autenticazione a due fattori per il tuo utente.

Adesso torna alla pagina di login e prova nuovamente l’accesso

Se hai fatto tutto correttamente ti verrà richiesto di inserire il codice OTP che potrai recuperare direttamentedal tuo smartphone.

Premi Verify completare la procedura di login.

Come attivare l’autenticazione a due fattori nelle tue Applicazioni

Abbiamo visto che esiste un modo per attivare l’autenticazione a due fattori in Oracle APEX e l’applicazione di demo che abbiamo installato ne è la prova.

Tuttavia, come possiamo riutilizzare quello che abbiamo visto nelle nostre applicazioni?

Nella seconda parte di questo articolo ci concentreremo proprio su questo.

Per comodità ho quindi creato una semplice applicazione di prova e ti farò vedere cosa devi fare per implementare l’autenticazione a due fattori.

Amministrazione Utenti

Per attivare l’autenticazione a due fattori dovremo prima di tutto attivare uno schema di autenticazione custom.

Gli utenti di questa applicazione saranno amministrati usando la tabella TFA_USER che abbiamo creato pochi minuti fa.

Per aggiungere nuovi utenti può essere utile costruire una semplice pagina di amministrazione utenti usando, ad esempio, un Interactive Report + Form.

• Accedi all’APP Builder clicca Create Page
• Seleziona Interactive Report e premi Next.

• Inserisci i seguenti parametri e premi Next
  • Name: Amministrazione Utenti
  • Include Form Page: Yes
  • Form Page Name: Modifica Utente
  • Table/View Name: TFA_USER

• Specifica la Primary Key e premi Create Page

Questo sarà il risultato

Configuriamo la pagina Modifica Utente

• Accedi all APP Builder e clicca sulla pagina Modifica Utente

• Lascia disponibili solo i seguenti Page Items (tutti gli altri li puoi tranquillamente eliminare).
  • PX_USERID
    • Type: Hidden
  • PX_USERNAME
    • Type: Display Only
  • PX_EXIPIRY_DATE
    • Type: Date
  • PX_ACTIVE
    • Type: Checkbox
    • Value Required: No
    • Checked Value: 1
    • Unchecked Value: 0
  • PX_TFA_ENABLED
    • Type: Checkbox
    • Value Required: No
    • Checked Value: 1
    • Unchecked Value: 0

Quello riportato nella figura seguente dovrebbe essere il risultato:

Per aggiungere un nuovo utente non utilizzeremo la Form Page che abbiamo visto ma ne creeremo una nuova.

• Accedi all’APP Builder e clicca Create Page
• Seleziona il Blank Page
• Inserisci i parametri e clicca Create Page
  • Name: Nuovo Utente
  • Page Mode: Modal Dialog

• Crea una nuova Page Region di nome User Registration e configura al suo interno i seguenti Page Items
  • PX_USERNAME
    • Type: Text Field
    • Value Required: Yes
  • PX_PASSWORD
    • Type: Password
    • Value Required: Yes
  • PX_CONFIRM_PASSWORD
    • Type: Password
    • Value Required: Yes
  • Button CREATE
    • Position: Create
    • Action: Submit Page

• Crea una Validation Rule
  • Name: Password Match
  • Type: Expression
  • Language: PL/SQL
  • PL/SQL Expression: :PX_PASSWORD = :PX_CONFIRM_PASSWORD
  • Error Message: Inserisci la stessa password
  • Associated Item: PX_PASSWORD

• Crea una seconda Validation Rule la quale verificherà che l’utente che sto registrando non sia già stato precedentemente creato
  • Name: Username Check
  • Type: No Rows Returned
  • SQL Query: select null from tfa_user where lower(username) = lower(:PX_USERNAME)
  • Error Message: Utente già registrato
  • Associated Item: PX_USERNAME

• Clicca sul tab Processes e crea due nuovi Page Process
  • Create User di tipo Execute Code
  • Close Dialog di tipo Close Dialog

• Page Process Create User
  • Type: Execute Code
  • Language: PL/SQL
  • PL/SQL Code: inserisci lo script seguente

pkg_tfa_apex.p_register_user(
    p_username => :P6_USERNAME
  , p_password => :P6_PASSWORD
  , p_confirm_password => :P6_CONFIRM_PASSWORD
);

• Apri la definizione della pagina Amministrazione Utenti e clicca sul Page Button CREATE

• Modifica la Target Page sostituendo quella presente con la pagina di registrazione di un nuovo utente che abbiamo appena creato

Schema di Autenticazione

Ora che abbiamo tutto quello che serve per amministrare gli utenti possiamo cambiare lo schema di autenticazione della nostra applicazione.

• Accedi all’APP Builder e vai in Shared Components > Security > Authentication Schema
• Premi Create
• Seleziona l’opzione in figura e premi Next

• Configura i seguenti parametri e poi premi Create Authentication Scheme
  • Name: Two Factor – Authentication Scheme
  • Scheme Type: Custom

• Apri le impostazioni dello Schema di Autenticazione che hai creato e specifica la funzione che deve essere utilizzata per consentire il login
  • Authentication Function Name: pkg_tfa_apex.f_authenticate_user

• Clicca Make Current Scheme per attivare il nuovo Schema di Autenticazione

Arrivati a questo punto siamo in grado di creare nuovi utenti specificandone username e password e possiamo anche effettuare il login.

Facciamo un test.

• Accedi all’applicazione e vai in Amministrazione Utenti
• Clicca Create

• Specifica la USERNAME e la PASSWORD del nuovo utente e poi clicca Create

• Ora torna alla pagina di login ed inserisci le credenziali

Se hai fatto tutto correttamente dovresti essere in grado di effettuare il login

Sempre dall’APP, torna nuovamente alla pagina di amministrazione degli utenti e attiva per l’utente che appena creato il flag Two-Factor Authentication Enabled e premi Apply Changes

Adesso prova a collegarti nuovamente.

Cosa è successo?

Lo so già…nulla! L’utente si collega normalmente, vero?

Non preoccuparti, non hai sbagliato.

In effetti, arrivati fino a questo punto non abbiamo ancora costruito il modulo per la verifica a due fattori.

Ci siamo limitati, ad attivare uno schema di autenticazione custom.

Modulo di Registrazione Two-Factor Authenticator

Quando si lavora con le applicazioni che implementano l’autenticazione a due fattori, al primo accesso viene chiesto all’utente di registrare nell’Authenticator APP installata nel proprio smartphone un codice alfanumerico che serve per far si che venga generato l’OTP (One Time Password).

Questo codice alfanumerico (che rappresenta la chiave segreta condivisa) viene tipicamente mostrato anche in formato QR Code.

Solo dopo aver registrato la chiave segreta l’Authenticator APP sarà in grado di generare le chiavi OTP che l’utente dovrà usare per autenticarsi.

Tuttavia test_user deve prima di tutto registrare nell’autenticator app che ha installato nel proprio smartphone l’applicazione Oracle APEX.

In questa parte del tutorial ci concentreremo sulla costruzione di una pagina che mostri all’utente la chiave di registrazione dell’applicazione.

Questo codice è stato già generato dalla procedura pkg_tfa_apex.p_register_user che abbiamo usato nella form di registrazione ed è stato salvato nella tabella TFA_USER nel campo SHARED_SECRET.

Per far si che APEX sia in grado di capire quando mostrare la form di registrazione abbiamo bisogno di aggiungere un flag alla tabella TFA_USER

• Collegati ad Oracle APEX e vai in SQL Workshop > SQL Commands
• Esegui il seguente comando

alter table "TFA_USER" add
("IS_REGISTERED" NUMBER)

Quando un utente viene creato per la prima volta il flag IS_REGISTERED sarà NULL. Dopo aver registrato la chiave verrà automaticamente valorizzato a 1.

Creiamo la pagina per la registrazione dell’applicazione.

• Accedi all’APP Builder e clicca Create Page
• Seleziona Blank Page e poi Create Page

Prima di tutto dobbiamo importare nella nostra applicazione la libreria JavaScript che ci serve per visualizzare il QR Code.

Useremo la stessa libreria JavaScript utilizzata dall’applicazione di demo che abbiamo già provato. Puoi trovarla in Shared Components > Static Application Files.

Dopo averla importata nella nostra app possiamo collegarla alla nostra pagina di registrazione:

• Apri la definizione della pagina OTP Register e seleziona in nodo principale
• Vai alla sezione JavaScript ed inserisci il riferimento alla libreria JavaScript

Adesso possiamo configurare la pagina OTP Register

• Vai alla sezione Appearance e seleziona il Page Template Login

• Aggiungi una nuova Page Region
  • Name: Instructions
  • Type: Static
  • Template: Login
  • HTML Code: inserisci la seguente stringa HTML

<div id="qrcode" style="text-align:center;"></div>
<div>
    </br>
    <div>Scansiona il codice QR Code nella tua Applicazione di Autenticazione preferita</div>
    </br>
    <div>Inserisci il codice OTP e clicca Verifica per completare la procedura.</div>
</div>

• Aggiungi alla Page Region Instructions i seguenti Page Items
  • PX_USERID
    • Type: Hidden
  • PX_OTP_URI
    • Type: Hidden
  • PX_USERNAME
    • Type: Display Only
    • Template: Optional – Floating
  • PX_APP_CODE
    • Type: Display Only
    • Template: Optional – Floating

• Aggiungi una seconda Page Region
  • Name: Code Verification
  • Type: Static
  • Template: Blank With Attributes
  • Parent Region: Instructions

• Aggiungi i seguenti Page Items
  • PX_OTP_CODE
    • Type: Text Field
    • Value Required: Yes
  • Button VERIFY
    • Action: Submit Page

• Crea un Page Process nella sezione Before Header
  • Name: Load OTP Data
  • Type: Execute Code
  • Language: PL/SQL
  • PL/SQL Code: inserisci il codice seguente

select 
  oos_util_totp.format_key_uri(
    p_label_accountname => :APP_TITLE || ' - ' || lower(username)
    , p_label_issuer => :APP_TITLE
    , p_secret => shared_secret
  ),
  shared_secret,
  userid,
  null
into :P13_OTP_URI, :P13_APP_CODE, :P13_USERID, :P13_OTP_CODE
from tfa_user
where lower(username) = lower(:P13_USERNAME);

• Crea una Dynamic Action di tipo Execute JavaScript Code nella sezione Page Load

• Inserisci nella Dynamic Action il seguente codice JavaScript (sostituisci P13_OTP_URI con il Page Item che hai creato nella tua pagina)

var qr = qrcode(0, 'M');
qr.addData(apex.item('P13_OTP_URI').getValue());
qr.make();
this.affectedElements.append(qr.createImgTag(4, 16, 'OTP URI'));

• Vai in Affected Elements ed imposta le seguenti proprietà
  • Selection Type: jQuery Selector
  • jQuery Selector: div#qrcode

• Vai nel tab Processes e crea una nuova Validation Rule

• Vai alle impostazioni della Validation Rule e configura le proprietà:
  • Name: Validate OTP
  • Type: Expression
  • Language: PL/SQL
  • Error Message: Il codice di verifica non è corretto oppure è scaduto. Per favore, riprova.
  • When Button Pressed: VERIFY
  • PL/SQL Expression: inserisci l’espressione seguente:

pkg_tfa_apex.f_validate_otp(
    p_userid => :P13_USERID
  , p_otp => :P13_OTP_CODE
)

• Crea il Page Process che servirà per salvare in APEX l’avvenuta registrazione dell’applicazione
  • Name: Register TFA
  • Type: Execute Code
  • When Button Pressed: VERIFY
  • PL/SQL Code: inserisci il codice seguente

update tfa_user
set is_registered = 1
where userid = :P13_USERID;

• Crea un altro Page Process per gestire la procedura di Post Login
  • Name: Post Login
  • Type: Execute Code
  • When Button Pressed: VERIFY
  • PL/SQL Code: inserisci il codice seguente

apex_authentication.post_login(
  p_username => :P13_USERNAME
  , p_password => null
);

• Completa la configurazione di questa pagina creando un Branch che effettuerà il Redirect all’Home Page
  • Name: Go to Home Page
  • Point: After Processing
  • Type: Page Redirect
  • Target: seleziona l’home page dell’applicazione

Modulo di Validazione One-Time Password

Dopo aver registrato per la chiave segreta condivisa nel proprio smartphone la nostra applicazione dovrà richiedere solo la validazione dell’OTP (One Time Password) generata dall’Authenticator APP.

In questa sezione del tutorial creeremo una pagina, molto simile alla precedente, che richiederà all’utente di inserire solo l’OTP.

• Accedi all’APP Builder e crea una nuova Blank Page
  • Name: OTP Validate
  • Page Template: Login

• Aggiungi una Page Region
  • Name: Instructions
  • Type: Static Content
  • Template: Login
  • HTML Source: inserisci il seguente codice HTML

<div style="text-align:center;"></div>
<div>
    </br>
    <div>Inserisci il codice OTP e clicca Verifica per effettuare il login.</div>
</div>

• Aggiungi i seguenti Page Items
  • PX_USERID
    • Type: Hidden
  • PX_USERNAME
    • Type: Hidden
  • PX_OTP_CODE
    • Type: Text Field
    • Value Required: Yes
  • Button VERIFY
    • Action: Submit Page

• Aggiungi il Process Load OTP Data con il seguente codice PL/SQL

select userid, null
into :P14_USERID, :P14_OTP_CODE
from tfa_user
where lower(username) = lower(:P14_USERNAME);

• Vai nella sezione Page Process e crea i seguenti oggetti che dovranno avere la stessa configurazione della pagina OTP Register
  • Validation Rule Validate OTP
  • Process Post Login
  • Process Clear Session State
  • Branch Go to Home Page

Pagina di Login

Abbiamo quasi finito!

Quello che adesso manca è collegare la pagina di Login della nostra applicazione alle pagine di registrazione dell’app e di verifica dell’OTP.

Quello che faremo sarà modificare la procedura di login.

Se per l’utente che si sta collegando non è attiva l’autenticazione a due fattori allora tutto funzionerà come sempre: dopo aver inserito username e password si accederà direttamente all’home page.

Invece, se è attiva l’autenticazione a due fattori sarà richiesto di inserire il codice OTP.

Per gestire correttamente tutte le casistiche ho aggiunto al package pkg_tfa_apex una procedura PL-SQL all’interno della quale verifico se per l’utente che sta provando a collegarsi è attiva l’autenticazione a due fattori ed eseguo il redirect verso una delle due pagine che abbiamo creato

• OTP Register, Page Number = 13
• OTP Validate, Page Number = 14

Quello che devi fare è aggiungere al package pkg_tfa_apex questa procedura facendo attenzione a cambiare i riferimenti ai page number delle pagine che hai creato in corrispondenza delle istruzioni APEX_PAGE.GET_URL

  procedure p_authenticate_user2(
    p_username in varchar2
    , p_password in varchar2
  )
  as
    l_password_hash tfa_user.password_hash%type;
    l_tfa_enabled tfa_user.tfa_enabled%type;
    l_tfa_is_registered tfa_user.is_registered%type;
    login_failed exception;
    l_otp_url clob;
  begin
    begin
      select password_hash, tfa_enabled, is_registered
      into l_password_hash, l_tfa_enabled, l_tfa_is_registered
      from tfa_user
      where 1 = 1
        and lower(username) = lower(p_username)
        and coalesce(expiry_date, sysdate) >= sysdate
        and active = 1
      ;
    exception
      when no_data_found then
        raise login_failed;
    end;
    if l_password_hash = f_hash_password(p_password => p_password) then
      if l_tfa_enabled = 0 then
        apex_authentication.post_login(
          p_username => p_username
          , p_password => null
        );
        apex_util.clear_page_cache();
      else
          apex_authentication.login(
            p_username => p_username
            , p_password => p_password
          );
          
          if (nvl(l_tfa_is_registered,0)=0 ) then
              l_otp_url := APEX_PAGE.GET_URL (
                p_page   => 13,
                p_items  => 'P13_USERNAME',
                p_values => p_username );
          else
              l_otp_url := APEX_PAGE.GET_URL (
                p_page   => 14,
                p_items  => 'P14_USERNAME',
                p_values => p_username );
          end if;   
        apex_util.clear_page_cache();
        apex_util.redirect_url (p_url => l_otp_url );
      end if;
    else
      raise login_failed;
    end if;
  exception
    when login_failed then
      apex_authentication.login(
        p_username => p_username
        , p_password => null
      );
  end p_authenticate_user2;

L’ultima cosa che rimane da fare è agganciare la procedura di autenticazione alla pagina di Login

• Accedi all’APP Builder e seleziona la Login Page
• Vai nel tab Page Processes e clicca sul processo Login

• Sostituisci lo script del Process con questo:

/**
apex_authentication.login(
    p_username => :P9999_USERNAME,
    p_password => :P9999_PASSWORD );
*/
pkg_tfa_apex.p_authenticate_user2(
  p_username => :P9999_USERNAME, 
  p_password => :P9999_PASSWORD
);

Ora possiamo finalmente provare la nostra applicazione.

Provo ad eseguire il login con utente test_user.

Poichè non ho ancora registrato nel mio smartphone questa applicazione, atterro sulla pagina OTP Register.

Prendo io mio smartphone e avvio Google Authenticator per scansionare il QR Code. Ora posso completare l’accesso inserendo l’OTP.

Se effettuo li logout e provo a collegarmi di nuovo APEX mi mostra la pagina per inserire direttamente l’OTP.

Conclusioni

Bene, siamo arrivati alla fine di questo tutorial. Spero con tutto il cuore che tu lo abbia trovato interessante.

Riuscire ad usare l’autenticazione a due fattori rappresenta un modo molto utile per aumentare la sicurezza delle tue applicazioni realizzate con Oracle APEX.

Se lo desideri puoi scaricare l’applicazione di demo che ho realizzato per questo tutorial cliccando sul seguente link (ho utilizzato Oracle APEX 22.1.2).