Which programming languages support variable variables? Can you give some examples?
Variable variables are a feature found in some programming languages that allow the creation and modification of variables dynamically, based on the value of another variable.

Here are some programming languages that support variable variables:

1. PHP - PHP allows the use of variable variables, which are created by prefixing the name of a variable with a dollar sign ($) twice. Here is an example:
```php
$foo = bar;
$$foo = hello;
echo $bar; // outputs hello
```

2. Perl - In Perl, variable variables are called symbolic references. They can be created using a scalar variable with the name of the variable to reference, prefixed with a dollar sign ($) and enclosed in curly braces. Here is an example:
```perl
my $foo = bar;
${$foo} = hello;
print $bar; # outputs hello
```

3. Bash - In Bash, variable variables are created using the eval command, which evaluates a string as a command. Here is an example:
```bash
foo=bar
bar=hello
eval echo \$$foo # outputs hello
```

It's worth noting that while variable variables can be useful in certain situations, they can also make code harder to read and maintain. As such, it's generally recommended to use them sparingly and only when necessary.
Are these potentially vulnerable to code injection?
Yes, the use of variable variables in programming languages can potentially make code vulnerable to injection attacks.

In PHP, for example, if the value of the variable used to create a variable variable is controlled by an attacker, it can lead to unexpected behavior or security issues. Consider the following example:
```
$user_input = foo;
// An attacker can set $user_input to foo'; phpinfo(); // to execute arbitrary code
```
In this case, an attacker can inject code into the value of $user_input and execute arbitrary code through the variable variable.
Similarly, in Perl, if the value of the scalar variable used to create a symbolic reference is controlled by an attacker, it can lead to similar security issues.
In Bash, the use of eval to create variable variables can also lead to injection vulnerabilities if the input passed to eval is not properly sanitized.
In general, it's important to validate and sanitize any user input that is used to create variable variables, or to avoid using variable variables altogether if possible.