Mostrando entradas con la etiqueta sql. Mostrar todas las entradas
Mostrando entradas con la etiqueta sql. Mostrar todas las entradas

viernes, 21 de agosto de 2020

Fecha actual, subselects y registros pasados más recientes en MariaDB

 JI se ha decidido a colaborar con este blog publicando alguna entrada de vez en cuando, siguiendo la misma filosofía del "lo explico para enterarme yo".
 
En esta su primera entrada nos habla de SELECTS y SUBSELECTS y la fecha actual en MariaDB.
 
Esperemos que sea la primera de muchas entradas futuras.



MARIADB: FECHA ACTUAL Y REGISTROS MÁS RECIENTES


Como me ha costado un rato, comparto esto por si otro estuviera en el mismo caso, lo ve más rápido y si no es exactamente lo que busca, igual le vale como punto de partida.

Tengo una base de datos en MariaDB y necesito sacar un registro con la fecha más reciente, por lo que he necesitado la fórmula curdate() para sacar la fecha actual

Como lo que quería era la factura más reciente, anterior a hoy (PROBLEMA: tenemos algunas con fecha futura), he hecho una subconsulta. Primero he seleccionado los datos que quería de la factura y he puesto que la fecha fuera igual a la mayor (más reciente) de las pasadas (en el WHERE de la subconsulta le indico que sea anterior a hoy).

SELECT id_factura, cliente, fecha

FROM facturas

WHERE fecha = (select max(fecha)

               from facturas

               where fecha < curdate())


Es sencillo, pero me ha dado un poco de quebradero de cabeza porque al usar MAX hay que poner el campo que queramos y el paréntesis pegado a la palabra porque si no da error, así me ha pasado a mí en la consulta SQL. Utilizo un servidor de Hostinger, no sé si este comportamiento será el mismo en todos, pero mejor coger una buena costumbre para evitar fallos similares.

Espero que os pueda servir.

jueves, 28 de julio de 2016

La crème de la crème (consultas TOP-N en Oracle)

En esta entrada hablaba de cómo seleccionar las N primeras filas de una tabla. En todos los casos (Informix, SQL Server, SQLite, Oracle), hacía una consulta básica y nos quedábamos con los 10 primeros resultados. Las filas en una tabla relacional no están ordenadas, por definición, lo cual significa que la consulta nos da las N primeras filas aleatorias, es decir, sin ordenar.

Pero la cosa cambia un poco si las queremos ordenadas, es decir los mejores resultados, las mejores notas, los mejores salarios, la crème de la crème... (o los peores).

Queremos los resultados crème de la crème

Esto significa sacar las N filas primeras (o mínimas) o las N filas últimas (o máximas), lo que se denomina a veces consultas TOP-N (TOP-N queries, por si queréis buscarlo en inglés).

En el caso de SQLite3 podíamos poner la cláusula LIMIT después del ORDER BY, como se explicaba en aquella entrada. Pero en ORACLE no existe la cláusula LIMIT, así que habrá que hacerlo de alguna otra manera.

En principio, utilizando la columna "mágica" ROWNUM, si hacemos lo siguiente:

SELECT * FROM TABLA WHERE ROWNUM <= 100

estamos obteniendo 100 filas aleatorias. Uno podría pensar que entonces, para obtener las TOP-100 filas bastaría con añadir una condición ORDER BY, tal que así:

SELECT * FROM TABLA WHERE ROWNUM <= 100 ORDER BY CAMPO

Pero eso no funcionaría. Lo que nos estaría dando son 100 filas aleatorias, y una vez seleccionadas (y no antes), nos las mostraría ordenadas por el CAMPO indicado. Pero eso no significa que nos esté dando las 100 filas PRIMERAS (según en el orden indicado) de la tabla. El problema es que el valor de ROWNUM se está asignando justo al seleccionar la fila, y la operación ORDER BY se aplica después.

Así pues, la forma correcta de hacerlo en Oracle es intercalar una SELECT dentro de otra:

SELECT * FROM (la-consulta-original) WHERE ROWNUM <= 100

Es decir, para el caso que nos ocupa:

SELECT * FROM (SELECT * FROM TABLA ORDER BY CAMPO) WHERE ROWNUM <= 100


Ale, problema resuelto. A seguir tecleando.

--

Nota: no confundir ROWNUM con ROWID. Ambas son columnas que asigna ORACLE automáticamente, pero no significan lo mismo.

Si queréis una explicación muy buena y bastante detallada acerca de la diferencia entre ROWNUM y ROWID y cómo utilizar ROWNUM para consultas TOP-N y para resultados paginados, echadle un vistazo a este artículo

http://www.epidataconsulting.com/tikiwiki/tiki-read_article.php?articleId=63

lunes, 9 de marzo de 2015

Buscando desesperadamente a Susan... digoooo... un gestor de BD Oracle

Resulta que últimamente en el curro tengo que lidiar con bases de datos Oracle, cosa que había hecho hasta ahora muy poco (algún contacto puntual sin mayor trascendencia, algún cursillo básico enseñando SQL básico sobre Oracle y... poco más).

Pero ahora se trata de trabajar a diario con algunas BD Oracle. Para ello, el primer paso es proveerme de una buena herramienta de administración de Oracle. Hasta hace unas semanas, la única herramienta que conocía era TOAD que, a pesar de haberla utilizado de forma esporádica, hay que reconocerle que es muuuuuy, pero que muuuuy completa. Tiene una cantidad de características impresionante. Sólo tiene una pega... es de pago. No obstante, si alguien quiere probarla, podéis descargar una versión de evaluación por 30 días.
http://software.dell.com/products/toad-for-oracle/software-downloads.aspx

Si tu organización puede permitírselo, mi recomendación es comprarla. Me parece muy bien pagar por un buen software (ahora bien, no he mirado el precio, así que no sé si se pasan o no).

Sin embargo, en mi caso esto no era una opción. Así que yo busco una aplicación gratuita (si ya fuera libre, miel sobre hojuelas, pero tampoco me obsesiona esto). Tras el habitual proceso de googleo, investigación, descargas, instalaciones, configuración y desinstalaciones, me he quedado con tres candidatas. Bueno, quedado no es la palabra, ya que aún no me he decantado por una:

  • TORA [http://torasql.com/]: tiene buena pinta "la publi", pero, lamentablemente, no he conseguido hacerla funcionar. Al parecer, no soy el único, parece que no es tan fácil hacerla funcionar [http://sourceforge.net/p/tora/discussion/52737/thread/bc088bb4/]. Será cuestión de dedicarle más tiempo. Pero cuando le has dedicado un rato y no le has sacado punta, la verdad es que te aburres y te apetece dejarla y probar otra. Probablemente vuelva a dedicarle algún rato más, ya veremos. Si alguien ha conseguido hacerla funcionar en un Windows7 64 bits, por favor, que me diga cómo.



- SQuirreL SQL [http://squirrel-sql.sourceforge.net/]. Esta he conseguido hacerla funcionar rápidamente, y tiene buena pinta. Aún no la he probado mucho, pero ya veremos. Está hecha en Java, lo que se le nota un poco en rendimiento (algunas exportaciones de tablas gordas han sido un poco lentas), pero tampoco pienso andar moviendo grandes bloques de datos frecuentemente, así que probablemente me valga. Una ventaja es que sólo ocupa 56MB, que no es una barbaridad para los tiempos que corren. Como podéis ver en el menú contextual de la imagen, un montón de opciones para exportar a CSV, Excel, HTML... y otras cosas útiles.


- Y por último, SQL Developer. Esta herramienta, recomendada por un compañero, la proporciona Oracle gratuitamente [http://www.oracle.com/technetwork/developer-tools/sql-developer/downloads/index.html] y también va sobre la JVM, así que (los prejuicios pesan mucho, pero es que cuando son fundados...) será cuestión de evaluarla y ver qué tal. Un poco mamotreto sí que es (casi 500MB una vez descomprimida), pero mi intención es probarla.



Bueno, ¿hay alguna herramienta que conozcáis y que me recomendariais en lugar de estas? Cualquier información será muy bienvenida.

miércoles, 3 de diciembre de 2014

Convertir columna NULL en columna NOT NULL


1. EL PROBLEMA

Parece una tontería (y en el fondo, lo es), pero esta mañana me he enfrentado a la necesidad de tener que cambiar el diseño de una tabla para especificar la restricción sobre una columna, que inicialmente podía contener valores nulos, para que fuera una columna NOT NULL. Coser y cantar, me he dicho... Pero no. La cosa se ha complicado un poco.

Figura 1. Situación de partida: actualmente la columna id_concurso puede ser NULL. Queremos cambiar esto

Antes de nada, habrá que rellenar de datos esta columna, para asegurarnos de que no hay ningún registro con NULL en ese campo. Esto es de cajón (no puedo indicar que sea NOT NULL una columna que contiene datos NULL), así que asumimos que esto ya lo hemos hecho (por ejemplo, se pueden actualizar todos los NULL a un valor especial como cero o un número negativo).


2. PRIMER INTENTO: EL DISEÑADOR GRÁFICO DE TABLAS

Como la base de datos está en una instancia de SQL Server, en primer lugar, he intentado hacer el cambio desde la interfaz gráfica del SQL Server 2008 Management Studio, la herramienta oficial de administración de bases de datos de Microsoft, asumiendo que la cosa iba a ser cosa de desmarcar el checkbox y guardar.

Figura 2. Desmarcar el checkbox de "Permitir valores NULL" y ya está. ¿O no?

Pero... cuando lo he intentado, ¡mi gozo en un pozo!

Figura 3. Mensaje de error. No se puede hacer desde la interfaz gráfica. ¡OMG!


3. SEGUNDO INTENTO: DDL

Bueno. No es la primera vez que esta herramienta, el Management Studio, me da estos disgustos. A veces impide hacer cosas desde la interfaz gráfica (como alterar la PRIMARY KEY) pero me permite hacerlas escribiendo la correspondiente instrucción DDL en una ventana de consulta. Así que intentaré hacerlo así.

Después de intentar recordar (sin éxito, mi memoria no da para mucho) la sintaxis de la instrucción ALTER TABLE para hacer esto, me he tenido que lanzar a una búsqueda en Internet, asumiendo que lo iba a encontrar en menos de un minuto. Pero...

... buscando... buscando... buscando...

...tras unos minutos dando vueltas, me encuentro con que aparentemente NO se puede hacer en un único paso (ah, quizás mi memoria no era tan mala después de todo). Aquí tenéis una explicación (en inglés) de cómo se puede hacer para Firebird, pero imagino que el proceso puede valer para cualquier otro motor de BD. Básicamente, los pasos son:

1. Crear una nueva columna NOT NULL
2. Rellenar de datos esta columna con los datos de la columna original
3. Eliminar la columna original
4. Renombrar la columna nueva con el nombre de la columna original

OJO: si lo miráis en el ejemplo de Firebird que os he enlazado, la sintaxis que allí aparece no es válida para SQL Server (no sé si es que con Firebird vale, o es que directamente han cometido algún error sintáctico).

Se entiende, ¿no?

Ok, manos a la obra.


Paso 1. Crear nueva columna temporal

Al ejecutar la primera instrucción, obtengo el mensaje de error siguiente:

Figura 4. Mensaje de error. No puedo crear una columna NOT NULL. 

Claro, qué despiste. Si crea una columna nueva NOT NULL, ¿qué valores le asignaríamos a los registros existentes en esa columna? Así que tendremos que especificar un valor DEFAULT para esos registros, dejando la instrucción así (esto no lo tuvieron en cuenta en el ejemplo del Firebird)

1. ALTER TABLE mitabla ADD columna_nueva INTEGER NOT NULL DEFAULT 0


Figura 5. Ahora sí: nueva columna no nula creada. Datos por defecto a 0 (cero)


Paso 2. Rellenar los datos

Figura 6. Actualizar el nuevo campo a partir del antiguo. Sin problemas


Paso 3. Eliminar la columna original

Figura 7. Eliminar columna


Paso 4. Renombrar la columna

Figura 8. Vaya, la sintaxis en SQL Server no es 'RENAME COLUMN'.

Un par de consultas al patito y veo que en SQL Server, para renombrar una columna de una tabla, hay que usar el procedimiento sp_rename,

Figura 9. Renombrar una columna con sp_rename. ¿Por qué no me funciona?

Bueno, como veréis en la figura 9, no me ha funcionado, seguramente por algún error de sintaxis. Me he vuelto loco probando distintas maneras: con comillas sencillas, con comillas dobles, con el nombre simple de la tabla, con el nombre de la tabla totalmente cualificado (precedido de esquema y propietario)... y no he conseguido ejecutar el sp_rename. Lo que sí he comprobado es que con el diseñador, en la interfaz gráfica, sí que te deja modificar el nombre de la columna, así que he optado por esa opción, la fácil. Pero agradecería si alguien me sabe decir por qué no me ha funcionado ninguna de las opciones anteriores.

Figura 10. Podemos renombrar la columna desde la vista Diseño de la tabla


4. CONCLUSIÓN

Aunque en principio parece una operación trivial modificar el estatus de una columna de una tabla que acepta valores nulos a la situación en que no los acepta, a la hora de la verdad la cosa se puede complicar un poco.

Como resumen, aquí están los pasos que yo he dado en SQL Server 2008 Management Studio

1. ALTER TABLE mitabla ADD columna_nueva INTEGER NOT NULL DEFAULT 0;
2. UPDATE mitabla SET columna_nueva = columna_original
3. ALTER TABLE mitabla DROP COLUMN columna_original
4. Renombrar 'columna_nueva' a 'columna_original' en el diseñador gráfico

En la explicación en inglés que os he puesto arriba introducen un COMMIT entre los pasos 1 y 2 y otro entre los pasos 2 y 3. Me parece una muy buena idea, aunque os dejo a vosotros el pensar por qué.


EPILOGO

Después de tener esta entrada escrita, encuentro (concretamente, aquí) que hay una forma muuuuuuuucho más simple de hacer lo que yo quería

ALTER TABLE dbo.mitabla ALTER COLUMN columna_original INTEGER NOT NULL

La he probado y funciona perfectamente

Figura 11. ¡Haber empezado por ahí, hombre!


A la vista del resultado, a punto he estado de borrar esta entrada, pero no lo he hecho por varias razones

1) Ilustra un proceso que ocurre muchas veces en informática. Uno se plantea una forma de hacer las cosas, y cuando está cerca del final, descubre otra forma más sencilla de hacerlo. Mi opinión es que no hay que ser nostálgico, no te aferres a "tu" código por el hecho de que tú lo has "parido". Si hay una forma mejor, o más sencilla, tira lo viejo y quédate con lo mejor.

2) En el ejemplo del Firebird que encontré, se indicaba que con ese motor de BD había que hacerlo así, con la secuencia de cuatro pasos que os he puesto arriba. No he probado si también allí funciona la forma "simple", pero si no funciona, habría que usar la "compleja". Lo mismo vale para otros SGBD (Sistemas Gestores de Bases de Datos, o motores).

3) La secuencia de cuatro pasos indicada tiene sentido desde el punto de vista pedagógico, para aquellas personas que están aprendiendo temas de administración de bases de datos.

4) Como digo a veces, el lema de este blog es "Lo explico para enterarme yo". Es decir, si no me hubiera planteado explicar el problema paso a paso, quizás no hubiera encontrado la solución simple. Al menos, queda aquí para mí como una lección aprendida.

5) Y además, ya que la tenía escrita no iba a borrarla, ¿verdad? ;-) (esto es una broma, como digo en el punto 1: "no te aferres, no te aferres...").

martes, 4 de febrero de 2014

Las mejores inyecciones son chorizos y jamones (parte 4, última)

4. Qué se puede hacer

Hasta aquí, hemos visto algunos ejemplos muy sencillos de cómo se puede intentar inyectar código SQL en una aplicación web (ojo: esto también sirve para una aplicación de escritorio). Pero, ¿hay algo que la madre de Caperucita pueda hacer para que el lobo no le putee la base de datos con una inyección SQL?

Bueno, no hay una solución mágica, pero se pueden hacer algunas cosas que sirven como pequeñas ayudas. Entre unas cosas y otras, se puede mitigar algo el poder de los ataques. Vamos allá. Seguro que a algunos se os ocurren más, pero estas son algunas de las actuaciones más básicas.

4.1 Instrucciones SQL precompiladas (prepared statements)

En primer lugar, está el uso de instrucciones SQL preparadas o precompiladas (prepared statements). Esto depende tanto del lenguaje (los más utilizados soportan todos formas más o menos parecidas de hacerlo) como de la BD. Estas instrucciones preparadas son como consultas precompiladas en las que lo único que falta es rellenar algunos datos que se han establecido como parámetros. Al estar precompiladas, estas instrucciones sólo se analizan (parsing) una vez, y se gana velocidad de ejecución, ya que el motor de la BD puede optimizar la consulta cuando se compila.

Pero lo mejor de ellas, para el caso que nos ocupa, es que los parámetros son gestionados por el motor de la BD; no tenemos que componer la sentencia SQL concatenando partes fijas con los parámetros. Bien es cierto que el motor también puede cometer un fallo, pero, seamos realistas, me fío más del equipo de programadores del motor de la BD y de su sistema de revisión que de mí, aunque nada más sea por el tamaño del equipo que tiene que haber detrás de un motor como SQL Server, Oracle o MySQL, por poner algunos. Y mira que yo soy buen programador (y además, guapo), pero aún y con esas, no creo que les gane ;-)

El caso es que los parámetros normalmente tienen tipos (integer, string...) que son comprobados por el motor y eso facilita mucho evitar que se cuelen cosas "raras".

En el caso de PHP, que es el que me pilla más cercano ahora, las instrucciones preparadas se pueden utilizar con los PDOs. Más info aquí:
http://php.net/manual/en/pdo.prepared-statements.php

4.2 Sanear la entrada

Otra cosa que se puede hacer es analizar la entrada que está metiendo el usuario para ver si contiene caracteres raros. Por ejemplo, si en el campo donde espero leer un NIF me encuentro algo que no son dígitos ni letras, ¡alarma! Como norma general, se pueden validar campos habituales como el NIF, los apellidos, el nombre, etc... para alertar si contienen comillas, exclamaciones, barras, etc... Se puede funcionar por lista negra (un conjunto de caracteres prohibidos) o, mejor aún (en mi opinión), si se sabe de antemano, funcionar por lista blanca (conjuntos de caracteres permitidos). En un apellido no permitiría ni siquiera un dígito. No obstante, a veces habrá que permitir la comilla (se me ocurren apellidos como O'hara) y en particular hay que tener cuidado con las codificaciones de los caracteres con tildes, eñes, etc...

4.3 Permisos en la BD

Bueno, si a pesar de nuestras precauciones el atacante logra ejecutar una instrucción contra la BD, intentemos que al menos el daño sea el menor posible. Siguiendo el principio de mínimo privilegio, un usuario nunca debería tener más permisos de los estrictamente necesarios para realizar su labor. Si sólo va a consultar datos en la BD, no tiene por qué tener permisos para cargarse una tabla. De esta forma, aun en el caso de que un atacante consiguiera inyectar una instrucción del tipo "drop table", si la ejecución se lleva a cabo con los permisos de un usuario con acceso de sólo lectura, ésta fallaría.

Así que ya sabéis, para configurar bien los permisos, a revisar aquello del GRANT SELECT ON TABLA... para el caso específico de vuestra BD.

Principio del mínimo privilegio:
http://sophosiberia.es/principio-de-minimo-privilegio-reducir-el-area-de-ataque/

4.4 Otras pequeñas ayudas

Por último, hay algunas otras cosas que se pueden hacer que, aunque no son la panacea, pueden aportar su granito de arena.

4.4.1) Limitar el tamaño de los campos de entrada. 

Por ejemplo, los login de los usuarios. En entornos empresariales a veces hay reglas cuadriculadas para asignar los login (así ocurre en uno de los entornos en los que suelo trabajar). Si los nombres de usuarios no superan los 10 caracteres, por ejemplo, limitar el tamaño de ese campo puede contribuir a que desde el formulario no se puedan insertar peticiones con instrucciones largas (por ejemplo, no se podría insertar el DROP TABLE...). Esto no evita que se lance una petición a través de un programa elaborado específicamente para ello, pero dificulta un poco la realización de ataques.

2) Registrar lo que se ejecute

También puede ser conveniente llevar un registro (tabla de log, fichero, log del sistema...) con las operaciones que se van realizando desde los programas. Esto no va a evitar que se produzcan los problemas, pero al menos puede ayudar para, una vez producidos y detectados los mismos, determinar el origen (usuario, dirección IP...) y por lo menos saber por dónde buscar para intentar cazar al lobo. Si no hemos podido evitar el ataque, al menos nos queda el consuelo de intentar pillar al responsable y darle un capón.

3) Filtros por palabras

Se pueden filtrar determinadas palabras clave en las entradas del usuario (como "drop", "delete"...) en determinados campos donde esto no tiene sentido. Por ejemplo, normalmente no encontraremos nombres o apellidos con esas palabras, así que si un usuario se llama "Drop..." lo mínimo que se puede hacer es disparar una alerta y llamar al leñador, a que venga con el hacha.

4) Codificaciones de cadenas

Esta solución no la he probado, pero la vi apuntada en un foro y quizás merezca dedicarle un poco de atención. La idea es codificar las entradas del usuario haciendo una conversión de las cadenas de entrada a codificaciones puras ASCII.

Lo que se argumenta es que con estas codificaciones desaparecen las comillas, los puntos y coma y otros caracteres "peligrosos". Pero no tengo muy claro cómo se harían las búsquedas y comparaciones. En fin, ahí os dejo apuntados los nombres de las funciones que habría que mirar, para aquellos que deseéis investigar: base64, hex2bin, unhex, pack...

Aquí lo dejo

Bueno, con esto doy por zanjado el tema. Como veréis, la metáfora del cuento de Caperucita ha ido perdiendo fuerza con cada nueva entrada; fue una chorrada que se me ocurrió un día y después me ha dado un poco de pereza mantenerla, aunque ahí la dejo por si alguien quiere elaborar un poco sobre ella y darle mejor forma.

Por otro lado, como ya he dicho otras veces, estas entradas las escribo, en primer lugar, para mí, por lo que a veces puede que dé por supuestas ciertas cosas y no me esfuerce en explicar las bases, aunque creo que cualquier programador con un nivel básico puede seguir las explicaciones sin complicaciones. En este caso, apenas he tocado la punta del iceberg del tema en cuestión, pero a mí me bastaba con tener unas pruebas de concepto que funcionaran realmente, y lo he conseguido, así que al menos a mí me ha valido. El hecho de haberme obligado a escribir de forma más o menos estructurada me ha generado, como otras veces, más preguntas que respuestas, y un montón de ideas y tareas a realizar, así que ahora me toca dedicarme a implementar muchas de las ideas que han ido apareciendo durante la escritura de esta serie de entradas, así como hacer pruebas reales en mis aplicaciones, pues me he dado cuenta de algunos fallos que tengo que debería corregir cuanto antes.

Para eso me sirve escribir ;-)

Referencias

Aquí tenéis el enlace a todos los artículos anteriores de la serie:

Parte 1
http://cosicasdeinformatica.blogspot.com.es/2014/01/las-mejores-inyecciones-son-chorizos-y.html

Parte 2
http://cosicasdeinformatica.blogspot.com.es/2014/01/las-mejores-inyecciones-son-chorizos-y_23.html

Parte 3
http://cosicasdeinformatica.blogspot.com.es/2014/01/las-mejores-inyecciones-son-chorizos-y_27.html

lunes, 27 de enero de 2014

Las mejores inyecciones son chorizos y jamones (parte 3)

3.2 Haciendo daño (DROP TABLE)

Preguntémonos ahora si sería posible llevar al cabo el caso del DROP TABLE descrito en el apartado 1.

Imaginemos que el atacante no sabe el nombre de las tablas de nuestra BD. Para ilustrar qué pasaría en este caso, primero probaremos con una tabla que no exista introduciendo en el nombre de usuario la expresión

' or '1'='1'; drop table kk2--

Y al pulsar el botón "Entrar" obtenemos


Imagen 3.1 Intentando eliminar una tabla inexistente

Bueno, no sabemos si ha funcionado el DROP TABLE o ha fallado, pero sí sabemos que no se produce ningún mensaje de error. El atacante podría ir haciendo pruebas por fuerza bruta, hasta encontrar una tabla que sí exista. Para probarlo, he creado en la BD una tabla "kk" y quiero ver si se elimina y se me notifica de ello. He repetido la prueba

Imagen 3.2 Intentando eliminar una tabla que sí existe

Como véis, ningún mensaje de error o éxito. Pero al comprobar si  la tabla sigue viva me encuentro con (...redoble de tambores...)

¡Vaya, ha desaparecido! (bueno, aquí no tengo una imagen para ilustrar esto, pero tendréis que creerme, es que un pantallazo en este caso no aporta nada).

Hmmm... peligro, peligro...

En este caso, el atacante no sabe si su técnica ha funcionado, pero si lo que le interesa simplemente es hacer daño, no le sería demasiado complicado realizar un script que fuera generando por fuerza bruta todas las combinaciones de nombres entre 1 y 30 caracteres (pongamos por caso) y cargarse nuestra BD completa. Vale que esto llevaría un buen rato, pero el lobo tiene tiempo libre y ganas de fastidiar.

Según he leído (esto no lo he probado), la ejecución de dos sentencias SQL en una única llamada a la función correspondiente no funciona con todas las BBDD. Según dicen, en MySQL no funcionaría. Pero yo acabo de comprobar que en SQL Server sí funciona, así que ¡CUIDADÍN!

3.3 Meter basura en casa (INSERT INTO)

Continuando con nuestras pruebas, imaginemos por un momento que el atacante sabe el nombre de la tabla de usuarios y los campos, al menos el del nombre del usuario y el del hash de la clave (login y epass, respectivamente, en nuestro ejemplo). Pensar que un atacante sabe tanto no es descabellado, pues es relativamente sencillo forzar errores que, si no se gestionan bien (casi nunca se gestionan bien al 100%) revelan algunos de estos datos. Más adelante veremos algunos ejemplos sobre formas de obtener información acerca de la BD, como nombres de tablas, campos, etc...

En ese caso, podría intentar insertar un registro que le proporcione una cuenta de usuario. Algo así como:

' or '1'='1'; insert into usuarios(login, epass) values ('lobito', 'x')--

Donde 'x' sería el valor hash de la clave que él desea ponerse. Vale, aquí quizás estamos suponiendo ya demasiado, como que se utiliza un algoritmo u otro (MD5, SHA1...) para calcular el hash, pero tampoco esto es descabellado. Además, utilizar una "sal" (salt) para la contraseña dificultaría el ataque, pero de momento seguimos con ejemplos en entornos más o menos sencillos.

Bien, pues introducida la expresión que he puesto, pulsamos Entrar y...

Imagen 3.3 Nos la han colado doblada

¡Vaya, ahí está el registro insertado!

Que luego esa información le sea más o menos útil al lobo en su lucha contra la Caperumadre es otra cosa, pero el caso es que ya ha conseguido introducir datos ficticios, basura, en la BD. ¡Hmmm, malo, malísimo!

La semana que viene continuaremos.

Referencia:

Las mejores inyecciones son chorizos y jamones (un cuento de inyección SQL). 

Parte 1
http://cosicasdeinformatica.blogspot.com.es/2014/01/las-mejores-inyecciones-son-chorizos-y.html

Parte 2
http://cosicasdeinformatica.blogspot.com.es/2014/01/las-mejores-inyecciones-son-chorizos-y_23.html

jueves, 23 de enero de 2014

Las mejores inyecciones son chorizos y jamones (parte 2)

En la parte 1 hablé de la teoría; ahora vamos a montar un entorno básico y a hacer algunas pruebas, a ver si lo que allí se contaba es así realmente.

2. Un entorno de pruebas

Para tener un entorno de pruebas, crearé dos páginas PHP, una con el formulario de solicitud de datos y otra con el resultado del procesamiento. Probablemente, en una aplicación real esta página sea la misma, o no, pero de momento estamos haciendo algunas pruebas "de juguete".

 1 <html>
 2     <head>
 3         <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 4         <title>Pruebas SQL Injection</title>
 5     </head>
 6 <body>
 7     <h1>Introduzca usuario y contraseña</h1>
 8     <form action="test2_res.php" method=POST target=_blank>
 9         Usuario <INPUT TYPE="text" NAME="usuario" SIZE=20 MAXLENGTH=20>
10         <br>
11         Contraseña <INPUT TYPE="password" NAME="pwd"   SIZE=20 MAXLENGTH=20>
12         <br>
13         <INPUT TYPE="submit" CLASS="boton" VALUE="Entrar">
14     </form>
15 </body>
16 </html>
Listado 2.1. La página de prueba

que se ve más o menos así (con variaciones mínimas entre navegadores):

Imagen 2.1 Como véis, todo un derroche de diseño y buen gusto.

Y la parte de procesamiento en la página 2 podría ser algo más o menos así:

 1 <?php
 2     //...otras cosas
 3     
 4     $conn = conectar_bd(); //falta control de errores
 5     $usuario = $_POST['usuario'];
 6     $pwd     = $_POST['pwd'];
 7     $epwd    = strtoupper(md5($pwd));
 8     echo "Datos leídos '$usuario' y '$pwd' -->encriptada: '$epwd'<br>";
 9     $sql = "select login, epass from usuarios where login = '$usuario' and epass = '$epwd'";
10     $rs=odbc_exec($conn, $sql);
11     if (!$rs) {exit("Error en SQL");}
12     
13     $encontrados = 0;
14     while ($row = odbc_fetch_array($rs)) {
15         $encontrados++;
16         echo "encontrado registro " . $row['login'] . " " . $row['epass'];
17     }
18     
19     if ($encontrados == 0) {
20         echo "no se encontró el usuario";
21     }
22     
23     //... otras cosas
24 ?>
Listado 2.2. La página que procesa el login y la clave introducidos

Como habréis visto, si habéis leído el código (si no lo has hecho, vuelve unas líneas arriba y léelo antes de continuar), la clave no se almacena en claro, sino que se almacena su hash MD5, pero esto no cambia en nada la prueba de concepto y lo que hemos dicho hasta ahora (sólo añade un poco de realismo a la situación, ya que esto es algo habitual en sistemas reales). También veréis que el procesamiento se limita a listar todos los registros que se encuentren que cumplan la condición, que en principio es que coincida el login con el que ha introducido el usuario, y el hash de la contraseña introducida con el hash almacenado en el campo "epass" (e de encriptada). En un sistema real en producción, lógicamente este listado de los registros recuperados no se haría, pero para nuestras pruebas es más ilustrativo. También voy a mostrar la sentencia SQL que se ejecuta, ya que a efectos de muestra va a ser de ayuda para entender lo que está pasando por dentro, y el hash de la clave introducida, esto es simplemente porque durante las pruebas lo hice así y ahora no me apetece repetir las capturas de pantalla quitando esto.

Por otra parte, en la BD, montada sobre un servidor SQL Server, he dado de alta un usuario con nombre 'caperu' y contraseña 'reparto1'.

Primero insertamos un par usuario / clave normal y vemos que todo funciona como se espera:



Si introducimos una clave incorrecta:




Bueno, en apariencia todo funciona más o menos bien. Con esto ya tenemos el entorno de prueba montado. Manos a la obra.

3. Haciendo algunas pruebas

Ahora intentaremos probar casos similares al descrito en el apartado 1 para ver si conseguimos obtener el mensaje de acierto: "encontrado registro..."

3.1 ¿Es uno igual a uno?

En primer lugar, supongamos que el lobo está engandulado, y se limita a meter en el campo "usuario" la siguiente expresión:

' or '1'='1'--

y deja la contraseña en blanco (¿para qué teclear sin necesidad?). Le da a ejecutar... et voilà! (La explicación a por qué usar esta expresión está en la parte 1, así que no me voy a repetir aquí).




Vaya, esto pinta mal, ¿eh? El lobo malo ha conseguido revelar todos los nombres de los usuarios, incluyendo el de Caperucita (usuario "caperu"). Además, puede decir que ha entrado en la BD. Por supuesto, en un sistema real se comprobarían otras cosas, pero estamos trabajando con una prueba de concepto y el ejemplo ya nos permite atisbar algunos de los peligros de esta técnica.

Bueno, creo que hasta aquí ya está bien por hoy. Hemos montado un entorno de pruebas y esta primera prueba ha sido suficiente para tomar conciencia del problema. 

¿Qué pruebas se te ocurre que podría hacer el lobo a continuación? ¿Cómo podría la Caperumadre prevenirse contra esto? 

La semana que viene seguiremos con el tema...

Referencia:

Las mejores inyecciones son chorizos y jamones (un cuento de inyección SQL). Parte 1
http://cosicasdeinformatica.blogspot.com.es/2014/01/las-mejores-inyecciones-son-chorizos-y.html

martes, 14 de enero de 2014

Las mejores inyecciones son chorizos y jamones (un cuento de inyección SQL). Parte 1

Bien es verdad que hace casi 4 meses que no escribo en este blog, pero este año me he propuesto escribir un poco más que el pasado. Cosa que no será muy difícil, ya que el año pasado sólo escribí cinco entradas. De momento, he empezado con una serie que me dará para varias entradas.

viernes, 13 de enero de 2012

SQL - Seleccionar sólo las primeras N filas

El otro día metí la pata haciendo un SELECT genérico de una tabla de la que desconocía el tamaño. El procesador se puso casi al 100% durante 5 minutos, y el disco duro no dejaba de rascar. Los usuarios que compartían (sufrían) conmigo el acceso a la BD estuvieron experimentando un rendimiento pésimo durante esos 5 minutos (bueno, los pocos que intentaron trabajar en ese período), que a mí se me hicieron eternos. El problema es que la tabla tenía casi 2 millones de registros y esto fue er... bueno... "un poco" pesado. Encima, el resultado fue a una página web, así que os podéis imaginar el tamaño del "ascensor" (el recuadro) de la barra de desplazamiento. Casi no se podía pinchar en él de pequeño que se quedó.

El caso es que me interesaba simplemente ojear el contenido de esa tabla, me hubiera bastado con recuperar unos pocos registros, digamos, unos 100 para hacerme una idea de su contenido. Bueno, pues eso se puede hacer sin necesidad de poner filtros a los datos (cosa que en su momento no podía hacer pues no tenía ni idea de los campos y datos de la tabla).

En ORACLE
SELECT * FROM TABLA WHERE ROWNUM <100

En MS SQL Server y en SYBASE

SELECT TOP 10 * FROM TABLA

En INFORMIX
SELECT FIRST 100 * FROM TABLA


Actualización 02/09/2014 para incluir SQLite3, que me ha hecho falta hoy. Hay que añadir LIMIT(N) al final de la consulta

En SQLite3
SELECT * FROM TABLA LIMIT(100)

Si hubiera cláusulas WHERE u ORDER BY, hay que poner la opción LIMIT al final de todo, o sea:

SELECT * FROM TABLA WHERE CONDICION ORDER BY CAMPO LIMIT(100)
Related Posts Plugin for WordPress, Blogger...