Port check
Enter a host (domain or IP) and a port. The server will try to connect via TCP.
WHOIS lookup
Search for IP or domain and see the raw WHOIS response.
Waiting for query…
JavaScript Obfuscator
Paste your script on the left and generate the obfuscated version on the right.
Details of Obfuscation
The first configuration, known as fast-1, focuses on creating a lighter and quicker obfuscation layer. The main idea here is to keep the code compact, which means removing unnecessary spaces and line breaks so that the final script is smaller and loads faster in the browser. Another important feature is the use of string arrays, which essentially means that text values inside the code are stored in arrays and then referenced indirectly, making it harder for someone reading the code to immediately understand the meaning of each string. To make this even stronger, the string array may be rotated, which changes the order of the stored values and complicates reverse engineering. In addition, this configuration has self-defending capabilities, which means that if someone tries to tamper with or debug the code, it may stop functioning or break intentionally. On the other hand, more advanced transformations such as control flow flattening or adding fake dead code are not included in this profile, because the main goal is speed and efficiency rather than maximum protection.
The second configuration, fast-2, provides a balance between compactness and readability obfuscation. Just like the first one, the script is reduced to a more compact form for efficiency. However, in this case the code is also simplified, which means that redundant expressions are rewritten in a cleaner way before being obfuscated, resulting in a smaller and more optimized script. This version also makes use of string arrays and rotates them, making text values harder to track. The threshold of how many strings are obfuscated is carefully balanced so that performance is not heavily affected. Control flow flattening is disabled here too, because the intention of this fast profile is to protect while keeping execution speed high. This configuration is especially useful for projects that need to run quickly on the client side while still protecting core logic from casual inspection.
The third configuration, fast-3, takes a slightly different approach by adjusting the threshold of how many strings are actually placed into arrays. This means that not all strings are obfuscated, but only a fraction, which reduces overhead and makes the code faster to run. The result is a good compromise: many strings are hidden and rewritten, yet the application still runs smoothly. The compacting and simplification of code remain, making the script both small and reasonably optimized. Since control flow flattening is disabled, the code structure is not drastically altered, keeping execution performance high. This type of configuration is typically chosen when developers want to avoid any unnecessary slowdowns but still want to protect the most visible parts of their logic.
The fourth configuration, fast-4, is another variant designed for speed but with a much higher threshold for hiding strings. This means that almost all the strings in the code are transformed and stored indirectly, which makes the script much harder to analyze but can slightly increase execution complexity. Still, because advanced transformations are not used, the code remains performant and light compared to stronger protection profiles. As with the other fast modes, this approach is recommended when developers are mostly concerned with protecting intellectual property without heavily sacrificing speed. It works particularly well for applications where text values may reveal sensitive business logic but where performance is still critical.
The first strong configuration, strong-1, represents a significant jump in protection compared to the fast series. Here the code is compacted as usual, but now control flow flattening is enabled, which completely rearranges the way the execution flow looks, making it extremely difficult for humans to follow the logic. Dead code injection is also applied, which means that useless code snippets are inserted randomly to confuse anyone trying to analyze the program. Strings are completely hidden in arrays, and these arrays are rotated, adding another layer of confusion. The self-defending feature ensures that if someone tries to modify the script or remove the obfuscation, it will break or stop working. In this profile, the threshold for hiding strings is set to the maximum, which means every string is protected. This makes the code much more resilient against reverse engineering, but it also adds some computational cost.
The second strong configuration, strong-2, is one of the most advanced and protective setups available. Not only does it flatten the control flow, but it also does so with a high threshold, meaning that almost all parts of the code are affected. Strings are hidden and additionally encoded using strong methods like RC4, which makes them practically impossible to read without executing the code. Arrays of strings are shuffled and rotated, further complicating the analysis. This version splits long strings into smaller chunks, which are later reassembled at runtime, making it extremely difficult to reconstruct the original values. There are also features like disabling console output to prevent debugging, transforming numeric values into complex expressions, simplifying and rewriting object keys, and encoding characters using Unicode escape sequences. Together, these techniques create an environment where reverse engineering is time-consuming and highly impractical. This configuration is ideal when protecting sensitive algorithms, proprietary logic, or financial operations.
The third strong configuration, strong-3, follows a similar philosophy but emphasizes total protection of strings. In this case, strings are always hidden, encoded using RC4, and shuffled. Dead code is also injected, making the script appear much more complex than it actually is. Control flow flattening completely scrambles the logical structure, while self-defending features make it risky for attackers to try modifying or debugging the script. This creates a hardened codebase where every critical part is protected. While this adds a performance overhead, it is often worth the trade-off when the goal is to make sure the application cannot be easily copied or tampered with.
The fourth strong configuration, strong-4, applies many of the same principles but uses a different method for string encoding. Instead of RC4, it uses Base64 encoding, which is simpler but still effective in hiding text values from plain sight. The threshold is slightly lower, which means that not all strings are hidden, but still a significant portion of them are. Control flow flattening makes the execution order confusing, and the inclusion of Unicode escape sequences ensures that characters are not easily recognizable. This creates a balanced configuration that offers strong protection while being less heavy than the most extreme strong profiles. It is suitable for projects that need strong obfuscation without fully sacrificing runtime efficiency.
Port-Check
A port-check is one of the most useful tools when it comes to understanding how devices communicate on the internet. Every service that runs online uses a specific port to transmit and receive data. For example, web browsing usually occurs through port 80 for standard HTTP traffic and port 443 for secure HTTPS communication. Email services rely on ports like 25, 465, or 587 for sending messages, while ports 110 or 995 are often used for receiving mail through POP3, and ports 143 or 993 are used for IMAP. File transfers, another common activity, may pass through ports such as 21 for FTP or 22 for secure SSH connections. By checking whether a port is open, closed, or filtered, administrators and users can verify that the service is available and running correctly.
The importance of checking ports goes beyond simply knowing if a service is active. From a security perspective, leaving unnecessary ports open can expose a system to attacks. Hackers often scan large ranges of ports to identify weaknesses and entry points. For this reason, blocking or closing unused ports is considered one of the first steps in securing servers and personal computers. A closed port means that no communication is allowed through it, significantly reducing the attack surface of a machine. Firewalls, both hardware and software, play a vital role in enforcing these rules by controlling which ports can be accessed from outside networks.
Performing regular port-checks ensures that essential services remain accessible while risky or unused ports are properly shut down. This kind of practice is common in both corporate environments and personal networks. For example, a company hosting a website will need to confirm that port 443 is open and responding correctly to encrypted requests, while at the same time blocking ports that are not relevant to the service being provided. On a personal level, users might check ports if they experience issues with online gaming, video conferencing, or file sharing. By diagnosing port accessibility, one can quickly determine whether a connection problem is due to local restrictions, firewall rules, or issues with the service provider. In summary, port-checking is both a diagnostic and a security tool, helping balance accessibility with protection.
Whois Lookup
A Whois lookup is a service that allows anyone to retrieve registration details about a domain name or an IP address. When a domain is registered, information such as the name of the registrant, the organization, the registrar, and the dates of creation and expiration are stored in public databases. By performing a Whois lookup, a user can access this information and gain valuable insight into who owns a particular website or which company is responsible for a certain range of IP addresses. This transparency was built into the architecture of the internet to maintain accountability and trust between parties interacting online.
The benefits of consulting Whois records are numerous. For individuals, it can be a simple way to verify whether a domain is genuinely connected to a legitimate business or organization. For businesses, Whois lookups can help detect trademark infringement, uncover fraudulent websites, or track down cybersquatting, where malicious actors register domains similar to well-known brands. Network administrators use Whois to identify the source of suspicious traffic, investigate potential abuse, or resolve connectivity problems by contacting the correct provider or owner. Even law enforcement agencies rely on Whois data to track down cybercriminals and coordinate with registrars during investigations.
Another advantage of Whois lookups is their role in domain management and strategic planning. Before registering a new domain, a company might check Whois to confirm availability or to see who currently owns a name that is of interest. It can also reveal when a domain is set to expire, opening the opportunity to acquire it if the current owner does not renew. Similarly, Whois can help identify trends in domain ownership, such as whether a certain group of websites is operated by the same entity. All of this information contributes to making better decisions regarding branding, cybersecurity, and online presence. In essence, Whois lookup services provide a window into the administrative layer of the internet, offering transparency, security, and business intelligence.