WO2016207542A1

WO2016207542A1 - Electronic voting machine and infrastructure comprising such a machine

Info

Publication number: WO2016207542A1
Application number: PCT/FR2016/051523
Authority: WO
Inventors: Damien REIMERT; Stéphane FRENOT; Stéphane GRUMBACH; Simon MEYFFRET
Original assignee: Inria Institut National De Recherche En Informatique Et En Automatique; Institut National Des Sciences Appliquees Lyon
Priority date: 2015-06-22
Filing date: 2016-06-22
Publication date: 2016-12-29
Also published as: FR3037702B1; FR3037702A1

Abstract

The invention relates to an electronic voting machine (42 - 44 - 46) that stores a ranked identifier list and a standby data table having a pointer to an identifier from the list. A central unit executes a first function, which processes a message by verifying a condition related to a comparison with the identifiers from the list and completing the standby table with data from the message that is related to a vote, and a second function, which processes a message by verifying a condition related to a comparison with the identifiers from the list and constructing a message containing both the identifier from the list to which the standby table points, and data from the standby table. A controller sends a request, related to the identifier to which the standby table points, to homologous machines and calls up the first function with each response message. Said controller calls up the second function each time a request is received from a homologous machine and conditionally changes the pointer, from the standby data table, to a higher-ranking identifier from the ranked list on the basis of the data from the standby table.

Description

Electronic voting machine and infrastructure comprising such a machine

The invention relates to an electronic voting machine.

By vote, we mean here any expression of a wish. A vote may relate to a broad election or poll. Voting can be the selection of one of a set of possible elements, or a freely expressed element.

So-called "online" voting systems are known, where the voters communicate with a machine that acts like a server to vote. For example, the voting server may take the form of a web application, executed on a web server, to which the voters access via a browser. Such systems are widely used today.

Online voting systems, and more generally electronic voting systems operating in a centralized organization, are not very effective in ensuring the secrecy of votes. In centralized voting systems, the same machine concentrates all the voting data, that is to say the wishes expressed by the voters and identification data of these voters. Technically, it is very complicated in this case to ensure that the votes of participants can absolutely not be found, that is to say, to establish a relationship between the identifier of a user and a sub-part at least the results of the vote. For some years now, electronic voting systems have been proposed operating in a decentralized organization. To ensure the confidentiality of data, most of these systems implement so-called "homomorphic" encryption methods. These methods are particularly expensive in calculations. In practice, they are reserved for votes with few participants, of the order of more than a few dozen.

The invention aims to improve the situation. The proposed electronic voting machine comprises memory for storing a row of identifiers, and at least one pending data table with a pointer to an identifier of the row of identifiers, a communication interface, a central unit computer capable of interacting with the memory and the communication interface to execute a first function capable of processing a message by verifying a first condition relating to a comparison of a content of said message with the identifiers of the list of identifiers respectively, and, where appropriate, by completing the waiting table with message data relating to a vote and a second function capable of processing a message by verifying a second condition relating to a comparison of the content of said message to the identifiers of the list row of identifiers, and, if necessary, by constructing a message with the identifier of the list to which point e the pending table and at least some of the pending table data. The machine further comprises a controller arranged to send a request to peer electronic voting machines, the query on the identifier to which the waiting array points and call the first function with each response message, call the second function whenever a request is received from a peer electronic voting machine, and conditionally changing the pointer of the waiting data table to an identifier of the higher ranked row list according to the data of the waiting table.

The proposed machine ensures both a vote preserving the anonymity of the source and a vote count. The counting is inexpensive in machine resources, even in the case of a poll involving a large number of homologous machines. Stripping converges rapidly, with little exchange of messages between peer machines compared to conventional methods. The counting remains anonymous.

It also proposes an electronic voting infrastructure comprising several homologous voting machines of the type previously proposed.

Finally, an electronic voting method is proposed comprising the following steps:

storing a row of identifiers, and at least one table of pending data with a pointer to an identifier of the list of identifiers; receiving a request from an electronic voting machine, the request relating to the identifier to which the waiting table points,

check a condition relating to a comparison of the content of the request with the identifiers of the row of identifiers, and, if necessary, construct a message in response with the identifier of the list to which the table on hold is pointing and certain at least data from the waiting table,

conditionally changing the pointer of the pending data table to an identifier of the higher ranked row list according to the data of the waiting table.

Other characteristics and advantages of the invention will appear on examining the following description and the attached drawings, in which:

FIG. 1 represents a functional diagram illustrating an electronic voting infrastructure in a first operating state;

FIG. 2 represents a functional diagram illustrating the infrastructure of FIG. 1 in a second operating state; FIGS. 3 to 6 show functional diagrams respectively illustrating a controller, a configurator, a manager and a voting module for an electronic voting infrastructure;

FIG. 7 represents a flowchart illustrating the operation of an electronic voting infrastructure;

FIG. 8 represents a flowchart illustrating the setting up of an electronic ballot; FIG. 9 represents a flowchart illustrating the operation of an electronic voting infrastructure controller in a polling establishment phase; FIG. 10 represents a flowchart illustrating the operation of an electronic voting infrastructure configurator in a polling establishment phase; FIG. 11 represents a flowchart illustrating the operation of an electronic voting infrastructure manager in a polling establishment phase;

FIG. 12 represents a flowchart illustrating the operation of a voting machine of an electronic voting infrastructure in a voting phase;

FIGS. 13 and 14 represent flowcharts illustrating the operation of a voting machine of an electronic voting infrastructure in a stripping phase; FIG. 15 represents a block diagram of an encapsulation function for a voting machine of an electronic voting infrastructure; and

FIG. 16 is a block diagram of a verification function for a voting machine of an electronic voting infrastructure.

The attached drawings contain elements of a certain character and may therefore not only serve to complete the invention, but also contribute to its definition, if necessary. Figure 1 shows an electronic voting infrastructure 1 in a first operating state. This first operating state corresponds to a phase of establishment of the electronic voting infrastructure.

Infrastructure 1 is organized on a computer network infrastructure. The computer network comprises machines equipped with hardware and software that enable the machines of the infrastructure 1 to communicate with each other. These communications take place according to one or more lower level network protocols. The machines of the infrastructure 1 communicate with each other according to a higher level protocol which allows data exchanges between the machines of the infrastructure 1. The infrastructure 1 comprises at least one machine forming a controller 10. The controller 10 of the infrastructure 1 organizes e-voting processes. The controller 10 initiates the electronic voting processes. The controller 10 defines the electronic voting processes and launches them. The definition of an electronic voting process includes in particular the establishment of a list of identifiers corresponding to machines of the network infrastructure authorized to participate in the vote, and data relating to the subject of the voting process.

Unlike conventional electronic voting systems, any machine in the network infrastructure can function as a controller 10.

The infrastructure 1 further comprises at least one machine forming a configurator 20. The configurator 20 is more particularly active in the configuration of a topology for the infrastructure 1. The configurator 20 provides each machine of the infrastructure 1 the data necessary for the exchange of data relating to the voting process.

The infrastructure 1 further comprises at least one machine forming a manager 30. The manager 30 supports the organization of the voting machines between them and the distribution of encryption data. This is in particular to ensure a coherence and distribution of encryption keys corresponding to a tree structure. As a variant, this task can be performed by another machine of the infrastructure, in particular the configurator 20.

The controller 10, the configurator 20 and the manager 30 together form a functional unit that can be viewed as a server in the electronic voting infrastructure 1. Here, the controller 10, the configurator 20 and the manager 30 correspond to equipment, typically computer central units, physically distinct from each other. This avoids the same equipment concentrating all information relating to infrastructure 1, voting processes and voting machines. This improves security and privacy. Alternatively, the controller 10, the configurator 20 and the manager 30 may correspond to the same equipment.

The infrastructure 1 further comprises a plurality of voting machines, for example a first voting machine 42, a second voting machine 44 and an umpteenth voting machine 46.

Together, the voting machines of infrastructure 1 form a group 40 of voting machines. Group 40 machines are able to communicate with each other. For this purpose, the infrastructure 1 comprises at least one linking server machine, or a tracker 50. The tracker 50 maintains machine addresses of the voting infrastructure, in particular their address in the network infrastructure, for example an internet protocol address, or "IP" address.

The manager 30 and the configurator 20 are preferably trusted third parties. The voting infrastructure machines can be connected to a network time server for synchronization. Figure 2 shows the electronic voting infrastructure 1 in a second operating state. This second operating state corresponds to a vote and counting phase.

In this second operating state, the controller 10, the configurator 20 and the manager 30 are absent from the voting infrastructure 1. They are inactive during the vote and counting phase. Preferably, the machines corresponding to the controller 10, the configurator 20 and / or the manager 30 are off, or at least unavailable within the network infrastructure. This makes the data relating to the voting process course, including the list of identifiers of voting machines, inaccessible from the network infrastructure. This greatly improves the security of the process in that the most sensitive data is only accessible for a very short time, only at the initialization of the voting infrastructure.

In the second operating state, the infrastructure 1 comprises the voting machines and the tracker 50.

Since the controller 10, the configurator 20 and the manager 30 are not able to listen to the data exchanges through the voting infrastructure 1, they can be considered as trusted authorities.

FIG. 3 shows a controller module 100 used for example for the controller 10 of the infrastructure 1 of FIG. 1.

The controller module 100 includes a main controller 110 and a data storage structure 120. The controller 110 is capable of reading, writing, and processing data in the storage structure 120. The storage structure 120 at least temporarily maintains a set of polling data, including voter identification and voting identification data. The storage structure 120 may be organized in the random access memory of a computer, or any other volatile memory device. In this case, the current polling data is cleared when the module is powered off. This power down can be programmed to intervene at the end of the phase of establishing the voting infrastructure. This avoids, in particular, a list of voting identifiers being hacked.

The controller module 100 further comprises at least a first communication interface 140 that can be controlled by the controller 110 to communicate with the machines of a network infrastructure, for example the machines of the infrastructure 1 of FIG. 1. Optionally, the controller module 100 further comprises a user interface 130 that interacts with the main controller 110. The user interface 130 may be of graphic type. The controller module 100 may be implemented in the form of a software controller of the type known as the "Node.js server" executed by a central computer unit. The storage structure 120 may be organized in the random access memory of the computer in question. FIG. 4 shows a configurator module 200 used for example as a configurator 20 of the infrastructure 1 of FIG. 1.

The configurator module 200 comprises a main controller 210 and a storage structure 220 which stores the data relating to the configurator function. The controller 210 can read, write and process the data in the storage structure 220. Preferably, the storage structure 220 is organized in volatile memory. This improves the security of the ballot.

The configurator module 200 further comprises a communication interface 230 which can be controlled by the main controller 210 to transmit and receive data through an electronic voting infrastructure, for example the infrastructure 1 of FIG. 1.

The configurator module 200 may take the form of a server of type Node.js that runs on a central computer unit. The storage structure 220 may be organized in the random access memory of the computer in question.

FIG. 5 shows a management module 300 that can be used as a manager of an electronic voting infrastructure, for example the manager of the infrastructure 1 of FIG. 1.

The management module 300 comprises a main controller 310 and a data storage structure 320 with which the controller can interact, in particular for read, write and process data. The storage structure 320 is preferably organized in volatile memory.

The management module 300 further comprises a communication interface 330 which can be controlled by the controller 310 for exchanging data through an electronic voting infrastructure, for example the infrastructure 1 of FIG. 1.

The management module 300 can be implemented in the form of a server Node.js which runs on a central computer unit. The storage structure 320 can be organized in the RAM of this CPU.

FIG. 6 shows an electronic voting module 400 used for example as a voting machine of an electronic voting infrastructure, for example any machine of the group 40 of FIG. 1.

The voting module 400 includes a controller 410 and a data storage structure 420 with which the main controller 410 can interact to read, write and store data. Voter module 400 further includes a user interface 430 that interacts with the main controller 410. The user interface 430 may be of graphic type.

The voting module 400 further comprises a communication interface 440 which can be controlled by the main controller 410 to exchange data through an electronic voting infrastructure, in particular, the infrastructure 1 of Figure 1.

The voting module 400 can be made in the form of a javascript application, for example using a type function library known as "angular.js" executed on a central computer unit in an internet browser. The storage structure 420 may be organized in the storage memory of this central unit.

The controller modules 100, configurator 200, manager 300 and vote manager 400 preferably run on machines separate from the network infrastructure, such as this has been described in connection with FIG. 1. Sensitive data is distributed. It reduces the risk that an attack on one of these machines will disclose all data from the voting process. As a variant, at least some of these modules run on the same machine of the network infrastructure. In particular, the same machine can function as controller, manager, configurator and / or voting machine. This is facilitated by the fact that the controller, the manager and the configurator do not need to be active once the ballot is launched.

Figure 7 illustrates different operational modes of a voting infrastructure, in particular infrastructure 1 of Figure 1.

According to a first operational mode, represented by block 5, at least some of the software and hardware elements of a network infrastructure cooperate to organize an electronic voting ballot. This operation mainly concerns one or more machines of the infrastructure that will act in the manner of an infrastructure server, for example the assembly formed of the controller 10, the configurator 20 and the manager 30 of FIG. an initial communication between the infrastructure server and equipment intended to operate as electronic voting machines, for example the machines of group 40 of FIG.

According to a second operational mode, illustrated by block 7, each voting machine receives the expression of a vote. In a traditional voting process, operation 7 is what is commonly referred to as a poll or poll. The vote is purely local. In this operational mode, the infrastructure server is idle. The infrastructure corresponds to the infrastructure of Figure 2.

In a third operational mode, illustrated by block 9, the polling data are collected. This operational mode mainly concerns the voting machines themselves, where appropriate linked to one another by means of an additional machine, for example the tracker 50 of FIG. corresponds to what is called a recount in a conventional ballot. The infrastructure corresponds to the infrastructure of Figure 2.

Figure 8 details the organization of an electronic ballot, for example in the infrastructure 1 of Figure 1.

Polling configuration data is first set up, which corresponds to block 52. The configuration data includes data on the subject of the vote and voter data, in particular their identification in the voting infrastructure. electronic voting. In particular, it involves establishing a list of voting identifiers such that each voter can be associated anonymously with a vote identifier.

We then organize a tree structure that organizes the voting identifiers. This corresponds to block 54. In this tree structure, the voting machines correspond to the leaves of an n-ary tree. Between each leaf of the tree and the root of the tree are identified nodes that connect different branches of the tree.

We then generate a collection of encryption keys, here of symmetrical type, which will be used by voting machines mainly to check and / or vote. This corresponds to block 56.

FIG. 9 illustrates a principal function for the controller of an electronic voting infrastructure, for example the controller 10 of FIG. 1, in a mode of operation corresponding to the setting up of a poll.

The function starts in a step 900.

In the next step 902, the function receives a string SntcStrg corresponding to the subject of the vote expressed in natural language. The SntcStrg chain may be entered by the user of an infrastructure controller, where appropriate through a user interface, for example the interface 130 of FIG. 3, or a request of the REST type. The SntcStrg string can be a question, for example. In the next step 904, the function starts a loop structure by initializing a counter k to zero.

In the next step, step 906, the function receives a Chce character string which corresponds to the expression, in natural language, of a possible answer to the question of step 902.

In the next step 908, the function creates an indexed array Answrs [..] in which it stores the Chce string of step 906 as an index element k.

In the next step 910, the function increments the counter k, then returns to step 906. The steps 906 to 910 are repeated as long as the function receives character strings corresponding to possible answers to the question that makes the subject of the vote. Steps 904 to 910 correspond to the entry of a set of possible answers to the question entered in step 902. Steps 904 to 910 are optional: the vote may admit free answers to the question of step 902 .

In the next step 912, the function starts a second loop structure by initializing a counter j to zero.

In the next step 914, the function receives a voter identifier VtrPubld, for example in the form of a string of characters. The identifier VtrPubld corresponds to a public identification data of the voter: it is under this identifier that the voter is known to the poll organizer. This identifier corresponds for example to an identity document reference, an email address, a social network identifier, for example of the type known as Facebook, or even a pseudonym chosen for the poll. The function also receives a VtrPubAdd address with the voter identifier VtrPubld. The VtrPubAdd address allows the sending of messages for the voter. The address VtrPubAdd comprises, for example, a voting machine address, for example the address in the network infrastructure of one of the first voting machine 42, the second voting machine 44 and the nth voting machine 46. , or an email address. The address VtrPubAdd is optional insofar as the voter identifier VtrPubld can be put in relation with an address that can be used for sending message, for example when the VtrPubld identifier itself corresponds to an e-mail address.

In the next step 916, the function stores the received VtrPubld identifier in a VtrPub [..] array as an index element j.

In the next step 918, the function increments the counter j and then returns to step 914 as long as voter IDs are received, until a time period expires or a quota is reached. voting, or until an end of list is received.

The function then proceeds to the next step 920.

It follows from the succession of steps 912 to 918 a list of public identifiers of persons authorized to participate in the poll, stored in the table VtrPub [..].

In step 920, the function receives polling parameters, especially at its beginning and end. These are for example parameters defining a time period of validity of the vote. These time parameters here include a poll start date StrtDat and a poll end date EdDat.

The function ends in the next step 922.

Steps 900 to 922 correspond to the receipt of data relating to the definition of a poll. This definition includes a declaration of vote, in the form of the chain SntcStrg, a list of possible answers to this declaration, here gathered in the table Answrs ["], a list of persons authorized to participate in the vote, here gathered in the table VtrPub [..], and a ballot validity period, here in the form of a start StrtDat date and an end EdDat date. The application described here corresponds to a classic election. Depending on the intended application, which may be different, the manner of defining the poll may vary, particularly with respect to the data of steps 902 to 910. FIG. 10 illustrates a main function for the configurator of an electronic voting infrastructure, for example the controller 20 of FIG. 1, in an operating mode corresponding to an implementation of this infrastructure. The function starts in a step 1000.

In the next step 1002, the function receives a list of vote identifiers VtPvtld, for example gathered in a table VtrPvt [..]. The cardinal of the list of voting identifiers corresponds to that of the list of voter IDs. Each voter identifier VtrPubld corresponds to a vote identifier VtPvtld. The VtPvtld identifiers identify the votes and not the voters. For example, each vote identifier VtPvtld results from an anonymization function called with a voter identifier. Typically this function can be implemented in the infrastructure controller, for example the controller 10 of FIG. 1. By way of example only, each vote identifier VtPvtld results from a hash function, for example of type MD5, called on the result of the concatenation of a voter identifier VtrPubld and a respective private key, for example generated for the occasion.

In the case where the voting infrastructure manages several polls concomitantly, the function can also receive, in step 1002, a poll identifier.

The list of vote identifiers VtPvtld may be transmitted in a message, typically addressed by the infrastructure controller, for example the controller 10 of FIG. 1, to the infrastructure manager, for example the manager 20 of FIG. 1.

The controller and the infrastructure manager are identified here by their respective CtrlrAdd or CfgtrAdd addresses in the network infrastructure.

In the next step 1004, the function generates a tree structure whose number of sheets corresponds to the cardinal of the list of voter IDs. In other words, the tree structure has as many sheets as the ballot contains voters. The function generates a list of node identifiers, noted generically NodIdx_i. This tree structure can be stored as a KTRE [..] list of tables, in which each table relates a node identifier NodIdx_i and a list of child nodes each identified by their index number in the table. .

The tree structure of step 1004 is similar to that of a B + tree. Whenever possible, each child node is a tree leading to as many leaves as other child nodes. The tree includes a number ChldNbr of children and a number HghtNbr of levels, or height. The numbers ChldNbr of children and HgtNbr of levels are such that the number VtrNbr of the identifiers of voters:

or strictly greater than the number ChldNbr of nodes raised to a power corresponding to the HgtNbr of ranks minus one;

or less than or equal to the number ChldNbr of nodes raised to a power corresponding to the HgtNbr.

The nodes are indexed. The root is the node whose index value is zero.

Each node may be associated with a Nodldx index value, and its child nodes may each be associated with a respective index value of the Nodldx form. Idx where Idx is an integer less than or equal to the number ChldNbr minus one denoting a child node.

In this way, each leaf of the tree can be associated with an index value Lfldx of the form i_l.i_2..i_HgtNbr, where each element i corresponds to an integer. Each leaf of the tree can be associated with a natural integer LfNbr corresponding to the translation of the index value Lfldx, for example by virtue of the following function:

LfNbr: = SUM (j: = l, j: = HgtNbr, (i, j-l) * k ^A (HgtNbr - j)

Where SUM () is the sum function.

Conversely, each natural integer corresponding to a vote identifier may be uniquely associated with an index value designating a leaf in the tree structure. Preferably, care is taken to maintain the equilibrium of the tree by assigning to the lower-level nodes the same number of leaves of the tree with k-1 leaves where the number k corresponds to the normal number of threads. 'a knot. One of the nodes of the tree can be found with 2k-1 leaves. The number k is set at creation. The larger the number k, the less distinguishable the votes. The larger the number k, the longer the counting time may be. The number k is greater than or equal to 3. The following formula indicates a relationship between parameters of the tree structure:

HgtNbr = SUP (log ^A k (cardinal (VtPvtId))) This formula indicates that the number HgtNbr of levels of the tree structure corresponds to the whole function by higher values of the logarithm of the number k that multiplies the number of identifiers of vote .

In the next step 1006, the function starts a loop structure by initializing a counter k to zero.

In the next step 1008, the function associates a branch of the tree structure with each voter identifier value VtPvtld. In the case where the nodes are indexed as indicated in step 1004, the branch of the tree structure is designated by the index value of the parent node of that sheet. For example, the function creates an array VBB [..] with, as index element k, an array of two elements corresponding respectively to:

a vote identifier, here generically the identifier VtPvtId_k for the index identifier k in the array;

a row list of NodIdx_i node identifiers, the nodes of the list connecting a leaf of the tree to the root of the tree. Each time, a NodIdx_i identifier is related to an integer value NodChldNbr_i which corresponds to the number of child nodes of the considered node. In an alternative embodiment, each NodIdx_i identifier is associated with a respective encryption key value NodKy_i.

The list of node identifiers is arranged so that the order of the nodes corresponds to the path of a branch of the tree, from a leaf to the root. In replacing, or in addition, each Nodldx node identifier may be associated with a value indicating the level of the node in the tree structure.

In the next step 1010, the function increments the counter k.

In the next step 1012, the function verifies that the counter k has reached its final value, which corresponds to the cardinal of the list VtPvt [..] of the vote identifiers VtPvtld.

If so, then the function proceeds to the next step 1014. Otherwise, the function returns to step 1008.

In step 1014, the function transmits a result list which corresponds to the VBB [..] table. For example, the data in the VBB table is included in a message sent by the configurator to the infrastructure controller. The function stops at the next step 1016.

The controller of the electronic voting infrastructure receives from the configurator a list corresponding to the VBB list of vote identifiers, in which each vote identifier is associated with a row list of node identifiers. The controller transmits to the associated address of each voter identifier a message comprising the vote identifier value VtPvtld and the row list of node identifiers, if appropriate accompanied by the NodKy key values and / or number values. of children NodChildNbr. This data is retrieved on the VTR voting machines. Alternatively, the key values are not generated by the infrastructure configurator. Each voting machine sends the row list of nodes to the manager 30 which in return sends a list of private keys NodKy each corresponding to a node of the list. In this case, the data transmitted by the controller includes an address of the manager 30 in the network of the infrastructure.

FIG. 11 illustrates an example of a main function for a voting infrastructure manager, for example the manager 30 of FIG. 1, in a mode of operation corresponding to the setting up of a poll. The function starts in a step 1100.

In the next step 1102, the function receives a row list Brch [..] of node identifiers. The row list Brch [..] is received in a message sent from a voting machine of the infrastructure to the infrastructure manager. The Brch [..] list corresponds to the list of node identifiers received on the voting machine in question.

In step 1004, the function generates a private key value for each node identifier value of the list. The private key corresponds to an asymmetric encryption algorithm for use in the voting infrastructure. The key values are generically noted NodKy_i.

In the next step 1006, the function constructs a message to the polling machine designated by the VtrAdd address as received at step 1002.

The message comprises a list NodPvtKy [..] of private key values, each corresponding to a node identifier of the list Brch ["], and a list Trckrs [..] of addresses of connection servers, of the type for example tracker 50 of Figures 1 and 2.

The function ends in the next step 1108.

Each machine in the group of voting machines receives an initial message including an encryption key specific to this voting machine. This message is received via another medium of communication such as a postal mail. The value of this key is noted generically PrsnKy_i for the voting machine i. The initial message further comprises a list of linking servers, for example designated by their respective addresses TrckrAdd. Here, the initial message is sent to each machine of the group of administration machines by an infrastructure manager, for example the manager 30 of FIG. 1. The sending of the initial message is preferably controlled by a controller of the user. infrastructure, for example the controller 10 of Figure 1. The first message and the second message are sent separately, on command of an infrastructure controller, for example the controller 10 of FIG.

Once a voting machine has received the initial message, it is able to participate in the ballot. It can operate according to the second operational mode of the infrastructure.

FIG. 12 illustrates a principal function for a voting machine of an electronic voting infrastructure, for example one of the machines VTR_1, VTR_2 and VTR_3 of FIG. 2, according to an operational mode corresponding to the conduct of a poll.

The machine has a vote identifier value VtPvtld, a row list of node identifiers Brch ["], and, for each node identifier Nodld of this list, an integer value NodChldNbr corresponding to a node cardinal and a NodKy encryption key value.

The function starts with a step 1200.

In the next step 1202, the function receives a PllMat data set necessary for the conduct of the poll. These data can, as a whole, be seen as voting material. In particular, this data is received through a message from a source of the infrastructure. The address of the source in question is made available to the voting machine by one or more linking servers, for example the tracker 50 of FIGS. 1 and 2. The data in question can be received in encrypted form by the controller 10. The message may also come from a configurator of the voting infrastructure. The destination address of this message may differ from the known address of the trackers of the voting infrastructure. For example, the trackers know the internet protocol addresses of the voting machines and the message in question is sent to an email address in connection with the voter ID. In the next step 1204, the function decrypts the voting material PllMat using an encryption key PrsnKy_i of the machine i. This key can be transmitted by another medium such as a postal mail. In the next step 1206, the function controls a return of the question and the possible answers.

In the next step 1208, the function receives the expression of a Chce vote, for example in the form of a choice or, if necessary, of a free answer. The function creates a result table Tlly [..] to store the result of the vote. For example, the dimension of the table Tlly [..] corresponds to the number of possible answers to the question asked. And the function stores the value 1 (one) as an element whose index corresponds to the choice of step 1106.

In the next step 1210, the function generates a SignVal signature value using the NodKy encryption key associated with the lowest-level Nodld node identifier in the Brch [..] list and the result of the vote. from the previous step, for example the result table Rslt [..].

In step 1212, the function constructs a CrptBx object for encapsulating the voting results. An object of type CrptBx can be seen as an electronic urn.

A CrptBx object includes, or relates to, a CrptBxId identifier value, vote result data, for example in the form of a CrptBxTlly list ["], and a CrptBxSgn signature value. An object of CrptBx type can for example take the form of a triplet gathering these three elements.

In step 1212, the function constructs a CrptBx type object with the voting result data from step 1208. The CrptBxId identifier corresponds to the lowest-level Nodld node identifier in the Brch [. .] of the voting machine, typically the first identifier of this list. The CrptBxTlly list [..] corresponds to the list Rslt [..]. The value CrptBxSgn corresponds to the SignVal signature value of step 1210. The function also locally creates a pending data table CrtCrptBx [..] including a pointer value CrtCrptBxId to the lowest-level node identifier in the Brch [..] list of the voting machine, and the CrptBx object that has just been created. The function ends in the next step 1214.

A vote in itself corresponds to a purely local process, which concerns an infrastructure voting machine. A vote does not require any communication of the voting machine in question with the homologous machines of the voting infrastructure. Each vote results locally in the creation of a CrptBx object and a table CrtCrptBx [..] containing this object, stored on the machine of the infrastructure where the vote took place. Figure 13 illustrates a first function for any voting machine of an electronic voting infrastructure according to the third operational mode which corresponds to the counting of the votes.

The function starts in a step 1300.

In the next step 1302, the function constructs an interrogation message for at least one tracker of the voting infrastructure, for example the tracker 50 of FIG. 2.

In the next step 1304, the function receives in response a list VtrAdd [..] of homologous machines of the voting infrastructure, for example at least some of the machines of the group of machines 40 of FIG. 2. The machines are identified by their address on the network infrastructure. The VtrAdd [..] list may only correspond to a subset of the infrastructure's voting machines. For example, the machines in the VtrAdd list [..] are randomly selected from the addresses maintained in the tracker, or the tracker in question only maintains the addresses of some of the voting machines in the infrastructure.

In the next step 1306, the function constructs a request in the form of a message here comprising a NodIdQry value corresponding to a node identifier. This NodIdQry value corresponds to an element of the Brch [..] list. This value is the lowest-level element unknown in the Brch [..] list. In one embodiment, this value corresponds to the value CrtCrptBxId. The function issues a request to each of the addresses in the VtrAdd [..] list. Alternatively, the request could include several node identifiers of the Brch [..] list.

In the next step 1308, the function processes a response received in the form of a message sent from one of the addresses of the list VtrAdd [..]. The message contains an object of type CrptBx. The identifier CrptBxId corresponds to one of the node identifiers of the Brch list [..] of the machine at the origin of the response. Depending on the progress of this machine, the CrptBxId identifier may correspond to:

the NodldQry identifier of the requested node; or

- a node identifier higher than the NodldQry identifier in the Brch [..] list.

In the latter case, the CrptBx object does not necessarily contain the expected response, that is, an object corresponding to the NodldQry identifier.

In the next step 1310, the function checks the consistency of the data contained in the CrptBx object and, if necessary, processes this data by integrating the CrptBx object into the pending CrtCrptBx ["] array. The function can call a verification subfunction.

Steps 1308 and 1310 are restarted each time a response containing a CrptBx object is received. Step 1304 corresponding to the interrogation of a tracker is renewed, for example at regular time intervals. The function ends in the next step 1312.

Fig. 14 illustrates a second function for any voting machine according to the third operational mode. This second function processes the request type messages received by a voting machine and from a voting machine homologous to the electronic voting infrastructure.

The function starts in a step 1400. In the next step 1402, the function receives a request in the form of a message sent by a voting machine homologous to the voting infrastructure. The sending voting machine is identified by an address of this machine in the network infrastructure. The received message comprises a NodIdQry node identifier.

In the next step 1404, the function verifies that the identifier NodIdQry is in CrtCrptBx. Otherwise the function stops at step 1408.

If yes, then, in the next step 1406, the function sends a response message to the sending machine. In one embodiment, the function is arranged to respond randomly to the received message, in particular according to a response rate set as a parameter, for example 80%. The function may further maintain a list of the issuing machines and / or NodIdQry IDs requested. This allows the function in particular to stop responding when the same machine and / or the same NodIdQry identifier are too often requested.

The response message includes at least one CrptBx object from the CrtCrptBx array [..] waiting on the voting machine. Here, the function addresses a single CrptBx object. This further improves the confidentiality of the counting. Alternatively, the function could return all the CrptBx objects available in the CrtCrptBx [..] table.

According to the progress of the voting machine, that is to say the identifier of the list to which the value CrtCrptBxId points, the object CrptBx in response can correspond to the identifier NodIdQry or to a upper identifier in the Brch [..] list. This CrptBx object does not necessarily contain the expected response of the machine that is causing the request message. The function can address part of the table CrtCrptBx [..] which corresponds to a superset of what is requested, namely the identifier NodIdQry, possibly without the data corresponding to the identifier NodIdQry. The content of the response may depend on the result of a random draw implemented by the function, in particular when the machine has several CrptBx objects corresponding to the NodIdQry identifier.

The function also ends after step 1408. In addition, each time a response message is received and verified, the voting machine can perform an update function on the pending CrtCrptBx [..] table and the CrptBx objects it contains. This function checks whether the number of different signatures contained in the CrptBx objects of the waiting table CrtCrptBx [..] corresponds to the cardinal value associated with the node identifier of the Brch list [..] to which the CrtCrptBxId value points. . If so, then the update function changes the value of CrptCrpBxId so that it points to the just higher rank node ID in the Brch [..] list of the voting machine. And the function creates a new object of type CrptBx from the CrptBx objects of the pending array. Old CrptBx objects are replaced by the new one. The function uses an aggregate function that updates the CrptBxTlly [..] list of the new object from the voting results of the old CprtBx objects corresponding to a lower-ranked node in the Brch [..] list. the voting machine.

Figure 15 illustrates a function Bld () 1500 as an example of CrptBx object aggregation function.

The Bld () 1500 function receives several CrptBx objects as input. The CrptBxId identifier of these objects corresponds to the identifier of the same node of the Brch list [..] of the voting machine.

The Bld () function 1500 includes a concatenation subfunction Cnct () 1502 that is called with the CrptBxSgn signature values of the CrptBx objects. The function Cnct () 1502 outputs an HshVal, or hash, fingerprint value resulting from the concatenation of these signature values.

The function Bld () 1500 includes a query subfunction Prt () 1504. The function Prt () 1504 is called with the value CrptBxId which corresponds to a node identifier in the Brch list [..] of the machine. vote. The function Prt () outputs a CrtNodld node identifier value which corresponds to the node of rank just above in the Brch list [..] at the node identified by the value CrptBxId. For example, the Prt () function returns the identifier of the node that follows the node identified by the CrptBxId value in the Brch [..] row list.

The function Bld () 1500 also includes an aggregation subfunction Mrg () 1506. The Mrg () function 1506 is called with the voting results contained in the CrptBx objects received as input, in particular their CrptBxTlly lists [.. ]. The function Mrg () 1506 establishes consolidated data from these lists CrptBxTlly [..] that it stores for example in a new list CrtTlly [..]. Consolidation may depend on the nature of the vote. In a simple embodiment, the consolidation consists in counting the voices expressed for each of the possible choices. In this case, the Mrg () function adds the result vectors.

The Bld () function 1500 includes a hash function Hsh () 1508, or footprint. The function Hsh () 1508 is called with the value HshVal delivered by the function Cnct () 1502, the value CrtNodld delivered by the function Prt () 1504 and the list CrtTlly [..] delivered by the function Mrg () 1506. The function Hsh () 1508 outputs a second HshVal2 fingerprint value resulting from the application of a hash function on the input data. The Bld () function 1500 also includes a Crpt () 1510 encryption function. The Crpt () function 1510 performs encryption from input values. The function Crpt () 1510 receives the value HshVal resulting from the function Cnct () 1502, the node identifier corresponding to the identifiers CrptBxId and the value HshVal2 resulting from the function Hsh () 1508. The function Crpt () 1510 uses as key the value associated with the node identifier corresponding to the value CrtNodld in the list Brch.

Finally, the Bld () function 1500 includes a Bxg () 1512 encapsulation function. The Bxg () function 1512 creates an object of the CrptBx type from the data it receives. The function Bxg () 1512 assigns to the new object CrptBx: the result of the function Crpt () 1510 as a signature CrptBxSgn, the value of the identifier CrtNodld as a value CrptBxId and the list CrtTlly [..] as result data CprtBxTllyl ..].

FIG. 16 illustrates a function Vrf () for checking an object of the CrptBx type. The Vrf () function comprises a Nbxg 1602 desencapsulation subfunction, which receives as input an object of the CrptBx type. It outputs the data contained in the CrptBx object, in particular a CrptBxId identifier value, a CrptBxTlly list [.] Of voting results, a CrptBxSgn signature value.

The function Vrf () further comprises a decryption sub-function Dcph 1604. The subfunction Dcph is called with the value CrptBxSgn resulting from the call of the function Nbxg 1602, and an associated key value, in the machine. vote, with the identifier corresponding to the CrptBxId identifier value. Dcph 1604 provides a first HshVal signature value which should correspond to the concatenation of the signature values of the aggregated CrptBx objects in the verified CrptBx object, a second HshVal2 signature value which should correspond to the second HshVal2 imprint value described in connection with Fig. 15 and an IdVal identifier value which should correspond to a node identifier of the Brch list [..].

The Vrf () function also includes an Hsh () 1606 footprint subfeature that produces an HshVaB footprint value from input values. Here, the function Hsh () 1606 is called with the credential value CrptBxId, the vote result data CrptBxTlly [..] and the first HshVall imprint value resulting from the function Nbxg 1602. This results in a third value HshVaB fingerprint by hashing.

The function Vrf () comprises a comparison subfunction Cmpr () 1608. The function Cmpr () 1608 is called with the value HshVaB resulting from the call of the function Hsh () 1606 and the second impression value HshVal2 resulting the call to the Dcph () function. The function Cmpr () 1608 delivers a Boolean value that corresponds to a comparison of these values.

The function Vrf () comprises a first search sub-function Srchl () 1610. The function Srchl () 1610 is called with the identifier value IdVal resulting from the call of the function Dcph () 1604 and the list Brch [ "] Respective node identifiers of the voting machine. The Srchl () function 1610 returns a Boolean value that corresponds to the presence or absence of the IdVal identifier value in the Brch [..] list. The Vrf () function includes a second Srch2 () search subfunction 1612. The Srch2 () function is called with the HshVall fingerprint value resulting from the call to the Dcph () 1604 function and a fingerprint value CrrtHshVal corresponding to the concatenation of the signature values of CrptBx objects in the pending array. The Srch2 () function returns a Boolean value that corresponds to the presence or absence of the fingerprint value of the level corresponding to IdVal in HshVall.

The function Srchl () 1610 is furthermore arranged here so that the Boolean value it returns corresponds to the result of calling the function Srch2 () according to a truth table corresponding to an AND gate.

The function Vrf () 1600 finally comprises a logic function ND () 1614 which delivers a Boolean value resulting from the comparison of input values according to a truth table corresponding to an AND function. The ND () function 1614 is called with the Boolean value BoolVall resulting from the function Cmpr () 1608 and the Boolean value BoolVal2 resulting from the call of the function Srchl () 1610.

We have just described an electronic voting machine and an electronic voting infrastructure comprising such a machine. These have the following particularities:

Neither the controller nor the configurator nor the infrastructure manager are active in the operational modes corresponding to the polling and counting.

The tree structure that organizes the counting is never materialized: a voting machine only has the identifiers corresponding to a branch of this tree.

The tracker maintains a list of addresses corresponding to the nodes that at one point participated in the voting mechanism. The machines corresponding to the new incoming nodes can be shown to the tracker. The latter maintains an ordered list by date of arrival of the nodes. At each new connection, the tracker returns a sub-list of addresses to contact. Then, if a machine does not find new votes to integrate, it can contact the tracker to get a new sub-list of addresses in order to be able to restart the search mechanism of the voting values.

The voting data are collected in a messy form that can not be related to the voting machines.

- During the counting, each voting machine tries to calculate partial results, each corresponding to a node of the tree structure, from the leaf to the root of this tree. To do this, a voting machine will look for voting data from peer machines that calculate partial results for possibly different (higher) nodes.

- The balance of the tree structure decreases the ability to distinguish between the results corresponding to different branches of the tree.

Any machine in the network infrastructure can define and launch an e-voting process and not just the configurator.

The infrastructure can operate on the basis of different communication protocols of the internet protocol. In particular, different protocols can be used for setting up the ballot and its counting.

A voting machine could answer queries with all the CrptBx objects it has, regardless of the rank of the sending machine.

The invention is not limited to the embodiments described above by way of example only. It encompasses all the variants that can be considered by those skilled in the art.

Claims

claims

An electronic voting machine of the type comprising:

memory (400) for storing a row of identifiers, and at least one table of pending data with a pointer to an identifier of the row of identifiers;

a communication interface (440);

a computer central unit (410) capable of interacting with the memory (400) and the communication interface (440) to execute:

a first function capable of processing a message by verifying a first condition relating to a comparison of a content of said message with the identifiers of the row of identifiers respectively, and, where appropriate, by completing the table waiting with data from the message relating to a vote;

a second function capable of processing a message by verifying a second condition relating to a comparison of the content of said message to the identifiers of the list of identifiers, and, if necessary, by constructing a message with the identifier of the list to which points the table on hold and at least some of the data in the pending table;

a controller (410) arranged for:

issue a request to peer electronic voting machines, the request for the identifier to which the waiting array points and call the first function with each response message,

calling the second function each time a request is received from a peer electronic voting machine, and

conditionally changing the pending data table pointer to an identifier of the higher ranked row list based on the data in the pending table.

2. Machine according to claim 1 wherein the identifiers of the row list denotes a node of a tree structure, the list corresponding to at least part of a branch of the tree structure.

3. Machine according to one of claims 1 and 2, wherein the first function completes the data table pending with message data relating to a signature value, the second function constructs the message with a signature value, and the pointer of the pending data array is changed based on a result of a signature test contained in the pending array.

4. Machine according to one of the preceding claims, wherein the memory stores a collection of integer values each associated with a respective identifier of the row list of identifiers, and the pointer of the table of pending data is modified according to a result of a test of the integer value associated with the identifier to which the pending data array points.

5. Machine according to one of the preceding claims, wherein the controller is arranged to issue a prior request to a connection server and issue a request to some at least peer electronic voting machines corresponding to addresses received from the linking server.

6. Machine according to one of the preceding claims, wherein the data table pending maintains data relating to a vote on the machine.

7. Machine according to one of the preceding claims, wherein at least a portion of the data of the waiting table is organized into a list of digital objects each maintaining a relationship between vote result data and an identifier of the ordered list. identifiers.

8. Machine according to claim 7, wherein the second function constructs said message with all the digital objects of the data table pending.

9. Machine according to one of the preceding claims, wherein the identifiers of the row list of identifiers of the digital objects of the pending table are of rank lower than the rank of the identifier to which the table pending.

10. Machine according to one of the preceding claims, wherein the controller is arranged to aggregate the voting data of the pending table to the modification of the pointer of this table.

11. Electronic voting infrastructure comprising several homologous voting machines according to one of the preceding claims.

12. Infrastructure according to claim 11 comprising a connection server arranged for, on request, return a set of addresses corresponding to a subset only of voting machines homologous infrastructure.

The infrastructure of claim 12, wherein the set of addresses is randomly selected by the addresses of the peer voting machines.

14. Electronic voting method of the type comprising the following steps:

storing a row of identifiers, and at least one table of pending data with a pointer to an identifier of the list of identifiers;

- send a request to peer electronic voting machines, the query on the identifier to which the pending table points,

processing at least one message in response by verifying a condition relating to a comparison of a content of said message with the identifiers of the row of identifiers respectively, and, where appropriate, by completing the table waiting with data of the message relating to a vote,

15. Electronic voting method of the type comprising the following steps:

receiving a request from an electronic voting machine, the request relating to the identifier to which the waiting table points,

check a condition relating to a comparison of the content of the request with the identifiers of the row of identifiers, and, if necessary, construct a message in response with the identifier of the list to which the table on hold is pointing and certain at least data from the waiting table, conditionally changing the pointer of the pending data table to an identifier of the higher ranked row list according to the data of the waiting table.