Discover the server name behind a dns name in seconds: DNS Lookup Essentials, Reverse DNS, TLS Clues, Origin Hints 2026

Discover the server name behind a dns name in seconds. Quick fact: you can reveal the exact server host or IP-related details behind almost any domain with a few simple tools. This guide is built for creators and tech-curious folks alike, so you’ll get practical steps, real-world tips, and clear examples you can apply today.

• Quick-start steps

  1. Use basic DNS lookups to see A/AAAA records and map the domain to an IP.
  2. Check the reverse DNS to learn the hostname associated with an IP.
  3. Use port-check and banner-grabbing tools to learn what service is running at the server.
  4. Cross-check with passive data sources to confirm server identity.

• What you’ll learn

  • How to identify the primary server behind a DNS name
  • The difference between IP, hostname, and service banners
  • When passive data can mislead and how to verify
  • Practical tips for privacy and security considerations

Useful resources: Apple Website – apple.com, Artificial Intelligence Wikipedia – en.wikipedia.org/wiki/Artificial_intelligence, DNS Tools – example.org/dns-tools, ICANN – icann.org, Shodan – shodan.io, SecurityTrails – securitytrails.com

Table of Contents

• What does “server name behind a DNS name” mean?
• Quick methods to reveal the server behind a DNS name
• Deeper dive: DNS records and what they tell you
• Reverse DNS and PTR records explained
• Port scanning, banners, and service identification
• Why content delivery networks CDNs complicate the picture
• Privacy, ethics, and legal considerations
• Practical examples: real-world walkthroughs
• Common mistakes to avoid
• SEO and optimization tips for your own content
• Frequently Asked Questions

What does “server name behind a DNS name” mean?
When you type a domain like example.com, your browser resolves it to an IP address. That IP belongs to a server somewhere—often behind layers like load balancers, CDNs, or reverse proxies. The “server name” could be the underlying host, the origin server, or the service visible through banners and TLS certificates. In short, you’re trying to map the public DNS name to the actual machine or service behind it.

Quick methods to reveal the server behind a DNS name
Below are practical, quick-start approaches you can try now. I’ve added intuition on what you’re likely to learn with each method.

1. Basic DNS lookups A, AAAA, CNAME, NS

• What to run:
  • dig example.com A
  • dig example.com AAAA
  • dig example.com CNAME
  • nslookup example.com
• What you’ll see and what it means:
  • A/AAAA records show the IP addresses used by the domain.
  • CNAME reveals if the domain is an alias to another domain.
  • NS tells you who runs the domain’s DNS; sometimes the owner’s infrastructure hints at the hosting environment.
• Quick takeaway: If you get multiple IPs, you’re probably behind a load balancer or CDN. If you land on a well-known CDN edge, the “server name” may be the edge node, not the origin.

2. Reverse DNS PTR to learn the hostname from an IP

• What to run:
  • dig -x 93.184.216.34
• What you’ll learn:
  • The PTR record can reveal a hostname associated with the IP. This is not always set or accurate, but it can point you to the hosting provider or organization.

3. Whois and registrar data

• What to run:
  • whois example.com
• What you’ll learn:
  • Registration details, hosting providers, and sometimes the organization owning the IP block. This can guide you toward the provider that owns the origin server.

4. Service banners and TLS certificate inspection

• What to run:
  • openssl s_client -connect example.com:443
  • nmap -sV example.com
• What you’ll learn:
  • TLS certificate subject and issuer can indicate the hosting company or service e.g., a certificate issued to a cloud provider.
  • Port scanning reveals the services running on the host, which helps identify the server type web server, mail server, game server, etc..

5. HTTP headers and server banners

• What to run:
  • curl -I https://example.com
  • curl -s https://example.com | head -n 1
• What you’ll learn:
  • Server header often reveals the software Apache, nginx, cloudflare, etc.. Some sites spoof this, so treat it as a hint rather than a truth.

6. Passive data sources and footprinting

• What to run:
  • securitytrails.com, censys.io, shodan.io searches for the domain
• What you’ll learn:
  • Historical data, technologies used, SSL configurations, and associated hosts. This can help you infer the origin server behind the DNS name.

Deeper dive: DNS records and what they tell you

• A and AAAA records: point to IPs; multiple A records suggest load balancing or CDN usage.
• CNAME: aliasing to another domain; tells you the actual origin might be hosted elsewhere.
• MX: mail servers; if you’re querying a domain, this reveals email infrastructure rather than web servers.
• TXT: sometimes contains SPF, DKIM, or domain verification data useful for security posture but not directly about the web server.
• PTR: reverse DNS; not always set, but when present, helps identify the host on that IP.

Reverse DNS and PTR records explained

• Reverse DNS maps IPs back to domain names. Many networks rely on reverse DNS for logging and anti-spam measures.
• Limitations:
  • Not all IPs have PTR records.
  • PTR can point to a general host name like host-1234.isp.net, which isn’t helpful for identifying the origin server.
• Practical approach:
  • Use forward DNS plus IP ownership data to triangulate the likely origin.

Port scanning, banners, and service identification

• Why this matters: The combination of open ports and service banners helps you identify what’s running on the server, which is a strong hint of the underlying server type.
• Tools and tips:
  • Nmap: great for discovering open ports and versions. Use with care and respect the target’s policy.
  • Banner grabbing: banner data on ports like 80/443, 21, 22, 25 often reveals software versions dangerous if misused.
• Quick example:
  • nmap -sV example.com
  • If you see https on 80/443 with “nginx” or “Apache” in the banner, you know the web server software, not necessarily the origin host.

Why content delivery networks CDNs complicate the picture

• CDNs mask the origin server. The DNS name resolves to CDN edge servers, so zapping into the origin becomes tricky.
• Signs you’re behind a CDN:
  • IPs belong to CDN networks.
  • TLS certificates issued to CDN providers or shared with the CDN.
  • HTTP headers like cf-ray Cloudflare, x-amz-cf-id Amazon CloudFront, and similar.
• How to get closer to the origin ethically and legally:
  • Check the domain’s DNS records for CNAMEs pointing to known providers e.g., amazonaws.com, cloudfront.net.
  • Use policy-compliant communications with site owners for origin details if you have a legitimate reason.

Privacy, ethics, and legal considerations

• Respect terms of service and laws. Scanning and fingerprinting can be intrusive or illegal in some contexts.
• Use only domains you own or have explicit permission to test.
• If you’re doing this for research or content, clearly state boundaries and avoid attempting intrusive methods on domains you don’t control.

Practical examples: real-world walkthroughs
Example 1: Revealing a simple domain behind a CDN

• Domain: examplecdn.com
• Steps:
  • dig examplecdn.com A -> IPs show a set of CDN edge addresses.
  • dig examplecdn.com CNAME -> points to d1234.cdnprovider.net.
  • curl -I https://examplecdn.com -> server header shows “cloudflare” or similar.
  • Open ports with nmap -> 443 only with TLS, common for CDN-driven sites.
• Takeaway: The origin server is often obfuscated behind CDN infrastructure.

Example 2: Origin server behind a load balancer

• Domain: myservice.org
• Steps:
  • A records show multiple IPs from diverse ranges.
  • PTR for an IP might reveal a data center or hosting provider.
  • TLS certificate issuer shows a data center brand or cloud provider.
  • Nmap shows open ports for 80/443 and sometimes 8443 or 5432 if the service is exposed.
• Takeaway: The service likely runs behind a load balancer with multiple origin servers.

Example 3: Direct hosting on a single server

• Domain: myblog.example
• Steps:
  • A record IP points to a single address in a known hosting range.
  • HTTP banner indicates nginx.
  • TLS cert shows a domain-validated certificate for the site.
• Takeaway: This is probably a straightforward origin server without CDN masking.

Common mistakes to avoid

• Relying solely on TLS certificate issuer to identify the origin; CDNs can use shared certificates.
• Assuming a server banner is trustworthy; banners can be spoofed or altered.
• Overlooking CDN presence when domains have multiple A records from the same provider’s IP ranges.
• Skipping consent: never scan or probe servers you don’t own or don’t have permission to test.

SEO and optimization tips for your own content

• Use clear, plain language and step-by-step guides.
• Include practical, real-world examples to illustrate each technique.
• Use visuals such as numbered steps and small tables to summarize findings without getting too long-winded.
• Optimize for user intent: people searching for “how to discover the server behind a DNS name” want actionable steps, not theory.
• Include a robust FAQ with at least 10 questions to capture long-tail queries.

Frequently Asked Questions

What does it mean to discover the server name behind a DNS name?

It means identifying the actual host or service behind the domain by examining DNS records, IPs, reverse DNS, certificates, and banners to infer the origin server or service.

Can I always find the origin server for any domain?

Not always. Many domains use CDNs or proxies that hide the origin. Some domains also aggressively mask information for security and privacy.

Is it legal to scan domains to identify their server?

Legal guidelines vary by jurisdiction. Only scan domains you own or have explicit permission to test. Follow responsible disclosure practices.

What is a CDN, and how does it affect identification?

A CDN distributes content from edge servers, masking the origin. You’ll often see CDN-related IP ranges, headers, and certificates instead of the origin details.

Why do I sometimes see different IPs for the same domain?

Because of load balancing, CDN usage, or DNS changes. Different users or times may resolve to different edge servers.

What data is most trustworthy when identifying a server?

Cross-reference multiple data points: DNS records, TLS certificates, HTTP headers, and active port banners. Don’t rely on a single source.

How do I identify the cloud provider hosting a domain?

Look at the IP ranges, TLS certificate issuers, and CNAME patterns. Passive data sources like SecurityTrails or Shodan can help map IPs to providers.

Can I determine the exact origin server behind a CDN?

Often not directly. You can infer likely origin by looking for CNAMEs, DNS history, or contacting the site owner for permission to learn more.

What tools should beginners start with?

Dig/nslookup for DNS, curl for HTTP headers, and basic nmap usage for service discovery. Always follow safe and ethical guidelines.

How do privacy and ethics play into this?

Respect privacy, avoid intruding into systems you don’t own, and obtain permission before probing. Use the information responsibly and for legitimate purposes.

Additional resources and references

• DNS Tools – example.org/dns-tools
• ICANN – icann.org
• Shodan – shodan.io
• SecurityTrails – securitytrails.com
• What is DNS? – en.wikipedia.org/wiki/Domain_name_system
• Understanding TLS Certificates – ssl.com/blog/tls-certificate-basics
• HTTP Headers Explained – developer.mozilla.org/en-US/docs/Web/HTTP/Headers

Notes for creators

• If you’re producing a video or tutorial, pair each method with a short live demonstration.
• Include a “before you begin” checklist and a “safety and ethics” reminder for your audience.
• Provide a downloadable quick-reference cheat sheet with commands and expected outcomes.
• Use relatable analogies: think of DNS like a phone book, IPs as streets, and TLS certificates as ID badges.

Appendix: Quick reference commands

• DNS A record: dig example.com A
• DNS AAAA record: dig example.com AAAA
• DNS CNAME: dig example.com CNAME
• Reverse DNS: dig -x 93.184.216.34
• Whois: whois example.com
• TLS scan: openssl s_client -connect example.com:443
• Service version: nmap -sV example.com
• HTTP headers: curl -I https://example.com

End of document

Yes—use a quick DNS lookup to reveal the server name in seconds. In this guide, you’ll learn how to uncover the real host behind a DNS name using practical steps like forward DNS checks, reverse DNS lookups, TLS certificate clues, and origin-detection tricks. This is a practical, step-by-step walkthrough you can follow in real life, not just theory. We’ll cover the exact commands, the reasoning behind each step, and the common pitfalls you’ll run into when a site uses CDNs or privacy protections. By the end, you’ll have a solid playbook you can use in under five minutes, with tips to verify your results and avoid mistakes.

What you’ll get in this guide

• A simple, repeatable 1-minute method to identify the server name behind a DNS name
• How to read DNS records A, AAAA, CNAME and what they tell you about hosting
• How to perform reverse DNS lookups and what PTR records really mean
• How to extract hostname hints from TLS certificates and SNI
• How to use WHOIS and IP allocation data to infer ownership and hosting
• How to spot when a site is fronted by a CDN or edge network and what that means for origin discovery
• Real-world examples, common mistakes, and safety tips
• A clear FAQ with at least 10 questions so you have quick answers on hand

Useful resources unlinked text

• DNS Lookup Tools – dig, nslookup, host
• TLS and certificates – openssl s_client, certificate inspection guides
• WHOIS data sources – regional internet registries RIRs and public WHOIS databases
• CDN and hosting indicators – Cloudflare, Akamai, Fastly documentation
• Network tracing – traceroute, pathping, mtr
• Privacy, legality, and ethics guides – best practices when probing domains you don’t own

Body

The basics you should know before you start

Before you jump into commands, here’s the quick mental model. A DNS name like example.com is a pointer to an IP address or another name. That IP address is where the actual server sits. But many sites don’t point directly to the origin server. they point to a CDN, a load balancer, or a virtual host. Your goal is to gather clues about the real origin when possible, and to understand when you can’t. The most common records to check are A IPv4, AAAA IPv6, CNAME aliasing, and potentially PTR reverse DNS. TLS certificates and HTTP headers often leak hints about the origin. WHOIS tells you who owns the IP and the hosting provider. Together, these data points create a picture of where the server lives.

Quick-start 1-minute method

If you’re in a rush, here’s a fast, repeatable method you can run in your terminal.

1. Forward DNS check

• Command: dig example.com A
• What you’re looking for: the IPv4 addresses the domain resolves to. If you get multiple addresses, note them. some may represent CDN edge nodes, others the origin.

2. Check AAAA for IPv6

• Command: dig example.com AAAA
• What you’re looking for: IPv6 addresses, if any. Some CDNs prefer IPv6, which can influence routing and server selection.

3. Inspect potential CNAME chains

• Command: dig example.com CNAME
• What you’re looking for: a canonical name that the domain points to. If there’s a chain, follow it with more digs to see the final A/AAAA addresses.

4. Reverse lookups on the IPs

• Command: dig -x 203.0.113.10
• What you’re looking for: a hostname associated with the IP. A PTR record can hint at the original host, but many large networks don’t publish friendly PTR names.

5. TLS certificate clues

• Command: openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null | openssl x509 -noout -subject -issuer -dates -text
• What you’re looking for: the certificate’s common name CN and Subject Alternative Names SANs. If the cert lists a hostname that matches the domain or a well-known origin host, you’ve got a clue about the server name or the service presenting the certificate.

6. Check the certificate’s public fingerprints

• Command: openssl s_client -connect example.com:443 -servername example.com </dev/null 2>/dev/null | openssl x509 -noout -fingerprint -sha256
• What you’re looking for: fingerprints can help you verify you’re seeing the expected certificate, not a spoof.

7. Quick WHOIS for the IP or domain

• Command: whois 203.0.113.10
• What you’re looking for: the organization that owns the IP block, the hosting provider, and possibly the data-center location. This can hint at the origin hosting if not directly exposed by DNS.

8. Look for CDN hints

• Check the CNAME target. many CDNs use known hostnames like something.cdnprovider.net. A chain ending in a CDN domain usually means you’re seeing an edge server, not the origin.

9. HTTP headers for server hints

• Command: curl -I https://example.com
• What you’re looking for: Server, Via, X-Cache, x-amz-id-2, or other headers that indicate edge infrastructure or origin servers.

10. Keep an eye on latencies

• While not a definitive indicator, large jump patterns or long RTTs between hops can suggest edge networks or geo-distributed hosting.

Tip: When you see a CNAME that points to a CDN, you’re often not going to reveal the origin easily. In that case, you may rely more on TLS certificate hints and AS/ownership data from WHOIS to infer the likely origin.

Understanding the data points A, AAAA, CNAME, PTR

• A and AAAA: These show where the domain resolves to today. If a domain has many A records that resolve to known CDN IP ranges, you’re likely looking at a front-end edge network.
• CNAME: This reveals aliasing. A CNAME can point to a provider like a CDN or a hosting platform. Following the chain often leads you to the final A/AAAA.
• PTR: Reverse DNS can expose a hostname that the IP is configured to present, but many networks don’t publish meaningful PTR records. Don’t rely on PTR as your sole origin indicator.
• TLS CN/SAN: The certificate’s subject fields can reveal the intended hostname for the service you’re connecting to. Some CDNs present certificates that include the origin host name or a host inside the CDN network.
• WHOIS/IP allocation: Ownership data tells you who owns the IP block and who manages the hosting—this helps you map the IP to a provider like a cloud provider, data center, or hosting company.

How to interpret TLS certificates for host hints

TLS certificates are a goldmine when looking for origin hints. If you connect to a site and the certificate lists a hostname that looks like the domain itself or a domain you know to be part of the origin, you’ve found a potential lead. If the SANs include a host that looks like a corporate origin for example, app.example.com or origin.example.net you’re closer to the real server. Remember that modern TLS configurations often use a single certificate for many domains across a CDN, so the hostname in the certificate may not always be the exact origin.

Pro tip: Compare the certificate’s common name and SANs with the domain you queried. If they align with a known service like a cloud app, API gateway, or a SaaS origin, you’ve got a stronger signal. Discover the fastest and most reliable dns servers with nslookup: Benchmark Latency and Reliability 2026

How CDN usage changes your results

CDNs are built to mask the origin server. When a domain is behind a CDN, the A/AAAA records usually point to the CDN’s edge infrastructure, which then proxies traffic to the origin. In this case:

• You’ll often see multiple IPs in different geographies.
• The TLS certificate may be shared across many domains, with a wildcard or SAN that’s not the exact origin hostname.
• Reverse DNS on edge IPs might reveal generic CDN hostnames rather than the actual origin.
• WHOIS data might point to the CDN provider rather than the site owner.

If your goal is to discover the origin, you’ll mostly rely on TLS hints and file footprints across edge nodes, as well as any public hints from the domain’s own DNS configuration. If you’re just trying to map where a domain lands on the internet for performance checks, the edge view is often enough.

Practical examples illustrative, not real customer data

• Example A: examplecdn.com

  • A records point to 93.184.216.34 and 93.184.216.35
  • CNAME resolves to origin.cdnprovider.net
  • TLS cert CN is examplecdn.com with SANs including origin.examplecdn.net
  • WHOIS shows the IP block is managed by a large CDN provider
  • In this case, you’re seeing CDN edge servers. the origin is behind the CDN

• Example B: some-service.io

  • A records reveal a set of AWS IP ranges
  • TLS cert CN is api.some-service.io
  • HTTP headers show X-Cache: Hit from CloudFront
  • Traceroute paths hop through CloudFront edge networks
  • You can infer the host is behind a CDN and the origin is in the AWS network

• Example C: corporateapp.net Discover the DNS Server IP on Linux a Step by Step Guide to Find DNS Addresses and Verify Connectivity 2026

  • PTR for IP shows host-1234.corporate-data-center.net
  • WHOIS lists a private data-center provider
  • The TLS certificate lists a corporate internal hostname in SANs
  • Conclusion: the origin is likely in a private data center, but the public DNS may hide it behind a VPN or NAT

These examples show how to triangulate the origin by combining data sources. The key takeaway: don’t rely on a single data point. look for patterns across multiple signals.

Tables: quick-reference commands by OS

OS	Command	What it shows	Quick tip
Windows	nslookup example.com	DNS A/AAAA records and server used	For quick checks, use Resolve-DnsName in PowerShell for richer output
Windows	nslookup -type=PTR IP	Reverse DNS name, if available	PTR is hit-or-miss on modern networks
macOS/Linux	dig example.com A	IPv4 addresses	Use +short for concise output
macOS/Linux	dig example.com CNAME	Alias targets	Follow CNAME chains to the final A/AAAA
macOS/Linux	dig -x 203.0.113.10	Reverse DNS	PTR record if published
macOS/Linux	curl -I https://example.com	HTTP headers	Look for Server, Via, X-Cache
All	openssl s_client -connect example.com:443 -servername example.com	TLS certificate	Inspect CN and SANs for origin hints

Common pitfalls and how to avoid them

• Pitfall: The site uses a CDN, so A/AAAA records show the CDN edge, not the origin.
  • Solution: Focus on TLS certs, CNAME chains, and HTTP header hints. check for CDN-specific headers or hostnames.
• Pitfall: No PTR records for the IPs you see.
  • Solution: Don’t rely on reverse DNS. move to WHOIS and CDN indicators.
• Pitfall: Certificates are wildcarded or shared across many domains.
  • Solution: Look for SAN patterns that map to a known origin service or to a private hostname in the same organization.
• Pitfall: Hostnames in TLS do not match the domain you started with.
  • Solution: It could be a TLS termination service. verify with multiple data points headers, path, and certificate.
• Pitfall: You don’t own the domain. actions may violate terms of service or laws.
  • Solution: Always stay within lawful boundaries. use public data and caution when probing.

Ethical note: Use this guide for legitimate purposes—troubleshooting, performance optimization, or domain research you’re authorized to conduct. If you’re probing domains you don’t own or operate, be mindful of privacy and legal implications.

Real-world tips you can apply today

• When you see a CNAME to a well-known CDN, treat the origin as hidden behind edge servers unless you have explicit provenance from the domain owner.
• If the TLS certificate shows a corporate hostname in SANs that matches a known internal service, you may be looking at a private origin that isn’t publicly exposed.
• If you’re trying to verify a security posture or perform a safe pentest, ensure you have permission and follow responsible disclosure practices.
• For a quick video recap, you can demonstrate the exact commands on your own domain or a test domain you control to avoid disrupting services.

Advanced detection: when you need more depth

• Use historical DNS data: Some services provide historical DNS history that can show changes in A/AAAA/CNAME over time. This can reveal a shift from origin to CDN and back.
• Look at edge-server fingerprints: Some CDNs publish distinctive TLS fingerprints or header patterns that hint at the provider.
• Observe traffic patterns: Sudden changes in routing, geo-distribution, or response times can indicate a migration to a new hosting or CDN configuration.
• Combine with security research tools: Vulnerability databases and security research platforms sometimes expose patterns that can hint at underlying services tied to a host.

Final tips for creators and researchers

• Always start with the simplest checks A/AAAA, CNAME and gradually layer in more complex tests TLS, headers, WHOIS.
• Document every step you take when you’re testing a domain so you can reproduce your results or explain your methodology in a video or write-up.
• Use a consistent workflow and a checklist to ensure you don’t miss a data point. This makes your content reliable and repeatable.

Frequently Asked Questions

How can I identify the origin server for a domain?

Start with forward DNS A/AAAA/CNAME, then check reverse DNS PTR, TLS cert CN/SANs, HTTP headers, and finally WHOIS data. If it’s behind a CDN, expect limited visibility into the true origin.

Can I always discover the server behind a DNS name?

Not always. Some domains are fully behind CDNs or privacy-protecting setups, which hide the origin. In those cases you’ll rely on TLS hints and ownership data to infer.

What is reverse DNS and why is it useful?

Reverse DNS PTR maps an IP back to a hostname. It can reveal the host the IP is configured to present. However, PTRs aren’t always published or meaningful for modern hosting. Discover the Power of Verified Discord Communities How to Add Verification to a Discord Server 2026

How do I check the TLS certificate for hostname hints?

Connect to the domain on port 443 with a TLS client openssl s_client and inspect the certificate’s CN and SANs. These fields can reveal the intended host or related services.

What if the domain uses a CDN?

Expect edge IPs and certificates shared across many domains. Look for CNAMEs pointing to CDN networks and TLS patterns that indicate edge termination rather than origin.

What data can WHOIS reveal about the host?

WHOIS can show the owner of the IP block, the hosting provider, and the registered organization. This helps map who operates the service and where it’s hosted.

How accurate are the hints from TLS certs?

TLS hints are helpful but not definitive. A certificate can be shared by many domains or terminated at a CDN edge. Use TLS data in combination with other signals.

Are there privacy concerns or legal considerations?

Yes. Probing domains you don’t own can raise privacy and legal concerns. Always obtain permission and stay within the boundaries of applicable laws and terms of service. Discover the real reason why your discord server is down and how to fix it fast 2026

What tools are best for beginners?

For beginners, start with dig and nslookup for DNS, openssl s_client for TLS, and curl for HTTP headers. Resolve-DnsName in PowerShell is handy on Windows. Gradually add WHOIS and traceroute as you gain confidence.

How fast can I get results?

With practice, you can complete the core checks in under five minutes. A thorough analysis with multiple data sources may take longer, but you’ll have a much clearer picture of the server and hosting behind the DNS name.

Sources:

Vpn路由器ptt 完整指南：选购、设置、性能对比、隐私保护要点与实战技巧

Edge of sleep vpn reddit

How to connect multiple devices nordvpn Discover the Secret How to Easily Look Up a Discord Server: Quick, Practical Guide to Finding Any Community 2026

免费节点翻墙订阅：VPN 节点、稳定性、价格对比、以及实用订阅攻略

Die besten kostenlosen vpns fur android tv inklusive purevpn im test 2025