Free extract data software for linux

GNU DDD is a graphical front-end for command-line debuggers such as GDB, DBX, WDB, Ladebug, JDB, XDB, the Perl debugger, the bash debugger, or the Python debugger.

Besides "usual front-end features such as viewing source texts, DDD has become famous through its interactive graphical data display, where data structures are displayed as graphs.

Nabu is a simple framework that extracts chunks of various types of information from documents written in simple text files (written with reStructuredText conventions) and that stores this information (including the document) in a remote database for later retrieval.
The processing and extraction of the document is handled on a server, and there is a small and simple client that is used to push the files to the server for processing and storage (think rsync). The client requires only Python to work.
The presentation layer is left unspecified: you can use whichever web application framework you like to present the extracted data in the way that you prefer.
Main features:
- It is flexible: you can use
- any text editor you like to edit the files;
- any source code control system you like to store and maintain them (or none);
- any database for storage;
- and any web application framework for presentation. Nabu does not dictate how the information is presented/served to the clients;
- you edit files locally, not in a bleeping web browser window (programmers will appreciate the value of this), in your favourite editor environment;
- the organization of the source files in subdirectories has nothing to do with how the content is presented. We use a unique ID system (similar to arch) where your document to be published must contain a unique string to mark it with that id. You can put that string in a reStructuredText comment or a bibliographic field. Unlike Wikis, this allows you to change the title of your documents while keeping the possibility of a permanent link to them.
- It effectively offers you a sandbox for creating content, and then how you organize and present the content is dictated by ways that you decide, most likely independent of the source file organization structure;
- the input data can be scattered over many files, it does not have to be stored in files per-category (for example, you dont have to store all your "contacts" in a single "address book" file, they can be found within/across all your body of published file and a server might present as a single list if desired). I conjecture that this may be closer to how humans think of this data. This body of files can be used to create a mind-mapping system;
- we recognize that the value of the information lies in the source itself, the text files. This valuable source remains with you, and you are free to manage them in any way you prefer, with any version control system you like (if you want to do that). You can completely dump the data stored in the database and rebuild it from the text files;
- various semantic chunks of content are automatically extracted from your document. These semantic things are easily written with little code and are configurable. Nabu comes with example content extractors;
- a light-weight program with minimal dependencies is used to upload the files to the server. The server processes the files for content. This maximizes the potential that you will be able to use Nabu anywhere, on any platform. The client only requires Python to work;

Xephyrus Data Structures Tag Library provides an easy way to create and manipulate the contents of common Java data-structures such as maps and lists.
Enhancements:
- The library was polished up.
- Several improvements were made and a few bugs were fixed.
- This version is aimed at Java 5 and JSP 2.0.

THC-ManipulateData can search data on a harddisk/partition/file, extract the part you are interested in, and write it back after you modified it.
Useful to find and modify really all unencrypted Logfiles on a system. Does everything in RAW mode, and hence does not tamper a/m/ctimes.
It comes with 4 tools:
Syntax of search_data: ./search_data [-i] [-d] blockdevice searchstring
-i - the only parameter which is optional. This does the
search case insensitive.
-d - dump the found occasions in hex
blockdevice - a blockdevice you want to search for data. It need
not to be a blockdevice, it can be anything, but normaly
you use it on these.
searchstring - a string you want to search for
The blockdevice is searched for the occurance of searchstring, which are printed with location when found.
Example: ./search_data -i /dev/hda3 "connect from 10.0.0.1"
Output looks like:
found at 234600: connect from 10.0.0.1/unresolved (UNKNOWN)
Syntax of read_data: ./read_data blockdevice start_address no_of_bytes
blockdevice - a blockdevice you want to get your data from. It need not to be a blockdevice, it can be anything, but normaly you use it on these.
start_address - from which offset of the blockdevice you want to extract data from
no_of_bytes - how many bytes of data starting at the start_address you want to extract in a file.
The output filename is always START_ADDRESS.NO_OF_BYTES
Example: ./read_data /dev/hda3 234653 1024
writes 1024 bytes of data from /dev/hda3 starting from offset 234653 to the file "234653.1024"
Syntax of write_data: ./write_data blockdevice filename
blockdevice - a blockdevice you want to write your data to. It need not to be a blockdevice, it can be anything, but normaly you use it on these.
filename - the data you want to write to the blockdevice. For error protection, the location where it is put it gathered from the filename - as you can see above from read_data. If you modified the data extracted with read_data into the file, it may not have a different size than defined in the filename! The data in filename is written to the blockdevice
Example: ./write_data /dev/hda3 234653.1024
writes 1024 bytes of data to /dev/hda3 starting at offset 234653 with the
data read from the file "234653.1024"
Syntax of replace_data: ./replace_data [-i] blockdevice searchstring replacestring
-i - the only parameter which is optional. This does the search case insensitive.
blockdevice - a blockdevice you want to search for data. It need not to be a blockdevice, it can be anything, but normaly you use it on these.
searchstring - a string you want to search for
replacestring - the string you want to replace the found entries with
The blockdevice is searched for the occurance of searchstring, and is then replaced.
Example: ./replace_data -i /dev/hda3 "connect from 1.0.0.1" "Remap table failure "
Output looks like:
found at 234600 - replaced
Enhancements:
- fixed a bug in read/write_data, seeks over 2gb now succeed
- added -d for hexdump display of occasions found in search_data

htmlSQL is a PHP class to query the web by an SQL like language. htmlSQL is a experimental PHP class which allows you to access HTML values by an SQL like syntax.

This means that you dont have to write complex functions (regular expressions) to extract specific values.

How to use

Just include the "snoopy.class.php" and the "htmlsql.class.php" files into your PHP scripts and look at the examples (examples/) to get an idea of how to use the htmlSQL class. It should be very simple.

Background & Idea

I had this idea while extracting some data from a website. As I realized that the algorithms and functions to extract links and other tags are often the same - I had the idea to combine all functions to an universal usable class. While drinking a coffee and thinking on that problem, I thought it would be cool to access HTML elements by using SQL. So I started creating this class...

Warning!

The eval() function is used for the WHERE statement. Make sure that all user data is checked and filtered against malicious PHP code. Never trust user input!

wavextract is a program for extracting embedded audio data from JPEG images. wavextract project is useful if you have a digital camera that can record audio notes and embed them in photos (e.g. HP, Kodak, Fujifilm, Canon, etc.)

Wavextract is written in Python and is tested on Linux (but it should probably
work also on other operating systems).

You must have Python 2.4 (maybe it will work also with Python 2.3, but I didnt
test it) and Python Imaging Library (PIL) installed.

pkcrack is an implementation of a known plaintext attack on password encrypted ZIP archives. For the attack to be successful you have to have at least 106 bytes of unencrypted compressed data from the given ZIP archive (the data must be compressed using the same compression method as the encrypted counterpart). Providing this, the sophisticated attack can be thousand times (or even more) faster than a brute force attack (considering non-trivial long password). The speed is affected by the amount of plaintext you transmit.
Enhancements:
- "Relf" has found and fixed a bug that caused pkcrack to fail under certain circumstances (roughly one out of 32 keys couldnt be found). Thanks!
- Two more options for pkcrack, also by "Relf" (Thanks again!): -a will stop stage2 immediately when a combination of key0, key1, key2 has been found -n disables the (new!) progress indicator
- corrected handling of data descriptor in extract-functions (Thanks to "Relf" and Andreas Lessig !)
- zipdecrypt now uses dynamic allocation for directory entries, which means the 200 files limit is gone
- The extract program now has a -v flag to print a verbose description of the ZIP file
- Considerable speedups in stage1
- The source distribution now includes an automated test suite