Poblar LDAP desde fichero JSON [PAM y SSH con Clave publica]

3 Aug, 2016

En esta entrada podemos ver como introducir usuarios desde un fichero JSON a LDAP para utilizarlos para autenticación con clave publica para poder acceder por ssh a nuestra maquina, con creación automática del directorio home del usuario.

Scripts: (https://github.com/Tedezed/LDAP/tree/master/Poblar%20LDAP%20con%20JSON)

  • Poblar_LDAP.py Para añadir los usuarios del fichero humans.js.
  • Eliminar_LDAP.py Para eliminar los usuarios del fichero humans.js.
  • humans.js Usuarios que vamos a añadir a nuestro LDAP.
  • public_key.sh Script para consultar la clave publica del usuario.

Comenzamos añadiendo el esquema openssh-lpk, para poder incluir claves públicas ssh en un directorio LDAP:

nano openssh-lpk.ldif
dn: cn=openssh-lpk,cn=schema,cn=config
objectClass: olcSchemaConfig
cn: openssh-lpk
olcAttributeTypes: ( 1.3.6.1.4.1.24552.500.1.1.1.13 NAME 'sshPublicKey'
  DESC 'MANDATORY: OpenSSH Public key'
  EQUALITY octetStringMatch
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )
olcObjectClasses: ( 1.3.6.1.4.1.24552.500.1.1.2.0 NAME 'ldapPublicKey' SUP top AUXILIARY
  DESC 'MANDATORY: OpenSSH LPK objectclass'
  MAY ( sshPublicKey $ uid )
  )
sudo ldapadd -Y EXTERNAL -H ldapi:/// -f openssh-lpk.ldif

Creamos un virtualenv:

cd .virtualenv
virtualenv ldap
cd ldap

Activamos el virtualenv anterior:

source bin/activate

Instalamos python-ldap:

pip install python-ldap

Una vez echo esto podemos ejecutar Poblar_LDAP.py para introducir los usuarios del fichero humans.js.

Instalamos libnss-ldapd para la autenticación de usuario en LDAP:

apt-get install libnss-ldapd ldap-utils

Configuración durante la instalación:

Conexión:

ldap://localhost:389/

Base de nuestro árbol:

dc=example,dc=org

Configuración de NSS con LDAP:

passwd
group

Configuramos /etc/pam.d/common-session

session [success=ok default=ignore] pam_ldap.so minimum_uid=2000

Configuramos mkhomedir en pam-configs:

nano /usr/share/pam-configs/mkhomedir
Name: Create home directory during login
Default: yes
Priority: 900
Session-Type: Additional
Session:
        required        pam_mkhomedir.so umask=0022 skel=/etc/skel

Actualizamos pam con:

sudo pam-auth-update

Creamos nuestro script para obtener la clave publica del usuario del ldap:

nano /usr/bin/public_key.sh
#!/bin/sh
ip_ldap="localhost"
port=389
base="dc=example,dc=org"

ldapsearch -x -h $ip_ldap -p $port -b $base -s sub "(&(objectClass=posixAccount) (objectClass=ldapPublicKey) (cn=$1))" | \
sed -n '/^ /{H;d};/sshPublicKey:/x;$g;s/\n *//g;s/sshPublicKey: //gp'

Comprobamos su funcionamiento de script:

(ldap)root@debian:/home/debian/ldap/python# sh /usr/bin/public_key.sh morrigan.rigan
ssh-rsa ssh-rsa Clave_RSA_Publica

Editamos y especificamos la ruta del script:

nano /etc/ssh/sshd_config
# LDAP SSH
AuthorizedKeysCommand /usr/bin/public_key.sh
AuthorizedKeysCommandUser root

Reiniciamos:

service sshd restart

Pantalla LCD 16×2 y PCF8574 (I2C) para Arduino

2 Aug, 2016

En esta entrada tratare de una forma breve el uso de una pantalla LCD 16x2 con PCF8574 por i2c.

Lo primeo sera identificar la dirección de nuestra pantalla utilizando el siguiente código:

    #include <Wire.h>
     
     
    void setup()
    {
      Wire.begin();
     
      Serial.begin(9600);
      while (!Serial);             // Leonardo: wait for serial monitor
      Serial.println("\nI2C Scanner");
    }
     
     
    void loop()
    {
      byte error, address;
      int nDevices;
     
      Serial.println("Scanning...");
     
      nDevices = 0;
      for(address = 1; address < 127; address++ )
      {
        // The i2c_scanner uses the return value of
        // the Write.endTransmisstion to see if
        // a device did acknowledge to the address.
        Wire.beginTransmission(address);
        error = Wire.endTransmission();
     
        if (error == 0)
        {
          Serial.print("I2C device found at address 0x");
          if (address<16)
            Serial.print("0");
          Serial.print(address,HEX);
          Serial.println("  !");
     
          nDevices++;
        }
        else if (error==4)
        {
          Serial.print("Unknow error at address 0x");
          if (address<16)
            Serial.print("0");
          Serial.println(address,HEX);
        }    
      }
      if (nDevices == 0)
        Serial.println("No I2C devices found\n");
      else
        Serial.println("done\n");
     
      delay(5000);           // wait 5 seconds for next scan
    }

Conectaremos las salidas SLC, SDA, GND a negativo y VCC la conectaremos a una de las salidas de 5V.

Una vez compilado y subido el código anterior, podremos abrir nuestro monitor serial que se encuentra el el apartado herramientas del IDE de Arduino.

Nos mostrara algo así:

Scanning...
I2C device found at address 0x3F  !
done

Con esto tendremos la dirección de nuestra pantalla, ya solo quedaría probarla con un código de ejemplo, recuerda tener instalada la librería LiquidCrystal.

#include <Wire.h>                 
#include <LiquidCrystal_I2C.h>   
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);//Direccion de LCD
void setup()   { 
lcd.begin(16,2);// Indicamos medidas de LCD        
}
void loop() {
lcd.clear();//Elimina todos los simbolos del LCD
lcd.setCursor(0,0);//Posiciona la primera letra despues del segmento 5 en linea 1             
lcd.print("AventuraBinaria");
delay (2000);//Dura 2 segundos
lcd.clear();
lcd.setCursor(3,1);//Posiciona la primera letra despues del segmento 6 en linea 2            
lcd.print("Hola Mundo!");
delay (2000);//Dura 1 segundo  
}

Un saludo!

Pantalla LCD 16x2 y PCF8574 (I2C) para Raspberry pi

2 Aug, 2016

En esta entrada trataremos de utilizar una de las pantallas LCD más comunes, comunicándonos con un circuito PCF8574, mediante I2C. Estos dos últimos los compre juntos para simplificar el control de la pantalla LCD, ya que también podemos conectar la pantalla directamente a nuestra Raspberry pi, pero tendremos el inconveniente de que nos ocupara gran cantidad de las salidas disponibles. De este modo ocuparemos un total de 4 pines.

Comenzamos, actualizamos nuestro Raspbian con las siguientes instrucciones:

$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get dist-upgrade
$ sudo rpi-update

Introducimos en /boot/config.txt la siguiente linea:

device_tree=

Reiniciamos nuestra Raspberry pi.

$ sudo reboot

Verificamos que podemos ejecutar:

$ sudo hwclock

Ejecutamos sudo raspi-config para cambiar la configuración de nuestra Raspberry pi.

Seleccionamos lo siguiente:

  • 8 Advanced Options
  • A7 I2C
  • Yes o Ok Salimos con Finish.

Instalamos paquetes necesarios:

$ sudo apt-get update
$ sudo apt-get install python-smbus i2c-tools

Editamos el archivo:

$ sudo nano /etc/modprobe.d/raspi-blacklist.conf

Este lo dejamos de la siguiente forma:

blacklist spi-bcm2708
#blacklist i2c-bcm2708

Editamos el achivo:

$ nano /etc/modules

Este lo dejamos de la siguiente forma:

snd-bcm2835
i2c-dev

Reiniciamos la Raspberry.

$ sudo reboot

Para testear introducimos el comando i2cdetectcon el variante del parámetro -y siguiente.

Para los modelos A, B Rev 2 o B+:

$ sudo i2cdetect -y 1

Para el modelo original B Rev 1:

$ sudo i2cdetect -y 0

En mi caso tengo el modelo B+ así que ejecuto el siguiente comando:

$ sudo i2cdetect -y 1

Nos devolvera algo asi:

0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Conectamos la pantalla LCD con el circuito de expansión. La conexión es muy simple. Conectamos nuestra pantalla Raspberry pi con PCF8574:

  • GND negativo.
  • VCC positivo 5V.
  • SDA.
  • SCL.

Una vez conectada nuestra pantalla con el circuito PCF8574, volvemos a ejecutar el comando:

$ sudo i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 3f
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Con 3f identificamos la dirección para controlar la pantalla. En la siguiente entrada continuare explicando el uso de la pantalla LCD, con código Python disponible en mi Github.

https://vine.co/v/edhvIb16Bnw