95 lines
3.5 KiB
Python
95 lines
3.5 KiB
Python
import argparse # standaard libary
|
|
from Crypto.PublicKey import RSA # pycryptodome, eventueel downloaden met pip
|
|
from Crypto.Hash import SHA256
|
|
from Crypto.Signature import pkcs1_15
|
|
|
|
# Als dit niet object georienteerd programmeren is weet ik het ook niet meer -Taha Genc
|
|
|
|
def parse_args():
|
|
"""
|
|
parseer argumenten, let op dit werkt alleen als de script is aangeroepen met python!
|
|
"""
|
|
parser = argparse.ArgumentParser(description='Sign bestanden met keys')
|
|
parser.add_argument('input', help='Set input bestand wat gesigned moet worden') # verplicht!
|
|
parser.add_argument('-o', '--output', default=None, help="Set output signature, standaard 'inputbestand.ext.signature'") # optioneel
|
|
parser.add_argument('-p', '--privatekey', default='private.pem', help='Set privatekey, standaard private.pem') # eventueel andere privatekey
|
|
|
|
return parser.parse_args()
|
|
|
|
def check_output(out, input):
|
|
if out == None: # als output standaard behouden wordt
|
|
name = '' # maak lege naam aan
|
|
|
|
list = input.split('.')[:-1] # split naam op basis van punten en sla alleen alle waardes behalve de laatste op in een list, echt niet elegant maar het werkt
|
|
|
|
for x in list: # iterate list met waardes
|
|
name = name + x + '.' # maak weer een gehele string met punten
|
|
|
|
return name + 'signature' # append signature achter de naam
|
|
else: # output is geherdefinieerd
|
|
return out
|
|
|
|
def import_privatekey(private_key_loc):
|
|
"""
|
|
private_key_loc: bestands locatie van de private key
|
|
return: RSA pkey object
|
|
|
|
functie om de privatekey te openen en direct te importeren in een RSA object
|
|
"""
|
|
return RSA.import_key(open(private_key_loc).read())
|
|
|
|
def open_tobesigned(input_loc):
|
|
"""
|
|
input_loc: bestands locate van het bestand wat ondertekent moet worden
|
|
return: binary inhoud van bestand
|
|
|
|
functie opent bestand als binary
|
|
"""
|
|
with open(input_loc, 'rb') as file:
|
|
return file.read()
|
|
|
|
def generate_hash(data):
|
|
"""
|
|
data: binary data
|
|
return: binary hash
|
|
|
|
genereert sha256 hash op basis van binary data
|
|
"""
|
|
return SHA256.new(data)
|
|
|
|
def generate_signature(pkey, hash):
|
|
"""
|
|
pkey: private key in RSA object formaat
|
|
hash: hash wat gesigned moet worden in binary formaat
|
|
return: binary signature data
|
|
|
|
genereert een signature op basis van de hash en private key
|
|
"""
|
|
return pkcs1_15.new(pkey).sign(hash)
|
|
|
|
def save_signature(output_loc, data):
|
|
"""
|
|
output_loc: bestands locatie waar de binary signature moet worden opgeslagen
|
|
data: binary signature data
|
|
return: niets
|
|
|
|
slaat binair de signature data op in bestand
|
|
"""
|
|
with open(output_loc, 'wb') as file:
|
|
file.write(bytes(data))
|
|
return
|
|
|
|
def main(input_loc, output_loc, private_key_loc):
|
|
"""
|
|
De hoofdfunctie wat wordt aangeroepen
|
|
1. Open privatekey
|
|
2. Open bestand
|
|
3. Genereer hash van bestand
|
|
4. Genereer signature van hash met privatekey
|
|
5. Sla signature op in bestand
|
|
"""
|
|
save_signature(output_loc, generate_signature(import_privatekey(private_key_loc), generate_hash(open_tobesigned(input_loc)))) # wat een oneliner wow
|
|
|
|
if __name__ == "__main__":
|
|
options = parse_args() # haal argumenten op
|
|
main(options.input, check_output(options.output, options.input), options.privatekey) # roep main functie aan met gekregen argumenten |