===================================================================
RCS file: /cvs/palm/Palm-Keyring/lib/Palm/Keyring.pm,v
retrieving revision 1.33
retrieving revision 1.34
diff -u -r1.33 -r1.34
--- palm/Palm-Keyring/lib/Palm/Keyring.pm	2007/02/21 01:26:07	1.33
+++ palm/Palm-Keyring/lib/Palm/Keyring.pm	2007/02/21 05:24:14	1.34
@@ -1,5 +1,5 @@
 package Palm::Keyring;
-# $RedRiver: Keyring.pm,v 1.32 2007/02/19 03:33:56 andrew Exp $
+# $RedRiver: Keyring.pm,v 1.33 2007/02/21 01:26:07 andrew Exp $
 ########################################################################
 # Keyring.pm *** Perl class for Keyring for Palm OS databases.
 #
@@ -28,26 +28,30 @@
 my $NULL       = chr 0;
 
 my @CRYPTS = (
-    { # None
+    { 
+        alias     => 'None',
         name      => 'None',
         keylen    => 8,
         blocksize => 1,
         default_iter => 500,
     },
-    { # DES-EDE3
+    { 
+        alias     => 'DES-EDE3',
         name      => 'DES_EDE3',
         keylen    => 24,
         blocksize =>  8,
         DES_odd_parity => 1,
         default_iter => 1000,
     },
-    { # AES128
+    {   
+        alias     => 'AES128',
         name      => 'Rijndael',
         keylen    => 16,
         blocksize => 16,
         default_iter => 100,
     },
-    { # AES256
+    { 
+        alias     => 'AES256',
         name      => 'Rijndael',
         keylen    => 32,
         blocksize => 16,
@@ -123,6 +127,24 @@
     return 1;
 }
 
+# Accessors
+
+sub crypts
+{
+    my $crypt = shift;
+    if ($crypt =~ /\D/) {
+        foreach my $c (@CRYPTS) {
+            if ($c->{alias} eq $crypt) {
+                return $c;
+            }
+        }
+        # didn't find it.
+        return;
+    } else {
+        return $CRYPTS[$crypt];
+    }
+}
+
 # ParseRecord
 
 sub ParseRecord 
@@ -152,6 +174,7 @@
         $rec->{name}      = $field->{data};
         $rec->{ivec}      = $ivec;
         $rec->{encrypted} = $encrypted;
+        delete $rec->{data};
 
     } else {
         die 'Unsupported Version';
@@ -306,6 +329,7 @@
     my $rec  = shift;
     my $data = shift;
     my $pass = shift || $self->{password};
+    my $ivec = shift;
 
     if ( ! $pass && ! $self->{appinfo}->{key}) {
         croak("password not set!\n");
@@ -335,31 +359,30 @@
         $rec->{name}    ||= $data->{name};
 
     } elsif ($self->{version} == 5) {
-        my @recs = ($data, $acct);
-        my $name;
+        my @accts = ($data, $acct);
         if ($self->{options}->{v4compatible}) {
             $rec->{name} ||= $data->{name};
-            foreach my $rec (@recs) {
+            foreach my $a (@accts) {
                 my @fields;
-                foreach my $k (sort keys %{ $rec }) {
+                foreach my $k (sort keys %{ $a }) {
                     my $field = {
                         label    => $k,
                         font     => 0,
-                        data     => $rec->{$k},
+                        data     => $a->{$k},
                     };
                     push @fields, $field;
                 }
-                $rec = \@fields;
+                $a = \@fields;
             }
         }
 
-        my $ivec;
         ($encrypted, $ivec) = _encrypt_v5(
-            @recs,
+            @accts,
             $self->{appinfo}->{key}, 
             $self->{appinfo}->{cipher},
+            $ivec,
         );
-        if ($ivec) {
+        if (defined $ivec) {
             $rec->{ivec} = $ivec;
         }
 
@@ -459,12 +482,15 @@
     my $old    = shift;
     my $key    = shift;
     my $cipher = shift;
-    my $length = $CRYPTS[ $cipher ]{blocksize};
-    my $ivec   = shift || pack("C*",map {rand(256)} 1..$length);
-
+    my $ivec   = shift;
+    my $blocksize   = $CRYPTS[ $cipher ]{blocksize};
     my $keylen      = $CRYPTS[ $cipher ]{keylen}; 
     my $cipher_name = $CRYPTS[ $cipher ]{name};
 
+    if (! defined $ivec) { 
+        $ivec = pack("C*",map {rand(256)} 1..$blocksize);
+    }
+
     my $changed = 0;
     my $need_newdate = 1;
     my $date_index;
@@ -527,7 +553,6 @@
     foreach my $field (@{ $new }) {
         $decrypted .= _pack_field($field);
     }
-
     my $encrypted;
     if ($cipher_name eq 'None') {
         # do nothing
@@ -540,6 +565,7 @@
             -iv          => $ivec,
             -cipher      => $cipher_name,
             -keysize     => $keylen,
+            -blocksize   => $blocksize,
             -header      => 'none',
             -padding     => 'oneandzeroes',
         );
@@ -634,6 +660,7 @@
 sub _decrypt_v5
 {
     require Crypt::CBC;
+
     my $encrypted = shift;
     my $key       = shift;
     my $cipher    = shift;
@@ -641,6 +668,7 @@
 
     my $keylen       = $CRYPTS[ $cipher ]{keylen};
     my $cipher_name  = $CRYPTS[ $cipher ]{name};
+    my $blocksize    = $CRYPTS[ $cipher ]{blocksize};
 
     my $decrypted;
 
@@ -655,6 +683,7 @@
             -iv          => $ivec,
             -cipher      => $cipher_name,
             -keysize     => $keylen,
+            -blocksize   => $blocksize,
             -header      => 'none',
             -padding     => 'oneandzeroes',
         );
@@ -662,7 +691,8 @@
         if (! $c) {
             croak("Unable to set up encryption!");
         }
-        $encrypted .= $NULL x $keylen; # pad out a keylen
+        my $len = $blocksize - length($encrypted) % $blocksize;
+        $encrypted .= $NULL x $len;
         $decrypted  = $c->decrypt($encrypted);
 
     } else {
@@ -925,6 +955,7 @@
     return $key;
 }
 
+# Helpers
 
 sub _calc_keys 
 {
@@ -1033,15 +1064,16 @@
     if ($len + 4 > length $field) {
         return undef, $field;
     }
-    my $unpackstr = "S1 C1 C1 A$len";
-    if ($len % 2 && $len + 4 < length $field) {
+    my $unpackstr = "x2 C1 C1 A$len";
+    my $offset    =   2 +1 +1 +$len;
+    if ($len % 2) { # && $len + 4 < length $field) {
         # trim the 0/1 byte padding for next even address.
+        $offset++;
         $unpackstr .= ' x' 
     }
-    $unpackstr .= ' A*';
 
-    my (undef, $label, $font, $data, $leftover) 
-        = unpack $unpackstr, $field;
+    my ($label, $font, $data) = unpack $unpackstr, $field;
+    my $leftover = substr $field, $offset;
 
     if ($label == 3) {
         $data = _parse_keyring_date($data);
@@ -1310,12 +1342,35 @@
 
 =back
 
+=head2 crypt
+
+Pass in the alias of the crypt to use, or the index.
+
+This is a function, not a method.  
+
+    my $c = Palm::Keyring::crypt($cipher);
+
+$c is now:
+
+    $c = {
+        alias     => (None|DES_EDE3|AES128|AES256),
+        name      => (None|DES_EDE3|Rijndael),
+        keylen    => <key length of the ciphe>,
+        blocksize => <block size of the cipher>,
+        default_iter => <default iterations for the cipher>,
+    };
+
+
 =head2 Encrypt
 
-    $pdb->Encrypt($rec, $acct[, $password]);
+    $pdb->Encrypt($rec, $acct[, $password[, $ivec]]);
 
 Encrypts an account into a record, either with the password previously 
 used, or with a password that is passed.
+
+$ivec is the initialization vector to use to encrypt the record.  This is
+not used by v4 databases.  Normally this is not passed and is generated 
+randomly.
 
 $rec is a record from $pdb->{records} or a new_Record().
 The v4 $acct is a hashref in the format below.