atacul SETUP de cleptografie în ecdsa

Încerc să implementez atacul SETUP de cleptografie al ecdsa cu python. Doar un simplu script pentru a verifica algoritmul. Cu toate acestea, nu pot obține rezultatul corect, așa cum spunea hârtie. Unde este problema? Poate cineva să ajute?

din ecpy.curves import Curve, Point
import hashlib
import gmpy

cv = Curve.get_curve('secp256k1')
G = Punct(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
          0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
          CV)


semnul def (k, d, hash):
    R = k * G
    r1 = R.x % p
    k_ = int(gmpy.invert(k, p))
    s1 = (k_ * (hash + d * r1)) % p
    întoarcere (r1, s1)


(a, b, h, e) = (11, 22, 33, 44)
hash1 = 987654321
hash2 = 77777
d = 123
v = 456
p = 2 ** 256 - 2 ** 32 - 977
j = 0
u = 1

pKey1 = d * G
V = v * G

k1 = 8888
(r1, s1) = semn(k1, d, hash1)
print("(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, „mare”)
(r2, s2) = semn(k2, v, hash2)
print("(r2, s2): ", (r2, s2))

R1 = Punct(x=r1, y=(cv.y_recover(x=r1)), curba=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')
imprimare (K2 * G.x)

Nu face nimic. Tocmai l-am implementat în rust-lang. Și acesta este codul meu. Pur și simplu implementat. Am nevoie de muncă suplimentară și nu o lua în serios

utilizați curv::arithmetic::Converter;
folosește curv::elliptic::curves::{ Punct, Scalar, Secp256k1};
folosește curv::BigInt;
utilizați openssl::hash::{Hasher, MessageDigest};

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

    // Cheia privată a atacatorului
    fie v = Scalar::<Secp256k1>::random();
    // Cheia publică a atacatorului
    fie V = Point::generator() * v.clone();

    // Cheia privată a utilizatorului
    fie D = Scalar::<Secp256k1>::random();
    println!("{:?}", D.to_bigint());
    // Cheia publică a utilizatorului
    fie Q = Point::generator() * D.clone();

    let message1 = String::from("Primul mesaj de semnat");
    let message2 = String::from("Al doilea mesaj de semnat");

    hasher.update(message1.as_bytes()).expect(„Eroare hash”);
    fie m1: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    fie k1 = Scalar::<Secp256k1>::random();
    let signaturePoint1 = Point::generator() * k1.clone();
    lasă r1 = Scalar::from_bigint(&(signaturePoint1.x_coord().unwrap()));
    fie 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(„Eroare hash”);
    fie m2: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

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

    fie Z = a.clone() * k1.clone() * Point::generator()
        + b.clone() * k1.clone() * V.clone()
        + j.clone() * h.clone() * Point::generator()
        + u.clone() * e.clone() * V.clone();
    fie zX = Z.x_coord().unwrap();
    hasher.update(&zX.to_bytes()).expect(„Eroare hash”);
    lasa hash =
        Scalar::<Secp256k1>::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));
    fie k2 = hash;
    let signaturePoint2 = k2.clone() * Point::generator();
    let r2 = Scalar::<Secp256k1>::from_bigint(&signaturePoint2.x_coord().unwrap());
    fie s2 = k2.clone().invert().unwrap() * (m2.clone() + r2.clone() * D.clone());
    println!("r2: {:?}", r2.to_bigint());
    println!("s2: {:?}", s2.to_bigint());
    let recovered = ExtractUsersPrivateKey(mesaj1, mesaj2, a, b, h, e, r1, s1, r2, s2, v, V, Q);
    println!("{:?}", recovered.to_bigint());
}

fn ExtractUsersPrivateKey(
    mesaj 1: șir,
    mesaj 2: șir,
    a: Scalar<Secp256k1>,
    b: scalar<Secp256k1>,
    h: scalar<Secp256k1>,
    e: Scalar<Secp256k1>,
    r1: scalar<Secp256k1>,
    s1: scalar<Secp256k1>,
    r2: scalar<Secp256k1>,
    s2: Scalar<Secp256k1>,
    atacatorPrivate: Scalar<Secp256k1>,
    atacatorPublic: Punct<Secp256k1>,
    userPublic: Punct<Secp256k1>,
) -> Scalar<Secp256k1> {
    let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap();

    hasher.update(message1.as_bytes()).expect(„Eroare hash”);
    fie m1: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    hasher.update(message2.as_bytes()).expect(„Eroare hash”);
    fie m2: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));
    fie w = s1.invert().unwrap();
    fie u1 = m1.clone() * w.clone();
    fie u2 = r1.clone() * w.clone();
    let verifyPoint = u1.clone() * Point::generator() + u2.clone() * userPublic.clone();

    fie Z1 = verifyPoint.clone() * a.clone()
        + (verifyPoint.clone() * b.clone() * attackerPrivate.clone());

    let u: Scalar<Secp256k1> = Scalar::from(0 as u16);
    fie j: Scalar<Secp256k1> = Scalar::from(0 as u16);
    fie Z2 = Z1.clone()
        + j.clone() * h.clone() * Point::generator()
        + u.clone() * e.clone() * atacatorPublic.clone();
    let zX: Scalar<Secp256k1> = Scalar::from_bigint(&Z2.x_coord().unwrap());
    hasher.update(&zX.to_bigint().to_bytes()).expect(„Eroare hash”);
    lasă hash: Scalar<Secp256k1> =
        Scalar::from_bigint(&BigInt::from_bytes(hasher.finish().unwrap().as_ref()));
    let kCandiate = hash.clone();
    let verifyPointCandiate = kCandiate.clone() * Point::generator();
    let rCandiate = verifyPointCandiate.x_coord().unwrap();
    if rCandiate == r2.to_bigint() {
        return (s2.clone() * kCandiate.clone() - m2) * (r2.invert().unwrap());
    }
    Scalar::random()
}

Aceasta este biblioteca pe care o folosesc

[dependențe]
curv-kzen = "0,8"
openssl = "0,10"
openssl-sys = "0.9"