secp256kFUN!  

这是一个中级Rust secp256k1椭圆曲线密码学库，针对娱乐进行了优化！这里的“娱乐”意味着

• 类型安全：使用其他API时通常必须处理的错误情况，通过Rust的类型系统在编译时就被排除了。
• 抽象化：该库公开了两个简单的抽象 点 和 标量，以便您可以干净地实现加密。
• 不可优化：在群上表达某种操作的最直接方式也是最有效的方式。
• 文档化：我们试图为每个函数制作工作示例并对其进行文档化。

娱乐并不意味着（目前还没有 — 请帮助！）

• 未经过充分审查：这里的实现尚未得到很多审查。
• 抵抗侧信道攻击：尚未对是否该库或其底层的算术（来自 k256）抵抗时间攻击等进行实证研究。《strong>没有尝试在释放内存时“归零”秘密。
• 性能：该库在总体上不如 libsecp256k1。

本库的目标是让研究人员能够实验想法，让他们在比特币上工作，并享受这个过程！像 rust-secp256k1 这样的 高级 库使得正确和高效地实现异构加密方案变得困难。而像 parity/libsecp256k1 这样的 低级 库虽然可行，但生成的代码往往容易出错且难以阅读。

使用

[dependencies]
secp256kfun = "0.10"

应该使用？

只要你的目标是制造有趣和娱乐性的东西，这个库就适用于生产。如果你想设计一些稳定的东西，很多人会依赖它，那么这个库可能是一个风险选择。以下是一些替代方案

1. rust-secp256k1 - Bitcoin 本身使用的 libsecp256k1 的 rust 绑定
2. k256 - 该库的算术默认基于此库。
3. ristretto - 如果你不需要使用 secp256k1

文档

docs.rs/secp256kfun

特性

以下是本库的显著特性。

零元素

secp256k1 点和标量都有一个概念上的 零 元素。不幸的是，在围绕比特币的东西中，零标量和零点在大多数情况下都是非法值。《secp256kfun》通过使用 标记类型 解决这些困难。点和标量在编译时用 Zero 或 NonZero 标记（默认为 NonZero）。因此，如果你用 NonZero 类型声明你的函数，传递一个 Zero 类型将会在编译时出错，如下所示

use secp256kfun::{marker::*, Scalar, Point,G,g};
// a randomly selected Scalar will never be zero (statistically unreachable)
let x = Scalar::random(&mut rand::thread_rng());
dbg!(&x); // Scalar<.., NonZero>
// Multiplying a NonZero scalar by G (which is also NonZero) results in a NonZero point
let X = g!(x * G);
dbg!(&X) // Point<..,NonZero>
let Y = g!(-x * G)
// An addition **can** lead to a zero so the result is marked Zero
let sum = g!(X + Y);
dbg!(&sum); // Point<.., Zero>
// Now let's say I naively decide to use this value as my public key...
let public_key = sum.normalize();
// BOOM! This is a compile time Error! 🎉
send_pubkey_to_bob(&public_key);

fn send_pubkey_to_bob(public_key: &Point) {
    unimplemented!()
}

这给了我们

error[E0308]: mismatched types
 --> src/lib.rs:77:20
   |
17 | send_pubkey_to_bob(&public_key);
     |                  ^^^^^^^^^^^ expected struct `secp256kfun::marker::NonZero`, found struct `secp256kfun::marker::Zero`

为了解决这个问题，库会强制你手动将值标记为 NonZero，然后处理它为零的情况。

match sum.normalize().non_zero() {
    Some(public_key) => send_pubkey_to_bob(&public_key), // it was actually NonZero
    None => .. // deal with the case it is Zero
}

变量时间还是常数时间？

注意：从 v0.7.0 版本开始，由于我们更改了算术后端到 k256，因此 Secret 和 Public 标记几乎不起作用，因为 k256 没有变量时间算法。然而，这种情况可能在未来的版本中有所改善。

use secp256kfun::{marker::*, Point, Scalar, g};

/// commit to a secret value x with publicly known A and B.
fn pedersen_commit(
    A: &Point<impl PointType>, // Accept any kind of Point
    B: &Point<impl PointType>,
    r: &Scalar<impl Secrecy>, // Accept a Secret or Public Scalar
    x: &Scalar<impl Secrecy, Zero>, // Allow commitment to Zero
) -> Point {
    // Make the commitment
    g!(r * A +  x * B)
        .normalize()
        // If the result is zero we could easily compute the discrete
        // logarithm of B with respect to A. Since this is meant to be unknown
        // this is computionally unreachable.
        .non_zero().expect("computationally unreachable")
}

// public setup
let A = secp256kfun::G; // use the standard basepoint for one of the points
let B = Point::random(&mut rand::thread_rng());

// Alice commits to her secret value x with randomness r
let r = Scalar::random(&mut rand::thread_rng());
let x = Scalar::<Secret, Zero>::from(42);
let commitment = pedersen_commit(A, &B, &r, &x);

// Imagine Later on, Bob receives the public opening (r,x) for commitment. He
// doesn't care about leaking these values via execution time so he marks them
// as public.
let r = r.public();
let x = x.public();

// Now he'll compute the commitment in faster variable time and check it
// against the original
assert_eq!(commitment, pedersen_commit(A, &B, &r, &x));