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.1 and 1.5

version 1.1, 2006/01/26 20:54:19

version 1.5, 2006/11/10 04:52:27

Line 9

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

# $Id$

# $RedRiver$

# $RedRiver: Keyring.pm,v 1.4 2006/11/10 04:21:17 andrew Exp $

use strict;

package Palm::Keyring;

Line 18

use vars qw( $VERSION @ISA );

use Digest::MD5 qw(md5);

use Crypt::TripleDES;

use Crypt::DES;

use constant ENCRYPT => 1;

use constant DECRYPT => 0;

Line 65

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

Line 87

Line 86

$self->{version} = 4;

# Give the PDB the first record that will hold the encrypted password

$self->{records} = [

$self->{records} = [ {

{

'category' => 0,

'attributes' => {

'private' => 1,

'Secret' => 1,

'Dirty' => 1,

'dirty' => 1

];

}, ];

if ($pass) {

$self->Encrypt($pass);

Line 113

Line 110

);

}

sub Load

{

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

$skip++;

next;

}

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

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

$record->{encrypted} = $encrypted;

}

sub Encrypt

{

my $self = shift;

Line 142

Line 159

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 = $self->_crypt3des($plaintext, ENCRYPT);

$record->{data} = join("\0", $name, $encrypted);

$record->{data} = join("\000", $name, $encrypted);

}

return 1;

Line 171

Line 188

next unless defined $record->{data};

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

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

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

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

my $decrypted = $self->_crypt3des($encrypted, 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 : '';

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

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

# print "Account: $account\n";

Line 194

Line 219

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;

Line 242

Line 249

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

Line 282

Line 289

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

Line 313

Line 320

return 1;

}

# XXX Have to make this encrypt as well as decrypting, but w00 h00!

# do null padding on the end of a cleartext if we are going to encrypt it

sub _crypt3des {

my ( $self, $plaintext, $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 )));

}

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

}

__END__

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