【加密算法】】椭圆曲线密码学（ECC）

1.2. 加法运算公式

2.3. 椭圆曲线上有多少个点（群的阶）

椭圆曲线，如 \(y^2 \equiv x^3 − x \pmod {61}\) 上（包含 \(\mathcal{O}\) ）有多少个点呢（注：群中元素个数又称为群的阶）？这里素数P  比较小，我们把 x 从 0 到 p-1 遍历一次，每个  x看是否可以求出合法的  y也满足  \(y \in \{0, 1, \cdots, p-1\}\)，即可统计出所有满足要求的点。当  x固定时最多有 2 个 y ，再加上一个额外的\(\mathcal{O}\)  ，所以我们知道 \(\mathbb{F}_{p}\) 上的椭圆曲线的点的数量肯定不会超过2p+1  。这种方法当素数p  很大时效率很慢，可以用 Schoof's algorithm 快速计算椭圆曲线上点的个数。
 

对于有限素域  \(\mathbb{F}_{p}\)上的椭圆曲线，其点的个数记为\(\#E(\mathbb{F}_{p})\)  。
 

2.3.1. Hasse 定理

Hasse's theorem 表明有限素域 \(\mathbb{F}_{p}\) 上的椭圆曲线的点的个数\(\#E(\mathbb{F}_{p})\)  会满足下面约束：
 $$\mid \#E(\mathbb{F}_{p}) - (p + 1) \mid \le 2 \sqrt{p}$$

比如，前面介绍的 \(\mathbb{F}_{13}]) 上的曲线 \(y^2 = x^3 + 3x + 8\) ，我们已经知道：\(\#E(\mathbb{F}_{p})=9\)  ，容易验证  \(\mid 9 - (13+1) \mid \le 2 \sqrt{13}\)是成立的。
 

2.4. 标量乘法和循环子群

我们定义下面记号：

$$nP = \underbrace{P + P + \cdots + P}_{n \text{ times}}$$

定义 \\(0P = \mathcal{O}\) 。以  \(y^2 \equiv x^3 + 2x + 3 \pmod {97}\)为例，取  \(P=(3,6)\)，我们计算一下\(P, 2P, 3P, 4P, 5P, 6P \cdots\)  ，由群的“封闭性”可知，它们都属于椭圆曲线所在“群”。

$$\begin{aligned}
0P &= \mathcal{O} \\
1P &= (3, 6) \\
2P &= (80, 10) \\
3P &= (80, 87) \\
4P &= (3, 91) \\
5P &= \mathcal{O} \\
6P &= (3, 6) \\
7P &= (80, 10) \\
8P &= (80, 87) \\
8P &= (3, 91) \\
10P &= \mathcal{O} \\
\cdots \\
\end{aligned}$$

我们可以发现，P  的倍数只有 5 个点，而椭圆曲线上其他的点没有出现在P  的倍数中。
 可以证明  \(\mathcal{O}, (3, 6), (80, 10), (80, 87), (3, 91)\)  在椭圆曲线群所定义的加法运算下也构成群，它称为椭圆曲线群的“子群”，由于这个子群的每个元素可通过对\(P=(3, 6)\)  重复进行群运算而生成，所以这个子群又称为“循环子群”，其中  P称为循环子群的 Base Point（或者 Generator）。
 

2.4.1. Generator 的选择

在循环子群中，除\(\mathcal{O}\)  外，每个点都可以作为 Generator。那么怎么从中选择一个 Generator 作为椭圆曲线的参数呢？我们 一般从中选择 X 坐标较小的点，对于 X 坐标一样小时可能存在的两个点中，一般从中选择 y 坐标较小的点。
 

参考：https://crypto.stackexchange.com/questions/88575/prime-order-elliptic-c…
 

2.4.2. 循环子群的元素个数（子群的阶）

拉格朗日定理（Lagrange's theorem）：设 G 为有限群， A 是  G的子群，则  A的元素个数（子群的阶）是G  的元素个数的因数。
 

上面定理阐述了子群的阶和群的阶的关系。
 

实例 1：椭圆曲线群  \\(y^2 \equiv x^3 - x + 3 \pmod {37}\)（包含点  \(\mathcal{O}\)）的阶经过计算可知为 \(N=42\) ，则其子群的阶  n只可能是 42 的因数，即 \(n=1,2,3,6,7,14,21,42\) 。在椭圆曲线取一点  \(P=(2,3)\)，计算可知  \(P \neq \mathcal{O}, 2P \neq \mathcal{O}, \cdots, 6P \neq \mathcal{O}, 7P = \mathcal{O}, 8P = P, \cdots\)，显然由点P  生成的循环子群的阶为7  ，它确实是42  的因数，这从侧面印证了拉格朗日定理。
 

实例 2：椭圆曲线群 \(y^2 \equiv x^3 - x + 1 \pmod {29}\) （包含点  \(\mathcal{O}\)）的阶经过计算可知为N=37  。 由于  37是素数，它只有两个因数，即 \(n=1, 37\) 。由拉格朗日定理知，子群的阶要么是 1 ，要么是 37 。当  时 \(n=1\)，子群仅包含 \(\mathcal{O}\) ，当 \(n=37\)时，子群就是椭圆曲线群本身。
 

注：设  为椭圆曲线群的阶，  为由  （Base Point）生成的循环子群的阶，我们称  为相应循环子群的余因子（cofactor）。
 

2.5. 离散对数问题

在椭圆曲线的循环子群中（设循环子群的阶为 n ），考虑式子\(Q=kP\)  ，对于给定的  k和 P 计算  相对容易Q（可以使用 Double-and-add 算法）；而如果已知点P  和Q  ，求k  则比较困难（当然我们并不能证明它很“难”，只是说目前没有找到有效的算法来计算上式中的k  ），这个问题称为椭圆曲线离散对数问题（Elliptic-Curve Discrete-Logarithm Problem, ECDLP）。
 

如果要暴力求解 k 的话，你需要设 \(k=1,2,\cdots,n\) ，对于每一个 k 直接使用加法计算公式验证其是否满足  \(Q = \underbrace{P + P + \cdots + P}_{k \text{ times}}\)，当 k 非常大时，暴力求解没有应用价值。
 

注：在 Digital Signature Algorithm（DSA）或者 Diffie-Hellman Key Exchange 算法中，我们也会说到“离散对数问题”，它指的是另一个问题：  k和y  满足 \(y \equiv g^k \pmod p\) ，其中g,p  是参数，已知y  时请问k  是多少？这个问题也很“难”（目前没有找到有效算法），这里不介绍。
 

3. Elliptic Curve Cryptography

3.1. Domain Parameters

使用基于椭圆曲线的密码学算法时，各个参与方首先需要约定好椭圆曲线的各个参数，它们被称为 Domain Parameters。
 

下面是 ECC 的 Domain Parameters：
 

• The prime  that specifies the size of the finite field.（注：  一般取很大的素数）
• The coefficients  and  of the elliptic curve equation. 到此，我们可以确定椭圆曲线群  了，参见节 2.2
• The base point (generator)  that generates our subgroup. 有了 Generator 后，我们可以确定  上的一个循环子群了，参见节 2.4
• The order  of the subgroup.  就是上一步得到的循环子群的元素个数
• The cofactor 
  $h=N/n$

  of the subgroup. 这里 
  $N=\mathrm{\#}E({\mathbb{F}}_p)$

  ，即 
  $N$

  是椭圆曲线群 
  $E({\mathbb{F}}_p)$

  所包含的所有点的个数，由拉格朗日定理（参见节 2.4.2）可知， 
  $h$

  一定是一个整数。显然，当 
  $h=1$

  时，由 
  $G$

  确定的椭圆曲线的所有点就是椭圆曲线群 
  $E({\mathbb{F}}_p)$

  本身，比如曲线 Secp256k1 的 
  $h$

  就是 1。曲线 Curve25519 的 cofactor 
  $h=8$

  ，所以它的 Generator 得到的循环子群的元素个数是椭圆曲线群 
  $E({\mathbb{F}}_p)$

  元素个数的 
  $1/8$

  。需要说明的是，当 
  $h>1$

  时，有一些安全问题需要注意：比如可能遭受 Small-Subgroup Attack，还可能存在 Non-injective behavior/Covert channels/Implementation-defined behavior/Nontrivial modifications 等问题，具体可参考：Decaf: Eliminating cofactors through point compression, 1.1 Pitfalls of a cofactor。区块链 Monero 上出现过由于 
  $Cofactor>1$

  而引起的安全漏洞，参考：Disclosure of a Major Bug in CryptoNote Based Currencies
   

一般使用 \((p, a, b, G, n, h)\)  表示 ECC 的 Domain Parameters。需要说明的是： 当  \(p,a,b,G\)确定后，  n和h  也就确定了，也就是说  n,h是由  \(p,a,b,G\) 计算出来的参数。
 

3.1.1. Random Curves (seed )

前面说过，椭圆曲线离散对数问题的困难的。这不完全正确，如当满足条件 \(p=hn\) 时的所有椭圆曲线都比较容易破解。
 

为了减少潜在的风险，我们可以增加一个随机种子 S ，用它来产生参数 a,b ，或者 G ，或者这两者。这样，椭圆曲线变得不可预测。
 

3.1.2. 选择合适的椭圆曲线

关于选择椭圆曲线有很多不同的“标准”，如：
 

• ANSI X9.62 (1999).
• IEEE P1363 (2000).
• SEC 2 (2000).
• NIST FIPS 186-2 (2000).
• ANSI X9.63 (2001).
• Brainpool (2005).
• NSA Suite B (2005).
• ANSSI FRP256V1 (2011).
   

如何选择一个“安全的”？可参考：SafeCurves: choosing safe curves for elliptic-curve cryptography （注：Bitcoin 使用的 secp256k1 ，在该网页中被标记为 Unsafe）。
 

3.1.3. Secp256k1

Bitcoin 使用的椭圆曲线是 secp256k1 ，它的参数如下：

$$\begin{aligned} p &= \texttt{0xffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f} \\ a &= \texttt{0} \\ b &= \texttt{7} \\ x_G &= \texttt{0x79be667e f9dcbbac 55a06295 ce870b07 029bfcdb 2dce28d9 59f2815b 16f81798} \\ y_G &= \texttt{0x483ada77 26a3c465 5da4fbfc 0e1108a8 fd17b448 a6855419 9c47d08f fb10d4b8} \\ n &= \texttt{0xffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141} \\ h &= \texttt{1} \\ \end{aligned} $$

3.1.4. Secp256k1 VS. Secp256r1 (NIST P-256)

美国国家安全局建议使用的椭圆曲线是 secp256r1（也被称为 NIST P-256），secp256r1 使用的参数是：
 

  p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff
                  a = 0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc
                  b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b
                x_G = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296
                y_G = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5
                  n = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551
                  h = 0x1
                

曲线 secp256k1 和 secp256r1 的名称只有一字之差，k 和 r 的不同。其中 k 表示 Koblitz（他是 ECC 发明人）；而 r 表示随机，即参数是随机选取的，但美国国家安全局并没有公布随机数的挑选规则，所以外界一直存在疑虑，怀疑 NSA 可能对随机数生成器动过手脚，让破解难度大幅降低。
 

注 1：secp256r1 曲线还有其它的别名：prime256v1 或者 nist256p1 或者 NIST P-256，参考：https://www.ietf.org/rfc/rfc4492.html#appendix-A
注 2：在区块链领域，Secp256k1 使用更广泛；不过在区块链以外的其它领域，Secp256r1 使用更广泛，比如 Android/iOS 的硬件安全密钥都支持 Secp256r1，而不支持 Secp256k1。
 

3.2. Elliptic Curve Diffie-Hellman (ECDH)

下面介绍使用椭圆曲线进行密钥交换（Key Exchange）的过程，它是 Diffie-Hellman algorithm 算法的变种，一般称为 Elliptic curve Diffie-Hellman (ECDH)。

Alice 和 Bob 想进行通信，为了加密（基于效率考虑往往会采用对称密钥算法，如 AES 等）通信的数据，他们需要约定同一个密钥（称为“Shared Secret”）。

使用 ECDH 算法约定“Shared Secret”的过程（和 Diffie-Hellman 密钥交换算法基本类似）如下。

第一步，选择一个椭圆曲线（即确定 Domain parameters），你可以从 Standards for Efficient Cryptography, SEC 2: Recommended Elliptic Curve Domain Parameters 中选择一个推荐的参数。

第二步，为 Alice 和 Bob 分别生成 private key/public key。比如，Alice 生成 private key/public key 的过程如下：
1、从\(\{1, 2, \cdots, n - 1\}\)  （  n在 Domain parameters 中指定的循环子群的阶）中随机选择一个数 \(d_A\) 作为 private key。
2、计算  \(Q_A=d_A G\)（  是 Domain parameters 中的 Base Point），\(Q_A\)  就是 public key。（注：这就是由私钥生成公钥的过程，直接按多次加法求解比较慢，可采用 Double-and-add 算法进行优化。这里有一个使用 Double-and-add 算法计算公钥的例子：https://bitcoin.stackexchange.com/questions/25024/how-do-you-get-a-bitc…）
类似的过程，Bob 生成一个 private key/public key，分别记为 \(d_B, Q_B\)  ，有  \(Q_B=d_B G\)。

第三步，Alice 和 Bob 分别把自己的公钥传送给对方，传递过程被别人偷看也没关系，由公钥无法容易地计算出私钥。

第四步， Alice 用自己的私钥和 Bob 的公钥计算 \( ，同Secret_1=d_A Q_B\)样地，Bob 用自己的私钥和 Alice 的公钥计算 \(Secret_2=d_B Q_A\) ，由于  \(Secret_1 = Secret_2\)（因为  \(d_A Q_B = d_A (d_B G) = d_B (d_A G) = d_B Q_A\)），所以它可作为“Shared Secret”。
 

3.2.1. Ephemeral ECDH (ECDHE)

如果通信双方不使用固定的 private key/public key，而是在建立连接时才动态生成各自的 private key/public key（注：这次通信结束，下次连接时重新生成各自的 private key/public key），这称为 Ephemeral ECDH (ECDHE)。
 

3.3. 公钥表达形式（Uncompressed and Compressed）

在椭圆曲线中，私钥 \(d \in \{1, 2, \cdots, n - 1\}\)  是整数；而公钥 \(Q =d G\) 则是椭圆曲线上的一个“点”，它有  两个坐标，每个坐标都是整数。下面是 secp256k1 曲线上公钥的一个例子：

$$\begin{aligned}
x_Q &= \texttt{0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352} \\
y_Q &= \texttt{0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6} \\
\end{aligned}$$

我们容易验证这个公钥确实是 secp256k1 曲线上的一个点：
 

Python 3.6.8 (default, Oct  7 2019, 12:59:55)
            [GCC 8.3.0] on linux
            Type "help", "copyright", "credits" or "license" for more information.
            >>> p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
            >>> x = 0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352
            >>> y = 0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6
            >>> y**2 % p - (x**3 + 7) % p
            0
            

一般地，我们往往用“一个数”来表达椭圆曲线中的公钥，如何用一个数来表达两个坐标呢？有两种方案：“Uncompressed format”和“Compressed format”（Compressed format 有 ansiX962_compressed_prime 和 ansiX962_compressed_char2 标准，这里不介绍它们）。

下面介绍一下“Uncompressed format”，它的规则很简单，把 
$x_Q$

和 
$y_Q$

直接连接在一起，再在前面加个 0x04 前缀即可。例如有：

$$\begin{array}{rl}{x}_Q& =\mathtt{\text{0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352}}\\ y_Q& =\mathtt{\text{0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6}}\end{array}$$

$$\begin{aligned}
x_Q &= \texttt{0x50863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B2352} \\
y_Q &= \texttt{0x2CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6} \\
\end{aligned}$$

则公钥（十六进制）可表示为：
 

Q = 0450863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B23522CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6
            

参考：https://stackoverflow.com/questions/6665353/is-there-a-standardized-fixed-length-encoding-for-ec-public-keys
 

3.4. Elliptic Curve Digital Signature Algorithm (ECDSA)

recid = R.y & 1;                             // Where (R.x, R.y) = k * G;

if (s > curve.n / 2) recid = recid ^ 1;      // i.e. if (s > curve.n - s) recid = recid ^ 1;
                

3.5. ECDSA 的 Python 实现

#!/usr/bin/env python3
                # -*- coding: utf-8 -*-
                # 代码摘自：https://github.com/andreacorbellini/ecc/blob/master/scripts/ecdsa.py
                import collections
                import hashlib
                import random
                EllipticCurve = collections.namedtuple('EllipticCurve', 'name p a b g n h')
                curve = EllipticCurve(
                    'secp256k1',
                    # Field characteristic.
                    p=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f,
                    # Curve coefficients.
                    a=0,
                    b=7,
                    # Base point.
                    g=(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
                       0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8),
                    # Subgroup order.
                    n=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141,
                    # Subgroup cofactor.
                    h=1,
                )
                # Modular arithmetic ##########################################################
                def inverse_mod(k, p):
                    """Returns the inverse of k modulo p.
                    This function returns the only integer x such that (x * k) % p == 1.
                    k must be non-zero and p must be a prime.
                    """
                    if k == 0:
                        raise ZeroDivisionError('division by zero')
                    if k < 0:
                        # k ** -1 = p - (-k) ** -1  (mod p)
                        return p - inverse_mod(-k, p)
                    # Extended Euclidean algorithm.
                    s, old_s = 0, 1
                    t, old_t = 1, 0
                    r, old_r = p, k
                    while r != 0:
                        quotient = old_r // r
                        old_r, r = r, old_r - quotient * r
                        old_s, s = s, old_s - quotient * s
                        old_t, t = t, old_t - quotient * t
                    gcd, x, y = old_r, old_s, old_t
                    assert gcd == 1
                    assert (k * x) % p == 1
                    return x % p
                # Functions that work on curve points #########################################
                def is_on_curve(point):
                    """Returns True if the given point lies on the elliptic curve."""
                    if point is None:
                        # None represents the point at infinity.
                        return True
                    x, y = point
                    return (y * y - x * x * x - curve.a * x - curve.b) % curve.p == 0
                def point_neg(point):
                    """Returns -point."""
                    assert is_on_curve(point)
                    if point is None:
                        # -0 = 0
                        return None
                    x, y = point
                    result = (x, -y % curve.p)
                    assert is_on_curve(result)
                    return result
                def point_add(point1, point2):
                    """Returns the result of point1 + point2 according to the group law."""
                    assert is_on_curve(point1)
                    assert is_on_curve(point2)
                    if point1 is None:
                        # 0 + point2 = point2
                        return point2
                    if point2 is None:
                        # point1 + 0 = point1
                        return point1
                    x1, y1 = point1
                    x2, y2 = point2
                    if x1 == x2 and y1 != y2:
                        # point1 + (-point1) = 0
                        return None
                    if x1 == x2:
                        # This is the case point1 == point2.
                        m = (3 * x1 * x1 + curve.a) * inverse_mod(2 * y1, curve.p)
                    else:
                        # This is the case point1 != point2.
                        m = (y1 - y2) * inverse_mod(x1 - x2, curve.p)
                    x3 = m * m - x1 - x2
                    y3 = y1 + m * (x3 - x1)
                    result = (x3 % curve.p,
                              -y3 % curve.p)
                    assert is_on_curve(result)
                    return result
                def scalar_mult(k, point):
                    """Returns k * point computed using the double and point_add algorithm."""
                    assert is_on_curve(point)
                    if k % curve.n == 0 or point is None:
                        return None
                    if k < 0:
                        # k * point = -k * (-point)
                        return scalar_mult(-k, point_neg(point))
                    result = None
                    addend = point
                    while k:
                        if k & 1:
                            # Add.
                            result = point_add(result, addend)
                        # Double.
                        addend = point_add(addend, addend)
                        k >>= 1
                    assert is_on_curve(result)
                    return result
                # Keypair generation and ECDSA ################################################
                def make_keypair():
                    """Generates a random private-public key pair."""
                    private_key = random.randrange(1, curve.n)
                    public_key = scalar_mult(private_key, curve.g)
                    return private_key, public_key
                def hash_message(message):
                    """Returns the truncated SHA512 hash of the message."""
                    message_hash = hashlib.sha512(message).digest()
                    e = int.from_bytes(message_hash, 'big')
                    # FIPS 180 says that when a hash needs to be truncated, the rightmost bits
                    # should be discarded.
                    z = e >> (e.bit_length() - curve.n.bit_length())
                    assert z.bit_length() <= curve.n.bit_length()
                    return z
                def sign_message(private_key, message):
                    z = hash_message(message)
                    r = 0
                    s = 0
                    while not r or not s:
                        k = random.randrange(1, curve.n)
                        x, y = scalar_mult(k, curve.g)
                        r = x % curve.n
                        s = ((z + r * private_key) * inverse_mod(k, curve.n)) % curve.n
                    return (r, s)
                def verify_signature(public_key, message, signature):
                    z = hash_message(message)
                    r, s = signature
                    w = inverse_mod(s, curve.n)
                    u1 = (z * w) % curve.n
                    u2 = (r * w) % curve.n
                    x, y = point_add(scalar_mult(u1, curve.g),
                                     scalar_mult(u2, public_key))
                    if (r % curve.n) == (x % curve.n):
                        return 'signature matches'
                    else:
                        return 'invalid signature'
                print('Curve:', curve.name)
                private, public = make_keypair()
                print("Private key:", hex(private))
                print("Public key: (0x{:x}, 0x{:x})".format(*public))
                msg = b'Hello!'
                signature = sign_message(private, msg)
                print()
                print('Message:', msg)
                print('Signature: (0x{:x}, 0x{:x})'.format(*signature))
                print('Verification:', verify_signature(public, msg, signature)) # 验证通过
                msg = b'Hi there!'                # 使用不同的消息，会验证失败
                print()
                print('Message:', msg)
                print('Verification:', verify_signature(public, msg, signature))
                private, public = make_keypair()  # 使用不同的公钥，会验证失败
                msg = b'Hello!'
                print()
                print('Message:', msg)
                print("Public key: (0x{:x}, 0x{:x})".format(*public))
                print('Verification:', verify_signature(public, msg, signature))
                

3.6. Elliptic Curve 加解密方案

# 下面是 ECIES 加密数据的过程
                    # Input:
                    #   pub_key 是接收者的公钥
                    #   msg 是等待加密的消息
                    # Output:
                    #   ephemeral_pub_key 是临时公钥，接收者用它进行 ECDH 可以得到 AES 对称加密所用的密钥（具体来说就是接收者私钥乘以这个临时公钥）
                    #   iv 是 AES 算法的初始化变量
                    #   tag 是消息认证码
                    #   ciphertext 是密文
                    encrypt(pub_key, msg):
                      ephemeral_pri_key, ephemeral_pub_key = gen_key();
                      shared_secret = ephemeral_pri_key * pub_key;  // 这是 ECDH 计算临时 shared_secret 的过程，ECIES 的 KA 过程
                      iv = gen_random();  // AES 算法需要的 iv 值
                      // 注意：在实现 ECIES 时一般不会直接把上面的 shared_secret 当作 AES 的密钥；
                      // 而是使用 X9.63 KDF 或者 HKDF https://en.wikipedia.org/wiki/HKDF 等 KDF 函数处理后，把结果当作 AES 密钥
                      // 不过，这个例子中省略了这个步骤
                      // aes gcm 本身是一种 AEAD 算法（这样不需要分别进行 ECIES 的 MAC/ENC 操作了），它的 tag 就是消息认证所需的 mac 值
                      ciphertext, tag = aes_gcm_encrypt(shared_secret, iv, msg);
                      return ephemeral_pub_key, iv, tag, ciphertext
                    # 下面是 ECIES 解密数据的过程
                    # Input:
                    #   pri_key 是接收者的私钥
                    #   ephemeral_pub_key/iv/tag/ciphertext 是加密过程的输出，这里作为解密过程的输入
                    # Output:
                    #   plaintext 是解密后的明文
                    decrypt(pri_key, ephemeral_pub_key, iv, tag, ciphertext):
                      shared_secret = pri_key * ephemeral_pub_key  // 这是 ECDH 计算临时 shared_secret 的过程
                      // 注意：在实现 ECIES 时一般不会直接把上面的 shared_secret 当作 AES 的密钥；
                      // 而是使用 X9.63 KDF 或者 HKDF https://en.wikipedia.org/wiki/HKDF 等 KDF 函数处理后，把结果当作 AES 密钥
                      // 不过，这个例子中省略了这个步骤
                      plaintext = aes_gcm_decrypt(shared_secret, iv, tag, ciphertext)
                      return plaintext
                    

3.7. 其它坐标系