[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.8

version 1.2, 2006/01/31 23:03:39 version 1.8, 2006/11/10 17:31:38
Line 9 
Line 9 
 #   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$  # $Id$
 # $RedRiver: Keyring.pm,v 1.1 2006/01/26 20:54:19 andrew Exp $  # $RedRiver: Keyring.pm,v 1.7 2006/11/10 16:45:42 andrew Exp $
   
 use strict;  use strict;
 package Palm::Keyring;  package Palm::Keyring;
Line 65 
Line 65 
         my $classname   = shift;          my $classname   = shift;
         my $pass = shift;          my $pass = shift;
   
           # Create a generic PDB. No need to rebless it, though.
         my $self        = $classname->SUPER::new(@_);          my $self        = $classname->SUPER::new(@_);
                         # Create a generic PDB. No need to rebless it,  
                         # though.  
   
         $self->{name} = "Keys-Gtkr";    # Default          $self->{name} = "Keys-Gtkr";    # Default
         $self->{creator} = "Gtkr";          $self->{creator} = "Gtkr";
         $self->{type} = "Gkyr";          $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;          $self->{attributes}{resource} = 0;
                                 # 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          # Initialize the AppInfo block
         $self->{appinfo} = {};          $self->{appinfo} = {};
Line 87 
Line 86 
         $self->{version} = 4;          $self->{version} = 4;
   
         # Give the PDB the first record that will hold the encrypted password          # Give the PDB the first record that will hold the encrypted password
         $self->{records} = [          $self->{records} = [ {
                 {                  'category'   => 0,
                   'category' => 0,                  'attributes' => {
                   'attributes' => {                          'private' => 1,
                                                         'private' => 1,                          'Secret'  => 1,
                                                         'Secret' => 1,                          'Dirty'   => 1,
                                                         'Dirty' => 1,                          'dirty'   => 1,
                                                         'dirty' => 1  
                                                   },  
                 },                  },
         ];          }, ];
   
         if ($pass) {          if ($pass) {
                 $self->Encrypt($pass);                  $self->Encrypt($pass);
Line 113 
Line 110 
                 );                  );
 }  }
   
   sub Load
   {
           my $self = shift;
           $self->SUPER::Load(@_);
   
           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;
           }
           1;
   }
   
   sub Write
   {
           my $self = shift;
           $self->Encrypt() || return undef;
           return $self->SUPER::Load(@_);
   }
   
 sub Encrypt  sub Encrypt
 {  {
         my $self = shift;          my $self = shift;
         my $pass = shift;          my $pass = shift;
   
   
         if ($pass) {          if ($pass) {
                 unless ($self->_keyring_verify($pass) ) {                  unless ($self->_keyring_verify($pass) ) {
                         # This would encrypt with a new password.                          # This would encrypt with a new password.
Line 127 
Line 147 
                 }                  }
         }          }
   
         my $seen_enc_pass = 0;          $self->{digest} ||= _calc_keys($self->{password});
         foreach my $record (@{ $self->{records} }) {  
                 unless ($seen_enc_pass) {  
                         $seen_enc_pass = 1;  
                         next;  
                 }  
   
           foreach my $record (@{ $self->{records} }) {
                 next unless defined $record->{plaintext};                  next unless defined $record->{plaintext};
   
                 my $name        = defined $record->{plaintext}->{name}        ? $record->{plaintext}->{name}        : '';                  my $name        = defined $record->{plaintext}->{name}        ?
                 my $account     = defined $record->{plaintext}->{account}     ? $record->{plaintext}->{account}     : '';                          $record->{plaintext}->{name}        : '';
                 my $password    = defined $record->{plaintext}->{password}    ? $record->{plaintext}->{password}    : '';                  my $account     = defined $record->{plaintext}->{account}     ?
                 my $description = defined $record->{plaintext}->{description} ? $record->{plaintext}->{description} : '';                          $record->{plaintext}->{account}     : '';
                   my $password    = defined $record->{plaintext}->{password}    ?
                           $record->{plaintext}->{password}    : '';
                   my $description = defined $record->{plaintext}->{description} ?
                           $record->{plaintext}->{description} : '';
                 my $extra       = '';                  my $extra       = '';
   
                 my $plaintext = join("\000", $account, $password, $description, $extra);                  my $plaintext = join("\000", $account, $password, $description, $extra);
   
                 my $encrypted = $self->_crypt3des($plaintext, ENCRYPT);                  my $encrypted = _crypt3des($plaintext, $self->{digest}, ENCRYPT);
   
                 $record->{data} = join("\000", $name, $encrypted);                  $record->{data} = join("\000", $name, $encrypted);
         }          }
Line 161 
Line 181 
                 $self->_keyring_verify($pass) || return undef;                  $self->_keyring_verify($pass) || return undef;
         }          }
   
         my $seen_enc_pass = 0;          $self->{digest} ||= _calc_keys($self->{password});
         foreach my $record (@{ $self->{records} }) {  
                 unless ($seen_enc_pass) {  
                         # need to skip the first record because it is the encrypted password  
                         $seen_enc_pass = 1;  
                         next;  
                 }  
   
           foreach my $record (@{ $self->{records} }) {
                 next unless defined $record->{data};                  next unless defined $record->{data};
   
                 my ($name, $encrypted) = split /\000/, $record->{data}, 2;                  my ($name, $encrypted) = split /\000/, $record->{data}, 2;
                   next unless $encrypted;
   
                 $record->{plaintext}->{name} = $name;                  $record->{plaintext}->{name} = $name;
   
                 my $decrypted = $self->_crypt3des($encrypted, DECRYPT);                  my $decrypted = _crypt3des($encrypted, $self->{digest}, DECRYPT);
                 my ($account, $password, $description, $extra)                  my ($account, $password, $description, $extra)
                       = split /\000/, $decrypted, 4;                        = split /\000/, $decrypted, 4;
   
                 $record->{plaintext}->{account}     = defined $account     ? $account     : '';                  $record->{plaintext}->{account}     = defined $account     ?
                 $record->{plaintext}->{password}    = defined $password    ? $password    : '';                          $account     : '';
                 $record->{plaintext}->{description} = defined $description ? $description : '';                  $record->{plaintext}->{password}    = defined $password    ?
                           $password    : '';
                   $record->{plaintext}->{description} = defined $description ?
                           $description : '';
   
         print "Name:      '$name'\n";                  #print "Name:      '$name'\n";
         print "Encrypted: '$encrypted' - Length: " . length($encrypted) . "\n";                  #print "Encrypted: '$encrypted' - Length: " . length($encrypted) . "\n";
         #print "Hex:       '" . unpack("H*", $encrypted) . "'\n";                  #print "    Hex:   '" . unpack("H*", $encrypted) . "'\n";
         #print "Binary:    '" . unpack("b*", $encrypted) . "'\n";                  #print "    Binary:'" . unpack("b*", $encrypted) . "'\n";
         print "Decrypted: '$decrypted' - Length: " . length($decrypted) . "\n";                  #print "Decrypted: '$decrypted' - Length: " . length($decrypted) . "\n";
         print "Hex:       '" . unpack("H*", $decrypted) . "'\n";                  #print "    Hex:   '" . unpack("H*", $decrypted) . "'\n";
         print "Binary:    '" . unpack("b*", $decrypted) . "'\n";                  #print "    Binary:'" . unpack("b*", $decrypted) . "'\n";
         print "\n";                  #print "\n";
                 #print "Extra: $extra\n";                  #print "Extra: $extra\n";
                   #exit;
                 #--------------------------------------------------                  #--------------------------------------------------
                 # print "Account:     $account\n";                  # print "Account:     $account\n";
                 # print "Password:    $password\n";                  # print "Password:    $password\n";
Line 204 
Line 225 
   
 sub _calc_keys  sub _calc_keys
 {  {
         my $self = shift;          my $pass = shift;
   
         my $pass = $self->{'password'};  
         die "No password defined!" unless defined $pass;          die "No password defined!" unless defined $pass;
   
         my $digest = md5($pass);          my $digest = md5($pass);
Line 223 
Line 242 
         # print length $digest, "\n";          # print length $digest, "\n";
         #--------------------------------------------------          #--------------------------------------------------
   
         $self->{digest} = $digest;  
         return $digest;          return $digest;
 }  }
   
Line 232 
Line 250 
         my $self = shift;          my $self = shift;
         my $pass = shift;          my $pass = shift;
   
         die "No password specified!" unless defined $pass;          die "No password specified!" unless $pass;
         $self->{password} = $pass;          $self->{password} = $pass;
   
         # AFAIK the thing we use to test the password is          # AFAIK the thing we use to test the password is
         #     always in the first entry          #     always in the first entry
         my $data = $self->{records}->[0]->{data};          my $data = $self->{records}->[1]->{data};
         #die "No encrypted password in file!" unless defined $data;          #die "No encrypted password in file!" unless defined $data;
         return undef unless defined $data;          return undef unless defined $data;
   
Line 253 
Line 271 
   
         if ($data eq $salt . $digest) {          if ($data eq $salt . $digest) {
                 # May as well generate the keys we need now, since we know the password is right                  # May as well generate the keys we need now, since we know the password is right
                 if ($self->_calc_keys()) {                  $self->{digest} = _calc_keys($self->{password});
                   if ($self->{digest}) {
                         return 1;                          return 1;
                 } else {                  } else {
                         return undef;                          return undef;
Line 272 
Line 291 
         my $self = shift;          my $self = shift;
         my $pass = shift;          my $pass = shift;
   
         die "No password specified!" unless defined $pass;          die "No password specified!" unless $pass;
   
         # if the database already has a password in it          # if the database already has a password in it
         if ($self->{records}->[0]->{data}) {          if ($self->{records}->[1]->{data}) {
                 # Make sure everything is decrypted before we update the keyring                  # Make sure everything is decrypted before we update the keyring
                 $self->Decrypt() || return undef;                  $self->Decrypt() || return undef;
         }          }
Line 295 
Line 314 
   
         # AFAIK the thing we use to test the password is          # AFAIK the thing we use to test the password is
         #     always in the first entry          #     always in the first entry
         $self->{records}->[0]->{data} = $data;          $self->{records}->[1]->{data} = $data;
   
         $self->{password} = $pass;          $self->{password} = $pass;
         $self->_calc_keys();          $self->{digest}   = _calc_keys($self->{password});
   
         return 1;          return 1;
 }  }
   
   
 # XXX Have to make this encrypt as well as decrypting, but w00 h00!  # XXX It looks like they are using des_ecb2_encrypt so I dunno if that is different
 # do null padding on the end of a cleartext if we are going to encrypt it  
 sub _crypt3des {  sub _crypt3des {
     my ( $self, $plaintext, $flag ) = @_;          my ( $plaintext, $passphrase, $flag ) = @_;
   
         my $passphrase = $self->{digest} || $self->_calc_keys();          $passphrase .= ' ' x (16*3);
     $passphrase .= ' ' x (16*3);          my $cyphertext = "";
     my $cyphertext = "";  
   
           my $size = length ( $plaintext );
           #print "STRING: '$plaintext' - Length: " . length($plaintext) . "\n";
   
     my $size = length ( $plaintext );          my @C;
     print "STRING: '$plaintext' - Length: " . length($plaintext) . "\n";          for ( 0..2 ) {
                   $C[$_] = new Crypt::DES( pack( "H*", substr($passphrase, 16*$_, 16 )));
           }
   
     # This check should see if it is plaintext first, if it is,          for ( 0 .. (($size)/8) - 1) {
     #   pad it with \000                  my $pt = substr( $plaintext, $_*8, 8 );
     # if not, then die                  #print "PT: '$pt' - Length: " . length($pt) . "\n";
     die "record not 8 byte padded" if (length($plaintext) % 8) && ! $flag;                  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 .= (chr(0) x $len);# . $pt;
                           #print "Binary:    '" . unpack("b*", $pt) . "'\n";
                           #print "PT: '$pt' - Length: " . length($pt) . "\n";
                   }
                   $pt = $C[0]->decrypt( $pt );
                   $pt = $C[1]->encrypt( $pt );
                   $pt = $C[2]->decrypt( $pt );
                   #print "PT: '$pt' - Length: " . length($pt) . "\n";
                   $cyphertext .= $pt;
           }
   
     my %C;          return substr ( $cyphertext, 0, $size );
     for ( 0..2 ) {  
       $C{$_} = new Crypt::DES( pack( "H*", substr($passphrase, 16*$_, 16 )));  
     }  
   
     for ( 0 .. (($size)/8) - 1) {  
      my $pt = substr( $plaintext, $_*8, 8 );  
         print "PT: '$pt' - Length: " . length($pt) . "\n";  
         if (length($pt) < 8) {  
           my $len = 8 - length($pt);  
           print "LENGTH: $len\n";  
           print "Binary:    '" . unpack("b*", $pt) . "'\n";  
           $pt .= (chr(0) x $len);# . $pt;  
           print "Binary:    '" . unpack("b*", $pt) . "'\n";  
           print "PT: '$pt' - Length: " . length($pt) . "\n";  
         }  
         $pt = $C{0}->decrypt( $pt );  
         $pt = $C{1}->encrypt( $pt );  
         $pt = $C{2}->decrypt( $pt );  
         print "PT: '$pt' - Length: " . length($pt) . "\n";  
         $cyphertext .= $pt;  
     }  
   
     return substr ( $cyphertext, 0, $size );  
 }  }
   
 1;  1;
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.8
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>