PHP Bcrypt 更安全的密码加密机制

为了避免在服务器受到攻击,数据库被拖库时,用户的明文密码不被泄露,一般会对密码进行单向不可逆加密——哈希

常见的方式是:

哈希方式 加密密码
md5(‘123456’) e10adc3949ba59abbe56e057f20f883e
md5(‘123456’ . ($salt = ‘salt’)) 207acd61a3c1bd506d7e9a4535359f8a
sha1(‘123456’) 40位密文
hash(‘sha256’, ‘123456’) 64位密文
hash(‘sha512’, ‘123456’) 128位密文

密文越长,在相同机器上,进行撞库消耗的时间越长,相对越安全。

比较常见的哈希方式是 md5 + 盐,避免用户设置简单密码,被轻松破解。

password_hash

但是,现在要推荐的是 password_hash() 函数,可以轻松对密码实现加盐加密,而且几乎不能破解。

$password = '123456';

var_dump(password_hash($password, PASSWORD_DEFAULT));
var_dump(password_hash($password, PASSWORD_DEFAULT));

password_hash 生成的哈希长度是 PASSWORD_BCRYPT —— 60位,PASSWORD_DEFAULT —— 60位 ~ 255位。PASSWORD_DEFAULT 取值跟 php 版本有关系,会等于其他值,但不影响使用。

每一次 password_hash 运行结果都不一样,因此需要使用 password_verify 函数进行验证。

$password = '123456';

$hash = password_hash($password, PASSWORD_DEFAULT);
var_dump(password_verify($password, $hash));

password_hash 会把计算 hash 的所有参数都存储在 hash 结果中,可以使用 password_get_info 获取相关信息。

$password = '123456';
$hash = password_hash($password, PASSWORD_DEFAULT);
var_dump(password_get_info($hash));
输出
array(3) {
  ["algo"]=>
  int(1)
  ["algoName"]=>
  string(6) "bcrypt"
  ["options"]=>
  array(1) {
    ["cost"]=>
    int(10)
  }
}
注意不包含 salt

可以看出我当前版本的 PHP 使用 PASSWORD_DEFAULT 实际是使用 PASSWORD_BCRYPT。

password_hash($password, $algo, $options) 的第三个参数 $options 支持设置至少 22 位的 salt。但仍然强烈推荐使用 PHP 默认生成的 salt,不要主动设置 salt。

当要更新加密算法和加密选项时,可以通过 password_needs_rehash 判断是否需要重新加密,下面的代码是一段官方示例

$options = array('cost' => 11);
// Verify stored hash against plain-text password
if (password_verify($password, $hash))
{
    // Check if a newer hashing algorithm is available
    // or the cost has changed
    if (password_needs_rehash($hash, PASSWORD_DEFAULT, $options))
    {
        // If so, create a new hash, and replace the old one
        $newHash = password_hash($password, PASSWORD_DEFAULT, $options);
    }
    // Log user in
}

password_needs_rehash 可以理解为比较 $algo + $option 和 password_get_info($hash) 返回值。

password_hash 运算慢

password_hash 是出了名的运行慢,也就意味着在相同时间内,密码重试次数少,泄露风险降低。

$password = '123456';
var_dump(microtime(true));
var_dump(password_hash($password, PASSWORD_DEFAULT));
var_dump(microtime(true));

echo "\n";

var_dump(microtime(true));
var_dump(md5($password));
for ($i = 0; $i < 999; $i++)
{
    md5($password);
}
var_dump(microtime(true));
输出
float(1495594920.7034)
string(60) "$2y$10$9ZLvgzqmiZPEkYiIUchT6eUJqebekOAjFQO8/jW/Q6DMrmWNn0PDm"
float(1495594920.7818)

float(1495594920.7818)
string(32) "e10adc3949ba59abbe56e057f20f883e"
float(1495594920.7823)

password_hash 运行一次耗时 784 毫秒, md5 运行 1000 次耗时 5 毫秒。这是一个非常粗略的比较,跟运行机器有关,但也可以看出 password_hash 运行确实非常慢。

使用 JavaScript 对中文进行排序

在网页上展示列表时经常需要对列表进行排序:按照修改/访问时间排序、按照地区、按照名称排序。

对于中文列表按照名称排序就是按照拼音排序,不能简单通过字符串比较—— ‘a’ > ‘b’——这种方式来实现。

比如比较 ‘北京’ vs ‘上海’,实际是比较 ‘běijīng’ vs ‘shànghǎi’;比较 ‘北京’ vs ‘背景’,实际是比较 ‘běijīng’ vs ‘bèijǐng’。
一般需要获取到字符串的拼音,再比较各自的拼音。

JavaScript 提供本地化文字排序,比如对中文按照拼音排序,不需要程序显示比较字符串拼音。

String.prototype.localeCompare 在不考虑多音字的前提下,基本可以完美实现按照拼音排序。

在没有出现意外的情况下,各个支持 localeCompare 的浏览器都很正常。最近将 Chrome 更新到 58.0.3029.110,突然发现中文排序不正常。

// 正常应该返回 1, 拼音 jia 在前, kai 在后
'开'.localeCompare('驾');
// 得到
-1;

// Chrome 58.0.3029.110 下返回 -1, 其他浏览器正常

// 确认之后是 localeCompare 需要明确指定 locales 参数
'开'.localeCompare('驾', 'zh');
// 得到
1

在 Chrome 下传递 locales 参数才能获得正常预期结果

Edge 浏览器支持 localeCompare

Firefox 浏览器支持 localeCompare

IE 11 浏览器支持 localeCompare

其他浏览器对 localeCompare 支持也很友好,目前也不需要明确传递 locales,浏览器支持参考 developer.mozilla.org

使用CSS变量提高代码复用率

CSS 支持通过 ––variable-name: variable-value 声明变量,并通过 var(––variable-name) 使用变量。

CSS 使用变量示例

.parent {
    --color-red: red;
}

.child {
    color: var(--color-red);
}

Less 和 Sass 已分别使用 $ 和 @ 声明变量,CSS 则采用双划线声明变量。

Less / Sass 变量示例

/* Less 变量示例 */

@blue: #f938ab;

.blue {
    color: @blue;
}

/* Sass 变量示例 */

$blue: #1875e7;

.blue {
    color: $blue;
}

不同于 Less/Sass 在最外层声明, CSS Variable 需要在具体 selector 下声明变量,因此可以在子元素下覆盖父元素定义的变量

一般将 CSS Variable 定义在伪类 :root 下,让所有子元素都可以继承。

定义在伪类 :root 下

:root {
  --base-color: #333;
  --base-size: 14px;
}

.btn {
    color: var(--base-color);
    font-size: var(--base-size);
}

变量继承与重写

div {
    padding: 2px;
}

.one {
    --border: 1px solid red;
    border: var(--border);
}

.two {
    border: var(--border);
    --border: 2px solid green;
}

.three {
    border: var(--border);
}
<div class="one">
    1
    <div class="two">
        2-1
        <div class="three">3</div>
    </div>
    <div class="two">2-2</div>
</div>

解析到 .two selector 会优先解析 .two 拥有的变量,再应用。因此 .two 应用的 --border2px solid green
.three 也会应用 .two 定义的变量。

动态修改 CSS Variable

网页渲染完成之后,再修改变量值,会重新应用 CSS。

因为 val(variable-name) 返回的是 variable-value,所以当 variable-value 不包含单位是,某些样式需要明确指定单位。

:root {
    --line-height: 20;
}

p {
    line-height: var(--line-height)px;
}

这点不像 jQuery 自动检测浏览器设置的默认单位。需要显示设置单位

JavaScript Proxy 代理

Proxy 对象可以捕获源对象(对象、数组、函数)的操作,包括增删改查(获取、赋值、枚举、删除)以及函数调用,可以更加全面地控制源对象。

代理对象

// 源对象 必须是复杂数据类型,如 对象、数组、函数
var target = {age: 27};

var handler = {
    get: function(target, key) {
        // 代理 target[key]
        console.log('get');
        if (key in target) {
            return target[key];
        }
    },
    set: function(target, key, value) {
        // 代理 target[key] = value
        console.log('set');
        target[key] = value;
    },
    deleteProperty: function(target, key) {
        // 代理 delete target[key]
        console.log('deleteProperty');
        return key in target ? delete target[key] : false;
    },
    enumerate: function(target, key) {
        console.log('enumerate');
        return Object.keys(target);
    },
    ownKeys: function(target, key) {
        // 代理 Object.getOwnPropertyNames(target)
        // 代理 Object.getOwnPropertySymbols(target)
        console.log('ownKeys');
        return Object.keys(target);
    },
    has: function(target, key) {
        // 代理 key in target
        console.log('has');
        return key in target;
    },
    defineProperty: function(target, key, desc) {
        // 代理 Object.defineProperty(proxy, key, desc)
        console.log('defineProperty');
        Object.defineProperty(target, key, desc);
        return target;
    },
    getOwnPropertyDescriptor: function(target, key) {
        console.log('getOwnPropertyDescriptor');
        return key in target ? {
            value: target[key],
            writable: true,
            enumerable: false,
            configurable: true
        } : undefined;    
    }
};

// 新建代理
var proxy = new Proxy(target, handler);

proxy.age;

proxy.age = 28;

Object.defineProperty(proxy, 'name', {value: 'seven'});

proxy.name;
target.name;

Object.keys(proxy),会分别调用 handler.ownKeys 和 getOwnPropertyDescriptor,前者用于获取 target 的 key 列表,后者用于依次判断每个 key 是否可以迭代。
若 getOwnPropertyDescriptor 返回值得 enumerate 为 false,则该 key 不会出现在 Object.keys(proxy) 返回结果中。

Object.getOwnPropertyDescriptors(proxy) 和 Object.keys(proxy) 一样,会分别调用 handler.ownKeys 和 getOwnPropertyDescriptor,但不会根据 getOwnPropertyDescriptor 返回结果过滤 key。


代理数组

var target = [1, 2, 3];

var handler = {
    set: function(target, key, value) {
        // 代理 target[key] = value
        console.log('set');
        target[key] = value;
        // 代理数组 set,需要 返回源对象
        // 代理对象不需要
        return target;
    }
};

var proxy = new Proxy(target, handler);

proxy.push(4);
proxy.pop();
proxy.unshift(5);
proxy.shift();

代理数组 handler.set 需要返回源对象,其余与代理对象一致。


代理函数

var target = function (name) {
    this.name = name;

    this.sayHello = function() {
        return 'Hi, I am ' + this.name;
    };

    return 'Hi, I am ' + name;
};

var handler = {
    construct: function(target, args) {
        console.log('construct');
        var inst = Object.create(target.prototype);
        target.apply(inst, args);
        return inst;
    },
    apply: function(target, args)  {
        console.log('apply');
        return target.apply(target, args);
    }
};

var proxy = new Proxy(target, handler);

proxy();

var inst = new proxy('seven');
inst.sayHello();

代理函数可以设置 handler.construct 和 handler.apply,其余与代理对象一致。


创建可以撤销的代理

var target = {age: 27};

var handler = {
    get: function(target, key) {
        // 代理 target[key]
        console.log('get');
        if (key in target) {
            return target[key];
        }
    }
};

var revocable = Proxy.revocable(target, handler);
var proxy = revocable.proxy;

proxy.age;

// 执行撤销
revocable.revoke();

// 撤销之后再执行任何代理操作都会报错

// TypeError
proxy.age;