palm/Palm-Keyring/lib/Palm/Keyring.pm - diff

Return to Keyring.pm CVS log

Up to [local] / palm / Palm-Keyring / lib / Palm

Diff for /palm/Palm-Keyring/lib/Palm/Keyring.pm between version 1.6 and 1.9

version 1.6, 2006/11/10 16:18:59

version 1.9, 2006/11/10 17:49:51

Line 9

# This started as Memo.pm, I just made it work for Keyring.

# $Id$

# $RedRiver: Keyring.pm,v 1.5 2006/11/10 04:52:27 andrew Exp $

# $RedRiver: Keyring.pm,v 1.8 2006/11/10 17:31:38 andrew Exp $

use strict;

package Palm::Keyring;

Line 92

'private' => 1,

'Secret' => 1,

'Dirty' => 1,

'dirty' => 1

'dirty' => 1,

}, ];

Line 115

my $self = shift;

$self->SUPER::Load(@_);

# Skip the first 2 records because they are special

# and don't have any plaintext

my $skip = 0;

foreach my $record (@{ $self->{records} }) {

if ($skip < 2) {

next unless exists $record->{data};

$skip++;

next;

}

my ($name, $encrypted) = split /\000/, $record->{data}, 2;

next unless $encrypted;

$record->{plaintext}->{name} = $name;

$record->{encrypted} = $encrypted;

}

Line 142

Line 137

my $self = shift;

my $pass = shift;

if ($pass) {

unless ($self->_keyring_verify($pass) ) {

# This would encrypt with a new password.

Line 151

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};

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 $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);

}

Line 185

Line 181

$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};

my ($name, $encrypted) = split /\000/, $record->{data}, 2;

next unless $encrypted;

$record->{plaintext}->{name} = $name;

my $decrypted = $self->_crypt3des($encrypted, DECRYPT);

my $decrypted = _crypt3des($encrypted, $self->{digest}, DECRYPT);

my ($account, $password, $description, $extra)

= 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 "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 "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 "Extra: $extra\n";

#exit;

#--------------------------------------------------

# print "Account: $account\n";

# print "Password: $password\n";

Line 228

Line 225

sub _calc_keys

{

my $self = shift;

my $pass = shift;

my $pass = $self->{'password'};

die "No password defined!" unless defined $pass;

my $digest = md5($pass);

Line 247

Line 242

# print length $digest, "\n";

#--------------------------------------------------

$self->{digest} = $digest;

return $digest;

}

Line 261

Line 255

# AFAIK the thing we use to test the password is

# 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;

return undef unless defined $data;

Line 277

Line 271

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;

Line 299

Line 294

die "No password specified!" unless $pass;

# 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

$self->Decrypt() || return undef;

}

Line 319

Line 314

# AFAIK the thing we use to test the password is

# always in the first entry

$self->{records}->[0]->{data} = $data;

$self->{records}->[1]->{data} = $data;

$self->{password} = $pass;

$self->_calc_keys();

$self->{digest} = _calc_keys($self->{password});

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 {

my ( $self, $plaintext, $flag ) = @_;

my ( $plaintext, $passphrase, $flag ) = @_;

my $passphrase = $self->{digest} || $self->_calc_keys();

$passphrase .= ' ' x (16*3);

my $cyphertext = "";

my $size = length ( $plaintext );

#print "STRING: '$plaintext' - Length: " . length($plaintext) . "\n";

# This check should see if it is plaintext first, if it is,

# pad it with \000

# if not, then die

die "record not 8 byte padded" if (length($plaintext) % 8) && ! $flag;

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) - 1) {

my $pt = substr( $plaintext, $_*8, 8 );

#print "PT: '$pt' - Length: " . length($pt) . "\n";

if (length($pt) < 8) {

die "record not 8 byte padded" if $flag == DECRYPT;

my $len = 8 - length($pt);

print "LENGTH: $len\n";

#print "LENGTH: $len\n";

print "Binary: '" . unpack("b*", $pt) . "'\n";

#print "Binary: '" . unpack("b*", $pt) . "'\n";

$pt .= (chr(0) x $len);# . $pt;

print "Binary: '" . unpack("b*", $pt) . "'\n";

#print "Binary: '" . unpack("b*", $pt) . "'\n";

#print "PT: '$pt' - Length: " . length($pt) . "\n";

}

$pt = $C[0]->decrypt( $pt );

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>