不是很明白如此刁钻的需求存在的意义。
 
当然，刁钻只是说在一个页面搞多个连接过于奢侈，对而言服务器更加奢侈。刁钻归刁钻，实现起来没有难度，参考 JavaScript 面向对象编程的任一方案，将连接对象的生成过程批量化或者封装成构造函数，每次需要建立连接的时候创建一个新的通信连接就可以了，还有收到消息之后要记得关闭连接，不然可能会因浏览器并发请求数量的限制而导致新连接失败，如果实现的时候产生闭包，还要考虑内存暴涨甚至泄露的问题。
 
// 工厂模式
 
fucntion establishSocket(options){
 
const socket = new WebSocket(options.url);
 
socket.open();
 
let messageQueue ; // 临时存储需要发送的信息
 
// 这里不考虑复用连接的情况，因为连接复用需要自定义通信协议
 
let messageHandler ; // 暂存消息处理回调函数
 
let errorHandler ; // 暂存错误处理回调函数
 
const handler = {
 
socket,
 
send: message => {
 
if(socket.readyState === 1){
 
socket.send(message)
 
} else {
 
messageQueue = message;
 
}
 
return {
 
then: (resolve, reject) => {
 
messageHandler = resolve;
 
errorHandler = reject;
 
}
 
}
 
}
 
};
 
socket.onopen = () => {
 
if(messageQueue){
 
socket.send(messageQueue);
 
}
 
};
 
socket.onmessage = e => {
 
if(messageHandler instanceof Function){
 
messageHandler(e);
 
messageHandler = null;
 
} else {
 
throw new Error('DEVELOP_ERROR: No webSocket response handler!')
 
};
 
socket.close();
 
};
 
socket.onerror = err => {
 
if(errorHandler instanceof Fucntion){
 
errorHandler(err);
 
errorHandler = null;
 
} else {
 
throw new Error(err);
 
}
 
}
 
// 这里的 return 会产生闭包，过多连接可能导致浏览器卡顿甚至崩溃
 
return handler;
 
}
 
// 使用的时候
 
establishSocket({url: 'your.socket.server.url'}).send('your message').then(e => {
 
// 在这里处理服务器返回的消息
 
});
 
以上代码没有测试过，不对其运行结果负责，毕竟单一页面内建立多个 socket 连接，始终不是一个好的设计方案，还不如使用 http 请求。

 
 

  勒索病毒“Satan”作为2018年最为活跃的勒索病毒之一，近日国内出现了其最新变种感染案例。该病毒不但可以在Windows和Linux下感染执行，而且还能利用多个应用漏洞进行传播。被加密的文件后缀名从起初的.satan更新为.lucky。目前***的C&C服务器仍然存活，不排除有大面积感染的可能。
  
勒索病毒核心Web应用漏洞如下：
  
Tomcat任意文件上传漏洞（CVE-2017-12615）
Tomcat web管理后台弱口令爆破
Weblogic WLS 组件漏洞（CVE-2017-10271）
Apache Struts2远程代码执行漏洞S2-045
Apache Struts2远程代码执行漏洞S2-057
Weblogic任意文件上传漏洞（CVE-2018-2894）
  


  
我们通过ZoomEye统计全国可能影响设备IP约137,850个。WebSOC网站立体监控系统最新4.6.38.0版本，可准确识别此病毒高危Web应用漏洞，请相关用户引起关注，及时做好设备检查和防护措施。
  
升级下载
  

   
1.离线升级包下载（系统管理-关于-获取证书编号登录）：http://update.knownsec.com。
   
2.在线自动升级：系统管理-版本升级-升级策略-开启自动升级。
  
  
临时防护建议
  
定期对重要数据进行备份。
检查crontab和rc.local文件，删除该病毒相关的启动信息。
检查/etc/rc6.d/S20loop文件指向的位置，删除该目录下相关的样本程序文件，包括.loop，.conn32/64，.cry32/64，最后删除/etc/rc6.d/S20loop文件。
为操作系统和相关应用设置复杂的登录口令。
及时更新相关应用的版本，或安装安全补丁来修复应用漏洞。
  
禁用Tomcat Web登录
  
由于该病毒会通过Tomcat爆破的方式进行传播，因此建议用户直接登录服务器进行应用部署，禁用Web管理页面的登录功能。
  
在Tomcat配置文件中，删除类似如下的配置项，即可禁用Web端登录：
  
IOC
  
C&C：
    

     
111.90.158.225
111.90.158.225/d/ft32
107.179.65.195/d/ft32
23.247.83.135/d/ft32
111.90.158.224/d/ft32
    
Hash：
    

     
34CDBBDA5F7C02CA179A366232ADBB96
     
84DDEE0187C61D8EB4348E939DA5A366
     
36E34E763A527F3AD43E9C30ACD276FF
     
D1AC4B74EE538DAB998085E0DFAA5E8D
     
A8CAB7C48D687B510FB8EAF053BD5722
     
7FCD8A6C72C06D1892132D5E1D793B4B
     
8D3C8045DF750419911C6E1BF493C747
     
E145264CFFA3C01A93871B27A4F569CC
     
3D659FC3561E94051998D11381A00BBD
     
226B25F47DD6C62077CF52AEB5A759E7
     
161090CAC8C73B249E8B9A939AB4B665
    
  


 
 
 
转载于:https://blog.51cto.com/14071176/2324286

今天，项目中用到了websocket，就找了一下相关资料。觉得这篇不错就转了一下。
 
一、websocket与http
 
WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）
 
首先HTTP有 1.1 和 1.0 之说，也就是所谓的 keep-alive ，把多个HTTP请求合并为一个，但是 Websocket 其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充可以通过这样一张图理解
 
 
有交集，但是并不是全部。
 
另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据，就是这样=。=
 
再简单来说，层级不一样。
 
二、Websocket是什么样的协议，具体有什么优点
 
首先，Websocket是一个持久化的协议，相对于HTTP这种非持久的协议来说。简单的举个例子吧，用目前应用比较广泛的PHP生命周期来解释。
 
HTTP的生命周期通过 Request 来界定，也就是一个 Request 一个 Response ，那么在 HTTP1.0 中，这次HTTP请求就结束了。
 
在HTTP1.1中进行了改进，使得有一个keep-alive，也就是说，在一个HTTP连接中，可以发送多个Request，接收多个Response。但是请记住 Request = Response， 在HTTP中永远是这样，也就是说一个request只能有一个response。而且这个response也是被动的，不能主动发起。
 
教练，你BB了这么多，跟Websocket有什么关系呢？_(:з」∠)_好吧，我正准备说Websocket呢。。
 
首先Websocket是基于HTTP协议的，或者说借用了HTTP的协议来完成一部分握手。
 
首先我们来看个典型的 Websocket 握手（借用Wikipedia的。。）
 
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
Origin: http://example.com
 
熟悉HTTP的童鞋可能发现了，这段类似HTTP协议的握手请求中，多了几个东西。我会顺便讲解下作用。
 
Upgrade: websocket
Connection: Upgrade
 
这个就是Websocket的核心了，告诉 Apache 、 Nginx 等服务器：注意啦，我发起的是Websocket协议，快点帮我找到对应的助理处理~不是那个老土的HTTP。
 
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
 
首先， Sec-WebSocket-Key 是一个 Base64 encode 的值，这个是浏览器随机生成的，告诉服务器：泥煤，不要忽悠窝，我要验证尼是不是真的是Websocket助理。
 
然后， Sec_WebSocket-Protocol 是一个用户定义的字符串，用来区分同URL下，不同的服务所需要的协议。简单理解：今晚我要服务A，别搞错啦~
 
最后， Sec-WebSocket-Version 是告诉服务器所使用的 Websocket Draft （协议版本），在最初的时候，Websocket协议还在 Draft 阶段，各种奇奇怪怪的协议都有，而且还有很多期奇奇怪怪不同的东西，什么Firefox和Chrome用的不是一个版本之类的，当初Websocket协议太多可是一个大难题。。不过现在还好，已经定下来啦~大家都使用的一个东西~ 脱水： 服务员，我要的是13岁的噢→_→
 
然后服务器会返回下列东西，表示已经接受到请求， 成功建立Websocket啦！
 
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
Sec-WebSocket-Protocol: chat
 
这里开始就是HTTP最后负责的区域了，告诉客户，我已经成功切换协议啦~
 
Upgrade: websocket
Connection: Upgrade
 
依然是固定的，告诉客户端即将升级的是 Websocket 协议，而不是mozillasocket，lurnarsocket或者shitsocket。
 
然后， Sec-WebSocket-Accept 这个则是经过服务器确认，并且加密过后的 Sec-WebSocket-Key 。 服务器：好啦好啦，知道啦，给你看我的ID CARD来证明行了吧。。
 
后面的， Sec-WebSocket-Protocol 则是表示最终使用的协议。
 
至此，HTTP已经完成它所有工作了，接下来就是完全按照Websocket协议进行了。具体的协议就不在这阐述了。
 
——————技术解析部分完毕——————
 
 
你TMD又BBB了这么久，那到底Websocket有什么鬼用， http long poll ，或者ajax轮询 不都可以实现实时信息传递么。
 
 
好好好，年轻人，那我们来讲一讲Websocket有什么用。来给你吃点胡（苏）萝（丹）卜（红）
 
 
三、Websocket的作用
 
在讲Websocket之前，我就顺带着讲下 long poll 和 ajax轮询 的原理。
 
ajax轮询
 
ajax轮询的原理非常简单，让浏览器隔个几秒就发送一次请求，询问服务器是否有新信息。
 
场景再现：
 
客户端：啦啦啦，有没有新信息(Request)
 
服务端：没有（Response）
 
客户端：啦啦啦，有没有新信息(Request)
 
服务端：没有。。（Response）
 
客户端：啦啦啦，有没有新信息(Request)
 
服务端：你好烦啊，没有啊。。（Response）
 
客户端：啦啦啦，有没有新消息（Request）
 
服务端：好啦好啦，有啦给你。（Response）
 
客户端：啦啦啦，有没有新消息（Request）
 
服务端：。。。。。没。。。。没。。。没有（Response） —- loop
 
long poll
 
long poll 其实原理跟 ajax轮询 差不多，都是采用轮询的方式，不过采取的是阻塞模型（一直打电话，没收到就不挂电话），也就是说，客户端发起连接后，如果没消息，就一直不返回Response给客户端。直到有消息才返回，返回完之后，客户端再次建立连接，周而复始。
 
场景再现：
 
客户端：啦啦啦，有没有新信息，没有的话就等有了才返回给我吧（Request）
 
服务端：额。。 等待到有消息的时候。。来 给你（Response）
 
客户端：啦啦啦，有没有新信息，没有的话就等有了才返回给我吧（Request） -loop
 
从上面可以看出其实这两种方式，都是在不断地建立HTTP连接，然后等待服务端处理，可以体现HTTP协议的另外一个特点，被动性。
 
何为被动性呢，其实就是，服务端不能主动联系客户端，只能有客户端发起。
 
简单地说就是，服务器是一个很懒的冰箱（这是个梗）（不会、不能主动发起连接），但是上司有命令，如果有客户来，不管多么累都要好好接待。
 
说完这个，我们再来说一说上面的缺陷（原谅我废话这么多吧OAQ）
 
从上面很容易看出来，不管怎么样，上面这两种都是非常消耗资源的。
 
ajax轮询 需要服务器有很快的处理速度和资源。（速度）long poll 需要有很高的并发，也就是说同时接待客户的能力。（场地大小）
 
所以 ajax轮询 和 long poll 都有可能发生这种情况。
 
客户端：啦啦啦啦，有新信息么？
 
服务端：月线正忙，请稍后再试（503 Server Unavailable）
 
客户端：。。。。好吧，啦啦啦，有新信息么？
 
服务端：月线正忙，请稍后再试（503 Server Unavailable）
 
客户端：
 
 
然后服务端在一旁忙的要死：冰箱，我要更多的冰箱！更多。。更多。。（我错了。。这又是梗。。）
 
言归正传，我们来说Websocket吧
 
通过上面这个例子，我们可以看出，这两种方式都不是最好的方式，需要很多资源。
 
一种需要更快的速度，一种需要更多的’电话’。这两种都会导致’电话’的需求越来越高。
 
哦对了，忘记说了HTTP还是一个状态协议。
 
通俗的说就是，服务器因为每天要接待太多客户了，是个健忘鬼，你一挂电话，他就把你的东西全忘光了，把你的东西全丢掉了。你第二次还得再告诉服务器一遍。
 
所以在这种情况下出现了，Websocket出现了。他解决了HTTP的这几个难题。首先，被动性，当服务器完成协议升级后（HTTP->Websocket），服务端就可以主动推送信息给客户端啦。所以上面的情景可以做如下修改。
 
客户端：啦啦啦，我要建立Websocket协议，需要的服务：chat，Websocket协议版本：17（HTTP Request）
 
服务端：ok，确认，已升级为Websocket协议（HTTP Protocols Switched）
 
客户端：麻烦你有信息的时候推送给我噢。。
 
服务端：ok，有的时候会告诉你的。
 
服务端：balabalabalabala
 
服务端：balabalabalabala
 
服务端：哈哈哈哈哈啊哈哈哈哈
 
服务端：笑死我了哈哈哈哈哈哈哈
 
就变成了这样，只需要经过一次HTTP请求，就可以做到源源不断的信息传送了。（在程序设计中，这种设计叫做回调，即：你有信息了再来通知我，而不是我傻乎乎的每次跑来问你 ）
 
这样的协议解决了上面同步有延迟，而且还非常消耗资源的这种情况。那么为什么他会解决服务器上消耗资源的问题呢？
 
其实我们所用的程序是要经过两层代理的，即HTTP协议在Nginx等服务器的解析下，然后再传送给相应的Handler（PHP等）来处理。简单地说，我们有一个非常快速的 接线员（Nginx） ，他负责把问题转交给相应的 客服（Handler） 。
 
本身接线员基本上速度是足够的，但是每次都卡在客服（Handler）了，老有客服处理速度太慢。，导致客服不够。Websocket就解决了这样一个难题，建立后，可以直接跟接线员建立持久连接，有信息的时候客服想办法通知接线员，然后接线员在统一转交给客户。
 
这样就可以解决客服处理速度过慢的问题了。
 
同时，在传统的方式上，要不断的建立，关闭HTTP协议，由于HTTP是非状态性的，每次都要重新传输 identity info （鉴别信息），来告诉服务端你是谁。
 
虽然接线员很快速，但是每次都要听这么一堆，效率也会有所下降的，同时还得不断把这些信息转交给客服，不但浪费客服的处理时间，而且还会在网路传输中消耗过多的流量/时间。
 
但是Websocket只需要一次HTTP握手，所以说整个通讯过程是建立在一次连接/状态中，也就避免了HTTP的非状态性，服务端会一直知道你的信息，直到你关闭请求，这样就解决了接线员要反复解析HTTP协议，还要查看identity info的信息。
 
同时由客户主动询问，转换为服务器（推送）有信息的时候就发送（当然客户端还是等主动发送信息过来的。。），没有信息的时候就交给接线员（Nginx），不需要占用本身速度就慢的客服（Handler）了
 
——————–
 
至于怎么在不支持Websocket的客户端上使用Websocket。。答案是： 不能
 
但是可以通过上面说的 long poll 和 ajax 轮询 来 模拟出类似的效果
 
——————–
 
内容转自知乎：http://www.zhihu.com/question/20215561 

  本文我们来实现一个基于WebSocket协议的案例。
 
WebSocket案例
 
1.需求分析
 
  Http协议是无状态的, 浏览器和服务器间的请求响应一次，下一次会重新创建连接.所有在有些情况下并不是太适用。这时websocket就是我们的一种实现方案，具体的websocket的内容网上很多，自行查阅哦，本文主要是介绍基于netty如何实现websocket通信。
 
要求：
 
实现基于webSocket的长连接的全双工的交互
改变Http协议多次请求的约束，实现长连接了， 服务器可以发送消息给浏览器
客户端浏览器和服务器端会相互感知，比如服务器关闭了，浏览器会感知，同样浏览器关闭了，服务器会感知
 
2.案例代码实现
 
2.1 服务端处理器
 
  服务器处理器中我们仅仅需要处理请求和客户端连接和端口的情况，具体如下：
 
package com.dpb.netty.websocket;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;

import java.time.LocalDateTime;


/**
 * @program: netty4demo
 * @description: 处理器
 * @author: 波波烤鸭
 * @create: 2019-12-30 22:39
 */
public class SocketServerHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, TextWebSocketFrame textWebSocketFrame) throws Exception {
        // 打印接收到的消息
        System.out.println("服务端接受到的消息:" + textWebSocketFrame.text());
        // 返回消息给客户端
        channelHandlerContext.writeAndFlush(new TextWebSocketFrame("服务器时间: " + LocalDateTime.now() + "  ： " + textWebSocketFrame.text()));
    }

    /**
     * 客户端连接的时候触发
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // LongText() 唯一的  ShortText() 不唯一
        System.out.println("handlerAdded：" + ctx.channel().id().asLongText());
        System.out.println("handlerAdded：" + ctx.channel().id().asShortText());
    }

    /**
     * 客户端断开连接的时候触发
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved：" + ctx.channel().id().asLongText());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常发生了...");
        ctx.close();
    }
}

 
2.2 服务端
 
  服务端代码在原有的基础上需要转换相关的协议，具体如下:
 
package com.dpb.netty.websocket;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.ServerSocketChannel;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.stream.ChunkedWriteHandler;

import java.net.ServerSocket;

/**
 * @program: netty4demo
 * @description: 基于WebSocket协议的服务端
 * @author: 波波烤鸭
 * @create: 2019-12-30 22:31
 */
public class SocketServerDemo {

    public static void main(String[] args) throws Exception {
        // 1.创建对应的EventLoopGroup对象
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();
        ServerBootstrap bootstrap = new ServerBootstrap();
        try{
            bootstrap.group(bossGroup,workGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // websocket 相关的配置
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            //因为基于http协议，使用http的编码和解码器
                            pipeline.addLast(new HttpServerCodec());
                            //是以块方式写，添加ChunkedWriteHandler处理器
                            pipeline.addLast(new ChunkedWriteHandler());

                            /*
                            说明
                                1. http数据在传输过程中是分段, HttpObjectAggregator ，就是可以将多个段聚合
                                2. 这就就是为什么，当浏览器发送大量数据时，就会发出多次http请求
                             */
                            pipeline.addLast(new HttpObjectAggregator(8192));
                            /*
                            说明
                                1. 对应websocket ，它的数据是以 帧(frame) 形式传递
                                2. 可以看到WebSocketFrame 下面有六个子类
                                3. 浏览器请求时 ws://localhost:8888/hello 表示请求的uri
                                4. WebSocketServerProtocolHandler 核心功能是将 http协议升级为 ws协议 , 保持长连接
                                5. 是通过一个 状态码 101
                             */
                            pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));
                            // 自定义handler，处理业务逻辑
                            pipeline.addLast(new SocketServerHandler());

                        }
                    });
            System.out.println("服务启动了....");
            ChannelFuture future = bootstrap.bind(8888).sync();
            future.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

 
2.3 客户端实现
 
  在客户端中我们就简单的实现一个HTML页面，在其中发送websocket协议相关的请求，然后接受相关的消息，如下，注意注释
 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>websocket案例测试</title>
</head>
<body>
<script>
    var socket;
    //判断当前浏览器是否支持websocket
    if(window.WebSocket) {
        //go on
        socket = new WebSocket("ws://localhost:8888/hello");
        //相当于channelReado, ev 收到服务器端回送的消息
        socket.onmessage = function (ev) {
            var rt = document.getElementById("responseText");
            rt.value = rt.value + "\n" + ev.data;
        }

        //相当于连接开启(感知到连接开启)
        socket.onopen = function (ev) {
            var rt = document.getElementById("responseText");
            rt.value = "连接开启了.."
        }

        //相当于连接关闭(感知到连接关闭)
        socket.onclose = function (ev) {

            var rt = document.getElementById("responseText");
            rt.value = rt.value + "\n" + "连接关闭了.."
        }
    } else {
        alert("当前浏览器不支持websocket")
    }

    //发送消息到服务器
    function send(message) {
        if(!window.socket) { //先判断socket是否创建好
            return;
        }
        if(socket.readyState == WebSocket.OPEN) {
            //通过socket 发送消息
            socket.send(message)
        } else {
            alert("连接没有开启");
        }
    }
</script>
<form onsubmit="return false">
    <textarea name="message" style="height: 300px; width: 300px"></textarea>
    <input type="button" value="发生消息" onclick="send(this.form.message.value)">
    <textarea id="responseText" style="height: 300px; width: 300px"></textarea>
    <input type="button" value="清空内容" onclick="document.getElementById('responseText').value=''">
</form>
</body>
</html>
 
3.测试分析
 
  分别运行服务器和客户端，访问测试，如下：
 
 
 
运行效果：
 
 
同时在第一次运行的时候打开调试环境：
 
 
好了，本文我们就介绍到此，感兴趣的可以自己运行下
 
欢迎关注点赞O(∩_∩)O哈哈~