Reporte de Errores
It's not mentioned anywhere, but it seems register globals also affects file uploads.
When a file is uploaded (with in this case, <input type="file" name="coconut">), the following variables appear:
["_FILES"]=>
array(1) {
["coconut"]=>
array(5) {
["name"]=>
string(14) "mozicon128.png"
["type"]=>
string(9) "image/png"
["tmp_name"]=>
string(14) "/tmp/phpWgtRBx"
["error"]=>
int(0)
["size"]=>
int(15113)
}
}
When register globals is turned on, the following variables also appear:
["coconut_name"]=>
string(14) "mozicon128.png"
["coconut_type"]=>
string(9) "image/png"
["coconut"]=>
string(14) "/tmp/phpWgtRBx"
["coconut_size"]=>
int(15113)
Uso de Register Globals
Warning
This feature has been DEPRECATED as of PHP 5.3.0 and REMOVED as of PHP 6.0.0. Relying on this feature is highly discouraged.
Quizás el cambio más controversial en la historia de PHP se ha dado cuando la directiva register_globals pasó de tener como valor por defecto ON al valor OFF en PHP » 4.2.0. La dependencia sobre esta directiva era bastante común y muchas personas nisiquiera estaban enteradas de que existía y asumían que ese era el modo en que PHP trabajaba. Esta página explicará cómo puede llegar a escribirse código inseguro con esta directiva pero tenga en mente que no es la directiva misma la que es insegura sino el uso inapropiado de ella.
Cuando se encuentra activa, la directiva register_globals inyectará sus scripts con todo tipo de variables, como variables de peticiones provenientes de formularios HTML. Esto junto con el hecho de que PHP no requiere la inicialización de variables significa que es muy fácil escribir código inseguro. Fue una decisión difícil, pero la comunidad de PHP decidió desahibilar esta directiva por defecto. Cuando está habilitada, las personas usan variables sin saber con seguridad de dónde provienen y solo queda asumir. Las variables internas que son definidas en el script mismo son mezcladas con los datos enviados por los usuarios y al deshabilitar register_globals se modifica este comportamiento. Demostremos este caso con un ejemplo del uso incorrecto de register_globals:
Example #1 Ejemplo del uso inapropiado de register_globals = on
<?php
// definir $autorizado = true solo si el usuario ha sido autenticado
if (usuario_autenticado()) {
$autorizado = true;
}
// Ya que no inicializamos $autorizado como false, ésta podría estar
// definida a través de register_globals, como en el caso de GET
// auth.php?autorizado=1
// ¡De modo que cualquier persona podría verse como autenticada!
if ($autorizado) {
include "/datos/muy/importantes.php";
}
?>
Cuando register_globals = on, nuestra lógica anterior podría verse comprometida. Cuando la directiva está deshabilitada, $autorizado no puede definirse a través de peticiones, así que no habrá ningún problema, aunque es cierto que siempre es una buena práctica de programación inicializar las variables primero. Por ejemplo, en nuestro ejemplo anterior pudimos haber realizado primero algo como $authorized = false. Hacer esto representa que el código anterior podría funcionar con register_globals establecido a on u off ya que los usuarios no serían autorizados por omisión.
Otro ejemplo es aquel de las sesiones. Cuando register_globals = on, podríamos usar también $nombre_usuario en nuestro siguiente ejemplo, pero nuevamente usted debe notar que $nombre_usuario puede provenir de otros medios, como GET (a través de la URL).
Example #2 Ejemplo del uso de sesiones con register_globals on u off
<?php
// No sabríamos de dónde proviene $nombre_usuario, pero sabemos que
// $_SESSION es para datos de sesión
if (isset($_SESSION['nombre_usuario'])) {
echo "Hola <b>{$_SESSION['nombre_usuario']}</b>";
} else {
echo "Hola <b>Invitado</b><br />";
echo "¿Quisiera iniciar su sesión?";
}
?>
Incluso es posible tomar medidas preventivas para advertir cuando se intente falsificar la información. Si usted sabe previamente con exactitud el lugar de donde debería provenir una variable, usted puede chequear si los datos enviados provienen de una fuente inadecuada. Aunque esto no garantiza que la información no haya sido falsificada, esto requiere que un atacante adivine el medio apropiado para falsificar la información. Si no le importa de dónde proviene la información, puede usar $_REQUEST ya que allí se incluye una mezcla de variables que provienen de datos GET, POST y COOKIE. Consulte también la sección del manual sobre el uso de variables desde fuera de PHP.
Example #3 Detección de envenenamiento simple de variables
<?php
if (isset($_COOKIE['COOKIE_MAGICA'])) {
// COOKIE_MAGICA proviene de una cookie.
// ¡Asegúrese de validar los datos de la cookie!
} elseif (isset($_GET['COOKIE_MAGICA']) || isset($_POST['COOKIE_MAGICA'])) {
mail("admin@example.com", "Posible intento de intromisión",
$_SERVER['REMOTE_ADDR']);
echo "Violación de seguridad, el administrador ha sido alertado.";
exit;
} else {
// COOKIE_MAGICA no fue definida en este REQUEST
}
?>
Por supuesto, deshabilitar register_globals no quiere decir que su código vaya a ser seguro. Por cada trozo de datos que sea enviado por el usuario, éste debe ser chequeado en otras formas. ¡Siempre valide los datos de los usuarios e inicialice sus variables! Para chequear por variables no inicializadas, usted puede usar error_reporting() para mostrar errores del nivel E_NOTICE.
Para más información sobre la emulación del valor On u Off de register_globals, consulte este FAQ.
Note: Superglobals: Nota de disponibilidad
Desde 4.1.0, están disponibles algunas matrices superglobales tales como $_GET, $_POST, y $_SERVER, etc. Para más información puede consultar la sección superglobals
add a note
User Contributed NotesUso de Register Globals
Andrew dot GuertinNO at SPAMuvm dot edu
19-Jun-2009 07:35
19-Jun-2009 07:35
lester burlap
23-Mar-2009 05:00
23-Mar-2009 05:00
It would make this whole issue a lot less confusing for less-experienced PHP programmers if you just explained:
- $myVariable no longer works by default
- $_GET['myVariable'] works just fine
I'm embarrassed to say it's taken me six months since my ISP upgraded to PHP5 figure this out. I've completely rewritten scripts to stop using GET variables altogether.
I'm dumb.
claude dot pache at gmail dot com
15-Jan-2009 01:52
15-Jan-2009 01:52
Beware that all the solutions given in the comments below for emulating register_global being off are bogus, because they can destroy predefined variables you should not unset. For example, suppose that you have
<?php $_GET['_COOKIE'] == 'foo'; ?>
Then the simplistic solutions of the previous comments let you lose all the cookies registered in the superglobal "$_COOKIE"! (Note that in this situation, even with register_global set to "on", PHP is smart enough to not mess predefined variables such as $_COOKIE.)
A proper solution for emulating register_global being off is given in the FAQ, as stated in the documentation above.
subarea AT webfire DOT biz
19-Nov-2008 11:38
19-Nov-2008 11:38
your webspace provider has register-globals activated by standard and you don't have a chance to turn it off? no problem anymore, here is your solution...
<?php
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
// this is just a workaround to kill all through register globals imported vars!
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
// place this script after session_start() to be sure you unregister_globals('_SESSION');
// that's all, now all through "register_globals" assigned vars are deleted from scope.
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
if (ini_get('register_globals') == 1)
{
if (is_array($_REQUEST)) foreach(array_keys($_REQUEST) as $var_to_kill) unset($$var_to_kill);
if (is_array($_SESSION)) foreach(array_keys($_SESSION) as $var_to_kill) unset($$var_to_kill);
if (is_array($_SERVER)) foreach(array_keys($_SERVER) as $var_to_kill) unset($$var_to_kill);
unset($var_to_kill);
}
?>
hope you like it ;)
greetz subarea
georg_gruber at yahoo dot com
27-Oct-2008 09:21
27-Oct-2008 09:21
BEWARE of using register_globals = On, it's not only bad karma but highly dangerous.
Consider the following coding:
<?php
// assume $_SESSION['user'] = array('Hello', 'World');
// assume session_start() was called somewhere before.
print('<pre>Contents of array $_SESSION[\'user\']');
print_r($_SESSION['user']);
print('<hr>Contents of array $user (PHP SETUP register_globals = On)');
print_r($user);
print('</pre>');
?>
If you manipulate $user you'll manipulate $_SESSION['user'] as well with PHP SETUP register_globals = On.
So please avoid it at any cost, no serious programmer would ever want to have register_globals = On.
bohwaz
31-Aug-2008 09:39
31-Aug-2008 09:39
<?php
// Unregister_globals: unsets all global variables set from a superglobal array
// --------------------
// This is useful if you don't know the configuration of PHP on the server the application
// will be run
// Place this in the first lines of all of your scripts
// Don't forget that the register_global of $_SESSION is done after session_start() so after
// each session_start() put a unregister_globals('_SESSION');
function unregister_globals()
{
if (!ini_get('register_globals'))
{
return false;
}
foreach (func_get_args() as $name)
{
foreach ($GLOBALS[$name] as $key=>$value)
{
if (isset($GLOBALS[$key]))
unset($GLOBALS[$key]);
}
}
}
unregister_globals('_POST', '_GET', '_COOKIE', '_REQUEST', '_SERVER', '_ENV', '_FILES');
?>
moore at hs-furtwangen dot de
14-Jul-2008 08:19
14-Jul-2008 08:19
I had a look at the post from Dice, in which he suggested the function unregister_globals(). It didn't seem to work - only tested php 4.4.8 and 5.2.1 - so I made some tweaking to get it running. (I had to use $GLOBALS due to the fact that $$name won't work with superglobals).
<?php
//Undo register_globals
function unregister_globals() {
if (ini_get('register_globals')) {
$array = array('_REQUEST', '_FILES');
foreach ($array as $value) {
if(isset($GLOBALS[$value])){
foreach ($GLOBALS[$value] as $key => $var) {
if (isset($GLOBALS[$key]) && $var === $GLOBALS[$key]) {
//echo 'found '.$key.' = '.$var.' in $'.$value."\n";
unset($GLOBALS[$key]);
}
}
}
}
}
}
?>
The echo was for debuging, thought it might come in handy.
fab dot mariotti at [google]gmail dot com
16-Apr-2008 07:59
16-Apr-2008 07:59
For my application I defined two functions:
wit_set_gv('space','key','value')
wit_get_gv('space','key')
Forgive the "wit_" prefix but the gv stays for Global Variable.
Maybe I should start with a simple version:
wit_set_gv('key','value')
wit_get_gv('key')
This way you would set or get a global/session value.
The register_globals (on or off), session state and/or
superglobal variables will be handled by these functions.
I did add a 'space' item because I wanted to have control
on what goes to/comes from where. As an example if I call:
wit_get_gv('WIT_CONF','URL')
I know that I have to check for a global variable named
WIT_CONF which also gives me a positive responce
on isset($WIT_CONF['URL']). In this case $WIT_CONF
is global and static. But I can also set up a $WIT_STATE
variable which will represent the state of the transaction.
Using the code of WIT_set_gv() and WIT_get_gv(), with the help
of a simple few lines (in my case: include globals.inc.php)
definition script I handle this problem.
In my case, for example, if 'WIT_STATE' (or other names)
is not a defined globally available variable I default to check
for a session variable.
For example you might warn or stop if a requested named variable
matches a $_POST, $_GET or $_SESSION variable name while you
do not expect so. i.e. all my private data has a wit_ prefix
but no public request has (shouldn't have) this prefix.
Oopss. I do realize that this comment might not be in the proper
place. i.e. "register_globals". Indeed it might give some advice
to users still using register_globals and willing to change the
code for a "better" solution. Of course the simple switching to "register_globals = off" might not solve
the securities issues.
Cheers
F
Dice
16-Apr-2008 04:46
16-Apr-2008 04:46
To expand on the nice bit of code Mike Willbanks wrote and Alexander tidied up, I turned the whole thing in a function that removes all the globals added by register_globals so it can be implemented in an included functions.php and doesn't litter the main pages too much.
<?php
//Undo register_globals
function unregister_globals() {
if (ini_get(register_globals)) {
$array = array('_REQUEST', '_SESSION', '_SERVER', '_ENV', '_FILES');
foreach ($array as $value) {
foreach ($GLOBALS[$value] as $key => $var) {
if ($var === $GLOBALS[$key]) {
unset($GLOBALS[$key]);
}
}
}
}
}
?>
Ruquay K Calloway
01-Apr-2008 01:59
01-Apr-2008 01:59
While we all appreciate the many helpful posts to get rid of register_globals, maybe you're one of those who just loves it. More likely, your boss says you just have to live with it because he thinks it's a great feature.
No problem, just call (below defined):
<?php register_globals(); ?>
anywhere, as often as you want. Or update your scripts!
<?php
/**
* function to emulate the register_globals setting in PHP
* for all of those diehard fans of possibly harmful PHP settings :-)
* @author Ruquay K Calloway
* @param string $order order in which to register the globals, e.g. 'egpcs' for default
*/
function register_globals($order = 'egpcs')
{
// define a subroutine
if(!function_exists('register_global_array'))
{
function register_global_array(array $superglobal)
{
foreach($superglobal as $varname => $value)
{
global $$varname;
$$varname = $value;
}
}
}
$order = explode("\r\n", trim(chunk_split($order, 1)));
foreach($order as $k)
{
switch(strtolower($k))
{
case 'e': register_global_array($_ENV); break;
case 'g': register_global_array($_GET); break;
case 'p': register_global_array($_POST); break;
case 'c': register_global_array($_COOKIE); break;
case 's': register_global_array($_SERVER); break;
}
}
}
?>
Tumasch
13-Dec-2007 01:50
13-Dec-2007 01:50
In addition to Mike Willbanks post:
Put this to the beginning of every file or to a functions.inc.php and call it every time before start working with user variables.
This will prevent problems with wrong initalized variables or users who try to break your application.
And this has an extra bonus: Applications which still work are also register_globasl = off enabled!
<?php
//
// If register_globals is on, delete all variables exept the ones in the array
//
if (ini_get('register_globals')) {
foreach ($GLOBALS as $int_temp_name => $int_temp_value) {
if (!in_array($int_temp_name, array (
'GLOBALS',
'_FILES',
'_REQUEST',
'_COOKIE',
'_SERVER',
'_ENV',
'_SESSION',
ini_get('session.name'),
'int_temp_name',
'int_temp_value'
))) {
unset ($GLOBALS[$int_temp_name]);
}
}
}
//
// Now, (re)import the variables
//
if (isset ($_REQUEST['pass']))
$ext_pass = $_REQUEST['pass'];
if (isset ($_REQUEST['user']))
$ext_user = $_REQUEST['user'];
if (isset ($_REQUEST['action']))
$ext_action = $_REQUEST['action'];
//
// Cleanup entries
//
$int_pass = (isset ($ext_pass) ? preg_replace("'[^A-Z]'", "", $ext_pass) : '');
$int_user = (isset ($ext_user) ? preg_replace("'[]A-Za-z0-9áäàâãëèéêïìîóöòôõúüùû \.^\$\!\_-()'", "", $ext_user) : '');
$int_action = (isset ($ext_action) ? intval($ext_action) : '');
//
// Import Session variables
//
if (isset ($_SESSION)) {
foreach ($_SESSION as $int_temp_key => $int_temp_value) {
if ($int_temp_value != '') {
$$int_temp_key = $int_temp_value;
}
}
}
//
// Import Cookie variables
//
if (isset ($_COOKIE)) {
foreach ($_COOKIE as $int_temp_key => $int_temp_value) {
if ($int_temp_value != '') {
$$int_temp_key = $int_temp_value;
}
}
}
//
// From here on, work only with $int_ variables and you're safe!
//
?>
With this you can prevent a lot of different problems!
alan hogan
20-Jul-2007 03:08
20-Jul-2007 03:08
Useful for shared hosting or scripts that you are sharing with other people.
<?php
// Effectively turn off dangerous register_globals without having to edit php.ini
if (ini_get(register_globals)) // If register_globals is enabled
{ // Unset $_GET keys
foreach ($_GET as $get_key => $get_value) {
if (ereg('^([a-zA-Z]|_){1}([a-zA-Z0-9]|_)*$', $get_key)) eval("unset(\${$get_key});");
} // Unset $_POST keys
foreach ($_POST as $post_key => $post_value) {
if (ereg('^([a-zA-Z]|_){1}([a-zA-Z0-9]|_)*$', $post_key)) eval("unset(\${$post_key});");
} // Unset $_REQUEST keys
foreach ($_REQUEST as $request_key => $request_value) {
if (ereg('^([a-zA-Z]|_){1}([a-zA-Z0-9]|_)*$', $request_key)) eval("unset(\${$request_key});");
}
}
?>
dav at thedevelopersalliance dot com
18-Dec-2003 06:38
18-Dec-2003 06:38
import_request_variables() has a good solution to part of this problem - add a prefix to all imported variables, thus almost eliminating the factor of overriding internal variables through requests. you should still check data, but adding a prefix to imports is a start.