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 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 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']))
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)
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
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 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 __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 __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
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 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 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 as 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
def _sign_result(self, pin, input_file):
token_name = Election().get_hsm_token_name()
priv_key_label = Election().get_hsm_priv_key()
pkcs11lib = Election().get_pkcs11_path()
args = [
input_file,
_sig(input_file), token_name, priv_key_label, pin, pkcs11lib
]
exit_code = 0
try:
exit_code = subprocess.call([self.sign_prog] + args)
except OSError as oserr:
errstr = "Tulemuste faili '%s' allkirjastamine 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_SIGN_ERRORS:
errstr2 = G_SIGN_ERRORS[exit_code]
errstr = \
"Tulemuste faili '%s' allkirjastamine nurjus: %s (kood %d)" % \
(input_file, errstr2, exit_code)
evlog.log_error(errstr)
return False
errstr = "Tulemuste faili '%s' allkirjastamine nurjus (signaal %d)" % \
(input_file, exit_code)
evlog.log_error(errstr)
return False
def _sign_result_files(self, pin):
f1 = self._reg.path(['hlr', 'output', evcommon.ELECTIONRESULT_FILE])
f2 = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_STAT_FILE])
ret1 = self._sign_result(pin, f1)
ret2 = self._sign_result(pin, f2)
if (ret1 and ret2):
import zipfile
zippath = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_ZIP_FILE])
rzip = zipfile.ZipFile(zippath, "w")
rzip.write(f1, evcommon.ELECTIONRESULT_FILE)
rzip.write(_sig(f1), _sig(evcommon.ELECTIONRESULT_FILE))
rzip.write(f2, evcommon.ELECTIONRESULT_STAT_FILE)
rzip.write(_sig(f2), _sig(evcommon.ELECTIONRESULT_STAT_FILE))
if os.path.isfile(CERT_PATH) and os.access(CERT_PATH, os.R_OK):
rzip.write(CERT_PATH, CERT)
if os.path.isfile(README_PATH) and os.access(README_PATH, os.R_OK):
rzip.write(README_PATH, README)
rzip.close()
return True
else:
return False
def _add_kehtetu(self, ringkond, district):
self.__cnt.add_vote(ringkond, district, ringkond[0] + ".kehtetu")
def _check_vote(self, ringkond, district, haal, line_nr):
ret = True
if haal == CORRUPTED_VOTE:
errstr = "Häält (rida=%d) ei õnnestunud dekrüptida" % line_nr
evlog.log_error(errstr)
ret = False
else:
lst = haal.split('\n')
if ((len(lst) != 4) or (lst[0] != evcommon.VERSION)
or (lst[1] != self._elid) or (lst[3] != "")):
ret = False
else:
if not formatutil.is_valiku_kood(lst[2]):
ret = False
elif lst[2].split(".")[0] != ringkond[0]:
ret = False
if ret and self.__cnt.has_choice(ringkond, district, lst[2]):
self.__cnt.add_vote(ringkond, district, lst[2])
else:
ret = False
self._add_kehtetu(ringkond, district)
return ret
def handle_vote(self, votelst, line_nr):
try:
dist = (votelst[0], votelst[1])
ring = (votelst[2], votelst[3])
vote = base64.decodestring(votelst[5])
if not self._check_vote(ring, dist, vote, line_nr):
self._log4.log_info(tyyp=4,
haal=base64.decodestring(votelst[4]),
ringkond_omavalitsus=votelst[2],
ringkond=votelst[3])
else:
self._log5.log_info(tyyp=5,
haal=base64.decodestring(votelst[4]),
ringkond_omavalitsus=votelst[2],
ringkond=votelst[3])
return True
except:
evlog.log_exception()
return False
def _count_votes(self):
dvl = DecodedVoteList(self, self.__cnt)
dvl.attach_logger(evlog.AppLog())
dvl.attach_elid(self._elid)
if not dvl.check_format(self.output_file, 'Loen hääli: '):
evlog.log_error('Häälte lugemine ebaõnnestus')
return False
return True
def _write_result(self):
result_dist_fn = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_FILE])
out_f = file(result_dist_fn, 'w')
out_f.write(evcommon.VERSION + '\n' + self._elid + '\n')
self.__cnt.outputdist(out_f)
out_f.close()
ksum.store(result_dist_fn)
result_stat_fn = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_STAT_FILE])
out_f = file(result_stat_fn, 'w')
out_f.write(evcommon.VERSION + '\n' + self._elid + '\n')
self.__cnt.outputstat(out_f)
out_f.close()
ksum.store(result_stat_fn)
print "Hääled (%d) on loetud." % self.__cnt.count()
def _check_logs(self):
log_lines = 0
log_lines = log_lines + self._log4.lines_in_file()
log_lines = log_lines + self._log5.lines_in_file()
# remove header
log_lines = log_lines - 6
if log_lines != self.__cnt.count():
errstr = "Log4 ja Log5 ridade arv (%d) "\
"ei klapi häälte arvuga (%d)" % \
(log_lines, self.__cnt.count())
evlog.log_error(errstr)
return False
return True
def _create_logs(self):
with open(self._reg.path(['common', 'log4']), 'w') as log4_f:
log4_f.write(evcommon.VERSION + "\n")
log4_f.write(self._elid + "\n")
log4_f.write("4\n")
with open(self._reg.path(['common', 'log5']), 'w') as log5_f:
log5_f.write(evcommon.VERSION + "\n")
log5_f.write(self._elid + "\n")
log5_f.write("5\n")
return True
def run(self, pin):
try:
self.__cnt.load(self._reg)
if not self._decrypt_votes(pin):
return False
if not self._create_logs():
return False
if not self._count_votes():
return False
self._write_result()
if not self._check_logs():
return False
if not self._sign_result_files(pin):
return False
return True
except:
evlog.log_exception()
return False
class HTSBase:
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 haaletanud(self, isikukood):
latest = self.get_latest_vote(isikukood)
return latest is not None
def get_revoked_path(self, pc):
user_key = htscommon.get_user_key(pc)
return self._reg.path(user_key + ['reason'])
def get_latest_vote(self, pc):
user_key = htscommon.get_user_key(pc)
if self._reg.check(user_key):
files = self._reg.list_keys(user_key)
votes = []
for el in files:
if htscommon.VALID_VOTE_PATTERN.match(el):
votes.append(el)
votes.sort()
latest = votes.pop()
if latest:
return htscommon.get_votefile_time(latest)
return None
def restore_vote(self, revline, operator):
timest = self.get_latest_vote(revline[0])
os.unlink(self.get_revoked_path(revline[0]))
self._revlog.log_info(
tegevus='ennistamine',
isikukood=revline[0],
nimi=revline[1],
timestamp=timest,
operaator=operator,
pohjus=revline[2])
def revoke_vote(self, revline, operator):
timest = self.get_latest_vote(revline[0])
nowstr = time.strftime("%Y%m%d%H%M%S", time.localtime())
self._reg.create_string_value(
htscommon.get_user_key(revline[0]), 'reason',
"%s\t%s" % (nowstr, revline[2]))
self._revlog.log_info(
tegevus='tühistamine',
testtime=nowstr,
isikukood=revline[0],
nimi=revline[1],
timestamp=timest,
operaator=operator,
pohjus=revline[2])
def is_user_revoked(self, pc):
user_key = htscommon.get_user_key(pc)
if self._reg.check(user_key + ['reason']):
line = self._reg.read_string_value(user_key, 'reason').value
data = line.split('\t')
return True, data[1], data[0]
return False, '', ''
def save_log(self, lines, log):
fn = self._reg.path(['common', 'log%s' % log])
lf = htscommon.LoggedFile(fn)
lf.open('w')
lf.write(evcommon.VERSION + "\n")
lf.write(self._elid + "\n")
lf.write("%s\n" % log)
for el in lines:
lf.write(el + '\n')
lf.close()
def save_revocation_report(self, report):
fn = self._reg.path(['hts', 'output', evcommon.REVREPORT_FILE])
outfile = htscommon.LoggedFile(fn)
outfile.open('a')
for el in report:
outfile.write("\t".join(el) + "\n")
outfile.close()
def talletaja(self, ik):
vl = None
try:
vl = inputlists.VotersList('hts', self._reg)
if not vl.has_voter(ik):
return None
ret = vl.get_voter(ik)
return ret
finally:
if vl is not None:
vl.close()
vl = None
def main_function():
try:
if Election().is_hes():
server = 'hes'
elif Election().is_hts():
server = 'hts'
else:
raise Exception('Vigane serveri tüüp')
election_ids = Election().get_questions()
if len(election_ids) == 0:
print "Valijanimekirju pole laaditud"
else:
election_ids.sort()
for el_i in election_ids:
print "%s" % el_i
reg_i = Election().get_sub_reg(el_i, [server])
if not reg_i.check(['voters_files']):
print "\tValijanimekirju pole laaditud"
continue
file_list = reg_i.list_keys(['voters_files'])
file_list.sort()
if len(file_list) == 0:
print "\tValijanimekirju pole laaditud"
else:
prefix_len = 8 + 1 + 14 + 1
j = 1
added_total = 0
for vf_i in file_list:
file_date = vf_i[0:4] + "." + vf_i[4:6] + \
"." + vf_i[6:8] + " " + vf_i[8:10] + \
":" + vf_i[10:12] + ":" + vf_i[12:14]
file_name = vf_i[15:]
if len(file_name) > prefix_len:
file_name = file_name[prefix_len:]
print "\t%02d. %s - %s" % (j, file_date, file_name)
j += 1
# nimekirja kokkulugemine
_rf = file(reg_i.path(['voters_files', vf_i]), "r")
line = _rf.readline() # päise 1. rida
line = _rf.readline() # päise 2. rida
filetype = _rf.readline() # päise 3. rida
added = 0
removed = 0
while 1:
line = _rf.readline()
if len(line) == 0:
break
fields = line.split("\t")
if fields[2] == "lisamine":
added += 1
added_total += 1
else:
removed += 1
added_total -= 1
print \
"\t Faili tüüp: %s\n" % filetype.strip() + \
"\t Lisamisi %d, " % added + \
"eemaldamisi %d\n" % removed + \
"\t Kokku peale laadimist: %d" % added_total
except Exception, ex:
print 'Viga valijanimekirjade uuenduste ajaloo kuvamisel: ' + str(ex)
sys.exit(1)
class HTSBase:
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 haaletanud(self, isikukood):
latest = self.get_latest_vote(isikukood)
return latest <> None
def get_revoked_path(self, pc):
user_key = htscommon.get_user_key(pc)
return self._reg.path(user_key + ['reason'])
def get_latest_vote(self, pc):
user_key = htscommon.get_user_key(pc)
if self._reg.check(user_key):
files = self._reg.list_keys(user_key)
votes = []
for el in files:
if htscommon.VALID_VOTE_PATTERN.match(el):
votes.append(el)
votes.sort()
latest = votes.pop()
if latest:
return htscommon.get_votefile_time(latest)
return None
def restore_vote(self, revline, operator):
timest = self.get_latest_vote(revline[0])
os.unlink(self.get_revoked_path(revline[0]))
self._revlog.log_info(tegevus='ennistamine',
isikukood=revline[0],
nimi=revline[1],
timestamp=timest,
operaator=operator,
pohjus=revline[2])
def revoke_vote(self, revline, operator):
timest = self.get_latest_vote(revline[0])
nowstr = time.strftime("%Y%m%d%H%M%S", time.localtime())
self._reg.create_string_value(\
htscommon.get_user_key(revline[0]), 'reason', \
"%s\t%s" % (nowstr, revline[2]))
self._revlog.log_info(tegevus='tühistamine',
testtime=nowstr,
isikukood=revline[0],
nimi=revline[1],
timestamp=timest,
operaator=operator,
pohjus=revline[2])
def is_user_revoked(self, pc):
user_key = htscommon.get_user_key(pc)
if self._reg.check(user_key + ['reason']):
line = self._reg.read_string_value(user_key, 'reason').value
data = line.split('\t')
return True, data[1], data[0]
return False, '', ''
def save_log(self, lines, log):
fn = self._reg.path(['common', 'log%s' % log])
lf = htscommon.LoggedFile(fn)
lf.open('w')
lf.write(evcommon.VERSION + "\n")
lf.write(self._elid + "\n")
lf.write("%s\n" % log)
for el in lines:
lf.write(el + '\n')
lf.close()
def save_revocation_report(self, report):
fn = self._reg.path(['hts', 'output', evcommon.REVREPORT_FILE])
outfile = htscommon.LoggedFile(fn)
outfile.open('a')
for el in report:
outfile.write("\t".join(el) + "\n")
outfile.close()
def talletaja(self, ik):
vl = None
try:
vl = inputlists.VotersList('hts', self._reg)
if not vl.has_voter(ik):
return None
ret = vl.get_voter(ik)
return ret
finally:
if vl != None:
vl.close()
vl = 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 as 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
def _sign_result(self, pin, input_file):
token_name = Election().get_hsm_token_name()
priv_key_label = Election().get_hsm_priv_key()
pkcs11lib = Election().get_pkcs11_path()
args = [input_file,
_sig(input_file),
token_name,
priv_key_label,
pin,
pkcs11lib]
exit_code = 0
try:
exit_code = subprocess.call([self.sign_prog] + args)
except OSError as oserr:
errstr = "Tulemuste faili '%s' allkirjastamine 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_SIGN_ERRORS:
errstr2 = G_SIGN_ERRORS[exit_code]
errstr = \
"Tulemuste faili '%s' allkirjastamine nurjus: %s (kood %d)" % \
(input_file, errstr2, exit_code)
evlog.log_error(errstr)
return False
errstr = "Tulemuste faili '%s' allkirjastamine nurjus (signaal %d)" % \
(input_file, exit_code)
evlog.log_error(errstr)
return False
def _sign_result_files(self, pin):
f1 = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_FILE])
f2 = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_STAT_FILE])
ret1 = self._sign_result(pin, f1)
ret2 = self._sign_result(pin, f2)
if (ret1 and ret2):
import zipfile
zippath = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_ZIP_FILE])
rzip = zipfile.ZipFile(zippath, "w")
rzip.write(f1, evcommon.ELECTIONRESULT_FILE)
rzip.write(_sig(f1), _sig(evcommon.ELECTIONRESULT_FILE))
rzip.write(f2, evcommon.ELECTIONRESULT_STAT_FILE)
rzip.write(_sig(f2), _sig(evcommon.ELECTIONRESULT_STAT_FILE))
if os.path.isfile(CERT_PATH) and os.access(CERT_PATH, os.R_OK):
rzip.write(CERT_PATH, CERT)
if os.path.isfile(README_PATH) and os.access(README_PATH, os.R_OK):
rzip.write(README_PATH, README)
rzip.close()
return True
else:
return False
def _add_kehtetu(self, ringkond, district):
self.__cnt.add_vote(ringkond, district, ringkond[0] + ".kehtetu")
def _check_vote(self, ringkond, district, haal, line_nr):
ret = True
if haal == CORRUPTED_VOTE:
errstr = "Häält (rida=%d) ei õnnestunud dekrüptida" % line_nr
evlog.log_error(errstr)
ret = False
else:
lst = haal.split('\n')
if ((len(lst) != 4) or
(lst[0] != evcommon.VERSION) or
(lst[1] != self._elid) or
(lst[3] != "")):
ret = False
else:
if not formatutil.is_valiku_kood(lst[2]):
ret = False
elif lst[2].split(".")[0] != ringkond[0]:
ret = False
if ret and self.__cnt.has_choice(ringkond, district, lst[2]):
self.__cnt.add_vote(ringkond, district, lst[2])
else:
ret = False
self._add_kehtetu(ringkond, district)
return ret
def handle_vote(self, votelst, line_nr):
try:
dist = (votelst[0], votelst[1])
ring = (votelst[2], votelst[3])
vote = base64.decodestring(votelst[5])
if not self._check_vote(ring, dist, vote, line_nr):
self._log4.log_info(
tyyp=4,
haal=base64.decodestring(votelst[4]),
ringkond_omavalitsus=votelst[2],
ringkond=votelst[3])
else:
self._log5.log_info(
tyyp=5,
haal=base64.decodestring(votelst[4]),
ringkond_omavalitsus=votelst[2],
ringkond=votelst[3])
return True
except:
evlog.log_exception()
return False
def _count_votes(self):
dvl = DecodedVoteList(self, self.__cnt)
dvl.attach_logger(evlog.AppLog())
dvl.attach_elid(self._elid)
if not dvl.check_format(self.output_file, 'Loen hääli: '):
evlog.log_error('Häälte lugemine ebaõnnestus')
return False
return True
def _write_result(self):
result_dist_fn = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_FILE])
out_f = file(result_dist_fn, 'w')
out_f.write(evcommon.VERSION + '\n' + self._elid + '\n')
self.__cnt.outputdist(out_f)
out_f.close()
ksum.store(result_dist_fn)
result_stat_fn = self._reg.path(
['hlr', 'output', evcommon.ELECTIONRESULT_STAT_FILE])
out_f = file(result_stat_fn, 'w')
out_f.write(evcommon.VERSION + '\n' + self._elid + '\n')
self.__cnt.outputstat(out_f)
out_f.close()
ksum.store(result_stat_fn)
print "Hääled (%d) on loetud." % self.__cnt.count()
def _check_logs(self):
log_lines = 0
log_lines = log_lines + self._log4.lines_in_file()
log_lines = log_lines + self._log5.lines_in_file()
# remove header
log_lines = log_lines - 6
if log_lines != self.__cnt.count():
errstr = "Log4 ja Log5 ridade arv (%d) "\
"ei klapi häälte arvuga (%d)" % \
(log_lines, self.__cnt.count())
evlog.log_error(errstr)
return False
return True
def _create_logs(self):
with open(self._reg.path(['common', 'log4']), 'w') as log4_f:
log4_f.write(evcommon.VERSION + "\n")
log4_f.write(self._elid + "\n")
log4_f.write("4\n")
with open(self._reg.path(['common', 'log5']), 'w') as log5_f:
log5_f.write(evcommon.VERSION + "\n")
log5_f.write(self._elid + "\n")
log5_f.write("5\n")
return True
def run(self, pin):
try:
self.__cnt.load(self._reg)
if not self._decrypt_votes(pin):
return False
if not self._create_logs():
return False
if not self._count_votes():
return False
self._write_result()
if not self._check_logs():
return False
if not self._sign_result_files(pin):
return False
return True
except:
evlog.log_exception()
return False
