- use identity in voting

- group certificate tool instead of ca daemon
- consensus api fully implemented, consensus+testbed test
- authorities use consensus
- some progress on transport api

1 files changed, 311 insertions, 191 deletions

diff --git a/src/main/java/org/gnunet/voting/BallotTool.java b/src/main/java/org/gnunet/voting/BallotTool.java
index fe83789..452e606 100644
--- a/src/main/java/org/gnunet/voting/BallotTool.java
+++ b/src/main/java/org/gnunet/voting/BallotTool.java
@@ -25,221 +25,341 @@ import com.google.common.base.Charsets;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.Files;
 import com.google.common.io.OutputSupplier;
+import org.gnunet.identity.Identity;
+import org.gnunet.identity.IdentityCallback;
+import org.gnunet.mesh.Mesh;
+import org.gnunet.mesh.MeshRunabout;
+import org.gnunet.mesh.TunnelEndHandler;
+import org.gnunet.testbed.CompressedConfig;
+import org.gnunet.util.AbsoluteTime;
+import org.gnunet.util.Configuration;
+import org.gnunet.util.PeerIdentity;
 import org.gnunet.util.Program;
-import org.gnunet.util.crypto.EcdsaPrivateKey;
+import org.gnunet.util.crypto.EddsaSignature;
 import org.gnunet.util.getopt.Argument;
 import org.gnunet.util.getopt.ArgumentAction;
+import org.gnunet.voting.messages.*;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.List;
+import java.util.Random;
 
 /**
  * Tool for creating, manipulating and submitting ballot files.
  */
-public class BallotTool {
-    public static void main(String[] args) {
-        new Program(args) {
-            @Argument(
-                    shortname = "q",
-                    longname = "query",
-                    action = ArgumentAction.SET,
-                    description = "query election result")
-            boolean query = false;
-
-            @Argument(
-                    shortname = "s",
-                    longname = "submit",
-                    action = ArgumentAction.SET,
-                    description = "submit the vote to the authorities")
-            boolean submit = false;
-
-            @Argument(
-                    shortname = "r",
-                    longname = "register",
-                    action = ArgumentAction.SET,
-                    description = "register an election with the authorities")
-            boolean register = false;
-
-            @Argument(
-                    shortname = "i",
-                    longname = "issue",
-                    action = ArgumentAction.SET,
-                    description = "sign the ballot as issuer")
-            boolean issue = false;
-
-            @Argument(
-                    shortname = "x",
-                    longname = "select",
-                    action = ArgumentAction.STORE_STRING,
-                    argumentName = "CHOICE",
-                    description = "select and encrypt a vote option")
-            String select = null;
-
-            @Argument(
-                    shortname = "V",
-                    longname = "verify",
-                    action = ArgumentAction.SET,
-                    description = "verify signatures in the ballot and show information")
-            boolean verify = false;
-
-            @Argument(
-                    shortname = "t",
-                    longname = "template",
-                    action = ArgumentAction.SET,
-                    description = "write a template ballot to the give ballot file")
-            boolean template = false;
-
-            @Override
-            protected String makeHelpText() {
-                return "gnunet-ballot [OPTIONS]... BALLOT [PRIVKEYFILE]\n" +
-                        "Create, modify and execute operation on ballots.";
-            }
+public class BallotTool extends Program {
+    @Argument(
+            shortname = "e",
+            longname = "ego",
+            action = ArgumentAction.STORE_STRING,
+            description = "ego to use for the operation")
+    String egoName = null;
 
-            private void runTemplate(String filename) {
-                File f = new File(filename);
-                if (f.exists()) {
-                    System.err.println("file already exists, not overwriting");
-                    return;
-                }
-                InputStream is = getClass().getResourceAsStream("template.espec");
-                OutputSupplier<FileOutputStream> oss = Files.newOutputStreamSupplier(f);
-                try {
-                    ByteStreams.copy(is, oss);
-                } catch (IOException e) {
-                    System.err.println("could not copy template file: " + e.getMessage());
-                }
-            }
+    @Argument(
+            shortname = "q",
+            longname = "query",
+            action = ArgumentAction.SET,
+            description = "query election result")
+    boolean query = false;
 
-            private void runIssue(String ballotFilename, String privKeyFilename) {
-                File bf = new File(ballotFilename);
-                if (!bf.exists()) {
-                    System.err.println("ballot file does not exist");
-                    return;
-                }
-                File kf = new File(privKeyFilename);
-                if (!kf.exists()) {
-                    System.err.println("private-key file does not exist");
-                    return;
-                }
-                Ballot b = new Ballot(ballotFilename);
-                EcdsaPrivateKey privateKey = EcdsaPrivateKey.fromFile(privKeyFilename);
-                if (privateKey == null) {
-                    System.err.println("keyfile invalid");
-                    return;
-                }
-                b.issue(privateKey);
-                try {
-                    Files.write(b.serialize(), bf, Charsets.UTF_8);
-                } catch (IOException e) {
-                    System.err.println("could not write ballot file: " + e.getMessage());
-                }
-            }
+    @Argument(
+            shortname = "s",
+            longname = "submit",
+            action = ArgumentAction.SET,
+            description = "submit the vote to the authorities")
+    boolean submit = false;
 
-            public void runSelect(String ballotFilename, String privKeyFilename, String choice) {
-                File bf = new File(ballotFilename);
-                if (!bf.exists()) {
-                    System.err.println("ballot file does not exist");
-                    return;
-                }
-                File kf = new File(privKeyFilename);
-                if (!kf.exists()) {
-                    System.err.println("private-key file does not exist");
-                    return;
-                }
-                EcdsaPrivateKey privateKey = EcdsaPrivateKey.fromFile(privKeyFilename);
-                if (privateKey == null) {
-                    System.err.println("keyfile invalid");
-                    return;
-                }
-                Ballot ballot = new Ballot(ballotFilename);
-                ballot.encodeChoice(choice, privateKey);
-                try {
-                    Files.write(ballot.serialize(), bf, Charsets.UTF_8);
-                } catch (IOException e) {
-                    System.err.println("can not write to ballot file");
-                    return;
-                }
-                System.out.println("vote written to ballot file");
-            }
+    @Argument(
+            shortname = "r",
+            longname = "register",
+            action = ArgumentAction.SET,
+            description = "register an election with the authorities")
+    boolean register = false;
+
+    @Argument(
+            shortname = "i",
+            longname = "issue",
+            action = ArgumentAction.SET,
+            description = "sign the ballot as issuer (use with -e)")
+    boolean issue = false;
 
+    @Argument(
+            shortname = "x",
+            longname = "select",
+            action = ArgumentAction.STORE_STRING,
+            argumentName = "CHOICE",
+            description = "select and encrypt a vote option (use with -e)")
+    String select = null;
+
+    @Argument(
+            shortname = "V",
+            longname = "verify",
+            action = ArgumentAction.SET,
+            description = "verify signatures in the ballot and show information")
+    boolean verify = false;
+
+    @Argument(
+            shortname = "g",
+            longname = "group",
+            action = ArgumentAction.STORE_STRING,
+            description = "incorporate the group cert into the ballot")
+    String groupCertFile = null;
+
+
+    @Argument(
+            shortname = "t",
+            longname = "template",
+            action = ArgumentAction.SET,
+            description = "write a template ballot to the give ballot file")
+    boolean template = false;
+
+    private Identity.Ego ego;
+
+    private Ballot ballot;
+    private String ballotFilename;
+
+    private Mesh mesh;
+    private Mesh.Tunnel tunnel;
+
+    private PeerIdentity currentAuthority;
+
+    /**
+     * Are we finished with communicating over the mesh tunnel and don't need to worry about
+     * disconnection?
+     */
+    private boolean tunnelCommunicationFinished;
+
+    public class BallotTunnelEndHandler implements TunnelEndHandler {
+        @Override
+        public void onTunnelEnd(Mesh.Tunnel tunnel) {
+            // FIXME
+        }
+    }
+
+    public class BallotRegisterReceiver extends MeshRunabout {
+        public void visit(BallotRegisterSuccessMessage m) {
+            System.out.println("ballot successfully registered");
+            ballot.addRegistrationSignature(currentAuthority, m.registrationSignature);
+            writeBallot();
+            tunnel.destroy();
+            mesh.destroy();
+        }
+
+        public void visit(BallotRegisterFailureMessage m) {
+            System.out.println("registering failed: " + m.reason);
+            tunnel.destroy();
+            mesh.destroy();
+        }
+
+    }
 
-            public void runVerify(String ballotFilename) {
-                File bf = new File(ballotFilename);
-                if (!bf.exists()) {
-                    System.err.println("ballot file does not exist");
-                    return;
+    public class QueryReceiver extends MeshRunabout {
+        public void visit(QueryResponseMessage m) {
+            if (m.results.length != ballot.choices.size()) {
+                System.out.println("failure to query result: malformed response");
+            } else {
+                System.out.println("got results:");
+                for (int i = 0; i < m.results.length; i++) {
+                    System.out.println("'" + ballot.choices.get(i) + "': " + m.results[i]);
                 }
-                Ballot ballot = new Ballot(ballotFilename);
-                System.out.print(ballot.describe());
             }
 
-            @Override
-            public void run() {
-                if (template) {
-                    if (this.unprocessedArgs.length != 1) {
-                        System.err.println("-t/--template requires exactly one positional argument");
-                        return;
-                    }
-                    runTemplate(unprocessedArgs[0]);
-                    return;
-                }
+            tunnel.destroy();
+            mesh.destroy();
+        }
 
-                if (register) {
-                    if (this.unprocessedArgs.length != 1) {
-                        System.err.println("-r/--register requires exactly one positional argument");
-                        return;
-                    }
-                    RegisterCommand c = new RegisterCommand(getConfiguration(), unprocessedArgs[0]);
-                    c.run();
-                    return;
-                }
-                if (issue) {
-                    if (this.unprocessedArgs.length != 2) {
-                        System.err.println("-i/--issue requires exactly two positional arguments");
-                        return;
-                    }
-                    runIssue(unprocessedArgs[0], unprocessedArgs[1]);
-                    return;
-                }
-                if (select != null) {
-                    if (this.unprocessedArgs.length != 2) {
-                        System.err.println("-x/--select requires exactly two positional argument");
-                        return;
-                    }
-                    runSelect(unprocessedArgs[0], unprocessedArgs[1], select);
-                    return;
-                }
-                if (submit) {
-                    if (this.unprocessedArgs.length != 1) {
-                        System.err.println("-s/--submit requires exactly one positional argument");
-                        return;
-                    }
-                    SubmitCommand c = new SubmitCommand(getConfiguration(), unprocessedArgs[0]);
-                    c.run();
-                    return;
-                }
-                if (verify) {
-                    if (this.unprocessedArgs.length != 1) {
-                        System.err.println("-V/--verify requires exactly one positional argument");
-                        return;
-                    }
-                    runVerify(unprocessedArgs[0]);
-                    return;
+        public void visit(QueryFailureMessage m) {
+            System.out.println("failure to query result: authority refused");
+            tunnel.destroy();
+            mesh.destroy();
+        }
+    }
+
+    public class SubmitReceiver extends MeshRunabout {
+
+        public void visit(SubmitSuccessMessage m) {
+            System.out.println("vote successfully submitted");
+            ballot.addConfirmation(currentAuthority, m.confirmationSig);
+            writeBallot();
+            tunnel.destroy();
+            mesh.destroy();
+        }
+
+        public void visit(SubmitFailureMessage m) {
+            System.out.println("vote not submitted: " + m.reason);
+            tunnel.destroy();
+            mesh.destroy();
+        }
+    }
+
+    @Override
+    protected String makeHelpText() {
+        return "gnunet-ballot [OPTIONS]... BALLOT\n" +
+                "Create, modify and execute operation on ballots.";
+    }
+
+    private void runTemplate() {
+        File f = new File(ballotFilename);
+        if (f.exists()) {
+            System.err.println("file already exists, not overwriting");
+            return;
+        }
+        InputStream is = getClass().getResourceAsStream("ballot-template.espec");
+        OutputSupplier<FileOutputStream> oss = Files.newOutputStreamSupplier(f);
+        try {
+            ByteStreams.copy(is, oss);
+        } catch (IOException e) {
+            System.err.println("could not copy template file: " + e.getMessage());
+        }
+    }
+
+    private void writeBallot() {
+        try {
+            Files.write(ballot.serialize(), new File(ballotFilename), Charsets.UTF_8);
+        } catch (IOException e) {
+            System.err.println("could not write ballot file: " + e.getMessage());
+        }
+    }
+
+    void doCommands() {
+        if (null != groupCertFile) {
+            Configuration groupCertConfig = new Configuration();
+            groupCertConfig.parse(groupCertFile);
+            GroupCert groupCert = GroupCert.fromGroupCertConfig(groupCertConfig);
+            ballot.encodeGroup(groupCert);
+            writeBallot();
+            return;
+        }
+        if (register) {
+            List<PeerIdentity> remainingAuthorities = ballot.getRemainingRegisterAuthorities();
+            if (remainingAuthorities.isEmpty()) {
+                System.err.println("all authorities already received the ballot");
+                return;
+            }
+            Random r = new Random();
+            currentAuthority = remainingAuthorities.get(r.nextInt(remainingAuthorities.size()));
+            System.out.println("registering ballot with authority " + currentAuthority.toString());
+            mesh = new Mesh(getConfiguration(), new BallotTunnelEndHandler(), new BallotRegisterReceiver());
+            tunnel = mesh.createTunnel(currentAuthority, TallyAuthorityDaemon.MESH_PORT, true, true, null);
+            BallotRegisterRequestMessage m = new BallotRegisterRequestMessage();
+            CompressedConfig ccfg = new CompressedConfig(ballot.toConfiguration());
+            m.compressedBallotConfig = ccfg.compressed_data;
+            tunnel.send(m);
+            return;
+        }
+        if (issue) {
+            if (null == ego) {
+                System.out.println("no ego given");
+                return;
+            }
+            ballot.issue(ego.getPrivateKey());
+            writeBallot();
+            return;
+        }
+        if (select != null) {
+            if (null == ego) {
+                System.out.println("no ego given");
+                return;
+            }
+            ballot.encodeChoice(select, ego.getPrivateKey());
+            writeBallot();
+            return;
+        }
+        if (submit) {
+            List<PeerIdentity> remainingAuthorities = ballot.getRemainingSubmitAuthorities();
+            if (remainingAuthorities.isEmpty()) {
+                System.err.println("all authorities already received the ballot");
+                return;
+            }
+            Random r = new Random();
+            PeerIdentity authority = remainingAuthorities.get(r.nextInt(remainingAuthorities.size()));
+            System.out.println("submitting to authority" + authority.toString());
+            currentAuthority = authority;
+            mesh = new Mesh(cfg, new BallotTunnelEndHandler(), new SubmitReceiver());
+            tunnel = mesh.createTunnel(authority, TallyAuthorityDaemon.MESH_PORT, true, true, null);
+            SubmitMessage m = new SubmitMessage();
+            if (ballot.voterPub == null) {
+                throw new InvalidBallotException("no voter in ballot");
+            }
+            m.voterPub = ballot.voterPub;
+            if (ballot.groupCert == null) {
+                throw new InvalidBallotException("no group cert in ballot");
+            }
+            m.groupCertExpiration = ballot.groupCert.getExpiration().asMessage();
+            m.groupCert = ballot.groupCert.getSignature();
+            m.ballotGuid = ballot.getBallotGuid();
+            m.choiceId = ballot.choiceId;
+            tunnel.send(m);
+            return;
+        }
+        if (verify) {
+            System.out.print(ballot.describe());
+            return;
+        }
+        if (query) {
+            List<PeerIdentity> remainingAuthorities = ballot.getAuthorities();
+            if (remainingAuthorities.isEmpty()) {
+                System.err.println("no authorities available");
+                return;
+            }
+            Random r = new Random();
+            PeerIdentity authority = remainingAuthorities.get(r.nextInt(remainingAuthorities.size()));
+            System.out.println("querying authority" + authority.toString());
+            mesh = new Mesh(cfg, new BallotTunnelEndHandler(), new QueryReceiver());
+            tunnel = mesh.createTunnel(authority, TallyAuthorityDaemon.MESH_PORT, true, true, null);
+            QueryMessage m = new QueryMessage();
+            m.ballotGUID = ballot.getBallotGuid();
+            tunnel.send(m);
+            return;
+        }
+    }
+
+    @Override
+    public void run() {
+        if (unprocessedArgs.length != 1) {
+            System.err.println("no ballot file specified");
+            setReturnValue(1);
+            return;
+        }
+        ballotFilename = unprocessedArgs[0];
+        if (template) {
+            runTemplate();
+            return;
+        }
+        // all other commands need a loaded ballot file
+        File bf = new File(ballotFilename);
+        if (!bf.exists()) {
+            System.err.println("ballot file does not exist");
+            return;
+        }
+        ballot = new Ballot(ballotFilename);
+        if (null != egoName) {
+            Identity.lookup(getConfiguration(), egoName, new IdentityCallback() {
+                @Override
+                public void onEgo(Identity.Ego ego) {
+                    BallotTool.this.ego = ego;
+                    doCommands();
                 }
-                if (query) {
-                    if (this.unprocessedArgs.length != 1) {
-                        System.err.println("-q/--query requires exactly one positional argument");
-                        return;
-                    }
-                    QueryCommand c = new QueryCommand(getConfiguration(), unprocessedArgs[0]);
-                    c.run();
-                    return;
+                @Override
+                public void onError(String errorMessage) {
+                    System.err.println("can't retrieve ego: " + errorMessage);
+                    setReturnValue(1);
                 }
-            }
-        }.start();
+            });
+        } else {
+            doCommands();
+        }
+    }
 
+    private BallotTool(String[] args) {
+        super(args);
     }
 
+    public static void main(String args[]) {
+        Program tool = new BallotTool(args);
+        tool.start();
+    }
 }