Rework client.

2 files changed, 104 insertions, 23 deletions

diff --git a/test/test_builder.py b/test/test_builder.py
index 52de066..a16f714 100644
--- a/test/test_builder.py
+++ b/test/test_builder.py
@@ -2,13 +2,13 @@ from unittest import TestCase
 import tempfile
 
 from click.testing import CliRunner
-from pyecsca.ec.curves import get_curve
+from pyecsca.ec.curves import get_params
 from pyecsca.ec.mult import LTRMultiplier
-from pyecsca.ec.mod import Mod
-from pyecsca.ec.point import Point
+from pyecsca.ec.configuration import HashType, RandomMod, Multiplication, Squaring, Reduction
 
-from pyecsca.codegen.common import *
-from pyecsca.codegen.builder import *
+from pyecsca.codegen.common import Platform, DeviceConfiguration
+from pyecsca.codegen.render import render_and_build
+from pyecsca.codegen.builder import build_impl, list_impl
 
 
 class BuilderTests(TestCase):
@@ -20,18 +20,16 @@ class BuilderTests(TestCase):
         mult = Multiplication.BASE
         sqr = Squaring.BASE
         red = Reduction.BASE
-        group = get_curve("secp128r1", "projective")
-        model = group.curve.model
-        coords = group.curve.coordinate_model
-        group.neutral = Point(coords, X=Mod(0, group.curve.prime), Y=Mod(1, group.curve.prime),
-                              Z=Mod(0, group.curve.prime))
+        params = get_params("secg", "secp128r1", "projective")
+        model = params.curve.model
+        coords = params.curve.coordinate_model
         add = coords.formulas["add-1998-cmo"]
         dbl = coords.formulas["dbl-1998-cmo"]
         scl = coords.formulas["z"]
         formulas = [add, dbl, scl]
         scalarmult = LTRMultiplier(add, dbl, scl)
-        config = Configuration(platform, hash_type, mod_rand, mult, sqr, red, model, coords,
-                               formulas, scalarmult, True, True, True)
+        config = DeviceConfiguration(model, coords, formulas, scalarmult, hash_type, mod_rand, mult,
+                                     sqr, red, platform, True, True, True)
         temp = tempfile.mkdtemp()
         render_and_build(config, temp, True)
 
@@ -39,18 +37,20 @@ class BuilderTests(TestCase):
         runner = CliRunner()
         with runner.isolated_filesystem():
             result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "-v", "shortw", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "test.elf"])
+                                   ["--platform", "HOST", "-v", "shortw", "projective",
+                                    "add-1998-cmo",
+                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
             self.assertEqual(result.exit_code, 0)
             result = runner.invoke(build_impl,
-                                   ["--platform", "HOST", "--strip", "--no-remove", "shortw", "projective",
+                                   ["--platform", "HOST", "--strip", "--no-remove", "shortw",
+                                    "projective",
                                     "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=True)",
-                                    "test_stripped.elf"])
+                                    "."])
             self.assertEqual(result.exit_code, 0)
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "--no-ecdsa", "montgom",
                                     "xz", "ladd-1987-m", "dbl-1987-m", "scale", "ldr()",
-                                    "test_ldr.elf"])
+                                    "."])
             self.assertEqual(result.exit_code, 0)
 
     def test_cli_build_fails(self):
@@ -59,32 +59,37 @@ class BuilderTests(TestCase):
             # unknown model
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "missing", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "test.elf"])
+                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
             self.assertEqual(result.exit_code, 2)
             # unknown coordinates
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "shortw", "missing", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "test.elf"])
+                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
             self.assertEqual(result.exit_code, 2)
             # unknown formula
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "shortw", "projective", "missing",
-                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "test.elf"])
+                                    "dbl-1998-cmo", "z", "ltr(complete=True)", "."])
             self.assertEqual(result.exit_code, 2)
             # bad formatted mult spec
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "missing", "test.elf"])
+                                    "dbl-1998-cmo", "z", "missing", "."])
             self.assertEqual(result.exit_code, 2)
             # unknown mult
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "dbl-1998-cmo", "z", "missing()", "test.elf"])
+                                    "dbl-1998-cmo", "z", "missing()", "."])
             self.assertEqual(result.exit_code, 2)
             # missing required formulas to mult
             result = runner.invoke(build_impl,
                                    ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
-                                    "z", "missing", "test.elf"])
+                                    "z", "ltr(complete=True)", "."])
+            self.assertEqual(result.exit_code, 2)
+            # duplicate formulas
+            result = runner.invoke(build_impl,
+                                   ["--platform", "HOST", "shortw", "projective", "add-1998-cmo",
+                                    "add-1998-cmo", "z", "ltr(complete=True)", "."])
             self.assertEqual(result.exit_code, 2)
 
     def test_cli_list(self):
diff --git a/test/test_client.py b/test/test_client.py
new file mode 100644
index 0000000..93f7a82
--- /dev/null
+++ b/test/test_client.py
@@ -0,0 +1,76 @@
+from unittest import TestCase
+
+from click.testing import CliRunner
+from pyecsca.ec.curves import get_params
+from pyecsca.ec.mod import Mod
+
+from pyecsca.codegen.builder import build_impl
+from pyecsca.codegen.client import (encode_data, decode_data, encode_scalar, cmd_init_prng,
+                                    cmd_set_curve, cmd_set_pubkey, cmd_set_privkey, cmd_scalar_mult,
+                                    cmd_ecdh, cmd_ecdsa_sign, cmd_ecdsa_verify, cmd_generate,
+                                    cmd_debug, main)
+
+
+class EncodingTests(TestCase):
+
+    def test_encode_decode(self):
+        data = {"a": encode_scalar(0xcafebabe),
+                "b": {
+                    "c": encode_scalar(Mod(1, 3)),
+                    "d": bytes([0x2])
+                }}
+        encoded = encode_data(None, data)
+        result = decode_data(encoded)
+        self.assertEqual(data, result)
+
+
+class CommandTest(TestCase):
+
+    def setUp(self):
+        self.curve = get_params("secg", "secp128r1", "projective")
+        self.model = self.curve.curve.model
+        self.coords = self.curve.curve.coordinate_model
+
+    def test_init_prng(self):
+        cmd_init_prng(bytes([0xca, 0xfe, 0xba, 0xbe]))
+
+    def test_set_curve(self):
+        cmd_set_curve(self.curve)
+
+    def test_generate(self):
+        cmd_generate()
+
+    def test_set_pubkey(self):
+        cmd_set_pubkey(self.curve.generator)
+
+    def test_set_privkey(self):
+        cmd_set_privkey(0x123456789)
+
+    def test_scalar_mult(self):
+        cmd_scalar_mult(0x123456789)
+
+    def test_ecdh(self):
+        cmd_ecdh(self.curve.generator)
+
+    def test_ecdsa_sign(self):
+        cmd_ecdsa_sign(b"something")
+
+    def test_ecdsa_verify(self):
+        cmd_ecdsa_verify(b"something", b"signature")
+
+    def test_debug(self):
+        cmd_debug()
+
+
+class ClientTests(TestCase):
+
+    def test_generate(self):
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            runner.invoke(build_impl,
+                          ["--platform", "HOST", "-v", "shortw", "projective",
+                           "add-1998-cmo", "dbl-1998-cmo", "z", "ltr(complete=False)", "."])
+            result = runner.invoke(main,
+                                   ["--platform", "HOST", "--binary", "./pyecsca-codegen-HOST.elf",
+                                    "gen", "shortw", "projective", "secg/secp128r1"])
+            self.assertEqual(result.exit_code, 0)