martes, 10 de abril de 2012

Table Splitting y Entity Splitting en Entity Framework

Hay 2 conceptos de modelado en Entity Framework que podrían resultarnos útil en determinados escenarios. Estoy hablando de Table Splitting y Entity Splitting.

Table Splitting

Table Splitting hace mención al hecho de mapear una tabla a dos o más entidades de nuestro modelo, entre las cuales habrá una relación 1:1.

Los motivos que pueden empujarnos a llevar a cabo esta práctica podrían ser:

  • Dividir una entidad de nuestro modelo que tiene muchas propiedades, en varias entidades con menos campos y más manejables. Es decir, organizar mejor nuestro modelo.
  • Hacer lazy loading a determinados campos. Imagina que un campo es del tipo ntext y tiene “chorrocientos” caracteres que sólo consultaras en ocasiones muy puntuales. Sería una pena forzar, tanto la consulta SQL contra la base de datos como la carga del mismo dato en una entidad en memoria, cada vez que leyeras una entidad.

Un ejemplo sería una tabla como la siguiente:

clip_image001

Que finalmente se mapeará en nuestro modelo con las siguientes entidades:

clip_image002

Si te fijas, lo que hemos hecho ha sido:

  • Crear una entidad Producto mapeada contra la tabla Productos, con sólo la propiedad Descripcion (además de la propiedad IdProducto que es la clave de la tabla).
  • Crear una entidad Propiedad mapeada también contra la tabla Productos, con las propiedades del 1 al 6 (justo las que no están mapeadas en la entidad Producto y además también la propiedad IdProducto).
  • Crear una  asociación 1:1 entre ambas entidades.

A partir de aquí, para el tratamiento de esta entidad sólo debemos tener en cuenta algunos puntos de interés:

Insertar una entidad

Al insertar una entidad deberemos insertar en un solo paso (una llamada a SaveChanges) todas las entidades que hayamos creado como producto del Table Splitting. Es decir, algo como lo siguiente no funcionaría porque sólo estamos haciendo el insert de una entidad y no de sus entidades relacionadas  (incluso cuando todas las propiedades de las entidades relacionadas 1:1 en nuestro Table Splitting, admitan valores nulos):

Dim p As New Producto With {.IdProducto = 1, .Descripcion = "Xbox 360"}

ctx.Productos.AddObject(p)

 

ctx.SaveChanges()

 

clip_image003

Lo correcto sería:

Dim p As New Producto With {.IdProducto = 1, .Descripcion = "Xbox 360"}

ctx.Productos.AddObject(p)

 

Dim prop As New Propiedad

p.Propiedades = prop

 

ctx.SaveChanges()

 

Resumiendo, un INSERT tiene que  disponer de todos los campos de la tabla para llevar a cabo la operación.

Eliminar una entidad

Al igual que ocurre al insertar la entidad, deberá eliminarse toda la entidad como un bloque.

Entity Splitting

Esta técnica es justamente contraria a Table Splitting.

Con Entity Splitting lo que hacemos es mapear dos o más tablas de nuestra base de datos en una sola entidad en nuestro modelo.

El principal motivo para hacer Entity Splitting es, normalmente, aunar en una entidad del modelo varias tablas que conceptualmente son el mismo registro.

Por ejemplo, partiendo de las siguientes tablas de base de datos:

clip_image004

Llegaremos al siguiente modelo de EF:

clip_image005

clip_image006

Ahora un código como el siguiente grabará en ambas tablas de nuestra base de datos:

Dim p As New Productos

p.IdProducto = 1

p.Descripcion = "Xbox"

p.Propiedad1 = "360"

ctx.Productos.AddObject(p)

 

ctx.SaveChanges()

 

Espero haber dejado claro estos conceptos y que te sirvan de ayuda.

Un saludo.

Microsoft Reporting Viewer y despliegue privado

Llevamos algún tiempo utilizando Microsoft Reporting Viewer y en entornos de hosting compartido donde no se tiene acceso al servidor, resulta imposible distribuir y ejecutar el run-time que recomienda Microsoft. Microsoft Report Viewer 2010 Redistributable Package

De este modo y a prueba “ensayo-error”, veremos cuales son los pasos necesarios para realizar una distribución privada de los ensamblados que necesita Microsoft Reporting Viewer para funcionar. Es decir, vamos a llevar a cabo un private deployment.

Nuestro entono de pruebas es un servidor Windows 2008 R2 y el despliegue privado ha sido probado tanto para un sitio web como para un proyecto de aplicación web.

Si subimos una aplicación sencilla con un solo formulario y un control ReportViewer y un fichero .rdlc (el informe en sí mismo), el primer error será el siguiente:

clip_image002

Este error nos informa de que no encuentra el ensamblado Microsoft.ReportViewer.Webforms. En realidad, cuando agregamos el control ReportViewer también se agregaron automáticamente las siguientes referencias a ensamblados de nuestro GAC:

·         Microsoft.ReportViewer.Common

·         Microsoft.ReportViewer.WebForms

Para solucionar este error, basta con copiar desde el GAC (C:\Windows\assembly\GAC_MSIL) los anteriores ficheros en el directorio \bin de nuestra aplicación.

Si volvemos a ejecutar de nuevo nuestra página con nuestro visor, ahora el error será el siguiente:

clip_image003

Vaya! Parece que también tendremos que copiar el ensamblado Microsoft.ReportViewer.ProcessingObjectModel a nuestro directorio \bin.

Hecho esto nuestro informe funcionará correctamente con un despliegue privado del run-time de Microsoft Reporting Viewer.

Un saludo.

lunes, 12 de marzo de 2012

Cómo proteger tu servidor MailEnable en Internet

Últimamente estoy que lo tiro con los posts relativos a la seguridad en un servidor VPS en Internet. Si recuerdas, he escrito ya los siguientes posts:

Después de hablar de SQL Server, RDP y el FileZilla (servicio FTP), hoy toca hablar del servicio SMTP y del servidor MailEnable en su versión estándar (gratuita).

Te prometo que estos posts no me gustan en exceso pero, la única forma de acordarme de los pasos necesarios para asegurar mi servidor de nuevo en caso de desastre, es que los cuente en el blog y así perduren aunque mi servidor sea atacado por una legión de hackers malhumorados.

Cómo configurar el servidor MailEnable no te lo voy a contar porque, además de no ser ningún experto, está perfectamente expuesto en los siguientes enlaces: Installation guide y  Quick Start guide.

Sin embargo, lo que si voy a contar en este post es cómo asegurarnos de que, en un principio, nuestro servidor cumple con las normas de seguridad básicas que, en mi opinión, deberían estar activas.

STMP Relay

  • Sólo permitir envío de correo para usuarios autenticados.
  • Permitir envío para un rango de IPs privilegiadas (por defecto, sólo está activa la dirección local 127.0.0.1)

image

Ten en cuenta que esta configuración es la que hace posible que a los 5 minutos de levantar tu servidor de correo en Internet, no seas origen de spam y seas agregado a una lista negra de spammers como por arte de magia.

Mensaje de bienvenida

Ya puestos, cuantas menos pistas mejor, así que pasamos del mensaje de bienvenido por defecto a uno bastante más neutro que no da información sobre el servidor ni su versión.

Con el mensaje por defecto:

image

Con un mensaje personalizado:

image

image

No permitir correo anónimo para direcciones locales

Básicamente, si el destinatario del correo es una cuenta local al dominio de correo, no es necesario suministrar credenciales de seguridad, por lo que es posible enviar un correo “fake” del estilo cualquier_direccion@cualquier_dominio.algo a cuenta_local@tudominio.algo.

Si no te lo crees sigue los sencillos pasos expuestos en este blog antes de “cortar” el grifo.

Asumiendo que no queremos dar la oportunidad de enviar correo anónimo a nuestras direcciones de correo locales, es necesario activar la siguiente configuración:

image

Desactivar los comandos VRFY y EXPN

Para una lista completa de los comandos disponibles para STMP, visita el siguiente enlace: STMP Commands.

Básicamente VRFY y EXPN permiten comprobar la existencia de nombres de cuentas de correo o incluso devolver todas las cuentas de una lista. Más información en Whatever happened to VRFY?

Para desactivar los comandos, de nuevo en la pestaña “Advanced STMP” del conector de SMTP, accede a “Allowed STMP Commands”, desmárcalos y listo.

Cabe mencionar que con la configuración actual de nuestro servidor SMTP, no nos será posible por código .NET averiguar si una dirección de correo existe o no sin enviar un correo. Es decir, fallarán métodos como How to check if email address exists without sending an email? y componentes de terceros como Email Validador .NET.

Por último, sólo quiero comentarte que no soy ningún experto en MailEnable ni el servicio SMTP, así que es probable que me haya dejado muchas cosas “obvias” en el tintero, pero por algo se empieza.

Un saludo!

domingo, 4 de marzo de 2012

Visualizador de relaciones y restricciones en un DataSet

Quizás hoy en día un método extensor de DataSet y DataTable no sea muy popular porque es una tecnología de la que cualquier Geek de pro huye como la peste.

De hecho, hoy en día no tiene mucho sentido seguir utilizando DataSets puesto que tenemos disponibles otras tecnologías de accedo a datos mucho más modernas y mejor preparadas para la batalla, como son cualquier ORM del estilo de Entity Framework e incluso Linq To Sql (también en desuso pero al fin y al cabo también un ORM).

En cualquier caso, el otro día un amigo me comentaba en el correo que conocer la base de ADO.NET nos ayudará a entender mejor todo las nuevas propuestas de acceso a datos de Microsoft que, al final de los finales, siguen tirando por debajo código ADO.NET (es cierto que EF no utiliza DataSets pero al final y al cabo un DataSet es ADO.NET Core, un must-know).

En esta situación y no pudiendo olvidar que tarde o temprano tendremos que volver a tocar código viejo o heredado que utiliza DataSets, he creído oportuno realizar unos métodos extensores que me ayudarán a ver las relaciones y restricciones existentes en un DataSet a través de la ventana de inspección de Visual Studio.

El código de los métodos extensores es el siguiente (perdona que no sea C#, pero estoy seguro de que sabrás encontrar algún traductor en línea para pasar este código de VB a C#).

Module MyDataSetExtensions
    Private Sub DumpUniqueConstraintToHtml(ByVal uc As UniqueConstraint, ByVal dump As StringBuilder)
        dump.Append(String.Format("<p><b>UniqueConstraint {0}</b></p>", uc.ConstraintName))
        dump.Append(String.Format("<p>IsPrimaryKey {0}</p>", uc.IsPrimaryKey))
        dump.Append("<p>Columns</p>")
        dump.Append("<ul>")
        For Each col As DataColumn In uc.Columns
            dump.Append(String.Format("<li>{0}</li>", col.ColumnName))
        Next
        dump.Append("</ul>")
    End Sub
    Private Sub DumpForeignKeyConstraintToHtml(ByVal fkc As ForeignKeyConstraint, ByVal dump As StringBuilder)
        dump.Append(String.Format("<p><b>ForeignKeyConstraint: {0}</b></p>", fkc.ConstraintName))
        dump.Append(String.Format("<p>UpdateRule {0}</p>", fkc.UpdateRule.ToString()))
        dump.Append(String.Format("<p>DeleteRule {0}</p>", fkc.DeleteRule.ToString()))
        dump.Append(String.Format("<p>AcceptRejectRule {0}</p>", fkc.AcceptRejectRule.ToString()))
        dump.Append(String.Format("<p>RelatedTable {0}</p>", fkc.RelatedTable.TableName))
        dump.Append("<p>RelatedColumns</p>")
        dump.Append("<ul>")
        For Each col As DataColumn In fkc.RelatedColumns
            dump.Append(String.Format("<li>{0}</li>", col.ColumnName))
        Next
        dump.Append("</ul>")
        dump.Append("<p>Columns</p>")
        dump.Append("<ul>")
        For Each col As DataColumn In fkc.Columns
            dump.Append(String.Format("<li>{0}</li>", col.ColumnName))
        Next
        dump.Append("</ul>")
    End Sub
    Private Function GetHtmlStyle() As String
        Return "p, ul, li { margin-bottom: 2px; margin-top: 2px; }"
    End Function
    <System.Runtime.CompilerServices.Extension()> _
    Public Function DumpConstraintsToHtml(ByVal table As DataTable) As String
        Dim dump As New StringBuilder
        dump.Append(String.Format("<style>{0}</style>", GetHtmlStyle()))
        dump.Append(String.Format("<p>TableName {0}</p>", table.TableName))
        dump.Append(String.Format("<p>Constraints {0}</p>", table.Constraints.Count))
        For Each c As Constraint In table.Constraints
            If TypeOf c Is UniqueConstraint Then
                Dim uc As UniqueConstraint = DirectCast(c, UniqueConstraint)
                DumpUniqueConstraintToHtml(uc, dump)
            ElseIf TypeOf c Is ForeignKeyConstraint Then
                Dim fkc As ForeignKeyConstraint = DirectCast(c, ForeignKeyConstraint)
                DumpForeignKeyConstraintToHtml(fkc, dump)
            End If
        Next
        Return dump.ToString()
    End Function
    <System.Runtime.CompilerServices.Extension()> _
    Public Function DumpRelationsToHtml(ByVal dataSet As DataSet) As String
        Dim dump As New StringBuilder
        dump.Append(String.Format("<style>{0}</style>", GetHtmlStyle()))
        dump.Append(String.Format("<p>DataSetName {0}</p>", dataSet.DataSetName))
        dump.Append(String.Format("<p>Relations {0}</p>", dataSet.Relations.Count))
        For Each dr As DataRelation In dataSet.Relations
            dump.Append(String.Format("<p><b>RelationName {0}</b></p>", dr.RelationName))
            dump.Append(String.Format("<p>ParentTable {0}</p>", dr.ParentTable.TableName))
            dump.Append(String.Format("<p>ChildTable {0}</p>", dr.ChildTable.TableName))
            dump.Append(String.Format("<p>Nested {0}</p>", dr.Nested))
            dump.Append("<p>ParentColumns</p>")
            dump.Append("<ul>")
            For Each col As DataColumn In dr.ParentColumns
                dump.Append(String.Format("<li>{0}</li>", col.ColumnName))
            Next
            dump.Append("</ul>")
            If Not dr.ParentKeyConstraint Is Nothing Then
                dump.Append(String.Format("<p><b>ParentKeyConstraint</b></li>", dr.ParentKeyConstraint.ConstraintName))
                DumpUniqueConstraintToHtml(dr.ParentKeyConstraint, dump)
            End If
            dump.Append("<p>ChildColumns</p>")
            dump.Append("<ul>")
            For Each col As DataColumn In dr.ChildColumns
                dump.Append(String.Format("<li>{0}</li>", col.ColumnName))
            Next
            dump.Append("</ul>")
            If Not dr.ChildKeyConstraint Is Nothing Then
                dump.Append(String.Format("<p><b>ChildKeyConstraint</b></li>", dr.ChildKeyConstraint.ConstraintName))
                DumpForeignKeyConstraintToHtml(dr.ChildKeyConstraint, dump)
            End If
        Next
        Return dump.ToString()
    End Function
End Module

Teniendo disponible el código en nuestro proyecto podríamos agregar a la ventana inspección algo como esto:



  • MiDataTable.DumpConstraintsToHtml()

  • MiDataSet.DumpRelationsToHtml()

Y con el visualizador de HTML veríamos lo siguiente (fíjate que incluso en el código de los métodos extensores hemos agregado la etiqueta style de HTML para poder ajustar un poco el resultado):


image


image


No quiero acabar este post sin revelarte el amigo que sin él saberlo me impulsó a escribir este post. Estoy hablando de Óscar Osotorrio… y por supuesto no dejes de visitar su blog que te será muy útil seguro http://oscarsotorrio.com/ 


Un saludo!

miércoles, 29 de febrero de 2012

Cómo proteger tu servidor FileZilla Server en Internet

Dentro de mi espiral de paranoia relativa a la seguridad de mi nuevo servidor, hoy le toca el turno al servicio FTP.

Como servidor de FTP hemos seleccionado FileZilla Server.

Los pasos que hemos tomado para intentar garantizar la seguridad del servicio han sido los siguientes:

Cambiar el mensaje de bienvenida que, por defecto, muestra el nombre del programa y versión del mismo. Lo cambiamos para no dar más información y que esta pueda ser utiliza en nuestro contra a través de exploits de seguridad conocidos del programa y versión.

clip_image001

Activa el autobaneo para que si una misma IP intenta conectar erróneamente X veces dentro un periodo concreto, sea baneada automáticamente.

clip_image002

Activar el log para después poder analizarlo si es necesario.

clip_image003

Cambiar la cuenta de usuario con la que se ejecuta el servicio de FileZilla.

Para ello y según la documentación del producto, hay que crear un nuevo usuario y darle los siguientes permisos:

  • Escritura en el fichero FileZilla Server.xml.
  • Escritura en la carpeta \Logs del directorio de instalación.
  • Control total en el directorio raíz donde vayamos a alojar las carpetas compartidas del servicio.

Después cambiaremos la cuenta en servicios (por defecto se ejecuta con la cuenta SYSTEM que tiene excesivos privilegios):

clip_image004

clip_image005

Por último, tendremos que utilizar los servicios de cuota de Windows si queremos limitar el espacio máximo para las subidas de ficheros que se realicen a través del servicio FTP.

La verdad es que es una pena que FileZilla Server no tenga integrada esta característica, porque de hacerlo seguro que podríamos configurar la cuota por usuario de FTP en vez de sólo hacerlo para la cuenta de Windows en la que estamos ejecutando el servicio.

En el siguiente ejemplo estoy limitando a la cuenta de Windows FileZilla a 5 GB y además estoy diciendo que cuando llegue a los 4 GB lance un warning (que podremos ver en el visor de sucesos de Windows).

clip_image006

clip_image008

Un saludo!

martes, 28 de febrero de 2012

Basado en hechos reales (II): Como proteger tu RDP en Internet

Estamos que lo tiramos con los ataques informáticos. Si ya en un anterior post vimos como proteger nuestra instalación de SQL Server en Internet, ahora toca el turno de prevenir ataques contra RDP (Remote Desktop Protocol).

Como ya estábamos sobre aviso y con la mosca detrás de la oreja, ahora estamos todo el día viendo el visor de sucesos de Windows. Pues bien, cual es nuestra sorpresa cuando vemos que tenemos cientos de sucesos de error de auditoria con el identificador de evento 4625. Esto es un error al intentar iniciar sesión en el servidor.

Además resulta que los nombres de cuenta son del todo variopintos, por ejemplo: Administrador, administrator, John… ¿John? Un momento, no conozco a nadie llamado John, así que está claro, algún desaprensivo está utilizando un escaneador de puertos y un generador de nombres de usuario y claves aleatorias para intentar acceder a mi servidor por la fuerza bruta.

Está claro que capar RDP no es una opción porque entonces ni yo mismo podría acceder a mi servidor, pero gracias al equipo de soporte de domitienda y sus recomendaciones, vamos a realizar los siguientes ajustes para intentar poner difícil el acceso a nuestro servidor a nuestros amiguitos los crackers (no los llamo hackers porque hace tiempo aprendí la diferencia entre crackers y hackers):

  • Denegar el permiso para iniciar sesión de forma remota al usuario Administrador.
  • Crear un nuevo usuario en el grupo Administradores, pero con un nombre no común y concederle permiso para iniciar sesión de forma remota.
  • Cambiar el puerto para RDP (un clásico ya lo de cambiar puertos y así frustrar el escaneo de puertos con herramientas automatizadas).

Crear un nuevo usuario en el grupo Administradores y concederle permiso para iniciar sesión de forma remota es muy sencillo puesto que de forma predeterminada, todos los usuarios del grupo Administradores tienen ese permiso concedido (además también del grupo “Usuarios de escritorio remoto”).

Sin embargo, no es tan obvio como denegar el acceso por escritorio remoto al usuario Administrador. Los pasos a seguir son los siguientes:

  • Inicio > Panel de control > Herramientas administrativas > Directivas de seguridad local
  • Directivas locales > Asignación de derechos de usuario
  • Denegar inicio de sesión a través de Servicios de Escritorio remoto
  • Agregar al usuario Administrador

clip_image001

Después de este cambio, si intentamos acceder por RDP con el usuario Administrador obtendremos el siguiente error:

clip_image003

Por último, para cambiar el puerto del escritorio remoto hay que cambiar un valor en el registro de Windows:

En el siguiente enlace de Microsoft lo explica, pero te lo resumo aquí porque es muy sencillo, simplemente hay que cambiar un valor del registro:

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\TerminalServer\WinStations\RDP-Tcp\PortNumber y donde pone 3389 ponemos cualquier otro.

Lógicamente sólo quedará crear una regla en el firewall para el nuevo puerto seleccionado, y si además en este regla restringimos el acceso a sólo ciertas IPs, pues yo mi parte quedaré muy satisfecho con la seguridad en lo relativo a RDP.

Un saludo!

lunes, 27 de febrero de 2012

Basado en hechos reales: Cómo proteger tu SQL Server en Internet.

Recientemente hemos sufrido un ataque informático contra nuestra base de datos SQL Server 2008 R2 expuesta en Internet.

Por casualidad nos pusimos a mirar el log de errores y descubrimos que había más de 2 millones y medio de intentos de inicio de sesión erróneos del usuario sa desde hace más de 2 meses.

El cómo no nos dimos cuenta en todo ese tiempo de que estábamos siendo atacados por fuerza bruta contra el usuario sa daría para otro post, pero ahora lo más importante es intentar incrementar drásticamente la seguridad de nuestro servidor SQL Server en Internet y dejar de buscar culpables… sobre todo porque yo mismo soy el principal culpable!

“Cabe resaltar que este post asume un escenario con un servidor VPS donde se tienen plenos derechos de administración accediendo por escritorio remoto, es decir, no estoy hablando de Windows Azure ni de un hosting compartido”

La medida más efectiva para evitar ataques contra tu servidor SQL Server en Internet es NO exponerlo a Internet. Esto parece de perogrullo, pero a veces no es tan obvio. ¿Por qué expones tu servidor SQL Server en Internet? Normalmente será porque los desarrolladores argumentan que necesitan acceder a la base de datos para consultar datos, realizar cambios, etc. Yo creo que los desarrolladores (entre los que yo me incluyo) deberíamos pensar que un sistema en producción no es nuestra banco de pruebas personal y que si realmente necesitamos acceder a los datos del servidor hay otras herramientas para darnos acceso sin comprometer la seguridad del servidor. Por ejemplo, escritorio remoto, una VPN, etc.

La verdad es que para un sistema SQL Server en producción no se me ocurre ninguna buena razón para exponerlo directamente en Internet.

Antes de ver que medidas tomamos para garantizar la seguridad de nuestro servidor, la pregunta es ¿Cómo me doy cuenta de que estoy siendo atacado? Pues mirando el log de errores de SQL Server. El log de errores de SQL Server lo podemos consultar de 2 formas distintas:

  • De forma manual, accediendo a Administración > Registros de SQL Server
  • A través de T-SQL, con el comando xp_ReadErrorLog

En cualquiera de los 2 casos podrás ver una información como la siguiente (aquí optamos por el comando xp_ReadErrorLog que es más directo)

xp_ReadErrorLog 0, 1, 'failed'

LogDate

ProcessInfo

Text

2012-02-23 10:39:25.710

NULL

Login failed for user 'sa'. Motivo: la contraseña no es válida para el inicio de sesión proporcionado. [CLIENTE: <local machine>]

Ahora imagina este registro pero multiplicado por 2.5 millones de veces con distintas IP y desde hace 2 meses…y 2.5 GB de log de regalo… ¡terror!

Lo primero es cortar de raíz el acceso al servidor SQL Server desde Internet, y esto es tan sencillo cómo deshabilitar las siguientes reglas del firewall (puede que en tu equipo no se llamen igual, pero básicamente responderán al mismo propósito):

  • MS SQL over TCP protocol. Puerto 1433 sobre TCP.
  • MS SQL Probe. Puerto 1434 sobre UDP.

En este momento ya estamos seguros porque NO exponemos nuestro servidor SQL Server a Internet, pero ¿Qué pasa si tuviéramos necesidad de hacerlo por algún motivo que ahora mismo se me escapa?

Pues te cuento que según mis investigaciones en google y con la ayuda del sentido común (el menos común de los sentidos por otra parte) las medidas que vamos a tomar son las siguientes:

1. Asegurarnos que todas las claves de los login de SQL Server responden a una política de contraseñas fuerte que impiden poner nombres como “Pepe” o “God”. Esto es porque así los diccionarios de ataques por fuerza bruta no encontrarán nuestra contraseña a la primera de turno y además, cuando empiecen a generar contraseñas de forma aleatoria, les cueste más… Gracias a esto después de 2 meses, nuestro servidor no ha sido hackeado (esta es la única triste medalla que podemos lucir a día de hoy).

A este respecto podemos instruir a SQL Server para garantizar una política de contraseñas e incluso forzar la expiración de los login de SQL Server. Más info aquí. Yo por mi parte no voy a activar esta configuración pero prometo que mi contraseña será de muuuchos caracteres, con números, mayúsculas y minúsculas y algún carácter especial como la arroba o el ampersand.

2. Cambiar el puerto por defecto donde escucha SQL Server. Por defecto, SQL Server atiende al puerto 1433 (puerto bien conocido o como dicen en inglés, well known port). Esto significa que cualquier escáner de puertos que detecte que esté abierto el puerto 1433 automáticamente nos dirá que tenemos a SQL Server a la escucha, luego seremos una victima pidiendo a voces un verdugo.

Una lista completa de estos puertos “bien conocidos” la puedes encontrar en la Wikipedia, que por ejemplo nos dice que los siguientes puertos son “bien conocidos”:

  • 1433/tcp Microsoft-SQL-Server
  • 1434/tcp Microsoft-SQL-Monitor
  • 1434/udp Microsoft-SQL-Monitor

Primero vamos a hacer un ejemplo con los puertos abiertos para ver que información nos da un escáner de puertos on-line como http://www.internautas.org/w-scanonline.php

Con los puertos abiertos (sin haber desactivado las reglas del firewall):

clip_image001

Con los puertos cerrados (habiendo desactivado las reglas del firewall):

clip_image002

Aunque en este post nos estamos centrando en los puertos 1433 TCP (puerto por defecto para SQL Server) y 1434 UDP (puerto por defecto para el servicio SQL Server Browser), hay otros puertos menos habituales pero también relacionados con SQL Server que también podrían estar abiertos. Puedes encontrar más información sobre estos puertos aquí.

Además y aunque no es el propósito de este post, si utilizamos instancias con nombre podríamos estar utilizando puertos dinámicos. Un excelente post que habla sobre ello y lo deja muy claro SQL Server runs on which port? Y otro post más que indica como averiguar que puerto concreto está utilizando SQL Server si estamos utilizando los puertos dinámicos How to Find the Dynamic Port reserved by SQL Server?

En cualquier caso, nosotros no tenemos instancias con nombre y la instancia por defecto utiliza el puerto 1433, así que lo cambiaremos a cualquier otro puerto en el rango 49152-65535 (este es el rango para puertos personalizados que seguro no nos darán problemas mañana con la instalación de otros programas). Imaginemos que lo cambio por ejemplo al puerto 50215. El procedimiento para cambiar el puerto está muy bien explicado aquí.

Después de esto ya sólo nos queda crear una regla en el firewall de Windows, en la que incluso podríamos acotar que direcciones IP podrán conectar (yo por mi parte sólo daré acceso a la IP pública de mi oficina).

3. Deshabilitar la cuenta del usuario sa. Esta medida responde a que es por todos conocidos que cualquier instalación de SQL Server tendrá un usuario sa con privilegios administrativos sobre el servidor. Pero claro está que si deshabilitamos esta cuenta, nuestro atacante no sabrá con que login de SQL Server llevar a cabo su ataque. Lógicamente, antes de deshabilitar la cuenta sa estate seguro de que has creado otro login con los mismos privilegios que el usuario sa o que tienes agregada alguna cuenta de usuario de Windows al role de servidor sysadmin.

Hasta aquí hemos llegado con el propósito de intentar poner las cosas un poco más difíciles a nuestros queridos “amigos de lo ajeno”.

Un saludo!