from hashlib import sha1
from unittest import TestCase

from pyecsca.ec.curves import get_curve
from pyecsca.ec.mult import LTRMultiplier
from pyecsca.ec.signature import *
from parameterized import parameterized

class SignatureTests(TestCase):

    def setUp(self):
        self.secp128r1 = get_curve("secp128r1", "projective")
        self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
        self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
        self.mult = LTRMultiplier(self.add, self.dbl)
        self.msg = 0xcafebabe.to_bytes(4, byteorder="big")
        self.priv = 0xdeadbeef
        self.mult.init(self.secp128r1, self.secp128r1.generator)
        self.pub = self.mult.multiply(self.priv)

    @parameterized.expand([
        ("SHA1", ECDSA_SHA1),
        ("SHA224", ECDSA_SHA224),
        ("SHA256", ECDSA_SHA256),
        ("SHA384", ECDSA_SHA384),
        ("SHA512", ECDSA_SHA512)
    ])
    def test_all(self, name, algo):
        signer = algo(self.mult, self.secp128r1, privkey=self.priv)
        assert signer.can_sign
        sig = signer.sign_data(self.msg)
        verifier = algo(self.mult, self.secp128r1, add=self.add, pubkey=self.pub)
        assert verifier.can_verify
        assert verifier.verify_data(sig, self.msg)
        # none = ECDSA_NONE(self.mult, add=self.add, pubkey=self.pub, privkey=self.priv)
        # digest = sha1(self.msg).digest()
        # sig = none.sign_hash(digest)
        # assert none.verify_hash(sig, digest)
        # sig = none.sign_data(digest)
        # assert none.verify_data(sig, digest)

    def test_cannot(self):
        ok = ECDSA_NONE(self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv)
        data = b"aaaa"
        sig = ok.sign_data(data)

        no_priv = ECDSA_NONE(self.mult, self.secp128r1, pubkey=self.pub)
        with self.assertRaises(RuntimeError):
            no_priv.sign_data(data)
        with self.assertRaises(RuntimeError):
            no_priv.sign_hash(data)
        no_pubadd = ECDSA_NONE(self.mult, self.secp128r1, privkey=self.priv)
        with self.assertRaises(RuntimeError):
            no_pubadd.verify_data(sig, data)
        with self.assertRaises(RuntimeError):
            no_pubadd.verify_hash(sig, data)

        with self.assertRaises(ValueError):
            Signature(self.mult, self.secp128r1)

    @parameterized.expand([
        ("SHA1", ECDSA_SHA1),
        ("SHA224", ECDSA_SHA224),
        ("SHA256", ECDSA_SHA256),
        ("SHA384", ECDSA_SHA384),
        ("SHA512", ECDSA_SHA512)
    ])
    def test_fixed_nonce(self, name, algo):
        signer = algo(self.mult, self.secp128r1, privkey=self.priv)
        sig_one = signer.sign_data(self.msg, nonce=0xabcdef)
        sig_other = signer.sign_data(self.msg, nonce=0xabcdef)
        verifier = algo(self.mult, self.secp128r1, add=self.add, pubkey=self.pub)
        assert verifier.verify_data(sig_one, self.msg)
        assert verifier.verify_data(sig_other, self.msg)
        self.assertEqual(sig_one, sig_other)

    def test_der(self):
        sig = SignatureResult(0xaaaaa, 0xbbbbb)
        self.assertEqual(sig, SignatureResult.from_DER(sig.to_DER()))