Crypt::RSA - RSA public-key cryptosystem. |
Crypt::RSA - RSA public-key cryptosystem.
$Revision: 1.48 $ (Beta) $Date: 2001/09/25 12:44:55 $
my $rsa = new Crypt::RSA;
my ($public, $private) = $rsa->keygen ( Identity => 'Lord Macbeth <macbeth@glamis.com>', Size => 1024, Password => 'A day so foul & fair', Verbosity => 1, ) or die $rsa->errstr();
my $cyphertext = $rsa->encrypt ( Message => $message, Key => $public, Armour => 1, ) || die $rsa->errstr();
my $plaintext = $rsa->decrypt ( Cyphertext => $cyphertext, Key => $private, Armour => 1, ) || die $rsa->errstr();
my $signature = $rsa->sign ( Message => $message, Key => $private ) || die $rsa->errstr();
my $verify = $rsa->verify ( Message => $message, Signature => $signature, Key => $public ) || die $rsa->errstr();
This manual assumes familiarity with public-key cryptography and the RSA algorithm. If you don't know what these are or how they work, please refer to the sci.crypt FAQ[15]. A formal treatment of RSA can be found in [1].
Crypt::RSA is a pure-perl, cleanroom implementation of the RSA public-key cryptosystem. It uses Math::Pari(3), a perl interface to the blazingly fast PARI library, for big integer arithmetic and number theoretic computations.
Crypt::RSA provides arbitrary size key-pair generation, plaintext-aware encryption (OAEP) and digital signatures with appendix (PSS). For compatibility with SSLv3, RSAREF2, PGP and other applications that follow the PKCS #1 v1.5 standard, it also provides PKCS #1 v1.5 encryption and signatures.
Crypt::RSA is structured as bundle of modules that encapsulate different parts of the RSA cryptosystem. The RSA algorithm is implemented in Crypt::RSA::Primitives(3). Encryption schemes, located under Crypt::RSA::ES, and signature schemes, located under Crypt::RSA::SS, use the RSA algorithm to build encryption/signature schemes that employ secure padding. (See the note on Security of Padding Schemes.)
The key generation engine and other functions that work on both components of the key-pair are encapsulated in Crypt::RSA::Key(3). Crypt::RSA::Key::Public(3) & Crypt::RSA::Key::Private(3) provide mechanisms for storage & retrival of keys from disk, decoding & encoding of keys in certain formats, and secure representation of keys in memory. Finally, the Crypt::RSA module provides a convenient, DWIM wrapper around the rest of the modules in the bundle.
It has been conclusively shown that textbook RSA is insecure[3,7]. Secure
RSA requires that plaintext is padded in a specific manner before
encryption and signing. There are four main standards for padding: PKCS
#1 v1.5 encryption & signatures, and OAEP encryption & PSS signatures.
Crypt::RSA implements these as four modules that
provide overloaded encrypt(), decrypt(), sign()
and verify()
methods that
add padding functionality to the basic RSA operations.
Crypt::RSA::ES::PKCS1v15(3) implements PKCS #1 v1.5 encryption, Crypt::RSA::SS::PKCS1v15(3) implements PKCS #1 v1.5 signatures, Crypt::RSA::ES::OAEP(3) implements Optimal Asymmetric Encryption and Crypt::RSA::SS::PSS(3) Probabilistic Signatures.
PKCS #1 v1.5 schemes are older and hence more widely deployed, but PKCS #1 v1.5 encryption has certain flaws that make it vulnerable to chosen-cyphertext attacks[9]. Even though Crypt::RSA works around these vulnerabilities, it is recommended that new applications use OAEP and PSS, both of which are provably secure[13]. In any event, Crypt::RSA::Primitives (without padding) should never be used directly.
That said, there exists a scheme called Simple RSA[16] that provides security without padding. However, Crypt::RSA doesn't implement this scheme yet.
new()
returns an object
loaded with default values. This object can be customized by specifying
encryption & signature schemes, key formats and post processors. For
details see the section on Customizing the Crypt::RSA
object later in this manpage.
keygen()
generates and returns an RSA key-pair of specified bitsize.
keygen()
is a synonym for Crypt::RSA::Key::generate(). Parameters and
return values are described in the Crypt::RSA::Key(3) manpage.
encrypt()
performs RSA encryption on a string of arbitrary length with a
public key using the encryption scheme bound to the object. The default
scheme is OAEP. encrypt()
returns cyphertext (a string) on success and
undef on failure. It takes a hash as argument with following keys:
decrypt()
performs RSA decryption with a private key using the encryption
scheme bound to the object. The default scheme is OAEP. decrypt()
returns
plaintext on success and undef on failure. It takes a hash as argument
with following keys:
sign()
creates an RSA signature on a string with a private key using the
signature scheme bound to the object. The default scheme is
PSS. sign()
returns a signature on success and undef on failure. It takes
a hash as argument with following keys:
verify()
verifies an RSA signature with a public key using the signature
scheme bound to the object. The default scheme is PSS. verify()
returns a
true value on success and undef on failure. It takes a hash as argument
with following keys:
Apart from Crypt::RSA, the following modules are intended for application developer and end-user consumption:
A Crypt::RSA object can be customized by passing any of the following keys in a hash to new(): ES to specify the encryption scheme, SS to specify the signature scheme, PP to specify the post processor, and KF to specify the key format. The value associated with these keys can either be a name (a string) or a hash reference that specifies a module name, its constructor, and constructor arguments. For example:
my $rsa = new Crypt::RSA ( ES => 'OAEP' );
or
my $rsa = new Crypt::RSA ( ES => { Module => 'Crypt::RSA::ES::OAEP' } );
A module thus specified need not be included in the Crypt::RSA bundle, but it must be interface compatible with the ones provided with Crypt::RSA.
As of this writing, the following names are recognised:
'OAEP', 'PKCS1v15'
'PSS', 'PKCS1v15'
'Native', 'SSH'
'ASCII'
All modules in the Crypt::RSA bundle use a common error handling method
(implemented in Crypt::RSA::Errorhandler(3)). When a method fails it
returns undef and calls $self->error()
with the error message. This error
message is available to the caller through the errstr()
method. For more
details see the Crypt::RSA::Errorhandler(3) manpage.
Vipul Ved Prakash, <mail@vipul.net>
Thanks to Ilya Zakharevich for help with Math::Pari, Benjamin Trott for several patches including SSH key support, Genèche Ramanoudjame for extensive testing and numerous bug reports, Shizukesa on #perl for suggesting the error handling method used in this module, and Dave Paris for good advice.
Copyright (c) 2000-2001, Vipul Ved Prakash. All rights reserved. This code is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
Crypt::RSA::Primitives(3), Crypt::RSA::DataFormat(3), Crypt::RSA::Errorhandler(3), Crypt::RSA::Debug(3), Crypt::Primes(3), Crypt::Random(3), Crypt::CBC(3), Crypt::Blowfish(3), Tie::EncryptedHash(3), Convert::ASCII::Armour(3), Math::Pari(3), Class::Loader(3), crypt-rsa-interoperability(3), crypt-rsa-interoperability-table(3).
pac@lists.vipul.net is a mailing list for discussing the usage & development of asymmetric cryptography modules in perl. Please post Crypt::RSA related communications directly to the list address. Before you post though, take a moment to grep through the list archives at <URL:http://lists.vipul.net/mailman/listinfo/pac/> to see if your question has already been answered there.
Chronologically sorted (for the most part).
Crypt::RSA - RSA public-key cryptosystem. |