Come leggere un indirizzo IP al contrario?

Se abbiamo questa stringa ( indirizzo IP ):192.168.1.1

Come posso derivare il ( modulo di registrazione inversa DNS ) da questa stringa, così verrà mostrato come 1.1.168.192.in-addr.arpausando uno script di shell?

Puoi farlo con AWK . Ci sono modi migliori per farlo, ma questo è il più semplice, credo.

echo '192.168.1.1' | awk 'BEGIN{FS="."}{print $4"."$3"."$2"."$1".in-addr.arpa"}'

Ciò invertirà l'ordine dell'indirizzo IP.

Solo per salvare alcune sequenze di tasti, come suggerito Mikel, possiamo ridurre ulteriormente l'affermazione superiore:

echo '192.168.1.1' | awk -F . '{print $4"."$3"."$2"."$1".in-addr.arpa"}'

O

echo '192.168.1.1' | awk -F. '{print $4"."$3"."$2"."$1".in-addr.arpa"}'

O

echo '192.168.1.1' | awk -F. -vOFS=. '{print $4,$3,$2,$1,"in-addr.arpa"}'

AWK è piuttosto flessibile. :)

Solo per valore di curiosità ... usando tacda GNU coreutils: data una variabile ipnel modulo 192.168.1.1allora

$(printf %s "$ip." | tac -s.)in-addr.arpa

vale a dire

$ ip=192.168.1.1
$ rr=$(printf %s "$ip." | tac -s.)in-addr.arpa
$ echo "$rr"
1.1.168.192.in-addr.arpa

Se si desidera utilizzare solo shell ( zsh, ksh93, bash), ecco un altro modo:

IFS=. read w x y z <<<'192.168.1.1'
printf '%d.%d.%d.%d.in-addr.arpa.' "$z" "$y" "$x" "$w"

O in semplice vecchia conchiglia:

echo '192.168.1.1' | { IFS=. read w x y z; echo "$z.$y.$w.$x.in-addr.arpa."; }

Facilmente con Perl, quindi:

$ echo 192.168.1.1|perl -nle 'print join ".",reverse(split /\./,$_)'
1.1.168.192

Per finire, Ruby:

ruby -r ipaddr -e 'puts IPAddr.new(ARGV.first).reverse' 192.168.1.1

Che supporta anche IPv6

2607:F8B0:4000:080A:0000:0000:0000:2000
=> 0.0.0.2.0.0.0.0.0.0.0.0.0.0.0.0.a.0.8.0.0.0.0.4.0.b.8.f.7.0.6.2.ip6.arpa

Tramite GNU sed,

sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g' file

Inverte qualsiasi formato di indirizzo IPv4.

Esempio:

$ echo '192.168.1.1' | sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g'
1.1.168.192.in-addr.arpa

$ echo '192.1.1.1' | sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g'
1.1.1.192.in-addr.arpa

$ echo '1.1.1.1' | sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g'
1.1.1.1.in-addr.arpa

$ sed -r 's/^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$/\4.\3.\2.\1.in-addr.arpa/g' <<< '192.168.189.23'
23.189.168.192.in-addr.arpa

Utilizzando la libreria standard di Python :

>>> ipaddress.ip_address('192.168.1.1').reverse_pointer
'1.1.168.192.in-addr.arpa'

Con zsh:

$ ip=192.168.1.1
$ echo ${(j:.:)${(s:.:Oa)ip}}.in-addr.arpa
1.1.168.192.in-addr.arpa

Quelli sono flag di espansione variabili:

• s:.:: s plit on.
• Oa: Inversa o rder l' una RRay
• j:.:: J oin su.

Un'altra possibilità è utilizzare lo strumento da riga di comando "dig" con l'opzione "-x".

Effettua effettivamente una richiesta sulla voce PTR, ma se si filtra su "PTR" mostrerà una riga commentata (la richiesta) e forse alcune risposte.

L'uso di "dig" può essere utile per una rapida scrittura del nome PTR, senza dover scrivere un piccolo script. Soprattutto se ne hai bisogno in modo interattivo (per tagliare e incollare il risultato). Funziona anche su IPv6.

Se vuoi che funzioni anche con IPv6 , puoi usarlo dig -x.

Per esempio:

$ dig -x 194.68.208.240 | egrep '^;.*PTR$' | cut -c 2- | awk '{print $1}'
240.208.68.194.in-addr.arpa.

$ dig -x 2001:db8:dc61:2a61::1 | egrep '^;.*PTR$' | cut -c 2- | awk '{print $1}'
1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.6.a.2.1.6.c.d.8.b.d.0.1.0.0.2.ip6.arpa.

In Python

 a = "192.168.1.122"
 import re
 m = re.search(r'(\d+)\.(\d+)\.(\d+)\.(\d+)',a)
 ip = m.group(4),m.group(3),m.group(2),m.group(1)
 '.'.join(ip) + ".in-addr.arpa"
 '122.1.168.192.in-addr.arpa'

IFS=. ; set -- ${0+192.168.1.2}
printf %b. $4 $3 $2 $1 in-addr.arpa\\c

IFS=. ; printf %s\\n \
    in-addr.arpa ${0+192.168.1.2} |    
sed '1!G;$s/\n/./gp;h;d'

IFS=. ; printf '[%b.] ' \
    ${0+192.168.1.2.]PPPPP\\c} |dc
echo in-addr.arpa

$ while read ip
while> do
while> n=( $(echo $ip) ) && echo "${n[4]}"'.'"${n[3]}"'.'"${n[2]}"'.'"${n[1]}"'.'"in-addr.arpa"
while> done
192.168.1.2
2.1.168.192.in-addr.arpa

In questo modo puoi digitare un indirizzo e premere Invio per il tuo risultato.

Con hostcomando da dnsutils:

$ host -t ptr 192.168.1.1 | cut -d' ' -f 2
1.1.168.192.in-addr.arpa.

Assumendo una var contiene il ip: ip=192.168.2.1. Se il valore deve essere assegnato a una nuova variabile, racchiudere qualsiasi soluzione all'interno $()e assegnarla alla var rr=$(...).

Alcune soluzioni sono possibili:

Semplici : printf 'arpa.in-addr.%s.' "$ip" | tac -s.
maggior parte delle conchiglie : IFS=. eval 'set -- $ip'; echo "$4.$3.$2.$1.in-addr.arpa"
Alcune shell : IFS=. read d c b a <<<"$ip"; printf %s "$a.$b.$c.$d.in-addr.arpa."
awk : echo "$ip" | awk -F. '{OFS=FS;print $4,$3,$2,$1,"in-addr.arpa"}'
sed : echo "$ip" | sed -E 's/([^.]+)\.([^.]+)\.([^.]+)\.([^.]+)$/\4.\3.\2.\1.in-addr.arpa./'
sed : echo "arpa.in-addr.$ip" | sed 'y/./\n/' | sed 'G;$s/\n/./gp;h;d'
perl : echo "$ip" | perl -F\\. -lane '$,=".";print( join(".",(reverse @F),"in-addr.arpa"))'
dig : dig -x "$ip" | awk -F '[; \t]+' '/^;.*PTR$/{print($2)}'
ospite: host -t ptr 192.168.2.1 | cut -d' ' -f2

Entrambe le soluzioni di scavo e host funzionano con IPv6.

#!/bin/bash
# script file name reverseip.sh
if [ -z $1 ] || [ "help" == $1 ]
then
echo 'Convert a full ipv4 or ipv6 address to arpa notation'
echo "usage:"
echo ./reverseip.sh "help"
echo ./reverseip.sh "ipv4 address format: xxxx.xxxx.xxxx.xxxx"
echo ./reverseip.sh "ipv6 address format: xxxx:xxxx:xxxx:xxxx::xxxx"
echo "examples:"
echo ./reverseip.sh 216.58.207.35
echo ./reverseip.sh 2a00:1450:4001:824::2003
exit
fi

# if ip address passed containing ':'
if [[ $1 = *':'* ]];
then
# invert ipv6 address e.g.: 2a00:1450:4001:824::2003 to 3.0.0.2.0.0.0.0.0.0.0.0.0.0.0.0.4.2.8.0.1.0.0.4.0.5.4.1.0.0.a.2.
# @see lsowen https://gist.github.com/lsowen/4447d916fd19cbb7fce4
echo "$1" | awk -F: 'BEGIN {OFS=""; }{addCount = 9 - NF; for(i=1; i<=NF;i++){if(length($i) == 0){ for(j=1;j<=addCount;j++){$i = ($i "0000");} } else { $i = substr(("0000" $i), length($i)+5-4);}}; print}' | rev | sed -e "s/./&./g" | echo "$(</dev/stdin)ip6.arpa."
else
# invert ipv6 address e.g.: 216.58.207.35 to 35.207.58.216.in-addr.arpa
# @see Stéphane Chazelas /unix/132779/how-to-read-an-ip-address-backwards
echo $(printf %s "$1." | tac -s.)in-addr.arpa
fi

Un'alternativa più breve alla risposta di mattbianco con meno strumenti, ma l'utilizzo di pcregrep potrebbe essere:

$ dig -x 194.68.208.240 | pcregrep -o1 '^;(\S+)\s+IN\s+PTR$'
240.208.68.194.in-addr.arpa.

$ dig -x 2001:db8:dc61:2a61::1 | pcregrep -o1 '^;(\S+)\s+IN\s+PTR$'
1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.6.a.2.1.6.c.d.8.b.d.0.1.0.0.2.ip6.arpa.

Utilizzare la seguente shell di una riga:

echo '192.168.1.1' | tr '.' '\n' | tac | paste -s -d '.' -