为什么 Python3？

1. Shell 不适合某些复杂运算，尤其是 OpenWRT 用的 ash。

2. Lua 缺乏某些 SDK，比如说阿里云 SDK 就没有 Lua 版。

3. Python2 已经过时。

4. Node.js 在小型设备上不如 Python3 高效。

5. C、C++ 之流太难了！Go、Rust 还得编译，麻烦。

6. Perl、Ruby 已没落。

一个例子

当 IPv6 地址变化时，将地址发送到钉钉：https://github.com/UMU618/openwrt-ipv6-addresses

安装与调试

1. 安装可执行程序

1

opkg install python3-base

安装 python3-base 之后，就可以运行 python3 了。

1
2
3
4
5
6
7

root@UMU:~# python3
Could not find platform dependent libraries <exec_prefix>
Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]
Python 3.7.6 (default, Feb 11 2020, 12:41:31)
[GCC 7.5.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

用以下 Python 代码，打印目前已有的模块：

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
35
36
37

import sys

# 打印的信息太长
i = 0
for m in sys.modules:
    i += 1
    print('{0:2d} {1:32s} {2}'.format(i, m, sys.modules[m]))

# 不精准
i = 0
for m in sys.modules.values():
    i += 1
    if m.__spec__:
        v = m.__spec__.origin
    elif m.__builtins__:
        v = '-'
    else:
        v = ''
    print('{0:2d} {1:32s} {2}'.format(i, m.__name__, v))

# 推荐使用
i = 0
for m in sys.modules.values():
    i += 1
    s = str(m)
    start = s.find("'")
    end = s.find("'", start+1)
    k = s[start+1:end]
    start = s.find('from', end+1)
    if start > -1:
        start += 4
        end = s.find('>', start+1)
    else:
        start = s.find('(', end+1)
        end = s.find(')', start+1)
    v = s[start+1:end]
    print('{0:2d} {1:28s} {2}'.format(i, k, v))

结果为：

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

 1 sys                          built-in
 2 builtins                     built-in
 3 _frozen_importlib            frozen
 4 _imp                         built-in
 5 _thread                      built-in
 6 _warnings                    built-in
 7 _weakref                     built-in
 8 zipimport                    built-in
 9 _frozen_importlib_external   frozen
10 io                           built-in
11 marshal                      built-in
12 posix                        built-in
13 encodings                    '/usr/lib/python3.7/encodings/__init__.pyc'
14 codecs                       '/usr/lib/python3.7/codecs.pyc'
15 _codecs                      built-in
16 encodings.aliases            '/usr/lib/python3.7/encodings/aliases.pyc'
17 encodings.utf_8              '/usr/lib/python3.7/encodings/utf_8.pyc'
18 _signal                      built-in
19 __main__                     built-in
20 encodings.latin_1            '/usr/lib/python3.7/encodings/latin_1.pyc'
21 io                           '/usr/lib/python3.7/io.pyc'
22 abc                          '/usr/lib/python3.7/abc.pyc'
23 _abc                         built-in
24 site                         '/usr/lib/python3.7/site.pyc'
25 os                           '/usr/lib/python3.7/os.pyc'
26 stat                         '/usr/lib/python3.7/stat.pyc'
27 _stat                        built-in
28 posixpath                    '/usr/lib/python3.7/posixpath.pyc'
29 genericpath                  '/usr/lib/python3.7/genericpath.pyc'
30 posixpath                    '/usr/lib/python3.7/posixpath.pyc'
31 _collections_abc             '/usr/lib/python3.7/_collections_abc.pyc'
32 _sitebuiltins                '/usr/lib/python3.7/_sitebuiltins.pyc'
33 atexit                       built-in

下面来实现获取 IPv6 地址的功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def net_hex_to_ipv6(h):
    ipv6 = h[0:4]
    i = 4
    while i < len(h):
        ipv6 += ':' + h[i:i+4]
        i += 4
    return ipv6

with open('/proc/net/if_inet6') as f:
    for line in f:
        p = line.split()
        if p[3] == '00' and (int(p[4], 16) & 0x80) != 0x80:
            ip = net_hex_to_ipv6(p[0])
            print(ip)
    f.close()

以上代码有个“美中不足”：只能打印地址的“首选格式”，不支持“压缩格式”。下面改进！

2. 安装轻量库

UMU 打算使用 socket 模块的工具函数格式化 IPv6 地址，但目前已安装的 python3-base 不带 socket 模块：

1
2
3
4

>>> import socket
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'socket'

所以需要安装 python3-light：

1

opkg install python3-light

装完即可愉快地玩耍：

1
2
3
4
5

import socket

ip = '0618:0618:0618:0618:0000:0000:0000:0618'
print(ip, '->',
    socket.inet_ntop(socket.AF_INET6, socket.inet_pton(socket.AF_INET6, ip)))

以上代码打印：0618:0618:0618:0618:0000:0000:0000:0618 -> 618:618:618:618::618。

3. 全量安装

如果 python3-light 还不能满足您，推荐来个全家桶：

1

opkg install python3

PS: 不要以为只要上面这句就全装上了，前面的 opkg install python3-base 是必要的！如果只装 python3，则 /usr/bin/python3 并不存在！

（完）

前言

• 如果您看得懂，那么，这是 Node.js 程序员的 C++ 进修指南。

• 如果您没看懂，那么，这是学 C++ 的劝退书！

目的

用 C++ 改写 Node.js 程序，主要目的可能有两个：保密、提高性能。

那么您肯定要问：为什么不用 Go 或者 Rust 改写？UMU 是推荐用 Go 或 Rust 的，而且相对改写为 C++ 要简单得多，本系列文章，可能从反面论证：您应该选择用 Go 或者 Rust 改写！

代码仓库

https://github.com/UMU618/cpp-for-nodejs-programmers

第一个例子

在《学习 Rust【2】减少代码嵌套》中，UMU 提到一个使代码平坦化的例子，咱们把其中最基本的功能提炼出来，成为最简单的例子：

1
2
3
4
5
6
7
8
9
10
11

setTimeout(() => {
  console.log('step1')
}, 1000)

setTimeout(() => {
  console.log('step2')
}, 2000)

setTimeout(() => {
  console.log('step3')
}, 3000)

这段代码实现的功能是：一秒后打印 step1，再一秒后打印 step2，再一秒后打印 step3，退出。

翻译为 C++

首先明确一点：JavaScript 是 JIT 语言，不用编译，语言宿主直接解释运行。C++ 是 AOT 语言，需要编译。所以我们需要编译器（比如 g++、clang++）和编译脚本（比如 make、cmake）。下面我们会选择在 macOS 上使用 clang++ 和 cmake 来编译 C++ 代码。其中，cmake 其实是用来产生 Makefile 的，如果您学过 Makefile，可以直接用它。

安装依赖软件

• 安装 Xcode，以获取 MacOSX.sdk。

• 安装 clang++ 和 cmake：

1
2

brew install llvm
brew install cmake

STL 实现

• C++ 代码：

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// set_timeout.cc
// UMU: 这是一个不太好的实现
#include <chrono>
#include <future>
#include <iostream>
#include <vector>

class Timer {
 public:
  template <typename T>
  void setTimeout(T function, int delay);
  void stop();
  void wait();

 private:
  bool clear = false;
  std::vector<std::thread> pool;
};

template <typename T>
void Timer::setTimeout(T function, int delay) {
  this->clear = false;
  pool.emplace_back(std::thread([=]() {
    if (this->clear) {
      return;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(delay));
    if (this->clear) {
      return;
    }
    function();
  }));
}

void Timer::stop() {
  this->clear = true;
}

void Timer::wait() {
  for (std::thread& thread : pool) {
    if (thread.joinable()) {
      thread.join();
    }
  }
}

int main() {
  Timer timer;
  //timer.setTimeout([&]() { std::cout << "step1\n"; timer.stop(); }, 1000);
  timer.setTimeout([]() { std::cout << "step1\n"; }, 1000);
  timer.setTimeout([]() { std::cout << "step2\n"; }, 2000);
  timer.setTimeout([]() { std::cout << "step3\n"; }, 3000);
  timer.wait();
  return 0;
}

• cmake 脚本，CMakeLists.txt：

1
2
3
4
5
6

cmake_minimum_required (VERSION 3.5)
project (set_timeout)

add_executable(set_timeout set_timeout.cc)
set_property(TARGET set_timeout PROPERTY CXX_STANDARD 17)
target_compile_features(set_timeout PRIVATE cxx_auto_type)

• 编译：

1
2
3

# cd to source code directory
cmake .
make

小结：以上代码，可用，但不推荐。首先它是用多线程模拟的定时器，当设置 N 个定时器时，将创建 N 个线程，这不够优雅。其次，当您取消定时器时，会发现它无法立刻取消并退出线程。

Boost Asio 实现

我们知道，Nodejs 内部使用 libuv 作为异步 IO 库，它是 C 实现的，用 C++ 调用 libuv 就显得不那么 C++，所以我们决定用和 libuv 同类且更强大的 Boost Asio 来代替。

• 安装 boost，目前是 1.72.0 版：

1

brew install boost

• C++ 代码：

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include <chrono>
#include <iostream>
#include <vector>

#include <boost/asio.hpp>
#include <boost/asio/steady_timer.hpp>

class Timer {
 public:
  template <typename T>
  void setTimeout(T function, int delay);
  void stop();
  void wait();

 private:
  boost::asio::io_context io;
  std::vector<boost::asio::steady_timer> timers;
  size_t count;
};

template <typename T>
void Timer::setTimeout(T function, int delay) {
  auto& timer = timers.emplace_back(boost::asio::steady_timer(io));
  ++count;
  timer.expires_from_now(std::chrono::milliseconds(delay));
  timer.async_wait([=](const boost::system::error_code& error) {
    // boost::system::error::operation_canceled
    // boost::asio::error::operation_aborted
    if (!error) {
      function();
    }
  });
}

void Timer::stop() {
  for (auto& timer : timers) {
    timer.cancel();
  }
}

void Timer::wait() {
  io.run();
}

int main() {
  Timer timer;
  //timer.setTimeout([&]() { std::cout << "step1\n"; timer.stop(); }, 1000);
  timer.setTimeout([]() { std::cout << "step1\n"; }, 1000);
  timer.setTimeout([]() { std::cout << "step2\n"; }, 2000);
  timer.setTimeout([]() { std::cout << "step3\n"; }, 3000);
  timer.wait();
  return 0;
}

• cmake 脚本，CMakeLists.txt：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

cmake_minimum_required (VERSION 3.5)
project (set_timeout)

add_executable(set_timeout set_timeout.cc)
set_property(TARGET set_timeout PROPERTY CXX_STANDARD 17)
target_compile_features(set_timeout PRIVATE cxx_auto_type)

set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_STATIC_RUNTIME ON)
find_package(Boost 1.71.0)
if(Boost_FOUND)
  include_directories(${Boost_INCLUDE_DIRS})
  target_link_libraries(set_timeout ${Boost_LIBRARIES})
endif()

小结：好很多，但太难了……这真是劝退书！

结论先行：减少代码嵌套就是降低复杂度。

资源管理一向是编程中的重要任务。当一个函数要管理多个资源时，很容易出现代码嵌套层级太深的问题，尤其是调用系统或第三方 API 时。

以 C 语言代码为例，这里简化为两个资源，请您自行脑补多个资源：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int error_code = 0;
resource1 *p1 = new_resource1();
// UMU: with C++ SHOULD be `p1 != nullptr`
if (p1) {
  resource2 *p2 = new_resource2();
  if (p2) {
    if (!deal_resources(p1, p2)) {
      error_code = 3;
    }
    free_new_resource2(p2);
  } else {
    error_code = 2;
  }
  free_new_resource1(p1);
} else {}
  error_code = 1;
}

return error_code;

上面代码最深嵌套是三层，为了减少嵌套，可以把代码改为平坦结构，降低到一层：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

resource1 *p1 = new_resource1();
if (!p1) {
  free_new_resource1(p1);
  return 1;
}

resource2 *p2 = new_resource2();
if (!p2) {
  free_new_resource1(p1);
  free_new_resource2(p2);
  return 2;
}

if (!deal_resources(p1, p2)) {
  free_new_resource1(p1);
  free_new_resource2(p2);
  return 3;
}

free_new_resource1(p1);
free_new_resource2(p2);

但这么改在资源释放时，更容易遗漏。也有人为使代码层级平坦化，会使用 goto 到函数末尾统一释放，或者更优雅点的 C++ 方式：用 try...throw...catch...finally 将所有资源包含起来管理。

Node.js 的异步回调函数也存在嵌套层级过深的问题，可以用 Promise 来平坦化，参考：

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

setTimeout(() => {
  console.log('step1')
  setTimeout(() => {
    console.log('step2')
    setTimeout(function() {
      console.log('step3')
      console.log('done!')
    }, 1000)
  }, 1000)
}, 1000)

// flatten
let timer = (text) => {
  let promise = new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log(text)
      resolve()
    }, 1000)
  })

  return promise
}

timer("step1")
  .then(() => {
    return timer("step2")
  })
  .then(() => {
    return timer("step3")
  })
  .then(() => {
    console.log("done!")
  })

C++ 建议使用 RAII 思想来管理资源，获得资源后立刻放到管理对象里。如果有些资源使用得不频繁，想偷懒不去封装，则可以使用 scope_exit。go 语言更是用内置关键字 defer 来提供 scope_exit 机制。

Rust 用 scopeguard 提供 scope_exit 机制，defer! 宏和 go 的 defer 功能类似。

另外，Rust 还有 ? 操作符，也有减少嵌套的作用。比如这个任务：打开文件，如果失败就返回错误。go 是这样写的：

1
2
3
4
5
6
7
8
9
10
11
12
13

package main

import (
	"os"
)

func main() {
	file, error := os.Open("file.txt")
	if error != nil {
		panic(error)
	}
	defer file.Close()
}

同样功能，Rust 代码少一层：

1
2
3
4
5
6

use std::fs::File;

fn main() -> std::io::Result<()> {
  let _f = File::open("file.txt")?;
  Ok(())
}

前情

上篇《ECC Node.js》讲解椭圆曲线点的计算。本篇分析椭圆曲线签名算法。

代码

https://github.com/UMU618/secp256k1-tools

范例数据

已知，待签名数据为：

1
2
3
4
5
6
7

const data = Buffer.from(
  // chainId
  'aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906'
  // serializedTransaction
  + 'c0fbc75d000000000000000000000000'
  // sha256 of serializedContextFreeData
  + '0000000000000000000000000000000000000000000000000000000000000000', 'hex')

运行 node ecc-sign.js，信息摘要为：

1
2
3
4
5
6

[
  204,  24,  57, 178,  84, 129,  31, 104,
   99,  30, 100, 210,   3,  38,  31, 168,
  138, 248, 252, 131, 196,  14, 203, 152,
   34, 152, 102, 149, 181,  94, 182, 148
]

签名为：

1
2
3
4
5
6
7
8

Uint8Array [
   27,  36, 211, 214,  45,  20, 219,  85, 150,  70, 174,
  229, 131, 173,  20,  61,  37, 129, 232,  80,  19, 164,
   36, 249, 132,  56,  36,  74, 210,  34, 221,  98, 164,
   68,   6, 237,  42, 240, 227, 212,  33, 105, 239, 200,
   11,  59,  11, 148, 226,  85, 212, 106, 250, 155,  34,
   25, 101,  69, 159, 138, 157, 114,  44,  38, 202
]

签名的字符串形式为：SIG_K1_Gg74ULRryVHxYZvMRLJgTrAZW6PZGC5SYfUiswtMJxBwfTTnGEnTejeWXopL2oSs8EZD7mqAC8mCps6VKq95Bgic9tGNHJ

分析

数值全部使用 16 进制表示。

1. 范例使用的钥匙对

   • 签名私钥：5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3

   • k = d2653ff7cbb2d8ff129ac27ef5781ce68b2558c41a74af1f2ddca635cbeef07d

   • 对应的公钥：EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV

   • K = [c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf, eeceff7130fd352c698d2279967e2397f045479940bb4e7fb178fd9212fca8c0]

2. 信息先用 sha256 算法计算摘要，范例中值为 h = cc1839b254811f68631e64d203261fa88af8fc83c40ecb9822986695b55eb694

3. 签名数据一共 65 字节，第一个字节 [27] 是 recoveryParam，使用前要先减去 27，它的一个作用是区别 y 坐标值的奇偶性，后面是两个 256bit 数，分别记为 x、s，x 是随机私钥 r 在椭圆曲线上的点 rG 的 x 坐标值，s = (h + k * x) / r。

   • x = 24d3d62d14db559646aee583ad143d2581e85013a424f98438244ad222dd62a4

   • s = 4406ed2af0e3d42169efc80b3b0b94e255d46afa9b221965459f8a9d722c26ca

   • 注意：elliptic 库把本文的 x 记为 r，为了和算法保持一致，UMU 没有采用 elliptic 的标识方式。

4. 计算 rG = [24d3d62d14db559646aee583ad143d2581e85013a424f98438244ad222dd62a4, bc336258d8f1789ad949773ef4abfe6a6e56c9dd77754e18869c7ab2801a4ae2]

1
2
3
4
5
6
7
8
9
10
11

const BN = require('bn.js')
const elliptic = require('elliptic')

const x = new BN('24d3d62d14db559646aee583ad143d2581e85013a424f98438244ad222dd62a4', 16, 'be')
console.log('x =', x.toString(16))

// (27 - 27) & 1 是偶数，取偶数的 y
const p_even = elliptic.curves.secp256k1.curve.pointFromX(x, false)
console.log('y_even = ', p_even.getY().toString(16))
// const p_odd = elliptic.curves.secp256k1.curve.pointFromX(x, true)
// console.log('y_odd  = ', p_odd.getY().toString(16))

1. 计算 hG/s + x * K/s

   • u1 = h/s = b774bb6040cced0596626026679594b2b5478e6a5a8ba25b3411ed5360ea6bfa

   • u2 = x/s = 5697dfd4caab3caa0ed315a97f99f1ad7bce1ce85e0be32c63847d1dd4be327a

   • result = u1 G + u2 K = [24d3d62d14db559646aee583ad143d2581e85013a424f98438244ad222dd62a4, bc336258d8f1789ad949773ef4abfe6a6e56c9dd77754e18869c7ab2801a4ae2]，与 rG 一致，签名验证通过。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

const BN = require('bn.js')
const elliptic = require('elliptic')

const k1 = elliptic.curves.secp256k1
const h = new BN('cc1839b254811f68631e64d203261fa88af8fc83c40ecb9822986695b55eb694', 16)
const s = new BN('4406ed2af0e3d42169efc80b3b0b94e255d46afa9b221965459f8a9d722c26ca', 16)
// u1 = h/s
const sinv = s.invm(k1.n)
const u1 = h.mul(sinv).umod(k1.n)
u1.toString(16)

const x = new BN('24d3d62d14db559646aee583ad143d2581e85013a424f98438244ad222dd62a4', 16)
// u2 = x/s
const u2 = x.mul(sinv).umod(k1.n)
u2.toString(16)

const k = new BN('d2653ff7cbb2d8ff129ac27ef5781ce68b2558c41a74af1f2ddca635cbeef07d', 16)
const K = k1.g.mul(k)
const result = k1.g.mulAdd(u1, K, u2)  // k1.g.mul(u1).add(K.mul(u2))
result.getX().toString(16)
result.getY().toString(16)

数学原理

参考：椭圆曲线加密和签名算法

hG/s + xK/s = hG/s + x(kG)/s = (h + xk)G/s = r(h + xk)G / (h + kx) = rG

结论先行：从语法上说，Rust 基本无敌。

1. ++ 和 --

++、-- 一般是 +=、-= 的特例（除了 C++ 的迭代器），没有必要单独支持，新语言倾向于语法的单一性。

Python 的情况比较有意思，放后面是语法错误，放前面其实就是正负号，+ 写两次还是原来的数，- 写两次是负负得正，也还是原来的数。

2. 三目运算符（?:）

Rust 的 let = if else 就有 C 语言 ?: 的功能，即判断语句的子语句块可以有返回值。

3. 条件无需括号

字符是能少打一个是一个，有效预防鼠标手。另外，Go 和 Rust 的语句块必须包含于 {}。

4. 异常处理

5. 换行符（;）

Rust 有分号的是语句（statement），返回值是 ()，即没有返回值。而没分号的是表达式（expression），返回值就是自身的值。

其实想说的是：有的 return 被简化掉了。省略 ; 就是省略 return，真香。但是，由于隐含 return，所以只能用于语句块的最后一行。

6. case 隐含 break

Rust 优秀在用 match 代替 switch，明确告诉大家这是新语法，而 Go/Swift 用 switch，却改变 case 行为，还多出一个 fallthrough 关键字，容易引起鲸神魂裂。

极路由 1S

1S 有两款硬件：hc5661 和 hc5661a，刷错变砖，而且要刷的文件名有点迷惑性，意不意外？

• hc5661: https://breed.hackpascal.net/breed-mt7620-hiwifi-hc5761.bin

• hc5661a: https://breed.hackpascal.net/breed-mt7628-hiwifi-hc5661a.bin

原版 bootloader 有 DHCP 功能，自身 IP 是 192.168.2.1，比较特殊。

这里以 hc5661 为例，版本是：HC5661 - 1.4.11.21001s，破解式 root 或开发者解锁后，可以直接 mtd unlock u-boot，开不开心？

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

BusyBox v1.22.1 (2018-05-10 05:32:57 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.

***********************************************************
              __  __  _              _   ____  _   TM
             / / / / (_) _      __  (_) / __/ (_)
            / /_/ / / / | | /| / / / / / /_  / /
           / __  / / /  | |/ |/ / / / / __/ / /
          /_/ /_/ /_/   |__/|__/ /_/ /_/   /_/
                  http://www.hiwifi.com/      rooted by UMU
***********************************************************
root@HiUMU:~# cat /proc/mtd
dev:    size   erasesize  name
mtd0: 00030000 00010000 "u-boot"
mtd1: 00010000 00010000 "hw_panic"
mtd2: 00010000 00010000 "Factory"
mtd3: 00020000 00010000 "oem"
mtd4: 00010000 00010000 "bdinfo"
mtd5: 00010000 00010000 "backup"
mtd6: 00f70000 00010000 "firmware"
mtd7: 00120000 00010000 "kernel"
mtd8: 00e50000 00010000 "rootfs"
mtd9: 00400000 00010000 "rootfs_data"
root@HiUMU:~# mtd unlock u-boot
Unlocking u-boot ...
root@HiUMU:~# cd /tmp
root@HiUMU:/tmp# mtd write ./breed-mt7620-hiwifi-hc5761.bin u-boot
Unlocking u-boot ...

Writing from ./breed-mt7620-hiwifi-hc5761.bin to u-boot ...
[e:0]   [w0]
[e:1]   [w1]

刷完，捅菊花进入的信息是：

极路由 3

版本 HC5861 - 1.4.10.20837s，一样能开发者解锁后直接刷。这种不保护 bootloader 的 ROM，也是醉了，真香……已经过保，也不想恢复官方 ROM，直接刷 BREED，再刷 OpenWRT 18.06.5。

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

BusyBox v1.22.1 (2018-03-10 04:32:13 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.

***********************************************************
              __  __  _              _   ____  _   TM
             / / / / (_) _      __  (_) / __/ (_)
            / /_/ / / / | | /| / / / / / /_  / /
           / __  / / /  | |/ |/ / / / / __/ / /
          /_/ /_/ /_/   |__/|__/ /_/ /_/   /_/
                  http://www.hiwifi.com/
***********************************************************
root@Hiwifi:~# cat /proc/mtd
dev:    size   erasesize  name
mtd0: 00030000 00010000 "u-boot"
mtd1: 00010000 00010000 "hw_panic"
mtd2: 00010000 00010000 "Factory"
mtd3: 00020000 00010000 "oem"
mtd4: 00010000 00010000 "bdinfo"
mtd5: 00010000 00010000 "backup"
mtd6: 00f70000 00010000 "firmware"
mtd7: 00120000 00010000 "kernel"
mtd8: 00e50000 00010000 "rootfs"
mtd9: 00380000 00010000 "rootfs_data"
root@Hiwifi:~# mtd unlock u-boot
Unlocking u-boot ...
root@Hiwifi:~# cd /tmp
root@Hiwifi:/tmp# mtd write breed-mt7620-hiwifi-hc5861.bin u-boot
Unlocking u-boot ...

Writing from breed-mt7620-hiwifi-hc5861.bin to u-boot ...
[e:0]   [w0]
[e:1]   [w1]

BREED 信息：

嗯……这款路由器就是骗钱的。

Lenovo Y1S

这款最简单，直接捅菊花进官方恢复模式，刷这个文件：https://breed.hackpascal.net/breed-mt7620-lenovo-y1s.bin！

Newifi D1

先官方 ROM 降级：xCloudOS_newifi-d1_Build20150922_v0.0.4.3500_beta_sign.bin 或更早的 xCloudOS_newifi-d1_Build_v0.0.4.2100_beta_sign.bin，自寻下载。

较老的版本可能和 Y1S 一样可以直接在恢复模式下刷，不过 UMU 忘记这样尝试。

0.0.4.3500, r33798 的版本，布局如下：

1
2
3
4
5
6
7
8
9
10
11

# cat /proc/mtd
dev:    size   erasesize  name
mtd0: 00030000 00010000 "u-boot"
mtd1: 00010000 00010000 "u-boot-env"
mtd2: 00010000 00010000 "Factory"
mtd3: 02000000 00010000 "fullflash"
mtd4: 01fb0000 00010000 "firmware"
mtd5: 0012a926 00010000 "kernel"
mtd6: 01e656da 00010000 "rootfs"
mtd7: 01080000 00010000 "rootfs_data"
mtd8: 00020000 00010000 "panic_oops"

网上的刷机教程如下：

1
2
3
4
5
6

cd /tmp
wget https://breed.hackpascal.net/breed-mt7621-newifi-d1.bin --no-check-certificate
dd if=/dev/zero bs=1024 count=192 | tr "\000" "\377" >breed_192.bin
dd if=breed-mt7621-newifi-d1.bin of=breed_192.bin conv=notrunc
cat /tmp/breed_192.bin /dev/mtd1 /dev/mtd2 /dev/mtd4 >fullflash_with_breed.bin
mtd write fullflash_with_breed.bin fullflash

原理：u-boot 分区不能直接刷，但 fullflash 分区可以刷，fullflash 其实包含了 u-boot。

fullflash = u-boot + u-boot-env + firmware

以上命令就是组合成一个适合刷到 fullflash 的文件，而且是用 BREED 覆盖了 u-boot，然后刷到 fullflash，这样 u-boot 就被覆盖了，其它分区还是原来的内容。

值得注意的是：刷完 BREED，捅菊花的位置变了，不再是捅原来的菊花……而是天线下方那个红十字按钮，这原是用于 WPS 的。

Newifi D2

访问 http://192.168.99.1/newifi/ifiwen_hss.html 开启 SSHD，查看分区布局：

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

BusyBox v1.24.1 (2018-02-27 16:23:44 CST) built-in shell (ash)


  _______________________________________________________________
 |    ____                 _                 ____               |
 |   |  _ \ __ _ _ __   __| | ___  _ __ __ _| __ )  _____  __   |
 |   | |_) / _` | '_ \ / _` |/ _ \| '__/ _` |  _ \ / _ \ \/ /   |
 |   |  __/ (_| | | | | (_| | (_) | | | (_| | |_) | (_) >  <    |
 |   |_|   \__,_|_| |_|\__,_|\___/|_|  \__,_|____/ \___/_/\_\   |
 |                                                              |
 |                  PandoraBox SDK Platform                     |
 |                  The Core of SmartRouter                     |
 |       Copyright 2013-2016 D-Team Technology Co.,Ltd.SZ       |
 |                http://www.pandorabox.org.cn                  |
 |______________________________________________________________|
  Base on OpenWrt BARRIER BREAKER (3.2.1.7418, 2018-03-06-git-bbccda9)
#cat /proc/mtd
dev:    size   erasesize  name
mtd0: 00010000 00010000 "u-boot-env"
mtd1: 00010000 00010000 "Factory"
mtd2: 01fb0000 00010000 "firmware"
mtd3: 00146bf9 00010000 "kernel"
mtd4: 01e49407 00010000 "rootfs"
mtd5: 00d40000 00010000 "rootfs_data"
mtd6: 00020000 00010000 "panic_oops"
mtd7: 00010000 00010000 "nvram"

这是被隐藏掉两个分区的！

高端刷法，是用一个内核模块来刷的，自寻 newifi-d2-jail-break.ko，参考文章：https://www.right.com.cn/forum/thread-365936-1-1.html

按以上链接刷好是 1.1 (r1237) 版，进 BREED 刷最新 BREED：https://breed.hackpascal.net/breed-mt7621-newifi-d2.bin

信息为：

When I write pathfinding codes in JavaScript, I ran into this problem: how to empty the array?

Methods

• Method 1

1

array = []

• Method 2

1

array.length = 0

• Method 3

1

array.splice(0, array.length)

• Method 4

1
2
3

while (array.length > 0) {
    array.pop()
}

Difference between Method 1 and the others

Method 1 only reassign a:

1
2
3
4
5
6
7
8

let a = [1, 2, 3]
let b = a

// empty a, but doesn't affect b
a = []

console.log('a =', a)
console.log('b =', b)

Method 2, 3, 4, will empty multiple variables referencing the same object:

1
2
3
4
5
6
7
8

let a = [1, 2, 3]
let b = a

// empty a and b
a.length = 0

console.log('a =', a)
console.log('b =', b)

More

See https://github.com/UMU618/js-empty-array#example

起源

今天看到有网文《iptables+tproxy实现ss-redir的UDP转发的方法》说：“OpenWrt 做 UDP 转发需要的依赖是：iptables-mod-tproxy, kmod-ipt-tproxy 和 ip-full”。使用 opkg install ip 安装的默认是 ip-tiny，一般情况下都是够用的，不禁想弄明白两者有何区别。

探索

拿 ip 命令对比测试：

• ip-tiny

1
2
3

OBJECT := { link | address | route | rule | neigh | tunnel | maddress |
            mroute | mrule | monitor | netns | macsec | token | ila |
            vrf | sr }

• ip-full

1
2
3
4

OBJECT := { link | address | addrlabel | route | rule | neigh | ntable |
            tunnel | tuntap | maddress | mroute | mrule | monitor | xfrm |
            netns | l2tp | fou | macsec | tcp_metrics | token | netconf | ila |
            vrf | sr }

即 ip-full 多了这些对象： addrlabel | ntable | tuntap | xfrm | l2tp | fou | tcp_metrics | netconf。举个例子，只安装 ip-tiny 时，运行 ip xfrm 报错如下：

Object “xfrm” is unknown, try “ip help”.

相关知识：

xfrm is an IP framework for transforming packets (such as encrypting
their payloads). This framework is used to implement the IPsec
protocol suite (with the state object operating on the Security
Association Database, and the policy object operating on the Security
Policy Database). It is also used for the IP Payload Compression
Protocol and features of Mobile IPv6.

结论

实际上，转发普通 UDP 包，并不需要 ip-full，ip-tiny 即可。

需求

原版 EOS 历史 API 插件将数据都保存在内存，随着历史数据越来越多，内存消耗高达 T 级以上，使得这个插件失去实用性。于是出现很多替代产品，比如把数据同步到 MongoDB，然后用 Nodejs 对接 MongoDB 来实现 API 服务。

2019 年 3 月份，MEET.ONE 实现了一个基于 MongoDB 的 EOS 历史 API 服务。劣者将去掉 MongoDB 交互部分的框架开源于 UMU618/eos-history-api-service。

测试

这个 API 服务的开发者是公司另一名 Web 全栈开发，他测试通过之后，劣者用 cleos 一试，立马 bug！调试后端代码，发现 req.body 不是一个 JSON 对象。

劣者立刻用 tcpdump 抓包，发现 cleos 发出去的包并无异常，body 就是一段 JSON 数据。

交流后，发现测试工具的差异：劣者是 C++ 开发，自然而然使用 cleos 测试，而 Web 全栈开发对 cleos 比较陌生，他们会选择 postman 或者自己写测试性客户端。比如：

1
2
3
4
5
6
7

const request = require('request-json')
const client = request.createClient('http://127.0.0.1:8888/')

const json = {"id": "d5245026c757532ea3dd5b3a02a07620eb7238113d0a49cae5ebb93921a34135"};
client.post('/v1/history/get_transaction', json, function(err, res, body) {
  console.log(res.statusCode, body)
})

后来劣者写了一个简易的 Web 服务器，显示请求头。

1
2
3
4
5
6
7
8
9
10
11
12
13

const http = require('http')

http.createServer(function (req, res) {
  let buffer = req.method + ' ' + req.url + ' ' + req.httpVersion
  console.log(buffer)
  res.write(buffer + '\r\n')
  for (let i = 0; i < req.rawHeaders.length; i += 2) {
    buffer = req.rawHeaders[i] + ': ' + req.rawHeaders[i + 1]
    console.log(buffer)
    res.write(buffer + '\r\n')
  }
  res.end()
}).listen(8888)

经对比，cleos 发的请求不带 Content-Type。cleos 是 EOSIO 的官方工具，使用者众多，若不支持它是不合理的，后端也不能要求客户端都带上 Content-Type。

调试

检查后端代码，其对 body 的解析是用 body-parser 完成的：

1

app.use(bodyParser.json())

使用以下命令启动服务：

1

DEBUG=body-parser:* node app.js

发现有这样 2 行关键的调试信息：

1
2

body-parser:json content-type undefined +0ms
body-parser:json skip parsing +1ms

原来 body-parser 会检查 Content-Type，不符合它的预期，就不解析，于是 body 就不是 JSON 对象。

开发

暴力的解决方案

参考《Express 解析 json 格式 post 数据》后，我们这样解决：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 显式调用 JSON.parse 强行解析
app.use((req, res, next) => {
  req.rawBody = ''
  req.on('data', (chunk) => {
    req.rawBody += chunk
  })
  req.on('end', () => {
    try {
      req.body = JSON.parse(req.rawBody)
    } catch (err) {
      req.body = null
    }
    next()
  })
})

但劣者认为以上方案比较不优雅，JavaScript 作为一门高级语言，我们希望更多专注于业务逻辑，尽量复用现有代码，少自己写工具性代码。下面探讨使用 body-parser 的解法。

优雅的解决方案

劣者希望能告诉 body-parser 遇到不传 Content-Type 依然当它是 JSON 去解析。于是这就得去看它的代码！我们从上面关键的调试信息入手，可以很快发现：

1
2
3
4
5
6

// determine if request should be parsed
if (!shouldParse(req)) {
  debug('skip parsing')
  next()
  return
}

而 shouldParse 是可以由传入的选项影响的：

1
2
3
4
5
6
7
8
9
10
11
12

function json (options) {
  var opts = options || {}
  // 省略部分无关代码
  var type = opts.type || 'application/json'
  // 省略部分无关代码

  // create the appropriate type checking function
  var shouldParse = typeof type !== 'function'
    ? typeChecker(type)
    : type
  // 省略部分无关代码
}

于是最终的解决方案是：如果不传 Content-Type，当做 application/json；但如果有传，那得传对，否则也是不理。效果上，比之前无脑地当成 application/json，稍微好一些。实现上，则更优雅。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12

// Force body-parser to parse data as JSON
const bodyParser = require('body-parser')
const typeis = require('type-is')

app.use(bodyParser.json({ type: function(req) {
  if (undefined === req.headers['content-type']) {
    // cleos POST data without content-type
    return true
  } else {
    return Boolean(typeis(req, 'application/json'))
  }
}}))

（完）

前情

上篇《基于 ECC 的私钥转为公钥的过程》讲到求椭圆曲线上的点时，用的是基于 Python 的 SAGE。为了方便 Node.js 程序员理解和实现完整流程代码，本篇用 Node.js 库实现椭圆曲线点的计算。

用 Node.js 求椭圆曲线的点

库的选型考虑 eosjs 用的 ecurve 和 elliptic。

1. ecurve

1
2
3
4
5
6
7
8

const ecurve = require('ecurve')
const BigInteger = require('bigi')

const k1 = ecurve.getCurveByName('secp256k1')
const pk = BigInteger.fromHex('d2653ff7cbb2d8ff129ac27ef5781ce68b2558c41a74af1f2ddca635cbeef07d')
const pub = k1.G.multiply(pk)
pub.affineX.toHex()
pub.affineY.isEven()

得到 x 值为 c0ded2bc1f1305fb0faac5e6c03ee3a1924234985427b6167ca569d13df435cf，y 为偶数，和 SAGE 计算结果一样。

2. elliptic

流程基本一样，所以这里给出完整转换代码。

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
35
36
37
38
39
40

/**
 * @author UMU618 <umu618@hotmail.com>
 * @copyright MEET.ONE 2019
 * @description Use block-always-using-brace npm-coding-style.
 */

'use strict'

const bsc = require('bs58check')
const ripemd160 = require('ripemd160')
const bs = require('bs58')
const elliptic = require('elliptic')
const BN = require('bn.js')

function encodePublicKey(payload) {
  const checksum = new ripemd160().update(payload).digest()

  return bs.encode(Buffer.concat([
    payload,
    checksum.slice(0, 4)
  ]))
}

function privateKeyToPublicKey(privateKey) {
  const buf = bsc.decode(privateKey)
  if (0x80 !== buf[0]) {
    throw new Error('Not a private key.')
  }
  const k1 = elliptic.curves.secp256k1
  const pvt = new BN(buf.slice(1), 'be')
  const pub = k1.g.mul(pvt)
  const y = pub.getY().isEven() ? 2 : 3
  return 'EOS' + encodePublicKey(Buffer.from([y].concat(pub.getX().toArray())))
}

const privateKey = '5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3'
const publicKey = privateKeyToPublicKey(privateKey)

console.log(privateKey)
console.log(publicKey)

3. 对比

elliptic 比较好用，比较快。

代码

https://github.com/UMU618/secp256k1-tools