version 1.36, 2007/02/22 05:16:04 |
version 1.45, 2007/02/26 00:02:13 |
|
|
package Palm::Keyring; |
package Palm::Keyring; |
# $RedRiver: Keyring.pm,v 1.35 2007/02/22 04:11:35 andrew Exp $ |
# $RedRiver: Keyring.pm,v 1.44 2007/02/23 22:11:33 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; |
$Carp::Verbose = 1; |
|
|
|
use base qw/ Palm::StdAppInfo /; |
use base qw/ Palm::StdAppInfo /; |
|
|
|
|
# Set defaults |
# Set defaults |
if ($self->{version} == 5) { |
if ($self->{version} == 5) { |
$self->{options}->{cipher} ||= 0; # 'None' |
$self->{options}->{cipher} ||= 0; # 'None' |
$self->{options}->{iterations} ||= |
my $c = crypts($self->{options}->{cipher}) |
$CRYPTS[ $self->{options}->{cipher} ]{default_iter}; |
or croak('Unknown cipher ' . $self->{options}->{cipher}); |
|
$self->{options}->{iterations} ||= $c->{default_iter}; |
$self->{appinfo}->{cipher} ||= $self->{options}->{cipher}; |
$self->{appinfo}->{cipher} ||= $self->{options}->{cipher}; |
$self->{appinfo}->{iter} ||= $self->{options}->{iterations}; |
$self->{appinfo}->{iter} ||= $self->{options}->{iterations}; |
}; |
}; |
|
|
if ( defined $options->{password} ) { |
if ( defined $options->{password} ) { |
|
|
sub crypts |
sub crypts |
{ |
{ |
my $crypt = shift; |
my $crypt = shift; |
if ($crypt =~ /\D/) { |
if (! defined $crypt || ! length $crypt) { |
|
return; |
|
} elsif ($crypt =~ /\D/) { |
foreach my $c (@CRYPTS) { |
foreach my $c (@CRYPTS) { |
if ($c->{alias} eq $crypt) { |
if ($c->{alias} eq $crypt) { |
return $c; |
return $c; |
|
|
delete $rec->{data}; |
delete $rec->{data}; |
|
|
} elsif ($self->{version} == 5) { |
} elsif ($self->{version} == 5) { |
my $blocksize = $CRYPTS[ $self->{appinfo}->{cipher} ]{blocksize}; |
my $c = crypts( $self->{appinfo}->{cipher} ) |
|
or croak('Unknown cipher ' . $self->{appinfo}->{cipher}); |
|
my $blocksize = $c->{blocksize}; |
my ($field, $extra) = _parse_field($rec->{data}); |
my ($field, $extra) = _parse_field($rec->{data}); |
my $ivec = substr $extra, 0, $blocksize; |
delete $rec->{data}; |
my $encrypted = substr $extra, $blocksize; |
|
|
|
$rec->{name} = $field->{data}; |
$rec->{name} = $field->{data}; |
$rec->{ivec} = $ivec; |
$rec->{ivec} = substr $extra, 0, $blocksize; |
$rec->{encrypted} = $encrypted; |
$rec->{encrypted} = substr $extra, $blocksize; |
delete $rec->{data}; |
|
|
|
} else { |
} else { |
die 'Unsupported Version'; |
die 'Unsupported Version'; |
|
|
} |
} |
|
|
} elsif ($self->{version} == 5) { |
} elsif ($self->{version} == 5) { |
my $field = { |
my $field; |
'label_id' => 1, |
if ($rec->{name}) { |
'data' => $rec->{name}, |
$field = { |
'font' => 0, |
'label_id' => 1, |
}; |
'data' => $rec->{name}, |
my $packed .= _pack_field($field); |
'font' => 0, |
|
}; |
|
} else { |
|
$field = { |
|
'label_id' => $EMPTY, |
|
'data' => $EMPTY, |
|
'font' => 0, |
|
}; |
|
} |
|
my $packed = _pack_field($field); |
|
|
$rec->{data} = join '', $packed, $rec->{ivec}, $rec->{encrypted}; |
$rec->{data} = join '', $packed, $rec->{ivec}, $rec->{encrypted}; |
|
|
|
|
my $key = shift; |
my $key = shift; |
my $cipher = shift; |
my $cipher = shift; |
my $ivec = shift; |
my $ivec = shift; |
my $blocksize = $CRYPTS[ $cipher ]{blocksize}; |
my $c = crypts($cipher) or croak('Unknown cipher ' . $cipher); |
my $keylen = $CRYPTS[ $cipher ]{keylen}; |
|
my $cipher_name = $CRYPTS[ $cipher ]{name}; |
|
|
|
if (! defined $ivec) { |
if (! defined $ivec) { |
$ivec = pack("C*",map {rand(256)} 1..$blocksize); |
$ivec = pack("C*",map {rand(256)} 1..$c->{blocksize}); |
} |
} |
|
|
my $changed = 0; |
my $changed = 0; |
|
|
my $date_index; |
my $date_index; |
for (my $i = 0; $i < @{ $new }; $i++) { |
for (my $i = 0; $i < @{ $new }; $i++) { |
if ( |
if ( |
(exists $new->[$i]->{label_id} && $new->[$i]->{label_id} == 3) || |
($new->[$i]->{label_id} && $new->[$i]->{label_id} == 3) || |
(exists $new->[$i]->{label} && $new->[$i]->{label} eq 'lastchange') |
($new->[$i]->{label} && $new->[$i]->{label} eq 'lastchange') |
) { |
) { |
$date_index = $i; |
$date_index = $i; |
if ( $old && $#{ $new } == $#{ $old } && ( |
if ( $old && $#{ $new } == $#{ $old } && ( |
$new->[$i]->{data}->{day} != $old->[$i]->{data}->{day} || |
$new->[$i]{data}{day} != $old->[$i]{data}{day} || |
$new->[$i]->{data}->{month} != $old->[$i]->{data}->{month} || |
$new->[$i]{data}{month} != $old->[$i]{data}{month} || |
$new->[$i]->{data}->{year} != $old->[$i]->{data}->{year} |
$new->[$i]{data}{year} != $old->[$i]{data}{year} |
)) { |
)) { |
$changed = 1; |
$changed = 1; |
$need_newdate = 0; |
$need_newdate = 0; |
last; |
|
} |
} |
|
|
} elsif ($old && $#{ $new } == $#{ $old }) { |
} elsif ($old && $#{ $new } == $#{ $old }) { |
|
|
$decrypted .= _pack_field($field); |
$decrypted .= _pack_field($field); |
} |
} |
my $encrypted; |
my $encrypted; |
if ($cipher_name eq 'None') { |
if ($c->{name} eq 'None') { |
# do nothing |
# do nothing |
$encrypted = $decrypted; |
$encrypted = $decrypted; |
|
|
} elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') { |
} elsif ($c->{name} eq 'DES_EDE3' or $c->{name} eq 'Rijndael') { |
require Crypt::CBC; |
require Crypt::CBC; |
my $c = Crypt::CBC->new( |
my $cbc = Crypt::CBC->new( |
-key => $key, |
-key => $key, |
-literal_key => 1, |
-literal_key => 1, |
-iv => $ivec, |
-iv => $ivec, |
-cipher => $cipher_name, |
-cipher => $c->{name}, |
-keysize => $keylen, |
-keysize => $c->{keylen}, |
-blocksize => $blocksize, |
-blocksize => $c->{blocksize}, |
-header => 'none', |
-header => 'none', |
-padding => 'oneandzeroes', |
-padding => 'oneandzeroes', |
); |
); |
|
|
croak("Unable to set up encryption!"); |
croak("Unable to set up encryption!"); |
} |
} |
|
|
$encrypted = $c->encrypt($decrypted); |
$encrypted = $cbc->encrypt($decrypted); |
|
|
} else { |
} else { |
die "Unsupported Version"; |
die "Unsupported Version"; |
|
|
my $cipher = shift; |
my $cipher = shift; |
my $ivec = shift; |
my $ivec = shift; |
|
|
my $keylen = $CRYPTS[ $cipher ]{keylen}; |
my $c = crypts($cipher) or croak('Unknown cipher ' . $cipher); |
my $cipher_name = $CRYPTS[ $cipher ]{name}; |
|
my $blocksize = $CRYPTS[ $cipher ]{blocksize}; |
|
|
|
my $decrypted; |
my $decrypted; |
|
|
if ($cipher_name eq 'None') { |
if ($c->{name} eq 'None') { |
# do nothing |
# do nothing |
$decrypted = $encrypted; |
$decrypted = $encrypted; |
|
|
} elsif ($cipher_name eq 'DES_EDE3' or $cipher_name eq 'Rijndael') { |
} elsif ($c->{name} eq 'DES_EDE3' or $c->{name} eq 'Rijndael') { |
require Crypt::CBC; |
require Crypt::CBC; |
my $c = Crypt::CBC->new( |
my $cbc = Crypt::CBC->new( |
-key => $key, |
-key => $key, |
-literal_key => 1, |
-literal_key => 1, |
-iv => $ivec, |
-iv => $ivec, |
-cipher => $cipher_name, |
-cipher => $c->{name}, |
-keysize => $keylen, |
-keysize => $c->{keylen}, |
-blocksize => $blocksize, |
-blocksize => $c->{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!"); |
} |
} |
my $len = $blocksize - length($encrypted) % $blocksize; |
my $len = $c->{blocksize} - length($encrypted) % $c->{blocksize}; |
$encrypted .= $NULL x $len; |
$encrypted .= $NULL x $len; |
$decrypted = $c->decrypt($encrypted); |
$decrypted = $cbc->decrypt($encrypted); |
|
|
} else { |
} else { |
die "Unsupported Version"; |
die "Unsupported Version"; |
|
|
|
|
my $salt = pack("H*", $appinfo->{salt}); |
my $salt = pack("H*", $appinfo->{salt}); |
|
|
|
my $c = crypts($appinfo->{cipher}) |
|
or croak('Unknown cipher ' . $appinfo->{cipher}); |
my ($key, $hash) = _calc_key_v5( |
my ($key, $hash) = _calc_key_v5( |
$pass, $salt, $appinfo->{iter}, |
$pass, $salt, $appinfo->{iter}, |
$CRYPTS[ $appinfo->{cipher} ]{keylen}, |
$c->{keylen}, |
$CRYPTS[ $appinfo->{cipher} ]{DES_odd_parity}, |
$c->{DES_odd_parity}, |
); |
); |
|
|
#print "Iter: '" . $appinfo->{iter} . "'\n"; |
#print "Iter: '" . $appinfo->{iter} . "'\n"; |
|
|
my $length = 8; |
my $length = 8; |
my $salt = shift || pack("C*",map {rand(256)} 1..$length); |
my $salt = shift || pack("C*",map {rand(256)} 1..$length); |
|
|
|
my $c = crypts($cipher) or croak('Unknown cipher ' . $cipher); |
my ($key, $hash) = _calc_key_v5( |
my ($key, $hash) = _calc_key_v5( |
$pass, $salt, $iter, |
$pass, $salt, $iter, |
$CRYPTS[ $cipher ]->{keylen}, |
$c->{keylen}, |
$CRYPTS[ $cipher ]->{DES_odd_parity}, |
$c->{DES_odd_parity}, |
); |
); |
|
|
$appinfo->{salt} = unpack "H*", $salt; |
$appinfo->{salt} = unpack "H*", $salt; |
$appinfo->{iter} = $iter; |
$appinfo->{iter} = $iter; |
$appinfo->{cipher} = $cipher; |
$appinfo->{cipher} = $cipher; |
|
|
$appinfo->{key} = $key; |
|
$appinfo->{masterhash} = $hash; |
$appinfo->{masterhash} = $hash; |
|
$appinfo->{key} = $key; |
|
|
return $key; |
return $key; |
} |
} |
|
|
import Digest::SHA1 qw(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); } |
|
|
my $hash = unpack("H*", substr(sha1($key.$salt),0, 8)); |
my $hash = unpack("H*", substr(sha1($key.$salt),0, 8)); |
|
|
|
|
my ($label, $font, $data) = unpack $unpackstr, $field; |
my ($label, $font, $data) = unpack $unpackstr, $field; |
my $leftover = substr $field, $offset; |
my $leftover = substr $field, $offset; |
|
|
if ($label == 3) { |
if ($label && $label == 3) { |
$data = _parse_keyring_date($data); |
$data = _parse_keyring_date($data); |
} |
} |
return { |
return { |
|
|
notes => 255, |
notes => 255, |
); |
); |
|
|
my $label = $field->{label_id} || $labels{ $field->{label} }; |
my $packed; |
my $font = $field->{font} || 0; |
if (defined $field) { |
my $data = $field->{data} || ''; |
my $label = $field->{label_id} || 0; |
|
if (defined $field->{label} && ! $label) { |
|
$label = $labels{ $field->{label} }; |
|
} |
|
my $font = $field->{font} || 0; |
|
my $data = defined $field->{data} ? $field->{data} : $EMPTY; |
|
|
if ($label == 3) { |
if ($label && $label == 3) { |
$data = _pack_keyring_date($data); |
$data = _pack_keyring_date($data); |
} |
} |
my $len = length $data; |
my $len = length $data; |
my $packstr = "n1 C1 C1 A*"; |
my $packstr = "n1 C1 C1 A*"; |
|
|
my $packed = pack $packstr, ($len, $label, $font, $data); |
$packed = pack $packstr, ($len, $label, $font, $data); |
|
|
if ($len % 2) { |
if ($len % 2) { |
# add byte padding for next even address. |
# add byte padding for next even address. |
$packed .= $NULL; |
$packed .= $NULL; |
|
} |
|
} else { |
|
my $packstr = "n1 C1 C1 x1"; |
|
$packed = pack $packstr, 0, 0, 0; |
} |
} |
|
|
return $packed; |
return $packed; |
|
|
return substr($t, 0, $keylen); |
return substr($t, 0, $keylen); |
} |
} |
|
|
sub DES_odd_parity($) { |
sub _DES_odd_parity($) { |
my $key = $_[0]; |
my $key = $_[0]; |
my ($r, $i); |
my ($r, $i); |
my @odd_parity = ( |
my @odd_parity = ( |
|
|
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. |
It currently supports the v4 Keyring databases as well as |
The pre-release v5 databases are mostly supported. There are definitely some |
the pre-release v5 databases. I am not completely happy with the interface |
bugs, For example, t/keyring5.t sometimes fails. I am not sure why yet. |
for accessing v5 databases, so any suggestions on improvements on |
|
the interface are appreciated. |
|
|
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. |
|
|
next if $_ == 0 && $pdb->{version} == 4; |
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}, ' - '; |
|
if ($pdb->{version} == 4 || $pdb->{options}->{v4compatible}) { |
|
print ' - ', $acct->{account}; |
|
} else { |
|
foreach my $a (@{ $acct }) { |
|
if ($a->{label} eq 'account') { |
|
print ' - ', $a->{data}; |
|
last; |
|
} |
|
} |
|
} |
|
print "\n"; |
} |
} |
|
|
=head1 SUBROUTINES/METHODS |
=head1 SUBROUTINES/METHODS |
|
|
$pdb = new Palm::Keyring({ key1 => value1, key2 => value2 }); |
$pdb = new Palm::Keyring({ key1 => value1, key2 => value2 }); |
$pdb = new Palm::Keyring( -key1 => value1, -key2 => value2); |
$pdb = new Palm::Keyring( -key1 => value1, -key2 => value2); |
|
|
=head3 Supported options are: |
=over |
|
|
|
=item Supported options |
|
|
=over |
=over |
|
|
=item password |
=item password |
|
|
|
|
=item cipher |
=item cipher |
|
|
The cipher to use. 0, 1, 2 or 3. |
The cipher to use. Either the number or the name. |
|
|
0 => None |
0 => None |
1 => DES_EDE3 |
1 => DES_EDE3 |
|
|
|
|
The number of iterations to encrypt with. |
The number of iterations to encrypt with. |
|
|
|
=item options |
|
|
|
A hashref of the options that are set |
|
|
=back |
=back |
|
|
|
=back |
|
|
For v5 databases there are some additional appinfo fields set. |
For v5 databases there are some additional appinfo fields set. |
|
These are set either on new() or Load(). |
|
|
$pdb->{appinfo} = { |
$pdb->{appinfo} = { |
# normal appinfo stuff described in L<Palm::StdAppInfo> |
# normal appinfo stuff described in L<Palm::StdAppInfo> |
cipher => The index number of the cipher being used |
cipher => The index number of the cipher being used |
iter => Number of iterations for the cipher |
iter => Number of iterations for the cipher |
}; |
}; |
|
|
=head2 crypt |
=head2 crypts |
|
|
Pass in the alias of the crypt to use, or the index. |
Pass in the alias of the crypt to use, or the index. |
|
|
|
These only make sense for v5 databases. |
|
|
This is a function, not a method. |
This is a function, not a method. |
|
|
|
$cipher can be 0, 1, 2, 3, None, DES_EDE3, AES128 or AES256. |
|
|
my $c = Palm::Keyring::crypt($cipher); |
my $c = Palm::Keyring::crypt($cipher); |
|
|
$c is now: |
$c is now: |
|
|
$c = { |
$c = { |
alias => (None|DES_EDE3|AES128|AES256), |
alias => (None|DES_EDE3|AES128|AES256), |
name => (None|DES_EDE3|Rijndael), |
name => (None|DES_EDE3|Rijndael), |
keylen => <key length of the ciphe>, |
keylen => <key length of the cipher>, |
blocksize => <block size of the cipher>, |
blocksize => <block size of the cipher>, |
default_iter => <default iterations for the cipher>, |
default_iter => <default iterations for the cipher>, |
}; |
}; |
|
|
|
|
|
|
The account name is stored in $rec->{name} for both v4 and v5 databases. |
The account name is stored in $rec->{name} for both v4 and v5 databases. |
It is not returned in the decrypted information for v5. |
It is not returned in the decrypted information for v5. |
|
|
$rec->{name} = 'account name'; |
$rec->{name} = 'account name'; |
|
|
|
|
Decrypts the record and returns a reference 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 && $pdb->{version} == 4; |
next if $_ == 0 && $pdb->{version} == 4; |
my $rec = $pdb->{records}->[$_]; |
my $rec = $pdb->{records}->[$_]; |
my $acct = $pdb->Decrypt($rec); |
my $acct = $pdb->Decrypt($rec); |
|
|
|
|
For v4 |
For v4 |
|
|
$pdb->{digest} = the calculated digest used from the key; |
$pdb->{digest} = the calculated digest used from the key; |
$pdb->{password} = the password that was passed in; |
$pdb->{password} = the password that was passed in; |
|
|
For v5 |
For v5 |
|
|
$pdb->{appinfo} = { |
$pdb->{appinfo} = { |
# As described under new() with these additional fields |
# As described under new() with these additional fields |
cipher => The index number of the cipher being used |
cipher => The index number of the cipher being used |
iter => Number of iterations for the cipher |
iter => Number of iterations for the cipher |
key => The key that is calculated from the password |
key => The key that is calculated from the password |
and salt and is used to decrypt the records. |
and salt and is used to decrypt the records. |
masterhash => the hash of the key that is stored in the |
masterhash => the hash of the key that is stored in the |
database. Either set when Loading the database |
database. Either set when Loading the database |
or when setting a new password. |
or when setting a new password. |
salt => the salt that is either read out of the database |
salt => the salt that is either read out of the database |
or calculated when setting a new password. |
or calculated when setting a new password. |
}; |
}; |
|
|
|
=head2 Other overridden subroutines/methods |
|
|
|
=over |
|
|
|
=item ParseAppInfoBlock |
|
|
|
Converts the extra returned by Palm::StdAppInfo::ParseAppInfoBlock() into |
|
the following additions to $pdb->{appinfo} |
|
|
|
$pdb->{appinfo} = { |
|
cipher => The index number of the cipher being used (Not v4) |
|
iter => Number of iterations for the cipher (Not v4) |
|
}; |
|
|
|
=item PackAppInfoBlock |
|
|
|
Reverses ParseAppInfoBlock before |
|
sending it on to Palm::StdAppInfo::PackAppInfoBlock() |
|
|
|
=item ParseRecord |
|
|
|
Adds some fields to a record from Palm::StdAppInfo::ParseRecord() |
|
|
|
$rec = { |
|
name => Account name |
|
ivec => The IV for the encrypted record. (Not v4) |
|
encrypted => the encrypted information |
|
}; |
|
|
|
=item PackRecord |
|
|
|
Reverses ParseRecord and then sends it through Palm::StdAppInfo::PackRecord() |
|
|
|
=back |
|
|
=head1 DEPENDENCIES |
=head1 DEPENDENCIES |
|
|
Palm::StdAppInfo |
Palm::StdAppInfo |
|
|
|
B<For v4 databases> |
|
|
Digest::MD5 |
Digest::MD5 |
|
|
Crypt::DES |
Crypt::DES |
|
|
Readonly |
B<For v5 databases> |
|
|
|
Digest::HMAC_SHA1 |
|
|
|
Digest::SHA1 |
|
|
|
Depending on how the database is encrypted |
|
|
|
Crypt::CBC - For any encryption but None |
|
|
|
Crypt::DES_EDE3 - DES_EDE3 encryption |
|
|
|
Crytp::Rijndael - AES encryption schemes |
|
|
=head1 THANKS |
=head1 THANKS |
|
|
I would like to thank the helpful Perlmonk shigetsu who gave me some great advice |
I would like to thank the helpful Perlmonk shigetsu who gave me some great advice |
|
|
as giving me some very helpful hints about doing a few things that I was |
as giving me some very helpful hints about doing a few things that I was |
unsure of. He is really great. |
unsure of. He is really great. |
|
|
|
And finally, |
|
thanks to Jochen Hoenicke E<lt>hoenicke@gmail.comE<gt> |
|
(one of the authors of Palm Keyring) |
|
for getting me started on the v5 support as well as providing help |
|
and some subroutines. |
|
|
=head1 BUGS AND LIMITATIONS |
=head1 BUGS AND LIMITATIONS |
|
|
|
I am sure there are problems with this module. For example, I have |
|
not done very extensive testing of the v5 databases. |
|
|
|
I am not sure I am 'require module' the best way, but I don't want to |
|
depend on modules that you don't need to use. |
|
|
|
I am not very happy with the data structures used by Encrypt() and |
|
Decrypt() for v5 databases, but I am not sure of a better way. |
|
|
|
The v4 compatibility mode does not insert a fake record 0 where |
|
normally the encrypted password is stored. |
|
|
|
The date validation for packing new dates is very poor. |
|
|
|
I have not gone through and standardized on how the module fails. Some |
|
things fail with croak, some return undef, some may even fail silently. |
|
Nothing initializes a lasterr method or anything like that. I need |
|
to fix all that before it is a 1.0 candidate. |
|
|
Please report any bugs or feature requests to |
Please report any bugs or feature requests to |
C<bug-palm-keyring at rt.cpan.org>, or through the web interface at |
C<bug-palm-keyring at rt.cpan.org>, or through the web interface at |