Como posso obter o comentário da chave ssh do authorized_keys atual?

Question

Edit: O que eu realmente preciso saber QUE chave ssh de authorized_keys foi usada para identificar o usuário atualmente conectado.

De acordo com "man sshd":

Protocol 2 public key consist of options, keytype, base64-encoded key, comment.

Eu vejo que quando eu uso o ssh-keygen, o comentário geralmente é a identidade local do usuário. Existe alguma maneira de acessar esse valor quando estou no computador remoto? (Tipo como a variável de shell SSH_CLIENT)

(Supondo que eu imponha o comentário para ser uma identidade remota de algum tipo, eu gostaria de registrar isso de um script de shell! Isso é no Ubuntu)

    

Answer 1

Eu pessoalmente não recomendaria essa solução, mas estou postando isso para fins de discussão.

Se você estiver disposto a:

1. Alterar o nível de log do SSHd
2. Conceda acesso ao seu script para / var / log / secure (ou arquivo de log equivalente)

Você pode definir "LogLevel DEBUG" em sshd_config para obter as seguintes entradas sempre que uma chave ssh for usada com êxito para autenticação:

Aug 13 11:51:13 myhost sshd[20195]: debug1: matching key found: file /home/myuser/.ssh/authorized_keys, line 3
Aug 13 11:51:13 myhost sshd[20195]: Found matching DSA key: 00:aa:bb:cc:dd:ee:00:c0:0b:fa:ce:00:00:ab:cd:ef

Escrever um script para analisar os logs e recuperar as informações relevantes seria trivial. Você provavelmente poderia grep por "sshd [$ PPID]" para reduzir as linhas que o script tem que mutar.

Observe que alterar o nível de log para DEBUG aumentará o tamanho de seus logs e poderá violar a privacidade dos usuários. De "man sshd_config":

Logging with a DEBUG level violates the privacy of users and is not recommended.

Tenho certeza de que existem várias etapas que podem ser tomadas para tornar essa solução um pouco menos medonha (por exemplo, registrando informações de DEBUG do sshd em um arquivo diferente e controlando o acesso a esse arquivo e ao script), mas no final ainda vai fazer você se encolher.

    

Answer 2

Isso ajudará se você quiser rastrear o login de um script na máquina SSHd .

Etapa 1 : a variável do shell ' SSH_CLIENT ' fornece duas partes da informação

• O endereço IP remoto ( 192.168.1.2 na linha abaixo)
• A porta TCP remota pela qual o cliente se conectou ( 56120 abaixo)

    SSH_CLIENT='192.168.1.2 56120 22'  
                ----------- -----  
                 Source IP   Port

Step 2 : Agora você pode fazer um login (de trás para frente) no IP de origem (192.168.1.2) e verificar o UserID .

SSHd-Server$ ssh [email protected] exec "netstat -et  | grep 56120"  
 tcp  0  0 hostname:56120 localhost:ssh ESTABLISHED user1  9937126
                    -----                           ----- 

Você identificou [email protected] .

    

Answer 3

É por conveniência, da página ssh-keygen man no Debian:

For RSA1 keys, there is also a comment field in the key file that is only for convenience to the user to help identify the key. The comment can tell what the key is for, or whatever is useful. The comment is initialized to “user@host” when the key is created, but can be changed using the -c option.

Acho que o mais próximo que você conseguir para determinar qual chave foi usada para efetuar login é com ssh-add , com -L, da página man:

-L Lists public key parameters of all identities currently represented by the agent.

Você pode aumentar o nível de log do daemon ssh para DEBUG1:

LogLevel DEBUG1

E o log mostrará a impressão digital RSA da chave SSH usada para efetuar login:

Aug 13 08:52:56 ubuntu_test sshd[17115]: debug1: matching key found: file /home/username/.ssh/authorized_keys, line 1
Aug 13 08:52:56 ubuntu_test sshd[17115]: Found matching RSA key: xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx

Você pode obter a impressão digital de uma chave com ssh-keygen :

-l Show fingerprint of specified public key file. Private RSA1 keys are also supported. For RSA and DSA keys ssh-keygen tries to find the matching public key file and prints its fingerprint. If combined with -v, an ASCII art representation of the key is supplied with the fingerprint.

Em um arquivo de chaves autorizado, você teria que dividir cada linha em um novo arquivo para ler com ssh-keygen -l . Aqui está um exemplo de script Ruby que fará isso:

#!/usr/bin/env ruby
File.open("/home/username/.ssh/authorized_keys").each do |l|
  file_name = l.split(" ")[2]
  key_file = File.new("#{file_name}.pub_key", "w")
  key_file.puts l
  key_file.close
  puts %x{ssh-keygen -l -f #{file_name}.pub_key}
end

    

Answer 4

Se você tiver a chave pública (do usuário suspeito), poderá pesquisar a assinatura em auth.log . Combine isso com a saída de (observe que -l é aqui pequeno -L ):

ssh-keygen -l <enter>

Este comando solicitará o caminho para a chave pública e emitirá a assinatura para essa chave.

    

Answer 5

Desde que eu não consegui encontrar uma resposta completa na net para isso eu escrevi meu próprio bash scritp:

#!/bin/bash

cat /root/.ssh/authorized_keys | while read KEY; do
        echo "";
        name=$(echo "$KEY" | cut -d ' ' -f3-);
        file_name=$(echo "$name" | tr ' ' '_');
        echo $KEY > $file_name;
        fingerprint=$(ssh-keygen -l -f $file_name);
        rm -f $file_name;
        echo "$name login's";
        logins=$(grep 'echo "$fingerprint" | awk '{print $2}'' /var/log/secure*);
        logins_count=$(echo "$logins" | wc -l);
        echo "Total Login's: $logins_count";
        if [ -n "$logins" ]; then
                login_pids=$(echo "$logins" | perl -p -e 's/.*\[(.*)\].*/$1/g');
                for f in 'ps -e | grep 'sshd' | awk '{print $1}' | grep "$login_pids"'; do
                        [ -n "$f" ] && echo "Current sessions pid: $f";
                done;
        fi;
done;

#

Edit: Eu escrevi isso muitos anos depois espero que possa ser útil para alguém https://github.com/sayajin101/SSH-Key-Login-Extended