Existe-t-il un moyen de mettre en cache les informations d'identification GitHub pour pousser les validations?

J'ai récemment basculé vers la synchronisation de mes référentiels sur https: // sur GitHub (en raison de problèmes de pare-feu), et il demande un mot de passe à chaque fois.

Existe-t-il un moyen de mettre en cache les informations d'identification, au lieu de s'authentifier à chaque fois git push?

Avec Git version 1.7.9 et versions ultérieures

Depuis Git 1.7.9 (sorti fin janvier 2012), il existe un mécanisme soigné dans Git pour éviter d'avoir à taper tout le temps votre mot de passe pour HTTP / HTTPS, appelés assistants d'identification . (Merci à dazonic d' avoir signalé cette nouvelle fonctionnalité dans les commentaires ci-dessous.)

Avec Git 1.7.9 ou version ultérieure, vous pouvez simplement utiliser l'un des assistants d'identification suivants:

git config --global credential.helper cache

... qui indique à Git de garder votre mot de passe en cache pendant 15 minutes (par défaut). Vous pouvez définir un délai d'expiration plus long avec:

git config --global credential.helper "cache --timeout=3600"

(Cet exemple a été suggéré dans la page d'aide de GitHub pour Linux .) Vous pouvez également stocker vos informations d'identification de façon permanente si vous le souhaitez, voir les autres réponses ci-dessous.

L'aide de GitHub suggère également que si vous êtes sous Mac OS X et que vous avez utilisé Homebrew pour installer Git, vous pouvez utiliser le magasin de clés natif de Mac OS X avec:

git config --global credential.helper osxkeychain

Pour Windows, il existe un assistant appelé Git Credential Manager pour Windows ou wincred dans msysgit .

git config --global credential.helper wincred # obsolete

Avec Git pour Windows 2.7.3+ (mars 2016):

git config --global credential.helper manager

Pour Linux, vous pouvez utilisergnome-keyring (ou une autre implémentation de porte-clés telle que KWallet).

Avec les versions Git antérieures à 1.7.9

Avec les versions de Git antérieures à 1.7.9, cette option plus sécurisée n'est pas disponible et vous devrez modifier l'URL que votre origintélécommande utilise pour inclure le mot de passe de cette manière:

https://you:password@github.com/you/example.git

... en d'autres termes avec :passwordaprès le nom d'utilisateur et avant le @.

Vous pouvez définir une nouvelle URL pour votre origintélécommande avec:

git config remote.origin.url https://you:password@github.com/you/example.git

Assurez-vous que vous utilisez httpset sachez que si vous le faites, votre mot de passe GitHub sera stocké en texte brut dans votre .gitrépertoire, ce qui n'est évidemment pas souhaitable.

Avec n'importe quelle version de Git (enfin, depuis la version 0.99)

Une autre approche consiste à mettre votre nom d'utilisateur et votre mot de passe dans votre ~/.netrcfichier, bien que, comme pour conserver le mot de passe dans l'URL distante, cela signifie que votre mot de passe sera stocké sur le disque en texte brut et est donc moins sécurisé et déconseillé. Cependant, si vous souhaitez adopter cette approche, ajoutez la ligne suivante à votre ~/.netrc:

machine <hostname> login <username> password <password>

... en remplaçant <hostname>par le nom d'hôte du serveur, et <username>et <password>par votre nom d'utilisateur et mot de passe. N'oubliez pas non plus de définir des autorisations de système de fichiers restrictives sur ce fichier:

chmod 600 ~/.netrc

Notez que sous Windows, ce fichier doit être appelé _netrcet vous devrez peut-être définir la variable d'environnement% HOME% - pour plus de détails, voir:

• Git - Comment utiliser le fichier .netrc sous Windows pour enregistrer l'utilisateur et le mot de passe

Vous pouvez également demander à Git de stocker vos informations d'identification de manière permanente en utilisant les éléments suivants:

git config credential.helper store

Remarque: Bien que cela soit pratique, Git stockera vos informations d'identification en texte clair dans un fichier local (.git-credentials) sous le répertoire de votre projet (voir ci-dessous pour le répertoire "home"). Si vous n'aimez pas cela, supprimez ce fichier et passez à l'utilisation de l'option de cache.

Si vous souhaitez que Git recommence à vous demander des informations d'identification à chaque fois qu'il doit se connecter au référentiel distant, vous pouvez exécuter cette commande:

git config --unset credential.helper

Pour stocker les mots de passe dans .git-credentialsvotre %HOME%répertoire par opposition au répertoire du projet: utilisez l' --globalindicateur

git config --global credential.helper store

TLDR; Utilisez un fichier netrc chiffré avec Git 1.8.3+ .

L'enregistrement d'un mot de passe pour une URL HTTPS du référentiel Git est possible avec un ~/.netrc(Unix) ou %HOME%/_netrc(notez le _) sous Windows.

Mais : ce fichier stockerait votre mot de passe en texte brut.

Solution : cryptez ce fichier avec GPG (GNU Privacy Guard) et faites-le décrypter par Git chaque fois qu'il a besoin d'un mot de passe (pour push/ pull/ fetch/ cloneopération).

Remarque: avec Git 2.18 (Q2 2018), vous pouvez désormais personnaliser le GPG utilisé pour décrypter le .netrcfichier crypté .

Voir commit 786ef50 , commit f07eeed (12 mai 2018) de Luis Marsano (``) .
^{(Fusionné par Junio ​​C Hamano - gitster- dans commit 017b7c5 , 30 mai 2018)}

git-credential-netrc: accepter l' gpgoption

git-credential-netrca été codé en dur pour décrypter avec ' gpg' quelle que soit l'option gpg.program.
C'est un problème sur les distributions comme Debian qui appellent autre chose le GnuPG moderne, comme ' gpg2'

Instructions pas à pas pour Windows

Avec Windows:

(Git a un gpg.exedans sa distribution, mais l'utilisation d'une installation GPG complète inclut un gpg-agent.exe, qui mémorisera votre phrase secrète associée à votre clé GPG.)

• Installez gpg4Win Lite, l'interface de ligne de commande gnupg minimum (prenez la plus récentegpg4win-vanilla-2.X.Y-betaZZ.exe ), et complétez votre CHEMIN avec le répertoire d'installation de GPG:

  set PATH=%PATH%:C:\path\to\gpg
  copy C:\path\to\gpg\gpg2.exe C:\path\to\gpg\gpg.exe

(Notez la copycommande ' ': Git aura besoin d'un script Bash pour exécuter la commande ' gpg'. Comme il gpg4win-vanilla-2est livré avec gpg2.exe, vous devez le dupliquer.)

• Créez ou importez une clé GPG et faites-lui confiance:

  gpgp --import aKey
  # or
  gpg --gen-key

(Assurez-vous de mettre un mot de passe pour cette clé.)

• Faites confiance à cette clé

• Installez le script d'assistance des informations d'identification dans un répertoire de votre %PATH%:

  cd c:\a\fodler\in\your\path
  curl -o c:\prgs\bin\git-credential-netrc https://raw.githubusercontent.com/git/git/master/contrib/credential/netrc/git-credential-netrc.perl

(Attention: le script est renommé dans Git 2.25.x / 2.26, voir ci-dessous)

(Oui, c'est un script Bash, mais il fonctionnera sur Windows car il sera appelé par Git.)

• Créer un fichier _netrc en texte clair

  machine a_server.corp.com
  login a_login
  password a_password
  protocol https
  
  machine a_server2.corp.com
  login a_login2
  password a_password2
  protocol https

(N'oubliez pas la protocolpartie ' ': ' http' ou ' https' selon l'URL que vous utiliserez.)

• Chiffrez ce fichier:

  gpg -e -r a_recipient _netrc

(Vous pouvez maintenant supprimer le _netrcfichier en ne gardant que le fichier _netrc.gpgcrypté.)

• Utilisez ce fichier crypté:

  git config --local credential.helper "netrc -f C:/path/to/_netrc.gpg -v"

(Notez le ' /': C:\path\to...ne fonctionnerait pas du tout.) (Vous pouvez utiliser d'abord -v -dpour voir ce qui se passe.)

Désormais, toute commande Git utilisant une URL HTTP (S) qui nécessite une authentification déchiffrera ce _netrc.gpgfichier et utilisera le login / mot de passe associé au serveur que vous contactez. La première fois, GPG vous demandera la phrase secrète de votre clé GPG, pour décrypter le fichier. Les autres fois, l'agent gpg lancé automatiquement par le premier appel GPG vous fournira cette phrase secrète.

De cette façon, vous pouvez mémoriser plusieurs URL / identifiants / mots de passe dans un seul fichier et les stocker sur votre disque crypté.
Je le trouve plus pratique qu'un "cache" helper ", où vous devez vous souvenir et taper (une fois par session) un mot de passe différent pour chacun de vos services distants, pour que ce mot de passe soit mis en cache en mémoire.

Avec Git 2.26 (Q1 2020), l'exemple d'aide des informations d'identification à utiliser .netrca été mis à jour pour fonctionner immédiatement. Voir patch / discussion .

Voir commit 6579d93 , commit 1c78c78 (20 décembre 2019) par Denton Liu ( Denton-L) .
^{(Fusionné par Junio ​​C Hamano - gitster- dans commit 1fd27f8 , 25 déc.2019 )}

contrib/credential/netrc: rendre PERL_PATHconfigurable

^{Signé par: Denton Liu}

Le chemin de shebang pour l'interprète Perl en git-credential-netrcétait codé en dur.
Cependant, certains utilisateurs peuvent l'avoir situé à un emplacement différent et auraient donc dû modifier manuellement le script.

Ajoutez un .perlpréfixe au script pour le désigner comme modèle et ignorez la version générée.
Augmentez le Makefileafin qu'il génère à git-credential-netrcpartir de git-credential-netrc.perl, tout comme les autres scripts Perl.

Les recettes Makefile ont été volées sans vergogne contrib/mw-to-git/Makefile.

Et:

Avec la version 2.26 (T1 2020), l'exemple d'assistance des informations d'identification pour l'utilisation de .netrc a été mis à jour pour fonctionner immédiatement.

Voir commit 6579d93 , commit 1c78c78 (20 décembre 2019) par Denton Liu ( Denton-L) .
^{(Fusionné par Junio ​​C Hamano - gitster- dans commit 1fd27f8 , 25 déc.2019 )}

contrib/credential/netrc: travailler hors repo

^{Signé par: Denton Liu}

Actuellement, git-credential-netrcne fonctionne pas en dehors d'un référentiel git. Il échoue avec l'erreur suivante:

fatal: Not a git repository: . at /usr/share/perl5/Git.pm line 214.

Cependant, il n'y a aucune raison réelle de devoir être dans un référentiel. Les assistants d'identification devraient également être en mesure de fonctionner correctement en dehors du référentiel.

Appelez la version non auto de config()afin qu'elle git-credential-netrcn'ait plus besoin d'être exécutée dans un référentiel.

Jeff King ( peff) ajoute:

Je suppose que vous utilisez un cryptage gpg netrc(sinon, vous devriez probablement simplement l'utiliser credential-store).
Pour un accès par mot de passe "en lecture seule", je trouve que la combinaison passavec config comme ceci est un peu plus agréable:

[credential "https://github.com"]
  username = peff
  helper = "!f() { test $1 = get && echo password=`pass github/oauth`; }; f"

Il existe un moyen simple et à l'ancienne de stocker les informations d'identification de l'utilisateur dans une URL HTTPS:

https://user:password@github.com/...

Vous pouvez modifier l'URL avec git remote set-url <remote-repo> <URL>

L'inconvénient évident de cette approche est que vous devez stocker le mot de passe en texte brut. Vous pouvez toujours simplement entrer le nom d'utilisateur ( https://user@github.com/...) qui vous fera au moins économiser la moitié des tracas.

Vous préférerez peut-être passer à SSH ou utiliser le logiciel client GitHub.

Utilisez un magasin d'informations d'identification.

Pour Git 2.11+ sur OS X et Linux , utilisez le magasin d'informations d'identification intégré de Git :

git config --global credential.helper libsecret

Pour msysgit 1.7.9+ sur Windows :

git config --global credential.helper wincred

Pour Git 1.7.9+ sur OS X, utilisez:

git config --global credential.helper osxkeychain

Vous pouvez simplement utiliser

git config credential.helper store

Lorsque vous saisirez le mot de passe la prochaine fois avec Pull ou Push, il sera stocké dans un fichier .git-credentials en texte brut (un peu incertain, mais placez-le simplement dans un dossier protégé).

Et c'est tout, comme indiqué sur cette page:

git-credential-store

Il n'était pas immédiatement évident pour moi que je devais d'abord télécharger l'aide! J'ai trouvé le téléchargement de credential.helper sur Atlassian's Authentifying permanent with Git repositories .

Citation:

Suivez ces étapes si vous souhaitez utiliser Git avec la mise en cache des informations d'identification sur OS X:

Téléchargez le binaire git-credential-osxkeychain.

Exécutez la commande ci-dessous pour vous assurer que le binaire est exécutable:

chmod a+x git-credential-osxkeychain

Mettez-le dans le répertoire /usr/local/bin.

Exécutez la commande ci-dessous:

git config --global credential.helper osxkeychain

Incluez simplement les informations de connexion dans l'URL:

git remote rm origin
git remote add origin https://username:mypassword@github.com/path/to/repo.git

Remarque: je ne recommande pas cette méthode, mais si vous êtes pressé et que rien d'autre ne fonctionne, vous pouvez utiliser cette méthode.

Sur une configuration GNU / Linux, un ~ / .netrc fonctionne très bien aussi:

$ cat ~/.netrc
machine github.com login lot105 password howsyafather

Cela peut dépendre des bibliothèques réseau que Git utilise pour le transport HTTPS .

Pour Windows, vous pouvez utiliser le plug-in Git Credential Manager (GCM). Il est actuellement géré par Microsoft. La bonne chose est qu'il enregistre le mot de passe dans le Windows Credential Store, pas en texte brut.

Il y a un programme d'installation sur la page des versions du projet. Cela installera également la version officielle de Git pour Windows avec le gestionnaire d'informations d'identification intégré. Il permet une authentification à deux facteurs pour GitHub (et d'autres serveurs). Et dispose d'une interface graphique pour la connexion initiale.

Pour les utilisateurs de Cygwin (ou les utilisateurs utilisant déjà le Git officiel pour Windows), vous préférerez peut-être l'installation manuelle. Téléchargez le package zip à partir de la page des versions . Extrayez le package, puis exécutez le install.cmdfichier. Cela s'installera dans votre ~/bindossier. (Assurez-vous que votre ~/binrépertoire est dans votre PATH.) Vous le configurez ensuite à l'aide de cette commande:

git config --global credential.helper manager

Git exécutera ensuite le git-credential-manager.exelors de l'authentification sur n'importe quel serveur.

Si vous ne souhaitez pas stocker votre mot de passe en texte clair comme l'a dit Mark, vous pouvez utiliser une URL GitHub différente pour la récupération que pour la transmission. Dans votre fichier de configuration, sous [remote "origin"]:

url = git://github.com/you/projectName.git
pushurl = git@github.com:you/projectName.git

Il demandera toujours un mot de passe lorsque vous poussez, mais pas lorsque vous récupérez, au moins pour les projets open source.

OAuth

Vous pouvez créer votre propre jeton d'API personnel ( OAuth ) et l'utiliser de la même manière que vous utiliseriez vos informations d'identification normales (à:) /settings/tokens. Par exemple:

git remote add fork https://4UTHT0KEN@github.com/foo/bar
git push fork

.netrc

Une autre méthode consiste à configurer votre utilisateur / mot de passe dans ~/.netrc( _netrcsous Windows), par exemple

machine github.com
login USERNAME
password PASSWORD

Pour HTTPS, ajoutez la ligne supplémentaire:

protocol https

Un assistant d'identification

Pour mettre en cache votre mot de passe GitHub dans Git lors de l'utilisation de HTTPS, vous pouvez utiliser un assistant d'identification pour dire à Git de se souvenir de votre nom d'utilisateur et de votre mot de passe GitHub chaque fois qu'il communique avec GitHub.

• Mac: git config --global credential.helper osxkeychain( osxkeychain helperest requis),
• Les fenêtres: git config --global credential.helper wincred
• Linux et autres: git config --global credential.helper cache

En relation:

• Comment stocker votre mot de passe https GitHub sous Linux dans un trousseau de terminal?
• Comment puis-je m'assurer que Git ne me demande pas mon nom d'utilisateur et mon mot de passe GitHub?
• Configurer les clients Git, comme GitHub pour Windows, pour ne pas demander d'authentification
• Pousser un dépôt local vers un dépôt GitHub doté d'une authentification à deux facteurs

Vous pouvez utiliser des assistants d'identification.

git config --global credential.helper 'cache --timeout=x'

où xest le nombre de secondes.

Après avoir cloné le référentiel repo, vous pouvez modifier repo/.git/configet ajouter une configuration comme ci-dessous:

[user]
    name = you_name
    password = you_password
[credential]
    helper = store

Ensuite, on ne vous demandera pas usernameet passwordencore.

Je sais que ce n'est pas une solution sécurisée, mais parfois vous avez juste besoin d'une solution simple - sans rien installer d'autre. Et comme helper = store ne fonctionnait pas pour moi, j'ai créé un assistant factice:

Créez un script et placez-le dans votre dossier bin utilisateurs, ici nommé credfake , ce script fournira votre nom d'utilisateur et votre mot de passe:

#!/bin/bash
while read line
do
  echo "$line"
done < "/dev/stdin"
echo username=mahuser
echo password=MahSecret12345

rendez-le exécutable:

chmod u+x /home/mahuser/bin/credfake

puis configurez-le dans git:

git config --global credential.helper /home/mahuser/bin/credfake

(ou utilisez-le sans --global pour le seul dépôt)

et - voilá - git utilisera cet utilisateur + mot de passe.

Un jeton d'authentification doit être utilisé à la place du mot de passe du compte. Accédez aux paramètres / applications GitHub, puis créez un jeton d'accès personnel. Le jeton peut être utilisé de la même manière qu'un mot de passe.

Le jeton est destiné à permettre aux utilisateurs de ne pas utiliser le mot de passe du compte pour le travail de projet. Utilisez uniquement le mot de passe lorsque vous effectuez des tâches d'administration, comme la création de nouveaux jetons ou la révocation d'anciens jetons.

Au lieu d'un jeton ou d'un mot de passe qui accorde à un utilisateur un accès complet à un compte GitHub, une clé de déploiement spécifique au projet peut être utilisée pour accorder l'accès à un référentiel de projet unique. Un projet Git peut être configuré pour utiliser cette clé différente dans les étapes suivantes lorsque vous pouvez toujours accéder à d'autres comptes ou projets Git avec vos informations d'identification normales:

1. Écrivez un fichier de configuration SSH qui contient le Host, IdentityFilepour la clé de déploiement, peut-être le UserKnownHostsFile, et peut-être le User(même si je pense que vous n'en avez pas besoin).
2. Écrivez un script shell wrapper SSH qui est virtuellement ssh -F /path/to/your/config $*
3. Préparez-vous GIT_SSH=/path/to/your/wrapperdevant votre commande Git normale. Ici, git remote(l'origine) doit utiliser le git@github.com:user/project.gitformat.

Il est préférable d'utiliser les informations d'identification pour la sécurité, mais vous pouvez les conserver pendant un certain temps en utilisant le cache:

git config --global credential.helper cache
git config credential.helper 'cache --timeout=3600'

Vos informations d'identification seront enregistrées pendant 3600 secondes.

Les choses sont un peu différentes si vous utilisez l' authentification à deux facteurs comme je le suis. Comme je n'ai pas trouvé de bonne réponse ailleurs, je vais en coller une ici pour que je puisse la trouver plus tard.

Si vous utilisez l'authentification à deux facteurs, la spécification du nom d'utilisateur / mot de passe ne fonctionnera même pas - vous obtenez un accès refusé. Mais vous pouvez utiliser un jeton d'accès à l'application et utiliser l'aide aux informations d'identification de Git pour le mettre en cache pour vous. Voici les liens pertinents:

• Configuration de la ligne de commande pour fonctionner avec l'authentification à 2 facteurs (recherchez la section intitulée "Comment cela fonctionne-t-il pour la ligne de commande Git?")
• Mise en cache des informations d'identification

Et je ne me souviens pas où j'ai vu cela, mais quand on vous demande votre nom d'utilisateur - c'est là que vous collez le jeton d'accès à l'application. Laissez ensuite le mot de passe vide. Cela a fonctionné sur mon Mac.

Cela fonctionne pour moi, j'utilise Windows 10

git config --global credential.helper wincred

Habituellement, vous avez une URL distante, quelque chose comme ça,

git remote -v

origin    https://gitlab.com/username/Repo.git (fetch)
origin    https://gitlab.com/username/Repo.git (push)

Si vous souhaitez ignorer le nom d'utilisateur et le mot de passe lors de l'utilisation git push, essayez ceci:

 git remote set-url origin https://username:password@gitlab.com/username/Repo.git

Je viens d'ajouter la même URL (avec les détails de l'utilisateur, y compris le mot de passe) à l'origine.

REMARQUE: cela ne fonctionne pas si le nom d'utilisateur est un identifiant de messagerie.

git remote -v

origin    https://username:password@gitlab.com/username/Repo.git (fetch)
origin    https://username:password@gitlab.com/username/Repo.git (push)

J'ai obtenu ma réponse de la page de manuel de gitcredentials (7) . Pour mon cas, je n'ai pas de cache d'informations d'identification dans mon installation Windows; J'utilise credential-store.

Après avoir utilisé credential-store, le nom d'utilisateur / mot de passe sont stockés dans le [dossier utilisateur] /. Git-credentials fichier. Pour supprimer le nom d'utilisateur / mot de passe, supprimez simplement le contenu du fichier.

La documentation du compositeur mentionne que vous pouvez l'empêcher d'utiliser l'API GitHub, afin qu'il agisse comme git clone:

Si vous définissez la no-apiclé sur truesur un référentiel GitHub, il clonera le référentiel comme il le ferait avec tout autre référentiel Git au lieu d'utiliser l'API GitHub. Mais contrairement à l'utilisation gitdirecte du pilote, composer tentera toujours d'utiliser les fichiers zip de GitHub.

La section ressemblerait donc à ceci:

"repositories": [
    {
        "type": "vcs",
        "no-api": true,
        "url": "https://github.com/your/repo"
    }
],

Gardez à l'esprit que l'API est là pour une raison. Donc, cela devrait être une méthode de dernier recours concernant l'augmentation de la charge sur github.com.

Vous modifiez également le fichier bashrc et y ajoutez un script.

Cela vous demanderait votre mot de passe une fois lorsque vous démarrez Git, puis s'en souviendrait jusqu'à ce que vous vous déconnectiez.

SSH_ENV=$HOME/.ssh/environment
  
# Start the ssh-agent
function start_agent {
    echo "Initializing new SSH agent..."

    # Spawn ssh-agent
    /usr/bin/ssh-agent | sed 's/^echo/#echo/' > "${SSH_ENV}"
    echo succeeded
    chmod 600 "${SSH_ENV}"
    . "${SSH_ENV}" > /dev/null
    /usr/bin/ssh-add
}
  
if [ -f "${SSH_ENV}" ]; then
     . "${SSH_ENV}" > /dev/null
   ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
      start_agent;
  }
else
    start_agent;
fi

Si vous utilisez osxkeychainun jeton qui a expiré et que vous souhaitez le mettre à jour, procédez comme suit:

Exécutez dans le terminal, puis appuyez deux fois sur entrée.

git credential-osxkeychain erase
 host=github.com
 protocol=https

Vous devez maintenant être invité à saisir un nom d'utilisateur / mot de passe. Cependant, il semble parfois que cela ne «prenne» pas et que vous devez continuer à rentrer.

Si tel est le cas, redémarrez votre ordinateur . Maintenant, la prochaine fois que vous exécutez une commande git et entrez votre nom d'utilisateur / mot de passe, il sera enregistré.