kleptography SETUP tấn công trong ecdsa

Tôi đang cố gắng thực hiện cuộc tấn công CÀI ĐẶT kleptography của ecdsa bằng python. Chỉ cần một tập lệnh đơn giản để xác minh thuật toán. Tuy nhiên tôi không thể có được đầu ra đúng như bài báo đã nói. Vấn đề ở đâu? Có ai giúp được không?

từ ecpy.curves nhập Đường cong, Điểm
nhập hashlib
nhập gmpy

cv = Curve.get_curve('secp256k1')
G = Điểm(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
          0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
          cv)


dấu def(k, d, hash):
    R = k * G
    r1 = R.x %p
    k_ = int(gmpy.invert(k, p))
    s1 = (k_ * (băm + d * r1)) % p
    trả lại (r1, s1)


(a, b, h, e) = (11, 22, 33, 44)
băm1 = 987654321
băm2 = 77777
d = 123
v = 456
p = 2** 256 - 2** 32 - 977
j = 0
bạn = 1

pKey1 = d * G
V = v * G

k1 = 8888
(r1, s1) = dấu (k1, d, hash1)
in("(r1, s1): ", (r1, s1))

z = a*k1*G + b*k1*V + h*j*G + e*u*V
k2 = hashlib.sha256(str(z).encode('ASCII')).digest()
k2 = int.from_bytes(k2, 'lớn')
(r2, s2) = dấu (k2, v, hash2)
in("(r2, s2): ", (r2, s2))

R1 = Điểm(x=r1, y=(cv.y_recover(x=r1)), đường cong=cv)
Z1 = a * R1 + b * v * R1
Z2 = Z1 + h * j * G + e * u * V
K2 = int.from_bytes(hashlib.sha256(str(Z2).encode('ASCII')).digest(), 'big')
in(K2 * G.x)

Đừng bận tâm. Chỉ cần thực hiện nó trong Rust-lang. Và đây là mã của tôi. Chỉ đơn giản là thực hiện. Cần làm thêm và đừng nghiêm túc

sử dụng curv::arithmetic::Converter;
sử dụng curv::elliptic::curves::{ Điểm, Vô hướng, Secp256k1};
sử dụng đường cong :: BigInt;
sử dụng openssl::hash::{Hasher, MessageDigest};

fn chính() {
    let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap();

    // Khóa riêng của kẻ tấn công
    let v = Scalar::<Secp256k1>::random();
    // Khóa công khai của kẻ tấn công
    let V = Point::generator() * v.clone();

    // Khóa riêng của người dùng
    let D = Scalar::<Secp256k1>::random();
    println!("{:?}", D.to_bigint());
    // Khóa công khai của người dùng
    let Q = Point::generator() * D.clone();

    let message1 = String::from("Tin nhắn đầu tiên cần ký");
    let message2 = String::from("Tin nhắn thứ hai cần ký");

    hasher.update(message1.as_bytes()).expect("Lỗi băm");
    để m1: Vô hướng<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    let k1 = Scalar::<Secp256k1>::random();
    để signaturePoint1 = Point::generator() * k1.clone();
    let r1 = Scalar::from_bigint(&(signaturePoint1.x_coord().unwrap()));
    hãy để s1 = k1.clone().invert().unwrap() * (m1.clone() + D.clone() * r1.clone());

    println!("r1: {:?}", r1.to_bigint());
    println!("s1: {:?}", s1.to_bigint());

    hasher.update(message2.as_bytes()).expect("Lỗi băm");
    để m2: Vô hướng<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    để a: Scalar<Secp256k1> = Scalar::random();
    let b: Scalar<Secp256k1> = Scalar::random();
    let h: Scalar<Secp256k1> = Scalar::random();
    let e: Scalar<Secp256k1> = Scalar::random();
    cho u: Scalar<Secp256k1> = Scalar::from(0 as u16);
    let j: Scalar<Secp256k1> = Scalar::from(0 as u16);

    để Z = a.clone() * k1.clone() * Điểm::generator()
        + b.clone() * k1.clone() * V.clone()
        + j.clone() * h.clone() * Điểm::generator()
        + u.clone() * e.clone() * V.clone();
    hãy để zX = Z.x_coord().unwrap();
    hasher.update(&zX.to_bytes()).expect("Lỗi băm");
    hãy băm =
        Vô hướng::<Secp256k1>::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));
    đặt k2 = hàm băm;
    để signaturePoint2 = k2.clone() * Point::generator();
    let r2 = Scalar::<Secp256k1>::from_bigint(&signaturePoint2.x_coord().unwrap());
    hãy để s2 = k2.clone().invert().unwrap() * (m2.clone() + r2.clone() * D.clone());
    println!("r2: {:?}", r2.to_bigint());
    println!("s2: {:?}", s2.to_bigint());
    để phục hồi = ExtractUsersPrivateKey(message1, message2, a, b, h, e, r1, s1, r2, s2, v, V, Q);
    println!("{:?}", đã phục hồi.to_bigint());
}

fn ExtractUsersPrivateKey(
    tin nhắn1: Chuỗi,
    message2: Chuỗi,
    a: Vô hướng<Secp256k1>,
    b: Vô hướng<Secp256k1>,
    h: Vô hướng<Secp256k1>,
    e: Vô hướng<Secp256k1>,
    r1: Vô hướng<Secp256k1>,
    s1: Vô hướng<Secp256k1>,
    r2: Vô hướng<Secp256k1>,
    s2: Vô hướng<Secp256k1>,
    kẻ tấn côngPrivate: Scalar<Secp256k1>,
    kẻ tấn côngPublic: Điểm<Secp256k1>,
    userPublic: Điểm<Secp256k1>,
) -> Vô hướng<Secp256k1> {
    let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap();

    hasher.update(message1.as_bytes()).expect("Lỗi băm");
    để m1: Vô hướng<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    hasher.update(message2.as_bytes()).expect("Lỗi băm");
    để m2: Vô hướng<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));
    hãy để w = s1.invert().unwrap();
    hãy để u1 = m1.clone() * w.clone();
    hãy để u2 = r1.clone() * w.clone();
    hãy verifyPoint = u1.clone() * Point::generator() + u2.clone() * userPublic.clone();

    hãy để Z1 = verifyPoint.clone() * a.clone()
        + (verifyPoint.clone() * b.clone() * kẻ tấn côngPrivate.clone());

    cho u: Scalar<Secp256k1> = Scalar::from(0 as u16);
    let j: Scalar<Secp256k1> = Scalar::from(0 as u16);
    đặt Z2 = Z1.clone()
        + j.clone() * h.clone() * Điểm::generator()
        + u.clone() * e.clone() * kẻ tấn côngPublic.clone();
    let zX: Scalar<Secp256k1> = Scalar::from_bigint(&Z2.x_coord().unwrap());
    hasher.update(&zX.to_bigint().to_bytes()).expect("Lỗi băm");
    hãy băm: Scalar<Secp256k1> =
        Scalar::from_bigint(&BigInt::from_bytes(hasher.finish().unwrap().as_ref()));
    hãy để kCandiate = hash.clone();
    hãy verifyPointCandiate = kCandiate.clone() * Point::generator();
    hãy để rCandiate = verifyPointCandiate.x_coord().unwrap();
    nếu rCandiate == r2.to_bigint() {
        return (s2.clone() * kCandiate.clone() - m2) * (r2.invert().unwrap());
    }
    Vô hướng::ngẫu nhiên()
}

Đây là thư viện tôi đang sử dụng

[phụ thuộc]
cong-kzen = "0,8"
openssl = "0,10"
openssl-sys = "0,9"