Listado de la etiqueta: Python

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!

Seguro que te interesa (GitHub behind the scenes – parte 1)

Esta entrada es un poco atípica, realmente no es más que una excusa para presentaros el nuevo repositorio en GitHub de esta web.

Poco a poco quiero ir ofreciendo los scripts que me hacen la vida más sencilla y que pueden ayudaros en ciertas tareas. Para estrenar el repo, he pensado en contar cómo hago la entrada de los Viernes en las que os listo las noticias que me han parecido más interesantes de la semana.

Tras unas cuantas entradas en las que iba recopilando enlaces a mano, decidí que así no podía continuar. Como dice un gran amigo, soy muy vago, pero vago de los buenos. Eso me hace pensar en cómo automatizar absolutamente todo lo que hago para que las tareas repetitivas las haga una CPU y yo pueda centrarme en ideas felices o a imaginar qué isla me compraré cuando me toque la lotería.

Gracias a lo de internet, tiro de Twitter para estar al tanto de las noticias de última hora y suelo hacer retweet de lo que me llama la atención. Noticias, herramientas, análisis, humor… pero todo relacionado con lo que me apasiona, la seguridad de la información.

Como últimamente le he cogido cariño a Python (al pitón como le llamo alegremente por la oficina de Dive), decidí tirar de un poco de crawling vía BeautifulSoup para buscar en twitter ciertos elementos.

Básicamente lo que hago es abrir la página de Twitter de SecurityInside y busco todos los retweets. De cada uno, me quedo con los elementos interesantes (título, autor, imágen y texto) y los pongo en forma de tabla para que se vea de forma decente como una entrada del blog. Básicamente esto:

# Get retweet info
# ---------------------------------------------------------------------------------------
req = requests.get(url)
statusCode = req.status_code

if statusCode == 200:

    html = BeautifulSoup(req.text, "html.parser")

    for timeline in html.find_all('div', {'data-test-selector':'ProfileTimeline'}):
        for oltag in timeline.find_all('ol', {'id':'stream-items-id'}):
            for litag in oltag.find_all('li'):
                for div in litag.find_all('div', {"class" : "tweet"}):
                    try:
                        if div['data-retweet-id']:

                            for small in litag.find_all('small', {"class" : "time"}):
                                for a in small.find_all('a', {"class" : "tweet-timestamp"}):
                                    try:
                                        date = a['title'].encode("ascii", "ignore")

                                    except Exception as e:
                                        None

                            title = div.find('p', {'class':'TweetTextSize'}).getText().split('http')[0].encode("ascii", "ignore")

                            link = div.find('a', {'class':'twitter-timeline-link'}).getText().encode("ascii", "ignore")

                            name = div.find('span', {'class':'username'}).getText().split('@')[1].encode("ascii", "ignore")
							
                            for img in div.find_all('img'):
                                if 'avatar' in img:
                                    image = 'http://securityinside.info/wp-content/uploads/logo.png'
                                else:
                                    image = img['src'].encode("ascii", "ignore")

                            print '<tr><td style="vertical-align:middle;border:0px;margin: 0px 0px"><img class="aligncenter" src="' + image + '" alt="' + name + '" width="150"/></td>\n<td style="vertical-align:middle;border:0px;margin: 0px 0px"><strong><a href="https://twitter.com/' + name + '" target="_blank">' + date + ' @' + name + ':<br></a></strong> <a href="' + link + '" target="_blank">' + title + '</a></td></tr>'

                    except Exception as e:
                        None

else:
    print "Status Code %d" %statusCode

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

 

Como podéis ver, sólo tengo que copiar la línea que me genera el script e insertarla en la entrada. La tarea se completa añadiendo el texto habitual y configurando las categorías, la imágen y los valores SEO.

Vale, me vais a decir que eso también se puede automatizar. La respuesta es que si, por eso os dejo pendiente la segunda parte del artículo en la que dedicaré otro rato a generar la entrada completa (insertando en base de datos y demás).

Pero poco a poco, que estoy un poco liado gestionando los backups anti malware de la junta directiva… pero eso es otra historia que os voy a contar en breve.

¿Os lo vais a perder?

de-charleta

De Charleta: “Python 4 Kids” (Antonio García Martínez)

En esta ocasión, vemos un proyecto muy interesante de un amigo de la lista de la Rooted CON, un ejemplo más de que aprender es cosa de niños.

Python4Kids (Python para niños) es un proyecto para que los niños de hoy «hablen fluidamente» Python, un lenguaje de programación elegante y fácil de aprender, facilitándoles el convertirse en los hackers del mañana.

Antonio García Martínez es un consultor de Seguridad de los que nos gustan, de esos que tienen siempre proyectos en la cabeza y que sueñan con emprender y perseguir sueños.

Charla TED en Sao Paulo, Brasil 2013

Español.

Twittor controlando los bots a través de Twitter

Twittor: Controla tus bots utilizando Twitter como servidor C&C

En este artículo vamos a ver una herramienta llamada Twittor que permite, de una forma especial y sencilla, el despliegue de una botnet utilizando Twitter como servidor C&C. Por una parte veremos una introducción a Twittor y finalizaremos con una demo del funcionamiento de la herramienta.

Leer más