Formyown的博客 2020-07-29T08:23:34.920Z http://formyown.github.io/ Formyown Hexo Netty获取并检查Websocket握手请求 http://formyown.github.io/2020/07/29/Netty获取并检查Websocket握手请求/ 2020-07-29T12:00:00.000Z 2020-07-29T08:23:34.920Z 在使用Netty开发Websocket服务时，通常需要解析来自客户端请求的URL、Headers等等相关内容，并做相关检查或处理。本文将讨论两种实现方法。

方法一：基于HandshakeComplete自定义事件

特点：使用简单、校验在握手成功之后、失败信息可以通过Websocket发送回客户端。

1.1 从netty源码出发

一般地，我们将netty内置的WebSocketServerProtocolHandler作为Websocket协议的主要处理器。通过研究其代码我们了解到在本处理器被添加到Pipline后handlerAdded方法将会被调用。此方法经过简单的检查后将WebSocketHandshakeHandler添加到了本处理器之前，用于处理握手相关业务。

我们都知道Websocket协议在握手时是通过HTTP(S)协议进行的，那么这个WebSocketHandshakeHandler应该就是处理HTTP相关的数据的吧？

下方代码经过精简，放心阅读😄

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package io.netty.handler.codec.http.websocketx;

public class WebSocketServerProtocolHandler extends WebSocketProtocolHandler {

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        ChannelPipeline cp = ctx.pipeline();
        if (cp.get(WebSocketServerProtocolHandshakeHandler.class) == null) {
            // Add the WebSocketHandshakeHandler before this one.
            cp.addBefore(ctx.name(), WebSocketServerProtocolHandshakeHandler.class.getName(),
                    new WebSocketServerProtocolHandshakeHandler(serverConfig));
        }
        //...
    }
}

我们来看看WebSocketServerProtocolHandshakeHandler都做了什么操作。

channelRead方法会尝试接收一个FullHttpRequest对象，表示来自客户端的HTTP请求，随后服务器将会进行握手相关操作，此处省略了握手大部分代码，感兴趣的同学可以自行阅读。

可以注意到，在确认握手成功后，channelRead将会调用两次fireUserEventTriggered，此方法将会触发其他（在此处理器之后）的处理器中名为的serEventTriggered方法。其中一个方法传入了WebSocketServerProtocolHandler对象，此对象保存了HTTP请求相关信息。那么解决方案逐渐浮出水面，通过监听自定义事件即可实现检查握手的HTTP请求。

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
package io.netty.handler.codec.http.websocketx;

/**
 * Handles the HTTP handshake (the HTTP Upgrade request) for {@link WebSocketServerProtocolHandler}.
 */
class WebSocketServerProtocolHandshakeHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
        final FullHttpRequest req = (FullHttpRequest) msg;
        if (isNotWebSocketPath(req)) {
            ctx.fireChannelRead(msg);
            return;
        }

        try {

            //...
                
            if (!future.isSuccess()) {
                
            } else {
                localHandshakePromise.trySuccess();
                // Kept for compatibility
                ctx.fireUserEventTriggered(
                        WebSocketServerProtocolHandler.ServerHandshakeStateEvent.HANDSHAKE_COMPLETE);
                ctx.fireUserEventTriggered(
                        new WebSocketServerProtocolHandler.HandshakeComplete(
                                req.uri(), req.headers(), handshaker.selectedSubprotocol()));
            }
        } finally {
            req.release();
        }
    }
}

1.2 解决方案

下面的代码展示了如何监听自定义事件。通过抛出异常可以终止链接，同时可以利用ctx向客户端以Websocket协议返回错误信息。因为此时握手已经完成，所以虽然这种方案简单的过分，但是效率并不高，耗费服务端资源。

1
2
3
4
5
6
7
8
9
10
private final class ServerHandler extends SimpleChannelInboundHandler<DeviceDataPacket> {
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        
        if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
            // 在此处获取URL、Headers等信息并做校验，通过throw异常来中断链接。
        }
        super.userEventTriggered(ctx, evt);
    }
}

1.3 ChannelInitializer实现

附上Channel初始化代码作为参考。

1
2
3
4
5
6
7
8
9
10
11
12
13
private final class ServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline()
                .addLast("http-codec", new HttpServerCodec())
                .addLast("chunked-write", new ChunkedWriteHandler())
                .addLast("http-aggregator", new HttpObjectAggregator(8192))
                .addLast("log-handler", new LoggingHandler(LogLevel.WARN))
                .addLast("ws-server-handler", new WebSocketServerProtocolHandler(endpointUri.getPath()))
                .addLast("server-handler", new ServerHandler());
    }
}

方法二：基于新增安全检查处理器

特点：使用相对复杂、校验在握手成功之前、失败信息可以通过HTTP返回客户端。

2.1 解决方案

编写一个入站处理器，接收FullHttpMessage消息，在Websocket处理器之前检测拦截请求信息。下面的例子主要做了四件事情：

  1. 从HTTP请求中提取关心的数据
  2. 安全检查
  3. 将结果和其他数据绑定在Channel
  4. 触发安全检查完毕自定义事件
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
public class SecurityServerHandler extends ChannelInboundHandlerAdapter {
    private static final ObjectMapper json = new ObjectMapper();

    public static final AttributeKey<SecurityCheckComplete> SECURITY_CHECK_COMPLETE_ATTRIBUTE_KEY =
            AttributeKey.valueOf("SECURITY_CHECK_COMPLETE_ATTRIBUTE_KEY");

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if(msg instanceof FullHttpMessage){
            //extracts device information headers
            HttpHeaders headers = ((FullHttpMessage) msg).headers();
            String uuid = Objects.requireNonNull(headers.get("device-connection-uuid"));
            String devDescJson = Objects.requireNonNull(headers.get("device-description"));
            //deserialize device description
            DeviceDescription devDesc = json.readValue(devDescJson, DeviceDescriptionWithCertificate.class);
            //check ......

            //
            SecurityCheckComplete complete = new SecurityCheckComplete(uuid, devDesc);
            ctx.channel().attr(SECURITY_CHECK_COMPLETE_ATTRIBUTE_KEY).set(complete);
            ctx.fireUserEventTriggered(complete);
        }
        //other protocols
        super.channelRead(ctx, msg);
    }
    @Getter
    @AllArgsConstructor
    public static final class SecurityCheckComplete {
        private String connectionUUID;
        private DeviceDescription deviceDescription;
    }
}

在业务逻辑处理器中，可以通过组合自定义的安全检查事件和Websocket握手完成事件。例如，在安全检查后进行下一步自定义业务检查，在握手完成后发送自定义内容等等，就看各位同学自由发挥了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 private final class ServerHandler extends SimpleChannelInboundHandler<DeviceDataPacket> {

    public final AttributeKey<DeviceConnection> 
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof SecurityCheckComplete){
            log.info("Security check has passed");
            SecurityCheckComplete complete = (SecurityCheckComplete) evt;
            listener.beforeConnect(complete.getConnectionUUID(), complete.getDeviceDescription());
        }
        else if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
            log.info("Handshake has completed");
            SecurityCheckComplete complete = ctx.channel().attr(SecurityServerHandler.SECURITY_CHECK_COMPLETE_ATTRIBUTE_KEY).get();
            DeviceDataServer.this.listener.postConnect(complete.getConnectionUUID(),
                    new DeviceConnection(ctx.channel(), complete.getDeviceDescription()));
        }
        super.userEventTriggered(ctx, evt);
    }
}

2.2 ChannelInitializer实现

附上Channel初始化代码作为参考。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private final class ServerInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline()
                .addLast("http-codec", new HttpServerCodec())
                .addLast("chunked-write", new ChunkedWriteHandler())
                .addLast("http-aggregator", new HttpObjectAggregator(8192))
                .addLast("log-handler", new LoggingHandler(LogLevel.WARN))
                .addLast("security-handler", new SecurityServerHandler())
                .addLast("ws-server-handler", new WebSocketServerProtocolHandler(endpointUri.getPath()))
                .addLast("packet-codec", new DataPacketCodec())
                .addLast("server-handler", new ServerHandler());
    }
}

总结

上述两种方式分别在握手完成后和握手之前拦截检查；实现复杂度和性能略有不同，可以通过具体业务需求选择合适的方法。

Netty增强了责任链模式，使用userEvent传递自定义事件使得各个处理器之间减少耦合，更专注于业务。但是、相比于流动于各个处理器之间的"主线"数据来说，userEvent传递的"支线"数据往往不受关注。通过阅读Netty内置的各种处理器源码，探索其产生的事件，同时在开发过程中加以善用，可以减少冗余代码。另外在开发自定义的业务逻辑时，应该积极利用userEvent传递事件数据，降低各模块之间代码耦合。

]]> <p>在使用Netty开发Websocket服务时，通常需要解析来自客户端请求的URL、Headers等等相关内容，并做相关检查或处理。本文将讨论两种实现方法。</p> <h1 id="方法一基于handshakecomplete自定义事件"><a class="markdown Decimaljs在class-transformer中异常的解决方案 http://formyown.github.io/2019/12/17/Decimaljs在class-transformer中异常的解决方案/ 2019-12-17T03:07:09.000Z 2020-07-29T08:23:34.916Z 背景

在使用class-transformer进行对象转换并且遇到类型为Decimal的数据时工作不正常

异常复现

我们有以下类型，是目标对象：

1
2
3
4
5
6
7
export class OrderItemTransfer {
    ///忽略其他无关内容

    @Expose()
    price: Decimal;

}

以及，源对象定义：

1
2
3
4
5
6
7
8
9
10
11
12
@Entity()
export class OrderItem {
    ///忽略其他无关内容

    @Column({
        type: "decimal",
        precision: 5, scale: 2, default: 0,
        transformer: new DecimalTransformer()
    })
    price: Decimal;

}

我们的目标是将 OrderItem 类型的对象转换到 OrderItemTransfer 类型。于是有以下代码：

1
2
3
let transfer = plainToClass(OrderItemTransfer, entity);
//发生异常: Error
//Error: [DecimalError] Invalid argument: undefined

异常分析

通过追踪调用栈发现如下信息:

stack

找到调用Decimal构造函数的具体代码

caller

可以看到，这里直接调用了Decimal构造函数，然而Decimal的构造函数并不支持参数是null/undefined从而引发了异常。

plainToClass这个方法的设计是针对plain object到class的转换，通过下图可见，他的类型判断相对简单

type-check

在判断对象类型是object之后并没有进一步判断构造函数相关信息（针对plain object的设计并不需要判断，因为这种情况并不存在自定义的构造函数）。但是这种特性恰巧妨碍了我们使用类似于Decimal这种没有默认构造函数的类型。

解决方案

其实2017年已经有人提过这个问题，但是这种情况确实是此方法的设计情况之外，而且官方也并没有给出解决方案。仅有某位用户提供的一个临时性的解决方案:

1
2
3
else if (value[valueKey] instanceof Function) {
    subValue = value[valueKey](); --> Comment out this line
}

这个解决方案真的能解决问题么？答案是：可以，但不优雅。

与其提交pr给class-transformer不如从另外一个角度来解决，那就是从Decimal.js下手。由于问题发生在Decimal类型没有默认的构造函数，那么我们为何不拓展以下这个类型呢？

1
2
3
4
5
6
7
8
class DecimalPatch {
    constructor(v) {
        if (!v) v = 0;
        let d = new Decimal(v) as any;
        delete d.constructor;
        Object.assign(this, d);
    }
}

看到这里，你可能要问几个问题：

为什么不用extends呢？答案是class-transformer拿到的类型仍是Decimal的构造函数

为什么要delete d.constructor呢？答案是防止plainToClass再次调用constructor

(这个方法很迷，它会调用源对象的所有方法求值赋值给目标对象，看似是为了调用getter作用的函数，但是并没有判断能力，就连构造函数也不放过QAQ。。。)

现在，你可以这样使用它

1
2
3
4
5
6
7
8
9
10
11
12
13
@Entity()
export class OrderItem {
    ///忽略其他无关内容

    @Column({
        type: "decimal",
        precision: 5, scale: 2, default: 0,
        transformer: new DecimalTransformer() //还记得这里么，
        //解释一下，DecimalTransformer是用于将数据库查询出的数据转换为自定义数据
    })
    price: Decimal;

}

它长这个样子

1
2
3
4
5
6
7
8
export class DecimalTransformer implements ValueTransformer {
    to(data: Decimal): string {
        return data.toString();
    }
    from(data: string): Decimal {
        return new Decimal(data); //这里实例化了对象
    }
}

那么我们可以修改上述代码：

1
2
3
from(data: string): DecimalPatch {
    return new DecimalPatch(data);
}

这样，entity中的数据实际类型是DecimalPatch，并且工作一切正常

]]> <h2 id="背景"><a class="markdownIt-Anchor" href="#背景"></a> 背景</h2> <p>在使用<a href="https://github.com/typestack/class-transformer" target="_bla Ethereum以太坊签名验证算法Java实现 http://formyown.github.io/2019/02/16/Ethereum以太坊签名验证算法Java实现/ 2019-02-16T15:41:00.000Z 2020-07-29T08:23:34.920Z 开始之前

在验证之前，我们需要这些基本的信息: 签名，原文，地址（或者公钥）

Sig: 0x5f3c4ab309427d25cdc34a41cb432610c6c817e76ce9aec0c9336365063687ff29c92963edd6935f365d5f28c146f227881b626c7db18e87b9baf2089729741b1c

Message: 签名这段文字以验证你是这个账户的持有者。

Address: 0x1c52C6F743351fC9b97AE4Fe32194A588398FE69

处理原文

首先我们需要将原为处理为Hash形式

1
MessageHash = keccak256(prefix + message)

这个prefix是个什么东西？

我们来看看签名在生成的时候是如何计算的。在Ethereum官方文档中，关于eth_sig的描述是这样的：

原文地址: https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign

可疑的地方是sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))，我们可以看到在message之前添加了一段话："\x19Ethereum Signed Message:\n" + len(message)。真正被签名的数据不是单纯的message，而是在message之前添加了这句话（prefix）后整体做了hash运算。所以，我们在计算hash的时候，也需要照做。

1
2
3
String message = "签名这段文字以验证你是这个账户的持有者。";
byte[] msgBuffer = message.getBytes("UTF-8");
byte[] msgPrefix =  ("\u0019Ethereum Signed Message:\n" + msgBuffer.length).getBytes("UTF-8");

现在已经将原始消息和prefix都转换成了字节数组的形式，接下来需要把这两部分拼接起来

1
2
3
byte[] msg = new byte[msgPrefix.length + msgBuffer.length];
System.arraycopy(msgPrefix, 0, msg, 0, msgPrefix.length);
System.arraycopy(msgBuffer, 0, msg, msgPrefix.length, msgBuffer.length);

毫无难度，利用System.arraycopy方法可以轻松得拷贝数组，得到msg后，就可以计算keccak256(msg)了

1
2
3
4
import org.ethereum.crypto.cryptohash.Keccak256;

Keccak256 keccak256 = new Keccak256();
byte[] msgHash = keccak256.copy().digest(msg);

这里使用了ethereumj的加密包，当然你也可以使用其他的包或者自己实现keccak256。

结果：msgHash = 767cab717f7e9a3f56765c89f39887b9934a8e78ad4d0a2fb1fd0d009bb7012b (32字节，HEX)

好了，到目前为止msgHash已经拿到了，接下来就要处理签名了

处理签名

再来看一眼签名: 0x5f3c4ab309427d25cdc34a41cb432610c6c817e76ce9aec0c9336365063687ff29c92963edd6935f365d5f28c146f227881b626c7db18e87b9baf2089729741b1c
长度是65个字节。

然而这段签名是由三部分组成的。它们分别是 r, s, v。r和s长度都是32字节，v是一个字节。下面的代码将会吧签名拆分成上述部分。

1
2
3
4
5
import org.bouncycastle.util.encoders.Hex;

byte[] r = Hex.decode(sig.substring(0, 64));
byte[] s = Hex.decode(sig.substring(64, 128));
byte v = Hex.decode(sig.substring(128, 130))[0];

结果：
r = 5f3c4ab309427d25cdc34a41cb432610c6c817e76ce9aec0c9336365063687ff (32字节，HEX)
s = 29c92963edd6935f365d5f28c146f227881b626c7db18e87b9baf2089729741b (32字节，HEX)
v = 28 (10进制)

得到这三个数据以后，就可以进入下一个环节辣

什么是椭圆曲线数字签名算法

若果你不想了解或者已经了解椭圆曲线的细节，可以跳过此小节

ECDSA，EC，和Secp256k1

以太坊使用的是Elliptic Curve Digital Signature Algorithm (ECDSA，椭圆曲线数字签名算法)进行签名。可是Elliptic Curve(EC，椭圆曲线)又是个什么东西？
为了有一个直观感受，这里有一个简单但是通用的方程

y2=x3+ax+by^2 = x^3 + ax + b

其中a都是常数b，不同的取值会形成不同的曲线方程

各种EC的形状

在这里https://www.desmos.com/calculator/9vv5aklebf，你可以调整a和b的值来观察不同的取值

这些方程和加密有什么联系么？当然！不过首先要了解什么是群以及加法

群(Groups) 和阿贝尔群

群：若 非空 集合 𝔾, 定义在 𝔾 上的一个二元运算：加法，符号+表示，满足：

  1. 封闭性：存在a,b∈𝔾a,b\in𝔾, (a+b)∈𝔾(a+b)\in𝔾

  2. 结合律：存在a,b,c∈𝔾a,b,c\in𝔾, (a+b)+c=a+(b+c)(a+b)+c = a+(b+c)

  3. 交换律：存在a,b∈𝔾a,b\in𝔾, a+b=b+aa+b = b+a

  4. 单位元：集合 𝔾 中有一个确切的值即单位元00，使得 a+0=0+a=aa+0=0+a=a

  5. 逆元：集合 𝔾 中每个成员都有其相反数，即a+b=0a+b=0

则(𝔾,+)(𝔾,+)称为一个群，或者加法群也叫阿贝尔群。

椭圆曲线上的加法

假设曲线y2=x3+7y^2 = x^3 + 7上有两个点，PP和QQ

P=(x1,y1)P = (x_1, y_1)

Q=(x2,y2)Q = (x_2, y_2)

P,Q

过 PP 和 QQ 做一条直线，相交于曲线 R′R'

P,Q,R

过 R′R' 做 XX 轴垂线并相交于曲线 RR

P,Q,R,R'

那么 P+Q=RP + Q = R

如何计算 P+QP + Q

访问 https://www.desmos.com/calculator/fttnxuzryp 查看更多关于计算的细节

我们已经知道了 PP 和 QQ,又
P=(x1,y1)P = (x_1, y_1)
Q=(x2,y2)Q = (x_2, y_2)
那么过这两点直线的斜率
k=(y2−y1)/(x2−x1)k = (y_2-y_1)/(x_2-x_1)

设 R=(x3,y3)R=(x_3,y_3)
x3=k2−x1−x2x_3 = k^2 - x_1 - x_2
y3=k(x1−x3)−y1y_3 = k(x_1 - x_3) - y_1

椭圆曲线和阿贝尔群

上述对于椭圆曲线上加法的描述和解析使我们得知PPQQRR都是曲线上的点，且满足阿贝尔群的定义。不难证明椭圆曲线上的加法是一个阿贝尔群。

椭圆曲线上的乘法

现在我们已经知道了如何计算加法，那么如何计算2P2P的值呢？
其实2P2P就是P+PP + P。还记得过两点做直线么？这里只有一个点P, 相当于P和Q重合，那么这段直线的斜率就是过P点的切线的斜率，直接求导。

k=3x12/2y1k = 3x_1^2/2y_1

这样带入上述公式
R=(x3,y3)R=(x_3,y_3)
x3=k2−x1−x2x_3 = k^2 - x_1 - x_2
y3=k(x1−x3)−y1y_3 = k(x_1 - x_3) - y_1
就能得出R=2PR=2P的值了

如何计算3P3P的值呢？
现在我们已经知道了2P2P的值，那么只需要计算2P+P=3P就可以啦设2P + P = 3P就可以啦设Q = 2P过过P$ 和 QQ做直线，相交于R′R', 过R′R'做XX轴垂线相交于曲线另外一点RR
那么RR就是这里的3P3P的值啦

依此类推，我们可以计算nP(n>0)nP(n>0)的值

离散的特性

有空的同学务必要试一试

掏出纸和笔，设定随机点PP画出7P7P的位置。

你会发现1P,2P,3P....7P1P,2P,3P....7P的位置相差很大，没有规律可循。如果给定两点PP以及7P7P的值，你能求出乘数77吗？
即便是只有7，这里的计算量也是很大的，如果给定PP和nPnP(nn是一个22562^256的数字),那么逆推出nn的难度就相当大了，以人类文明现有水平，很难在短时间（几百年）计算出结果。

这就是为什么椭圆曲线数字签名算法安全性这么高了。

签名过程

用户持有公钥KK和私钥kk, 以及原文MM

验证过程

签名验证过程

，更具体的,是secp256k1椭圆曲线。

https://en.bitcoin.it/wiki/Secp256k1

此椭圆曲线的方程是

y2=x3+7y^2 = x^3 + 7

这个方程的图像看起来是这个样子：

secp256k1图像
https://www.desmos.com/calculator/ialhd71we3

茫然

从r,s,v中反推出公钥

]]> <h2 id="开始之前"><a class="markdownIt-Anchor" href="#开始之前"></a> 开始之前</h2> <p>在验证之前，我们需要这些基本的信息: 签名，原文，地址（或者公钥）</p> <p><img src="/2019/02/16/Eth