File Coverage

blib/lib/Bitcoin/Secp256k1.pm

Criterion	Covered	Total	%
statement	150	154	97.4
branch	33	60	55.0
condition	32	77	41.5
subroutine	37	37	100.0
pod	27	27	100.0
total	279	355	78.5

package Bitcoin::Secp256k1;
$Bitcoin::Secp256k1::VERSION = '0.011';
use v5.10;
use strict;
use warnings;
use Digest::SHA qw(sha256);
use Carp;

# RANDOMNESS SOURCE
# libsecp256k1 needs a source of randomness to randomize context, which
# increases its security. Since it is not 100% required for the library to work
# properly, we try a couple sources first, and may eventually give up with a
# warning.

use constant HAS_CRYPTX => eval { require Crypt::PRNG; 1; };
use constant HAS_BYTES_RANDOM_SECURE => eval { require Bytes::Random::Secure; 1; };

sub _random_bytes
{
	my ($count) = @_;

	if (HAS_CRYPTX) {
		return Crypt::PRNG::random_bytes($count);
	}

	if (HAS_BYTES_RANDOM_SECURE) {
		return Bytes::Random::Secure::random_bytes($count);
	}

	carp
		'Caution: no supported PRNG module is installed. For extra security, please install CryptX or Bytes::Random::Secure';
	return undef;
}

our $FORCED_SCHNORR_AUX_RAND;

sub _schnorr_aux_random
{
	return $FORCED_SCHNORR_AUX_RAND // _random_bytes(32);
}

# LOW LEVEL API
# XS defines constructor, destructor and some general utility methods
# interacting directly with libsecp256k1. All of these methods are private and
# subject to change. They are used internally to deliver high level API below.

require XSLoader;
XSLoader::load('Bitcoin::Secp256k1', $Bitcoin::Secp256k1::VERSION);

# HIGH LEVEL API
# These methods are implemented in Perl and deliver more convenient API to
# interact with. They are stable and public.

sub _croak_usage
{
	my $args_str = join ', ', @_;

	my ($package) = caller;
	my ($calling_sub) = (caller 1)[3];
	$calling_sub =~ s/^${package}:://;

	croak "bad or undefined arguments, usage: \$secp256k1->$calling_sub($args_str)";
}

sub verify_private_key
{
	my ($self, $private_key) = @_;

	(defined $private_key)
		or _croak_usage(qw($private_key));

	return $self->_verify_privkey($private_key);
}

sub verify_public_key
{
	my ($self, $public_key) = @_;

	(defined $public_key)
		or _croak_usage(qw($public_key));

	# scope for local $@
	{
		local $@;

		my $success = eval {
			$self->_pubkey($public_key);
			1;
		};

		return !!$success;
	}
}

sub create_public_key
{
	my ($self, $private_key) = @_;

	(defined $private_key)
		or _croak_usage(qw($private_key));

	$self->_create_pubkey($private_key);
	return $self->_pubkey;
}

sub normalize_signature
{
	my ($self, $signature) = @_;

	(defined $signature)
		or _croak_usage(qw($signature));

	$self->_signature($signature);
	$self->_normalize;

	return $self->_signature;
}

sub compress_public_key
{
	my ($self, $public_key, $compressed) = @_;
	$compressed //= !!1;

	(defined $public_key)
		or _croak_usage(qw($public_key [$compressed]));

	return $self->_pubkey($public_key, $compressed);
}

sub sign_message
{
	my ($self, $private_key, $message) = @_;

	(defined $private_key and defined $message)
		or _croak_usage(qw($private_key $message));

	return $self->sign_digest($private_key, sha256(sha256($message)));
}

sub sign_message_schnorr
{
	my ($self, $private_key, $message) = @_;

	(defined $private_key and defined $message)
		or _croak_usage(qw($private_key $message));

	return $self->sign_digest_schnorr($private_key, sha256($message));
}

sub sign_message_recoverable
{
	my ($self, $private_key, $message) = @_;

	(defined $private_key and defined $message)
		or _croak_usage(qw($private_key $message));

	return $self->sign_digest_recoverable($private_key, sha256(sha256($message)));
}

sub sign_digest
{
	my ($self, $private_key, $digest) = @_;

	(defined $private_key and defined $digest)
		or _croak_usage(qw($private_key $digest));

	$self->_sign($private_key, $digest);
	return $self->_signature;
}

sub sign_digest_schnorr
{
	my ($self, $private_key, $digest) = @_;

	(defined $private_key and defined $digest)
		or _croak_usage(qw($private_key $digest));

	$self->_sign_schnorr($private_key, $digest);
	return $self->_signature_schnorr;
}

sub sign_digest_recoverable
{
	my ($self, $private_key, $digest) = @_;

	(defined $private_key and defined $digest)
		or _croak_usage(qw($private_key $digest));

	$self->_sign_recoverable($private_key, $digest);
	return $self->_signature_recoverable;
}

sub recover_public_key_message
{
	my ($self, $recoverable_signature, $message) = @_;

	(defined $recoverable_signature and defined $message)
		or _croak_usage(qw($signature $message));

	return $self->recover_public_key_digest($recoverable_signature, sha256(sha256($message)));
}

sub recover_public_key_digest
{
	my ($self, $recoverable_signature, $digest) = @_;

	(defined $recoverable_signature and defined $digest)
		or _croak_usage(qw($signature $digest));

	$self->_signature_recoverable($recoverable_signature);
	$self->_recover_pubkey_recoverable($digest);
	return $self->_pubkey;
}

sub verify_message
{
	my ($self, $public_key, $signature, $message) = @_;

	(defined $public_key and defined $signature and defined $message)
		or _croak_usage(qw($public_key $signature $message));

	return $self->verify_digest($public_key, $signature, sha256(sha256($message)));
}

sub verify_message_schnorr
{
	my ($self, $public_key, $signature, $message) = @_;

	(defined $public_key and defined $signature and defined $message)
		or _croak_usage(qw($public_key $signature $message));

	return $self->verify_digest_schnorr($public_key, $signature, sha256($message));
}

sub verify_message_recoverable
{
	my ($self, $public_key, $signature, $message) = @_;

	(defined $public_key and defined $signature and defined $message)
		or _croak_usage(qw($public_key $signature $message));

	return $self->verify_digest_recoverable($public_key, $signature, sha256(sha256($message)));
}

sub verify_digest
{
	my ($self, $public_key, $signature, $digest) = @_;

	(defined $public_key and defined $signature and defined $digest)
		or _croak_usage(qw($public_key $signature $digest));

	$self->_pubkey($public_key);
	$self->_signature($signature);
	$self->_normalize;

	return $self->_verify($digest);
}

sub verify_digest_schnorr
{
	my ($self, $public_key, $signature, $digest) = @_;

	(defined $public_key and defined $signature and defined $digest)
		or _croak_usage(qw($public_key $signature $digest));

	$self->_xonly_pubkey($public_key);
	$self->_signature_schnorr($signature);

	return $self->_verify_schnorr($digest);
}

sub verify_digest_recoverable
{
	my ($self, $public_key, $signature, $digest) = @_;

	(defined $public_key and defined $signature and defined $digest)
		or _croak_usage(qw($public_key $signature $digest));

	$self->_signature_recoverable($signature);
	$self->_recover_pubkey_recoverable($digest);
	my $recovered_pubkey = $self->_pubkey;

	return $recovered_pubkey eq $public_key;
}

sub negate_public_key
{
	my ($self, $public_key) = @_;

	(defined $public_key)
		or _croak_usage(qw($public_key));

	$self->_pubkey($public_key);
	$self->_pubkey_negate;

	return $self->_pubkey;
}

sub negate_private_key
{
	my ($self, $private_key) = @_;

	(defined $private_key)
		or _croak_usage(qw($private_key));

	return $self->_privkey_negate($private_key);
}

sub xonly_public_key
{
	my ($self, $public_key) = @_;

	(defined $public_key)
		or _croak_usage(qw($public_key));

	$self->_pubkey($public_key);
	$self->_convert_pubkey_xonly;

	return $self->_xonly_pubkey;
}

sub add_public_key
{
	my ($self, $public_key, $tweak) = @_;

	(defined $public_key and defined $tweak)
		or _croak_usage(qw($public_key $tweak));

	$self->_pubkey($public_key);
	$self->_pubkey_add($tweak);

	return $self->_pubkey;
}

sub add_private_key
{
	my ($self, $private_key, $tweak) = @_;

	(defined $private_key and defined $tweak)
		or _croak_usage(qw($private_key $tweak));

	return $self->_privkey_add($private_key, $tweak);
}

sub multiply_public_key
{
	my ($self, $public_key, $tweak) = @_;

	(defined $public_key and defined $tweak)
		or _croak_usage(qw($public_key $tweak));

	$self->_pubkey($public_key);
	$self->_pubkey_mul($tweak);

	return $self->_pubkey;
}

sub multiply_private_key
{
	my ($self, $private_key, $tweak) = @_;

	(defined $private_key and defined $tweak)
		or _croak_usage(qw($private_key $tweak));

	return $self->_privkey_mul($private_key, $tweak);
}

sub combine_public_keys
{
	my ($self, @public_keys) = @_;

	(@public_keys > 0)
		or _croak_usage(qw($public_key [@more_public_keys]));

	$self->_clear;
	foreach my $pub (@public_keys) {

		(defined $pub)
			or _croak_usage(qw($public_key [@more_public_keys]));

		$self->_pubkey($pub);
		$self->_push_pubkey;
	}

	$self->_pubkey_combine;

	return $self->_pubkey;
}

1;

__END__