精华内容
下载资源
问答
  • 他们的最好成绩,1秒钟可以并发6次,赶在Database入库前,Cache进行Missing Loading前,强占这其中十几毫秒的时间,进行恶意攻击。 相关链接: Memcached笔记——(一)安装&常规错误&监控 Memcached笔记...

    近半个月过得很痛苦,主要是产品上线后,引来无数机器用户恶意攻击,不停的刷新产品各个服务入口,制造垃圾数据,消耗资源。他们的最好成绩,1秒钟可以并发6次,赶在Database入库前,Cache进行Missing Loading前,强占这其中十几毫秒的时间,进行恶意攻击。

    相关链接:
    Memcached笔记——(一)安装&常规错误&监控
    Memcached笔记——(二)XMemcached&Spring集成
    Memcached笔记——(三)Memcached使用总结

    Memcached笔记——(四)应对高并发攻击

    为了应对上述情况,做了如下调整:

    1. 更新数据时,先写Cache,然后写Database,如果可以,写操作交给队列后续完成。
    2. 限制统一帐号,同一动作,同一秒钟并发次数,超过1次不做做动作,返回操作失败。
    3. 限制统一用户,每日动作次数,超限返回操作失败。

    要完成上述操作,同事给我支招。用Memcached的add方法,就可以很快速的解决问题。不需要很繁琐的开发,也不需要依赖数据库记录,完全内存操作。

    以下实现一个判定冲突的方法:

    Java代码 复制代码 收藏代码
    1. /**
    2. * 冲突延时 1秒
    3. */
    4. public static final int MUTEX_EXP = 1;
    5. /**
    6. * 冲突键
    7. */
    8. public static final String MUTEX_KEY_PREFIX = "MUTEX_";
    9. /**
    10. * 冲突判定
    11. *
    12. * @param key
    13. */
    14. public boolean isMutex(String key) {
    15. return isMutex(key, MUTEX_EXP);
    16. }
    17. /**
    18. * 冲突判定
    19. *
    20. * @param key
    21. * @param exp
    22. * @return true 冲突
    23. */
    24. public boolean isMutex(String key, int exp) {
    25. boolean status = true;
    26. try {
    27. if (memcachedClient.add(MUTEX_KEY_PREFIX + key, exp, "true")) {
    28. status = false;
    29. }
    30. } catch (Exception e) {
    31. logger.error(e.getMessage(), e);
    32. }
    33. return status;
    34. }
    	/**
    	 * 冲突延时 1秒
    	 */
    	public static final int MUTEX_EXP = 1;
    	/**
    	 * 冲突键
    	 */
    	public static final String MUTEX_KEY_PREFIX = "MUTEX_";
    
    	/**
    	 * 冲突判定
    	 * 
    	 * @param key
    	 */
    	public boolean isMutex(String key) {
    		return isMutex(key, MUTEX_EXP);
    	}
    
    	/**
    	 * 冲突判定
    	 * 
    	 * @param key
    	 * @param exp
    	 * @return true 冲突
    	 */
    	public boolean isMutex(String key, int exp) {
    		boolean status = true;
    		try {
    			if (memcachedClient.add(MUTEX_KEY_PREFIX + key, exp, "true")) {
    				status = false;
    			}
    		} catch (Exception e) {
    			logger.error(e.getMessage(), e);
    		}
    		return status;
    	}

    做个说明:

    选项 说明
    add 仅当存储空间中不存在键相同的数据时才保存
    replace 仅当存储空间中存在键相同的数据时才保存
    set 与add和replace不同,无论何时都保存

    也就是说,如果add操作返回为true,则认为当前不冲突!

    回归场景,恶意用户1秒钟操作6次,遇到上述这个方法,只有乖乖地1秒后再来。别小看这1秒钟,一个数据库操作不过几毫秒。1秒延迟,足以降低系统负载,增加恶意用户成本。

    附我用到的基于XMemcached实现:

    Java代码 复制代码 收藏代码
    1. import net.rubyeye.xmemcached.MemcachedClient;
    2. import org.apache.log4j.Logger;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.stereotype.Component;
    5. /**
    6. *
    7. * @author Snowolf
    8. * @version 1.0
    9. * @since 1.0
    10. */
    11. @Component
    12. public class MemcachedManager {
    13. /**
    14. * 缓存时效 1天
    15. */
    16. public static final int CACHE_EXP_DAY = 3600 * 24;
    17. /**
    18. * 缓存时效 1周
    19. */
    20. public static final int CACHE_EXP_WEEK = 3600 * 24 * 7;
    21. /**
    22. * 缓存时效 1月
    23. */
    24. public static final int CACHE_EXP_MONTH = 3600 * 24 * 30;
    25. /**
    26. * 缓存时效 永久
    27. */
    28. public static final int CACHE_EXP_FOREVER = 0;
    29. /**
    30. * 冲突延时 1秒
    31. */
    32. public static final int MUTEX_EXP = 1;
    33. /**
    34. * 冲突键
    35. */
    36. public static final String MUTEX_KEY_PREFIX = "MUTEX_";
    37. /**
    38. * Logger for this class
    39. */
    40. private static final Logger logger = Logger
    41. .getLogger(MemcachedManager.class);
    42. /**
    43. * Memcached Client
    44. */
    45. @Autowired
    46. private MemcachedClient memcachedClient;
    47. /**
    48. * 缓存
    49. *
    50. * @param key
    51. * @param value
    52. * @param exp
    53. * 失效时间
    54. */
    55. public void cacheObject(String key, Object value, int exp) {
    56. try {
    57. memcachedClient.set(key, exp, value);
    58. } catch (Exception e) {
    59. logger.error(e.getMessage(), e);
    60. }
    61. logger.info("Cache Object: [" + key + "]");
    62. }
    63. /**
    64. * Shut down the Memcached Cilent.
    65. */
    66. public void finalize() {
    67. if (memcachedClient != null) {
    68. try {
    69. if (!memcachedClient.isShutdown()) {
    70. memcachedClient.shutdown();
    71. logger.debug("Shutdown MemcachedManager...");
    72. }
    73. } catch (Exception e) {
    74. logger.error(e.getMessage(), e);
    75. }
    76. }
    77. }
    78. /**
    79. * 清理对象
    80. *
    81. * @param key
    82. */
    83. public void flushObject(String key) {
    84. try {
    85. memcachedClient.deleteWithNoReply(key);
    86. } catch (Exception e) {
    87. logger.error(e.getMessage(), e);
    88. }
    89. logger.info("Flush Object: [" + key + "]");
    90. }
    91. /**
    92. * 冲突判定
    93. *
    94. * @param key
    95. */
    96. public boolean isMutex(String key) {
    97. return isMutex(key, MUTEX_EXP);
    98. }
    99. /**
    100. * 冲突判定
    101. *
    102. * @param key
    103. * @param exp
    104. * @return true 冲突
    105. */
    106. public boolean isMutex(String key, int exp) {
    107. boolean status = true;
    108. try {
    109. if (memcachedClient.add(MUTEX_KEY_PREFIX + key, exp, "true")) {
    110. status = false;
    111. }
    112. } catch (Exception e) {
    113. logger.error(e.getMessage(), e);
    114. }
    115. return status;
    116. }
    117. /**
    118. * 加载缓存对象
    119. *
    120. * @param key
    121. * @return
    122. */
    123. public <T> T loadObject(String key) {
    124. T object = null;
    125. try {
    126. object = memcachedClient.<T> get(key);
    127. } catch (Exception e) {
    128. logger.error(e.getMessage(), e);
    129. }
    130. logger.info("Load Object: [" + key + "]");
    131. return object;
    132. }
    133. }
    import net.rubyeye.xmemcached.MemcachedClient;
    
    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * 
     * @author Snowolf
     * @version 1.0
     * @since 1.0
     */
    @Component
    public class MemcachedManager {
    
    	/**
    	 * 缓存时效 1天
    	 */
    	public static final int CACHE_EXP_DAY = 3600 * 24;
    
    	/**
    	 * 缓存时效 1周
    	 */
    	public static final int CACHE_EXP_WEEK = 3600 * 24 * 7;
    
    	/**
    	 * 缓存时效 1月
    	 */
    	public static final int CACHE_EXP_MONTH = 3600 * 24 * 30;
    
    	/**
    	 * 缓存时效 永久
    	 */
    	public static final int CACHE_EXP_FOREVER = 0;
    
    	/**
    	 * 冲突延时 1秒
    	 */
    	public static final int MUTEX_EXP = 1;
    	/**
    	 * 冲突键
    	 */
    	public static final String MUTEX_KEY_PREFIX = "MUTEX_";
    	/**
    	 * Logger for this class
    	 */
    	private static final Logger logger = Logger
    			.getLogger(MemcachedManager.class);
    
    	/**
    	 * Memcached Client
    	 */
    	@Autowired
    	private MemcachedClient memcachedClient;
    
    	/**
    	 * 缓存
    	 * 
    	 * @param key
    	 * @param value
    	 * @param exp
    	 *            失效时间
    	 */
    	public void cacheObject(String key, Object value, int exp) {
    		try {
    			memcachedClient.set(key, exp, value);
    		} catch (Exception e) {
    			logger.error(e.getMessage(), e);
    		}
    		logger.info("Cache Object: [" + key + "]");
    	}
    
    	/**
    	 * Shut down the Memcached Cilent.
    	 */
    	public void finalize() {
    		if (memcachedClient != null) {
    			try {
    				if (!memcachedClient.isShutdown()) {
    					memcachedClient.shutdown();
    					logger.debug("Shutdown MemcachedManager...");
    				}
    			} catch (Exception e) {
    				logger.error(e.getMessage(), e);
    			}
    		}
    	}
    
    	/**
    	 * 清理对象
    	 * 
    	 * @param key
    	 */
    	public void flushObject(String key) {
    		try {
    			memcachedClient.deleteWithNoReply(key);
    		} catch (Exception e) {
    			logger.error(e.getMessage(), e);
    		}
    		logger.info("Flush Object: [" + key + "]");
    	}
    
    	/**
    	 * 冲突判定
    	 * 
    	 * @param key
    	 */
    	public boolean isMutex(String key) {
    		return isMutex(key, MUTEX_EXP);
    	}
    
    	/**
    	 * 冲突判定
    	 * 
    	 * @param key
    	 * @param exp
    	 * @return true 冲突
    	 */
    	public boolean isMutex(String key, int exp) {
    		boolean status = true;
    		try {
    			if (memcachedClient.add(MUTEX_KEY_PREFIX + key, exp, "true")) {
    				status = false;
    			}
    		} catch (Exception e) {
    			logger.error(e.getMessage(), e);
    		}
    		return status;
    	}
    
    	/**
    	 * 加载缓存对象
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public <T> T loadObject(String key) {
    		T object = null;
    		try {
    			object = memcachedClient.<T> get(key);
    		} catch (Exception e) {
    			logger.error(e.getMessage(), e);
    		}
    		logger.info("Load Object: [" + key + "]");
    		return object;
    	}
    
    }

    相关链接:
    Memcached笔记——(一)安装&常规错误&监控
    Memcached笔记——(二)XMemcached&Spring集成
    Memcached笔记——(三)Memcached使用总结

    Memcached笔记——(四)应对高并发攻击

    展开全文
  • 主要介绍了Windows服务器应对高并发和DDOS攻击的配置方法,本文讲解了应对高并发请求、应对DDOS攻击的多种配置方法,需要的朋友可以参考下
  • windows服务器应对高并发和DDOS攻击

    千次阅读 多人点赞 2013-08-02 17:22:09
    windows系统本身就有很多机制可以用来提高性能和安全,其中有不少可以用来应对高并发请求和DDOS攻击的情况。通过修改TCP延迟等待时间、最大用户端口、最大TCP控制块、最大哈希表大小、保持连接时间等可以有效提高...

    windows系统本身就有很多机制可以用来提高性能和安全,其中有不少可以用来应对高并发请求和DDOS攻击的情况。

    通过以下配置可以改善windows服务器性能:

    一、应对高并发请求:

    1TCP连接延迟等待时间 TcpTimedWaitDelay

    这是设定TCP/IP 可释放已关闭连接并重用其资源前,必须经过的时间。关闭和释放之间的此时间间隔通称 TIME_WAIT状态或两倍最大段生命周期(2MSL)状态。在此时间内,重新打开到客户机和服务器的连接的成本少于建立新连接。减少此条目的值允许 TCP/IP更快地释放已关闭的连接,为新连接提供更多资源。如果运行的应用程序需要快速释放和创建新连接,而且由于 TIME_WAIT中存在很多连接,导致低吞吐量,则调整此参数。缺省值240秒,最小30秒,最大300秒,建议设为30秒。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "TcpTimedWaitDelay"=dword:0000001e

    2、最大TCP使用端口 MaxUserPort:

    TCP客户端和服务器连接时,客户端必须分配一个动态端口,默认情况下这个动态端口的分配范围为 1024-5000,也就是说默认情况下,客户端最多可以同时发起3977Socket连接。通过修改调整这个动态端口的范围,可以提高系统的数据吞吐率

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "MaxUserPort"=dword:0000fffe

    3、保持连接时间 KeepAliveTime:

    Windows默认情况下不发送保持活动数据包,但某些TCP包中可能请求保持活动的数据包。保持连接可以被攻击者利用建立大量的连接造成服务器拒绝服务。降低这个参数值有助于系统更快速地断开非活动会话。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "KeepAliveTime"=dword:000493e0

    4、TCP数据最大重发次数 TcpMaxDataRetransmissions

    此参数控制TCP在连接异常中止前数据段重新传输的次数。如果这个限定次数内,计算机没有收到任何确认消息,连接将会被终止。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "TcpMaxDataRetransmissions"=dword:00000003
    5、TCP连接最大重发次数 TcpMaxConnectResponseRetransmissions

    此参数设定SYN-ACK等待时间,可以用来提高系统的网络性能。缺省时间为3,消耗时间为45秒;项值为2,消耗时间为21秒;项值为1,消耗时间为9秒;项值为0,表示不等待,消耗时间为3秒

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "TcpMaxConnectResponseRetransmissions"=dword:00000002

    二、应对DDOS攻击:(包括以上设置)

    1、SYN攻击防护 SynAttackProtect:

    为防范SYN攻击,Windows NT系统的TCP/IP协议栈内嵌了SynAttackProtect机制。SynAttackProtect机制是通过关闭某些socket选项,增加额外的连接指示和减少超时时间,使系统能处理更多的SYN连接,以达到防范SYN攻击的目的。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "SynAttackProtect"=dword:00000002

    2、无效网关检测功能 EnableDeadGWDetect:

    当服务器设置了多个网关,在网络不通畅的时候系统会尝试连接第二个网关。允许自动探测失效网关可导致 DoS,关闭它可以抵御SNMP攻击,优化网络。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "EnableDeadGWDetect"=dword:00000000

    3、ICMP重定向功能 EnableICMPRedirect:

    是否响应ICMP重定向报文。ICMP重定向报文有可能被用以攻击,所以系统应该拒绝接受此类报文,用以抵御ICMP攻击。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "EnableICMPRedirect"=dword:00000000

    4、IP源路由限制 DisableIPSourceRouting:

    是否禁用IP源路由包,禁用可以提高IP源路由保护级别,用以防范数据包欺骗

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "DisableIPSourceRouting"=dword:00000002

    5、路由发现功能 PerformRouterDiscovery:

    ICMP路由通告报文可以被用来增加路由表纪录,可能导致DOS攻击,所以禁止路由发现。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "PerformRouterDiscovery"=dword:00000000
    
    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces]
    "PerformRouterDiscovery"=dword:00000000

    6、服务器名响应功能 NoNameReleaseOnDemand

    允许计算机忽略除来自 Windows服务器以外的 NetBIOS名称发布请求。当攻击者发出查询服务器NetBIOS名的请求时,可以使服务器禁止响应。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "NoNameReleaseOnDemand"=dword:00000001

    7、Internet组管理协议级别 IGMPLevel

    用于控制系统在多大程度上支持IP组播和参与Internet组管理协议。缺省值为2,支持发送和接收组播数据;项值为1表示只支持发送组播数据;项值为0表示不支持组播功能。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters]
    "IGMPLevel"=dword:00000000

    8、匿名访问限制 RestrictAnonymous

    用于禁止匿名访问查看用户列表和安全权限。匿名访问可以使连接者与目标主机建立一条空连接而无需用户名和密码,利用这个空连接,连接者可以得到用户列表。有了用户列表,就可以穷举猜测密码。

    [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa]
    "restrictanonymous"=dword:00000001

    参考文章:

    1、http://technet.microsoft.com/library/dd349797(v=ws.10).aspx
    2、http://technet.microsoft.com/library/cc708591(v=WS.10).aspx
    3、http://technet.microsoft.com/library/cc163074.aspx
    4、http://technet.microsoft.com/library/cc940037.aspx
    5、http://www.isi.edu/touch/pubs/infocomm99/infocomm99-web
    6、http://support.microsoft.com/default.aspx?scid=kb;EN-US;q120642

    展开全文
  • 如何模拟并发请求

    2019-10-28 17:42:01
    网站出现恶意并发攻击,解决问题第一步,自己先模拟并发,进行测试 注意: session 登录状态,我们需要设置 cookie api 登录状态,我们一般需要设置 Bearer token 1.并发工具: postman - 网上各种说 ...
    网站出现恶意并发攻击,解决问题第一步,自己先模拟并发,进行测试
    
    	注意:
    		session 登录状态,我们需要设置 cookie
    
    		api 登录状态,我们一般需要设置 Bearer token
    
    
    	1.并发工具:
    		postman - 网上各种说 postman 并发测试,那是迭代请求,并非并发,错误
    
    		AB(Apache Bench) - 这个是经常听说的一款,很简单
    			参考:
    				ab(Apache Bench)命令详解以及压力测试模拟
    					https://blog.csdn.net/jiajiren11/article/details/79486967
    
    		JMeter - Apache JMeter是Apache组织开发的基于Java的压力测试工具
    			参考:
    				使用 JMeter 进行压力测试
    					https://www.cnblogs.com/stulzq/p/8971531.html
    
    		其他工具,没看,参考:
    			10大主流压力测试工具
    				https://blog.csdn.net/langzitianya/article/details/81479422
    
    			九款Web服务器性能压力测试工具
    				https://blog.csdn.net/qq_33440246/article/details/80591070
    
    	2.自己使用 PHP 来模拟并发
    		1>使用 guzzlehttp 的并发请求
    
    			use GuzzleHttp\Client;
    			use GuzzleHttp\Promise;
    			use Psr\Http\Message\ResponseInterface;
    			use GuzzleHttp\Exception\RequestException;
    			use GuzzleHttp\Exception\ServerException;
    
    		    /**
    		     * 模拟发红包 - 异步并发
    		     */
    		    public function mockSendRedPacketConcurrent($token)
    		    {
    		        $client = new Client([
    		            'base_uri' => 'http://xxx/api/',
    		        ]);
    
    		        $promises = [];
    		        for($i = 0; $i < 20; $i++){
    		            $promise = $client->postAsync('red/sent', [
    		                'headers' => [
    		                    'Accept' => 'application/json',
    
    		                    // 登录 token
    		                    'Authorization' => 'Bearer ' . $token,
    
    		                    // 模拟不同的虚拟IP
    		                    'X-Forwarded-For' => '168.1.1.' . $i,
    		                ],
    		                'query' => [
    		                    'red_money' => 100,
    		                    'red_type' => 1,
    		                    'red_group' => 184,
    		                    'red_num' => 1,
    		                    'red_title' => '恭喜发财',
    		                ],
    		            ]);
    		            $promises[] = $promise;
    		        }
    
    		        $results = Promise\unwrap($promises);
    
    		        foreach($results as $result){
    		            $body = $result->getBody();
    		            $content = $body->getContents();
    		            dump($content);
    		        }
    		    }
    
    		2>使用 curl 并发请求
    			https://www.cnblogs.com/52fhy/p/8908315.html
    			https://www.oschina.net/question/54100_58279
    
    		    /**
    		     * 模拟发红包 - Rolling cURL并发
    		     */
    		    public function mockSendRedPacketCurl()
    		    {
    		    	$token = '';
    
    		        $urls = [];
    		        for($i = 0; $i < 600; $i++){
    		            $urls[] = 'http://xxx/api/red/sent';
    		        }
    
    		        $responses = $this->rolling_curl($urls, $token, 30);
    		        dd($responses);
    		    }
    
    		    /**
    		     * Rolling cURL并发
    		     */
    		    private function rolling_curl($urls, $token, $delay) {
    		        $queue = curl_multi_init();
    		        $map = array();
    
    		        foreach ($urls as $i => $url) {
    		            $ch = curl_init();
    
    		            $headers = [
    	                    'Accept' => 'application/json',
    
    	                    // 登录 token
    	                    'Authorization' => 'Bearer ' . $token,
    
    	                    // 模拟不同的虚拟IP
    	                    'X-Forwarded-For' => '168.1.1.' . $i,
    		            ];
    		            $params = [
    		                'red_money' => 1,
    		                'red_type' => 2,
    		                'red_group' => '201910270025455db473899d72f',
    		                'red_num' => 1,
    		                'red_title' => '并发测试',
    		            ];
    		            // $params = [
    		            //     'red_money' => 100,
    		            //     'red_type' => 1,
    		            //     'red_group' => 184,
    		            //     'red_num' => 1,
    		            //     'red_title' => '恭喜发财',
    		            // ];
    		            curl_setopt($ch, CURLOPT_URL, $url);
    		            curl_setopt($ch, CURLOPT_POST, 1);
    		            curl_setopt($ch, CURLOPT_POSTFIELDS, $params);
    		            curl_setopt($ch, CURLOPT_TIMEOUT, 100);
    		            curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    		            curl_setopt($ch, CURLOPT_HEADER, 0);
    		            curl_setopt($ch, CURLOPT_NOSIGNAL, true);
    		            curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    
    		            curl_multi_add_handle($queue, $ch);
    		            $map[(string) $ch] = $url;
    		        }
    
    		        $responses = array();
    		        do {
    		            while (($code = curl_multi_exec($queue, $active)) == CURLM_CALL_MULTI_PERFORM) ;
    
    		            if ($code != CURLM_OK) { break; }
    
    		            // a request was just completed -- find out which one
    		            while ($done = curl_multi_info_read($queue)) {
    
    		                // get the info and content returned on the request
    		                $info = curl_getinfo($done['handle']);
    		                $error = curl_error($done['handle']);
    		                $content = curl_multi_getcontent($done['handle']);
    		                // $results = callback(curl_multi_getcontent($done['handle']), $delay);
    		                // $responses[$map[(string) $done['handle']]] = compact('info', 'error', 'results');
    		                $responses[] = [
    		                    'info' => $info,
    		                    'error' => $error,
    		                    'content' => $content,
    		                ];
    
    		                // remove the curl handle that just completed
    		                curl_multi_remove_handle($queue, $done['handle']);
    		                curl_close($done['handle']);
    		            }
    
    		            // Block for data in / output; error handling is done by curl_multi_exec
    		            if ($active > 0) {
    		                curl_multi_select($queue, 0.5);
    		            }
    
    		        } while ($active);
    
    		        curl_multi_close($queue);
    		        return $responses;
    		    }
    
    		参考文章:
    			模拟 ip 是可以的
    				https://blog.csdn.net/intel80586/article/details/8906779
    				不过 laravel 的 ip() 好像检测比较准确 
    
    			使用 guzzlehttp 来实现并发请求:
    				https://segmentfault.com/q/1010000007683839
    					使用guzzle发送异步请求返回的promise 调用 then 方法不会立即执行, 还必须要调用wait去等待所有的请求结束,才会执行
    
    			curl 并发:
    				https://www.cnblogs.com/52fhy/p/8908315.html
    				https://www.oschina.net/question/54100_58279
    
    
    
    
    

     

    展开全文
  • 分布式锁解决超卖的优化:《用分布式锁来防止库存超卖,但是是每秒上千订单的高并发场景,如何对分布式锁进行高并发优化来应对这个场景?》](https://blog.csdn.net/u010391342/article/details/84372342) 高并发...

    这两篇文章很简单易懂,自己看一下就行,所以没有自己写一下。蛮有趣的。

    分布式锁解决超卖的优化:《用分布式锁来防止库存超卖,但是是每秒上千订单的高并发场景,如何对分布式锁进行高并发优化来应对这个场景?》](https://blog.csdn.net/u010391342/article/details/84372342)

    高并发情况下出现的问题和如何解决:《Web大规模高并发请求和抢购的解决方案》

    展开全文
  • 将waf.php文件上传网站里,在核心文件里加入引用代码:include('waf.php');根据你文件存放的路径修改
  • redis缓存如何应对高并发请求和攻击

    千次阅读 2019-01-07 16:14:57
    发生缓存穿透,高并发场景下,如果是黑客恶意攻击也是致命的。那么在缓存这层怎么作保护方案尼 缓存穿透示意图 方案 1)缓存空数据 将数据库查询结果为空的key也存储在缓存中。当后续又出现该key的...
  • nginx利用limit模块设置IP并发防CC攻击

    万次阅读 2013-01-21 09:02:04
    来源:http://blog.xencdn.net/nginx-limit-conn-how-to/ ...   nginx利用limit模块设置IP并发防CC攻击
  • wpsshop商城b2c官方正版 php开源框架 高并发,抗ddos攻击 抗cc攻击 二次开发,学习必不可少的源码 测试可以使用 官方下载 含手机端 pc端。
  • 基于并发投影时序逻辑模型检测的入侵检测方法,朱维军,陈建辉,基于投影时序逻辑模型检测的入侵检测方法具有描述网络入侵者分段攻击的能力,然而对并发攻击仍无能为力,因为该逻辑无法直接描述
  • Nginx限制访问速率和最大并发连接数模块--limit (防止DDOS攻击) Tengine版本采用http_limit_req_module进行限制 具体连接请参考 http://tengine.taobao.org/document_cn/http_limit_req_cn.html 和官方nginx...
  • webbench接口并发测试

    2019-08-07 11:49:25
    介绍一个接口并发测试攻击webbench,对接口进行并发压力测试
  • HttpLimitZoneModule 限制并发连接数实例 limit_zone只能定义在http作用域,limit_conn可以定义在http server location作用域 http { limit_conn_zone $binary_remote_addr zone=conn:10m; #定义一个...
  • 下面方法可以防止黑客知道你的源服务器真实IP进行并发攻击,通常只需要保护动态文件请求,如PHP。 添加文件 nginx/conf/limit/whiteip.conf 里面是你要忽略限制的白名单IP地址,通常是你自己的地址或者CND地址,...
  • 并发编程总结

    万次阅读 2020-11-11 16:08:07
    并发编程 一、现代计算机的理论模型 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sSV7HdSh-1604483918602)(images/image-20201010142026285.png)] 独写速度:寄存器 > L1 > L2 &...
  • 并发学习

    2016-03-29 15:30:34
    网络:dns轮询+DDOS攻击防护 对于高并发并没有什么通用解决方案,必须根据业务场景进行分析,不同的业务场景对于架构的取舍是不一样的.但万变不离其宗,掌握这些处理高并发的分析方法还是很有必要的. 如何学习高...
  • 下面方法可以防止黑客知道你的源服务器真实IP进行并发攻击,通常只需要保护动态文件请求,如PHP。 添加文件 nginx/conf/limit/whiteip.conf 里面是你要忽略限制的白名单IP地址,通常是你自己的地址或者CND地址,...
  • 网站并发处理总结

    2017-12-20 08:49:47
    这种情况普通网站是不会出现的,决定于用户基数,除非有人通过脚本或工具攻击你的网站,攻击这属于安全问题,某天你的网站遭受DOS洪水攻击时,你想到的不是高并发,而是从安全层面处理。曾经做一次抢红包的活动遭遇...
  • 并发是指在同一个时间点,有很多用户同时的访问URL地址,比如:淘宝的双11,双12,就会产生高并发,如贴吧的爆吧,就是恶意的高并发请求,也就是DDOS攻击,再屌丝点的说法就像玩撸啊撸被ADC暴击了一样,那伤害你懂得...
  • SpringCloud实战视频下载Javaweb练手项目源码下载精选Javaweb相关...也就是DDOS攻击,再屌丝点的说法就像玩撸啊撸被ADC暴击了一样,那伤害你懂得(如果你看懂了这个说法,说明是正在奔向人生巅峰的屌丝。)高并发会...
  • TCP、HTTP负载均衡设置同时可防DDOS等恶意攻击,要做超大规模并发平台的看过来   配置如下:  global # 全局参数的设置  log 127.0.0.1 local2  # log语法:log &lt;address_1&gt;[max_level_1]  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,345
精华内容 28,138
关键字:

并发攻击