[BACK]Return to Keyring.pm CVS log [TXT][DIR] Up to [local] / palm / Palm-Keyring / lib / Palm

Diff for /palm/Palm-Keyring/lib/Palm/Keyring.pm between version 1.2 and 1.22

version 1.2, 2006/01/31 23:03:39 version 1.22, 2007/02/01 01:56:11
Line 1 
Line 1 
 # Palm::Keyring.pm  package Palm::Keyring;
   
   # $RedRiver: Keyring.pm,v 1.21 2007/01/31 05:32:20 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.  #   This started as Memo.pm, I just made it work for Keyring.
 #  
 # $Id$  
 # $RedRiver: Keyring.pm,v 1.1 2006/01/26 20:54:19 andrew Exp $  
   
 use strict;  use strict;
 package Palm::Keyring;  use warnings;
 use Palm::Raw();  use Carp;
 use Palm::StdAppInfo();  
 use vars qw( $VERSION @ISA );  
   
   use base qw/ Palm::StdAppInfo /;
   
 use Digest::MD5 qw(md5);  use Digest::MD5 qw(md5);
 use Crypt::DES;  use Crypt::DES;
   use Readonly;
   
 use constant ENCRYPT    =>  1;  Readonly my $ENCRYPT    => 1;
 use constant DECRYPT    =>  0;  Readonly my $DECRYPT    => 0;
 use constant MD5_CBLOCK => 64;  Readonly my $MD5_CBLOCK => 64;
 my $kSaltSize = 4;  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.  # One liner, to allow MakeMaker to work.
 $VERSION = do { my @r = (q$Revision$ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };  our $VERSION = 0.92;
   
 @ISA = qw( Palm::StdAppInfo Palm::Raw );  sub new {
       my $classname = shift;
       my $pass      = shift;
   
 =head1 NAME      # Create a generic PDB. No need to rebless it, though.
       my $self = $classname->SUPER::new(@_);
   
 Palm::Keyring - Handler for Palm Keyring databases.      $self->{'name'}    = 'Keys-Gtkr';    # Default
       $self->{'creator'} = 'Gtkr';
       $self->{'type'}    = 'Gkyr';
   
 =head1 SYNOPSIS      # 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;
   
     use Palm::Keyring;      # Initialize the AppInfo block
         $pdb->Decrypt('mypassword');      $self->{'appinfo'} = {};
   
 =head1 DESCRIPTION      # Add the standard AppInfo block stuff
       Palm::StdAppInfo::seed_StdAppInfo( $self->{'appinfo'} );
   
 The Keyring PDB handler is a helper class for the Palm::PDB package. It      # Set the version
 parses Keyring databases.  See      $self->{'version'} = 4;
 L<http://gnukeyring.sourceforge.net/>.  
   
 It is just the standard Palm::Raw with 2 additional public methods.  Decrypt and Encrypt.      if ( defined $pass ) {
           $self->Password($pass);
       }
   
 =cut      return $self;
 =head2 new  }
   
   $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  sub ParseRecord {
 and an empty record list.      my $self     = shift;
   
 Use this method if you're creating a Keyring PDB from scratch.      my $rec = $self->SUPER::ParseRecord(@_);
   
 =cut      # skip the 0 record that holds the password
 #'      return $rec if ! exists $self->{'records'};
 sub new      return $rec if ! exists $rec->{'data'};
 {  
         my $classname   = shift;  
         my $pass = shift;  
   
         my $self        = $classname->SUPER::new(@_);      my ( $name, $encrypted ) = split /$NULL/xm, $rec->{'data'}, 2;
                         # Create a generic PDB. No need to rebless it,  
                         # though.  
   
         $self->{name} = "Keys-Gtkr";    # Default      return $rec if ! $encrypted;
         $self->{creator} = "Gtkr";      delete $rec->{'data'};
         $self->{type} = "Gkyr";      $rec->{'name'} = $name;
         $self->{attributes}{resource} = 0;      $rec->{'encrypted'} = $encrypted;
                                 # The PDB is not a resource database by  
                                 # default, but it's worth emphasizing,  
                                 # since MemoDB is explicitly not a PRC.  
   
         # Initialize the AppInfo block      return $rec;
         $self->{appinfo} = {};  }
   
         # Add the standard AppInfo block stuff  sub PackRecord {
         &Palm::StdAppInfo::seed_StdAppInfo($self->{appinfo});      my $self = shift;
       my $rec  = shift;
   
         # Set the version      my $rec0_id = $self->{'records'}->[0]->{'id'};
         $self->{version} = 4;  
   
         # Give the PDB the first record that will hold the encrypted password      if ($rec->{'encrypted'} && ! $rec->{'id'} == $rec0_id) {
         $self->{records} = [          if (! defined $rec->{'name'}) {
                 {              $rec->{'name'} = $EMPTY;
                   'category' => 0,          }
                   'attributes' => {          $rec->{'data'} = join $NULL, $rec->{'name'}, $rec->{'encrypted'};
                                                         'private' => 1,          delete $rec->{'name'};
                                                         'Secret' => 1,          delete $rec->{'encrypted'};
                                                         'Dirty' => 1,      }
                                                         'dirty' => 1  
                                                   },  
                 },  
         ];  
   
         if ($pass) {      return $self->SUPER::PackRecord($rec, @_);
                 $self->Encrypt($pass);  
         }  
   
         return $self;  
 }  }
   
 sub import  sub Encrypt {
 {      my $self = shift;
         &Palm::PDB::RegisterPDBHandlers(__PACKAGE__,      my $rec  = shift;
                 [ "Gtkr", "Gkyr" ],      my $data = shift;
                 );      my $pass = shift || $self->{'password'};
 }  
   
 sub Encrypt      if ( ! $pass) {
 {          croak("'password' not set!\n");
         my $self = shift;      }
         my $pass = shift;  
   
         if ($pass) {      if ( ! $rec) {
                 unless ($self->_keyring_verify($pass) ) {          croak("Needed parameter 'record' not passed!\n");
                         # 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;  
                 }  
         }  
   
         my $seen_enc_pass = 0;      if ( ! $data) {
         foreach my $record (@{ $self->{records} }) {          croak("Needed parameter 'data' not passed!\n");
                 unless ($seen_enc_pass) {      }
                         $seen_enc_pass = 1;  
                         next;  
                 }  
   
                 next unless defined $record->{plaintext};      if ( ! $self->Password($pass)) {
           croak("Incorrect Password!\n");
       }
   
                 my $name        = defined $record->{plaintext}->{name}        ? $record->{plaintext}->{name}        : '';      $self->{'digest'}   ||= _calc_keys( $pass );
                 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       = '';  
   
                 my $plaintext = join("\000", $account, $password, $description, $extra);      $data->{'account'}  ||= $EMPTY;
       $data->{'password'} ||= $EMPTY;
       $data->{'notes'}    ||= $EMPTY;
   
                 my $encrypted = $self->_crypt3des($plaintext, ENCRYPT);      my $changed      = 0;
       my $need_newdate = 0;
       my $acct = {};
       if ($rec->{'encrypted'}) {
           $acct = $self->Decrypt($rec, $pass);
           foreach my $key (keys %{ $data }) {
               next if $key eq 'lastchange';
               if ($data->{$key} ne $acct->{$key}) {
                   $changed = 1;
                   last;
               }
           }
           if ( exists $data->{'lastchange'} && exists $acct->{'lastchange'} && (
               $data->{'lastchange'}->{day}   != $acct->{'lastchange'}->{day}   ||
               $data->{'lastchange'}->{month} != $acct->{'lastchange'}->{month} ||
               $data->{'lastchange'}->{year}  != $acct->{'lastchange'}->{year}
           )) {
               $changed = 1;
               $need_newdate = 0;
           } else {
               $need_newdate = 1;
           }
   
                 $record->{data} = join("\000", $name, $encrypted);      } else {
         }          $changed = 1;
       }
   
         return 1;      # no need to re-encrypt if it has not changed.
 }      return 1 if ! $changed;
   
 sub Decrypt      my ($day, $month, $year);
 {  
         my $self = shift;  
         my $pass = shift;  
   
         if ($pass) {      if ($data->{'lastchange'} && ! $need_newdate ) {
                 $self->_keyring_verify($pass) || return undef;          $day   = $data->{'lastchange'}->{'day'}   || 1;
         }          $month = $data->{'lastchange'}->{'month'} || 0;
           $year  = $data->{'lastchange'}->{'year'}  || 0;
   
         my $seen_enc_pass = 0;          # XXX Need to actually validate the above information somehow
         foreach my $record (@{ $self->{records} }) {          if ($year >= 1900) {
                 unless ($seen_enc_pass) {              $year -= 1900;
                         # need to skip the first record because it is the encrypted password          }
                         $seen_enc_pass = 1;      } else {
                         next;          $need_newdate = 1;
                 }      }
   
                 next unless defined $record->{data};      if ($need_newdate) {
           ($day, $month, $year) = (localtime)[3,4,5];
       }
       $year -= 4;
       $month++;
   
                 my ($name, $encrypted) = split /\000/, $record->{data}, 2;  
                 $record->{plaintext}->{name} = $name;  
   
                 my $decrypted = $self->_crypt3des($encrypted, DECRYPT);      my $p = $day | ($month << 5) | ($year << 9);
                 my ($account, $password, $description, $extra)      my $packeddate = pack 'n', $p;
                       = split /\000/, $decrypted, 4;  
   
                 $record->{plaintext}->{account}     = defined $account     ? $account     : '';      my $plaintext = join $NULL,
                 $record->{plaintext}->{password}    = defined $password    ? $password    : '';          $data->{'account'}, $data->{'password'}, $data->{'notes'}, $packeddate;
                 $record->{plaintext}->{description} = defined $description ? $description : '';  
   
         print "Name:      '$name'\n";      my $encrypted = _crypt3des( $plaintext, $self->{'digest'}, $ENCRYPT );
         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";  
                 #--------------------------------------------------  
                 # print "Account:     $account\n";  
                 # print "Password:    $password\n";  
                 # print "Description: $description\n";  
                 #--------------------------------------------------  
   
         }      return if ! $encrypted;
   
         return 1;      $rec->{'attributes'}{'Dirty'} = 1;
       $rec->{'attributes'}{'dirty'} = 1;
       $rec->{'name'}    ||= $data->{'name'};
       $rec->{'encrypted'} = $encrypted;
   
       return 1;
 }  }
   
 sub _calc_keys  sub Decrypt {
 {      my $self = shift;
         my $self = shift;      my $rec  = shift;
       my $pass = shift || $self->{'password'};
   
         my $pass = $self->{'password'};      if ( ! $pass) {
         die "No password defined!" unless defined $pass;          croak("'password' not set!\n");
       }
   
         my $digest = md5($pass);      if ( ! $rec) {
           croak("Needed parameter 'record' not passed!\n");
       }
   
         my ($key1, $key2) = unpack('a8a8', $digest);      if ( ! $self->Password($pass)) {
         #--------------------------------------------------          croak("Invalid Password!\n");
         # print "key1: $key1: ", length $key1, "\n";      }
         # print "key2: $key2: ", length $key2, "\n";  
         #--------------------------------------------------  
   
         $digest = unpack('H*', $key1 . $key2 . $key1);      if ( ! $rec->{'encrypted'} ) {
         #--------------------------------------------------          croak("No encrypted content!");
         # print "Digest: ", $digest, "\n";      }
         # print length $digest, "\n";  
         #--------------------------------------------------  
   
         $self->{digest} = $digest;      $self->{'digest'} ||= _calc_keys( $pass );
         return $digest;  
       my $decrypted =
           _crypt3des( $rec->{'encrypted'}, $self->{'digest'}, $DECRYPT );
       my ( $account, $password, $notes, $packeddate ) = split /$NULL/xm,
             $decrypted, 4;
   
       my %Modified;
       if ($packeddate) {
           my $u = unpack 'n', $packeddate;
           my $year  = (($u & 0xFE00) >> 9) + 4; # since 1900
           my $month = (($u & 0x01E0) >> 5) - 1; # 0-11
           my $day   = (($u & 0x001F) >> 0);     # 1-31
   
           %Modified = (
               year   => $year,
               month  => $month || 0,
               day    => $day   || 1,
           );
       }
   
       return {
           name       => $rec->{'name'},
           account    => $account,
           password   => $password,
           notes      => $notes,
           lastchange => \%Modified,
       };
 }  }
   
 sub _keyring_verify  sub Password {
 {      my $self = shift;
         my $self = shift;      my $pass = shift || $self->{'password'};
         my $pass = shift;      my $new_pass = shift;
   
         die "No password specified!" unless defined $pass;      if (! exists $self->{'records'}) {
         $self->{password} = $pass;          # Give the PDB the first record that will hold the encrypted password
           $self->{'records'} = [ $self->new_Record ];
   
         # AFAIK the thing we use to test the password is          return $self->_password_update($pass);
         #     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;  
   
         $data =~ s/\0$//;      if ($new_pass) {
           my @accts = ();
           foreach my $i (0..$#{ $self->{'records'} }) {
               if ($i == 0) {
                   push @accts, undef;
                   next;
               }
               my $acct = $self->Decrypt($self->{'records'}->[$i], $pass);
               if ( ! $acct ) {
                   croak("Couldn't decrypt $self->{'records'}->[$i]->{'name'}");
               }
               push @accts, $acct;
           }
   
         my $salt = substr($data, 0, $kSaltSize);          if ( ! $self->_password_update($new_pass)) {
               croak("Couldn't set new password!");
           }
           $pass = $new_pass;
   
         my $msg = $salt . $pass;          foreach my $i (0..$#accts) {
               next if $i == 0;
               delete $self->{'records'}->[$i]->{'encrypted'};
               $self->Encrypt($self->{'records'}->[$i], $accts[$i], $pass);
           }
       }
   
         $msg .= "\0" x (MD5_CBLOCK - length($msg));      return $self->_password_verify($pass);
   }
   
         my $digest = md5($msg);  sub _calc_keys {
       my $pass = shift;
       if (! defined $pass) { croak('No password defined!'); };
   
         if ($data eq $salt . $digest) {      my $digest = md5($pass);
                 # May as well generate the keys we need now, since we know the password is right  
                 if ($self->_calc_keys()) {      my ( $key1, $key2 ) = unpack 'a8a8', $digest;
                         return 1;  
                 } else {      #--------------------------------------------------
                         return undef;      # print "key1: $key1: ", length $key1, "\n";
                 }      # print "key2: $key2: ", length $key2, "\n";
         } else {      #--------------------------------------------------
                 return undef;  
         }      $digest = unpack 'H*', $key1 . $key2 . $key1;
   
       #--------------------------------------------------
       # print "Digest: ", $digest, "\n";
       # print length $digest, "\n";
       #--------------------------------------------------
   
       return $digest;
 }  }
   
 sub _keyring_update  sub _password_verify {
 {      my $self = shift;
         # It is very important to Encrypt after calling this      my $pass = shift;
         #     (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;  
   
         die "No password specified!" unless defined $pass;      if (! $pass) { croak('No password specified!'); };
   
         # if the database already has a password in it      if (defined $self->{'password'} && $pass eq $self->{'password'}) {
         if ($self->{records}->[0]->{data}) {          # already verified this password
                 # Make sure everything is decrypted before we update the keyring          return 1;
                 $self->Decrypt() || return undef;      }
         }  
   
         my $salt;      # AFAIK the thing we use to test the password is
         for (1..$kSaltSize) {      #     always in the first entry
                 $salt .= chr(int(rand(255)));      my $data = $self->{'records'}->[0]->{'data'};
         }  
   
         my $msg = $salt . $pass;      #die "No encrypted password in file!" unless defined $data;
       if ( ! defined $data) { return; };
   
         $msg .= "\0" x (MD5_CBLOCK - length($msg));      $data =~ s/$NULL$//xm;
   
         my $digest = md5($msg);      my $salt = substr $data, 0, $kSalt_Size;
   
         my $data = $salt . $digest;# . "\0";      my $msg = $salt . $pass;
   
         # AFAIK the thing we use to test the password is      $msg .= "\0" x ( $MD5_CBLOCK - length $msg );
         #     always in the first entry  
         $self->{records}->[0]->{data} = $data;  
   
         $self->{password} = $pass;      my $digest = md5($msg);
         $self->_calc_keys();  
   
         return 1;      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;
           }
       }
       return;
 }  }
   
   sub _password_update {
   
 # XXX Have to make this encrypt as well as decrypting, but w00 h00!      # It is very important to Encrypt after calling this
 # do null padding on the end of a cleartext if we are going to encrypt it      #     (Although it is generally only called by Encrypt)
 sub _crypt3des {      # because otherwise the data will be out of sync with the
     my ( $self, $plaintext, $flag ) = @_;      # password, and that would suck!
       my $self = shift;
       my $pass = shift;
   
         my $passphrase = $self->{digest} || $self->_calc_keys();      if (! defined $pass) { croak('No password specified!'); };
     $passphrase .= ' ' x (16*3);  
     my $cyphertext = "";  
   
       my $salt;
       for ( 1 .. $kSalt_Size ) {
           $salt .= chr int rand 255;
       }
   
     my $size = length ( $plaintext );      my $msg = $salt . $pass;
     print "STRING: '$plaintext' - Length: " . length($plaintext) . "\n";  
   
     # This check should see if it is plaintext first, if it is,      $msg .= "\0" x ( $MD5_CBLOCK - length $msg );
     #   pad it with \000  
     # if not, then die  
     die "record not 8 byte padded" if (length($plaintext) % 8) && ! $flag;  
   
     my %C;      my $digest = md5($msg);
     for ( 0..2 ) {  
       $C{$_} = new Crypt::DES( pack( "H*", substr($passphrase, 16*$_, 16 )));      my $data = $salt . $digest;    # . "\0";
   
       # AFAIK the thing we use to test the password is
       #     always in the first entry
       $self->{'records'}->[0]->{'data'} = $data;
   
       $self->{'password'} = $pass;
       $self->{'digest'}   = _calc_keys( $self->{'password'} );
   
       return 1;
   }
   
   sub _crypt3des {
       my ( $plaintext, $passphrase, $flag ) = @_;
   
       $passphrase   .= $SPACE x ( 16 * 3 );
       my $cyphertext = $EMPTY;
   
       my $size = length $plaintext;
   
       #print "STRING: '$plaintext' - Length: " . (length $plaintext) . "\n";
   
       my @C;
       for ( 0 .. 2 ) {
           $C[$_] =
             new Crypt::DES( pack 'H*', ( substr $passphrase, 16 * $_, 16 ));
     }      }
   
     for ( 0 .. (($size)/8) - 1) {      for ( 0 .. ( ($size) / 8 ) ) {
      my $pt = substr( $plaintext, $_*8, 8 );          my $pt = substr $plaintext, $_ * 8, 8;
         print "PT: '$pt' - Length: " . length($pt) . "\n";  
         if (length($pt) < 8) {          #print "PT: '$pt' - Length: " . length($pt) . "\n";
           my $len = 8 - length($pt);          if (! length $pt) { next; };
           print "LENGTH: $len\n";          if ( (length $pt) < 8 ) {
           print "Binary:    '" . unpack("b*", $pt) . "'\n";              if ($flag == $DECRYPT) { croak('record not 8 byte padded'); };
           $pt .= (chr(0) x $len);# . $pt;              my $len = 8 - (length $pt);
           print "Binary:    '" . unpack("b*", $pt) . "'\n";  
           print "PT: '$pt' - Length: " . length($pt) . "\n";              #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";
         }          }
         $pt = $C{0}->decrypt( $pt );          if ( $flag == $ENCRYPT ) {
         $pt = $C{1}->encrypt( $pt );              $pt = $C[0]->encrypt($pt);
         $pt = $C{2}->decrypt( $pt );              $pt = $C[1]->decrypt($pt);
         print "PT: '$pt' - Length: " . length($pt) . "\n";              $pt = $C[2]->encrypt($pt);
         $cyphertext .= $pt;          }
     }          else {
               $pt = $C[0]->decrypt($pt);
               $pt = $C[1]->encrypt($pt);
               $pt = $C[2]->decrypt($pt);
           }
   
     return substr ( $cyphertext, 0, $size );          #print "PT: '$pt' - Length: " . length($pt) . "\n";
           $cyphertext .= $pt;
       }
   
       $cyphertext =~ s/$NULL+$//xm;
   
       #print "CT: '$cyphertext' - Length: " . length($cyphertext) . "\n";
   
       return $cyphertext;
 }  }
   
 1;  1;
 __END__  __END__
   
   =head1 NAME
   
   Palm::Keyring - Handler for Palm Keyring databases.
   
   =head1 DESCRIPTION
   
   The Keyring PDB handler is a helper class for the Palm::PDB package. It
   parses Keyring for Palm OS databases.  See
   L<http://gnukeyring.sourceforge.net/>.
   
   It has the standard Palm::PDB methods with 2 additional public methods.
   Decrypt and Encrypt.
   
   It currently supports the v4 Keyring databases.  The v5 databases from
   the pre-release keyring-2.0 are not supported.
   
   This module doesn't store the decrypted content.  It only keeps it until it
   returns it to you or encrypts it.
   
   =head1 SYNOPSIS
   
       use Palm::PDB;
       use Palm::Keyring;
   
       my $pass = 'password';
       my $file = 'Keys-Gtkr.pdb';
       my $pdb  = new Palm::PDB;
       $pdb->Load($file);
   
       foreach (0..$#{ $pdb->{'records'} }) {
           next if $_ = 0; # skip the password record
           my $rec  = $pdb->{'records'}->[$_];
           my $acct = $pdb->Decrypt($rec, $pass);
           print $rec->{'name'}, ' - ', $acct->{'account'}, "\n";
       }
   
   =head1 SUBROUTINES/METHODS
   
   =head2 new
   
       $pdb = new Palm::Keyring([$password]);
   
   Create a new PDB, initialized with the various Palm::Keyring fields
   and an empty record list.
   
   Use this method if you're creating a Keyring PDB from scratch otherwise you
   can just use Palm::PDB::new() before calling Load().
   
   =head2 Encrypt
   
       $pdb->Encrypt($rec, $acct, [$password]);
   
   Encrypts an account into a record, either with the password previously
   used, or with a password that is passed.
   
   $rec is a record from $pdb->{'records'} or a newly generated record.
   $acct is a hashref in the format below.
   
       my $acct = {
           name       => $rec->{'name'},
           account    => $account,
           password   => $password,
           notes      => $notes,
           lastchange => {
               year  => 107, # years since 1900
               month =>   0, # 0-11, 0 = January, 11 = December
               day   =>  30, # 1-31, same as localtime
           },
       };
   
   If you have changed anything other than the lastchange, or don't pass in a
   lastchange record, Encrypt() will generate a new lastchange for you.
   
   If you pass in a lastchange field that is different than the one in the
   record, it will honor what you passed in.
   
   It also only uses the $acct->{'name'} if there is not already a $rec->{'name'}.
   
   =head2 Decrypt
   
       my $acct = $pdb->Decrypt($rec[, $password]);
   
   Decrypts the record and returns a hashref for the account as described
   under Encrypt().
   
       foreach (0..$#{ $pdb->{'records'}) {
           next if $_ == 0;
           my $rec = $pdb->{'records'}->[$_];
           my $acct = $pdb->Decrypt($rec[, $password]);
           # do something with $acct
       }
   
   =head2 Password
   
       $pdb->Password([$password[, $new_password]]);
   
   Either sets the password to be used to crypt, or if you pass $new_password,
   changes the password on the database.
   
   If you have created a new $pdb, and you didn't set a password when you
   called new(), you only need to pass one password and it will set that as
   the password.
   
   If nothing is passed, and there has been a password used before,
   it just verifies that the password was correct.
   
   =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<bug-palm-keyring at rt.cpan.org>, or through the web interface at
   L<http://rt.cpan.org>.  I will be notified, and then you'll automatically be
   notified of progress on your bug as I make changes.
   
 =head1 AUTHOR  =head1 AUTHOR
   
 Andrew Fresh E<lt>andrew@mad-techies.org<gt>  Andrew Fresh E<lt>andrew@mad-techies.orgE<gt>
   
   =head1 LICENSE AND COPYRIGHT
   
   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  =head1 SEE ALSO
   
 Palm::PDB(3)  Palm::PDB(3)
   
 Palm::StdAppInfo(3)  Palm::StdAppInfo(3)
   
 =cut  The Keyring for Palm OS website:
   L<http://gnukeyring.sourceforge.net/>
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.22
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>