Comment lire une adresse IP à l'envers?

Si nous avons cette chaîne ( adresse IP ):192.168.1.1

Comment puis-je dériver le ( formulaire d'enregistrement inversé DNS ) de cette chaîne, il sera donc affiché comme en 1.1.168.192.in-addr.arpautilisant un script shell?

Vous pouvez le faire avec AWK . Il y a de meilleures façons de le faire, mais c'est la plus simple, je pense.

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

Cela inversera l'ordre de l'adresse IP.

Juste pour économiser quelques touches, comme l'a suggéré Mikel, nous pouvons raccourcir encore la déclaration supérieure:

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

OU

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

OU

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

AWK est assez flexible. :)

Juste pour la valeur de la curiosité ... en utilisant tacde GNU coreutils: étant donné une variable ipdans le formulaire 192.168.1.1puis

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

c'est à dire

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

Si vous souhaitez utiliser uniquement shell ( zsh, ksh93, bash), voici une autre façon:

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

Ou en plaine ancienne:

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

Facilement avec Perl, donc:

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

Pour compléter, Ruby:

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

Qui prend également en charge 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

Grâce à 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

Il inverse tout format d'adresse IPv4.

Exemple:

$ 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

En utilisant la bibliothèque standard de Python :

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

Avec zsh:

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

Ce sont des indicateurs d'extension variables:

• s:.:: s plit sur.
• Oa: Inverse o rder l' un rray
• j:.:: j oin on.

Une autre possibilité consiste à utiliser l'outil de ligne de commande "dig" avec le commutateur "-x".

Il fait en fait une demande sur l'entrée PTR, mais si vous filtrez sur "PTR" il vous montrera une ligne commentée (la demande) et peut-être quelques réponses.

L'utilisation de "dig" peut être pratique pour une écriture rapide du nom PTR, sans avoir à écrire un petit script. Surtout si vous en avez besoin de manière interactive (pour couper et coller le résultat). Il fonctionne également sur IPv6.

Si vous souhaitez qu'il fonctionne également avec IPv6 , vous pouvez l'utiliser dig -x.

Par exemple:

$ 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.

En 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

De cette façon, vous pouvez saisir une adresse et appuyer sur Retour pour votre résultat.

Avec la hostcommande de dnsutils:

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

En supposant un var contient l'adresse IP: ip=192.168.2.1. Si la valeur doit être donnée à une nouvelle variable, insérez simplement une solution à l'intérieur $()et affectez-la à la var rr=$(...).

Quelques solutions sont possibles:

: printf 'arpa.in-addr.%s.' "$ip" | tac -s.
La plupart des obus Les plus simples : IFS=. eval 'set -- $ip'; echo "$4.$3.$2.$1.in-addr.arpa"
Certains obus : 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)}'
host: host -t ptr 192.168.2.1 | cut -d' ' -f2

Les solutions Dig et Host fonctionnent avec 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

Une alternative plus courte à la réponse de mattbianco avec moins d'outils, mais l'utilisation de pcregrep pourrait être:

$ 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.

Utilisez le shell d'une ligne suivant:

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