Sicurezza e race conditionSecurity and Race Conditions

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

Le race condition nel metodo DisposeRace Conditions in the Dispose Method

Se una classe Dispose (metodo) (per altre informazioni, vedere Garbage Collection) non è sincronizzato, è possibile che il codice di pulitura all'interno 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;  
    }  
}  

Perché ciò Dispose implementazione non è sincronizzata, è possibile Cleanup deve essere chiamato da un primo thread e quindi un secondo thread prima _myObj è impostata 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 una questione di sicurezza varia a seconda che cosa accade quando il Cleanup codice viene eseguito.Whether this is a security concern depends on what happens when the Cleanup code runs. Un problema principale con non sincronizzate Dispose implementazioni prevede l'uso degli handle di risorsa, ad esempio i 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 comporta 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 accedere ai membri della classe prima che i costruttori di classe sono completata l'esecuzione di altri thread.In some applications, it might be possible for other threads to access class members before their class constructors have completely run. È consigliabile esaminare tutti i costruttori della 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.

Le race condition con gli oggetti memorizzati nella cacheRace Conditions with Cached Objects

Il codice che memorizza nella cache le informazioni di sicurezza o Usa la sicurezza dall'accesso di codice Assert operazione può essere vulnerabile a situazioni di 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 DoOtherWork che può essere chiamato 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 che esaminarlo per questa vulnerabilità.If your code caches security information, make sure that you review it for this vulnerability.

Condizioni di competizione nei finalizzatoriRace Conditions in Finalizers

Le race condition possono verificarsi anche in un oggetto che fa riferimento a una risorsa statica o non gestita che viene resa disponibile nel relativo 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 verrà modificata in un finalizzatore di classe, è necessario sincronizzare gli oggetti tutti gli accessi alla 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