0:00:00.000,0:00:04.440
Muchas gracias Brittany por esta maravillosa y nada desagradable introducción.

0:00:04.440,0:00:07.920
Entonces, hablando de entradas de prueba desagradables.

0:00:08.640,0:00:12.660
Empecemos con las pruebas. Tenemos un cliente, tenemos un servidor,

0:00:12.660,0:00:17.400
supongamos que ambos hablan SSL, hay un protocolo de vigilancia,

0:00:17.400,0:00:21.540
y entonces tenemos un cliente que envía una carga útil al servidor

0:00:21.540,0:00:27.600
y tenemos el servidor que responde a las cosas, ustedes probablemente han visto esto como parte de la

0:00:27.600,0:00:31.080
conocida vulnerabilidad Heartbleed pero no vamos a hablar de eso hoy.

0:00:31.080,0:00:36.480
De todos modos, lo importante es que la carga útil que se envía y, es decir, al servidor

0:00:36.480,0:00:40.140
y la carga útil que el servidor responde deben ser idénticos,

0:00:40.140,0:00:43.080
y entonces el cliente sabe que el servidor sigue vivo.

0:00:43.800,0:00:46.440
Ahora supongamos que ustedes tienen un servicio de este tipo, cosa muy simple,

0:00:46.440,0:00:49.680
y desean probar que esto funciona, bueno, ¿qué hacen?

0:00:49.680,0:00:53.880
Tienen que elaborar una serie de entradas, más entradas y aún más entradas,

0:00:53.880,0:00:59.280
posiblemente probando casos de esquina y todo eso. Y, bueno, también tenemos que comprobar si

0:00:59.280,0:01:01.680
el servidor es realmente bueno, va a hacer lo correcto,

0:01:01.680,0:01:05.820
por lo que también es necesario especificar un número de salidas y comprobar que las entradas realmente

0:01:05.820,0:01:09.420
obtienen las salidas correctas y todo. Esta es la prueba tal y como la conocemos,

0:01:09.420,0:01:12.420
por lo que esta es la prueba que todos hemos hecho, y, sí,

0:01:12.420,0:01:16.860
lo hacemos todo el día y es aburrido y es difícil, y es aburrido, pero hace el trabajo,

0:01:16.860,0:01:22.380
Sí, sí, lo hacemos. Pero quiero hoy, quiero

0:01:22.380,0:01:26.760
hablar de cómo crear dicha entrada. Así que vamos a ir para un enfoque simple aquí.

0:01:26.760,0:01:31.380
Vamos a crear algunas entradas al azar. Así que estoy lanzando un dado y yo sólo

0:01:31.380,0:01:35.340
lanzando bytes aleatorios en mi servidor, esto se llama fuzzing,

0:01:35.340,0:01:38.580
puede ser arbitrariamente inteligente, y si tienes suerte,

0:01:38.580,0:01:41.100
bueno, en nuestro caso uno de

0:01:41.640,0:01:46.980
256 mensajes será realmente correcto y, posiblemente, obtenga su respuesta

0:01:46.980,0:01:49.980
pero en la mayoría de los casos nada va a suceder porque el servidor simplemente

0:01:49.980,0:01:55.020
va a decir, este no es un mensaje válido. Y de todos modos después de un par de intentos, 

0:01:55.020,0:01:58.200
probablemente será bloqueado porque envió demasiados mensajes ilegales al servidor de todos modos.

0:01:58.980,0:02:03.060
Así que aquí tienes. ¿Qué más podemos hacer?

0:02:03.060,0:02:10.260
Quiero hablar con ustedes hoy cómo ustedes puede convertirse en, cómo ustedes pueden convertirse en un superhéroe de pruebas.

0:02:10.260,0:02:16.740
Un superhéroe de pruebas mediante la creación de un robot, un robot que hará automáticamente lo correcto,

0:02:16.740,0:02:20.820
a saber, el envío de entradas que son correctas para el servidor y también comprobar

0:02:20.820,0:02:23.820
si las salidas son correctas y entonces usted puede finalmente relajarse.

0:02:25.020,0:02:27.960
¿Cómo podemos hacerlo? Bueno, podrían ir y

0:02:27.960,0:02:32.820
programar tal robot, que sería una manera, pero entonces ustedes tienen que programar tal robot para

0:02:32.820,0:02:35.580
cada nuevo, cada nuevo servidor, todo lo que usted mira,

0:02:35.580,0:02:38.400
y eso es, oh, sí, eso es, sí, puedo hacer eso,

0:02:38.400,0:02:40.020
eso tampoco es divertido. No,

0:02:40.020,0:02:43.620
lo que hacemos aquí es aprovechar los lenguajes.

0:02:43.620,0:02:47.520
Y no estamos hablando de lenguajes de programación, pero estamos hablando de lenguajes formales.

0:02:47.520,0:02:50.880
¿Acabo de decir la palabra formal? Por favor, quédense con nosotros un momento.

0:02:51.720,0:02:55.680
Y sé que si han estudiado informática, quizá hayan aprendido lenguajes formales,

0:02:55.680,0:02:58.860
¿no te gustó? espera, espera un momento, es todo es super útil.

0:02:58.860,0:03:03.600
Porque si tienen un lenguaje formal, en nuestro caso, por ejemplo, una gramática,

0:03:03.600,0:03:09.240
entonces pueden especificar lo que el, lo que las entradas al servidor deben ser,

0:03:09.240,0:03:15.540
por lo que es 0x1 seguido de la longitud de la carga útil y el relleno y lo que la respuesta debe ser en formas abstractas,

0:03:15.540,0:03:19.500
por lo que el servidor envía de vuelta 0x2 longitud, como la carga útil, y el relleno.

0:03:19.500,0:03:24.840
Y estas son cosas que realmente se pueden especificar en una gramática

0:03:24.840,0:03:27.840
que describe el formato correcto de tales interacciones

0:03:27.840,0:03:34.860
y si ustedes tienen una gramática entonces, bueno, ustedes todavía tienen que comprobar que la carga útil es idéntica

0:03:35.820,0:03:40.560
pero también, gramática por sí sola no es suficiente, porque el problema aquí es también,

0:03:40.560,0:03:44.820
que tienen cosas en estas interacciones que ustedes también necesitan para satisfacer,

0:03:44.820,0:03:49.680
por ejemplo, el campo de longitud que se ve aquí tiene en realidad, tiene que ser idénticos,

0:03:49.680,0:03:54.180
tiene que ser en realidad la longitud exacta de la carga útil que sigue,

0:03:54.180,0:03:58.440
y estas son cosas que no se puede expresar fácilmente en una gramática.

0:03:58.440,0:04:00.240
Por lo tanto, lo que hacemos es

0:04:00.240,0:04:05.700
primero fusionamos estas dos cosas, la solicitud y la respuesta, en una sola gramática,

0:04:05.700,0:04:11.400
pero luego hacemos algo muy bonito, porque como la sintaxis por sí sola 

0:04:11.400,0:04:18.060
no es suficiente para capturar estas relaciones semánticas entre los elementos individuales,

0:04:18.060,0:04:24.300
añadimos restricciones adicionales a la entrada que describen estos semántica

0:04:24.300,0:04:30.240
como fórmulas lógicas. Se trata de fórmulas lógicas en las que

0:04:30.240,0:04:36.660
los no-terminales, la cosa entre paréntesis angulares, en realidad toman el papel de variables aquí.

0:04:36.660,0:04:38.280
Por ejemplo, aquí podemos especificar

0:04:38.280,0:04:43.920
que la mecánica, por ejemplo, especificar que la longitud, que es un entero de 16 bits,

0:04:43.920,0:04:46.920
es en realidad idéntica a la longitud de la carga útil.

0:04:47.460,0:04:49.980
Y aún podemos hacer más. También podemos comprobar que

0:04:49.980,0:04:53.760
la salida es correcta, por ejemplo, diciendo que la carga útil que tenemos

0:04:53.760,0:04:58.140
visto en la solicitud del cliente es idéntica a la carga útil que el servidor responde.

0:04:58.860,0:05:02.880
Y esto es lo que hemos construido en un lenguaje llamado Isla

0:05:02.880,0:05:08.520
que es a la vez un lenguaje para especificar dichas entradas y salidas mediante gramáticas y restricciones,

0:05:09.240,0:05:14.160
pero también es más que eso, es también un fuzzer y un solucionador para producir

0:05:14.160,0:05:19.680
entradas válidas que satisfagan todas estas restricciones. Y también es un corrector que le ayuda a

0:05:19.680,0:05:24.360
analizar y comprobar y mutar las entradas siguiendo todas estas restricciones,

0:05:24.360,0:05:30.420
y es esta herramienta que, bueno, es una de las herramientas que te puede hacer un superhéroe.

0:05:30.420,0:05:36.060
Permítanme mostrarles cómo funciona realmente. Aquí está Isla trabajando.

0:05:36.600,0:05:42.300
Lo que hace Isla es utilizar la gramática para producir intercambios

0:05:42.300,0:05:45.660
o para producir entradas y salidas, así que tenemos un intercambio de nuevo

0:05:45.660,0:05:50.220
entre el cliente y el servidor, cliente y servidor, hey, los tenemos.

0:05:50.220,0:05:54.540
Y ahora utiliza técnicas de producción bastante estándar, a saber,

0:05:54.540,0:05:59.580
toma el elemento en el lado izquierdo de una regla y reemplaza esto por el

0:05:59.580,0:06:03.960
elementos en el lado derecho de la regla, por lo que un intercambio se convierte en una solicitud y respuesta,

0:06:03.960,0:06:09.600
y ahora ampliamos la solicitud y ahora tomamos la longitud y ampliamos la longitud

0:06:09.600,0:06:14.640
y la longitud es un número entero, de 16 bits, y ahora instanciamos esto,

0:06:14.640,0:06:18.300
saltarse algunas cosas, y decir, bien, la longitud es de 5 bytes.

0:06:19.260,0:06:24.180
Ahora instanciamos los otros elementos también, como la carga útil, por ejemplo.

0:06:24.180,0:06:29.760
Y aquí es donde entra la magia de Isla, porque Isla automáticamente

0:06:29.760,0:06:34.500
satisface estas restricciones. Así que la palabra "hello" tiene cinco bytes, que

0:06:34.500,0:06:39.600
resulta ser la longitud, por lo que todo esto encaja. Y ahora tenemos que instanciar el

0:06:39.600,0:06:42.000
relleno, relleno no es muy interesante, esto es sólo cero bytes,

0:06:42.000,0:06:48.660
y lo que tenemos ahora es una entrada completa y válida que satisface tanto la sintaxis como la semántica.

0:06:48.660,0:06:52.200
Esto es algo que ahora podemos enviar felizmente al servidor

0:06:52.200,0:06:56.040
y el servidor responderá entonces con una respuesta válida

0:06:56.040,0:07:03.480
e Isla puede ahora ir y descomponer esta respuesta, por lo que, de nuevo, analizar a lo largo de las reglas de la gramática

0:07:03.480,0:07:06.420
así que tenemos una longitud, tenemos una carga útil, tenemos un relleno

0:07:06.420,0:07:12.900
y puede identificar lo que estos elementos son, por lo que esta es la longitud y esta es la carga útil

0:07:12.900,0:07:16.620
y aquí tenemos el relleno. Y ahora desde, desde Isla sabe

0:07:16.620,0:07:23.460
lo que el, Isla sabe lo que la carga útil es, entonces en realidad puede ir y también comprobar si

0:07:23.460,0:07:26.280
la restricción de salida se cumple, es decir,

0:07:26.280,0:07:31.860
si el hola, si la carga útil en la solicitud en realidad es idéntica

0:07:31.860,0:07:36.420
a la carga útil en la respuesta. Así que tenemos un intercambio completo aquí,

0:07:36.420,0:07:41.880
y felizmente sabemos que todo funciona. Bueno, la vida es buena, no Heartbleed hoy,

0:07:41.880,0:07:46.560
y como ves esto resuelve dos problemas, dos grandes problemas,

0:07:46.560,0:07:48.240
resuelve, aborda el problema.

0:07:48.240,0:07:52.500
Uno es el problema de la generación de pruebas, es decir, la generación de entradas,

0:07:52.500,0:07:57.240
y el otro es el problema de los oráculos, es decir, la comprobación de las entradas.

0:07:58.380,0:08:03.900
Ahora todo esto es genial para ustedes si son desarrolladores normales, sí, superhéroes y todo eso,

0:08:04.920,0:08:08.700
pero ahora volvamos al título. Hablaba de entradas desagradables,

0:08:08.700,0:08:11.940
no sólo sus entradas vainilla regulares, no,

0:08:11.940,0:08:14.880
estamos hablando hardcore aquí, está bien, vamos a ir,

0:08:14.880,0:08:18.360
vamos a pensar en algo, vamos a pensar en algo que es inusual.

0:08:18.360,0:08:22.800
Así que voy a pedirles que pasen de ser una persona amable normal

0:08:22.800,0:08:26.700
a una persona algo más desagradable, aquí tenemos a la persona desagradable,

0:08:26.700,0:08:30.840
por lo que este es un super villano, y ahora no sólo desea comprobar

0:08:30.840,0:08:32.220
lo que el servidor está haciendo, bueno no,

0:08:32.220,0:08:35.820
ustedes quiere romper el servidor, por lo que es un probador de penetración o

0:08:35.820,0:08:36.960
algo así. Ok, bien,

0:08:36.960,0:08:39.660
por supuesto, este es también es su trabajo como probador para comprobar en contra de eso.

0:08:39.660,0:08:44.220
¿Qué podemos hacer aquí? Vamos a utilizar nuestros superpoderes recién descubiertos

0:08:44.220,0:08:48.360
para crear super super grandes desbordamientos de búfer. Con Isla esto es super fácil, 

0:08:48.360,0:08:51.360
sólo tienes que añadir otra nueva restricción a eso y decir,

0:08:51.360,0:08:54.720
mi carga útil debe ser de al menos 100 millones de bytes.

0:08:54.720,0:08:57.540
Eso debería ser suficiente para desbordar la mayoría de los búferes.

0:08:57.540,0:09:00.780
Aunque no estoy seguro de que esto sea válido. Bueno, podemos averiguarlo fácilmente.

0:09:00.780,0:09:04.860
Acabamos de sintetizar esto y enviamos estos 100 millones de bytes a un servidor cercano

0:09:04.860,0:09:08.400
y entonces sabremos si se estrella o no. Tal vez se va a estrellar,

0:09:08.400,0:09:11.640
tal vez va a funcionar, bueno, vamos a averiguar, no hay problema.

0:09:11.640,0:09:17.130
O vamos a tratar de construir algunas inyecciones SQL. Seguimos siendo desagradable aquí, 

0:09:17.130,0:09:20.100
ustedes probablemente han oído hablar de inyecciones SQL, así que simplemente vamos a decir, bien,

0:09:20.100,0:09:23.040
la carga útil debe ser algo así como "drop table customers"

0:09:23.040,0:09:28.200
y ahí van, ahí van tus clientes. Así que envía 0x1 "drop table customers".

0:09:28.200,0:09:31.560
Ahora supongamos que estas interacciones individuales

0:09:31.560,0:09:34.800
en realidad se registran en una base de datos. Y entonces se obtiene un comando como este

0:09:34.800,0:09:38.520
"insertar valores de registro de carga útil" y luego "drop table customers"

0:09:38.520,0:09:39.780
boom. Usted puede, boom,

0:09:39.780,0:09:44.820
la tabla de clientes en su servidor ha desaparecido. Sí, esto es, estos son ataques reales,

0:09:44.820,0:09:46.680
esto es lo que pasa todo el tiempo, pero ahora ustedes pueden realmente

0:09:46.680,0:09:51.960
prevenirlos comprobándolos ustedes mismo. O vas bien, oh sí, inyección SQL.

0:09:51.960,0:09:54.780
O construyes inyecciones HTML, otra vez lo mismo,

0:09:54.780,0:09:59.880
insertar algunos extra, algunos elementos HTML extra aquí y dicen,

0:09:59.880,0:10:03.060
bien, voy a introducir algunas etiquetas HTML,

0:10:03.060,0:10:07.020
también podrían ser secuencias de comandos para el caso, y sí, hemos enviado eso,

0:10:07.020,0:10:10.560
y si esto se registra lo que va a suceder es que

0:10:10.560,0:10:13.380
ahora, de repente, su registro contiene elementos HTML

0:10:13.380,0:10:17.580
lo que significa que la próxima vez que revisen su registro de repente será interactivo

0:10:17.580,0:10:20.100
elementos en su registro, por ejemplo, el botón de cierre.

0:10:20.100,0:10:23.340
Ahora le añadimos un script que roba la contraseña y demás,

0:10:23.340,0:10:28.440
agarra la captura de pantalla de la pantalla, envía el historial de navegación a quien sea,

0:10:28.440,0:10:30.840
Sip, estos son todas, estos son todas

0:10:30.840,0:10:33.600
cosas que, que los atacantes pueden hacer, y sí,

0:10:33.600,0:10:38.160
también pueden combinar todo esto, pero ahora por fin realmente tienen un medio para, 

0:10:38.160,0:10:40.440
ustedes tienen un medio para combinar todo eso. Bien,

0:10:40.440,0:10:43.740
ustedes pueden venir al instante, pueden venir con una regla para entradas desagradables,

0:10:43.740,0:10:47.580
y por entrada desagradable una entrada de desbordamiento de búfer, entrada de inyección SQL,

0:10:47.580,0:10:49.260
entrada de inyección HTML, sí,

0:10:49.260,0:10:51.060
todo divertido. De acuerdo,

0:10:51.060,0:10:53.820
¿Qué estamos haciendo aquí? ¿Estamos construyendo un arma para los atacantes?

0:10:53.820,0:10:59.520
Ustedes ven que ustedes pueden utilizar todas estas herramientas como un acusado también

0:10:59.520,0:11:05.040
porque ustedes pueden utilizar estas herramientas igual de bien para ver lo que es posible y para

0:11:05.040,0:11:08.940
llegar a toda la creatividad en su mente para evitar que esto suceda en el código de producción.

0:11:09.480,0:11:15.180
Y si te interesan todas estas técnicas, escribir estas cosas, escribir estas gramáticas,

0:11:15.180,0:11:16.980
probando bien, tengo dos libros para ustedes.

0:11:16.980,0:11:20.520
Uno se llama "The Fuzzing Book" el otro se llama "The Debugging Book"

0:11:20.520,0:11:22.260
y si los buscas en Google, lo siento,

0:11:22.260,0:11:26.580
¿somos Microsoft? Si usted Bing ellos o lo que sea,

0:11:26.580,0:11:28.800
si los buscas en Internet los vas a encontrar,

0:11:28.800,0:11:30.900
fuzzingbook.org, debuggingbook.org,

0:11:30.900,0:11:34.980
y con esto me gustaría terminar. Cómo convertirse en un superhéroe de las pruebas:

0:11:34.980,0:11:40.980
especificaciones del lenguaje, entradas desagradables, y por supuesto estos dos libros

0:11:40.980,0:11:44.280
con un bonito código QR que los lleva directamente a un tutorial.

0:11:44.280,0:11:47.340
Si les interesa todo eso hagan una captura de pantalla ahora mismo,

0:11:47.340,0:11:51.780
siganme en la red de Elon Musk o síganme en la

0:11:51.780,0:11:57.780
super agradable red de Mastodon, como quieran, y muchas gracias y estoy feliz de cerrar.

0:11:57.780,0:12:02.040
Gracias. Fantástico,

0:12:02.040,0:12:05.640
muchas gracias, definitivamente se cerró

0:12:05.640,0:12:10.380
su parte del trato en ese caso. Así que realmente aprecio la presentación atractiva.

0:12:10.380,0:12:13.980
Ya tenemos una pregunta que queremos plantear,

0:12:13.980,0:12:17.280
si ustedes tienen preguntas por favor no duden en ponerlas en el Slack y

0:12:17.280,0:12:21.000
serán transmitidos y vamos a pasar a lo largo, e incluso si no tenemos el tiempo para hacerlo,

0:12:21.000,0:12:25.980
nos aseguraremos de que obtengan tus respuestas, pueden contar con ello.

0:12:25.980,0:12:31.560
Así que una de las preguntas que tenemos aquí es, ¿por qué un nuevo lenguaje en lugar de, por ejemplo,

0:12:31.560,0:12:35.880
tiene a la gente expresando las restricciones en Python o algo que ya saben?

0:12:37.380,0:12:40.140
Respuestas múltiples. A, las gramáticas no son un lenguaje nuevo,

0:12:40.140,0:12:44.880
las gramáticas son mucho más antiguas que Python, de hecho Python se especifica como una gramática.

0:12:44.880,0:12:46.860
En segundo lugar, estas restricciones son, bueno,

0:12:46.860,0:12:49.800
muy familiares para cualquiera que sea programador. En tercer lugar,

0:12:49.800,0:12:55.800
quieres una especificación de lenguaje que puedas usar tanto para analizar como para producir

0:12:55.800,0:13:00.240
y esto es algo que un lenguaje de propósito general como Python no puede hacer,

0:13:00.240,0:13:04.920
porque si especifica un productor, por ejemplo, en Python, que produce entradas,

0:13:04.920,0:13:07.560
no se puede utilizar para el análisis sintáctico, no se puede utilizar para la comprobación,

0:13:07.560,0:13:12.660
no se puede utilizar para mutar las cosas, así que tienes que construir este analizador por sí mismo,

0:13:12.660,0:13:15.360
usted también tiene que poner en práctica todas las estrategias de prueba para usted,

0:13:15.360,0:13:21.600
y tener esto en una forma abstracta le permite, le permite desbloquear todas estas estrategias,

0:13:21.600,0:13:27.060
te permite razonar sobre tu código y, bueno, e incluso puede servir como puede incluso servir como

0:13:27.060,0:13:31.500
una documentación independiente del lenguaje de lo que tu programa realmente

0:13:31.500,0:13:34.800
espera en términos de entradas y lo que produce como salidas.

0:13:36.300,0:13:42.780
Fantástico, muchas gracias, no veo más preguntas,

0:13:42.780,0:13:48.300
Quiero hacer una pregunta rápida sobre, tipo de, escalabilidad de este enfoque.

0:13:48.300,0:13:52.560
Así que, como, esto es realmente interesante, y la idea de ser capaz de generar entradas que

0:13:52.560,0:13:57.660
son válidos y no válidos con un lenguaje de especificación creo que es potencialmente revolucionario,

0:13:58.440,0:14:04.620
pero ¿podemos llevar esto a un contexto más simple que no es la comunicación del servidor?

0:14:04.620,0:14:09.720
¿Hay otras maneras en que podríamos utilizar esta especificación para probar cualquiera de nuestros sistemas de software?

0:14:10.260,0:14:12.420
No tiene por qué ser la comunicación del servidor en absoluto.

0:14:12.420,0:14:15.960
Puede reemplazar el servidor por cualquier programa que toma una entrada y luego usted

0:14:15.960,0:14:19.440
puede enviar entradas a este mismo programa. Esta puede ser su entrada de línea de comandos,

0:14:19.440,0:14:24.600
esto puede ser su, lo que sea, su controlador de tren,

0:14:24.600,0:14:27.360
su cosa sistema, lo que sea, así,

0:14:27.360,0:14:30.540
y usted también no tiene que comprobar necesariamente la salida.

0:14:30.540,0:14:33.120
Si puedes vivir sin comprobar la salida, también puedes hacerlo.

0:14:34.080,0:14:39.600
La cosa es que si usted tiene un conjunto muy complejo de restricciones,

0:14:39.600,0:14:43.980
a continuación, la solución de todas estas restricciones tomará tiempo, por lo que va a tomar un minuto más o menos,

0:14:43.980,0:14:47.940
o tal vez incluso más tiempo, y también habrá programas

0:14:47.940,0:14:51.660
para los que la prueba, para que la solución de estas limitaciones será imposible.