泷羽sec专题课笔记-- Linux基础(1)--基础命令/查找命令

最新推荐文章于 2025-11-25 12:11:25 发布

原创最新推荐文章于 2025-11-25 12:11:25 发布 · 1.2k 阅读

CC 4.0 BY-SA版权

文章标签：

　　本笔记为泷羽sec 《红队全栈课程》学习笔记，课程请可自行前往B站学习，课程/笔记主要涉及网络安全相关知识、系统以及工具的介绍等，请使用该课程、本笔记以及课程和笔记中提及工具的读者，遵守网络安全相关法律法规，切勿进行违法违规违纪的操作。

写在最前面的话，我们为什么要学习网络安全这门技术：

维护国家安全

　　防范网络攻击：网络安全威胁已成为国家安全的重要挑战。学习网络安全有助于识别和防范来自国内外的网络攻击，防止敌对势力通过网络手段窃取敏感信息、破坏关键基础设施或干扰社会正常运作。
　　保护关键基础设施：现代社会高度依赖网络技术，金融系统、交通网络、电力供应等关键基础设施都依赖于稳定的网络环境。掌握网络安全知识有助于保护这些基础设施免受网络攻击，确保国家的正常运转。

促进经济发展

　　保障数字经济安全：数字经济已成为国家经济增长的重要引擎。通过学习网络安全，可以保障数字经济的健康发展，防止数据泄露和网络犯罪对经济活动的干扰。
　　增强国际竞争力：在全球化的背景下，网络安全技术水平直接影响国家的国际竞争力。掌握先进的网络安全技术和策略，有助于提升国家在全球数字经济中的地位。

提升社会稳定

　　防范社会风险：网络犯罪和网络恐怖主义对社会稳定构成严重威胁。学习网络安全有助于及时发现和应对这些风险，维护社会的和谐与稳定。
　　保护公民权益：网络安全直接关系到公民的隐私权和信息安全。通过学习网络安全，可以更好地保护公民的合法权益，增强公众对政府和企业的信任。

推动科技进步

　　创新安全技术：网络安全领域的技术创新不断推动信息技术的进步。学习网络安全有助于推动新技术的研发和应用，提升国家在科技领域的整体实力。
　　促进国际合作：网络安全是全球性问题，需要各国共同努力应对。通过学习网络安全，可以参与国际网络安全合作，共同制定国际标准和规范，提升全球网络安全水平。

强化法治建设

　　完善法律法规：学习网络安全有助于推动和完善相关法律法规的制定和实施，确保网络安全工作有法可依、有章可循。
　　提升执法能力：掌握网络安全知识可以提升执法部门的网络侦查和取证能力，有效打击网络犯罪，维护法律权威。

培养专业人才

　　构建人才梯队：网络安全领域需要大量高素质的专业人才。通过系统学习和培训，可以培养出一批具备专业知识和实战经验的网络安全专家，为国家的网络安全事业提供坚实的人才保障。　　总之，学习网络安全不仅是个人职业发展的需要，更是维护国家安全、促进经济发展、保障社会稳定和推动科技进步的重要手段。通过不断提升网络安全意识和能力，我们可以更好地应对日益复杂的网络安全挑战，为实现国家的长期稳定和发展贡献力量。

以下为linux基础（1）视频对应的内容视频传送门 ==> linux基础（1）_哔哩哔哩_bilibili

一、Linux基础命令

　　1.touch命令

　　该条命令最常用的方法是创建一个空文件，不过在日常学习和工作中，可能也有人会用echo>1.txt或者直接在桌面上鼠标右键创建文件。

　　在具体使用过程中，也可以使用诸如touch ~/Desktop/1.txt 在指定目录创建文件，还可以一次性创建多个文件，比如touch 2.txt 3.txt 4.txt

touch [filename]

touch [path/filename]

　　-c参数，如果文件不存在，则不会创建文件。

touch -c [filename]

　　使用了-c参数，试图创建0.txt，结果并没有创建成功

　　-a -m参数都和时间有关，不过说这两个参数之前，就要先说下touch的基础用法，直接touch一个已经存在的文件，另外需要结合stat命令一起学习。先把已经创建的文件清理干净，然后我们执行如下命令。

　　我们可以看到文件touch后，查看文件的状态，有4个时间分别是Access、Modify、Change、Birth。

　　Access是访问时间，如果文件最后一次被访问，记录的时间就会改变；

　　Modify是修改时间，如果文件最有一次被修改，这个时间就会改变；

　　Change是状态改变时间，如果文件的状态（权限、所有者等）调整，这个时间就会改变；

　　Birth是文件的最初创建时间，这个时间从文件创建就被记录下来。

　　我们首先鼠标右键，就用mousepad或者vim访问下，然后不保存，直接关闭，再用stat查看。

　　我们可以看到文件访问时间被修改了，而当我们只使用-a参数，我们会发现，只修改了Access和Change的时间。

如果我们使用-m参数，我们会发现文件的Modify和Change参数一起被修改了。

　　所以汇总下来情况，以及另外测试下其他几条命令对文件时间属性的影响如下

	Access	Modify	Change	Birth
touch 无参数	√	√	√	×
touch -a	√	×	√	×
touch -m	×	√	√	×
echo >>	×	√	√	×
ls	×	×	×	×
cat	√	×	×	×
mousepad 打开直接保存	√	×	×	×
mousepad 修改保存	√	√	√	√
vim 打开 :q!	√	×	×	×
vim 打开修改 :wq	√（打开时间）	√（写入时间）	√（写入时间）	×
chmod	×	×	√	×
touch fileA -r fileB	√（引入FileB访问时间）	√（命令执行时间）	×	×
touch file -t stamp	√（stamp)	√（stamp)	×	×

　　所有有些命令就很有意思了，比如echo > 或者 echo >> 这个只会修改文件的Modify和Change时间，而不会访问文件，也就说echo是在不访问文件的情况下对文件进行修改。

　　而用mousepad或者vim ，打开文件就会修改访问时间，但是如果直接关闭或者无修改直接按保存，都不会修改其他时间属性。

　　touch 的-f 参数，这条命令会引入其他文件的访问时间，以及使用-t 指定时间戳，这里有个比较搞笑的情况，执行这两命令时会发生：一个文件还没有创建但是文件已经被访问过的情况。

　　2.mkdir命令

　　mkdir命令用来创建文件夹，基础使用过程略，主要对一些参数进行讲解。

　　mkdir -p 参数

　　该参数可以创建多级目录，中间不存在的话会自动创建。比如我们要在家目录桌面连续创建3个3层目录深的文件夹，可以使用下面的命令格式，但是第4条命令是不对的，创建到根目录去了：

mkdir -p ~/Desktop/1/2/3

mkdir -p 2/3/4

mkdir -p ./3/4/5

mkdir -p /4/5/6 #这条命令变成在/根目录创建了，是错误的

　　mkdir -m参数

　　-m 参数用于创建文件夹的时候，给文件夹赋予相应的权限，和chmod 777这种类似，这条命令也可以和-p 组合使用，但是实测下来，仅对最深一层文件夹生效。

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 1              
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir -m 700 2       
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ ll
total 8
drwxrwxr-x 2 kali kali 4096 Nov  6 06:06 1
drwx------ 2 kali kali 4096 Nov  6 06:06 2
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir -m 700 -p 3/4/5
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ ll
total 12
drwxrwxr-x 2 kali kali 4096 Nov  6 06:06 1
drwx------ 2 kali kali 4096 Nov  6 06:06 2
drwxrwxr-x 3 kali kali 4096 Nov  6 06:06 3
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ cd 3      
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/3]
└─$ ll
total 4
drwxrwxr-x 3 kali kali 4096 Nov  6 06:06 4
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/3]
└─$ cd 4
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/3/4]
└─$ ll
total 4
drwx------ 2 kali kali 4096 Nov  6 06:06 5
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/3/4]
└─$

　　mkdir -v参数

　　可以显示命令的详细执行过程，组合-p命令的话，运行结果如下：

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir -p 1/2/3/4/5 -v
mkdir: created directory '1'
mkdir: created directory '1/2'
mkdir: created directory '1/2/3'
mkdir: created directory '1/2/3/4'
mkdir: created directory '1/2/3/4/5'

3.rm命令

　　rm命令可以删除文件和文件夹，删除过程中可以结合通配符使用

　　rm -v参数

　　显示命令的详细执行过程

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt 2.txt 3.txt 11.txt 12.txt 13.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm ?.txt -v
removed '1.txt'
removed '2.txt'
removed '3.txt'
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm ?3.txt -v
removed '13.txt'
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm *.txt -v 
removed '11.txt'
removed '12.txt'
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$

　　rm -i/-I 参数

　　删除前进行逐个提示/和提示一次

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt 2.txt 3.txt 11.txt 12.txt 13.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm -i *.*
rm: remove regular empty file '1.txt'? y
rm: remove regular empty file '2.txt'? y
rm: remove regular empty file '3.txt'? y
rm: remove regular empty file '11.txt'? y
rm: remove regular empty file '12.txt'? y
rm: remove regular empty file '13.txt'? y

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt 2.txt 3.txt 11.txt 12.txt 13.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm -I *.*                                   
rm: remove 6 arguments? y

　　rm -r 参数

　　递归删除，可以删除文件夹

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir -p 1/2/3/4/5   
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm 1     
rm: cannot remove '1': Is a directory
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm 1 -r -v
removed directory '1/2/3/4/5'
removed directory '1/2/3/4'
removed directory '1/2/3'
removed directory '1/2'
removed directory '1'

　　rm -d 参数

　　删除空目录

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 1 2 3 4/5 -p
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ tree                                        
.
├── 1
├── 2
├── 3
└── 4
    └── 5

6 directories, 0 files
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm -d -v  
rm: missing operand
Try 'rm --help' for more information.
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rm * -d -v
zsh: sure you want to delete all 4 files in /home/kali/Desktop [yn]? y
removed directory '1'
removed directory '2'
removed directory '3'
rm: cannot remove '4': Directory not empty

　　4.rmdir命令

　　这条命令专门用于删除空的文件夹，其实我是用的不太多，因为rm命令也可以删除文件夹。这条命令可以看成是mkdir -p 的逆运算，具体演示如下：

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 4/5 -p -v
mkdir: created directory '4'
mkdir: created directory '4/5'
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ rmdir 4/5 -p -v
rmdir: removing directory, '4/5'
rmdir: removing directory, '4'

5、mv命令

　　mv命令可以移动文件，如果同目录下面起到的是改名效果，命令执行过程中可以带-v查看具体执行过程。

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt                                 
# 将1.txt改名2.txt                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1.txt 2.txt 
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 1           
# 将2.txt 移动到当前目录下面的1文件夹下                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 2.txt 1    
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ tree       
.
└── 1
    └── 2.txt

2 directories, 1 file
# 将移进去的文件再移回来，同时改名叫3.txt                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1/2.txt 3.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ ll                    
total 4
drwxrwxr-x 2 kali kali 4096 Nov  6 06:39 1
-rw-rw-r-- 1 kali kali    0 Nov  6 06:37 3.txt

　　也可以批量移动文件，如下所示：

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt 2.txt 3.txt 11.txt 12.txt 13.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1.txt 2.txt 1
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ tree                                        
.
├── 1
│   ├── 1.txt
│   └── 2.txt
├── 11.txt
├── 12.txt
├── 13.txt
└── 3.txt

# 如果移动到一个不存在的目录就会出错                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1?.txt 3     
mv: target '3': No such file or directory

　　还可移动文件夹（含下面的文件）

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 1       
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1/1.txt                               
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 2
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ tree         
.
├── 1
│   └── 1.txt
└── 2

3 directories, 1 file
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1 2           
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ tree
.
└── 2
    └── 1
        └── 1.txt

3 directories, 1 file

　　mv -i参数

　　该参数是遇到覆盖文件的情况时发出提醒要求确认

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt 2.txt 3.txt 11.txt 12.txt 13.txt
# 无提醒                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1.txt 2.txt  -v
renamed '1.txt' -> '2.txt'
# 有提醒                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 3.txt 2.txt -i -v
mv: overwrite '2.txt'? y
renamed '3.txt' -> '2.txt'

　　mv --backup参数

　　该参数是遇到目的文件同名的时候，把目的文件扩展名加上个~，再把原文件移动过去，具体展示如下

┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 1
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1/1.txt                               
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ echo 11> 1/1.txt
# 请注意 桌面的1.txt 写入了00                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ echo 00>1.txt   
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1.txt 1/1.txt --backup 
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ tree         
.
└── 1
    ├── 1.txt
    └── 1.txt~

2 directories, 2 files
# 00的文件替换了目标文件夹中的文件                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ cat 1/1.txt
00
# 目标文件夹中的文件修改了扩展名                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ cat 1/1.txt~
11

　　mv -n 参数

　　不覆盖已存在的文件

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt                                 
                                                                                                                                                                                                             
┌──(kali㉿kali)-[~/Desktop]
└─$ touch 2.txt             
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop]
└─$ mv 1.txt 2.txt -n  
mv: not replacing '2.txt'

　　mv命令还有其他参数，初级阶段暂时用不到，具体可以执行mv --help查看及研究

　　6、cp命令

　　cp命令基础用法是复制一个文件或者文件夹，基础用法略，主要说明一下一些参数的用法。

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt                   
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ mkdir 1/2/3 -p
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1/2/3/4.txt
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ cp 1 2 -r -v     # -r 是递归复制文件夹下面内容  -v 是详细输出
'1' -> '2'
'1/2' -> '2/2'
'1/2/3' -> '2/2/3'
'1/2/3/4.txt' -> '2/2/3/4.txt'
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ tree             
.
├── 1
│   └── 2
│       └── 3
│           └── 4.txt
├── 1.txt
└── 2
    └── 2
        └── 3
            └── 4.txt

7 directories, 3 files

　　cp -a参数

　　带属性复制，访问时间和修改时间会一同复制。

┌──(kali㉿kali)-[~/Desktop]
└─$ touch 1.txt -t 200011111111.11
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ stat 1.txt 
  File: 1.txt
  Size: 0               Blocks: 0          IO Block: 4096   regular empty file
Device: 8,1     Inode: 436045      Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    kali)   Gid: ( 1000/    kali)
Access: 2000-11-11 11:11:11.000000000 -0500
Modify: 2000-11-11 11:11:11.000000000 -0500
Change: 2024-11-06 07:32:20.121888956 -0500
 Birth: 2024-11-06 07:31:50.957834148 -0500
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ cp 1.txt 2.txt   
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ cp 1.txt 3.txt -a
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ stat *    
  File: 1.txt
  Size: 0               Blocks: 0          IO Block: 4096   regular empty file
Device: 8,1     Inode: 436045      Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    kali)   Gid: ( 1000/    kali)
Access: 2024-11-06 07:32:31.177866512 -0500
Modify: 2000-11-11 11:11:11.000000000 -0500
Change: 2024-11-06 07:32:20.121888956 -0500
 Birth: 2024-11-06 07:31:50.957834148 -0500
  File: 2.txt
  Size: 0               Blocks: 0          IO Block: 4096   regular empty file
Device: 8,1     Inode: 436020      Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    kali)   Gid: ( 1000/    kali)
Access: 2024-11-06 07:32:31.177866512 -0500
Modify: 2024-11-06 07:32:31.177866512 -0500
Change: 2024-11-06 07:32:31.177866512 -0500
 Birth: 2024-11-06 07:32:31.177866512 -0500
  File: 3.txt
  Size: 0               Blocks: 0          IO Block: 4096   regular empty file
Device: 8,1     Inode: 436047      Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    kali)   Gid: ( 1000/    kali)
Access: 2024-11-06 07:32:31.177866512 -0500  # 可以看到-a，Access和Modify 时间戳是保留的
Modify: 2000-11-11 11:11:11.000000000 -0500
Change: 2024-11-06 07:32:36.005830795 -0500
 Birth: 2024-11-06 07:32:36.005830795 -0500

　　cp -l参数

　　-l参数是用于复制硬链接，首先创建了1个txt文件内容为111，再用cp -l参数复制硬链接到2.txt，用echo>>向1.txt内2222文本信息，再对硬链接执行cat命令查看，可以看到2.txt也被修改。

┌──(kali㉿kali)-[~/Desktop]
└─$ rm *.txt   
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ echo 111>1.txt 
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ cp -l 1.txt 2.txt
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ cat 2.txt        
111
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ echo 2222>>1.txt
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ cat 2.txt
111
2222

　　cp -b 参数

　　这条命令是带备份复制，如果目标文件会被替换则会留好备份，可对文件夹进行设置查看到隐藏文件。

　　cp -i 参数

　　该参数是，如果在复制过程中如发生覆盖情况，则进行确认。

┌──(kali㉿kali)-[~/Desktop/test]
└─$ cp 1.txt 2.txt -i
cp: overwrite '2.txt'? n

　　cp -p 参数

　　该参数是复制文件的时候连同文件的权限一起复制，演示如下。

# 初始权限为664
┌──(kali㉿kali)-[~/Desktop/test]
└─$ ll
total 4
-rw-rw-r-- 1 kali kali 6 Nov  6 08:18 1.txt

# 将权限修改为777                                                                                                                     
┌──(kali㉿kali)-[~/Desktop/test]
└─$ chmod 666 1.txt
                                                                                     
┌──(kali㉿kali)-[~/Desktop/test]
└─$ ll
total 4
-rw-rw-rw- 1 kali kali 6 Nov  6 08:18 1.txt
                                                                                     
┌──(kali㉿kali)-[~/Desktop/test]
└─$ cp 1.txt 2.txt   

# 不带权限复制，复制后文件的权限还是664                                                                                     
┌──(kali㉿kali)-[~/Desktop/test]
└─$ ll
total 8
-rw-rw-rw- 1 kali kali 6 Nov  6 08:18 1.txt
-rw-rw-r-- 1 kali kali 6 Nov  6 08:26 2.txt   <---

# 使用-p带权限复制                                                                                     
┌──(kali㉿kali)-[~/Desktop/test]
└─$ cp 1.txt 3.txt -p

# 带权限复制的文件，和被复制文件的全息一样，都是666                                                                                     
┌──(kali㉿kali)-[~/Desktop/test]
└─$ ll
total 12
-rw-rw-rw- 1 kali kali 6 Nov  6 08:18 1.txt
-rw-rw-r-- 1 kali kali 6 Nov  6 08:26 2.txt
-rw-rw-rw- 1 kali kali 6 Nov  6 08:18 3.txt   <---

　　cp -d 参数

　　该参数专门用来复制软链接，具体演示如下（s开头表示实体文件，r开头表示软连接）

　　根据演示可以看到，如果cp 直接复制软链接，则目标文件会变成实体文件（下面的cp r1.txt s2.txt命令），如果要带软链接复制，则必须加上-d参数。几条命令下来实际是有s1和 s2两个实体文件。

　　另外，如果仅把软链接移动到文件夹内，软链接因为找不到实体文件，就会出错。但是把软链接对应的文件一同复制进来，则会恢复正常。此外，下图的r1.txt软链接虽然体现出错的红色图标，但只要关闭文件夹再打开次就会恢复正常）

　　7、ln命令

　　ln核心用途是创建链接，包括软连接和硬链接，ln 默认是创建硬链接，如果-s是创建软链接。我们用ls -i参数列出文件时可以看到文件inode，2个硬链接的文件的inode是一样的。

　　ln还可以给文件夹创建软链接（无法创建硬链接，会提示出错）

　　以上为ln的初级用法，ln其他用法可以--help进行查看。

二、Linux查找类命令

　　locate

　　该命令的运行须依赖于一个预先建立的数据库，命令可以用来快速查找文件，如果数据库文件不存在或路径不正确，就会出错，所以需要先更新数据库，使用下面的命令

sudo updatedb

　　待上述更新完毕后，如果要搜索gcc，则使用下列命令

locate gcc # 列出所有带gcc的文件以及路径

locate -b gcc # 仅列出带有gcc名字的文件

locate -c gcc # 列出相应的匹配数字

# 名字及路径中带有gcc
┌──(kali㉿kali)-[~/Desktop]
└─$ locate -c gcc
1771

# 仅名字中带有gcc                                                                                   
┌──(kali㉿kali)-[~/Desktop]
└─$ locate -c -b gcc
191

locate -i gcc # 不区分大小写

locate -l 10 gcc # 列出10条就停止

locate -l 10 -0 gcc # 不换行显示

locate -r '/gcc$' # -r 使用正则，匹配仅以gcc开头的文件

┌──(kali㉿kali)-[~/Desktop]
└─$ locate -l 10 gcc   
/etc/alternatives/i686-w64-mingw32-gcc
/etc/alternatives/i686-w64-mingw32-gcc-13
/etc/alternatives/i686-w64-mingw32-gcc-ar
/etc/alternatives/i686-w64-mingw32-gcc-nm
/etc/alternatives/i686-w64-mingw32-gcc-ranlib
/etc/alternatives/x86_64-w64-mingw32-gcc
/etc/alternatives/x86_64-w64-mingw32-gcc-13
/etc/alternatives/x86_64-w64-mingw32-gcc-ar
/etc/alternatives/x86_64-w64-mingw32-gcc-nm
/etc/alternatives/x86_64-w64-mingw32-gcc-ranlib
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ locate -l 10 -0 gcc # 不换行显示
/etc/alternatives/i686-w64-mingw32-gcc/etc/alternatives/i686-w64-mingw32-gcc-13/etc/alternatives/i686-w64-mingw32-gcc-ar/etc/alternatives/i686-w64-mingw32-gcc-nm/etc/alternatives/i686-w64-mingw32-gcc-ranlib/etc/alternatives/x86_64-w64-mingw32-gcc/etc/alternatives/x86_64-w64-mingw32-gcc-13/etc/alternatives/x86_64-w64-mingw32-gcc-ar/etc/alternatives/x86_64-w64-mingw32-gcc-nm/etc/alternatives/x86_64-w64-mingw32-gcc-ranlib
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ locate -r '/gcc$'                                      
/usr/bin/gcc
/usr/lib/gcc
/usr/libexec/gcc
/usr/share/gcc
/usr/share/bash-completion/completions/gcc
/usr/share/doc/gcc
/usr/share/doc/gcc-13-base/gcc
/usr/share/lintian/overrides/gcc

which/where

　　这2条命都可以快速定位linux系统中，有没有相应的命令，但有时where查询到的结果更加多，比如where可以查到有2个python文件路径，where还可以查找ls这种操作系统的命令的路径，而which是无法查到或者查到的信息不够详细。

┌──(kali㉿kali)-[~/Desktop]
└─$ which python
/usr/bin/python
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ which python?
python? not found
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ where python 
/usr/bin/python
/bin/python
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ which ls     
ls: aliased to ls --color=auto
                                                                                     
┌──(kali㉿kali)-[~/Desktop]
└─$ where ls    
ls: aliased to ls --color=auto
/usr/bin/ls
/bin/ls

　　不过总的说来，which一般在后渗透阶段，比如打到服务器里面，已经getshell了需要提权的情况下，我们服务器上信息收集的时候，会一次性使用which curl wget python …… （注意可以同时加多个参数），来查询这条服务器上有什么可执行的程序供我们利用。当然，where也可以附带多个参数。

┌──(kali㉿kali)-[/]
└─$ which curl wget python
/usr/bin/curl
/usr/bin/wget
/usr/bin/python
                                                                                             
┌──(kali㉿kali)-[/]
└─$ where curl wget python
/usr/bin/curl
/bin/curl
/usr/bin/wget
/bin/wget
/usr/bin/python
/bin/python

find

　　find也是一个查找文件用的命令，和上面的locate相比，它的查询速度略慢，优点是可以设置不同的参数实现精确查找，但同时它查找的时候也会受到用户的权限限制，它无法在没有相应权限的目录中进行查找。

find ~ -mtime 2 -ls | sort -k9 -k10 | more

　　这条命令实际应该是查询48-72小时之间被修改过的文件，日和时分排序

　　参数说明

~ 表示查询所在目录，如果是从根目录开始则改成/，如果从当前目录查找则改成.
-mtime 2 表示查找48-72小时内被修改的文件
-ls 是输出长输出格式，
sort -k9 -k10 第9、10列分别是“年月日时分秒”中的日和时分，默认升序排列，-r 可以倒序

　　这里关于-mtime参数说明下，就查询区间和参数设置详见下表：

修改时间（小时）	参数
[0-24)	-mtime -1
[24-48)	-mtime 1
[48,∞)	-mtime +1
[0-48)	-mtime -2
[48-72)	-mtime 2
[72,∞)	-mtime +2

　　如果用一张图来表示的话，大概是下面这个样子

　　另外结合上面学到的touch -t 时间戳可以修改文件的修改时间，我们结合这条命令验证下，1.txt是1天内的文件，2.txt是2天内的文件，以此类推。另外正好是24小时比较难验证，故未进行验资。

# 这里需要看下kali的系统时间，不一定是物理机时间
┌──(kali㉿kali)-[~/Desktop/test]
└─$ date +"%Y-%m-%d %H:%M:%S"                      
2024-11-06 18:04:25
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ touch 1.txt -t 202411061800.00  
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ touch 2.txt -t 202411051800.00 
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ touch 3.txt -t 202411041800.00 
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ touch 4.txt -t 202411031800.00 
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -mtime -1 -type f -ls | sort -k9 -k10   
   427103      0 -rw-rw-r--   1 kali     kali            0 Nov  6 18:00 ./1.txt
#   k1        k2    k3        k4  k5       k6           k7  k8  k9  k10  k11
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -mtime -2 -type f -ls | sort -k9 -k10
   427106      0 -rw-rw-r--   1 kali     kali            0 Nov  5 18:00 ./2.txt
   427103      0 -rw-rw-r--   1 kali     kali            0 Nov  6 18:00 ./1.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -mtime 1 -type f -ls | sort -k9 -k10   
   427106      0 -rw-rw-r--   1 kali     kali            0 Nov  5 18:00 ./2.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -mtime 2 -type f -ls | sort -k9 -k10
   427120      0 -rw-rw-r--   1 kali     kali            0 Nov  4 18:00 ./3.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -mtime +2 -type f -ls | sort -k9 -k10
   427121      0 -rw-rw-r--   1 kali     kali            0 Nov  3 18:00 ./4.txt
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -mtime +1 -type f -ls | sort -k9 -k10
   427121      0 -rw-rw-r--   1 kali     kali            0 Nov  3 18:00 ./4.txt
   427120      0 -rw-rw-r--   1 kali     kali            0 Nov  4 18:00 ./3.txt

find . -type f -iname '*.sh' -mmin -30 -ls

　　有了第一条命令的经验，那么这条命令相对比较好理解，是查找30分钟内修改过的类型是文件的，扩展名是.sh的文件，用-ls长格式输出。

　　另外关于-name 和 -iname的区别，因为Linux是严格区分大小写，-iname sh的时候，会把sH/Sh都搜索出来。我们验证下：

┌──(kali㉿kali)-[~/Desktop/test]
└─$ touch a.sh A.sh aa.sh aA.sh                   
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -name a.sh   
./a.sh

┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -iname "a.sh" 
./a.sh
./A.sh

┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -iname "?.sh"
./a.sh
./A.sh
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -name "?.sh" 
./a.sh
./A.sh
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -name "?a.sh"
./aa.sh
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -iname "?a.sh"
./aa.sh
./aA.sh

┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -iname "*.sh" 
./a.sh
./aa.sh
./aA.sh
./A.sh
                                                                                                                         
┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -name "*.sh" 
./a.sh
./aa.sh
./aA.sh
./A.sh

　　根据上面的试验可以发现，使用-name的时候是严格区分了大小写，而-iname的时候是忽略了大小写。另外无论是-name还是-iname均可以使用通配符。

find . -name "*.txt" -exec rm -rf {} \;

　　这条命令是查找所有的txt文件，并执行删除操作，其中-exec 是find的一个比较有意思的参数，而且它的固定格式是 -exec .... {} \; 注意{}后面的空格和反斜杠\和分号;都不能省略。具体演示如下：

┌──(kali㉿kali)-[~/Desktop/test]
└─$ touch 1.111 2.111 3.111 4.111  

┌──(kali㉿kali)-[~/Desktop/test]
└─$ find . -type f -name "*.111" -exec rm -rf -v {} \;
removed './2.111'
removed './1.111'
removed './4.111'
removed './3.111'

find / -usr root -type f -perm -o=w -name "*.sh" 2>/dev/null

　　这条命令是查找用户是root但是其他用户至少有写权限的sh文件，同时有许多文件夹我们无权限访问导致查找时会出错，为快速定位检索到的文件我们会选择丢弃错误信息。

┌──(kali㉿kali)-[~/Desktop/test]
└─$ find / -user root -perm -o=w -name "*.sh" 2>/dev/null
/etc/rc2.d/S01console-setup.sh
/etc/rcS.d/S01keyboard-setup.sh
/etc/alternatives/desktop-grub.sh
/etc/rc4.d/S01console-setup.sh
/etc/rc3.d/S01console-setup.sh
/etc/rc5.d/S01console-setup.sh
/usr/lib/java-wrappers/java-wrappers.sh
/usr/lib/java-wrappers/jvm-list.sh
/usr/share/desktop-base/grub_background.sh
/usr/share/desktop-base/kali-theme/grub/grub_background.sh

　　关于2>/dev/null丢弃出错，其中2表示错误信息(stderr)，1为正确信息(stdout)，0表示标准输入(stdin)；/dev/null是Linux系统中一个特殊设备，数据丢进去就会消失，Linux系统中类似设备还有很多，后续会遇到。我们除了丢弃错误信息以外，也可以把正确输出和错误输出分别输出到2个不同的tty设备；还可以把错误输出重定向到某个文件中，如果愿意的话。具体详细下图演示。