c++ - plugin - Uso de Google Chrome Sandbox

net sdk player chrome

Question

Existen varios recursos que explican cómo funciona Sandbox en Chrome y qué hace para proteger a los usuarios de códigos maliciosos.

Blog de Chromium
Documentación del desarrollador de Chromium
Preguntas frecuentes sobre Sandbox

Eso es genial, y me gusta el diseño centrado en el sistema operativo que tienen (algo así como "El sistema operativo probablemente sabe cómo protegerse mejor que nosotros, así que lo dejamos" acercarse). También mencionan en varios lugares que el Sandbox en sí fue diseñado para no depender de Chrome, sino más o menos independiente, de modo que, en teoría, cualquier proceso podría ser protegido siempre que la arquitectura del programa sea compatible (el código de espacio aislado debe ejecutarse como su propio proceso como hijo de un padre sin espacio aislado)

Solo tengo una aplicación cuyo diseño lo prepara para sandboxing, y fue capaz de lograr que un proceso padre / hijo trabajara con él. Tengo el código de Chromium y ... no tengo idea de qué hacer a continuación.

¿Alguien ha puesto a prueba algo con esto todavía? ¿Hay algún recurso que documente su uso o API? Me imagino que debería ser bastante simple, pero no sé por dónde empezar.

EDITAR: ¡Mi hallazgo a continuación en las respuestas!

Answer 1

De acuerdo, entonces esto es lo que encontré sobre el código de sandboxing con Chrome.

Primero, necesitarás obtener el código fuente de cromo . Esto es grande , y tomará un tiempo obtenerlo, pero aún no he encontrado atajos confiables para pagar que aún puedan obtener resultados utilizables. Alos, es muy importante que sigas las instrucciones en esa página MUY CERCA. El equipo de Google sabe lo que hacen y no están interesados ​​en pasos inútiles. Todo en esa página es necesario. Sí. Todo.

Ahora, una vez que obtienes la fuente, en realidad no tienes que construir Chrome en su totalidad (¡lo cual puede tomar horas!) Para usar la caja de arena. En su lugar, han sido lo suficientemente buenos como para proporcionarle una solución de espacio aislado (que se encuentra en la carpeta de la zona de pruebas) que puede construir de forma autónoma. Construya este proyecto y asegúrese de que todo compila. Si lo hace, ¡genial! Si no lo hace, no siguió los pasos en la página de compilación, ¿verdad? Cuelga tu cabeza con vergüenza y vete a hacerlo esta vez. No te preocupes, esperaré ...

Ahora que todo ha construido su principal punto de interés es el proyecto sandbox_poc ("poc" = Prueba de concepto). Este proyecto es básicamente un envoltorio GUI mínimo alrededor de un sandbox que lanzará un dll arbitrario en un punto de entrada dado en un entorno de espacio aislado. Muestra todos los pasos necesarios para crear y usar un sandbox, y se trata de la mejor referencia que tiene. ¡Remítalo a menudo!

Cuando mires el código, probablemente notarás que el código que en realidad contiene es en sí mismo. Esto es muy común con todos los ejemplos de la zona de pruebas, y de acuerdo con este hilo (que puede estar desactualizado) es posiblemente la única forma de trabajo para la caja de arena en este momento. El hilo describe cómo uno teóricamente salvaguarda un proceso separado, pero no lo he intentado. Sin embargo, para estar seguro, tener una aplicación de auto llamada es el método del "bien conocido".

sandbox_proc incluye una gran cantidad de bibliotecas estáticas, pero parecen ser principalmente para la interfaz de usuario de muestra que han creado. Los únicos que he encontrado que parecen ser necesarios para una caja de arena mínima son:

sandbox.lib base.lib dbghelp.lib

Sin embargo, hay otra dependencia que no es del todo obvia al mirar el proyecto, y es lo que más me atrapó. Cuando creó la solución de wowhelper.exe , uno de los archivos de salida debe ser un " wowhelper.exe ". Aunque nunca se menciona en ninguna parte, ¡este archivo debe copiarse en el mismo directorio que el ejecutable que está creando! Si no es así, tus intentos de guardar el código siempre fallarán con un error genérico de "archivo no encontrado". ¡Esto puede ser muy frustrante si no sabes lo que está pasando! Ahora, estoy desarrollando en Windows 7 64 bits, que puede tener algo que ver con el requisito de wowhelper (WOW es un acrónimo común para aplicaciones de interoperabilidad entre 16/32 y 64 bits), pero no tengo una buena manera de probar eso. ahora mismo. ¡Por favor avíseme si alguien más se entera más!

¡Así que eso es todo lo del entorno, aquí hay un poco de código smaple para que empieces! Tenga en cuenta que aunque utilizo wcout en el proceso secundario aquí, no puede ver ningún resultado de la consola cuando se ejecuta en el entorno limitado. Cualquier cosa así debe ser comunicada al proceso principal a través de 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);
}
}

¡Con suerte eso es suficiente para que otros codificadores curiosos tengan un espacio aislado! ¡Buena suerte!

Answer 2

No estoy seguro de qué tipo de respuesta quieres ... Lo primero que debes hacer es consultar la reference código fuente de Chrome. Lo que nos interesa es esto:

sandbox: el proyecto de la zona de pruebas que intenta evitar que un procesador hackeado modifique el sistema.

Especulando alrededor de ese código, y buscando referencias API en la parte de Rendering del Chromium podrían ayudar.

procesador: código para el subproceso en cada pestaña. Esto integra WebKit y habla con el navegador para E / S.

Ve a ver qué pasa, probablemente puedas ver cómo Google usa su sandbox, espero que sea algo similar a

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

En general, este es el enfoque que uso cuando conozco una nueva base de código, verifico cómo se llama.