linux | Penguin, Swim Faster in the sea! [跳至正文](http://www.liukang.com/#content)

# [Penguin, Swim Faster in the sea!](https://www.liukang.com/amp/)

 搜索 搜索： 搜索… 搜索

# 标签归档：linux

 [RASPBERRY PI 树莓派](https://www.liukang.com/blog/category/%e7%bd%91%e7%bb%9c%e7%94%9f%e6%b4%bb-%e6%8a%80%e6%9c%af%e5%8f%8a%e9%9a%8f%e7%ac%94/raspberry-pi-%e6%a0%91%e8%8e%93%e6%b4%be/amp/)

# [对比用SHELL SCRIPT和C语言API操作RASPBERRY PI GPIO的速度](https://www.liukang.com/blog/2015/04/28/%e5%af%b9%e6%af%94%e7%94%a8shell-script%e5%92%8cc%e8%af%ad%e8%a8%80api%e6%93%8d%e4%bd%9craspberry-pi-gpio%e7%9a%84%e9%80%9f%e5%ba%a6/amp/)

 [2015年4月28日](https://www.liukang.com/blog/2015/04/28/%e5%af%b9%e6%af%94%e7%94%a8shell-script%e5%92%8cc%e8%af%ad%e8%a8%80api%e6%93%8d%e4%bd%9craspberry-pi-gpio%e7%9a%84%e9%80%9f%e5%ba%a6/amp/) [kang](https://www.liukang.com/blog/author/kang/amp/) [留下评论](https://www.liukang.com/blog/2015/04/28/%e5%af%b9%e6%af%94%e7%94%a8shell-script%e5%92%8cc%e8%af%ad%e8%a8%80api%e6%93%8d%e4%bd%9craspberry-pi-gpio%e7%9a%84%e9%80%9f%e5%ba%a6/amp/#respond)

对Raspberry Pi的GPIO在shell script里面可以直接用sysfs的方式进行操作，也可以调用gpio命令来进行操作，还可以用API来进行操作。今天做了个实验对比sysfs方式、第三方gpio命令以及C语言API操作对效率的影响。

[昨天写的文章](http://www.liukang.com/2014/04/raspberry-pi-gpio-led-memory-usage/amp/)里面提到了用GPIO来控制LED灯的显示，今天其实是突发奇想，想看看用第三方gpio命令来操作和直接操作sysfs的效率到底有多大的区别。

## 物理连线

连线和昨天写的文章里面的连线方法基本一样，只是在GPIO管脚和GND之间跨接了一个可以测频率的万用表（UNI-T UT136D）。

## Shell Script 响应速度测试

### 测试脚本

```
#!/bin/bash
#Written by Kang Liu (http://www.liukang.com)
#You have the freedom to use and/or modify the script, and the freedom to distribute modified and therefore derivative script.
#Actually in this test, I will only use GPIO 17 (WiringIO 0) (Red LED)
orgled=27
greenled=18
redled=17
init_led()
{
 for i in $orgled $greenled $redled
 do
 if [ ! -d /sys/class/gpio/gpio$i ]
 then
 echo $i >/sys/class/gpio/export
 fi
 echo "out" >/sys/class/gpio/gpio$i/direction
 echo 0 >/sys/class/gpio/gpio$i/value
 done
}

cleanup()
{
 init_led
 for i in $orgled $greenled $redled
 do
 if [ -d /sys/class/gpio/gpio$i ]
 then
 echo $i > /sys/class/gpio/unexport
 fi
 done
 exit 0
}
gpio_ben()
{
 echo 1 > /sys/class/gpio/gpio$1/value
 echo 0 > /sys/class/gpio/gpio$1/value
 #gpio write 0 1 #method 4
 #gpio write 0 0 #method 4
}

init_led
trap cleanup INT TERM EXIT
while :
do
 #gpio_ben 17 #method 2, method 4
 echo 1 > /sys/class/gpio/gpio17/value #method 1
 echo 0 > /sys/class/gpio/gpio17/value #method 1
 #gpio write 0 1 #method 3
 #gpio write 0 0 #method 3
done
```

### 方法1：直接调用sysfs控制通断

脚本中默认没有注释掉的就是方法1，相当于用下面命令来操作gpio实现让电路通断：

```
while :
do
 echo 1 > /sys/class/gpio/gpio17/value #method 1
 echo 0 > /sys/class/gpio/gpio17/value #method 1
done
```

实测频率在1.1kHz左右。目测LED基本感觉不到闪烁。

测试结果照片如下，最后两位数字在不断跳动。

![万用表测试GPIO接口频率 (Shell Script)](https://www.liukang.com/wp-content/uploads/2016/07/DSCN0742.jpg)

### 方法2：用shell脚本中的函数调用sysfs控制通断

相当于用下面命令来通过自定义函数gpio_ben操作gpio，实现电路通断：

```
 gpio_ben()
{
 echo 1 > /sys/class/gpio/gpio$1/value
 echo 0 > /sys/class/gpio/gpio$1/value
}

while :
do
 gpio_ben 17
done
```

实测频率在750Hz左右。目测LED基本感觉不到闪烁。

### 方法3：用gpio外部命令来控制通断

相当于用下面的命令来通过gpio外部命令来操作gpio，实现电路的通断：

```
while :
do
 gpio write 0 1
 gpio write 0 0
done
```

实际频率在40Hz左右。目测LED能感觉到一些闪烁。

### 方法4：用通过函数调用gpio外部命令控制通断

相当于用里阿敏的命令来通过函数调用gpio外部命令来操作，实现电路的通断：

```
gpio_ben()
{
 gpio write 0 1
 gpio write 0 0
}
while :
do
 gpio_ben
done
```

和方法3测到的结果基本一致40Hz左右，目测LED 能感觉到一些闪烁。

### Shell Script测试结论

总结一下测试的结果：

方法方法1:直接用shell内部命令调用sysfs方法2:使用函数通过shell的内部命令调用sysfs方法3:使用gpio外部命令控制方法4:通过函数调用gpio外部命令响应频率约1.1 KHz约 750 Hz约 40 Hz约 40 Hz 占空比约 53-54%约 60%-61% 约49% -51% 约50%-51%

和预期一致，使用shell的内部命令(echo和重定向符等)调用sysfs明显效率比使用第三方的命令效率要高。只不过效率高出的比例（27倍！）确实超乎意料。

有些超出预期的是在相对足够快的时候使用shell函数对效率产生的影响也能比较明显的表现出来，方法1和方法2使用的命令是一致的，只是方法2通过函数调用了那些命令。效率相差了几乎40%！

为了进一步验证，我又利用万用表测试占空比的功能进行了补充测试，得到的结果见上面表格。分析shell代码，我估计是因为shell脚本进入和退出函数时占用了相对不少的时间，以至于直接影响到了频率和占空比。这也说明在shell中使用函数其实是要消耗不少资源的。

用函数编写脚本逻辑上会清晰一些，但是就像当年上学时学过的一样，比较“面向机器”、“面向过程”、“面向对象” 编程逻辑上依次可能会一个比一个清晰，但是牺牲的是运行效率。

另外需要特别说明的是频率和占空比测试时使用的不是专业的示波器，只是一个带有频率测试功能的万用表，因此只写了大概的数值。而且在测试频率时不是空载的，电路中带着电阻和LED。但是测得数值的差别已经足够可以反映出来运行效率的差距了。

## 用C语言代码来测试gpio

其实本文主要想写的是shell脚本来做gpio操作的测试，临写完时觉得还是该试试看gpio到底能”跑多快”。参考[例子](http://wiringpi.com/examples/blink/)写了一段C代码编译之后测试，跑出的结果真是甩出shell脚本N条街……要想追求速度还是要上C啊……不知道汇编去操作会不会更快些……

### 使用WiringPi C API测试

代码如下：

```
#include <wiringPi.h>
int main (void)
{
 wiringPiSetup () ;
 pinMode (0, OUTPUT) ;
 for (;;)
 {
 digitalWrite (0, HIGH) ;
 digitalWrite (0, LOW) ;
 }
 return 0 ;
}
```

测试的频率达到了4.5-4.6 MHz，占空比46%-47%。测试结果的照片如下：

![万用表测试GPIO响应频率 (C语言API方式代码编译之后结果)](https://www.liukang.com/wp-content/uploads/2016/07/DSCN0743.jpg)

### 测试使用C语言代码通过文件操作调用sysfs

代码如下：

```
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int main (void)
{
 FILE *fp;
 int gpiovaluefile;
 char off='0';
 char on='1';
 fp = fopen("/sys/class/gpio/export", "w");
 fprintf( fp, "%d", 17 );
 fclose (fp);
 fp = fopen("/sys/class/gpio/gpio17/direction", "rb+");
 fprintf (fp,"out");
 fclose (fp);
 gpiovaluefile = open("/sys/class/gpio/gpio17/value",O_SYNC|O_WRONLY);
 write(gpiovaluefile,&off,1);
 for (;;)
 {
 write(gpiovaluefile,&on,1);
 write(gpiovaluefile,&off,1);
 }
 close (gpiovaluefile); //will never reach here actually...
}
```

其中

```
open("/sys/class/gpio/gpio17/value",O_SYNC|O_WRONLY);
```

这一行我试用了O_SYNC, O_DSYNC, O_ASYNC分别测试，占空比基本都保持在50%正负不到1%的接近理想状况。频率结果如下：

O_ASYNC 175-185 kHz O_DSYNC 168-177 (偶尔有看到超过180 kHz的情况） O_SYNC 168-177 (偶尔有看到超过180 kHz的情况）

实际测试时结果相对不稳定，数值跳动的比较厉害，由于手头没有示波器，看不出来实际输出的波形和频率。

### C语言程序测试的结论

使用C语言WiringPi API来操作gpio看似是几种方法中响应时间最快的，但是占空比距离理想值的50%有3%-4%的差距。(和预期的一样) 使用C语言对sysfs操作速度仍远超过shell脚本；占空比最接近理想值的50%，但是没有使用Wiring Pi API调用gpio响应时间短。

## 对比Shell Script和C语言程序测试结果

使用语言C语言SHELL脚本 调用方法 wiring Pi API 直接文件操作sysfs 直接文件操作sysfs使用函数操作sysfs外部gpio命令通过函数调用外部gpio命令测试响应频率 4.5-4.6 MHz 168-185 KHz 1.1 KHz 750 Hz 40 Hz 40 Hz 测试占空比 46%-46% 非常接近50% 53%-54% 60%-61% 49-51% 50%-51%相对最慢方法的大致”速度倍数” 11万倍以上 4千倍以上 27.5倍 18.75倍 1 *最慢 1 *最慢

所有测试时，肉眼都能感觉出来作为参照的LED灯要比常亮的状态下要略微暗一点点。在40Hz的时候能相对明显的感觉出来LED灯在快速闪烁。

目前看来要想追求速度，用C代码调用API写gpio是效率最高的。有机会试试汇编再做对比。

谨以此文对今日所作测试做一些记录。

 [RASPBERRY PI 树莓派](https://www.liukang.com/blog/category/%e7%bd%91%e7%bb%9c%e7%94%9f%e6%b4%bb-%e6%8a%80%e6%9c%af%e5%8f%8a%e9%9a%8f%e7%ac%94/raspberry-pi-%e6%a0%91%e8%8e%93%e6%b4%be/amp/)

# [【BASH脚本】通过LINUX SYSFS调用GPIO实现LED显示RASPBERRY PI内存占用率](https://www.liukang.com/blog/2014/04/27/%e3%80%90bash%e8%84%9a%e6%9c%ac%e3%80%91%e9%80%9a%e8%bf%87linux-sysfs%e8%b0%83%e7%94%a8gpio%e5%ae%9e%e7%8e%b0led%e6%98%be%e7%a4%baraspberry-pi%e5%86%85%e5%ad%98%e5%8d%a0%e7%94%a8%e7%8e%87/amp/)

 [2014年4月27日](https://www.liukang.com/blog/2014/04/27/%e3%80%90bash%e8%84%9a%e6%9c%ac%e3%80%91%e9%80%9a%e8%bf%87linux-sysfs%e8%b0%83%e7%94%a8gpio%e5%ae%9e%e7%8e%b0led%e6%98%be%e7%a4%baraspberry-pi%e5%86%85%e5%ad%98%e5%8d%a0%e7%94%a8%e7%8e%87/amp/) [kang](https://www.liukang.com/blog/author/kang/amp/) [留下评论](https://www.liukang.com/blog/2014/04/27/%e3%80%90bash%e8%84%9a%e6%9c%ac%e3%80%91%e9%80%9a%e8%bf%87linux-sysfs%e8%b0%83%e7%94%a8gpio%e5%ae%9e%e7%8e%b0led%e6%98%be%e7%a4%baraspberry-pi%e5%86%85%e5%ad%98%e5%8d%a0%e7%94%a8%e7%8e%87/amp/#respond)

这几天弄了个树莓派(Raspberry Pi)玩，装了个Linux。树莓派的GPIO其实非常容易调用，甚至可以直接通过Linux的sysfs来读写GPIO接口的状态，周末空闲的时候写了段bash Shell Script来控制LED灯来展示Linux的内存占用率。这只是个很简单的bash脚本，主要来示意一下如何通过Linux sysfs来调用GPIO来操作LED，通过修改脚本其实可以实现更多的功能，例如显示CPU的温度是否过高等。

## 我使用的硬件设备：

1. Raspberry Pi
1. LED x3 (不同颜色)
1. 470Ω 电阻 x3 (用来为LED降压)
1. 杜邦线 (母-公) x3 (用来连接树莓派的GPIO到面包板)
1. 面包板 x1

## 第一步：用gpio命令验证物理连线

gpio命令是需要安装[WiringPI](http://wiringpi.com/)之后才有的，默认系统不带。安装之后用root权限(sudo)执行 gpio readall，将得到类似下面的结果：

```
root@raspberrypi:~# gpio readall
+----------+-Rev2-+------+--------+------+-------+
| wiringPi | GPIO | Phys | Name | Mode | Value |
+----------+------+------+--------+------+-------+
| 0 | 17 | 11 | GPIO 0 | OUT | Low |
| 1 | 18 | 12 | GPIO 1 | OUT | Low |
| 2 | 27 | 13 | GPIO 2 | OUT | Low |
| 3 | 22 | 15 | GPIO 3 | IN | Low |
| 4 | 23 | 16 | GPIO 4 | IN | Low |
| 5 | 24 | 18 | GPIO 5 | IN | Low |
| 6 | 25 | 22 | GPIO 6 | IN | Low |
| 7 | 4 | 7 | GPIO 7 | IN | Low |
| 8 | 2 | 3 | SDA | IN | High |
| 9 | 3 | 5 | SCL | IN | High |
| 10 | 8 | 24 | CE0 | ALT0 | High |
| 11 | 7 | 26 | CE1 | ALT0 | High |
| 12 | 10 | 19 | MOSI | ALT0 | Low |
| 13 | 9 | 21 | MISO | ALT0 | Low |
| 14 | 11 | 23 | SCLK | ALT0 | Low |
| 15 | 14 | 8 | TxD | ALT0 | High |
| 16 | 15 | 10 | RxD | ALT0 | High |
| 17 | 28 | 3 | GPIO 8 | ALT2 | Low |
| 18 | 29 | 4 | GPIO 9 | ALT2 | Low |
| 19 | 30 | 5 | GPIO10 | ALT2 | Low |
| 20 | 31 | 6 | GPIO11 | ALT2 | Low |
+----------+------+------+--------+------+-------+
root@raspberrypi:~#
```

Phy对应的是针脚的位置， GPIO对应的是GPIO的编号。需要注意两点：

1. 实际执行这个命令后Raspberry Pi显示的GPIO编号很可能和我的不一样，要仔细看好然后再看看要用哪个编号。
1. GPIO的编号和物理针脚不一定是顺序对应的，比如我这次要用的是针脚11, 12, 13，对应的GPIO编号是17, 18, 27。当然如果要用wiringPi的逻辑pin的话就是0, 1, 2，但是我这次不打算用wiringPi，只用sysfs来实现对LED的控制。

## 第二步：连接线路

**注意：连线前断电，连好之后请再三确认之后再通电！**

Raspberry Pi Control LED by using GPIOGPIO LED 树莓派 面包板接线示意图GPIO 连接LED 电路图

连接好线之后，请再次目视检查确认线没接错，特别是0v (GND)一定不要接错！**再三确认之后再通电**，进入Raspberry Pi的命令行界面测试接线是否正确。刚刚接好线的时候LED是不会像上图那样亮起来的，可以执行下面命令看看LED是否会亮（注意要有root权限）：

```
root@raspberrypi:~# echo 17 >/sys/class/gpio/export
root@raspberrypi:~# echo "out" > /sys/class/gpio/gpio17/direction
root@raspberrypi:~# echo 1 >/sys/class/gpio/gpio17/value
```

修改GPIO的数字，依次测试。如果一切正常，那么三盏LED灯会依次亮起来，记住每个数字对应的LED的颜色。

## 第三步：编写脚本通过sysfs调用GPIO实现用LED灯展示内存占用率

我写的脚本如下，如果你愿意，你可以随意使用/修改后再使用/分发。

````
#!/bin/bash
#A Sample script to check memory usage and reflect the result by LED.
#Written by Kang Liu (http://www.liukang.com)
#You have the freedom to use and/or modify the script, and the freedom to distribute modified and therefore derivative script.
#gpio number for the LEDs
orgled=27
greenled=18
redled=17

#precentage of available memory
memfreehigh=60
memfreelow=30

#seconds to wait between each check
waitperiod=10

#Init GPIO sysfs
#Set default as "Off" for LEDs
init_led()
{
 for i in $orgled $greenled $redled
 do
 if [ ! -d /sys/class/gpio/gpio$i ]
 then
 echo $i >/sys/class/gpio/export
 fi
 echo "out" >/sys/class/gpio/gpio$i/direction
 echo 0 >/sys/class/gpio/gpio$i/value
 done
}

#Set LED value
#Parameter is the GPIO number for the LED
set_led()
{
 led_status=`cat /sys/class/gpio/gpio$1/value`
 if [ "$led_status" -ne 1 ]
 then
 init_led
 echo 1 > /sys/class/gpio/gpio$1/value
 fi
}

#Turn off All LEDs before exit
cleanup()
{
 init_led
 for i in $orgled $greenled $redled
 do
 if [ -d /sys/class/gpio/gpio$i ]
 then
 echo $i > /sys/class/gpio/unexport
 fi
 done
 exit 0
}

check_mem_usage()
{
 output=`free |grep Mem|tr -s [:space:]`
 #uncomment the below lines if you want to debug
 #echo $output
 total=`echo $output | cut -d ' ' -f 2`
 used=`echo $output | cut -d ' ' -f 3`
 available=$((100-used*100/total))
 #echo $available% available
 if [ $available -le $memfreelow ]
 then
 #echo "RED"
 set_led $redled
 return
 fi
 if [ $available -ge $memfreehigh ]
 then
 #echo "GREEN"
 set_led $greenled
 return
 fi
 #echo "ORANGE"
 set_led $orgled

}

init_led
trap cleanup INT TERM EXIT
while :
do
 check_mem_usage
 sleep $waitperiod
done
````

上面的脚本实现每10秒钟检查一次内存占用率（利用free命令），如果可用率高于60%，那么亮绿灯；如果可用率低于30%，则亮红灯。在30%到60%之间时亮橙色灯。在退出程序后，LED都会灭掉。

将上面脚本保存为.sh后缀，然后chmod +x赋予执行权限，再执行就可以了。

对上面的脚本稍加修改也可以实现用LED监控树莓派的CPU温度等等，这里就不一一列举代码了。用Shell获取树莓派的CPU/GPU温度可以参考这里：[Raspberry Pi onboard temperature sensors](http://wiki.stocksy.co.uk/wiki/Raspberry_Pi_onboard_temperature_sensors)。

 [网络生活-技术及随笔](https://www.liukang.com/blog/category/%e7%bd%91%e7%bb%9c%e7%94%9f%e6%b4%bb-%e6%8a%80%e6%9c%af%e5%8f%8a%e9%9a%8f%e7%ac%94/amp/)

# [FAIL2BAN ON UBUNTU](https://www.liukang.com/blog/2014/04/19/fail2ban-on-ubuntu/amp/)

 [2014年4月19日](https://www.liukang.com/blog/2014/04/19/fail2ban-on-ubuntu/amp/) [kang](https://www.liukang.com/blog/author/kang/amp/) [留下评论](https://www.liukang.com/blog/2014/04/19/fail2ban-on-ubuntu/amp/#respond)

本文主要介绍如何使用 fail2ban 来削弱针对ssh的猜密码攻击。Ubuntu上自带的 fail2ban 默认规则有些小问题，看似不能直接生效。本文对系统自带 fail2ban 规则做了些修改，实际在Ubuntu Linux 14上测试可用。

清明假期的时候闲的没事将主机从AWS迁移出来了，blog平台也换成了WordPress。新的主机在所在的网段被无聊的人扫来扫去（有种回到校园网的感觉），而且有不少尝试对ssh的攻击，本着“不折腾不会死”的做死精神，在新的主机上启用了fail2ban。

新的主机跑的是Ubuntu Linux的，使用系统默认配置的fail2ban之后发现其实是不生效的。上网搜了一下发现不少人在抱怨fail2ban不能用。这周末自己闲在家里稍微研究了一下，原来是Ubuntu默认安装的fail2ban规则和系统auth.log产生的log不能匹配造成的。

简单记录一下让Ubuntu Linux上的fail2ban来阻挡ssh猜用户名/密码的攻击方法：

1. 保证机器的时间正确（时区也看看），安装fail2ban(参考[这里](https://help.ubuntu.com/community/Fail2ban)）。
1. 启用ssh证书认证（对，这个和fail2ban没任何关系，但总比用密码认证安全些），具体参考这里: [How To Set Up SSH Keys](https://www.digitalocean.com/community/articles/how-to-set-up-ssh-keys--2)
1. 看一下/var/log/auth.log中的sshd的报错，我这里放几个我遇到的比较典型的(student是随便一个用户名，10.1.1.1是任意的一个ip，example.com是任意的域名）：

  - Invalid user student from 10.1.1.1
  - Received disconnect from 10.1.1.1: 11: Bye Bye [preauth]
  - Address 10.1.1.1 maps to example.com, but this does not map back to the address – POSSIBLE BREAK-IN ATTEMPT!
  - reverse mapping checking getaddrinfo for example.com [10.1.1.1] failed – POSSIBLE BREAK-IN ATTEMPT!

1. copy /etc/fail2ban/filter.d/ssh.conf /etc/fail2ban/filter.d/bad-ssh.conf
1. vi （或者你任何喜欢的文本编辑器，别和我争论这点，我是习惯用vi了）bad-ssh.conf，修改成以下内容：

```
[INCLUDES]
before = common.conf

[Definition]
_daemon = sshd
failregex = Received disconnect from : .*: Bye Bye \[preauth\]
 Address maps to .* POSSIBLE BREAK-IN ATTEMPT!$
 Invalid user .* from $
 Did not receive identification string from 
 reverse mapping checking getaddrinfo for .* \[\] failed - POSSIBLE BREAK-IN ATTEMPT!$
ignoreregex =
```

1. 修改/etc/fail2ban/jail.local，增加下面一段内容

```
[bad-ssh]
enabled = true
port = ssh
filter = bad-ssh
logpath = /var/log/auth.log
action = iptables[name=sshd, port=ssh, protocol=tcp]
maxretry = 2
bantime = 36000
```

1. [optional] 修改 /etc/fail2ban/action.d/iptables-blocktype.conf，我是认为直接drop就好了，对这种无聊的攻击没义务发icmp port unreachable回去

```
# Option: blocktype
# Note: This is what the action does with rules. This can be any jump target
# as per the iptables man page (section 8). Common values are DROP
# REJECT, REJECT --reject-with icmp-port-unreachable
# Values: STRING
#blocktype = REJECT --reject-with icmp-port-unreachable
blocktype = DROP
```

1. 执行service fail2ban restart，注意观察/var/log/fail2ban.log和auth.log，再有攻击发生会能看到类似下面的日志：

```
2014-04-19 17:47:29,215 fail2ban.actions: WARNING [bad-ssh] Ban 10.1.1.1
```

如果想要测试自己写的正则表达式是否正确，可以使用fail2ban自带的”fail2ban-regex”来测试，从auth.log中找出自己想匹配的一条日志，然后执行一下这个命令来试试看自己写的表达式是否会匹配即可。例如下面的例子：

````
root@hostname:~# fail2ban-regex 'Apr 19 18:55:07 hostname sshd[9146]: Received disconnect from 10.1.1.1: 11: Bye Bye [preauth]' 'Received disconnect from '

Running tests
=============

Use failregex line : Received disconnect from 
Use single line : Apr 19 18:55:07 hostname sshd[9146]: Received dis...


Results
=======

Failregex: 1 total
|- #) [# of hits] regular expression
| 1) [1] Received disconnect from 
`-

Ignoreregex: 0 total

Date template hits:
|- [# of hits] date format
| [1] MONTH Day Hour:Minute:Second
`-

Lines: 1 lines, 0 ignored, 1 matched, 0 missed
root@hostname:~#
````

需要注意，如果日志里面有中括号([])等特殊字符，记得要用正则表达式的转义字符”\”来匹配。要想匹配的更准确些，还可以考虑用上”$”（行尾）”^”行首等等……正则表达式怎么写就不多说了，网上的教程一大堆……

最后还是要多废话几句，fail2ban不能完全阻止所有的针对ssh的攻击，只能靠暂时封禁来削弱这种攻击的强度。定期看系统日志，发现潜在异常并且根据日志来进行相应的调整是系统管理员必须要做的事情。

## liukang=liukang->next;

 [退出移动版](https://www.liukang.com/blog/tag/linux/?noamp=mobile)