From 03f3933d32930f05747609489ffc630b7be129b9 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Tue, 25 Apr 2017 22:10:17 +0200
Subject: [PATCH 01/46] Fist python script alpha release

---
 gpgit.py | 816 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 816 insertions(+)
 create mode 100755 gpgit.py

diff --git a/gpgit.py b/gpgit.py
new file mode 100755
index 0000000..737a8a9
--- /dev/null
+++ b/gpgit.py
@@ -0,0 +1,816 @@
+#!/usr/bin/env python3
+
+from __future__ import print_function
+import os
+import sys
+import argparse
+import tempfile
+import filecmp
+import hashlib
+import gzip
+import lzma
+import bz2
+from github import Github
+import git
+from git import Repo
+import gnupg
+
+
+# TODO: check == True to is True
+# TODO proper document functions with """ to generate __docnames___
+# TODO pylint analysis
+# TODO add zip and lz support, make xz default
+# TODO swap step 4.2 and 4.3
+# TODO remove returns after self.error as it already exits
+# TODO document compression level default: gzip/bz2 max and lzma/xz 6. see note about level 6 https://docs.python.org/3/library/lzma.html
+# TODO replace armorfrom true/false to .sig/.asc?
+
+class colors(object):
+    RED   = "\033[1;31m"
+    BLUE  = "\033[1;34m"
+    CYAN  = "\033[1;36m"
+    MAGENTA = "\033[1;35m"
+    YELLOW = "\033[1;33m"
+    GREEN = "\033[1;32m"
+    UNDERLINE = '\033[4m'
+    BOLD    = "\033[;1m"
+    REVERSE = "\033[;7m"
+    RESET = "\033[0;0m"
+
+class Substep(object):
+    color = {
+        'OK': colors.GREEN,
+        'FAIL': colors.RED,
+        'INFO': colors.YELLOW,
+        'WARN': colors.YELLOW,
+        'TODO': colors.MAGENTA,
+        'NOTE': colors.BLUE,
+        }
+
+    def __init__(self, number, name, funct):
+        # Params
+        self.number = number
+        self.name = name
+        self.funct = funct
+
+        # Default values
+        self.status = 'FAIL'
+        self.msg = 'Aborting due to previous errors'
+        self.infos = []
+
+    def setstatus(self, status, msg, infos):
+        self.status = status
+        self.msg = msg
+        self.infos = infos
+
+    def printstatus(self):
+        # Check if status is known
+        if self.status not in self.color:
+            raise SystemError('Internal error. Please report this issue.')
+
+        # Sample: "1.2 [ OK ] Key already generated"
+        print(colors.BOLD + '  ' + self.number, self.color[self.status] + '[' + self.status.center(4) + ']' + colors.RESET, self.msg)
+
+        # Sample: " -> [INFO] GPG key: [rsa4096] 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161"
+        for info in self.infos:
+            print(colors.BOLD + '   -> ' + self.color['INFO'] + '[INFO]' + colors.RESET, info)
+
+        # Check for error
+        if self.status == 'FAIL':
+            return True
+
+    def run(self):
+        # Run selected step function if activated
+        if self.status == 'TODO':
+            # Sample: "  -> Will associate your GPG key with Github"
+            print(colors.BLUE + "  ->", colors.BOLD + self.msg + colors.RESET)
+            return self.funct()
+
+class Step(object):
+    def __init__(self, number, name, substeps):
+        # Params
+        self.number = number
+        self.name = name
+        self.substeps = substeps
+
+    def printstatus(self):
+        # Sample: "1. Generate a new GPG key"
+        print(colors.BOLD + self.number, self.name + colors.RESET)
+        err = False
+        for substep in self.substeps:
+            if substep.printstatus():
+                err = True
+        return err
+
+    def run(self):
+        # Run all substeps if enabled
+        # Sample: "==> 2. Publish your key"
+        print(colors.GREEN + "==>", colors.BOLD + self.number, self.name + colors.RESET)
+        for substep in self.substeps:
+            if substep.run():
+                return True
+
+# Helper class to compare a stream without writing
+class strmcmp(object):
+    def __init__(self, strmcmp):
+        self.strmcmp = strmcmp
+        self.__equal = True
+    def write(self, data):
+        if data != self.strmcmp.read(len(data)):
+            self.__equal = False
+    def equal(self):
+        # Check end of file too
+        if self.strmcmp.read(1) == b'' and self.__equal:
+            return True
+
+class GPGit(object):
+    # RFC4880 9.1.  Public-Key Algorithms
+    gpgAlgorithmIDs = {
+        '1': 'RSA',
+        '2': 'RSA Encrypt-Only',
+        '3': 'RSA Sign-Only',
+        '17': 'DSA',
+        '18': 'Elliptic Curve',
+        '19': 'ECDSA',
+        '21': 'DH',
+        }
+
+    # TODO add elliptic curve support
+    gpgSecureAlgorithmIDs = [ '1', '3' ]
+    gpgSecureKeyLength = [ '2048', '4096' ]
+
+    compressionAlgorithms = {
+        'gz': gzip,
+        'gzip': gzip,
+        'xz': lzma,
+        'bz2': bz2,
+        'bzip2': bz2,
+    }
+
+    def __init__(self, config):
+        self.Steps = [
+            Step('1.', 'Generate a new GPG key', [
+                Substep('1.1', 'Strong, unique, secret passphrase', self.step_1_1),
+                Substep('1.2', 'Key generation', self.step_1_2),
+                ]),
+            Step('2.', 'Publish your key', [
+                Substep('2.1', 'Submit your key to a key server', self.step_2_1),
+                Substep('2.2', 'Associate GPG key with Github', self.step_2_2),
+                Substep('2.3', 'Publish your full fingerprint', self.step_2_3),
+                ]),
+            Step('3.', 'Usage of GPG by git', [
+                Substep('3.1', 'Configure git GPG key', self.step_3_1),
+                Substep('3.2', 'Commit signing', self.step_3_2),
+                Substep('3.3', 'Create signed git tag', self.step_3_3),
+                ]),
+            Step('4.', 'Creation of a signed compressed release archive', [
+                Substep('4.1', 'Create compressed archive', self.step_4_1),
+                Substep('4.2', 'Sign the sources', self.step_4_2),
+                Substep('4.3', 'Create the message digest', self.step_4_3),
+                ]),
+            Step('5.', 'Upload the release', [
+                Substep('5.1', 'Github', self.step_5_1),
+                Substep('5.2', 'Configure HTTPS for your download server', self.step_5_2),
+                ])
+            ]
+
+        self.config = config
+        #self.config['signingkey'] = None
+        # self.config['gpgsign'] = None
+
+
+        self.gpg = gnupg.GPG()
+        self.gpgkey = None
+        self.repo = None
+
+        # Expand hash info list
+        self.hash = {}
+        for sha in self.config['sha']:
+            self.hash[sha] = {}
+
+    def load_defaults(self):
+        # Create git repository instance
+        try:
+            self.repo = Repo(self.config['git_dir'], search_parent_directories=True)
+        except git.exc.InvalidGitRepositoryError:
+            self.error('Not inside a git directory: ' + self.config['git_dir'])
+        reader = self.repo.config_reader()
+
+        gitconfig = [
+            ['username', 'user', 'name'],
+            ['email', 'user', 'email'],
+            ['signingkey', 'user', 'signingkey'],
+            ['gpgsign', 'commit', 'gpgsign'],
+            ['output', 'user', 'gpgitoutput'],
+            ['token', 'user', 'githubtoken']
+        ]
+
+        # Read in git config values
+        for config in gitconfig:
+            # Create not existing keys
+            if config[0] not in self.config:
+                self.config[config[0]] = None
+
+            # Check if gitconfig provides a setting
+            if self.config[config[0]] is None and reader.has_option(config[1], config[2]):
+                val = reader.get_value(config[1], config[2])
+                if type(val) == int:
+                    val = str(val)
+                self.config[config[0]] = val
+
+        # Get default git signing key
+        if self.config['fingerprint'] is None and self.config['signingkey']:
+            self.config['fingerprint'] = self.config['signingkey']
+
+        # Check if Github URL is used
+        if self.config['github'] is True:
+            if 'github' not in self.repo.remotes.origin.url.lower():
+                self.config['github'] = False
+
+        # Default message
+        if self.config['message'] is None:
+            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit\nhttps://github.com/NicoHood/gpgit'
+
+        # Default output path
+        if self.config['output'] is None:
+            self.config['output'] = os.path.join(self.repo.working_tree_dir, 'archive')
+
+        # Check if path exists
+        if not os.path.isdir(self.config['output']):
+            self.error('Not a valid path: ' + self.config['output'])
+
+        # Set default project name
+        if self.config['project'] is None:
+            self.config['project'] = os.path.basename(self.repo.remotes.origin.url).replace('.git','')
+
+        # Default config level (repository == local)
+        self.config['config_level'] = 'repository'
+
+        # Ask for Github token
+        #TODO
+        #if self.config['token'] is None:
+        #    self.config['token'] = input('Enter Github token to access release API: ')
+
+        # Create Github API instance
+        #TODO
+        # self.github = Github(self.config['token'])
+        #
+        # print(dir(self.github))
+        # self.githubuser = self.github.get_user()
+        # self.githubrepo = self.githubuser.get_repo(self.config['project'])
+        # rel = self.githubrepo.get_release(self.config['tag'])
+        # print(rel, dir(rel))
+
+    def set_substep_status(self, number, status, msg, infos=[]):
+        # Search for substep by number and add new data
+        for step in self.Steps:
+            for substep in step.substeps:
+                if substep.number == number:
+                    # Only overwrite if entry is relevant
+                    if substep.status != 'TODO' or status == 'FAIL':
+                        substep.setstatus(status, msg, infos)
+                    return
+        raise SystemError('Internal error. Please report this issue.')
+
+    def analyze(self):
+        # Checks to execute
+        checks = [
+            ['Analyzing gpg key', self.analyze_step_1],
+            ['Receiving key from keyserver', self.analyze_step_2],
+            ['Analyzing git settings', self.analyze_step_3],
+            ['Analyzing existing archives/signatures/message digests', self.analyze_step_4],
+            ['Analyzing server settings', self.analyze_step_5],
+            ]
+
+        # Execute checks and print status
+        for check in checks:
+            print(check[0], end='...', flush=True)
+            err = check[1]()
+            print('\r\033[K', end='')
+            if err:
+                return True
+
+    def analyze_step_1(self):
+        # Get private keys
+        private_keys = self.gpg.list_keys(True)
+        for key in private_keys:
+            # Check key algorithm gpgit support
+            if key['algo'] not in self.gpgAlgorithmIDs:
+                raise SystemError('Unknown key algorithm. Please report this issue. ID: ' + key['algo'])
+            else:
+                key['algoname'] = self.gpgAlgorithmIDs[key['algo']]
+
+        # Check if a fingerprint was selected/found
+        if self.config['fingerprint'] is None:
+            # Check if gpg keys are available, but not yet configured
+            if private_keys is not None:
+                # TODO fancier print
+                print('\r\033[K', end='')
+                print("GPG seems to be already configured on your system but git is not.")
+                print('Please select one of the existing keys below or generate a new one:')
+                print()
+
+                # Print option menu
+                print('0: Generate a new RSA 4096 key')
+                for i, key in enumerate(private_keys, start=1):
+                    print(str(i) + ':', key['fingerprint'], key['uids'][0], key['algoname'], key['length'])
+
+                # User input
+                # TODO cannot do ctrl + c
+                userinput = -1
+                while userinput < 0 or userinput > len(private_keys):
+                    try:
+                        userinput = int(input("Please select a key number from above: "))
+                    except:
+                        userinput = -1
+                print()
+
+                # Safe new fingerprint
+                if userinput != 0:
+                    self.config['fingerprint'] = private_keys[userinput - 1]['fingerprint']
+
+        # Validate selected gpg key
+        if self.config['fingerprint'] is not None:
+            # Check if the full fingerprint is used
+            if len(self.config['fingerprint']) != 40:
+                self.set_substep_status('1.2', 'FAIL',
+                    'Please specify the full fingerprint',
+                    ['GPG ID: ' + self.config['fingerprint']])
+                return True
+
+            # Find selected key
+            for key in private_keys:
+                if key['fingerprint'] == self.config['fingerprint']:
+                    self.gpgkey = key
+                    break;
+
+            # Check if key is available in keyring
+            if self.gpgkey is None:
+                self.set_substep_status('1.2', 'FAIL',
+                    'Selected key is not available in keyring',
+                    ['GPG ID: ' + self.config['fingerprint']])
+                return True
+
+            # Check key algorithm security
+            if self.gpgkey['algo'] not in self.gpgSecureAlgorithmIDs \
+                    or self.gpgkey['length'] not in self.gpgSecureKeyLength:
+                self.set_substep_status('1.2', 'FAIL',
+                    'Insecure key algorithm used: '
+                    + self.gpgkey['algoname'] + ' '
+                    + self.gpgkey['length'],
+                    ['GPG ID: ' + self.config['fingerprint']])
+                return True
+
+            # Check key algorithm security
+            if self.gpgkey['trust'] == 'r':
+                self.set_substep_status('1.2', 'FAIL',
+                    'Selected key is revoked',
+                    ['GPG ID: ' + self.config['fingerprint']])
+                return True
+
+            # Use selected key
+            self.set_substep_status('1.2', 'OK',
+                'Key already generated', [
+                    'GPG key: ' + self.gpgkey['uids'][0],
+                    'GPG ID: [' + self.gpgkey['algoname'] + ' '
+                    + self.gpgkey['length'] + '] ' + self.gpgkey['fingerprint']
+                    + ' '
+                ])
+
+            # Warn about strong passphrase
+            self.set_substep_status('1.1', 'NOTE',
+                'Please use a strong, unique, secret passphrase')
+
+        else:
+            # Generate a new key
+            self.set_substep_status('1.2', 'TODO',
+                'Generating an RSA 4096 GPG key for '
+                + self.config['username']
+                + ' ' + self.config['email']
+                + ' valid for 3 years.')
+
+            # Warn about strong passphrase
+            self.set_substep_status('1.1', 'TODO',
+                'Please use a strong, unique, secret passphrase')
+
+    def analyze_step_2(self):
+        # Add publish note
+        self.set_substep_status('2.3', 'NOTE',
+            'Please publish the full GPG fingerprint on your project page')
+
+        # Check Github GPG key
+        if self.config['github'] == True:
+            # TODO Will associate your GPG key with Github
+            self.set_substep_status('2.2', 'NOTE',
+                'Please associate your GPG key with Github')
+        else:
+            self.set_substep_status('2.2', 'OK',
+                'No Github repository used')
+
+        if self.config['fingerprint'] is None:
+            self.set_substep_status('2.3', 'TODO',
+                'Please publish the full GPG fingerprint on your project page')
+        else:
+            self.set_substep_status('2.3', 'NOTE',
+                'Please publish the full GPG fingerprint on your project page')
+
+        # Only check if a fingerprint was specified
+        if self.config['fingerprint'] is not None:
+            # Check key on keyserver
+            # TODO catch receive exception
+            # TODO add timeout
+            # https://stackoverflow.com/questions/366682/how-to-limit-execution-time-of-a-function-call-in-python
+            key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
+
+            # Found key on keyserver
+            if self.config['fingerprint'] in key.fingerprints:
+                self.set_substep_status('2.1', 'OK',
+                    'Key already published on ' + self.config['keyserver'])
+                return
+
+        # Upload key to keyserver
+        self.set_substep_status('2.1', 'TODO',
+            'Publishing key on ' + self.config['keyserver'])
+
+    def analyze_step_3(self):
+        # Check if git was already configured with the gpg key
+        if self.config['signingkey'] != self.config['fingerprint'] \
+                or self.config['fingerprint'] is None:
+            # Check if git was already configured with a different key
+            if self.config['signingkey'] is None:
+                self.config['config_level'] = 'global'
+
+            self.set_substep_status('3.1', 'TODO',
+                'Configuring ' + self.config['config_level']
+                + ' git settings with your GPG key')
+        else:
+            self.set_substep_status('3.1', 'OK',
+                'Git already configured with your GPG key')
+
+        # Check commit signing
+        if self.config['gpgsign'] == True:
+            self.set_substep_status('3.2', 'OK',
+                'Commit signing already enabled')
+        else:
+            self.set_substep_status('3.2', 'TODO',
+                'Enabling ' + self.config['config_level']
+                + ' git settings with commit signing')
+
+        # Check if tag was already created
+        # TODO refresh tags?
+        if self.repo.tag('refs/tags/' + self.config['tag']) in self.repo.tags:
+            # Verify signature
+            try:
+                self.repo.create_tag(self.config['tag'],
+                    verify=True,
+                    ref=None)
+                # # Check if every added file has been commited TODO
+                # if ! git diff --cached --exit-code &>/dev/null; then
+                #     print_step "INFO" 'You have added new changes but did not commit them yet. See "git status" or "git diff"'
+                # fi
+            except:
+                self.set_substep_status('3.3', 'FAIL',
+                    'Invalid signature for tag ' + self.config['tag'] + '. Was the tag even signed?')
+                return True
+            else:
+                self.set_substep_status('3.3', 'OK',
+                    'Good signature for existing tag ' + self.config['tag'])
+        else:
+            self.set_substep_status('3.3', 'TODO',
+                'Creating signed tag ' + self.config['tag'] + ' and pushing it to the remote git')
+
+    def analyze_step_4(self):
+        # Check all compression option tar files
+        filename = self.config['project'] + '-' + self.config['tag']
+        for tar in self.config['tar']:
+            # Get tar filename
+            tarfile = filename + '.tar.' + tar
+            tarfilepath = os.path.join(self.config['output'], tarfile)
+
+            # Check if compressed tar files exist
+            if os.path.isfile(tarfilepath):
+                # TODO multiple compression algorithms
+                # Verify existing archive
+                try:
+                    with self.compressionAlgorithms[tar].open(tarfilepath, "rb") as tarstream:
+                        cmptar = strmcmp(tarstream)
+                        self.repo.archive(cmptar, treeish=self.config['tag'], prefix=filename + '/', format='tar')
+                        if not cmptar.equal():
+                            self.set_substep_status('4.1', 'FAIL',
+                                'Existing archive differs from local source', [tarfilepath])
+                            return True
+                except lzma.LZMAError:
+                    self.set_substep_status('4.1', 'FAIL',
+                        'Archive not in ' + tar + ' format', [tarfilepath])
+                    return True
+
+                # Successfully verified
+                self.set_substep_status('4.1', 'OK',
+                    'Existing archive(s) verified successfully', ['Path: ' + self.config['output'], 'Basename: ' + filename])
+            else:
+                self.set_substep_status('4.1', 'TODO',
+                    'Creating new release archive(s)', ['Path: ' + self.config['output'], 'Basename: ' + filename])
+
+            # Get signature filename from setting
+            if self.config['no_armor']:
+                sigfilepath = tarfilepath + '.sig'
+            else:
+                sigfilepath = tarfilepath + '.asc'
+
+            # Check if signature is existant
+            if os.path.isfile(sigfilepath):
+                # Check if signature for tar exists
+                if not os.path.isfile(tarfilepath):
+                    self.set_substep_status('4.2', 'FAIL',
+                        'Signature found without corresponding archive',
+                        [sigfilepath])
+                    return True
+
+                # Verify signature
+                with open(sigfilepath, "rb") as sig:
+                    verified = self.gpg.verify_file(sig, tarfilepath)
+                    # Check trust level and fingerprint match
+                    if verified.trust_level is None \
+                            or verified.trust_level < verified.TRUST_FULLY \
+                            or verified.fingerprint != self.config['fingerprint']:
+                        if verified.trust_text is None:
+                            verified.trust_text = 'Invalid signature'
+                        self.set_substep_status('4.2', 'FAIL',
+                            'Signature could not be verified successfully with gpg',
+                            [sigfilepath, 'Trust level: ' + verified.trust_text])
+                        return True
+
+                # Successfully verified
+                self.set_substep_status('4.2', 'OK',
+                    'Existing signature(s) verified successfully')
+            else:
+                self.set_substep_status('4.2', 'TODO',
+                    'Creating GPG signature(s) for archive(s)')
+
+            # Verify all selected shasums if existant
+            for sha in self.config['sha']:
+                shafilepath = tarfilepath + '.' + sha
+
+                # Calculate hash of tarfile
+                if os.path.isfile(tarfilepath):
+                    hash_sha = hashlib.new(sha)
+                    with open(tarfilepath, "rb") as f:
+                        for chunk in iter(lambda: f.read(4096), b""):
+                            hash_sha.update(chunk)
+                    self.hash[sha][tarfile] = hash_sha.hexdigest()
+
+                # Check if hash already exists
+                if os.path.isfile(shafilepath):
+                    # Check if tar for hash exists
+                    if not os.path.isfile(tarfilepath):
+                        self.set_substep_status('4.3', 'FAIL',
+                            'Message digest found without corresponding archive',
+                            [shafilepath])
+                        return True
+
+                    # Read hash and filename
+                    with open(shafilepath, "r") as f:
+                        hashinfo = f.readline().split()
+
+                    # Verify hash
+                    if len(hashinfo) != 2 \
+                            or self.hash[sha][tarfile] != hashinfo[0] \
+                            or os.path.basename(hashinfo[1]) != tarfile:
+                        self.set_substep_status('4.3', 'FAIL',
+                            'Message digest could not be successfully verified',
+                            [shafilepath])
+                        return True
+
+                    # Successfully verified
+                    self.set_substep_status('4.3', 'OK',
+                        'Existing message digest(s) verified successfully')
+                else:
+                    self.set_substep_status('4.3', 'TODO',
+                        'Creating message digest(s) for archive(s)')
+
+    def analyze_step_5(self):
+        # Check Github GPG key
+        if self.config['github'] == True:
+            # TODO Check github API
+            self.set_substep_status('5.1', 'TODO',
+                'Uploading release files to Github')
+            self.set_substep_status('5.2', 'OK',
+                'Github uses well configured https')
+        else:
+            self.set_substep_status('5.1', 'NOTE',
+                'Please upload the compressed archive, signature and message digest manually')
+            self.set_substep_status('5.2', 'NOTE',
+                'Please configure HTTPS for your download server')
+
+    # Strong, unique, secret passphrase
+    def step_1_1(self):
+        print('More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
+
+    # Key generation
+    def step_1_2(self):
+        #TODO
+        pass
+
+    # Submit your key to a key server
+    def step_2_1(self):
+        self.gpg.send_keys(self.config['keyserver'], self.config['fingerprint'])
+
+    # Associate GPG key with Github
+    def step_2_2(self):
+        pass
+
+    # Publish your full fingerprint
+    def step_2_3(self):
+        print('Your fingerprint is:', self.config['fingerprint'])
+
+    # Configure git GPG key
+    def step_3_1(self):
+        # Configure git signingkey settings
+        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
+            cw.set("user", "signingkey", self.config['fingerprint'])
+
+    # Commit signing
+    def step_3_2(self):
+        # Configure git signingkey settings
+        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
+            cw.set("commit", "gpgsign", True)
+
+    # Create signed git tag
+    def step_3_3(self):
+        try:
+            self.repo.create_tag(self.config['tag'],
+                message=self.config['message'],
+                sign=True,
+                local_user=self.config['fingerprint'])
+        except:
+            self.error("Signing tag failed")
+            return True
+
+    # Create compressed archive
+    def step_4_1(self):
+        # Check all compression option tar files
+        filename = self.config['project'] + '-' + self.config['tag']
+        for tar in self.config['tar']:
+            # Get tar filename
+            tarfile = filename + '.tar.' + tar
+            tarfilepath = os.path.join(self.config['output'], tarfile)
+
+            # Create compressed tar files if it does not exist
+            if not os.path.isfile(tarfilepath):
+                print(':: Creating', tarfilepath)
+                with self.compressionAlgorithms[tar].open(tarfilepath, 'wb') as tarstream:
+                    self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/', format='tar')
+
+    # Sign the sources
+    def step_4_2(self):
+        # Check all compression option tar files
+        filename = self.config['project'] + '-' + self.config['tag']
+        for tar in self.config['tar']:
+            # Get tar filename
+            tarfile = filename + '.tar.' + tar
+            tarfilepath = os.path.join(self.config['output'], tarfile)
+
+            # Get signature filename from setting
+            if self.config['no_armor']:
+                sigfilepath = tarfilepath + '.sig'
+            else:
+                sigfilepath = tarfilepath + '.asc'
+
+            # Check if signature is existant
+            if not os.path.isfile(sigfilepath):
+                # Sign tar file
+                with open(tarfilepath, 'rb') as tarstream:
+                    print(':: Creating', sigfilepath)
+                    signed_data = self.gpg.sign_file(
+                        tarstream,
+                        keyid=self.config['fingerprint'],
+                        binary=bool(self.config['no_armor']),
+                        detach=True,
+                        output=sigfilepath,
+                        #digest_algo='SHA512' #TODO v 2.x gpg module
+                        )
+                    if signed_data.fingerprint != self.config['fingerprint']:
+                        self.error('Signing data failed')
+                    # TODO https://tools.ietf.org/html/rfc4880#section-9.4
+                    #print(signed_data.hash_algo) -> 8 -> SHA256
+
+    # Create the message digest
+    def step_4_3(self):
+        # Check all compression option tar files
+        filename = self.config['project'] + '-' + self.config['tag']
+        for tar in self.config['tar']:
+            # Get tar filename
+            tarfile = filename + '.tar.' + tar
+            tarfilepath = os.path.join(self.config['output'], tarfile)
+
+            # Verify all selected shasums if existant
+            for sha in self.config['sha']:
+                # Check if hash already exists
+                shafilepath = tarfilepath + '.' + sha
+                if not os.path.isfile(shafilepath):
+
+                    # Calculate hash of tarfile
+                    if tarfile not in self.hash[sha]:
+                        hash_sha = hashlib.new(sha)
+                        with open(tarfilepath, "rb") as f:
+                            for chunk in iter(lambda: f.read(4096), b""):
+                                hash_sha.update(chunk)
+                        self.hash[sha][tarfile] = hash_sha.hexdigest()
+
+                    # Write cached hash and filename
+                    print(':: Creating', shafilepath)
+                    with open(shafilepath, "w") as f:
+                        f.write(self.hash[sha][tarfile] + '  ' + tarfile)
+
+    # Github
+    def step_5_1(self):
+        pass
+
+    # Configure HTTPS for your download server
+    def step_5_2(self):
+        pass
+
+    def printstatus(self):
+        # Print the status tree
+        err = False
+        for step in self.Steps:
+            if step.printstatus():
+                err = True
+        if err:
+            self.error('Exiting due to previous errors')
+        return err
+
+    def run(self):
+        # Execute all steps
+        for step in self.Steps:
+            if step.run():
+                self.error('Executing step failed')
+                return True
+
+    def error(self, msg):
+        print(colors.RED + '==> Error:' + colors.RESET, msg)
+        sys.exit(1)
+
+
+def main(arguments):
+    parser = argparse.ArgumentParser(description=
+    'A Python script that automates the process of signing git sources via GPG')
+    parser.add_argument('tag', action='store', help='Tagname')
+    parser.add_argument('-v', '--version', action='version', version='GPGit 2.0.0')
+    parser.add_argument('-m', '--message', action='store', help='tag message')
+    parser.add_argument('-o', '--output', action='store', help='output path of the compressed archive, signature and message digest')
+    parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(), help='path of the git project')
+    parser.add_argument('-f', '--fingerprint', action='store', help='(full) GPG fingerprint to use for signing/verifying')
+    parser.add_argument('-p', '--project', action='store', help='name of the project, used for archive generation')
+    parser.add_argument('-e', '--email', action='store', help='email used for gpg key generation')
+    parser.add_argument('-u', '--username', action='store', help='username used for gpg key generation')
+    parser.add_argument('-c', '--comment', action='store', help='comment used for gpg key generation')
+    parser.add_argument('-k', '--keyserver', action='store', default='hkps://hkps.pool.sks-keyservers.net', help='keyserver to use for up/downloading gpg keys')
+    parser.add_argument('-n', '--no-github', action='store_false', dest='github', help='disable Github API functionallity')
+    parser.add_argument('-t', '--tar', choices=['gz', 'gzip', 'xz', 'bz2', 'bzip2'], default=['xz'], nargs='+', help='compression option')
+    parser.add_argument('-s', '--sha', choices=['sha256', 'sha384', 'sha512'], default=['sha512'], nargs='+', help='message digest option')
+    parser.add_argument('-b', '--no-armor', action='store_true', help='do not create ascii armored signature output')
+
+    args = parser.parse_args()
+
+    # TODO debug
+    #print(vars(args))
+
+    gpgit = GPGit(vars(args))
+    gpgit.load_defaults()
+    gpgit.analyze()
+    gpgit.printstatus()
+    print()
+    # TODO user selection
+    # TODO check if even something needs to be done
+    input('Continue with the selected operations? [Y/n]')
+    print()
+    gpgit.run()
+
+
+
+    # rorepo is a Repo instance pointing to the git-python repository.
+    # For all you know, the first argument to Repo is a path to the repository
+    # you want to work with
+    # path = '.'
+    # repo = Repo(path, search_parent_directories=True)
+    # assert not repo.bare
+    # reader = repo.config_reader()             # get a config reader for read-only access
+    # with repo.config_writer():       # get a config writer to change configuration
+    #     pass                         # call release() to be sure changes are written and locks are released
+    # with repo.config_writer() as cw:
+    #     # TODO catch new section error
+    #     cw.set("gpgit", "test", "test")
+    #
+    # print(reader.sections())
+    # print(reader.get_value('user', 'email'))
+    # for entry in reader:
+    #     print(entry)
+    # #print(repo.untracked_files)
+    # print(repo.config_level)
+    #
+    # print("done")
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))

From bccbd7b5f5016b26d66409974bddaf8ffa690be0 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Tue, 25 Apr 2017 22:16:05 +0200
Subject: [PATCH 02/46] Added user input check

---
 gpgit.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 737a8a9..79c05c7 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -494,6 +494,7 @@ def analyze_step_4(self):
                 try:
                     with self.compressionAlgorithms[tar].open(tarfilepath, "rb") as tarstream:
                         cmptar = strmcmp(tarstream)
+                        # TODO catch error when archive exists but no tag --> compare wont work
                         self.repo.archive(cmptar, treeish=self.config['tag'], prefix=filename + '/', format='tar')
                         if not cmptar.equal():
                             self.set_substep_status('4.1', 'FAIL',
@@ -783,9 +784,12 @@ def main(arguments):
     print()
     # TODO user selection
     # TODO check if even something needs to be done
-    input('Continue with the selected operations? [Y/n]')
-    print()
-    gpgit.run()
+    ret = input('Continue with the selected operations? [Y/n]')
+    if ret == 'y' or ret == '':
+        print()
+        #gpgit.run()
+    else:
+        gpgit.error('Aborted by user')
 
 
 

From b86a7db767134fffa9663ae56edcbf146c354ceb Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 18:45:45 +0200
Subject: [PATCH 03/46] Check for Github assets and stop if nothing todo

---
 gpgit.py | 99 ++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 68 insertions(+), 31 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 79c05c7..0ae5098 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -179,6 +179,11 @@ def __init__(self, config):
         # self.config['gpgsign'] = None
 
 
+        self.assets = []
+        self.newassets = []
+        self.todo = False
+
+
         self.gpg = gnupg.GPG()
         self.gpgkey = None
         self.repo = None
@@ -246,22 +251,11 @@ def load_defaults(self):
         # Default config level (repository == local)
         self.config['config_level'] = 'repository'
 
-        # Ask for Github token
-        #TODO
-        #if self.config['token'] is None:
-        #    self.config['token'] = input('Enter Github token to access release API: ')
-
-        # Create Github API instance
-        #TODO
-        # self.github = Github(self.config['token'])
-        #
-        # print(dir(self.github))
-        # self.githubuser = self.github.get_user()
-        # self.githubrepo = self.githubuser.get_repo(self.config['project'])
-        # rel = self.githubrepo.get_release(self.config['tag'])
-        # print(rel, dir(rel))
-
     def set_substep_status(self, number, status, msg, infos=[]):
+        # Flag execution of minimum one step
+        if status == 'TODO':
+            self.todo = True
+
         # Search for substep by number and add new data
         for step in self.Steps:
             for substep in step.substeps:
@@ -485,6 +479,7 @@ def analyze_step_4(self):
         for tar in self.config['tar']:
             # Get tar filename
             tarfile = filename + '.tar.' + tar
+            self.assets += [tarfile]
             tarfilepath = os.path.join(self.config['output'], tarfile)
 
             # Check if compressed tar files exist
@@ -514,9 +509,11 @@ def analyze_step_4(self):
 
             # Get signature filename from setting
             if self.config['no_armor']:
-                sigfilepath = tarfilepath + '.sig'
+                sigfile = tarfile + '.sig'
             else:
-                sigfilepath = tarfilepath + '.asc'
+                sigfile = tarfile + '.asc'
+            self.assets += [sigfile]
+            sigfilepath = os.path.join(self.config['output'], sigfile)
 
             # Check if signature is existant
             if os.path.isfile(sigfilepath):
@@ -550,7 +547,9 @@ def analyze_step_4(self):
 
             # Verify all selected shasums if existant
             for sha in self.config['sha']:
-                shafilepath = tarfilepath + '.' + sha
+                shafile = tarfile + '.' + sha
+                self.assets += [shafile]
+                shafilepath = os.path.join(self.config['output'], shafile)
 
                 # Calculate hash of tarfile
                 if os.path.isfile(tarfilepath):
@@ -592,11 +591,44 @@ def analyze_step_4(self):
     def analyze_step_5(self):
         # Check Github GPG key
         if self.config['github'] == True:
-            # TODO Check github API
-            self.set_substep_status('5.1', 'TODO',
-                'Uploading release files to Github')
             self.set_substep_status('5.2', 'OK',
                 'Github uses well configured https')
+
+            # Ask for Github token
+            if self.config['token'] is None:
+               self.config['token'] = input('Enter Github token to access release API: ')
+
+            # Create Github API instance
+            self.github = Github(self.config['token'])
+
+            # Acces Github API
+            try:
+                self.githubuser = self.github.get_user()
+                self.githubrepo = self.githubuser.get_repo(self.config['project'])
+            except:
+                self.error('Error accessing Github API for project ' + self.config['project'])
+
+            # Check Release and its assets
+            rel = None
+            try:
+                rel = self.githubrepo.get_release(self.config['tag'])
+            except:
+                self.newassets = self.assets
+            else:
+                # Determine which assets need to be uploaded
+                asset_list = [x.name for x in rel.get_assets()]
+                for asset in self.assets:
+                    if asset not in asset_list:
+                        self.newassets += [asset]
+
+            # Check if assets already uploaded
+            if len(self.newassets) == 0:
+                self.set_substep_status('5.1', 'OK',
+                    'Release already published on Github')
+            else:
+                self.set_substep_status('5.1', 'TODO',
+                    'Uploading release files to Github')
+
         else:
             self.set_substep_status('5.1', 'NOTE',
                 'Please upload the compressed archive, signature and message digest manually')
@@ -774,22 +806,27 @@ def main(arguments):
 
     args = parser.parse_args()
 
-    # TODO debug
-    #print(vars(args))
-
     gpgit = GPGit(vars(args))
     gpgit.load_defaults()
     gpgit.analyze()
     gpgit.printstatus()
     print()
-    # TODO user selection
-    # TODO check if even something needs to be done
-    ret = input('Continue with the selected operations? [Y/n]')
-    if ret == 'y' or ret == '':
-        print()
-        #gpgit.run()
+
+    # Check if even something needs to be done
+    if gpgit.todo:
+        # User selection
+        ret = input('Continue with the selected operations? [Y/n]')
+        if ret == 'y' or ret == '':
+            print()
+            if not gpgit.run():
+                print('Finished without errors')
+        else:
+            gpgit.error('Aborted by user')
     else:
-        gpgit.error('Aborted by user')
+        print(colors.GREEN + "==>", colors.RESET, 'Everything looks okay. Nothing to do.')
+
+
+
 
 
 

From abaded2c45db74ac796db6b0165f19893e6978bd Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 18:49:37 +0200
Subject: [PATCH 04/46] Remove debug stuff

---
 gpgit.py | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 0ae5098..a488df1 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -825,33 +825,5 @@ def main(arguments):
     else:
         print(colors.GREEN + "==>", colors.RESET, 'Everything looks okay. Nothing to do.')
 
-
-
-
-
-
-    # rorepo is a Repo instance pointing to the git-python repository.
-    # For all you know, the first argument to Repo is a path to the repository
-    # you want to work with
-    # path = '.'
-    # repo = Repo(path, search_parent_directories=True)
-    # assert not repo.bare
-    # reader = repo.config_reader()             # get a config reader for read-only access
-    # with repo.config_writer():       # get a config writer to change configuration
-    #     pass                         # call release() to be sure changes are written and locks are released
-    # with repo.config_writer() as cw:
-    #     # TODO catch new section error
-    #     cw.set("gpgit", "test", "test")
-    #
-    # print(reader.sections())
-    # print(reader.get_value('user', 'email'))
-    # for entry in reader:
-    #     print(entry)
-    # #print(repo.untracked_files)
-    # print(repo.config_level)
-    #
-    # print("done")
-
-
 if __name__ == '__main__':
     sys.exit(main(sys.argv[1:]))

From 1da6bca5a2ff88d7d95834c5ca80d3a26b1dc0ce Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 19:58:17 +0200
Subject: [PATCH 05/46] Pull and push tags

---
 gpgit.py | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index a488df1..116a20f 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -450,8 +450,10 @@ def analyze_step_3(self):
                 'Enabling ' + self.config['config_level']
                 + ' git settings with commit signing')
 
+        # Refresh tags
+        self.repo.remotes.origin.fetch('--tags')
+
         # Check if tag was already created
-        # TODO refresh tags?
         if self.repo.tag('refs/tags/' + self.config['tag']) in self.repo.tags:
             # Verify signature
             try:
@@ -670,8 +672,13 @@ def step_3_2(self):
 
     # Create signed git tag
     def step_3_3(self):
+        print(':: Creating, signing and pushing tag', self.config['tag'])
+
+        # Create a signed tag
+        newtag = None
         try:
-            self.repo.create_tag(self.config['tag'],
+            newtag = self.repo.create_tag(
+                self.config['tag'],
                 message=self.config['message'],
                 sign=True,
                 local_user=self.config['fingerprint'])
@@ -679,6 +686,13 @@ def step_3_3(self):
             self.error("Signing tag failed")
             return True
 
+        # Push tag
+        try:
+            self.repo.remotes.origin.push(newtag)
+        except:
+           self.error("Pushing tag failed")
+           return True
+
     # Create compressed archive
     def step_4_1(self):
         # Check all compression option tar files

From 51d437e46d96eb80004f0697ff8f4bd12a5d8316 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 20:30:00 +0200
Subject: [PATCH 06/46] Add Release uploading

---
 gpgit.py | 35 +++++++++++++++++++++++++++++------
 1 file changed, 29 insertions(+), 6 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 116a20f..d619538 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -178,14 +178,20 @@ def __init__(self, config):
         #self.config['signingkey'] = None
         # self.config['gpgsign'] = None
 
-
+        # Github API
+        self.github = None
+        self.githubuser = None
+        self.githubrepo = None
+        self.release = None
         self.assets = []
         self.newassets = []
         self.todo = False
 
-
+        # GPG
         self.gpg = gnupg.GPG()
         self.gpgkey = None
+
+        # Git
         self.repo = None
 
         # Expand hash info list
@@ -611,14 +617,16 @@ def analyze_step_5(self):
                 self.error('Error accessing Github API for project ' + self.config['project'])
 
             # Check Release and its assets
-            rel = None
             try:
-                rel = self.githubrepo.get_release(self.config['tag'])
+                self.release = self.githubrepo.get_release(self.config['tag'])
             except:
                 self.newassets = self.assets
+                self.set_substep_status('5.1', 'TODO',
+                    'Creating release and uploading release files to Github')
+                return
             else:
                 # Determine which assets need to be uploaded
-                asset_list = [x.name for x in rel.get_assets()]
+                asset_list = [x.name for x in self.release.get_assets()]
                 for asset in self.assets:
                     if asset not in asset_list:
                         self.newassets += [asset]
@@ -771,7 +779,21 @@ def step_4_3(self):
 
     # Github
     def step_5_1(self):
-        pass
+        # Create release if not existant
+        if self.release is None:
+            self.release = self.githubrepo.create_git_release(
+                self.config['tag'],
+                self.config['project'] + ' ' + self.config['tag'],
+                self.config['message'],
+                draft=False, prerelease=self.config['prerelease'])
+
+        # Upload assets
+        for asset in self.newassets:
+            assetpath = os.path.join(self.config['output'], asset)
+            print(':: Uploading', assetpath)
+            # TODO not functional see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
+            # TODO change label and mime type
+            self.release.upload_asset(assetpath, "Testlabel", "application/x-xz")
 
     # Configure HTTPS for your download server
     def step_5_2(self):
@@ -814,6 +836,7 @@ def main(arguments):
     parser.add_argument('-c', '--comment', action='store', help='comment used for gpg key generation')
     parser.add_argument('-k', '--keyserver', action='store', default='hkps://hkps.pool.sks-keyservers.net', help='keyserver to use for up/downloading gpg keys')
     parser.add_argument('-n', '--no-github', action='store_false', dest='github', help='disable Github API functionallity')
+    parser.add_argument('-a', '--prerelease', action='store_true', help='Flag as Github prerelease')
     parser.add_argument('-t', '--tar', choices=['gz', 'gzip', 'xz', 'bz2', 'bzip2'], default=['xz'], nargs='+', help='compression option')
     parser.add_argument('-s', '--sha', choices=['sha256', 'sha384', 'sha512'], default=['sha512'], nargs='+', help='message digest option')
     parser.add_argument('-b', '--no-armor', action='store_true', help='do not create ascii armored signature output')

From 38a1850c2ac8c101ceb8ad14f5b5a78ae3e7a9a5 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 20:31:45 +0200
Subject: [PATCH 07/46] Check if tag exists befor verifying archive

---
 gpgit.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index d619538..6986c2b 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -492,12 +492,16 @@ def analyze_step_4(self):
 
             # Check if compressed tar files exist
             if os.path.isfile(tarfilepath):
-                # TODO multiple compression algorithms
+                # Check if tag exists
+                if self.repo.tag('refs/tags/' + self.config['tag']) not in self.repo.tags:
+                    self.set_substep_status('4.1', 'FAIL',
+                        'Archive exists but no corresponding tag!?', [tarfilepath])
+                    return True
+
                 # Verify existing archive
                 try:
                     with self.compressionAlgorithms[tar].open(tarfilepath, "rb") as tarstream:
                         cmptar = strmcmp(tarstream)
-                        # TODO catch error when archive exists but no tag --> compare wont work
                         self.repo.archive(cmptar, treeish=self.config['tag'], prefix=filename + '/', format='tar')
                         if not cmptar.equal():
                             self.set_substep_status('4.1', 'FAIL',

From 32642424526e5c273f3d471537cfa125cf661ebc Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 20:33:51 +0200
Subject: [PATCH 08/46] Remove debug note

---
 gpgit.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 6986c2b..fe9395c 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -466,10 +466,6 @@ def analyze_step_3(self):
                 self.repo.create_tag(self.config['tag'],
                     verify=True,
                     ref=None)
-                # # Check if every added file has been commited TODO
-                # if ! git diff --cached --exit-code &>/dev/null; then
-                #     print_step "INFO" 'You have added new changes but did not commit them yet. See "git status" or "git diff"'
-                # fi
             except:
                 self.set_substep_status('3.3', 'FAIL',
                     'Invalid signature for tag ' + self.config['tag'] + '. Was the tag even signed?')

From 435cd80f6a040126506ba83f9bcbea922dcded47 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 21:58:05 +0200
Subject: [PATCH 09/46] Fix key selection menu

---
 gpgit.py | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index fe9395c..8f15b6d 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -303,8 +303,7 @@ def analyze_step_1(self):
         # Check if a fingerprint was selected/found
         if self.config['fingerprint'] is None:
             # Check if gpg keys are available, but not yet configured
-            if private_keys is not None:
-                # TODO fancier print
+            if len(private_keys):
                 print('\r\033[K', end='')
                 print("GPG seems to be already configured on your system but git is not.")
                 print('Please select one of the existing keys below or generate a new one:')
@@ -316,13 +315,16 @@ def analyze_step_1(self):
                     print(str(i) + ':', key['fingerprint'], key['uids'][0], key['algoname'], key['length'])
 
                 # User input
-                # TODO cannot do ctrl + c
-                userinput = -1
-                while userinput < 0 or userinput > len(private_keys):
-                    try:
-                        userinput = int(input("Please select a key number from above: "))
-                    except:
-                        userinput = -1
+                try:
+                    userinput = -1
+                    while userinput < 0 or userinput > len(private_keys):
+                        try:
+                            userinput = int(input("Please select a key number from above: "))
+                        except ValueError:
+                            userinput = -1
+                except KeyboardInterrupt:
+                    print()
+                    self.error('Aborted by user')
                 print()
 
                 # Safe new fingerprint

From 571369f334ca175a5723e9c3d8fdb4dba1798642 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 21:59:02 +0200
Subject: [PATCH 10/46] Add key generation

---
 gpgit.py | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 8f15b6d..187fc79 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -389,7 +389,7 @@ def analyze_step_1(self):
                 'Generating an RSA 4096 GPG key for '
                 + self.config['username']
                 + ' ' + self.config['email']
-                + ' valid for 3 years.')
+                + ' valid for 1 year.')
 
             # Warn about strong passphrase
             self.set_substep_status('1.1', 'TODO',
@@ -653,8 +653,32 @@ def step_1_1(self):
 
     # Key generation
     def step_1_2(self):
-        #TODO
-        pass
+        # Generate RSA key command
+        # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
+        # Preferences: TODO https://security.stackexchange.com/questions/82216/how-to-change-default-cipher-in-gnupg-on-both-linux-and-windows
+        input_data = """
+        Key-Type: RSA
+        Key-Length: 4096
+        Key-Usage: cert sign auth
+        Subkey-Type: RSA
+        Subkey-Length: 4096
+        Subkey-Usage: encrypt
+        Name-Real: {0}
+        Name-Email: {1}
+        Expire-Date: 1y
+        Preferences: SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
+        Keyserver: {2}
+        %ask-passphrase
+        %commit
+        """.format(self.config['username'], self.config['email'], self.config['keyserver'])
+
+        # Execute gpg key generation command
+        print(colors.BLUE + ':: ' + colors.RESET + 'We need to generate a lot of random bytes. It is a good idea to perform')
+        print(colors.BLUE + ':: ' + colors.RESET + 'some other action (type on the keyboard, move the mouse, utilize the')
+        print(colors.BLUE + ':: ' + colors.RESET + 'disks) during the prime generation; this gives the random number')
+        print(colors.BLUE + ':: ' + colors.RESET + 'generator a better chance to gain enough entropy.')
+        self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
+        print(colors.BLUE + ':: ' + colors.RESET + 'Key generation finished. You new fingerprint is: ' + self.config['fingerprint'])
 
     # Submit your key to a key server
     def step_2_1(self):

From 808f35aa93ce1867603cf3b4274adbda3f961c93 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 22:09:29 +0200
Subject: [PATCH 11/46] Catch gpg keyserver errors

---
 gpgit.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/gpgit.py b/gpgit.py
index 187fc79..09841fa 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -422,7 +422,10 @@ def analyze_step_2(self):
             # TODO catch receive exception
             # TODO add timeout
             # https://stackoverflow.com/questions/366682/how-to-limit-execution-time-of-a-function-call-in-python
-            key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
+            try:
+                key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
+            except:
+                self.error('Unkown keyserver download error. Please try again alter.')
 
             # Found key on keyserver
             if self.config['fingerprint'] in key.fingerprints:

From 8722c483d9e2208408b2b59013227199efddf01a Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 22:10:00 +0200
Subject: [PATCH 12/46] Colorize output

---
 gpgit.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 09841fa..1d320f7 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -652,7 +652,7 @@ def analyze_step_5(self):
 
     # Strong, unique, secret passphrase
     def step_1_1(self):
-        print('More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
+        print(colors.BLUE + ':: ' + colors.RESET + 'More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
 
     # Key generation
     def step_1_2(self):
@@ -685,6 +685,7 @@ def step_1_2(self):
 
     # Submit your key to a key server
     def step_2_1(self):
+        print(colors.BLUE + ':: ' + colors.RESET + 'Publishing key ' + self.config['fingerprint'])
         self.gpg.send_keys(self.config['keyserver'], self.config['fingerprint'])
 
     # Associate GPG key with Github
@@ -709,7 +710,7 @@ def step_3_2(self):
 
     # Create signed git tag
     def step_3_3(self):
-        print(':: Creating, signing and pushing tag', self.config['tag'])
+        print(colors.BLUE + ':: ' + colors.RESET + 'Creating, signing and pushing tag', self.config['tag'])
 
         # Create a signed tag
         newtag = None
@@ -741,7 +742,7 @@ def step_4_1(self):
 
             # Create compressed tar files if it does not exist
             if not os.path.isfile(tarfilepath):
-                print(':: Creating', tarfilepath)
+                print(colors.BLUE + ':: ' + colors.RESET + 'Creating', tarfilepath)
                 with self.compressionAlgorithms[tar].open(tarfilepath, 'wb') as tarstream:
                     self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/', format='tar')
 
@@ -764,7 +765,7 @@ def step_4_2(self):
             if not os.path.isfile(sigfilepath):
                 # Sign tar file
                 with open(tarfilepath, 'rb') as tarstream:
-                    print(':: Creating', sigfilepath)
+                    print(colors.BLUE + ':: ' + colors.RESET + 'Creating', sigfilepath)
                     signed_data = self.gpg.sign_file(
                         tarstream,
                         keyid=self.config['fingerprint'],
@@ -802,7 +803,7 @@ def step_4_3(self):
                         self.hash[sha][tarfile] = hash_sha.hexdigest()
 
                     # Write cached hash and filename
-                    print(':: Creating', shafilepath)
+                    print(colors.BLUE + ':: ' + colors.RESET + 'Creating', shafilepath)
                     with open(shafilepath, "w") as f:
                         f.write(self.hash[sha][tarfile] + '  ' + tarfile)
 
@@ -819,7 +820,7 @@ def step_5_1(self):
         # Upload assets
         for asset in self.newassets:
             assetpath = os.path.join(self.config['output'], asset)
-            print(':: Uploading', assetpath)
+            print(colors.BLUE + ':: ' + colors.RESET + 'Uploading', assetpath)
             # TODO not functional see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
             # TODO change label and mime type
             self.release.upload_asset(assetpath, "Testlabel", "application/x-xz")

From ae46b63fab36a5fe6a582c55914cb501a8b8ad06 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 22:10:28 +0200
Subject: [PATCH 13/46] Minor syle changes

---
 gpgit.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 1d320f7..1836e96 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -24,6 +24,7 @@
 # TODO remove returns after self.error as it already exits
 # TODO document compression level default: gzip/bz2 max and lzma/xz 6. see note about level 6 https://docs.python.org/3/library/lzma.html
 # TODO replace armorfrom true/false to .sig/.asc?
+# TODO don't use plain except:, always specify which errors you'll get
 
 class colors(object):
     RED   = "\033[1;31m"
@@ -174,9 +175,8 @@ def __init__(self, config):
                 ])
             ]
 
+        # Config via parameters
         self.config = config
-        #self.config['signingkey'] = None
-        # self.config['gpgsign'] = None
 
         # Github API
         self.github = None

From 2cd8c1bb688e1c4e772fcecf2a36b8ac5fd9abcf Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 22:33:42 +0200
Subject: [PATCH 14/46] Flush user input

---
 gpgit.py | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 1836e96..6255b5a 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -26,6 +26,15 @@
 # TODO replace armorfrom true/false to .sig/.asc?
 # TODO don't use plain except:, always specify which errors you'll get
 
+def flush_input():
+    try:
+        import sys, termios
+        termios.tcflush(sys.stdin, termios.TCIOFLUSH)
+    except ImportError:
+        import msvcrt
+        while msvcrt.kbhit():
+            msvcrt.getch()
+
 class colors(object):
     RED   = "\033[1;31m"
     BLUE  = "\033[1;34m"
@@ -319,6 +328,7 @@ def analyze_step_1(self):
                     userinput = -1
                     while userinput < 0 or userinput > len(private_keys):
                         try:
+                            flush_input()
                             userinput = int(input("Please select a key number from above: "))
                         except ValueError:
                             userinput = -1
@@ -609,7 +619,8 @@ def analyze_step_5(self):
 
             # Ask for Github token
             if self.config['token'] is None:
-               self.config['token'] = input('Enter Github token to access release API: ')
+                flush_input()
+                self.config['token'] = input('Enter Github token to access release API: ')
 
             # Create Github API instance
             self.github = Github(self.config['token'])
@@ -882,7 +893,12 @@ def main(arguments):
     # Check if even something needs to be done
     if gpgit.todo:
         # User selection
-        ret = input('Continue with the selected operations? [Y/n]')
+        flush_input()
+        try:
+            ret = input('Continue with the selected operations? [Y/n]')
+        except KeyboardInterrupt:
+            print()
+            gpgit.error('Aborted by user')
         if ret == 'y' or ret == '':
             print()
             if not gpgit.run():

From d163d11305871b2a0fa4efa708b5fb722ec8b775 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 23:17:06 +0200
Subject: [PATCH 15/46] Catch interrupt signal for token input

---
 gpgit.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/gpgit.py b/gpgit.py
index 6255b5a..f384a9d 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -620,7 +620,11 @@ def analyze_step_5(self):
             # Ask for Github token
             if self.config['token'] is None:
                 flush_input()
-                self.config['token'] = input('Enter Github token to access release API: ')
+                try:
+                    self.config['token'] = input('Enter Github token to access release API: ')
+                except KeyboardInterrupt:
+                    print()
+                    gpgit.error('Aborted by user')
 
             # Create Github API instance
             self.github = Github(self.config['token'])

From d5b1615db4216300e43cf1a27da0b45f8e4df05c Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 23:36:15 +0200
Subject: [PATCH 16/46] Add some offline error detections

---
 gpgit.py | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index f384a9d..d8296d5 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -14,7 +14,21 @@
 import git
 from git import Repo
 import gnupg
+import signal
+from contextlib import contextmanager
 
+class TimeoutException(Exception): pass
+
+@contextmanager
+def time_limit(seconds):
+    def signal_handler(signum, frame):
+        raise TimeoutException
+    signal.signal(signal.SIGALRM, signal_handler)
+    signal.alarm(seconds)
+    try:
+        yield
+    finally:
+        signal.alarm(0)
 
 # TODO: check == True to is True
 # TODO proper document functions with """ to generate __docnames___
@@ -429,13 +443,11 @@ def analyze_step_2(self):
         # Only check if a fingerprint was specified
         if self.config['fingerprint'] is not None:
             # Check key on keyserver
-            # TODO catch receive exception
-            # TODO add timeout
-            # https://stackoverflow.com/questions/366682/how-to-limit-execution-time-of-a-function-call-in-python
             try:
-                key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
-            except:
-                self.error('Unkown keyserver download error. Please try again alter.')
+                with time_limit(10):
+                    key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
+            except TimeoutException:
+                self.error('Keyserver timed out. Please try again alter.')
 
             # Found key on keyserver
             if self.config['fingerprint'] in key.fingerprints:
@@ -472,7 +484,10 @@ def analyze_step_3(self):
                 + ' git settings with commit signing')
 
         # Refresh tags
-        self.repo.remotes.origin.fetch('--tags')
+        try:
+            self.repo.remotes.origin.fetch('--tags')
+        except git.exc.GitCommandError:
+            self.error('Error fetching remote tags.')
 
         # Check if tag was already created
         if self.repo.tag('refs/tags/' + self.config['tag']) in self.repo.tags:

From aafbe44f7e22d3c5e26fb76f7779835c2d25ed15 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 23:36:39 +0200
Subject: [PATCH 17/46] Show version in message

---
 gpgit.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index d8296d5..62292f5 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -148,6 +148,8 @@ def equal(self):
             return True
 
 class GPGit(object):
+    version = '2.0.0'
+
     # RFC4880 9.1.  Public-Key Algorithms
     gpgAlgorithmIDs = {
         '1': 'RSA',
@@ -263,7 +265,7 @@ def load_defaults(self):
 
         # Default message
         if self.config['message'] is None:
-            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit\nhttps://github.com/NicoHood/gpgit'
+            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' + self.version + '\nhttps://github.com/NicoHood/gpgit'
 
         # Default output path
         if self.config['output'] is None:
@@ -885,7 +887,7 @@ def main(arguments):
     parser = argparse.ArgumentParser(description=
     'A Python script that automates the process of signing git sources via GPG')
     parser.add_argument('tag', action='store', help='Tagname')
-    parser.add_argument('-v', '--version', action='version', version='GPGit 2.0.0')
+    parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')
     parser.add_argument('-o', '--output', action='store', help='output path of the compressed archive, signature and message digest')
     parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(), help='path of the git project')

From 8ef8d96424a8c4d2aaec4f8778fc6c36c3a7dc4a Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Fri, 12 May 2017 23:36:59 +0200
Subject: [PATCH 18/46] Show tar and sha filetypes in preview

---
 gpgit.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 62292f5..ec4d3f4 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -545,7 +545,7 @@ def analyze_step_4(self):
                     'Existing archive(s) verified successfully', ['Path: ' + self.config['output'], 'Basename: ' + filename])
             else:
                 self.set_substep_status('4.1', 'TODO',
-                    'Creating new release archive(s)', ['Path: ' + self.config['output'], 'Basename: ' + filename])
+                    'Creating new release archive(s): ' + ', '.join(str(x) for x in self.config['tar']), ['Path: ' + self.config['output'], 'Basename: ' + filename])
 
             # Get signature filename from setting
             if self.config['no_armor']:
@@ -626,7 +626,7 @@ def analyze_step_4(self):
                         'Existing message digest(s) verified successfully')
                 else:
                     self.set_substep_status('4.3', 'TODO',
-                        'Creating message digest(s) for archive(s)')
+                        'Creating message digest(s) for archive(s): ' + ', '.join(str(x) for x in self.config['sha']))
 
     def analyze_step_5(self):
         # Check Github GPG key

From dc62c9c85e0498822ac0ecfe8867242448751be4 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 00:04:57 +0200
Subject: [PATCH 19/46] Remove key server from key properties to avoid later
 issues

---
 gpgit.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index ec4d3f4..f515354 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -702,10 +702,9 @@ def step_1_2(self):
         Name-Email: {1}
         Expire-Date: 1y
         Preferences: SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
-        Keyserver: {2}
         %ask-passphrase
         %commit
-        """.format(self.config['username'], self.config['email'], self.config['keyserver'])
+        """.format(self.config['username'], self.config['email'])
 
         # Execute gpg key generation command
         print(colors.BLUE + ':: ' + colors.RESET + 'We need to generate a lot of random bytes. It is a good idea to perform')

From 441a683a833dad47e56de17e4feac18bd095d0ef Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 00:47:39 +0200
Subject: [PATCH 20/46] minor

---
 gpgit.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index f515354..de1d164 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -690,7 +690,6 @@ def step_1_1(self):
     def step_1_2(self):
         # Generate RSA key command
         # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
-        # Preferences: TODO https://security.stackexchange.com/questions/82216/how-to-change-default-cipher-in-gnupg-on-both-linux-and-windows
         input_data = """
         Key-Type: RSA
         Key-Length: 4096
@@ -884,7 +883,7 @@ def error(self, msg):
 
 def main(arguments):
     parser = argparse.ArgumentParser(description=
-    'A Python script that automates the process of signing git sources via GPG')
+    'A Python script that automates the process of signing git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')

From 98dfc71bff052aa891caf9ee1100044cbbf8f90d Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 01:30:01 +0200
Subject: [PATCH 21/46] Readme update

---
 Readme.md          | 318 ++++++++++++++++++++++-----------------------
 img/screenshot.png | Bin 0 -> 96194 bytes
 requirements.txt   |   3 +
 3 files changed, 156 insertions(+), 165 deletions(-)
 create mode 100644 img/screenshot.png
 create mode 100644 requirements.txt

diff --git a/Readme.md b/Readme.md
index 4b813bf..b8e86b2 100644
--- a/Readme.md
+++ b/Readme.md
@@ -2,9 +2,43 @@
 
 ![gpgit.png](img/gpgit.png)
 
-GPGit is meant to bring GPG to the masses. It is not only a shell script that
-automates the process of creating new signed git releases with GPG but also
-comes with this step-by-step readme guide for learning how to use GPG.
+## Introduction
+As we all know, today more than ever before, it is crucial to be able to trust
+our computing environments. One of the main difficulties that package
+maintainers of Linux distributions face, is the difficulty to verify the
+authenticity and the integrity of the source code. With GPG signatures it is
+possible for packagers to verify easily and quickly source code releases.
+
+##### Overview of the required tasks:
+* Create and/or use a **[4096-bit RSA keypair][1]** for the file signing
+* Use a **[strong, unique, secret passphrase][2]** for the key
+* Upload the public key to a **[key server][3]** and **[publish the full fingerprint][4]**
+* **Sign** every new git **[commit][5]** and **[tag][6]**
+* Create **[signed][7], [compressed][8]** (xz --best) release **archives**
+* Upload a **[strong message digest][9]** (sha512) of the archive
+* Configure **[HTTPS][10]** for your download server
+
+#### GPGit
+[GPGit][11] is meant to bring GPG to the masses. It is not only a shell script
+that automates the process of [creating new signed git releases with GPG][12]
+but also comes with a [step-by-step readme guide][13] for learning how to use
+GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
+
+[1]: https://github.com/NicoHood/gpgit#12-key-generation
+[2]: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase
+[3]: https://github.com/NicoHood/gpgit#21-submit-your-key-to-a-key-server
+[4]: https://github.com/NicoHood/gpgit#23-publish-your-full-fingerprint
+[5]: https://github.com/NicoHood/gpgit#32-commit-signing
+[6]: https://github.com/NicoHood/gpgit#33-create-signed-git-tag
+[7]: https://github.com/NicoHood/gpgit#43-sign-the-sources
+[8]: https://github.com/NicoHood/gpgit#41-create-compressed-archive
+[9]: https://github.com/NicoHood/gpgit#42-create-the-message-digest
+[10]: https://github.com/NicoHood/gpgit#52-configure-https-for-your-download-server
+[11]: https://github.com/NicoHood/gpgit
+[12]: https://github.com/NicoHood/gpgit#script-usage
+[13]: https://github.com/NicoHood/gpgit#gpg-quick-start-guide
+[14]: https://developer.github.com/v3/repos/releases/
+
 
 ## Index
 * [Introduction](#introduction)
@@ -14,57 +48,19 @@ comes with this step-by-step readme guide for learning how to use GPG.
 * [Appendix](#appendix)
 * [Version History](#version-history)
 
-## Introduction
-As we all know, today more than ever before, it is crucial to be able to trust
-our computing environments. One of the main difficulties that package
-maintainers of Linux distributions face, is the difficulty to verify the
-authenticity and the integrity of the source code. With GPG signatures it is
-possible to verify easily and quickly source code releases.
-
-##### Overview of the required tasks:
-* Create and/or use a 4096-bit RSA keypair for the file signing.
-* Keep your key secret, use a strong unique passphrase for the key.
-* Upload the public key to a key server and publish the [full fingerprint](https://lkml.org/lkml/2016/8/15/445).
-* Sign every new git commit and tag.
-* Create signed compressed (xz --best) release archives
-* Upload a strong message digest (sha512) of the archive
-* Configure https for your download server
-
-### Explanation
-Only a large key can remain secure for a long period of time. It is crucial to
-secure this key with a strong unique passphrase so nobody is able to fake
-releases of your software. Do not store the key in untrusted devices.
-
-Every git commit/tag/release needs to be signed in order to verify the history
-of the whole software as well as the latest source files. As an alternative
-strong message digest can help to add another layer of securing the source
-integrity.
-
-Https ensure that your sources are downloaded over an encrypted, secure channel.
-It also gives your public fingerprint and the message digest more trust.
-
 ## Installation
 ### ArchLinux
 You can install gpgit from [AUR](https://aur.archlinux.org/packages/gpgit/).
 Make sure to [build in a clean chroot](https://wiki.archlinux.org/index.php/DeveloperWiki:Building_in_a_Clean_Chroot).
+Please give the package a vote so I can move it to the official ArchLinux
+[community] repository for even simpler installation.
 
-### Manual Installation
-##### Dependencies:
-* bash
-* gnupg
-* git
-* coreutils
-* grep
-
-##### Optional Dependencies:
-* wget (online source verification)
-* curl (Github uploading)
-* gzip (compression algorithm)
-* xz (compression algorithm)
-* lzip (compression algorithm)
+### Ubuntu/Debian/Other
+GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pypi/pip).
 
 ```bash
-PREFIX=/usr/local sudo make install
+sudo apt-get install python pip gnupg git
+pip install --user -r requirements.txt
 ```
 
 ## Script Usage
@@ -72,116 +68,108 @@ The script guides you through all 5 steps of the
 [GPG quick start guide](#gpg-quick-start-guide). **By default no extra arguments
 beside the tag are required.** Follow the instructions and you are good to go.
 
-```bash
-$ gpgit 1.1.3
-==> 1. Generate new GPG key
-    Key already generated. Using key: 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161
-==> 2. Publish your key
-    Assuming key was already published after its creation. If not please do so.
-==> 3. Usage of GPG by git
-  -> 3.1 Configure git GPG key
-    Git already configured with your GPG key
-  -> 3.2 Commit signing
-    Commit signing already enabled.
-  -> 3.3 Create signed git tag
-    Refreshing tags from upstream.
-    Continue? [Y/n]y
-Already up-to-date.
-    Creating signed tag 1.1.3 and pushing it to the remote git.
-    Continue? [Y/n]y
-Counting objects: 1, done.
-Writing objects: 100% (1/1), 794 bytes | 0 bytes/s, done.
-Total 1 (delta 0), reused 0 (delta 0)
-To github.com:NicoHood/gpgit.git
- * [new tag]         1.1.3 -> 1.1.3
-==> 4. Creation of a signed compressed release archive
-  -> 4.0 Download archive from online source
-    Downloading source from URL https://github.com/NicoHood/gpgit/archive/1.1.3.tar.gz
-    Continue? [Y/n]y
---2017-01-29 13:05:43--  https://github.com/NicoHood/gpgit/archive/1.1.3.tar.gz
-Resolving github.com (github.com)... 192.30.253.112, 192.30.253.113
-Connecting to github.com (github.com)|192.30.253.112|:443... connected.
-HTTP request sent, awaiting response... 302 Found
-Location: https://codeload.github.com/NicoHood/gpgit/tar.gz/1.1.3 [following]
---2017-01-29 13:05:43--  https://codeload.github.com/NicoHood/gpgit/tar.gz/1.1.3
-Resolving codeload.github.com (codeload.github.com)... 192.30.253.121, 192.30.253.120
-Connecting to codeload.github.com (codeload.github.com)|192.30.253.121|:443... connected.
-HTTP request sent, awaiting response... 200 OK
-Length: unspecified [application/x-gzip]
-Saving to: '/hackallthethings/gpgit/archive/gpgit-1.1.3.tar.gz'
-
-/hackallthethings/gpgit/archive/gpgit-1.1.3.tar.gz       [ <=> ]  10.90K  --.-KB/s    in 0.001s
-
-2017-01-29 13:05:44 (8.16 MB/s) - '/hackallthethings/gpgit/archive/gpgit-1.1.3.tar.gz' saved [11162]
-
-  -> 4.1 Create compressed archive
-    Archive /hackallthethings/gpgit/archive/gpgit-1.1.3.tar.gz already exists.
-    Verifying git against local source.
-    Continue? [Y/n]y
-    Existing archive successfully verified against local source.
-  -> 4.2 Create message digest
-    Creating message digest /hackallthethings/gpgit/archive/gpgit-1.1.3.tar.gz.sha512
-    Continue? [Y/n]y
-  -> 4.3 Sign the sources
-    Creating signature /hackallthethings/gpgit/archive/gpgit-1.1.3.tar.gz.sig
-    Continue? [Y/n]y
-==> 5. Upload the release
-  -> 5.1 Github
-    Uploading to Github. Please setup a Github token first:
-    (Github->Settings->Personal access tokens; public repo access)
-    Continue? [Y/n]y
-    Enter your Github token:
-    Github release created.
-    Signature uploaded.
-    Message digest uploaded.
-==> Finished without errors
+![screenshot](img/screenshot.png)
+
+### Parameters
+
+For more information checkout the help page:
+```
+$ gpgit --help
+usage: gpgit.py [-h] [-v] [-m MESSAGE] [-o OUTPUT] [-g GIT_DIR]
+                [-f FINGERPRINT] [-p PROJECT] [-e EMAIL] [-u USERNAME]
+                [-c COMMENT] [-k KEYSERVER] [-n] [-a]
+                [-t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]]
+                [-s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]] [-b]
+                tag
+
+A Python script that automates the process of signing git sources via GPG.
+
+positional arguments:
+  tag                   Tagname
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --version         show program's version number and exit
+  -m MESSAGE, --message MESSAGE
+                        tag message
+  -o OUTPUT, --output OUTPUT
+                        output path of the compressed archive, signature and
+                        message digest
+  -g GIT_DIR, --git-dir GIT_DIR
+                        path of the git project
+  -f FINGERPRINT, --fingerprint FINGERPRINT
+                        (full) GPG fingerprint to use for signing/verifying
+  -p PROJECT, --project PROJECT
+                        name of the project, used for archive generation
+  -e EMAIL, --email EMAIL
+                        email used for gpg key generation
+  -u USERNAME, --username USERNAME
+                        username used for gpg key generation
+  -c COMMENT, --comment COMMENT
+                        comment used for gpg key generation
+  -k KEYSERVER, --keyserver KEYSERVER
+                        keyserver to use for up/downloading gpg keys
+  -n, --no-github       disable Github API functionallity
+  -a, --prerelease      Flag as Github prerelease
+  -t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...], --tar {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]
+                        compression option
+  -s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...], --sha {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]
+                        message digest option
+  -b, --no-armor        do not create ascii armored signature output
 ```
 
-For additional tweaks you may use some optional parameters:
+### Configuration
+Additional configuration can be made via [git config](https://git-scm.com/docs/git-config).
+
 ```bash
-$ gpgit --help
-Usage: gpgit <tag> [options]
-
-Mandatory parameters:
-<tag>           Tagname
-
-Actions:
--h --help       Show this help message
-
-Options:
--o, --output    The output path of the compressed archive, signature and message digest.
-                Default: "git rev-parse --show-toplevel)/archive"
--u, --username  Username of the user. Used for GPG key generation.
-                Default: git config user.name
--e, --email     Email of the user. Used for GPG key generation.
-                Default: "git config user.email"
--p, --project   The name of the project. Used for archive geneation.
-                Default: "git config --local remote.origin.url \
-                           | sed -n \'s#.*/\([^.]*\)\.git#\1#p\'"
--g, --gpg       Specify (full) GPG fingerprint to use for signing.
-                Default: "git config user.signingkey"
--w, --wget      Download source from a user-specified URL.
-                Default: Auto detection for Github URL
--t, --tar       Valid compression options: gz|xz|lz
-                Default: gz
--s, --sha       Valid message digest options: sha256|sha384|sha512
-                Default: sha512
--m, --message   Specify the tag message.
-                Default: "Release <tag>"
--y, --yes       Assume "yes" on all questions.
+# GPGit settings
+git config user.githubtoken <githubtoken>
+git config user.gpgitoutput ~/gpgit
+
+# GPG settings
+git config user.signingkey <fingerprint>
+git config commit.gpgsign true
+
+# General settings
+git config user.name <username>
+git config user.email <email>
 ```
 
-## GPG quick start guide
+## GPG Quick Start Guide
 GPGit guides you through 5 simple steps to get your software project ready
 with GPG signatures. Further details can be found below.
 
 1. [Generate a new GPG key](#1-generate-a-new-gpg-key)
+  1. Strong, unique, secret passphrase
+  2. Key generation
 2. [Publish your key](#2-publish-your-key)
+  1. Submit your key to a key server
+  2. Associate GPG key with Github
+  3. Publish your full fingerprint
 3. [Usage of GPG by git](#3-usage-of-gpg-by-git)
+  1. Configure git GPG key
+  2. Commit signing
+  3. Create signed git tag
 4. [Creation of a signed compressed release archive](#4-creation-of-a-signed-compressed-release-archive)
+  1. Create compressed archive
+  2. Create the message digest
+  3. Sign the sources
 5. [Upload the release](#5-upload-the-release)
+  1. Github
+  2. Configure HTTPS for your download server
 
 ### 1. Generate a new GPG key
+#### 1.1 Strong, unique, secret passphrase
+Make sure that your new passphrase for the GPG key meets high security
+standards. If the passphrase/key is compromised all of your signatures are
+compromised too.
+
+Here are a few examples how to keep a passphrase strong but easy to remember:
+* [How to Create a Secure Password](https://open.buffer.com/creating-a-secure-password/)
+* [Mooltipass](https://www.themooltipass.com/)
+* [Keepass](http://keepass.info/)
+
+#### 1.2 Key generation
 If you don't have a GPG key yet, create a new one first. You can use RSA
 (4096 bits) or ECC (Curve 25519) for a strong key. The latter one does currently
 not work with Github. You want to stay with RSA for now.
@@ -193,7 +181,7 @@ Crucial key generation settings:
 * (1) RSA and RSA
 * 4096 bit key size
 * 4096 bit subkey size
-* Valid for 3 years (3y)
+* Valid for 1 year (1y)
 * Username and email
 
 ##### Example key generation:
@@ -207,11 +195,11 @@ gpg: revocation certificate stored as
 '/tmp/openpgp-revocs.d/3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6.rev'
 public and secret key created and signed.
 
-pub   rsa4096 2017-01-04 [SC] [expires: 2020-01-04]
+pub   rsa4096 2017-01-04 [SC] [expires: 2018-01-04]
       3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
       3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
 uid                      John Doe (gpgit example) <john@doe.com>
-sub   rsa4096 2017-01-04 [E] [expires: 2020-01-04]
+sub   rsa4096 2017-01-04 [E] [expires: 2018-01-04]
 ```
 
 The generated key has the fingerprint `3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6`
@@ -231,13 +219,13 @@ Now the user can get your key by requesting the fingerprint from the keyserver:
 
 ```bash
 # Publish key
-gpg --keyserver hkps://hkps.pool.sks-keyservers.net --send-keys 3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
+gpg --keyserver hkps://hkps.pool.sks-keyservers.net --send-keys <fingerprint>6
 
 # Import key
-gpg --keyserver hkps://hkps.pool.sks-keyservers.net --recv-keys 3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
+gpg --keyserver hkps://hkps.pool.sks-keyservers.net --recv-keys <fingerprint>
 ```
 
-#### 2.2 Associate GPG key with github
+#### 2.2 Associate GPG key with Github
 To make Github display your commits as "verified" you also need to add your
 public [GPG key to your Github profile](https://github.com/settings/keys).
 [[Read more]](https://help.github.com/articles/generating-a-gpg-key/)
@@ -250,9 +238,9 @@ gpg --list-secret-keys --keyid-format LONG
 gpg --armor --export <fingerprint>
 ```
 
-#### 2.3 Publish your fingerprint
+#### 2.3 Publish your full fingerprint
 To make it easy for everyone else to find your key it is crucial that you
-publish the fingerprint on a trusted platform, such as your website or Github.
+publish the [**full fingerprint**](https://lkml.org/lkml/2016/8/15/445) on a trusted platform, such as your website or Github.
 To give the key more trust other users can sign your key too.
 [[Read more]](https://wiki.debian.org/Keysigning)
 
@@ -304,7 +292,7 @@ for those countries with slow and unstable internet connections.
 git archive --format=tar.gz -o gpgit-1.0.0.tar.gz --prefix gpgit-1.0.0 1.0.0
 
 # .tar.xz
-git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | xz -9 > gpgit-1.0.0.tar.xz
+git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | xz > gpgit-1.0.0.tar.xz
 
 # .tar.lz
 git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | lzip --best > gpgit-1.0.0.tar.xz
@@ -353,20 +341,26 @@ The script also supports uploading to Github directly. Create a new Github token
 first and then follow the instructions of the script.
 
 How to generate a Github token:
-* Go to preferences
-* Developer settings section on the left
-* Personal access tokens
-* Generate a new token
-* Check "public_repo"
-* Generate the token and store it safely
+* Go to ["Settings - Personal access tokens"](https://github.com/settings/tokens)
+* Generate a new token with permissions "public_repo" and "admin:gpg_key"
+* Store it safely
+
+#### 5.2 Configure HTTPS for your download server
+* [Why HTTPS Matters](https://developers.google.com/web/fundamentals/security/encrypt-in-transit/why-https)
+* [Let's Encrypt](https://letsencrypt.org/)
+* [SSL Server Test](https://www.ssllabs.com/ssltest/)
 
 ## Appendix
 
-### Email encryption
-You can also use this key for email encryption
+### Email Encryption
+You can also use your GPG key for email encryption
 with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird#EnigMail_-_Encryption).
 [[Read more]](https://www.enigmail.net/index.php/en/)
 
+## Contact
+You can get securely in touch with me [here](http://contact.nicohood.de).
+Don't hesitate to [file a bug at Github](https://github.com/NicoHood/gpgit/issues).
+
 ## Version History
 ```
 1.2.0 (24.04.2017)
@@ -399,9 +393,3 @@ with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird
 Untagged Release (16.12.2016)
 * Initial release of the software
 ```
-
-## Legal Notes
-The GPGit logo is a mix of the gnupg and the git logo which are both distributed as Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0). See [LICENSE](img/LICENSE) for more details.
-
-* https://www.gnupg.org/copying.html
-* https://git-scm.com/downloads/logos
diff --git a/img/screenshot.png b/img/screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d5c1e9e77bd8c5556e4e02b099e1244bf760db2
GIT binary patch
literal 96194
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

literal 0
HcmV?d00001

diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..c7f43b2
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,3 @@
+GitPython
+python-gnupg
+PyGithub

From cdbc77c4815f1308622a852d3303a447f9946c70 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 01:30:16 +0200
Subject: [PATCH 22/46] Create non-existing output folder

---
 gpgit.py | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/gpgit.py b/gpgit.py
index de1d164..bbff658 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -41,6 +41,7 @@ def signal_handler(signum, frame):
 # TODO don't use plain except:, always specify which errors you'll get
 
 def flush_input():
+    # TODO removes in progress prints.
     try:
         import sys, termios
         termios.tcflush(sys.stdin, termios.TCIOFLUSH)
@@ -273,7 +274,17 @@ def load_defaults(self):
 
         # Check if path exists
         if not os.path.isdir(self.config['output']):
-            self.error('Not a valid path: ' + self.config['output'])
+            # Create not existing path
+            print('Not a valid path: ' + self.config['output'])
+            try:
+                ret = input('Create non-existing output path? [Y/n]')
+            except KeyboardInterrupt:
+                print()
+                self.error('Aborted by user')
+            if ret == 'y' or ret == '':
+                os.makedirs(self.config['output'])
+            else:
+                self.error('Aborted by user')
 
         # Set default project name
         if self.config['project'] is None:

From 4898f1a99a269de28f89cf1ce0b269e3eaeab7c2 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 01:39:19 +0200
Subject: [PATCH 23/46] Readme fixes

---
 Readme.md | 50 +++++++++++++++++++++++++-------------------------
 gpgit.py  |  2 +-
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/Readme.md b/Readme.md
index b8e86b2..8db7baa 100644
--- a/Readme.md
+++ b/Readme.md
@@ -19,7 +19,7 @@ possible for packagers to verify easily and quickly source code releases.
 * Configure **[HTTPS][10]** for your download server
 
 #### GPGit
-[GPGit][11] is meant to bring GPG to the masses. It is not only a shell script
+[GPGit][11] is meant to bring GPG to the masses. It is not only a python script
 that automates the process of [creating new signed git releases with GPG][12]
 but also comes with a [step-by-step readme guide][13] for learning how to use
 GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
@@ -140,23 +140,23 @@ GPGit guides you through 5 simple steps to get your software project ready
 with GPG signatures. Further details can be found below.
 
 1. [Generate a new GPG key](#1-generate-a-new-gpg-key)
-  1. Strong, unique, secret passphrase
-  2. Key generation
+    1. [Strong, unique, secret passphrase](#11-strong-unique-secret-passphrase)
+    2. [Key generation](#12-key-generation)
 2. [Publish your key](#2-publish-your-key)
-  1. Submit your key to a key server
-  2. Associate GPG key with Github
-  3. Publish your full fingerprint
+    1. [Submit your key to a key server](#21-submit-your-key-to-a-key-server)
+    2. [Associate GPG key with Github](#22-associate-gpg-key-with-github)
+    3. [Publish your full fingerprint](#23-publish-your-full-fingerprint)
 3. [Usage of GPG by git](#3-usage-of-gpg-by-git)
-  1. Configure git GPG key
-  2. Commit signing
-  3. Create signed git tag
+    1. [Configure git GPG key](#31-configure-git-gpg-key)
+    2. [Commit signing](#32-commit-signing)
+    3. [Create signed git tag](#33-create-signed-git-tag)
 4. [Creation of a signed compressed release archive](#4-creation-of-a-signed-compressed-release-archive)
-  1. Create compressed archive
-  2. Create the message digest
-  3. Sign the sources
+    1. [Create compressed archive](#41-create-compressed-archive)
+    2. [Sign the sources](#42-create-the-message-digest)
+    3. [Create the message digest](#43-sign-the-sources)
 5. [Upload the release](#5-upload-the-release)
-  1. Github
-  2. Configure HTTPS for your download server
+    1. [Github](#51-github)
+    2. [Configure HTTPS for your download server](#52-configure-https-for-your-download-server)
 
 ### 1. Generate a new GPG key
 #### 1.1 Strong, unique, secret passphrase
@@ -301,17 +301,7 @@ git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | lzip --best > gpgit-1.0.0.
 git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | cmp <(xz -dc gpgit-1.0.0.tar.xz)
 ```
 
-#### 4.2 Create the message digest
-Message digests are used to ensure the integrity of a file. It can also serve as
-checksum to verify the download. Message digests **do not** replace GPG
-signatures. They rather provide and alternative simple way to verify the source.
-Make sure to provide message digest over a secure channel like https.
-
-```bash
-sha512 gpgit-1.0.0.tar.xz > gpgit-1.0.0.tar.xz.sha512
-```
-
-#### 4.3 Sign the sources
+#### 4.2 Sign the sources
 Type the filename of the tarball that you want to sign and then run:
 ```bash
 gpg --armor --detach-sign gpgit-1.0.0.tar.xz
@@ -332,6 +322,16 @@ to first verify the signature after downloading.
 gpg --verify gpgit-1.0.0.tar.xz.asc
 ```
 
+#### 4.3 Create the message digest
+Message digests are used to ensure the integrity of a file. It can also serve as
+checksum to verify the download. Message digests **do not** replace GPG
+signatures. They rather provide and alternative simple way to verify the source.
+Make sure to provide message digest over a secure channel like https.
+
+```bash
+sha512 gpgit-1.0.0.tar.xz > gpgit-1.0.0.tar.xz.sha512
+```
+
 ### 5. Upload the release
 #### 5.1 Github
 Create a new "Github Release" to add additional data to the tag. Then drag the
diff --git a/gpgit.py b/gpgit.py
index bbff658..c806279 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -894,7 +894,7 @@ def error(self, msg):
 
 def main(arguments):
     parser = argparse.ArgumentParser(description=
-    'A Python script that automates the process of signing git sources via GPG.')
+    'A python script that automates the process of signing git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')

From 4cf57a40c37f96c40305be6dea63a59e67bc3765 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 01:41:30 +0200
Subject: [PATCH 24/46] Extended Contact info

---
 Readme.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Readme.md b/Readme.md
index 8db7baa..8993fed 100644
--- a/Readme.md
+++ b/Readme.md
@@ -46,6 +46,7 @@ GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
 * [Script Usage](#script-usage)
 * [GPG quick start guide](#gpg-quick-start-guide)
 * [Appendix](#appendix)
+* [Contact][#contact]
 * [Version History](#version-history)
 
 ## Installation
@@ -360,6 +361,7 @@ with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird
 ## Contact
 You can get securely in touch with me [here](http://contact.nicohood.de).
 Don't hesitate to [file a bug at Github](https://github.com/NicoHood/gpgit/issues).
+More cool projects from me can be found [here](http://www.nicohood.de).
 
 ## Version History
 ```

From 12e4e60cdfd838c1c931914c0bee432532782d3d Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 12:25:02 +0200
Subject: [PATCH 25/46] Readme plan

---
 Readme.md | 44 ++++++++++++++++++++++++++++++--------------
 gpgit.py  |  2 +-
 2 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/Readme.md b/Readme.md
index 8993fed..1179a79 100644
--- a/Readme.md
+++ b/Readme.md
@@ -9,7 +9,7 @@ maintainers of Linux distributions face, is the difficulty to verify the
 authenticity and the integrity of the source code. With GPG signatures it is
 possible for packagers to verify easily and quickly source code releases.
 
-##### Overview of the required tasks:
+#### Overview of the required tasks:
 * Create and/or use a **[4096-bit RSA keypair][1]** for the file signing
 * Use a **[strong, unique, secret passphrase][2]** for the key
 * Upload the public key to a **[key server][3]** and **[publish the full fingerprint][4]**
@@ -18,7 +18,7 @@ possible for packagers to verify easily and quickly source code releases.
 * Upload a **[strong message digest][9]** (sha512) of the archive
 * Configure **[HTTPS][10]** for your download server
 
-#### GPGit
+### GPGit
 [GPGit][11] is meant to bring GPG to the masses. It is not only a python script
 that automates the process of [creating new signed git releases with GPG][12]
 but also comes with a [step-by-step readme guide][13] for learning how to use
@@ -46,7 +46,7 @@ GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
 * [Script Usage](#script-usage)
 * [GPG quick start guide](#gpg-quick-start-guide)
 * [Appendix](#appendix)
-* [Contact][#contact]
+* [Contact](#contact)
 * [Version History](#version-history)
 
 ## Installation
@@ -60,8 +60,24 @@ Please give the package a vote so I can move it to the official ArchLinux
 GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pypi/pip).
 
 ```bash
-sudo apt-get install python pip gnupg git
-pip install --user -r requirements.txt
+# Install dependencies
+sudo apt-get install python3 python3-pip gnupg2 git
+VERSION=2.0.0
+
+# Download and verify source
+wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
+wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz.asc
+gpg2 --keyserver hkps://pgp.mit.edu --recv-keys 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161
+gpg2 --verify gpgit-${VERSION}.tar.xz.asc gpgit-${VERSION}.tar.xz
+
+# Extract and install dependencies
+tar -xf gpgit-${VERSION}.tar.xz
+cd gpgit-${VERSION}
+pip3 install --user -r requirements.txt
+
+# Install  and run GPGit
+sudo cp gpgit.py /usr/local/bin/gpgit
+gpgit --help
 ```
 
 ## Script Usage
@@ -124,16 +140,16 @@ Additional configuration can be made via [git config](https://git-scm.com/docs/g
 
 ```bash
 # GPGit settings
-git config user.githubtoken <githubtoken>
-git config user.gpgitoutput ~/gpgit
+git config --global user.githubtoken <githubtoken>
+git config --global user.gpgitoutput ~/gpgit
 
 # GPG settings
-git config user.signingkey <fingerprint>
-git config commit.gpgsign true
+git config --global user.signingkey <fingerprint>
+git config --global commit.gpgsign true
 
 # General settings
-git config user.name <username>
-git config user.email <email>
+git config --global user.name <username>
+git config --global user.email <email>
 ```
 
 ## GPG Quick Start Guide
@@ -208,7 +224,7 @@ in this example. Share it with others so they can verify your source.
 [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Create_key_pair)
 
 If you ever move your installation make sure to backup `~/.gnupg/` as it
-contains the private key and the revocation certificate. Handle it with care.
+contains the **private key** and the **revocation certificate**. Handle it with care.
 [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Revoking_a_key)
 
 ### 2. Publish your key
@@ -220,10 +236,10 @@ Now the user can get your key by requesting the fingerprint from the keyserver:
 
 ```bash
 # Publish key
-gpg --keyserver hkps://hkps.pool.sks-keyservers.net --send-keys <fingerprint>6
+gpg --keyserver hkps://pgp.mit.edu --send-keys <fingerprint>6
 
 # Import key
-gpg --keyserver hkps://hkps.pool.sks-keyservers.net --recv-keys <fingerprint>
+gpg --keyserver hkps://pgp.mit.edu --recv-keys <fingerprint>
 ```
 
 #### 2.2 Associate GPG key with Github
diff --git a/gpgit.py b/gpgit.py
index c806279..3fa9e48 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -905,7 +905,7 @@ def main(arguments):
     parser.add_argument('-e', '--email', action='store', help='email used for gpg key generation')
     parser.add_argument('-u', '--username', action='store', help='username used for gpg key generation')
     parser.add_argument('-c', '--comment', action='store', help='comment used for gpg key generation')
-    parser.add_argument('-k', '--keyserver', action='store', default='hkps://hkps.pool.sks-keyservers.net', help='keyserver to use for up/downloading gpg keys')
+    parser.add_argument('-k', '--keyserver', action='store', default='hkps://pgp.mit.edu', help='keyserver to use for up/downloading gpg keys')
     parser.add_argument('-n', '--no-github', action='store_false', dest='github', help='disable Github API functionallity')
     parser.add_argument('-a', '--prerelease', action='store_true', help='Flag as Github prerelease')
     parser.add_argument('-t', '--tar', choices=['gz', 'gzip', 'xz', 'bz2', 'bzip2'], default=['xz'], nargs='+', help='compression option')

From 39ce8074d84e55039a0b467ec77f7de4c7cce116 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 15:31:42 +0200
Subject: [PATCH 26/46] Add option to resign an older tag

---
 gpgit.py | 52 ++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 36 insertions(+), 16 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 3fa9e48..f087755 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -503,19 +503,23 @@ def analyze_step_3(self):
             self.error('Error fetching remote tags.')
 
         # Check if tag was already created
-        if self.repo.tag('refs/tags/' + self.config['tag']) in self.repo.tags:
+        tag = self.repo.tag('refs/tags/' + self.config['tag'])
+        if tag in self.repo.tags:
             # Verify signature
             try:
                 self.repo.create_tag(self.config['tag'],
                     verify=True,
                     ref=None)
-            except:
-                self.set_substep_status('3.3', 'FAIL',
-                    'Invalid signature for tag ' + self.config['tag'] + '. Was the tag even signed?')
-                return True
+            except git.exc.GitCommandError:
+                if hasattr(tag.tag, 'message') and '-----BEGIN PGP SIGNATURE-----' in tag.tag.message:
+                    self.set_substep_status('3.3', 'FAIL',
+                        'Invalid signature for tag ' + self.config['tag'])
+                    return True
+                self.set_substep_status('3.3', 'TODO',
+                    'Adding signature for unsigned tag: ' + self.config['tag'])
             else:
                 self.set_substep_status('3.3', 'OK',
-                    'Good signature for existing tag ' + self.config['tag'])
+                    'Good signature for existing tag: ' + self.config['tag'])
         else:
             self.set_substep_status('3.3', 'TODO',
                 'Creating signed tag ' + self.config['tag'] + ' and pushing it to the remote git')
@@ -753,21 +757,37 @@ def step_3_2(self):
     def step_3_3(self):
         print(colors.BLUE + ':: ' + colors.RESET + 'Creating, signing and pushing tag', self.config['tag'])
 
+        # Check if tag needs to be recreated
+        force = False
+        ref = 'HEAD'
+        date = ''
+        tag = self.repo.tag('refs/tags/' + self.config['tag'])
+        if tag in self.repo.tags:
+            force = True
+            ref = self.config['tag']
+            if hasattr(tag.tag, 'message'):
+                self.config['message'] = tag.tag.message
+            if hasattr(tag.tag, 'tagged_date'):
+                date = str(tag.tag.tagged_date)
+
         # Create a signed tag
         newtag = None
-        try:
-            newtag = self.repo.create_tag(
-                self.config['tag'],
-                message=self.config['message'],
-                sign=True,
-                local_user=self.config['fingerprint'])
-        except:
-            self.error("Signing tag failed")
-            return True
+        with self.repo.git.custom_environment(GIT_COMMITTER_DATE=date):
+            try:
+                newtag = self.repo.create_tag(
+                    self.config['tag'],
+                    ref = ref,
+                    message = self.config['message'],
+                    sign = True,
+                    local_user = self.config['fingerprint'],
+                    force = force)
+            except git.exc.GitCommandError:
+                self.error("Signing tag failed.")
+                return True
 
         # Push tag
         try:
-            self.repo.remotes.origin.push(newtag)
+            self.repo.remotes.origin.push(newtag, force = force)
         except:
            self.error("Pushing tag failed")
            return True

From 6bf3ba89105c9d13e0176da3f8bb72162f88ece2 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 15:33:39 +0200
Subject: [PATCH 27/46] Remove input flushing as it also clears STOUT for some
 readon which makes the output disappear sometimes

---
 gpgit.py | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index f087755..cabefe5 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -40,16 +40,6 @@ def signal_handler(signum, frame):
 # TODO replace armorfrom true/false to .sig/.asc?
 # TODO don't use plain except:, always specify which errors you'll get
 
-def flush_input():
-    # TODO removes in progress prints.
-    try:
-        import sys, termios
-        termios.tcflush(sys.stdin, termios.TCIOFLUSH)
-    except ImportError:
-        import msvcrt
-        while msvcrt.kbhit():
-            msvcrt.getch()
-
 class colors(object):
     RED   = "\033[1;31m"
     BLUE  = "\033[1;34m"
@@ -355,7 +345,6 @@ def analyze_step_1(self):
                     userinput = -1
                     while userinput < 0 or userinput > len(private_keys):
                         try:
-                            flush_input()
                             userinput = int(input("Please select a key number from above: "))
                         except ValueError:
                             userinput = -1
@@ -651,7 +640,6 @@ def analyze_step_5(self):
 
             # Ask for Github token
             if self.config['token'] is None:
-                flush_input()
                 try:
                     self.config['token'] = input('Enter Github token to access release API: ')
                 except KeyboardInterrupt:
@@ -943,7 +931,6 @@ def main(arguments):
     # Check if even something needs to be done
     if gpgit.todo:
         # User selection
-        flush_input()
         try:
             ret = input('Continue with the selected operations? [Y/n]')
         except KeyboardInterrupt:

From 95bc5d02edcb4529bb5e2bba7e489812c8238435 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 16:03:44 +0200
Subject: [PATCH 28/46] Improve exceptions

---
 gpgit.py | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index cabefe5..a57e79f 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -10,7 +10,7 @@
 import gzip
 import lzma
 import bz2
-from github import Github
+from github import Github, GithubException
 import git
 from git import Repo
 import gnupg
@@ -34,11 +34,9 @@ def signal_handler(signum, frame):
 # TODO proper document functions with """ to generate __docnames___
 # TODO pylint analysis
 # TODO add zip and lz support, make xz default
-# TODO swap step 4.2 and 4.3
 # TODO remove returns after self.error as it already exits
 # TODO document compression level default: gzip/bz2 max and lzma/xz 6. see note about level 6 https://docs.python.org/3/library/lzma.html
 # TODO replace armorfrom true/false to .sig/.asc?
-# TODO don't use plain except:, always specify which errors you'll get
 
 class colors(object):
     RED   = "\033[1;31m"
@@ -650,16 +648,19 @@ def analyze_step_5(self):
             self.github = Github(self.config['token'])
 
             # Acces Github API
+            print(dir(GithubException))
             try:
                 self.githubuser = self.github.get_user()
                 self.githubrepo = self.githubuser.get_repo(self.config['project'])
-            except:
-                self.error('Error accessing Github API for project ' + self.config['project'])
+            except GithubException:
+                # TODO improve: https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
+                self.error('Error accessing Github API for project ' + self.config['project'] + '. Wrong token?')
 
             # Check Release and its assets
             try:
                 self.release = self.githubrepo.get_release(self.config['tag'])
-            except:
+            except GithubException:
+                # TODO improve: https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
                 self.newassets = self.assets
                 self.set_substep_status('5.1', 'TODO',
                     'Creating release and uploading release files to Github')
@@ -774,11 +775,12 @@ def step_3_3(self):
                 return True
 
         # Push tag
-        try:
-            self.repo.remotes.origin.push(newtag, force = force)
-        except:
-           self.error("Pushing tag failed")
-           return True
+        #try:
+        self.repo.remotes.origin.push(newtag, force = force)
+        # TODO check exception https://github.com/gitpython-developers/GitPython/issues/621
+        # except ???:
+        #    self.error("Pushing tag failed")
+        #    return True
 
     # Create compressed archive
     def step_4_1(self):

From fa3c2a08c20d58b1302fad35a2feea3e5f52166f Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 16:11:06 +0200
Subject: [PATCH 29/46] Minor fixes

---
 gpgit.py | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index a57e79f..511c876 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -30,14 +30,6 @@ def signal_handler(signum, frame):
     finally:
         signal.alarm(0)
 
-# TODO: check == True to is True
-# TODO proper document functions with """ to generate __docnames___
-# TODO pylint analysis
-# TODO add zip and lz support, make xz default
-# TODO remove returns after self.error as it already exits
-# TODO document compression level default: gzip/bz2 max and lzma/xz 6. see note about level 6 https://docs.python.org/3/library/lzma.html
-# TODO replace armorfrom true/false to .sig/.asc?
-
 class colors(object):
     RED   = "\033[1;31m"
     BLUE  = "\033[1;34m"
@@ -425,7 +417,7 @@ def analyze_step_2(self):
             'Please publish the full GPG fingerprint on your project page')
 
         # Check Github GPG key
-        if self.config['github'] == True:
+        if self.config['github'] is True:
             # TODO Will associate your GPG key with Github
             self.set_substep_status('2.2', 'NOTE',
                 'Please associate your GPG key with Github')
@@ -475,7 +467,7 @@ def analyze_step_3(self):
                 'Git already configured with your GPG key')
 
         # Check commit signing
-        if self.config['gpgsign'] == True:
+        if self.config['gpgsign'] is True:
             self.set_substep_status('3.2', 'OK',
                 'Commit signing already enabled')
         else:
@@ -632,7 +624,7 @@ def analyze_step_4(self):
 
     def analyze_step_5(self):
         # Check Github GPG key
-        if self.config['github'] == True:
+        if self.config['github'] is True:
             self.set_substep_status('5.2', 'OK',
                 'Github uses well configured https')
 
@@ -772,7 +764,6 @@ def step_3_3(self):
                     force = force)
             except git.exc.GitCommandError:
                 self.error("Signing tag failed.")
-                return True
 
         # Push tag
         #try:
@@ -780,7 +771,6 @@ def step_3_3(self):
         # TODO check exception https://github.com/gitpython-developers/GitPython/issues/621
         # except ???:
         #    self.error("Pushing tag failed")
-        #    return True
 
     # Create compressed archive
     def step_4_1(self):
@@ -895,7 +885,6 @@ def run(self):
         for step in self.Steps:
             if step.run():
                 self.error('Executing step failed')
-                return True
 
     def error(self, msg):
         print(colors.RED + '==> Error:' + colors.RESET, msg)

From 2aaf867aa790f6c414c3fabfded32152d8fcc069 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 13 May 2017 16:47:10 +0200
Subject: [PATCH 30/46] Style fixes

---
 gpgit.py | 298 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 152 insertions(+), 146 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 511c876..15710e8 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -4,18 +4,17 @@
 import os
 import sys
 import argparse
-import tempfile
-import filecmp
 import hashlib
 import gzip
 import lzma
 import bz2
+import signal
+from contextlib import contextmanager
 from github import Github, GithubException
 import git
 from git import Repo
 import gnupg
-import signal
-from contextlib import contextmanager
+
 
 class TimeoutException(Exception): pass
 
@@ -31,14 +30,14 @@ def signal_handler(signum, frame):
         signal.alarm(0)
 
 class colors(object):
-    RED   = "\033[1;31m"
-    BLUE  = "\033[1;34m"
-    CYAN  = "\033[1;36m"
+    RED = "\033[1;31m"
+    BLUE = "\033[1;34m"
+    CYAN = "\033[1;36m"
     MAGENTA = "\033[1;35m"
     YELLOW = "\033[1;33m"
     GREEN = "\033[1;32m"
     UNDERLINE = '\033[4m'
-    BOLD    = "\033[;1m"
+    BOLD = "\033[;1m"
     REVERSE = "\033[;7m"
     RESET = "\033[0;0m"
 
@@ -74,7 +73,8 @@ def printstatus(self):
             raise SystemError('Internal error. Please report this issue.')
 
         # Sample: "1.2 [ OK ] Key already generated"
-        print(colors.BOLD + '  ' + self.number, self.color[self.status] + '[' + self.status.center(4) + ']' + colors.RESET, self.msg)
+        print(colors.BOLD + '  ' + self.number, self.color[self.status] + '['
+              + self.status.center(4) + ']' + colors.RESET, self.msg)
 
         # Sample: " -> [INFO] GPG key: [rsa4096] 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161"
         for info in self.infos:
@@ -143,8 +143,8 @@ class GPGit(object):
         }
 
     # TODO add elliptic curve support
-    gpgSecureAlgorithmIDs = [ '1', '3' ]
-    gpgSecureKeyLength = [ '2048', '4096' ]
+    gpgSecureAlgorithmIDs = ['1', '3']
+    gpgSecureKeyLength = ['2048', '4096']
 
     compressionAlgorithms = {
         'gz': gzip,
@@ -246,7 +246,8 @@ def load_defaults(self):
 
         # Default message
         if self.config['message'] is None:
-            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' + self.version + '\nhttps://github.com/NicoHood/gpgit'
+            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' \
+                                     + self.version + '\nhttps://github.com/NicoHood/gpgit'
 
         # Default output path
         if self.config['output'] is None:
@@ -268,7 +269,8 @@ def load_defaults(self):
 
         # Set default project name
         if self.config['project'] is None:
-            self.config['project'] = os.path.basename(self.repo.remotes.origin.url).replace('.git','')
+            url = self.repo.remotes.origin.url
+            self.config['project'] = os.path.basename(url).replace('.git', '')
 
         # Default config level (repository == local)
         self.config['config_level'] = 'repository'
@@ -312,7 +314,7 @@ def analyze_step_1(self):
         for key in private_keys:
             # Check key algorithm gpgit support
             if key['algo'] not in self.gpgAlgorithmIDs:
-                raise SystemError('Unknown key algorithm. Please report this issue. ID: ' + key['algo'])
+                raise SystemError('Unknown key algorithm ID: ' + key['algo'])
             else:
                 key['algoname'] = self.gpgAlgorithmIDs[key['algo']]
 
@@ -328,7 +330,8 @@ def analyze_step_1(self):
                 # Print option menu
                 print('0: Generate a new RSA 4096 key')
                 for i, key in enumerate(private_keys, start=1):
-                    print(str(i) + ':', key['fingerprint'], key['uids'][0], key['algoname'], key['length'])
+                    print(str(i) + ':', key['fingerprint'], key['uids'][0], key['algoname'],
+                          key['length'])
 
                 # User input
                 try:
@@ -351,9 +354,8 @@ def analyze_step_1(self):
         if self.config['fingerprint'] is not None:
             # Check if the full fingerprint is used
             if len(self.config['fingerprint']) != 40:
-                self.set_substep_status('1.2', 'FAIL',
-                    'Please specify the full fingerprint',
-                    ['GPG ID: ' + self.config['fingerprint']])
+                self.set_substep_status('1.2', 'FAIL', 'Please specify the full fingerprint',
+                                        ['GPG ID: ' + self.config['fingerprint']])
                 return True
 
             # Find selected key
@@ -364,73 +366,63 @@ def analyze_step_1(self):
 
             # Check if key is available in keyring
             if self.gpgkey is None:
-                self.set_substep_status('1.2', 'FAIL',
-                    'Selected key is not available in keyring',
-                    ['GPG ID: ' + self.config['fingerprint']])
+                self.set_substep_status('1.2', 'FAIL', 'Selected key is not available in keyring',
+                                        ['GPG ID: ' + self.config['fingerprint']])
                 return True
 
             # Check key algorithm security
             if self.gpgkey['algo'] not in self.gpgSecureAlgorithmIDs \
                     or self.gpgkey['length'] not in self.gpgSecureKeyLength:
-                self.set_substep_status('1.2', 'FAIL',
-                    'Insecure key algorithm used: '
-                    + self.gpgkey['algoname'] + ' '
-                    + self.gpgkey['length'],
-                    ['GPG ID: ' + self.config['fingerprint']])
+                self.set_substep_status('1.2', 'FAIL', 'Insecure key algorithm used: '
+                                        + self.gpgkey['algoname'] + ' ' + self.gpgkey['length'],
+                                        ['GPG ID: ' + self.config['fingerprint']])
                 return True
 
             # Check key algorithm security
             if self.gpgkey['trust'] == 'r':
-                self.set_substep_status('1.2', 'FAIL',
-                    'Selected key is revoked',
-                    ['GPG ID: ' + self.config['fingerprint']])
+                self.set_substep_status('1.2', 'FAIL', 'Selected key is revoked',
+                                        ['GPG ID: ' + self.config['fingerprint']])
                 return True
 
             # Use selected key
-            self.set_substep_status('1.2', 'OK',
-                'Key already generated', [
-                    'GPG key: ' + self.gpgkey['uids'][0],
-                    'GPG ID: [' + self.gpgkey['algoname'] + ' '
-                    + self.gpgkey['length'] + '] ' + self.gpgkey['fingerprint']
-                    + ' '
-                ])
+            self.set_substep_status('1.2', 'OK', 'Key already generated',
+                                    [
+                                    'GPG key: ' + self.gpgkey['uids'][0],
+                                    'GPG ID: [' + self.gpgkey['algoname'] + ' '
+                                    + self.gpgkey['length'] + '] ' + self.gpgkey['fingerprint']
+                                    + ' ' ])
 
             # Warn about strong passphrase
-            self.set_substep_status('1.1', 'NOTE',
-                'Please use a strong, unique, secret passphrase')
+            self.set_substep_status('1.1', 'NOTE', 'Please use a strong, unique, secret passphrase')
 
         else:
             # Generate a new key
-            self.set_substep_status('1.2', 'TODO',
-                'Generating an RSA 4096 GPG key for '
-                + self.config['username']
-                + ' ' + self.config['email']
-                + ' valid for 1 year.')
+            self.set_substep_status('1.2', 'TODO', 'Generating an RSA 4096 GPG key for '
+                                    + self.config['username']
+                                    + ' ' + self.config['email']
+                                    + ' valid for 1 year.')
 
             # Warn about strong passphrase
-            self.set_substep_status('1.1', 'TODO',
-                'Please use a strong, unique, secret passphrase')
+            self.set_substep_status('1.1', 'TODO', 'Please use a strong, unique, secret passphrase')
 
     def analyze_step_2(self):
         # Add publish note
         self.set_substep_status('2.3', 'NOTE',
-            'Please publish the full GPG fingerprint on your project page')
+                                'Please publish the full GPG fingerprint on your project page')
 
         # Check Github GPG key
         if self.config['github'] is True:
             # TODO Will associate your GPG key with Github
-            self.set_substep_status('2.2', 'NOTE',
-                'Please associate your GPG key with Github')
+            self.set_substep_status('2.2', 'NOTE', 'Please associate your GPG key with Github')
         else:
-            self.set_substep_status('2.2', 'OK',
-                'No Github repository used')
+            self.set_substep_status('2.2', 'OK', 'No Github repository used')
 
         if self.config['fingerprint'] is None:
             self.set_substep_status('2.3', 'TODO',
-                'Please publish the full GPG fingerprint on your project page')
+                                    'Please publish the full GPG fingerprint on your project page')
         else:
             self.set_substep_status('2.3', 'NOTE',
-                'Please publish the full GPG fingerprint on your project page')
+                                    'Please publish the full GPG fingerprint on your project page')
 
         # Only check if a fingerprint was specified
         if self.config['fingerprint'] is not None:
@@ -444,12 +436,11 @@ def analyze_step_2(self):
             # Found key on keyserver
             if self.config['fingerprint'] in key.fingerprints:
                 self.set_substep_status('2.1', 'OK',
-                    'Key already published on ' + self.config['keyserver'])
+                                        'Key already published on ' + self.config['keyserver'])
                 return
 
         # Upload key to keyserver
-        self.set_substep_status('2.1', 'TODO',
-            'Publishing key on ' + self.config['keyserver'])
+        self.set_substep_status('2.1', 'TODO', 'Publishing key on ' + self.config['keyserver'])
 
     def analyze_step_3(self):
         # Check if git was already configured with the gpg key
@@ -459,21 +450,17 @@ def analyze_step_3(self):
             if self.config['signingkey'] is None:
                 self.config['config_level'] = 'global'
 
-            self.set_substep_status('3.1', 'TODO',
-                'Configuring ' + self.config['config_level']
-                + ' git settings with your GPG key')
+            self.set_substep_status('3.1', 'TODO', 'Configuring ' + self.config['config_level']
+                                    + ' git settings with your GPG key')
         else:
-            self.set_substep_status('3.1', 'OK',
-                'Git already configured with your GPG key')
+            self.set_substep_status('3.1', 'OK', 'Git already configured with your GPG key')
 
         # Check commit signing
         if self.config['gpgsign'] is True:
-            self.set_substep_status('3.2', 'OK',
-                'Commit signing already enabled')
+            self.set_substep_status('3.2', 'OK', 'Commit signing already enabled')
         else:
-            self.set_substep_status('3.2', 'TODO',
-                'Enabling ' + self.config['config_level']
-                + ' git settings with commit signing')
+            self.set_substep_status('3.2', 'TODO', 'Enabling ' + self.config['config_level']
+                                    + ' git settings with commit signing')
 
         # Refresh tags
         try:
@@ -486,22 +473,21 @@ def analyze_step_3(self):
         if tag in self.repo.tags:
             # Verify signature
             try:
-                self.repo.create_tag(self.config['tag'],
-                    verify=True,
-                    ref=None)
+                self.repo.create_tag(self.config['tag'], verify=True, ref=None)
             except git.exc.GitCommandError:
-                if hasattr(tag.tag, 'message') and '-----BEGIN PGP SIGNATURE-----' in tag.tag.message:
+                if hasattr(tag.tag, 'message') \
+                        and '-----BEGIN PGP SIGNATURE-----' in tag.tag.message:
                     self.set_substep_status('3.3', 'FAIL',
-                        'Invalid signature for tag ' + self.config['tag'])
+                                            'Invalid signature for tag ' + self.config['tag'])
                     return True
-                self.set_substep_status('3.3', 'TODO',
-                    'Adding signature for unsigned tag: ' + self.config['tag'])
+                self.set_substep_status('3.3', 'TODO', 'Adding signature for unsigned tag: '
+                                        + self.config['tag'])
             else:
-                self.set_substep_status('3.3', 'OK',
-                    'Good signature for existing tag: ' + self.config['tag'])
+                self.set_substep_status('3.3', 'OK', 'Good signature for existing tag: '
+                                        + self.config['tag'])
         else:
-            self.set_substep_status('3.3', 'TODO',
-                'Creating signed tag ' + self.config['tag'] + ' and pushing it to the remote git')
+            self.set_substep_status('3.3', 'TODO', 'Creating signed tag ' + self.config['tag']
+                                    + ' and pushing it to the remote git')
 
     def analyze_step_4(self):
         # Check all compression option tar files
@@ -517,29 +503,33 @@ def analyze_step_4(self):
                 # Check if tag exists
                 if self.repo.tag('refs/tags/' + self.config['tag']) not in self.repo.tags:
                     self.set_substep_status('4.1', 'FAIL',
-                        'Archive exists but no corresponding tag!?', [tarfilepath])
+                                            'Archive exists but no corresponding tag!?',
+                                            [tarfilepath])
                     return True
 
                 # Verify existing archive
                 try:
                     with self.compressionAlgorithms[tar].open(tarfilepath, "rb") as tarstream:
                         cmptar = strmcmp(tarstream)
-                        self.repo.archive(cmptar, treeish=self.config['tag'], prefix=filename + '/', format='tar')
+                        self.repo.archive(cmptar, treeish=self.config['tag'],
+                                          prefix=filename + '/', format='tar')
                         if not cmptar.equal():
                             self.set_substep_status('4.1', 'FAIL',
-                                'Existing archive differs from local source', [tarfilepath])
+                                                    'Existing archive differs from local source',
+                                                    [tarfilepath])
                             return True
                 except lzma.LZMAError:
-                    self.set_substep_status('4.1', 'FAIL',
-                        'Archive not in ' + tar + ' format', [tarfilepath])
+                    self.set_substep_status('4.1', 'FAIL', 'Archive not in ' + tar + ' format',
+                                            [tarfilepath])
                     return True
 
                 # Successfully verified
-                self.set_substep_status('4.1', 'OK',
-                    'Existing archive(s) verified successfully', ['Path: ' + self.config['output'], 'Basename: ' + filename])
+                self.set_substep_status('4.1', 'OK', 'Existing archive(s) verified successfully',
+                                        ['Path: ' + self.config['output'], 'Basename: ' + filename])
             else:
-                self.set_substep_status('4.1', 'TODO',
-                    'Creating new release archive(s): ' + ', '.join(str(x) for x in self.config['tar']), ['Path: ' + self.config['output'], 'Basename: ' + filename])
+                self.set_substep_status('4.1', 'TODO', 'Creating new release archive(s): '
+                                        + ', '.join(str(x) for x in self.config['tar']), [
+                                        'Path: ' + self.config['output'], 'Basename: ' + filename])
 
             # Get signature filename from setting
             if self.config['no_armor']:
@@ -554,8 +544,8 @@ def analyze_step_4(self):
                 # Check if signature for tar exists
                 if not os.path.isfile(tarfilepath):
                     self.set_substep_status('4.2', 'FAIL',
-                        'Signature found without corresponding archive',
-                        [sigfilepath])
+                                            'Signature found without corresponding archive',
+                                            [sigfilepath])
                     return True
 
                 # Verify signature
@@ -567,17 +557,15 @@ def analyze_step_4(self):
                             or verified.fingerprint != self.config['fingerprint']:
                         if verified.trust_text is None:
                             verified.trust_text = 'Invalid signature'
-                        self.set_substep_status('4.2', 'FAIL',
-                            'Signature could not be verified successfully with gpg',
-                            [sigfilepath, 'Trust level: ' + verified.trust_text])
+                        self.set_substep_status('4.2', 'FAIL', 'Signature could not be verified ' \
+                                                + 'successfully with gpg', [
+                                                sigfilepath, 'Trust level: ' + verified.trust_text])
                         return True
 
                 # Successfully verified
-                self.set_substep_status('4.2', 'OK',
-                    'Existing signature(s) verified successfully')
+                self.set_substep_status('4.2', 'OK', 'Existing signature(s) verified successfully')
             else:
-                self.set_substep_status('4.2', 'TODO',
-                    'Creating GPG signature(s) for archive(s)')
+                self.set_substep_status('4.2', 'TODO', 'Creating GPG signature(s) for archive(s)')
 
             # Verify all selected shasums if existant
             for sha in self.config['sha']:
@@ -597,9 +585,8 @@ def analyze_step_4(self):
                 if os.path.isfile(shafilepath):
                     # Check if tar for hash exists
                     if not os.path.isfile(tarfilepath):
-                        self.set_substep_status('4.3', 'FAIL',
-                            'Message digest found without corresponding archive',
-                            [shafilepath])
+                        self.set_substep_status('4.3', 'FAIL', 'Message digest found without ' \
+                                                + 'corresponding archive', [shafilepath])
                         return True
 
                     # Read hash and filename
@@ -611,22 +598,22 @@ def analyze_step_4(self):
                             or self.hash[sha][tarfile] != hashinfo[0] \
                             or os.path.basename(hashinfo[1]) != tarfile:
                         self.set_substep_status('4.3', 'FAIL',
-                            'Message digest could not be successfully verified',
-                            [shafilepath])
+                                                'Message digest could not be successfully verified',
+                                                [shafilepath])
                         return True
 
                     # Successfully verified
                     self.set_substep_status('4.3', 'OK',
-                        'Existing message digest(s) verified successfully')
+                                            'Existing message digest(s) verified successfully')
                 else:
                     self.set_substep_status('4.3', 'TODO',
-                        'Creating message digest(s) for archive(s): ' + ', '.join(str(x) for x in self.config['sha']))
+                                            'Creating message digest(s) for archive(s): '
+                                            + ', '.join(str(x) for x in self.config['sha']))
 
     def analyze_step_5(self):
         # Check Github GPG key
         if self.config['github'] is True:
-            self.set_substep_status('5.2', 'OK',
-                'Github uses well configured https')
+            self.set_substep_status('5.2', 'OK', 'Github uses well configured https')
 
             # Ask for Github token
             if self.config['token'] is None:
@@ -640,22 +627,24 @@ def analyze_step_5(self):
             self.github = Github(self.config['token'])
 
             # Acces Github API
-            print(dir(GithubException))
             try:
                 self.githubuser = self.github.get_user()
                 self.githubrepo = self.githubuser.get_repo(self.config['project'])
             except GithubException:
-                # TODO improve: https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
-                self.error('Error accessing Github API for project ' + self.config['project'] + '. Wrong token?')
+                # TODO improve:
+                #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
+                self.error('Error accessing Github API for project ' + self.config['project']
+                           + '. Wrong token?')
 
             # Check Release and its assets
             try:
                 self.release = self.githubrepo.get_release(self.config['tag'])
             except GithubException:
-                # TODO improve: https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
+                # TODO improve:
+                #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
                 self.newassets = self.assets
                 self.set_substep_status('5.1', 'TODO',
-                    'Creating release and uploading release files to Github')
+                                        'Creating release and uploading release files to Github')
                 return
             else:
                 # Determine which assets need to be uploaded
@@ -666,21 +655,21 @@ def analyze_step_5(self):
 
             # Check if assets already uploaded
             if len(self.newassets) == 0:
-                self.set_substep_status('5.1', 'OK',
-                    'Release already published on Github')
+                self.set_substep_status('5.1', 'OK', 'Release already published on Github')
             else:
-                self.set_substep_status('5.1', 'TODO',
-                    'Uploading release files to Github')
+                self.set_substep_status('5.1', 'TODO', 'Uploading release files to Github')
 
         else:
             self.set_substep_status('5.1', 'NOTE',
-                'Please upload the compressed archive, signature and message digest manually')
+                                    'Please upload the compressed archive, signature and message ' \
+                                    + 'digest manually')
             self.set_substep_status('5.2', 'NOTE',
-                'Please configure HTTPS for your download server')
+                                    'Please configure HTTPS for your download server')
 
     # Strong, unique, secret passphrase
     def step_1_1(self):
-        print(colors.BLUE + ':: ' + colors.RESET + 'More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
+        print(colors.BLUE + ':: ' + colors.RESET
+              + 'More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
 
     # Key generation
     def step_1_2(self):
@@ -702,12 +691,17 @@ def step_1_2(self):
         """.format(self.config['username'], self.config['email'])
 
         # Execute gpg key generation command
-        print(colors.BLUE + ':: ' + colors.RESET + 'We need to generate a lot of random bytes. It is a good idea to perform')
-        print(colors.BLUE + ':: ' + colors.RESET + 'some other action (type on the keyboard, move the mouse, utilize the')
-        print(colors.BLUE + ':: ' + colors.RESET + 'disks) during the prime generation; this gives the random number')
-        print(colors.BLUE + ':: ' + colors.RESET + 'generator a better chance to gain enough entropy.')
+        print(colors.BLUE + ':: ' + colors.RESET
+              + 'We need to generate a lot of random bytes. It is a good idea to perform')
+        print(colors.BLUE + ':: ' + colors.RESET
+              + 'some other action (type on the keyboard, move the mouse, utilize the')
+        print(colors.BLUE + ':: ' + colors.RESET
+              + 'disks) during the prime generation; this gives the random number')
+        print(colors.BLUE + ':: ' + colors.RESET
+              + 'generator a better chance to gain enough entropy.')
         self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
-        print(colors.BLUE + ':: ' + colors.RESET + 'Key generation finished. You new fingerprint is: ' + self.config['fingerprint'])
+        print(colors.BLUE + ':: ' + colors.RESET
+              + 'Key generation finished. You new fingerprint is: ' + self.config['fingerprint'])
 
     # Submit your key to a key server
     def step_2_1(self):
@@ -736,7 +730,8 @@ def step_3_2(self):
 
     # Create signed git tag
     def step_3_3(self):
-        print(colors.BLUE + ':: ' + colors.RESET + 'Creating, signing and pushing tag', self.config['tag'])
+        print(colors.BLUE + ':: ' + colors.RESET + 'Creating, signing and pushing tag',
+              self.config['tag'])
 
         # Check if tag needs to be recreated
         force = False
@@ -757,17 +752,17 @@ def step_3_3(self):
             try:
                 newtag = self.repo.create_tag(
                     self.config['tag'],
-                    ref = ref,
-                    message = self.config['message'],
-                    sign = True,
-                    local_user = self.config['fingerprint'],
-                    force = force)
+                    ref=ref,
+                    message=self.config['message'],
+                    sign=True,
+                    local_user=self.config['fingerprint'],
+                    force=force)
             except git.exc.GitCommandError:
                 self.error("Signing tag failed.")
 
         # Push tag
         #try:
-        self.repo.remotes.origin.push(newtag, force = force)
+        self.repo.remotes.origin.push(newtag, force=force)
         # TODO check exception https://github.com/gitpython-developers/GitPython/issues/621
         # except ???:
         #    self.error("Pushing tag failed")
@@ -785,7 +780,8 @@ def step_4_1(self):
             if not os.path.isfile(tarfilepath):
                 print(colors.BLUE + ':: ' + colors.RESET + 'Creating', tarfilepath)
                 with self.compressionAlgorithms[tar].open(tarfilepath, 'wb') as tarstream:
-                    self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/', format='tar')
+                    self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/',
+                                      format='tar')
 
     # Sign the sources
     def step_4_2(self):
@@ -838,15 +834,15 @@ def step_4_3(self):
                     # Calculate hash of tarfile
                     if tarfile not in self.hash[sha]:
                         hash_sha = hashlib.new(sha)
-                        with open(tarfilepath, "rb") as f:
-                            for chunk in iter(lambda: f.read(4096), b""):
+                        with open(tarfilepath, "rb") as filestream:
+                            for chunk in iter(lambda: filestream.read(4096), b""):
                                 hash_sha.update(chunk)
                         self.hash[sha][tarfile] = hash_sha.hexdigest()
 
                     # Write cached hash and filename
                     print(colors.BLUE + ':: ' + colors.RESET + 'Creating', shafilepath)
-                    with open(shafilepath, "w") as f:
-                        f.write(self.hash[sha][tarfile] + '  ' + tarfile)
+                    with open(shafilepath, "w") as filestream:
+                        filestream.write(self.hash[sha][tarfile] + '  ' + tarfile)
 
     # Github
     def step_5_1(self):
@@ -862,7 +858,8 @@ def step_5_1(self):
         for asset in self.newassets:
             assetpath = os.path.join(self.config['output'], asset)
             print(colors.BLUE + ':: ' + colors.RESET + 'Uploading', assetpath)
-            # TODO not functional see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
+            # TODO not functional
+            # see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
             # TODO change label and mime type
             self.release.upload_asset(assetpath, "Testlabel", "application/x-xz")
 
@@ -892,24 +889,33 @@ def error(self, msg):
 
 
 def main(arguments):
-    parser = argparse.ArgumentParser(description=
-    'A python script that automates the process of signing git sources via GPG.')
+    parser = argparse.ArgumentParser(description='A python script that automates the process of ' \
+                                     + 'signing git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')
-    parser.add_argument('-o', '--output', action='store', help='output path of the compressed archive, signature and message digest')
-    parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(), help='path of the git project')
-    parser.add_argument('-f', '--fingerprint', action='store', help='(full) GPG fingerprint to use for signing/verifying')
-    parser.add_argument('-p', '--project', action='store', help='name of the project, used for archive generation')
+    parser.add_argument('-o', '--output', action='store',
+                        help='output path of the compressed archive, signature and message digest')
+    parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(),
+                        help='path of the git project')
+    parser.add_argument('-f', '--fingerprint', action='store',
+                        help='(full) GPG fingerprint to use for signing/verifying')
+    parser.add_argument('-p', '--project', action='store',
+                        help='name of the project, used for archive generation')
     parser.add_argument('-e', '--email', action='store', help='email used for gpg key generation')
-    parser.add_argument('-u', '--username', action='store', help='username used for gpg key generation')
-    parser.add_argument('-c', '--comment', action='store', help='comment used for gpg key generation')
-    parser.add_argument('-k', '--keyserver', action='store', default='hkps://pgp.mit.edu', help='keyserver to use for up/downloading gpg keys')
-    parser.add_argument('-n', '--no-github', action='store_false', dest='github', help='disable Github API functionallity')
+    parser.add_argument('-u', '--username', action='store',
+                        help='username used for gpg key generation')
+    parser.add_argument('-k', '--keyserver', action='store', default='hkps://pgp.mit.edu',
+                        help='keyserver to use for up/downloading gpg keys')
+    parser.add_argument('-n', '--no-github', action='store_false', dest='github',
+                        help='disable Github API functionallity')
     parser.add_argument('-a', '--prerelease', action='store_true', help='Flag as Github prerelease')
-    parser.add_argument('-t', '--tar', choices=['gz', 'gzip', 'xz', 'bz2', 'bzip2'], default=['xz'], nargs='+', help='compression option')
-    parser.add_argument('-s', '--sha', choices=['sha256', 'sha384', 'sha512'], default=['sha512'], nargs='+', help='message digest option')
-    parser.add_argument('-b', '--no-armor', action='store_true', help='do not create ascii armored signature output')
+    parser.add_argument('-t', '--tar', choices=['gz', 'gzip', 'xz', 'bz2', 'bzip2'], default=['xz'],
+                        nargs='+', help='compression option')
+    parser.add_argument('-s', '--sha', choices=['sha256', 'sha384', 'sha512'], default=['sha512'],
+                        nargs='+', help='message digest option')
+    parser.add_argument('-b', '--no-armor', action='store_true',
+                        help='do not create ascii armored signature output')
 
     args = parser.parse_args()
 

From 30e21eb2af83adffbb1c9acd48c59435c66bd0f2 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Wed, 17 May 2017 21:14:19 +0200
Subject: [PATCH 31/46] Refactor class layout

---
 gpgit.py | 1011 +++++++++++++++++++++++++++---------------------------
 1 file changed, 497 insertions(+), 514 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 15710e8..a724bcd 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -42,18 +42,8 @@ class colors(object):
     RESET = "\033[0;0m"
 
 class Substep(object):
-    color = {
-        'OK': colors.GREEN,
-        'FAIL': colors.RED,
-        'INFO': colors.YELLOW,
-        'WARN': colors.YELLOW,
-        'TODO': colors.MAGENTA,
-        'NOTE': colors.BLUE,
-        }
-
-    def __init__(self, number, name, funct):
+    def __init__(self, name, funct):
         # Params
-        self.number = number
         self.name = name
         self.funct = funct
 
@@ -62,76 +52,28 @@ def __init__(self, number, name, funct):
         self.msg = 'Aborting due to previous errors'
         self.infos = []
 
-    def setstatus(self, status, msg, infos):
-        self.status = status
-        self.msg = msg
-        self.infos = infos
-
-    def printstatus(self):
-        # Check if status is known
-        if self.status not in self.color:
-            raise SystemError('Internal error. Please report this issue.')
-
-        # Sample: "1.2 [ OK ] Key already generated"
-        print(colors.BOLD + '  ' + self.number, self.color[self.status] + '['
-              + self.status.center(4) + ']' + colors.RESET, self.msg)
-
-        # Sample: " -> [INFO] GPG key: [rsa4096] 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161"
-        for info in self.infos:
-            print(colors.BOLD + '   -> ' + self.color['INFO'] + '[INFO]' + colors.RESET, info)
-
-        # Check for error
-        if self.status == 'FAIL':
-            return True
-
-    def run(self):
-        # Run selected step function if activated
-        if self.status == 'TODO':
-            # Sample: "  -> Will associate your GPG key with Github"
-            print(colors.BLUE + "  ->", colors.BOLD + self.msg + colors.RESET)
-            return self.funct()
-
 class Step(object):
-    def __init__(self, number, name, substeps):
+    def __init__(self, name, *args):
         # Params
-        self.number = number
         self.name = name
-        self.substeps = substeps
-
-    def printstatus(self):
-        # Sample: "1. Generate a new GPG key"
-        print(colors.BOLD + self.number, self.name + colors.RESET)
-        err = False
-        for substep in self.substeps:
-            if substep.printstatus():
-                err = True
-        return err
-
-    def run(self):
-        # Run all substeps if enabled
-        # Sample: "==> 2. Publish your key"
-        print(colors.GREEN + "==>", colors.BOLD + self.number, self.name + colors.RESET)
-        for substep in self.substeps:
-            if substep.run():
-                return True
-
-# Helper class to compare a stream without writing
-class strmcmp(object):
-    def __init__(self, strmcmp):
-        self.strmcmp = strmcmp
-        self.__equal = True
-    def write(self, data):
-        if data != self.strmcmp.read(len(data)):
-            self.__equal = False
-    def equal(self):
-        # Check end of file too
-        if self.strmcmp.read(1) == b'' and self.__equal:
-            return True
-
-class GPGit(object):
-    version = '2.0.0'
-
-    # RFC4880 9.1.  Public-Key Algorithms
+        self.substeps = []
+        for substep in args:
+            self.substeps += [substep]
+
+    def print_exec(self, msg):
+        # TODO only with verbose?
+        print(colors.BLUE + ':: ' + colors.RESET + msg)
+
+    def setstatus(self, subnumber, status, msg, *args):
+        if subnumber > 0:
+            self.substeps[subnumber - 1].status = status
+            self.substeps[subnumber - 1].msg = msg
+            self.substeps[subnumber - 1].infos = []
+            for info in args:
+                self.substeps[subnumber - 1].infos += [info]
+
+class Step1(Step):
+    # RFC4880 9.1. Public-Key Algorithms
     gpgAlgorithmIDs = {
         '1': 'RSA',
         '2': 'RSA Encrypt-Only',
@@ -146,177 +88,25 @@ class GPGit(object):
     gpgSecureAlgorithmIDs = ['1', '3']
     gpgSecureKeyLength = ['2048', '4096']
 
-    compressionAlgorithms = {
-        'gz': gzip,
-        'gzip': gzip,
-        'xz': lzma,
-        'bz2': bz2,
-        'bzip2': bz2,
-    }
-
-    def __init__(self, config):
-        self.Steps = [
-            Step('1.', 'Generate a new GPG key', [
-                Substep('1.1', 'Strong, unique, secret passphrase', self.step_1_1),
-                Substep('1.2', 'Key generation', self.step_1_2),
-                ]),
-            Step('2.', 'Publish your key', [
-                Substep('2.1', 'Submit your key to a key server', self.step_2_1),
-                Substep('2.2', 'Associate GPG key with Github', self.step_2_2),
-                Substep('2.3', 'Publish your full fingerprint', self.step_2_3),
-                ]),
-            Step('3.', 'Usage of GPG by git', [
-                Substep('3.1', 'Configure git GPG key', self.step_3_1),
-                Substep('3.2', 'Commit signing', self.step_3_2),
-                Substep('3.3', 'Create signed git tag', self.step_3_3),
-                ]),
-            Step('4.', 'Creation of a signed compressed release archive', [
-                Substep('4.1', 'Create compressed archive', self.step_4_1),
-                Substep('4.2', 'Sign the sources', self.step_4_2),
-                Substep('4.3', 'Create the message digest', self.step_4_3),
-                ]),
-            Step('5.', 'Upload the release', [
-                Substep('5.1', 'Github', self.step_5_1),
-                Substep('5.2', 'Configure HTTPS for your download server', self.step_5_2),
-                ])
-            ]
-
-        # Config via parameters
+    def __init__(self, config, gpg):
+        # Params
         self.config = config
+        self.gpg = gpg
 
-        # Github API
-        self.github = None
-        self.githubuser = None
-        self.githubrepo = None
-        self.release = None
-        self.assets = []
-        self.newassets = []
-        self.todo = False
-
-        # GPG
-        self.gpg = gnupg.GPG()
-        self.gpgkey = None
-
-        # Git
-        self.repo = None
-
-        # Expand hash info list
-        self.hash = {}
-        for sha in self.config['sha']:
-            self.hash[sha] = {}
-
-    def load_defaults(self):
-        # Create git repository instance
-        try:
-            self.repo = Repo(self.config['git_dir'], search_parent_directories=True)
-        except git.exc.InvalidGitRepositoryError:
-            self.error('Not inside a git directory: ' + self.config['git_dir'])
-        reader = self.repo.config_reader()
-
-        gitconfig = [
-            ['username', 'user', 'name'],
-            ['email', 'user', 'email'],
-            ['signingkey', 'user', 'signingkey'],
-            ['gpgsign', 'commit', 'gpgsign'],
-            ['output', 'user', 'gpgitoutput'],
-            ['token', 'user', 'githubtoken']
-        ]
-
-        # Read in git config values
-        for config in gitconfig:
-            # Create not existing keys
-            if config[0] not in self.config:
-                self.config[config[0]] = None
-
-            # Check if gitconfig provides a setting
-            if self.config[config[0]] is None and reader.has_option(config[1], config[2]):
-                val = reader.get_value(config[1], config[2])
-                if type(val) == int:
-                    val = str(val)
-                self.config[config[0]] = val
-
-        # Get default git signing key
-        if self.config['fingerprint'] is None and self.config['signingkey']:
-            self.config['fingerprint'] = self.config['signingkey']
-
-        # Check if Github URL is used
-        if self.config['github'] is True:
-            if 'github' not in self.repo.remotes.origin.url.lower():
-                self.config['github'] = False
-
-        # Default message
-        if self.config['message'] is None:
-            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' \
-                                     + self.version + '\nhttps://github.com/NicoHood/gpgit'
-
-        # Default output path
-        if self.config['output'] is None:
-            self.config['output'] = os.path.join(self.repo.working_tree_dir, 'archive')
-
-        # Check if path exists
-        if not os.path.isdir(self.config['output']):
-            # Create not existing path
-            print('Not a valid path: ' + self.config['output'])
-            try:
-                ret = input('Create non-existing output path? [Y/n]')
-            except KeyboardInterrupt:
-                print()
-                self.error('Aborted by user')
-            if ret == 'y' or ret == '':
-                os.makedirs(self.config['output'])
-            else:
-                self.error('Aborted by user')
-
-        # Set default project name
-        if self.config['project'] is None:
-            url = self.repo.remotes.origin.url
-            self.config['project'] = os.path.basename(url).replace('.git', '')
-
-        # Default config level (repository == local)
-        self.config['config_level'] = 'repository'
-
-    def set_substep_status(self, number, status, msg, infos=[]):
-        # Flag execution of minimum one step
-        if status == 'TODO':
-            self.todo = True
-
-        # Search for substep by number and add new data
-        for step in self.Steps:
-            for substep in step.substeps:
-                if substep.number == number:
-                    # Only overwrite if entry is relevant
-                    if substep.status != 'TODO' or status == 'FAIL':
-                        substep.setstatus(status, msg, infos)
-                    return
-        raise SystemError('Internal error. Please report this issue.')
+        # Initialize parent
+        Step.__init__(self, 'Generate a new GPG key',
+            Substep('Strong, unique, secret passphrase', self.substep1),
+            Substep('Key generation', self.substep2),
+            )
 
     def analyze(self):
-        # Checks to execute
-        checks = [
-            ['Analyzing gpg key', self.analyze_step_1],
-            ['Receiving key from keyserver', self.analyze_step_2],
-            ['Analyzing git settings', self.analyze_step_3],
-            ['Analyzing existing archives/signatures/message digests', self.analyze_step_4],
-            ['Analyzing server settings', self.analyze_step_5],
-            ]
-
-        # Execute checks and print status
-        for check in checks:
-            print(check[0], end='...', flush=True)
-            err = check[1]()
-            print('\r\033[K', end='')
-            if err:
-                return True
-
-    def analyze_step_1(self):
         # Get private keys
         private_keys = self.gpg.list_keys(True)
         for key in private_keys:
             # Check key algorithm gpgit support
             if key['algo'] not in self.gpgAlgorithmIDs:
-                raise SystemError('Unknown key algorithm ID: ' + key['algo'])
-            else:
-                key['algoname'] = self.gpgAlgorithmIDs[key['algo']]
+                return 'Unknown key algorithm ID: ' + key['algo'] + ' Please report this error.'
+            key['algoname'] = self.gpgAlgorithmIDs[key['algo']]
 
         # Check if a fingerprint was selected/found
         if self.config['fingerprint'] is None:
@@ -343,7 +133,7 @@ def analyze_step_1(self):
                             userinput = -1
                 except KeyboardInterrupt:
                     print()
-                    self.error('Aborted by user')
+                    return 'Aborted by user'
                 print()
 
                 # Safe new fingerprint
@@ -354,75 +144,113 @@ def analyze_step_1(self):
         if self.config['fingerprint'] is not None:
             # Check if the full fingerprint is used
             if len(self.config['fingerprint']) != 40:
-                self.set_substep_status('1.2', 'FAIL', 'Please specify the full fingerprint',
-                                        ['GPG ID: ' + self.config['fingerprint']])
+                self.setstatus(2, 'FAIL', 'Please specify the full fingerprint',
+                                        'GPG ID: ' + self.config['fingerprint'])
                 return True
 
             # Find selected key
             for key in private_keys:
                 if key['fingerprint'] == self.config['fingerprint']:
-                    self.gpgkey = key
+                    gpgkey = key
                     break;
 
             # Check if key is available in keyring
-            if self.gpgkey is None:
-                self.set_substep_status('1.2', 'FAIL', 'Selected key is not available in keyring',
-                                        ['GPG ID: ' + self.config['fingerprint']])
+            if gpgkey is None:
+                self.setstatus(2, 'FAIL', 'Selected key is not available in keyring',
+                                        'GPG ID: ' + self.config['fingerprint'])
                 return True
 
             # Check key algorithm security
-            if self.gpgkey['algo'] not in self.gpgSecureAlgorithmIDs \
-                    or self.gpgkey['length'] not in self.gpgSecureKeyLength:
-                self.set_substep_status('1.2', 'FAIL', 'Insecure key algorithm used: '
-                                        + self.gpgkey['algoname'] + ' ' + self.gpgkey['length'],
-                                        ['GPG ID: ' + self.config['fingerprint']])
+            if gpgkey['algo'] not in self.gpgSecureAlgorithmIDs \
+                    or gpgkey['length'] not in self.gpgSecureKeyLength:
+                self.setstatus(2, 'FAIL', 'Insecure key algorithm used: '
+                                        + gpgkey['algoname'] + ' ' + gpgkey['length'],
+                                        'GPG ID: ' + self.config['fingerprint'])
                 return True
 
             # Check key algorithm security
-            if self.gpgkey['trust'] == 'r':
-                self.set_substep_status('1.2', 'FAIL', 'Selected key is revoked',
-                                        ['GPG ID: ' + self.config['fingerprint']])
+            if gpgkey['trust'] == 'r':
+                self.setstatus(2, 'FAIL', 'Selected key is revoked',
+                               'GPG ID: ' + self.config['fingerprint'])
                 return True
 
             # Use selected key
-            self.set_substep_status('1.2', 'OK', 'Key already generated',
-                                    [
-                                    'GPG key: ' + self.gpgkey['uids'][0],
-                                    'GPG ID: [' + self.gpgkey['algoname'] + ' '
-                                    + self.gpgkey['length'] + '] ' + self.gpgkey['fingerprint']
-                                    + ' ' ])
+            self.setstatus(2, 'OK', 'Key already generated',
+                                    'GPG key: ' + gpgkey['uids'][0],
+                                    'GPG ID: [' + gpgkey['algoname'] + ' '
+                                    + gpgkey['length'] + '] ' + gpgkey['fingerprint']
+                                    + ' ' )
 
             # Warn about strong passphrase
-            self.set_substep_status('1.1', 'NOTE', 'Please use a strong, unique, secret passphrase')
+            self.setstatus(1, 'NOTE', 'Please use a strong, unique, secret passphrase')
 
         else:
             # Generate a new key
-            self.set_substep_status('1.2', 'TODO', 'Generating an RSA 4096 GPG key for '
+            self.setstatus(2, 'TODO', 'Generating an RSA 4096 GPG key for '
                                     + self.config['username']
                                     + ' ' + self.config['email']
                                     + ' valid for 1 year.')
 
             # Warn about strong passphrase
-            self.set_substep_status('1.1', 'TODO', 'Please use a strong, unique, secret passphrase')
+            self.setstatus(1, 'TODO', 'Please use a strong, unique, secret passphrase')
+
+    # Strong, unique, secret passphrase
+    def substep1(self):
+        self.print_exec('More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
+
+    # Key generation
+    def substep2(self):
+        return
+        # Generate RSA key command
+        # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
+        input_data = """
+        Key-Type: RSA
+        Key-Length: 4096
+        Key-Usage: cert sign auth
+        Subkey-Type: RSA
+        Subkey-Length: 4096
+        Subkey-Usage: encrypt
+        Name-Real: {0}
+        Name-Email: {1}
+        Expire-Date: 1y
+        Preferences: SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
+        %ask-passphrase
+        %commit
+        """.format(self.config['username'], self.config['email'])
+
+        # Execute gpg key generation command
+        self.print_exec('We need to generate a lot of random bytes. It is a good idea to perform')
+        self.print_exec('some other action (type on the keyboard, move the mouse, utilize the')
+        self.print_exec('disks) during the prime generation; this gives the random number')
+        self.print_exec('generator a better chance to gain enough entropy.')
+        self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
+        self.print_exec('Key generation finished. You new fingerprint is: ' + self.config['fingerprint'])
+
+class Step2(Step):
+    def __init__(self, config, gpg):
+        # Params
+        self.config = config
+        self.gpg = gpg
+
+        # Initialize parent
+        Step.__init__(self, 'Publish your GPG key',
+                      Substep('Send GPG key to a key server', self.substep1),
+                      Substep('Publish full fingerprint', self.substep2),
+                      Substep('Associate GPG key with Github', self.substep3))
 
-    def analyze_step_2(self):
+    def analyze(self):
         # Add publish note
-        self.set_substep_status('2.3', 'NOTE',
-                                'Please publish the full GPG fingerprint on your project page')
+        if self.config['fingerprint'] is None:
+            self.setstatus(2, 'TODO', 'Please publish the full GPG fingerprint on the project page')
+        else:
+            self.setstatus(2, 'NOTE', 'Please publish the full GPG fingerprint on the project page')
 
         # Check Github GPG key
         if self.config['github'] is True:
             # TODO Will associate your GPG key with Github
-            self.set_substep_status('2.2', 'NOTE', 'Please associate your GPG key with Github')
-        else:
-            self.set_substep_status('2.2', 'OK', 'No Github repository used')
-
-        if self.config['fingerprint'] is None:
-            self.set_substep_status('2.3', 'TODO',
-                                    'Please publish the full GPG fingerprint on your project page')
+            self.setstatus(3, 'NOTE', 'Please associate your GPG key with Github')
         else:
-            self.set_substep_status('2.3', 'NOTE',
-                                    'Please publish the full GPG fingerprint on your project page')
+            self.setstatus(3, 'OK', 'No Github repository used')
 
         # Only check if a fingerprint was specified
         if self.config['fingerprint'] is not None:
@@ -431,18 +259,43 @@ def analyze_step_2(self):
                 with time_limit(10):
                     key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
             except TimeoutException:
-                self.error('Keyserver timed out. Please try again alter.')
+                return 'Keyserver timed out. Please try again alter.'
 
             # Found key on keyserver
             if self.config['fingerprint'] in key.fingerprints:
-                self.set_substep_status('2.1', 'OK',
-                                        'Key already published on ' + self.config['keyserver'])
+                self.setstatus(1, 'OK', 'Key already published on ' + self.config['keyserver'])
                 return
 
         # Upload key to keyserver
-        self.set_substep_status('2.1', 'TODO', 'Publishing key on ' + self.config['keyserver'])
+        self.setstatus(1, 'TODO', 'Publishing key on ' + self.config['keyserver'])
 
-    def analyze_step_3(self):
+    # Send GPG key to a key server
+    def substep1(self):
+        self.print_exec('Publishing key ' + self.config['fingerprint'])
+        self.gpg.send_keys(self.config['keyserver'], self.config['fingerprint'])
+
+    # Publish your full fingerprint
+    def substep2(self):
+        print('Your fingerprint is:', self.config['fingerprint'])
+
+    # Associate GPG key with Github
+    def substep3(self):
+        #TODO
+        pass
+
+class Step3(Step):
+    def __init__(self, config, repo):
+        # Params
+        self.config = config
+        self.repo = repo
+
+        # Initialize parent
+        Step.__init__(self, 'Use Git with GPG',
+                      Substep('Configure Git GPG key', self.substep1),
+                      Substep('Enable commit signing', self.substep2),
+                      Substep('Create signed Git tag', self.substep3))
+
+    def analyze(self):
         # Check if git was already configured with the gpg key
         if self.config['signingkey'] != self.config['fingerprint'] \
                 or self.config['fingerprint'] is None:
@@ -450,23 +303,21 @@ def analyze_step_3(self):
             if self.config['signingkey'] is None:
                 self.config['config_level'] = 'global'
 
-            self.set_substep_status('3.1', 'TODO', 'Configuring ' + self.config['config_level']
-                                    + ' git settings with your GPG key')
+            self.setstatus(1, 'TODO', 'Configuring ' + self.config['config_level'] + 'Git GPG key')
         else:
-            self.set_substep_status('3.1', 'OK', 'Git already configured with your GPG key')
+            self.setstatus(1, 'OK', 'Git already configured with your GPG key')
 
         # Check commit signing
         if self.config['gpgsign'] is True:
-            self.set_substep_status('3.2', 'OK', 'Commit signing already enabled')
+            self.setstatus(2, 'OK', 'Commit signing already enabled')
         else:
-            self.set_substep_status('3.2', 'TODO', 'Enabling ' + self.config['config_level']
-                                    + ' git settings with commit signing')
+            self.setstatus(2, 'TODO', 'Enabling ' + self.config['config_level'] + ' commit signing')
 
         # Refresh tags
         try:
             self.repo.remotes.origin.fetch('--tags')
         except git.exc.GitCommandError:
-            self.error('Error fetching remote tags.')
+            return 'Error fetching remote tags.'
 
         # Check if tag was already created
         tag = self.repo.tag('refs/tags/' + self.config['tag'])
@@ -477,19 +328,90 @@ def analyze_step_3(self):
             except git.exc.GitCommandError:
                 if hasattr(tag.tag, 'message') \
                         and '-----BEGIN PGP SIGNATURE-----' in tag.tag.message:
-                    self.set_substep_status('3.3', 'FAIL',
-                                            'Invalid signature for tag ' + self.config['tag'])
+                    self.setstatus(3, 'FAIL', 'Invalid signature for tag ' + self.config['tag'])
                     return True
-                self.set_substep_status('3.3', 'TODO', 'Adding signature for unsigned tag: '
-                                        + self.config['tag'])
+                self.setstatus(3, 'TODO', 'Signing existing tag: ' + self.config['tag'])
             else:
-                self.set_substep_status('3.3', 'OK', 'Good signature for existing tag: '
-                                        + self.config['tag'])
+                self.setstatus(3, 'OK', 'Good signature for existing tag: ' + self.config['tag'])
         else:
-            self.set_substep_status('3.3', 'TODO', 'Creating signed tag ' + self.config['tag']
+            self.setstatus(3, 'TODO', 'Creating signed tag ' + self.config['tag']
                                     + ' and pushing it to the remote git')
 
-    def analyze_step_4(self):
+    # Configure git GPG key
+    def substep1(self):
+        # Configure git signingkey settings
+        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
+            cw.set("user", "signingkey", self.config['fingerprint'])
+
+    # Enable commit signing
+    def substep2(self):
+        # Configure git signingkey settings
+        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
+            cw.set("commit", "gpgsign", True)
+
+    # Create signed git tag
+    def substep3(self):
+        self.print_exec('Creating, signing and pushing tag ' + self.config['tag'])
+
+        # Check if tag needs to be recreated
+        force = False
+        ref = 'HEAD'
+        date = ''
+        tag = self.repo.tag('refs/tags/' + self.config['tag'])
+        if tag in self.repo.tags:
+            force = True
+            ref = self.config['tag']
+            if hasattr(tag.tag, 'message'):
+                self.config['message'] = tag.tag.message
+            if hasattr(tag.tag, 'tagged_date'):
+                date = str(tag.tag.tagged_date)
+
+        # Create a signed tag
+        newtag = None
+        with self.repo.git.custom_environment(GIT_COMMITTER_DATE=date):
+            try:
+                newtag = self.repo.create_tag(
+                    self.config['tag'],
+                    ref=ref,
+                    message=self.config['message'],
+                    sign=True,
+                    local_user=self.config['fingerprint'],
+                    force=force)
+            except git.exc.GitCommandError:
+                return "Signing tag failed."
+
+        # Push tag
+        # TODO catch missing exception https://github.com/gitpython-developers/GitPython/issues/621
+        self.repo.remotes.origin.push(newtag, force=force)
+
+class Step4(Step):
+    compressionAlgorithms = {
+        'gz': gzip,
+        'gzip': gzip,
+        'xz': lzma,
+        'bz2': bz2,
+        'bzip2': bz2,
+    }
+
+    def __init__(self, config, gpg, repo, assets):
+        # Params
+        self.config = config
+        self.gpg = gpg
+        self.repo = repo
+        self.assets = assets
+
+        # Expand hash info list
+        self.hash = {}
+        for sha in self.config['sha']:
+            self.hash[sha] = {}
+
+        # Initialize parent
+        Step.__init__(self, 'Create a signed release archive',
+                      Substep('Create compressed archive', self.substep1),
+                      Substep('Sign the archive', self.substep2),
+                      Substep('Create the message digest', self.substep3))
+
+    def analyze(self):
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -502,9 +424,8 @@ def analyze_step_4(self):
             if os.path.isfile(tarfilepath):
                 # Check if tag exists
                 if self.repo.tag('refs/tags/' + self.config['tag']) not in self.repo.tags:
-                    self.set_substep_status('4.1', 'FAIL',
-                                            'Archive exists but no corresponding tag!?',
-                                            [tarfilepath])
+                    self.setstatus(1, 'FAIL', 'Archive exists but no corresponding tag!?',
+                                   tarfilepath)
                     return True
 
                 # Verify existing archive
@@ -514,22 +435,21 @@ def analyze_step_4(self):
                         self.repo.archive(cmptar, treeish=self.config['tag'],
                                           prefix=filename + '/', format='tar')
                         if not cmptar.equal():
-                            self.set_substep_status('4.1', 'FAIL',
-                                                    'Existing archive differs from local source',
-                                                    [tarfilepath])
+                            self.setstatus(1, 'FAIL', 'Existing archive differs from local source',
+                                           tarfilepath)
                             return True
                 except lzma.LZMAError:
-                    self.set_substep_status('4.1', 'FAIL', 'Archive not in ' + tar + ' format',
-                                            [tarfilepath])
+                    self.setstatus(1, 'FAIL', 'Archive not in ' + tar + ' format',
+                                            tarfilepath)
                     return True
 
                 # Successfully verified
-                self.set_substep_status('4.1', 'OK', 'Existing archive(s) verified successfully',
-                                        ['Path: ' + self.config['output'], 'Basename: ' + filename])
+                self.setstatus(1, 'OK', 'Existing archive(s) verified successfully',
+                                        'Path: ' + self.config['output'], 'Basename: ' + filename)
             else:
-                self.set_substep_status('4.1', 'TODO', 'Creating new release archive(s): '
-                                        + ', '.join(str(x) for x in self.config['tar']), [
-                                        'Path: ' + self.config['output'], 'Basename: ' + filename])
+                self.setstatus(1, 'TODO', 'Creating new release archive(s): '
+                                        + ', '.join(str(x) for x in self.config['tar']),
+                                        'Path: ' + self.config['output'], 'Basename: ' + filename)
 
             # Get signature filename from setting
             if self.config['no_armor']:
@@ -543,9 +463,8 @@ def analyze_step_4(self):
             if os.path.isfile(sigfilepath):
                 # Check if signature for tar exists
                 if not os.path.isfile(tarfilepath):
-                    self.set_substep_status('4.2', 'FAIL',
-                                            'Signature found without corresponding archive',
-                                            [sigfilepath])
+                    self.setstatus(2, 'FAIL', 'Signature found without corresponding archive',
+                                   sigfilepath)
                     return True
 
                 # Verify signature
@@ -557,15 +476,14 @@ def analyze_step_4(self):
                             or verified.fingerprint != self.config['fingerprint']:
                         if verified.trust_text is None:
                             verified.trust_text = 'Invalid signature'
-                        self.set_substep_status('4.2', 'FAIL', 'Signature could not be verified ' \
-                                                + 'successfully with gpg', [
-                                                sigfilepath, 'Trust level: ' + verified.trust_text])
+                        self.setstatus(2, 'FAIL', 'Signature verification failed',
+                                       sigfilepath, 'Trust level: ' + verified.trust_text)
                         return True
 
                 # Successfully verified
-                self.set_substep_status('4.2', 'OK', 'Existing signature(s) verified successfully')
+                self.setstatus(2, 'OK', 'Existing signature(s) verified successfully')
             else:
-                self.set_substep_status('4.2', 'TODO', 'Creating GPG signature(s) for archive(s)')
+                self.setstatus(2, 'TODO', 'Creating GPG signature(s) for archive(s)')
 
             # Verify all selected shasums if existant
             for sha in self.config['sha']:
@@ -585,8 +503,8 @@ def analyze_step_4(self):
                 if os.path.isfile(shafilepath):
                     # Check if tar for hash exists
                     if not os.path.isfile(tarfilepath):
-                        self.set_substep_status('4.3', 'FAIL', 'Message digest found without ' \
-                                                + 'corresponding archive', [shafilepath])
+                        self.setstatus(3, 'FAIL', 'Message digest found without ' \
+                                       + 'corresponding archive', shafilepath)
                         return True
 
                     # Read hash and filename
@@ -597,178 +515,18 @@ def analyze_step_4(self):
                     if len(hashinfo) != 2 \
                             or self.hash[sha][tarfile] != hashinfo[0] \
                             or os.path.basename(hashinfo[1]) != tarfile:
-                        self.set_substep_status('4.3', 'FAIL',
-                                                'Message digest could not be successfully verified',
-                                                [shafilepath])
+                        self.setstatus(3, 'FAIL', 'Message digest verification failed', shafilepath)
                         return True
 
                     # Successfully verified
-                    self.set_substep_status('4.3', 'OK',
-                                            'Existing message digest(s) verified successfully')
+                    self.setstatus(3, 'OK', 'Existing message digest(s) verified successfully')
                 else:
-                    self.set_substep_status('4.3', 'TODO',
-                                            'Creating message digest(s) for archive(s): '
-                                            + ', '.join(str(x) for x in self.config['sha']))
+                    self.setstatus(3, 'TODO', 'Creating message digest(s) for archive(s): '
+                                   + ', '.join(str(x) for x in self.config['sha']))
 
-    def analyze_step_5(self):
-        # Check Github GPG key
-        if self.config['github'] is True:
-            self.set_substep_status('5.2', 'OK', 'Github uses well configured https')
-
-            # Ask for Github token
-            if self.config['token'] is None:
-                try:
-                    self.config['token'] = input('Enter Github token to access release API: ')
-                except KeyboardInterrupt:
-                    print()
-                    gpgit.error('Aborted by user')
-
-            # Create Github API instance
-            self.github = Github(self.config['token'])
-
-            # Acces Github API
-            try:
-                self.githubuser = self.github.get_user()
-                self.githubrepo = self.githubuser.get_repo(self.config['project'])
-            except GithubException:
-                # TODO improve:
-                #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
-                self.error('Error accessing Github API for project ' + self.config['project']
-                           + '. Wrong token?')
-
-            # Check Release and its assets
-            try:
-                self.release = self.githubrepo.get_release(self.config['tag'])
-            except GithubException:
-                # TODO improve:
-                #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
-                self.newassets = self.assets
-                self.set_substep_status('5.1', 'TODO',
-                                        'Creating release and uploading release files to Github')
-                return
-            else:
-                # Determine which assets need to be uploaded
-                asset_list = [x.name for x in self.release.get_assets()]
-                for asset in self.assets:
-                    if asset not in asset_list:
-                        self.newassets += [asset]
-
-            # Check if assets already uploaded
-            if len(self.newassets) == 0:
-                self.set_substep_status('5.1', 'OK', 'Release already published on Github')
-            else:
-                self.set_substep_status('5.1', 'TODO', 'Uploading release files to Github')
-
-        else:
-            self.set_substep_status('5.1', 'NOTE',
-                                    'Please upload the compressed archive, signature and message ' \
-                                    + 'digest manually')
-            self.set_substep_status('5.2', 'NOTE',
-                                    'Please configure HTTPS for your download server')
-
-    # Strong, unique, secret passphrase
-    def step_1_1(self):
-        print(colors.BLUE + ':: ' + colors.RESET
-              + 'More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
-
-    # Key generation
-    def step_1_2(self):
-        # Generate RSA key command
-        # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
-        input_data = """
-        Key-Type: RSA
-        Key-Length: 4096
-        Key-Usage: cert sign auth
-        Subkey-Type: RSA
-        Subkey-Length: 4096
-        Subkey-Usage: encrypt
-        Name-Real: {0}
-        Name-Email: {1}
-        Expire-Date: 1y
-        Preferences: SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
-        %ask-passphrase
-        %commit
-        """.format(self.config['username'], self.config['email'])
-
-        # Execute gpg key generation command
-        print(colors.BLUE + ':: ' + colors.RESET
-              + 'We need to generate a lot of random bytes. It is a good idea to perform')
-        print(colors.BLUE + ':: ' + colors.RESET
-              + 'some other action (type on the keyboard, move the mouse, utilize the')
-        print(colors.BLUE + ':: ' + colors.RESET
-              + 'disks) during the prime generation; this gives the random number')
-        print(colors.BLUE + ':: ' + colors.RESET
-              + 'generator a better chance to gain enough entropy.')
-        self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
-        print(colors.BLUE + ':: ' + colors.RESET
-              + 'Key generation finished. You new fingerprint is: ' + self.config['fingerprint'])
-
-    # Submit your key to a key server
-    def step_2_1(self):
-        print(colors.BLUE + ':: ' + colors.RESET + 'Publishing key ' + self.config['fingerprint'])
-        self.gpg.send_keys(self.config['keyserver'], self.config['fingerprint'])
-
-    # Associate GPG key with Github
-    def step_2_2(self):
-        pass
-
-    # Publish your full fingerprint
-    def step_2_3(self):
-        print('Your fingerprint is:', self.config['fingerprint'])
-
-    # Configure git GPG key
-    def step_3_1(self):
-        # Configure git signingkey settings
-        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
-            cw.set("user", "signingkey", self.config['fingerprint'])
-
-    # Commit signing
-    def step_3_2(self):
-        # Configure git signingkey settings
-        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
-            cw.set("commit", "gpgsign", True)
-
-    # Create signed git tag
-    def step_3_3(self):
-        print(colors.BLUE + ':: ' + colors.RESET + 'Creating, signing and pushing tag',
-              self.config['tag'])
-
-        # Check if tag needs to be recreated
-        force = False
-        ref = 'HEAD'
-        date = ''
-        tag = self.repo.tag('refs/tags/' + self.config['tag'])
-        if tag in self.repo.tags:
-            force = True
-            ref = self.config['tag']
-            if hasattr(tag.tag, 'message'):
-                self.config['message'] = tag.tag.message
-            if hasattr(tag.tag, 'tagged_date'):
-                date = str(tag.tag.tagged_date)
-
-        # Create a signed tag
-        newtag = None
-        with self.repo.git.custom_environment(GIT_COMMITTER_DATE=date):
-            try:
-                newtag = self.repo.create_tag(
-                    self.config['tag'],
-                    ref=ref,
-                    message=self.config['message'],
-                    sign=True,
-                    local_user=self.config['fingerprint'],
-                    force=force)
-            except git.exc.GitCommandError:
-                self.error("Signing tag failed.")
-
-        # Push tag
-        #try:
-        self.repo.remotes.origin.push(newtag, force=force)
-        # TODO check exception https://github.com/gitpython-developers/GitPython/issues/621
-        # except ???:
-        #    self.error("Pushing tag failed")
 
     # Create compressed archive
-    def step_4_1(self):
+    def substep1(self):
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -778,13 +536,13 @@ def step_4_1(self):
 
             # Create compressed tar files if it does not exist
             if not os.path.isfile(tarfilepath):
-                print(colors.BLUE + ':: ' + colors.RESET + 'Creating', tarfilepath)
+                self.print_exec('Creating ' + tarfilepath)
                 with self.compressionAlgorithms[tar].open(tarfilepath, 'wb') as tarstream:
                     self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/',
                                       format='tar')
 
     # Sign the sources
-    def step_4_2(self):
+    def substep2(self):
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -802,7 +560,7 @@ def step_4_2(self):
             if not os.path.isfile(sigfilepath):
                 # Sign tar file
                 with open(tarfilepath, 'rb') as tarstream:
-                    print(colors.BLUE + ':: ' + colors.RESET + 'Creating', sigfilepath)
+                    self.print_exec('Creating ' + sigfilepath)
                     signed_data = self.gpg.sign_file(
                         tarstream,
                         keyid=self.config['fingerprint'],
@@ -812,12 +570,12 @@ def step_4_2(self):
                         #digest_algo='SHA512' #TODO v 2.x gpg module
                         )
                     if signed_data.fingerprint != self.config['fingerprint']:
-                        self.error('Signing data failed')
+                        return 'Signing data failed'
                     # TODO https://tools.ietf.org/html/rfc4880#section-9.4
                     #print(signed_data.hash_algo) -> 8 -> SHA256
 
     # Create the message digest
-    def step_4_3(self):
+    def substep3(self):
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -840,12 +598,85 @@ def step_4_3(self):
                         self.hash[sha][tarfile] = hash_sha.hexdigest()
 
                     # Write cached hash and filename
-                    print(colors.BLUE + ':: ' + colors.RESET + 'Creating', shafilepath)
+                    self.print_exec('Creating ' + shafilepath)
                     with open(shafilepath, "w") as filestream:
                         filestream.write(self.hash[sha][tarfile] + '  ' + tarfile)
 
+class Step5(Step):
+    def __init__(self, config, assets):
+        # Params
+        self.config = config
+        self.assets = assets
+        self.newassets = []
+
+        # Github API
+        self.github = None
+        self.githubuser = None
+        self.githubrepo = None
+        self.release = None
+
+        # Initialize parent
+        Step.__init__(self, 'Upload the release',
+                      Substep('Configure HTTPS download server', self.substep1),
+                      Substep('Github', self.substep2))
+
+    def analyze(self):
+        # Check Github GPG key
+        if self.config['github'] is True:
+            self.setstatus(1, 'OK', 'Github uses well configured https')
+
+            # Ask for Github token
+            if self.config['token'] is None:
+                try:
+                    self.config['token'] = input('Enter Github token to access release API: ')
+                except KeyboardInterrupt:
+                    print()
+                    gpgit.error('Aborted by user')
+
+            # Create Github API instance
+            self.github = Github(self.config['token'])
+
+            # Acces Github API
+            try:
+                self.githubuser = self.github.get_user()
+                self.githubrepo = self.githubuser.get_repo(self.config['project'])
+            except GithubException:
+                # TODO improve exception:
+                #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
+                return 'Error accessing Github API for project ' + self.config['project']
+
+            # Check Release and its assets
+            try:
+                self.release = self.githubrepo.get_release(self.config['tag'])
+            except GithubException:
+                # TODO improve:
+                #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
+                self.newassets = self.assets
+                self.setstatus(2, 'TODO', 'Creating release and uploading release files to Github')
+                return
+            else:
+                # Determine which assets need to be uploaded
+                asset_list = [x.name for x in self.release.get_assets()]
+                for asset in self.assets:
+                    if asset not in asset_list:
+                        self.newassets += [asset]
+
+            # Check if assets already uploaded
+            if len(self.newassets) == 0:
+                self.setstatus(2, 'OK', 'Release already published on Github')
+            else:
+                self.setstatus(2, 'TODO', 'Uploading the release files to Github')
+
+        else:
+            self.setstatus(2, 'NOTE', 'Please upload the release files manually')
+            self.setstatus(1, 'NOTE', 'Please configure HTTPS for your download server')
+
+    # Configure HTTPS for your download server
+    def substep1(self):
+        pass
+
     # Github
-    def step_5_1(self):
+    def substep2(self):
         # Create release if not existant
         if self.release is None:
             self.release = self.githubrepo.create_git_release(
@@ -857,45 +688,189 @@ def step_5_1(self):
         # Upload assets
         for asset in self.newassets:
             assetpath = os.path.join(self.config['output'], asset)
-            print(colors.BLUE + ':: ' + colors.RESET + 'Uploading', assetpath)
+            self.print_exec('Uploading ' + assetpath)
             # TODO not functional
             # see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
             # TODO change label and mime type
             self.release.upload_asset(assetpath, "Testlabel", "application/x-xz")
 
-    # Configure HTTPS for your download server
-    def step_5_2(self):
-        pass
+# Helper class to compare a stream without writing
+class strmcmp(object):
+    def __init__(self, strmcmp):
+        self.strmcmp = strmcmp
+        self.__equal = True
+    def write(self, data):
+        if data != self.strmcmp.read(len(data)):
+            self.__equal = False
+    def equal(self):
+        # Check end of file too
+        if self.strmcmp.read(1) == b'' and self.__equal:
+            return True
+
+class GPGit(object):
+    version = '2.0.0'
+
+    colormap = {
+        'OK': colors.GREEN,
+        'FAIL': colors.RED,
+        'INFO': colors.YELLOW,
+        'WARN': colors.YELLOW,
+        'TODO': colors.MAGENTA,
+        'NOTE': colors.BLUE,
+        }
+
+    def __init__(self, config):
+        # Config via parameters
+        self.config = config
+        self.assets = []
+
+        # GPG
+        self.gpg = gnupg.GPG()
+
+        # Git
+        self.repo = None
+
+        # Create git repository instance
+        try:
+            self.repo = Repo(self.config['git_dir'], search_parent_directories=True)
+        except git.exc.InvalidGitRepositoryError:
+            self.error('Not inside a git directory: ' + self.config['git_dir'])
+        reader = self.repo.config_reader()
+
+        gitconfig = [
+            ['username', 'user', 'name'],
+            ['email', 'user', 'email'],
+            ['signingkey', 'user', 'signingkey'],
+            ['gpgsign', 'commit', 'gpgsign'],
+            ['output', 'user', 'gpgitoutput'],
+            ['token', 'user', 'githubtoken']
+        ]
+
+        # Read in git config values
+        for config in gitconfig:
+            # Create not existing keys
+            if config[0] not in self.config:
+                self.config[config[0]] = None
+
+            # Check if gitconfig provides a setting
+            if self.config[config[0]] is None and reader.has_option(config[1], config[2]):
+                val = reader.get_value(config[1], config[2])
+                if type(val) == int:
+                    val = str(val)
+                self.config[config[0]] = val
+
+        # Get default git signing key
+        if self.config['fingerprint'] is None and self.config['signingkey']:
+            self.config['fingerprint'] = self.config['signingkey']
+
+        # Check if Github URL is used
+        if self.config['github'] is True:
+            if 'github' not in self.repo.remotes.origin.url.lower():
+                self.config['github'] = False
+
+        # Default message
+        if self.config['message'] is None:
+            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' \
+                                     + self.version + '\nhttps://github.com/NicoHood/gpgit'
+
+        # Default output path
+        if self.config['output'] is None:
+            self.config['output'] = os.path.join(self.repo.working_tree_dir, 'archive')
+
+        # Check if path exists
+        if not os.path.isdir(self.config['output']):
+            # Create not existing path
+            print('Not a valid path: ' + self.config['output'])
+            try:
+                ret = input('Create non-existing output path? [Y/n]')
+            except KeyboardInterrupt:
+                print()
+                self.error('Aborted by user')
+            if ret == 'y' or ret == '':
+                os.makedirs(self.config['output'])
+            else:
+                self.error('Aborted by user')
+
+        # Set default project name
+        if self.config['project'] is None:
+            url = self.repo.remotes.origin.url
+            self.config['project'] = os.path.basename(url).replace('.git', '')
+
+        # Default config level (repository == local)
+        self.config['config_level'] = 'repository'
+
+        # Create array fo steps to analyse and run
+        self.step1 = Step1(self.config, self.gpg)
+        self.step2 = Step2(self.config, self.gpg)
+        self.step3 = Step3(self.config, self.repo)
+        self.step4 = Step4(self.config, self.gpg, self.repo, self.assets)
+        self.step5 = Step5(self.config, self.assets)
+        self.Steps = [ self.step1, self.step2, self.step3, self.step4, self.step5 ]
+
+    def analyze(self):
+        for i, step in enumerate(self.Steps, start=1):
+            # TODO remove return True in analyze functions to only abort on critical errors
+            print('Analyzing step', i, 'of', len(self.Steps), end='...', flush=True)
+            err_msg = step.analyze()
+            if err_msg:
+                return err_msg
+            print('\r\033[K', end='')
 
     def printstatus(self):
-        # Print the status tree
-        err = False
-        for step in self.Steps:
-            if step.printstatus():
-                err = True
-        if err:
-            self.error('Exiting due to previous errors')
-        return err
+        todo = False
+        error = False
+        for i, step in enumerate(self.Steps, start=1):
+            # Sample: "1. Generate a new GPG key"
+            print(colors.BOLD + str(i) + '.', step.name + colors.RESET)
+            for j, substep in enumerate(step.substeps, start=1):
+                # Sample: "1.2 [ OK ] Key already generated"
+                print(colors.BOLD + '  ' + str(i) + '.' + str(j), self.colormap[substep.status] + '['
+                      + substep.status.center(4) + ']' + colors.RESET, substep.msg)
+
+                # Sample: " -> [INFO] GPG key: [rsa4096] 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161"
+                for info in substep.infos:
+                    print(colors.BOLD + '   -> ' + self.colormap['INFO'] + '[INFO]' + colors.RESET, info)
+
+                # Check for error or todos
+                if substep.status == 'FAIL':
+                    error = True
+                elif substep.status == 'TODO':
+                    todo = True
+
+        # Return error or todo status
+        if error:
+            return -1
+        if todo:
+            return 1
 
     def run(self):
         # Execute all steps
-        for step in self.Steps:
-            if step.run():
-                self.error('Executing step failed')
+        for i, step in enumerate(self.Steps, start=1):
+            # Run all substeps if enabled
+            # Sample: "==> 2. Publish your key"
+            print(colors.GREEN + "==>", colors.BOLD + str(i) + '.', step.name + colors.RESET)
+            for j, substep in enumerate(step.substeps, start=1):
+                # Run selected step function if activated
+                if substep.status == 'TODO':
+                    # Sample: "  -> Will associate your GPG key with Github"
+                    print(colors.BLUE + "  ->", colors.BOLD + str(i) +'.' + str(j), substep.name + colors.RESET)
+                    err_msg = substep.funct()
+                    if err_msg:
+                        return err_msg
 
     def error(self, msg):
         print(colors.RED + '==> Error:' + colors.RESET, msg)
         sys.exit(1)
 
 
-def main(arguments):
+def main():
     parser = argparse.ArgumentParser(description='A python script that automates the process of ' \
                                      + 'signing git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')
     parser.add_argument('-o', '--output', action='store',
-                        help='output path of the compressed archive, signature and message digest')
+                        help='output path of the archive, signature and message digest')
     parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(),
                         help='path of the git project')
     parser.add_argument('-f', '--fingerprint', action='store',
@@ -920,13 +895,16 @@ def main(arguments):
     args = parser.parse_args()
 
     gpgit = GPGit(vars(args))
-    gpgit.load_defaults()
-    gpgit.analyze()
-    gpgit.printstatus()
+    err_msg = gpgit.analyze()
+    if err_msg:
+        print()
+        gpgit.error(err_msg)
+
+    ret = gpgit.printstatus()
     print()
 
     # Check if even something needs to be done
-    if gpgit.todo:
+    if ret > 0:
         # User selection
         try:
             ret = input('Continue with the selected operations? [Y/n]')
@@ -935,12 +913,17 @@ def main(arguments):
             gpgit.error('Aborted by user')
         if ret == 'y' or ret == '':
             print()
-            if not gpgit.run():
+            err_msg = gpgit.run()
+            if err_msg:
+                gpgit.error(err_msg)
+            else:
                 print('Finished without errors')
         else:
             gpgit.error('Aborted by user')
+    elif ret < 0:
+        gpgit.error('Exiting due to previous errors')
     else:
         print(colors.GREEN + "==>", colors.RESET, 'Everything looks okay. Nothing to do.')
 
 if __name__ == '__main__':
-    sys.exit(main(sys.argv[1:]))
+    sys.exit(main())

From 561f17e3f1c256f8f42f92ab7aa529c56d110adf Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Wed, 17 May 2017 21:25:16 +0200
Subject: [PATCH 32/46] Format fixes

---
 gpgit.py | 58 +++++++++++++++++---------------------------------------
 1 file changed, 17 insertions(+), 41 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index a724bcd..0b67102 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -95,9 +95,8 @@ def __init__(self, config, gpg):
 
         # Initialize parent
         Step.__init__(self, 'Generate a new GPG key',
-            Substep('Strong, unique, secret passphrase', self.substep1),
-            Substep('Key generation', self.substep2),
-            )
+                      Substep('Strong, unique, secret passphrase', self.substep1),
+                      Substep('Key generation', self.substep2))
 
     def analyze(self):
         # Get private keys
@@ -144,9 +143,7 @@ def analyze(self):
         if self.config['fingerprint'] is not None:
             # Check if the full fingerprint is used
             if len(self.config['fingerprint']) != 40:
-                self.setstatus(2, 'FAIL', 'Please specify the full fingerprint',
-                                        'GPG ID: ' + self.config['fingerprint'])
-                return True
+                return 'Please specify the full fingerprint. GPG ID: ' + self.config['fingerprint']
 
             # Find selected key
             for key in private_keys:
@@ -156,23 +153,17 @@ def analyze(self):
 
             # Check if key is available in keyring
             if gpgkey is None:
-                self.setstatus(2, 'FAIL', 'Selected key is not available in keyring',
-                                        'GPG ID: ' + self.config['fingerprint'])
-                return True
+                return 'Selected key not found in keyring. GPG ID: ' + self.config['fingerprint']
 
             # Check key algorithm security
             if gpgkey['algo'] not in self.gpgSecureAlgorithmIDs \
                     or gpgkey['length'] not in self.gpgSecureKeyLength:
-                self.setstatus(2, 'FAIL', 'Insecure key algorithm used: '
-                                        + gpgkey['algoname'] + ' ' + gpgkey['length'],
-                                        'GPG ID: ' + self.config['fingerprint'])
-                return True
+                return 'Insecure key algorithm used: ' + gpgkey['algoname'] + ' ' \
+                       + gpgkey['length'] + ' GPG ID: ' + self.config['fingerprint']
 
             # Check key algorithm security
             if gpgkey['trust'] == 'r':
-                self.setstatus(2, 'FAIL', 'Selected key is revoked',
-                               'GPG ID: ' + self.config['fingerprint'])
-                return True
+                return 'Selected key is revoked. GPG ID: ' + self.config['fingerprint']
 
             # Use selected key
             self.setstatus(2, 'OK', 'Key already generated',
@@ -328,8 +319,7 @@ def analyze(self):
             except git.exc.GitCommandError:
                 if hasattr(tag.tag, 'message') \
                         and '-----BEGIN PGP SIGNATURE-----' in tag.tag.message:
-                    self.setstatus(3, 'FAIL', 'Invalid signature for tag ' + self.config['tag'])
-                    return True
+                    return 'Invalid signature for tag ' + self.config['tag']
                 self.setstatus(3, 'TODO', 'Signing existing tag: ' + self.config['tag'])
             else:
                 self.setstatus(3, 'OK', 'Good signature for existing tag: ' + self.config['tag'])
@@ -424,9 +414,7 @@ def analyze(self):
             if os.path.isfile(tarfilepath):
                 # Check if tag exists
                 if self.repo.tag('refs/tags/' + self.config['tag']) not in self.repo.tags:
-                    self.setstatus(1, 'FAIL', 'Archive exists but no corresponding tag!?',
-                                   tarfilepath)
-                    return True
+                    return 'Archive exists without corresponding tag: ' + tarfile
 
                 # Verify existing archive
                 try:
@@ -435,13 +423,9 @@ def analyze(self):
                         self.repo.archive(cmptar, treeish=self.config['tag'],
                                           prefix=filename + '/', format='tar')
                         if not cmptar.equal():
-                            self.setstatus(1, 'FAIL', 'Existing archive differs from local source',
-                                           tarfilepath)
-                            return True
+                            return 'Existing archive differs from local source:' + tarfilepath
                 except lzma.LZMAError:
-                    self.setstatus(1, 'FAIL', 'Archive not in ' + tar + ' format',
-                                            tarfilepath)
-                    return True
+                    return 'Archive not in ' + tar + ' format: ' + tarfilepath
 
                 # Successfully verified
                 self.setstatus(1, 'OK', 'Existing archive(s) verified successfully',
@@ -463,9 +447,7 @@ def analyze(self):
             if os.path.isfile(sigfilepath):
                 # Check if signature for tar exists
                 if not os.path.isfile(tarfilepath):
-                    self.setstatus(2, 'FAIL', 'Signature found without corresponding archive',
-                                   sigfilepath)
-                    return True
+                    return 'Signature found without corresponding archive: ' + sigfilepath
 
                 # Verify signature
                 with open(sigfilepath, "rb") as sig:
@@ -476,9 +458,8 @@ def analyze(self):
                             or verified.fingerprint != self.config['fingerprint']:
                         if verified.trust_text is None:
                             verified.trust_text = 'Invalid signature'
-                        self.setstatus(2, 'FAIL', 'Signature verification failed',
-                                       sigfilepath, 'Trust level: ' + verified.trust_text)
-                        return True
+                        return 'Signature verification failed: ' + sigfilepath \
+                               + ' Trust level: ' + verified.trust_text
 
                 # Successfully verified
                 self.setstatus(2, 'OK', 'Existing signature(s) verified successfully')
@@ -503,9 +484,7 @@ def analyze(self):
                 if os.path.isfile(shafilepath):
                     # Check if tar for hash exists
                     if not os.path.isfile(tarfilepath):
-                        self.setstatus(3, 'FAIL', 'Message digest found without ' \
-                                       + 'corresponding archive', shafilepath)
-                        return True
+                        return 'Message digest found without corresponding archive: ' + shafilepath
 
                     # Read hash and filename
                     with open(shafilepath, "r") as f:
@@ -515,8 +494,7 @@ def analyze(self):
                     if len(hashinfo) != 2 \
                             or self.hash[sha][tarfile] != hashinfo[0] \
                             or os.path.basename(hashinfo[1]) != tarfile:
-                        self.setstatus(3, 'FAIL', 'Message digest verification failed', shafilepath)
-                        return True
+                        return 'Message digest verification failed: ' + shafilepath
 
                     # Successfully verified
                     self.setstatus(3, 'OK', 'Existing message digest(s) verified successfully')
@@ -712,9 +690,8 @@ class GPGit(object):
 
     colormap = {
         'OK': colors.GREEN,
-        'FAIL': colors.RED,
         'INFO': colors.YELLOW,
-        'WARN': colors.YELLOW,
+        'WARN': colors.RED,
         'TODO': colors.MAGENTA,
         'NOTE': colors.BLUE,
         }
@@ -809,7 +786,6 @@ def __init__(self, config):
 
     def analyze(self):
         for i, step in enumerate(self.Steps, start=1):
-            # TODO remove return True in analyze functions to only abort on critical errors
             print('Analyzing step', i, 'of', len(self.Steps), end='...', flush=True)
             err_msg = step.analyze()
             if err_msg:

From 3177c6c36ae2a46b30c43118adc19e7e11a5b8a9 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Wed, 17 May 2017 22:20:44 +0200
Subject: [PATCH 33/46] Style improvements and small fixes

---
 gpgit.py | 110 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 62 insertions(+), 48 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 0b67102..3f826d7 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -16,7 +16,8 @@
 import gnupg
 
 
-class TimeoutException(Exception): pass
+class TimeoutException(Exception):
+    pass
 
 @contextmanager
 def time_limit(seconds):
@@ -110,7 +111,7 @@ def analyze(self):
         # Check if a fingerprint was selected/found
         if self.config['fingerprint'] is None:
             # Check if gpg keys are available, but not yet configured
-            if len(private_keys):
+            if private_keys:
                 print('\r\033[K', end='')
                 print("GPG seems to be already configured on your system but git is not.")
                 print('Please select one of the existing keys below or generate a new one:')
@@ -146,10 +147,11 @@ def analyze(self):
                 return 'Please specify the full fingerprint. GPG ID: ' + self.config['fingerprint']
 
             # Find selected key
+            gpgkey = None
             for key in private_keys:
                 if key['fingerprint'] == self.config['fingerprint']:
                     gpgkey = key
-                    break;
+                    break
 
             # Check if key is available in keyring
             if gpgkey is None:
@@ -167,10 +169,8 @@ def analyze(self):
 
             # Use selected key
             self.setstatus(2, 'OK', 'Key already generated',
-                                    'GPG key: ' + gpgkey['uids'][0],
-                                    'GPG ID: [' + gpgkey['algoname'] + ' '
-                                    + gpgkey['length'] + '] ' + gpgkey['fingerprint']
-                                    + ' ' )
+                           'GPG key: ' + gpgkey['uids'][0], 'GPG ID: [' + gpgkey['algoname'] + ' '
+                           + gpgkey['length'] + '] ' + gpgkey['fingerprint'] + ' ')
 
             # Warn about strong passphrase
             self.setstatus(1, 'NOTE', 'Please use a strong, unique, secret passphrase')
@@ -178,16 +178,16 @@ def analyze(self):
         else:
             # Generate a new key
             self.setstatus(2, 'TODO', 'Generating an RSA 4096 GPG key for '
-                                    + self.config['username']
-                                    + ' ' + self.config['email']
-                                    + ' valid for 1 year.')
+                           + self.config['username'] + ' ' + self.config['email']
+                           + ' valid for 1 year.')
 
             # Warn about strong passphrase
             self.setstatus(1, 'TODO', 'Please use a strong, unique, secret passphrase')
 
     # Strong, unique, secret passphrase
     def substep1(self):
-        self.print_exec('More infos: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
+        self.print_exec('More infos:',
+                        'https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
 
     # Key generation
     def substep2(self):
@@ -215,7 +215,8 @@ def substep2(self):
         self.print_exec('disks) during the prime generation; this gives the random number')
         self.print_exec('generator a better chance to gain enough entropy.')
         self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
-        self.print_exec('Key generation finished. You new fingerprint is: ' + self.config['fingerprint'])
+        self.print_exec('Key generation finished. You new fingerprint is: '
+                        + self.config['fingerprint'])
 
 class Step2(Step):
     def __init__(self, config, gpg):
@@ -325,7 +326,7 @@ def analyze(self):
                 self.setstatus(3, 'OK', 'Good signature for existing tag: ' + self.config['tag'])
         else:
             self.setstatus(3, 'TODO', 'Creating signed tag ' + self.config['tag']
-                                    + ' and pushing it to the remote git')
+                           + ' and pushing it to the remote git')
 
     # Configure git GPG key
     def substep1(self):
@@ -429,11 +430,11 @@ def analyze(self):
 
                 # Successfully verified
                 self.setstatus(1, 'OK', 'Existing archive(s) verified successfully',
-                                        'Path: ' + self.config['output'], 'Basename: ' + filename)
+                               'Path: ' + self.config['output'], 'Basename: ' + filename)
             else:
                 self.setstatus(1, 'TODO', 'Creating new release archive(s): '
-                                        + ', '.join(str(x) for x in self.config['tar']),
-                                        'Path: ' + self.config['output'], 'Basename: ' + filename)
+                               + ', '.join(str(x) for x in self.config['tar']),
+                               'Path: ' + self.config['output'], 'Basename: ' + filename)
 
             # Get signature filename from setting
             if self.config['no_armor']:
@@ -596,9 +597,10 @@ def __init__(self, config, assets):
         # Initialize parent
         Step.__init__(self, 'Upload the release',
                       Substep('Configure HTTPS download server', self.substep1),
-                      Substep('Github', self.substep2))
+                      Substep('Upload to Github', self.substep2))
 
     def analyze(self):
+        """Analyze: Upload the release"""
         # Check Github GPG key
         if self.config['github'] is True:
             self.setstatus(1, 'OK', 'Github uses well configured https')
@@ -640,21 +642,21 @@ def analyze(self):
                         self.newassets += [asset]
 
             # Check if assets already uploaded
-            if len(self.newassets) == 0:
-                self.setstatus(2, 'OK', 'Release already published on Github')
-            else:
+            if self.newassets:
                 self.setstatus(2, 'TODO', 'Uploading the release files to Github')
+            else:
+                self.setstatus(2, 'OK', 'Release already published on Github')
 
         else:
             self.setstatus(2, 'NOTE', 'Please upload the release files manually')
             self.setstatus(1, 'NOTE', 'Please configure HTTPS for your download server')
 
-    # Configure HTTPS for your download server
     def substep1(self):
+        """Configure HTTPS download server"""
         pass
 
-    # Github
     def substep2(self):
+        """Upload to Github"""
         # Create release if not existant
         if self.release is None:
             self.release = self.githubrepo.create_git_release(
@@ -672,8 +674,8 @@ def substep2(self):
             # TODO change label and mime type
             self.release.upload_asset(assetpath, "Testlabel", "application/x-xz")
 
-# Helper class to compare a stream without writing
 class strmcmp(object):
+    """Helper class to compare a stream without writing"""
     def __init__(self, strmcmp):
         self.strmcmp = strmcmp
         self.__equal = True
@@ -686,6 +688,7 @@ def equal(self):
             return True
 
 class GPGit(object):
+    """Class that manages GPGit steps and substeps analysis, print and execution."""
     version = '2.0.0'
 
     colormap = {
@@ -724,17 +727,18 @@ def __init__(self, config):
         ]
 
         # Read in git config values
-        for config in gitconfig:
+        for cfg in gitconfig:
             # Create not existing keys
-            if config[0] not in self.config:
-                self.config[config[0]] = None
+            if cfg[0] not in self.config:
+                self.config[cfg[0]] = None
 
             # Check if gitconfig provides a setting
-            if self.config[config[0]] is None and reader.has_option(config[1], config[2]):
-                val = reader.get_value(config[1], config[2])
-                if type(val) == int:
+            if self.config[cfg[0]] is None and reader.has_option(cfg[1], cfg[2]):
+                val = reader.get_value(cfg[1], cfg[2])
+                # TODO reading wrong values for commit.gpgsign, type() was working
+                if isinstance(val, int):
                     val = str(val)
-                self.config[config[0]] = val
+                self.config[cfg[0]] = val
 
         # Get default git signing key
         if self.config['fingerprint'] is None and self.config['signingkey']:
@@ -777,35 +781,37 @@ def __init__(self, config):
         self.config['config_level'] = 'repository'
 
         # Create array fo steps to analyse and run
-        self.step1 = Step1(self.config, self.gpg)
-        self.step2 = Step2(self.config, self.gpg)
-        self.step3 = Step3(self.config, self.repo)
-        self.step4 = Step4(self.config, self.gpg, self.repo, self.assets)
-        self.step5 = Step5(self.config, self.assets)
-        self.Steps = [ self.step1, self.step2, self.step3, self.step4, self.step5 ]
+        step1 = Step1(self.config, self.gpg)
+        step2 = Step2(self.config, self.gpg)
+        step3 = Step3(self.config, self.repo)
+        step4 = Step4(self.config, self.gpg, self.repo, self.assets)
+        step5 = Step5(self.config, self.assets)
+        self.steps = [step1, step2, step3, step4, step5]
 
     def analyze(self):
-        for i, step in enumerate(self.Steps, start=1):
-            print('Analyzing step', i, 'of', len(self.Steps), end='...', flush=True)
+        """Analze all steps and substeps for later preview printing"""
+        for i, step in enumerate(self.steps, start=1):
+            print('Analyzing step', i, 'of', len(self.steps), end='...', flush=True)
             err_msg = step.analyze()
             if err_msg:
                 return err_msg
             print('\r\033[K', end='')
 
     def printstatus(self):
+        """Print preview list with step and substeps."""
         todo = False
         error = False
-        for i, step in enumerate(self.Steps, start=1):
+        for i, step in enumerate(self.steps, start=1):
             # Sample: "1. Generate a new GPG key"
             print(colors.BOLD + str(i) + '.', step.name + colors.RESET)
             for j, substep in enumerate(step.substeps, start=1):
                 # Sample: "1.2 [ OK ] Key already generated"
-                print(colors.BOLD + '  ' + str(i) + '.' + str(j), self.colormap[substep.status] + '['
-                      + substep.status.center(4) + ']' + colors.RESET, substep.msg)
+                print(colors.BOLD + '  ' + str(i) + '.' + str(j), self.colormap[substep.status]
+                      + '[' + substep.status.center(4) + ']' + colors.RESET, substep.msg)
 
                 # Sample: " -> [INFO] GPG key: [rsa4096] 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161"
                 for info in substep.infos:
-                    print(colors.BOLD + '   -> ' + self.colormap['INFO'] + '[INFO]' + colors.RESET, info)
+                    print(colors.BOLD + '   -> ' + colors.YELLOW + '[INFO]' + colors.RESET, info)
 
                 # Check for error or todos
                 if substep.status == 'FAIL':
@@ -820,8 +826,8 @@ def printstatus(self):
             return 1
 
     def run(self):
-        # Execute all steps
-        for i, step in enumerate(self.Steps, start=1):
+        """Execute all steps + substeps."""
+        for i, step in enumerate(self.steps, start=1):
             # Run all substeps if enabled
             # Sample: "==> 2. Publish your key"
             print(colors.GREEN + "==>", colors.BOLD + str(i) + '.', step.name + colors.RESET)
@@ -829,17 +835,25 @@ def run(self):
                 # Run selected step function if activated
                 if substep.status == 'TODO':
                     # Sample: "  -> Will associate your GPG key with Github"
-                    print(colors.BLUE + "  ->", colors.BOLD + str(i) +'.' + str(j), substep.name + colors.RESET)
+                    print(colors.BLUE + "  ->", colors.BOLD + str(i) +'.' + str(j),
+                          substep.name + colors.RESET)
                     err_msg = substep.funct()
                     if err_msg:
                         return err_msg
 
-    def error(self, msg):
-        print(colors.RED + '==> Error:' + colors.RESET, msg)
-        sys.exit(1)
+    def error(self, *args):
+        """Print error and exit program. An optional integer param specifies the exit code."""
+        status = 1
+        for msg in args:
+            if type(msg) == int:
+                status = msg
+            else:
+                print(colors.RED + '==> Error:' + colors.RESET, msg)
+        sys.exit(status)
 
 
 def main():
+    """Main entry point that parses configs and creates GPGit instance."""
     parser = argparse.ArgumentParser(description='A python script that automates the process of ' \
                                      + 'signing git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')

From 3390798f894293aad3f26cd8e1b5e017714037b3 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Thu, 18 May 2017 19:09:57 +0200
Subject: [PATCH 34/46] Fix more pylint warnings and add docstrings

---
 gpgit.py | 175 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 94 insertions(+), 81 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 3f826d7..ea24c95 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+"""A python script that automates the process of signing Git sources via GPG."""
 from __future__ import print_function
 import os
 import sys
@@ -17,11 +18,16 @@
 
 
 class TimeoutException(Exception):
+    """Timeout exception for time_limit function"""
     pass
 
 @contextmanager
 def time_limit(seconds):
+    """Timeout helper function. Can be used as follows: with time_limit(seconds).
+    Nested calls with multiple time_limits will not work!
+    """
     def signal_handler(signum, frame):
+        #pylint: disable=unused-argument
         raise TimeoutException
     signal.signal(signal.SIGALRM, signal_handler)
     signal.alarm(seconds)
@@ -30,7 +36,7 @@ def signal_handler(signum, frame):
     finally:
         signal.alarm(0)
 
-class colors(object):
+class Colors(object):
     RED = "\033[1;31m"
     BLUE = "\033[1;34m"
     CYAN = "\033[1;36m"
@@ -42,7 +48,22 @@ class colors(object):
     REVERSE = "\033[;7m"
     RESET = "\033[0;0m"
 
+class Streamcmp(object):
+    """Helper class to compare a stream without writing"""
+    def __init__(self, strm):
+        self.__strm = strm
+        self.__equal = True
+    def write(self, data):
+        """Compare written data with input stream reading"""
+        if data != self.__strm.read(len(data)):
+            self.__equal = False
+    def equal(self):
+        """Check if both streams match completely."""
+        if self.__strm.read(1) == b'' and self.__equal:
+            return True
+
 class Substep(object):
+    """Contains name and execution functions of a Step"""
     def __init__(self, name, funct):
         # Params
         self.name = name
@@ -54,6 +75,7 @@ def __init__(self, name, funct):
         self.infos = []
 
 class Step(object):
+    """Holds variable number of substeps. Step1-5 inherit from this class."""
     def __init__(self, name, *args):
         # Params
         self.name = name
@@ -61,11 +83,13 @@ def __init__(self, name, *args):
         for substep in args:
             self.substeps += [substep]
 
-    def print_exec(self, msg):
-        # TODO only with verbose?
-        print(colors.BLUE + ':: ' + colors.RESET + msg)
+    @staticmethod
+    def verbose(*args):
+        """Verbose print used for substep execution"""
+        print(Colors.BLUE + '::' + Colors.RESET, *args)
 
     def setstatus(self, subnumber, status, msg, *args):
+        """Set variables of the substeps in a batch"""
         if subnumber > 0:
             self.substeps[subnumber - 1].status = status
             self.substeps[subnumber - 1].msg = msg
@@ -74,6 +98,7 @@ def setstatus(self, subnumber, status, msg, *args):
                 self.substeps[subnumber - 1].infos += [info]
 
 class Step1(Step):
+    """Generate a new GPG key"""
     # RFC4880 9.1. Public-Key Algorithms
     gpgAlgorithmIDs = {
         '1': 'RSA',
@@ -100,6 +125,7 @@ def __init__(self, config, gpg):
                       Substep('Key generation', self.substep2))
 
     def analyze(self):
+        """Analyze: Generate a new GPG key"""
         # Get private keys
         private_keys = self.gpg.list_keys(True)
         for key in private_keys:
@@ -184,14 +210,13 @@ def analyze(self):
             # Warn about strong passphrase
             self.setstatus(1, 'TODO', 'Please use a strong, unique, secret passphrase')
 
-    # Strong, unique, secret passphrase
     def substep1(self):
-        self.print_exec('More infos:',
-                        'https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
+        """Strong, unique, secret passphrase"""
+        self.verbose('More infos:',
+                     'https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase')
 
-    # Key generation
     def substep2(self):
-        return
+        """Key generation"""
         # Generate RSA key command
         # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
         input_data = """
@@ -210,15 +235,16 @@ def substep2(self):
         """.format(self.config['username'], self.config['email'])
 
         # Execute gpg key generation command
-        self.print_exec('We need to generate a lot of random bytes. It is a good idea to perform')
-        self.print_exec('some other action (type on the keyboard, move the mouse, utilize the')
-        self.print_exec('disks) during the prime generation; this gives the random number')
-        self.print_exec('generator a better chance to gain enough entropy.')
+        self.verbose('We need to generate a lot of random bytes. It is a good idea to perform')
+        self.verbose('some other action (type on the keyboard, move the mouse, utilize the')
+        self.verbose('disks) during the prime generation; this gives the random number')
+        self.verbose('generator a better chance to gain enough entropy.')
         self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
-        self.print_exec('Key generation finished. You new fingerprint is: '
-                        + self.config['fingerprint'])
+        self.verbose('Key generation finished. You new fingerprint is: '
+                     + self.config['fingerprint'])
 
 class Step2(Step):
+    """Publish your GPG key"""
     def __init__(self, config, gpg):
         # Params
         self.config = config
@@ -231,6 +257,7 @@ def __init__(self, config, gpg):
                       Substep('Associate GPG key with Github', self.substep3))
 
     def analyze(self):
+        """Analyze: Publish your GPG key"""
         # Add publish note
         if self.config['fingerprint'] is None:
             self.setstatus(2, 'TODO', 'Please publish the full GPG fingerprint on the project page')
@@ -261,21 +288,22 @@ def analyze(self):
         # Upload key to keyserver
         self.setstatus(1, 'TODO', 'Publishing key on ' + self.config['keyserver'])
 
-    # Send GPG key to a key server
     def substep1(self):
-        self.print_exec('Publishing key ' + self.config['fingerprint'])
+        """Send GPG key to a key server"""
+        self.verbose('Publishing key ' + self.config['fingerprint'])
         self.gpg.send_keys(self.config['keyserver'], self.config['fingerprint'])
 
-    # Publish your full fingerprint
     def substep2(self):
+        """Publish your full fingerprint"""
         print('Your fingerprint is:', self.config['fingerprint'])
 
-    # Associate GPG key with Github
     def substep3(self):
+        """Associate GPG key with Github"""
         #TODO
         pass
 
 class Step3(Step):
+    """Use Git with GPG"""
     def __init__(self, config, repo):
         # Params
         self.config = config
@@ -288,6 +316,7 @@ def __init__(self, config, repo):
                       Substep('Create signed Git tag', self.substep3))
 
     def analyze(self):
+        """Analyze: Use Git with GPG"""
         # Check if git was already configured with the gpg key
         if self.config['signingkey'] != self.config['fingerprint'] \
                 or self.config['fingerprint'] is None:
@@ -300,7 +329,7 @@ def analyze(self):
             self.setstatus(1, 'OK', 'Git already configured with your GPG key')
 
         # Check commit signing
-        if self.config['gpgsign'] is True:
+        if self.config['gpgsign'].lower() == 'true':
             self.setstatus(2, 'OK', 'Commit signing already enabled')
         else:
             self.setstatus(2, 'TODO', 'Enabling ' + self.config['config_level'] + ' commit signing')
@@ -328,21 +357,23 @@ def analyze(self):
             self.setstatus(3, 'TODO', 'Creating signed tag ' + self.config['tag']
                            + ' and pushing it to the remote git')
 
-    # Configure git GPG key
     def substep1(self):
+        """Configure git GPG key"""
         # Configure git signingkey settings
-        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
-            cw.set("user", "signingkey", self.config['fingerprint'])
+        with self.repo.config_writer(config_level=self.config['config_level']) as cfgwriter:
+            cfgwriter.set("user", "signingkey", self.config['fingerprint'])
 
-    # Enable commit signing
     def substep2(self):
+        """Enable commit signing"""
         # Configure git signingkey settings
-        with self.repo.config_writer(config_level=self.config['config_level']) as cw:
-            cw.set("commit", "gpgsign", True)
+        # TODO not working for repository (local) setting as config group does not yet exist
+        # TODO also fix above?
+        with self.repo.config_writer(config_level=self.config['config_level']) as cfgwriter:
+            cfgwriter.set("commit", "gpgsign", True)
 
-    # Create signed git tag
     def substep3(self):
-        self.print_exec('Creating, signing and pushing tag ' + self.config['tag'])
+        """Create signed Git tag"""
+        self.verbose('Creating, signing and pushing tag ' + self.config['tag'])
 
         # Check if tag needs to be recreated
         force = False
@@ -376,6 +407,7 @@ def substep3(self):
         self.repo.remotes.origin.push(newtag, force=force)
 
 class Step4(Step):
+    """Create a signed release archive"""
     compressionAlgorithms = {
         'gz': gzip,
         'gzip': gzip,
@@ -403,6 +435,7 @@ def __init__(self, config, gpg, repo, assets):
                       Substep('Create the message digest', self.substep3))
 
     def analyze(self):
+        """Analyze: Create a signed release archive"""
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -420,7 +453,7 @@ def analyze(self):
                 # Verify existing archive
                 try:
                     with self.compressionAlgorithms[tar].open(tarfilepath, "rb") as tarstream:
-                        cmptar = strmcmp(tarstream)
+                        cmptar = Streamcmp(tarstream)
                         self.repo.archive(cmptar, treeish=self.config['tag'],
                                           prefix=filename + '/', format='tar')
                         if not cmptar.equal():
@@ -476,8 +509,8 @@ def analyze(self):
                 # Calculate hash of tarfile
                 if os.path.isfile(tarfilepath):
                     hash_sha = hashlib.new(sha)
-                    with open(tarfilepath, "rb") as f:
-                        for chunk in iter(lambda: f.read(4096), b""):
+                    with open(tarfilepath, "rb") as filestream:
+                        for chunk in iter(lambda: filestream.read(4096), b""):
                             hash_sha.update(chunk)
                     self.hash[sha][tarfile] = hash_sha.hexdigest()
 
@@ -488,8 +521,8 @@ def analyze(self):
                         return 'Message digest found without corresponding archive: ' + shafilepath
 
                     # Read hash and filename
-                    with open(shafilepath, "r") as f:
-                        hashinfo = f.readline().split()
+                    with open(shafilepath, "r") as filestream:
+                        hashinfo = filestream.readline().split()
 
                     # Verify hash
                     if len(hashinfo) != 2 \
@@ -503,9 +536,8 @@ def analyze(self):
                     self.setstatus(3, 'TODO', 'Creating message digest(s) for archive(s): '
                                    + ', '.join(str(x) for x in self.config['sha']))
 
-
-    # Create compressed archive
     def substep1(self):
+        """Create compressed archive"""
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -515,13 +547,13 @@ def substep1(self):
 
             # Create compressed tar files if it does not exist
             if not os.path.isfile(tarfilepath):
-                self.print_exec('Creating ' + tarfilepath)
+                self.verbose('Creating ' + tarfilepath)
                 with self.compressionAlgorithms[tar].open(tarfilepath, 'wb') as tarstream:
                     self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/',
                                       format='tar')
 
-    # Sign the sources
     def substep2(self):
+        """Sign the archive"""
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -539,7 +571,7 @@ def substep2(self):
             if not os.path.isfile(sigfilepath):
                 # Sign tar file
                 with open(tarfilepath, 'rb') as tarstream:
-                    self.print_exec('Creating ' + sigfilepath)
+                    self.verbose('Creating ' + sigfilepath)
                     signed_data = self.gpg.sign_file(
                         tarstream,
                         keyid=self.config['fingerprint'],
@@ -553,8 +585,8 @@ def substep2(self):
                     # TODO https://tools.ietf.org/html/rfc4880#section-9.4
                     #print(signed_data.hash_algo) -> 8 -> SHA256
 
-    # Create the message digest
     def substep3(self):
+        """Create the message digest"""
         # Check all compression option tar files
         filename = self.config['project'] + '-' + self.config['tag']
         for tar in self.config['tar']:
@@ -577,7 +609,7 @@ def substep3(self):
                         self.hash[sha][tarfile] = hash_sha.hexdigest()
 
                     # Write cached hash and filename
-                    self.print_exec('Creating ' + shafilepath)
+                    self.verbose('Creating ' + shafilepath)
                     with open(shafilepath, "w") as filestream:
                         filestream.write(self.hash[sha][tarfile] + '  ' + tarfile)
 
@@ -610,8 +642,7 @@ def analyze(self):
                 try:
                     self.config['token'] = input('Enter Github token to access release API: ')
                 except KeyboardInterrupt:
-                    print()
-                    gpgit.error('Aborted by user')
+                    return 'Aborted by user'
 
             # Create Github API instance
             self.github = Github(self.config['token'])
@@ -668,35 +699,21 @@ def substep2(self):
         # Upload assets
         for asset in self.newassets:
             assetpath = os.path.join(self.config['output'], asset)
-            self.print_exec('Uploading ' + assetpath)
+            self.verbose('Uploading ' + assetpath)
             # TODO not functional
             # see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
-            # TODO change label and mime type
-            self.release.upload_asset(assetpath, "Testlabel", "application/x-xz")
-
-class strmcmp(object):
-    """Helper class to compare a stream without writing"""
-    def __init__(self, strmcmp):
-        self.strmcmp = strmcmp
-        self.__equal = True
-    def write(self, data):
-        if data != self.strmcmp.read(len(data)):
-            self.__equal = False
-    def equal(self):
-        # Check end of file too
-        if self.strmcmp.read(1) == b'' and self.__equal:
-            return True
+            self.release.upload_asset(assetpath)
 
 class GPGit(object):
     """Class that manages GPGit steps and substeps analysis, print and execution."""
     version = '2.0.0'
 
     colormap = {
-        'OK': colors.GREEN,
-        'INFO': colors.YELLOW,
-        'WARN': colors.RED,
-        'TODO': colors.MAGENTA,
-        'NOTE': colors.BLUE,
+        'OK': Colors.GREEN,
+        'INFO': Colors.YELLOW,
+        'WARN': Colors.RED,
+        'TODO': Colors.MAGENTA,
+        'NOTE': Colors.BLUE,
         }
 
     def __init__(self, config):
@@ -734,11 +751,7 @@ def __init__(self, config):
 
             # Check if gitconfig provides a setting
             if self.config[cfg[0]] is None and reader.has_option(cfg[1], cfg[2]):
-                val = reader.get_value(cfg[1], cfg[2])
-                # TODO reading wrong values for commit.gpgsign, type() was working
-                if isinstance(val, int):
-                    val = str(val)
-                self.config[cfg[0]] = val
+                self.config[cfg[0]] = str(reader.get_value(cfg[1], cfg[2]))
 
         # Get default git signing key
         if self.config['fingerprint'] is None and self.config['signingkey']:
@@ -803,15 +816,15 @@ def printstatus(self):
         error = False
         for i, step in enumerate(self.steps, start=1):
             # Sample: "1. Generate a new GPG key"
-            print(colors.BOLD + str(i) + '.', step.name + colors.RESET)
+            print(Colors.BOLD + str(i) + '.', step.name + Colors.RESET)
             for j, substep in enumerate(step.substeps, start=1):
                 # Sample: "1.2 [ OK ] Key already generated"
-                print(colors.BOLD + '  ' + str(i) + '.' + str(j), self.colormap[substep.status]
-                      + '[' + substep.status.center(4) + ']' + colors.RESET, substep.msg)
+                print(Colors.BOLD + '  ' + str(i) + '.' + str(j), self.colormap[substep.status]
+                      + '[' + substep.status.center(4) + ']' + Colors.RESET, substep.msg)
 
                 # Sample: " -> [INFO] GPG key: [rsa4096] 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161"
                 for info in substep.infos:
-                    print(colors.BOLD + '   -> ' + colors.YELLOW + '[INFO]' + colors.RESET, info)
+                    print(Colors.BOLD + '   -> ' + Colors.YELLOW + '[INFO]' + Colors.RESET, info)
 
                 # Check for error or todos
                 if substep.status == 'FAIL':
@@ -830,32 +843,32 @@ def run(self):
         for i, step in enumerate(self.steps, start=1):
             # Run all substeps if enabled
             # Sample: "==> 2. Publish your key"
-            print(colors.GREEN + "==>", colors.BOLD + str(i) + '.', step.name + colors.RESET)
+            print(Colors.GREEN + "==>", Colors.BOLD + str(i) + '.', step.name + Colors.RESET)
             for j, substep in enumerate(step.substeps, start=1):
                 # Run selected step function if activated
                 if substep.status == 'TODO':
                     # Sample: "  -> Will associate your GPG key with Github"
-                    print(colors.BLUE + "  ->", colors.BOLD + str(i) +'.' + str(j),
-                          substep.name + colors.RESET)
+                    print(Colors.BLUE + "  ->", Colors.BOLD + str(i) +'.' + str(j),
+                          substep.name + Colors.RESET)
                     err_msg = substep.funct()
                     if err_msg:
                         return err_msg
 
-    def error(self, *args):
+    @staticmethod
+    def error(*args):
         """Print error and exit program. An optional integer param specifies the exit code."""
         status = 1
         for msg in args:
-            if type(msg) == int:
+            if isinstance(msg, int):
                 status = msg
             else:
-                print(colors.RED + '==> Error:' + colors.RESET, msg)
+                print(Colors.RED + '==> Error:' + Colors.RESET, msg)
         sys.exit(status)
 
-
 def main():
     """Main entry point that parses configs and creates GPGit instance."""
     parser = argparse.ArgumentParser(description='A python script that automates the process of ' \
-                                     + 'signing git sources via GPG.')
+                                     + 'signing Git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')
@@ -913,7 +926,7 @@ def main():
     elif ret < 0:
         gpgit.error('Exiting due to previous errors')
     else:
-        print(colors.GREEN + "==>", colors.RESET, 'Everything looks okay. Nothing to do.')
+        print(Colors.GREEN + "==>", Colors.RESET, 'Everything looks okay. Nothing to do.')
 
 if __name__ == '__main__':
     sys.exit(main())

From 2a5f869bb60a5c5606f0a54a68a6f5637985fd5d Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Thu, 18 May 2017 20:00:23 +0200
Subject: [PATCH 35/46] Minor fixes

---
 gpgit.py | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index ea24c95..7489e6c 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-"""A python script that automates the process of signing Git sources via GPG."""
+"""A Python script that automates the process of signing Git sources via GPG."""
 from __future__ import print_function
 import os
 import sys
@@ -37,16 +37,16 @@ def signal_handler(signum, frame):
         signal.alarm(0)
 
 class Colors(object):
-    RED = "\033[1;31m"
-    BLUE = "\033[1;34m"
-    CYAN = "\033[1;36m"
-    MAGENTA = "\033[1;35m"
-    YELLOW = "\033[1;33m"
-    GREEN = "\033[1;32m"
+    RED = '\033[1;31m'
+    BLUE = '\033[1;34m'
+    CYAN = '\033[1;36m'
+    MAGENTA = '\033[1;35m'
+    YELLOW = '\033[1;33m'
+    GREEN = '\033[1;32m'
     UNDERLINE = '\033[4m'
-    BOLD = "\033[;1m"
-    REVERSE = "\033[;7m"
-    RESET = "\033[0;0m"
+    BOLD = '\033[;1m'
+    REVERSE = '\033[;7m'
+    RESET = '\033[0;0m'
 
 class Streamcmp(object):
     """Helper class to compare a stream without writing"""
@@ -71,7 +71,7 @@ def __init__(self, name, funct):
 
         # Default values
         self.status = 'FAIL'
-        self.msg = 'Aborting due to previous errors'
+        self.msg = 'Internal error'
         self.infos = []
 
 class Step(object):
@@ -712,6 +712,7 @@ class GPGit(object):
         'OK': Colors.GREEN,
         'INFO': Colors.YELLOW,
         'WARN': Colors.RED,
+        'FAIL': Colors.RED,
         'TODO': Colors.MAGENTA,
         'NOTE': Colors.BLUE,
         }
@@ -843,12 +844,12 @@ def run(self):
         for i, step in enumerate(self.steps, start=1):
             # Run all substeps if enabled
             # Sample: "==> 2. Publish your key"
-            print(Colors.GREEN + "==>", Colors.BOLD + str(i) + '.', step.name + Colors.RESET)
+            print(Colors.GREEN + '==>', Colors.BOLD + str(i) + '.', step.name + Colors.RESET)
             for j, substep in enumerate(step.substeps, start=1):
                 # Run selected step function if activated
                 if substep.status == 'TODO':
                     # Sample: "  -> Will associate your GPG key with Github"
-                    print(Colors.BLUE + "  ->", Colors.BOLD + str(i) +'.' + str(j),
+                    print(Colors.BLUE + '  ->', Colors.BOLD + str(i) +'.' + str(j),
                           substep.name + Colors.RESET)
                     err_msg = substep.funct()
                     if err_msg:
@@ -867,7 +868,7 @@ def error(*args):
 
 def main():
     """Main entry point that parses configs and creates GPGit instance."""
-    parser = argparse.ArgumentParser(description='A python script that automates the process of ' \
+    parser = argparse.ArgumentParser(description='A Python script that automates the process of ' \
                                      + 'signing Git sources via GPG.')
     parser.add_argument('tag', action='store', help='Tagname')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
@@ -926,7 +927,7 @@ def main():
     elif ret < 0:
         gpgit.error('Exiting due to previous errors')
     else:
-        print(Colors.GREEN + "==>", Colors.RESET, 'Everything looks okay. Nothing to do.')
+        print(Colors.GREEN + '==>', Colors.RESET, 'Everything looks okay. Nothing to do.')
 
 if __name__ == '__main__':
     sys.exit(main())

From 50acda1a641f92269dc37762e49603d19b18ffe9 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 20 May 2017 12:22:12 +0200
Subject: [PATCH 36/46] Readme updates

---
 Readme.md | 193 +++++++++++++++++++++---------------------------------
 gpgit.py  |  38 +++++------
 2 files changed, 94 insertions(+), 137 deletions(-)

diff --git a/Readme.md b/Readme.md
index 1179a79..25e084e 100644
--- a/Readme.md
+++ b/Readme.md
@@ -3,31 +3,26 @@
 ![gpgit.png](img/gpgit.png)
 
 ## Introduction
-As we all know, today more than ever before, it is crucial to be able to trust
-our computing environments. One of the main difficulties that package
-maintainers of Linux distributions face, is the difficulty to verify the
-authenticity and the integrity of the source code. With GPG signatures it is
-possible for packagers to verify easily and quickly source code releases.
+As we all know, today more than ever before, it is crucial to be able to trust our computing environments. One of the main difficulties that package maintainers of Linux distributions face, is the difficulty to verify the authenticity and the integrity of the source code. With GPG signatures it is possible for packagers to verify source code releases quickly and easily.
 
 #### Overview of the required tasks:
 * Create and/or use a **[4096-bit RSA keypair][1]** for the file signing
 * Use a **[strong, unique, secret passphrase][2]** for the key
 * Upload the public key to a **[key server][3]** and **[publish the full fingerprint][4]**
-* **Sign** every new git **[commit][5]** and **[tag][6]**
+* **Sign** every new Git **[commit][5]** and **[tag][6]**
 * Create **[signed][7], [compressed][8]** (xz --best) release **archives**
 * Upload a **[strong message digest][9]** (sha512) of the archive
 * Configure **[HTTPS][10]** for your download server
 
 ### GPGit
-[GPGit][11] is meant to bring GPG to the masses. It is not only a python script
-that automates the process of [creating new signed git releases with GPG][12]
-but also comes with a [step-by-step readme guide][13] for learning how to use
-GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
+[GPGit][11] is meant to bring GPG to the masses. It is not only a Python script that automates the process of [creating new signed Git releases with GPG][12] but also comes with a [step-by-step readme guide][13] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][14] for uploading.
+
+The security status of Linux projects will be tracked in the [Linux Security Database][15]. Thanks for your help in making Linux projects more secure by using GPG signatures.
 
 [1]: https://github.com/NicoHood/gpgit#12-key-generation
 [2]: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase
-[3]: https://github.com/NicoHood/gpgit#21-submit-your-key-to-a-key-server
-[4]: https://github.com/NicoHood/gpgit#23-publish-your-full-fingerprint
+[3]: https://github.com/NicoHood/gpgit#21-send-key-to-a-key-server
+[4]: https://github.com/NicoHood/gpgit#22-publish-full-fingerprint
 [5]: https://github.com/NicoHood/gpgit#32-commit-signing
 [6]: https://github.com/NicoHood/gpgit#33-create-signed-git-tag
 [7]: https://github.com/NicoHood/gpgit#43-sign-the-sources
@@ -38,7 +33,7 @@ GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
 [12]: https://github.com/NicoHood/gpgit#script-usage
 [13]: https://github.com/NicoHood/gpgit#gpg-quick-start-guide
 [14]: https://developer.github.com/v3/repos/releases/
-
+[15]: https://github.com/NicoHood/LSD
 
 ## Index
 * [Introduction](#introduction)
@@ -51,7 +46,7 @@ GPG. GPGit integrates perfect with the [Github Release API][14] for uploading.
 
 ## Installation
 ### ArchLinux
-You can install gpgit from [AUR](https://aur.archlinux.org/packages/gpgit/).
+You can install GPGit from [AUR](https://aur.archlinux.org/packages/gpgit/).
 Make sure to [build in a clean chroot](https://wiki.archlinux.org/index.php/DeveloperWiki:Building_in_a_Clean_Chroot).
 Please give the package a vote so I can move it to the official ArchLinux
 [community] repository for even simpler installation.
@@ -92,14 +87,14 @@ beside the tag are required.** Follow the instructions and you are good to go.
 For more information checkout the help page:
 ```
 $ gpgit --help
-usage: gpgit.py [-h] [-v] [-m MESSAGE] [-o OUTPUT] [-g GIT_DIR]
+usage: gpgit [-h] [-v] [-m MESSAGE] [-o OUTPUT] [-g GIT_DIR]
                 [-f FINGERPRINT] [-p PROJECT] [-e EMAIL] [-u USERNAME]
-                [-c COMMENT] [-k KEYSERVER] [-n] [-a]
+                [-k KEYSERVER] [-n] [-a]
                 [-t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]]
                 [-s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]] [-b]
                 tag
 
-A Python script that automates the process of signing git sources via GPG.
+A Python script that automates the process of signing Git sources via GPG.
 
 positional arguments:
   tag                   Tagname
@@ -110,27 +105,27 @@ optional arguments:
   -m MESSAGE, --message MESSAGE
                         tag message
   -o OUTPUT, --output OUTPUT
-                        output path of the compressed archive, signature and
-                        message digest
+                        output path of the archive, signature and message
+                        digest
   -g GIT_DIR, --git-dir GIT_DIR
-                        path of the git project
+                        path of the Git project
   -f FINGERPRINT, --fingerprint FINGERPRINT
                         (full) GPG fingerprint to use for signing/verifying
   -p PROJECT, --project PROJECT
                         name of the project, used for archive generation
   -e EMAIL, --email EMAIL
-                        email used for gpg key generation
+                        email used for GPG key generation
   -u USERNAME, --username USERNAME
-                        username used for gpg key generation
-  -c COMMENT, --comment COMMENT
-                        comment used for gpg key generation
+                        username used for GPG key generation
   -k KEYSERVER, --keyserver KEYSERVER
-                        keyserver to use for up/downloading gpg keys
+                        keyserver to use for up/downloading GPG keys
   -n, --no-github       disable Github API functionallity
   -a, --prerelease      Flag as Github prerelease
-  -t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...], --tar {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]
+  -t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...], \
+  --tar {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]
                         compression option
-  -s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...], --sha {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]
+  -s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...], \
+  --sha {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]
                         message digest option
   -b, --no-armor        do not create ascii armored signature output
 ```
@@ -153,46 +148,41 @@ git config --global user.email <email>
 ```
 
 ## GPG Quick Start Guide
-GPGit guides you through 5 simple steps to get your software project ready
-with GPG signatures. Further details can be found below.
+GPGit guides you through 5 simple steps to get your software project ready with GPG signatures. Further details can be found below.
 
 1. [Generate a new GPG key](#1-generate-a-new-gpg-key)
     1. [Strong, unique, secret passphrase](#11-strong-unique-secret-passphrase)
     2. [Key generation](#12-key-generation)
 2. [Publish your key](#2-publish-your-key)
-    1. [Submit your key to a key server](#21-submit-your-key-to-a-key-server)
-    2. [Associate GPG key with Github](#22-associate-gpg-key-with-github)
-    3. [Publish your full fingerprint](#23-publish-your-full-fingerprint)
-3. [Usage of GPG by git](#3-usage-of-gpg-by-git)
-    1. [Configure git GPG key](#31-configure-git-gpg-key)
-    2. [Commit signing](#32-commit-signing)
-    3. [Create signed git tag](#33-create-signed-git-tag)
-4. [Creation of a signed compressed release archive](#4-creation-of-a-signed-compressed-release-archive)
+    1. [Send GPG key to a key server](#21-send-key-to-a-key-server)
+    2. [Publish full fingerprint](#22-publish-full-fingerprint)
+    3. [Associate GPG key with Github](#23-associate-gpg-key-with-github)    
+3. [Use Git with GPG](#3-usage-of-gpg-by-git)
+    1. [Configure Git GPG key](#31-configure-git-gpg-key)
+    2. [Enble commit signing](#32-enable-commit-signing)
+    3. [Create signed Git tag](#33-create-signed-git-tag)
+4. [Create a signed release archive](#4-creation-of-a-signed-compressed-release-archive)
     1. [Create compressed archive](#41-create-compressed-archive)
-    2. [Sign the sources](#42-create-the-message-digest)
+    2. [Sign the archive](#42-create-the-message-digest)
     3. [Create the message digest](#43-sign-the-sources)
 5. [Upload the release](#5-upload-the-release)
-    1. [Github](#51-github)
-    2. [Configure HTTPS for your download server](#52-configure-https-for-your-download-server)
+    1. [Configure HTTPS download server](#51-github)
+    2. [Upload to Github](#52-configure-https-for-your-download-server)
 
 ### 1. Generate a new GPG key
 #### 1.1 Strong, unique, secret passphrase
-Make sure that your new passphrase for the GPG key meets high security
-standards. If the passphrase/key is compromised all of your signatures are
-compromised too.
+Make sure that your new passphrase for the GPG key meets high security standards. If the passphrase/key is compromised all of your signatures are compromised too.
 
 Here are a few examples how to keep a passphrase strong but easy to remember:
 * [How to Create a Secure Password](https://open.buffer.com/creating-a-secure-password/)
 * [Mooltipass](https://www.themooltipass.com/)
 * [Keepass](http://keepass.info/)
+* [PasswordCard](https://www.passwordcard.org/en)
 
 #### 1.2 Key generation
-If you don't have a GPG key yet, create a new one first. You can use RSA
-(4096 bits) or ECC (Curve 25519) for a strong key. The latter one does currently
-not work with Github. You want to stay with RSA for now.
+If you don't have a GPG key yet, create a new one first. You can use RSA (4096 bits) or ECC (Curve 25519) for a strong key. The latter one does currently not work with Github. You want to stay with RSA for now.
 
-**Make sure that your secret key is stored somewhere safe and use a unique
-strong password.**
+**Make sure that your secret key is stored somewhere safe and use a unique strong password.**
 
 Crucial key generation settings:
 * (1) RSA and RSA
@@ -215,24 +205,18 @@ public and secret key created and signed.
 pub   rsa4096 2017-01-04 [SC] [expires: 2018-01-04]
       3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
       3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
-uid                      John Doe (gpgit example) <john@doe.com>
+uid                      John Doe <john@doe.com>
 sub   rsa4096 2017-01-04 [E] [expires: 2018-01-04]
 ```
 
-The generated key has the fingerprint `3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6`
-in this example. Share it with others so they can verify your source.
-[[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Create_key_pair)
+The generated key has the fingerprint `3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6` in this example. Share it with others so they can verify your source. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Create_key_pair)
 
-If you ever move your installation make sure to backup `~/.gnupg/` as it
-contains the **private key** and the **revocation certificate**. Handle it with care.
-[[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Revoking_a_key)
+If you ever move your installation make sure to backup `~/.gnupg/` as it contains the **private key** and the **revocation certificate**. Handle it with care. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Revoking_a_key)
 
 ### 2. Publish your key
 
-#### 2.1 Submit your key to a key server
-To make the public key widely available, upload it to a key server.
-Now the user can get your key by requesting the fingerprint from the keyserver:
-[[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Use_a_keyserver)
+#### 2.1 Send GPG key to a key server
+To make the public key widely available, upload it to a key server. Now the user can get your key by requesting the fingerprint from the keyserver: [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Use_a_keyserver)
 
 ```bash
 # Publish key
@@ -242,10 +226,11 @@ gpg --keyserver hkps://pgp.mit.edu --send-keys <fingerprint>6
 gpg --keyserver hkps://pgp.mit.edu --recv-keys <fingerprint>
 ```
 
+#### 2.3 Publish full fingerprint
+To make it easy for everyone else to find your key it is crucial that you publish the [**full fingerprint**](https://lkml.org/lkml/2016/8/15/445) on a trusted platform, such as your website or Github. To give the key more trust other users can sign your key too. [[Read more]](https://wiki.debian.org/Keysigning)
+
 #### 2.2 Associate GPG key with Github
-To make Github display your commits as "verified" you also need to add your
-public [GPG key to your Github profile](https://github.com/settings/keys).
-[[Read more]](https://help.github.com/articles/generating-a-gpg-key/)
+To make Github display your commits as "verified" you also need to add your public [GPG key to your Github profile](https://github.com/settings/keys). [[Read more]](https://help.github.com/articles/generating-a-gpg-key/)
 
 ```bash
 # List keys + full fingerprint
@@ -255,17 +240,9 @@ gpg --list-secret-keys --keyid-format LONG
 gpg --armor --export <fingerprint>
 ```
 
-#### 2.3 Publish your full fingerprint
-To make it easy for everyone else to find your key it is crucial that you
-publish the [**full fingerprint**](https://lkml.org/lkml/2016/8/15/445) on a trusted platform, such as your website or Github.
-To give the key more trust other users can sign your key too.
-[[Read more]](https://wiki.debian.org/Keysigning)
-
-### 3. Usage of GPG by git
-#### 3.1 Configure git GPG key
-In order to make git use your GPG key you need to set the default signing key
-for git.
-[[Read more]](https://help.github.com/articles/telling-git-about-your-gpg-key/)
+### 3. Use Git with GPG
+#### 3.1 Configure Git GPG key
+In order to make Git use your GPG key you need to set the default signing key for Git. [[Read more]](https://help.github.com/articles/telling-git-about-your-gpg-key/)
 
 ```bash
 # List keys + full fingerprint
@@ -274,20 +251,15 @@ gpg --list-secret-keys --keyid-format LONG
 git config --global user.signingkey <fingerprint>
 ```
 
-#### 3.2 Commit signing
-To verify the git history, git commits needs to be signed. You can manually sign
-commits or enable it by default for every commit. It is recommended to globally
-enable git commit signing.
-[[Read more]](https://help.github.com/articles/signing-commits-using-gpg/)
+#### 3.2 Enable commit signing
+To verify the Git history, Git commits needs to be signed. You can manually sign commits or enable it by default for every commit. It is recommended to globally enable Git commit signing. [[Read more]](https://help.github.com/articles/signing-commits-using-gpg/)
 
 ```bash
 git config --global commit.gpgsign true
 ```
 
-#### 3.3 Create signed git tag
-Git tags need to be created from the command line and always need a switch to
-enable tag signing.
-[[Read more]](https://help.github.com/articles/signing-tags-using-gpg/)
+#### 3.3 Create signed Git tag
+Git tags need to be created from the command line and always need a switch to enable tag signing. [[Read more]](https://help.github.com/articles/signing-tags-using-gpg/)
 
 ```bash
 # Creates a signed tag
@@ -297,12 +269,9 @@ git tag -s mytag
 git tag -v mytag
 ```
 
-### 4. Creation of a signed compressed release archive
+### 4. Create a signed release archive
 #### 4.1 Create compressed archive
-You can use `git archive` to create archives of your tagged git release. It is
-highly recommended to use a strong compression which is especially beneficial
-for those countries with slow and unstable internet connections.
-[[Read more]](https://git-scm.com/docs/git-archive)
+You can use `git archive` to create archives of your tagged Git release. It is highly recommended to use a strong compression which is especially beneficial for those countries with slow and unstable internet connections. [[Read more]](https://git-scm.com/docs/git-archive)
 
 ```bash
 # .tar.gz
@@ -318,73 +287,61 @@ git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | lzip --best > gpgit-1.0.0.
 git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | cmp <(xz -dc gpgit-1.0.0.tar.xz)
 ```
 
-#### 4.2 Sign the sources
+#### 4.2 Sign the archive
 Type the filename of the tarball that you want to sign and then run:
 ```bash
 gpg --armor --detach-sign gpgit-1.0.0.tar.xz
 ```
-Do not blindly sign the Github source downloads unless you have compared its
-content with the local files via `diff.`
-[[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Make_a_detached_signature)
+**Do not blindly sign the Github source downloads** unless you have compared its content with the local files via `diff.` [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Make_a_detached_signature)
 
-To not need to retype your password every time for signing you can also use
-[gpg-agent](https://wiki.archlinux.org/index.php/GnuPG#gpg-agent).
+To not need to retype your password every time for signing you can also use [gpg-agent](https://wiki.archlinux.org/index.php/GnuPG#gpg-agent).
 
-This gives you a file called `gpgit-1.0.0.tar.xz.asc` which is the GPG
-signature. Release it along with your source tarball and let everyone know
-to first verify the signature after downloading.
-[[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Verify_a_signature)
+This gives you a file called `gpgit-1.0.0.tar.xz.asc` which is the GPG signature. Release it along with your source tarball and let everyone know to first verify the signature after downloading. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Verify_a_signature)
 
 ```bash
 gpg --verify gpgit-1.0.0.tar.xz.asc
 ```
 
 #### 4.3 Create the message digest
-Message digests are used to ensure the integrity of a file. It can also serve as
-checksum to verify the download. Message digests **do not** replace GPG
-signatures. They rather provide and alternative simple way to verify the source.
-Make sure to provide message digest over a secure channel like https.
+Message digests are used to ensure the integrity of a file. It can also serve as checksum to verify the download. Message digests **do not** replace GPG signatures. They rather provide and alternative simple way to verify the source. Make sure to provide message digest over a secure channel like https.
 
 ```bash
 sha512 gpgit-1.0.0.tar.xz > gpgit-1.0.0.tar.xz.sha512
 ```
 
 ### 5. Upload the release
-#### 5.1 Github
-Create a new "Github Release" to add additional data to the tag. Then drag the
-.tar.xz .sig and .sha512 file onto the release.
+#### 5.1 Configure HTTPS download server
+* [Why HTTPS Matters](https://developers.google.com/web/fundamentals/security/encrypt-in-transit/why-https)
+* [Let's Encrypt](https://letsencrypt.org/)
+* [SSL Server Test](https://www.ssllabs.com/ssltest/)
 
-The script also supports uploading to Github directly. Create a new Github token
-first and then follow the instructions of the script.
+#### 5.2 Upload to Github
+Create a new "Github Release" to add additional data to the tag. Then drag the .tar.xz .sig and .sha512 files onto the release.
+
+The script also supports uploading to Github directly. Create a new Github token first and then follow the instructions of the script.
 
 How to generate a Github token:
 * Go to ["Settings - Personal access tokens"](https://github.com/settings/tokens)
 * Generate a new token with permissions "public_repo" and "admin:gpg_key"
 * Store it safely
 
-#### 5.2 Configure HTTPS for your download server
-* [Why HTTPS Matters](https://developers.google.com/web/fundamentals/security/encrypt-in-transit/why-https)
-* [Let's Encrypt](https://letsencrypt.org/)
-* [SSL Server Test](https://www.ssllabs.com/ssltest/)
-
 ## Appendix
 
 ### Email Encryption
-You can also use your GPG key for email encryption
-with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird#EnigMail_-_Encryption).
-[[Read more]](https://www.enigmail.net/index.php/en/)
+You can also use your GPG key for email encryption with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird#EnigMail_-_Encryption). [[Read more]](https://www.enigmail.net/index.php/en/)
 
 ## Contact
-You can get securely in touch with me [here](http://contact.nicohood.de).
-Don't hesitate to [file a bug at Github](https://github.com/NicoHood/gpgit/issues).
-More cool projects from me can be found [here](http://www.nicohood.de).
+You can get securely in touch with me [here](http://contact.nicohood.de). Don't hesitate to [file a bug at Github](https://github.com/NicoHood/gpgit/issues). More cool projects from me can be found [here](http://www.nicohood.de).
 
 ## Version History
 ```
+2.0.0 (xx.xx.2017)
+* TODO
+
 1.2.0 (24.04.2017)
 * Trap on errors
 * Detect gpg2
-* Fix git tags pull/push
+* Fix Git tags pull/push
 * Small code fixes
 * Thanks @cmaglie with #3
 
diff --git a/gpgit.py b/gpgit.py
index 7489e6c..35ddf49 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -136,10 +136,10 @@ def analyze(self):
 
         # Check if a fingerprint was selected/found
         if self.config['fingerprint'] is None:
-            # Check if gpg keys are available, but not yet configured
+            # Check if GPG keys are available, but not yet configured
             if private_keys:
                 print('\r\033[K', end='')
-                print("GPG seems to be already configured on your system but git is not.")
+                print("GPG seems to be already configured on your system but Git is not.")
                 print('Please select one of the existing keys below or generate a new one:')
                 print()
 
@@ -166,7 +166,7 @@ def analyze(self):
                 if userinput != 0:
                     self.config['fingerprint'] = private_keys[userinput - 1]['fingerprint']
 
-        # Validate selected gpg key
+        # Validate selected GPG key
         if self.config['fingerprint'] is not None:
             # Check if the full fingerprint is used
             if len(self.config['fingerprint']) != 40:
@@ -234,7 +234,7 @@ def substep2(self):
         %commit
         """.format(self.config['username'], self.config['email'])
 
-        # Execute gpg key generation command
+        # Execute GPG key generation command
         self.verbose('We need to generate a lot of random bytes. It is a good idea to perform')
         self.verbose('some other action (type on the keyboard, move the mouse, utilize the')
         self.verbose('disks) during the prime generation; this gives the random number')
@@ -317,10 +317,10 @@ def __init__(self, config, repo):
 
     def analyze(self):
         """Analyze: Use Git with GPG"""
-        # Check if git was already configured with the gpg key
+        # Check if Git was already configured with the GPG key
         if self.config['signingkey'] != self.config['fingerprint'] \
                 or self.config['fingerprint'] is None:
-            # Check if git was already configured with a different key
+            # Check if Git was already configured with a different key
             if self.config['signingkey'] is None:
                 self.config['config_level'] = 'global'
 
@@ -355,17 +355,17 @@ def analyze(self):
                 self.setstatus(3, 'OK', 'Good signature for existing tag: ' + self.config['tag'])
         else:
             self.setstatus(3, 'TODO', 'Creating signed tag ' + self.config['tag']
-                           + ' and pushing it to the remote git')
+                           + ' and pushing it to the remote Git')
 
     def substep1(self):
-        """Configure git GPG key"""
-        # Configure git signingkey settings
+        """Configure Git GPG key"""
+        # Configure Git signingkey settings
         with self.repo.config_writer(config_level=self.config['config_level']) as cfgwriter:
             cfgwriter.set("user", "signingkey", self.config['fingerprint'])
 
     def substep2(self):
         """Enable commit signing"""
-        # Configure git signingkey settings
+        # Configure Git signingkey settings
         # TODO not working for repository (local) setting as config group does not yet exist
         # TODO also fix above?
         with self.repo.config_writer(config_level=self.config['config_level']) as cfgwriter:
@@ -578,7 +578,7 @@ def substep2(self):
                         binary=bool(self.config['no_armor']),
                         detach=True,
                         output=sigfilepath,
-                        #digest_algo='SHA512' #TODO v 2.x gpg module
+                        #digest_algo='SHA512' #TODO v 2.x GPG module
                         )
                     if signed_data.fingerprint != self.config['fingerprint']:
                         return 'Signing data failed'
@@ -728,11 +728,11 @@ def __init__(self, config):
         # Git
         self.repo = None
 
-        # Create git repository instance
+        # Create Git repository instance
         try:
             self.repo = Repo(self.config['git_dir'], search_parent_directories=True)
         except git.exc.InvalidGitRepositoryError:
-            self.error('Not inside a git directory: ' + self.config['git_dir'])
+            self.error('Not inside a Git directory: ' + self.config['git_dir'])
         reader = self.repo.config_reader()
 
         gitconfig = [
@@ -744,7 +744,7 @@ def __init__(self, config):
             ['token', 'user', 'githubtoken']
         ]
 
-        # Read in git config values
+        # Read in Git config values
         for cfg in gitconfig:
             # Create not existing keys
             if cfg[0] not in self.config:
@@ -754,7 +754,7 @@ def __init__(self, config):
             if self.config[cfg[0]] is None and reader.has_option(cfg[1], cfg[2]):
                 self.config[cfg[0]] = str(reader.get_value(cfg[1], cfg[2]))
 
-        # Get default git signing key
+        # Get default Git signing key
         if self.config['fingerprint'] is None and self.config['signingkey']:
             self.config['fingerprint'] = self.config['signingkey']
 
@@ -876,16 +876,16 @@ def main():
     parser.add_argument('-o', '--output', action='store',
                         help='output path of the archive, signature and message digest')
     parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(),
-                        help='path of the git project')
+                        help='path of the Git project')
     parser.add_argument('-f', '--fingerprint', action='store',
                         help='(full) GPG fingerprint to use for signing/verifying')
     parser.add_argument('-p', '--project', action='store',
                         help='name of the project, used for archive generation')
-    parser.add_argument('-e', '--email', action='store', help='email used for gpg key generation')
+    parser.add_argument('-e', '--email', action='store', help='email used for GPG key generation')
     parser.add_argument('-u', '--username', action='store',
-                        help='username used for gpg key generation')
+                        help='username used for GPG key generation')
     parser.add_argument('-k', '--keyserver', action='store', default='hkps://pgp.mit.edu',
-                        help='keyserver to use for up/downloading gpg keys')
+                        help='keyserver to use for up/downloading GPG keys')
     parser.add_argument('-n', '--no-github', action='store_false', dest='github',
                         help='disable Github API functionallity')
     parser.add_argument('-a', '--prerelease', action='store_true', help='Flag as Github prerelease')

From 835901899b8c72fa4ea00f30de1784b35ceaf1cf Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 20 May 2017 14:00:08 +0200
Subject: [PATCH 37/46] Update Readme

---
 Readme.md | 56 +++++++++++++++++++++++++++----------------------------
 1 file changed, 27 insertions(+), 29 deletions(-)

diff --git a/Readme.md b/Readme.md
index 25e084e..7451b18 100644
--- a/Readme.md
+++ b/Readme.md
@@ -9,31 +9,32 @@ As we all know, today more than ever before, it is crucial to be able to trust o
 * Create and/or use a **[4096-bit RSA keypair][1]** for the file signing
 * Use a **[strong, unique, secret passphrase][2]** for the key
 * Upload the public key to a **[key server][3]** and **[publish the full fingerprint][4]**
-* **Sign** every new Git **[commit][5]** and **[tag][6]**
-* Create **[signed][7], [compressed][8]** (xz --best) release **archives**
-* Upload a **[strong message digest][9]** (sha512) of the archive
-* Configure **[HTTPS][10]** for your download server
+* **[Sign][5]** every new Git **[commit][6]** and **[tag][7]**
+* Create **[signed][8], [compressed][9]** (xz --best) release **archives**
+* Upload a **[strong message digest][10]** (sha512) of the archive
+* Configure **[HTTPS][11]** for your download server
 
 ### GPGit
-[GPGit][11] is meant to bring GPG to the masses. It is not only a Python script that automates the process of [creating new signed Git releases with GPG][12] but also comes with a [step-by-step readme guide][13] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][14] for uploading.
+[GPGit][12] is meant to bring GPG to the masses. It is not only a Python script that automates the process of [creating new signed Git releases with GPG][13] but also comes with a [step-by-step readme guide][14] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][15] for uploading.
 
-The security status of Linux projects will be tracked in the [Linux Security Database][15]. Thanks for your help in making Linux projects more secure by using GPG signatures.
+The security status of Linux projects will be tracked in the [Linux Security Database][16]. Thanks for your help in making Linux projects more secure by using GPG signatures.
 
 [1]: https://github.com/NicoHood/gpgit#12-key-generation
 [2]: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase
 [3]: https://github.com/NicoHood/gpgit#21-send-key-to-a-key-server
 [4]: https://github.com/NicoHood/gpgit#22-publish-full-fingerprint
-[5]: https://github.com/NicoHood/gpgit#32-commit-signing
-[6]: https://github.com/NicoHood/gpgit#33-create-signed-git-tag
-[7]: https://github.com/NicoHood/gpgit#43-sign-the-sources
-[8]: https://github.com/NicoHood/gpgit#41-create-compressed-archive
-[9]: https://github.com/NicoHood/gpgit#42-create-the-message-digest
-[10]: https://github.com/NicoHood/gpgit#52-configure-https-for-your-download-server
-[11]: https://github.com/NicoHood/gpgit
-[12]: https://github.com/NicoHood/gpgit#script-usage
-[13]: https://github.com/NicoHood/gpgit#gpg-quick-start-guide
-[14]: https://developer.github.com/v3/repos/releases/
-[15]: https://github.com/NicoHood/LSD
+[5]: https://github.com/NicoHood/gpgit#31-configure-git-gpg-key
+[6]: https://github.com/NicoHood/gpgit#32-commit-signing
+[7]: https://github.com/NicoHood/gpgit#33-create-signed-git-tag
+[8]: https://github.com/NicoHood/gpgit#42-sign-the-archive
+[9]: https://github.com/NicoHood/gpgit#41-create-compressed-archive
+[10]: https://github.com/NicoHood/gpgit#43-create-the-message-digest
+[11]: https://github.com/NicoHood/gpgit#51-configure-https-download-server
+[12]: https://github.com/NicoHood/gpgit
+[13]: https://github.com/NicoHood/gpgit#script-usage
+[14]: https://github.com/NicoHood/gpgit#gpg-quick-start-guide
+[15]: https://github.com/NicoHood/gpgit#52-upload-to-github
+[16]: https://github.com/NicoHood/LSD
 
 ## Index
 * [Introduction](#introduction)
@@ -46,10 +47,7 @@ The security status of Linux projects will be tracked in the [Linux Security Dat
 
 ## Installation
 ### ArchLinux
-You can install GPGit from [AUR](https://aur.archlinux.org/packages/gpgit/).
-Make sure to [build in a clean chroot](https://wiki.archlinux.org/index.php/DeveloperWiki:Building_in_a_Clean_Chroot).
-Please give the package a vote so I can move it to the official ArchLinux
-[community] repository for even simpler installation.
+You can install GPGit from [AUR](https://aur.archlinux.org/packages/gpgit/). Make sure to [build in a clean chroot](https://wiki.archlinux.org/index.php/DeveloperWiki:Building_in_a_Clean_Chroot). Please give the package a vote so I can move it to the official ArchLinux [community] repository for even simpler installation.
 
 ### Ubuntu/Debian/Other
 GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pypi/pip).
@@ -57,7 +55,7 @@ GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pyp
 ```bash
 # Install dependencies
 sudo apt-get install python3 python3-pip gnupg2 git
-VERSION=2.0.0
+VERSION=2.0.1
 
 # Download and verify source
 wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
@@ -157,17 +155,17 @@ GPGit guides you through 5 simple steps to get your software project ready with
     1. [Send GPG key to a key server](#21-send-key-to-a-key-server)
     2. [Publish full fingerprint](#22-publish-full-fingerprint)
     3. [Associate GPG key with Github](#23-associate-gpg-key-with-github)    
-3. [Use Git with GPG](#3-usage-of-gpg-by-git)
+3. [Use Git with GPG](#3-use-git-with-gpg)
     1. [Configure Git GPG key](#31-configure-git-gpg-key)
     2. [Enble commit signing](#32-enable-commit-signing)
     3. [Create signed Git tag](#33-create-signed-git-tag)
-4. [Create a signed release archive](#4-creation-of-a-signed-compressed-release-archive)
+4. [Create a signed release archive](#4-create-a-signed-release-archive)
     1. [Create compressed archive](#41-create-compressed-archive)
-    2. [Sign the archive](#42-create-the-message-digest)
-    3. [Create the message digest](#43-sign-the-sources)
+    2. [Sign the archive](#42-sign-the-archive)
+    3. [Create the message digest](#43-create-the-message-digest)
 5. [Upload the release](#5-upload-the-release)
-    1. [Configure HTTPS download server](#51-github)
-    2. [Upload to Github](#52-configure-https-for-your-download-server)
+    1. [Configure HTTPS download server](#51-configure-https-download-server)
+    2. [Upload to Github](#52-upload-to-github)
 
 ### 1. Generate a new GPG key
 #### 1.1 Strong, unique, secret passphrase
@@ -318,7 +316,7 @@ sha512 gpgit-1.0.0.tar.xz > gpgit-1.0.0.tar.xz.sha512
 #### 5.2 Upload to Github
 Create a new "Github Release" to add additional data to the tag. Then drag the .tar.xz .sig and .sha512 files onto the release.
 
-The script also supports uploading to Github directly. Create a new Github token first and then follow the instructions of the script.
+The script also supports [uploading to Github](https://developer.github.com/v3/repos/releases/) directly. Create a new Github token first and then follow the instructions of the script.
 
 How to generate a Github token:
 * Go to ["Settings - Personal access tokens"](https://github.com/settings/tokens)

From d9e6aed3cf3f5093e7c7bc748ae00ee4aa894e40 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 3 Jun 2017 20:54:43 +0200
Subject: [PATCH 38/46] Some bugfixes and move parameters into git config

---
 Readme.md | 135 ++++++++++++++++++++-------------------
 gpgit.py  | 184 +++++++++++++++++++++++++++++++-----------------------
 2 files changed, 177 insertions(+), 142 deletions(-)

diff --git a/Readme.md b/Readme.md
index 7451b18..acf0de5 100644
--- a/Readme.md
+++ b/Readme.md
@@ -15,7 +15,7 @@ As we all know, today more than ever before, it is crucial to be able to trust o
 * Configure **[HTTPS][11]** for your download server
 
 ### GPGit
-[GPGit][12] is meant to bring GPG to the masses. It is not only a Python script that automates the process of [creating new signed Git releases with GPG][13] but also comes with a [step-by-step readme guide][14] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][15] for uploading.
+[GPGit][12] is meant to bring GPG to the masses. It is not only a Python script that automates the process of [creating new signed Git releases with GPG][13], but also a [quick-start-guide][14] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][15] for uploading.
 
 The security status of Linux projects will be tracked in the [Linux Security Database][16]. Thanks for your help in making Linux projects more secure by using GPG signatures.
 
@@ -40,7 +40,7 @@ The security status of Linux projects will be tracked in the [Linux Security Dat
 * [Introduction](#introduction)
 * [Installation](#installation)
 * [Script Usage](#script-usage)
-* [GPG quick start guide](#gpg-quick-start-guide)
+* [GPG Quick Start Guide](#gpg-quick-start-guide)
 * [Appendix](#appendix)
 * [Contact](#contact)
 * [Version History](#version-history)
@@ -55,7 +55,7 @@ GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pyp
 ```bash
 # Install dependencies
 sudo apt-get install python3 python3-pip gnupg2 git
-VERSION=2.0.1
+VERSION=2.0.2
 
 # Download and verify source
 wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
@@ -74,76 +74,75 @@ gpgit --help
 ```
 
 ## Script Usage
-The script guides you through all 5 steps of the
-[GPG quick start guide](#gpg-quick-start-guide). **By default no extra arguments
-beside the tag are required.** Follow the instructions and you are good to go.
+The script guides you through all 5 steps of the [GPG quick start guide](#gpg-quick-start-guide). **By default no extra arguments beside the tag are required.** Follow the instructions and you are good to go.
 
 ![screenshot](img/screenshot.png)
 
 ### Parameters
 
-For more information checkout the help page:
-```
-$ gpgit --help
-usage: gpgit [-h] [-v] [-m MESSAGE] [-o OUTPUT] [-g GIT_DIR]
-                [-f FINGERPRINT] [-p PROJECT] [-e EMAIL] [-u USERNAME]
-                [-k KEYSERVER] [-n] [-a]
-                [-t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]]
-                [-s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]] [-b]
-                tag
-
-A Python script that automates the process of signing Git sources via GPG.
-
-positional arguments:
-  tag                   Tagname
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -v, --version         show program's version number and exit
-  -m MESSAGE, --message MESSAGE
-                        tag message
-  -o OUTPUT, --output OUTPUT
-                        output path of the archive, signature and message
-                        digest
-  -g GIT_DIR, --git-dir GIT_DIR
-                        path of the Git project
-  -f FINGERPRINT, --fingerprint FINGERPRINT
-                        (full) GPG fingerprint to use for signing/verifying
-  -p PROJECT, --project PROJECT
-                        name of the project, used for archive generation
-  -e EMAIL, --email EMAIL
-                        email used for GPG key generation
-  -u USERNAME, --username USERNAME
-                        username used for GPG key generation
-  -k KEYSERVER, --keyserver KEYSERVER
-                        keyserver to use for up/downloading GPG keys
-  -n, --no-github       disable Github API functionallity
-  -a, --prerelease      Flag as Github prerelease
-  -t {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...], \
-  --tar {gz,gzip,xz,bz2,bzip2} [{gz,gzip,xz,bz2,bzip2} ...]
-                        compression option
-  -s {sha256,sha384,sha512} [{sha256,sha384,sha512} ...], \
-  --sha {sha256,sha384,sha512} [{sha256,sha384,sha512} ...]
-                        message digest option
-  -b, --no-armor        do not create ascii armored signature output
-```
+#### -h, --help
+Show help message and exit.
+
+#### -v, --version
+Show program's version and exit.
+
+#### tag
+Tagname of the release. E.g. `1.0.0` or `20170521` with `$(date +%Y%m%d)`.
+
+#### -m <msg>, --message <msg>
+Use the given <msg> as the commit message.
+
+#### -o <path>, --output <path>
+Output path of the archive, signature and message digest. You can also set this option via configuration.
+
+#### -g <path>, --git-dir <path>
+Path to the Git project.
+
+#### -n, --no-github
+Disable Github API functionality. Github releases need to be created manually and release assets need to be uploaded manually. GPGit will not prompt for a Github token anymore.
+
+#### -p, --prerelease
+Flag as Github prerelease.
 
 ### Configuration
-Additional configuration can be made via [git config](https://git-scm.com/docs/git-config).
+Additional configuration can be made via [git config](https://git-scm.com/docs/git-config). Example usage:
 
 ```bash
-# GPGit settings
-git config --global user.githubtoken <githubtoken>
-git config --global user.gpgitoutput ~/gpgit
+git config --global gpgit.token <token>
+git config --global gpgit.output ~/gpgit
+git config --local gpgit.tar xz
+```
 
-# GPG settings
-git config --global user.signingkey <fingerprint>
-git config --global commit.gpgsign true
+#### user.signingkey
+Full GPG fingerprint to use for signing/verifying.
+
+#### gpgit.output
+Output path of the archive, signature and message digest. You can also set this option via parameter.
+
+#### gpgit.tar
+Archive compression option. Chose between "gz,gzip,xz,bz2,bzip2". Default: "xz"
+
+#### gpgit.sha
+Message digest algorithm. chose between "sha256,sha384,sha512". Default: "sha512"
+
+#### gpgit.keyserver
+Keyserver to use for GPG key check. Automatically set to "skip" after the first check was successfull. Default: "hkps://pgp.mit.edu"
+
+#### gpgit.github
+Enable or disable Github functionality with "true|false". Default: "true" (enabled)
+
+#### gpgit.user
+Username used for github uploading.
+
+#### gpgit.project
+Project name used for github uploading and archive naming.
+
+#### gpgit.armor
+Use ascii armored output of GPG (.asc instead of .sig) with "true|false". Default: "true" (armored output).
+
+#### gpgit.token
+Specify the Github token for Github API release uploading.
 
-# General settings
-git config --global user.name <username>
-git config --global user.email <email>
-```
 
 ## GPG Quick Start Guide
 GPGit guides you through 5 simple steps to get your software project ready with GPG signatures. Further details can be found below.
@@ -334,7 +333,17 @@ You can get securely in touch with me [here](http://contact.nicohood.de). Don't
 ## Version History
 ```
 2.0.0 (xx.xx.2017)
-* TODO
+* Switch to Python3 from bash
+* New user interface with preview
+* More verification
+* Better GPG usage
+* More parameters
+* Configurable settings via git config
+* Better error traces
+* Resigning a tag is now possible
+* General improvements
+* New logo
+* Improved documentation
 
 1.2.0 (24.04.2017)
 * Trap on errors
diff --git a/gpgit.py b/gpgit.py
index 35ddf49..2dee0db 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -9,6 +9,7 @@
 import gzip
 import lzma
 import bz2
+from getpass import getpass
 import signal
 from contextlib import contextmanager
 from github import Github, GithubException
@@ -139,7 +140,7 @@ def analyze(self):
             # Check if GPG keys are available, but not yet configured
             if private_keys:
                 print('\r\033[K', end='')
-                print("GPG seems to be already configured on your system but Git is not.")
+                print('GPG seems to be already configured on your system but Git is not.')
                 print('Please select one of the existing keys below or generate a new one:')
                 print()
 
@@ -276,6 +277,7 @@ def analyze(self):
             # Check key on keyserver
             try:
                 with time_limit(10):
+                    # TODO cannot catch error for unknown GPG key as its run in a separat thread
                     key = self.gpg.recv_keys(self.config['keyserver'], self.config['fingerprint'])
             except TimeoutException:
                 return 'Keyserver timed out. Please try again alter.'
@@ -317,14 +319,10 @@ def __init__(self, config, repo):
 
     def analyze(self):
         """Analyze: Use Git with GPG"""
-        # Check if Git was already configured with the GPG key
-        if self.config['signingkey'] != self.config['fingerprint'] \
-                or self.config['fingerprint'] is None:
-            # Check if Git was already configured with a different key
-            if self.config['signingkey'] is None:
-                self.config['config_level'] = 'global'
-
-            self.setstatus(1, 'TODO', 'Configuring ' + self.config['config_level'] + 'Git GPG key')
+        # Check if Git was already configured with a different key
+        if self.config['fingerprint'] is None:
+            self.config['config_level'] = 'global'
+            self.setstatus(1, 'TODO', 'Configuring ' + self.config['config_level'] + ' Git GPG key')
         else:
             self.setstatus(1, 'OK', 'Git already configured with your GPG key')
 
@@ -470,10 +468,10 @@ def analyze(self):
                                'Path: ' + self.config['output'], 'Basename: ' + filename)
 
             # Get signature filename from setting
-            if self.config['no_armor']:
-                sigfile = tarfile + '.sig'
-            else:
+            if self.config['armor']:
                 sigfile = tarfile + '.asc'
+            else:
+                sigfile = tarfile + '.sig'
             self.assets += [sigfile]
             sigfilepath = os.path.join(self.config['output'], sigfile)
 
@@ -562,10 +560,10 @@ def substep2(self):
             tarfilepath = os.path.join(self.config['output'], tarfile)
 
             # Get signature filename from setting
-            if self.config['no_armor']:
-                sigfilepath = tarfilepath + '.sig'
-            else:
+            if self.config['armor']:
                 sigfilepath = tarfilepath + '.asc'
+            else:
+                sigfilepath = tarfilepath + '.sig'
 
             # Check if signature is existant
             if not os.path.isfile(sigfilepath):
@@ -575,7 +573,7 @@ def substep2(self):
                     signed_data = self.gpg.sign_file(
                         tarstream,
                         keyid=self.config['fingerprint'],
-                        binary=bool(self.config['no_armor']),
+                        binary=not bool(self.config['armor']),
                         detach=True,
                         output=sigfilepath,
                         #digest_algo='SHA512' #TODO v 2.x GPG module
@@ -640,7 +638,12 @@ def analyze(self):
             # Ask for Github token
             if self.config['token'] is None:
                 try:
-                    self.config['token'] = input('Enter Github token to access release API: ')
+                    print('\r\033[K', end='')
+                    print('Accessing Github API to access Github releases and assets.')
+                    print('You can deactive Github API uploading with -n or set your',
+                          'Github token permanent with:')
+                    print('git config --global user.githubtoken <githubtoken>')
+                    self.config['token'] = getpass('Please enter Github token: ')
                 except KeyboardInterrupt:
                     return 'Aborted by user'
 
@@ -654,7 +657,8 @@ def analyze(self):
             except GithubException:
                 # TODO improve exception:
                 #https://github.com/PyGithub/PyGithub/issues/152#issuecomment-301249927
-                return 'Error accessing Github API for project ' + self.config['project']
+                return 'Error accessing Github API for project ' + self.config['project'] \
+                       + ' with username ' + self.config['username'] + '. Wrong token supplied?'
 
             # Check Release and its assets
             try:
@@ -667,7 +671,13 @@ def analyze(self):
                 return
             else:
                 # Determine which assets need to be uploaded
-                asset_list = [x.name for x in self.release.get_assets()]
+                try:
+                    asset_list = [x.name for x in self.release.get_assets()]
+                except AttributeError:
+                    self.config['github'] = False
+                    self.setstatus(2, 'WARN', 'Requires PyGithub >= 1.35')
+                    return
+
                 for asset in self.assets:
                     if asset not in asset_list:
                         self.newassets += [asset]
@@ -706,7 +716,7 @@ def substep2(self):
 
 class GPGit(object):
     """Class that manages GPGit steps and substeps analysis, print and execution."""
-    version = '2.0.0'
+    version = '2.0.2'
 
     colormap = {
         'OK': Colors.GREEN,
@@ -717,31 +727,62 @@ class GPGit(object):
         'NOTE': Colors.BLUE,
         }
 
-    def __init__(self, config):
-        # Config via parameters
-        self.config = config
+    def __init__(self, tag, config):
+        # Create module instances and helpers
+        self.gpg = gnupg.GPG()
+        self.repo = None
         self.assets = []
 
-        # GPG
-        self.gpg = gnupg.GPG()
+        # Config via parameters
+        self.config = {
+            'tag': tag,
+            'message': None,
+            'output': None,
+            'git_dir': os.getcwd(),
+            'github': False,
+            'prerelease': False,
+        }
 
-        # Git
-        self.repo = None
+        # Overwrite every default value if passed in via parameter
+        for param in self.config:
+            if param in config:
+                self.config[param] = config[param]
+
+        # Load configuration
+        self.load_git_config()
+        self.load_default_config()
+
+        # Create array fo steps to analyse and run
+        step1 = Step1(self.config, self.gpg)
+        step2 = Step2(self.config, self.gpg)
+        step3 = Step3(self.config, self.repo)
+        step4 = Step4(self.config, self.gpg, self.repo, self.assets)
+        step5 = Step5(self.config, self.assets)
+        self.steps = [step1, step2, step3, step4, step5]
 
-        # Create Git repository instance
+    def load_git_config(self):
+        """Loads configuration settings from git config. Does not overwrite existing settings."""
         try:
             self.repo = Repo(self.config['git_dir'], search_parent_directories=True)
         except git.exc.InvalidGitRepositoryError:
             self.error('Not inside a Git directory: ' + self.config['git_dir'])
         reader = self.repo.config_reader()
 
+        # Array represents: config['username'], git config user.name
         gitconfig = [
             ['username', 'user', 'name'],
             ['email', 'user', 'email'],
-            ['signingkey', 'user', 'signingkey'],
+            ['fingerprint', 'user', 'signingkey'],
             ['gpgsign', 'commit', 'gpgsign'],
-            ['output', 'user', 'gpgitoutput'],
-            ['token', 'user', 'githubtoken']
+            ['output', 'gpgit', 'output'],
+            ['tar', 'gpgit', 'tar'],
+            ['sha', 'gpgit', 'sha'],
+            ['keyserver', 'gpgit', 'keyserver'], # TODO set to the fp once the key was checked once to speed things up
+            ['github', 'gpgit', 'github'],
+            ['username', 'gpgit', 'user'],
+            ['project', 'gpgit', 'project'],
+            ['armor', 'gpgit', 'armor'],
+            ['token', 'gpgit', 'token'],
         ]
 
         # Read in Git config values
@@ -754,23 +795,30 @@ def __init__(self, config):
             if self.config[cfg[0]] is None and reader.has_option(cfg[1], cfg[2]):
                 self.config[cfg[0]] = str(reader.get_value(cfg[1], cfg[2]))
 
-        # Get default Git signing key
-        if self.config['fingerprint'] is None and self.config['signingkey']:
-            self.config['fingerprint'] = self.config['signingkey']
-
-        # Check if Github URL is used
-        if self.config['github'] is True:
-            if 'github' not in self.repo.remotes.origin.url.lower():
-                self.config['github'] = False
-
-        # Default message
-        if self.config['message'] is None:
-            self.config['message'] = 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' \
-                                     + self.version + '\nhttps://github.com/NicoHood/gpgit'
+        # Convert tar and sha settings into arrays
+        if self.config['tar'] and not isinstance(self.config['tar'], list):
+            self.config['tar'] = self.config['tar'].split(',')
+        if self.config['sha'] and not isinstance(self.config['sha'], list):
+            self.config['sha'] = self.config['sha'].split(',')
+
+    def load_default_config(self):
+        """Autodetects missing parameters or sets default values."""
+        defaults = {
+            'sha': ['sha512'],
+            'tar': ['xz'],
+            'keyserver': 'hkps://pgp.mit.edu',
+            'armor': True,
+            'config_level': 'repository',
+            'message': 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' \
+                       + self.version + '\nhttps://github.com/NicoHood/gpgit',
+            'project': os.path.basename(self.repo.remotes.origin.url).replace('.git', ''),
+            'output': os.path.join(self.repo.working_tree_dir, 'gpgit'),
+        }
 
-        # Default output path
-        if self.config['output'] is None:
-            self.config['output'] = os.path.join(self.repo.working_tree_dir, 'archive')
+        # Load default values
+        for val in defaults:
+            if val not in self.config or self.config[val] is None:
+                self.config[val] = defaults[val]
 
         # Check if path exists
         if not os.path.isdir(self.config['output']):
@@ -786,21 +834,11 @@ def __init__(self, config):
             else:
                 self.error('Aborted by user')
 
-        # Set default project name
-        if self.config['project'] is None:
-            url = self.repo.remotes.origin.url
-            self.config['project'] = os.path.basename(url).replace('.git', '')
-
-        # Default config level (repository == local)
-        self.config['config_level'] = 'repository'
-
-        # Create array fo steps to analyse and run
-        step1 = Step1(self.config, self.gpg)
-        step2 = Step2(self.config, self.gpg)
-        step3 = Step3(self.config, self.repo)
-        step4 = Step4(self.config, self.gpg, self.repo, self.assets)
-        step5 = Step5(self.config, self.assets)
-        self.steps = [step1, step2, step3, step4, step5]
+        # Check if Github URL is used
+        # TODO fix for projects that dont have a Github url
+        if self.config['github'] is True:
+            if 'github' not in self.repo.remotes.origin.url.lower():
+                self.config['github'] = False
 
     def analyze(self):
         """Analze all steps and substeps for later preview printing"""
@@ -838,6 +876,7 @@ def printstatus(self):
             return -1
         if todo:
             return 1
+        return 0
 
     def run(self):
         """Execute all steps + substeps."""
@@ -870,35 +909,21 @@ def main():
     """Main entry point that parses configs and creates GPGit instance."""
     parser = argparse.ArgumentParser(description='A Python script that automates the process of ' \
                                      + 'signing Git sources via GPG.')
-    parser.add_argument('tag', action='store', help='Tagname')
+    parser.add_argument('tag', action='store',
+                        help='Tagname of the release. E.g. "1.0.0" or "20170521".')
     parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
     parser.add_argument('-m', '--message', action='store', help='tag message')
     parser.add_argument('-o', '--output', action='store',
                         help='output path of the archive, signature and message digest')
     parser.add_argument('-g', '--git-dir', action='store', default=os.getcwd(),
                         help='path of the Git project')
-    parser.add_argument('-f', '--fingerprint', action='store',
-                        help='(full) GPG fingerprint to use for signing/verifying')
-    parser.add_argument('-p', '--project', action='store',
-                        help='name of the project, used for archive generation')
-    parser.add_argument('-e', '--email', action='store', help='email used for GPG key generation')
-    parser.add_argument('-u', '--username', action='store',
-                        help='username used for GPG key generation')
-    parser.add_argument('-k', '--keyserver', action='store', default='hkps://pgp.mit.edu',
-                        help='keyserver to use for up/downloading GPG keys')
     parser.add_argument('-n', '--no-github', action='store_false', dest='github',
                         help='disable Github API functionallity')
     parser.add_argument('-a', '--prerelease', action='store_true', help='Flag as Github prerelease')
-    parser.add_argument('-t', '--tar', choices=['gz', 'gzip', 'xz', 'bz2', 'bzip2'], default=['xz'],
-                        nargs='+', help='compression option')
-    parser.add_argument('-s', '--sha', choices=['sha256', 'sha384', 'sha512'], default=['sha512'],
-                        nargs='+', help='message digest option')
-    parser.add_argument('-b', '--no-armor', action='store_true',
-                        help='do not create ascii armored signature output')
 
     args = parser.parse_args()
 
-    gpgit = GPGit(vars(args))
+    gpgit = GPGit(args.tag, vars(args))
     err_msg = gpgit.analyze()
     if err_msg:
         print()
@@ -921,6 +946,7 @@ def main():
             if err_msg:
                 gpgit.error(err_msg)
             else:
+                # TODO more colors with green arrow
                 print('Finished without errors')
         else:
             gpgit.error('Aborted by user')

From a66846947c6453f9b62231b35d7f5dd2e8315700 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 3 Jun 2017 21:02:45 +0200
Subject: [PATCH 39/46] Changed readme sections

---
 Readme.md | 51 +++++++++++++++++++++++++--------------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git a/Readme.md b/Readme.md
index acf0de5..340f512 100644
--- a/Readme.md
+++ b/Readme.md
@@ -2,7 +2,7 @@
 
 ![gpgit.png](img/gpgit.png)
 
-## Introduction
+# Introduction
 As we all know, today more than ever before, it is crucial to be able to trust our computing environments. One of the main difficulties that package maintainers of Linux distributions face, is the difficulty to verify the authenticity and the integrity of the source code. With GPG signatures it is possible for packagers to verify source code releases quickly and easily.
 
 #### Overview of the required tasks:
@@ -38,12 +38,11 @@ The security status of Linux projects will be tracked in the [Linux Security Dat
 
 ## Index
 * [Introduction](#introduction)
-* [Installation](#installation)
-* [Script Usage](#script-usage)
+* [GPGit Documentation](#gpgit-documentation)
 * [GPG Quick Start Guide](#gpg-quick-start-guide)
 * [Appendix](#appendix)
-* [Contact](#contact)
-* [Version History](#version-history)
+
+# GPGit Documentation
 
 ## Installation
 ### ArchLinux
@@ -144,7 +143,7 @@ Use ascii armored output of GPG (.asc instead of .sig) with "true|false". Defaul
 Specify the Github token for Github API release uploading.
 
 
-## GPG Quick Start Guide
+# GPG Quick Start Guide
 GPGit guides you through 5 simple steps to get your software project ready with GPG signatures. Further details can be found below.
 
 1. [Generate a new GPG key](#1-generate-a-new-gpg-key)
@@ -166,8 +165,8 @@ GPGit guides you through 5 simple steps to get your software project ready with
     1. [Configure HTTPS download server](#51-configure-https-download-server)
     2. [Upload to Github](#52-upload-to-github)
 
-### 1. Generate a new GPG key
-#### 1.1 Strong, unique, secret passphrase
+## 1. Generate a new GPG key
+### 1.1 Strong, unique, secret passphrase
 Make sure that your new passphrase for the GPG key meets high security standards. If the passphrase/key is compromised all of your signatures are compromised too.
 
 Here are a few examples how to keep a passphrase strong but easy to remember:
@@ -176,7 +175,7 @@ Here are a few examples how to keep a passphrase strong but easy to remember:
 * [Keepass](http://keepass.info/)
 * [PasswordCard](https://www.passwordcard.org/en)
 
-#### 1.2 Key generation
+### 1.2 Key generation
 If you don't have a GPG key yet, create a new one first. You can use RSA (4096 bits) or ECC (Curve 25519) for a strong key. The latter one does currently not work with Github. You want to stay with RSA for now.
 
 **Make sure that your secret key is stored somewhere safe and use a unique strong password.**
@@ -210,9 +209,9 @@ The generated key has the fingerprint `3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6`
 
 If you ever move your installation make sure to backup `~/.gnupg/` as it contains the **private key** and the **revocation certificate**. Handle it with care. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Revoking_a_key)
 
-### 2. Publish your key
+## 2. Publish your key
 
-#### 2.1 Send GPG key to a key server
+### 2.1 Send GPG key to a key server
 To make the public key widely available, upload it to a key server. Now the user can get your key by requesting the fingerprint from the keyserver: [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Use_a_keyserver)
 
 ```bash
@@ -223,10 +222,10 @@ gpg --keyserver hkps://pgp.mit.edu --send-keys <fingerprint>6
 gpg --keyserver hkps://pgp.mit.edu --recv-keys <fingerprint>
 ```
 
-#### 2.3 Publish full fingerprint
+### 2.3 Publish full fingerprint
 To make it easy for everyone else to find your key it is crucial that you publish the [**full fingerprint**](https://lkml.org/lkml/2016/8/15/445) on a trusted platform, such as your website or Github. To give the key more trust other users can sign your key too. [[Read more]](https://wiki.debian.org/Keysigning)
 
-#### 2.2 Associate GPG key with Github
+### 2.2 Associate GPG key with Github
 To make Github display your commits as "verified" you also need to add your public [GPG key to your Github profile](https://github.com/settings/keys). [[Read more]](https://help.github.com/articles/generating-a-gpg-key/)
 
 ```bash
@@ -237,8 +236,8 @@ gpg --list-secret-keys --keyid-format LONG
 gpg --armor --export <fingerprint>
 ```
 
-### 3. Use Git with GPG
-#### 3.1 Configure Git GPG key
+## 3. Use Git with GPG
+### 3.1 Configure Git GPG key
 In order to make Git use your GPG key you need to set the default signing key for Git. [[Read more]](https://help.github.com/articles/telling-git-about-your-gpg-key/)
 
 ```bash
@@ -248,14 +247,14 @@ gpg --list-secret-keys --keyid-format LONG
 git config --global user.signingkey <fingerprint>
 ```
 
-#### 3.2 Enable commit signing
+### 3.2 Enable commit signing
 To verify the Git history, Git commits needs to be signed. You can manually sign commits or enable it by default for every commit. It is recommended to globally enable Git commit signing. [[Read more]](https://help.github.com/articles/signing-commits-using-gpg/)
 
 ```bash
 git config --global commit.gpgsign true
 ```
 
-#### 3.3 Create signed Git tag
+### 3.3 Create signed Git tag
 Git tags need to be created from the command line and always need a switch to enable tag signing. [[Read more]](https://help.github.com/articles/signing-tags-using-gpg/)
 
 ```bash
@@ -266,8 +265,8 @@ git tag -s mytag
 git tag -v mytag
 ```
 
-### 4. Create a signed release archive
-#### 4.1 Create compressed archive
+## 4. Create a signed release archive
+### 4.1 Create compressed archive
 You can use `git archive` to create archives of your tagged Git release. It is highly recommended to use a strong compression which is especially beneficial for those countries with slow and unstable internet connections. [[Read more]](https://git-scm.com/docs/git-archive)
 
 ```bash
@@ -284,7 +283,7 @@ git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | lzip --best > gpgit-1.0.0.
 git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | cmp <(xz -dc gpgit-1.0.0.tar.xz)
 ```
 
-#### 4.2 Sign the archive
+### 4.2 Sign the archive
 Type the filename of the tarball that you want to sign and then run:
 ```bash
 gpg --armor --detach-sign gpgit-1.0.0.tar.xz
@@ -299,20 +298,20 @@ This gives you a file called `gpgit-1.0.0.tar.xz.asc` which is the GPG signature
 gpg --verify gpgit-1.0.0.tar.xz.asc
 ```
 
-#### 4.3 Create the message digest
+### 4.3 Create the message digest
 Message digests are used to ensure the integrity of a file. It can also serve as checksum to verify the download. Message digests **do not** replace GPG signatures. They rather provide and alternative simple way to verify the source. Make sure to provide message digest over a secure channel like https.
 
 ```bash
 sha512 gpgit-1.0.0.tar.xz > gpgit-1.0.0.tar.xz.sha512
 ```
 
-### 5. Upload the release
-#### 5.1 Configure HTTPS download server
+## 5. Upload the release
+### 5.1 Configure HTTPS download server
 * [Why HTTPS Matters](https://developers.google.com/web/fundamentals/security/encrypt-in-transit/why-https)
 * [Let's Encrypt](https://letsencrypt.org/)
 * [SSL Server Test](https://www.ssllabs.com/ssltest/)
 
-#### 5.2 Upload to Github
+### 5.2 Upload to Github
 Create a new "Github Release" to add additional data to the tag. Then drag the .tar.xz .sig and .sha512 files onto the release.
 
 The script also supports [uploading to Github](https://developer.github.com/v3/repos/releases/) directly. Create a new Github token first and then follow the instructions of the script.
@@ -322,9 +321,9 @@ How to generate a Github token:
 * Generate a new token with permissions "public_repo" and "admin:gpg_key"
 * Store it safely
 
-## Appendix
+# Appendix
 
-### Email Encryption
+## Email Encryption
 You can also use your GPG key for email encryption with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird#EnigMail_-_Encryption). [[Read more]](https://www.enigmail.net/index.php/en/)
 
 ## Contact

From f412651f659887dc9e00aff923e664545e8b6ff0 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 3 Jun 2017 21:05:05 +0200
Subject: [PATCH 40/46] Fixed readme headlines

---
 Readme.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Readme.md b/Readme.md
index 340f512..2b6637e 100644
--- a/Readme.md
+++ b/Readme.md
@@ -150,7 +150,7 @@ GPGit guides you through 5 simple steps to get your software project ready with
     1. [Strong, unique, secret passphrase](#11-strong-unique-secret-passphrase)
     2. [Key generation](#12-key-generation)
 2. [Publish your key](#2-publish-your-key)
-    1. [Send GPG key to a key server](#21-send-key-to-a-key-server)
+    1. [Send GPG key to a key server](#21-send-gpg-key-to-a-key-server)
     2. [Publish full fingerprint](#22-publish-full-fingerprint)
     3. [Associate GPG key with Github](#23-associate-gpg-key-with-github)    
 3. [Use Git with GPG](#3-use-git-with-gpg)
@@ -222,10 +222,10 @@ gpg --keyserver hkps://pgp.mit.edu --send-keys <fingerprint>6
 gpg --keyserver hkps://pgp.mit.edu --recv-keys <fingerprint>
 ```
 
-### 2.3 Publish full fingerprint
+### 2.2 Publish full fingerprint
 To make it easy for everyone else to find your key it is crucial that you publish the [**full fingerprint**](https://lkml.org/lkml/2016/8/15/445) on a trusted platform, such as your website or Github. To give the key more trust other users can sign your key too. [[Read more]](https://wiki.debian.org/Keysigning)
 
-### 2.2 Associate GPG key with Github
+### 2.3 Associate GPG key with Github
 To make Github display your commits as "verified" you also need to add your public [GPG key to your Github profile](https://github.com/settings/keys). [[Read more]](https://help.github.com/articles/generating-a-gpg-key/)
 
 ```bash

From 87d5a1fa6e88cdea895fc3b4c96ad39b55d60ebf Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Sat, 3 Jun 2017 21:06:08 +0200
Subject: [PATCH 41/46] Remove appendix from index

---
 Readme.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Readme.md b/Readme.md
index 2b6637e..e172582 100644
--- a/Readme.md
+++ b/Readme.md
@@ -40,7 +40,6 @@ The security status of Linux projects will be tracked in the [Linux Security Dat
 * [Introduction](#introduction)
 * [GPGit Documentation](#gpgit-documentation)
 * [GPG Quick Start Guide](#gpg-quick-start-guide)
-* [Appendix](#appendix)
 
 # GPGit Documentation
 

From 5406babbaeebb5455685f6ba0e38d4d1bc18fba8 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Tue, 13 Jun 2017 20:20:37 +0200
Subject: [PATCH 42/46] Prerelease 2.0.4

---
 Readme.md |  2 +-
 gpgit.py  | 14 +++++++-------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Readme.md b/Readme.md
index e172582..8c950df 100644
--- a/Readme.md
+++ b/Readme.md
@@ -53,7 +53,7 @@ GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pyp
 ```bash
 # Install dependencies
 sudo apt-get install python3 python3-pip gnupg2 git
-VERSION=2.0.2
+VERSION=2.0.4
 
 # Download and verify source
 wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
diff --git a/gpgit.py b/gpgit.py
index 2dee0db..631fcc1 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -753,12 +753,12 @@ def __init__(self, tag, config):
         self.load_default_config()
 
         # Create array fo steps to analyse and run
-        step1 = Step1(self.config, self.gpg)
-        step2 = Step2(self.config, self.gpg)
-        step3 = Step3(self.config, self.repo)
-        step4 = Step4(self.config, self.gpg, self.repo, self.assets)
-        step5 = Step5(self.config, self.assets)
-        self.steps = [step1, step2, step3, step4, step5]
+        self.step1 = Step1(self.config, self.gpg)
+        self.step2 = Step2(self.config, self.gpg)
+        self.step3 = Step3(self.config, self.repo)
+        self.step4 = Step4(self.config, self.gpg, self.repo, self.assets)
+        self.step5 = Step5(self.config, self.assets)
+        self.steps = [self.step1, self.step2, self.step3, self.step4, self.step5]
 
     def load_git_config(self):
         """Loads configuration settings from git config. Does not overwrite existing settings."""
@@ -919,7 +919,7 @@ def main():
                         help='path of the Git project')
     parser.add_argument('-n', '--no-github', action='store_false', dest='github',
                         help='disable Github API functionallity')
-    parser.add_argument('-a', '--prerelease', action='store_true', help='Flag as Github prerelease')
+    parser.add_argument('-p', '--prerelease', action='store_true', help='Flag as Github prerelease')
 
     args = parser.parse_args()
 

From c8fc2b943310bac31b4e89954557496c9b625d01 Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Wed, 14 Jun 2017 19:37:21 +0200
Subject: [PATCH 43/46] Small fixes for prerelease 2.0.5

---
 Readme.md |  2 +-
 gpgit.py  | 10 +++++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/Readme.md b/Readme.md
index 8c950df..d3521f8 100644
--- a/Readme.md
+++ b/Readme.md
@@ -53,7 +53,7 @@ GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pyp
 ```bash
 # Install dependencies
 sudo apt-get install python3 python3-pip gnupg2 git
-VERSION=2.0.4
+VERSION=2.0.5
 
 # Download and verify source
 wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
diff --git a/gpgit.py b/gpgit.py
index 631fcc1..437784f 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -203,6 +203,10 @@ def analyze(self):
             self.setstatus(1, 'NOTE', 'Please use a strong, unique, secret passphrase')
 
         else:
+            # Check if Git username and email is set
+            if not self.config['username']or not self.config['email']:
+                return 'Please set your email and username with: "git config --global user.email <email>" and  "git config --global user.name <name>"'
+
             # Generate a new key
             self.setstatus(2, 'TODO', 'Generating an RSA 4096 GPG key for '
                            + self.config['username'] + ' ' + self.config['email']
@@ -327,7 +331,7 @@ def analyze(self):
             self.setstatus(1, 'OK', 'Git already configured with your GPG key')
 
         # Check commit signing
-        if self.config['gpgsign'].lower() == 'true':
+        if self.config['gpgsign'] and self.config['gpgsign'].lower() == 'true':
             self.setstatus(2, 'OK', 'Commit signing already enabled')
         else:
             self.setstatus(2, 'TODO', 'Enabling ' + self.config['config_level'] + ' commit signing')
@@ -716,7 +720,7 @@ def substep2(self):
 
 class GPGit(object):
     """Class that manages GPGit steps and substeps analysis, print and execution."""
-    version = '2.0.2'
+    __version__ = '2.0.5'
 
     colormap = {
         'OK': Colors.GREEN,
@@ -911,7 +915,7 @@ def main():
                                      + 'signing Git sources via GPG.')
     parser.add_argument('tag', action='store',
                         help='Tagname of the release. E.g. "1.0.0" or "20170521".')
-    parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.version)
+    parser.add_argument('-v', '--version', action='version', version='GPGit ' + GPGit.__version__)
     parser.add_argument('-m', '--message', action='store', help='tag message')
     parser.add_argument('-o', '--output', action='store',
                         help='output path of the archive, signature and message digest')

From f21e0c0cd5f3da419713401fee350ce39f18c85a Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Mon, 19 Jun 2017 21:34:41 +0200
Subject: [PATCH 44/46] i18n for strings

---
 gpgit.py | 62 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 30 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index 437784f..dfe85ae 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -196,7 +196,7 @@ def analyze(self):
 
             # Use selected key
             self.setstatus(2, 'OK', 'Key already generated',
-                           'GPG key: ' + gpgkey['uids'][0], 'GPG ID: [' + gpgkey['algoname'] + ' '
+                           'GPG key: {}'.format(gpgkey['uids'][0]), 'GPG ID: [' + gpgkey['algoname'] + ' '
                            + gpgkey['length'] + '] ' + gpgkey['fingerprint'] + ' ')
 
             # Warn about strong passphrase
@@ -208,9 +208,9 @@ def analyze(self):
                 return 'Please set your email and username with: "git config --global user.email <email>" and  "git config --global user.name <name>"'
 
             # Generate a new key
-            self.setstatus(2, 'TODO', 'Generating an RSA 4096 GPG key for '
-                           + self.config['username'] + ' ' + self.config['email']
-                           + ' valid for 1 year.')
+            self.setstatus(2, 'TODO',
+                           'Generating an RSA 4096 GPG key for {} {} valid for 1 year.'.format( \
+                           self.config['username'], self.config['email']))
 
             # Warn about strong passphrase
             self.setstatus(1, 'TODO', 'Please use a strong, unique, secret passphrase')
@@ -245,8 +245,8 @@ def substep2(self):
         self.verbose('disks) during the prime generation; this gives the random number')
         self.verbose('generator a better chance to gain enough entropy.')
         self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
-        self.verbose('Key generation finished. You new fingerprint is: '
-                     + self.config['fingerprint'])
+        self.verbose('Key generation finished. You new fingerprint is: {}'.format(
+                                                                    self.config['fingerprint']))
 
 class Step2(Step):
     """Publish your GPG key"""
@@ -288,20 +288,20 @@ def analyze(self):
 
             # Found key on keyserver
             if self.config['fingerprint'] in key.fingerprints:
-                self.setstatus(1, 'OK', 'Key already published on ' + self.config['keyserver'])
+                self.setstatus(1, 'OK', 'Key already published on {}'.format(self.config['keyserver']))
                 return
 
         # Upload key to keyserver
-        self.setstatus(1, 'TODO', 'Publishing key on ' + self.config['keyserver'])
+        self.setstatus(1, 'TODO', 'Publishing key on {}'.format(self.config['keyserver']))
 
     def substep1(self):
         """Send GPG key to a key server"""
-        self.verbose('Publishing key ' + self.config['fingerprint'])
+        self.verbose('Publishing key {}'.format(self.config['fingerprint']))
         self.gpg.send_keys(self.config['keyserver'], self.config['fingerprint'])
 
     def substep2(self):
         """Publish your full fingerprint"""
-        print('Your fingerprint is:', self.config['fingerprint'])
+        print('Your fingerprint is: {}'.format(self.config['fingerprint']))
 
     def substep3(self):
         """Associate GPG key with Github"""
@@ -326,7 +326,7 @@ def analyze(self):
         # Check if Git was already configured with a different key
         if self.config['fingerprint'] is None:
             self.config['config_level'] = 'global'
-            self.setstatus(1, 'TODO', 'Configuring ' + self.config['config_level'] + ' Git GPG key')
+            self.setstatus(1, 'TODO', 'Configuring {} Git GPG key'.format(self.config['config_level']))
         else:
             self.setstatus(1, 'OK', 'Git already configured with your GPG key')
 
@@ -334,7 +334,7 @@ def analyze(self):
         if self.config['gpgsign'] and self.config['gpgsign'].lower() == 'true':
             self.setstatus(2, 'OK', 'Commit signing already enabled')
         else:
-            self.setstatus(2, 'TODO', 'Enabling ' + self.config['config_level'] + ' commit signing')
+            self.setstatus(2, 'TODO', 'Enabling {} commit signing'.format(self.config['config_level']))
 
         # Refresh tags
         try:
@@ -352,12 +352,13 @@ def analyze(self):
                 if hasattr(tag.tag, 'message') \
                         and '-----BEGIN PGP SIGNATURE-----' in tag.tag.message:
                     return 'Invalid signature for tag ' + self.config['tag']
-                self.setstatus(3, 'TODO', 'Signing existing tag: ' + self.config['tag'])
+                self.setstatus(3, 'TODO', 'Signing existing tag: {}'.format(self.config['tag']))
             else:
-                self.setstatus(3, 'OK', 'Good signature for existing tag: ' + self.config['tag'])
+                self.setstatus(3, 'OK', 'Good signature for existing tag: {}'.format(self.config['tag']))
         else:
-            self.setstatus(3, 'TODO', 'Creating signed tag ' + self.config['tag']
-                           + ' and pushing it to the remote Git')
+            self.setstatus(3, 'TODO',
+                           'Creating signed tag {} and pushing it to the remote Git'.format( \
+                           self.config['tag']))
 
     def substep1(self):
         """Configure Git GPG key"""
@@ -375,7 +376,7 @@ def substep2(self):
 
     def substep3(self):
         """Create signed Git tag"""
-        self.verbose('Creating, signing and pushing tag ' + self.config['tag'])
+        self.verbose('Creating, signing and pushing tag {}'.format(self.config['tag']))
 
         # Check if tag needs to be recreated
         force = False
@@ -465,11 +466,11 @@ def analyze(self):
 
                 # Successfully verified
                 self.setstatus(1, 'OK', 'Existing archive(s) verified successfully',
-                               'Path: ' + self.config['output'], 'Basename: ' + filename)
+                               'Path: {}'.format(self.config['output']), 'Basename: {}'.format(filename))
             else:
-                self.setstatus(1, 'TODO', 'Creating new release archive(s): '
-                               + ', '.join(str(x) for x in self.config['tar']),
-                               'Path: ' + self.config['output'], 'Basename: ' + filename)
+                self.setstatus(1, 'TODO', 'Creating new release archive(s): {}'.format( \
+                               ', '.join(str(x) for x in self.config['tar'])),
+                               'Path: {}'.format(self.config['output']), 'Basename: {}'.format(filename))
 
             # Get signature filename from setting
             if self.config['armor']:
@@ -535,8 +536,9 @@ def analyze(self):
                     # Successfully verified
                     self.setstatus(3, 'OK', 'Existing message digest(s) verified successfully')
                 else:
-                    self.setstatus(3, 'TODO', 'Creating message digest(s) for archive(s): '
-                                   + ', '.join(str(x) for x in self.config['sha']))
+                    self.setstatus(3, 'TODO',
+                                   'Creating message digest(s) for archive(s): {}'.format( \
+                                   ', '.join(str(x) for x in self.config['sha'])))
 
     def substep1(self):
         """Create compressed archive"""
@@ -549,7 +551,7 @@ def substep1(self):
 
             # Create compressed tar files if it does not exist
             if not os.path.isfile(tarfilepath):
-                self.verbose('Creating ' + tarfilepath)
+                self.verbose('Creating {}'.format(tarfilepath))
                 with self.compressionAlgorithms[tar].open(tarfilepath, 'wb') as tarstream:
                     self.repo.archive(tarstream, treeish=self.config['tag'], prefix=filename + '/',
                                       format='tar')
@@ -573,7 +575,7 @@ def substep2(self):
             if not os.path.isfile(sigfilepath):
                 # Sign tar file
                 with open(tarfilepath, 'rb') as tarstream:
-                    self.verbose('Creating ' + sigfilepath)
+                    self.verbose('Creating {}'.format(sigfilepath))
                     signed_data = self.gpg.sign_file(
                         tarstream,
                         keyid=self.config['fingerprint'],
@@ -611,7 +613,7 @@ def substep3(self):
                         self.hash[sha][tarfile] = hash_sha.hexdigest()
 
                     # Write cached hash and filename
-                    self.verbose('Creating ' + shafilepath)
+                    self.verbose('Creating {}'.format(shafilepath))
                     with open(shafilepath, "w") as filestream:
                         filestream.write(self.hash[sha][tarfile] + '  ' + tarfile)
 
@@ -713,7 +715,7 @@ def substep2(self):
         # Upload assets
         for asset in self.newassets:
             assetpath = os.path.join(self.config['output'], asset)
-            self.verbose('Uploading ' + assetpath)
+            self.verbose('Uploading {}'.format(assetpath))
             # TODO not functional
             # see https://github.com/PyGithub/PyGithub/pull/525#issuecomment-301132357
             self.release.upload_asset(assetpath)
@@ -814,7 +816,7 @@ def load_default_config(self):
             'armor': True,
             'config_level': 'repository',
             'message': 'Release ' + self.config['tag'] + '\n\nCreated with GPGit ' \
-                       + self.version + '\nhttps://github.com/NicoHood/gpgit',
+                       + self.__version__ + '\nhttps://github.com/NicoHood/gpgit',
             'project': os.path.basename(self.repo.remotes.origin.url).replace('.git', ''),
             'output': os.path.join(self.repo.working_tree_dir, 'gpgit'),
         }
@@ -827,7 +829,7 @@ def load_default_config(self):
         # Check if path exists
         if not os.path.isdir(self.config['output']):
             # Create not existing path
-            print('Not a valid path: ' + self.config['output'])
+            print('Not a valid path: {}'.format(self.config['output']))
             try:
                 ret = input('Create non-existing output path? [Y/n]')
             except KeyboardInterrupt:
@@ -847,7 +849,7 @@ def load_default_config(self):
     def analyze(self):
         """Analze all steps and substeps for later preview printing"""
         for i, step in enumerate(self.steps, start=1):
-            print('Analyzing step', i, 'of', len(self.steps), end='...', flush=True)
+            print('Analyzing step {} of {}...'.format(i, len(self.steps)), end='', flush=True)
             err_msg = step.analyze()
             if err_msg:
                 return err_msg

From 558bbef072994a30e50e61187c40f6ecf1c1e86c Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Mon, 19 Jun 2017 21:41:11 +0200
Subject: [PATCH 45/46] Fix line length

---
 gpgit.py | 48 +++++++++++++++++++++++++++---------------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/gpgit.py b/gpgit.py
index dfe85ae..0d9d1a0 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -196,7 +196,8 @@ def analyze(self):
 
             # Use selected key
             self.setstatus(2, 'OK', 'Key already generated',
-                           'GPG key: {}'.format(gpgkey['uids'][0]), 'GPG ID: [' + gpgkey['algoname'] + ' '
+                           'GPG key: {}'.format(gpgkey['uids'][0]),
+                           'GPG ID: [' + gpgkey['algoname'] + ' '
                            + gpgkey['length'] + '] ' + gpgkey['fingerprint'] + ' ')
 
             # Warn about strong passphrase
@@ -205,12 +206,13 @@ def analyze(self):
         else:
             # Check if Git username and email is set
             if not self.config['username']or not self.config['email']:
-                return 'Please set your email and username with: "git config --global user.email <email>" and  "git config --global user.name <name>"'
+                return 'Please set your email and username with: ' \
+                       + '"git config --global user.email <email>" and ' \
+                       + '"git config --global user.name <name>"'
 
             # Generate a new key
-            self.setstatus(2, 'TODO',
-                           'Generating an RSA 4096 GPG key for {} {} valid for 1 year.'.format( \
-                           self.config['username'], self.config['email']))
+            self.setstatus(2, 'TODO', 'Generating an RSA 4096 GPG key for {} {} valid for 1 year.' \
+                           .format(self.config['username'], self.config['email']))
 
             # Warn about strong passphrase
             self.setstatus(1, 'TODO', 'Please use a strong, unique, secret passphrase')
@@ -245,8 +247,8 @@ def substep2(self):
         self.verbose('disks) during the prime generation; this gives the random number')
         self.verbose('generator a better chance to gain enough entropy.')
         self.config['fingerprint'] = str(self.gpg.gen_key(input_data))
-        self.verbose('Key generation finished. You new fingerprint is: {}'.format(
-                                                                    self.config['fingerprint']))
+        self.verbose('Key generation finished. You new fingerprint is: {}' \
+                     .format(self.config['fingerprint']))
 
 class Step2(Step):
     """Publish your GPG key"""
@@ -288,7 +290,8 @@ def analyze(self):
 
             # Found key on keyserver
             if self.config['fingerprint'] in key.fingerprints:
-                self.setstatus(1, 'OK', 'Key already published on {}'.format(self.config['keyserver']))
+                self.setstatus(1, 'OK', 'Key already published on {}' \
+                               .format(self.config['keyserver']))
                 return
 
         # Upload key to keyserver
@@ -326,7 +329,8 @@ def analyze(self):
         # Check if Git was already configured with a different key
         if self.config['fingerprint'] is None:
             self.config['config_level'] = 'global'
-            self.setstatus(1, 'TODO', 'Configuring {} Git GPG key'.format(self.config['config_level']))
+            self.setstatus(1, 'TODO', 'Configuring {} Git GPG key' \
+                           .format(self.config['config_level']))
         else:
             self.setstatus(1, 'OK', 'Git already configured with your GPG key')
 
@@ -334,7 +338,8 @@ def analyze(self):
         if self.config['gpgsign'] and self.config['gpgsign'].lower() == 'true':
             self.setstatus(2, 'OK', 'Commit signing already enabled')
         else:
-            self.setstatus(2, 'TODO', 'Enabling {} commit signing'.format(self.config['config_level']))
+            self.setstatus(2, 'TODO', 'Enabling {} commit signing' \
+                           .format(self.config['config_level']))
 
         # Refresh tags
         try:
@@ -354,11 +359,11 @@ def analyze(self):
                     return 'Invalid signature for tag ' + self.config['tag']
                 self.setstatus(3, 'TODO', 'Signing existing tag: {}'.format(self.config['tag']))
             else:
-                self.setstatus(3, 'OK', 'Good signature for existing tag: {}'.format(self.config['tag']))
+                self.setstatus(3, 'OK', 'Good signature for existing tag: {}' \
+                               .format(self.config['tag']))
         else:
-            self.setstatus(3, 'TODO',
-                           'Creating signed tag {} and pushing it to the remote Git'.format( \
-                           self.config['tag']))
+            self.setstatus(3, 'TODO', 'Creating signed tag {} and pushing it to the remote Git' \
+                           .format(self.config['tag']))
 
     def substep1(self):
         """Configure Git GPG key"""
@@ -466,11 +471,13 @@ def analyze(self):
 
                 # Successfully verified
                 self.setstatus(1, 'OK', 'Existing archive(s) verified successfully',
-                               'Path: {}'.format(self.config['output']), 'Basename: {}'.format(filename))
+                               'Path: {}'.format(self.config['output']),
+                               'Basename: {}'.format(filename))
             else:
-                self.setstatus(1, 'TODO', 'Creating new release archive(s): {}'.format( \
-                               ', '.join(str(x) for x in self.config['tar'])),
-                               'Path: {}'.format(self.config['output']), 'Basename: {}'.format(filename))
+                self.setstatus(1, 'TODO', 'Creating new release archive(s): {}' \
+                               .format(', '.join(str(x) for x in self.config['tar'])),
+                               'Path: {}'.format(self.config['output']),
+                               'Basename: {}'.format(filename))
 
             # Get signature filename from setting
             if self.config['armor']:
@@ -536,9 +543,8 @@ def analyze(self):
                     # Successfully verified
                     self.setstatus(3, 'OK', 'Existing message digest(s) verified successfully')
                 else:
-                    self.setstatus(3, 'TODO',
-                                   'Creating message digest(s) for archive(s): {}'.format( \
-                                   ', '.join(str(x) for x in self.config['sha'])))
+                    self.setstatus(3, 'TODO', 'Creating message digest(s) for archive(s): {}' \
+                                   .format(', '.join(str(x) for x in self.config['sha'])))
 
     def substep1(self):
         """Create compressed archive"""

From 971c4612982c500802c2d42f3685e05cf23cf50f Mon Sep 17 00:00:00 2001
From: NicoHood <git@nicohood.de>
Date: Tue, 27 Jun 2017 16:04:56 +0200
Subject: [PATCH 46/46] Prepare for 2.0.7 Release

---
 Makefile                    | 2 +-
 Readme.md                   | 4 ++--
 gpgit.py                    | 2 +-
 gpgit.sh => legacy/gpgit.sh | 0
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename gpgit.sh => legacy/gpgit.sh (100%)

diff --git a/Makefile b/Makefile
index 80efb8a..d4d2ae3 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ all:
 	  @echo "Run 'make uninstall' for uninstallation."
 
 install:
-		install -Dm755 gpgit.sh $(DESTDIR)$(PREFIX)/bin/gpgit
+		install -Dm755 gpgit.py $(DESTDIR)$(PREFIX)/bin/gpgit
 		install -Dm644 Readme.md $(DESTDIR)$(PREFIX)/share/doc/gpgit/Readme.md
 
 uninstall:
diff --git a/Readme.md b/Readme.md
index d3521f8..46daa66 100644
--- a/Readme.md
+++ b/Readme.md
@@ -53,7 +53,7 @@ GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pyp
 ```bash
 # Install dependencies
 sudo apt-get install python3 python3-pip gnupg2 git
-VERSION=2.0.5
+VERSION=2.0.7
 
 # Download and verify source
 wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
@@ -330,7 +330,7 @@ You can get securely in touch with me [here](http://contact.nicohood.de). Don't
 
 ## Version History
 ```
-2.0.0 (xx.xx.2017)
+2.0.7 (27.06.2017)
 * Switch to Python3 from bash
 * New user interface with preview
 * More verification
diff --git a/gpgit.py b/gpgit.py
index 0d9d1a0..b5c44c7 100755
--- a/gpgit.py
+++ b/gpgit.py
@@ -728,7 +728,7 @@ def substep2(self):
 
 class GPGit(object):
     """Class that manages GPGit steps and substeps analysis, print and execution."""
-    __version__ = '2.0.5'
+    __version__ = '2.0.7'
 
     colormap = {
         'OK': Colors.GREEN,
diff --git a/gpgit.sh b/legacy/gpgit.sh
similarity index 100%
rename from gpgit.sh
rename to legacy/gpgit.sh