Obtener permiso denegado (clave pública) en gitlab

Mi problema es que no puedo empujar o buscar desde GitLab. Sin embargo, puedo clonar (a través de HTTP o SSH). Recibo este error cuando intento presionar:

Permiso denegado (clave pública) fatal: no se pudo leer desde el repositorio remoto

De todos los hilos que he visto, esto es lo que he hecho:

• Configurar una clave SSH en mi computadora y agregar la clave pública a GitLab
• Hecho la configuración --global para nombre de usuario y correo electrónico
• Clonado a través de SSH y HTTP para verificar si resolvería el problema
• Hecho el comando ssh -T git@gitlab.com

Si tiene alguna idea sobre cómo resolver mi problema, sería muy apreciado.

Encontré esto después de buscar mucho. Funcionará perfectamente bien para mí.

1. Vaya a "Git Bash" como cmd. Haga clic derecho y "Ejecutar como administrador".
2. Tipo ssh-keygen
3. Presione enter.
4. Le pedirá que guarde la clave en el directorio específico.
5. Presione enter. Le pedirá que escriba la contraseña o que ingrese sin contraseña.
6. La clave pública se creará en el directorio específico.
7. Ahora ve al directorio y abre la .sshcarpeta.
8. Verás un archivo id_rsa.pub. Ábralo en el bloc de notas. Copie todo el texto de él.
9. Vaya a https://gitlab.com/profile/keys .
10. Pegue aquí en el campo de texto "clave".
11. Ahora haga clic en el "Título" a continuación. Se llenará automáticamente.
12. Luego haga clic en "Agregar clave".

Ahora inténtalo y funcionará seguro.

Paso 1: se agregó un archivo de configuración en el ~/.ssh/configarchivo que se parece

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

Paso 2: solo clona el repositorio de git SIN sudo.
Documentación: https://gitlab.com/help/ssh/README#working-with-non-default-ssh-key-pair-paths

Creo que la solución simple es agregar una clave privada al agente de autenticación (si su clave no es ~/.ssh/id_rsa),

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

Básicamente dejas que ssh-agentse encargue de eso.

Además, puede agregarlo permanentemente .

En mi caso, no funcionó en el WSL (Windows Subsystem for Linux).

Cuando comienzo el WSL, debo

• iniciar ssh-agent_ eval $(ssh-agent -s)
• agregue la clave al agente ssh: ssh-add ~/.ssh/id_rsa
• si se le solicita, ingrese la contraseña

Ahora la conexión funciona.
Podemos probar esto conssh -T git@github.com

notas:

• comadreja-concurso nos permite reutilizar las claves ssh que se cargan en concurso PuTTY dentro del WSL
• explicación detallada: Git a través de SSH desde Windows devuelve Permiso denegado

asegúrese de no estar ejecutando sudo git clone git@gitlab.com:project/somethiing.git, de lo contrario, ssh buscará en /root/.sshlugar de la clave que cargó~/.ssh/id_rsa

Hay una solución muy simple para esto: en lugar de trabajar con ssh, muévase a https. para hacer esto: en su carpeta de proyecto tiene una carpeta .git allí, tiene un archivo de configuración, ábralo en un editor de texto y cambie la línea

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

a

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

Si estás en Linux o Macox, prueba esto en la terminal:

ssh-add -l

si no devuelve nada, intente esto:

ssh-add

debe crear identidad en ~ / .ssh / id_rsa

después de reintentar:

ssh-add -l

debe devolver su identidad, por lo que después de volver a intentar clonar, debe funcionar

NB: no olvide agregar su clave ssh en su perfil gitlab

Gracias

En mi caso, no fue un problema de gitlab, sino uno de configuración sshd. El servidor ssh no permitió la conexión, excepto por una lista de usuarios. El usuario git, el que se conecta remotamente a gitlab, no estaba en esa lista. Por lo tanto, verifique esto antes que nada.

Puede verificar la configuración de su servidor ssh en /etc/ssh/sshd_config. Si tiene una línea con la opción AllowUsers, agregue git:

AllowUsers user1 user2 user3 git

Tengo gitlab ejecutándose con docker, esto es lo que hice para solucionar mi problema.

Descubrí que dentro de docker / var / log / gitlab / sshd / current había múltiples ocurrencias de un mensaje:

Autenticación rechazada: mal propietario o modos para el archivo /var/opt/gitlab/.ssh/authorized_keys

Después de lo cual cambié la propiedad de ese archivo de 99: usuarios a git: usuarios con:

chown git: usuarios Authorized_keys

Pasos a realizar, obtuve el mismo error pero lo solucioné. Gitlab quiere ssh-rsa, así que a continuación se muestra el código para ejecutar ssh para rsa

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

name@gmail.com es el correo electrónico de su cuenta de gitlab

2. Te pedirá que ingreses, así que solo presiona Enter después de que aparezca el siguiente código,

   Ingrese el archivo en el que guardará la clave (/home/yourDesktopName/.ssh/id_rsa):

3. Te pedirá nuevamente que ingreses, así que solo presiona Enter después de que aparezca el siguiente código,

   Ingrese la frase de contraseña (vacía para ninguna frase de contraseña):

4. Se le solicitará nuevamente la última vez que ingrese, así que solo presione Enter después de que se solicite el código siguiente,

   Ingrese la misma frase de contraseña nuevamente:

5. Mostrará su ssh-rsa generar.

6. Inicie sesión en su cuenta de Gitlab y vaya a la barra de navegación derecha que obtendrá y en la barra lateral izquierda obtendrá la clave ssh. Entra en él.

7. Mire por encima del mensaje que le pide que ingrese, obtendrá la ruta de ssh-rsa.

8. Vaya a su carpeta SSH y obtenga el id_rsa.pub

9. Ábralo y obtenga la clave y copie y pegue en Gitlab y ya casi está listo.

10. Corregido por: ssh -T git@gitlab.com

11. Conseguirás: Welcome to GitLab, @joy4!

12. Hecho.

Anteriormente fue muy difícil para mí, pero cuando lo intenté, fue muy fácil agregar la clave ssh en Mac y Linux. Hay algunos pasos y comandos para hacer esto de la siguiente manera:

1. Abra una terminal de su sistema y muévase dentro del directorio de su proyecto con el comando:

cd 'project directory name'

2. Ejecutar comando ssh-keygen en ese terminal e introdúzcalo hasta que aparezca la imagen randomart de la clave.

3. Luego ingrese un comando más en esa terminal:

cat ~/.ssh/id_rsa.pub

Generará su clave ssh. La clave comenzará con ssh-rsay terminará con .local.

4. Copie la clave y vaya a su sección de perfil de Gitlab, luego a la ssh keysección y péguela allí. Haga clic en el Addbotón, esto funcionará.

Tuve el mismo problema, lo resolví agregando una nueva clave ssh:

1. ssh-keygen -t ed25519 -C "email@example.com"
2. Copie su clave SSH pública en el portapapeles (xclip -sel clip < ~/.ssh/id_ed25519.pub en mi caso en Linux)
3. En gitlab, vaya a settings=>sshclaves y pase la nueva clave

Cuando tienes varias cuentas git y quieres una clave ssh diferente

Debe seguir el mismo paso para generar la clave ssh, pero asegúrese de

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

Ingrese la ruta que desea guardar (Ej: my-pc / Desktop / .ssh / ed25519)

Agregue la clave pública a su gitlab ( Cómo agregar clave ssh a gitlab )

Tienes que crear una nueva identidad ssh usando el siguiente comando

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

Dos cosas principalmente

1. Debe tener las claves id_rsa.pub e id_rsa (privadas) en su carpeta .ssh (que debe estar en su carpeta de inicio. Créelo si no está allí, coloque sus claves). No funcionaría si hubiera nombrado sus archivos clave de manera diferente

2. Cambie el permiso de id_rsa como chmod 400 ~ / .ssh / id_rsa

Otro problema que puede causar este comportamiento es cuando tiene una configuración con 2 posibles ubicaciones% HOME%.

Estoy usando una PC donde algunos de mis documentos se almacenan localmente, y algunos de ellos se almacenan en una unidad de red. Algunas aplicaciones piensan que C:\Users\<MyUserName>\es mi %home%, otras piensan queU:\ es el hogar.

Resulta ssh-keygenponer mi clave privada debajo C:\users\<MyUserName>\, y eso ssh -Tyssh -v también mirar allí.

Entonces, todo parece funcionar bien, excepto eso git clone, git pushy otros buscan una clave enU:\ . Lo que falla, por lo que me sale el error antes mencionado.

Me tomó una hora para averiguar, pero al final la solución fue simple: he copiado todo, desde C:\Users\<MyUserName>\.sshaU:\.ssh

Resolví así ...

Generó una clave para Windows usando este comando:

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

pero el problema fue que después de ejecutar este comando, apareció una línea: "Ingrese el archivo en el que guardará la clave (/c/Users/xxx/.ssh/id_rsa):" Aquí, estaba dando solo el nombre del archivo debido a que mi clave se guardaba en mi pwd y no en la ubicación dada. Cuando hice "git clone", suponía que la clave estaba en la ubicación "/c/Users/xxx/.ssh/id_rsa" pero no se encontró, por lo tanto, arrojó un error.

En el momento de la generación de la clave, se generaban 2 archivos, por ejemplo, "archivo1" y "archivo1.pub". Cambié el nombre de estos dos archivos como

file1 -> id_rsa 

y

file1.pub -> id_rsa.pub

y coloca ambos en la ubicación "/c/Users/xxx/.ssh/"

Vaya a la terminal y vuelva a generar la clave ssh. Tipo ssh-keygen . Le preguntará dónde desea guardarlo, escriba la ruta.

Luego copie la clave pública a la plataforma gitlabs. Suele comenzar con ssh-rsa.

El problema para mí fue que cambié UsePAMde yesque noen el fichero de configuración SSH bajo /etc/ssh/sshd_config. Con UsePAM yestodo funciona perfectamente.

Encontré la solución en la ayuda de 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

¡Espero que pueda ayudar a algunos de ustedes!

¿Cómo agregar la clave SSH a la cuenta de gitlab en ubuntu?

1. Abra la terminal en el directorio de su proyecto.
2. Escriba 'ssh-keygen -o -t rsa -b 4096 -C "su correo electrónico de gitlab"' y presione enter
3. Escriba 'vim /home/mnbtech/.ssh/id_rsa.pub' y presione enter (o abra manualmente su 'id_rsa.pub' desde donde lo guardó)

4. Aparecerá la clave SSH. Copia esos y

5. Ve a tu cuenta de gitlab.

6. Haga clic en la imagen de perfil y haga clic en configuración
7. En el lado izquierdo, seleccione SSH-Keys
8. Luego pegue esas claves Haga clic en Agregar clave

¡Se agregará SSH-Key!

(Nota: si tiene la clave SSH Generate Previews y se le denegó el permiso (clave pública). Elimine su clave ssh de Previews y Genere una nueva y agregue git user.name y correo electrónico en su terminal)

Resolví el git@gitlab.com: Permission denied (publickey)problema usando las siguientes instrucciones

1. CORRER cat ~/.ssh/id_rsa.pub
2. Copie id_rsa.pub(clave pública) en su configuración de getlab `-> SSH Keys
3. CORRER cat ~/.ssh/id_rsa
4. Copiar id_rsa(clave privada) a `Code_repo-> git_auth-> id_rsa

NOTA: Cuide al usuario de la máquina si está utilizando el rootusuario en su DockerFile o en cualquier otro lugar y luego use sudo suantes de ejecutar los comandos anteriores para obtener las claves públicas y privadas del usuario root.

En nuestro caso, no fue un problema del lado del usuario / cliente, sino del lado del servidor de Gitlab.

Estamos ejecutando una instancia local de Gitlab CE 12.9 en CentOS 7.1.

Descubrimos que en el servidor, el archivo .ssh / Authorized_keys no se actualizaba correctamente. Los usuarios crean sus claves SSH (siguiendo la guía de Gitlab) y las agregan al servidor de Gitlab, pero el servidor no actualiza las claves autorizadas , por lo que siempre dará lugar a errores de permiso denegado.

Una solución alternativa era reconstruir el archivo autorizado_claves ejecutando:

$ sudo gitlab-rake gitlab:shell:setup

Eso funcionaría para cualquiera que agregara sus claves antes de ejecutar la tarea de rastrillo. Para los siguientes usuarios que agregarían sus claves, alguien debe ejecutar manualmente las tareas de rastrillo nuevamente.

Una solución más permanente era no usar el archivo autorizado_claves y usar en su lugar una búsqueda indexada en la base de datos de Gitlab :

GitLab Shell proporciona una manera de autorizar a los usuarios de SSH a través de una búsqueda rápida e indexada de la base de datos de GitLab. GitLab Shell utiliza la huella digital de la clave SSH para verificar si el usuario está autorizado para acceder a GitLab.

Agregue lo siguiente a su sshd_configarchivo. Esto generalmente se encuentra en /etc/ssh/sshd_config, pero lo será /assets/sshd_configsi está utilizando 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 

Recargar OpenSSH:

# Debian or Ubuntu installations   
sudo service ssh reload

# CentOS installations   
sudo service sshd reload 

Confirme que SSH está funcionando eliminando la clave SSH de su usuario en la interfaz de usuario, agregando una nueva e intentando obtener un repositorio.

De manera predeterminada (bueno, el valor predeterminado en nuestra instalación), el archivo Escribir en autor_claves se verificó en el Área de administración> Configuración de optimización del rendimiento . Así que desmarcamos eso y usamos la base de datos de Gitlab en su lugar.

Después de configurar la búsqueda indexada y desmarcar el archivo Escribir en autor_claves , el acceso SSH se volvió correcto.

Para cualquiera que use Windows 10 y nada más que trabaje para él / ella:

En mi caso, tuve que clonar el repositorio con https en lugar de ssh y apareció una ventana emergente pidiendo mis credenciales. Después de eso todo funciona bien.

Lo sé, estoy respondiendo esto muy tarde e incluso StackOverflow confirmó si realmente quiero responder. Estoy respondiendo porque en realidad nadie describió el problema real, por lo que quería compartirlo.

Los basicos

Primero, comprenda que cuál es el control remoto aquí. El control remoto es GitLab y su sistema es el local, por lo tanto, cuando hablamos del control remoto origin, cualquier URL establecida en su git remote -vsalida es su URL remota.

Los protocolos

Básicamente, Git clone / push / pull funciona principalmente en dos protocolos diferentes (también hay otros):

1. Protocolo HTTP
2. Protocolo SSH

Cuando clona un repositorio (o cambia la URL remota) y usa la URL HTTP como https://gitlab.com/wizpanda/backend-app.git, entonces usa el primer protocolo, es decir, el protocolo HTTP.

Mientras que si clonas el repositorio (o cambias la URL remota) y usas la URL como git@gitlab.com:wizpanda/backend-app.git entonces, usa el protocolo SSH.

Protocolo HTTP

En este protocolo, cada operación remota, es decir, clonar, empujar y tirar, utiliza la autenticación simple, es decir, el nombre de usuario y la contraseña de su control remoto (GitLab en este caso), lo que significa que para cada operación, debe escribir su nombre de usuario y contraseña, lo que puede ser engorroso. .

Entonces, cuando empuja / jala / clona, ​​GitLab / GitHub lo autentica con su nombre de usuario y contraseña y le permite realizar la operación.

Si desea probar esto, puede cambiar a la URL HTTP ejecutando el comando git remote set-url origin <http-git-url>.

Para evitar ese caso, puede usar el protocolo SSH.

Protocolo SSH

Una conexión SSH simple funciona en pares de claves público-privadas. Entonces, en su caso, GitLab no puede autenticarlo porque está utilizando una URL SSH para comunicarse. Ahora, GitLab debe conocerte de alguna manera. Para eso, debe crear un par de claves pública-privada y darle la clave pública a GitLab.

Ahora, cuando empuja / jala / clona con GitLab, GIT (SSH internamente) ofrecerá por defecto su clave privada a GitLab y confirmará su identidad y luego GitLab le permitirá realizar la operación.

Así que no repetiré los pasos que ya dio Muhammad, los repetiré teóricamente.

1. Genere un par de claves `ssh-keygen -t rsa -b 2048 -C" Mi clave SSH común "
2. El par de claves generado estará por defecto en ~/.sshnombre id_rsa.pub(clave pública) &id_rsa (clave privada).
3. Almacenará la clave pública en su cuenta de GitLab (la misma clave se puede usar en múltiples servidores o cuentas).
4. Cuando clonas / empujas / jalas, GIT ofrece tu clave privada.
5. GitLab combina la clave privada con su clave pública y le permite realizar.

Consejos

Siempre debe crear una clave rsa segura con al menos 2048 bytes. Entonces el comando puede ser ssh-keygen -t rsa -b 2048.

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

Pensamiento general

Tanto el enfoque tiene sus pros y sus contras. Después de escribir el texto anterior, fui a buscar más sobre esto porque nunca leí algo sobre esto.

Encontré este documento oficial https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols que dice más sobre esto. Mi punto aquí es que, al leer el error y reflexionar sobre el error, puede hacer su propia teoría o comprensión y luego puede coincidir con algunos resultados de Google para solucionar el problema :)

Agregué mi ~/.ssh/id_rsa.puba la lista de claves SSH conocidas en mi configuración de GitLab https://gitlab.com/profile/keys . Eso resolvió el problema para mí. :-)

Uso ubuntu 18.04, y en realidad fue un problema de permiso en mi máquina local. El problema desapareció cuando configuré el permiso de lectura / escritura en mi carpeta .git.

Bueno, tuve este mismo problema y después de intentar la respuesta @Khan propuso. Sin embargo, solo pude hacerlo funcionar simplemente cambiando la url de origen en el archivo .git / config a la dirección https: https://gitlab.com/mygitlabusername/mygitproject.git

Como el acceso a través de ssh está denegado, descubrí que usar https no debería ser un problema. Sin embargo, le pedirá su nombre de usuario y contraseña para cada envío al repositorio at

Úselo git config credential.helper storesi su sitio usa TLS / SSL. Espero que esto funcione

Parece haber diferencias entre las dos formas de acceder a un repositorio git, es decir, usando SSH o HTTPS. Para mí, encontré el error porque estaba tratando de impulsar mi repositorio local usando SSH.

El problema simplemente se puede resolver haciendo clic en el botón de clonar en la página de inicio de su proyecto y copiando el enlace HTTPS y reemplazándolo por el enlace SSH que aparece con el formato "git @ gitlab ...".

Cambiar permiso :: chmod 400 ~ / .ssh / id_rsa Me ayudó.