From 975093af371fd755cbc84576782b1aafd2f12dd2 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 11 Feb 2025 22:44:39 +0100 Subject: [PATCH 01/49] added image used in database.xml --- security/figures/xkcd-bobby-tables.png | Bin 0 -> 31908 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 security/figures/xkcd-bobby-tables.png diff --git a/security/figures/xkcd-bobby-tables.png b/security/figures/xkcd-bobby-tables.png new file mode 100644 index 0000000000000000000000000000000000000000..530ddc0473ec44d032181c4b8b13a93caa738c6d GIT binary patch literal 31908 zcmV)ZK&!urP)004R=004l4008;_004mL004C`008P>0026e000+nl3&F}00009 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 literal 0 HcmV?d00001 From 0b36111b92f1feae70f37f32df1156fca273da07 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 11 Feb 2025 23:59:55 +0100 Subject: [PATCH 02/49] added cgi-bin.xml --- security/cgi-bin.xml | 243 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 243 insertions(+) create mode 100644 security/cgi-bin.xml diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml new file mode 100644 index 000000000..f20e28c26 --- /dev/null +++ b/security/cgi-bin.xml @@ -0,0 +1,243 @@ + + + + + + PHP installato come binario CGI + + + Possibili attacchi + + L'utilizzo di PHP come binario CGI è un'opzione che ne permette l'uso se per qualche + motivo non lo si voglia integrare come modulo del server (come Apache) + sia per utilizzarlo con diversi tipi di wrapper CGI che per creare + con chroot e setuid ambienti + sicuri per gli script. Questa configurazione di solito prevede l'installazione + del'eseguibile php nella directory del server web + cgi-bin. + L'informativa CERT CA-96.11 sconsiglia + di posizionare interpreti in cgi-bin. + Invece il binario php può essere utilizzato in modo autonomo, + PHP è progettato per prevenire gli attacchi possibili in questa configurazione: + + + + + Accesso al file system: http://my.host/cgi-bin/php?/etc/passwd + + + Le informazioni di una query ovvero la parte dell'URL dopo il punto interrogativo (?) vengono + passate come argomenti dalla riga di comando dall'interfaccia CGI all'interprete. + Di solito gli interpreti aprono ed eseguono il file + specificato specificato nel primo argomento della riga di comando. + + + Quando PHP viene invocato come binario CGI, php non interpreta + gli argomenti della riga di comando. + + + + + Accesso a qualsiasi documento web sul server:http://my.host/cgi-bin/php/secret/doc.html + + + Le informazioni sull'URL dopo il nome del binario PHP, + /secret/doc.html sono + convenzionalmente usate per specificare il nome dello script da + aprire e interpretare dal programma CGI. + Solitamente alcune direttive nella configurazione del server web (Apache: + Action) sono usate per reindirizzare le richieste di documenti come + http://my.host/secret/script.php all'interprete PHP. Con questa configurazione, + il server web prima controlla i permessi di accesso alla directory /secret, e poi crea la richiesta che viene reindirizzata a http://my.host/cgi-bin/php/secret/script.php. + Purtroppo, se la richiesta è fatta originariamente in questo modo, + il server web non esegue alcun controllo di accesso al file /secret/script.php, ma solo per il file + /cgi-bin/php. In questo modo + qualsiasi utente che è in grado di accedere a /cgi-bin/php è in grado di accedere a qualsiasi + documento protetto sul server web. + + + In PHP, le direttive di configurazione a runtime cgi.force_redirect, doc_root e user_dir possono essere utilizzate per prevenire + questo tipo di attacco, se la struttura dei documenti del server ha directory + con restrizioni di accesso. Vedere qui di seguito per un completo chiarimento + delle diverse combinazioni. + + + + + + + 1º Caso :solo files publici elaborati + + + Se il tuo server non ha alcun contenuto e non è protetto + da password o un controllo d'accesso basato su IP, non c'è bisogno di + questa configurazione. Se il tuo server web non ti consente + di effettuare reindirizzamenti, o non hai un modo per + comunicare all'eseguibile di PHP che la richiesta è una richiesta reindirizzata in modo sicuro, puoi abilitare la + direttiva cgi.force_redirect.ini. + Devi comunque assicurarti che i tuoi script PHP + non usino nè un modo ne l'altro modo di chiamare lo script, + né direttamente http://my.host/cgi-bin/php/dir/script.php + né tramite reindirizzamento http://my.host/dir/script.php. + + + Il reindirizzamento può essere configurato in Apache utilizzando AddHandler e la direttiva + Action (vedi sotto). + + + + + 2º Caso : utilizzo di <literal>cgi.force_redirect</literal> + + La configurazione della direttiva cgi.force_redirect + impedisce a chiunque di chiamare direttamente php + tramite URL http://my.host/cgi-bin/php/secretdir/script.php. + Invece, PHP funzionerà in questa modalità solo se la richiesta viene fatta + passare attraverso le regole di reindirizzamento del server web. + + + Solitamente il reindirizzamento nella configurazione di Apache + viene eseguito con le seguenti direttive: + + + + + + Questa opzione è stata testata solo con il server web Apache + e si basa su Apache per impostare la variabile di ambiente + CGI non standard REDIRECT_STATUS sulle richieste + reindirizzate. Se il server web non supporta alcun modo per + stabilire se la richiesta è diretta o reindirizzata, non è + possibile utilizzare questa opzione e si deve utilizzare uno + degli altri modi per eseguire la versione CGI documentata + qui. + + + + + 3º: impostare doc_root o user_dir + + Includere contenuti attivi, come script ed eseguibili, nelle + directory dei documenti del server Web è talvolta considerato + una pratica non sicura. Se, a causa di un errore di configurazione, + gli script non vengono eseguiti ma visualizzati come normali documenti HTML, + ciò può causare la perdita di proprietà intellettuale o far visualizare informazioni di + sicurezza come le password. Pertanto, molti amministratori di sistema + preferiranno impostare un'altra struttura di directory per gli script + accessibili solo tramite PHP CGI e quindi saranno sempre interpretati e + non visualizzati come tali. + + + Inoltre, se il metodo per verificare che le richieste non vengano + reindirizzate, come descritto nella sezione precedente, non è disponibile, + è necessario impostare il doc_root degli script + diverso dalla radice dei documenti Web. + + + Puoi impostare la directory per gli script di PHP tramite la direttiva di configurazione + doc_root nel + file di configurazione, oppure + puoi impostare la variabile d'ambiente + PHP_DOCUMENT_ROOT. Se è stata configurata, la versione CGI + di PHP eseguirà sempre il file che si trova in + doc_root con le informazioni sul percorso URL, così puoi essere sicuro + che nessuno script venga eseguito al di fuori di questa + directory (tranne per user_dir + di seguito). + + + Un'altra opzione utilizzabile è user_dir. Quando user_dir non è + impostato, l'unica cosa che controlla nel file aperto è + doc_root. L'apertura di un URL come http://my.host/~user/doc.php non + comporta l'apertura di un file nella directory home dell'utente, ma di un file + chiamato ~user/doc.php in + doc_root (esatto, il nome della directory inizia con una tilde + [~]). + + + Se la user_dir è impostata, ad esempio, su public_php, una richiesta come http://my.host/~user/doc.php aprirà un file + file chiamato doc.php nella directory + denominata public_php sotto la home + directory dell'utente. Se la home dell'utente è /home/user, il file eseguito è + /home/user/public_php/doc.php. + + + L'espansione user_dir avviene indipendentemente + dall'impostazione doc_root, in modo da poter controllare + la radice del documento e l'accesso alla directory dell'utente + separatamente. + + + + + 4º Caso: script PHP fuori dalla cartella web + + Un'opzione molto sicura è mettere il binario del parser PHP da qualche parte + al di fuori dell'cartella web dei file. In /usr/local/bin, per esempio. L'unico vero + lo svantaggio di questa opzione è che ora dovrai inserire una riga + simile a: + + + + + + come prima riga di qualsiasi file PHP deve contenere il tag. Avrai anche bisogno di + rendere il file eseguibile. Dovrai fare esattamente come + tratteresti qualsiasi altro script CGI script in Perl o sh o un'altro + altro comune linguaggio di scripting che utilizza l'escape + #! come meccanismo per avviarsi. + + + Per far sì che PHP gestisca correttamente le informazioni PATH_INFO e + PATH_TRANSLATED in modo corretto con questa configurazione, è necessario + abilitare la direttiva cgi.discard_path. + + + + + + From 68dfc24eac047458051459ff847f11f98ae26b5c Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 12 Feb 2025 15:52:50 +0100 Subject: [PATCH 03/49] fix typo errors.xml --- security/errors.xml | 149 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 security/errors.xml diff --git a/security/errors.xml b/security/errors.xml new file mode 100644 index 000000000..7400b12c7 --- /dev/null +++ b/security/errors.xml @@ -0,0 +1,149 @@ + + + + + + + Segnalazione errori + + Con la sicurezza di PHP, ci sono due aspetti nella segnalazione degli errori. Uno è + utile per aumentarene la sicurezza, l’altro è dannoso. + + + Una tattica d'attacco di solito prevede la profilazione di un sistema reperendo + dati dagli errori, dal controllo dei tipi e dai contesti degli + errori che vengono restituiti. Ciò consente al cracker del sistema di sondare + le informazioni del server, per determinare possibili punti deboli. + Ad esempio, se un'utente malintenzionato avesse raccolto informazioni su una pagina + con l'invio di un modulo precedente, potrebbe tentare di sovrascrivere le + variabili o modificarle: + + Variabili d'attacco in una pagina HTML personalizzata + + + + + +]]> + + + + + Gli errori che vengono normalmente restituiti da PHP possono essere molto utili allo + sviluppatore che sta tentando di eseguire il debug di uno script, indicando quali + funzioni o file hanno avuto esito negativo, il file PHP + e il numero di riga in cui si è verificato l'errore. Queste sono tutte le + informazioni che possono essere usate. Non è raro che in php + lo sviluppatore debba utilizzare show_source, + evidenzia_stringa, o + highlight_file come strumento di debug, ma in + un sito live, questo può esporre informazioni di solito nascoste, sintassi non controllata, + e altre informazioni pericolose. Particolarmente pericoloso è far eseguire + codice da fonti conosciute con gestori di debug incorporati o utilizzando + tecniche comuni di debug. Se l'attaccante può determinare quale + tecnica conosciuta stai usando, potrebbero provare a forzare una pagina, + inviando varie stringhe di debug usate da queste tecniche: + + Sfruttare le variabili di debug classiche + + + + + + +]]> + + + + + Indipendentemente dal metodo di gestione degli errori, la capacità di sondare un + sistema tramite gli errori porta a fornire ad un'utente malintenzionato + più informazioni. + + + Ad esempio, lo stile stesso di un errore PHP generico indica che un sistema + sta eseguendo PHP. Se l'aggressore stava guardando una pagina .html e + volevo sondare il back-end (per cercare punti deboli noti nel + sistema), fornendo dati errati che potrebbero essere in grado di + determinare che un sistema è stato creato con PHP. + + + L'errore di una funzione può indicare se un sistema sta eseguendo uno + specifico database engine o fornire indizi su come una specifica pagina web, è + programmata o progettata. Ciò consente un'indagine più approfondita per + aprire porte del database o cercare bug o punti deboli specifici + di una pagina web. Fornendo diversi dati errati, per esempio, + un utente malintenzionato può determinare l'ordine di autenticazione in uno script, + (dagli errori con il numero di riga) e sondare gli exploit che + possono essere sfruttati in diversi casi nello script. + + + Un errore di filesystem o un'errore generale di PHP può indicare quali autorizzazioni + ha il server web, nonché la struttura e l'organizzazione dei + file sul server web. Il codice di errore scritto dallo sviluppatore può aggravare + questo problema, portando ad un facile reperimento delle informazione da parte + di risorse precedentemente "nascoste". + + + Esistono tre soluzioni principali a questo problema. Il primo è quello + esaminare attentamente tutte le funzioni e tentare di risolvere la maggior parte + degli errori. Il secondo è disabilitare completamente la segnalazione degli errori + nel codice di produzione. Il terzo consiste nell'utilizzare la funzione custom + della gestione degli errori di PHP per creare il proprio gestore di errori. A seconda + sulla tua politica di sicurezza, potresti riuscire ad applicare tutte e tre + le soluzioni alla tua situazione. + + + Un modo per impedire questo problema in anticipo è quello di utilizzare + error_reporting di PHP, per aiutarti a + proteggere il tuo codice e trovare vari utilizzi che potrebbero essere pericolosi. + Testando il tuo codice, prima della distribuzione, con E_ALL, + puoi trovare rapidamente le aree in cui le tue variabili potrebbero essere + esposte all'inquinamento o alla modifica. Una volta pronto per la distribuzione, + dovresti disabilitare completamente la segnalazione degli errori impostando + error_reporting su 0 o disattivare l'opzione di visualizzazione + dell'errore nel file &php.ini; display_errors, + per isolare il codice dall'analisi(). Se scegli di applicare quest'ultima soluzione, + dovresti anche definire il percorso al tuo file registro usando il file + error_log e attivare nella direttiva ini + log_errors. + + Trovare variabili pericolose con E_ALL + + +]]> + + + + + + From 2f717c3f402657b7d727271bfe866a02d6b4ea28 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 12 Feb 2025 17:38:28 +0100 Subject: [PATCH 04/49] added securyty/errors.xml --- security/errors.xml | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/security/errors.xml b/security/errors.xml index 7400b12c7..d25a45259 100644 --- a/security/errors.xml +++ b/security/errors.xml @@ -3,22 +3,23 @@ + - Segnalazione errori + Segnalazione degli errori - Con la sicurezza di PHP, ci sono due aspetti nella segnalazione degli errori. Uno è + Dal punto di vista della sicurezza di PHP, ci sono due aspetti nella segnalazione degli errori. Uno è utile per aumentarene la sicurezza, l’altro è dannoso. Una tattica d'attacco di solito prevede la profilazione di un sistema reperendo dati dagli errori, dal controllo dei tipi e dai contesti degli - errori che vengono restituiti. Ciò consente al cracker del sistema di sondare + errori che vengono restituiti. Ciò consente al cracker del sistema di analizzare le informazioni del server, per determinare possibili punti deboli. Ad esempio, se un'utente malintenzionato avesse raccolto informazioni su una pagina con l'invio di un modulo precedente, potrebbe tentare di sovrascrivere le variabili o modificarle: - Variabili d'attacco in una pagina HTML personalizzata + Attaccare le Variabili in una pagina HTML personalizzata @@ -34,11 +35,11 @@ sviluppatore che sta tentando di eseguire il debug di uno script, indicando quali funzioni o file hanno avuto esito negativo, il file PHP e il numero di riga in cui si è verificato l'errore. Queste sono tutte le - informazioni che possono essere usate. Non è raro che in php + informazioni che possono essere visualizzate. Non è raro che in php lo sviluppatore debba utilizzare show_source, evidenzia_stringa, o highlight_file come strumento di debug, ma in - un sito live, questo può esporre informazioni di solito nascoste, sintassi non controllata, + un sito live, questo può esporre le variabili nascoste, sintassi non controllate, e altre informazioni pericolose. Particolarmente pericoloso è far eseguire codice da fonti conosciute con gestori di debug incorporati o utilizzando tecniche comuni di debug. Se l'attaccante può determinare quale @@ -63,7 +64,7 @@ più informazioni. - Ad esempio, lo stile stesso di un errore PHP generico indica che un sistema + Ad esempio, lo stile di un errore PHP generico indica che un sistema sta eseguendo PHP. Se l'aggressore stava guardando una pagina .html e volevo sondare il back-end (per cercare punti deboli noti nel sistema), fornendo dati errati che potrebbero essere in grado di @@ -76,14 +77,14 @@ aprire porte del database o cercare bug o punti deboli specifici di una pagina web. Fornendo diversi dati errati, per esempio, un utente malintenzionato può determinare l'ordine di autenticazione in uno script, - (dagli errori con il numero di riga) e sondare gli exploit che - possono essere sfruttati in diversi casi nello script. + (dagli errori con il numero di riga) e cercare i vari exploit che + possono essere sfruttati nello script. Un errore di filesystem o un'errore generale di PHP può indicare quali autorizzazioni - ha il server web, nonché la struttura e l'organizzazione dei + il server web ha, nonché la struttura e l'organizzazione dei file sul server web. Il codice di errore scritto dallo sviluppatore può aggravare - questo problema, portando ad un facile reperimento delle informazione da parte + questo problema, portando ad un facile reperimento delle informazioni di risorse precedentemente "nascoste". @@ -96,8 +97,8 @@ le soluzioni alla tua situazione. - Un modo per impedire questo problema in anticipo è quello di utilizzare - error_reporting di PHP, per aiutarti a + Un modo per impedire in anticipo questo problema è quello di utilizzare + error_reporting di PHP, può aiutarti a proteggere il tuo codice e trovare vari utilizzi che potrebbero essere pericolosi. Testando il tuo codice, prima della distribuzione, con E_ALL, puoi trovare rapidamente le aree in cui le tue variabili potrebbero essere From 2a5785318c4d253c0739d2086a1237e86b9c2ac0 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 12 Feb 2025 19:56:42 +0100 Subject: [PATCH 05/49] added security/database.xml file to be finished --- security/database.xml | 490 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 security/database.xml diff --git a/security/database.xml b/security/database.xml new file mode 100644 index 000000000..92dbe678e --- /dev/null +++ b/security/database.xml @@ -0,0 +1,490 @@ + + + + + Sicurezza del Database + + + Al giorno d'oggi, i database sono componenti essenziali di qualsiasi + applicazione basata sul Web, consentendo ai siti Web di fornire vari contenuti + dinamici. Poiché anche le informazioni molto sensibili o segrete possono + essere archiviate in un database, dovresti considerare seriamente di + protegere i tuoi database. + + + Per recuperare o archiviare qualsiasi informazione di cui hai bisogno per connetterti al database, + inviare una query legittima, recuperare il risultato e quindi chiudere la connessione. + Oggigiorno, il linguaggio di query comunemente utilizzato per questo tipo di interazione è + l'SQL (Structured Query Language). Guarda come un aggressore può manomettere una query SQL. + + + Come puoi immaginare, PHP non può proteggere il database da solo. + Le prossime sezioni mirano a essere un'introduzione di come + accedere e manipolare ai database all'interno di uno script PHP. + + + Keep in mind this simple rule: defense in depth. The more places you + take action to increase the protection of your database, the less + probability of an attacker succeeding in exposing or abusing any stored + information. Good design of the database schema and the application + deals with your greatest fears. + + + + Designing Databases + + The first step is always to create the database, unless you want to use + one from a third party. When a database is created, it is + assigned to an owner, who executed the creation statement. Usually, only + the owner (or a superuser) can do anything with the objects in that + database, and in order to allow other users to use it, privileges must be + granted. + + + Applications should never connect to the database as its owner or a + superuser, because these users can execute any query at will, for + example, modifying the schema (e.g. dropping tables) or deleting its + entire content. + + + You may create different database users for every aspect of your + application with very limited rights to database objects. The most + required privileges should be granted only, and avoid that the same user + can interact with the database in different use cases. This means that if + intruders gain access to your database using your applications credentials, + they can only effect as many changes as your application can. + + + + + Connecting to Database + + You may want to establish the connections over SSL to encrypt + client/server communications for increased security, or you can use ssh + to encrypt the network connection between clients and the database server. + If either of these is used, then monitoring your traffic and gaining + information about your database will be difficult for a would-be attacker. + + + + + + Encrypted Storage Model + + SSL/SSH protects data travelling from the client to the server: SSL/SSH + does not protect persistent data stored in a database. SSL is an + on-the-wire protocol. + + + Once an attacker gains access to your database directly (bypassing the + webserver), stored sensitive data may be exposed or misused, unless + the information is protected by the database itself. Encrypting the data + is a good way to mitigate this threat, but very few databases offer this + type of data encryption. + + + The easiest way to work around this problem is to first create your own + encryption package, and then use it from within your PHP scripts. PHP + can assist you in this with several extensions, such as OpenSSL and Sodium, covering a wide variety of encryption + algorithms. The script encrypts the data before inserting it into the database, and decrypts + it when retrieving. See the references for further examples of how + encryption works. + + + + Hashing + + In the case of truly hidden data, if its raw representation is not needed + (i.e. will not be displayed), hashing should be taken into consideration. + The well-known example for hashing is storing the cryptographic hash of a + password in a database, instead of the password itself. + + + The password functions + provide a convenient way to hash sensitive data and work with these hashes. + + + password_hash is used to hash a given string using the + strongest algorithm currently available and password_verify + checks whether the given password matches the hash stored in database. + + + Hashing password field + + +]]> + + + + + + + SQL Injection + + SQL injection is a technique where an attacker exploits flaws in + application code responsible for building dynamic SQL queries. + The attacker can gain access to privileged sections of the application, + retrieve all information from the database, tamper with existing data, + or even execute dangerous system-level commands on the database + host. The vulnerability occurs when developers concatenate or + interpolate arbitrary input in their SQL statements. + + + + + Splitting the result set into pages ... and making superusers + (PostgreSQL) + + + In the following example, user input is directly interpolated into the + SQL query allowing the attacker to gain a superuser account in the database. + + + +]]> + + + Normal users click on the 'next', 'prev' links where the $offset + is encoded into the URL. The script expects that the incoming + $offset is a number. However, what if someone tries to + break in by appending the following to the URL + + + + + + If it happened, the script would present a superuser access to the attacker. + Note that 0; is to supply a valid offset to the + original query and to terminate it. + + + + It is a common technique to force the SQL parser to ignore the rest of the + query written by the developer with -- which is the + comment sign in SQL. + + + + A feasible way to gain passwords is to circumvent your search result pages. + The only thing the attacker needs to do is to see if there are any submitted variables + used in SQL statements which are not handled properly. These filters can be set + commonly in a preceding form to customize WHERE, ORDER BY, + LIMIT and OFFSET clauses in SELECT + statements. If your database supports the UNION construct, + the attacker may try to append an entire query to the original one to list + passwords from an arbitrary table. It is strongly recommended to store only + secure hashes of passwords instead of the passwords themselves. + + + Listing out articles ... and some passwords (any database server) + + + +]]> + + + The static part of the query can be combined with another + SELECT statement which reveals all passwords: + + + + + + + + UPDATE and INSERT statements are also + susceptible to such attacks. + + + From resetting a password ... to gaining more privileges (any database server) + + + +]]> + + + If a malicious user submits the value + ' or uid like'%admin% to $uid to + change the admin's password, or simply sets $pwd to + hehehe', trusted=100, admin='yes to gain more + privileges, then the query will be twisted: + + + +]]> + + + + + While it remains obvious that an attacker must possess at least some + knowledge of the database architecture to conduct a successful + attack, obtaining this information is often very simple. For example, + the code may be part of an open-source software and be publicly available. + This information may also be divulged + by closed-source code - even if it's encoded, obfuscated, or compiled - + and even by your own code through the display of error messages. + Other methods include the use of typical table and column names. For + example, a login form that uses a 'users' table with column names + 'id', 'username', and 'password'. + + + + Attacking the database host operating system (MSSQL Server) + + A frightening example of how operating system-level commands can be + accessed on some database hosts. + + + +]]> + + + If attacker submits the value + a%' exec master..xp_cmdshell 'net user test testpass /ADD' -- + to $prod, then the $query will be: + + + +]]> + + + MSSQL Server executes the SQL statements in the batch including a command + to add a new user to the local accounts database. If this application + were running as sa and the MSSQLSERVER service was + running with sufficient privileges, the attacker would now have an + account with which to access this machine. + + + + Some examples above are tied to a specific database server, but it + does not mean that a similar attack is impossible against other products. + Your database server may be similarly vulnerable in another manner. + + + + + A funny example of the issues regarding SQL injection + + + + + + Image courtesy of xkcd + + + + + + + Avoidance Techniques + + The recommended way to avoid SQL injection is by binding all data via + prepared statements. Using parameterized queries isn't enough to entirely + avoid SQL injection, but it is the easiest and safest way to provide input + to SQL statements. All dynamic data literals in WHERE, + SET, and VALUES clauses must be + replaced with placeholders. The actual data will be bound during the + execution and sent separately from the SQL command. + + + Parameter binding can only be used for data. Other dynamic parts of the + SQL query must be filtered against a known list of allowed values. + + + + Avoiding SQL injection by using PDO prepared statements + +prepare("SELECT * FROM products WHERE id LIKE ? ORDER BY price {$sortingOrder}"); +// The value is provided with LIKE wildcards +$stmt->execute(["%{$productId}%"]); + +?> +]]> + + + + + + Prepared statements are provided + by PDO, + by MySQLi, + and by other database libraries. + + + + SQL injection attacks are mainly based on exploiting the code not being written + with security in mind. Never trust any input, especially + from the client side, even though it comes from a select box, + a hidden input field, or a cookie. The first example shows that such a + simple query can cause disasters. + + + + A defense-in-depth strategy involves several good coding practices: + + + + Never connect to the database as a superuser or as the database owner. + Use always customized users with minimal privileges. + + + + + Check if the given input has the expected data type. PHP has + a wide range of input validating functions, from the simplest ones + found in Variable Functions and + in Character Type Functions + (e.g. is_numeric, ctype_digit + respectively) and onwards to the + Perl Compatible Regular Expressions + support. + + + + + If the application expects numerical input, consider verifying data + with ctype_digit, silently change its type + using settype, or use its numeric representation + by sprintf. + + + + + If the database layer doesn't support binding variables then + quote each non-numeric user-supplied value that is passed to the + database with the database-specific string escape function (e.g. + mysql_real_escape_string, + sqlite_escape_string, etc.). + Generic functions like addslashes are useful only + in a very specific environment (e.g. MySQL in a single-byte character + set with disabled NO_BACKSLASH_ESCAPES), so it is + better to avoid them. + + + + + Do not print out any database-specific information, especially + about the schema, by fair means or foul. See also Error Reporting and Error Handling and Logging Functions. + + + + + + + Besides these, you benefit from logging queries either within your script + or by the database itself, if it supports logging. Obviously, the logging is unable + to prevent any harmful attempt, but it can be helpful to trace back which + application has been circumvented. The log is not useful by itself but + through the information it contains. More detail is generally better than less. + + + + + + From fa642be8f80a690e98b8466f49ed953bc0f29a5b Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 13 Feb 2025 18:26:44 +0100 Subject: [PATCH 06/49] database.xml changes in progress --- security/database.xml | 50 +++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/security/database.xml b/security/database.xml index 92dbe678e..7622072ff 100644 --- a/security/database.xml +++ b/security/database.xml @@ -23,41 +23,39 @@ Le prossime sezioni mirano a essere un'introduzione di come accedere e manipolare ai database all'interno di uno script PHP. - - Keep in mind this simple rule: defense in depth. The more places you - take action to increase the protection of your database, the less - probability of an attacker succeeding in exposing or abusing any stored - information. Good design of the database schema and the application - deals with your greatest fears. + + Tieni presente questa semplice regola: difesa in profondità. Più prendi provvedimenti + per aumentare la protezione del database, minore è probabilità che un utente malintenzionato + riesca a esporre o abusare di eventuali dati archiviati. Una buona progettazione + dello schema del database e dell'applicazione previene le tue più grandi paure. - - Designing Databases + + Proggetazione del database - Designing Databases - The first step is always to create the database, unless you want to use - one from a third party. When a database is created, it is - assigned to an owner, who executed the creation statement. Usually, only - the owner (or a superuser) can do anything with the objects in that - database, and in order to allow other users to use it, privileges must be - granted. + Il primo passo è quello di creare il database, a meno che non si voglia utilizzarne uno + di terze parti. Quando il database è stato creato, gli viene assegnato a un proprietario, + che ha eseguito l'istruzione di creazione. Di solito, solo il proprietario + (o un superuser) può fare qualsiasi cosa con gli oggetti in quel database e, + per consentire ad altri utenti di utilizzarlo, devono essere concessi dei privilegi. - Applications should never connect to the database as its owner or a - superuser, because these users can execute any query at will, for - example, modifying the schema (e.g. dropping tables) or deleting its - entire content. + Le applicazioni non dovrebbero mai connettersi al database come proprietario o + superutente, perché questi utenti possono eseguire qualsiasi query a piacimento, + ad esempio, modificando lo schema (ad esempio eliminando tabelle) o eliminandone + l'intero contenuto. - You may create different database users for every aspect of your - application with very limited rights to database objects. The most - required privileges should be granted only, and avoid that the same user - can interact with the database in different use cases. This means that if - intruders gain access to your database using your applications credentials, - they can only effect as many changes as your application can. + Puoi creare vari utenti del database uno per ogni funzionalità della tua applicazione + con diritti molto limitati sugli oggetti del database. Dovrebbero essere concessi + solo i privilegi necessari per evitare che lo stesso utente possa modificare + il database tramite le diverse funzionalità. Ciò significa che se gli intrusi ottengono + l'accesso al tuo database utilizzando le credenziali delle tue applicazioni, + possono apportare tante modifiche quante ne possono apportare i tuoi privilegi. - + - + Connecting to Database You may want to establish the connections over SSL to encrypt From 63da224f75934271634e4c23d6419c96d05ef6a5 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 14 Feb 2025 01:02:28 +0100 Subject: [PATCH 07/49] update --- security/database.xml | 95 +++++++++++++++++++++++-------------------- 1 file changed, 52 insertions(+), 43 deletions(-) diff --git a/security/database.xml b/security/database.xml index 7622072ff..58bebc52f 100644 --- a/security/database.xml +++ b/security/database.xml @@ -31,7 +31,7 @@ - Proggetazione del database - Designing Databases + Progetazione del database Il primo passo è quello di creare il database, a meno che non si voglia utilizzarne uno di terze parti. Quando il database è stato creato, gli viene assegnato a un proprietario, @@ -52,68 +52,69 @@ il database tramite le diverse funzionalità. Ciò significa che se gli intrusi ottengono l'accesso al tuo database utilizzando le credenziali delle tue applicazioni, possono apportare tante modifiche quante ne possono apportare i tuoi privilegi. - - + + - - Connecting to Database + + Connessione al database + + Potresti voler stabilire connessioni SSL per crittografare le + comunicazioni client/server per una maggiore sicurezza oppure è possibile utilizzare ssh + per crittografare la connessione di rete tra i client e il server del database. + Se viene utilizzato uno di questi, monitorare il traffico e ottenere + le informazioni sul tuo database saranno difficili da parte di un potenziale utente malintenzionato. + - You may want to establish the connections over SSL to encrypt - client/server communications for increased security, or you can use ssh - to encrypt the network connection between clients and the database server. - If either of these is used, then monitoring your traffic and gaining - information about your database will be difficult for a would-be attacker. + Se il tuo server database ha il supporto SSL nativo, considera l'utilizzo di Funzioni OpenSSL nella comunicazione tra + PHP e database tramite SSL. - - Encrypted Storage Model + Modello d'archiviazione crittografato - Encrypted Storage Model - SSL/SSH protects data travelling from the client to the server: SSL/SSH - does not protect persistent data stored in a database. SSL is an - on-the-wire protocol. + SSL/SSH protegge i dati che viaggiano dal client al server: SSL/SSH + non protegge i dati persistenti archiviati in un database. SSL è un + protocollo on-the-wire. - Once an attacker gains access to your database directly (bypassing the - webserver), stored sensitive data may be exposed or misused, unless - the information is protected by the database itself. Encrypting the data - is a good way to mitigate this threat, but very few databases offer this - type of data encryption. + Una volta che un utente malintenzionato ottiene l'accesso diretto al tuo database (aggirando il server web), + i dati sensibili memorizzati potrebbero essere esposti o utilizzati in modo improprio, a meno che + le informazioni siano protette dal database stesso. La crittografia dei dati + è un buon modo per limitare questa minaccia, ma pochissimi database offrono + questo tipo di crittografia dei dati. - The easiest way to work around this problem is to first create your own - encryption package, and then use it from within your PHP scripts. PHP - can assist you in this with several extensions, such as OpenSSL and Sodium, covering a wide variety of encryption - algorithms. The script encrypts the data before inserting it into the database, and decrypts - it when retrieving. See the references for further examples of how - encryption works. + Il modo più semplice per aggirare questo problema è crearne prima uno tuo + pacchetto di crittografia e quindi utilizzarlo dai nei tuoi script PHP. PHP + può aiutarti in questo con diverse estensioni, come OpenSSL e Sodium, che copre un'ampia varietà di algoritmi di crittografia. + Lo script cripta i dati prima di inserirli nel database e li decripta + durante il recupero. Vedere i riferimenti per ulteriori esempi + di come funziona la crittografia. Hashing - In the case of truly hidden data, if its raw representation is not needed - (i.e. will not be displayed), hashing should be taken into consideration. - The well-known example for hashing is storing the cryptographic hash of a - password in a database, instead of the password itself. + Nel caso di dati veramente nascosti(privati- segreti- ), se non è necessaria la loro rappresentazione grezza(originale - ) + (p.es. non dev'essere visualizzato), è necessario prendere in considerazione l'hashing. + L'esempio ben noto di hashing è la memorizzazione della password criptata tramite hashing + (è il salvataggio dell'hash della password) nel database, + invece della password stessa. - The password functions - provide a convenient way to hash sensitive data and work with these hashes. + Le funzioni per password + possono fornire un modo conveniente per eseguire l'hashing dei dati sensibili e lavorare con questi hash. - password_hash is used to hash a given string using the - strongest algorithm currently available and password_verify - checks whether the given password matches the hash stored in database. + password_hash viene utilizzato per eseguire l'hashing di una determinata stringa utilizzando + l'algoritmo più potente attualmente disponibile e password_verify + controlla se la password fornita corrisponde all'hash memorizzato nel database. - + Hashing password field - + SQL Injection + L'SQL injection è una tecnica in cui un utente malintenzionato sfrutta i difetti del file + codice dell'applicazione responsabile della creazione di query SQL dinamiche. + L'aggressore può accedere a sezioni privilegiate dell'applicazione, + recuperare tutte le informazioni dal database, manomettere i dati esistenti, + o addirittura eseguire comandi pericolosi a livello di sistema sul database + ospite. La vulnerabilità si verifica quando gli sviluppatori concatenano o + interpolare input arbitrari nelle loro istruzioni SQL. + SQL injection is a technique where an attacker exploits flaws in application code responsible for building dynamic SQL queries. The attacker can gain access to privileged sections of the application, From b072d607c5c5eb0cc46c1fa004cb0d7fc945d288 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 15 Feb 2025 02:28:34 +0100 Subject: [PATCH 08/49] Merge branch 'security' --- security/cgi-bin.xml | 14 +-- security/filesystem.xml | 235 ++++++++++++++++++++++++++++++++++++++++ security/general.xml | 72 ++++++++++++ security/hiding.xml | 78 +++++++++++++ security/intro.xml | 59 ++++++++++ security/sessions.xml | 34 ++++++ security/variables.xml | 104 ++++++++++++++++++ 7 files changed, 589 insertions(+), 7 deletions(-) create mode 100644 security/filesystem.xml create mode 100644 security/general.xml create mode 100644 security/hiding.xml create mode 100644 security/intro.xml create mode 100644 security/sessions.xml create mode 100644 security/variables.xml diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index f20e28c26..100ce270f 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -1,6 +1,6 @@ - + PHP installato come binario CGI @@ -76,7 +76,7 @@ - 1º Caso :solo files publici elaborati + 1° Caso :solo files publici elaborati Se il tuo server non ha alcun contenuto e non è protetto @@ -99,7 +99,7 @@ - 2º Caso : utilizzo di <literal>cgi.force_redirect</literal> + 2° Caso : utilizzo di <literal>cgi.force_redirect</literal> La configurazione della direttiva cgi.force_redirect @@ -132,7 +132,7 @@ AddHandler php-script .php - 3º: impostare doc_root o user_dir + 3°: impostare doc_root o user_dir Includere contenuti attivi, come script ed eseguibili, nelle directory dei documenti del server Web è talvolta considerato @@ -192,10 +192,10 @@ AddHandler php-script .php - 4º Caso: script PHP fuori dalla cartella web + 4° Caso: script PHP fuori dalla cartella web Un'opzione molto sicura è mettere il binario del parser PHP da qualche parte - al di fuori dell'cartella web dei file. In /usr/local/bin, per esempio. L'unico vero lo svantaggio di questa opzione è che ora dovrai inserire una riga simile a: @@ -215,7 +215,7 @@ AddHandler php-script .php Per far sì che PHP gestisca correttamente le informazioni PATH_INFO e PATH_TRANSLATED in modo corretto con questa configurazione, è necessario - abilitare la direttiva cgi.discard_path. + abilitare la direttiva cgi.discard_path. diff --git a/security/filesystem.xml b/security/filesystem.xml new file mode 100644 index 000000000..b163ee0df --- /dev/null +++ b/security/filesystem.xml @@ -0,0 +1,235 @@ + + + + + + Sicurezza del Filesystem + + PHP dipende dalla gestione della sicurezza di molti sistemi server che usano + i permessi basati su file e directory. Ciò consente + di controllare quali file nel filesystem possono essere letti. Si dovrebbe prestare attenzione + a tutti i file che sono pubblici per garantire + che siano sicuri in lettura da parte degli utenti che hanno accesso a quel + file system. + + + Poiché PHP è stato progettato per consentire l'accesso a livello utente al file system, + potrebbe essere possibile scrivere uno script PHP che ti consenta + di leggere file di sistema come /etc/passwd, modificare le connessioni ethernet, + inviare enormi documenti in stampa, ecc. Questo suggerisce alcune + ovvie implicazioni, in quanto devi assicurarti che i file + da cui leggi e su cui scrivi siano quelli appropriati. + + + Considerate il seguente script, dove l'utente indica che vorrebbe + eliminare un file nella propria directory home. Ciò presuppone una + situazione in cui un'interfaccia web PHP viene regolarmente utilizzata per la + gestione dei file, quindi all'utente Apache è consentito eliminare i file nelle + directory home dell'utente. + + + + Un controllo non accurato di una variabile porta a... + + +]]> + + + Poiché il nome utente e il nome file possono essere inviati da un form, + possono inviare un nome utente e un nome file appartenenti a un'altro utente, + ed eliminarli anche se non dovrebbero essere autorizzati a farlo. + In questo caso, dovresti usare un'altra forma di autenticazione. + Considera cosa potrebbe accadere se le variabili inviate fossero + "../etc/" e "passwd". + Il codice quindi leggerebbe effettivamente: + + ... un'attacco al filesystem + + +]]> + + + Ci sono due misure importanti che dovresti adottare per prevenire questi problemi. + + + + Consentire solo autorizzazioni limitate ai file binari da parte dell'utente web PHP. + + + + + Controllare tutte le variabili inviate. + + + + Ecco uno script migliorato: + + Controllo più sicuro dei nomi dei file + + +]]> + + + Tuttavia, anche questo non è privo di difetti. Se il tuo sistema di autenticazione + consentiva agli utenti di creare i propri accessi e un'altro utente + voleva accedere a "../etc/", il sistema è nuovamente esposto. Per + questo motivo, potresti preferire scrivere un controllo più personalizzato: + + Controllo più sicuro dei nomi dei file + + +]]> + + + + + A seconda del sistema operativo, esiste un'ampia varietà di file + di cui dovresti preoccuparti, tra cui nomi di risorse (/dev/ + o COM1), file di configurazione (file /etc/ e + file .ini), cartelle di archiviazione classiche (/home/, + My Documents), ecc. Per questo + motivo, di solito è più facile creare una policy in cui proibisci tutto tranne ciò che consenti esplicitamente. + + + Problemi relativi ai valori NULL + + Poiché PHP utilizza le funzioni derivate da C per le operazioni correlate + al file system, potrebbero gestire i valori NULL in un modo del tutto inaspettato. + Poiché i valori NULL indicano la fine di una stringa in C, le stringhe che li contengono + non saranno valutate nella loro interezza, ma solo finché non incontreranno un valore NULL. + + Il seguente fa vedere un codice vulnerabile che mostra questo problema: + + + Script vulnerabile ai valori NULL + + +]]> + + + + Pertanto, qualsiasi stringa contaminata utilizzata in un'operazione sul file system dovrebbe sempre + essere convalidata correttamente. Ecco una versione migliore dell'esempio precedente: + + + Convalida corretta dell'input + + +]]> + + + + + + + diff --git a/security/general.xml b/security/general.xml new file mode 100644 index 000000000..813368102 --- /dev/null +++ b/security/general.xml @@ -0,0 +1,72 @@ + + + + + + Considerazioni Generali + + Un sistema completamente sicuro è virtualmente impossibile, quindi un + approccio spesso utilizzato nella professione della sicurezza è quello + di bilanciare rischio e usabilità. Se ogni variabile inviata da un + utente richiedesse due forme di convalida biometrica (come una scansione + della retina e un'impronta digitale), si avrebbe un livello di identificazione + estremamente elevato. Ci vorrebbe anche mezz'ora per compilare un modulo abbastanza + complesso, il che porterebbe a incoraggiare gli utenti a trovare dei modi per + aggirare la sicurezza. + + + La migliore sicurezza è spesso abbastanza discreta da soddisfare + i requisiti senza che all'utente gli venga impedito di svolgere il proprio + lavoro o caricare troppo l'autore del codice con un'eccessiva complessità. + In effetti, alcuni attacchi alla sicurezza sono semplicemente degli exploit di + questo tipo di sicurezza eccessivamente complessa, che tende a perdersi nel tempo. + + + Una frase che vale la pena ricordare: un sistema è valido quanto l'anello più debole + di una catena. Se tutte le transazioni vengono registrate in modo massiccio in base a + ora, posizione, tipo di transazione, ecc. ma l'utente viene verificato solo in base a + un singolo cookie, la validità del collegamento degli utenti + al log degli accessi è gravemente compromessa. + + + Quando esegui un test, tieni presente che non sarai in grado di testare tutte le + casistiche, nemmeno per la più semplice delle pagine. L'input che + potresti aspettarti sarà completamente diverso dall'input fornito da + un dipendente insoddisfatto, un cracker con mesi di tempo libero o un gatto + che cammina sulla tastiera. Ecco perché è + meglio guardare il codice da una prospettiva logica, per discernere + dove possono essere introdotti dati imprevisti e quindi seguire come vengono + modificati, ridotti o amplificati. + + + Internet è pieno di persone che cercano di diventare famosi + violando il tuo codice, mandando in crash il tuo sito, pubblicando + contenuti inappropriati e rendendoti la giornata interessante in altri modi. + Non importa se hai un sito grande o piccolo, sei + un bersaglio semplicemente perché sei online, perché hai un server a cui + puoi connetterti. Molti programmi di cracking non distinguono le dimensioni del bersaglio, + semplicemente analizzano enormi blocchi di IP alla ricerca di vittime. Cerca di non + diventarne uno. + + + + diff --git a/security/hiding.xml b/security/hiding.xml new file mode 100644 index 000000000..b648cc3e8 --- /dev/null +++ b/security/hiding.xml @@ -0,0 +1,78 @@ + + + + + + Hiding PHP + + In generale, la sicurezza tramite l'occultamento è una delle forme di sicurezza più deboli. + Ma in alcuni casi, ogni piccolo briciolo di sicurezza in più è benvenuto. + + + Alcune semplici tecniche possono aiutare a nascondere PHP, rallentando + eventualmente un aggressore che sta tentando di scoprire debolezze nel tuo + sistema. Impostando exhibit_php su off nel tuo + file &php.ini;, riduci la quantità di informazioni a loro disposizione. + + + Un'altra tattica è quella di configurare il server Web come Apache per + analizzare diversi tipi di file tramite PHP, con una direttiva &htaccess; + o nel file di configurazione di Apache. Puoi quindi + utilizzare estensioni di file falsi: + + Nascondere PHP come se fosse un altro linguaggio + + + + + O lo nasconde completamente: + + Using unknown types for PHP extensions + + + + + Oppure nasconderlo come codice HTML, ma questo fa si avrà un leggero calo di prestazioni perché + tutto l'HTML verrà processato tramite il motore di PHP: + + Usando <acronym>HTML</acronym> come se fosse l'estensione di PHP + + + + + Per far funzionare tutto in modo efficace, devi rinominare i tuoi file PHP con + le estensioni di cui sopra. Sebbene sia una forma di sicurezza attraverso + l'occultamento, è una misura preventiva minore con pochi inconvenienti. + + + + + diff --git a/security/intro.xml b/security/intro.xml new file mode 100644 index 000000000..9294b3a17 --- /dev/null +++ b/security/intro.xml @@ -0,0 +1,59 @@ + + + + + + Introduction + + PHP è un linguaggio potente e l'interprete, che sia incluso in un server web come modulo o eseguito come binario separato + CGI, è in grado di accedere ai file, eseguire + comandi e aprire connessioni di rete sul server. Queste + proprietà rendono qualsiasi cosa eseguita su un server web non sicura per default. + PHP è progettato specificamente per essere un linguaggio più sicuro per + scrivere programmi CGI rispetto a Perl o C e, con la corretta configurazione + in fase di compilazione e runtime e le corrette pratiche di codifica, può darti + giusta combinazione di libertà e sicurezza di cui hai bisogno. + + + Poiché ci sono molti modi per utilizzare PHP, ci sono molte opzioni + di configurazione che ne controllano il comportamento. Un'ampia selezione + di opzioni garantisce che puoi utilizzare PHP per diversi scopi, ma significa + anche che ci sono possibili configurazioni del server + che risultano non sicure. + + + La flessibilità di configurazione di PHP è pari alla flessibilità del codice. + PHP può essere utilizzato per creare applicazioni server + complete, con tutta la potenza di una shell, oppure può essere utilizzato + per semplici Server Side Include con pochi rischi e in un ambiente strettamente + controllato. Il modo in cui si crea quell'ambiente e quanto sia + sicuro, dipende in gran parte dallo sviluppatore PHP. + + + Questo capitolo inizia con alcuni consigli generali sulla sicurezza, spiega + le diverse combinazioni di configurazione e le situazioni + in cui possono essere utilizzate in modo sicuro e descrive diverse considerazioni nella + codifica per diversi livelli di sicurezza. + + + + diff --git a/security/sessions.xml b/security/sessions.xml new file mode 100644 index 000000000..829982c8d --- /dev/null +++ b/security/sessions.xml @@ -0,0 +1,34 @@ + + + + Securezza della sessione + + + È importante mantenere sicura la gestione delle sessioni HTTP. + La sicurezza relativa alle sessioni è descritta nella sezione + Sessione e Sicurezza + del riferimento Gestione delle sessioni. + + + + + diff --git a/security/variables.xml b/security/variables.xml new file mode 100644 index 000000000..a1494f105 --- /dev/null +++ b/security/variables.xml @@ -0,0 +1,104 @@ + + + + + + + + Dati inviati dall'utente + + La più grande debolezza in molti programmi scritti in PHP non è insita nel + linguaggio stesso, ma semplicemente un problema di codice scritto non tenendo + a mente la sicurezza. Per questo motivo, dovresti sempre prenderti il ​​tempo + di considerare le implicazioni di una certa parte di codice, per accertare + il possibile malfunzionamento se gli viene inviata una variabile inaspettata. + + Utilizzo pericoloso delle variabili + + +]]> + + + + + Dovresti sempre esaminare attentamente il tuo codice per assicurarti + che tutte le variabili inviate da un browser web siano state correttamente + controllate e farti le seguenti domande: + + + + Questo script avrà effetto solo sui file previsti? + + + + + Può un dato indesiderato o inusuale interferire con il funzionamento? + + + + + Questo script può essere utilizzato in modi non previsti? + + + + + Può essere usato insieme ad altri script in modo dannoso? + + + + + Le transazioni verranno adeguatamente tracciate? + + + + + + Ponendosi queste domande durante la scrittura dello script, + piuttosto che farsele dopo, previeni una riscrittura difficoltosa quando + si ha invece bisogno di migliorare la sicurezza. Iniziando usare queste regole, + non si garantisce la sicurezza del sistema, ma si può contribuire a + migliorarlo. + + + Potresti anche voler disattivare register_globals, + magic_quotes o altre impostazioni utili che potrebbero confonderti + sulla validità, la fonte o il valore di una determinata variabile. + Lavorare con PHP in modalità error_reporting(E_ALL) può + anche aiutare ad informarti sulle variabili utilizzate prima che vengano + controllate o inizializzate (in modo da impedire che vengano utilizzati dati insoliti). + + + + From 00827c6190c6d10bd2d8da090483386fd52ade3a Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 15 Feb 2025 05:10:16 +0100 Subject: [PATCH 09/49] Merge branch 'one-security' into clean-security --- security/database.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/database.xml b/security/database.xml index 58bebc52f..53c975652 100644 --- a/security/database.xml +++ b/security/database.xml @@ -87,7 +87,7 @@ Il modo più semplice per aggirare questo problema è crearne prima uno tuo - pacchetto di crittografia e quindi utilizzarlo dai nei tuoi script PHP. PHP + pacchetto di crittografia e quindi utilizzarlo dai nei tuoi script PHP. PHP può aiutarti in questo con diverse estensioni, come OpenSSL e Sodium, che copre un'ampia varietà di algoritmi di crittografia. From d524a5e5de973344510387cf814a33ecd46f43e1 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 15 Feb 2025 02:28:34 +0100 Subject: [PATCH 10/49] Merge branch 'security' From d58d8ff89325e2745762ef9c9840fa42229b51d0 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 15 Feb 2025 12:32:49 +0100 Subject: [PATCH 11/49] git pull From dc9626f1189fb2c1a06dddb435338371f7699d18 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 15 Feb 2025 12:29:11 +0100 Subject: [PATCH 12/49] mod security/database.xml --- security/database.xml | 39 ++++++++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 9 deletions(-) diff --git a/security/database.xml b/security/database.xml index 53c975652..998fe9a33 100644 --- a/security/database.xml +++ b/security/database.xml @@ -115,7 +115,7 @@ controlla se la password fornita corrisponde all'hash memorizzato nel database. - Hashing password field + Campo per l'Hash della password - SQL Injection - L'SQL injection è una tecnica in cui un utente malintenzionato sfrutta i difetti del file + L'SQL injection è una tecnica dove un utente malintenzionato sfrutta i difetti del codice dell'applicazione responsabile della creazione di query SQL dinamiche. L'aggressore può accedere a sezioni privilegiate dell'applicazione, recuperare tutte le informazioni dal database, manomettere i dati esistenti, o addirittura eseguire comandi pericolosi a livello di sistema sul database - ospite. La vulnerabilità si verifica quando gli sviluppatori concatenano o - interpolare input arbitrari nelle loro istruzioni SQL. + ospite(host). La vulnerabilità si verifica quando gli sviluppatori concatenano o + interpolano input(dati) arbitrari nelle loro istruzioni SQL. SQL injection is a technique where an attacker exploits flaws in application code responsible for building dynamic SQL queries. @@ -166,10 +165,13 @@ if ($row && password_verify($password, $row['pwd'])) { - Splitting the result set into pages ... and making superusers + Dividere il set di risultati in pagine ... e creare superutenti<!--XXX tradurre--> (PostgreSQL) + Nell'esempio seguente, l'input dell'utente viene interpolato (binding) direttamente nel + Query SQL che consente all'aggressore di ottenere un account superutente nel database. + In the following example, user input is directly interpolated into the SQL query allowing the attacker to gain a superuser account in the database. @@ -200,18 +202,37 @@ insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd) ]]> + Se ciò dovesse accadere, lo script presenterebbe un accesso da superutente all'aggressore. + Tieni presente che 0; fornisce un offset valido a + query originale e per terminarla. + If it happened, the script would present a superuser access to the attacker. Note that 0; is to supply a valid offset to the original query and to terminate it. + È una tecnica comune forzare il parser SQL a ignorare il resto del file + query scritta dallo sviluppatore con -- che è il + segno di commento in SQL. + It is a common technique to force the SQL parser to ignore the rest of the query written by the developer with -- which is the comment sign in SQL. + Un modo fattibile per ottenere password è aggirare le pagine dei risultati di ricerca. + L'unica cosa che l'attaccante deve fare è vedere se sono presenti variabili inviate + utilizzato nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati + comunemente in una forma precedente per personalizzare WHERE, ORDER BY, + Clausole LIMIT e OFFSET in SELECT + dichiarazioni. Se il tuo database supporta il costrutto UNION, + l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale da elencare + password da una tabella arbitraria. Si consiglia vivamente di conservare solo + proteggere gli hash delle password anziché le password stesse. + + A feasible way to gain passwords is to circumvent your search result pages. The only thing the attacker needs to do is to see if there are any submitted variables used in SQL statements which are not handled properly. These filters can be set @@ -223,7 +244,7 @@ insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd) secure hashes of passwords instead of the passwords themselves. - Listing out articles ... and some passwords (any database server) + Elenco degli articoli... e alcune password (qualsiasi server di database) - Listing out articles ... and some passwords (any database server) - The static part of the query can be combined with another - SELECT statement which reveals all passwords: + La parte statica della query può essere combinata con un'altra - The static part of the query can be combined with another + SELECTdichiarazione che rivela tutte le password: - statement which reveals all passwords: Date: Tue, 18 Feb 2025 14:49:01 +0100 Subject: [PATCH 13/49] translation progress --- security/database.xml | 63 +++++++++++++++---------------------------- 1 file changed, 22 insertions(+), 41 deletions(-) diff --git a/security/database.xml b/security/database.xml index 998fe9a33..97e8d15c4 100644 --- a/security/database.xml +++ b/security/database.xml @@ -114,7 +114,7 @@ l'algoritmo più potente attualmente disponibile e password_verify controlla se la password fornita corrisponde all'hash memorizzato nel database. - + Campo per l'Hash della password SQL Injection L'SQL injection è una tecnica dove un utente malintenzionato sfrutta i difetti del - codice dell'applicazione responsabile della creazione di query SQL dinamiche. + codice responsabile della creazione di query SQL dinamiche. L'aggressore può accedere a sezioni privilegiate dell'applicazione, recuperare tutte le informazioni dal database, manomettere i dati esistenti, o addirittura eseguire comandi pericolosi a livello di sistema sul database ospite(host). La vulnerabilità si verifica quando gli sviluppatori concatenano o - interpolano input(dati) arbitrari nelle loro istruzioni SQL. - - SQL injection is a technique where an attacker exploits flaws in - application code responsible for building dynamic SQL queries. - The attacker can gain access to privileged sections of the application, - retrieve all information from the database, tamper with existing data, - or even execute dangerous system-level commands on the database - host. The vulnerability occurs when developers concatenate or - interpolate arbitrary input in their SQL statements. + interpolano dati arbitrari nelle loro istruzioni SQL. - Dividere il set di risultati in pagine ... e creare superutenti<!--XXX tradurre--> + Dividere il set di risultati in pagine ... e creare superutenti (PostgreSQL) - Nell'esempio seguente, l'input dell'utente viene interpolato (binding) direttamente nel - Query SQL che consente all'aggressore di ottenere un account superutente nel database. - - In the following example, user input is directly interpolated into the - SQL query allowing the attacker to gain a superuser account in the database. + Nell'esempio seguente, l'input dell'utente viene interpolato (binding) direttamente nella + Query SQL che consente all'aggressore di ottenere un account superuser(amministratore) nel database. - Normal users click on the 'next', 'prev' links where the $offset - is encoded into the URL. The script expects that the incoming - $offset is a number. However, what if someone tries to - break in by appending the following to the URL + Di solito gli utenti usano i collegamenti "next", "previous" dove $offset + viene passato nell'URL. Lo script si aspetta che l'$offset + sia un numero. Tuttavia, cosa succede se qualcuno prova a craccarlo + aggiungendo quanto segue all'URL? - Se ciò dovesse accadere, lo script presenterebbe un accesso da superutente all'aggressore. - Tieni presente che 0; fornisce un offset valido a - query originale e per terminarla. - - If it happened, the script would present a superuser access to the attacker. - Note that 0; is to supply a valid offset to the - original query and to terminate it. + Se ciò dovesse accadere, lo script fornirebbe un accesso d'amministratore all'aggressore. + Tieni presente che 0; fornirebbe un offset valido alla query originale + e la terminerebbe. - È una tecnica comune forzare il parser SQL a ignorare il resto del file - query scritta dallo sviluppatore con -- che è il - segno di commento in SQL. - - It is a common technique to force the SQL parser to ignore the rest of the - query written by the developer with -- which is the - comment sign in SQL. + È una tecnica comune per forzare il parser SQL a ignorare il resto del file + una query scritta dallo sviluppatore con -- che introduce + i commenti in SQL. - Un modo fattibile per ottenere password è aggirare le pagine dei risultati di ricerca. + Un modo possibile per ottenere le password è analizzare le pagine dei risultati di ricerca. L'unica cosa che l'attaccante deve fare è vedere se sono presenti variabili inviate - utilizzato nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati + utilizzate nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati comunemente in una forma precedente per personalizzare WHERE, ORDER BY, Clausole LIMIT e OFFSET in SELECT dichiarazioni. Se il tuo database supporta il costrutto UNION, l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale da elencare - password da una tabella arbitraria. Si consiglia vivamente di conservare solo - proteggere gli hash delle password anziché le password stesse. + password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password + anziché le password stesse. A feasible way to gain passwords is to circumvent your search result pages. @@ -260,7 +241,7 @@ $result = odbc_exec($conn, $query); La parte statica della query può essere combinata con un'altra - The static part of the query can be combined with another SELECTdichiarazione che rivela tutte le password: - statement which reveals all passwords: - + - + UPDATE and INSERT statements are also susceptible to such attacks. From 079021b023fd15cdd5c32bb2dffcafb692de1008 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 18 Feb 2025 14:49:01 +0100 Subject: [PATCH 14/49] translation progress --- security/database.xml | 82 ++++++++++++++----------------------------- 1 file changed, 26 insertions(+), 56 deletions(-) diff --git a/security/database.xml b/security/database.xml index 998fe9a33..a484719d7 100644 --- a/security/database.xml +++ b/security/database.xml @@ -1,6 +1,6 @@ - + Sicurezza del Database @@ -114,7 +114,7 @@ l'algoritmo più potente attualmente disponibile e password_verify controlla se la password fornita corrisponde all'hash memorizzato nel database. - + Campo per l'Hash della password SQL Injection L'SQL injection è una tecnica dove un utente malintenzionato sfrutta i difetti del - codice dell'applicazione responsabile della creazione di query SQL dinamiche. + codice responsabile della creazione di query SQL dinamiche. L'aggressore può accedere a sezioni privilegiate dell'applicazione, recuperare tutte le informazioni dal database, manomettere i dati esistenti, o addirittura eseguire comandi pericolosi a livello di sistema sul database ospite(host). La vulnerabilità si verifica quando gli sviluppatori concatenano o - interpolano input(dati) arbitrari nelle loro istruzioni SQL. - - SQL injection is a technique where an attacker exploits flaws in - application code responsible for building dynamic SQL queries. - The attacker can gain access to privileged sections of the application, - retrieve all information from the database, tamper with existing data, - or even execute dangerous system-level commands on the database - host. The vulnerability occurs when developers concatenate or - interpolate arbitrary input in their SQL statements. + interpolano dati arbitrari nelle loro istruzioni SQL. - Dividere il set di risultati in pagine ... e creare superutenti<!--XXX tradurre--> + Dividere il set di risultati in pagine ... e creare superutenti (PostgreSQL) - Nell'esempio seguente, l'input dell'utente viene interpolato (binding) direttamente nel - Query SQL che consente all'aggressore di ottenere un account superutente nel database. - - In the following example, user input is directly interpolated into the - SQL query allowing the attacker to gain a superuser account in the database. + Nell'esempio seguente, l'input dell'utente viene interpolato (binding) direttamente nella + Query SQL che consente all'aggressore di ottenere un account superuser(amministratore) nel database. - Normal users click on the 'next', 'prev' links where the $offset - is encoded into the URL. The script expects that the incoming - $offset is a number. However, what if someone tries to - break in by appending the following to the URL + Di solito gli utenti usano i collegamenti "next", "previous" dove $offset + viene passato nell'URL. Lo script si aspetta che l'$offset + sia un numero. Tuttavia, cosa succede se qualcuno prova a craccarlo + aggiungendo quanto segue all'URL? - Se ciò dovesse accadere, lo script presenterebbe un accesso da superutente all'aggressore. - Tieni presente che 0; fornisce un offset valido a - query originale e per terminarla. - - If it happened, the script would present a superuser access to the attacker. - Note that 0; is to supply a valid offset to the - original query and to terminate it. + Se ciò dovesse accadere, lo script fornirebbe un accesso d'amministratore all'aggressore. + Tieni presente che 0; fornirebbe un offset valido alla query originale + e la terminerebbe. - È una tecnica comune forzare il parser SQL a ignorare il resto del file - query scritta dallo sviluppatore con -- che è il - segno di commento in SQL. - - It is a common technique to force the SQL parser to ignore the rest of the - query written by the developer with -- which is the - comment sign in SQL. + È una tecnica comune per forzare il parser SQL a ignorare il resto del file + una query scritta dallo sviluppatore con -- che introduce + i commenti in SQL. - Un modo fattibile per ottenere password è aggirare le pagine dei risultati di ricerca. + Un modo possibile per ottenere le password è analizzare le pagine dei risultati di ricerca. L'unica cosa che l'attaccante deve fare è vedere se sono presenti variabili inviate - utilizzato nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati + utilizzate nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati comunemente in una forma precedente per personalizzare WHERE, ORDER BY, Clausole LIMIT e OFFSET in SELECT dichiarazioni. Se il tuo database supporta il costrutto UNION, l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale da elencare - password da una tabella arbitraria. Si consiglia vivamente di conservare solo - proteggere gli hash delle password anziché le password stesse. - - - A feasible way to gain passwords is to circumvent your search result pages. - The only thing the attacker needs to do is to see if there are any submitted variables - used in SQL statements which are not handled properly. These filters can be set - commonly in a preceding form to customize WHERE, ORDER BY, - LIMIT and OFFSET clauses in SELECT - statements. If your database supports the UNION construct, - the attacker may try to append an entire query to the original one to list - passwords from an arbitrary table. It is strongly recommended to store only - secure hashes of passwords instead of the passwords themselves. + password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password + anziché le password stesse. - Elenco degli articoli... e alcune password (qualsiasi server di database) - Listing out articles ... and some passwords (any database server) + Elenco degli articoli... e alcune password (può essere usato su qualunque server di database). - La parte statica della query può essere combinata con un'altra - The static part of the query can be combined with another - SELECTdichiarazione che rivela tutte le password: - statement which reveals all passwords: - + La parte statica della query può essere combinata con un'altra + SELECTrichiesta che rivela tutte le password: + - + UPDATE and INSERT statements are also susceptible to such attacks. From d00e1421bf774400cf1d30a576139179904dfacd Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 18 Feb 2025 22:56:23 +0100 Subject: [PATCH 15/49] translation progress database.xml --- security/database.xml | 132 ++++++++++++++++++++++++++++++++++++++---- 1 file changed, 120 insertions(+), 12 deletions(-) diff --git a/security/database.xml b/security/database.xml index 54fc89b82..06d932a52 100644 --- a/security/database.xml +++ b/security/database.xml @@ -241,7 +241,7 @@ $result = odbc_exec($conn, $query); La parte statica della query può essere combinata con un'altra - The static part of the query can be combined with another SELECTdichiarazione che rivela tutte le password: - statement which reveals all passwords: - + - + + Lo sono anche le istruzioni UPDATE e INSERT + suscettibili a tali attacchi. + UPDATE and INSERT statements are also susceptible to such attacks. + Dalla reimpostazione di una password... all'acquisizione di più privilegi (qualsiasi server di database) + From resetting a password ... to gaining more privileges (any database server) @@ -266,11 +271,19 @@ $query = "UPDATE usertable SET pwd='$pwd' WHERE uid='$uid';"; ]]> + + Se un utente malintenzionato invia il valore + ' o uid like'%admin% in $uid in + cambia la password dell'amministratore o imposta semplicemente $pwd su + hehehe', trust=100, admin='yes per ottenere di più + privilegi, la query verrà distorta: + If a malicious user submits the value ' or uid like'%admin% to $uid to change the admin's password, or simply sets $pwd to hehehe', trusted=100, admin='yes to gain more privileges, then the query will be twisted: + + Mentre resta ovvio che un malintenzionato debba possederne almeno alcuni + conoscenza dell'architettura del database per condurre un'attività di successo + attacco, ottenere queste informazioni è spesso molto semplice. Per esempio, + il codice può far parte di un software open source ed essere disponibile al pubblico. + Tali informazioni potranno anche essere divulgate + tramite codice closed-source, anche se codificato, offuscato o compilato, + e anche dal proprio codice attraverso la visualizzazione di messaggi di errore. + Altri metodi includono l'uso di nomi di tabelle e colonne tipici. Per + ad esempio, un modulo di accesso che utilizza una tabella "utenti" con nomi di colonne + "id", "nome utente" e "password". + + While it remains obvious that an attacker must possess at least some knowledge of the database architecture to conduct a successful attack, obtaining this information is often very simple. For example, @@ -302,11 +327,16 @@ $query = "UPDATE usertable SET pwd='hehehe', trusted=100, admin='yes' WHERE - Attacking the database host operating system (MSSQL Server) - - A frightening example of how operating system-level commands can be - accessed on some database hosts. - + + Attacking the database host operating system (MSSQL Server) -- Attaccare il sistema operativo host del database (MSSQL Server) + + Un esempio spaventoso di come possono essere i comandi a livello di sistema operativo + accessibile su alcuni host di database. + + A frightening example of how operating system-level commands can be + accessed on some database hosts. + + + Se l'attaccante invia il valore + a%' exec master..xp_cmdshell 'net user test testpass /ADD' -- + a $prod, quindi $query sarà: + + If attacker submits the value a%' exec master..xp_cmdshell 'net user test testpass /ADD' -- to $prod, then the $query will be: @@ -335,6 +370,14 @@ $result = mssql_query($query); ]]> + MSSQL Server esegue le istruzioni SQL nel batch incluso un comando + per aggiungere un nuovo utente al database degli account locali. Se questa applicazione + erano in esecuzione come sa e il servizio MSSQLSERVER lo era + in esecuzione con privilegi sufficienti, l'utente malintenzionato ora avrebbe un file + account con cui accedere a questa macchina. + + + MSSQL Server executes the SQL statements in the batch including a command to add a new user to the local accounts database. If this application were running as sa and the MSSQLSERVER service was @@ -343,16 +386,20 @@ $result = mssql_query($query); + Alcuni esempi sopra riportati sono legati a un server di database specifico, ma it + non significa che un attacco simile sia impossibile contro altri prodotti. + Il tuo server database potrebbe essere altrettanto vulnerabile in un altro modo. + Some examples above are tied to a specific database server, but it does not mean that a similar attack is impossible against other products. - Your database server may be similarly vulnerable in another manner. + Your database server may be similarly vulnerable in another manner. - A funny example of the issues regarding SQL injection + A funny example of the issues regarding SQL injection - A funny example of the issues regarding SQL injection - + @@ -363,8 +410,18 @@ $result = mssql_query($query); - Avoidance Techniques + Avoidance Techniques - Tecniche di evitamento + Il modo consigliato per evitare l'iniezione SQL è associare tutti i dati + tramite istruzioni preparate. L'utilizzo di query parametrizzate non è + sufficiente per evitare completamente l'iniezione SQL, ma è il modo più + semplice e sicuro per fornire input alle istruzioni SQL. Tutti i letterali + di dati dinamici nelle clausole WHERE, + SET e VALUES devono essere sostituiti + con segnaposto. I dati effettivi verranno associati durante l'esecuzione e + inviati separatamente dal comando SQL. + + The recommended way to avoid SQL injection is by binding all data via prepared statements. Using parameterized queries isn't enough to entirely avoid SQL injection, but it is the easiest and safest way to provide input @@ -374,6 +431,10 @@ $result = mssql_query($query); execution and sent separately from the SQL command. + Il binding dei parametri può essere utilizzato solo per i dati. Altre + parti dinamiche della query SQL devono essere filtrate in base a un elenco + noto di valori consentiti. + Parameter binding can only be used for data. Other dynamic parts of the SQL query must be filtered against a known list of allowed values. @@ -406,6 +467,14 @@ $stmt->execute(["%{$productId}%"]); + + Gli attacchi di iniezione SQL si basano principalmente sullo sfruttamento del codice non scritto + con la sicurezza in mente. Non fidarti mai di nessun input, specialmente + dal lato client, anche se proviene da una casella di selezione, + un campo di input nascosto o un cookie. Il primo esempio mostra che una query così + semplice può causare disastri. + + SQL injection attacks are mainly based on exploiting the code not being written with security in mind. Never trust any input, especially from the client side, even though it comes from a select box, @@ -414,16 +483,29 @@ $stmt->execute(["%{$productId}%"]); + Una strategia di difesa in profondità comporta diverse buone pratiche di codifica: + A defense-in-depth strategy involves several good coding practices: + Non connettersi mai al database come superutente o come proprietario del database. Utilizzare sempre utenti personalizzati con privilegi minimi. + Never connect to the database as a superuser or as the database owner. Use always customized users with minimal privileges. + Controlla se l'input fornito ha il tipo di dati previsto. PHP ha + una vasta gamma di funzioni di convalida dell'input, da quelle più semplici + che si trovano in Funzioni variabili e + in Funzioni tipo carattere + (ad esempio is_numeric, ctype_digit + rispettivamente) e oltre al + supporto per Espressioni regolari compatibili con Perl. + + Check if the given input has the expected data type. PHP has a wide range of input validating functions, from the simplest ones found in Variable Functions and @@ -436,6 +518,11 @@ $stmt->execute(["%{$productId}%"]); + Se l'applicazione prevede un input numerico, prendi in considerazione la verifica dei dati + con ctype_digit, modifica silenziosamente il suo tipo + usando settype o usa la sua rappresentazione numerica + con sprintf. + If the application expects numerical input, consider verifying data with ctype_digit, silently change its type using settype, or use its numeric representation @@ -444,6 +531,16 @@ $stmt->execute(["%{$productId}%"]); + Se il livello del database non supporta variabili di binding, allora + cita ogni valore non numerico fornito dall'utente che viene passato al + database con la funzione di escape della stringa specifica del database (ad esempio + mysql_real_escape_string, + sqlite_escape_string, ecc.). + Le funzioni generiche come addslashes sono utili solo + in un ambiente molto specifico (ad esempio MySQL in un set di caratteri a singolo byte + con NO_BACKSLASH_ESCAPES disabilitato), quindi è + meglio evitarle. + If the database layer doesn't support binding variables then quote each non-numeric user-supplied value that is passed to the database with the database-specific string escape function (e.g. @@ -457,6 +554,11 @@ $stmt->execute(["%{$productId}%"]); + Non stampare informazioni specifiche del database, in particolare + sullo schema, con mezzi leciti o illeciti. Vedere anche Segnalazione degli errori e Funzioni di gestione e registrazione degli errori. + Do not print out any database-specific information, especially about the schema, by fair means or foul. See also Error Reporting and execute(["%{$productId}%"]); + Oltre a ciò, puoi trarre vantaggio dalla registrazione delle query all'interno del tuo script + o dal database stesso, se supporta la registrazione. Ovviamente, la registrazione non è in grado + di prevenire alcun tentativo dannoso, ma può essere utile risalire a quale + applicazione è stata aggirata. Il registro non è utile di per sé, ma + attraverso le informazioni che contiene. Più dettagli sono generalmente meglio di meno. + Besides these, you benefit from logging queries either within your script or by the database itself, if it supports logging. Obviously, the logging is unable to prevent any harmful attempt, but it can be helpful to trace back which application has been circumvented. The log is not useful by itself but through the information it contains. More detail is generally better than less. - + From 7656c4eecd8a20cb0d62e6243b21eb7ab6a5a264 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 19 Feb 2025 17:18:59 +0100 Subject: [PATCH 16/49] fixed tags undisclosed --- security/database.xml | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/security/database.xml b/security/database.xml index 06d932a52..5dd2fa634 100644 --- a/security/database.xml +++ b/security/database.xml @@ -430,6 +430,7 @@ $result = mssql_query($query); replaced with placeholders. The actual data will be bound during the execution and sent separately from the SQL command. + Il binding dei parametri può essere utilizzato solo per i dati. Altre parti dinamiche della query SQL devono essere filtrate in base a un elenco @@ -464,23 +465,22 @@ $stmt->execute(["%{$productId}%"]); by PDO, by MySQLi, and by other database libraries. - + - - Gli attacchi di iniezione SQL si basano principalmente sullo sfruttamento del codice non scritto - con la sicurezza in mente. Non fidarti mai di nessun input, specialmente - dal lato client, anche se proviene da una casella di selezione, - un campo di input nascosto o un cookie. Il primo esempio mostra che una query così - semplice può causare disastri. - - - SQL injection attacks are mainly based on exploiting the code not being written - with security in mind. Never trust any input, especially - from the client side, even though it comes from a select box, - a hidden input field, or a cookie. The first example shows that such a - simple query can cause disasters. - + Gli attacchi di iniezione SQL si basano principalmente sullo sfruttamento del codice non scritto + con la sicurezza in mente. Non fidarti mai di nessun input, specialmente + dal lato client, anche se proviene da una casella di selezione, + un campo di input nascosto o un cookie. Il primo esempio mostra che una query così + semplice può causare disastri. + + + SQL injection attacks are mainly based on exploiting the code not being written + with security in mind. Never trust any input, especially + from the client side, even though it comes from a select box, + a hidden input field, or a cookie. The first example shows that such a + simple query can cause disasters. + Una strategia di difesa in profondità comporta diverse buone pratiche di codifica: From ee56bfa3235526989b4ec7c80c93321705621cc3 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 19 Feb 2025 20:28:39 +0100 Subject: [PATCH 17/49] translation progress database.xml --- security/database.xml | 48 +++++++++++++++++++++---------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/security/database.xml b/security/database.xml index 5dd2fa634..8d533717f 100644 --- a/security/database.xml +++ b/security/database.xml @@ -8,25 +8,25 @@ Al giorno d'oggi, i database sono componenti essenziali di qualsiasi applicazione basata sul Web, consentendo ai siti Web di fornire vari contenuti dinamici. Poiché anche le informazioni molto sensibili o segrete possono - essere archiviate in un database, dovresti considerare seriamente di + essere archiviate in un database, dovresti prendere seriamente in considerazione di protegere i tuoi database. Per recuperare o archiviare qualsiasi informazione di cui hai bisogno per connetterti al database, - inviare una query legittima, recuperare il risultato e quindi chiudere la connessione. - Oggigiorno, il linguaggio di query comunemente utilizzato per questo tipo di interazione è - l'SQL (Structured Query Language). Guarda come un aggressore può manomettere una query SQL. - Come puoi immaginare, PHP non può proteggere il database da solo. - Le prossime sezioni mirano a essere un'introduzione di come + Come si può immaginare, PHP non può proteggere il database da solo. + Le prossime sezioni puntano a introdurre le modalità di come accedere e manipolare ai database all'interno di uno script PHP. - Tieni presente questa semplice regola: difesa in profondità. Più prendi provvedimenti + Bisogna tener presente questa semplice regola: (Defense in Depth) difesa in profondità. Più prendi provvedimenti per aumentare la protezione del database, minore è probabilità che un utente malintenzionato - riesca a esporre o abusare di eventuali dati archiviati. Una buona progettazione + riesca ad accedere o abusare di eventuali dati archiviati. Una buona progettazione dello schema del database e dell'applicazione previene le tue più grandi paure. @@ -34,39 +34,39 @@ Progetazione del database Il primo passo è quello di creare il database, a meno che non si voglia utilizzarne uno - di terze parti. Quando il database è stato creato, gli viene assegnato a un proprietario, + di terze parti. Una volta creato il database, gli viene assegnato a un proprietario, che ha eseguito l'istruzione di creazione. Di solito, solo il proprietario (o un superuser) può fare qualsiasi cosa con gli oggetti in quel database e, - per consentire ad altri utenti di utilizzarlo, devono essere concessi dei privilegi. + per consentire ad altri utenti di utilizzarlo, gli devono essere concessi dei privilegi. Le applicazioni non dovrebbero mai connettersi al database come proprietario o superutente, perché questi utenti possono eseguire qualsiasi query a piacimento, - ad esempio, modificando lo schema (ad esempio eliminando tabelle) o eliminandone - l'intero contenuto. + ad esempio, potrebbero modificare lo schema (ad esempio eliminando tabelle) o potrebbero + eliminare l'intero contenuto. - Puoi creare vari utenti del database uno per ogni funzionalità della tua applicazione - con diritti molto limitati sugli oggetti del database. Dovrebbero essere concessi + E' possiile creare vari utenti del database uno per ogni ruolo della tua applicazione + con diritti molto limitati sugli elementi del database. Dovrebbero essere concessi solo i privilegi necessari per evitare che lo stesso utente possa modificare il database tramite le diverse funzionalità. Ciò significa che se gli intrusi ottengono l'accesso al tuo database utilizzando le credenziali delle tue applicazioni, - possono apportare tante modifiche quante ne possono apportare i tuoi privilegi. + potrebbero apportare tutte le modifiche quante ne sono previsti dai privilegi. Connessione al database - Potresti voler stabilire connessioni SSL per crittografare le - comunicazioni client/server per una maggiore sicurezza oppure è possibile utilizzare ssh - per crittografare la connessione di rete tra i client e il server del database. - Se viene utilizzato uno di questi, monitorare il traffico e ottenere - le informazioni sul tuo database saranno difficili da parte di un potenziale utente malintenzionato. - + E' possibile stabilire connessioni SSL per crittografare le + comunicazioni client/server per una maggiore sicurezza oppure è possibile utilizzare SSH + per criptare la connessione di rete tra i client e il server del database. + Se viene utilizzato uno di questi sistemi, monitorare il traffico e ottenere + le informazioni sul tuo database saranno difficili da parte di un potenziale malintenzionato. + - Se il tuo server database ha il supporto SSL nativo, considera l'utilizzo di Funzioni OpenSSL nella comunicazione tra + Se il tuo server database ha il supporto SSL nativo, considera l'utilizzo delle Funzioni OpenSSL nelle comunicazioni tra PHP e database tramite SSL. @@ -430,7 +430,7 @@ $result = mssql_query($query); replaced with placeholders. The actual data will be bound during the execution and sent separately from the SQL command. - + Il binding dei parametri può essere utilizzato solo per i dati. Altre parti dinamiche della query SQL devono essere filtrate in base a un elenco From f71dcadb069cf0c4773bef6a5979325672abe2f0 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 20 Feb 2025 10:19:29 +0100 Subject: [PATCH 18/49] Merge branch 'security' of https://github.com/ManueldG/doc-it into security From a3129d8c7e0a7b31e7632834b75d6d5bc0504ce1 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 20 Feb 2025 10:31:30 +0100 Subject: [PATCH 19/49] Merge branch 'security' of https://github.com/ManueldG/doc-it into security From 368f8a12148566942c05c0de3fc0f95cd106b260 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 20 Feb 2025 10:34:24 +0100 Subject: [PATCH 20/49] translation progress database.xml --- security/database.xml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/security/database.xml b/security/database.xml index 8d533717f..03436fa22 100644 --- a/security/database.xml +++ b/security/database.xml @@ -46,7 +46,7 @@ eliminare l'intero contenuto. - E' possiile creare vari utenti del database uno per ogni ruolo della tua applicazione + E' possibile creare vari utenti del database uno per ogni ruolo della tua applicazione con diritti molto limitati sugli elementi del database. Dovrebbero essere concessi solo i privilegi necessari per evitare che lo stesso utente possa modificare il database tramite le diverse funzionalità. Ciò significa che se gli intrusi ottengono @@ -63,12 +63,12 @@ per criptare la connessione di rete tra i client e il server del database. Se viene utilizzato uno di questi sistemi, monitorare il traffico e ottenere le informazioni sul tuo database saranno difficili da parte di un potenziale malintenzionato. - + Se il tuo server database ha il supporto SSL nativo, considera l'utilizzo delle Funzioni OpenSSL nelle comunicazioni tra PHP e database tramite SSL. - + @@ -85,21 +85,21 @@ è un buon modo per limitare questa minaccia, ma pochissimi database offrono questo tipo di crittografia dei dati. - - Il modo più semplice per aggirare questo problema è crearne prima uno tuo - pacchetto di crittografia e quindi utilizzarlo dai nei tuoi script PHP. PHP - può aiutarti in questo con diverse estensioni, come + Il modo più semplice per aggirare questo problema è innanzitutto creare il proprio pacchetto di crittografia, + e quindi utilizzarlo nei tuoi script PHP. PHP + può aiutarti con diverse estensioni, come OpenSSL e Sodium, che copre un'ampia varietà di algoritmi di crittografia. Lo script cripta i dati prima di inserirli nel database e li decripta durante il recupero. Vedere i riferimenti per ulteriori esempi - di come funziona la crittografia. + su come funziona la crittografia. Hashing - Nel caso di dati veramente nascosti(privati- segreti- ), se non è necessaria la loro rappresentazione grezza(originale - ) + Nel caso di dati veramente nascosti(estremamente /privati- segreti- ), se non è necessaria la loro rappresentazione grezza(originale - in chiaro ) (p.es. non dev'essere visualizzato), è necessario prendere in considerazione l'hashing. L'esempio ben noto di hashing è la memorizzazione della password criptata tramite hashing (è il salvataggio dell'hash della password) nel database, From 278fba49a73f34e70aebb2cbaeb995e6c1f1e254 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 20 Feb 2025 10:34:24 +0100 Subject: [PATCH 21/49] translation progress database.xml --- security/database.xml | 59 ++++++++++++++++++++----------------------- 1 file changed, 27 insertions(+), 32 deletions(-) diff --git a/security/database.xml b/security/database.xml index 03436fa22..cc0ff7911 100644 --- a/security/database.xml +++ b/security/database.xml @@ -71,7 +71,7 @@ - + Modello d'archiviazione crittografato - Encrypted Storage Model SSL/SSH protegge i dati che viaggiano dal client al server: SSL/SSH @@ -106,15 +106,15 @@ invece della password stessa. - Le funzioni per password - possono fornire un modo conveniente per eseguire l'hashing dei dati sensibili e lavorare con questi hash. + Le funzioni per le password + possono fornire un modo semplice per eseguire l'hashing dei dati sensibili e lavorare con questi hash. password_hash viene utilizzato per eseguire l'hashing di una determinata stringa utilizzando l'algoritmo più potente attualmente disponibile e password_verify controlla se la password fornita corrisponde all'hash memorizzato nel database. - + Campo per l'Hash della password ospite(host). La vulnerabilità si verifica quando gli sviluppatori concatenano o interpolano dati arbitrari nelle loro istruzioni SQL. - - Dividere il set di risultati in pagine ... e creare superutenti + <title> <!-- XXX 1 controllo --> + Dividere il set di risultati in pagine ... e creare superutenti <!-- amministratori --> (PostgreSQL) - Nell'esempio seguente, l'input dell'utente viene interpolato (binding) direttamente nella - Query SQL che consente all'aggressore di ottenere un account superuser(amministratore) nel database. + Nell'esempio seguente, l'input dell'utente viene interpolato direttamente nella + Query SQL che consente all'aggressore di ottenere un account superuser nel database. - Di solito gli utenti usano i collegamenti "next", "previous" dove $offset + Di solito gli utenti usano i collegamenti "next", "previous" dove l'$offset viene passato nell'URL. Lo script si aspetta che l'$offset sia un numero. Tuttavia, cosa succede se qualcuno prova a craccarlo aggiungendo quanto segue all'URL? @@ -192,13 +192,13 @@ insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd) Se ciò dovesse accadere, lo script fornirebbe un accesso d'amministratore all'aggressore. - Tieni presente che 0; fornirebbe un offset valido alla query originale + Tieni presente che 0; fornisce un offset valido alla query originale e la terminerebbe. - È una tecnica comune per forzare il parser SQL a ignorare il resto del file - una query scritta dallo sviluppatore con -- che introduce + È una tecnica comune per forzare il parser SQL a ignorare il resto del file + con una query scritta dal programmatore con -- che introduce i commenti in SQL. @@ -206,11 +206,11 @@ insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd) Un modo possibile per ottenere le password è analizzare le pagine dei risultati di ricerca. L'unica cosa che l'attaccante deve fare è vedere se sono presenti variabili inviate utilizzate nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati - comunemente in una forma precedente per personalizzare WHERE, ORDER BY, + comunemente in una forma personalizzata di WHERE, ORDER BY, Clausole LIMIT e OFFSET in SELECT dichiarazioni. Se il tuo database supporta il costrutto UNION, - l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale da elencare - password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password + l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale da elencare + password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password anziché le password stesse. @@ -224,9 +224,7 @@ insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd) passwords from an arbitrary table. It is strongly recommended to store only secure hashes of passwords instead of the passwords themselves. - - Elenco degli articoli... e alcune password (può essere usato su qualunque server di database). - + Elencare gli articoli... e alcune password (può essere usato su qualunque database server). - La parte statica della query può essere combinata con un'altra - The static part of the query can be combined with another - SELECTdichiarazione che rivela tutte le password: - statement which reveals all passwords: + La parte statica della query può essere combinata con un'altra + SELECTdichiarazione che rivela tutte le password: - Lo sono anche le istruzioni UPDATE e INSERT + Anche le istruzioni UPDATE e INSERT sono suscettibili a tali attacchi. - UPDATE and INSERT statements are also - susceptible to such attacks. + - - Dalla reimpostazione di una password... all'acquisizione di più privilegi (qualsiasi server di database) - - From resetting a password ... to gaining more privileges (any database server) - + Dalla reimpostazione di una password... all'acquisizione di più privilegi (qualsiasi database server) + - Se un utente malintenzionato invia il valore - ' o uid like'%admin% in $uid in + Se un utente malintenzionato invia il valore + ' or uid like '%admin% in $uid in cambia la password dell'amministratore o imposta semplicemente $pwd su - hehehe', trust=100, admin='yes per ottenere di più + hehehe', trusted=100, admin='yes per ottenere di più privilegi, la query verrà distorta: If a malicious user submits the value From b4f19d8bc27301a3acf053c4727427ae5cd1dc01 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 20 Feb 2025 12:55:09 +0100 Subject: [PATCH 22/49] Merge branch 'security' of https://github.com/ManueldG/doc-it into security From d8a3077b8ef4c219d7f22e5e0e2a8fce8827864b Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 03:28:49 +0100 Subject: [PATCH 23/49] translation progress database.xml --- security/database.xml | 106 +++++++++++------------------------------- 1 file changed, 27 insertions(+), 79 deletions(-) diff --git a/security/database.xml b/security/database.xml index cc0ff7911..a297ee826 100644 --- a/security/database.xml +++ b/security/database.xml @@ -266,19 +266,11 @@ $query = "UPDATE usertable SET pwd='$pwd' WHERE uid='$uid';"; ]]> - - Se un utente malintenzionato invia il valore - ' or uid like '%admin% in $uid in - cambia la password dell'amministratore o imposta semplicemente $pwd su - hehehe', trusted=100, admin='yes per ottenere di più - privilegi, la query verrà distorta: - - If a malicious user submits the value - ' or uid like'%admin% to $uid to - change the admin's password, or simply sets $pwd to - hehehe', trusted=100, admin='yes to gain more - privileges, then the query will be twisted: - + Se un utente malintenzionato invia la stringa + ' or uid like '%admin% in $uid per + cambiare la password dell'amministratore oppure impostare la variabile $pwd semplicemente con + hehehe', trusted=100, admin='yes per ottenere + privilegi più elevati, la query verrà corrotta: - - Mentre resta ovvio che un malintenzionato debba possederne almeno alcuni - conoscenza dell'architettura del database per condurre un'attività di successo - attacco, ottenere queste informazioni è spesso molto semplice. Per esempio, + + Mentre è scontato che un malintenzionato debba possederne almeno alcune nozioni + dell'architettura del database per condurre un'attacco riuscito , + è spesso molto semplice ottenere queste informazioni . Per esempio, il codice può far parte di un software open source ed essere disponibile al pubblico. Tali informazioni potranno anche essere divulgate - tramite codice closed-source, anche se codificato, offuscato o compilato, - e anche dal proprio codice attraverso la visualizzazione di messaggi di errore. + tramite codice closed-source, anche se è codificato, offuscato o compilato - + e anche tramite il proprio codice attraverso la visualizzazione di messaggi di errore Altri metodi includono l'uso di nomi di tabelle e colonne tipici. Per - ad esempio, un modulo di accesso che utilizza una tabella "utenti" con nomi di colonne - "id", "nome utente" e "password". - - - While it remains obvious that an attacker must possess at least some - knowledge of the database architecture to conduct a successful - attack, obtaining this information is often very simple. For example, - the code may be part of an open-source software and be publicly available. - This information may also be divulged - by closed-source code - even if it's encoded, obfuscated, or compiled - - and even by your own code through the display of error messages. - Other methods include the use of typical table and column names. For - example, a login form that uses a 'users' table with column names - 'id', 'username', and 'password'. + ad esempio, un modulo d'accesso che utilizza una tabella "utenti" con nomi di colonne + "id", "username" e "password". - Attacking the database host operating system (MSSQL Server) -- Attaccare il sistema operativo host del database (MSSQL Server) + Attaccare il sistema operativo host del database (MSSQL Server) - Un esempio spaventoso di come possono essere i comandi a livello di sistema operativo - accessibile su alcuni host di database. - - A frightening example of how operating system-level commands can be - accessed on some database hosts. + Un preoccupante esempio di come è possibile accedere ai comandi a livello di sistema operativo + da parte di alcuni database su host. @@ -343,14 +320,9 @@ $result = mssql_query($query); ]]> - Se l'attaccante invia il valore + Se l'attaccante invia la stringa a%' exec master..xp_cmdshell 'net user test testpass /ADD' -- a $prod, quindi $query sarà: - - - If attacker submits the value - a%' exec master..xp_cmdshell 'net user test testpass /ADD' -- - to $prod, then the $query will be: MSSQL Server esegue le istruzioni SQL nel batch incluso un comando per aggiungere un nuovo utente al database degli account locali. Se questa applicazione - erano in esecuzione come sa e il servizio MSSQLSERVER lo era - in esecuzione con privilegi sufficienti, l'utente malintenzionato ora avrebbe un file - account con cui accedere a questa macchina. - - - - MSSQL Server executes the SQL statements in the batch including a command - to add a new user to the local accounts database. If this application - were running as sa and the MSSQLSERVER service was - running with sufficient privileges, the attacker would now have an - account with which to access this machine. + era in esecuzione come sa e il servizio MSSQLSERVER era + in esecuzione con privilegi sufficienti, l'utente malintenzionato ora avrebbe un'account + con cui accedere a questa macchina. - Alcuni esempi sopra riportati sono legati a un server di database specifico, ma it - non significa che un attacco simile sia impossibile contro altri prodotti. - Il tuo server database potrebbe essere altrettanto vulnerabile in un altro modo. - - Some examples above are tied to a specific database server, but it - does not mean that a similar attack is impossible against other products. - Your database server may be similarly vulnerable in another manner. + Alcuni esempi sopra riportati sono legati ad uno specifico database , ma + non significa che un attacco simile sia impossibile verso altri prodotti. + Il tuo database potrebbe essere altrettanto vulnerabile in un altri modi. - A funny example of the issues regarding SQL injection - A funny example of the issues regarding SQL injection + Un esempio divertente dei problemi riguardanti SQL injection @@ -405,9 +365,9 @@ $result = mssql_query($query); - Avoidance Techniques - Tecniche di evitamento + Tecniche di elusione - Il modo consigliato per evitare l'iniezione SQL è associare tutti i dati + Il modo consigliato per evitare l'SQL injection è associare tutti i dati tramite istruzioni preparate. L'utilizzo di query parametrizzate non è sufficiente per evitare completamente l'iniezione SQL, ma è il modo più semplice e sicuro per fornire input alle istruzioni SQL. Tutti i letterali @@ -415,25 +375,13 @@ $result = mssql_query($query); SET e VALUES devono essere sostituiti con segnaposto. I dati effettivi verranno associati durante l'esecuzione e inviati separatamente dal comando SQL. - - - The recommended way to avoid SQL injection is by binding all data via - prepared statements. Using parameterized queries isn't enough to entirely - avoid SQL injection, but it is the easiest and safest way to provide input - to SQL statements. All dynamic data literals in WHERE, - SET, and VALUES clauses must be - replaced with placeholders. The actual data will be bound during the - execution and sent separately from the SQL command. Il binding dei parametri può essere utilizzato solo per i dati. Altre parti dinamiche della query SQL devono essere filtrate in base a un elenco noto di valori consentiti. - - Parameter binding can only be used for data. Other dynamic parts of the - SQL query must be filtered against a known list of allowed values. - + Avoiding SQL injection by using PDO prepared statements From bddb9df5ce77b19ba5e273fea717b9c99faa8c08 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 15:23:47 +0100 Subject: [PATCH 24/49] translation progress database.xml --- security/database.xml | 21 +++++++-------------- 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/security/database.xml b/security/database.xml index a297ee826..d307b6f83 100644 --- a/security/database.xml +++ b/security/database.xml @@ -384,7 +384,7 @@ $result = mssql_query($query); - Avoiding SQL injection by using PDO prepared statements + Eludere un'SQL injection usando PDO prepared Statement - Avoiding SQL injection by using PDO prepared statements execute(["%{$productId}%"]); - Prepared statements are provided - by PDO, - by MySQLi, - and by other database libraries. + Le Prepared statement Sono fornite. + da PDO, + da MySQLi, + e da altre librerie per database. - Gli attacchi di iniezione SQL si basano principalmente sullo sfruttamento del codice non scritto - con la sicurezza in mente. Non fidarti mai di nessun input, specialmente + Gli attacchi SQL injection sfruttano principalmente il codice scritto + senza fare attanzione alla sicurezza. Non fidarti mai di nessun input, specialmente dal lato client, anche se proviene da una casella di selezione, un campo di input nascosto o un cookie. Il primo esempio mostra che una query così semplice può causare disastri. - - - SQL injection attacks are mainly based on exploiting the code not being written - with security in mind. Never trust any input, especially - from the client side, even though it comes from a select box, - a hidden input field, or a cookie. The first example shows that such a - simple query can cause disasters. From 5ced9f029e05d49ab512428838302eb770611a76 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 15:54:11 +0100 Subject: [PATCH 25/49] translation progress database.xml --- security/database.xml | 32 ++++++-------------------------- 1 file changed, 6 insertions(+), 26 deletions(-) diff --git a/security/database.xml b/security/database.xml index d307b6f83..4f37e4d2b 100644 --- a/security/database.xml +++ b/security/database.xml @@ -419,16 +419,11 @@ $stmt->execute(["%{$productId}%"]); - Una strategia di difesa in profondità comporta diverse buone pratiche di codifica: - - A defense-in-depth strategy involves several good coding practices: + Una strategia di difesa in-depth comporta diverse buone pratiche di scrittura del codice: - Non connettersi mai al database come superutente o come proprietario del database. Utilizzare sempre utenti personalizzati con privilegi minimi. - - Never connect to the database as a superuser or as the database owner. - Use always customized users with minimal privileges. + Non connettersi mai al database come amministratore o come proprietario. Utilizzare sempre utenti personalizzati con privilegi minimi. @@ -436,20 +431,10 @@ $stmt->execute(["%{$productId}%"]); Controlla se l'input fornito ha il tipo di dati previsto. PHP ha una vasta gamma di funzioni di convalida dell'input, da quelle più semplici che si trovano in Funzioni variabili e - in Funzioni tipo carattere - (ad esempio is_numeric, ctype_digit - rispettivamente) e oltre al - supporto per Espressioni regolari compatibili con Perl. - - - Check if the given input has the expected data type. PHP has - a wide range of input validating functions, from the simplest ones - found in Variable Functions and - in Character Type Functions - (e.g. is_numeric, ctype_digit - respectively) and onwards to the - Perl Compatible Regular Expressions - support. + in Funzioni di tipo carattere + (ad esempio rispettivamente is_numeric, ctype_digit + ) e oltre al + supporto per le Espressioni regolari compatibili con Perl. @@ -458,11 +443,6 @@ $stmt->execute(["%{$productId}%"]); con ctype_digit, modifica silenziosamente il suo tipo usando settype o usa la sua rappresentazione numerica con sprintf. - - If the application expects numerical input, consider verifying data - with ctype_digit, silently change its type - using settype, or use its numeric representation - by sprintf. From e752b7fb2167919dd75e704d5f2ae9243efe7e90 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 20:37:54 +0100 Subject: [PATCH 26/49] translation progress database.xml --- security/database.xml | 21 +++++---------------- 1 file changed, 5 insertions(+), 16 deletions(-) diff --git a/security/database.xml b/security/database.xml index 4f37e4d2b..8bfc67898 100644 --- a/security/database.xml +++ b/security/database.xml @@ -448,7 +448,7 @@ $stmt->execute(["%{$productId}%"]); Se il livello del database non supporta variabili di binding, allora - cita ogni valore non numerico fornito dall'utente che viene passato al + cita ogni valore non numerico fornito dall'utente che viene passato al database con la funzione di escape della stringa specifica del database (ad esempio mysql_real_escape_string, sqlite_escape_string, ecc.). @@ -471,31 +471,20 @@ $stmt->execute(["%{$productId}%"]); Non stampare informazioni specifiche del database, in particolare - sullo schema, con mezzi leciti o illeciti. Vedere anche , con mezzi leciti o illeciti. Vedere anche la Segnalazione degli errori e Funzioni di gestione e registrazione degli errori. - - Do not print out any database-specific information, especially - about the schema, by fair means or foul. See also Error Reporting and Error Handling and Logging Functions. - Oltre a ciò, puoi trarre vantaggio dalla registrazione delle query all'interno del tuo script + Oltre a ciò, puoi trarre vantaggio dalla registrazione delle query all'interno del tuo script o dal database stesso, se supporta la registrazione. Ovviamente, la registrazione non è in grado di prevenire alcun tentativo dannoso, ma può essere utile risalire a quale - applicazione è stata aggirata. Il registro non è utile di per sé, ma - attraverso le informazioni che contiene. Più dettagli sono generalmente meglio di meno. - - Besides these, you benefit from logging queries either within your script - or by the database itself, if it supports logging. Obviously, the logging is unable - to prevent any harmful attempt, but it can be helpful to trace back which - application has been circumvented. The log is not useful by itself but - through the information it contains. More detail is generally better than less. + applicazione è stata aggirata. Il registro non è utile di per sé, ma + attraverso le informazioni che contiene. Generalmente più dettagli ci sono meglio è. From 853cfa5aff357e41a3e9157dfe6c35046132c4ee Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:07:23 +0100 Subject: [PATCH 27/49] mod revision errors.xml --- security/errors.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/errors.xml b/security/errors.xml index d25a45259..b1e13cb59 100644 --- a/security/errors.xml +++ b/security/errors.xml @@ -1,6 +1,6 @@ - + From a02a99d61560ed310df6d575cb1b3c2e3ce6fc43 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:07:41 +0100 Subject: [PATCH 28/49] mod revision filesystem.xml --- security/filesystem.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/filesystem.xml b/security/filesystem.xml index b163ee0df..6557913a6 100644 --- a/security/filesystem.xml +++ b/security/filesystem.xml @@ -1,6 +1,6 @@ - + Sicurezza del Filesystem From 6d36fab5f02c2c1158cba416e7746c986c220841 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:08:04 +0100 Subject: [PATCH 29/49] mod revision general.xml --- security/general.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/general.xml b/security/general.xml index 813368102..d86f4c617 100644 --- a/security/general.xml +++ b/security/general.xml @@ -1,6 +1,6 @@ - + Considerazioni Generali From 3dadc0bb5e39c37d3a6acf9ee19ff15bbc0d43ab Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:08:25 +0100 Subject: [PATCH 30/49] mod revision hiding.xml --- security/hiding.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/hiding.xml b/security/hiding.xml index b648cc3e8..f1ba05db2 100644 --- a/security/hiding.xml +++ b/security/hiding.xml @@ -1,6 +1,6 @@ - + Hiding PHP From fabe6fb0be9c340823ff11832dd6443cfaa231dd Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:08:40 +0100 Subject: [PATCH 31/49] mod revision intro.xml --- security/intro.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/intro.xml b/security/intro.xml index 9294b3a17..274d96564 100644 --- a/security/intro.xml +++ b/security/intro.xml @@ -1,6 +1,6 @@ - + Introduction From 7950a5a18bbc09fda8e90fbb16f944e528ba1468 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:08:59 +0100 Subject: [PATCH 32/49] mod revision sessions.xml --- security/sessions.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/sessions.xml b/security/sessions.xml index 829982c8d..73d2add0e 100644 --- a/security/sessions.xml +++ b/security/sessions.xml @@ -1,5 +1,5 @@ - + Securezza della sessione From 631323746df88a45b72560a239532604176452f8 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Fri, 21 Feb 2025 22:09:14 +0100 Subject: [PATCH 33/49] mod revision variables.xml --- security/variables.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/variables.xml b/security/variables.xml index a1494f105..7fd9e6c96 100644 --- a/security/variables.xml +++ b/security/variables.xml @@ -1,6 +1,6 @@ - + From b04108d9b0c9e34c9358cba5fd3199da4aadaf69 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 22 Feb 2025 16:49:58 +0100 Subject: [PATCH 34/49] translation progress database.xml --- security/database.xml | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/security/database.xml b/security/database.xml index 8bfc67898..1a331af75 100644 --- a/security/database.xml +++ b/security/database.xml @@ -68,7 +68,7 @@ Se il tuo server database ha il supporto SSL nativo, considera l'utilizzo delle Funzioni OpenSSL nelle comunicazioni tra PHP e database tramite SSL. - + @@ -423,18 +423,28 @@ $stmt->execute(["%{$productId}%"]); - Non connettersi mai al database come amministratore o come proprietario. Utilizzare sempre utenti personalizzati con privilegi minimi. + Non connettersi mai al database come amministratore o come proprietario. Utilizzare sempre utenti personalizzati con privilegi minimi. - Controlla se l'input fornito ha il tipo di dati previsto. PHP ha - una vasta gamma di funzioni di convalida dell'input, da quelle più semplici + Controlla se l'input fornito è del tipo di dati previsto. PHP ha + una vasta gamma di funzioni per la convalida dell'input, da quelle più semplici che si trovano in Funzioni variabili e in Funzioni di tipo carattere - (ad esempio rispettivamente is_numeric, ctype_digit - ) e oltre al - supporto per le Espressioni regolari compatibili con Perl. + (es.: rispettivamente is_numerice ctype_digit + ) oltre al supporto per le Espressioni regolari compatibili con Perl. + + + + Check if the given input has the expected data type. PHP has + a wide range of input validating functions, from the simplest ones + found in Variable Functions and + in Character Type Functions + (e.g. is_numeric, ctype_digit + respectively) and onwards to the + Perl Compatible Regular Expressions + support. @@ -443,6 +453,11 @@ $stmt->execute(["%{$productId}%"]); con ctype_digit, modifica silenziosamente il suo tipo usando settype o usa la sua rappresentazione numerica con sprintf. + + If the application expects numerical input, consider verifying data + with ctype_digit, silently change its type + using settype, or use its numeric representation + by sprintf. From d48af7393f8a46e616e0778aa46b9ee08eea23ba Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 22 Feb 2025 20:32:23 +0100 Subject: [PATCH 35/49] translation progress database.xml --- security/database.xml | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/security/database.xml b/security/database.xml index 1a331af75..4add996e2 100644 --- a/security/database.xml +++ b/security/database.xml @@ -291,7 +291,7 @@ $query = "UPDATE usertable SET pwd='hehehe', trusted=100, admin='yes' WHERE Mentre è scontato che un malintenzionato debba possederne almeno alcune nozioni dell'architettura del database per condurre un'attacco riuscito , - è spesso molto semplice ottenere queste informazioni . Per esempio, + è spesso molto semplice ottenere queste informazioni. Per esempio, il codice può far parte di un software open source ed essere disponibile al pubblico. Tali informazioni potranno anche essere divulgate tramite codice closed-source, anche se è codificato, offuscato o compilato - @@ -485,7 +485,7 @@ $stmt->execute(["%{$productId}%"]); - Non stampare informazioni specifiche del database, in particolare + Non stampare informazioni specifiche del database, in particolare sullo schema, con mezzi leciti o illeciti. Vedere anche la Segnalazione degli errori e Funzioni di gestione e registrazione degli errori. @@ -495,11 +495,11 @@ $stmt->execute(["%{$productId}%"]); - Oltre a ciò, puoi trarre vantaggio dalla registrazione delle query all'interno del tuo script - o dal database stesso, se supporta la registrazione. Ovviamente, la registrazione non è in grado - di prevenire alcun tentativo dannoso, ma può essere utile risalire a quale - applicazione è stata aggirata. Il registro non è utile di per sé, ma - attraverso le informazioni che contiene. Generalmente più dettagli ci sono meglio è. + Oltre a ciò, puoi trarre vantaggio dal log delle query da parte del tuo script + o dal database stesso, se lo supporta. Ovviamente, il log non è in grado + di prevenire alcun tentativo dannoso, ma può essere utile per risalire a quale + applicazione è stata colpita. Il registro non è utile di per sé, ma + sono utili le informazioni che contiene. Generalmente più dettagli ci sono nel log meglio è. From 20bd9e7787092377c10c1f9f50ee28e56eef5f84 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sun, 23 Feb 2025 11:43:21 +0100 Subject: [PATCH 36/49] translation progress database.xml --- security/database.xml | 166 +++++++++++++++++------------------------- 1 file changed, 66 insertions(+), 100 deletions(-) diff --git a/security/database.xml b/security/database.xml index 4add996e2..173b04e5e 100644 --- a/security/database.xml +++ b/security/database.xml @@ -6,8 +6,8 @@ Al giorno d'oggi, i database sono componenti essenziali di qualsiasi - applicazione basata sul Web, consentendo ai siti Web di fornire vari contenuti - dinamici. Poiché anche le informazioni molto sensibili o segrete possono + applicazione basata sul Web, consentendo ai siti Web di fornire molti contenuti + dinamici. Poiché anche le informazioni sensibili o segrete possono essere archiviate in un database, dovresti prendere seriamente in considerazione di protegere i tuoi database. @@ -16,16 +16,16 @@ eseguire una query, recuperare il risultato e quindi chiudere la connessione. Oggigiorno, il linguaggio più utilizzato per questo tipo di interazione è l'SQL (Structured Query Language). Di seguito viene mostrato come un'aggressore può manomettere una query SQL. + linkend="security.database.sql-injection">manometterelo con una query SQL. - Come si può immaginare, PHP non può proteggere il database da solo. + Da come si può immaginare, PHP non può proteggere da solo il database. Le prossime sezioni puntano a introdurre le modalità di come accedere e manipolare ai database all'interno di uno script PHP. Bisogna tener presente questa semplice regola: (Defense in Depth) difesa in profondità. Più prendi provvedimenti - per aumentare la protezione del database, minore è probabilità che un utente malintenzionato + per aumentare la sicurezza del database, minore è probabilità che un utente malintenzionato riesca ad accedere o abusare di eventuali dati archiviati. Una buona progettazione dello schema del database e dell'applicazione previene le tue più grandi paure. @@ -34,15 +34,15 @@ Progetazione del database Il primo passo è quello di creare il database, a meno che non si voglia utilizzarne uno - di terze parti. Una volta creato il database, gli viene assegnato a un proprietario, - che ha eseguito l'istruzione di creazione. Di solito, solo il proprietario - (o un superuser) può fare qualsiasi cosa con gli oggetti in quel database e, + di terze parti. Una volta creato il database, viene assegnato un proprietario, + a chi ha eseguito l'istruzione di creazione. Di solito, solo il proprietario + (o l'amministratore) può fare qualsiasi cosa con gli oggetti di quel database e, per consentire ad altri utenti di utilizzarlo, gli devono essere concessi dei privilegi. Le applicazioni non dovrebbero mai connettersi al database come proprietario o - superutente, perché questi utenti possono eseguire qualsiasi query a piacimento, - ad esempio, potrebbero modificare lo schema (ad esempio eliminando tabelle) o potrebbero + amministratore, poichè questi utenti possono eseguire qualsiasi query a piacimento, + ad esempio, potrebbero modificare lo schema (ad esempio eliminando le tabelle) o potrebbero eliminare l'intero contenuto. @@ -51,28 +51,28 @@ solo i privilegi necessari per evitare che lo stesso utente possa modificare il database tramite le diverse funzionalità. Ciò significa che se gli intrusi ottengono l'accesso al tuo database utilizzando le credenziali delle tue applicazioni, - potrebbero apportare tutte le modifiche quante ne sono previsti dai privilegi. + potrebbero apportare tutte le modifiche quante ne sono previste dai privilegi. Connessione al database - E' possibile stabilire connessioni SSL per crittografare le - comunicazioni client/server per una maggiore sicurezza oppure è possibile utilizzare SSH + E' possibile per una maggiore sicurezza stabilire connessioni SSL per criptare le + comunicazioni client/server oppure è possibile utilizzare SSH per criptare la connessione di rete tra i client e il server del database. - Se viene utilizzato uno di questi sistemi, monitorare il traffico e ottenere - le informazioni sul tuo database saranno difficili da parte di un potenziale malintenzionato. + Se viene utilizzato uno di questi sistemi, sarà difficile monitorare il traffico e ottenere + le informazioni del tuo database da parte di un potenziale malintenzionato. - Se il tuo server database ha il supporto SSL nativo, considera l'utilizzo delle Funzioni OpenSSL nelle comunicazioni tra + Se il server del database ha il supporto nativo SSL, si può considerare l'uso delle funzioni OpenSSL per comunicazioni tra PHP e database tramite SSL. - + - - Modello d'archiviazione crittografato - Encrypted Storage Model + + Modello d'archiviazione crittografato SSL/SSH protegge i dati che viaggiano dal client al server: SSL/SSH non protegge i dati persistenti archiviati in un database. SSL è un @@ -85,24 +85,24 @@ è un buon modo per limitare questa minaccia, ma pochissimi database offrono questo tipo di crittografia dei dati. - - Il modo più semplice per aggirare questo problema è innanzitutto creare il proprio pacchetto di crittografia, + + Il modo più semplice per aggirare il problema è innanzitutto creare il proprio pacchetto di crittografia, e quindi utilizzarlo nei tuoi script PHP. PHP può aiutarti con diverse estensioni, come OpenSSL e Sodium, che copre un'ampia varietà di algoritmi di crittografia. + linkend="book.openssl">OpenSSL o Sodium, che impiega un'ampia varietà di algoritmi di crittografia. Lo script cripta i dati prima di inserirli nel database e li decripta durante il recupero. Vedere i riferimenti per ulteriori esempi - su come funziona la crittografia. + su come funziona la crittografia. Hashing - Nel caso di dati veramente nascosti(estremamente /privati- segreti- ), se non è necessaria la loro rappresentazione grezza(originale - in chiaro ) + Nel caso di dati veramente segreti , se non è necessaria la loro rappresentazione originale (p.es. non dev'essere visualizzato), è necessario prendere in considerazione l'hashing. - L'esempio ben noto di hashing è la memorizzazione della password criptata tramite hashing - (è il salvataggio dell'hash della password) nel database, + Un'esempio ben noto di hashing + è il salvataggio dell'hash della password nel database, invece della password stessa. @@ -117,7 +117,8 @@ Campo per l'Hash della password - + SQL Injection - L'SQL injection è una tecnica dove un utente malintenzionato sfrutta i difetti del + L'SQL injection è una tecnica dove un'utente malintenzionato sfrutta i difetti del codice responsabile della creazione di query SQL dinamiche. L'aggressore può accedere a sezioni privilegiate dell'applicazione, recuperare tutte le informazioni dal database, manomettere i dati esistenti, - o addirittura eseguire comandi pericolosi a livello di sistema sul database - ospite(host). La vulnerabilità si verifica quando gli sviluppatori concatenano o + o addirittura eseguire comandi pericolosi a livello di sistema Host dul database. + La vulnerabilità si verifica quando gli sviluppatori concatenano o interpolano dati arbitrari nelle loro istruzioni SQL. - <!-- XXX 1 controllo --> - Dividere il set di risultati in pagine ... e creare superutenti <!-- amministratori --> + <title> + Dividere il set di risultati in pagine ... e creare amministratori <!-- amministratori --> (PostgreSQL) - Nell'esempio seguente, l'input dell'utente viene interpolato direttamente nella - Query SQL che consente all'aggressore di ottenere un account superuser nel database. + Nell'esempio seguente, l'input dell'utente viene interpolato direttamente nella + Query SQL che consente all'aggressore di ottenere un account amministratore nel database. - È una tecnica comune per forzare il parser SQL a ignorare il resto del file - con una query scritta dal programmatore con -- che introduce + Una tecnica comune per forzare il parser SQL a ignorare il resto della richiesta + query scritta dal programmatore è usare -- che introduce i commenti in SQL. Un modo possibile per ottenere le password è analizzare le pagine dei risultati di ricerca. L'unica cosa che l'attaccante deve fare è vedere se sono presenti variabili inviate - utilizzate nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri possono essere impostati - comunemente in una forma personalizzata di WHERE, ORDER BY, - Clausole LIMIT e OFFSET in SELECT - dichiarazioni. Se il tuo database supporta il costrutto UNION, - l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale da elencare - password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password + utilizzate nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri di solito possono essere impostati + in un form usato precedentemente e personalizzarlo usando le clausule WHERE, ORDER BY, + LIMIT e OFFSET nell'istruzione SELECT. + Se il database supporta il costrutto UNION, + l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale per far elencare + le password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password anziché le password stesse. - - - A feasible way to gain passwords is to circumvent your search result pages. - The only thing the attacker needs to do is to see if there are any submitted variables - used in SQL statements which are not handled properly. These filters can be set - commonly in a preceding form to customize WHERE, ORDER BY, - LIMIT and OFFSET clauses in SELECT - statements. If your database supports the UNION construct, - the attacker may try to append an entire query to the original one to list - passwords from an arbitrary table. It is strongly recommended to store only - secure hashes of passwords instead of the passwords themselves. - + Elencare gli articoli... e alcune password (può essere usato su qualunque database server). - La parte statica della query può essere combinata con un'altra - SELECTdichiarazione che rivela tutte le password: + La parte statica della query può essere combinata con un'altra SELECT + che rivela tutte le password: - Alcuni esempi sopra riportati sono legati ad uno specifico database , ma + Alcuni esempi sopra riportati sono legati ad uno specifico database, ma non significa che un attacco simile sia impossibile verso altri prodotti. Il tuo database potrebbe essere altrettanto vulnerabile in un altri modi. @@ -366,7 +356,7 @@ $result = mssql_query($query); Tecniche di elusione - + Il modo consigliato per evitare l'SQL injection è associare tutti i dati tramite istruzioni preparate. L'utilizzo di query parametrizzate non è sufficiente per evitare completamente l'iniezione SQL, ma è il modo più @@ -404,16 +394,16 @@ $stmt->execute(["%{$productId}%"]); - Le Prepared statement Sono fornite. - da PDO, - da MySQLi, + I Prepared statement sono forniti da + PDO, + MySQLi, e da altre librerie per database. Gli attacchi SQL injection sfruttano principalmente il codice scritto senza fare attanzione alla sicurezza. Non fidarti mai di nessun input, specialmente - dal lato client, anche se proviene da una casella di selezione, + dal lato client, anche se proviene da un menu a tendina, un campo di input nascosto o un cookie. Il primo esempio mostra che una query così semplice può causare disastri. @@ -423,7 +413,8 @@ $stmt->execute(["%{$productId}%"]); - Non connettersi mai al database come amministratore o come proprietario. Utilizzare sempre utenti personalizzati con privilegi minimi. + Non connettersi mai al database come amministratore o come proprietario. + Utilizzare sempre utenti personalizzati con privilegi minimi. @@ -434,59 +425,34 @@ $stmt->execute(["%{$productId}%"]); in Funzioni di tipo carattere (es.: rispettivamente is_numerice ctype_digit ) oltre al supporto per le Espressioni regolari compatibili con Perl. - - - - Check if the given input has the expected data type. PHP has - a wide range of input validating functions, from the simplest ones - found in Variable Functions and - in Character Type Functions - (e.g. is_numeric, ctype_digit - respectively) and onwards to the - Perl Compatible Regular Expressions - support. Se l'applicazione prevede un input numerico, prendi in considerazione la verifica dei dati - con ctype_digit, modifica silenziosamente il suo tipo + con ctype_digit, modificare con discrezione il suo tipo usando settype o usa la sua rappresentazione numerica con sprintf. - - If the application expects numerical input, consider verifying data - with ctype_digit, silently change its type - using settype, or use its numeric representation - by sprintf. - Se il livello del database non supporta variabili di binding, allora - cita ogni valore non numerico fornito dall'utente che viene passato al - database con la funzione di escape della stringa specifica del database (ad esempio + Se il livello del database non supporta il binding delle variabili, allora + va messo tra virgolette ogni valore non numerico fornito dall'utente che viene passato al + database con la specifica funzione di escape del database per le stringhe (ad esempio mysql_real_escape_string, sqlite_escape_string, ecc.). Le funzioni generiche come addslashes sono utili solo - in un ambiente molto specifico (ad esempio MySQL in un set di caratteri a singolo byte - con NO_BACKSLASH_ESCAPES disabilitato), quindi è + in un ambiente molto specifico (ad esempio MySQL in un set di caratteri a singolo byte + con NO_BACKSLASH_ESCAPES disabilitato)e quindi è meglio evitarle. - - If the database layer doesn't support binding variables then - quote each non-numeric user-supplied value that is passed to the - database with the database-specific string escape function (e.g. mysql_real_escape_string, - sqlite_escape_string, etc.). - Generic functions like addslashes are useful only - in a very specific environment (e.g. MySQL in a single-byte character - set with disabled NO_BACKSLASH_ESCAPES), so it is - better to avoid them. - Non stampare informazioni specifiche del database, in particolare - sullo schema, con mezzi leciti o illeciti. Vedere anche la , a qualunque costo. Vedere anche la sezione Segnalazione degli errori e Funzioni di gestione e registrazione degli errori. @@ -496,8 +462,8 @@ $stmt->execute(["%{$productId}%"]); Oltre a ciò, puoi trarre vantaggio dal log delle query da parte del tuo script - o dal database stesso, se lo supporta. Ovviamente, il log non è in grado - di prevenire alcun tentativo dannoso, ma può essere utile per risalire a quale + o, se lo supporta, dal database stesso. Ovviamente, il log non è in grado + di prevenire alcun tentativo d'attacco, ma può essere utile per capire quale applicazione è stata colpita. Il registro non è utile di per sé, ma sono utili le informazioni che contiene. Generalmente più dettagli ci sono nel log meglio è. From b1b28510c295a4a3ce5bda10f9965f0a4a134024 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 25 Feb 2025 12:12:25 +0100 Subject: [PATCH 37/49] translation progress database.xml --- security/database.xml | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/security/database.xml b/security/database.xml index 173b04e5e..c9c4eeaa0 100644 --- a/security/database.xml +++ b/security/database.xml @@ -402,57 +402,57 @@ $stmt->execute(["%{$productId}%"]); Gli attacchi SQL injection sfruttano principalmente il codice scritto - senza fare attanzione alla sicurezza. Non fidarti mai di nessun input, specialmente + senza pensare alla sicurezza. Non fidarti mai di nessun input, specialmente dal lato client, anche se proviene da un menu a tendina, un campo di input nascosto o un cookie. Il primo esempio mostra che una query così semplice può causare disastri. - Una strategia di difesa in-depth comporta diverse buone pratiche di scrittura del codice: + Una strategia di difesa in-depth comporta diverse Best Practics di scrittura del codice: Non connettersi mai al database come amministratore o come proprietario. - Utilizzare sempre utenti personalizzati con privilegi minimi. + Utilizzare sempre appositi utenti con privilegi minimi. Controlla se l'input fornito è del tipo di dati previsto. PHP ha una vasta gamma di funzioni per la convalida dell'input, da quelle più semplici - che si trovano in Funzioni variabili e - in Funzioni di tipo carattere - (es.: rispettivamente is_numerice ctype_digit - ) oltre al supporto per le Espressioni regolari compatibili con Perl. + che si trovano in Funzioni variabili e + in Funzioni tipo carattere + (es.: rispettivamente is_numeric e ctype_digit) + oltre al supporto per le Espressioni regolari compatibili con Perl. - Se l'applicazione prevede un input numerico, prendi in considerazione la verifica dei dati + Se l'applicazione prevede un input numerico, prendere in considerazione la verifica dei dati con ctype_digit, modificare con discrezione il suo tipo - usando settype o usa la sua rappresentazione numerica + usando settype o formattare la sua rappresentazione numerica con sprintf. - Se il livello del database non supporta il binding delle variabili, allora + Se l'interfaccia del database non supporta il binding delle variabili, allora va messo tra virgolette ogni valore non numerico fornito dall'utente che viene passato al database con la specifica funzione di escape del database per le stringhe (ad esempio mysql_real_escape_string, sqlite_escape_string, ecc.). Le funzioni generiche come addslashes sono utili solo in un ambiente molto specifico (ad esempio MySQL in un set di caratteri a singolo byte - con NO_BACKSLASH_ESCAPES disabilitato)e quindi è + con NO_BACKSLASH_ESCAPES disabilitato) e quindi è meglio evitarle. mysql_real_escape_string, - Non far visualizare informazioni specifiche del database, in particolare - lo schema , a qualunque costo. Vedere anche la sezione . Vedere anche le sezioniSegnalazione degli errori e Funzioni di gestione e registrazione degli errori. @@ -461,12 +461,12 @@ $stmt->execute(["%{$productId}%"]); - Oltre a ciò, puoi trarre vantaggio dal log delle query da parte del tuo script - o, se lo supporta, dal database stesso. Ovviamente, il log non è in grado + Oltre a ciò, puoi trarre vantaggio dal log delle query tramite il tuo script + o, se lo supporta, attraverso il database stesso. Ovviamente, il log non è in grado di prevenire alcun tentativo d'attacco, ma può essere utile per capire quale applicazione è stata colpita. Il registro non è utile di per sé, ma sono utili le informazioni che contiene. Generalmente più dettagli ci sono nel log meglio è. - + From edb48b41cfd8843e3dfbf77edd1508f7797d645d Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 25 Feb 2025 17:40:06 +0100 Subject: [PATCH 38/49] translation progress database.xml --- security/database.xml | 49 ++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 26 deletions(-) diff --git a/security/database.xml b/security/database.xml index c9c4eeaa0..c2ad99246 100644 --- a/security/database.xml +++ b/security/database.xml @@ -16,7 +16,7 @@ eseguire una query, recuperare il risultato e quindi chiudere la connessione. Oggigiorno, il linguaggio più utilizzato per questo tipo di interazione è l'SQL (Structured Query Language). Di seguito viene mostrato come un'aggressore può manometterelo con una query SQL. + linkend="security.database.sql-injection">manometterlo con una query SQL. Da come si può immaginare, PHP non può proteggere da solo il database. @@ -31,7 +31,7 @@ - Progetazione del database + Progettazione del database Il primo passo è quello di creare il database, a meno che non si voglia utilizzarne uno di terze parti. Una volta creato il database, viene assegnato un proprietario, @@ -41,7 +41,7 @@ Le applicazioni non dovrebbero mai connettersi al database come proprietario o - amministratore, poichè questi utenti possono eseguire qualsiasi query a piacimento, + amministratore, poiché questi utenti possono eseguire qualsiasi query a piacimento, ad esempio, potrebbero modificare lo schema (ad esempio eliminando le tabelle) o potrebbero eliminare l'intero contenuto. @@ -207,11 +207,11 @@ insert into pg_shadow(usename,usesysid,usesuper,usecatupd,passwd) Un modo possibile per ottenere le password è analizzare le pagine dei risultati di ricerca. L'unica cosa che l'attaccante deve fare è vedere se sono presenti variabili inviate utilizzate nelle istruzioni SQL che non vengono gestite correttamente. Questi filtri di solito possono essere impostati - in un form usato precedentemente e personalizzarlo usando le clausule WHERE, ORDER BY, + in un form usato precedentemente e personalizzarlo usando le clausole WHERE, ORDER BY, LIMIT e OFFSET nell'istruzione SELECT. Se il database supporta il costrutto UNION, l'aggressore potrebbe tentare di aggiungere un'intera query a quella originale per far elencare - le password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password + le password da una tabella arbitraria. Si consiglia vivamente di salvare sole le secure hash delle password anziché le password stesse. Elencare gli articoli... e alcune password (può essere usato su qualunque database server). @@ -228,7 +228,7 @@ $result = odbc_exec($conn, $query); La parte statica della query può essere combinata con un'altra SELECT - che rivela tutte le password: + per rivelare tutte le password: Anche le istruzioni UPDATE e INSERT sono suscettibili a tali attacchi. - - - Dalla reimpostazione di una password... all'acquisizione di più privilegi (qualsiasi database server) - + Dalla reimpostazione di una password... all'acquisizione di più privilegi (per qualsiasi database server) Se un utente malintenzionato invia la stringa - ' or uid like '%admin% in $uid per - cambiare la password dell'amministratore oppure impostare la variabile $pwd semplicemente con + per cambiare la password dell'amministratore + ' or uid like '%admin% in $uid + oppure impostare la variabile $pwd semplicemente con hehehe', trusted=100, admin='yes per ottenere - privilegi più elevati, la query verrà corrotta: + privilegi più elevati, la query verrà aggirata: - + Mentre è scontato che un malintenzionato debba possederne almeno alcune nozioni - dell'architettura del database per condurre un'attacco riuscito , + dell'architettura del database per condurre un'attacco ben riuscito , è spesso molto semplice ottenere queste informazioni. Per esempio, il codice può far parte di un software open source ed essere disponibile al pubblico. Tali informazioni potranno anche essere divulgate @@ -357,13 +354,13 @@ $result = mssql_query($query); Tecniche di elusione - Il modo consigliato per evitare l'SQL injection è associare tutti i dati - tramite istruzioni preparate. L'utilizzo di query parametrizzate non è - sufficiente per evitare completamente l'iniezione SQL, ma è il modo più - semplice e sicuro per fornire input alle istruzioni SQL. Tutti i letterali + Un modo consigliato per evitare l'SQL injection è associare tutti i dati + usando prepared-statements. L'utilizzo di query parametrizzate non è + sufficiente per evitare completamente l'injection SQL, ma è il modo più + semplice e sicuro per fornire l'input alle istruzioni SQL. Tutti i letterali di dati dinamici nelle clausole WHERE, SET e VALUES devono essere sostituiti - con segnaposto. I dati effettivi verranno associati durante l'esecuzione e + con un segnaposto. I dati effettivi verranno trasposti durante l'esecuzione e inviati separatamente dal comando SQL. @@ -371,20 +368,20 @@ $result = mssql_query($query); Il binding dei parametri può essere utilizzato solo per i dati. Altre parti dinamiche della query SQL devono essere filtrate in base a un elenco noto di valori consentiti. - + - Eludere un'SQL injection usando PDO prepared Statement - Avoiding SQL injection by using PDO prepared statements + Eludere un'SQL injection usando PDO prepared Statement prepare("SELECT * FROM products WHERE id LIKE ? ORDER BY price {$sortingOrder}"); -// The value is provided with LIKE wildcards +// Il valore è reso disponibile usando LIKE $stmt->execute(["%{$productId}%"]); ?> From 9b86065d2d1bd4d4ca05f596aa537e7c6266cbd0 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Tue, 25 Feb 2025 17:57:24 +0100 Subject: [PATCH 39/49] typo fixed --- security/database.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/security/database.xml b/security/database.xml index c2ad99246..1b69433a1 100644 --- a/security/database.xml +++ b/security/database.xml @@ -9,7 +9,7 @@ applicazione basata sul Web, consentendo ai siti Web di fornire molti contenuti dinamici. Poiché anche le informazioni sensibili o segrete possono essere archiviate in un database, dovresti prendere seriamente in considerazione di - protegere i tuoi database. + proteggere i tuoi database. Per recuperare o archiviare qualsiasi informazione di cui hai bisogno per connetterti al database, @@ -257,7 +257,7 @@ $query = "UPDATE usertable SET pwd='$pwd' WHERE uid='$uid';"; ' or uid like '%admin% in $uid oppure impostare la variabile $pwd semplicemente con hehehe', trusted=100, admin='yes per ottenere - privilegi più elevati, la query verrà aggirata: + privilegi più elevati, la query verrà aggirata: Date: Tue, 25 Feb 2025 18:11:34 +0100 Subject: [PATCH 40/49] some fix --- security/cgi-bin.xml | 4 ++-- security/errors.xml | 4 ++-- security/intro.xml | 2 +- security/sessions.xml | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index 100ce270f..fc04bd69a 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -76,7 +76,7 @@ - 1° Caso :solo files publici elaborati + 1° Caso :solo files pubblici elaborati Se il tuo server non ha alcun contenuto e non è protetto @@ -138,7 +138,7 @@ AddHandler php-script .php directory dei documenti del server Web è talvolta considerato una pratica non sicura. Se, a causa di un errore di configurazione, gli script non vengono eseguiti ma visualizzati come normali documenti HTML, - ciò può causare la perdita di proprietà intellettuale o far visualizare informazioni di + ciò può causare la perdita di proprietà intellettuale o far visualizzare informazioni di sicurezza come le password. Pertanto, molti amministratori di sistema preferiranno impostare un'altra struttura di directory per gli script accessibili solo tramite PHP CGI e quindi saranno sempre interpretati e diff --git a/security/errors.xml b/security/errors.xml index b1e13cb59..59593b0ea 100644 --- a/security/errors.xml +++ b/security/errors.xml @@ -8,10 +8,10 @@ Segnalazione degli errori Dal punto di vista della sicurezza di PHP, ci sono due aspetti nella segnalazione degli errori. Uno è - utile per aumentarene la sicurezza, l’altro è dannoso. + utile per aumentarne la sicurezza, l’altro è dannoso. - Una tattica d'attacco di solito prevede la profilazione di un sistema reperendo + Una tattica d'attacco di solito prevede la profiliazione di un sistema reperendo dati dagli errori, dal controllo dei tipi e dai contesti degli errori che vengono restituiti. Ciò consente al cracker del sistema di analizzare le informazioni del server, per determinare possibili punti deboli. diff --git a/security/intro.xml b/security/intro.xml index 274d96564..ef11cf478 100644 --- a/security/intro.xml +++ b/security/intro.xml @@ -3,7 +3,7 @@ - Introduction + Introduzione PHP è un linguaggio potente e l'interprete, che sia incluso in un server web come modulo o eseguito come binario separato CGI, è in grado di accedere ai file, eseguire diff --git a/security/sessions.xml b/security/sessions.xml index 73d2add0e..6328797a6 100644 --- a/security/sessions.xml +++ b/security/sessions.xml @@ -1,7 +1,7 @@ - Securezza della sessione + Sicurezza della sessione È importante mantenere sicura la gestione delle sessioni HTTP. From 7984b04c06b435d521d969ba20464a4da149d909 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 27 Feb 2025 13:08:42 +0100 Subject: [PATCH 41/49] mod variables.xml --- security/variables.xml | 43 ++++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 20 deletions(-) diff --git a/security/variables.xml b/security/variables.xml index 7fd9e6c96..e709420a9 100644 --- a/security/variables.xml +++ b/security/variables.xml @@ -7,24 +7,25 @@ Dati inviati dall'utente - La più grande debolezza in molti programmi scritti in PHP non è insita nel - linguaggio stesso, ma semplicemente un problema di codice scritto non tenendo - a mente la sicurezza. Per questo motivo, dovresti sempre prenderti il ​​tempo - di considerare le implicazioni di una certa parte di codice, per accertare - il possibile malfunzionamento se gli viene inviata una variabile inaspettata. + La più grande debolezza di molti programmi scritti in PHP + non è insita nel linguaggio, ma semplicemente un problema di codice scritto + non tenendo a mente la sicurezza. Per questo motivo, dovresti sempre prenderti + il ​​tempo di considerare le implicazioni di una certa parte di codice, per + accertare il possibile malfunzionamento se gli viene inviata una variabile + inaspettata. Utilizzo pericoloso delle variabili - Dovresti sempre esaminare attentamente il tuo codice per assicurarti + Bisognerebbe esaminare attentamente il codice per assicurarci che tutte le variabili inviate da un browser web siano state correttamente - controllate e farti le seguenti domande: + controllate e porsi le seguenti domande: @@ -67,18 +68,20 @@ exec ($evil_var); Ponendosi queste domande durante la scrittura dello script, - piuttosto che farsele dopo, previeni una riscrittura difficoltosa quando - si ha invece bisogno di migliorare la sicurezza. Iniziando usare queste regole, - non si garantisce la sicurezza del sistema, ma si può contribuire a + piuttosto che farsele dopo, si previene una difficile riscrittura quando + invece si ha bisogno di migliorarne la sicurezza. Iniziando a usare queste + regole, non si garantisce la sicurezza del sistema, ma si può contribuire a migliorarlo. - Potresti anche voler disattivare register_globals, - magic_quotes o altre impostazioni utili che potrebbero confonderti - sulla validità, la fonte o il valore di una determinata variabile. - Lavorare con PHP in modalità error_reporting(E_ALL) può - anche aiutare ad informarti sulle variabili utilizzate prima che vengano - controllate o inizializzate (in modo da impedire che vengano utilizzati dati insoliti). + Si potrebbe anche voler disattivare register_globals, + magic_quotes o altre impostazioni utili che potrebbero + renderne meno chiare la validità, la fonte o il valore + di una determinata variabile. Lavorare con + PHP in modalità error_reporting(E_ALL) può + anche aiutare ad informare sulle variabili utilizzate prima che vengano + controllate o inizializzate (in modo da impedire che vengano utilizzati + dati insoliti). From 0b525998e32c01c826eb666441b4a83fda2acc19 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 27 Feb 2025 14:42:45 +0100 Subject: [PATCH 42/49] review cgi-bin.xml to finish --- security/cgi-bin.xml | 63 +++++++++++++++++++++++++++++++------------- 1 file changed, 44 insertions(+), 19 deletions(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index fc04bd69a..8b2af294e 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -1,6 +1,7 @@ + PHP installato come binario CGI @@ -8,13 +9,13 @@ Possibili attacchi - L'utilizzo di PHP come binario CGI è un'opzione che ne permette l'uso se per qualche - motivo non lo si voglia integrare come modulo del server (come Apache) - sia per utilizzarlo con diversi tipi di wrapper CGI che per creare - con chroot e setuid ambienti - sicuri per gli script. Questa configurazione di solito prevede l'installazione - del'eseguibile php nella directory del server web - cgi-bin. + L'utilizzo di PHP come binario CGI è un'opzione che ne + permette l'uso se per qualche motivo non lo si voglia integrare come + modulo del server (come Apache) sia per utilizzarlo con diversi tipi + di wrapper CGI che per creare con chroot + e setuid ambienti sicuri per gli script. Questa configurazione + di solito prevede l'installazione del'eseguibile php + nella directory del server web cgi-bin. L'informativa CERT CA-96.11 sconsiglia di posizionare interpreti in cgi-bin. Invece il binario php può essere utilizzato in modo autonomo, @@ -27,14 +28,15 @@ role="url">http://my.host/cgi-bin/php?/etc/passwd - Le informazioni di una query ovvero la parte dell'URL dopo il punto interrogativo (?) vengono - passate come argomenti dalla riga di comando dall'interfaccia CGI all'interprete. - Di solito gli interpreti aprono ed eseguono il file - specificato specificato nel primo argomento della riga di comando. + Le informazioni di una query ovvero la parte dell'URL dopo il punto + interrogativo (?) vengono passate come argomenti + dalla riga di comando dall'interfaccia CGI all'interprete. Di solito + gli interpreti aprono ed eseguono il file specificato specificato + nel primo argomento della riga di comando. - Quando PHP viene invocato come binario CGI, php non interpreta - gli argomenti della riga di comando. + Quando PHP viene invocato come binario CGI, php + non interpreta gli argomenti della riga di comando. @@ -48,11 +50,11 @@ convenzionalmente usate per specificare il nome dello script da aprire e interpretare dal programma CGI. Solitamente alcune direttive nella configurazione del server web (Apache: - Action) sono usate per reindirizzare le richieste di documenti come - http://my.host/secret/script.php all'interprete PHP. Con questa configurazione, - il server web prima controlla i permessi di accesso alla directory /secret, e poi crea la richiesta che viene reindirizzata a Action) sono usate per reindirizzare le richieste di + documenti come http://my.host/secret/script.php all'interprete PHP. + Con questa configurazione, il server web prima controlla i permessi + di accesso alla directory /secret, + e poi crea la richiesta che viene reindirizzata a http://my.host/cgi-bin/php/secret/script.php. Purtroppo, se la richiesta è fatta originariamente in questo modo, il server web non esegue alcun controllo di accesso al file 1° Caso :solo files pubblici elaborati - Se il tuo server non ha alcun contenuto e non è protetto + + Se il tuo server non ha alcun contenuto che e non è protetto da password o un controllo d'accesso basato su IP, non c'è bisogno di questa configurazione. Se il tuo server web non ti consente di effettuare reindirizzamenti, o non hai un modo per From afa2b4fdc5006c2c6b378742f7360d5f82ffc786 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 27 Feb 2025 20:43:46 +0100 Subject: [PATCH 43/49] check cgi-bin.xml --- security/cgi-bin.xml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index 8b2af294e..4d91a1293 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -10,12 +10,12 @@ Possibili attacchi L'utilizzo di PHP come binario CGI è un'opzione che ne - permette l'uso se per qualche motivo non lo si voglia integrare come - modulo del server (come Apache) sia per utilizzarlo con diversi tipi - di wrapper CGI che per creare con chroot - e setuid ambienti sicuri per gli script. Questa configurazione - di solito prevede l'installazione del'eseguibile php - nella directory del server web cgi-bin. + permette l'uso nel caso non lo si voglia integrare come modulo del server + (come Apache) sia per utilizzarlo con diversi tipi di wrapper CGI + che per creare con chroot e setuid + ambienti sicuri per gli script. Questa configurazione di solito prevede + l'installazione dell'eseguibile php nella directory + del server web cgi-bin. L'informativa CERT CA-96.11 sconsiglia di posizionare interpreti in cgi-bin. Invece il binario php può essere utilizzato in modo autonomo, @@ -31,8 +31,8 @@ Le informazioni di una query ovvero la parte dell'URL dopo il punto interrogativo (?) vengono passate come argomenti dalla riga di comando dall'interfaccia CGI all'interprete. Di solito - gli interpreti aprono ed eseguono il file specificato specificato - nel primo argomento della riga di comando. + gli interpreti aprono ed eseguono il file specificato nel primo + argomento della riga di comando. Quando PHP viene invocato come binario CGI, php @@ -42,7 +42,7 @@ Accesso a qualsiasi documento web sul server:http://my.host/cgi-bin/php/secret/doc.html + role="url">http://my.host/cgi-bin/php/secret/doc.html Le informazioni sull'URL dopo il nome del binario PHP, From 56964ec443aab6df497dc226a2b91b45aa918d48 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 27 Feb 2025 22:48:34 +0100 Subject: [PATCH 44/49] improve the translation cgi-bin.xml --- security/cgi-bin.xml | 51 ++++++++++++-------------------------------- 1 file changed, 14 insertions(+), 37 deletions(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index 4d91a1293..5170d4440 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -42,13 +42,13 @@ Accesso a qualsiasi documento web sul server:http://my.host/cgi-bin/php/secret/doc.html + role="url">http://my.host/cgi-bin/php/secret/doc.html Le informazioni sull'URL dopo il nome del binario PHP, /secret/doc.html sono convenzionalmente usate per specificare il nome dello script da - aprire e interpretare dal programma CGI. + aprire e da interpretare dal programma CGI. Solitamente alcune direttive nella configurazione del server web (Apache: Action) sono usate per reindirizzare le richieste di documenti come http://my.host/secret/script.php all'interprete PHP. @@ -78,43 +78,20 @@ - 1° Caso :solo files pubblici elaborati + 1° Caso: solo files pubblici elaborati - - - Se il tuo server non ha alcun contenuto che e non è protetto + + Se il server non ha alcun contenuto che non è protetto da password o un controllo d'accesso basato su IP, non c'è bisogno di - questa configurazione. Se il tuo server web non ti consente - di effettuare reindirizzamenti, o non hai un modo per - comunicare all'eseguibile di PHP che la richiesta è una richiesta reindirizzata in modo sicuro, puoi abilitare la + usare questa configurazione. Se il server web non consente di + effettuare reindirizzamenti, o non c'è un modo per + comunicare all'eseguibile di PHP che la richiesta è una + richiesta di reindirizzamento sicuro, è possibile abilitare la direttiva cgi.force_redirect.ini. - Devi comunque assicurarti che i tuoi script PHP - non usino nè un modo ne l'altro modo di chiamare lo script, - né direttamente http://my.host/cgi-bin/php/dir/script.php - né tramite reindirizzamento http://my.host/cgi-bin/php/dir/script.php + né indirettamente http://my.host/dir/script.php. @@ -124,7 +101,7 @@ Il reindirizzamento può essere configurato in Apache utilizzando la sintassi - 2° Caso : utilizzo di <literal>cgi.force_redirect</literal> + 2° Caso: utilizzo di <literal>cgi.force_redirect</literal> La configurazione della direttiva cgi.force_redirect From a68ca5fe14058fac34bb83944dc5f658b39e047f Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 27 Feb 2025 23:21:37 +0100 Subject: [PATCH 45/49] improve the translation cgi-bin.xml --- security/cgi-bin.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index 5170d4440..ccc45c5ef 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -93,7 +93,7 @@ né direttamente http://my.host/cgi-bin/php/dir/script.php né indirettamente http://my.host/dir/script.php. - + Il reindirizzamento può essere configurato in Apache utilizzando AddHandler e la direttiva Action (vedi sotto). From fd1a8ebce85ebc009aa98b59a06f75367483a7f7 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Sat, 1 Mar 2025 20:12:01 +0100 Subject: [PATCH 46/49] Improved and revised translation cgi-bin.xml --- security/cgi-bin.xml | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index ccc45c5ef..848a6a613 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -3,16 +3,17 @@ + PHP installato come binario CGI Possibili attacchi - L'utilizzo di PHP come binario CGI è un'opzione che ne - permette l'uso nel caso non lo si voglia integrare come modulo del server - (come Apache) sia per utilizzarlo con diversi tipi di wrapper CGI - che per creare con chroot e setuid + Usare di PHP come binario CGI è un'opzione che + permette di evitare di integrarlo come modulo del server + (come Apache) oppure per utilizzarlo con diversi tipi di wrapper CGI + o per creare con chroot e setuid ambienti sicuri per gli script. Questa configurazione di solito prevede l'installazione dell'eseguibile php nella directory del server web cgi-bin. @@ -28,9 +29,8 @@ role="url">http://my.host/cgi-bin/php?/etc/passwd - Le informazioni di una query ovvero la parte dell'URL dopo il punto - interrogativo (?) vengono passate come argomenti - dalla riga di comando dall'interfaccia CGI all'interprete. Di solito + Le informazioni contenute nell'URL dopo il punto interogativa (?) + vengono passate come argomenti dalla riga di comando all'interprete tramite interfaccia CGI. Di solito gli interpreti aprono ed eseguono il file specificato nel primo argomento della riga di comando. @@ -40,6 +40,25 @@ + Accesso a qualsiasi documento web sul server:http://my.host/cgi-bin/php/secret/doc.html From 301cc5b6c939c97a945a200109849d5ce2cf17fb Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 5 Mar 2025 12:10:12 +0100 Subject: [PATCH 47/49] fixed sub-issues #13 --- security/cgi-bin.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index 848a6a613..fe9532a11 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -153,7 +153,7 @@ AddHandler php-script .php - 3°: impostare doc_root o user_dir + 3° caso: impostare doc_root o user_dir Includere contenuti attivi, come script ed eseguibili, nelle directory dei documenti del server Web è talvolta considerato From 87f25eb18660b704096023f57c66bd20d0114cf8 Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Wed, 5 Mar 2025 18:07:58 +0100 Subject: [PATCH 48/49] fixed typo cgi-bin --- security/cgi-bin.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/security/cgi-bin.xml b/security/cgi-bin.xml index fe9532a11..3eb6d0108 100644 --- a/security/cgi-bin.xml +++ b/security/cgi-bin.xml @@ -153,7 +153,7 @@ AddHandler php-script .php - 3° caso: impostare doc_root o user_dir + 3° Caso: impostare doc_root o user_dir Includere contenuti attivi, come script ed eseguibili, nelle directory dei documenti del server Web è talvolta considerato From 2c08a7f6d7bbb7e69e11db8ee324e1b515609d4a Mon Sep 17 00:00:00 2001 From: Manuel della Gala <74384683+ManueldG@users.noreply.github.com> Date: Thu, 6 Mar 2025 01:15:03 +0100 Subject: [PATCH 49/49] update security/variables to complete update EN version security/variables.xml --- security/variables.xml | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-) diff --git a/security/variables.xml b/security/variables.xml index e709420a9..fa73cb3a9 100644 --- a/security/variables.xml +++ b/security/variables.xml @@ -1,6 +1,7 @@ - + + @@ -66,23 +67,33 @@ exec ($evil_var); - + Ponendosi queste domande durante la scrittura dello script, piuttosto che farsele dopo, si previene una difficile riscrittura quando invece si ha bisogno di migliorarne la sicurezza. Iniziando a usare queste regole, non si garantisce la sicurezza del sistema, ma si può contribuire a - migliorarlo. + migliorarlo. + + + Migliorare la sicurezza disabilitando le impostazioni utili per nascondere + l'origine dei dati, la validità o l'integrità dell'input. La creazione di variabili implicite e + l'input incontrollato può portare a vulnerabilità come attacchi di injection e + manipolazione dei dati. - Si potrebbe anche voler disattivare register_globals, - magic_quotes o altre impostazioni utili che potrebbero - renderne meno chiare la validità, la fonte o il valore - di una determinata variabile. Lavorare con - PHP in modalità error_reporting(E_ALL) può - anche aiutare ad informare sulle variabili utilizzate prima che vengano - controllate o inizializzate (in modo da impedire che vengano utilizzati - dati insoliti). + Funzionalità come register_globals e + magic_quotes (entrambi rimossi in PHP 5.4.0) hanno contribuito + ad agevolare questi rischi creando automaticamente variabili dall'input dell'utente e + escape dai dati in modo incoerente. Sebbene queste funzioni non siano più in PHP, persistono rischi simili + se la gestione dell'input è gestita in modo errato. + + Abilitare error_reporting(E_ALL) + aiuta a rilevare le variabili non inizializzate e a convalidare l'input. Utilizzare la modalità strict + (declare(strict_types=1), + introdotto in PHP 7) per garantire la sicurezza dei tipi, prevenire conversioni involontarie, + e migliorare la sicurezza generale. +