NAME

Crypt::ECDSA -- Elliptical Cryptography Digital Signature Algorithm

DESCRIPTION

An implementation of the elliptic curve digital signature algorithm in Perl,
using the Math::GMPz library and a little C for speed.

Implements the pending FIPS 186-3 ECDSA standard for digital signatures using
elliptical key crytography.  Like FIPS 186-3, this is preliminary-- not yet 
ready for full use.  It does contain a working implementation of the elliptical 
key crypto found in the current 186-2 standard.  The final details of the 186-3 
standard are still being worked out.  Perhaps a preliminary version of signature
in the NEW standard might be the following, which uses SHA-256 instead of the
current SHA-1 digest:

my $ecdsa = Crypt::ECDSA->new( 
  standard => 'ECP-256',
  algorithm => Digest::SHA->new(256);
);
my $msg = "This is a test message fpr perl ecdsa."    
my ( $r, $s ) = ecdsa->signature( message => $msg );

print "Signature (r, s) is: \nr = $r\ns = $s\n";

SYNOPSIS

my $ecdsa = Crypt::ECDSA->new( standard => 'ECP-256' );

my $msg = "This is a test message fpr perl ecdsa."

my ( $r, $s ) = ecdsa->signature( message => $msg );

my $verify_ok = $ecdsa->verify( r => $r, 's' => $s, message => $msg );

METHODS

new

Create an ECDSA object.

Arguments include:

standard => curve type, one of 'ECP-192', 'ECP-224', 'ECP-256', 'ECP-384',
  'ECP-521', 'EC2N-163', 'EC2N-233', 'EC2N-283', 'EC2N-409', 'EC2N-571',
  
algorithm => $algo,  where $algo is a Digest::SHA interface compatible object,
  which defaults to Digest::SHA(1) which does SHA-1 digests for ECDSA.
  
.. and other arguments, used as per Crypt::ECDSA::Key.

);

key

my $key = $ecdsa->key;

Get the key object in use by this ecdsa object

errstr

print $ecdsa->errstr;

Get the last internal error message

keygen

if( $want_new_key ) {  $
  my( $secret, $base_point ) = ecdsa->keygen(); 

Make a new private/ public key pair

make_text_digest

  my $msg = "This is a test message fpr perl ecdsa."
  
  my  $digest = ecdsa->make_text_digest( $msg );

Make a text digest via the algorithm passed to new ( default is SHA-1 )

signature

  my ( $r, $s ) = ecdsa->signature( message => $msg );
  
Sign a message as message => message or a digest as hash => $digest

sign

Sign is a synonym for signature

verify_public_key

Verify a public key point, as in the Crypt::ECDSA::Key method 

verify

Verify as message given  r, s, and either message or its digest


  my $msg = "This is a test message fpr perl ecdsa."
  my $digest = ecdsa->make_text_digest( $msg );
  my $verify_ok = $ecdsa->verify( r => $r, 's' => $s, message => $msg );
  my $verify_ok = $ecdsa->verify( r => $r, 's' => $s, hash => $digest );

NOTES

See FIPS 186-3, draft standard Note the use of SHA-1 hashing is becoming deprecated, but is still the default. SHA-256 hashing may be used instead of SHA-1 when practicable.

See also http://en.wikipedia.org/wiki/Elliptic_Curve_DSA, quoted below:

Signature generation algorithm

Suppose Alice wants to send a signed message to Bob. 
Initially, the curve parameters (q,FR,a,b,G,n,h) must be agreed upon. 
Also, Alice must have a key pair suitable for elliptic curve cryptography, 
consisting of a private key dA (a randomly selected integer in the 
interval [1,n ? 1]) and a public key QA (where QA = dAG).

For Alice to sign a message m, she follows these steps:

 1. Calculate e = HASH(m), where HASH is a cryptographic hash function, such as SHA-1.
 2. Select a random integer k from [1,n ? 1].
 3. Calculate r = x1(mod n), where (x1,y1) = kG. If r = 0, go back to step 2.
 4. Calculate s = k ? 1(e + dAr)(mod n). If s = 0, go back to step 2.
 5. The signature is the pair (r,s).

Signature verification algorithm

For Bob to authenticate Alice's signature, he must have a copy of her 
public key QA. He follows these steps:

 1. Verify that r and s are integers in [1,n ? 1]. If not, the signature is invalid.
 2. Calculate e = HASH(m), where HASH is the same function used in the signature generation.
 3. Calculate w = s ? 1(mod n).
 4. Calculate u1 = ew(mod n) and u2 = rw(mod n).
 5. Calculate (x1,y1) = u1G + u2QA.
 6. The signature is valid if x1 = r(mod n), invalid otherwise.

TODO

Currently I know of no working non-Cygwin redent versions of the library needed by 
Math::GMPz.

The Koblitz curve point multiplication algorithm could be optimized a bit more.

AUTHOR

William Herrera (wherrera@skylightview.com)

COPYRIGHT

 Copyright (C) 2007 William Hererra.  All Rights Reserved.

 This module is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself.