25
Jan
2014

Nvidia NVS 5400 (Optimus) propietary driver on Linux Mint 16

For about 6 months, since I’m using the Nvidia NVS 5400 (with Optimus technology) video card, I’ve been having weird random crashes at boot time. Optimus was disabled at UEFI and I tried many versions of the Nvidia closed drivers. This happened both in Linux Mint 15 and Linux Mint 16 and no kernel upgrade (at least for now) solved it.

I disabled nouveau and nvidia drivers and booted on plain text mode. What I noticed was a repetitive sequence of events: 1. grub started fine, 2. a video controlled was used by the kernel, 3. at some point, the video controller was switched for a new one and that was the moment of the random crash. If the system crashed, no log nor output was given: only a freeze (sometimes black) screen. I think this issue is in the new video controller, that doesn’t load well every time or can’t handle the nvidia chipset.

So, If you are stuck on this, what I did was editing the /etc/default/grub file replacing GRUB_CMDLINE_LINUX_DEFAULT var with the following: GRUB_CMDLINE_LINUX_DEFAULT=”video=vga text nvidia.blacklist=1 nomodeset”. Then you have to run updagrade-grub2. nomodeset does the trick: when we disable KMS (Kernel Mode-setting) system boots with a fallback/legacy video controller and no crashes. After booting, we log in using the command line interface, run startx and we are on desktop with nvidia drivers loaded.

Of course we won’t have a beautiful graphic splash boot screen but works like a charm! No crashes, no pain.

22
Oct
2013

Configure Eclipse CDT with symbol and include path resolution (Linux GCC toolchain)

After installing Eclipse CDT (Eclipse for C/C++ development) and G++ (GCC for C++) in my Linux Mint distro, I discovered that symbol and include path resolution for C++ couldn’t be done using the Linux GCC toolchain. Although the program was compiling perfectly, the Eclipse analyzer showed everything as missing in the GUI. It was pretty strange because I noticed that manually adding the symbols and include paths to the project (through the project settings) resolved the problem, but the default C++ project using Cross GCC toolchain didn’t need this to be okay.

After looking-at and trying every single-option in the Eclipse preferences, I came to the solution. I’d like to share it because I didn’t find much useful information using Google.

Go to Window -> Preferences -> C/C++ -> New C/C++ Project Wizard -> Makefile Project -> Discovery Options. In the Discovery profile scope dropdown menu select the option Per language. Select GNU C++ in Tools and check the option Automate discovery of paths and symbols.

Now, include paths and symbols are added as part of the CDT GCC built-in Compiler Settings, for the GNU C++ language.

25
May
2013

Fin de una etapa laboral

 

Deloitte

 

Ayer fue un día especial para mí porque cerré mi etapa laboral en Deloitte, comenzada por el año 2010.

Quiero agradecerle a la gente que ha confiado en mí, y en particular a mis compañeros, por todo este tiempo. He tenido el gusto de trabajar con gente con mucho talento pero, más importante, con buena gente. Ese ambiente de trabajo es invalorable.

Más allá del know-how técnico y de otras habilidades que uno va casi sin darse cuenta aprendiendo, me llevo algo muy valioso que es descubrir, con cierto detalle, qué cosas dentro de la informática son las que más me interesan; y en las que me quiero seguir especializando. El cierre de esta etapa tiene que ver, evidentemente, con eso.

Tengo sin dudas vocación por la ingeniería, la ciencia y la informática. Me encanta entender cómo funcionan las cosas, llegar a la capa más baja de abstracción tanto en la teoría como en la práctica. Me interesa la seguridad informática, pero particularmente la explotación de software y sistemas, la ingeniería reversa de aplicaciones y protocolos, el análisis de malware, el desarrollo en lenguajes como C/C++ y Assembly. Hacia eso me estoy, desde hace ya un tiempo, enfocando…

9
May
2013

Mi primer buffer overflow controlado!

Paso 1: Crear un programa de pruebas en C, con una vulnerabilidad de buffer overflow intencional.

#include <stdio .h>
#include <stdlib .h>
#include <string .h>
 
int function(char* par);
 
int main(int argc, char* argv[]){
	int return_value = function(argv[1]);
	return 0;
}
 
int function(char* par){
	char localbuff[10];
	memcpy(localbuff, par, strlen(par));
	return 1;
}
</string></stdlib></stdio>


Leer el resto del artículo »

13
Apr
2013

C++11 Ping-Pong std::threads

Como Tarea 1 de programación en el curso Pattern-Oriented Architectures for Concurrent and Networked Software (POSA, para los amigos) que estoy haciendo en Coursera, se requirió hacer un programa sencillo de ping-pong entre threads. El objetivo era poner en práctica algunas primitivas para el manejo de la concurrencia y la sincronización. Básicamente el output por consola de este programa debía ser algo así:
Ready… Set… Go!
Ping!
Pong!
Ping!
Pong!
Ping!
Pong!
Done!

Se podían elegir muchos lenguajes para el desarrollo. Antes de pasar a lo técnico, quiero mostrar algunas cifras relativas al desarrollo del curso. Están inscriptas unas 30.000 personas apróx. Esta tarea (correspondiente a la 4ta semana del curso), fue entregada por 1.600 personas apróx. Esta fue la cantidad de programas por lenguaje:

Java 840
C++11 260
C# 199
Python 170
Ruby 56
C++ ACE 51
Scala 50
C++ boost 4


Leer el resto del artículo »

2
Nov
2012

Punteros a funciones: desde C a Assembler

En C tenemos la posibilidad de pasar punteros a funciones como parámetros de una función. Esto permite realizar llamadas a la función-parámetro desde la función. Si por ejemplo lo combinamos con parámetros de tipo *void (para la función-parámetro), podría llegar a verse como una forma rústica de polimorfismo.

Ejemplo:

#include <stdlib .h>
#include <stdio .h>
 
int foo(int);
void bar(int (*)(int));
 
int main(int argc, char *argv[]){
 
	bar(foo);
 
	return 0;
}
 
int foo(int num){
	return num;
}
 
void bar(int (*func)(int)){
	int res = (*func)(3);
	printf("res = %d\n", res);
}
</stdio></stdlib>


Leer el resto del artículo »

27
Oct
2012

Linux: analizando el stack de un proceso

En este breve artículo quiero presentar un análisis básico del stack de un proceso en Linux. Se trata de un caso de ejecución sencillo, contado como un storyboard, para ir a los conceptos fundamentales del código ejecutable (visto como assembler), llamadas a funciones y manejo de memoria. La arquitectura en este caso es IA-32.

1. Tenemos un programa sencillo escrito en C

#include <stdio .h>
#include <stdlib .h>
 
int main(void){
 
    int x;
    int y;
 
    x = 4;
    y = 5;
 
    foo();
 
    return 0;
}
 
int foo(){
    int y = 1;
    return y;
}
</stdlib></stdio>

Se declaran dos variables locales en la función main, se llama a una función foo y se declara una variable local en la función foo.


Leer el resto del artículo »

29
Sep
2012

Computer Architecture y Cryptography en Coursera

Coursera es un proyecto libre, abierto y gratuito de enseñanza online, soportado por varias de las universidades más prestigiosas del mundo -principalmente universidades estadounidenses-.

A través de una moderna plataforma web, se brindan cursos no-presenciales de diversas áreas de las ciencias. Cada curso es guiado por un docente de la universidad que lo patrocina e incluye textos, materiales, slides, videos de las clases, ámbitos de intercambio con otros alumnos (con revisión periódica de los docentes) y evaluaciones. Algunos cursos, incluso, brindan un certificado de asistencia o realización de las tareas prácticas. Todo el material puede ser descargado para su visualización offline.

Los cursos duran entre 6 y 10 semanas en general. Sin embargo, al enrolarse en casi todos los casos es posible acceder completamente al material teórico y a los videos -especialmente cuando se trata de cursos dictados en una base regular-. Se recomienda hacer el seguimiento del curso en las fechas pautadas para poder acompasar su desarrollo con los aspectos prácticos y las evaluaciones.

Si no conocen, entren y vean: http://www.coursera.org.

Luego de esta introducción, quiero comentarles que estoy enrolado en dos cursos muy interesantes: Computer Architecture y Cryptography.

Computer Architecture

princeton university coursera

  • Comienzo: 30 de setiembre 2012
  • Duración: 10 semanas
  • Carga de trabajo: 5-8 horas por semana
  • Profesor: David Wentzlaff
  • Keywords: Computer Science: Systems, Security, Networking, Electrical and Materials Engineering

Enrolarse: https://www.coursera.org/course/crypto

Cryptography I

stanford university coursera

  • Comienzo: 5 de noviembre 2012
  • Duración: 6 semanas
  • Carga de trabajo: 5-7 horas por semana
  • Profesor: Dan Boneh
  • Keywords: Computer Science: Theory Computer Science: Systems, Security, Networking

Enrolarse: https://www.coursera.org/course/comparch

Quiero agradecer a mi amigo Mariano, que gracias a él conocí Coursera hace ya varios meses.

9
Sep
2012

Desde un High-Level Language a un archivo ejecutable

pasaje de high level language a archivo ejecutable assembler

Professional Assembly Language – Richard Blum (2005)

La figura describe el proceso que se desarrolla para traducir código escrito en un lenguaje de alto nivel (High-Level Language) a código de máquina (contenido en un archivo binario ejecutable).

El compilador cumple la función de transformar el código escrito en el lenguaje de alto nivel a código objeto. El código objeto es código de máquina que aún no se encuentra en condiciones de ser ejecutado, por las razones que veremos más adelante. Este código depende de la arquitectura de procesador para la cuál se compile (por ejemplo IA-32, ARM, etc.).

En lenguajes como C y C++, se suele generar un archivo de código objeto por cada archivo con código de alto nivel -contando los headers y su implementación en forma conjunta-.

La mayoría de los programas se componen de múltiples archivos con código de alto nivel. Existe una relación entre estos archivos para definir estructuras complejas, reutilización de componentes, separación de funcionalidades e interacciones.


Leer el resto del artículo »

1
Sep
2012

Leer un archivo en C a un array de chars (char*)

En este sencillo código vamos a mostrar y comentar una técnica para leer un archivo (eventualmente binario) a un array de chars (char*) desde C, utilizando algunas system calls POSIX y alguna función de la biblioteca estándar.

/*
Auth: martin.com.uy/sec
*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
 
int main(int argc, char* argv[]) {
 
	puts("Comienzo del programa...\n");
 
	int archivo_fd, archivo_open_flags;
 
	archivo_open_flags = O_RDONLY;
 
	archivo_fd = open("/ruta/al/archivo.bin", archivo_open_flags);
 
	if(archivo_fd == -1){
		puts("Error al abrir el archivo.\n");
		return EXIT_FAILURE;
	}
	puts("Archivo abierto correctamente.\n");
 
	puts("Leyendo archivo...\n");
 
	int bytes_leidos;
 
	int cantidad_bytes_archivo = 0;
 
	int comienzo_del_archivo = lseek(archivo_fd, 0, SEEK_SET);
 
	int fin_del_archivo = lseek(archivo_fd, 0, SEEK_END);
 
	printf("Comienzo del archivo offset: %d, Fin del archivo offset: %d.\n\n", comienzo_del_archivo, fin_del_archivo);
 
	cantidad_bytes_archivo = fin_del_archivo - comienzo_del_archivo;
 
	char* archivo_bytes = (char*)malloc(cantidad_bytes_archivo);
 
	lseek(archivo_fd, 0, SEEK_SET);
 
        read(archivo_fd, archivo_bytes, cantidad_bytes_archivo);
 
	printf("Lectura del archivo finalizada. Cantidad de bytes archivo: %d.\n\n", cantidad_bytes_archivo);
 
	if(close(archivo_fd) == -1){
		puts("Error al cerrar el archivo.\n");
		return EXIT_FAILURE;
	}
 
	puts("Archivo cerrado.\n");
 
	return EXIT_SUCCESS;
}

Si bien el código es auto-explicativo, quiero comentar brevemente lo que se está haciendo en la parte central de la función.

Una vez abierto el archivo (obtenido su file descriptor), el kernel almacena un offset donde se indica la posición en la que estamos parados sobre el archivo. Cada vez que utilizamos, por ejemplo, la system call read(), este offset es incrementado la cantidad de bytes que hayan sido leídos -hasta llegar al EoF-.

La system call lseek() nos permite controlar (mover) este offset donde estamos parados dentro del archivo abierto. Lo que hacemos en esta función es pararnos al principio, pararnos al final y obtener el largo del archivo en bytes. Una vez con ese largo, construimos un buffer de lectura del tamaño exacto del archivo. Con dicho buffer utilizamos la system call read() y de una sola vez cargamos el archivo.

Probablemente esta forma de leer sea más útil para archivo binarios.