Finding your gnome keyring file location
A practical guide to locating GNOME Keyring data and keyring files across common Linux setups.
Finding your GNOME Keyring file location
If you’re trying to locate where GNOME Keyring stores its keyrings or where the actual password data lives, you’re not alone. The GNOME Keyring project has evolved over time, and different components (like Seahorse, the GUI for managing secrets, and the underlying keyring daemons) may use slightly different paths depending on your Linux distribution and GNOME version. Below you’ll find practical guidance to pinpoint the storage location on most common setups, plus notes on legacy locations and how to interpret what you see.
Comparison of keyring storage concepts
| Kind | Location scope | Typical files | Access method | Modern vs legacy | Notes |
|---|---|---|---|---|---|
| Legacy layout | User home only | ~/.gnome2/keyrings | File path, gnome-keyring tools | Legacy | Deprecated in newer GNOME |
| Modern GNOME Keyring | DConf/DBus managed | ~/.local/share/keyrings, gnome-keyring, or under ~/.local/state | DBus API, secret-service | Modern | Varies by distro |
| Common patterns | System/user split | keyrings file, .db key files | API or CLI | Mixed | Depends on session |
| Session-specific | per-login | session-keyring files | DBus, PAM | Supported | Cleared on logout |
Compiled November 2026; check the provider's site for current details.
Where GNOME Keyring stores data: the general idea
- GNOME Keyring is a collection of components that manages secrets, passwords, keys, and certificates.
- Each user session has its own keyring data, isolated per user.
- Data is typically stored in hidden directories under the user’s home directory, or in a runtime cache for faster access, with the actual material loaded into memory when needed.
In short: you’re looking for user-specific files, usually under your home directory, with names that reflect the keyrings (for example, login.keyring in older setups).
Legacy locations: the classic ~/.gnome2/keyrings layout
What you might see
- A common historical location is ~/.gnome2/keyrings/
- Inside you may encounter files named login.keyring and possibly other.keyring files
- These files can be small if they store only metadata and not raw secrets. The secrets are kept in a separate DB file or integrated in a separate service
When this path shows up
- On older GNOME versions or some arch setups, Seahorse reads keyrings from this directory
- If you upgrade your system, the location may have shifted, but some tools still reference the old path for compatibility
Caution about file contents
- The keyring files themselves are not always human-readable
- The actual sensitive data is protected and often encrypted. You’ll typically unlock the keyring via a password
If you still have ~/.gnome2/keyrings on your system, it’s worth inspecting, but don’t rely on it exclusively for modern GNOME setups.
Modern GNOME Keyring: common current patterns
Per-user runtime and cache locations
- The GNOME keyring daemon often stores session-related data in runtime-accessible areas and caches
- You might encounter paths under your home directory’s cache folders, such as ~/.cache/keyring-*/ or similar
- The SSH agent component of GNOME Keyring can surface as SSH_AUTH_SOCK, pointing to a socket in your runtime area
Where to look
- Check your home directory for hidden folders and files that reference gnome-keyring or keyring
- Look in ~/.local/share/keyrings or ~/.cache/keyring-*/ directories
- In some distributions, secrets can be managed by a separate agent with its own socket under /run/user/UID/ or ~/.cache
How this affects you
- The actual secret material may live in a database file within those directories, or be loaded by the keyring daemon from a protected store
- The GUI Seahorse app will connect to the running keyring daemon and display items regardless of the exact file on disk
How to identify the keyring files you have
Step-by-step quick scan
- Open a terminal
- List hidden folders in your home: ls -la ~ | grep -i key
- Check common caches: ls -la ~/.cache | grep -i key
- Inspect per-user runtime: ls -la /run/user/$(id -u) | grep -i key
- If Seahorse is installed, launch it and observe which keyrings appear
How to interpret the results
- If you notice login.keyring in a legacy path, that’s your older default keyring
- If you see references to keyrings under ~/.local/share/keyrings or ~/.cache/keyring-*, you’re in a more modern layout
- If you see a socket like SSH_AUTH_SOCK pointing to a keyring path, your active session’s keyring is being used as the SSH agent
A practical comparison: legacy vs modern layouts
| Aspect | Legacy (older GNOME) | Modern GNOME Keyring | Notes |
|---|---|---|---|
| Default location | ~/.gnome2/keyrings/ | Various under ~/.local/share/keyrings, ~/.cache/keyring-*/ | Distribution and GNOME version dependent |
| Keyring files | login.keyring, possibly other.keyring files | Database-like files or entries managed by the daemon; exact file formats vary | Tools may read from the daemon rather than raw files |
| Access method | Seahorse GUI; direct file access limited by encryption | Seahorse GUI; keyring daemon; SSH agent integration | The daemon abstracts raw file contents |
| SSH agent | Part of GNOME Keyring; SSH_AUTH_SOCK may point to a socket | Same, often using /run/user/UID/… for the socket | Environmental variable indicates location |
| Typical user action | Unlock the keyring with the password to access stored secrets | Unlock via GUI or login, or auto-unlock settings | Auto-unlock behavior varies by distro and policy |
How to identify keyring files you have
| Check | Location | File type | Tool to read | Output example | Notes |
|---|---|---|---|---|---|
| Legacy keyrings | ~/.gnome2/keyrings | .key or keyring files | gnome-keyring-daemon, gnome-keyring-admin | Names like login.keyring | Deprecating |
| Modern keyrings | ~/.local/share/keyrings | .gpg, .trustdb, or .keyring | secret-tool, gio, gnome-keyring | List of items via secret-tool search | Primary modern path |
| System keyrings | /usr/share/keyrings | .gpg, .keyring | apt-key, gpg | Read-only reference | System-wide |
| Session keyrings | /run/user/$UID | session-specific | gnome-keyring-daemon | In-memory only | Ephemeral |
Compiled November 2026; check the provider's site for current details.
How GNOME Keyring integrates with other tools
- Seahorse: The graphical interface for managing passwords, keys, and certificates. It communicates with the GNOME Keyring daemon to display and edit items.
- ssh-agent integration: The keyring can provide SSH credentials to the shell, with SSH_AUTH_SOCK pointing to a named socket.
- Automatic unlock: Many systems unlock GNOME Keyring at login if you use a login password, but this depends on PAM and session configuration.
- Password stores: Web browsers or apps that use GNOME Keyring often rely on the daemon to retrieve credentials securely.
How to verify which keyring is in use and where it lives
- Check the running daemon: ps aux | grep gnome-keyring
- Inspect environment variables: echo $SSH_AUTH_SOCK to see if the keyring provides an SSH agent. The value normally includes a path to a runtime socket
- Use Seahorse to list items: If the GUI shows items, you’re connected to the active keyring daemon
- Look at dconf/gsettings for keyring-related settings: Some configurations expose storage preferences
If you’re troubleshooting, these steps help confirm that the daemon is active, what socket it uses, and where the storage appears to be located on your system. Filter paper hole size
Troubleshooting tips: when you can’t find the keyring
- If you don’t find any keyring files in the expected places, the data may be loaded from a daemon cache or a modern storage area managed by the GNOME Keyring service
- Ensure the gnome-keyring-daemon is running, and that you have a user session with proper permissions
- Check for possible misconfigurations: your distribution may separate key storage into multiple components or use a different secrets manager
- If you’ve migrated from an older GNOME version, the new storage location may be in ~/.local/share/keyrings or ~/.cache/keyrings, even if an old path remains on the system
Quick commands you can run now
| Command | Purpose | Output/Result | When to use | Notes |
|---|---|---|---|---|
| ls -la ~/.gnome2/keyrings | See legacy files | Lists files | If legacy is suspected | May be empty on modern setups |
| ls -la ~/.local/share/keyrings | See modern files | Lists keyrings | When modern layout used | Common modern location |
| secret-tool search --all | List secrets | Secrets found | Inspect available secrets | Requires API access |
| gnome-keyring-daemon --start | Start daemon | Daemon running | If not running | Background service |
| gsettings get org.gnome.crypto.cache enabled | Check cache | true/false | Verify cache usage | Optional state check |
| find / -name "*.keyring" 2>/dev/null | Locate keyring files | Paths found | Broad search | May be slow |
Compiled November 2026; check the provider's site for current details.
Quick commands you can run now
- Find keyring-related directories
- ls -la ~ | grep -i key
- ls -la ~/.local/share | grep -i key
- ls -la ~/.cache | grep -i key
- Check the moment-to-moment access point
- echo $SSH_AUTH_SOCK
- ps aux | grep gnome-keyring
- Open Seahorse to browse items
- seahorse
If you want to see what a specific distribution uses for GNOME Keyring storage, you can search for “GNOME Keyring location” plus your distro name, but the patterns above cover the majority of modern and legacy setups.
Final note and recommendation
- For most users, you don’t need to memorize a single exact path. The GNOME Keyring daemon abstracts storage, and tools like Seahorse query the daemon to show you your secrets. If you’re debugging or backing up data, focus on locating the daemon’s runtime socket and the common storage directories under ~/.local/share/keyrings or ~/.cache/keyring-*/. Understanding the distinction between legacy keyrings (like ~/.gnome2/keyrings) and current daemon-backed storage will save you time and prevent accidental data loss. If you’re migrating systems, rely on Seahorse and checks of SSH_AUTH_SOCK to confirm you’re connected to the correct keyring.

