Utilizzo di Google Chrome Sandbox

Question

Ci sono diverse risorse là fuori che spiegano come funziona la sandbox in Chrome e cosa fa per proteggere gli utenti dal codice dannoso.

Chromium Blog
Chromium Developer Documentation
Sandbox FAQ

che è grande, e mi piace il design OS-centric che hanno in luogo (un po 'un "Il sistema operativo probabilmente sa come proteggere sé meglio di noi, in modo da lasciamo che "si avvicinino". Inoltre menzionano in diversi punti che la sandbox stessa è stata progettata per non dipendere da Chrome ma invece più o meno standalone in modo che teoricamente qualsiasi processo possa essere sandbox purché l'architettura del programma sia compatibile (il codice in modalità sandbox deve essere eseguito come se fosse figlio di un genitore non in modalità sandboxing)

Mi capita proprio di avere un'applicazione il cui design lo rende maturo per il sandboxing, ed è stato in grado di far funzionare un processo genitore/figlio. Ho il codice Chromium e ... non ho idea di cosa fare dopo.

Qualcuno ha ancora qualcosa in questo sandboxing? Esistono risorse che documentano il suo utilizzo o le API? Immagino che dovrebbe essere piuttosto semplice, ma non riesco a capire da dove iniziare.

MODIFICA: La mia scoperta qui sotto nelle risposte!

Answer 1

Ok, ecco cosa ho trovato sul codice sandboxing con Chrome.

Prima di tutto, devi andare get the chromium source code. Questo è grande, e ci vorrà un po 'per ottenere, ma non ho ancora trovato alcuna scorciatoia affidabile per verificare che ancora risultati utilizzabili. Alo, è molto importante seguire le istruzioni su quella pagina MOLTO CLOSAMENTE. L'equipaggio di Google sa quello che stanno facendo e non è appassionato di passi inutili. Tutto su quella pagina è necessario. Sì. Qualunque cosa.

Ora, una volta ottenuto il codice sorgente, non è necessario crearlo nella sua interezza (che può richiedere ore!) Per utilizzare la sandbox.Invece sono stati abbastanza carini da darti una soluzione sandbox separata (che si trova nella cartella sandbox) che può essere costruita autonomamente. Costruisci questo progetto e assicurati che tutto compili. Se lo fa, bene! In caso contrario, non hai seguito i passaggi nella pagina di creazione, vero? Abbassa la testa per la vergogna e vai a farlo davvero stavolta. Non ti preoccupare, aspetterò ...

Ora che tutto ha costruito il tuo principale punto di interesse è il progetto sandbox_poc ("poc" = Proof of Concept). Questo progetto è fondamentalmente un involucro della GUI minimale attorno a una sandbox che lancerà una DLL arbitraria in un determinato punto di ingresso in un ambiente sandbox. Mostra tutti i passaggi necessari per la creazione e l'utilizzo di una sandbox e rappresenta il miglior riferimento che hai. Riferiscilo spesso!

Come si guarda attraverso il codice, probabilmente si noterà che il codice in realtà è sandboxes stesso. Questo è molto comune con tutti gli esempi di sandbox, e according to this thread (che potrebbe essere obsoleto) è probabilmente l'unico modo di funzionare per sandbox al momento. Il thread descrive come teoricamente si potrebbe sandbox un processo separato, ma non l'ho provato. Per sicurezza, però, avere un'app self-calling è il metodo "noto bene".

sandbox_proc include un gran numero di librerie statiche, ma sembrano essere principalmente per l'interfaccia utente di esempio che hanno creato. Gli unici che ho trovato che sembrano essere richiesto per un sandbox minimo sono:

sandbox.lib base.lib dbghelp.lib 

C'è un'altra dipendenza che non è del tutto evidente dalla guardando il progetto, però, ed è quello che mi sono coinvolti sulla più lunga. Quando hai creato la soluzione sandbox, uno dei file di output dovrebbe essere "wowhelper.exe". Anche se non è mai menzionato da nessuna parte, questo file deve essere copiato nella stessa directory dell'eseguibile che si sta facendo sandboxing! Se non lo è, i tentativi di sandbox del codice falliranno sempre con un errore generico di "file non trovato". Questo può essere molto frustrante se non sai cosa sta succedendo! Ora, sto sviluppando su Windows 7 a 64 bit, che potrebbe avere qualcosa a che fare con il requisito di wowhelper (WOW è un acronimo comune per le app di interoperabilità tra 16/32/64 bit), ma non ho un buon modo di testarlo proprio adesso. Per favore fatemi sapere se qualcun altro lo scopre di più!

Quindi questo è tutto l'ambiente, ecco un po 'di codice per farti andare! Si noti che sebbene io utilizzi wcout nel processo figlio qui, non è possibile vedere alcun output della console durante l'esecuzione nella sandbox. Qualsiasi cosa del genere deve essere comunicata al processo genitore tramite IPC.

#include <sandbox/src/sandbox.h> 
#include <sandbox/src/sandbox_factory.h> 
#include <iostream> 

using namespace std; 

int RunParent(int argc, wchar_t* argv[], sandbox::BrokerServices* broker_service) { 
    if (0 != broker_service->Init()) { 
     wcout << L"Failed to initialize the BrokerServices object" << endl; 
     return 1; 
    } 

    PROCESS_INFORMATION pi; 

    sandbox::TargetPolicy* policy = broker_service->CreatePolicy(); 

    // Here's where you set the security level of the sandbox. Doing a "goto definition" on any 
    // of these symbols usually gives you a good description of their usage and alternatives. 
    policy->SetJobLevel(sandbox::JOB_LOCKDOWN, 0); 
    policy->SetTokenLevel(sandbox::USER_RESTRICTED_SAME_ACCESS, sandbox::USER_LOCKDOWN); 
    policy->SetAlternateDesktop(true); 
    policy->SetDelayedIntegrityLevel(sandbox::INTEGRITY_LEVEL_LOW); 

    //Add additional rules here (ie: file access exceptions) like so: 
    policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES, sandbox::TargetPolicy::FILES_ALLOW_ANY, "some/file/path"); 

    sandbox::ResultCode result = broker_service->SpawnTarget(argv[0], GetCommandLineW(), policy, &pi); 

    policy->Release(); 
    policy = NULL; 

    if (sandbox::SBOX_ALL_OK != result) { 
     wcout << L"Sandbox failed to launch with the following result: " << result << endl; 
     return 2; 
    } 

    // Just like CreateProcess, you need to close these yourself unless you need to reference them later 
    CloseHandle(pi.hThread); 
    CloseHandle(pi.hProcess); 

    broker_service->WaitForAllTargets(); 

    return 0; 
} 

int RunChild(int argc, wchar_t* argv[]) { 
    sandbox::TargetServices* target_service = sandbox::SandboxFactory::GetTargetServices(); 

    if (NULL == target_service) { 
     wcout << L"Failed to retrieve target service" << endl; 
     return 1; 
    } 

    if (sandbox::SBOX_ALL_OK != target_service->Init()) { 
     wcout << L"failed to initialize target service" << endl; 
     return 2; 
    } 

    // Do any "unsafe" initialization code here, sandbox isn't active yet 

    target_service->LowerToken(); // This locks down the sandbox 

    // Any code executed at this point is now sandboxed! 

    TryDoingSomethingBad(); 

    return 0; 
} 

int wmain(int argc, wchar_t* argv[]) { 
    sandbox::BrokerServices* broker_service = sandbox::SandboxFactory::GetBrokerServices(); 

    // A non-NULL broker_service means that we are not running the the sandbox, 
    // and are therefore the parent process 
    if(NULL != broker_service) { 
     return RunParent(argc, argv, broker_service); 
    } else { 
     return RunChild(argc, argv); 
    } 
} 

Speriamo che sia sufficiente per ottenere qualsiasi altro codificatore curioso sandboxing! In bocca al lupo!

Answer 2

Non sono sicuro di quale tipo di risposta desideri ... La prima cosa che dovresti fare è controllare il codice sorgente di Chrome reference. Ciò che ci interessa è questo:

sandbox: il progetto sandbox che tenta di impedire a un renderer compromesso di modificare il sistema.

Spelunking attorno a quel codice e ricerca di riferimenti API nella parte Rendering di Chromium potrebbe aiutare.

renderer: codice per il sottoprocesso in ciascuna scheda. Questo incorpora WebKit e parla al browser per I/O.

andare a cercare lì intorno, probabilmente si può vedere come Google si stanno usando il sandbox, mi aspetto che sarà qualcosa di simile a

//Lets start up the sandbox, I'm using the Chrome Blog example 
TargetPolicy::SetTokenLevel() 
TargetPolicy::SetJobLevel() 
TargetPolicy::SetIntegrityLevel() 
TargetPolicy::SetDesktop() 

In genere questo è l'approccio che uso quando incontro un nuovo codice di base, controlla come viene chiamato.