1) El documento describe la creación y gestión de procesos e hilos en Linux. Incluye ejemplos de cómo crear procesos con fork() y hilos con pthread_create(), y cómo comunicarlos y sincronizarlos con wait(), exit(), join() y otras funciones.
2) También explica conceptos básicos como los identificadores de proceso (pid), la estructura jerárquica de procesos, y cómo los procesos e hilos comparten y gestionan la memoria de forma independiente.
3) Finalmente, propone actividades prácticas
Pablo González - Jugando a lo Super Mario entre túneles y máquinas [rooted2018]RootedCON
Este documento presenta una introducción al pivoting, que es una técnica utilizada en pentesting para acceder a sistemas que no son directamente accesibles. Explica cómo establecer túneles SSH y usar port forwarding para conectarse a través de máquinas intermedias y evadir detecciones. También cubre el uso de portproxy en Windows y cómo integrar estas técnicas en Metasploit.
1) El documento presenta un borrador de un capítulo sobre memoria compartida, semaforos y colas de mensajes en Unix.
2) Describe las tres formas de comunicación entre procesos en Unix (memoria compartida, semaforos y colas de mensajes) y las llamadas del sistema relacionadas.
3) Explica cómo crear canales de comunicación entre procesos usando las llamadas get y el comando ipcs para verificar el estado de los canales.
Eduardo Blázquez - Técnicas de Ingeniería Inversa I & II [rooted2018]RootedCON
Esta charla tratará de enseñar todos los conocimientos básicos para poder llevar a cabo el análisis de un programa dentro de un debugger. Para esto, se enseñará la arquitectura y el lenguaje ensamblador usados en el intel x86 de 32 bits, para después realizar un reversing de un binario para la resolución de un crackme. La teoría, así como las técnicas mostradas en esta charla, servirán a todos los oyentes como bases necesarias en el mundo del análisis de malware, así como en el mundo del exploiting. Es por tanto recomendable a todos los oyentes que quieran seguir el ejemplo que se verá, traer un ordenador portatil con windows (puede usarse una máquina virtual) ya sea de 64 o 32 bits, con el debugger OllyDBG o el debugger x64debugger instalados.
Jose Selvi - Adaptando exploits para evitar la frustración [RootedSatellite V...RootedCON
El documento describe cómo adaptar un exploit para una vulnerabilidad (CVE-2012-6096) en un programa (history.cgi) para que funcione en un sistema objetivo diferente. Explica cómo depurar el programa CGI, identificar la dirección de retorno y las direcciones de funciones como system() y exit(), y construir una secuencia de instrucciones ROP para ejecutar comandos con privilegios de sistema a pesar de las protecciones como ASLR y NX.
Este documento presenta información sobre procesos y threads. Explica que los procesos son programas en ejecución identificados por un PID, mientras que los threads son unidades mínimas de trabajo que comparten el espacio de direcciones de un proceso. También describe herramientas para la sincronización de threads como mutexes y semáforos, e indica que el módulo threading de Python soporta la programación concurrente mediante threads mientras que multiprocessing permite la ejecución de procesos en paralelo.
Manuel Blanco - GNU/Linux Binary Exploitation I&II [rooted2018]RootedCON
Taller introductorio a la explotación de software GNU/Linux. Se explicarán diversos tipos de vulnerabilidades (corrupciones de memoria, fugas de información, condiciones de carrera, etc...) siguiendo metodologías actuales del desarrollo de exploits donde se sortearán las protecciones del sistema operativo.
Abel Valero - VM + VFS = The Wooden Horse [rooted2018]RootedCON
Se mostrara como analizar malware altamente ofuscado con tecnicas avanzadas como es la implementacion de una maquina virtual para evitar mostrar el codigo real.
El objetivo es descifrar todos y cada uno de los componentes de este malware obteniendo el codigo original antes de pasar por su VM.
Para ello se ha creado distintas herramientas que facilitan esta tarea, veremos como fueron implementandose.
Por ultimo analizaremos el payload final y las tecnicas que utiliza para realizar sus implantes en distintos procesos del sistema, como es el uso de un sistema de archivos virtual (VFS), utilizado para ocultar los distintos componentes.
Pablo González - Jugando a lo Super Mario entre túneles y máquinas [rooted2018]RootedCON
Este documento presenta una introducción al pivoting, que es una técnica utilizada en pentesting para acceder a sistemas que no son directamente accesibles. Explica cómo establecer túneles SSH y usar port forwarding para conectarse a través de máquinas intermedias y evadir detecciones. También cubre el uso de portproxy en Windows y cómo integrar estas técnicas en Metasploit.
1) El documento presenta un borrador de un capítulo sobre memoria compartida, semaforos y colas de mensajes en Unix.
2) Describe las tres formas de comunicación entre procesos en Unix (memoria compartida, semaforos y colas de mensajes) y las llamadas del sistema relacionadas.
3) Explica cómo crear canales de comunicación entre procesos usando las llamadas get y el comando ipcs para verificar el estado de los canales.
Eduardo Blázquez - Técnicas de Ingeniería Inversa I & II [rooted2018]RootedCON
Esta charla tratará de enseñar todos los conocimientos básicos para poder llevar a cabo el análisis de un programa dentro de un debugger. Para esto, se enseñará la arquitectura y el lenguaje ensamblador usados en el intel x86 de 32 bits, para después realizar un reversing de un binario para la resolución de un crackme. La teoría, así como las técnicas mostradas en esta charla, servirán a todos los oyentes como bases necesarias en el mundo del análisis de malware, así como en el mundo del exploiting. Es por tanto recomendable a todos los oyentes que quieran seguir el ejemplo que se verá, traer un ordenador portatil con windows (puede usarse una máquina virtual) ya sea de 64 o 32 bits, con el debugger OllyDBG o el debugger x64debugger instalados.
Jose Selvi - Adaptando exploits para evitar la frustración [RootedSatellite V...RootedCON
El documento describe cómo adaptar un exploit para una vulnerabilidad (CVE-2012-6096) en un programa (history.cgi) para que funcione en un sistema objetivo diferente. Explica cómo depurar el programa CGI, identificar la dirección de retorno y las direcciones de funciones como system() y exit(), y construir una secuencia de instrucciones ROP para ejecutar comandos con privilegios de sistema a pesar de las protecciones como ASLR y NX.
Este documento presenta información sobre procesos y threads. Explica que los procesos son programas en ejecución identificados por un PID, mientras que los threads son unidades mínimas de trabajo que comparten el espacio de direcciones de un proceso. También describe herramientas para la sincronización de threads como mutexes y semáforos, e indica que el módulo threading de Python soporta la programación concurrente mediante threads mientras que multiprocessing permite la ejecución de procesos en paralelo.
Manuel Blanco - GNU/Linux Binary Exploitation I&II [rooted2018]RootedCON
Taller introductorio a la explotación de software GNU/Linux. Se explicarán diversos tipos de vulnerabilidades (corrupciones de memoria, fugas de información, condiciones de carrera, etc...) siguiendo metodologías actuales del desarrollo de exploits donde se sortearán las protecciones del sistema operativo.
Abel Valero - VM + VFS = The Wooden Horse [rooted2018]RootedCON
Se mostrara como analizar malware altamente ofuscado con tecnicas avanzadas como es la implementacion de una maquina virtual para evitar mostrar el codigo real.
El objetivo es descifrar todos y cada uno de los componentes de este malware obteniendo el codigo original antes de pasar por su VM.
Para ello se ha creado distintas herramientas que facilitan esta tarea, veremos como fueron implementandose.
Por ultimo analizaremos el payload final y las tecnicas que utiliza para realizar sus implantes en distintos procesos del sistema, como es el uso de un sistema de archivos virtual (VFS), utilizado para ocultar los distintos componentes.
Este documento presenta un taller sobre programación paralela en C++11. Explica las principales características de los headers thread, mutex, condition variable y atomic, así como el uso de futures. Incluye ejemplos sobre la creación de hilos, el uso de join y detach, la identificación de hilos, y funciones como yield de this_thread.
Este documento describe el proceso de instalación y prueba de paquetes de código abierto para realidad aumentada. Se instalaron dependencias como OpenCV y GLUT, y paquetes como ARToolKit. Se compiló con éxito el ejemplo simpleTest.c usando un archivo Makefile. El script .sh permitió ejecutar el programa compilado y detectar con éxito un marcador usando la cámara web.
Clase 02 gestion de puertos - directivasalmidon_pcb
El documento describe varias directivas del compilador CCS utilizadas para la programación de microcontroladores PIC. Estas directivas incluyen #include, #fuses, #use delay, #bit, #byte, #define, void y main() para la gestión general del código. También cubre directivas específicas para la gestión de puertos como #use standard_io, set_tris_x, input, output_x y otras.
El documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, métodos públicos y privados. Explica el uso de constructores y destructores para inicializar y liberar recursos de objetos. También cubre temas como E/S con flujos, manejo de archivos y constructores parametrizados.
Este documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, constructores, destructores y funciones miembro. También cubre sobrecarga de operadores, funciones amigas y constructores de copia. El documento proporciona ejemplos para ilustrar cómo se implementan estos conceptos en C++.
Este documento presenta un tutorial introductorio sobre Python. Explica brevemente qué es Python, por qué es un lenguaje popular, cómo instalarlo e incluye un ejemplo de "Hola Mundo". Luego procede a explicar conceptos básicos de Python como tipos de datos, controles de flujo, orientación a objetos, módulos, entre otros temas. El documento parece estar dirigido a principiantes con el objetivo de enseñar los fundamentos del lenguaje Python de una manera simple y didáctica.
Este documento proporciona información sobre Tkinter, una librería de Python para crear interfaces gráficas de usuario. Explica qué es Tkinter, por qué usarla y describe varios widgets comunes como Frame, Label, Button, Entry, ComboBox, CheckButton, RadioButton, ScrolledText, SpinBox y MessageBox. Además, introduce los tipos mutables de Tkinter como IntVar, StringVar y BooleanVar que deben usarse con widgets para actualizar dinámicamente el texto mostrado. El objetivo general es crear una aplicación GUI básica con Tkinter para mostrar estos conceptos.
1. El documento introduce el lenguaje de programación Java, el cual es orientado a objetos y multiplataforma. 2. Explica las ventajas de Java como su orientación a objetos, simplicidad, portabilidad entre plataformas, robustez y facilidades para programación en red. 3. Cubre conceptos básicos de Java como tipos de datos, declaraciones, expresiones, conversiones de tipos, instrucciones de control e introducción a clases, arreglos, argumentos de programa y manejo de excepciones.
Python es un lenguaje de programación dinámico e interpretado que ofrece tipado dinámico, fuerte tipado, flexibilidad y portabilidad. Sus principales características incluyen una sintaxis limpia y legible similar al pseudocódigo, una amplia biblioteca estándar y ser multiplataforma. Python se puede utilizar para el desarrollo web, bases de datos, software, juegos, bioinformática, física y educación.
El documento describe los diferentes tipos de archivos complementarios que se utilizan en aplicaciones Windows, incluyendo bibliotecas estáticas (.lib), bibliotecas dinámicas (.dll), drivers (.drv, .sys) y drivers virtuales (.vxd). También explica cómo las aplicaciones pueden enlazarse con bibliotecas estáticas mediante la inclusión del archivo .lib y con bibliotecas dinámicas mediante la carga del archivo .dll en tiempo de ejecución.
DTrace es una herramienta de instrumentación desarrollada por Sun que permite analizar el comportamiento de sistemas Solaris en tiempo real sin afectar el rendimiento. Se compone de un lenguaje de programación llamado D y proveedores que publican sondas. Los programas DTrace se usan para definir sondas, predicados y acciones. También permite crear nuevos proveedores para instrumentar aplicaciones personalizadas.
Este documento presenta el código HDL para un decodificador BCD a 7 segmentos. Describe la interfaz del decodificador, incluyendo las entradas, salidas y funciones. Explica conceptos clave como palabras reservadas, vectores, funciones y case statements. Finalmente, los estudiantes proporcionan conclusiones sobre las similitudes entre la programación HDL y los lenguajes de alto nivel como Java.
Este documento describe la estructura básica de un programa en C++. Un programa en C++ típicamente incluye archivos de cabecera, declaraciones de variables globales, una función principal y otras funciones secundarias. La función principal contiene el cuerpo principal del programa, que puede incluir instrucciones declarativas, de entrada/salida, repetitivas y condicionales. Las funciones secundarias realizan tareas específicas y devuelven valores.
Este documento presenta una introducción al concepto de desbordamiento de buffer y cómo tomar el control del flujo de ejecución mediante esta vulnerabilidad. Explica conceptos técnicos como la pila del proceso, shellcodes y técnicas avanzadas como return-into-libc. El objetivo es ofrecer una comprensión de los aspectos técnicos subyacentes para poder subvertir el flujo de ejecución y ejecutar código arbitrario de forma segura.
Parcial I de Sistema de Operación – Semestre 201415Viviana Trujillo
Este documento contiene las instrucciones para un parcial sobre sistemas operativos. Incluye 5 preguntas con múltiples partes que cubren temas como variables de shell, makefiles, llamadas al sistema vs funciones de bibliotecas, procesos y jerarquías de procesos, scripts y compilación. Los estudiantes deben responder preguntas cortas, analizar código, explicar los pasos de comandos y crear un script recursivo o iterativo para calcular factoriales.
Este documento describe los tipos de datos escalares en Python, incluyendo números enteros, flotantes, complejos, fraccionarios y lógicos. Explica las reglas para crear identificadores de variables y palabras reservadas. También cubre operaciones aritméticas, conversiones de tipos numéricos, y funciones matemáticas como redondeo en el módulo math.
Compilador divisor de cantidades con Jflex y CupSoraya Lara
Este documento describe el desarrollo de un compilador divisor de cantidades utilizando las herramientas JFlex y CUP. JFlex se utiliza para generar el analizador léxico y reconoce tokens como números, operadores y fin de línea. CUP se utiliza para generar el analizador sintáctico y define la gramática formal que representa expresiones aritméticas válidas de división. El compilador verifica la sintaxis y realiza la operación de división, reportando errores si la entrada no es válida.
Este documento describe la estructura básica de un programa en C++, incluyendo secciones sobre archivos de cabecera, comentarios, directivas de preprocesador, la función main(), identificadores, entrada/salida mediante funciones como printf() y scanf(), variables y constantes, operadores, condicionales if-else y switch, bucles como for y while, y funciones. El documento ofrece una introducción general a los conceptos fundamentales de la programación en C++.
Este documento describe cómo crear procesos y hilos en C utilizando las bibliotecas fork(), pthread.h y otras funciones del sistema operativo Linux. Explica cómo medir el tiempo de creación de procesos y hilos, pasar parámetros a las funciones de los hilos, y esperar a que terminen los hilos antes de finalizar el programa principal. El objetivo es comparar el rendimiento de procesos frente a hilos al gestionar tareas concurrentes.
Este documento describe un cluster de 35 nodos que se utilizará para ejecutar aplicaciones paralelas mediante MPI. Explica cómo configurar el entorno MPI MPICH2, compilar y ejecutar programas paralelos en el cluster. También presenta algunos ejemplos simples de programas MPI como la activación de procesos, la paralelización de un bucle y la comunicación punto a punto mediante envío y recepción de mensajes.
Este documento presenta un taller sobre programación paralela en C++11. Explica las principales características de los headers thread, mutex, condition variable y atomic, así como el uso de futures. Incluye ejemplos sobre la creación de hilos, el uso de join y detach, la identificación de hilos, y funciones como yield de this_thread.
Este documento describe el proceso de instalación y prueba de paquetes de código abierto para realidad aumentada. Se instalaron dependencias como OpenCV y GLUT, y paquetes como ARToolKit. Se compiló con éxito el ejemplo simpleTest.c usando un archivo Makefile. El script .sh permitió ejecutar el programa compilado y detectar con éxito un marcador usando la cámara web.
Clase 02 gestion de puertos - directivasalmidon_pcb
El documento describe varias directivas del compilador CCS utilizadas para la programación de microcontroladores PIC. Estas directivas incluyen #include, #fuses, #use delay, #bit, #byte, #define, void y main() para la gestión general del código. También cubre directivas específicas para la gestión de puertos como #use standard_io, set_tris_x, input, output_x y otras.
El documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, métodos públicos y privados. Explica el uso de constructores y destructores para inicializar y liberar recursos de objetos. También cubre temas como E/S con flujos, manejo de archivos y constructores parametrizados.
Este documento explica los conceptos básicos de la programación orientada a objetos en C++. Define clases, objetos, constructores, destructores y funciones miembro. También cubre sobrecarga de operadores, funciones amigas y constructores de copia. El documento proporciona ejemplos para ilustrar cómo se implementan estos conceptos en C++.
Este documento presenta un tutorial introductorio sobre Python. Explica brevemente qué es Python, por qué es un lenguaje popular, cómo instalarlo e incluye un ejemplo de "Hola Mundo". Luego procede a explicar conceptos básicos de Python como tipos de datos, controles de flujo, orientación a objetos, módulos, entre otros temas. El documento parece estar dirigido a principiantes con el objetivo de enseñar los fundamentos del lenguaje Python de una manera simple y didáctica.
Este documento proporciona información sobre Tkinter, una librería de Python para crear interfaces gráficas de usuario. Explica qué es Tkinter, por qué usarla y describe varios widgets comunes como Frame, Label, Button, Entry, ComboBox, CheckButton, RadioButton, ScrolledText, SpinBox y MessageBox. Además, introduce los tipos mutables de Tkinter como IntVar, StringVar y BooleanVar que deben usarse con widgets para actualizar dinámicamente el texto mostrado. El objetivo general es crear una aplicación GUI básica con Tkinter para mostrar estos conceptos.
1. El documento introduce el lenguaje de programación Java, el cual es orientado a objetos y multiplataforma. 2. Explica las ventajas de Java como su orientación a objetos, simplicidad, portabilidad entre plataformas, robustez y facilidades para programación en red. 3. Cubre conceptos básicos de Java como tipos de datos, declaraciones, expresiones, conversiones de tipos, instrucciones de control e introducción a clases, arreglos, argumentos de programa y manejo de excepciones.
Python es un lenguaje de programación dinámico e interpretado que ofrece tipado dinámico, fuerte tipado, flexibilidad y portabilidad. Sus principales características incluyen una sintaxis limpia y legible similar al pseudocódigo, una amplia biblioteca estándar y ser multiplataforma. Python se puede utilizar para el desarrollo web, bases de datos, software, juegos, bioinformática, física y educación.
El documento describe los diferentes tipos de archivos complementarios que se utilizan en aplicaciones Windows, incluyendo bibliotecas estáticas (.lib), bibliotecas dinámicas (.dll), drivers (.drv, .sys) y drivers virtuales (.vxd). También explica cómo las aplicaciones pueden enlazarse con bibliotecas estáticas mediante la inclusión del archivo .lib y con bibliotecas dinámicas mediante la carga del archivo .dll en tiempo de ejecución.
DTrace es una herramienta de instrumentación desarrollada por Sun que permite analizar el comportamiento de sistemas Solaris en tiempo real sin afectar el rendimiento. Se compone de un lenguaje de programación llamado D y proveedores que publican sondas. Los programas DTrace se usan para definir sondas, predicados y acciones. También permite crear nuevos proveedores para instrumentar aplicaciones personalizadas.
Este documento presenta el código HDL para un decodificador BCD a 7 segmentos. Describe la interfaz del decodificador, incluyendo las entradas, salidas y funciones. Explica conceptos clave como palabras reservadas, vectores, funciones y case statements. Finalmente, los estudiantes proporcionan conclusiones sobre las similitudes entre la programación HDL y los lenguajes de alto nivel como Java.
Este documento describe la estructura básica de un programa en C++. Un programa en C++ típicamente incluye archivos de cabecera, declaraciones de variables globales, una función principal y otras funciones secundarias. La función principal contiene el cuerpo principal del programa, que puede incluir instrucciones declarativas, de entrada/salida, repetitivas y condicionales. Las funciones secundarias realizan tareas específicas y devuelven valores.
Este documento presenta una introducción al concepto de desbordamiento de buffer y cómo tomar el control del flujo de ejecución mediante esta vulnerabilidad. Explica conceptos técnicos como la pila del proceso, shellcodes y técnicas avanzadas como return-into-libc. El objetivo es ofrecer una comprensión de los aspectos técnicos subyacentes para poder subvertir el flujo de ejecución y ejecutar código arbitrario de forma segura.
Parcial I de Sistema de Operación – Semestre 201415Viviana Trujillo
Este documento contiene las instrucciones para un parcial sobre sistemas operativos. Incluye 5 preguntas con múltiples partes que cubren temas como variables de shell, makefiles, llamadas al sistema vs funciones de bibliotecas, procesos y jerarquías de procesos, scripts y compilación. Los estudiantes deben responder preguntas cortas, analizar código, explicar los pasos de comandos y crear un script recursivo o iterativo para calcular factoriales.
Este documento describe los tipos de datos escalares en Python, incluyendo números enteros, flotantes, complejos, fraccionarios y lógicos. Explica las reglas para crear identificadores de variables y palabras reservadas. También cubre operaciones aritméticas, conversiones de tipos numéricos, y funciones matemáticas como redondeo en el módulo math.
Compilador divisor de cantidades con Jflex y CupSoraya Lara
Este documento describe el desarrollo de un compilador divisor de cantidades utilizando las herramientas JFlex y CUP. JFlex se utiliza para generar el analizador léxico y reconoce tokens como números, operadores y fin de línea. CUP se utiliza para generar el analizador sintáctico y define la gramática formal que representa expresiones aritméticas válidas de división. El compilador verifica la sintaxis y realiza la operación de división, reportando errores si la entrada no es válida.
Este documento describe la estructura básica de un programa en C++, incluyendo secciones sobre archivos de cabecera, comentarios, directivas de preprocesador, la función main(), identificadores, entrada/salida mediante funciones como printf() y scanf(), variables y constantes, operadores, condicionales if-else y switch, bucles como for y while, y funciones. El documento ofrece una introducción general a los conceptos fundamentales de la programación en C++.
Este documento describe cómo crear procesos y hilos en C utilizando las bibliotecas fork(), pthread.h y otras funciones del sistema operativo Linux. Explica cómo medir el tiempo de creación de procesos y hilos, pasar parámetros a las funciones de los hilos, y esperar a que terminen los hilos antes de finalizar el programa principal. El objetivo es comparar el rendimiento de procesos frente a hilos al gestionar tareas concurrentes.
Este documento describe un cluster de 35 nodos que se utilizará para ejecutar aplicaciones paralelas mediante MPI. Explica cómo configurar el entorno MPI MPICH2, compilar y ejecutar programas paralelos en el cluster. También presenta algunos ejemplos simples de programas MPI como la activación de procesos, la paralelización de un bucle y la comunicación punto a punto mediante envío y recepción de mensajes.
Este documento habla sobre la construcción de rootkits básicos. Explica qué es un rootkit, los tipos comunes, y funciones como esconder procesos y archivos. Luego cubre consideraciones para desarrollo en kernel vs espacio de usuario, y ejemplos como módulos "Hello World" y manejo de parámetros. Por último, aborda temas avanzados como trabajar con la estructura de tareas, esconder el módulo cargado, y técnicas de hijacking como la tabla de syscalls y VFS.
Este documento describe tres prácticas relacionadas con Asterisk Gateway Interface (AGI). La Parte I explica cómo crear un script PHP para leer números de un archivo de texto y reproducirlos mediante AGI. La Parte II instruye cómo crear una extensión para llamar a un script AGI sin parámetros que reproduzca dos archivos de audio. La Parte III instruye cómo configurar un cable T1 cruzado para una práctica de troncales digitales.
En este taller práctico aprenderemos a desarrollar módulos de Kernel que funcionen como rootkits. Al final del taller el participante podrá mostrar un pequeño rootkit que funcione como keylogger. Entenderá y desarrollara técnicas para ocultarse y métodos anti-forenses.
Objetivo Principal:
Aprender las técnicas de desarrollo de Rootkits
Objetivos Secundarios:
Conocer las características del Kernel.
Aprender a generar módulos de Kernel
Conociendo algunas téncias (VFS Hijacking, Syscall Hijacking, StructTask Hijack, Infecting LKM’s)
Temario
Introducción a los Rootkits
Introducción a los Módulos de Kernel
Consideraciones de Programación
Parámetros de Módulos
Estructuras del Kernel
Hijacking
Prácticas
El módulo “Hello World”
Manejando Parámetros en el módulo.
Trabajando con la task_struct
Escondiendo módulos
Hijacking de /proc
Hijacking de syscall
Creando de un keylogger
Requisitos:
Conocimientos medios en C
Manejo básico/medio de linux
Una PC/Laptop con VirtualBox (Se entregará a cada participante una imágen con Debian 64Bits para que comiencen a desarrollar).
Este documento presenta un tutorial de C++ dividido en 23 capítulos. El tutorial utiliza ejemplos sencillos de código para explicar conceptos básicos como funciones, tipos de datos, clases, herencia, entre otros. Cada capítulo contiene uno o más fragmentos de código con comentarios que describen su funcionalidad. El objetivo del tutorial es servir como referencia rápida para aprender los fundamentos del lenguaje C++.
Linux Kernel - System Calls - Modules - DriversMartin Baez
Este documento resume los conceptos clave de los sistemas operativos, incluyendo: 1) El kernel, system calls y módulos; 2) Cómo las system calls permiten a los procesos de usuario acceder a funciones del kernel; 3) Los módulos extienden la funcionalidad del kernel sin necesidad de recompilarlo. También explica los dispositivos y cómo los controlan los drivers implementados como módulos del kernel.
El documento presenta un ejercicio sobre la creación de procesos en paralelo mediante el uso de fork en C. Se proporciona un programa que crea dos procesos de forma secuencial esperando a que cada uno finalice antes de crear el siguiente. Se pide modificar el programa para que ambos procesos se creen simultáneamente y el proceso padre espere a la finalización de ambos. Luego, se muestra la solución modificada usando dos llamadas a fork seguidas de dos wait para esperar a los dos procesos hijos.
El documento describe cómo instalar y usar Flex en Windows para generar analizadores léxicos. Explica cómo instalar MinGW y Flex, y provee ejemplos simples de analizadores léxicos para reemplazar un nombre de usuario, reconocer números y palabras clave en un archivo de texto, y contar palabras, líneas y caracteres en un archivo.
El documento describe los procesos en Linux, incluyendo que cada proceso tiene un número de identificación único (PID), que el proceso que crea otro proceso se llama proceso padre y el creado proceso hijo. También describe las librerías estándar utilizadas en C para la entrada/salida, manejo de archivos y procesos, así como funciones como fork(), getpid(), getppid() y getuid() para crear y obtener información de procesos. Finalmente, incluye ejemplos de código C para imprimir información de procesos y crear
El documento describe SystemTap, una herramienta que permite extraer información del kernel de Linux en ejecución. SystemTap permite escribir scripts que nombran eventos y les asignan manejadores. Cuando ocurren los eventos, los manejadores recopilan y resumen datos del kernel. Los scripts de SystemTap se compilan a módulos de kernel que se cargan para recopilar datos. La herramienta facilita el diagnóstico de problemas de rendimiento y funcionalidad del sistema rastreando eventos del kernel como la entrada y salida de funciones.
El documento describe los conceptos fundamentales de la multiprogramación y los procesos en sistemas operativos. Explica cómo el SO mantiene múltiples procesos en ejecución mediante el uso de estructuras de datos como PCB y colas de procesos, y cambia entre procesos a través del cambio de contexto. También describe cómo los procesos se comunican entre sí mediante el uso de tuberías y señales.
(1) El documento describe cómo Unix implementa el ciclo de vida de los procesos mediante el uso de funciones como fork(), exec(), wait() y exit(). (2) Cada proceso tiene un identificador único (PID) y mantiene información como el PID de su proceso padre (PPID), identificadores de usuario y grupo, y estado. (3) Unix administra los procesos rotando el uso del procesador entre procesos listos para ejecutar de forma que todos parezcan avanzar simultáneamente aunque sólo uno ejecute a la vez.
Sistemas Distribuidos y Paralelismo - Unidad 2ingnucious
Este documento habla sobre los sistemas distribuidos y paralelos, específicamente sobre el pasaje de mensajes. Explica las características del pasaje de mensajes, la máquina virtual paralela PVM, y provee ejemplos de cómo usar PVM para la creación de procesos, el envío y recepción de mensajes, y la comunicación entre grupos de procesos.
Este documento describe los conceptos de memoria estática y dinámica en los sistemas de computación. Explica que la memoria estática es asignada por el compilador para elementos fijos del programa, mientras que la memoria dinámica es asignada y liberada dinámicamente durante la ejecución. También cubre temas como la asignación de memoria, el uso de pilas y colas, y el recolector de basura.
Presentación para el Hackmeeting III (MadHack 2002) que tuvo lugar entre los días 4 y 6 de octubre del 2002 en el Laboratorio 3 en Lavapies, Madrid. (v 1.0).
Describe los tipos de exploits más habituales, análisis de shellcodes comunes, sistemas de protección "anti-exploits", sistemas de evasión en shellcodes anti IDS y el código fuente contiene descripción detallada de su contenido.
Esta práctica presenta ejemplos básicos de programación en Arduino para la lectura de sensores, evaluando ejemplos sencillos en un simulador online. El objetivo es conocer el entorno de programación de Arduino, programar códigos sencillos y entender la adquisición de señales analógicas. Se incluyen dos tutoriales sobre programación básica en Arduino y el uso del simulador online.
Este documento describe los conceptos básicos de la programación orientada a objetos en C++. Explica las clases, objetos, constructores, destructores, sobrecarga de operadores, funciones amigas y constructores de copia. También cubre temas como el manejo de ficheros, formatos de entrada y salida, y constructores parametrizados.
Los puentes son estructuras esenciales en la infraestructura de transporte, permitiendo la conexión entre diferentes
puntos geográficos y facilitando el flujo de bienes y personas.
NTP 223 NORMAS PARA TRABAJO SEGURO EN ESPACIOS CONFINADOS. Ing. Josue Donoso ...
procesos
1. Practica 2. Creación de procesos e hilos
1. Objetivos
1).-Que el alumno aprenda a crear procesos y a controlar la estructura jerár-
quica resultante con las llamadas al sistema fork, getpid, getppid, wait y exit.
2).-Que el alumno aprenda a gestionar hilos con la biblioteca de funciones
pthread (POSIX Threads).
2. Introducción
2.1. Creación de proceso con fork.
Un proceso es cualquier programa o comando en ejecución con un identifica-
dor de proceso o pid asignado por el sistema y que está en alguno de los siguientes
estados: Running (R), Sleeping (S), Waiting (D), Stopped (T) o Zombie (Z). To-
dos los procesos, exepto el proceso init cuyo pid es 1, tienen un proceso creador
al cual llamamos su proceso padre. Una llamada al sistema para crear procesos en
Linux es fork() y su declaración es:
#include <unistd.h>
#include <sys/types.h>
pid_t fork(void);
Después de la invocación de fork() se crea un proceso hijo con el mismo
código que el proceso padre y una copia de sus datos (variables y valores). El
proceso padre recibe como valor de retorno un entero positivo que corresponde
al pid de su hijo y el proceso hijo recibe como valor de retorno 0, este valor
se pude utilizar para controlar las instrucciones que debe ejecutar cada proceso.
Por otro lado, fork() regresa -1 si el proceso hijo no se puede crear. Ambos
procesos continúa con la ejecución del programa a partir del fork() de manera
concurrente. Ambos procesos comparten los archivos abiertos pero cada uno tiene
1
2. su propio contador de programa. Adicionalmente, las funciones getpid() y
getppid() regresan el pid y el ppid (pid del proceso padre) de quien las invoca,
su declaración es:
#include <unistd.h>
pid_t getpid(void);
pid_t getppid(void);
Ejemplo 1.
/*
* $ gcc 1fork.c -o fork
* $ ./fork
*
* Después de invocar fork(): El proceso hijo incrementa en uno
*sus variables y escribe el resultado en el archivo salida.txt, el proceso
*padre incrementa en dos sus variables y escribe el resultado en el archivo
*salida.txt, ambos procesos imprimen el contenido del archivo.
*
*Cada proceso maneja sus variables de forma independiente aun siendo globales.
*Los dos procesos tienen acceso concurrente al archivo, cada proceso cierra el
archivo para sí mismo.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int x=1; //variable global
int main()
{
pid_t ret;
FILE *apArch;
int y=2; //variable local
if( (apArch=fopen("salida.txt","w")) == NULL ){
printf("Error al abrir archivon");
exit(0);
}
ret=fork();
switch(ret){
case -1:printf("No se pude crear un proceso hijo.n");
break;
case 0: x=x+1;
y=y+1;
fprintf(apArch,"soy el proceso hijo pid: %d, pidPadre: %d, x= %d,y
= %dn",getpid(),getppid(),x,y);
fclose(apArch);
break;
default:x=x+2;
y=y+2;
2
3. fprintf(apArch,"soy el proceso padre pid: %d, pidHijo: %d, x= %d,y
= %dn",getpid(),ret,x,y);
fclose(apArch);
}
system("cat ./salida.txt"); //Muestra el contenido del archivo
//lo hacen los dos procesos.
return 1;
}
Compilación y ejecución
$ gcc 1fork.c -o fork
$ ./fork
soy el proceso padre pid:17275, pidHijo: 17276, x=3,y=4
soy el proceso hijo pid:17276, pidPadre: 17275, x=2,y=3
soy el proceso padre pid:17275, pidHijo: 17276, x=3,y=4
soy el proceso hijo pid:17276, pidPadre: 17275, x=2,y=3
2.2. Comunicación mediante wait y exit.
Después de una invocación a fork() el proceso padre puede esperar la ter-
minación de su hijo con la función wait() y su hijo puede avisarle a su padre
que ya terminó con la función exit(), su declaración es:
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
pid_t wait(int *status);
void exit(int st);
exit() termina el proceso que la invoca y le regresa el valor de st al sistema
quien lo almacena en status. wait() bloquea la ejecución del proceso padre
hasta que alguno de sus procesos hijos invoca exit(). wait() regresa el pid
del proceso que invocó exit() y continúa ejecutándose, dos de las macros que
se pueden utilizar para evaluar el contenido de status son:
WIFEXITED(status) Distinto de cero si el hijo terminó normalmente.
WEXITSTATUS(status) Evalúa los ocho bits menos significativos del
código de retorno del hijo, puede ser el argumento de exit() o de return(),
es decir st.
3
4. Ejemplo 2 y 3
Descargar el .zip de moodle.
Compilación y ejecución
$ gcc 2fork.c -o fork
$ ./fork
$ ps -eo pid,user,comm|grep fork|head -n 1|awk ’{print $1}’|xargs pstree -cp
$ gcc 3fork.c -o fork
$ ./fork
$ ps -eo pid,user,comm|grep fork|head -n 1|awk ’{print $1}’|xargs pstree -cp
2.3. Hilos POSIX
POSIX Threads (Portable Operating System Interface Threads) es una biblio-
teca de funciones proporcionada por los sistemas operativos tipo UNIX para la
gestión de hilos. Para trabajar con hilos POSIX es necesario incluir la biblioteca
de funciones pthread.h en el encabezado de los programas en lenguaje C y
compilar con la opción lpthread. Algunas de sus funciones son:
#include <pthread.h>
int pthread_create(pthread_t *tid, const pthread_attr_t
*attr, (void *)(*star_routine)(void *), void *arg);
void pthread_exit(void *value_ptr);
int pthread_join(pthread_t thread, void **value_ptr);
La función pthread_create sirve para crear hilos, regresa 0 si tuvo éxito
y un valor de error en caso contrario, sus argumentos deben ser:
tid Un apuntador a la variable donde se almacenará el identificador del
hilo, si es que la llamada tuvo éxito.
attr Es un apuntador a la variable donde se almacenan los atributos que
el sistema debe asignar al hilo. Si es igual a NULL, tendrá los atributos por
omisión.
(*star_routine) Es una referencia a la función que el hilo ejecuta
cuando es creado. La función devuelve un apuntador sin tipo (void *) y
su único argumento es un apuntador sin tipo (void *). Para poder utilizar
un argumento de otro tipo se debe hacer un cast al recuperar el valor.
4
5. arg Es el argumento que se le pasa a la función star_routine().
La función pthread_exit termina el hilo que la invoca. El valor del argu-
mento value_ptr queda disponible para pthread_join si la primera tuvo
éxito. value_ptr debe apuntar a datos que existan después de que el hilo ter-
mine.
La función pthread_join suspende la ejecución del hilo que la invoca has-
ta que el hilo identificado con thread termine, ya sea porque llamó a pthread_exit
o por que fue cancelado. Si value_ptr no es NULL, entonces el valor retornado
por thread es almacenado en la ubicación apuntado por value_ptr.
Ejemplo 4.
El hilo principal crea dos hilos y espera a que termine su ejecución, cada uno
ejecuta la función ejecutaHilo() con la cual imprime un mensaje y termina,
cada hilo se ejecuta a su propia velocidad. Las variables h1 y h2 son referencias
a los hilos, asignadas por posix.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
void ejecutaHilo();
void main()
{
pthread_t h1,h2;
pthread_create(&h1,NULL,(void *)&ejecutaHilo,NULL);
pthread_create(&h2,NULL,(void *)&ejecutaHilo,NULL);
pthread_join(h1,NULL);
pthread_join(h2,NULL);
}
void ejecutaHilo()
{
printf("Hilo en ejecución...n");
sleep(5);
pthread_exit(NULL);
}
Compilación y ejecución
$ gcc ejemplo1.c -lpthread
$ ./a.out
Hilo en ejecución...
Hilo en ejecución...
5
6. Mientras se está ejecutando, hacer lo siguiente en otra terminal:
$ ps -eo pid,user,comm|grep a.out|head -n 1|awk ’{print $1}’|xargs pstree -cp
a.out(4411)-----{a.out}(4412)
|--{a.out}(4413)
Ejemplo 5.
La biblioteca de funciones pthread.h le asigna a cada hilo un identificador
que se guarda en tid, y se puede obtener con la función pthread_self(). Por
otro lado Linux también le asigna un identificador a cada hilo, el cual se puede
obtener con la llamada al sistema SYS_gettid que no pertenece a C. Además
los hilos pueden ser nombrados por los argumentos de la función que ejecutan.
Lo anterior se muestra en el siguiente código.El hilo principal crea dos hilos,
cada uno ejecuta la función ejecutaHilo() que recibe un id asignado por el
programa, el hilo imprime dicho identificador junto con los identificadores asig-
nados por posix y por Linux.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <syscall.h>
void ejecutaHilo(void *id);
void main()
{
pthread_t h1,h2;
int id1=10, id2=20;
pthread_create(&h1,NULL,(void *)&ejecutaHilo,(void *)&id1);
printf("hilo1( %u) creadon",(unsigned int)h1);
pthread_create(&h2,NULL,(void *)&ejecutaHilo,(void *)&id2);
printf("hilo2( %u) creadon",(unsigned int)h2);
pthread_join(h1,NULL);
pthread_join(h2,NULL);
}
void ejecutaHilo(void *id)
{
int *idh=(int *)(id);
int tid=syscall(SYS_gettid);//LLamada al sistema explícita, para obtener el
id de Linux
printf("Hilo en ejecución con idPosix= %u, idLinux= %d, idPrograma= %dn",(int)
pthread_self(),tid,*idh);
sleep(7);
pthread_exit(NULL);
}
6
7. Compilación y ejecución
$ gcc ejemplo2.c -o -lpthread
$ ./a.out
hilo1(2075494144) creado
Hilo en ejecución con idPosix=2075494144, idLinux=4262, idPrograma=10
hilo2(2067101440) creado
Hilo en ejecución con idPosix=2067101440, idLinux=4263, idPrograma=20
Mientras se está ejecutando, hacer lo siguiente en otra terminal:
$ ps -eo pid,user,comm|grep a.out|head -n 1|awk ’{print $1}’|xargs pstree -cp
a.out(4411)-----{a.out}(4412)
|--{a.out}(4413)
Ejemplo 6.
Notar el uso de pthread_join y pthread_exit.
Notar que se pude hacer referencia al id asignado por posix con h1 y h2,
sin necesidad de utilizar pthread_self()
Es decir, que los hilos se pueden gestionar con el id asignado por posix (h1
y h2), sin necesidad de conocer el id asignado por Linux.
Notar que comparten memoria: Pueden leer las variables globales y las re-
ferencias a memoria (apuntadores) son sobre un espacio de memoria com-
partido.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int varGlobal = 1000; //compartida por los hilos.
void ejecutaHilo(void *id); //ejecutada por los hilos.
void main()
{
pthread_t h1,h2; //id posix para los hilos
int v1=5, v2=6; //argumentos para la función que ejecutan los hilos
int *r1=NULL; //para guardar el valor de exit y leerlo con join
int i;
pthread_create(&h1,NULL,(void *)&ejecutaHilo,(void *)&v1);
pthread_create(&h2,NULL,(void *)&ejecutaHilo,(void *)&v2);
for(i=0;i<10;i++){
printf("Hilo principal, varGlobal= %dn",varGlobal+=1);
sleep(1);
}
7
8. pthread_join(h1,(void **)&r1);
printf("hilo1 termina con: %dn",*r1);
pthread_join(h2,(void **)&r1);
printf("hilo2 termina con: %dn",*r1);
}
void ejecutaHilo(void *v)
{
int *vh=(int *)(v);
sleep(*vh); //utiliza el argumento recibido.
printf("Hilo que recibe %d, espera %ds, imprime varGlobal= %d, modifca val
recibidon",*vh,*vh,varGlobal);
*vh=5*(*vh); //modifica el argumento recibido.
pthread_exit(vh); //termina y deja vh para el join.
}
Compilación y ejecución
$ gcc ejemplo3.c -lpthread
$ ./a.out
Hilo principal, varGlobal=1001
Hilo principal, varGlobal=1002
Hilo principal, varGlobal=1003
Hilo principal, varGlobal=1004
Hilo principal, varGlobal=1005
Hilo que recibe 5, espera 5s, imprime varGlobal=1005, modifca val recibido
Hilo principal, varGlobal=1006
Hilo que recibe 6, espera 6s, imprime varGlobal=1006, modifca val recibido
Hilo principal, varGlobal=1007
Hilo principal, varGlobal=1008
Hilo principal, varGlobal=1009
Hilo principal, varGlobal=1010
hilo1 termina con: 25
hilo2 termina con: 30
Mientras se está ejecutando, hacer lo siguiente en otra terminal:
$ ps -eo pid,user,comm|grep ej1hilos|head -n 1|awk ’{print $1}’|xargs pstree -cp
a.out(4736)-----{a.out}(4737)
|--{a.out}(4738)
8
9. 3. Actividades.
1. Construir un árbol binario de procesos de altura N. Hacer que N sea gene-
rado aleatoriamente y que el nodo raíz imprima el número total de hijos.
Utilizar sleep() para poder visualizar el árbol con el comando visto en los
ejercicios.
NOTA. No utilizar recursividad.
2. Modificar el ejemplo cuatro para que cada hilo genere dos hilos más y es-
pere su finalización. Explicar qué es lo que pasa ¿Quién es el padre de los
nuevos hilos? Mostrar el árbol de procesos (hilos).
3. Modificar el ejemplo uno para que un hilo clone al proceso con fork(). Ex-
plicar qué es lo que pasa ¿También se clonan los hilos? Mostrar el árbol de
procesos (hilos).
4. Después de haber ejecutado el fork() del punto anterior. Dado que todos los
hilos comparten los recursos del proceso al que pertenecen ¿Es posible que
un hilo sepa a qué proceso pertenece? En caso afirmativo ¿Cómo?
5. Modificar el ejemplo tres para que genere N hilos y los guarde en un arreglo.
Cada hilo debe ejecutar la función ejecutaHilo recibiendo como argu-
mento la localidad (i) donde se encuentra el hilo, el hilo debe escribir su va-
lor i en la variable global y salir con pthread_exit(). El hilo principal
debe esperar por cada uno de los hilos con la función pthread_join().
N debe ser definido en el programa o dado por el usuario. Asegurarse de que
los hilos se ejecuten concurrentemente, es decir, no serializar la ejecución
con sleep u otro código.
6. ¿Cuál es el valor que se espera que tenga la variable global? y ¿Por qué?
7. Hacer que cada hilo del programa anterior, además de su identificador (i),
imprima quien es su vecino posterior (i+1) y anterior (i-1), suponiendo que
el arreglo es circular. Notar que no es necesaria la comunicación entre hilos,
cada hilo debe calcular i-1 e i+1 a partir de i.
9