ipinfo

#!/bin/bash -
# Print extra information about IPv4 address to standard output
# Version 3.0
# Written by Bernard Lim <lim.yiok.kia@gmail.com>

AUTHOR="Bernard Lim <lim.yiok.kia@gmail.com>"
PROG=$(basename $0)
VERSION="3.0"

HTTP="http://"
SOCKS="socks4://"

USER_AGENT="Mozilla/5.0"
DNS_OPTION=
PROXY_OPTION=
MAX_FIELDS=11

# public DNS servers
# non-responsive DNS servers are commented out
DNS_HOST="pcsupport.about.com"
DNS_PATH="/od/tipstricks/a/free-public-dns-servers.htm"
DNS_SOURCE="${HTTP}${DNS_HOST}${DNS_PATH}"
DNS_SERVERS=( \
209.244.0.3 \
209.244.0.4 \
8.8.8.8 \
8.8.4.4 \
84.200.69.80 \
84.200.70.40
8.26.56.26 \
8.20.247.20 \
208.67.222.222 \
208.67.220.220 \
156.154.70.1 \
156.154.71.1 \
199.85.126.10 \
199.85.127.10 \
#81.218.119.11 \
#209.88.198.133 \
195.46.39.39 \
195.46.39.40 \
107.150.40.234 \
50.116.23.211 \
208.76.50.50 \
#208.76.51.51 \
216.146.35.35 \
216.146.36.36 \
37.235.1.174 \
37.235.1.177 \
89.233.43.71 \
#91.239.100.100 \
74.82.42.42 \
109.69.8.51 )

# dependency message
depends() {
  echo "$PROG: depends on \`$*'" >&2
  echo "Install \`$*' and try again." >&2
  exit 1
}

# die a graceful death!
die() {
  echo "$PROG: $*" >&2
  echo "Try \`$PROG -h' for more information." >&2
  exit 1
}

# fanciful output
b="\033[1m"  # bold
u="\033[4m"  # underline
o="\033[0m"  # off

# shorter usage
short() {
  usage | sed '2q'
  echo "Try \`$PROG -h' for more information."
}

# usage message
usage() {
cat <<EOF
Usage: $PROG [OPTION]... [ADDRESS]...
Print extra information about ADDRESS to standard output.

$(echo -e ${b}Output${o})
ipaddr|ptr;...|pdns;...|cc|state|city|zip|lat|lon|asn|isp

    where "|" is the field separator.

$(echo -e ${b}Fields${o})
  1) ipaddr       IPv4 address in quad-dotted notation
  2) ptr          PTR record from reverse DNS lookup
  3) pdns         Passive DNS
  4) cc           Two-letter country code
  5) state        Two-letter state code
  6) city         City name
  7) zip          Postal or ZIP code
  8) lat          Latitude coordinate
  9) lon          Longitude coordinate
 10) asn          Autonomous System (AS) number
 11) isp          AS Operator or previously ISP

$(echo -e ${b}Options${o})
  -d              Use random public domain name server
                  to perform reverse DNS lookup
  -f LIST         Select only these fields. Like \`cut'
  -h              Display this help and exit
  -l(d|p)         List available public (d)omain name
                  servers or open (p)roxies
  -p              Use random open proxy to perform
                  passive DNS lookup and GeoIP lookup
  -v              Print version information and exit

Use one, and only one -f. Each LIST is made up of one range,
or many ranges separated by commas. Selected input is written
in the same order that it is read, and is written exactly once.
Each range is one of:

  N               N'th field, counted from 1
  N-              from N'th field, to end of line
  N-M             from N'th to M'th (included) field
  -M              from first to M'th (included) field

$(echo -e ${b}Examples${o})
  $PROG 8.8.8.8          # Use default settings and print all fields
  $PROG -l(d|p)          # List available domain name servers or open proxies
  $PROG -d 8.8.8.8       # Use random domain name server and print all fields
  $PROG -f2 8.8.8.8      # Print second field, PTR record
  $PROG -f-2,4- 8.8.8.8  # Print fields 1 to 2 and fields 4 to 11

Report $PROG bugs to $AUTHOR
This software is distributed in the hope that it will be
useful but without any warranty. It is provided “as is”.
EOF
}

# proxify - return random proxy from xroxy.com
# timeout in 5 seconds
# type = Anonymous, 1atency < 1ms, reliability > 90%
proxify() {
  PROXY_HOST="www.xroxy.com"
  PROXY_TYPE="Anonymous"
  PROXY_LIST="type=${PROXY_TYPE}&latency=1000&reliability=9000&desc=true&pnum="
  PROXY_PATH="/proxylist.php?"
  PROXY_SOURCE="${PROXY_HOST}${PROXY_PATH}${PROXY_LIST}"

  get_proxies() {
    for ((page=0; page<3; page++)); do
      (curl -m5 -s -A $USER_AGENT "${PROXY_SOURCE}$page" &)
    done |
    grep -Eo 'host=[0-9.]+&port=[0-9]+' |
    sed -e 's/\&port=/:/' -e 's/host=//'
  }

  if which curl &>/dev/null; then
    PROXY_SERVERS=($(get_proxies))
    if [ ${#PROXY_SERVERS[@]} -gt 0 ]; then
      PROXY_SERVER=${PROXY_SERVERS[$RANDOM % ${#PROXY_SERVERS[@]}]}
      echo "$PROXY_SERVER"
    else
      PROXY_SERVER=
      return 1
    fi
  else
    depends "curl"
  fi
}

# parse ranges separated by commas
# and print sorted/unique integers
# for up to 50, if limit is absent
parse() {
  local limit=$2
  local ranges=($(tr ',' ' ' <<<"$1"))
  local nr=$(awk -F"," '{ print NF }' <<<"$1")

  if [ ${#ranges[@]} -lt $nr ]; then
    die "fields are numbered from 1"
  fi

  for range in ${ranges[@]}; do
    expansion=$(expand $range ${limit:=50})
    if [ -z "$expansion" ]; then return 1; fi
    echo "$expansion"
  done |
  tr ' ' '\n' |
  sort -un |
  tr '\n' ' '
}

# expand ranges of the form N, N-, N-M, -N
# bash - largest positive integer is 9223372036854775807
expand() {
  local input=$1
  local max=$2

  if [ -z "$input" ]; then
    die "fields are numbered from 1"
  fi

  if grep -Eo '^-$' <<<"$input" &>/dev/null; then
    die "invalid range with no endpoint: $input"
  fi

  # N
  if grep -Eo '^[0-9]+$' <<<"$input" &>/dev/null; then
    let value="$input"
    let nd="$(echo -n $value | wc -c)"
    if [ $nd -ge 5 ]; then
      die "field number \`$input' is too large"
    fi

    if [ $value -eq 0 ]; then
      die "fields are numbered from 1"
    fi

    echo $value

  # N-
  elif grep -Eo '^[0-9]+-$' <<<"$input" &>/dev/null; then
    lo="${input%-}"
    let value="$lo"
    let nd="$(echo -n $value | wc -c)"
    if [ $nd -ge 5 ]; then
      die "field number \`$lo' is too large"
    fi

    if [ $value -eq 0 ]; then
      die "fields are numbered from 1"
    fi

    seq $lo $max

  # N-M
  elif grep -Eo '^[0-9]+-[0-9]+' <<<"$input" &>/dev/null; then
    lo="${input%-*}"
    let value="$lo"
    let nd="$(echo -n $value | wc -c)"
    if [ $nd -ge 5 ]; then
      die "field number \`$lo' is too large"
    fi

    if [ $value -eq 0 ]; then
      die "fields are numbered from 1"
    fi

    hi="${input#*-}"
    let value="$hi"
    let nd="$(echo -n $value | wc -c)"
    if [ $nd -ge 5 ]; then
      die "field number \`$hi' is too large"
    fi

    if [ $value -eq 0 ]; then
      die "fields are numbered from 1"
    fi

    if (( $lo > $hi )); then
      die "invalid decreasing range"
    fi

    if (( $hi > $max )); then
      hi=$max
    fi

    seq $lo $hi

  # -N
  elif grep -Eo '^-[0-9]+$' <<<"$input" &>/dev/null; then
    hi="${input#-}"
    let value="$hi"
    let nd="$(echo -n $value | wc -c)"
    if [ $nd -ge 5 ]; then
      die "field number \`$hi' is too large"
    fi

    if [ $value -eq 0 ]; then
      die "fields are numbered from 1"
    fi

    if (( $hi > $max )); then
      hi=$max
    fi

    seq $hi

  # No man's land
  else
    die "invalid field list"
  fi
}

# wrapper for host - DNS lookup tool
# timeout in 1 second
dnslookup() {
  if which host &>/dev/null; then
    local dnp="domain name pointer"
    local A=$(host -W1 -s $1 $DNS_OPTION | grep "$dnp" || echo "(NXDOMAIN)")
    local B=$(awk '{ print $NF }' <<<"$A")
    if [ $(tr -cd '.' <<<"$B" | wc -c) -ne 1 ]; then
      sed -r 's/\.?$//' <<<"$B" |
      tr '\n' ';' |
      sed 's/;$//'
    else
      echo "(NULL)"
    fi
  else
    depends "host"
  fi
}

# over-simplistic JSON parser
retrieve() {
  local json=$1
  local key=$2
  local value=$(grep -Eo "\"$key\":.*,?" <<<"$json" | \
    cut -d"," -f1 | \
    cut -d":" -f2 | \
    tr -d '"' | \
    sed -r 's/^\s?\{?//' | \
    sed -r 's/\s?\}?$//')
  [ -z "$value" ] && echo "N/A" || echo "$value"
}

# web scraper for GeoIP
# timeout in 2 seconds and retry
geoip() {
  local urls=( \
    freegeoip.net/json \
    www.telize.com/geoip \
    ip.pycox.com/json \
    ip-api.com/json \
  )

  if which curl &>/dev/null; then
    while true; do
      local url=${urls[$RANDOM % ${#urls[@]}]}
      local json=$(curl -m2 -s -A $USER_AGENT $PROXY_OPTION "$url/$1")
      if [ -n "$json" ]; then break; fi
    done

    local ccy=$(retrieve "$json" "(country_code|countryCode)")

    if grep 'telize' <<<"$url" &>/dev/null; then
      local stt=$(retrieve "$json" "region_code")
    else
      local stt=$(retrieve "$json" "region(_code)?")
    fi

    local cty=$(retrieve "$json" "city")
    local zip=$(retrieve "$json" "(postal|zip)(_code)?")
    local lat=$(retrieve "$json" "lat(itude)?")
    local lon=$(retrieve "$json" "lon(gitude)?")

    if [[ "$lat" != "N/A" ]]; then lat=$(printf "%.3f" "$lat"); fi
    if [[ "$lon" != "N/A" ]]; then lon=$(printf "%.3f" "$lon"); fi

    echo "$ccy|$stt|$cty|$zip|$lat|$lon"
  else
    depends "curl"
  fi
}

# whois wrapper for IP to ASN - v4.whois.cymru.com
ip2asn() {
  if which whois &>/dev/null; then
    ( IFS=' |' read asn ip name < <(whois -h v4.whois.cymru.com " -f $1")
      asn=$(grep -E '(Error|NA)' <<<"$asn" &>/dev/null && \
        echo "N/A" || echo "AS$asn")
      name=$(grep -E '(line|NA)' <<<"$name" &>/dev/null && \
        echo "N/A" || echo "$name")
      name=${name#* }
      name=${name/- /}
      name=${name%,*}
      echo "$asn|$name" )
  else
    depends "whois"
  fi
}

# wrapper for geoiplookup - geolocation lookup tool
geolookup() {
  if which geoiplookup &>/dev/null; then
    geoiplookup $1 | awk ' \
      BEGIN { RS=""; FS="\n"; OFS="|"; } \
            { split($3, a, ": "); \
              $3=a[2]; \
              gsub(", ", "|", $3); \
              print $3 \
            }'
  else
    geoip $1
  fi
}

# wrapper for geoiplookup - geolocation lookup tool (ASN)
asnlookup() {
  if which geoiplookup &>/dev/null; then
    geoiplookup $1 | awk ' \
      BEGIN { RS=""; FS="\n"; OFS="|"; } \
            { split($4, b, ": "); \
              $4=b[2]; \
              sub(" ", "|", $4); \
              print $4 \
            }'
  else
    ip2asn $1
  fi
}

# bypass bgp.he.net nounce mechanism
nounce() {
  if which curl &>/dev/null; then
    local ua=Mozilla/5.0
    local s=bgp.he.net
    local path=$(curl -s -A $ua -H "Host: $s" -D - $s/ip/$1 | \
      grep -Eo '.*--.*;' | \
      sed -r 's/.*=(.*);/\1/' | \
      sed 's/%/\/x/g')
    local p=$(echo -ne $path | md5sum | cut -d' ' -f1)
    local i=$(curl -s -A $ua -H "Host: $s" $s/i | md5sum | cut -d' ' -f1)

    # oh yeah!
    curl \
      -s \
      -XPOST \
      -A $ua \
      -H "Host: $s" \
      -d "p=$p" -d "i=$i" \
      -D - \
      -b "path=$path" \
      $s/jc | grep -Eo 'c=.*--.*;'
  else
    depends "curl"
  fi
}

# web scraper for passive DNS - bgp.he.net
# timeout in 10 seconds
psvlookup() {
  if which curl &>/dev/null; then
    local url="bgp.he.net/ip/$1#_dns"
    n=$(nounce $1)
    PSV=$(curl -m10 -s -A "$USER_AGENT" "$PROXY_OPTION" -b $n $url | \
      sed 's/>, </>\n</g' | \
      sed -nr 's/^\s*<a href="\/dns.*>(.*)<\/a>/\1/p' | \
      tr '\n' ';' | \
      sed 's/;$//')
    if [ -z "$PSV" ]; then echo "N/A"; else echo "$PSV"; fi
  else
    depends "curl"
  fi
}

# stitch 'em up
stitch() {
  RESULT=$1

  if [ -n "$DNS" ]; then RESULT="$RESULT|$DNS"; fi
  if [ -n "$BGP" ]; then RESULT="$RESULT|$BGP"; fi
  if [ -n "$GEO" ]; then RESULT="$RESULT|$GEO"; fi
  if [ -n "$ASN" ]; then RESULT="$RESULT|$ASN"; fi

  echo "$RESULT"
}

# input validation
validate() {
  # sanity check
  if [ -z "$1" ]; then
    die "missing argument: [ADDRESS]"
  else
    # quad dotted format check
    if grep -E -v '^([0-9]+\.){3}[0-9]+$' <<<"$1" &>/dev/null; then
      die "invalid IPv4 address: $1"
    else
      # ip value check
      OLD_IFS=$IFS
      IFS=. read a b c d <<<"$1"
      if (( $a > 255 || $b > 255 || $c > 255 || $d > 255 )); then
        die "invalid IPv4 address: $1"
      fi
      IFS=$OLD_IFS
    fi
  fi
}

# parse short options
OPTIND=1
while getopts ":df:hl:pv" opt; do
  case $opt in
    d)
      if [[ "$LASTOPT" == "$opt" ]]; then
        die "only one \`-$opt' may be specified"
      fi

      DNS_SERVER=${DNS_SERVERS[$RANDOM % ${#DNS_SERVERS[@]}]}
      DNS_OPTION="$DNS_SERVER"
      LASTOPT=$opt
      ;;
    f)
      if [[ "$LASTOPT" == "$opt" ]]; then
        die "only one \`-$opt' may be specified"
      fi

      # validate ranges
      if grep -E -v '^[0-9,-]+$' <<<"$OPTARG" &>/dev/null; then
        die "invalid field list -- '$OPTARG'"
      fi

      FIELD=$OPTARG
      LASTOPT=$opt
      ;;
    h)
      if [[ $# -ne 1 || $OPTIND -eq 1 ]]; then short; exit 1; fi

      usage
      exit 0
      ;;
    l)
      if [ $# -ne 1 ]; then short; exit 1; fi

      # validate option argument
      case $OPTARG in
        d)
          echo "# Public DNS servers"
          echo "# $DNS_SOURCE"
          tr ' ' '\n' <<<"${DNS_SERVERS[@]}"
          exit 0
          ;;
        p)
          if proxify &>/dev/null; then
            echo "# Open proxies"
            echo "# ${HTTP}${PROXY_HOST}"
            tr ' ' '\n' <<<"${PROXY_SERVERS[@]}"
            exit 0
          else
            die "$PROXY_HOST (connection timeout)"
          fi
          ;;
        *)
          die "invalid option argument -- '$OPTARG'"
          ;;
      esac
      ;;
    p)
      if [[ "$LASTOPT" == "$opt" ]]; then
        die "only one \`-$opt' may be specified"
      fi

      PROXY="on"
      LASTOPT=$opt
      ;;
    v)
      if [[ $# -ne 1 || $OPTIND -eq 1 ]]; then short; exit 1; fi

      echo "$PROG $VERSION"
      echo "Written by $AUTHOR"
      exit 0
      ;;
    :)
      die "option requires an argument -- '$OPTARG'"
      ;;
    \?)
      die "invalid option -- '$OPTARG'"
      ;;
  esac
done
shift $((OPTIND - 1))

# check for empty arguments
if [[ -n "$LASTOPT" && $# -eq 0 ]]; then
  validate; exit 1
elif [ $# -eq 0 ]; then
  short; exit 1
fi

# main
for i in $*; do
  input=$i; validate "$input"

  if [ -n "$PROXY" ]; then
    PROXY=$(proxify)

    if [ -z "$PROXY" ]; then
      PROXY_OPTION=
    elif [ "$PROXY" = ":" ]; then
      PROXY_OPTION=
    elif [ "${PROXY#*:}" -eq 1080 ]; then
      PROXY_OPTION="-x ${SOCKS}${PROXY}"
    else
      PROXY_OPTION="-x ${HTTP}${PROXY}"
    fi
  fi

  if [ -z "$FIELD" ]; then
    DNS=$(dnslookup "$input"); if [ $? -eq 1 ]; then exit 1; fi
    BGP=$(psvlookup "$input"); if [ $? -eq 1 ]; then exit 1; fi
    GEO=$(geolookup "$input"); if [ $? -eq 1 ]; then exit 1; fi
    ASN=$(asnlookup "$input"); if [ $? -eq 1 ]; then exit 1; fi

    stitch "$input"
  else
    SET=($(parse "$FIELD" "$MAX_FIELDS"))

    # if field is in set; turn on
    if grep -E '\b2\b' <<<"${SET[*]}" &>/dev/null; then DNS="on"; fi
    if grep -E '\b3\b' <<<"${SET[*]}" &>/dev/null; then BGP="on"; fi
    if grep -E '\b[4-9]\b' <<<"${SET[*]}" &>/dev/null; then GEO="on"; fi
    if grep -E '\b(10|11)\b' <<<"${SET[*]}" &>/dev/null; then ASN="on"; fi

    TWO=$(printf "N/A|%0.s" {1..2})
    SIX=$(printf "N/A|%0.s" {1..6})

    if [[ "$DNS" == "on" ]]; then
      DNS=$(dnslookup "$input")
      if [ $? -eq 1 ]; then exit 1; fi
    else
      DNS="N/A"
    fi

    if [[ "$BGP" == "on" ]]; then
      BGP=$(psvlookup "$input")
      if [ $? -eq 1 ]; then exit 1; fi
    else
      BGP="N/A"
    fi

    if [[ "$GEO" == "on" ]]; then
      GEO=$(geolookup "$input")
      if [ $? -eq 1 ]; then exit 1; fi
    else
      GEO="${SIX%|}"
    fi

    if [[ "$ASN" == "on" ]]; then
      ASN=$(asnlookup "$input")
      if [ $? -eq 1 ]; then exit 1; fi
    else
      ASN="${TWO%|}"
    fi

    stitch "$input" |
    cut -d"|" -f"$FIELD" 2>/dev/null |
    sed '/^$/d'
  fi
done