Listado de la etiqueta: aws

security-api

Security API – Dale a tus empleados lo que necesitan (de forma segura)

Hace poco vimos en SecurityInside consejos a tener en cuenta para revisar la seguridad de tu API. Como comentamos, ofrecer servicios de información en el mundo de hoy si no tienes API, te da una desventaja considerable que podría terminar por arruinar tu negocio.

Es por eso que tu departamento de desarrollo debe tener en mente trabajar en una buena api (sencilla y segura) que de servicio tanto a clientes como a las plataformas y herramientas internas.

Hay muchas formas de desarrollar APIs, pero en mi caso me he decantado últimamente por Flask para Python sobre Elastic Beanstalk de Amazon Web Services.

Security API, ¿por qué?

Cada vez que arranco un proyecto de seguridad con una nueva empresa, me presento desde el punto de vista de vida laboral. Cuento mis años como becario, desarrollador, jefe de proyecto, consultor y luego el paso al mundo de la seguridad. Me miran como diciendo «¿para qué todo este rollo?». Sencillo, es la forma de introducir que soy un apasionado de la seguridad y que mi objetivo principal es asegurar los activos de la empresa, pero siempre tratando de hacer la vida sencilla a los compañeros que tienen que lidiar con todas las medidas y controles de seguridad que se implanten.

Conozco profesionales de la seguridad que nunca se han manchado las manos picando código y que aplican medidas maravillosas que fortifican los activos mientras complican el trabajo diario. Lo importante es la seguridad, pero mi perfil de desarrollador me hace pensar siempre en hacerlo de forma que ellos tengan todas las facilidades para trabajar. Seguros, pero trabajando.

Por todo esto, hace no mucho empecé a dar vueltas a la idea de crear una «security api» que diera servicio a determinadas necesidades de los compañeros de los diferentes departamentos. De esta forma, aplico medidas de seguridad generales y les doy la posibilidad de solicitar ciertos permisos, accesos, … de forma automática en base a roles.

¿Cómo funciona?

Básicamente todo funciona en base a usuarios que se autentican con login, password y 2fa (Google Authenticator, Android, iOS). Cada usuario tiene un rol y subrol con el que se indica qué cosas tienen permitidas y todo se gestiona mediante JSON Web Tokens.

Flask api template

Os he dejado en Github un nuevo repositorio que contiene el esqueleto de una api desarrollado en Python utilizando la biblioteca Flask.

Podéis lanzarlo en local para desarrollo y hacer pruebas de forma sencilla utilizando Postman, ya que os he dejado también un fichero con ejemplos de uso. Tendréis queja… 😀

Vamos viéndo cosillas

En el fichero principal (flask_api.py) veréis unas cuantas cosas que os voy a ir explicando.

Al principio, tenéis una función que se lanza tras arrancar el server, ahí se pueden configurar diferentes cosas (dar de alta la ip del server en determinados grupos de seguridad, enviar notificaciones, …):

##########################################################################################
# This function makes initial tasks.
##########################################################################################
@application.before_first_request
def _run_on_start():

    if not DEBUG:
        print "Flask started!"
        
        # Here you can do some initial tasks

##########################################################################################

Después se incluyen dos apartados para la gestión de códigos 404 y 405:

##########################################################################################
# This function returns happy 404.
##########################################################################################
@application.errorhandler(404)
def page_not_found(e):
    
    return redirect("https://goo.gl/LuKygx", code=302)

##########################################################################################

##########################################################################################
# This function returns happy 405.
##########################################################################################
@application.errorhandler(405)
def method_not_allowed(e):
    
    ret_html = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"/>'
    ret_html = ret_html + '<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es" lang="es">'
    ret_html = ret_html + '<head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" />'
    ret_html = ret_html + '<title>Flask API SecurityInside.info Template</title>'
    ret_html = ret_html + '<style type="text/css" media="screen">'
    ret_html = ret_html + 'h1 {text-align:left; color: #444;}'
    ret_html = ret_html + '</style></head><body>'
    ret_html = ret_html + '<h1>Flask API <a href="http://www.securityinside.info" target="blank">SecurityInside.info</a> Template</h1>'
    ret_html = ret_html + 'Method not allowed or missing params, check API doc to solve the problem.'
    ret_html = ret_html + '</body></html>'

    return flask_api_functions.ret_content_type(ret_html, 'html', 405) 

##########################################################################################

Una siempre interesante función ping para comprobar rápidamente si el server está vivo:

##########################################################################################
# This function shows API alive info. 
##########################################################################################
@application.route('/' + API_VERSION + '/ping', methods=['GET'])
def ping():
    
    response = {'code': 200, 'message': 'pong'}    
    return flask_api_functions.ret_content_type(response, 'json', 200)

##########################################################################################

La parte más interesante del ejemplo, la gestión del login y creación del token:

##########################################################################################
# This function checks auth user and return JWT.
##########################################################################################
@application.route('/' + API_VERSION + '/login', methods=['POST'])
def login():
    
    # Check preconditions
    ##################################################################################
    response = flask_api_functions.check_preconditions(request, False)
    
    if (response['code'] != 200):
        return flask_api_functions.ret_content_type(response, 'json', response['code'])
    ##################################################################################
    
    # Check for user credentials
    ##################################################################################
    response = flask_api_functions.check_auth(request)
    return flask_api_functions.ret_content_type(response, 'json', response['code'])
    ##################################################################################

##########################################################################################

Y la implementación concreta dentro del fichero flask_api_functions.py:

##########################################################################################
# This function checks user authorization header request.
#
# @param request - User request data.
#
# @return Formatted response.
# 
##########################################################################################
def check_auth(request):
    
    try:
        auth = base64.b64decode(request.headers['Authorization'].split()[1])
    
    except:
        response = {'code': 401, 'message': 'Invalid basic authorization header.'}
        return response

    if len(auth.split(':')) != 2:
        response = {'code': 401, 'message': 'Invalid basic authorization header.'}
        return response
    else:
        """
        Here you have to check user credentials and optional totp value.
        """

        # If user credentials is ok, then generate jwt
        if(True): 
            
            # User with valid credentials
            token = jwt.encode({
                'user_id': '<insert_here_user_id>',
                'user_name': '<insert_here_user_name>',
                'user_roles': '<insert_here_user_roles>',
                'other_fields': '<insert_here_other_fields>',
                'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=1)}, 
                SECRET)
                                
            response = {'code': 200, 'message': None, 'token': token}
            return response

        # If user credentials is not ok, then return error message
        else:
            response = {'code': 401, 'message': '(d\'oh!) Wrong user, password, totp value or maybe user is not active.'}
            return response

##########################################################################################

Para entender ciertas cosas como la forma de enviar el header «Authentication», pásate por el README.md del repositorio y ejecuta las pruebas con postman, verás que es la mar de sencillo.

El ejemplo es sólo parte del script completo. Si quieres utilizarlo o modificarlo, puedes descargarlo desde nuestro repositorio en GitHub.

 

Importante antes de terminar

Flask no está preparado para funcionar directamente en un entorno de producción, para hacerlo tienes que tener en cuenta un par de cosas (está todo en la documentación del repositorio).

En mi caso particular, ya os he dicho que lo tengo montado en Elastic Beanstalk de Amazon Web Services, si queréis os puedo contar cómo lo he hecho en otra entrada.

Por supuesto, si tenéis alguna duda sobre esta entrada, preguntad que estaré encantado de echar una mano.

Saludos!

sftp

sFTP en AWS EC2 en 5 minutos

En algún momento te puedes encontrar con la necesidad de levantar un sFTP para que alguien te envíe ficheros. Yo lo he necesitado hace poco y lo he solucionado rápidamente con una instancia de AWS EC2. Te dejo paso a paso lo que tienes que hacer por si lo necesitas.

Leer más

aws-summit-madrid-16

SecurityInside en el AWS Summit de Madrid 2016

Tras la visita el año pasado al AWS Summit de Barcelona, en esta ocasión nos pillaba mucho más cerca. El AWS Summit de Madrid se celebró el pasado Jueves en cines Kinépolis con una gran participación de público y de empresas patrocinadoras.

Puesto que trabajo en un entorno compuesto principalmente por servicios cloud de Amazon WS, la visita a este tipo de eventos es totalmente recomendada. Ya sabéis que la filosofía de SecurityInside es no dejar nunca de aprender.

El evento

Tal y como os comenté en la entrada de la Rooted CON, el sitio es un acierto total. Parece que los grandes eventos se están poniendo de acuerdo en utilizar las instalaciones de Kinépolis y, para el asistente, es una gran noticia. No hay problema de aparcamiento, gran oferta de restaurantes, cafeterías, espacio para apagar fuegos en remoto… todo genial.

Para el que no lo tenga claro, el AWS Summit es un evento en el que los responsables de diferentes servicios de Amazon nos explican las novedades y casos prácticos para que podamos utilizarlos en nuestro día a día. Además, lo complementan con ejemplos reales de empresas que han tenido éxito utilizando los diferentes servicios que se ofrecen y que siguen creciendo año a año.

aws-summit-2

Las sesiones

Puesto que el pasado Summit fue hace relativamente poco tiempo, en esta ocasión no hubo demasiadas novedadas, pero sí ejemplos de uso que te hacen pensar y que posiblemente acaben en nuestros sistemas a corto plazo. Lo bueno de este tipo de eventos es que te dan ideas y soluciones en las que no habías caído.

En mi caso particular, la sesión más interesante fue la relativa a la gestión de seguridad. Un repaso completo a la forma en la que tener todo bajo control desde el minuto cero que se nos contó en primera persona por Bill Murray, Director of AWS Security Programs y por los diferentes partners del evento:

aws-summit-madrid-sponsors

Seguridad en Amazon WS

La infraestructura en la nube de Amazon WS está diseñada para ser uno de los entornos de informática en la nube más flexibles y seguros de los disponibles en la actualidad. Ofrece una plataforma extremadamente escalable y de alta fiabilidad para que los clientes puedan implementar aplicaciones y datos de forma rápida y segura.

Los centros de datos de AWS disponen de la máxima seguridad 24/7. Los sistemas ambientales de los centros están diseñados para minimizar el impacto de las interrupciones en las operaciones. La existencia de varias regiones geográficas disponibles hace que la información sobreviva a la mayoría de las averías, incluidas catástrofes naturales.

AWS establece exhaustivos sistemas de supervisión de seguridad y red, protegiendo frente a ataques DDoS y detección de ataques de fuerza bruta contra sistemas de contraseñas en las cuentas de AWS, poniendo a prueba la infraestructura constantemente, desde todos los ángulos posibles y desde diferentes regiones.

Además del amplio equipo de expertos, AWS cuenta con una gran variedad de herramientas y sistemas que automatizan muchas de las tareas de seguridad, desde la gestión de credenciales hasta la supervisión del uso del servidor y red. Los programas de análisis automatizados, por ejemplo, han reducido el tiempo de una evaluación de ingeniería de seguridad de horas a minutos e incrementando la velocidad de análisis de docenas de hosts al día a miles de hosts en el mismo tiempo.

La infraestructura de AWS es mejorada constantemente, sustituyendo el hardware que llega al final de su vida con procesadores más recientes, mejorando así el rendimiento e incorporando tecnologías de seguridad, buscando reducir al máximo las fricciones entre los procesos de seguridad y los servicios.

AWS construye sus centros en múltiples regiones geográficas y numerosas zonas de disponibilidad dentro de cada región. Esto es, las zonas de disponibilidad están físicamente aisladas en una región y ubicadas en zonas de menor riesgo. En caso de improbable fallo, los procesos automatizados pueden desviar el tráfico de datos del cliente de la zona afectada (si hacemos uso de la configuración multi AZ), equilibrando la carga de tráfico entre los demás sitios.

Para clientes obligados a cumplir con determinadas leyes o normas de seguridad, AWS proporciona informes de certificación que describen cómo su infraestructura en la nube cumple con los controles exigidos por estas normas. Cada certificación que AWS obtiene significa que un auditor ha verificado que están instaurados los controles específicos y que funcionan según lo previsto.

Para ayudar al mantenimiento de seguridad de datos y sistemas en la nube, AWS dispone de una amplia variedad de funcionalidades y servicios:

  • Seguridad de red: Provee de diferentes opciones de seguridad a nivel de red para mantener los recursos y comunicaciones con la privacidad deseada.
  • Control de acceso: Solo permite acceso a usuarios, clientes y aplicaciones autorizadas a los recursos AWS, estableciendo políticas de control de acceso, cuentas individuales de usuarios y credenciales únicas.
  • Monitorización y seguimiento: AWS ofrece herramientas para hacer seguimiento y monitorizar los recursos en la nube. Con ellas, hay inmediata visibilidad del inventario, así como sobre usuarios y actividades sobre la aplicación.
  • Copias de seguridad: Una estrategia de seguridad debe incluir backups o snapshots de los datos con regularidad. Por eso, AWS realiza backups automáticos y, en otros casos, es posible configurar snapshots usando las diferentes opciones de configuración.
  • Cifrado: AWS utiliza sistemas de cifrado siempre que sea posible y recomienda su uso. Permite el almacenamiento de datos cifrados, centralización de gestión de claves y almacenamiento en hardware cifrado dedicado.
  • Región aislada: Para clientes con necesidades adicionales por cumplimiento de regulación especial, AWS ofrece regiones aisladas llamadas GovCloud (US) con estrictos y únicos requerimientos de seguridad que permiten un entorno en el que lanzar aplicaciones ITAR.

Ya sabemos que nada es 100% seguro, pero Amazon WS hace un gran esfuerzo por mantener unos servicios con el máximo nivel de fortificación para que nuestra actividad pueda resistir los múltiples vectores de ataque a los que estamos expuestos.

Y tu, ¿utilizas Amazon WS? Recuerda que tienes un gran abanico de recursos gratuitos para empezar a familiarizarte con este ecosistema.

 

De momento, eso es todo. Como siempre digo, si ves algún error, no estás de acuerdo con lo que cuento o quieres hacer alguna aportación, no dudes en pasarte por los comentarios.

security-monkey-netflix

Security Monkey: Controla la seguridad de AWS con Netflix (parte 1)

Supongo que todos conocéis Netflix a estas alturas, el servicio VOD con suscripción mensual que aterrizó en España hace unos meses y ya es todo un éxito.

Pero, además de ser una forma estupenda de ver películas y series, puede ofrecernos mucho que aprender gracias a lo que algunos (yo no :D) llaman pornografía tecnológica.

Netflix es una de esas empresas que se rodea de los mejores ingenieros para poder ofrecer un servicio con calidad por encima de lo normal. En ese sentido, leer de forma regular «The Netflix Tech Blog» es altamente recomendable.

 

Aprendiendo de los mejores

Que profesionales tan altamente cualificados como los que trabajan en Neflix dediquen una parte de su tiempo a contarnos cómo hacen las cosas, es algo de agradecer. Vivimos en un mundo en el que estamos obligados a aprender de forma contínua y este tipo de lecturas nos abren la mente a nuevas formas de hacer las cosas.

Puedes encontrar temas tan interesantes como:

Y sobre todo, en general de elementos de Amazon WS (unos servicios con los que suelo trabajar tal y como os conté en Controla lo que hacen tus usuarios con Amazon WS IAM (parte 1) y Controla lo que hacen tus usuarios con Amazon WS IAM (parte 2)).

aws-summit-1

 

Security Monkey

Revisando esto, me he encontrado con una solución desarrollada por el equipo Netflix que tiene por objetivo monitorizar y analizar la seguridad de los servicios de AWS.

Se trata de un desarrollo propio que ofrecen como open source y que nos permite monitorizar la configuración de los servicios EC2, RDS, S3 e IAM. Cualquier cambio que se realice sobre ellos quedará registrado para que tengamos el control de todo lo que sucede.

Está pensada para correr sobre una máquina Linux y almacenar la información en una PostgreSQL. A nivel tecnológico está escrita en Python utilizando el framework Flask, utilizando datos JSON servidos mediante una API REST.

Casos de uso típicos serían:

  • Visualización de cambios históricos de un elemento (como los cambios en grupos de seguridad).
  • Auditorías de configuraciones incorrectas (como permisos en buckets S3).

Para conseguir esto, Security Monkey cuenta con tres componentes principales:

  • Watcher, es el encargado de observar nuestra cuenta para detectar cambios. Cuando eso ocurre, se almacena esa información en la base de datos interna.
  • Notifier, es el encargado de avisarnos cuando se produce un evento que podemos personalizar.
  • Auditor, es el encargado de realizar pruebas y revisiones sobre los elementos, reglas y políticas. Podemos definir aquello que no queremos que ocurra para que salte una alarma si se encuentra (como grupos de seguridad con puertos abiertos al mundo).

Una vez lo tengamos funcionando podremos acceder mediante su interfaz web, configurar los elementos que queremos monitorizar y ver todo en detalle.

 

¿Te ha gustado tanto como a mi? Entonces descarga el proyecto desde su repositorio y coméntanos qué tal tu experiencia. Yo lo haré en un post en el que os mostraré el proceso de instalación, configuración y uso. De momento, esto es todo, espero que os esté resultando interesante.

Como siempre digo, si ves algún error, no estás de acuerdo con lo que cuento o quieres hacer alguna aportación, no dudes en pasarte por los comentarios.

Controla lo que hacen tus usuarios con Amazon WS IAM (parte 2)

En la primera parte de esta serie de post relativos a la gestión de usuarios (IAM) en Amazon WS, estuvimos conversando sobre la forma en la que conceder permisos de forma ordenada y sencilla, así como algunos consejos para tener el control de todo lo que ocurre. Si no lo recuerdas, no dudes en echarle un vistazo antes de seguir.

Algo realmente importante en este panel IAM es el control sobre la cuenta root. No se aconseja utilizar dicha cuenta y Amazon nos anima en el panel de control a activar autenticación multifactor (MFA).

aws-iam-2-1

Panel de control de Amazon WS IAM

 

Como se puede ver en este ejemplo, uno de los checks importantes de seguridad es activar ese MFA. El motivo es sencillo, añadir una capa extra de seguridad al acceso con el usuario que tiene capacidad para hacer cualquier cosa, incluso eliminar la propia cuenta.

De esta forma, para entrar como root, se necesitará la contraseña (algo que el usuario sabe) y otro elemento que ahora veremos (algo que el usuario tiene). En mi caso, ese elemento es un código temporal que puede ser gestionado de diferentes formas:

aws-iam-2-2

Opciones MFA en Amazon WS

 

Básicamente, podemos optar por soluciones software o hardware. En mi caso particular, estoy utilizando la primera mediante apps para móviles. ¿El motivo? Hoy en día todo el mundo tiene smartphone, todos lo llevan siempre a mano y casi todos (en esto parece que la concienciación ha servido) tienen un patrón de bloqueo. Esto hace que «lo que el usuario tiene» esté mejor controlado que un dispositivo o tarjeta que sólo usa para acceso puntual.

De esta forma, si alguien pierde el teléfono puede avisar de inmediato para que su usuario sea puesto en cuarentena hasta que se renueven tanto la contraseña como el sistema mfa.

Las opciones de apps son estas:

aws-iam-2-3

Apps MFA para móviles

 

Por utilizar siempre la misma, recomiendo Google Authenticator para Android o iOS. Sólo tenemos que acceder a la pestaña «Security Credentials» del usuario y pulsar sobre la opción «Manage MFA Device».

aws-iam-2-4

 

Al seleccionarlo, se inicia el proceso. En nuestro caso, seleccionamos dispositivo virtual (app para móvil):

aws-iam-2-5

 

Únicamente tendríamos que arrancar la aplicación y escanear el qr que aparece en pantalla. Tras hacerlo, se nos piden dos códigos consecutivos para comprobar que todo funciona correctamente y listo.

aws-iam-2-6

 

La próxima vez que entremos en el panel de control de Amazon WS con este usuario, se nos pedirá un código que podremos consultar en nuestra app.

aws-iam-2-7

 

De esta forma, los pasos recomendables para la gestión de usuarios en Amazon WS IAM se podrían resumir en:

  1. Desde la cuenta root, crear un usuario para administración.
  2. Activar MFA en root y admin.
  3. Desde admin, gestionar usuarios, grupos y políticas.

Por supuesto, recuerda que el MFA también puede ser activado para el resto de usuarios. Al principio se mostrarán reticentes a utilizarlo, pero ya sabes que concienciar y hacer entender que ciertas medidas son necesarias para tratar de asegurar los activos de la empresa es parte fundamental de nuestro trabajo.

 

De momento, esto es todo, espero que os esté resultando interesante. Como siempre digo, si ves algún error, no estás de acuerdo con lo que cuento o quieres hacer alguna aportación, no dudes en pasarte por los comentarios.