version 1.30, 2007/02/19 01:37:10 |
version 1.36, 2007/02/22 05:16:04 |
|
|
package Palm::Keyring; |
package Palm::Keyring; |
# $RedRiver: Keyring.pm,v 1.29 2007/02/19 00:22:42 andrew Exp $ |
# $RedRiver: Keyring.pm,v 1.35 2007/02/22 04:11:35 andrew Exp $ |
######################################################################## |
######################################################################## |
# Keyring.pm *** Perl class for Keyring for Palm OS databases. |
# Keyring.pm *** Perl class for Keyring for Palm OS databases. |
# |
# |
|
|
use warnings; |
use warnings; |
|
|
use Carp; |
use Carp; |
use Data::Dumper; |
$Carp::Verbose = 1; |
|
|
use base qw/ Palm::StdAppInfo /; |
use base qw/ Palm::StdAppInfo /; |
|
|
use Digest::HMAC_SHA1 qw(hmac_sha1); |
|
use Digest::SHA1 qw(sha1); |
|
use Crypt::CBC; |
|
|
|
use Digest::MD5 qw(md5); |
|
use Crypt::DES; |
|
|
|
my $ENCRYPT = 1; |
my $ENCRYPT = 1; |
my $DECRYPT = 0; |
my $DECRYPT = 0; |
my $MD5_CBLOCK = 64; |
my $MD5_CBLOCK = 64; |
|
|
my $NULL = chr 0; |
my $NULL = chr 0; |
|
|
my @CRYPTS = ( |
my @CRYPTS = ( |
{ # None |
{ |
|
alias => 'None', |
name => 'None', |
name => 'None', |
keylen => 8, |
keylen => 8, |
blocksize => 1, |
blocksize => 1, |
default_iter => 500, |
default_iter => 500, |
}, |
}, |
{ # DES-EDE3 |
{ |
|
alias => 'DES-EDE3', |
name => 'DES_EDE3', |
name => 'DES_EDE3', |
keylen => 24, |
keylen => 24, |
blocksize => 8, |
blocksize => 8, |
DES_odd_parity => 1, |
DES_odd_parity => 1, |
default_iter => 1000, |
default_iter => 1000, |
}, |
}, |
{ # AES128 |
{ |
|
alias => 'AES128', |
name => 'Rijndael', |
name => 'Rijndael', |
keylen => 16, |
keylen => 16, |
blocksize => 16, |
blocksize => 16, |
default_iter => 100, |
default_iter => 100, |
}, |
}, |
{ # AES256 |
{ |
|
alias => 'AES256', |
name => 'Rijndael', |
name => 'Rijndael', |
keylen => 32, |
keylen => 32, |
blocksize => 16, |
blocksize => 16, |
|
|
return 1; |
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 |
# ParseRecord |
|
|
sub ParseRecord |
sub ParseRecord |
|
|
my $ivec = substr $extra, 0, $blocksize; |
my $ivec = substr $extra, 0, $blocksize; |
my $encrypted = substr $extra, $blocksize; |
my $encrypted = substr $extra, $blocksize; |
|
|
if ($self->{options}->{v4compatible}) { |
$rec->{name} = $field->{data}; |
$rec->{name} = $field->{data}; |
|
} else { |
|
$rec->{name} = $field; |
|
} |
|
$rec->{ivec} = $ivec; |
$rec->{ivec} = $ivec; |
$rec->{encrypted} = $encrypted; |
$rec->{encrypted} = $encrypted; |
|
delete $rec->{data}; |
|
|
} else { |
} else { |
die 'Unsupported Version'; |
die 'Unsupported Version'; |
|
|
} |
} |
|
|
} elsif ($self->{version} == 5) { |
} elsif ($self->{version} == 5) { |
my $field; |
my $field = { |
if ($rec->{name}) { |
'label_id' => 1, |
if ($self->{options}->{v4compatible}) { |
'data' => $rec->{name}, |
$field = { |
'font' => 0, |
label => 'name', |
}; |
font => 0, |
my $packed .= _pack_field($field); |
data => $rec->{'name'}, |
|
}; |
|
} else { |
|
$field = $rec->{name}; |
|
} |
|
} |
|
my $packed = ''; |
|
if ($field) { |
|
$packed = _pack_field($field); |
|
} |
|
my $len = length $packed; |
|
my $blocksize = $CRYPTS[ $self->{appinfo}->{cipher} ]{blocksize}; |
|
|
|
$rec->{data} = join '', $packed, $rec->{ivec}, $rec->{encrypted}; |
$rec->{data} = join '', $packed, $rec->{ivec}, $rec->{encrypted}; |
|
|
|
|
|
|
my $unpackstr |
my $unpackstr |
= ("C1" x 8) # 8 uint8s in an array for the salt |
= ("C1" x 8) # 8 uint8s in an array for the salt |
. ("S1" x 2) # the iter (uint16) and the cipher (uint16) |
. ("n1" x 2) # the iter (uint16) and the cipher (uint16) |
. ("C1" x 8); # and finally 8 more uint8s for the hash |
. ("C1" x 8); # and finally 8 more uint8s for the hash |
|
|
my (@salt, $iter, $cipher, @hash); |
my (@salt, $iter, $cipher, @hash); |
|
|
|
|
my $packstr |
my $packstr |
= ("C1" x 8) # 8 uint8s in an array for the salt |
= ("C1" x 8) # 8 uint8s in an array for the salt |
. ("S1" x 2) # the iter (uint16) and the cipher (uint16) |
. ("n1" x 2) # the iter (uint16) and the cipher (uint16) |
. ("C1" x 8); # and finally 8 more uint8s for the hash |
. ("C1" x 8); # and finally 8 more uint8s for the hash |
|
|
my @salt = map { hex $_ } $appinfo->{salt} =~ /../gxm; |
my @salt = map { hex $_ } $appinfo->{salt} =~ /../gxm; |
|
|
my $rec = shift; |
my $rec = shift; |
my $data = shift; |
my $data = shift; |
my $pass = shift || $self->{password}; |
my $pass = shift || $self->{password}; |
|
my $ivec = shift; |
|
|
if ( ! $pass && ! $self->{appinfo}->{key}) { |
if ( ! $pass && ! $self->{appinfo}->{key}) { |
croak("password not set!\n"); |
croak("password not set!\n"); |
|
|
$rec->{name} ||= $data->{name}; |
$rec->{name} ||= $data->{name}; |
|
|
} elsif ($self->{version} == 5) { |
} elsif ($self->{version} == 5) { |
my @recs = ($data, $acct); |
my @accts = ($data, $acct); |
my $name; |
|
if ($self->{options}->{v4compatible}) { |
if ($self->{options}->{v4compatible}) { |
$rec->{name} ||= $data->{name}; |
$rec->{name} ||= $data->{name}; |
foreach my $rec (@recs) { |
foreach my $a (@accts) { |
my @fields; |
my @fields; |
foreach my $k (sort keys %{ $rec }) { |
foreach my $k (sort keys %{ $a }) { |
my $field = { |
my $field = { |
label => $k, |
label => $k, |
font => 0, |
font => 0, |
data => $rec->{$k}, |
data => $a->{$k}, |
}; |
}; |
push @fields, $field; |
push @fields, $field; |
} |
} |
$rec = \@fields; |
$a = \@fields; |
} |
} |
} |
} |
|
|
my $ivec; |
|
($encrypted, $ivec) = _encrypt_v5( |
($encrypted, $ivec) = _encrypt_v5( |
@recs, |
@accts, |
$self->{appinfo}->{key}, |
$self->{appinfo}->{key}, |
$self->{appinfo}->{cipher}, |
$self->{appinfo}->{cipher}, |
|
$ivec, |
); |
); |
if ($ivec) { |
if (defined $ivec) { |
$rec->{ivec} = $ivec; |
$rec->{ivec} = $ivec; |
} |
} |
|
|
|
|
my $old = shift; |
my $old = shift; |
my $key = shift; |
my $key = shift; |
my $cipher = shift; |
my $cipher = shift; |
my $length = $CRYPTS[ $cipher ]{blocksize}; |
my $ivec = shift; |
my $ivec = shift || pack("C*",map {rand(256)} 1..$length); |
my $blocksize = $CRYPTS[ $cipher ]{blocksize}; |
|
|
my $keylen = $CRYPTS[ $cipher ]{keylen}; |
my $keylen = $CRYPTS[ $cipher ]{keylen}; |
my $cipher_name = $CRYPTS[ $cipher ]{name}; |
my $cipher_name = $CRYPTS[ $cipher ]{name}; |
|
|
|
if (! defined $ivec) { |
|
$ivec = pack("C*",map {rand(256)} 1..$blocksize); |
|
} |
|
|
my $changed = 0; |
my $changed = 0; |
my $need_newdate = 1; |
my $need_newdate = 1; |
my $date_index; |
my $date_index; |
|
|
foreach my $field (@{ $new }) { |
foreach my $field (@{ $new }) { |
$decrypted .= _pack_field($field); |
$decrypted .= _pack_field($field); |
} |
} |
|
|
my $encrypted; |
my $encrypted; |
if ($cipher_name eq 'None') { |
if ($cipher_name eq 'None') { |
# do nothing |
# do nothing |
$encrypted = $decrypted; |
$encrypted = $decrypted; |
|
|
} elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') { |
} elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') { |
|
require Crypt::CBC; |
my $c = Crypt::CBC->new( |
my $c = Crypt::CBC->new( |
-literal_key => 1, |
|
-key => $key, |
-key => $key, |
|
-literal_key => 1, |
-iv => $ivec, |
-iv => $ivec, |
-cipher => $cipher_name, |
-cipher => $cipher_name, |
-keysize => $keylen, |
-keysize => $keylen, |
|
-blocksize => $blocksize, |
-header => 'none', |
-header => 'none', |
-padding => 'oneandzeroes', |
-padding => 'oneandzeroes', |
); |
); |
|
|
|
|
# Decrypt |
# Decrypt |
|
|
sub Decrypt |
sub Decrypt |
{ |
{ |
my $self = shift; |
my $self = shift; |
my $rec = shift; |
my $rec = shift; |
|
|
|
|
sub _decrypt_v5 |
sub _decrypt_v5 |
{ |
{ |
|
|
my $encrypted = shift; |
my $encrypted = shift; |
my $key = shift; |
my $key = shift; |
my $cipher = shift; |
my $cipher = shift; |
|
|
|
|
my $keylen = $CRYPTS[ $cipher ]{keylen}; |
my $keylen = $CRYPTS[ $cipher ]{keylen}; |
my $cipher_name = $CRYPTS[ $cipher ]{name}; |
my $cipher_name = $CRYPTS[ $cipher ]{name}; |
|
my $blocksize = $CRYPTS[ $cipher ]{blocksize}; |
|
|
my $decrypted; |
my $decrypted; |
|
|
|
|
$decrypted = $encrypted; |
$decrypted = $encrypted; |
|
|
} elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') { |
} elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') { |
|
require Crypt::CBC; |
my $c = Crypt::CBC->new( |
my $c = Crypt::CBC->new( |
-literal_key => 1, |
|
-key => $key, |
-key => $key, |
|
-literal_key => 1, |
-iv => $ivec, |
-iv => $ivec, |
-cipher => $cipher_name, |
-cipher => $cipher_name, |
-keysize => $keylen, |
-keysize => $keylen, |
|
-blocksize => $blocksize, |
-header => 'none', |
-header => 'none', |
-padding => 'oneandzeroes', |
-padding => 'oneandzeroes', |
); |
); |
|
|
if (! $c) { |
if (! $c) { |
croak("Unable to set up encryption!"); |
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); |
$decrypted = $c->decrypt($encrypted); |
|
|
} else { |
} else { |
|
|
} |
} |
} |
} |
} elsif ($self->{version} == 5) { |
} elsif ($self->{version} == 5) { |
return _password_verify_v5($pass, $self->{appinfo}); |
return _password_verify_v5($self->{appinfo}, $pass); |
} else { |
} else { |
# XXX unsupported version |
# XXX unsupported version |
} |
} |
|
|
|
|
sub _password_verify_v4 |
sub _password_verify_v4 |
{ |
{ |
|
require Digest::MD5; |
|
import Digest::MD5 qw(md5); |
|
|
my $pass = shift; |
my $pass = shift; |
my $data = shift; |
my $data = shift; |
|
|
|
|
|
|
my $digest = md5($msg); |
my $digest = md5($msg); |
|
|
if (! $data eq $salt . $digest ) { |
if ($data ne $salt . $digest ) { |
return; |
return; |
} |
} |
|
|
|
|
|
|
sub _password_verify_v5 |
sub _password_verify_v5 |
{ |
{ |
my $pass = shift; |
|
my $appinfo = shift; |
my $appinfo = shift; |
|
my $pass = shift; |
|
|
my $salt = pack("H*", $appinfo->{salt}); |
my $salt = pack("H*", $appinfo->{salt}); |
|
|
|
|
$CRYPTS[ $appinfo->{cipher} ]{DES_odd_parity}, |
$CRYPTS[ $appinfo->{cipher} ]{DES_odd_parity}, |
); |
); |
|
|
|
#print "Iter: '" . $appinfo->{iter} . "'\n"; |
#print "Key: '". unpack("H*", $key) . "'\n"; |
#print "Key: '". unpack("H*", $key) . "'\n"; |
|
#print "Salt: '". unpack("H*", $salt) . "'\n"; |
#print "Hash: '". $hash . "'\n"; |
#print "Hash: '". $hash . "'\n"; |
#print "Hash: '". $appinfo->{masterhash} . "'\n"; |
#print "Hash: '". $appinfo->{masterhash} . "'\n"; |
|
|
|
|
|
|
sub _password_update_v4 |
sub _password_update_v4 |
{ |
{ |
|
require Digest::MD5; |
|
import Digest::MD5 qw(md5); |
|
|
my $pass = shift; |
my $pass = shift; |
|
|
if (! defined $pass) { croak('No password specified!'); }; |
if (! defined $pass) { croak('No password specified!'); }; |
|
|
return $key; |
return $key; |
} |
} |
|
|
|
# Helpers |
|
|
sub _calc_keys |
sub _calc_keys |
{ |
{ |
|
|
{ |
{ |
my ($pass, $salt, $iter, $keylen, $dop) = @_; |
my ($pass, $salt, $iter, $keylen, $dop) = @_; |
|
|
|
require Digest::HMAC_SHA1; |
|
import Digest::HMAC_SHA1 qw(hmac_sha1); |
|
require Digest::SHA1; |
|
import Digest::SHA1 qw(sha1); |
|
|
my $key = _pbkdf2( $pass, $salt, $iter, $keylen, \&hmac_sha1 ); |
my $key = _pbkdf2( $pass, $salt, $iter, $keylen, \&hmac_sha1 ); |
if ($dop) { $key = DES_odd_parity($key); } |
if ($dop) { $key = DES_odd_parity($key); } |
|
|
|
|
|
|
sub _crypt3des |
sub _crypt3des |
{ |
{ |
|
require Crypt::DES; |
|
|
my ( $plaintext, $passphrase, $flag ) = @_; |
my ( $plaintext, $passphrase, $flag ) = @_; |
|
|
$passphrase .= $SPACE x ( 16 * 3 ); |
$passphrase .= $SPACE x ( 16 * 3 ); |
|
|
$labels[3] = 'lastchange'; |
$labels[3] = 'lastchange'; |
$labels[255] = 'notes'; |
$labels[255] = 'notes'; |
|
|
my ($len) = unpack "S1", $field; |
my ($len) = unpack "n1", $field; |
if ($len + 4 > length $field) { |
if ($len + 4 > length $field) { |
return undef, $field; |
return undef, $field; |
} |
} |
my $unpackstr = "S1 C1 C1 A$len"; |
my $unpackstr = "x2 C1 C1 A$len"; |
if ($len % 2 && $len + 4 < length $field) { |
my $offset = 2 +1 +1 +$len; |
|
if ($len % 2) { # && $len + 4 < length $field) { |
# trim the 0/1 byte padding for next even address. |
# trim the 0/1 byte padding for next even address. |
|
$offset++; |
$unpackstr .= ' x' |
$unpackstr .= ' x' |
} |
} |
$unpackstr .= ' A*'; |
|
|
|
my (undef, $label, $font, $data, $leftover) |
my ($label, $font, $data) = unpack $unpackstr, $field; |
= unpack $unpackstr, $field; |
my $leftover = substr $field, $offset; |
|
|
if ($label == 3) { |
if ($label == 3) { |
$data = _parse_keyring_date($data); |
$data = _parse_keyring_date($data); |
|
|
$data = _pack_keyring_date($data); |
$data = _pack_keyring_date($data); |
} |
} |
my $len = length $data; |
my $len = length $data; |
my $packstr = "S1 C1 C1 A*"; |
my $packstr = "n1 C1 C1 A*"; |
|
|
my $packed = pack $packstr, ($len, $label, $font, $data); |
my $packed = pack $packstr, ($len, $label, $font, $data); |
|
|
|
|
|
|
1; |
1; |
__END__ |
__END__ |
|
|
=head1 NAME |
=head1 NAME |
|
|
Palm::Keyring - Handler for Palm Keyring databases. |
Palm::Keyring - Handler for Palm Keyring databases. |
|
|
It has the standard Palm::PDB methods with 2 additional public methods. |
It has the standard Palm::PDB methods with 2 additional public methods. |
Decrypt and Encrypt. |
Decrypt and Encrypt. |
|
|
It currently supports the v4 Keyring databases. The v5 databases from |
It currently supports the v4 Keyring databases. |
the pre-release keyring-2.0 are not supported. |
The pre-release v5 databases are mostly supported. There are definitely some |
|
bugs, For example, t/keyring5.t sometimes fails. I am not sure why yet. |
|
|
This module doesn't store the decrypted content. It only keeps it until it |
This module doesn't store the decrypted content. It only keeps it until it |
returns it to you or encrypts it. |
returns it to you or encrypts it. |
|
|
$pdb->Load($file); |
$pdb->Load($file); |
|
|
foreach (0..$#{ $pdb->{records} }) { |
foreach (0..$#{ $pdb->{records} }) { |
next if $_ = 0; # skip the password record |
# skip the password record for version 4 databases |
|
next if $_ == 0 && $pdb->{version} == 4; |
my $rec = $pdb->{records}->[$_]; |
my $rec = $pdb->{records}->[$_]; |
my $acct = $pdb->Decrypt($rec, $pass); |
my $acct = $pdb->Decrypt($rec, $pass); |
print $rec->{name}, ' - ', $acct->{account}, "\n"; |
print $rec->{name}, ' - ', $acct->{account}, "\n"; |
|
|
|
|
=head2 new |
=head2 new |
|
|
$pdb = new Palm::Keyring([$password]); |
$pdb = new Palm::Keyring([$password[, $version]]); |
|
|
Create a new PDB, initialized with the various Palm::Keyring fields |
Create a new PDB, initialized with the various Palm::Keyring fields |
and an empty record list. |
and an empty record list. |
|
|
If you pass in a password, it will initalize the first record with the encrypted |
If you pass in a password, it will initalize the first record with the encrypted |
password. |
password. |
|
|
|
new() now also takes options in other formats |
|
|
|
$pdb = new Palm::Keyring({ key1 => value1, key2 => value2 }); |
|
$pdb = new Palm::Keyring( -key1 => value1, -key2 => value2); |
|
|
|
=head3 Supported options are: |
|
|
|
=over |
|
|
|
=item password |
|
|
|
The password used to initialize the database |
|
|
|
=item version |
|
|
|
The version of database to create. Accepts either 4 or 5. Currently defaults to 4. |
|
|
|
=item v4compatible |
|
|
|
The format of the fields passed to Encrypt and returned from Decrypt have changed. |
|
This allows programs to use the newer databases with few changes but with less features. |
|
|
|
=item cipher |
|
|
|
The cipher to use. 0, 1, 2 or 3. |
|
|
|
0 => None |
|
1 => DES_EDE3 |
|
2 => AES128 |
|
3 => AES256 |
|
|
|
=item iterations |
|
|
|
The number of iterations to encrypt with. |
|
|
|
=back |
|
|
|
For v5 databases there are some additional appinfo fields set. |
|
|
|
$pdb->{appinfo} = { |
|
# normal appinfo stuff described in L<Palm::StdAppInfo> |
|
cipher => The index number of the cipher being used |
|
iter => Number of iterations for the cipher |
|
}; |
|
|
|
=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 |
=head2 Encrypt |
|
|
$pdb->Encrypt($rec, $acct[, $password]); |
$pdb->Encrypt($rec, $acct[, $password[, $ivec]]); |
|
|
Encrypts an account into a record, either with the password previously |
Encrypts an account into a record, either with the password previously |
used, or with a password that is passed. |
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(). |
$rec is a record from $pdb->{records} or a new_Record(). |
$acct is a hashref in the format below. |
The v4 $acct is a hashref in the format below. |
|
|
my $acct = { |
my $v4acct = { |
name => $rec->{name}, |
name => $rec->{name}, |
account => $account, |
account => $account, |
password => $password, |
password => $password, |
|
|
}, |
}, |
}; |
}; |
|
|
|
The v5 $acct is an arrayref full of hashrefs that contain each encrypted field. |
|
|
|
my $v5acct = [ |
|
{ |
|
'label_id' => 2, |
|
'data' => 'abcd1234', |
|
'label' => 'password', |
|
'font' => 0 |
|
}, |
|
{ |
|
'label_id' => 3, |
|
'data' => { |
|
'month' => 1, |
|
'day' => 11, |
|
'year' => 107 |
|
}, |
|
'label' => 'lastchange', |
|
'font' => 0 |
|
}, |
|
{ |
|
'label_id' => 255, |
|
'data' => 'This is a short note.', |
|
'label' => 'notes', |
|
'font' => 0 |
|
} |
|
]; |
|
|
|
|
|
The account name is stored in $rec->{name} for both v4 and v5 databases. |
|
It is not returned in the decrypted information for v5. |
|
|
|
$rec->{name} = 'account name'; |
|
|
If you have changed anything other than the lastchange, or don't pass in a |
If you have changed anything other than the lastchange, or don't pass in a |
lastchange key, Encrypt() will generate a new lastchange date for you. |
lastchange key, Encrypt() will generate a new lastchange date for you. |
|
|
|
|
|
|
my $acct = $pdb->Decrypt($rec[, $password]); |
my $acct = $pdb->Decrypt($rec[, $password]); |
|
|
Decrypts the record and returns a hashref for the account as described |
Decrypts the record and returns a reference for the account as described |
under Encrypt(). |
under Encrypt(). |
|
|
foreach (0..$#{ $pdb->{records}) { |
foreach (0..$#{ $pdb->{records}) { |
next if $_ == 0; |
next if $_ == 0 && $pdb->{version} == 4; |
my $rec = $pdb->{records}->[$_]; |
my $rec = $pdb->{records}->[$_]; |
my $acct = $pdb->Decrypt($rec[, $password]); |
my $acct = $pdb->Decrypt($rec); |
# do something with $acct |
# do something with $acct |
} |
} |
|
|
|
|
=head2 Password |
=head2 Password |
|
|
$pdb->Password([$password[, $new_password]]); |
$pdb->Password([$password[, $new_password]]); |
|
|
|
|
If nothing is passed, it forgets the password that it was remembering. |
If nothing is passed, it forgets the password that it was remembering. |
|
|
|
After a successful password verification the following fields are set |
|
|
|
For v4 |
|
|
|
$pdb->{digest} = the calculated digest used from the key; |
|
$pdb->{password} = the password that was passed in; |
|
|
|
For v5 |
|
|
|
$pdb->{appinfo} = { |
|
# As described under new() with these additional fields |
|
cipher => The index number of the cipher being used |
|
iter => Number of iterations for the cipher |
|
key => The key that is calculated from the password |
|
and salt and is used to decrypt the records. |
|
masterhash => the hash of the key that is stored in the |
|
database. Either set when Loading the database |
|
or when setting a new password. |
|
salt => the salt that is either read out of the database |
|
or calculated when setting a new password. |
|
}; |
|
|
=head1 DEPENDENCIES |
=head1 DEPENDENCIES |
|
|
Palm::StdAppInfo |
Palm::StdAppInfo |
|
|
|
|
The Keyring for Palm OS website: |
The Keyring for Palm OS website: |
L<http://gnukeyring.sourceforge.net/> |
L<http://gnukeyring.sourceforge.net/> |
|
|
|
The HACKING guide for palm keyring databases: |
|
L<http://gnukeyring.cvs.sourceforge.net/*checkout*/gnukeyring/keyring/HACKING> |
|
|
Johan Vromans also has a wxkeyring app that now uses this module, available |
Johan Vromans also has a wxkeyring app that now uses this module, available |
from his website at L<http://www.vromans.org/johan/software/sw_palmkeyring.html> |
from his website at L<http://www.vromans.org/johan/software/sw_palmkeyring.html> |