Ho il git pushmio lavoro in un repository Git remoto.

Tutti pushmi chiederanno di inserire usernamee password. Vorrei evitarlo per ogni push, ma come configurarlo per evitarlo?

1. Generare una chiave SSH

Linux / Mac

Apri il terminale per creare i tasti ssh:

cd ~                 #Your home directory
ssh-keygen -t rsa    #Press enter for all values

Per Windows

(Funziona solo se il programma di commit è in grado di utilizzare certificati / chiavi ssh private e pubbliche)

1. Usa Putty Gen per generare una chiave
2. Esporta la chiave come chiave SSH aperta

Ecco una procedura dettagliata su putty gen per i passaggi precedenti

2. Associare la chiave SSH al repository remoto

Questo passaggio varia in base alla configurazione del telecomando.

• Se si tratta di un repository GitHub e si dispone dei privilegi di amministratore, accedere alle impostazioni e fare clic su "Aggiungi chiave SSH". Copia il contenuto del tuo ~/.ssh/id_rsa.pubnel campo "Chiave".

• Se il tuo repository è gestito da qualcun altro, dai al tuo amministratore id_rsa.pub.

• Se il tuo repository remoto è amministrato dal tuo, puoi usare questo comando per esempio:

  scp ~/.ssh/id_rsa.pub YOUR_USER@YOUR_IP:~/.ssh/authorized_keys/id_rsa.pub

3. Impostare l'URL remoto su un modulo che supporti SSH ¹

Se hai eseguito i passaggi precedenti e ricevi ancora la richiesta della password, assicurati che l'URL del repository sia nel modulo

git+ssh://git@github.com/username/reponame.git

al contrario di

https://github.com/username/reponame.git

Per visualizzare l'URL del repository, eseguire:

git remote show origin

Puoi modificare l'URL con:

git remote set-url origin git+ssh://git@github.com/username/reponame.git

_{[1] Questa sezione comprende la risposta di Eric P}

Autenticazione permanente con i repository Git,

Eseguire il comando seguente per abilitare la memorizzazione nella cache delle credenziali.

$ git config credential.helper store
$ git push https://github.com/repo.git

Username for 'https://github.com': <USERNAME>
Password for 'https://USERNAME@github.com': <PASSWORD>

L'uso deve anche specificare la scadenza della memorizzazione nella cache ,

git config --global credential.helper 'cache --timeout 7200'

Dopo aver abilitato la memorizzazione nella cache delle credenziali, verrà memorizzato nella cache per 7200 secondi (2 ore) .

Nota: helper delle credenziali che memorizza la password non crittografata sul disco locale.

Se hai già impostato le chiavi SSH e stai ancora ricevendo la richiesta della password, assicurati che l'URL del repository sia nel modulo

git+ssh://git@github.com/username/reponame.git

al contrario di

https://github.com/username/reponame.git

Per visualizzare l'URL del repository, eseguire:

git remote show origin

Puoi modificare l'URL in questo git remote set-urlmodo:

git remote set-url origin git+ssh://git@github.com/username/reponame.git

Basta usare l' --repoopzione per il comando push git. Come questo:

$ git push --repo https://name:password@bitbucket.org/name/repo.git

Risparmio indefinito

Puoi usare git-credential-store tramite

git config credential.helper store

che memorizza la tua password non crittografata nel file system :

L'uso di questo helper memorizza le tue password non crittografate su disco, protette solo dalle autorizzazioni del filesystem. Se questo non è un compromesso sulla sicurezza accettabile, prova git-credential-cache o trova un aiuto che si integri con l'archiviazione sicura fornita dal tuo sistema operativo.

Con un timeout

Utilizzare la cache di credenziali git che per impostazione predefinita memorizza la password per 15 minuti.

git config credential.helper cache

per impostare un timeout diverso, utilizzare --timeout(qui 5 minuti)

git config credential.helper 'cache --timeout=300'

Salvataggio sicuro a tempo indeterminato (OS X e Windows)

• Se stai usando un Mac, Git viene fornito con una modalità "osxkeychain" , che memorizza nella cache le credenziali nel portachiavi sicuro collegato all'account di sistema. Questo metodo memorizza le credenziali su disco e non scadono mai, ma sono crittografate con lo stesso sistema che archivia i certificati HTTPS e i riempimenti automatici di Safari. L'esecuzione del seguente sulla riga di comando attivare questa funzione: git config --global credential.helper osxkeychain. Dovrai archiviare le credenziali nel Portachiavi utilizzando anche l'app Portachiavi.
• Se stai usando Windows, puoi installare un helper chiamato "Git Credential Manager per Windows". Questo è simile all'helper "osxkeychain" descritto sopra, ma utilizza l'archivio credenziali di Windows per controllare le informazioni riservate. È disponibile all'indirizzo https://github.com/Microsoft/Git-Credential-Manager-for-Windows . [sottolinea il mio]

Stavo usando il collegamento https ( https://github.com/org/repo.git) invece del collegamento ssh;

git@github.com:org/repo.git  

Il passaggio ha risolto il problema per me!

Passo 1 -

Crea chiavi SSH sul tuo sistema linux usando il comando seguente

ssh-keygen -t rsa -b 4096 -C "your_email"

Chiederà passphrase e nome file (il valore predefinito sarà ~ / .ssh / id_rsa, ~ / .ssh / id_rsa.pub)

Passo 2 -

Una volta creati i file aggiungi la chiave pubblica id_rsa.pub alla sezione ssh dell'account github.

Passaggio 3:

Sulla tua macchina aggiungi la chiave privata id_rsa a ssh-agent usando il comando seguente

ssh-add ~/.ssh/id_rsa 

Passaggio 4:

Ora aggiungi l'URL remoto git@github.com: user_name / repo_name.git al tuo repository git locale usando il comando seguente.

git remote remove origin
git remote add origin git@github.com:user_name/repo_name.git

Questo è tutto.

Collega il tuo client git al tuo archivio di credenziali del sistema operativo. Ad esempio, in Windows associ l'helper delle credenziali a wincred:

git config --global credential.helper wincred

C'è un modo per saltare la digitazione della password quando si utilizza https: // su GitHub?

Sul sistema operativo Windows, usa questo invece, questo funziona per me:

https://{Username}:{Password}@github.com/{Username}/{repo}.git

per esempio

git clone https://{Username}:{Password}@github.com/{Username}/{repo}.git

git pull https://{Username}:{Password}@github.com/{Username}/{repo}.git

git remote add origin https://{Username}:{Password}@github.com/{Username}/{repo}.git

git push origin master

Volevo solo sottolineare qualcosa sulla soluzione di cui sopra più volte:

git config credential.helper store

È possibile utilizzare qualsiasi comando che richiede una password dopo questo. Non devi spingere. (puoi anche tirare per esempio) Dopo di che, non dovrai digitare nuovamente il tuo nome utente / password.

Ho usato la risposta suggerita da Pavel e ha funzionato per me. La mia differenza era farlo mentre aggiungevo il telecomando in questo modo:git remote add (alias) https://(name:password)@github.com/(the remote address).git

L'esecuzione del comando seguente ha risolto il problema per me.

git config --global credential.helper wincred

Si prega di fare riferimento alla documentazione github di seguito:

https://help.github.com/articles/caching-your-github-password-in-git/

Per quanto ne so, ci sono semplicemente due modi sicuri : ssh o passwd crittografati usando un keystore .

SSH

1. Accedi al tuo github;
2. Visita: https://github.com/settings/keys ;
3. Nuova chiave SSH;
4. cat ~/.ssh/id_rsa.pub, incollalo lì, nominalo e salvalo (se non hai questo file, generane uno per te ssh-keygen -t rsa- basta inserire per tutte le istruzioni);
5. Vai al tuo repository locale e aggiorna il tuo telecomando git remote set-url origin git+ssh://git@github.com/username/reponame.git: puoi prima verificarlo git remote -v);
6. Ecco qua, basta touch t; git add t; git commit -m "test"; git pushe confermare sì per godersi il mondo senza password .

passwd ENCRYPTED utilizzando un keystore

Se usi semplicemente git config --global credential.helper storecome altri menzionati, le tue password non crittografate verranno semplicemente memorizzate in un testo semplice sotto il ~/.git-credentialsquale non è sicuro come sembra.

Prova a crittografarlo come

sudo apt-get install libgnome-keyring-dev
sudo make --directory=/usr/share/doc/git/contrib/credential/gnome-keyring
git config --global credential.helper /usr/share/doc/git/contrib/credential/gnome-keyring/git-credential-gnome-keyring

git config --global credential.helper store

In questo caso, stai usando https://git@github.com/username/reponame.git.

La mia soluzione su Windows:

1. Fare clic destro sulla directory per spingere e selezionare "Git Bash Here".
2. ssh-keygen -t rsa (Premi Invio per tutti i valori)
3. Controllare il terminale per: Your public key has been saved in /c/Users/<your_user_name_here>/.ssh/id_rsa.pub
4. Copia la chiave pubblica dal file specificato.
5. Vai al tuo profilo GitHub => Impostazioni => Chiavi SSH e GPG => Nuova chiave SSH => Incolla qui la tua chiave SSH => Salva

Se il tuo PC è sicuro o non ti interessa la sicurezza della password, questo può essere ottenuto molto semplicemente. Supponendo che il repository remoto sia su GitHub e originsia il tuo nome locale per il repository remoto, usa questo comando

git remote set-url --push origin https://<username>:<password>@github.com/<repo>

Il --pushflag assicura che ciò cambi l'URL del repository solo per il git pushcomando. (La domanda posta nel post originale riguarda git pushsolo il comando. Richiedere un nome utente + una password solo per le operazioni push è la normale configurazione per i repository pubblici su GitHub. Si noti che i repository privati su GitHub richiederebbero anche un nome utente + password per le operazioni pull e fetch , quindi per un repository privato non vorresti usare il --push flag...)

ATTENZIONE: questo è intrinsecamente insicuro perché:

1. il tuo ISP, o chiunque acceda alla tua rete, può facilmente vedere la password in chiaro nell'URL;

2. chiunque ottenga l'accesso al tuo PC può visualizzare la tua password utilizzando git remote show origin.

Ecco perché usare una chiave SSH è la risposta accettata.

Anche una chiave SSH non è totalmente sicura . Chiunque abbia accesso al tuo PC, ad esempio, può comunque fare push che rovinano il tuo repository o, peggio ancora, push si impegna a fare sottili modifiche al tuo codice. (Tutti i commit spinti sono ovviamente molto visibili su GitHub. Ma se qualcuno volesse cambiare il codice di nascosto, potrebbero --amendun precedente commit senza cambiare il messaggio di commit, e quindi forzarlo a spingerlo. Sarebbe furtivo e abbastanza difficile da notare nella pratica. )

Ma rivelare la tua password è peggio . Se un utente malintenzionato acquisisce conoscenza del tuo nome utente + password, può fare cose come bloccarti dal tuo account, eliminare il tuo account, eliminare definitivamente il repository, ecc.

In alternativa, per semplicità e sicurezza, puoi fornire solo il tuo nome utente nell'URL, in modo che dovrai digitare la password ogni volta che git pushnon dovrai fornire il tuo nome utente ogni volta. (Mi piace molto questo approccio, dover digitare la password mi fa una pausa per pensare ogni volta git push, quindi non posso git pushper caso.)

git remote set-url --push origin https://<username>@github.com/<repo>

Tutto ciò deriva dal fatto che git non fornisce un'opzione nei comandi clone / pull / push / fetch per inviare le credenziali attraverso una pipe. Sebbene fornisca credential.helper, memorizza sul file system o crea un demone ecc. Spesso, le credenziali di GIT sono a livello di sistema e onus per tenerle al sicuro è sull'applicazione che richiama i comandi git. Davvero molto pericoloso.

Ecco cosa ho dovuto aggirare. 1. La versione di Git (git --version) dovrebbe essere maggiore o uguale a 1.8.3.

GIT CLONE

Per la clonazione, utilizzare "git clone URL" dopo aver modificato l'URL dal formato, http: // {myuser} @ {my_repo_ip_address} / {myrepo_name.git} a http: // {myuser}: {mypwd} @ {my_repo_ip_address} /{myrepo_name.git}

Quindi eliminare il repository della password come nella sezione successiva.

SPURGO

Ora, questo sarebbe andato e

1. scritto la password in git remote origin. Digita "git remote -v" per vedere il danno. Correggere impostando l'URL di origine remoto senza password. "git remote set_url origin http: // {myuser} @ {my_repo_ip_address} / {myrepo_name.git}"
2. ha scritto la password in .git / registra nel repository. Sostituisci tutte le istanze di pwd usando un comando unix come find .git / logs -exec sed -i 's / {my_url_with_pwd} // g' {} \; Qui {my_url_with_pwd} è l'URL con password. Poiché l'URL presenta barre rovesciate, deve essere evitato da due barre rovesciate. Ad esempio, per l'URL http: // kris: passs123@192.168.0.1/proj.git -> http: \\ / \\ / kris: passs123@192.168.0.1 \\ / proj.git

Se l'applicazione utilizza Java per eseguire questi comandi, utilizzare ProcessBuilder anziché Runtime. Se è necessario utilizzare Runtime, utilizzare getRunTime (). Exec che accetta l'array String come argomenti con / bin / bash e -c come argomenti anziché quello che accetta una singola stringa come argomento.

GIT FETCH / PULL / PUSH

1. imposta la password nell'URL remoto di git come: "git remote set_url origin http: // {myuser}: {mypwd} @ {my_repo_ip_address} / {myrepo_name.git}"
2. Immettere il comando git fetch / push / pull. Non ti verrà richiesta la password.
3. Eseguire lo spurgo come nella sezione precedente. Non perderlo.

Devi impostare una chiave privata SSH, puoi esaminarla pagina , come eseguire l'installazione su Mac, se sei su Linux la guida dovrebbe essere quasi la stessa, su Windows avresti bisogno di uno strumento come MSYS .

Sembra che, almeno quando si utilizza TortoiseGIT su Windows, è possibile creare le chiavi SSH e trasferirle sul server GIT usando semplicemente:

> ssh-keygen.exe
> ssh-copy-id [username]@[GIT_server]