Articolo di :

Nicola Montemurro

Nicola Montemurro

Nicola Montemurro

Nicola Montemurro un Consulente IT specializzato in sicurezza e resilienza infrastrutturale, Windows, Linux, VMWare, CCNA

network & system architect, network architect, system architect, architetto di rete, architetto di sistemi

L’architetto di rete, tutto quello da sapere
1920 1080 Nicola Montemurro

Cos'è un architetto di rete?

Molte delle nostre interazioni si basano sulla capacità di collegare tra loro diversi dispositivi, utilizzando complessi sistemi informatici attraverso la comunicazione di dati. Lo scambio costante di informazioni da un dispositivo all’altro avviene regolarmente sia per le attività personali che per quelle professionali. Componente fondamentale per le operazioni aziendali, le reti sono essenziali per proteggere le informazioni e garantire la privacy dei dati, aiutandoci ad accedere a varie applicazioni software e a svolgere compiti complessi ogni giorno.

Le reti forniscono la base necessaria per consentire lo scambio di informazioni in modo rapido, accurato e sicuro tra i vari dispositivi. Essendo il quadro di riferimento per le nostre attività tecnologiche, le reti devono essere progettate per soddisfare le esigenze specifiche di ogni organizzazione, ed è proprio questo che fanno gli architetti di rete. Progettano, implementano e gestiscono le reti, sia dal punto di vista del software che dell’hardware.

Compiti e responsabilità di un architetto di rete

l’architetto di rete ha la responsabilità di progettare la rete di un’organizzazione in modo specifico per raggiungere gli obiettivi aziendali delineati. Ogni rete di computer deve essere configurata in modo tale che tutti gli utenti finali possano accedere in modo sicuro ed efficiente agli strumenti necessari per svolgere il proprio lavoro. Ciò comporta anche l’implementazione della rete per soddisfare rigorosi standard di sicurezza, oltre all’installazione e alla configurazione di qualsiasi elemento hardware. Questi professionista IT deve avere una solida conoscenza di una varietà di reti, tra cui LAN (reti locali), WAN (reti geografiche) e intranet.

A che tipo di compiti devono essere preparati i professionisti IT che ricoprono il ruolo di architetto di rete?

Le mansioni e le responsabilità includono i seguenti aspetti:

  • Progettare sistemi di rete per soddisfare le esigenze operative e gli standard del settore.
  • Gestire l’intero processo di implementazione della rete.
  • Monitorare le prestazioni della rete e adottare misure di follow-up per risolvere i problemi di latenza e di sicurezza.
  • Eseguire aggiornamenti regolari della rete per creare maggiore efficienza.
  • Creare backup in caso di blackout o violazione.
  • Riparare l’hardware di rete difettoso o obsoleto.
  • Documentare l’intero ecosistema di rete, compresi software e hardware.
  • Rimanere aggiornati sui nuovi progressi per ottimizzare le prestazioni della rete.

Competenze essenziali per un ruolo di architetto di rete

La descrizione del lavoro di un architetto di rete o Network & System Architect, definizione inglese, può comprendere le seguenti competenze tecniche:

  • Comprensione avanzata della progettazione dell’architettura tecnica
  • Esperienza di infrastruttura di rete
  • Esperienza nell’installazione e configurazione di hardware di rete
  • Manutenzione di router e switch
  • Gestione dell’installazione di firewall e monitoraggio continuo
  • Conoscenza approfondita dei principi di sicurezza di rete e dei protocolli di cybersecurity
  • Conoscenza dei bilanciatori di carico e della loro applicazione ottimale
  • Conoscenza approfondita dei principi di sicurezza della rete e dei protocolli di cybersecurity
  • Conoscenza dei bilanciatori di carico e della loro migliore applicazione
  • Esperienza di assistenza tecnica
  • Conoscenza delle reti private virtuali (VPN)
  • Esperienza con il sistema dei nomi di dominio (DNS)
  • Conoscenza dei framework di rete e dell’impatto dell’utilizzo di diversi tipi
  • Migliori pratiche del protocollo di controllo della trasmissione/protocollo Internet (TCP/IP)
  • Conoscenza di IPv6
  • Esperienza con la segmentazione della rete
  • Conoscenza generale dello sviluppo del software e del suo impatto sulle esigenze di rete
  • Conoscenza fondamentale dei sistemi operativi e del loro impatto sulla progettazione della rete

Le competenze trasversali o ``soft skills`` utili ad un Network & System Architect possono essere le seguenti:

  • Forti capacità analitiche, di pensiero critico e di risoluzione dei problemi per aiutare a risolvere problemi complessi.
  • Buone capacità di comunicazione per gestire il trasferimento delle conoscenze e la risoluzione dei problemi con gli utenti finali.
  • Attenzione meticolosa ai dettagli nello sviluppo del progetto e della documentazione.
  • Gestione efficace del team per garantire una gestione appropriata di tutte le attività e i problemi relativi alla rete.

Requisiti di istruzione e certificazione

Le conoscenze dell’architetto di rete prevedono, solitamente, la laurea. I datori di lavoro spesso cercano un’istruzione in un campo correlato, come l’informatica, le scienze informatiche, i sistemi informatici o una laurea in ingegneria. Alcune organizzazioni più piccole possono accettare un titolo di studio associato per una posizione entry-level, ma in genere è preferibile un’istruzione superiore.

Le certificazioni IT aiutano a colmare eventuali lacune nelle competenze e a dimostrare la conoscenza di aree che potrebbero non essere immediatamente evidenti data l’esperienza passata. Le certificazioni consigliate per gli architetti di rete includono:

  • CompTIA Network+
  • CompTIA Security+
  • Certified Information Systems Security Professional (CISSP)
  • Cisco Certified Internetwork Expert Routing and Switching (CCIE R&S)
  • Cisco Certified Network Associate (CCNA)
  • Cisco Certified Network Professional (CCNP)
  • Cisco Certified Design Expert (CCDE)
  • CCIE Enterprise Infrastructure Certification
  • VMware Certified Professional
  • VMware Certified Advanced Professional
  • VMware Certified Design Expert
Tips & Tricks,vmdk,find,head,tail, kali

Tips & Tricks: Correggere gli Errori e Compattare i file vmdk in VMware Workstation
1920 1280 Nicola Montemurro

Correggere gli Errori e Compattare i file vmdk in VMware Workstation

Tips & Tricks del giorno.

Questa guida mostra come è possibile ridurre i file del disco virtuale in modalità “Thin Provision” (con estensione .vmdk) delle macchine virtuali VMware Workstation in modo che, se compressi, occupino molto meno spazio.

Questo script correggere gli errori e compatta i file vmdk.

Versione Windows:

:: ----------------------------------------------------------------------------------
:: - File Name : vmdk-shrink.cmd
:: - Author : Nicola Montemurro
:: - Administrator : Nicola Montemurro - Mobile: -
:: - Create : 18/01/2021
:: - Last Update : 02/12/2022
:: - Description : VMware vmdk shrinker 
:: - Position : E:\Progetti\software\scripts\cmd
:: - Note : NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
:: -----------------------------------------------------------------------------------
@echo off

set VMDIR="F:\VMware VM"

for /f "tokens=*" %%D in ('dir %VMDIR%\*.vmdk /A-D /S /B') do (
echo .
echo Checking "%%D"
vmware-vdiskmanager.exe -e "%%D"
echo .
echo Repairing "%%D"
vmware-vdiskmanager.exe -R "%%D"
echo .
echo Shrinking "%%D"
vmware-vdiskmanager.exe -k "%%D"
)

In alcune circostanze, su Windows, si verifica l’errore seguente, si tratta di un errore conosciuto dagli sviluppatori VMWare, che potete ignorare.

SSLConfigLoad: Failed to load OpenSSL config file.

Versione Linux:

# ----------------------------------------------------------------------------------
# - File Name : vmdk-shrink.sh
# - Author : Nicola Montemurro
# - Administrator : Nicola Montemurro - Mobile: -
# - Create : 18/01/2021
# - Last Update : 02/12/2022
# - Description : VMware vmdk shrinker
# - Position : /usr/local/scripts
# - Note : NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
# -----------------------------------------------------------------------------------
#!/usr/bin/bash

VMDIR=~/vmware

find $VMDIR -type f -name *.vmdk -exec vmware-vdiskmanager -e {} \; \
-exec vmware-vdiskmanager -R {} \; \
-exec vmware-vdiskmanager -k {} \;
OpenSSL 3.5.0, openvpn, pqc, quantum safe

OpenSSL 3.5.0 con supporto per la crittografia post-quantistica (PQC)
1920 1280 Nicola Montemurro

OpenSSL 3.5.0 con supporto per la crittografia post-quantistica

OpenSSL 3.5.0 con supporto per la crittografia post-quantistica rilasciato l’8 Aprile 2025, destinato a rivoluzionare la sicurezza informatica, rispondendo alla crescente esigenza di una crittografia resistente ai quanti (PQC).

Come già esposto nell’articolo Standard di crittografia Post-Quantum: Il NIST completa la standardizzazione per affrontare le minacce dei computer quantistici occorre che gli amministratore di sistema, inizino ad adottare i necessari correttivi per mantenere gli adeguati standard di sicurezza.

Punti salienti di OpenSSL 3.5.0

1 - Algoritmi di crittografia post-quantistica

OpenSSL 3.5.0 introduce il supporto per tre importanti algoritmi di CQP:

  • ML-KEM (Module Lattice-Based Key Encapsulation Mechanism): Un meccanismo di scambio di chiavi sicuro, progettato per resistere agli attacchi dell’informatica quantistica.
  • ML-DSA (Module Lattice-Based Digital Signature Algorithm): Un robusto algoritmo di firma basato su strutture reticolari, che garantisce autenticità e non ripudio.
  • SLH-DSA (Stateless Hash-Based Digital Signature Algorithm): Un metodo di firma basato su hash che sfrutta il framework SPHINCS+ per una maggiore sicurezza.

Questi algoritmi sono conformi agli standard emergenti e sono fondamentali per prepararsi a un mondo post-quantistico in cui i metodi crittografici classici potrebbero non essere più sicuri (vedi articolo già trattato qui).

Per informazioni dettagliate potete consultare la bozza del memo ietf draft-ietf-tls-ecdhe-mlkem-00

2 - Supporto TLS migliorato

L’elenco predefinito dei gruppi TLS supportati è stato aggiornato per includere i gruppi ibridi PQC Key Encapsulation Mechanism (KEM), dando priorità alle opzioni sicure dal punto di vista quantistico e rimuovendo i gruppi usati raramente. Inoltre, i keyshares TLS predefiniti offrono ora X25519MLKEM768 e X25519, consentendo meccanismi di scambio di chiavi più robusti.

3 - Supporto del protocollo QUIC

OpenSSL 3.5.0 aggiunge il supporto lato server per QUIC (Quick UDP Internet Connections), standardizzato in RFC 9000. Questa funzione include la compatibilità con stack QUIC di terze parti e supporta connessioni 0-RTT per una comunicazione più veloce ed efficiente.

4 - Nuove opzioni di configurazione e funzionalità

La release introduce diverse nuove funzionalità:

  • no-tls-deprecated-ec: Disabilita il supporto per i gruppi TLS deprecati.
  • enable-fips-jitter: Consente al provider FIPS di utilizzare la fonte di entropia JITTER per una maggiore casualità.
  • Oggetti chiave simmetrica opachi (EVP_SKEY): Migliora la gestione sicura delle chiavi.
  • Generazione centralizzata delle chiavi in CMP: semplifica la gestione crittografica.

Cambiamenti di compatibilità e deprecazioni
OpenSSL 3.5.0 apporta anche alcuni cambiamenti potenzialmente incompatibili:

  • Il cifrario predefinito per alcune applicazioni come req, cms e smime è stato aggiornato da des-ede3-cbc a aes-256-cbc.
  • Tutte le funzioni BIO_meth_get_*() sono state deprecate.

Un problema notevole in questa versione riguarda la chiamata di SSL_accept sugli oggetti restituiti da SSL_accept_connection, che attualmente provoca un errore. Si consiglia agli utenti di utilizzare SSL_do_handshake come soluzione alternativa fino a quando non verrà implementata una correzione in OpenSSL 3.5.1.

Con OpenSSL 3.5.0, il progetto compie un passo coraggioso nell’era quantistica, dotando gli sviluppatori e le organizzazioni di strumenti per salvaguardare i dati dalle future minacce quantistiche, mantenendo al contempo la compatibilità con i sistemi esistenti.

Questo rilascio sottolinea l’impegno di OpenSSL per l’innovazione e la sicurezza in un panorama digitale in continua evoluzione.

Tips & Tricks,vmdk,find,head,tail, kali

Tips & Tricks: Risoluzione di “An error occurred during the signature verification” in Kali Linux
1920 1280 Nicola Montemurro

Tips & Tricks del giorno.

Per coloro che cercando di aggiornare l’ultima versione dell’elenco dei pacchetti dal repository software di Kali Linux e da qualsiasi repository di terze parti eventualmente configurato e all’esecuzione del comando:

apt update

dovessero visualizzare i seguenti messaggi di avviso:

Warning: An error occurred during the signature verification. The repository is not updated and the previous index files will be used. OpenPGP signature verification failed: https://http.kali.org/kali kali-rolling InRelease: Sub-process /usr/bin/sqv returned an error code (1), error message is: Missing key 827C8569F2518CC677FECA1AED65462EC8D5E4C5, which is needed to verify signature.
Warning: Failed to fetch https://http.kali.org/kali/dists/kali-rolling/InRelease Sub-process /usr/bin/sqv returned an error code (1), error message is: Missing key 827C8569F2518CC677FECA1AED65462EC8D5E4C5, which is needed to verify signature.
Warning: Some index files failed to download. They have been ignored, or old ones used instead.

è molto probabile che non su tratti di un problema del vostro sistema, ma come da comunicato sul sito ufficiale di Kali Linux, si tratta di un problema dovuto alla perdita delle firme digitali(chiavi) del repository, che sono state ricreate.

Per recuperare le nuove firme, occorre seguire quanto indicato di seguito:

# download del package

wget https://http.kali.org/kali/pool/main/k/kali-archive-keyring/kali-archive-keyring_2025.1_all.deb -O /usr/src/kali-archive-keyring_2025.1_all.ded

# installazione

sudo dpkg -i /usr/src/kali-archive-keyring_2025.1_all.deb

# pulizia

rm -f /usr/src/kali-archive-keyring_2025.1_all.deb

Al termine sarete nuovamente in grado di aggiornare dal repository all’ultima versione.

Algoritmi resistenti ai quanti o quantum resistant

Algoritmi resistenti ai quanti o quantum resistant, cosa sono e perché sono necessari?
1920 1280 Nicola Montemurro

Algoritmi resistenti ai quanti o quantum resistant

Quando i computer quantistici diventeranno abbastanza potenti ed è ragionevole pensare che già lo siano, saranno in grado di decifrare alcune chiavi di crittografia comunemente utilizzate, in un tempo decisamente breve.

Immaginate un ladro che, invece di scassinare una cassaforte, faccia evaporare le sue pareti con una tecnologia fuori da ogni legge fisica conosciuta. Ecco la rivoluzione (e la minaccia) dei computer quantistici per quanto concerne la sicurezza informatica. Mentre i sistemi classici faticano con calcoli secolari, i calcolatori quantistici sfruttano la sovrapposizione quantistica e l’entanglement per operazioni milioni di volte più veloci. Il risultato? Lo tsunami che travolge le fondamenta della crittografia moderna.

Ecco perché si sta lavorando alacremente per progettare nuovi tipi di algoritmi che siano resistenti anche al più potente computer quantistico che possiamo immaginare.

Crittografia Asimmetrica: Il crollo delle mura

Tutta la sicurezza online,  dalle email alle criptovalute, poggia su algoritmi come RSA e ECC. La loro forza? Problemi matematici intrattabili per i computer tradizionali, come fattorizzare numeri giganteschi o risolvere logaritmi discreti.
La mannaia si chiama Algoritmo di fattorizzazione di Shor, un algoritmo quantistico che sminuzza questi problemi in tempo polinomiale. Come? Sfruttando la capacità di eseguire calcoli in parallelo in spazi di stati multipli. Conseguenza: una volta operativi, computer quantistici sufficientemente potenti sgretoleranno RSA-2048 come fosse vetro.

Crittografia Simmetrica: Le mura che resistono (al momento)

Per AES, 3DES e simili, la minaccia è più sottile ma non letale. L’algoritmo di ricerca di Grover accelera la ricerca della chiave tramite un’”intuizione quantistica”, riducendo la complessità da \(2^n\) a \(2(^n/2)\).

Un esempio concreto:

AES-128 oggi richiederebbe 21282128 tentativi → impossibile.
Con Grover: 264264 → fattibile per un quantum computer di grandi dimensioni.

La soluzione:

Raddoppiare la dimensione delle chiavi; AES-256 resisterebbe, riportando l’attacco a 21282128 tentativi, un muro ancora invalicabile.

Conclusione:

Il quantum computing non è fantascienza: è una tempesta all’orizzonte. Per la crittografia asimmetrica è la fine di un’era, per quella simmetrica un campanello d’allarme che impone chiavi più lunghe. La buona notizia? La migrazione verso soluzioni quantum-resistant è già iniziata.

Standard Post-Quantum (PQC): Il NIST sta già selezionando algoritmi a prova di quanti, basati su reticoli, funzioni hash o codici correttori (argomento già trattato qui).
Quantum Key Distribution (QKD): Sfrutta la fisica quantistica per distribuire chiavi inviolabili—ma è costosa e pratica solo in scenari specifici.

Il messaggio agli esperti di cybersecurity è chiaro: innovare oggi, per non essere crackati domani.

La Corsa Contro il Tempo

Non occorre allarmismo, i quantum computer pratici e stabili per queste imprese non esistono ancora, ma è bene tenere presente che la posta in gioco è troppo alta per aspettare; la corsa è aperta.

Tips & Tricks,vmdk,find,head,tail, kali

Tips & Tricks: head e tail per estrarre contenuti da un file di testo
1920 1280 Nicola Montemurro

Tips & Tricks del giorno.

A volte, potrebbe essere necessario conoscere il contenuto di una specifica riga oppure un intervallo di righe di un file testo senza doverlo aprire con un editor, soprattutto se l’operazione deve essere fatta in modo non interattivo; la soluzione di usare head e tail combinati si dimostra essere utile soprattutto nel caso in cui il file in questione sia di grandi dimensioni.

Preparare il file da utilizzare per le prove, contenente un numero arbitrario di righe (in questo caso 100).

root@kali:~# for i in $(seq 1 1 100); do echo "Line number $i" >> test.txt; done

Verificare il contenuto del file, appena creato.

root@kali:~# cat test.txt

Line number 1
Line number 2
Line number 3
.....
Line number 98
Line number 99
Line number 100

Gestire lo stream di dati, partendo dall'alto

Per visualizzare una specifica riga (es. riga 15):

Attraverso la pipeline , si procedera’ a ridurre, sempre di più il numero di righe necessario, fino ad ottenere il risultato aspettato; Lo stream del file contenente 100 righe, generato dal comando cat, sara’ inviato, al comando head, che attraverso l’opzione -15, considerera’ solo le prime 15 righe; sara’, poi, inviato al comando tail, che attraverso l’opzione -1 considerera’ solo la prima riga, dal basso, l’ultima dello stream, di 15 righe, ricevuto da head, che sara’, quindi, inviata, in questo caso, alla console o terminale per essere visualizzato (Line number 15).

root@kali:~# cat test.txt | head -15 |tail -1
Line number 15

Per un range di righe specifico (es dalla riga 37 alla riga 39), digitare:

root@kali:~# cat test.txt | head -39 |tail -3
Line number 37
Line number 38
Line number 39

Gestire lo stream di dati, partendo dal basso

Questo metodo, è sicuramente controintuitivo, ma potrebbe rivelarsi essere utile nel caso il file contenesse molte righe (milioni) e l’informazione di cui avete bisogno, potrebbe risiedere verso il fondo, in pratica nella seconda metà del file per evitare di produrre uno stream da tutto il file inutilmente.

Il questo caso, abbiamo bisogno di avere una informazione aggiuntiva; contando dall’alto, la prima riga del file è la riga uno (1), per contare dal basso, occorre, quindi, conoscere il numero dell’ultima riga del file.

root@kali:~# cat test.txt |wc -l
100

Conoscendo, che il file è composto da 100 righe per estrarre la riga 90 digitare:

root@kali:~# cat test.txt |tail -11| head -1
Line number 90

Per un range di righe specifico (es dalla 75 alla 79) digitare:

root@kali:~# cat test.txt |tail -26| head -5
Line number 75
Line number 76
Line number 77
Line number 78
Line number 79

Considerazioni finali

In questo articolo abbiamo esplorato l’uso essenziale dei comandi Linux head e tail,  svelandone le funzionalità, le applicazioni e le sinergie, nel conteggio delle righe di file di testo; vi invito ad approfondire questi comandi e a sperimentare gli esempi fin qui visti per sfruttare tutto il loro potenziale.

rsa, ecdsa, ancription, crittografia, algoritmo, firma

Crittografia: Confronto tra ECDSA e RSA
1920 1280 Nicola Montemurro

In questo articolo metteremo a confronto due metodi di firma digitale ampiamente utilizzati: ECDSA (Elliptic Curve Digital Signature Algorithm) e RSA (che prende il nome dai suoi inventori: Rivest, Shamir e Adleman.), algoritmi crittografici che differiscono per caratteristiche come la dimensione della chiave, le risorse necessarie e di conseguenza, le prestazioni.

Confronto:

ECDSA utilizza in genere chiavi di dimensioni comprese tra 256 e 384 bit. Nonostante le dimensioni ridotte, la chiave ECDSA offre un livello di sicurezza equivalente a chiavi RSA molto più grandi. Ad esempio, una chiave ECDSA a 256 bit offre una sicurezza paragonabile a una chiave RSA a 3072 bit.

RSA utilizza comunemente chiavi di dimensioni comprese tra 2048 e 4096 bit. Per raggiungere lo stesso livello di sicurezza di ECDSA, sono necessarie chiavi più grandi. Ad esempio, una chiave RSA a 2048 bit è approssimativamente equivalente in termini di sicurezza a una chiave ECDSA a 224 bit.

Prestazioni e velocità

ECDSA eccelle in termini di prestazioni, offrendo una maggiore velocità di generazione delle chiavi e di creazione e verifica delle firme. La sua efficienza lo rende ideale per i dispositivi con potenza di elaborazione limitata.

RSA tende a essere più lento, soprattutto durante la generazione della chiave e la creazione della firma. La verifica può essere relativamente veloce, ma nel complesso RSA richiede più risorse di calcolo, il che può rappresentare un limite in ambienti con risorse limitate.

Uso delle risorse

ECDSA utilizza meno potenza di calcolo, memoria ed energia, rendendolo adatto a dispositivi con risorse limitate.

RSA consuma più potenza di calcolo e memoria e di conseguenza, più energia, il che è accettabile per i sistemi con ampie risorse ma può essere uno svantaggio per i dispositivi più piccoli.

Adozione e compatibilità

ECDSA è sempre più diffuso, soprattutto nei sistemi e nelle applicazioni moderne. È supportato dalla maggior parte dei nuovi browser e piattaforme web. Tuttavia, la compatibilità con i sistemi più vecchi può essere limitata.

RSA rimane ampiamente utilizzato ed è compatibile con quasi tutti i sistemi, comprese le piattaforme legacy. È la scelta standard per molte applicazioni esistenti ed è ben conosciuta dai professionisti della sicurezza.

Resistenza post-quantistica: Prepararsi alle minacce future

Entrambi gli algoritmi potrebbero essere vulnerabili ai futuri sviluppi dei computer quantistici, che potrebbero decifrare le attuali tecniche crittografiche. Sebbene entrambe le tecnologie siano vulnerabili a attacchi quantistici, RSA potrebbe essere più costoso da attaccare rispetto a ECDSA, ma entrambe potrebbero richiedere una transizione a metodi crittografici resistenti ai computer quantistici (vedi Standard di crittografia Post-Quantum: Il NIST completa la standardizzazione per affrontare le minacce dei computer quantistici), come la crittografia basata su reticolo. (vedi teoria dei gruppi).

Considerazioni finali:

Sia ECDSA che RSA sono algoritmi crittografici efficaci per proteggere le informazioni digitali attraverso le firme digitali, ciascuno con i propri punti di forza. ECDSA offre vantaggi in termini di velocità ed efficienza delle risorse, rendendolo adatto alle applicazioni moderne e ai dispositivi con risorse limitate, mentre RSA offre un’ampia compatibilità ed è ben consolidato in vari sistemi. Per decidere tra i due, è necessario considerare fattori quali i requisiti di prestazione, la disponibilità di risorse, la compatibilità del sistema e le esigenze di sicurezza a lungo termine. Indipendentemente dalla scelta, l’implementazione corretta degli algoritmi e il rispetto delle migliori pratiche di sicurezza sono fondamentali per mantenere l’integrità e la riservatezza delle comunicazioni digitali.

encryption, quantum, quantum computing, crittografia

Standard di crittografia Post-Quantum: Il NIST completa la standardizzazione per affrontare le minacce dei computer quantistici
1920 1280 Nicola Montemurro

Il National Institute of Standards and Technology (NIST) degli Stati Uniti ha annunciato il completamento della standardizzazione di un set di algoritmi di crittografia progettati per proteggere i dati da attacchi informatici provenienti da computer quantistici. Questa iniziativa fa parte del progetto di standardizzazione della crittografia post-quantistica (PQC), che mira a garantire la sicurezza delle informazioni nell’era dei computer quantistici.

L’Evoluzione del Quantum Computing e le Sue Implicazioni sulla Sicurezza

Il quantum computing, con la sua capacità di risolvere rapidamente complessi problemi matematici, rappresenta una minaccia per la crittografia tradizionale, che si basa su difficoltà computazionali insormontabili per i computer convenzionali. Tuttavia, un computer quantistico sufficientemente potente potrebbe, in futuro, eludere questi sistemi di sicurezza. Gli algoritmi recentemente standardizzati dal NIST sono basati su nuove sfide matematiche che mettono in difficoltà sia i computer tradizionali che quelli quantistici, garantendo quindi una protezione più robusta.

Una Nuova Era per la Sicurezza Digitale

La crittografia gioca un ruolo fondamentale nella protezione di segreti elettronici, dai messaggi e-mail ai dati sensibili legati alla salute, fino alle informazioni vitali per la sicurezza nazionale”, ha dichiarato Laurie E. Locascio, Direttore del NIST. “Con i nuovi algoritmi, possiamo affrontare le sfide future garantendo che la sicurezza delle nostre informazioni non venga compromessa dalla tecnologia quantistica.

Le Novità della Standardizzazione

Gli algoritmi finalizzati dal NIST comprendono il codice informatico, le istruzioni per l’implementazione e gli usi previsti, e sono pronti per essere integrati nei sistemi di crittografia esistenti. Dustin Moody, responsabile del progetto PQC del NIST, ha enfatizzato l’importanza di integrare questi algoritmi il prima possibile: “Invitiamo gli amministratori di sistema a iniziare l’integrazione, poiché la completa adozione richiederà tempo”, ha dichiarato Moody.

In parallelo, il NIST continua a valutare altri set di algoritmi che potrebbero fungere da backup in futuro. Due categorie di algoritmi sono ancora in fase di valutazione: una dedicata alla crittografia generale e una per la protezione delle firme digitali. Entro la fine del 2024, il NIST prevede di selezionare uno o due algoritmi aggiuntivi per la crittografia generale, mentre una nuova valutazione di circa 15 algoritmi per le firme digitali sarà annunciata prossimamente.

Un Futuro Preparato per le Sfide Quantistiche

“Non c’è bisogno di aspettare gli standard futuri”, ha sottolineato Moody. “I tre algoritmi finalizzati sono già pronti per l’uso e, per la maggior parte delle applicazioni, rappresentano la principale soluzione di sicurezza digitale. Continueremo a sviluppare piani di backup, ma la nostra priorità è essere pronti a fronteggiare le minacce immediate”.

Considerazioni finali

La protezione delle informazioni digitali sta entrando in una nuova fase, alimentata dalla necessità di difendersi dai rischi legati ai computer quantistici. Con la pubblicazione di questi nuovi standard, il NIST rafforza il suo ruolo di leader nella protezione delle comunicazioni globali e nella sicurezza digitale, preparandosi a fronteggiare le sfide tecnologiche del futuro.

Fonti: National Institute of Standards and Technology (NIST)
Dipartimento del Commercio degli Stati Uniti

Tips & Tricks,vmdk,find,head,tail, kali

Tips & Tricks: Python per Sottrarre Giorni, Mesi, Anni dalla Data
1920 1280 Nicola Montemurro

Tips & Tricks del giorno.

A volte in uno script può essere necessario sottrarre o eventualmente sommare un numero arbitrario di giorni e/o mesi e/o anni da una data;

Ecco l’esempio di una soluzione per la sottrazione; per l’addizione é sufficiente invertire il segno di ciascuna variabile.

Versione Bash:

# ----------------------------------------------------------------------------------
# - Script file name    :       subtractdate.sh
# - Author              :       NM
# - DNS administrator   :       NM  - Tel. xxx, Mobile: xxx -
# - Create              :       28.12.2009
# - Last Update         :       28.12.2009
# - Description         :       Sottrae n giorni dalla data attuale
# - Position            :       /usr/local/script/
# - note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  -----------------------------------------------------------------------------------

#!/bin/bash

DAYS=$1
MONTHS=$2
YEARS=$3

[ -z $DAYS ] && DAYS=0
[ -z $MONTHS ] && MONTHS=0
[ -z $YEARS ] && YEARS=0


RESDATE=$(date -d "$date -$DAYS days -$MONTHS months -$YEARS years" '+%d/%m/%Y')

echo $RESDATE

Versione Powershell:

[CmdletBinding()]
Param(
    [Parameter(Mandatory=$false)][int]$days,
    [Parameter(Mandatory=$false)][int]$months,
    [Parameter(Mandatory=$false)][int]$years 
    )
        
    Process {
        if (($days -eq $null) || ($days -eq "")) {
            $days=0
        }
        if (($months -eq $null) || ($months -eq "")) {
            $months=0
        }
        if (($years -eq $null) || ($years -eq "")) {
            $years=0
        }
    
        $today = Get-Date
    
        return $($($today.AddYears(-$years).AddMonths(-$months)).AddDays(-$days))
    }

 

Segui:

Se sei interessato ad altri vai alla sezione: Tips & Tricks

reti rete dmz switch fibra ottica

Rete DMZ, facciamo chiarezza
1920 1280 Nicola Montemurro

Cos'è la DMZ

Con il termine DMZ, zona demilitarizzata, in informatica, si intende la sottorete, posta tra la rete locale, LAN, e altre reti considerati non attendibili, quali Internet, WAN, ma non solo. Qualsiasi servizio, sia esso destinato a utenti Internet o destinato ad utenti di reti terze, dovrebbe transitare dalla rete DMZ.

Non è insolito, però, che la gestione della DMZ, segua le regole dell’anarchia, ognuno posiziona server, in questa rete, secondo i criteri più disparati; sovente, in dmz, mi è capitato di trovare il server WEB con il sito istituzionale, il server WEB del CRM dell’ufficio del personale, il server SQL, il server Proxy, il server FTP, il server Active Directory, il file server, il centralino, il server per la gestione dell’antifurto, e una volta anche un AS400.

Fermi tutti!!!, Facciamo chiarezza

Nella realtà, la zona demilitarizzata è quella striscia di terra posta tra due confini di stato; gli stati che confinano sono due e i confini sono due, entrambi, militarizzati, separati da un lembo di terra considerata non appartenente ad alcuno dei due stati, quindi demilitarizzata, gli unici punti di contatto tra i due confini è rappresentato dai checkpoint di frontiera; sono certo che, anche a voi, osservandola da questo punto di vista la DMZ non vi apparirà più una zona sicura.

La capitale

Avvicinandoci al contesto informatico, ma comunque seguendo la paràfrasi dei confini e degli stati, per un momento NON consideriamo i DATI della vostra azienda come IL Capitale, ma come LA Capitale; stando a quanto appena esposto, andreste a costruire LA Capitale del vostro stato nella DMZ?

Provo a rispondere per voi, NO, non lo fareste, anzi la costruireste dietro alla linea di confine militarizzata, ben protetta dai militari.

L'uso corretto della DMZ

Abbandonando le parafrasi e riportando l’argomento in ambito informatico, la DMZ è quella rete che deve essere posta tra due firewall (i confini antrambi militarizzati) nella quale NON devono essere contenuti dati (La capitale)  in cui i server devono sono avere il compito di verificare (i checkpoint di frontiera); deve essere considerata solo una rete di transito.

Nella DMZ, devono essere ospitati solo server vuoti ed eventualmente sacrificabili; in caso di attacco, se dovessero essere violati, l’impatto sarebbe contenuto. I dati, di contro, devono insistere su altre reti, sempre protette firewall, che nel caso delle architetture a doppio bastione è sempre quello interno.

La regola principe

Tra l’utente e i dati devono esistere, almeno, due livelli di firewall.

L’interposizione di più livelli di controllo la si può realizzare, contringendo il flusso ad  attraversare il firewall più volte.

L'esempio comune

Ipotizzando di creare, sul firewall,  tre reti distinte, nella prima si posizione il database server, nella seconda l’application server, nella terza (la DMZ) il web server; in questo modo, l’utente, attraverserà il firewall per fare la richiesta al web server, il quale, attraversando in firewall, farà la richiesta al application server, il quale, attraversando il firewall, farà la richiesta al database server.

utente <=|=> web server <=|=> application server <=|=> database server

In questo modo sarete in grado di controllare tutto il flusso; potete controllare quale utente può accedere al web server, potete controllare l’accesso all’application server, autorizzando solo a quel web server e potete controllare l’accesso al database server autorizzando solo quell’application server.

Qualora, application server e web server non siano separabili, si fanno “scivolare in basso”, al secondo livello, e si aggiunge un reverse proxy al posto del web server.

utente <=|=> reverse proxy <=|=> web application server <=|=> database server

Considerazioni finali

Come, sicuramente, avrete notato, in entrambe le soluzioni, nella DMZ, insiste solo il web server o il reverse proxy, unico punto di contatto con gli utenti, siano essi provenienti dalla reti interne, oppure da internet; le altre reti, in particolare quella sulla quale insiste il database server, è ben lontana dall’essere raggiungibile.

BIND, dns, bind, dominio, domini

BIND: Configurazione delle Viste (view) DNS in Chroot
1920 1280 Nicola Montemurro

BIND: Configurazione delle Viste (view) DNS in Chroot

Premessa

Prima di iniziare a descrivere la configurazione DNS a viste (view) con BIND in ambiente Chroot, già anticipata nell’articolo BIND e Chroot: Compilazione e installazione occorre descrivere cosa sono le viste (view)  DNS e perchè si utilizzano.

Cosa sono le viste in BIND?

La configurazione delle viste in BIND consente di gestire in modo più flessibile le risoluzioni DNS, permettendo di fornire risposte differenti a query provenienti da fonti differenti. Questa funzionalità è particolarmente utile negli scenari complessi, come reti aziendali o ISP, dove è necessario gestire accessi in modo granulare ai dati DNS; permettono di definire diverse configurazioni di zone per diverse categorie di client. Ogni vista può avere record DNS distinti, e il server DNS restituisce la risposta corretta in base all’indirizzo IP del client che fa la richiesta.

Facendo l’esempio della Società che possiede più BU (Business Unit) distribuite sul territorio, ciascuna con il proprio ramo di rete (branch), con il proprio server CMS posto all’interno del datacenter della Società, potrebbero entrambi usare la stessa URL (cms.esempio.com), per terminare su server differenti, così per gli utenti VPN di ciascuna BU, mentre per gli utenti internet, la richiesta di accesso alla medesima URL potrebbe terminare sul CMS della società.

Realizzazione di una configurazione di esempio

Nei passaggi seguenti, saranno indicati percorsi, che saranno implicitamente, ricondotti alla root jail, creata dello script pubblicato nell’articolo “Bind e Chroot: Compilazione e Installazione“; La sostanza non cambia, per coloro che desiderassero effettuare una installazione senza root jail, che dovranno solo modificare il percorso dei file adattandoli al proprio ambiente.

File e directory principali

L’elenco delle directory della root jail è questo;

[root@fe01 ~]# cd /jail/named
[root@fe01 named]# ls -l
total 0
drwxr-xr-x 2 named named 59 Oct 2 12:08 dev
drwxr-xr-x 2 named named 23 Oct 2 12:08 etc
drwxr-xr-x 2 named named 6 Oct 2 12:08 master
drwxr-xr-x 2 named named 6 Oct 2 12:08 reverse
drwxr-xr-x 2 named named 6 Oct 2 12:08 slave
drwxr-xr-x 4 named named 31 Oct 2 12:08 usr
drwxr-xr-x 6 named named 53 Oct 2 12:08 var
[root@fe01 named]# cd etc/
[root@fe01 etc]# ls -l
total 36
-rw-r--r-- 1 named named 2641 Oct 2 12:08 localtime
-rw-r--r-- 1 named named 1277 Oct 2 17:07 named.acl
-rw-r--r-- 1 named named 4532 Oct 2 17:04 named.conf
-rw-r--r-- 1 named named 2839 Oct 2 16:46 named.logger
-rw-r--r-- 1 named named 441 Oct 2 16:47 rndc.key

Il file fondamentale per il funzionamento di BIND è il named.conf che deve trovarsi nella directory /etc  e può contenere tutta la configurazione oppure essere suddivisa in più file, per una migliore gestione.

In questo esempio, suddivideremo la configurazione, anche per aiutare a comprendere ciascun contesto; spiegheremo i punti salienti per aiutare a comprendere il concetto di vista (view), senza entrare nel merito di ciascuna istruzione, che potrà essere verificata nella documentazione ufficiale;

Esempio di file named.conf

# -----------------------------------------------------------------------------
# - Zone file name      :       named.conf
# - Author              :       NM
# - DNS administrator   :       NM
# - Create              :       02.10.2024
# - Last Update         :       02.10.2024
# - Description         :       File di configurazione BIND su Linux Almalinux 9.2
# - Position            :       /etc
# - Info                :       
# - Note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  ----------------------------------------------------------------------------

Include "/etc/named.acl";
Include "/etc/named.logger";
#Include "/etc/rndc.key";

options { 
        directory "/";
//      Size of the sent packets
        max-udp-size 4096;
//      Size of received packets
        edns-udp-size 4096;
        listen-on { 127.0.0.1; 172.16.60.40; };
        dnssec-validation no;
        max-cache-size 1024M;  // 25% of MEM
        max-cache-ttl 60; // limit cached record to a 60s TTL
        max-ncache-ttl 60; // limit cache neg. resp. to a 60s TTL
        version "My Name is Bind, James Bind";
        forward first;
        forwarders { 8.8.8.8; 1.1.1.1; }; // da commentare con uso di root.hints
        // forwarders { IP.1.DNS.PROVIDER; IP.2.DNS.PROVIDER; }; // da commentare con uso di root.hints
        pid-file "/var/run/named.pid";
        dump-file "/var/dump/named.db";
        statistics-file "/var/stats/named.stats";
        transfers-in 100;
        transfers-out 100;
//        datasize 20M;
        allow-transfer { none; };
        allow-recursion { net-internals; };

   };


controls {
       inet 127.0.0.1 port 953
               allow { 127.0.0.1; } keys { "rndc-key"; };
  };

statistics-channels {
        inet 127.0.0.1 port 9999 allow { 127.0.0.1; };
  };
   

view "internal" {
        match-clients { !net-externals; net-internals; localhost; };
        allow-query { localhost; net-internals; };

        zone "." {
                type hint;
                file "root.hints";
        };

        zone "localhost" {
                type master;
                file "master/localhost/localhost.zone";
                allow-update { none; };
        };

        zone "0.0.127.in-addr.arpa" {
                type master;
                file "reverse/127.0.0.in-addr.arpa.zone";
                allow-update { none; };
        };

        zone "60.16.172.in-addr.arpa.zone" {
                type master;
                file "reverse/172.16.60.in-addr.arpa.zone";
                allow-update { none; };
        };

        zone "esempio.com"  {
                type master;
                file "master/esempio.com/int.esempio.com.zone";
                allow-update { none; };
        };

        zone "solutioncafe.it" { 
                type master; 
                file "master/solutioncafe.it/int.solutioncafe.it.zone"; 
                allow-update { none; }; 
        };

// FORWARD

        zone "esempio.loc"  {
                type forward;
                forwarders { 192.168.58.4; };
                forward only ;
        };

        zone "8.10.10.in-addr.arpa"    {
                type forward;
                forwarders { 10.10.100.1; };
                forward only ;
        };
        
        zone "7.10.10.in-addr.arpa"    {
                type forward;
                forwarders { 10.10.100.1; };
                forward only ;
        };
        
  }; // end internal view


view "external" {
      match-clients { any; };
      allow-recursion { net-externals; };
      allow-query { any; };

        zone "esempio.com"  { 
                type master;
                file "master/esempio.com/ext.esempio.com.zone";
                allow-query { any; };
        };

        zone "solutioncafe.it"  { 
                type master;
                file "master/solutioncafe.it/ext.solutioncafe.it.zone";
                allow-query { any; };
        };

  }; // end external view

descrizione: il file named.conf di esempio, si divide in:

configurazione globale: contiene la configurazione globale del server DNS;

  1. listen-on { 127.0.0.1; x.x.x.x; }; riferisce con quali indirizzo/i dell’ host erogare il servizio.
  2. forwarders { x.x.x.x; y.y.y.y;  }; riferisce a quale indirizzo/i inoltrare le richieste che non può risolvere in autonomia (last resort ).

view “internals”: contiene la lista dei nomi dei file di zona per ciascun dominio per il quale il DNS è autoritativo.

  1. match-clients { !net-externals; net-internals; localhost; };  si riferisce a quali gruppi di IP (clients) possono accedere a questa vista, in questo caso è negato l’accesso (!) al gruppo net-externals è invece permesso al gruppo net-internals e localhost;
  2. allow-query { localhost; net-internals; }; si riferisce a quali gruppi di IP (clients) che possono effettuare query alle zone per domini di questa vista.
  3. zone “.” si riferisce al dominio . (root); il file contiene la lista dei root DNS ai quale inoltrare le richieste che il DNS non può risolvere in autonomia; sostituisce i forwarders visti in precedenza qualora si abbia la possibilità di esporre a internet il DNS.
  4. // FORWARD  alla linea (linea 100), indica un gruppo di domini, per i quali non esiste il file di configurazione, ma la cui risoluzione deve essere inoltrata a un forwarders { x.x.x.x; }; specifico per ciascun dominio dell’elenco ed è diverso dagli indirizzi dei forwarders globali; questa tecnica è chiamata forwarding condizionale.

view “esternals”: contiene la lista dei nomi dei file di zona per ciascun dominio per il quale il DNS è autoritativo;

  1. match-clients { any; };  si riferisce a IP (clients) possono accedere a questa vista, in questo caso qualsiasi IP;
  2. allow-recursion { net-externals; };  indica che le query ricorsive, possono essere fatte solo dalle reti interne.

Il numero di viste è arbitrario, in questa configurazione mi sono limitato a specificarne due, per non complicare troppo l’esposizione.

Esempio di file named.acl

# -----------------------------------------------------------------------------
# - Zone file name      :       named.acl
# - Author              :       NM
# - DNS administrator   :       NM
# - Create              :       02.10.2024
# - Last Update         :       02.10.2024
# - Description         :       File di configurazione BIND Almalinux 9.2
# - Position            :       /jail/named/etc
# - note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  ----------------------------------------------------------------------------

// acl's "localhost", "none", "any", "localnets" are built-in in BIND
// NOTE: "localnets"  --> matches all the IP address(es) and subnetmasks of the server on which BIND is installed


acl "host-vpn-vps" {
        172.16.89.5/32;
  };

acl "net-vpn-roadwarrior" {
        172.16.88.0/25;
  };

acl "net-office" {
        10.10.7.0/27;
        10.10.8.0/27;
        172.16.60.32/27;
  };

acl "net-internals" {
        127.0.0.1;
        localhost;
        net-office;
        host-vpn-vps;
        net-vpn-roadwarrior;
  };

acl "net-externals" {
        5.2.22.56/29;             ### RETE PUBBLICA
        15.235.197.206/32;        ### HOST VPS (ipv4)
        2402:1f00:8000:800::19be; ### HOST VPS (ipv6)
  };

descrizione: Il file acl, raggruppa indirizzi IP di reti e host, poi utilizzati nel file named.conf per “condizionare” il comportamento del flusso di richieste; il file contiene tre gruppi in cui sono elencati i relativi indirizzi IP che vengono poi aggiunti, utilizzando il nome specifico, a ulteriori due gruppi che saranno, poi, utilizzati nelle viste.

La scelta di creare tre gruppi da confluire in ulteriori due gruppi, potrebbe sembrare inutile, ma la gestione granulare, realizzata in questo modo, agevola di molto leggibilità e di conseguenza la manutenzione, soprattutto i numero di reti da gestire è elevato; in ogni caso, nulla vieta di creare solo il gruppo da utilizzare nella vista (in questo caso due).

Esempio di file named.logger

# -----------------------------------------------------------------------------
# - Zone file name      :       named.logger
# - Author              :       NM
# - DNS administrator   :       NM
# - Create              :       02.10.2024
# - Last Update         :       02.10.2024
# - Description         :       File di configurazione BIND Almalinux 9.2
# - Position            :       /jail/named/etc
# - note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  ----------------------------------------------------------------------------
// defaults to use 7 files in rotation
// BIND 9.x parses the whole file before using the log
// failure messages up to this point are in (syslog) /var/log/messages

logging {
        channel log-syslog {
                syslog daemon;
                severity info;
                };

        channel log-config {
                file "var/log/config.log" versions 99 size 10M;
                severity info;
                print-severity yes;
                print-time yes;
                print-category yes;
                };

        channel log-client {
                file "var/log/client.log" versions 99 size 10M;
                severity info;
                print-severity yes;
                print-time yes;
                print-category yes;
                };

        channel log-query {
                file "var/log/query.log" versions 99 size 20M;
                severity info;
                print-severity yes;
                print-time yes;
                print-category yes;
                };

        channel log-security {
                file "var/log/security.log" versions 99 size 10M;
                severity info;
                print-severity yes;
                print-time yes;
                print-category yes;
                };

        channel log-xfer-in {
                file "/var/log/xfer-in.log" versions 99 size 10M;
                severity info;
                print-severity yes;
                print-time yes;
                print-category yes;
                };

        channel log-xfer-out {
                file "/var/log/xfer-out.log" versions 99 size 10M;
                severity info;
                print-severity yes;
                print-time yes;
                print-category yes;
                };

        category config {
                log-syslog;
                };

        category client {
                log-client;
                };

        category queries {
                log-query;
                };

        category security {
                log-security;
                };

        category xfer-in {
                log-xfer-in;
                };

        category xfer-out {
                log-xfer-out;
                };

  };

descrizione: nel file named.logger sono definite le regole di logging, il file di esempio permette la gestione separata per ciascuno dei sette canali implementato da BIND in modo di raccogliere le informazioni in modo granulare.

Esempio di file della zona interna (int.esempio.com.zone)

;# -----------------------------------------------------------------------------
;# - Zone file name      :       int.esempio.com.zone
;# - Author              :       NM
;# - DNS administrator   :       NM
;# - Create              :       02.10.2024
;# - Last Update         :       03.10.2024
;# - Description         :       file per la zona esempio.com
;# - Position            :       /master/esempio.com
;# - Info                :
;# - Note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
;#  ----------------------------------------------------------------------------

$TTL    86400

@       IN      SOA     ns1.esempio.com. admin.esempio.com. (

                          2024100201 ; Serial
                          3600       ; Refresh
                          1800       ; Retry
                          604800     ; Expire
                          86400 )    ; Negative Cache TTL
;

@       IN      NS      ns1.esempio.com.
@       IN      A       192.168.1.10

ns1     IN      A       172.16.60.40

www     IN      A       192.168.1.10

mail    IN      A       192.168.1.11
smtp    IN      CNAME   mail

Esempio di file della zona esterna (ext.esempio.com.zone)

;# -----------------------------------------------------------------------------
;# - Zone file name      :       ext.esempio.com.zone
;# - Author              :       NM
;# - DNS administrator   :       NM
;# - Create              :       02.10.2024
;# - Last Update         :       03.10.2024
;# - Description         :       file per la zona esempio.com
;# - Position            :       named/master/esempio.com
;# - Info                :
;# - Note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
;#  ----------------------------------------------------------------------------

$TTL    86400

@       IN      SOA     ns1.esempio.com. admin.esempio.com. (

                          2024100201 ; Serial
                          3600       ; Refresh
                          1800       ; Retry
                          604800     ; Expire
                          86400 )    ; Negative Cache TTL
;

@       IN      NS      ns1.esempio.com.

@       IN      A       203.0.113.10

ns1     IN      A       203.0.113.10
www     IN      A       203.0.113.10

mail    IN      A       203.0.113.11
smtp    IN      CNAME   smtp.myprovider.com.

Avvio del server DNS

tips & tricks

Per controllare che non ci siano errori di sintassi nel file named.conf, eseguite:

/usr/local/named/bin/named-checkconf -t /jail/named /etc/named.conf

Assegnazione dei permessi corretti a tutti i file nella root jail

chown -R named:named /jail/named

Avvio del server

systemctl restart named

Un’occhiata al log messages

tail -f /var/log/messages

Oct 2 21:18:01 fe01 named[4110]: automatic empty zone: view external: EMPTY.AS112.ARPA
Oct 2 21:18:01 fe01 named[4110]: automatic empty zone: view external: HOME.ARPA
Oct 2 21:18:01 fe01 named[4110]: automatic empty zone: view external: RESOLVER.ARPA
Oct 2 21:18:01 fe01 named[4110]: command channel listening on 127.0.0.1#953
Oct 2 21:18:01 fe01 named[4110]: managed-keys-zone/internal: loaded serial 0
Oct 2 21:18:01 fe01 named[4110]: managed-keys-zone/external: loaded serial 0
Oct 2 21:18:01 fe01 named[4110]: zone esempio.com/IN/internal: loaded serial 2024100201
Oct 2 21:18:01 fe01 named[4110]: zone esempio.com/IN/external: loaded serial 2024100201
Oct 2 21:18:01 fe01 named[4110]: all zones loaded
Oct 2 21:18:01 fe01 named[4110]: running

Verifica del processo

ps -ef |grep named

named 4110 1 0 21:18 ? 00:00:00 /usr/local/named/sbin/named -u named -t /jail/named -c /etc/named.conf -n 2

Prova di lookup, dal server dns stesso

[root@fe01 esempio.com]# nslookup
> www.esempio.com
Server: 172.16.60.40
Address: 172.16.60.40#53

Name: www.esempio.com
Address: 192.168.1.10
>

Prova di lookup da un server diverso su rete diversa

[root@web01 named]# nslookup
> www.esempio.com
Server: 203.0.113.10
Address: 203.0.113.10#53

Name: www.esempio.com
Address: 203.0.113.10
>

Considerazioni finali

La configurazione delle viste in BIND è uno strumento potente per gestire scenari DNS complessi, consentendo di personalizzare le risposte in base alle esigenze specifiche di diversi gruppi di client.

CA, certificato https ssl, tls, Certification Authority

CA, Certification Authority Pubbliche: La Sicurezza basata sulla Fiducia
1920 1280 Nicola Montemurro

La Sicurezza Digitale e la Fiducia tra Certification Authority e Utenti

La sicurezza delle comunicazioni online si basa su un sistema complesso di autenticazione e verifica. I certificati digitali svolgono un ruolo cruciale in questo ecosistema, garantendo autenticità, integrità e riservatezza nelle transazioni. Tuttavia, la sicurezza fornita dai certificati è direttamente collegata alla fiducia che gli utenti ripongono nelle Certification Authority (CA) che li emettono. Quando questa fiducia viene compromessa, le conseguenze possono essere significative.

Il Ruolo delle Certification Authority

Le Certification Authority sono responsabili della verifica dell’identità delle entità richiedenti certificati digitali. Una volta completata questa verifica, rilasciano certificati che attestano l’autenticità di un sito web o di un servizio. Gli utenti si aspettano che i certificati siano emessi in modo sicuro e rappresentino informazioni veritiere. Questa fiducia si basa su processi rigorosi di autenticazione e su pratiche di sicurezza consolidate dalle CA.

Compromissione della Fiducia

La compromissione di una CA può avvenire attraverso attacchi mirati, come il furto delle chiavi private. In tali casi, gli attaccanti possono emettere certificati falsi, alterando il panorama della sicurezza digitale. Questo scenario, già verificatosi in varie occasioni, suscita preoccupazioni importanti per la protezione delle comunicazioni online.

Conseguenze della Compromissione

Le ripercussioni di una compromissione della CA sono numerose e gravi:

  1. Frode e phishing: Gli attaccanti possono utilizzare certificati falsi per impersonare siti legittimi, facilitando attacchi di phishing che compromettono informazioni sensibili.
  2. Perdita di dati: Comunicazioni precedentemente sicure possono diventare vulnerabili, esponendo dati privati a malintenzionati.
  3. Danni reputazionali: Le aziende associate a certificati compromessi possono subire danni significativi alla loro reputazione, portando a una diminuzione della fiducia da parte dei clienti e a una conseguente riduzione delle vendite.
  4. Interruzioni operative: La necessità di revocare e sostituire certificati compromessi può causare interruzioni nei servizi, influenzando l’accesso degli utenti e la continuità operativa.
  5. Costi di recupero: Le organizzazioni colpite affrontano costi elevati per gestire la situazione, inclusi audit di sicurezza e implementazione di misure preventive.

Sanzioni legali: Se le aziende non riescono a proteggere adeguatamente i dati degli utenti, possono incorrere in sanzioni legali o normative, senza considerando i danni derivanti dalla perdita di reputazione.

Ecco un elenco di alcune compromissioni significative che hanno coinvolto diverse Certification Authority (CA) nel corso degli anni:

  1. Microsoft Trust Services (2020): Microsoft ha rivelato che alcuni certificati erano stati emessi erroneamente a causa di un errore di configurazione. Anche se non si è trattato di una compromissione in senso stretto, l’incidente ha suscitato preoccupazioni riguardo alla gestione dei certificati e alla sicurezza dei sistemi.
  2. DigiNotar (2011): La CA olandese DigiNotar è stata compromessa, portando all’emissione di certificati falsi per domini come Google e altri. Questo incidente ha avuto un impatto significativo, specialmente in Iran, dove i certificati sono stati utilizzati per attacchi di man-in-the-middle.
  3. Comodo (2011): Un attacco a Comodo, una delle CA più grandi, ha portato all’emissione non autorizzata di certificati per domini come Mozilla e Google. Comodo ha rapidamente revocato i certificati compromessi, ma l’incidente ha sollevato preoccupazioni sulla sicurezza. Microsoft ha collaborato con Comodo dopo un attacco alla CA, che ha portato all’emissione di certificati non autorizzati. L’incidente ha costretto Microsoft e altri grandi attori del settore a rivedere le loro politiche di sicurezza.
  4. Trustwave (2012): Anche se non direttamente legato a Microsoft, l’incidente di Trustwave, che ha emesso certificati per il monitoraggio del traffico HTTPS, ha avuto ripercussioni sulla fiducia nel sistema dei certificati digitali, influenzando anche l’ecosistema in cui operano aziende come Microsoft.
  5. StartCom (2016): StartCom, una CA di lunga data, è stata coinvolta in un incidente di compromissione che ha portato alla revoca di certificati. Questo ha anche portato a discussioni sul rispetto degli standard di sicurezza da parte delle CA.
  6. Let’s Encrypt (2020): Anche se Let’s Encrypt è generalmente considerata sicura, un incidente nel 2020 ha rivelato che un certificato era stato emesso erroneamente a causa di un errore nel processo di convalida. Questo ha spinto a una revisione delle procedure di emissione.
  7. GlobalSign (2011): Un attacco a GlobalSign ha portato all’emissione di certificati non autorizzati. Sebbene i dettagli fossero meno noti, l’incidente ha causato una sospensione temporanea della capacità della CA di emettere nuovi certificati.
  8. Symantec (2015): Symantec è stata coinvolta in un’importante controversia riguardante l’emissione di certificati non conformi agli standard. Anche se non si è trattato di una compromissione in senso stretto, il caso ha portato a una significativa perdita di fiducia e a una revisione della sua autorità come CA.
  9. WoSign (2016): WoSign, una CA cinese, ha emesso certificati non autorizzati e non conformi agli standard di sicurezza, il che ha portato a una riduzione della fiducia e a provvedimenti da parte dei principali browser per revocare il riconoscimento della sua autorità.

Questi incidenti evidenziano che la sicurezza di un sistema certificato da parte di un ente pubblico, non rappresenta con certezza di essere sicuro, essendo, appunto, basato sulla fiducia.

Considerazioni finali

In questo articolo abbiamo evidenziato che la sicurezza di un certificato si basa solo su una relazione di fiducia, tra l’utente e Certification Authority, ma che non deve essere assunto come totem assoluto. Abbiamo mostrato come, nel corso del tempo, ci sono state molte violazioni che sono state rese pubbliche mentre molte altre sono state sottaciute; le violazione conosciute, mettono in evidenza la responsabilità di terzi, ma non dimentichiamo che le aziende sono fatte di persone che spesso, agiscono per interesse personale.

È essenziale che le organizzazioni adottino misure rigorose per proteggere la propria infrastruttura di sicurezza, restando  informate per salvaguardare i propri dati, in quanto la sicurezza resta sempre una propria responsabilità.

BIND, dns, bind, dominio, domini

BIND: Chroot DNS, Compilazione e installazione
1920 1280 Nicola Montemurro

Introduzione

L’uso di BIND in un ambiente chrooted è una pratica comune per migliorare la sicurezza del server DNS; la chroot (jail) isola il processo di BIND da altre parti del sistema operativo, limitando il suo accesso ai file di sistema e riducendo la superficie di attacco. Questo approccio è particolarmente utile in contesti in cui è necessario garantire che il server DNS operi in modo sicuro, minimizzando i rischi associati a vulnerabilità di sicurezza o configurazioni errate.

In un ambiente chrooted, il processo di BIND viene eseguito in una directory specifica, chiamata “root jail”, che contiene solo i file e le librerie necessari per il funzionamento del server DNS. Questo implica che dovranno essere configurati percorsi specifici per i file di configurazione, i dati e le librerie, assicurando al contempo che il sistema non venga compromesso in caso di exploit.

Perchè eseguire BIND in una jail chroot

L’idea alla base dell’esecuzione di BIND DNS in una jail chroot è quella di limitare la “quantità” di accesso che un individuo malintenzionato potrebbe ottenere sfruttando le eventuali vulnerabilità di BIND; è per lo stesso motivo che eseguiamo BIND come utente non privilegiato (named). Questo, in ogni caso, deve essere considerato come un supplemento alle normali precauzioni di sicurezza (esecuzione dell’ultima versione, controllo degli accessi, ecc.), non certo come un sostituto di esse.

I vari passaggi

Di seguito, presento una panoramica dettagliata delle fasi necessarie per la compilazione di BIND, rivolta a professionisti del settore, ma anche a coloro che desiderano sperimentare.

Non entro, volutamente, nel merito del sistema operativo; tutti i passaggi indicati di seguito, sono stati eseguiti con utente privilegiato (root), da terminale ssh, in ambiente Linux Almalinux 9.2 (base Red Hat Enterprise).

Prerequisiti

dnf update
dnf install gcc make libtool libxml2-devel openssl-devel
dnf install -y libmaxminddb-devel libuv-devel libnghttp2-devel libxml2-devel jemalloc-devel

Scaricare il Codice Sorgente di BIND

wget https://downloads.isc.org/isc/bind9/9.18.30/bind-9.18.30.tar.xz

Estrazione

tar -xJvf bind-9.18.30.tar.xz

Configurazione

cd bind-9.18.30
configure --prefix=/usr/local/named --sysconfdir=/usr/local/named/etc --mandir=/usr/share/man --enable-largefile \
--with-openssl --with-maxminddb --enable-full-report --with-libxml2 --with-jemalloc

Compilazione

make -j8

Test

make test

Installazione

make install

Preparazione della root jail e creazione dell'account utente (named)

# ----------------------------------------------------------------------------------
# - File Name           :       init-bind-jail.sh
# - Author              :       NM
# - Administrator       :       NM  - Mobile: XXX
# - Create              :       18/01/2008
# - Last Update         :       20/11/2008
# - Description         :       File per la configurazione jail DNS BIND
# - Position            :       /usr/local/scripts
# - Note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  -----------------------------------------------------------------------------------

#/bin/bash

# Source function library.
. /etc/rc.d/init.d/functions

JAILDIR=/jail

SERHOME=$JAILDIR/named
SERUSER=named
SERGROUP=named

uexists() {

   return=`id $SERUSER &> /dev/null`

  }

if ! uexists
then
        uid=$(cat /etc/passwd | cut -f3 -d: | sort -un | awk 'BEGIN { min=5000; max=5100 } { if ($0<min) { uuid=min } else if ($0>=min && $0<=max) {uuid=$0 + 1} } END { print uuid }')

        gid=$(cat /etc/group | cut -f3 -d: | sort -un | awk 'BEGIN { min=5000; max=5100 } { if ($0<min) { uuid=min } else if ($0>=min && $0<=max) {uuid=$0 + 1} } END { print uuid }')


        groupadd -g $gid $SERGROUP

        useradd -d $SERHOME -m -c "Bind User" -g $SERGROUP -u $uid $SERUSER -s /sbin/nologin

fi

mkdir -p $SERHOME
mkdir -p $SERHOME/etc $SERHOME/dev $SERHOME/var/log $SERHOME/var/run $SERHOME/usr/sbin
mkdir -p $SERHOME/master $SERHOME/slave $SERHOME/reverse $SERHOME/var/stats $SERHOME/var/dump $SERHOME/var/log $SERHOME/usr/local

mknod -m 0666 $SERHOME/dev/null c 1 3
mknod -m 0666 $SERHOME/dev/zero c 1 5
mknod -m 0666 $SERHOME/dev/random c 1 8
mknod -m 0666 $SERHOME/dev/urandom c 1 9

cp /etc/localtime $SERHOME/etc

chown -R $SERUSER:$SERGROUP $SERHOME

chown -R $SERUSER:$SERGROUP $SERHOME/master
chown -R $SERUSER:$SERGROUP $SERHOME/slave
chown -R $SERUSER:$SERGROUP $SERHOME/reverse
chown -R $SERUSER:$SERGROUP $SERHOME/var/stats
chown -R $SERUSER:$SERGROUP $SERHOME/var/dump

Script di avvio del servizio (named)

Script per l’avvio del servizio “named”, e’ sufficiente creare un file in /etc/init.d/named, copiare, incollare e salvare.

# ----------------------------------------------------------------------------------
# - File Name           :       named
# - Author              :       NM
# - Administrator       :       NM  - Mobile: XXX
# - Create              :       14/04/2006
# - Last Update         :       20/01/2007
# - Description         :       File per lo start/stop named (bind)
# - Position            :       /etc/init.d/
# - Note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  -----------------------------------------------------------------------------------

#!/bin/bash
#
# named           This shell script takes care of starting and stopping
#                 named (BIND DNS server).
#
# chkconfig: 345 55 45
# description: named (BIND) is a Domain Name Server (DNS) \
# that is used to resolve host names to IP addresses.
# probe: true

# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

JAILDIR=/jail

[ -f /usr/local/named/sbin/named ] || exit 0

[ -f $JAILDIR/named/etc/named.conf ] || exit 0

setretvalue() {
        RET=$1
        if [ -n "$RET" ] && [ "$RET" -eq 0 ]
        then
                echo_success
        else
                echo_failure
        fi
   }

start() {
        # Start daemons.
        echo -n "Starting named: "
        if [ ! -f /var/lock/subsys/named ]
        then
                daemon /usr/local/named/sbin/named -u named -t $JAILDIR/named -c /etc/named.conf -n 2
                RETVAL=$?
                [ $RETVAL -eq 0 ] && touch /var/lock/subsys/named
        else
                setretvalue 1
        fi
        echo
        return $RETVAL
}

stop() {
        PID=`pidof named`
        # Stop daemons.
        echo -n "Shutting down named: "
        if [ -n "$PID" ]
        then
                kill -9 $PID
                RETVAL=$?
                [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/named
        fi
        setretvalue $RETVAL
        echo
}



case "$1" in
  start)
        start
        ;;
  stop)
        stop
        ;;
  status)
        status named
        RETVAL=$?
        ;;
  restart)
        stop
        start
        RETVAL=$?
        ;;
  reload)
        /usr/local/named/sbin/rndc reload
        RETVAL=$?
        ;;
  probe)
        /usr/local/named/sbin/rndc reload >/dev/null 2>&1 || echo start
        RETVAL=0
        ;;

  *)
        echo "Usage: named {start|stop|status|restart|reload}"
        RETVAL=1
esac

exit $RETVAL

chmod +x /etc/init.d/named
systemctl enable named

Considerazioni finali

Provando ad avviare il servizio, non verrà visualizzato nessun errore, ma il servizio, mancando la configurazione, non potrà avviarsi.

In un prossimo articolo, descriverò come realizzare una configurazione a “view” (vista), in modo da mostrare come su possa ottenere una risposta DNS diversa in funzione dell’ IP sorgente che effettua la richiesta.

Documentazione

Per informazione in merito alla documentazione, potete consultare BIND 9.19 Administrator Reference Manual

Principio del Minimo Privilegio

Principio del Minimo Privilegio
1920 1280 Nicola Montemurro

Il Principio del Minimo Privilegio (Least Privilege Principle) è un concetto fondamentale nella sicurezza informatica e nella gestione delle identità e degli accessi. Esso stabilisce che gli utenti, i sistemi e i processi devono ricevere solo i privilegi e le autorizzazioni strettamente necessari per svolgere le loro funzioni. Questo principio si applica a tutti gli aspetti dell’accesso ai dati e alle risorse, riducendo al minimo le possibilità di accessi non autorizzati e di danni potenziali.

Vantaggi del Principio del Minimo Privilegio

  1. Riduzione del Rischio di Compromissione
    Limitando l’accesso ai dati e alle risorse sensibili, si riduce la superficie di attacco. Se un account viene compromesso, i danni sono contenuti e non possono espandersi a tutto il sistema.
  2. Minimizzazione degli Errori Umani
    Consentire agli utenti di accedere solo a ciò che è necessario riduce il rischio di errori accidentali, come la cancellazione o la modifica di file critici.
  3. Compliance Normativa
    Molte normative e standard di sicurezza, come GDPR, HIPAA e PCI-DSS, richiedono l’implementazione del principio del minimo privilegio come parte delle pratiche di protezione dei dati. La sua adozione può aiutare le organizzazioni a mantenere la conformità.
  4. Controllo Migliorato
    Avere politiche di accesso ben definite consente una gestione più semplice e chiara dei diritti di accesso. Questo facilita l’audit e il monitoraggio delle attività degli utenti.

Implementazione del Principio del Minimo Privilegio

  1. Valutazione dei Ruoli
    È fondamentale analizzare i ruoli e le responsabilità degli utenti all’interno dell’organizzazione. Ogni ruolo dovrebbe avere accesso solo alle risorse necessarie per il proprio lavoro.
  2. Configurazione di Accessi Granulari
    Le autorizzazioni dovrebbero essere configurate in modo granulare, consentendo accessi specifici a file, sistemi e dati. L’uso di gruppi e ruoli può semplificare questa gestione.
  3. Revisione Periodica degli Accessi
    È importante effettuare revisioni regolari dei privilegi di accesso per assicurarsi che siano sempre appropriati e allineati con le funzioni attuali degli utenti.
  4. Formazione e Sensibilizzazione
    Educare gli utenti sull’importanza del principio del minimo privilegio e sulle pratiche di sicurezza può contribuire a una maggiore adozione e a una gestione più consapevole dei privilegi.

Sfide nell’Applicazione del Principio del Minimo Privilegio

  • Complessità nella Gestione: La definizione e la gestione accurata delle autorizzazioni possono diventare complesse, specialmente in ambienti con numerosi utenti e ruoli.
  • Resistenza al Cambiamento: Gli utenti possono essere riluttanti a ridurre i loro privilegi, soprattutto se si trovano in difficoltà nell’accedere a risorse di cui hanno bisogno.
  • Equilibrio tra Sicurezza e Usabilità: È fondamentale trovare un equilibrio tra la sicurezza e la facilità d’uso. Limitazioni eccessive possono ostacolare la produttività.

Conclusione

Il Principio del Minimo Privilegio è una strategia essenziale per migliorare la sicurezza delle informazioni e proteggere le risorse aziendali. La sua implementazione non solo aiuta a mitigare i rischi di accessi non autorizzati e di compromissioni, ma promuove anche una cultura della responsabilità e della sicurezza all’interno dell’organizzazione. Investire in un approccio basato su questo principio è fondamentale per costruire un ambiente di lavoro più sicuro e resiliente.

BIND, dns, bind, dominio, domini

BIND: Perché implementare DNSSEC
1920 1280 Nicola Montemurro

Introduzione a Bind

BIND (Berkeley Internet Name Domain) è uno dei server DNS più diffusi e rispettati a livello globale, fondamentale per la risoluzione dei nomi di dominio in indirizzi IP. Sviluppato originariamente presso l’Università di Berkeley, BIND è diventato lo standard de facto per la gestione dei servizi DNS su sistemi UNIX e Linux. Grazie alla sua robustezza, flessibilità e continua evoluzione, è ampiamente utilizzato da organizzazioni di ogni dimensione.

La Sicurezza della Risoluzione DNS: Il Ruolo di DNSSEC

In un contesto in cui la sicurezza delle informazioni è fondamentale, la protezione delle comunicazioni DNS ha acquisito un’importanza crescente. DNSSEC (Domain Name System Security Extensions) è un insieme di specifiche progettate per garantire l’integrità e l’autenticità delle informazioni DNS. Implementare DNSSEC con BIND significa adottare misure di sicurezza avanzate, che proteggono gli utenti da attacchi come il cache poisoning e l’intercettazione delle comunicazioni.

Perché Implementare DNSSEC?

1. Integrità dei Dati:

DNSSEC utilizza la crittografia per firmare digitalmente i record DNS, assicurando che le risposte provengano realmente dalla sorgente autorizzata. Questo previene manomissioni e garantisce che gli utenti ricevano dati autentici.

2. Autenticità delle Risposte

Con DNSSEC, ogni record DNS è accompagnato da una firma crittografica. Gli utenti possono verificare che le risposte DNS non siano state alterate durante il transito, riducendo il rischio di attacchi di spoofing.

3. Protezione Contro Attacchi Malevoli

Gli attacchi di tipo cache poisoning, in cui un attaccante compromette la cache DNS di un resolver, possono portare a deviazioni verso siti dannosi. DNSSEC fornisce una protezione efficace contro tali vulnerabilità, garantendo che solo le risposte firmate e verificate siano accettate.

Adozione Crescente

Con l’aumento della consapevolezza riguardo alla sicurezza informatica, sempre più organizzazioni stanno adottando DNSSEC. Essere tra i pionieri di questa tecnologia può non solo migliorare la sicurezza, ma anche rafforzare la reputazione dell’organizzazione nel mercato.

Ulteriori informazioni

Per approfondire ulteriormente BIND vai a www.isc.org

Considerazioni finali

Incorporare BIND con DNSSEC rappresenta una scelta strategica per le organizzazioni che desiderano garantire un ambiente sicuro e affidabile per la risoluzione dei nomi di dominio. La protezione offerta da DNSSEC non solo preserva l’integrità delle informazioni, ma contribuisce anche a costruire un ecosistema Internet più sicuro e resistente alle minacce informatiche. Con l’evoluzione delle tecnologie e l’aumento delle vulnerabilità, implementare DNSSEC non è più una mera opzione, ma una necessità per chiunque operi nel settore informatico.

Asterisk, pbx, acd, ivr, voicemail, voip, pjsip.conf, extensions.conf

Asterisk: Tutorial – Compilazione e Installazione #01
1922 1282 Nicola Montemurro

Le istruzioni che troverete di seguito, sono state eseguite da riga di comando, su terminale ssh collegato ad un server Linux sul quale è stata installata una distribuzione Almalinux (base Red Hat Enterprise) e eseguiti con privilegi di root.

Nulla vieta di utilizzare una distribuzione differente, ma la parte relativa alle dipendenze, potrebbe non corrispondere a quella indicata in questo articolo.

Asterisk: Tutorial – Compilazione e Installazione #01

Presupposto

Primo articolo del tutorial relativo ad Asterisk.

Se ti sei perso la parte precedente, la trovi qui:

  1. Asterisk: Tutorial – Setup del tuo sistema di telefonia PBX #00

1. Aggiornamento del sistema

dnf update

2. Installazione delle librerie necessarie

dnf install -y epel-release
dnf install -y git gcc gcc-c++ make ncurses-devel libuuid-devel libxml2-devel libedit-devel libuuid-devel  libxml2-devel
dnf install -y bzip2 bzip2-devel libsq3-devel jansson jansson-devel

Per installare la documentazione (opzionale) è richiesta l’installazione del package doxygen-latex

dnf install -y doxygen

3. Download dell'ultima versione di Asterisk (18.9-cert10 )

cd /usr/src
wget https://downloads.asterisk.org/pub/telephony/certified-asterisk/asterisk-certified-18.9-cert10.tar.gz

4. Estrazione dei file

tar -xzvf asterisk-certified-18.9-cert10.tar.gz

5. Compilazione

cd asterisk-certified-18.9-cert10
sh configure
make -j4

6. Selezione moduli

Se la compilazione è andata a buon fine, potete configurare cosa installare del vostro Asterisk digitando:

make menuselect

Vi comparirà un menu come mostrato di seguito

**************************************************
Asterisk Module and Build Option Selection
**************************************************

Press ‘h’ for help.

—> Add-ons (See README-addons.txt)
Applications
Bridging Modules
Call Detail Recording
Channel Event Logging
Channel Drivers
Codec Translators
Format Interpreters
Dialplan Functions
PBX Modules
Resource Modules
Test Modules
Compiler Flags
Utilities
AGI Samples
Core Sound Packages
Music On Hold File Packages
Extras Sound Packages

Da questo menu si possono, eventualmente, rimuovere le parti (moduli ) che si suppone di non utilizzare, per alleggerire la struttura. Per il momento lasciandoci la possibilità di esplorare quante più possibili ambiti di configurazione, mi sono limitato ad abilitare la parte audio in lingua Italiana.

7. Selezione dei file audio in lingua (Core sound Packages)

Entrare nella sezione “Core sound Packages” e selezionare (premendo la barra spaziatrice):

[*] CORE-SOUNDS-IT-WAV
[*] CORE-SOUNDS-IT-ULAW
[*] CORE-SOUNDS-IT-ALAW
[*] CORE-SOUNDS-IT-GSM
[*] CORE-SOUNDS-IT-G729
[*] CORE-SOUNDS-IT-G722

Questo ci permette di abilitare i messaggi in italiano per i relativi codec.

Premendo il tasto esc, si torna al menu principale.

8. Selezione delle musiche di attesa (Music On Hold File Packages)

Entrare nel menu “Music On Hold File Packages” e selezionare:

[*] MOH-OPSOUND-WAV
[*] MOH-OPSOUND-ULAW
[*] MOH-OPSOUND-ALAW
[*] MOH-OPSOUND-GSM
[*] MOH-OPSOUND-G729
[*] MOH-OPSOUND-G722

Questo ci permette di rendere disponibili le musiche di attesa relative sempre agli stessi codec.

Premendo due volte esc verrà chiesta la possibilità di uscire, premendo Y (yes) si uscirà senza salvare, premendo N (cancel) si ritorna al menu principale e premendo S (save) si proseguirà l’uscita salvando le impostazioni fatte.

9. Installazione

Se la compilazione è andata a buon fine, digitare:

make install
make progdocs
make sample
make config
systemctl start asterisk

A questo punto potete accedere alla console Asterisk digitando:

asterisk -rvvvvvv

Considerazioni finali

In questo articolo abbiamo esplorato i vari punti per realizzare l’installazione di Asterisk partendo dal codice sorgente.

Nel prossimo articolo, proseguiremo iniziando la costruzione della configurazione del PBX.

multitasking, thread

Multitasking Apparente, Time Slicing e Sistemi Multiprocessore
1920 1280 Nicola Montemurro

Il Multitasking

Il multitasking è un concetto da sempre dibattuto nella gestione delle risorse nel computing in generale. In questo articolo, esploreremo come il multitasking sia solo apparente e come si relazioni al time slicing e come queste tecniche vengano applicate nei sistemi multiprocessore. Analizzeremo anche le implicazioni per le prestazioni e l’esperienza utente, fornendo un quadro chiaro per gli operatori del settore e coloro interessati alla materia.

Il Multitasking Apparente

Il multitasking apparente è la capacità di un sistema operativo di dare l’illusione che più processi o applicazioni stiano funzionando simultaneamente. In realtà, il sistema esegue un solo processo alla volta, alternando rapidamente tra di essi. Questa capacità è fondamentale per un’esperienza utente fluida e reattiva.

Il Time Slicing

Il time slicing è la tecnica che permette di implementare il multitasking apparente. Ecco come funziona:

  • Intervallo di Tempo: Ogni processo riceve un breve intervallo di tempo, noto come “time slice”, durante il quale può utilizzare la CPU.

  • Switch Rapidi: Una volta scaduto il time slice, il sistema operativo interrompe il processo attivo e passa al successivo. Questo passaggio avviene rapidamente, creando l’illusione che tutti i processi siano in esecuzione contemporaneamente.

Per approfondire, ulteriormente, l’argomento del time slicing leggi anche Time Slicing nei Sistemi Operativi

Sistemi Multiprocessore e Scheduler

Nei sistemi multiprocessore (ovvero sistemi con più core fisici), il concetto di scheduling e time slicing si complica, ma offre anche vantaggi significativi:

Quanti Scheduler Esistono

In un sistema multiprocessore, esiste generalmente un singolo scheduler globale che gestisce l’assegnazione dei processi ai vari core. Tuttavia, è possibile avere anche scheduler locali, uno per ogni core, che gestiscono i thread dei processi assegnati, dallo scheduler globale, a quel core specifico.

Scheduler Globale e Locale

  • Scheduler Globale: Gestisce l’assegnazione dei processi ai vari core, cercando di ottimizzare il bilanciamento del carico. Questo tipo di scheduler decide quali processi eseguire e su quale core.
  • Scheduler Locale: Si occupa della gestione dei thread già assegnati a un core specifico, applicando il time slicing e le strategie di scheduling interne (multithread);

Vantaggi

Utilizzando un sistema multiprocessore, dotato di core con scheduler locale, che possano gestire in autonomia il proprio time slicing, rappresenta sicuramente, un vantaggio in termini di performance generali, in quanto, lo scheduler globale, demandando la gestione del time slicing, dei thread dei processi assegnati allo stesso core, risulta meno soggetto a congestione, ma il fatto che in ogni caso, al termine delle operazioni di calcolo da parte dei singoli core, tutto debba essere ricondotto allo scheduler globale, fa sì che il multitasking continui ad essere solo apparente.

Considerazioni Finali

Il concetto di multitasking è strettamente legato alla tecnica del time slicing. Quest’ultima consente ai sistemi operativi di gestire l’esecuzione di più processi in modo che l’utente percepisca che stanno funzionando simultaneamente.

Asterisk, pbx, acd, ivr, voicemail, voip, pjsip.conf, extensions.conf

Asterisk: Tutorial – Setup del tuo sistema di telefonia PBX #00
1922 1282 Nicola Montemurro

Perchè un altro tutorial? (uno dei tanti)

C‘era davvero l’esigenza di un altro tutorial Asterisk? Non lo so, mi “sporco le mani” configurando Asterisk dall’inizio dei tempi … o quasi (anno 2004), ho letto molti tutorial ma nessuno mi ha soddisfatto pienamente, da questo, il tentativo di provare a spiegarne, semplicemente (ci provo), la messa in opera partendo da zero.

Asterisk

Asterisk è un software open source per la creazione di sistemi di comunicazione, che può gestire chiamate vocali, videoconferenze, messaggi istantanei e molto altro. È stato sviluppato per la prima volta da Mark Spencer nel 1999 e ha guadagnato popolarità per la sua flessibilità e potenza.

Glossario

Iniziamo dal glossario, cercando di rendere fruibili ai non addetti, gli acronimi che ritroveremo nelle varie fasi di questo percorso.

ACD: Automatic Call Distribution
Sistema per l’instradamento automatico delle chiamate in arrivo.
AGI: Asterisk Gateway Interface
Interfaccia che consente di eseguire script esterni durante le chiamate.
CID: Caller ID
Identificazione del chiamante, visualizzata sul telefono del destinatario.
CLI: Command Line Interface
Interfaccia a riga di comando per interagire con Asterisk.
DID: Direct Inward Dialing
Sistema che consente ai chiamanti di raggiungere direttamente un interno senza passare per un centralino.
DTMF: Dual-Tone Multi-Frequency
Segnali audio generati quando si premono i tasti di un telefono.
IVR: Interactive Voice Response
Sistema che consente agli utenti di interagire tramite comandi vocali o tasti.
IAX: Inter-Asterisk eXchange
Protocollo di comunicazione utilizzato per il collegamento tra server Asterisk.
PBX: Private Branch Exchange
Si tratta di un sistema telefonico utilizzato all’interno di un’organizzazione per gestire le comunicazioni telefoniche.
PSTN: Public Switched Telephone Network
Rete telefonica tradizionale.
SIP: Session Initiation Protocol
Protocollo di comunicazione utilizzato per la segnalazione nelle chiamate VoIP.
SIP Trunk: Connessione tra un PBX e il provider VoIP tramite SIP.
Consente di effettuare chiamate telefoniche su Internet.

Caratteristiche principali:

VoIP (Voice over IP)

Supporta vari protocolli VoIP come SIP (Session Initiation Protocol) e IAX (Inter-Asterisk eXchange), permettendo la connessione di telefoni IP e altri dispositivi.

PBX (Private Branch Exchange)

Funziona come un centralino telefonico, consentendo la gestione di chiamate interne ed esterne, con funzionalità come la composizione automatica, il trasferimento di chiamata e la segreteria telefonica.

Configurabilità

E’ estremamente versatile, tramite i files di configurazione (es. extensions.conf, sip.conf e pjsip.conf) consente agli utenti di personalizzare le funzionalità e i flussi di chiamata secondo le proprie esigenze.

Integrazione

Può integrarsi con diversi sistemi CRM, database e applicazioni aziendali, ampliando le sue capacità e consentendo l’automazione dei processi.

Supporto codecs

Asterisk supporta una vasta gamma di codec audio, come G.711, G.729 e Opus, per garantire una qualità audio ottimale e un’efficienza nella larghezza di banda.

Funzionalità avanzate

Include opzioni come IVR (Interactive Voice Response), conferenze telefoniche, registrazione delle chiamate, e supporto per la videochiamata.

Comunità attiva

Essendo un progetto open source, Asterisk ha una comunità molto attiva che contribuisce allo sviluppo e alla documentazione, rendendo disponibili tutorial e risorse per facilitare l’adozione e l’implementazione.

Interfacce di amministrazione

Applicazioni comuni:

Uffici

Utilizzato come centralino per gestire le comunicazioni aziendali.

Call Center

Abilita la gestione di chiamate in entrata e in uscita, con reportistica e analisi.

Considerazioni finali

Questo articolo rappresenta l’anticipazione di quanto sarà illustrato nei prossimi articoli della serie relativa alla configurazione e messa in opera di un sistema di telefonia PBX Asterisk.

Per approfondire

Per approfondire Asterisk vai a asterisk.org

Hyper-Threading

Hyper-Threading: Ottimizzazione delle Prestazioni CPU
1920 1280 Nicola Montemurro

Cos' è l'Hyper-Threading

Hyper-Threading è una tecnologia sviluppata da Intel che consente a un singolo core di un processore di eseguire due thread contemporaneamente. Questo significa che ogni core fisico del processore viene visto come due core logici dal sistema operativo, aumentando l’efficienza del processamento e migliorando le prestazioni in specifici scenari di utilizzo. In questo articolo, esploreremo in dettaglio come funziona hyperthreading, i suoi vantaggi e le sue limitazioni, fornendo così una panoramica utile per gli operatori del settore e per chiunque desideri comprendere meglio le architetture moderne dei processori.

Come Funziona Hyper-Threading

Architettura dei Core

La tecnologia Hyper-Threading si basa su un’architettura progettata per massimizzare l’uso delle risorse del core. Ogni core di un processore Hyper-Threading è dotato di:

  • Registri: Spazio di archiviazione temporanea per i dati.

  • Unità di esecuzione: Componenti che eseguono le istruzioni.

  • Cache: Memoria veloce per l’accesso ai dati utilizzati frequentemente.

Quando un core è occupato con un thread, Hyper-Threading utilizza i cicli di clock non impiegati per eseguire un secondo thread, riducendo i tempi di inattività e aumentando la produttività.

Vantaggi dell’Hyperthreading

1. Aumento delle Prestazioni

In scenari di carico pesante, come gaming, editing video e applicazioni di produttività, Hyper-Threading può offrire un notevole incremento delle prestazioni, rendendo possibile l’esecuzione di più operazioni contemporaneamente.

2. Multithreading Efficiente

Può migliorare significativamente le prestazioni in scenari multithreading. Questa capacità di eseguire più thread simultaneamente si traduce in un utilizzo più efficiente delle risorse del processore, specialmente in applicazioni che richiedono un elevato throughput.

3. Miglior Utilizzo delle Risorse

La tecnologia contribuisce a garantire che le risorse del processore siano utilizzate al massimo, riducendo i tempi di inattività e migliorando l’efficienza energetica.

4. Ottimizzazione del Multithreading

In ambienti di lavoro in cui si eseguono più applicazioni consente una gestione fluida e reattiva, migliorando l’esperienza utente.

5. Efficienza Energetica

Ottimizzando l’uso delle risorse della CPU, l’Hyper-Threading contribuisce a una migliore efficienza energetica. Le operazioni più rapide possono ridurre il tempo di attesa, consentendo un risparmio energetico complessivo.

Limiti dell'hyperthreading

1. Non Sempre Vantaggioso

Non tutte le applicazioni traggono beneficio dall’Hyper-Threading. Alcuni carichi di lavoro non sono progettati per l’esecuzione parallela e potrebbero non mostrare miglioramenti significativi. È importante valutare le specifiche esigenze delle applicazioni per determinare se Hyper-Threading, possa effettivamente apportare vantaggi in termini di prestazioni.

2. Non raddoppia delle Prestazioni

Sebbene Hyper-Threading migliori le prestazioni, è importante notare che non raddoppia necessariamente la capacità di elaborazione. In alcune situazioni, come carichi di lavoro leggeri o applicazioni che non supportano bene il multithreading, i benefici possono risultare minimi.

3. Overhead di Gestione

L’implementazione di Hyper-Threading comporta un certo overhead nella gestione dei thread, il che può influire sulle prestazioni in scenari specifici. La sovrapposizione di operazioni può causare congestione e inefficienze se non gestita correttamente.

Considerazioni finali

Hyper-Threading è una tecnologia chiave per il miglioramento dell’efficienza nei processori moderni, specialmente in contesti di multitasking e in applicazioni ad alta intensità di lavoro. Comprendere i meccanismi e le implicazioni di questa tecnologia è fondamentale per gli operatori del settore che desiderano ottimizzare le prestazioni delle proprie macchine.

storage, raid, disk, disks, nvme, ssd

RAID: Vantaggi e Svantaggi nelle diverse condizioni d’uso
1920 1280 Nicola Montemurro

La gestione dei dati è una delle componenti fondamentali in qualsiasi infrastruttura IT, sia essa destinata a piccole realtà aziendali o grandi data center. I sistemi RAID (Redundant Array of Independent Disks) offrono soluzioni per ottimizzare le prestazioni, garantire la ridondanza e facilitare la gestione dello storage. In questo articolo, analizzeremo i principali livelli di RAID, evidenziando i loro vantaggi e svantaggi in base a contesti di utilizzo specifici.

1. RAID 0: Striping

Descrizione

RAID 0 è una configurazione che utilizza lo striping per distribuire i dati su più dischi. Non è presente alcuna ridondanza; i dati vengono suddivisi in blocchi e scritti su diversi dischi in parallelo.

Vantaggi

  • Elevate prestazioni: Poiché le operazioni di lettura e scrittura avvengono simultaneamente su più dischi, RAID 0 offre prestazioni significativamente superiori rispetto a configurazioni non stripate.

  • Massimizzazione della capacità: La capacità totale è equivalente alla somma delle capacità di tutti i dischi, consentendo l’utilizzo completo dello spazio disponibile.

Svantaggi

  • Nessuna ridondanza: La mancanza di parità o mirror implica che un guasto di un solo disco comporta la perdita di tutti i dati.

  • Maggiore vulnerabilità: Maggiore è il numero di dischi, maggiore è il rischio di guasti, aumentando la probabilità di perdita di dati.

Condizioni d'uso

E’ indicato per applicazioni che richiedono elevate prestazioni, come l’editing video o i giochi, dove la velocità è essenziale e la perdita di dati non è critica.

2. RAID 1: Mirror

Descrizione

La configurazione che crea una copia esatta dei dati su due o più dischi. Ogni disco contiene un mirror degli altri.

Vantaggi

  • Alta disponibilità: Se un disco si guasta, i dati rimangono accessibili tramite il disco rimanente, garantendo una notevole affidabilità.

  • Facilità di recupero: La ricostruzione dei dati è relativamente semplice e veloce, poiché è sufficiente sostituire il disco guasto.

Svantaggi

  • Capacità ridotta: Solo il 50% della capacità totale dei dischi è utilizzabile, poiché i dati sono duplicati.

  • Costo elevato: L’investimento iniziale è maggiore rispetto a configurazioni non ridondanti a causa della necessità di dischi aggiuntivi.

Condizioni d'uso

E’ ideale per server critici, database e file server in cui la protezione dei dati è fondamentale e non possono essere tollerate perdite.

3. RAID 5: Striping con Parità

Descrizione

Combina lo striping dei dati con la distribuzione della parità, offrendo un equilibrio tra prestazioni e ridondanza. La parità viene distribuita su tutti i dischi.

Vantaggi

  • Tolleranza ai guasti: Può resistere al guasto di un disco senza perdita di dati, grazie alle informazioni di parità.

  • Capacità efficiente: Maggiore capacità utilizzabile rispetto a RAID 1, in quanto solo una porzione dello spazio è utilizzata per la parità.

Svantaggi

  • Prestazioni di scrittura inferiori: La necessità di calcolare e scrivere le informazioni di parità può rallentare le operazioni di scrittura.

  • Complessità nella ricostruzione: In caso di guasto, la ricostruzione del disco può richiedere tempo e risorse.

Condizioni d'uso

E’ adatto per server di file e applicazioni in cui si desidera un buon compromesso tra prestazioni, capacità e protezione dei dati.

4. RAID 6: Doppia Parità

Descrizione

  • Protezione avanzata: È in grado di gestire il guasto di due dischi senza perdita di dati, aumentando ulteriormente la sicurezza.

  • Buona capacità utilizzabile: Rispetto a RAID 5, offre una protezione superiore con una riduzione minima della capacità.

Svantaggi

  • Sovraccarico di scrittura: Il calcolo della doppia parità può comportare prestazioni di scrittura inferiori rispetto a RAID 5.

  • Capacità ridotta: La capacità utilizzabile è inferiore a quella di RAID 5 a causa della maggiore quantità di parità.

Condizioni d'uso

E’ ideale per ambienti di archiviazione di dati aziendali e sistemi in cui la protezione dei dati è di massima importanza.

5. RAID 10: Combinazione di Mirror e Striping

Descrizione

Combina le caratteristiche di RAID 1+0, eseguendo lo striping su dischi che sono a loro volta mirrorati.

Vantaggi

  • Eccellenti prestazioni: Offre prestazioni superiori sia in lettura che in scrittura, combinando i vantaggi dello striping e del mirroring.

  • Alta disponibilità: Può tollerare il guasto di più dischi, purché non si guasti un disco in ciascuna coppia di mirror.

Svantaggi

  • Costo elevato: La capacità utilizzabile è ridotta al 50%, poiché la duplicazione dei dati richiede più dischi.

  • Maggiore complessità: La configurazione e la gestione sono più complicate rispetto ad altri livelli RAID.

Condizioni d'uso

E’ consigliato per database ad alte prestazioni e server di applicazioni in cui sia necessaria sia l’affidabilità che la velocità.

Raid 50 Combinazione di Striping con parità + Striping

Descrizione

Combina le caratteristiche di RAID 5 + 0. In questa configurazione, i dati vengono prima distribuiti in striping tra gruppi di dischi configurati in RAID 5, e successivamente i gruppi stessi sono striped come un array RAID 0. Questo approccio fornisce un equilibrio tra prestazioni e tolleranza ai guasti.

Vantaggi

  • Elevate prestazioni: RAID 50 offre prestazioni superiori rispetto a RAID 5, poiché lo striping tra i gruppi di dischi consente un accesso simultaneo ai dati.

  • Tolleranza ai guasti: Può tollerare il guasto di un disco in ogni array RAID 5, offrendo una maggiore protezione rispetto a RAID 0 e RAID 5 singoli.

  • Efficienza dello spazio: Come in RAID 5, solo una parte dello spazio totale è utilizzata per la parità, massimizzando la capacità disponibile.

Svantaggi

  • Complessità nella configurazione: La configurazione di RAID 50 richiede una pianificazione più attenta e una gestione più complessa rispetto ai livelli RAID più semplici.

  • Costo: Necessita di un numero maggiore di dischi per implementare correttamente la configurazione, aumentando i costi.

  • Prestazioni di scrittura: Anche se migliori rispetto a RAID 5, le prestazioni di scrittura possono essere inferiori rispetto a configurazioni RAID più semplici come RAID 0.

Condizioni d'uso

E’ particolarmente adatto per ambienti di storage che richiedono prestazioni elevate e una robusta protezione dei dati, come database e applicazioni di virtualizzazione. È ideale per sistemi in cui sia le prestazioni di lettura che di scrittura sono critiche e dove la perdita di dati deve essere evitata a tutti i costi.

6. RAID-Z: Parità Integrata in ZFS

Descrizione

RAID-Z è una tecnologia specifica di ZFS, che utilizza la parità per proteggere i dati e offre funzionalità avanzate come snapshot e clone.

Vantaggi

  • Protezione robusta: Integra la protezione dei dati direttamente nel file system, garantendo l’integrità dei dati.

  • Gestione semplice: L’integrazione con ZFS facilita la configurazione e la gestione delle risorse di storage.

Svantaggi

  • Complessità di configurazione: Richiede competenze specifiche per una corretta implementazione e gestione.

  • Prestazioni di scrittura variabili: Le prestazioni di scrittura possono essere inferiori rispetto a configurazioni RAID più semplici in scenari di scrittura intensiva.

Condizioni d'uso

RAID-Z è adatto per ambienti di archiviazione dati aziendali dove la protezione, la flessibilità e la gestione dei dati sono cruciali.

Considerazioni finali

La selezione del livello RAID più adatto è determinata da vari fattori, tra cui requisiti di prestazioni, capacità di storage, budget e tolleranza al guasto. Ogni configurazione presenta vantaggi e svantaggi specifici, e una scelta informata può migliorare significativamente la gestione dei dati.

Per ulteriori approfondimenti wikipedia

exif, cancellare i dati exif, metadati, dati exif, cleanexif, cleanexif.py

Rimuovere i Dati EXIF dalle Immagini
1920 1280 Nicola Montemurro

Cosa sono i Metadati dalle Immagini

Nel mondo digitale odierno, la privacy è un tema importante, specialmente quando si tratta di condividere immagini online. Ogni foto che scattiamo contiene informazioni invisibili note come dati EXIF (Exchangeable Image File Format), chiamati anche Metadati. Questi dati possono rivelare dettagli sensibili, come la posizione georeferenziata del luogo in cui è stata scattata l’immagine e le impostazioni della fotocamera o il nome dell’autore. Da qui nasce l’esigenza di uno strumento quale lo script Python cleanexif.py. In questo articolo, esploreremo la logica alla base di questo script e forniremo esempi di utilizzo per aiutarti a rimuovere in modo efficiente i dati EXIF dalle tue immagini.

Cos’è cleanexif.py?

cleanexif.py è uno script progettato per cercare e rimuovere i dati EXIF da file immagine in una directory specificata. Lo script offre diverse funzionalità utili, tra cui la possibilità di fare il backup dei file originali, escludere determinate estensioni di file e directory dalla scansione, e registrare le operazioni in un file di log.

Perché Rimuovere i Dati EXIF?

Benchè possano essere utili in molti casi, rimuovere i dati EXIF è fondamentale per proteggere la propria privacy. Prima di caricare foto sui social media o inviarle via email o condividerle attraverso un blog è consigliabile eliminare informazioni potenzialmente compromettenti. Inoltre, alcuni servizi online possono rifiutare immagini con dati EXIF per motivi di sicurezza.

Ecco un esempio di immagine, scaricata tramite motore di ricerca, utilizzata proprio in questo blog e “ripulita” con cleanexif.py, in questo caso si tratta di informazioni prevalentemente tecniche riguardando l’immagine stessa, ma il seti di dati disponibile, può riguardare informazioni molto più personali, quali ad esempio Nome Utente, coordinate geolocalizzate, etc.

Prima:

ExifTool Version Number         : 12.96
File Name                       : privacy-please.jpg
Directory                       : D:/Documenti/immagini
File Size                       : 177 kB
File Modification Date/Time     : 2024:07:22 13:45:56+02:00
File Access Date/Time           : 2024:09:25 12:53:15+02:00
File Creation Date/Time         : 2024:09:25 12:53:15+02:00
File Permissions                : -rw-rw-rw-
File Type                       : JPEG
File Type Extension             : jpg
MIME Type                       : image/jpeg
JFIF Version                    : 1.01
Exif Byte Order                 : Big-endian (Motorola, MM)
Photometric Interpretation      : RGB
Make                            : NIKON CORPORATION
Camera Model Name               : NIKON D80
Orientation                     : Horizontal (normal)
Samples Per Pixel               : 3
X Resolution                    : 72
Y Resolution                    : 72
Resolution Unit                 : inches
Software                        : Adobe Photoshop 23.4 (Windows)
Modify Date                     : 2022:07:07 14:51:19
Exposure Time                   : 1/125
F Number                        : 1.4
Exposure Program                : Aperture-priority AE
ISO                             : 1600
Exif Version                    : 0221
Date/Time Original              : 2007:01:24 11:58:36
Create Date                     : 2007:01:24 11:58:36
Compressed Bits Per Pixel       : 4
Shutter Speed Value             : 1/125
Aperture Value                  : 1.4
Exposure Compensation           : 0
Max Aperture Value              : 1.4
Metering Mode                   : Spot
Light Source                    : Unknown
Flash                           : No Flash
Focal Length                    : 50.0 mm
Sub Sec Time                    : 20
Sub Sec Time Original           : 20
Sub Sec Time Digitized          : 20
Flashpix Version                : 0100
Color Space                     : sRGB
Exif Image Width                : 1920
Exif Image Height               : 1280
Sensing Method                  : One-chip color area
Custom Rendered                 : Normal
Exposure Mode                   : Auto
White Balance                   : Auto
Digital Zoom Ratio              : 1
Focal Length In 35mm Format     : 75 mm
Scene Capture Type              : Standard
Gain Control                    : High gain up
Contrast                        : High
Saturation                      : Normal
Sharpness                       : Normal
Subject Distance Range          : Unknown
Compression                     : JPEG (old-style)
Thumbnail Offset                : 948
Thumbnail Length                : 3098
XMP Toolkit                     : Adobe XMP Core 7.2-c000 79.566ebc5, 2022/05/09-07:22:29
Creator Tool                    : Ver.1.00
Metadata Date                   : 2022:07:07 14:51:19-07:00
Color Mode                      : RGB
ICC Profile Name                : sRGB IEC61966-2.1
History                         : 2022-07-07T14:50:52-07:00.File Privacy_Please_Hotel_Lock_3x2.jpg opened.2022-07-07T14:51:19-07:00.File D:\10-22-2017 D-Drive Files\DonkeyHotey\WhoWhatWhy\Gajda_Privacy\posted\Privacy_Please_Hotel_Lock_3x2.jpg saved.
Document ID                     : 2E6221C20317B13575DF0E8A7019FB0F
Instance ID                     : xmp.iid:602c8262-f052-5a48-9fc4-57906e3f94fe
Original Document ID            : 2E6221C20317B13575DF0E8A7019FB0F
Format                          : image/jpeg
History Action                  : saved
History Instance ID             : xmp.iid:602c8262-f052-5a48-9fc4-57906e3f94fe
History When                    : 2022:07:07 14:51:19-07:00
History Software Agent          : Adobe Photoshop 23.4 (Windows)
History Changed                 : /
Current IPTC Digest             : bf2a01135522004279f5c636cfdea9cd
Coded Character Set             : UTF8
Application Record Version      : 0
Date Created                    : 2007:01:24
Time Created                    : 11:58:36
IPTC Digest                     : bf2a01135522004279f5c636cfdea9cd
Displayed Units X               : inches
Displayed Units Y               : inches
Print Style                     : Centered
Print Position                  : 0 0
Print Scale                     : 1
Global Angle                    : 30
Global Altitude                 : 30
URL List                        :
Slices Group Name               : Privacy_Please_Hotel_Lock_3x2
Num Slices                      : 1
Pixel Aspect Ratio              : 1
Photoshop Thumbnail             : (Binary data 3098 bytes, use -b option to extract)
Has Real Merged Data            : Yes
Writer Name                     : Adobe Photoshop
Reader Name                     : Adobe Photoshop 2022
Photoshop Quality               : 12
Photoshop Format                : Standard
Image Width                     : 1920
Image Height                    : 1280
Encoding Process                : Baseline DCT, Huffman coding
Bits Per Sample                 : 8
Color Components                : 3
Y Cb Cr Sub Sampling            : YCbCr4:2:0 (2 2)
Aperture                        : 1.4
Image Size                      : 1920x1280
Megapixels                      : 2.5
Shutter Speed                   : 1/125
Create Date                     : 2007:01:24 11:58:36.20
Date/Time Original              : 2007:01:24 11:58:36.20
Modify Date                     : 2022:07:07 14:51:19.20
Thumbnail Image                 : (Binary data 3098 bytes, use -b option to extract)
Date/Time Created               : 2007:01:24 11:58:36
Light Value                     : 3.9
Scale Factor To 35 mm Equivalent: 1.5
Circle Of Confusion             : 0.020 mm
Field Of View                   : 27.0 deg
Focal Length                    : 50.0 mm (35 mm equivalent: 75.0 mm)
Hyperfocal Distance             : 89.15 m

Dopo:

ExifTool Version Number         : 12.96
File Name                       : privacy-please.jpg
Directory                       : D:/Documenti/blog/example/images
File Size                       : 175 kB
File Modification Date/Time     : 2024:09:25 12:53:16+02:00
File Access Date/Time           : 2024:09:25 12:52:33+02:00
File Creation Date/Time         : 2024:09:25 12:52:33+02:00
File Permissions                : -rw-rw-rw-
File Type                       : JPEG
File Type Extension             : jpg
MIME Type                       : image/jpeg
JFIF Version                    : 1.01
Resolution Unit                 : None
X Resolution                    : 1
Y Resolution                    : 1
Image Width                     : 1920
Image Height                    : 1280
Encoding Process                : Baseline DCT, Huffman coding
Bits Per Sample                 : 8
Color Components                : 3
Y Cb Cr Sub Sampling            : YCbCr4:2:0 (2 2)
Image Size                      : 1920x1280
Megapixels                      : 2.5

Come Funziona cleanexif.py

Lo script è costruito attorno a funzioni modulari che gestiscono specifiche attività, funziona sia in ambiente Linux, Mac, Windows. Ecco un riepilogo della logica implementata:

1. Scansione delle Directory

Utilizza os.walk per esaminare ricorsivamente una directory specificata, identificando file di tipo immagine.

2. Rimozione dei Dati EXIF

Usa la libreria PIL (Pillow) per aprire i file immagine e rimuovere i dati EXIF, se sono presenti.

3. Backup dei File Originali

Prima di modificare un’immagine, crea un backup, qualora l’utente lo ritenga necessario, in una directory designata, assicurandosi di mantenere una copia dei file originali interessati dall’operazione di rimozione dei metadati.

4. Registrazione delle Operazioni

Le azioni intraprese sono registrate in un file di log, utile per controllare il processo e diagnosticarne eventuali errori.

Esempi di Utilizzo

Perdhè lo script funzioni, occorre che sia installata la libreria Pillow; Per installarla utilizza il seguente comando:

 python3 -m pip install Pillow

Installazione delle Dipendenze

Esecuzione Base

Per eseguire lo script, utilizza il seguente comando:

python cleanexif.py /path/to/images

Questo comando avvierà la scansione della directory /path/to/images alla ricerca di file immagine dai quali rimuovere i dati EXIF.

Esempio Completo

Supponiamo di voler scansionare una directory specifica, escludendo alcuni tipi di file e directory. Puoi farlo con il comando:

python cleanexif.py /path/to/images \
--log-path D:\EXIF\logs\example.log \
--backup-path /path/to/backups \
--exclude-exts .png .gif \
--exclude-dirs dir1 dir2 \
--max-log-size 10MB \
--verbose

In dettaglio:

  • —log-path: Specifica il percorso del file di log, creando automaticamente la directory se non esiste.
  • —backup-path: Indica dove salvare i backup dei file originali.
  • —exclude-exts: Esclude file con estensioni .png e .gif dalla scansione.
  • —exclude-dirs: Esclude le directory dir1 e dir2 dalla scansione.
  • —max-log-size: Limita la dimensione del file di log a 10 MB.
  • —verbose: Attiva un output dettagliato durante l’esecuzione.

Esempio di utilizzo tramite Crontab

Programmazione temporale, in questo caso, tramite Crontab, lo script viene eseguito al minuto 30 di ogni ora e serve a ripulire le immagini di questo blog, togliendo l’onere, a chi allega le immagini, di occuparsi della rimozione dei metadati.

30 * * * * /usr/bin/python3 /usr/local/scripts/clenaexif.py /usr/local/apache2.4/websites/blog/wp-content/uploads \

--backup-path /usr/local/cleanexif-backup/blog-image-backup --log-path /var/log --max-log-size 10MB

Esempio di utilizzo tramite file batch Windows

@echo off

:: ############## SOLUTIONCAFE.IT

set SCRIPT_PATH=E:\Progetti\software\scripts\python\EXIF\cleanexif.py
set IMAGES_DIR=D:\Documenti\blog\solutioncafe.it
set LOG_PATH=%IMAGES_DIR%
set BACKUP_PATH=%IMAGES_DIR%\exifimage-backup
set EXCLUDE_DIRS=exifimage-backup
set MAX_LOG_SIZE=10MB

:: Esegue
python "%SCRIPT_PATH%" "%IMAGES_DIR%" --log-path "%LOG_PATH%" --backup-path "%BACKUP_PATH%" --exclude-dirs %EXCLUDE_DIRS% --max-log-size %MAX_LOG_SIZE% --verbose

:: Messaggio di completamento
echo Operazione completata!
pause

Considerazioni finali

Rimuovere i dati EXIF dalle immagini è un passo fondamentale per proteggere la tua privacy online. Lo script cleanexif.py fornisce una soluzione semplice ed efficace per gestire i file immagine. Con la sua versatilità e facilità d’uso, diventerà un alleato prezioso per chiunque desideri mantenere il controllo sulle proprie informazioni personali.

Risorse Aggiuntive

Questo il link per approfondire le funzionalità di Pillow

Questo il link per approfondire le funzionalità di cleanexif.py

programmazione, multi, thread, multithread, multithreading

Multithread: Sfruttare il Time Slicing nella Programmazione
1920 1280 Nicola Montemurro

Introduzione

Nel contesto della programmazione, l’implementazione del multithreading offre opportunità uniche per migliorare l’efficienza e la reattività delle applicazioni. In questo articolo, esploreremo come la programmazione multithread possa sfruttare al meglio il time slicing, analizzando tecniche, vantaggi e fornendo esempi di codice in C / C++, Delphi / Lazarus (object Pascal) e Python.

Cos'è il Multithreading?

Il multithreading è una tecnica che consente l’esecuzione concorrente di più thread all’interno di un processo. Ogni thread può eseguire operazioni in modo indipendente, permettendo una migliore gestione delle risorse della CPU e una maggiore reattività dell’applicazione. Utilizzando il time slicing, i thread possono alternarsi rapidamente nell’uso della CPU, migliorando l’efficienza complessiva.

Vantaggi del Multithreading

– Reattività: Le applicazioni possono continuare a rispondere agli input dell’utente mentre eseguono operazioni intensive in background.

– Utilizzo Ottimale delle Risorse: Il multithreading permette di sfruttare al meglio i processori multi-core.

– Semplicità di Gestione: Suddividere un’applicazione in thread può semplificare la gestione di compiti complessi.

Esempi di Implementazione

1. C / C++

In C / C++, possiamo utilizzare la libreria `pthread` per gestire i thread. Ecco un semplice esempio che dimostra come creare e gestire thread.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

void* print_message(void* message) {
    printf("%s\n", (char*)message);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    const char* message1 = "Hello from Thread 1";
    const char* message2 = "Hello from Thread 2";

    pthread_create(&thread1, NULL, print_message, (void*)message1);
    pthread_create(&thread2, NULL, print_message, (void*)message2);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

In questo esempio, creiamo due thread che stampano messaggi differenti. La funzione `pthread_create` avvia i thread, mentre `pthread_join` garantisce che il main thread attenda la loro conclusione.

2. Delphi / Lazarus

In Delphi, la gestione dei thread avviene tramite la classe `TThread`. Ecco un esempio di implementazione.

program MultithreadExample;

{$APPTYPE CONSOLE}

uses
  SysUtils, Classes;

type
  TMyThread = class(TThread)
  protected
    procedure Execute; override;
  end;

procedure TMyThread.Execute;
begin
  WriteLn('Hello from Thread: ', ThreadID);
end;

var
  Thread1, Thread2: TMyThread;
begin
  Thread1 := TMyThread.Create;
  Thread2 := TMyThread.Create;

  Thread1.Start;
  Thread2.Start;

  Thread1.WaitFor;
  Thread2.WaitFor;

  Thread1.Free;
  Thread2.Free;
end.

In questo esempio, creiamo una classe che estende `TThread` e sovrascriviamo il metodo `Execute` per stampare un messaggio. I thread vengono avviati e attesi nel main program.

3. Python

In Python, il modulo `threading` rende semplice la creazione di thread. Ecco come implementare un esempio simile.

import threading

def print_message(message):
    print(message)

thread1 = threading.Thread(target=print_message, args=("Hello from Thread 1",))
thread2 = threading.Thread(target=print_message, args=("Hello from Thread 2",))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

In questo codice, creiamo due thread per stampare messaggi diversi. La funzione `join()` assicura che il main thread attenda il completamento dei thread creati.

Tecniche di Ottimizzazione del Multithreading

1. Gestione delle Risorse

Assicurarsi che i thread non accedano contemporaneamente a risorse condivise senza sincronizzazione. Utilizzare meccanismi di locking come mutex o semafori per evitare condizioni di race.

2. Assegnazione delle Priorità

Impostare le priorità dei thread in base all’importanza delle operazioni può migliorare ulteriormente le prestazioni. In C/C++, puoi utilizzare `sched_setscheduler`, mentre in Python il modulo `threading` offre solo funzionalità di base.

3. Profilazione e Debugging

Utilizzare strumenti di profiling per monitorare le prestazioni dei thread e identificare eventuali colli di bottiglia. In C/C++, strumenti come `gprof` possono fornire informazioni utili, mentre in Python puoi utilizzare `cProfile`.

Considerazioni finali

La programmazione multithread rappresenta una potente tecnica per migliorare la reattività e l’efficienza delle applicazioni, sfruttando appieno il time slicing. Con l’implementazione di pratiche di gestione adeguate e la scelta delle giuste tecnologie, gli sviluppatori possono ottenere risultati significativi in termini di prestazioni.

ottimizzare il time slicing, time slice

Ottimizzare il Time Slicing
1920 1280 Nicola Montemurro

Introduzione

Dopo aver esplorato il time slicing e la sua importanza nei sistemi operativi, è fondamentale approfondire le tecniche di programmazione che possono massimizzare i benefici di questa strategia. In questo articolo, esamineremo le pratiche di programmazione più efficaci per sfruttare al meglio il time slicing, consentendo una gestione ottimale delle risorse della CPU e garantendo prestazioni elevate.

Progettazione dei Processi e Thread

1. Definizione Chiara dei Processi

Quando si progettano applicazioni, è essenziale definire in modo chiaro i processi e i thread. Un’architettura ben strutturata aiuta a garantire che i processi possano essere eseguiti in modo indipendente e cooperativo, riducendo il rischio di conflitti e aumentando l’efficienza del time slicing.

2. Uso Efficiente dei Thread

Utilizzare thread per gestire operazioni parallele può migliorare la reattività dell’applicazione. In linguaggi come C e C++, la creazione di thread tramite librerie come `pthread` o la classe `std::thread` può ottimizzare il tempo di CPU disponibile. In Delphi, la gestione dei thread può avvenire tramite `TThread`, mentre in Python, il modulo `threading` consente di lavorare facilmente con thread. Scegliere il metodo più adatto in base al linguaggio e al contesto di utilizzo è cruciale.

Gestione delle Priorità

1. Impostazione delle Priorità dei Processi

Un aspetto fondamentale per ottimizzare il time slicing è la gestione delle priorità. I programmatori dovrebbero assegnare priorità appropriate ai processi in base alla loro importanza. In C e C++, è possibile modificare la priorità dei thread utilizzando funzioni specifiche come `sched_setscheduler`. In Python, la gestione delle priorità è più limitata, ma si possono utilizzare soluzioni alternative per simulare questo comportamento.

2. Strategie di Scheduling Personalizzate

A seconda del contesto dell’applicazione, potrebbe essere utile implementare strategie di scheduling personalizzate. In ambienti ad alte prestazioni, considerare l’uso di algoritmi di scheduling real-time può migliorare ulteriormente la reattività e l’affidabilità dei processi.

Ottimizzazione del Quantum di Tempo

1. Regolazione Dinamica del Quantum

Impostare un quantum fisso può essere limitante. Implementare un sistema che regoli dinamicamente il quantum in base al carico di lavoro attuale e alle esigenze dei processi può portare a prestazioni più equilibrate. Utilizzare una strategia di feedback queue per monitorare l’uso della CPU e adattare il quantum in tempo reale è una strategia efficace.

2. Profilazione delle Prestazioni

Utilizzare strumenti di profiling, come Valgrind per C/C++ o cProfile per Python, per monitorare il comportamento dei processi e l’uso della CPU può fornire informazioni preziose. Questi dati possono essere utilizzati per ottimizzare ulteriormente il quantum e identificare i colli di bottigli

Utilizzo di Strutture Dati Appropriate

1. Selezione delle Strutture Dati

La scelta delle strutture dati può influenzare significativamente le prestazioni. Strutture dati efficienti, come code, alberi bilanciati o liste collegate, possono facilitare la gestione dei processi e migliorare l’efficienza del time slicing.

2. Minimizzare l'Overhead di Allocazione

Evitare l’allocazione e la deallocazione frequente di memoria durante l’esecuzione dei processi può ridurre l’overhead. L’utilizzo di pool di memoria e tecniche di caching per riutilizzare oggetti già esistenti è una pratica comune e utile.

Testing e Validazione

1. Test di Carico

Eseguire test di carico per valutare come il sistema si comporta sotto diverse condizioni di stress è cruciale. Questi test possono rivelare come il time slicing influisce sulle prestazioni e aiutare a identificare le aree di miglioramento.

2. Monitoraggio Post-Implementazione

Dopo l’implementazione, è fondamentale monitorare continuamente le prestazioni. L’analisi dei log e l’uso di strumenti di monitoraggio, come perf per C/C++ o psutil per Python, possono fornire informazioni utili per ottimizzare ulteriormente la gestione del time slicing.

Considerazioni finali

Ottimizzare l’uso del time slicing richiede una combinazione di progettazione attenta, gestione delle priorità, regolazione del quantum e utilizzo di strutture dati efficienti. Implementando queste tecniche di programmazione, gli operatori del settore possono garantire che le loro applicazioni siano reattive e performanti, sfruttando al massimo le capacità dei moderni sistemi operativi.

python, stored procedure mysql,Dati EXIF

Dati EXIF: analisi tecnica dello strumento per la loro rimozione
1920 1280 Nicola Montemurro

Obiettivi e Necessità

La gestione delle immagini digitali, per coloro che ne condividono di continuo sui social, siti web, blog, etc. richiede una considerazione attenta dei metadati, in particolare dei dati EXIF (Exchangeable Image File Format). Questi metadati, che possono includere informazioni sensibili come posizione GPS, nome dell’utente, data di scatto e dettagli della fotocamera, possono compromettere la privacy e la sicurezza.

La gestione delle immagini digitali, per coloro che ne condividono di continuo sui social, siti web, blog, etc. richiede una considerazione attenta dei metadati, in particolare dei dati EXIF (Exchangeable Image File Format). Questi metadati, che possono includere informazioni sensibili come posizione GPS, nome dell’utente, data di scatto e dettagli della fotocamera, possono compromettere la privacy e la sicurezza.

Questo articolo analizza un’applicazione Python progettata per rimuovere i dati EXIF in modo automatizzato e sistematico, evidenziando la struttura logica e le funzionalità principali del codice.

Struttura e Logica del Codice

Il codice analizzato è suddiviso in moduli e funzioni ben definiti, ciascuno con un compito specifico. Questa organizzazione ne migliora la leggibilità, consente la facile manutenzione ed eventuale estensione.

Funzione per la trasformazione del formato file size

La funzione parse_human_readable_size consente di definire la dimensione dei file di log in un formato intelligibile dall’utente.

def parse_human_readable_size(size_str):
    size_pattern = re.compile(r'(\d+)([KMG]B?)', re.IGNORECASE)
    match = size_pattern.fullmatch(size_str.strip())
    if match:
        size = int(match.group(1))
        unit = match.group(2).upper()
        if unit in ['KB', 'K']:
            return size * 1024
        elif unit in ['MB', 'M']:
            return size * 1024**2
        elif unit in ['GB', 'G']:
            return size * 1024**3
    raise ValueError(f"Invalid size format: {size_str}")

2. Configurazione del Logging

La funzione setup_logging gestisce la configurazione del sistema di logging, consentendo di definire percorso e nome del file di log qualora nell’argomento sia specificato l’intero filepath, altrimenti, qualora nell’argomento sia esplicitata solo la directory, assumerà come nome file lo stesso basename dello script in esecuzione. inoltre al raggiungimento di una data dimensione, si occuperà di effettuare la rotazione del file.

def setup_logging(log_file_path, max_log_size):
    log_dir = log_file_path.parent
    log_dir.mkdir(parents=True, exist_ok=True)
    if log_file_path.is_dir():
        log_file_path = log_dir / f"{Path(__file__).stem}.log"
    handler = RotatingFileHandler(log_file_path, maxBytes=max_log_size, backupCount=5)
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)
    logger.addHandler(handler)

3. Creazione del percorso di Backup delle immagini soggette a modifica

La funzione generate_unique_backup_file assicura che ogni backup abbia un nome unico, evitando conflitti.; qualora vengano processati più file con lo stesso nome, per evitare di sovrascrivere il backup del file precedentemente processato, la funzione si occuperà di generare un nome file con suffisso esadecimale a tre cifre (da 000 a FFF)  da assegnare al nuovo file;

def generate_unique_backup_file(original_file_path, backup_dir):
    base_name = Path(original_file_path).name
    backup_path = Path(backup_dir) / base_name
    index = 0
    while backup_path.exists():
        index += 1
        suffix = f"{index:03x}"
        backup_path = Path(backup_dir) / f"{Path(base_name).stem}_{suffix}{Path(base_name).suffix}"
    return backup_path

4. Backup dei File Originali

La funzione backup_file gestisce il backup delle immagini originali prima della rimozione dei dati EXIF.

def backup_file(original_file_path, backup_dir):
    backup_path = generate_unique_backup_file(original_file_path, backup_dir)
    backup_path.parent.mkdir(parents=True, exist_ok=True)
    try:
        shutil.copy2(original_file_path, backup_path)
        logging.info(f"Backup created for: {original_file_path} at {backup_path}")
    except PermissionError:
        logging.error(f"Permission denied when backing up {original_file_path}.")
    except Exception as e:
        logging.error(f"Error backing up {original_file_path}: {e}")

5. Rimozione dei Dati EXIF

La funzione remove_exif_data rimuove i dati EXIF dalle immagini.

def remove_exif_data(image_path, backup_dir=None):
    try:
        with Image.open(image_path) as image:
            exif_data = getattr(image, 'getexif', lambda: None)()
            if exif_data:
                if backup_dir:
                    backup_file(image_path, backup_dir)
                image.save(image_path, quality=100)
                logging.info(f"EXIF data removed from: {image_path}")
                return True
            else:
                logging.debug(f"No EXIF data found in: {image_path}")
                return False
    except FileNotFoundError:
        logging.error(f"File not found: {image_path}")
        return False
    except PermissionError:
        logging.error(f"Permission denied for file: {image_path}")
        return False
    except OSError as e:
        logging.error(f"Error processing {image_path}: {e}")
        return False

6. Ricerca e Rimozione Dati EXIF

La funzione search_and_remove_exif esplora le directory e rimuove i dati EXIF, richiamando la funzione remove_exif_data.

def search_and_remove_exif(root_dir, backup_dir=None, exclude_exts=None, exclude_dirs=None, verbose=False):
    total_files_processed = 0
    total_files_modified = 0

    for root, dirs, files in os.walk(root_dir):
        if exclude_dirs and any(exclude in root for exclude in exclude_dirs):
            logging.debug(f"Excluded directory: {root}")
            continue

        for file in files:
            file_ext = Path(file).suffix.lower()
            if exclude_exts and file_ext in exclude_exts:
                logging.debug(f"Excluded file: {file}")
                continue
            if file_ext in ('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp'):
                image_path = Path(root) / file
                total_files_processed += 1
                if remove_exif_data(image_path, backup_dir):
                    total_files_modified += 1
                    if verbose:
                        print(f"Removed EXIF from: {image_path}")
                else:
                    if verbose:
                        print(f"No EXIF data in: {image_path}")

    logging.info(f"Total files processed: {total_files_processed}")
    logging.info(f"Total files modified: {total_files_modified}")

7. Funzione Main

La funzione main gestisce l’interfaccia a riga di comando e coordina l’esecuzione.

def main():
    import argparse

    parser = argparse.ArgumentParser(description="Remove EXIF data from media files.")
    parser.add_argument('path', type=str, help="Path to the directory to search")
    parser.add_argument('--log-path', type=str, help="Path to the log file or directory", default=None)
    parser.add_argument('--backup-path', type=str, help="Path to the backup directory", default=None)
    parser.add_argument('--exclude-exts', type=str, nargs='*', help="File extensions to exclude", default=None)
    parser.add_argument('--exclude-dirs', type=str, nargs='*', help="Directories to exclude", default=None)
    parser.add_argument('--max-log-size', type=str, help="Max log file size (e.g. 5MB, 1GB)", default="5MB")
    parser.add_argument('--verbose', action='store_true', help="Enable verbose output")
    args = parser.parse_args()

    max_log_size = parse_human_readable_size(args.max_log_size)

    if args.log_path:
        log_file_path = Path(args.log_path)
        if log_file_path.is_dir():
            log_file_path = log_file_path / f"{Path(__file__).stem}.log"
    else:
        log_file_path = Path(__file__).parent / f"{Path(__file__).stem}.log"

    setup_logging(log_file_path, max_log_size)

    start_time = time.time()
    search_and_remove_exif(args.path, args.backup_path, args.exclude_exts, args.exclude_dirs, args.verbose)
    elapsed_time = time.time() - start_time
    logging.info(f"Process completed in {elapsed_time:.2f} seconds.")

Codice completo

# ----------------------------------------------------------------------------------
# - Script file name    :       cleanexif.py
# - Author              :       NM
# - DNS administrator   :       NM
# - Create              :       22.08.2024
# - Last Update         :       22.08.2024
# - Description         :
# - Position            :       /usr/local/script
# - note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  -----------------------------------------------------------------------------------

import os
import logging
import shutil
from logging.handlers import RotatingFileHandler
from PIL import Image
from pathlib import Path
import time
import re

def parse_human_readable_size(size_str):
    """Converte una dimensione in formato human-readable in byte."""
    size_pattern = re.compile(r'(\d+)([KMG]B?)', re.IGNORECASE)
    match = size_pattern.fullmatch(size_str.strip())

    if match:
        size = int(match.group(1))
        unit = match.group(2).upper()

        if unit in ['KB', 'K']:
            return size * 1024
        elif unit in ['MB', 'M']:
            return size * 1024**2
        elif unit in ['GB', 'G']:
            return size * 1024**3
    raise ValueError(f"Invalid size format: {size_str}")

def setup_logging(log_file_path, max_log_size):
    """Configura il logging con rotazione basata sulla dimensione."""
    # Crea la directory se non esiste
    log_dir = log_file_path.parent
    log_dir.mkdir(parents=True, exist_ok=True)

    # Assicurati che il percorso sia un file, non una directory
    if log_file_path.is_dir():
        log_file_path = log_dir / f"{Path(__file__).stem}.log"

    # Configura il gestore di log
    handler = RotatingFileHandler(log_file_path, maxBytes=max_log_size, backupCount=5)
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)

    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)
    logger.addHandler(handler)

def generate_unique_backup_file(original_file_path, backup_dir):
    """Genera un percorso di backup unico aggiungendo un suffisso esadecimale se necessario."""
    base_name = Path(original_file_path).name
    backup_path = Path(backup_dir) / base_name

    index = 0
    while backup_path.exists():
        index += 1
        suffix = f"{index:03x}"
        backup_path = Path(backup_dir) / f"{Path(base_name).stem}_{suffix}{Path(base_name).suffix}"

    return backup_path

def backup_file(original_file_path, backup_dir):
    """Copia il file originale nel percorso di backup, mantenendo la struttura."""
    backup_path = generate_unique_backup_file(original_file_path, backup_dir)
    backup_path.parent.mkdir(parents=True, exist_ok=True)
    try:
        shutil.copy2(original_file_path, backup_path)
        logging.info(f"Backup created for: {original_file_path} at {backup_path}")
    except PermissionError:
        logging.error(f"Permission denied when backing up {original_file_path}.")
    except Exception as e:
        logging.error(f"Error backing up {original_file_path}: {e}")

def remove_exif_data(image_path, backup_dir=None):
    """Rimuove i dati EXIF da un'immagine, creando un backup se richiesto."""
    try:
        with Image.open(image_path) as image:
            exif_data = getattr(image, 'getexif', lambda: None)()
            if exif_data:
                if backup_dir:
                    backup_file(image_path, backup_dir)
                image.save(image_path, quality=100)
                logging.info(f"EXIF data removed from: {image_path}")
                return True
            else:
                logging.debug(f"No EXIF data found in: {image_path}")
                return False
    except FileNotFoundError:
        logging.error(f"File not found: {image_path}")
        return False
    except PermissionError:
        logging.error(f"Permission denied for file: {image_path}")
        return False
    except OSError as e:
        logging.error(f"Error processing {image_path}: {e}")
        return False

def search_and_remove_exif(root_dir, backup_dir=None, exclude_exts=None, exclude_dirs=None, verbose=False):
    """Cerca e rimuove i dati EXIF da tutti i file di immagine in una directory."""
    total_files_processed = 0
    total_files_modified = 0

    for root, dirs, files in os.walk(root_dir):
        if exclude_dirs and any(exclude in root for exclude in exclude_dirs):
            logging.debug(f"Excluded directory: {root}")
            continue

        for file in files:
            file_ext = Path(file).suffix.lower()
            if exclude_exts and file_ext in exclude_exts:
                logging.debug(f"Excluded file: {file}")
                continue
            if file_ext in ('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp'):
                image_path = Path(root) / file
                total_files_processed += 1
                if remove_exif_data(image_path, backup_dir):
                    total_files_modified += 1
                    if verbose:
                        print(f"Removed EXIF from: {image_path}")
                else:
                    if verbose:
                        print(f"No EXIF data in: {image_path}")

    logging.info(f"Total files processed: {total_files_processed}")
    logging.info(f"Total files modified: {total_files_modified}")

def main():
    import argparse

    parser = argparse.ArgumentParser(description="Remove EXIF data from media files.")
    parser.add_argument('path', type=str, help="Path to the directory to search")
    parser.add_argument('--log-path', type=str, help="Path to the log file or directory", default=None)
    parser.add_argument('--backup-path', type=str, help="Path to the backup directory", default=None)
    parser.add_argument('--exclude-exts', type=str, nargs='*', help="File extensions to exclude", default=None)
    parser.add_argument('--exclude-dirs', type=str, nargs='*', help="Directories to exclude", default=None)
    parser.add_argument('--max-log-size', type=str, help="Max log file size (e.g. 5MB, 1GB)", default="5MB")
    parser.add_argument('--verbose', action='store_true', help="Enable verbose output")
    args = parser.parse_args()

    max_log_size = parse_human_readable_size(args.max_log_size)

    # Imposta il percorso del file di log
    if args.log_path:
        log_file_path = Path(args.log_path)
        if log_file_path.is_dir():
            log_file_path = log_file_path / f"{Path(__file__).stem}.log"
    else:
        log_file_path = Path(__file__).parent / f"{Path(__file__).stem}.log"

    setup_logging(log_file_path, max_log_size)

    start_time = time.time()
    search_and_remove_exif(args.path, args.backup_path, args.exclude_exts, args.exclude_dirs, args.verbose)
    elapsed_time = time.time() - start_time
    logging.info(f"Process completed in {elapsed_time:.2f} seconds.")

if __name__ == "__main__":
    main()
    logging.shutdown()

Considerazioni finali

L’analisi dettagliata delle funzioni del codice pone l’accento sulla volontà di ottenere la progettazione accurata e la logica ben definita sinergiche all’obiettivo di rimuovere i dati EXIF dalle immagini, garantendo una maggiore protezione dei dati e nel contempo una gestione semplice e organizzata dei file.

time slicing, time slice, quantum

Time Slicing nei Sistemi Operativi
1920 1280 Nicola Montemurro

Introduzione

Nel mondo dei sistemi operativi, la gestione efficiente della CPU è cruciale per garantire prestazioni ottimali. Tra le tecniche più significative troviamo il time slicing, che permette a più processi di condividere equamente l’unità di elaborazione. In questo articolo, esploreremo in dettaglio come funziona il time slicing, i suoi vantaggi e svantaggi, e come gli operatori del settore possano ottimizzarne l’uso.

Cos’è il Time Slicing?

Il time slicing è un metodo di pianificazione dei processi che consente a un sistema operativo di garantire un accesso equo alla CPU. In ambienti a singlola CPU, questa tecnica offre un’illusione di multitasking, permettendo a più processi di apparire in esecuzione simultaneamente.

Funzionamento del Time Slicing

1. Processi e Thread

Ogni processo in un sistema operativo ha uno stato e risorse dedicate. Per gestire la concorrenza, il sistema operativo divide il tempo della CPU in intervalli noti come quantum.

2. Quantum di Tempo

Il quantum rappresenta il tempo massimo che un processo può utilizzare la CPU prima di essere interrotto. La scelta di un quantum adeguato è critica: se troppo breve, genera frequenti cambi di contesto; se troppo lungo, può portare a una scarsa reattività.

3. Pianificazione e Interruzioni

Quando il sistema operativo inizia la pianificazione, seleziona un processo dalla coda e lo esegue per un tempo pari al quantum. Al termine, un interrupt timer genera un’interruzione, consentendo al sistema di salvare lo stato del processo attuale e caricare quello di un altro processo in attesa.

4. Cambio di Contesto

Il context switching è il processo di salvataggio e ripristino degli stati dei processi. Questo passaggio, sebbene necessario, introduce un overhead significativo che può influenzare le prestazioni globali.

Vantaggi del Time Slicing

– Equità: Ogni processo ha accesso alla CPU, riducendo il rischio di starvation.

– Reattività: Processi interattivi rispondono meglio, garantendo un’esperienza utente fluida.

Svantaggi del Time Slicing

– Overhead: Il cambio di contesto comporta un costo in termini di tempo e risorse.

– Latency: Un quantum troppo breve può aumentare la latenza e ridurre l’efficienza.

Ottimizzazione del Time Slicing

1. Scelta del Quantum

La scelta del quantum è una delle decisioni più critiche nel design dei sistemi operativi. Deve essere bilanciata: un quantum più lungo riduce l’overhead, ma può compromettere la reattività, mentre uno troppo corto aumenta il numero di cambi di contesto.

2. Strategie di Scheduling

Diversi sistemi operativi offrono strategie di scheduling variabili. In Linux, ad esempio, si può utilizzare il comando `chrt` per cambiare la politica di scheduling di un processo, da “normal” a “real-time“.

3. Monitoraggio e Analisi

Utilizzare strumenti come `htop` in  ambiente Unix/Linux o il Task Manager di Windows consente agli amministratori di monitorare le prestazioni dei processi e modificare le priorità, ottimizzando così il time slicing.

Considerazioni finali

Il time slicing è una componente fondamentale nella gestione della CPU nei sistemi operativi moderni. Per i professionisti del settore, comprendere a fondo questa tecnica e come ottimizzarla può portare a significativi miglioramenti delle prestazioni. Mentre l’implementazione del time slicing offre un’efficace condivisione delle risorse, è essenziale prestare attenzione alla configurazione del quantum e alla gestione dei cambi di contesto.

Proxy Auto-Configuration

Proxy Auto-Configuration (PAC), Autoconfigurazione del Browser
1920 1280 Nicola Montemurro

Cos'è Proxy.pac

Il file .pac, comunemente proxy.pac (Proxy Auto-Configuration) è uno script di autoconfigurazione del browser, basato sulla funzione javaScript FindProxyForURL(url, host) che restituisce un risultato basato su condizioni definite dal gestore del sistema di proxy, che un moderno browser è in grado di interpretare in tempo reale, comportandosi di conseguenza.

Viene utilizzato quando è necessario discriminare la modalità di navigazione in modo da specificare, al browser, quale proxy utilizzare oppure se connettersi in modo “diretto”.

La centralizzazione della configurazione tramite proxy.pac consente di ridurre la necessità di configurazioni manuali distribuite su ciascun dispositivo degli utenti, semplificando la gestione e manutenzione delle configurazioni e minimizzando il rischio di errore.

Eccone un esempio:

function FindProxyForURL(url, host)
{
       if (isPlainHostName(host))
       {
       return "DIRECT";
       }
// NAME HOSTS --> DIRECT

        if ((host=="domainname.it")||
            (host=="domainname.com"))
        {
        return "DIRECT";
        }

// NAME HOSTS --> PROXY

        if ((host=="abcd.domainname.it")||
            (host=="efgh.subdomain.domainname.it"))
        {
        return ProxyServer(url);
        }

// IP HOSTS --> DIRECT

        if ((host=="10.60.50.141") ||      // Servizio XYZ;
            (host=="10.32.1.103"))         // Servizio ZXY;
        {
        return "DIRECT";
        }

// IP HOSTS --> PROXY A

        if ((host=="10.128.64.50")   ||    // Servizio A
            (host=="10.51.8.50")     ||    // Servizio B
            (host=="10.51.76.202"))        // Servizio C
        {
        return ProxyServer(url);
        }

// IP HOSTS --> PROXY B;

        if ((host=="XXX.201.99.120") ||
            (host=="YYY.223.212.242") ||
            (host=="ZZZ.221.99.154"))
        {
        return "PROXY aa.bbb.ccc.d:8080; DIRECT";
        }

 //LOCAL DOMAIN NAME --> DIRECT

        if (dnsDomainIs(host, "subdomain.mydomain.it") ||
            dnsDomainIs(host, "subdomain.mydomain.com") ||
            dnsDomainIs(host, "internaldomain.loc") ||
            dnsDomainIs(host, "otherdomain.it"))
        {
        return "DIRECT";
        }

//PRIVATE NETWORK --> DIRECT 

        if (isInNet(host, "10.0.0.0", "255.0.0.0") ||
            isInNet(host, "127.0.0.0", "255.0.0.0")  ||
            isInNet(host, "172.16.0.0", "255.240.0.0")  ||
            isInNet(host, "192.168.0.0", "255.255.0.0"))
        {
        return "DIRECT";
        }

        // otherwise use Proxy Server

        else

        function ProxyServer(url);

function ProxyServer(url) {
   return "PROXY cache.internaldomain.it:3128; DIRECT";
}

Considerazioni finali

Il file proxy.pac rappresenta uno strumento essenziale per la gestione delle configurazioni proxy nelle reti aziendali. La sua flessibilità e capacità di automatizzare la configurazione del proxy consentono alle organizzazioni di implementare politiche di sicurezza efficaci, ottimizzare la larghezza di banda e semplificare la gestione delle configurazioni client. Con una corretta implementazione e manutenzione, il file proxy.pac può contribuire significativamente all’efficienza operativa e alla sicurezza della rete aziendale

Per approfondire:

Per ulteriori informazioni sullo script di autoconfigurazione potete consultare Wikipedia

Per verificare la sintassi del file di autoconfigurazione del browser proxy.pac potete utilizzare pactester.

python, stored procedure mysql,Dati EXIF

MYSQL: Eseguire Stored Procedure da Crontab
1920 1280 Nicola Montemurro

Quando il cliente ti chiede di poter ricevere un report, in merito alle chiamate ricevute sul centralino Asterisk, e nella tua testa si fa largo l’idea di riuscire a risolvere semplicemente e con poco, sappi che stai sognando e che da lì a poco, avrai un brusco risveglio.
Estrarre i dati da database, non era un problema, si trattava di scrivere una stored procedure da eseguire in tempi pianificati dal Crontab Linux, la complicazione vera era rappresentata dalla modalità di pianificazione, che prevedeva la produzione del report in orari diversi per giorni diversi, con dati relativi a un intervallo di tempo anteriore, rispetto alla data di esecuzione, sempre variabile.

Come spesso accade, in ambito informatico, esistono molti modi per ottenerne il medesimo risultato; cercando di essere efficace ma, soprattutto, in ottica di riutilizzo del codice, ho pensato a questa soluzione.

Lo script Python, mostrato di seguito, esegue la stored procedure Mysql, producendo il report in formato Excel che viene inoltrato via email.

# ----------------------------------------------------------------------------------
# - Script file name    :       backtothefuture.py
# - Author              :       Nicola Montemurro
# - DNS administrator   :       Nicola Montemurro  - Tel. xxx, Mobile: xxx
# - Create              :       21.03.2024
# - Last Update         :       24.03.2024
# - Description         :
# - Position            :       /usr/local/script
# - note                :       NON modificare senza AUTORIZZAZIONE dell'AMMINISTRATORE
#  -----------------------------------------------------------------------------------

# Back to the Future: The expression refers to the time when one has
# to stop (over) thinking about the things they could, or not,
# have done in the past so that what happened wouldn’t have happened. #!/usr/bin/env python3 # -*- coding: utf-8 -*- import argparse import datetime from datetime import datetime, date, timedelta import mysql.connector from mysql.connector import (connection) from mysql.connector import Error import smtplib from email.message import EmailMessage import csv ”’ RUN MODE: 1: 2: 3: ”’ class Datetime64Converter(mysql.connector.conversion.MySQLConverter): “”” A mysql.connector Converter that handles datetime64 types “”” mysqlconfig = { ‘user’: ‘mysqluser’, ‘password’: ‘password’, ‘host’: ‘172.17.6.2’, ‘database’: ‘database’, ‘raise_on_warnings’: True } smtphost = ‘172.17.7.10’ sender = “sender@dominio.it” recipients = “utente1@dominio.it, utente2@dominio.com” csvfilename=’output.csv’ ########### CODE MySQLStoredProcedure=’mysql-storedprocedure-name’ isconnected = False now = datetime.today() #print(now) def connectToMysql(): try: conn = mysql.connector.connect(**mysqlconfig) conn.set_converter_class(Datetime64Converter) except mysql.connector.Error as error: print(format(error)) finally: # mysql_isconnected = mysqlconn.is_connected pass return conn def disconnectFromMysql(conn): try: conn.disconnect conn.close except mysql.connector.Error as error: print(format(error)) return conn def callStoredProcedure(conn): past = calcdate(days[0], hours[0], mins[0]) args = (past, now) #2024-03-21 20:00:00 cursor = conn.cursor() try: cursor.callproc(MySQLStoredProcedure, args) results = [] for result in cursor.stored_results(): #results.append(result.fetchall()) results = result.fetchall() # debug #print(results) except mysql.connector.Error as error: print(format(error)) finally: cursor.close return results def buildcsv(chunks, filename): # https://docs.python.org/3/library/csv.html try: fhandle = open(filename, ‘w’, encoding=’utf-8′, newline=”) headers = [‘col1’, ‘col2’, ‘col3’, ‘col4’, ‘col5’, ‘col6′] # create csv write object writer = csv.writer(fhandle, delimiter=’;’, quotechar='”‘, dialect=’excel’, quoting=csv.QUOTE_NONE) writer.writerow(headers) for line in chunks: writer.writerow(line) except Exception as e: print(e) finally: # close file fhandle.close() def composemsg(content, attachment): msg = EmailMessage() msg[‘Subject’] = ‘oggetto email del giorno: ‘ + str(now) msg[‘From’] = sender msg[‘To’] = recipients msg.set_content(str(content)) with open(attachment, ‘rb’) as f: content = f.read() msg.add_attachment(content, maintype=’text’, subtype=’plain’, filename=attachment) return msg def sendmsg(content, attachment): # https://docs.python.org/3/library/smtplib.html emsg = composemsg(content, attachment) try: with smtplib.SMTP(smtphost, 25) as s: s.set_debuglevel(0) s.ehlo() s.ehlo_or_helo_if_needed #s.starttls() s.sendmail(sender, recipients.split(‘,’),emsg.as_string()) s.close except smtplib.SMTPException as error: print(format(error)) except smtplib.SMTPServerDisconnected as error: print(format(error)) except smtplib.SMTPResponseException as error: print(format(error)) except smtplib.SMTPSenderRefused as error: print(format(error)) except smtplib.SMTPRecipientsRefused as error: print(format(error)) except smtplib.SMTPDataError as error: print(format(error)) except smtplib.SMTPConnectError as error: print(format(error)) except smtplib.SMTPHeloError as error: print(format(error)) except smtplib.SMTPNotSupportedError as error: print(format(error)) except smtplib.SMTPAuthenticationError as error: print(format(error)) def calcdate(idays, ihours, imins): backtothefuture = now – timedelta(days = float(idays)) backtothefuture -= timedelta(hours = float(ihours)) backtothefuture -= timedelta(minutes = float(imins)) #print(backtothefuture) return backtothefuture parser = argparse.ArgumentParser() parser.add_argument(“-d”, “–days”, type=int, default=[0], nargs=1, required=False, help=”subtract DAYS days from today’s date”) parser.add_argument(“-H”, “–hours”, type=int, default=[0], nargs=1, required=False, help=”subtract HOURS hours from today’s date”) parser.add_argument(“-m”, “–mins”, type=int, default=[0], nargs=1, required=False, help=”subtract MINS mins from today’s date”) args=parser.parse_args() days=(args.days) hours=(args.hours) mins=(args.mins) def main(): MySQLConnection = connectToMysql() isconnected = MySQLConnection.is_connected if isconnected: spres = callStoredProcedure(MySQLConnection) buildcsv(spres, csvfilename) sendmsg(spres, csvfilename) disconnectFromMysql(MySQLConnection) #print(spres) if __name__ == “__main__”: main()

Di seguito viene mostrato un esempio di uso da Crontab

#
#
#
### INTERVALLO DI INIZIO A PARTIRE DALLE 17:00 del sabato alle 8:00 del lunedi (39H oppure 1d 15H)
0 8 * * 1 /usr/bin/python3 /usr/local/scripts/backtothefuture.py --days 1 --hours 15
### INTERVALLO DI INIZIO A PARTIRE DALLE 17:00 fino alle 8:00 (mar - sab)
0 8 * * 2-6 /usr/bin/python3 /usr/local/scripts/backtothefuture.py --hours 15
### INTERVALLO DI INIZIO A PARTIRE DALLE 8:00 alle 13:00 (lun-sab)
0 13 * * 1-6 /usr/bin/python3 /usr/local/scripts/backtothefuture.py -H 5
### INTERVALLO DI INIZIO A PARTIRE DALLE 13:00 ALLE 15:00 (lun-sab)
0 15 * * 1-6 /usr/bin/python3 /usr/local/scripts/backtothefuture.py -H 2
### INTERVALLO DI INIZIO A PARTIRE DALLE 15:00 ALLE 17:00 (lun-sab)
0 17 * * 1-6 /usr/bin/python3 /usr/local/scripts/backtothefuture.py -H 2
#
#
#
gestione degli accessi

Gestione degli accessi: Diritti, Privilegi e Autorizzazioni
2050 1538 Nicola Montemurro

Gestione degli accessi

L’argomento della Gestione degli accessi potrà sembrare banale, quanto scontato, ma vi assicuro che mi imbatto spesso in termini onnipresenti come amministratore e account utente standard o normale. In termini di capacità, la differenza tra questi due è abbastanza evidente. Tuttavia, quando si tratta esplicitamente di espressioni come diritti di amministratore, diritti non di amministratore, privilegi di amministratore, privilegi non di amministratore, privilegi elevati, privilegi ridotti, permessi elevati, permessi ridotti, diritti utente standard, permessi utente normali, ecc., allora le cose iniziano a diventare più oscure. Per aumentare ulteriormente la confusione, è anche un’osservazione comune che i diritti, i privilegi e le autorizzazioni sono quasi sempre usati in modo intercambiabile nel contesto di un determinato account, sia esso amministratore o qualsiasi altro utente.

Attraverso questo articolo cercherò di chiarire questa ambiguità nella gestione degli accessi e svelare la somiglianza e le differenze, se ce ne sono, tra questi tre costrutti di controllo degli accessi e la loro relazione con account diversi.

Diritti

I diritti sono i metodi di autorizzazione con cui un account può accedere a una macchina, ad esempio una workstation o un server. Questo è il motivo per cui vengono anche indicati come diritti di accesso o diritti utente. I diritti vengono assegnati agli account o ai gruppi da un amministratore.

Privilegi

I privilegi sono le operazioni che un account può eseguire sul computer dopo aver eseguito correttamente l’accesso. I privilegi vengono concessi agli account o ai gruppi da un Amministratore.

Autorizzazioni

Le autorizzazioni sono controlli di accesso agli oggetti a protezione diretta e ai relativi attributi. Riferendoci all’ambiente Windows, gli oggetti Active Directory, il registro di sistema, i file e le directory sul file system, i processi, i thread, i servizi, le condivisioni di rete e così via, sono tipi di oggetti a protezione diretta. In sostanza, oggetti diversi hanno attributi diversi e attributi diversi possono avere un set diverso di autorizzazioni. In altre parole, le autorizzazioni controllano quale utente può accedere a quale oggetto e in che modo. Le autorizzazioni vengono assegnati agli account o ai gruppi da un amministratore; Riferendoci all’ambiente *nix, non esistono, letteralmente, gli oggetti perchè tecnicamente sono file, ma sostanzialmente, le regole restano le stesse.

Cos’è un Amministratore?

Un amministratore è un account che ha almeno i diritti e i privilegi sufficienti ad assegnare, diritti, privilegi e autorizzazioni agli altri account, oltre che poter elevare ulteriormente i propri; solo un’altro account amministratore può ridurne i diritti, privilegi e le autorizzazioni.

In pratica, un amministratore può assegnare diritti e privilegi a un account e assegnare autorizzazioni per gli oggetti a protezione diretta, in modo che altri account possano lavorare su di essi.

Cos’è un utente Standard?

Un utente standard non è altro che un account che dispone di diritti e privilegi minimi.

Spero di aver espresso chiaramente i concetti sull’uso corretto della gestione degli accessi e di aver contribuito a fare un po’ di chiarezza in merito.

riservatezza, sicurezza, privacy, security

Riservatezza e Sicurezza
1920 1280 Nicola Montemurro

L'importanza della sicurezza

Sia la sicurezza (cybersecurity) che la riservatezza (privacy) sono importanti nel mondo fisico e digitale. La riservatezza è il diritto di controllare il modo in cui le informazioni vengono visualizzate e utilizzate, mentre la sicurezza è la protezione da minacce o pericoli. Nel mondo digitale, la sicurezza si riferisce generalmente all’accesso non autorizzato ai dati, e spesso implica la protezione contro i criminali informatici. La privacy riguarda il diritto di gestire le proprie informazioni personali, mentre la sicurezza è la protezione di tali informazioni. Entrambi sono aspetti ugualmente importanti della sicurezza informatica. L’utente ha diritto alla privacy e deve adottare misure per proteggere le proprie informazioni e i propri dati personali nel mondo digitale.

Sicurezza e Riservatezza

La differenza principale tra privacy e cybersecurity è che la privacy riguarda il modo in cui i dati vengono utilizzati e controllati, mentre la cybersecurity li protegge. La cybersecurity può esistere senza privacy, ma non è vero il contrario. La sicurezza informatica e la riservatezza sono entrambe ugualmente importanti per la gestione di informazioni e dati personali e sensibili. In generale, la riservatezza si riferisce ai dettagli che vi riguardano direttamente e al modo in cui desiderate condividerli. La sicurezza vi tiene al riparo da potenziali minacce. La cybersecurity, quindi, implica la protezione dei dati dall’uso o dall’accesso non autorizzato. In termini di dati, la privacy si riferisce direttamente al modo in cui le aziende sono in grado di raccogliere, gestire, archiviare e controllare l’uso dei dati forniti. La privacy personale è stata spesso considerata un lusso non accessibile a tutti, mentre la sicurezza è stata a lungo ritenuta essenziale. La sicurezza pubblica è sempre stata anteposta alla privacy; tuttavia, la mancanza di privacy personale può diventare un problema di sicurezza pubblica. Pur essendo diverse, la sicurezza e la privacy devono essere mantenute entrambe.

Per garantire la sicurezza delle informazioni, è necessario proteggere la propria privacy seguendo alcune misure di sicurezza.

  • Limitate la vostra presenza sui social media e la quantità di dati che condividete online.
  • Leggete integralmente l’informativa sulla privacy dell’organizzazione prima di accettarne i termini.
  • Tenete al sicuro i documenti di identità (Carta di Indentità, Patente, Passaporto, Tessera Sanitaria, etc) ed evitate di distribuirli se non strettamente necessario.
  • Utilizzate l’autenticazione a più fattori per accedere a siti sicuri.
  • Utilizzate i firewall.
  • Utilizzate password diverse per siti e applicazioni diversi. Rendete ogni password complessa o prendete in considerazione una passphrase.

Una volta che i vostri dati sono online, non sono più sotto il vostro diretto controllo. Fate attenzione a chi condivide queste informazioni. Assicuratevi di sapere esattamente quali dati stanno raccogliendo, come intendono proteggerli e a chi le condivideranno. Essere informati e consapevoli può aiutare a proteggere la vostra privacy e di conseguenza la vostra sicurezza.

vmware e virtualbox

VLAN con VMware Workstation e Virtualbox
1920 1280 Nicola Montemurro

Utilizzare le vlan con gli hypervisor desktop e possibile e non particolarmente difficile per chi ha un minimo di competenze di networking, a patto di possedere i requisiti minimi necessari, quali uno switch managed che gestisca vlan e qualora si voglia fare in modo che le stesse vlan comunichino tra loro, occorre anche un router con capacità di bridging.

Se siete curiosi sull’argomento e avete voglia di sperimentare, ma non possedete router e switch adatti, potete, provare installando Linux su un paio di macchine virtuali, che svolgeranno la funzione di switch e router; argomento che, però, tratterò in un prossimo articolo;

Affinchè possano essere utlizzate le singole vlan è fondamentale l’uso di un bridge, che consenta la suddivisione del trunk vlan erogato dallo switch; il bridge non è altro che una, scheda di rete (hardware) opportunamente configurata.

Realizzare il bridge su Windows

Per questo caso è necessario, se già non la si possiede, installare, una seconda scheda di rete prodotta da Intel e compatibile con i drivers Intel Proset (potete ricercare l’HCL, Hardware Compatibility, List); esistono, comunque, altri produttori hardware che hanno le medesime funzionalità (es. Realtek o Broadcom), per le quali si applicano gli stessi concetti.

Il bridge

Dopo aver installato, correttamente il driver specifico dell’hardware, proseguite con l’installazione del software ProSet; al termine, sarà resa disponibile la nuova interfaccia di rete, col nome dell’hardware utilizzato, ad es. Intel(R) I210 Gigabit Network Connection, ovvero il bridge.

Intel Proset
Intel Proset vlan
New VLAN

L'interfaccia VLAN

Occorre, adesso, configurare l’interfaccia per ciascuna vlan trasportata da trunk, come da configurazione dello switch, come descritto.

Fate click col tasto destro, sul bridge => proprietà => configura e se non ci saranno stati errori, vi apparirà una finestra contenente una serie di tabs, tra i quali il tab VLAN; dopo aver inserito l’ID vlan e confermato, verrà creata una nuova interfaccia, con nome Ethernet’X’, ovvero l’interfaccia VLAN, rinominata in VLAN 15 nell’esempio illustrato.

nic rename

Giunti a questa fase, avrete realizzato il bridge e la relativa interfaccia vlan, nell’esempio vlan 15, che potrete usare direttamente da Windows assegnandogli un indirizzo IP specifico; in questo caso il vostro pc sarà collegato ad entrambe le sottoreti, la sottorete ordinaria e la e la sottorete taggata 15, oppure, oggetto di questo articolo, la stessa interfaccia vlan può diventare, a sua volta, bridge per l’ambiente di virtualizzazione a bordo del pc.

VMWare Workstation

VMware Workstation, implementa la parte di rete in modo centralizzato, in una sezione specifica che troverete facendo click sul menù Edit => Virtual Network Editor, sarà, quindi, visualizzata una finestra come indicato sotto (con UAC attivo dovrete concedere l’autorizzazione), selezionate Add Network, selezionate una vmnetX disponibile dall’elenco a discesa e confermate, selezionate Bridged (Connect VMs …) e selezionate dall’elenco a discesa l’interfaccia che fa riferimento alla vlan che intendete associare e premete OK, a questo punto, selezionate una VM, tasto destro, selezionate Settings, andate in Network Adapter, sul tab di destra, selezionate Custom e dal menù a discesa, selezionate la vmnet corrispondente alla vlan che intendete assegnare.

Fatto!

Adesso la VM ha l’interfaccia di rete assegnata ad una vlan della vostra rete, non dovete fare altro che assegnare il giusto indirizzo IP al sistema operativo.

vmware workstation vlan
vlan machine settings

Virtualbox

Virtualbox, non ha la gestione centralizzata, gestisce il bridging, assegnando un’interfaccia di rete, così come appare sul pc, direttamente alla scheda di rete virtuale della VM;  dovrete solo selezionare, Scheda con bridge, dal menù a discesa e successivamente l’interfaccia di rete desiderata.

Virtualbox vlans

Bindings

Aggiungo alcune considerazioni sul binding, termine con il quale, nella terminologia del networking, si definisce, generalmente, l’associazione di un protocollo, o per essere noiosamente precisi, di uno stack (di protocollo) alla relativa interfaccia; in questo specifico caso, mi riferisco ai binding necessari da attivare alle interfacce di rete Windows affinchè quanto esposto fin’ora sia effettivamente utilizzabile.

Nel primo caso, viene mostrato una interfaccia in uso PER Windows, sono attivi tutti i protocolli necessari ad operare in un contesto Active Directory; il secondo caso, riguarda il bridge di cui abbiamo trattato sopra, non necessita di nulla tranne del bind al driver; il terzo caso, riguarda l’uso diretto della vlan DA Windows, se notate lo stack ipv4 è spuntato e ha un indirizzo IP assegnato; il quarto caso riguarda una vlan in uso solo sulle VM, non ha bisogno di utilizzare alcuno stack, in quanto vengono implementati direttamente da sistema operativo della VM (ospite / guest); in tutti i casi, sono attivi solo i bindings spuntati, il resto, anche quelli non visibili, sono disabilitati; come potete vedere in tutti i casi, sono spuntati sempre VMware Bridge Protocol, VirtualBox NDIS6 Bridget networking e Npcap Packet Driver (NPCAP) (Wireshark), l’essenza della spunta, nasconderà l’interfaccia stessa all’applicazione relativa.

LAN Properties
VLAN Bridge
vlan ip assigned
binding ip unassigned

Nota

La pratica di disattivare i protocolli non necessari, dovrebbe essere la buona norma per mantenere la rete pulita dal traffico inutile ed efficiente, in particolar modo per le reti con un numero rilevante di host.

Considerazioni finali

L’utilizzo delle VLAN con gli hypervisor desktop è possibile e di faceli implementazione, a patto di avere quei requisiti necessari per la realizzazione del bridge che implementerà, di fatto, la gestione del VLAN tagging.

  • 1
  • 2

    Preferenze Privacy

    Quando visiti il nostro sito web, possono essere memorizzate alcune informazioni, di servizi specifici, tramite il tuo browser, di solito sotto forma di cookie. Qui puoi modificare le tue preferenze sulla privacy. Il blocco di alcuni cookie può influire sulla tua esperienza sul nostro sito Web e sui servizi che offriamo.

    Il nostro sito web utilizza cookie, principalmente di terze parti. Personalizza le preferenze sulla privacy e/o acconsenti all'utilizzo dei cookie.