java - Blog.Seconet.it

Java

Mag 19 2023

Come Decodificare un token JWT in Java

Un JSON Web Token (JWT) viene spesso utilizzato nella sicurezza dell’API REST. Anche se il token può essere analizzato da framework come Spring Security OAuth , potremmo voler elaborare il token nel nostro codice.

In questo tutorial, decodificheremo e verificheremo l’integrità di un JWT .

Struttura di un JWT

Innanzitutto, capiamo la struttura di un JWT :

Header
Payload
Signature (firma)

La firma è facoltativa. Un JWT valido può essere costituito solo dalle sezioni di intestazione e payload. Tuttavia, utilizziamo la sezione della firma per verificare il contenuto dell’intestazione e il payload per L’autorizzazione si sicurezza.

Le sezioni sono rappresentate come stringhe con codifica base64url separate da un delimitatore punto (‘.’). In base alla progettazione, chiunque può decodificare un JWT e leggere il contenuto delle sezioni di intestazione e payload. Ma abbiamo bisogno di accedere alla chiave segreta utilizzata per creare la firma per verificare l’integrità di un token.

Più comunemente, il JWT contiene le “affermazioni” di un utente. Questi rappresentano i dati sull’utente, che l’API può utilizzare per concedere autorizzazioni o tracciare l’utente che fornisce il token. La decodifica del token consente all’applicazione di utilizzare i dati e la convalida consente all’applicazione di considerare attendibile che il JWT sia stato generato da una fonte attendibile.

Diamo un’occhiata a come possiamo decodificare e convalidare un token in Java.

Decodifica di un JWT

Possiamo decodificare un token utilizzando le funzioni Java integrate.

Per prima cosa, suddividiamo il token nelle sue sezioni:

String[] chunks = token.split("\\.");

Dovremmo notare che l’espressione regolare passata a String.split utilizza un ‘. ‘ con escape. carattere da evitare ‘.’ che significa “qualsiasi carattere”.

Il nostro array di blocchi ora dovrebbe avere due o tre elementi corrispondenti alle sezioni del JWT.

Successivamente, decodifichiamo l’intestazione e le parti del payload utilizzando un decodificatore base64url:

Base64.Decoder decoder = Base64.getUrlDecoder();

String header = new String(decoder.decode(chunks[0]));
String payload = new String(decoder.decode(chunks[1]));

Eseguiamo questo codice con un JWT (possiamo decodificare online per confrontare i risultati):

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJBQkMxMjMiLCJleHAiOjE2ODQ1NjcyODgsImlhdCI6MTY4NDQ4MDg4OH0._p0r5iAzPfJCMamBSRGNSqQJu4xqtjyx7_EtQN1f9jE

L’output ci darà l’intestazione decodificata di qualsiasi payload:

{"alg":"HS256","typ":"JWT"}{"sub":"ABC123", "exp": 1684567288,"iat": 1684480888}

Se in un JWT sono definite solo le sezioni di intestazione e payload, abbiamo finito e le informazioni sono state decodificate correttamente.

Verifica del JWT

Successivamente, possiamo verificare l’integrità dell’intestazione e del payload per assicurarci che non siano stati alterati utilizzando la sezione della firma.

Dipendenze

Per la verifica, possiamo aggiungere jjwt al nostro pom.xml :

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.7.0</version>
</dependency>

Abbiamo bisogno di una versione di questa libreria dalla versione 0.7.0 in poi.

Configurazione dell’algoritmo di firma e della specifica della chiave

Per iniziare a verificare il payload e l’intestazione, abbiamo bisogno sia dell’algoritmo di firma utilizzato originariamente per firmare il token sia della chiave segreta:

SignatureAlgorithm sa = SignatureAlgorithm.HS256;
SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(), sa.getJcaName());

In questo esempio, abbiamo codificato il nostro algoritmo di firma in HS256 . Tuttavia, potremmo decodificare il JSON dell’intestazione e leggere il campo alg per ottenere questo valore.

Dovremmo anche notare che la variabile secretKey è una rappresentazione String della chiave segreta. Potremmo fornirlo alla nostra applicazione tramite la sua configurazione o tramite un’API REST esposta dal servizio che emette il JWT.

Esecuzione della verifica

Ora che abbiamo l’algoritmo di firma e la chiave segreta, possiamo iniziare a eseguire la verifica.

Ricombiniamo l’intestazione e il payload in un JWT senza segno, unendoli con il ‘.’ delimitatore:

String tokenWithoutSignature = chunks[0] + "." + chunks[1];
String signature = chunks[2];

Ora abbiamo il token non firmato e la firma fornita. Possiamo usare la libreria per convalidarlo:

DefaultJwtSignatureValidator validator = new DefaultJwtSignatureValidator(sa, secretKeySpec);

if (!validator.isValid(tokenWithoutSignature, signature)) {
    throw new Exception("Could not verify JWT token integrity!");
}

Analizziamolo.

Innanzitutto, creiamo un validatore con l’algoritmo e il segreto scelti. Quindi gli forniamo i dati del token non firmato e la firma fornita.

Quindi il validatore genera una nuova firma e la confronta con la firma fornita. Se sono uguali, abbiamo verificato l’integrità dell’intestazione e del payload

Terminato

abbiamo esaminato la struttura di un JWT e come decodificarlo in JSON.

Quindi abbiamo utilizzato una libreria per verificare l’integrità di un token utilizzando la sua firma, l’algoritmo e la chiave segreta.

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 14 2023

Eclipse Shortcuts

Gli shortcuts in Eclipse sono uno strumento utile per accelerare la tua produttività. Con la giusta combinazione di tasti, è possibile svolgere le attività più comuni in Eclipse in pochi secondi. Gli shortcuts sono uno strumento prezioso per gli sviluppatori. Sono semplici da usare e possono aiutare a risparmiare tempo prezioso.

In Eclipse utilizzando la combinazione Ctrl + Shift + L avremo la lista completa di tutti gli shortcuts disponibili nell’ide, questa combinazione da tastiera è la più importante quando non ci ricordiamo la combinazione dei tasti per la nostra scrittura del codice.

Vediamo un elenco non esaustivo di quelli più comuni:

Ctrl + Shift + F: Formatta il codice
Ctrl + Space: Mostra suggerimenti di codifica
Ctrl + Shift + L: Visualizza la lista dei tasti di scelta rapida
Ctrl + Shift + T: Apre una nuova finestra di dialogo per cercare una classe
Ctrl + Shift + R: Apre una finestra di dialogo per cercare un file
Ctrl + Shift + [X/Y]: Cambia il carattere/stringa selezionata (Uppercase/Lowercase)
Ctrl + D: Cancella la riga
Ctrl + M: Massimizza la finestra di codice
Ctrl + 1: Visualizza la finestra quick fix
Ctrl + Shift + S: Salva tutte le modifice
Ctrl +S: Salva le modifiche al file aperto
Ctrl + Shift + / (tastiera numerica): Comprime tutti i metodi di classe alle definizioni
Ctrl + Shift + * (tastiera numerica): Espande tutti i metodi di classe
Ctrl + E: Switch editor
Alt + Shift +R: Rinomina – Refactoring
Alt + Enter: Proprietà del file aperto
Ctrl + Alt + Shift +L: Ricerca veloce

Altri shortcuts

Scrivi “sysout” + Ctrl + space: risultato System.out.println();
Scrivi “main” + Crtl + space: risultato verrà generato il metodo main della classe
Scrivi “for” + Ctrl + space: risultato verrà visualizzata una finestra per la generazione dei cicli for
Scrivi “while” +Ctrl + space: risultato verrà visualizzata una finestra per la generazione dei cicli while
Scrivi “if” + Ctrl +space: risultato verrà visualizzata una una finestra per la generazione condizione if

Dunque gli shortcuts ci consentono di eseguire rapidamente una determinata azione, Eclipse ha un sacco di scorciatoie per codificare Java più velocemente. Non è necessario impararle a memoria tutte, ma l’uso di quelle più comuni farà di noi uno sviluppatore migliore 😉

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 6 2023

Multithread in Java e priorità

La funzionalità multithreading in Java è quella che consente l’esecuzione simultanea di due o più parti di un programma per il massimo utilizzo della CPU. Ogni parte del programma viene chiamata thread. Quindi, i thread sono processi leggeri all’interno di un processo.

I thread possono essere creati utilizzando due meccanismi:

Estensione della classe Thread
Implementazione dell’interfaccia eseguibile

Creazione di thread estendendo la classe Thread
Creiamo una classe che estende la classe java.lang.Thread . Questa classe ...Leggi di più

sovrascrive il metodo run() disponibile nella classe Thread. Un thread inizia la sua vita all’interno del metodo run(). Creiamo un oggetto della nostra nuova classe e chiamiamo il metodo start() per avviare l’esecuzione di un thread. Start() richiama il metodo run() sull’oggetto Thread.

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 1 in esecuzione");
            }
        });
 
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 2 in esecuzione");
            }
        });
 
        t1.start();
        t2.start();
    }
}

Creazione di thread implementando l’interfaccia Runnable
Creiamo una nuova classe che implementa l’interfaccia java.lang.Runnable e sovrascrive il metodo run(). Quindi istanziamo un oggetto Thread e chiamiamo il metodo start() su questo oggetto.

public class MultithreadingDemo implements Runnable {
    public void run()
    {
        try {
            // Visualizzazione del thread in esecuzione
            System.out.println(
                    "Thread " + Thread.currentThread().getId()
                            + " is running");
        }
        catch (Exception e) {
            // eventuale eccezione
            System.out.println("Exception is caught" + e.getMessage());
        }
    }
}
// Main Class
class Multithread {
    public static void main(String[] args)
    {
        int n = 8; // Number of threads
        for (int i = 0; i < n; i++) {
            Thread object
                    = new Thread(new MultithreadingDemo());
            object.start();
        }
    }
}

In conclusione

Se estendiamo la classe Thread, la nostra classe non può estendere nessun’altra classe perché Java non supporta l’ereditarietà multipla. Ma, se implementiamo l’interfaccia Runnable, la nostra classe può ancora estendere altre classi base.
Possiamo ottenere le funzionalità di base di un thread estendendo la classe Thread perché fornisce alcuni metodi integrati come yield(), interrupt() ecc. che non sono disponibili nell’interfaccia Runnable.
L’uso di runnable ti darà un oggetto che può essere condiviso tra più thread.

Parliamo ora di come ottenere e impostare la priorità di un thread in java.

public final int getPriority(): il metodo java.lang.Thread.getPriority() restituisce la priorità del thread specificato.
public final void setPriority(int newPriority): il metodo java.lang.Thread.setPriority() modifica la priorità del thread nel valore newPriority. Questo metodo genera IllegalArgumentException se il valore del parametro newPriority supera il limite minimo(1) e massimo(10).

Il thread con la priorità più alta avrà una possibilità di esecuzione prima degli altri thread. Supponiamo che ci siano 3 thread t1, t2 e t3 con priorità 4, 6 e 1. Quindi, il thread t2 verrà eseguito per primo in base alla priorità massima 6, dopodiché verrà eseguito t1 e quindi t3.

Ora smanettoni vi starete chiedendo cosa succede se assegniamo le stesse priorità ai thread ?

Semplice, se due thread hanno la stessa priorità, non possiamo aspettarci quale thread verrà eseguito per primo. Dipende dall’algoritmo del thread scheduler (Round-Robin, First Come First Serve, ecc.)

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Java

Mar 3 2023

Le collection di tipo set in java

Le collezioni di tipo Set in Java sono un tipo di contenitore che non consente elementi duplicati. In altre parole, ogni elemento all’interno di un Set deve essere unico

^[1]. L’interfaccia Set è implementata dalle classi HashSet, LinkedHashSet e TreeSet.La classe HashSet implementa l’interfaccia Set utilizzando una tabella hash. Questo significa che gli elementi all’interno di un HashSet non sono ordinati e possono essere acceduti in modo casuale

^[2].La classe LinkedHashSet estende la classe HashSet e mantiene l’ordine di inserimento degli elementi. Ciò significa che gli elementi all’interno di un LinkedHashSet possono essere acceduti nell’ordine in cui sono stati inseriti

^[2].La classe TreeSet implementa l’interfaccia SortedSet e mantiene gli elementi ordinati in base al loro valore. Ciò significa che gli elementi all’interno di un TreeSet possono essere acceduti in ordine crescente o decrescente...Leggi di più

^[2].Per aggiungere elementi a un Set, si può utilizzare il metodo add(). Per rimuovere elementi da un Set, si può utilizzare il metodo remove().

^[1]Per verificare se un elemento esiste all’interno di un Set, si può utilizzare il metodo contains().

Ecco un esempio di codice:

import java.util.HashSet;

public class Main {
  public static void main(String[] args) {
    // Creazione del set
    HashSet<String> set = new HashSet<String>();

    // Aggiunta degli elementi al set
    set.add("elemento1");
    set.add("elemento2");
    set.add("elemento3");

    // Stampa del set
    System.out.println(set);

    // Rimozione dell'elemento "elemento2" dal set
    set.remove("elemento2");

    // Verifica se l'elemento "elemento1" esiste nel set
    System.out.println(set.contains("elemento1"));
  }
}

Nell’esempio sopra abbiamo visto come aggiungere elementi alla collection di tipo set, ma come facciamo a rimuovere un elemento ? Semplice utilizziamo il metodo remove.

// Rimozione dell'elemento "elemento2" dal set
    set.remove("elemento2");

Se invece abbiamo bisogno di cercare un elemento possiamo utilizzare il metodo contains

 // Verifica se l'elemento "elemento1" esiste nel set
    System.out.println(set.contains("elemento1"));

Set vs List un List è una sequenza ordinata di elementi che consente duplicati, mentre un Set è una sequenza non ordinata di elementi distinti che non consente duplicati. Un’altra differenza tra i due è che un List può contenere qualsiasi numero di valori nulli, mentre un Set può contenere al massimo un elemento nullo.
Sia List che Set sono interfacce che appartengono al framework Collection ed estendono l’interfaccia Collection. La scelta tra l’utilizzo di un elenco o di un set dipende dal caso d’uso specifico. Se l’ordine e i duplicati sono importanti, è necessario utilizzare un elenco. Se sono necessari solo elementi distinti e l’ordine non è importante, è comodo utilizzare un set.
Vale la pena notare che ci sono diverse classi in Java che implementano entrambe le interfacce, come ArrayList per List e HashSet per Set[1].

Se in questo articolo ci sono degli errori o hai dei suggerimenti, faccelo sapere!

Sergio Cornacchione 0 Commenti

Archivi tag: java

Come Decodificare un token JWT in Java

Eclipse Shortcuts

Multithread in Java e priorità

Le collection di tipo set in java