Sicurezza e race conditionSecurity and Race Conditions

Un'altra area di interesse è il rischio di protezione possano essere sfruttati da race condition.Another area of concern is the potential for security holes exploited by race conditions. Esistono diversi modi in cui questa situazione potrebbe verificarsi.There are several ways in which this might happen. Negli argomenti che seguono descrivono alcuni aspetti problematici che lo sviluppatore deve evitare.The subtopics that follow outline some of the major pitfalls that the developer must avoid.

Race condition nel metodo DisposeRace Conditions in the Dispose Method

Se una classe Dispose (metodo) (per ulteriori informazioni, vedere Garbage Collection) non è sincronizzato, è possibile il codice di pulizia all'interno di Dispose può essere eseguito più di una volta, come illustrato nell'esempio seguente.If a class's Dispose method (for more information, see Garbage Collection) is not synchronized, it is possible that cleanup code inside Dispose can be run more than once, as shown in the following example.

Sub Dispose()  
    If Not (myObj Is Nothing) Then  
       Cleanup(myObj)  
       myObj = Nothing  
    End If  
End Sub  
void Dispose()   
{  
    if( myObj != null )   
    {  
        Cleanup(myObj);  
        myObj = null;  
    }  
}  

Poiché questo Dispose implementazione non è sincronizzata, è possibile per Cleanup di essere chiamato da un primo thread e quindi un secondo thread prima _myObj è impostato su null.Because this Dispose implementation is not synchronized, it is possible for Cleanup to be called by first one thread and then a second thread before _myObj is set to null. Se si tratta di un problema di sicurezza varia a seconda che cosa avviene quando il Cleanup viene eseguito codice.Whether this is a security concern depends on what happens when the Cleanup code runs. Un problema con non sincronizzate Dispose implementazioni prevede l'utilizzo di handle di risorsa, ad esempio file.A major issue with unsynchronized Dispose implementations involves the use of resource handles such as files. Eliminazione non corretta può causare l'handle non corretto da usare, che spesso le vulnerabilità di sicurezza.Improper disposal can cause the wrong handle to be used, which often leads to security vulnerabilities.

Condizioni di competizione nei costruttoriRace Conditions in Constructors

In alcune applicazioni, potrebbe essere possibile che altri thread di accedere a membri della classe prima che i costruttori di classe hanno eseguito completamente.In some applications, it might be possible for other threads to access class members before their class constructors have completely run. È necessario esaminare tutti i costruttori di classe per assicurarsi che non siano presenti problemi di sicurezza se questo deve verificarsi o sincronizzare i thread se necessario.You should review all class constructors to make sure that there are no security issues if this should happen, or synchronize threads if necessary.

Condizioni di competizione con gli oggetti memorizzati nella cacheRace Conditions with Cached Objects

Codice che memorizza nella cache le informazioni di sicurezza o che utilizza la sicurezza dall'accesso di codice Assert operazione può essere vulnerabile a race condition se altre parti della classe non sono sincronizzati in modo appropriato, come illustrato nell'esempio seguente.Code that caches security information or uses the code access security Assert operation might also be vulnerable to race conditions if other parts of the class are not appropriately synchronized, as shown in the following example.

Sub SomeSecureFunction()  
    If SomeDemandPasses() Then  
        fCallersOk = True  
        DoOtherWork()  
        fCallersOk = False()  
    End If  
End Sub  

Sub DoOtherWork()  
    If fCallersOK Then  
        DoSomethingTrusted()  
    Else  
        DemandSomething()  
        DoSomethingTrusted()  
    End If  
End Sub  
void SomeSecureFunction()   
{  
    if(SomeDemandPasses())   
    {  
        fCallersOk = true;  
        DoOtherWork();  
        fCallersOk = false();  
    }  
}  
void DoOtherWork()   
{  
    if( fCallersOK )   
    {  
        DoSomethingTrusted();  
    }  
    else   
    {  
        DemandSomething();  
        DoSomethingTrusted();  
    }  
}  

Se sono presenti altri percorsi di DoOtherWork che possono essere chiamati da un altro thread con lo stesso oggetto, un chiamante non attendibile può essere aggirata da una richiesta.If there are other paths to DoOtherWork that can be called from another thread with the same object, an untrusted caller can slip past a demand.

Se il codice memorizza nella cache le informazioni di sicurezza, assicurarsi di verificare per questa vulnerabilità.If your code caches security information, make sure that you review it for this vulnerability.

Condizioni di competizione nei distruttoriRace Conditions in Finalizers

Le condizioni di competizione possono verificarsi anche in un oggetto che fa riferimento a una risorsa statica o non gestita che viene resa disponibile nel finalizzatore.Race conditions can also occur in an object that references a static or unmanaged resource that it then frees in its finalizer. Se più oggetti condividono una risorsa che viene modificata in un finalizzatore di classe, è necessario sincronizzare gli oggetti ogni accesso a tale risorsa.If multiple objects share a resource that is manipulated in a class's finalizer, the objects must synchronize all access to that resource.

Vedere ancheSee Also

Linee guida per la generazione di codice sicuroSecure Coding Guidelines