web-dev-qa-db-fra.com

Comment vérifier si une valeur dans une chaîne est une adresse IP

quand je fais ça

ip = request.env["REMOTE_ADDR"]

Je reçois l'adresse IP du client. Mais que faire si je veux valider si la valeur de la variable est vraiment une adresse IP? Comment je fais ça?

S'il vous plaît aider. Merci d'avance. Et désolé si cette question est répétée, je n'ai pas pris l'effort de la trouver ...

MODIFIER

Qu'en est-il des adresses IPv6?

ruby-on-railsrubystringipipv6
29
Rohit

Pourquoi ne pas laisser une bibliothèque la valider pour vous? Vous ne devez pas introduire d'expressions régulières complexes impossibles à conserver.

% gem install ipaddress

Ensuite, dans votre application

require "ipaddress"

IPAddress.valid? "192.128.0.12"
#=> true

IPAddress.valid? "192.128.0.260"
#=> false

# Validate IPv6 addresses without additional work.
IPAddress.valid? "ff02::1"
#=> true

IPAddress.valid? "ff02::ff::1"
#=> false


IPAddress.valid_ipv4? "192.128.0.12"
#=> true

IPAddress.valid_ipv6? "192.128.0.12"
#=> false

Vous pouvez également utiliser la classe IPAddr intégrée de Ruby, mais elle ne se prête pas très bien à la validation.

Bien entendu, si l'adresse IP vous est fournie par le serveur d'applications ou par la structure, il n'y a aucune raison de la valider. Utilisez simplement les informations qui vous sont données et gérez les exceptions avec élégance.

33
molf

Ruby a déjà le regex nécessaire dans la bibliothèque standard. Commander resolv .

require "resolv"

"192.168.1.1"   =~ Resolv::IPv4::Regex ? true : false #=> true
"192.168.1.500" =~ Resolv::IPv4::Regex ? true : false #=> false

"ff02::1"    =~ Resolv::IPv6::Regex ? true : false #=> true
"ff02::1::1" =~ Resolv::IPv6::Regex ? true : false #=> false

Si vous aimez le court chemin ...

require "resolv"

!!("192.168.1.1"   =~ Resolv::IPv4::Regex) #=> true
!!("192.168.1.500" =~ Resolv::IPv4::Regex) #=> false

!!("ff02::1"    =~ Resolv::IPv6::Regex) #=> true
!!("ff02::1::1" =~ Resolv::IPv6::Regex) #=> false

S'amuser!

Mise à jour (2018-10-08):

Parmi les commentaires ci-dessous, j'aime la version très courte:

!!(ip_string =~ Regexp.union([Resolv::IPv4::Regex, Resolv::IPv6::Regex]))

Très élégant avec Rails (également une réponse d'en bas):

validates :ip,
          :format => {
            :with => Regexp.union(Resolv::IPv4::Regex, Resolv::IPv6::Regex)
          }
30
wingfire
require 'ipaddr'
!(IPAddr.new(str) rescue nil).nil?

Je l'utilise pour une vérification rapide car il utilise la bibliothèque intégrée. Prend en charge les ipv4 et ipv6. Il n’est pas très strict, par exemple, «999.999.999.999» est valide. Voir la réponse gagnante si vous avez besoin de plus de précision.

14
Evgenii

Comme la plupart des réponses ne parlent pas de validation IPV6, j'ai eu le même problème. Je l'ai résolu en utilisant la bibliothèque Ruby Regex, comme mentionné par @wingfire.

Mais j'ai aussi utilisé la bibliothèque Regexp pour utiliser sa méthode union comme expliqué ici

J'ai donc ce code pour une validation:

validates :ip, :format => { 
                  :with => Regexp.union(Resolv::IPv4::Regex, Resolv::IPv6::Regex)
                }

J'espère que cela peut aider quelqu'un!

8
Philippe B.

Toutes les réponses ci-dessus supposent que IPv4 ... vous devez vous demander à quel point il est sage de limiter votre application à IPv4 en ajoutant ce type de vérification à la migration Internet vers IPv6.

Si vous me demandez: ne le validez pas du tout. Au lieu de cela, passez simplement la chaîne telle quelle aux composants réseau qui utiliseront l'adresse IP et laissez-les effectuer la validation. Attrapez les exceptions qu'ils liront quand ce sera faux et utilisez cette information pour dire à l'utilisateur ce qui s'est passé. Ne réinventez pas la roue, construisez sur le travail des autres.

4
Stijn de Witt

Utilisez http://www.Ruby-doc.org/stdlib-1.9.3/libdoc/ipaddr/rdoc/IPAddr.html il effectue la validation pour vous. Il suffit de sauver l’exception avec false et vous savez qu’elle n’est pas valide.

1.9.3p194 :002 > IPAddr.new('1.2.3.4')
 => #<IPAddr: IPv4:1.2.3.4/255.255.255.255> 
1.9.3p194 :003 > IPAddr.new('1.2.3.a')
ArgumentError: invalid address
  from /usr/local/rvm/rubies/Ruby-1.9.3-p194/lib/Ruby/1.9.1/ipaddr.rb:496:in `rescue in initialize'
  from /usr/local/rvm/rubies/Ruby-1.9.3-p194/lib/Ruby/1.9.1/ipaddr.rb:493:in `initialize'
  from (irb):3:in `new'
  from (irb):3
  from /usr/local/rvm/rubies/Ruby-1.9.3-p194/bin/irb:16:in `<main>'
4
mar
require 'ipaddr'

def is_ip?(ip)
  !!IPAddr.new(ip) rescue false
end

is_ip?("192.168.0.1")
=> true

is_ip?("www.google.com")
=> false

Ou, si cela ne vous dérange pas d'étendre les classes principales:

require 'ipaddr'

class String
  def is_ip?
    !!IPAddr.new(self) rescue false
  end
end

"192.168.0.1".is_ip?
=> true

"192.168.0.512".is_ip?
=> false
3
Knotty66

Essaye ça

Utilisez IPAddr

require 'ipaddr'
true if IPAddr.new(ip) rescue false
2
Rahul Patel

J'utilise cette expression régulière que j'ai trouvée ici

/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

1
Gerhard

pour faire correspondre une adresse IP valide avec une utilisation rationnelle

^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$

au lieu de

^([01]?[0-9][0-9]?|2[0-4][0-9]|25[0-5])(\.([01]?[0-9][0-9]?|2[0-4][0-9]|25[0-5])){3}$

parce que de nombreux moteurs d'expression régulière correspondent à la première possibilité dans la séquence OR

vous pouvez essayer votre moteur regex: 10.48.0.200

tester la différence ici

0
Alban

L'adresse IP sous forme de chaîne doit contenir exactement quatre chiffres, séparés par des points. Chaque numéro doit être compris entre 0 et 255 inclus.

0
squadette

Valider à l'aide d'une expression régulière:

\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}
0
ankitjaininfo