NATO HACKING SECURE COMMUNICATIONS

"PTTID for Unit 1234 is: 
(hexidecimal) 01 80 1234 2E3E 00 6580A862DD8808 
01 is the command opcode 
80 is its argument 
1234 is the unit ID 
2E3E is presumably the CRC (though the "inverted CCITT-CRC" hint seems reasonable, I haven't successfully found the exact algorithm/input data ordering that works)
00 is an unknown field (it is 00 for PTTIDs, 76 for STS and MSG)
and 6580A862DD8808 is the FEC (convolutional code) bits
Now, for the successful hacking of the evening...
To generate the convolutional code bits, perform the following operation:
1. reverse the bit order for each byte of the first 7 bytes (to undo the reversal performed for display, above)
2. feed those bits into a shift register which is preloaded with all zeros
3. for each bit, calculate the modulo-2 sum: bit(n)+bit(n-2)+bit(n-5)+bit(n-6)
4. then for each byte of resulting output, again reverse those bits to generate the values listed above (for display)
Note that because of the constraint length and lack of trailer of this convolutational code, it does not protect (most of) the final "unknown" field. "

Advanced traffic interception for mobile apps using Mallory and Burp

Intercepting non HTTP/S traffic with Mallory

I was testing an application for a client and found that I could intercept the initial login request and response using burp suite, after that the application displayed a spinning wait dial and then closed down. When I removed the proxy the application would function so clearly something was amiss.

The problem with setting your devices to use burp is that it only fully handles HTTP/S and websockets, and it tends to drop traffic which does not fit this criteria. There are likely a number of ways to get around this by redirecting traffic but we also want to play with that non HTTP/S traffic so for this we will use Mallory Proxy.

Mallory is a transparent TCP and UDP proxy and it’s quite a powerful tool! Unfortunately it hasn’t been updated in quite a while and a lot of the documentation is TBC so it can take a while to get to know the ins and outs of it.

The following tutorial is pretty good at getting Mallory set up on a Kali box:
http://blog.opensecurityresearch.com/2012/05/mallory-mitm-fix-ssl-decryption.html

If you have any specific issues a more up to date thread can be found here
https://intrepidusgroup.com/insight/2013/07/getting-mallory-to-run-in-modern-versions-of-ubuntu/

I don’t believe at the time of setup I ran into any issues with the setup script which downloads all the dependencies etc.

When Mallory is running it will listen on a specific port the problem is getting traffic to that port.

I found that setting my Kali vmware to act as a gateway was the best option. I set two bridged interfaces to link onto my testing LAN:

eth0 inet addr:192.168.0.184 Bcast:192.168.168.255 Mask:255.255.255.0
eth1 inet addr:192.168.0.180 Bcast:192.168.168.255 Mask:255.255.255.0

On the device I set the gateway to eth1/192.168.0.180 and then allow traffic to flow between the interfaces using iptables:

iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
iptables –table nat –append POSTROUTING –out-interface eth0 -j MASQUERADE
iptables –append FORWARD –in-interface eth1 -j ACCEPT
echo 1 > /proc/sys/net/ipv4/ip_forward

At this point you can fire up Wireshark and start to profile your application. What you want to do is pick out is the flow of traffic to specific hosts as well as the ports. At this point we start picking through and identifying our application traffic so as to redirect it to our respective proxies. Whilst Mallory is a powerful tool it lacks the flexibility that burp has which is why I separate the traffic streams.

I found that my mobile app was talking MQTT to a Mosquito server on a specific host, it was this MQTT traffic which Burp suite was dropping and thus causing the application to crash. So say we want to direct this traffic to our Mallory proxy we would use:

iptables -t nat -A PREROUTING -p tcp –dport -d -j REDIRECT –to-ports

If there is traffic to a certain host you want to just pass through you can use:

iptables -t nat -A PREROUTING -p tcp -d > -j ACCEPT

We can then tell iptables to route all our other 443 traffic to a burp instance:

iptables -t nat -A PREROUTING -p tcp –dport 443 -j DNAT –to-destination :
iptables -t nat -A POSTROUTING -p tcp –dport 443 -j MASQUERADE

The following will redirect our port 80 traffic to a burp instance:

iptables -t nat -A PREROUTING -p tcp –dport 80 -j DNAT –to-destination :
iptables -t nat -A POSTROUTING -p tcp –dport 80 -j MASQUERADE

Also the order of the IP tables rules is important, you need to have you host specific redirects before you main catch all redirects.

For a sanity check the following rules will redirect https://pentestpatners.com to Mallory and everything else to burp suite. I put my iptables rules in a little bash script so I can easily edit and rerun them.

#!/bin/bash
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
iptables –table nat –append POSTROUTING –out-interface eth0 -j MASQUERADE
iptables –append FORWARD –in-interface eth1 -j ACCEPT
echo 1 > /proc/sys/net/ipv4/ip_forward

#redirect ssl pentestpartners.com to mallory
iptables -t nat -A PREROUTING -p tcp –dport 443 -d 78.129.201.147 -j REDIRECT –to-ports 4443

#redirect HTTP to burp
iptables -t nat -A PREROUTING -p tcp –dport 80 -j DNAT –to-destination 192.168.0.118:8080
iptables -t nat -A POSTROUTING -p tcp –dport 80 -j MASQUERADE

#redirect other SSL to burp
iptables -t nat -A PREROUTING -p tcp –dport 443 -j DNAT –to-destination 192.168.0.118:8080
iptables -t nat -A POSTROUTING -p tcp –dport 443 -j MASQUERADE

The following shows the streams running through Mallory

At this point hopefully you have successfully routed you troublesome traffic to Mallory and your standard HTTP/S to burp and your application should be running without any crashes. Mallory has some tampering features like burp which we will look at in the following section.

Using Mallory

Mallory can be quite troublesome to get working, as we have setup our own iptables rules do not toggle any of the options on the “Interfaces” tab. The protocols tab is pretty self-explanatory, you may need to define a new port if your traffic is non-standard but the help section is a little more complete there.

The streams tab will show the flow of traffic as well as the contents of each request, you need to enable “Intercept” and “Auto Send” on this page, if you disable auto send you have the option of editing requests before they go to the server and then manually send them.

The documentation for the rules tab is a little lighter:

The data will be affected by the rules sequentially top to bottom and the rule we are likely to use the most is the “Muck” rule.

These rules are configured as follows:

• Name: Name of the rule
• Direction: Do we want to replace server to client, client to server or both
• Address: Do we want to only target one address
• Port: Do we want to target one port
• Payload: A string to patch in the requests/response before the rule will run
• Muck: This is a regex like in the sed command FIND/REPLACE/GLOBALLY
• Passthu: Does the packet then go to the next rule?

Mallory won’t decode gziped responses so it’s best to remove the accept Encoding-Header from requests using the following rule:

Make sure the rule is at the top of the list.

For a test we can use the following rule:

With the results:

For SSL traffic you can replace the ca.cer and ca.key in /mallory/current/src/ca/ with your exported burp files or you can import the ca.cer which Mallory generates onto your device.

The downside of mallory is that there is no way to export the streams into a meaningful format which can dissect the data, such as wireshark.
…unless you write a script to do it.
To save you the time and effort I have written one called mallory2pcap.py. There’ll be a separate post on that but there is a link to the code here. When given the mallory SQLite database and an output name it will write a pcap file on the fly using the contents of the database:

When this file is opened wireshark will dissect the requests and hopefully display the correct data:

I do have to say several bottles of strong cider were consumed when this script was coded so there may be bugs and it’s mainly held together with tape but it should work!!

Hopefully this how-to has provided an insight into intercepting mobile application traffic and using some less known tools and tricks.

https://www.pentestpartners.com/security-blog/advanced-traffic-interception-for-mobile-apps-using-mallory-and-burp/

Termius - SSH, Mosh and Telnet client App

Free Features:
· SSH client with support of ECDSA, ed25519, and chacha20-poly1305
· Desktop app for Windows, Mac, and Linux
· Mosh & Telnet protocol support
· Local terminal with bash
· Built-in RSA/DSA/ECDSA key generator and Putty keys importer
· XTerm-256 colors, VT100 and vanilla terminal types support
· Local, Remote, and Dynamic port forwarding
· Automatic icon recognition, e.g., Raspberry Pi, Ubuntu, Fedora
· Hardware keyboard support
· Password, key, and 2FA authentication
· 11 awesome color schemes
· Terminal Touch with the support of arrow keys, Ctrl and Alt.
· Organize hosts into groups to share settings among them
· No ads or banners

Premium Features, $9,99 annually. 
· Cross-device sync *
· SSH key agent forwarding
· SFTP client
· Terminal tabs
· HTTP/SOCKS proxy
· CLI tool to export ~/.ssh/config 
· Fingerprint protection
· Home Screen Widget 
· AWS EC2 and Digital Ocean host import
· Host chaining
· Save and run snippets
· Env variables 

* Using zero-knowledge cloud storage with 2FA protection. All the data encrypted on the client-side using AES-256.

https://play.google.com/store/apps/details?id=com.server.auditor.ssh.client&hl=pt_PT

MDC-1200 Signaling Decoder With ANDROID [DEMO]

CTCSS DCS Tone Decoder And Frequency Counter

Nacre Quietpro Single Tactical Headset System, Motorola XTS, HT1000, MTS...

Funtenna Demo Data Exfiltration Using Malware Induced Compromising Emana...

The Illegal $5 WiFi Jammer for iPhone & Android

Wifi Jammer App

Mobile WiFi Jamming (Disrupting WiFi Networks with Mobile Devices) Tom Nardi | 01.09.15 Categories: Blog

Mobile WiFi Jamming (Disrupting WiFi Networks with Mobile Devices)

At this point, everyone should be pretty familiar with the “rogue AP” concept: an attacker creates an innocent enough looking WiFi access point, hopes people connect to it, and then does nasty things when they do. It’s simple to setup, hard for the average user to detect, and increasingly common.

But putting up an access point is only half the battle. How do you get victims to actually connect to an rogue AP once it’s setup? An attacker can give it a tempting name, and if it’s the only open AP in an area with nothing but encrypted networks it may have a shot, but more often than not the client machines are going to connect to whatever their appropriate network is and ignore any other APs that may have popped up. So the question is, how could one nudge an unsuspecting user off of their own WiFi network and onto another one?

One way is to simply blast the rival networks off the air.

Air Superiority

To be very clear, calling this technique jamming is inaccurate, but that hasn’t stopped a number of developers from using the term, so we’ll just play along for the sake of consistency. To properly jam WiFi (or any other form of radio communication), you basically blast out a lot of random noises on the frequencies that particular technology uses. It’s conceptually very simple, but also a very big infraction as far as our friends at the Federal Communications Commission are concerned; so it isn’t something you won’t be doing with any consumer-level WiFi hardware.

Since jamming on the hardware level is out of the question, a number of developers have found a way to clog up WiFi communications in software. This is much more akin to a denial of service attack, where tools are used to repeatedly spam deauthentication packets at WiFi access points and clients to force them to disconnect. With the appropriate software and a powerful WiFi adapter that supports packet injection, an attacker can put a stranglehold on legitimate communications.

There are a couple of ways it can be done, but for this example we will look at wifijammer by Dan McInerney.

Installing Wifijammer

This tool takes the form of a single Python script, wifijammer.py, that you can grab right from GitHub. Installing it on your device is as simple as opening the terminal and running:

git clone https://github.com/DanMcInerney/wifijammer.git

Once you’ve cloned the Git repository and entered the newly created directory, you should be able to run it right away. Unfortunately, when you try and run it you’ll probably get an error about not being able to find “./dvips”.

A little digging around shows this is actually a bug in the python-pyx package that’s been floating around since at least 2012. You can get around this by simply removing the python-pyx package with “apt”, but that will also remove wifitap, which you may not want to do.

In the end, as silly as it sounds, the easiest workaround for this bug is to simply create an empty directory named “dvips” so it finds what it’s expecting:

mkdir ./dvips

After creating the directory (or removing python-pyx), you just need to plug in your external WiFi adapter and you’re set.

Note: In testing, it has been found that unplugging the external WiFi adapter after running wifijammer has a tendency to lock up the device. It’s suggested that you shutdown the device before disconnecting the external adapter to prevent data loss.

Radius Jamming

If ran with no options, wifijammer will select the strongest WiFi interface on your device that supports packet injection (your external WiFi adapter) and puts it into monitor mode. It will spend a few seconds on each WiFi channel collecting data, and then once it has a list of clients and APs, it starts rapidly going through them and firing out deauthentications.

The top of the screen will show the devices that have been deauthenticated, while the bottom of the screen will continually scroll devices that wifijammer has detected.

With a powerful external WiFi adapter, a setup like this will destabilize the WiFi networks within a fairly large radius, say a few hundred feet.

But it’s a completely non-discriminatory attack, it will try to knock out every WiFi network it sees. It may however be advantageous to try and jam one specific access point, or perhaps even just one client device. In other cases the broad radius attack may fail, and a more direct approach is required. For those situations, wifijammer has a number of options to tailor the attack to the situation at hand.

Targeted Jamming

The advanced parameters for wifijammer let you specify things like the target’s MAC address and channel, as well as some under the hood options like how many packets to send and how long to wait between deauthentications.

A good starting point for experimentation is something like the following:

wifijammer -c -a -p 5 -d

Aside from the obvious channel and target variables, the -p option tells wifijammer to send 5 deauthentication packets at a time, and the -d option disables sending deauthentication packets to broadcast addresses (this speeds up the attack, and many devices ignore them anyway).

Practical Use

In practice, tools like wifijammer can be used to disable some or all of the WiFi networks in the target area, which can lead unsuspecting users to an rogue AP under an attacker’s control. It’s important to realize that attacks like this cannot literally force a target to switch networks (they would still need to select the rogue AP in their device’s network settings), but it may give them the impetus to check for additional networks where they otherwise wouldn’t have.

When deployed from a mobile device like the Pwn Pad or Pwn Phone, WiFi jamming attacks can be especially effective, as the source of the transmission can be brought in extremely close to the targets (such as in a coffee shop, office, or other public place) without arousing suspicion.

https://www.pwnieexpress.com/blog/mobile-wifi-jamming

RSA Key Extraction via Low-Bandwidth Acoustic Cryptanalysis

Abstract

Many computers emit a high-pitched noise during operation, due to vibration in some of their electronic components. These acoustic emanations are more than a nuisance: they can convey information about the software running on the computer, and in particular leak sensitive information about security-related computations. In a preliminary presentation (Eurocrypt'04 rump session), we have shown that different RSA keys induce different sound patterns, but it was not clear how to extract individual key bits. The main problem was that the acoustic side channel has a very low bandwidth (under 20 kHz using common microphones, and a few hundred kHz using ultrasound microphones), many orders of magnitude below the GHz-scale clock rates of the attacked computers.

In this paper we describe a new acoustic cryptanalysis key extraction attack, applicable to GnuPG's current implementation of RSA. The attack can extract full 4096-bit RSA decryption keys from laptop computers (of various models), within an hour, using the sound generated by the computer during the decryption of some chosen ciphertexts. We experimentally demonstrate that such attacks can be carried out, using either a plain mobile phone placed next to the computer, or a more sensitive microphone placed 4 meters away.

Beyond acoustics, we demonstrate that a similar low-bandwidth attack can be performed by measuring the electric potential of a computer chassis. A suitably-equipped attacker need merely touch the target computer with his bare hand, or get the required leakage information from the ground wires at the remote end of VGA, USB or Ethernet cables.

---

1 Introduction

1.1 Overview

Cryptanalytic side-channel attacks target implementations of cryptographic algorithms which, while perhaps secure at the mathematical level, inadvertently leak secret information through indirect channels: variations in power consumption, electromagnetic emanations, timing variations, contention for CPU resources such as caches, and so forth (see [And08] for a survey). Acoustic emanations, i.e., the noise generated by computers, are one such potential channel. Eavesdropping on keyboards and printers has been well-demonstrated [AA04, ZZT05, BDG+10]. Mechanical noise from fans and storage devices such as hard disks are obviously indicative of system activity, but seem to carry very coarse information that is apparently of little use for cryptanalysis.

We focus on a different source of computer noise: vibration of electronic components in the computer, sometimes heard as a faint high-pitched tone or hiss (commonly called "coil whine", though often generated by capacitors). These acoustic emanations, typically caused by voltage regulation circuits, are correlated with system activity since CPUs drastically change their power draw according to the type of operations they perform. However, the bandwidth of these signals is very low: up to 20 kHz for audible signals and commodity microphones, and up to a few hundred kHz using ultrasound microphones. (Beyond these frequencies, air attenuation and reduced microphone sensitivity render the signals undetectable.) |1| Cryptanalytic side-channel attacks typically require measurements with temporal resolution similar to the time scale of the target operation, but here the target cryptographic computation is many orders of magnitude faster (at the GHz scale), so we have no hope of observing individual operations. Moreover, the acoustic signals of interest are very faint. Indeed, a recent survey on side channels surmised that while "acoustic effects have been suggested as possible side channels |2|, the quality of the resulting measurements is likely to be low" [KJJR11].

Acoustic cryptanalysis. We show that, despite these difficulties, full key recovery via acoustic cryptanalysis is quite feasible on common software and hardware. As a study case, we focus on the GnuPG (GNU Privacy Guard) [Gnu], a popular, cross-platform, open-source implementation of the OpenPGP standard [CDF+07]. We observe that GnuPG's RSA signing (or decryption) operations are readily identified by their acoustic frequency spectrum. Moreover, the spectrum is often key-dependent, so that secret keys can be distinguished by the sound made when they are used. The same applies to ElGamal decryption. We devise and demonstrate a key extraction attack that can reveal 4096-bit RSA secret keys when used by GnuPG running on a laptop computer, within an hour, by analyzing the sound generated by the computer during decryption of chosen ciphertexts. We demonstrate the attack on various targets and by various methods, including the internal microphone of a plain mobile phone placed next to the computer, and using a sensitive microphone from a distance of 4 meters.

In a nutshell, the key extraction attack relies on crafting chosen ciphertexts that cause numerical cancellations deep inside GnuPG's modular exponentiation algorithm. This causes the special value zero to appear frequently in the innermost loop of the algorithm, where it affects control flow. A single iteration of that loop is much too fast for direct acoustic observation, but the effect is repeated and amplified over many thousands of iterations, resulting in a gross leakage effect that is discernible in the acoustic spectrum over hundreds of milliseconds.

Low-bandwidth power and voltage analysis. With this technique for inducing robust low-bandwidth signals, we revisit other channels and observe that similar leakage can often be induced, acquired, and exploited. For example, in many computers the "ground" potential fluctuates (even when connected to a grounded power supply) and leaks the requisite signal; this can be measured by touching exposed metal on the computer's chassis, or at the remote end of VGA, USB and Ethernet cables. We can also acquire and exploit these low-frequency signals by power analysis, using measurement of the power supply current, even if the clockrate-scale high frequencies (needed for standard power analysis) have been filtered out.

Chosen-ciphertext channel by e-mail. The key extraction attack requires decryption of ciphertexts adaptively chosen by the attacker. Prior works requiring chosen plaintext or ciphertext typically attacked network protocols such as SSL/TLS [BB05] or WEP [BGW01, BHL06], or used direct access to a protected device's input. To apply the attack to GnuPG, we identified and exploited a new chosen-ciphertext attack vector: OpenPGP encrypted e-mail messages. We specifically targeted Enigmail, a popular plugin to the Thunderbird e-mail client that enables transparent signing and encryption of email messages using GnuPG, following the OpenPGP [CDF+07] and PGP/MIME [ETLR01] standards. Enigmail automatically decrypts incoming e-mail (for notification purposes), as long as the GnuPG passphrase is cached or empty. In this case, an attacker can e-mail suitably-crafted messages to the victims, wait until they reach the target computer, and observe the acoustic signature of their decryption, thereby closing the adaptive attack loop.

http://www.derechos.org/nizkor/espana/doc/acoustic.html

SMB Relay Attack

SMBRelay and LLMNR Zero to Breach in Ten Minutes

Introduction to Fuzzing Web Applications with Burp-Suite Intruder Tool

HACKING NATO SERVERS Connecting to a RDS Server from a Local Computer Using SSH Tunneling on a Mac

Connecting to a RDS Server from a Local Computer Using SSH Tunneling on a Mac

Solution

If you scour the internet there appear to two main solutions.

1. Add your IP address to a whitelist on rds, but could be problematic since your IP address will probably change.
2. Connect to the RDS instance using SSH tunneling.

I had not set up SSH tunneling before and for some reason had a hard time tracking it down. I use sequl pro to inspect our database sometimes, and I realize I was able to connect using SSH tunneling via their gui interface.

So, what is the solution?

There are two steps:

1. Set up the SSH Tunnel

ssh -N -L 3306:your.rds.endpoint.rds.amazonaws.com:3306 sshuser@yourserver.com

 -N   
only set up the tunnel

 -L   
set up the forwarding

 3306
that first number is the port on your local machine

your.rds.endpoint.amazonaws.com
The name of the rds endpoing

3306
the port on the remote computer

sshuser@yourserver.com
how you log in to your ec2 instance

2. Use the SSH Tunnel

mysql -u dbuser -p -h 127.0.0.1

This lets you connect to the remote rds instance. Note that you have to use the host here 127.0.0.1 explicitly and that it is not the host you set up earlier. This is because it is now forwarding all of the requests. That’s all.

To be clear on how the ports work, here is another example

ssh -N -L 1234:your.rds.endpoint.rds.amazonaws.com:3306 sshuser@yourserver.com

mysql -u dbuser -p -h 127.0.0.1 -P 1234

This says forward from port 1234 on my computer to port 3306 on the remote instance. I just used 3306 in both as the defaults.

http://thekeesh.com/2014/01/connecting-to-a-rds-server-from-a-local-computer-using-ssh-tunneling-on-a-mac/