port to PyQt5, runs on Py2.7 and 3.4+, more modular

Author: 8go

Makefile

@@ -1,14 +1,16 @@
 UI_GENERATED := \
+	ui_trezor_chooser_dialog.py \
+	ui_trezor_pin_dialog.py \
 	ui_trezor_passphrase_dialog.py \
 	ui_dialog.py \
-	ui_enter_pin_dialog.py \
-	ui_trezor_chooser_dialog.py \
 	#end of UI_GENERATED
 
 all: $(UI_GENERATED)
 
 ui_%.py: %.ui
-	pyuic4 -o $@ $<
+	pyuic5 -o $@ $<
 
 clean:
-	rm -rf $(UI_GENERATED)
+	rm -f $(UI_GENERATED)
+	rm -rf __pycache__
+	rm -f *.pyc

README.md

@@ -9,8 +9,6 @@
 `TrezorSymmetricFileEncryption` is a small, simple tool that
 allows you to symmetrically encrypt and decrypt files.
 
-Note that it is software, currently in alpha stage.
-
 # Features
 
   * Trezor convenience

TrezorSymmetricFileEncryption.py

@@ -16,190 +16,27 @@
 
 import sys
 import logging
-import getpass
 
-from PyQt4 import QtGui
+from PyQt5.QtWidgets import QApplication  # for the clipboard and window
 
-from trezorlib.client import BaseClient, ProtocolMixin  # CallException, PinException
-from trezorlib.transport import ConnectionError
-from trezorlib.transport_hid import HidTransport
-from trezorlib import messages_pb2 as proto
-
-import file_map
-
-from dialogs import TrezorPassphraseDialog, Dialog, EnterPinDialog, TrezorChooserDialog
+from dialogs import Dialog
 
 import basics
+import settings
 import processing
+from trezor_app_specific import FileMap
+import trezor_app_generic
 
+"""
+The file with the main function.
 
-class QtTrezorMixin(object):
-	"""
-	Mixin for input of Trezor PIN and passhprases.
-	Works via both, terminal as well as PyQt GUI
-	"""
-
-	def __init__(self, *args, **kwargs):
-		super(QtTrezorMixin, self).__init__(*args, **kwargs)
-		self.passphrase = None
-		self.readpinfromstdin = None
-		self.readpassphrasefromstdin = None
-
-	def callback_ButtonRequest(self, msg):
-		return proto.ButtonAck()
-
-	def callback_PassphraseRequest(self, msg):
-		if self.passphrase is not None:
-			return proto.PassphraseAck(passphrase=str(self.passphrase))
-
-		if self.readpassphrasefromstdin:
-			# read passphrase from stdin
-			try:
-				passphrase = getpass.getpass("Please enter passphrase: ")
-				passphrase = str(passphrase)
-			except KeyboardInterrupt:
-				sys.stderr.write("\nKeyboard interrupt: passphrase not read. Aborting.\n")
-				sys.exit(3)
-			except Exception as e:
-				sys.stderr.write("Critical error: Passphrase not read. Aborting. (%s)" % e)
-				sys.exit(3)
-		else:
-			dialog = TrezorPassphraseDialog()
-			if not dialog.exec_():
-				sys.exit(3)
-			else:
-				passphrase = dialog.passphraseEdit.text()
-				passphrase = str(passphrase)
-
-		return proto.PassphraseAck(passphrase=passphrase)
-
-	def callback_PinMatrixRequest(self, msg):
-		if self.readpinfromstdin:
-			# read PIN from stdin
-			print("                  7  8  9")
-			print("                  4  5  6")
-			print("                  1  2  3")
-			try:
-				pin = getpass.getpass("Please enter PIN: ")
-			except KeyboardInterrupt:
-				sys.stderr.write("\nKeyboard interrupt: PIN not read. Aborting.\n")
-				sys.exit(7)
-			except Exception as e:
-				sys.stderr.write("Critical error: PIN not read. Aborting. (%s)" % e)
-				sys.exit(7)
-		else:
-			dialog = EnterPinDialog()
-			if not dialog.exec_():
-				sys.exit(7)
-			pin = dialog.pin()
-
-		return proto.PinMatrixAck(pin=pin)
-
-	def prefillPassphrase(self, passphrase):
-		"""
-		Instead of asking for passphrase, use this one
-		"""
-		if passphrase is not None:
-			self.passphrase = passphrase.decode("utf-8")
-		else:
-			self.passphrase = None
+Code should work on both Python 2.7 as well as 3.4.
+Requires PyQt5.
+(Old version supported PyQt4.)
+"""
 
-	def prefillReadpinfromstdin(self, readpinfromstdin=False):
-		"""
-		Specify if PIN should be read from stdin instead of from GUI
-		@param readpinfromstdin: True to force it to read from stdin, False otherwise
-		@type readpinfromstdin: C{bool}
-		"""
-		self.readpinfromstdin = readpinfromstdin
 
-	def prefillReadpassphrasefromstdin(self, readpassphrasefromstdin=False):
-		"""
-		Specify if passphrase should be read from stdin instead of from GUI
-		@param readpassphrasefromstdin: True to force it to read from stdin, False otherwise
-		@type readpassphrasefromstdin: C{bool}
-		"""
-		self.readpassphrasefromstdin = readpassphrasefromstdin
-
-
-class QtTrezorClient(ProtocolMixin, QtTrezorMixin, BaseClient):
-	"""
-	Trezor client with Qt input methods
-	"""
-	pass
-
-
-class TrezorChooser(object):
-	"""Class for working with Trezor device via HID"""
-
-	def __init__(self):
-		pass
-
-	def getDevice(self):
-		"""
-		Get one from available devices. Widget will be shown if more
-		devices are available.
-		"""
-		devices = self.enumerateHIDDevices()
-
-		if not devices:
-			return None
-
-		transport = self.chooseDevice(devices)
-		client = QtTrezorClient(transport)
-
-		return client
-
-	def enumerateHIDDevices(self):
-		"""Returns Trezor HID devices"""
-		devices = HidTransport.enumerate()
-
-		return devices
-
-	def chooseDevice(self, devices):
-		"""
-		Choose device from enumerated list. If there's only one Trezor,
-		that will be chosen.
-
-		If there are multiple Trezors, diplays a widget with list
-		of Trezor devices to choose from.
-
-		@returns HidTransport object of selected device
-		"""
-		if not len(devices):
-			raise RuntimeError("No Trezor connected!")
-
-		if len(devices) == 1:
-			try:
-				return HidTransport(devices[0])
-			except IOError:
-				raise RuntimeError("Trezor is currently in use")
-
-		# maps deviceId string to device label
-		deviceMap = {}
-		for device in devices:
-			try:
-				transport = HidTransport(device)
-				client = QtTrezorClient(transport)
-				label = client.features.label and client.features.label or "<no label>"
-				client.close()
-
-				deviceMap[device[0]] = label
-			except IOError:
-				# device in use, do not offer as choice
-				continue
-
-		if not deviceMap:
-			raise RuntimeError("All connected Trezors are in use!")
-
-		dialog = TrezorChooserDialog(deviceMap)
-		if not dialog.exec_():
-			sys.exit(9)
-
-		deviceStr = dialog.chosenDeviceStr()
-		return HidTransport([deviceStr, None])
-
-
-def showGui(trezor, settings, fileMap, logger):
+def showGui(trezor, dialog, settings):
 	"""
 	Initialize, ask for encrypt/decrypt options,
 	ask for files to be decrypted/encrypted,
@@ -212,66 +49,74 @@ def showGui(trezor, settings, fileMap, logger):
 	@param settings: Settings object to store command line arguments or
 		items selected in GUI
 	"""
-	dialog = Dialog(trezor, settings, fileMap, logger)
-	settings.settings2Gui(dialog, trezor)
-	processing.reportLogging("Trezor label: %s" % trezor.features.label, logging.INFO,
-		"Trezor IO", settings, logger, dialog)
+	settings.settings2Gui(dialog)
 	if not dialog.exec_():
-		processing.reportLogging("Shutting down due to user request "
-			"(Done/Quit was called).", logging.DEBUG,
-			"GUI IO", settings, logger, None)
-		sys.exit(4)  # Esc or exception
-	settings.gui2Settings(dialog, trezor)
-
-
-# root
-
-logging.basicConfig(stream=sys.stderr, level=basics.LOGGINGLEVEL)
-logger = logging.getLogger('tsfe')
-
-app = QtGui.QApplication(sys.argv)
+		# Esc or exception or Quit/Close/Done
+		settings.mlogger.log("Shutting down due to user request "
+			"(Done/Quit was called).", logging.DEBUG, "GUI IO")
+		# sys.exit(4)
+	settings.gui2Settings(dialog)
 
-settings = processing.Settings(logger)  # initialize settings
-# parse command line
-processing.parseArgs(sys.argv[1:], settings, logger)
 
-try:
-	trezorChooser = TrezorChooser()
-	trezor = trezorChooser.getDevice()
-except (ConnectionError, RuntimeError) as e:
-	processing.reportLogging("Connection to Trezor failed: %s" % e.message,
-		logging.CRITICAL, "Trezor Error", settings, logger)
-	sys.exit(1)
-
-if trezor is None:
-	processing.reportLogging("No available Trezor found, quitting.",
-		logging.CRITICAL, "Trezor Error", settings, logger)
-	sys.exit(1)
-
-trezor.clear_session()
-trezor.prefillReadpinfromstdin(settings.RArg)
-trezor.prefillReadpassphrasefromstdin(settings.AArg)
-trezor.prefillPassphrase(settings.PArg)
-
-fileMap = file_map.FileMap(trezor, logger)
-
-# if everything is specified in the command line then do not call the GUI
-if ((settings.PArg is None) or (len(settings.inputFiles) <= 0)) and (not settings.TArg):
-	# something was not specified, so we call the GUI
-	showGui(trezor, settings, fileMap, logger)
-else:
-	processing.reportLogging("Trezor label: %s" % trezor.features.label, logging.INFO,
-		"Trezor IO", settings, logger, None)
-	processing.reportLogging("Everything was specified or --terminal was set, "
-		"hence the GUI will not be called.", logging.INFO,
-		"Trezor IO", settings, logger, None)
+def useTerminal(fileMap, settings):
 	if settings.WArg:
-		processing.reportLogging("The option `--wipe` is set. In case of "
+		settings.mlogger.log("The option `--wipe` is set. In case of "
 			"encryption, the original plaintext files will "
 			"be shredded after encryption. In case of decryption, "
 			"the encrypted files will be shredded after decryption. "
 			"Abort if you are uncertain or don't understand.", logging.WARNING,
-			"Dangerous arguments", settings, logger, None)
-
-	processing.processAll(trezor, settings, fileMap, logger, dialog=None)
-	sys.exit(0)
+			"Dangerous arguments")
+	processing.processAll(fileMap, settings, dialog=None)
+
+
+def main():
+	app = QApplication(sys.argv)
+	if app is None:  # just to get rid f the linter warning on above line
+		print("Critical error: Qt cannot be initialized.")
+	sets = settings.Settings()  # initialize settings
+	# parse command line
+	args = settings.Args(sets)
+	args.parseArgs(sys.argv[1:])
+
+	trezor = trezor_app_generic.setupTrezor(sets.TArg, sets.mlogger)
+	# trezor.clear_session() ## not needed
+	trezor.prefillReadpinfromstdin(sets.RArg)
+	trezor.prefillReadpassphrasefromstdin(sets.AArg)
+	if sets.PArg is None:
+		trezor.prefillPassphrase(u'')
+	else:
+		trezor.prefillPassphrase(sets.PArg)
+
+	# if everything is specified in the command line then do not call the GUI
+	if ((sets.PArg is None) or (len(sets.inputFiles) <= 0)) and (not sets.TArg):
+		dialog = Dialog(trezor, sets)
+		sets.mlogger.setQtextbrowser(dialog.textBrowser)
+		sets.mlogger.setQtextheader(dialog.descrHeader())
+		sets.mlogger.setQtextcontent(dialog.descrContent())
+		sets.mlogger.setQtexttrailer(dialog.descrTrailer())
+	else:
+		sets.mlogger.log("Everything was specified or --terminal was set, "
+			"hence the GUI will not be called.", logging.INFO, u"Arguments")
+
+	sets.mlogger.log("Trezor label: %s" % trezor.features.label,
+		logging.INFO, "Trezor IO")
+	sets.mlogger.log("For each operation click 'Confirm' on Trezor "
+		"to give permission.", logging.INFO, "Trezor IO")
+
+	fileMap = FileMap(trezor, sets)
+
+	if ((sets.PArg is None) or (len(sets.inputFiles) <= 0)) and (not sets.TArg):
+		# something was not specified, so we call the GUI
+		# or user wants GUI, so we call the GUI
+		dialog.setFileMap(fileMap)
+		dialog.setVersion(basics.VERSION_STR)
+		showGui(trezor, dialog, sets)
+	else:
+		useTerminal(fileMap, sets)
+	# cleanup
+	sets.mlogger.log("Cleaning up before shutting down.", logging.DEBUG, "Info")
+	trezor.close()
+
+
+if __name__ == '__main__':
+	main()