Phase 6: AIOS security plugin with conservative login lockdown config (10 attempts)
This commit is contained in:
Hanson.xyz Dev
Vendored
Executable
+246
@@ -0,0 +1,246 @@
|
||||
<?php
|
||||
|
||||
namespace IPLib\Service;
|
||||
|
||||
/**
|
||||
* Helper class to work with unsigned binary integers.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class BinaryMath
|
||||
{
|
||||
/**
|
||||
* @var \IPLib\Service\BinaryMath|null
|
||||
*/
|
||||
private static $instance;
|
||||
|
||||
/**
|
||||
* @return \IPLib\Service\BinaryMath
|
||||
*/
|
||||
public static function getInstance()
|
||||
{
|
||||
if (self::$instance === null) {
|
||||
self::$instance = new self();
|
||||
}
|
||||
|
||||
return self::$instance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trim the leading zeroes from a non-negative integer represented in binary form.
|
||||
*
|
||||
* @param string $value
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function reduce($value)
|
||||
{
|
||||
$value = ltrim($value, '0');
|
||||
|
||||
return $value === '' ? '0' : $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare two non-negative integers represented in binary form.
|
||||
*
|
||||
* @param string $a
|
||||
* @param string $b
|
||||
*
|
||||
* @return int 1 if $a is greater than $b, -1 if $b is greater than $b, 0 if they are the same
|
||||
*/
|
||||
public function compare($a, $b)
|
||||
{
|
||||
list($a, $b) = $this->toSameLength($a, $b);
|
||||
|
||||
return $a < $b ? -1 : ($a > $b ? 1 : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add 1 to a non-negative integer represented in binary form.
|
||||
*
|
||||
* @param string $value
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function increment($value)
|
||||
{
|
||||
$lastZeroIndex = strrpos($value, '0');
|
||||
if ($lastZeroIndex === false) {
|
||||
return '1' . str_repeat('0', strlen($value));
|
||||
}
|
||||
|
||||
return ltrim(substr($value, 0, $lastZeroIndex), '0') . '1' . str_repeat('0', strlen($value) - $lastZeroIndex - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the bitwise AND of two non-negative integers represented in binary form.
|
||||
*
|
||||
* @param string $operand1
|
||||
* @param string $operand2
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function andX($operand1, $operand2)
|
||||
{
|
||||
$operand1 = $this->reduce($operand1);
|
||||
$operand2 = $this->reduce($operand2);
|
||||
$numBits = min(strlen($operand1), strlen($operand2));
|
||||
$operand1 = substr(str_pad($operand1, $numBits, '0', STR_PAD_LEFT), -$numBits);
|
||||
$operand2 = substr(str_pad($operand2, $numBits, '0', STR_PAD_LEFT), -$numBits);
|
||||
$result = '';
|
||||
for ($index = 0; $index < $numBits; $index++) {
|
||||
$result .= $operand1[$index] === '1' && $operand2[$index] === '1' ? '1' : '0';
|
||||
}
|
||||
|
||||
return $this->reduce($result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the bitwise OR of two non-negative integers represented in binary form.
|
||||
*
|
||||
* @param string $operand1
|
||||
* @param string $operand2
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function orX($operand1, $operand2)
|
||||
{
|
||||
list($operand1, $operand2, $numBits) = $this->toSameLength($operand1, $operand2);
|
||||
$result = '';
|
||||
for ($index = 0; $index < $numBits; $index++) {
|
||||
$result .= $operand1[$index] === '1' || $operand2[$index] === '1' ? '1' : '0';
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute 2 raised to the given exponent.
|
||||
*
|
||||
* If the result fits into a native PHP integer, an int is returned.
|
||||
* If the result exceeds PHP_INT_MAX, a string containing the exact decimal representation is returned.
|
||||
*
|
||||
* @param int $exponent The non-negative exponent
|
||||
*
|
||||
* @return int|numeric-string
|
||||
*/
|
||||
public function pow2string($exponent)
|
||||
{
|
||||
if ($exponent < PHP_INT_SIZE * 8 - 1) {
|
||||
return 1 << $exponent;
|
||||
}
|
||||
$digits = array(1);
|
||||
for ($i = 0; $i < $exponent; $i++) {
|
||||
$carry = 0;
|
||||
foreach ($digits as $index => $digit) {
|
||||
$product = $digit * 2 + $carry;
|
||||
$digits[$index] = $product % 10;
|
||||
$carry = (int) ($product / 10);
|
||||
}
|
||||
if ($carry !== 0) {
|
||||
$digits[] = $carry;
|
||||
}
|
||||
}
|
||||
$result = implode('', array_reverse($digits));
|
||||
/** @var numeric-string $result */
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param numeric-string|mixed $value
|
||||
*
|
||||
* @return numeric-string|'' empty string if $value is not a valid numeric string
|
||||
*/
|
||||
public function normalizeIntegerString($value)
|
||||
{
|
||||
if (!is_string($value) || $value === '') {
|
||||
return '';
|
||||
}
|
||||
$sign = $value[0];
|
||||
if ($sign === '-' || $sign === '+') {
|
||||
$value = substr($value, 1);
|
||||
}
|
||||
$matches = null;
|
||||
if (!preg_match('/^0*([0-9]+)$/', $value, $matches)) {
|
||||
return '';
|
||||
}
|
||||
$numericString = $matches[1];
|
||||
if ($sign === '-' && $numericString !== '0') {
|
||||
$numericString = '-' . $numericString;
|
||||
}
|
||||
/** @var numeric-string $numericString */
|
||||
|
||||
return $numericString;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param numeric-string $value a string that has been normalized with normalizeIntegerString()
|
||||
*
|
||||
* @return numeric-string
|
||||
*/
|
||||
public function add1ToIntegerString($value)
|
||||
{
|
||||
if ($value[0] === '-') {
|
||||
if ($value === '-1') {
|
||||
return '0';
|
||||
}
|
||||
$digits = str_split(substr($value, 1));
|
||||
$i = count($digits) - 1;
|
||||
while ($i >= 0) {
|
||||
if ($digits[$i] !== '0') {
|
||||
$digits[$i] = (string) ((int) $digits[$i] - 1);
|
||||
break;
|
||||
}
|
||||
$digits[$i] = '9';
|
||||
$i--;
|
||||
}
|
||||
$imploded = implode('', $digits);
|
||||
if ($imploded[0] === '0') {
|
||||
$imploded = substr($imploded, 1);
|
||||
}
|
||||
$result = '-' . $imploded;
|
||||
/** @var numeric-string $result */
|
||||
|
||||
return $result; // @phpstan-ignore varTag.nativeType
|
||||
}
|
||||
$digits = str_split($value);
|
||||
$carry = 1;
|
||||
for ($i = count($digits) - 1; $i >= 0; $i--) {
|
||||
$sum = (int) $digits[$i] + $carry;
|
||||
$digits[$i] = (string) ($sum % 10);
|
||||
$carry = (int) ($sum / 10);
|
||||
if ($carry === 0) {
|
||||
break;
|
||||
}
|
||||
if ($i === 0) {
|
||||
array_unshift($digits, (string) $carry);
|
||||
}
|
||||
}
|
||||
$result = implode('', $digits);
|
||||
/** @var numeric-string $result */
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Zero-padding of two non-negative integers represented in binary form, so that they have the same length.
|
||||
*
|
||||
* @param string $num1
|
||||
* @param string $num2
|
||||
*
|
||||
* @return array{string, string, int} The first array element is $num1 (padded), the first array element is $num2 (padded), the third array element is the number of bits
|
||||
*/
|
||||
private function toSameLength($num1, $num2)
|
||||
{
|
||||
$num1 = $this->reduce($num1);
|
||||
$num2 = $this->reduce($num2);
|
||||
$numBits = max(strlen($num1), strlen($num2));
|
||||
|
||||
return array(
|
||||
str_pad($num1, $numBits, '0', STR_PAD_LEFT),
|
||||
str_pad($num2, $numBits, '0', STR_PAD_LEFT),
|
||||
$numBits,
|
||||
);
|
||||
}
|
||||
}
|
||||
Vendored
Executable
+254
@@ -0,0 +1,254 @@
|
||||
<?php
|
||||
|
||||
namespace IPLib\Service;
|
||||
|
||||
use InvalidArgumentException;
|
||||
|
||||
/**
|
||||
* @internal
|
||||
*
|
||||
* @readonly
|
||||
*/
|
||||
class NumberInChunks
|
||||
{
|
||||
const CHUNKSIZE_BYTES = 8;
|
||||
|
||||
const CHUNKSIZE_WORDS = 16;
|
||||
|
||||
/**
|
||||
* @var bool
|
||||
*/
|
||||
public $negative;
|
||||
|
||||
/**
|
||||
* @var int[]
|
||||
*/
|
||||
public $chunks;
|
||||
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
public $chunkSize;
|
||||
|
||||
/**
|
||||
* @param bool $negative
|
||||
* @param int[] $chunks
|
||||
* @param int $chunkSize
|
||||
*/
|
||||
public function __construct($negative, array $chunks, $chunkSize)
|
||||
{
|
||||
$this->negative = $negative;
|
||||
$this->chunks = $chunks;
|
||||
$this->chunkSize = $chunkSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws \InvalidArgumentException if $other has a $chunkSize that's not the same as the $chunkSize of this
|
||||
*
|
||||
* @return \IPLib\Service\NumberInChunks
|
||||
*/
|
||||
public function negate()
|
||||
{
|
||||
return new self($this->chunks === array(0) ? false : !$this->negative, $this->chunks, $this->chunkSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws \InvalidArgumentException if $other has a $chunkSize that's not the same as the $chunkSize of this
|
||||
*
|
||||
* @return \IPLib\Service\NumberInChunks
|
||||
*/
|
||||
public function add(NumberInChunks $that)
|
||||
{
|
||||
if ($this->chunkSize !== $that->chunkSize) {
|
||||
throw new InvalidArgumentException('Incompatible chunk size');
|
||||
}
|
||||
if ($this->negative === $that->negative) {
|
||||
return new self($this->negative, self::addChunks($this->chunks, $that->chunks, $this->chunkSize), $this->chunkSize);
|
||||
}
|
||||
if ($that->negative) {
|
||||
list($negative, $chunks) = self::substractChunks($this->chunks, $that->chunks, $this->chunkSize);
|
||||
} else {
|
||||
list($negative, $chunks) = self::substractChunks($that->chunks, $this->chunks, $this->chunkSize);
|
||||
}
|
||||
|
||||
return new self($negative, $chunks, $this->chunkSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int $int
|
||||
* @param int $chunkSize
|
||||
*
|
||||
* @return \IPLib\Service\NumberInChunks
|
||||
*/
|
||||
public static function fromInteger($int, $chunkSize)
|
||||
{
|
||||
if ($int === 0) {
|
||||
return new self(false, array(0), $chunkSize);
|
||||
}
|
||||
$negative = $int < 0;
|
||||
if ($negative) {
|
||||
$positiveInt = -$int;
|
||||
/** @var int|float $positiveInt may be float because -PHP_INT_MIN is bigger than PHP_INT_MAX */
|
||||
if (is_float($positiveInt)) {
|
||||
return self::fromNumericString((string) $int, $chunkSize);
|
||||
}
|
||||
$int = $positiveInt;
|
||||
}
|
||||
$bitMask = (1 << $chunkSize) - 1;
|
||||
$chunks = array();
|
||||
while ($int !== 0) {
|
||||
$chunks[] = $int & $bitMask;
|
||||
$int >>= $chunkSize;
|
||||
}
|
||||
|
||||
return new self($negative, array_reverse($chunks), $chunkSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $numericString a string normalized with BinaryMath::normalizeIntegerString()
|
||||
* @param int $chunkSize
|
||||
*
|
||||
* @return \IPLib\Service\NumberInChunks
|
||||
*/
|
||||
public static function fromNumericString($numericString, $chunkSize)
|
||||
{
|
||||
if ($numericString === '0') {
|
||||
return new self(false, array(0), $chunkSize);
|
||||
}
|
||||
$negative = $numericString[0] === '-';
|
||||
if ($negative) {
|
||||
$numericString = substr($numericString, 1);
|
||||
}
|
||||
$chunks = array();
|
||||
while ($numericString !== '0') {
|
||||
$chunks[] = self::modulo($numericString, $chunkSize);
|
||||
$numericString = self::divide($numericString, $chunkSize);
|
||||
}
|
||||
|
||||
return new self($negative, array_reverse($chunks), $chunkSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $numericString
|
||||
* @param int $chunkSize
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
private static function modulo($numericString, $chunkSize)
|
||||
{
|
||||
$divisor = 1 << $chunkSize;
|
||||
$carry = 0;
|
||||
$len = strlen($numericString);
|
||||
for ($i = 0; $i < $len; $i++) {
|
||||
$digit = (int) $numericString[$i];
|
||||
$carry = ($carry * 10 + $digit) % $divisor;
|
||||
}
|
||||
|
||||
return $carry;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $numericString
|
||||
* @param int $chunkSize
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
private static function divide($numericString, $chunkSize)
|
||||
{
|
||||
$divisor = 1 << $chunkSize;
|
||||
$quotient = '';
|
||||
$carry = 0;
|
||||
$len = strlen($numericString);
|
||||
for ($i = 0; $i < $len; $i++) {
|
||||
$digit = (int) $numericString[$i];
|
||||
$value = $carry * 10 + $digit;
|
||||
$quotient .= (string) ($value >> $chunkSize);
|
||||
$carry = $value % $divisor;
|
||||
}
|
||||
|
||||
return ltrim($quotient, '0') ?: '0';
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int[] $addend1
|
||||
* @param int[] $addend2
|
||||
* @param int $chunkSize
|
||||
*
|
||||
* @return int[]
|
||||
*/
|
||||
private static function addChunks(array $addend1, array $addend2, $chunkSize)
|
||||
{
|
||||
$divisor = 1 << $chunkSize;
|
||||
$result = array();
|
||||
$carry = 0;
|
||||
while ($addend1 !== array() || $addend2 !== array()) {
|
||||
$sum = $carry + (array_pop($addend1) ?: 0) + (array_pop($addend2) ?: 0);
|
||||
$result[] = $sum % $divisor;
|
||||
$carry = $sum >> $chunkSize;
|
||||
}
|
||||
if ($carry !== 0) {
|
||||
$result[] = $carry;
|
||||
}
|
||||
|
||||
return array_reverse($result);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param int[] $minuend
|
||||
* @param int[] $subtrahend
|
||||
* @param int $chunkSize
|
||||
*
|
||||
* @return array{bool, int[]}
|
||||
*/
|
||||
private static function substractChunks(array $minuend, array $subtrahend, $chunkSize)
|
||||
{
|
||||
$minuendCount = count($minuend);
|
||||
$subtrahendCount = count($subtrahend);
|
||||
if ($minuendCount > $subtrahendCount) {
|
||||
$count = $minuendCount;
|
||||
$negative = false;
|
||||
} elseif ($minuendCount < $subtrahendCount) {
|
||||
$count = $subtrahendCount;
|
||||
$negative = true;
|
||||
} else {
|
||||
$count = $minuendCount;
|
||||
$negative = false;
|
||||
for ($i = 0; $i < $count; $i++) {
|
||||
$delta = $minuend[$i] - $subtrahend[$i];
|
||||
if ($delta === 0) {
|
||||
continue;
|
||||
}
|
||||
if ($delta < 0) {
|
||||
$negative = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ($negative) {
|
||||
list($minuend, $subtrahend) = array($subtrahend, $minuend);
|
||||
}
|
||||
$subtrahend = array_pad($subtrahend, -$count, 0);
|
||||
$borrowValue = 1 << $chunkSize;
|
||||
$result = array();
|
||||
$borrow = 0;
|
||||
for ($i = $count - 1; $i >= 0; $i--) {
|
||||
$value = $minuend[$i] - $subtrahend[$i] - $borrow;
|
||||
if ($value < 0) {
|
||||
$value += $borrowValue;
|
||||
$borrow = 1;
|
||||
} else {
|
||||
$borrow = 0;
|
||||
}
|
||||
$result[] = $value;
|
||||
}
|
||||
while (isset($result[1])) {
|
||||
$value = array_pop($result);
|
||||
if ($value !== 0) {
|
||||
$result[] = $value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return array($negative, array_reverse($result));
|
||||
}
|
||||
}
|
||||
Vendored
Executable
+175
@@ -0,0 +1,175 @@
|
||||
<?php
|
||||
|
||||
namespace IPLib\Service;
|
||||
|
||||
use IPLib\Address\AddressInterface;
|
||||
use IPLib\Factory;
|
||||
use IPLib\Range\Subnet;
|
||||
|
||||
/**
|
||||
* Helper class to calculate the subnets describing all (and only all) the addresses between two boundaries.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class RangesFromBoundaryCalculator
|
||||
{
|
||||
/**
|
||||
* The BinaryMath instance to be used to perform bitwise operations.
|
||||
*
|
||||
* @var \IPLib\Service\BinaryMath
|
||||
*/
|
||||
private $math;
|
||||
|
||||
/**
|
||||
* The number of bits used to represent addresses.
|
||||
*
|
||||
* @var int
|
||||
*
|
||||
* @example 32 for IPv4, 128 for IPv6
|
||||
*/
|
||||
private $numBits;
|
||||
|
||||
/**
|
||||
* The bit masks for every bit index.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
private $masks;
|
||||
|
||||
/**
|
||||
* The bit unmasks for every bit index.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
private $unmasks;
|
||||
|
||||
/**
|
||||
* Initializes the instance.
|
||||
*
|
||||
* @param int $numBits the number of bits used to represent addresses (32 for IPv4, 128 for IPv6)
|
||||
*/
|
||||
public function __construct($numBits)
|
||||
{
|
||||
$this->math = BinaryMath::getInstance();
|
||||
$this->setNumBits($numBits);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the subnets describing all (and only all) the addresses between two boundaries.
|
||||
*
|
||||
* @param \IPLib\Address\AddressInterface $from
|
||||
* @param \IPLib\Address\AddressInterface $to
|
||||
*
|
||||
* @return \IPLib\Range\Subnet[]|null return NULL if the two addresses have an invalid number of bits (that is, different from the one passed to the constructor of this class)
|
||||
*/
|
||||
public function getRanges(AddressInterface $from, AddressInterface $to)
|
||||
{
|
||||
if ($from->getNumberOfBits() !== $this->numBits || $to->getNumberOfBits() !== $this->numBits) {
|
||||
return null;
|
||||
}
|
||||
if ($from->getComparableString() > $to->getComparableString()) {
|
||||
list($from, $to) = array($to, $from);
|
||||
}
|
||||
$result = array();
|
||||
$this->calculate($this->math->reduce($from->getBits()), $this->math->reduce($to->getBits()), $this->numBits, $result);
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the number of bits used to represent addresses (32 for IPv4, 128 for IPv6).
|
||||
*
|
||||
* @param int $numBits
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function setNumBits($numBits)
|
||||
{
|
||||
$numBits = (int) $numBits;
|
||||
$masks = array();
|
||||
$unmasks = array();
|
||||
for ($bit = 0; $bit < $numBits; $bit++) {
|
||||
$masks[$bit] = str_repeat('1', $numBits - $bit) . str_repeat('0', $bit);
|
||||
$unmasks[$bit] = $bit === 0 ? '0' : str_repeat('1', $bit);
|
||||
}
|
||||
$this->numBits = $numBits;
|
||||
$this->masks = $masks;
|
||||
$this->unmasks = $unmasks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the subnets.
|
||||
*
|
||||
* @param string $start the start address (represented in reduced bit form)
|
||||
* @param string $end the end address (represented in reduced bit form)
|
||||
* @param int $position the number of bits in the mask we are comparing at this cycle
|
||||
* @param \IPLib\Range\Subnet[] $result found ranges will be added to this variable
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
private function calculate($start, $end, $position, array &$result)
|
||||
{
|
||||
if ($start === $end) {
|
||||
$result[] = $this->subnetFromBits($start, $this->numBits);
|
||||
|
||||
return;
|
||||
}
|
||||
$startMasked = '';
|
||||
for ($index = $position - 1; $index >= 0; $index--) {
|
||||
$startMasked = $this->math->andX($start, $this->masks[$index]);
|
||||
$endMasked = $this->math->andX($end, $this->masks[$index]);
|
||||
if ($startMasked !== $endMasked) {
|
||||
$position = $index;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ($startMasked === $start && $this->math->andX($this->math->increment($end), $this->unmasks[$position]) === '0') {
|
||||
$result[] = $this->subnetFromBits($start, $this->numBits - 1 - $position);
|
||||
|
||||
return;
|
||||
}
|
||||
$middleAddress = $this->math->orX($start, $this->unmasks[$position]);
|
||||
$this->calculate($start, $middleAddress, $position, $result);
|
||||
$this->calculate($this->math->increment($middleAddress), $end, $position, $result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an address instance starting from its bits.
|
||||
*
|
||||
* @param string $bits the bits of the address (represented in reduced bit form)
|
||||
*
|
||||
* @return \IPLib\Address\AddressInterface
|
||||
*/
|
||||
private function addressFromBits($bits)
|
||||
{
|
||||
$bits = str_pad($bits, $this->numBits, '0', STR_PAD_LEFT);
|
||||
$bytes = array();
|
||||
foreach (explode("\n", trim(chunk_split($bits, 8, "\n"))) as $byteBits) {
|
||||
$bytes[] = (int) bindec($byteBits);
|
||||
}
|
||||
$result = Factory::addressFromBytes($bytes);
|
||||
/** @var AddressInterface $result */
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an range instance starting from the bits if the address and the length of the network prefix.
|
||||
*
|
||||
* @param string $bits the bits of the address (represented in reduced bit form)
|
||||
* @param int $networkPrefix the length of the network prefix
|
||||
*
|
||||
* @return \IPLib\Range\Subnet
|
||||
*/
|
||||
private function subnetFromBits($bits, $networkPrefix)
|
||||
{
|
||||
$startAddress = $this->addressFromBits($bits);
|
||||
$numOnes = $this->numBits - $networkPrefix;
|
||||
if ($numOnes === 0) {
|
||||
return new Subnet($startAddress, $startAddress, $networkPrefix);
|
||||
}
|
||||
$endAddress = $this->addressFromBits(substr($bits, 0, -$numOnes) . str_repeat('1', $numOnes));
|
||||
|
||||
return new Subnet($startAddress, $endAddress, $networkPrefix);
|
||||
}
|
||||
}
|
||||
Vendored
Executable
+173
@@ -0,0 +1,173 @@
|
||||
<?php
|
||||
|
||||
namespace IPLib\Service;
|
||||
|
||||
/**
|
||||
* Helper class to work with unsigned integers.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class UnsignedIntegerMath
|
||||
{
|
||||
/**
|
||||
* Convert a string containing a decimal, octal or hexadecimal number into its bytes.
|
||||
*
|
||||
* @param string $value
|
||||
* @param int $numBytes the wanted number of bytes
|
||||
* @param bool $onlyDecimal Only parse decimal numbers
|
||||
*
|
||||
* @return int[]|null
|
||||
*/
|
||||
public function getBytes($value, $numBytes, $onlyDecimal = false)
|
||||
{
|
||||
$m = null;
|
||||
if ($onlyDecimal) {
|
||||
if (preg_match('/^0*(\d+)$/', $value, $m)) {
|
||||
return $this->getBytesFromDecimal($m[1], $numBytes);
|
||||
}
|
||||
} else {
|
||||
if (preg_match('/^0[Xx]0*([0-9A-Fa-f]+)$/', $value, $m)) {
|
||||
return $this->getBytesFromHexadecimal($m[1], $numBytes);
|
||||
}
|
||||
if (preg_match('/^0+([0-7]*)$/', $value, $m)) {
|
||||
return $this->getBytesFromOctal($m[1], $numBytes);
|
||||
}
|
||||
if (preg_match('/^[1-9][0-9]*$/', $value)) {
|
||||
return $this->getBytesFromDecimal($value, $numBytes);
|
||||
}
|
||||
}
|
||||
|
||||
// Not a valid number
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return int
|
||||
*/
|
||||
protected function getMaxSignedInt()
|
||||
{
|
||||
return PHP_INT_MAX;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $value never zero-length, never extra leading zeroes
|
||||
* @param int $numBytes
|
||||
*
|
||||
* @return int[]|null
|
||||
*/
|
||||
private function getBytesFromBits($value, $numBytes)
|
||||
{
|
||||
$valueLength = strlen($value);
|
||||
if ($valueLength > $numBytes << 3) {
|
||||
// overflow
|
||||
return null;
|
||||
}
|
||||
$remainderBits = $valueLength % 8;
|
||||
if ($remainderBits !== 0) {
|
||||
$value = str_pad($value, $valueLength + 8 - $remainderBits, '0', STR_PAD_LEFT);
|
||||
}
|
||||
$bytes = array_map('bindec', str_split($value, 8));
|
||||
/** @var int[] $bytes */
|
||||
|
||||
return array_pad($bytes, -$numBytes, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $value may be zero-length, never extra leading zeroes
|
||||
* @param int $numBytes
|
||||
*
|
||||
* @return int[]|null
|
||||
*/
|
||||
private function getBytesFromOctal($value, $numBytes)
|
||||
{
|
||||
if ($value === '') {
|
||||
return array_fill(0, $numBytes, 0);
|
||||
}
|
||||
$bits = implode(
|
||||
'',
|
||||
array_map(
|
||||
function ($octalDigit) {
|
||||
return str_pad(decbin((int) octdec($octalDigit)), 3, '0', STR_PAD_LEFT);
|
||||
},
|
||||
str_split($value, 1)
|
||||
)
|
||||
);
|
||||
$bits = ltrim($bits, '0');
|
||||
|
||||
return $bits === '' ? array_fill(0, $numBytes, 0) : self::getBytesFromBits($bits, $numBytes);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $value never zero-length, never extra leading zeroes
|
||||
* @param int $numBytes
|
||||
*
|
||||
* @return int[]|null
|
||||
*/
|
||||
private function getBytesFromDecimal($value, $numBytes)
|
||||
{
|
||||
$valueLength = strlen($value);
|
||||
$maxSignedIntLength = strlen((string) $this->getMaxSignedInt());
|
||||
if ($valueLength < $maxSignedIntLength) {
|
||||
return $this->getBytesFromBits(decbin((int) $value), $numBytes);
|
||||
}
|
||||
// Divide by two, so that we have 1 less bit
|
||||
$carry = 0;
|
||||
$halfValue = ltrim(
|
||||
implode(
|
||||
'',
|
||||
array_map(
|
||||
function ($digit) use (&$carry) {
|
||||
$number = $carry + (int) $digit;
|
||||
$carry = ($number % 2) * 10;
|
||||
|
||||
return (string) $number >> 1;
|
||||
},
|
||||
str_split($value, 1)
|
||||
)
|
||||
),
|
||||
'0'
|
||||
);
|
||||
$halfValueBytes = $this->getBytesFromDecimal($halfValue, $numBytes);
|
||||
if ($halfValueBytes === null) {
|
||||
return null;
|
||||
}
|
||||
$carry = $carry === 0 ? 0 : 1;
|
||||
$result = array_fill(0, $numBytes, 0);
|
||||
for ($index = $numBytes - 1; $index >= 0; $index--) {
|
||||
$byte = $carry + ($halfValueBytes[$index] << 1);
|
||||
if ($byte <= 0xFF) {
|
||||
$carry = 0;
|
||||
} else {
|
||||
$carry = ($byte & ~0xFF) >> 8;
|
||||
$byte -= 0x100;
|
||||
}
|
||||
$result[$index] = $byte;
|
||||
}
|
||||
if ($carry !== 0) {
|
||||
// Overflow
|
||||
return null;
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $value never zero-length, never extra leading zeroes
|
||||
* @param int $numBytes
|
||||
*
|
||||
* @return int[]|null
|
||||
*/
|
||||
private function getBytesFromHexadecimal($value, $numBytes)
|
||||
{
|
||||
$valueLength = strlen($value);
|
||||
if ($valueLength > $numBytes << 1) {
|
||||
// overflow
|
||||
return null;
|
||||
}
|
||||
$value = str_pad($value, $valueLength + $valueLength % 2, '0', STR_PAD_LEFT);
|
||||
$bytes = array_map('hexdec', str_split($value, 2));
|
||||
/** @var int[] $bytes */
|
||||
|
||||
return array_pad($bytes, -$numBytes, 0);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user