Curve::getPrime() - Code Metrics - Inspection of "PHP ECC Works" - Spomky-Labs/jose - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — v7 ( 986b39...d5cb12 )

by Florent

created 2017-09-15 11:11 UTC

Curve::getPrime() A

↳ Parent: Curve

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2017 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace Jose\Component\Core\Util\Ecc\Primitives;

use Jose\Component\Core\Util\Ecc\Crypto\Key\PublicKey;
use Jose\Component\Core\Util\Ecc\Math\GmpMath;
use Jose\Component\Core\Util\Ecc\Math\ModularArithmetic;

/**
 * This class is a representation of an EC over a field modulo a prime number.
 *
 * Important objectives for this class are:
 * - Does the curve contain a point?
 * - Comparison of two curves.
 */
final class Curve
{
    /**
     * Elliptic curve over the field of integers modulo a prime.
     *
     * @var \GMP
     */
    private $a;

    /**
     * @var \GMP
     */
    private $b;

    /**
     * @var \GMP
     */
    private $prime;

    /**
     * Binary length of keys associated with these curve parameters.
     *
     * @var int
     */
    private $size;

    /**
     * @var Point
     */
    private $generator;

    /**
     * @param int   $size
     * @param \GMP  $prime
     * @param \GMP  $a
     * @param \GMP  $b
     * @param Point $generator
     */
    public function __construct(int $size, \GMP $prime, \GMP $a, \GMP $b, Point $generator)
    {
        $this->size = $size;
        $this->prime = $prime;
        $this->a = $a;
        $this->b = $b;
        $this->generator = $generator;
    }

    /**
     * @return \GMP
     */
    public function getA(): \GMP
    {
        return $this->a;
    }

    /**
     * @return \GMP
     */
    public function getB(): \GMP
    {
        return $this->b;
    }

    /**
     * @return \GMP
     */
    public function getPrime(): \GMP
    {
        return $this->prime;
    }

    /**
     * @return int
     */
    public function getSize(): int
    {
        return $this->size;
    }

    /**
     * @param \GMP      $x
     * @param \GMP      $y
     * @param \GMP|null $order
     *
     * @return Point
     */
    public function getPoint(\GMP $x, \GMP $y, ?\GMP $order = null): Point
    {
        if (!$this->contains($x, $y)) {
            throw new \RuntimeException('Curve '.$this->__toString().' does not contain point ('.GmpMath::toString($x).', '.GmpMath::toString($y).')');
        }
        $point = Point::create($x, $y, $order);
        if (!is_null($order)) {
            $mul = $this->mul($point, $order);
            if (!$mul->isInfinity()) {
                throw new \RuntimeException('SELF * ORDER MUST EQUAL INFINITY. ('.(string) $mul.' found instead)');
            }
        }

        return $point;
    }

    /**
     * @param \GMP  $x
     * @param \GMP  $y
     *
     * @return PublicKey
     */
    public function getPublicKeyFrom(\GMP $x, \GMP $y): PublicKey
    {
        $point = $this->getPoint($x, $y);

        if (GmpMath::cmp($point->getX(), gmp_init(0, 10)) < 0 || GmpMath::cmp($this->generator->getOrder(), $point->getX()) <= 0
            || GmpMath::cmp($point->getY(), gmp_init(0, 10)) < 0 || GmpMath::cmp($this->generator->getOrder(), $point->getY()) <= 0
        ) {
            throw new \RuntimeException('Generator point has x and y out of range.');
        }


        return PublicKey::create($point);
    }

    /**
     * @param \GMP $x
     * @param \GMP $y
     *
     * @return bool
     */
    public function contains(\GMP $x, \GMP $y): bool
    {
        $eq_zero = GmpMath::equals(
            ModularArithmetic::sub(
                GmpMath::pow($y, 2),
                GmpMath::add(
                    GmpMath::add(
                        GmpMath::pow($x, 3),
                        GmpMath::mul($this->getA(), $x)
                    ),
                    $this->getB()
                ),
                $this->getPrime()
            ),
            gmp_init(0, 10)
        );

        return $eq_zero;
    }

    /**
     * @param Point $one
     * @param Point $two
     *
     * @return Point
     */
    public function add(Point $one, Point $two): Point
    {
        /*if (!$this->equals($two->getCurve())) {
            throw new \RuntimeException('The Elliptic Curves do not match.');
        }*/

        if ($two->isInfinity()) {
            return clone $one;
        }

        if ($one->isInfinity()) {
            return clone $two;
        }

        if (GmpMath::equals($two->getX(), $one->getX())) {
            if (GmpMath::equals($two->getY(), $one->getY())) {
                return $this->getDouble($one);
            } else {
                return Point::infinity();
            }
        }

        $slope = ModularArithmetic::div(
            GmpMath::sub($two->getY(), $one->getY()),
            GmpMath::sub($two->getX(), $one->getX()),
            $this->getPrime()
        );

        $xR = ModularArithmetic::sub(
            GmpMath::sub(GmpMath::pow($slope, 2), $one->getX()),
            $two->getX(),
            $this->getPrime()
        );

        $yR = ModularArithmetic::sub(
            GmpMath::mul($slope, GmpMath::sub($one->getX(), $xR)),
            $one->getY(),
            $this->getPrime()
        );

        return $this->getPoint($xR, $yR, $one->getOrder());
    }

    /**
     * @param Point $one
     * @param \GMP  $n
     *
     * @return Point
     */
    public function mul(Point $one, \GMP $n): Point
    {
        if ($one->isInfinity()) {
            return Point::infinity();
        }

        /** @var \GMP $zero */
        $zero = gmp_init(0, 10);
        if (GmpMath::cmp($one->getOrder(), $zero) > 0) {
            $n = GmpMath::mod($n, $one->getOrder());
        }

        if (GmpMath::equals($n, $zero)) {
            return Point::infinity();
        }

        /** @var Point[] $r */
        $r = [
            Point::infinity(),
            clone $one,
        ];

        $k = $this->getSize();
        $n = str_pad(GmpMath::baseConvert(GmpMath::toString($n), 10, 2), $k, '0', STR_PAD_LEFT);

        for ($i = 0; $i < $k; ++$i) {
            $j = $n[$i];

            Point::cswap($r[0], $r[1], $j ^ 1);

            $r[0] = $this->add($r[0],$r[1]);
            $r[1] = $this->getDouble($r[1]);

            Point::cswap($r[0], $r[1], $j ^ 1);
        }

        $this->validate($r[0]);

        return $r[0];
    }

    /**
     * @param Curve $other
     *
     * @return int
     */
    public function cmp(Curve $other): int
    {
        $equal = GmpMath::equals($this->getA(), $other->getA());
        $equal &= GmpMath::equals($this->getB(), $other->getB());
        $equal &= GmpMath::equals($this->getPrime(), $other->getPrime());

        return $equal ? 0 : 1;
    }

    /**
     * @param Curve $other
     *
     * @return bool
     */
    public function equals(Curve $other): bool
    {
        return $this->cmp($other) === 0;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return 'curve(' . GmpMath::toString($this->getA()) . ', ' . GmpMath::toString($this->getB()) . ', ' . GmpMath::toString($this->getPrime()) . ')';
    }

    /**
     * @param Point $point
     */
    private function validate(Point $point)
    {
        if (!$point->isInfinity() && !$this->contains($point->getX(), $point->getY())) {
            throw new \RuntimeException('Invalid point');
        }
    }

    /**
     * @param Point $point
     *
     * @return Point
     */
    public function getDouble(Point $point): Point
    {
        if ($point->isInfinity()) {
            return Point::infinity();
        }

        $a = $this->getA();
        $threeX2 = GmpMath::mul(gmp_init(3, 10), GmpMath::pow($point->getX(), 2));

        $tangent = ModularArithmetic::div(
            GmpMath::add($threeX2, $a),
            GmpMath::mul(gmp_init(2, 10), $point->getY()),
            $this->getPrime()
        );

        $x3 = ModularArithmetic::sub(
            GmpMath::pow($tangent, 2),
            GmpMath::mul(gmp_init(2, 10), $point->getX()),
            $this->getPrime()
        );

        $y3 = ModularArithmetic::sub(
            GmpMath::mul($tangent, GmpMath::sub($point->getX(), $x3)),
            $point->getY(),
            $this->getPrime()
        );

        return $this->getPoint($x3, $y3, $point->getOrder());
    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2014-2017 Spomky-Labs
7			*
8			* This software may be modified and distributed under the terms
9			* of the MIT license. See the LICENSE file for details.
10			*/
11
12			namespace Jose\Component\Core\Util\Ecc\Primitives;
13
14			use Jose\Component\Core\Util\Ecc\Crypto\Key\PublicKey;
15			use Jose\Component\Core\Util\Ecc\Math\GmpMath;
16			use Jose\Component\Core\Util\Ecc\Math\ModularArithmetic;
17
18			/**
19			* This class is a representation of an EC over a field modulo a prime number.
20			*
21			* Important objectives for this class are:
22			* - Does the curve contain a point?
23			* - Comparison of two curves.
24			*/
25			final class Curve
26			{
27			/**
28			* Elliptic curve over the field of integers modulo a prime.
29			*
30			* @var \GMP
31			*/
32			private $a;
33
34			/**
35			* @var \GMP
36			*/
37			private $b;
38
39			/**
40			* @var \GMP
41			*/
42			private $prime;
43
44			/**
45			* Binary length of keys associated with these curve parameters.
46			*
47			* @var int
48			*/
49			private $size;
50
51			/**
52			* @var Point
53			*/
54			private $generator;
55
56			/**
57			* @param int $size
58			* @param \GMP $prime
59			* @param \GMP $a
60			* @param \GMP $b
61			* @param Point $generator
62			*/
63			public function __construct(int $size, \GMP $prime, \GMP $a, \GMP $b, Point $generator)
64			{
65			$this->size = $size;
66			$this->prime = $prime;
67			$this->a = $a;
68			$this->b = $b;
69			$this->generator = $generator;
70			}
71
72			/**
73			* @return \GMP
74			*/
75			public function getA(): \GMP
76			{
77			return $this->a;
78			}
79
80			/**
81			* @return \GMP
82			*/
83			public function getB(): \GMP
84			{
85			return $this->b;
86			}
87
88			/**
89			* @return \GMP
90			*/
91			public function getPrime(): \GMP
92			{
93			return $this->prime;
94			}
95
96			/**
97			* @return int
98			*/
99			public function getSize(): int
100			{
101			return $this->size;
102			}
103
104			/**
105			* @param \GMP $x
106			* @param \GMP $y
107			* @param \GMP\|null $order
108			*
109			* @return Point
110			*/
111			public function getPoint(\GMP $x, \GMP $y, ?\GMP $order = null): Point
112			{
113			if (!$this->contains($x, $y)) {
114			throw new \RuntimeException('Curve '.$this->__toString().' does not contain point ('.GmpMath::toString($x).', '.GmpMath::toString($y).')');
115			}
116			$point = Point::create($x, $y, $order);
117			if (!is_null($order)) {
118			$mul = $this->mul($point, $order);
119			if (!$mul->isInfinity()) {
120			throw new \RuntimeException('SELF * ORDER MUST EQUAL INFINITY. ('.(string) $mul.' found instead)');
121			}
122			}
123
124			return $point;
125			}
126
127			/**
128			* @param \GMP $x
129			* @param \GMP $y
130			*
131			* @return PublicKey
132			*/
133			public function getPublicKeyFrom(\GMP $x, \GMP $y): PublicKey
134			{
135			$point = $this->getPoint($x, $y);
136
137			if (GmpMath::cmp($point->getX(), gmp_init(0, 10)) < 0 \|\| GmpMath::cmp($this->generator->getOrder(), $point->getX()) <= 0
138			\|\| GmpMath::cmp($point->getY(), gmp_init(0, 10)) < 0 \|\| GmpMath::cmp($this->generator->getOrder(), $point->getY()) <= 0
139			) {
140			throw new \RuntimeException('Generator point has x and y out of range.');
141			}
142
143
144			return PublicKey::create($point);
145			}
146
147			/**
148			* @param \GMP $x
149			* @param \GMP $y
150			*
151			* @return bool
152			*/
153			public function contains(\GMP $x, \GMP $y): bool
154			{
155			$eq_zero = GmpMath::equals(
156			ModularArithmetic::sub(
157			GmpMath::pow($y, 2),
158			GmpMath::add(
159			GmpMath::add(
160			GmpMath::pow($x, 3),
161			GmpMath::mul($this->getA(), $x)
162			),
163			$this->getB()
164			),
165			$this->getPrime()
166			),
167			gmp_init(0, 10)
168			);
169
170			return $eq_zero;
171			}
172
173			/**
174			* @param Point $one
175			* @param Point $two
176			*
177			* @return Point
178			*/
179			public function add(Point $one, Point $two): Point
180			{
181			/*if (!$this->equals($two->getCurve())) {
182			throw new \RuntimeException('The Elliptic Curves do not match.');
183			}*/
184
185			if ($two->isInfinity()) {
186			return clone $one;
187			}
188
189			if ($one->isInfinity()) {
190			return clone $two;
191			}
192
193			if (GmpMath::equals($two->getX(), $one->getX())) {
194			if (GmpMath::equals($two->getY(), $one->getY())) {
195			return $this->getDouble($one);
196			} else {
197			return Point::infinity();
198			}
199			}
200
201			$slope = ModularArithmetic::div(
202			GmpMath::sub($two->getY(), $one->getY()),
203			GmpMath::sub($two->getX(), $one->getX()),
204			$this->getPrime()
205			);
206
207			$xR = ModularArithmetic::sub(
208			GmpMath::sub(GmpMath::pow($slope, 2), $one->getX()),
209			$two->getX(),
210			$this->getPrime()
211			);
212
213			$yR = ModularArithmetic::sub(
214			GmpMath::mul($slope, GmpMath::sub($one->getX(), $xR)),
215			$one->getY(),
216			$this->getPrime()
217			);
218
219			return $this->getPoint($xR, $yR, $one->getOrder());
220			}
221
222			/**
223			* @param Point $one
224			* @param \GMP $n
225			*
226			* @return Point
227			*/
228			public function mul(Point $one, \GMP $n): Point
229			{
230			if ($one->isInfinity()) {
231			return Point::infinity();
232			}
233
234			/** @var \GMP $zero */
235			$zero = gmp_init(0, 10);
236			if (GmpMath::cmp($one->getOrder(), $zero) > 0) {
237			$n = GmpMath::mod($n, $one->getOrder());
238			}
239
240			if (GmpMath::equals($n, $zero)) {
241			return Point::infinity();
242			}
243
244			/** @var Point[] $r */
245			$r = [
246			Point::infinity(),
247			clone $one,
248			];
249
250			$k = $this->getSize();
251			$n = str_pad(GmpMath::baseConvert(GmpMath::toString($n), 10, 2), $k, '0', STR_PAD_LEFT);
252
253			for ($i = 0; $i < $k; ++$i) {
254			$j = $n[$i];
255
256			Point::cswap($r[0], $r[1], $j ^ 1);
257
258			$r[0] = $this->add($r[0],$r[1]);
259			$r[1] = $this->getDouble($r[1]);
260
261			Point::cswap($r[0], $r[1], $j ^ 1);
262			}
263
264			$this->validate($r[0]);
265
266			return $r[0];
267			}
268
269			/**
270			* @param Curve $other
271			*
272			* @return int
273			*/
274			public function cmp(Curve $other): int
275			{
276			$equal = GmpMath::equals($this->getA(), $other->getA());
277			$equal &= GmpMath::equals($this->getB(), $other->getB());
278			$equal &= GmpMath::equals($this->getPrime(), $other->getPrime());
279
280			return $equal ? 0 : 1;
281			}
282
283			/**
284			* @param Curve $other
285			*
286			* @return bool
287			*/
288			public function equals(Curve $other): bool
289			{
290			return $this->cmp($other) === 0;
291			}
292
293			/**
294			* @return string
295			*/
296			public function __toString(): string
297			{
298			return 'curve(' . GmpMath::toString($this->getA()) . ', ' . GmpMath::toString($this->getB()) . ', ' . GmpMath::toString($this->getPrime()) . ')';
299			}
300
301			/**
302			* @param Point $point
303			*/
304			private function validate(Point $point)
305			{
306			if (!$point->isInfinity() && !$this->contains($point->getX(), $point->getY())) {
307			throw new \RuntimeException('Invalid point');
308			}
309			}
310
311			/**
312			* @param Point $point
313			*
314			* @return Point
315			*/
316			public function getDouble(Point $point): Point
317			{
318			if ($point->isInfinity()) {
319			return Point::infinity();
320			}
321
322			$a = $this->getA();
323			$threeX2 = GmpMath::mul(gmp_init(3, 10), GmpMath::pow($point->getX(), 2));
324
325			$tangent = ModularArithmetic::div(
326			GmpMath::add($threeX2, $a),
327			GmpMath::mul(gmp_init(2, 10), $point->getY()),
328			$this->getPrime()
329			);
330
331			$x3 = ModularArithmetic::sub(
332			GmpMath::pow($tangent, 2),
333			GmpMath::mul(gmp_init(2, 10), $point->getX()),
334			$this->getPrime()
335			);
336
337			$y3 = ModularArithmetic::sub(
338			GmpMath::mul($tangent, GmpMath::sub($point->getX(), $x3)),
339			$point->getY(),
340			$this->getPrime()
341			);
342
343			return $this->getPoint($x3, $y3, $point->getOrder());
344			}
345			}
346

Spomky-Labs / jose

Push — v7 ( 986b39...d5cb12 )

Curve::getPrime() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like