Kali Linux Tutorials
Live-Forensicator : Powershell Script To Aid Incidence Response And Live Forensics

Live Forensicator is part of the Black Widow Toolbox, its aim is to assist Forensic Investigators and Incidence responders in carrying out a quick live forensic investigation.

It achieves this by gathering different system information for further review for anomalous behaviour or unexpected data entry, it also looks out for unusual files or activities and points it out to the investigator.

It is paramount to note that this script has no inbuilt intelligence its left for the investigator to analyse the output and decide on a conclusion or decide on carrying out more deeper investigation. Optional DependenciesThis script is written in powershell for use on windows PCs and Servers.

For additional features it depends on external binaries.

It has a supporting file WINPMEM for taking RAM dumps https://github.com/Velocidex/WinPmem

It also depends on Nirsoft’s BrowserHistoryView for exporting browser history http://www.nirsoft.net/utils/browsing_history_view.html

This script is expected to work out of the box.

winpmem_mini_x64_rc2.exe | BrowsingHistoryView64.exe | BrowsingHistoryView86.exe | etl2pcapng64.exe | etl2pcapng86.exe Usagecopy the files to the computer
git clone https://github.com/Johnng007/Live-Forensicator.git
Execution
.\Forensicator.ps1 ExamplesBasic
.\Forensicator.ps1
Check your Version
.\Forensicator.ps1 -Version
Check for Updates
.\Forensicator.ps1 -Update
Decrypt An Encrypted Artifact
.\Forensicator.ps1 -DECRYPT DECRYPT
Extract Event Logs alongside Basic Usage
.\Forensicator.ps1 -EVTX EVTX
Grab weblogs IIS & Apache
.\Forensicator.ps1 -WEBLOGS WEBLOGS
Run Network Tracing & Capture PCAPNG for 120 secounds
.\Forensicator.ps1 -PCAP PCAP
Extract RAM Dump alongside Basic Usage
.\Forensicator.ps1 -RAM RAM
Check for log4j with the JNDILookup.class
.\Forensicator.ps1 -log4j log4j
Encrypt Artifact after collecting it
.\Forensicator.ps1 -ENCRYPTED ENCRYPTED
Yes of course you can do all
.\Forensicator.ps1 -EVTX EVTX -RAM RAM -log4j log4j -PCAP PCAP -WEBLOGS WEBLOGS
For Unattended Mode on Basic Usage
.\Forensicator.ps1 -OPERATOR “Ebuka John” -CASE 01123 -TITLE “Ransomeware Infected Laptop” -LOCATION Nigeria -DEVICE AZUZ
You can use unattended mode for each of the other parameters
.\Forensicator.ps1 -OPERATOR “Ebuka John” -CASE 01123 -TITLE “Ransomeware Infected Laptop” -LOCATION Nigeria -DEVICE AZUZ -EVTX EVTX -RAM RAM -log4j log4j
Check for files that has similar extensions with ransomeware encrypted files (can take some time to complete)
.\Forensicator.ps1 -RANSOMEWARE RANSOMEWARE
You can compress the Forensicator output immidiately after execution Oneliner
.\Forensicator.ps1 ; Start-Sleep -s 15 ; Compress-Archive -Path “$env:computername” -DestinationPath “C:\inetpub\wwwroot\$env:computername.zip” -Force NotesRun the script as an administrator to get value.
The results are outputed in nice looking html files with an index file.
You can find all extracted Artifacts in the script’s working directory.

Forensicator Has the ability to Search through all the folders within a system looking for files with similar extensions as well known Ransomewares, Albeit this search takes long but its helpful if the Alert you recieved is related to a Ransomeware attack, Use the -RANSOMEWARE Parameter to invoke this.

Forensictor now hs the ability to capture network traffic using netsh trace, this is useful when your investigation has to do with asset communicating with known malicious IPs, this way you can parse the pcapng file to wireshark and examine for C&C servers. By Defult i set the capture to take 120secs

Sometimes it may be paramount to maintain the integrity of the Artifacts, where lawyers may argue that it might have been compromised on transit to your lab. Forensicator can now encrypt the Artifact with a unique randome[...]

___________________________
@hacking_Attack
@Hacking_Video

Kali Linux Tutorials
FormatFuzzer : A Framework For High-Efficiency, High-Quality Generation And Parsing Of Binary Inputs

FormatFuzzer is a framework for high-efficiency, high-quality generation and parsing of binary inputs. It takes a binary template that describes the format of a binary input and generates an executable that produces and parses the given binary format. From a binary template for GIF, for instance, FormatFuzzerproduces a GIF generator – also known as GIF fuzzer.

Generators produced by FormatFuzzerare highly efficient, producing thousands of valid test inputs per second – in sharp contrast to mutation-based fuzzers, where the large majority of inputs is invalid. Inputs generated by FormatFuzzerare independent from the program under test (or actually, any program), so you can also use them in black-box settings. However, FormatFuzzeralso integrates with AFL++ to produce valid inputs that also aim for maximum coverage. In our experiments, this “best of two worlds” approach surpasses all other settings; see our paper for details.

The binary templates used by FormatFuzzer come from the 010 editor. There are more than 170 binary templates, which either can be used directly for FormatFuzzeror adapted for its use. Out of the box, FormatFuzzerproduces formats such as AVI, BMP, GIF, JPG, MIDI, MP3, MP4, PCAP, PNG, WAV, and ZIP; and we keep on extending this list every week.

Contributors are welcome! Visit the FormatFuzzer project page for filing ideas and issues, or adding pull requests. For details on how FormatFuzzerworks and how it compares, read our paper for more info. Getting

FormatFuzzer is available from the FormatFuzzer project page. You can download and unpack the latest release from the releases page.

For the very latest and greatest, you can also clone its git repository:

git clone https://github.com/uds-se/FormatFuzzer.git

All further actions take place in its main folder:

cd FormatFuzzer

Prerequisites

To run FormatFuzzer, you need the following:

* Python 3
* A C++ compiler with GNU libraries (notably getopt_long()) such as clangor gcc* The Python packages py010parser, six, and intervaltree* A zliblibrary (for compression functions)
* A boostlibrary (for checksum functions)

If you plan to edit the build and configuration scripts (.ac and .amfiles), you will also need

* GNU autoconf
* GNU automake Installing Requirements on Linux (Debian Packages)

sudo apt install git g++ make automake python3-pip zlib1g-dev libboost1.71-dev
pip3 install py010parser six intervaltree

Installing Requirements on MacOS (with Xcode & Homebrew)

xcode-select –install
brew install python3 automake boost
pip3 install py010parser six intervaltree

Installing Python Packages Only (All Operating Systems)

On all systems, using pip:

pip install py010parser
pip install six
pip install intervaltree

Building

Note: all building commands require you to be in the same folder as this READMEfile. Building a fuzzer outside of this folder is not yet supported. Method 1: Using the build.sh script

There’s a build.shscript which automates all construction steps. Simply run

./build.sh gif

to create a GIF fuzzer.

This works for all file formats provided in templates/; if there is a file templates/FOO.bt, then ./build.sh FOOwill build a fuzzer. Method 2: Using Make

There’s a Makefile(source in Makefile.am) which automates all construction steps. (Requires GNU make.) First do

touch configure Makefile.in

then

./configure

and then

make gif-fuzzer

to create a GIF fuzzer.

This works for all file formats[...]

___________________________
@hacking_Attack
@Hacking_Video

yAnti-replay, encryptionhttps://s.w.org/images/core/emoji/13.1.0/72x72/274c.png https://s.w.org/images/core/emoji/13.1.0/72x72/2705.png IPv6https://s.w.org/images/core/emoji/13.1.0/72x72/2705.png https://s.w.org/images/core/emoji/13.1.0/72x72/2705.png Download

___________________________
@hacking_Attack
@Hacking_Video

ly generated key using AES algorithm, you can specify this by using the -ENCRYPTED parameter. You can decrypt it at will anywhere anytime even with another copy of Forensicator, just keep your key safe. This task is performed by the FileCryptography.psm1 file What Forensicator GrabsUSER AND ACCOUNT INFORMATION
1. GETS CURRENT USER.
2. SYSTEM DETAILS.
3. USER ACCOUNTS
4. LOGON SESSIONS
5. USER PROFILES
6. ADMINISTRATOR ACCOUNTS
7. LOCAL GROUPS
SYSTEM INFORMATION
1. INSTALLED PROGRAMS.
2. INSTALLED PROGRAMS FROM REGISTERY.
3. ENVIRONMENT VARIABLES
4. SYSTEM INFORMATION
5. OPERATING SYSTEM INFORMATION
6. HOTFIXES
8. WINDOWS DEFENDER STATUS AND DETAILS
NETWORK INFORMATION
1. NETWORK ADAPTER INFORMATION.
2. CURRENT IP CONFIGURATION IPV6 IPV4.
3. CURRENT CONNECTION PROFILES.
4. ASSOCIATED WIFI NETWORKS AND PASSWORDS.
5. ARP CACHES
6. CURRENT TCP CONNECTIONS AND ASSOCIATED PROCESSES
7. DNS CACHE
8. CURRENT FIREWALL RULES
9. ACTIVE SMB SESSIONS (IF ITS A SERVER)
10. ACTIVE SMB SHARES
11. IP ROUTES TO NON LOCAL DESTINATIONS
12. NETWORK ADAPTERS WITH IP ROUTES TO NON LOCAL DESTINATIONS
13. IP ROUTES WITH INFINITE VALID LIFETIME
PROCESSES | SCHEDULED TASK | REGISTRY
1. PROCESSES.
2. STARTUP PROGRAMS
3. SCHEDULED TASK
4. SCHEDULED TASKS AND STATE
5. SERVICES
6. PERSISTANCE IN REGISTRY
OTHER CHECKS
1. LOGICAL DRIVES
2. CONNECTED AND DISCONNECTED WEBCAMS
3. USB DEVICES
4. UPNP DEVICES
5. ALL PREVIOUSLY CONNECTED DRIVES
6. ALL FILES CREATED IN THE LAST 180 DAYS
7. 100 DAYS WORTH OF POWERSHELL HISTORY
8. EXECUTABLES IN DOWNLOADS FOLDER
9. EXECUTABLES IN APPDATA
10. EXECUATBLES IN TEMP
11. EXECUTABLES IN PERFLOGS
12. EXECUTABLES IN THE DOCUMENTS FOLDER
ORTHER REPORTS IN THE HTML INDEX FILE
1. GROUP POLICY REPORT
2. WINPMEM RAM CAPTURE
3. LOG4J
4. IIS LOGS
5. TOMCAT LOGS
6. BROWSING HISTORY OF ALL USERS
7. CHECK FOR FILES THAT HAS SIMILAR EXTENSIONS WITH KNOWN RANSOMEWARE ENCRYPTED FILES
NOTE: THIS CHECK CAN TAKE SOME TIME TO COMPLETE DEPENDING ON THE NUMBER OF DRIVES AND AMOUNT OF FILES.
8. RUNS NETWORK TRACING USING NETSH TRACE & CONVERTS TO PCAPNG FOR FURTHER ANALYSIS Download

___________________________
@hacking_Attack
@Hacking_Video

Kali Linux Tutorials
Covert-Control : Google Drive, OneDrive And Youtube As Covert-Channels – Control Systems Remotely By Uploading Files To Google Drive, OneDrive, Youtube Or Telegram

Covert-Control systems remotely by uploading files to Google Drive, OneDrive, Youtube or Telegram using Python to create the files and the listeners. It allows to create text files, images, audio or videos, with the commands in cleartext or encrypted using AES.

* covert-googledrive.py – Control systems uploading files to a public folder in Google Drive.
* covert-onedrive.py – Control systems uploading files to a public folder in OneDrive.
* covert-youtube.py – Control systems uploading videos to Youtube (updated from covert-tube).
* covert-telegram.py – Control systems with a Telegram bot. Create Files To Upload

You can find example files in the folder test_files or create new ones with generate_file.py:

python3 generate_file.py -t TYPE [-o OUTPUTFILE] [-c COMMAND] [-e]

* -t (–type) [Required]: Types of file: “text”, “image”, “audio” or “video”.
* -o (–outputfile) [Optional]: Output file.
* -c (–command) [Optional]: Command to execute.
* -e (–encrypted) [Optional]: Add this flag to encrypt the command with AES.

Examples:

python3 generate_file.py -t text -c “whoami” -o text.txt
python3 generate_file.py -t text -c “whoami” -o text_encrypted.txt -e
python3 generate_file.py -t audio -c “whoami” -o audio.wav
python3 generate_file.py -t audio -c “whoami” -o audio_encrypted.wav -e
python3 generate_file.py -t image -c “whoami” -o image.png
python3 generate_file.py -t image -c “whoami” -o image_encrypted.png -e
python3 generate_file.py -t video -c “whoami” -o video.avi
python3 generate_file.py -t video -c “whoami” -o video_encrypted.avi -e

Configuration

Common configuration values:

* data_type (Optional. Default: “text”):data_typeFile typeEncryptedValid forExtensiontextText fileNoGoogle Drive, OneDrive.txttext_encryptedText fileYesGoogle Drive, OneDrive.txtimageImageNoGoogle Drive, OneDrive.pngimage_encryptedImageYesGoogle Drive, OneDrive.pngaudioAudioNoGoogle Drive, OneDrive.wavaudio_encryptedAudioYesGoogle Drive, OneDrive.wavvideoVideoNoGoogle Drive, OneDrive, Youtube.avivideo_encryptedVideoYesGoogle Drive, OneDrive, Youtube.avi
* delay_seconds (Optional. Default: 300): Seconds between checks of new files uploaded to the Google Drive or OneDrive folder or new videos in the Youtube channel.
* aes_key (Optional. Default: “covert-control21”): Key for AES encryption.
* debug (Optional. Default: True): Print messages and timestamps in the listener or not.

Specific configuration values:

* googledrive_folder: Url of public Google Drive folder to monitor (for covert-googledrive.py).
* onedrive_folder: Url of public OneDrive folder to monitor (for covert-onedrive.py).
* youtube_channel_id: Youtube channel ID of the channel to monitor. You can get it from here (for covert-youtube.py).
* youtube_api_key: Get an API key creating an application and generating the key in here (for covert-youtube.py).
* telegram_token: Bot token, create it using BotFather. Write “/newbot”, then send a name for the bot (for example, “botname”) and a username for the bot ending in “-bot” (for example, “somethingrandombot”) (for covert-telegram.py).
* telegram_username: Specify a Telegram username so it only executes commands received from this user (without “@”). Google Drive

It allows to execute commands uploading text files, images, audio and videos, unencrypted or encrypted with AES. The optional input argument is the public folder url, which can be also configured in config.py:

python3 covert-googledrive.py [FOLDER_URL]

The listener will check the Google Drive folder every 300 seconds by default (can be updated in config.py). In this case a video, “video.avi”, is uploaded with the command in the QR of the video:
https://blogger.googleusercontent.com/img/a/AVvXsEiQ0Xy9TjU938xPAZF_0oVr2j4Z00_HTeKkBr[...]

___________________________
@hacking_Attack
@Hacking_Video

provided in templates/; if there is a file templates/FOO.bt, then make FOO-fuzzerwill build a fuzzer. Method 3: Manual steps

If the above makemethod does not work, or if you want more control, you may have to proceed manually. Step 1: Compiling Binary Template Files into C++ code

Run the ffcompilecompiler to compile the binary template into C++ code. It takes two arguments: the .btbinary template, and a .cppC++ file to be generated.

./ffcompile templates/gif.bt gif.cpp

Step 2: Compiling the C++ code

Use the following commands to create a fuzzer gif-fuzzer. First, compile the generic command-line driver:

g++ -c -I . -std=c++17 -g -O3 -Wall fuzzer.cpp

(-I . denotes the location of the bt.hfile; -std=c++17sets the C++ standard.)

Then, compile the binary parser/compiler:

g++ -c -I . -std=c++17 -g -O3 -Wall gif.cpp

Finally, link the binary parser/compiler with the command-line driver to obtain an executable. If you use any extra libraries (such as -lz), be sure to specify these here too.

g++ -O3 gif.o fuzzer.o -o gif-fuzzer -lz

Running the Fuzzer

FormatFuzzer can be run as a standalone parser, generator or mutator of specific formats. In addition, it can called by general-purpose fuzzers such as AFL++ to integrate those format-specific capabilities into the fuzzing process (see the section below on AFL++ integration).

The generated fuzzer takes a command as first argument, followed by options and arguments to that command.

The most important command is fuzz, for producing outputs. Its arguments are files to be generated in the appropriate format.

Run the generator as

./gif-fuzzer fuzz output.gif

to create a random binary file output.gif, or

./gif-fuzzer fuzz out1.gif out2.gif out3.gif

to create three GIF files out1.gif, out2.gif, and out3.gif.

Note that the gif.bttemplate we provide has been augmented with special functions to make generation of valid files easier. If you use an original .bttemplate files without adaptations, you may get warnings during generation and create invalid files. Running Parsers

You can also run the fuzzer as a parser for binary files, using the parsecommand. This is useful if you want to test the accuracy of the binary template, or if you want to mutate an input (see `Decision Files’, below).

To run the parser, use

./gif-fuzzer parse input.gif

You will see error messages if input.gifcannot be successfully parsed.

Decision Files

While parsing, you can also store all parsing decisions (i.e. which parsing alternatives were taken) in a decision file. This is a sequence of bytes enumerating the decisions taken. Each byte stands for a single parsing decision. A byte value of 0means that the first alternative was taken, a byte value of 1means that the second alternative was taken, and so on.

You can generate such a decision file when parsing an input:

./gif-fuzzer parse –decisions input.dec input.gif

Here, input.decstores the decisions made for parsing `input.gif’.

You can also use such a decision file when generating inputs. The fuzzer will then take the exact same decisions as found during parsing. The following command generates a new GIF file using the decisions determined while parsing `input.gif’:

./gif-fuzzer fuzz –decisions input.dec input2.gif

If everything works well, both files should be identical:

cmp input.gif input2.gif

By mutating a decision file (e.g. replacing individual bytes), you can create inputs that are similar to the original file parsed. This is useful for interfacing with specific testing strategies and fuzzers such as AFL, where you can use gif-fuzzerand the like as translators from decision files to binary fil[...]

___________________________
@hacking_Attack
@Hacking_Video

6v1JBNHF7ZDeKXgeJWeSsGqDFomNal3Avs_ZkElM6OSuGYkDGSxpF7MRGTwIEWhs2PvYKG8u4IY64BLmNVJbmqg126yR00dj2PyBYF7NlYwCreHd5GG8ZSIc7Lc0NHXlTI2k_ADNI8azm7R-uQIre8=s376
After finding there is a new file uploaded to the folder, it is downloaded, processed and the commands are executed:
https://blogger.googleusercontent.com/img/a/AVvXsEhsOuOHIKhkahz-AJ5a6F8uvfW2baUemeOgtonRJc1v5c_NEe4z4aZBxnwW6crKIXRtzIHR69tKyRfB86rTzlsmo9xq_cu1xhNZlzaYGFc5caGIGC8YNsMp8ahO6EH1nfJNrRjtFfabGzl5kVArSvEQjJawiDDfvIB_9Fq0dbH6pc9EpRCpkkk8OJ44=s567
Onedrive

It allows to execute commands uploading text files, images, audio and videos, unencrypted or encrypted with AES. The optional input argument is the public folder url, which can be also configured in config.py:

python3 covert-onedrive.py [FOLDER_URL]

The listener will check the OneDrive folder every 300 seconds by default (this can be updated in config.py). In this case an audio, “audio_encrypted.wav”, is uploaded with the command encrypted with AES:
https://blogger.googleusercontent.com/img/a/AVvXsEgKKyiPs1qyXjJ9F6eiuflhcdBoLMvdCVv9EbYl-0sl8AGGfTwYNBUKHswlMb0nMu-0HcgcQj_0_oXQ3mWogRwjfJs9e4pjddn_iwcQZJwAFDAC10JltaCDfar3Jj8ID6wuPU0_HFotbJh2F4po37r9JW7-G-Uk6q1lqYYWm7JK2j77dpVO8UnLs47O=s230
After finding there is a new file uploaded to the folder, it is downloaded, processed and the commands are executed:
https://blogger.googleusercontent.com/img/a/AVvXsEiFWipP0330C1-vfJAbjmIuUyGCeQA-SuPh1TLTpFrvMss2fKvJ-PBcxmzPrVr1UjKsu3LYCA5I6WreBSjnQNY5ZxjeV5fSjZLnQezc98PN5B9UHsuewtVLmjW3Iz56BNl-zpwAX1TE9xeQapnMCmUoqePR2XOduNMOaNHgABJsNwRNJ6B-TJzJeRs5=s605
NOTE: This will only work if you do not delete any file in the folder, if you do it you must create a new one. It could be possible to implement it to work even after deleting files, but it would be necessary to create many requests and would be less stealthy. Youtube

It allows to execute commands uploading videos, unencrypted or encrypted with AES. The optional input arguments are the Youtube channel ID to monitor and the API key, which can be also configured in config.py:

python3 covert-youtube.py [CHANNEL_ID] [API_KEY]

The listener will check the Youtube channel every 300 seconds by default (this can be updated in config.py). First the video is uploaded:
https://blogger.googleusercontent.com/img/a/AVvXsEgVTIoZe4SSgWs-qxCQsipdPVG2QywLg-E9Jq-73XJQQjCKQq3c_64Tga8EhH-95rb02-UfCmNKgSRJBfL9Wo8zLpb_LrtvTijnikOT4EcXJnIs66wsP8A6P5V9D1bLhffYPKjk2bPt_eA_6ayXodnLiwy791JawsRINUHvcTR1jBArUibWJBuXAgfb=s640
After finding there is a new video in the channel, it is downloaded, processed and the commands are executed:
https://blogger.googleusercontent.com/img/a/AVvXsEgabeaMu4DUfInuM5x5acxzrfau9oIFqSVcTv0Vh5h2cGBwwVL0hb2zxjmc_J-oNNDysKYY-vM7E72wFV103upM0f6aOXkkyRaeXB2SDjPifmx5NRKF4sBMl5YWTUX7LklxzerJ3JMHcLeKKQZBxjiQyqLZaPLJRJqA5lZDdhAlORwwV1c0DI0GiaDZ=s657
Telegram

Control systems remotely with a Telegram bot. This option does not allow to upload files, but it is possible to send the commands in cleartext (“/cmd”) or encrypted with AES (“/encrypted”). The first optional input argument is the bot token, which can be also configured in config.py; the second one is used to configure a single Telegram user who can send commands to the bot (without “@”):

python3 covert-telegram.py [BOT_TOKEN] [TELEGRAM_USER]

The listener will check the commands in the chat and show the output:

/cmd CLEARTEXT_COMMAND
/encrypted AES_ENCRYPTED_COMMAND
https://blogger.googleusercontent.com/img/a/AVvXsEh7_SVWVNyeyjDVsGhq3iHdElVdakxkYRaTkF0QGiZ15VPVgSeASBdklvFuYDa4V7-LcPiFsa2L-kbDesjClpxaPlVMZdc3-_2fOmTE7e0iBSUX8ufUXN-FsnkUqspj2zo8NtSfKvlpnOa1AbLG5Kxx-uYkKs_FWTU0TEsFfJtfhAgUKU2c4cWWEPdN=s485
Installation

sudo apt install libzbar0
pip install bs4 Pillow opencv-python pyqrcode pypng pyzbar youtube_dl pytesseract python-telegram-bot requests argparse pycryptodome
git clone https://github.com/ricardojoserf/covert-control && cd covert-control/

Creating standalone binaries

pyinstaller –onefile covert-googledrive.py
[...]

___________________________
@hacking_Attack
@Hacking_Video

es and back: AFL would mutate decision files, and the program under test would run on the translated binary files. In contrast to mutating binary files directly (as AFL would normally do), this would have the advantage of always having valid inputs – and thus progressing much faster towards coverage. AFL++ Integration

In addition to the format-specific fuzzers, such as gif-fuzzer, FormatFuzzer can also be compiled into format-specific shared libraries, such as gif.so(for that, simply run ./build.sh gifor make gif.so). Those shared libraries can be loaded by general-purpose fuzzers, such as AFL++.

To run AFL++ with FormatFuzzer, just follow the instructions on our modified version of AFL++. We support different fuzzing strategies, including:

* AFL+FFMut: runs AFL++ using FormatFuzzer to provide format-specific smart mutations.
* AFL+FFGen: uses FormatFuzzer as a format-specific generator, while AFL++ mutates its decision seeds. Creating and Customizing Binary Templates

To write your own .btbinary templates (and thus create a high-efficiency fuzzer/parser for this format), read the section Introduction to Templates and Scripts from the 010 Editor Manual.

In many cases, a template of the format you are looking for (or a similar one) may already exist. Have a look at the 010 editor binary template collection whether there is something that you can use or base your format on.

Note that the .btfiles provided in the repository generally target parsing files. They can be used for generating files, too; but they often lack exact information which parts of the input are required.

In this section, we discuss some of the ways in which you can customize .btfiles to work well with FormatFuzzer.

For example, for the GIF format, the file templates/gif-orig.bt shows the original binary template, which was only designed for parsing, while the file templates/gif.bt is a modified version which is capable of generating valid GIFs. Comparing the two files, we see that a small number changes was required to achieve this.

If you have created a gif-fuzzer, either by running make gif-fuzzeror by using the ffcompiletool, you have already obtained a C++ file gif.cppwhich contains an implementation of the GIF generator and parser. This is useful to see how the changes you make to the binary template are translated into executable code. More details on the C++ code are presented on the next section.

The GIF binary template makes use of lookahead functions ReadUByte()and ReadUShort()to look ahead at the values of the next bytes in the file before actually parsing them into a struct field. At generation time, we allow those functions to receive an additional argument specifying a set of good known values to pick for the bytes that we look ahead. In addition, we also allow specifying a global set of good known values to always use when calling a particular lookahead function, such as ReadUByte(). Those are stored in the ReadUByteInitValuesvector.

By default, our translation procedure ffcompiletries to mine interesting values which have been used in comparisons against lookahead bytes and use them as a global set of known values. When running

./ffcompile templates/gif.bt gif.cpp

a printed message shows the lookahead functions identified, as well as the mined interesting values:

Finished creating cpp generator.
Lookahead functions found:
ReadUByte
ReadUShort
Mined interesting values:
GlobalColorTableFlag: [‘1’]
LocalColorTableFlag: [‘1’]
ReadUByte: [‘0x3B’, ‘0x2C’]
ReadUShort: [‘0xF921’, ‘0xFE21’, ‘0x0121’, ‘0xFF21’]
Signature: [‘”GIF”‘]

For GIF generation, however, it is better to specify the set of good known values for ReadUByte()individually at each call to the function. So we define an empty array (size 0)

const local [...]

___________________________
@hacking_Attack
@Hacking_Video

pyinstaller –onefile covert-onedrive.py
pyinstaller –onefile covert-telegram.py
pyinstaller –onefile covert-youtube.py
rm -rf build
rm *spec
ls dist/ Download

___________________________
@hacking_Attack
@Hacking_Video

UBYTE ReadUByteInitValues[0];

to overwrite the set of global ReadUByteInitValuesand for each call to ReadUByte(), we use an additional argument to specify the set of good values to use for that particular location. The binary template language is also powerful enough to allow this choice to be made based on runtime conditions. For example, in the following code we show how the choice of appropriate values for a ReadUByte()call can depend on the current GIF version we are generating. A GIF version 89aallows one extra possible value for the byte (0x21).

if(GifHeader.Version == “89a”)
local UBYTE values[] = { 0x3B, 0x2C, 0x21 };
else
local UBYTE values[] = { 0x3B, 0x2C };
while (ReadUByte(FTell(), values) != 0x3B) {
…
}

The remaining edits required for the GIF binary template are similar. For example, for each struct field can also specify a set of known good values. For example this specifies the correct values for the Versionfield: 87aand 89a.

char Version[3] = { {“87a”}, {“89a”} };

Understanding the Generated C++ Code

For debugging purposes, as well as for understanding how to make appropriate changes to improve your generators and parsers, it may be useful to understand some inner workings of the generated C++ code. Ideally, you should be able to edit the binary template files until they can be used to generate valid files with high probability, so you wouldn’t have to edit the generated C++ code.

The C++ code creates a class for each structand uniondefined in the binary template, as well as for native types, such as int.

At construction time, when initializing a variable, we can define a set of good known values that this variable can assume. For example, the constructor call

char_array_class cname(cname_element, { “IHDR”, “tEXt”, “PLTE”, “cHRM”, “sRGB”, “iEXt”, “zEXt”, “tIME”, “pHYs”, “bKGD”, “sBIT”, “sPLT”, “acTL”, “fcTL”, “fdAT”, “IHDR”, “IEND” });

would specify 17 good values to use for variable cname. But this is often not enough, since the choice of appropriate chunk types is context sensitive. So we also allow specifying a set of good values at generation time when generating a new chunk. For example, this call could be used to generate an instance of chunkfor the first chunk, which must have type IHDR.

GENERATE(chunk, ::g->chunk.generate({ “IHDR” }, false));

When generating the second chunk, we might use this long list of possible chunks that can come between the IHDR chunk and the PLTE chunk:

GENERATE(chunk, ::g->chunk.generate({ “iCCP”, “sRGB”, “sBIT”, “gAMA”, “cHRM”, “pHYs”, “sPLT”, “tIME”, “zTXt”, “tEXt”, “iTXt”, “eXIf”, “oFFs”, “pCAL”, “sCAL”, “acTL”, “fcTL”, “fdAT”, “fRAc”, “gIFg”, “gIFt”, “gIFx”, “sTER” }, true));

The generator will then uniformly pick one of the good known values to use for the new instance. We also allow the choice of an evil value which is not one of the good known values with small probability 1/128. This feature can be enabled or disabled any time by using the method set_evil_bit.

All the random choices taken by the generator are done by calling the rand_int()method.

long long rand_int(unsigned long long x, std::function parse);

When running the program as a generator, this method samples an integer from 0 to x-1 by reading bytes from the random buffer. When running the program as a parser, this method uses the parse()function to find out which random bytes must be present in the random buffer in order to generate the target file, and then writes those bytes to the random buffer. The parsefunction receives as an argument the buffer at the current position of the file and must then return which value would have to be returned by the current call to rand_int()in order to generate this exact file configuration. Download

___________________________
@hacking_Attack
@Hacking_Video

SQL Injection [CWE-89] — The Hacktivists

SQL Injection is a weakness that is caused by improper neutralization of special elements used in an SQL query.Continue reading on Medium »
Read more...

LDAP Injection [CWE-90] — The Hacktivists

LDAP Injection weakness describes improper neutralization of special elements used in LDAP queries.Continue reading on Medium »
Read more...

XML Injection [CWE-91] — The Hacktivists

XML Injection weakness describes improper neutralization of special elements used in XML queries.Continue reading on Medium »
Read more...

Code Injection [CWE-94] — The Hacktivists

Code Injection weakness describes improper control of code generation.Continue reading on Medium »
Read more...

PHP File Inclusion [CWE-98] — The Hacktivists

PHP File Inclusion weakness describes improper control of filename within Include() or Require() statements in a PHP program.Continue reading on Medium »
Read more...

Off-by-one Error [CWE-193] — The Hacktivists

Off-by-one error occurs when a program uses an improper maximum or minimum value that is one more or one less than the proper value.Continue reading on Medium »
Read more...

Improper Handling of Length Parameter Inconsistency [CWE-130] — The Hacktivists

Improper Handling of Length Parameter Inconsistency is a security weakness that describes improper handling of a length field for…Continue reading on Medium »
Read more...

HTTP Response Splitting [CWE-113] — The Hacktivists

HTTP Response Splitting weakness describes improper neutralization of CRLF sequences in HTTP headers.Continue reading on Medium »
Read more...

hacking: security in practice
When using BEEF browser hacking, do your hacking capabilities basically stop the moment the user exist the page with the JS hook?

In other words you can't send a facebook login later or pretty much anything else.

submitted by /u/hankcarter90
[link] [comments]

___________________________
@hacking_Attack
@Hacking_Video