Free diablo 2 hex editor software for linux

Bob the Butcher project is a distributed password cracker package.
This is ALPHA software, full of bugs, some of them being likely to be security holes. Besides, there is no client authentification, so anybody could impersonate a client and alter your search results.
Only use it on a trusted network!
Main features:
- Ciphers near source compatibility with John the Ripper. Bob the Butcher benefits from the fast algorithms that have been develloped for John:
Traditionnal DES Solar Designer
BSDI DES [BROKEN] Solar Designer
FreeBSD MD5 [BROKEN] Solar Designer
Windows NTLM (MD4)
MMX/SSE2 bartavelle
Windows Cache (mscash) bartavelle
Raw MD5 (hex-encoded) bartavelle
Raw SHA1 (hex-encoded) bartavelle
MySQL passwords Noah Williamsson
Netscape LDAP SHA Sun-Zero
Netscape LDAP SHA
MMX/SSE2 Bartavelle
Lotus Domino Jeff Fay
Oracle Passwords Bartavelle
- Password cracking speed scales linearly with the number of cracking clients.
- Central server that can handles several jobs, supporting different priorities (in the future.
- Smart keyspace distribution when several jobs are using the same algorithm (not for now).
Usage:
Build instructions
Only works on pentium or later!
./configure --enable-debug
make
cd bob_client
./bob_client -b
If it segfaults, try again with:
./configure --enable-debug --disable-sse2
bob_server
Just run ./bob_server -k SECRET_KEY
bob_admin
Use it to add jobs and check status. For now only he following commands work:
newjob : add a new job
status : gives general status
jobinf : give detailled status
Dont forget to use the -k switch for PSK.
bob_client Put this one on as many computers as possible, and just run:
./bob_client -d -k SECRET_KEY server_host_name
Enhancements:
- Bugfixes in cyphers, support for Solaris, and a prototype Python server.

edanator is an intuitive graphical binary and hex calculator. Each nibble is displayed in hex and binary. Clicking on the button (hex nibble or binary bit) changes the value. Bit and nibble shifting is supported via dedicated buttons. The project supports variable widths per word (up to 64- bits), three words (each on a different row), and mathematical operations between words.
Enhancements:
- An endian-ness button for swapping bit labels was added along with a bit reverse function.

Wcalc is a very capable calculator. Wcalc has standard functions (sin, asin, and sinh for example), many pre-defined constants (pi, e, c, etc.), support for using variables, a command history, hex/octal/binary input and output, unit conversions, bit-shifting, embedded comments, and an expandable expression entry field. It evaluates expressions using the standard order of operations.
Wcalc is a very capable calculator. It supports abitrary precision, has standard functions (sin, asin, and sinh for example, in either radians or degrees), many pre-defined constants (pi, e, c, etc.), support for using variables, "active" variables, a command history, hex/octal/binary input and output, unit conversions, embedded comments, and an expandable expression entry field. It evaluates expressions using the standard order of operations.
Wcalc uses intuitive expressions. For example, Wcalc will evaluate: 5sin 4!-7*2(4%6)^2 to be -221.96631678
Wcalc also comes in a command-line version that works on most (if not all) forms of Unix (including Linux and BSD). To support arbitrary precision, Wcalc relies on the GMP and MPFR libraries.
In the MacOSX release, these are compiled-in, so you shouldnt have to install them yourself. NOTE: GMP comes with a broken version of MPFR (I really wish they wouldnt do that). You have to install a real version of MPFR for Wcalc to work.
Enhancements:
- This has plenty of bugfixes and a couple nifty new features. In the GUI realm, Wcalc now also serves as a System Service, and so adds a "Wcalc Compute" entry to the Services menu of other applications.
- In the CLI realm, Wcalcs error reporting is now more friendly, and will tell you exactly where in the line the error occurred.
- Also, Wcalc now uses tab-completion in the CLI, and can tab-complete just about anything (variables, conversion units, commands, functions, etc.).

galculator is a GTK 2 based calculator with ordinary notation/reverse polish notation, a formula entry mode, different number bases (OCT, HEX, DEC, BIN) and different units of angular measure (DEG, RAD, GRAD).
[a basic calculator] galculator features two user modes: basic and scientific mode. Basic mode is intended for simple computations. Only the most important operations and functions are available in algebraic mode as well as in Reverse Polish Mode. Formula entry, available for the basic as well as for the more sophisticated scientific mode, aims to make the calculator even more user friendlier: type as you would write on a paper!
[a scientific calculator] Scientific Mode is galculators state-of-the-art. It supports different number bases (DEC/HEX/OCT/BIN) and angle units (DEG/RAD/GRAD) and features a wide range of mathematical (basic arithmetic operations, trigonometric functions, etc), other useful functions (memory, etc) and user defined functions. Of course, algebraic mode as well as Reverse Polish Notation are available. See below for a detailed list of supported functions.
[a GTK 2 based calculator] galculator is written entirely in C and uses GTK version 2. Especially the display takes big advantages of the new possibilities in GTK 2. Have a look at the screenshots section to see what Im talking about.
[why another calculator] Some time ago, I was looking for a GTK based calulator. Nothing special, just for simple computations. But I wasnt able to find one. This application lacked full keypad support, that one didnt know hexadecimal numbers. Therefore I decided to write my own calculator application with all the features Id expected others to have.
Main features:
- Algebraic mode, RPN (Reverse Polish Notation) and Formula Entry mode
- decimal, hexadecimal, octal and binary number base
- radiant, degree and grad support
- arithmetic precedence
- Basic and Scientific Mode
- user defined constants
- user defined functions
- trigonometric functions
- power, sqare root
- natural and common logarithm
- inverse and hyperbolic functions
- memory functions
- logical operations
- display RPN stack
- preferences dialog/configuration file
- display modules
- X pasting
- i18n
- configurable variable type in HEX/BIN/OCT mode
- thousands separator

Bless is a high quality, full featured hex editor.

Bless is written in mono/Gtk# and its primary platform is GNU/Linux. However it should be able to run without problems on every platform that mono and Gtk# run.

There are also plans for the addition of a lua based scripting language for binary data manipulation.

Simulator 8085 is a simulator of the 8085 MP for KDE (3.1 and 3.2pre) that allows you write code in a text editor.

After assembling, the hex code is readable alongside the mnemonics. It can handle jumping labels and strings, and you can choose beetween a single or multiple window interface. All 8085 MP inclusive interrupts work.

Convert::BinHex can extract data from Macintosh BinHex files.

ALPHA WARNING: this code is currently in its Alpha release. Things may change drastically until the interface is hammered out: if you have suggestions or objections, please speak up now!

SYNOPSIS

Simple functions:

use Convert::BinHex qw(binhex_crc macbinary_crc);

# Compute HQX7-style CRC for data, pumping in old CRC if desired:
$crc = binhex_crc($data, $crc);

# Compute the MacBinary-II-style CRC for the data:
$crc = macbinary_crc($data, $crc);

Hex to bin, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Hex2Bin") which keeps internal conversion state:
# Create and use a "translator" object:
my $H2B = Convert::BinHex->hex2bin; # get a converter object
while (< STDIN >) {
print $STDOUT $H2B->next($_); # convert some more input
}
print $STDOUT $H2B->done; # no more input: finish up

Hex to bin, OO interface. The following operations must be done in the order shown!
# Read data in piecemeal:
$HQX = Convert::BinHex->open(FH=>*STDIN) || die "open: $!";
$HQX->read_header; # read header info
@data = $HQX->read_data; # read in all the data
@rsrc = $HQX->read_resource; # read in all the resource

Bin to hex, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Bin2Hex") which keeps internal conversion state:
# Create and use a "translator" object:
my $B2H = Convert::BinHex->bin2hex; # get a converter object
while (< STDIN >) {
print $STDOUT $B2H->next($_); # convert some more input
}
print $STDOUT $B2H->done; # no more input: finish up

Bin to hex, file interface. Yes, you can convert to BinHex as well as from it!
# Create new, empty object:
my $HQX = Convert::BinHex->new;

# Set header attributes:
$HQX->filename("logo.gif");
$HQX->type("GIFA");
$HQX->creator("CNVS");

# Give it the data and resource forks (either can be absent):
$HQX->data(Path => "/path/to/data"); # here, data is on disk
$HQX->resource(Data => $resourcefork); # here, resource is in core

# Output as a BinHex stream, complete with leading comment:
$HQX->encode(*STDOUT);

PLANNED!!!! Bin to hex, "CAP" interface. Thanks to Ken Lunde for suggesting this.
# Create new, empty object from CAP tree:
my $HQX = Convert::BinHex->from_cap("/path/to/root/file");
$HQX->encode(*STDOUT);

BinHex is a format used by Macintosh for transporting Mac files safely through electronic mail, as short-lined, 7-bit, semi-compressed data streams. Ths module provides a means of converting those data streams back into into binary data.