Dato le chiavi in ​​formato ~ / .ssh / authorized_keys, puoi determinare facilmente la forza delle chiavi?

~ / .ssh / authorized_keys [2] contiene l'elenco di chiavi pubbliche.

Sfortunatamente, ogni chiave pubblica non specifica la forza della chiave (numero di bit).

Esiste un'utilità in grado di elaborare questo file riga per riga e generare la forza chiave?

Ho controllato le pagine man ssh-keygen, ma sembra che funzionerebbe solo con le chiavi private.

Inoltre, esiste uno strumento che produce l'hash sha1 nello stesso modo in cui viene visualizzato nello pageantstrumento Putty?

Il formato che sto cercando:

Key Algorithm  Strength  Hash                                             Comment
ssh-rsa        2048      00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff  user1@host1
ssh-rsa        2048      11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff:11  user2@host2

ssh-keygen può fare il nucleo del lavoro (generare un'impronta digitale da una chiave pubblica), ma non elaborerà automaticamente un elenco di più chiavi come si trova normalmente in un authorized_keysfile.

Ecco uno script che divide le chiavi, le fornisce a ssh-keygen e produce la tabella desiderata:

#!/bin/sh

# usage: authkeys-report <authorized_keys-file>    

set -ue

tmp="$(mktemp -t fingerprint-authkeys.XXXXXXXX)"
trap 'rm -f "$tmp"' 0

while read opts key; do
    case "$opts" in
        [0-9]*|ssh-dss|ssh-rsa)
            # not options, first "word" is part of key
            key="$opts $key"
        ;;
    esac
    echo "$key" >$tmp
    set -- $(ssh-keygen -lf "$tmp")
    bits="$1" fingerprint="$2"

    set -- $key # Note: will mangle whitespace in the comment
    case "$1" in
        [0-9]*) # SSH v1 key
            type=rsa1
            shift 3
        ;;
        ssh-rsa|ssh-dss) # SSH v2 key
            type="$1"
            shift 2
        ;;
        *)
            type=unknown
            set --
        ;;
    esac

    printf '%-14s %-9s %s %s\n' "$type" "$bits" "$fingerprint" "$*"
done <$1

ssh-keygenin openssh-7.2 (attualmente almeno in Fedora e Ubuntu Xenial) supporta la lettura di più chiavi da un singolo file. Quindi correre semplicemente

# ssh-keygen -l -f ~/.ssh/authorized_keys
2048 SHA256:xh0IVbI... jakuje@jakuje (RSA)
2048 SHA256:xh0IVbI... jakuje@jakuje (RSA)

produce l'output desiderato.

Se hai zsh, puoi farlo come una riga:

while read line ; do ssh-keygen -lf =(echo $line); done < .ssh/authorized_keys

estrapolando dalla soluzione zsh una soluzione bash

while read line ; do ssh-keygen -l -f <(echo $line); done < .ssh/authorized_keys 

/ dev / fd / 63 non è un file di chiave pubblica.
/ dev / fd / 63 non è un file di chiave pubblica.

quasi ... Questo dovrebbe funzionare, ma ssh-keygen sembra non amare leggere direttamente dal file generato. Utilizzando un file temporaneo per <(reindirizzamento, funziona quindi. Perché?

while read line
do
  cat > /tmp/key <(echo $line)
  ssh-keygen -l -f /tmp/key
done < .ssh/authorized_keys 

1024 1f: c7: da: ef: ff: ff: ff: ff: c8: 77: c6: f8: 1f: dd: f3: 1a / tmp / key (RSA)
3072 83: cd: af: b4: ff: ff: ff: ff: 02: 30: e7: 1e: 47: ed: c5: 69 / tmp / key (RSA)

ovviamente puoi scrivere più facilmente ed essere felice

while read line
do
  echo $line > /tmp/key
  ssh-keygen -l -f /tmp/key
done < .ssh/authorized_keys 
rm /tmp/key

Script per elencare tutte le impronte digitali dal authorized_keysfile, creato da saravana:

#!/usr/bin/ksh

USER=`whoami`
USER_H=` lsuser -a home $USER |awk -F '=' '{print $2}'`

cat $USER_H/.ssh/authorized_keys| while read line
do
  echo $line > /tmp/finger_print
  echo "************* Key,finger print details below ***************************"

  cat /tmp/finger_print
  echo

  ssh-keygen -l -f /tmp/finger_print|grep -v not|awk '{print $1" " $2 " " $4}'
  if ssh-keygen -l -f /tmp/finger_print|grep "is not a" > /dev/null 2>&1
  then
    echo "The above key is an Invalid Key,Please correct it"
  fi

  echo "========================================================================"

  rm /tmp/finger_print
done