public function test()
{
$privKey = hash('sha256', 'private key', true);
$msg32 = hash('sha256', 'msg', true);
$pub_t = '';
/** @var resource $pub_t */
$context = TestCase::getContext();
// Create public key of our private key
$this->assertEquals(1, secp256k1_ec_pubkey_create($context, $pub_t, $privKey));
// Create recoverable signature
$r_sig_t = '';
/** @var resource $r_sig_t */
$this->assertEquals(1, secp256k1_ecdsa_sign_recoverable($context, $r_sig_t, $msg32, $privKey));
$this->assertEquals(SECP256K1_TYPE_RECOVERABLE_SIG, get_resource_type($r_sig_t));
// Recover public key from the signature
$r_pubkey_t = '';
/** @var resource $r_pubkey_t */
$this->assertEquals(1, secp256k1_ecdsa_recover($context, $r_pubkey_t, $r_sig_t, $msg32));
// Compare the two public keys
$sPubkey = '';
$srPubkey = '';
$this->assertEquals(1, secp256k1_ec_pubkey_serialize($context, $sPubkey, $pub_t, 0));
$this->assertEquals(1, secp256k1_ec_pubkey_serialize($context, $srPubkey, $r_pubkey_t, 0));
$this->assertEquals($sPubkey, $srPubkey);
// Double check that serialize(sig) == serialize(parse(serialize(sig))
$sSig = '';
/** @var resource $sSig */
$recid = '';
secp256k1_ecdsa_recoverable_signature_serialize_compact($context, $r_sig_t, $sSig, $recid);
$parsedSig = '';
/** @var resource $parsedSig */
$this->assertEquals(1, secp256k1_ecdsa_recoverable_signature_parse_compact($context, $parsedSig, $sSig, $recid));
$sSigAgain = '';
$recidAgain = '';
secp256k1_ecdsa_recoverable_signature_serialize_compact($context, $parsedSig, $sSigAgain, $recidAgain);
// Prepare expected DER sig
$rl = 32;
$r = substr($sSig, 0, 32);
if (ord($sSig[0]) > 0x80) {
$rl++;
$r = "" . $r;
}
$sl = 32;
$s = substr($sSig, 32, 32);
if (ord($sSig[32]) > 0x80) {
$sl++;
$s = "" . $s;
}
$t = 4 + $rl + $sl;
$der = "0" . chr($t) . "" . chr($rl) . $r . "" . chr($sl) . $s;
$plain = '';
/** @var resource $plain */
// Test that conversion is successful
$this->assertEquals(1, secp256k1_ecdsa_recoverable_signature_convert($context, $plain, $r_sig_t));
// Test the converted sig's DER output matches what we expect
$derSer = '';
$this->assertEquals(1, secp256k1_ecdsa_signature_serialize_der($context, $derSer, $plain));
$this->assertEquals($der, $derSer);
}
/**
* @param $privkey
* @param $msg
* @param $sig
* @param $ePubCreate
* @param $eSigCreate
*/
private function genericTest($context, $privkey, $msg, $sig, $ePubCreate, $eSigCreate)
{
$seckey = $this->toBinary32($privkey);
$msg = $this->toBinary32($msg);
$sig = $this->toBinary32($sig);
/** @var resource $pubkey */
$pubkey = '';
$this->assertEquals($ePubCreate, \secp256k1_ec_pubkey_create($context, $seckey, $pubkey));
/** @var resource $s */
$s = '';
secp256k1_ecdsa_signature_parse_der($context, $sig, $s);
$this->assertEquals($eSigCreate, \secp256k1_ecdsa_verify($context, $msg, $s, $pubkey));
}
/**
* Testing return value 1
*/
public function testEcdsa()
{
$context = TestCase::getContext();
$priv1 = str_pad('', 32, "A");
$priv2 = str_pad('', 32, "@");
$expectedSecret = '238c14f420887f8e9bfa78bc9bdded1975f0bb6384e33b4ebbf7a8c776844aec';
$pub1 = '';
$pub2 = '';
$this->assertEquals(1, secp256k1_ec_pubkey_create($context, $pub1, $priv1));
$this->assertEquals(1, secp256k1_ec_pubkey_create($context, $pub2, $priv2));
/**
* @var resource $pub2
* @var resource $pub1
*/
$result = '';
$this->assertEquals(1, secp256k1_ecdh($context, $result, $pub2, $priv1));
$this->assertEquals(32, strlen($result));
$this->assertEquals(pack("H*", $expectedSecret), $result);
}
public function testVerifyCompact()
{
$context = TestCase::getContext();
$recid = 1;
$compressed = 0;
$sig = pack("H*", 'fe5fe404f3d8c21e1204a08c38ff3912d43c5a22541d2f1cdc4977cbcad240015a3b6e9040f62cacf016df4fef9412091592e4908e5e3a7bd2a42a4d1be01951');
/** @var resource $s */
$s = '';
$this->assertEquals(1, secp256k1_ecdsa_recoverable_signature_parse_compact($context, $s, $sig, $recid));
$privateKey = pack("H*", 'fbb80e8a0f8af4fb52667e51963ac9860c192981f329debcc5d123a492a726af');
$publicKey = '';
$this->assertEquals(1, secp256k1_ec_pubkey_create($context, $publicKey, $privateKey));
$ePubKey = '';
$this->assertEquals(1, secp256k1_ec_pubkey_serialize($context, $ePubKey, $publicKey, $compressed));
$msg = pack("H*", '03acc83ba10066e791d51e8a8eb90ec325feea7251cb8f979996848fff551d13');
$recPubKey = '';
$this->assertEquals(1, secp256k1_ecdsa_recover($context, $recPubKey, $s, $msg));
$serPubKey = '';
$this->assertEquals(1, secp256k1_ec_pubkey_serialize($context, $serPubKey, $recPubKey, $compressed));
$this->assertEquals($ePubKey, $serPubKey);
}
/**
* @dataProvider getErroneousTypeVectors
* @expectedException \PHPUnit_Framework_Error_Warning
*/
public function testErroneousTypes($context, $seckey)
{
$pubkey = '';
\secp256k1_ec_pubkey_create($context, $seckey, $pubkey);
}
/**
* @return PublicKey
*/
public function getPublicKey()
{
if (null === $this->publicKey) {
$context = $this->ecAdapter->getContext();
$publicKey_t = '';
/** @var resource $publicKey_t */
if (1 !== secp256k1_ec_pubkey_create($context, $this->getBinary(), $publicKey_t)) {
throw new \RuntimeException('Failed to create public key');
}
$this->publicKey = new PublicKey($this->ecAdapter, $publicKey_t, $this->compressed);
}
return $this->publicKey;
}
/**
* @param PrivateKeyInterface $privateKey
* @return \BitWasp\Bitcoin\Key\PublicKey
* @throws \Exception
*/
public function privateToPublic(PrivateKeyInterface $privateKey)
{
$publicKey = '';
$ret = \secp256k1_ec_pubkey_create($privateKey->getBuffer()->getBinary(), (int) $privateKey->isCompressed(), $publicKey);
if ($ret === 1) {
$public = PublicKeyFactory::fromHex(bin2hex($publicKey), $this);
return $public;
}
throw new \Exception('Unable to convert private to public key');
}
function generateKeyPair()
{
// Create a context:
$ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
do {
// Generate random str:
$privkey = mcrypt_create_iv(32, \MCRYPT_DEV_URANDOM);
// Attempt to verify that it's a valid private key:
} while (!(bool) secp256k1_ec_seckey_verify($ctx, $privkey));
$pubkey = null;
$pubkeyRef = null;
// Create the public key (note: For additional safety, check this equals 1):
secp256k1_ec_pubkey_create($ctx, $privkey, $pubkeyRef);
// Serialise it:
secp256k1_ec_pubkey_serialize($ctx, $pubkeyRef, false, $pubkey);
// Done:
return array('private' => $privkey, 'public' => $pubkey);
}
