Creación, publicación y firma de claves PGP

5 Feb, 2017

Comments

En esta entrada vamos a ver los pasos básicos para construir un anillo de confianza con PGP, certificando la identidad y firmando claves.

Generar par de claves

Para comenzar generamos un par de claves propio, con nuestro nombre real y correo electronico:

~/.gnupg$ gpg --gen-key
  1. Seleccionamos la opción 4 solo RSA para firmar.
  2. Tamaño de 4096 bits.
  3. En mi caso la clave nunca caduca, opción 0.
  4. Introducimos nuestro nombre real, correo electrónico y un comentario.

Una vez introducido las siguientes opciones, nos saldrá el siguiente mensaje. Es necesario generar muchos bytes aleatorios. Es una buena idea realizar alguna otra tarea (trabajar en otra ventana/consola, mover el ratón, usar la red y los discos) durante la generación de números primos. Esto da al generador de números aleatorios mayor oportunidad de recoger suficiente entropía. Lo que tendremos que hacer es ejecutar tareas pesadas, como ejecutar una maquina virtual, para generar bytes aleatorios.

Para terminar nos pasara la siguiente información con el ID de nuestra clave:

gpg: clave **E0000000** marcada como de confianza absoluta
claves pública y secreta creadas y firmadas.
gpg: comprobando base de datos de confianza
gpg: 3 dudosa(s) necesaria(s), 1 completa(s) necesaria(s),
modelo de confianza PGP
gpg: nivel: 0 validez: 1 firmada: 0 confianza: 0-, 0q, 0n, 0m, 0f, 1u
pub 40000/E0000000 2015-11-19
Huella de clave = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
uid Nuestro_nombre (Comentario) nuestro_correo@gmail.com;

También nos informara que la clave como configuramos anteriormente solo sirve para firmar, para cifrar tendremos que crear una subclave:

Tenga en cuenta que esta clave no puede ser usada para cifrar. Puede usar la orden “–edit-key” para crear una subclave con este propósito.

Agregar una subclave para encriptación

~/.gnupg$ gpg --edit-key nuestro_correo@gmail.com

Ejecutamos:

gpg: addkey
  1. Introducimos nuestra contraseña de la clave anterior.
  2. Seleccionamos la opción 6 RSA solo para cifrar.
  3. Tamaño de 4096 bits.
  4. Introducimos la validez.
  5. De nuevo tendremos que generar bytes aleatorios con la actividad de nuestra maquina.

Guardamos y salimos: gpg: save

Para ver nuestra clave:

~/.gnupg$ gpg -k

Exportar e importar clave sin firmar

Exportar clave a archivo:

gpg --output TclavePublica.gpg --export E0000000

Exportar clave a http://pgp.mit.edu/

gpg --send-keys --keyserver pgp.mit.edu E0000000

Importar clave de archivo:

gpg --import clavePublica.gpg

Importar clave de http://pgp.mit.edu/

gpg --keyserver pgp.mit.edu --recv-keys A0000000F

Firma de claves PGP e importación

Después podemos firmar las claves de otras personas para ampliar nuestra zona de confianza, también ellos firmaran la nuestra. En primer lugar hacemos acto de notario y confirmamos la identidad de las personas con su clave y correo.

Una vez echo esto firmamos su clave subida al servidor:

~/.gnupg$ gpg --edit-key A0000000F

Firmamos con:

gpg: sign

Introducimos nuestra contraseña para firmar la clave ajena.

Guardamos y salimos:

gpg: save

Enviamos clave firmada al servidor pgp.mit.edu con:

gpg --keyserver pgp.mit.edu --send-keys A0000000F

Eliminar clave privada:

gpg --keyserver pgp.mit.edu --delete-secret-key E0000000

Eliminar clave publica:

gpg --keyserver pgp.mit.edu --delete-keys E0000000

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

3 Aug, 2016

Comments

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

Comments

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!