Cómo usar eval en Linux Bash Scripts

De todos los comandos de Bash, pobre viejo eval probablemente tiene la peor reputación. ¿Justificado o simplemente mala prensa? Discutimos el uso y los peligros de este menos querido de los comandos de Linux.

Necesitamos hablar sobre la evaluación

Usado sin cuidado, eval puede conducir a un comportamiento impredecible e incluso a inseguridades en el sistema. Por lo que parece, probablemente no deberíamos usarlo, ¿verdad? Bueno, no del todo.

Se podría decir algo similar sobre los automóviles. En las manos equivocadas, son un arma mortal. La gente los usa en ataques de ariete y como vehículos de huida. ¿Deberíamos todos dejar de usar automóviles? No claro que no. Pero tienen que ser utilizados correctamente y por personas que sepan conducirlos.

El adjetivo habitual aplicado a eval es "malvado". Pero todo se reduce a cómo se usa. los eval comando coteja el valores de una o más variables. Crea una cadena de comandos. Luego ejecuta ese comando. Esto lo hace útil cuando necesita hacer frente a situaciones en las que el contenido de un comando se deriva dinámicamente durante la ejecución de su secuencia de comandos.

Los problemas surgen cuando se escribe un script para usar eval en una cadena que se ha recibido de algún lugar fuera de la secuencia de comandos. Puede ser ingresado por un usuario, enviado a través de una API, etiquetado en una solicitud HTTPS o en cualquier otro lugar externo al script.

Si la cadena que eval va a funcionar no se derivó localmente y mediante programación, existe el riesgo de que la cadena contenga instrucciones maliciosas incrustadas u otra entrada mal formada. Obviamente, no quieres eval para ejecutar comandos maliciosos. Entonces, para estar seguro, no use eval con cadenas generadas externamente o entrada del usuario.

Primeros pasos con eval

los eval El comando es un comando de shell Bash integrado. Si Bash está presente, eval estará presente.

eval concatena sus parámetros en una sola cadena. Utilizará un solo espacio para separar elementos concatenados. Evalúa los argumentos y luego pasa la cadena completa al shell para ejecutar.

Vamos a crear una variable llamada wordcount.

wordcount="wc -w raw-notes.md"

La variable de cadena contiene un comando para contar las palabras en un archivo llamado "raw-notes.md".

Nosotros podemos usar eval para ejecutar ese comando pasándole el valor de la variable

El comando se ejecuta en el shell actual, no en un subshell. Podemos mostrar esto fácilmente. Tenemos un archivo de texto corto llamado "variables.txt". Contiene estas dos líneas.

first=How-To
second=Geek

usaremos cat para enviar estas líneas a la ventana del terminal. Entonces usaremos eval para evaluar un cat comando para que se actúe sobre las instrucciones dentro del archivo de texto. Esto establecerá las variables para nosotros.

cat variables.txt
eval "$(cat variables.txt)"
echo $first $second

Mediante el uso echo para imprimir los valores de las variables podemos ver que eval El comando se ejecuta en el shell actual, no en un subshell.

Un proceso en una subcapa no puede cambiar el entorno de la capa principal. Debido a que eval se ejecuta en el shell actual, las variables establecidas por eval son utilizables desde el shell que lanzó el eval dominio.

Tenga en cuenta que si utiliza eval en un script, el caparazón que sería alterado por eval es el subshell en el que se ejecuta el script, no el shell que lo inició.

RELACIONADO: Cómo usar los comandos cat y tac de Linux

Uso de variables en la cadena de comandos

Podemos incluir otras variables en las cadenas de comandos. Estableceremos dos variables para contener números enteros.

num1=10 
num2=7

Crearemos una variable para contener un expr comando que devolverá la suma de dos números. Esto significa que necesitamos acceder a los valores de las dos variables enteras en el comando. Tenga en cuenta los acentos graves alrededor de la expr declaración.

add="`expr $num1 + $num2`"

Crearemos otro comando para que nos muestre el resultado de la expr declaración.

show="echo"

Tenga en cuenta que no necesitamos incluir un espacio al final del echo cadena, ni al comienzo de la expr cuerda. eval se encarga de eso.

Y para ejecutar todo el comando usamos:

eval $show $add

Los valores de las variables dentro de la expr cadena se sustituyen en la cadena por eval antes de que se pase al shell para que se ejecute.

RELACIONADO: Cómo trabajar con variables en Bash

Acceso a variables dentro de variables

Puede asignar un valor a una variable y luego asignar el nombre de esa variable a otra variable. Usando evalpuede acceder a la valor contenida en la primera variable, de su nombre que es el valor almacenado en la segunda variable. Un ejemplo le ayudará a desenredar eso.

Copie este script en un editor y guárdelo como un archivo llamado "assign.sh".

#!/bin/bash

title="How-To Geek"
webpage=title
command="echo"
eval $command ${$webpage}

Tenemos que hacerlo ejecutable con el chmod dominio.

chmod +x assign.sh

Deberá hacer esto para cualquier secuencia de comandos que copie de este artículo. Simplemente use el nombre de script apropiado en cada caso.

Cuando ejecutamos nuestro script vemos el texto de la variable title a pesar de eval el comando está usando la variable webpage.

./assign.sh

El signo de dólar escapado"$"Y los frenos"{}"Hacer que eval mire el valor contenido dentro de la variable cuyo nombre está almacenado en el webpage variable.

Uso de variables creadas dinámicamente

Nosotros podemos usar eval para crear variables dinámicamente. Este script se llama "loop.sh".

#!/bin/bash

total=0
label="Looping complete. Total:"

for n in {1..10}
do
  eval x$n=$n
  echo "Loop" $x$n
  ((total+=$x$n))
done

echo $x1 $x2 $x3 $x4 $x5 $x6 $x7 $x8 $x9 $x10

echo $label $total

Crea una variable llamada total que contiene la suma de los valores de las variables que creamos. Luego crea una variable de cadena llamada label. Esta es una simple cadena de texto.

Vamos a repetir 10 veces y crear 10 variables llamadas x1 hasta x10. los eval declaración en el cuerpo del bucle proporciona la "x" y toma el valor del contador del bucle $n para crear el nombre de la variable. Al mismo tiempo, establece la nueva variable en el valor del contador de bucle. $n.

Imprime la nueva variable en la ventana del terminal y luego incrementa la total variable con el valor de la nueva variable.

Fuera del bucle, las 10 nuevas variables se imprimen una vez más, todas en una línea. Tenga en cuenta que también podemos referirnos a las variables por sus nombres reales, sin usar una versión calculada o derivada de sus nombres.

Finalmente, imprimimos el valor de la total variable.

./loop.sh

RELACIONADO: Introducción: Bash Loops: for, while y till

Uso de eval con arreglos

Imagine un escenario en el que tiene un script que se ejecuta durante mucho tiempo y realiza algún procesamiento por usted. Escribe en un archivo de registro con un nombre creado a partir de una marca de tiempo. De vez en cuando, se iniciará un nuevo archivo de registro. Cuando finaliza el script, si no ha habido errores, borra los archivos de registro que ha creado.

No quieres que simplemente rm *.log, solo desea que elimine los archivos de registro que ha creado. Este script simula esa funcionalidad. Este es "clear-logs.sh".

#!/bin/bash

declare -a logfiles

filecount=0 
rm_string="echo"

function create_logfile() {
  ((++filecount))
  filename=$(date +"%Y-%m-%d_%H-%M-%S").log
  logfiles[$filecount]=$filename
  echo $filecount "Created" ${logfiles[$filecount]}
}

# body of the script. Some processing is done here that
# periodically generates a log file. We'll simulate that
create_logfile
sleep 3
create_logfile
sleep 3
create_logfile
sleep 3
create_logfile

# are there any files to remove?
for ((file=1; file<=$filecount; file++))
do
  # remove the logfile
  eval $rm_string ${logfiles[$file]} "deleted..."
  logfiles[$file]=""
done

El script declara una matriz llamada logfiles . Esto contendrá los nombres de los archivos de registro creados por el script. Declara una variable llamada filecount . Esto contendrá la cantidad de archivos de registro que se han creado.

También declara una cadena llamada rm_string. En un script del mundo real, esto contendría el rm comando, pero estamos usando echo para que podamos demostrar el principio de una manera no destructiva.

La función create_logfile() es donde se nombra cada archivo de registro y donde se abriría. Solo estamos creando el Nombre del archivoy simulando que se ha creado en el sistema de archivos.

La función incrementa la filecount variable. Su valor inicial es cero, por lo que el primer nombre de archivo que creamos se almacena en la posición uno de la matriz. Esto se hace a propósito, como veremos más adelante.

El nombre del archivo se crea usando el date comando y la extensión “.log”. El nombre se almacena en la matriz en la posición indicada por filecount. El nombre se imprime en la ventana del terminal. En un script del mundo real, también crearía el archivo real.

El cuerpo del script se simula usando el sleep dominio. Crea el primer archivo de registro, espera tres segundos y luego crea otro. Crea cuatro archivos de registro, espaciados para que las marcas de tiempo en sus nombres de archivo sean diferentes.

Finalmente, hay un bucle que elimina los archivos de registro. El archivo de contador de bucles se establece en uno. Cuenta hasta e incluyendo el valor de filecountque contiene el número de archivos que se crearon.

Si filecount todavía está configurado en cero, porque no se crearon archivos de registro, el cuerpo del ciclo nunca se ejecutará porque uno no es menor o igual a cero. es por eso que el filecount la variable se estableció en cero cuando se declaró y por qué se incrementó antes de se creó el primer archivo.

Dentro del ciclo, usamos eval con nuestro no destructivo rm_string y el nombre del archivo que se recupera de la matriz. Luego establecemos el elemento de la matriz en una cadena vacía.

Esto es lo que vemos cuando ejecutamos el script.

./clear-logs.sh

No todo es malo

muy difamado eval definitivamente tiene sus usos. Como la mayoría de las herramientas, si se usa de manera imprudente, es peligrosa y en más de un sentido.

Si se asegura de que las cadenas en las que funciona se crean internamente y no se capturan de humanos, API o cosas como solicitudes HTTPS, evitará las principales trampas.

RELACIONADO: Cómo mostrar la fecha y la hora en la terminal de Linux (y usarla en scripts Bash)