Filtrado de Llamadas al Sistema Automatizado para la Seguridad del Servidor

Las aplicaciones de servidor se comunican con el sistema operativo a través de Llamadas al sistema, que son solicitudes al SO para realizar tareas. Con el tiempo, el número de estas llamadas ha crecido a medida que las aplicaciones se han vuelto más complejas. Este crecimiento presenta riesgos de Seguridad, ya que las aplicaciones sin privilegios pueden explotar vulnerabilidades en estas llamadas.

Para combatir estos riesgos, algunas estrategias buscan limitar el número de llamadas al sistema que una aplicación puede usar según sus necesidades. Al restringir llamadas innecesarias, podemos reducir las posibilidades de ataques al núcleo y mejorar la seguridad en general.

Este documento presenta un sistema de filtrado automático diseñado para aplicaciones de servidor. A diferencia de métodos anteriores, este sistema funciona sin necesidad de acceso al código fuente de la aplicación, lo que significa que puede operar en binarios compilados. Esto es crucial para mejorar la seguridad del servidor sin requerir cambios en el código original de la aplicación.

#El Problema con las Llamadas al Sistema

Cada aplicación requiere varias llamadas al sistema para funcionar correctamente. Sin embargo, muchas de estas llamadas se vuelven innecesarias después de que la aplicación ha comenzado. Por ejemplo, un servidor web puede necesitar un conjunto diferente de permisos una vez que comienza a manejar solicitudes de clientes en comparación con cuando está arrancando.

Las soluciones actuales a menudo dependen de saber cómo clasificar estas llamadas en fases: inicialización y servicio. Sin embargo, estos métodos suelen requerir acceso al código fuente de la aplicación, el cual no siempre está disponible. Esta realidad limita su efectividad.

Además, los métodos existentes normalmente exigen que un usuario identifique manualmente cuándo la aplicación pasa de una fase a otra. Este proceso puede ser propenso a errores, lo que lleva a una comprensión incompleta de qué llamadas deberían ser permitidas en un momento dado.

#Nuestro Enfoque

Presentamos un nuevo sistema que automatiza la identificación de las fases de una aplicación de servidor sin necesidad de acceso al código fuente. Nuestra solución combina Análisis Estático y dinámico para determinar qué llamadas al sistema son necesarias durante la fase de servicio de la aplicación.

#Técnicas Clave

1. Identificación de Fase: Nuestro sistema detecta automáticamente la fase de servicio de la aplicación observando sus patrones de ejecución de manera dinámica. Buscamos estructuras de bucle específicas que indican dónde ocurre el trabajo principal de la aplicación.

2. Análisis Estático: Analizamos el código binario para crear un gráfico de llamadas de función. Este gráfico nos ayuda a identificar cómo interactúan diferentes funciones y qué llamadas al sistema pueden invocar.

3. Análisis Dinámico: Mientras que nuestro análisis estático nos da un buen punto de partida, también observamos ejecuciones reales de la aplicación. Esto nos da datos en tiempo real sobre qué llamadas se están realizando durante la fase de servicio.

4. Filtrado Automatizado: Una vez que recopilamos suficiente información, creamos un filtro que asegura que solo se permitan las llamadas al sistema necesarias durante la fase de servicio. Esto ayuda a prevenir posibles exploits limitando las capacidades de cualquier aplicación comprometida.

#Evaluación

Probamos nuestro sistema de filtrado usando aplicaciones de servidor populares en Linux x86-64. A través de varios experimentos, demostramos que nuestro sistema identifica de manera efectiva las fases de servicio, genera filtros precisos de llamadas al sistema y reduce la superficie de ataque de cada aplicación.

#Resultados

Nuestros hallazgos mostraron que:

• Nuestro sistema supera los enfoques anteriores que solo usan binarios.
• Logra resultados comparables a métodos que dependen del código fuente.
• Nuestro filtro permite aproximadamente un 8.33% más de llamadas al sistema que las soluciones basadas en código fuente, mientras que filtra llamadas críticas para la seguridad en el 88.23% de los casos.

#Reducción de Superficie de Ataque

Las mejoras en seguridad fueron evidentes en nuestras pruebas. Evaluamos cuántas vulnerabilidades conocidas del núcleo podrían ser explotadas sin nuestro filtro. Los resultados confirmaron que nuestro filtrado reduce significativamente el riesgo al bloquear posibles ataques.

#Manejo de Bibliotecas Dinámicas

Otro desafío en el filtrado es lidiar con bibliotecas cargadas dinámicamente. Muchas aplicaciones cargan componentes adicionales en tiempo de ejecución, lo que puede requerir sus propias llamadas al sistema. Nuestro sistema identifica con éxito estas bibliotecas y resuelve sus dependencias, asegurando que todas las llamadas necesarias estén contabilizadas.

#Importancia de las Bibliotecas Dinámicas

Las bibliotecas dinámicas añaden flexibilidad a las aplicaciones, pero complican la seguridad. Si estas bibliotecas no se filtran adecuadamente, pueden llevar a vulnerabilidades.

#Nuestra Solución

Nuestro enfoque incorpora tanto análisis estático para predecir qué bibliotecas podrían ser cargadas como análisis dinámico para rastrear las llamadas reales realizadas durante la ejecución. Este enfoque híbrido nos permite filtrar eficazmente las llamadas necesarias.

#Metodología de Filtrado de Llamadas al Sistema

Nuestro método involucra varios pasos para asegurar la precisión en el filtrado de llamadas al sistema.

#1. Construcción del Gráfico de Llamadas de Función

Comenzamos construyendo un gráfico de llamadas de función para la aplicación. Este gráfico representa cómo están conectadas diferentes funciones y qué llamadas podrían hacer.

#2. Identificación de Llamadas al Sistema Alcanzables

A continuación, determinamos qué llamadas al sistema son alcanzables desde el punto de transición identificado anteriormente. Esto implica rastrear todos los caminos potenciales en el gráfico de llamadas de función para ver qué llamadas se pueden hacer.

#3. Generación del Filtro

Finalmente, usando la información recopilada, generamos un filtro que especifica qué llamadas al sistema están permitidas durante la fase de servicio. Este filtro se implementa en la aplicación para asegurarse de que solo use las llamadas necesarias.

#Evaluación de Seguridad

Realizamos una evaluación exhaustiva de seguridad de nuestro sistema de filtrado probándolo contra vulnerabilidades conocidas y métodos de ataque.

#Bloqueo de Exploits

En nuestras pruebas, nuestro sistema bloqueó con éxito un porcentaje significativo de intentos de exploit al filtrar llamadas de sistema críticas.

#Mitigación de Vulnerabilidades

También examinamos qué tan bien ayuda nuestro filtrado a mitigar vulnerabilidades del núcleo. Los resultados indicaron una mejora significativa en seguridad, con nuestro sistema previniendo exploits que podrían aprovechar llamadas al sistema no filtradas.

#Conclusión

Nuestra solución de filtrado automático de llamadas al sistema representa un avance significativo en la seguridad de las aplicaciones de servidor. Al eliminar llamadas al sistema innecesarias durante la fase de servicio y manejar adecuadamente las bibliotecas cargadas dinámicamente, proporcionamos una defensa robusta contra ataques potenciales.

Este enfoque no solo mejora la seguridad, sino que también simplifica el proceso de ajuste de permisos de aplicación, facilitando a los desarrolladores proteger su software sin necesidad de alterar el código original.

Nuestros hallazgos subrayan el potencial de los sistemas de filtrado automático en la seguridad de aplicaciones de servidor mientras establecen las bases para futuros avances en esta área crítica.