How do I use GNOME Keyring with Python Keyring in virtual environment?

Question

I have written a Python script that I would like to run in the background on my Raspberry Pi. The script makes use of the Python module Keyring (link), which is used to access a keyring backend to provide password input to the script.

I wrote the script in OS X, for which Keyring makes use of OS X Keychain. But on a headless Raspberry Pi not using X11, something like GNOME Keychain must be installed to act as the backend.

I have read the Pypi instructions (referenced below), but I am unfamiliar with D-Bus and how to make it all work in practice. Would anyone be willing to provide a practical example of how D-bus and the GNOME Keyring may be handled by Raspbian, assuming this:

• The script should always run in the background as long as the Raspberry is powered on, and it is invoked via crontab.
• The script should run from a virtualenv environment, which has the Keyring module installed.
• Handling of the GNOME Keyring/D-Bus session is handled as automatically as possible, and can provide the keyring entries to the script without user input (e.g. loaded automatically when the Raspberry is powered on, or the script is executed).

---

https://pypi.python.org/pypi/keyring#using-keyring-on-headless-linux-systems

Using Keyring on headless Linux systems

It is possible to use the SecretService backend on Linux systems without X11 server available (only D-Bus is required). To do that, you need the following:

Install the GNOME Keyring daemon. (Note: I have done this via apt-get).

Start a D-Bus session, e.g. run dbus-run-session -- sh and run the following commands inside that shell.

Run gnome-keyring-daemon with --unlock option. The description of that option says:

Read a password from stdin, and use it to unlock the login keyring or create it if the login keyring does not exist.

When that command is started, enter your password into stdin and press Ctrl+D (end of data). After that the daemon will fork into background (use --foreground option to prevent that).

Now you can use the SecretService backend of Keyring. Remember to run your application in the same D-Bus session as the daemon.

Answer 1

You still have to follow the instructions and get the required context up and running. This is normally done when logging into the graphical shell, but since you use a headless system, you have to create the environment.

That means either you login (using ssh) and run the programs from the commandline as specified in "Using Keyring on headless Linux systems) and then start your own program, or you make a script which does all those actions.

If your program is to be started from crontab, the second option (making a script that does all the required things and then start your Python program) is the way to go.

Please note that your environment when running a script from cron is different, including a very restricted PATH where commands are searched.

Running from a virtualenv is automatic if your program is installed as a package entrypoint (i.e. you did /path/to/your/virtualenv/bin/python setup.py install ). If you didn't make your program into a package, it suffices to start it as:

/path/to/your/virtualenv/bin/python /path/to/your/main/python/prog.py

to actually use all the packages installed in your virtualenv.

You should be able to do the steps specified from your python program, but this deviates from the description (that assumes you have a shell). So unless you are experienced in those matters, I would stick with making a shell script that does the steps, and then calls your python program.