One place for hosting & domains

      programas

      Cómo usar subprocess para ejecutar programas externos en Python


      El autor seleccionó el COVID-19 Relief Fund para que reciba una donación como parte del programa Write for DOnations.

      Introducción

      Python 3 incluye el módulo subprocess para ejecutar programas externos y leer sus resultados en su código Python.

      Encontrará subprocess útil si desea usar otro programa en su computadora desde su código Python. Por ejemplo, es posible que desee invocar git desde su código Python para recuperar archivos en su proyecto que tienen un seguimiento por parte del control de versiones de git. Ya que cualquier programa al que acceda en su computadora puede estar controlado por subprocess, los ejemplos mostrados aquí serán aplicables a cualquier programa externo que desee invocar desde su código Python.

      subprocess incluye varias clases y funciones, pero en este tutorial cubriremos una de las funciones más útiles de subprocess: subprocess.run. Revisaremos sus diferentes usos y principales argumentos de palabras clave.

      Requisitos previos

      Para sacar el máximo provecho de este tutorial, se recomienda tener cierta familiaridad con la programación en Python 3. Puede consultar estos tutoriales para obtener la información de fondo necesaria:

      Ejecutar un programa externo

      Puede usar la función subprocess.run para ejecutar un programa externo desde su código Python. Primero, sin embargo, necesitará importar los módulos subprocess y sys a su programa:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "print('ocean')"])

      Si ejecuta esto, recibirá un resultado similar al siguiente:

      Output
      ocean

      Vamos a revisar este ejemplo:

      • sys.executable es la ruta absoluta al ejecutable de Python con el que se invocó su programa en un principio. Por ejemplo, sys.executable podría ser una ruta como /usr/local/bin/python.
      • subprocess.run obtiene una lista de cadenas que consisten en los componentes del comando que estamos intentando ejecutar. Ya que la primera cadena que pasamos es sys.executable, indicamos a subprocess.run que ejecute un nuevo programa Python.
      • El componente -c es una opción de línea de comandos python que le permite pasar una cadena con un programa completo Python para ejecutar. En nuestro caso, pasamos un programa que imprime la cadena ocean.

      Puede pensar en cada entrada de la lista que pasamos a subprocess.run como si estuviese separada por un espacio. Por ejemplo, [sys.executable, "-c", "print('ocean')"] se traduce aproximadamente como /usr/local/bin/python -c "print('ocean')". Observe que subprocess automáticamente pone entre comillas los componentes del comando antes de intentar ejecutarlos sobre el sistema operativo subyacente de forma que, por ejemplo, puede pasar un nombre de archivo que tenga espacios.

      Advertencia: Nunca pase una entrada no confiable a subprocess.run. Ya que subprocess.run tiene la capacidad de realizar comandos arbitrarios en su computadora, los agentes maliciosos pueden usarlo para manipular su computadora de formas inesperadas.

      Capturar resultados desde un programa externo

      Ahora que podemos invocar un programa externo usando subprocess.run, vamos a ver cómo podemos capturar el resultado desde ese programa. Por ejemplo, este proceso podría ser útil si quisiéramos usar git ls-files para crear todos sus archivos guardados actualmente bajo control de versiones.

      Nota: Los ejemplos que se muestran en esta sección requieren Python 3.7 o posterior. En particular, los argumentos de palabra clave capture_output y text fueron añadidos en Python 3.7 cuando se lanzó en junio del 2018.

      Vamos a añadir nuestro ejemplo anterior:

      import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "print('ocean')"], capture_output=True, text=True
)
print("stdout:", result.stdout)
print("stderr:", result.stderr)

      Si ejecutamos este código, obtendremos un resultado como el siguiente:

      Output
      stdout: ocean

stderr:

      Este ejemplo es, en gran medida, el mismo que presentamos en la primera sección: aún estamos ejecutando un subproceso para imprimir ocean. Es sobre todo importante que pasemos los argumentos de palabra clave capture_output=True y text=True a subproecss.run.

      subprocess-run devuelve un objeto subprocess.CompletedProcess que está vinculado a result. El objeto subprocess.CompletedProcess incluye detalles sobre el código de salida del programa externo y su resultado. capture_output=True garantiza que result-stdout y result-stderr se completan con el resultado correspondiente del programa externo. De forma predeterminada, result.stdout y result.stderr están vinculados como bytes, pero el argumento de palabra clave text=True indica a Python que decodifique los bytes en cadenas.

      En la sección de resultado, stdout es ocean (además de la nueva línea final que print añade de forma implícita) y no tenemos stderr.

      Vamos a probar un ejemplo que produce un valor no vacío para stderr:

      import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "raise ValueError('oops')"], capture_output=True, text=True
)
print("stdout:", result.stdout)
print("stderr:", result.stderr)

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output
      stdout:
stderr: Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError: oops

      Este código ejecuta un subproceso de Python que crea de inmediato un ValueError. Cuando inspeccionamos el resultado final, no vemos nada en stdout y un Traceback de nuestro ValueError en stderr. Esto es porque, por defecto, Python escribe el Traceback de la excepción sin administrar a stderr.

      Generar una excepción en un código de salida erróneo

      A veces, es útil generar una excepción si un programa que ejecutamos sale con un código de salida erróneo. Los programas que salen con un código cero se consideran correctos, pero se considera que los programas que salen con un código no cero encontraron un error. Como ejemplo, este patrón podría ser útil si quisiéramos generar una excepción en el caso de que ejecutemos git ls-files es un directorio que realmente no era un repositorio git.

      Podemos usar el argumento de palabra clave check=True para que subprocess.run genere una excepción si el programa externo devuelve un código de salida no cero:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"], check=True)

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output
      Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError: oops
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/subprocess.py", line 512, in run
    raise CalledProcessError(retcode, process.args,
subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Este resultado muestra que ejecutamos un subproceso que generó un error, que se imprime en stderr en nuestro terminal. A continuación, subprocess.run planteó generó un subprocess.CalledProcessError en nuestro nombre en nuestro programa Python principal.

      Alternativamente, el módulo subprocess también incluye el método subprocess.CompletedProcess.check_returncode, que podemos invocar a efectos similares:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"])
result.check_returncode()

      Si ejecutamos este código, recibiremos:

      Output
      Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError: oops
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/subprocess.py", line 444, in check_returncode
    raise CalledProcessError(self.returncode, self.args, self.stdout,
subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Ya que no pasamos check=True a subprocess.run, vinculamos correctamente una instancia subprocess.CompletedProcess a result, a pesar de que nuestro programa salió con un código no cero. Al invocar result.check_returncode(), sin embargo, se genera un subprocess.CalledProcessError porque detecta que el proceso completado salió con un código erróneo.

      Usar timeout para salir de los programas de forma anticipada

      subprocess.run incluye el argumento timeout para permitirle detener un programa externo si tarda demasiado en ejecutarse:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "import time; time.sleep(2)"], timeout=1)

      Si ejecutamos este código, obtendremos un resultado como el siguiente:

      Output
      Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/subprocess.py", line 491, in run
    stdout, stderr = process.communicate(input, timeout=timeout)
  File "/usr/local/lib/python3.8/subprocess.py", line 1024, in communicate
    stdout, stderr = self._communicate(input, endtime, timeout)
  File "/usr/local/lib/python3.8/subprocess.py", line 1892, in _communicate
    self.wait(timeout=self._remaining_time(endtime))
  File "/usr/local/lib/python3.8/subprocess.py", line 1079, in wait
    return self._wait(timeout=timeout)
  File "/usr/local/lib/python3.8/subprocess.py", line 1796, in _wait
    raise TimeoutExpired(self.args, timeout)
subprocess.TimeoutExpired: Command '['/usr/local/bin/python', '-c', 'import time; time.sleep(2)']' timed out after 0.9997982999999522 seconds

      El subproceso que intentamos ejecutar usó la función time.sleep para hibernar durante 2 segundos. Sin embargo, pasamos el argumento de palabra clave timeout=1 a subprocess.run para desconectar nuestro subproceso tras 1 segundo. Esto explica por qué nuestra invocación a subprocess.run finalmente generó una excepción subprocess.TimeoutExpired.

      Tenga en cuenta que el argumento de palabra clave timeout para subprocess.run es aproximado. Python hará todo lo posible para anular el subproceso tras el número de segundos de timeout, pero no será necesariamente exacto.

      Pasar input a programas

      A veces, los programas esperan que se pase una entrada a través de stdin.

      El argumento de palabra clave input a subprocess.run le permite pasar datos al stdin del subproceso. Por ejemplo:

      import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "import sys; print(sys.stdin.read())"], input=b"underwater"
)

      Obtendremos un resultado similar al siguiente tras ejecutar este código:

      Output
      underwater

      En este caso, pasamos los bytes underwater a input. Nuestro subproceso objetivo utilizó sys.stdin para leer lo pasado en stdin (underwater) e imprimió nuestro resultado.

      El argumento de palabra clave input puede ser útil si desea encadenar múltiples invocaciones subprocess.run juntas pasando el resultado de un programa como la entrada de otro.

      Conclusión

      El módulo subprocess es una parte potente de la biblioteca estándar de Python que le permite ejecutar programas externos e inspeccionar sus resultados fácilmente. En este tutorial, aprendió a usar subprocess.run para controlar programas externos, pasar entrada a ellos, analizar sus resultados y comprobar sus códigos de retorno.

      El módulo subprocess expone clases y utilidades adicionales que no abarcamos en este tutorial. Ahora que tiene una base, puede usar la documentación del módulo subprocess para obtener más información sobre otras clases y utilidades disponibles.



      Source link

      Como usar o subprocess para executar programas externos em Python 3


      O autor selecionou a COVID-19 Relief Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O Python 3 inclui o módulo subprocess para executar programas externos e ler suas saídas em seu código Python.

      Você pode achar o subprocess útil se quiser usar outro programa em seu computador dentro do seu código Python. Por exemplo, você pode querer invocar o git dentro do seu código Python para recuperar arquivos em seu projeto que são rastreados no controle de versão git. Como qualquer programa que você possa acessar em seu computador pode ser controlado pelo subprocess, os exemplos mostrados aqui serão aplicáveis a qualquer programa externo que você queira invocar a partir do seu código Python.

      O subprocess inclui várias classes e funções, mas neste tutorial, vamos cobrir uma das funções mais úteis do subprocess: subprocess.run. Vamos revisar seus diferentes usos e principais argumentos de palavra-chave.

      Pré-requisitos

      Para tirar o máximo proveito deste tutorial, recomenda-se ter alguma familiaridade com programação em Python 3. Você pode revisar esses tutoriais para as informações básicas necessárias:

      Executando um programa externo

      Você pode usar a função subprocess.run para executar um programa externo a partir do seu código Python. Primeiro, porém, você precisa importar os módulos subprocess e sys para seu programa:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "print('ocean')"])

      Se você executar isso, receberá uma saída como a seguinte:

      Output
      ocean

      Vamos revisar este exemplo:

      • sys.executable é o caminho absoluto para o executável Python com o qual seu programa foi originalmente invocado. Por exemplo, sys.executable pode ser um caminho como /usr/local/bin/python.
      • subprocess.run recebe uma lista de strings que consistem nos componentes do comando que estamos tentando executar. Como a primeira string que passamos é sys.executable, estamos instruindo subprocess.run a executar um novo programa Python.
      • O componente -c é uma opção de linha de comando python que lhe permite passar uma string com um programa Python inteiro para executar. Em nosso caso, passamos um programa que imprime a string ocean.

      Você pode pensar em cada entrada na lista que passamos para subprocess.run como sendo separadas por um espaço. Por exemplo, [sys.executable, "-c", "print('ocean')"] traduz aproximadamente para /usr/local/bin/python -c "print('ocean')". Observe que o subprocess automaticamente coloca aspas nos componentes do comando antes de tentar executá-los no sistema operacional subjacente para que, por exemplo, você possa passar um nome de arquivo que tenha espaços nele.

      Atenção: nunca passe entrada não confiável para subprocess.run. Como o subprocess.run tem a capacidade de executar comandos arbitrários em seu computador, indivíduos maliciosos podem usá-lo para manipular seu computador de maneiras inesperadas.

      Capturando a saída de um programa externo

      Agora que podemos invocar um programa externo usando subprocess.run, vamos ver como podemos capturar a saída desse programa. Por exemplo, este processo poderia ser útil se quiséssemos usar git ls-files para exibir todos os seus arquivos atualmente armazenados sob o controle de versão.

      Nota: os exemplos mostrados nesta seção exigem Python 3.7 ou superior. Em particular, os argumentos de palavra-chave capture_output e text foram adicionados ao Python 3.7 quando ele foi lançado em junho de 2018.

      Vamos adicionar ao nosso exemplo anterior:

      import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "print('ocean')"], capture_output=True, text=True
)
print("stdout:", result.stdout)
print("stderr:", result.stderr)

      Se executarmos esse código, receberemos um resultado como o seguinte:

      Output
      stdout: ocean

stderr:

      Este exemplo é em grande parte o mesmo que o introduzido na primeira seção: ainda estamos executando um subprocesso para imprimir ocean. É importante ressaltar, no entanto, que passamos os argumentos de palavra-chave capture_output=True e text=True para subprocess.run.

      subprocess.run retorna um objeto subprocess.CompletedProcess que está vinculado a result. O objeto subprocess.CompletedProcess inclui detalhes sobre o código de saída do programa externo e sua saída. capture_output=True garante que result.stdout e result.stderr estejam preenchidos com a saída correspondente do programa externo. Por padrão, result.stdout e result.stderr são vinculados como bytes, mas o argumento de palavra-chave text=True instrui o Python a, em vez disso, decodificar os bytes em strings.

      Na seção output stdout é ocean (mais uma nova linha final que print adiciona implicitamente), e não temos nenhum stderr.

      Vamos tentar um exemplo que produz um valor não vazio para stderr:

      import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "raise ValueError('oops')"], capture_output=True, text=True
)
print("stdout:", result.stdout)
print("stderr:", result.stderr)

      Se executarmos esse código, receberemos uma saída como a seguinte:

      Output
      stdout:
stderr: Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError: oops

      Este código executa um subprocesso Python que imediatamente gera um erro de ValueError. Quando inspecionamos o result final, não vemos nada em stdout e um Traceback de nosso ValueError em stderr. Isso ocorre porque, por padrão, o Python escreve o Traceback da exceção não tratada em stderr.

      Gerando uma exceção em um código de saída ruim

      Às vezes, é útil gerar uma exceção se um programa que executamos termine com um código de saída ruim. Os programas que terminam com um código zero são considerados bem sucedidos, mas programas que terminam com um código não zero são considerados como tendo encontrado um erro. Como um exemplo, esse padrão poderia ser útil se quiséssemos gerar uma exceção no caso em que executamos git ls-files em um diretório que não fosse realmente um repositório git.

      Podemos usar o argumento de palavra-chave check=True para subprocess.run para ter uma exceção gerada se o programa externo retornar um código de saída não zero:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"], check=True)

      Se executarmos esse código, receberemos uma saída como a seguinte:

      Output
      Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError: oops
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/subprocess.py", line 512, in run
    raise CalledProcessError(retcode, process.args,
subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Esta saída mostra que executamos um subprocesso que gerou um erro, que é impresso em stderr em nosso terminal. Em seguida, subprocess.run criou devidamente um subprocess.CalledProcessError por nós em nosso programa Python principal.

      Alternativamente, o módulo subprocess também inclui o método subprocess.CompletedProcess.check_returncode, que podemos invocar para um efeito semelhante:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"])
result.check_returncode()

      Se executarmos este código, receberemos:

      Output
      Traceback (most recent call last):
  File "<string>", line 1, in <module>
ValueError: oops
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/subprocess.py", line 444, in check_returncode
    raise CalledProcessError(self.returncode, self.args, self.stdout,
subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Como não passamos check=True para subprocess.run, vinculamos com sucesso uma instância de subprocess.CompletedProcess a result, mesmo que nosso programa seja encerrado com um código diferente de zero. Chamar result.check_returncode(), no entanto, gera um subprocess.CalledProcessError porque ele detecta que o processo finalizado foi encerrado com um código ruim.

      Usando o timeout para sair de programas mais cedo

      subprocess.run inclui o argumento timeout para permitir que você pare um programa externo se estiver levando muito tempo para executar:

      import subprocess
import sys

result = subprocess.run([sys.executable, "-c", "import time; time.sleep(2)"], timeout=1)

      Se executarmos esse código, receberemos um resultado como o seguinte:

      Output
      Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.8/subprocess.py", line 491, in run
    stdout, stderr = process.communicate(input, timeout=timeout)
  File "/usr/local/lib/python3.8/subprocess.py", line 1024, in communicate
    stdout, stderr = self._communicate(input, endtime, timeout)
  File "/usr/local/lib/python3.8/subprocess.py", line 1892, in _communicate
    self.wait(timeout=self._remaining_time(endtime))
  File "/usr/local/lib/python3.8/subprocess.py", line 1079, in wait
    return self._wait(timeout=timeout)
  File "/usr/local/lib/python3.8/subprocess.py", line 1796, in _wait
    raise TimeoutExpired(self.args, timeout)
subprocess.TimeoutExpired: Command '['/usr/local/bin/python', '-c', 'import time; time.sleep(2)']' timed out after 0.9997982999999522 seconds

      O subprocesso que tentamos executar usou a função time.sleep para colocá-lo em repouso por 2 segundos. No entanto, passamos o argumento de palavra-chave timeout=1 para subprocess.run para expirar nosso subprocesso após 1 segundo. Isso explica por que nossa chamada para subprocess.run finalmente gerou uma exceção subprocess.TimeoutExpired.

      Observe que o argumento de palavra-chave timeout para subprocess.run é aproximado. Python fará um melhor esforço para matar o subprocesso após o número de segundos de timeout, mas ele não será necessariamente exato.

      Passando a entrada para programas

      Às vezes, os programas esperam que a entrada seja passada para eles via stdin.

      O argumento de palavra-chave input para subprocess.run permite que você passe dados para o stdin do subprocesso. Por exemplo:

      import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "import sys; print(sys.stdin.read())"], input=b"underwater"
)

      Receberemos uma saída como a seguinte depois de executar este código:

      Output
      underwater

      Neste caso, passamos os bytes underwater para input. Nosso subprocesso alvo usou sys.stdin para ler o que foi passado em stdin (underwater) e o imprimiu em nossa saída.

      O argumento de palavra-chave input pode ser útil se você quiser encadear várias chamadas subprocess.run juntas passando a saída de um programa como a entrada para outro.

      Conclusão

      O módulo subprocess é uma parte poderosa da biblioteca padrão Python que permite que você execute programas externos e inspecione suas saídas com facilidade. Neste tutorial, você aprendeu a usar subprocess.run para controlar programas externos, passar a entrada para eles, analisar sua saída e verificar seus códigos de retorno.

      O módulo subprocess expõe classes e utilitários adicionais que não abordamos neste tutorial. Agora que você tem um conhecimento básico, você pode usar a documentação do módulo subprocess para aprender mais sobre outras classes e utilitários disponíveis.



      Source link

      Cómo instalar y usar Radamsa para probar programas y servicios de red con fuzzing en Ubuntu 18.04


      El autor seleccionó la Electronic Frontier Foundation Inc para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Las amenazas de seguridad son cada vez más complejas, por lo que los desarrolladores y los administradores de sistemas deben adoptar un enfoque proactivo para defender y probar la seguridad de sus aplicaciones.

      Un método frecuente para probar la seguridad de aplicaciones o servicios de red de clientes es el fuzzing, que implica enviar datos no válidos o con formato incorrecto a la aplicación en cuestión y analizar su respuesta. Es útil para ayudar a probar cuán resistente y sólida es una aplicación ante entradas inesperadas, como datos corruptos o ataques reales.

      Radamsa es una herramienta de fuzzing de código abierto que puede generar casos de prueba basados en datos de entrada especificados por el usuario. Se puede programar mediante scripts por completo y se utiliza para detectar vulnerabilidades en aplicaciones reales, como Gzip, de forma exitosa.

      A través de este tutorial, instalará y utilizará Radamsa para probar aplicaciones de línea de comandos y de red con fuzzing usando sus propios casos de prueba.

      Advertencia: Radamsa es una herramienta de pruebas de penetración que le permite identificar vulnerabilidades o deficiencias en sistemas o aplicaciones determinados. No debe usar las vulnerabilidades que detecte Radamsa para ninguna forma de comportamiento imprudente, daño o explotación malintencionada. Las vulnerabilidades se deben informar de manera ética a la persona encargada del mantenimiento de la aplicación afectada y no se deben divulgar públicamente sin permiso explícito.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      Advertencia: Radamsa puede hacer que aplicaciones o sistemas se ejecuten de forma inestable o se bloqueen, por lo que debe ejecutarlo únicamente en un entorno en el que esté preparado para esto, como un servidor dedicado. Asegúrese también de contar con el permiso explícito por escrito del propietario del sistema que probará con fuzzing antes proceder.

      Una vez que tenga todo esto listo, inicie sesión en su servidor como usuario no root.

      Paso 1: Instalar Radamsa

      Primero, descargará y compilará Radamsa para comenzar a utilizarlo en su sistema. El código fuente de Radamsa está disponible en el repositorio oficial de GitLab.

      Comience actualizando el índice de paquetes locales de modo que se refleje cualquier cambio anterior:

      Luego, instalará los paquetes gcc, git, make y wget necesarios para compilar el código fuente en un binario ejecutable:

      • sudo apt install gcc git make wget

      Después de confirmar la instalación, apt descargará e instalará los paquetes específicos y todas sus dependencias necesarias.

      A continuación, descargará una copia del código fuente de Radamsa clonándolo del repositorio alojado en GitLab:

      • git clone https://gitlab.com/akihe/radamsa.git

      Al hacerlo, se creará un directorio llamado radamsa que contendrá el código fuente de la aplicación. Diríjase al directorio para comenzar a compilar el código:

      Luego, puede iniciar el proceso de compilación usando make:

      Por último, puede instalar el binario de Radamsa compilado en su $PATH:

      Una vez completado esto, puede verificar la versión instalada para asegurar que todo funcione:

      El resultado debe tener un aspecto similar al siguiente:

      Output
      Radamsa 0.6

      Si ve el error radamsa: command not found, verifique que todas las dependencias necesarias se hayan instalado y que no se haya habido errores durante la compilación.

      Ahora que instaló Radamsa, puede comenzar a generar algunos casos de prueba de muestra para comprender el funcionamiento de Radamsa y sus aplicaciones.

      Paso 2: Generar casos de prueba con fuzzing

      Ahora que instaló Radamsa, puede usarlo para generar casos de pruebas con fuzzing.

      Un caso de prueba es información que se utilizará como entrada para el programa que someta a prueba. Por ejemplo, si prueba con fuzzing un programa de archivo, como Gzip, un caso de prueba puede ser un archivo de almacenamiento que intente descomprimir.

      Nota: Radamsa manipula los datos de entrada de una gran variedad de formas inesperadas, como la repetición extrema, la inversión de bits y la inserción de caracteres de control, entre otras. Antes de proceder, tenga en cuenta que esto puede hacer que su sesión de terminal se interrumpa o se vuelva inestable.

      Primero, pase un texto sencillo a Radamsa para ver lo que sucede:

      • echo "Hello, world!" | radamsa

      Con esto, se manipularán (o expondrán a fuzzing) los datos ingresados y se generará un caso de prueba, como el siguiente:

      Output
      Hello,, world!

      En este caso, Radamsa agregó una coma adicional entre Hello y world. A pesar de que no parezca un cambio significativo, en algunas aplicaciones, esto puede hacer que los datos se interpreten de forma incorrecta.

      Hagamos un nuevo intento ejecutando el mismo comando. Obtendrá un resultado distinto:

      Output
      Hello, '''''''wor'd!

      Esta vez, se insertaron varias comillas simples (') en la cadena, entre ellas, una que sobrescribió la l en world. Las posibilidades de que este caso de prueba en particular genere problemas en aplicaciones son más altas, dado que se suelen utilizar comillas simples y dobles para separar diferentes porciones de datos de una lista.

      Probemos una vez más:

      Output
      Hello, $+$PATHu0000`xcalc`world!

      En este caso, Radamsa insertó una cadena de inserción de shell, que será útil para realizar pruebas en busca de vulnerabilidades de inserción de comandos en la aplicación que pruebe.

      Usó Radamsa para someter a fuzzing una cadena de entrada y producir una serie de casos de prueba. A continuación, utilizará Radamsa para someter a fuzzing una aplicación de línea de comandos.

      Paso 3: Someter a fuzzing una aplicación de línea de comandos

      En este paso, utilizará Radamsa para aplicar fuzzing a una aplicación de línea de comandos e informar los bloqueos que se produzcan.

      La técnica exacta para hacer pruebas con fuzzing varía en gran medida de un programa a otro, así como la eficacia de cada método. Sin embargo, en este tutorial usaremos jq como ejemplo, que es un programa de línea de comandos para procesar datos de JSON.

      Puede usar cualquier otro programa similar siempre y cuando aplique el principio general de tomar algún tipo de datos estructurados o no estructurados, hacer algo con ellos y luego producir un resultado. Por ejemplo, este caso también funcionaría con Gzip, Grep, bc y tr, entre otros.

      Si aún no instaló jq, puede hacerlo usando apt:

      De esta manera, jq quedará instalado.

      Para comenzar la prueba con fuzzing, cree un archivo JSON de ejemplo que utilizará como entrada para Radamsa:

      Luego, añada los siguientes datos de JSON de ejemplo al archivo:

      test.json

      {
  "test": "test",
  "array": [
    "item1: foo",
    "item2: bar"
  ]
}

      Puede analizar este archivo usando jq si desea verificar que la sintaxis de JSON sea válida:

      Si el JSON es válido, jq mostrará el archivo. De lo contrario, mostrará un error que puede usar para corregir la sintaxis cuando sea necesario.

      A continuación, aplique fuzzing al archivo JSON de prueba usando Radamsa y, luego, páselo a jq. Esto hará que jq lea el caso de prueba sometido a fuzzing o manipulado en lugar de los datos JSON originales válidos.

      Si Radamsa muestra los datos de JSON de una forma que siga siendo válida desde el punto de vista sintáctico, jq mostrará los datos, pero con los cambios que le haya realizado Radamsa.

      Alternativamente, si Radamsa hace que los datos de JSON no sean válidos, jq mostrará un error que corresponda. Por ejemplo:

      Output
      parse error: Expected separator between values at line 5, column 16

      El resultado alternativo sería que jq no pudiera manejar los datos sometidos a fuzzing de forma correcta, lo cual haría que se bloqueara o no funcionara de forma adecuada. Esto es lo que realmente se busca con el método de fuzzing, ya que podría indicar una vulnerabilidad de seguridad, como un desbordamiento de búfer o una inserción de comandos.

      Para realizar pruebas de detección de vulnerabilidades como estas de forma más eficiente, se puede usar una secuencia de comandos de Bash a fin de automatizar el proceso de fuzzing, incluidos los procesos de generar casos de prueba, pasarlos al programa de destino y detectar cualquier resultado pertinente.

      Cree un archivo llamado jq-fuzz.sh:

      El contenido exacto de la secuencia de comandos variará según el tipo de programa que someta a fuzzing y los datos de entrada. Sin embargo, en el caso de jq y otros programas similares, la secuencia de comandos siguiente será suficiente.

      Copie la secuencia de comandos a su archivo jq-fuzz.sh:

      jq-fuzz.sh

      #!/bin/bash
while true; do
  radamsa test.json > input.txt
  jq . input.txt > /dev/null 2>&1
  if [ $? -gt 127 ]; then
    cp input.txt crash-`date +s%.%N`.txt
    echo "Crash found!"
  fi
done

      Esta secuencia de comandos contiene while para hacer que el contenido se repita reiteradamente. Cada vez que se repita la secuencia de comandos, Radamsa generará un caso de prueba basado en test.json y lo guardará en input.txt.

      Luego, el caso de prueba input.txt se ejecutará en jq y todo el resultado estándar y de error se reenviará a /dev/null para evitar saturar la pantalla del terminal.

      Por último, se verifica el valor de salida de jq. Si el valor de salida es superior a 127, esto indica una interrupción irrecuperable (un bloqueo), por lo que los datos de entrada se guardan para su análisis posterior en un archivo llamado crash- seguido de la fecha actual en segundos y nanosegundos de Unix.

      Marque la secuencia de comandos como ejecutable y ejecútela para comenzar a probar jq con fuzzing de forma automática:

      • chmod +x jq-fuzz.sh

      • ./jq-fuzz.sh

      Puede pulsar CTRL+C en cualquier momento para finalizar la secuencia de comandos. Luego, puede verificar si se encontraron errores utilizando ls para mostrar una lista de directorios en la que se encuentran los archivos de bloqueos que se hayan creado.

      Se recomienda mejorar los datos de JSON de entrada, dado que probablemente el uso de un archivo de entrada más complejo mejore la calidad de los resultados de la aplicación de fuzzing. Evite usar un archivo grande o uno que contenga muchos datos repetidos; lo ideal es usar un archivo de entrada que sea pequeño y, no obstante, tenga la mayor cantidad de elementos “complejos” posible. Por ejemplo, un buen archivo de entrada debe contener muestras de datos almacenados en todos los formatos, incluso cadenas, enteros, booleanos, listas, objetos y datos anidados si es posible.

      Utilizó Radamsa para probar una aplicación de línea de comandos con fuzzing. A continuación, utilizará Radamsa para probar solicitudes a servicios de red.

      Paso 4: Probar solicitudes a servicios de red con fuzzing

      Radamsa también se puede utilizar para probar servicios de red, ya sea como cliente o servidor de red. En este paso, utilizará Radamsa para probar un servicio de red con fuzzing y Radamsa funcionará como cliente.

      El propósito de probar servicios de red con fuzzing es determinar cuán resistente es un servicio de red en particular ante el envío de datos maliciosos o con formato incorrecto. Muchos servicios de red, como los servidores web o DNS, suelen estar expuestos a Internet, lo cual los convierte en un objetivo común para los atacantes. Un servicio de red que no sea suficientemente resistente a la recepción de datos con formato incorrecto puede bloquearse o, lo que sería peor aún, fallar en estado abierto. Esto podría permitir a los atacantes leer datos confidenciales, como claves de cifrado o datos de usuarios.

      Si bien la técnica específica para probar servicios de red con fuzzing varía en gran medida según el servicio de red, en este ejemplo usaremos Radamsa para probar un servidor web básico que proporciona contenido HTML estático.

      Primero, debe configurar el servidor web para su uso en pruebas. Puede hacerlo usando el servidor de desarrollo incorporado que viene con el paquete php-cli. También necesitará curl para probar su servidor web.

      Si no tiene php-cli ni curl instalados, puede instalarlos usando apt:

      • sudo apt install php-cli curl

      A continuación, cree un directorio para almacenar los archivos de su servidor web y posiciónese en él:

      Luego, cree un archivo HTML que contenga texto de ejemplo:

      Añada lo siguiente al archivo:

      index.html

      <h1>Hello, world!</h1>

      Ahora, podrá ejecutar su servidor web de PHP. Tendrá que poder ver el registro del servidor web mientras siga utilizando otra sesión de terminal. Por ello, abra otra sesión y aplique SSH al servidor para lo siguiente:

      • cd ~/www

      • php -S localhost:8080

      Con esto, se mostrará algo similar a lo siguiente:

      Output
      PHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan  1 16:06:41 2020
Listening on http://localhost:8080
Document root is /home/user/www
Press Ctrl-C to quit.

      Ahora, podrá regresar a su sesión de terminal original y verificar que el servidor web esté funcionando mediante curl:

      Con esto, se mostrará el archivo de ejemplo index.html que creó anteriormente:

      Output
      <h1>Hello, world!</h1>

      Solo se debe poder acceder a su servidor web de forma local, por lo que no debe abrir ningún puerto en su firewall para él.

      Ahora que configuró su servidor web de prueba, podrá comenzar a realizar pruebas con fuzzing utilizando Radamsa.

      Primero, deberá crear una solicitud HTTP de ejemplo a fin de usarla como información de entrada para Radamsa. Cree un archivo nuevo para almacenar esto en la siguiente ubicación:

      Luego, copie la siguiente solicitud HTTP de ejemplo al archivo:

      http-request.txt

      GET / HTTP/1.1
Host: localhost:8080
User-Agent: test
Accept: */*

      A continuación, puede usar Radamsa para enviar esta solicitud HTTP a su servidor web local. Para hacerlo, deberá usar Radamsa como cliente TCP, lo que se puede hacer especificando una dirección IP y un puerto para establecer conexión:

      • radamsa -o 127.0.0.1:8080 http-request.txt

      Nota: Tenga en cuenta que usar Radamsa como cliente TCP, puede hacer que se transmitan datos maliciosos o con formato incorrecto a través de la red. Esto puede provocar errores; por ello, debe asegurarse de acceder únicamente a las redes que tenga permitido probar o, preferentemente, aténgase a utilizar la dirección de host local (127.0.0.1).

      Por último, si ve los registros de salida de su servidor web local observará que recibió las solicitudes, pero probablemente no las haya procesado porque no eran válidas o tenían un formato incorrecto.

      Los registros de salida se mostrarán en su segunda ventana de terminal:

      Output
      [Wed Jan  1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

      Para obtener resultados óptimos y asegurarse de que los bloqueos se registren, es conveniente escribir una secuencia de comandos de automatización similar a la que se utilizó en el paso 3. También debe considerar la posibilidad de usar un archivo de entrada más complejo, que puede contener elementos añadidos, como encabezados HTTP adicionales.

      De esta manera, probó un servicio de red con fuzzing usando Radamsa como cliente TCP. A continuación, probará a un cliente de red utilizando Radamsa como servidor.

      Paso 5: Probar aplicaciones clientes de red con fuzzing

      En este paso, utilizará Radamsa para probar una aplicación cliente de red con fuzzing. Esto se logra interceptando respuestas de un servicio de red y sometiéndolas a fuzzing antes de que las reciba el cliente.

      El propósito de este tipo de fuzzing es probar la resistencia de las aplicaciones clientes de red a la recepción de datos maliciosos o de formato incorrecto de servicios de red. Por ejemplo, probará un navegador web (cliente) que recibirá HTML con formato incorrecto de un servidor web (servicio de red) o un cliente DNS que recibirá respuestas DNS con formato incorrecto de un servidor DNS.

      Al igual que en el caso de aplicaciones de línea de comandos o servicios de red, la técnica exacta para probar con fuzzing cada aplicación cliente de red varía considerablemente. Sin embargo, en este ejemplo utilizará whois, una aplicación de envío y recepción simple basada en TCP.

      La aplicación whois se utiliza para enviar solicitudes a servidores WHOIS y recibir registros WHOIS como respuesta. WHOIS funciona a través del puerto TCP 43 con texto no cifrado, por lo que es ideal para realizar pruebas con fuzzing en redes.

      Si aún no cuenta con whois, puede instalarlo usando apt:

      Primero, deberá adquirir una respuesta whois de muestra para usarla como dato de entrada. Puede hacerlo enviando una solicitud whois y guardando el resultado en un archivo. Puede usar cualquier dominio que desee, dado que probará el programa whois de forma local con datos de muestra:

      • whois example.com > whois.txt

      A continuación, deberá configurar Radamsa como un servidor que proporcione versiones distorsionadas de esta respuesta whois. Deberá poder continuar usando su terminal una vez que Radamsa esté en ejecución en el modo de servidor, por lo que se recomienda abrir otra sesión de terminal y conexión SSH con su servidor para lo siguiente:

      • radamsa -o :4343 whois.txt -n inf

      Con esto, Radamsa se ejecutará en el modo de servidor TCP y enviará una versión de whois.txt sometida a fuzzing cada vez que se establezca una conexión con el servidor, independientemente de los datos de solicitud que se reciban.

      Ahora, puede proceder con la prueba de la aplicación cliente whois. Deberá realizar una solicitud whois normal para cualquier dominio que prefiera (no es necesario que sea el mismo al que se aplican los datos de muestra), pero con whois apuntando a su servidor de Radamsa local:

      • whois -h localhost:4343 example.com

      Recibirá como respuesta sus datos de muestra, aunque distorsionados por Radamsa. Puede continuar realizando solicitudes al servidor local mientras Radamsa esté en ejecución. Este enviará una respuesta diferente en cada ocasión.

      Al igual que con los servicios de red, para mejorar la eficacia de estas pruebas del cliente de red con fuzzing y asegurarse de que se registren los bloqueos, es conveniente escribir una secuencia de comandos de automatización similar a la que se utilizó en el paso 3.

      En este paso final, utilizó Radamsa para probar una aplicación cliente de red con fuzzing.

      Conclusión

      A través de este artículo, configuró Radamsa y lo utilizó para probar una aplicación de línea de comandos, un servicio de red y un cliente de red. Ahora tiene los conocimientos básicos necesarios para probar sus propias aplicaciones con fuzzing y mejorar su solidez y resistencia contra ataques.

      Si desea explorar Radamsa en mayor profundidad, puede revisar el archivo README de Radamsa de forma detallada; contiene más información técnica y ejemplos relacionados con los usos posibles de la herramienta:

      También puede probar otras herramientas de fuzzing como American Fuzzy Lop (AFL), una herramienta de fuzzing avanzada diseñada para probar aplicaciones binarias con una velocidad y una precisión sumamente altas:



      Source link

      Forgot Your Password ?