Planet

Más de un mes después, DJAD vuelve a moverse un poco.
Tras más de un mes sin pasarnos por el blog y casi sin realizar novedades en cuanto al desarrollo de la aplicación, hoy volvemos para darle un empujoncito a esa versión 0.0.2 que tanto se nos está resistiendo.
Hoy solo escribimos para informaros de que ya está disponible una parte de esa versión, de momento sale a la luz el aspecto gráfico.
En cuanto a las funciones que incluye, tan solo hay una pequeña modificación y es que en el apartado de las funciones de C, se han incluido dos dimensiones más al código que creaba las tablas, disponiendo así de la opción de generar una tabla de 2, 3 y 4 dimensiones.
Otra de las novedades (sin funcionalidad por ahora) es que podréis ver que en el menú de selección de lenguaje se han introducido dos funciones, una que sincronizara el contenido de dos carpetas y otra, que comprimirá la carpeta seleccionada, siendo estas dos funciones exclusivas para Linux.
Por el momento nada más que decir, os contaremos más novedades próximamente aunque podréis ver alguna novedad más cuando entréis a la aplicación.
Como sucedió con la versión anterior, en el menú superior tenéis el enlace a la aplicación.
Incluiremos en la barra lateral un enlace a las versiones antiguas para que podáis ver la evolución del proyecto con el paso del tiempo.
Sin nada más que contaros, nos despedimos hasta la próxima.

Introducción
El objetivo de esta entrada no es otro que dar unas nociones básicas de ASM para tener una base con la que empezar a realizar reversing para los menos avezados.
¿Qué es?
Una entrada donde se condensen los principios básicos a conocer y tener en cuenta para introducirnos un poco en el mundo del reversing. Tómalo como una pequeña guía de referencia, nada más.
Para un buen aprendizaje de ASM consulta el libro “The art of assembly language”.
¿Qué no es?
No se trata de un tutorial sobre programación en ASM, ni se trata de explicar conceptos avanzados en la materia ni lenguaje.
Prerrequisitos

• Sistema binario.
• Sistema hexadecimal.
• Conocer el funcionamiento de una CPU.
• Conocer cómo se estructura un sistema operativo.
• Conocer como se procesan y almacenan los datos en memoria.

¿Qué es la ingeniería inversa?
Wikipedia– (El objetivo de la ingeniería inversa (reversing) es obtener información a partir de un producto accesible al público, con el fin de determinar de qué está hecho, qué lo hace funcionar y cómo fue fabricado.
El método se denomina así porque avanza en dirección opuesta a las tareas habituales de ingeniería, que consisten en utilizar datos técnicos para elaborar un producto determinado.
La ingeniería inversa es un método de resolución. Aplicar ingeniería inversa a algo supone profundizar en el estudio de su funcionamiento, hasta el punto de que podamos llegar a entender, modificar y mejorar dicho modo de funcionamiento.)
Adentrándonos en ASM
Obtener unas nociones básicas de ensamblador es fundamental para comenzar nuestra incursión en el mundo del reversing, hazte a la idea de que tendrás que manejarte al dedo con él.
Olvídate de las facilidades que podías gozar en python, C, C++, perl, etc. Esto es otra historia, aquí usaremos abreviaturas y números, y probablemente al comienzo todo te parezca bastante lioso e incluso frustrante.
Bits, Bytes, Words DWords

• BIT – Unidad mínima de información. Su valor puede oscilar entre el ‘0’ o ‘1’. El sistema binario se forma por la unión de varios bits.
• BYTE – Un byte está formado por 8 bits. Su valor puede oscilar entre 0-255. Es un sistema en base 2. Nosotros para facilitar la lectura de los números binarios, usaremos el sistema hexadecimal (sistema en base 16) por la rapidez y facilidad para leer.
• WORD – Son dos bytes o lo que es lo mismo 16 bits. Su valor oscila entre 0-65535d (0h – 0FFFFh)
• DWORD – Son dos words o lo que es lo mismo 32 bits. Su valor oscila entre 0-4294967295d (0h-0FFFFFFFFh)

Registros
Similar a las variables. Un registro es una zona especial en la memoria de nuestro procesador donde podemos almacenar y consultar un valor único. Con la salvedad de que existen un número limitado de ellos y cada uno tiene un cometido específico.
En arquitecturas Intel (que será la elegida por nosotros) podemos distinguir un total de 8 registros:

• EAX (Extended Accumulator Register) – Destacamos dos funcionalidades de uso común para este tipo de registro: Almacenar el valor de retorno de una función y utilizarlo como contenedor para resolver sencillas operaciones matemáticas.
  Es un registro volátil, dado que su valor no es almacenado. A pesar de que se establezca el valor de retorno de una función al contenido del mismo.
• EBX (Extended Base Register) - Suele utilizarse como apoyo para acelerar el cálculo de operaciones. Es un registro no volátil.
• ECX (Extended Counter Register) – Registro volátil que puede ser utilizado como contador de bucle o contenedor de parámetros que sean pasado a funciones
• EDX (Extended Data Register) – Registro volátil usado mayormente como parámetro para funciones. Normalmente se usa también para almacenar variables a corto plazo dentro de una función.
• ESI (Extended Source Index) – Registro no volátil que normalmente es usado como puntero. Es utilizado por aquellas funciones que requieren un origen y un destino para los datos que se utilizan. Apuntando este al origen en todo momento.
• EDI (Extended Destination Index) - Al igual que el registro ESI, es no volátil y usado como puntero, a diferencia de que este apunta al destino siempre.
• EBP (Extended Base Pointer) – Registro no volátil con dos usos comunes según el compilador que utilicemos, así puede desempeñar el papel de un registro como otro cualquiera o ser el puntero al marco de pila.
• ESP (Extended Stack Pointer) – Almacena un puntero a la parte inferior de la pila. Tras ejecutar una función el valor que tenía el registro al principio debe de coincidir con el asociado tras la función
• EIP (Extended Instruction Pointer)

Estos registros de 32 bits a su vez pueden ser divididos en registros de menor tamaño (16 bits, y 8 bits, distinguiendo la parte superior e inferior).
Por tanto tenemos:

• 8 registros de 32 bits: EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP EIP
• 8 registros de 16 bits: AX, BX, CX, DX, SI, DI, BP, SP, IP
• 8 registros de 8 bits: AH, AL, BH, BL, CH, CL, DH, DL

Donde H hace referencia a Higher (Bits más significantes de la dirección) y L a Lower(Bits menos significantes de la dirección).
De esta forma ECX = 0x24101989, quedaría como CX = 0x2410, CH = 0x19 y CL = 0x89, y de paso ya sabéis cuándo hacerme un regalo (rubias por favor ;D).
Ahora mismo debemos de quedarnos con una idea ligeramente similar a esta:

Las banderas (Flags)
Se tratan de simples bits que nos indican el estado de algo. En arquitecturas de 32bits tenemos un total de 32 banderas, pero nosotros sólo vamos a utilizar tres de ellas:

• Z-Flag – (Zero flag) Será el flag que más acabaremos usando, cuando su valor es ‘1’ nos indica que el resultado de una operación fue ‘0’. Su valor puede ser cambiado por todas aquellas instrucciones que realicen operaciones matemáticas y por la instrucción ‘cmp’
• C-Flag – (Carry flag) Su valor va ligado al uso de acarreo en operaciones de suma y resta.
• O-Flag – (Overflow flag) Su valor cambia a disposición del valor que adopte el bit más significativo. Si queremos realizar la suma de 127 consigo mismo, este es representado como 0111 1111, en este momento el MSB es ‘0’, pero al realizar la operación (0111 1111 + 0111 1111) obtenemos 1111 1110, siendo ‘1’ ahora el valor del MSB.

Segmentos (Segments) y desplazamientos (Offsets)
El concepto de segmento podemos definirlo como la zona de memoria donde las instrucciones (CS), datos (DS) o pila (SS) son almacenadas.
A su vez cada segmento es dividido en 'offsets'. Así en aplicaciones de 32-bits estos offsets estos van numerados desde 00000000 a FFFFFFFF, o lo que es lo mismo 65536 zonas de memoria.
Por tanto podemos aceptar el concepto de offset como un valor indicativo de desplazamiento desde el punto de inicio del objeto hasta un punto dado, presumiblemente siempre dentro del mismo objeto.
Un ejemplo real de esto podemos ponerlo como un libro en el caso de un segmento, y una línea específica de una página como un offset.
La pila
Podemos ver el concepto de pila como una estructura de datos, en la que el modo de acceso a sus elementos es de tipo LIFO (Last Input First Output – Primeo en entrar, último en salir).
Distinguimos dos comandos para interactuar con ella:

• Push (apilar) – Coloca un objeto en la pila.
• Pop (desapilar) – Saca un objeto de la pila.

Cuando llamamos a una función, todos sus parámetros son almacenados en sentido inverso en la pila antes de hacer de pasar el flujo de ejecución a la función.
NuestraFuncion(int param1, int param2, char param3, float param4)
Esto en ensamblador quedaría:
push param4
push param3
push param2
push param1
call NuestraFuncion
add esp, 10h
Como comentabamos vamos pasando los parámetros a nuestra pila para posteriormente realizar la llamada. Después de acabar la ejecución de nuestra función el puntero a pila sigue teniendo 16 bytes por delante de lo que tenía en un principio. Con la intención de restaurar el estado original de la misma, debemos añadir al puntero el valor 10h que corresponde a los 4 elementos que hemos introducido en la pila (4bytes por cada instrucción push ejecutada).
Operaciones lógicas
A lo largo de nuestro recorrido deberemos conocer cómo funcionan las operaciones lógicas a nivel de bits:

• Operación AND – Realiza la función booleana de producto lógico.
• Operación OR – Realiza la función booleana de suma lógica.
• Operación XOR - Realiza la función booleana de A’B+AB’.
• Operación NOT – Realiza la función booleana de inversión o negación de una variable lógica.

Instrucciones
Instrucción NOP – Es una abreviatura de “No operation” y su uso es de simple relleno.
Desplazando datos:

• 'mov' – Instrucción análoga a '=', puede mover datos entre un registro y memoria, dos registros o incluso entre una constante y memoria.
• 'movsx' – Versión especializada para usar con registros de diferentes tamaños y con signo.
• 'movzx' – Versión especializada para usar con registros de diferentes tamaños y sin signo.
• ‘lea’ (Load Effective Address) – Uso similar a ‘mov’ y utilizado para calcular desplazamientos en vectores, dado que podemos hacer uso de [dirección comienzo + offset*datasize] para encontrar la dirección de un elemento en concreto del vector. Su uso también se basa para cálculos de multiplicaciones y sumas.

Operaciones lógicas y matemáticas

• ‘add’, ‘sub’ – Permiten sumar o restar respectivamente a un registro, un valor constante, un registro o un puntero.
  add eax, 5
  sub ecx, 5
  add ebx, eax
• ‘inc’, ‘dec’ – Permiten incrementar o decrementar respectivamente un registro.
  inc ebx
  dec eax
• ‘and’, ‘or’, ‘xor’, ‘neg’ – Instrucciones encargadas de realizar las operaciones lógicas a nivel de bits, que hemos explicado anteriormente.
  and eax, 5 ; eax = eax & 7
  xor eax, 0 ; eax = eax ^ 0
  or eax, 19 ; eax = eax | 19
  neg eax ; eax = !eax
  xor eax, eax ; eax = 0
• ‘mul’, ‘imul’, ‘div’, ‘idiv’, ‘cdq’ – Correspondientes a las operaciones de multiplicación y división, ambas hacen uso de los registros de 64 bits edx:eax. ‘mul’ multiplica el valor sin signo almacenado en el registro eax con el operando y almacena el resultado en el registro de edx:eax. Por otro lado ‘imul’ realizad la misma operación a excepción de que el valor es con signo.
  mul ecx ; edx:eax =eax * ecx (Sin signo)
  imul ecx ; edx:eax = eax * ecx (Con signo)
  Cuando se usan dos parámetros, el comportamiento es el esperado, multiplica el primero por el segundo y almacena el resultado en el primer parámetro.
  ‘div’ divide el valor almacenado en el registro edx:eax por el operando y el cociente lo almacena en eax. El resto o módulo es almacenado en edx. Al igual que sucedía con ‘imul’ la operación ‘idiv’ permite utilizar valores con signo.
  div ecx ; eax = edx:eax / ecx (Sin signo)
  ; edx = edx:eax % ecx (Sin signo)
  idiv ecx ; eax = edx:eax / ecx (Con signo)
  ; edx = edx:eax % ecx (Con signo)
  Por otro lado la operación ‘cdq’ es usada antes que ‘idiv’ y su cometido es convertir el valor de 32bit almacenado en eax en un valor de 64 bit para almacenarlo en edx:eax sobreescribiendo cualquier valor que haya en edx con ceros en caso de ser eax positivo o con ‘F’ en caso de ser eax negativo.
• ‘shl’, ‘shr’ – Shift Left y Shift Right respectivamente, nos permiten realizar desplazamiento a nivel de bits hacia la derecha e izquierda, al igual que los operadores << y >> usados en C.

Saltos Estas instrucciones son utilizadas en caso de bucles y condiciones de comprobación. Realizando una comprobación del valor que almacena el registro, dirección o constante asociada a la instrucción.

• ‘jmp’ – Envía la ejecución del programa a la dirección especificada
  jmp 2420h ; Saltamos a la dirección 0x2420
• ‘call’, ‘ret’ – ‘call’ tiene un uso similar a ‘jmp’ a excepción de que además de realizar el salto a la dirección solicitada, almacena en la pila la dirección de la instrucción ejecutada.
  Por otro lado ‘ret’ obtiene el tope de la pila y desplaza el flujo de ejecución de nuestra aplicación hasta la dirección de memoria asociada. Si el registro SP apunta a una dirección errónea o esta ha sido sobreescrita desencadenará que nuestra aplicación se cierre inesperadamente. Con estas instrucciones jugaremos más adelante.
• ‘cmp’, ‘test’ – ‘cmp’ compara los dos operandos y establece una serie de flags como resultado de la operación realizada.
  Por otro lado ‘test’ realiza una operación and a nivel de bit entre las dos variables y posteriormente realiza una comparación con 0.
  Los flags más comunes:
  • Cero (Zero) – Lo establece únicamente si los dos elementos son iguales.
  • Mayor que (Greater than) – Lo establece si el primer elemento es mayor que el segundo.
  • Menor que (Less than) – Lo establece si el primer elemento es menor que el segundo.

  cmp eax, ebx ; Compara EAX y EBX y establece el flag Zero si son iguales
  cmp EAX, [404000] ; Compara EAX con el contenido de 404000
  test eax, eax

Otras instrucciones relacionadas con los saltos

• ja - Salta si es mayor - CF=0 y ZF=0
• jae – Salta si es mayor o igual - CF=0
• jb (el whisky no) – Salta si es menor - CF=1
• jbe - Salta si es menor o igual - CF=1 o ZF=1
• jc – Salta si el flag de acarreo está establecido - CF=1
• jcxz – Salta si CX es 0 - CX=0
• je – Salta si la comprobación es igual - ZF=1
• jecxz – Salta si ECX es 0 - ECX=0
• jg - Salta si es mayor (Con signo) - ZF=0 y SF=OF
• jge – Salta si es mayor o igual (CS) - SF=OF
• jl – Salta si es menor (CS) - SF != OF
• jle – Salta si es menor o igual (CS) - ZF=1 y OF != OF
• jmp - Salta - Siempre salta
• jna – Salta si no es mayor (Sin signo) - CF=1 o ZF=1
• jnae - Salta si no es mayor o igual (SS) - CF=1
• jnb - Salta si no es menor (SS) - CF=0
• jnbe - Salta si no es menor o igual (SS) - CF=0 y ZF=0
• jnc - Salta si el flag de acarreo no está establecido - CF=0
• jne - Salta si no es igual - ZF=0
• jng - Salta si no es mayor (CS) - ZF=1 o SF!=OF
• jnge - Salta si no es mayor o igual (CS) - SF!=OF
• jnl - Salta si no es menor (CS) - SF=OF
• jnle - Salta si no es menor o igual (CS) - ZF=0 y SF=OF
• jno - Salta si el flag de overflow no está establecido - OF=0
• jnp - Salta si el bit de paridad no está establecido - PF=0
• jns - Salta si el flag de signo no está establecido - SF=0
• jnz - Salta si no es cero - ZF=0
• jo - Salta si el flag de overflow está establecido - OF=1<7li>
• jp - Salta si el bit de paridad está establecido - PF=1
• jpe - Salta si el bit de paridad es igual - PF=1
• jpo - Salta si el bit de paridad es impar - PF=0
• js - Salta si el bit de signo está establecido - SF=1
• jz - Salta si es cero - ZF=1

Buenas, tras la configuración debemos de añadir las lineas de código del dispositivo para que establezca la comunicación con el otro dispositivo.
Primero incluimos la libreria:

#include // para usar librerias xbee

Añadimos la configuración en setup:

//Configuramos el puerto xbee
xbee.begin(BAUDIOS);

Ahora preparamos los datos:

uint8_t datos[] = {direccionNodo, direccionRed, valorTem, valorHum, valorLum...};

Ahora realizamos la conexión:

// Preparamos el envio
Tx16Request tx16 = Tx16Request(0x1234, datos, sizeof(datos)); //modificar para cada nodo
TxStatusResponse txStatus = TxStatusResponse();
// enviamos
xbee.send(tx16);
Serial.println("");
// esperamos si hay respuesta
if (xbee.readPacket(5000)) {
// Si ha llegado el paquete
if (xbee.getResponse().getApiId() == TX_STATUS_RESPONSE) {
xbee.getResponse().getZBTxStatusResponse(txStatus);
// comprobamos si todo es correcto
if (txStatus.getStatus() == SUCCESS) {
Serial.println("Enviado Correctamente...");
} else {
Serial.println("Error al enviar...Lo intentaremos otra vez");
}
}
} else {
Serial.println("Error no hay respuesta...Lo intentaremos otra vez");
}
Serial.println("");

La próxima será el controlador.

Para poder trabajar en una wiki sobre el engine de renderizado Ogre3D he tenido que aprender a utilizar la biblioteca en algún sitio. Estos conocimientos también son indispensables para el desarrollo de Sion Tower. Lo cierto es que debería poner un disclaimer como una casa advirtiendo mi escasa experiencia porque aún estoy aprendiendo. En cualquier

Después de terminar las Navidades retomaré el proyecto de TweetMoi, basado como comente en el último post, una aplicación basada en redes sociales, con la capacidad de poder postear en cada una de ellas, y a la vez, incluso que cada usuario pueda ver su TimeLine de redes sociales juntas.
Esta característica, se encuentra bastante avanzada y posteriormente me dispondré a crear una cuenta en Android Market, y subir una pequeña prueba de la aplicación y lanzarla para comprobar como es la acogida de la aplicación con el mundo Android.
Los siguientes puntos de implementación serán los siguientes:

• Integración completa con todas las redes sociales, Facebook, Google Buzz.
• Descarga de avatares del Timeline de los usuarios.
• Integración con una aplicación Django para realización una administración de usuarios federal.
• Conexión HTTP con la aplicación Django.

Esperemos que esta nueva versión este disponible lo antes posible, y como he comentado anteriormente, pueda salir a formar parte del Android Market cuandos se encuentre terminada.
 

Hola a todos, mi nombre es Moisés Vázquez Sánchez, estudio en la Universidad Rey Juan Carlos de Madrid, y actualmente me encuentro desarrollando el proyecto de fin de carrera para la carrera de Ingeniería Superior Informática, este blog lo usaré como página de encuentra de la aplicación del proyecto, para ir comentando las partes desarrolladas y en lo que me encuentro desarrollando, y como una página de soporte para la aplicación que más adelante subiré al Androir Market.
Daros la bienvenida, y espero que os guste el proyecto.

Bueno, aquí teneís un buen documental sobre Arduino.
Link al video

These days I have spent some hours setting up the environment where I am going to develop the project. I worked with XAMPP in Ingenia, where I did my internship, but I had never set up the server nor any … Continue reading →

Buenas, primero feliz año a todos, ahora vamos a configurar los módulos xbee de los dispositivos, primero debemos de quitar el micro ATMEGA a la placa Arduino, haciendo palanca, suavemente y con paciencia. Luego, debemos de conectarlo con el ordenador y usando el software X-CTU, lo configuraremos, si usamos linux debemos de tener wine instalado, además debemos de ejecutar la siguiente linea de código: sudo ln -s /dev/ttyUSBX /home/directoriousuario/dosdevices/comY
Siendo X, número puerto USB que se ha conectado con el dispositivo, e Y un número aleatorio que debemos elegir.
Ahora usamos el dispositivo X-CTU, que lo podemos descargar con el enlace del nombre y según si es un nodo o un nexo ejecutaremos unas sentencias, que tras ejecutarlas debemos recibir un OK. Todo esto sera explicado detalladamente en un manual que confeccionaré y publicaré en los siguientes días.

Como ya casi todos sabréis en GeoRemindMe nos encanta trabajar en equipo y compartir experiencias; también muchos sabréis que Codeko patrocina este proyecto particularmente patrocinando los Hackathones.
Hasta ahora hemos estado demasiado ocupados intentando organizar otros asuntos, pero queremos empezar el año anunciando 2 eventos en los que nos reuniremos físicamente en Granada (y virtualmente todos aquellos que lo deseen) para pegarle otro achuchón al trabajo ya realizado.
Autor: andreweland (vía Flickr)
Para hacer más didáctica, divertida y productiva la experiencia utilizaremos (y explicaremos) una metodología basada en Scrum (con algunos matices de otra metodología llamada Kanban). Y dependiendo del número de personas que seamos haremos grupos de trabajo enfocados en las diferentes ramas del proyecto (Aplicación Web | Web promocional | Aplicación Móvil).
Cualquier persona de cualquier rama puede participar en el Hackaton; no solo programadores, sino también diseñadores, traductores, personas con conocimientos de marketing, … ¡¡o personas sin ningún conocimiento en particular pero que quieran aprender!!.
El primer encuentro será el próximo fin de semana (del 13 al 15 de Enero) -> Formulario de inscripción.
——————————–
Agenda:
Viernes 13: 16:00-20:00 En la ETSIIT, Aula por definir.
Sabado 14 y Domingo 15, de 11:00 a 20:00: C\Elena 3,3D
——————————–
Y el segundo encuentro será en el Hackaton de proyectos de software libre de la UGR del 4 al 7 de Marzo.
Aquellos interesados podéis inscribiros en el siguiente formulario de inscripción (se dan créditos de libre configuración a los alumnos de la UGR).
¡En vemos en breve!