=================================================================== RCS file: /cvs/palm/Palm-Keyring/lib/Palm/Keyring.pm,v retrieving revision 1.12 retrieving revision 1.14 diff -u -r1.12 -r1.14 --- palm/Palm-Keyring/lib/Palm/Keyring.pm 2007/01/28 00:18:46 1.12 +++ palm/Palm-Keyring/lib/Palm/Keyring.pm 2007/01/28 22:24:17 1.14 @@ -1,458 +1,489 @@ -# Palm::Keyring.pm +package Palm::Keyring; + +# $RedRiver: Keyring.pm,v 1.13 2007/01/28 18:13:28 andrew Exp $ # -# Perl class for dealing with Keyring for Palm OS databases. +# Perl class for dealing with Keyring for Palm OS databases. # -# Copyright (C) 2004, Andrew Fresh -# You may distribute this file under the terms of the Artistic -# License, as specified in the README file distributed with the p5-Palm distribution. -# # This started as Memo.pm, I just made it work for Keyring. -# -# $RedRiver: Keyring.pm,v 1.11 2007/01/27 23:59:29 andrew Exp $ use strict; -package Palm::Keyring; -use Palm::Raw(); -use Palm::StdAppInfo(); -use vars qw( $VERSION @ISA ); +use warnings; +use Carp; +use base qw/ Palm::StdAppInfo /; + use Digest::MD5 qw(md5); use Crypt::DES; +use Readonly; -use constant ENCRYPT => 1; -use constant DECRYPT => 0; -use constant MD5_CBLOCK => 64; -my $kSaltSize = 4; +Readonly my $ENCRYPT => 1; +Readonly my $DECRYPT => 0; +Readonly my $MD5_CBLOCK => 64; +Readonly my $kSalt_Size => 4; +Readonly my $EMPTY => q{}; +Readonly my $SPACE => q{ }; +Readonly my $NULL => chr 0; - # One liner, to allow MakeMaker to work. -$VERSION = do { my @r = (q$Revision: 1.12 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; +our ($VERSION) = q$Revision: 1.14 $ =~ m{ Revision: \s+ (\S+) }xm; -@ISA = qw( Palm::StdAppInfo Palm::Raw ); +#@ISA = qw( Palm::StdAppInfo Palm::Raw ); -=head1 NAME +sub new { + my $classname = shift; + my $pass = shift; -Palm::Keyring - Handler for Palm Keyring databases. + # Create a generic PDB. No need to rebless it, though. + my $self = $classname->SUPER::new(@_); -=head1 SYNOPSIS + $self->{'name'} = 'Keys-Gtkr'; # Default + $self->{'creator'} = 'Gtkr'; + $self->{'type'} = 'Gkyr'; - use Palm::PDB; - use Palm::Keyring; - my $pdb = new Palm::PDB; - $pdb->Load($file); - foreach my $record (@{ $pdb->{'records'} }) { - print "$record->{'plaintext'}->{'name'}\n"; - } - $pdb->Decrypt($password); - # do something with the decrypted parts + # The PDB is not a resource database by + # default, but it's worth emphasizing, + # since MemoDB is explicitly not a PRC. + $self->{'attributes'}{'resource'} = 0; -=head1 DESCRIPTION + # Initialize the AppInfo block + $self->{'appinfo'} = {}; -The Keyring PDB handler is a helper class for the Palm::PDB package. It -parses Keyring for Palm OS databases. See -L. + # Add the standard AppInfo block stuff + Palm::StdAppInfo::seed_StdAppInfo( $self->{'appinfo'} ); -It has the standard Palm::PDB methods with 2 additional public methods. -Decrypt and Encrypt. + # Set the version + $self->{'version'} = 4; -It currently supports the v4 Keyring databases. The v5 databases from the pre-release keyring-2.0 are not supported. + # Give the PDB the first record that will hold the encrypted password + $self->{'records'} = [ $self->new_Record ]; -=cut + if ( defined $pass ) { + $self->Encrypt($pass); + } -=head2 new + return $self; +} - $pdb = new Palm::Keyring([$password]); +sub import { + Palm::PDB::RegisterPDBHandlers( __PACKAGE__, [ 'Gtkr', 'Gkyr' ], ); + return 1; +} -Create a new PDB, initialized with the various Palm::Keyring fields -and an empty record list. +sub Load { + my $self = shift; + my $filename = shift; + my $password = shift; -Use this method if you're creating a Keyring PDB from scratch otherwise you -can just use Palm::PDB::new(). + $self->{'appinfo'} = {}; + $self->{'records'} = []; + $self->SUPER::Load($filename); -=cut + foreach my $rec ( @{ $self->{'records'} } ) { + if ( ! exists $rec->{'data'}) { next; }; + my ( $name, $encrypted ) = split /$NULL/xm, $rec->{'data'}, 2; + if ( ! $encrypted ) { next }; + $rec->{'plaintext'}->{'name'} = $name; + $rec->{'encrypted'} = $encrypted; + } -sub new -{ - my $classname = shift; - my $pass = shift; + return $self->Decrypt($password) if defined $password; - # Create a generic PDB. No need to rebless it, though. - my $self = $classname->SUPER::new(@_); + return 1; +} - $self->{name} = "Keys-Gtkr"; # Default - $self->{creator} = "Gtkr"; - $self->{type} = "Gkyr"; - # The PDB is not a resource database by - # default, but it's worth emphasizing, - # since MemoDB is explicitly not a PRC. - $self->{attributes}{resource} = 0; +sub Write { + my $self = shift; + my $filename = shift; + my $password = shift; - # Initialize the AppInfo block - $self->{appinfo} = {}; + $self->Encrypt($password) || return; + return $self->SUPER::Write($filename); +} - # Add the standard AppInfo block stuff - &Palm::StdAppInfo::seed_StdAppInfo($self->{appinfo}); +sub Encrypt { + my $self = shift; + my $pass = shift; - # Set the version - $self->{version} = 4; + if ($pass) { + if ( + !( exists $self->{'records'}->[0]->{'data'} + && $self->_keyring_verify($pass) ) + ) + { - # Give the PDB the first record that will hold the encrypted password - $self->{records} = [ $self->new_Record ]; + # This would encrypt with a new password. + # First decrypting everything with the old password of course. + $self->_keyring_update($pass) || return; + $self->_keyring_verify($pass) || return; + } + } - if (defined $pass) { - $self->Encrypt($pass); - } + $self->{'digest'} ||= _calc_keys( $self->{'password'} ); - return $self; -} + foreach my $rec ( @{ $self->{'records'} } ) { + if (!defined $rec->{'plaintext'}) { next; }; -sub import -{ - &Palm::PDB::RegisterPDBHandlers(__PACKAGE__, - [ "Gtkr", "Gkyr" ], - ); + my $name = + defined $rec->{'plaintext'}->{'name'} + ? $rec->{'plaintext'}->{'name'} + : $EMPTY; + my $account = + defined $rec->{'plaintext'}->{'account'} + ? $rec->{'plaintext'}->{'account'} + : $EMPTY; + my $password = + defined $rec->{'plaintext'}->{'password'} + ? $rec->{'plaintext'}->{'password'} + : $EMPTY; + my $description = + defined $rec->{'plaintext'}->{'description'} + ? $rec->{'plaintext'}->{'description'} + : $EMPTY; + my $extra = $EMPTY; + + my $plaintext = join "$NULL", $account, $password, $description, $extra; + + my $encrypted = _crypt3des( $plaintext, $self->{'digest'}, $ENCRYPT ); + + $rec->{'data'} = join "$NULL", $name, $encrypted; + } + + return 1; } -=pod +sub Decrypt { + my $self = shift; + my $pass = shift; -=head2 Load + if ($pass) { + $self->_keyring_verify($pass) || return; + } - $pdb->Load($filename[, $password]); + $self->{'digest'} ||= _calc_keys( $self->{'password'} ); -Overrides the standard Palm::Raw Load() to add -$record->{'plaintext'}->{'name'} and -$record->{'encrypted'} fields. -$record->{'plaintext'}->{'name'} holds the name of the record, -$record->{'encrypted'} is the encrypted information in the PDB. + my $reccount = 0; + foreach my $rec ( @{ $self->{'records'} } ) { + $reccount++; -It also takes an additional optional parameter, which is the password to use to -decrypt the database. + # always skip the first record that has the password in it. + next if $reccount <= 1; + if ( ! defined $rec->{'data'} ) { + warn 'Invalid record ' . ( $reccount - 1 ) . "\n"; + next; + } -See Decrypt() for the additional fields that are available after decryption. + my ( $name, $encrypted ) = split /$NULL/xm, $rec->{'data'}, 2; + if (! $encrypted) { next; }; -=cut + $rec->{'plaintext'}->{'name'} = $name; -sub Load -{ - my $self = shift; - my $filename = shift; - my $password = shift; + my $decrypted = _crypt3des( $encrypted, $self->{'digest'}, $DECRYPT ); + my ( $account, $password, $description, $extra ) = split /$NULL/xm, + $decrypted, 4; - $self->{'appinfo'} = {}; - $self->{'records'} = []; - $self->SUPER::Load($filename); + $rec->{'plaintext'}->{'account'} = defined $account ? $account : $EMPTY; + $rec->{'plaintext'}->{'password'} = + defined $password ? $password : $EMPTY; + $rec->{'plaintext'}->{'description'} = + defined $description ? $description : $EMPTY; - foreach my $record (@{ $self->{records} }) { - next unless exists $record->{data}; - my ($name, $encrypted) = split /\000/, $record->{data}, 2; - next unless $encrypted; - $record->{plaintext}->{name} = $name; - $record->{encrypted} = $encrypted; - } + #print "Name: '$name'\n"; + #print "Encrypted: '$encrypted' - Length: " . length($encrypted) . "\n"; + #print " Hex: '" . unpack("H*", $encrypted) . "'\n"; + #print " Binary:'" . unpack("b*", $encrypted) . "'\n"; + #print "Decrypted: '$decrypted' - Length: " . length($decrypted) . "\n"; + #print " Hex: '" . unpack("H*", $decrypted) . "'\n"; + #print " Binary:'" . unpack("b*", $decrypted) . "'\n"; + #print "\n"; + #print "Extra: $extra\n"; + #exit; + #-------------------------------------------------- + # print "Account: $account\n"; + # print "Password: $password\n"; + # print "Description: $description\n"; + #-------------------------------------------------- - return $self->Decrypt($password) if defined $password; + } - 1; + return 1; } -=pod +sub _calc_keys { + my $pass = shift; + if (! defined $pass) { croak('No password defined!'); }; -=head2 Write + my $digest = md5($pass); - $pdb->Write($filename[, $password]); + my ( $key1, $key2 ) = unpack 'a8a8', $digest; -Just like the Palm::Raw::Write() but encrypts everything before saving. + #-------------------------------------------------- + # print "key1: $key1: ", length $key1, "\n"; + # print "key2: $key2: ", length $key2, "\n"; + #-------------------------------------------------- -Also takes an optional password to encrypt with a new password, not needed -unless you are changing the password. + $digest = unpack 'H*', $key1 . $key2 . $key1; -=cut + #-------------------------------------------------- + # print "Digest: ", $digest, "\n"; + # print length $digest, "\n"; + #-------------------------------------------------- -sub Write -{ - my $self = shift; - my $filename = shift; - my $password = shift; - - $self->Encrypt($password) || return undef; - return $self->SUPER::Write($filename); + return $digest; } -=pod +sub _keyring_verify { + my $self = shift; + my $pass = shift; -=head2 Encrypt + if (! $pass) { croak('No password specified!'); }; - $pdb->Encrypt([$password]); + # AFAIK the thing we use to test the password is + # always in the first entry + my $data = $self->{'records'}->[0]->{'data'}; -Encrypts the PDB, either with the password used to decrypt or create it, or -optionally with a password that is passed. + #die "No encrypted password in file!" unless defined $data; + if (! defined $data) { return; }; -See Decrypt() for an what plaintext fields are available to be encrypted. + $data =~ s/$NULL$//xm; -=cut + my $salt = substr $data, 0, $kSalt_Size; -sub Encrypt -{ - my $self = shift; - my $pass = shift; + my $msg = $salt . $pass; - if ($pass) { - unless (exists $self->{'records'}->[0]->{'data'} && - $self->_keyring_verify($pass) ) { - # This would encrypt with a new password. - # First decrypting everything with the old password of course. - $self->_keyring_update($pass) || return undef; - $self->_keyring_verify($pass) || return undef; - } - } + $msg .= "\0" x ( $MD5_CBLOCK - length $msg ); - $self->{digest} ||= _calc_keys($self->{password}); + my $digest = md5($msg); - foreach my $record (@{ $self->{records} }) { - next unless defined $record->{plaintext}; + if ( $data eq $salt . $digest ) { - my $name = defined $record->{plaintext}->{name} ? - $record->{plaintext}->{name} : ''; - my $account = defined $record->{plaintext}->{account} ? - $record->{plaintext}->{account} : ''; - my $password = defined $record->{plaintext}->{password} ? - $record->{plaintext}->{password} : ''; - my $description = defined $record->{plaintext}->{description} ? - $record->{plaintext}->{description} : ''; - my $extra = ''; +# May as well generate the keys we need now, since we know the password is right + $self->{'digest'} = _calc_keys($pass); + if ( $self->{'digest'} ) { + $self->{'password'} = $pass; + return 1; + } + } + return; +} - my $plaintext = join("\000", $account, $password, $description, $extra); +sub _keyring_update { - my $encrypted = _crypt3des($plaintext, $self->{digest}, ENCRYPT); + # It is very important to Encrypt after calling this + # (Although it is generally only called by Encrypt) + # because otherwise the data will be out of sync with the + # password, and that would suck! + my $self = shift; + my $pass = shift; - $record->{data} = join("\000", $name, $encrypted); - } + if (! $pass) { croak('No password specified!'); }; - 1; -} + # if the database already has a password in it + if ( $self->{'records'}->[0]->{'data'} ) { -=head2 Decrypt + # Make sure everything is decrypted before we update the keyring + $self->Decrypt() || return; + } - $pdb->Decrypt([$password]); + my $salt; + for ( 1 .. $kSalt_Size ) { + $salt .= chr int rand 255; + } -Decrypts the PDB and fills out the rest of the fields available in -$record->{'plaintext'}. + my $msg = $salt . $pass; -The plaintext should now be this, before encryption or after decryption: + $msg .= "\0" x ( $MD5_CBLOCK - length $msg ); - $record->{'plaintext'} = { - name => $name, - account => $account, - password => $account_password, - description => $description, - }; + my $digest = md5($msg); -=cut + my $data = $salt . $digest; # . "\0"; -sub Decrypt -{ - my $self = shift; - my $pass = shift; + # AFAIK the thing we use to test the password is + # always in the first entry + $self->{'records'}->[0]->{'data'} = $data; - if ($pass) { - $self->_keyring_verify($pass) || return undef; - } + $self->{'password'} = $pass; + $self->{'digest'} = _calc_keys( $self->{'password'} ); - $self->{digest} ||= _calc_keys($self->{password}); + return 1; +} - foreach my $record (@{ $self->{records} }) { - next unless defined $record->{data}; +sub _crypt3des { + my ( $plaintext, $passphrase, $flag ) = @_; - my ($name, $encrypted) = split /\000/, $record->{data}, 2; - next unless $encrypted; + $passphrase .= $SPACE x ( 16 * 3 ); + my $cyphertext = $EMPTY; - $record->{plaintext}->{name} = $name; + my $size = length $plaintext; - my $decrypted = _crypt3des($encrypted, $self->{digest}, DECRYPT); - my ($account, $password, $description, $extra) - = split /\000/, $decrypted, 4; + #print "STRING: '$plaintext' - Length: " . (length $plaintext) . "\n"; - $record->{plaintext}->{account} = defined $account ? - $account : ''; - $record->{plaintext}->{password} = defined $password ? - $password : ''; - $record->{plaintext}->{description} = defined $description ? - $description : ''; + my @C; + for ( 0 .. 2 ) { + $C[$_] = + new Crypt::DES( pack 'H*', ( substr $passphrase, 16 * $_, 16 )); + } - #print "Name: '$name'\n"; - #print "Encrypted: '$encrypted' - Length: " . length($encrypted) . "\n"; - #print " Hex: '" . unpack("H*", $encrypted) . "'\n"; - #print " Binary:'" . unpack("b*", $encrypted) . "'\n"; - #print "Decrypted: '$decrypted' - Length: " . length($decrypted) . "\n"; - #print " Hex: '" . unpack("H*", $decrypted) . "'\n"; - #print " Binary:'" . unpack("b*", $decrypted) . "'\n"; - #print "\n"; - #print "Extra: $extra\n"; - #exit; - #-------------------------------------------------- - # print "Account: $account\n"; - # print "Password: $password\n"; - # print "Description: $description\n"; - #-------------------------------------------------- + for ( 0 .. ( ($size) / 8 ) ) { + my $pt = substr $plaintext, $_ * 8, 8; - } + #print "PT: '$pt' - Length: " . length($pt) . "\n"; + if (! length $pt) { next; }; + if ( (length $pt) < 8 ) { + if ($flag == $DECRYPT) { croak('record not 8 byte padded'); }; + my $len = 8 - (length $pt); - 1; -} + #print "LENGTH: $len\n"; + #print "Binary: '" . unpack("b*", $pt) . "'\n"; + $pt .= ($NULL x $len); -sub _calc_keys -{ - my $pass = shift; - die "No password defined!" unless defined $pass; + #print "PT: '$pt' - Length: " . length($pt) . "\n"; + #print "Binary: '" . unpack("b*", $pt) . "'\n"; + } + if ( $flag == $ENCRYPT ) { + $pt = $C[0]->encrypt($pt); + $pt = $C[1]->decrypt($pt); + $pt = $C[2]->encrypt($pt); + } + else { + $pt = $C[0]->decrypt($pt); + $pt = $C[1]->encrypt($pt); + $pt = $C[2]->decrypt($pt); + } - my $digest = md5($pass); + #print "PT: '$pt' - Length: " . length($pt) . "\n"; + $cyphertext .= $pt; + } - my ($key1, $key2) = unpack('a8a8', $digest); - #-------------------------------------------------- - # print "key1: $key1: ", length $key1, "\n"; - # print "key2: $key2: ", length $key2, "\n"; - #-------------------------------------------------- + $cyphertext =~ s/$NULL+$//xm; - $digest = unpack('H*', $key1 . $key2 . $key1); - #-------------------------------------------------- - # print "Digest: ", $digest, "\n"; - # print length $digest, "\n"; - #-------------------------------------------------- + #print "CT: '$cyphertext' - Length: " . length($cyphertext) . "\n"; - return $digest; + return $cyphertext; } -sub _keyring_verify -{ - my $self = shift; - my $pass = shift; +1; +__END__ - die "No password specified!" unless $pass; +=head1 NAME - # AFAIK the thing we use to test the password is - # always in the first entry - my $data = $self->{records}->[0]->{data}; - #die "No encrypted password in file!" unless defined $data; - return undef unless defined $data; +Palm::Keyring - Handler for Palm Keyring databases. - $data =~ s/\0$//; +=head1 DESCRIPTION - my $salt = substr($data, 0, $kSaltSize); +The Keyring PDB handler is a helper class for the Palm::PDB package. It +parses Keyring for Palm OS databases. See +L. - my $msg = $salt . $pass; +It has the standard Palm::PDB methods with 2 additional public methods. +Decrypt and Encrypt. - $msg .= "\0" x (MD5_CBLOCK - length($msg)); +It currently supports the v4 Keyring databases. The v5 databases from the pre-release keyring-2.0 are not supported. - my $digest = md5($msg); +=head1 SYNOPSIS - if ($data eq $salt . $digest) { - # May as well generate the keys we need now, since we know the password is right - $self->{digest} = _calc_keys($pass); - if ($self->{digest}) { - $self->{password} = $pass; - return 1; - } else { - return undef; - } - } else { - return undef; + use Palm::PDB; + use Palm::Keyring; + my $pdb = new Palm::PDB; + $pdb->Load($file); + foreach my $rec (@{ $pdb->{'records'} }) { + print "$rec->{'plaintext'}->{'name'}\n"; } -} + $pdb->Decrypt($password); + # do something with the decrypted parts -sub _keyring_update -{ - # It is very important to Encrypt after calling this - # (Although it is generally only called by Encrypt) - # because otherwise the data will be out of sync with the - # password, and that would suck! - my $self = shift; - my $pass = shift; +=head1 SUBROUTINES/METHODS - die "No password specified!" unless $pass; +=head2 new - # if the database already has a password in it - if ($self->{records}->[0]->{data}) { - # Make sure everything is decrypted before we update the keyring - $self->Decrypt() || return undef; - } + $pdb = new Palm::Keyring([$password]); - my $salt; - for (1..$kSaltSize) { - $salt .= chr(int(rand(255))); - } +Create a new PDB, initialized with the various Palm::Keyring fields +and an empty record list. - my $msg = $salt . $pass; +Use this method if you're creating a Keyring PDB from scratch otherwise you +can just use Palm::PDB::new(). - $msg .= "\0" x (MD5_CBLOCK - length($msg)); +=head2 Load - my $digest = md5($msg); + $pdb->Load($filename[, $password]); - my $data = $salt . $digest;# . "\0"; +Overrides the standard Palm::Raw Load() to add +$rec->{'plaintext'}->{'name'} and +$rec->{'encrypted'} fields. +$rec->{'plaintext'}->{'name'} holds the name of the record, +$rec->{'encrypted'} is the encrypted information in the PDB. - # AFAIK the thing we use to test the password is - # always in the first entry - $self->{records}->[0]->{data} = $data; +It also takes an additional optional parameter, which is the password to use to +decrypt the database. - $self->{password} = $pass; - $self->{digest} = _calc_keys($self->{password}); +See Decrypt() for the additional fields that are available after decryption. - return 1; -} +=head2 Write -sub _crypt3des { - my ( $plaintext, $passphrase, $flag ) = @_; - my $NULL = chr(0); + $pdb->Write($filename[, $password]); - $passphrase .= ' ' x (16*3); - my $cyphertext = ""; +Just like the Palm::Raw::Write() but encrypts everything before saving. - my $size = length ( $plaintext ); - #print "STRING: '$plaintext' - Length: " . length($plaintext) . "\n"; +Also takes an optional password to encrypt with a new password, not needed +unless you are changing the password. - my @C; - for ( 0..2 ) { - $C[$_] = new Crypt::DES( pack( "H*", substr($passphrase, 16*$_, 16 ))); - } +=head2 Encrypt - for ( 0 .. (($size)/8)) { - my $pt = substr( $plaintext, $_*8, 8 ); - #print "PT: '$pt' - Length: " . length($pt) . "\n"; - next unless length($pt); - if (length($pt) < 8) { - die "record not 8 byte padded" if $flag == DECRYPT; - my $len = 8 - length($pt); - #print "LENGTH: $len\n"; - #print "Binary: '" . unpack("b*", $pt) . "'\n"; - $pt .= ($NULL x $len); - #print "PT: '$pt' - Length: " . length($pt) . "\n"; - #print "Binary: '" . unpack("b*", $pt) . "'\n"; - } - if ($flag == ENCRYPT) { - $pt = $C[0]->encrypt( $pt ); - $pt = $C[1]->decrypt( $pt ); - $pt = $C[2]->encrypt( $pt ); - } else { - $pt = $C[0]->decrypt( $pt ); - $pt = $C[1]->encrypt( $pt ); - $pt = $C[2]->decrypt( $pt ); - } - #print "PT: '$pt' - Length: " . length($pt) . "\n"; - $cyphertext .= $pt; - } + $pdb->Encrypt([$password]); - $cyphertext =~ s/$NULL+$//; - #print "CT: '$cyphertext' - Length: " . length($cyphertext) . "\n"; +Encrypts the PDB, either with the password used to decrypt or create it, or +optionally with a password that is passed. - return $cyphertext; -} +See Decrypt() for an what plaintext fields are available to be encrypted. -1; -__END__ +=head2 Decrypt + $pdb->Decrypt([$password]); + +Decrypts the PDB and fills out the rest of the fields available in +$rec->{'plaintext'}. + +The plaintext should now be this, before encryption or after decryption: + + $rec->{'plaintext'} = { + name => $name, + account => $account, + password => $account_password, + description => $description, + }; + +=head1 DEPENDENCIES + +Palm::StdAppInfo + +Digest::MD5 + +Crypt::DES + +Readonly + +=head1 BUGS AND LIMITATIONS + +Once this module is uploaded, you can +Please report any bugs or feature requests to +C, or through the web interface at +L. I will be notified, and then you'll automatically be +notified of progress on your bug as I make changes. + =head1 AUTHOR Andrew Fresh Eandrew@mad-techies.orgE +=head1 LICENSE AND COPYRIGHT + +You may distribute this file under the terms of perl itself +as specified in the LICENSE file. + +Copyright 2004, 2005, 2006, 2007 Andrew Fresh, All Rights Reserved. + +This program is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + =head1 SEE ALSO Palm::PDB(3) @@ -461,5 +492,3 @@ The Keyring for Palm OS website: L - -=cut