HPACK(1)

NAME
hpack — Multi-System Archiver

SYNOPSIS
hpack command [-options] archive [file|@scriptfile]...

DESCRIPTION
The hpack Multi-System Archiver is an archiver that was written to allow the transfer of archived data to different systems. In the past archivers have traditionally been available for single systems only, for example PKZIP(tm) and LHARC for the IBM PC, Larc for the Amiga, StuffIt(tm) and Compactor for the Macintosh, and tar and compress for UNIX systems (while these archivers are available on other systems, their use is not widespread). It is intended to make hpack a more universal archiver by offering versions for the following environments:

Currently Bavarian, Dutch, English, German, Italian, Polish, Spanish, and Swiss German versions of hpack using the ASCII, IBM PC, IBM Codepage 850, IBM Codepage 869, ISO 8859-1 (Latin 1), ISO 8859-2 (Latin 2), ISO 8859-3 (Latin 3), ISO 8859-4 (Latin 4), Macintosh, Mazovia, and NeXTSTEP character sets exist. Anyone wishing to take advantage of these features should read the section HPACK Internationalization below.

Note: This documentation is intended mainly as an alternative to the proper documentation which is in Postscript format. If possible the proper documentation should be used.

INVOCATION
hpack is run with the following command:

hpack command [-options] archive [file|@scriptfile]...

The allowed values of command are:

a   Add files to an archive.
x   Extract files from an archive.
v   Display a directory of files inside an archive.
p   View files within an archive.
t   Test the integrity of an archive.
d   Delete files from an archive.
f   Freshen files to an archive.
r   Replace files in an archive.
u   Update files to an archive.

The allowed options are:

-0  Store files without attempting any compression.
-a  Store file attributes.
-b pathname
    Specify a base pathname for all files.
-c options
    Encryption options (conventional and public-key encryption).
-d options
    Directory options (Mkdir, Rmdir, Mvdir, path options etc).
-e  Add (or use) error recovery information.
-f  Force file move into or out of an archive.
-i  Interactive mode (prompt for all actions).
-k  Overwrite existing archive.
-l  Security options (data authentication)
-m  Create a multipart archive.
-o options
    Overwrite on extraction options (All, None, Prompt, Smart).
-r  Recurse through subdirectories.
-s  Run in stealth mode.
-t  Touch files on extraction.
-u  Unified compression mode.
-v options
    View files options (Files, Directories, All).
-w  Treat files as archive comments.
-x options
    Text file translate options (see below).
+options
    Extended options (usually system-specific, see below).

Commands, options, extended options, and archive and file names may be given in upper or lower case (they are given in lowercase in the examples which follow merely for consistency). Options may be lumped together or may be given separately preceded by the delimiter. The option may be used to indicate that no more options are present on the command line, following the standard UNIX convention. Extended options must be given separately followed by the delimiter.

The default archive extension is hpack will always add this extension (provided the underlying filesystem supports it), changing any other given extension if necessary. Note that some quantum physics theories suggest that when the user is not directly observing the hpack archive, it may cease to exist or will exist only in a vague and indeterminate state; in this case the existence of the extension cannot be guaranteed.

The filenames field may consist of zero or more filenames, defaulting to all files if no filenames are given (in other words archive all files in the current directory, or dearchive and view all files in the archive). hpack uses UNIX-style wildcards (which are described in more detail in the section HPACK Wildcards below), as well as UNIX-style pathnames in place of the usual ones used by the systems' command interpreter, so that for example the path:

is used instead of the MSDOS equivalent:

or the VMS equivalent:

or the Archimedes equivalent:

If any additional components are needed, such as drives, network nodes, or devices, these can be specified in the manner usual to the host command interpreter. For example if the path in the above example were on drive under MSDOS the pathname would be:

If the path in the above example were on the node, on device under VMS, the pathname would be:

The scriptfiles are names of files preceded with an character. When hpack encounters one of these it will treat the filename as a file containing a list of files to process. Script files and normal filenames may be freely mixed on the command line. See the section HPACK Script Files below for more information.

HPACK Wildcards

When hpack scans any filename that has been given to it, it will check for the presence in the filename of any of the special characters:

If one of these is detected, then the string of characters making up the filename will be treated as being a pattern for a filename, rather than the name of a specific file. These special characters have the following meanings when used in a filename string:

Matches zero or more characters

Matches any one character

Matches any of the enclosed range of characters
    in turn. If two characters appearing in the pattern in alphabetical order are separated by a dash then any character in the alphabetic range between these two characters will be matched. This is a more selective version of the form.

As above, but this time matches anything
    not in the enclosed range of characters

Treat the next character as a normal character
    rather than one of the special characters. This can be used to override the usual meaning of the and characters. Note that the Atari ST, MSDOS, and OS/2 versions of hpack uses instead of since the command interpreter uses in its pathnames.

The case-sensitivity when handling filenames depends on the operating system hpack is being run under. On the Atari ST and under MSDOS and VMS, filenames are converted to uppercase, but are not case-sensitive; on the Amiga, Archimedes, Macintosh and under OS/2, filenames are left as is, but are also not case sensitive (so that will match and and under UNIX, filenames are left as is, and are case sensitive, so that and are treated as separate names.

These wildcards can be combined to create quite powerful expressions. For example, to match any filename not beginning with an or and containing at least two characters, the required expression would be:

where the would match anything but or the would match the second character required, and the would match any remaining characters.

For example, if we have an archive whose contents are:

we could perform the following file matches on it:

Expression
    Matches files

Finally, note that these wildcards may not perform quite like the standard wildcards used by the system's command interpreter. For example under GemDOS, MSDOS, and OS/2, to specify all files in a directory or archive, it is not necessary to use the usual sequence of Instead simply typing will match all the files in the archive (the DOS-like wildcards are in fact a bit of a hack — for example will (incorrectly) match The extended wildcards act as true wildcards, so that will not match as it would under DOS, since there is a spurious in the DOS wildcard matching.

These extended wildcards can be useful when extracting files whose names cannot normally be handled by the command interpreter. For example, to extract the file from the archive you would type:

where the wildcard will match the spaces. Alternatively you can just type:

which will usually do the same thing with a lot less typing involved.

Another point is that these wildcards cannot be used to represent full regular expressions (the idea behind hpack was to create an archiver, not a regular expression parser), so that, for example, will not work as an expression, and that they can only be used inside pathnames when the path is inside the archive (since the extended wildcards are built on top of the usual operating system ones (if they exist) the resulting system would run very slowly if they had to be simulated on an external filesystem).

Using wildcards for pathnames inside archives is perfectly legal. When matching wildcards to pathnames, hpack follows the standard convention of matching the directory contents if the directory name is given, or matching the directory itself when a wildcard matching it is given. Consider an archive with a subdirectory with both the archive root directory and the subdirectory containing files. Then the following wildcard matches could occur:

Match all files and directories in the root directory

Match the directory
    (and possibly other files) in the root directory.

Match the contents of directory
    (equivalent to

Match all files and directories (equivalent to using
    with the [-r]ecurse option).

Unlike most filesystems, hpack has no notion of a ``current directory'' within an archive, so all pathnames must be given relative to the archive root directory.

Finally, UNIX users may have to either set the shell variable (csh) or quote the wildcard characters used to prevent them being expanded by the shell if it is required that hpack handle wildcard expansion. One case in which this is necessary is when recursively adding files in subdirectories which match a certain filespec to an archive. The command

exposes the filespec to shell wildcard expansion. The shell will try to match all the files in the current directory whose names end in and it will not try to match any files in subdirectories. In contrast:

will cause hpack to perform the wildcard expansion, and will correctly add files in subdirectories. Some shells provide other ways to turn off their wildcard expansion. For instance, csh user can do the following:

and ksh users can do the following:

HPACK Commands

a   Add files to an archive. The archive given in the command-line is opened, or created if it doesn't already exist, and is given the extension if this is not explicitly specified. Then all files given in the list of filenames are added to to it.

    Example: To add all files in the current directory to the archive in the current directory:

x   Extract files from an archive. All files are extracted from the archive given in the command line to the current directory. If the file already exists and no overwrite options are given (these are explained in the section HPACK Options below), you will be asked if you wish to overwrite it:

    The answer will replace the file with the file from the archive, will skip the extraction of this file, and will process all files from this point as if a answer was given for each file. In some cases the name of the file extracted will need to be translated to allow for the naming conventions of different operating systems. In these cases the original name will be printed, followed by the name it will be extracted under.

    On Apple systems data is divided into two sections in a file, a ``data fork'' and a ``resource fork''. Under non-Apple operating systems only the data fork will be extracted from an archive: the resource fork (which only Apple systems can make any use of) will be skipped.

    Example: To extract all files in not beginning with an to the current directory:

v   Display a directory of files inside an archive. If no view options are given (these are explained in the section HPACK Options below), a listing in the following format is produced: HPACK - The multi-system archiver Version 0.79a0 (shareware version) For Amiga, Archimedes, Atari ST, Macintosh, MSDOS, OS/2, and UNIX Copyright (c) Peter Gutmann 1989 - 1993. Release date: 1 May 1993

    Archive is 'ARCHIVE.HPK'

    System Length Size Ratio Date Time Name ------ ------ ------ ----- -------- -------- -------------------------
     MSDOS 18537 6217 66% 04/05/90 11:32:48 README.TXT
     Atari 8301 3169 74% 27/12/90 21:02:39 LZSS.EXE
     UNIX 30061 9127 70% 24/11/89 16:52:57 compr.method.txt
     OS/2 8481 3282 61% 22/12/90 08:58:52 Comp.test
      Mac 0 0 0% 01/07/91 18:20:20 Fast LZ Decoder using B.. ------ ------ ------ ----- -------------------------
            65380 21795 67% Total of 5 files

    Done

    The archive used is displayed, followed by a list of all the files within the archive. The fields for each file inside the archive are as follows:

    The system the file was archived under.

    The length of the file when unarchived.

    The size of the compressed file within the archive.

    The ratio of the compressed file to the uncompressed file.

    The creation date of the file within the archive.

    The creation time of the file within the archive.

    The name of the file within the archive.
        If the name is too long to fit on the screen then a is appended to indicate this. In addition files may have a single character prepended to them: an asterisk before the name indicates that this file has been encrypted, a dash indicates that it includes authentication information, and a hash indicates that it is both encrypted and includes authentication information.

        Note that the name within the archive may not be the same as the name given to the unarchived file since translation may be necessary to allow for the naming conventions of different operating systems.

        Note also that in the example above the file originating on the Macintosh has a length of zero bytes. This does not necessarily mean the total data size is zero bytes, since files originating on Apple systems have a second block of data called a resource fork which contains code and other program resources. These resources are only useful on Apple systems and are not shown as part of the total file size on other systems.

    Finally the total length of all files within the archive, uncompressed and compressed, the overall compression ratio for the archive, and the number of files within the archive, is given. If any filespecs are given, only files which match those filespecs will be displayed. This is useful when you only want to extract certain files and would like to see how much space they will use.

    If more than one archive is viewed, a grand total of the size and number of files in all the archives viewed is printed. The type of information printed may be controlled by using the view options (which are explained in the section HPACK Options below). The default is to print all files and directories in the root directory of an archive. If the root directory contains no files or directories matching the given filenames and/or wildcards, the error message will be printed. To recursively display the contents of all subdirectories, either the [-r]ecurse subdirectories option or the wildcard string should be used.

    Example: To view the contents of any archives in the current directory

p   View files within an archive. This option will output the contents of one or more files within an archive, with a prompt for more between files. The output can be redirected in the standard manner, for example:

    will send the file from within the archive to the printer, and:

    will display the file with page breaks on your screen. Note that trying to display non-text files in this manner can be interesting, if not terribly productive.

    Example: To display the file from within the archive

t   Test the integrity of an archive. hpack will display the usual messages about extracting data as it unpacks and tests the data, and if it thinks the data has been corrupted it will issue the following warning message:

    Otherwise hpack will display:

    If, when all files have been tested, there were corrupted files, hpack will print the total number of corrupted files:

    where n is the number of corrupted files.

    Note that this test is also performed automatically on extracting a file from an archive.

    Example: To test the integrity of all MSDOS executable files in the archive

d   Delete files from an archive. All files given in the command-line are deleted from the given archive.

    If all files are deleted from an archive (leaving an empty archive), hpack will delete the archive as well.

    Example: To delete all Pascal program files (a commendable move) from the archive

f   Freshen files in an archive. The dates of all specified files in the archive are compared with the dates of the same files on disk. If the version on disk is more recent than the stored version, the stored version is replaced by the version on disk. If all files in the archive are uptodate, hpack will display the message:

    and exit.

    Example: To freshen all files in the archive

r   Replace files in an archive. All given files in the archive are replaced by their counterparts on disk.

    Example: To replace all the files which begin with the letters a-g in the archive with their couterparts on disk:

u   Update files to an archive. All specified files not already in the archive are added to the archive, and all files already in the archive are replaced if the version on disk is more recent than the version already in the archive.

    Example: To update the archive with all files from the directory

    Note that the last four options need to create temporary work files on disk. Thus it is necessary to have at least twice as much free disk space to work with as the total length of the archive. All other options use only the archive file, so it is possible to use them with minimal free disk space.

HPACK Options

-0  Store files without attempting any compression. This option can be used to quickly add incompressible files to an archive or when breaking up a large file to move to another system via a multidisk archive when space isn't at a premium.

-a  Store file attributes. Many operating systems support two levels of files, those classed as ``normal'', and those classed as ``hidden'', ``invisible'', ``system files'', and so on (for example the Macintosh, MSDOS, and the Atari ST all have these file types). By default hpack will only add normal files to an archive. However using the [-a]ttributes flag allows archiving of files with special attributes as well as full restoration of attributes when archives are extracted. The [-a]ttributes flag is also necessary under some operating systems to store extra information pertaining to a file, for example access control information, file and directory type information, icons, and so on.

    hpack will attempt to translate the attributes of files from different systems into equivalent file attributes for the local system. This has varying degrees of effectiveness: Many of the Apple IIgs, Atari ST, Macintosh, MSDOS, and OS/2 attributes are equivalent so a direct translation is possible, and the Amiga, the Apple IIgs, the Archimedes, UNIX, and VMS also have some of the read/write attributes in common, and have a rough equivalent of a read-only file attribute in these attributes.

    If directories were stored within the archive, hpack will also store directory attributes, and set the directory attributes to the stored values when creating the directories on extraction.

    Example: To extract all files in the root directory of the archive restoring all possible attribute information:

-b  Specify a base pathname for all files. This option is followed by the pathname which hpack will use as a base path for all files to be added to or extracted from an archive. This option is very convenient when adding a number of files in the same directory to an archive or when extracting an archive to a directory which is not the same as the current directory. It is also useful for handling archives which contain subdirectories. To add files to a subdirectory within hpack, the base pathname is used to specify the path to the subdirectory, with the actual file pathname given being the path inside hpack in which the file will be stored. In this case the argument given with the [-b]ase path option is the part of the pathname outside the archive, and the file pathname is the part of the pathname inside the archive.

    Example: To extract all files in the archive to the directory

    Example: To add the files and all in the directory to the archive

    Example: To add the files in to the archive inside the archive directory

-c  Encryption options (conventional and public-key encryption). Encrypt/decrypt archive data using a selection of public- and conventional-key encryption algorithms. Using this option with conventional-key encryption will prompt for a passphrase before any files are added, followed by a request to retype the passphrase for security if the data is being encrypted. This passphrase, which is not echoed to the screen, should be a minimum of eight and a maximum of eighty characters long, and may contain any combination of upper and lowercase letters, numbers, spaces, punctuation symbols, and control characters. If public-key encryption is used, the userID of the recipient of the data is specified as part of the encryption command. Although hpack itself will support non-ASCII text strings, the userIDs for public keys must be in ASCII format for compatibility with other programs. Be warned that forgetting or losing a conventional or public-key encryption key will present you with a fairly substantial exercise in cryptography.

    By default hpack will encrypt entire archives (rather than just the files in them), meaning that not even the archive directory can be read by someone who does not have the decryption password.

    The encryption options are divided into two classes, those employing conventional-key encryption and those employing public-key encryption:

    -c  Use conventional-key encryption to encrypt the entire archive, the same as [-c]rypt [a]ll.

    -ci Encrypt individual files using conventional-key encryption. The use of this option is not generally recommended as it is not quite as secure as the standard [-c]rypt [a]ll option. It is however useful when only a few files need to be encrypted, the rest being subject to constant change which makes encrypting them impractical.

    -ca Encrypt entire archive. This will encrypt not only the files themselves but all additional data associated with them (attributes, icons, and so on), as well as the archive directory information. The only remaining accessible data is a small amount of archive identification information needed to allow hpack to process the archive.

    -cs Prompt for second password to access archive data. This allows the archive directory to be encrypted with one password, and files to be encrypted with another password. This option is useful if it is desirable to give a group of users access to the archive directory but not to the files themselves, since the contents of the archive can be made available with the first password, but a second password is required to access the files themselves.

    -cpi<userID>
        Encrypt individual files using the public key which matches the given userID. The public-key-encryption equivalent of the [-c]rypt option. This option is not recommended if more than a small number of files are present in an archive due to the amount of time needed to perform each public-key decryption calculation.

    -cpa<userID>
        Encrypt the entire archive using the public key which matches the given userID. The public-key-encryption equivalent of the [-c]rypt [a]ll option.

    -cps<userID>
        Encrypt the archive with a secondary public key which matches the given userID. The public-key-encryption equivalent of the [-c]rypt [s]econdary option.

    When processing an encrypted archive, all that is necessary is to tell hpack to handle encrypted data by specifying the [-c]rypt option. hpack will determine the encryption type and prompt for passwords as necessary as it processes the archive. If the archive is public-key encrypted and the recipients secret key is protected by encryption, hpack will prompt:

    If an incorrect password is given, hpack will warn:

    and allow the password to be reentered. Up to three attempts at the password are allowed before hpack gives up.

    When searching for the key corresponding to a given userID, hpack will perform a case-insensitive match of the given userID against any part of the keys userID. This means that only a partial userID need be given on the command line, and hpack will use the first key for which the partial userID matches. This makes specifying the userID easier since the entire userID need not be given, but also means care should be taken if there are several similar userIDs (all of which may match a certain userID fragment) in a collection of keys. In all cases these userIDs act exactly like they do in PGP.

    If there is a chance that the userID is ambiguous, the key can also be specified by its keyID using the standard C programming language format for hexadecimal values, namely a prefix of and then the value itself. The keyID is the 6-digit hexadecimal value displayed for the key. As with userIDs, hpack will perform a case-insensitive match against any part of the full keyID.

    hpack will also allow the public-key encryption of data for multiple recipients, meaning that a single encrypted archive can be sent to an arbitrarily large number of recipients. This allows archives to be distributed to working groups or via mailing lists without necessitating a separate encrypted archive for each recipient. Note that there is a slightly increased risk involved in this process since the chain of intended recipients is only as strong as its weakest link — only one of the private keys needs to be compromised to render the encrypted data insecure.

    The use of encryption for multiple recipients is specified by enclosing a comma-seperated list of recipient userIDs or keyIDs inside a key-or construct:

    On decryption, the data can be decrypted by user1 or user2 or ... userN. Future versions of HPACK will also allow key-and (where all of a given list of keys must be used to decrypt data) and key-quorum (where a certain proportion of a given number of keys must be used to decrypt data).

    In addition there are moves afoot to add a mailing-list capability to the public keyring format which will be fully supported by hpack if it eventuates.

    Example: To encrypt the entire archive leaving only a small amount of identification information readable:

    Example: To encrypt all files to be added to the archive

    Example: To encrypt the entire archive with the archive directory readable by but the archive data itself only readable by

    Example: To encrypt the file in the archive with the key corresponding to the hexadecimal keyID A72F3B, taking advantage of the fact that hpack will match any fragment of the keyID:

    Example: To encrypt the entire archive making it readable by either or

    Note that the public-key decryption process can take a long time, especially when it must be performed multiple times (for example when the [-c]rypt [p]ublic-key [i]ndividual files option is used). hpack will display the message:

    whenever it performs the calculations involved in public-key decryption. This process can often take significantly longer than one moment — on slower machines hpack may appear to have ground to a halt as it performs the public-key decryption operation. Unless there is a special need for it, the use of conventional-key encryption is recommended.

    One advantage of public-key encryption is that the key management is automatic — there is no need to enter passwords to perform the encryption and decryption operations. When passwords must be entered manually for conventional-key encryption, there is a chance that an incorrect password will be entered by mistake. If this happens for archive directories, hpack will warn:

    Since the password was incorrect, the archive directory information has been decrypted incorrectly. The option should be selected and the password reentered.

    If this happens for archived files, the files will not be extracted properly:

    Again, the password should be reentered when hpack is re-run.

-d  Directory options. This hideously complicated command has a large number of suboptions. Normally hpack will store any directories it finds files in inside an archive, in effect allowing you to archive entire directory trees. These directory options allow more precise control over the storing of directories inside the archive.

    hpack will add directories traversed only if there are files contained in them. To add all directories regardless of whether they contain files or not, use the [-d]irectories [a]ll option (see below).

    The extended directory options are are as follows: (Note: Some of these aren't implemented yet: Feedback on whether this way of doing things is a good idea or not would be appreciated.)

    -da Store or extract all directories scanned, even if they contain no files. This option is useful for storing entire filesystems inside archives and restoring entire directory trees from archives.

    -dc Create only immediate containing directory for a group of files, not the entire directory path. This is mainly for use by GUI versions of hpack to allow extraction of individual directories, folders, or drawers (depending on what the host operating system calls them) of files.

    -df Flatten directories. This option can be used to prevent hpack from storing directories, so that all files added or extracted are placed in the same directory, in effect flattening the directory structure.

    -dm Mkdir: Create the given directories. (Not yet implemented — if necessary this can be faked by using where path is the new directory to add and the non-matching filespec ensures that only the new directory, but none of the files in it, are added.)

    -dn Do not create the directory inside the archive if it doesn't already exist. If an attempt is made to add a file to a nonexistent directory, hpack will exit with the error message:

    -dr Rmdir: Delete the given directories. (Not yet implemented)

    -dv Mvdir: Move the given directory into the second given directory.
        Warning: Through injudicious use of this command it is possible to create circular directory references, or to cut off entire directory trees. Do not try to move directories into subdirectories of themselves! (Or should hpack check for this?) (Not yet implemented)

    Example: To delete the directory inside the archive

    Note the use of the [a]dd command as a dummy command: In this case the main command is ignored and only the directory option is used (ICK!).

    Example: To move all files and directories in and below in the archive into the directory

    Example: To add all files and directories (even empty ones) in and below the current directory to the archive

-e  Add (or use) error recovery information. This option allows the adding of error recovery information to the archive when adding files, or makes use of error recovery information present in an archive. hpack will write extra information with the file data which may be used to recover the data if the main archive directory is seriously damaged. This recovery information will increase the amount of data stored for each file by about 20-25 bytes. Note that although hpack will add this extra information, the current version will not make use of it.

    Example: To add all text files in the directory to archive adding error recovery information for each file:

    Example: To extract the same files from the archive, making use of the error recovery information:

-i  Interactive mode — prompt for all actions. This option works for all commands except [v]iew files (for which it would be pointless). Before the file is processed, hpack will ask whether you wish to process this file; answering will handle the file, will skip the file, and will process all files from this point (in other words it will assume a answer for each file from this point).

    Example: To add all files in the current directory to the archive prompting for each file before adding it:

-f  Force file move into or out of an archive. This option can be used with the [a]dd, [f]reshen, [r]eplace, [u]pdate, and [x]tract commands to move the files instead of merely copying the data into or out of an archive. Note that when the move option is used in conjunction with encryption, hpack will go to extreme lengths to destroy any traces of the file which is being moved. Caution is recommended when using move with encryption as forgetting the password or using the wrong public key will lead to the permanent loss of the encrypted data.

    If all files are moved out of an archive (leaving an empty archive), hpack will delete the archive as well.

    Example: To move all text files from the archive into the current directory:

-k  Overwrite existing archive. This only works with the [a]dd command. Normally, using the [a]dd command will add any new files to the end of an existing archive. Using the [-k]ill switch will erase the old archive and create a new one.

    Example: To create the archive on drive overwriting it if it already exists, and add all files in the current directory to it:

-l  Security options (data authentication). This option allows the encapsulation of either entire archives or individual files inside a secure envelope which it is computationally infeasible to break. This option allows anyone to later determine that the data has been both untampered with, and genuinely came from the source (corresponding to the userID) from which it claims to have originated.

    When searching for the key corresponding to a given userID, hpack will perform a case-insensitive match of the given userID against any part of the keys userID. This means that only a partial userID need be given on the command line, and hpack will use the first key for which the partial userID matches. This makes specifying the userID easier since the entire userID need not be given, but also means care should be taken if there are several similar userIDs (all of which may match a certain userID fragment) in a collection of keys. In all cases these userIDs act exactly like they do in PGP.

    If there is a chance that the userID is ambiguous, the key can also be specified by its keyID using the standard C programming language format for hexadecimal values namely a prefix of and then the value itself. The keyID is the 6-digit hexadecimal value displayed for the key. As with userIDs, hpack will perform a case-insensitive match against any part of the full keyID.

    If the secret key is protected by encryption, hpack will prompt:

    If an incorrect password is given, hpack will warn:

    and allow the password to be reentered. Up to three attempts at the password are allowed before hpack gives up.

    The security options are as follows:

    -l<userID>
        Secure the entire archive with security information from a given userID.

    -li<userID>
        Secure individual files rather than the archive as a whole, with security information for a given userID. The use of this option is not generally recommended since the generation of the security information for each file can consume a considerable amount of time, and since only the files themselves are secured it leaves the file attributes and directory information open to modification. It is however useful when only a few files need to be secured, the rest being subject to constant change which makes securing them impractical.

    Example: To create the archive add all files in the current directory to it, and secure it on behalf of your cat:

-m  Create a multipart archive. Normally when hpack runs out of disk space it will exit with an error message. When this option is used hpack will instead prompt for another disk and continue the archive on the new disk. In this manner it is possible to spread an archive which would be too large for a single disk over several disks. Due to their rather special nature, multipart archives do not support the [d]elete, [f]reshen, [r]eplace, or [u]pdate commands (since, for example, deleting a file from the middle of an archive which stretches over 15 disks would be quite time-consuming). All other operations are supported however.

    Example: To fully back up hard drive onto drive

    This will create the archive on one or more disks in drive containing the complete contents of the drive (the options used are [-k]ill existing archive, [-m]ultipart archive, store file and directory [-a]ttributes, [-r]ecurse through all subdirectories, for [-d]irectories store [a]ll of them, even empty ones). Once each disk has been completely filled, hpack will prompt:

    followed by the message:

    as it continues the archive on the next disk inserted. Note the use of the [-k]ill existing archive option to overwrite any existing archive of the same name which may already exist on the disk — if hpack finds an archive of the given name already on the disk and the [-k]ill option is not specified, it will not, by default, overwrite it but will exit with an error message.

    Multipart archives have a minimum size of around 500 bytes (roughly the size of a disk sector for many disk formats — storing archive parts of less than 500-odd bytes would be pointless). If a section of a multi-part archive is less than approximately 500 bytes hpack will skip it and move it to the next (hopefully less full) disk after printing the following warning:

    If a multipart archive is small enough to fit onto a single disk, hpack will store the archive as a standard archive instead of a multipart one.

    Example: To view the files in the previously created multipart archive:

    hpack will automatically determine whether the archive is a multipart archive or not so the [-m]ultipart command is only necessary when creating the archive. Since hpack stores its directory information at the end of the archive, only the last disk or disks of the archive must be read to obtain the archive directory. Initially hpack will prompt:

    If the wrong disk is inserted, hpack will prompt:

    where n is the part number of this section of the archive.

    Example: To extract the single file from the previously created archive:

    hpack will then prompt for the disk which contains the file

    where n is the part number of the archive section which contains

    Example: To fully restore the contents of a hard drive from the previously created archive:

    hpack will prompt for the last part of the archive as usual and then for each disk in turn as it extracts the files from the archive.

-o  Overwrite on extraction options. Normally when hpack tries to extract a file which already exists, it will prompt for whether the existing file should be overwritten or not. With this switch it is possible to specify a default action to be taken. There are four possibilities:

    -oa Automatically overwrite [a]ll existing files on extraction.

    -on Automatically overwrite [n]one of the existing files on extraction.

    -os [s]mart overwrite. hpack will change the extension of the file to be extracted to and try to extract this file. If a file of this name already exists, the extension will be changed to and so on until it is possible to extract the file. This option is very useful for files that have been archived on a system which allows filenames which are longer or more complex than those allowed by the local system and which due to the filename being truncated or translated end up with identical names. Note that the term ``extension'' can mean different things to different operating systems — hpack will do its best to use the local equivalent.

    -op [p]rompt for new filename. hpack will ask for a new filename and try to use that name, repeating until a non-conflicting filename is given.

    Example: To extract all files from the archive to the current directory, skipping any files that already exist:

-r  Recurse through subdirectories. hpack will step through all sub-directories of the current directory, and add all files with names matching those given on the command line.

    Example: To add all files in all directories in and below the current directory to the archive

-s  Run in stealth mode. All messages except warnings and error messages are suppressed. hpack will automatically turn on stealth mode if it detects it is running in the background on operating systems which support background operation.

    Example: To add all files in the current directory to all archives in the current directory, without printing the usual progress reports to the screen:

-t  Touch files on extraction. Normally hpack will give all files and directories extracted the original date they had when they were archived. Using the [-t]ouch option will give files and directories the current date.

    Example: To extract all files from the archive giving them todays datestamp:

-u  Unified compression mode. In this mode hpack will attempt to achieve increased compression by using unified compression across all files to be added. This is especially effective when many generally similar files or many small files are being added to an archive. The disadvantage of unified compression is that the archive cannot be updated or changed later, and that when extracting individual files there is a slight speed penalty as intervening files are skipped. Unified compression is ideal for storing data like Usenet news articles, collections of icons, and program source code, in which cases significant compression gains are usually seen.

    Example: To all all files in to the archive using the unified compression mode:

-v  View options. Normally when the [v]iew command is used, hpack will print information on all the directories and files in an archive. With these options it is possible to specify which parts of the archive directory are to be viewed. There are three possible options:

    -vf Display information only on matching files.

    -vd Display information only on matching directories. This option is sexually transmitted.

    Example: To print all the files, but not any directories or subdirectories, in the archive

-w  Treat files as archive comments. This makes the [a]dd, [d]elete, [f]reshen, [r]eplace, and [u]pdate commands work for archive comments instead of normal files. Archive comments are files which are displayed when the [v]iew archive command is used, and may contain text describing the contents of the archive, ANSI extended characters, graphics, digitised sound, even full motion video with 16-bit stereo sound if desired. Most CLI versions of hpack will currently only handle the displaying of plain text, although some will handle ANSI-text type archive comments as well. Comments can be added, deleted, replaced, and so on just like normal files. Subdirectories can contain their own comments, and each directory can contain multiple comment files. In addition comment filenames are not treated as normal archive filenames, so a directory can contain a comment file and a normal archived file of the same name. Possible archive comment types are:

    -w  Plain text comment. This can be entered in free-form since hpack will automatically word wrap the text to fit the screen size. Plain text comments may also contain formatting commands which control the way the text is displayed. For more information on formatting the text comments, see the extended documentation file

    -wa ANSI text comment. This type of comment can contain the extended 8-bit character set used by IBM PC's, as well as ANSI escape codes. No reformatting of any type is done on ANSI comments. Note that the plain text comment type is preferred, since many systems cannot display the extended ANSI character set or interpret ANSI escape codes. Also note that if an ANSI comment is stored as plain text hpack will quietly delete all extended characters and ANSI escape codes when it displays the comment, to make it conform to the 7-bit ASCII character set.

    -wg GIF format graphics comment. Display of this comment format is generally only suported on systems running graphics-based user interfaces.

    Example: To view all comment-type files in the archive as files instead of displaying them as comments:

-x  Text file translate options. Different systems store text files in different formats, for example on the Amiga, the Archimedes, and under UNIX, these are stored in ASCII format with a linefeed at the end of each line; on the Atari ST and under MSDOS and OS/2, there are carriage return/linefeed pairs at the end of each line; and on the Macintosh, there are carriage returns at the end of each line. Some systems store text in a non-ASCII format altogether, for example IBM systems which use the EBCDIC character set, and Prime systems which use their own bizarre text encoding technique. Using this option it is possible to specify translation of different character systems and end-of-line markers to the one used by the local system. In most cases the [-x]late option will suffice, however it is possible to override the translation using the following options:

    -x  Smart translate. hpack will attempt to translate all files it recognises as text files from the textfile format used on the system the file was archived on to the textfile format used on the system the file is being extracted on. In most cases this option will be the only one necessary.

    -xr Treat carriage return (ASCII 13) as end-of-line marker. The Macintosh stores text this way.

    -xl Treat linefeed (ASCII 10) as end-of-line marker. Text on the Amiga, the Archimedes, and UNIX systems is stored in this manner.

    -xc Treat carriage return/linefeed pairs as end-of-line marker. The Atari ST, MSDOS and OS/2 store text files like this.

    -xxnn
        Treat the one- or two-character hexadecimal value n or nn as the character to use as the end-of-line delimiter. For example when moving textfiles from a QNX 2.x/3.x system (which uses the RS character, ASCII 30 or 1E hexadecimal), the option would be -xx1e.

    -xe Translate the character set from EBCDIC to ASCII. Text on IBM systems is stored this way.

    -xp Translate the character encoding from that used on Prime systems to ASCII.

    -xa Translate from ASCII to ASCII.

    The textfile translation works by first translating entire character sets (either ASCII, Prime ASCII or EBCDIC) if necessary, and then translating the end-of-line characters, depending on the options specified.

    The end-of-line translation options are only available where they would make sense (for example the ability to translate linefeed to linefeed isn't particularly useful). The possible translation options are shown below, with LF being the linefeed character, CR being carriage return, and CRLF being carriage return/linefeed pairs:

    Archimedes	|	CR→CRLF	Archimedes	Macintosh
    	To →	|	Atari ST	Amiga	Macintosh
    		|	MSDOS	Archimedes
    	From	|	OS/2	UNIX

    	Atari ST	|	 	-xc	-xc
    	MSDOS	|	---	CRLF→LF	CRLF→CR
    	OS/2	|
    		|
    	Amiga	|	-xl	 	-xl
    	Archimedes	|	LF→CRLF	---	LF→CR
    	UNIX	|
    		|
    	Macintosh	|	-xr	-xr
    		|	CR→CRLF	CR→LF	---

    Example: To extract all files with the extension from the archive translating linefeed characters into whatever end-of-line character the local system uses:

    Example: To extract all files with the extension from the archive translating the files from EBCDIC to ASCII, and translating all carriage return characters to the end-of-line character used by the local system:

HPACK Extended Options
The extended options supported by hpack are usually somewhat system-specific and in general will only be present on one particular version of hpack. They either support the storing or extraction of system-specific information in archives, or the special handling of data which has been archived on another system. The recognised options are:

    +devcheck
        MSDOS version only. Check all files for [s]afe extraction. MSDOS has a serious problem in that when a file with the same name as a device driver is extracted (for example or it will force the contents of that file into the device driver. The damage can be minor for devices like (it will at a minimum mangle the system date and time, perhaps scramble the CMOS ram, or cause the system to hang — even the changing of system dates can cause problems on a system running a computer bulletin board which relies on correct timestamps), all the way through to very serious for devices like (it will corrupt the disk cache and therefore corrupt the drives being cached).

        The +devcheck option will check each file before extracting it, and if it corresponds to a device driver will print the warning:

        and move on to the next file. The only way in which hpack will allow a file of this type to be extracted is by using the [-o]verwrite [p]rompt option, in which you will be prompted for a new filename to extract under. Even [-o]verwrite [s]mart is unsafe since the peculiar handling of device drivers by DOS makes the automatic substitution of a new filename very difficult.

        Filenames which can cause these problems are virtually unheard-of — they would have to be created deliberately by a malicious user, in which case there are few limits on the potential damage they can cause.

    +invert
        Archimedes version only. ADFS doesn't support extensions to filenames since dots are used as directory delimiters, which can lead to problems when moving, for example, source code files ending with the traditional and to the Archimedes. Many programs allow a workaround where the file is accessed as This option allows this form of inversion of the filename and directory structure so that and would be extracted as and This command usually invokes an intense sense of disbelief in non-Archimedes owners.

        Incidentally, non-Archimedes owners may wonder what the Archimedes uses in place of a in filenames. It uses a of course.

    +lower
        Amiga, Archimedes, OS/2, Macintosh, and UNIX versions only. Force all file and directory names to lowercase. Some systems store file and directory names in uppercase only. Using this option all names will be converted to lowercase before any operations (such as [v]iew archive, [x]tract from archive, and so on), are performed on them. When processing Atari ST, MSDOS, and some OS/2 archives, the use of the +lower option is recommended.

    +noext
        By default HPACK will force an extension of (where the operating system allows it) to be added to the archive name, with any existing extension being replaced by This option allows the default behaviour to be overridden so that no extension is added or changed. However this lack of an extension will force hpack to work much harder in deciding what is and isn't an hpack archive, and will disable certain features such as its ability to automatically pick out hpack archives when simply told to process all files in a directory. This option is mainly for use with automated mail-processing software such as Fidonet mail unpackers which depend on the extension for information on the packet contents.

    +noumask
        UNIX version only. Normally the setting of the umask environment variable affects the attribute bits of any files and directories hpack creates. This option overrides the umask setting and uses the attributes stored within the archive. Since these attributes can be set to allow outsiders read/write access to files and directories which would normally be off-limits to them, this option should be used with care.

    +rsx
        VMS version only. Normally VMS files can have 39 characters of filename and 39 characters of extension, or type. This can lead to strange-looking filenames when they are truncated from operating systems which allow longer or more flexible names. Using this option truncates filenames to an RSX-11 compatible format, which results in more traditional-looking names with 9 characters of filename and three characters of file type, and directory names with 9 characters of filename.

    +select <select-statement>
        Apply an SQL select command. This option is explained in more detail in the section HPACK SQL Commands in the extended documentation.

    +type<type-association>
        Archimedes, Apple IIgs, and Macintosh versions only. Some operating systems store file type information for each file. hpack will, when extracting files, try to determine the type information for each file and set it correctly. However in some cases no type information can be determined, or the determined information may be incorrect. This option can be used to set type information for a file, or to override hpack's internal type-determining rules.

        Type information is given as a type-association, associating a file extension with whatever type information the OS requires, and is given in the form:

        For example to associate the Macintosh ThinkC source file type with the extension the type argument would be corresponding to the ThinkC file type and creator type.

        Example: To associate the extension on the Macintosh with the ThinkC source file type:

        Example: To associate the extension on the Archimedes with the GIF file type:

        The types given above are actually already part of hpack's default rule set for type associations, but can be overridden with the use of the +type option if desired.

HPACK Archive Integrity
hpack checks the integrity of files stored within an archive by encoding a continuous checksum as part of each file when it is archived, and decoding it as the file is extracted. As soon as an error is encountered, hpack will skip over the rest of the file and move on to the next one. If the file checksums differ then it may be reasonably assumed that there is an error in the extracted data. This is important: The entire physical universe, including hpack itself, may one day collapse back into an infinitely small space. Should another universe subsequently re-emerge, the integrity of hpack archives in that universe cannot be guaranteed.

hpack also checksums the archive directory. If an error is found in the directory information, the message:

will be displayed. Hitting at this point will abort any attempts to process the archive, hitting will process the (damaged) archive. hpack will attempt some error recovery in this case (for example files and directories which seem to be in impossible directories will be moved into the root directory), and some files may be able to be recovered. If error recovery information (specified with the [-e]rror recovery option (see the section HPACK Options above)) is present, chances of recovering data from an archive with a corrupted directory are greatly enhanced.

HPACK Archive/Data Authentication
Data authentication facilities in an archiver should provide the following features:

1.  Sender authenticity. The data could only have come from the source which it is supposed to have come from.

2.  Data integrity measures. Any attempt to tamper with the data should be recognised and reported by the authentication system.

3.  Non-repudiation of origin. The originator of the data cannot later disclaim responsibility for it.

hpack includes provisions for authenticating archived data by adding a unique digital signature to either entire archives or individual files within an archive. This works exactly like a normal signature on a piece of paper, proving that the sender was the true originator of the file or archive. Forgery of a digital signature of this sort is computationally infeasible, and once the data has been signed the sender cannot later disavow his or her signature. In addition a cryptographic checksum of the data or archive is made and included as part of the signature to allow detection of any attempts to tamper with the data. Like forging a signature, defeating the checksum is computationally infeasible.

When the data in an archive with authentication information present is extracted or tested, an authentication check is performed for the entire archive before it is processed. Similarly, an authentication check is performed on files before they are extracted if there is authentication information present.

In order for the authenticity information generation and checking to be possible, two key files are required. To secure archives, the files or which contain the secret key of the person securing the archive, are required. To check secured archives, the files or which contain the public key of the person or organization who signed the file or archive are needed. These key files are generated and managed by either version 2.0 or higher of Philip Zimmermanns excellent pgp encryption package (for the PGP keys), or various implementations of pem, among them Mark Riordan's equally good ripem encryption package. If you don't have a copy of pgp or ripem, it is recommended you obtain one. pgp is freely available on many archive sites, computer bulletin boards and other systems. ripem may only be available within the United States. pgp is also required to handle any key management, and for authentication of the keys themselves. ripem currently doesn't support much key management or key authentication. The pgp documentation and portions of the extended hpack documentation are recommended reading for those wanting more information on the background of pgp and the security techniques used by pgp and hpack.

If PEM (Privacy-Enhanced Mail) ever becomes a reality, hpack will support PEM/PKCS format keys as well as pgp ones. This will allow data to be encrypted and decrypted inside the US with PEM keys and outside the US with pgp keys, allowing, for the first time, the easy transfer of public-key encrypted data to and from the US.

Before hpack can use it, the secret keyring must have a small amount of extta information added to it. Details on this are given in the section Using PGP Secret Keyrings below.

hpack will search for the key files in the directories given in the environment variables PGPPATH and PEMPATH. These variables should contain the paths to any and files which are needed, with more than one path being possible. In order to eliminate the possibility of spoofing via a bogus keyring placed in the current directory, hpack will, like all well-designed OS shells, not search the current directory unless this is explicitly specified in the PGPPATH or PEMPATH variables with the use of the option indicating the path to the current directory.

For example if the search path for pgp keyrings included the directories and then PGPPATH should be set with:

    (Atari ST, MSDOS, OS/2)

    (Archimedes)

    (UNIX csh)

    (UNIX sh)

The directories for pgp and pem keyrings are always searched in the order given in the PGPPATH and PEMPATH variables. Note that in the above example the single-user Amiga, Atari ST, MSDOS and OS/2 systems only have a single path for keyrings, whereas the multiuser UNIX environments have multiple search paths corresponding to custom user keyrings followed by system-wide master keyrings.

If the data in the archive, or the archive itself, is to be checked, the authentication check will be performed using the key found in or If the authentication check succeeds, the message:

will be displayed, with name being the name of the person or organization who made the signature, and date being the date the signature was made (on some systems the signature time may be off by a few hours if the system doesn't adjust for different time zones properly). If the check fails, the message:

will be printed. If the archive is a multipart archive (for which the authentication check can take some time since an archive stretching over several disks needs to be processed), the message:

is displayed. The answer will check the authenticity of the archive, will skip the authenticity check and continue with processing the archive.

If the data in the archive, or the archive itself, is to be secured, the authentication information will be generated using the key found in or

The signature scheme used is the RSA public key cryptosystem (for more information on this and the pgp encryption package see the extended documentation This scheme involves the manipulation of very large numbers, which can be quite time-consuming on slow systems, where the signature generation and checking can take several minutes (for this reason the use of authentication for entire archives rather than individual files in an archive is recommended).

Unlike encryption software, authentication code is not export-restricted from the US. The U.S. Code of Federal Regulations, Title 22 which includes sub-chapter M, ``International Traffic in Arms Regulations'' (ITAR), makes an exception for software that can only be used for authentication purposes and cannot not be used for general-purpose encipherment and decipherment, as is the case for the data authentication code in hpack.

HPACK Internationalization
hpack is available in Bavarian, Dutch, English, German, Italian, Polish, Spanish, and Swiss German versions using the ASCII, IBM PC (Codepage 437), IBM Codepage 850, IBM Codepage 869, ISO 8859-1 (Latin 1), ISO 8859-2 (Latin 2), ISO 8859-3 (Latin 3), ISO 8859-4 (Latin 4), Macintosh, Mazovia, and NeXTSTEP character sets. The exact language and character set used by hpack is controlled by the environment variables CHARSET and LANGUAGE. By default hpack interacts with users in English using the ASCII/ISO646 character set. By setting these two variables, another language and/or character set can be selected. Note that not all combinations of languages and character sets will provide a useful result.

Possible options for LANGUAGE are and

Possible options for CHARSET are and

For example to set hpack to interact with the user in Italian using the ISO 8859-1 (Latin 1) character set, the environment variables should be set as follows:

    (MSDOS, OS/2)

    (UNIX csh)

    (UNIX sh)

Obtaining Public Keys
There are currently several key servers which can be used to obtain pgp public keys through the Internet and UUCP email systems. These are a convenient way of obtaining keys for people you wish to communicate with. The servers do not attempt to guarantee that a key is a valid key — the signators on the key should be used for that kind of security. These services can be discontinued at any time without prior notification.

Operating key servers as of 1 April 1993 are:
Site:    Iowa State University

Site:    MIT/Athena

Site:    University of Texas

Site:    Texas A&M University

Site:    Demon Internet Services, UK

Site: Relcom Corporation, Moscow

Site:    J. P. and Associates

Updates to this list are posted to the Usenet newsgroups.

Each keyserver processes requests in the form of mail messages. The commands for the server are entered on the line of the message, for example:

In the above example the server will return an informational message on how to use it. Other possible commands are:

    Command
        Message body contains

    Your PGP public key to add to server.
    Returned list of all PGP keys the server knows about
        (the same as the output from PGP's -kv command).
    Returned list of all PGP keys in verbose format
        (the same as the output from PGP's -kvv command).
    Returned complete public key ring from the server.
    Returned public key for the given
        userID.
    Returned set of keys for which the userID matches the given
        regexp.

To have your key added to the collection maintained by the key servers, save your public key to a file in ASCII-armoured format and simply mail it to one of the pgp key servers using as the message subject line. For example with most command-line oriented mailers the command would be:

To get the key for the userID (my own public key), the command would be:

mail -s "get pgut1" <server address>

To get multiple keys using the mget command, possible options are:

    Gets all keys whose userIDs contain ``michael''.
    Gets the two keys with the given keyIDs.

In addition to this service, there is a large collection of public keys available for anonymous FTP at:

To have your key added to the collection send it to Vesselin Bontchev,

HPACK Archive/Data Encryption
hpack allows data stored in an archive to be encrypted with a variety of public or conventional-key encryption algorithms. Encryption of either entire archives or individual files is possible, as well as the use of multiple keys to encrypt different sections of an archive (though the use of public-key encryption is preferred for this since its inherent automatic key management greatly simplifies handling the encrypted data).

When chosing an encryption key for a conventional-key algorithm, the following guidelines should be observed:

•   hpack allows keys of up to 80 characters in length. These keys can contain letters, numbers, spaces, and punctuation. This fact should be made use of to the fullest, with preferred passwords being entire phrases rather than individual words. There exist programs designed to allow high-speed password cracking of conventional-key encryption algorithms which can, in a matter of hours (sometimes minutes, even seconds in the case of very weak algorithms), attempt to use the contents of an average large dictionary as sample passwords. Most passwords composed of single words can be broken with ease in this manner, even in the case of algorithms like the MDC one which is used by hpack, which has been specially designed to be resistant to this form of attack (doing a brute-force search of all 8-letter passwords (the minimum length allowed by hpack) assuming a worst-case situation in which the password contains lowercase letters only, can be accomplished in 662 years on a fast CPU (Sparcstation IPX) if the attacker knows the contents of the encrypted file(s) in advance — or about 8 months on a network of 1000 of these machines. Using an intelligent dictionary-based cracking program will reduce this time significantly). This is especially apparent if the encryption algorithm used is very weak — the Pkzip encryption, for example, can be broken in this manner in a few seconds on a cheap personal computer using the standard Unix wordlist).

•   Simple modifications to passwords should not be trusted. Capitalizing some letters, spelling the word backwards, adding one or two digits to the end, and so on, only present a slightly more difficult challenge to the average password-cracker than plain unadorned passwords.

•   Probably the most difficult passwords to crack in this manner are ones comprising phrases or sentences, since instead of searching a small body of text like the contents of a dictionary, the cracker must search a much larger corpus of data, namely all possible phrases in the language being used. Needless to say, the use of common phrases should be avoided, since these will be an obvious target for crackers.

As is the case when using public-key encryption for data and archive authentication, the secret keyring will need to have a small quantity of extra information added to it, for which details are given in the section Using PGP Secret Keyrings below.

Using PGP Secret Keyrings
Like pgp and pem implementations, hpack can store its secret keys in an encrypted format to protect them from prying eyes. However the encryption algorithm hpack uses is somewhat different to the one used in pgp due to patent restrictions and in pem due to export restrictions. This means that encrypted pgp keyrings need to have a small amount of extra information added to them before hpack can use them. The hpack distribution includes a utility called keycvt which performs this task. keycvt is run as follows:

Normally keycvt will append the extra information to the existing keyring. However if an optional output keyfile name is given, the extra information will be written to the output file instead of being added to the keyring.

The source keyring may contain one or more secret keys. For each key in the file, keycvt will display its key information and ask:

An response will cause keycvt to print:

and move on to the next key. A response will cause keycvt to try to add the extra information needed by hpack. If the key is encrypted, keycvt will ask for the decryption password:

If the incorrect password is entered, keycvt will warn:

and allow it to be reentered. Up to three attempts at the password are allowed before keycvt gives up. When the key has been read in, keycvt will add the extra information encrypted with the same password as was used for the decryption. This is the password which hpack, like pgp and pem implementations, will use to decrypt the secret key.

Please note that, unlike hpack, keycvt will echo the password entered to the screen. Since keycvt is a one-use only application and since obtaining keyboard input without echo is quite difficult on many systems, keycvt uses a standard input routine to obtain its password. In addition, the password used for keycvt should follow the same rules as hpack, namely the key should be 8 characters or more long (see the section HPACK Archive/Data Encryption below for more details).

Finally, when keycvt has finished processing the key file, it will ask:

A response will add the new key information to the output key file. If no keys were converted or an response is given, keycvt will display:

In addition, keycvt will create the seed file needed by hpack in the same directory as the pgp seed file if it doesn't already exist. If the seed file already exists, keycvt will display:

and exit. If the file doesn't exist, hpack will create it and display:

before exiting.

This seed file can also be created manually by copying the pgp seed file to a new file

Authentication of HPACK Executables
There have been several occasions in the past when fake versions of new archivers have been distributed. Sometimes these fake release are even wrapped up in a nice-looking ``security envelope'' guaranteeing their authenticity. Since the source code is freely available, it's all too easy for anyone to create a fake version of hpack in which the encryption or authentication code has been compromised. In order to avoid any problems in this respect, the distributed hpack executables are accompanied by a digital signature (see the section HPACK Archive/Data Authentication above) which can be used to verify that it is indeed an official version. Unlike the schemes used by other archivers, it is computationally infeasible to compromise this method of authentication.

In order to check the authenticity of the particular version of hpack, you will need the pgp encryption package (see the section HPACK Archive/Data Authentication above), and my public key, which is included in the standard pgp distribution and also in the hpack distribution. My key is signed by Philip Zimmermann, the original author of pgp, and several members of the pgp development team. First, you should check my key for authenticity:

When it performs the key check, pgp should display the following signatures: Type bits/keyID Date User ID pub 1024/997D47 1992/08/02 Peter Gutmann <pgut1@cs.aukuni.ac.nz> sig! E722D9 1992/11/26 Branko Lankester <lankeste@fwi.uva.nl> sig! 997D47 1992/10/11 Peter Gutmann <pgut1@cs.aukuni.ac.nz> sig! 7C02F9 1992/09/07 Felipe Rodriquez <nonsenso@utopia.hacktic.nl> sig! 1336F5 1992/09/05 Harry Bush <Harry@castle.riga.lv> sig! 67F70B 1992/09/02 Philip R. Zimmermann <prz@sage.cgd.ucar.edu>

Version 2.1 and up of pgp can, in addition, calculate a key fingerprint for a key. This can be calculated with:

pgp should display the following: pub 1024/997D47 1992/08/02 Peter Gutmann <pgut1@cs.aukuni.ac.nz>
          Key fingerprint = 7C 6D 81 DF F2 62 0F 4A 67 0E 86 50 99 7E A6 B1

If the keyID or key fingerprint for my key differs from the one shown above or the signatures don't check out, then the key is a probably a fake and shouldn't be trusted. Assuming the key is in order, the authenticity of the program itself and the internationalization information can be checked with:

where and are the digital signatures included with the program as distributed. For example to check the authenticity of the Amiga hpack executable type:

When it performs the check, pgp should display:

If pgp reports a bad signature then the executable shouldn't be trusted. A new, hopefully untouched, version can be obtained from any archive site, BBS, or system which carries the standard hpack distribution, or you can arrange to get it directly from the author.

Using HPACK Encryption in the US
The following section is only of interested to hpack users residing in the US — non-US hpack users can skip it.

The RSA public-key encryption algorithm is covered by US Patent 4,405,829, and also by US Patent 4,218,582. The exclusive licensing rights to both patents are held by Public Key Partners (PKP) of Sunnyvale, California. The US version of hpack uses a special set of routines called RSAREF which are available from RSA Laboratories, which is the research and development division of RSA Data Security, Inc., the company founded by the inventors of the RSA public-key cryptosystem. RSA Laboratories reviews, designs and implements secure and efficient cryptosystems of all kinds. Its clients include government agencies, telecommunications companies, computer manufacturers, software developers, cable TV broadcasters, interactive video manufacturers, and satellite broadcast companies, among others.

RSA Laboratories have granted users of hpack permission to make a small number of changes to the RSAREF code in order to integrate it into hpack. More details on this integration are contained in the file included in the hpack distribution. This applies only for noncommercial use of hpack. Anyone intending to use hpack commercially should contact RSA Laboratories at the address given below.

Everyone who wishes to compile hpack themselves must obtain their own copy of RSAREF. Free licenses to redistribute RSAREF are available. For information, please send electronic mail to

RSAREF is available to citizens and permanent residents of the US. It can't be sent outside the United States, or given to anyone who is not a United States citizen and doesn't have a ``green card''. These are US State and Commerce Department requirements, because the code in RSAREF is export-controlled technology. (Incidentally, the fastest implementation I've ever seen of the conventional cipher used in RSAREF was written in Moscow, but that's another story).

Any questions on the RSAREF software, licenses, export restrictions, or other RSA Laboratories offerings should be addressed to:
RSA Laboratories    RSA Data Security, Inc.
10 Twin Dolphin Drive    100 Marine Parkway
Redwood City, CA  94065    Redwood City, CA  94065
USA    USA

(415) 595-7703    (415) 595-8782
(415) 595-4126 (fax)    (415) 595-1873 (fax)

or via email to

CREDITS
Many people have helped to get hpack where it is today, among them (in no particular order):

Ports to different operating systems:

    Stuart Woolford did the UNIX port.

    John Burnell did the OS/2 port.

    Jason Williams and Edouard Poor helped with the Archimedes port.

    Nick Little and Joerg Plate helped with the Amiga port.

    Martin Braschler did the Atari ST/TT port.

Translations:

    Peter Sowa and Martin Braschler did the German translation.

    Peter de Vocht did the Dutch translation.

    Arrigo Triulzi did the Italian translation.

    Rafal Mazkowski did the Polish translation.

    Eduardo Jacob did the Spanish translation.

    Martin Braschler did the Swiss German translation.

    Peter Gutmann had a go at the Klingon translation.

Documentation:

    DaviD W. Sanderson did major formatting work on the man page.

CONTACTING THE AUTHOR
You can contact me in any of the following ways:

•   By calling me on +64 9 426-5097 within reasonable hours (10am-12pm NZT).

•   By Usenet email to either (preferred), or or (in rough order of preference).

•   By Fidonet email to Peter Gutmann at However this is probably about as reliable a link as using carrier mackerel across the Sahara.

•   By snail mail to 24 Durness Pl, Orewa, Auckland, New Zealand

•   By throwing a bottle in the ocean (slightly less reliable than the Fidonet link).

•   By implanting subliminal messages in the music I listen to.

HPACK Error Messages
The error messages given by hpack are the following: The command you have given resulted in no changes being made to the archive(s) specified, due to the files you specified not being found on the disk. The command you have given resulted in no changes being made to the archive(s) specified. There can be several reasons for this, among them being that there were no matching files in the archive to replace/update, or that there were no matching files in the root directory of the archive (hpack will not, by default, check subdirectories: To handle subdirectories you must either give the full path within the archive, or use the [-r]ecurse subdirectories option). The command you have given resulted in no changes being made to the archive(s) specified, as they could not be found on the disk. There is not enough room on the current disk to finish archiving/unarchiving a file. You have given hpack a command which it doesn't understand. Check the section HPACK Commands for valid hpack commands. You have given hpack an option which it doesn't understand. Check the section HPACK Options for valid hpack options. You have specified an unknown option for the [-o]verwrite switch. This error may also be caused by forgetting to specify an option for the switch, in which case hpack will treat the character following the -o as the option. You have specified an unknown option for the [-v]iew options switch. This error may also be caused by forgetting to specify an option for the switch, in which case hpack will treat the character following the -v as the option. You have specified an unknown option for the [-d]irectory options switch. This error may also be caused by forgetting to specify an option for the switch, in which case hpack will treat the character following the -d as the option. You have used an incorrect format when using wildcards in filenames. You have used a very complex wildcard sequence, and hpack doesn't have enough room to process it fully. Try simplifying the expression, or break it up into separate simpler expressions. You have used wildcards in a pathname outside the archive. Since hpack's extended wildcards are built on top of the usual operating system ones (if they exist) the resulting system would run very slowly if they had to be simulated on an external filesystem. The supposed archive file does not appear to be an archive created by hpack. hpack cannot open the archive file. hpack cannot open the data file to dearchive data to, and is skipping to the next file to be processed. hpack cannot open the temporary work file it needs for the [d]elete, [f]reshen, [r]eplace, or [u]pdate commands. hpack cannot open the script file containing the list of files to process and hpack control commands, and is skipping to the next file to be processed. The base directory you have specified does not exist. hpack cannot create a directory to unarchive files into. This error message arises when using the [-b]ase path option and either a drive specifier is given in the pathname of one of the files to process or the base path includes an actual path and the file pathname is specified as being off the root directory. Since the base path is prepended to the pathname of the file, the pathname cannot contain a drive specifier or absolute directory reference in it. The version of hpack you are using is unfamiliar with the archiving method used for this file, and is skipping to the next file to be processed. The data in this file is encrypted, and no means of decryption has been supplied by the user; therefore hpack cannot process it and will move on to the next file to be processed. The entire archive (rather than just the data in it) is encrypted, and hpack cannot decrypt it to read it. This is either because no decryption password has been supplied, or because the archive is encrypted with an encryption method for which no decryption information is available. You have used the [-k]ill original archive option along with the [r]eplace, [f]reshen, or [u]pdate options. You have asked hpack to [f]reshen, [u]pdate, [r]eplace, or [d]elete files in a multipart archive, which would involve rewriting an archive spread across multiple disks. If an archive is compressed as one unit, it cannot later be changed in any way. Unit-compressed archives trade off compressed size for flexibility in updating them. You have asked hpack to [a]dd, [f]reshen, [u]pdate, [r]eplace, [d]elete, or [x]tract with move, files in an encrypted archive. Files or data in an encrypted archive cannot be changed without decrypting and re-encrypting the entire archive. You have asked hpack to make changes to an unencrypted archive, using block-encryption. hpack will not retroactively encrypt the archive, however the files can be individually encrypted as they are added to the archive. You have specified that data be both conventional and public-key encrypted. Data can be encrypted with one of the two methods, but not with both at once. When encrypting data, hpack will ask you to retype the password for security. If the second password doesn't match the first password, this error message is issued. The passphrase you have entered is either less than eight characters (making it dangerously short), or more than 80 characters (making it excessively long). The keyfile containing the keys used for decrypting and authenticating data is corrupted. You have forgotten to specify a userID when adding authentication information to an archive, or when using public-key encryption, or haven't given a primary userID for public-key encryption when using a secondary userID. The secret key needed to add authentication information to data for the given userID cannot be found, and the authentication information cannot be added. The public key needed to encrypt data for the given userID cannot be found, and the encryption can't be carried out. The secret key needed to decrypt the data cannot be found, and the data cannot be decrypted. This message will also occur if the secret key exists but hasn't been processed with the keycvt utility, which adds a small amount of extra information needed by hpack to use the key. See the section Using PGP Secret Keyrings above for more details. The public key for the authentication information attached to the data or archive can't be found, and thus the data authentication check can't be carried out. The information used for authenticating the data in an archive has been corrupted. The random seed file needed for public-key encryption cannot be read. If it doesn't exist or has been accidentally destroyed, a new one should be created either using the keycvt utility or manually. See the section Using PGP Secret Keyrings above for more details. The archive directory information has been corrupted. Depending on how bad the corruption is, hpack will either exit or prompt the user for whether it should try to continue, attempting to fix any errors in the directory as it processes it. There is not enough memory available for hpack to continue. You have used more than the maximum allowable number of characters (the limit set by the host OS) in a pathname. You have asked hpack to add a file to a nonexistent directory inside an archive. Input lines in script files are given a basic check for being valid filenames. If blatantly incorrect characters are discovered in a line of input this warning will be printed. Errors (either illegal characters or too-long pathnames) have been detected in the script file. More than 10 errors have been detected in the script file. This error message generally results from erroneously specifying a non-script file as a script file. You have tried to go down through more than 15 levels of subdirectories using the [-r]ecurse subdirectories option. The user or some other program interrupted hpack during the archiving process (for example by pressing the ``Break'' key or by sending it a termination signal). In some implementations of the Xmodem and Ymodem transfer protocols, CP/M end-of-file characters (Ctrl-Z's) are appended to the end of the transmitted file. When hpack detects these spurious characters on the end of an archive, it will truncate the archive to its correct size and issue this warning message. If part of a multipart archive is less than approximately 500 bytes long, hpack will not attempt to create the archive but will move the data to the next, hopefully less full, disk. A miscellaneous type of file error occurred during the archiving process (for example some sort of network error). The message itself will if possible contain more detail about the precise type of error. Some form of internal error occurred in hpack. Contact the author with details on how the error was brought about. Some CLI versions of hpack, notably the Amiga, Archimedes, Mac-CLI, MSDOS, OS/2, UNIX, and VMS ones, support a long argument format signalled by the -z switch, which is used to handle OS-specific options. The version you are using doesn't support this option.

DISCLAIMER
This program is guaranteed to perform as claimed, excluding any delays caused or enhanced by war, civil commotion, or rioting, whether declared, spontaneous, reprehensible, or justified; undue pressure to perform, from whatsoever source; mal de mer, mal de pays, mal de siecle, mal de code, mal de machine, or any force majeure not pretofore invoked.

The program warranty is void in case of nuclear war, whether caused by the program or not.

TRADEMARKS
Amiga is a trademark of Commodore Business Machines.
Archimedes is a trademark of Acorn Computers.
GIF is a trademark of Compuserve Inc.
IBM is a trademark of International Business Machines Corp.
Macintosh is a trademark of Apple Computer Inc.
MSDOS is a trademark of Microsoft Inc.
OS/2 is a trademark of International Business Machines Corp.
PKZIP is a trademark of PKWare Inc.
Prime and Primos are a trademark's of Prime Computer Corp.
QNX is a trademark of someone.
Rolemaster is a trademark of Iron Crown Enterprises Inc.
StuffIt is a trademark of Raymond Lau and Aladdin Systems.
ThinkC is a trademark of Symantec Corporation.
UNIX is both a trademark and a footnote of AT&T.
Windoze is not a trademark of Microsoft Corp.
Windows is, but it's a somewhat less accurate description of its performance.
These trademark lists are a trademark of too many lawyers and too few people with common sense being involved.

``Good compression isn't a matter of life and death — it's far more important than that''