Zines/phrack/52/8.txt

---[  Phrack Magazine   Volume 8, Issue 52 January 26, 1998, article 08 of 20


-------------------------[  Steganography Thumbprinting


--------[  The HackLab (http://www.hacklab.com)



Steg`a*nog"ra*phy (?), n. [Gr. covered (fr. to cover closely) +
   -graphy.] The art of writing in cipher, or in characters which are not
   intelligible except to persons who have the key; cryptography.  


i. Introduction

    While this may be a general description of cryptography, steganography has
come to describe not only the act of encrypting data, but also of hiding its
very existence.  Steganography (or "stego") uses techniques to store a
"message" file within a "container" file by altering the container file in
such a way as to make the original file _appear_ unchanged.  The resulting
file can be referred to as the stego file and contains the message file
enclosed in a close approximation of the original container file.  Several
tools exist (mostly for DOS/Windows/NT) which automate these functions using
DES, DES3 or IDEA as encryption methods and BMP, GIF, JPG, WAV, VOC and even
ASCII files as containers.  Using these tools, data can be hidden within
images, sounds, and even other data files.  However, these tools do leave
perceptible traces on their container files and do not offer nearly the
level of obfuscation the user assumes.
    
    This article will provide the reader with a fundamental understanding of
basic stego techniques and will highlight some of the "thumbprints" left by
modern steganographic toolsets, specifically on graphic images.  Not intended
to challenge the cryptographic strength or perceptible mathematical variances
of current steganographic techniques, this article will give the reader a
basic understanding of stego and suggest low-budget methods for detecting and
cracking basic steganographic techniques.  Also presented is a program which
can be used to brute-force two of the most popular stego toolsets.


I. Basic Steganography


    Simply put, steganography involves the hiding of messages.  While there are
many techniques employed by the various tools, the least common denominator
amongst most toolsets is the modification of some of the Least Significant
Bits (or LSBs) of the container file's individual bytes.  In the simplest
example, consider the following binary representations of the numbers 20
through 27:

10100 10101 10110 10111 11000 11001 11010 11011

    By modifying the LSBs of these binary digits, we can hide the binary
representation of the number 200 (11001000) across the above bytestream:

10101 10101 10110 10110 11001 11000 11010 11010

    By reconstructing the LSBs of the above bytestream, we recover the number
200 (11001000). In the above example, the original bytestream of the numbers
20-27 is the container, while the number 200 is the message file.  This is a
very poor basic example since the resulting stego file is not an accurate
representation of the original file.  After modification to include the
message file, the numbers 20-27 now read:
 
21 21 22 22 25 24 26 26

    However, in most stego applications, the container file does not contain
bytestreams which are rendered useless by modifying LSB information.
Instead, container files typically contain various levels of "noise" at the
level of the LSB's which when viewed apart from the rest of the byte can
appear random.  A sound (.WAV) file, for example contains mostly inaudible
background noise at the LSB level.  An 8-bit graphic file will contain minor
color differences at the LSB level, while a 24-bit image will contain color
changes which are nearly imperceptible to the human eye.  A very common
container format is a 256 color, 8 bit image such as a GIF or BMP file.


II. Stego Techniques


    In an 8-bit image such as a GIF or BMP each pixel is described as a number
from 0 - 255 which refers to an actual color in the "color lookup table" or
palette.  A common misconception is that all images simply contain strings of
bytes that describe individual colors, and that the graphic file simply
lists these colors in left-to-right, and top-to-bottom fashion.  This is
only partially true for 8-bit images.  The palette lists every color that is
used in the image (and extra colors, if less than 256 total colors are actually
used in the image), and the image data itself is stored as a series of digits
from 0 - 255 which reference an entry in the palette.  In this way, the image
can be reconstructed by performing palette lookups to determine the color to
insert at that pixel location.

    In order to hide data within an 8-bit GIF or BMP container, most existing
tools use one of two techniques which I will term LSB palette reference
modification and RGB element LSB modification.

    LSB palette reference modification involves changing the LSB(s) of a
_palette_reference_ (0 - 255) in order to hide the data contained in the
message.  Remember that a palette reference simply contains a number from 0 -
255 which references a color, or entry, in the palette.  In order to hide
data, a program utilizing palette reference modification may decide which
color to point to based on the color's LSBs.  This type of program will pay
no attention to how similar the colors are, only whether or not the LSBs
serve its purpose of data hiding.  If the adjacent colors in the palette have
dissimilar LSBs, they are well suited for data hiding and become good
candidates for storing hidden text in the final stegoed container.  If a 0
(zero) is meant to be hidden, the stego program inserts the palette index
reference of the color with the LSB of 0 (zero), and vice versa for hiding a
1 (one).

    RGB element LSB modification involves modifying the pixel's _actual_color_
by changing the LSB of the Red, Green or Blue elements of the color in the
color table.  For example, the color "white" is represented by the RGB values
255,255,255 which in binary equates to:

11111111 11111111 11111111

listed in RGB order.  By altering the LSB of each color in the RGB element,
we can hide data by making almost identical copies of colors such that only
the LSBs are different.  Since the color is only changed by one or two LSBs,
the resulting colors are very close, perhaps undetectable to the human eye.
The result of this change to the colors in the table enables nearly identical
colors to be referenced by multiple table entries.  This becomes extremely
obvious when the palette is viewed and sorted by luminance (relative
brightness)in a product such as Paint Shop Pro.  These similar colors will be
grouped right next to each other in a luminance-sorted palette.  Using this
technique, a binary 1 in the message file can be represented in the stego file
by replacing a color in the container file with an altered version of that
color whose RG or B element ends with a binary 1.  Likewise, a binary 0 in the 
message file can be represented in the stego file by replacing the original
color in the container file with an altered version of that color whose RG or 
B element ends with a binary 0.


III. Steganographic Thumbprints 


    Several tools are available that apply these techniques to files on
several different platforms.  I will focus on two specific toolsets; Steganos
and S-Tools v4.0.  Steganos is perhaps the most versatile and powerful of the
toolsets, while S-Tools seems to be the easiest and most widely used (not to
mention the fact that I like S-Tools; it's been around for a long time and
is very well done).  Other available toolsets include similar functionality
and hiding techniques.  In order to discover what the tools actually do when
they hide data, it's best to use a simple BMP container file.  The RGB BMP
file utilizes a palette scheme identical to that of a GIF for the purposes
of our tests, and all the reviewed toolsets can use BMP files as containers.

    For example, consider a container image which is 50 pixels by 50 pixels and
contains only black-colored (0,0,0) pixels.  This image references palette
entry 0 (zero) as its only color.  I will use a freeware painting program Paint
Shop Pro V4.10 (PSP) to create and analyze the base images.  When creating 
this image, PSP used a default palette with 216 unique palette entries and 40 
"filler" entries at the end of the palette all of which contain the value 
(0,0,0) or pure black.

Our message file is simply a text file which contains the phrase "This is a
test."


A. S-Tools


    When the message file is hidden using S-Tools, the resulting 8-bit image
appears identical to the human eye when compared to the original.  However,
there are perceptible oddities about the file which are revealed under closer 
scrutiny.

    Since S-Tools uses RGB element LSB modification as its hiding technique,
the palette has distinct and very obvious characteristics.  Many of the
palette's colors are offset by a single bit in the R,G or B element.  This is
very obvious when the palette is sorted by luminance (brightness) and viewed
with PSP.  The first sixteen (and only original) colors in this palette are:

(51,1,1) (51,1,0) (50,1,0) (51,0,1) (51,0,0) (50,0,1) (50,0,0) 

(1,1,0) (1,1,0) (0,1,1) (0,1,0) (1,0,1) (1,0,1) (1,0,0) (0,0,1) (0,0,0)

    Notice that the offsets of the RGB elements are only 1 bit.  This is an
imperceptible color change, and is a very wasteful use of the palette.
Remember, there are only 256 colors to work with.  Most 8-bit image creation
programs are very careful when deciding which colors to include in the palette,
and almost all use standard palettes which contain all the most commonly used
colors.  To see a palette with this many _nearly_ identical colors is odd.
Also, the palette has been adjusted to contain less colors. The standard 
colors selected by PSP have been replaced by some of the colors listed above.
As is typical with this type of hiding, the slack space at the end of the
palette has been reduced to make room for the new copies of existing colors.
This type of hiding will always make itself obvious by using single-bit
offsets in one or more of the LSBs.  Since this type of thumbprint is so
easily identifiable, we will concentrate our efforts on the harder-to-detect
palette reference method used by Steganos.


B. Steganos


    Steganos kindly reminds you that 8-bit images don't make terribly secure
containers.  It's a good thing, too, because when the message file is hidden
using Steganos the resulting 8-bit image has a major anomaly- the stego
image is completely different than the original!  As opposed to an all-black
image, the image now resembles a black-and-blue checkerboard.  However, this
difference is only obvious if you have access to the original image.  Since
an interceptor will most likely not have a copy of the original image, we
will examine other methods of detection.  When the palette of the image is
checked for single-bit offset colors (as in the stego image created with
S-Tools), none can be found.  Also, there is no more or less slack space at
the end of the palette than existed in the original palette.  Steganos does
not alter the palette in any way when hiding data.  It uses the LSB palette
reference technique described above.  However, there are very distinctive
ways of determining if this technique has been used to hide data, specifically
by looking at _how_ the palette's colors are used.  In this simple case, a
histogram will show exactly the type of modification we are looking for.
In the words of the PSP Help documentation,

"A histogram is a graph of image color values, typically RGB values and/or
luminance.  In a histogram, the spectrum for a color component appears on the
horizontal axis, and the vertical axis indicates the portion of the image's
color that matches each point on the component's spectrum."

    In a nutshell, this simply means a graph is generated showing how the
color(s) are used in an image, and how similar (in shade) they are.  When
viewing the "blue" histogram for the Steganos-hidden file, we see something
like this:

100= X                   X
   - X                   X
90 = X                   X
   - X                   X
80 = X                   X
   - X                   X
70 = X                   X
   - X                   X
60 = X                   X
   - X                   X
50 = X                   X
   - X                   X
40 = X                   X
   - X                   X
30 = X                   X
   - X                   X
20 = X                   X
   - X                   X
10 = X                   X
   - X                   X
00 = X                   X 
  . ! . ! . ! . ! . ! . ! . ! . ! . ! . ! . . . 
    0   1   2   3   4   5   6   7   8   9       2
    0   0   0   0   0   0   0   0   0   0       5     
                                                5

    The X-axis shows the spectrum for the color blue (from 0 to 255).  The
Y-axis shows the number of pixels in the image that match that color.  When
displaying a histogram, the 100 on the Y axis is not percentage, but a MAX
value (in this case 1272) which indicates the greatest number of pixels used
for _any_one_color_.  Since there are really only two colors _used_ in this
stego image, there are only two vertical bars.  These bars indicate that in
the Blue color family there are really only two colors used; one with a blue
value of zero, and another with a blue value of approximately 50 (51 to be
exact).  Upon examining the color table for this image sorted in
_palette_order_, it is evident that these two referenced colors are only
similar since they are placed right next to one another in the palette.  The
two colors are (0,0,0) and (0,0,51) or black and very, very dark blue.  The
image mostly has black hues, and Steganos probably picked the very dark blue
color (00110011) as the 1 for some hidden data, and black (00000000) as the
0 for some hidden data since these colors are _right_ next to each other in
a palette-index-order color table listing.  Although they reside next to each
other in the palette, the colors are not very similar which makes the final
stego file appear discolored.  Steganos does not modify any of the colors,
but it modifies how the original palette is used by making nearly equal
references to a color and its neighbor (when sorted by palette index).
Bottom line: this image uses neighboring palette colors nearly an identical
number of times.  1272 pixels were used for black and 1228 pixels were used
for the dark, dark blue.  This would not be unusual if not for the fact that
the colors are palette index neighbors.  If the designer of the image were
using some sort of shading effect, there would be many more than just two
shades involved in this 256 color image, and the shading offsets would be
greater.  These two colors don't even appear as shades of one another when
placed side-by-side.

    A skilled interceptor will know immediately that something is not quite
right with these images.  They both display typical signs of data hiding.


IV.  Real-World example


    Intercepting a single-color image and determining that it is stegoed is a
trivial task.  Increasing the number of used colors within the boundaries of
the 256-color palette could (so the reader may think) obfuscate the hidden
message file.  However, by applying a few simple methodologies, a pattern
emerges which can increase the odds of detecting a stegoed image.  For
example, if a two-color image is created using only the colors black (0,0,0)
and white (255,255,255), and data is hidden in the file by using Steganos,
the results would show that Steganos not only used black and white, but two
more colors from the palette are used with values of (0,0,51) and
(255,255,51) respectively.  These newly-used colors adjoin the original two
colors in the palette listing, have differing LSBs, and are referenced
nearly as much in the new image as the original colors are.  A similar
situation evolves when a 6-color image is created.  After Steganos hides the
data, the original 6 colors and their palette neighbors will be used in
the new file.  The 6 new colors become alternate representations of the
original 6 colors in terms of their LSBs.  This methodology holds true all
the way up to images containing 256 different colors.  By understanding these
patterns, all 8-bit Steganos images can be detected without access to the
original image.

    When attempting to detect the use of steganography in 16 or 24-bit images,
a great deal of pattern analysis must be used.  24-bit stego detection is not
for the faint of heart, but it can be done.  Standard "randomization" solutions
fall quite short of solving this problem since LSB data in image creation
programs is hardly random.  It follows a pronounced pattern when viewed as a
part of a whole: an 8-bit number.  Most standard graphics effects do not use
random data, they use patterns to create and maintain a certain graphic
illusion.  Inserting "random" data, even at the LSB level can become fuel for
the analyst's fire.  In many 24-bit stego programs, bits in the secret text
are generally inserted with average spacing between them, then random "noise"
is added to make the secret bits seem less obvious.  The random "noise" would 
(should!) have a random interval between differing bits.  The contrast of an
average spacing against random spacing may be enough to not only alert an
analyst, but to point out where secret bits start and random bits begin.  The
bottom line is that 24-bit detection is doable, just not practical for an
amateur- yet!


V.  The Future


    Steganography is in it's infancy, but several new technologies are emerging
including selection and construction methods of data hiding and continuing
research in the area of random distribution.

    Selection involves the generation of a large number of copies of the same
container file that differ slightly.  In the case of an image file, you may
make minor adjustments in hue, saturation and RGB levels to the end that your
secret message will eventually _appear_ in the LSBs of the data!  Although
difficult to generate, this type of data hiding is nearly impossible to detect
since the image's characteristics are not altered at all.

    Construction simply involves modeling the characteristics of the original
container when creating your message.  In simplest terms, mold your message
around the existing container instead of molding the container to your message.
If, for example the original image were left unchanged, and a key was
developed to create the message _from_ the image, detection would be impossible
without the key.

    Several advances are being made in the area of random distribution,
specifically by Tuomas Aura at the Helsinki University of Technology.  His
paper "Practical Invisibility in Digital Communication" presents a technique
called "pseudorandom permutation", which brings steganography up to the
technical level of cryptography and properly addresses the issue of
randomness from a data hiding perspective.  His paper is excellent reading
and can be found at http://deadlock.hut.fi/ste/ste_html.html

    Interesting research (and proof-of-concepts) are being done to utilize
stego techniques in reserved fields in TCP, UDP and ICMP packets.  This
research proves that steganography has merit and application beyond sound and
image files.  Unfortunately, using stego where there was nothing before (ie 
within typically blank reserved fields) can raise a flag in and of itself.  Use
encryption and compression to further protect data.  It really doesn't matter
if the secret data is discovered if the underlying crypto is secure.


VI. Conclusion


    Detecting stego in an 8-bit image is fairly easy.  Actually gaining access
to the secret text becomes a bit harder yet a simple overlooked method involves
bruteforcing the creating application (see S_BRUTE.WBT program below).  On the
other hand, 24-bit image analysis requires quite a bit of work.  If you choose
to employ data hiding techniques, use 24-bit images and compress and encrypt
your message file, bearing in mind that 24-bit images can raise flags simply
due to their size.
 
When attempting to identify stego files in 8-bit images, keep in mind the
following pointers: 

* Search for the obvious thumbprint of an RGB element.
* In the stego file: single-bit offsets between colors in a palette sorted by 
  luminance (this SCREAMS S-Tools!).
* If no single-bit offsets exist between the colors in the palette, search
  for Palette Reference thumbprints which include the following:
* Use of palette index neighbors a near-equal number of times either in the
  entire image (use a histogram) or in an area which should be primarily
  single-color only but contains a checkerboard effect (use zoom 11:1 to see
  individual pixels, and the eyedropper tool to quickly view the RGB
  elements in PSP)
* Poor image quality (noise and snow are common side-effects).
* For more detailed analysis the reader might consider using an MS-DOS 
  program msgifscn.zip, available from Simtel mirror sites worldwide, to
  dump the entire contents of an 8-bit GIF image's palette to a file, which
  can be dumped into MS Excel for analysis (the analysis add-in in for Excel
  comes in REAL handy for binary conversions and data sorts.)
* If you have a clue that the file you're looking at may contain stegoed 
  data, it never hurts to brute force the application that created it! (see
  the S_BRUTE program listing at the end of this article) While this may be
  one of the slower methods of breaking stego, it is often easier to
  derive possible keyphrases from other sources than attacking the stego
  algorithm or the crypto.


VII.  The program

    The author of S-Tools sells the source code for his program, and Steganos
makes available an SDK for hiding/decoding files using it's algorithms, but
an option exists for programs that do not make their source available:
bruteforce of the application itself.  Although using the API and SDK's
available would be significantly faster, there are times when this option
just may not exist.

    To that end, included below are two files, S_BRUTE.WBT and S_BRUTE.INI.
This program was written in WinBatch, which is a language that acts very much
like the UNIX language TCL/TK (or Expect), but operates in a Windows 95/NT
context.  Developed to control Windows applications, WinBatch provides a
perfect vehicle for brute-forcing an application's password function (see
http://www.windowware.com for the free compiler to run S_BRUTE). S_BRUTE is
an application that will bruteforce S-Tools v4 and Steganos using a
dictionary file in an attempt to determine the passphrase of a stegoed image
(which will subsequently reveal the hidden text). The program selects which
tool to use based on which executable you select, and the S-Tools portion of
the program will not only bruteforce the passphrase, but will attempt all
four algorithms available to S- Tools.  Unfortunately S-Tools uses certain
mouse-only operations, so you will effectively lose your mouse while the
S-Tools portion runs.  The dictionary needed by this program is simply a list
of words or passphrases separated by newlines.  Keep in mind that Steganos
does not allow passwords shorter than five characters, so strip those out to
save time.  If you need to use a " (double-quote) in the word/passphrase,
simply use "" (two double quotes) in the dictionary.  WinBatch likes this.  A
log file is created as c:\output.txt which simply lists all the attempted
words/passphrases.  The output file can be reused as a dictionary since no
extraneous information is written out.  Two options exist for inputting the
names of the Stego tool executable, the dictionary file and the stego image.
The S_BRUTE.INI file format (see below) allows the variables exepath, dict
and stegofile which allow the input of these full path names into the
program.  In addition, the program can prompt for the filenames manually
using standard Windows '95 file boxes.  In this case, pay attention to the
box titles as they come up.  These titles describe what file the program is
looking for.  A variable is also available in the INI file called
STEGANOSDELAY.  This value (listed in seconds) determines how long to wait
for a passphrase error message from Steganos.  The default is 0, but if you
get a lot of false positives (your machine is SLOW!) set this value to a few
seconds.  Due to the speed of the bruteforce attack, this program is not
always accurate as to _which_word_ actually worked if it finds a match.  In
this case, S_BRUTE will tell you which word it _thinks_ worked, but you may
have to try the word S_BRUTE gave you plus one or two of the previous words
in c:\output.txt (plus a few different algorithms if you're using S-Tools).
Either way, you are only looking at about 12 combinations (not bad!).

    Note that S-Tools and/or Steganos must be properly installed prior to using
this program.  S_BRUTE was not designed to brute force the entire keyspace, but
to give you a faster method of determining the passphrase if you have any idea
what it might be.  If the stego image is found on a web page, create a
dictionary from words and phrases found on that site, and let S_BRUTE do the
work for you.

<++> sbrute/S_BRUTE.WBT
;; Steganography Brute v1.0 written by a researcher at hacklab.com 
;; For new versions and support programs see http://www.hacklab.com
;; This little toy brute forces two very common Steganography utilities, 
;; specifically Steganos (http://www.steganography.com) and S-Tools written 
;; by Andrew Brown (a.brown@nexor.co.uk) 
;; This program can be run using a free program called WinBatch 
;; from http://www.windowware.com
;;
;;
;;Notes:
;;
;; 1) The program depends on the executable name being either "S-TOOLS.EXE" or
;;	"STEGANOS.EXE". This exe name decides many things, including the
;;	semantics of the brute force attack and which types of container files
;;	to accept. (Remember that the tools accept different types of container 
;;	files.)
;; 2) The dictionary file is simply a text file with words or phrases separated
;; 	by CR(LF). If a " (double quote) must be used in the word or phrase, 
;;	use "" (two double quotes) instead. This is Winbatch's way of representing
;; 	the double quote in a string.
;; 3) Internally, this program converts all Windows LFN-formatted dir/filenames to
;;	DOS-style 8.3 or short dir/filenames. If you have problems, finding/using
;;	LFN files, you may want to manually convert them to a SFN dir/file structure.
;; 4) The S-Tools test requires certain mouse-only operations. During this part of
;;	the program, it's best to leave your machine alone. Otherwise the mouse will
;;	be all over the place. Sorry. 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:main                         ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


Intcontrol(12,4,0,0,0) 		;;controls abrupt endings

if (winmetrics(-4) < 4 ) 
        error="This program runs on Windows NT or Windows '95 only!"
        gosub bail_error
EndIf

cr=Num2Char(13)
lf=Num2Char(10)
crlf=StrCat(cr, lf)
progname="Steganography Brute"
STEGANOS=0			;; Flag for Steganos
STOOLS=0			;; Flag for S-Tools
	


text1='This program brute forces Steganography programs.'
text2='Including S-Tools v4.0 and Steganos. Do you wish'
text3='to continue?'
;q = AskYesNo('%progname%',"%text1% %crlf% %text2% %crlf% %text3%")
If (AskYesNo('%progname%',"%text1% %crlf% %text2% %crlf% %text3%")  == @NO) Then Exit

text1="It is easiest to make all file settings through the"
text2="S_BRUTE.INI file in this directory. If you do not use"
text3="this file, you will be manually prompted for the files."
Text4="Do you wish to use the INI file?"
q= AskYesNo("%progname%"," %text1% %crlf% %text2% %crlf% %text3% %crlf% %text4%")

if (q  == @NO) Then gosub prompt_for_files
else gosub set_files


if (STEGANOS) 
	gosub steganos
else 
	if (STOOLS) then gosub stools
EndIf

error="Passphrase not found!"
gosub bail_error

Exit



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:steganos                 ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Run("%exepath%", "%stegofile%")
WinWaitExist("",10)        ;;; Steganos' first window has no title. 
			   ;;; If you have problems,
SendKeysTo("","{ENTER}")   ;;; comment out these two lines...
;TimeDelay(10)             ;;; and uncomment...
;SendKey("{ENTER}")        ;;; these two lines.


WinWaitExist("Steganos for Windows 95",30)
SendKeysTo("Steganos for Windows 95","{ENTER}")

dictgrip=FileOpen("%dict%","READ")
fn1="c:\output.txt"
handleout=FileOpen("%fn1%","Append")
stitle="Steganos for Windows 95"
START_TIME=TimeYmdHms()
word=0

while (word != "*EOF*")            
   word = FileRead(dictgrip)
   if word =="" then continue
   if word =="*EOF*" then break
   ClipPut("%word%")
   SendKeysTo(stitle,"^v{ENTER}")
   TimeDelay(STEGANOSDELAY)
   test=strsub(MsgTextGet(stitle),1,22)
   if test=="" 
    text1="I think we have a match!"
    text2="Due to the speed of the brute force attack, check c:\output.txt"
    text3="to see the last few words used, but I think the passphrase is:"
    text4="%word%"
    success="%text1% %crlf%%text2% %crlf%%text3% %crlf%%text4%"
    gosub bail_success
   else
    if test=="This password is wrong"
	   SendKeysTo(stitle,"{ENTER}")
	   SendKeysTo(stitle,"!B{ENTER}")
	   FileWrite(handleout,"%word%" )
    endif
   endif
endwhile
STOP_TIME=TimeYmdHms()

FileClose(dictgrip)
FileClose(handleout)

Return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:stools                  ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Run("%exepath%", "%stegofile%")
if (WinWaitExist("Welcome to S-Tools",5) == @TRUE) 
	SendKeysTo("Welcome to S-Tools","!C")
EndIf

	winplace(0,0,400,400,"~S-Tools")
	WinWaitClose("Please Wait")
	SendMenusTo("~S-Tools", "Window Tile Horizontally")

text1="S-Tools requires certain mouse-only operations."
text2='After clicking OK, position the mouse within your'
text3="image in the S-Tools window and click the left button."

message("Setup mouse for S-Tools","%text1% %crlf% %text2% %crlf% %text3%")

while (mouseinfo(4)!="4")
	magic=mouseinfo(2)
endwhile

magicx=( ItemExtract(1,magic," ") )
magicy=( ItemExtract(2,magic," ") )


dictgrip=FileOpen("%dict%","READ")
fn1="c:\output.txt"
handleout=FileOpen("%fn1%","Append")

START_TIME=TimeYmdHms()
word=0
while (word != "*EOF*")            
        word = FileRead(dictgrip)
        if word =="" then continue
	ClipPut("%word%")

	;;;  write to the output file
	if word!="*EOF*" 
		if (FileWrite(handleout,"%word%" ) >0)
			error="Unable to open file %fn1%."
			gosub bail_error
		EndIf
	Endif
		
	for dumnum=1 to 4      ;; for all the algorithms 
		
	 MouseMove(magicx, magicy, "","")
	 MouseClick(@RCLICK, 0)
	 SendKeysTo("~S-Tools","r")
	 SendKeysTo("~Revealing","!P^v!V^v!E")

	 if (dumnum==1) then SendKeysTo("~Revealing","I")   ;; IDEA
	 if (dumnum==2) then SendKeysTo("~Revealing","D")   ;; DES
	 if (dumnum==3) then SendKeysTo("~Revealing","T")   ;; DES3
	 if (dumnum==4) then SendKeysTo("~Revealing","M")   ;; MDC
	 SendKeysTo("~Revealing","{ENTER}")
	 ;childlist=WinItemChild("~S-Tools")
	 numchilds= ItemCount(WinItemChild("~S-Tools"), @TAB)

	 if (numchilds>2)
	  text1="We have an extra window in S-Tools! Possible passphrase match."
	  text2="Due to the speed of the brute force attack, check c:\output.txt"
	  text3="to see the last few words used, but I think the passphrase is:"
	  text4="%word%"
 	  success="%text1% %crlf%%text2% %crlf%%text3% %crlf%%text4%"
	  gosub bail_success
	 endif
       next

endwhile

FileClose(dictgrip)
FileClose(handleout)        

return



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:set_files                    ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
fname=IniReadPvt("Main", "exepath", ".\S-TOOLS.EXE", ".\S_BRUTE.INI")
gosub path_clean
exepath=fname

gosub determine_tool_type

fname=IniReadPvt("Main", "dict", ".\DICT.TXT", ".\S_BRUTE.INI")
gosub path_clean
dict=fname

fname=IniReadPvt("Main", "stegofile", ".\STEGO.GIF", ".\S_BRUTE.INI")
gosub path_clean
stegofile=fname

STEGANOSDELAY=IniReadPvt("Main","STEGANOSDELAY","0",".\S_BRUTE.INI")

gifname= ItemExtract( (ItemCount("%stegofile%", "\")), "%stegofile%", "\")

Return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:prompt_for_files             ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
msg = "Enter the Steganos error delay 0-60"
STEGANOSDELAY=AskLine("%progname%", msg ,"0")

types="Dictionary Text Files|*.txt|All Files|*.*|"
dict=AskFileName("Select Dictionary Filename", "C:\", types, "dict.txt", 1)
dict=FileNameShort(dict)

types="Steganography tool Executable|*.exe|"
msg="Where is the S-Tools or Steganos executable?"
exepath=AskFileName(msg, "C:\", types, "", 1)
exepath=FileNameShort(exepath)

gosub determine_tool_type

if (STEGANOS)
  types="Stego File (with hidden message)|*.bmp;*.dib;*.voc;*.wav;*.txt;*.html|"
else
  types="Stego File (with hidden message)|*.gif;*.bmp;*.wav|"
endif

text1="Select Stego Filename (containing hidden message)"
stegofile=AskFileName("%text1%", "C:\", types, "", 1)
stegofile=FileNameShort(stegofile)
gifname= ItemExtract( (ItemCount("%stegofile%", "\")), "%stegofile%", "\")
Return







;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:path_clean                   ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
switch FileExist(fname)
	case 0	
		error="File %fname% not found!"
		gosub bail_error
		break
	case (2)
		error="File %fname% in use!"
		gosub bail_error
		break
endswitch
fname=FileNameShort(fname)
Return


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:determine_tool_type          ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
exename=(StrUpper(ItemExtract( (ItemCount("%exepath%", "\")), "%exepath%", "\")))

if (exename == "S-TOOLS.EXE") then STOOLS=1
else if (exename == "STEGANOS.EXE") then STEGANOS=1
Return


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:bail_error                   ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
STOP_TIME=TimeYmdHms()
Message("%progname% Error!","%error%")
SECONDS=TimeDiffSecs(STOP_TIME,START_TIME)
Message("%progname%","Finished in %SECONDS% seconds.")
Exit

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
:bail_success                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
STOP_TIME=TimeYmdHms()
Message("%progname% Success!!!","%success%")
Message("%progname%","Time Started: %START_TIME%%crlf%Time Finished: %STOP_TIME%")
Exit

<-->
<++> sbrute/S_BRUTE.INI
[Main]

EXEPATH="C:\Program Files\Deus Ex Machina\Steganos\Steganos.exe"
DICT="C:\win\desktop\dict.txt"
STEGOFILE="C:\win\desktop\steclouds.bmp"
;STEGOFILE="C:\win\desktop\s-tclouds.gif"
STEGANOSDELAY=0	;; Set this higher for false positives.
			;; (Steganos does not use different names for its
			;; windows, so this program makes negative result
			;; checks (ie bad passwords) based on an error dialog.
			;; This timeout controls how many seconds to wait for 
			;; an error. Default=0

<-->
----[  EOF