La siguientes historias de seguridad informática están basadas en hechos reales y han sido ficcionadas para transmitir mejor las ideas. Ésta serie de historias no podrían ser posibles sin la tutoría y el tiempo invertido de, Hiram Camarillo, asesor en seguridad de la firma Seekurity.
La presente historia se titula ¿Cómo las puedo borrar? y la hemos divido en dos entregas que espero disfruten tanto como nosotros. En la siguiente entrega, intentaré persuadir a Hiram para que nos comente algunas reglas básicas para evitar que ésto nos suceda.
Al trabajar en la edición de cualquier archivo, en especial archivos de texto (código), solemos modificar, eliminar y agregar líneas, lo cual puede resultar en el arrepentimiento. En ocasiones realizamos un cambio que altera por completo el funcionamiento de nuestro programa, por lo cual algunas personas inician un control de versiones rústico sin darse cuenta; cuando empiezan a guardar archivos bajo nombres como «[archivo]primero.txt», «[archivo]elBueno.txt», «[archivo]elBueno2.txt», «[archivo]ahoraSiElBueno.txt», entonces es momento de comenzar con algún buen gestor de versiones.
Todo lo que explico a continuación es especialmente dirigido a quienes se inician (o ya están avanzados) en la programación porque es a lo que yo me dedico, pero es perfectamente aplicable a cualquier área que requiera de trabajar sobre la edición de archivos.
El control de versiones cubre algunas necesidades principales:
Organizar y respaldar el progreso del trabajo.
Facilitar el trabajo en equipo.
Facilitar el trabajo sobre ideas simultáneas sin necesidad de que una afecte al avance de otra.
Simplificar la integración del trabajo.
Git es un proyecto de Software Libre que inició Linus Torvalds en 2005 para poder llevar el control de versiones del Kernel de Linux. Lo primero que debemos saber al respecto es que continúa siendo Software Libre que podemos manejar desde la terminal de nuestra computadora y que existen algunas plataformas en línea para facilitar su uso, tales como GitHub y GitLab. Lo siguiente que hay que tener en cuenta es que está pensado para poder modificar el mismo proyecto simultáneamente, por lo que tenemos que familiarizarnos con el uso de “ramas” que explicaré en la siguiente entrada.
Por ahora hay que aprender a configurar Git para poder empezar a usarlo, usamos los siguientes comandos, para este ejemplo usaré mi nombre y un correo inexistente:
Estos datos de configuración no representan un usuario en alguna plataforma ni significa que estás generando una cuenta, simplemente git lo guarda para que proyectos en los que hay más autores o que se suben en línea, podamos guardar control de quién realizó una parte y poder contactarlo establecer contacto en caso de necesitarlo.
De momento aprenderemos a inicializar el control de versiones de un proyecto. Git utiliza “repositorios” que no son más que carpetas con un archivo de configuración oculto en el que se guardará el estado de cada versión, algo así como un snapshot de la carpeta.
Para inicializar el repositorio abrimos la terminal y creamos la carpeta (en este caso la llamaré “ejemplo” que tendrá nuestro repositorio y nos movemos a ella:
~] $ mkdir ejemplo
Después inicializamos el repositorio correspondiente a la carpeta con el mismo nombre que le hemos asignado:
~] $ git init ejemplo
No hemos agregado nada al repositorio, podemos verificar su estado con el comando siguiente, y tendremos un resultado similar al que muestro:
~] $ cd ejemplo
ejemplo] $ git status
On branch master
Initial commit
nothing to commit (create/copy files and use "git add" to track)
Ahora empezamos a hacer cambios en el repositorio creando algún archivo:
ejemplo] $ touch haikus.txt
y con nuestro editor de texto favorito lo editamos, en este caso agregaré las líneas siguientes:
“Al Fuji subes
despacio —pero subes,
caracolito.”
Kobayashi Issa
Entonces podemos guardar la primera versión de nuestro archivo usando los siguientes comandos de Git:
Primero agregamos los cambios que acabamos de hacer al respositorio:
ejemplo] $ git add haikus.txt
Lo siguiente es guardar el cambio con un mensaje corto que nos haga recordar lo que hemos cambiado en el futuro y tendremos un mensaje como el siguiente:
ejemplo] $ git commit -m “agregué haiku de Kobayashi Issa”
[master (root-commit) f82cf06] agregué haiku de kobayashi issa i"
1 file changed, 5 insertions(+)
create mode 100644 haikus.txt
En este punto ya hay cambios agregados en nuestro repositorio, que podemos ver ejecutando el comando log:
ejemplo] $ git log
commit f82cf06a3530df2511e4dbc1abcd8ee7a10f6762 (HEAD -> master)
Author: karla <eee@mail.com>
Date: Mon Oct 22 07:14:10 2018 -0500
agregué haiku de kobayashi issa
Ahora, cada cambio que hagamos y guardemos como el anterior quedará registrado y podremos referirnos a su commit correspondiente con la clave que se muestra en la terminal, en este caso “f82cf06a3530df2511e4dbc1abcd8ee7a10f6762”, aunque con los primeros y caracteres generalmente es suficiente (en este caso “f82cf06”), y en caso de que desees volver a alguna versión anterior puedes ejecutar el comando git checkout ḿás el código del commit para visualizar el estado del repositorio en el momento en el que creaste ese commit. Aunque entonces es viable iniciar una rama para trabajar simultáneamente sin perder las versiones que hayas hecho antes de decidir volver a una antigua versión. Lo cual explicaré en la siguiente entrada.
De nuevo yo, León Ramos, jugando con una tornamesa. Pues me quedé encarrerado con mi restauración anterior y, no pude desaprovechar una oferta que encontré en Mercado Libre, así que, adquirí una Technics SL-B202 que no servía para nada y me propuse hacer algo muy diferente con ella.
Al principio pensé en simplemente restaurarla, pero luego quise decir algo con ella y al estar despintándola, llegaron a mi mente las formas de la estrella de la muerte y de los soldados blancos, storm troopers, de StarWars. Fue así que la tornamesa tuvo un tema, un motivo y un futuro.
Me encanta que el color blanco pueda ser un elemento de contraste y, a la vez armonioso, con cualquier decoración.
En el siguiente video resumo los pasos básicos de una restauración que me llevó cerca de 4 meses, aunque en realidad, hay tanto material, tantas fotos, tantos videos de lo que estuve haciendo, que bien podrían salirme cuarenta minutos de videos y un álbum de fotos. Con gusto comparto mi experiencia y lo que he podido aprender.
Espero que lo disfruten mucho y les comento que, ¡la tornamesa todavía no tiene dueño! Abriré en noviembre una subasta pública en MercadoLibre para que participen.
Para los adictos a los viniles hay ciertos momentos de enojo que regresan una y otra vez. Uno de ellos es: haber encontrado una pieza única en una tienda de viniles y, aunque en el tocadiscos del vendedor se escucha bien, en tu tornamesa el disco hace saltar la aguja y no se escucha nada.
Cuando regresas con el vendedor, el te dice sabiamente -No hay problema, sólo auméntale el peso a tu aguja.
¿Qué pasa si no tienes el peso suficiente?
La aguja puede saltar y ser inestable, no lograrás escuchar los discos que están ligeramente ondulados.
¿Qué pasa si tiene un peso mayor?
Si es más pesada de lo que debiera, puedes dañar el vinil que escuchas o, si no regresas al peso anterior, también puedes dañar otros discos.
¿Cuál es el peso ideal?
Es buena pregunta, el peso ideal está dictado por el fabricante de la aguja. Busca en Internet la tabla de valores compatibles con tu aguja. Normalmente oscilan entre 2 y 3g de peso.
¿Cómo lo ajusto?
Lo puedes ajustar usando las perillas de tu tocadiscos, si tu tocadiscos no los tiene, te sugiero que pienses seriamente en adquirir uno con más opciones. Sin embargo, como lo pueden ver en el video, los tocadiscos pueden mentir, por lo que sugiero que se use una pesa o balanza para tocadiscos o tornamesa. Su uso es muy sencillo y te da mucha paz mental.
Espero que el video que anexo les sea de mucha utilidad y que puedan escuchar sus viniles como es debido.
Tradicionalmente los microcontroladores, se programan usando un algoritmo secuencial, en la cual los recursos de hardware, no se comparten entre funciones, es decir el uso de un periférico, como son: la Unidad Aritmetica Lógica, contadores, Convertidores Analogico Digital, etc; no son liberados hasta que termina la función actual de ejecutarse. Esto implica tener varias funciones anidadas, que esperan a que la función en ejecución termina de usar los recursos del microcontrolador.
El nivel de integración actual, ha permitido que los microcontroladores posean, mayor capacidad de memoria, mayor velocidad de transferencia de datos para su procesamiento y un acceso mas rápido a la lectura y escritura de memoria.
Todas las características anteriormente citadas, permiten el poder implementar un RTOS (Sistema Operativo en Tiempo Real) en un microcontrolador de 8 bits. Un RTOS, es un gestor de tiempo de ejecución, que administra diferentes tareas que son parecidas a una función secuencial, pero permiten ser, puestas en espera, imitarles el acceso a la memoria y/o al hardware, guardar el entorno actual de contadores, periféricos, contador del programa, etc. Saltar a otra tarea, compartir los recursos y regresar a la tarea que se quedo en espera. Todo esto gracias a la creación de varios Stacks (pilas de registros guardados) en este caso generalmente en memoría RAM. Finalmente la tarea que estaba esperando o que se quedo a mitad de ejecución, puede continuar su ejecución justo en el punto donde fue interrumpida.
Después de comprender este sencillo ejemplo, imaginémonos que esta “puesta en espera” se realiza con diferentes tareas, compartiendo recursos y saltando simultáneamente entre ellas. La combinación de un gestor de tiempos entre tareas secuenciales que comparten recursos, es el objetivo de los RTOS.
Arduino UNO con un RTOS
Una arquitectura Arduino UNO (Atmega328, 8 Bits uC a 16 mega hertz) gracias a freeRTOS, nos permite implementar un pequeño Sistema en Tiempo Real.
Quiero compartirles, este código que utiliza un RTOS en un arduino UNO, es para un cubo de leds de 3×3. En futuras aportaciones explicare a detalle como funciona este RTOS y como configurar las diferentes tareas creadas. Por el momento a grandes razgos:
Una tarea ejecuta las secuencias de patrones de encendido de los leds
Una tarea revisa el potenciómetro (genera un voltaje variable) que aumenta la velocidad de las secuencias
Una tarea revisa el estado de un botón que cambia la secuencia de encendido de los leds, por si ya te aburriste y quieres que los leds prendan con un patrón diferente.
Este programa también se puede escribir de manera tradicional, con lógica secuencial, pero al usar un RTOS, para actualizar las variables globales, que controlan el sentido y velocidad de los patrones de encendido de los leds, se hace evidente, que al usar un RTOS, el programa final es más sencillo y utiliza más eficientemente los recursos del microcontrolador.
Adjunto también, un enlace a un video, para que vean el funcionamiento de este cubito de 3×3.
Rafael Sobrevilla
Referencias
Programación de Sistemas Embebidos en C, Gustavo Galeano, Primera Edición, 2009, Alfaomega
/**************************************************************************************************
* File name: cube3x3.ino
* Date Start: 17-may-17
* Author: Rafael Sobrevilla
* email: rasobrevilla@yahoo.com
* Descrip:
* – Control a 27 leds cube
* – Use digital outputs of arduino UNO
* + D2 – D10 Control of base leds
* + D11 – D13 The three floors
* + A0 – A1 Two Buttons
* + D0 and D1 To keep the serial port available
*
* led1 led2 led3
*
* led4 led5 led6
*
* led7 led8 led9
*
* floor0
* floor1
* floor2
*
**************************************************************************************************/
/**************************************************************************/
/* Include headers */
/**************************************************************************/
#include <Arduino_FreeRTOS.h>
/*************************************************************************/
/* Define two task for Sensors and Clock */
/*************************************************************************/
void TaskPatron( void *pvParameters );
//void TaskPotenciometer ( void *pvParameter );
void TaskButton ( void *pvParameter );
/********************************************************************/
/* Global variables */
/********************************************************************/
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;
int led5 = 6;
int led6 = 7;
int led7 = 8;
int led8 = 9;
int led9 = 10;
int floor0 = 11;
int floor1 = 12;
int floor2 = 13;
int sen_pin0 = A0;
int sen_pin1 = A2;
const int ON = 1;
const int OFF = 0;
int delay_ms_value_1 = 250;
int delay_ms_value_2 = 500;
int button_status = 0;
int potenciometer_status = 0;
/***************************************************************************/
/* Setup function is executed when you press reset or power the board */
/***************************************************************************/
void setup() {
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB, on LEONARDO, MICRO, YUN, and other 32u4 based boards.
}
// Now set up two tasks to run independently.
xTaskCreate (
TaskPatron
, (const portCHAR *) «Sensor»
, 128 // Stack size
, NULL
, 3 // Priority
, NULL );
xTaskCreate (
TaskButton
, (const portCHAR *)»Motors» // A name just for humans
, 128 // This stack size can be checked & adjusted by reading the Stack Highwater
, NULL
, 3 // Priority, with 3 (configMAX_PRIORITIES – 1) being the highest, and 0 being the lowest.
, NULL );
// Now the task scheduler, which takes over control of scheduling individual tasks, is automatically started.
}
/***********************************************************************/
/* Function for turn on a Position led */
/***********************************************************************/
int enable(int position_led, int floor_on)
{
digitalWrite(position_led, ON);
digitalWrite(floor_on, ON );
}
/***********************************************************************/
/* Fnction for turn off a Position Led */
/***********************************************************************/
int disable(int position_led, int floor_on)
{
digitalWrite(position_led, OFF);
digitalWrite(floor_on, OFF );
}
/*****************************************************************************/
/* LOOP FUNCTION */
/*****************************************************************************/
void loop()
{
// Empty. Things are done in Tasks.
}
void TaskPatron(void *pvParameters) // This is a task.
{
(void) pvParameters;
for (;;)
{
Serial.println(«PATRONES»);
do{
patron1();
}while(button_status > 200);
do{
patron2();
}while(button_status > 200);
do{
patron3();
}while(button_status > 200);
do{
patron4();
}while(button_status > 200);
}
}
void TaskPotenciometer (void *pvParameters) // This is a task.
{
(void) pvParameters;
for(;;)
{
potenciometer_status = analogRead (sen_pin0);
Serial.println(potenciometer_status);
//delay(delay_ms_value_2);
}
}
void TaskButton (void *pvParameters) // This is a task.
{
(void) pvParameters;
for(;;)
{
button_status = analogRead (sen_pin1);
Serial.println(button_status);
//delay(delay_ms_value_2);
}
}
En esta ocasión hablaremos de cómo hacer un tapete de corcho para tu tornamesa o tocadiscos. Esta inquietud me surgió porque lograba escuchar cierto ruido inducido por el giro mecánico de mi tornamesa. En mi caso tengo una tornamesa reconstruída de los años ochenta y eso me hace poner más atención a la parte mecánica del equipo. Noté que escuchaba ciertos ruiditos que no venían del disco, dichos ruidos son más perceptibles cuando escuchas música suave o clásica.
Noté que el tapete de fábrica de mi tornamesa estaba fabricado en hule y, por el paso del tiempo, se volvió en una pieza menos elástica. Todavía no llega al punto del desquebrajamiento, sin embargo, quise probar con otras opciones.
Una de las que encontré fue sustituirla por un tapete de corcho, entre otras razones, porque no daña la superficie de los discos de vinil y, al mismo tiempo, absorbe vibraciones. Así que me dí a la tarea de buscar uno para mi equipo.
Lamentablemente los que encontré disponibles estaban en el extranjero y tardarían mucho tiempo en llegar. Así que busqué herramientas para realizar mi tapete yo mismo. En el siguiente video, comparto lo que aprendimos al momento de realizar los cortes apropiados, así como su puesta en funcionamiento.
Materiales necesarios:
Tapete de corte o una mesa de trabajo
Regla o cinta métrica
Herramienta de corte circular con filo grueso para profundidades mayores a 4mm
Hoja de corcho de 4mm de espesor
Broca para madera del grosor para el corte interior
Con este post comenzamos la sección de minitutoriales de comandos GNU/Linux. El objetivo de dicha sección es tener un compendio de videos en español que expliquen tips y trucos que frecuentemente se necesitan al operar éstos sistemas.
Se cubren los siguientes puntos de forma breve:
Formas de usar el comando
Switches simples
Usar otro puerto para SSH
Formas de salir de una conexión SSH
SSH sin password
Crear un proxy SOCKS para navegar
Reenviar un puerto remoto a la máquina local (ideal para realizar comunicaciones encriptadas rápidas)
Si tienes dudas, no vaciles en escribirnos, o bien, sugiere qué otros comandos quieres que expliquemos.
