|
PeaZip
free
archiver Development
Roadmap 
 Curious
about ideas and works behind
PeaZip archiver? Click the picture to enlarge the roadmap of
the
software
development.
To know more, you can see the detailed changelog of previous PeaZip free archiver releases.
Project's goals
-
PEA - Pack Encrypt Authenticate
- The initial goal of the application
was creating a frontend for Pea archiver utility, implementing PEA
archive
format,
designed ground
up by myself to primarily focus on security and integrity: I wanted
something
performing strong authenticated encryption and perform integrity checks
on both input objects and output volume(s). Pea offer those
characteristics, and is open source (LGPL) freeware; file format specifications are released under public domain. I did a bit of cryptanalisys of it (see Documentation
package); I hope more authoritative people may analyze it further.
- Most archivers offer strong
encryption, but bounded to password-only auhentication: Pea executable
offers two factor authentication to increase encryption's security
margins against
password-related threats, like social engineering, dictionary attacks,
bruteforcing, keylogging...
-
Bring focus on Lazarus/FreePascal
- I'm developing PeaZip project in
FreePascal language, under Lazarus IDE. I like Pascal-related languages
and I think Lazarus/FreePascal is one of the best cross-platform IDE
available; I like it even more because it is open source and because
it's growing day by day in a more mature and powerful IDE. I'll be glad
to bring a bit of developer's attention on Lazarus/FreePascal through
my project.
-
Archiving and compression
- Designing PeaZip UI, I'm aiming to
focus on archive-specific tools, operations and needs rather than
focusing on offering a faithful emulation of a file
browser, like many mainstream archivers does. Saving lists of objects
to be archived, saving archiving/extraction job definitions and
receiving detailed job log
after operations are primary goals of PeaZip UI. However,
PeaZip's system integration, if desired, allows the user to perform
most common
operations (add to archive, extract here, encrypt, split file etc)
without even care
of the main program UI.
- 7-Zip: thanking Igor Pavlov and
Myspace choice of offering 7z under LGPL I was able to easily add
support to many mainstream archive and compression formats to PeaZip,
transforming it from a niche project (formerly named Pea-Peach) to a
possibly wider targeted software. I hope I can turn back to them part
of the benefit supporting .7z archive format,
expecially on Linux systems, offering a ready to use solution to
extract and archive in .7z format among others.
- ARC: a new, very promising archive format,
featuring
powerful but efficient compression, strong encryption and recovery
records.
- PAQ/LPAQ: today one of the most
promising research project in the file compression's field is Matt
Mahoney's
Paq. Many different implementation and branches exists, most as command
line binaries and some integrated in archivers with GUI (like WinRK,
WinUDA, KGB Archiver etc). PeaZip act as GUI fronted to Paq too (see
documentation for details on versions supported), hoping to contribute
to the diffusion of the format and in bringing focus on this
interesting research project.
- QUAD/BALZ: Ilia Muraviev's QUAD and
BALZ are
very promising ROLZ-based compression software featuring high
compression ratio and fast decompression, making them very
well suited in scenarios were decompression occurs more often than
compression (i.e. package release).
- Strip/UPX: I often use Strip/UPX on
executables I compile (including PeaZip's ones); the GUI
frontend for Strip/UPX in PeaZip comes to be very handy for me and I
hope it can be an useful plus for many other developers to reduce
executables size.
- Two factor authentication: from
version 2.1 PeaZip can use keyfiles for any supported format featuring
encryption.
The SHA256 hash of the keyfile (no size
limit) is encoded in Base64 (RFC 4648) and prepended to the password.
So, it is possible to work on
archives encrypted in that way using PeaZip or any application
following the
same convention, or simply entering the Base64-encoded hash as the
first part
of the password.
Notes
Note on UTF-8 support
From version 2.2 UTF-8 character encoding is supported (even if,
currently, using the experimental 0.9.25 build of Lazarus IDE),
allowing to properly handle extended characters in filenames and to
deploy localization of PeaZip's user interface text in any language.
It should be noted however that, at present level of development of
Lazarus/FreePascal project, most of the underlying FreePascal
file-handling routines are still ANSI-only, meaning the UTF-8 strings
PeaZip uses internally still have to be translated to ANSI strings to
be passed to certain functions.
As PeaZip aims 1) to stay cross-platform and 2) to bridge the gap
between GUI and console worlds, allowing to easily export jobs as
command lines, UTF-8 support is utterly complicated because each system
/ desktop environment / widgetset PeaZip is ported to has different
levels and ways of supporting UTF-8 encoding for different APIs, for
system pipes, for command line interpreters etc.
This issue currently causes:
- PeaZip
cannot
browse files/dirs containing characters which are not featured in host
system’s character’s set (they will be replaced by ? widlcard) due to
the need of ANSI translation for strings passed to certain FPC routines;
- decoding of names of archived objects using extended
characters
is not straightforward and is accomplished with a workaround using ?
wildcard for extended characters (over ANSII code 126, ~ character),
that may lead the archive browser to not accurately present archive’s
content (switching the browser to flat view mode may be helpful in some
cases), however the ability of operate (test, extract etc) on the whole
archive is not affected by this issue.
Note on drag and drop
(Windows)
From version
2.1 it is possible to drag items from application to system (Windows
version).
PeaZip uses a custom drag&drop to system
feature that doesn’t need to copy files being dragged to system’s temp
folder
before, resulting in faster operation when big files are involved, and
in
better security if temp folder has not the same desired security
policies of
actual output folder.
This custom drag and drop
function will not show
default Windows drag and drop cursors and it can drag files to the path
of
(file)Explorer windows with Address field enabled (as it is by default
on all
Windows versions), or to the desktop; it will prompt a directory
selection
dialog if the path is not recognized i.e. content is dropped to an
application
other than (file)Explorer.
Note on PeaZip's context
menu (Windows)
Please note that launching the program through links in SendTo allows
receiving multiple input arguments from the command line for each
instance of the program; those links can be customized editing the link
files in SendTo folder.
Conversely, links in Context Menu can receive a single input argument
from command line for each instance of the program; this limitation
need changing programming approach to be avoided, see in this
discussion thread in example.
Moreover, Context Menu items can be customized only editing the
registry, which is inherently more complex (and potentially more
dangerous) that editing a link file as in previous case; that’s why
links in SendTo was the first system’s integration mechanism
implemented, anyway Context Menu integration was added in version 1.7
alongside the classic SendTo integration.
At present level of development PeaZip’s Context Menu items can accept
a single input argument; extraction, test, list, add to separate
archives and split feature works just fine with this limitation, since
they launch in parallel one instance for each input argument, but add
to archive features cannot be replicated (unless there is only a single
object to archive).
For that reason it’s recommended to keep Add to archive, Add to .7z and
Add to zip links in SendTo menu.
For similar reason program’s entries in Windows context menu are not
grouped in a subfolder since it will involve much more complex (and
potentially more dangerous) modifications to be written to registers
than creating separate entries.
Note on PEA archive type limitations
Such a
list can be all but complete, however: when I designed
PEA
archive format I was less experienced and I basically didn't take in
account the need to browse the archive
or to partially extract objects; just to create and extract it.
Since
filenames are, by design, saved along file streams, there is not an
easy way to
accomplish it without parsing the entire archive (which can be
a reasonable solution only for small archives) or without changing
format
specifications breaking the compatibility with former versions.
A
workaround I may implement in future to allow archive browsing could be
creating an extra text
filecontaining filenames, saved as first
archive's object; that will not introduce
backward incompatibility since previos PEA version could still
correctly handle the new archives (just having the list-file as extra
content) and will be quite painless introducing negligible space
and speed payload, unless archiving many small files.
This is just an
hypothetical evaluation and there still is not a roadmap about it.
Anyway this is a PEA format related issue has no impact on users using
PeaZip to handle formats other than PEA.
Notes for developes
Packages
PeaZip sources are contained in the peazip-*.src.zip package.
PeaZip and PeaZip_portable shares the same sources being PeaZip
installable basically the same portable application packaged into an
installable format: Inno Setup's .exe for Windows, DEB, RPM and TGZ for
Linux.
Compilation,
build and porting
PeaZip, Pea and Gwrap are written in FreePascal
(highly compatible with Delphi and
ObjectPascal languages) and require Lazarus IDE  to be
compiled; Windows setup scripts (.iss files) are developed using
Inno Setup.
To compile PeaZip binaries open the .lpi file of the
desired binary (i.e. peach.lpi for peazip binary) and select "build
all".
FreePascal supports multiple widgetsets (Win32, WinCE,
GTK1, GTK2, Qt, Carbon, fpGUI) to allow compilation of GUI applications
for the
various supported systems and to create different “flavours” of the
application
for platforms supporting multiple widgetsets (i.e Linux).
PeaZip's sourcecode is cross platform, platform-specific
code portions are contained in conditional compilations blocks.
Deploying the application to other targets than MSWINDOWS
and LINUX may require adaptation of those platform specific areas (and
possibly
other fine-tunings); PC-BSD users successfully built PeaZip on *BSD
platform.
PeaZip will also need various backend compression and
archiving applications to be reachable in expected directories within
the
application's path, please refer to the structure of any of the
precompiled
packages, either installable or portable, to see what third parts
binaries must
be included, and refer to respective Authors for ports of those
utilities.
Being PeaZip programmed as frontend/backend
application, missing or unwanted backend binaries can be omitted, at
the cost
of losing the ability of handling supported formats; for the same
reason,
backend binaries can be freely replaced with 64 bit counterparts or
with
updated versions (which will work fine as long as they follow the same
syntax).
PeaZip code should be fairly easy to port on Delphi and
other Pascal
dialects; the underlying crypto library ,
developed and maintained by Wolfgang Ehrhardt, is
explicitly written to be portable to most or all Pascal dialects,
however due to some ASM parts some of its features may be x86 processor
specific.
Testing
PeaZip free archiver
should run on all
Windows and Linux systems (on Linux it may require some gtk/gdk libraries, like libgdk_pixbuf); the program is tested on:
- Windows 98SE;
- Windows 2000; Windows XP and Windows
Vista, 32 and 64 bit
- various 32 and 64 bit Linux with GTK1 and/or GTK2 and Gnome and/or KDE
Cryptoanalisys
You can find a stub
of cryptoanalisys of PEA archive
format on PEA online help (.pdf)
PEA archive support in third parts software
To support Pea file format in your
applications you may follow one of those ways:
- use directly the executable Pea archiving utility
(LGPL
freeware) passing parameters through command line, as in PeaZip;
- use Pea sourcecode as library to call
Pea-related functions from your code (as in the
demo application in "sources" package);
- create a new implementation following
the file format specifications, which are released under public domain
and, as for what is known to the Author, are free and unencumbered for
any use.
|
|
