                           .-------------------.
                            !Stego !Help file 
                           '-------------------'

Version: 1.3 (5 January 2009)

Author: Nat Queen <n.m.queen@bham.ac.uk>

Primary distribution site: http://www.queen.clara.net/pgp/acorn.html


What does it do?
================

!Stego implements a form of steganography (the process of hiding data in
files which appear to be something totally different). The program hides
messages in sprites, which will be referred to here as 'container sprites'.
These sprites have the appearance of a random texture, like one that might
be used for a backdrop.


Why use steganography?
======================

  "No one shall be subjected to arbitrary interference with his privacy,
  family, home or correspondence..." - Article 12, Universal Declaration of
  Human Rights

Unfortunately, this basic human right is not guaranteed everywhere. 
Sometimes it is even dangerous to exercise it. You might want to use
steganography if your employer, your ISP, or your government forbids the use
of encryption or the transmission of certain types of material. Or you might
want to hide the fact that you are using PGP because you or one of your
correspondents lives in a police state which can put people in prison for
refusing to reveal the contents of encrypted messages.


How to use !Stego
=================

When you run !Stego, a directory window will open, showing two inner
applications, !Hide and !Reveal. These are used for hiding data in a
container sprite or for recovering the data.


!Hide
=====

Run !Hide, and another directory window will open, showing a directory
'DataDir'. Nothing else will happen if that directory is empty.

To hide a text file, put it in the directory 'DataDir' and run !Hide again.
A container sprite in which the message is hidden will be created. This
sprite file, with the special filename '~sprite~', will appear in another
directory 'SpriteDir'. The original text file will disappear. If you want to
keep it, make sure that a copy of it is still present in some other
directory before running !Hide.

The text file to be hidden may contain either an ordinary text message or an
ASCII-armoured PGP message (created with either PGP or GnuPG). In the first
case, special characters with ASCII values above 128 (e.g. characters from
other languages) are allowed. However, ASCII values below 32 will *not* be
processed properly by the program. This means that no attempt should be made
to process binary files in this way.

If you have more than one text file to hide, you can put all of them in the
directory 'DataDir'. Every time you run !Hide, one of the files will be
hidden in a new container sprite. However, each such sprite will be given
the same filename '~sprite~', so that you will have to save each one
somewhere, with a filename of your choice, before generating the next one.

The program automatically detects whether or not the input file contains a
PGP-encrypted message, because PGP messages are treated differently from
ordinary text messages in order to preserve high security. If the program
is used to hide a PGP-encrypted message, the input file should contain only
one such message. If there is more than one, only the first of them will be
encoded in the sprite, and all the others will be ignored. Moreover,
anything before the PGP header (the BEGIN line) or after the PGP footer (the
END line) will be ignored.


!Reveal
=======

To recover a hidden message from a container sprite, run !Reveal. A
directory window will open, showing the directory 'SpriteDir'. Nothing else
will happen if that directory is empty.

Put the container sprite in that directory and run !Reveal again. The sprite
will be deleted, and instead the original text file will appear in the
directory DataDir. The restored text file will always be named 'message'. If
you want to save it somewhere, you can rename it appropriately.  If you want
to keep the container sprite, make sure that a copy of it is still present
in some other directory before running !Reveal.

If you have more than one container sprite to process, !Reveal will process
them one at a time, in the same way that !Hide conceals one text file at a
time in a container sprite.


Some technical notes
====================

If you are seriously concerned about security, it is strongly recommended
that any text files to be concealed by !Stego are first PGP-encrypted. For
this purpose, PGP or GnuPG must be installed in your computer.

A fairly high degree of security is achieved by hiding a PGP-encrypted
message in a container sprite. The PGP header and footer are automatically
stripped from the message before encoding it in the sprite, and they are
restored when recovering the message. This is done to ensure that the
sprite will not reveal certain patterns characteristic of a PGP message. 
The body of a PGP message looks essentially like a collection of random
characters from a certain standard set, and these characters are converted
into certain pixel colours in the sprite. Thus, the sprite will not reveal
any obvious patterns.

A lower degree of security is obtained when hiding an ordinary text message,
since most text messages contain very conspicuous patterns. If the same
simple encoding procedure were used as for PGP messages, these patterns
would show up easily in the container sprite. Therefore, when hiding
ordinary (non-PGP) text messages the program works in a different way, in
order to conceal any patterns to a large extent. The same character may be
encoded as a pixel colour in many different ways, depending on its position
in the message. However, serious cryptanalysis could still reveal the
presence of hidden patterns. Therefore this method provides only limited
security. In fact, it would be a trivial matter for anyone with a copy of
!Stego to extract the message!

Container sprites created by !Stego have a certain standard size (about 8K).
When hiding a PGP message smaller than the size of the sprite, the extra
space in the sprite is padded by giving the relevant pixels pseudorandom
colours from the standard set. Thus, the sprite gives no obvious visual
clues about the length of the hidden message (though anyone who understands
how the program works would be able to discover its length). In the case of
ordinary text messages, however, the pattern generated by the message (which
may be far from random) is simply repeated until the whole sprite is filled.
This produces some very pretty (but innocent-looking) sprites when hiding
short messages.

Messages longer than the standard size of a container sprite can also be
encoded (but their length must still be less than 60000 bytes). In this
case, the sprite filesize simply becomes longer, and the extra characters
are simply ignored if the sprite is viewed by means of !Paint (though
certain other applications capable of viewing sprites may report that the
sprite is corrupted). It should be pointed out that the security is weakened
somewhat when such long messages are hidden.

There may be situations when it would be embarrassing or even dangerous if
anyone discovered that you had certain files in your computer. In such cases
it is desirable to remove all traces of the original data from the disc
after hiding a text file. !Stego does this automatically. Whenever you use
!Hide to conceal a text file in a container sprite, all traces of the
original data are securely wiped from the disc (assuming that you have not
left a copy anywhere else). This is done by means of Sergio Monesi's
powerful utility 'nuke', which overwrites the relevant disc sectors with a
'military' level of security. This is far more secure than ordinary
'deleting', which simply removes the reference to the file in the directory
structure but leaves the data intact on the disc surface until it is
overwritten by other files.


Stealth messages
================

!Stego offers a more advanced option for users who require the highest
possible security. If you need only moderate security, you may safely ignore
this option.

A weakness in the ordinary use of !Stego, as described above, is that anyone
with a copy of the program can easily recover the hidden message from a
container sprite. Of course, if it's strongly encrypted with PGP, no
unauthorised person will be able to read its contents. But what if the
secret police demand that the message be decrypted?

!Stego solves this problem by making it possible for a container sprite to
hide a *second* PGP message, known as a 'stealth message', which is
undetectable by any unauthorised person. A stealth message is encrypted with
an additional passphrase, and the container sprite in which it is hidden has
the same general appearance as one without any stealth message. If any
attempt is made to use !Stego to recover a stealth message with the wrong
passphrase, the program will behave exactly as it does when there is no
stealth message. This provides a strong defence against unwanted snooping.

A further explanation of stealth messages, and how to hide or recover them,
is given in a separate file '!Stealth' inside the main !Stego directory.

Note that a stealth message can be hidden in a container sprite only if the
sprite already hides a PGP message, and if the stealth message is itself
PGP-encrypted. Therefore the option of using stealth messages is available
only to users of PGP or GnuPG.


History
=======

v1.0 - First release (15 June 2000)

v1.1 - Now hides stealth messages; no restrictions on input filenames
       (20 September 2000)

v1.2 - Fixed a bug when hiding very large files (21 September 2000)

v1.3 - Updated the 'nuke' utility - now 32-bit compatible (5 January 2009)


Legal notice
============

!Stego is freeware. The copyright is retained by the author, Nat Queen. 
You may copy and distribute this software freely as long as none of the
files are altered or removed. If you distribute !Stego in any PD library,
magazine cover disc or CD, or on any site on the Internet, please drop a
line about it in my mailbox, so that I can keep you informed about possible
future updates. Any distribution method is allowed, provided that you do not
make any profit from it. This software must not be distributed as part of
any other application without my prior permission.

This software has been thoroughly tested, but no guarantee is given as to
its suitability for any purpose. The author accepts no responsibility for
any data loss, crashes or other undesired effects caused directly or
indirectly by using !Stego.


Thanks to:
==========

Tony Hopstaken, for teaching me some good programming tricks and for helpful
suggestions.

Sergio Monesi, for permission to include his 'nuke' utility in this program.
