de-charleta

De Charleta: “De casa se viene llorado” (David Meléndez)

En esta ocasión os traigo una charla de la última edición de la RootedCON en la que David Meléndez trata con enfado y humor la situación actual del empleo en nuestro sector. Una charla interesante que todo profesional de HR debería ver, sobre todo para escuchar mi dulce voz en la ronda de preguntas :D, ¡no te la pierdas!

David Meléndez se define a sí mismo como constructor de robots y experto en tortillas. Nos tiene habituados a estupendas charlas sobre drones y otras especialidades entre las que incluye programación, sistemas embebidos, seguridad, … Todo un crack en su campo al que da gusto escuchar.

RootedCON 2017.

Español.

seguro-interesa

¡Seguro que te interesa! – 49

En esta sección os dejamos las noticias que nos han llamado la atención y que consideramos te pueden ser de ayuda.
Leer más

phishing

Phishing: cómo identificarlo

De acuerdo al Código Penal español, un fraude (o estafa) es aquel en el que se usa el engaño para producir un error en otro y conseguir lucrarse con ello. Pero lo que es realmente nuevo y nos interesa si somos de los que usamos el ordenador para cualquier cosa, es el delito considerado como “fraude informático”, especificado en el artículo 248.2 del Código Penal.

En él, se explican las estafas de índole informática:

  1. Los que se valgan de alguna manipulación informática o artificio semejante, consiguiendo transferencias no consentidas de cualquier activo patrimonial.
  2. Los que posean programas informáticos destinados específicamente a la estafa.
  3. Aquellos que usen tarjetas o cheques de viaje o cualquier dato de cualquiera de ellos, realizando operaciones que produzcan un perjuicio en sus dueños.

De esta forma vemos cómo la estafa se ha modernizado y ha avanzado tanto que puede llegar a ser imperceptible para las personas que la sufren. Algunas, de hecho, podrían tardar en darse cuenta de que han sido víctimas de un fraude.

En este artículo hablaremos del phishing

Según Wikipedia, Phishing o suplantación de identidad es un término informático que denomina un modelo de abuso informático y que se comete mediante el uso de algún tipo de ingeniería social, caracterizado por intentar adquirir información confidencial de forma fraudulenta (como puede ser una contraseña, información detallada sobre tarjetas de crédito u otra información bancaria). El cibercriminal, conocido como phisher, se hace pasar por una persona o empresa de confianza en una aparente comunicación oficial electrónica, por lo común un correo electrónico, o algún sistema de mensajería instantánea o incluso utilizando también llamadas telefónicas

El caso más normal ocurre cuando un usuario recibe un email de su banco instándole a dirigirse a una web externa. Dicha web es maliciosa y sirve para recabar los datos del cliente y obtener su contraseña de acceso.

¿Cómo puedo saber que se trata de phising?

Éste tipo de estafas no abarcan sólo el fraude bancario. Pueden vestirse de muchas formas: emails de redes sociales (Facebook, Twitter…), tiendas de productos (cosméticos, ropa, gafas de sol…), encuestas para páginas webs externas. En definitiva,  éstos son los rasgos que suelen tener en común las estafas de pishing informático:

  • Faltas de ortografía o de formato: a menudo estas estafas vienen traducidas de otros idiomas o se han hecho sin considerar el aspecto gramatical. Si ves que aparecen palabras mal escritas y la redacción es pobre y con tiempos verbales extraños, ándate con ojo.
  • Enlaces externos: tal vez la parte más importante de toda estafa de pishing informático. Te intentarán dirigir a otras páginas webs que, aunque tengan la apariencia de ser originales y auténticas, no lo serán.
  • Datos personales: algunas podrán ser peligrosas sólo con el hecho de que entres en ellas, pero la mayoría pretenderán acceder a tus datos bancarios o cuentas personales. En algún momento, te pedirán que introduzcas tus datos de acceso para alguna de tus páginas webs de uso frecuente.
  • Estafador lejano: ocurre cuando el delincuente se hace pasar por alguien que generalmente vive lejos, en algún país diferente al tuyo. Podrás detectarle fácilmente si ya desde el principio el remitente es desconocido.

¿Cómo detecto, interrumpo o denuncio el fraude?

En la entrada en la que hablábamos de delitos informáticos te dimos diferentes opciones para denunciar este tipo de ataques, no dudes en echarle un vistazo si te encuentras en esa situación. Siempre podrás presentarte en cualquier comisaría y te indicarán qué acciones debes tomar, pero mi consejos es:

  • Corta toda comunicación: sea cual sea el tipo de fraude, lo primero que tienes que hacer es cortarlo de raíz.
  • Avisa a tu banco: si es una estafa de tipo bancario y están usando información de una entidad real, lo mejor que puedes hacer es avisarles. A ellos les ayudará en caso de que ocurran más problemas con fraude informático, y a ti te permitirá proteger tu información por si alguien intenta hacerse con ella.
  • Cambia tus datos de acceso: si te has dado cuenta tarde o simplemente quieres estar más seguro, intenta cambiar los datos de acceso que creas que estén en peligro.
  • Algunos servidores de correo electrónico te permiten marcar el correo como posible fraude. Al menos así se evitará que la estafa se extienda.
  • Hazte con una buena aplicación anti-virus y anti-malware que trate de advertirte en caso de que a ti se te pase algún detalle sospechoso.

Recuerda que no sólo es importante el saber cómo actuar tras una estafa, sino también el saber identificarla antes de que ocurra. ¡Toda precaución es poca!

seguro-interesa

¡Seguro que te interesa! – 48

En esta sección os dejamos las noticias que nos han llamado la atención y que consideramos te pueden ser de ayuda.
Leer más

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!