def do_export_all(self): """Kõigi valimiste väljund failid CDle """ if Election().count_questions() < 1: print "Ei ole midagi eksportida" return cd_burner = burner.FileListBurner(evcommon.burn_buff()) try: print "Ekspordime kõik. Palun oota.." for i in Election().get_questions(): self.update_files(i) file_list = self.file_table.values() # Olukord, kus valimiste ID on, aga faile pole if len(file_list) == 0: print "Ei ole midagi eksportida" return # Kui on, siis ka vastav sha256 fail exporti for file_key in self.file_table.keys(): sha256f = self.get_sha256_file(file_key) if sha256f: file_list.append(sha256f) if not cd_burner.append_files(i, file_list): return cd_burner.burn() finally: cd_burner.delete_files()
def do_set_mid_conf(): try: def_url = Election().get_mid_url() except: def_url = 'https://www.openxades.org:8443/DigiDocService' try: def_name = Election().get_mid_name() except: def_name = 'Testimine' try: def_auth_msg, def_sign_msg = Election().get_mid_messages() except: def_auth_msg = 'E-hääletus, autentimine' def_sign_msg = 'E-hääletus, hääle allkirjastamine' url = uiutil.ask_string(\ "Sisesta DigiDocService'i URL", None, None, def_url) name = uiutil.ask_string(\ "Sisesta teenuse nimi", None, None, def_name) auth_msg = uiutil.ask_string(\ "Sisesta sõnum autentimisel", None, None, def_auth_msg) sign_msg = uiutil.ask_string(\ "Sisesta sõnum allkirjastamisel", None, None, def_sign_msg) Election().set_mid_conf(url, name, auth_msg, sign_msg)
def hts_vote(self, valid_person, vote): ik = valid_person[0] en = valid_person[1] pn = valid_person[2] evlog.AppLog().set_person(ik) import base64 decoded_vote = base64.decodestring(vote) evlog.log('Hääle talletamine: %s %s' % (en, pn)) if not Election().can_vote(ik): error = HESResult() error.pole_valija(ik) return self.__return_error(error) inspector = VoteChecker(decoded_vote, ik) mobid = 'MOBILE_ID_CONTEXT' in os.environ if not inspector.check_vote(mobid): return self.__return_error(inspector.error) params = {} params[evcommon.POST_EVOTE] = vote params[evcommon.POST_PERSONAL_CODE] = ik params[evcommon.POST_VOTERS_FILES_SHA256] = \ Election().get_voters_files_sha256() params[evcommon.POST_SESS_ID] = sessionid.voting() hts_connector = HTSConnector(params) if not hts_connector.work_strict(): return self.__return_error(hts_connector.error) return hts_connector.answer[1], hts_connector.answer[2]
def test_cgp_grey_animal_kingdom(self): """Tests CGP Grey example STV election 'Politics in the Animal Kingdom' Link: https://www.youtube.com/watch?v=l8XOZJkozfI Expected winners: Gorilla, Monkey, Tiger """ # Setup tarsier = Candidate('tarsier', name='Tarsier') gorilla = Candidate('gorilla', name='Gorilla') monkey = Candidate('monkey', name='Monkey') tiger = Candidate('tiger', name='Tiger') lynx = Candidate('lynx', name='Lynx') expected_winners = set([gorilla, monkey, tiger]) seats = 3 tiebreak_alphanumeric = 'abcdefghijklmnopqrstuvwxyz' num_ballots = 10000 ballots = ( ballots_for_candidates([tarsier, gorilla], int( .05 * num_ballots)) + ballots_for_candidates( [gorilla, tarsier, monkey], int(.28 * num_ballots)) + ballots_for_candidates([monkey], int(.33 * num_ballots)) + ballots_for_candidates([tiger], int(.21 * num_ballots)) + ballots_for_candidates([lynx, tiger, tarsier, monkey, gorilla], int(.13 * num_ballots))) # Test election = Election(seats=seats, ballots=ballots, random_alphanumeric=tiebreak_alphanumeric) results = election.compute_results() self.assertEqual(expected_winners, results.candidates_elected)
def create_actions(self): max_votes_per_voter = None if Election().get_root_reg().check(['common', 'max_votes_per_voter']): max_votes_per_voter = \ Election().get_root_reg().read_integer_value(\ ['common'], 'max_votes_per_voter').value for el in self.questions: _hts = hts.HTS(el[0]) voter = _hts.talletaja(self.signercode) dsc = '' try: dsc = Election().get_sub_reg(\ el[0]).read_string_value(['common'], 'description').value except: dsc = el[0] if voter == None: self.user_msg = EV_ERRORS.POLE_VALIJA self.log_msg = "Pole valija %s, %s" % (self.signercode, dsc) raise HTSStoreException, evcommon.EVOTE_ERROR if max_votes_per_voter: if self._count_votes(el[0]) >= max_votes_per_voter: self.user_msg = EV_ERRORS.TEHNILINE_VIGA self.log_msg = self.user_msg raise HTSStoreException, evcommon.EVOTE_ERROR self.actions.append([_hts, voter, el[1]])
def do_rem_rights(elid): ik = uiutil.ask_id_num() right_str = "" if Election().is_hes() or Election().is_hlr(): right = uiutil.ask_int( "Võimalikud volitused:\n " + "\t(1) Valikute nimekirja laadija\n" + "\t(2) Valimisjaoskondade nimekirja laadija\n" + "Vali volitus:", 1, 1, 2) if right == 1: right_str = "VALIK" elif right == 2: right_str = "JAOSK" elif Election().is_hts(): right = uiutil.ask_int( "Võimalikud volitused:\n " + "\t(1) Tühistus- ja ennistusnimekirja laadija\n" + "\t(2) Valimisjaoskondade nimekirja laadija\n" + "Vali volitus:", 1, 1, 2) if right == 1: right_str = "TYHIS" elif right == 2: right_str = "JAOSK" if not uiutil.ask_yes_no("Kas soovid eemaldada volituse"): return subprocess.call([SCRIPT_REGRIGHTS, elid, "rem", ik, right_str])
def check_ocsp(): log = evlog.Logger() log.set_format(evlog.AppLogFormat('OCSPWD')) log.set_logs(Election().get_path(evcommon.OCSP_LOG_FILE)) try: _conf = bdocconfig.BDocConfig() _conf.load(Election().get_bdoc_conf()) _ocsp = _conf.get_ocsp_responders() for el in _ocsp: app = ('openssl ocsp -issuer "%s" -serial 123 -url "%s" -noverify' % (_ocsp[el], el)) pp = subprocess.Popen(app, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, close_fds=True) is_ok = 0 start = time.time() while True: line = pp.stdout.readline() if not line: break if line.strip().find('This Update:') != -1: is_ok = 1 end = time.time() if is_ok: log.log_info(message='OCSP päringu tegemiseks kulus %5.2f sekundit' % (end - start)) else: log.log_info(message='OCSP ei vasta') except: log.log_err(message=exception_msg.trace())
def main_function(): if len(sys.argv) != 3: usage() el_id = sys.argv[1] _if = sys.argv[2] if not check_file(_if): print "Faili " + _if + " ei eksisteeri" sys.exit(1) if not ksum.has(_if): print "Faili " + ksum.filename(_if) + " ei eksisteeri" sys.exit(1) if not ksum.check(_if): print "Kontrollsumma ei klapi" sys.exit(1) reg = Election().get_sub_reg(el_id) reg.ensure_key(['hlr', 'input']) dst = reg.path(['hlr', 'input', 'votes']) os.system("cp " + _if + " " + dst) os.system("cp " + ksum.filename(_if) + " " + ksum.filename(dst)) Election().config_hlr_input_elid_done(el_id)
def do_rem_rights(elid): ik = uiutil.ask_id_num() right_str = "" if Election().is_hes() or Election().is_hlr(): right = uiutil.ask_int("Võimalikud volitused:\n " + \ "\t(1) Valikute nimekirja laadija\n" + \ "\t(2) Valimisjaoskondade nimekirja laadija\n" + \ "Vali volitus:", 1, 1, 2) if right == 1: right_str = "VALIK" elif right == 2: right_str = "JAOSK" elif Election().is_hts(): right = uiutil.ask_int("Võimalikud volitused:\n " + \ "\t(1) Tühistus- ja ennistusnimekirja laadija\n" + "\t(2) Valimisjaoskondade nimekirja laadija\n" + \ "Vali volitus:", 1, 1, 2) if right == 1: right_str = "TYHIS" elif right == 2: right_str = "JAOSK" if not uiutil.ask_yes_no("Kas oled kindel"): return cmd = "%s %s rem %s %s" % (SCRIPT_REGRIGHTS, elid, ik, right_str) os.system(cmd)
def prepare(self, confer_name): if Election().is_hes(): self.root = 'hes' elif Election().is_hlr(): self.root = 'hlr' else: raise Exception('Vigane serveritüüp') if not ElectionState().can_replace_candidates(): print 'Selles hääletuse faasis (%s) valikuid muuta ei saa'\ % ElectionState().str() return False self.reg = Election().get_sub_reg(self.elid) AppLog().set_app(confer_name, self.elid) AppLog().log('Valikute nimekirja välja vahetamine: ALGUS') self.quest = question.Question(self.elid, self.root, self.reg) self._ed = inputlists.Districts() self._ed.load(self.root, self.reg) self._backup_old_choices() print 'Valimised: ' + self.elid return True
def create_sub1_hts(sub): sub.create(CHOICE_CONFIGURE_COMMON) sub.add_item(CHOICE_BDOC_CONF, serviceutil.do_bdoc_conf) sub.add_item(CHOICE_INSTALL, serviceutil.do_install) sub.add_item(CHOICE_CONFIG_FILES_HISTORY, serviceutil.do_config_files_history) sub.add_item(CHOICE_VERIFICATION_CONF, serviceutil.do_verification_conf) if self.state == election.ETAPP_ENNE_HAALETUST: if Election().is_voters_list_disabled(): sub.add_item(CHOICE_ENABLE_VOTERS_LIST, serviceutil.do_enable_voters_list) else: sub.add_item(CHOICE_DISABLE_VOTERS_LIST, serviceutil.do_disable_voters_list) if (self.state == election.ETAPP_ENNE_HAALETUST and Election().is_hts_configured()): sub.add_item(CHOICE_START_ELECTION, self.do_change_state) if self.state == election.ETAPP_HAALETUS: sub.add_item(CHOICE_START_REVOCATION, self.do_change_state) if self.state == election.ETAPP_TYHISTUS: sub.add_item(CHOICE_START_COUNTING, self.do_change_state)
def create_actions(self): max_votes_per_voter = None if Election().get_root_reg().check(['common', 'max_votes_per_voter']): max_votes_per_voter = \ Election().get_root_reg().read_integer_value(\ ['common'], 'max_votes_per_voter').value for el in self.questions: _hts = hts.HTS(el[0]) voter = _hts.talletaja(self.signercode) dsc = '' try: dsc = Election().get_sub_reg(\ el[0]).read_string_value(['common'], 'description').value except: dsc = el[0] if voter == None: self.user_msg = EvMessage().get_str("POLE_LUBATUD_HAALETADA", \ evstrings.POLE_LUBATUD_HAALETADA) % (self.signercode, dsc) self.log_msg = self.user_msg raise HTSStoreException, evcommon.EVOTE_ERROR if max_votes_per_voter: if self._count_votes(el[0]) >= max_votes_per_voter: self.user_msg = EvMessage().get_str(\ "TEHNILINE_VIGA_MAX_HAALTE_ARV_PER_HAALETAJA_ON_ULETATUD", \ evstrings.TEHNILINE_VIGA_MAX_HAALTE_ARV_PER_HAALETAJA_ON_ULETATUD) self.log_msg = self.user_msg raise HTSStoreException, evcommon.EVOTE_ERROR self.actions.append([_hts, voter, el[1]])
def result(electionID): if 'admin' in session: election = Election.getElection({'_id': ObjectId(electionID)}) if election['date'].date() < datetime.datetime.now().date(): pass elif election['date'].date() == datetime.datetime.now().date() and election['endtime'] < str(datetime.datetime.now().time())[:5]: pass else: flash('Election not yet ended! Wait for Election to end to calculate result', 'warning') return redirect(url_for('dashboard')) result = {} response = Blockchain.get_chain() for block in response['chain']: IpfsBlock = Blockchain.get_by_hash(block['IpfsHash']) for txn_hash in IpfsBlock['data']: txn = Blockchain.get_by_hash(txn_hash) if txn['electionID'] == electionID: if txn['candidateID'] not in result: result[txn['candidateID']] = 1 else: result[txn['candidateID']] += 1 Election.updateElection({'_id':ObjectId(electionID)}, {'$set':{'result':result}}) flash('Result calculated and published.', 'info') return redirect(url_for('dashboard')) else: flash('You need to Login first!', 'warning') return redirect(url_for('login'))
def main(): # Run Experiments start = time() for cname in sorted(CONTESTS): for t in xrange(NTRIALS): cattr = CONTESTS[cname] c, g, a, params = cattr['c'], cattr['g'], cattr['a'], cattr['p'] contest = Contest(c, g, a, params) e = Election([contest]) e.run() for aname in sorted(AUDITS): outcome, nballots = e.audit(AUDITS[aname])[0] # assumes 1 contest if outcome != contest.outcome[0]: results[cname][aname]['e'] += 1 results[cname][aname]['n'] += nballots end = time() # Report Results for cname in sorted(CONTESTS): print cname for aname in sorted(AUDITS): avg_nballots = results[cname][aname]['n'] / float(NTRIALS) avg_nerrors = results[cname][aname]['e'] / float(NTRIALS) print '\t%s\t%f\t%f' % (aname, avg_nballots, avg_nerrors) print 'Runtime: ' + str(end - start)
def process_args(args): """Processes command-line election arguments and runs election. Args: argparse.Namespace containing election arguments. """ if args.ballots is not None: if args.ballots.startswith('http'): ballots = ballots_from_url(args.ballots) else: ballots = ballots_from_file(args.ballots) else: ballots = ballots_from_input() election = Election( ballots, args.seats, can_eliminate_no_confidence=not (args.disallow_nc_elimination), can_random_tiebreak=not (args.disallow_random_tiebreak), name=args.name, random_alphanumeric=args.alphanumeric) results = election.compute_results() if args.verbose: print(results.description()) else: for candidate in results.candidates_elected: print(candidate)
def do_it(self): c_ring, c_dist = self._ed.create(self.root, self.reg) Election().copy_config_file(self.elid, self.root, self.jaosk_f, evcommon.DISTRICT_FILES) print 'Paigaldatud %d ringkonda ja %d jaoskonda' % (c_ring, c_dist) c_choice = self._ch.create(self.quest.choices_proxy()) Election().copy_config_file(self.elid, self.root, self.valik_f, evcommon.CANDIDATE_FILES) print 'Paigaldatud %d valikut' % c_choice if self.root in ['hes', 'hts']: print 'Paigaldan valijate faili võtit' Election().copy_voter_public_key_file(self.elid, self.voter_public_key_f) print 'Võti on paigaldatud' c_add, c_del = self._vl.create('Paigaldan valijaid: ') print 'Valijad on paigaldatud. '\ 'Teostati %d lisamist ja %d eemaldamist'\ % (c_add, c_del) Election().copy_config_file(self.elid, self.root, self.voter_f, evcommon.VOTERS_FILES) Election().add_voters_file_hash(self.voter_f) return True
def test_1_candidate_1_seat(self): """Tests a 1 candidate election for 1 seat. Expected winners: A Round 0 Ballots: 10 * [A] Votes: A: 10 Threshold: (10) / (1+1) + 1 = 6 Result: A is elected """ # Setup expected_winners = set(candidates_for_ids(['A'])) seats = 1 tiebreak_alphanumeric = 'abcdefghijklmnopqrstuvwxyz' ballots = (ballots_for_ids(['A'], 10)) # Test election = Election(seats=seats, ballots=ballots, random_alphanumeric=tiebreak_alphanumeric) results = election.compute_results() self.assertEqual(expected_winners, results.candidates_elected)
def test_wikipedia_food_selection(self): """Tests Wikipedia's example STV election, using choices of food. Link: https://en.wikipedia.org/wiki/Single_transferable_vote#Example Expected winners: Chocolate, Oranges, Strawberries """ # Setup chocolate = Candidate('chocolate', name='Chocolate') oranges = Candidate('oranges', name='Oranges') pears = Candidate('pears', name='Pears') strawberries = Candidate('strawberries', name='Strawberries') sweets = Candidate('sweets', name='Sweets') expected_winners = set([chocolate, oranges, strawberries]) seats = 3 tiebreak_alphanumeric = 'abcdefghijklmnopqrstuvwxyz' ballots = (ballots_for_candidates([oranges], 4) + ballots_for_candidates([pears, oranges], 2) + ballots_for_candidates([chocolate, strawberries], 8) + ballots_for_candidates([chocolate, sweets], 4) + ballots_for_candidates([strawberries], 1) + ballots_for_candidates([sweets], 1)) # Test election = Election(seats=seats, ballots=ballots, random_alphanumeric=tiebreak_alphanumeric) results = election.compute_results() self.assertEqual(expected_winners, results.candidates_elected)
def test_nc_halt_early(self): """ Tests a 3 candidate election for 3 seats. Once No Confidence is elected, the election should end. Expected winners: B, NC Round 0 Ballots: 5 * [A, NC] 6 * [B, NC] 4 * [C, NC] 5 * [NC] Votes: A: 5 B: 6 C: 4 NC: 5 Threshold: (6+5+4+5) / (3+1) + 1 = 6 Result: B is elected Round 1 Ballots: 5 * [A, NC] 4 * [C, NC] 5 * [NC] Votes: A: 5 C: 4 NC: 5 Threshold: (5+4+5) / (2+1) + 1 = 5.666 Result: C is eliminated Round 2 Ballots: 5 * [A, NC] 9 * [NC] Votes: A: 5 NC: 9 Threshold: (5+9) / (2+1) + 1 = 5.666 Result: NC is elected """ # Setup expected_winners = set(candidates_for_ids(['B', 'NC'])) seats = 3 tiebreak_alphanumeric = 'abcdefghijklmnopqrstuvwxyz' ballots = (ballots_for_ids(['A', 'NC'], 5) + ballots_for_ids(['B', 'NC'], 6) + ballots_for_ids(['C', 'NC'], 4) + ballots_for_ids(['NC'], 5)) # Test election = Election(seats=seats, ballots=ballots, random_alphanumeric=tiebreak_alphanumeric) results = election.compute_results() self.assertEqual(expected_winners, results.candidates_elected)
def __create_vote_key(self): reg = Election().get_root_reg() while True: vote_id = _generate_vote_id() key = htscommon.get_verification_key(vote_id) if not reg.check(key): reg.create_key(key) return vote_id
def process_elid(elid): print "%s" % elid reg_i = Election().get_sub_reg(elid, [Election().get_server_str()]) process_district_files(reg_i) process_candidate_files(reg_i) if not Election().is_hlr(): process_voters_files(reg_i)
def __init__(self, elid): self._elid = elid self._errmsg = None self._reg = Election().get_sub_reg(self._elid) self._revlog = evlog.Logger() self._revlog.set_format(evlog.RevLogFormat()) self._revlog.set_logs(self._reg.path(['common', evcommon.REVLOG_FILE]))
def add_hts_files_to_table(elid, table): import os reg = Election().get_root_reg() if reg.check(['questions', elid, 'hts', 'output']): o_files = os.listdir(reg.path(['questions', elid, 'hts', 'output'])) for of in o_files: if of.find("tokend.") == 0 and of.find(".sha1") == -1: table.add_file(EvFile(of, of, ['questions', elid, 'hts', 'output']))
def do_view_election_description(elid): el_reg = Election().get_sub_reg(elid) try: description = el_reg.read_string_value(['common'], 'description').value except IOError: description = uiutil.NOT_DEFINED_STR except LookupError: description = uiutil.NOT_DEFINED_STR print "Valimiste %s kirjeldus: %s\n" % (elid, description)
def add_hts_files_to_table(elid, table): import os reg = Election().get_root_reg() if reg.check(['questions', elid, 'hts', 'output']): o_files = os.listdir(reg.path(['questions', elid, 'hts', 'output'])) for of in o_files: if of.find("tokend.") == 0 and of.find(".sha1") == -1: table.add_file( EvFile(of, of, ['questions', elid, 'hts', 'output']))
def calc_probability_hurdle_surpassing(self, party): seats = np.zeros(self.__sample_size) for idx in range(self.__sample_size): election_result = self.values.T[idx] election = Election(election_result, drop_other_parties=self.__drop_other_parties) seats_by_party = election.calc_seats_by_party() seats[idx] = seats_by_party[party.idx] return np.count_nonzero(seats) / self.__sample_size
def do_session_conf(): try: def_length = Election().get_session_length() except (IOError, LookupError): def_length = 60 session_length = uiutil.ask_int( "Sisesta valimisseansi kehtivusaeg minutites", def_length, 1) Election().set_session_length(session_length)
def _count_votes(self, elid): user_key = htscommon.get_user_key(self.signercode) if Election().get_sub_reg(elid).check(user_key): keys = Election().get_sub_reg(elid).list_keys(user_key) try: keys.remove(htscommon.VOTE_VERIFICATION_ID_FILENAME) except ValueError: pass # No "otp" file return len(keys) return 0
def calc_seats_by(self, coalition: Coalition): coalition_seats = np.zeros(self.__sample_size) for idx in range(self.__sample_size): election_result = self.values.T[idx] election = Election(election_result, drop_other_parties=self.__drop_other_parties) seats_by_party = election.calc_seats_by_party() for party in coalition.parties: coalition_seats[idx] += seats_by_party[party.idx] return coalition_seats
def __init__(self): os.environ['MOBILE_ID_CONTEXT'] = '1' self.url = Election().get_mid_url() self.name = Election().get_mid_name() self.auth_msg, self.sign_msg = Election().get_mid_messages() loc = DigiDocServiceLocator() # self.fp = open('/tmp/debug.out', 'a') # kw = { 'tracefile': self.fp } kw = {} self.srv = loc.getDigiDocService(self.url, **kw)
def kooskolaline(self, voters_files_sha1): if Election().get_root_reg().check(['common', 'voters_files_sha1']): hts_voters_files_sha1 = \ Election().get_root_reg().read_string_value( ['common'], 'voters_files_sha1').value else: hts_voters_files_sha1 = '' if hts_voters_files_sha1 != voters_files_sha1: return False return True
def test_forward_tiebreak(self): """Tests a 3 candidate election for 2 seats. In the event of a tie to eliminate a candidate, and no backward tiebreak, eliminate the candidate with the fewest next-choice votes. Repeat for all subsequent ranks as necessary. Expected winners: A, C Round 0 Ballots: 6 * [A] 3 * [B, C] 3 * [C] Votes: A: 6 B: 3 C: 3 Threshold: (6+3+3) / (2+1) + 1 = 5 Result: A is elected Round 1 Ballots: 3 * [B, C] 3 * [C] Votes: B: 3 C: 3 Threshold: (3+2+1) / (1+1) + 1 = 4 Result: B is eliminated B and C are tied for fewest votes in this and previous rounds. B has fewer next-rank votes, so B is eliminated. Round 2 Ballots: 6 * [C] Votes: C: 6 Threshold: (6) / (1+1) + 1 = 4 Result: C is elected """ # Setup expected_winners = set(candidates_for_ids(['A', 'C'])) seats = 2 tiebreak_alphanumeric = 'abcdefghijklmnopqrstuvwxyz' ballots = (ballots_for_ids(['A'], 6) + ballots_for_ids(['B', 'C'], 3) + ballots_for_ids(['C'], 3)) # Test election = Election(seats=seats, ballots=ballots, random_alphanumeric=tiebreak_alphanumeric) results = election.compute_results() self.assertEqual(expected_winners, results.candidates_elected)
def test_random_tiebreak(self): """Tests a 3 candidate election for 2 seats. In the event of a tie to eliminate a candidate, and no backward tiebreak or forward tiebreak, eliminate a random candidate based on uid. Expected winners: A, C Round 0 Ballots: 6 * [A] 3 * [B] 3 * [C] Votes: A: 6 B: 3 C: 3 Threshold: (6+3+3) / (2+1) + 1 = 5 Result: A is elected Round 1 Ballots: 3 * [B] 3 * [C] Votes: B: 3 C: 3 Threshold: (3+3) / (1+1) + 1 = 4 Result: B is elected B and C are tied for fewest votes in this and all previous rounds, as well as future ranks. B's uid ('gwashington') is ordered before C's uid ('jadams') in the tiebreak_alphanumeric, so B is eliminated. Round 2 Ballots: 3 * [C] Votes: C: 3 Threshold: (3) / (1+1) + 1 = 2.5 Result: C is elected """ # Setup expected_winners = set(candidates_for_ids(['A', 'C'])) seats = 2 tiebreak_alphanumeric = 'abcdefghijklmnopqrstuvwxyz' ballots = (ballots_for_ids(['A'], 6) + ballots_for_ids(['B'], 3) + ballots_for_ids(['C'], 3)) # Test election = Election(seats=seats, ballots=ballots, random_alphanumeric=tiebreak_alphanumeric) results = election.compute_results() self.assertEqual(expected_winners, results.candidates_elected)
def purge_otp(reg, otp): otp_key = htscommon.get_verification_key(otp) voter = reg.read_string_value(otp_key, "voter").value.rstrip() voter_key = htscommon.get_user_key(voter) elids = reg.read_string_value(otp_key, "elids").value.rstrip().split("\t") for elid in elids: sreg = Election().get_sub_reg(elid) if sreg.check(voter_key + [htscommon.VOTE_VERIFICATION_ID_FILENAME]): sreg.delete_value(voter_key, htscommon.VOTE_VERIFICATION_ID_FILENAME) reg.ensure_no_key(otp_key)
def main_function(): try: election_ids = Election().get_questions() if len(election_ids) == 0: print "Sätteid pole laaditud" else: election_ids.sort() for el_i in election_ids: process_elid(el_i) except Exception as ex: print 'Viga valijanimekirjade uuenduste ajaloo kuvamisel: ' + str(ex) sys.exit(1)
class EvFile: def __init__(self, filename, uiname, regprefix): self.__filename = filename self.__uiname = uiname self.__regprefix = regprefix self.__reg = Election().get_root_reg() def exists(self): return self.__reg.check(self.__regprefix + [self.__filename]) def path(self): return self.__reg.path(self.__regprefix + [self.__filename]) def name(self): return self.__uiname
def main_function(): if len(sys.argv) != 3: usage() el_id = sys.argv[1] _if = sys.argv[2] if not ksum.check(_if, True): print "Kontrollsumma ei klapi" sys.exit(1) reg = Election().get_sub_reg(el_id) reg.ensure_key(['hlr', 'input']) dst = reg.path(['hlr', 'input', 'votes']) shutil.copy(_if, dst) ksum.store(dst) Election().config_hlr_input_elid_done(el_id)
def __load_bdoc(self, elid): voter_key = htscommon.get_user_key(self._voter_code) sreg = Election().get_sub_reg(elid) for votefile in sreg.list_keys(voter_key): if htscommon.VALID_VOTE_PATTERN.match(votefile): bdoc = bdocpythonutils.BDocContainer() bdoc.load(sreg.path(voter_key + [votefile])) bdoc.validate(bdocpythonutils.ManifestProfile("TM")) self._voter = htscommon.get_votefile_voter(votefile) break if not bdoc: evlog.log_error("No valid BDOC found for voter %s using vote ID %s" % \ (self._voter, self._vote_id)) raise HTSVerifyException, evcommon.VERIFY_ERROR return bdoc
def _revoke_vote_id(voter_code): elec = Election() otps = set() for quest in elec.get_questions(): reg = elec.get_sub_reg(quest) key = htscommon.get_user_key(voter_code) if reg.check(key + [htscommon.VOTE_VERIFICATION_ID_FILENAME]): otp = reg.read_string_value(key, \ htscommon.VOTE_VERIFICATION_ID_FILENAME) otps.add(otp.value) evlog.log("Revoking vote ID %s" % otp) if not _delete_vote_id(otp.value): evlog.log_error("No such vote-ID: %s" % otp) otp.delete() if len(otps) > 1: evlog.log_error("The voter %s had multiple vote ID-s: %s" % \ (voter_code, ", ".join(otps)))
def do_set_hts_conf(): reg = Election().get_root_reg() if reg.check(['common', 'htsip']): try: def_ip_port = reg.read_ipaddr_value(\ ['common'], 'htsip').value.split(":") def_ip = def_ip_port[0] if len(def_ip_port) > 1: try: def_port = int(def_ip_port[-1]) except ValueError: def_port = 80 else: def_port = 80 except: def_ip = None def_port = 80 else: def_ip = None def_port = 80 hts_ip = uiutil.ask_string("Sisesta HTSi IP aadress", None, None, def_ip) hts_port = uiutil.ask_int("Sisesta HTSi port", def_port, 0, 65535) if reg.check(['common', 'htspath']): try: def_url = reg.read_string_value(['common'], 'htspath').value except: def_url = None else: def_url = None hts_url = uiutil.ask_string("Sisesta HTSi URL", None, None, def_url) try: def_verify = Election().get_hts_verify_path() except: def_verify = None hts_verify = uiutil.ask_string("Sisesta HTSi hääle kontrolli URL", \ None, None, def_verify) cmd = "%s set %s:%d %s %s" % (SCRIPT_CONFIG_HTH, hts_ip, hts_port, \ hts_url, hts_verify) os.system(cmd)
def __load_bdoc(self, elid): voter_key = htscommon.get_user_key(self._voter_code) sreg = Election().get_sub_reg(elid) vote_files = [] for vfile in sreg.list_keys(voter_key): if htscommon.VALID_VOTE_PATTERN.match(vfile): vote_files.append(vfile) vote_files.sort() latest = vote_files.pop() if latest: bdoc = htsbase.get_vote(sreg.path(voter_key + [latest])) if not bdoc: evlog.log_error("No valid BDOC found for voter %s using vote ID %s" % \ (self._voter_code, self._vote_id)) raise HTSVerifyException, evcommon.VERIFY_ERROR return bdoc
def work(self, check_fn, purge_fn): reg = Election().get_root_reg() runtime = int(time.time()) AppLog().log("Purging %ss as of %s: START" % (self._desc, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(runtime)))) try: if not reg.check(self._key): return for key in reg.list_keys(self._key): try: if check_fn(reg, key, runtime): AppLog().log("Purging %s %s" % (self._desc, key)) purge_fn(reg, key) except: AppLog().log("Error processing %s %s" % (self._desc, key)) AppLog().log_exception() except: AppLog().log_exception() finally: AppLog().log("Purging %ss: DONE" % self._desc)
def do_set_hts_conf(): reg = Election().get_root_reg() if reg.check(['common', 'htsip']): try: def_ip_port = reg.read_ipaddr_value( ['common'], 'htsip').value.split(":") def_ip = def_ip_port[0] if len(def_ip_port) > 1: try: def_port = int(def_ip_port[-1]) except ValueError: def_port = 80 else: def_port = 80 except: def_ip = None def_port = 80 else: def_ip = None def_port = 80 hts_ip = uiutil.ask_string("Sisesta HTSi IP aadress", None, None, def_ip) hts_port = uiutil.ask_int("Sisesta HTSi port", def_port, 0, 65535) try: def_url = Election().get_hts_path() except: def_url = "/hts.cgi" hts_url = uiutil.ask_string("Sisesta HTSi URL", None, None, def_url) try: def_verify = Election().get_hts_verify_path() except: def_verify = "/hts-verify-vote.cgi" hts_verify = uiutil.ask_string( "Sisesta HTSi hääle kontrolli URL", None, None, def_verify) subprocess.call([SCRIPT_CONFIG_HTH, "%s:%d" % (hts_ip, hts_port), hts_url, hts_verify])
def __init__(self, elid, tmpdir): self._elid = elid evlog.AppLog().set_app('HLR', self._elid) self._reg = Election().get_sub_reg(self._elid) self._log4 = evlog.Logger('log4') self._log5 = evlog.Logger('log5') self._log4.set_format(evlog.EvLogFormat()) self._log5.set_format(evlog.EvLogFormat()) self._log4.set_logs(self._reg.path(['common', 'log4'])) self._log5.set_logs(self._reg.path(['common', 'log5'])) tmpreg = evreg.Registry(root=tmpdir) tmpreg.ensure_key([]) tmpreg.delete_sub_keys([]) self.output_file = tmpreg.path(['decrypted_votes']) self.__cnt = ChoicesCounter()
def do_set_hsm_conf(): reg = Election().get_root_reg() if reg.check(['common', 'hsm', 'tokenname']): try: def_tokenname = \ reg.read_string_value(['common', 'hsm'], 'tokenname').value except: def_tokenname = "evote" else: def_tokenname = "evote" token_name = uiutil.ask_string(\ "Sisesta HSM'i partitsiooni nimi", None, None, def_tokenname) if reg.check(['common', 'hsm', 'privkeylabel']): try: def_privkeylabel = \ reg.read_string_value(['common', 'hsm'], 'privkeylabel').value except: def_privkeylabel = "evote_key" else: def_privkeylabel = "evote_key" priv_key_label = uiutil.ask_string(\ "Sisesta privaatvõtme nimi", None, None, def_privkeylabel) if reg.check(['common', 'hsm', 'pkcs11']): try: def_pkcs11 = \ reg.read_string_value(['common', 'hsm'], 'pkcs11').value except: def_pkcs11 = "/usr/lunasa/lib/libCryptoki2_64.so" else: def_pkcs11 = "/usr/lunasa/lib/libCryptoki2_64.so" pkcs11_path = uiutil.ask_file_name(\ "Sisesta PKCS11 teegi asukoht", def_pkcs11) cmd = "%s set %s %s %s" % \ (SCRIPT_CONFIG_HSM, token_name, priv_key_label, pkcs11_path) os.system(cmd)
class HTSBase: def __init__(self, elid): self._elid = elid self._errmsg = None self._reg = Election().get_sub_reg(self._elid) self._log1 = evlog.Logger() self._log1.set_format(evlog.EvLogFormat()) self._log1.set_logs(self._reg.path(['common', 'log1'])) self._log2 = evlog.Logger() self._log2.set_format(evlog.EvLogFormat()) self._log2.set_logs(self._reg.path(['common', 'log2'])) self._log3 = evlog.Logger() self._log3.set_format(evlog.EvLogFormat()) self._log3.set_logs(self._reg.path(['common', 'log3'])) self._revlog = evlog.Logger() self._revlog.set_format(evlog.RevLogFormat()) self._revlog.set_logs(self._reg.path(['common', evcommon.REVLOG_FILE])) def _haaletanud_konf(self, isikukood): user_key = htscommon.get_user_key(isikukood) return self._reg.check(user_key) and \ len(self._reg.list_keys(user_key)) > 0 def haaletanud(self, isikukood): logi = self._log1.contains(isikukood) konf = self._haaletanud_konf(isikukood) if logi and konf: return True if (not logi) and (not konf): return False self._errmsg = 'Logifail LOG1 ja serveri olek ei ole kooskõlalised' raise Exception(self._errmsg)
def do_change_election_description(elid): description = uiutil.ask_string("Sisesta valimiste kirjeldus") el_reg = Election().get_sub_reg(elid) el_reg.create_string_value(['common'], 'description', description)
def __init__(self, sessid): if not sessid: raise ValueError("Missing sessid") self.__key = [evcommon.IDSPOOL, sessid] self.__reg = Election().get_root_reg()
def __init__(self, filename, uiname, regprefix): self.__filename = filename self.__uiname = uiname self.__regprefix = regprefix self.__reg = Election().get_root_reg()
def issue_vote_id(self): vote_id = self.__create_vote_key() rreg = Election().get_root_reg() key = htscommon.get_verification_key(vote_id) rreg.create_string_value(key, "voter", self.signercode) rreg.create_integer_value(key, "timestamp", int(time.time())) rreg.create_integer_value(key, "count", \ Election().get_verification_count()) # Store the election IDs and include a backreference in the # corresponding questions' subregistries. elids = "" for elid in [quest[0] for quest in self.questions]: elids += elid + "\t" sreg = Election().get_sub_reg(elid) skey = htscommon.get_user_key(self.signercode) sreg.ensure_key(skey) sreg.create_string_value(skey, \ htscommon.VOTE_VERIFICATION_ID_FILENAME, vote_id) rreg.create_string_value(key, "elids", elids) return vote_id
class HTSVerify: def __init__(self): self._rreg = Election().get_root_reg() self._vote_id = None self._voter_code = None self._voter = None def __revoke_vote_id(self): _revoke_vote_id(self._voter_code) def verify_id(self, vote_id): # check if valid vote ID if not formatutil.is_vote_verification_id(vote_id): # We don't know how large vote_id is, so don't write to disk evlog.log_error("Malformed vote ID") raise HTSVerifyException, evcommon.VERIFY_ERROR vote_id = vote_id.lower() otp_key = htscommon.get_verification_key(vote_id) # check if corresponding OTP exists if not self._rreg.check(otp_key): evlog.log_error("No such vote ID: %s" % vote_id) raise HTSVerifyException, evcommon.VERIFY_ERROR self._voter_code = self._rreg.read_string_value(\ otp_key, "voter").value.rstrip() # check if timestamp is OK current = int(time.time()) created = self._rreg.read_integer_value(otp_key, "timestamp").value timeout = Election().get_verification_time() * 60 if created + timeout < current: evlog.log("Vote ID %s has expired" % vote_id) self.__revoke_vote_id() raise HTSVerifyException, evcommon.VERIFY_ERROR # check if count is OK count = self._rreg.read_integer_value(otp_key, "count").value if count <= 0: evlog.log_error("Vote ID %s count is zero, but had not been revoked") self.__revoke_vote_id() raise HTSVerifyException, evcommon.VERIFY_ERROR self._vote_id = vote_id def __load_bdoc(self, elid): voter_key = htscommon.get_user_key(self._voter_code) sreg = Election().get_sub_reg(elid) for votefile in sreg.list_keys(voter_key): if htscommon.VALID_VOTE_PATTERN.match(votefile): bdoc = bdocpythonutils.BDocContainer() bdoc.load(sreg.path(voter_key + [votefile])) bdoc.validate(bdocpythonutils.ManifestProfile("TM")) self._voter = htscommon.get_votefile_voter(votefile) break if not bdoc: evlog.log_error("No valid BDOC found for voter %s using vote ID %s" % \ (self._voter, self._vote_id)) raise HTSVerifyException, evcommon.VERIFY_ERROR return bdoc def __decrease_count(self): otp_key = htscommon.get_verification_key(self._vote_id) count = self._rreg.read_integer_value(otp_key, "count").value - 1 if count > 0: self._rreg.create_integer_value(otp_key, "count", count) else: self.__revoke_vote_id() def get_response(self): import binascii # load a random BDOC from the ones available otp_key = htscommon.get_verification_key(self._vote_id) elids = self._rreg.read_string_value(otp_key, "elids")\ .value.rstrip().split("\t") bdoc = self.__load_bdoc(random.choice(elids)) evlog.log("Sending BDOC %s with vote ID %s for verification" %\ (ksum.votehash(bdoc.get_bytes()), self._vote_id)) # check consistency bdoc_set = set([doc.split(".")[0] for doc in bdoc.documents]) elids_set = set(elids) if bdoc_set != elids_set: evlog.log_error("Votes in BDOC for vote ID %s are inconsistent " \ "with registry: %s, %s" % (self._vote_id, bdoc_set, elids_set)) raise HTSVerifyException, evcommon.VERIFY_ERROR # create question objects questions = [] for elid in elids: questions.append(question.Question(\ elid, "hts", Election().get_sub_reg(elid))) # start assembling the response ret = "" # append questions for quest in questions: ret += quest.qname() + ":" + str(quest.get_type()) + "\t" ret += "\n" # append election IDs and votes for votefile in bdoc.documents: elid = votefile.split(".")[0] ret += elid + "\t" + binascii.b2a_hex(bdoc.documents[votefile]) + "\n" ret += "\n" # append voter ret += self._voter["nimi"] + "\t" + self._voter_code + "\n" # append choices list for quest in questions: ret += quest.choices_to_voter(self._voter) self.__decrease_count() return ret
def __init__(self): self._rreg = Election().get_root_reg() self._vote_id = None self._voter_code = None self._voter = None
class HLR: """ Häältelugemisrakendus """ def __init__(self, elid, tmpdir): self._elid = elid evlog.AppLog().set_app('HLR', self._elid) self._reg = Election().get_sub_reg(self._elid) self._log4 = evlog.Logger('log4') self._log5 = evlog.Logger('log5') self._log4.set_format(evlog.EvLogFormat()) self._log5.set_format(evlog.EvLogFormat()) self._log4.set_logs(self._reg.path(['common', 'log4'])) self._log5.set_logs(self._reg.path(['common', 'log5'])) tmpreg = evreg.Registry(root=tmpdir) tmpreg.ensure_key([]) tmpreg.delete_sub_keys([]) self.output_file = tmpreg.path(['decrypted_votes']) self.decrypt_prog = DECRYPT_PROGRAM self.sign_prog = SIGN_PROGRAM self.__cnt = ChoicesCounter() def __del__(self): try: os.remove(self.output_file) except: pass def _decrypt_votes(self, pin): input_file = self._reg.path(['hlr', 'input', 'votes']) token_name = Election().get_hsm_token_name() priv_key_label = Election().get_hsm_priv_key() pkcs11lib = Election().get_pkcs11_path() args = [input_file, self.output_file, \ token_name, priv_key_label, pin, pkcs11lib] exit_code = 0 try: exit_code = subprocess.call([self.decrypt_prog] + args) except OSError, oserr: errstr = "Häälte faili '%s' dekrüpteerimine nurjus: %s" % \ (input_file, oserr) evlog.log_error(errstr) return False if exit_code == 0: return True if exit_code > 0: errstr2 = "Tundmatu viga" if exit_code in G_DECRYPT_ERRORS: errstr2 = G_DECRYPT_ERRORS[exit_code] errstr = \ "Häälte faili '%s' dekrüpteerimine nurjus: %s (kood %d)" % \ (input_file, errstr2, exit_code) evlog.log_error(errstr) return False errstr = "Häälte faili '%s' dekrüpteerimine nurjus (signaal %d)" % \ (input_file, exit_code) evlog.log_error(errstr) return False
class MobileIDContext: phoneno = None lang = None challenge = None midsess = None origvote = None votefiles = {} __sessid = None __reg = None def __init__(self, sessid): if sessid == None: raise Exception('Puuduv sessiooniidentifikaator') self.__sessid = sessid self.__reg = Election().get_root_reg() self.lang = 'EST' def sessid(self): return self.__sessid def kill(self): self.__reg.ensure_no_key([evcommon.MIDSPOOL, self.__sessid]) def set_phone(self, phone): self.phoneno = phone def set_origvote(self, hv): self.origvote = hv def get_origvote(self): self.origvote = self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid], \ 'origvote').value return self.origvote def add_votefile(self, filename, data): self.votefiles[filename] = data def get_votefiles(self): for key in self.__reg.list_keys([evcommon.MIDSPOOL, self.__sessid, \ 'votefiles']): self.votefiles[key] = self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid, 'votefiles'], key).value return self.votefiles def generate_challenge(self): self.challenge = binascii.b2a_hex(os.urandom(10)) def verify_challenge(self, signature): return challenge_ok(self.certificate(), self.mychallenge(), \ self.ourchallenge(), signature) def mychallenge(self): return self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid], \ 'mychallenge').value def ourchallenge(self): return self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid], \ 'ourchallenge').value def certificate(self): return self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid], \ 'cert').value def set_auth_succ(self): self.__reg.ensure_key([evcommon.MIDSPOOL, self.__sessid, 'authsucc']) def auth_succ(self): return self.__reg.check(\ [evcommon.MIDSPOOL, self.__sessid, 'authsucc']) def save_post_auth(self, rsp): self.__reg.reset_key([evcommon.MIDSPOOL, self.__sessid]) self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'cert', rsp._CertificateData) self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'phone', self.phoneno) self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'midsess', rsp._Sesscode) self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'mychallenge', self.challenge) self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'ourchallenge', rsp._Challenge) def load_pre_sign(self): self.phoneno = self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid], 'phone').value def save_post_sign(self, midsess): self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'midsess', midsess) self.__reg.create_value([evcommon.MIDSPOOL, self.__sessid], \ 'origvote', self.origvote) self.__reg.ensure_key([evcommon.MIDSPOOL, self.__sessid, 'votefiles']) for el in self.votefiles: self.__reg.create_value(\ [evcommon.MIDSPOOL, self.__sessid, 'votefiles'],\ el, self.votefiles[el]) def load_pre_poll(self): self.midsess = int(self.__reg.read_value(\ [evcommon.MIDSPOOL, self.__sessid], 'midsess').value)
class SessionContext: def __init__(self, sessid): if not sessid: raise ValueError("Missing sessid") self.__key = [evcommon.IDSPOOL, sessid] self.__reg = Election().get_root_reg() def store_session(self, cert): self.__reg.ensure_key(self.__key) self.__reg.create_value(self.__key, "cert", cert) self.__reg.create_integer_value(self.__key, "start", int(time.time())) def check_session(self, cert): if not self.__reg.check(self.__key): return evcommon.EVOTE_ERROR, evmessage.EV_ERRORS.SEANSS_PUUDUB start = self.__reg.read_integer_value(self.__key, "start").value length = Election().get_session_length() * 60 if start + length < int(time.time()): return evcommon.EVOTE_ERROR, evmessage.EV_ERRORS.SEANSS_PUUDUB if self.__reg.read_value(self.__key, "cert").value != cert: evlog.log_error('Sertifikaat muutus') return evcommon.EVOTE_CERT_ERROR, evmessage.EV_ERRORS.TEHNILINE_VIGA return evcommon.EVOTE_OK, None def kill(self): self.__reg.ensure_no_key(self.__key)
def __init__(self, sessid): if sessid == None: raise Exception('Puuduv sessiooniidentifikaator') self.__sessid = sessid self.__reg = Election().get_root_reg() self.lang = 'EST'