Aller au contenu

Unix pass

De Marmits Wiki

🔐 1. pass – Le gestionnaire de mots de passe Unix

✅ Avantages :

  • 100perso.kdbx% CLI
  • Chiffrement avec GPG
  • Compatible Git (versionnage)
  • Très léger et scriptable

🔧 Installation :

sudo apt-get install pass gnupg

gpg --full-generate-key

gpg --list-keys

Puis initialise pass : avec pub 

pass init "Identité GPG"

🔧 Utilisation :

  • Ajouter un mot de passe :

    pass add perso/site-web

    → tape ton mot de passe quand demandé

  • Afficher un mot de passe : bash pass show perso/site-web

  • Lister les entrées : bash pass ls

  • Supprimer une entrée : bash pass rm perso/site-web


🔐 2. Commandes pratiques (compatibles Debian 13) pour :

  1. Voir les TTL effectifs de gpg‑agent
  2. Vérifier que l’agent tourne (ou le lancer si besoin)

1) Afficher les TTL effectifs (default & current)

# Affiche les valeurs "default" et "current" vues par gpg-agent
gpgconf --list-options gpg-agent \
| awk -F: '/^default-cache-ttl|^max-cache-ttl/ {printf "%-20s default=%s  current=%s\n",$1,$7,$10}'
  • default-cache-ttl : durée par défaut (en secondes) de mise en cache de ta passphrase.
  • max-cache-ttl : durée maximale (plafond) autorisée.

Si aucune « current » n’est définie dans la conf utilisateur, ce seront les valeurs par défaut de GnuPG: typiquement 600 s (10min) pour default-cache-ttl et 7200 s (2h) pour max-cache-ttl.

Tu peux aussi vérifier ce que tu as explicitement configuré : 

grep -E '^(default|max)-cache-ttl' "$HOME/.gnupg/gpg-agent.conf" || echo "Aucun TTL défini dans gpg-agent.conf (valeurs par défaut appliquées)"

Référence: la conf du cache TTL est gérée par gpg-agent, pas par pass lui‑même (voir la doc man de pass et gpg-agent).

2) Vérifier que gpg‑agent tourne (et obtenir son socket)

Méthode simple (et idempotente)

# Lance l’agent si besoin (sans créer de doublons), ne produit pas d’erreur si déjà lancé
gpgconf --launch gpg-agent

# Récupère le chemin du socket
SOCK="$(gpgconf --list-dirs agent-socket)"
echo "Socket gpg-agent: $SOCK"

# Vérifie que le socket existe
ls -l "$SOCK"

Tester la communication avec l’agent

# Interroge l'agent (retourne la version si OK)
gpg-connect-agent 'GETINFO version' /bye

(Optionnel) Voir le/les processus

pgrep -a gpg-agent || echo "Aucun processus gpg-agent visible (il peut être auto-spawn via le socket)"

Points à connaître dans un container Docker :

  • gpgconf --launch gpg-agent et gpg-connect-agent suffisent : gpg-agent est auto‑démarré à la demande via le socket UNIX, même sans systemd.
  • Si tu utilises pinentry-mode loopback (fréquent en CI/container), pense à l’option --pinentry-mode=loopback côté GnuPG/gpg et/ou à configurer allow-loopback-pinentry dans gpg-agent.conf.

Bonus : remettre à jour l’agent après modification des TTL

Si tu modifies ~/.gnupg/gpg-agent.conf : 

gpgconf --reload gpg-agent
# puis re-vérifie :
gpgconf --list-options gpg-agent | awk -F: '/^default-cache-ttl|^max-cache-ttl/ {printf "%-20s default=%s  current=%s\n",$1,$7,$10}'

Le délai avant que pass show te redemande la passphrase GPG dépend du cache d’agent GPG (gpg-agent), pas de pass lui-même.

Par défaut :

  • gpg-agent garde la passphrase en mémoire pendant 600 secondes (10 minutes) après la dernière utilisation.
  • Ce délai est contrôlé par les paramètres :
    • default-cache-ttl (par défaut 600 s)
    • max-cache-ttl (par défaut 7200 s = 2 h)

Ces paramètres se trouvent dans le fichier : 

~/.gnupg/gpg-agent.conf

Pour vérifier ou modifier :

Ajoute par exemple : 

default-cache-ttl 3600      # 1 heure
max-cache-ttl 7200          # 2 heures

Puis recharge l’agent : 

gpgconf --reload gpg-agent

Script pour configurer et visualiser gpg‑agent

(avec paramètre d’entrée)

  • Par défaut (sans option) → il affiche uniquement l’état de gpg-agent + les TTL actuels.
  • Avec --set-ttl <DEF> <MAX> → il applique les TTL (en secondes), recharge l’agent, puis réaffiche les valeurs.

Rappel : les TTL (default-cache-ttl / max-cache-ttl) sont gérés par gpg‑agent (pas par pass). On peut les lire et recharger via gpgconf. [man.archlinux.org]

Script : pass-ttl-check.sh

Installe-le, par exemple dans ~/bin/pass-ttl-check.sh, puis :

chmod +x ~/bin/pass-ttl-check.sh 

#!/usr/bin/env bash
set -euo pipefail

# ------------------------------------------------------------
# pass-ttl-check.sh
# - Sans option : montre l'état de gpg-agent + TTL effectifs.
# - --set-ttl <DEF> <MAX> : applique les TTL et recharge l'agent.
# ------------------------------------------------------------

# Couleurs (facultatif)
BOLD="\033[1m"; DIM="\033[2m"; RED="\033[31m"; GREEN="\033[32m"; YELLOW="\033[33m"; NC="\033[0m"
info()  { echo -e "${BOLD}$*${NC}"; }
warn()  { echo -e "${YELLOW}[!]${NC} $*"; }
err()   { echo -e "${RED}[x]${NC} $*" 1>&2; }
ok()    { echo -e "${GREEN}[ok]${NC} $*"; }

need_bin() {
  command -v "$1" >/dev/null 2>&1 || { err "Commande requise non trouvée: $1"; exit 1; }
}

usage() {
  cat <<'USAGE'
Usage:
  pass-ttl-check.sh                 # Affiche uniquement les infos (gpg-agent + TTL)
  pass-ttl-check.sh --set-ttl <DEF> <MAX>
                                    # Définit les TTL (secondes) puis reload gpg-agent
  pass-ttl-check.sh -h | --help     # Aide

Exemples :
  pass-ttl-check.sh
  pass-ttl-check.sh --set-ttl 3600 7200
USAGE
}

conf_file_path() { echo "${HOME}/.gnupg/gpg-agent.conf"; }

ensure_gnupg_perms() {
  [[ -d "${HOME}/.gnupg" ]] || mkdir -p "${HOME}/.gnupg"
  chmod 700 "${HOME}/.gnupg" || true
}

launch_agent() { gpgconf --launch gpg-agent >/dev/null 2>&1 || true; }
agent_socket() { gpgconf --list-dirs agent-socket 2>/dev/null || true; }

check_agent() {
  launch_agent
  local sock; sock="$(agent_socket)"
  if [[ -n "${sock}" && -S "${sock}" ]]; then
    ok "gpg-agent dispo (socket: ${sock})"
  else
    warn "Socket gpg-agent introuvable (l'agent peut être auto-spawn via le socket)."
  fi

  if gpg-connect-agent 'GETINFO version' /bye >/dev/null 2>&1; then
    local ver
    ver="$(gpg-connect-agent 'GETINFO version' /bye 2>/dev/null | awk '{print $2}')"
    ok "Communication gpg-agent OK (version: ${ver})"
  else
    err "Impossible de communiquer avec gpg-agent."
    exit 1
  fi
}

show_ttls() {
  info "\n--- TTL vus par gpg-agent ---"
  # gpgconf --list-options gpg-agent : colonnes séparées par ':'.
  # Nous affichons colonnes 7 (default) et 10 (current) pour les deux paramètres intéressants.
  if ! gpgconf --list-options gpg-agent \
      | awk -F: '/^(default-cache-ttl|max-cache-ttl)/{
          name=$1; def=$7; cur=$10; if(cur=="") cur="(defaut)";
          printf "%-20s default=%-6s current=%s\n", name, def, cur
        }'; then
    warn "Impossible de lire les options via gpgconf."
  fi

  # Montre ce qui est explicitement posé dans le fichier de conf (si présent)
  local conf; conf="$(conf_file_path)"
  echo
  info "--- Contenu TTL dans ${conf} (si existant) ---"
  if [[ -f "$conf" ]]; then
    grep -E '^(default|max)-cache-ttl' "$conf" || echo "(aucune ligne TTL explicite)"
  else
    echo "(fichier absent)"
  fi
}

apply_ttls() {
  local DEF_TTL="$1" MAX_TTL="$2"
  [[ "$DEF_TTL" =~ ^[0-9]+$ && "$MAX_TTL" =~ ^[0-9]+$ ]] || { err "TTL non numériques."; exit 1; }

  ensure_gnupg_perms
  local conf; conf="$(conf_file_path)"
  [[ -f "$conf" ]] && cp -a "$conf" "${conf}.bak.$(date +%Y%m%d-%H%M%S)" && ok "Backup: ${conf}.bak.*"

  # Réécrit (ou crée) en supprimant d'éventuelles anciennes lignes TTL
  { [[ -f "$conf" ]] && grep -Ev '^(default|max)-cache-ttl' "$conf" || true; } > "${conf}.tmp"
  {
    echo "default-cache-ttl ${DEF_TTL}"
    echo "max-cache-ttl ${MAX_TTL}"
    # Optionnel si tu utilises --pinentry-mode loopback :
    # echo "allow-loopback-pinentry"
  } >> "${conf}.tmp"

  mv "${conf}.tmp" "$conf"
  chmod 600 "$conf"
  ok "TTL écrits dans ${conf} (default=${DEF_TTL}s, max=${MAX_TTL}s)"

  # Recharge l'agent pour prise en compte immédiate
  if gpgconf --reload gpg-agent; then
    ok "gpg-agent rechargé"
  else
    warn "Reload gpg-agent non concluant (l'agent se relancera au prochain usage)."
  fi
}

main() {
  # Dépendances minimales
  need_bin gpgconf
  need_bin gpg-connect-agent
  need_bin awk

  case "${1:-}" in
    -h|--help) usage; exit 0 ;;
    --set-ttl)
      [[ $# -eq 3 ]] || { err "Arguments manquants pour --set-ttl"; usage; exit 1; }
      info "=== Application des TTL demandés ==="
      check_agent
      apply_ttls "$2" "$3"
      show_ttls
      ;;
    "")
      info "=== Informations gpg-agent & TTL ==="
      check_agent
      show_ttls
      ;;
    *)
      err "Option inconnue: $1"; usage; exit 1 ;;
  esac
}

main "$@"

Utilisation

  • Afficher uniquement les infos (par défaut) : bash ~/bin/pass-ttl-check.sh
  • Appliquer des TTL (seconds) puis recharger l’agent : bash ~/bin/pass-ttl-check.sh --set-ttl 3600 7200 → default-cache-ttl = 3600 (1h), max-cache-ttl = 7200 (2h).


Références

  • Man page officielle de pass (alias add ↔ insert, et bonnes pratiques): [man.archlinux.org]
  • gpg-agent / gpgconf (lecture/écriture des options, reload de l’agent): la gestion des TTL se fait côté agent et s’observe via gpgconf --list-options gpg-agent, rechargée via gpgconf --reload gpg-agent. [man.archlinux.org]
Récupérée de "https://marmits.com/w/index.php?title=Unix_pass&oldid=3599"