JARM

JARM Description

JARM is a Transport Layer Security (TLS) server identification tool that features active scanning.

The JARM hash is similar in purpose to JA3S and JA4S.

JARM fingerprints can be used to:

  • Quickly verify that all servers in a group have the same TLS configuration.
  • Group disparate servers on the Internet by configuration, for example to identify that a server may belong to Google, Salesforce, or Apple.
  • Identify applications or infrastructure with default settings.
  • Identify command and control (C2) infrastructure for malware and other malicious servers on the Internet.

Homepage:

Author:

  • John Althouse - Original idea, concept and project lead
  • Andrew Smart - Concept and testing
  • RJ Nunnally - Programing and testing
  • Mike Brady - Programing and testing

License: BSD-3-Clause license

JARM Help

Usage:

jarm.py [-h] [-i INPUT] [-p PORT] [-v] [-V] [-o OUTPUT] [-j] [-P PROXY] [scan]

To scan, it is mandatory to specify a target (a single IP or a file with a list of targets), and you can optionally specify a port to be scanned.

Options:

positional arguments:
  scan                  Enter an IP or domain to scan.

options:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Provide a list of IP addresses or domains to scan, one domain or IP address per line. Optional: Specify port to scan with comma separation (e.g. 8.8.4.4,853).
  -p PORT, --port PORT  Enter a port to scan (default 443).
  -v, --verbose         Verbose mode: displays the JARM results before being hashed.
  -V, --version         Print out version and exit.
  -o OUTPUT, --output OUTPUT
                        Provide a filename to output/append results to a CSV file.
  -j, --json            Output ndjson (either to file or stdout; overrides --output defaults to CSV)
  -P PROXY, --proxy PROXY
                        To use a SOCKS5 proxy, provide address:port.

JARM Manual

The man page is missing.

How JARM Works

Before learning how JARM works, it is important to understand how TLS works. TLS and its predecessor SSL are used to encrypt communications for both regular applications like web browsers to protect your data and for malware to hide in the noise of network traffic.

To initiate a TLS session, the client will send a TLS Client Hello message after the three-way TCP handshake. This packet and how it is generated depends on the packets and methods used to build the client application. The server, if accepting TLS connections, will respond with a TLS Server Hello packet.

TLS servers construct their Server Hello packet based on the data received in the TLS Client Hello packet. The way the Server Hello is formulated for any given Client Hello can vary depending on how the application or server was built, including:

  • Operating system
  • Operating system version
  • Libraries used
  • Versions of those libraries
  • The order in which the libraries were called
  • Custom configuration

All of these factors result in each TLS Server responding in a unique way. The combination of factors makes it unlikely that servers deployed by different organizations will have the same response.

JARM works by generating and actively sending 10 TLS Client Hello packets with different configurations to a target TLS server and capturing certain attributes of the TLS Server Hello responses. The server may respond to packets with different TLS Client Hello settings with different responses. The aggregated TLS server responses are then hashed in a specific way to create a JARM fingerprint.

JARM was created by the same team that developed JA3/S in 2017, a passive client-server TLS fingerprinting method that can now be found in most network security tools. But while JA3/S is passive, meaning it fingerprints clients and servers by sniffing (capturing) network traffic, JARM is an active server fingerprinter.

The 10 TLS Client Hello packets in JARM have been specifically crafted to extract unique responses from TLS servers. JARM sends different TLS versions, ciphers, and extensions in different orders to collect unique responses. Does the server support TLS 1.3? Will it negotiate TLS 1.3 with 1.2 ciphers? If we order the ciphers from weakest to strongest, which cipher will it choose? These are the types of unusual questions that JARM essentially asks the server to extract the most unique responses. The 10 responses are then hashed to produce the JARM fingerprint.

The JARM fingerprint hash is a hybrid fuzzy hash, it uses a combination of a reversible and non-reversible hashing algorithm to create a 62-character fingerprint. The first 30 characters consist of the cipher and TLS version chosen by the server for each of the 10 client hellos sent. "000" means that the server refused to negotiate that client hello. The remaining 32 characters are a truncated SHA256 hash of the cumulative extensions sent by the server (ignoring x509 certificate data). When comparing JARM fingerprints, if the first 30 characters are the same but the last 32 are different, it would indicate that the servers have very similar configurations accepting the same versions and ciphers, although not exactly identical given that the extensions are different.

After receiving each TLS server hello message, JARM gracefully closes the connection with a FIN to avoid leaving sockets open.

It is important to note that JARM is a high-performance fingerprint function and should not be considered or confused with a secure cryptographic function. JARM fingerprints are designed with the goal of being both human-readable and machine-processable. This means that it is small enough to be visually distinguishable from another server's fingerprint, or to be shared in a short message, while still allowing enough room for contextual details.

JARM Usage Example

Scan host w-e-b.site on the default port and print results:

python jarm.py w-e-b.site

Scan IP 185.117.153.79 on the default port and print results:

python jarm.py 185.117.153.79

Scan host hackware.local on port 50443 and print results:

python jarm.py hackware.local -p 50443

Scan host suip.biz and print the collected data used to obtain the hash in addition to the final hash:

python jarm.py suip.biz -v

Scan all targets from the targets.txt file and print results:

python jarm.py -i targets.txt

Example of the contents of the targets.txt file:

hackware.ru
kali.tools
suip.biz
suip.biz,443
157.245.118.66
157.245.118.66,443
w-e-b.site
t.me
google.com
youtube.com
hackware.local,50443

Scan all targets from the file targets.txt and save the results to a file in CSV format (-o results.csv):

python jarm.py -i targets.txt -o results.csv

Example contents of the results.csv file:

cat results.csv
hackware.ru,185.26.122.82,29d29d00029d29d00042d42d0000002059a3b916699461c5923779b77cf06b
kali.tools,185.26.122.59,29d29d00029d29d00042d42d0000002059a3b916699461c5923779b77cf06b
suip.biz,185.117.153.79,29d2ad00029d29d00042d43d00000051af7d8070a18e002eaaedf620fa118c
suip.biz,185.117.153.79,29d2ad00029d29d00042d43d00000051af7d8070a18e002eaaedf620fa118c
157.245.118.66,157.245.118.66,29d2ad00029d29d00042d43d000000ad9bf51cc3f5a1e29eecb81d0c7b06eb
157.245.118.66,157.245.118.66,29d2ad00029d29d00042d43d000000ad9bf51cc3f5a1e29eecb81d0c7b06eb
w-e-b.site,157.245.118.66,29d2ad00029d29d00042d43d00000051af7d8070a18e002eaaedf620fa118c
t.me,149.154.167.99,29d29d15d29d29d00042d42d0000005fd00fabd213a5ac89229012f70afd5c
google.com,142.251.223.78,27d40d40d29d40d1dc42d43d00041d4689ee210389f4f6b4b5b1b93f92252d
youtube.com,172.217.26.78,27d40d40d29d40d1dc42d43d00041d4689ee210389f4f6b4b5b1b93f92252d
hackware.local,127.0.0.1,07d19d1ad21d21d07c42d43d000000112e88add4281e6a02c1102a6e18e86a

Scan all targets from the targets.txt file and save the results to a file (-o results.json) in JSON format (-j):

python jarm.py -i targets.txt -o results.json -j

How to install JARM

Installation on Kali Linux

git clone https://github.com/salesforce/jarm
cd jarm
python jarm.py -h

Installation on BlackArch

git clone https://github.com/salesforce/jarm
cd jarm
python jarm.py -h

Installation on Debian, Linux Mint, Ubuntu

git clone https://github.com/salesforce/jarm
cd jarm
python jarm.py -h

JARM Screenshots

JARM Tutorials

Coming soon…

Related tools

Recommended for you:

Comments are Closed

Рейтинг@Mail.ru