Importar datos desde un fichero json a nuestro servidor de MongoDB
Cuando trabajamos con bases de datos, ya sea para pruebas o para iniciar una puesta en marcha en producción. Lo habitual es que tengamos que importar datos desde otro sistema.
El formato JSon es uno de los formatos de intercambio de datos que más popularidad tiene en la actualidad. Este formato nos permite una gran flexibilidad en el manejo de estos. Casi todos los lenguajes de programación, por no decir todos, en la actualidad cuenta con librerías para el manejo de este tipo de datos. Por lo que el manejo de estos se vuelve muy sencillo.
En el caso de MongoDB, no necesitamos utilizar ningún lenguaje de programación para importar un fichero en formato JSon a nuestra base de datos.
Dentro de la instalación de MongoDB podemos encontrar un comando que nos facilita y mucho esta tarea. Este comando es “mongoimport”
Ha este comando le tendremos que pasar una serie de parámetros para indicarle en que base de datos queremos guardas las colecciones, las tablas en el formato de bases de datos relacionales. El nombre de la colección donde queremos que se guarden nuestros documentos, los registros siguiendo la analogía con las bases de datos relaciones. Y por ultimo, el fichero en formato json donde se encuentran nuestros datos.
MongoDB nos facilita un fichero json con las ciudades de Estados Unidos para hacer pruebas. Vamos a usar este fichero para mostrar un ejemplo. El fichero lo podéis encontrar en la siguiente dirección: http://media.mongodb.org/zips.json. Lo descargamos y lo guardamos en nuestro sistema.
Una aclaración, este método es independiente del sistema donde tengamos instalado nuestro servidor MongoDB. Funciona tanto en Linux, Windows, o Mac. En este caso y que no sirva de precedente, las pruebas la he realizado con un windows 10, y con servidor Debian. Lo habitual es tener el servidor de MongoDB corriendo en un servidor Linux.
Importar los datos a nuestro servidor de MongoDB.
Una vez que ya tenemos nuestro fichero descargado vamos a ver como lo importamos.
Con el parámetro “–db” le indicamos que queremos guardar los datos en la siguiente base de datos. En este caso “ciudadesdb”.
Con el parámetro “–collection” le indicamos la colección, es decir, la tabla donde queremos guardar los datos. En este caso “ciudades”.
El parámetro “–drop” le indicar a mongoimport que descarte todos los datos que hubiese ya en la colección. Es decir, borraría todos los datos que tuviese la tabla antes de realizar la importación de los datos. Cuidado con este parámetro, si queremos añadir los nuevos datos a los ya existentes, no debemos incluir este parámetro.
El parámetro “–file” es donde le indicamos a mongoimport donde está el fichero en formato json con los datos que deseamos importar.
Y esto sería suficiente que nuestro servidor,
Esta en el equipo local, es decir, está en “localhost”.
El puerto que está a la escucha es el de por defecto de la instalación de MongoDB.
Y además no tiene nombre de usuario ni contraseña para acceder a él.
Parámetros avanzados para mongoimport
Como en muchos de los casos no se va a dar alguna de estas opciones tendremos que utilizar alguno de los siguientes parámetros.
Para indicarle a mongoimport en qué dirección esta nuestro servidor usaremos el paramento “–host” y le indicaremos la dirección donde se encuentra nuestro servidor.
Para indicarle el puerto por que cual está a la escucha nuestro MongoDB utilizaremos el paramento “–port” y el puerto que hemos configurado.
Para autentificarnos en el servidor tendremos que utilizar los siguientes paramentos. Para indicarle el nombre de usuario que tenemos que usar usaremos el parámetro “–username” o en versión corta “-u” seguido del nombre de usuario que deseamos usar. Para indicarle la contraseña utilizaremos le parámetro “–password” o “-p” seguido de la contraseña deseada.
Con estos parámetros ya podremos indicar el servidor que deseamos usar, y el usuario de queremos utilizar.
En muchas ocasiones necesitamos instalar un antivirus en nuestro servidor de ficheros bajo un sistemas Linux. Al tratarse de un sistema Linux, las opciones son un poco escasas.
La mejor opción que podemos utilizar es instalar el antivirus ClamAV. Este antivirus es preparado para correr sin ningún problema en nuestro servidor de aplicaciones.
Instalar el antivirus ClamAV en nuestro servidor
Lo primero que debemos hacer antes de instalar ClamAv, o cualquier otro programa, es tener nuestro sistema actualizado. Esto lo podemos hacer con los siguientes comandos.
1
sudo apt-get update; sudo apt-get uprade -y
Una vez que ya tenemos actualizado nuestro sistema, pasamos ha instalar el antivirus.
1
sudo apt-get install clamav clamav-daemon -y
Con clamav instalamos el antivirus propiamente dicho. Con clamav-daemon instalamos el servicio que se ejecutara al inicio de nuestro servidor.
Actualizar la base de datos del ClamAV
Con los pasos anteriores hemos instalado el software del antivirus. El siguiente paso que tenemos que hacer, es actualizarla base de datos de firmas de los virus. Para ellos solo tenemos que ejecutar el siguiente comando.
1
sudo freshclam
En algunas ocasiones, al ejecutarse este comando, nos muestra un mensaje de error. Este error es que no puede tener acceso en exclusiva. Esto esta ocasionado, por que le programa de ClamAV tiene abierta ya la base de datos. Para resolver este problema solo tenemos que para ClamAV.
Paramos el servicio
1
sudo service clamav-freshclam stop
Volvemos a ejecutar el programa para actualizar la base de datos
1
sudo freshclam
Una vez que termina de actualizar la base de datos, volvemos a activar el servicio de ClamAV
1
sudo service clamav-fressclam start
Realizar un escaneo con ClamAV
Para realizar un escaneo están fácil como ejecutar el programa e indicarle el direcctoria que deseamos escanear.
1
sudo clamscan -r /directorio/scanear/
En este ejemplo usamos el parámetro “-r”. Este parámetro lo que hace un escaneo recursivo, es decir, escaneamos la carpeta indicada y todas las incluidas dentro.
Escanear y eliminar los virus encontrados
Para escáner y eliminar los virus que encontremos los haremos de la siguiente manera:
1
sudo clamscan --remove /direcorio_escanear/
Activar el antivirus ClamAV en el inicio
Para que nuestro sistema este protegido cada vez que iniciemos nuestro equipo tendremos que añadir al arranque, tanto el servicio de CalmAv, como el servicio que se encarga de tener la base de datos actualizada.
Activar servicio de ClamAv
1
sudo /etc/init.d/clamav-daemon start
Activar servicio para el gestor de la base de datos
1
sudo /etc/init.d/clamav-freshclam start
Con esto ya tendremos nuestros servidor de ficheros protegido ante los virus.
En determinadas ocasiones tenemos que proteger nuestra conexión de miradas indiscretas, ya sea porque estamos conectados en una WiFi publica, un hotel, etc.
Normalmente para esto se suele recomendar el uso de una VPN. Pero si el servidor de vpn no esta bajo nuestro control podemos no tener esa seguridad deseada.
Proton servidor de VPN anónima
La empresa Proton, famosa por su servidor de correo gratuito y anónimo, a puesto en marcha un servicio de VPN. Esta nos garantiza que nuestra información no sera compartida con ningún gobierno/empresa, y que no habrá ningún log con nuestros datos.
Proton pone a nuestra disposición varios planes de conexión. Varios de pago con diferentes velocidades de conexión, país de donde saldrá nuestra conexión. navegación a través de TOR, numero de dispositivos, etc.
Pero también tiene un plan gratuito. Esta cuenta esta limitado al uso de un solo dispositivos, elección de solo 3 países de salida y velocidad baja, pero suficiente para un uso normal.
Crear una cuenta en ProtonVPN
Lo primero que tenemos que hacer es entrar en la pagina de ProtonVPN y seleccionar el plan que deseamos. Para esta prueba seleccionamos el “FREE”.
Registro en ProtonVPN
El siguiente paso para poder usar el servicio, no es más que una pagina de registro. Como en cualquier pagina de registro, metemos nuestro nombre se usuario, contraseña, cuenta de correo de verificación y poco más.
Registro en ProtonVPN
En el siguiente paso Proton nos enviara a nuestro correo un código de verificación, introducimos el código en la casilla y seguimos.
Obtener archivo de configuración de servidor VPN
Una vez registrados tenemos acceso al escritorio de nuestra cuenta en ProtonVPN, en el tenemos un menú con varias opciones, acceso al escritorio (Dashboard), aquí no mostrara nuestro username (para entrar en la pagina de Proton), si tenemos cuenta de correo de ProtonMail y nuestro plan y si queremos registrarnos a otro.
La siguiente opción es la de “Cuenta” (Account), en esta opción nos mostrara nuestro VPN Login y VPN Password, estos son los datos de identificación cuando creemos nuestra conexión vpn en nuestro dispositivo.
Descarga de ProtonVPN
En la opción de “Descargas” (Download), podremos descargar tanto el cliente de vpn, como los ficheros de configuración. En mi caso lo he instalado en un Ubuntu, al pulsar sobre el icono de Linux, se nos abre una nueva ventana con los pasos que deberemos de seguir para instalar el cliente de OpenVPN.
Configuración de ProtonVPN
Una vez que tenemos el cliente de OpenVPN instalado. Nos desplazamos un poco hacia abajo y no aparecerá las opciones para seleccionar la plataforma en la que estamos corriendo, el protocolo que queremos usar, el protocolo recomendado es el de UDP, pero si nuestra navegación es muy lenta podemos elegir el de TCP.
La ultima opción que tenemos que elegir es el país por el que deseamos salir. En la versión “FREE” solo tenemos 3 países donde elegir, Japón, Holanda y EEUU. Pulsamos la opción de “Server Configs” y vamos a uno de esos países. Elegimos el servidor “XX-FREE#X” y descargamos el fichero.
Servidores ProtonVPN
También tenemos la opción de descargarlos todos. Nos desplazamos hasta el final de la pagina y pulsamos sobre “Download all configurations”. Nos descargara un fichero “zip” con todos los ficheros.
Crear conexión VPN en nuestro dispositivo
Para crear una conexión en Ubuntu, hay varias maneras, por entorno gráfico o por consola.
Cliente red Ubuntu
Para crear la conexión en entorno gráfico, vamos a opciones de red, Configuración de vpn. Agregar una vpn y seleccionamos la opción de “importar desde archivo”. Se nos abrirá una ventana donde seleccionaremos el archivo que nos hemos descargado.
Importar configuración ProtonVPN
Con esto ya tendremos nuestra conexión configurada, con su certificado y demás configuración. Solo falta para terminar la configuración, indicar nuestro OpenVPN Username y OpenVPN Password. Lo introducimos en las casillas de “Nombre de usuario” y “Contraseña” respectivamente.
Configuración cliente VPN
Listo ya tenemos nuestra conexión de vpn con un servidor realmente anónimo y seguro creada. Para comprobarla solo tenemos que activarla, abrir la pagina de www.cualesmiip.com y comprobar cual es nuestra ip publica.
.Net Core permite la portabilidad de nuestras aplicaciones ha cualquier sistemas, ya sea Linux, OSx o Windows.
La nueva versión del framework .Net nos permite desarrollar nuestras aplicaciones y poder ejecutarlas en cualquier sistema.
Como en Linux, pudiendo compilar nuestro código en las distribuciones más populares, como RedHat, Fedora, Suse, CentOS, Oracle, Debian, Linux Mint, Ubuntu, etc. .En sistemas Linux solo podremos crear aplicaciones en 64 bits. Para sistemas de microsoft podemos crear aplicaciones, no solo para pc’s, donde podemos personalizar la compilación desde versiones 7 de windows, hasta la
ultima de windows 10, pero también podemos compilar nuestros códigos para la XBox, la Raspberry Pi 3, con Windows 10, tanto para versiones de 32 como de 64. Para sistemas de apple podemos compilar para las versiones 10 de OSx, en concreto para las versiones 10.10, 10.11 y 10.12, solo en 64 bits. También podemos hacer correr nuestros programas en Android, aunque para este ultimo no esta muy preparado.
Como instalar .Net Core en Ubuntu.
En mi caso la instalación del framework de .Net Core lo he realizado en mi sistema con Ubuntu 17.04. Para ello tenemos que agregar las fuentes donde se encuentra el framework. Para que nuestro Ubuntu nos reconozca estas fuentes como fuentes seguras, lo primero que debemos hacer es agregar las firmas de estas.
Este repositorio es para la versión 17.04 de Ubuntu, si necesitas instalar el framework en otra versión puedes ir a esta pagina ( https://www.microsoft.com/net/core#linuxubuntu ) para encontrar las direcciones para versiones anteriores de Ubuntu.
Una vez que tengamos el repositorio cargado, actualizamos las librerías de nuestro Ubuntu.
sudo apt-get update
E instalamos el framework de .Net Core.
sudo apt-get install dotnet-sdk-2.0.0
En este caso es la versión 2.0 del .Net Core, ultima versión a la fecha de escribir este post.
Llegados a este punto ya podemos desarrollar nuestra aplicación en C#. El framework nos proporciona una serie de comandos, tanto para crear unas plantillas que nos facilitara la creación de nuestras aplicaciones, como para la compilación o la publicación de la aplicación.
Crear un nuevo proyecto con .Net Core en C#
Para probar si todo funciona correctamente, podemos crear la típica aplicación de “Hola mundo”, para ellos solo tenemos que crear un proyecto de tipo “Console”.
mkdir Mi_Proyecto
cd Mi_Proyecto
dotnet new console
Esta crea en la carpeta que le indiquemos un proyecto en lenguaje C# para ejecutarse en la consola de Linux, o de cualquier otro sistema compatible.
Si estamos usando la versión 1.0 de .Net Core, después de crear el nuevo proyecto, del tipo que sea, tendremos que ejecutar el comando “dotnet restore” para restaurar el árbol de dependencias del proyecto. En el caso de estar utilizando la versión 2.0, esto no es necesario, ya que este proceso esta incluido en la ejecución del comando “dotnet new”.
Ejecutar el proyecto .Net Core
Para probar la aplicación podemos utilizar el comando de compilar y ejecutar nuestro.
dotnet run
Este comando compilara y ejecutara el proyecto que se encuentre en el directorio. Si queremos indicarle donde se encuentra el proyecto tendremos que utilizar le parámetro “-p” seguido de la ruta donde se encuentre nuestro proyecto.
dotnet run -p /Ruta/Donde/Esta/Nuestro/proyecto.csproj
Publicar un proyecto en .Net Core
Para distribuir nuestro proyecto debemos crear el paquete con nuestro ejecutable y todas sus dependencias. Para esto debemos usar el comando “dotnet publish”. Este comando nos creara una carpeta con todos los ficheros necesarios para la distribucion de la aplicación
Con el parametro “-c” le indicamos que utilice la configuración para crear un compilado utilizado el tipo “Release”. Si no se indica este paramentro, se utilizara por defecto “Debug”.
El parámetro “-o” le indicamos la carpeta donde queremos que nos cree el paquete. Si no indicamos este parámetro lo creara en una carpeta dentro de la propia del proyecto.
El parámetro “-r” le indicamos que “runtime” o RID se va utilizar para crear la distribución. En este punto es donde le indicamos bajo que sistema operativo queremos que se ejecute nuestra distribución. Si no indicamos este parámetro, el paquete que se cree sera para el sistema operativo bajo el que estemos ejecutando el programa.
Las diferentes opciones son las siguiente:
RID de Windows
Portátil
win-x86
win-x64
Windows 7/Windows Server 2008 R2
win7-x64
win7-x86
Windows 8/Windows Server 2012
win8-x64
win8-x86
win8-arm
Windows 8.1/Windows Server 2012 R2
win81-x64
win81-x86
win81-arm
Windows 10/Windows Server 2016
win10-x64
win10-x86
win10-arm
win10-arm64
RID de Linux
Portátil
linux-x64
CentOS
centos-x64
centos.7-x64
Debian
debian-x64
debian.8-x64
Fedora
fedora-x64
fedora.24-x64
fedora.25-x64 (.NET Core 2.0 o versiones posteriores)
fedora.26-x64 (.NET Core 2.0 o versiones posteriores)
Gentoo (.NET Core 2.0 o versiones posteriores)
gentoo-x64
openSUSE
opensuse-x64
opensuse.42.1-x64
Oracle Linux
ol-x64
ol.7-x64
ol.7.0-x64
ol.7.1-x64
ol.7.2-x64
Red Hat Enterprise Linux
rhel-x64
rhel.6-x64 (.NET Core 2.0 o versiones posterores)
rhel.7-x64
rhel.7.1-x64
rhel.7.2-x64
rhel.7.3-x64 (.NET Core 2.0 o versiones posteriores)
rhel.7.4-x64 (.NET Core 2.0 o versiones posteriores)
Tizen (.NET Core 2.0 o versiones posteriores)
tizen
Ubuntu
ubuntu-x64
ubuntu.14.04-x64
ubuntu.14.10-x64
ubuntu.15.04-x64
ubuntu.15.10-x64
ubuntu.16.04-x64
ubuntu.16.10-x64
Derivados de Ubuntu
linuxmint.17-x64
linuxmint.17.1-x64
linuxmint.17.2-x64
linuxmint.17.3-x64
linuxmint.18-x64
linuxmint.18.1-x64 (.NET Core 2.0 o versiones posteriores)
RID de OS X
osx-x64 (.NET Core 2.0 o versiones posteriores)
osx.10.10-x64
osx.10.11-x64
osx.10.12-x64 (.NET Core 1.1 o versiones posteriores)
RID de Android (.NET Core 2.0 o versiones posteriores)
android
android.21
Esto seria lo básico para poder desarrollar en .Net Core bajo Linux.
Para facilitar el desarrolo en .Net hay varias extensiones para los principales editores que los desarrollados solemos utilizar, como puede Atom, Brackets, Sublime Text, Emacs, Vim o Visual Studio Code.
Para controlar un servomotor con arduino, este nos lo pone muy fácil. A la facilidad de uso de estos dispositivos, se suma el de disponer de una librería nativa en el propio IDE de arduino.
Que es un servomotor o servo?
Los servomotores son simples motores DC con una caja de engranajes para reducir la velocidad de giro de este, y sumado a una electrónica para el control de la posición.
Como todo en esta vida, los hay de diferentes tipos, fuerzas, tamaños y como no colores.
El precio de los servos varían desde poco más de 1€, se pueden encontrar en Aliexpress o Amazon, hasta de varios cientos de euros, para sistemas industriales.
Para el uso que normalmente se hace de ellos, tanto en robótica “domestica”, como para pequeños proyectos donde el coste del prototipo no queremos que se nos salga de madre, con los baratos nos es más que de sobra.
Servomotores más habituales.
El modelos más habitual en el montaje de pequeños robot, o brazos articulados el servo más habitual es el modelo SG90, también se le conoce como 9g, creo que porque su peso es ese. Este servomotor nos ofrece tanto una calidad más que aceptable para nuestros proyectos, como un precio muy contenido, este suele estar por los poco más de 1€. Este tiene una caga de engranajes de plástico, por lo que si nuestro proyecto va a necesitar que desarrolle mucha fuerce, sera mejor utilizar otro tipo de servomotor. El tamaño de este es muy contenido y la mayoría de chasis, ya sea de vehículos, robots o brazos articulados, suele venir diseñados para albergar este tipo de servos. Otro modelo muy utilizado es el MG90 de tamaño y forma idéntico al SG90, pero con la caja de engranajes en metal. Al tener los engranajes de metal del par de fuerza que puede aguantar es mayor.
Que necesito?
Para trabajar con un servo y arduino, los materiales que vamos ha necesitar son los siguientes.
Esquema de montaje de un servomotor controlado con Arduino.
El esquema de montaje de un servomotor controlado con arduino es muy simple. Los cables de los que dispone el servo son muy simples, un cable de color rojo, para el positivo, este suele estar alimentado entre 4,8v hasta los 7v. Por que si no tenemos muchos dispositivos conectados a nuestro arduino, lo podremos alimentar con el sin ningun problema. Cable de color negro, como es normal el negativo del servo, si alimentamos nuestro servo con una alimentación externa al arduino no debemos que olvidarnos de unir todos las masas del proyecto, para homogeneizar esta. Y por ultimo es el cable de color amarillo, este es el de control del servo. Este cable de control lo conectaremos a cualquier pin PWD de nuestro arduino.
Esquema de montaje.
Codificación del servomotor con arduino
Para programar el servo con muestro arduino no tiene mayor complejidad. El propio IDE de Arduino dispone de una librería para el control de estos aparatos. Solo tendremos que ir a la opción de “Programa” –> “Incluir libreria” –> “Servo” o directamente escribir en nuestro código.
#include <Servo.h>
Una vez agregada la librería, solo tenemos que crear un objeto el cual controlara nuestro servo.
Servo controlServo;
Lo siguiente que deberemos hacer sera indicarle a nuestro objeto, en que pin esta conectado nuestro servo, esta operación se hace mediante el comando attach, este comando tiene dos versiones. La versión simple, a la cual solo le pasaremos como parametro el numero del pin al cual tenemos conectado nuestro servomotor.
controlServo.attach(4);
Y la versión extendida, en esta versión, ademas de pasar el pin donde esta conectado el servo, tambien le pasaremos el valor mínimo y máximo de tamaño de la onda de control del servo.
controlServo.attach(4, 200, 2100);
En el 99,9% de los casos, con pasarle el pin donde esta conectado el servo en el arduino sera más que suficiente.
Si queremo “desenlazarnos” de el la librería Servo de Arduino nos ofrece la posibilidad de hacerlo mediante el comando detach(). Solo con llamarlo nos desconectaremos del servomotor.
controlServo.detach()
Para comprobar que estamos conectados a un servo, contamos con el siguiente comando attached(), este nos devolverá “True” si estamos conectados o “False” si no lo estamos.
if (controlServo.attached() == true)
{
Serial.print('Estamos conectados al servo');
}
else
{
controlServo.attach(4);
}
Para poder situar el servo en el ángulo que deseemos utilizaremos el comando write(). Ha este comando le pasaremos como parámetro el angulo en el que queremos posicionar nuestro servo.
controlServo.write(90);
Si queremos saber en que posición se encuentro nuestro servo utilizaremos el comando read(). Este nos devuelve el angulo en el que se encuentra nuestro servomotor.
int posServo;
posServo = controlServo.read();
Y con estos simples comando tendremos un control absoluto sobre los servomotores que tengamos conectados a nuestro Arduino.
Ejemplo completo del uso de servomotores con arduino.
#include <Servo.h>
Servo controlServo;
int pinServo = 4;
int posServo = 0;
void setup() {
// put your setup code here, to run once:
// Paramentros de Servo.attach(pin, min, max)
// pin -> pin donde esta conectado la señal de servo
// min -> Valor minimo de la onda del servo
// max -> Valor maximo de la onda del servo
controlServo.attach(pinServo);
}
void loop() {
// put your main code here, to run repeatedly:
if (controlServo.attached() == false)
{
controlServo.attach(pinServo);
}
posServo = controlServo.read();
if (posServo != 90)
{
// Posicionamos el servo en los 90 grados
controlServo.write(90);
// Esperamos 1 segundo
delay(1000);
}
else
{
// Lo posicionamos en los 180 grados
controlServo.write(180);
// Volvemos a esperar otro segundo
delay(1000);
}
controlServo.detach();
}
Si tienes alguna duda o sugerencia, no dudes en dejarnos tu comentario.
Hace poco Rapid7 a puesto a disposición una nueva versión Metasploitable, una maquina virtual que nos permite practicar técnicas de pentesting sin tener que “romper” nada. Estas maquinas esta preparadas con múltiples vulnerabilidades lo que permite practicar deber técnicas de hacking.
Nueva versión de Metasploitable 3
Ha diferencia de las maquina anteriores, en las que estaban basadas en Linux. Esta nueva versión esta basada en una versión de Windows Server, en concreto en la 2008 r2.
Las versiones anteriores de estas maquinas estaban disponibles las maquinas virtuales completas. En esta ocasión, lo que dispones en el Github de Rapid7 son unos script, tanto para Linux, como para Windows, realizado con PowerShell, para crear nuestra máquina.
En fichero de README.md, tenemos los pasos que debemos seguir para crear la maquina, ya sea de forma automática, utilizando los script anteriores, o de forma manual, que no deja de ser los pasos contenidos en los ficheros, introducidos manualmente por nosotros en la consola, ya sea en linux, o en windows.
Programas necesarios para crear la maquina
Para la creación de la maquina virtual tenemos que tener varios programas, en unas versiones en concreto para su realización.
VirtualBox 5.1.6
Lo primero que tendremos que tener instalado, sera la versión 5.1.6 de VirtualBox, por que dice la ultima versión de VirtualBox la 5.1.8 tiene un fallo que no permite el correcto funcionamiento del script. Podemos descargar la versión coreccta de VirtualBox desde esta dirección https://www.virtualbox.org/wiki/Download_Old_Builds_5_1
Una vez descargado el VirtualBox en la versión adecuada los instalamos. En mi caso con Ubuntu.
Otro programa que debemos tener en nuestro sistema es Packer, que permite la creación y distribución de la maquina, si quieres saber mas sobre este programa puedes echarle un vistazo a su pagina. Para instalar este programa solo tenemos que descargar la ultima versión desde la pagina. En mi caso con Ubuntu, solo tuve que descomprimir el fichero, y agregar la ruta donde se encuentra a la variable Path del sistema. Para agregar la ruta del Packer en Linux.
export PATH=$PATH:~/packer
Cambiaremos “~/packer” por la ruta donde hallamos descomprimido el fichero.
Vagrant
Otro de los programas que necesitaremos tener instalados es Vagrant y Vagrant Reload Plugin. En el caso de Ubuntu podemos hacerlo mediante los repositorios del sistemas.
sudo apt-get install vagrant
Una vez que tenemos instalado Vagrant, instalamos el plugin
vagrant plugin install vagrant-reload
Crear la máquina virtual de Metasploitable 3
Una instalados todos los programas, ya podemos ejecutar el script. Con Ubuntu.
./build_win2008.sh
Lo primero que hace el script, es verificar que disponemos de los programas, y en la versión adecuado. Si todo esta bien, descargara la imagen desde el servidor de Microsoft del Windows Server 20008 r2. Una vez descargada la imagen instalara y configurara el sistema. Por último creara la maquina virtual.
Una vez que termine correctamente el script, se habrá creado un fichero con el siguiente nombre “windows_2008_r2_virtualbox.box”. Este fichero es el que contiene la máquina virtual.
Para agregar la maquina a nuestra copia de VirtualBox ejecutaremos el comando “vagrant up”, este comando creará y configurará la maquina virtual para que este accesible en nuestro VirtualBox.
Y con estos paso ya tenemos nuestra nueva maquina vulnerable para divertirnos un rato.
Si tienes alguna duda o sugerencia puedes dejarnos un comentario.
Mediante un sensor DS18B20 podemos obtener una lectura de temperatura fácil y precisa. Este sensor puede ser una gran aliado para nuestro montajes. Este sensor de temperatura utiliza el protocolo de comunicación 1-Wire, lo que nos permite una facil comunicación con el, y la posibilidad de crear un red de sensores, sin tener que ocupar muchos de nuestros pines de entradas y salidad de datos de nuestro Raspberry Pi.
El montaje del sensor en un sencillo, la alimentación del sensor lo haremos mediante el pin de 3,3v del conector GPIO (pin 1), al clave rojo del sensor, en mi caso, si utilizamos la versión como un transistor, la conectaremos al pin más a la izquierda. La masa, la sacaremos el pin 6 del GPIO, y lo conectaremos al cable negro, o al pin de la derecha del sensor. La salida de datos la conectaremos al pin 4, al cable amarillo, o al pin del medio del sensor. Para terminar el montaje, tendremos que situar una resistencia de 4K7 Ohm, entre el pin positivo del sensor y el pin de datos.
Esquema de montaje del sensor DS18B20 con un Raspberry Pi
El sensor DS18B20, permite conectar varios sensores al mismo canal, es decir, que si queremos añadir más sensores DS18B20 a nuestro circuito, no tendremos que ocupar más pines de datos de nuestra raspberry, colo tendremos que conectar cada uno de los pines del sensor al mismo circuito que el primero.
Ejemplo de montaje de varios sensores DS18B20 a una Raspberry Pi.
Montaje de varios sensores DS18B20 a una Raspberry Pi
Comprobando la instalación de los sensores DS18B20
Como todas las comunicaciones que Linux hace con cualquier dispositivo, ya sea puertos serie, USB, comunicaciones I2C, etc. La forma de trabajar la Raspberry Pi con el sensor de temperatura DS18B20 es creando un fichero, donde el sensor escribe los datos devuelto. Esta comunicación la realiza mediante el bus 1-Wire.
Para comprobar que nuestra Raspberry Pi lee todos los sensores que tenemos instalados, solo tendremos que mirar cuantas carpetas con el inicio “28” tenemos dentro del directorio que maneja las comunicaciones con el bus 1-Wire. Cada una de estas carpetas que comienzan por “28” corresponde con el numero de serie del sensor de temperatura.
ls /sys/bus/w1/devices/
Cada una de estas carpetas que comienzan por “28” corresponde con el número de serie del sensor de temperatura. Si faltase alguna carpeta, habría que comprobar la conexión de ese sensor.
Lectura del sensor DS18B20 con una Raspberry Pi
Para leer los datos proporcionados por el sensor de temperatura DS18B20 con nuestra Raspberry Pi solo tendremos que acceder a cada una de las carpetas, y leer los datos que hay dentro del fichero “w1-slave”. En este fichero tendremos el valor de la temperatura leída por el sensor * 1000, es decir, para obtener el valor real de la temperatura, dividiremos el valor del parametro “t” / 1000.
Para hacer esto desde Python, haremos los siguiente.
Añadiremos las siguientes librerías, para el manejo de ficheros y directorios del sistema
# Librerias para la lectura de la temperatura
import os
import glob
Cargamos los módulos en el kernel del sistema para manejar el bus 1wire del conector GPIO del Raspberry Pi.
Con esta linea cargamos el nombre del primer sensor de la lista disponible, para cargar las demás rutas solo tendremos que cambiar “[0]” por la posición deseada.
Lo siguiente que haremos es leer el fichero “w1_slave”, para leer el valor de la temperatura del sensor. Leemos el fichero y cargamos todas las lineas disponibles en una variable.
Una vez que ya tenemos el contenido del fichero, buscamos el parámetro “t” donde esta la temperatura. Una vez que encontramos la temperatura, la multiplicamos por 1000, par obtener el valor real.
posTemp = linSensor[1].find('t=')
# Si la posicion es valida
if posTemp != -1:
# Anadimos son posiciones mas por t=
strTemp = lines[1][posTemp+2:]
# Calculamos la temperatura real
temperatura = float(strTemp) / 1000.0
Con esto ya tendríamos el valor del sensor, con su valor real, dentro de la variable “temperatura”.
Uno de los métodos más habituales para proteger carpetas en un servidor web bajo Apache, es la utilización del archivo .htaccess.
Proteger un directorio con .htaccess en Apache
Lo primero que tenemos que tener en cuenta, es si nuestro servidor web tiene activada la opción de trabajar con el fichero .htaccess.
Para comprobar si tenemos activada esta opción, es mirar en el fichero de configuración “/etc/apache2/sites-available/000-default.conf”, si no tenemos creado ningun virtual host, si tenemos el siguiente parámetro.
AllowOverride All
Si en nuestro fichero de configuración existe este parametro, pero con el atributo de “None”, cambiaremos este por “All”.
Con este parametro le indicamos a Apache que reconozca todas las directivas que encuentre dentro del fichero .htaccess. Si solo queremos que tenga en cuenta las directivas de autenticación en vez de poner “All” tendremos que poner “AuthConfig”.
Si tenemos creados virtual host, esto los tendremos que comprobar en el fichero que hayamos utilizado para crear la configuración de nuestro virtual host.
Ejemplo de configuración.
<Directory /var/www/pruebas.local/public_html/>
Options Indexes FollowSymLinks
AllowOverride All
Order allow,deny
allow from all
</Directory>
Crear nuestro fichero de contraseñas
Lo primero que tenemos que tener para proteger nuestra carpeta es un fichero con las contraseñas a las que vamos ha permitir el acceso. Este fichero contendrá el nombre de usuario y la contraseña codificada en MD5.
Para crear el fichero utilizaremos el siguiente programa.
Con el parametro “-c” le indicamos a htpasswd que vamos ha crear un fichero nuevo de contraseñas. Si el fichero ya existiera, este seria borrado.
Luego indicaremos la ruta completa donde queremos guardar el fichero con las contraseñas, no tiene por que estar dentro de las carpetas del servidor web, pero si tiene que tener los permisos para acceder a el.
Por ultimo le indicaremos el nombre de usuario que deseamos utilizar para esa contraseña.
Una vez finalizado nos quedara un fichero con la siguiente linea.
usuario:$spr1$lE/2eTdy$q/FMRI9UrogzET/Ks/6mH/
Si queremos añadir más usuarios a nuestro fichero, simplemente no utilizaremos el parámetro “-c”, quedando de la siguiente manera.
Para crear el fichero .htaccess, nos situaremos dentro del directorio que deseamos proteger.
cd /var/www/pruebas.local/public_html/protegido
Creamos el fichero .htaccess con nuestro editor favorito, en mi caso nano
nano .htaccess
Si el usuario con el estamos trabajando no tuviera los permisos suficientes para trabajar en el directorio que intentamos proteger, la creariamos utilizando “sudo”
sudo nano .htaccess
Si creamos el fichero, con cualquier usuario que no sea www-data, cambiaremos el propìetario del fichero, para no tener problemas.
sudo chown www-data:www-data .htaccess
Y añadimos las siguientes lineas al fichero .htaccess
AuthType Basic
AuthName "Area protegida, introduzca nombre de usuario y contraseña"
AuthUserFile /ruta/donde/queremos/guardar/las/contraseñas
Require valid-user
De esta forma, solo los usuario que están en el fichero de contraseñas que hemos creado, tendrán acceso al directorio.
Si solo queremos, que unicamente, que acceda un usuario de la lista que hemos creado. Cambiaremos el parametro de “Requiere” por “user” más el nombre de usuario que deseemos que tenga acceso. Quedando de la siguiente forma.
AuthType Basic
AuthName "Area protegida, introduzca nombre de usuario y contraseña"
AuthUserFile /ruta/donde/queremos/guardar/las/contraseñas
Require user UsuarioConAcceso
Y con esto ya tendríamos implementado nuestro control de accesos a nuestro directorio.
Si tiene alguna duda o sugerencia, déjanos un comentario.
En alguna ocasión, al instalar algún programa en nuestro Ubuntu, puede ser extrapolado a cualquier sistema Linux, Al descargar las dependencias de librerías que necesita puede haber una confusión cuando nuestro sistema es de 64 bits, y la aplicación esta programada para la versión de 32 bits.
Problema con librerías en Google Earth
Este es el caso que nos podemos encontrar al instalar el Google Earth. Cuando descargamos el programa de la pagina, esta nos ofrece el fichero de instalación que se ajusta a nuestro sistema operativo automáticamente. Pero el problema esta que la versión que se descarga para Debian, y sus variantes, como es el caso de Ubuntu. Este fichero de instalación es de 32 bits.
Al instalar, se descargan las dependencias que se ajustan mejor para nuestra versión de sistema operativo, en este caso las librerías descargadas son las de la versión de 64 bits.
Al ejecutar el Google Earth, nos muestra un error indicándonos que no tenemos la librería “libgthread-2.0.so.0”.
~$ google-earth
./googleearth-bin: error while loading shared libraries: libgthread-2.0.so.0: cannot open shared object file: No such file or directory
Nos muestra que si tenemos la librería instalada, en la mejor versión “libglib2.0-0:amd64” para nuestro sistema operativo.
Solución al problema con las librerias
Para forzar a que se instale la versión de 32 bits, tendremos que ejecutar el siguiente comando.
sudo apt-get install libglib2.0-0:i386
Lo que hacemos es instalar la librería “libglib2.0-0”, donde esta la librería que necesitamos, con el anterior comando se nos muestra junto con la versión en la que esta instalada, ya se de 64 bits (amd64), o de 32 bits (i386). Seguido de la versión que queremos instalar, en este caso la de 32 bits (:i386).
~$ sudo apt-get install libglib2.0-0:i386
Leyendo lista de paquetes... Hecho
Creando árbol de dependencias
Leyendo la información de estado... Hecho
Se instalarán los siguientes paquetes NUEVOS:
libglib2.0-0:i386
0 actualizados, 1 nuevos se instalarán, 0 para eliminar y 0 no actualizados.
Se necesita descargar 0 B/1.184 kB de archivos.
Se utilizarán 5.479 kB de espacio de disco adicional después de esta operación.
Seleccionando el paquete libglib2.0-0:i386 previamente no seleccionado.
(Leyendo la base de datos ... 263708 ficheros o directorios instalados actualmente.)
Preparando para desempaquetar .../libglib2.0-0_2.48.1-1~ubuntu16.04.1_i386.deb ...
Desempaquetando libglib2.0-0:i386 (2.48.1-1~ubuntu16.04.1) ...
Procesando disparadores para libc-bin (2.23-0ubuntu3) ...
Procesando disparadores para libglib2.0-0:amd64 (2.48.1-1~ubuntu16.04.1) ...
Configurando libglib2.0-0:i386 (2.48.1-1~ubuntu16.04.1) ...
Procesando disparadores para libc-bin (2.23-0ubuntu3) ...
Si no se ha producido ningún fallo, ya tendremos las librerías instaladas, tanto en la versión de 64 (amd64) como en la de 32 (i386).
Podemos verificarlo ejecutando de nuevo el comando “dpkg -S libgthread-2.0.so.0”. Esta vez nos tiene que mostrar lo siguiente.
El Internet de la cosas (IoT) a puesto de moda el conectar cualquier cosa a internet. Y nuestros proyectos con arduino no iban a ser menos.
En el mercado, hay multitud de shield que nos dan la posibilidad de añadir conexión wifi a nuestro arduino, pero estas placas tienen un precio demasiado alto, la mayoría de ellos ha un precio elevado. Estos precios de los sistemas wifi contrastan con el precio habitual que suelen tener los demás accesorios para arduino.
Modulo wifi ESP8266
Pero además de los shield tenemos otros método de poder añadir conectividad wifi a nuestro proyectos de arduino. Este es el modulo Wifi ESP8266 nos ofrece conexión wifi de una manera sencilla y barata.
Ademas de la conexión wifi, este modulo permite una configuración muy fácil mediante el uso de comandos AT, dispone a su vez de un pequeño servidor web, que nos facilitara la conexión a él mediante el uso de un simple navegador.
Conectar el modulo wifi ESP8266 con arduino
La conexión del modulo ESP8266 con arduino es muy simple, solo tendremos que conectar los pines RX y TX del modulo, a los pines RC y TX de muestro arduino, si lo preferimos, como es mi caso, los podemos conectar a cualquier otros pines y utilizar la librería de emulación de comunicaciones serie.
Luego tendremos que conectar el pin marcado como RST a la alimentación de 3.3v de muestro arduino. La alimentación del modulo la tendremos que realizar utilizando un fuente de 3.3 v externa.
La salida de voltaje del arduino solo ofrece una alimentación de 50 mAmp, el modulo wifi ESP8266, en el arranque consume un poco más. Para pruebas podemos conectarlo a la salida de 3.3 v del arduino, pero si tienes la posibilidad de contar con una fuente externa, es mejor que lo conectes a ella. Solo queda conectar el pin GND a la fuente externa o a uno de los pines GND del arduino.
Alimentación a través de Arduino del modulo ESP8266
Circuito con alimentación exterior del modulo wifi.
Alimentación del modulo ESP8266 mediante fuente externa
Código para leer los datos desde el puesto serie del módulo ESP8266 y escribirlos al puerto serie de la consola, y viceversa.
#include <SoftwareSerial.h>
// Creamos un puerto serie virtual para la conexión con el modulo Wifi
SoftwareSerial Wifi(3, 2); // Pin RX, Pin TX
void setup()
{
// Creamos la conexion serie para el control desde la consola
Serial.begin(9600);
// Creamos la conexión con el modulo Wifi
Wifi.begin(115200);
}
void loop()
{
// Si hay datos desde el modulo Wifi
if (Wifi.available())
{
// Leemos un caracter
char c = BT1.read() ;
// Y lo escribimos en el puerto de la consola
Serial.print(c);
}
// Si Hay datos disponibles desde la consola
if (Serial.available())
{
// Leemos un caracter
char c = Serial.read();
// Y lo escribimos en el modulo Wifi
Wifi.print(c);
}
}
Es simple código nos va ha permitir comprobar el estado de nuestro modulo ESP8266 y realizar las configuraciones básicas.
Comprobar el funcionamiento del modulo Wifi ESP8266
Al arrancar el modulo, este nos tiene que devolver un mensaje de “Ready”
[Vendedor:www.ai-thinker.com Version:0.9.2.4]
ready
Para verificar que tenemos conexión con el modulo, desde la ventana de consola, escribimos AT, si todo es correcto y tenemos conexión con el modulo. Este nos devolverá un “OK”
[Vendedor:www.ai-thinker.com Version:0.9.2.4]
ready AT OK
Este modulo permite 3 modos de funcionamiento:
Modo 1: Modo estandar, en este modo de funcionamiento, el módulo se comporta como si fuera un router. Modo servidor.
Modo 2: Modo dispositivo / AP, en cambio en este modo, es módulo se comporta como si fuera un dispositivo que se va ha conectar con un router. Modo cliente.
Modo 3: Esta forma de funcionamiento, es la mezcla de los dos anteriores. Funciona lo mismo de cliente como de servidor.
Para ver en que modo esta funcionando nuestro ESP8266, le enviamos el siguiente comando AT.
AT+CWMODE?
+CWMODE:3
OK
En este caso, nos indica que esta funcionando en el modo 3. Si no sabemos muy bien como queremos que funcione nuestro modulo ESP8266, lo podemos dejar en este modo para asegurarnos su correcto funcionamiento.
Para cambiar el modo de funcionamiento, le tendremos que enviar el siguiente comando AT.
AT+CWMODE=3
no change
En este caso, como ya estaba en este modo de funcionamiento, no indica que no se ja producido ninguna cambio. Si el modo de funcionamiento no fuese el ya establecido, no devolvería un “OK”.
Conexión con la red wifi con el ESP8266
Mediante otro comando AT, podemos obtener la lista de conexiones wifi al alcance del modulo.
La información que nos aparece es, posición en la lista, el SSID de la conexión wifi, potencia de la señal, y la MAC del router.
Para conectar el modulo ESP8266, a nuestra red wifi, utilizaremos otro comando AT. En este caso, el comando AT+CWJAP=”SSID_nuestra_conexión”, “contraseña”
AT+CWJAP="SSID_nuestra_conexión", "contraseña"
OK
Si la conexión se ha realizado con existo, nos devolverá como siempre un “OK”.
Obtener información de nuestra conexión con ESP8266
Al establecer conexión, con nuestro router o el servidor de DHCP que tengamos instalado en nuestra, este le tiene que asignar una dirección IP a nuestro modulo. Para conocer la ip asignado a nuestro modulo wifi utilizaremos el siguiente comando AT.
AT*CIFSR
192.168.1.1
192.168.1.201
OK
Este comando AT nos devolverá, en una primera linea, la dirección ip del router, y en una segunda, la dirección ip que se le ha asignado al modulo.
Activar servidor TCP en el modulo wifi ESP8266
Con esto, ya podríamos conectarnos al ESP8266, pero para poder interactuar con el debemos activar el servidor disponible en modulo. Para activar este servidor volvemos a tirar de comando AT.
AT+CIPSERVER=1, 80
OK
Esto activara el servidor TCP en el puerto 80.
Para desactivar el servidor solo tendremos que repetir el mismo comando cambiado el 1 por un 0.
AT+CIPSERVER=0, 512
OK
Una vez que tengamos el servidor TCP activado en el modulo, podremos interactuar con el estableciendo una conexión en la dirección ip asignada y mediante el puerto activado.
Tabla con los comandos AT disponibles en el modulo wifi ESP8266
Comandos
Descripción
Tipo
Configuración / Ejecución
Estado
Prueba
Parámetros y ejemplos
AT
general test
basic
–
–
–
–
AT+RST
restart the module
basic
–
–
–
–
AT+GMR
check firmware version
basic
–
–
–
–
AT+CWMODE
wifi mode
wifi
AT+CWMODE=<mode>
AT+CWMODE?
AT+CWMODE=?
1= Sta, 2= AP, 3=both, Sta is the default mode of router, AP is a normal mode for devices
AT+CWJAP
join the AP
wifi
AT+ CWJAP =<ssid>,< pwd >
AT+ CWJAP?
–
ssid = ssid, pwd = wifi password
AT+CWLAP
list the AP
wifi
AT+CWLAP
AT+CWQAP
quit the AP
wifi
AT+CWQAP
–
AT+CWQAP=?
AT+ CWSAP
set the parameters of AP
wifi
AT+ CWSAP= <ssid>,<pwd>,<chl>, <ecn>
AT+ CWSAP?
ssid, pwd, chl = channel, ecn = encryption; eg. Connect to your router: AT+CWJAP=”www.electrodragon.com”,”helloworld”; and check if connected: AT+CWJAP?
AT+CWLIF
check join devices’ IP
wifi
AT+CWLIF
–
–
AT+ CIPSTATUS
get the connection status
TCP/IP
AT+ CIPSTATUS
<id>,<type>,<addr>,<port>,<tetype>= client or server mode
id = 0-4, type = TCP/UDP, addr = IP address, port= port; eg. Connect to another TCP server, set multiple connection first: AT+CIPMUX=1; connect: AT+CIPSTART=4,”TCP”,”X1.X2.X3.X4″,9999
AT+CIPMODE
set data transmission mode
TCP/IP
AT+CIPMODE=<mode>
AT+CIPSEND?
0 not data mode, 1 data mode; return “Link is builded”
eg. send data: AT+CIPSEND=4,15 and then enter the data.
AT+CIPCLOSE
close TCP or UDP connection
TCP/IP
AT+CIPCLOSE=<id> or AT+CIPCLOSE
AT+CIPCLOSE=?
AT+CIFSR
Get IP address
TCP/IP
AT+CIFSR
AT+ CIFSR=?
AT+ CIPMUX
set mutiple connection
TCP/IP
AT+ CIPMUX=<mode>
AT+ CIPMUX?
0 for single connection 1 for multiple connection
AT+ CIPSERVER
set as server
TCP/IP
AT+ CIPSERVER= <mode>[,<port> ]
mode 0 to close server mode, mode 1 to open; port = port; eg. turn on as a TCP server: AT+CIPSERVER=1,8888, check the self server IP address: AT+CIFSR=?
AT+ CIPSTO
Set the server timeout
AT+CIPSTO=<time>
AT+CIPSTO?
<time>0~28800 in second
+IPD
received data
For Single Connection mode(CIPMUX=0): + IPD, <len>:
For Multi Connection mode(CIPMUX=1): + IPD, <id>, <len>: <data>
más popularidad tiene en la actualidad. Este formato nos permite una gran flexibilidad en el manejo de estos. Casi todos los lenguajes de programación, por no decir todos, en la actualidad cuenta con librerías para el manejo de este tipo de datos. Por lo que el manejo de estos se vuelve muy sencillo.
