===================================================================
RCS file: /cvs/palm/Palm-Keyring/lib/Palm/Keyring.pm,v
retrieving revision 1.1
retrieving revision 1.10
diff -u -r1.1 -r1.10
--- palm/Palm-Keyring/lib/Palm/Keyring.pm	2006/01/26 20:54:19	1.1
+++ palm/Palm-Keyring/lib/Palm/Keyring.pm	2006/12/06 18:45:42	1.10
@@ -8,8 +8,8 @@
 #
 #   This started as Memo.pm, I just made it work for Keyring.
 #
-# $Id: Keyring.pm,v 1.1 2006/01/26 20:54:19 andrew Exp $
-# $RedRiver$
+# $Id: Keyring.pm,v 1.10 2006/12/06 18:45:42 andrew Exp $
+# $RedRiver: Keyring.pm,v 1.9 2006/11/10 17:49:51 andrew Exp $
 
 use strict;
 package Palm::Keyring;
@@ -18,7 +18,7 @@
 use vars qw( $VERSION @ISA );
 
 use Digest::MD5 qw(md5);
-use Crypt::TripleDES;
+use Crypt::DES;
 
 use constant ENCRYPT    =>  1;
 use constant DECRYPT    =>  0;
@@ -27,7 +27,7 @@
 
 
 # One liner, to allow MakeMaker to work.
-$VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
+$VERSION = do { my @r = (q$Revision: 1.10 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };
 
 @ISA = qw( Palm::StdAppInfo Palm::Raw );
 
@@ -65,17 +65,16 @@
 	my $classname	= shift;
 	my $pass = shift;
 
+	# Create a generic PDB. No need to rebless it, though.
 	my $self	= $classname->SUPER::new(@_);
-			# Create a generic PDB. No need to rebless it,
-			# though.
 
 	$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;
-				# 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
 	$self->{appinfo} = {};
@@ -87,17 +86,7 @@
 	$self->{version} = 4;
 
 	# Give the PDB the first record that will hold the encrypted password
-	$self->{records} = [
-		{
-		  'category' => 0,
-		  'attributes' => {
-							'private' => 1,
-							'Secret' => 1,
-							'Dirty' => 1,
-							'dirty' => 1
-						  },
-		},
-	];
+	$self->{records} = [ $self->new_Record ];
 
 	if ($pass) {
 		$self->Encrypt($pass);
@@ -113,11 +102,36 @@
 		);
 }
 
+sub Load
+{
+	my $self = shift;
+	$self->{'appinfo'} = {};
+	$self->{'records'} = [];
+	$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::Write(@_);
+}
+
 sub Encrypt
 {
 	my $self = shift;
 	my $pass = shift;
 
+
 	if ($pass) {
 		unless ($self->_keyring_verify($pass) ) {
 			# This would encrypt with a new password.  
@@ -127,26 +141,26 @@
 		}
 	}
 
-	my $seen_enc_pass = 0;
-	foreach my $record (@{ $self->{records} }) {
-		unless ($seen_enc_pass) {
-			$seen_enc_pass = 1;
-			next;
-		}
+	$self->{digest} ||= _calc_keys($self->{password});
 
+	foreach my $record (@{ $self->{records} }) {
 		next unless defined $record->{plaintext};
 
-		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 $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       = '';
 
-		my $plaintext = join("\0", $account, $password, $description, $extra);
+		my $plaintext = join("\000", $account, $password, $description, $extra);
 
-		my $encrypted = $self->_crypt($plaintext, ENCRYPT);
+		my $encrypted = _crypt3des($plaintext, $self->{digest}, ENCRYPT);
 
-		$record->{data} = join("\0", $name, $encrypted);
+		$record->{data} = join("\000", $name, $encrypted);
 	}
 
 	return 1;
@@ -161,28 +175,37 @@
 		$self->_keyring_verify($pass) || return undef;
 	}
 
-	my $seen_enc_pass = 0; 
-	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;
-		}
+	$self->{digest} ||= _calc_keys($self->{password});
 
+	foreach my $record (@{ $self->{records} }) {
 		next unless defined $record->{data};
 
-		my ($name, $encrypted) = split /\0/, $record->{data};
+		my ($name, $encrypted) = split /\000/, $record->{data}, 2;
+		next unless $encrypted;
+
 		$record->{plaintext}->{name} = $name;
 
-		my $decrypted = $self->_crypt($encrypted, DECRYPT);
+		my $decrypted = _crypt3des($encrypted, $self->{digest}, DECRYPT);
 		my ($account, $password, $description, $extra) 
-		      = split /\0/, $decrypted, 4;
+		      = split /\000/, $decrypted, 4;
 
-		$record->{plaintext}->{account}     = defined $account     ? $account     : '';
-		$record->{plaintext}->{password}    = defined $password    ? $password    : '';
-		$record->{plaintext}->{description} = defined $description ? $description : '';
+		$record->{plaintext}->{account}     = defined $account     ? 
+			$account     : '';
+		$record->{plaintext}->{password}    = defined $password    ? 
+			$password    : '';
+		$record->{plaintext}->{description} = defined $description ? 
+			$description : '';
 
+		#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";
@@ -194,29 +217,9 @@
 	return 1;
 }
 
-sub _crypt
-{
-	my $self = shift;
-	my $original = shift;
-	my $flag = shift;
-
-	my $digest = $self->{digest} || $self->_calc_keys();
-	#print "DIGEST: $digest\n";
-
-	my $des = new Crypt::TripleDES;
-
-	if ($flag == ENCRYPT) {
-		return $des->encrypt3($original, $digest);
-	} else {
-		return $des->decrypt3($original, $digest);
-	}
-}
-
 sub _calc_keys
 {
-	my $self = shift;
-
-	my $pass = $self->{'password'};
+	my $pass = shift;
 	die "No password defined!" unless defined $pass;
 
 	my $digest = md5($pass);
@@ -233,7 +236,6 @@
 	# print length $digest, "\n";
 	#-------------------------------------------------- 
 
-	$self->{digest} = $digest;
 	return $digest;
 }
 
@@ -242,7 +244,7 @@
 	my $self = shift;
 	my $pass = shift;
 
-	die "No password specified!" unless defined $pass;
+	die "No password specified!" unless $pass;
 	$self->{password} = $pass;
 
 	# AFAIK the thing we use to test the password is 
@@ -263,7 +265,8 @@
 
 	if ($data eq $salt . $digest) {
 		# 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;
 		} else {
 			return undef;
@@ -282,7 +285,7 @@
 	my $self = 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 ($self->{records}->[0]->{data}) {
@@ -308,11 +311,71 @@
 	$self->{records}->[0]->{data} = $data;
 
 	$self->{password} = $pass;
-	$self->_calc_keys();
+	$self->{digest}   = _calc_keys($self->{password});
 
 	return 1;
 }
 
+
+# XXX It looks like they are using des_ecb2_encrypt so I dunno if that is different
+sub _crypt3des { 
+	my ( $plaintext, $passphrase, $flag ) = @_; 
+	my $NULL = chr(0);
+
+	$passphrase .= ' ' x (16*3); 
+	my $cyphertext = "";
+
+	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 )));
+	}
+
+
+# XXX From Crypt::TripleDES
+# http://search.cpan.org/src/VIPUL/Crypt-TripleDES-0.24/lib/Crypt/TripleDES.pm
+#
+#    for ( 0 .. (($size)/8) -1 ) { 
+#     my $pt = substr( $plaintext, $_*8, 8 );
+#        $pt = Crypt::PPDES::des_ecb_encrypt( $flag ? $keyvecs{0} : $keyvecs{2}, $flag, $pt );
+#        $pt = Crypt::PPDES::des_ecb_encrypt( $keyvecs{1}, (not $flag), $pt );
+#        $pt = Crypt::PPDES::des_ecb_encrypt( $flag ? $keyvecs{2} : $keyvecs{0}, $flag, $pt );
+#        $cyphertext .= $pt; 
+#    } 
+
+	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; 
+	} 
+
+	$cyphertext =~ s/$NULL+$//;
+	#print "CT: '$cyphertext' - Length: " . length($cyphertext) . "\n";
+
+	return $cyphertext;
+}
 
 1;
 __END__