Cuando la Seguridad Informática es una Inversión

Hace algunos años era imposible pensar que la seguridad informática era ni remotamente imprescindible en las organizaciones, pero esto ha cambiado radicalmente en los últimos cinco años.

Esto debido principalmente al auge de las aplicaciones móviles, debido al boom de los teléfonos inteligentes los llamados smartphones, si a esto le sumamos los smart TV, las tabletas, relojes inteligentes pues sin lugar a dudas las organizaciones tienen que blindarse de una gran cantidad de equipos, herramientas (software) y hardware de seguridad informática.

Uno de los estudios más respetables realizados por la firma Gartner revela que con el internet de las cosas un total de 6.4 billones de dispositivos estarán conectados a internet.

http://www.gartner.com/newsroom/id/3165317

No nos imaginamos la cantidad de recursos que hay que poner en marcha para mantener a raya la seguridad informática, un tema que cada dia nos tomamos más en serio y que ya dejó de ser un gasto netamente de capricho de las empresas.

Gartner

Figura 1. IOT (Internet of Things)

Todo lo que nos viene es una gran avalancha de que tendremos que contener de la mejor manera, se dice que por cada vez que de da de alta un dispositivo con acceso a internet se nos duplica el esfuerzo para securizar cada elemento de seguridad.

Un estudio revela también que las empresa invierten en promedio unos 50.000 € cifra que en mi opinión puede ser discreta dependiendo del core business de la empresa.

Este interesante articulo de Forbes nos da una perspectiva bastante real de lo que estamos comentando.

http://www.forbes.com/sites/tonybradley/2016/03/23/6-tips-to-help-you-avoid-a-near-miss-in-security/#4291eab438c3

Esto nos lleva a lo que se llama ROSI que significa la el retorno de la inversión de la seguridad informática.

Esto me trae un buen recuerdo de un artículo que pude leer en el país y que resume bastante bien el tema de la inversion en la seguridad informática.

Con la famosa coletilla «A mi no me va a pasar» pero cuando te pasa la cantidad de dinero que se pierden por no tener por ejemplo un sitio web bancario en linea cada segundo que pasa fuera de servicio son bits que se convierten a la final en miles de euros.

El pais

http://www.elpais.com.uy/economia-y-mercado/desafio-invertir-seguridad-informatica-anadir.html

Entonces podemos decir con propiedad que la seguridad informática ya no es un juego es algo que cada dia se toma más en serio para poder brindar un servicio de calidad sin riesgos a que nuestras organizaciones sean vulnerables.

Hasta la próxima……

 

de-charleta

De Charleta: “License to Kill: Malware Hunting with the Sysinternals Tools” (Mark Russinovich)

En esta ocasión, veremos ejemplos de uso de varias herramientas de Sysinternals, tales como Process Monitor, Process Explorer y Autoruns. El objetivo es ver la utilidad de las mismas en el análisis y borrado de malware, algo que está en alza en el mundo de la seguridad.

Nos lo cuenta, nada más y nada menos, que el gran Mark Russinovich (CTO de Microsoft Azure).

Mark Russinovich es un emprendedor, tecnólogo y escritor de éxito. Comenzó fundando Winternals Software y Sysinternals.com y ahora es
Chief technology officer en la división Azure de Microsoft.

TechEd NorthAmerica 2013.

Inglés.

seguro-interesa

¡Seguro que te interesa! – 24

En esta sección os dejamos las noticias que nos han llamado la atención y que consideramos te pueden ser de ayuda. Es por eso que es… ¡seguro que te interesan!

[21/03/16] Ingenieros de Palo Alto descubren una nueva familia de malware para iOS (AceDeceiver) que infecta dispositivos Apple sin jailbreak explotando fallos en el diseño del mecanismo de protección DRM (Digital Rights Management).

[21/03/16] Según estudios de la Universidad Pontificia Comillas ICAI-ICADE, España es uno de los países que más ciberataques sufre.

[22/03/16] Google aumenta su política de recompensa para la intrusión en ordenadores Chromebook (no te pierdas las bases).

[23/03/16] Si te gustan los retos, no te pierdas el Hacky Easter 2016 de los amigos de Hacking-Lab.com.

Saludos!

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

En proyectos pasados y actuales he tenido que lidiar con los servicios cloud de Amazon, los conocidos como Amazon Web Services. Para los que no los conozcan, son un conjunto de servicios de computación, almacenamiento, base de datos, redes, análisis… que permiten montar infraestructuras complejas, eficientes y escalablas a precios muy competitivos (se paga por uso).

En un principio me tocó montar la red, servidores, servicios y bases de datos. Ahora ando desde otro punto de vista, el de tratar de asegurar la infraestructura para que la continuidad de negocio de mi trabajo actual no se vea comprometida. La puerta de entrada son los usuarios y de eso vamos a hablar hoy.

 

Entendiendo Amazon WS IAM

Para gestionar el acceso a los recursos, AWS cuenta con un servicio llamada IAM (Identity & Access Management) que permite gestionar el acceso a los recursos en base a diferentes identidades:

Usuarios: es una entidad individual, una persona que utiliza recursos. Cuando creamos un usuario, le podemos dar acceso a la consola de administración o a la api para que pueda interactuar con aquello que deseemos de AWS mediante políticas de uso.

Grupos: se utilizan para agrupar usuarios que tienen características similares y, por tanto, permisos similares. Normalmente se usan para crear departamentos en los que todos los usuarios tienen que tener acceso a los mismo recursos. Editar, añadir o eliminar una política al grupo, afecta inmediatamente a todos los usuarios del mismo.

Roles: son parecidos a los usuarios, pero de forma inpersonal. Son permisos que se conceden para llevar a cabo determinadas tareas puntuales. Se suelen usar para asignar a máquinas o procesos que se lanzan de forma automática o incluso aquellas que se lanzan de forma manual sin importar el usuario que lo hace (no es el usuario el que tiene los premisos, es el popio proceso).

 

¿Cómo indico qué se puede o no hacer?

Para eso están las policies, que son reglas que se aplican para cada servicio y que pueden contener todo tipo de detalle para hacerlas completamente a medida. Una policy tiene un aspecto similar a esto:

{
   "Version": "2012-10-17",
   "Statement": [{
      "Effect": "Allow",
      "Action": "ec2:Describe*",
      "Resource": "*"
    }
   ]
}

Tener cierto control y destreza a la hora de escribir estas policies es complicado, por eso Amazon nos pone a mano dos recursos interesantes:

  • AWS Policy Generator: una web en la que podemos ver todas las opciones que hay para cada servicio e incluso generar el fichero para hacer copy-paste.
aws-policy-generator

Web para generar policies de AWS.

 

  • Herramienta interna de simulación: desde la consola de administración de IAM podemos hacer una simulación de la policy que realizará una prueba sobre los recursos y acciones que definamos.
aws-simulate-policy1

Enlace para simular policy concreta

 

aws-simulate-policy2

Pantalla del simulador de policies

 

Asignación de policies

A la hora de aplicarlas sobre un usuario o grupo, podemos optar por hacerlo de dos formas:

  • Managed: podemos verlo como un policies que tenemos almacenadas y que asignamos con intención de que sea algo permanente (aunque, por supuesto, podemos revocar en cualquier momento).
  • Inline: es algo así como permisos temporales que se asignan con la intención de que sea algo puntual, ya sea por la persona o grupo que lo recibe o por el tipo de permiso que se concede.

 

¿Vemos un ejemplo?

Con todo esto, una posible situación sería asignar grupos por departamento y entorno de desarrollo, asignando las policies necesarias para cada zona concreta. Por ejemplo:

  • Departamento1-DEV: policies para usuarios del departamento1 con acceso a recursos de desarrollo.
  • Departamento1-PRE: policies para usuarios del departamento1 con acceso a recursos de preproducción.
  • Departamento1-PRO: policies para usuarios del departamento1 con acceso a recursos de producción.

Puesto que un usuario puede pertenecer a varios grupos, no habría problema en asignar a «Usuario1» a los grupos «DEV» y «PRE» del «Departamento1».

 

Control casero

Cuando todo esto empieza a crecer, utilizo un pequeño script que me lista todos los usuarios, así como las políticas que tiene asignadas como grupo o individualmente. Me sirve para exportar rápidamente esa información y poder ver en papel la foto actual de los permisos. Si utilizas la consola, tienes que entrar uno a uno y es un poco coñazo.

Lo único que hago es tirar consultas sobre la API para mostrar, de forma ordenada, la información que necesito.

##########################################################################################
#
# File: iam-list-users-policies.py
# Author: Cristobal Espinosa
# 
# https://boto3.readthedocs.org/en/latest/reference/services/index.html
#
##########################################################################################

# Imports ################################################################################
import boto3
from colorama import init, Fore, Style
##########################################################################################

# Initial values #########################################################################
init(autoreset=True)

step = False # Set as True to step by step view
##########################################################################################

print 
print Fore.GREEN + '-- IAM POLICIES CONTROL'
print Fore.GREEN + '----------------------------------------------------------------------------------'
print 

client = boto3.client('iam')

user_list = client.list_users()

# List users
for user in user_list['Users']:
    print Fore.YELLOW + '[**] ' + Fore.WHITE + user['UserName'] + ':'
    
    # List user inline policies
    print Fore.YELLOW + '\t[*] ' + Fore.WHITE + 'User inline policies:'
    user_policies = client.list_user_policies(UserName = user['UserName'])
        
    for policy in user_policies['PolicyNames']: 
        print '\t\t- ' + policy
    
    print    
    
    # List user managed policies
    print Fore.YELLOW + '\t[*] ' + Fore.WHITE + 'User managed policies:'
    user_policies = client.list_attached_user_policies(UserName = user['UserName'])
        
    for policy in user_policies['AttachedPolicies']: 
        print '\t\t- ' + policy['PolicyName']
    
    print

    # Get user groups    
    user_groups = client.list_groups_for_user(UserName = user['UserName'])

    print Fore.YELLOW + '\t[*] ' + Fore.WHITE + 'User groups and associated policies:'
    for group in user_groups['Groups']:
        
        group_policies = client.list_attached_group_policies(GroupName = group['GroupName'])
                        
        for group_policy in group_policies['AttachedPolicies']:
            print '\t\t- [' + group['GroupName'] + '] -> ' + group_policy['PolicyName']
    
        print

    print Fore.GREEN + '----------------------------------------------------------------------------------'
    print  
    
    if step: 
        raw_input("Press Enter to continue...")  
        print

Me gustaría trabajar en ampliar este script para que sea capaz de avisarme de cambios tanto en policies como en el contenido de las mismas, de forma que si un usuario «obtiene cambios fuera de control», pueda enterarme lo antes posible.

El resultado de este código es algo así:

aws-policy-script

Resultados del primer usuario

Lo que podéis ver aquí es el modo paso a paso (step = True) con los resultados del primer usuario (el nombre es lo que hay borrado junto a [**]). Se ve rápidamente que no tiene policies de tipo inline o managed y que, todo lo que tiene, le llega por pertenecer a dos grupos del mismo departamento y diferente entorno (DEV y PRE). Las policies asociadas a cada grupo aparecen a la derecha del mismo.

Como véis, un script muy sencillo, pero que me permite exportar rápidamente la información que necesito para verificar si algún usuario tiene permisos que no debe o pertenece a algún grupo equivocado.

 

De momento, esto es todo, en la continuación de esta entrada hablaremos del usuario root y de la autenticación con segundo factor. Espero que os esté resultando interesante y, 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.

de-charleta

De Charleta: “Taller sobre Ciberacoso” (Emilio Calatayud)

En esta ocasión, dejamos un poco de lado lo técnico aprovechando las vacaciones y os recomendamos esta charla taller en la que Emilio Calatayud (Juez de menores de Granada) trata de enfocar la seguridad empezando por la educación de los más pequeños.

Para los que tenemos príncipes o princesas alrededor y nos preocupamos por su seguridad actual y futura, las palabras de Emilio Calatayud son una ayuda para hacer las cosas bien. Como siempre decimos, la seguridad empieza por la formación, educación y cultura.

Emilio Calatayud es un abogado, escritor y magistrado español, juez de menores de Granada, muy conocido por sus sentencias rehabilitatorias y ejemplares.

Cybercamp 2014.

Español.