网络安全自学篇-PHP代码审计（二）

一个网络安全学习爱好者在学习过程中记录下的笔记，希望在CSDN能和大家一起成长，学习，分享，进步，下面分享的是我搜集的一些关于字符串的各种函数，数组，类和正则，希望对入门代码审计的朋友们有所帮助，大神有兴趣看看即可，勿喷感谢，同时也欢迎各位师傅私聊交流学习。文章有所参考，也感谢教授我网安知识的师父们，感谢出生在这个互联网时代，知识触手可及。

认识函数

一、字符串操作函数
1、查找

//strchr()查找字符串在另一字符串中第一次出现的位置，并返回剩余字符串
echo "strchr:Hello world!-->".strchr("Hello world!","world")."\n";
//stristr()查找字符串在另一字符串中第一次出现的位置，并返回剩余字符串（大小写不敏感）
echo "stristr:Hello world!-->".stristr("Hello world!","wo")."\n";
//strstr()在字符串中搜索指定字符，并返回字符串从指定字符第一次出现的位置开始的剩余部分
echo "strstr:Hello world!-->".strstr("Hello world!","world")."\n";
//strpos()查找字符串在另一字符串中第一次出现的位置（大小写敏感）
echo "strpos:Hello world!-->".strpos("Hello world!","wo")."\n";
//stripos()返回字符串在另一字符串中第一次出现的位置（大小写不敏感）
echo "stripos:Hello world!-->".stripos("Hello world!","wo")."\n";
//strrpos()查找字符串在另一字符串中最后一次出现的位置(大小写敏感)
echo "strrpos:Hello world!-->".strrpos("Hello world!","L")."\n";
//strripos()查找字符串在另一字符串中最后一次出现的位置(大小写不敏感)
echo "strripos:Hello world!-->".strripos("Hello world!","l")."\n";
//strcspn()返回字符串在找到任何指定的字符之前的字符数量
echo "strcspn:Hello world!-->".strcspn("Hello world!","w")."\n";
//strpbrk()在字符串中搜索指定字符，并返回字符串从指定字符第一次出现的位置开始的剩余部分
echo "strpbrk:Hello world!-->".strpbrk("Hello world!","oe")."\n";
//str_word_count()计算字符串中的单词数
echo "str_word_count:Hello world!-->".str_word_count("Hello world!")."\n";

2、截取

//chop()从字符串右端删除字符，注意是右端
echo "chop:Hello world!-->".chop("Hello world!","world!")."\n";
//trim()移除字符串两侧的指定字符
echo "trim:Hello world!-->".trim(" Hello world! "," ")."\n";
//ltrim()从字符串左端删除字符，注意是左端
echo "ltrim:Hello world!-->".ltrim("Hello world!","Hello")."\n";
//ltrim()从字符串右端删除字符，注意是右端
echo "rtrim:Hello world!-->".rtrim("Hello world!","world!")."\n";
//ord()返回字符串中第一个字符的 ASCII 值
echo "ord:Hello world!-->".ord("Hello world!")."\n";
//strtok()把字符串分割为更小的字符串
echo "strtok:Hello world!-->".strtok("Hello world!","w")."\n";
//substr()返回从指定位置开始的剩余字符串
echo "substr:Hello world!-->".substr("Hello world!",6)."\n";
//mb_substr()返回中文字符串从指定位置开始的几个字符串,中文占3字节
echo "mb_substr:Hello world!-->".mb_substr("你好世界",0,6)."\n";

3、替换

//addcslashes()在指定字符前添加反斜杠
echo "addcslashes:Hello world!-->".addcslashes("Hello world!","w")."\n";
//addslashes() 在预定义的字符前添加反斜杠的字符串，如',",\,NULL
echo "addslashes:Hello world!-->".addslashes('Hello \ "world!"')."\n";
//bin2hex() 转换为十六进制值
echo "bin2hex:Hello world!-->".bin2hex("Hello world!")."\n";
//hex2bin() 把十六进制值转换为 ASCII 字符
echo "hex2bin:48656c6c6f20576f726c6421-->".hex2bin("48656c6c6f20576f726c6421")."\n";
//chr()从指定 ASCII 值返回字符
echo "chr:Hello world!-->".chr("52")."\n";
//convert_cyr_string()把字符串由一种字符集转换成另一种
//k - koi8-r,
//w - windows-1251
//i - iso8859-5
//a - x-cp866
//d - x-cp866
//m - x-mac-cyrillic
echo "convert_cyr_string:Hello world! æøå-->".convert_cyr_string("Hello world! æøå",'w','a')."\n";
//convert_uudecode()对 uuencode 编码的字符串进行解码
echo "convert_uudecode:,2&5L;&\@=V]R;&0A
-->".convert_uudecode(",2&5L;&\@=V]R;&0A
")."\n";
//htmlspecialchars ()输出 htmlspecialchars 函数使用的翻译表
print_r(get_html_translation_table());
//htmlentities()把一些字符转换为 HTML 实体
echo "htmlentities:<© W3CSçh°°¦§>-->".htmlentities("<© W3CSçh°°¦§>")."\n";
//html_entity_decode()把html实体转换为字符
echo "html_entity_decode:&lt;&copy; W3CS&ccedil;h&deg;&deg;&brvbar;&sect;&gt;-->".html_entity_decode("&lt;&copy; W3CS&ccedil;h&deg;&deg;&brvbar;&sect;&gt;")."\n";
//htmlspecialchars()把一些预定义的字符转换为 HTML 实体
echo "htmlspecialchars:<b>Hello world!</b>-->".htmlspecialchars("<b>Hello world!</b>")."\n";
//htmlspecialchars_decode()把预定义的 HTML 实体 "&lt;"（小于）和 "&gt;"（大于）转换为字符
echo "htmlspecialchars_decode:&lt;b&gt;bold&lt;/b&gt;-->".htmlspecialchars_decode("&lt;b&gt;Hello world!&lt;/b&gt;")."\n";
//implode(),join()把数组元素组合为一个字符串
echo "implode,join:'Hello','world!'-->".implode(" ",array('Hello','World!'))."\n";
//lcfirst()把字符串中的首字符转换为小写
echo "lcfirst:Hello world!-->".lcfirst("Hello world!")."\n";
//md5()计算字符串的 MD5 散列
echo "md5:Hello world!-->".md5("Hello world!")."\n";
//计算字符串的 SHA-1 散列
echo "sha1:Hello world!-->".sha1("Hello world!")."\n";
//str_ireplace()替换字符串中的一些字符（大小写不敏感）
echo "str_ireplace:Hello world!-->".str_ireplace("WORLD","JADORE","Hello world!")."\n";
//str_replace()替换字符串中的一些字符（大小写敏感）
echo "str_replace:Hello world!-->".str_replace("WORLD","JADORE","Hello world!")."\n";
//str_rot13()对字符串执行 ROT13 编码
echo "str_rot13:Hello world!-->".str_rot13("Hello world!")."\n";
//str_shuffle()随机地打乱字符串中的所有字符
echo "str_shuffle:Hello world!-->".str_shuffle("Hello world!")."\n";
//stripcslashes()删除由 addcslashes() 函数添加的反斜杠
echo "stripcslashes:\Hello world!-->".stripcslashes("\Hello world!")."\n";
//stripslashes()删除由 addslashes() 函数添加的反斜杠
echo "stripslashes:\Hello world!-->".stripslashes("\Hello world!")."\n";
//strrev()反转字符串
echo "strrev:Hello world!-->".strrev("Hello world!")."\n";
//strtr()转换字符串中特定的字符
echo "strtr:Hello world!-->".strtr("Hello world!","lo","ae")."\n";
//substr_replace()把字符串的一部分替换为另一个字符串
echo "substr_replace:Hello-->".substr_replace("Hello","world",0)."\n";
//ucfirst()把字符串中的首字符转换为大写
echo "ucfirst:hello world!-->".ucfirst("hello world!")."\n";
//ucwords()把字符串中每个单词的首字符转换为大写
echo "ucwords:hello world!-->".ucfirst("hello world!")."\n";
//strtoupper()把字符串转换为大写
echo "strtoupper:hello world!-->".strtoupper("hello world!")."\n";
//strtolower()把字符串转换为小写
echo "strtolower:HELLO WORLD!-->".strtolower("HELLO WORLD!")."\n";

4、分割

//chunk_split()把字符串分割为一连串更小的部分
echo "chunk_split:HELLO WORLD!-->".chunk_split("HELLO WORLD!",1,".")."\n";
//str_split()把字符串分割到数组中
echo "str_split:Hello world!-->";
print_r(str_split("Hello world!",3));
//explode()把字符串打散为数组
echo "explode:Hello world!-->";
print_r(explode(" ","Hello world!"));
//strip_tags()剥去字符串中的 HTML 和 PHP 标签
echo "strip_tags:<php> <b>Hello world!-->".strip_tags("<php> <b>Hello world!")."\n";

正则

一、最左原则（非贪婪模式）：正则表达式总是从目标字符串的最左侧开始，依次匹配，直到匹配到符合表达式要求的部分，或直到匹配目标字符串的结束
二、最长原则（贪婪模式）：对于匹配到的目标字符串，正则表达式总是会匹配到符合正则表达式要求的最长的部分
首先从分隔符开始，常用包括/,#,~，用于表明一串正则的开始，如/a.*a/，当表达式有过多转义字符时，建议先用
#，如url链接

preg_match("/https:\/\/.*com/","https://baidu.com",$match);
print_r($match);
preg_match("#https://.*com#","https://baidu.com",$match);
print_r($match);

\d匹配一个数字字符。等价于 [0-9]。
\D匹配一个非数字字符。等价于 [^0-9]。
\f匹配一个换页符。等价于 \x0c 和 \cL。
\n匹配一个换行符。等价于 \x0a 和 \cJ。
\r匹配一个回车符。等价于 \x0d 和 \cM。
\s匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t匹配一个制表符。等价于 \x09 和 \cI。
\v匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。
\W匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。
\xn匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 “A”。’\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。
\nm标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 • \nm 将匹配八进制转义值 nm。
\nml如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号(?)。
.匹配除 “\n” 之外的任何单个字符
^{匹配输入字符串的开始位置。在字符域[]中表示取反，如’[}\w]‘等于’\w’;而^\w表示以单词字符开头。
KaTeX parse error: Undefined control sequence: \w at position 16: 匹配输入字符串的结束位置。例'\̲w̲‘表示以单词字符结尾。
?匹配前面的子表达式零次或一次 等价于 {0,1}，例如，“do(es)?” 可以匹配 “do” 或 “does”。
匹配前面的子表达式零次或多次，等价于{0,}。例如，zo 能匹配 “z” 、 “zo”、‘zoo’。
+匹配前面的子表达式一次或多次，等价于{1,}例如，‘zo+’ 能匹配 “zo” 以及 “zoo”。
{n}n 为非负整数,匹配确定的n次。例如，‘o{2}’ 不能匹配 “Bob” 或‘Booob’，但是能匹配 “food” 中的两个 o。
{n,}n 为非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。
{n,m}m和n均为非负整数，其中n<= m。最少匹配n次且最多匹配m次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。
[]字符集合(字符域)。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。
()匹配 ()内的内容 并获取这一匹配。搭配\n(n为大于1的整数)，‘http://baidu.com’若表达式：'（\w+） (:)\/\/.*\1’则匹配‘http://baidu.comhttp',\1表示http。
(?:)匹配不获取匹配结果，不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如， ‘industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式。上面表达式若改为'（?:\w+）(:)\/\/.*\1'，则\1表示为：
| x|y,匹配 x 或 y。例如，‘z|food’ 能匹配 “z” 或 “food”。’(z|f)ood’ 则匹配 “zood” 或 “food”。
[-] 字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。
(?=pattern)正 向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹 配不需要获取供以后使用。例如，‘Windows (?=95|98|NT|2000)’ 能匹配 “Windows 2000” 中的 “Windows” ，但不能匹配 “Windows 3.1” 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹 配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)负 向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不 需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’ 能匹配 “Windows 3.1” 中的 “Windows”，但不能匹配 “Windows 2000” 中的 “Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜 索，而不是从包含预查的字符之后开始
有时候最后定界符会有一个字母，如‘/as.*/i’,那这个i又是什么呢，这就是模式修正符；
i表示在和模式进行匹配进不区分大小写
m将模式视为多行，使用^和 $表示任何一行都可以以正则表达式开始或结束 s如果没有使用这个模式修正符号，元字符中的"."默认不能表示换行符号,将字符串视为单行 x表示模式中的空白忽略不计 e正则表达式必须使用在preg_replace替换字符串的函数中时才可以使用(讲这个函数时再说) A以模式字符串开头，相当于元字符^ Z以模式字符串结尾，相当于元字符$
U正则表达式的特点：就是比较“贪婪”，使用该模式修正符可以取消贪婪模式
贪婪模式案例：

preg_match('/a.*d/','asddassdasd',$match);//最长
print_r($match);
preg_match('/a.*d/U','asddassdasd',$match);//最短
print_r($match);
//preg_match只匹配一次，preg_match_all会把所有符合的字符串都匹配出来，并且放置到matches二维数组中
preg_match_all("/a.*d/U","asddassdasd",$matchs);
print_r($matchs);

数组

$cars=array("Volvo","BMW","Toyota");
print_r($cars);
$arr=array(1,2,3,'a'=>4);
$arr['b']=5;//增
unset($arr['b']);//删
$arr[2]=2;//改
print_r($arr);//查
//数组排序
//sort() - 对数组进行升序排列
//rsort() - 对数组进行降序排列
//asort() - 根据关联数组的值，对数组进行升序排列
//ksort() - 根据关联数组的键，对数组进行升序排列
//arsort() - 根据关联数组的值，对数组进行降序排列
//krsort() - 根据关联数组的键，对数组进行降序排列
//1.按照字母升序排列
$cars=array("Volvo","BMW","Toyota");
sort($cars);
print_r($cars);
//2.按照数字升序排列
$numbers=array(4,5,8,22,1,2);
sort($numbers);
print_r($numbers);
//3.按照字母降序排列
$cars=array("Volvo","BMW","Toyota");
sort($cars);
print_r($cars);
//4.按照数字降序排列
$numbers=array(4,5,8,22,1,2);
sort($numbers);
print_r($numbers);

类

类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象 − 是类的实例。
成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可称为对象的属性。
成员函数 − 定义在类的内部，可用于访问对象的数据。
继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类 − 一个类继承其他类称为子类，也可称为派生类。
多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

class Site {
    /*成员变量*/
    var $url;
    var $title;
    /*构造函数*/
    function __construct($par1, $par2)
    {
        $this->url = $par1;
        $this->title = $par2;
    }
    /*成员函数*/
    function setUrl($par) {
        $this->url = $par;
    }
    function getUrl() {
        echo $this->url . PHP_EOL;//PHP_EOL为换行符
    }
    function setTitle($par) {
        $this->title = $par;
    }
    function getTitle() {
        echo $this->title . PHP_EOL;
    }
}
//构造函数
echo "添加了构造函数"."\n";
$yxzj1 = new Site('夜行字节','https://ityo.cn');
$zjmb1 = new Site('字节脉搏','https://zj.cn');
$jadore1 = new Site('我','https://jadore.cn');
//析构函数
echo "析构函数"."\n";
class MyDes {
    function __construct()
    {
        print "构造函数\n";
        $this->name = "我的销毁类";
    }
    function __destruct()
    {
        print "销毁".$this->name."\n";
    }
}
$obj = new MyDes();
echo "继承"."\n";
class Child_Site extends Site {
    var $category;
    function setCate($par) {
        $this->category = $par;
    }
    function getCate() {
        echo $this->category . PHP_EOL;
    }
    /*方法重写*/
    function getUrl()
    {
        echo $this->url . POP_EOL;
        return $this->url;
    }
    function getTitle()
    {
        echo $this->title . PHP_EOL;
        return $this->title;
    }
}
//访问控制
//public（公有）：公有的类成员可以在任何地方被访问。
//protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
//private（私有）：私有的类成员则只能被其定义所在的类访问。
class MyClass {
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';
    function printHello() {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}
$obj1 = new MyClass();
echo $obj1->public;
//echo $obj1->protected;
//echo $obj1->private;
$obj1->printHello();
class MyClass2 extends MyClass {
    protected $protected = 'Protected2';
    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        //echo $this->private;
    }
}
$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
//echo $obj2->private; // 未定义 private
//echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
echo "\n";
//声明一个接口
interface iTemplate {
    public function setVariable($name,$var);
    public function getHtml($template);
}
//接口实现
class Template implements iTemplate {
    private $vars = array();
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
    public function getHtml($template)
    {
        foreach ($this->vars as $name => $value) {
            $template = str_replace('{'.$name.'}',$value,$template);
        }
        return $template;
    }
}
class MyCl {
    const constant = '常量值';
    function showConstant() {
        echo self::constant.PHP_EOL;
    }
}
echo MyCl::constant.PHP_EOL;
$classname = "MyCl";
echo $classname::constant.PHP_EOL;
$class = new MyCl();
$class->showConstant();
echo $class::constant.PHP_EOL;
abstract class AbstractClass{
    //强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}
class ConcreteClass1 extends AbstractClass {
    protected function getValue() {
        return "ConcreteClass1";
    }
    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}
class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}
$class1 = new ConcreteClass1();
$class1->printOut();
echo $class1->prefixValue('FOO_').PHP_EOL;
$class2 = new ConcreteClass2();
$class2->printOut();
echo $class2->prefixValue('FOO_').PHP_EOL;
//Static 关键字
//声明类属性或方法为 static(静态)，就可以不实例化类而直接访问
class FOO {
    public static $my_static = 'foo';
    public function staticValue() {
        return self::$my_static;
    }
}
print FOO::$my_static . PHP_EOL;
$foo = new FOO();
print $foo->staticValue() . PHP_EOL;
//Final 关键字
//如果父类中的方法被声明为 final，则子类无法覆盖该方法,如果一个类被声明为 final，则不能被继承。
class BaseClass {
    function __construct()
    {
        print "BaseClass 类中构造方法" . PHP_EOL;
    }
}
class SubClass extends BaseClass {
    //继承BaseClass类的构造方法
}
//调用BaseClass构造方法
$obj3 = new BaseClass();
//调用BaseClass、SubClass构造方法
$obj3 = new SubClass();