атака клептографии SETUP в ecdsa

Я пытаюсь реализовать клептографическую атаку SETUP на ecdsa с помощью python. Просто скрипт для проверки алгоритма. Однако я не могу получить правильный результат, как сказано в документе. В чем проблема? Кто-нибудь может помочь?

из ecpy.curves импортировать кривую, точку
импортировать хеш-библиотеку
импортировать gmpy

cv = Curve.get_curve('secp256k1')
G = точка (0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,
          0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8,
          резюме)


знак защиты (k, d, хэш):
    р = к * г
    r1 = R.x % p
    k_ = int(gmpy.invert(k, p))
    s1 = (k_ * (хэш + d * r1)) % p
    возврат (r1, s1)


(а, б, з, д) = (11, 22, 33, 44)
хеш1 = 987654321
хеш2 = 77777
д = 123
v = 456
р = 2 ** 256 - 2 ** 32 - 977
j = 0
ты = 1

pKey1 = d * G
V = v * G

к1 = 8888
(r1, s1) = знак (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, 'большой')
(r2, s2) = знак (k2, v, хэш2)
печать("(r2, s2): ", (r2, s2))

R1 = точка (x = r1, y = (cv.y_recover (x = r1)), кривая = cv)
Z1 = а * R1 + b * v * R1
Z2 = Z1 + h * j * G + e * u * V
K2 = int.from_bytes(hashlib.sha256(str(Z2).encode('ASCII')).digest(), 'большой')
печать (K2 * G.x)

Неважно. Только что реализовал на rust-lang. И это мой код. Просто реализовано. Нужна дополнительная работа и не воспринимайте это всерьез

используйте curv::arithmetic::Converter;
используйте curv::elliptic::curves::{ Point, Scalar, Secp256k1};
используйте кривую:: BigInt;
используйте openssl::hash::{Hasher, MessageDigest};

главная функция () {
    let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap();

    // закрытый ключ злоумышленника
    пусть v = Scalar::<Secp256k1>::random();
    // Открытый ключ злоумышленника
    пусть V = Point::generator() * v.clone();

    // закрытый ключ пользователя
    пусть D = Scalar::<Secp256k1>::random();
    println!("{:?}", D.to_bigint());
    // Открытый ключ пользователя
    пусть Q = Point::generator() * D.clone();

    let message1 = String::from("Первое сообщение для подписи");
    let message2 = String::from("Второе сообщение для подписи");

    hasher.update(message1.as_bytes()).expect("Ошибка хеширования");
    пусть m1: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    пусть k1 ​​= Scalar::<Secp256k1>::random();
    пусть подписьPoint1 = Point::generator() * k1.clone();
    пусть r1 = Scalar::from_bigint(&(signaturePoint1.x_coord().unwrap()));
    пусть 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("Ошибка хеширования");
    пусть m2: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    пусть a: Scalar<Secp256k1> = Scalar::random();
    пусть b: Scalar<Secp256k1> = Scalar::random();
    пусть h: Scalar<Secp256k1> = Scalar::random();
    пусть e: Scalar<Secp256k1> = Scalar::random();
    пусть u: Scalar<Secp256k1> = Scalar::from(0 as u16);
    пусть j: Scalar<Secp256k1> = Scalar::from(0 as u16);

    пусть 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();
    пусть zX = Z.x_coord().unwrap();
    hasher.update(&zX.to_bytes()).expect("Ошибка хеширования");
    пусть хэш =
        Scalar::<Secp256k1>::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));
    пусть k2 = хэш;
    пусть подписьPoint2 = k2.clone() * Point::generator();
    пусть r2 = Scalar::<Secp256k1>::from_bigint(&signaturePoint2.x_coord().unwrap());
    пусть s2 = k2.clone().invert().unwrap() * (m2.clone() + r2.clone() * D.clone());
    println!("r2: {:?}", r2.to_bigint());
    println!("s2: {:?}", s2.to_bigint());
    пусть восстановлено = ExtractUsersPrivateKey (сообщение1, сообщение2, a, b, h, e, r1, s1, r2, s2, v, V, Q);
    println!("{:?}", восстановлено.to_bigint());
}

fn ИзвлечьUsersPrivateKey(
    сообщение1: строка,
    сообщение2: строка,
    а: скаляр <Secp256k1>,
    б: Скаляр <Secp256k1>,
    h: скаляр <Secp256k1>,
    e: Скаляр <Secp256k1>,
    r1: скаляр <Secp256k1>,
    s1: скаляр <Secp256k1>,
    r2: скаляр <Secp256k1>,
    s2: скаляр <Secp256k1>,
    AttackerPrivate: Scalar<Secp256k1>,
    AttackerPublic: Point<Secp256k1>,
    userPublic: Point<Secp256k1>,
) -> Скаляр <Secp256k1> {
    let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap();

    hasher.update(message1.as_bytes()).expect("Ошибка хеширования");
    пусть m1: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));

    hasher.update(message2.as_bytes()).expect("Ошибка хеширования");
    пусть m2: Scalar<Secp256k1> =
        Scalar::from_bigint(&(BigInt::from_bytes(hasher.finish().unwrap().as_ref())));
    пусть w = s1.invert().unwrap();
    пусть u1 = m1.clone() * w.clone();
    пусть u2 = r1.clone() * w.clone();
    пусть verifyPoint = u1.clone() * Point::generator() + u2.clone() * userPublic.clone();

    пусть Z1 = verifyPoint.clone () * a.clone ()
        + (verifyPoint.clone() * b.clone() * AttackerPrivate.clone());

    пусть u: Scalar<Secp256k1> = Scalar::from(0 as u16);
    пусть j: Scalar<Secp256k1> = Scalar::from(0 as u16);
    пусть Z2 = Z1.clone()
        + j.clone() * h.clone() * Point::generator()
        + u.clone() * e.clone() * AttackerPublic.clone();
    пусть zX: Scalar<Secp256k1> = Scalar::from_bigint(&Z2.x_coord().unwrap());
    hasher.update(&zX.to_bigint().to_bytes()).expect("Ошибка хеширования");
    пусть хэш: Scalar<Secp256k1> =
        Scalar::from_bigint(&BigInt::from_bytes(hasher.finish().unwrap().as_ref()));
    пусть kCandiate = hash.clone();
    пусть verifyPointCandiate = kCandiate.clone() * Point::generator();
    let rCandiate = verifyPointCandiate.x_coord().unwrap();
    если rCandiate == r2.to_bigint() {
        return (s2.clone() * kCandiate.clone() - m2) * (r2.invert().unwrap());
    }
    Скаляр::случайный()
}

Это библиотека, которую я использую

[зависимости]
кривая-кзен = "0,8"
опенсл = "0,10"
openssl-sys = "0,9"