精华内容
下载资源
问答
  • websocket 通信协议

    千次阅读 2012-07-27 21:38:46
    websocket通信协议实现的是基于浏览器的原生socket,在客户端用JS即可轻松完成,前些天都在学习websocket 协议(但实际上websocket 协议甚为简约),并且粗略的思考过websocket的对于下一代web应用会产生怎样的...

     

    分类: html / xml 346人阅读 评论(0) 收藏 举报

    websocket通信协议实现的是基于浏览器的原生socket,在客户端用JS即可轻松完成,前些天都在学习websocket 协议(但实际上websocket 协议甚为简约),并且粗略的思考过websocket的对于下一代web应用会产生怎样的影响,我想最大的巨变应该是就是实时性上吧!另外诸如上传大文件之类的优于http的应用。但问题也随之而来,服务端怎么办?前些天我弄了个websocket 聊天室的demo,现在还得在服务器上专门开个进程来跑呢,也许到时候不再是简单架设个web server就能跑应用的了。也许过不了多久,会出不同的服务端方案吧!先期待一下。

    websocket的协议是很简单的,这里我把它分成客户端和服务端来讲。在客户端,newWebSocket即可实例化一个新的websocket对象,但其参数略微有一点不一样,参数格式是这样的ws://yourdomain:port/path ,这个从我的聊天室demo里面就可以轻松看出(ws = newWebSocket( “ws://www.zendstudio.net:9108/chat” ); ),WebSocket对象会自动解析这段字符串,发送到指定服务器端口,首先执行的是双方握手(handshake),客户端发送数据格式类似这样:

    1. GET /chat HTTP/1.1  
    2. Upgrade: WebSocket  
    3. Connection: Upgrade  
    4. Host: www.zendstudio.net:9108  
    5. Origin: http://www.zendstudio.net  
    6. Cookie: somenterCookie  
    GET /chat HTTP/1.1
    Upgrade: WebSocket
    Connection: Upgrade
    Host: www.zendstudio.net:9108
    Origin: http://www.zendstudio.net
    Cookie: somenterCookie

    这很是有些类似于http的头信息,同样每行都是以”/r/n”结尾的,上面这段格式无需我们去构造,WebSocket对象会自动发送,对客户端这是透明的。此时服务端应该返回的信息是:

    1. HTTP/1.1 101 Web Socket Protocol Handshake  
    2. Upgrade: WebSocket  
    3. Connection: Upgrade  
    4. WebSocket-Origin: http://www.zendstudio.net  
    5. WebSocket-Location: ws://www.zendstudio.net:9108/chat  
    HTTP/1.1 101 Web Socket Protocol Handshake
    Upgrade: WebSocket
    Connection: Upgrade
    WebSocket-Origin: http://www.zendstudio.net
    WebSocket-Location: ws://www.zendstudio.net:9108/chat

    从这里我们太容易看出来,websocket协议的握手部分根本就是个类http的协议,所不同的是http每次都会有这样子的头信息交互,这在某些时候不得不显得很糟糕。而websocket只会执行一次这个过程,之后的传输信息就变得异常简洁了。

    客户端在握手成功后,会触发WebSocket对象的onopen事件,告诉客户端连接已经成功建立了。客户端的WebSocket对象一共绑定了四个事件:1、onopen:连接建立时触发;2、onmessage:收到服务端消息时触发;3、onerror:连接出错时触发;4、onclose:连接关闭时触发;有了这4个事件,我们就可以很容易很轻松的驾驭websocket,并且需要说明的是websocket支持二进制数据的传输,因此,它远不止聊天室应用这么简单。

    服务端呢?服务端也是非常简单的,但是仍然需要注意的问题是,作为服务器,安全和性能是不可忽略的,除此之外,只管往socket里面写数据就可以了,websocket的通信数据全部是以”/x00″开头以”/xFF”结尾的,无论是服务端发出的数据还是客户端发送的数据都遵从这个格式,唯一不同的是客户端的WebSocket对象能够自动将头尾去除,获得主体数据,这就省却了我们在客户端处理原始数据的必要,真是个体贴周到的对象啊!顺便说一句,WebSocket通信数据的编码总是UTF-8格式的

    好了,websocket协议就是这么简单。到这里,写一个服务端应该不是什么困难的事情了吧?这仅仅需要一点点socket编程知识,任何语言都可以轻松实现。另外,我想说下源码的事情,有童鞋给我留言希望看看我的服务端源码,我想想还是算了,当我公布的源码徒增自己一堆麻烦,因为一部分人把我当成写应用的了,他们总是会说:“这代码怎么不能用?”,或者说“你能再修改下源代码,以便实现下我们公司当前需要用到的XXX功能吗?”我本为技术交流,之前公布飞信php源代码的时候,就遇到太多这样的情况,我并没有为飞信php建立项目,我不可能花很多时间去跟踪飞信协议变化,不断维护我的代码。同样的,这次的websocketphp服务端源代码我也不打算献丑了,还是不了。非常感谢大家持久以来的支持,希望我们能继续讨论技术本身。

     

     

     

     

    HTML5 WebSocket:下一次Web通信革命揭幕

    分类: 互联网/网络 C#.Net/ASP.Net/ADO.Net 1503人阅读 评论(1) 收藏 举报
    • 让我们一起来了解HTML 5对当前Web通信的改变。HTML 5 Web Socket通过在Web上的一个单一Socket定义了一个全双工通信信道为Web通信带来了显著的改善。

    HTML5 WebSocket:下一次Web通信革命揭幕

     

    【51CTO译文】关于HTML 5的各种前沿技术应用51CTO已经报道过很多,比如HTML 5的视频音频元素、HTML 5 Web SQL Database、HTML5 File API以及如何从零开始构建一个HTML 5页面等等。这些都是HTML 5对当前Web开发标准技术的升级或扩展。今天,51CTO带您了解HTML 5的另一面——HTML 5 Web Socket,以及它对当前Web通信的改变。

    最近关于HTML 5 Web Socket的流言已经满天飞,它通过Web上的一个单一Socket定义了一个全双工通信信道,HTML 5 Web Socket并不是普通HTTP通信的增强版,它代表着一个巨大的进步,特别是针对实时的、事件驱动的Web应用程序

    Google的工程师Ian Hickson说“数据的字节数急剧减少到2字节,延迟从150毫秒减少到50毫秒,实际上,这两个因素已经足以引起Google的兴趣了”。通过在一个浏览器中模拟全双工连接,HTML 5 Web Socket对Web通信带来了显著的改善。

    让我们与传统的解决方案相比,看看HTML 5 Web Socket是如何减少不必要的网络流量和延迟的。

    当前的Web通信——头疼的轮询 (Polling)

    通常,当浏览器访问一个网页时,会向托管该网页的Web服务器发送一个HTTP请求,Web服务器识别这一请求,并返回响应。例如,股票价格,新闻报道,门票销售,流量模式,医疗设备读数等,在浏览器渲染页面时,响应可能会过期,如果你想获得最新的“实时”信息,你可以不断地手动刷新页面,但显然这不是最好的办法。

    目前提供的实时Web程序主要是围绕轮询和其它服务器端推送技术进行的,最著名的是Comnet,它推迟了HTTP响应的结束,基于Comnet的推送通常是使用JavaScript结合长轮询(Long Polling)或流连接策略实现的。

    使用轮询时,浏览器定期发送HTTP请求,并立即收到响应,这种技术是交付实时信息的第一次尝试,显然,如果知道消息传递的时间间隔,这算是一个好办法,因为你可以在服务器上的信息可用时同步客户端请求,但实时数据往往是不可预测的,不可避免会产生一些不必要的请求,导致许多连接处于打开状态,有些不必关闭的连接却被关闭了。

    使用长轮询时,浏览器向服务器发送一个请求,服务器在既定期限内保持请求处于打开状态,如果在此期间收到通知,向客户端发送一个包含消息的响应,如果在此期间没有收到消息,服务器发送一个响应终止打开的请求。最重要的是要理解,当你的信息容量很高时,长轮询与传统的轮询相比不提供任何性能改善。实际上,它可能更糟,因为长轮询可能会失控进入一个死循环。

    使用流时,浏览器发送一个完整的请求,但服务器发送一个响应,并保存打开状态,然后不断更新使其一直保持打开(或在一段时间内保持打开),无论何时消息准备好发送时,响应就更新,但服务器不会发送一个结束的响应,因此连接就一直保持打开状态,后面发送的消息就可以继续使用这个连接。但流仍然是封装在 HTTP中的,阻扰了防火墙和代理服务器选择缓冲区中的内容进行响应,因此消息传递的时间就延长了。许多流式Comnet解决方案都转向了长轮询,另外,TLS(SSL)连接可以用来屏蔽来自缓冲区的响应,但在这种情况下,每个连接消耗的服务器资源更多了。

    最终,所有这些方法都提供了实时数据,包含HTTP请求和响应头,其中包含许多额外的,不必要的头数据,最重要的是,全双工连接需要的不仅仅是从服务器到客户端的下行连接。为了模拟基于半双工HTTP上的全双工通信,目前的许多解决方案都使用了两个连接:一个下行连接,一个上行连接。维护和协调这两个连接需要大量的系统开销,并增加了复杂性。简言之,HTTP不是为实时的,全双工通信设计的,如图1所示,它显示了构建一个Comnet Web应用程序的复杂性,它从后端数据源使用发布/订阅模式基于半双工HTTP显示实时数据。

    Comnet程序的复杂性 
    图 1:Comnet程序的复杂性

    当你试图向外扩展那些Comet解决方案时,情况变得更糟糕,模拟基于HTTP的双向通信容易出错,即使最终用户感觉某些东西看起来象是一个实时Web应用程序,但这种“实时”体验的代价都是非常高昂的,需要付出更多的延迟等待时间,不必要的网络流量和对CPU性能的拖累。

     

    HTML 5 Web Socket ——拯救

    HTML 5 Web Socket定义在HTML 5规范的通信章节,它代表Web通信的下一个演变:通过一个单一的Socket实现一个全双工,双向通信的信道。HTML 5 Web Socket提供了一个真正的标准,你可以使用它构建可扩展的实时Web应用程序。此外,由于它提供了一个浏览器自带的套接字,消除了Comet解决方案的许多问题,Web Socket显著降低了系统开销和复杂性。

    为了建立一个Web Socket连接,客户端和服务器在初始握手期间要从HTTP协议升级到WebSocket协议,如下面的例子:

    例1:WebSocket握手(浏览器请求,服务器响应)

        
    1. GET /text HTTP/1.1/r/n  
    2. Upgrade: WebSocket/r/n  
    3. Connection: Upgrade/r/n  
    4. Host: www.websocket.org/r/n  
    5. .../r/n  
    6. HTTP/1.1 101 WebSocket Protocol Handshake/r/n  
    7. Upgrade: WebSocket/r/n  
    8. Connection: Upgrade/r/n  
    9. .../r/n 

    建立好连接后,WebSocket数据帧就可以在客户端和服务器之间以全双工模式传输,在同一时间任何方向,可以全双工发送文本和二进制帧,最小的帧只有2个字节。在文本帧中,每一帧始于0x00直接,止于0xFF字节,数据使用UTF-8编码。WebSocket文本帧使用终结器,而二进制帧使用一个长度前缀。

    注意:虽然WebSocket协议已经可以支持多种客户端,但不能将原始数据传递给 JavaScript,因为JavaScript不支持字节类型,因此,如果客户端是JavaScript,二进制数据会被忽略,但可以传递给支持字节类型的客户端。

    Comet和HTML 5 Web Socket之间的对决

    人们最关注的是HTML 5 Web Socket如何减少不必要的网络流量和延迟,我们比较一个轮询应用程序和Web Socket应用程序就知道了。

    对于轮询的例子,我创建了一个简单的Web应用程序,一个网页使用传统的发布/订阅模式从 RabbitMQ消息代理请求实时的股票数据,它是通过轮询一个托管在Web服务器上的Java Servlet实现的,RabbitMQ消息代理从一个虚构的,不断更新价格的股票价格源接收数据,网页连接并订阅一个特定的股票频道(消息代理上的一个主题),使用XMLHttpRequest每秒更新一次进行轮询。当收到更新时,执行一些计算,然后将股票数据显示在图2所示的表中。

    一个JavaScript股票行情应用程序 
    图 2:一个JavaScript股票行情应用程序

    注意:后端的股票源每秒实际上产生了大量的股票价格更新,因此使用每秒一次轮询的方式比使用长轮询方式更好,长轮询会产生许多连续的轮询,轮询会更有效地阻止传入更新。

    这一切看起来还不错,但仔细观察,你就会发现这种应用程序存在严重的问题,例如,使用Firefox的Firebug插件(允许你调试网页和监控页面加载和脚本执行时间),你可以看到每秒都有一个GET请求砸向服务器。打开Live HTTP Headers(另一个Firefox 插件,显示实时的HTTP消息头流量)揭示每个请求关联的消息头开销数量是相当惊人的。下面两个例子显示了一个请求和响应的HTTP消息头数据。

    例2:HTTP请求头

        
    1. GET /PollingStock//PollingStock HTTP/1.1  
    2. Host: localhost:8080  
    3. User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.1.5) Gecko/20091102 Firefox/3.5.5  
    4. Accept: text/html,application/xhtml+xml,application/xml; q = 0 .9,*/*; q = 0 .8  
    5. Accept-Language: en-us  
    6. Accept-Encoding: gzip,deflate  
    7. Accept-Charset: ISO-8859-1,utf-8; q = 0 .7,*; q = 0 .7  
    8. Keep-Alive: 300  
    9. Connection: keep-alive  
    10. Referer: http://www.example.com/PollingStock/  
    11. Cookie:  showInheritedConstant = falseshowInheritedProtectedConstant = falseshowInheritedProperty = falseshowInheritedProtectedProperty = falseshowInheritedMethod = false ;   showInheritedProtectedMethod = false ;   showInheritedEvent = falseshowInheritedStyle = falseshowInheritedEffect = false  

    例3:HTTP响应头

        
    1. HTTP/1.x 200 OK  
    2. X-Powered-By: Servlet/2.5  
    3. Server: Sun Java System Application Server 9.1_02  
    4. Content-Type: text/html; charset = UTF -8  
    5. Content-Length: 21  
    6. Date: Sat, 07 Nov 2009 00:32:46 GMT 

    HTTP请求和响应头信息开销总共包括871字节,而且还不包括任何数据,当然,这只是一个例子,你的消息头数据完全可能低于871字节,但我也看到过消息头数据超过2000字节的情况。在这个例子中,股票主题消息数据大约只有20个字符。

    当你把这样的程序大规模部署给用户时会怎么样?我们使用三个不同的用例观察一下该轮询应用程序关联的HTTP请求和响应头数据需要的网络吞吐量。

    用例A:1000客户端,每秒轮询一次
    网络吞吐量(871x1000)=871000字节=6968000比特/秒(6.6Mbps)

    用例B:10000客户端,每秒轮询一次
    网络吞吐量(871x10000)=8710000字节=69680000比特/秒(66Mbps)

    用例C:100000客户端,每秒轮询一次
    网络吞吐量(871x100000)=87100000字节=696800000比特/秒(665Mbps)

    这是一个不必要的巨大的网络吞吐量,这时我们可以使用HTML 5 Web Socket,我使用HTML 5 Web Socket重构了应用程序,给网页添加了一个事件处理程序,同步监听来自消息代理的股票更新消息。每个消息都是一个Web Socket帧,开销只有2个字节(而不是871字节),再来看看对网络吞吐量的影响。

    用例A:1000客户端,每秒轮询一次
    网络吞吐量(2x1000)=2000字节=16000比特/秒(0.015Mbps)

    用例B:10000客户端,每秒轮询一次
    网络吞吐量(2x10000)=20000字节=160000比特/秒(0.153Mbps)

    用例C:100000客户端,每秒轮询一次
    网络吞吐量(2x100000)=200000字节=1600000比特/秒(1.526Mbps)

    正如你在图3中可以看到的,与轮询解决方案相比,HTML 5 Web Socket减少了不必要的网络流量。

     

     
    图 3:比较轮询和WebSocket应用程序之间的网络吞吐量

    延迟减少怎么样呢?看看图4便知,图中上半部分显示了半双工轮询方案的延迟,这里我们假设消息从服务器传输到浏览器需要50毫秒,轮询方式引入许多额外的延迟,因为当响应完成时,一个新的请求已经发送到服务器了,这个新请求又需要50毫秒,在此期间服务器不能发送任何消息给浏览器,导致额外的服务器内存消耗。

    图4下半部分显示了Web Socket方式产生的延迟,一旦连接升级到Web Socket,消息的传输会更及时,从服务器传输到浏览器仍然需要50毫秒,但Web Socket连接保持打开,之后就再也不用向服务器发送请求了。

    比较轮询和WebSocket应用程序之间的网络吞吐量 
    图 4:轮询和Web Socket应用程序之间的延迟对比

    HTML5 Web Socket和Kaazing WebSocket网关

    目前,只有Google的Chrome浏览器原生支持HTML 5 Web Socket,但其它浏览器也将提供支持,若要解决这个限制,Kaazing Web Socket网关为所有旧浏览器(IE 5.5+,Firefox 1.5+,Safari 3.0+和Opera 9.5+)提供了一个完整的Web Socket仿真,因此你现在就可以使用HTML 5 Web Socket API。

    Web Socket很了不起,但在你的浏览器中有一个全双工套接字连接后可以做什么呢?为了充分利用HTML 5 Web Socket的全部功能,Kaazing为二进制通信提供了一个ByteSocket库,为诸如Stomp、AMQP、XMPP、IRC等协议提供了更高级的库,它们都是建立在Web Socket之上的。

    例如,如果你为Stomp或AMQP协议使用了一个更高级的库,这时你可以直接与后端消息代理如RabbitMQ进行通信,通过直接连接服务,不再需要额外的应用程序服务逻辑将这些双向,全双工TCP后端协议转换成非双向,半双工HTTP连接,因为浏览器本身就可以理解这些协议。

    5 Kaazing Web Socket网关扩展基于TCP的消息,并具有更好的性能 
    5 :Kaazing Web Socket网关扩展基于TCP的消息,并具有更好的性能

    总结

    HTML 5 Web Socket在实时Web应用扩展性方面朝前迈出了一大步,正如你在本文中所看到的,HTML 5 Web Socket可以提供5000:1或 – 根据HTTP消息头大小 – 1000:1的比例减少不必要的HTTP头流量和3:1的比例减少通信延迟,这不是一个渐进式的改进,而是一次革命性的飞跃。

    Kaazing Web Socket网关让HTML 5 Web Socket代码能够在所有浏览器中运行,同时提供额外的协议库允许你充分利用HTML 5 Web Socket提供的全双工套接字连接功能,直接与后端服务进行通信。

     

     
     

    甲骨文发布JSR 356 针对WebSocket的Java API

    2012-02-10 13:29 | 2785次阅读 | 【已有12条评论】发表评论

    来源:oracle | 收藏到我的网摘

    甲骨文公司近日申请了JSR 356规范,据描述,这是“针对WebSocket的Java API”,旨在定义一个用于创建WebSocket应用程序的标准API。规范的领导者是Danny Coward。

    甲骨文称,尽管在GrizzlyGlassFish中,服务器端和客户端都能很好地支持WebSocket,但如果有一个标准的话,可以更好地发展可移植代码。随着这个JSR的加入,Java EE 7现在更加完整了。

    该规范预计在本月21日开始评审投票,通过后将被列出Java EE 7中。

    展开全文
  • WebSocket通信协议应用安全问题分析

    千次阅读 2017-08-01 10:22:00
    WebSocket通信协议于2011年被IETF定为标准RFC 6455,WebSocket API也被W3C定为标准,主流的浏览器都已经支持WebSocket通信。 WebSocket协议是基于TCP协议上的独立的通信协议,在建立WebSocket通信连接前,需要使...

    WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。WebSocket通信协议于2011年被IETF定为标准RFC 6455,WebSocket API也被W3C定为标准,主流的浏览器都已经支持WebSocket通信。

    WebSocket协议是基于TCP协议上的独立的通信协议,在建立WebSocket通信连接前,需要使用HTTP协议进行握手,从HTTP连接升级为WebSocket连接。浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输。

    WebSocket定义了两种URI格式, “ws://“和“wss://”,类似于HTTP和HTTPS, “ws://“使用明文传输,默认端口为80,”wss://“使用TLS加密传输,默认端口为443。

     
     
    1. ws-URI: "ws://host[:port]path[?query]"  
    2. wss-URI: "wss://host[:port]path[?query]" 

    WebSocket 握手阶段,需要用到一些HTTP头,升级HTTP连接为WebSocket连接如下表所示。

    WebSocket应用安全问题分析

    一次完整的握手连接如下图:

    WebSocket应用安全问题分析

    一旦服务器端返回 101 响应,即可完成 WebSocket 协议切换。服务器端可以基于相同端口,将通信协议从 http://或 https:// 切换到 ws://或 wss://。协议切换完成后,浏览器和服务器端可以使用 WebSocket API 互相发送和收取文本和二进制消息。

    WebSocket应用安全问题

    WebSocket作为一种通信协议引入到Web应用中,并不会解决Web应用中存在的安全问题,因此WebSocket应用的安全实现是由开发者或服务端负责。这就要求开发者了解WebSocket应用潜在的安全风险,以及如何做到安全开发规避这些安全问题。

    认证

    WebSocket 协议没有规定服务器在握手阶段应该如何认证客户端身份。服务器可以采用任何 HTTP 服务器的客户端身份认证机制,如 cookie认证,HTTP 基础认证,TLS 身份认证等。在WebSocket应用认证实现上面临的安全问题和传统的Web应用认证是相同的,如: CVE-2015-0201 , Spring框架的Java SockJS客户端生成可预测的会话ID,攻击者可利用该漏洞向其他会话发送消息; CVE-2015-1482 , Ansible Tower未对用户身份进行认证,远程攻击者通过websocket连接获取敏感信息。

    授权

    同认证一样,WebSocket协议没有指定任何授权方式,应用程序中用户资源访问等的授权策略由服务端或开发者实现。WebSocket应用也会存在和传统Web应用相同的安全风险,如:垂直权限提升和水平权限提升。

    跨域请求

    WebSocket使用基于源的安全模型,在发起WebSocket握手请求时,浏览器会在请求中添加一个名为Origin的HTTP头,Oringin字段表示发起请求的源,以此来防止未经授权的跨站点访问请求。WebSocket 的客户端不仅仅局限于浏览器,因此 WebSocket 规范没有强制规定握手阶段的 Origin 头是必需的,并且WebSocket不受浏览器同源策略的限制。如果服务端没有针对Origin头部进行验证可能会导致跨站点WebSocket劫持攻击。该漏洞最早在 2013 年被Christian Schneider 发现并公开,Christian 将之命名为跨站点 WebSocket 劫持 (Cross Site WebSocket Hijacking)(CSWSH)。跨站点 WebSocket 劫持危害大,但容易被开发人员忽视。相关案例可以参考: IPython Notebook( CVE-2014-3429 ), OpenStack Compute( CVE-2015-0259 ), Zeppelin WebSocket服务器 等跨站WebSocket劫持。

    WebSocket应用安全问题分析

    上图展示了跨站WebSocket劫持的过程,某个用户已经登录了WebSocket应用程序,如果他被诱骗访问了某个恶意网页,而恶意网页中植入了一段js代码,自动发起 WebSocket 握手请求跟目标应用建立 WebSocket 连接。注意到,Origin 和 Sec-WebSocket-Key 都是由浏览器自动生成的,浏览器再次发起请求访问目标服务器会自动带上Cookie 等身份认证参数。如果服务器端没有检查 Origin头,则该请求会成功握手切换到 WebSocket 协议,恶意网页就可以成功绕过身份认证连接到 WebSocket 服务器,进而窃取到服务器端发来的信息,或者发送伪造信息到服务器端篡改服务器端数据。与传统跨站请求伪造(CSRF)攻击相比,CSRF 主要是通过恶意网页悄悄发起数据修改请求,而跨站 WebSocket 伪造攻击不仅可以修改服务器数据,还可以控制整个双向通信通道。也正是因为这个原因,Christian 将这个漏洞命名为劫持(Hijacking),而不是请求伪造(Request Forgery)。

    理解了跨站WebSocket劫持攻击的原理和过程,那么如何防范这种攻击呢?处理也比较简单,在服务器端的代码中增加 对Origin头的检查,如果客户端发来的 Origin 信息来自不同域,服务器端可以拒绝该请求。但是仅仅检查 Origin 仍然是不够安全的,恶意网页可以伪造Origin头信息,绕过服务端对Origin头的检查,更完善的解决方案可以借鉴CSRF的解决方案-令牌机制。

    拒绝服务

    WebSocket设计为面向连接的协议,可被利用引起客户端和服务器端拒绝服务攻击,相关案例可参考: F5 BIG-IP远程拒绝服务漏洞( CVE-2016-9253 )。

    1. 客户端拒绝服务

    WebSocket连接限制不同于HTTP连接限制,和HTTP相比,WebSocket有一个更高的连接限制,不同的浏览器有自己特定的最大连接数,如:火狐浏览器默认最大连接数为200。通过发送恶意内容,用尽允许的所有Websocket连接耗尽浏览器资源,引起拒绝服务。

    2. 服务器端拒绝服务

    WebSocket建立的是持久连接,只有客户端或服务端其中一发提出关闭连接的请求,WebSocket连接才关闭,因此攻击者可以向服务器发起大量的申请建立WebSocket连接的请求,建立持久连接,耗尽服务器资源,引发拒绝服务。针对这种攻,可以通过设置单IP可建立连接的最大连接数的方式防范。攻击者还可以通过发送一个单一的庞大的数据帧(如, 2^16),或者发送一个长流的分片消息的小帧,来耗尽服务器的内存,引发拒绝服务攻击, 针对这种攻击,通过限制帧大小和多个帧重组后的总消息大小的方式防范。

    中间人攻击

    WebSocket使用HTTP或HTTPS协议进行握手请求,在使用HTTP协议的情况下,若存在中间人可以嗅探HTTP流量,那么中间人可以获取并篡改WebSocket握手请求,通过伪造客户端信息与服务器建立WebSocket连接,如下图所示。防范这种攻击,需要在加密信道上建立WebSocket连接,使用HTTPS协议发起握手请求。

    WebSocket应用安全问题分析

    输入校验

    WebSocket应用和传统Web应用一样,都需要对输入进行校验,来防范来客户端的XSS攻击,服务端的SQL注入,代码注入等攻击。

    总结

    Websocket是一个基于TCP的HTML5的新协议,可以实现浏览器和服务器之间的全双工通讯。在即时通讯等应用中,WebSocket具有很大的性能优势, 并且非常适合全双工通信,但是,和任何其他技术一样,开发WebSocket应用也需要考虑潜在的安全风险。



    作者:佚名

    来源:51CTO

    展开全文
  • 深入WebSocket通信协议细节

    千次阅读 2017-04-23 20:05:30
    WebSocket出现之前,Web端为了实现即时通讯,所用的技术都是Ajax轮询(polling)。轮询是在特定的的时间间隔(如每1秒),由浏览器对服务器发出HTTP request,然后由服务器返回最新的数据给客服端的浏览器。这种传统的...

    传统“长轮询”实现Web端即时通讯的问题


    WebSocket出现之前,Web端为了实现即时通讯,所用的技术都是Ajax轮询(polling)。轮询是在特定的的时间间隔(如每1秒),由浏览器对服务器发出HTTP request,然后由服务器返回最新的数据给客服端的浏览器。这种传统的HTTP request 的模式带来很明显的缺点 – 浏览器需要不断的向服务器发出请求,然而HTTP request 的header是非常长的,里面包含的数据可能只是一个很小的值,这样会占用很多的带宽。

    而比较新的技术去做轮询的效果是Comet ,   但这种技术虽然可达到全双工通信,依然需要发出请求。

    WebSocket 技术概览


    在 WebSocket API,浏览器和服务器只需要要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送,改变了原有的B/S模式。

    WebSocket技术应用的典型架构:
    WebSocket详解(三):深入WebSocket通信协议细节_1.png 

    WebSocket的技术原理:
    WebSocket详解(三):深入WebSocket通信协议细节_2.png 


    浏览器端的websocket 发起的请求一般是:



    // javacsript
      var ws = new WebSocket("ws://127.0.0.1:4000");
      ws.onopen = function(){
        console.log("succeed");
      };
      ws.onerror = function(){
        console.log(“error”);
      };
      ws.onmessage = function(e){
      console.log(e); 
      }








    当 new 一个 websocket 对象之后,就会向服务器发送一个 get 请求:
    WebSocket详解(三):深入WebSocket通信协议细节_3.png 

    这个请求是对摸个服务器的端口发送的,一般的话,会预先在服务器将一个socket 绑定到一个端口上,客户端和服务器端在这个预定的端口上通信(我这里绑定的就是 4000 端口,默认情况下,websocke 使用 80 端口)。

    然后,在服务器端的socket监听到这个packet 之后就生成一个新的 socket,将发送过来的数据中的 Sec-WebSocket-Key 解析出来,然后按照把“Sec-WebSocket-Ke”加上一个魔幻字符串“258EAFA5-E914-47DA-95CA-C5AB0DC85B11”。使用SHA-1加密,之后进行BASE-64编码,将结果做为“Sec-WebSocket-Accept”头的值,返回给客户端。

    客户端收到这个之后,就会将 通信协议 upgrade 到 websocket 协议:
    WebSocket详解(三):深入WebSocket通信协议细节_4.png 

    然后就会在这个持久的通道下进行通信,包括浏览器的询问,服务器的push,双方是在一个全双工的状态下相互通信。

    WebSocket 通信协议


    如上述的例子:切换后的websocket 协议中的 数据传输帧的格式(此时不再使用html协议) 官方文档给出的说明:
    WebSocket详解(三):深入WebSocket通信协议细节_QQ20160525-0.png 

    直接看这个,谁都会有点头大: 我花了一幅图来简单的解释这个 frame 的结构:
    WebSocket详解(三):深入WebSocket通信协议细节_5.png 

    各字段的解释:
    1
    2
    3
    4
    5
    6
    7
    FIN              1bit 表示信息的最后一帧,flag,也就是标记符
    RSV 1-3        1bit each 以后备用的 默认都为 0
    Opcode         4bit 帧类型,
    Mask              1bit 掩码,是否加密数据,默认必须置为1
    Payload len   7bit 数据的长度,当这个7 bit的数据 == 126 时,后面的2 个字节也是表示数     据长度,当它 == 127 时,后面的 8 个字节表示数据长度
    Masking-key      1 or 4 bit 掩码
    Payload data  playload len  bytes 数据

    所以我们这里的代码,通过判断 Playload len的值,来用 substr 截取 Masking-key 和 PlayloadData。

    根据掩码解析数据的方法是:
    1
    2
    3
    for ( i = 0 ; i < data.length ; i++){
        orginalData += data[i]  ^  maskingKey[i mod 4 ];
    }

    在PHP中,当我们收到数据之后,按照这里的格式截取数据,并将其按照这里的方法解析后就得到了浏览器发送过来的数据。 当我们想把数据发送给浏览器时,也要按照这个格式组装frame。 这里是我的方法:
    function frame($s){
                      $a = str_split($s, 125);
                      if (count($a) == 1){
                              return "\x81" . chr(strlen($a[0])) . $a[0];
                      }
                      $ns = "";
                      foreach ($a as $o){
                              $ns .= "\x81" . chr(strlen($o)) . $o;
                      }
                      return $ns;
              }





    强行将要发送的数据分割成 125 Byte / frame,这样 playload len 只需要 7 bits。也就是直接将数据的长度的ascall码拼接上去,然后后面跟上要发送的数据。 每一个 frame 前面加的 ‘\x81’ 用二进制就是: 1000 0001 1000 :
    1
    2
    1 是 FIN
    000 是三个备用的bit

    0001 指的是 opcode 官方的解释:
    WebSocket详解(三):深入WebSocket通信协议细节_QQ20160525-1.png 
    可以设置 opcode的值,来告诉浏览器这个frame的数据属性。
    展开全文
  • WebSocket协议实时通信技术原理

    千次阅读 2017-11-16 11:24:04
    咳咳咳~毕业设计弄了一个基于PC端和移动端的客服聊天系统,使用的核心技术是H5的WebSocket。还没找到实习,有时间整理整理下哈。HTML5 WebSocket协议实时通讯机制Ajax长轮询过程中,客户端通过频繁地向服务器发送...

    咳咳咳~毕业设计弄了一个基于PC端和移动端的客服聊天系统,使用的核心技术是H5的WebSocket。还没找到实习,有时间整理整理下哈。


    HTML5 WebSocket协议实时通讯机制

    Ajax长轮询过程中,客户端通过频繁地向服务器发送HTTP请求的方式与服务器保持这一种虚拟的连接,此连接的方式属于循环连接而不属于长连接。

    相对于HTTP协议这一非持久连接的特点来说,为避免HTTP轮询的滥用,2011年,由IETF(互联网工程任务组)制定并规范了WebSocket通信协议。

    WebSocket通信协议是HTML5支持浏览器与服务器进行多路复用全双工(Full-Duplex)通信的技术,是一个持久化协议,允许服务器主动发送信息给客户端。客户端通过JavaScript实现相应的API与服务器建立WebSocket连接后,客户端发送的Request请求信息当中不再带有请求头Head的部分信息,与Ajax长轮询通信对比,WebSocket通讯,不仅能降低服务器的压力而且保证了数据的实时传输。

    WebSocket协议实时通信技术原理

    最喜欢拆东西,解剖技术原理了。做事多问个为什么,凭什么要这样实现,这样做的作用是什么。

    WebSocket协议是基于TCP协议并遵从HTTP协议的握手规范的一种通讯协议,其通过发送连接请求,握手,验证握手信息这三个步骤与服务器建立WebSocket连接。

    这里写图片描述


    • 发送连接请求

    客户端通过一个格式为:ws://host:port/的请求地址发起WebSocket连接请求,并由JavaScript实现WebSocket API与服务器建立WebSocket连接,其中host为服务器主机IP地址或域名,port为端口。为了让本客服系统能够在不同浏览器建立WebSocket连接,在发送连接请求前,需要开启SockJS的支持,创建一个全双工的信道。

    WebSocket请求头信息:

    这里写图片描述

    相关字段说明:

    字段名说明
    Connection:Upgrade标识该HTTP请求是一个协议升级请求
    Upgrade: WebSocket协议升级为WebSocket协议
    Sec-WebSocket-Version: 13客户端支持WebSocket的版本
    Sec-WebSocket-Key:jONIMu4nFOf0iwNnc2cihg==客户端采用base64编码的24位随机字符序列。
    Sec-WebSocket-Extensions协议扩展类型

    HTTP协议和WebSocket协议关系图:

    这里写图片描述

    可以看出WebSocket请求是HTTP协议进行升级的,即使请求格式为ws://,其本质也是一个HTTP请求,借用了HTTP的部分设施兼容了客户端的握手规则。


    • 握手

    当服务器收到请求后,会解析请求头信息,根据升级后的协议判断该请求为WebSocket请求,并取出请求信息中的Sec-WebSocket-Key字段的数据按照某种算法重新生成一个新的字符串序列放入响应头Sec-WebSocket-Accept中。

    WebSocket服务器响应头信息:

    这里写图片描述

    相关字段说明:
    Sec-WebSocket-Accept:服务器接受客户端HTTP协议升级的证明。


    • WebSocket建立连接

    客户端接收服务器的响应后,同样会解析请求头信息,取出请求信息中的Sec-WebSocket-Accept字段,并用服务器内部处理Sec-WebSocket-Key字段的算法处理之前发送的Sec-WebSocket-Key,把处理得到的结果与Sec-WebSocket-Accept进行对比,数据相同则表示客户端与服务器成功建立WebSocket连接,反之失败。


    WebSocket通信协议的数据传输

    WebSocket通讯协议的数据传输格式是以帧的形式传输的,其帧格式如图:

    这里写图片描述

    相关字段说明:

    这里写图片描述

    根据数据帧的设计可以看出,WebSocket通讯协议是通过心跳检查PING-PONG帧来实现WebSocket长连接。当WebSocket连接建立后,PING帧和PONG帧都会不携带数据地进行来回传输,当连接发生变化时,相应数据信息会被植入PING帧,PONG帧作为响应帧返回结果。

    建立连接后,可在客户端使用JavaScript实现相关的WebSocket API。相关实现接口如下表:

    实现方式说明
    New WebSocket(“ws://host:port/”);发起与服务器建立WebSocket连接的对象
    websocket.onopen()=function(){}接收连接成功建立的响应函数
    websocket.onerror()=function(){}接收异常信息的响应函数
    websocket.onmessage()=functionm(event){}接收服务器返回的消息函数
    websocket.onclose()=function(){}接收连接关闭的响应函数
    sendMessage(event.data)=function(data){}发送消息函数
    websocket.close()=function(){}连接关闭函数

    ..

    从目前各Web技术领域来看,各大浏览器均支持WebSocket协议的实现,但WebSocket协议所支持服务器较少,如:NodeJS、Tomcat7.0等,相信未来会得到普及。


    Spring-WebSocket源码剖析

    上面已经通过解析数据包阐述了WebSocket的基本原理。由于Spring 4.0更新后直接增加了对WebSocket的支持,下文将借此通过Spring 框架提供的源代码进行分析Spring 框架是如何实现在接收到客户端的连接请求后与服务器建立连接的。

    以下代码片段摘自官方下载的源代码:spring-websocket-4.0.6.RELEASE-sources
    下载地址:https://spring.io/blog/2014/07/08/spring-framework-4-0-6-released

    (1)封装来自客户端发送的WebSocket连接请求信息:

    public class WebSocketHttpHeaders extends HttpHeaders {
    
        public static final String SEC_WEBSOCKET_ACCEPT = "Sec-WebSocket-Accept";
    
        public static final String SEC_WEBSOCKET_EXTENSIONS = "Sec-WebSocket-Extensions";
    
        public static final String SEC_WEBSOCKET_KEY = "Sec-WebSocket-Key";
    
        public static final String SEC_WEBSOCKET_PROTOCOL = "Sec-WebSocket-Protocol";
    
        public static final String SEC_WEBSOCKET_VERSION = "Sec-WebSocket-Version";
    
        private static final long serialVersionUID = -6644521016187828916L;
    
        private final HttpHeaders headers;
    
        public WebSocketHttpHeaders() {
            this(new HttpHeaders(), false);
        }
    
        public WebSocketHttpHeaders(HttpHeaders headers) {
            this(headers, false);
        }
    
        private WebSocketHttpHeaders(HttpHeaders headers, boolean readOnly) {
            this.headers = readOnly ? HttpHeaders.readOnlyHttpHeaders(headers) : headers;
        }
    
        public static WebSocketHttpHeaders readOnlyWebSocketHttpHeaders(WebSocketHttpHeaders headers){
            return new WebSocketHttpHeaders(headers, true);
        }
    
        ***
        **
        *
        *
    }
    

    (2)判断请求的协议类型,获取请求信息进入握手环节: 注意相关注释!!

    public abstract class AbstractWebSocketClient implements WebSocketClient {
    
        protected final Log logger = LogFactory.getLog(getClass());
    
        private static final Set<String> specialHeaders = new HashSet<String>();
    
        static {
            specialHeaders.add("cache-control");
            specialHeaders.add("connection");
            specialHeaders.add("host");
            specialHeaders.add("sec-websocket-extensions");
            specialHeaders.add("sec-websocket-key");
            specialHeaders.add("sec-websocket-protocol");
            specialHeaders.add("sec-websocket-version");
            specialHeaders.add("pragma");
            specialHeaders.add("upgrade");
        }
    
        @Override
        public ListenableFuture<WebSocketSession> doHandshake(WebSocketHandler webSocketHandler,String uriTemplate, Object... uriVars) {..
    
        @Override
        public final ListenableFuture<WebSocketSession> doHandshake(WebSocketHandler webSocketHandler,
                WebSocketHttpHeaders headers, URI uri) {
    
            Assert.notNull(webSocketHandler, "webSocketHandler must not be null");
            Assert.notNull(uri, "uri must not be null");
    
            String scheme = uri.getScheme();
    
            /*判断协议类型*/
            Assert.isTrue(((scheme != null) && ("ws".equals(scheme) || "wss".equals(scheme))), "Invalid scheme: " + scheme);
    
            if (logger.isDebugEnabled()) {
                logger.debug("Connecting to " + uri);
    
            /*封装响应信息*/
            HttpHeaders headersToUse = new HttpHeaders();
            if (headers != null) {
                for (String header : headers.keySet()) {
                    if (!specialHeaders.contains(header.toLowerCase())) {
                        headersToUse.put(header, headers.get(header));
                    }
                }
            }
    
            List<String> subProtocols = ((headers != null) && (headers.getSecWebSocketProtocol() != null)) ?
                    headers.getSecWebSocketProtocol() : Collections.<String>emptyList();
    
            List<WebSocketExtension> extensions = ((headers != null) && (headers.getSecWebSocketExtensions() != null)) ?
                    headers.getSecWebSocketExtensions() : Collections.<WebSocketExtension>emptyList();
    
            /*进入握手环节*/
            return doHandshakeInternal(webSocketHandler, headersToUse, uri, subProtocols, extensions,
                    Collections.<String, Object>emptyMap());
        }
    
        protected abstract ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandler webSocketHandler,
                HttpHeaders headers, URI uri, List<String> subProtocols, List<WebSocketExtension> extensions,
                Map<String, Object> attributes);
    
    }

    (3)握手处理: 注意相关注释!!

    public class StandardWebSocketClient extends AbstractWebSocketClient {
    
        private final WebSocketContainer webSocketContainer;
    
        private AsyncListenableTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
    
        public StandardWebSocketClient() {
            this.webSocketContainer = ContainerProvider.getWebSocketContainer();
        }
    
        public StandardWebSocketClient(WebSocketContainer webSocketContainer) {
            Assert.notNull(webSocketContainer, "WebSocketContainer must not be null");
            this.webSocketContainer = webSocketContainer;
        }
    
        public void setTaskExecutor(AsyncListenableTaskExecutor taskExecutor) {..
    
        public AsyncListenableTaskExecutor getTaskExecutor() {..
    
        /*握手处理,生成连接会话句柄Session*/
        @Override
        protected ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandler webSocketHandler,
                HttpHeaders headers, final URI uri, List<String> protocols,
                List<WebSocketExtension> extensions, Map<String, Object> attributes) {
    
            int port = getPort(uri);
            InetSocketAddress localAddress = new InetSocketAddress(getLocalHost(), port);
            InetSocketAddress remoteAddress = new InetSocketAddress(uri.getHost(), port);
    
            final StandardWebSocketSession session = new StandardWebSocketSession(headers,
                    attributes, localAddress, remoteAddress);
    
            final ClientEndpointConfig.Builder configBuilder = ClientEndpointConfig.Builder.create();
            configBuilder.configurator(new StandardWebSocketClientConfigurator(headers));
            configBuilder.preferredSubprotocols(protocols);
            configBuilder.extensions(adaptExtensions(extensions));
            final Endpoint endpoint = new StandardWebSocketHandlerAdapter(webSocketHandler, session);
    
            Callable<WebSocketSession> connectTask = new Callable<WebSocketSession>() {
                @Override
                public WebSocketSession call() throws Exception {
                    webSocketContainer.connectToServer(endpoint, configBuilder.build(), uri);
                    return session;
                }
            };
    
            if (this.taskExecutor != null) {
                return this.taskExecutor.submitListenable(connectTask);
            }
            else {
                ListenableFutureTask<WebSocketSession> task = new ListenableFutureTask<WebSocketSession>(connectTask);
                task.run();
                return task;
            }
        }
    
        private static List<Extension> adaptExtensions(List<WebSocketExtension> extensions){..
    
        private InetAddress getLocalHost() {..
        private int getPort(URI uri) {..
        private class StandardWebSocketClientConfigurator extends Configurator {
            private final HttpHeaders headers;
            public StandardWebSocketClientConfigurator(HttpHeaders headers) {..
            @Override
            public void beforeRequest(Map<String, List<String>> requestHeaders) {..
            @Override
            public void afterResponse(HandshakeResponse response) {..
    
    }

    (4)建立WebSocket连接,开始通讯: 注意相关注释!!

    public abstract class ConnectionManagerSupport implements SmartLifecycle {
    
        protected final Log logger = LogFactory.getLog(getClass());
    
        private final URI uri;
    
        private boolean autoStartup = false;
    
        private boolean isRunning = false;
    
        private int phase = Integer.MAX_VALUE;
    
        private final Object lifecycleMonitor = new Object();
    
        public ConnectionManagerSupport(String uriTemplate, Object... uriVariables) {
            this.uri = UriComponentsBuilder.fromUriString(uriTemplate).buildAndExpand(
                    uriVariables).encode().toUri();
        }
    
        public void setAutoStartup(boolean autoStartup) {..
        @Override
        public boolean isAutoStartup() {..
        public void setPhase(int phase) {..
        @Override
        public int getPhase() {..
        protected URI getUri() {..
        @Override
        public boolean isRunning() {..
    
        @Override
        public final void start() {
            synchronized (this.lifecycleMonitor) {
                if (!isRunning()) {
                    startInternal();
                }
            }
        }
    
        /*打开连接,synchronized处理并发连接*/
        protected void startInternal() {
            synchronized (lifecycleMonitor) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Starting " + this.getClass().getSimpleName());
                }
                this.isRunning = true;
                openConnection();
            }
        }
    
        protected abstract void openConnection();
    
        @Override
        public final void stop() {..
    
        /*关闭连接*/
        protected void stopInternal() throws Exception {
            if (isConnected()) {
                closeConnection();
            }
        }
    
        protected abstract boolean isConnected();
    
        protected abstract void closeConnection() throws Exception;
    
        @Override
        public final void stop(Runnable callback) {
            synchronized (this.lifecycleMonitor) {
                this.stop();
                callback.run();
            }
        }
    
    }

    Spring-WebSocket领域模型:

    这里写图片描述


    今天不卖奶茶了~

    展开全文
  • 网络协议、socket、webSocket

    万次阅读 多人点赞 2019-07-31 19:20:28
    OSI是一个开放性的通信系统互连参考模型,他是一个定义得非常好的协议规范。OSI模型有7层结构,从上到下分别是 7应用层6表示层5 会话层 4传输层3 网络层 2数据链路层1物理层。 下面的图表显示不同的协议在最初OSI...
  • 详解 websocket 协议

    千次阅读 2020-08-09 15:50:45
    websocket 是一个十分高性能的 socket 协议,体量小使其拥有更快的传输效率,全双工的方式为我们解决了更多基于双端通信的业务场景,它是 web 开发者所必须要掌握的一门协议。本文帮你你探索 websocket 的本质,让你...
  • WebSocket协议与java实现

    2019-12-19 15:38:25
    一、webSocket协议研究: 研究源码发现有些域和方法的算法看不懂,不知道是什么含义。于是回来看看协议。网址:webSocket协议协议的帧结构: FIN:判断这一帧数据是不是这一消息的最后一帧。 RSV1、RSV2、...
  • WebSocket API是下一代客户端-服务器的异步通信方法。该通信取代了单个的TCP套接字,使用ws或wss协议,可用于任意的客户端和服务器程序。WebSocket目前由W3C进行标准化。WebSocket已经受到Firefox 4、Chrome 4、...
  • WebSocket ——一种在 2011 年被互联网工程任务组(IETF)标准化的协议WebSocket 解决了一个长期存在的问题:既然底层的协议(HTTP)是一个请求/响应模 式的交互序列,那么如何实时地发布信息呢?AJAX 提供了...
  • websocket协议规范

    2021-02-05 11:56:25
    websocket协议规范 ...标签:网络通信协议websocketwebsocket协议客户端vbwebsocket教程 《websocket协议详解》教程分三篇: 什么是websocket websocket协议规范 用vb编写websocket客户端示例(每秒...
  • Websocket通信

    2021-07-12 21:13:02
    Websocket通信websocket的概念websocket的特点websocket的应用场景websocket和http的区别websocket和socket的区别WebSocket中的常用注解websocket配置websocket客户端代码websocket服务端代码 websocket的概念 ...
  • WebSocket协议介绍

    2021-09-01 21:24:37
    文章目录前言一、WebSocket是什么?... 前言 WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455,并由RFC7936补充规范。WebSocket API也被W3C定
  • websocket协议 解析

    2021-07-14 15:52:28
    WebSocket 介绍 WebSocket 发起单个请求,服务端不需要等待客服端,客户端在任何时候也能发消息到服务端,减少了轮询时候的延迟.经历一次连接后,服务器能给客户端发多次。下图是轮询与WebSocket的区别。 基于http...
  • WebSocket协议入门:WebSocket API

    万次阅读 2020-04-15 17:24:00
    点击connect按钮,服务器代码显示 点击send按钮,浏览器发送数据,服务器回送... var wsServer = 'ws://192.168.189.155:9096/';ws代表websocket的意思。 https://www.cnblogs.com/fuqiang88/p/5956363.html ...
  • Netty之WebSocket协议开发

    千次阅读 2016-10-25 20:18:39
    为了解决这些问题,我们引入了webSocket。HTTP协议的弊端我们来总结一下HTTP协议的弊端:1.HTTP协议是半双工的协议。大家知道对讲机吗?它就是半双工的设备。当对方在说话时,你就不能说话了,也就是说一个时间点上...
  • 本文阅读时间大约8分钟。1. WebSocket简介WebSocekt协议诞生于2008年,在2011年成为国际标准,目前所有的浏览器都已经支持WebSocket协议了。WebSocke...
  • websocket 协议

    2020-01-09 10:15:52
    WebSocket通信协议于2011年被IETF定为标准RFC 6455,并由RFC7936补充规范。WebSocket API也被W3C定为标准。 WebSocket协议是基于TCP的一种新的网络协议,和http协议一样属于应用层协议 WebSocket使得客户端和...
  • WebSocket 协议

    千次阅读 2016-09-27 15:11:54
    WebSocket 协议 WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。在这之前都是客户端主动请求服务端,一请求一应答,很多时候实现消息更新都是采用ajax轮询,有延迟,...
  • 其实是这样的,WebSocket协议是借用HTTP协议的101 switch protocol来达到协议转换的,从HTTP协议切换成WebSocket通信协议。 再简单点来说,它就好像将Ajax和Comet技术的特点结合到了一起,只不过性能要高并且使用...
  • WebSocket协议 WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给...WebSocket通信协议于2011年被IETF定为标准RFC 6455,并被RFC7936...
  • 1: webSocket 一般情况Web 应用的交互... WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。 浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求,连接建立以后,客户端和服...
  • WebSocket主要被用来解决客户端发起多个http请求到服务器资源浏览器必须要经过长时间的轮询问题,即就是不使用轮询的方式,而是服务器端主动推数据的方式,但是该种方式需要依赖我们今天要讲的websocket协议来完成。...
  • WebSocket的出现不是空穴来风,起初在HTTP/1.1基础上通过轮询和长连接达到信息实时同步的功能,但是这并没有跳出HTTP/1.1自身的缺陷。...为此,WebSocket诞生了,跳出HTTP/1.1,建立一个新的真正全双工通信协议
  • ws(websocket协议

    万次阅读 2017-09-10 20:56:06
    WebSocket协议 websocket 简介  (2013-04-09 15:39:28) ...WebSocket是html5新增加的一种通信协议,目前流行的浏览器都支持这个协议,例如Chrome,Safrie,Firefox,Opera,IE等等,对该协议支持最早的应该
  • 序 近期工作忙碌,为了赶SegmentFault for Android 4.0版,到了发疯的程度。我来汇报一个进度,已经实现基于websocket的私信...那么在这之余,因为个人对各个通信协议都有颇有兴趣,便顺便去看了下ietf写的关于we...
  • WebSocket协议入门:WebSocket 协议

    千次阅读 2020-04-15 17:23:16
    WebSocket协议 WebSocket为Web应用程序保留了HTTP的特性(URL、HTTP安全性、更简单的基于数据模型的消息和内置的文本支持),同时提供了其他网络架构和通信模式。和TCP一样,WebSocket是异步的,可以用作高级协议的...
  • http协议轮询: 三、Long poll 和Ajax轮询以及WebSocket的原理 1、Ajax轮询的原理。 场景如下: 客户端:啦啦啦,有没有新信息(Request) 服务端:没有(Response) 客户端:啦啦啦,有没有新信息(Request) ...
  • WebSocket协议解析

    2019-11-04 17:19:34
    WebSocket协议解析 转载请注明出处:WebSocket解析 现在,很多网站为了实现推送技术,所用的技术都是轮询。轮询是指在特定的时间间隔(如每一秒),由浏览器对服务器发起HTTP请求,然后由服...
  • WebSocket是web浏览器与web服务器之间全双工通信的标准。该协议包括一个打开阶段握手、接着是基本消息帧、TCP之上的分层。 而我们所认知的WebSocket协议则是由IEIF...WebSocket通信协议在2011年12月11日,被RFC6455定义

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,576
精华内容 5,830
关键字:

websocket通信协议设计