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 __proxy(self, vote=None, votebox=None):
try:
evlog.log(LOGSIG[self.__task] + ': ALGUS')
if ElectionState().election_on():
security = CertAnalyzer()
if security.work():
if self.__task == TASK_CAND:
return \
self.__get_candidate_list(security.valid_person())
elif self.__task == TASK_VOTE:
return self.__hts_vote(\
security.valid_person(), vote, votebox)
else:
r1, r2 = protocol.msg_error_technical()
return self.__return_error(r1, r2)
else:
evlog.log_error('Viga: "%s"' % security.logmsg)
return \
self.__return_error(security.errcode, security.errmsg)
else:
r1, r2 = ElectionState().election_off_msg()
return self.__return_error(r1, r2)
except:
return self.__return_exception()
finally:
evlog.log(LOGSIG[self.__task] + ': LõPP')
def talleta_base64(self, data):
try:
try:
AppLog().log('Hääle talletamine: ALGUS')
if ElectionState().election_on():
return self.__all.talleta_base64(data)
r1, msg = ElectionState().election_off_msg()
AppLog().log_error(msg)
return evcommon.EVOTE_ERROR, msg
except:
AppLog().log_exception()
return evcommon.EVOTE_ERROR, EV_ERRORS.TEHNILINE_VIGA
finally:
AppLog().log('Hääle talletamine: LõPP')
def haaletanud(self, ik):
try:
try:
AppLog().log('Korduvhääletuse kontroll: ALGUS')
if ElectionState().election_on():
ok, msg = self.__all.haaletanud(ik)
return True, ok, msg
r1, msg = ElectionState().election_off_msg()
AppLog().log_error(msg)
return False, False, msg
except:
AppLog().log_exception()
return False, False, EV_ERRORS.TEHNILINE_VIGA
finally:
AppLog().log('Korduvhääletuse kontroll: LõPP')
def verification_configuration(self):
try:
AppLog().log("Load verification configuration: START")
if ElectionState().election_on():
return evcommon.VERIFY_OK, "BLOB" # TODO msg-seadistus
ret, msg = ElectionState().election_off_msg()
AppLog().log_error(msg)
return evcommon.VERIFY_ERROR, msg
except:
AppLog().log_exception()
return evcommon.VERIFY_ERROR, EvMessage().get_str(\
"TECHNICAL_ERROR_LOAD_CONFIGURATION", \
evstrings.TECHNICAL_ERROR_LOAD_CONFIGURATION)
finally:
AppLog().log("Load verification configuration: END")
def yleminek_tyhistusperioodi(self, pref=''):
p_time = "00:00:00"
try:
try:
s_time = time.time()
AppLog().log('Üleminek tühistusperioodi: ALGUS')
if ElectionState().get() == election.ETAPP_TYHISTUS:
_hts = hts.HTS(self._elid)
all_, rev, res = _hts.tyhistusperioodi()
p_time = time.strftime("%H:%M:%S", \
time.gmtime(long(time.time() - s_time)))
print '%sVastuvõetud häälte koguarv: %d' % (pref, all_)
print '%sTühistatud korduvate häälte arv: %d' % \
(pref, rev)
print \
'%sHääletanute nimekirja kantud kirjete arv: %d' % \
(pref, res)
print '\nAega kulus: %s' % p_time
else:
mess = \
'Antud funktsioon on lubatud vaid tühistusperioodil'
print mess
AppLog().log_error(mess)
except:
print 'Üleminek tühistusperioodi ebaõnnestus'
AppLog().log_exception()
finally:
AppLog().log(\
'Üleminek tühistusperioodi (%s): LÕPP' % p_time)
def tyhista_ennista(self, filename):
p_time = "00:00:00"
try:
try:
s_time = time.time()
AppLog().log(\
'Tühistus-/ennistusnimekirja laadimine: ALGUS')
if ElectionState().get() == election.ETAPP_TYHISTUS:
_htsr = htsrevoke.HTSRevoke(self._elid)
all_, res_a, res_u = _htsr.tyhista_ennista(filename)
p_time = time.strftime("%H:%M:%S", \
time.gmtime(long(time.time() - s_time)))
print 'Tühistamine/ennistamine'
print '\tKirjeid kokku: %d' % all_
print '\tEdukalt töödeldud kirjeid: %d' % res_a
print '\tProbleemseid kirjeid: %d' % res_u
print '\nAega kulus: %s' % p_time
else:
mess = \
'Antud funktsioon on lubatud vaid tühistusperioodil'
print mess
AppLog().log_error(mess)
except:
print 'Tühistus-/ennistusnimekirja laadimine ebaõnnestus'
AppLog().log_exception()
finally:
AppLog().log(\
'Tühistus-/ennistusnimekirja laadimine (%s): LÕPP' % p_time)
def loendamisele_minevad_haaled(self, pref=''):
p_time = "00:00:00"
try:
try:
s_time = time.time()
AppLog().log(\
'Loendamisele minevate ' \
'häälte nimekirja koostamine: ALGUS')
if ElectionState().get() == election.ETAPP_LUGEMINE:
_hts = hts.HTS(self._elid)
g_v, b_v = _hts.lugemisperioodi()
p_time = time.strftime("%H:%M:%S", \
time.gmtime(long(time.time() - s_time)))
print '%sLoendamisele minevate häälte arv: %d' % \
(pref, g_v)
print '%sAvalduse alusel tühistatud häälte arv: %d' % \
(pref, b_v)
print '\nAega kulus: %s' % p_time
else:
mess = 'Antud funktsioon on lubatud vaid lugemisperioodil'
print mess
AppLog().log_error(mess)
except:
print 'Loendamisele minevate häälte nimekirja ' \
'koostamine ebaõnnestus'
AppLog().log_exception()
finally:
AppLog().log(\
'Loendamisele minevate häälte nimekirja ' \
'koostamine (%s): LÕPP' % p_time)
def verify(self, vote_id):
try:
AppLog().log("Vote verification: START")
if ElectionState().election_on():
return self.__all.verify(vote_id)
ret, msg = ElectionState().election_off_msg()
AppLog().log_error(msg)
return evcommon.VERIFY_ERROR, msg
except:
AppLog().log_exception()
return evcommon.VERIFY_ERROR, EvMessage().get_str(
"TECHNICAL_ERROR_VOTE_VERIFICATION",
evstrings.TECHNICAL_ERROR_VOTE_VERIFICATION)
finally:
AppLog().log("Vote verification: END")
def talleta_base64(self, data):
try:
try:
AppLog().log('Hääle talletamine: ALGUS')
if ElectionState().election_on():
return self.__all.talleta_base64(data)
r1, msg = ElectionState().election_off_msg()
AppLog().log_error(msg)
return evcommon.EVOTE_ERROR, msg
except:
AppLog().log_exception()
return evcommon.EVOTE_ERROR, \
EvMessage().get_str("TEHNILINE_VIGA_HAALE_TALLETAMISEL", \
evstrings.TEHNILINE_VIGA_HAALE_TALLETAMISEL)
finally:
AppLog().log('Hääle talletamine: LõPP')
def prepare(self, confer_name, server_root):
self.root = server_root
if not ElectionState().can_load_conf():
print 'Selles hääletuse faasis (%s) valimisinfot laadida ei saa'\
% ElectionState().str()
return False
self.reg = Election().get_sub_reg(self.elid)
AppLog().set_app(confer_name, self.elid)
AppLog().log('Valimiste failide laadimine: ALGUS')
self.quest = question.Question(self.elid, self.root, self.reg)
self.quest.reset_data()
print 'Valimised: ' + self.elid
return True
def do_restore_init_status():
if not uiutil.ask_yes_no("Kas oled kindel"):
return
if not uiutil.ask_yes_no("Initsialiseerimisel kustutatakse " + \
"antud hääled.\nKas jätkan"):
return
Election().restore_init_status()
ElectionState().init()
def haaletanud(self, ik):
try:
try:
AppLog().log('Korduvhääletuse kontroll: ALGUS')
if ElectionState().election_on():
ok, msg = self.__all.haaletanud(ik)
return True, ok, msg
r1, msg = ElectionState().election_off_msg()
AppLog().log_error(msg)
return False, False, msg
except:
AppLog().log_exception()
return False, False, \
EvMessage().get_str(\
"TEHNILINE_VIGA_KORDUVHAALETUSE_KONTROLLIL",\
evstrings.TEHNILINE_VIGA_KORDUVHAALETUSE_KONTROLLIL)
finally:
AppLog().log('Korduvhääletuse kontroll: LõPP')
def init_auth(self, phone):
try:
evlog.log("Autentimispäring: ALGUS %s" % (phone))
if not ElectionState().election_on():
r1, r2 = ElectionState().election_off_msg()
evlog.log_error('Viga operatsioonil "cand", teade "%s"' % r2)
return protocol.msg_error(r1, r2)
self.ctx().set_phone(phone)
self.ctx().generate_challenge()
service = MobileIDService()
rsp = service.init_auth(self.ctx())
if rsp._Status == 'OK':
rsp._CertificateData = rsp._CertificateData.strip()
self.ctx().save_post_auth(rsp)
alog, elog = evlogdata.get_cert_data_log(
rsp._CertificateData, 'cand/auth', True)
evlog.log('Autentimispäring (%s, %s, %s, %s)' %
(rsp._UserIDCode, rsp._UserGivenname,
rsp._UserSurname, rsp._Challenge))
evlog.log(alog)
if elog:
evlog.log_error(elog)
return protocol.msg_mobid_auth_init_ok(self.ctx().sessid(),
rsp._ChallengeID)
return self.__return_mid_error(rsp._Status)
except httplib.BadStatusLine as exc:
return self.__return_badstatusline_error(exc)
except ZSI.FaultException as exc:
return self.__return_zsi_error(exc)
except:
return self.__return_exception()
finally:
evlog.log('Autentimispäring: LÕPP')
def init_auth(self, phone):
try:
evlog.log("Autentimispäring: ALGUS %s" % (phone))
if not ElectionState().election_on():
r1, r2 = ElectionState().election_off_msg()
return protocol.msg_error(r1, r2)
self.ctx().set_phone(phone)
self.ctx().generate_challenge()
service = MobileIDService()
rsp_cert = service.get_cert(self.ctx())
if not (rsp_cert._SignCertStatus == 'OK'):
return self.__return_mid_error(rsp_cert._SignCertStatus)
if rsp_cert._AuthCertStatus == 'OK':
res, err = cert_ok(rsp_cert._AuthCertData)
if not res:
evlog.log_error(err)
return self.__return_mid_policy_error()
else:
return self.__return_mid_error(rsp_cert._AuthCertStatus)
rsp = service.init_auth(self.ctx())
if rsp._Status == 'OK':
self.ctx().save_post_auth(rsp)
evlog.log('Autentimispäring (%s, %s, %s, %s)' % \
(rsp._UserIDCode, rsp._UserGivenname, \
rsp._UserSurname, rsp._Challenge))
return protocol.msg_mobid_auth_init_ok(\
self.ctx().sessid(), rsp._ChallengeID)
return self.__return_mid_error(rsp._Status)
except httplib.BadStatusLine, exc:
return self.__return_badstatusline_error(exc)
def __init__(self):
self.quit_flag = 0
self.cmd_list = []
self.__sub0 = MenuItemSubMenu()
self.__sub1 = MenuItemSubMenu()
self.__sub2 = MenuItemSubMenu()
self.file_table = {}
self.ui_update_function = None
self.cur_elid = ""
self.file_action = ""
self.menu_caption = ""
self.state = ElectionState().get()
self.init_main_menu()
def execute():
_state = ElectionState().get()
if _state == election.ETAPP_TYHISTUS:
qlist = Election().get_questions()
for el in qlist:
_hts = htsdisp.HTSDispatcher(el)
print el
_hts.yleminek_tyhistusperioodi('\t')
elif _state == election.ETAPP_LUGEMINE:
qlist = Election().get_questions()
for el in qlist:
_hts = htsdisp.HTSDispatcher(el)
print el
_hts.loendamisele_minevad_haaled('\t')
else:
pass
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 purge_otps():
# Read the verification timeout value before defining check_otp, so we only
# have to read it once.
timeout = Election().get_verification_time() * 60
def check_otp(reg, otp, runtime):
otp_key = htscommon.get_verification_key(otp)
created = reg.read_integer_value(otp_key, "timestamp").value
return created + timeout < runtime
purger = purge.Purger("expired vote ID", htscommon.get_verification_key())
purger.work(check_otp, purge_otp)
if __name__ == '__main__':
if ElectionState().election_on():
purge_otps()
# vim:set ts=4 sw=4 et fileencoding=utf8:
def update(self):
self.state = ElectionState().get()
use_binary = self.file_action != ACTION_BROWSE_FILE
self.update_files(self.cur_elid, use_binary)
if self.ui_update_function:
self.ui_update_function()
def init_done(self): # pylint: disable=R0201
ElectionState().init()
Election().init_conf_done()
def apply_changes(elid, voter_f):
"""Muudatuste rakendamine"""
vl = None
tokend = {}
def check_state():
if not ElectionState().can_apply_changes():
sys.stderr.write('Selles hääletuse faasis (%s) pole võimalik '
'nimekirju uuendada\n'
% ElectionState().str())
sys.exit(1)
try:
buflog = None
if Election().is_hes():
root = 'hes'
elif Election().is_hts():
root = 'hts'
else:
raise Exception('Vigane serveritüüp')
buflog = BufferedLog(Election().
get_path(evcommon.VOTER_LIST_LOG_FILE),
'APPLY-CHANGES', elid)
check_state()
reg = Election().get_sub_reg(elid)
ed = inputlists.Districts()
ed.load(root, reg)
vl = inputlists.VotersList(root, reg, ed)
vl.attach_elid(elid)
vl.ignore_errors()
evlog.AppLog().set_app('APPLY-CHANGES')
vl.attach_logger(evlog.AppLog())
print "Kontrollin valijate faili terviklikkust"
checkResult = sigverify.check_existent(voter_f, elid)
if not checkResult[0]:
raise Exception('Kontrollimisel tekkis viga: %s\n' % checkResult[1])
else:
print "Valijate faili terviklikkus OK"
voters_file_sha256 = ksum.compute(voter_f)
if Election().get_root_reg().check(
['common', 'voters_file_hashes', voters_file_sha256]):
raise Exception('Kontrollsummaga %s fail on juba laaditud\n'
% voters_file_sha256)
if not vl.check_format(voter_f, 'Kontrollin valijate nimekirja: '):
print "Valijate nimekiri ei vasta vormingunõuetele"
sys.exit(1)
else:
print 'Valijate nimekiri OK'
vl.attach_logger(buflog)
if not vl.check_muudatus(
'Kontrollin muudatuste kooskõlalisust: ',
ElectionState().election_on(), tokend):
print "Sisend ei ole kooskõlas olemasoleva konfiguratsiooniga"
else:
print "Muudatuste kooskõlalisus OK"
_apply = 1
if not buflog.empty():
print 'Muudatuste sisselaadimisel esines vigu'
buflog.output_errors()
_apply = uiutil.ask_yes_no(
'Kas rakendan kooskõlalised muudatused?')
if not _apply:
buflog.log_error('Muudatusi ei rakendatud')
print 'Muudatusi ei rakendatud'
else:
if ElectionState().election_on() and root == 'hts':
create_tokend_file(tokend, reg, elid)
a_count, d_count = vl.create('Paigaldan valijaid: ')
print 'Teostasin %d lisamist ja %d eemaldamist' \
% (a_count, d_count)
Election().copy_config_file(
elid, root, voter_f, evcommon.VOTERS_FILES)
Election().add_voters_file_hash(voter_f)
print 'Muudatuste rakendamine lõppes edukalt'
except SystemExit:
sys.stderr.write('Viga muudatuste laadimisel\n')
if buflog:
buflog.output_errors()
raise
except Exception as ex:
sys.stderr.write('Viga muudatuste laadimisel: ' + str(ex) + '\n')
if buflog:
buflog.output_errors()
sys.exit(1)
finally:
if vl is not None:
vl.close()
def check_state():
if not ElectionState().can_apply_changes():
sys.stderr.write('Selles hääletuse faasis (%s) pole võimalik '
'nimekirju uuendada\n'
% ElectionState().str())
sys.exit(1)
def do_change_state(self):
if not uiutil.ask_yes_no("Kas oled kindel"):
return
ElectionState().next()
if Election().is_hts():
subprocess.call(SCRIPT_HTS_STATE)
