Bump version: 0.14.3 → 0.14.4

https://dev.gnupg.org/rG40da61b89b62dcb77847dc79eb159e885f52f817#change-o4DEJvEV1Dx2

Also, refactor decoding and add a few tests.

.bumpversion.cfg

@@ -0,0 +1,6 @@
+[bumpversion]
+commit = True
+tag = True
+current_version = 0.14.4
+
+[bumpversion:file:setup.py]

.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.6', '3.7', '3.8', '3.9', '3.10']
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip tox
+      - name: Build and test
+        run: |
+          tox

.pylintrc

@@ -1,2 +1,4 @@
 [MESSAGES CONTROL]
-disable=invalid-name, missing-docstring, locally-disabled, unbalanced-tuple-unpacking,no-else-return
+disable=invalid-name, missing-docstring, locally-disabled, unbalanced-tuple-unpacking,no-else-return,fixme,duplicate-code,cyclic-import,import-outside-toplevel,consider-using-with,consider-using-f-string,unspecified-encoding
+[SIMILARITIES]
+min-similarity-lines=5

.travis.yml

@@ -1,27 +0,0 @@
-sudo: false
-language: python
-python:
-  - "2.7"
-  - "3.4"
-  - "3.5"
-  - "3.6"
-
-cache:
-  directories:
-    - $HOME/.cache/pip
-
-before_install:
-  - pip install -U setuptools pylint coverage pep8 pydocstyle "pip>=7.0" wheel
-
-install:
-  - pip install -e .
-
-script:
-  - pep8 libagent
-  - pylint --reports=no --rcfile .pylintrc libagent
-  - pydocstyle libagent
-  - coverage run --source libagent/ -m py.test -v
-
-after_success:
-  - coverage report
-

INSTALL.md

@@ -1,70 +0,0 @@
-# Installation
-
-Install the following packages (depending on your distribution):
-
-### Debian
-
-    $ apt update && apt upgrade
-    $ apt install python-pip python-dev libusb-1.0-0-dev libudev-dev
-
-### Fedora/RedHat
-
-    $ yum update
-    $ yum install python-pip python-devel libusb-devel libudev-devel \
-                  gcc redhat-rpm-config
-
-Also, update Python packages before starting the installation:
-
-    $ pip install -U setuptools pip
-
-Make sure you are running the latest firmware version on your hardware device.
-Currently the following firmware versions are supported:
-
- * [TREZOR](https://wallet.trezor.io/data/firmware/releases.json): `1.4.2+`
- * [KeepKey](https://github.com/keepkey/keepkey-firmware/releases): `3.0.17+`
- * [Ledger Nano S](https://github.com/LedgerHQ/blue-app-ssh-agent): `0.0.3+` (install [SSH/PGP Agent](https://www.ledgerwallet.com/images/apps/chrome-mngr-apps.png) app)
-
-## TREZOR
-
-Make sure that your `udev` rules are configured [correctly](https://doc.satoshilabs.com/trezor-user/settingupchromeonlinux.html#manual-configuration-of-udev-rules).
-Then, install the latest [trezor_agent](https://pypi.python.org/pypi/trezor_agent) package:
-
-    $ pip install trezor_agent
-
-Or, directly from the latest source code:
-
-    $ git clone https://github.com/romanz/trezor-agent
-    $ pip install --user -e trezor-agent/agents/trezor
-
-## KeepKey
-
-Make sure that your `udev` rules are configured [correctly](https://support.keepkey.com/support/solutions/articles/6000037796-keepkey-wallet-is-not-being-recognized-by-linux).
-Then, install the latest [keepkey_agent](https://pypi.python.org/pypi/keepkey_agent) package:
-
-    $ pip install keepkey_agent
-
-Or, directly from the latest source code:
-
-    $ git clone https://github.com/romanz/trezor-agent
-    $ pip install --user -e trezor-agent/agents/keepkey
-
-## Ledger Nano S
-
-Make sure that your `udev` rules are configured [correctly](http://support.ledgerwallet.com/knowledge_base/topics/ledger-wallet-is-not-recognized-on-linux).
-Then, install the latest [ledger_agent](https://pypi.python.org/pypi/ledger_agent) package:
-
-    $ pip install ledger_agent
-
-Or, directly from the latest source code:
-
-    $ git clone https://github.com/romanz/trezor-agent
-    $ pip install --user -e trezor-agent/agents/ledger
-
-## Troubleshooting
-
-If there is an import problem with the installed `protobuf` package,
-see [this issue](https://github.com/romanz/trezor-agent/issues/28) for fixing it.
-
-If you can't find the command-line utilities (after running `pip install --user`),
-please make sure that `~/.local/bin` is on your `PATH` variable
-(see a [relevant](https://github.com/pypa/pip/issues/3813) issue).

README-GPG.md

@@ -1,102 +0,0 @@
-Note: the GPG-related code is still under development, so please try the current implementation
-and please let me [know](https://github.com/romanz/trezor-agent/issues/new) if something doesn't
-work well for you. If possible:
-
- * record the session (e.g. using [asciinema](asciinema.org))
- * attach the GPG agent log from `~/.gnupg/{trezor,ledger}/gpg-agent.log`
-
-Thanks!
-
-# Installation
-
-First, verify that you have GPG 2.1.11+ installed
-([Debian](https://gist.github.com/vt0r/a2f8c0bcb1400131ff51),
-[macOS](https://sourceforge.net/p/gpgosx/docu/Download/)):
-
-```
-$ gpg2 --version | head -n1
-gpg (GnuPG) 2.1.15
-```
-
-This GPG version is included in [Ubuntu 16.04](https://launchpad.net/ubuntu/+source/gnupg2)
-and [Linux Mint 18](https://community.linuxmint.com/software/view/gnupg2).
-
-Update you device firmware to the latest version and install your specific `agent` package:
-
-```
-$ pip install --user (trezor|keepkey|ledger)_agent
-```
-
-# Quickstart
-
-## Identity creation
-[![asciicast](https://asciinema.org/a/90416.png)](https://asciinema.org/a/90416)
-
-In order to use specific device type for GPG indentity creation, use either command:
-```
-$ DEVICE=(trezor,ledger) ./scripts/gpg-init "John Doe <john@doe.bit>"
-```
-
-## Sample usage (signature and decryption)
-[![asciicast](https://asciinema.org/a/120441.png)](https://asciinema.org/a/120441)
-
-In order to use specific device type for GPG operations, set the following environment variable to either:
-```
-$ export GNUPGHOME=~/.gnupg/{trezor,ledger}
-```
-
-You can use GNU Privacy Assistant (GPA) in order to inspect the created keys
-and perform signature and decryption operations using:
-
-```
-$ sudo apt install gpa
-$ GNUPGHOME=~/.gnupg/trezor gpa
-```
-[![GPA](https://cloud.githubusercontent.com/assets/9900/20224804/053d7474-a849-11e6-87f3-ab07dc536158.png)](https://www.gnupg.org/related_software/swlist.html#gpa)
-
-## Git commit & tag signatures:
-Git can use GPG to sign and verify commits and tags (see [here](https://git-scm.com/book/en/v2/Git-Tools-Signing-Your-Work)):
-```
-$ git config --local commit.gpgsign 1
-$ git config --local gpg.program $(which gpg2)
-$ git commit --gpg-sign                      # create GPG-signed commit
-$ git log --show-signature -1                # verify commit signature
-$ git tag v1.2.3 --sign                      # create GPG-signed tag
-$ git tag v1.2.3 --verify                    # verify tag signature
-```
-
-## Password manager
-
-First install `pass` from [passwordstore.org](https://www.passwordstore.org/) and initialize it to use your TREZOR-based GPG identity:
-```
-$ export GNUPGHOME=~/.gnupg/trezor
-$ pass init "Roman Zeyde <roman.zeyde@gmail.com>"
-Password store initialized for Roman Zeyde <roman.zeyde@gmail.com>
-```
-Then, you can generate truly random passwords and save them encrypted using your public key (as separate `.gpg` files under `~/.password-store/`):
-```
-$ pass generate Dev/github 32
-$ pass generate Social/hackernews 32
-$ pass generate Social/twitter 32
-$ pass generate VPS/linode 32
-$ pass
-Password Store
-├── Dev
-│   └── github
-├── Social
-│   ├── hackernews
-│   └── twitter
-└── VPS
-    └── linode
-```
-In order to paste them into the browser, you'd need to decrypt the password using your hardware device:
-```
-$ pass --clip VPS/linode
-Copied VPS/linode to clipboard. Will clear in 45 seconds.
-```
-
-You can also use the following [Qt-based UI](https://qtpass.org/) for `pass`:
-```
-$ sudo apt install qtpass
-$ GNUPGHOME=~/.gnupg/trezor qtpass
-```

README-SSH.md

@@ -1,87 +0,0 @@
-# Screencast demo usage
-
-## Simple usage (single SSH session)
-[![Demo](https://asciinema.org/a/22959.png)](https://asciinema.org/a/22959)
-
-## Advanced usage (multiple SSH sessions from a sub-shell)
-[![Subshell](https://asciinema.org/a/33240.png)](https://asciinema.org/a/33240)
-
-## Using for GitHub SSH authentication (via `trezor-git` utility)
-[![GitHub](https://asciinema.org/a/38337.png)](https://asciinema.org/a/38337)
-
-## Loading multiple SSH identities from configuration file
-[![Config](https://asciinema.org/a/bdxxtgctk5syu56yfz8lcp7ny.png)](https://asciinema.org/a/bdxxtgctk5syu56yfz8lcp7ny)
-
-# Public key generation
-
-Run:
-
-	/tmp $ trezor-agent user@ssh.hostname.com -v > hostname.pub
-	2015-09-02 15:03:18,929 INFO         getting "ssh://user@ssh.hostname.com" public key from Trezor...
-	2015-09-02 15:03:23,342 INFO         disconnected from Trezor
-	/tmp $ cat hostname.pub
-	ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBGSevcDwmT+QaZPUEWUUjTeZRBICChxMKuJ7dRpBSF8+qt+8S1GBK5Zj8Xicc8SHG/SE/EXKUL2UU3kcUzE7ADQ= ssh://user@ssh.hostname.com
-
-Append `hostname.pub` contents to `/home/user/.ssh/authorized_keys`
-configuration file at `ssh.hostname.com`, so the remote server
-would allow you to login using the corresponding private key signature.
-
-# Usage
-
-Run:
-
-	/tmp $ trezor-agent user@ssh.hostname.com -v -c
-	2015-09-02 15:09:39,782 INFO         getting "ssh://user@ssh.hostname.com" public key from Trezor...
-	2015-09-02 15:09:44,430 INFO         please confirm user "roman" login to "ssh://user@ssh.hostname.com" using Trezor...
-	2015-09-02 15:09:46,152 INFO         signature status: OK
-	Linux lmde 3.16.0-4-amd64 #1 SMP Debian 3.16.7-ckt11-1+deb8u3 (2015-08-04) x86_64
-
-	The programs included with the Debian GNU/Linux system are free software;
-	the exact distribution terms for each program are described in the
-	individual files in /usr/share/doc/*/copyright.
-
-	Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
-	permitted by applicable law.
-	Last login: Tue Sep  1 15:57:05 2015 from localhost
-	~ $
-
-Make sure to confirm SSH signature on the Trezor device when requested.
-
-## Accessing remote Git/Mercurial repositories
-
-Use your SSH public key to access your remote repository (e.g. [GitHub](https://help.github.com/articles/adding-a-new-ssh-key-to-your-github-account/)):
-
-	$ trezor-agent -v -e ed25519 git@github.com | xclip
-
-Use the following Bash alias for convinient Git operations:
-
-	$ alias git_hub='trezor-agent -v -e ed25519 git@github.com -- git'
-
-Replace `git` with `git_hub` for remote operations:
-
-	$ git_hub push origin master
-
-The same works for Mercurial (e.g. on [BitBucket](https://confluence.atlassian.com/bitbucket/set-up-ssh-for-mercurial-728138122.html)):
-
-	$ trezor-agent -v -e ed25519 git@bitbucket.org -- hg push
-
-
-# Troubleshooting
-
-If SSH connection fails to work, please open an [issue](https://github.com/romanz/trezor-agent/issues)
-with a verbose log attached (by running `trezor-agent -vv`) .
-
-## Incompatible SSH options
-
-Note that your local SSH configuration may ignore `trezor-agent`, if it has `IdentitiesOnly` option set to `yes`.
-
-     IdentitiesOnly
-             Specifies that ssh(1) should only use the authentication identity files configured in
-             the ssh_config files, even if ssh-agent(1) or a PKCS11Provider offers more identities.
-             The argument to this keyword must be “yes” or “no”.
-             This option is intended for situations where ssh-agent offers many different identities.
-             The default is “no”.
-
-If you are failing to connect, try running:
-
-    $ trezor-agent -vv user@host -- ssh -vv -oIdentitiesOnly=no user@host

README.md

@@ -1,25 +1,42 @@
-# Using TREZOR as a hardware SSH/GPG agent
+# Hardware-based SSH/GPG agent
 
-[![Build Status](https://travis-ci.org/romanz/trezor-agent.svg?branch=master)](https://travis-ci.org/romanz/trezor-agent)
+[![Build](https://github.com/romanz/trezor-agent/actions/workflows/ci.yml/badge.svg)](https://github.com/romanz/trezor-agent/actions)
 [![Chat](https://badges.gitter.im/romanz/trezor-agent.svg)](https://gitter.im/romanz/trezor-agent)
 
-See SatoshiLabs' blog posts about this feature:
+This project allows you to use various hardware security devices to operate GPG and SSH.  Instead of keeping your key on your computer and decrypting it with a passphrase when you want to use it, the key is generated and stored on the device and never reaches your computer.  Read more about the design [here](doc/DESIGN.md).
+
+You can do things like sign your emails, git commits, and software packages, manage your passwords (with [pass](https://www.passwordstore.org/) and [gopass](https://www.justwatch.com/gopass/), among others), authenticate web tunnels and file transfers, and more.
+
+See the following blog posts about this tool:
 
 - [TREZOR Firmware 1.3.4 enables SSH login](https://medium.com/@satoshilabs/trezor-firmware-1-3-4-enables-ssh-login-86a622d7e609)
 - [TREZOR Firmware 1.3.6 — GPG Signing, SSH Login Updates and Advanced Transaction Features for Segwit](https://medium.com/@satoshilabs/trezor-firmware-1-3-6-20a7df6e692)
 - [TREZOR Firmware 1.4.0 — GPG decryption support](https://www.reddit.com/r/TREZOR/comments/50h8r9/new_trezor_firmware_fidou2f_and_initial_ethereum/d7420q7/)
+- [A Step by Step Guide to Securing your SSH Keys with the Ledger Nano S](https://thoughts.t37.net/a-step-by-step-guide-to-securing-your-ssh-keys-with-the-ledger-nano-s-92e58c64a005)
 
-## Installation
+Currently [TREZOR One](https://trezor.io/), [TREZOR Model T](https://trezor.io/), [Keepkey](https://www.keepkey.com/), [Ledger Nano S](https://www.ledgerwallet.com/products/ledger-nano-s), and [OnlyKey](https://onlykey.io) are supported.
 
-See the [following instructions](INSTALL.md) for the
-[TREZOR](https://trezor.io/), [Keepkey](https://www.keepkey.com/) and
-[Ledger Nano S](https://www.ledgerwallet.com/products/ledger-nano-s) devices.
+## Components
 
-## Usage
+This repository contains source code for one library as well as
+agents to interact with several different hardware devices:
 
-For SSH, see the [following instructions](README-SSH.md) (for Windows support,
-see [trezor-ssh-agent](https://github.com/martin-lizner/trezor-ssh-agent) project by Martin Lízner).
+* [`libagent`](https://pypi.org/project/libagent/): shared library
+* [`trezor-agent`](https://pypi.org/project/trezor-agent/): Using Trezor as hardware-based SSH/PGP agent
+* [`ledger_agent`](https://pypi.org/project/ledger_agent/): Using Ledger as hardware-based SSH/PGP agent
+* [`keepkey_agent`](https://pypi.org/project/keepkey_agent/): Using KeepKey as hardware-based SSH/PGP agent
+* [`onlykey-agent`](https://pypi.org/project/onlykey-agent/): Using OnlyKey as hardware-based SSH/PGP agent
 
-For GPG, see the [following instructions](README-GPG.md).
 
-See [here](https://github.com/romanz/python-trezor#pin-entering) for PIN entering instructions.
+The [/releases](/releases) page on Github contains the `libagent`
+releases.
+
+## Documentation
+
+* **Installation** instructions are [here](doc/INSTALL.md)
+* **SSH** instructions and common use cases are [here](doc/README-SSH.md)
+
+    Note: If you're using Windows, see [trezor-ssh-agent](https://github.com/martin-lizner/trezor-ssh-agent) by Martin Lízner.
+
+* **GPG** instructions and common use cases are [here](doc/README-GPG.md)
+* Instructions to configure a Trezor-style **PIN entry** program are [here](doc/README-PINENTRY.md)

agents/onlykey/onlykey_agent.py

@@ -0,0 +1,7 @@
+import libagent.gpg
+import libagent.ssh
+from libagent.device.onlykey import OnlyKey as DeviceType
+
+ssh_agent = lambda: libagent.ssh.main(DeviceType)
+gpg_tool = lambda: libagent.gpg.main(DeviceType)
+gpg_agent = lambda: libagent.gpg.run_agent(DeviceType)

agents/onlykey/setup.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+from setuptools import setup
+
+setup(
+    name='onlykey-agent',
+    version='1.2.0',
+    description='Using onlykey as hardware SSH/GPG agent',
+    author='CryptoTrust',
+    author_email='t@crp.to',
+    url='http://github.com/trustcrypto/onlykey-agent',
+    scripts=['onlykey_agent.py'],
+    install_requires=[
+        'libagent>=0.14.2',
+        'onlykey>=1.2.0'
+    ],
+    platforms=['POSIX'],
+    classifiers=[
+        'Environment :: Console',
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Information Technology',
+        'Intended Audience :: System Administrators',
+        'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
+        'Operating System :: POSIX',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        'Topic :: System :: Networking',
+        'Topic :: Communications',
+        'Topic :: Security',
+        'Topic :: Utilities',
+    ],
+    entry_points={'console_scripts': [
+        'onlykey-agent = onlykey_agent:ssh_agent',
+        'onlykey-gpg = onlykey_agent:gpg_tool',
+        'onlykey-gpg-agent = onlykey_agent:gpg_agent',
+    ]},
+)

agents/trezor/setup.py

@@ -3,15 +3,15 @@ from setuptools import setup
 
 setup(
     name='trezor_agent',
-    version='0.9.0',
+    version='0.11.0',
     description='Using Trezor as hardware SSH/GPG agent',
     author='Roman Zeyde',
     author_email='roman.zeyde@gmail.com',
     url='http://github.com/romanz/trezor-agent',
     scripts=['trezor_agent.py'],
     install_requires=[
-        'libagent>=0.9.0',
-        'trezor>=0.7.6'
+        'libagent>=0.14.0',
+        'trezor[hidapi]>=0.12.0,<0.13'
     ],
     platforms=['POSIX'],
     classifiers=[
@@ -22,10 +22,10 @@ setup(
         'Intended Audience :: System Administrators',
         'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
         'Operating System :: POSIX',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3.4',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
         'Topic :: Software Development :: Libraries :: Python Modules',
         'Topic :: System :: Networking',
         'Topic :: Communications',
@@ -36,5 +36,6 @@ setup(
         'trezor-agent = trezor_agent:ssh_agent',
         'trezor-gpg = trezor_agent:gpg_tool',
         'trezor-gpg-agent = trezor_agent:gpg_agent',
+        'trezor-signify = trezor_agent:signify_tool',
     ]},
 )

agents/trezor/trezor_agent.py

@@ -1,7 +1,7 @@
-import libagent.gpg
-import libagent.ssh
+from libagent import signify, gpg, ssh
 from libagent.device.trezor import Trezor as DeviceType
 
-ssh_agent = lambda: libagent.ssh.main(DeviceType)
-gpg_tool = lambda: libagent.gpg.main(DeviceType)
-gpg_agent = lambda: libagent.gpg.run_agent(DeviceType)
+ssh_agent = lambda: ssh.main(DeviceType)
+gpg_tool = lambda: gpg.main(DeviceType)
+gpg_agent = lambda: gpg.run_agent(DeviceType)
+signify_tool = lambda: signify.main(DeviceType)

contrib/neopg-trezor

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+import os
+import sys
+
+agent = 'trezor-gpg-agent'
+binary = 'neopg'
+
+if sys.argv[1:2] == ['agent']:
+    os.execvp(agent, [agent, '-vv'] + sys.argv[2:])
+else:
+    # HACK: pass this script's path as argv[0], so it will be invoked again
+    # when NeoPG tries to run its own agent:
+    # https://github.com/das-labor/neopg/blob/1fe50460abe01febb118641e37aa50bc429a1786/src/neopg.cpp#L114
+    # https://github.com/das-labor/neopg/blob/1fe50460abe01febb118641e37aa50bc429a1786/legacy/gnupg/common/asshelp.cpp#L217
+    os.execvp(binary, [__file__, 'gpg2'] + sys.argv[1:])

doc/DESIGN.md

@@ -0,0 +1,51 @@
+# Design
+
+Most cryptographic tools (such as gpg, ssh and openssl) allow the offloading of some key cryptographic steps to *engines* or *agents*. This is to allow sensitive operations, such as asking for a password or doing the actual encryption step, to be kept separate from the larger body of code. This makes it easier to secure those steps, move them onto hardware or easier to audit.
+
+SSH and GPG do this by means of a simple interprocess communication protocol (usually a unix domain socket) and an agent (`ssh-agent`) or GPG key daemon (`gpg-agent`).  The `trezor-agent` mimics these two protocols.
+
+These two agents make the connection between the front end (e.g. a `gpg --sign` command, or an `ssh user@fqdn`). And then they wait for a request from the 'front end', and then do the actual asking for a password and subsequent using the private key to sign or decrypt something.
+
+The various hardware wallets (Trezor, KeepKey and Ledger) each have the ability (as of Firmware 1.3.4) to use the NIST P-256 elliptic curve to sign, encrypt or decrypt. This curve can be used with S/MIME, GPG and SSH.
+
+So when you `ssh` to a machine - rather than consult the normal ssh-agent (which in turn will use your private SSH key in files such as `~/.ssh/id_rsa`) -- the trezor-agent will aks your hardware wallet to use its private key to sign the challenge.
+
+## Key Naming
+
+`trezor-agent` goes to great length to avoid using the valuable parent key.
+
+The rationale behind this is that `trezor-agent` is to some extent condemned to *blindly* signing any NONCE given to it (e.g. as part of a challenge respone, or as the hash/hmac of someting to sign).
+
+And doing so with the master private key is risky - as rogue (ssh) server could possibly provide a doctored NONCE that happens to be tied to a transaction or something else.
+
+It therefore uses only derived child keys pairs instead (according to the [BIP-0032: Hierarchical Deterministic Wallets][1] system) - and ones on different leafs. So the parent key is only used within the device for creating the child keys - and not exposed in any way to `trezor-agent`.
+
+### SSH
+
+It is common for SSH users to use one (or a few) private keys with SSH on all servers they log into. The `trezor-agent` is slightly more cautious and derives a child key that is *unique* to the server and username you are logging into from your master private key on the device.
+
+So taking a commmand such as:
+
+	$ trezor-agent -c user@fqdn.com
+
+The `trezor-agent` will take the `user`@`fqdn.com`; canonicalise it (e.g. to add the ssh default port number if none was specified) and then apply some simple hashing (See [SLIP-0013 : Authentication using deterministic hierarchy][2]). The resulting 128bit hash is then used to construct a lead 'HD node' that contains an extened public private *child* key.
+
+This way they keypair is specific to the server/hostname/port and protocol combination used. And it is this private key that is used to sign the nonce passed by the SSH server (as opposed to the master key).
+
+The `trezor-agent` then instructs SSH to connect to the server. It will then engage in the normal challenge response process, ask the hardware wallet to blindly sign any nonce flashed by the server with the derived child private key and return this to the server. It then hands over to normal SSH for the rest of the logged in session.
+
+### GPG
+
+GPG uses much the same approach as SSH, except in this case it relies on [SLIP-0017 : ECDH using deterministic hierarchy][3] for the mapping to an ECDH key and it maps these to the normal GPG child key infrastructure.
+
+Note: Keepkey does not support en-/de-cryption at this time.
+
+### Index
+
+The canonicalisation process ([SLIP-0013][2] and [SLIP-0017][3]) of an email address or ssh address allows for the mixing in of an extra 'index' - a unsigned 32 bit number. This allows one to have multiple, different keys, for the same address.
+
+This feature is currently not used -- it is set to '0'. This may change in the future.
+
+[1]: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+[2]: https://github.com/satoshilabs/slips/blob/master/slip-0013.md
+[3]: https://github.com/satoshilabs/slips/blob/master/slip-0017.md

doc/INSTALL.md

@@ -0,0 +1,164 @@
+# Installation
+
+## 1. Prerequisites
+
+Install the following packages (depending on your distribution):
+
+### OS dependencies
+
+This software needs Python, libusb, and libudev along with development files.
+
+You can install them on these distributions as follows:
+
+##### Debian
+
+    $ apt-get install python3-pip python3-dev python3-tk libusb-1.0-0-dev libudev-dev
+
+##### RedHat
+
+    $ yum install python3-pip python3-devel python3-tk libusb-devel libudev-devel \
+                  gcc redhat-rpm-config
+
+##### Fedora
+
+    $ dnf install python3-pip python3-devel python3-tkinter libusb-devel libudev-devel \
+                  gcc redhat-rpm-config
+
+##### OpenSUSE
+
+    $ zypper install python-pip python-devel python-tk libusb-1_0-devel libudev-devel
+
+If you are using python3 or your system `pip` command points to `pip3.x`
+(`/etc/alternatives/pip -> /usr/bin/pip3.6`) you will need to install these
+dependencies instead:
+
+    $ zypper install python3-pip python3-devel python3-tk libusb-1_0-devel libudev-devel
+
+##### macOS
+
+There are many different options to install python environment on macOS ([official](https://www.python.org/downloads/mac-osx/), [anaconda](https://conda.io/docs/user-guide/install/macos.html), ..). Most importantly you need `libusb`. Probably the easiest way is via [homebrew](https://brew.sh/)
+
+    $ brew install libusb
+
+### GPG
+
+If you intend to use GPG make sure you have GPG installed and up to date.  This software requires a GPG version >= 2.1.11.
+
+You can verify your installed version by running:
+```
+$ gpg2 --version | head -n1
+gpg (GnuPG) 2.1.15
+```
+
+ * Follow this installation guide for [Debian](https://gist.github.com/vt0r/a2f8c0bcb1400131ff51)
+ * Install GPG for [macOS](https://sourceforge.net/p/gpgosx/docu/Download/)
+ * Install packages for Ubuntu 16.04 [here](https://launchpad.net/ubuntu/+source/gnupg2)
+ * Install packages for Linux Mint 18 [here](https://community.linuxmint.com/software/view/gnupg2)
+
+# 2. Install the TREZOR agent
+
+1. Make sure you are running the latest firmware version on your Trezor:
+
+ * [TREZOR firmware releases](https://wallet.trezor.io/data/firmware/releases.json): `1.4.2+`
+
+2. Make sure that your `udev` rules are configured [correctly](https://wiki.trezor.io/Udev_rules).
+
+3. Then, install the latest [trezor_agent](https://pypi.python.org/pypi/trezor_agent) package:
+
+    ```
+    $ pip3 install Cython hidapi
+    $ pip3 install trezor_agent
+    ```
+
+    Or, directly from the latest source code:
+
+    ```
+    $ git clone https://github.com/romanz/trezor-agent
+    $ pip3 install --user -e trezor-agent
+    $ pip3 install --user -e trezor-agent/agents/trezor
+    ```
+
+    Or, through Homebrew on macOS:
+
+    ```
+    $ brew install trezor-agent
+    ```
+
+# 3. Install the KeepKey agent
+
+1. Make sure you are running the latest firmware version on your KeepKey:
+
+ * [KeepKey firmware releases](https://github.com/keepkey/keepkey-firmware/releases): `3.0.17+`
+
+2. Make sure that your `udev` rules are configured [correctly](https://support.keepkey.com/support/solutions/articles/6000037796-keepkey-wallet-is-not-being-recognized-by-linux).
+Then, install the latest [keepkey_agent](https://pypi.python.org/pypi/keepkey_agent) package:
+
+    ```
+    $ pip3 install keepkey_agent
+    ```
+
+    Or, on Mac using Homebrew:
+
+    ```
+    $ homebrew install keepkey-agent
+    ```
+
+    Or, directly from the latest source code:
+
+    ```
+    $ git clone https://github.com/romanz/trezor-agent
+    $ pip3 install --user -e trezor-agent/agents/keepkey
+    ```
+
+# 4. Install the Ledger Nano S agent
+
+1. Make sure you are running the latest firmware version on your Ledger Nano S:
+
+ * [Ledger Nano S firmware releases](https://github.com/LedgerHQ/blue-app-ssh-agent): `0.0.3+` (install [SSH/PGP Agent](https://www.ledgerwallet.com/images/apps/chrome-mngr-apps.png) app)
+
+2. Make sure that your `udev` rules are configured [correctly](https://ledger.zendesk.com/hc/en-us/articles/115005165269-What-if-Ledger-Wallet-is-not-recognized-on-Linux-).
+3. Then, install the latest [ledger_agent](https://pypi.python.org/pypi/ledger_agent) package:
+
+    ```
+    $ pip3 install ledger_agent
+    ```
+
+    Or, directly from the latest source code:
+
+    ```
+    $ git clone https://github.com/romanz/trezor-agent
+    $ pip3 install --user -e trezor-agent
+    $ pip3 install --user -e trezor-agent/agents/ledger
+    ```
+
+# 5. Install the OnlyKey agent
+
+1. Make sure you are running the latest firmware version on your OnlyKey:
+
+ * [OnlyKey Firmware Upgrade Guide](https://docs.crp.to/upgradeguide.html)
+
+2. Make sure that your `udev` rules are configured [correctly](https://docs.crp.to/linux.html#udev-rule).
+3. Then, install the latest [onlykey-agent](https://pypi.python.org/pypi/onlykey-agent) package:
+
+    ```
+    $ pip3 install onlykey-agent
+    ```
+
+    Or, directly from the latest source code:
+
+    ```
+    $ git clone https://github.com/romanz/trezor-agent
+    $ pip3 install --user -e trezor-agent
+    $ pip3 install --user -e trezor-agent/agents/onlykey
+    ```
+
+# 6. Installation Troubleshooting
+
+If there is an import problem with the installed `protobuf` package,
+see [this issue](https://github.com/romanz/trezor-agent/issues/28) for fixing it.
+
+If you can't find the command-line utilities (after running `pip install --user`),
+please make sure that `~/.local/bin` is on your `PATH` variable
+(see a [relevant](https://github.com/pypa/pip/issues/3813) issue).
+
+If you can't find command-line utilities and are on macOS/OSX check `~/Library/Python/2.7/bin` and add to `PATH` if necessary (see a [relevant](https://github.com/romanz/trezor-agent/issues/155) issue).

doc/README-GPG.md

@@ -0,0 +1,251 @@
+# GPG Agent
+
+Note: the GPG-related code is still under development, so please try the current implementation
+and please let me [know](https://github.com/romanz/trezor-agent/issues/new) if something doesn't
+work well for you. If possible:
+
+ * record the session (e.g. using [asciinema](https://asciinema.org))
+ * attach the GPG agent log from `~/.gnupg/{trezor,ledger}/gpg-agent.log` (can be [encrypted](https://keybase.io/romanz))
+
+Thanks!
+
+## 1. Configuration
+
+1. Initialize the agent GPG directory.
+
+    [![asciicast](https://asciinema.org/a/3iNw2L9QWB8R3EVdYdAxMOLK8.png)](https://asciinema.org/a/3iNw2L9QWB8R3EVdYdAxMOLK8)
+
+    Run
+
+    ```
+    $ (trezor|keepkey|ledger|onlykey)-gpg init "Roman Zeyde <roman.zeyde@gmail.com>"
+    ```
+
+    Follow the instructions provided to complete the setup.  Keep note of the timestamp value which you'll need if you want to regenerate the key later.
+
+    If you'd like a Trezor-style PIN entry program, follow [these instructions](README-PINENTRY.md).
+
+2. Add `export GNUPGHOME=~/.gnupg/(trezor|keepkey|ledger|onlykey)` to your `.bashrc` or other environment file.
+
+    This `GNUPGHOME` contains your hardware keyring and agent settings.  This agent software assumes all keys are backed by hardware devices so you can't use standard GPG keys in `GNUPGHOME` (if you do mix keys you'll receive an error when you attempt to use them).
+
+    If you wish to switch back to your software keys unset `GNUPGHOME`.
+
+3. Log out and back into your session to ensure your environment is updated everywhere.
+
+## 2. Usage
+
+You can use any GPG commands or software that uses GPG as usual and will be prompted to interact with your hardware device as necessary.  The agent is automatically started if it isn't running when you run any `gpg` command.
+
+##### Restarting the agent
+
+If you change settings or need to restart the agent for some other reason, simply kill it.  It will restart the next time GPG is invoked.
+
+## 3. Common Use Cases
+
+### Sign and decrypt files
+
+[![asciicast](https://asciinema.org/a/120441.png)](https://asciinema.org/a/120441)
+
+### Inspect GPG keys
+You can use GNU Privacy Assistant (GPA) in order to inspect the created keys and perform signature and decryption operations as usual:
+
+```
+$ sudo apt install gpa
+$ gpa
+```
+
+[![GPA](https://cloud.githubusercontent.com/assets/9900/20224804/053d7474-a849-11e6-87f3-ab07dc536158.png)](https://www.gnupg.org/related_software/swlist.html#gpa)
+
+### Sign Git commits and tags
+
+Git can use GPG to sign and verify commits and tags (see [here](https://git-scm.com/book/en/v2/Git-Tools-Signing-Your-Work)):
+
+```
+$ git config --local commit.gpgsign 1
+$ git config --local gpg.program $(which gpg2)
+$ git commit --gpg-sign                      # create GPG-signed commit
+$ git log --show-signature -1                # verify commit signature
+$ git tag v1.2.3 --sign                      # create GPG-signed tag
+$ git tag v1.2.3 --verify                    # verify tag signature
+```
+
+Note that your git email has to correlate to your gpg key email. If you use a different email for git, you'll need to either generate a new gpg key for that email or set your git email using the command:
+
+````
+$ git config  user.email foo@example.com
+````
+
+If your git email is configured incorrectly, you will receive the error:
+
+````
+error: gpg failed to sign the data
+fatal: failed to write commit object
+````
+
+when committing to git.
+
+### Manage passwords
+
+Password managers such as [pass](https://www.passwordstore.org/) and [gopass](https://www.justwatch.com/gopass/) rely on GPG for encryption so you can use your device with them too.
+
+##### With `pass`:
+
+First install `pass` from [passwordstore.org] and initialize it to use your TREZOR-based GPG identity:
+```
+$ pass init "Roman Zeyde <roman.zeyde@gmail.com>"
+Password store initialized for Roman Zeyde <roman.zeyde@gmail.com>
+```
+Then, you can generate truly random passwords and save them encrypted using your public key (as separate `.gpg` files under `~/.password-store/`):
+```
+$ pass generate Dev/github 32
+$ pass generate Social/hackernews 32
+$ pass generate Social/twitter 32
+$ pass generate VPS/linode 32
+$ pass
+Password Store
+├── Dev
+│   └── github
+├── Social
+│   ├── hackernews
+│   └── twitter
+└── VPS
+    └── linode
+```
+In order to paste them into the browser, you'd need to decrypt the password using your hardware device:
+```
+$ pass --clip VPS/linode
+Copied VPS/linode to clipboard. Will clear in 45 seconds.
+```
+
+You can also use the following [Qt-based UI](https://qtpass.org/) for `pass`:
+```
+$ sudo apt install qtpass
+```
+
+### Re-generate a GPG identity
+[![asciicast](https://asciinema.org/a/5tIQa5qt5bV134oeOqFyKEU29.png)](https://asciinema.org/a/5tIQa5qt5bV134oeOqFyKEU29)
+
+If you've forgotten the timestamp value, but still have access to the public key, then you can
+retrieve the timestamp with the following command (substitute "john@doe.bit" for the key's address or id):
+
+```
+$ gpg2 --export 'john@doe.bit' | gpg2 --list-packets | grep created | head -n1
+```
+
+### Add new UIDs to your identity
+
+After your main identity is created, you can add new user IDs using the regular GnuPG commands:
+```
+$ trezor-gpg init "Foobar" -vv
+$ export GNUPGHOME=${HOME}/.gnupg/trezor
+$ gpg2 -K
+------------------------------------------
+sec   nistp256/6275E7DA 2017-12-05 [SC]
+uid         [ultimate] Foobar
+ssb   nistp256/35F58F26 2017-12-05 [E]
+
+$ gpg2 --edit Foobar
+gpg> adduid
+Real name: Xyzzy
+Email address:
+Comment:
+You selected this USER-ID:
+    "Xyzzy"
+
+Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
+
+gpg> save
+
+$ gpg2 -K
+------------------------------------------
+sec   nistp256/6275E7DA 2017-12-05 [SC]
+uid         [ultimate] Xyzzy
+uid         [ultimate] Foobar
+ssb   nistp256/35F58F26 2017-12-05 [E]
+```
+
+### Generate GnuPG subkeys
+In order to add TREZOR-based subkey to an existing GnuPG identity, use the `--subkey` flag:
+```
+$ gpg2 -k foobar
+pub   rsa2048/90C4064B 2017-10-10 [SC]
+uid         [ultimate] foobar
+sub   rsa2048/4DD05FF0 2017-10-10 [E]
+
+$ trezor-gpg init "foobar" --subkey
+```
+
+[![asciicast](https://asciinema.org/a/Ick5G724zrZRFsGY7ZUdFSnV1.png)](https://asciinema.org/a/Ick5G724zrZRFsGY7ZUdFSnV1)
+
+In order to enter existing GPG passphrase, I recommend installing and using a graphical Pinentry:
+```
+$ sudo apt install pinentry-gnome3
+$ sudo update-alternatives --config pinentry
+There are 4 choices for the alternative pinentry (providing /usr/bin/pinentry).
+
+  Selection    Path                      Priority   Status
+------------------------------------------------------------
+* 0            /usr/bin/pinentry-gnome3   90        auto mode
+  1            /usr/bin/pinentry-curses   50        manual mode
+  2            /usr/bin/pinentry-gnome3   90        manual mode
+  3            /usr/bin/pinentry-qt       80        manual mode
+  4            /usr/bin/pinentry-tty      30        manual mode
+
+Press <enter> to keep the current choice[*], or type selection number: 0
+```
+
+### Sign and decrypt email
+
+Follow [these instructions](enigmail.md) to set up Enigmail in Thunderbird.
+
+### Start the agent as a systemd unit
+
+##### 1. Create these files in `~/.config/systemd/user`
+
+Replace `trezor` with `keepkey` or `ledger` or `onlykey` as required.
+
+###### `trezor-gpg-agent.service`
+
+````
+[Unit]
+Description=trezor-gpg-agent
+Requires=trezor-gpg-agent.socket
+
+[Service]
+Type=simple
+Environment="GNUPGHOME=%h/.gnupg/trezor"
+Environment="PATH=/bin:/usr/bin:/usr/local/bin:%h/.local/bin"
+ExecStart=/usr/bin/trezor-gpg-agent -vv
+````
+
+If you've installed `trezor-agent` locally you may have to change the path in `ExecStart=`.
+
+###### `trezor-gpg-agent.socket`
+
+````
+[Unit]
+Description=trezor-gpg-agent socket
+
+[Socket]
+ListenStream=%t/gnupg/S.gpg-agent
+FileDescriptorName=std
+SocketMode=0600
+DirectoryMode=0700
+
+[Install]
+WantedBy=sockets.target
+````
+
+##### 2. Stop trezor-gpg-agent if it's already running
+
+```
+killall trezor-gpg-agent
+```
+
+##### 3. Run
+
+```
+systemctl --user start trezor-gpg-agent.service trezor-gpg-agent.socket
+systemctl --user enable trezor-gpg-agent.socket
+```

doc/README-NeoPG.md

@@ -0,0 +1,31 @@
+# NeoPG experimental support
+
+1. Download build and install NeoPG from [source code](https://github.com/das-labor/neopg#installation).
+
+2. Generate Ed25519-based identity (using a [special wrapper](https://github.com/romanz/trezor-agent/blob/c22109df24c6eb8263aa40183a016be3437b1a0c/contrib/neopg-trezor) to invoke TREZOR-based agent):
+
+```bash
+$ export NEOPG_BINARY=$PWD/contrib/neopg-trezor
+$ $NEOPG_BINARY --help
+
+$ export GNUPGHOME=/tmp/homedir
+$ trezor-gpg init "FooBar" -e ed25519
+sec   ed25519 2018-07-01 [SC]
+      802AF7E2DCF4491FFBB2F032341E95EF57CD7D5E
+uid           [ultimate] FooBar
+ssb   cv25519 2018-07-01 [E]
+```
+
+3. Sign and verify signatures:
+```
+$ $NEOPG_BINARY -v --detach-sign FILE
+neopg: starting agent '/home/roman/Code/trezor/trezor-agent/contrib/neopg-trezor'
+neopg: using pgp trust model
+neopg: writing to 'FILE.sig'
+neopg: EDDSA/SHA256 signature from: "341E95EF57CD7D5E FooBar"
+
+$ $NEOPG_BINARY --verify FILE.sig FILE
+neopg: Signature made Sun Jul  1 11:52:51 2018 IDT
+neopg:                using EDDSA key 802AF7E2DCF4491FFBB2F032341E95EF57CD7D5E
+neopg: Good signature from "FooBar" [ultimate]
+```

doc/README-PINENTRY.md

@@ -0,0 +1,69 @@
+# Custom PIN entry
+
+In order to use the default GPG pinentry program, install one of the following Linux packages:
+
+```
+$ apt install pinentry-{curses,gnome3,qt}
+```
+
+or (on macOS):
+
+```
+$ brew install pinentry
+```
+
+By default a standard GPG PIN entry program is used when entering your Trezor PIN, but it's difficult to use if you don't have a numeric keypad or want to use your mouse.
+
+You can specify a custom PIN entry program such as [trezor-gpg-pinentry-tk](https://github.com/rendaw/trezor-gpg-pinentry-tk) (and separately, a passphrase entry program) to match your workflow.
+
+The below examples use `trezor-gpg-pinentry-tk` but any GPG compatible PIN entry can be used.
+
+##### 1. Install the PIN entry
+
+Run
+
+```
+pip install trezor-gpg-pinentry-tk
+```
+
+##### 2. SSH
+
+Add the flag `--pin-entry-binary trezor-gpg-pinentry-tk` to all calls to `trezor-agent`.
+
+To automatically use this flag, add the line `pinentry=trezor-gpg-pinentry-tk` to `~/.ssh/agent.config`.  **Note** this is currently broken due to [this dependency issue](https://github.com/bw2/ConfigArgParse/issues/114).
+
+If you run the SSH agent with Systemd you'll need to add `--pin-entry-binary` to the `ExecStart` command.  You may also need to add this line:
+
+```
+Environment="DISPLAY=:0"
+```
+
+to the `[Service]` section to tell the PIN entry program how to connect to the X11 server.
+
+##### 3. GPG
+
+If you haven't completed initialization yet, run:
+
+```
+$ (trezor|keepkey|ledger)-gpg init --pin-entry-binary trezor-gpg-pinentry-tk "Roman Zeyde <roman.zeyde@gmail.com>"
+```
+
+to configure the PIN entry at the same time.
+
+Otherwise, open `$GNUPGHOME/trezor/run-agent.sh` and change the `--pin-entry-binary` option to `trezor-gpg-pinentry-tk` and run:
+
+```
+killall trezor-gpg-agent
+```
+
+##### 4. Troubleshooting
+
+Any problems running the PIN entry program with GPG should appear in `$HOME/.gnupg/trezor/gpg-agent.log`.
+
+You can get similar logs for SSH by specifying `--log-file` in the SSH command line.
+
+The passphrase is cached by the agent (after its first entry), which needs to be restarted in order to reset the passphrase:
+```
+$ killall trezor-agent  	# (for SSH)
+$ killall trezor-gpg-agent	# (for GPG)
+```

doc/README-SSH.md

@@ -0,0 +1,226 @@
+# SSH Agent
+
+## 1. Configuration
+
+SSH requires no configuration, but you may put common command line options in `~/.ssh/agent.conf` to avoid repeating them in every invocation.
+
+See `(trezor|keepkey|ledger|onlykey)-agent -h` for details on supported options and the configuration file format.
+
+If you'd like a Trezor-style PIN entry program, follow [these instructions](README-PINENTRY.md).
+
+## 2. Usage
+
+Use the `(trezor|keepkey|ledger|onlykey)-agent` program to work with SSH. It has three main modes of operation:
+
+##### 1. Export public keys
+
+To get your public key so you can add it to `authorized_hosts` or allow
+ssh access to a service that supports it, run:
+
+```
+(trezor|keepkey|ledger|onlykey)-agent identity@myhost
+```
+
+The identity (ex: `identity@myhost`) is used to derive the public key and is added as a comment to the exported key string.
+
+##### 2. Run a command with the agent's environment
+
+Run
+
+```
+$ (trezor|keepkey|ledger|onlykey)-agent identity@myhost -- COMMAND --WITH --ARGUMENTS
+```
+
+to start the agent in the background and execute the command with environment variables set up to use the SSH agent.  The specified identity is used for all SSH connections.  The agent will exit after the command completes.
+Note the `--` separator, which is used to separate `trezor-agent`'s arguments from the SSH command arguments.
+
+Example:
+```
+ (trezor|keepkey|ledger|onlykey)-agent -e ed25519 bob@example.com -- rsync up/ bob@example.com:/home/bob
+```
+
+As a shortcut you can run
+
+```
+$ (trezor|keepkey|ledger|onlykey)-agent identity@myhost -s
+```
+
+to start a shell with the proper environment.
+
+##### 3. Connect to a server directly via `(trezor|keepkey|ledger|onlykey)-agent`
+
+If you just want to connect to a server this is the simplest way to do it:
+
+```
+$ (trezor|keepkey|ledger|onlykey)-agent user@remotehost -c
+```
+
+The identity `user@remotehost` is used as both the destination user and host as well as for key derivation, so you must generate a separate key for each host you connect to.
+
+## 3. Common Use Cases
+
+### Start a single SSH session
+[![Demo](https://asciinema.org/a/22959.png)](https://asciinema.org/a/22959)
+
+### Start multiple SSH sessions from a sub-shell
+
+This feature allows using regular SSH-related commands within a subprocess running user's shell.
+`SSH_AUTH_SOCK` environment variable is defined for the subprocess (pointing to the SSH agent, running as a parent process).
+This way the user can use SSH-related commands (e.g. `ssh`, `ssh-add`, `sshfs`, `git`, `hg`), while authenticating via the hardware device.
+
+[![Subshell](https://asciinema.org/a/33240.png)](https://asciinema.org/a/33240)
+
+### Load different SSH identities from configuration file
+
+[![Config](https://asciinema.org/a/bdxxtgctk5syu56yfz8lcp7ny.png)](https://asciinema.org/a/bdxxtgctk5syu56yfz8lcp7ny)
+
+### Implement passwordless login
+
+Run:
+
+	/tmp $ trezor-agent user@ssh.hostname.com -v > hostname.pub
+	2015-09-02 15:03:18,929 INFO         getting "ssh://user@ssh.hostname.com" public key from Trezor...
+	2015-09-02 15:03:23,342 INFO         disconnected from Trezor
+	/tmp $ cat hostname.pub
+	ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBGSevcDwmT+QaZPUEWUUjTeZRBICChxMKuJ7dRpBSF8+qt+8S1GBK5Zj8Xicc8SHG/SE/EXKUL2UU3kcUzE7ADQ= ssh://user@ssh.hostname.com
+
+Append `hostname.pub` contents to `/home/user/.ssh/authorized_keys`
+configuration file at `ssh.hostname.com`, so the remote server
+would allow you to login using the corresponding private key signature.
+
+### Access remote Git/Mercurial repositories
+
+Export your public key and register it in your repository web interface
+(e.g. [GitHub](https://help.github.com/articles/adding-a-new-ssh-key-to-your-github-account/)):
+
+	$ trezor-agent -v -e ed25519 git@github.com > ~/.ssh/github.pub
+
+Add the following configuration to your `~/.ssh/config` file:
+
+	Host github.com
+		IdentityFile ~/.ssh/github.pub
+
+Use the following Bash alias for convenient Git operations:
+
+	$ alias ssh-shell='trezor-agent ~/.ssh/github.pub -v --shell'
+
+Now, you can use regular Git commands under the "SSH-enabled" sub-shell:
+
+	$ ssh-shell
+	$ git push origin master
+
+The same works for Mercurial (e.g. on [BitBucket](https://confluence.atlassian.com/bitbucket/set-up-ssh-for-mercurial-728138122.html)):
+
+	$ ssh-shell
+	$ hg push
+
+### Start the agent as a systemd unit
+
+##### 1. Create these files in `~/.config/systemd/user`
+
+Replace `trezor` with `keepkey` or `ledger` or `onlykey` as required.
+
+###### `trezor-ssh-agent.service`
+
+````
+[Unit]
+Description=trezor-agent SSH agent
+Requires=trezor-ssh-agent.socket
+
+[Service]
+Type=simple
+Restart=always
+Environment="DISPLAY=:0"
+Environment="PATH=/bin:/usr/bin:/usr/local/bin:%h/.local/bin"
+ExecStart=/usr/bin/trezor-agent --foreground --sock-path %t/trezor-agent/S.ssh IDENTITY
+````
+
+If you've installed `trezor-agent` locally you may have to change the path in `ExecStart=`.
+
+Replace `IDENTITY` with the identity you used when exporting the public key.
+
+`IDENTITY` can be a path (starting with `/`) to a file containing a list of public keys
+generated by Trezor. I.e. `/home/myUser/.ssh/trezor.conf` with one public key per line.
+This is a more convenient way to have a systemd setup that has to handle multiple
+keys/hosts.
+
+When updating the file, make sure to restart trezor-agent.
+
+If you have multiple Trezors connected, you can select which one to use via a `TREZOR_PATH`
+environment variable. Use `trezorctl list` to find the correct path. Then add it
+to the agent with the following line:
+````
+Environment="TREZOR_PATH=<your path here>"
+````
+Note that USB paths depend on the _USB port_ which you use.
+
+###### `trezor-ssh-agent.socket`
+
+````
+[Unit]
+Description=trezor-agent SSH agent socket
+
+[Socket]
+ListenStream=%t/trezor-agent/S.ssh
+FileDescriptorName=ssh
+Service=trezor-ssh-agent.service
+SocketMode=0600
+DirectoryMode=0700
+
+[Install]
+WantedBy=sockets.target
+````
+
+##### 2. Run
+
+```
+systemctl --user start trezor-ssh-agent.service trezor-ssh-agent.socket
+systemctl --user enable trezor-ssh-agent.socket
+```
+
+##### 3. Add this line to your `.bashrc` or equivalent file:
+
+```bash
+export SSH_AUTH_SOCK=$(systemctl show --user --property=Listen trezor-ssh-agent.socket | grep -o "/run.*" | cut -d " " -f 1)
+```
+
+Make sure the SSH_AUTH_SOCK variable matches the location of the socket that trezor-agent
+is listening on: `ps -x | grep trezor-agent`. In this setup trezor-agent should start
+automatically when the socket is opened.
+
+##### 4. SSH will now automatically use your device key in all terminals.
+
+## 4. Troubleshooting
+
+If SSH connection fails to work, please open an [issue](https://github.com/romanz/trezor-agent/issues)
+with a verbose log attached (by running `trezor-agent -vv`) .
+
+##### `IdentitiesOnly` SSH option
+
+Note that your local SSH configuration may ignore `trezor-agent`, if it has `IdentitiesOnly` option set to `yes`.
+
+     IdentitiesOnly
+             Specifies that ssh(1) should only use the authentication identity files configured in
+             the ssh_config files, even if ssh-agent(1) or a PKCS11Provider offers more identities.
+             The argument to this keyword must be “yes” or “no”.
+             This option is intended for situations where ssh-agent offers many different identities.
+             The default is “no”.
+
+If you are failing to connect, save your public key using:
+
+	$ trezor-agent -vv foobar@hostname.com > ~/.ssh/hostname.pub
+
+And add the following lines to `~/.ssh/config` (providing the public key explicitly to SSH):
+
+	Host hostname.com
+		User foobar
+		IdentityFile ~/.ssh/hostname.pub
+
+Then, the following commands should successfully command to the remote host:
+
+	$ trezor-agent -v foobar@hostname.com -s
+	$ ssh foobar@hostname.com
+
+or,
+
+	$ trezor-agent -v foobar@hostname.com -c

doc/enigmail.md

@@ -0,0 +1,26 @@
+# Tutorial
+
+First, install [Thunderbird](https://www.mozilla.org/en-US/thunderbird/) and
+the [Enigmail](https://www.enigmail.net/index.php/en/) add-on.
+
+Make sure to use the correct GNUPGHOME path before starting Thunderbird:
+```bash
+$ export GNUPGHOME=${HOME}/.gnupg/trezor
+$ thunderbird
+```
+Run the Enigmail's setup wizard and choose your GPG identity:
+![01](https://user-images.githubusercontent.com/9900/31327339-47a5f69a-acd7-11e7-997c-7b5a286fe5bc.png)
+![02](https://user-images.githubusercontent.com/9900/31327344-51dcd246-acd7-11e7-8cdc-dd305a512dbb.png)
+![03](https://user-images.githubusercontent.com/9900/31327346-546862a0-acd7-11e7-8e00-b40994bd6f17.png)
+
+Then, you can compose encrypted (and signed) messages using the regular UI:
+
+NOTES:
+ - The email's title is **public** - only the body is encrypted.
+ - You will be asked to confirm the signature using the hardware device before sending the email.
+
+![04](https://user-images.githubusercontent.com/9900/31327356-660d098e-acd7-11e7-9e43-762898f5b57e.png)
+![05](https://user-images.githubusercontent.com/9900/31327365-76679dda-acd7-11e7-9403-6965f0c6d8fe.png)
+
+After receiving the email, you will be asked to confirm the decryption the hardware device:
+![06](https://user-images.githubusercontent.com/9900/31327371-7c1da4cc-acd7-11e7-9a5a-20accf621b49.png)

libagent/device/__init__.py

@@ -1,3 +1,3 @@
 """Cryptographic hardware device management."""
 
-from . import interface
+from . import interface, ui

libagent/device/fake_device.py

@@ -5,8 +5,8 @@ import logging
 
 import ecdsa
 
-from . import interface
 from .. import formats
+from . import interface
 
 log = logging.getLogger(__name__)
 
@@ -21,6 +21,11 @@ def _verify_support(identity):
 class FakeDevice(interface.Device):
     """Connection to TREZOR device."""
 
+    @classmethod
+    def package_name(cls):
+        """Python package name."""
+        return 'fake-device-agent'
+
     def connect(self):
         """Return "dummy" connection."""
         log.critical('NEVER USE THIS CODE FOR REAL-LIFE USE-CASES!!!')
@@ -35,8 +40,7 @@ class FakeDevice(interface.Device):
         return self
 
     def close(self):
-        """Close connection."""
-        self.conn = None
+        """Close the device."""
 
     def pubkey(self, identity, ecdh=False):
         """Return public key."""
@@ -44,7 +48,8 @@ class FakeDevice(interface.Device):
         data = self.vk.to_string()
         x, y = data[:32], data[32:]
         prefix = bytearray([2 + (bytearray(y)[0] & 1)])
-        return bytes(prefix) + x
+        pubkey = bytes(prefix) + x
+        return formats.decompress_pubkey(pubkey=pubkey, curve_name=identity.curve_name)
 
     def sign(self, identity, blob):
         """Sign given blob and return the signature (as bytes)."""

libagent/device/interface.py

@@ -59,7 +59,7 @@ class DeviceError(Error):
     """Error during device operation."""
 
 
-class Identity(object):
+class Identity:
     """Represent SLIP-0013 identity, together with a elliptic curve choice."""
 
     def __init__(self, identity_str, curve_name):
@@ -77,7 +77,7 @@ class Identity(object):
         s = identity_to_string(self.identity_dict)
         return unidecode.unidecode(s).encode('ascii')
 
-    def __str__(self):
+    def to_string(self):
         """Return identity serialized to string."""
         return '<{}|{}>'.format(identity_to_string(self.identity_dict), self.curve_name)
 
@@ -102,7 +102,7 @@ class Identity(object):
             return self.curve_name
 
 
-class Device(object):
+class Device:
     """Abstract cryptographic hardware device interface."""
 
     def __init__(self):
@@ -113,6 +113,14 @@ class Device(object):
         """Connect to device, otherwise raise NotFoundError."""
         raise NotImplementedError()
 
+    def close(self):
+        """Close connection to device.
+
+        By default, close the underlying connection. Overriding classes
+        can perform their own cleanup.
+        """
+        self.conn.close()
+
     def __enter__(self):
         """Allow usage as context manager."""
         self.conn = self.connect()
@@ -121,7 +129,7 @@ class Device(object):
     def __exit__(self, *args):
         """Close and mark as disconnected."""
         try:
-            self.conn.close()
+            self.close()
         except Exception as e:  # pylint: disable=broad-except
             log.exception('close failed: %s', e)
         self.conn = None

libagent/device/keepkey.py

@@ -1,7 +1,7 @@
 """KeepKey-related code (see https://www.keepkey.com/)."""
 
-from . import trezor
 from .. import formats
+from . import trezor
 
 
 def _verify_support(identity, ecdh):
@@ -20,6 +20,11 @@ def _verify_support(identity, ecdh):
 class KeepKey(trezor.Trezor):
     """Connection to KeepKey device."""
 
+    @classmethod
+    def package_name(cls):
+        """Python package name (at PyPI)."""
+        return 'keepkey-agent'
+
     @property
     def _defs(self):
         from . import keepkey_defs
@@ -27,6 +32,9 @@ class KeepKey(trezor.Trezor):
 
     required_version = '>=1.0.4'
 
+    def _override_state_handler(self, _):
+        """No support for `state` handling on Keepkey."""
+
     def pubkey(self, identity, ecdh=False):
         """Return public key."""
         _verify_support(identity, ecdh)

libagent/device/keepkey_defs.py

@@ -2,8 +2,23 @@
 
 # pylint: disable=unused-import,import-error
 
-from keepkeylib.client import CallException as Error
+from keepkeylib.client import CallException
 from keepkeylib.client import KeepKeyClient as Client
+from keepkeylib.client import PinException
 from keepkeylib.messages_pb2 import PassphraseAck, PinMatrixAck
-from keepkeylib.transport_hid import HidTransport as Transport
+from keepkeylib.transport_hid import HidTransport
+from keepkeylib.transport_webusb import WebUsbTransport
 from keepkeylib.types_pb2 import IdentityType
+
+get_public_node = Client.get_public_node
+sign_identity = Client.sign_identity
+Client.state = None
+
+
+def find_device():
+    """Returns first WebUSB or HID transport."""
+    for d in WebUsbTransport.enumerate():
+        return WebUsbTransport(d)
+
+    for d in HidTransport.enumerate():
+        return HidTransport(d)

libagent/device/ledger.py

@@ -6,6 +6,7 @@ import struct
 
 from ledgerblue import comm  # pylint: disable=import-error
 
+from .. import formats
 from . import interface
 
 log = logging.getLogger(__name__)
@@ -36,6 +37,11 @@ def _convert_public_key(ecdsa_curve_name, result):
 class LedgerNanoS(interface.Device):
     """Connection to Ledger Nano S device."""
 
+    @classmethod
+    def package_name(cls):
+        """Python package name (at PyPI)."""
+        return 'ledger-agent'
+
     def connect(self):
         """Enumerate and connect to the first USB HID interface."""
         try:
@@ -56,8 +62,12 @@ class LedgerNanoS(interface.Device):
         apdu = binascii.unhexlify(apdu)
         apdu += bytearray([len(path) + 1, len(path) // 4])
         apdu += path
-        result = bytearray(self.conn.exchange(bytes(apdu)))[1:]
-        return _convert_public_key(curve_name, result)
+        log.debug('apdu: %r', apdu)
+        result = bytearray(self.conn.exchange(bytes(apdu)))
+        log.debug('result: %r', result)
+        return formats.decompress_pubkey(
+            pubkey=_convert_public_key(curve_name, result[1:]),
+            curve_name=identity.curve_name)
 
     def sign(self, identity, blob):
         """Sign given blob and return the signature (as bytes)."""
@@ -77,7 +87,9 @@ class LedgerNanoS(interface.Device):
         apdu += bytearray([len(blob) + len(path) + 1])
         apdu += bytearray([len(path) // 4]) + path
         apdu += blob
+        log.debug('apdu: %r', apdu)
         result = bytearray(self.conn.exchange(bytes(apdu)))
+        log.debug('result: %r', result)
         if identity.curve_name == 'nist256p1':
             offset = 3
             length = result[offset]
@@ -106,6 +118,8 @@ class LedgerNanoS(interface.Device):
         apdu += bytearray([len(pubkey) + len(path) + 1])
         apdu += bytearray([len(path) // 4]) + path
         apdu += pubkey
+        log.debug('apdu: %r', apdu)
         result = bytearray(self.conn.exchange(bytes(apdu)))
+        log.debug('result: %r', result)
         assert result[0] == 0x04
         return bytes(result)

libagent/device/onlykey.py

@@ -0,0 +1,377 @@
+# pylint: disable=too-many-locals,too-many-statements,too-many-branches
+# pylint: disable=attribute-defined-outside-init
+"""OnlyKey-related code (see https://www.onlykey.io/)."""
+
+import codecs
+import hashlib
+import logging
+import time
+
+import ecdsa
+import nacl.signing
+import unidecode
+
+from . import interface
+
+# import pgpy
+# from pgpy import PGPKey
+
+
+log = logging.getLogger(__name__)
+
+
+class OnlyKey(interface.Device):
+    """Connection to OnlyKey device."""
+
+    @classmethod
+    def package_name(cls):
+        """Python package name (at PyPI)."""
+        return 'onlykey-agent'
+
+    @property
+    def _defs(self):
+        from . import onlykey_defs
+        return onlykey_defs
+
+    def connect(self):
+        """Enumerate and connect to the first USB HID interface."""
+        try:
+            self.device_name = 'OnlyKey'
+            self.ok = self._defs.OnlyKey()
+            self.ok.set_time(time.time())
+            self.okversion = self.ok.read_string(timeout_ms=500)
+            self.okversion = self.okversion[8:]
+            self.skeyslot = 132
+            self.dkeyslot = 132
+        except Exception as e:
+            raise interface.NotFoundError('{} not connected: "{}"') from e
+
+    def set_skey(self, skey):
+        """Set signing key to use."""
+        self.skeyslot = skey
+        log.debug('Setting skey slot = %s', skey)
+
+    def set_dkey(self, dkey):
+        """Set decryption key to use."""
+        self.dkeyslot = dkey
+        log.debug('Setting dkey slot = %s', dkey)
+
+    def import_pub(self, pubkey):
+        """Import PGP public key."""
+        self.import_pubkey = pubkey
+        log.debug('Public key to import = %s', pubkey)
+        # self.import_pubkey_obj, _ = pgpy.PGPKey.from_blob(pubkey)
+        # self.import_pubkey_bytes = bytes(self.import_pubkey_obj)
+
+    def get_sk_dk(self):
+        """Get default signing key and decryption key slots."""
+        self.set_skey(132)
+        self.set_dkey(132)
+
+    def sig_hash(self, sighash):
+        """Set signature hashing algorithm to use."""
+        if sighash in (b'rsa-sha2-512', b'rsa-sha2-256'):
+            self.sighash = sighash
+            log.info('Setting RSA signature Hash Type =%s', sighash)
+
+    def close(self):
+        """Close connection."""
+        log.info('disconnected from %s', self.device_name)
+        self.ok.close()
+
+    def pubkey(self, identity, ecdh=False):
+        """Return public key."""
+        curve_name = identity.get_curve_name(ecdh=ecdh)
+        if identity.identity_dict['proto'] != 'ssh' and hasattr('self', 'skeyslot') is False:
+            self.get_sk_dk()
+        if identity.identity_dict['proto'] != 'ssh' and self.dkeyslot < 132 and ecdh is True:
+            this_slot_id = self.dkeyslot
+            log.info('Key Slot =%s', this_slot_id)
+        elif self.skeyslot < 132 and ecdh is False:
+            this_slot_id = self.skeyslot
+            log.info('Key Slot =%s', this_slot_id)
+        else:
+            this_slot_id = 132
+
+        log.info('Requesting public key from key slot =%s', this_slot_id)
+
+        log.debug('"%s" getting public key (%s) from %s',
+                  identity.to_string(), curve_name, self)
+
+        # Calculate hash for key derivation input data
+        if identity.identity_dict['proto'] == 'ssh':
+            if identity.identity_dict.get('user'):
+                id_parts = unidecode.unidecode(identity.identity_dict['user'] + '@' +
+                                               identity.identity_dict['host']).encode('ascii')
+            else:
+                id_parts = unidecode.unidecode(identity.identity_dict['host']).encode('ascii')
+        else:
+            id_parts = identity.to_bytes()
+        log.info('Identity to hash =%s', id_parts)
+        h1 = hashlib.sha256()
+        h1.update(id_parts)
+        data = h1.hexdigest()
+        log.info('Identity hash =%s', data)
+
+        if this_slot_id > 100:
+            if curve_name == 'curve25519':
+                data = '04' + data
+            elif curve_name == 'secp256k1':
+                # Not currently supported by agent, for future use
+                data = '03' + data
+            elif curve_name == 'nist256p1':
+                data = '02' + data
+            elif curve_name == 'ed25519':
+                data = '01' + data
+        else:
+            data = '00' + data
+
+        self.ok.send_message(msg=self._defs.Message.OKGETPUBKEY, slot_id=this_slot_id, payload=data)
+        log.info('curve name= %s', repr(curve_name))
+        t_end = time.time() + 1.5
+        if curve_name != 'rsa':
+            while time.time() < t_end:
+                try:
+                    ok_pubkey = self.ok.read_bytes(timeout_ms=100)
+                    if len(ok_pubkey) == 64 and len(set(ok_pubkey[0:63])) != 1:
+                        break
+                except Exception as e:
+                    raise interface.DeviceError(e)
+
+            log.info('received= %s', repr(ok_pubkey))
+            if len(set(ok_pubkey[34:63])) == 1:
+                if curve_name in ('nist256p1', 'secp256k1'):
+                    raise interface.DeviceError("Public key curve does not match requested type")
+                ok_pubkey = bytearray(ok_pubkey[0:32])
+                log.info('Received Public Key generated by OnlyKey= %s', repr(ok_pubkey.hex()))
+                vk = nacl.signing.VerifyKey(bytes(ok_pubkey),
+                                            encoder=nacl.encoding.RawEncoder)
+                log.info('vk= %s', repr(vk))
+                # time.sleep(3)
+                return vk
+            elif len(ok_pubkey) == 64:
+                ok_pubkey = bytearray(ok_pubkey[0:64])
+                if curve_name in ('ed25519', 'curve25519'):
+                    raise interface.DeviceError("Public key curve does not match requested type")
+                log.info('Received Public Key generated by OnlyKey= %s', repr(ok_pubkey))
+                if identity.curve_name == 'nist256p1':
+                    vk = ecdsa.VerifyingKey.from_string(ok_pubkey, curve=ecdsa.NIST256p)
+                else:
+                    vk = ecdsa.VerifyingKey.from_string(ok_pubkey, curve=ecdsa.SECP256k1)
+                return vk
+        else:
+            ok_pubkey = []
+            while time.time() < t_end:
+                try:
+                    ok_pub_part = self.ok.read_bytes(timeout_ms=100)
+                    if len(ok_pub_part) == 64 and len(set(ok_pub_part[0:63])) != 1:
+                        log.info('received part= %s', repr(ok_pub_part))
+                        ok_pubkey += ok_pub_part
+                        # Todo know RSA type to know how many packets
+                except Exception as e:
+                    raise interface.DeviceError(e)
+
+            log.info('received= %s', repr(ok_pubkey))
+            if len(ok_pubkey) == 256:
+                # https://security.stackexchange.com/questions/42268/how-do-i-get-the-rsa-bit-length-with-the-pubkey-and-openssl
+                ok_pubkey = b'\x00\x00\x00\x07' + b'\x73\x73\x68\x2d\x72\x73\x61' + \
+                                                b'\x00\x00\x00\x03' + b'\x01\x00\x01' + \
+                                                b'\x00\x00\x01\x01' + b'\x00' + bytes(ok_pubkey)
+                # ok_pubkey = b'\x00\x00\x00\x07' + b'\x72\x73\x61\x2d\x73\x68\x61\x32\x2d\x32\x35\x
+                # 36' + b'\x00\x00\x00\x03' + b'\x01\x00\x01' + b'\x00\x00\x01\x01' + b'\x00' + byte
+                # s(ok_pubkey)
+            elif len(ok_pubkey) == 512:
+                ok_pubkey = b'\x00\x00\x00\x07' + b'\x73\x73\x68\x2d\x72\x73\x61' + \
+                                                b'\x00\x00\x00\x03' + b'\x01\x00\x01' + \
+                                                b'\x00\x00\x02\x01' + b'\x00' + bytes(ok_pubkey)
+            else:
+                raise interface.DeviceError("Error response length is not a valid public key")
+            log.info('pubkey len = %s', len(ok_pubkey))
+            return ok_pubkey
+
+    def sign(self, identity, blob):
+        """Sign given blob and return the signature (as bytes)."""
+        curve_name = identity.get_curve_name(ecdh=False)
+        log.debug('"%s" signing %r (%s) on %s',
+                  identity.to_string(), blob, curve_name, self)
+        if identity.identity_dict['proto'] != 'ssh' and hasattr('self', 'skeyslot') is False:
+            self.get_sk_dk()
+        # Calculate hash for SSH signing
+        if curve_name == 'rsa':
+            if self.sighash == b'rsa-sha2-512':
+                log.info('rsa-sha2-512')
+                h1 = hashlib.sha512()
+                h1.update(blob)
+                data = h1.hexdigest()
+                data = codecs.decode(data, 'hex_codec')
+            elif self.sighash == b'rsa-sha2-256':
+                log.info('rsa-sha2-256')
+                h1 = hashlib.sha256()
+                h1.update(blob)
+                data = h1.hexdigest()
+                data = codecs.decode(data, 'hex_codec')
+        else:
+            # Calculate hash for key derivation input data
+            h1 = hashlib.sha256()
+            if identity.identity_dict['proto'] == 'ssh':
+                if identity.identity_dict.get('user'):
+                    id_parts = unidecode.unidecode(identity.identity_dict['user'] + '@' +
+                                                   identity.identity_dict['host']).encode('ascii')
+                else:
+                    id_parts = unidecode.unidecode(identity.identity_dict['host']).encode('ascii')
+            else:
+                id_parts = identity.to_bytes()
+            h1.update(id_parts)
+            data = h1.hexdigest()
+            data = codecs.decode(data, 'hex_codec')
+            log.info('Identity to hash =%s', id_parts)
+            log.info('Identity hash =%s', data)
+        # Determine type of key to derive on OnlyKey for signature
+        # Slot 132 used for derived key, slots 101-116 used for stored ecc keys
+        # slots 1-4 used for stored RSA keys
+        if self.skeyslot == 132:
+            if curve_name == 'ed25519':
+                this_slot_id = 201
+                log.info('Key type ed25519')
+            elif curve_name == 'nist256p1':
+                this_slot_id = 202
+                log.info('Key type nistp256')
+            else:
+                this_slot_id = 203
+                log.info('Key type secp256k1')
+            # Send data and identity hash
+            raw_message = blob + data
+        else:
+            this_slot_id = self.skeyslot
+            # Send just data to sign
+            raw_message = blob
+        h2 = hashlib.sha256()
+        h2.update(raw_message)
+        d = h2.digest()
+        assert len(d) == 32
+        b1, b2, b3 = get_button(self, d[0]), get_button(self, d[15]), get_button(self, d[31])
+        log.info('Key Slot =%s', this_slot_id)
+        print('Enter the 3 digit challenge code on OnlyKey to authorize '+identity.to_string())
+        print('{} {} {}'.format(b1, b2, b3))
+        t_end = time.time() + 22
+        if curve_name != 'rsa':
+            self.ok.send_large_message2(msg=self._defs.Message.OKSIGN, payload=raw_message,
+                                        slot_id=this_slot_id)
+            while time.time() < t_end:
+                try:
+                    result = self.ok.read_bytes(timeout_ms=100)
+                    if len(result) == 64 and len(set(result[0:63])) != 1:
+                        break
+                except Exception as e:
+                    raise interface.DeviceError(e)
+
+            if len(result) >= 60:
+                log.info('received= %s', repr(result))
+                while len(result) < 64:
+                    result.append(0)
+                log.info('disconnected from %s', self.device_name)
+                self.ok.close()
+                return bytes(result)
+        else:
+            self.ok.send_large_message2(msg=self._defs.Message.OKSIGN, payload=data,
+                                        slot_id=this_slot_id)
+            result = []
+            while time.time() < t_end:
+                try:
+                    sig_part = self.ok.read_bytes(timeout_ms=100)
+                    if len(sig_part) == 64 and len(set(sig_part[0:63])) != 1:
+                        log.info('received part= %s', repr(sig_part))
+                        result += sig_part
+                        t_end = time.time() + 1
+                        # Todo know RSA type to know how many packets
+                except Exception as e:
+                    raise interface.DeviceError(e)
+
+            log.info('received= %s', repr(result))
+            return bytes(result)
+        raise Exception('failed to sign challenge')
+
+    def ecdh(self, identity, pubkey):
+        """Get shared session key using Elliptic Curve Diffie-Hellman."""
+        curve_name = identity.get_curve_name(ecdh=True)
+        log.debug('"%s" shared session key (%s) for %r from %s',
+                  identity.to_string(), curve_name, pubkey, self)
+        # Calculate hash for key derivation input data
+        h1 = hashlib.sha256()
+        if identity.identity_dict['proto'] == 'ssh':
+            if identity.identity_dict.get('user'):
+                id_parts = unidecode.unidecode(identity.identity_dict['user'] + '@' +
+                                               identity.identity_dict['host']).encode('ascii')
+            else:
+                id_parts = unidecode.unidecode(identity.identity_dict['host']).encode('ascii')
+        else:
+            id_parts = identity.to_bytes()
+        h1.update(id_parts)
+        log.info('Identity to hash =%s', id_parts)
+        data = h1.hexdigest()
+        log.info('Identity hash =%s', data)
+        data = codecs.decode(data, 'hex_codec')
+        # Determine type of key to derive on OnlyKey for ecdh
+        # Slot 132 used for derived key, slots 101-116 used for stored ecc keys,
+        # slots 1-4 used for stored RSA keys
+        if self.dkeyslot == 132:
+            if curve_name == 'curve25519':
+                this_slot_id = 204
+                log.info('Key type curve25519')
+            elif curve_name == 'nist256p1':
+                this_slot_id = 202
+                log.info('Key type nistp256')
+            else:
+                this_slot_id = 203
+                log.info('Key type secp256k1')
+            raw_message = pubkey + data
+        else:
+            this_slot_id = self.dkeyslot
+            raw_message = pubkey
+        log.info('Key Slot =%s', this_slot_id)
+        log.info('data hash =%s', data)
+        h2 = hashlib.sha256()
+        h2.update(raw_message)
+        d = h2.digest()
+        assert len(d) == 32
+        b1, b2, b3 = get_button(self, d[0]), get_button(self, d[15]), get_button(self, d[31])
+        self.ok.send_large_message2(msg=self._defs.Message.OKDECRYPT, payload=raw_message,
+                                    slot_id=this_slot_id)
+        print('Enter the 3 digit challenge code on OnlyKey to authorize ' + identity.to_string())
+        print('{} {} {}'.format(b1, b2, b3))
+        t_end = time.time() + 22
+        if curve_name != 'rsa':
+            while time.time() < t_end:
+                try:
+                    result = self.ok.read_bytes(timeout_ms=100)
+                    if len(result) == 64 and len(set(result[0:63])) != 1:
+                        break
+                except Exception as e:
+                    raise interface.DeviceError(e)
+            if len(set(result[34:63])) == 1:
+                result = b'\x04' + bytes(result[0:32])
+        else:
+            result = []
+            while time.time() < t_end:
+                try:
+                    dec_part = self.ok.read_bytes(timeout_ms=100)
+                    if len(dec_part) == 64 and len(set(dec_part[0:63])) != 1:
+                        log.info('received part= %s', repr(dec_part))
+                        result += dec_part
+                        t_end = time.time() + 1
+                        # Todo know RSA type to know how many packets
+                except Exception as e:
+                    raise interface.DeviceError(e)
+
+        log.info('received= %s', repr(result))
+        log.info('disconnected from %s', self.device_name)
+        self.ok.close()
+        return bytes(result)
+
+
+def get_button(self, byte):
+    """Return button number."""
+    if str(self.okversion) == 'v0.2-beta.8c':
+        return byte % 5 + 1
+    else:
+        return byte % 6 + 1

libagent/device/onlykey_defs.py

@@ -0,0 +1,5 @@
+"""OnlyKey-related definitions."""
+
+# pylint: disable=unused-import,import-error,no-name-in-module
+
+from onlykey import Message, OnlyKey

libagent/device/trezor.py

@@ -2,11 +2,10 @@
 
 import binascii
 import logging
-import os
-import sys
 
 import semver
 
+from .. import formats
 from . import interface
 
 log = logging.getLogger(__name__)
@@ -15,86 +14,83 @@ log = logging.getLogger(__name__)
 class Trezor(interface.Device):
     """Connection to TREZOR device."""
 
+    @classmethod
+    def package_name(cls):
+        """Python package name (at PyPI)."""
+        return 'trezor-agent'
+
     @property
     def _defs(self):
         from . import trezor_defs
-        # Allow using TREZOR bridge transport (instead of the HID default)
-        trezor_defs.Transport = {
-            'bridge': trezor_defs.BridgeTransport,
-        }.get(os.environ.get('TREZOR_TRANSPORT'), trezor_defs.HidTransport)
         return trezor_defs
 
     required_version = '>=1.4.0'
-    passphrase = os.environ.get('TREZOR_PASSPHRASE', '')
+
+    ui = None  # can be overridden by device's users
+    cached_session_id = None
+
+    def _verify_version(self, connection):
+        f = connection.features
+        log.debug('connected to %s %s', self, f.device_id)
+        log.debug('label    : %s', f.label)
+        log.debug('vendor   : %s', f.vendor)
+        current_version = '{}.{}.{}'.format(f.major_version,
+                                            f.minor_version,
+                                            f.patch_version)
+        log.debug('version  : %s', current_version)
+        log.debug('revision : %s', binascii.hexlify(f.revision))
+        if not semver.match(current_version, self.required_version):
+            fmt = ('Please upgrade your {} firmware to {} version'
+                   ' (current: {})')
+            raise ValueError(fmt.format(self, self.required_version,
+                                        current_version))
 
     def connect(self):
-        """Enumerate and connect to the first USB HID interface."""
-        def passphrase_handler(_):
-            log.debug('using %s passphrase for %s',
-                      'non-empty' if self.passphrase else 'empty', self)
-            return self._defs.PassphraseAck(passphrase=self.passphrase)
+        """Enumerate and connect to the first available interface."""
+        transport = self._defs.find_device()
+        if not transport:
+            raise interface.NotFoundError('{} not connected'.format(self))
 
-        def create_pin_handler(conn):
-            if os.isatty(sys.stdin.fileno()):
-                return conn.callback_PinMatrixRequest  # CLI-based PIN handler
+        log.debug('using transport: %s', transport)
+        for _ in range(5):  # Retry a few times in case of PIN failures
+            connection = self._defs.Client(transport=transport,
+                                           ui=self.ui,
+                                           session_id=self.__class__.cached_session_id)
+            self._verify_version(connection)
 
-            def qt_handler(_):
-                # pylint: disable=import-error
-                from PyQt5.QtWidgets import QApplication, QInputDialog, QLineEdit
-                label = ('Use the numeric keypad to describe number positions.\n'
-                         'The layout is:\n'
-                         '    7 8 9\n'
-                         '    4 5 6\n'
-                         '    1 2 3\n'
-                         'Please enter PIN:')
-                app = QApplication([])
-                qd = QInputDialog()
-                qd.setTextEchoMode(QLineEdit.Password)
-                qd.setLabelText(label)
-                qd.show()
-                app.exec_()
-                return self._defs.PinMatrixAck(pin=qd.textValue())
-
-            return qt_handler
-
-        for d in self._defs.Transport.enumerate():
-            log.debug('endpoint: %s', d)
-            transport = self._defs.Transport(d)
-            connection = self._defs.Client(transport)
-            connection.callback_PassphraseRequest = passphrase_handler
-            connection.callback_PinMatrixRequest = create_pin_handler(connection)
-            f = connection.features
-            log.debug('connected to %s %s', self, f.device_id)
-            log.debug('label    : %s', f.label)
-            log.debug('vendor   : %s', f.vendor)
-            current_version = '{}.{}.{}'.format(f.major_version,
-                                                f.minor_version,
-                                                f.patch_version)
-            log.debug('version  : %s', current_version)
-            log.debug('revision : %s', binascii.hexlify(f.revision))
-            if not semver.match(current_version, self.required_version):
-                fmt = ('Please upgrade your {} firmware to {} version'
-                       ' (current: {})')
-                raise ValueError(fmt.format(self, self.required_version,
-                                            current_version))
-            connection.ping(msg='', pin_protection=True)  # unlock PIN
-            return connection
-        raise interface.NotFoundError('{} not connected'.format(self))
+            try:
+                # unlock PIN and passphrase
+                self._defs.get_address(connection,
+                                       "Testnet",
+                                       self._defs.PASSPHRASE_TEST_PATH)
+                return connection
+            except (self._defs.PinException, ValueError) as e:
+                log.error('Invalid PIN: %s, retrying...', e)
+                continue
+            except Exception as e:
+                log.exception('ping failed: %s', e)
+                connection.close()  # so the next HID open() will succeed
+                raise
+        return None
 
     def close(self):
         """Close connection."""
-        self.conn.close()
+        self.__class__.cached_session_id = self.conn.session_id
+        super().close()
 
     def pubkey(self, identity, ecdh=False):
         """Return public key."""
         curve_name = identity.get_curve_name(ecdh=ecdh)
         log.debug('"%s" getting public key (%s) from %s',
-                  identity, curve_name, self)
+                  identity.to_string(), curve_name, self)
         addr = identity.get_bip32_address(ecdh=ecdh)
-        result = self.conn.get_public_node(n=addr,
-                                           ecdsa_curve_name=curve_name)
+        result = self._defs.get_public_node(
+            self.conn,
+            n=addr,
+            ecdsa_curve_name=curve_name)
         log.debug('result: %s', result)
-        return result.node.public_key
+        pubkey = bytes(result.node.public_key)
+        return formats.decompress_pubkey(pubkey=pubkey, curve_name=identity.curve_name)
 
     def _identity_proto(self, identity):
         result = self._defs.IdentityType()
@@ -103,12 +99,18 @@ class Trezor(interface.Device):
         return result
 
     def sign(self, identity, blob):
+        """Sign given blob and return the signature (as bytes)."""
+        sig, _ = self.sign_with_pubkey(identity, blob)
+        return sig
+
+    def sign_with_pubkey(self, identity, blob):
         """Sign given blob and return the signature (as bytes)."""
         curve_name = identity.get_curve_name(ecdh=False)
         log.debug('"%s" signing %r (%s) on %s',
-                  identity, blob, curve_name, self)
+                  identity.to_string(), blob, curve_name, self)
         try:
-            result = self.conn.sign_identity(
+            result = self._defs.sign_identity(
+                self.conn,
                 identity=self._identity_proto(identity),
                 challenge_hidden=blob,
                 challenge_visual='',
@@ -116,8 +118,8 @@ class Trezor(interface.Device):
             log.debug('result: %s', result)
             assert len(result.signature) == 65
             assert result.signature[:1] == b'\x00'
-            return result.signature[1:]
-        except self._defs.Error as e:
+            return bytes(result.signature[1:]), bytes(result.public_key)
+        except self._defs.TrezorFailure as e:
             msg = '{} error: {}'.format(self, e)
             log.debug(msg, exc_info=True)
             raise interface.DeviceError(msg)
@@ -126,17 +128,18 @@ class Trezor(interface.Device):
         """Get shared session key using Elliptic Curve Diffie-Hellman."""
         curve_name = identity.get_curve_name(ecdh=True)
         log.debug('"%s" shared session key (%s) for %r from %s',
-                  identity, curve_name, pubkey, self)
+                  identity.to_string(), curve_name, pubkey, self)
         try:
-            result = self.conn.get_ecdh_session_key(
+            result = self._defs.get_ecdh_session_key(
+                self.conn,
                 identity=self._identity_proto(identity),
                 peer_public_key=pubkey,
                 ecdsa_curve_name=curve_name)
             log.debug('result: %s', result)
             assert len(result.session_key) in {65, 33}  # NIST256 or Curve25519
             assert result.session_key[:1] == b'\x04'
-            return result.session_key
-        except self._defs.Error as e:
+            return bytes(result.session_key)
+        except self._defs.TrezorFailure as e:
             msg = '{} error: {}'.format(self, e)
             log.debug(msg, exc_info=True)
             raise interface.DeviceError(msg)

libagent/device/trezor_defs.py

@@ -1,10 +1,31 @@
 """TREZOR-related definitions."""
 
-# pylint: disable=unused-import,import-error
+import logging
+# pylint: disable=unused-import,import-error,no-name-in-module,no-member
+import os
 
-from trezorlib.client import CallException as Error
+import mnemonic
+import semver
+
+import trezorlib
+from trezorlib.btc import get_address, get_public_node
+from trezorlib.client import PASSPHRASE_TEST_PATH
 from trezorlib.client import TrezorClient as Client
-from trezorlib.messages_pb2 import PassphraseAck, PinMatrixAck
-from trezorlib.transport_bridge import BridgeTransport
-from trezorlib.transport_hid import HidTransport
-from trezorlib.types_pb2 import IdentityType
+from trezorlib.exceptions import PinException, TrezorFailure
+from trezorlib.messages import IdentityType
+from trezorlib.misc import get_ecdh_session_key, sign_identity
+from trezorlib.transport import get_transport
+
+log = logging.getLogger(__name__)
+
+
+def find_device():
+    """Selects a transport based on `TREZOR_PATH` environment variable.
+
+    If unset, picks first connected device.
+    """
+    try:
+        return get_transport(os.environ.get("TREZOR_PATH"), prefix_search=True)
+    except Exception as e:  # pylint: disable=broad-except
+        log.debug("Failed to find a Trezor device: %s", e)
+        return None

libagent/device/ui.py

@@ -0,0 +1,156 @@
+"""UIs for PIN/passphrase entry."""
+
+import logging
+import os
+import subprocess
+import sys
+
+from .. import util
+
+try:
+    from trezorlib.client import PASSPHRASE_ON_DEVICE
+except ImportError:
+    PASSPHRASE_ON_DEVICE = object()
+
+
+log = logging.getLogger(__name__)
+
+
+class UI:
+    """UI for PIN/passphrase entry (for TREZOR devices)."""
+
+    def __init__(self, device_type, config=None):
+        """C-tor."""
+        default_pinentry = 'pinentry'  # by default, use GnuPG pinentry tool
+        if config is None:
+            config = {}
+        self.pin_entry_binary = config.get('pin_entry_binary',
+                                           default_pinentry)
+        self.passphrase_entry_binary = config.get('passphrase_entry_binary',
+                                                  default_pinentry)
+        self.options_getter = create_default_options_getter()
+        self.device_name = device_type.__name__
+        self.cached_passphrase_ack = util.ExpiringCache(
+            seconds=float(config.get('cache_expiry_seconds', 'inf')))
+
+    def get_pin(self, _code=None):
+        """Ask the user for (scrambled) PIN."""
+        description = (
+            'Use the numeric keypad to describe number positions.\n'
+            'The layout is:\n'
+            '    7 8 9\n'
+            '    4 5 6\n'
+            '    1 2 3')
+        return interact(
+            title='{} PIN'.format(self.device_name),
+            prompt='PIN:',
+            description=description,
+            binary=self.pin_entry_binary,
+            options=self.options_getter())
+
+    def get_passphrase(self, prompt='Passphrase:', available_on_device=False):
+        """Ask the user for passphrase."""
+        passphrase = None
+        if self.cached_passphrase_ack:
+            passphrase = self.cached_passphrase_ack.get()
+        if passphrase is None:
+            env_passphrase = os.environ.get("TREZOR_PASSPHRASE")
+            if env_passphrase is not None:
+                passphrase = env_passphrase
+            elif available_on_device:
+                passphrase = PASSPHRASE_ON_DEVICE
+            else:
+                passphrase = interact(
+                    title='{} passphrase'.format(self.device_name),
+                    prompt=prompt,
+                    description=None,
+                    binary=self.passphrase_entry_binary,
+                    options=self.options_getter())
+        if self.cached_passphrase_ack:
+            self.cached_passphrase_ack.set(passphrase)
+        return passphrase
+
+    def button_request(self, _code=None):
+        """Called by TrezorClient when device interaction is required."""
+        # XXX: show notification to the user?
+
+
+def create_default_options_getter():
+    """Return current TTY and DISPLAY settings for GnuPG pinentry."""
+    options = []
+    if sys.stdin.isatty():  # short-circuit calling `tty`
+        try:
+            ttyname = subprocess.check_output(args=['tty']).strip()
+            options.append(b'ttyname=' + ttyname)
+        except subprocess.CalledProcessError as e:
+            log.warning('no TTY found: %s', e)
+
+    display = os.environ.get('DISPLAY')
+    if display is not None:
+        options.append('display={}'.format(display).encode('ascii'))
+    else:
+        log.warning('DISPLAY not defined')
+
+    log.info('using %s for pinentry options', options)
+    return lambda: options
+
+
+def write(p, line):
+    """Send and flush a single line to the subprocess' stdin."""
+    log.debug('%s <- %r', p.args, line)
+    p.stdin.write(line)
+    p.stdin.flush()
+
+
+class UnexpectedError(Exception):
+    """Unexpected response."""
+
+
+def expect(p, prefixes, confidential=False):
+    """Read a line and return it without required prefix."""
+    resp = p.stdout.readline()
+    log.debug('%s -> %r', p.args, resp if not confidential else '********')
+    for prefix in prefixes:
+        if resp.startswith(prefix):
+            return resp[len(prefix):]
+    raise UnexpectedError(resp)
+
+
+def interact(title, description, prompt, binary, options):
+    """Use GPG pinentry program to interact with the user."""
+    args = [binary]
+    p = subprocess.Popen(args=args,
+                         stdin=subprocess.PIPE,
+                         stdout=subprocess.PIPE,
+                         env=os.environ)
+    p.args = args  # TODO: remove after Python 2 deprecation.
+    expect(p, [b'OK'])
+
+    title = util.assuan_serialize(title.encode('ascii'))
+    write(p, b'SETTITLE ' + title + b'\n')
+    expect(p, [b'OK'])
+
+    if description:
+        description = util.assuan_serialize(description.encode('ascii'))
+        write(p, b'SETDESC ' + description + b'\n')
+        expect(p, [b'OK'])
+
+    if prompt:
+        prompt = util.assuan_serialize(prompt.encode('ascii'))
+        write(p, b'SETPROMPT ' + prompt + b'\n')
+        expect(p, [b'OK'])
+
+    log.debug('setting %d options', len(options))
+    for opt in options:
+        write(p, b'OPTION ' + opt + b'\n')
+        expect(p, [b'OK', b'ERR'])
+
+    write(p, b'GETPIN\n')
+    pin = expect(p, [b'OK', b'D '], confidential=True)
+
+    p.communicate()  # close stdin and wait for the process to exit
+    exit_code = p.wait()
+    if exit_code:
+        raise subprocess.CalledProcessError(exit_code, binary)
+
+    return pin.decode('ascii').strip()

libagent/formats.py

@@ -5,7 +5,7 @@ import io
 import logging
 
 import ecdsa
-import ed25519
+import nacl.signing
 
 from . import util
 
@@ -88,8 +88,10 @@ def parse_pubkey(blob):
 
         def ed25519_verify(sig, msg):
             assert len(sig) == 64
-            vk = ed25519.VerifyingKey(pubkey)
-            vk.verify(sig, msg)
+            vk = nacl.signing.VerifyKey(bytes(pubkey),
+                                        encoder=nacl.encoding.RawEncoder)
+            vk.verify(msg, sig)
+            log.debug('verify signature')
             return sig
 
         result.update(curve=CURVE_ED25519, verifier=ed25519_verify)
@@ -101,7 +103,9 @@ def _decompress_ed25519(pubkey):
     """Load public key from the serialized blob (stripping the prefix byte)."""
     if pubkey[:1] == b'\x00':
         # set by Trezor fsm_msgSignIdentity() and fsm_msgGetPublicKey()
-        return ed25519.VerifyingKey(pubkey[1:])
+        return nacl.signing.VerifyKey(pubkey[1:], encoder=nacl.encoding.RawEncoder)
+    else:
+        return None
 
 
 def _decompress_nist256(pubkey):
@@ -126,6 +130,8 @@ def _decompress_nist256(pubkey):
         point = ecdsa.ellipticcurve.Point(curve.curve, x, y)
         return ecdsa.VerifyingKey.from_public_point(point, curve=curve,
                                                     hashfunc=hashfunc)
+    else:
+        return None
 
 
 def decompress_pubkey(pubkey, curve_name):
@@ -157,8 +163,8 @@ def serialize_verifying_key(vk):
     Currently, NIST256P1 and ED25519 elliptic curves are supported.
     Raise TypeError on unsupported key format.
     """
-    if isinstance(vk, ed25519.keys.VerifyingKey):
-        pubkey = vk.to_bytes()
+    if isinstance(vk, nacl.signing.VerifyKey):
+        pubkey = vk.encode(encoder=nacl.encoding.RawEncoder)
         key_type = SSH_ED25519_KEY_TYPE
         blob = util.frame(SSH_ED25519_KEY_TYPE) + util.frame(pubkey)
         return key_type, blob

libagent/gpg/__init__.py

@@ -13,13 +13,17 @@ import contextlib
 import functools
 import logging
 import os
+import re
+import subprocess
 import sys
 import time
 
+import daemon
+import pkg_resources
 import semver
 
-from . import agent, client, encode, keyring, protocol
 from .. import device, formats, server, util
+from . import agent, client, encode, keyring, protocol
 
 log = logging.getLogger(__name__)
 
@@ -73,23 +77,126 @@ def export_public_key(device_type, args):
                                       subkey=subkey,
                                       signer_func=signer_func)
 
-    sys.stdout.write(protocol.armor(result, 'PUBLIC KEY BLOCK'))
+    return protocol.armor(result, 'PUBLIC KEY BLOCK')
 
 
-def run_create(device_type, args):
-    """Export public GPG key."""
+def verify_gpg_version():
+    """Make sure that the installed GnuPG is not too old."""
+    existing_gpg = keyring.gpg_version().decode('ascii')
+    required_gpg = '>=2.1.11'
+    msg = 'Existing GnuPG has version "{}" ({} required)'.format(existing_gpg,
+                                                                 required_gpg)
+    if not semver.match(existing_gpg, required_gpg):
+        log.error(msg)
+
+
+def check_output(args):
+    """Runs command and returns the output as string."""
+    log.debug('run: %s', args)
+    out = subprocess.check_output(args=args).decode('utf-8')
+    log.debug('out: %r', out)
+    return out
+
+
+def check_call(args, stdin=None, env=None):
+    """Runs command and verifies its success."""
+    log.debug('run: %s%s', args, ' {}'.format(env) if env else '')
+    subprocess.check_call(args=args, stdin=stdin, env=env)
+
+
+def write_file(path, data):
+    """Writes data to specified path."""
+    with open(path, 'w') as f:
+        log.debug('setting %s contents:\n%s', path, data)
+        f.write(data)
+    return f
+
+
+def run_init(device_type, args):
+    """Initialize hardware-based GnuPG identity."""
     util.setup_logging(verbosity=args.verbose)
     log.warning('This GPG tool is still in EXPERIMENTAL mode, '
                 'so please note that the API and features may '
                 'change without backwards compatibility!')
 
-    existing_gpg = keyring.gpg_version().decode('ascii')
-    required_gpg = '>=2.1.11'
-    if semver.match(existing_gpg, required_gpg):
-        export_public_key(device_type, args)
-    else:
-        log.error('Existing gpg2 has version "%s" (%s required)',
-                  existing_gpg, required_gpg)
+    verify_gpg_version()
+
+    # Prepare new GPG home directory for hardware-based identity
+    device_name = device_type.package_name().rsplit('-', 1)[0]
+    log.info('device name: %s', device_name)
+    homedir = args.homedir
+    if not homedir:
+        homedir = os.path.expanduser('~/.gnupg/{}'.format(device_name))
+
+    log.info('GPG home directory: %s', homedir)
+
+    if os.path.exists(homedir):
+        log.error('GPG home directory %s exists, '
+                  'remove it manually if required', homedir)
+        sys.exit(1)
+
+    check_call(['mkdir', '-p', homedir])
+    check_call(['chmod', '700', homedir])
+
+    agent_path = util.which('{}-gpg-agent'.format(device_name))
+
+    # Prepare GPG agent invocation script (to pass the PATH from environment).
+    with open(os.path.join(homedir, 'run-agent.sh'), 'w') as f:
+        f.write(r"""#!/bin/sh
+export PATH="{0}"
+{1} \
+-vv \
+--pin-entry-binary={pin_entry_binary} \
+--passphrase-entry-binary={passphrase_entry_binary} \
+--cache-expiry-seconds={cache_expiry_seconds} \
+$*
+""".format(os.environ['PATH'], agent_path, **vars(args)))
+    check_call(['chmod', '700', f.name])
+    run_agent_script = f.name
+
+    # Prepare GPG configuration file
+    with open(os.path.join(homedir, 'gpg.conf'), 'w') as f:
+        f.write("""# Hardware-based GPG configuration
+agent-program {0}
+personal-digest-preferences SHA512
+default-key \"{1}\"
+""".format(run_agent_script, args.user_id))
+
+    # Prepare a helper script for setting up the new identity
+    with open(os.path.join(homedir, 'env'), 'w') as f:
+        f.write("""#!/bin/bash
+set -eu
+export GNUPGHOME={0}
+COMMAND=$*
+if [ -z "${{COMMAND}}" ]
+then
+    ${{SHELL}}
+else
+    ${{COMMAND}}
+fi
+""".format(homedir))
+    check_call(['chmod', '700', f.name])
+
+    # Generate new GPG identity and import into GPG keyring
+    pubkey = write_file(os.path.join(homedir, 'pubkey.asc'),
+                        export_public_key(device_type, args))
+    verbosity = ('-' + ('v' * args.verbose)) if args.verbose else '--quiet'
+    check_call(keyring.gpg_command(['--homedir', homedir, verbosity,
+                                    '--import', pubkey.name]))
+
+    # Make new GPG identity with "ultimate" trust (via its fingerprint)
+    out = check_output(keyring.gpg_command(['--homedir', homedir,
+                                            '--list-public-keys',
+                                            '--with-fingerprint',
+                                            '--with-colons']))
+    fpr = re.findall('fpr:::::::::([0-9A-F]+):', out)[0]
+    f = write_file(os.path.join(homedir, 'ownertrust.txt'), fpr + ':6\n')
+    check_call(keyring.gpg_command(['--homedir', homedir,
+                                    '--import-ownertrust', f.name]))
+
+    # Load agent and make sure it responds with the new identity
+    check_call(keyring.gpg_command(['--homedir', homedir,
+                                    '--list-secret-keys', args.user_id]))
 
 
 def run_unlock(device_type, args):
@@ -99,51 +206,126 @@ def run_unlock(device_type, args):
         log.info('unlocked %s device', d)
 
 
+def _server_from_assuan_fd(env):
+    fd = env.get('_assuan_connection_fd')
+    if fd is None:
+        return None
+    log.info('using fd=%r for UNIX socket server', fd)
+    return server.unix_domain_socket_server_from_fd(int(fd))
+
+
+def _server_from_sock_path(env):
+    sock_path = keyring.get_agent_sock_path(env=env)
+    return server.unix_domain_socket_server(sock_path)
+
+
 def run_agent(device_type):
     """Run a simple GPG-agent server."""
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--homedir', default=os.environ.get('GNUPGHOME'))
-    args, _ = parser.parse_known_args()
+    p = argparse.ArgumentParser()
+    p.add_argument('--homedir', default=os.environ.get('GNUPGHOME'))
+    p.add_argument('-v', '--verbose', default=0, action='count')
+    p.add_argument('--server', default=False, action='store_true',
+                   help='Use stdin/stdout for communication with GPG.')
+    p.add_argument('--daemon', default=False, action='store_true',
+                   help='Daemonize the agent.')
 
+    p.add_argument('--pin-entry-binary', type=str, default='pinentry',
+                   help='Path to PIN entry UI helper.')
+    p.add_argument('--passphrase-entry-binary', type=str, default='pinentry',
+                   help='Path to passphrase entry UI helper.')
+    p.add_argument('--cache-expiry-seconds', type=float, default=float('inf'),
+                   help='Expire passphrase from cache after this duration.')
+
+    args, _ = p.parse_known_args()
+
+    if args.daemon:
+        with daemon.DaemonContext():
+            run_agent_internal(args, device_type)
+    else:
+        run_agent_internal(args, device_type)
+
+
+def run_agent_internal(args, device_type):
+    """Actually run the server."""
     assert args.homedir
-    config_file = os.path.join(args.homedir, 'gpg-agent.conf')
 
-    lines = (line.strip() for line in open(config_file))
-    lines = (line for line in lines if line and not line.startswith('#'))
-    config = dict(line.split(' ', 1) for line in lines)
+    log_file = os.path.join(args.homedir, 'gpg-agent.log')
+    util.setup_logging(verbosity=args.verbose, filename=log_file)
 
-    util.setup_logging(verbosity=int(config['verbosity']),
-                       filename=config['log-file'])
-    sock_path = keyring.get_agent_sock_path()
-    handler = agent.Handler(device=device_type())
-    with server.unix_domain_socket_server(sock_path) as sock:
-        for conn in agent.yield_connections(sock):
-            with contextlib.closing(conn):
-                try:
-                    handler.handle(conn)
-                except agent.AgentStop:
-                    log.info('stopping gpg-agent')
-                    return
-                except Exception as e:  # pylint: disable=broad-except
-                    log.exception('gpg-agent failed: %s', e)
+    log.debug('sys.argv: %s', sys.argv)
+    log.debug('os.environ: %s', os.environ)
+    log.debug('pid: %d, parent pid: %d', os.getpid(), os.getppid())
+    try:
+        env = {'GNUPGHOME': args.homedir, 'PATH': os.environ['PATH']}
+        pubkey_bytes = keyring.export_public_keys(env=env)
+        device_type.ui = device.ui.UI(device_type=device_type,
+                                      config=vars(args))
+        handler = agent.Handler(device=device_type(),
+                                pubkey_bytes=pubkey_bytes)
+
+        sock_server = _server_from_assuan_fd(os.environ)
+        if sock_server is None:
+            sock_server = _server_from_sock_path(env)
+
+        with sock_server as sock:
+            for conn in agent.yield_connections(sock):
+                with contextlib.closing(conn):
+                    try:
+                        handler.handle(conn)
+                    except agent.AgentStop:
+                        log.info('stopping gpg-agent')
+                        return
+                    except IOError as e:
+                        log.info('connection closed: %s', e)
+                        return
+                    except Exception as e:  # pylint: disable=broad-except
+                        log.exception('handler failed: %s', e)
+
+    except Exception as e:  # pylint: disable=broad-except
+        log.exception('gpg-agent failed: %s', e)
 
 
 def main(device_type):
     """Parse command-line arguments."""
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers()
+    epilog = ('See https://github.com/romanz/trezor-agent/blob/master/'
+              'doc/README-GPG.md for usage examples.')
+    parser = argparse.ArgumentParser(epilog=epilog)
 
-    p = subparsers.add_parser('create', help='Export public GPG key')
+    agent_package = device_type.package_name()
+    resources_map = {r.key: r for r in pkg_resources.require(agent_package)}
+    resources = [resources_map[agent_package], resources_map['libagent']]
+    versions = '\n'.join('{}={}'.format(r.key, r.version) for r in resources)
+    parser.add_argument('--version', help='print the version info',
+                        action='version', version=versions)
+
+    subparsers = parser.add_subparsers(title='Action', dest='action')
+    subparsers.required = True
+
+    p = subparsers.add_parser('init',
+                              help='initialize hardware-based GnuPG identity')
     p.add_argument('user_id')
     p.add_argument('-e', '--ecdsa-curve', default='nist256p1')
-    p.add_argument('-t', '--time', type=int, default=int(time.time()))
+    p.add_argument('-t', '--time', type=int, default=0)
     p.add_argument('-v', '--verbose', default=0, action='count')
     p.add_argument('-s', '--subkey', default=False, action='store_true')
-    p.set_defaults(func=run_create)
 
-    p = subparsers.add_parser('unlock', help='Unlock the hardware device')
+    p.add_argument('--homedir', type=str, default=os.environ.get('GNUPGHOME'),
+                   help='Customize GnuPG home directory for the new identity.')
+
+    p.add_argument('--pin-entry-binary', type=str, default='pinentry',
+                   help='Path to PIN entry UI helper.')
+    p.add_argument('--passphrase-entry-binary', type=str, default='pinentry',
+                   help='Path to passphrase entry UI helper.')
+    p.add_argument('--cache-expiry-seconds', type=float, default=float('inf'),
+                   help='Expire passphrase from cache after this duration.')
+
+    p.set_defaults(func=run_init)
+
+    p = subparsers.add_parser('unlock', help='unlock the hardware device')
     p.add_argument('-v', '--verbose', default=0, action='count')
     p.set_defaults(func=run_unlock)
 
     args = parser.parse_args()
+    device_type.ui = device.ui.UI(device_type=device_type, config=vars(args))
+
     return args.func(device_type=device_type, args=args)

libagent/gpg/agent.py

@@ -2,8 +2,8 @@
 import binascii
 import logging
 
-from . import client, decode, keyring, protocol
 from .. import util
+from . import client, decode, keyring, protocol
 
 log = logging.getLogger(__name__)
 
@@ -21,25 +21,17 @@ def yield_connections(sock):
         yield conn
 
 
-def serialize(data):
-    """Serialize data according to ASSUAN protocol."""
-    for c in [b'%', b'\n', b'\r']:
-        escaped = '%{:02X}'.format(ord(c)).encode('ascii')
-        data = data.replace(c, escaped)
-    return data
-
-
 def sig_encode(r, s):
     """Serialize ECDSA signature data into GPG S-expression."""
-    r = serialize(util.num2bytes(r, 32))
-    s = serialize(util.num2bytes(s, 32))
+    r = util.assuan_serialize(util.num2bytes(r, 32))
+    s = util.assuan_serialize(util.num2bytes(s, 32))
     return b'(7:sig-val(5:ecdsa(1:r32:' + r + b')(1:s32:' + s + b')))'
 
 
 def _serialize_point(data):
     prefix = '{}:'.format(len(data)).encode('ascii')
     # https://www.gnupg.org/documentation/manuals/assuan/Server-responses.html
-    return b'(5:value' + serialize(prefix + data) + b')'
+    return b'(5:value' + util.assuan_serialize(prefix + data) + b')'
 
 
 def parse_ecdh(line):
@@ -57,6 +49,18 @@ def parse_ecdh(line):
     return dict(items)[b'e']
 
 
+def _key_info(conn, args):
+    """
+    Dummy reply (mainly for 'gpg --edit' to succeed).
+
+    For details, see GnuPG agent KEYINFO command help.
+    https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=blob;f=agent/command.c;h=c8b34e9882076b1b724346787781f657cac75499;hb=refs/heads/master#l1082
+    """
+    fmt = 'S KEYINFO {0} X - - - - - - -'
+    keygrip, = args
+    keyring.sendline(conn, fmt.format(keygrip).encode('ascii'))
+
+
 class AgentError(Exception):
     """GnuPG agent-related error."""
 
@@ -65,37 +69,79 @@ class AgentStop(Exception):
     """Raised to close the agent."""
 
 
-class Handler(object):
+# pylint: disable=too-many-instance-attributes
+class Handler:
     """GPG agent requests' handler."""
 
-    def __init__(self, device):
+    def _get_options(self):
+        return self.options
+
+    def __init__(self, device, pubkey_bytes):
         """C-tor."""
+        self.reset()
+        self.options = []
+        device.ui.options_getter = self._get_options
         self.client = client.Client(device=device)
-        # Cache ASSUAN commands' arguments between commands
-        self.keygrip = None
-        self.digest = None
-        self.algo = None
         # Cache public keys from GnuPG
-        self.pubkey_bytes = keyring.export_public_keys()
+        self.pubkey_bytes = pubkey_bytes
         # "Clone" existing GPG version
         self.version = keyring.gpg_version()
 
         self.handlers = {
-            b'RESET': None,
-            b'OPTION': None,
+            b'RESET': lambda *_: self.reset(),
+            b'OPTION': lambda _, args: self.handle_option(*args),
             b'SETKEYDESC': None,
-            b'GETINFO': lambda conn, _: keyring.sendline(conn, b'D ' + self.version),
+            b'NOP': None,
+            b'GETINFO': self.handle_getinfo,
             b'AGENT_ID': lambda conn, _: keyring.sendline(conn, b'D TREZOR'),  # "Fake" agent ID
             b'SIGKEY': lambda _, args: self.set_key(*args),
             b'SETKEY': lambda _, args: self.set_key(*args),
             b'SETHASH': lambda _, args: self.set_hash(*args),
             b'PKSIGN': lambda conn, _: self.pksign(conn),
             b'PKDECRYPT': lambda conn, _: self.pkdecrypt(conn),
-            b'HAVEKEY': lambda _, args: self.have_key(*args),
-            b'KEYINFO': lambda conn, _: self.key_info(conn),
+            b'HAVEKEY': lambda conn, args: self.have_key(conn, *args),
+            b'KEYINFO': _key_info,
             b'SCD': self.handle_scd,
+            b'GET_PASSPHRASE': self.handle_get_passphrase,
         }
 
+    def reset(self):
+        """Reset agent's state variables."""
+        self.keygrip = None
+        self.digest = None
+        self.algo = None
+
+    def handle_option(self, opt):
+        """Store GPG agent-related options (e.g. for pinentry)."""
+        self.options.append(opt)
+        log.debug('options: %s', self.options)
+
+    def handle_get_passphrase(self, conn, _):
+        """Allow simple GPG symmetric encryption (using a passphrase)."""
+        p1 = self.client.device.ui.get_passphrase('Symmetric encryption:')
+        p2 = self.client.device.ui.get_passphrase('Re-enter encryption:')
+        if p1 == p2:
+            result = b'D ' + util.assuan_serialize(p1.encode('ascii'))
+            keyring.sendline(conn, result, confidential=True)
+        else:
+            log.warning('Passphrase does not match!')
+
+    def handle_getinfo(self, conn, args):
+        """Handle some of the GETINFO messages."""
+        result = None
+        if args[0] == b'version':
+            result = self.version
+        elif args[0] == b's2k_count':
+            # Use highest number of S2K iterations.
+            # https://www.gnupg.org/documentation/manuals/gnupg/OpenPGP-Options.html
+            # https://tools.ietf.org/html/rfc4880#section-3.7.1.3
+            result = '{}'.format(64 << 20).encode('ascii')
+        else:
+            log.warning('Unknown GETINFO command: %s', args)
+
+        if result:
+            keyring.sendline(conn, b'D ' + result)
+
     def handle_scd(self, conn, args):
         """No support for smart-card device protocol."""
         reply = {
@@ -105,7 +151,7 @@ class Handler(object):
             raise AgentError(b'ERR 100696144 No such device <SCD>')
         keyring.sendline(conn, b'D ' + reply)
 
-    @util.memoize
+    @util.memoize_method  # global cache for key grips
     def get_identity(self, keygrip):
         """
         Returns device.interface.Identity that matches specified keygrip.
@@ -152,25 +198,25 @@ class Handler(object):
         ec_point = self.client.ecdh(identity=identity, pubkey=remote_pubkey)
         keyring.sendline(conn, b'D ' + _serialize_point(ec_point))
 
-    @util.memoize
-    def have_key(self, *keygrips):
-        """Check if current keygrip correspond to a TREZOR-based key."""
-        try:
-            self.get_identity(keygrip=keygrips[0])
-        except KeyError as e:
-            log.warning('HAVEKEY(%s) failed: %s', keygrips, e)
+    def have_key(self, conn, *keygrips):
+        """Check if any keygrip corresponds to a TREZOR-based key."""
+        if len(keygrips) == 1 and keygrips[0].startswith(b"--list="):
+            # Support "fast-path" key listing:
+            # https://dev.gnupg.org/rG40da61b89b62dcb77847dc79eb159e885f52f817
+            keygrips = list(decode.iter_keygrips(pubkey_bytes=self.pubkey_bytes))
+            log.debug('keygrips: %r', keygrips)
+            keyring.sendline(conn, b'D ' + util.assuan_serialize(b''.join(keygrips)))
+            return
+
+        for keygrip in keygrips:
+            try:
+                self.get_identity(keygrip=keygrip)
+                break
+            except KeyError as e:
+                log.warning('HAVEKEY(%s) failed: %s', keygrip, e)
+        else:
             raise AgentError(b'ERR 67108881 No secret key <GPG Agent>')
 
-    def key_info(self, conn):
-        """
-        Dummy reply (mainly for 'gpg --edit' to succeed).
-
-        For details, see GnuPG agent KEYINFO command help.
-        https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=blob;f=agent/command.c;h=c8b34e9882076b1b724346787781f657cac75499;hb=refs/heads/master#l1082
-        """
-        fmt = 'S KEYINFO {0} X - - - - - - -'
-        keyring.sendline(conn, fmt.format(self.keygrip).encode('ascii'))
-
     def set_key(self, keygrip):
         """Set hexadecimal keygrip for next operation."""
         self.keygrip = keygrip

libagent/gpg/client.py

@@ -15,7 +15,7 @@ def create_identity(user_id, curve_name):
     return result
 
 
-class Client(object):
+class Client:
     """Sign messages and get public keys from a hardware device."""
 
     def __init__(self, device):
@@ -25,14 +25,12 @@ class Client(object):
     def pubkey(self, identity, ecdh=False):
         """Return public key as VerifyingKey object."""
         with self.device:
-            pubkey = self.device.pubkey(ecdh=ecdh, identity=identity)
-        return formats.decompress_pubkey(
-            pubkey=pubkey, curve_name=identity.curve_name)
+            return self.device.pubkey(ecdh=ecdh, identity=identity)
 
     def sign(self, identity, digest):
         """Sign the digest and return a serialized signature."""
         log.info('please confirm GPG signature on %s for "%s"...',
-                 self.device, identity)
+                 self.device, identity.to_string())
         if identity.curve_name == formats.CURVE_NIST256:
             digest = digest[:32]  # sign the first 256 bits
         log.debug('signing digest: %s', util.hexlify(digest))
@@ -43,6 +41,6 @@ class Client(object):
     def ecdh(self, identity, pubkey):
         """Derive shared secret using ECDH from remote public key."""
         log.info('please confirm GPG decryption on %s for "%s"...',
-                 self.device, identity)
+                 self.device, identity.to_string())
         with self.device:
             return self.device.ecdh(pubkey=pubkey, identity=identity)

libagent/gpg/decode.py

@@ -7,10 +7,10 @@ import logging
 import struct
 
 import ecdsa
-import ed25519
+import nacl.signing
 
-from . import protocol
 from .. import util
+from . import protocol
 
 log = logging.getLogger(__name__)
 
@@ -67,7 +67,8 @@ def _parse_ed25519_pubkey(mpi):
     prefix, value = util.split_bits(mpi, 8, 256)
     if prefix != 0x40:
         raise ValueError('Invalid MPI prefix: {}'.format(prefix))
-    return ed25519.VerifyingKey(util.num2bytes(value, size=32))
+    vk = nacl.signing.VerifyKey(util.num2bytes(value, size=32), encoder=nacl.encoding.RawEncoder)
+    return vk
 
 
 SUPPORTED_CURVES = {
@@ -186,6 +187,7 @@ def _parse_pubkey(stream, packet_type='pubkey'):
     log.debug('key ID: %s', util.hexlify(p['key_id']))
     return p
 
+
 _parse_subkey = functools.partial(_parse_pubkey, packet_type='subkey')
 
 
@@ -195,6 +197,7 @@ def _parse_user_id(stream, packet_type='user_id'):
     to_hash = b'\xb4' + util.prefix_len('>L', value)
     return {'type': packet_type, 'value': value, '_to_hash': to_hash}
 
+
 # User attribute is handled as an opaque user ID
 _parse_attribute = functools.partial(_parse_user_id,
                                      packet_type='user_attribute')
@@ -279,18 +282,20 @@ HASH_ALGORITHMS = {
 }
 
 
-def load_by_keygrip(pubkey_bytes, keygrip):
-    """Return public key and first user ID for specified keygrip."""
+def _parse_pubkey_packets(pubkey_bytes):
     stream = io.BytesIO(pubkey_bytes)
-    packets = list(parse_packets(stream))
     packets_per_pubkey = []
-    for p in packets:
+    for p in parse_packets(stream):
         if p['type'] == 'pubkey':
             # Add a new packet list for each pubkey.
             packets_per_pubkey.append([])
         packets_per_pubkey[-1].append(p)
+    return packets_per_pubkey
 
-    for packets in packets_per_pubkey:
+
+def load_by_keygrip(pubkey_bytes, keygrip):
+    """Return public key and first user ID for specified keygrip."""
+    for packets in _parse_pubkey_packets(pubkey_bytes):
         user_ids = [p for p in packets if p['type'] == 'user_id']
         for p in packets:
             if p.get('keygrip') == keygrip:
@@ -298,6 +303,15 @@ def load_by_keygrip(pubkey_bytes, keygrip):
     raise KeyError('{} keygrip not found'.format(util.hexlify(keygrip)))
 
 
+def iter_keygrips(pubkey_bytes):
+    """Iterate over all keygrips in this pubkey."""
+    for packets in _parse_pubkey_packets(pubkey_bytes):
+        for p in packets:
+            keygrip = p.get('keygrip')
+            if keygrip:
+                yield keygrip
+
+
 def load_signature(stream, original_data):
     """Load signature from stream, and compute GPG digest for verification."""
     signature, = list(parse_packets((stream)))

libagent/gpg/encode.py

@@ -2,8 +2,8 @@
 import io
 import logging
 
-from . import decode, keyring, protocol
 from .. import util
+from . import decode, keyring, protocol
 
 log = logging.getLogger(__name__)
 
@@ -23,12 +23,14 @@ def create_primary(user_id, pubkey, signer_func, secret_bytes=b''):
         # https://tools.ietf.org/html/rfc4880#section-5.2.3.4
         protocol.subpacket_byte(0x1B, 1 | 2),  # key flags (certify & sign)
         # https://tools.ietf.org/html/rfc4880#section-5.2.3.21
-        protocol.subpacket_byte(0x15, 8),  # preferred hash (SHA256)
+        protocol.subpacket_bytes(0x15, [8, 9, 10]),  # preferred hash
         # https://tools.ietf.org/html/rfc4880#section-5.2.3.8
-        protocol.subpacket_byte(0x16, 0),  # preferred compression (none)
+        protocol.subpacket_bytes(0x16, [2, 3, 1]),  # preferred compression
         # https://tools.ietf.org/html/rfc4880#section-5.2.3.9
-        protocol.subpacket_byte(0x17, 0x80)  # key server prefs (no-modify)
+        protocol.subpacket_byte(0x17, 0x80),  # key server prefs (no-modify)
         # https://tools.ietf.org/html/rfc4880#section-5.2.3.17
+        protocol.subpacket_byte(0x1E, 0x01),  # advanced features (MDC)
+        # https://tools.ietf.org/html/rfc4880#section-5.2.3.24
     ]
     unhashed_subpackets = [
         protocol.subpacket(16, pubkey.key_id()),  # issuer key id

libagent/gpg/keyring.py

@@ -14,17 +14,32 @@ from .. import util
 log = logging.getLogger(__name__)
 
 
-def get_agent_sock_path(sp=subprocess):
+def check_output(args, env=None, sp=subprocess):
+    """Call an external binary and return its stdout."""
+    log.debug('calling %s with env %s', args, env)
+    p = sp.Popen(args=args, env=env, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
+    (output, error) = p.communicate()
+    log.debug('output: %r', output)
+    if error:
+        log.debug('error: %r', error)
+    return output
+
+
+def get_agent_sock_path(env=None, sp=subprocess):
     """Parse gpgconf output to find out GPG agent UNIX socket path."""
-    lines = sp.check_output(['gpgconf', '--list-dirs']).strip().split(b'\n')
+    args = [util.which('gpgconf'), '--list-dirs']
+    output = check_output(args=args, env=env, sp=sp)
+    lines = output.strip().split(b'\n')
     dirs = dict(line.split(b':', 1) for line in lines)
+    log.debug('%s: %s', args, dirs)
     return dirs[b'agent-socket']
 
 
-def connect_to_agent(sp=subprocess):
+def connect_to_agent(env=None, sp=subprocess):
     """Connect to GPG agent's UNIX socket."""
-    sock_path = get_agent_sock_path(sp=sp)
-    sp.check_call(['gpg-connect-agent', '/bye'])  # Make sure it's running
+    sock_path = get_agent_sock_path(sp=sp, env=env)
+    # Make sure the original gpg-agent is running.
+    check_output(args=['gpg-connect-agent', '/bye'], sp=sp)
     sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     sock.connect(sock_path)
     return sock
@@ -36,9 +51,9 @@ def communicate(sock, msg):
     return recvline(sock)
 
 
-def sendline(sock, msg):
+def sendline(sock, msg, confidential=False):
     """Send a binary message, followed by EOL."""
-    log.debug('<- %r', msg)
+    log.debug('<- %r', ('<snip>' if confidential else msg))
     sock.sendall(msg + b'\n')
 
 
@@ -99,8 +114,8 @@ def parse(s):
             value, s = parse(s)
             values.append(value)
         return values, s[1:]
-    else:
-        return parse_term(s)
+
+    return parse_term(s)
 
 
 def _parse_ecdsa_sig(args):
@@ -110,6 +125,7 @@ def _parse_ecdsa_sig(args):
     return (util.bytes2num(sig_r),
             util.bytes2num(sig_s))
 
+
 # DSA and EDDSA happen to have the same structure as ECDSA signatures
 _parse_dsa_sig = _parse_ecdsa_sig
 _parse_eddsa_sig = _parse_ecdsa_sig
@@ -140,7 +156,7 @@ def sign_digest(sock, keygrip, digest, sp=subprocess, environ=None):
 
     assert communicate(sock, 'RESET').startswith(b'OK')
 
-    ttyname = sp.check_output(['tty']).strip()
+    ttyname = check_output(args=['tty'], sp=sp).strip()
     options = ['ttyname={}'.format(ttyname)]  # set TTY for passphrase entry
 
     display = (environ or os.environ).get('DISPLAY')
@@ -160,9 +176,7 @@ def sign_digest(sock, keygrip, digest, sp=subprocess, environ=None):
     assert communicate(sock, 'PKSIGN') == b'OK'
     while True:
         line = recvline(sock).strip()
-        if line.startswith(b'S PROGRESS'):
-            continue
-        else:
+        if not line.startswith(b'S PROGRESS'):
             break
     line = unescape(line)
     log.debug('unescaped: %r', line)
@@ -175,51 +189,70 @@ def sign_digest(sock, keygrip, digest, sp=subprocess, environ=None):
     return parse_sig(sig)
 
 
+def get_gnupg_components(sp=subprocess):
+    """Parse GnuPG components' paths."""
+    args = [util.which('gpgconf'), '--list-components']
+    output = check_output(args=args, sp=sp)
+    components = dict(re.findall('(.*):.*:(.*)', output.decode('utf-8')))
+    log.debug('gpgconf --list-components: %s', components)
+    return components
+
+
+@util.memoize
+def get_gnupg_binary(sp=subprocess, neopg_binary=None):
+    """Starting GnuPG 2.2.x, the default installation uses `gpg`."""
+    if neopg_binary:
+        return neopg_binary
+    return get_gnupg_components(sp=sp)['gpg']
+
+
 def gpg_command(args, env=None):
     """Prepare common GPG command line arguments."""
     if env is None:
         env = os.environ
-    cmd = ['gpg2']
-    homedir = env.get('GNUPGHOME')
-    if homedir:
-        cmd.extend(['--homedir', homedir])
-    return cmd + args
+    cmd = get_gnupg_binary(neopg_binary=env.get('NEOPG_BINARY'))
+    return [cmd] + args
 
 
 def get_keygrip(user_id, sp=subprocess):
     """Get a keygrip of the primary GPG key of the specified user."""
     args = gpg_command(['--list-keys', '--with-keygrip', user_id])
-    output = sp.check_output(args).decode('ascii')
+    output = check_output(args=args, sp=sp).decode('utf-8')
     return re.findall(r'Keygrip = (\w+)', output)[0]
 
 
 def gpg_version(sp=subprocess):
     """Get a keygrip of the primary GPG key of the specified user."""
     args = gpg_command(['--version'])
-    output = sp.check_output(args)
-    line = output.split(b'\n')[0]  # b'gpg (GnuPG) 2.1.11'
-    return line.split(b' ')[-1]  # b'2.1.11'
+    output = check_output(args=args, sp=sp)
+    line = output.split(b'\n', maxsplit=1)[0]  # b'gpg (GnuPG) 2.1.11'
+    line = line.split(b' ')[-1]  # b'2.1.11'
+    line = line.split(b'-')[0]  # remove trailing version parts
+    return line.split(b'v')[-1]  # remove 'v' prefix
 
 
-def export_public_key(user_id, sp=subprocess):
+def export_public_key(user_id, env=None, sp=subprocess):
     """Export GPG public key for specified `user_id`."""
     args = gpg_command(['--export', user_id])
-    result = sp.check_output(args=args)
+    result = check_output(args=args, env=env, sp=sp)
     if not result:
         log.error('could not find public key %r in local GPG keyring', user_id)
         raise KeyError(user_id)
     return result
 
 
-def export_public_keys(sp=subprocess):
+def export_public_keys(env=None, sp=subprocess):
     """Export all GPG public keys."""
     args = gpg_command(['--export'])
-    return sp.check_output(args=args)
+    result = check_output(args=args, env=env, sp=sp)
+    if not result:
+        raise KeyError('No GPG public keys found at env: {!r}'.format(env))
+    return result
 
 
 def create_agent_signer(user_id):
     """Sign digest with existing GPG keys using gpg-agent tool."""
-    sock = connect_to_agent()
+    sock = connect_to_agent(env=os.environ)
     keygrip = get_keygrip(user_id)
 
     def sign(digest):

libagent/gpg/protocol.py

@@ -5,6 +5,8 @@ import hashlib
 import logging
 import struct
 
+import nacl.signing
+
 from .. import formats, util
 
 log = logging.getLogger(__name__)
@@ -47,6 +49,11 @@ def subpacket_byte(subpacket_type, value):
     return subpacket(subpacket_type, '>B', value)
 
 
+def subpacket_bytes(subpacket_type, values):
+    """Create GPG subpacket with 8-bit unsigned integers."""
+    return subpacket(subpacket_type, '>' + 'B'*len(values), *values)
+
+
 def subpacket_prefix_len(item):
     """Prefix subpacket length according to RFC 4880 section-5.2.3.1."""
     n = len(item)
@@ -87,7 +94,7 @@ def _serialize_nist256(vk):
 
 def _serialize_ed25519(vk):
     return mpi((0x40 << 256) |
-               util.bytes2num(vk.to_bytes()))
+               util.bytes2num(vk.encode(encoder=nacl.encoding.RawEncoder)))
 
 
 def _compute_keygrip(params):
@@ -126,7 +133,7 @@ def keygrip_ed25519(vk):
         ['b', util.num2bytes(0x2DFC9311D490018C7338BF8688861767FF8FF5B2BEBE27548A14B235ECA6874A, size=32)],  # nopep8
         ['g', util.num2bytes(0x04216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A6666666666666666666666666666666666666666666666666666666666666658, size=65)],  # nopep8
         ['n', util.num2bytes(0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED, size=32)],  # nopep8
-        ['q', vk.to_bytes()],
+        ['q', vk.encode(encoder=nacl.encoding.RawEncoder)],
     ])
 
 
@@ -139,7 +146,7 @@ def keygrip_curve25519(vk):
         ['b', b'\x01'],
         ['g', util.num2bytes(0x04000000000000000000000000000000000000000000000000000000000000000920ae19a1b8a086b4e01edd2c7748d14c923d4d7e6d7c61b229e9c5a27eced3d9, size=65)],  # nopep8
         ['n', util.num2bytes(0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED, size=32)],  # nopep8
-        ['q', vk.to_bytes()],
+        ['q', vk.encode(encoder=nacl.encoding.RawEncoder)],
     ])
 
 
@@ -180,7 +187,7 @@ def get_curve_name_by_oid(oid):
     raise KeyError('Unknown OID: {!r}'.format(oid))
 
 
-class PublicKey(object):
+class PublicKey:
     """GPG representation for public key packets."""
 
     def __init__(self, curve_name, created, verifying_key, ecdh=False):

libagent/gpg/tests/test_agent.py

@@ -0,0 +1,11 @@
+from .. import agent
+
+
+def test_sig_encode():
+    SIG = (
+        b'(7:sig-val(5:ecdsa(1:r32:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+        b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+        b'\x00\x00\x00\x00\x0c)(1:s32:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+        b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+        b'\x00\x00\x00\x00")))')
+    assert agent.sig_encode(12, 34) == SIG

libagent/gpg/tests/test_decode.py

@@ -1,11 +1,10 @@
-import glob
 import io
-import os
+import pathlib
 
 import pytest
 
-from .. import decode, protocol
 from ... import util
+from .. import decode, protocol
 
 
 def test_subpackets():
@@ -30,8 +29,8 @@ def test_mpi():
     assert decode.parse_mpis(util.Reader(s), n=2) == [0x123, 5]
 
 
-cwd = os.path.join(os.path.dirname(__file__))
-input_files = glob.glob(os.path.join(cwd, '*.gpg'))
+cwd = pathlib.Path(__file__).parent
+input_files = cwd.glob('*.gpg')
 
 
 @pytest.fixture(params=input_files)
@@ -60,3 +59,20 @@ def test_has_custom_subpacket():
 def test_load_by_keygrip_missing():
     with pytest.raises(KeyError):
         decode.load_by_keygrip(pubkey_bytes=b'', keygrip=b'')
+
+
+def test_keygrips():
+    pubkey_bytes = (cwd / "romanz-pubkey.gpg").open("rb").read()
+    keygrips = list(decode.iter_keygrips(pubkey_bytes))
+    assert [k.hex() for k in keygrips] == [
+        '7b2497258d76bc6539ed88d018cd1c739e2dbb6c',
+        '30ae97f3d8e0e34c5ed80e1715fd442ca24c0a8e',
+    ]
+
+    for keygrip in keygrips:
+        pubkey_dict, user_ids = decode.load_by_keygrip(pubkey_bytes, keygrip)
+        assert pubkey_dict['keygrip'] == keygrip
+        assert [u['value'] for u in user_ids] == [
+            b'Roman Zeyde <roman.zeyde@gmail.com>',
+            b'Roman Zeyde <me@romanzey.de>',
+        ]

libagent/gpg/tests/test_keyring.py

@@ -41,7 +41,7 @@ def test_parse_rsa():
     assert keyring.parse_sig(sig) == (0x1020304,)
 
 
-class FakeSocket(object):
+class FakeSocket:
     def __init__(self):
         self.rx = io.BytesIO()
         self.tx = io.BytesIO()
@@ -53,6 +53,14 @@ class FakeSocket(object):
         self.tx.write(data)
 
 
+def mock_subprocess(output, error=b''):
+    sp = mock.Mock(spec=['Popen', 'PIPE'])
+    p = mock.Mock(spec=['communicate'])
+    sp.Popen.return_value = p
+    p.communicate.return_value = (output, error)
+    return sp
+
+
 def test_sign_digest():
     sock = FakeSocket()
     sock.rx.write(b'OK Pleased to meet you, process XYZ\n')
@@ -61,10 +69,8 @@ def test_sign_digest():
     sock.rx.seek(0)
     keygrip = '1234'
     digest = b'A' * 32
-    sp = mock.Mock(spec=['check_output'])
-    sp.check_output.return_value = '/dev/pts/0'
     sig = keyring.sign_digest(sock=sock, keygrip=keygrip,
-                              digest=digest, sp=sp,
+                              digest=digest, sp=mock_subprocess('/dev/pts/0'),
                               environ={'DISPLAY': ':0'})
     assert sig == (0x30313233343536373839414243444546,)
     assert sock.tx.getvalue() == b'''RESET
@@ -85,8 +91,7 @@ def test_iterlines():
 
 
 def test_get_agent_sock_path():
-    sp = mock.Mock(spec=['check_output'])
-    sp.check_output.return_value = b'''sysconfdir:/usr/local/etc/gnupg
+    sp = mock_subprocess(b'''sysconfdir:/usr/local/etc/gnupg
 bindir:/usr/local/bin
 libexecdir:/usr/local/libexec
 libdir:/usr/local/lib/gnupg
@@ -96,6 +101,6 @@ dirmngr-socket:/run/user/1000/gnupg/S.dirmngr
 agent-ssh-socket:/run/user/1000/gnupg/S.gpg-agent.ssh
 agent-socket:/run/user/1000/gnupg/S.gpg-agent
 homedir:/home/roman/.gnupg
-'''
+''')
     expected = b'/run/user/1000/gnupg/S.gpg-agent'
     assert keyring.get_agent_sock_path(sp=sp) == expected

libagent/gpg/tests/test_protocol.py

@@ -1,9 +1,9 @@
 import ecdsa
-import ed25519
+import nacl.signing
 import pytest
 
-from .. import protocol
 from ... import formats
+from .. import protocol
 
 
 def test_packet():
@@ -83,8 +83,8 @@ def test_nist256p1_ecdh():
 
 
 def test_ed25519():
-    sk = ed25519.SigningKey(b'\x00' * 32)
-    vk = sk.get_verifying_key()
+    sk = nacl.signing.SigningKey(b'\x00'*32, encoder=nacl.encoding.RawEncoder)
+    vk = sk.verify_key
     pk = protocol.PublicKey(curve_name=formats.CURVE_ED25519,
                             created=42, verifying_key=vk)
     assert repr(pk) == 'GPG public key ed25519/36B40FE6'
@@ -92,8 +92,8 @@ def test_ed25519():
 
 
 def test_curve25519():
-    sk = ed25519.SigningKey(b'\x00' * 32)
-    vk = sk.get_verifying_key()
+    sk = nacl.signing.SigningKey(b'\x00'*32, encoder=nacl.encoding.RawEncoder)
+    vk = sk.verify_key
     pk = protocol.PublicKey(curve_name=formats.ECDH_CURVE25519,
                             created=42, verifying_key=vk)
     assert repr(pk) == 'GPG public key curve25519/69460384'

libagent/server.py

@@ -39,6 +39,43 @@ def unix_domain_socket_server(sock_path):
         remove_file(sock_path)
 
 
+class FDServer:
+    """File-descriptor based server (for NeoPG)."""
+
+    def __init__(self, fd):
+        """C-tor."""
+        self.fd = fd
+        self.sock = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
+
+    def accept(self):
+        """Use the same socket for I/O."""
+        return self, None
+
+    def recv(self, n):
+        """Forward to underlying socket."""
+        return self.sock.recv(n)
+
+    def sendall(self, data):
+        """Forward to underlying socket."""
+        return self.sock.sendall(data)
+
+    def close(self):
+        """Not needed."""
+
+    def settimeout(self, _):
+        """Not needed."""
+
+    def getsockname(self):
+        """Simple representation."""
+        return '<fd: {}>'.format(self.fd)
+
+
+@contextlib.contextmanager
+def unix_domain_socket_server_from_fd(fd):
+    """Build UDS-based socket server from a file descriptor."""
+    yield FDServer(fd)
+
+
 def handle_connection(conn, handler, mutex):
     """
     Handle a single connection using the specified protocol handler in a loop.
@@ -122,7 +159,7 @@ def run_process(command, environ):
     try:
         p = subprocess.Popen(args=command, env=env)
     except OSError as e:
-        raise OSError('cannot run %r: %s' % (command, e))
+        raise OSError('cannot run %r: %s' % (command, e)) from e
     log.debug('subprocess %d is running', p.pid)
     ret = p.wait()
     log.debug('subprocess %d exited: %d', p.pid, ret)

libagent/signify/__init__.py

@@ -0,0 +1,109 @@
+"""TREZOR support for Ed25519 signify signatures."""
+
+import argparse
+import binascii
+import contextlib
+import functools
+import hashlib
+import logging
+import os
+import re
+import struct
+import subprocess
+import sys
+import time
+
+import pkg_resources
+import semver
+
+from .. import formats, server, util
+from ..device import interface, ui
+
+log = logging.getLogger(__name__)
+
+
+def _create_identity(user_id):
+    result = interface.Identity(identity_str='signify://', curve_name='ed25519')
+    result.identity_dict['host'] = user_id
+    return result
+
+
+class Client:
+    """Sign messages and get public keys from a hardware device."""
+
+    def __init__(self, device):
+        """C-tor."""
+        self.device = device
+
+    def pubkey(self, identity):
+        """Return public key as VerifyingKey object."""
+        with self.device:
+            return bytes(self.device.pubkey(ecdh=False, identity=identity))
+
+    def sign_with_pubkey(self, identity, data):
+        """Sign the data and return a signature."""
+        log.info('please confirm Signify signature on %s for "%s"...',
+                 self.device, identity.to_string())
+        log.debug('signing data: %s', util.hexlify(data))
+        with self.device:
+            sig, pubkey = self.device.sign_with_pubkey(blob=data, identity=identity)
+            assert len(sig) == 64
+            assert len(pubkey) == 33
+            assert pubkey[:1] == b"\x00"
+            return sig, pubkey[1:]
+
+
+def format_payload(pubkey, data):
+    """See http://www.openbsd.org/papers/bsdcan-signify.html for details."""
+    keynum = hashlib.sha256(pubkey).digest()[:8]
+    return binascii.b2a_base64(b"Ed" + keynum + data).decode("ascii")
+
+
+def run_pubkey(device_type, args):
+    """Export hardware-based Signify public key."""
+    util.setup_logging(verbosity=args.verbose)
+    log.warning('This Signify tool is still in EXPERIMENTAL mode, '
+                'so please note that the key derivation, API, and features '
+                'may change without backwards compatibility!')
+
+    identity = _create_identity(user_id=args.user_id)
+    pubkey = Client(device=device_type()).pubkey(identity=identity)
+    comment = f'untrusted comment: identity {identity.to_string()}\n'
+    result = comment + format_payload(pubkey=pubkey, data=pubkey)
+    print(result, end="")
+
+
+def run_sign(device_type, args):
+    """Sign an input blob using Ed25519."""
+    util.setup_logging(verbosity=args.verbose)
+    identity = _create_identity(user_id=args.user_id)
+    data = sys.stdin.buffer.read()
+    sig, pubkey = Client(device=device_type()).sign_with_pubkey(identity, data)
+    pubkey_str = format_payload(pubkey=pubkey, data=pubkey)
+    comment = f'untrusted comment: pubkey {pubkey_str}'
+    result = comment + format_payload(pubkey=pubkey, data=sig)
+    print(result, end="")
+
+
+def main(device_type):
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser()
+
+    subparsers = parser.add_subparsers(title='Action', dest='action')
+    subparsers.required = True
+
+    p = subparsers.add_parser('pubkey')
+    p.add_argument('user_id')
+    p.add_argument('-v', '--verbose', default=0, action='count')
+    p.set_defaults(func=run_pubkey)
+
+    p = subparsers.add_parser('sign')
+    p.add_argument('user_id')
+    p.add_argument('-v', '--verbose', default=0, action='count')
+    p.set_defaults(func=run_sign)
+
+    args = parser.parse_args()
+    device_type.ui = ui.UI(device_type=device_type, config=vars(args))
+    device_type.ui.cached_passphrase_ack = util.ExpiringCache(seconds=float(60))
+
+    return args.func(device_type=device_type, args=args)

libagent/ssh/__init__.py

@@ -1,16 +1,19 @@
 """SSH-agent implementation using hardware authentication devices."""
-import argparse
 import contextlib
 import functools
 import io
 import logging
 import os
 import re
+import signal
 import subprocess
 import sys
 import tempfile
 import threading
 
+import configargparse
+import daemon
+import pkg_resources
 
 from .. import device, formats, server, util
 from . import client, protocol
@@ -20,9 +23,11 @@ log = logging.getLogger(__name__)
 UNIX_SOCKET_TIMEOUT = 0.1
 
 
-def ssh_args(label):
+def ssh_args(conn):
     """Create SSH command for connecting specified server."""
-    identity = device.interface.string_to_identity(label)
+    I, = conn.identities
+    identity = I.identity_dict
+    pubkey_tempfile, = conn.public_keys_as_files()
 
     args = []
     if 'port' in identity:
@@ -30,12 +35,15 @@ def ssh_args(label):
     if 'user' in identity:
         args += ['-l', identity['user']]
 
+    args += ['-o', 'IdentityFile={}'.format(pubkey_tempfile.name)]
+    args += ['-o', 'IdentitiesOnly=true']
     return args + [identity['host']]
 
 
-def mosh_args(label):
+def mosh_args(conn):
     """Create SSH command for connecting specified server."""
-    identity = device.interface.string_to_identity(label)
+    I, = conn.identities
+    identity = I.identity_dict
 
     args = []
     if 'port' in identity:
@@ -48,31 +56,63 @@ def mosh_args(label):
     return args
 
 
-def create_agent_parser():
+def _to_unicode(s):
+    try:
+        return unicode(s, 'utf-8')
+    except NameError:
+        return s
+
+
+def create_agent_parser(device_type):
     """Create an ArgumentParser for this tool."""
-    p = argparse.ArgumentParser()
+    epilog = ('See https://github.com/romanz/trezor-agent/blob/master/'
+              'doc/README-SSH.md for usage examples.')
+    p = configargparse.ArgParser(default_config_files=['~/.ssh/agent.config'],
+                                 epilog=epilog)
     p.add_argument('-v', '--verbose', default=0, action='count')
 
-    curve_names = [name for name in formats.SUPPORTED_CURVES]
-    curve_names = ', '.join(sorted(curve_names))
+    agent_package = device_type.package_name()
+    resources_map = {r.key: r for r in pkg_resources.require(agent_package)}
+    resources = [resources_map[agent_package], resources_map['libagent']]
+    versions = '\n'.join('{}={}'.format(r.key, r.version) for r in resources)
+    p.add_argument('--version', help='print the version info',
+                   action='version', version=versions)
+
+    curve_names = ', '.join(sorted(formats.SUPPORTED_CURVES))
     p.add_argument('-e', '--ecdsa-curve-name', metavar='CURVE',
                    default=formats.CURVE_NIST256,
                    help='specify ECDSA curve name: ' + curve_names)
     p.add_argument('--timeout',
                    default=UNIX_SOCKET_TIMEOUT, type=float,
-                   help='Timeout for accepting SSH client connections')
+                   help='timeout for accepting SSH client connections')
     p.add_argument('--debug', default=False, action='store_true',
-                   help='Log SSH protocol messages for debugging.')
+                   help='log SSH protocol messages for debugging.')
+    p.add_argument('--log-file', type=str,
+                   help='Path to the log file (to be written by the agent).')
+    p.add_argument('--sock-path', type=str,
+                   help='Path to the UNIX domain socket of the agent.')
+
+    p.add_argument('--pin-entry-binary', type=str, default='pinentry',
+                   help='Path to PIN entry UI helper.')
+    p.add_argument('--passphrase-entry-binary', type=str, default='pinentry',
+                   help='Path to passphrase entry UI helper.')
+    p.add_argument('--cache-expiry-seconds', type=float, default=float('inf'),
+                   help='Expire passphrase from cache after this duration.')
 
     g = p.add_mutually_exclusive_group()
+    g.add_argument('-d', '--daemonize', default=False, action='store_true',
+                   help='Daemonize the agent and print its UNIX socket path')
+    g.add_argument('-f', '--foreground', default=False, action='store_true',
+                   help='Run agent in foreground with specified UNIX socket path')
     g.add_argument('-s', '--shell', default=False, action='store_true',
-                   help='run ${SHELL} as subprocess under SSH agent')
+                   help=('run ${SHELL} as subprocess under SSH agent, allowing '
+                         'regular SSH-based tools to be used in the shell'))
     g.add_argument('-c', '--connect', default=False, action='store_true',
                    help='connect to specified host via SSH')
     g.add_argument('--mosh', default=False, action='store_true',
                    help='connect to specified host via using Mosh')
 
-    p.add_argument('identity', type=str, default=None,
+    p.add_argument('identity', type=_to_unicode, default=None,
                    help='proto://[user@]host[:port][/path]')
     p.add_argument('command', type=str, nargs='*', metavar='ARGUMENT',
                    help='command to run under the SSH agent')
@@ -80,7 +120,7 @@ def create_agent_parser():
 
 
 @contextlib.contextmanager
-def serve(handler, sock_path=None, timeout=UNIX_SOCKET_TIMEOUT):
+def serve(handler, sock_path, timeout=UNIX_SOCKET_TIMEOUT):
     """
     Start the ssh-agent server on a UNIX-domain socket.
 
@@ -90,9 +130,6 @@ def serve(handler, sock_path=None, timeout=UNIX_SOCKET_TIMEOUT):
     ssh_version = subprocess.check_output(['ssh', '-V'],
                                           stderr=subprocess.STDOUT)
     log.debug('local SSH version: %r', ssh_version)
-    if sock_path is None:
-        sock_path = tempfile.mktemp(prefix='trezor-ssh-agent-')
-
     environ = {'SSH_AUTH_SOCK': sock_path, 'SSH_AGENT_PID': str(os.getpid())}
     device_mutex = threading.Lock()
     with server.unix_domain_socket_server(sock_path) as sock:
@@ -112,14 +149,20 @@ def serve(handler, sock_path=None, timeout=UNIX_SOCKET_TIMEOUT):
                 quit_event.set()
 
 
-def run_server(conn, command, debug, timeout):
+def run_server(conn, command, sock_path, debug, timeout):
     """Common code for run_agent and run_git below."""
+    ret = 0
     try:
         handler = protocol.Handler(conn=conn, debug=debug)
-        with serve(handler=handler, timeout=timeout) as env:
-            return server.run_process(command=command, environ=env)
+        with serve(handler=handler, sock_path=sock_path,
+                   timeout=timeout) as env:
+            if command:
+                ret = server.run_process(command=command, environ=env)
+            else:
+                signal.pause()  # wait for signal (e.g. SIGINT)
     except KeyboardInterrupt:
         log.info('server stopped')
+    return ret
 
 
 def handle_connection_error(func):
@@ -128,7 +171,7 @@ def handle_connection_error(func):
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
-        except IOError as e:
+        except device.interface.NotFoundError as e:
             log.error('Connection error (try unplugging and replugging your device): %s', e)
             return 1
     return wrapper
@@ -149,7 +192,7 @@ def import_public_keys(contents):
         yield line
 
 
-class JustInTimeConnection(object):
+class JustInTimeConnection:
     """Connect to the device just before the needed operation."""
 
     def __init__(self, conn_factory, identities, public_keys=None):
@@ -157,6 +200,7 @@ class JustInTimeConnection(object):
         self.conn_factory = conn_factory
         self.identities = identities
         self.public_keys_cache = public_keys
+        self.public_keys_tempfiles = []
 
     def public_keys(self):
         """Return a list of SSH public keys (in textual format)."""
@@ -173,19 +217,47 @@ class JustInTimeConnection(object):
             pk['identity'] = identity
         return public_keys
 
+    def public_keys_as_files(self):
+        """Store public keys as temporary SSH identity files."""
+        if not self.public_keys_tempfiles:
+            for pk in self.public_keys():
+                f = tempfile.NamedTemporaryFile(prefix='trezor-ssh-pubkey-', mode='w')
+                f.write(pk)
+                f.flush()
+                self.public_keys_tempfiles.append(f)
+
+        return self.public_keys_tempfiles
+
     def sign(self, blob, identity):
         """Sign a given blob using the specified identity on the device."""
         conn = self.conn_factory()
         return conn.sign_ssh_challenge(blob=blob, identity=identity)
 
 
+@contextlib.contextmanager
+def _dummy_context():
+    yield
+
+
+def _get_sock_path(args):
+    sock_path = args.sock_path
+    if not sock_path:
+        if args.foreground:
+            log.error('running in foreground mode requires specifying UNIX socket path')
+            sys.exit(1)
+        else:
+            sock_path = tempfile.mktemp(prefix='trezor-ssh-agent-')
+    return sock_path
+
+
 @handle_connection_error
 def main(device_type):
     """Run ssh-agent using given hardware client factory."""
-    args = create_agent_parser().parse_args()
-    util.setup_logging(verbosity=args.verbose)
+    args = create_agent_parser(device_type=device_type).parse_args()
+    util.setup_logging(verbosity=args.verbose, filename=args.log_file)
 
     public_keys = None
+    filename = None
     if args.identity.startswith('/'):
         filename = args.identity
         contents = open(filename, 'rb').read().decode('utf-8')
@@ -198,25 +270,41 @@ def main(device_type):
             identity_str=args.identity, curve_name=args.ecdsa_curve_name)]
     for index, identity in enumerate(identities):
         identity.identity_dict['proto'] = 'ssh'
-        log.info('identity #%d: %s', index, identity)
+        log.info('identity #%d: %s', index, identity.to_string())
 
-    if args.connect:
-        command = ['ssh'] + ssh_args(args.identity) + args.command
-    elif args.mosh:
-        command = ['mosh'] + mosh_args(args.identity) + args.command
-    else:
-        command = args.command
-
-    use_shell = bool(args.shell)
-    if use_shell:
-        command = os.environ['SHELL']
+    # override default PIN/passphrase entry tools (relevant for TREZOR/Keepkey):
+    device_type.ui = device.ui.UI(device_type=device_type, config=vars(args))
 
     conn = JustInTimeConnection(
         conn_factory=lambda: client.Client(device_type()),
         identities=identities, public_keys=public_keys)
-    if command:
-        return run_server(conn=conn, command=command, debug=args.debug,
-                          timeout=args.timeout)
+
+    sock_path = _get_sock_path(args)
+    command = args.command
+    context = _dummy_context()
+    if args.connect:
+        command = ['ssh'] + ssh_args(conn) + args.command
+    elif args.mosh:
+        command = ['mosh'] + mosh_args(conn) + args.command
+    elif args.daemonize:
+        out = 'SSH_AUTH_SOCK={0}; export SSH_AUTH_SOCK;\n'.format(sock_path)
+        sys.stdout.write(out)
+        sys.stdout.flush()
+        context = daemon.DaemonContext()
+        log.info('running the agent as a daemon on %s', sock_path)
+    elif args.foreground:
+        log.info('running the agent on %s', sock_path)
+
+    use_shell = bool(args.shell)
+    if use_shell:
+        command = os.environ['SHELL']
+        sys.stdin.close()
+
+    if command or args.daemonize or args.foreground:
+        with context:
+            return run_server(conn=conn, command=command, sock_path=sock_path,
+                              debug=args.debug, timeout=args.timeout)
     else:
         for pk in conn.public_keys():
             sys.stdout.write(pk)
+        return 0  # success exit code

libagent/ssh/client.py

@@ -11,7 +11,7 @@ from . import formats, util
 log = logging.getLogger(__name__)
 
 
-class Client(object):
+class Client:
     """Client wrapper for SSH authentication device."""
 
     def __init__(self, device):
@@ -20,15 +20,14 @@ class Client(object):
 
     def export_public_keys(self, identities):
         """Export SSH public keys from the device."""
-        public_keys = []
+        pubkeys = []
         with self.device:
             for i in identities:
-                pubkey = self.device.pubkey(identity=i)
-                vk = formats.decompress_pubkey(pubkey=pubkey,
-                                               curve_name=i.curve_name)
-                public_keys.append(formats.export_public_key(vk=vk,
-                                                             label=str(i)))
-        return public_keys
+                vk = self.device.pubkey(identity=i)
+                label = i.to_string()
+                pubkey = formats.export_public_key(vk=vk, label=label)
+                pubkeys.append(pubkey)
+        return pubkeys
 
     def sign_ssh_challenge(self, blob, identity):
         """Sign given blob using a private key on the device."""
@@ -41,7 +40,7 @@ class Client(object):
         log.debug('hidden challenge size: %d bytes', len(blob))
 
         log.info('please confirm user "%s" login to "%s" using %s...',
-                 msg['user'].decode('ascii'), identity,
+                 msg['user'].decode('ascii'), identity.to_string(),
                  self.device)
 
         with self.device:

libagent/ssh/protocol.py

@@ -70,7 +70,7 @@ def _legacy_pubs(buf):
     return util.frame(code, num)
 
 
-class Handler(object):
+class Handler:
     """ssh-agent protocol handler."""
 
     def __init__(self, conn, debug=False):
@@ -149,9 +149,9 @@ class Handler(object):
         try:
             sig_bytes = key['verifier'](sig=signature, msg=blob)
             log.info('signature status: OK')
-        except formats.ecdsa.BadSignatureError:
+        except formats.ecdsa.BadSignatureError as e:
             log.exception('signature status: ERROR')
-            raise ValueError('invalid ECDSA signature')
+            raise ValueError('invalid ECDSA signature') from e
 
         log.debug('signature size: %d bytes', len(sig_bytes))
 

libagent/ssh/tests/test_client.py

@@ -17,12 +17,16 @@ PUBKEY_TEXT = ('ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzd'
 
 class MockDevice(device.interface.Device):  # pylint: disable=abstract-method
 
+    @classmethod
+    def package_name(cls):
+        return 'fake-device-agent'
+
     def connect(self):  # pylint: disable=no-self-use
         return mock.Mock()
 
     def pubkey(self, identity, ecdh=False):  # pylint: disable=unused-argument
         assert self.conn
-        return PUBKEY
+        return formats.decompress_pubkey(pubkey=PUBKEY, curve_name=identity.curve_name)
 
     def sign(self, identity, blob):
         """Sign given blob and return the signature (as bytes)."""

libagent/ssh/tests/test_protocol.py

@@ -45,7 +45,7 @@ def test_unsupported():
 
 
 def ecdsa_signer(identity, blob):
-    assert str(identity) == '<ssh://localhost|nist256p1>'
+    assert identity.to_string() == '<ssh://localhost|nist256p1>'
     assert blob == NIST256_BLOB
     return NIST256_SIG
 
@@ -66,7 +66,7 @@ def test_sign_missing():
 
 def test_sign_wrong():
     def wrong_signature(identity, blob):
-        assert str(identity) == '<ssh://localhost|nist256p1>'
+        assert identity.to_string() == '<ssh://localhost|nist256p1>'
         assert blob == NIST256_BLOB
         return b'\x00' * 64
 
@@ -96,7 +96,7 @@ ED25519_SIG = b'''\x8eb)\xa6\xe9P\x83VE\xfbq\xc6\xbf\x1dV3\xe3<O\x11\xc0\xfa\xe4
 
 
 def ed25519_signer(identity, blob):
-    assert str(identity) == '<ssh://localhost|ed25519>'
+    assert identity.to_string() == '<ssh://localhost|ed25519>'
     assert blob == ED25519_BLOB
     return ED25519_SIG
 

libagent/tests/test_interface.py

@@ -2,6 +2,6 @@ from ..device import interface
 
 
 def test_unicode():
-    i = interface.Identity(u'ko\u017eu\u0161\u010dek@host', 'ed25519')
+    i = interface.Identity('ko\u017eu\u0161\u010dek@host', 'ed25519')
     assert i.to_bytes() == b'kozuscek@host'
     assert sorted(i.items()) == [('host', 'host'), ('user', 'kozuscek')]

libagent/tests/test_server.py

@@ -1,4 +1,3 @@
-import functools
 import io
 import os
 import socket
@@ -19,7 +18,7 @@ def test_socket():
     assert not os.path.isfile(path)
 
 
-class FakeSocket(object):
+class FakeSocket:
 
     def __init__(self, data=b''):
         self.rx = io.BytesIO(data)
@@ -74,26 +73,27 @@ def test_handle():
 
 
 def test_server_thread():
-    connections = [FakeSocket()]
+    sock = FakeSocket()
+    connections = [sock]
     quit_event = threading.Event()
 
-    class FakeServer(object):
+    class FakeServer:
         def accept(self):  # pylint: disable=no-self-use
-            if connections:
-                return connections.pop(), 'address'
-            quit_event.set()
-            raise socket.timeout()
+            if not connections:
+                raise socket.timeout()
+            return connections.pop(), 'address'
 
         def getsockname(self):  # pylint: disable=no-self-use
             return 'fake_server'
 
-    handler = protocol.Handler(conn=empty_device()),
-    handle_conn = functools.partial(server.handle_connection,
-                                    handler=handler,
-                                    mutex=None)
+    def handle_conn(conn):
+        assert conn is sock
+        quit_event.set()
+
     server.server_thread(sock=FakeServer(),
                          handle_conn=handle_conn,
                          quit_event=quit_event)
+    quit_event.wait()
 
 
 def test_spawn():

libagent/tests/test_util.py

@@ -25,7 +25,7 @@ def test_frames():
     assert util.read_frame(io.BytesIO(f)) == b''.join(msgs)
 
 
-class FakeSocket(object):
+class FakeSocket:
     def __init__(self):
         self.buf = io.BytesIO()
 
@@ -115,3 +115,32 @@ def test_memoize():
     assert g(1) == g(1)
     assert g(1) != g(2)
     assert f.mock_calls == [mock.call(1), mock.call(2)]
+
+
+def test_assuan_serialize():
+    assert util.assuan_serialize(b'') == b''
+    assert util.assuan_serialize(b'123\n456') == b'123%0A456'
+    assert util.assuan_serialize(b'\r\n') == b'%0D%0A'
+
+
+def test_cache():
+    timer = mock.Mock(side_effect=range(7))
+    c = util.ExpiringCache(seconds=2, timer=timer)  # t=0
+    assert c.get() is None                          # t=1
+    obj = 'foo'
+    c.set(obj)                                      # t=2
+    assert c.get() is obj                           # t=3
+    assert c.get() is obj                           # t=4
+    assert c.get() is None                          # t=5
+    assert c.get() is None                          # t=6
+
+
+def test_cache_inf():
+    timer = mock.Mock(side_effect=range(6))
+    c = util.ExpiringCache(seconds=float('inf'), timer=timer)
+    obj = 'foo'
+    c.set(obj)
+    assert c.get() is obj
+    assert c.get() is obj
+    assert c.get() is obj
+    assert c.get() is obj

libagent/util.py

@@ -5,6 +5,7 @@ import functools
 import io
 import logging
 import struct
+import time
 
 log = logging.getLogger(__name__)
 
@@ -145,7 +146,7 @@ def hexlify(blob):
     return binascii.hexlify(blob).decode('ascii').upper()
 
 
-class Reader(object):
+class Reader:
     """Read basic type objects out of given stream."""
 
     def __init__(self, stream):
@@ -213,3 +214,67 @@ def memoize(func):
             return result
 
     return wrapper
+
+
+def memoize_method(method):
+    """Simple caching decorator."""
+    cache = {}
+
+    @functools.wraps(method)
+    def wrapper(self, *args, **kwargs):
+        """Caching wrapper."""
+        key = (args, tuple(sorted(kwargs.items())))
+        if key in cache:
+            return cache[key]
+        else:
+            result = method(self, *args, **kwargs)
+            cache[key] = result
+            return result
+
+    return wrapper
+
+
+@memoize
+def which(cmd):
+    """Return full path to specified command, or raise OSError if missing."""
+    try:
+        # For Python 3
+        from shutil import which as _which
+    except ImportError:
+        # For Python 2
+        from backports.shutil_which import which as _which
+    full_path = _which(cmd)
+    if full_path is None:
+        raise OSError('Cannot find {!r} in $PATH'.format(cmd))
+    log.debug('which %r => %r', cmd, full_path)
+    return full_path
+
+
+def assuan_serialize(data):
+    """Serialize data according to ASSUAN protocol (for GPG daemon communication)."""
+    for c in [b'%', b'\n', b'\r']:
+        escaped = '%{:02X}'.format(ord(c)).encode('ascii')
+        data = data.replace(c, escaped)
+    return data
+
+
+class ExpiringCache:
+    """Simple cache with a deadline."""
+
+    def __init__(self, seconds, timer=time.time):
+        """C-tor."""
+        self.duration = seconds
+        self.timer = timer
+        self.value = None
+        self.set(None)
+
+    def get(self):
+        """Returns existing value, or None if deadline has expired."""
+        if self.timer() > self.deadline:
+            self.value = None
+        return self.value
+
+    def set(self, value):
+        """Set new value and reset the deadline for expiration."""
+        self.deadline = self.timer() + self.duration
+        self.value = value

release.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -eux
+rm -rv dist/*
+python3 setup.py sdist
+gpg2 -v --detach-sign -a dist/*.tar.gz
+twine upload dist/*

scripts/gpg-init

@@ -1,57 +0,0 @@
-#!/bin/bash
-set -eu
-
-gpg2 --version >/dev/null  # verify that GnuPG 2 is installed
-
-USER_ID="${1}"
-DEVICE=${DEVICE:="trezor"}  # or "ledger"
-CURVE=${CURVE:="nist256p1"}  # or "ed25519"
-TIMESTAMP=${TIMESTAMP:=`date +%s`}  # key creation timestamp
-HOMEDIR=~/.gnupg/${DEVICE}
-
-# Prepare new GPG home directory for hardware-based identity
-rm -rf "${HOMEDIR}"
-mkdir -p "${HOMEDIR}"
-chmod 700 "${HOMEDIR}"
-
-# Generate new GPG identity and import into GPG keyring
-$DEVICE-gpg create -v "${USER_ID}" -t "${TIMESTAMP}" -e "${CURVE}" > "${HOMEDIR}/pubkey.asc"
-gpg2 --homedir "${HOMEDIR}" --import < "${HOMEDIR}/pubkey.asc" 2> /dev/null
-rm -f "${HOMEDIR}/S.gpg-agent"  # (otherwise, our agent won't be started automatically)
-
-# Make new GPG identity with "ultimate" trust (via its fingerprint)
-FINGERPRINT=$(gpg2 --homedir "${HOMEDIR}" --list-public-keys --with-fingerprint --with-colons | sed -n -E 's/^fpr:::::::::([0-9A-F]+):$/\1/p' | head -n1)
-echo "${FINGERPRINT}:6" | gpg2 --homedir "${HOMEDIR}" --import-ownertrust 2> /dev/null
-
-AGENT_PATH="$(which ${DEVICE}-gpg-agent)"
-
-# Prepare GPG configuration file
-echo "# Hardware-based GPG configuration
-agent-program ${AGENT_PATH}
-personal-digest-preferences SHA512
-default-key \"${USER_ID}\"
-" > "${HOMEDIR}/gpg.conf"
-
-# Prepare GPG agent configuration file
-echo "# Hardware-based GPG agent emulator
-log-file ${HOMEDIR}/gpg-agent.log
-verbosity 2
-" > "${HOMEDIR}/gpg-agent.conf"
-
-# Prepare a helper script for setting up the new identity
-echo "#!/bin/bash
-set -eu
-export GNUPGHOME=${HOMEDIR}
-COMMAND=\$*
-if [ -z \"\${COMMAND}\" ]
-then
-    \${SHELL}
-else
-    \${COMMAND}
-fi
-" > "${HOMEDIR}/env"
-chmod u+x "${HOMEDIR}/env"
-
-echo "Starting ${DEVICE}-gpg-agent at ${HOMEDIR}..."
-# Load agent and make sure it responds with the new identity
-GNUPGHOME="${HOMEDIR}" gpg2 -K 2> /dev/null

setup.py

@@ -3,7 +3,7 @@ from setuptools import setup
 
 setup(
     name='libagent',
-    version='0.9.2',
+    version='0.14.4',
     description='Using hardware wallets as SSH/GPG agent',
     author='Roman Zeyde',
     author_email='roman.zeyde@gmail.com',
@@ -12,11 +12,20 @@ setup(
         'libagent',
         'libagent.device',
         'libagent.gpg',
-        'libagent.ssh'
+        'libagent.signify',
+        'libagent.ssh',
     ],
     install_requires=[
+        'docutils>=0.14',
+        'python-daemon>=2.3.0',
+        'wheel>=0.32.3',
+        'backports.shutil_which>=3.5.1',
+        'ConfigArgParse>=0.12.1',
+        'python-daemon>=2.1.2',
         'ecdsa>=0.13',
-        'ed25519>=1.4',
+        'pynacl>=1.4.0',
+        'mnemonic>=0.18',
+        'pymsgbox>=1.0.6',
         'semver>=2.2',
         'unidecode>=0.4.20',
     ],
@@ -29,10 +38,7 @@ setup(
         'Intended Audience :: System Administrators',
         'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
         'Operating System :: POSIX',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3 :: Only',
         'Topic :: Software Development :: Libraries :: Python Modules',
         'Topic :: System :: Networking',
         'Topic :: Communications',

tox.ini

@@ -1,6 +1,6 @@
 [tox]
-envlist = py27,py3
-[pep8]
+envlist = py3
+[pycodestyle]
 max-line-length = 100
 [pep257]
 add-ignore = D401
@@ -8,15 +8,15 @@ add-ignore = D401
 deps=
     pytest
     mock
-    pep8
+    pycodestyle
     coverage
     pylint
     semver
     pydocstyle
-    isort
+    isort<5
 commands=
-    pep8 libagent
-    isort --skip-glob .tox -c -r libagent
+    pycodestyle libagent
+    isort --skip-glob .tox -c -rc libagent
     pylint --reports=no --rcfile .pylintrc libagent
     pydocstyle libagent
     coverage run --source libagent -m py.test -v libagent