Principi Fondativi della IT Security

La sicurezza informatica ha una base concettuale sorprendentemente stabile. Cambiano le tecnologie, ma i principi fondativi sono rimasti quasi identici da decenni. Il punto di partenza classico è la triade CIA: Confidentiality, Integrity, Availability. È il modello più semplice per definire cosa significhi davvero “proteggere” un sistema.

Confidentiality significa che l’informazione è accessibile solo a chi è autorizzato. Il meccanismo tecnico principale è il controllo dell’accesso: identità, autenticazione, autorizzazione e cifratura. Quando cifri un database o limiti l’accesso tramite IAM stai difendendo la confidenzialità.

Integrity significa che i dati non vengono alterati in modo non autorizzato. Qui entrano in gioco firme digitali, hash crittografici, controllo delle modifiche, versioning e logging. Se qualcuno modifica un record senza autorizzazione, il sistema deve accorgersene o impedirlo.

Availability significa che sistemi e dati devono essere disponibili quando servono. Questo riguarda resilienza, ridondanza, disaster recovery, protezione da DDoS, capacity planning. Un sistema perfettamente sicuro ma sempre offline è inutile.

Su questa base si innesta il modello operativo AAA: Authentication, Authorization, Accounting.

Authentication risponde alla domanda “chi sei?”. Tecnologicamente significa password, MFA, certificati, biometria, federazione di identità.

Authorization risponde alla domanda “cosa puoi fare?”. Qui entrano RBAC (role-based access control), ABAC (attribute-based), policy engine e gestione dei privilegi.

Accounting significa “cosa hai fatto?”. È la registrazione delle attività: audit log, tracciamento delle sessioni, telemetria di sicurezza. Senza accounting non esiste responsabilità né investigazione.

Se si combinano CIA e AAA emerge una struttura interessante:

  • Confidentiality dipende soprattutto da Authentication e Authorization
  • Integrity dipende da Authorization e Accounting
  • Availability dipende da resilienza infrastrutturale e monitoraggio operativo

Questo schema è ancora la spina dorsale di quasi tutte le architetture moderne.

Nel panorama attuale del settore, però, la sicurezza si è evoluta in alcune direzioni chiave.

La prima è Identity-centric security. Il perimetro di rete è scomparso con cloud, SaaS e lavoro remoto. L’identità diventa il nuovo perimetro. Per questo IAM, PAM e identity governance sono oggi componenti centrali delle architetture di sicurezza.

La seconda è Zero Trust. Il principio è semplice ma radicale: nessun utente o sistema è considerato affidabile a priori. Ogni accesso viene continuamente verificato in base a identità, dispositivo, contesto e comportamento.

La terza è telemetria e rilevazione delle minacce. Non basta prevenire gli attacchi. Si assume che una compromissione prima o poi avverrà. Per questo SIEM, XDR, UEBA e SOC monitorano costantemente i segnali di sicurezza.

La quarta è automazione e resilienza operativa. Gli ambienti IT sono troppo complessi per essere gestiti manualmente. SOAR, policy automation e security orchestration diventano necessari per reagire rapidamente agli incidenti.

Se si guarda l’architettura complessiva oggi, la sicurezza si può riassumere in cinque grandi pilastri operativi:

identità, dispositivi, rete, applicazioni, dati.

Curiosamente torniamo sempre allo stesso nucleo concettuale. Tutte le architetture moderne — dal NIST Zero Trust alle piattaforme cloud security — non fanno altro che espandere e raffinare le idee originali della CIA triad e del modello AAA.

Ad ogni modo, negli ultimi anni il modello è stato esteso. Una delle evoluzioni più usate negli ambienti architetturali moderni è CIA(NA-SP). La logica è semplice: mantenere la triade originaria ma aggiungere proprietà che riflettano meglio la realtà dei sistemi digitali contemporanei.

Il primo elemento aggiuntivo è Non-repudiation.
Significa che un soggetto non può negare di aver compiuto un’azione. È una proprietà fondamentale nei sistemi distribuiti e nei processi legali digitali. Le tecnologie chiave sono:

  • firme digitali
  • timestamping
  • log firmati
  • certificati PKI

Il secondo è Authenticity.
Autenticità significa che l’origine di dati, identità o software può essere verificata. Non è esattamente la stessa cosa dell’autenticazione dell’utente. Riguarda la provenienza dell’oggetto digitale: software firmato, firmware autenticato, supply chain software verificata.

Il terzo è Safety.
Safety è un concetto preso dall’ingegneria dei sistemi critici. Non riguarda solo attacchi informatici, ma il fatto che il sistema non produca danni anche se qualcosa va storto. In ambienti industriali, automotive o medicali questa proprietà è fondamentale. Significa progettare sistemi che falliscono in modo controllato.

Infine arrivano due proprietà molto moderne: Privacy e Security observability / provenance (SP).

Privacy è diventata una dimensione autonoma con normative come GDPR. Non basta proteggere i dati: bisogna gestirli secondo principi di minimizzazione, finalità e controllo dell’utente.

Provenance / observability riguarda la capacità di tracciare l’origine e il percorso dei dati e delle azioni. In un mondo di microservizi, supply chain software e AI pipeline, sapere da dove proviene qualcosa è diventato essenziale.

Se si guarda la struttura CIANA-SP nel suo insieme, emerge qualcosa di interessante: il modello si sposta dalla semplice protezione del dato verso la fiducia nei sistemi digitali.

In pratica:

  • CIA protegge il dato
  • CIANA-SP protegge l’ecosistema che genera e usa il dato

Questo cambiamento riflette tre trasformazioni profonde del settore.

La prima è la scomparsa del perimetro di rete. Con cloud e SaaS non esiste più un confine fisico. La sicurezza si sposta su identità, contesto e telemetria.

La seconda è la supply chain digitale. Oggi gran parte del software proviene da dipendenze esterne. L’autenticità e la provenienza del codice diventano cruciali.

La terza è la resilienza sistemica. Non si assume più che gli attacchi possano essere completamente prevenuti. Si progettano sistemi che continuano a funzionare anche sotto attacco.

Ora entra in gioco un’altra dimensione: il post-quantum computing.

Molti sistemi di sicurezza moderni si basano su crittografia asimmetrica: RSA, ECC, Diffie-Hellman. Questi algoritmi si basano su problemi matematici difficili per i computer classici, ma vulnerabili a un computer quantistico sufficientemente potente tramite l’algoritmo di Shor.

Questo impatta direttamente diversi elementi della CIANA-SP.

Confidentiality verrebbe compromessa se i sistemi di cifratura attuali diventassero decrittabili.

Integrity e Non-repudiation dipendono da firme digitali che potrebbero essere falsificate.

Authenticity dipende da PKI e certificati che usano le stesse primitive crittografiche.

Per questo il settore sta già lavorando sulla Post-Quantum Cryptography (PQC). Gli algoritmi candidati selezionati dal NIST — come Kyber e Dilithium — si basano su problemi matematici diversi, ad esempio i reticoli (lattice problems), che sono considerati resistenti agli attacchi quantistici.

Ma l’impatto non è solo crittografico. L’arrivo del quantum cambia anche il modo di pensare alla sicurezza architetturale.

Emergono nuovi modelli da considerare:

Il primo è crypto-agility.
I sistemi devono poter cambiare algoritmo crittografico rapidamente. Non si progetta più una PKI statica per vent’anni; si progettano architetture in grado di evolvere.

Il secondo è data longevity security.
Un attaccante può oggi registrare traffico cifrato e decifrarlo in futuro quando i computer quantistici saranno disponibili. Questo è il famoso problema harvest now, decrypt later. Per i dati sensibili a lungo termine bisogna già usare protezioni resistenti al quantum.

Il terzo è verifiable computing e trusted execution.
Con sistemi sempre più distribuiti cresce l’importanza di ambienti di esecuzione verificabili: TEE, confidential computing, attestazione hardware. Inoltre, in futuro quando i computer quantistici saranno disponibili sorgerà il problema Trust Now, Forge Later (TNFL) dove un attaccante potrà fasificare l’autenticità del dato.

Il quarto è identity resilience.
Se la crittografia delle identità viene compromessa, tutto il modello Zero Trust crolla. Per questo le architetture IAM devono diventare quantum-ready.

Guardando il quadro generale si vede un filo logico molto affascinante.

Negli anni ’70 la sicurezza informatica nasce per proteggere computer isolati.
Negli anni ’90 protegge reti e sistemi distribuiti.
Oggi protegge ecosistemi digitali globali.
Domani dovrà proteggere ecosistemi dove la capacità di calcolo stessa cambia paradigma.

La CIA triad non è quindi superata. È come la meccanica newtoniana: semplice, ma ancora utile. I modelli come CIANA-SP sono l’equivalente della relatività e della meccanica quantistica della sicurezza: servono quando il sistema diventa molto più grande, molto più interconnesso e molto più potente.

SSH tunneling/SOCKS

Ciao,

capita alle volte che sia necessario fare un accesso ad un software (es. RDP) da una rete dove non sia disponibile l’apertura di rete alla porta necessaria.

Un modo veloce per risolvere è quello di usare in socks o un tunneling usando una porta che sia disponibile.

A seguito un esempio di server SOCKS usando ssh:

ssh -D 1080 user@<IP Address or Domain of your Server>

Al prompt, definite la password per l’utente indicato e ..fino a quando la finestra resta aperta, avremo disponibile un server SOCKS operativo su localhost:1080.

Se invece volessimo fare un tunneling su una sola porta, basterà usare sempre ssh nel seguente modo:

ssh -L [localhost:]3389:remote.desktop.host:3389 ssh.server.reacheable

fino a quando la finestra resterà aperta, basterà fare un RDP su localhost per essere mandati via tunneling ssh verso ssh.server.reacheable per poi finire su remote.desktop.host

Ulteriori switch che potrebbero essere utili:

-C: compress data in the tunnel, save bandwidth
-q: quiet mode, don’t output anything locally
-N: do not execute remote commands, useful for just forwarding ports
-f: to fork it to a background command

Curve Ellittiche in pratica

Ciao,

di seguito un semplice esempio di come utilizzare le curve ellittiche tramite il classico strumento openssl e i nostri classici amici Alice e Bob.

Alice e Bob generano le proprie chiavi pubbliche e private ti tipo ellittico


Creazione Chiavi


Alice:

openssl genpkey -algorithm  X25519 -out alice_privkey.pem
openssl pkey -in alice_privkey.pem -pubout -out alice_pubkey.pem

Bob:

openssl genpkey -algorithm  X25519 -out bob_privkey.pem
openssl pkey -in bob_privkey.pem -pubout -out bob_pubkey.pem

Cifra


Alice:

Alice genera una chiave EC temporanea e ne deriva un segreto usando la chiave pubblica di Bob

openssl genpkey -algorithm X25519 -out temp_privkey.pem
openssl pkeyutl -derive -inkey temp_privkey.pem -peerkey bob_pubkey.pem | base64 -w0 > secret.txt

(Attenzione, openssl tratta i dati da console come stringhe. Per evitare problemi di 0x00 presenti nella chiave, la convertiamo in base64)

Alice cifra il file per Bob con il segreto ottenuto
openssl enc -aes-256-cbc -in Testo.txt -out Testo.txt.enc -pass file:secret.txt

Alice genera la parte pubblica della chiave temporanea dalla quale Bob otterrà il segreto

openssl ecparam -in temp_privkey.pem -pubout -out temp_pubkey.pem

Alice invia a Bob il file cifrato Testo.txt.enc e la chiave pubblica temp_pubkey.pem

Decifra


Bob:

Bob usa la sua chiave privata ” bob_privkey.pem ” e la chiave pubblica ricevuta ” temp_pubkey.pem ” per derivare il segreto

openssh pkeyutl -derive -inkey bob_privkey.pem -peerkey temp_pubkey.pem | base64 -w0 > secret.txt

Bob decifra il testo cifrato

openssl enc -d -aes-256-cbc -in Testo.txt.enc -out Testo.txt -pass file:secret.txt

STEAM install on CENTOS7

To install Steam on a barebone Centos7 follow the next console commands:

yum install glibc.i686 libstdc++.i686 libgcc.i686
iptables -I INPUT -p udp –dport 27016 -j ACCEPT
iptables -I INPUT -p tcp –dport 27016 -j ACCEPT
iptables -I INPUT -p udp –dport 7778 -j ACCEPT
iptables -I INPUT -p tcp –dport 7778 -j ACCEPT
iptables -I INPUT -p tcp –dport 32330 -j ACCEPT

useradd -m steam
su – steam

mkdir steamcmd
cd steamcmd
wget http://media.steampowered.com/installer/steamcmd_linux.tar.gz
tar -xvzf steamcmd_linux.tar.gz

./steamcmd.sh

 

XML/XSD Estensione

Ciao,
mi è capitato di dover realizzare degli schemi XSD che potessero permettere l’aggiunta dinamica di tag. Il caso specifico era un elenco di periferiche presenti in un server dove ogni dispositivo aveva il proprio tag e dentro esso aveva la proprie caratteristiche.

Per ottenere ciò è utilizzabile il tag <xs:any>.


Aggiunta di “Qualunque dato” senza alcun controllo se non sintattico che i tag (se presenti) siano correttamente aperti e chiusi


Schema:

<xs:schema xmlns:xs=”http://www.w3.org/2001/XMLSchema”>
<xs:element name=”computer”>
<xs:annotation>
<xs:documentation xml:lang=”it-IT”>Definizione di un computer</xs:documentation>
<xs:documentation xml:lang=”en-US”>Definition of a computer</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element name=”keyboard” />
<xs:element name=”mouse” />
<xs:element name=”monitor” />
<xs:any namespace=”##any” processContents=”lax” minOccurs=”0″ maxOccurs=”unbounded”/>
</xs:sequence>
</xs:complexType>
</xs:element>

Esempio:

<computer>
<keyboard>105 keys</keyboard>
<mouse>3 button</mouse>
<monitor>vga</monitor>
  <joystic>
     <mytag1>
        data1
        <mytag2 myattr=”asd”>
            myValue
        </mytag2>
     </mytag1>
  </joystic>
</computer>

 


Aggiunta di un estensione basata su uno schema esterno “senza alcun controllo” se non sintattico che i tag (se presenti) siano correttamente aperti e chiusi. Il controllo rispetto lo schema esterno deve essere fatto con una attività ulteriore separata.

Schema:

<xs:schema xmlns:xs=”http://www.w3.org/2001/XMLSchema”>
  <xs:complexType name=”myextraType”>
          <xs:sequence>
               <xs:any namespace=”##other” processContents=”lax” maxOccurs=”unbounded”/>
          </xs:sequence>
     </xs:complexType>
<xs:element name=”computer”>
<xs:annotation>
<xs:documentation xml:lang=”it-IT”>Definizione di un computer</xs:documentation>
<xs:documentation xml:lang=”en-US”>Definition of a computer</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element name=”keyboard” />
<xs:element name=”mouse” />
<xs:element name=”monitor” />
<xs:element name=”myextra” type=”myextraType” minOccurs=”0″ maxOccurs=”unbounded”/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

 

Esempio:

<computer>
<keyboard>105 keys</keyboard>
<mouse>3 button</mouse>
<monitor>vga</monitor>
  <myextra xmlns:myExt=”http://personal.site/myExtensions.xsd”>
     <myExt:joystick>
        data1
        <myExt:mytag2 myattr=”asd”>
            myValue
        </myExt:mytag2>
     </myExt:joistick>
  </myextra>
</computer>

C# Password TextBox

Ciao,

di seguito il codice C# per l’estensione del componente TextBox al fine di mitigare il problema dei “keyLogger”.

Il codice è funzionante anche se sicuramente prototipale.

Spero possa esservi utile.

(Codice presso GitHub: https://github.com/waltzie/CSharp-PasswordTextBox)

using System;
using System.ComponentModel;
using System.Linq;
using System.Windows.Forms;
namespace WaltZie.Windows.Forms
{

///
/// Estensione della casella TextBox per gestire le password in modo che non possano essere intercettate dai keylkoggers
///

// Problema con i caratteri [] gestiti da sendkey
// Problema con digitazione caratteri in contemporanea. Occorre reindirizzare OnKeyPress a thread sequenziali.

public class PasswordTextBox : System.Windows.Forms.TextBox
{
public static PasswordTextBox Instance = new PasswordTextBox();

private string junk = “”;
private uint _junkMax = 4;
private uint _junkMin = 2;
private byte _minchar = 32;
private byte _maxchar = 126;
private string _allowedchars=””;
private string _scramble;
private bool _obfuscate = false;

private static readonly Random random = new Random();
private static readonly object syncLock = new object();
private delegate string del(string s);

public PasswordTextBox() {
}

protected override void OnMouseDown(MouseEventArgs e)
{
if (String.IsNullOrEmpty(this.Text))
{
sendJunkChars();
}
base.OnMouseDown(e);
}

///
///
The AllowedChars represents characters allowed.

/// The AllowedChars gets/sets the value of the string field, _allowedchars.
///
[Category(“Extensions”), Browsable(true), Description(“String containig allowed chars”)]
public string AllowedChars
{
set
{
if ((value.Length) < 256) { this._allowedchars = value; this._scramble = new string(_allowedchars.ToCharArray().OrderBy(x => Guid.NewGuid()).ToArray());
}
}
get
{
return this._allowedchars;
}
}

///
///
The Obfuscate define if typed text must be obfuscate with shuffled allowd chars.

/// The Obfuscate gets/sets the value of the bool field, _obfuscate.
///
[Category(“Extensions”), Browsable(true), Description(“Obfuscate input data”)]
public bool Obfuscate
{
set
{
this._obfuscate = value;
if (this._obfuscate && _allowedchars == “”) this.AllowedChars = ” !\”#$%&'()*+-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~”;
}
get
{
return this._obfuscate;
}
}

///
///
The ClearText represents real typed test.

/// The ClearText gets the value of the de-obfuscated string field, Text.
/// Returns original de-obfuscated typed text.
///
[Category(“Extensions”), Browsable(true), Description(“Clear text”)]
public string ClearText
{
get
{
return deobfuscate(this.Text);
}
}

private bool IsAllowedChar(char c)
{
if (char.IsControl(c)) return false;
if (this._allowedchars.Length > 0)
{
if (this._allowedchars.Contains(c.ToString())) return true;
else return false;
}
else return true;
}

private string Randomchar()
{
return Convert.ToChar(random.Next(this._minchar, this._maxchar)).ToString();
}

private string junkGenerator()
{
string randomString = “”;
for (int i = 0; i < random.Next((int)this._junkMin, (int)this._junkMax); i++)
randomString += Randomchar();
return randomString;
}
private void sendJunkChars()
{
string outchar = “”;
lock (syncLock)
{
this.junk += junkGenerator();
for (int i = 0; i < this.junk.Length; i++)
if (“+^%~(){}”.Contains(this.junk[i])) outchar += “{” + this.junk[i] + “}”;
else outchar += this.junk[i].ToString();
this.Focus();
SendKeys.Send(outchar);
}
}

private char obfuscate(char s) {
lock (syncLock)
{
if (this._obfuscate) return this._scramble[this._allowedchars.IndexOf(s)];
else return s;
}
}
private string deobfuscate(string s) {
if (!this._obfuscate) return s;
string outstr = “”;
for (int i=0; i<this.Text.Length;i++) { outstr += this._allowedchars[this._scramble.IndexOf(this.Text[i])].ToString(); } return outstr; } protected override bool ProcessCmdKey(ref Message msg, Keys keyData) { if (this.junk.Length == 0) { if (keyData == Keys.Delete) OnKeyPress(new KeyPressEventArgs((Char)Keys.Back)); } return base.ProcessCmdKey(ref msg, keyData); } protected override void OnKeyPress(KeyPressEventArgs e) { // Controllare this.SelectedText base.OnKeyPress(e); string keyInput = e.KeyChar.ToString(); if (this.junk.Length > 0)
{
//this char is junk
e.Handled = true;
lock(syncLock) this.junk = this.junk.Remove(this.junk.Length – 1);
}
else if (IsAllowedChar(e.KeyChar))
{
e.KeyChar = obfuscate(e.KeyChar);
sendJunkChars();
}
else if (e.KeyChar == ‘\b’)
{
try
{
// Backspace key is OK
sendJunkChars();
}
catch { e.Handled = true; }
}
else
{
// Consume this invalid key and beep
e.Handled = true;
System.Media.SystemSounds.Exclamation.Play();
}
}
}
}

DoD 8570 compliance

Ogni tanto, nelle varie offerte di lavoro, si vede fra i requisiti la richiesta “8570 compliance”.

Non si tratta di una certificazione in sè, ma si tratta di aver raggiunt un set minimo di certificazioni particolari.

8570-cert

Verificate se avete tali certificazioni e nel caso, potrete aggiungere al vostro curriculum il blasone “DoD 8570 compliance“.

Quale wiki fà per te?

Per l’organizzazione dei dati lavorativi personali e non, è comune riempire il proprio spazio disco di cartelle e file. Questo metodo sebbene rapido, non è di facile gestione, soprattutto nella ricerca e catalogazione delle informazioni. Senza parlare poi dei semilavorati come le le bozze. Inoltre, resta sempre perenne il rischio di rottura dei supporti che richiederebbe un sistema di gestione dei backup e degli allineamenti.

Questo ha portato l’evoluzione dei CMS (Content Management Systems) in particolar modo di quelli basati sul famoso WiKi in tantissime varianti.

Nel caso in cui foste interessati a trovare il CMS stile WiKi che fà per voi, vi suggerisco di dare un’occhiata al seguente sito che permette tramite una funzione di ricerca di identificare i tools che rispondano alle vostre esigenze.

http://www.wikimatrix.org/

CISSP – Certified Information Systems Security Professional

Ciao,

sicuramente fra le varie certificzioni di sicurezza, quella più ambita ed apprezzata internazionalmente è la CISSP.

E’ una certificazione molto ricercata che copre in modo approfondito e vasto il mondo dell’IT security. E’ difficile da ottenere in quanto richiede una esperienza comprovata di 5 anni in almeno 2 dei 10 domini che la certificazione copre.

Ad ogni modo … se volete prepararvi a sostenerla … vi consiglio il seguente sito  OPEN SECURITY TRAINING.

Buono studio!