[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.34 and 1.38

version 1.34, 2007/02/21 05:24:14 version 1.38, 2007/02/23 02:54:49
Line 1 
Line 1 
 package Palm::Keyring;  package Palm::Keyring;
 # $RedRiver: Keyring.pm,v 1.33 2007/02/21 01:26:07 andrew Exp $  # $RedRiver: Keyring.pm,v 1.37 2007/02/23 02:34:01 andrew Exp $
 ########################################################################  ########################################################################
 # Keyring.pm *** Perl class for Keyring for Palm OS databases.  # Keyring.pm *** Perl class for Keyring for Palm OS databases.
 #  #
Line 168 
Line 168 
     } elsif ($self->{version} == 5) {      } elsif ($self->{version} == 5) {
         my $blocksize = $CRYPTS[ $self->{appinfo}->{cipher} ]{blocksize};          my $blocksize = $CRYPTS[ $self->{appinfo}->{cipher} ]{blocksize};
         my ($field, $extra) = _parse_field($rec->{data});          my ($field, $extra) = _parse_field($rec->{data});
         my $ivec      = substr $extra, 0, $blocksize;          delete $rec->{data};
         my $encrypted = substr $extra, $blocksize;  
   
         $rec->{name}      = $field->{data};          $rec->{name}      = $field->{data};
         $rec->{ivec}      = $ivec;          $rec->{ivec}      = substr $extra, 0, $blocksize;
         $rec->{encrypted} = $encrypted;          $rec->{encrypted} = substr $extra, $blocksize;
         delete $rec->{data};  
   
     } else {      } else {
         die 'Unsupported Version';          die 'Unsupported Version';
Line 202 
Line 200 
         }          }
   
     } elsif ($self->{version} == 5) {      } elsif ($self->{version} == 5) {
         my $field = {          my $field;
             'label_id' => 1,          if ($rec->{name}) {
             'data'     => $rec->{name},              $field = {
             'font'     => 0,                  'label_id' => 1,
         };                  'data'     => $rec->{name},
         my $packed .= _pack_field($field);                  'font'     => 0,
               };
           } else {
               $field = {
                   'label_id' => $EMPTY,
                   'data'     => $EMPTY,
                   'font'     => 0,
               };
           }
           my $packed = _pack_field($field);
   
         $rec->{data} = join '', $packed, $rec->{ivec}, $rec->{encrypted};          $rec->{data} = join '', $packed, $rec->{ivec}, $rec->{encrypted};
   
Line 262 
Line 269 
   
     my $unpackstr      my $unpackstr
         = ("C1" x 8)  # 8 uint8s in an array for the salt          = ("C1" x 8)  # 8 uint8s in an array for the salt
         . ("S1" x 2)  # the iter (uint16) and the cipher (uint16)          . ("n1" x 2)  # the iter (uint16) and the cipher (uint16)
         . ("C1" x 8); # and finally 8 more uint8s for the hash          . ("C1" x 8); # and finally 8 more uint8s for the hash
   
     my (@salt, $iter, $cipher, @hash);      my (@salt, $iter, $cipher, @hash);
Line 303 
Line 310 
   
     my $packstr      my $packstr
         = ("C1" x 8)  # 8 uint8s in an array for the salt          = ("C1" x 8)  # 8 uint8s in an array for the salt
         . ("S1" x 2)  # the iter (uint16) and the cipher (uint16)          . ("n1" x 2)  # the iter (uint16) and the cipher (uint16)
         . ("C1" x 8); # and finally 8 more uint8s for the hash          . ("C1" x 8); # and finally 8 more uint8s for the hash
   
     my @salt = map { hex $_ } $appinfo->{salt} =~ /../gxm;      my @salt = map { hex $_ } $appinfo->{salt} =~ /../gxm;
Line 407 
Line 414 
   
 sub _encrypt_v4  sub _encrypt_v4
 {  {
     require Crypt::CBC;  
   
     my $new    = shift;      my $new    = shift;
     my $old    = shift;      my $old    = shift;
     my $digest = shift;      my $digest = shift;
Line 496 
Line 501 
     my $date_index;      my $date_index;
     for (my $i = 0; $i < @{ $new }; $i++) {      for (my $i = 0; $i < @{ $new }; $i++) {
         if (          if (
             (exists $new->[$i]->{label_id} && $new->[$i]->{label_id} == 3) ||              ($new->[$i]->{label_id} && $new->[$i]->{label_id} == 3) ||
             (exists $new->[$i]->{label}    && $new->[$i]->{label}    eq 'lastchange')              ($new->[$i]->{label} && $new->[$i]->{label} eq 'lastchange')
         ) {          ) {
             $date_index   = $i;              $date_index   = $i;
             if ( $old && $#{ $new } == $#{ $old } && (              if ( $old && $#{ $new } == $#{ $old } && (
                     $new->[$i]->{data}->{day}   != $old->[$i]->{data}->{day}   ||                      $new->[$i]{data}{day}   != $old->[$i]{data}{day}   ||
                     $new->[$i]->{data}->{month} != $old->[$i]->{data}->{month} ||                      $new->[$i]{data}{month} != $old->[$i]{data}{month} ||
                     $new->[$i]->{data}->{year}  != $old->[$i]->{data}->{year}                      $new->[$i]{data}{year}  != $old->[$i]{data}{year}
                 )) {                  )) {
                 $changed      = 1;                  $changed      = 1;
                 $need_newdate = 0;                  $need_newdate = 0;
                 last;  
             }              }
   
         } elsif ($old && $#{ $new } == $#{ $old }) {          } elsif ($old && $#{ $new } == $#{ $old }) {
Line 559 
Line 563 
         $encrypted = $decrypted;          $encrypted = $decrypted;
   
     } elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') {      } elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') {
           require Crypt::CBC;
         my $c = Crypt::CBC->new(          my $c = Crypt::CBC->new(
             -literal_key => 1,  
             -key         => $key,              -key         => $key,
               -literal_key => 1,
             -iv          => $ivec,              -iv          => $ivec,
             -cipher      => $cipher_name,              -cipher      => $cipher_name,
             -keysize     => $keylen,              -keysize     => $keylen,
Line 659 
Line 664 
   
 sub _decrypt_v5  sub _decrypt_v5
 {  {
     require Crypt::CBC;  
   
     my $encrypted = shift;      my $encrypted = shift;
     my $key       = shift;      my $key       = shift;
Line 677 
Line 681 
         $decrypted = $encrypted;          $decrypted = $encrypted;
   
     } elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') {      } elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') {
           require Crypt::CBC;
         my $c = Crypt::CBC->new(          my $c = Crypt::CBC->new(
             -literal_key => 1,  
             -key         => $key,              -key         => $key,
               -literal_key => 1,
             -iv          => $ivec,              -iv          => $ivec,
             -cipher      => $cipher_name,              -cipher      => $cipher_name,
             -keysize     => $keylen,              -keysize     => $keylen,
Line 791 
Line 796 
             }              }
         }          }
     } elsif ($self->{version} == 5) {      } elsif ($self->{version} == 5) {
         return _password_verify_v5($pass, $self->{appinfo});          return _password_verify_v5($self->{appinfo}, $pass);
     } else {      } else {
         # XXX unsupported version          # XXX unsupported version
     }      }
Line 830 
Line 835 
   
 sub _password_verify_v5  sub _password_verify_v5
 {  {
     my $pass    = shift;  
     my $appinfo = shift;      my $appinfo = shift;
       my $pass    = shift;
   
     my $salt = pack("H*", $appinfo->{salt});      my $salt = pack("H*", $appinfo->{salt});
   
Line 841 
Line 846 
         $CRYPTS[ $appinfo->{cipher} ]{DES_odd_parity},          $CRYPTS[ $appinfo->{cipher} ]{DES_odd_parity},
     );      );
   
       #print "Iter: '" . $appinfo->{iter} . "'\n";
     #print "Key:  '". unpack("H*", $key) . "'\n";      #print "Key:  '". unpack("H*", $key) . "'\n";
       #print "Salt: '". unpack("H*", $salt) . "'\n";
     #print "Hash: '". $hash . "'\n";      #print "Hash: '". $hash . "'\n";
     #print "Hash: '". $appinfo->{masterhash} . "'\n";      #print "Hash: '". $appinfo->{masterhash} . "'\n";
   
Line 1060 
Line 1067 
     $labels[3]   = 'lastchange';      $labels[3]   = 'lastchange';
     $labels[255] = 'notes';      $labels[255] = 'notes';
   
     my ($len) = unpack "S1", $field;      my ($len) = unpack "n1", $field;
     if ($len + 4 > length $field) {      if ($len + 4 > length $field) {
         return undef, $field;          return undef, $field;
     }      }
Line 1075 
Line 1082 
     my ($label, $font, $data) = unpack $unpackstr, $field;      my ($label, $font, $data) = unpack $unpackstr, $field;
     my $leftover = substr $field, $offset;      my $leftover = substr $field, $offset;
   
     if ($label == 3) {      if ($label && $label == 3) {
         $data = _parse_keyring_date($data);          $data = _parse_keyring_date($data);
     }      }
     return {      return {
Line 1099 
Line 1106 
         notes      => 255,          notes      => 255,
     );      );
   
     my $label = $field->{label_id} || $labels{ $field->{label} };      my $packed;
     my $font  = $field->{font}     || 0;      if (defined $field) {
     my $data  = $field->{data}     || '';          my $label = $field->{label_id} || 0;
           if (defined $field->{label} && ! $label) {
               $label = $labels{ $field->{label} };
           }
           my $font  = $field->{font} || 0;
           my $data  = defined $field->{data} ? $field->{data} : $EMPTY;
   
     if ($label == 3) {          if ($label && $label == 3) {
         $data = _pack_keyring_date($data);              $data = _pack_keyring_date($data);
     }          }
     my $len = length $data;          my $len = length $data;
     my $packstr = "S1 C1 C1 A*";          my $packstr = "n1 C1 C1 A*";
   
     my $packed = pack $packstr, ($len, $label, $font, $data);          $packed = pack $packstr, ($len, $label, $font, $data);
   
     if ($len % 2) {          if ($len % 2) {
         # add byte padding for next even address.              # add byte padding for next even address.
         $packed .= $NULL;              $packed .= $NULL;
           }
       } else {
           my $packstr = "n1 C1 C1 x1";
           $packed = pack $packstr, 0, 0, 0;
     }      }
   
     return $packed;      return $packed;
Line 1265 
Line 1281 
 It has the standard Palm::PDB methods with 2 additional public methods.  It has the standard Palm::PDB methods with 2 additional public methods.
 Decrypt and Encrypt.  Decrypt and Encrypt.
   
 It currently supports the v4 Keyring databases.  It currently supports the v4 Keyring databases as well as
 The pre-release v5 databases are mostly supported.  There are definitely some  the pre-release v5 databases.  I am not completely happy with the interface
 bugs,  For example, t/keyring5.t sometimes fails.  I am not sure why yet.  for accessing the v5 database, so any suggestions on improvements on
   the interface are appreciated.
   
 This module doesn't store the decrypted content.  It only keeps it until it  This module doesn't store the decrypted content.  It only keeps it until it
 returns it to you or encrypts it.  returns it to you or encrypts it.
Line 1287 
Line 1304 
         next if $_ == 0 && $pdb->{version} == 4;          next if $_ == 0 && $pdb->{version} == 4;
         my $rec  = $pdb->{records}->[$_];          my $rec  = $pdb->{records}->[$_];
         my $acct = $pdb->Decrypt($rec, $pass);          my $acct = $pdb->Decrypt($rec, $pass);
         print $rec->{name}, ' - ', $acct->{account}, "\n";          print $rec->{name}, ' - ';
           if ($pdb->{version} == 4 || $pdb->{options}->{v4compatible}) {
               print ' - ', $acct->{account};
           } else {
               foreach my $a (@{ $acct }) {
                   if ($a->{label} eq 'account') {
                       print ' - ',  $a->{data};
                       last;
                   }
               }
           }
           print "\n";
     }      }
   
 =head1 SUBROUTINES/METHODS  =head1 SUBROUTINES/METHODS
Line 1310 
Line 1338 
     $pdb = new Palm::Keyring({ key1 => value1,  key2 => value2 });      $pdb = new Palm::Keyring({ key1 => value1,  key2 => value2 });
     $pdb = new Palm::Keyring( -key1 => value1, -key2 => value2);      $pdb = new Palm::Keyring( -key1 => value1, -key2 => value2);
   
 =head3 Supported options are:  =over
   
   =item Supported options
   
 =over  =over
   
 =item password  =item password
Line 1340 
Line 1370 
   
 The number of iterations to encrypt with.  The number of iterations to encrypt with.
   
   =item options
   
   A hashref of the options that are set
   
 =back  =back
   
   =back
   
   For v5 databases there are some additional appinfo fields set.
   
       $pdb->{appinfo} = {
           # normal appinfo stuff described in L<Palm::StdAppInfo>
           cipher     => The index number of the cipher being used
           iter       => Number of iterations for the cipher
       };
   
 =head2 crypt  =head2 crypt
   
 Pass in the alias of the crypt to use, or the index.  Pass in the alias of the crypt to use, or the index.
   
   These only make sense for v5 databases.
   
 This is a function, not a method.  This is a function, not a method.
   $cipher can be 0, 1, 2, 3, None, DES_EDE3, AES128 or AES256.
   
     my $c = Palm::Keyring::crypt($cipher);      my $c = Palm::Keyring::crypt($cipher);
   
Line 1360 
Line 1407 
         default_iter => <default iterations for the cipher>,          default_iter => <default iterations for the cipher>,
     };      };
   
   
 =head2 Encrypt  =head2 Encrypt
   
     $pdb->Encrypt($rec, $acct[, $password[, $ivec]]);      $pdb->Encrypt($rec, $acct[, $password[, $ivec]]);
Line 1416 
Line 1462 
   
   
 The account name is stored in $rec->{name} for both v4 and v5 databases.  The account name is stored in $rec->{name} for both v4 and v5 databases.
 It is not returned in the decrypted information for v5.  It is not returned in the decrypted information for v5.
   
     $rec->{name} = 'account name';      $rec->{name} = 'account name';
   
Line 1455 
Line 1501 
 the password.  the password.
   
 If nothing is passed, it forgets the password that it was remembering.  If nothing is passed, it forgets the password that it was remembering.
   
   After a successful password verification the following fields are set
   
   For v4
   
       $pdb->{digest}   = the calculated digest used from the key;
       $pdb->{password} = the password that was passed in;
   
   For v5
   
       $pdb->{appinfo} = {
           # As described under new() with these additional fields
           cipher     => The index number of the cipher being used
           iter       => Number of iterations for the cipher
           key        => The key that is calculated from the password
                         and salt and is used to decrypt the records.
           masterhash => the hash of the key that is stored in the
                         database.  Either set when Loading the database
                         or when setting a new password.
           salt       => the salt that is either read out of the database
                         or calculated when setting a new password.
       };
   
 =head1 DEPENDENCIES  =head1 DEPENDENCIES
   
Legend:
Removed from v.1.34  
changed lines
  Added in v.1.38
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>