Ottenere l'autorizzazione negata (chiave pubblica) su gitlab

Il mio problema è che non riesco a eseguire il push o il recupero da GitLab. Tuttavia, posso clonare (tramite HTTP o tramite SSH). Ottengo questo errore quando provo a spingere:

Autorizzazione negata (chiave pubblica) fatale: impossibile leggere dal repository remoto

Da tutti i thread che ho cercato, ecco cosa ho fatto:

• Imposta una chiave SSH sul mio computer e aggiungi la chiave pubblica a GitLab
• Fatto il config --global per nome utente ed e-mail
• Clonato tramite SSH e HTTP per verificare se avrebbe risolto il problema
• Fatto il comando ssh -T git@gitlab.com

Se hai qualche idea su come risolvere il mio problema, sarebbe molto apprezzato.

L'ho trovato dopo aver cercato molto. Funzionerà perfettamente bene per me.

1. Vai a "Git Bash" proprio come cmd. Fare clic destro e "Esegui come amministratore".
2. genere ssh-keygen
3. Premere Invio.
4. Ti chiederà di salvare la chiave nella directory specifica.
5. Premere Invio. Ti verrà richiesto di digitare la password o inserire senza password.
6. La chiave pubblica verrà creata nella directory specifica.
7. Ora vai alla directory e apri la .sshcartella.
8. Vedrai un file id_rsa.pub. Aprilo sul blocco note. Copia tutto il testo da esso.
9. Vai su https://gitlab.com/profile/keys .
10. Incolla qui nel campo di testo "chiave".
11. Ora fai clic sul "Titolo" in basso. Si riempirà automaticamente.
12. Quindi fare clic su "Aggiungi chiave".

Ora provaci e funzionerà di sicuro.

Passaggio 1: aggiunto un file di configurazione nel ~/.ssh/configfile che sembra

   User git
   Hostname gitlab.com
   IdentityFile ~/.ssh/id_rsa_gitlab
   TCPKeepAlive yes
   IdentitiesOnly yes

Passaggio 2: basta clonare il repository git SENZA sudo.
Documentazione: https://gitlab.com/help/ssh/README#working-with-non-default-ssh-key-pair-paths

Penso che la soluzione semplice sia aggiungere la chiave privata all'agente di autenticazione (se la tua chiave non lo è ~/.ssh/id_rsa),

ssh-add ~/.ssh/<your private key>

Fondamentalmente lasci ssh-agentche te ne occupi.

Inoltre, puoi aggiungerlo in modo permanente .

Nel mio caso non ha funzionato nel WSL (sottosistema Windows per Linux).

Quando avvio il WSL, devo

• avvia ssh-agent_ eval $(ssh-agent -s)
• aggiungi la chiave all'agente ssh: ssh-add ~/.ssh/id_rsa
• se richiesto, inserire la password

Ora la connessione funziona.
Possiamo provarlo conssh -T git@github.com

Appunti:

• weasel-pageant ci permette di riutilizzare le chiavi ssh che sono caricate nel concorso PuTTY all'interno del WSL
• spiegazione dettagliata: Git tramite SSH da Windows restituisce Autorizzazione negata

assicurati di non essere in esecuzione sudo git clone git@gitlab.com:project/somethiing.git, altrimenti ssh cercherà /root/.sshinvece della chiave che hai caricato~/.ssh/id_rsa

C'è una soluzione molto semplice a questo: invece di lavorare con ssh, passa a https. per fare questo: nella cartella del tuo progetto hai una cartella .git - hai un file di configurazione - aprilo in un editor di testo e cambia la riga

url =git@gitlab.com: tuonome / tuoproject.git

per

url = https://gitlab.com/yourname/yourproject.git

se sei in Linux o macox, prova questo nel terminale:

ssh-add -l

se non restituisce nulla, prova questo:

ssh-add

deve creare identità in ~ / .ssh / id_rsa

dopo un nuovo tentativo:

ssh-add -l

deve restituire la tua identità, quindi dopo riprovare a clonare, deve funzionare

NB: non dimenticare di aggiungere la tua chiave ssh nel tuo profilo gitlab

Grazie

Nel mio caso, non è stato un problema gitlab, ma uno di configurazione sshd. Il server SSH non ha consentito la connessione ad eccezione di un elenco di utenti. L'utente git, quello che si collega in remoto a gitlab, non era in quella lista. Quindi, controlla prima di ogni altra cosa.

Puoi controllare la configurazione del tuo server SSH in /etc/ssh/sshd_config. Se hai una linea con l'opzione AllowUsers, aggiungi git ad essa:

AllowUsers user1 user2 user3 git

Ho gitlab in esecuzione con la finestra mobile, questo è quello che ho fatto per risolvere il mio problema.

È stato riscontrato che all'interno di docker / var / log / gitlab / sshd / current c'erano più ricorrenze di un messaggio:

Autenticazione rifiutata: cattiva proprietà o modalità per il file /var/opt/gitlab/.ssh/authorized_keys

Dopo di che ho cambiato la proprietà di quel file da 99: utenti a git: utenti con:

chown git: utenti authorized_keys

I passaggi da eseguire hanno lo stesso errore ma l'ho risolto. Gitlab vuole ssh-rsa, quindi di seguito è riportato il codice per eseguire ssh per rsa

1. ssh-keygen -o -t rsa -b 4096 -C "name@gmail.com"

name@gmail.com è l'e-mail del tuo account gitlab

2. Ti verrà chiesto di inserire, quindi premi Invio dopo aver richiesto il codice seguente,

   Inserisci il file in cui salvare la chiave (/home/yourDesktopName/.ssh/id_rsa):

3. Ti chiederà di nuovo di inserire, quindi premi Invio dopo aver richiesto il codice seguente,

   Inserisci passphrase (vuoto per nessuna passphrase):

4. Richiederà di nuovo l'ultimo accesso, quindi premi Invio dopo aver richiesto il codice seguente,

   Immettere di nuovo la stessa passphrase:

5. Mostrerai il tuo ssh-rsa generate.

6. Accedi al tuo account Gitlab e vai sulla barra di navigazione destra otterrai le impostazioni e nella barra laterale sinistra otterrai il tasto SSH. Entra in esso.

7. Guarda sopra il prompt che ti chiede di entrare, otterrai il percorso di ssh-rsa.

8. Vai alla tua cartella SSH e ottieni id_rsa.pub

9. Aprilo e ottieni la chiave e Copia Incolla su Gitlab e il gioco è fatto.

10. Controlla da: ssh -T git@gitlab.com

11. Otterrete: Welcome to GitLab, @joy4!

12. Fatto.

In precedenza è stato molto difficile per me, ma quando l'ho provato è diventato così facile aggiungere la chiave ssh in Mac e Linux. Ci sono alcuni passaggi e comandi per fare ciò come segue:

1. Apri un terminale del tuo sistema e spostati nella directory del progetto con il comando:

cd 'project directory name'

2. Esegui il comando ssh-keygenin quel terminale e immettilo finché non appare l'immagine casuale della chiave.

3. Quindi immettere un altro comando in quel terminale:

cat ~/.ssh/id_rsa.pub

Genererà la tua chiave ssh. La chiave inizierà con ssh-rsae finirà con .local.

4. Copia la chiave e vai alla sezione del tuo profilo Gitlab, quindi alla ssh keysezione e incollala lì. Fare clic sul Addpulsante funzionerà.

Ho avuto lo stesso problema, l'ho risolto aggiungendo una nuova chiave ssh:

1. ssh-keygen -t ed25519 -C "email@example.com"
2. Copia la tua chiave SSH pubblica negli appunti (xclip -sel clip < ~/.ssh/id_ed25519.pub nel mio caso su Linux)
3. Su gitlab, vai su settings=>sshkeys e oltre la nuova chiave

Quando si dispone di più account Git e si desidera una chiave SSH diversa

Devi seguire lo stesso passaggio per generare il tasto ssh, ma assicurati di si

ssh-keygen -t ed25519 -C "your-email-id@gmail.com" 

Immettere il percorso che si desidera salvare (ad es. My-pc / Desktop / .ssh / ed25519)

Aggiungi la chiave pubblica a gitlab ( Come aggiungere la chiave ssh a gitlab )

Devi creare una nuova identità ssh usando il comando seguente

ssh-add ~/my-pc/Desktop/.ssh/ed25519

Due cose principalmente

1. Devi avere le chiavi id_rsa.pub e id_rsa (private) nella tua cartella .ssh (che dovrebbe essere nella tua cartella home. Creala se non c'è metti le tue chiavi). Non funzionerebbe se hai nominato i file delle chiavi in ​​modo diverso

2. Modifica l'autorizzazione di id_rsa come chmod 400 ~ / .ssh / id_rsa

Un altro problema che può causare questo comportamento è quando si ha un'installazione con 2 possibili posizioni% HOME%.

Sto usando un PC in cui alcuni dei miei documenti sono archiviati localmente e alcuni sono memorizzati su un'unità di rete. Alcune applicazioni pensano che C:\Users\<MyUserName>\sia mia %home%, altre lo pensanoU:\ sia la casa.

Risulta ssh-keygenmesso sotto la mia chiave privata C:\users\<MyUserName>\, e che ssh -Tessh -v guarda lì.

Quindi tutto sembra funzionare bene, tranne quello git clone, git pushe altri cercano una chiave U:\. Che non riesce, quindi ottengo l'errore di cui sopra.

Mi ci è voluta un'ora per scoprirlo, ma alla fine la soluzione è stata semplice: ho copiato tutto da C:\Users\<MyUserName>\.sshaU:\.ssh

Ho risolto in questo modo ..

Ha generato una chiave per Windows usando questo comando:

ssh-keygen -t rsa -C "your.email@example.com" -b 4096

ma il problema era che dopo aver eseguito questo comando, veniva visualizzata una riga: "Inserisci il file in cui salvare la chiave (/c/Users/xxx/.ssh/id_rsa):" Qui, stavo dando solo il nome del file a causa del quale la mia chiave veniva salvata nel mio pwd e non nella posizione indicata. Quando ho fatto "git clone", presupponevo che la chiave fosse nella posizione "/c/Users/xxx/.ssh/id_rsa" ma non è stata trovata, quindi stava generando un errore.

Al momento della generazione della chiave 2 sono stati generati i file dire "file1" e "file1.pub". Ho rinominato entrambi questi file come

file1 -> id_rsa 

e

file1.pub -> id_rsa.pub

e collocati entrambi nella posizione "/c/Users/xxx/.ssh/"

Vai al terminale e rigenera nuovamente il tasto ssh. Tipo ssh-keygen. Ti chiederà dove vuoi salvarlo, digita il percorso.

Quindi copia la chiave pubblica sulla piattaforma gitlabs. Di solito inizia con ssh-rsa.

Il problema per me era che sono passato UsePAMdal yesal nofile di configurazione SSH sotto /etc/ssh/sshd_config. Con UsePAM yestutto funziona perfettamente.

Ho trovato la soluzione nell'aiuto di gitlab .

To create a new SSH key pair: 
 1. Open a terminal on Linux or macOS, or Git Bash / WSL on Windows.
 2. Generate a new ED25519 SSH key pair: ssh-keygen -t ed25519 -C "email@example.com"
 2.1 Or, if you want to use RSA: ssh-keygen -o -t rsa -b 4096 -C "email@example.com"
 3. Next, you will be prompted to input a file path to save your SSH key pair to... use the suggested path by pressing Enter
 4. Once the path is decided, you will be prompted to input a password to secure your new SSH key pair. It's a best practice to use a password, but it's not required and you can skip creating it by pressing Enter twice.
 5. Copy your public SSH key to the clipboard by using one of the commands below depending on your Operating System:
        macOS:        pbcopy < ~/.ssh/id_ed25519.pub
        WSL / GNU/Linux (requires the xclip package):      xclip -sel clip < ~/.ssh/id_ed25519.pub
        Git Bash on Windows:      cat ~/.ssh/id_ed25519.pub | clip
 6. Navigating to SSH Keys and pasting your public key in the Key field
 7. Click the Add key button

Spero che possa aiutare qualcuno di voi!

Come aggiungere la chiave SSH all'account gitlab in Ubuntu?

1. Apri il terminale nella directory del tuo progetto.
2. Digita 'ssh-keygen -o -t rsa -b 4096 -C "il tuo indirizzo email gitlab"' e premi invio
3. Digita "vim /home/mnbtech/.ssh/id_rsa.pub" e premi invio (o apri manualmente il tuo "id_rsa.pub" dal punto in cui l'hai salvato)

4. Apparirà la chiave SSH. Copia quelli e

5. Vai al tuo account gitlab.

6. Fare clic sull'immagine del profilo e fare clic sull'impostazione
7. Nella parte sinistra selezionare i tasti SSH
8. Quindi incollare la chiave Fare clic su Aggiungi chiave

Verrà aggiunta la chiave SSH!

(NB: se hai la chiave Generazione anteprime SSH e l'autorizzazione per ottenere negato (chiave pubblica). Elimina la tua chiave ssh Anteprima e genera una nuova e aggiungi git user.name ed e-mail sul tuo terminale)

Ho risolto il git@gitlab.com: Permission denied (publickey)problema usando le seguenti istruzioni

1. CORRERE cat ~/.ssh/id_rsa.pub
2. Copia id_rsa.pub(chiave pubblica) nel tuo getlab `Setting -> SSH Keys
3. CORRERE cat ~/.ssh/id_rsa
4. Copia id_rsa(chiave privata) in `Code_repo-> git_auth-> id_rsa

NOTA: se l'utente sta utilizzando rootDockerFile o altrove, prendersi cura dell'utente della macchina, quindi utilizzare sudo suprima di eseguire i comandi sopra per ottenere le chiavi pubbliche e private dell'utente root.

Nel nostro caso, non è stato un problema sul lato utente / client, ma sul lato server Gitlab.

Stiamo eseguendo un'istanza Gitlab CE 12.9 locale su CentOS 7.1.

Abbiamo scoperto che sul server il file .ssh / authorized_keys non si aggiornava correttamente. Gli utenti creano le proprie chiavi SSH (seguendo la guida Gitlab) e aggiungere al server Gitlab, ma il server non aggiorna l'authorized_keys , così sarà sempre portare a errori di autorizzazione negata.

Una soluzione alternativa consisteva nel ricostruire il file authorized_keys eseguendo:

$ sudo gitlab-rake gitlab:shell:setup

Funzionerebbe per chiunque abbia aggiunto le proprie chiavi prima di eseguire l'attività di rake. Per i prossimi utenti che desiderano aggiungere le loro chiavi, qualcuno deve eseguire nuovamente manualmente le attività di rake.

Una soluzione più permanente era quella di non utilizzare il file authorized_keys e utilizzare invece una ricerca indicizzata sul database Gitlab :

GitLab Shell fornisce un modo per autorizzare gli utenti SSH tramite una ricerca rapida e indicizzata nel database GitLab. GitLab Shell utilizza l'impronta digitale della chiave SSH per verificare se l'utente è autorizzato ad accedere a GitLab.

Aggiungi quanto segue al tuo sshd_configfile. Questo di solito si trova in /etc/ssh/sshd_config, ma lo sarà /assets/sshd_configse stai usando Omnibus Docker:

Match User git    # Apply the AuthorizedKeysCommands to the git user only   
  AuthorizedKeysCommand /opt/gitlab/embedded/service/gitlab-shell/bin/gitlab-shell-authorized-keys-check git %u %k   
  AuthorizedKeysCommandUser git 
Match all    # End match, settings apply to all users again 

Ricarica OpenSSH:

# Debian or Ubuntu installations   
sudo service ssh reload

# CentOS installations   
sudo service sshd reload 

Conferma che SSH funziona rimuovendo la chiave SSH dell'utente nell'interfaccia utente, aggiungendone una nuova e tentando di estrarre un repository.

Per impostazione predefinita (bene il valore predefinito sulla nostra installazione), il file Scrivi in ​​authorized_keys è stato controllato nell'area di amministrazione> Impostazioni di ottimizzazione delle prestazioni . Quindi abbiamo deselezionato quello e usato invece il database Gitlab.

Dopo aver impostato la ricerca indicizzata e deselezionato il file Scrivi su authorized_keys , l'accesso SSH è diventato OK.

Per chiunque utilizzi Windows 10 e nient'altro che funzioni per lui / lei:

Nel mio caso, ho dovuto clonare il repository con https anziché ssh e una finestra è spuntata chiedendo le mie credenziali. Dopodiché tutto funziona bene.

Lo so, sto rispondendo molto tardi e anche StackOverflow ha confermato se voglio davvero rispondere. Sto rispondendo perché nessuno ha effettivamente descritto il problema reale, quindi volevo condividere lo stesso.

Le basi

In primo luogo, capire che cos'è il telecomando qui. Il telecomando è GitLab e il tuo sistema è il locale, quindi quando parliamo del telecomando origin, qualsiasi URL impostato git remote -vnell'output è il tuo URL remoto.

I protocolli

Fondamentalmente, clone / push / pull di Git funziona principalmente su due protocolli diversi (ce ne sono anche altri) -

1. Protocollo HTTP
2. Protocollo SSH

Quando cloni un repository (o modifichi l'URL remoto) e utilizzi l'URL HTTP come https://gitlab.com/wizpanda/backend-app.git , utilizza il primo protocollo, ovvero il protocollo HTTP.

Mentre se clonate il repository (o modificate l'URL remoto) e utilizzate l'URL come git@gitlab.com:wizpanda/backend-app.gitallora, utilizza il protocollo SSH.

Protocollo HTTP

In questo protocollo, ogni operazione remota, ad esempio clonazione, push & pull, utilizza la semplice autenticazione, cioè nome utente e password del telecomando (GitLab in questo caso), il che significa che per ogni operazione, è necessario digitare il nome utente e la password che potrebbero essere ingombranti .

Quindi quando si preme / pull / clone, GitLab / GitHub ti autentica con il tuo nome utente e password e ti consente di eseguire l'operazione.

Se vuoi provare questo, puoi passare all'URL HTTP eseguendo il comando git remote set-url origin <http-git-url> .

Per evitare questo caso, è possibile utilizzare il protocollo SSH.

Protocollo SSH

Una semplice connessione SSH funziona su coppie di chiavi pubblico-private. Quindi, nel tuo caso, GitLab non può autenticarti perché stai utilizzando l'URL SSH per comunicare. Ora, GitLab deve conoscerti in qualche modo. Per questo, devi creare una coppia di chiavi pubblica-privata e fornire la chiave pubblica a GitLab.

Ora quando si preme / pull / clone con GitLab, GIT (SSH internamente) offrirà di default la propria chiave privata a GitLab e conferma la propria identità e quindi GitLab consentirà di eseguire l'operazione.

Quindi non ripeterò i passi che sono già stati dati da Muhammad, li ripeterò teoricamente.

1. Genera una coppia di chiavi `ssh-keygen -t rsa -b 2048 -C" La mia chiave SSH comune "
2. La coppia di chiavi generata sarà predefinita in ~/.sshnome id_rsa.pub(chiave pubblica) eid_rsa (chiave privata).
3. Memorizzerai la chiave pubblica sul tuo account GitLab (la stessa chiave può essere utilizzata in più o in qualsiasi server / account).
4. Quando cloni / premi / tira, GIT offre la tua chiave privata.
5. GitLab abbina la chiave privata con la tua chiave pubblica e ti consente di eseguire.

Suggerimenti

È sempre necessario creare una chiave rsa avanzata con almeno 2048 byte. Quindi il comando può essere ssh-keygen -t rsa -b 2048.

https://gitlab.com/help/ssh/README#generating-a-new-ssh-key-pair

Pensiero generale

Entrambi gli approcci hanno i loro pro e contro. Dopo aver digitato il testo sopra, sono andato a cercare di più su questo perché non ho mai letto qualcosa al riguardo.

Ho trovato questo documento ufficiale https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols che racconta di più al riguardo. Il mio punto qui è che, leggendo l'errore e riflettendo sull'errore, puoi creare la tua teoria o comprensione e quindi abbinare alcuni risultati di Google per risolvere il problema :)

Ho aggiunto il mio ~/.ssh/id_rsa.puball'elenco delle chiavi SSH conosciute nelle mie impostazioni GitLab https://gitlab.com/profile/keys . Ciò ha risolto il problema per me. :-)

Uso Ubuntu 18.04, ed era effettivamente un problema di autorizzazione nel mio computer locale. Il problema era scomparso quando ho impostato l'autorizzazione in lettura / scrittura per la mia cartella .git.

Bene ho avuto lo stesso problema e dopo aver provato la risposta proposta da @Khan. Tuttavia, sono stato in grado di farlo funzionare solo cambiando l'URL di origine nel file .git / config nell'indirizzo https: https://gitlab.com/mygitlabusername/mygitproject.git

Dato che l'accesso via ssh è negato, ho capito che usare https non dovrebbe essere un problema. Chiederà comunque il nome utente e la password per ogni push nel repository

Si prega di utilizzare git config credential.helper storese il sito utilizza TLS / SSL. Spero che funzioni

Sembra che ci siano differenze tra i due modi per accedere a un repository git, ovvero utilizzando SSH o HTTPS. Per me, ho riscontrato l'errore perché stavo cercando di inviare il mio repository locale tramite SSH.

Il problema può essere semplicemente risolto facendo clic sul pulsante clone nella pagina di destinazione del progetto e copiando il collegamento HTTPS e sostituendolo al collegamento SSH che appare con il formato "git @ gitlab ...".

Permesso di modifica :: chmod 400 ~ / .ssh / id_rsa Mi ha aiutato.