Infrastruttura di sicurezza: convalida dell'input - Procedure di mitigazioneSecurity Frame: Input Validation | Mitigations

Prodotto o servizioProduct/Service ArticoloArticle
Applicazione WebWeb Application
DatabaseDatabase
API WebWeb API
Azure Document DBAzure Document DB
WCFWCF

Disabilitare gli script XSLT per tutte le trasformazioni con fogli di stile non attendibiliDisable XSLT scripting for all transforms using untrusted style sheets

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Sicurezza XSLT , Proprietà XsltSettings.EnableScriptXSLT Security, XsltSettings.EnableScript Property
PassaggiSteps XSLT supporta l'inserimento di script all'interno dei fogli di stile con l'elemento <msxml:script>.XSLT supports scripting inside style sheets using the <msxml:script> element. Ciò consente di usare funzioni personalizzate in una trasformazione XSLT.This allows custom functions to be used in an XSLT transformation. Lo script viene eseguito nel contesto del processo che esegue la trasformazione.The script is executed under the context of the process performing the transform. Lo script XSLT può essere disabilitato in un ambiente non attendibile per impedire l'esecuzione di codice non attendibile.XSLT script must be disabled when in an untrusted environment to prevent execution of untrusted code. Se si usa .NET, gli script XSLT sono disabilitati per impostazione predefinita. È tuttavia necessario verificare che non siano stati abilitati in modo esplicito tramite la proprietà XsltSettings.EnableScript.If using .NET: XSLT scripting is disabled by default; however, you must ensure that it has not been explicitly enabled through the XsltSettings.EnableScript property.

EsempioExample

XsltSettings settings = new XsltSettings();
settings.EnableScript = true; // WRONG: THIS SHOULD BE SET TO false

EsempioExample

Se si usa MSXML 6.0, gli script XSLT sono disabilitati per impostazione predefinita. È tuttavia necessario verificare che non siano stati abilitati in modo esplicito tramite la proprietà AllowXsltScript dell'oggetto DOM XML.If you are using using MSXML 6.0, XSLT scripting is disabled by default; however, you must ensure that it has not been explicitly enabled through the XML DOM object property AllowXsltScript.

doc.setProperty("AllowXsltScript", true); // WRONG: THIS SHOULD BE SET TO false

EsempioExample

Se si usa MSXML 5 o versione inferiore, gli script XSLT sono abilitati per impostazione predefinita e devono essere disabilitati in modo esplicito.If you are using MSXML 5 or below, XSLT scripting is enabled by default and you must explicitly disable it. Impostare la proprietà AllowXsltScript dell'oggetto DOM XML su false.Set the XML DOM object property AllowXsltScript to false.

doc.setProperty("AllowXsltScript", false); // CORRECT. Setting to false disables XSLT scripting.

Verificare che ogni pagina che potrebbe includere contenuti controllabili dall'utente rifiuti esplicitamente l'analisi MIME automaticaEnsure that each page that could contain user controllable content opts out of automatic MIME sniffing

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences IE8 Security Part V: Comprehensive Protection (Sicurezza di IE8 parte V: protezione completa)IE8 Security Part V - Comprehensive Protection
PassaggiSteps

Per ogni pagina che potrebbe includere contenuti controllabili dall'utente, è necessario usare l'intestazione HTTP X-Content-Type-Options:nosniff.For each page that could contain user controllable content, you must use the HTTP Header X-Content-Type-Options:nosniff. Per rispettare questo requisito, è possibile impostare l'intestazione necessaria pagina per pagina solo per le pagine che potrebbero includere contenuti controllabili dall'utente oppure eseguire l'impostazione a livello globale per tutte le pagine nell'applicazione.To comply with this requirement, you can either set the required header page by page for only those pages that might contain user-controllable content, or you can set it globally for all pages in the application.

A ogni tipo di file fornito da un server Web è associato un tipo MIME (denominato anche content-type) che descrive la natura del contenuto (immagine, testo, applicazione e così via).Each type of file delivered from a web server has an associated MIME type (also called a content-type) that describes the nature of the content (that is, image, text, application, etc.)

L'intestazione X-Content-Type-Options è un'intestazione HTTP che consente agli sviluppatori di specificare che il contenuto non deve essere sottoposto ad analisi MIME.The X-Content-Type-Options header is an HTTP header that allows developers to specify that their content should not be MIME-sniffed. Questa intestazione è progettata per mitigare gli attacchi basati sull'analisi MIME.This header is designed to mitigate MIME-Sniffing attacks. Il supporto per questa intestazione è stato aggiunto in Internet Explorer 8 (IE8).Support for this header was added in Internet Explorer 8 (IE8)

Solo gli utenti di Internet Explorer 8 (IE8) potranno usufruire di X-Content-Type-Options.Only users of Internet Explorer 8 (IE8) will benefit from X-Content-Type-Options. Le versioni precedenti di Internet Explorer attualmente non rispettano l'intestazione X-Content-Type-Options.Previous versions of Internet Explorer do not currently respect the X-Content-Type-Options header

Internet Explorer 8 e le versioni successive sono gli unici browser principali che implementano una funzionalità di rifiuto esplicito dell'analisi MIME.Internet Explorer 8 (and later) are the only major browsers to implement a MIME-sniffing opt-out feature. Se e quando gli altri browser principali (Firefox, Safari e Chrome) implementeranno funzionalità simili, questa raccomandazione verrà aggiornata per includere anche la sintassi per tali browser.If and when other major browsers (Firefox, Safari, Chrome) implement similar features, this recommendation will be updated to include syntax for those browsers as well

EsempioExample

Per abilitare l'intestazione necessaria a livello globale per tutte le pagine nell'applicazione, eseguire una di queste operazioni:To enable the required header globally for all pages in the application, you can do one of the following:

  • Aggiungere l'intestazione nel file web.config se l'applicazione è ospitata da Internet Information Services (IIS) 7Add the header in the web.config file if the application is hosted by Internet Information Services (IIS) 7
<system.webServer> 
  <httpProtocol> 
    <customHeaders> 
      <add name=""X-Content-Type-Options"" value=""nosniff""/>
    </customHeaders>
  </httpProtocol>
</system.webServer> 
  • Aggiungere l'intestazione tramite Application_BeginRequest globaleAdd the header through the global Application_BeginRequest
void Application_BeginRequest(object sender, EventArgs e)
{
  this.Response.Headers[""X-Content-Type-Options""] = ""nosniff"";
} 
  • Implementare un modulo HTTP personalizzatoImplement custom HTTP module
public class XContentTypeOptionsModule : IHttpModule 
  {
    #region IHttpModule Members 
    public void Dispose() 
    { 

    } 
    public void Init(HttpApplication context)
    { 
      context.PreSendRequestHeaders += newEventHandler(context_PreSendRequestHeaders); 
    } 
    #endregion 
    void context_PreSendRequestHeaders(object sender, EventArgs e) 
      { 
        HttpApplication application = sender as HttpApplication; 
        if (application == null) 
          return; 
        if (application.Response.Headers[""X-Content-Type-Options ""] != null) 
          return; 
        application.Response.Headers.Add(""X-Content-Type-Options "", ""nosniff""); 
      } 
  } 
  • È possibile abilitare l'intestazione necessaria solo per pagine specifiche aggiungendola a singole risposte:You can enable the required header only for specific pages by adding it to individual responses:
this.Response.Headers[""X-Content-Type-Options""] = ""nosniff""; 

Applicare la protezione avanzata o la disabilitazione della risoluzione di entità XMLHarden or Disable XML Entity Resolution

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Espansione di entità XML, Attacchi Denial of Service e difese in XML, Cenni preliminari sulla sicurezza MSXML, Procedure consigliate per la protezione del codice MSXML, Informazioni di riferimento sul protocollo NSXMLParserDelegate, Risoluzione di riferimenti esterniXML Entity Expansion, XML Denial of Service Attacks and Defenses, MSXML Security Overview, Best Practices for Securing MSXML Code, NSXMLParserDelegate Protocol Reference, Resolving External References
PassaggiSteps

Nonostante non sia largamente usata, esiste una funzionalità di XML che consente al parser XML di espandere macro entità con valori definiti all'interno del documento stesso o da origini esterne.Although it is not widely used, there is a feature of XML that allows the XML parser to expand macro entities with values defined either within the document itself or from external sources. Ad esempio, il documento potrebbe definire un'entità "companyname" con il valore "Microsoft" in modo che ogni occorrenza del testo "&companyname;" nel documento venga automaticamente sostituita con il testo "Microsoft".For example, the document might define an entity "companyname" with the value "Microsoft," so that every time the text "&companyname;" appears in the document, it is automatically replaced with the text Microsoft. In alternativa, il documento potrebbe definire un'entità "MSFTStock" che fa riferimento a un servizio Web esterno per recuperare il valore corrente delle azioni Microsoft.Or, the document might define an entity "MSFTStock" that references an external web service to fetch the current value of Microsoft stock.

Ogni occorrenza di "&MSFTStock;" nel documento verrà quindi automaticamente sostituita con il prezzo corrente del titolo azionario.Then any time "&MSFTStock;" appears in the document, it is automatically replaced with the current stock price. Questa funzionalità può tuttavia essere usata in modo improprio per creare condizioni di Denial of Service (DoS).However, this functionality can be abused to create denial of service (DoS) conditions. Un utente malintenzionato può annidare più entità per creare un'espansione esponenziale di XML che userà tutta la memoria disponibile nel sistema.An attacker can nest multiple entities to create an exponential expansion XML bomb that consumes all available memory on the system.

In alternativa, può creare un riferimento esterno che trasmette una quantità infinita di dati o semplicemente blocca il thread.Alternatively, he can create an external reference that streams back an infinite amount of data or that simply hangs the thread. Di conseguenza, tutti i team devono disabilitare interamente la risoluzione di entità XML interne e/o esterne se non viene usata dall'applicazione oppure, se tale funzionalità è assolutamente necessaria, limitare manualmente la quantità di memoria e di tempo utilizzabile dall'applicazione per la risoluzione di entità.As a result, all teams must disable internal and/or external XML entity resolution entirely if their application does not use it, or manually limit the amount of memory and time that the application can consume for entity resolution if this functionality is absolutely necessary. Se la risoluzione di entità non è richiesta dall'applicazione, disabilitarla.If entity resolution is not required by your application, then disable it.

EsempioExample

Per il codice .NET Framework, è possibile usare gli approcci seguenti:For .NET Framework code, you can use the following approaches:

XmlTextReader reader = new XmlTextReader(stream);
reader.ProhibitDtd = true;

XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = true;
XmlReader reader = XmlReader.Create(stream, settings);

// for .NET 4
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Prohibit;
XmlReader reader = XmlReader.Create(stream, settings);

Si noti che il valore predefinito di ProhibitDtd in XmlReaderSettings è true, ma in XmlTextReader è false.Note that the default value of ProhibitDtd in XmlReaderSettings is true, but in XmlTextReader it is false. Se si usa XmlReaderSettings, non è necessario impostare ProhibitDtd su true in modo esplicito, ma è consigliabile ai fini della sicurezza.If you are using XmlReaderSettings, you do not need to set ProhibitDtd to true explicitly, but it is recommended for safety sake that you do. Si noti anche che la classe XmlDocument consente la risoluzione di entità per impostazione predefinita.Also note that the XmlDocument class allows entity resolution by default.

EsempioExample

Per disabilitare la risoluzione di entità per le classi XmlDocument, usare l'overload XmlDocument.Load(XmlReader) del metodo Load e impostare le proprietà appropriate nell'argomento XmlReader per disabilitare la risoluzione, come illustrato nel codice seguente:To disable entity resolution for XmlDocuments, use the XmlDocument.Load(XmlReader) overload of the Load method and set the appropriate properties in the XmlReader argument to disable resolution, as illustrated in the following code:

XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = true;
XmlReader reader = XmlReader.Create(stream, settings);
XmlDocument doc = new XmlDocument();
doc.Load(reader);

EsempioExample

Se non è possibile disabilitare la risoluzione di entità per l'applicazione, impostare la proprietà XmlReaderSettings.MaxCharactersFromEntities su un valore ragionevole in base alle esigenze dell'applicazione.If disabling entity resolution is not possible for your application, set the XmlReaderSettings.MaxCharactersFromEntities property to a reasonable value according to your application's needs. Verrà così limitato l'impatto dei potenziali attacchi DoS con espansione esponenziale.This will limit the impact of potential exponential expansion DoS attacks. Il codice seguente offre un esempio di questo approccio:The following code provides an example of this approach:

XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
settings.MaxCharactersFromEntities = 1000;
XmlReader reader = XmlReader.Create(stream, settings);

EsempioExample

Se è necessario risolvere entità incorporate ma non entità esterne, impostare la proprietà XmlReaderSettings.XmlResolver su null.If you need to resolve inline entities but do not need to resolve external entities, set the XmlReaderSettings.XmlResolver property to null. Ad esempio:For example:

XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
settings.MaxCharactersFromEntities = 1000;
settings.XmlResolver = null;
XmlReader reader = XmlReader.Create(stream, settings);

Si noti che in MSXML6, la proprietà ProhibitDTD è impostata su true (in modo da disabilitare l'elaborazione DTD) per impostazione predefinita.Note that in MSXML6, ProhibitDTD is set to true (disabling DTD processing) by default. Per il codice Apple OSX/iOS, è possibile usare due parser XML: NSXMLParser e libXML2.For Apple OSX/iOS code, there are two XML parsers you can use: NSXMLParser and libXML2.

Verifica della canonizzazione degli URL nelle applicazioni che utilizzano http.sysApplications utilizing http.sys perform URL canonicalization verification

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences N/DN/A
PassaggiSteps

Tutte le applicazioni che usano http.sys devono seguire le linee guida seguenti:Any application that uses http.sys should follow these guidelines:

  • Limitare la lunghezza degli URL a non oltre 16.384 caratteri (ASCII o Unicode).Limit the URL length to no more than 16,384 characters (ASCII or Unicode). Questa è la lunghezza massima assoluta degli URL in base all'impostazione predefinita di Internet Information Services (IIS) 6.This is the absolute maximum URL length based on the default Internet Information Services (IIS) 6 setting. Se possibile, i siti Web devono cercare di mantenere una lunghezza inferiore a tale massimo.Websites should strive for a length shorter than this if possible
  • Usare le classi di I/O file standard di .NET Framework (come FileStream), perché sfruttano le regole di canonizzazione di .NET FX.Use the standard .NET Framework file I/O classes (such as FileStream) as these will take advantage of the canonicalization rules in the .NET FX
  • Compilare in modo esplicito un elenco di nomi file noti consentiti.Explicitly build an allow-list of known filenames
  • Rifiutare in modo esplicito i nomi file noti che non verranno gestiti con rifiuti tramite UrlScan, ossia i file con estensione exe, bat, cmd, com, htw, ida, idq, htr, idc, shtm[l], stm, printer, ini, pol e dat.Explicitly reject known filetypes you will not serve UrlScan rejects: exe, bat, cmd, com, htw, ida, idq, htr, idc, shtm[l], stm, printer, ini, pol, dat files
  • Rilevare le eccezioni seguenti:Catch the following exceptions:
    • System.ArgumentException (per i nomi di dispositivo)System.ArgumentException (for device names)
    • System.NotSupportedException (per i flussi di dati)System.NotSupportedException (for data streams)
    • System.IO.FileNotFoundException (per i nomi file preceduti da carattere di escape non validi)System.IO.FileNotFoundException (for invalid escaped filenames)
    • System.IO.DirectoryNotFoundException (per le directory precedute da carattere di escape non valide)System.IO.DirectoryNotFoundException (for invalid escaped dirs)
  • Non chiamare API di I/O file Win32.Do not call out to Win32 file I/O APIs. In caso di URL non valido, restituire automaticamente un errore 400 all'utente e registrare l'errore effettivo.On an invalid URL gracefully return a 400 error to the user, and log the real error.

Verificare la presenza dei controlli appropriati quando si accettano file dagli utentiEnsure appropriate controls are in place when accepting files from users

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Unrestricted File Upload (Caricamento di file senza restrizioni), File Signature Table (Tabella delle firme dei file)Unrestricted File Upload, File Signature Table
PassaggiSteps

I file caricati rappresentano un rischio significativo per le applicazioni.Uploaded files represent a significant risk to applications.

Il primo passaggio di numerosi attacchi consiste nell'inserire codice nel sistema da attaccare.The first step in many attacks is to get some code to the system to be attacked. È quindi sufficiente trovare un modo per far sì che il codice venga eseguito.Then the attack only needs to find a way to get the code executed. Il caricamento di un file consente all'utente malintenzionato di portare a termine il primo passaggio.Using a file upload helps the attacker accomplish the first step. Le conseguenze del caricamento di file senza restrizioni possono variare dalla completa acquisizione della proprietà del sistema al sovraccarico del file system o del database, all'inoltro di attacchi ai sistemi back-end e al semplice danneggiamento.The consequences of unrestricted file upload can vary, including complete system takeover, an overloaded file system or database, forwarding attacks to back-end systems, and simple defacement.

Ciò dipende da come il file caricato viene usato dall'applicazione e soprattutto dalla posizione in cui viene archiviato.It depends on what the application does with the uploaded file and especially where it is stored. La convalida sul lato server dei caricamenti di file non è disponibile.Server side validation of file uploads is missing. Per la funzionalità di caricamento file devono essere implementati i controlli di sicurezza seguenti:Following security controls should be implemented for File Upload functionality:

  • Controllo dell'estensione di file (deve essere accettato solo un set valido di tipi di file consentiti)File Extension check (only a valid set of allowed file type should be accepted)
  • Limite di dimensione massima dei fileMaximum file size limit
  • I file non devono essere caricati in webroot, ma in una directory in un'unità non di sistemaFile should not be uploaded to webroot; the location should be a directory on non-system drive
  • Deve essere seguita la convenzione di denominazione in modo da garantire una certa casualità nel nome del file caricato e impedire le sovrascritture di fileNaming convention should be followed, such that the uploaded file name have some randomness, so as to prevent file overwrites
  • I file devono essere sottoposti ad analisi antivirus prima della scrittura sul discoFiles should be scanned for anti-virus before writing to the disk
  • Verificare che il nome file e tutti gli altri metadati (ad esempio, il percorso file) vengano convalidati in relazione alla presenza di caratteri dannosiEnsure that the file name and any other metadata (e.g., file path) are validated for malicious characters
  • La firma del formato di file deve essere controllata per impedire a un utente di caricare un file mascherato (ad esempio, caricare un file EXE modificandone l'estensione in txt)File format signature should be checked, to prevent a user from uploading a masqueraded file (e.g., uploading an exe file by changing extension to txt)

EsempioExample

Per informazioni dettagliate sull'ultimo punto relativo alla convalida della firma del formato di file, vedere la classe seguente:For the last point regarding file format signature validation, refer to the class below for details:

        private static Dictionary<string, List<byte[]>> fileSignature = new Dictionary<string, List<byte[]>>
                    {
                    { ".DOC", new List<byte[]> { new byte[] { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 } } },
                    { ".DOCX", new List<byte[]> { new byte[] { 0x50, 0x4B, 0x03, 0x04 } } },
                    { ".PDF", new List<byte[]> { new byte[] { 0x25, 0x50, 0x44, 0x46 } } },
                    { ".ZIP", new List<byte[]> 
                                            {
                                              new byte[] { 0x50, 0x4B, 0x03, 0x04 },
                                              new byte[] { 0x50, 0x4B, 0x4C, 0x49, 0x54, 0x55 },
                                              new byte[] { 0x50, 0x4B, 0x53, 0x70, 0x58 },
                                              new byte[] { 0x50, 0x4B, 0x05, 0x06 },
                                              new byte[] { 0x50, 0x4B, 0x07, 0x08 },
                                              new byte[] { 0x57, 0x69, 0x6E, 0x5A, 0x69, 0x70 }
                                                }
                                            },
                    { ".PNG", new List<byte[]> { new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A } } },
                    { ".JPG", new List<byte[]>
                                    {
                                              new byte[] { 0xFF, 0xD8, 0xFF, 0xE0 },
                                              new byte[] { 0xFF, 0xD8, 0xFF, 0xE1 },
                                              new byte[] { 0xFF, 0xD8, 0xFF, 0xE8 }
                                    }
                                    },
                    { ".JPEG", new List<byte[]>
                                        { 
                                            new byte[] { 0xFF, 0xD8, 0xFF, 0xE0 },
                                            new byte[] { 0xFF, 0xD8, 0xFF, 0xE2 },
                                            new byte[] { 0xFF, 0xD8, 0xFF, 0xE3 }
                                        }
                                        },
                    { ".XLS", new List<byte[]>
                                            {
                                              new byte[] { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 },
                                              new byte[] { 0x09, 0x08, 0x10, 0x00, 0x00, 0x06, 0x05, 0x00 },
                                              new byte[] { 0xFD, 0xFF, 0xFF, 0xFF }
                                            }
                                            },
                    { ".XLSX", new List<byte[]> { new byte[] { 0x50, 0x4B, 0x03, 0x04 } } },
                    { ".GIF", new List<byte[]> { new byte[] { 0x47, 0x49, 0x46, 0x38 } } }
                };

        public static bool IsValidFileExtension(string fileName, byte[] fileData, byte[] allowedChars)
        {
            if (string.IsNullOrEmpty(fileName) || fileData == null || fileData.Length == 0)
            {
                return false;
            }

            bool flag = false;
            string ext = Path.GetExtension(fileName);
            if (string.IsNullOrEmpty(ext))
            {
                return false;
            }

            ext = ext.ToUpperInvariant();

            if (ext.Equals(".TXT") || ext.Equals(".CSV") || ext.Equals(".PRN"))
            {
                foreach (byte b in fileData)
                {
                    if (b > 0x7F)
                    {
                        if (allowedChars != null)
                        {
                            if (!allowedChars.Contains(b))
                            {
                                return false;
                            }
                        }
                        else
                        {
                            return false;
                        }
                    }
                }

                return true;
            }

            if (!fileSignature.ContainsKey(ext))
            {
                return true;
            }

            List<byte[]> sig = fileSignature[ext];
            foreach (byte[] b in sig)
            {
                var curFileSig = new byte[b.Length];
                Array.Copy(fileData, curFileSig, b.Length);
                if (curFileSig.SequenceEqual(b))
                {
                    flag = true;
                    break;
                }
            }

            return flag;
        }

Verificare che nell'applicazione Web vengano usati parametri indipendenti dai tipi per l'accesso ai datiEnsure that type-safe parameters are used in Web Application for data access

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences N/DN/A
PassaggiSteps

Se si usa la raccolta Parameters, SQL considera l'input come un valore letterale anziché come codice eseguibile.If you use the Parameters collection, SQL treats the input is as a literal value rather then as executable code. La raccolta Parameters può essere usata per imporre vincoli di tipo e lunghezza sui dati di input.The Parameters collection can be used to enforce type and length constraints on input data. I valori non compresi nell'intervallo attivano un'eccezione.Values outside of the range trigger an exception. Se non vengono usati parametri SQL indipendenti dai tipi, gli utenti malintenzionati potrebbero eseguire attacchi di tipo injection incorporati nell'input non filtrato.If type-safe SQL parameters are not used, attackers might be able to execute injection attacks that are embedded in the unfiltered input.

Quando si costruiscono query SQL, usare parametri indipendenti dai tipi per evitare gli attacchi SQL injection che possono verificarsi con input non filtrato.Use type safe parameters when constructing SQL queries to avoid possible SQL injection attacks that can occur with unfiltered input. È possibile usare parametri indipendenti dai tipi con stored procedure e con istruzioni SQL dinamiche.You can use type safe parameters with stored procedures and with dynamic SQL statements. I parametri vengono considerati dal database come valori letterali e non come codice eseguibile.Parameters are treated as literal values by the database and not as executable code. Viene anche eseguito il controllo del tipo e della lunghezza dei parametri.Parameters are also checked for type and length.

EsempioExample

Il codice seguente illustra come usare parametri indipendenti dai tipi con SqlParameterCollection quando si chiama una stored procedure.The following code shows how to use type safe parameters with the SqlParameterCollection when calling a stored procedure.

using System.Data;
using System.Data.SqlClient;

using (SqlConnection connection = new SqlConnection(connectionString))
{ 
DataSet userDataset = new DataSet(); 
SqlDataAdapter myCommand = new SqlDataAdapter(LoginStoredProcedure", connection); 
myCommand.SelectCommand.CommandType = CommandType.StoredProcedure; 
myCommand.SelectCommand.Parameters.Add("@au_id", SqlDbType.VarChar, 11); 
myCommand.SelectCommand.Parameters["@au_id"].Value = SSN.Text; 
myCommand.Fill(userDataset);
}  

Nell'esempio di codice precedente, la lunghezza del valore di input non può essere maggiore di 11 caratteri.In the preceding code example, the input value cannot be longer than 11 characters. Se i dati non sono conformi alla lunghezza o al tipo definito dal parametro, la classe SqlParameter genera un'eccezione.If the data does not conform to the type or length defined by the parameter, the SqlParameter class throws an exception.

Usare classi di associazione di modelli separate o elenchi di filtri di associazione per prevenire la vulnerabilità dell'assegnazione di massa in MVCUse separate model binding classes or binding filter lists to prevent MVC mass assignment vulnerability

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies MVC 5, MVC 6MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Attributi dei metadati, Public Key Security Vulnerability And Mitigation (Vulnerabilità della sicurezza delle chiavi pubbliche e mitigazione), Guida completa all'assegnazione di massa in ASP.NET MVC, Introduzione a Entity Framework con MVCMetadata Attributes, Public Key Security Vulnerability And Mitigation, Complete Guide to Mass Assignment in ASP.NET MVC, Getting Started with EF using MVC
PassaggiSteps
  • Quando è consigliabile controllare eventuali vulnerabilità all'overposting? Le vulnerabilità all'overposting si possono verificare ovunque si associno classi modello dall'input utente.When should I look for over-posting vulnerabilities? - Over-posting vulnerabilities can occur any place you bind model classes from user input. I framework come MVC possono rappresentare i dati utente in classi .NET personalizzate, tra cui Plain Old CLR Object (POCO).Frameworks like MVC can represent user data in custom .NET classes, including Plain Old CLR Objects (POCOs). MVC popola automaticamente queste classi modello con i dati della richiesta, offrendo una pratica rappresentazione per la gestione dell'input utente.MVC automatically populates these model classes with data from the request, providing a convenient representation for dealing with user input. Quando queste classi includono proprietà che non devono essere impostate dall'utente, l'applicazione può essere vulnerabile ad attacchi di overposting, che consentono all'utente un controllo sui dati non previsto dall'applicazione.When these classes include properties that should not be set by the user, the application can be vulnerable to over-posting attacks, which allow user control of data that the application never intended. Così come l'associazione di modelli MVC, le tecnologie di accesso a database come i mapper relazionali/a oggetti come Entity Framework spesso supportano anche l'uso di oggetti POCO per rappresentare i dati dei database.Like MVC model binding, database access technologies such as object/relational mappers like Entity Framework often also support using POCO objects to represent database data. Queste classi del modello di dati consentono di gestire i dati dei database con la stessa praticità offerta da MVC per la gestione dell'input utente.These data model classes provide the same convenience in dealing with database data as MVC does in dealing with user input. Dato che MVC e il database supportano modelli simili, come gli oggetti POCO, le stesse classi sembrano facilmente riusabili per entrambi gli scopi.Because both MVC and the database support similar models, like POCO objects, it seems easy to reuse the same classes for both purposes. Questa procedura non riesce a mantenere la separazione dei compiti e offre un'area comune in cui proprietà non previste vengono esposte all'associazione di modelli, consentendo attacchi di overposting.This practice fails to preserve separation of concerns, and it is one common area where unintended properties are exposed to model binding, enabling over-posting attacks.
  • Perché non è consigliabile usare classi modello del database non filtrate come parametri per le azioni MVC? Perché l'associazione di modelli MVC associa tutti gli elementi nella classe.Why shouldn't I use my unfiltered database model classes as parameters to my MVC actions? - Because MVC model binding will bind anything in that class. Un utente malintenzionato può inviare una richiesta HTTP includendo anche dati non mostrati nella visualizzazione e questi verranno associati da MVC perché l'azione indica che la classe del database è la forma di dati da accettare come input utente.Even if the data does not appear in your view, a malicious user can send an HTTP request with this data included, and MVC will gladly bind it because your action says that database class is the shape of data it should accept for user input.
  • Perché è necessario prestare attenzione alla forma usata per l'associazione di modelli? L'uso dell'associazione di modelli ASP.NET MVC con modelli eccessivamente estesi espone un'applicazione ad attacchi di overposting.Why should I care about the shape used for model binding? - Using ASP.NET MVC model binding with overly broad models exposes an application to over-posting attacks. L'overposting potrebbe consentire a utenti malintenzionati di modificare dati dell'applicazione non previsti dallo sviluppatore, ad esempio sostituendo il prezzo di un articolo o i privilegi di sicurezza di un account.Over-posting could enable attackers to change application data beyond what the developer intended, such as overriding the price for an item or the security privileges for an account. Le applicazioni devono usare modelli di associazione specifici dell'azione (o specifici elenchi di filtri delle proprietà consentite) per fornire un contratto esplicito per l'input non attendibile da consentire tramite l'associazione di modelli.Applications should use action-specific binding models (or specific allowed property filter lists) to provide an explicit contract for what untrusted input to allow via model binding.
  • La presenza di modelli di associazione separati è solo una duplicazione del codice? No, è una separazione dei compiti.Is having separate binding models just duplicating code? - No, it is a matter of separation of concerns. Se si riusano i modelli del database nei metodi delle azioni, qualsiasi proprietà o proprietà secondaria nella classe potrà essere impostata dall'utente in una richiesta HTTP.If you reuse database models in action methods, you are saying any property (or sub-property) in that class can be set by the user in an HTTP request. Se ciò non corrisponde al comportamento desiderato per MVC, è necessario usare un elenco di filtri o una forma di classe separata per indicare a MVC quali dati possono invece provenire dall'input utente.If that is not what you want MVC to do, you need a filter list or a separate class shape to show MVC what data can come from user input instead.
  • Se si usano modelli di associazione separati per l'input utente, è necessario duplicare tutti gli attributi di annotazione dei dati? Non necessariamente.If I have separate binding models for user input, do I have to duplicate all my data annotation attributes? - Not necessarily. È possibile usare MetadataTypeAttribute nella classe modello del database per il collegamento ai metadati in una classe di associazione di modelli.You can use MetadataTypeAttribute on the database model class to link to the metadata on a model binding class. Si noti soltanto che il tipo a cui fa riferimento MetadataTypeAttribute deve essere un subset del tipo di riferimento (può avere meno proprietà, ma non di più).Just note that the type referenced by the MetadataTypeAttribute must be a subset of the referencing type (it can have fewer properties, but not more).
  • Lo spostamento di dati tra i modelli dell'input utente e i modelli del database è un'attività tediosa. È possibile copiare semplicemente tutte le proprietà con la reflection? Sì.Moving data back and forth between user input models and database models is tedious. Can I just copy over all properties using reflection? - Yes. Le uniche proprietà incluse nei modelli di associazione sono quelle che sono state accertate come sicure per l'input utente.The only properties that appear in the binding models are the ones you have determined to be safe for user input. Non esistono motivi di sicurezza che impediscono di usare la reflection per copiare tutte le proprietà comuni tra i due modelli.There is no security reason that prevents using reflection to copy over all properties that exist in common between these two models.
  • Come funziona [Bind(Exclude ="…")]? È possibile usare questo attributo anziché modelli di associazione separati? Questo approccio non è consigliabile.What about [Bind(Exclude ="…")]. Can I use that instead of having separate binding models? - This approach is not recommended. Usando [Bind(Exclude ="…")], qualsiasi nuova proprietà è associabile per impostazione predefinita.Using [Bind(Exclude ="…")] means that any new property is bindable by default. Quando viene aggiunta una nuova proprietà, è necessario ricordare un passaggio aggiuntivo per garantire la sicurezza e non si ottiene una progettazione sicura per impostazione predefinita.When a new property is added, there is an extra step to remember to keep things secure, rather than having the design be secure by default. Dipendere dal fatto che lo sviluppatore controlli questo elenco ogni volta che viene aggiunta una proprietà è rischioso.Depending on the developer checking this list every time a property is added is risky.
  • [Bind(Include ="…")] è utile per le operazioni di modifica? No.Is [Bind(Include ="…")] useful for Edit operations? - No. [Bind(Include ="…")] è adatto solo per operazioni di tipo INSERT, ossia per l'aggiunta di nuovi dati.[Bind(Include ="…")] is only suitable for INSERT-style operations (adding new data). Per operazioni di tipo UPDATE, ossia per la revisione dei dati esistenti, usare un altro approccio, come l'uso di modelli di associazione separati o il passaggio di un elenco esplicito delle proprietà consentite a UpdateModel o TryUpdateModel.For UPDATE-style operations (revising existing data), use another approach, like having separate binding models or passing an explicit list of allowed properties to UpdateModel or TryUpdateModel. Con l'aggiunta di un attributo [Bind(Include ="…")] in un'operazione di modifica, MVC creerà un'istanza dell'oggetto e imposterà solo le proprietà elencate, mantenendo i valori predefiniti per tutte le altre.Adding a [Bind(Include ="…")] attribute on an Edit operation means that MVC will create an object instance and set only the listed properties, leaving all others at their default values. Quando i dati vengono resi persistenti, sostituirà interamente l'entità esistente, reimpostando i valori predefiniti per tutte le proprietà omesse.When the data is persisted, it will entirely replace the existing entity, resetting the values for any omitted properties to their defaults. Ad esempio, se la proprietà IsAdmin è stata omessa in un attributo [Bind(Include ="…")] per un'operazione di modifica, qualsiasi utente il cui nome è stato modificato tramite tale azione verrà reimpostato su IsAdmin = false. Qualsiasi utente modificato perderà così lo stato di amministratore.For example, if IsAdmin was omitted from a [Bind(Include ="…")] attribute on an Edit operation, any user whose name was edited via this action would be reset to IsAdmin = false (any edited user would lose administrator status). Se si vuole impedire l'aggiornamento di determinate proprietà, usare uno degli altri approcci descritti sopra.If you want to prevent updates to certain properties, use one of the other approaches above. Si noti che alcune versioni degli strumenti MVC generano classi controller con [Bind(Include ="…")] nelle azioni di modifica e prevedono che la rimozione di una proprietà dall'elenco impedisca attacchi di overposting.Note that some versions of MVC tooling generate controller classes with [Bind(Include ="…")] on Edit actions and imply that removing a property from that list will prevent over-posting attacks. Come descritto sopra, tuttavia, questo approccio non funziona come previsto e reimposta invece i dati nelle proprietà omesse sui valori predefiniti.However, as described above, that approach does not work as intended and instead will reset any data in the omitted properties to their default values.
  • Per le operazioni di creazione, esistono controindicazioni all'uso di [Bind(Include ="…")] anziché di modelli di associazione separati? Sì.For Create operations, are there any caveats using [Bind(Include ="…")] rather than separate binding models? - Yes. Per prima cosa, questo approccio non funziona per gli scenari di modifica e richiede quindi la gestione di due approcci separati per la mitigazione di tutte le vulnerabilità all'overposting.First this approach does not work for Edit scenarios, requiring maintaining two separate approaches for mitigating all over-posting vulnerabilities. In secondo luogo, i modelli di associazione separati impongono la separazione dei compiti tra la forma usata per l'input utente e la forma usata per la persistenza, una funzionalità non offerta da [Bind(Include ="…")].Second, separate binding models enforce separation of concerns between the shape used for user input and the shape used for persistence, something [Bind(Include ="…")] does not do. In terzo luogo, [Bind(Include ="…")] può gestire solo le proprietà di livello superiore e non è quindi possibile consentire solo parti di proprietà secondarie (come "Details.Name") nell'attributo.Third, note that [Bind(Include ="…")] can only handle top-level properties; you cannot allow only portions of sub-properties (such as "Details.Name") in the attribute. Infine e forse soprattutto, l'uso di [Bind(Include ="…")] comporta un passaggio aggiuntivo da ricordare ogni volta che la classe viene usata per l'associazione di modelli.Finally, and perhaps most importantly, using [Bind(Include ="…")] adds an extra step that must be remembered any time the class is used for model binding. Se un nuovo metodo di azione esegue l'associazione diretta alla classe dati senza includere un attributo [Bind(Include ="…")], può essere vulnerabile ad attacchi di overposting. Di conseguenza, l'approccio [Bind(Include ="…")] è un po' meno sicuro per impostazione predefinita.If a new action method binds to the data class directly and forgets to include a [Bind(Include ="…")] attribute, it can be vulnerable to over-posting attacks, so the [Bind(Include ="…")] approach is somewhat less secure by default. Se si usa [Bind(Include ="…")], ricordare di specificarlo ogni volta che le classi dati vengono incluse come parametri di metodi di azione.If you use [Bind(Include ="…")], take care always to remember to specify it every time your data classes appear as action method parameters.
  • Per le operazioni di creazione, l'inserimento dell'attributo [Bind(Include ="…")] nella classe modello evita di dover ricordare di inserire l'attributo in ogni metodo di azione? Questo approccio funziona in alcuni casi.For Create operations, what about putting the [Bind(Include ="…")] attribute on the model class itself? Does not this approach avoid the need to remember putting the attribute on every action method? - This approach works in some cases. L'uso di [Bind(Include ="…")] nel tipo di modello (anziché nei parametri di azione che usano la classe) evita di dover ricordare di includere l'attributo [Bind(Include ="…")] in ogni metodo di azione.Using [Bind(Include ="…")] on the model type itself (rather than on action parameters using this class), does avoid the need to remember to include the [Bind(Include ="…")] attribute on every action method. Usando l'attributo direttamente nella classe, si crea di fatto una superficie di attacco separata di tale classe ai fini dell'associazione di modelli.Using the attribute directly on the class effectively creates a separate surface area of this class for model binding purposes. Questo approccio, tuttavia, supporta una sola forma di associazione di modelli per classe modello.However, this approach only allows for one model binding shape per model class. Se un metodo di azione deve consentire l'associazione di modelli di un campo (come ad esempio un'azione riservata all'amministratore che aggiorna i ruoli utente) mentre le altre azioni devono impedire l'associazione di modelli di tale campo, questo approccio non funziona.If one action method needs to allow model binding of a field (for example, an administrator-only action that updates user roles) and other actions need to prevent model binding of this field, this approach will not work. Ogni classe può avere una sola forma di associazione di modelli. Se azioni diverse richiedono forme di associazione di modelli diverse, devono rappresentare queste forme separate usando classi di associazione di modelli separate oppure attributi [Bind(Include ="…")] separati nei metodi di azione.Each class can only have one model binding shape; if different actions need different model binding shapes, they need to represent these separate shapes using either separate model binding classes or separate [Bind(Include ="…")] attributes on the action methods.
  • Che cosa sono i modelli di associazione? Sono uguali ai modelli di visualizzazione? Si tratta di due concetti correlati.What are binding models? Are they the same thing as view models? - These are two related concepts. Il termine modello di associazione indica una classe modello usata in un'azione come elenco di parametri, ossia la forma passata dall'associazione di modelli MVC al metodo di azione.The term binding model refers to a model class used in an action is parameter list (the shape passed from MVC model binding to the action method). Il termine modello di visualizzazione indica una classe modello passata da un metodo di azione a una visualizzazione.The term view model refers to a model class passed from an action method to a view. L'uso di un modello specifico per la visualizzazione è un approccio comune per passare dati da un metodo di azione a una visualizzazione.Using a view-specific model is a common approach for passing data from an action method to a view. Questa forma è spesso adatta anche per l'associazione di modelli e il termine modello di visualizzazione può essere adottato per fare riferimento allo stesso modello usato in entrambe le posizioni.Often, this shape is also suitable for model binding, and the term view model can be used to refer the same model used in both places. Per la precisione, questa procedura riguarda specificamente i modelli di associazione e si concentra sulla forma passata all'azione, rilevante ai fini dell'assegnazione di massa.To be precise, this procedure talks specifically about binding models, focusing on the shape passed to the action, which is what matters for mass assignment purposes.

Codificare l'output Web non attendibile prima del renderingEncode untrusted web output prior to rendering

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, Web Form, MVC 5, MVC 6Generic, Web Forms, MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences How to prevent Cross-site scripting in ASP.NET (Come impedire attacchi tramite script da altri siti in ASP.NET), Cross-site Scripting (Attacchi tramite script da altri siti), XSS (Cross Site Scripting) Prevention Cheat Sheet (Foglio informativo sulla prevenzione degli attacchi tramite script da altri siti)How to prevent Cross-site scripting in ASP.NET, Cross-site Scripting, XSS (Cross Site Scripting) Prevention Cheat Sheet
PassaggiSteps Gli attacchi tramite script da altri siti (comunemente abbreviati in XSS, Cross-Site Scripting) sono un vettore di attacco per i servizi online o qualsiasi applicazione/componente che utilizza input dal Web.Cross-site scripting (commonly abbreviated as XSS) is an attack vector for online services or any application/component that consumes input from the web. Le vulnerabilità XSS possono consentire a un utente malintenzionato di eseguire script sul computer di un altro utente tramite un'applicazione Web vulnerabile.XSS vulnerabilities may allow an attacker to execute script on another user's machine through a vulnerable web application. Gli script dannosi possono essere usati per rubare cookie o manomettere in altro modo il computer di una vittima tramite JavaScript.Malicious scripts can be used to steal cookies and otherwise tamper with a victim's machine through JavaScript. È possibile impedire attacchi XSS convalidando l'input utente e verificando che il formato e la codifica siano corretti prima di eseguirne il rendering in una pagina Web.XSS is prevented by validating user input, ensuring it is well formed and encoding before it is rendered in a web page. La convalida dell'input e la codifica dell'output possono essere eseguite con Web Protection Library.Input validation and output encoding can be done by using Web Protection Library. Per il codice gestito (C#, VB.net e così via), usare uno o più metodi di codifica appropriati di Web Protection (Anti-XSS) Library, a seconda del contesto in cui si manifesta l'input utente:For Managed code (C#, VB.net, etc.), use one or more appropriate encoding methods from the Web Protection (Anti-XSS) Library, depending on the context where the user input gets manifested:

EsempioExample

* Encoder.HtmlEncode 
* Encoder.HtmlAttributeEncode 
* Encoder.JavaScriptEncode 
* Encoder.UrlEncode
* Encoder.VisualBasicScriptEncode 
* Encoder.XmlEncode 
* Encoder.XmlAttributeEncode 
* Encoder.CssEncode 
* Encoder.LdapEncode 

Eseguire la convalida dell'input e applicare filtri a tutte le proprietà del modello di tipo stringaPerform input validation and filtering on all string type Model properties

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, MVC 5, MVC 6Generic, MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Adding Validation (Aggiunta della convalida), Validating Model Data in an MVC Application (Convalida dei dati del modello in un'applicazione MVC), Principi guida per le applicazioni ASP.NET MVCAdding Validation, Validating Model Data in an MVC Application, Guiding Principles For Your ASP.NET MVC Applications
PassaggiSteps

Tutti i parametri di input devono essere convalidati prima di essere usati nell'applicazione per garantire la protezione dell'applicazione da input utente dannosi.All the input parameters must be validated before they are used in the application to ensure that the application is safeguarded against malicious user inputs. Convalidare i valori di input usando espressioni regolari sul lato server con una strategia di convalida tramite elenchi degli elementi consentiti.Validate the input values using regular expression validations on server side with a whitelist validation strategy. I parametri o gli input utente non purificati passati ai metodi possono causare vulnerabilità a code injection.Unsanitized user inputs / parameters passed to the methods can cause code injection vulnerabilities.

Per le applicazioni Web, i punti di ingresso possono includere anche campi modulo, stringhe di query, cookie, intestazioni HTTP e parametri del servizio Web.For web applications, entry points can also include form fields, QueryStrings, cookies, HTTP headers, and web service parameters.

All'associazione di modelli devono essere eseguiti i controlli di convalida dell'input seguenti:The following input validation checks must be performed upon model binding:

  • Nelle proprietà dei modelli deve essere usata l'annotazione RegularExpression, per l'accettazione dei caratteri e della lunghezza massima consentitiThe model properties should be annotated with RegularExpression annotation, for accepting allowed characters and maximum permissible length
  • I metodi del controller devono eseguire la convalida ModelStateThe controller methods should perform ModelState validity

Applicazione della purificazione nei campi modulo che accettano tutti i caratteri, ad esempio un editor di testo RTFSanitization should be applied on form fields that accept all characters, e.g, rich text editor

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Encode Unsafe Input (Codificare l'input non sicuro), HtmlSanitizerEncode Unsafe Input, HTML Sanitizer
PassaggiSteps

Identificare tutti i tag di markup statici che si vogliono usare.Identify all static markup tags that you want to use. Una procedura comune consiste nel limitare la formattazione a elementi HTML sicuri, come <b> (grassetto) e <i> (corsivo).A common practice is to restrict formatting to safe HTML elements, such as <b> (bold) and <i> (italic).

Prima della scrittura dei dati, applicare la codifica HTML.Before writing the data, HTML-encode it. In questo modo, eventuali script dannosi diventeranno sicuri perché verranno gestiti come testo anziché come codice eseguibile.This makes any malicious script safe by causing it to be handled as text, not as executable code.

  1. Disabilitare la convalida delle richieste ASP.NET aggiungendo l'attributo ValidateRequest="false" alla direttiva @ PageDisable ASP.NET request validation by the adding the ValidateRequest="false" attribute to the @ Page directive
  2. Codificare l'input di stringa con il metodo HtmlEncodeEncode the string input with the HtmlEncode method
  3. Usare StringBuilder e chiamare il relativo metodo Replace per rimuovere in modo selettivo la codifica negli elementi HTML che si vuole consentireUse a StringBuilder and call its Replace method to selectively remove the encoding on the HTML elements that you want to permit

La direttiva di pagina nei riferimenti disabilita la convalida delle richieste ASP.NET con l'impostazione ValidateRequest="false",The page-in the references disables ASP.NET request validation by setting ValidateRequest="false". applica la codifica HTML all'input e consente in modo selettivo <b> e <i>. In alternativa, è anche possibile usare una libreria .NET per la purificazione HTML.It HTML-encodes the input and selectively allows the <b> and <i> Alternatively, a .NET library for HTML sanitization may also be used.

HtmlSanitizer è una libreria .NET per la pulizia di documenti e frammenti HTML dei costrutti che possono causare attacchi XSS.HtmlSanitizer is a .NET library for cleaning HTML fragments and documents from constructs that can lead to XSS attacks. Per l'analisi, la manipolazione e il rendering di HTML e CSS usa AngleSharp.It uses AngleSharp to parse, manipulate, and render HTML and CSS. È possibile installare HtmlSanitizer come pacchetto NuGet e passare l'input utente attraverso i metodi di purificazione HTML o CSS pertinenti, a seconda dei casi, sul lato server.HtmlSanitizer can be installed as a NuGet package, and the user input can be passed through relevant HTML or CSS sanitization methods, as applicable, on the server side. Si noti che la purificazione deve essere presa in considerazione come controllo di sicurezza solo come ultima opzione.Please note that Sanitization as a security control should be considered only as a last option.

La convalida dell'input e la codifica dell'output sono considerati controlli di sicurezza più efficienti.Input validation and Output Encoding are considered better security controls.

Non assegnare elementi DOM a sink senza codifica incorporataDo not assign DOM elements to sinks that do not have inbuilt encoding

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences N/DN/A
PassaggiSteps Molte funzioni JavaScript non eseguono la codifica per impostazione predefinita.Many javascript functions don't do encoding by default. L'assegnazione di input non attendibile a elementi DOM tramite funzioni di questo tipo può determinare attacchi tramite script da altri siti (XSS).When assigning untrusted input to DOM elements via such functions, may result in cross site script (XSS) executions.

EsempioExample

Gli esempi seguenti non sono sicuri:Following are insecure examples:

document.getElementByID("div1").innerHtml = value;
$("#userName").html(res.Name);
return $('<div/>').html(value)
$('body').append(resHTML);   

Non usare innerHtml. Usare invece innerText.Don't use innerHtml; instead use innerText. Analogamente, usare $("#elm").text() invece di $("#elm").html().Similarly, instead of $("#elm").html(), use $("#elm").text()

Convalidare come chiusi o sicuri tutti i reindirizzamenti nell'applicazioneValidate all redirects within the application are closed or done safely

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences The OAuth 2.0 Authorization Framework - Open Redirectors (Framework di autorizzazione di OAuth 2.0 - Redirector aperti)The OAuth 2.0 Authorization Framework - Open Redirectors
PassaggiSteps

Se la progettazione dell'applicazione richiede il reindirizzamento a un percorso specificato dall'utente, è necessario vincolare le possibile destinazioni di reindirizzamento a un elenco "sicuro" predefinito di siti o domini.Application design requiring redirection to a user-supplied location must constrain the possible redirection targets to a predefined "safe" list of sites or domains. Tutti i reindirizzamenti nell'applicazione devono essere chiusi/sicuri.All redirects in the application must be closed/safe.

A tale scopo, seguire questa procedura:To do this:

  • Identificare tutti i reindirizzamenti.Identify all redirects
  • Implementare una procedura di mitigazione appropriata per ogni reindirizzamento.Implement an appropriate mitigation for each redirect. Le procedure di mitigazione appropriate includono un elenco elementi consentiti di reindirizzamento o la conferma dell'utente.Appropriate mitigations include redirect whitelist or user confirmation. Se un servizio o un sito Web con una vulnerabilità causata da reindirizzamenti aperti usa i provider di identità Facebook/OAuth/OpenID, un utente malintenzionato può rubare il token di accesso di un utente e rappresentare tale utente.If a web site or service with an open redirect vulnerability uses Facebook/OAuth/OpenID identity providers, an attacker can steal a user's logon token and impersonate that user. Si tratta di un rischio intrinseco quando si usa OAuth, come documentato nella sezione 10.15 relativa ai reindirizzamenti aperti della specifica RFC 6749 del framework di autorizzazione di OAuth 2.0. Analogamente, le credenziali degli utenti possono essere compromesse da attacchi di spear phishing con reindirizzamenti aperti.This is an inherent risk when using OAuth, which is documented in RFC 6749 "The OAuth 2.0 Authorization Framework", Section 10.15 "Open Redirects" Similarly, users' credentials can be compromised by spear phishing attacks using open redirects

Implementare la convalida dell'input in un tutti i parametri di tipo stringa accettati dai metodi del controllerImplement input validation on all string type parameters accepted by Controller methods

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, MVC 5, MVC 6Generic, MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Validating Model Data in an MVC Application (Convalida dei dati del modello in un'applicazione MVC), Principi guida per le applicazioni ASP.NET MVCValidating Model Data in an MVC Application, Guiding Principles For Your ASP.NET MVC Applications
PassaggiSteps Per i metodi che accettano come argomento solo un tipo di dati primitivo e non modelli, deve essere eseguita la convalida dell'input con un'espressione regolare.For methods that just accept primitive data type, and not models as argument,input validation using Regular Expression should be done. In questo caso, è necessario usare Regex.IsMatch con un criterio regex valido.Here Regex.IsMatch should be used with a valid regex pattern. Se l'input non corrisponde all'espressione regolare specificata, il controllo dovrà essere interrotto e dovrà essere visualizzato un avviso relativo all'errore di convalida.If the input doesn't match the specified Regular Expression, control should not proceed further, and an adequate warning regarding validation failure should be displayed.

Impostare il limite massimo di timeout per l'elaborazione di espressioni regolari per impedire attacchi DoS causati da espressioni regolari errateSet upper limit timeout for regular expression processing to prevent DoS due to bad regular expressions

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, Web Form, MVC 5, MVC 6Generic, Web Forms, MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Proprietà DefaultRegexMatchTimeoutDefaultRegexMatchTimeout Property
PassaggiSteps Per prevenire attacchi Denial of Service contro espressioni regolari create in modo non corretto, che causano un elevato backtracking, impostare il timeout predefinito globale.To ensure denial of service attacks against badly created regular expressions, that cause a lot of backtracking, set the global default timeout. Se il tempo necessario per l'elaborazione è superiore al limite massimo definito, verrà generata un'eccezione di timeout.If the processing time takes longer than the defined upper limit, it would throw a Timeout exception. In assenza di configurazione, il timeout sarà infinito.If nothing is configured, the timeout would be infinite.

EsempioExample

La configurazione seguente, ad esempio, genera un'eccezione RegexMatchTimeoutException se l'elaborazione richiede più di 5 secondi:For example, the following configuration will throw a RegexMatchTimeoutException, if the processing takes more than 5 seconds:

<httpRuntime targetFramework="4.5" defaultRegexMatchTimeout="00:00:05" />

Evitare di usare Html.Raw nelle visualizzazioni RazorAvoid using Html.Raw in Razor views

TitoloTitle DettagliDetails
ComponenteComponent Applicazione Web.Web Application
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies MVC 5, MVC 6MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences N/DN/A
PassaggioStep Le pagine Web ASP.Net (Razor) eseguono la codifica HTML automatica.ASP.Net WebPages (Razor) perform automatic HTML encoding. A tutte le stringhe stampate da nugget di codice incorporati (blocchi @) viene applicata automaticamente la codifica HTML.All strings printed by embedded code nuggets (@ blocks) are automatically HTML-encoded. Quando viene richiamato HtmlHelper.Raw, tuttavia, questo metodo restituisce markup senza codifica HTML.However, when HtmlHelper.Raw Method is invoked, it returns markup that is not HTML encoded. Se viene usato il metodo helper Html.Raw(), questo ignora la protezione con codifica automatica fornita da Razor.If Html.Raw() helper method is used, it bypasses the automatic encoding protection that Razor provides.

EsempioExample

L'esempio seguente non è sicuro:Following is an insecure example:

<div class="form-group">
            @Html.Raw(Model.AccountConfirmText)
        </div>
        <div class="form-group">
            @Html.Raw(Model.PaymentConfirmText)
        </div>
</div>

Non usare Html.Raw() a meno che non sia necessario visualizzare markup.Do not use Html.Raw() unless you need to display markup. Questo metodo non esegue implicitamente la codifica dell'output.This method does not perform output encoding implicitly. Usare altri helper ASP.NET, ad esempio @Html.DisplayFor()Use other ASP.NET helpers e.g., @Html.DisplayFor()

Non usare query dinamiche nelle stored procedureDo not use dynamic queries in stored procedures

TitoloTitle DettagliDetails
ComponenteComponent DatabaseDatabase
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences N/DN/A
PassaggiSteps

Un attacco SQL injection sfrutta le vulnerabilità nella convalida dell'input per eseguire comandi arbitrari nel database.A SQL injection attack exploits vulnerabilities in input validation to run arbitrary commands in the database. Può verificarsi quando l'applicazione usa l'input per costruire istruzioni SQL dinamiche per accedere al database,It can occur when your application uses input to construct dynamic SQL statements to access the database. nonché se il codice usa stored procedure costituite da stringhe passate contenenti input utente non elaborato.It can also occur if your code uses stored procedures that are passed strings that contain raw user input. Con l'attacco SQL injection, l'utente malintenzionato può eseguire comandi arbitrari nel database.Using the SQL injection attack, the attacker can execute arbitrary commands in the database. Tutte le istruzioni SQL, incluse quelle nelle stored procedure, devono includere parametri.All SQL statements (including the SQL statements in stored procedures) must be parameterized. Le istruzioni SQL con parametri accetteranno senza problemi caratteri con un significato speciale per SQL (come la virgoletta singola) perché sono fortemente tipizzate.Parameterized SQL statements will accept characters that have special meaning to SQL (like single quote) without problems because they are strongly typed.

EsempioExample

L'esempio seguente è una stored procedure dinamica non sicura:Following is an example of insecure dynamic Stored Procedure:

CREATE PROCEDURE [dbo].[uspGetProductsByCriteria]
(
  @productName nvarchar(200) = NULL,
  @startPrice float = NULL,
  @endPrice float = NULL
)
AS
 BEGIN
  DECLARE @sql nvarchar(max)
  SELECT @sql = ' SELECT ProductID, ProductName, Description, UnitPrice, ImagePath' +
       ' FROM dbo.Products WHERE 1 = 1 '
       PRINT @sql
  IF @productName IS NOT NULL
     SELECT @sql = @sql + ' AND ProductName LIKE ''%' + @productName + '%'''
  IF @startPrice IS NOT NULL
     SELECT @sql = @sql + ' AND UnitPrice > ''' + CONVERT(VARCHAR(10),@startPrice) + ''''
  IF @endPrice IS NOT NULL
     SELECT @sql = @sql + ' AND UnitPrice < ''' + CONVERT(VARCHAR(10),@endPrice) + ''''

  PRINT @sql
  EXEC(@sql)
 END

EsempioExample

Di seguito è riportata la stessa stored procedure implementata in modo sicuro:Following is the same stored procedure implemented securely:

CREATE PROCEDURE [dbo].[uspGetProductsByCriteriaSecure]
(
             @productName nvarchar(200) = NULL,
             @startPrice float = NULL,
             @endPrice float = NULL
)
AS
       BEGIN
             SELECT ProductID, ProductName, Description, UnitPrice, ImagePath
             FROM dbo.Products where
             (@productName IS NULL or ProductName like '%'+ @productName +'%')
             AND
             (@startPrice IS NULL or UnitPrice > @startPrice)
             AND
             (@endPrice IS NULL or UnitPrice < @endPrice)         
       END

Verificare l'esecuzione della convalida dei modelli nei metodi di API WebEnsure that model validation is done on Web API methods

TitoloTitle DettagliDetails
ComponenteComponent API WebWeb API
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies MVC 5, MVC 6MVC5, MVC6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Model Validation in ASP.NET Web API (Convalida dei modelli in un'API Web ASP.NET)Model Validation in ASP.NET Web API
PassaggiSteps Quando un client invia dati a un'API Web, è obbligatorio convalidare i dati prima di eseguire qualsiasi elaborazione.When a client sends data to a web API, it is mandatory to validate the data before doing any processing. Per le API Web ASP.NET che accettano modelli come input, usare le annotazioni dei dati nei modelli per impostare le regole di convalida nelle proprietà dei modelli.For ASP.NET Web APIs which accept models as input, use data annotations on models to set validation rules on the properties of the model.

EsempioExample

Il codice seguente illustra quanto descritto sopra:The following code demonstrates the same:

using System.ComponentModel.DataAnnotations;

namespace MyApi.Models
{
    public class Product
    {
        public int Id { get; set; }
        [Required]
        [RegularExpression(@"^[a-zA-Z0-9]*$", ErrorMessage="Only alphanumeric characters are allowed.")]
        public string Name { get; set; }
        public decimal Price { get; set; }
        [Range(0, 999)]
        public double Weight { get; set; }
    }
}

EsempioExample

Nel metodo di azione dei controller dell'API la validità del modello deve essere selezionata in modo esplicito come illustrato di seguito:In the action method of the API controllers, validity of the model has to be explicitly checked as shown below:

namespace MyApi.Controllers
{
    public class ProductsController : ApiController
    {
        public HttpResponseMessage Post(Product product)
        {
            if (ModelState.IsValid)
            {
                // Do something with the product (not shown).

                return new HttpResponseMessage(HttpStatusCode.OK);
            }
            else
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
        }
    }
}

Implementare la convalida dell'input in tutti i parametri di tipo stringa accettati dai metodi di API WebImplement input validation on all string type parameters accepted by Web API methods

TitoloTitle DettagliDetails
ComponenteComponent API WebWeb API
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, MVC 5, MVC 6Generic, MVC 5, MVC 6
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Validating Model Data in an MVC Application (Convalida dei dati del modello in un'applicazione MVC), Principi guida per le applicazioni ASP.NET MVCValidating Model Data in an MVC Application, Guiding Principles For Your ASP.NET MVC Applications
PassaggiSteps Per i metodi che accettano come argomento solo un tipo di dati primitivo e non modelli, deve essere eseguita la convalida dell'input con un'espressione regolare.For methods that just accept primitive data type, and not models as argument,input validation using Regular Expression should be done. In questo caso, è necessario usare Regex.IsMatch con un criterio regex valido.Here Regex.IsMatch should be used with a valid regex pattern. Se l'input non corrisponde all'espressione regolare specificata, il controllo dovrà essere interrotto e dovrà essere visualizzato un avviso relativo all'errore di convalida.If the input doesn't match the specified Regular Expression, control should not proceed further, and an adequate warning regarding validation failure should be displayed.

Verificare che nell'API Web vengano usati parametri indipendenti dai tipi per l'accesso ai datiEnsure that type-safe parameters are used in Web API for data access

TitoloTitle DettagliDetails
ComponenteComponent API WebWeb API
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences N/DN/A
PassaggiSteps

Se si usa la raccolta Parameters, SQL considera l'input come un valore letterale anziché come codice eseguibile.If you use the Parameters collection, SQL treats the input is as a literal value rather then as executable code. La raccolta Parameters può essere usata per imporre vincoli di tipo e lunghezza sui dati di input.The Parameters collection can be used to enforce type and length constraints on input data. I valori non compresi nell'intervallo attivano un'eccezione.Values outside of the range trigger an exception. Se non vengono usati parametri SQL indipendenti dai tipi, gli utenti malintenzionati potrebbero eseguire attacchi di tipo injection incorporati nell'input non filtrato.If type-safe SQL parameters are not used, attackers might be able to execute injection attacks that are embedded in the unfiltered input.

Quando si costruiscono query SQL, usare parametri indipendenti dai tipi per evitare gli attacchi SQL injection che possono verificarsi con input non filtrato.Use type safe parameters when constructing SQL queries to avoid possible SQL injection attacks that can occur with unfiltered input. È possibile usare parametri indipendenti dai tipi con stored procedure e con istruzioni SQL dinamiche.You can use type safe parameters with stored procedures and with dynamic SQL statements. I parametri vengono considerati dal database come valori letterali e non come codice eseguibile.Parameters are treated as literal values by the database and not as executable code. Viene anche eseguito il controllo del tipo e della lunghezza dei parametri.Parameters are also checked for type and length.

EsempioExample

Il codice seguente illustra come usare parametri indipendenti dai tipi con SqlParameterCollection quando si chiama una stored procedure.The following code shows how to use type safe parameters with the SqlParameterCollection when calling a stored procedure.

using System.Data;
using System.Data.SqlClient;

using (SqlConnection connection = new SqlConnection(connectionString))
{ 
DataSet userDataset = new DataSet(); 
SqlDataAdapter myCommand = new SqlDataAdapter(LoginStoredProcedure", connection); 
myCommand.SelectCommand.CommandType = CommandType.StoredProcedure; 
myCommand.SelectCommand.Parameters.Add("@au_id", SqlDbType.VarChar, 11); 
myCommand.SelectCommand.Parameters["@au_id"].Value = SSN.Text; 
myCommand.Fill(userDataset);
}  

Nell'esempio di codice precedente, la lunghezza del valore di input non può essere maggiore di 11 caratteri.In the preceding code example, the input value cannot be longer than 11 characters. Se i dati non sono conformi alla lunghezza o al tipo definito dal parametro, la classe SqlParameter genera un'eccezione.If the data does not conform to the type or length defined by the parameter, the SqlParameter class throws an exception.

Usare query SQL con parametri per Cosmos DBUse parametrized SQL queries for Cosmos DB

TitoloTitle DettagliDetails
ComponenteComponent Azure DocumentDBAzure Document DB
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies GenericoGeneric
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences Announcing SQL Parameterization in DocumentDB (Annuncio della parametrizzazione SQL in DocumentDB)Announcing SQL Parameterization in DocumentDB
PassaggiSteps Nonostante DocumentDB supporti solo query di sola lettura, se le query vengono costruite con la concatenazione con input utente sono comunque possibili attacchi SQL injection.Although DocumentDB only supports read-only queries, SQL injection is still possible if queries are constructed by concatenating with user input. Un utente potrebbe ottenere l'accesso a dati a cui non dovrebbe accedere nella stessa raccolta creando query SQL dannose.It might be possible for a user to gain access to data they shouldn’t be accessing within the same collection by crafting malicious SQL queries. Se le query vengono costruite in base all'input utente, usare query SQL con parametri.Use parameterized SQL queries if queries are constructed based on user input.

WCF: convalida dell'input tramite l'associazione allo schemaWCF Input validation through Schema binding

TitoloTitle DettagliDetails
ComponenteComponent WCFWCF
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, .NET Framework 3Generic, NET Framework 3
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences MSDNMSDN
PassaggiSteps

L'assenza di convalida espone a diversi attacchi di tipo injection.Lack of validation leads to different type injection attacks.

La convalida dei messaggi rappresenta una linea di difesa nella protezione di un'applicazione WCF.Message validation represents one line of defense in the protection of your WCF application. Con questo approccio, si convalidano i messaggi usando schemi per proteggere le operazioni del servizio WCF dall'attacco di un client non autorizzato.With this approach, you validate messages using schemas to protect WCF service operations from attack by a malicious client. Convalidare tutti i messaggi ricevuti dal client per proteggere il client dall'attacco di un servizio dannoso.Validate all messages received by the client to protect the client from attack by a malicious service. In questo modo è possibile convalidare i messaggi quando le operazioni utilizzano contratti dati o contratti di messaggio, una funzionalità non supportata dalla convalida dei parametri.Message validation makes it possible to validate messages when operations consume message contracts or data contracts, which cannot be done using parameter validation. La convalida dei messaggi consente di creare la logica di convalida all'interno di schemi, offrendo così maggiore flessibilità e riducendo i tempi di sviluppo.Message validation allows you to create validation logic inside schemas, thereby providing more flexibility and reducing development time. Gli schemi possono essere riusati in diverse applicazioni all'interno dell'organizzazione, creando standard per la rappresentazione dei dati.Schemas can be reused across different applications inside the organization, creating standards for data representation. La convalida dei messaggi consente anche di proteggere le operazioni quando utilizzano tipi di dati più complessi associati a contratti che rappresentano la logica di business.Additionally, message validation allows you to protect operations when they consume more complex data types involving contracts representing business logic.

Per eseguire la convalida dei messaggi, si compila prima di tutto uno schema che rappresenta le operazioni del servizio e i tipi di dati utilizzati da tali operazioni.To perform message validation, you first build a schema that represents the operations of your service and the data types consumed by those operations. Si crea quindi una classe .NET che implementa un controllo messaggio personalizzato del client e un controllo messaggio personalizzato dello strumento di recapito per convalidare i messaggi inviati al servizio o da esso ricevuti.You then create a .NET class that implements a custom client message inspector and custom dispatcher message inspector to validate the messages sent/received to/from the service. Successivamente, si implementa un comportamento dell'endpoint personalizzato per abilitare la convalida dei messaggi sia nel client che nel servizio.Next, you implement a custom endpoint behavior to enable message validation on both the client and the service. Infine, si implementa un elemento di configurazione personalizzato per la classe che consente di esporre il comportamento dell'endpoint personalizzato esteso nel file di configurazione del servizio o del client.Finally, you implement a custom configuration element on the class that allows you to expose the extended custom endpoint behavior in the configuration file of the service or the client"

WCF: convalida dell'input tramite controlli parametroWCF- Input validation through Parameter Inspectors

TitoloTitle DettagliDetails
ComponenteComponent WCFWCF
Fase SDLSDL Phase CompilareBuild
Tecnologie applicabiliApplicable Technologies Generico, .NET Framework 3Generic, NET Framework 3
Attributes (Attributi) (Attributi)Attributes N/DN/A
RiferimentiReferences MSDNMSDN
PassaggiSteps

La convalida dell'input e dei dati rappresenta una linea di difesa importante nella protezione di un'applicazione WCF.Input and data validation represents one important line of defense in the protection of your WCF application. È consigliabile convalidare tutti i parametri esposti nelle operazioni del servizio WCF per proteggere il servizio dall'attacco di un client malintenzionato.You should validate all parameters exposed in WCF service operations to protect the service from attack by a malicious client. Viceversa, è consigliabile convalidare tutti i valori restituiti ricevuti dal client per proteggere il client dall'attacco di un servizio dannoso.Conversely, you should also validate all return values received by the client to protect the client from attack by a malicious service

WCF offre diversi punti di estendibilità che consentono di personalizzare il comportamento del runtime WCF creando estensioni personalizzate.WCF provides different extensibility points that allow you to customize the WCF runtime behavior by creating custom extensions. I controlli messaggio e i controlli parametro sono due meccanismi di estendibilità usati per ottenere maggiore controllo sui dati che vengono passati tra un client e un servizio.Message Inspectors and Parameter Inspectors are two extensibility mechanisms used to gain greater control over the data passing between a client and a service. È consigliabile usare i controlli parametro per la convalida dell'input e i controlli messaggio solo quando è necessario controllare l'intero flusso dei messaggi da e verso un servizio.You should use parameter inspectors for input validation and use message inspectors only when you need to inspect the entire message flowing in and out of a service.

Per eseguire la convalida dell'input, si compila una classe .NET e si implementa un controllo parametro personalizzato per convalidare i parametri per le operazioni nel servizio.To perform input validation, you will build a .NET class and implement a custom parameter inspector in order to validate parameters on operations in your service. Si implementa quindi un comportamento dell'endpoint personalizzato per abilitare la convalida sia nel client che nel servizio.You will then implement a custom endpoint behavior to enable validation on both the client and the service. Infine, si implementa un elemento di configurazione personalizzato per la classe che consente di esporre il comportamento dell'endpoint personalizzato esteso nel file di configurazione del servizio o del client.Finally, you will implement a custom configuration element on the class that allows you to expose the extended custom endpoint behavior in the configuration file of the service or the client