/**
* @param CurveFpInterface $curve
* @param string $data
* @return PointInterface
*/
public function unserialize(CurveFpInterface $curve, $data)
{
if (substr($data, 0, 2) != '04') {
throw new \InvalidArgumentException('Invalid data: only uncompressed keys are supported.');
}
$data = substr($data, 2);
$dataLength = strlen($data);
$x = $this->adapter->hexDec(substr($data, 0, $dataLength / 2));
$y = $this->adapter->hexDec(substr($data, $dataLength / 2));
return $curve->getPoint($x, $y);
}
/**
* @dataProvider getB24Params
* @testdox Test 192-bit generated curve points against ECDSAVS section B2.4 samples
*/
public function testP192CurveEcdsavsB24SignatureValidityTest(MathAdapterInterface $math, $msg, $Qx, $Qy, $R, $S, $expected)
{
$msg = $math->hexDec($msg);
$Qx = $math->hexDec($Qx);
$Qy = $math->hexDec($Qy);
$R = $math->hexDec($R);
$S = $math->hexDec($S);
$generator = EccFactory::getNistCurves($math)->generator192();
$publicKey = $generator->getPublicKeyFrom($Qx, $Qy);
$signer = new Signer($math);
$actual = $signer->verify($publicKey, new Signature($R, $S), $math->digestInteger($msg));
$this->assertEquals($expected, $actual);
}
/**
* @dataProvider getAdapters
*/
public function testStrictIntegerReturnValues(MathAdapterInterface $math)
{
$x = 10;
$y = 4;
$mod = $math->mod($x, $y);
$this->assertTrue(is_string($mod) && !is_resource($mod));
$add = $math->add($x, $y);
$this->assertTrue(is_string($add) && !is_resource($add));
$sub = $math->sub($add, $y);
$this->assertTrue(is_string($sub) && !is_resource($sub));
$mul = $math->mul($x, $y);
$this->assertTrue(is_string($mul) && !is_resource($mul));
$div = $math->div($mul, $y);
$this->assertTrue(is_string($div) && !is_resource($div));
$pow = $math->pow($x, $y);
$this->assertTrue(is_string($pow) && !is_resource($div));
$powmod = $math->powmod($x, $y, $y);
$this->assertTrue(is_string($powmod) && !is_resource($powmod));
$bitwiseand = $math->bitwiseAnd($x, $y);
$this->assertTrue(is_string($bitwiseand) && !is_resource($bitwiseand));
$hexdec = $math->decHex($x);
$this->assertTrue(is_string($hexdec) && !is_resource($hexdec));
$dechex = $math->hexDec($hexdec);
$this->assertTrue(is_string($dechex) && !is_resource($dechex));
}
/**
* @param string $data
* {@inheritDoc}
* @see \Mdanter\Ecc\Serializer\PrivateKeySerializerInterface::parse()
* @throws \FG\ASN1\Exception\ParserException
*/
public function parse($data)
{
$asnObject = Object::fromBinary($data);
if (!$asnObject instanceof Sequence || $asnObject->getNumberofChildren() !== 4) {
throw new \RuntimeException('Invalid data.');
}
$children = $asnObject->getChildren();
$version = $children[0];
if ($version->getContent() != 1) {
throw new \RuntimeException('Invalid data: only version 1 (RFC5915) keys are supported.');
}
$key = $this->adapter->hexDec($children[1]->getContent());
$oid = $children[2]->getContent();
$generator = CurveOidMapper::getGeneratorFromOid($oid);
return $generator->getPrivateKeyFrom($key);
}
/**
* @dataProvider getDeterministicSign2Data
*/
public function testDeterministicSign2($curve, $size, $algo, $privKey, $message, $eK, $eR, $eS)
{
//echo "Try {$test->curve} / {$test->algorithm} / '{$test->message}'\n";
$G = CurveFactory::getGeneratorByName($curve);
// Initialize private key and message hash (decimal)
$privateKey = $G->getPrivateKeyFrom($this->math->hexDec($privKey));
$hashHex = hash($algo, $message);
$messageHash = $this->math->hexDec($hashHex);
// Derive K
$drbg = RandomGeneratorFactory::getHmacRandomGenerator($privateKey, $messageHash, $algo);
$k = $drbg->generate($G->getOrder());
$this->assertEquals($this->math->hexdec($eK), $k, 'k');
$hexSize = strlen($hashHex);
$hashBits = $this->math->baseConvert($messageHash, 10, 2);
if (strlen($hashBits) < $hexSize * 4) {
$hashBits = str_pad($hashBits, $hexSize * 4, '0', STR_PAD_LEFT);
}
$messageHash = $this->math->baseConvert(substr($hashBits, 0, $size), 2, 10);
$signer = new Signer($this->math);
$sig = $signer->sign($privateKey, $messageHash, $k);
// R and S should be correct
$sR = $this->math->hexDec($eR);
$sS = $this->math->hexDec($eS);
$this->assertTrue($signer->verify($privateKey->getPublicKey(), $sig, $messageHash));
$this->assertSame($sR, $sig->getR(), 'r');
$this->assertSame($sS, $sig->getS(), 's');
}
/**
* Extracts R and S values from given data
*
* @param string $value
*
* @return \Mdanter\Ecc\Crypto\Signature\Signature
*/
private function extractSignature(string $value) : \Mdanter\Ecc\Crypto\Signature\Signature
{
$length = $this->getSignatureLength();
$value = unpack('H*', $value)[1];
return new Signature($this->adapter->hexDec(substr($value, 0, $length)), $this->adapter->hexDec(substr($value, $length)));
}
/**
* Extracts R and S values from given data
*
* @param string $value
*
* @return \Mdanter\Ecc\Crypto\Signature\Signature
*/
private function extractSignature($value)
{
$length = $this->getSignatureLength();
$value = unpack('H*', $value)[1];
return new Signature($this->adapter->hexDec(substr($value, 0, $length)), $this->adapter->hexDec(substr($value, $length)));
}
/**
* @param bool $hex
* @return int|string
*/
public function getHash($hex = false)
{
$hash = hash($this->algo, $this->content, false);
return $hex ? $hash : $this->adapter->hexDec($hash);
}
/**
* @return int|string
*/
public function getInt()
{
return $this->math->hexDec($this->getHex());
}
/**
* @param $value
*
* @return int|string
*/
private function convertHexToDec($value)
{
return $this->adapter->hexDec($value);
}
/**
* @dataProvider getAdapters
*/
public function testModFunction(MathAdapterInterface $math)
{
// $o->compressed, $o->decompressed public key.
// Check that we can compress a key properly (tests $math->mod())
foreach ($this->compression_data as $o) {
$prefix = substr($o->decompressed, 0, 2);
// will be 04.
$this->assertEquals('04', $prefix);
// hex encoded (X,Y) coordinate of ECDSA public key.
$x = substr($o->decompressed, 2, 64);
$y = substr($o->decompressed, 66, 64);
// y % 2 == 0 - true: y is even(02) / false: y is odd(03)
$mod = $math->mod($math->hexDec($y), 2);
$compressed = '0' . ($mod == 0 ? '2' : '3') . $x;
// Check that the mod function reported the parity for the y value.
$this->assertTrue($compressed === $o->compressed);
}
}
/**
* Hash the data, returning a decimal.
*
* @param $string - a binary string to hash
* @return int|string
*/
public function hashDec($string)
{
$hex = $this->hash($string, false);
return $this->math->hexDec($hex);
}
/**
* @param int|string $max
* @return int|string
*/
public function generate($max)
{
$bytes = NumberSize::getFlooredByteSize($this->adapter, $max);
$iv = mcrypt_create_iv($bytes, \MCRYPT_DEV_URANDOM);
return $this->adapter->hexDec(bin2hex($iv));
}